forked from mattermost/mattermost
-
Notifications
You must be signed in to change notification settings - Fork 1
/
database.go
310 lines (255 loc) · 8.63 KB
/
database.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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
package config
import (
"bytes"
"database/sql"
"io/ioutil"
"net/url"
"strings"
"github.com/jmoiron/sqlx"
"github.com/pkg/errors"
"github.com/mattermost/mattermost-server/mlog"
"github.com/mattermost/mattermost-server/model"
// Load the MySQL driver
_ "github.com/go-sql-driver/mysql"
// Load the Postgres driver
_ "github.com/lib/pq"
)
// DatabaseStore is a config store backed by a database.
type DatabaseStore struct {
commonStore
originalDsn string
driverName string
dataSourceName string
db *sqlx.DB
}
// NewDatabaseStore creates a new instance of a config store backed by the given database.
func NewDatabaseStore(dsn string) (ds *DatabaseStore, err error) {
driverName, dataSourceName, err := parseDSN(dsn)
if err != nil {
return nil, errors.Wrap(err, "invalid DSN")
}
db, err := sqlx.Open(driverName, dataSourceName)
if err != nil {
return nil, errors.Wrapf(err, "failed to connect to %s database", driverName)
}
ds = &DatabaseStore{
driverName: driverName,
originalDsn: dsn,
dataSourceName: dataSourceName,
db: db,
}
if err = initializeConfigurationsTable(ds.db); err != nil {
return nil, errors.Wrap(err, "failed to initialize")
}
if err = ds.Load(); err != nil {
return nil, errors.Wrap(err, "failed to load")
}
return ds, nil
}
// initializeConfigurationsTable ensures the requisite tables in place to form the backing store.
func initializeConfigurationsTable(db *sqlx.DB) error {
_, err := db.Exec(`
CREATE TABLE IF NOT EXISTS Configurations (
Id VARCHAR(26) PRIMARY KEY,
Value TEXT NOT NULL,
CreateAt BIGINT NOT NULL,
Active BOOLEAN NULL UNIQUE
)
`)
if err != nil {
return errors.Wrap(err, "failed to create Configurations table")
}
_, err = db.Exec(`
CREATE TABLE IF NOT EXISTS ConfigurationFiles (
Name VARCHAR(64) PRIMARY KEY,
Data TEXT NOT NULL,
CreateAt BIGINT NOT NULL,
UpdateAt BIGINT NOT NULL
)
`)
if err != nil {
return errors.Wrap(err, "failed to create ConfigurationFiles table")
}
return nil
}
// parseDSN splits up a connection string into a driver name and data source name.
//
// For example:
// mysql://mmuser:mostest@dockerhost:5432/mattermost_test
// returns
// driverName = mysql
// dataSourceName = mmuser:mostest@dockerhost:5432/mattermost_test
//
// By contrast, a Postgres DSN is returned unmodified.
func parseDSN(dsn string) (string, string, error) {
// Treat the DSN as the URL that it is.
u, err := url.Parse(dsn)
if err != nil {
return "", "", errors.Wrap(err, "failed to parse DSN as URL")
}
scheme := u.Scheme
switch scheme {
case "mysql":
// Strip off the mysql:// for the dsn with which to connect.
u.Scheme = ""
dsn = strings.TrimPrefix(u.String(), "//")
case "postgres":
// No changes required
default:
return "", "", errors.Wrapf(err, "unsupported scheme %s", scheme)
}
return scheme, dsn, nil
}
// Set replaces the current configuration in its entirety and updates the backing store.
func (ds *DatabaseStore) Set(newCfg *model.Config) (*model.Config, error) {
return ds.commonStore.set(newCfg, ds.commonStore.validate, ds.persist)
}
// persist writes the configuration to the configured database.
func (ds *DatabaseStore) persist(cfg *model.Config) error {
b, err := marshalConfig(cfg)
if err != nil {
return errors.Wrap(err, "failed to serialize")
}
id := model.NewId()
value := string(b)
createAt := model.GetMillis()
tx, err := ds.db.Beginx()
if err != nil {
return errors.Wrap(err, "failed to begin transaction")
}
defer func() {
// Rollback after Commit just returns sql.ErrTxDone.
if err := tx.Rollback(); err != nil && err != sql.ErrTxDone {
mlog.Error("Failed to rollback configuration transaction", mlog.Err(err))
}
}()
params := map[string]interface{}{
"id": id,
"value": value,
"create_at": createAt,
"key": "ConfigurationId",
}
// Skip the persist altogether if we're effectively writing the same configuration.
var oldValue []byte
row := ds.db.QueryRow("SELECT Value FROM Configurations WHERE Active")
if err := row.Scan(&oldValue); err != nil && err != sql.ErrNoRows {
return errors.Wrap(err, "failed to query active configuration")
}
if bytes.Equal(oldValue, b) {
return nil
}
if _, err := tx.Exec("UPDATE Configurations SET Active = NULL WHERE Active"); err != nil {
return errors.Wrap(err, "failed to deactivate current configuration")
}
if _, err := tx.NamedExec("INSERT INTO Configurations (Id, Value, CreateAt, Active) VALUES (:id, :value, :create_at, TRUE)", params); err != nil {
return errors.Wrap(err, "failed to record new configuration")
}
if err := tx.Commit(); err != nil {
return errors.Wrap(err, "failed to commit transaction")
}
return nil
}
// Load updates the current configuration from the backing store.
func (ds *DatabaseStore) Load() (err error) {
var needsSave bool
var configurationData []byte
row := ds.db.QueryRow("SELECT Value FROM Configurations WHERE Active")
if err = row.Scan(&configurationData); err != nil && err != sql.ErrNoRows {
return errors.Wrap(err, "failed to query active configuration")
}
// Initialize from the default config if no active configuration could be found.
if len(configurationData) == 0 {
needsSave = true
defaultCfg := &model.Config{}
defaultCfg.SetDefaults()
// Assume the database storing the config is also to be used for the application.
// This can be overridden using environment variables on first start if necessary,
// or changed from the system console afterwards.
*defaultCfg.SqlSettings.DriverName = ds.driverName
*defaultCfg.SqlSettings.DataSource = ds.dataSourceName
configurationData, err = marshalConfig(defaultCfg)
if err != nil {
return errors.Wrap(err, "failed to serialize default config")
}
}
return ds.commonStore.load(ioutil.NopCloser(bytes.NewReader(configurationData)), needsSave, ds.commonStore.validate, ds.persist)
}
// GetFile fetches the contents of a previously persisted configuration file.
func (ds *DatabaseStore) GetFile(name string) ([]byte, error) {
query, args, err := sqlx.Named("SELECT Data FROM ConfigurationFiles WHERE Name = :name", map[string]interface{}{
"name": name,
})
if err != nil {
return nil, err
}
var data []byte
row := ds.db.QueryRowx(query, args...)
if err = row.Scan(&data); err != nil {
return nil, errors.Wrapf(err, "failed to scan data from row for %s", name)
}
return data, nil
}
// SetFile sets or replaces the contents of a configuration file.
func (ds *DatabaseStore) SetFile(name string, data []byte) error {
params := map[string]interface{}{
"name": name,
"data": data,
"create_at": model.GetMillis(),
"update_at": model.GetMillis(),
}
result, err := ds.db.NamedExec("UPDATE ConfigurationFiles SET Data = :data, UpdateAt = :update_at WHERE Name = :name", params)
if err != nil {
return errors.Wrapf(err, "failed to update row for %s", name)
}
count, err := result.RowsAffected()
if err != nil {
return errors.Wrapf(err, "failed to count rows affected for %s", name)
} else if count > 0 {
return nil
}
_, err = ds.db.NamedExec("INSERT INTO ConfigurationFiles (Name, Data, CreateAt, UpdateAt) VALUES (:name, :data, :create_at, :update_at)", params)
if err != nil {
return errors.Wrapf(err, "failed to insert row for %s", name)
}
return nil
}
// HasFile returns true if the given file was previously persisted.
func (ds *DatabaseStore) HasFile(name string) (bool, error) {
query, args, err := sqlx.Named("SELECT COUNT(*) FROM ConfigurationFiles WHERE Name = :name", map[string]interface{}{
"name": name,
})
if err != nil {
return false, err
}
var count int
row := ds.db.QueryRowx(query, args...)
if err = row.Scan(&count); err != nil {
return false, errors.Wrapf(err, "failed to scan count of rows for %s", name)
}
return count != 0, nil
}
// RemoveFile remoevs a previously persisted configuration file.
func (ds *DatabaseStore) RemoveFile(name string) error {
_, err := ds.db.NamedExec("DELETE FROM ConfigurationFiles WHERE Name = :name", map[string]interface{}{
"name": name,
})
if err != nil {
return errors.Wrapf(err, "failed to remove row for %s", name)
}
return nil
}
// String returns the path to the database backing the config, masking the password.
func (ds *DatabaseStore) String() string {
u, _ := url.Parse(ds.originalDsn)
// Strip out the password to avoid leaking in logs.
u.User = url.User(u.User.Username())
return u.String()
}
// Close cleans up resources associated with the store.
func (ds *DatabaseStore) Close() error {
ds.configLock.Lock()
defer ds.configLock.Unlock()
return ds.db.Close()
}