package cache
|
|
import (
|
"basic.com/dbapi.git"
|
"basic.com/pubsub/cache.git/shardmap"
|
"basic.com/pubsub/protomsg.git"
|
"basic.com/valib/gopherdiscovery.git"
|
"basic.com/valib/logger.git"
|
"encoding/json"
|
"errors"
|
"fmt"
|
"github.com/gogo/protobuf/proto"
|
"github.com/satori/go.uuid"
|
"strconv"
|
)
|
|
const (
|
PREFIX_CAMERA = "CAMERA_"
|
PREFIX_POLYGON = "POLYGON_"
|
PREFIX_TIME = "TIME_"
|
PREFIX_RULE = "RULE_"
|
SERVER_KEY = "SERVERINFO"
|
PREFIX_SDK = "SDK_"
|
PREFIX_DIC = "DIC_"
|
PREFIX_SO = "SO"
|
)
|
|
var cMap *shardmap.ShardMap
|
|
func Init(initChan chan bool, dbIp string, surveyPort int, pubSubPort int) {
|
cMap = shardmap.New(uint8(32))
|
urlSurvey := "tcp://" + dbIp + ":" + strconv.Itoa(surveyPort)
|
urlPubSub := "tcp://" + dbIp + ":" + strconv.Itoa(pubSubPort)
|
client, _ := gopherdiscovery.ClientWithSub(urlSurvey, urlPubSub, uuid.NewV4().String())
|
recvMsg := client.HeartBeatMsg()
|
fmt.Println(<-recvMsg)
|
|
initCacheData(initChan)
|
|
peers, _ := client.Peers()
|
for b := range peers {
|
fmt.Println("peerMsg:", b)
|
updateData(b)
|
}
|
}
|
|
func initCacheData(initChan chan bool) {
|
|
initPolygons() //初始化摄像机多边形缓存
|
|
initTimeRules() //初始化时间规则缓存
|
|
initCameraTaskRules() //初始化摄像机任务规则缓存
|
|
initCamera() //初始化摄像机信息
|
|
initServerInfo() //初始化服务器配置信息
|
|
initSdks() //初始化sdk列表信息
|
|
initSoData()
|
|
initDictionary() // 初始化字典
|
|
initChan <- true
|
}
|
|
var newUpdateMsg = &protomsg.DbChangeMessage{}
|
|
func updateData(b []byte) {
|
if err := proto.Unmarshal(b, newUpdateMsg); err != nil {
|
fmt.Println("dbChangeMsg unmarshal err:", err)
|
return
|
}
|
switch newUpdateMsg.Table {
|
case protomsg.TableChanged_T_Server:
|
initServerInfo()
|
case protomsg.TableChanged_T_Camera:
|
initCamera()
|
case protomsg.TableChanged_T_CameraPolygon: //更新摄像机多变形
|
initPolygons()
|
case protomsg.TableChanged_T_TimeRule: //更新时间规则
|
initTimeRules()
|
case protomsg.TableChanged_T_CameraTask: //更新摄像机规则配置参数
|
initCameraTaskRules()
|
case protomsg.TableChanged_T_CameraTaskArgs: //更新摄像机规则配置参数
|
initCameraTaskRules()
|
case protomsg.TableChanged_T_Sdk: //更新sdk配置
|
initSdks()
|
default:
|
fmt.Println("unknown operation")
|
|
}
|
}
|
|
func initServerInfo() {
|
var api dbapi.SysSetApi
|
b, s := api.GetServerInfo()
|
if b {
|
cMap.Set(SERVER_KEY, s)
|
}
|
}
|
|
func initCamera() {
|
var api dbapi.CameraApi
|
cameras := api.FindAll()
|
for _, cam := range cameras {
|
cMap.Set(PREFIX_CAMERA+cam.Id, cam)
|
}
|
}
|
|
func initPolygons() {
|
var api dbapi.CameraApi
|
data := api.FindAllPolygons()
|
pMap := make(map[string][]protomsg.CameraPolygon, 0)
|
for _, item := range data {
|
if item.Type != "line" {
|
cameraId := item.CameraId
|
if _, ok := pMap[cameraId]; ok {
|
pMap[cameraId] = append(pMap[cameraId], item)
|
} else {
|
pMap[cameraId] = []protomsg.CameraPolygon{item}
|
}
|
}
|
}
|
for k, v := range pMap {
|
cMap.Set(PREFIX_POLYGON+k, v)
|
}
|
}
|
|
func initTimeRules() {
|
var api dbapi.CameraApi
|
flag, rules := api.FindAllTimeRules()
|
if flag {
|
for _, rule := range rules {
|
cMap.Set(PREFIX_TIME+rule.Id, rule)
|
}
|
}
|
}
|
|
func initDictionary() {
|
var api dbapi.DicApi
|
flag, dics := api.FindByType("")
|
if flag {
|
var dicss map[string][]Dic
|
b, _ := json.Marshal(dics)
|
if err := json.Unmarshal(b, &dicss); err == nil {
|
for key, dics1 := range dicss {
|
for _, dic := range dics1 {
|
cMap.Set(PREFIX_DIC + key + dic.Value, dic)
|
}
|
}
|
}
|
}
|
}
|
|
func initCameraTaskRules() {
|
var api dbapi.CameraTaskArgsApi
|
all := api.FindAll()
|
|
for _, taskArg := range all {
|
cMap.Set(PREFIX_RULE+taskArg.CameraId, taskArg.TaskArgs)
|
}
|
}
|
|
func initSdks() {
|
var api dbapi.SdkApi
|
sdks := api.FindAll("")
|
for _, sdk := range sdks {
|
cMap.Set(PREFIX_SDK+sdk.Id, sdk)
|
}
|
}
|
|
func GetServerInfo() (con protomsg.LocalConfig, err error) {
|
config, b := cMap.Get(SERVER_KEY)
|
if b {
|
return config.(protomsg.LocalConfig), nil
|
} else {
|
return con, errors.New("conf not found")
|
}
|
}
|
|
//通过cameraId获取摄像机信息
|
func GetCameraById(cameraId string) (c protomsg.Camera, err error) {
|
cam, b := cMap.Get(PREFIX_CAMERA + cameraId)
|
if b {
|
return cam.(protomsg.Camera), nil
|
} else {
|
return c, errors.New("camera not found")
|
}
|
}
|
|
func GetPolygonsByCameraId(cameraId string) []protomsg.CameraPolygon {
|
obj, b := cMap.Get(PREFIX_POLYGON + cameraId)
|
if b {
|
return obj.([]protomsg.CameraPolygon)
|
} else {
|
return nil
|
}
|
}
|
|
//从缓存中获取时间规则
|
func GetTimeRuleById(id string) (exist bool, rule protomsg.CameraTimerule) {
|
obj, b := cMap.Get(PREFIX_TIME + id)
|
if b {
|
return true, obj.(protomsg.CameraTimerule)
|
} else {
|
return false, rule
|
}
|
}
|
|
//根据摄像机id从缓存中获取摄像机的任务规则设置
|
func GetCameraTaskRulesByCameraId(cameraId string) []*protomsg.TaskGroupArgs {
|
obj, b := cMap.Get(PREFIX_RULE + cameraId)
|
if b {
|
return obj.([]*protomsg.TaskGroupArgs)
|
} else {
|
return nil
|
}
|
}
|
|
func GetSdkById(sdkId string) (sdk protomsg.Sdk, err error) {
|
obj, b := cMap.Get(PREFIX_SDK + sdkId)
|
if b {
|
return obj.(protomsg.Sdk), nil
|
} else {
|
return sdk, errors.New("sdk not found")
|
}
|
}
|
|
// 获取字典值
|
func GetDic(key string) (name string) {
|
obj, b := cMap.Get(PREFIX_DIC + key)
|
if b {
|
return obj.(Dic).Name
|
} else {
|
return ""
|
}
|
}
|
|
func initSoData() {
|
var api dbapi.SoApi
|
soinfos := api.FindAll()
|
logger.Debug("=====================注册表信息：")
|
for _, soinfo := range soinfos {
|
logger.Debug(soinfo)
|
cMap.Set(PREFIX_SO+soinfo.SdkId, soinfo)
|
}
|
}
|
|
func GetSoInfoById(sdkId string) (sdk protomsg.SoInfo, err error) {
|
obj, b := cMap.Get(PREFIX_SO + sdkId)
|
if b {
|
return obj.(protomsg.SoInfo), nil
|
} else {
|
return sdk, errors.New("sdk not found")
|
}
|
}
|
|
type Dic struct {
|
Id string `json:"id"`
|
Value string `json:"value"`
|
Name string `json:"name"`
|
Type string `json:"type"`
|
Description string `json:"description"`
|
Sort int `json:"sort"`
|
Parent_id string `json:"parent_id"`
|
}
|
