-
Notifications
You must be signed in to change notification settings - Fork 62
/
provider.go
127 lines (111 loc) · 3.64 KB
/
provider.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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
// SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) 2022, Unikraft GmbH and The KraftKit Authors.
// Licensed under the BSD-3-Clause License (the "License").
// You may not use this file except in compliance with the License.
package manifest
import (
"context"
"encoding/json"
"fmt"
"strings"
"github.com/sirupsen/logrus"
"kraftkit.sh/log"
"kraftkit.sh/pack"
)
type Provider interface {
// Manifests returns a slice of Manifests which can be returned by this
// Provider
Manifests() ([]*Manifest, error)
// PullManifest from the provider.
PullManifest(context.Context, *Manifest, ...pack.PullOption) error
// DeleteManifest deletes the artifact based on the provider's implementation.
DeleteManifest(context.Context) error
// String returns the name of the provider
fmt.Stringer
json.Marshaler
}
// NewProvider ultimately returns one of the supported manifest providers by
// attempting an ordered instantiation based on the input source. For the
// provider which does not return an error is indicator that it is supported and
// thus the return of NewProvider a compatible interface Provider able to gather
// information about the manifest.
func NewProvider(ctx context.Context, path string, mopts ...ManifestOption) (Provider, error) {
log.G(ctx).WithFields(logrus.Fields{
"path": path,
}).Trace("trying manifest provider")
provider, err := NewManifestProvider(ctx, path, mopts...)
if err == nil {
log.G(ctx).WithFields(logrus.Fields{
"path": path,
}).Trace("using manifest provider")
return provider, nil
}
log.G(ctx).WithFields(logrus.Fields{
"path": path,
}).Trace("trying index provider")
provider, err = NewManifestIndexProvider(ctx, path, mopts...)
if err == nil {
log.G(ctx).WithFields(logrus.Fields{
"path": path,
}).Trace("using index provider")
return provider, nil
}
log.G(ctx).WithFields(logrus.Fields{
"path": path,
}).Trace("trying directory provider")
provider, err = NewDirectoryProvider(ctx, path, mopts...)
if err == nil {
log.G(ctx).WithFields(logrus.Fields{
"path": path,
}).Trace("using directory provider")
return provider, nil
}
// First attempt to detect whether the provided input is a Git repository. If
// it is, it could potentially be from GitHub as well.
log.G(ctx).WithFields(logrus.Fields{
"path": path,
}).Trace("trying git provider")
provider, err = NewGitProvider(ctx, path, mopts...)
if err == nil || strings.Contains(path, "github.com") {
log.G(ctx).WithFields(logrus.Fields{
"path": path,
}).Trace("trying github provider")
ghProvider, err := NewGitHubProvider(ctx, path, mopts...)
if err == nil {
log.G(ctx).WithFields(logrus.Fields{
"path": path,
}).Trace("using github provider")
return ghProvider, nil
}
log.G(ctx).WithFields(logrus.Fields{
"path": path,
}).Trace("using git provider")
return provider, nil
}
return nil, fmt.Errorf("could not determine provider for: %s", path)
}
// NewProviderFromString returns a provider based on a giving string which
// identifies the provider
func NewProviderFromString(ctx context.Context, provider, path string, entity any, mopts ...ManifestOption) (Provider, error) {
switch provider {
case "index":
return &ManifestIndexProvider{
path: path,
index: entity.(*ManifestIndex),
mopts: mopts,
ctx: ctx,
}, nil
case "manifest":
return &ManifestProvider{
path: path,
manifest: entity.(*Manifest),
}, nil
case "github":
return NewGitHubProvider(ctx, path, mopts...)
case "git":
return NewGitProvider(ctx, path, mopts...)
case "directory", "dir":
return NewDirectoryProvider(ctx, path, mopts...)
}
return nil, fmt.Errorf("could not determine provider for: %s", path)
}