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 // 赋值后就不变的初始值
|
Data AreaMap //
|
GroupId string // 联动规则需要记录下此时的规则组id
|
RuleResults []*RuleResult
|
}
|
type RuleResult struct { // 每个摄像机一个结构体
|
CameraId string // 摄像机id
|
Sort int32 // 摄像机在规则组中序号
|
Result string // 摄像机过滤数据得出的结果
|
RuleWithPre string // 摄像机之间的连接符
|
}
|
|
func TimeTicker() {
|
fmt.Println("定时器执行了")
|
ticker := time.NewTicker(1 * time.Second)
|
go func(ticker *time.Ticker) {
|
defer ticker.Stop()
|
for {
|
select {
|
case <-ticker.C:
|
fmt.Println("定时器执行单元")
|
// 每秒钟计数器池子里所有的计数器元素都减一，减到0的是该报警的
|
for _, timeEle := range TimeEleList {
|
if timeEle.N > 0 {
|
timeEle.N = timeEle.N - 1
|
logger.Info("-------------------------------------打印定时器元素当前值-----------------------------------------：",timeEle.N)
|
}
|
}
|
case stop := <-stopChan:
|
if stop {
|
fmt.Println("定时器结束")
|
//os.Exit(0)
|
}
|
}
|
}
|
}(ticker)
|
}
|
func StopTimeTicker() {
|
stopChan <- true
|
TimeTicker()
|
}
|
|
// 定时器单元 废弃版本
|
// func TimeTicker() chan bool {
|
// fmt.Println("执行了timeTicker")
|
// ticker := time.NewTicker(1 * time.Second)
|
// stopChan := make(chan bool)
|
// go func(ticker *time.Ticker) {
|
// defer ticker.Stop()
|
// for {
|
// select {
|
// case <-ticker.C:
|
// //fmt.Println("执行单元", "计数器集合2", TimeEleList)
|
// for k, timeEle := range TimeEleList {
|
// timeEle.n = timeEle.n - 1
|
// //fmt.Println("遍历的数值", TimeEleList)
|
// if timeEle.n == 0 {
|
// // do something alarm
|
// alarm(k, timeEle)
|
// }
|
// }
|
// case stop := <-stopChan:
|
// if stop {
|
// fmt.Println("定时器结束")
|
// return
|
// }
|
// }
|
// }
|
// }(ticker)
|
// return stopChan
|
// }
|
|
// 结构体根据某字段排序
|
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 }
|
