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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
package worker
import (
"context"
"strings"
"time"
cacheconfig "github.com/moby/buildkit/cache/config"
"github.com/moby/buildkit/session"
"github.com/moby/buildkit/solver"
"github.com/moby/buildkit/util/compression"
"github.com/pkg/errors"
)
func NewCacheResultStorage(wc *Controller) solver.CacheResultStorage {
return &cacheResultStorage{
wc: wc,
}
}
type cacheResultStorage struct {
wc *Controller
}
func (s *cacheResultStorage) Save(res solver.Result, createdAt time.Time) (solver.CacheResult, error) {
ref, ok := res.Sys().(*WorkerRef)
if !ok {
return solver.CacheResult{}, errors.Errorf("invalid result: %T", res.Sys())
}
if ref.ImmutableRef != nil {
if !ref.ImmutableRef.HasCachePolicyRetain() {
if err := ref.ImmutableRef.SetCachePolicyRetain(); err != nil {
return solver.CacheResult{}, err
}
}
}
return solver.CacheResult{ID: ref.ID(), CreatedAt: createdAt}, nil
}
func (s *cacheResultStorage) Load(ctx context.Context, res solver.CacheResult) (solver.Result, error) {
return s.load(ctx, res.ID, false)
}
func (s *cacheResultStorage) getWorkerRef(id string) (Worker, string, error) {
workerID, refID, err := parseWorkerRef(id)
if err != nil {
return nil, "", err
}
w, err := s.wc.Get(workerID)
if err != nil {
return nil, "", err
}
return w, refID, nil
}
func (s *cacheResultStorage) load(ctx context.Context, id string, hidden bool) (solver.Result, error) {
w, refID, err := s.getWorkerRef(id)
if err != nil {
return nil, err
}
if refID == "" {
return NewWorkerRefResult(nil, w), nil
}
ref, err := w.LoadRef(ctx, refID, hidden)
if err != nil {
return nil, err
}
return NewWorkerRefResult(ref, w), nil
}
func (s *cacheResultStorage) LoadRemotes(ctx context.Context, res solver.CacheResult, compressionopt *compression.Config, g session.Group) ([]*solver.Remote, error) {
w, refID, err := s.getWorkerRef(res.ID)
if err != nil {
return nil, err
}
ref, err := w.LoadRef(ctx, refID, true)
if err != nil {
return nil, err
}
if ref != nil {
defer ref.Release(context.TODO())
}
wref := WorkerRef{ref, w}
all := true // load as many compression blobs as possible
if compressionopt == nil {
comp := compression.New(compression.Default)
compressionopt = &comp
all = false
}
refCfg := cacheconfig.RefConfig{
Compression: *compressionopt,
}
remotes, err := wref.GetRemotes(ctx, false, refCfg, all, g)
if err != nil {
return nil, nil // ignore error. loadRemote is best effort
}
return remotes, nil
}
func (s *cacheResultStorage) Exists(ctx context.Context, id string) bool {
ref, err := s.load(ctx, id, true)
if err != nil {
return false
}
ref.Release(context.TODO())
return true
}
func parseWorkerRef(id string) (string, string, error) {
parts := strings.Split(id, "::")
if len(parts) != 2 {
return "", "", errors.Errorf("invalid workerref id: %s", id)
}
return parts[0], parts[1], nil
}
|
