-
Notifications
You must be signed in to change notification settings - Fork 498
/
stasher.go
89 lines (79 loc) · 2.58 KB
/
stasher.go
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
package stash
import (
"context"
"time"
"github.com/gomods/athens/pkg/errors"
"github.com/gomods/athens/pkg/index"
"github.com/gomods/athens/pkg/log"
"github.com/gomods/athens/pkg/module"
"github.com/gomods/athens/pkg/observ"
"github.com/gomods/athens/pkg/storage"
"go.opencensus.io/trace"
)
// Stasher has the job of taking a module
// from an upstream entity and stashing it to a Storage Backend and Index.
// It also returns a string that represents a semver version of
// what was requested, this is helpful if what was requested
// was a descriptive version such as a branch name or a full commit sha.
type Stasher interface {
Stash(ctx context.Context, mod, ver string) (string, error)
}
// Wrapper helps extend the main stasher's functionality with addons.
type Wrapper func(Stasher) Stasher
// New returns a plain stasher that takes
// a module from a download.Protocol and
// stashes it into a backend.Storage.
func New(f module.Fetcher, s storage.Backend, indexer index.Indexer, wrappers ...Wrapper) Stasher {
var st Stasher = &stasher{f, s, storage.WithChecker(s), indexer}
for _, w := range wrappers {
st = w(st)
}
return st
}
type stasher struct {
fetcher module.Fetcher
storage storage.Backend
checker storage.Checker
indexer index.Indexer
}
func (s *stasher) Stash(ctx context.Context, mod, ver string) (string, error) {
const op errors.Op = "stasher.Stash"
ctx, span := observ.StartSpan(ctx, op.String())
defer span.End()
log.EntryFromContext(ctx).Debugf("saving %s@%s to storage...", mod, ver)
// create a new context that ditches whatever deadline the caller passed
// but keep the tracing info so that we can properly trace the whole thing.
ctx, cancel := context.WithTimeout(trace.NewContext(context.Background(), span), time.Minute*10)
defer cancel()
v, err := s.fetchModule(ctx, mod, ver)
if err != nil {
return "", errors.E(op, err)
}
defer func() { _ = v.Zip.Close() }()
if v.Semver != ver {
exists, err := s.checker.Exists(ctx, mod, v.Semver)
if err != nil {
return "", errors.E(op, err)
}
if exists {
return v.Semver, nil
}
}
err = s.storage.Save(ctx, mod, v.Semver, v.Mod, v.Zip, v.Info)
if err != nil {
return "", errors.E(op, err)
}
err = s.indexer.Index(ctx, mod, v.Semver)
if err != nil && !errors.Is(err, errors.KindAlreadyExists) {
return "", errors.E(op, err)
}
return v.Semver, nil
}
func (s *stasher) fetchModule(ctx context.Context, mod, ver string) (*storage.Version, error) {
const op errors.Op = "stasher.fetchModule"
v, err := s.fetcher.Fetch(ctx, mod, ver)
if err != nil {
return nil, errors.E(op, err)
}
return v, nil
}