Add a --unmanaged flag to gclient config to allow the main solution to be unmanaged by the scm.

gclient.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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
@@ skipping 121 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 Dependency(GClientKeywords, gclient_utils.WorkItem):
   """Object that represents a dependency checkout."""
 
-  def __init__(self, parent, name, url, safesync_url, custom_deps,
+  def __init__(self, parent, name, url, safesync_url, managed, custom_deps,
                custom_vars, deps_file, should_process):
     # Warning: this function can be called from any thread. Both
     # self.dependencies and self.requirements are read and modified from
     # multiple threads at the same time. Sad.
     GClientKeywords.__init__(self)
     gclient_utils.WorkItem.__init__(self, name)
 
     # These are not mutable:
     self._parent = parent
     self._safesync_url = safesync_url
     self._deps_file = deps_file
     self._should_process = should_process
 
     # This is in both .gclient and DEPS files:
     self.url = url
 
     # These are only set in .gclient and not in DEPS files.
+    # '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' (defined below) is that the user specifies
+    # 'managed' via 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.custom_vars = custom_vars or {}
     self.custom_deps = custom_deps or {}
     self.deps_hooks = []
 
     # Calculates properties:
     self.parsed_url = None
     self.dependencies = []
     # A cache of the files affected by the current operation, necessary for
     # hooks.
     self._file_list = []
@@ skipping 225 matching lines @@
             logging.info('Won\'t process duplicate dependency %s' % tree[name])
             # In theory we could keep it as a shadow of the other one. In
             # practice, simply ignore it.
             #should_process = False
             continue
           else:
             raise gclient_utils.Error(
                 'Dependency %s specified more than once:\n  %s\nvs\n  %s' %
                 (name, tree[name].hierarchy(), self.hierarchy()))
       self.dependencies.append(Dependency(self, name, url, None, None, None,
-          self.deps_file, should_process))
+          None, self.deps_file, should_process))
     logging.debug('Loaded: %s' % str(self))
 
   # Arguments number differs from overridden method
   # pylint: disable=W0221
   def run(self, revision_overrides, command, args, work_queue, options):
     """Runs 'command' before parsing the DEPS in case it's a initial checkout
     or a revert."""
 
     def maybeGetParentRevision(options):
       """If we are performing an update and --transitive is set, set the
@@ skipping 239 matching lines @@
     "linux": "unix",
     "linux2": "unix",
     "linux3": "unix",
   }
 
   DEFAULT_CLIENT_FILE_TEXT = ("""\
 solutions = [
   { "name"        : "%(solution_name)s",
     "url"         : "%(solution_url)s",
     "deps_file"   : "%(deps_file)s",
+    "managed"     : %(managed)s,
     "custom_deps" : {
     },
     "safesync_url": "%(safesync_url)s",
   },
 ]
 """)
 
   DEFAULT_SNAPSHOT_SOLUTION_TEXT = ("""\
   { "name"        : "%(solution_name)s",
     "url"         : "%(solution_url)s",
     "deps_file"   : "%(deps_file)s",
+    "managed"     : %(managed)s,
     "custom_deps" : {
 %(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, None, None, None, 'unused',
-                        True)
+    Dependency.__init__(self, None, None, None, None, True, 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
     self.config_content = None
 
   def SetConfig(self, content):
     assert self.dependencies == []
     config_dict = {}
     self.config_content = content
     try:
       exec(content, config_dict)
     except SyntaxError, e:
       gclient_utils.SyntaxErrorToError('.gclient', e)
     for s in config_dict.get('solutions', []):
       try:
         tree = dict((d.name, d) for d in self.root.subtree(False))
         if s['name'] in tree:
           raise gclient_utils.Error(
               'Dependency %s specified more than once in .gclient' % s['name'])
         self.dependencies.append(Dependency(
             self, s['name'], s['url'],
             s.get('safesync_url', None),
+            s.get('managed', True),
             s.get('custom_deps', {}),
             s.get('custom_vars', {}),
             s.get('deps_file', 'DEPS'),
             True))
       except KeyError:
         raise gclient_utils.Error('Invalid .gclient file. Solution is '
                                   'incomplete: %s' % s)
     # .gclient can have hooks.
     self.deps_hooks = config_dict.get('hooks', [])
     self.deps_parsed = True
 
   def SaveConfig(self):
     gclient_utils.FileWrite(os.path.join(self.root_dir,
                                          self._options.config_filename),
                             self.config_content)
 
   @staticmethod
   def LoadCurrentConfig(options):
     """Searches for and loads a .gclient file relative to the current working
     dir. Returns a GClient object."""
     path = gclient_utils.FindGclientRoot(os.getcwd(), options.config_filename)
     if not path:
       return None
     client = GClient(path, options)
     client.SetConfig(gclient_utils.FileRead(
         os.path.join(path, options.config_filename)))
     return client
 
   def SetDefaultConfig(self, solution_name, deps_file, solution_url,
-                       safesync_url):
+                       safesync_url, managed=True):
     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,
     })
 
   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
     # makes testing a bit too fun.
     result = 'entries = {\n'
