Add the ability to specify a target_os for gclient solutions

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
@@ skipping 29 matching lines @@
                the current Python interpreter (sys.executable) will be used
                to run the command. If the list contains string "$matching_files"
                it will be removed from the list and the list will be extended
                by the list of matching files.
 
   Example:
     hooks = [
       { "pattern": "\\.(gif|jpe?g|pr0n|png)$",
         "action":  ["python", "image_indexer.py", "--all"]},
     ]
+
+Specifying a target OS
+  An optional key named "target_os" may be added to any solution to specify
+  an additional operating system that should be considered when processing
+  the deps_os dict of a DEPS file.
 """
 
 __version__ = "0.6.4"
 
 import copy
 import logging
 import optparse
 import os
 import posixpath
 import pprint
@@ skipping 76 matching lines @@
         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, safesync_url, managed, custom_deps, custom_vars,
-      deps_file, should_process):
+      deps_file, target_os, should_process):

[M-A Ruel, 2012/04/19 13:29:03]

It also doesn't make sense to make it per Dependency, so this shouldn't be done
here.

     GClientKeywords.__init__(self)
 
     # These are not mutable:
     self._parent = parent
     self._safesync_url = safesync_url
     self._deps_file = deps_file
     self._url = url
+    self._target_os = target_os
     # '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 --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
 
     # These are only set in .gclient and not in DEPS files.
@@ skipping 49 matching lines @@
 
   @property
   def custom_deps(self):
     return self._custom_deps.copy()
 
   @property
   def url(self):
     return self._url
 
   @property
+  def target_os(self):
+    return self._target_os
+
+  @property
   def recursion_limit(self):
     """Returns > 0 if this dependency is not too recursed to be processed."""
     return max(self.parent.recursion_limit - 1, 0)
 
   def get_custom_deps(self, name, url):
     """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, safesync_url, managed, custom_deps,
-               custom_vars, deps_file, should_process):
+               custom_vars, deps_file, target_os, should_process):
     gclient_utils.WorkItem.__init__(self, name)
     DependencySettings.__init__(
         self, parent, url, safesync_url, managed, custom_deps, custom_vars,
-        deps_file, should_process)
+        deps_file, target_os, should_process)
 
     # This is in both .gclient and DEPS files:
     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 169 matching lines @@
       # Eval the content.
       try:
         exec(deps_content, global_scope, local_scope)
       except SyntaxError, e:
         gclient_utils.SyntaxErrorToError(filepath, e)
     deps = local_scope.get('deps', {})
     # load os specific dependencies if defined.  these dependencies may
     # override or extend the values defined by the 'deps' member.
     if 'deps_os' in local_scope:
       enforced_os = self.root.enforced_os
+      if self.target_os and self.target_os not in enforced_os:
+        enforced_os = enforced_os + tuple([self.target_os])
+
       for deps_os_key in enforced_os:
         os_deps = local_scope['deps_os'].get(deps_os_key, {})
         if len(enforced_os) > 1:
           # Ignore any conflict when including deps for more than one
           # platform, so we collect the broadest set of dependencies
           # available. We may end up with the wrong revision of something for
           # our platform, but this is the best we can do.
           deps.update([x for x in os_deps.items() if not x[0] in deps])
         else:
           deps.update(os_deps)
@@ skipping 15 matching lines @@
         # dependency local path.
         rel_deps[os.path.normpath(os.path.join(self.name, d))] = url
       deps = rel_deps
 
     # 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_to_add.append(Dependency(
           self, name, url, None, None, None, None,
-          self.deps_file, should_process))
+          self.deps_file, self.target_os, should_process))
     deps_to_add.sort(key=lambda x: x.name)
     self.add_dependencies_and_close(deps_to_add, local_scope.get('hooks', []))
     logging.info('ParseDepsFile(%s) done' % self.name)
 
   def add_dependencies_and_close(self, deps_to_add, hooks):
     """Adds the dependencies, hooks and mark the parsing as done."""
     for dep in deps_to_add:
       if dep.verify_validity():
         self.add_dependency(dep)
     self._mark_as_parsed(hooks)
@@ skipping 257 matching lines @@
   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', 'safesync_url', 'custom_deps',
               'custom_vars', 'deps_hooks', 'file_list', 'should_process',
-              'processed', 'hooks_ran', 'deps_parsed', 'requirements'):
+              'target_os', 'processed', 'hooks_ran', 'deps_parsed',
+              'requirements'):
       # 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))
 
     for d in self.dependencies:
       out.extend(['  ' + x for x in str(d).splitlines()])
@@ skipping 57 matching lines @@
 # 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, True, None, None,
-                        'unused', True)
+                        'unused', None, 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))

[M-A Ruel, 2012/04/19 13:29:03]

enforced_os already does what you want. It is used at line 442 and will work
properly.

     self._root_dir = root_dir
     self.config_content = None
 
   def SetConfig(self, content):
     assert not self.dependencies
     config_dict = {}
     self.config_content = content
     try:
       exec(content, config_dict)
     except SyntaxError, e:
       gclient_utils.SyntaxErrorToError('.gclient', e)
 
     deps_to_add = []
     for s in config_dict.get('solutions', []):
       try:
         deps_to_add.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'),
+            s.get('target_os', None),

[M-A Ruel, 2012/04/19 13:29:03]

enforced_os doesn't make sense to be per solution. As such, it should be outside
of the solutions list. So;

if 'enforced_os' in config_dict:
  self.enforced_os = config_dict['enforced_os']
  logging.debug('Enforcing deps_os: %s' % self.enforced_os)

             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')
 
   def SaveConfig(self):
     gclient_utils.FileWrite(os.path.join(self.root_dir,
                                          self._options.config_filename),
@@ skipping 716 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: