删除错误的引用logger以及为定时器加入锁机制

panlei

2019-10-11 35a3ee126aa0e3372d332714ca9adba2a3261031

 ruleserver/ruleToformula.go

@@ -1,19 +1,19 @@
package ruleserver

import (
   "basic.com/pubsub/protomsg.git"
   "basic.com/valib/logger.git"
   "github.com/knetic/govaluate"
   "plugin"
   "ruleprocess/cache"
   "ruleprocess/structure"
   "sort"
   "strconv"
   "strings"
   "time"

   "basic.com/pubsub/protomsg.git"
   "github.com/knetic/govaluate"
   "sync"
)

var rw sync.RWMutex // 读写锁
// 对单帧图像的判断 thisSdkDatas  当前传入的这帧数据，cacheSdkData 定时器里缓存的一帧数据 没有就返回nil  (thisSdkDatas SdkDatas, cacheSdkDatas SdkDatas)
func Judge(args *structure.SdkDatas, message *protomsg.SdkMessage) {
   defer func() {
@@ -249,6 +249,7 @@
   logger.Info("------------------------------------------当前是联动任务，规则是：", groupRule.GroupText)
   var flag bool = true
   var timeEle = TimeElement{N: 2, InitN: 2, GroupId: groupRule.GroupId}
   rw.Lock()
   for k, timeEle1 := range TimeEleList {
      if k == groupRule.GroupId {
         flag = false // 已经有了这个定时器就置为false 不再新增
@@ -273,6 +274,7 @@
         }
      }
   }
   rw.Unlock()
   // 往数组里赋值
   isOk,labelTypes := RunRule(args, groupRule, taskId, message, label)
   if isOk {
@@ -324,6 +326,7 @@
            result, _ := expression.Evaluate(nil) // 得到数学公式的结果
            if result.(bool) {
               logger.Info("___________________________________________________________________联动任务报警")
               rw.RLock()
               if TimeEleList[groupRule.GroupId] != nil { // 极偶尔有情况会等于nil，不知道为啥，做个判断以防宕机
                  // 把数组里缓存的数据取出来一起报警
                  label.LinkCache = []structure.ResultMsg{}
@@ -342,6 +345,7 @@
                     }
                  }
               }
               rw.RUnlock()
            }
         }
      } else {
@@ -370,14 +374,15 @@
      //      va.Result = strconv.FormatBool(isOk)
      //   }
      //}
      rw.Lock()
      for k, _ := range TimeEleList {
         if k == groupRule.GroupId {
            delete(TimeEleList, k)
            logger.Debug("因为定时器的一帧数据结果为false，干掉定时器")
         }
      }
      rw.Unlock()
      // 因为本帧数据不符合规则，所以也不用统计结果数组里的东西

   }
}

@@ -387,6 +392,7 @@
      if rule.SdkArgAlias == "duration" { //
         logger.Info("当前小规则是：---------", rule)
         // 先看看定时器元素队列中是否有这条规则的定时器,如果有就不能再次创建了
         rw.Lock()
         var flag bool = true
         for k, _ := range TimeEleList {
            if k == groupId+"+"+rule.Id {
@@ -402,63 +408,8 @@
            TimeEleList[groupId+"+"+rule.Id] = &timeEle // 定时器元素以当前持续时间小规则id为键
            logger.Info("创建了计数器")
         }
         rw.Unlock()
      }
   }
}

func timeRuleResult(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
   if rule.PolygonId == am.AreaId { // 首先规则所对应的区域id要跟区域数据的id对的上
      if rule.SdkArgAlias == "time_rule" { // 判断是否符合时间规
         //logger.Info("----------当前时间规则：---------", rule)
         // 根据放值字段里存的时间规则的id去另一个表里查需要比对的时间段（比如当前时间是周三，应根据区域id查出其周三的几个布防时间段，数组）
         //logger.Info("时间规则的测试")
         now := time.Now()
         index := getIndexOfWeek(now.Weekday().String())
         timeList := GetTimeById(rule.SdkArgValue, index)
         //logger.Info("当天的时间段集合：----------", timeList)
         //logger.Info("从数据库中查出的时间规则：", timeList)
         // 判断图片数据的时间是否符合当前规则 在一个即为true，全不在为false

         if rule.Operator == "satisfy" || rule.Operator == "==" { // 满足所选的时间规则
            flag := "false"
            for _, timeSlot := range timeList {
               formula := "'" + timeSlot.Start + "'" + "<" + "'" + am.Time + "'"
               expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
               result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果

               formula1 := "'" + timeSlot.End + "'" + ">" + "'" + am.Time + "'"
               expression1, _ := govaluate.NewEvaluableExpression(formula1) // 得到数学公式
               result1, _ := expression1.Evaluate(nil)                      // 得到数学公式的结果
               //logger.Info("看看这两尊大神", result, result1)
               if result.(bool) && result1.(bool) {
                  flag = "true"
                  break
               }
            }
            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + flag, rule.Sort}
         }

         if rule.Operator == "unsatisfy" || rule.Operator == "!=" { // 不满足所选的时间规则
            flag := "true"
            for _, timeSlot := range timeList {
               formula := "'" + timeSlot.Start + "'" + " < " + "'" + am.Time + "'"
               //logger.Info("-----------------时间规则不满足的公式start：", formula)
               expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
               result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果

               formula1 := "'" + timeSlot.End + "'" + " > " + "'" + am.Time + "'"
               //logger.Info("-----------------时间规则不满足的公式end：", formula1)
               expression1, _ := govaluate.NewEvaluableExpression(formula1) // 得到数学公式
               result1, _ := expression1.Evaluate(nil)                      // 得到数学公式的结果
               if result.(bool) && result1.(bool) {
                  flag = "false"
                  break
               }
            }
            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + flag, rule.Sort}
         }

      }
   }
   return structure.LittleRuleResult{}
}