-
Notifications
You must be signed in to change notification settings - Fork 88
/
license_store.go
159 lines (134 loc) · 5.25 KB
/
license_store.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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
package kotsstore
import (
"bytes"
"database/sql"
"io/ioutil"
"path/filepath"
"github.com/pkg/errors"
kotsv1beta1 "github.com/replicatedhq/kots/kotskinds/apis/kots/v1beta1"
"github.com/replicatedhq/kots/kotskinds/client/kotsclientset/scheme"
gitopstypes "github.com/replicatedhq/kots/pkg/gitops/types"
"github.com/replicatedhq/kots/pkg/logger"
"github.com/replicatedhq/kots/pkg/persistence"
rendertypes "github.com/replicatedhq/kots/pkg/render/types"
serializer "k8s.io/apimachinery/pkg/runtime/serializer/json"
)
func (s *KOTSStore) GetLatestLicenseForApp(appID string) (*kotsv1beta1.License, error) {
db := persistence.MustGetPGSession()
query := `select license from app where id = $1`
row := db.QueryRow(query, appID)
var licenseStr sql.NullString
if err := row.Scan(&licenseStr); err != nil {
return nil, errors.Wrap(err, "failed to scan")
}
decode := scheme.Codecs.UniversalDeserializer().Decode
obj, _, err := decode([]byte(licenseStr.String), nil, nil)
if err != nil {
return nil, errors.Wrap(err, "failed to decode license yaml")
}
license := obj.(*kotsv1beta1.License)
return license, nil
}
func (s *KOTSStore) GetLicenseForAppVersion(appID string, sequence int64) (*kotsv1beta1.License, error) {
db := persistence.MustGetPGSession()
query := `select kots_license from app_version where app_id = $1 and sequence = $2`
row := db.QueryRow(query, appID, sequence)
var licenseStr sql.NullString
if err := row.Scan(&licenseStr); err != nil {
return nil, errors.Wrap(err, "failed to scan")
}
if licenseStr.Valid {
decode := scheme.Codecs.UniversalDeserializer().Decode
obj, _, err := decode([]byte(licenseStr.String), nil, nil)
if err != nil {
return nil, errors.Wrap(err, "failed to decode license yaml")
}
license := obj.(*kotsv1beta1.License)
return license, nil
}
return nil, nil
}
func (s *KOTSStore) GetAllAppLicenses() ([]*kotsv1beta1.License, error) {
db := persistence.MustGetPGSession()
query := `select license from app`
rows, err := db.Query(query)
if err != nil {
return nil, errors.Wrap(err, "failed to query")
}
defer rows.Close()
var licenseStr sql.NullString
licenses := []*kotsv1beta1.License{}
for rows.Next() {
if err := rows.Scan(&licenseStr); err != nil {
return nil, errors.Wrap(err, "failed to scan")
}
if licenseStr.Valid {
decode := scheme.Codecs.UniversalDeserializer().Decode
obj, _, err := decode([]byte(licenseStr.String), nil, nil)
if err != nil {
return nil, errors.Wrap(err, "failed to decode license yaml")
}
license := obj.(*kotsv1beta1.License)
licenses = append(licenses, license)
}
}
return licenses, nil
}
func (s *KOTSStore) UpdateAppLicense(appID string, sequence int64, archiveDir string, newLicense *kotsv1beta1.License, originalLicenseData string, failOnVersionCreate bool, gitops gitopstypes.DownstreamGitOps, renderer rendertypes.Renderer) (int64, error) {
db := persistence.MustGetPGSession()
tx, err := db.Begin()
if err != nil {
return int64(0), errors.Wrap(err, "failed to begin")
}
defer tx.Rollback()
ser := serializer.NewYAMLSerializer(serializer.DefaultMetaFactory, scheme.Scheme, scheme.Scheme)
var b bytes.Buffer
if err := ser.Encode(newLicense, &b); err != nil {
return int64(0), errors.Wrap(err, "failed to encode license")
}
encodedLicense := b.Bytes()
if err := ioutil.WriteFile(filepath.Join(archiveDir, "upstream", "userdata", "license.yaml"), encodedLicense, 0644); err != nil {
return int64(0), errors.Wrap(err, "failed to write new license")
}
// app has the original license data received from the server
updateQuery := `update app set license=$1 where id = $2`
_, err = tx.Exec(updateQuery, originalLicenseData, appID)
if err != nil {
return int64(0), errors.Wrapf(err, "update app %q license", appID)
}
newSeq, err := s.createNewVersionForLicenseChange(tx, appID, sequence, archiveDir, gitops, renderer)
if err != nil {
// ignore error here to prevent a failure to render the current version
// preventing the end-user from updating the application
if failOnVersionCreate {
return int64(0), errors.Wrap(err, "failed to create new version")
}
logger.Errorf("Failed to create new version from license sync: %v", err)
}
if err := tx.Commit(); err != nil {
return int64(0), errors.Wrap(err, "failed to commit transaction")
}
return newSeq, nil
}
func (s *KOTSStore) createNewVersionForLicenseChange(tx *sql.Tx, appID string, sequence int64, archiveDir string, gitops gitopstypes.DownstreamGitOps, renderer rendertypes.Renderer) (int64, error) {
registrySettings, err := s.GetRegistryDetailsForApp(appID)
if err != nil {
return int64(0), errors.Wrap(err, "failed to get registry settings for app")
}
app, err := s.GetApp(appID)
if err != nil {
return int64(0), errors.Wrap(err, "failed to get app")
}
downstreams, err := s.ListDownstreamsForApp(appID)
if err != nil {
return int64(0), errors.Wrap(err, "failed to list downstreams")
}
if err := renderer.RenderDir(archiveDir, app, downstreams, registrySettings); err != nil {
return int64(0), errors.Wrap(err, "failed to render new version")
}
newSequence, err := s.createAppVersion(tx, appID, &sequence, archiveDir, "License Change", false, gitops)
if err != nil {
return int64(0), errors.Wrap(err, "failed to create new version")
}
return newSequence, nil
}