hgitaly 18.7.0__tar.gz → 18.7.0a0__tar.gz

{hgitaly-18.7.0/hgitaly.egg-info → hgitaly-18.7.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hgitaly
-Version: 18.7.0
+Version: 18.7.0a0
 Summary: Server-side implementation of Gitaly protocol for Mercurial
 Home-page: https://foss.heptapod.net/heptapod/hgitaly
 Author: Georges Racinet
@@ -10,7 +10,7 @@ Keywords: hg mercurial heptapod gitlab
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: heptapod~=5.5.0
+Requires-Dist: heptapod>=5.4.0
 Requires-Dist: protobuf~=6.31.1
 Requires-Dist: grpcio~=1.76.0
 Requires-Dist: grpcio-status~=1.76.0

{hgitaly-18.7.0 → hgitaly-18.7.0a0}/functional_tests/test_blob_tree.py

@@ -108,9 +108,9 @@ def oid_normalizer(oid2git):
     return normalizer
 
 
-def test_compare_tree_entry_request(gitaly_rhgitaly_comparison):
+@parametrize('hg_server', ('hgitaly', 'rhgitaly'))
+def test_compare_tree_entry_request(gitaly_rhgitaly_comparison, hg_server):
     fixture = gitaly_rhgitaly_comparison
-    hg_server = 'rhgitaly'
 
     wrapper = fixture.hg_repo_wrapper
     wrapper.write_commit('foo', message="Some foo")
@@ -302,9 +302,10 @@ def test_compare_tree_entry_request(gitaly_rhgitaly_comparison):
                        )
 
 
-def test_compare_get_tree_entries_pagination(gitaly_rhgitaly_comparison):
+@parametrize('hg_server', ('hgitaly', 'rhgitaly'))
+def test_compare_get_tree_entries_pagination(gitaly_rhgitaly_comparison,
+                                             hg_server):
     fixture = gitaly_rhgitaly_comparison
-    hg_server = 'rhgitaly'
 
     wrapper = fixture.hg_repo_wrapper
     wrapper.write_commit('foo', message="Some foo")

{hgitaly-18.7.0 → hgitaly-18.7.0a0}/functional_tests/test_commit.py

@@ -406,7 +406,8 @@ def test_compare_list_files(gitaly_comparison):
         rpc_helper.assert_compare(revision=rev)
 
 
-def test_compare_find_commit(gitaly_rhgitaly_comparison):
+@parametrize('hg_server', ('hgitaly', 'rhgitaly'))
+def test_compare_find_commit(gitaly_rhgitaly_comparison, hg_server):
     fixture = gitaly_rhgitaly_comparison
     wrapper = fixture.hg_repo_wrapper
 
