Introduce different repo types (git and gitiles)

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 152 matching lines @@
   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)))
 
 
 class GitRepoSpec(RepoSpec):
-  def __init__(self, project_id, repo, branch, revision, path):
+  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
 
   def __str__(self):
     return ('GitRepoSpec{project_id="%(project_id)s", repo="%(repo)s", '
             'branch="%(branch)s", revision="%(revision)s", '
             'path="%(path)s"}' % self.__dict__)
 
   def run_git(self, context, *args):
     cmd = [self._git]
     if context is not None:
       cmd += ['-C', self._dep_dir(context)]
     cmd += list(args)
 
     logging.info('Running: %s', cmd)
     return subprocess.check_output(cmd)
 
   def checkout(self, context):
     checkout_dir = self._dep_dir(context)
-    fetch.ensure_git_checkout(
+    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 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
     return buf
 
   def updates(self, context, other_revision=None):
     """Returns a list of all updates to the branch since the revision this
     repo spec refers to.
     """
     raw_updates = self.raw_updates(
         context, (other_revision or 'origin/%s' % self.branch))
     updates = []
     for rev in raw_updates:
       info = self._get_commit_info(rev, context)
       updates.append(GitRepoSpec(
-          self.project_id, self.repo, self.branch, rev, self.path))
+          self.project_id,
+          self.repo,
+          self.branch,
+          rev,
+          self.path,
+          self.backend))
     return updates
 
   def commit_infos(self, context, other_revision):
     """Returns a list of commit infos on the branch between the pinned revision
     and |other_revision|.
     """
     raw_updates = self.raw_updates(context, other_revision)
     return [self._get_commit_info(rev, context) for rev in raw_updates]
 
   def raw_updates(self, context, other_revision):
@@ skipping 246 matching lines @@
   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)
 
   @classmethod
   def spec_for_dep(cls, dep):
-    """Returns a RepoSpec for the given dependency protobuf.
+    """Returns a RepoSpec for the given dependency protobuf."""
 
-    This assumes all dependencies are Git dependencies.
-    """
-    return GitRepoSpec(str(dep.project_id),
-                       str(dep.url),
-                       str(dep.branch),
-                       str(dep.revision),
-                       str(dep.path_override))
+    if dep.repo_type in (package_pb2.DepSpec.GIT, package_pb2.DepSpec.GITILES):
+      if dep.repo_type == package_pb2.DepSpec.GIT:
+        backend = fetch.LocalGitBackend()
+      elif dep.repo_type == package_pb2.DepSpec.GITILES:
+        backend = fetch.GitilesGitBackend()
+      return GitRepoSpec(str(dep.project_id),
+                         str(dep.url),
+                         str(dep.branch),
+                         str(dep.revision),
+                         str(dep.path_override),
+                         backend)
+
+    assert False, 'Unexpected repo type: %s' % dep
 
   @property
   def project_id(self):
     return self._project_id
 
   @property
   def recipes_path(self):
     return self._recipes_path
 
   @property
@@ skipping 140 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