hgitaly 18.0.0a0__tar.gz → 18.0.0a1__tar.gz

{hgitaly-18.0.0a0 → hgitaly-18.0.0a1}/.hgtags

@@ -143,3 +143,4 @@ c964e44bbddc2d8fd41fd72a685535dc7c793150 17.9.2
 fdf0201ab1df3afbb372f4dd1005009ca37be713 17.11.0a0
 035b7b7e03a1c34fea4bc7995d54d2c8d088c3f7 17.11.0
 82eb6e9f12cb5a63bcd6a1f5e9c5ff26fb17b0f6 17.11.1
+c719859a655c7de4b357d1c2ff0046fe55f78e2a 18.0.0a0

{hgitaly-18.0.0a0 → hgitaly-18.0.0a1}/PKG-INFO

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

hgitaly-18.0.0a1/hgitaly/VERSION

@@ -0,0 +1 @@
+18.0.0a1

{hgitaly-18.0.0a0 → hgitaly-18.0.0a1}/hgitaly/service/repository.py

@@ -501,13 +501,20 @@ class RepositoryServicer(RepositoryServiceServicer, HGitalyServicer):
                 match_data.seek(0)
 
     def set_custom_hooks(self, request, context):
-        def load_repo(req, context):
-            return self.load_repo(req.repository, context)
+        logger = LoggerAdapter(base_logger, context)
 
         with streaming_request_tempfile_extract(
                 request, context,
-                first_request_handler=load_repo
-        ) as (repo, tmpf):
+                first_request_handler=lambda req, _context: req.repository
+        ) as (grpc_repo, tmpf):
+            if self.is_repo_aux_git(grpc_repo):
+                logger.warning(
+                    "Heptapod does not currently use custom hooks "
+                    "on auxiliary Git repositories. Nothing to do"
+                )
+                return
+
+            repo = self.load_repo(grpc_repo, context)
             tmpf.flush()
             try:
                 restore_additional(repo.ui, repo,

{hgitaly-18.0.0a0 → hgitaly-18.0.0a1}/hgitaly/service/tests/test_repository_service.py

@@ -38,6 +38,7 @@ from hgitaly.revision import ZERO_SHA
 from hgitaly.stream import WRITE_BUFFER_SIZE
 from hgitaly.testing import TEST_DATA_DIR
 from hgitaly.testing.bundle import list_bundle_contents
+from hgitaly.testing.storage import GIT_REPOS_STOWED_AWAY_PATH
 from hgitaly.workdir import (
     ROSTER_FILE_NAME as WDS_ROSTER_FILE_NAME,
     working_directory,
@@ -349,6 +350,19 @@ def test_repository_exists(fixture_with_repo):
     assert exc_info.value.code() == INVALID_ARGUMENT
 
 
+def test_vcs_qualified_storage(fixture_with_repo):
+    fixture = fixture_with_repo
+
+    fixture.grpc_repo.storage_name = 'hg:default'
+    assert fixture.exists()
+
+    fixture.grpc_repo.storage_name = 'rhg:default'
+    assert fixture.exists()
+
+    fixture.grpc_repo.relative_path = 'no/such/path'
+    assert not fixture.exists()
+
+
 def test_repository_size(fixture_with_repo):
     fixture = fixture_with_repo
     size = fixture.size()
@@ -854,6 +868,14 @@ def test_set_custom_hooks(fixture_with_repo, tmpdir, rpc_name):
         meth(invalid_tarball_path)
     assert exc_info.value.code() == INTERNAL
 
+    # case of Aux Git repository (nothing to be done, no error even if
+    # repository does not exist)
+    meth(tarball_path,
+         Repository(
+             storage_name=fixture.grpc_repo.storage_name,
+             relative_path=str(GIT_REPOS_STOWED_AWAY_PATH / 'some.git'),
+         ))
+
 
 @parametrize('rpc_name', ['backup', 'get'])
 def test_backup_custom_hooks(fixture_with_repo, tmpdir, rpc_name):

{hgitaly-18.0.0a0 → hgitaly-18.0.0a1}/hgitaly/servicer.py

@@ -32,6 +32,7 @@ from .stub.shared_pb2 import (
 
 GARBAGE_COLLECTING_RATE_GEN2 = 250
 GARBAGE_COLLECTING_RATE_GEN1 = 20
+AUX_GIT_REPOS_RELATIVE_DIR = "+hgitaly/hg-git"
 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:
@@ -129,6 +130,11 @@ class HGitalyServicer:
         #   (typically ignoring some settings that can be critical to
         #   operation)
 
+    def is_repo_aux_git(self, repository: Repository):
+        if repository is None:
+            return False
+        return repository.relative_path.startswith(AUX_GIT_REPOS_RELATIVE_DIR)
+
     def load_repo(self, repository: Repository, context,
                   for_mutation_by=None,
                   ):
@@ -288,7 +294,7 @@ class HGitalyServicer:
             # in request, without having the request object itself
             raise ValueError('repository not set')
 
-        root_dir = self.storages.get(storage_name)
+        root_dir = self.storages.get(storage_name.rsplit(':', 1)[-1])
         if root_dir is None:
             raise KeyError('storage', storage_name)
         return root_dir

{hgitaly-18.0.0a0 → hgitaly-18.0.0a1}/hgitaly/tests/test_servicer.py

@@ -28,6 +28,7 @@ from ..testing.context import (
     FakeServicerContext,
     metadatum,
 )
+from ..testing.storage import GIT_REPOS_STOWED_AWAY_PATH
 from ..servicer import (
     HG_GIT_MIRRORING_MD_KEY,
     NATIVE_PROJECT_MD_KEY,
@@ -107,6 +108,23 @@ def test_load_repo(tmpdir):
     assert context.code == grpc.StatusCode.NOT_FOUND
 
 
+def test_is_repo_aux_git(tmpdir):
+    storage_root = tmpdir.join('repos')
+    storage_root_bytes = pycompat.sysbytes(str(storage_root))
+    servicer = HGitalyServicer(dict(storname=storage_root_bytes))
+
+    assert not servicer.is_repo_aux_git(None)
+    assert not servicer.is_repo_aux_git(
+        Repository(storage_name='storname',
+                   relative_path='some/repo.git')
+    )
+    assert servicer.is_repo_aux_git(
+        Repository(
+            storage_name='storname',
+            relative_path=str(GIT_REPOS_STOWED_AWAY_PATH / 'repo.git'))
+    )
+
+
 def test_load_repo_for_mutation(tmpdir):
     storage_root = tmpdir.join('repos')
     storage_root_bytes = pycompat.sysbytes(str(storage_root))

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

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

hgitaly-18.0.0a1/rust/rhgitaly/src/bundle.rs

@@ -0,0 +1,300 @@
+// Copyright 2025 Georges Racinet <georges.racinet@octobus.net>
+//
+// This software may be used and distributed according to the terms of the
+// GNU General Public License version 2 or any later version.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+use std::ffi::OsString;
+use std::fmt::{Debug, Formatter};
+use std::path::PathBuf;
+use std::sync::Arc;
+use tokio::sync::mpsc;
+use tokio_stream::wrappers::ReceiverStream;
+use tokio_util::sync::CancellationToken;
+use tonic::{metadata::MetadataMap, Response, Status};
+use tracing::{debug, info, warn};
+
+use crate::config::Config;
+use crate::gitaly::{
+    CreateBundleRequest, CreateBundleResponse, CreateRepositoryFromBundleRequest,
+    FetchBundleRequest, Repository, User,
+};
+use crate::repository::spawner::{BytesChunking, RepoProcessSpawnerTemplate, RequestHgSpawnable};
+use crate::repository::{
+    checked_git_repo_path_for_creation, checked_repo_path_for_creation,
+    default_repo_spec_error_status, RequestWithBytesChunk, RequestWithRepo,
+};
+use crate::streaming::{ResultResponseStream, WRITE_BUFFER_SIZE};
+
+/// In this function, the Repository is assumed to be a Git repository,
+/// sitting exacly at the given relative path (no switch to hg, no diversion to +hgitaly area)
+pub async fn create_git_bundle(
+    config: Arc<Config>,
+    repo_path: PathBuf,
+    shutdown_token: CancellationToken,
+    metadata: &MetadataMap,
+) -> ResultResponseStream<CreateBundleResponse> {
+    let git_config = Vec::new();
+    let spawner_tmpl = RepoProcessSpawnerTemplate::new_git_at_path(
+        config.clone(),
+        repo_path,
+        metadata,
+        git_config,
+    )
+    .await?;
+    let mut spawner = spawner_tmpl.git_spawner();
+    // TODO evaluate needs for buffers? One can expect RHGitaly to read it fast
+    // unless all threads are busy.
+    let (stdout_tx, mut stdout_rx) = mpsc::channel(3);
+    spawner.capture_stdout(stdout_tx, BytesChunking::Binary(*WRITE_BUFFER_SIZE));
+    let args: Vec<OsString> = vec!["bundle".into(), "create".into(), "-".into(), "--all".into()];
+    spawner.args(&args);
+
+    let (tx, rx) = mpsc::channel(1);
+    let spawned = spawner.spawn(shutdown_token);
+    let tx2 = tx.clone();
+
+    let read_stdout = async move {
+        while let Some(data) = stdout_rx.recv().await {
+            debug!("Received {} bytes", data.len());
+            tx.send(Ok(CreateBundleResponse { data }))
+                .await
+                .unwrap_or_else(|e| {
+                    warn!(
+                        "Request cancelled by client before all results \
+                             could be streamed back: {e}"
+                    )
+                })
+        }
+        info!("Finished listening on internal channel for bundle data");
+    };
+
+    tokio::task::spawn(async move {
+        let spawn_result = tokio::join!(spawned, read_stdout).0;
+        let err = match spawn_result {
+            Ok(0) => return,
+            Ok(git_exit_code) => {
+                Status::internal(format!("Git subprocess exited with code {}", git_exit_code))
+            }
+            Err(e) => e,
+        };
+
+        if tx2.send(Err(err.clone())).await.is_err() {
+            warn!("Request cancelled by client before error {err:?} could be streamed back");
+        }
+    });
+
+    Ok(Response::new(Box::pin(ReceiverStream::new(rx))))
+}
+
+pub async fn create_repo_from_git_bundle(
+    config: Arc<Config>,
+    opt_repo: Option<&Repository>,
+    divert_aux_git_repo: bool,
+    bundle_path: PathBuf,
+    shutdown_token: CancellationToken,
+    metadata: &MetadataMap,
+) -> Result<(), Status> {
+    let (_gl_repo, repo_path) =
+        checked_git_repo_path_for_creation(&config, opt_repo, divert_aux_git_repo)
+            .await
+            .map_err(default_repo_spec_error_status)?;
+
+    let git_config = vec![
+        // See comment in FetchBundle
+        ("transfer.fsckObjects".into(), "false".into()),
+    ];
+
+    let cwd = config.repositories_root.clone();
+
+    let mut spawner =
+        RepoProcessSpawnerTemplate::new_git_at_path(config, cwd, metadata, git_config)
+            .await?
+            .git_spawner();
+
+    let args: Vec<OsString> = vec![
+        "clone".into(),
+        "--bare".into(),
+        "--quiet".into(),
+        bundle_path.into(),
+        repo_path.into(),
+    ];
+    spawner.args(&args);
+    info!("Git args: {:?}", &args);
+    let git_exit_code = spawner.spawn(shutdown_token).await?;
+    if git_exit_code != 0 {
+        warn!("Git subprocess exited with code {git_exit_code}");
+        return Err(Status::internal(format!(
+            "Git subprocess exited with code {git_exit_code}"
+        )));
+    }
+    Ok(())
+}
+
+pub async fn git_fetch_bundle<Req: RequestWithRepo>(
+    config: Arc<Config>,
+    req: Req,
+    bundle_path: PathBuf,
+    shutdown_token: CancellationToken,
+    metadata: &MetadataMap,
+) -> Result<(), Status> {
+    // call git fetch on the bundle, using the in-memory remote trick
+    let git_config = vec![
+        ("remote.inmemory.url".into(), bundle_path.into()),
+        // Comment from Gitaly 17.8:
+        //
+        //   Starting in Git version 2.46.0, executing git-fetch(1) on a bundle
+        //   performs fsck checks when `transfer.fsckObjects` is enabled.
+        //   Prior to this, this configuration was always ignored and fsck checks
+        //   were not run.
+        //   Unfortunately, fsck message severity configuration is ignored by
+        //   Git only for bundle fetches. Until this is supported by
+        //   Git, disable `transfer.fsckObjects` so bundles containing fsck
+        //   errors can continue to be fetched.
+        //   This matches behavior prior to Git version 2.46.0.
+        ("transfer.fsckObjects".into(), "false".into()),
+        // Comment from Gitaly 17.8:
+        //
+        //   Git is so kind to point out that we asked it to not show forced updates
+        //   by default, so we need to ask it not to do that.
+        ("advice.fetchShowForcedUpdates".into(), "false".into()),
+    ];
+    let mut spawner = RepoProcessSpawnerTemplate::new_git(
+        config,
+        req,
+        metadata,
+        git_config,
+        default_repo_spec_error_status,
+    )
+    .await?
+    .git_spawner();
+    // TODO support `update_head`.
+    //
+    // Gitaly uses the `MirroRefSpec`: "+refs/*:refs/*", but it look like
+    // our simpler refspec below always includes HEAD (and any other symref, to be
+    // fair, so they have to update HEAD separately, and it is a pain to
+    // find in the bundle etc.
+    // For the current purposes (backup/restore of auxiliary Git repositories),
+    // we do not care, but otherwise playing
+    // with a negative refspec for HEAD when we do not want to update it would
+    // probably be the way to go.
+    let args: Vec<OsString> = vec![
+        "fetch".into(),
+        "--quiet".into(),
+        "--atomic".into(),
+        "--force".into(),
+        "inmemory".into(), // name of Git remote
+        "+*:*".into(),     // refspec to update all refs from the remote (the bundle)
+    ];
+    spawner.args(&args);
+
+    let git_exit_code = spawner.spawn(shutdown_token).await?;
+    if git_exit_code != 0 {
+        warn!("Git subprocess exited with code {git_exit_code}");
+        return Err(Status::internal(format!(
+            "Git subprocess exited with code {git_exit_code}"
+        )));
+    }
+    Ok(())
+}
+
+pub async fn create_repo_from_hg_bundle(
+    config: Arc<Config>,
+    opt_repo: Option<&Repository>,
+    bundle_path: PathBuf,
+    shutdown_token: CancellationToken,
+    metadata: &MetadataMap,
+) -> Result<(), Status> {
+    let (gl_repo, repo_path) = checked_repo_path_for_creation(&config, opt_repo)
+        .await
+        .map_err(default_repo_spec_error_status)?;
+
+    let cwd = config.repositories_root.clone();
+    let mut spawner =
+        RepoProcessSpawnerTemplate::new_hg_at_path(config, cwd, gl_repo, None, metadata)
+            .await?
+            .hg_spawner();
+
+    let args: Vec<OsString> = vec!["clone".into(), bundle_path.into(), repo_path.into()];
+    spawner.args(&args);
+    info!("Mercurial args: {:?}", &args);
+    let hg_exit_code = spawner.spawn(shutdown_token).await?;
+    if hg_exit_code != 0 {
+        let msg = format!("Mercurial subprocess exited with code {hg_exit_code}");
+        warn!(msg);
+        return Err(Status::internal(msg));
+    }
+    Ok(())
+}
+
+pub async fn hg_unbundle<Req: RequestHgSpawnable>(
+    config: Arc<Config>,
+    req: Req,
+    bundle_path: PathBuf,
+    shutdown_token: CancellationToken,
+    metadata: &MetadataMap,
+) -> Result<(), Status> {
+    let mut spawner =
+        RepoProcessSpawnerTemplate::new_hg(config, req, metadata, default_repo_spec_error_status)
+            .await?
+            .hg_spawner();
+
+    let args: Vec<OsString> = vec!["unbundle".into(), bundle_path.into()];
+    spawner.args(&args);
+    info!("Mercurial args: {:?}", &args);
+    let hg_exit_code = spawner.spawn(shutdown_token).await?;
+    if hg_exit_code != 0 {
+        let msg = format!("Mercurial subprocess exited with code {hg_exit_code}");
+        warn!(msg);
+        return Err(Status::internal(msg));
+    }
+    Ok(())
+}
+
+pub struct CreateBundleTracingRequest<'a>(pub &'a CreateBundleRequest);
+
+impl Debug for CreateBundleTracingRequest<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("CreateBundle")
+            .field("repository", &self.0.repository)
+            .finish()
+    }
+}
+
+impl RequestWithRepo for CreateBundleRequest {
+    fn repository_ref(&self) -> Option<&Repository> {
+        self.repository.as_ref()
+    }
+}
+
+pub struct CreateRepositoryFromBundleTracingRequest<'a>(pub &'a CreateRepositoryFromBundleRequest);
+
+impl Debug for CreateRepositoryFromBundleTracingRequest<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("CreateRepositoryFromBundle")
+            .field("repository", &self.0.repository)
+            .finish()
+    }
+}
+
+impl RequestWithRepo for CreateRepositoryFromBundleRequest {
+    fn repository_ref(&self) -> Option<&Repository> {
+        self.repository.as_ref()
+    }
+}
+
+impl RequestWithBytesChunk for CreateRepositoryFromBundleRequest {
+    fn bytes_chunk(&self) -> &[u8] {
+        &self.data
+    }
+}
+impl RequestWithRepo for FetchBundleRequest {
+    fn repository_ref(&self) -> Option<&Repository> {
+        self.repository.as_ref()
+    }
+}
+impl RequestHgSpawnable for FetchBundleRequest {
+    fn user_ref(&self) -> Option<&User> {
+        None
+    }
+}

