-
Notifications
You must be signed in to change notification settings - Fork 88
/
branding_store.go
159 lines (136 loc) · 4.27 KB
/
branding_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 (
"encoding/base64"
"fmt"
"time"
"github.com/pkg/errors"
"github.com/replicatedhq/kots/pkg/persistence"
"github.com/rqlite/gorqlite"
"github.com/segmentio/ksuid"
)
// GetInitialBranding returns the latest initial branding archive
func (s *KOTSStore) GetInitialBranding() ([]byte, error) {
db := persistence.MustGetDBSession()
query := `SELECT contents FROM initial_branding ORDER BY created_at DESC LIMIT 1`
rows, err := db.QueryOne(query)
if err != nil {
return nil, fmt.Errorf("failed to query: %v: %v", err, rows.Err)
}
if !rows.Next() {
// no initial branding, return empty
return nil, nil
}
var encodedBrandingArchive gorqlite.NullString
if err := rows.Scan(&encodedBrandingArchive); err != nil {
return nil, errors.Wrap(err, "failed to scan branding")
}
var brandingArchive []byte
if encodedBrandingArchive.Valid {
b, err := base64.StdEncoding.DecodeString(encodedBrandingArchive.String)
if err != nil {
return nil, errors.Wrap(err, "failed to decode")
}
brandingArchive = b
}
return brandingArchive, nil
}
// CreateInitialBranding creates a new initial branding archive
func (s *KOTSStore) CreateInitialBranding(brandingArchive []byte) (string, error) {
db := persistence.MustGetDBSession()
id := ksuid.New().String()
encodedBrandingArchive := base64.StdEncoding.EncodeToString(brandingArchive)
query := `INSERT INTO initial_branding (id, contents, created_at) VALUES (?, ?, ?)`
wr, err := db.WriteOneParameterized(gorqlite.ParameterizedStatement{
Query: query,
Arguments: []interface{}{id, encodedBrandingArchive, time.Now().Unix()},
})
if err != nil {
return "", fmt.Errorf("failed to insert initial branding: %v: %v", err, wr.Err)
}
return id, nil
}
// GetLatestBranding returns the latest branding archive for any app
func (s *KOTSStore) GetLatestBranding() ([]byte, error) {
db := persistence.MustGetDBSession()
// get the branding for the latest deployed version of any app
query := `SELECT av.branding_archive
FROM
app_downstream AS ad
INNER JOIN
app_version AS av
ON
ad.app_id = av.app_id AND ad.current_sequence = av.sequence
LEFT JOIN
app_downstream_version AS adv
ON
adv.app_id = av.app_id AND adv.parent_sequence = av.sequence
ORDER BY
adv.applied_at DESC
LIMIT 1`
rows, err := db.QueryOne(query)
if err != nil {
return nil, fmt.Errorf("failed to query: %v: %v", err, rows.Err)
}
if !rows.Next() {
// no versioned branding, return the initial branding
return s.GetInitialBranding()
}
var encodedBrandingArchive gorqlite.NullString
if err := rows.Scan(&encodedBrandingArchive); err != nil {
return nil, errors.Wrap(err, "failed to scan latest deployed branding")
}
var brandingArchive []byte
if encodedBrandingArchive.Valid {
b, err := base64.StdEncoding.DecodeString(encodedBrandingArchive.String)
if err != nil {
return nil, errors.Wrap(err, "failed to decode")
}
brandingArchive = b
}
return brandingArchive, nil
}
// GetLatestBrandingForApp returns the latest branding archive for a specific app
func (s *KOTSStore) GetLatestBrandingForApp(appID string) ([]byte, error) {
db := persistence.MustGetDBSession()
// get the branding for the latest deployed version of this app
query := `SELECT av.branding_archive
FROM
app_downstream AS ad
INNER JOIN
app_version AS av
ON
ad.app_id = av.app_id AND ad.current_sequence = av.sequence
LEFT JOIN
app_downstream_version AS adv
ON
adv.app_id = av.app_id AND adv.parent_sequence = av.sequence
WHERE
ad.app_id = ?
ORDER BY
adv.applied_at DESC
LIMIT 1`
rows, err := db.QueryOneParameterized(gorqlite.ParameterizedStatement{
Query: query,
Arguments: []interface{}{appID},
})
if err != nil {
return nil, fmt.Errorf("failed to query: %v: %v", err, rows.Err)
}
if !rows.Next() {
// no versioned branding, return the initial branding
return s.GetInitialBranding()
}
var encodedBrandingArchive gorqlite.NullString
if err := rows.Scan(&encodedBrandingArchive); err != nil {
return nil, errors.Wrapf(err, "failed to scan latest deployed branding for app %s", appID)
}
var brandingArchive []byte
if encodedBrandingArchive.Valid {
b, err := base64.StdEncoding.DecodeString(encodedBrandingArchive.String)
if err != nil {
return nil, errors.Wrap(err, "failed to decode")
}
brandingArchive = b
}
return brandingArchive, nil
}