Add workdir feature to release scripts.

tools/push-to-trunk/common_includes.py

 #!/usr/bin/env python
 # Copyright 2013 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
@@ skipping 30 matching lines @@
 import time
 import urllib
 import urllib2
 
 from git_recipes import GitRecipesMixin
 from git_recipes import GitFailedException
 
 VERSION_FILE = os.path.join("src", "version.cc")
 
 # V8 base directory.
-DEFAULT_CWD = os.path.dirname(
+V8_BASE = os.path.dirname(
     os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 
 def TextToFile(text, file_name):
   with open(file_name, "w") as f:
     f.write(text)
 
 
 def AppendToFile(text, file_name):
   with open(file_name, "a") as f:
@@ skipping 401 matching lines @@
     self._text = text
     self._number = number
     self._config = config
     self._state = state
     self._options = options
     self._side_effect_handler = handler
     self.vc = VC_INTERFACES[options.vc_interface]()
     self.vc.InjectStep(self)
 
     # The testing configuration might set a different default cwd.
-    self.default_cwd = self._config.get("DEFAULT_CWD") or DEFAULT_CWD
+    self.default_cwd = (self._config.get("DEFAULT_CWD") or
+                        os.path.join(self._options.work_dir, "v8"))
 
     assert self._number >= 0
     assert self._config is not None
     assert self._state is not None
     assert self._side_effect_handler is not None
 
   def __getitem__(self, key):
     # Convenience method to allow direct [] access on step classes for
     # manipulating the backed state dict.
     return self._state[key]
@@ skipping 116 matching lines @@
     for line in self.GitBranch().splitlines():
       if re.match(r"\*?\s*%s$" % re.escape(name), line):
         msg = "Branch %s exists, do you want to delete it?" % name
         if self.Confirm(msg):
           self.GitDeleteBranch(name)
           print "Branch %s deleted." % name
         else:
           msg = "Can't continue. Please delete branch %s and try again." % name
           self.Die(msg)
 
+  def BootstrapV8Checkout(self):

[Michael Achenbach, 2014/11/03 08:44:54]

Doh - this method isn't even called :/ Repairing in follow up...

+    if os.path.realpath(self.default_cwd) == os.path.realpath(V8_BASE):
+      self.Die("Can't use v8 checkout with calling script as work checkout.")
+    # Directory containing the working v8 checkout.
+    work_dir = os.path.dirname(self.default_cwd)
+    assert os.path.join(work_dir, "v8") == self.default_cwd
+
+    if not os.path.exits(work_dir):

[Michael Achenbach, 2014/11/03 09:02:02]

exits??? sleepy...

+      os.makedirs(work_dir)
+    if not os.path.exits(self.default_cwd):
+      self.Command("fetch", "v8")
+
   def InitialEnvironmentChecks(self, cwd):
     # Cancel if this is not a git checkout.
     if not os.path.exists(os.path.join(cwd, ".git")):  # pragma: no cover
       self.Die("This is not a git checkout, this script won't work for you.")
 
     # Cancel if EDITOR is unset or not executable.
     if (self._options.requires_editor and (not os.environ.get("EDITOR") or
         self.Command(
             "which", os.environ["EDITOR"]) is None)):  # pragma: no cover
       self.Die("Please set your EDITOR environment variable, you'll need it.")
@@ skipping 232 matching lines @@
                         help=("Optional full svn checkout for the commit."
                               "The folder needs to be the svn root."))
     parser.add_argument("--svn-config",
                         help=("Optional folder used as svn --config-dir."))
     parser.add_argument("-s", "--step",
         help="Specify the step where to start work. Default: 0.",
         default=0, type=int)
     parser.add_argument("--vc-interface",
                         help=("Choose VC interface out of git_svn|"
                               "git_read_svn_write."))
+    parser.add_argument("--work-dir",
+                        help=("Location where to bootstrap a working v8 "
+                              "checkout."))
     self._PrepareOptions(parser)
 
     if args is None:  # pragma: no cover
       options = parser.parse_args()
     else:
       options = parser.parse_args(args)
 
     # Process common options.
     if options.step < 0:  # pragma: no cover
       print "Bad step number %d" % options.step
@@ skipping 19 matching lines @@
     options.force_readline_defaults = not options.manual
     options.force_upload = not options.manual
 
     # Process script specific options.
     if not self._ProcessOptions(options):
       parser.print_help()
       return None
 
     if not options.vc_interface:
       options.vc_interface = "git_read_svn_write"
+    if not options.work_dir:
+      options.work_dir = "/tmp/v8-release-scripts-work-dir"
     return options
 
   def RunSteps(self, step_classes, args=None):
     options = self.MakeOptions(args)
     if not options:
       return 1
 
     state_file = "%s-state.json" % self._config["PERSISTFILE_BASENAME"]
     if options.step == 0 and os.path.exists(state_file):
       os.remove(state_file)
 
     steps = []
     for (number, step_class) in enumerate(step_classes):
       steps.append(MakeStep(step_class, number, self._state, self._config,
                             options, self._side_effect_handler))
     for step in steps[options.step:]:
       if step.Run():
         return 0
     return 0
 
   def Run(self, args=None):
     return self.RunSteps(self._Steps(), args)