添加日志系统

panlei

2019-07-05 40e90ca2c934c8505f2a9e9b1c4f076657008369

添加日志系统

 insertdata/insertDataToEs.go

@@ -4,9 +4,9 @@
    "encoding/json"
    "errors"
    "fmt"
    "log"
    "net"
    "ruleprocess/cache"
    "ruleprocess/logger"
    "strings"
    "time"

@@ -99,7 +99,7 @@

    // 直接从规则的标签数据里拿符合规则的人脸结果
    if msg.RuleResult["face"] != nil && len(msg.RuleResult["face"].([]ruleserver.Arg)) > 0 {
        log.Println("往ES插人脸数据")
        logger.Info("往ES插人脸数据")
        for _, face := range msg.RuleResult["face"].([]ruleserver.Arg) {
            // 上传大图
            // 解压缩并上传图片
@@ -116,7 +116,7 @@
                // 人脸检测，没有相似的底库人员
                localConfig, err := cache.GetServerInfo()
                if err != nil {
                    log.Println("查询本机信息失败！")
                    logger.Info("查询本机信息失败！")
                }
                serverIp, err := GetLocalIP()
                // 解压缩并上传图片
@@ -127,15 +127,15 @@
                // 查询cameraName
                camera, err := cache.GetCameraById(msg.Cid)
                if err != nil {
                    log.Println("查询摄像机信息失败")
                    logger.Info("查询摄像机信息失败")
                }
                i := protomsg.Image{}
                err = proto.Unmarshal(bdata, &i)
                log.Println("-------------------------------------------看下宽和高", i.Width, i.Height)
                logger.Info("-------------------------------------------看下宽和高", i.Width, i.Height)
                bytes := util.SubImg(i, int(face.Location.X), int(face.Location.Y), int(face.Location.X+face.Location.Width), int(face.Location.Y+face.Location.Height))
                resp, err := util.PostFormBufferData1(weedfsUrl, bytes, uuid.NewV4().String())
                if err != nil {
                    log.Println("上传小图出错")
                    logger.Info("上传小图出错")
                }
                sex := ""
                if face.ThftRes.Gender == 1 {
@@ -179,19 +179,19 @@
                requstbody, err := json.Marshal(pervideo)

                if err != nil {
                    log.Println("json parse error ", err)
                    logger.Info("json parse error ", err)
                    return

                }
                err = EsReq("POST", "http://192.168.1.182:9200/videopersons/perVideoPicture", requstbody)
                log.Println(err)
                logger.Info(err.Error())
            } else {
                log.Println("跟底库的相似数据---------：", face.Liker)
                logger.Info("跟底库的相似数据---------：", face.Liker)
            }
        }
    }
    if msg.RuleResult["yolo"] != nil && len(msg.RuleResult["yolo"].([]ruleserver.Result)) > 0 {
        log.Println("往ES插yolo数据")
        logger.Info("往ES插yolo数据")
        var sdkNames string = ""
        alarmRules := []AlarmRule{}
        for _, yoloResult := range msg.RuleResult["yolo"].([]ruleserver.Result) {
@@ -213,25 +213,25 @@
            //resp, err = util.PostFormBufferData(weedfsUrl, i, uuid.NewV4().String())
            resp, err = util.DrawPolygonOnImage(msg.Cid, i,msg.RuleResult["yolo"].([]ruleserver.Result))
            if err != nil {
                log.Println("画框或上传图片服务器出错", err)
                logger.Info("画框或上传图片服务器出错", err)
            } else {
                log.Println("已报警并上传改帧图片到服务器")
                logger.Info("已报警并上传改帧图片到服务器")
            }
        } else {
            isAlarm = 0
            // 不是报警数据不存
            return
        }
        // log.Println("图片上传返回值：", resp)
        // logger.Println("图片上传返回值：", resp)
        // 查询本机信息
        localConfig, err := cache.GetServerInfo()
        if err != nil {
            log.Println("查询本机信息失败！")
            logger.Info("查询本机信息失败！")
        }
        // 查询cameraName
        camera, err := cache.GetCameraById(msg.Cid)
        if err != nil {
            log.Println("查询摄像机信息失败")
            logger.Info("查询摄像机信息失败")
        }
        serverIp, err := GetLocalIP()
        peraction := Personaction{
@@ -259,15 +259,15 @@
        requstbody, err := json.Marshal(peraction)

        if err != nil {
            log.Println("json parse error ", err)
            logger.Info("json parse error ", err)
            return

        }
        err = EsReq("POST", "http://192.168.1.182:9200/personaction/perVideoAction", requstbody)
        if err != nil {
            log.Println("往ES插入数据失败", err)
            logger.Info("往ES插入数据失败", err)
        } else {
            log.Println("__________________________________________往ES插入yolo数据成功")
            logger.Info("__________________________________________往ES插入yolo数据成功")
        }
    }
}

 logger/logger.go

