Revert of [package.proto] add canonical_base_url field.

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 copy
 import difflib
 import logging
 import operator
 import os
 import subprocess
@@ skipping 18 matching lines @@
 
 class CyclicDependencyError(Exception):
   pass
 
 
 def cleanup_pyc(path):
   """Removes any .pyc files from |path|'s directory tree.
 
   This ensures we always use the fresh code.
   """
-  for root, _dirs, files in os.walk(path):
+  for root, dirs, files in os.walk(path):
     for f in files:
       if f.endswith('.pyc'):
         os.unlink(os.path.join(root, f))
 
 
 class InfraRepoConfig(object):
   def to_recipes_cfg(self, repo_root):
     # TODO(luqui): This is not always correct.  It can be configured in
     # infra/config:refs.cfg.
     return os.path.join(repo_root, 'infra', 'config', 'recipes.cfg')
@@ skipping 304 matching lines @@
       return False
     return self._proto_file == other._proto_file
 
 
 class Package(object):
   """Package represents a loaded package, and contains path and dependency
   information.
 
   This is accessed by loader.py through RecipeDeps.get_package.
   """
-  def __init__(self, name, repo_spec, deps, repo_root, relative_recipes_dir,
-               canonical_base_url):
+  def __init__(self, name, repo_spec, deps, repo_root, relative_recipes_dir):
     self.name = name
     self.repo_spec = repo_spec
     self.deps = deps
     self.repo_root = repo_root
     self.relative_recipes_dir = relative_recipes_dir
-    self.canonical_base_url = canonical_base_url
 
   @property
   def recipes_dir(self):
     return os.path.join(self.repo_root, self.relative_recipes_dir)
 
   @property
   def recipe_dir(self):
     return os.path.join(self.recipes_dir, 'recipes')
 
   @property
   def module_dir(self):
     return os.path.join(self.recipes_dir, 'recipe_modules')
 
   def find_dep(self, dep_name):
     if dep_name == self.name:
       return self
 
     assert dep_name in self.deps, (
         '%s does not exist or is not declared as a dependency of %s' % (
             dep_name, self.name))
     return self.deps[dep_name]
 
   def module_path(self, module_name):
     return os.path.join(self.recipes_dir, 'recipe_modules', module_name)
 
   def __repr__(self):
