cache

liuxiaolong

2019-07-01 4d21ccf808d91239f9200b15a46977f79b5cb199

cache

 cache/cache.go

@@ -1 +1,133 @@
package cache

import (
    "basic.com/dbapi.git"
    "basic.com/pubsub/cache.git/shardmap"
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/gopherdiscovery.git"
    "fmt"
    "github.com/gogo/protobuf/proto"
    "github.com/satori/go.uuid"
    "strconv"
)
const (
    PREFIX_POLYGON = "POLYGON_"
    PREFIX_TIME = "TIME_"
    PREFIX_RULE = "RULE_"
)

var cMap *shardmap.ShardMap


func Init(initChan chan bool,dbIp string,surveyPort int,pubSubPort int){
    urlSurvey := dbIp + strconv.Itoa(surveyPort)
    urlPubSub := 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()//初始化摄像机任务规则缓存

    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_CameraPolygon://更新摄像机多变形
        initPolygons()
    case protomsg.TableChanged_T_TimeRule://更新时间规则
        initTimeRules()
    case protomsg.TableChanged_T_CameraTaskArgs://更新摄像机规则配置参数
        initCameraTaskRules()
    default:
        fmt.Println("unknown operation")

    }
}

func initPolygons(){
    var api dbapi.CameraApi
    data := api.FindAllPolygons()
    for _, item := range data {
        cameraId :=item.CameraId
        arr, b := cMap.Get(PREFIX_POLYGON + cameraId)
        if b {
            list := arr.([]protomsg.CameraPolygon)
            list = append(list,item)
            cMap.Set(PREFIX_POLYGON + cameraId,list)
        } else {
            cMap.Set(PREFIX_POLYGON + cameraId,[]protomsg.CameraPolygon{ item })
        }
    }
}

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