hgitaly 18.7.0a0__tar.gz → 18.7.0a1__tar.gz

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

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

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

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

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

@@ -406,8 +406,7 @@ def test_compare_list_files(gitaly_comparison):
         rpc_helper.assert_compare(revision=rev)
 
 
-@parametrize('hg_server', ('hgitaly', 'rhgitaly'))
-def test_compare_find_commit(gitaly_rhgitaly_comparison, hg_server):
+def test_compare_find_commit(gitaly_rhgitaly_comparison):
     fixture = gitaly_rhgitaly_comparison
     wrapper = fixture.hg_repo_wrapper
 
@@ -416,7 +415,7 @@ def test_compare_find_commit(gitaly_rhgitaly_comparison, hg_server):
             normalize_commit_message(response.commit)
 
     rpc_helper = fixture.rpc_helper(
-        hg_server=hg_server,
+        hg_server='rhgitaly',
         stub_cls=CommitServiceStub,
         method_name='FindCommit',
         request_cls=FindCommitRequest,

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

@@ -122,6 +122,7 @@ 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.0a0 → hgitaly-18.7.0a1}/functional_tests/test_repository_service.py

@@ -77,8 +77,7 @@ TESTS_DATA_DIR = Path(__file__).parent / 'data'
 TIP_TAG_NAME = b'tip'
 
 
-@parametrize('hg_server', ('hgitaly', 'rhgitaly'))
-def test_compare_find_merge_base(gitaly_rhgitaly_comparison, hg_server):
+def test_compare_find_merge_base(gitaly_rhgitaly_comparison):
     fixture = gitaly_rhgitaly_comparison
     gitaly_repo = fixture.gitaly_repo
     git_repo = fixture.git_repo
@@ -112,10 +111,7 @@ def test_compare_find_merge_base(gitaly_rhgitaly_comparison, hg_server):
                                parent=node_mod.nullid).hex()
     git_shas[sha4] = git_repo.branches()[b'branch/other']['sha']
 
-    if hg_server == 'rhgitaly':
-        hgitaly_channel = fixture.rhgitaly_channel
-    else:
-        hgitaly_channel = fixture.hgitaly_channel
+    hgitaly_channel = fixture.rhgitaly_channel
     diff_stubs = dict(
         git=RepositoryServiceStub(fixture.gitaly_channel),
         hg=RepositoryServiceStub(hgitaly_channel),
@@ -365,11 +361,10 @@ 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,
-                            hg_server):
+                            server_repos_root):
     fixture = gitaly_rhgitaly_comparison
+    hg_server = 'rhgitaly'
     grpc_repo = fixture.gitaly_repo
     rpc_helper = fixture.rpc_helper(
         hg_server=hg_server,
@@ -382,6 +377,11 @@ 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()
 
 
-@parametrize('hg_server', ('hgitaly', 'rhgitaly'))
-def test_search_files_by_name(gitaly_rhgitaly_comparison, hg_server):
+def test_search_files_by_name(gitaly_rhgitaly_comparison):
     fixture = gitaly_rhgitaly_comparison
+    hg_server = 'rhgitaly'
 
     wrapper = fixture.hg_repo_wrapper
     ctx0 = wrapper.write_commit('afoo', message="Some foo")
@@ -841,6 +841,7 @@ 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.0a1/hgitaly/VERSION

@@ -0,0 +1 @@
+18.7.0a1

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

@@ -13,7 +13,6 @@ 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
@@ -23,8 +22,6 @@ 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,
@@ -40,33 +37,6 @@ 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.
 
@@ -135,8 +105,6 @@ 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():
@@ -147,22 +115,18 @@ 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 from Git repo if present or create.
+    """Ensure keep around file by creating it if needed
 
     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, than must use the
+    responsibility is handed to the caller, that must use the
     option only after having obtained the missing marker.
     """
-    if has_legacy_git_repo(repo):
-        ensure_gitlab_keep_arounds(repo.ui, repo)
-    elif init_empty:
+    if init_empty:
         init_keep_arounds(repo, ())
 
 

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

@@ -234,19 +234,6 @@ 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.0a0 → hgitaly-18.7.0a1}/hgitaly/service/commit.py

@@ -22,24 +22,13 @@ 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,
 )
@@ -62,22 +51,14 @@ 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,
@@ -100,9 +81,7 @@ from ..stub.commit_pb2 import (
     GetCommitMessagesResponse,
 )
 from ..stub.errors_pb2 import (
-    PathError,
     PathNotFoundError,
-    ResolveRevisionError,
 )
 from ..stub.commit_pb2_grpc import CommitServiceServicer
 from ..util import (
@@ -150,110 +129,6 @@ 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:
@@ -353,142 +228,6 @@ 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)
@@ -523,27 +262,6 @@ 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)