Merge remote-tracking branch 'origin/master'

sunty

2019-11-01 712ef81c6b8813a498a66cf61ffcd37e5c502c8c

 controllers/es.go

@@ -1,12 +1,16 @@
package controllers

import (
   "basic.com/valib/logger.git"
   "bytes"
   "encoding/json"
   "fmt"
   "github.com/gin-gonic/gin"
   "math/rand"
   "os/exec"
   "strconv"
   "strings"
   "webserver/cache"
   "webserver/extend/code"
   "webserver/extend/config"
   "webserver/extend/esutil"
@@ -17,147 +21,51 @@

type EsController struct{}

type EsManagementController struct{}

type EsClusterInfo struct {
   Ip string `json:"ip"`
}
// @Security ApiKeyAuth
// @Summary 比对数据查询
// @Description  比对数据查询
// @Accept  json
// @Produce json
// @Tags es
// @Param reqMap body models.EsSearch true "collection 为空"
// @Success 200 {string} json "{"code":200, msg:"目录结构数据", success:true}"
// @Failure 500 {string} json "{"code":500,  msg:"返回错误信息", success:false}"
// @Success 200 {string} json "{"code":200, msg:"", success:true}"
// @Failure 500 {string} json "{"code":500, msg:"", success:false}"
// @Router /data/api-v/es/queryEsCompareData [POST]
func PostEsCompareData(c *gin.Context) {
   searchBody := new(models.EsSearch)
   c.BindJSON(&searchBody)
   isEsSource := true
   databases := searchBody.DataBases
   page := searchBody.Page
   if page <= 0 {
      page = 1
   err := c.BindJSON(&searchBody)
   if err != nil || searchBody.PicUrl == "" || len(searchBody.DataBases) == 0 {
      util.ResponseFormat(c, code.RequestParamError, "参数有误")
      return
   }
   size := searchBody.Size
   if size <= 0 {
      size = 8
   }
   from := (page - 1) * size
   to := page * size
   threshold := searchBody.Threshold
   if threshold < 0 || threshold > 100 {
      threshold = 60
   }
   picUrl := searchBody.PicUrl
   /*feature := searchBody.Feature*/
   var featByte []byte
   if len(picUrl) > 3 { //   linux
      /*fileName := picUrl   // picIp 定义在 fileController weedfs 文件服务器 访问 路径 前缀
      detect := gorun.GetSimpleFaceDetect(fileName)
      if len(detect) != 1 {
         util.ResponseFormat(c,code.TooManyFeatureFindError,"图片特征值过多")
   if searchBody.CompareNum !="" {
      //二次搜索，不需要再比对了
      co := service.GetCompResultByNum(searchBody.CompareNum)
      if co != nil {
         //二次搜索和排序
         twiceM := GetCompareDataTwice(co,searchBody)
         util.ResponseFormat(c,code.Success,twiceM)
         return
      }else {
         featByte = detect[0]["feature"].([]byte)
      }*/ //   linux
   }
   data := make(map[string]interface{})
   searchBody.Page = 1
   searchBody.Size = 15000
   //searchMap := Struct2Map(*searchBody)
   if len(databases) == 1 && databases[0] == "esData" {
      searchBody.IsAggs = false
      data = searchEsData(*searchBody)
   } else {
      isEsSource = false
      data = service.QueryDbPersonsForCompare(*searchBody)
   }
   sources := data["datalist"].([]interface{})

   if len(sources) > 0 {
      //进行比对
      sources = sourceCompare(sources, isEsSource, featByte, threshold)
   } else {
      fmt.Println("查询条件下无数据 source 数据为空：" + string(len(sources)))
   }
   dataLen := len(sources)
   if from > dataLen-1 {
      from = 0
      to = 0
   }
   if to > dataLen {
      to = dataLen
   }
   sources = sources[from:to] // 数据 部分获取
   if !isEsSource {           //  人员数据要加底库名称
      for _, sou := range sources {
         tableId := sou.(map[string]interface{})["tableId"]
         if tableId != nil {
            info := QueryDbTableInfo(tableId.(string))
            if info["tableName"] != nil {
               sou.(map[string]interface{})["tableName"] = info["tableName"]
            } else {
               sou.(map[string]interface{})["tableName"] = "其他"
            }
            if info["bwType"] != nil {
               sou.(map[string]interface{})["bwType"] = info["bwType"]
            } else {
               sou.(map[string]interface{})["bwType"] = "4"
            }
         }
      } else {
         m :=make(map[string]interface{},0)
         m["compareNum"] = searchBody.CompareNum
         m["total"] = 0
         m["totalList"] = []CompareResult{}
         util.ResponseFormat(c,code.CompareResultGone,m)
         return
      }
   }
   dmap := make(map[string]interface{}, 2)
   dmap["datalist"] = sources
   dmap["total"] = dataLen
   util.ResponseFormat(c, code.Success, dmap)
   m :=make(map[string]interface{},0)
   m["compareNum"] = searchBody.CompareNum
   m["total"] = 0
   m["totalList"] = []CompareResult{}
   util.ResponseFormat(c,code.CompareResultGone,m)
}

// @Summary 查询摄像机以及启算法
// @Description 关联查询摄像机以及启算法
// @Produce json
// @Tags camera
// @Success 200 {string} json "{"code":200, success:true,  msg:"请求处理成功", data:"摄像机信息"}"
// @Failure 500 {string} json "{"code":500, success:false   msg:"",data:"错误信息内容"}"
// @Router /data/api-v/camera/queryCameraAndTaskInfo [get]
//func (ac *CameraController) QueryCameraAndTaskInfo(c *gin.Context) {
//   var cam models.Camera
//   rows := cam.FindAllCamTask()
//
//   if len(rows) == 0 {
//      util.ResponseFormat(c, code.ComError, "没有记录")
//      return
//   }
//   camList := make([]map[string]interface{}, 0, 5)
//   for _, cam := range rows {
//      newCam := make(map[string]interface{})
//      newCam["cameraid"] = cam.Id
//      newCam["rtspUrl"] = cam.Rtsp
//      tasks := cam.CamTask
//      taskList := make([]map[string]interface{}, 0)
//      if tasks != nil {
//         taskmap := make(map[string]interface{})
//         for _, task := range tasks {
//            taskId := taskmap[task.Taskid]
//            if taskId != nil {
//               cameraTasks := taskmap[task.Taskid].([]models.CameraTask)
//               cameraTasks = append(cameraTasks, task)
//               taskmap[task.Taskid] = cameraTasks
//            } else {
//               cameraTasks := make([]models.CameraTask, 0)
//               taskmap[task.Taskid] = append(cameraTasks, task)
//            }
//         }
//         for key, value := range taskmap {
//            i := make(map[string]interface{})
//            i["taskid"] = key
//            i["sdklist"] = value
//            taskList = append(taskList, i)
//         }
//      }
//      newCam["tasklist"] = taskList
//      camList = append(camList, newCam)
//   }
//   c.JSON(200, camList)
//
//}

func searchEsData(searchBody models.EsSearch) map[string]interface{} {
   //请求索引
@@ -166,7 +74,7 @@
   queryBody := searchBody.InputValue
   //检索框
   if queryBody != "" {
      queryStr = "\"must\":[{\"multi_match\":{\"query\":\"" + queryBody + "\",\"fields\":[\"tableName^1.5\",\"sex^2.0\",\"race^2.0\",\"content^1.0\",\"idCard^1.8\",\"cameraAddr^1.0\"]," +
      queryStr = "\"must\":[{\"multi_match\":{\"query\":\"" + queryBody + "\",\"fields\":[\"alarmRules.alarmLevel^1.5\",\"ageDescription^1.5\",\"taskName^1.5\",\"baseInfo.tableName^1.5\",\"sex^2.0\",\"race^2.0\",\"content^1.0\",\"baseInfo.idCard^1.8\",\"cameraAddr^1.0\"]," +
         "\"type\":\"cross_fields\",\"operator\":\"OR\",\"slop\":0,\"prefix_length\":0,\"max_expansions\":50,\"zero_terms_query\":\"NONE\",\"auto_generate_synonyms_phrase_query\":true,\"fuzzy_transpositions\":true,\"boost\":1}}],"
   }
   gteDate := searchBody.SearchTime[0]
@@ -191,7 +99,7 @@
   esTableIdStr := ""
   if tableId != nil && len(tableId) > 0 {
      esTableId = strings.Replace(strings.Trim(fmt.Sprint(tableId), "[]"), " ", "\",\"", -1)
      esTableIdStr = "{\"terms\":{\"tableId\":[\"" + esTableId + "\"]}},"
      esTableIdStr = "{\"terms\":{\"baseInfo.tableId\":[\"" + esTableId + "\"]}},"
   }
   isCollectionStr := ""
   isCollection := searchBody.Collection
@@ -205,8 +113,16 @@
   esSize := strconv.Itoa(webSize)
   //使用es底层机制处理分页
   //请求头
   url := "http://" + config.EsInfo.Masterip + ":" + config.EsInfo.Httpport +
   localConf, err2 := cache.GetServerInfo()
   if err2 !=nil || localConf.AlarmIp == "" || localConf.ServerId == "" {
      logger.Debug("localConfig is wrong!!!")
      return nil
   }
   url := "http://" + localConf.AlarmIp + ":" + strconv.Itoa(int(localConf.AlarmPort)) +
      "/" + index + "/_search?search_type=dfs_query_then_fetch"

   analyServerFilterStr := "{\"term\":{\"analyServerId\":\"" + localConf.ServerId + "\"}},"

   //请求体
   prama := "{\"from\":\"" + esFrom + "\",\"size\":\"" + esSize + "\"," +
      //   prama := "{\"size\":\"0\"," +
@@ -216,6 +132,7 @@
      taskIdStr +
      isCollectionStr +
      esTableIdStr +
      analyServerFilterStr +
      "{\"range\":{\"picDate\":{\"from\":\"" + gteDate + "\",\"to\":\"" + lteDate + "\",\"include_lower\":true,\"include_upper\":true,\"boost\":1}}}]}}," +
      "\"sort\":[{\"_score\":{\"order\":\"desc\"}},{\"picDate\":{\"order\":\"desc\"}}]," +
      "\"_source\":[\"baseInfo\",\"alarmRules\",\"sex\",\"analyServerName\",\"sdkName\",\"ageDescription\",\"content\",\"id\",\"cameraAddr\",\"picMaxUrl\",\"picDate\",\"race\",\"videoUrl\",\"picSmUrl\",\"taskName\",\"personIsHub\",\"isAlarm\",\"analyServerIp\",\"cameraId\"]}"
@@ -246,15 +163,252 @@
   return dataSource
}

// type  转 map
func Struct2Map(obj interface{}) map[string]interface{} {
   var data = make(map[string]interface{})
   bytes, _ := json.Marshal(obj)
   json.Unmarshal(bytes, &data)
   /*t := reflect.TypeOf(obj)
   v := reflect.ValueOf(obj)
   for i := 0; i < t.NumField(); i++ {
      data[t.Field(i).Name] = v.Field(i).Interface()
   }*/
   return data
//查询ES集群信息-入口
func (em *EsManagementController) GetEsClusterInfo(c *gin.Context) {
   var body EsClusterInfo
   c.BindJSON(&body)
   ip := body.Ip
   serverIp := ""
   if ip != "" {
      serverIp = ip
   } else {
      localConf, err2 := cache.GetServerInfo()
      if err2 != nil || localConf.ServerIp == "" {
         logger.Debug("localConfig is wrong!!!")
         util.ResponseFormat(c, code.QueryClusterInfoErr, err2)
         return
      }
      serverIp = localConf.ServerIp
   }
   nodeInfos, err := getEsClusterInfors(serverIp)
   if err != nil {
      util.ResponseFormat(c, code.QueryClusterInfoErr, err)
      return
   }
   util.ResponseFormat(c, code.QueryClusterInfoErr, nodeInfos)
}

//查询ES集群信息-业务逻辑
func getEsClusterInfors(ip string) ([]map[string]interface{}, error) {
   str := "curl " + ip + ":9200/_cat/nodes?v"
   cmd := exec.Command("sh", "-c", str)
   var out bytes.Buffer
   cmd.Stdout = &out
   err := cmd.Run()
   if err != nil {
      return nil, err
   }
   infos := strings.Split(string(out.String()), "\n")
   totalNodes := len(infos) - 1
   var nodeInfos []map[string]interface{}
   for i := 1; i < totalNodes; i++ {
      nodeInfo := make(map[string]interface{})
      context := strings.Fields(infos[i])
      nodeIp := context[0]
      Type := context[8]
      var nodeType string
      if Type == "*" {
         nodeType = "主节点"
      }
      if Type == "-" {
         nodeType = "从节点"
      }
      nodeInfo["ip"] = nodeIp
      nodeInfo["nodeType"] = nodeType
      url := "http://" + nodeIp + ":9200"
      buf := esutil.HttpGet(url)
      var info interface{}
      json.Unmarshal(buf, &info)
      tmpInfo := info.(map[string]interface{})
      tmpName := tmpInfo["name"].(string)
      versinInfo := tmpInfo["version"].(map[string]interface{})
      buildDate := versinInfo["build_date"].(string)
      nodeInfo["name"] = tmpName
      nodeInfo["buildDate"] = buildDate
      nodeInfos = append(nodeInfos, nodeInfo)
   }
   return nodeInfos, err
}

//创建节点
func (em *EsManagementController) CreateNode(c *gin.Context) {
   msg := "创建节点失败，请联系管理员"
   str := "sh /opt/script/create_first_node.sh"
   cmd := exec.Command("sh", "-c", str)
   var out bytes.Buffer
   cmd.Stdout = &out
   err := cmd.Run()
   if err != nil {

   }
   infos := strings.Split(string(out.String()), "\n")
   len := len(infos)
   res := infos[len-1]
   if res == "服务启动成功" {
      msg = "创建节点成功"
      util.ResponseFormat(c, code.Success, msg)
      return
   }
   util.ResponseFormat(c, code.CreateFirstNodeErr, msg)
}

//加入集群
func (em *EsManagementController) AddCluster(c *gin.Context) {
   var ac AddCluster
   err := c.BindJSON(&ac)
   if err != nil {
      util.ResponseFormat(c, code.RequestParamError, "参数有误")
      return
   }
   str := "sh /opt/script/create_node.sh " + ac.Option + ""
   if ac.Option == "1" {
      info, err := updateUnicastHosts(ac.Ip)
      if err != nil || info == false {
         util.ResponseFormat(c, code.QueryClusterInfoErr, err)
         return
      }
      if info == true {
         info := runScript(str)
         if info == "运行失败" {
            util.ResponseFormat(c, code.AddClusterInfoErr, info)
            return
         }
      }
   }
   if ac.Option == "2" {
      info, err := updateUnicastHosts(ac.Ip)
      if err != nil || info == false {
         util.ResponseFormat(c, code.QueryClusterInfoErr, err)
         return
      }
      if info == true {
         info := runScript(str)
         if info == "运行失败" {
            util.ResponseFormat(c, code.AddClusterInfoErr, info)
            return
         }
      }
   } else {
      util.ResponseFormat(c, code.RequestParamError, "参数有误")
      return
   }
   util.ResponseFormat(c, code.Success, "加入成功")
}

//脚本封装
func runScript(str string) string {

   cmd := exec.Command("sh", "-c", str)
   var out bytes.Buffer
   cmd.Stdout = &out
   err1 := cmd.Run()
   if err1 != nil {
      return "运行失败"
   }
   return out.String()
}

type AddCluster struct {
   Ip     string `json:"ip"`   //集群IP
   Option string `json:option` //节点类型
}

//更新组播列表
func updateUnicastHosts(host string) (bool, error) {
   nodeInfos, err := getEsClusterInfors(host)
   if err != nil {
      return false, err
   }
   var hosts []string
   for _, val := range nodeInfos {
      nodeType := val["nodeType"].(string)
      if nodeType == "主节点" {
         ip := val["ip"].(string)
         hosts = append(hosts, ip)
      }
   }
   msg := false
   for i, val := range hosts {
      val = val + ":9300"
      hosts[i] = val
   }
   verificationHosts := "[\"" + strings.Replace(strings.Trim(fmt.Sprint(hosts), "[]"), " ", "\",\"", -1) + "\"]"
   for i, val := range hosts {
      val = "\\\"" + val + "\\\""
      hosts[i] = val
   }
   oldUnicastHost := "\\[\\\"0.0.0.0:9300\\\"\\]"
   newUnicastHost := strings.Replace(strings.Trim(fmt.Sprint(hosts), ""), " ", ",", -1)
   str := "sed -ie 's/discovery.zen.ping.unicast.hosts: " + oldUnicastHost + "/discovery.zen.ping.unicast.hosts: " + newUnicastHost + "/g' /opt/elasticsearch/config/elasticsearch.yml"
   fmt.Println(str)
   cmd := exec.Command("sh", "-c", str)
   var out bytes.Buffer
   cmd.Stdout = &out
   err1 := cmd.Run()
   if err1 != nil {
      return false, err
   }
   res := getUnicastHosts()
   fmt.Println("res:          ", res)
   res1 := "discovery.zen.ping.unicast.hosts: " + verificationHosts + ""
   fmt.Println("res1:         ", res1)
   if res == res1 {
      msg = true
   }
   return msg, err
}

//func AddEsCluster(hosts []string) (string){
//   msg := "加入失败"
//   for i,val := range hosts{
//      val =val+":9300"
//      hosts[i] = val
//   }
//   verificationHosts := "[\""+strings.Replace(strings.Trim(fmt.Sprint(hosts), "[]"), " ", "\",\"", -1)+"\"]"
//   for i,val := range hosts{
//      val ="\\\""+val+"\\\""
//      hosts[i] = val
//   }
//   oldUnicastHost := "\\[\\\"0.0.0.0:9300\\\"\\]"
//   newUnicastHost := strings.Replace(strings.Trim(fmt.Sprint(hosts), ""), " ", ",", -1)
//   str := "sed -ie 's/discovery.zen.ping.unicast.hosts: "+oldUnicastHost+"/discovery.zen.ping.unicast.hosts: "+newUnicastHost+"/g' /opt/elasticsearch/config/elasticsearch.yml"
//   fmt.Println(str)
//   cmd := exec.Command("sh","-c",str)
//   var out bytes.Buffer
//   cmd.Stdout = &out
//   err := cmd.Run()
//   if err != nil {
//
//   }
//   res := getUnicastHosts()
//   fmt.Println("res:          ",res)
//   res1 := "discovery.zen.ping.unicast.hosts: "+verificationHosts+""
//   fmt.Println("res1:         ",res1)
//   if res == res1{
//      msg = "加入成功"
//   }
//   str2 := "echo \"node.master: true\" >> /opt/elasticsearch/config/elasticsearch.yml"
//   cmd2 := exec.Command("sh","-c",str2)
//   var out2 bytes.Buffer
//   cmd2.Stdout = &out2
//   err2 := cmd2.Run()
//   if err2 != nil {
//      msg = "加入失败"
//   }
//   return msg
//
//}

func getUnicastHosts() string {
   str := "cat /opt/elasticsearch/config/elasticsearch.yml | grep discovery.zen.ping.unicast.hosts:"
   cmd := exec.Command("sh", "-c", str)
   var out bytes.Buffer
   cmd.Stdout = &out
   err := cmd.Run()
   if err != nil {

   }
   infos := strings.Split(string(out.String()), "\n")[0]
   return infos

}