Move git_cache out to a separate library

diff --git a/Changelog b/Changelog
index 2a12d5aae9bda2860db6a2524d9ed05fcfc5f3d6..32f74a511c4436cc01c0fdf06e1c2ace0cca2fa3 100644 (file)
--- a/Changelog
+++ b/Changelog
@@ -1,4 +1,6 @@
 ## [Unreleased]
+### Changed
+- Moved git cache out to a separate library
 
 ## [2.1.1] - 2020-07-01
 ### Changed

diff --git a/default.nix b/default.nix
index 1a054198d9d001eb3270472f820d5524d30b352e..b3fc3a544a1cba59d941578590d18c813db00533 100644 (file)
--- a/default.nix
+++ b/default.nix
@@ -1,11 +1,32 @@
 { pkgs ? import <nixpkgs> { }, lint ? false }:
-pkgs.python3Packages.callPackage
-({ lib, buildPythonPackage, nix, git, autopep8, mypy, pylint, }:
+
+let
+  git-cache-fallback = { buildPythonPackage, fetchgit, git, mypy, }:
+    buildPythonPackage rec {
+      pname = "git-cache";
+      version = "1.0.0";
+      src = fetchgit {
+        url = "https://scottworley.com/git-cache.git";
+        rev = "v${version}";
+        sha256 = "06mzjc424988n2s1h25x2bi3mxbk2pnba31zkjljgw4cgw2p9036";
+      };
+      checkInputs = [ git mypy ];
+      doCheck = true;
+      checkPhase = "./test.sh";
+    };
+
+in pkgs.python3Packages.callPackage
+({ lib, buildPythonPackage, nix, git, autopep8, mypy, pylint, git-cache, }:
   buildPythonPackage rec {
     pname = "pinch";
     version = "3.0.0-pre";
     src = lib.cleanSource ./.;
+    propagatedBuildInputs = [ git-cache ];
     checkInputs = [ nix git mypy ] ++ lib.optionals lint [ autopep8 pylint ];
     doCheck = true;
     checkPhase = "./test.sh";
-  }) { }
+  }) {
+    git-cache =
+      pkgs.python3Packages.git-cache or (pkgs.python3Packages.callPackage
+        git-cache-fallback { });
+  }

diff --git a/pinch.py b/pinch.py
index ed33c928ae6a466c5e27a70ccf2a52d592bc8bc8..5eb76018e710025a01bf632b1ab3234a79153815 100644 (file)
--- a/pinch.py
+++ b/pinch.py
@@ -34,6 +34,8 @@ from typing import (
     Union,
 )
 
+import git_cache
+
 # Use xdg module when it's less painful to have as a dependency
 
 
@@ -160,17 +162,17 @@ class GitSearchPath(NamedTuple):
     git_repo: str
 
     def pin(self, v: Verification, old_pin: Optional[Pin]) -> GitPin:
+        _, new_revision = git_cache.fetch(self.git_repo, self.git_ref)
         if old_pin is not None:
             assert isinstance(old_pin, GitPin)
-        old_revision = old_pin.git_revision if old_pin is not None else None
-
-        new_revision = git_fetch(v, self, None, old_revision)
+            verify_git_ancestry(v, self, old_pin.git_revision, new_revision)
         return GitPin(release_name=git_revision_name(v, self, new_revision),
                       git_revision=new_revision)
 
     def fetch(self, v: Verification, pin: Pin) -> str:
         assert isinstance(pin, GitPin)
-        ensure_git_rev_available(v, self, pin, None)
+        git_cache.ensure_rev_available(
+            self.git_repo, self.git_ref, pin.git_revision)
         return git_get_tarball(v, self, pin)
 
 
@@ -182,14 +184,17 @@ class ChannelSearchPath(NamedTuple):
     def pin(self, v: Verification, old_pin: Optional[Pin]) -> ChannelPin:
         if old_pin is not None:
             assert isinstance(old_pin, ChannelPin)
-        old_revision = old_pin.git_revision if old_pin is not None else None
 
         channel_html, forwarded_url = fetch_channel(v, self)
         table, new_gitpin = parse_channel(v, channel_html)
         if old_pin is not None and old_pin.git_revision == new_gitpin.git_revision:
             return old_pin
         fetch_resources(v, new_gitpin, forwarded_url, table)