New file
@@ -0,0 +1,217 @@
package logger

import (
    "fmt"
    "log"
    "os"
    "os/exec"
    "strings"
    "time"
)

const (
    PanicLevel int = iota
    FatalLevel
    ErrorLevel
    WarnLevel
    InfoLevel
    DebugLevel
)

const (
    color_red = uint8(iota + 91)
    color_green        //    绿
    color_yellow        //    黄
    color_blue            //     蓝
    color_magenta         //    洋红
)

const (
    fatalPrefix        =    "[FATAL] "
    errorPrefix        =    "[ERROR] "
    warnPrefix        =    "[WARN] "
    infoPrefix        =    "[INFO] "
    debugPrefix        =    "[DEBUG] "
)

const (
    ByDay    int = iota
    ByWeek
    ByMonth
    BySize
)

type LogFile struct {
    level    int        // 日志等级
    saveMode int        // 保存模式
    saveDays int        // 日志保存天数
    logTime  int64        //
    fileName string        // 日志文件名
    filesize int64        // 文件大小, 需要设置 saveMode 为 BySize 生效
    fileFd   *os.File
}

var logFile LogFile

func init()  {
    logFile.saveMode = ByDay    // 默认按天保存
    logFile.saveDays = 15        // 默认保存三天的
    logFile.level = ErrorLevel
    logFile.filesize = 1024 * 1024 * 10    // 默认10M， 需要设置 saveMode 为 BySize
}

func Config(logFolder string, level int) {
    logFile.fileName = logFolder
    logFile.level = level

    log.SetOutput(logFile)
    //logger.SetFlags(logger.Lmicroseconds | logger.Lshortfile)
    log.SetFlags(log.Ldate | log.Ltime)
}
func GetLogFile() (*LogFile) {
    return &logFile
}

func SetLevel(level int) {
    logFile.level = level
}

func SetSaveMode(saveMode int)  {
    logFile.saveMode = saveMode
}

func SetSaveDays(saveDays int)  {
    logFile.saveDays = saveDays
}

func SetSaveSize(saveSize int64)  {
    logFile.filesize = saveSize
}

func Debug(args ...interface{}) {
    if logFile.level >= DebugLevel {
        log.SetPrefix(blue(debugPrefix))
        log.Output(2, fmt.Sprintln(args...))
    }
}

func Info(format string, args ...interface{}) {
    if logFile.level >= InfoLevel {
        log.SetPrefix(green(infoPrefix))
        log.Output(2, fmt.Sprintln(args...))
    }
}

func Warn(format string, args ...interface{}) {
    if logFile.level >= WarnLevel {
        log.SetPrefix(magenta(warnPrefix))
        log.Output(2, fmt.Sprintln(args...))
    }
}

func Error(args ...interface{}) {
    if logFile.level >= ErrorLevel {
        log.SetPrefix(red(errorPrefix))
        log.Output(2, fmt.Sprintln(args...))
    }
}

func Fatalf(args ...interface{}) {
    if logFile.level >= FatalLevel {
        log.SetPrefix(red(fatalPrefix))
        log.Output(2, fmt.Sprintln(args...))
    }
}

func GetRedPrefix(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_red, s)
}

func red(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_red, s)
}

func green(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_green, s)
}

func yellow(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_yellow, s)
}

func blue(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_blue, s)
}

func magenta(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_magenta, s)
}