@@ -415,7 +416,7 @@ def test_compare_find_commit(gitaly_rhgitaly_comparison):
             normalize_commit_message(response.commit)
 
     rpc_helper = fixture.rpc_helper(
-        hg_server='rhgitaly',
+        hg_server=hg_server,
         stub_cls=CommitServiceStub,
         method_name='FindCommit',
         request_cls=FindCommitRequest,
@@ -720,7 +721,7 @@ def test_compare_list_commits(gitaly_comparison):
     #
     #   @    4 (branch/default) merge with stable
     #   |\
-    #   | o  3 creates 'animals' (branch/stable)
+    #   | o  3 creates 'animal' (branch/stable)
     #   | |
     #   o |  2 rename 'foo' to 'zoo' (user: testuser)
     #   |/
@@ -811,18 +812,6 @@ def test_compare_list_commits(gitaly_comparison):
     # no result
     assert_compare(revisions=[ctx4.hex(), caret(ctx4)])
 
-    # with paths
-    assert_compare(revisions=[ctx4.hex()], paths=[b'animals'])
-    assert_compare(revisions=[ctx4.hex()], paths=[b'foo'])
-    assert_compare(revisions=[ctx4.hex()], paths=[b'zoo'])
-    assert_compare(revisions=[ctx3.hex(), ctx2.hex()],
-                   paths=[b'animals', b'zoo'])
-    assert_compare(revisions=[ctx4.hex()], paths=[b'anim*'])
-    # with two paths, Git starts returning the merge
-    # but Mercurial does not. This seems more consistent on the Mercurial
-    # side, so we won't compare. It would be:
-    #    assert_compare(revisions=[ctx4.hex()], paths=[b'anim*', b'foo'])
-
     # orderings
     #
     # Comparison is limited because Mercurial orderings don't exactly

{hgitaly-18.7.0 → hgitaly-18.7.0a0}/functional_tests/test_ref.py

@@ -122,7 +122,6 @@ def test_update_references(gitaly_rhgitaly_comparison,
             normalize_commit_message(response.commit)
 
     find_commit_helper = fixture.rpc_helper(
-        hg_server='rhgitaly',
         stub_cls=CommitServiceStub,
         method_name='FindCommit',
         request_cls=FindCommitRequest,

{hgitaly-18.7.0 → hgitaly-18.7.0a0}/functional_tests/test_repository_service.py

@@ -77,7 +77,8 @@ TESTS_DATA_DIR = Path(__file__).parent / 'data'
 TIP_TAG_NAME = b'tip'
 
 
-def test_compare_find_merge_base(gitaly_rhgitaly_comparison):
+@parametrize('hg_server', ('hgitaly', 'rhgitaly'))
+def test_compare_find_merge_base(gitaly_rhgitaly_comparison, hg_server):
     fixture = gitaly_rhgitaly_comparison
     gitaly_repo = fixture.gitaly_repo
     git_repo = fixture.git_repo
@@ -111,7 +112,10 @@ def test_compare_find_merge_base(gitaly_rhgitaly_comparison):
                                parent=node_mod.nullid).hex()
     git_shas[sha4] = git_repo.branches()[b'branch/other']['sha']
 
-    hgitaly_channel = fixture.rhgitaly_channel
+    if hg_server == 'rhgitaly':
+        hgitaly_channel = fixture.rhgitaly_channel
+    else:
+        hgitaly_channel = fixture.hgitaly_channel
     diff_stubs = dict(
         git=RepositoryServiceStub(fixture.gitaly_channel),
         hg=RepositoryServiceStub(hgitaly_channel),
@@ -361,10 +365,11 @@ def test_repository_size(gitaly_comparison,
                                                 relative_path='/some/path'))
 
 
+@parametrize('hg_server', ('hgitaly', 'rhgitaly'))
 def test_has_local_branches(gitaly_rhgitaly_comparison,
-                            server_repos_root):
+                            server_repos_root,
+                            hg_server):
     fixture = gitaly_rhgitaly_comparison
-    hg_server = 'rhgitaly'
     grpc_repo = fixture.gitaly_repo
     rpc_helper = fixture.rpc_helper(
         hg_server=hg_server,
@@ -377,11 +382,6 @@ def test_has_local_branches(gitaly_rhgitaly_comparison,
 
     assert_compare(repository=grpc_repo)
 
-    wrapper = fixture.hg_repo_wrapper
-    wrapper.commit_file('foo')
-    wrapper.command('gitlab-mirror')
-    assert_compare(repository=grpc_repo)
-
     # repo does not exist
     assert_compare_errors(
         same_details=False,
@@ -657,9 +657,9 @@ def test_create_bundle_from_ref_list(
         assert not target_repo_path(vcs, 'broken-bundle').exists()
 
 
-def test_search_files_by_name(gitaly_rhgitaly_comparison):
+@parametrize('hg_server', ('hgitaly', 'rhgitaly'))
+def test_search_files_by_name(gitaly_rhgitaly_comparison, hg_server):
     fixture = gitaly_rhgitaly_comparison
-    hg_server = 'rhgitaly'
 
     wrapper = fixture.hg_repo_wrapper
     ctx0 = wrapper.write_commit('afoo', message="Some foo")
@@ -841,7 +841,6 @@ def test_write_ref(gitaly_rhgitaly_comparison, server_repos_root, hg_server):
             normalize_commit_message(response.commit)
 
     find_commit_helper = fixture.rpc_helper(
-        hg_server='rhgitaly',
         stub_cls=CommitServiceStub,
         method_name='FindCommit',
         request_cls=FindCommitRequest,

hgitaly-18.7.0a0/hgitaly/VERSION

@@ -0,0 +1 @@
+18.7.0a0

{hgitaly-18.7.0 → hgitaly-18.7.0a0}/hgitaly/gitlab_ref.py

@@ -13,6 +13,7 @@ utilities about refs, i.e, anything about a full ref path, such as
 or tags.
 """
 from fnmatch import fnmatch
+import os
 import re
 
 from heptapod.gitlab.branch import gitlab_branch_ref
@@ -22,6 +23,8 @@ from hgext3rd.heptapod.branch import (
     get_default_gitlab_branch,
 )
 from hgext3rd.heptapod.tag import gitlab_tags
+from hgext3rd.heptapod import ensure_gitlab_special_refs
+from hgext3rd.heptapod import ensure_gitlab_keep_arounds
 from hgext3rd.heptapod.special_ref import (
     GITLAB_TYPED_REFS_MISSING,
     parse_special_ref,
@@ -37,6 +40,33 @@ from hgext3rd.heptapod.keep_around import (
 DOT_HG_RX = re.compile(br'\.hg$')
 
 
+def has_legacy_git_repo(repo):
+    """Return whether there is a legacy Git repo for this Mercurial repo.
+
+    With "legacy" here is meant the Git repository for a non-native project.
+    Git repositories meant for mirroring are *not* included in this scope.
+
+    As of Heptapod 17.6, this is the best way to know without direct indication
+    (from the inside) that a repository is not legacy (hg-git based).
+    The reverse implication is false, as there are loopholes:
+
+    - leftover Git repositories for Projects that have migrated to native
+    - native projects with addition conversion for mirrors whose Git
+      repositories have not been moved yet (bug, time to run the migration,
+      etc.)
+
+    The caller must be aware of these loopholes and avoid overwriting existing
+    data based on the legacy Git repo. In the intended case where this is to
+    decide on calling the `ensure` methods, this means it is ok only if there
+    is no existing data.
+    """
+    # if a repository is legacy, based on hg-git conversion, is whether
+    # it has a `.git` repository at the same location. Git repositories
+    # for mirroring are in a different place
+    git_path = DOT_HG_RX.sub(b'', repo.root) + b'.git'
+    return os.path.exists(git_path)
+
+
 def gitlab_special_ref_target(repo, ref_path):
     """Return the changeset for a special ref.
 
@@ -105,6 +135,8 @@ def iter_gitlab_special_refs_as_refs(repo, deref=True, patterns=None):
     """
     all_special_refs = special_refs(repo)
     if all_special_refs is GITLAB_TYPED_REFS_MISSING:
+        # transitional while we still have an inner Git repo
+        # would still be the best we can do near the end of HGitaly2 milestone
         all_special_refs = ensure_special_refs(repo)
 
     for sref, sha in all_special_refs.items():
@@ -115,18 +147,22 @@ def iter_gitlab_special_refs_as_refs(repo, deref=True, patterns=None):
 
 
 def ensure_special_refs(repo):
+    if has_legacy_git_repo(repo):
+        return ensure_gitlab_special_refs(repo.ui, repo)
     return {}
 
 
 def ensure_keep_arounds(repo, init_empty=False):
-    """Ensure keep around file by creating it if needed
+    """Ensure keep around from Git repo if present or create.
 
     An empty file is created so that the keep-arounds file is no
     more missing, but only if `init_empty` is `True`, so that
-    responsibility is handed to the caller, that must use the
+    responsibility is handed to the caller, than must use the
     option only after having obtained the missing marker.
     """
-    if init_empty:
+    if has_legacy_git_repo(repo):
+        ensure_gitlab_keep_arounds(repo.ui, repo)
+    elif init_empty:
         init_keep_arounds(repo, ())
 
 

{hgitaly-18.7.0 → hgitaly-18.7.0a0}/hgitaly/manifest.py

@@ -234,6 +234,19 @@ class ManifestMiner:
                    prefix + b'/'.join(flat_path) if flat_path else dir_path
                    )
 
+    def file_names_by_regexp(self, rx, subdir=b''):
+        manifest = self.changeset.manifest()
+        subdir_prefix = subdir + b'/' if subdir else b''
+
+        for file_path in manifest.iterkeys():
+            if not file_path.startswith(subdir_prefix):
+                continue
+
+            if rx is not None and rx.search(file_path) is None:
+                continue
+
+            yield file_path
+
     def iter_files_with_content(self, exclude_binary=False):
         manifest = self.changeset.manifest()
         repo = self.changeset.repo().unfiltered()

{hgitaly-18.7.0 → hgitaly-18.7.0a0}/hgitaly/service/commit.py

@@ -22,13 +22,24 @@ from mercurial import (
 from hgext3rd.heptapod.branch import get_default_gitlab_branch
 
 from .. import (
+    manifest,
     message,
 )
 from ..errors import (
     not_implemented,
     structured_abort,
 )
+from ..file_context import (
+    git_perms,
+)
+from ..git import (
+    OBJECT_MODE_TREE,
+)
 from ..logging import LoggerAdapter
+from ..oid import (
+    tree_oid,
+    blob_oid,
+)
 from ..pagination import (
     extract_limit,
 )
@@ -51,14 +62,22 @@ from ..stream import (
 from ..stub.commit_pb2 import (
     CommitIsAncestorRequest,
     CommitIsAncestorResponse,
+    TreeEntryRequest,
+    TreeEntryResponse,
     CheckObjectsExistRequest,
     CheckObjectsExistResponse,
     CountCommitsRequest,
     CountCommitsResponse,
     CountDivergingCommitsRequest,
     CountDivergingCommitsResponse,
+    GetTreeEntriesError,
+    GetTreeEntriesRequest,
+    GetTreeEntriesResponse,
+    TreeEntry,
     ListFilesRequest,
     ListFilesResponse,
+    FindCommitRequest,
+    FindCommitResponse,
     CommitStatsRequest,
     CommitStatsResponse,
     FindAllCommitsRequest,
@@ -81,7 +100,9 @@ from ..stub.commit_pb2 import (
     GetCommitMessagesResponse,
 )
 from ..stub.errors_pb2 import (
+    PathError,
     PathNotFoundError,
+    ResolveRevisionError,
 )
 from ..stub.commit_pb2_grpc import CommitServiceServicer
 from ..util import (
@@ -129,6 +150,110 @@ class CommitServicer(CommitServiceServicer, HGitalyServicer):
 
         return CommitIsAncestorResponse(value=result)
 
+    def TreeEntry(self, request: TreeEntryRequest,
+                  context) -> TreeEntryResponse:
+        """Return an entry of a tree.
+
+        The name could be confusing with the entry for a tree: the entry
+        can be of any type.
+
+        Actually, it always yields one response message, using the empty
+        response in case the given path does not resolve.
+        """
+        repo = self.load_repo(request.repository, context).unfiltered()
+        changeset = gitlab_revision_changeset(repo, request.revision)
+        if changeset is None:
+            # As of v15.8.0, Gitaly error details don't give up anything
+            context.abort(StatusCode.NOT_FOUND, "tree entry not found")
+
+        sha = changeset.hex().decode('ascii')
+        # early testing shows that even for leaf files, Gitaly ignores
+        # trailing slashes
+        path = request.path.rstrip(b'/')
+
+        try:
+            filectx = changeset.filectx(path)
+        except error.ManifestLookupError:
+            filectx = None
+
+        # TODO investigate why it's not the usual WRITE_BUFFER_SIZE
+        # The only occurrence we could find so far was a 16384 in grpc Golang
+        # lib (size of HTTP/2 frames).
+        # Could be because Gitaly implementation uses CopyN to send to
+        # its chunker (in `streamio.go`) and CopyN has a buffer.
+        buffer_size = 16384
+        if filectx is not None:
+            otype = TreeEntryResponse.ObjectType.BLOB
+            oid = blob_oid(repo, sha, path)
+            mode = git_perms(filectx)
+            size = filectx.size()
+            max_size = request.max_size
+            if max_size != 0 and size > request.max_size:
+                context.abort(
+                    StatusCode.FAILED_PRECONDITION,
+                    "object size (%d) is bigger than the maximum "
+                    "allowed size (%d)" % (size, max_size))
+
+            data = filectx.data()
+
+            limit = request.limit
+            if limit != 0:
+                data = data[:limit]
+
+            offset = 0
+            while offset < size:
+                # only the first response of the stream carries the metadata
+                if offset:
+                    resp = TreeEntryResponse()
+                else:
+                    resp = TreeEntryResponse(type=otype,
+                                             oid=oid,
+                                             size=size,
+                                             mode=mode)
+
+                resp.data = data[offset:offset+buffer_size]
+                offset += buffer_size
+
+                yield resp
+            return
+
+        subtrees, file_paths = manifest.miner(changeset).ls_dir(path)
+        if not subtrees and not file_paths:
+            context.abort(StatusCode.NOT_FOUND, "tree entry not found")
+
+        # path is an actual directory
+
+        # size computation to match Git response.
+        # The formula for size computation is meant to match the size
+        # returned by Git, which is actually the size of the raw Git Tree
+        # object as returned by `git-cat-file` with `<type>` parameter.
+        #
+        # The raw Git Tree object is a simple concatenation of entries, each
+        # one being made of
+        # - mode (octal representation): 6 bytes for blobs (e.g 100644),
+        #                                5 bytes for subtrees (40000)
+        # - 0x20 (separator): 1 byte
+        # - name of the entry
+        # - 0x00 (separator): 1 byte
+        # - binary SHA-1 of the object referenced by the entry: 20 bytes
+        # Hence the total length per entry is 27 + (name length) for subtrees
+        # and 28 + (name length) for blobs.
+        # Finally, our `ls_dir` returns full paths from the root, so the
+        # have to substract `len(path + b'/')`, hence `len(path) + 1`
+        # for each entry.
+        size = (
+            28 * len(file_paths) + 27 * len(subtrees)
+            + sum(len(s) for s in subtrees) + sum(len(f) for f in file_paths)
+            - (len(subtrees) + len(file_paths)) * (len(path) + 1)
+        )
+        # max_size does not apply here (see Gitaly comparison test)
+        yield TreeEntryResponse(
+            type=TreeEntryResponse.ObjectType.TREE,
+            oid=tree_oid(repo, sha, path),
+            mode=OBJECT_MODE_TREE,
+            size=size,
+        )
+
     def CountCommits(self,
                      request: CountCommitsRequest,
                      context) -> CountCommitsResponse:
@@ -228,6 +353,142 @@ class CommitServicer(CommitServiceServicer, HGitalyServicer):
         return CountDivergingCommitsResponse(left_count=left_count,
                                              right_count=right_count)
 
+    def GetTreeEntries(self, request: GetTreeEntriesRequest,
+                       context) -> GetTreeEntriesResponse:
+        repo = self.load_repo(request.repository, context)
+        revision = request.revision
+        changeset = gitlab_revision_changeset(repo, revision)
+        if changeset is None:
+            structured_abort(
+                context,
+                StatusCode.INVALID_ARGUMENT,
+                "invalid revision or path",
+                GetTreeEntriesError(resolve_tree=ResolveRevisionError(
+                    revision=request.revision)))
+
+        repo = repo.unfiltered()
+        sha = changeset.hex().decode('ascii')
+        if not request.path:
+            structured_abort(
+                context,
+                StatusCode.INVALID_ARGUMENT, "empty path",
+                GetTreeEntriesError(
+                    path=PathError(path=request.path,
+                                   error_type=PathError.ERROR_TYPE_EMPTY_PATH))
+            )
+        path = request.path.rstrip(b'/')  # same as in TreeEntry
+        if path == b'.':  # special case, means the top directory
+            path = b''
+
+        blob_type = TreeEntry.EntryType.BLOB
+        tree_type = TreeEntry.EntryType.TREE
+        miner = manifest.miner(changeset)
+
+        if request.recursive:
+            entries = ((epath, is_dir, b'')
+                       for epath, is_dir in miner.iter_dir_recursive(path))
+        elif request.skip_flat_paths:
+            trees, files = miner.ls_dir(path)
+            entries = itertools.chain(
+                ((epath, True, b'') for epath in trees),
+                ((epath, False, b'') for epath in files),
+            )
+        else:
+            entries = miner.iter_dir_with_flat_paths(path)
+
+        # TODO request.sort == SortBy.TREES_FIRST
+        limit = extract_limit(request)
+        if limit == 0:
+            return  # simplify things (next_cursor computation notably)
+
+        # voids the advantages of iteration, but there's few choice
+        # in the matter with sort and pagination
+        if request.sort == GetTreeEntriesRequest.SortBy.TREES_FIRST:
+            # each entry is (path, is_dir (bool), flat_path)
+            # where flat_path is ignored for sorting purposes.
+            # TODO OPTIM is it an improvement to avoid this post-processing
+            # sort by making ManifestMiner already provide directories first?
+            # to get an advantage, we'd need to avoid at least a list
+            # construction
+            entries = sorted(
+                entries,
+                key=lambda entry: (1 if entry[1] else 2, entry[0]))
+        else:
+            # TODO OPTIM because Mercurial manifests are stored in
+            # lexicographical ordering, this sort is probably unnecessary.
+            # In first impl of sorting and pagination, probably not worth
+            # the risk.
+            # Also would be neat to avoid consuming the iterator into
+            # a least, but is it worth the added complexity if it can't
+            # be done in the TREES_FIRST case?
+            # What if GitLab introduces a sort direction anyway ?
+            entries = sorted(entries)  # sorts lexicographically by path
+
+        if not entries:
+            # there is no such thing as an empty directory in Mercurial
+            try:
+                changeset.filectx(path)
+            except error.ManifestLookupError:
+                if request.recursive:
+                    err_code = StatusCode.NOT_FOUND
+                else:
+                    err_code = StatusCode.INVALID_ARGUMENT
+                structured_abort(
+                    context,
+                    err_code,
+                    "invalid revision or path",
+                    GetTreeEntriesError(resolve_tree=ResolveRevisionError(
+                        revision=request.revision))
+                )
+            else:
+                structured_abort(
+                    context,
+                    StatusCode.INVALID_ARGUMENT,
+                    "path not treeish",
+                    GetTreeEntriesError(resolve_tree=ResolveRevisionError(
+                        revision=request.revision))
+                )
+
+        def entry_oid(path, is_dir):
+            return (tree_oid if is_dir else blob_oid)(repo, sha, path)
+
+        page_token = request.pagination_params.page_token
+        if page_token:
+            for offset, (path, is_dir, _) in enumerate(entries):
+                if entry_oid(path, is_dir) == page_token:
+                    break
+            else:
+                context.abort(StatusCode.INTERNAL,
+                              "could not find starting OID: %s" % page_token)
+
+            entries = entries[offset+1:]
+
+        if limit < len(entries):
+            entries = entries[:limit]
+            last_path, last_is_dir = entries[-1][:2]
+            next_cursor = entry_oid(last_path, last_is_dir)
+        else:
+            next_cursor = ''
+
+        yield from chunked_with_cursor(
+            GetTreeEntriesResponse,
+            entries,
+            next_cursor=next_cursor,
+            builder=lambda chunk: dict(
+                entries=(
+                    TreeEntry(
+                        path=path,
+                        type=tree_type if is_dir else blob_type,
+                        oid=entry_oid(path, is_dir),
+                        commit_oid=revision,
+                        mode=(OBJECT_MODE_TREE if is_dir else
+                              git_perms(changeset.filectx(path))),
+                        flat_path=flat_path,
+                    )
+                    for path, is_dir, flat_path in chunk)
+                )
+        )
+
     def ListFiles(self, request: ListFilesRequest,
                   context) -> ListFilesResponse:
         repo = self.load_repo(request.repository, context)
@@ -262,6 +523,27 @@ class CommitServicer(CommitServiceServicer, HGitalyServicer):
             deletions=removetotal,
         )
 
+    def FindCommit(self,
+                   request: FindCommitRequest, context) -> FindCommitResponse:
+        logger = LoggerAdapter(base_logger, context)
+        revision = request.revision
+        if not revision:
+            context.abort(StatusCode.INVALID_ARGUMENT, "empty revision")
+
+        repo = self.load_repo(request.repository, context)
+        ctx = gitlab_revision_changeset(repo, revision)
+
+        if ctx is None:
+            logger.warning("FindCommit revision %r could not be found",
+                           revision)
+            return FindCommitResponse()
+
+        if ctx.rev() == NULL_REV:
+            return FindCommitResponse()
+
+        commit = message.commit(ctx)
+        return FindCommitResponse(commit=commit)
+
     def FindAllCommits(self, request: FindAllCommitsRequest,
                        context) -> FindAllCommitsResponse:
         logger = LoggerAdapter(base_logger, context)
@@ -559,14 +841,6 @@ class CommitServicer(CommitServiceServicer, HGitalyServicer):
         if request.max_parents == 1:
             revset += b" and not merge()"
 
-        if request.paths:
-            revset += b" and ("
-            revset += b" or ".join(
-                b'file("%s/%s")' % (repo.root, p)
-                for p in request.paths
-            )
-            revset += b")"
-
         Order = ListCommitsRequest.Order
         reverse = request.reverse