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 151 matching lines @@
     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)))
 
+  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."""
+    return (self == other)

[iannucci, 2017/01/30 17:53:20]

the equality operator overload in this file is a bit surprising :/. it might
make more sense to explicitly define this on GitRepoSpec instead of relying on
it's overload of __eq__ in the base class. Even if you just return self == other
in GitRepoSpec, it's better than going up and down the class hierarchy multiple
times.

(So: make this method raise NotImplementedError in the base class here, and
implement in all subclasses)

[Paweł Hajdan Jr., 2017/01/30 19:20:05]

Done.

+
 
 class GitRepoSpec(RepoSpec):
   def __init__(self, project_id, repo, branch, revision, path, backend):
     self.project_id = project_id
     self.repo = repo
     self.branch = branch
     self.revision = revision
     self.path = path
     self.backend = backend
 
@@ skipping 135 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):
@@ skipping 310 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