func (me LogFile) Write(buf []byte) (n int, err error) {
    if me.fileName == "" {
        fmt.Printf("consol: %s", buf)
        return len(buf), nil
    }

    switch logFile.saveMode {
    case BySize:
        fileInfo, err := os.Stat(logFile.fileName)
        if  err != nil {
            logFile.createLogFile()
            logFile.logTime = time.Now().Unix()
        }else {
            filesize:= fileInfo.Size();
            if logFile.fileFd == nil ||
                filesize > logFile.filesize {
                logFile.createLogFile()
                logFile.logTime = time.Now().Unix()
            }
        }
    default:    // 默认按天  ByDay
        if logFile.logTime+3600 < time.Now().Unix() {
            logFile.createLogFile()
            logFile.logTime = time.Now().Unix()
        }
    }

    if logFile.fileFd == nil {
        fmt.Printf("logger fileFd is nil !\n")
        return len(buf), nil
    }

    return logFile.fileFd.Write(buf)
}

func (me *LogFile) createLogFile() {
    logdir := "./"
    if index := strings.LastIndex(me.fileName, "/"); index != -1 {
        logdir = me.fileName[0:index] + "/"
        os.MkdirAll(me.fileName[0:index], os.ModePerm)
    }

    now := time.Now()
    filename := fmt.Sprintf("%s_%04d%02d%02d_%02d%02d",
        me.fileName, now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute())
    if err := os.Rename(me.fileName, filename); err == nil {
        go func() {
            tarCmd := exec.Command("tar", "-zcf", filename+".tar.gz", filename, "--remove-files")
            tarCmd.Run()

            rmCmd := exec.Command("/bin/sh", "-c",
                "find "+logdir+` -type f -mtime +` +string(logFile.saveDays)+ ` -exec rm {} \;`)
            rmCmd.Run()
        }()
    }

    for index := 0; index < 10; index++ {
        if fd, err := os.OpenFile(me.fileName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, os.ModeExclusive); nil == err {
            me.fileFd.Sync()
            me.fileFd.Close()
            me.fileFd = fd
            break
        }else {
            fmt.Println("Open logfile error! err: ", err.Error())
        }
        me.fileFd = nil
    }
}

 main.go

