---

panlei

2019-08-01 db9d26e3e4bd889a1bde64651d6fc39c32ae5391

 cache/cache.go

@@ -1 +1,205 @@
package cache

import (
   "basic.com/dbapi.git"
   "basic.com/pubsub/cache.git/shardmap"
   "basic.com/pubsub/protomsg.git"
   "basic.com/valib/gopherdiscovery.git"
   "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_"
)

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列表信息

   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 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")
   }
}