hgitaly 2.5.4__tar.gz → 2.6.0__tar.gz

{hgitaly-2.5.4 → hgitaly-2.6.0}/.hgtags

@@ -118,4 +118,3 @@ a118debbf0a0deaa94b02ed0007ab2ef0f2b73c3 2.4.0
 c1b00e1bc1bf0a2d41907b345c48cf795f910a4f 2.5.0
 136dff98ddc1315e6db9479d9b6dd2c2204c2e5f 2.5.1
 7dbcba18d83708ff81d8cec9696a86d24ed5d20a 2.5.2
-3a83836b7408f1318a80f1ba97051086596edd12 2.5.3

{hgitaly-2.5.4 → hgitaly-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hgitaly
-Version: 2.5.4
+Version: 2.6.0
 Summary: Server-side implementation of Gitaly protocol for Mercurial
 Home-page: https://foss.heptapod.net/heptapod/hgitaly
 Author: Georges Racinet

hgitaly-2.6.0/hgitaly/VERSION

@@ -0,0 +1 @@
+2.6.0

{hgitaly-2.5.4 → hgitaly-2.6.0}/hgitaly/diff.py

@@ -46,19 +46,17 @@ Status_Type_Map = dict(
     added=ChangedPaths.Status.ADDED,
     modified=ChangedPaths.Status.MODIFIED,
     removed=ChangedPaths.Status.DELETED,
-    renamed=ChangedPaths.Status.RENAMED,
     # Note: Mercurial includes TYPE_CHANGE
     # (symlink, regular file, submodule...etc) in MODIFIED status
 )
 """Mapping status object attributes to ChangedPaths enum."""
 
 COPIED = ChangedPaths.Status.COPIED
-RENAMED = ChangedPaths.Status.RENAMED
 DIFF_HUNKS_START_RX = re.compile(rb'^(--- )|^(Binary file)')
 """To match the header line right before hunks start getting dumped."""
 
 
-def changed_paths(repo, from_ctx, to_ctx, base_path, find_renames=False):
+def changed_paths(repo, from_ctx, to_ctx, base_path):
     if base_path is None:
         matcher = None
         path_trim_at = 0
@@ -76,33 +74,26 @@ def changed_paths(repo, from_ctx, to_ctx, base_path, find_renames=False):
             patterns=[b'path:' + base_path])
         path_trim_at = len(base_path) + 1
 
-    copy_info = copies.pathcopies(from_ctx, to_ctx, match=matcher)
-    # copies do not distinguish actual copies from renames. The difference
-    # will be that a rename goes with deletion of the original.
+    copied = list(copy_changed_paths(
+        from_ctx,
+        to_ctx,
+        copies.pathcopies(from_ctx, to_ctx, match=matcher),
+        trim_at=path_trim_at))
+    copied_paths = set(cp.path for cp in copied)
 
     status = from_ctx.status(to_ctx, match=matcher)
-    # this will remove renames from copy_info, keeping only actual copies
-    yield from status_changed_paths(from_ctx, to_ctx, status, copy_info,
-                                    find_renames=find_renames,
-                                    trim_at=path_trim_at)
-    yield from copy_changed_paths(from_ctx,
-                                  to_ctx,
-                                  copy_info,
-                                  trim_at=path_trim_at)
-
-
-def status_changed_paths(from_ctx, to_ctx, status, copy_info,
-                         find_renames=False, trim_at=0):
-    rcopy_info = {v: k for k, v in copy_info.items()}
+    for path in status_changed_paths(from_ctx, to_ctx, status,
+                                     trim_at=path_trim_at):
+        if path.path not in copied_paths:
+            yield path
+
+    yield from iter(copied)
+
+
+def status_changed_paths(from_ctx, to_ctx, status, trim_at=0):
     """Return ChangedPaths from Mercurial status object"""
     for stype in ['added', 'modified', 'removed']:
         for path in status.__getattribute__(stype):
-            copied_from = copy_info.get(path)
-            if copied_from is not None:
-                if copied_from not in status.removed or find_renames:
-                    continue
-
-            old_path = b''
             if stype == 'added':
                 old_mode = OBJECT_MODE_DOES_NOT_EXIST
                 old_blob_id = NULL_BLOB_OID
