hgitaly 18.4.0a0__tar.gz → 18.5.0.dev0__tar.gz

{hgitaly-18.4.0a0 → hgitaly-18.5.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hgitaly
-Version: 18.4.0a0
+Version: 18.5.0.dev0
 Summary: Server-side implementation of Gitaly protocol for Mercurial
 Home-page: https://foss.heptapod.net/heptapod/hgitaly
 Author: Georges Racinet
@@ -10,10 +10,10 @@ Keywords: hg mercurial heptapod gitlab
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: heptapod>=5.2.0dev0
+Requires-Dist: heptapod>=5.3.0dev0
 Requires-Dist: protobuf~=6.31.1
-Requires-Dist: grpcio~=1.74.0
-Requires-Dist: grpcio-status~=1.74.0
+Requires-Dist: grpcio~=1.75.0
+Requires-Dist: grpcio-status~=1.75.0
 Requires-Dist: grpc-interceptor
 Requires-Dist: grpcio-health-checking
 Requires-Dist: hg-loggingmod>=0.4.1

hgitaly-18.5.0.dev0/hgitaly/VERSION

@@ -0,0 +1 @@
+18.5.0dev0

{hgitaly-18.4.0a0 → hgitaly-18.5.0.dev0}/hgitaly/message.py

@@ -19,6 +19,7 @@ from .stub.shared_pb2 import (
     GitCommit,
     SignatureType,
     Tag,
+    User,
 )
 from .stub.commit_pb2 import (
     ListLastCommitsForTreeResponse,
@@ -138,6 +139,10 @@ def commit_author(ctx):
         )
 
 
+def user_for_hg(user: User) -> bytes:
+    return b'%s <%s>' % (user.name, user.email)
+
+
 def commit_stats(ctx):
     if len(ctx.parents()) > 1:
         # Gitaly does not provide the stats for merge commits

{hgitaly-18.4.0a0 → hgitaly-18.5.0.dev0}/hgitaly/service/mercurial_operations.py

@@ -15,11 +15,25 @@ from mercurial.node import nullhex as NULL_NODE_HEX
 from mercurial.phases import (
     public as PUBLIC,
 )
-from mercurial import util as hgutil
+from mercurial import (
+    cmdutil,
+    commands,
+    error as hgerror,
+    util as hgutil,
+)
+from hgext.rebase import (
+    rebaseruntime,
+    sortsource as rebase_sort_source
+)
 
 from heptapod.gitlab.branch import (
-    NAMED_BRANCH_PREFIX,
+    branch_is_named_branch,
     gitlab_branch_ref,
+    parse_gitlab_branch,
+)
+from hgext3rd.heptapod.branch import (
+    gitlab_branches,
+    invalidate_gitlab_branches,
 )
 
 from .. import message
@@ -48,6 +62,8 @@ from ..workdir import (
 from ..stub.errors_pb2 import (
     MergeConflictError,
     ReferenceUpdateError,
+    ReferenceStateMismatchError,
+    ResolveRevisionError,
 )
 from ..stub.mercurial_operations_pb2 import (
     CensorRequest,
@@ -62,6 +78,9 @@ from ..stub.mercurial_operations_pb2 import (
     PublishChangesetError,
     PublishChangesetRequest,
     PublishChangesetResponse,
+    RebaseError,
+    RebaseRequest,
+    RebaseResponse,
     ReleaseWorkingDirectoryRequest,
     ReleaseWorkingDirectoryResponse,
     GetWorkingDirectoryRequest,
@@ -266,7 +285,7 @@ class MercurialOperationsServicer(MercurialOperationsServiceServicer,
         target_branch = request.branch
         if not target_branch:
             context.abort(StatusCode.INVALID_ARGUMENT, "empty branch name")
-        if not target_branch.startswith(NAMED_BRANCH_PREFIX):
+        if not branch_is_named_branch(target_branch):
             context.abort(StatusCode.FAILED_PRECONDITION,
                           "Heptapod merges are currently targeting "
                           "named branches only (no topics nor bookmarks)")
@@ -384,7 +403,7 @@ class MercurialOperationsServicer(MercurialOperationsServiceServicer,
                     new_changeset = self.merge(working_dir=wd,
                                                source_changeset=to_merge,
                                                user=request.user,
-                                               message=request.message,
+                                               commit_message=request.message,
                                                unix_timestamp=unix_ts,
                                                context=context)
             except ConflictError as exc:
@@ -411,7 +430,7 @@ class MercurialOperationsServicer(MercurialOperationsServiceServicer,
                 ))
 
     def merge(self, working_dir, context, source_changeset,
-              user: User, message, unix_timestamp):
+              user: User, commit_message, unix_timestamp):
         """Merge changeset with given revno in working repository.
 
         The working repositoy is assumed to be already updated in a
@@ -424,11 +443,141 @@ class MercurialOperationsServicer(MercurialOperationsServiceServicer,
             raise ConflictError(unresolved)
         # TODO user timezone (symbolic or UTC offset?)
         self.repo_command(working_repo, context, 'commit',
-                          user=b'%s <%s>' % (user.name, user.email),
+                          user=message.user_for_hg(user),
                           date=b'%d 0' % unix_timestamp,
-                          message=message)
+                          message=commit_message)
         return working_repo[b'.']
 
+    def Rebase(self, request: RebaseRequest, context) -> RebaseResponse:
+        logger = LoggerAdapter(base_logger, context)
+
+        repo = self.load_repo(request.repository, context,
+                              for_mutation_by=request.user)
+
+        source = request.source
+        if not source:
+            context.abort(StatusCode.INVALID_ARGUMENT,
+                          "empty source branch name")
+        dest = request.destination
+        if not dest:
+            context.abort(StatusCode.INVALID_ARGUMENT,
+                          "empty destination branch name")
+
+        branch, topic = parse_gitlab_branch(source)
+        if topic is None:
+            structured_abort(
+                context,
+                StatusCode.INVALID_ARGUMENT,
+                "Not a topic",
+                RebaseError(pre_check=PreCheckUpdateError.NOT_A_TOPIC)
+            )
+        # todo check sha if given
+
+        dest_cs = gitlab_revision_changeset(repo, dest)
+        if dest_cs is None:
+            structured_abort(
+                context,
+                StatusCode.FAILED_PRECONDITION,
+                "Failed to resolve destination",
+                RebaseError(resolve_rev=ResolveRevisionError(revision=dest))
+            )
+        source_cs = gitlab_revision_changeset(repo, source)
+        if source_cs is None:
+            structured_abort(
+                context,
+                StatusCode.FAILED_PRECONDITION,
+                "Failed to resolve source",
+                RebaseError(resolve_rev=ResolveRevisionError(revision=source))
+            )
+        expected_sha = request.source_head_sha.encode('utf-8')
+        actual_sha = source_cs.hex()
+        if expected_sha and expected_sha != actual_sha:
+            structured_abort(
+                context,
+                StatusCode.FAILED_PRECONDITION,
+                "Source head sha mismatch",
+                RebaseError(ref_mismatch=ReferenceStateMismatchError(
+                    reference_name=source,
+                    expected_object_id=expected_sha,
+                    actual_object_id=actual_sha))
+            )
+
+        # branch and topic naming rules make sure that we need no escaping
+        # using the head sha for reassurance
+        revset = b"branch('%s//%s') and ::%s" % (
+            branch, topic, source_cs.hex()
+        )
+        username = message.user_for_hg(request.user)
+        logger.info("Performing rebase, revset=%r, destination=%r",
+                    revset, dest_cs.hex())
+        with self.working_dir(gl_repo=request.repository,
+                              repo=repo,
+                              changeset=source_cs,
+                              context=context) as wd:
+            did_rebase = wd_rebase(wd, username, revset, dest_cs, context)
+
+        if not did_rebase:
+            return RebaseResponse()
+
+        invalidate_gitlab_branches(repo)
+        # do not use gitlab_revisions_changeset, as building the
+        # changectx would fail (`repo[new_head]` would end up in LookupError)
+        # we'd need to reload the repo, which is quite useless because we
+        # are happy with just the new Node ID
+        new_head = gitlab_branches(repo)[source]
+        return RebaseResponse(
+            branch_update=OperationBranchUpdate(
+                commit_id=new_head.decode('ascii')))
+
+
+def wd_rebase(working_dir, username, revset, dest_cs, context):
+    """Perform the rebase in the working directory, handling errors
+
+    :returns: ``True`` if rebase actually happened
+    """
+    repo = working_dir.repo
+
+    # TODO would be nice to experiment with in-memory rebase (wouldn't
+    # need a working dir) but not sure what the good use cases are.
+    # For instance, is a small rebase on a big repo much more efficient
+    # in memory or should that precisely be avoided?
+    overrides = {
+        (b'experimental', b'evolution.allowunstable'): False,
+        (b'rebase', b'singletransaction'): True,
+    }
+    # overriding ui.username does not work, this does:
+    repo.ui.environ[b'HGUSER'] = username
+    with repo.ui.configoverride(overrides, b'rebase'):
+        rebase = cmdutil.findcmd(b'rebase', commands.table)[1][0]
+        try:
+            retcode = rebase(repo.ui, repo, rev=[revset], dest=dest_cs.hex())
+        except hgerror.ConflictResolutionRequired:
+            conflicts = list(mergestate.read(repo).unresolved())
+            runtime = rebaseruntime(repo, repo.ui)
+            runtime.restorestatus()
+            # rebase_sort_source is the generator used by rebase to
+            # know what to do in order. Not sure why each yielded element
+            # is a list though (it's a singleton in simple tested cases)
+            failed_rev = next(rebase_sort_source(runtime.destmap))[0]
+            failed_sha = repo[failed_rev].hex().decode('ascii')
+            current_sha = repo[None].p1().hex().decode('ascii')
+
+            # next use of this workdir should be able to recover. Still it
+            # is best to do it right away
+            rebase(repo.ui, repo, abort=True)
+            working_dir.purge()
+
+            structured_abort(
+                context,
+                StatusCode.FAILED_PRECONDITION,
+                "Rebase conflict",
+                RebaseError(conflict=MergeConflictError(
+                    conflicting_files=conflicts,
+                    conflicting_commit_ids=[current_sha, failed_sha]
+                ))
+            )
+    return retcode is None or retcode == 0
+
 
 def wd_merge(working_dir, source_cs):
     """Merge source_cs in the given a working directory (repo share).

{hgitaly-18.4.0a0 → hgitaly-18.5.0.dev0}/hgitaly/service/operations.py

@@ -23,7 +23,7 @@ from heptapod import (
 )
 
 from heptapod.gitlab.branch import (
-    NAMED_BRANCH_PREFIX,
+    branch_is_named_branch,
     parse_gitlab_branch,
 )
 
@@ -252,7 +252,7 @@ class OperationServicer(OperationServiceServicer, HGitalyServicer):
         if not request.branch:
             context.abort(StatusCode.INVALID_ARGUMENT, "empty branch name")
 
-        if not request.branch.startswith(NAMED_BRANCH_PREFIX):
+        if not branch_is_named_branch(request.branch):
             context.abort(StatusCode.FAILED_PRECONDITION,
                           "Heptapod fast forwards are currently "
                           "for named branches only (no topics nor bookmarks)")

{hgitaly-18.4.0a0 → hgitaly-18.5.0.dev0}/hgitaly/service/tests/fixture.py

@@ -17,6 +17,7 @@ from hgitaly.servicer import (
     SKIP_HOOKS_MD_KEY,
 )
 from hgitaly.stub.shared_pb2 import Repository
+from hgitaly.workdir import wd_path
 
 from heptapod.testhelpers import (
         LocalRepoWrapper,
@@ -37,6 +38,9 @@ from hgitaly.stub.shared_pb2 import (
     User,
 )
 from hgitaly.testing.storage import (
+    repo_workdirs_root,
+    storage_path,
+    storage_workdirs,
     stowed_away_git_repo_path,
 )
 
@@ -143,12 +147,12 @@ class ServiceFixture:
         self.repos_to_cleanup.append(repo_path)
         return repo_path, repo_msg
 
-    def storage_path(self, storage_name='default'):
+    def storage_path(self, **storage_kw):
         """Utility method to avoid depending too much on actual disk layout.
 
         This repeats the actual implementation just once.
         """
-        return self.server_repos_root / storage_name
+        return storage_path(self.server_repos_root, **storage_kw)
 
     def repo_path(self, rel_path, **kw):
         """Utility method to avoid depending too much on actual disk layout.
@@ -172,6 +176,23 @@ class ServiceFixture:
         """
         return LocalRepoWrapper.load(self.repo_path(rel_path, **kw))
 
+    def storage_workdirs(self, **storage_kw):
+        return storage_workdirs(self.server_repos_root, **storage_kw)
+
+    def repo_workdirs_root(self, grpc_repo=None):
+        if grpc_repo is None:
+            grpc_repo = self.grpc_repo
+        return repo_workdirs_root(self.server_repos_root, grpc_repo)
+
+    def workdir_repo_wrapper(self, wd_id, grpc_repo=None):
+        """Direct low level access to a workdir repo.
+
+        This doesn't go through the normal initialization procedure, hence
+        is suitable to check state after error recovery.
+        """
+        return LocalRepoWrapper.load(
+            wd_path(self.repo_workdirs_root(grpc_repo=grpc_repo), wd_id))
+
     def rpc(self, method_name, request):
         """Call a method, taking care of metadata."""
         return getattr(self.stub, method_name)(

{hgitaly-18.4.0a0 → hgitaly-18.5.0.dev0}/hgitaly/service/tests/test_mercurial_operations.py

@@ -15,6 +15,8 @@ from mercurial import (
     error as hg_error,
     phases,
 )
+from mercurial.mergestate import mergestate
+from mercurial.node import nullid as NULL_NODE
 from mercurial_testhelpers import RepoWrapper
 
 from google.protobuf.timestamp_pb2 import Timestamp
@@ -38,6 +40,9 @@ from hgitaly.stub.mercurial_operations_pb2 import (
     CensorRequest,
     MergeBranchError,
     MergeBranchRequest,
+    RebaseError,
+    RebaseRequest,
+    RebaseResponse,
     MercurialPermissions,
     PreCheckUpdateError,
     PublishChangesetRequest,
@@ -50,6 +55,7 @@ from hgitaly.stub.mercurial_operations_pb2_grpc import (
     MercurialOperationsServiceStub,
 )
 from hgitaly.tests.common import make_empty_repo_with_gitlab_state_maintainer
+from hgitaly.testing.repo import assert_empty_repo_status
 from .fixture import MutationServiceFixture
 
 parametrize = pytest.mark.parametrize
@@ -86,6 +92,12 @@ class OperationsFixture(MutationServiceFixture):
         return self.stub.MergeBranch(MergeBranchRequest(**kw),
                                      metadata=self.grpc_metadata())
 
+    def rebase(self, **kw):
+        kw.setdefault('repository', self.grpc_repo)
+        kw.setdefault('user', self.user)
+        return self.stub.Rebase(RebaseRequest(**kw),
+                                metadata=self.grpc_metadata())
+
     def get_workdir(self, **kw):
         kw.setdefault('client_id', self.client_id)
         kw.setdefault('incarnation_id', INCARNATION_ID)
@@ -596,6 +608,126 @@ def test_merge_branch_troubled_changesets(operations_fixture):
     assert merge_error.pre_check == PreCheckUpdateError.UNSTABLE_CHANGESET
 
 
+@parametrize('project_mode', ('hg-git-project', 'native-project'))
+def test_rebase_basic(operations_fixture, project_mode):
+    fixture = operations_fixture
+    rebase = fixture.rebase
+
+    fixture.hg_native = project_mode != 'hg-git-project'
+    wrapper = fixture.repo_wrapper
+
+    gl_branch = b'branch/default'
+    gl_topic = b'topic/default/zetop'
+
+    # 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')
+    sha0 = ctx0.hex().decode()
+    default_head = wrapper.commit_file('foo')
+    ctx2 = wrapper.commit_file('bar', topic='zetop', parent=ctx0)
+    sha2 = ctx2.hex().decode()
+    # avoid keeping the rebased changesets visible
+    wrapper.update_bin(NULL_NODE)
+
+    # simple error cases
+    with pytest.raises(RpcError) as exc_info:
+        rebase(source=gl_topic)
+    assert exc_info.value.code() == StatusCode.INVALID_ARGUMENT
+    with pytest.raises(RpcError) as exc_info:
+        rebase(destination=gl_branch)
+    assert exc_info.value.code() == StatusCode.INVALID_ARGUMENT
+
+    # not a topic
+    with pytest.raises(RpcError) as exc_info:
+        rebase(source=gl_branch, destination=gl_branch)
+    details, rebase_error = parse_assert_structured_error(
+        exc_info.value, RebaseError, StatusCode.INVALID_ARGUMENT)
+    assert rebase_error.pre_check == PreCheckUpdateError.NOT_A_TOPIC
+
+    # unresolvable source or dest
+    with pytest.raises(RpcError) as exc_info:
+        rebase(destination=gl_branch, source=b'topic/default/unknown')
+    details, rebase_error = parse_assert_structured_error(
+        exc_info.value, RebaseError, StatusCode.FAILED_PRECONDITION)
+    assert rebase_error.resolve_rev.revision == b'topic/default/unknown'
+    with pytest.raises(RpcError) as exc_info:
+        rebase(source=gl_topic, destination=b'branch/unknown')
+    details, rebase_error = parse_assert_structured_error(
+        exc_info.value, RebaseError, StatusCode.FAILED_PRECONDITION)
+    assert rebase_error.resolve_rev.revision == b'branch/unknown'
+
+    # source_sha check failed
+    with pytest.raises(RpcError) as exc_info:
+        rebase(destination=gl_branch, source=gl_topic, source_head_sha=sha0)
+    details, rebase_error = parse_assert_structured_error(
+        exc_info.value, RebaseError, StatusCode.FAILED_PRECONDITION)
+    mismatch = rebase_error.ref_mismatch
+    assert mismatch.expected_object_id == ctx0.hex()
+    assert mismatch.actual_object_id == ctx2.hex()
+    assert mismatch.reference_name == gl_topic
+
+    # working simple case
+    resp = rebase(source=gl_topic, source_head_sha=sha2,
+                  destination=gl_branch)
+    wrapper.reload()
+    new_hex = resp.branch_update.commit_id.encode('ascii')
+    assert new_hex
+    assert new_hex != ctx2.hex()
+    rebased = wrapper.repo[new_hex]
+    assert rebased.p1() == default_head
+    assert rebased.topic() == b'zetop'
+
+    # no-op gives empty response
+    wrapper.commit_file('fast-fwd', topic='ff', parent=default_head)
+    assert rebase(source=b'topic/default/ff',
+                  destination=gl_branch) == RebaseResponse()
+
+
+@parametrize('project_mode', ('hg-git-project', 'native-project'))
+def test_rebase_conflict(operations_fixture, project_mode):
+    fixture = operations_fixture
+    rebase = fixture.rebase
+
+    fixture.hg_native = project_mode != 'hg-git-project'
+    wrapper = fixture.repo_wrapper
+
+    gl_branch = b'branch/default'
+    gl_topic = b'topic/default/zetop'
+
+    # 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')
+    default_head = wrapper.commit_file('foo', content='foo')
+    default_sha = default_head.hex().decode()
+    ctx2 = wrapper.commit_file('foo', topic='zetop', parent=ctx0,
+                               content='bar')
+    sha2 = ctx2.hex().decode()
+    # avoid keeping the rebased changesets visible
+    wrapper.update_bin(NULL_NODE)
+
+    initial_branches = gitlab_branches(wrapper.repo)
+
+    with pytest.raises(RpcError) as exc_info:
+        rebase(source=gl_topic, destination=gl_branch)
+    details, rebase_error = parse_assert_structured_error(
+        exc_info.value, RebaseError, StatusCode.FAILED_PRECONDITION)
+    conflict = rebase_error.conflict
+    assert conflict.conflicting_files == [b"foo"]
+    assert set(conflict.conflicting_commit_ids) == {default_sha, sha2}
+
+    # nothing changed and working dir is clean
+    wrapper.reload()
+    assert gitlab_branches(wrapper.repo) == initial_branches
+
+    wd_wrapper = fixture.workdir_repo_wrapper(0)
+    wd_repo = wd_wrapper.repo
+    ms = mergestate.read(wd_repo)
+    assert not list(ms.unresolved())
+    wctx = wd_repo[None]
+    assert wctx.p1() == ctx2
+    assert_empty_repo_status(wd_wrapper)
+
+
 @parametrize('project_mode', ('hg-git-project', 'native-project'))
 def test_censor(operations_fixture, project_mode):
     fixture = operations_fixture

{hgitaly-18.4.0a0 → hgitaly-18.5.0.dev0}/hgitaly/service/tests/test_repository_service.py

@@ -896,8 +896,7 @@ def test_remove_repository(fixture_with_repo, wds_success):
     os.makedirs(aux_git_dir, exist_ok=True)
     (aux_git_dir / 'anyfile').write_bytes(b'anything')
 
-    tmp_dir = wrapper.path.parent / '+hgitaly/tmp'
-    wds_root = tmp_dir / 'workdirs' / grpc_repo.relative_path
+    wds_root = fixture.repo_workdirs_root()
 
     if wds_success == 'error':
         # let's sabotage the roster file to trigger an inner exception
@@ -920,7 +919,7 @@ def test_remove_repository(fixture_with_repo, wds_success):
     assert not aux_git_dir.exists()
 
     # no leftover in the temporary directory either
-    assert not os.listdir(tmp_dir / 'workdirs')
+    assert not os.listdir(fixture.storage_workdirs())
 
     # unknown storage and repo
     with pytest.raises(grpc.RpcError) as exc_info:

{hgitaly-18.4.0a0 → hgitaly-18.5.0.dev0}/hgitaly/servicer.py

@@ -33,6 +33,8 @@ from .stub.shared_pb2 import (
 GARBAGE_COLLECTING_RATE_GEN2 = 250
 GARBAGE_COLLECTING_RATE_GEN1 = 20
 AUX_GIT_REPOS_RELATIVE_DIR = "+hgitaly/hg-git"
+TMP_RELATIVE_DIR = "+hgitaly/tmp"
+REPOS_WORKDIRS_RELATIVE_DIR = TMP_RELATIVE_DIR + '/workdirs'
 HG_GIT_MIRRORING_MD_KEY = 'x-heptapod-hg-git-mirroring'
 NATIVE_PROJECT_MD_KEY = 'x-heptapod-hg-native'
 # TODO check if there is a GitLab MD for this, it should:
@@ -357,7 +359,7 @@ class HGitalyServicer:
         :raises OSError: if creation fails.
         """
         temp_dir = os.path.join(self.storage_root_dir(storage_name, context),
-                                b'+hgitaly', b'tmp')
+                                TMP_RELATIVE_DIR.encode('ascii'))
         if not ensure:
             return temp_dir
 

{hgitaly-18.4.0a0 → hgitaly-18.5.0.dev0}/hgitaly/stub/mercurial_aux_git_pb2.py

@@ -24,21 +24,30 @@ _sym_db = _symbol_database.Default()
 
 from . import lint_pb2 as lint__pb2
 from . import repository_pb2 as repository__pb2
+from . import shared_pb2 as shared__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x17mercurial-aux-git.proto\x12\x07hgitaly\x1a\nlint.proto\x1a\x10repository.proto2\xcd\x02\n\x16MercurialAuxGitService\x12Y\n\x12\x41uxGitCreateBundle\x12\x1b.gitaly.CreateBundleRequest\x1a\x1c.gitaly.CreateBundleResponse\"\x06\xfa\x97(\x02\x08\x02\x30\x01\x12y\n\x16\x41uxGitCreateFromBundle\x12).gitaly.CreateRepositoryFromBundleRequest\x1a*.gitaly.CreateRepositoryFromBundleResponse\"\x06\xfa\x97(\x02\x08\x01(\x01\x12]\n\x14\x41uxGitRepositorySize\x12\x1d.gitaly.RepositorySizeRequest\x1a\x1e.gitaly.RepositorySizeResponse\"\x06\xfa\x97(\x02\x08\x01\x62\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x17mercurial-aux-git.proto\x12\x07hgitaly\x1a\nlint.proto\x1a\x10repository.proto\x1a\x0cshared.proto\"h\n\x1a\x41uxGitCommitMappingRequest\x12,\n\nrepository\x18\x01 \x01(\x0b\x32\x12.gitaly.RepositoryB\x04\x98\xc6,\x01\x12\x0b\n\x03ids\x18\x02 \x03(\t\x12\x0f\n\x07reverse\x18\x03 \x01(\x08\"*\n\x1b\x41uxGitCommitMappingResponse\x12\x0b\n\x03ids\x18\x02 \x03(\t2\xb7\x03\n\x16MercurialAuxGitService\x12Y\n\x12\x41uxGitCreateBundle\x12\x1b.gitaly.CreateBundleRequest\x1a\x1c.gitaly.CreateBundleResponse\"\x06\xfa\x97(\x02\x08\x02\x30\x01\x12y\n\x16\x41uxGitCreateFromBundle\x12).gitaly.CreateRepositoryFromBundleRequest\x1a*.gitaly.CreateRepositoryFromBundleResponse\"\x06\xfa\x97(\x02\x08\x01(\x01\x12]\n\x14\x41uxGitRepositorySize\x12\x1d.gitaly.RepositorySizeRequest\x1a\x1e.gitaly.RepositorySizeResponse\"\x06\xfa\x97(\x02\x08\x01\x12h\n\x13\x41uxGitCommitMapping\x12#.hgitaly.AuxGitCommitMappingRequest\x1a$.hgitaly.AuxGitCommitMappingResponse\"\x06\xfa\x97(\x02\x08\x02\x62\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
 _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'mercurial_aux_git_pb2', _globals)
 if not _descriptor._USE_C_DESCRIPTORS:
   DESCRIPTOR._loaded_options = None
+  _globals['_AUXGITCOMMITMAPPINGREQUEST'].fields_by_name['repository']._loaded_options = None
+  _globals['_AUXGITCOMMITMAPPINGREQUEST'].fields_by_name['repository']._serialized_options = b'\230\306,\001'
   _globals['_MERCURIALAUXGITSERVICE'].methods_by_name['AuxGitCreateBundle']._loaded_options = None
   _globals['_MERCURIALAUXGITSERVICE'].methods_by_name['AuxGitCreateBundle']._serialized_options = b'\372\227(\002\010\002'
   _globals['_MERCURIALAUXGITSERVICE'].methods_by_name['AuxGitCreateFromBundle']._loaded_options = None
   _globals['_MERCURIALAUXGITSERVICE'].methods_by_name['AuxGitCreateFromBundle']._serialized_options = b'\372\227(\002\010\001'
   _globals['_MERCURIALAUXGITSERVICE'].methods_by_name['AuxGitRepositorySize']._loaded_options = None
   _globals['_MERCURIALAUXGITSERVICE'].methods_by_name['AuxGitRepositorySize']._serialized_options = b'\372\227(\002\010\001'
-  _globals['_MERCURIALAUXGITSERVICE']._serialized_start=67
-  _globals['_MERCURIALAUXGITSERVICE']._serialized_end=400
+  _globals['_MERCURIALAUXGITSERVICE'].methods_by_name['AuxGitCommitMapping']._loaded_options = None
+  _globals['_MERCURIALAUXGITSERVICE'].methods_by_name['AuxGitCommitMapping']._serialized_options = b'\372\227(\002\010\002'
+  _globals['_AUXGITCOMMITMAPPINGREQUEST']._serialized_start=80
+  _globals['_AUXGITCOMMITMAPPINGREQUEST']._serialized_end=184
+  _globals['_AUXGITCOMMITMAPPINGRESPONSE']._serialized_start=186
+  _globals['_AUXGITCOMMITMAPPINGRESPONSE']._serialized_end=228
+  _globals['_MERCURIALAUXGITSERVICE']._serialized_start=231
+  _globals['_MERCURIALAUXGITSERVICE']._serialized_end=670
 # @@protoc_insertion_point(module_scope)

{hgitaly-18.4.0a0 → hgitaly-18.5.0.dev0}/hgitaly/stub/mercurial_aux_git_pb2_grpc.py

@@ -3,6 +3,7 @@
 import grpc
 import warnings
 
+from . import mercurial_aux_git_pb2 as mercurial__aux__git__pb2
 from . import repository_pb2 as repository__pb2
 
 GRPC_GENERATED_VERSION = '1.74.0'
@@ -54,6 +55,11 @@ class MercurialAuxGitServiceStub(object):
                 request_serializer=repository__pb2.RepositorySizeRequest.SerializeToString,
                 response_deserializer=repository__pb2.RepositorySizeResponse.FromString,
                 _registered_method=True)
+        self.AuxGitCommitMapping = channel.unary_unary(
+                '/hgitaly.MercurialAuxGitService/AuxGitCommitMapping',
+                request_serializer=mercurial__aux__git__pb2.AuxGitCommitMappingRequest.SerializeToString,
+                response_deserializer=mercurial__aux__git__pb2.AuxGitCommitMappingResponse.FromString,
+                _registered_method=True)
 
 
 class MercurialAuxGitServiceServicer(object):
@@ -82,6 +88,13 @@ class MercurialAuxGitServiceServicer(object):
         context.set_details('Method not implemented!')
         raise NotImplementedError('Method not implemented!')
 
+    def AuxGitCommitMapping(self, request, context):
+        """/ Resolve Mercurial commit ID from Git commit ID and conversely
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
 
 def add_MercurialAuxGitServiceServicer_to_server(servicer, server):
     rpc_method_handlers = {
@@ -100,6 +113,11 @@ def add_MercurialAuxGitServiceServicer_to_server(servicer, server):
                     request_deserializer=repository__pb2.RepositorySizeRequest.FromString,
                     response_serializer=repository__pb2.RepositorySizeResponse.SerializeToString,
             ),
+            'AuxGitCommitMapping': grpc.unary_unary_rpc_method_handler(
+                    servicer.AuxGitCommitMapping,
+                    request_deserializer=mercurial__aux__git__pb2.AuxGitCommitMappingRequest.FromString,
+                    response_serializer=mercurial__aux__git__pb2.AuxGitCommitMappingResponse.SerializeToString,
+            ),
     }
     generic_handler = grpc.method_handlers_generic_handler(
             'hgitaly.MercurialAuxGitService', rpc_method_handlers)
@@ -196,3 +214,30 @@ class MercurialAuxGitService(object):
             timeout,
             metadata,
             _registered_method=True)
+
+    @staticmethod
+    def AuxGitCommitMapping(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/hgitaly.MercurialAuxGitService/AuxGitCommitMapping',
+            mercurial__aux__git__pb2.AuxGitCommitMappingRequest.SerializeToString,
+            mercurial__aux__git__pb2.AuxGitCommitMappingResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)