Revert "Remove all safesync_url functionality from gclient"

gclient.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Meta checkout manager supporting both Subversion and GIT."""
 # Files
 #   .gclient      : Current client configuration, written by 'config' command.
 #                   Format is a Python script defining 'solutions', a list whose
 #                   entries each are maps binding the strings "name" and "url"
@@ skipping 195 matching lines @@
       if var_name in self._custom_vars:
         return self._custom_vars[var_name]
       elif var_name in self._local_scope.get("vars", {}):
         return self._local_scope["vars"][var_name]
       raise gclient_utils.Error("Var is not defined: %s" % var_name)
 
 
 class DependencySettings(GClientKeywords):
   """Immutable configuration settings."""
   def __init__(
-      self, parent, url, managed, custom_deps, custom_vars,
+      self, parent, url, safesync_url, managed, custom_deps, custom_vars,
       custom_hooks, deps_file, should_process):
     GClientKeywords.__init__(self)
 
     # These are not mutable:
     self._parent = parent
+    self._safesync_url = safesync_url
     self._deps_file = deps_file
     self._url = url
     # 'managed' determines whether or not this dependency is synced/updated by
     # gclient after gclient checks it out initially.  The difference between
     # 'managed' and 'should_process' is that the user specifies 'managed' via
-    # the --managed command-line flag or a .gclient config, where
+    # the --unmanaged command-line flag or a .gclient config, where
     # 'should_process' is dynamically set by gclient if it goes over its
     # recursion limit and controls gclient's behavior so it does not misbehave.
     self._managed = managed
     self._should_process = should_process
     # This is a mutable value which has the list of 'target_os' OSes listed in
     # the current deps file.
     self.local_target_os = None
 
     # These are only set in .gclient and not in DEPS files.
     self._custom_vars = custom_vars or {}
@@ skipping 36 matching lines @@
 
   @property
   def root(self):
     """Returns the root node, a GClient object."""
     if not self.parent:
       # This line is to signal pylint that it could be a GClient instance.
       return self or GClient(None, None)
     return self.parent.root
 
   @property
+  def safesync_url(self):
+    return self._safesync_url
+
+  @property
   def should_process(self):
     """True if this dependency should be processed, i.e. checked out."""
     return self._should_process
 
   @property
   def custom_vars(self):
     return self._custom_vars.copy()
 
   @property
   def custom_deps(self):
@@ skipping 18 matching lines @@
     """Returns a custom deps if applicable."""
     if self.parent:
       url = self.parent.get_custom_deps(name, url)
     # None is a valid return value to disable a dependency.
     return self.custom_deps.get(name, url)
 
 
 class Dependency(gclient_utils.WorkItem, DependencySettings):
   """Object that represents a dependency checkout."""
 
-  def __init__(self, parent, name, url, managed, custom_deps,
+  def __init__(self, parent, name, url, safesync_url, managed, custom_deps,
                custom_vars, custom_hooks, deps_file, should_process):
     gclient_utils.WorkItem.__init__(self, name)
     DependencySettings.__init__(
-        self, parent, url, managed, custom_deps, custom_vars,
+        self, parent, url, safesync_url, managed, custom_deps, custom_vars,
         custom_hooks, deps_file, should_process)
 
     # This is in both .gclient and DEPS files:
     self._deps_hooks = []
 
     self._pre_deps_hooks = []
 
     # Calculates properties:
     self._parsed_url = None
     self._dependencies = []
@@ skipping 378 matching lines @@
     # Convert the deps into real Dependency.
     deps_to_add = []
     for name, url in deps.iteritems():
       should_process = self.recursion_limit and self.should_process
       deps_file = self.deps_file
       if self.recursedeps is not None:
         ent = self.recursedeps.get(name)
         if ent is not None:
           deps_file = ent['deps_file']
       deps_to_add.append(Dependency(
-          self, name, url, None, None, self.custom_vars, None,
+          self, name, url, None, None, None, self.custom_vars, None,
           deps_file, should_process))
     deps_to_add.sort(key=lambda x: x.name)
 
     # override named sets of hooks by the custom hooks
     hooks_to_run = []
     hook_names_to_suppress = [c.get('name', '') for c in self.custom_hooks]
     for hook in local_scope.get('hooks', []):
       if hook.get('name', '') not in hook_names_to_suppress:
         hooks_to_run.append(hook)
 
@@ skipping 386 matching lines @@
 
   @property
   def file_list_and_children(self):
     result = list(self.file_list)
     for d in self.dependencies:
       result.extend(d.file_list_and_children)
     return tuple(result)
 
   def __str__(self):
     out = []
-    for i in ('name', 'url', 'parsed_url', 'custom_deps',
+    for i in ('name', 'url', 'parsed_url', 'safesync_url', 'custom_deps',
               'custom_vars', 'deps_hooks', 'file_list', 'should_process',
               'processed', 'hooks_ran', 'deps_parsed', 'requirements',
               'allowed_hosts'):
       # First try the native property if it exists.
       if hasattr(self, '_' + i):
         value = getattr(self, '_' + i, False)
       else:
         value = getattr(self, i, False)
       if value:
         out.append('%s: %s' % (i, value))
@@ skipping 28 matching lines @@
     "mac": "mac",
     "unix": "unix",
     "linux": "unix",
     "linux2": "unix",
     "linux3": "unix",
     "android": "android",
   }
 
   DEFAULT_CLIENT_FILE_TEXT = ("""\
 solutions = [
-  {
-    "name"        : "%(solution_name)s",
+  { "name"        : "%(solution_name)s",
     "url"         : "%(solution_url)s",
     "deps_file"   : "%(deps_file)s",
     "managed"     : %(managed)s,
-    "custom_deps" : {},
+    "custom_deps" : {
+    },
+    "safesync_url": "%(safesync_url)s",
   },
 ]
 cache_dir = %(cache_dir)r
 """)
 
   DEFAULT_SNAPSHOT_SOLUTION_TEXT = ("""\
-  {
-    "name"        : "%(solution_name)s",
+  { "name"        : "%(solution_name)s",
     "url"         : "%(solution_url)s",
     "deps_file"   : "%(deps_file)s",
     "managed"     : %(managed)s,
     "custom_deps" : {
-%(solution_deps)s
-    },
+%(solution_deps)s    },
+    "safesync_url": "%(safesync_url)s",
   },
 """)
 
   DEFAULT_SNAPSHOT_FILE_TEXT = ("""\
 # Snapshot generated with gclient revinfo --snapshot
 solutions = [
 %(solution_list)s]
 """)
 
   def __init__(self, root_dir, options):
     # Do not change previous behavior. Only solution level and immediate DEPS
     # are processed.
     self._recursion_limit = 2
-    Dependency.__init__(self, None, None, None, True, None, None, None,
+    Dependency.__init__(self, None, None, None, None, True, None, None, None,
                         'unused', True)
     self._options = options
     if options.deps_os:
       enforced_os = options.deps_os.split(',')
     else:
       enforced_os = [self.DEPS_OS_CHOICES.get(sys.platform, 'unix')]
     if 'all' in enforced_os:
       enforced_os = self.DEPS_OS_CHOICES.itervalues()
     self._enforced_os = tuple(set(enforced_os))
     self._root_dir = root_dir
@@ skipping 20 matching lines @@
 
 The .gclient file contains:
 URL: %(expected_url)s (%(expected_scm)s)
 Cache mirror: %(mirror_string)s
 
 The local checkout in %(checkout_path)s reports:
 %(actual_url)s (%(actual_scm)s)
 
 You should ensure that the URL listed in .gclient is correct and either change
 it or fix the checkout. If you're managing your own git checkout in
-%(checkout_path)s but the URL in .gclient is for an svn repository, you should
-set 'managed': False in .gclient.
+%(checkout_path)s but the URL in .gclient is for an svn repository, you probably
+want to set 'managed': False in .gclient.
 '''  % {'checkout_path': os.path.join(self.root_dir, dep.name),
         'expected_url': dep.url,
         'expected_scm': gclient_scm.GetScmName(dep.url),
         'mirror_string' : mirror_string,
         'actual_url': actual_url,
         'actual_scm': gclient_scm.GetScmName(actual_url)})
 
   def SetConfig(self, content):
     assert not self.dependencies
     config_dict = {}
@@ skipping 20 matching lines @@
                                 cache_dir, '--force', '--all'])
     gclient_scm.GitWrapper.cache_dir = cache_dir
     git_cache.Mirror.SetCachePath(cache_dir)
 
     if not target_os and config_dict.get('target_os_only', False):
       raise gclient_utils.Error('Can\'t use target_os_only if target_os is '
                                 'not specified')
 
     deps_to_add = []
     for s in config_dict.get('solutions', []):
-      if s.get('safesync_url'):
-        raise gclient_utils.Error('safesync_url is not supported anymore. '
-                                  'Please remove it from your .gclient file.')
       try:
         deps_to_add.append(Dependency(
             self, s['name'], s['url'],
-            s.get('managed', False),
+            s.get('safesync_url', None),
+            s.get('managed', True),
             s.get('custom_deps', {}),
             s.get('custom_vars', {}),
             s.get('custom_hooks', []),
             s.get('deps_file', 'DEPS'),
             True))
       except KeyError:
         raise gclient_utils.Error('Invalid .gclient file. Solution is '
                                   'incomplete: %s' % s)
     self.add_dependencies_and_close(deps_to_add, config_dict.get('hooks', []))
     logging.info('SetConfig() done')
@@ skipping 105 matching lines @@
           ('You must specify the full solution name like --revision %s@%s\n'
            'when you have multiple solutions setup in your .gclient file.\n'
            'Other solutions present are: %s.') % (
               client.dependencies[0].name,
               options.revisions[0],
               ', '.join(s.name for s in client.dependencies[1:])),
           file=sys.stderr)
     return client
 
   def SetDefaultConfig(self, solution_name, deps_file, solution_url,
-                       managed=False, cache_dir=None):
+                       safesync_url, managed=True, cache_dir=None):
     self.SetConfig(self.DEFAULT_CLIENT_FILE_TEXT % {
       'solution_name': solution_name,
       'solution_url': solution_url,
       'deps_file': deps_file,
+      'safesync_url' : safesync_url,
       'managed': managed,
       'cache_dir': cache_dir,
     })
 
   def _SaveEntries(self):
     """Creates a .gclient_entries file to record the list of unique checkouts.
 
     The .gclient_entries file lives in the same directory as .gclient.
     """
     # Sometimes pprint.pformat will use {', sometimes it'll use { ' ... It
@@ skipping 22 matching lines @@
       return {}
     try:
       exec(gclient_utils.FileRead(filename), scope)
     except SyntaxError as e:
       gclient_utils.SyntaxErrorToError(filename, e)
     return scope['entries']
 
   def _EnforceRevisions(self):
     """Checks for revision overrides."""
     revision_overrides = {}
+    if self._options.head:
+      return revision_overrides
+    # Do not check safesync_url if one or more --revision flag is specified.
     if not self._options.revisions:
       for s in self.dependencies:
-        if not s.managed and not self._options.__dict__.get('head', False):
+        if not s.managed:
           self._options.revisions.append('%s@unmanaged' % s.name)
+        elif s.safesync_url:
+          self._ApplySafeSyncRev(dep=s)
     if not self._options.revisions:
       return revision_overrides
     solutions_names = [s.name for s in self.dependencies]
-    for i, revision in enumerate(self._options.revisions):
-      if '@' in revision:
-        name, rev = revision.split('@', 1)
-      else:
+    index = 0
+    for revision in self._options.revisions:
+      if not '@' in revision:
         # Support for --revision 123
-        name, rev = solutions_names[i], revision
+        revision = '%s@%s' % (solutions_names[index], revision)
+      name, rev = revision.split('@', 1)
       revision_overrides[name] = rev
+      index += 1
     return revision_overrides
 
+  def _ApplySafeSyncRev(self, dep):
+    """Finds a valid revision from the content of the safesync_url and apply it
+    by appending revisions to the revision list. Throws if revision appears to
+    be invalid for the given |dep|."""
+    assert len(dep.safesync_url) > 0
+    handle = urllib.urlopen(dep.safesync_url)
+    rev = handle.read().strip()
+    handle.close()
+    if not rev:
+      raise gclient_utils.Error(
+          'It appears your safesync_url (%s) is not working properly\n'
+          '(as it returned an empty response). Check your config.' %
+          dep.safesync_url)
+    scm = gclient_scm.CreateSCM(
+        dep.url, dep.root.root_dir, dep.name, self.outbuf)
+    safe_rev = scm.GetUsableRev(rev, self._options)
+    if self._options.verbose:
+      print('Using safesync_url revision: %s.\n' % safe_rev)
+    self._options.revisions.append('%s@%s' % (dep.name, safe_rev))
+
   def RunOnDeps(self, command, args, ignore_requirements=False, progress=True):
     """Runs a command on each dependency in a client and its dependencies.
 
     Args:
       command: The command to use (e.g., 'status' or 'diff')
       args: list of str - extra arguments to add to the command line.
     """
     if not self.dependencies:
       raise gclient_utils.Error('No solution specified')
 
@@ skipping 164 matching lines @@
         for k in sorted(entries.keys()):
           if entries[k]:
             # Quotes aren't escaped...
             custom_deps.append('      \"%s\": \'%s\',\n' % (k, entries[k]))
           else:
             custom_deps.append('      \"%s\": None,\n' % k)
         new_gclient += self.DEFAULT_SNAPSHOT_SOLUTION_TEXT % {
             'solution_name': d.name,
             'solution_url': d.url,
             'deps_file': d.deps_file,
+            'safesync_url' : d.safesync_url or '',
             'managed': d.managed,
             'solution_deps': ''.join(custom_deps),
         }
       # Print the snapshot configuration file
       print(self.DEFAULT_SNAPSHOT_FILE_TEXT % {'solution_list': new_gclient})
     else:
       entries = {}
       for d in self.root.subtree(False):
         if self._options.actual:
           entries[d.name] = GetURLAndRev(d)
@@ skipping 145 matching lines @@
 def CMDroot(parser, args):
   """Outputs the solution root (or current dir if there isn't one)."""
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if client:
     print(os.path.abspath(client.root_dir))
   else:
     print(os.path.abspath('.'))
 
 
-@subcommand.usage('[url]')
+@subcommand.usage('[url] [safesync url]')
 def CMDconfig(parser, args):
   """Creates a .gclient file in the current directory.
 
   This specifies the configuration for further commands. After update/sync,
   top-level DEPS files in each module are read to determine dependent
   modules to operate on as well. If optional [url] parameter is
   provided, then configuration is read from a specified Subversion server
   URL.
   """
   # We do a little dance with the --gclientfile option.  'gclient config' is the
   # only command where it's acceptable to have both '--gclientfile' and '--spec'
   # arguments.  So, we temporarily stash any --gclientfile parameter into
   # options.output_config_file until after the (gclientfile xor spec) error
   # check.
   parser.remove_option('--gclientfile')
   parser.add_option('--gclientfile', dest='output_config_file',
                     help='Specify an alternate .gclient file')
   parser.add_option('--name',
                     help='overrides the default name for the solution')
   parser.add_option('--deps-file', default='DEPS',
                     help='overrides the default name for the DEPS file for the'
                          'main solutions and all sub-dependencies')
-  parser.add_option('--managed', action='store_true', default=False,
+  parser.add_option('--unmanaged', action='store_true', default=False,
                     help='overrides the default behavior to make it possible '
-                         'to have the main solution managed by gclient '
-                         '(gclient will always auto-sync managed solutions '
-                         ' rather than leaving them untouched)')
-  parser.add_option('--unmanaged', action='store_true', default=True,
-                    help='This flag is a no-op; unmanaged is now the default.')
+                         'to have the main solution untouched by gclient '
+                         '(gclient will check out unmanaged dependencies but '
+                         'will never sync them)')
   parser.add_option('--cache-dir',
                     help='(git only) Cache all git repos into this dir and do '
                          'shared clones from the cache, instead of cloning '
                          'directly from the remote. (experimental)')
   parser.set_defaults(config_filename=None)
   (options, args) = parser.parse_args(args)
   if options.output_config_file:
     setattr(options, 'config_filename', getattr(options, 'output_config_file'))
   if ((options.spec and args) or len(args) > 2 or
       (not options.spec and not args)):
@@ skipping 11 matching lines @@
     else:
       # specify an alternate relpath for the given URL.
       name = options.name
       if not os.path.abspath(os.path.join(os.getcwd(), name)).startswith(
           os.getcwd()):
         parser.error('Do not pass a relative path for --name.')
       if any(x in ('..', '.', '/', '\\') for x in name.split(os.sep)):
         parser.error('Do not include relative path components in --name.')
 
     deps_file = options.deps_file
-    client.SetDefaultConfig(name, deps_file, base_url,
-                            managed=options.managed,
+    safesync_url = ''
+    if len(args) > 1:
+      safesync_url = args[1]
+    client.SetDefaultConfig(name, deps_file, base_url, safesync_url,
+                            managed=not options.unmanaged,
                             cache_dir=options.cache_dir)
   client.SaveConfig()
   return 0
 
 
 @subcommand.epilog("""Example:
   gclient pack > patch.txt
     generate simple patch for configured client and dependences
 """)
 def CMDpack(parser, args):
@@ skipping 67 matching lines @@
   parser.add_option('-n', '--nohooks', action='store_true',
                     help='don\'t run hooks after the update is complete')
   parser.add_option('-p', '--noprehooks', action='store_true',
                     help='don\'t run pre-DEPS hooks', default=False)
   parser.add_option('-r', '--revision', action='append',
                     dest='revisions', metavar='REV', default=[],
                     help='Enforces revision/hash for the solutions with the '
                          'format src@rev. The src@ part is optional and can be '
                          'skipped. -r can be used multiple times when .gclient '
                          'has multiple solutions configured and will work even '
-                         'if the src@ part is skipped.')
+                         'if the src@ part is skipped. Note that specifying '
+                         '--revision means your safesync_url gets ignored.')
   parser.add_option('--with_branch_heads', action='store_true',
                     help='Clone git "branch_heads" refspecs in addition to '
                          'the default refspecs. This adds about 1/2GB to a '
                          'full checkout. (git only)')
   parser.add_option('--with_tags', action='store_true',
                     help='Clone git tags in addition to the default refspecs.')
   parser.add_option('-t', '--transitive', action='store_true',
                     help='When a revision is specified (in the DEPS file or '
                           'with the command-line flag), transitively update '
                           'the dependencies to the date of the given revision. '
                           'Only supported for SVN repositories.')
   parser.add_option('-H', '--head', action='store_true',
-                    help='Begin by automatically syncing the root gclient '
-                         'solutions to HEAD of the remote repository. Similar '
-                         'to making the solution temporarily "managed".')
+                    help='skips any safesync_urls specified in '
+                         'configured solutions and sync to head instead')
   parser.add_option('-D', '--delete_unversioned_trees', action='store_true',
                     help='Deletes from the working copy any dependencies that '
                          'have been removed since the last sync, as long as '
                          'there are no local modifications. When used with '
                          '--force, such dependencies are removed even if they '
                          'have local modifications. When used with --reset, '
                          'all untracked directories are removed from the '
                          'working copy, excluding those which are explicitly '
                          'ignored in the repository.')
   parser.add_option('-R', '--reset', action='store_true',
@@ skipping 34 matching lines @@
                       'thing operating on the git repos (e.g. on a bot).')
   parser.add_option('--lock_timeout', type='int', default=5000,
                     help='GIT ONLY - Deadline (in seconds) to wait for git '
                          'cache lock to become available. Default is %default.')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
 
   if not client:
     raise gclient_utils.Error('client not configured; see \'gclient config\'')
 
+  if options.revisions and options.head:
+    # TODO(maruel): Make it a parser.error if it doesn't break any builder.
+    print('Warning: you cannot use both --head and --revision')
+
   if options.verbose:
     client.PrintLocationAndContents()
   ret = client.RunOnDeps('update', args)
   if options.output_json:
     slns = {}
     for d in client.subtree(True):
       normed = d.name.replace('\\', '/').rstrip('/') + '/'
       slns[normed] = {
           'revision': d.got_revision,
           'scm': d.used_scm.name if d.used_scm else None,
@@ skipping 186 matching lines @@
     if not options.config_filename:
       options.config_filename = self.gclientfile_default
     options.entries_filename = options.config_filename + '_entries'
     if options.jobs < 1:
       self.error('--jobs must be 1 or higher')
 
     # These hacks need to die.
     if not hasattr(options, 'revisions'):
       # GClient.RunOnDeps expects it even if not applicable.
       options.revisions = []
+    if not hasattr(options, 'head'):
+      options.head = None
     if not hasattr(options, 'nohooks'):
       options.nohooks = True
     if not hasattr(options, 'noprehooks'):
       options.noprehooks = True
     if not hasattr(options, 'deps_os'):
       options.deps_os = None
     if not hasattr(options, 'manually_grab_svn_rev'):
       options.manually_grab_svn_rev = None
     if not hasattr(options, 'force'):
       options.force = None
@@ skipping 40 matching lines @@
 
 
 if '__main__' == __name__:
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)
 
 # vim: ts=2:sw=2:tw=80:et: