sidedata: move sidedata-related utils to the dedicated module

Differential Revision: https://phab.mercurial-scm.org/D10360

mercurial/changegroup.py

@@ -7,7 +7,6 b''
 
 from __future__ import absolute_import
 
-import collections
 import os
 import struct
 import weakref
@@ -301,7 +300,7 b' class cg1unpacker(object):'
             and srctype == b'pull'
         )
         if adding_sidedata:
-            sidedata_helpers = get_sidedata_helpers(
+            sidedata_helpers = sidedatamod.get_sidedata_helpers(
                 repo,
                 sidedata_categories or set(),
                 pull=True,
@@ -1073,7 +1072,9 b' class cgpacker(object):'
                 # TODO a better approach would be for the strip bundle to
                 # correctly advertise its sidedata categories directly.
                 remote_sidedata = repo._wanted_sidedata
-            sidedata_helpers = get_sidedata_helpers(repo, remote_sidedata)
+            sidedata_helpers = sidedatamod.get_sidedata_helpers(
+                repo, remote_sidedata
+            )
 
         clstate, deltas = self._generatechangelog(
             cl,
@@ -1940,24 +1941,3 b' def _addchangegroupfiles('
                 )
 
     return revisions, files
-
-
-def get_sidedata_helpers(repo, remote_sd_categories, pull=False):
-    # Computers for computing sidedata on-the-fly
-    sd_computers = collections.defaultdict(list)
-    # Computers for categories to remove from sidedata
-    sd_removers = collections.defaultdict(list)
-    to_generate = remote_sd_categories - repo._wanted_sidedata
-    to_remove = repo._wanted_sidedata - remote_sd_categories
-    if pull:
-        to_generate, to_remove = to_remove, to_generate
-
-    for revlog_kind, computers in repo._sidedata_computers.items():
-        for category, computer in computers.items():
-            if category in to_generate:
-                sd_computers[revlog_kind].append(computer)
-            if category in to_remove:
-                sd_removers[revlog_kind].append(computer)
-
-    sidedata_helpers = (repo, sd_computers, sd_removers)
-    return sidedata_helpers

mercurial/localrepo.py

@@ -49,7 +49,6 b' from . import ('
     match as matchmod,
     mergestate as mergestatemod,
     mergeutil,
-    metadata as metadatamod,
     namespaces,
     narrowspec,
     obsolete,
@@ -90,6 +89,7 b' from .utils import ('
 from .revlogutils import (
     concurrency_checker as revlogchecker,
     constants as revlogconst,
+    sidedata as sidedatamod,
 )
 
 release = lockmod.release
@@ -1407,7 +1407,7 b' class localrepository(object):'
 
         self._wanted_sidedata = set()
         self._sidedata_computers = {}
-        metadatamod.set_sidedata_spec_for_repo(self)
+        sidedatamod.set_sidedata_spec_for_repo(self)
 
     def _getvfsward(self, origfunc):
         """build a ward for self.vfs"""

mercurial/metadata.py

@@ -14,12 +14,10 b' import struct'
 from .node import nullrev
 from . import (
     error,
-    requirements as requirementsmod,
     util,
 )
 
 from .revlogutils import (
-    constants as revlogconst,
     flagutil as sidedataflag,
     sidedata as sidedatamod,
 )
@@ -824,18 +822,6 b' def copies_sidedata_computer(repo, revlo'
     return sidedata, (flags_to_add, 0)
 
 
-def set_sidedata_spec_for_repo(repo):
-    if requirementsmod.COPIESSDC_REQUIREMENT in repo.requirements:
-        repo.register_wanted_sidedata(sidedatamod.SD_FILES)
-    repo.register_sidedata_computer(
-        revlogconst.KIND_CHANGELOG,
-        sidedatamod.SD_FILES,
-        (sidedatamod.SD_FILES,),
-        copies_sidedata_computer,
-        sidedataflag.REVIDX_HASCOPIESINFO,
-    )
-
-
 def _sidedata_worker(srcrepo, revs_queue, sidedata_queue, tokens):
     """The function used by worker precomputing sidedata
 

mercurial/revlog.py

@@ -2781,7 +2781,7 b' class revlog(object):'
                 text, sidedata = self._revisiondata(rev)
 
                 if sidedata_helpers is not None:
-                    (sidedata, new_flags) = storageutil.run_sidedata_helpers(
+                    (sidedata, new_flags) = sidedatautil.run_sidedata_helpers(
                         self, sidedata_helpers, sidedata, rev
                     )
                     flags = flags | new_flags[0] & ~new_flags[1]
@@ -2811,7 +2811,7 b' class revlog(object):'
                     sidedata = self.sidedata(rev)
 
                 if sidedata_helpers is not None:
-                    (sidedata, new_flags) = storageutil.run_sidedata_helpers(
+                    (sidedata, new_flags) = sidedatautil.run_sidedata_helpers(
                         self, sidedata_helpers, sidedata, rev
                     )
                     flags = flags | new_flags[0] & ~new_flags[1]
@@ -3089,7 +3089,7 b' class revlog(object):'
             current_offset = fp.tell()
             for rev in range(startrev, endrev + 1):
                 entry = self.index[rev]
-                new_sidedata, flags = storageutil.run_sidedata_helpers(
+                new_sidedata, flags = sidedatautil.run_sidedata_helpers(
                     store=self,
                     sidedata_helpers=helpers,
                     sidedata={},

mercurial/revlogutils/sidedata.py

@@ -32,9 +32,11 b' the concept.'
 
 from __future__ import absolute_import
 
+import collections
 import struct
 
-from .. import error
+from .. import error, requirements as requirementsmod
+from ..revlogutils import constants, flagutil
 from ..utils import hashutil
 
 ## sidedata type constant
@@ -91,3 +93,63 b' def deserialize_sidedata(blob):'
         sidedata[key] = entrytext
         dataoffset = nextdataoffset
     return sidedata
+
+
+def get_sidedata_helpers(repo, remote_sd_categories, pull=False):
+    # Computers for computing sidedata on-the-fly
+    sd_computers = collections.defaultdict(list)
+    # Computers for categories to remove from sidedata
+    sd_removers = collections.defaultdict(list)
+    to_generate = remote_sd_categories - repo._wanted_sidedata
+    to_remove = repo._wanted_sidedata - remote_sd_categories
+    if pull:
+        to_generate, to_remove = to_remove, to_generate
+
+    for revlog_kind, computers in repo._sidedata_computers.items():
+        for category, computer in computers.items():
+            if category in to_generate:
+                sd_computers[revlog_kind].append(computer)
+            if category in to_remove:
+                sd_removers[revlog_kind].append(computer)
+
+    sidedata_helpers = (repo, sd_computers, sd_removers)
+    return sidedata_helpers
+
+
+def run_sidedata_helpers(store, sidedata_helpers, sidedata, rev):
+    """Returns the sidedata for the given revision after running through
+    the given helpers.
+    - `store`: the revlog this applies to (changelog, manifest, or filelog
+      instance)
+    - `sidedata_helpers`: see `storageutil.emitrevisions`
+    - `sidedata`: previous sidedata at the given rev, if any
+    - `rev`: affected rev of `store`
+    """
+    repo, sd_computers, sd_removers = sidedata_helpers
+    kind = store.revlog_kind
+    flags_to_add = 0
+    flags_to_remove = 0
+    for _keys, sd_computer, _flags in sd_computers.get(kind, []):
+        sidedata, flags = sd_computer(repo, store, rev, sidedata)
+        flags_to_add |= flags[0]
+        flags_to_remove |= flags[1]
+    for keys, _computer, flags in sd_removers.get(kind, []):
+        for key in keys:
+            sidedata.pop(key, None)
+        flags_to_remove |= flags
+    return sidedata, (flags_to_add, flags_to_remove)
+
+
+def set_sidedata_spec_for_repo(repo):
+    # prevent cycle metadata -> revlogutils.sidedata -> metadata
+    from .. import metadata
+
+    if requirementsmod.COPIESSDC_REQUIREMENT in repo.requirements:
+        repo.register_wanted_sidedata(SD_FILES)
+    repo.register_sidedata_computer(
+        constants.KIND_CHANGELOG,
+        SD_FILES,
+        (SD_FILES,),
+        metadata.copies_sidedata_computer,
+        flagutil.REVIDX_HASCOPIESINFO,
+    )

mercurial/upgrade_utils/engine.py

@@ -12,7 +12,6 b' import stat'
 from ..i18n import _
 from ..pycompat import getattr
 from .. import (
-    changegroup,
     changelog,
     error,
     filelog,
@@ -45,7 +44,7 b' def get_sidedata_helpers(srcrepo, dstrep'
             flagutil.REVIDX_HASCOPIESINFO,
             replace=True,
         )
-    return changegroup.get_sidedata_helpers(srcrepo, dstrepo._wanted_sidedata)
+    return sidedatamod.get_sidedata_helpers(srcrepo, dstrepo._wanted_sidedata)
 
 
 def _revlogfrompath(repo, rl_type, path):

mercurial/utils/storageutil.py

@@ -499,7 +499,7 b' def emitrevisions('
         sidedata_flags = (0, 0)
         if sidedata_helpers:
             old_sidedata = store.sidedata(rev)
-            sidedata, sidedata_flags = run_sidedata_helpers(
+            sidedata, sidedata_flags = sidedatamod.run_sidedata_helpers(
                 store=store,
                 sidedata_helpers=sidedata_helpers,
                 sidedata=old_sidedata,
@@ -532,30 +532,6 b' def emitrevisions('
         prevrev = rev
 
 
-def run_sidedata_helpers(store, sidedata_helpers, sidedata, rev):
-    """Returns the sidedata for the given revision after running through
-    the given helpers.
-    - `store`: the revlog this applies to (changelog, manifest, or filelog
-      instance)
-    - `sidedata_helpers`: see `storageutil.emitrevisions`
-    - `sidedata`: previous sidedata at the given rev, if any
-    - `rev`: affected rev of `store`
-    """
-    repo, sd_computers, sd_removers = sidedata_helpers
-    kind = store.revlog_kind
-    flags_to_add = 0
-    flags_to_remove = 0
-    for _keys, sd_computer, _flags in sd_computers.get(kind, []):
-        sidedata, flags = sd_computer(repo, store, rev, sidedata)
-        flags_to_add |= flags[0]
-        flags_to_remove |= flags[1]
-    for keys, _computer, flags in sd_removers.get(kind, []):
-        for key in keys:
-            sidedata.pop(key, None)
-        flags_to_remove |= flags
-    return sidedata, (flags_to_add, flags_to_remove)
-
-
 def deltaiscensored(delta, baserev, baselenfn):
     """Determine if a delta represents censored revision data.
 

tests/testlib/ext-sidedata.py

@@ -12,7 +12,6 b' import struct'
 
 from mercurial.node import nullrev
 from mercurial import (
-    changegroup,
     extensions,
     requirements,
     revlog,
@@ -88,7 +87,7 b' def wrapget_sidedata_helpers(orig, srcre'
         )
         dstrepo.register_wanted_sidedata(b"whatever")
 
-    return changegroup.get_sidedata_helpers(srcrepo, dstrepo._wanted_sidedata)
+    return sidedata.get_sidedata_helpers(srcrepo, dstrepo._wanted_sidedata)
 
 
 def extsetup(ui):