{hgitaly-18.0.0a0 → hgitaly-18.0.0a1}/rust/rhgitaly/src/repository/spawner.rs

@@ -28,7 +28,7 @@ use super::{
     checked_git_repo_path, checked_repo_path, load_repo_at_and_then, RepoSpecError, RequestWithRepo,
 };
 use crate::config::Config;
-use crate::gitaly::User;
+use crate::gitaly::{Repository, User};
 use crate::metadata::{
     get_boolean_md_value, ACCEPT_MR_IID_KEY, HG_GIT_MIRRORING_MD_KEY, NATIVE_PROJECT_MD_KEY,
     SKIP_HOOKS_MD_KEY,
@@ -110,6 +110,16 @@ impl RepoProcessSpawnerTemplate {
         let (gitaly_repo, repo_path) = checked_repo_path(&config, request.repository_ref())
             .await
             .map_err(repo_spec_error_status)?;
+        Self::new_hg_at_path(config, repo_path, gitaly_repo, request.user_ref(), metadata).await
+    }
+
+    pub async fn new_hg_at_path(
+        config: Arc<Config>,
+        cwd: PathBuf,
+        gitaly_repo: &Repository,
+        opt_user: Option<&User>,
+        metadata: &MetadataMap,
+    ) -> Result<Self, Status> {
         let mut common_args = Vec::new();
         let mut common_env: Vec<(OsString, OsString)> = vec![
             (
@@ -134,7 +144,7 @@ impl RepoProcessSpawnerTemplate {
             common_env.push(("'HEPTAPOD_SKIP_ALL_GITLAB_HOOKS'".into(), "yes".into()));
         }
 
-        if let Some(user) = request.user_ref() {
+        if let Some(user) = opt_user {
             common_env.push(("HEPTAPOD_USERINFO_GL_ID".into(), user.gl_id.clone().into()));
             common_env.push((
                 "HEPTAPOD_USERINFO_USERNAME".into(),
@@ -160,7 +170,7 @@ impl RepoProcessSpawnerTemplate {
             common_args,
             common_env,
             config,
-            repo_path,
+            repo_path: cwd,
         })
     }
 

{hgitaly-18.0.0a0 → hgitaly-18.0.0a1}/rust/rhgitaly/src/repository.rs

@@ -42,6 +42,7 @@ pub enum RepoSpecError {
     MissingSpecification,
     UnknownStorage(String),
     RepoNotFound(PathBuf),
+    AlreadyExists(PathBuf),
 }
 
 /// Represent errors loading a repository (bad specification or internal errors)
@@ -78,6 +79,9 @@ pub fn default_repo_spec_error_status(err: RepoSpecError) -> Status {
         RepoSpecError::RepoNotFound(at) => {
             Status::not_found(format!("repository at \"{}\" not found", at.display()))
         }
+        RepoSpecError::AlreadyExists(_) => {
+            Status::already_exists("creating repository: repository exists already")
+        }
     }
 }
 
@@ -102,8 +106,18 @@ pub fn aux_git_to_main_hg<Req: RequestWithRepo>(req: &Req) -> Option<&str> {
     }
 }
 
+fn check_storage(repo: &Repository) -> Result<(), RepoSpecError> {
+    if repo.storage_name.rsplit(':').next() == Some("default") {
+        Ok(())
+    } else {
+        Err(RepoSpecError::UnknownStorage(repo.storage_name.clone()))
+    }
+}
+
 pub fn repo_path(config: &Config, repo: &Repository) -> Result<PathBuf, RepoSpecError> {
-    if repo.storage_name != "default" {
+    check_storage(repo)?;
+
+    if repo.storage_name.rsplit(':').next() != Some("default") {
         return Err(RepoSpecError::UnknownStorage(repo.storage_name.clone()));
     }
     let root = &config.repositories_root;
@@ -123,9 +137,8 @@ pub fn git_repo_path(
     repo: &Repository,
     divert_aux_area: bool,
 ) -> Result<PathBuf, RepoSpecError> {
-    if repo.storage_name != "default" {
-        return Err(RepoSpecError::UnknownStorage(repo.storage_name.clone()));
-    }
+    check_storage(repo)?;
+
     let mut path = if divert_aux_area {
         config.repositories_root.join(AUX_GIT_REPOS_RELATIVE_DIR)
     } else {
@@ -196,6 +209,21 @@ pub async fn checked_repo_path<'a>(
     Err(RepoSpecError::RepoNotFound(path))
 }
 
+/// Checks that repo is specified, and that there is nothing at its path
+pub async fn checked_repo_path_for_creation<'a>(
+    config: &Config,
+    gl_repo: Option<&'a Repository>,
+) -> Result<(&'a Repository, PathBuf), RepoSpecError> {
+    let repo = gl_repo
+        .as_ref()
+        .ok_or(RepoSpecError::MissingSpecification)?;
+    let path = repo_path(config, repo)?;
+    if fs::metadata(&path).await.is_ok() {
+        return Err(RepoSpecError::AlreadyExists(path));
+    }
+    Ok((repo, path))
+}
+
 pub async fn checked_git_repo_path<'a>(
     config: &Config,
     gl_repo: Option<&'a Repository>,
@@ -214,6 +242,21 @@ pub async fn checked_git_repo_path<'a>(
     Err(RepoSpecError::RepoNotFound(path))
 }
 
+pub async fn checked_git_repo_path_for_creation<'a>(
+    config: &Config,
+    gl_repo: Option<&'a Repository>,
+    divert_aux_area: bool,
+) -> Result<(&'a Repository, PathBuf), RepoSpecError> {
+    let repo = gl_repo
+        .as_ref()
+        .ok_or(RepoSpecError::MissingSpecification)?;
+    let path = git_repo_path(config, repo, divert_aux_area)?;
+    if fs::metadata(&path).await.is_ok() {
+        return Err(RepoSpecError::AlreadyExists(path));
+    }
+    Ok((repo, path))
+}
+
 /// Return a path to virtual filesystem for the repository store.
 ///
 /// As of this writing, this is nothing but a [`Path`], but it could become something

{hgitaly-18.0.0a0 → hgitaly-18.0.0a1}/rust/rhgitaly/src/service/mercurial_aux_git.rs

@@ -30,7 +30,7 @@ use crate::hgitaly::mercurial_aux_git_service_server::{
 use crate::metadata::correlation_id;
 use crate::repository::{
     blocking_join_error_status, checked_git_repo_path, default_repo_spec_error_status,
-    git_repo_path, RepoSpecError, RequestWithRepo,
+    RequestWithRepo,
 };
 use crate::streaming::{with_streaming_request_data_as_file, ResultResponseStream};
 use crate::util::tracing_span_id;
@@ -122,16 +122,10 @@ impl MercurialAuxGitServiceImpl {
                      First request chunk={:?}",
                     CreateRepositoryFromBundleTracingRequest(&first_req)
                 );
-                let gl_repo = first_req
-                    .repository_ref()
-                    .ok_or(RepoSpecError::MissingSpecification)
-                    .map_err(default_repo_spec_error_status)?;
-
-                let repo_path = git_repo_path(&config, gl_repo, true)
-                    .map_err(default_repo_spec_error_status)?;
                 create_repo_from_git_bundle(
                     config,
-                    repo_path,
+                    first_req.repository_ref(),
+                    true,
                     bundle_path,
                     shutdown_token,
                     metadata,