tools/gn/function_exec_script.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/command_line.h"
   6 #include "base/file_util.h"
   7 #include "base/logging.h"
   8 #include "base/process/kill.h"
   9 #include "base/process/launch.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/time/time.h"
  13 #include "build/build_config.h"
  14 #include "tools/gn/err.h"
  15 #include "tools/gn/filesystem_utils.h"
  16 #include "tools/gn/functions.h"
  17 #include "tools/gn/input_conversion.h"
  18 #include "tools/gn/input_file.h"
  19 #include "tools/gn/parse_tree.h"
  20 #include "tools/gn/scheduler.h"
  21 #include "tools/gn/trace.h"
  22 #include "tools/gn/value.h"
  23
  24 #if defined(OS_WIN)
  25 #include <windows.h>
  26
  27 #include "base/win/scoped_handle.h"
  28 #include "base/win/scoped_process_information.h"
  29 #endif
  30
  31 #if defined(OS_POSIX)
  32 #include <fcntl.h>
  33 #include <unistd.h>
  34
  35 #include "base/posix/file_descriptor_shuffle.h"
  36 #endif
  37
  38 namespace functions {
  39
  40 namespace {
  41
  42 const char kNoExecSwitch[] = "no-exec";
  43
  44 #if defined(OS_WIN)
  45 bool ExecProcess(const CommandLine& cmdline,
  46                  const base::FilePath& startup_dir,
  47                  std::string* std_out,
  48                  std::string* std_err,
  49                  int* exit_code) {
  50   SECURITY_ATTRIBUTES sa_attr;
  51   // Set the bInheritHandle flag so pipe handles are inherited.
  52   sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
  53   sa_attr.bInheritHandle = TRUE;
  54   sa_attr.lpSecurityDescriptor = NULL;
  55
  56   // Create the pipe for the child process's STDOUT.
  57   HANDLE out_read = NULL;
  58   HANDLE out_write = NULL;
  59   if (!CreatePipe(&out_read, &out_write, &sa_attr, 0)) {
  60     NOTREACHED() << "Failed to create pipe";
  61     return false;
  62   }
  63   base::win::ScopedHandle scoped_out_read(out_read);
  64   base::win::ScopedHandle scoped_out_write(out_write);
  65
  66   // Create the pipe for the child process's STDERR.
  67   HANDLE err_read = NULL;
  68   HANDLE err_write = NULL;
  69   if (!CreatePipe(&err_read, &err_write, &sa_attr, 0)) {
  70     NOTREACHED() << "Failed to create pipe";
  71     return false;
  72   }
  73   base::win::ScopedHandle scoped_err_read(err_read);
  74   base::win::ScopedHandle scoped_err_write(err_write);
  75
  76   // Ensure the read handle to the pipe for STDOUT/STDERR is not inherited.
  77   if (!SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)) {
  78     NOTREACHED() << "Failed to disabled pipe inheritance";
  79     return false;
  80   }
  81   if (!SetHandleInformation(err_read, HANDLE_FLAG_INHERIT, 0)) {
  82     NOTREACHED() << "Failed to disabled pipe inheritance";
  83     return false;
  84   }
  85
  86   base::FilePath::StringType cmdline_str(cmdline.GetCommandLineString());
  87
  88   STARTUPINFO start_info = {};
  89
  90   start_info.cb = sizeof(STARTUPINFO);
  91   start_info.hStdOutput = out_write;
  92   // Keep the normal stdin.
  93   start_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
  94   // FIXME(brettw) set stderr here when we actually read it below.
  95   //start_info.hStdError = err_write;
  96   start_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
  97   start_info.dwFlags |= STARTF_USESTDHANDLES;
  98
  99   // Create the child process.
 100   PROCESS_INFORMATION temp_process_info = {};
 101   if (!CreateProcess(NULL,
 102                      &cmdline_str[0],
 103                      NULL, NULL,
 104                      TRUE,  // Handles are inherited.
 105                      0, NULL,
 106                      startup_dir.value().c_str(),
 107                      &start_info, &temp_process_info)) {
 108     return false;
 109   }
 110   base::win::ScopedProcessInformation proc_info(temp_process_info);
 111
 112   // Close our writing end of pipes now. Otherwise later read would not be able
 113   // to detect end of child's output.
 114   scoped_out_write.Close();
 115   scoped_err_write.Close();
 116
 117   // Read output from the child process's pipe for STDOUT
 118   const int kBufferSize = 1024;
 119   char buffer[kBufferSize];
 120
 121   // FIXME(brettw) read from stderr here! This is complicated because we want
 122   // to read both of them at the same time, probably need overlapped I/O.
 123   // Also uncomment start_info code above.
 124   for (;;) {
 125     DWORD bytes_read = 0;
 126     BOOL success = ReadFile(out_read, buffer, kBufferSize, &bytes_read, NULL);
 127     if (!success || bytes_read == 0)
 128       break;
 129     std_out->append(buffer, bytes_read);
 130   }
 131
 132   // Let's wait for the process to finish.
 133   WaitForSingleObject(proc_info.process_handle(), INFINITE);
 134
 135   DWORD dw_exit_code;
 136   GetExitCodeProcess(proc_info.process_handle(), &dw_exit_code);
 137   *exit_code = static_cast<int>(dw_exit_code);
 138
 139   return true;
 140 }
 141 #else
 142 bool ExecProcess(const CommandLine& cmdline,
 143                  const base::FilePath& startup_dir,
 144                  std::string* std_out,
 145                  std::string* std_err,
 146                  int* exit_code) {
 147   *exit_code = EXIT_FAILURE;
 148
 149   std::vector<std::string> argv = cmdline.argv();
 150
 151   int pipe_fd[2];
 152   pid_t pid;
 153   base::InjectiveMultimap fd_shuffle1, fd_shuffle2;
 154   scoped_ptr<char*[]> argv_cstr(new char*[argv.size() + 1]);
 155
 156   fd_shuffle1.reserve(3);
 157   fd_shuffle2.reserve(3);
 158
 159   if (pipe(pipe_fd) < 0)
 160     return false;
 161
 162   switch (pid = fork()) {
 163     case -1:  // error
 164       close(pipe_fd[0]);
 165       close(pipe_fd[1]);
 166       return false;
 167     case 0:  // child
 168       {
 169         // DANGER: no calls to malloc are allowed from now on:
 170         // http://crbug.com/36678
 171
 172         // Obscure fork() rule: in the child, if you don't end up doing exec*(),
 173         // you call _exit() instead of exit(). This is because _exit() does not
 174         // call any previously-registered (in the parent) exit handlers, which
 175         // might do things like block waiting for threads that don't even exist
 176         // in the child.
 177         int dev_null = open("/dev/null", O_WRONLY);
 178         if (dev_null < 0)
 179           _exit(127);
 180
 181         fd_shuffle1.push_back(
 182             base::InjectionArc(pipe_fd[1], STDOUT_FILENO, true));
 183         fd_shuffle1.push_back(
 184             base::InjectionArc(dev_null, STDERR_FILENO, true));
 185         fd_shuffle1.push_back(
 186             base::InjectionArc(dev_null, STDIN_FILENO, true));
 187         // Adding another element here? Remeber to increase the argument to
 188         // reserve(), above.
 189
 190         for (size_t i = 0; i < fd_shuffle1.size(); ++i)
 191           fd_shuffle2.push_back(fd_shuffle1[i]);
 192
 193         if (!ShuffleFileDescriptors(&fd_shuffle1))
 194           _exit(127);
 195
 196         base::SetCurrentDirectory(startup_dir);
 197
 198         // TODO(brettw) the base version GetAppOutput does a
 199         // CloseSuperfluousFds call here. Do we need this?
 200
 201         for (size_t i = 0; i < argv.size(); i++)
 202           argv_cstr[i] = const_cast<char*>(argv[i].c_str());
 203         argv_cstr[argv.size()] = NULL;
 204         execvp(argv_cstr[0], argv_cstr.get());
 205         _exit(127);
 206       }
 207     default:  // parent
 208       {
 209         // Close our writing end of pipe now. Otherwise later read would not
 210         // be able to detect end of child's output (in theory we could still
 211         // write to the pipe).
 212         close(pipe_fd[1]);
 213
 214         char buffer[256];
 215         ssize_t bytes_read = 0;
 216
 217         while (true) {
 218           bytes_read = HANDLE_EINTR(read(pipe_fd[0], buffer, sizeof(buffer)));
 219           if (bytes_read <= 0)
 220             break;
 221           std_out->append(buffer, bytes_read);
 222         }
 223         close(pipe_fd[0]);
 224
 225         return base::WaitForExitCode(pid, exit_code);
 226       }
 227   }
 228
 229   return false;
 230 }
 231 #endif
 232
 233 }  // namespace
 234
 235 const char kExecScript[] = "exec_script";
 236 const char kExecScript_HelpShort[] =
 237     "exec_script: Synchronously run a script and return the output.";
 238 const char kExecScript_Help[] =
 239     "exec_script: Synchronously run a script and return the output.\n"
 240     "\n"
 241     "  exec_script(filename,\n"
 242     "              arguments = [],\n"
 243     "              input_conversion = \"\",\n"
 244     "              file_dependencies = [])\n"
 245     "\n"
 246     "  Runs the given script, returning the stdout of the script. The build\n"
 247     "  generation will fail if the script does not exist or returns a nonzero\n"
 248     "  exit code.\n"
 249     "\n"
 250     "  The current directory when executing the script will be the root\n"
 251     "  build directory. If you are passing file names, you will want to use\n"
 252     "  the rebase_path() function to make file names relative to this\n"
 253     "  path (see \"gn help rebase_path\").\n"
 254     "\n"
 255     "Arguments:\n"
 256     "\n"
 257     "  filename:\n"
 258     "      File name of python script to execute. Non-absolute names will\n"
 259     "      be treated as relative to the current build file.\n"
 260     "\n"
 261     "  arguments:\n"
 262     "      A list of strings to be passed to the script as arguments.\n"
 263     "      May be unspecified or the empty list which means no arguments.\n"
 264     "\n"
 265     "  input_conversion:\n"
 266     "      Controls how the file is read and parsed.\n"
 267     "      See \"gn help input_conversion\".\n"
 268     "\n"
 269     "      If unspecified, defaults to the empty string which causes the\n"
 270     "      script result to be discarded. exec script will return None.\n"
 271     "\n"
 272     "  dependencies:\n"
 273     "      (Optional) A list of files that this script reads or otherwise\n"
 274     "      depends on. These dependencies will be added to the build result\n"
 275     "      such that if any of them change, the build will be regenerated and\n"
 276     "      the script will be re-run.\n"
 277     "\n"
 278     "      The script itself will be an implicit dependency so you do not\n"
 279     "      need to list it.\n"
 280     "\n"
 281     "Example:\n"
 282     "\n"
 283     "  all_lines = exec_script(\n"
 284     "      \"myscript.py\", [some_input], \"list lines\",\n"
 285     "      [ rebase_path(\"data_file.txt\", root_build_dir) ])\n"
 286     "\n"
 287     "  # This example just calls the script with no arguments and discards\n"
 288     "  # the result.\n"
 289     "  exec_script(\"//foo/bar/myscript.py\")\n";
 290
 291 Value RunExecScript(Scope* scope,
 292                     const FunctionCallNode* function,
 293                     const std::vector<Value>& args,
 294                     Err* err) {
 295   if (args.size() < 1 || args.size() > 4) {
 296     *err = Err(function->function(), "Wrong number of arguments to exec_script",
 297                "I expected between one and four arguments.");
 298     return Value();
 299   }
 300
 301   const Settings* settings = scope->settings();
 302   const BuildSettings* build_settings = settings->build_settings();
 303   const SourceDir& cur_dir = scope->GetSourceDir();
 304
 305   // Find the python script to run.
 306   if (!args[0].VerifyTypeIs(Value::STRING, err))
 307     return Value();
 308   SourceFile script_source =
 309       cur_dir.ResolveRelativeFile(args[0].string_value());
 310   base::FilePath script_path = build_settings->GetFullPath(script_source);
 311   if (!build_settings->secondary_source_path().empty() &&
 312       !base::PathExists(script_path)) {
 313     // Fall back to secondary source root when the file doesn't exist.
 314     script_path = build_settings->GetFullPathSecondary(script_source);
 315   }
 316
 317   ScopedTrace trace(TraceItem::TRACE_SCRIPT_EXECUTE, script_source.value());
 318   trace.SetToolchain(settings->toolchain_label());
 319
 320   // Add all dependencies of this script, including the script itself, to the
 321   // build deps.
 322   g_scheduler->AddGenDependency(script_path);
 323   if (args.size() == 4) {
 324     const Value& deps_value = args[3];
 325     if (!deps_value.VerifyTypeIs(Value::LIST, err))
 326       return Value();
 327
 328     for (size_t i = 0; i < deps_value.list_value().size(); i++) {
 329       if (!deps_value.list_value()[0].VerifyTypeIs(Value::STRING, err))
 330         return Value();
 331       g_scheduler->AddGenDependency(
 332           build_settings->GetFullPath(cur_dir.ResolveRelativeFile(
 333               deps_value.list_value()[0].string_value())));
 334     }
 335   }
 336
 337   // Make the command line.
 338   const base::FilePath& python_path = build_settings->python_path();
 339   CommandLine cmdline(python_path);
 340   cmdline.AppendArgPath(script_path);
 341
 342   if (args.size() >= 2) {
 343     // Optional command-line arguments to the script.
 344     const Value& script_args = args[1];
 345     if (!script_args.VerifyTypeIs(Value::LIST, err))
 346       return Value();
 347     for (size_t i = 0; i < script_args.list_value().size(); i++) {
 348       if (!script_args.list_value()[i].VerifyTypeIs(Value::STRING, err))
 349         return Value();
 350       cmdline.AppendArg(script_args.list_value()[i].string_value());
 351     }
 352   }
 353
 354   // Log command line for debugging help.
 355   trace.SetCommandLine(cmdline);
 356   base::TimeTicks begin_exec;
 357   if (g_scheduler->verbose_logging()) {
 358 #if defined(OS_WIN)
 359     g_scheduler->Log("Pythoning",
 360                      base::UTF16ToUTF8(cmdline.GetCommandLineString()));
 361 #else
 362     g_scheduler->Log("Pythoning", cmdline.GetCommandLineString());
 363 #endif
 364     begin_exec = base::TimeTicks::Now();
 365   }
 366
 367   base::FilePath startup_dir =
 368       build_settings->GetFullPath(build_settings->build_dir());
 369   // The first time a build is run, no targets will have been written so the
 370   // build output directory won't exist. We need to make sure it does before
 371   // running any scripts with this as its startup directory, although it will
 372   // be relatively rare that the directory won't exist by the time we get here.
 373   //
 374   // If this shows up on benchmarks, we can cache whether we've done this
 375   // or not and skip creating the directory.
 376   base::CreateDirectory(startup_dir);
 377
 378   // Execute the process.
 379   // TODO(brettw) set the environment block.
 380   std::string output;
 381   std::string stderr_output;  // TODO(brettw) not hooked up, see above.
 382   int exit_code = 0;
 383   if (!CommandLine::ForCurrentProcess()->HasSwitch(kNoExecSwitch)) {
 384     if (!ExecProcess(cmdline, startup_dir,
 385                      &output, &stderr_output, &exit_code)) {
 386       *err = Err(function->function(), "Could not execute python.",
 387           "I was trying to execute \"" + FilePathToUTF8(python_path) + "\".");
 388       return Value();
 389     }
 390   }
 391   if (g_scheduler->verbose_logging()) {
 392     g_scheduler->Log("Pythoning", script_source.value() + " took " +
 393         base::Int64ToString(
 394             (base::TimeTicks::Now() - begin_exec).InMilliseconds()) +
 395         "ms");
 396   }
 397
 398   // TODO(brettw) maybe we need stderr also for reasonable stack dumps.
 399   if (exit_code != 0) {
 400     std::string msg = "Current dir: " + FilePathToUTF8(startup_dir) +
 401         "\nCommand: " + FilePathToUTF8(cmdline.GetCommandLineString()) +
 402         "\nReturned " + base::IntToString(exit_code);
 403     if (!output.empty())
 404       msg += " and printed out:\n\n" + output;
 405     else
 406       msg += ".";
 407     *err = Err(function->function(), "Script returned non-zero exit code.",
 408                msg);
 409     return Value();
 410   }
 411
 412   // Default to None value for the input conversion if unspecified.
 413   return ConvertInputToValue(scope->settings(), output, function,
 414                              args.size() >= 3 ? args[2] : Value(), err);
 415 }
 416
 417 }  // namespace functions