Make it possible to override more than one package

recipe_engine/package.py

 # Copyright 2015 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 import ast
 import collections
 import contextlib
 import copy
 import difflib
 import functools
@@ skipping 140 matching lines @@
   def checkout(self, context):
     """Fetches the specified package and returns the path of the package root
     (the directory that contains recipes and recipe_modules).
     """
     raise NotImplementedError()
 
   def repo_root(self, context):
     """Returns the root of this repository."""
     raise NotImplementedError()
 
+  def is_consistent_with(self, other):
+    """Returns True iff |other| can be used in place of |self| while keeping
+    the dependency graph consistent. Most often it means being pinned at the
+    same revision, but some specs (like path-based) are always compatible."""
+    raise NotImplementedError()
+
   def __eq__(self, other):
     raise NotImplementedError()
 
   def __ne__(self, other):
     return not (self == other)
 
   def proto_file(self, context):
     """Returns the ProtoFile of the recipes config file in this repository. 
     Requires a good checkout."""
     return ProtoFile(InfraRepoConfig().to_recipes_cfg(self.repo_root(context)))
@@ skipping 24 matching lines @@
 
   def checkout(self, context):
     checkout_dir = self._dep_dir(context)
     self.backend.checkout(
         self.repo, self.revision, checkout_dir, context.allow_fetch)
     cleanup_pyc(checkout_dir)
 
   def repo_root(self, context):
     return os.path.join(self._dep_dir(context), self.path)
 
+  def is_consistent_with(self, other):
+    return (self == other)
+
   def dump(self):
     buf = package_pb2.DepSpec(
         project_id=self.project_id,
         url=self.repo,
         branch=self.branch,
         revision=self.revision)
     if self.path:
       buf.path_override = self.path
 
     # Only dump repo_type if it's different from default. This preserves
@@ skipping 102 matching lines @@
   def proto_file(self, context):
     """Returns the ProtoFile of the recipes config file in this repository. 
     Requires a good checkout."""
     return ProtoFile(InfraRepoConfig().to_recipes_cfg(self.path))
 
   def __eq__(self, other):
     if not isinstance(other, type(self)):
       return False
     return self.path == other.path
 
+  def is_consistent_with(self, other):
+    # PathRepoSpec is always compatible, unless it's PathRepoSpec with a
+    # different path.
+    if isinstance(other, type(self)):
+      return self.path == other.path
+    return True
+
 
 class RootRepoSpec(RepoSpec):
   def __init__(self, proto_file):
     self._proto_file = proto_file
 
   def checkout(self, context):
     # We assume this is already checked out.
     pass
 
   def repo_root(self, context):
     return context.repo_root
 
+  def is_consistent_with(self, other):
+    return (self == other)
+
   def proto_file(self, context):
     return self._proto_file
 
   def __eq__(self, other):
     if not isinstance(other, type(self)):
       return False
     return self._proto_file == other._proto_file
 
 
 class Package(object):
@@ skipping 298 matching lines @@
   def _create_from_spec(self, repo_spec, package_spec, overriding):
     project_id = package_spec.project_id
 
     if project_id in self._packages:
       current = self._packages[project_id]
       if current is None:
         raise CyclicDependencyError(
             'Package %s depends on itself' % project_id)
 
       # Only enforce package consistency within the override boundary.
-      if current.is_override == overriding and repo_spec != current.repo_spec:
+      # It's fine if either spec claims it's consistent with the other.
+      if (current.is_override == overriding and
+          not repo_spec.is_consistent_with(current.repo_spec) and
+          not current.repo_spec.is_consistent_with(repo_spec)):
         raise InconsistentDependencyGraphError(
             project_id, (repo_spec, current.repo_spec))
     self._packages[project_id] = None
 
     deps = {}
     for dep, dep_repo in sorted(package_spec.deps.items()):
       dep_package = self._packages.get(dep)
       if not (dep_package and dep_package.is_override):
         dep_package = self._create_package(dep_repo, overriding)
       deps[dep] = dep_package
@@ skipping 28 matching lines @@
   >>> d = { 'x': 1, 'y': 2 }
   >>> sorted(_updated(d, { 'y': 3, 'z': 4 }).items())
   [('x', 1), ('y', 3), ('z', 4)]
   >>> sorted(d.items())
   [('x', 1), ('y', 2)]
   """
 
   d = copy.copy(d)
   d.update(updates)
   return d