CL-Softwares
/
modelRT
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor(handler): use logger package log func replace zap log func

This commit is contained in:
douxu 2025-06-06 16:41:52 +08:00
parent 9aa5b0dcc6
commit f6cee44f84
20 changed files with 145 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
database/query_component.go
View File

@ -6,17 +6,17 @@ import (
"time"
"modelRT/config"
"modelRT/logger"
"modelRT/orm"
"github.com/gofrs/uuid"
"github.com/panjf2000/ants/v2"
"go.uber.org/zap"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
// QueryCircuitDiagramComponentFromDB return the result of query circuit diagram component info order by page id from postgresDB
func QueryCircuitDiagramComponentFromDB(ctx context.Context, tx *gorm.DB, pool *ants.PoolWithFunc, logger *zap.Logger) (map[uuid.UUID]int, error) {
func QueryCircuitDiagramComponentFromDB(ctx context.Context, tx *gorm.DB, pool *ants.PoolWithFunc) (map[uuid.UUID]int, error) {
var components []orm.Component
// ctx超时判断
cancelCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
@ -24,7 +24,7 @@ func QueryCircuitDiagramComponentFromDB(ctx context.Context, tx *gorm.DB, pool *
result := tx.WithContext(cancelCtx).Clauses(clause.Locking{Strength: "UPDATE"}).Find(&components)
if result.Error != nil {
logger.Error("query circuit diagram component info failed", zap.Error(result.Error))
logger.Error(ctx, "query circuit diagram component info failed", "error", result.Error)
return nil, result.Error
}
@ -34,7 +34,7 @@ func QueryCircuitDiagramComponentFromDB(ctx context.Context, tx *gorm.DB, pool *
for _, component := range components {
pool.Invoke(config.ModelParseConfig{
ComponentInfo: component,
Context: ctx,
Ctx: ctx,
})
componentTypeMap[component.GlobalUUID] = component.ComponentType

9
database/query_page.go
View File

@ -5,26 +5,25 @@ import (
"context"
"time"
"modelRT/logger"
"modelRT/orm"
"go.uber.org/zap"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
// QueryAllPages return the all page info of the circuit diagram query by grid_id and zone_id and station_id
func QueryAllPages(ctx context.Context, tx *gorm.DB, logger *zap.Logger, gridID, zoneID, stationID int64) ([]orm.Page, error) {
func QueryAllPages(ctx context.Context, tx *gorm.DB, gridID, zoneID, stationID int64) ([]orm.Page, error) {
var pages []orm.Page
// ctx超时判断
// ctx timeout judgment
cancelCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
result := tx.Model(&orm.Page{}).WithContext(cancelCtx).Clauses(clause.Locking{Strength: "UPDATE"}).Select(`"page".id, "page".Name, "page".status,"page".context`).Joins(`inner join "station" on "station".id = "page".station_id`).Joins(`inner join "zone" on "zone".id = "station".zone_id`).Joins(`inner join "grid" on "grid".id = "zone".grid_id`).Where(`"grid".id = ? and "zone".id = ? and "station".id = ?`, gridID, zoneID, stationID).Scan(&pages)
if result.Error != nil {
logger.Error("query circuit diagram pages by gridID and zoneID and stationID failed", zap.Int64("grid_id", gridID), zap.Int64("zone_id", zoneID), zap.Int64("station_id", stationID), zap.Error(result.Error))
logger.Error(ctx, "query circuit diagram pages by gridID and zoneID and stationID failed", "grid_id", gridID, "zone_id", zoneID, "station_id", stationID, "error", result.Error)
return nil, result.Error
}
return pages, nil
}

14
database/query_topologic.go
View File

@ -8,17 +8,17 @@ import (
"modelRT/constant"
"modelRT/diagram"
"modelRT/logger"
"modelRT/orm"
"modelRT/sql"
"github.com/gofrs/uuid"
"go.uber.org/zap"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
// QueryTopologic return the topologic info of the circuit diagram
func QueryTopologic(ctx context.Context, tx *gorm.DB, logger *zap.Logger) ([]orm.Topologic, error) {
func QueryTopologic(ctx context.Context, tx *gorm.DB) ([]orm.Topologic, error) {
var topologics []orm.Topologic
// ctx超时判断
cancelCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
@ -26,23 +26,23 @@ func QueryTopologic(ctx context.Context, tx *gorm.DB, logger *zap.Logger) ([]orm
result := tx.WithContext(cancelCtx).Clauses(clause.Locking{Strength: "UPDATE"}).Raw(sql.RecursiveSQL, constant.UUIDNilStr).Scan(&topologics)
if result.Error != nil {
logger.Error("query circuit diagram topologic info by start node uuid failed", zap.String("start_node_uuid", constant.UUIDNilStr), zap.Error(result.Error))
logger.Error(ctx, "query circuit diagram topologic info by start node uuid failed", "start_node_uuid", constant.UUIDNilStr, "error", result.Error)
return nil, result.Error
}
return topologics, nil
}
// QueryTopologicFromDB return the result of query topologic info from DB
func QueryTopologicFromDB(ctx context.Context, tx *gorm.DB, logger *zap.Logger, componentTypeMap map[uuid.UUID]int) (*diagram.MultiBranchTreeNode, error) {
topologicInfos, err := QueryTopologic(ctx, tx, logger)
func QueryTopologicFromDB(ctx context.Context, tx *gorm.DB, componentTypeMap map[uuid.UUID]int) (*diagram.MultiBranchTreeNode, error) {
topologicInfos, err := QueryTopologic(ctx, tx)
if err != nil {
logger.Error("query topologic info failed", zap.Error(err))
logger.Error(ctx, "query topologic info failed", "error", err)
return nil, err
}
tree, err := BuildMultiBranchTree(topologicInfos, componentTypeMap)
if err != nil {
logger.Error("init topologic failed", zap.Error(err))
logger.Error(ctx, "init topologic failed", "error", err)
return nil, err
}
return tree, nil

20
diagram/redis_hash.go
View File

@ -7,8 +7,6 @@ import (
"modelRT/logger"
"github.com/redis/go-redis/v9"
"go.uber.org/zap"
)
// RedisHash defines the encapsulation struct of redis hash type
@ -16,7 +14,6 @@ type RedisHash struct {
ctx context.Context
rwLocker *locker.RedissionRWLocker
storageClient *redis.Client
logger *zap.Logger
}
// NewRedisHash define func of new redis hash instance
@ -25,7 +22,6 @@ func NewRedisHash(ctx context.Context, hashKey string, token string, lockLeaseTi
ctx: ctx,
rwLocker: locker.InitRWLocker(hashKey, token, lockLeaseTime, needRefresh),
storageClient: GetRedisClientInstance(),
logger: logger.GetLoggerInstance(),
}
}
@ -33,14 +29,14 @@ func NewRedisHash(ctx context.Context, hashKey string, token string, lockLeaseTi
func (rh *RedisHash) SetRedisHashByMap(hashKey string, fields map[string]interface{}) error {
err := rh.rwLocker.WLock(rh.ctx)
if err != nil {
rh.logger.Error("lock wLock by hashKey failed", zap.String("hashKey", hashKey), zap.Error(err))
logger.Error(rh.ctx, "lock wLock by hash_key failed", "hash_key", hashKey, "error", err)
return err
}
defer rh.rwLocker.UnWLock(rh.ctx)
err = rh.storageClient.HSet(rh.ctx, hashKey, fields).Err()
if err != nil {
rh.logger.Error("set hash by map failed", zap.String("hashKey", hashKey), zap.Any("fields", fields), zap.Error(err))
logger.Error(rh.ctx, "set hash by map failed", "hash_key", hashKey, "fields", fields, "error", err)
return err
}
return nil
@ -50,14 +46,14 @@ func (rh *RedisHash) SetRedisHashByMap(hashKey string, fields map[string]interfa
func (rh *RedisHash) SetRedisHashByKV(hashKey string, field string, value interface{}) error {
err := rh.rwLocker.WLock(rh.ctx)
if err != nil {
rh.logger.Error("lock wLock by hashKey failed", zap.String("hashKey", hashKey), zap.Error(err))
logger.Error(rh.ctx, "lock wLock by hash_key failed", "hash_key", hashKey, "error", err)
return err
}
defer rh.rwLocker.UnWLock(rh.ctx)
err = rh.storageClient.HSet(rh.ctx, hashKey, field, value).Err()
if err != nil {
rh.logger.Error("set hash by kv failed", zap.String("hashKey", hashKey), zap.String("field", field), zap.Any("value", value), zap.Error(err))
logger.Error(rh.ctx, "set hash by kv failed", "hash_key", hashKey, "field", field, "value", value, "error", err)
return err
}
return nil
@ -67,14 +63,14 @@ func (rh *RedisHash) SetRedisHashByKV(hashKey string, field string, value interf
func (rh *RedisHash) HGet(hashKey string, field string) (string, error) {
err := rh.rwLocker.RLock(rh.ctx)
if err != nil {
rh.logger.Error("lock rLock by hashKey failed", zap.String("hashKey", hashKey), zap.Error(err))
logger.Error(rh.ctx, "lock rLock by hash_key failed", "hash_key", hashKey, "error", err)
return "", err
}
defer rh.rwLocker.UnRLock(rh.ctx)
result, err := rh.storageClient.HGet(rh.ctx, hashKey, field).Result()
if err != nil {
rh.logger.Error("set hash by kv failed", zap.String("hashKey", hashKey), zap.String("field", field), zap.Error(err))
logger.Error(rh.ctx, "set hash by kv failed", "hash_key", hashKey, "field", field, "error", err)
return "", err
}
return result, nil
@ -84,14 +80,14 @@ func (rh *RedisHash) HGet(hashKey string, field string) (string, error) {
func (rh *RedisHash) HGetAll(hashKey string) (map[string]string, error) {
err := rh.rwLocker.RLock(rh.ctx)
if err != nil {
rh.logger.Error("lock rLock by hashKey failed", zap.String("hashKey", hashKey), zap.Error(err))
logger.Error(rh.ctx, "lock rLock by hash_key failed", "hash_key", hashKey, "error", err)
return nil, err
}
defer rh.rwLocker.UnRLock(rh.ctx)
result, err := rh.storageClient.HGetAll(rh.ctx, hashKey).Result()
if err != nil {
rh.logger.Error("get all hash field by hash key failed", zap.String("hashKey", hashKey), zap.Error(err))
logger.Error(rh.ctx, "get all hash field by hash key failed", "hash_key", hashKey, "error", err)
return nil, err
}
return result, nil

18
diagram/redis_set.go
View File

@ -33,14 +33,14 @@ func NewRedisSet(ctx context.Context, hashKey string, token string, lockLeaseTim
func (rs *RedisSet) SADD(setKey string, members ...interface{}) error {
err := rs.rwLocker.WLock(rs.ctx)
if err != nil {
rs.logger.Error("lock wLock by setKey failed", zap.String("setKey", setKey), zap.Error(err))
logger.Error(rs.ctx, "lock wLock by setKey failed", "set_key", setKey, "error", err)
return err
}
defer rs.rwLocker.UnWLock(rs.ctx)
err = rs.storageClient.SAdd(rs.ctx, setKey, members).Err()
if err != nil {
rs.logger.Error("add set by memebers failed", zap.String("setKey", setKey), zap.Any("members", members), zap.Error(err))
logger.Error(rs.ctx, "add set by memebers failed", "set_key", setKey, "members", members, "error", err)
return err
}
return nil
@ -50,14 +50,14 @@ func (rs *RedisSet) SADD(setKey string, members ...interface{}) error {
func (rs *RedisSet) SREM(setKey string, members ...interface{}) error {
err := rs.rwLocker.WLock(rs.ctx)
if err != nil {
rs.logger.Error("lock wLock by setKey failed", zap.String("setKey", setKey), zap.Error(err))
logger.Error(rs.ctx, "lock wLock by setKey failed", "set_key", setKey, "error", err)
return err
}
defer rs.rwLocker.UnWLock(rs.ctx)
count, err := rs.storageClient.SRem(rs.ctx, setKey, members).Result()
if err != nil || count != int64(len(members)) {
rs.logger.Error("rem members from set failed", zap.String("setKey", setKey), zap.Any("members", members), zap.Error(err))
logger.Error(rs.ctx, "rem members from set failed", "set_key", setKey, "members", members, "error", err)
return fmt.Errorf("rem members from set failed:%w", err)
}
@ -68,24 +68,24 @@ func (rs *RedisSet) SREM(setKey string, members ...interface{}) error {
func (rs *RedisSet) SMembers(setKey string) ([]string, error) {
err := rs.rwLocker.RLock(rs.ctx)
if err != nil {
rs.logger.Error("lock rLock by setKey failed", zap.String("setKey", setKey), zap.Error(err))
logger.Error(rs.ctx, "lock rLock by setKey failed", "set_key", setKey, "error", err)
return nil, err
}
defer rs.rwLocker.UnRLock(rs.ctx)
result, err := rs.storageClient.SMembers(rs.ctx, setKey).Result()
if err != nil {
rs.logger.Error("get all hash field by hash key failed", zap.String("setKey", setKey), zap.Error(err))
logger.Error(rs.ctx, "get all set field by hash key failed", "set_key", setKey, "error", err)
return nil, err
}
return result, nil
}
// SIsMember define func of determine whether an member is in set by key
func (rh *RedisHash) SIsMember(setKey string, member interface{}) (bool, error) {
result, err := rh.storageClient.SIsMember(rh.ctx, setKey, member).Result()
func (rs *RedisSet) SIsMember(setKey string, member interface{}) (bool, error) {
result, err := rs.storageClient.SIsMember(rs.ctx, setKey, member).Result()
if err != nil {
rh.logger.Error("get all hash field by hash key failed", zap.String("setKey", setKey), zap.Error(err))
logger.Error(rs.ctx, "get all set field by hash key failed", "set_key", setKey, "error", err)
return false, err
}
return result, nil

36
distributedlock/redis_lock.go
View File

@ -43,7 +43,6 @@ type redissionLocker struct {
subExitChan chan struct{}
client *redis.Client
refreshOnce *sync.Once
Logger *zap.Logger
}
func (rl *redissionLocker) Lock(ctx context.Context, timeout ...time.Duration) error {
@ -52,7 +51,7 @@ func (rl *redissionLocker) Lock(ctx context.Context, timeout ...time.Duration) e
}
result := rl.tryLock(ctx).(*constant.RedisResult)
if result.Code == constant.UnknownInternalError {
rl.Logger.Error(result.OutputResultMessage())
logger.Error(ctx, result.OutputResultMessage())
return fmt.Errorf("get lock failed:%w", result)
}
@ -68,7 +67,7 @@ func (rl *redissionLocker) Lock(ctx context.Context, timeout ...time.Duration) e
defer close(subMsg)
sub := rl.client.Subscribe(ctx, rl.waitChanKey)
defer sub.Close()
go rl.subscribeLock(sub, subMsg)
go rl.subscribeLock(ctx, sub, subMsg)
if len(timeout) > 0 && timeout[0] > 0 {
acquireTimer := time.NewTimer(timeout[0])
@ -77,23 +76,23 @@ func (rl *redissionLocker) Lock(ctx context.Context, timeout ...time.Duration) e
case _, ok := <-subMsg:
if !ok {
err := errors.New("failed to read the lock waiting for for the channel message")
rl.Logger.Error("failed to read the lock waiting for for the channel message")
logger.Error(ctx, "failed to read the lock waiting for for the channel message")
return err
}
resultErr := rl.tryLock(ctx).(*constant.RedisResult)
if (resultErr.Code == constant.LockFailure) || (resultErr.Code == constant.UnknownInternalError) {
rl.Logger.Info(resultErr.OutputResultMessage())
logger.Info(ctx, resultErr.OutputResultMessage())
continue
}
if resultErr.Code == constant.LockSuccess {
rl.Logger.Info(resultErr.OutputResultMessage())
logger.Info(ctx, resultErr.OutputResultMessage())
return nil
}
case <-acquireTimer.C:
err := errors.New("the waiting time for obtaining the lock operation has timed out")
rl.Logger.Info("the waiting time for obtaining the lock operation has timed out")
logger.Info(ctx, "the waiting time for obtaining the lock operation has timed out")
return err
}
}
@ -101,11 +100,11 @@ func (rl *redissionLocker) Lock(ctx context.Context, timeout ...time.Duration) e
return fmt.Errorf("lock the redis lock failed:%w", result)
}
func (rl *redissionLocker) subscribeLock(sub *redis.PubSub, subMsgChan chan struct{}) {
func (rl *redissionLocker) subscribeLock(ctx context.Context, sub *redis.PubSub, subMsgChan chan struct{}) {
if sub == nil || subMsgChan == nil {
return
}
rl.Logger.Info("lock: enter sub routine", zap.String("token", rl.Token))
logger.Info(ctx, "lock: enter sub routine", zap.String("token", rl.Token))
for {
select {
@ -126,7 +125,7 @@ ARGV[1]:锁的过期时间（lockLeaseTime）,单位为秒。
ARGV[2]:当前客户端的唯一标识（token）,用于区分不同的客户端。
*/
func (rl *redissionLocker) refreshLockTimeout(ctx context.Context) {
rl.Logger.Info("lock refresh by key and token", zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Info(ctx, "lock refresh by key and token", zap.String("token", rl.Token), zap.String("key", rl.Key))
lockTime := time.Duration(rl.lockLeaseTime/3) * time.Millisecond
timer := time.NewTimer(lockTime)
@ -139,17 +138,17 @@ func (rl *redissionLocker) refreshLockTimeout(ctx context.Context) {
res := rl.client.Eval(ctx, luascript.RefreshLockScript, []string{rl.Key}, rl.lockLeaseTime, rl.Token)
val, err := res.Int()
if err != redis.Nil && err != nil {
rl.Logger.Info("lock refresh failed", zap.String("token", rl.Token), zap.String("key", rl.Key), zap.Error(err))
logger.Info(ctx, "lock refresh failed", "token", rl.Token, "key", rl.Key, "error", err)
return
}
if constant.RedisCode(val) == constant.RefreshLockFailure {
rl.Logger.Error("lock refreash failed,can not find the lock by key and token", zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Error(ctx, "lock refreash failed,can not find the lock by key and token", "token", rl.Token, "key", rl.Key)
break
}
if constant.RedisCode(val) == constant.RefreshLockSuccess {
rl.Logger.Info("lock refresh success by key and token", zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Info(ctx, "lock refresh success by key and token", "token", rl.Token, "key", rl.Key)
}
timer.Reset(lockTime)
case <-rl.refreshExitChan:
@ -165,11 +164,11 @@ func (rl *redissionLocker) cancelRefreshLockTime() {
}
}
func (rl *redissionLocker) closeSub(sub *redis.PubSub, noticeChan chan struct{}) {
func (rl *redissionLocker) closeSub(ctx context.Context, sub *redis.PubSub, noticeChan chan struct{}) {
if sub != nil {
err := sub.Close()
if err != nil {
rl.Logger.Error("close sub failed", zap.String("token", rl.Token), zap.String("key", rl.Key), zap.Error(err))
logger.Error(ctx, "close sub failed", "token", rl.Token, "key", rl.Key, "error", err)
}
}
@ -203,7 +202,7 @@ func (rl *redissionLocker) UnLock(ctx context.Context) error {
res := rl.client.Eval(ctx, luascript.UnLockScript, []string{rl.Key, rl.waitChanKey}, unlockMessage, rl.Token)
val, err := res.Int()
if err != redis.Nil && err != nil {
rl.Logger.Info("unlock lock failed", zap.String("token", rl.Token), zap.String("key", rl.Key), zap.Error(err))
logger.Info(ctx, "unlock lock failed", zap.String("token", rl.Token), zap.String("key", rl.Key), zap.Error(err))
return fmt.Errorf("unlock lock failed:%w", constant.NewRedisResult(constant.UnknownInternalError, constant.UnLockType, err.Error()))
}
@ -212,12 +211,12 @@ func (rl *redissionLocker) UnLock(ctx context.Context) error {
rl.cancelRefreshLockTime()
}
rl.Logger.Info("unlock lock success", zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Info(ctx, "unlock lock success", zap.String("token", rl.Token), zap.String("key", rl.Key))
return nil
}
if constant.RedisCode(val) == constant.UnLocakFailureWithLockOccupancy {
rl.Logger.Info("unlock lock failed", zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Info(ctx, "unlock lock failed", zap.String("token", rl.Token), zap.String("key", rl.Key))
return fmt.Errorf("unlock lock failed:%w", constant.NewRedisResult(constant.UnLocakFailureWithLockOccupancy, constant.UnLockType, ""))
}
return nil
@ -252,7 +251,6 @@ func GetLocker(client *redis.Client, ops *RedissionLockConfig) *redissionLocker
needRefresh: ops.NeedRefresh,
client: client,
refreshExitChan: make(chan struct{}),
Logger: logger.GetLoggerInstance(),
}
return r
}

60
distributedlock/redis_rwlock.go
View File

@ -14,7 +14,6 @@ import (
uuid "github.com/gofrs/uuid"
"github.com/redis/go-redis/v9"
"go.uber.org/zap"
)
type RedissionRWLocker struct {
@ -27,7 +26,7 @@ type RedissionRWLocker struct {
func (rl *RedissionRWLocker) RLock(ctx context.Context, timeout ...time.Duration) error {
result := rl.tryRLock(ctx).(*constant.RedisResult)
if result.Code == constant.UnknownInternalError {
rl.Logger.Error(result.OutputResultMessage())
logger.Error(ctx, result.OutputResultMessage())
return fmt.Errorf("get read lock failed:%w", result)
}
@ -42,7 +41,7 @@ func (rl *RedissionRWLocker) RLock(ctx context.Context, timeout ...time.Duration
go rl.refreshLockTimeout(ctx)
})
}
rl.Logger.Info("success get the read lock by key and token", zap.String("key", rl.Key), zap.String("token", rl.Token))
logger.Info(ctx, "success get the read lock by key and token", "key", rl.Key, "token", rl.Token)
return nil
}
@ -53,7 +52,7 @@ func (rl *RedissionRWLocker) RLock(ctx context.Context, timeout ...time.Duration
subMsgChan := make(chan struct{}, 1)
sub := rl.client.Subscribe(ctx, rl.readWaitChanKey)
go rl.subscribeLock(sub, subMsgChan)
go rl.subscribeLock(ctx, sub, subMsgChan)
acquireTimer := time.NewTimer(timeout[0])
for {
@ -61,19 +60,19 @@ func (rl *RedissionRWLocker) RLock(ctx context.Context, timeout ...time.Duration
case _, ok := <-subMsgChan:
if !ok {
err := errors.New("failed to read the read lock waiting for for the channel message")
rl.Logger.Error("failed to read the read lock waiting for for the channel message")
logger.Error(ctx, "failed to read the read lock waiting for for the channel message")
return err
}
result := rl.tryRLock(ctx).(*constant.RedisResult)
if (result.Code == constant.RLockFailureWithWLockOccupancy) || (result.Code == constant.UnknownInternalError) {
rl.Logger.Info(result.OutputResultMessage())
logger.Info(ctx, result.OutputResultMessage())
continue
}
if result.Code == constant.LockSuccess {
rl.Logger.Info(result.OutputResultMessage())
rl.closeSub(sub, rl.subExitChan)
logger.Info(ctx, result.OutputResultMessage())
rl.closeSub(ctx, sub, rl.subExitChan)
if rl.needRefresh {
rl.refreshOnce.Do(func() {
@ -88,8 +87,8 @@ func (rl *RedissionRWLocker) RLock(ctx context.Context, timeout ...time.Duration
return nil
}
case <-acquireTimer.C:
rl.Logger.Info("the waiting time for obtaining the read lock operation has timed out")
rl.closeSub(sub, rl.subExitChan)
logger.Info(ctx, "the waiting time for obtaining the read lock operation has timed out")
rl.closeSub(ctx, sub, rl.subExitChan)
// after acquire lock timeout,notice the sub channel to close
return constant.AcquireTimeoutErr
}
@ -110,7 +109,7 @@ func (rl *RedissionRWLocker) tryRLock(ctx context.Context) error {
}
func (rl *RedissionRWLocker) refreshLockTimeout(ctx context.Context) {
rl.Logger.Info("lock refresh by key and token", zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Info(ctx, "lock refresh by key and token", "token", rl.Token, "key", rl.Key)
lockTime := time.Duration(rl.lockLeaseTime/3) * time.Millisecond
timer := time.NewTimer(lockTime)
@ -123,17 +122,17 @@ func (rl *RedissionRWLocker) refreshLockTimeout(ctx context.Context) {
res := rl.client.Eval(ctx, luascript.RefreshRWLockScript, []string{rl.Key, rl.RWTokenTimeoutPrefix}, rl.lockLeaseTime, rl.Token)
val, err := res.Int()
if err != redis.Nil && err != nil {
rl.Logger.Info("lock refresh failed", zap.String("token", rl.Token), zap.String("key", rl.Key), zap.Error(err))
logger.Info(ctx, "lock refresh failed", "token", rl.Token, "key", rl.Key, "error", err)
return
}
if constant.RedisCode(val) == constant.RefreshLockFailure {
rl.Logger.Error("lock refreash failed,can not find the read lock by key and token", zap.String("rwTokenPrefix", rl.RWTokenTimeoutPrefix), zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Error(ctx, "lock refreash failed,can not find the read lock by key and token", "rwTokenPrefix", rl.RWTokenTimeoutPrefix, "token", rl.Token, "key", rl.Key)
return
}
if constant.RedisCode(val) == constant.RefreshLockSuccess {
rl.Logger.Info("lock refresh success by key and token", zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Info(ctx, "lock refresh success by key and token", "token", rl.Token, "key", rl.Key)
}
timer.Reset(lockTime)
case <-rl.refreshExitChan:
@ -143,11 +142,11 @@ func (rl *RedissionRWLocker) refreshLockTimeout(ctx context.Context) {
}
func (rl *RedissionRWLocker) UnRLock(ctx context.Context) error {
rl.Logger.Info("unlock RLock by key and token", zap.String("key", rl.Key), zap.String("token", rl.Token))
logger.Info(ctx, "unlock RLock by key and token", "key", rl.Key, "token", rl.Token)
res := rl.client.Eval(ctx, luascript.UnRLockScript, []string{rl.Key, rl.RWTokenTimeoutPrefix, rl.writeWaitChanKey}, unlockMessage, rl.Token)
val, err := res.Int()
if err != redis.Nil && err != nil {
rl.Logger.Info("unlock read lock failed", zap.String("token", rl.Token), zap.String("key", rl.Key), zap.Error(err))
logger.Info(ctx, "unlock read lock failed", "token", rl.Token, "key", rl.Key, "error", err)
return fmt.Errorf("unlock read lock failed:%w", constant.NewRedisResult(constant.UnknownInternalError, constant.UnRLockType, err.Error()))
}
@ -156,12 +155,12 @@ func (rl *RedissionRWLocker) UnRLock(ctx context.Context) error {
rl.cancelRefreshLockTime()
}
rl.Logger.Info("unlock read lock success", zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Info(ctx, "unlock read lock success", "token", rl.Token, "key", rl.Key)
return nil
}
if constant.RedisCode(val) == constant.UnRLockFailureWithWLockOccupancy {
rl.Logger.Info("unlock read lock failed", zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Info(ctx, "unlock read lock failed", "token", rl.Token, "key", rl.Key)
return fmt.Errorf("unlock read lock failed:%w", constant.NewRedisResult(constant.UnRLockFailureWithWLockOccupancy, constant.UnRLockType, ""))
}
return nil
@ -170,7 +169,7 @@ func (rl *RedissionRWLocker) UnRLock(ctx context.Context) error {
func (rl *RedissionRWLocker) WLock(ctx context.Context, timeout ...time.Duration) error {
result := rl.tryWLock(ctx).(*constant.RedisResult)
if result.Code == constant.UnknownInternalError {
rl.Logger.Error(result.OutputResultMessage())
logger.Error(ctx, result.OutputResultMessage())
return fmt.Errorf("get write lock failed:%w", result)
}
@ -185,7 +184,7 @@ func (rl *RedissionRWLocker) WLock(ctx context.Context, timeout ...time.Duration
go rl.refreshLockTimeout(ctx)
})
}
rl.Logger.Info("success get the write lock by key and token", zap.String("key", rl.Key), zap.String("token", rl.Token))
logger.Info(ctx, "success get the write lock by key and token", "key", rl.Key, "token", rl.Token)
return nil
}
@ -196,7 +195,7 @@ func (rl *RedissionRWLocker) WLock(ctx context.Context, timeout ...time.Duration
subMsgChan := make(chan struct{}, 1)
sub := rl.client.Subscribe(ctx, rl.writeWaitChanKey)
go rl.subscribeLock(sub, subMsgChan)
go rl.subscribeLock(ctx, sub, subMsgChan)
acquireTimer := time.NewTimer(timeout[0])
for {
@ -204,19 +203,19 @@ func (rl *RedissionRWLocker) WLock(ctx context.Context, timeout ...time.Duration
case _, ok := <-subMsgChan:
if !ok {
err := errors.New("failed to read the write lock waiting for for the channel message")
rl.Logger.Error("failed to read the read lock waiting for for the channel message")
logger.Error(ctx, "failed to read the read lock waiting for for the channel message")
return err
}
result := rl.tryWLock(ctx).(*constant.RedisResult)
if (result.Code == constant.UnknownInternalError) || (result.Code == constant.WLockFailureWithRLockOccupancy) || (result.Code == constant.WLockFailureWithWLockOccupancy) || (result.Code == constant.WLockFailureWithNotFirstPriority) {
rl.Logger.Info(result.OutputResultMessage())
logger.Info(ctx, result.OutputResultMessage())
continue
}
if result.Code == constant.LockSuccess {
rl.Logger.Info(result.OutputResultMessage())
rl.closeSub(sub, rl.subExitChan)
logger.Info(ctx, result.OutputResultMessage())
rl.closeSub(ctx, sub, rl.subExitChan)
if rl.needRefresh {
rl.refreshOnce.Do(func() {
@ -231,8 +230,8 @@ func (rl *RedissionRWLocker) WLock(ctx context.Context, timeout ...time.Duration
return nil
}
case <-acquireTimer.C:
rl.Logger.Info("the waiting time for obtaining the write lock operation has timed out")
rl.closeSub(sub, rl.subExitChan)
logger.Info(ctx, "the waiting time for obtaining the write lock operation has timed out")
rl.closeSub(ctx, sub, rl.subExitChan)
// after acquire lock timeout,notice the sub channel to close
return constant.AcquireTimeoutErr
}
@ -256,7 +255,7 @@ func (rl *RedissionRWLocker) UnWLock(ctx context.Context) error {
res := rl.client.Eval(ctx, luascript.UnWLockScript, []string{rl.Key, rl.RWTokenTimeoutPrefix, rl.writeWaitChanKey, rl.readWaitChanKey}, unlockMessage, rl.Token)
val, err := res.Int()
if err != redis.Nil && err != nil {
rl.Logger.Error("unlock write lock failed", zap.String("token", rl.Token), zap.String("key", rl.Key), zap.Error(err))
logger.Error(ctx, "unlock write lock failed", "token", rl.Token, "key", rl.Key, "error", err)
return fmt.Errorf("unlock write lock failed:%w", constant.NewRedisResult(constant.UnknownInternalError, constant.UnWLockType, err.Error()))
}
@ -264,12 +263,12 @@ func (rl *RedissionRWLocker) UnWLock(ctx context.Context) error {
if rl.needRefresh && (constant.RedisCode(val) == constant.UnLockSuccess) {
rl.cancelRefreshLockTime()
}
rl.Logger.Info("unlock write lock success", zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Info(ctx, "unlock write lock success", "token", rl.Token, "key", rl.Key)
return nil
}
if (constant.RedisCode(val) == constant.UnWLockFailureWithRLockOccupancy) || (constant.RedisCode(val) == constant.UnWLockFailureWithWLockOccupancy) {
rl.Logger.Info("unlock write lock failed", zap.String("token", rl.Token), zap.String("key", rl.Key))
logger.Info(ctx, "unlock write lock failed", "token", rl.Token, "key", rl.Key)
return fmt.Errorf("unlock write lock failed:%w", constant.NewRedisResult(constant.RedisCode(val), constant.UnWLockType, ""))
}
return nil
@ -308,7 +307,6 @@ func GetRWLocker(client *redis.Client, conf *RedissionLockConfig) *RedissionRWLo
lockLeaseTime: conf.LockLeaseTime,
client: client,
refreshOnce: &sync.Once{},
Logger: logger.GetLoggerInstance(),
}
rwLocker := &RedissionRWLocker{

5
handler/alert_event_query.go
View File

@ -11,20 +11,17 @@ import (
"modelRT/network"
"github.com/gin-gonic/gin"
"go.uber.org/zap"
)
// QueryAlertEventHandler define query alert event process API
func QueryAlertEventHandler(c *gin.Context) {
var targetLevel constant.AlertLevel
logger := logger.GetLoggerInstance()
alertManger := alert.GetAlertMangerInstance()
levelStr := c.Query("level")
level, err := strconv.Atoi(levelStr)
if err != nil {
logger.Error("convert alert level string to int failed", zap.Error(err))
logger.Error(c, "convert alert level string to int failed", "error", err)
resp := network.FailureResponse{
Code: -1,

16
handler/anchor_point_replace.go
View File

@ -16,21 +16,19 @@ import (
"modelRT/orm"
"github.com/gin-gonic/gin"
"go.uber.org/zap"
)
// ComponentAnchorReplaceHandler define component anchor point replace process API
func ComponentAnchorReplaceHandler(c *gin.Context) {
var uuid, anchorName string
logger := logger.GetLoggerInstance()
pgClient := database.GetPostgresDBClient()
pgClient := database.GetPostgresDBClient()
cancelCtx, cancel := context.WithTimeout(c, 5*time.Second)
defer cancel()
var request network.ComponetAnchorReplaceRequest
if err := c.ShouldBindJSON(&request); err != nil {
logger.Error("unmarshal component anchor point replace info failed", zap.Error(err))
logger.Error(c, "unmarshal component anchor point replace info failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -45,7 +43,7 @@ func ComponentAnchorReplaceHandler(c *gin.Context) {
var componentInfo orm.Component
result := pgClient.WithContext(cancelCtx).Model(&orm.Component{}).Where("global_uuid = ?", uuid).Find(&componentInfo)
if result.Error != nil {
logger.Error("query component detail info failed", zap.Error(result.Error))
logger.Error(c, "query component detail info failed", "error", result.Error)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -57,7 +55,7 @@ func ComponentAnchorReplaceHandler(c *gin.Context) {
if result.RowsAffected == 0 {
err := fmt.Errorf("query component detail info by uuid failed:%w", constant.ErrQueryRowZero)
logger.Error("query component detail info from table is empty", zap.String("table_name", "component"))
logger.Error(c, "query component detail info from table is empty", "table_name", "component")
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -73,7 +71,7 @@ func ComponentAnchorReplaceHandler(c *gin.Context) {
tableName := model.SelectModelNameByType(componentInfo.ComponentType)
result = pgClient.WithContext(cancelCtx).Table(tableName).Where("global_uuid = ?", uuid).Find(&unmarshalMap)
if result.Error != nil {
logger.Error("query model detail info failed", zap.Error(result.Error))
logger.Error(c, "query model detail info failed", "error", result.Error)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -85,7 +83,7 @@ func ComponentAnchorReplaceHandler(c *gin.Context) {
if unmarshalMap == nil {
err := fmt.Errorf("query model detail info by uuid failed:%w", constant.ErrQueryRowZero)
logger.Error("query model detail info from table is empty", zap.String("table_name", tableName))
logger.Error(c, "query model detail info from table is empty", "table_name", tableName)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -97,7 +95,7 @@ func ComponentAnchorReplaceHandler(c *gin.Context) {
componentType := unmarshalMap["component_type"].(int)
if componentType != constant.DemoType {
logger.Error("can not process real time data of component type not equal DemoType", zap.Int64("component_id", componentInfo.ID))
logger.Error(c, "can not process real time data of component type not equal DemoType", "component_id", componentInfo.ID)
}
diagram.UpdateAnchorValue(componentInfo.ID, anchorName)

18
handler/circuit_diagram_create.go
View File

@ -13,17 +13,15 @@ import (
"github.com/bitly/go-simplejson"
"github.com/gin-gonic/gin"
"github.com/gofrs/uuid"
"go.uber.org/zap"
)
// CircuitDiagramCreateHandler define circuit diagram create process API
func CircuitDiagramCreateHandler(c *gin.Context) {
logger := logger.GetLoggerInstance()
pgClient := database.GetPostgresDBClient()
var request network.CircuitDiagramCreateRequest
if err := c.ShouldBindJSON(&request); err != nil {
logger.Error("unmarshal circuit diagram create info failed", zap.Error(err))
logger.Error(c, "unmarshal circuit diagram create info failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -35,7 +33,7 @@ func CircuitDiagramCreateHandler(c *gin.Context) {
graph, err := diagram.GetGraphMap(request.PageID)
if err != nil {
logger.Error("get topologic data from set by pageID failed", zap.Error(err))
logger.Error(c, "get topologic data from set by pageID failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -63,7 +61,7 @@ func CircuitDiagramCreateHandler(c *gin.Context) {
err = fmt.Errorf("convert uuid from string failed:%w:%w", err1, err2)
}
logger.Error("format uuid from string failed", zap.Error(err))
logger.Error(c, "format uuid from string failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -87,7 +85,7 @@ func CircuitDiagramCreateHandler(c *gin.Context) {
if err != nil {
tx.Rollback()
logger.Error("create topologic info into DB failed", zap.Any("topologic_info", topologicCreateInfos), zap.Error(err))
logger.Error(c, "create topologic info into DB failed", "topologic_info", topologicCreateInfos, "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -109,7 +107,7 @@ func CircuitDiagramCreateHandler(c *gin.Context) {
if err != nil {
tx.Rollback()
logger.Error("insert component info into DB failed", zap.Error(err))
logger.Error(c, "insert component info into DB failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -127,7 +125,7 @@ func CircuitDiagramCreateHandler(c *gin.Context) {
if err != nil {
tx.Rollback()
logger.Error("create component model into DB failed", zap.Any("component_infos", request.ComponentInfos), zap.Error(err))
logger.Error(c, "create component model into DB failed", "component_infos", request.ComponentInfos, "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -147,7 +145,7 @@ func CircuitDiagramCreateHandler(c *gin.Context) {
if err != nil {
tx.Rollback()
logger.Error("unmarshal component params info failed", zap.String("component_params", componentInfo.Params), zap.Error(err))
logger.Error(c, "unmarshal component params info failed", "component_params", componentInfo.Params, "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -165,7 +163,7 @@ func CircuitDiagramCreateHandler(c *gin.Context) {
if err != nil {
tx.Rollback()
logger.Error("format params json info to map failed", zap.Error(err))
logger.Error(c, "format params json info to map failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,

20
handler/circuit_diagram_delete.go
View File

@ -17,18 +17,16 @@ import (
"github.com/gin-gonic/gin"
"github.com/gofrs/uuid"
"go.uber.org/zap"
"gorm.io/gorm/clause"
)
// CircuitDiagramDeleteHandler define circuit diagram delete process API
func CircuitDiagramDeleteHandler(c *gin.Context) {
logger := logger.GetLoggerInstance()
pgClient := database.GetPostgresDBClient()
var request network.CircuitDiagramDeleteRequest
if err := c.ShouldBindJSON(&request); err != nil {
logger.Error("unmarshal circuit diagram del info failed", zap.Error(err))
logger.Error(c, "unmarshal circuit diagram del info failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -40,7 +38,7 @@ func CircuitDiagramDeleteHandler(c *gin.Context) {
graph, err := diagram.GetGraphMap(request.PageID)
if err != nil {
logger.Error("get topologic data from set by pageID failed", zap.Error(err))
logger.Error(c, "get topologic data from set by pageID failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -68,7 +66,7 @@ func CircuitDiagramDeleteHandler(c *gin.Context) {
err = fmt.Errorf("convert uuid from string failed:%w:%w", err1, err2)
}
logger.Error("format uuid from string failed", zap.Error(err))
logger.Error(c, "format uuid from string failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -93,7 +91,7 @@ func CircuitDiagramDeleteHandler(c *gin.Context) {
if err != nil {
tx.Rollback()
logger.Error("delete topologic info into DB failed", zap.Any("topologic_info", topologicDelInfo), zap.Error(err))
logger.Error(c, "delete topologic info into DB failed", "topologic_info", topologicDelInfo, "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -110,7 +108,7 @@ func CircuitDiagramDeleteHandler(c *gin.Context) {
if err != nil {
tx.Rollback()
logger.Error("delete topologic info failed", zap.Any("topologic_info", topologicDelInfo), zap.Error(err))
logger.Error(c, "delete topologic info failed", "topologic_info", topologicDelInfo, "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -136,7 +134,7 @@ func CircuitDiagramDeleteHandler(c *gin.Context) {
if err != nil {
tx.Rollback()
logger.Error("format uuid from string failed", zap.Error(err))
logger.Error(c, "format uuid from string failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -160,7 +158,7 @@ func CircuitDiagramDeleteHandler(c *gin.Context) {
err = fmt.Errorf("%w:please check uuid conditions", constant.ErrDeleteRowZero)
}
logger.Error("query component info into postgresDB failed", zap.String("component_global_uuid", componentInfo.UUID), zap.Error(err))
logger.Error(c, "query component info into postgresDB failed", "component_global_uuid", componentInfo.UUID, "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -182,7 +180,7 @@ func CircuitDiagramDeleteHandler(c *gin.Context) {
err = fmt.Errorf("%w:please check uuid conditions", constant.ErrDeleteRowZero)
}
logger.Error("delete component info into postgresDB failed", zap.String("component_global_uuid", componentInfo.UUID), zap.Error(err))
logger.Error(c, "delete component info into postgresDB failed", "component_global_uuid", componentInfo.UUID, "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -207,7 +205,7 @@ func CircuitDiagramDeleteHandler(c *gin.Context) {
}
msg := fmt.Sprintf("delete component info from table %s failed", modelStruct.ReturnTableName())
logger.Error(msg, zap.String("component_global_uuid", componentInfo.UUID), zap.Error(err))
logger.Error(c, msg, "component_global_uuid", componentInfo.UUID, "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,

14
handler/circuit_diagram_load.go
View File

@ -11,7 +11,6 @@ import (
"modelRT/network"
"github.com/gin-gonic/gin"
"go.uber.org/zap"
)
// CircuitDiagramLoadHandler define circuit diagram load process API
@ -25,12 +24,11 @@ import (
// @Failure 400 {object} network.FailureResponse "request process failed"
// @Router /model/diagram_load/{page_id} [get]
func CircuitDiagramLoadHandler(c *gin.Context) {
logger := logger.GetLoggerInstance()
pgClient := database.GetPostgresDBClient()
pageID, err := strconv.ParseInt(c.Query("page_id"), 10, 64)
if err != nil {
logger.Error("get pageID from url param failed", zap.Error(err))
logger.Error(c, "get pageID from url param failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -45,7 +43,7 @@ func CircuitDiagramLoadHandler(c *gin.Context) {
topologicInfo, err := diagram.GetGraphMap(pageID)
if err != nil {
logger.Error("get topologic data from set by pageID failed", zap.Error(err))
logger.Error(c, "get topologic data from set by pageID failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -66,7 +64,7 @@ func CircuitDiagramLoadHandler(c *gin.Context) {
for _, componentUUID := range VerticeLink {
component, err := database.QueryComponentByUUID(c, pgClient, componentUUID)
if err != nil {
logger.Error("get component id info from DB by uuid failed", zap.Error(err))
logger.Error(c, "get component id info from DB by uuid failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -81,7 +79,7 @@ func CircuitDiagramLoadHandler(c *gin.Context) {
componentParams, err := diagram.GetComponentMap(component.ID)
if err != nil {
logger.Error("get component data from set by uuid failed", zap.Error(err))
logger.Error(c, "get component data from set by uuid failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -100,7 +98,7 @@ func CircuitDiagramLoadHandler(c *gin.Context) {
rootVertexUUID := topologicInfo.RootVertex.String()
rootComponent, err := database.QueryComponentByUUID(c, pgClient, topologicInfo.RootVertex)
if err != nil {
logger.Error("get component id info from DB by uuid failed", zap.Error(err))
logger.Error(c, "get component id info from DB by uuid failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -115,7 +113,7 @@ func CircuitDiagramLoadHandler(c *gin.Context) {
rootComponentParam, err := diagram.GetComponentMap(rootComponent.ID)
if err != nil {
logger.Error("get component data from set by uuid failed", zap.Error(err))
logger.Error(c, "get component data from set by uuid failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,

20
handler/circuit_diagram_update.go
View File

@ -11,17 +11,15 @@ import (
"github.com/bitly/go-simplejson"
"github.com/gin-gonic/gin"
"go.uber.org/zap"
)
// CircuitDiagramUpdateHandler define circuit diagram update process API
func CircuitDiagramUpdateHandler(c *gin.Context) {
logger := logger.GetLoggerInstance()
pgClient := database.GetPostgresDBClient()
var request network.CircuitDiagramUpdateRequest
if err := c.ShouldBindJSON(&request); err != nil {
logger.Error("unmarshal circuit diagram update info failed", zap.Error(err))
logger.Error(c, "unmarshal circuit diagram update info failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -33,7 +31,7 @@ func CircuitDiagramUpdateHandler(c *gin.Context) {
graph, err := diagram.GetGraphMap(request.PageID)
if err != nil {
logger.Error("get topologic data from set by pageID failed", zap.Error(err))
logger.Error(c, "get topologic data from set by pageID failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -50,7 +48,7 @@ func CircuitDiagramUpdateHandler(c *gin.Context) {
for _, topologicLink := range request.TopologicLinks {
changeInfo, err := network.ParseUUID(topologicLink)
if err != nil {
logger.Error("format uuid from string failed", zap.Error(err))
logger.Error(c, "format uuid from string failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -73,7 +71,7 @@ func CircuitDiagramUpdateHandler(c *gin.Context) {
if err != nil {
tx.Rollback()
logger.Error("update topologic info into DB failed", zap.Any("topologic_info", topologicChangeInfo), zap.Error(err))
logger.Error(c, "update topologic info into DB failed", "topologic_info", topologicChangeInfo, "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -90,7 +88,7 @@ func CircuitDiagramUpdateHandler(c *gin.Context) {
if err != nil {
tx.Rollback()
logger.Error("update topologic info failed", zap.Any("topologic_info", topologicChangeInfo), zap.Error(err))
logger.Error(c, "update topologic info failed", "topologic_info", topologicChangeInfo, "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -107,7 +105,7 @@ func CircuitDiagramUpdateHandler(c *gin.Context) {
for index, componentInfo := range request.ComponentInfos {
componentID, err := database.UpdateComponentIntoDB(c, tx, componentInfo)
if err != nil {
logger.Error("udpate component info into DB failed", zap.Error(err))
logger.Error(c, "udpate component info into DB failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -125,7 +123,7 @@ func CircuitDiagramUpdateHandler(c *gin.Context) {
err = database.UpdateModelIntoDB(c, tx, componentID, componentInfo.ComponentType, componentInfo.Params)
if err != nil {
logger.Error("udpate component model info into DB failed", zap.Error(err))
logger.Error(c, "udpate component model info into DB failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -143,7 +141,7 @@ func CircuitDiagramUpdateHandler(c *gin.Context) {
for _, componentInfo := range request.ComponentInfos {
paramsJSON, err := simplejson.NewJson([]byte(componentInfo.Params))
if err != nil {
logger.Error("unmarshal component info by concurrent map failed", zap.String("component_params", componentInfo.Params), zap.Error(err))
logger.Error(c, "unmarshal component info by concurrent map failed", "component_params", componentInfo.Params, "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,
@ -159,7 +157,7 @@ func CircuitDiagramUpdateHandler(c *gin.Context) {
componentMap, err := paramsJSON.Map()
if err != nil {
logger.Error("format params json info to map failed", zap.Error(err))
logger.Error(c, "format params json info to map failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,

4
handler/real_time_data_query.go
View File

@ -11,20 +11,18 @@ import (
"modelRT/network"
"github.com/gin-gonic/gin"
"go.uber.org/zap"
)
// QueryRealTimeDataHandler define query real time data process API
func QueryRealTimeDataHandler(c *gin.Context) {
var targetLevel constant.AlertLevel
logger := logger.GetLoggerInstance()
alertManger := alert.GetAlertMangerInstance()
levelStr := c.Query("level")
level, err := strconv.Atoi(levelStr)
if err != nil {
logger.Error("convert alert level string to int failed", zap.Error(err))
logger.Error(c, "convert alert level string to int failed", "error", err)
resp := network.FailureResponse{
Code: http.StatusBadRequest,

21
handler/real_time_data_receive.go
View File

@ -7,7 +7,6 @@ import (
"github.com/gin-gonic/gin"
"github.com/gorilla/websocket"
jsoniter "github.com/json-iterator/go"
"go.uber.org/zap"
realtimedata "modelRT/real-time-data"
)
@ -19,11 +18,9 @@ var upgrader = websocket.Upgrader{
// RealTimeDataReceivehandler define real time data receive and process API
func RealTimeDataReceivehandler(c *gin.Context) {
logger := logger.GetLoggerInstance()
conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
if err != nil {
logger.Error("upgrade http protocol to websocket protocal failed", zap.Error(err))
logger.Error(c, "upgrade http protocol to websocket protocal failed", "error", err)
return
}
defer conn.Close()
@ -31,17 +28,17 @@ func RealTimeDataReceivehandler(c *gin.Context) {
for {
messageType, p, err := conn.ReadMessage()
if err != nil {
logger.Error("read message from websocket connection failed", zap.Error(err))
logger.Error(c, "read message from websocket connection failed", "error", err)
respByte := processResponse(-1, "read message from websocket connection failed", nil)
if len(respByte) == 0 {
logger.Error("process message from byte failed", zap.Error(err))
logger.Error(c, "process message from byte failed", "error", err)
continue
}
err = conn.WriteMessage(messageType, respByte)
if err != nil {
logger.Error("write message to websocket connection failed", zap.Error(err))
logger.Error(c, "write message to websocket connection failed", "error", err)
continue
}
continue
@ -50,17 +47,17 @@ func RealTimeDataReceivehandler(c *gin.Context) {
var request network.RealTimeDataReceiveRequest
err = jsoniter.Unmarshal([]byte(p), &request)
if err != nil {
logger.Error("unmarshal message from byte failed", zap.Error(err))
logger.Error(c, "unmarshal message from byte failed", "error", err)
respByte := processResponse(-1, "unmarshal message from byte failed", nil)
if len(respByte) == 0 {
logger.Error("process message from byte failed", zap.Error(err))
logger.Error(c, "process message from byte failed", "error", err)
continue
}
err = conn.WriteMessage(messageType, respByte)
if err != nil {
logger.Error("write message to websocket connection failed", zap.Error(err))
logger.Error(c, "write message to websocket connection failed", "error", err)
continue
}
continue
@ -74,13 +71,13 @@ func RealTimeDataReceivehandler(c *gin.Context) {
}
respByte := processResponse(0, "success", payload)
if len(respByte) == 0 {
logger.Error("process message from byte failed", zap.Error(err))
logger.Error(c, "process message from byte failed", "error", err)
continue
}
err = conn.WriteMessage(messageType, respByte)
if err != nil {
logger.Error("write message to websocket connection failed", zap.Error(err))
logger.Error(c, "write message to websocket connection failed", "error", err)
continue
}
}

8
pool/concurrency_anchor_parse.go
View File

@ -12,7 +12,6 @@ import (
"modelRT/logger"
"github.com/panjf2000/ants/v2"
"go.uber.org/zap"
)
// AnchorRealTimePool define anchor param pool of real time data
@ -31,12 +30,11 @@ func AnchorPoolInit(concurrentQuantity int) (pool *ants.PoolWithFunc, err error)
// AnchorFunc defines func that process the real time data of component anchor params
var AnchorFunc = func(poolConfig interface{}) {
var firstStart bool
logger := logger.GetLoggerInstance()
alertManager := alert.GetAlertMangerInstance()
anchorChanConfig, ok := poolConfig.(config.AnchorChanConfig)
if !ok {
logger.Error("conversion component anchor chan type failed")
logger.Error(anchorChanConfig.Ctx, "conversion component anchor chan type failed")
return
}
@ -56,12 +54,12 @@ var AnchorFunc = func(poolConfig interface{}) {
for _, value := range anchorRealTimeDatas {
anchorName, err := diagram.GetAnchorValue(componentID)
if err != nil {
logger.Error("can not get anchor value from map by uuid", zap.Int64("component_id", componentID), zap.Error(err))
logger.Error(anchorChanConfig.Ctx, "can not get anchor value from map by uuid", "component_id", componentID, "error", err)
continue
}
if anchorName != anchorParaConfig.AnchorName {
logger.Error("anchor name not equal param config anchor value", zap.String("map_anchor_name", anchorName), zap.String("param_anchor_name", anchorParaConfig.AnchorName))
logger.Error(anchorChanConfig.Ctx, "anchor name not equal param config anchor value", "map_anchor_name", anchorName, "param_anchor_name", anchorParaConfig.AnchorName)
continue
}

14
pool/concurrency_model_parse.go
View File

@ -10,21 +10,17 @@ import (
"modelRT/diagram"
"modelRT/logger"
"modelRT/model"
"go.uber.org/zap"
)
// ParseFunc defines func that parses the model data from postgres
var ParseFunc = func(parseConfig interface{}) {
logger := logger.GetLoggerInstance()
modelParseConfig, ok := parseConfig.(config.ModelParseConfig)
if !ok {
logger.Error("conversion model parse config type failed")
logger.Error(modelParseConfig.Ctx, "conversion model parse config type failed")
return
}
cancelCtx, cancel := context.WithTimeout(modelParseConfig.Context, 5*time.Second)
cancelCtx, cancel := context.WithTimeout(modelParseConfig.Ctx, 5*time.Second)
defer cancel()
pgClient := database.GetPostgresDBClient()
@ -33,10 +29,10 @@ var ParseFunc = func(parseConfig interface{}) {
result := pgClient.WithContext(cancelCtx).Table(tableName).Where("component_id = ?", modelParseConfig.ComponentInfo.ID).Find(&unmarshalMap)
if result.Error != nil {
logger.Error("query component detail info failed", zap.Error(result.Error))
logger.Error(modelParseConfig.Ctx, "query component detail info failed", "error", result.Error)
return
} else if result.RowsAffected == 0 {
logger.Error("query component detail info from table is empty", zap.String("table_name", tableName))
logger.Error(modelParseConfig.Ctx, "query component detail info from table is empty", "table_name", tableName)
return
}
@ -48,7 +44,7 @@ var ParseFunc = func(parseConfig interface{}) {
}
diagram.StoreAnchorValue(modelParseConfig.ComponentInfo.ID, anchorName)
GetComponentChan(modelParseConfig.Context, modelParseConfig.ComponentInfo.ID)
GetComponentChan(modelParseConfig.Ctx, modelParseConfig.ComponentInfo.ID)
uuid := modelParseConfig.ComponentInfo.GlobalUUID.String()
unmarshalMap["id"] = modelParseConfig.ComponentInfo.ID

14
real-time-data/kafka.go
View File

@ -8,7 +8,6 @@ import (
"modelRT/logger"
"github.com/confluentinc/confluent-kafka-go/kafka"
"go.uber.org/zap"
)
// RealTimeDataComputer continuously processing real-time data from Kafka specified topics
@ -17,9 +16,6 @@ func RealTimeDataComputer(ctx context.Context, consumerConfig kafka.ConfigMap, t
ctx, cancel := context.WithCancel(ctx)
defer cancel()
// get a logger
logger := logger.GetLoggerInstance()
// setup a channel to listen for interrupt signals
// TODO 将中断信号放到入参中
interrupt := make(chan struct{}, 1)
@ -30,13 +26,13 @@ func RealTimeDataComputer(ctx context.Context, consumerConfig kafka.ConfigMap, t
// create a new consumer
consumer, err := kafka.NewConsumer(&consumerConfig)
if err != nil {
logger.Error("init kafka consume by config failed", zap.Any("config", consumerConfig), zap.Error(err))
logger.Error(ctx, "init kafka consume by config failed", "config", consumerConfig, "error", err)
}
// subscribe to the topic
err = consumer.SubscribeTopics(topics, nil)
if err != nil {
logger.Error("subscribe to the topic failed", zap.Strings("topic", topics), zap.Error(err))
logger.Error(ctx, "subscribe to the topic failed", "topic", topics, "error", err)
}
// start a goroutine to handle shutdown
@ -51,17 +47,17 @@ func RealTimeDataComputer(ctx context.Context, consumerConfig kafka.ConfigMap, t
msg, err := consumer.ReadMessage(timeoutDuration)
if err != nil {
if ctx.Err() == context.Canceled {
logger.Info("context canceled, stopping read loop")
logger.Info(ctx, "context canceled, stopping read loop")
break
}
logger.Error("consumer read message failed", zap.Error(err))
logger.Error(ctx, "consumer read message failed", "error", err)
continue
}
// TODO 使用 ants.pool处理 kafka 的订阅数据
_, err = consumer.CommitMessage(msg)
if err != nil {
logger.Error("manual submission information failed", zap.Any("message", msg), zap.Error(err))
logger.Error(ctx, "manual submission information failed", "message", msg, "error", err)
}
}
}

8
real-time-data/real_time_data_receive.go
View File

@ -10,8 +10,6 @@ import (
"modelRT/logger"
"modelRT/network"
"modelRT/pool"
"go.uber.org/zap"
)
// RealTimeDataChan define channel of real time data receive
@ -23,8 +21,6 @@ func init() {
// ReceiveChan define func of real time data receive and process
func ReceiveChan(ctx context.Context) {
logger := logger.GetLoggerInstance()
for {
select {
case <-ctx.Done():
@ -34,13 +30,13 @@ func ReceiveChan(ctx context.Context) {
componentID := realTimeData.PayLoad.ComponentID
component, err := diagram.GetComponentMap(componentID)
if err != nil {
logger.Error("query component info from diagram map by componet id failed", zap.Int64("component_id", componentID), zap.Error(err))
logger.Error(ctx, "query component info from diagram map by componet id failed", "component_id", componentID, "error", err)
continue
}
componentType := component["component_type"].(int)
if componentType != constant.DemoType {
logger.Error("can not process real time data of component type not equal DemoType", zap.Int64("component_id", componentID))
logger.Error(ctx, "can not process real time data of component type not equal DemoType", "component_id", componentID)
continue
}

25
test/distributedlock/rwlock_test.go
View File

@ -11,16 +11,11 @@ import (
"github.com/redis/go-redis/v9"
"github.com/stretchr/testify/assert"
"go.uber.org/zap"
)
var (
log *zap.Logger
rdb *redis.Client
)
var rdb *redis.Client
func init() {
log = zap.Must(zap.NewDevelopment())
rdb = redis.NewClient(&redis.Options{
Network: "tcp",
Addr: "192.168.2.104:30001",
@ -46,7 +41,6 @@ func TestRWLockRLockAndUnRLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc556a",
})
rwLocker.Logger = log
duration := 10 * time.Second
// 第一次加读锁
@ -77,7 +71,6 @@ func TestRWLockReentrantRLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc556a",
})
rwLocker.Logger = log
duration := 10 * time.Second
// 第一次加读锁
@ -125,7 +118,6 @@ func TestRWLockRefreshRLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc556a",
})
rwLocker.Logger = log
duration := 10 * time.Second
// 第一次加读锁
@ -168,7 +160,6 @@ func TestRWLock2ClientRLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc556a",
})
rwLocker1.Logger = log
rwLocker2 := dl.GetRWLocker(rdb, &dl.RedissionLockConfig{
LockLeaseTime: 120,
@ -176,7 +167,6 @@ func TestRWLock2ClientRLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc5577",
})
rwLocker2.Logger = log
duration := 10 * time.Second
// locker1加读锁
@ -227,7 +217,6 @@ func TestRWLock2CWith2DifTimeRLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc556a",
})
rwLocker1.Logger = log
rwLocker2 := dl.GetRWLocker(rdb, &dl.RedissionLockConfig{
LockLeaseTime: 30,
@ -235,7 +224,6 @@ func TestRWLock2CWith2DifTimeRLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc5577",
})
rwLocker2.Logger = log
duration := 10 * time.Second
// locker1加读锁
@ -300,7 +288,6 @@ func TestRWLock2CWithTimeTransformRLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc556a",
})
rwLocker1.Logger = log
rwLocker2 := dl.GetRWLocker(rdb, &dl.RedissionLockConfig{
LockLeaseTime: 120,
@ -308,7 +295,6 @@ func TestRWLock2CWithTimeTransformRLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc5577",
})
rwLocker2.Logger = log
duration := 10 * time.Second
// locker1加读锁
@ -366,7 +352,6 @@ func TestRWLockWLockAndUnWLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc556a",
})
rwLocker.Logger = log
duration := 10 * time.Second
// 第一次加读锁
@ -397,7 +382,6 @@ func TestRWLockReentrantWLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc556a",
})
rwLocker.Logger = log
duration := 10 * time.Second
// 第一次加写锁
@ -445,7 +429,6 @@ func TestRWLock2CWithRLockAndWLockFailed(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc556a",
})
rwLocker1.Logger = log
rwLocker2 := dl.GetRWLocker(rdb, &dl.RedissionLockConfig{
LockLeaseTime: 30,
@ -453,7 +436,6 @@ func TestRWLock2CWithRLockAndWLockFailed(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc5577",
})
rwLocker2.Logger = log
duration := 10 * time.Second
// locker1加读锁
@ -485,7 +467,6 @@ func TestRWLock2CWithRLockAndWLockSucceed(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc556a",
})
rwLocker1.Logger = log
rwLocker2 := dl.GetRWLocker(rdb, &dl.RedissionLockConfig{
LockLeaseTime: 120,
@ -493,7 +474,7 @@ func TestRWLock2CWithRLockAndWLockSucceed(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc5577",
})
rwLocker2.Logger = log
duration := 10 * time.Second
// locker1加读锁
err := rwLocker1.RLock(ctx, duration)
@ -538,7 +519,6 @@ func TestRWLock2CWithWLockAndRLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc556a",
})
rwLocker1.Logger = log
rwLocker2 := dl.GetRWLocker(rdb, &dl.RedissionLockConfig{
LockLeaseTime: 30,
@ -546,7 +526,6 @@ func TestRWLock2CWithWLockAndRLock(t *testing.T) {
Key: "component",
Token: "fd348a84-e07c-4a61-8c19-f753e6bc5577",
})
rwLocker2.Logger = log
duration := 10 * time.Second
// locker1加写锁