@@ -12,12 +12,12 @@
    "gocv.io/x/gocv"
    "image"
    "image/color"
    "log"
    "os"
    "ruleprocess/cache"
    "ruleprocess/insertdata"
    "ruleprocess/ruleserver"
    "ruleprocess/util"
    "ruleprocess/logger"
    "sync"
)
var dbIp = flag.String("dbIp","127.0.0.1","dbserver ip")
@@ -25,6 +25,15 @@
var surveyPort = flag.Int("surveyPort",40007,"survey port") //心跳
var pubPort = flag.Int("pubPort",50007,"pubsub port") //数据更新
var initchan = make(chan bool)
func init () {
    var logFile = "/opt/ruleLog/error.log"
    var logSaveDays    =    15

    // 日志初始化
    logger.Config(logFile, logger.DebugLevel)
    logger.SetSaveDays(logSaveDays)
    logger.Info("loginit success !")
}
func main() {
    flag.Parse()
    wg := sync.WaitGroup{}
@@ -39,9 +48,9 @@
    wg.Wait()
    //resp,err := DrawPolygonOnImage()
    //if err != nil {
    //    log.Println("画框或者上传有问题")
    //    logger.Println("画框或者上传有问题")
    //}
    //log.Println(resp["fileUrl"].(string))
    //logger.Println(resp["fileUrl"].(string))
}
func nReciever(url string, m deliver.Mode, count int) {
    c := deliver.NewServer(m, url)
@@ -110,7 +119,7 @@
    }
    i := protomsg.Image{}
    err = proto.Unmarshal(bdata, &i)
    log.Println("----------------看看有几个算法：",len(m.Tasklab.Sdkinfos))
    logger.Info("----------------看看有几个算法：",len(m.Tasklab.Sdkinfos))
    for _, sdkinfo := range m.Tasklab.Sdkinfos { // yolo算法
        if sdkinfo.Sdktype == "Yolo" {
            arg := ruleserver.SdkData{}
@@ -137,7 +146,7 @@
                    fmt.Println("解析YOLO sdk数据时出现错误", err)
                    continue
                }
                log.Println("------当前算法name",sdkinfo.SdkName,"--------------看看yolo中有几个目标：",len(yoloParam.Infos))
                logger.Info("------当前算法name",sdkinfo.SdkName,"--------------看看yolo中有几个目标：",len(yoloParam.Infos))
                for _, info := range yoloParam.Infos {
                    if info.Typ == 0 {
                        photoMap := ruleserver.PhotoMap{Rects: rectFormat(info.RcObj), Score: float64(info.Prob)*100,IsYolo:true}
@@ -174,7 +183,7 @@
                    fmt.Println("解析FACE sdk数据时出现错误", err)
                    continue
                }
                log.Println("------当前算法name",sdkinfo.SdkName,"--------------看看人脸检测中有几个目标：",len(faceParam.Faces))
                logger.Info("------当前算法name",sdkinfo.SdkName,"--------------看看人脸检测中有几个目标：",len(faceParam.Faces))
                for _, info := range faceParam.Faces {
                    photoMap := ruleserver.PhotoMap{Rects: rectFormat(info.Pos.RcFace), Score: float64(info.Pos.Quality)*100, IsYolo:false,ThftRes:*(info.Result)}
                    arg.Photo = append(arg.Photo, photoMap)
@@ -215,9 +224,9 @@
                        fmt.Println("解析人脸比对数据时出现错误", err)
                        continue
                    }
                    log.Println("_________________________________________________________________解析出的人脸的相似的底库数据",binfos)
                    logger.Info("_________________________________________________________________解析出的人脸的相似的底库数据",binfos)
                }
                log.Println("------当前算法name",sdkinfo.SdkName,"--------------看看人脸提取中有几个目标：",len(faceParam.ExtComp))
                logger.Info("------当前算法name",sdkinfo.SdkName,"--------------看看人脸提取中有几个目标：",len(faceParam.ExtComp))
                for _, extComp := range faceParam.ExtComp {
                    baseinfos := protomsg.Binfos{}
                    err1 := proto.Unmarshal(extComp.Comp, &baseinfos)
@@ -280,7 +289,7 @@
    //client := &http.Client{Timeout: timeout}
    //resp, err := client.Do(request)
    //if err != nil {
    //    log.Fatal(err)
    //    logger.Fatal(err)
    //    return nil, err
    //}
    //defer func() {
@@ -303,7 +312,7 @@
    //    body := &bytes.Buffer{}
    //    _, err := body.ReadFrom(resp.Body)
    //    if err != nil {
    //        log.Fatal(err)
    //        logger.Fatal(err)
    //    }
    //    fmt.Println(resp.StatusCode)
    //    //fmt.Println(resp.Header)

 ruleserver/ruleToformula.go

@@ -3,8 +3,8 @@
import (
    "encoding/json"
    "fmt"
    "log"
    "ruleprocess/cache"
    "ruleprocess/logger"
    "sort"
    "strconv"
    "strings"
@@ -169,20 +169,20 @@
    //    if item.CameraId == cameraId && item.Type != "line" {
    //        // 需要根据比例把前台画的区域的坐标转化为相应摄像机拍摄的图像的大小   x坐标分别*image.width/页面区域宽  y坐标分别*image.height/页面区域高
    //        // 前台宽高固定
    //        //log.Println("------------符合条件的区域：",item)
    //        //logger.Println("------------符合条件的区域：",item)
    //        cameraPolygons = append(cameraPolygons, item)
    //    }
    //}
    cameraPolygons = cache.GetPolygonsByCameraId(cameraId)

    //log.Println("根据摄像机id查到的区域", cameraPolygons, "--区域数量为：", len(cameraPolygons))
    //logger.Println("根据摄像机id查到的区域", cameraPolygons, "--区域数量为：", len(cameraPolygons))
    return cameraPolygons
}

// 把sdk从数据帧上提取的按照区域分类归置
func SdkDataFormat(cameraId string, arg *SdkData, cameraPolygons []protomsg.CameraPolygon) {
    for _, polygon := range cameraPolygons {
        //log.Println("++++++在这儿看一下区域啊:", polygon.Polygon)
        //logger.Println("++++++在这儿看一下区域啊:", polygon.Polygon)
        areaMap := AreaMap{cameraId: cameraId, areaId: polygon.Id, areaJson: polygon.Polygon, triggerLine: polygon.TriggerLine, directionLine: polygon.DirectionLine}
        // 为每个摄像机区域填充数据
        areaMap.CountAreaObjs(arg)
@@ -201,17 +201,17 @@
        }
        // 跑本摄像机的所有规则组 一组一组跑
        taskRuleList := GetRuleGroup(args.CameraId) // 本摄像机下所有任务组
        //log.Println("看下摄像机下的任务组：",taskRuleList)
        //logger.Println("看下摄像机下的任务组：",taskRuleList)
        // 得到属于该摄像机的若干组任务的完整规则（跟每一条完整规则比较之后得出本张图像对于某个规则是否报警的结果。放进map，比如本帧图像的id，所碰撞成功的规则id）
        args.RuleResult = make(map[string]interface{})
        args.RuleResult["yolo"] = []Result{}
        args.RuleResult["face"] = []Arg{}
        if len(taskRuleList) > 0 {
            for _, taskRule := range taskRuleList {
                //log.Println("------------------------------任务规则：",taskRule)
                //logger.Println("------------------------------任务规则：",taskRule)
                ruleList := taskRule.GroupRules // 获取的是task下面的任务组
                taskId := taskRule.TaskId
                //log.Println("------------本组任务下的规则组的数量：",len(ruleList))
                //logger.Println("------------本组任务下的规则组的数量：",len(ruleList))
                for i := 0; i < len(ruleList); i++ {
                    temp := ruleList[i].Rules // temp为一组完整规则 在此需要判断规则是否是联动规则
                    if len(temp) > 0 {
@@ -234,7 +234,7 @@
            fmt.Println("比对规则有误", err.(string))
        }
    }()
    log.Println("+++++++++++规则开始运行+++++++++++++++++当前规则--：", (*groupRule).GroupText)
    logger.Info("+++++++++++规则开始运行+++++++++++++++++当前规则--：", (*groupRule).GroupText)
    resultSplice := []*LittleRuleResult{}
    // 先过完条件规则
    for j := 0; j < len(groupRule.Rules); j++ {
@@ -242,7 +242,7 @@
            for _, areaMap := range sdkData.AreaMapList {
                ruleResult := filterRule(groupRule.Rules[j], &areaMap)
                if ruleResult.Result != "" {
                    log.Println("条件规则结果：", ruleResult.Result)
                    logger.Info("条件规则结果：", ruleResult.Result)
                    resultSplice = append(resultSplice, &ruleResult)
                }
            }
@@ -255,7 +255,7 @@
            for _, areaMap := range sdkData.AreaMapList {
                ruleResult := transferParameters(groupRule.Rules[j], &areaMap)
                if ruleResult.Result != "" {
                    log.Println("数量规则结果：", ruleResult.Result)
                    logger.Info("数量规则结果：", ruleResult.Result)
                    resultSplice = append(resultSplice, &ruleResult)
                }
            }
@@ -267,7 +267,7 @@
            for _, areaMap := range sdkData.AreaMapList {
                ruleResult := timeRuleResult(groupRule.Rules[j], &areaMap)
                if ruleResult.Result != "" {
                    log.Println("时间规则结果：", ruleResult.Result)
                    logger.Info("时间规则结果：", ruleResult.Result)
                    resultSplice = append(resultSplice, &ruleResult)
                }
            }
@@ -296,13 +296,13 @@
        if strings.HasPrefix(completeFormula, ">") || strings.HasPrefix(completeFormula, "<") {
            completeFormula = completeFormula[1 :]
        }
        log.Println("-------------------看看拔毛后的表达式：",completeFormula)
        logger.Info("-------------------看看拔毛后的表达式：",completeFormula)
        expression, _ := govaluate.NewEvaluableExpression(completeFormula)
        result, _ := expression.Evaluate(nil) // 得到数学公式的结果
        return result.(bool)
    }
    if completeFormula != "" {
        log.Println("结果公式-----------：", completeFormula)
        logger.Info("结果公式-----------：", completeFormula)
        expression, _ := govaluate.NewEvaluableExpression(completeFormula)
        if strings.HasPrefix(completeFormula, "&&") || strings.HasPrefix(completeFormula, "||") {
            panic("规则有误，得到的数学公式不可解析")
@@ -316,7 +316,7 @@
                    timeEle.N = timeEle.InitN // 重置定时器
                }
            }
            log.Println("--------------------走这里了吗---------------")
            logger.Info("--------------------走这里了吗---------------")
            return false
        } else {
            // 最后成功报警才把符合条件的人脸数据塞进结果标签里
@@ -343,7 +343,7 @@
            for k, timeEle := range TimeEleList {
                if strings.Contains(k, taskId) {
                    if timeEle.N != 0 { // 跟这个任务有关的定时器要全部等于0
                        log.Println("———————————-------------不冤，你是被定时器打败的：")
                        logger.Info("———————————-------------不冤，你是被定时器打败的：")
                        flag = false
                    }
                }
@@ -380,10 +380,10 @@
                    //    args.RuleResult["face"] = faces
                    //}
                    args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkName, groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText,locations})
                    log.Println("-------------------yolo结果标签", args.RuleResult["yolo"].([]Result))
                    logger.Info("-------------------yolo结果标签", args.RuleResult["yolo"].([]Result))
                }
                if args.RuleResult["face"] != nil {
                    log.Println("-------------------face结果标签", args.RuleResult["face"].([]Arg))
                    logger.Info("-------------------face结果标签", args.RuleResult["face"].([]Arg))
                }
                return true
            } else {
@@ -404,7 +404,7 @@
            }
        }
    }
    //log.Println("-----------------------------------------------听说你是空的？",faces)
    //logger.Println("-----------------------------------------------听说你是空的？",faces)
    return faces
}

