1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
package repository
import (
"context"
"fmt"
"strings"
"gitlab.com/gitlab-org/gitaly/v16/internal/git"
"gitlab.com/gitlab-org/gitaly/v16/internal/gitaly/repoutil"
"gitlab.com/gitlab-org/gitaly/v16/internal/gitaly/storage"
"gitlab.com/gitlab-org/gitaly/v16/internal/structerr"
"gitlab.com/gitlab-org/gitaly/v16/proto/go/gitalypb"
)
func (s *server) CreateFork(ctx context.Context, req *gitalypb.CreateForkRequest) (*gitalypb.CreateForkResponse, error) {
// We don't validate existence of the source repository given that we may connect to a different Gitaly host in
// order to fetch from it. So it may or may not exist locally.
if err := s.locator.ValidateRepository(req.GetSourceRepository(), storage.WithSkipStorageExistenceCheck()); err != nil {
return nil, structerr.NewInvalidArgument("validating source repository: %w", err)
}
// Neither do we validate existence of the target repository given that this is the repository we wish to create
// in the first place.
if err := s.locator.ValidateRepository(req.GetRepository(), storage.WithSkipRepositoryExistenceCheck()); err != nil {
return nil, structerr.NewInvalidArgument("%w", err)
}
targetRepository := req.Repository
sourceRepository := req.SourceRepository
if err := repoutil.Create(ctx, s.locator, s.gitCmdFactory, s.txManager, s.repositoryCounter, targetRepository, func(repo *gitalypb.Repository) error {
targetPath, err := s.locator.GetRepoPath(repo, storage.WithRepositoryVerificationSkipped())
if err != nil {
return err
}
// Ideally we'd just fetch into the already-created repo, but that wouldn't
// allow us to easily set up HEAD to point to the correct ref. We thus have
// no easy choice but to use git-clone(1).
var stderr strings.Builder
cmd, err := s.gitCmdFactory.NewWithoutRepo(ctx,
git.Command{
Name: "clone",
Flags: []git.Option{
git.Flag{Name: "--bare"},
git.Flag{Name: "--quiet"},
},
Args: []string{
git.InternalGitalyURL,
targetPath,
},
},
git.WithInternalFetch(&gitalypb.SSHUploadPackRequest{
Repository: sourceRepository,
}),
git.WithConfig(git.ConfigPair{
// Disable consistency checks for fetched objects when creating a
// fork. We don't want to end up in a situation where it's
// impossible to create forks we already have anyway because we have
// e.g. retroactively tightened the consistency checks.
Key: "fetch.fsckObjects", Value: "false",
}),
git.WithDisabledHooks(),
git.WithStderr(&stderr),
)
if err != nil {
return fmt.Errorf("spawning fetch: %w", err)
}
if err := cmd.Wait(); err != nil {
return fmt.Errorf("fetching source repo: %w, stderr: %q", err, stderr.String())
}
if err := s.removeOriginInRepo(ctx, repo); err != nil {
return fmt.Errorf("removing origin remote: %w", err)
}
return nil
}, repoutil.WithSkipInit()); err != nil {
return nil, structerr.NewInternal("creating fork: %w", err)
}
return &gitalypb.CreateForkResponse{}, nil
}
|
