571 lines
14 KiB
Go
571 lines
14 KiB
Go
package v1
|
||
|
||
import (
|
||
"context"
|
||
"crypto/md5"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"fmt"
|
||
"time"
|
||
|
||
"go-common/app/infra/config/model"
|
||
"go-common/library/database/sql"
|
||
"go-common/library/ecode"
|
||
"go-common/library/log"
|
||
xtime "go-common/library/time"
|
||
)
|
||
|
||
const (
|
||
_buildVerKey = "%s_%s_%s"
|
||
_pushKey = "%s_%s_%s"
|
||
_cacheKey = "%s_%s_%d_%s"
|
||
_cacheKey2 = "%s_%s_%d_%s_2"
|
||
_fileKey = "%s_%d"
|
||
)
|
||
|
||
var (
|
||
addBusiness = "前端接口api添加配置版本"
|
||
addInfo = "添加版本:%d"
|
||
copyBusiness = "前端接口api拷贝配置版本"
|
||
copyInfo = "拷贝版本:%d，新的版本:%d"
|
||
updateBusiness = "前端接口api更新配置"
|
||
updateInfo = "更新版本:%d"
|
||
)
|
||
|
||
// PushKey push sub id
|
||
func pushKey(svr, host, env string) string {
|
||
return fmt.Sprintf(_pushKey, svr, host, env)
|
||
}
|
||
|
||
// buildVerKey version mapping key
|
||
func buildVerKey(svr, bver, env string) string {
|
||
return fmt.Sprintf(_buildVerKey, svr, bver, env)
|
||
}
|
||
|
||
// cacheKey config cache key
|
||
func cacheKey(svr, bver, env string, ver int64) string {
|
||
return fmt.Sprintf(_cacheKey, svr, bver, ver, env)
|
||
}
|
||
|
||
// cacheKey config cache key
|
||
func cacheKey2(svr, bver, env string, ver int64) string {
|
||
return fmt.Sprintf(_cacheKey2, svr, bver, ver, env)
|
||
}
|
||
|
||
// fileKey
|
||
func fileKey(filename string, ver int64) string {
|
||
return fmt.Sprintf(_fileKey, filename, ver)
|
||
}
|
||
|
||
// tokenKey
|
||
func tokenKey(svr, env string) string {
|
||
return fmt.Sprintf("%s_%s", svr, env)
|
||
}
|
||
|
||
// genConfig generate config
|
||
func genConfig(ver int64, cs []*model.NSValue) (conf *model.Content, err error) {
|
||
var b []byte
|
||
data := make(map[string]string)
|
||
for _, c := range cs {
|
||
data[c.Name] = c.Config
|
||
}
|
||
if b, err = json.Marshal(data); err != nil {
|
||
return
|
||
}
|
||
mb := md5.Sum(b)
|
||
conf = &model.Content{
|
||
Version: ver,
|
||
Md5: hex.EncodeToString(mb[:]),
|
||
Content: string(b),
|
||
}
|
||
return
|
||
}
|
||
|
||
// genConfig2 generate config
|
||
func genConfig2(ver int64, cs []*model.NSValue, ns map[int64]string) (conf *model.Content, err error) {
|
||
var (
|
||
b []byte
|
||
v string
|
||
ok bool
|
||
s *model.Namespace
|
||
)
|
||
nsc := make(map[string]*model.Namespace)
|
||
for _, c := range cs {
|
||
if v, ok = ns[c.NamespaceID]; !ok && c.NamespaceID != 0 {
|
||
continue
|
||
}
|
||
if s, ok = nsc[v]; !ok {
|
||
s = &model.Namespace{Name: v, Data: map[string]string{}}
|
||
nsc[v] = s
|
||
}
|
||
s.Data[c.Name] = c.Config
|
||
}
|
||
if b, err = json.Marshal(nsc); err != nil {
|
||
return
|
||
}
|
||
mb := md5.Sum(b)
|
||
conf = &model.Content{
|
||
Version: ver,
|
||
Md5: hex.EncodeToString(mb[:]),
|
||
Content: string(b),
|
||
}
|
||
return
|
||
}
|
||
|
||
// Push version to clients & generate config caches
|
||
func (s *Service) Push(c context.Context, svr *model.Service) (err error) {
|
||
var (
|
||
hosts []*model.Host
|
||
values []*model.NSValue
|
||
conf *model.Content
|
||
conf2 *model.Content
|
||
namespaces map[int64]string
|
||
)
|
||
if values, err = s.dao.Values(c, svr.Version); err != nil {
|
||
return
|
||
}
|
||
if namespaces, err = s.dao.Namespaces(c, svr.Version); err != nil {
|
||
return
|
||
}
|
||
if len(values) == 0 {
|
||
err = fmt.Errorf("config values is empty. svr:%s, host:%s, buildVer:%s, ver:%d", svr.Name, svr.Host, svr.BuildVersion, svr.Version)
|
||
log.Error("%v", err)
|
||
return
|
||
}
|
||
// compatible old version sdk
|
||
if conf, err = genConfig(svr.Version, values); err != nil {
|
||
log.Error("get config value:%s error(%v) ", values, err)
|
||
return
|
||
}
|
||
cacheKey := cacheKey(svr.Name, svr.BuildVersion, svr.Env, svr.Version)
|
||
if err = s.dao.SetFile(cacheKey, conf); err != nil {
|
||
log.Error("set confCashe error. svr:%s, buildVer:%s, ver:%d", svr.Name, svr.BuildVersion, svr.Env)
|
||
err = nil
|
||
}
|
||
if conf2, err = genConfig2(svr.Version, values, namespaces); err != nil {
|
||
log.Error("get config2 value:%s error(%v) ", values, err)
|
||
return
|
||
}
|
||
cacheKey2 := cacheKey2(svr.Name, svr.BuildVersion, svr.Env, svr.Version)
|
||
if err = s.dao.SetFile(cacheKey2, conf2); err != nil {
|
||
log.Error("set confCashe2 error. svr:%s, buildVer:%s, ver:%d", svr.Name, svr.BuildVersion, svr.Env)
|
||
err = nil
|
||
}
|
||
s.setVersion(svr.Name, svr.BuildVersion, svr.Env, svr.Version)
|
||
// push hosts
|
||
if hosts, err = s.dao.Hosts(c, svr.Name, svr.Env); err != nil {
|
||
log.Error("get hosts error. svr:%s, buildVer:%s, ver:%d", svr.Name, svr.BuildVersion, svr.Version)
|
||
err = nil
|
||
return
|
||
}
|
||
for _, h := range hosts {
|
||
if h.State == model.HostOnline {
|
||
pushKey := pushKey(h.Service, h.Name, svr.Env)
|
||
if ok := s.pubEvent(pushKey, &model.Version{Version: conf.Version}); ok {
|
||
log.Info("s.events.Pub(%s, %d) ok: %t", pushKey, conf.Version, ok)
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// Config return config content.
|
||
func (s *Service) Config(c context.Context, svr *model.Service) (conf *model.Content, err error) {
|
||
var values []*model.NSValue
|
||
if err = s.appAuth(c, svr.Name, svr.Env, svr.Token); err != nil {
|
||
return
|
||
}
|
||
cacheName := cacheKey(svr.Name, svr.BuildVersion, svr.Env, svr.Version)
|
||
if conf, err = s.dao.File(cacheName); err == nil {
|
||
return
|
||
}
|
||
if values, err = s.dao.Values(c, svr.Version); err != nil {
|
||
return
|
||
}
|
||
if len(values) == 0 {
|
||
err = fmt.Errorf("config values is empty. svr:%s, host:%s, buildVer:%s, ver:%d", svr.Name, svr.Host, svr.BuildVersion, svr.Version)
|
||
log.Error("%v", err)
|
||
return
|
||
}
|
||
if conf, err = genConfig(svr.Version, values); err != nil {
|
||
log.Error("get config value:%s error(%v) ", values, err)
|
||
return
|
||
}
|
||
if err = s.dao.SetFile(cacheName, conf); err != nil {
|
||
err = nil
|
||
}
|
||
return
|
||
}
|
||
|
||
// Config2 return config content.
|
||
func (s *Service) Config2(c context.Context, svr *model.Service) (conf *model.Content, err error) {
|
||
var (
|
||
values []*model.NSValue
|
||
namespaces map[int64]string
|
||
)
|
||
if err = s.appAuth(c, svr.Name, svr.Env, svr.Token); err != nil {
|
||
return
|
||
}
|
||
cacheName := cacheKey2(svr.Name, svr.BuildVersion, svr.Env, svr.Version)
|
||
if conf, err = s.dao.File(cacheName); err == nil {
|
||
return
|
||
}
|
||
if namespaces, err = s.dao.Namespaces(c, svr.Version); err != nil {
|
||
return
|
||
}
|
||
if values, err = s.dao.Values(c, svr.Version); err != nil {
|
||
return
|
||
}
|
||
if len(values) == 0 {
|
||
err = fmt.Errorf("config values is empty. svr:%s, host:%s, buildVer:%s, ver:%d", svr.Name, svr.Host, svr.BuildVersion, svr.Version)
|
||
log.Error("%v", err)
|
||
return
|
||
}
|
||
if conf, err = genConfig2(svr.Version, values, namespaces); err != nil {
|
||
log.Error("get config value:(%s) error(%v) ", values, err)
|
||
return
|
||
}
|
||
if err = s.dao.SetFile(cacheName, conf); err != nil {
|
||
err = nil
|
||
}
|
||
return
|
||
}
|
||
|
||
// File get one file content.
|
||
func (s *Service) File(c context.Context, svr *model.Service) (val string, err error) {
|
||
var (
|
||
curVer int64
|
||
ok bool
|
||
)
|
||
if err = s.appAuth(c, svr.Name, svr.Env, svr.Token); err != nil {
|
||
return
|
||
}
|
||
if svr.Version != model.UnknownVersion {
|
||
curVer = svr.Version
|
||
} else {
|
||
curVer, ok = s.version(svr.Name, svr.BuildVersion, svr.Env)
|
||
if !ok {
|
||
if curVer, err = s.dao.BuildVersion(c, svr.Name, svr.BuildVersion, svr.Env); err != nil {
|
||
log.Error("BuildVersion(%v) error(%v)", svr, err)
|
||
return
|
||
}
|
||
s.setVersion(svr.Name, svr.BuildVersion, svr.Env, curVer)
|
||
}
|
||
}
|
||
fKey := fileKey(svr.File, curVer)
|
||
if val, err = s.dao.FileStr(fKey); err == nil {
|
||
return
|
||
}
|
||
if val, err = s.dao.Value(c, svr.File, curVer); err != nil {
|
||
log.Error("Value(%v) error(%v)", svr.File, err)
|
||
return
|
||
}
|
||
s.dao.SetFileStr(fKey, val)
|
||
return
|
||
}
|
||
|
||
// CheckVersion check client version.
|
||
func (s *Service) CheckVersion(c context.Context, rhost *model.Host, env, token string) (evt chan *model.Version, err error) {
|
||
var (
|
||
curVer int64
|
||
)
|
||
if err = s.appAuth(c, rhost.Service, env, token); err != nil {
|
||
return
|
||
}
|
||
// set heartbeat
|
||
rhost.HeartbeatTime = xtime.Time(time.Now().Unix())
|
||
if err = s.dao.SetHost(c, rhost, rhost.Service, env); err != nil {
|
||
err = nil
|
||
}
|
||
evt = make(chan *model.Version, 1)
|
||
if rhost.Appoint > 0 {
|
||
if rhost.Appoint != rhost.ConfigVersion {
|
||
evt <- &model.Version{Version: rhost.Appoint}
|
||
}
|
||
return
|
||
}
|
||
// get current version, return if has new config version
|
||
if curVer, err = s.curVer(c, rhost.Service, rhost.BuildVersion, env); err != nil {
|
||
return
|
||
}
|
||
|
||
if curVer == model.UnknownVersion {
|
||
err = ecode.NothingFound
|
||
return
|
||
}
|
||
if curVer != rhost.ConfigVersion {
|
||
evt <- &model.Version{Version: curVer}
|
||
return
|
||
}
|
||
pushKey := pushKey(rhost.Service, rhost.Name, env)
|
||
s.eLock.Lock()
|
||
s.events[pushKey] = evt
|
||
s.eLock.Unlock()
|
||
return
|
||
}
|
||
|
||
// AppAuth check app is auth
|
||
func (s *Service) appAuth(c context.Context, svr, env, token string) (err error) {
|
||
var (
|
||
dbToken string
|
||
ok bool
|
||
tokenKey = tokenKey(svr, env)
|
||
)
|
||
s.eLock.RLock()
|
||
dbToken, ok = s.token[tokenKey]
|
||
s.eLock.RUnlock()
|
||
if !ok {
|
||
if dbToken, err = s.dao.Token(c, svr, env); err != nil {
|
||
log.Error("Token(%v,%v) error(%v)", svr, env, err)
|
||
return
|
||
}
|
||
s.SetToken(c, svr, env, dbToken)
|
||
}
|
||
|
||
if dbToken != token {
|
||
err = ecode.AccessDenied
|
||
}
|
||
return
|
||
}
|
||
|
||
// SetToken update Token
|
||
func (s *Service) SetToken(c context.Context, svr, env, token string) {
|
||
tokenKey := tokenKey(svr, env)
|
||
s.eLock.Lock()
|
||
s.token[tokenKey] = token
|
||
s.eLock.Unlock()
|
||
}
|
||
|
||
// Hosts return client hosts.
|
||
func (s *Service) Hosts(c context.Context, svr, env string) (hosts []*model.Host, err error) {
|
||
return s.dao.Hosts(c, svr, env)
|
||
}
|
||
|
||
// VersionSuccess return client versions which configuration is complete
|
||
func (s *Service) VersionSuccess(c context.Context, svr, env, bver string) (versions *model.Versions, err error) {
|
||
var (
|
||
vers []*model.ReVer
|
||
ver int64
|
||
)
|
||
if vers, err = s.dao.Versions(c, svr, env, model.ConfigEnd); err != nil {
|
||
log.Error("Versions(%v,%v,%v) error(%v)", svr, env, bver, err)
|
||
return
|
||
}
|
||
if ver, err = s.dao.BuildVersion(c, svr, bver, env); err != nil {
|
||
log.Error("BuildVersion(%v) error(%v)", svr, err)
|
||
return
|
||
}
|
||
versions = &model.Versions{
|
||
Version: vers,
|
||
DefVer: ver,
|
||
}
|
||
return
|
||
}
|
||
|
||
// VersionIng return client versions which configuration is creating
|
||
func (s *Service) VersionIng(c context.Context, svr, env string) (vers []int64, err error) {
|
||
var (
|
||
res []*model.ReVer
|
||
)
|
||
if res, err = s.dao.Versions(c, svr, env, model.ConfigIng); err != nil {
|
||
log.Error("Versions(%v,%v) error(%v)", svr, env, err)
|
||
return
|
||
}
|
||
vers = make([]int64, 0)
|
||
for _, reVer := range res {
|
||
vers = append(vers, reVer.Version)
|
||
}
|
||
return
|
||
}
|
||
|
||
// Builds all builds
|
||
func (s *Service) Builds(c context.Context, svr, env string) (builds []string, err error) {
|
||
return s.dao.Builds(c, svr, env)
|
||
}
|
||
|
||
// AddConfigs insert config into db.
|
||
func (s *Service) AddConfigs(c context.Context, svr, env, token, user string, data map[string]string) (err error) {
|
||
var (
|
||
svrID int64
|
||
ver int64
|
||
)
|
||
if err = s.appAuth(c, svr, env, token); err != nil {
|
||
return
|
||
}
|
||
if svrID, err = s.dao.ServiceID(c, svr, env); err != nil {
|
||
return
|
||
}
|
||
var tx *sql.Tx
|
||
if tx, err = s.dao.BeginTran(c); err != nil {
|
||
log.Error("begin tran error(%v)", err)
|
||
return
|
||
}
|
||
if ver, err = s.dao.TxInsertVer(tx, svrID, user); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
if len(data) != 0 {
|
||
if err = s.dao.TxInsertValues(c, tx, ver, user, data); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
}
|
||
if err = tx.Commit(); err != nil {
|
||
log.Error("tx.Commit error(%v)", err)
|
||
return
|
||
}
|
||
s.dao.InsertLog(c, user, addBusiness, fmt.Sprintf(addInfo, ver))
|
||
return
|
||
}
|
||
|
||
// CopyConfigs copy config in newVer.
|
||
func (s *Service) CopyConfigs(c context.Context, svr, env, token, user string, build string) (ver int64, err error) {
|
||
var (
|
||
svrID int64
|
||
curVer int64
|
||
values []*model.NSValue
|
||
)
|
||
if err = s.appAuth(c, svr, env, token); err != nil {
|
||
return
|
||
}
|
||
if curVer, err = s.curVer(c, svr, build, env); err != nil {
|
||
return
|
||
}
|
||
if values, err = s.dao.Values(c, curVer); err != nil {
|
||
return
|
||
}
|
||
data := make(map[string]string)
|
||
for _, c := range values {
|
||
data[c.Name] = c.Config
|
||
}
|
||
if svrID, err = s.dao.ServiceID(c, svr, env); err != nil {
|
||
return
|
||
}
|
||
var tx *sql.Tx
|
||
if tx, err = s.dao.BeginTran(c); err != nil {
|
||
log.Error("begin tran error(%v)", err)
|
||
return
|
||
}
|
||
if ver, err = s.dao.TxInsertVer(tx, svrID, user); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
if err = s.dao.TxInsertValues(c, tx, ver, user, data); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
if err = tx.Commit(); err != nil {
|
||
log.Error("tx.Commit error(%v)", err)
|
||
return
|
||
}
|
||
s.dao.InsertLog(c, user, copyBusiness, fmt.Sprintf(copyInfo, curVer, ver))
|
||
return
|
||
}
|
||
|
||
// UpdateConfigs update config.
|
||
func (s *Service) UpdateConfigs(c context.Context, svr, env, token, user string, ver int64, data map[string]string) (err error) {
|
||
var (
|
||
values []*model.NSValue
|
||
addData = make(map[string]string)
|
||
udata = make(map[string]string)
|
||
)
|
||
if err = s.appAuth(c, svr, env, token); err != nil {
|
||
return
|
||
}
|
||
if len(data) == 0 {
|
||
return
|
||
}
|
||
if values, err = s.dao.Values(c, ver); err != nil {
|
||
return
|
||
}
|
||
if len(values) == 0 {
|
||
return ecode.NothingFound
|
||
}
|
||
oldData := make(map[string]string)
|
||
for _, c := range values {
|
||
oldData[c.Name] = c.Config
|
||
}
|
||
for k, v := range data {
|
||
if _, ok := oldData[k]; ok {
|
||
udata[k] = v
|
||
} else {
|
||
addData[k] = v
|
||
}
|
||
}
|
||
var tx *sql.Tx
|
||
if tx, err = s.dao.BeginTran(c); err != nil {
|
||
log.Error("begin tran error(%v)", err)
|
||
return
|
||
}
|
||
if len(addData) != 0 {
|
||
if err = s.dao.TxInsertValues(c, tx, ver, user, addData); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
}
|
||
if len(udata) != 0 {
|
||
if err = s.dao.TxUpdateValues(tx, ver, user, udata); err != nil {
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
}
|
||
if err = tx.Commit(); err != nil {
|
||
log.Error("tx.Commit error(%v)", err)
|
||
return
|
||
}
|
||
s.dao.InsertLog(c, user, updateBusiness, fmt.Sprintf(updateInfo, ver))
|
||
return
|
||
}
|
||
|
||
func (s *Service) version(svr, bver, env string) (ver int64, ok bool) {
|
||
verKey := buildVerKey(svr, bver, env)
|
||
s.vLock.RLock()
|
||
ver, ok = s.versions[verKey]
|
||
s.vLock.RUnlock()
|
||
return
|
||
}
|
||
|
||
func (s *Service) setVersion(svr, bver, env string, ver int64) {
|
||
verKey := buildVerKey(svr, bver, env)
|
||
s.vLock.Lock()
|
||
s.versions[verKey] = ver
|
||
s.vLock.Unlock()
|
||
}
|
||
|
||
// ClearHost clear service hosts.
|
||
func (s *Service) ClearHost(c context.Context, svr, env string) (err error) {
|
||
return s.dao.ClearHost(c, svr, env)
|
||
}
|
||
|
||
// pubEvent publish a event to chan.
|
||
func (s *Service) pubEvent(key string, evt *model.Version) (ok bool) {
|
||
s.eLock.RLock()
|
||
c, ok := s.events[key]
|
||
s.eLock.RUnlock()
|
||
if ok {
|
||
c <- evt
|
||
}
|
||
return
|
||
}
|
||
|
||
// Unsub unsub a event.
|
||
func (s *Service) Unsub(svr, host, env string) {
|
||
key := pushKey(svr, host, env)
|
||
s.eLock.Lock()
|
||
delete(s.events, key)
|
||
s.eLock.Unlock()
|
||
}
|
||
|
||
func (s *Service) curVer(c context.Context, svr, build, env string) (ver int64, err error) {
|
||
var ok bool
|
||
// get current version, return if has new config version
|
||
ver, ok = s.version(svr, build, env)
|
||
if !ok {
|
||
if ver, err = s.dao.BuildVersion(c, svr, build, env); err != nil {
|
||
return
|
||
}
|
||
s.setVersion(svr, build, env, ver)
|
||
}
|
||
return
|
||
}
|