@@ -417,7 +417,7 @@
            }
        }
    }
    //log.Println("-----------------------------------------------听说你是空的？",faces)
    //logger.Println("-----------------------------------------------听说你是空的？",faces)
    return locations
}

@@ -439,12 +439,12 @@

    // }
    for _, obj := range arg.Photo {
        log.Println("------------------看看sdkData:", arg.SdkName, "的Photo数据----------------", obj, "----顺便看看占比-----：", PgsInterPercent(areaPoints, obj.Rects, widthScale, heigthScale))
        logger.Info("------------------看看sdkData:", arg.SdkName, "的Photo数据----------------", obj, "----顺便看看占比-----：", PgsInterPercent(areaPoints, obj.Rects, widthScale, heigthScale))
        if threshold <= obj.Score && size <= float64(obj.Rects.Width*obj.Rects.Height) && intersectionper <= PgsInterPercent(areaPoints, obj.Rects, widthScale, heigthScale) {
            // 这步要备齐表达式里所需要的所有参数
            a.targetNum++
            arg1 := Arg{obj.Score, PgsInterPercent(areaPoints, obj.Rects, widthScale, heigthScale), float64(obj.Rects.Width * obj.Rects.Height), obj.IsYolo, obj.Rects, obj.SdkName, obj.ThftRes, obj.Liker}
            //log.Println("放进去的arg：-------", arg1)
            //logger.Println("放进去的arg：-------", arg1)
            a.args = append(a.args, arg1)
            a.filterData = append(a.filterData, arg1)
        }
@@ -454,7 +454,7 @@
    a.time = time.Unix(time.Now().Unix(), 0).String()[11:16]
    a.keepRight = arg.KeepRight
    a.isStatic = arg.IsStatic
    //log.Println("--------------------看看区域数据：",*a)
    //logger.Println("--------------------看看区域数据：",*a)
}