@@ skipping 25 matching lines @@
     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.safesync_url:
-          continue
-        handle = urllib.urlopen(s.safesync_url)
-        rev = handle.read().strip()
-        handle.close()
-        if len(rev):
-          self._options.revisions.append('%s@%s' % (s.name, rev))
+        if not s.managed:
+          self._options.revisions.append('%s@unmanaged' % s.name)
+        elif s.safesync_url:
+          handle = urllib.urlopen(s.safesync_url)
+          rev = handle.read().strip()
+          handle.close()
+          if len(rev):
+            self._options.revisions.append('%s@%s' % (s.name, rev))
     if not self._options.revisions:
       return revision_overrides
     solutions_names = [s.name for s in self.dependencies]
     index = 0
     for revision in self._options.revisions:
       if not '@' in revision:
         # Support for --revision 123
         revision = '%s@%s' % (solutions_names[index], revision)
       sol, rev = revision.split('@', 1)
       if not sol in solutions_names:
@@ skipping 103 matching lines @@
           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)
         else:
@@ skipping 99 matching lines @@
 """
   parser.add_option('--spec',
                     help='create a gclient file containing the provided '
                          'string. Due to Cygwin/Python brokenness, it '
                          'probably can\'t contain any newlines.')
   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('--unmanaged', action='store_true', default=False,
+                    help='overrides the default behavior to make it possible '
+                         'to have the main solution untouched by gclient '
+                         '(gclient will check out unmanaged dependencies but '
+                         'will never sync them)')
   parser.add_option('--git-deps', action='store_true',
                     help='sets the deps file to ".DEPS.git" instead of "DEPS"')
   (options, args) = parser.parse_args(args)
   if ((options.spec and args) or len(args) > 2 or
       (not options.spec and not args)):
     parser.error('Inconsistent arguments. Use either --spec or one or 2 args')
 
   client = GClient('.', options)
   if options.spec:
     client.SetConfig(options.spec)
   else:
     base_url = args[0].rstrip('/')
     if not options.name:
       name = base_url.split('/')[-1]
       if name.endswith('.git'):
         name = name[:-4]
     else:
       # specify an alternate relpath for the given URL.
       name = options.name
     deps_file = options.deps_file
     if options.git_deps:
       deps_file = '.DEPS.git'
     safesync_url = ''
     if len(args) > 1:
       safesync_url = args[1]
-    client.SetDefaultConfig(name, deps_file, base_url, safesync_url)
+    client.SetDefaultConfig(name, deps_file, base_url, safesync_url,
+                            managed=not options.unmanaged)
   client.SaveConfig()
   return 0
 
 
 @attr('epilog', """Example:
   gclient pack > patch.txt
     generate simple patch for configured client and dependences
 """)
 def CMDpack(parser, args):
   """Generate a patch which can be applied at the root of the tree.
@@ skipping 295 matching lines @@
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
 
 
 if '__main__' == __name__:
   fix_encoding.fix_encoding()
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: