Some changes to allow recipes and modules to live noncentrally

scripts/slave/unittests/recipe_configs_test.py

 #!/usr/bin/python
 # Copyright 2013 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.
 
 """Provides test coverage for common recipe configurations.
 
 recipe config expectations are located in ../recipe_configs_test/*.expected
 
 In training mode, this will loop over every config item in ../recipe_configs.py
@@ skipping 25 matching lines @@
              for x in recipe_util.MODULE_DIRS()],
     data_file='.recipe_configs_test_coverage', data_suffix=True))()
 
 def covered(fn, *args, **kwargs):
   COVERAGE.start()
   try:
     return fn(*args, **kwargs)
   finally:
     COVERAGE.stop()
 
+LOADER = recipe_loader.ModuleLoader()
+
+def load_recipe_modules():
+  modules = {}
+  for modpath in recipe_loader.loop_over_recipe_modules():
+    # That's right, we're using the path as the local name! The local
+    # name really could be anything unique, we don't use it.
+    modules[modpath] = LOADER.load(recipe_loader.PathDependency(
+        modpath, local_name=modpath, base_path=os.curdir))
+  return modules
+
+
 RECIPE_MODULES = None
 def init_recipe_modules():
   global RECIPE_MODULES
-  RECIPE_MODULES = covered(recipe_loader.load_recipe_modules,
-                           recipe_util.MODULE_DIRS())
+  RECIPE_MODULES = covered(load_recipe_modules)
 
 from slave import recipe_config  # pylint: disable=F0401
 
 
 def evaluate_configurations(args):
   mod_id, var_assignments, verbose = args
-  mod = getattr(RECIPE_MODULES, mod_id)
+  mod = RECIPE_MODULES[mod_id]
   ctx = mod.CONFIG_CTX
 
   config_name = None
   try:
     make_item = lambda: covered(ctx.CONFIG_SCHEMA, **var_assignments)
 
     # Try ROOT_CONFIG_ITEM first. If it raises BadConf, then we can skip
     # this config.
     root_item = ctx.ROOT_CONFIG_ITEM
     if root_item:
@@ skipping 20 matching lines @@
     return True
   except Exception as e:
     print 'Caught exception [%s] with args (%s, %s): %s' % (
         e, mod_id, var_assignments, config_name)
     if verbose:
       traceback.print_exc()
     return False
 
 
 def multiprocessing_init():
-  init_recipe_modules()

[iannucci, 2015/05/05 23:35:59]

???????

-
   # HACK: multiprocessing doesn't work with atexit, so shim the exit functions
   # instead. This allows us to save exactly one coverage file per subprocess.
   # pylint: disable=W0212
   real_os_exit = multiprocessing.forking.exit
   def exitfn(code):
     COVERAGE.save()
     real_os_exit(code)
   multiprocessing.forking.exit = exitfn
 
   # This check mirrors the logic in multiprocessing.forking.exit
   if sys.platform != 'win32':
     # Even though multiprocessing.forking.exit is defined, it's not used in the
     # non-win32 version of multiprocessing.forking.Popen... *loss for words*
     os._exit = exitfn
 
 
 def coverage_parallel_map(fn, verbose):
   combination_generator = (
     (mod_id, var_assignments, verbose)
-    for mod_id, mod in RECIPE_MODULES.__dict__.iteritems()
-      if mod_id[0] != '_' and mod.CONFIG_CTX
+    for mod_id, mod in RECIPE_MODULES.iteritems()
+    if mod.CONFIG_CTX
     for var_assignments in imap(dict, product(*[
       [(key_name, val) for val in vals]
       for key_name, vals in mod.CONFIG_CTX.VAR_TEST_MAP.iteritems()
     ]))
   )
 
   pool = multiprocessing.Pool(initializer=multiprocessing_init)
   try:
     return pool.map_async(fn, combination_generator).get(999999)
   finally:
@@ skipping 21 matching lines @@
   if not success:
     print 'FATAL: Some recipe configuration(s) failed'
   if not all_covered:
     print 'FATAL: Recipes configs are not at 100% coverage.'
 
   return 1 if (not success or not all_covered) else 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))