[PATCH 2 of 5 modernize-streamclone] streamclone: move applystreamclone() from localrepo.py

Gregory Szorc gregory.szorc at gmail.com
Fri Oct 2 18:34:02 CDT 2015


# HG changeset patch
# User Gregory Szorc <gregory.szorc at gmail.com>
# Date 1443826292 25200
#      Fri Oct 02 15:51:32 2015 -0700
# Node ID 1e126600c72f702e2d8cb3cd336ba5b4cc4724e4
# Parent  ba68484c8cb8d72f1b172af4d1f4771e8a71746c
streamclone: move applystreamclone() from localrepo.py

Upcoming patches will modernize the streaming clone code. Streaming
clone data and code kind of lives in its own world. exchange.py is
arguably the most appropriate existing location for it. However, over
a dozen patches from now it became apparent that there was a lot of code
related to streaming clones and that having it contained within its own
module would make it easier to comprehend. So, we establish
streamclone.py.

It's worth noting that streamclone.py existed a long time ago, last seen
in the 1.6 release. It was removed in 04f76a954842.

The function was renamed as part of the move because its old name was
redundant with the new module name. The only other content change was
"self" was renamed to "repo" and minor grammar in the docstring was
updated.

diff --git a/mercurial/localrepo.py b/mercurial/localrepo.py
--- a/mercurial/localrepo.py
+++ b/mercurial/localrepo.py
@@ -18,8 +18,9 @@ import tags as tagsmod
 from lock import release
 import weakref, errno, os, time, inspect, random
 import branchmap, pathutil
 import namespaces
+import streamclone
 propertycache = util.propertycache
 filecache = scmutil.filecache
 
 class repofilecache(filecache):
@@ -1802,62 +1803,11 @@ class localrepository(object):
             raise util.Abort(_('locking the remote repository failed'))
         elif resp != 0:
             raise util.Abort(_('the server sent an unknown error code'))
 
-        self.applystreamclone(remotereqs, rbranchmap, fp)
+        streamclone.applyremotedata(self, remotereqs, rbranchmap, fp)
         return len(self.heads()) + 1
 
-    def applystreamclone(self, remotereqs, remotebranchmap, fp):
-        """Apply stream clone data to this repository.
-
-        "remotereqs" is a set of requirements to handle the incoming data.
-        "remotebranchmap" is the result of a branchmap lookup on the remote. It
-        can be None.
-        "fp" is a file object containing the raw stream data, suitable for
-        feeding into exchange.consumestreamclone.
-        """
-        lock = self.lock()
-        try:
-            exchange.consumestreamclone(self, fp)
-
-            # new requirements = old non-format requirements +
-            #                    new format-related remote requirements
-            # requirements from the streamed-in repository
-            self.requirements = remotereqs | (
-                    self.requirements - self.supportedformats)
-            self._applyopenerreqs()
-            self._writerequirements()
-
-            if remotebranchmap:
-                rbheads = []
-                closed = []
-                for bheads in remotebranchmap.itervalues():
-                    rbheads.extend(bheads)
-                    for h in bheads:
-                        r = self.changelog.rev(h)
-                        b, c = self.changelog.branchinfo(r)
-                        if c:
-                            closed.append(h)
-
-                if rbheads:
-                    rtiprev = max((int(self.changelog.rev(node))
-                            for node in rbheads))
-                    cache = branchmap.branchcache(remotebranchmap,
-                                                  self[rtiprev].node(),
-                                                  rtiprev,
-                                                  closednodes=closed)
-                    # Try to stick it as low as possible
-                    # filter above served are unlikely to be fetch from a clone
-                    for candidate in ('base', 'immutable', 'served'):
-                        rview = self.filtered(candidate)
-                        if cache.validfor(rview):
-                            self._branchcaches[candidate] = cache
-                            cache.write(rview)
-                            break
-            self.invalidate()
-        finally:
-            lock.release()
-
     def clone(self, remote, heads=[], stream=None):
         '''clone remote repository.
 
         keyword arguments:
diff --git a/mercurial/streamclone.py b/mercurial/streamclone.py
new file mode 100644
--- /dev/null
+++ b/mercurial/streamclone.py
@@ -0,0 +1,64 @@
+# streamclone.py - producing and consuming streaming repository data
+#
+# Copyright 2015 Gregory Szorc <gregory.szorc at gmail.com>
+#
+# This software may be used and distributed according to the terms of the
+# GNU General Public License version 2 or any later version.
+
+from __future__ import absolute_import
+
+from . import (
+    branchmap,
+    exchange,
+)
+
+def applyremotedata(repo, remotereqs, remotebranchmap, fp):
+    """Apply stream clone data to a repository.
+
+    "remotereqs" is a set of requirements to handle the incoming data.
+    "remotebranchmap" is the result of a branchmap lookup on the remote. It
+    can be None.
+    "fp" is a file object containing the raw stream data, suitable for
+    feeding into exchange.consumestreamclone.
+    """
+    lock = repo.lock()
+    try:
+        exchange.consumestreamclone(repo, fp)
+
+        # new requirements = old non-format requirements +
+        #                    new format-related remote requirements
+        # requirements from the streamed-in repository
+        repo.requirements = remotereqs | (
+                repo.requirements - repo.supportedformats)
+        repo._applyopenerreqs()
+        repo._writerequirements()
+
+        if remotebranchmap:
+            rbheads = []
+            closed = []
+            for bheads in remotebranchmap.itervalues():
+                rbheads.extend(bheads)
+                for h in bheads:
+                    r = repo.changelog.rev(h)
+                    b, c = repo.changelog.branchinfo(r)
+                    if c:
+                        closed.append(h)
+
+            if rbheads:
+                rtiprev = max((int(repo.changelog.rev(node))
+                        for node in rbheads))
+                cache = branchmap.branchcache(remotebranchmap,
+                                              repo[rtiprev].node(),
+                                              rtiprev,
+                                              closednodes=closed)
+                # Try to stick it as low as possible
+                # filter above served are unlikely to be fetch from a clone
+                for candidate in ('base', 'immutable', 'served'):
+                    rview = repo.filtered(candidate)
+                    if cache.validfor(rview):
+                        repo._branchcaches[candidate] = cache
+                        cache.write(rview)
+                        break
+        repo.invalidate()
+    finally:
+        lock.release()


More information about the Mercurial-devel mailing list