You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
224 lines
6.4 KiB
224 lines
6.4 KiB
package v1 |
|
|
|
import ( |
|
"bytes" |
|
"context" |
|
|
|
"go-common/app/infra/config/model" |
|
"go-common/library/database/sql" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
) |
|
|
|
const ( |
|
_getToken = "SELECT token FROM service_name WHERE name=? AND environment=?" |
|
_getBuildVersion = "SELECT b.config_id FROM service_name s, build_version b WHERE b.version=? AND s.name=? And s.environment=? AND s.id=b.service_id AND b.state=2" |
|
_getVersions = "SELECT c.id,c.remark FROM service_config c, service_name s WHERE s.name=? AND s.environment=? AND s.id =c.service_id AND c.state=? ORDER BY c.id DESC" |
|
_getNamespace = "SELECT id,namespace FROM service_namespace WHERE config_id=?" |
|
_getValue = "SELECT config_id,namespace_id,name,config FROM service_config_value WHERE config_id=?" |
|
_getFile = "SELECT config FROM service_config_value WHERE config_id=? AND name =?" |
|
_getBuilds = "SELECT b.version FROM service_name s ,build_version b WHERE s.name=? AND s.environment=? AND s.id=b.service_id AND b.state=2 ORDER BY b.id DESC" |
|
_getServiceID = "SELECT id FROM service_name where name=? AND environment =?" |
|
_insertVersion = "INSERT INTO service_config(service_id,state,operator) VALUES (?,?,?)" |
|
_insertConfigs = "INSERT INTO service_config_value(config_id,name,config,operator) VALUES " |
|
_updateConfigs = "UPDATE service_config_value SET config=?,operator=? WHERE config_id = ? AND name = ?" |
|
_insertLog = "INSERT INTO log(username,business,info) VALUES (?,?,?)" |
|
) |
|
|
|
// Token return a Secret from mysql. |
|
func (d *Dao) Token(c context.Context, svr, env string) (token string, err error) { |
|
row := d.db.QueryRow(c, _getToken, svr, env) |
|
if err = row.Scan(&token); err != nil { |
|
log.Error("row.Scan error(%v) svrName(%v)", err, svr) |
|
if err == sql.ErrNoRows { |
|
err = nil |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// BuildVersion return service build version from mysql. |
|
func (d *Dao) BuildVersion(c context.Context, svr, bver, env string) (version int64, err error) { |
|
row := d.db.QueryRow(c, _getBuildVersion, bver, svr, env) |
|
if err = row.Scan(&version); err != nil { |
|
if err == sql.ErrNoRows { |
|
version = model.UnknownVersion |
|
err = nil |
|
return |
|
} |
|
log.Error("row.Scan error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// Values return values from mysql. |
|
func (d *Dao) Values(c context.Context, ver int64) (rs []*model.NSValue, err error) { |
|
rows, err := d.db.Query(c, _getValue, ver) |
|
if err != nil { |
|
log.Error("db.Query(%d) error(%v)", ver, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
var r model.NSValue |
|
if err = rows.Scan(&r.ConfigID, &r.NamespaceID, &r.Name, &r.Config); err != nil { |
|
log.Error("rows.Scan error(%v)", err) |
|
return |
|
} |
|
rs = append(rs, &r) |
|
} |
|
return |
|
} |
|
|
|
// Namespaces return namespaces from mysql |
|
func (d *Dao) Namespaces(c context.Context, ver int64) (rs map[int64]string, err error) { |
|
rows, err := d.db.Query(c, _getNamespace, ver) |
|
if err != nil { |
|
log.Error("db.Query(%d) error(%v)", err) |
|
return |
|
} |
|
rs = make(map[int64]string) |
|
defer rows.Close() |
|
for rows.Next() { |
|
var id int64 |
|
var name string |
|
if err = rows.Scan(&id, &name); err != nil { |
|
log.Error("rows.Scan error(%v)", err) |
|
return |
|
} |
|
rs[id] = name |
|
} |
|
return |
|
} |
|
|
|
//Versions return versions from mysql |
|
func (d *Dao) Versions(c context.Context, svr, env string, state int8) (rs []*model.ReVer, err error) { |
|
rows, err := d.db.Query(c, _getVersions, svr, env, state) |
|
if err != nil { |
|
log.Error("db.Query(%s) error(%v)", svr, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
var r model.ReVer |
|
if err = rows.Scan(&r.Version, &r.Remark); err != nil { |
|
log.Error("rows.Scan error(%v)", err) |
|
return |
|
} |
|
rs = append(rs, &r) |
|
} |
|
return |
|
} |
|
|
|
// Value return values from mysql. |
|
func (d *Dao) Value(c context.Context, fname string, ver int64) (file string, err error) { |
|
row := d.db.QueryRow(c, _getFile, ver, fname) |
|
if err = row.Scan(&file); err != nil { |
|
log.Error("row.Scan error(%v)", err) |
|
if err == sql.ErrNoRows { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// Builds get service builds. |
|
func (d *Dao) Builds(c context.Context, svr, env string) (rs []string, err error) { |
|
rows, err := d.db.Query(c, _getBuilds, svr, env) |
|
if err != nil { |
|
log.Error("db.Query(%s) error(%v)", svr, err) |
|
return |
|
} |
|
defer rows.Close() |
|
for rows.Next() { |
|
var r string |
|
if err = rows.Scan(&r); err != nil { |
|
log.Error("rows.Scan error(%v)", err) |
|
return |
|
} |
|
rs = append(rs, r) |
|
} |
|
return |
|
} |
|
|
|
// ServiceID get ServiceID. |
|
func (d *Dao) ServiceID(c context.Context, svr, env string) (ID int64, err error) { |
|
row := d.db.QueryRow(c, _getServiceID, svr, env) |
|
if err != nil { |
|
log.Error("db.Query(%s) error(%v)", svr, err) |
|
return |
|
} |
|
if err = row.Scan(&ID); err != nil { |
|
log.Error("row.Scan error(%v)", err) |
|
if err == sql.ErrNoRows { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
} |
|
return |
|
} |
|
|
|
// TxInsertVer insert version. |
|
func (d *Dao) TxInsertVer(tx *sql.Tx, svrID int64, user string) (verID int64, err error) { |
|
row, err := tx.Exec(_insertVersion, svrID, model.ConfigIng, user) |
|
if err != nil { |
|
log.Error("db.insert(%d) error(%v)", svrID, err) |
|
return |
|
} |
|
return row.LastInsertId() |
|
} |
|
|
|
// TxInsertValues insert config values. |
|
func (d *Dao) TxInsertValues(c context.Context, tx *sql.Tx, verID int64, user string, data map[string]string) (err error) { |
|
var ( |
|
buffer bytes.Buffer |
|
insertTp string |
|
stmt *sql.Stmt |
|
is []interface{} |
|
) |
|
buffer.WriteString(_insertConfigs) |
|
insertTp = "(?,?,?,?)," |
|
for key, val := range data { |
|
buffer.WriteString(insertTp) |
|
is = append(is, verID) |
|
is = append(is, key) |
|
is = append(is, val) |
|
is = append(is, user) |
|
} |
|
buffer.Truncate(buffer.Len() - 1) |
|
if stmt, err = tx.Prepare(buffer.String()); err != nil { |
|
log.Error("d.insert() error(%v)", err) |
|
return |
|
} |
|
_, err = stmt.Exec(c, is...) |
|
if err != nil { |
|
log.Error("d.insert() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// TxUpdateValues update config values. |
|
func (d *Dao) TxUpdateValues(tx *sql.Tx, verID int64, user string, data map[string]string) (err error) { |
|
for key, val := range data { |
|
if _, err = tx.Exec(_updateConfigs, val, user, verID, key); err != nil { |
|
log.Error("db.UpdateValues(%d) error(%v)", user, err) |
|
break |
|
} |
|
} |
|
if err != nil { |
|
log.Error("d.insert() error(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
// InsertLog insert log. |
|
func (d *Dao) InsertLog(c context.Context, user, business, info string) (err error) { |
|
_, err = d.db.Exec(c, _insertLog, user, business, info) |
|
if err != nil { |
|
log.Error("db.InsertLog(%d) error(%v)", user, err) |
|
return |
|
} |
|
return |
|
}
|
|
|