@@ -111,21 +102,8 @@ def status_changed_paths(from_ctx, to_ctx, status, copy_info,
                 old_blob_id = ctx_blob_oid(from_ctx, path)
 
             if stype == 'removed':
-                new_path = rcopy_info.get(path)
-                if new_path is None:
-                    new_mode = OBJECT_MODE_DOES_NOT_EXIST
-                    new_blob_id = NULL_BLOB_OID
-                else:
-                    del copy_info[new_path]
-                    if find_renames:
-                        stype = 'renamed'
-                        old_path = path
-                        path = new_path
-                        new_mode = git_perms(to_ctx.filectx(new_path))
-                        new_blob_id = ctx_blob_oid(to_ctx, new_path)
-                    else:
-                        new_mode = OBJECT_MODE_DOES_NOT_EXIST
-                        new_blob_id = NULL_BLOB_OID
+                new_mode = OBJECT_MODE_DOES_NOT_EXIST
+                new_blob_id = NULL_BLOB_OID
             else:
                 new_mode = git_perms(to_ctx.filectx(path))
                 new_blob_id = ctx_blob_oid(to_ctx, path)
@@ -136,13 +114,11 @@ def status_changed_paths(from_ctx, to_ctx, status, copy_info,
                 new_mode=new_mode,
                 old_blob_id=old_blob_id,
                 new_blob_id=new_blob_id,
-                old_path=old_path,
                 status=Status_Type_Map[stype]
             )
 
 
-def copy_changed_paths(from_ctx, to_ctx, path_copies,
-                       trim_at=0, find_renames=False):
+def copy_changed_paths(from_ctx, to_ctx, path_copies, trim_at=0):
     """Return ChangedPaths for the given paths, relative to base_path.
 
     Given that Gitaly currently (gitaly@c54d613d0) does not pass
@@ -153,11 +129,8 @@ def copy_changed_paths(from_ctx, to_ctx, path_copies,
     for target, source in path_copies.items():
         yield ChangedPaths(path=target[trim_at:],
                            status=COPIED,
-                           old_mode=git_perms(from_ctx.filectx(source)),
-                           old_blob_id=ctx_blob_oid(from_ctx, source),
+                           old_mode=git_perms(to_ctx.filectx(source)),
                            new_mode=git_perms(to_ctx.filectx(target)),
-                           new_blob_id=ctx_blob_oid(to_ctx, target),
-                           old_path=source[trim_at:],
                            )
 
 

{hgitaly-2.5.4 → hgitaly-2.6.0}/hgitaly/message.py

@@ -87,10 +87,6 @@ def message_to_string(message):
     return result
 
 
-def as_dict(message):
-    return {descr.name: value for descr, value in message.ListFields()}
-
-
 class Logging:
     """Wrapper of requests and responses for sensible logging.
 

{hgitaly-2.5.4 → hgitaly-2.6.0}/hgitaly/service/diff.py

@@ -521,11 +521,8 @@ class DiffServicer(DiffServiceServicer, HGitalyServicer):
                                        for cp in cids_paths]
                 extracted.append((left_ctx, right_ctx, path))
 
-        find_renames = request.find_renames
         for paths in chunked(path for extr in extracted
-                             for path in changed_paths(
-                                     repo, *extr,
-                                     find_renames=find_renames)):
+                             for path in changed_paths(repo, *extr)):
             yield FindChangedPathsResponse(paths=paths)
 
     def GetPatchID(self, request: GetPatchIDRequest,

{hgitaly-2.5.4 → hgitaly-2.6.0}/hgitaly/service/mercurial_operations.py

@@ -285,19 +285,18 @@ class MercurialOperationsServicer(MercurialOperationsServiceServicer,
                         new_oid=current_head_id,
                     )))
 
-        same_branch = to_merge.branch() == current_head.branch()
-        linear = ancestor(to_merge, current_head) == current_head.rev()
-        if same_branch and linear and not request.semi_linear:
+        if ancestor(to_merge, current_head) == current_head.rev():
             # fast-forwardable!
