hgitaly 2.7.1__tar.gz → 2.8.0__tar.gz

{hgitaly-2.7.1 → hgitaly-2.8.0}/PKG-INFO

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

hgitaly-2.8.0/hgitaly/VERSION

@@ -0,0 +1 @@
+2.8.0

{hgitaly-2.7.1 → hgitaly-2.8.0}/hgitaly/diff.py

@@ -46,17 +46,19 @@ 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):
+def changed_paths(repo, from_ctx, to_ctx, base_path, find_renames=False):
     if base_path is None:
         matcher = None
         path_trim_at = 0
@@ -74,26 +76,33 @@ def changed_paths(repo, from_ctx, to_ctx, base_path):
             patterns=[b'path:' + base_path])
         path_trim_at = len(base_path) + 1
 
-    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)
+    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.
 
     status = from_ctx.status(to_ctx, match=matcher)
-    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):
+    # 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()}
     """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
@@ -102,8 +111,21 @@ def status_changed_paths(from_ctx, to_ctx, status, trim_at=0):
                 old_blob_id = ctx_blob_oid(from_ctx, path)
 
             if stype == 'removed':
-                new_mode = OBJECT_MODE_DOES_NOT_EXIST
-                new_blob_id = NULL_BLOB_OID
+                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
             else:
                 new_mode = git_perms(to_ctx.filectx(path))
                 new_blob_id = ctx_blob_oid(to_ctx, path)
@@ -114,11 +136,13 @@ def status_changed_paths(from_ctx, to_ctx, status, trim_at=0):
                 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):
+def copy_changed_paths(from_ctx, to_ctx, path_copies,
+                       trim_at=0, find_renames=False):
     """Return ChangedPaths for the given paths, relative to base_path.
 
     Given that Gitaly currently (gitaly@c54d613d0) does not pass
@@ -129,8 +153,11 @@ def copy_changed_paths(from_ctx, to_ctx, path_copies, trim_at=0):
     for target, source in path_copies.items():
         yield ChangedPaths(path=target[trim_at:],
                            status=COPIED,
-                           old_mode=git_perms(to_ctx.filectx(source)),
+                           old_mode=git_perms(from_ctx.filectx(source)),
+                           old_blob_id=ctx_blob_oid(from_ctx, 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.7.1 → hgitaly-2.8.0}/hgitaly/message.py

@@ -87,6 +87,10 @@ 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.7.1 → hgitaly-2.8.0}/hgitaly/service/diff.py

@@ -521,8 +521,11 @@ 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)):
+                             for path in changed_paths(
+                                     repo, *extr,
+                                     find_renames=find_renames)):
             yield FindChangedPathsResponse(paths=paths)
 
     def GetPatchID(self, request: GetPatchIDRequest,

{hgitaly-2.7.1 → hgitaly-2.8.0}/hgitaly/service/operations.py

@@ -152,7 +152,27 @@ class OperationServicer(OperationServiceServicer, HGitalyServicer):
                                  False)
             with operation_error_treatment(context, UserSquashError,
                                            logger=logger):
-                self.repo_command(wd.repo, context, 'fold', **opts)
+                retcode = self.repo_command(wd.repo, context, 'fold', **opts)
+                if retcode == 1:
+                    revs = wd.repo.revs(revset)
+                    if len(revs) == 1:
+                        rev = next(iter(revs))
+                        self.repo_command(wd.repo, context, 'update', rev)
+                        self.repo_command(
+                            wd.repo, context, 'amend',
+                            message=message,
+                            note=(b"Description changed for squash request "
+                                  b"for a single changeset"),
+                        )
+                    else:  # pragma no cover
+                        # This block is currently unreachable from tests
+                        # and is here in case of unexpected behaviour change
+                        # in the `fold` command.
+                        context.abort(
+                            StatusCode.INTERNAL,
+                            "Internal return code 1, but zero or more than "
+                            "one changeset for revset %r" % revset
+                        )
             self.repo_command(wd.repo, context, 'update', start_ctx.hex())
             # The workdir repo does not have to be reloaded, whereas the
             # main repo would. We just need to regrab the end changeset

{hgitaly-2.7.1 → hgitaly-2.8.0}/hgitaly/service/ref.py

