-
Notifications
You must be signed in to change notification settings - Fork 88
/
license.go
127 lines (108 loc) · 4.23 KB
/
license.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
package license
import (
"io/ioutil"
"os"
"path/filepath"
"github.com/pkg/errors"
kotsv1beta1 "github.com/replicatedhq/kots/kotskinds/apis/kots/v1beta1"
apptypes "github.com/replicatedhq/kots/pkg/app/types"
"github.com/replicatedhq/kots/pkg/kotsutil"
kotslicense "github.com/replicatedhq/kots/pkg/license"
"github.com/replicatedhq/kots/pkg/preflight"
kotspull "github.com/replicatedhq/kots/pkg/pull"
"github.com/replicatedhq/kots/pkg/render"
"github.com/replicatedhq/kots/pkg/store"
"github.com/replicatedhq/kots/pkg/version"
"k8s.io/client-go/kubernetes/scheme"
)
func Sync(a *apptypes.App, licenseString string, failOnVersionCreate bool) (*kotsv1beta1.License, bool, error) {
currentLicense, err := store.GetStore().GetLatestLicenseForApp(a.ID)
if err != nil {
return nil, false, errors.Wrap(err, "failed to get current license")
}
var updatedLicense *kotsv1beta1.License
if licenseString != "" {
decode := scheme.Codecs.UniversalDeserializer().Decode
obj, _, err := decode([]byte(licenseString), nil, nil)
if err != nil {
return nil, false, errors.Wrap(err, "failed to parse license")
}
unverifiedLicense := obj.(*kotsv1beta1.License)
verifiedLicense, err := kotspull.VerifySignature(unverifiedLicense)
if err != nil {
return nil, false, errors.Wrap(err, "failed to verify license")
}
updatedLicense = verifiedLicense
} else {
// get from the api
licenseData, err := kotslicense.GetLatestLicense(currentLicense)
if err != nil {
return nil, false, errors.Wrap(err, "failed to get latest license")
}
updatedLicense = licenseData.License
licenseString = string(licenseData.LicenseBytes)
}
archiveDir, err := ioutil.TempDir("", "kotsadm")
if err != nil {
return nil, false, errors.Wrap(err, "failed to create temp dir")
}
defer os.RemoveAll(archiveDir)
// Because an older version can be edited, it is possible to have latest version with an outdated license.
// So even if global license sequence is already latest, we still need to create a new app version in this case.
err = store.GetStore().GetAppVersionArchive(a.ID, a.CurrentSequence, archiveDir)
if err != nil {
return nil, false, errors.Wrap(err, "failed to get latest app version")
}
kotsKinds, err := kotsutil.LoadKotsKindsFromPath(archiveDir)
if err != nil {
return nil, false, errors.Wrap(err, "failed to load kotskinds from path")
}
synced := false
if updatedLicense.Spec.LicenseSequence != currentLicense.Spec.LicenseSequence ||
updatedLicense.Spec.LicenseSequence != kotsKinds.License.Spec.LicenseSequence {
newSequence, err := store.GetStore().UpdateAppLicense(a.ID, a.CurrentSequence, archiveDir, updatedLicense, licenseString, failOnVersionCreate, &version.DownstreamGitOps{}, &render.Renderer{})
if err != nil {
return nil, false, errors.Wrap(err, "failed to update license")
}
if err := preflight.Run(a.ID, a.Slug, newSequence, a.IsAirgap, archiveDir); err != nil {
return nil, false, errors.Wrap(err, "failed to run preflights")
}
synced = true
}
return updatedLicense, synced, nil
}
// Gets the license as it was at a given app sequence
func GetCurrentLicenseString(a *apptypes.App) (string, error) {
archiveDir, err := ioutil.TempDir("", "kotsadm")
if err != nil {
return "", errors.Wrap(err, "failed to create temp dir")
}
defer os.RemoveAll(archiveDir)
err = store.GetStore().GetAppVersionArchive(a.ID, a.CurrentSequence, archiveDir)
if err != nil {
return "", errors.Wrap(err, "failed to get latest app version")
}
kotsLicense, err := ioutil.ReadFile(filepath.Join(archiveDir, "upstream", "userdata", "license.yaml"))
if err != nil {
return "", errors.Wrap(err, "failed to read license file from archive")
}
return string(kotsLicense), nil
}
func CheckIfLicenseExists(license []byte) (*kotsv1beta1.License, error) {
decode := scheme.Codecs.UniversalDeserializer().Decode
obj, _, err := decode(license, nil, nil)
if err != nil {
return nil, errors.Wrap(err, "failed to decode license yaml")
}
decodedLicense := obj.(*kotsv1beta1.License)
allLicenses, err := store.GetStore().GetAllAppLicenses()
if err != nil {
return nil, errors.Wrap(err, "failed to get all app licenses")
}
for _, l := range allLicenses {
if l.Spec.LicenseID == decodedLicense.Spec.LicenseID {
return l, nil
}
}
return nil, nil
}