-            logger.info("This is actually a fast-forward, all checks "
-                        "passed, now publishing %r, mirroring to Git=%r",
-                        to_merge, with_hg_git)
-            self.publish(to_merge, context)
-            return MergeBranchResponse(
-                branch_update=OperationBranchUpdate(
-                    commit_id=to_merge.hex().decode('ascii'),
-                ))
-        elif request.semi_linear and not linear:
+            if not request.semi_linear:
+                logger.info("This is actually a fast-forward, all checks "
+                            "passed, now publishing %r, mirroring to Git=%r",
+                            to_merge, with_hg_git)
+                self.publish(to_merge, context)
+                return MergeBranchResponse(
+                    branch_update=OperationBranchUpdate(
+                        commit_id=to_merge.hex().decode('ascii'),
+                    ))
+        elif request.semi_linear:
             structured_abort(
                 context, StatusCode.FAILED_PRECONDITION,
                 "Not fast-forwardable",

{hgitaly-2.5.4 → hgitaly-2.6.0}/hgitaly/service/ref.py

@@ -28,8 +28,6 @@ from hgext3rd.heptapod.special_ref import (
 )
 from hgext3rd.heptapod.keep_around import (
     parse_keep_around_ref,
-    iter_keep_arounds,
-    init_keep_arounds,
 )
 
 from ..errors import (
@@ -42,8 +40,6 @@ from ..pagination import (
 )
 from ..revision import (
     CHANGESET_HASH_BYTES_REGEXP,
-    ZERO_SHA,
-    ZERO_SHA_STR,
     gitlab_revision_hash,
 )
 from ..stream import (
@@ -55,7 +51,6 @@ from ..stub.shared_pb2 import (
 )
 from ..stub.errors_pb2 import (
     ReferenceNotFoundError,
-    ReferenceStateMismatchError,
 )
 from ..stub.ref_pb2 import (
     FindDefaultBranchNameRequest,
@@ -79,9 +74,6 @@ from ..stub.ref_pb2 import (
     FindBranchResponse,
     DeleteRefsRequest,
     DeleteRefsResponse,
-    UpdateReferencesError,
-    UpdateReferencesRequest,
-    UpdateReferencesResponse,
     ListBranchNamesContainingCommitRequest,
     ListBranchNamesContainingCommitResponse,
     ListTagNamesContainingCommitRequest,
@@ -95,6 +87,9 @@ from ..stub.ref_pb2 import (
 )
 from ..stub.ref_pb2_grpc import RefServiceServicer
 
+from ..revision import (
+    ZERO_SHA_STR,
+)
 from ..branch import (
     BranchSortBy,
     gitlab_branch_head,
@@ -278,93 +273,6 @@ class RefServicer(RefServiceServicer, HGitalyServicer):
         return FindBranchResponse(
             branch=Branch(name=name, target_commit=message.commit(head)))
 
-    def UpdateReferences(self,
-                         request: UpdateReferencesRequest,
-                         context) -> UpdateReferencesResponse:
-        self.STATUS_CODE_STORAGE_NOT_FOUND = StatusCode.INVALID_ARGUMENT
-        first = True
-        special_changes = []
-        ka_changes = []
-        for req in request:
-            if first:
-                # blobs are given by oid, hence as in direct changeset Node
-                # IDs, the unfiltered repo is the right one for the task
-                repo = self.load_repo(req.repository, context).unfiltered()
-                first = False
-
-            for upd in req.updates:
-                if len(upd.new_object_id) != 40:
-                    oid = upd.new_object_id.decode('ascii', 'replace')
-                    context.abort(StatusCode.INVALID_ARGUMENT,
-                                  "validating new object ID: "
-                                  f'invalid object ID: "{oid}", '
-                                  f"expected length 40, got {len(oid)}")
-
-                ref_path = upd.reference
-                change = (upd.old_object_id, upd.new_object_id)
-                if change[0] == change[1]:
-                    # let's not waste resources for this
-                    continue
-
-                # consider only special refs and keep-arounds, as other refs
-                # (branches and tags) are only reflecting changesets content,
-                # setting them independently makes no sense with Mercurial
-                special_ref = parse_special_ref(ref_path)
-                if special_ref is not None:
-                    special_changes.append((special_ref, change))
-                    continue
-
-                ka = parse_keep_around_ref(upd.reference)
-                if ka is not None:
-                    if (
-                            upd.new_object_id != ZERO_SHA
-                            and ka != upd.new_object_id
-                    ):
-                        context.abort(StatusCode.INVALID_ARGUMENT,
-                                      "Inconsistent keep-around.")
-                    ka_changes.append(change)
-
-        with repo.lock():
-            # keeping promise of atomicity of this method
-            special_existing = special_refs(repo)
-            if special_existing is GITLAB_TYPED_REFS_MISSING:
-                special_existing = {}
-            for name, (old_id, new_id) in special_changes:
-                existing = special_existing.get(name)
-                if old_id == ZERO_SHA and existing is not None:
-                    context.abort(StatusCode.INTERNAL,
-                                  "committing update: "
-                                  "reference already exists")
-                elif old_id and old_id != ZERO_SHA and existing != old_id:
-                    Mismatch = ReferenceStateMismatchError  # just too long!
-                    structured_abort(
-                        context, StatusCode.ABORTED,
-                        "reference does not point to expected object",
-                        UpdateReferencesError(
-                            reference_state_mismatch=Mismatch(
-                                reference_name=b'refs/' + name,
-                                expected_object_id=old_id,
-                                actual_object_id=existing)))
-                elif new_id == ZERO_SHA:
-                    del special_existing[name]
-                else:
-                    special_existing[name] = new_id
-
-            # TODO make a collect_keep_arounds() or keep_arounds_set()
-            ka_existing = set(iter_keep_arounds(repo))
-            ka_existing.discard(GITLAB_TYPED_REFS_MISSING)
-            for old_id, new_id in ka_changes:
-                # bogus requests have already been prohibited
-                if new_id == ZERO_SHA:
-                    ka_existing.discard(old_id)
-                else:
-                    ka_existing.add(new_id)
-
-            write_special_refs(repo, special_existing)
-            init_keep_arounds(repo, ka_existing)
-
-        return UpdateReferencesResponse()
-
     def DeleteRefs(self,
                    request: DeleteRefsRequest,
                    context) -> DeleteRefsResponse:

{hgitaly-2.5.4 → hgitaly-2.6.0}/hgitaly/service/tests/test_diff.py

@@ -127,7 +127,7 @@ class DiffFixture(ServiceFixture):
                     (changed.status, perm_change))
         return by_file
 
-    def find_changed_paths_commits(self, commits, compare_to=(), **kw):
+    def find_changed_paths_commits(self, commits, compare_to=()):
         """Wrap FindChangedPaths used with CommitRequest.
 
         :param compare_to: if given, will be used in all requests, hoping
@@ -141,7 +141,6 @@ class DiffFixture(ServiceFixture):
                         commit_revision=c,
                         parent_commit_revisions=compare_to))
                 for c in commits],
-            **kw
         )
 
     def find_changed_paths_tree(self, left_oid, right_oid):
@@ -687,50 +686,6 @@ def test_find_changed_paths_copy_in_tree(diff_fixture):
     }
 
 
-def test_find_changed_paths_rename(diff_fixture):
-    wrapper = diff_fixture.repo_wrapper
-
-    (wrapper.path / 'subdir').mkdir()  # avoid all lengths to be 3
-    (wrapper.path / 'subdir/bar').write_text('some bar')
-    ctx0 = wrapper.commit(rel_paths=['subdir'], add_remove=True)
-
-    wrapper.command(b'mv', wrapper.repo.root + b'/subdir/bar',
-                    wrapper.repo.root + b'/subdir/baz')
-    ctx1 = wrapper.commit(rel_paths=['subdir'])
-
-    repo = wrapper.repo
-
-    sub0_oid, sub1_oid = [tree_oid(repo, ctx.hex().decode('ascii'), b'subdir')
-                          for ctx in (ctx0, ctx1)]
-    ret = diff_fixture.find_changed_paths_commits(
-        [ctx1.hex()],
-        compare_to=[ctx0.hex()],
-        find_renames=False,
-    )
-    assert ret == {
-        b'subdir/baz': [(ChangedPaths.Status.ADDED,
-                         (OBJECT_MODE_DOES_NOT_EXIST,
-                          OBJECT_MODE_NON_EXECUTABLE),
-                         )],
-        b'subdir/bar': [(ChangedPaths.Status.DELETED,
-                         (OBJECT_MODE_NON_EXECUTABLE,
-                          OBJECT_MODE_DOES_NOT_EXIST)
-                         )],
-    }
-
-    ret = diff_fixture.find_changed_paths_commits(
-        [ctx1.hex()],
-        compare_to=[ctx0.hex()],
-        find_renames=True,
-    )
-    assert ret == {
-        b'subdir/baz': [(ChangedPaths.Status.RENAMED, None)],
-    }
-
-    # TODO test the case of rename with duplication:
-    # hg cp foo bar; hg mv foo bar2
-
-
 def test_get_patch_id(diff_fixture):
     wrapper = diff_fixture.repo_wrapper
     patch_id = diff_fixture.get_patch_id

{hgitaly-2.5.4 → hgitaly-2.6.0}/hgitaly/service/tests/test_mercurial_operations.py

@@ -22,7 +22,6 @@ from hgext3rd.heptapod.branch import (
 )
 from heptapod.testhelpers.git import GitRepo
 
-from hgitaly.changelog import ancestor
 from hgitaly.errors import (
     parse_assert_structured_error,
 )
@@ -460,56 +459,6 @@ def test_merge_branch(operations_fixture, project_mode):
     assert conflict_error.conflicting_files == [b'foo']
 
 
-@parametrize('project_mode', ('hg-git-project',
-                              'native-project-without-git',
-                              'native-project-with-git',
-                              ))
-@parametrize('semi_lin_req', ('semi_linear_req', 'classical_req'))
-def test_merge_linear_named_branch(operations_fixture,
-                                   project_mode,
-                                   semi_lin_req):
-    fixture = operations_fixture
-    merge = fixture.merge_branch
-
-    fixture.hg_native = project_mode != 'hg-git-project'
-    if fixture.hg_native:
-        fixture.with_hg_git_mirroring = (
-            project_mode == 'native-project-with-git'
-        )
-    wrapper = fixture.repo_wrapper
-
-    gl_branch = b'branch/default'
-
-    # because of the config set by fixture, this leads in all cases to
-    # creation of a Git repo and its `branch/default` Git branch
-    ctx0 = wrapper.commit_file('foo')
-
-    linear_branch = b'linear'
-    linear_branch_ctx = wrapper.commit_file('foolin',
-                                            branch=linear_branch,
-                                            parent=ctx0)
-    # just checking what we just did
-    assert ancestor(linear_branch_ctx, ctx0) == ctx0.rev()
-
-    merge_msg = b"Actual merge for a named branch that makes linear history"
-    resp = merge(branch=gl_branch,
-                 commit_id=linear_branch_ctx.hex().decode('ascii'),
-                 semi_linear=semi_lin_req == 'semi_linear_req',
-                 hg_perms=PUBLISH_PERM,
-                 message=merge_msg)
-    wrapper.reload()
-
-    merge_sha = resp.branch_update.commit_id
-    assert merge_sha
-    merge_changeset = wrapper.repo[merge_sha.encode()]
-    assert merge_changeset.branch() == b'default'
-    assert merge_changeset.phase() == phases.public
-    assert gitlab_branches(wrapper.repo)[gl_branch] == merge_changeset.hex()
-    assert merge_changeset.p1().hex() == ctx0.hex()
-    assert merge_changeset.p2().hex() == linear_branch_ctx.hex()
-    assert merge_changeset.description() == merge_msg
-
-
 @parametrize('project_mode', ('hg-git-project',
                               'native-project-without-git',
                               'native-project-with-git',

{hgitaly-2.5.4 → hgitaly-2.6.0}/hgitaly/service/tests/test_ref.py

@@ -30,7 +30,6 @@ from hgext3rd.heptapod.keep_around import (
 from hgitaly import feature
 from hgitaly.errors import parse_assert_structured_error
 from hgitaly.revision import (
-    ZERO_SHA,
     ZERO_SHA_STR,
 )
 from hgitaly.tests.common import (
@@ -57,7 +56,6 @@ from hgitaly.stub.ref_pb2 import (
     FindRefsByOIDRequest,
     FindTagError,
     FindTagRequest,
-    UpdateReferencesRequest,
 )
 from hgitaly.stub.ref_pb2_grpc import RefServiceStub
 
@@ -87,10 +85,6 @@ class RefFixture(ServiceFixture):
             metadata=feature.as_grpc_metadata(self.feature_flags),
         )
 
-    def ref_exists(self, ref, **kw):
-        kw.setdefault('repository', self.grpc_repo)
-        return self.stub.RefExists(RefExistsRequest(ref=ref, **kw)).value
-
     def list_refs(self, patterns=(b"refs/", ), **kw):
         return [(ref.name, ref.target)
                 for resp in self.stub.ListRefs(
@@ -103,22 +97,6 @@ class RefFixture(ServiceFixture):
         kw.setdefault('repository', self.grpc_repo)
         return self.stub.FindRefsByOID(FindRefsByOIDRequest(**kw)).refs
 
-    def update_refs(self, updates, **kw):
-        Update = UpdateReferencesRequest.Update
-        kw.setdefault('repository', self.grpc_repo)
-
-        update_messages = []
-        for ref_path, old_id, new_id in updates:
-            upd_kw = dict(reference=ref_path, new_object_id=new_id)
-            if old_id is not None:
-                upd_kw['old_object_id'] = old_id
-            update_messages.append(Update(**upd_kw))
-
-        return self.stub.UpdateReferences(
-            iter([UpdateReferencesRequest(updates=[upd], **kw)
-                  for upd in update_messages])
-        )
-
 
 @pytest.fixture
 def ref_fixture(grpc_channel, server_repos_root):
@@ -655,58 +633,3 @@ def test_list_refs(ref_fixture):
     assert fixture.find_refs_by_oid(
         oid=sha1, sort_field='refname', limit=1
     ) == ['refs/heads/branch/default']
-
-
-def test_update_references(ref_fixture):
-    fixture = ref_fixture
-    wrapper = fixture.repo_wrapper
-
-    sha0 = wrapper.write_commit('afoo', message="Some foo").hex()
-    sha1 = wrapper.write_commit('afoo', message="Some foo").hex()
-
-    pipeline_1 = b'refs/pipelines/1'
-    ka_0 = b'refs/keep-around/' + sha0
-    fixture.update_refs([(pipeline_1, ZERO_SHA, sha1),
-                         (ka_0, ZERO_SHA, sha0),
-                         ])
-    assert fixture.ref_exists(ka_0)
-    assert fixture.ref_exists(pipeline_1)
-    assert fixture.list_refs(patterns=[b'refs/pipelines/']) == [
-        (pipeline_1, sha1.decode())
-    ]
-
-    fixture.update_refs([(pipeline_1, sha1, sha0),
-                         (ka_0, sha0, ZERO_SHA),
-                         ])
-    assert not fixture.ref_exists(ka_0)
-    assert fixture.list_refs(patterns=[b'refs/pipelines/']) == [
-        (pipeline_1, sha0.decode())
-    ]
-
-    # edge case equivalent to no-op
-    fixture.update_refs([(pipeline_1, sha0, sha0)])
-    assert fixture.list_refs(patterns=[b'refs/pipelines/']) == [
-        (pipeline_1, sha0.decode())
-    ]
-
-    # error cases
-    with pytest.raises(grpc.RpcError) as exc_info:
-        fixture.update_refs([(pipeline_1, None, b'branch/default')])
-    assert exc_info.value.code() == grpc.StatusCode.INVALID_ARGUMENT
-
-    with pytest.raises(grpc.RpcError) as exc_info:
-        fixture.update_refs([(ka_0, None, sha1)])
-    assert exc_info.value.code() == grpc.StatusCode.INVALID_ARGUMENT
-
-    with pytest.raises(grpc.RpcError) as exc_info:
-        fixture.update_refs([(pipeline_1, ZERO_SHA, sha1)])
-    assert exc_info.value.code() == grpc.StatusCode.INTERNAL
-    assert 'reference already exists' in exc_info.value.details()
-
-    with pytest.raises(grpc.RpcError) as exc_info:
-        fixture.update_refs([(pipeline_1, sha1, sha0)])
-    assert exc_info.value.code() == grpc.StatusCode.ABORTED
-
-    # deletions
-    fixture.update_refs([(pipeline_1, sha0, ZERO_SHA)])
-    assert not fixture.ref_exists(pipeline_1)