-    return 'Package(%r, %r, %r, %r, %r)' % (
-        self.name, self.repo_spec, self.deps, self.recipe_dir,
-        self.canonical_base_url)
+    return 'Package(%r, %r, %r, %r)' % (
+        self.name, self.repo_spec, self.deps, self.recipe_dir)
 
   def __str__(self):
     return 'Package %s, with dependencies %s' % (self.name, self.deps.keys())
 
 
 class RollCandidate(object):
   """RollCandidate represents a recipe roll candidate, i.e. updates
   to pinned revisions of recipe dependencies.
 
   This is mostly used by recipes.py autoroll command.
@@ skipping 51 matching lines @@
   def get_rolled_spec(self):
     """Returns a PackageSpec with all the deps updates from this roll."""
     # TODO(phajdan.jr): does this preserve comments? should it?
     new_deps = _updated(
         self._package_spec.deps,
         { project_id: spec for project_id, spec in
           self._updates.iteritems() })
     return PackageSpec(
         self._package_spec.project_id,
         self._package_spec.recipes_path,
-        new_deps,
-        self._package_spec.canonical_base_url)
+        new_deps)
 
   def get_commit_infos(self):
     """Returns a mapping project_id -> list of commits from that repo
     that are getting pulled by this roll.
     """
     commit_infos = {}
 
     for project_id, update in self._updates.iteritems():
       commit_infos[project_id] = self._package_spec.deps[
           project_id].commit_infos(self._context, update.revision)
@@ skipping 10 matching lines @@
     """Returns a unified diff between original package spec and one after roll.
     """
     orig = str(self._package_spec.dump()).splitlines()
     new = str(self.get_rolled_spec().dump()).splitlines()
     return '\n'.join(difflib.unified_diff(orig, new, lineterm=''))
 
 
 class PackageSpec(object):
   API_VERSION = 1
 
-  def __init__(self, project_id, recipes_path, deps, canonical_base_url):
+  def __init__(self, project_id, recipes_path, deps):
     self._project_id = project_id
     self._recipes_path = recipes_path
     self._deps = deps
-    self._canonical_base_url = canonical_base_url
 
   @classmethod
   def load_proto(cls, proto_file):
     buf = proto_file.read()
     assert buf.api_version == cls.API_VERSION
 
     deps = { str(dep.project_id): cls.spec_for_dep(dep)
              for dep in buf.deps }
-    return cls(str(buf.project_id), str(buf.recipes_path), deps,
-               buf.canonical_base_url)
+    return cls(str(buf.project_id), str(buf.recipes_path), deps)
 
   @classmethod
   def spec_for_dep(cls, dep):
     """Returns a RepoSpec for the given dependency protobuf."""
     url = str(dep.url)
     if url.startswith("file://"):
       return PathRepoSpec(str(dep.project_id), url[len("file://"):])
 
     if dep.repo_type in (package_pb2.DepSpec.GIT, package_pb2.DepSpec.GITILES):
       if dep.repo_type == package_pb2.DepSpec.GIT:
@@ skipping 14 matching lines @@
     return self._project_id
 
   @property
   def recipes_path(self):
     return self._recipes_path
 
   @property
   def deps(self):
     return self._deps
 
-  @property
-  def canonical_base_url(self):
-    return self._canonical_base_url
-
   def dump(self):
     return package_pb2.Package(
         api_version=self.API_VERSION,
         project_id=self._project_id,
         recipes_path=self._recipes_path,
-        deps=[ self._deps[dep].dump() for dep in sorted(self._deps.keys()) ],
-        canonical_base_url=self._canonical_base_url)
+        deps=[ self._deps[dep].dump() for dep in sorted(self._deps.keys()) ])
 
   def roll_candidates(self, root_spec, context):
     """Returns list of consistent roll candidates, and rejected roll candidates.
 
     The first one is sorted by score, descending. The more commits are pulled by
     the roll, the higher score.
 
     Second list is included to distinguish between a situation where there are
     no roll candidates from one where there are updates but they're not
     consistent.
@@ skipping 54 matching lines @@
                  are the override path.
     """
     context = PackageContext.from_proto_file(repo_root, proto_file, allow_fetch,
                                              deps_path=deps_path)
 
     if overrides:
       overrides = {project_id: PathRepoSpec(project_id, path)
                    for project_id, path in overrides.iteritems()}
     package_deps = cls(context, overrides=overrides)
 
-    package_deps._root_package = package_deps._create_package(
-        RootRepoSpec(proto_file))
+    package_deps._root_package = package_deps._create_package(RootRepoSpec(proto_file))
 
     return package_deps
 
   def _create_package(self, repo_spec):
     repo_spec.checkout(self._context)
     package_spec = PackageSpec.load_proto(repo_spec.proto_file(self._context))
     return self._create_from_spec(repo_spec, package_spec)
 
   def _create_from_spec(self, repo_spec, package_spec):
     project_id = package_spec.project_id
@@ skipping 12 matching lines @@
     self._packages[project_id] = None
 
     deps = {}
     for dep, dep_repo in sorted(package_spec.deps.items()):
       dep_repo = self._overrides.get(dep, dep_repo)
       deps[dep] = self._create_package(dep_repo)
 
     package = Package(
         project_id, repo_spec, deps,
         repo_spec.repo_root(self._context),
-        package_spec.recipes_path,
-        package_spec.canonical_base_url)
+        package_spec.recipes_path)
 
     self._packages[project_id] = package
     return package
 
   # TODO(luqui): Remove this, so all accesses to packages are done
   # via other packages with properly scoped deps.
   def get_package(self, package_id):
     return self._packages[package_id]
 
   @property
@@ skipping 12 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