// 将字符串格式的坐标序列化为Point格式
@@ -495,7 +495,7 @@
// 联动任务的处理
func LinkTask(args *SdkDatas, groupRule *protomsg.GroupRule, taskId string) {
    // new一个定时器，如果以此groupId为标志的定时器不存在的话
    log.Println("------------------------------------------当前是联动任务，规则是：", groupRule.GroupText)
    logger.Info("------------------------------------------当前是联动任务，规则是：", groupRule.GroupText)
    var flag bool = true
    var timeEle = TimeElement{N: 3, InitN: 3, GroupId: groupRule.GroupId}
    for k, timeEle1 := range TimeEleList {
@@ -531,13 +531,13 @@
        for _, va := range timeEle.RuleResults {
            if va.CameraId == args.CameraId {
                va.Result = strconv.FormatBool(isOk)
                log.Println("这个摄像机--", args.CameraId, "--被赋予了result", va.Result)
                logger.Info("这个摄像机--", args.CameraId, "--被赋予了result", va.Result)
            }
        }
        // 判断结果数组是否完满(即被赋值完毕)可得出报警结果
        var isPerfect = true
        for _, va := range timeEle.RuleResults {
            log.Println("---------------------瞅瞅当前数组________________：", *va)
            logger.Info("---------------------瞅瞅当前数组________________：", *va)
            if va.Result == "" && va.RuleWithPre != "||" {
                isPerfect = false
            }
@@ -550,12 +550,12 @@
            for _, va := range timeEle.RuleResults {
                completeFormula = completeFormula + va.RuleWithPre + "" + va.Result
            }
            log.Println("---------------------------联动任务的公式", completeFormula)
            logger.Info("---------------------------联动任务的公式", completeFormula)
            if completeFormula != "" {
                expression, _ := govaluate.NewEvaluableExpression(completeFormula)
                result, _ := expression.Evaluate(nil) // 得到数学公式的结果
                if result.(bool) {
                    log.Println("___________________________________________________________________联动任务报警")
                    logger.Info("___________________________________________________________________联动任务报警")
                    sdkName := ""
                    for j := 0; j < len(groupRule.Rules); j++ {
                        for _, sdkData := range args.Sdkdata {
@@ -566,10 +566,10 @@
                    }
                    if sdkName != "" {
                        args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkName, groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText,[]Rect{}})
                        log.Println("-------------------yolo结果标签", args.RuleResult["yolo"].([]Result))
                        logger.Info("-------------------yolo结果标签", args.RuleResult["yolo"].([]Result))
                    }
                    if args.RuleResult["face"] != nil {
                        log.Println("-------------------face结果标签", args.RuleResult["face"].([]Arg))
                        logger.Info("-------------------face结果标签", args.RuleResult["face"].([]Arg))
                    }
                    //os.Exit(0)
                }
@@ -600,7 +600,7 @@
                // 只需要过滤阈值，过滤完后数组长度大于0即为报警，但要考虑如何对每一张都报警呢
                argValue, err := strconv.ParseFloat(rule.SdkArgValue, 64)
                if err != nil {
                    log.Println("规则配置的阈值非法")
                    logger.Info("规则配置的阈值非法")
                    return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + "false", rule.Sort}
                }
                flag := "false"
@@ -631,7 +631,7 @@
                return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + flag, rule.Sort}
            }
            if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" { // 人脸检测
                log.Println("------------------------------------------------------------------------------------------------------------------------------------终于等到你")
                logger.Info("------------------------------------------------------------------------------------------------------------------------------------终于等到你")
                if rule.Operator == "==" || rule.Operator == ">=" || rule.Operator == "<=" || rule.Operator == "<" || rule.Operator == ">" || rule.Operator == "!=" {
                    // 如果是不规矩的连接符统统返回false 规则也只能判断人脸的相似度，所以不存在别的连接符
                    if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
@@ -647,13 +647,13 @@
                            var formula string
                            if rule.SdkArgAlias == "score" {
                                formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                                log.Println("当前相似度小公式：", formula)
                                logger.Info("当前相似度小公式：", formula)
                            } else if rule.SdkArgAlias == "proportion" {
                                formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                                log.Println("当前占比小公式：", formula)
                                logger.Info("当前占比小公式：", formula)
                            } else {
                                formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                                log.Println("当前尺寸小公式：", formula)
                                logger.Info("当前尺寸小公式：", formula)
                            }
                            expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
                            result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
@@ -664,7 +664,7 @@
                        am.targetNum = len(am.filterData) // 把符合条件的目标数量更新到targetNum字段
                    }
                    if am.targetNum > 0 {
                        log.Println("！！！！！！！！！人脸检测成功")
                        logger.Info("！！！！！！！！！人脸检测成功")
                        return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + "true", rule.Sort}
                    } else {
                        return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + "false", rule.Sort}
