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
85
86
87
88
89
90
91
92
93
94
95
96
|
package helper
import (
"os"
"path"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
"gitlab.com/gitlab-org/gitaly/internal/config"
)
// GetRepoPath returns the full path of the repository referenced by an
// RPC Repository message. The errors returned are gRPC errors with
// relevant error codes and should be passed back to gRPC without further
// decoration.
func GetRepoPath(repo *gitalypb.Repository) (string, error) {
repoPath, err := GetPath(repo)
if err != nil {
return "", err
}
if repoPath == "" {
return "", status.Errorf(codes.InvalidArgument, "GetRepoPath: empty repo")
}
if IsGitDirectory(repoPath) {
return repoPath, nil
}
return "", status.Errorf(codes.NotFound, "GetRepoPath: not a git repository '%s'", repoPath)
}
// GetPath returns the path of the repo passed as first argument. An error is
// returned when either the storage can't be found or the path includes
// constructs trying to perform directory traversal.
func GetPath(repo *gitalypb.Repository) (string, error) {
storagePath, err := GetStorageByName(repo.GetStorageName())
if err != nil {
return "", err
}
if _, err := os.Stat(storagePath); err != nil {
return "", status.Errorf(codes.Internal, "GetPath: storage path: %v", err)
}
relativePath := repo.GetRelativePath()
if len(relativePath) == 0 {
err := status.Errorf(codes.InvalidArgument, "GetPath: relative path missing from %+v", repo)
return "", err
}
if ContainsPathTraversal(relativePath) {
return "", status.Errorf(codes.InvalidArgument, "GetRepoPath: relative path can't contain directory traversal")
}
return path.Join(storagePath, relativePath), nil
}
// GetStorageByName will return the path for the storage, which is fetched by
// its key. An error is return if it cannot be found.
func GetStorageByName(storageName string) (string, error) {
storagePath, ok := config.StoragePath(storageName)
if !ok {
return "", status.Errorf(codes.InvalidArgument, "Storage can not be found by name '%s'", storageName)
}
return storagePath, nil
}
// IsGitDirectory checks if the directory passed as first argument looks like
// a valid git directory.
func IsGitDirectory(dir string) bool {
if dir == "" {
return false
}
for _, element := range []string{"objects", "refs", "HEAD"} {
if _, err := os.Stat(path.Join(dir, element)); err != nil {
return false
}
}
// See: https://gitlab.com/gitlab-org/gitaly/issues/1339
//
// This is a workaround for Gitaly running on top of an NFS mount. There
// is a Linux NFS v4.0 client bug where opening the packed-refs file can
// either result in a stale file handle or stale data. This can happen if
// git gc runs for a long time while keeping open the packed-refs file.
// Running stat() on the file causes the kernel to revalidate the cached
// directory entry. We don't actually care if this file exists.
os.Stat(path.Join(dir, "packed-refs"))
return true
}
|