-        ensure_git_rev_available(v, self, new_gitpin, old_revision)
+        git_cache.ensure_rev_available(
+            self.git_repo, self.git_ref, new_gitpin.git_revision)
+        if old_pin is not None:
+            verify_git_ancestry(
+                v, self, old_pin.git_revision, new_gitpin.git_revision)
         check_channel_contents(v, self, table, new_gitpin)
         return ChannelPin(
             release_name=new_gitpin.release_name,
@@ -345,13 +350,6 @@ def fetch_resources(
     v.result(open(table['git-revision'].file).read(999) == pin.git_revision)
 
 
-def git_cachedir(git_repo: str) -> str:
-    return os.path.join(
-        xdg.XDG_CACHE_HOME,
-        'pinch/git',
-        digest_string(git_repo.encode()))
-
-
 def tarball_cache_file(channel: TarrableSearchPath, pin: GitPin) -> str:
     return os.path.join(
         xdg.XDG_CACHE_HOME,
@@ -365,101 +363,19 @@ def tarball_cache_file(channel: TarrableSearchPath, pin: GitPin) -> str:
 def verify_git_ancestry(
         v: Verification,
         channel: TarrableSearchPath,
-        new_revision: str,
-        old_revision: Optional[str]) -> None:
-    cachedir = git_cachedir(channel.git_repo)
-    v.status('Verifying rev is an ancestor of ref')
+        old_revision: str,
+        new_revision: str) -> None:
+    cachedir = git_cache.git_cachedir(channel.git_repo)
+    v.status('Verifying rev is an ancestor of previous rev %s' % old_revision)
     process = subprocess.run(['git',
                               '-C',
                               cachedir,
                               'merge-base',
                               '--is-ancestor',
-                              new_revision,
-                              channel.git_ref])
-    v.result(process.returncode == 0)
-
-    if old_revision is not None:
-        v.status(
-            'Verifying rev is an ancestor of previous rev %s' %
-            old_revision)
-        process = subprocess.run(['git',
-                                  '-C',
-                                  cachedir,
-                                  'merge-base',
-                                  '--is-ancestor',
-                                  old_revision,
-                                  new_revision])
-        v.result(process.returncode == 0)
-
-
-def git_fetch(
-        v: Verification,
-        channel: TarrableSearchPath,
-        desired_revision: Optional[str],
-        old_revision: Optional[str]) -> str:
-    # It would be nice if we could share the nix git cache, but as of the time
-    # of writing it is transitioning from gitv2 (deprecated) to gitv3 (not ready
-    # yet), and trying to straddle them both is too far into nix implementation
-    # details for my comfort.  So we re-implement here half of nix.fetchGit.
-    # :(
-
-    cachedir = git_cachedir(channel.git_repo)
-    if not os.path.exists(cachedir):
-        v.status("Initializing git repo")
-        process = subprocess.run(
-            ['git', 'init', '--bare', cachedir])
-        v.result(process.returncode == 0)
-
-    v.status('Fetching ref "%s" from %s' % (channel.git_ref, channel.git_repo))
-    # We don't use --force here because we want to abort and freak out if forced
-    # updates are happening.
-    process = subprocess.run(['git',
-                              '-C',
-                              cachedir,
-                              'fetch',
-                              channel.git_repo,
-                              '%s:%s' % (channel.git_ref,
-                                         channel.git_ref)])
+                              old_revision,
+                              new_revision])
     v.result(process.returncode == 0)
 
-    if desired_revision is not None:
-        v.status('Verifying that fetch retrieved this rev')
-        process = subprocess.run(
-            ['git', '-C', cachedir, 'cat-file', '-e', desired_revision])
-        v.result(process.returncode == 0)
-
-    new_revision = open(
-        os.path.join(
-            cachedir,
-            'refs',
-            'heads',
-            channel.git_ref)).read(999).strip()
-
-    verify_git_ancestry(v, channel, new_revision, old_revision)
-
-    return new_revision
-
-
-def ensure_git_rev_available(
-        v: Verification,
-        channel: TarrableSearchPath,
-        pin: GitPin,
-        old_revision: Optional[str]) -> None:
-    cachedir = git_cachedir(channel.git_repo)
-    if os.path.exists(cachedir):
-        v.status('Checking if we already have this rev:')
-        process = subprocess.run(
-            ['git', '-C', cachedir, 'cat-file', '-e', pin.git_revision])
-        if process.returncode == 0:
-            v.status('yes')
-        if process.returncode == 1:
-            v.status('no')
-        v.result(process.returncode == 0 or process.returncode == 1)
-        if process.returncode == 0:
-            verify_git_ancestry(v, channel, pin.git_revision, old_revision)
-            return
-    git_fetch(v, channel, pin.git_revision, old_revision)
-
 
 def compare_tarball_and_git(
         v: Verification,
@@ -511,7 +427,7 @@ def git_checkout(
     v.status('Checking out corresponding git revision')
     git = subprocess.Popen(['git',
                             '-C',
-                            git_cachedir(channel.git_repo),
+                            git_cache.git_cachedir(channel.git_repo),
                             'archive',
                             pin.git_revision],
                            stdout=subprocess.PIPE)
@@ -543,7 +459,7 @@ def git_get_tarball(
                 pin.git_revision)
             git = subprocess.Popen(['git',
                                     '-C',
-                                    git_cachedir(channel.git_repo),
+                                    git_cache.git_cachedir(channel.git_repo),
                                     'archive',
                                     '--prefix=%s/' % pin.release_name,
                                     pin.git_revision],
@@ -610,7 +526,7 @@ def git_revision_name(
     v.status('Getting commit date')
     process = subprocess.run(['git',
                               '-C',
-                              git_cachedir(channel.git_repo),
+                              git_cache.git_cachedir(channel.git_repo),
                               'log',
                               '-n1',
                               '--format=%ct-%h',

diff --git a/setup.py b/setup.py
index 2c5dfc8bca33b6e0cd6c4c4f6044bb6508d0f3bb..9d10977c1b2e9faf3bbfd2562a46aa09ba34eb23 100644 (file)
--- a/setup.py
+++ b/setup.py
@@ -5,4 +5,5 @@ setup(
     version='3.0.0-pre',
     py_modules=['pinch'],
     entry_points={'console_scripts': ['pinch = pinch:main']},
+    dependency_links=['https://scottworley.com/git/git-cache'],
 )