@@ -682,7 +682,7 @@
        // 处理的都是yolo数据
        if rule.SdkId == am.sdkId && rule.PolygonId == am.areaId { // 首先这条规则得是这个算法的规则，其次规则所对应的区域id要跟区域数据的id对的上
            if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
                log.Println("----------当前条件规则：---------", rule)
                logger.Info("----------当前条件规则：---------", rule)
                var args []Arg
                if rule.RuleWithPre == "&&" {
                    args = am.filterData
@@ -695,13 +695,13 @@
                    var formula string
                    if rule.SdkArgAlias == "score" {
                        formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                        log.Println("当前相似度小公式：", formula)
                        logger.Info("当前相似度小公式：", formula)
                    } else if rule.SdkArgAlias == "proportion" {
                        formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                        log.Println("当前占比小公式：", formula)
                        logger.Info("当前占比小公式：", formula)
                    } else {
                        formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                        log.Println("当前尺寸小公式：", formula)
                        logger.Info("当前尺寸小公式：", formula)
                    }
                    expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
                    result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
@@ -758,7 +758,7 @@
//            num++
//        }
//    }
//    log.Println("看看区域内符合条件的目标数量：----------", num)
//    logger.Println("看看区域内符合条件的目标数量：----------", num)
//    formula := strconv.Itoa(num) + " " + ">" + "0"
//    expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
//    result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
@@ -804,13 +804,13 @@
func timeRuleResult(rule *protomsg.Rule, am *AreaMap) LittleRuleResult {
    if rule.PolygonId == am.areaId && rule.SdkId == am.sdkId { // 首先规则所对应的区域id要跟区域数据的id对的上
        if rule.SdkArgAlias == "time_rule" { // 判断是否符合时间规则
            log.Println("----------当前时间规则：---------", rule)
            logger.Info("----------当前时间规则：---------", rule)
            // 根据放值字段里存的时间规则的id去另一个表里查需要比对的时间段（比如当前时间是周三，应根据区域id查出其周三的几个布防时间段，数组）
            //fmt.Println("时间规则的测试")
            now := time.Now()
            index := getIndexOfWeek(now.Weekday().String())
            timeList := GetTimeById(rule.SdkArgValue, index)
            log.Println("当天的时间段集合：----------", timeList)
            logger.Info("当天的时间段集合：----------", timeList)
            //fmt.Println("从数据库中查出的时间规则：", timeList)
            // 判断图片数据的时间是否符合当前规则 在一个即为true，全不在为false

@@ -837,12 +837,12 @@
                flag := "true"
                for _, timeSlot := range timeList {
                    formula := "'" + timeSlot.Start + "'" + " < " + "'" + am.time + "'"
                    log.Println("-----------------时间规则不满足的公式start：", formula)
                    logger.Info("-----------------时间规则不满足的公式start：", formula)
                    expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
                    result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果

                    formula1 := "'" + timeSlot.End + "'" + " > " + "'" + am.time + "'"
                    log.Println("-----------------时间规则不满足的公式end：", formula1)
                    logger.Info("-----------------时间规则不满足的公式end：", formula1)
                    expression1, _ := govaluate.NewEvaluableExpression(formula1) // 得到数学公式
                    result1, _ := expression1.Evaluate(nil)                      // 得到数学公式的结果
                    if result.(bool) && result1.(bool) {
@@ -893,7 +893,7 @@
    json.Unmarshal([]byte(cameraTimeRule.TimeRule), &timeRangeList)
    for _, timerange := range timeRangeList {
        if timerange.Day == index {
            //log.Println("取到的时间规则：", timerange.TimeRange)
            //logger.Println("取到的时间规则：", timerange.TimeRange)
            return timerange.TimeRange
        }
    }

 ruleserver/timeTicker.go

@@ -2,8 +2,7 @@

import (
    "fmt"
    "log"
    "os"
    "ruleprocess/logger"
    "time"
)

@@ -40,13 +39,13 @@
                for _, timeEle := range TimeEleList {
                    if timeEle.N > 0 {
                        timeEle.N = timeEle.N - 1
                        log.Println("-------------------------------------打印定时器元素当前值-----------------------------------------：",timeEle.N)
                        logger.Info("-------------------------------------打印定时器元素当前值-----------------------------------------：",timeEle.N)
                    }
                }
            case stop := <-stopChan:
                if stop {
                    fmt.Println("定时器结束")
                    os.Exit(0)
                    //os.Exit(0)
                }
            }
        }