@@ -28,6 +28,8 @@ 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 (
@@ -40,6 +42,8 @@ from ..pagination import (
 )
 from ..revision import (
     CHANGESET_HASH_BYTES_REGEXP,
+    ZERO_SHA,
+    ZERO_SHA_STR,
     gitlab_revision_hash,
 )
 from ..stream import (
@@ -51,6 +55,7 @@ from ..stub.shared_pb2 import (
 )
 from ..stub.errors_pb2 import (
     ReferenceNotFoundError,
+    ReferenceStateMismatchError,
 )
 from ..stub.ref_pb2 import (
     FindDefaultBranchNameRequest,
@@ -74,6 +79,9 @@ from ..stub.ref_pb2 import (
     FindBranchResponse,
     DeleteRefsRequest,
     DeleteRefsResponse,
+    UpdateReferencesError,
+    UpdateReferencesRequest,
+    UpdateReferencesResponse,
     ListBranchNamesContainingCommitRequest,
     ListBranchNamesContainingCommitResponse,
     ListTagNamesContainingCommitRequest,
@@ -87,9 +95,6 @@ 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,
@@ -273,6 +278,93 @@ 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.7.1 → hgitaly-2.8.0}/hgitaly/service/repository.py

@@ -127,8 +127,6 @@ from ..stub.repository_pb2 import (
     SetCustomHooksResponse,
     WriteRefRequest,
     WriteRefResponse,
-    ApplyGitattributesRequest,
-    ApplyGitattributesResponse,
 )
 from ..stub.repository_pb2_grpc import RepositoryServiceServicer
 from ..stub.shared_pb2 import (
@@ -382,15 +380,6 @@ class RepositoryServicer(RepositoryServiceServicer, HGitalyServicer):
         set_default_gitlab_branch(repo, target_branch)
         return WriteRefResponse()
 
-    def ApplyGitattributes(self, request: ApplyGitattributesRequest,
-                           context) -> ApplyGitattributesResponse:
-        """Method used as testing bed for the `not_implemented` helper.
-
-        It is unlikely we ever implement this one, and if we do something
-        similar, we'll probably end up defining a ApplyHgAttributes anyway.
-        """
-        not_implemented(context, issue=1234567)
-
     def CreateRepository(self, request: CreateRepositoryRequest,
                          context) -> CreateRepositoryResponse:
         default_branch = request.default_branch
@@ -588,7 +577,7 @@ class RepositoryServicer(RepositoryServiceServicer, HGitalyServicer):
         if not os.path.exists(repo_path):
             # same error message as Gitaly (probably no need to repeat
             # repo details, since request often logged client-side)
-            context.abort(StatusCode.NOT_FOUND, "repository does not exist")
+            context.abort(StatusCode.NOT_FOUND, "repository not found")
 
         trash_path = os.path.join(
             self.temp_dir(request.repository.storage_name, context),

{hgitaly-2.7.1 → hgitaly-2.8.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=()):
+    def find_changed_paths_commits(self, commits, compare_to=(), **kw):
         """Wrap FindChangedPaths used with CommitRequest.
 
         :param compare_to: if given, will be used in all requests, hoping
@@ -141,6 +141,7 @@ 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):
@@ -686,6 +687,50 @@ 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.7.1 → hgitaly-2.8.0}/hgitaly/service/tests/test_operations.py

@@ -151,6 +151,16 @@ def test_user_squash(operations_fixture, project_mode, timestamp):
             squash(**kw)
         assert exc_info.value.code() == StatusCode.INVALID_ARGUMENT
 
+    amend_msg = b'squash becomes an amend!'
+    resp = squash(start_sha=sha1,
+                  end_sha=folded_sha,
+                  author=author,
+                  commit_message=amend_msg)
+    amended_sha = resp.squash_sha.encode('ascii')
+    wrapper.reload()
+    amended_ctx = wrapper.repo[amended_sha]
+    assert amended_ctx.description() == amend_msg
+
 
 @parametrize('project_mode', ('hg-git-project',
                               'native-project-without-git',

{hgitaly-2.7.1 → hgitaly-2.8.0}/hgitaly/service/tests/test_ref.py

@@ -30,6 +30,7 @@ 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 (
@@ -56,6 +57,7 @@ from hgitaly.stub.ref_pb2 import (
     FindRefsByOIDRequest,
     FindTagError,
     FindTagRequest,
+    UpdateReferencesRequest,
 )
 from hgitaly.stub.ref_pb2_grpc import RefServiceStub
 
@@ -85,6 +87,10 @@ 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(
@@ -97,6 +103,22 @@ 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):
@@ -633,3 +655,58 @@ 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)