package ruleserver
|
|
import (
|
"fmt"
|
"ruleprocess/logger"
|
"time"
|
)
|
|
var stopChan = make(chan bool)
|
|
// 计数器map 独立任务的键是任务id拼接区域id 联动任务的键是groupid（能不能都用groupId?）
|
var TimeEleList = make(map[string]*TimeElement)
|
|
// 定时器元素
|
type TimeElement struct {
|
N int // 按时间依次递减的当前值
|
InitN int // 赋值后就不变的初始值
|
BufferFlag int // 缓冲容错位 连续n帧false才为false
|
AlarmFlag bool // 报警标志位 定时器开启后第一次报警时会被置为true 往后再来报警也不会插进ES
|
CacheSdkData ResultMsg // 定时器的缓存数据 持续时间类的开启定时器时要缓存一帧
|
GroupId string // 联动规则需要记录下此时的规则组id
|
RuleResults []*RuleResult
|
}
|
type RuleResult struct {
|
// 每个摄像机一个结构体
|
CameraId string // 摄像机id
|
Sort int32 // 摄像机在规则组中序号
|
Result string // 摄像机过滤数据得出的结果
|
RuleWithPre string // 摄像机之间的连接符
|
}
|
|
func TimeTicker() {
|
logger.Info("定时器执行了")
|
fmt.Println("定时器执行了")
|
ticker := time.NewTicker(1 * time.Second)
|
go func(ticker *time.Ticker) {
|
defer ticker.Stop()
|
for {
|
select {
|
case <-ticker.C:
|
logger.Info("定时器执行单元", time.Now().Unix())
|
fmt.Println("定时器执行单元", time.Now().Unix())
|
// 每秒钟计数器池子里所有的计数器元素都减一，减到0的是该报警的
|
for k, timeEle := range TimeEleList {
|
if timeEle.N > 0 {
|
timeEle.N = timeEle.N - 1
|
logger.Error("-------------------------------------打印定时器元素当前值-----------------------------------------：", timeEle.N)
|
}
|
if timeEle.GroupId != "" && timeEle.N == 0 {
|
// 说明是联动任务的时间窗口 到点儿了该销毁了,再来了再创建
|
delete(TimeEleList, k)
|
}
|
}
|
case stop := <-stopChan:
|
if stop {
|
logger.Info("定时器结束")
|
return
|
//os.Exit(0)
|
}
|
}
|
}
|
}(ticker)
|
}
|
func StopTimeTicker() {
|
stopChan <- true
|
TimeTicker()
|
}
|
|
// 结构体根据某字段排序
|
type SubList []*RuleResult
|
|
func (p SubList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
|
func (p SubList) Len() int { return len(p) }
|
func (p SubList) Less(i, j int) bool { return p[i].Sort < p[j].Sort }
|
|
// 结构体根据某字段排序
|
type resultList []*LittleRuleResult
|
|
func (p resultList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
|
func (p resultList) Len() int { return len(p) }
|
func (p resultList) Less(i, j int) bool { return p[i].Sort < p[j].Sort }
|
