update

zhangmeng

2019-12-16 93c3c5e031eb1ca0960c2cf69d81423875b553c7

 camera/camera.go

@@ -1,194 +1,227 @@
package camera

import (
   "github.com/long/test/httpclient"
   "github.com/long/test/sdk"
   "strings"
   "taskpubsub/sdk"
   "taskpubsub/util"

   "nanomsg.org/go-mangos"
   "nanomsg.org/go-mangos/protocol/pair"
   "nanomsg.org/go-mangos/transport/ipc"
   "nanomsg.org/go-mangos/transport/tcp"

   "context"
   "encoding/json"
   "fmt"
   "time"
   "basic.com/pubsub/protomsg.git"
   "basic.com/valib/deliver.git"
   "basic.com/valib/logger.git"
   "github.com/gogo/protobuf/proto"
)

/*
* 1.  获取 cid
* 2.  获取 cid和 taskid关系
* 3.  获取 cid ipc communication
 */
var SocketManage = make(map[string]SocketContext)
var Initchannel = make(chan Camerdata)
var UrlPort = 7000
const (
   faceExtractWebCID    = "virtual-face-extract-web-camera-id"
   faceExtractWebTaskID = "92496BDF-2BFA-98F2-62E8-96DD9866ABD2"
)

type Camerdata struct {
   Cameraid string
   Rtsp     string
var SocketManage = make(map[string]util.SocketContext)

var shm bool = false

var innerRecvTopic = []string{
   "virtual-faceextract-sdk-pull_2", //to web 以图搜图
}

type SocketContext struct {
   Sock    mangos.Socket
   Context context.Context
   Cancel  context.CancelFunc
func initInnerTopic() {
   // for _, recvTopic := range innerRecvTopic {
   //    createCameraRecvServerAndListen(recvTopic)
   // }
}

func Taskdolist(cid string, taskid string, data []byte) {
func Init(useShm bool) {
   shm = useShm

   //  数据加工(打标签)
   sdkmsg := sdk.SdkData(cid, taskid, data)
   fmt.Println("============================")

   fmt.Println("sdk  打标签： ", cid, taskid, len(data))

   //  计算分发的主题
   SendTopic := sdk.SdkSendTopic(sdkmsg)
   if _, ok := sdk.SdkMap[SendTopic]; ok {
      fmt.Println("分发的主题存在")
      sdk.SdkMap[SendTopic] <- sdkmsg
      //fmt.Println("重新开始循环: ", sdk.SdkMap)
   } else {
      fmt.Println("分发的主题不存在")
   logger.Info("============ camera info ====================")
   for _, cd := range util.CameraIds {
      logger.Info(cd)
      logger.Info()
   }

}

func Init() {

   CameraRelative()
   fmt.Println()
   fmt.Println("cid,taskid , sid: ", CtsId)

   _, socket, err := NewCamerSocketListen("init", "tcp", "192.168.1.124", 0)
   if err != nil {
      return
   // 摄像机初始化
   for _, cam := range util.CameraIds {
      createCameraRecvServerAndListen(cam.Id)
   }

   go SendRecv(socket, Initchannel)
   //文件初始化
   for _, f := range util.FileArr {
      logger.Info(f)
   }
   for _, f := range util.FileArr {
      createCameraRecvServerAndListen(f.Id)
   }

   var cameratodecode Camerdata
   for {
      time.Sleep(2 * time.Second)
      i := 0
      for _, cam := range CtsId {
   // 手动输入的主题
   initInnerTopic()

         if i < 2 {
            cameratodecode.Cameraid = cam.Cameraid
            cameratodecode.Rtsp = cam.RtspUrl
            Initchannel <- cameratodecode
   go autoUpdateCamera(util.Cameraflag)

   go autoUpdateFiles(util.Fileflag)
}

// camera 接受数据
func createCameraRecvServerAndListen(id string) {
   if _, isExist := SocketManage[id]; !isExist { //不存在

      url := "ipc:///tmp/" + id + ".ipc"
      m := deliver.PushPull
      if shm {
         m = deliver.Shm
         url = id

      }

      logger.Info("CAMERA URL : ", url)
      socket, err := util.NewSocketListen(int(m), url, shm)
      if err != nil {
         logger.Error("create socket error")
         return
      }
      SocketManage[id] = socket

      go Recv(socket)
   }
}

func deleteCameraRecvServer(id string) {
   if _, isExist := SocketManage[id]; isExist { //存在
      SocketManage[id].Cancel()
      delete(SocketManage, id)
      logger.Info("删除server sdk: ", id)
   }
}

//动态处理
func autoUpdateCamera(cameraflag chan bool) {

   for _ = range cameraflag {
      logger.Info("test autodelcameraflag")
      var oldcameras []string

      for key := range SocketManage {
         if !strings.HasPrefix(key, util.File_Video_Id_Pre) && !strings.HasPrefix(key, util.File_Audio_Id_Pre) && !strings.HasPrefix(key, util.File_Img_Id_Pre) {
            oldcameras = append(oldcameras, key)
         }
         i++
      }

      var newcameras []string
      for _, camnew := range util.CameraIds {
         newcameras = append(newcameras, camnew.Id)
      }

      // 手动添加的全部加上
      for _, recvTopic := range innerRecvTopic {
         newcameras = append(newcameras, recvTopic)
      }

      cameraListUpdate := util.Difference(oldcameras, newcameras)
      logger.Info(cameraListUpdate)

      for key, op := range cameraListUpdate {
         if op == "add" {
            createCameraRecvServerAndListen(key)
         } else {
            deleteCameraRecvServer(key)
         }
      }
   }

}

func Recv(cameraid string, socket SocketContext) {
   socket.Sock.SetOption(mangos.OptionRecvDeadline, 5*time.Second)
   var msg []byte
//动态处理文件
func autoUpdateFiles(fileflag chan bool) {

   for _ = range fileflag {
      logger.Info("do auto del fileflag")
      var oldIds []string

      for key := range SocketManage {
         if strings.HasPrefix(key, util.File_Video_Id_Pre) || strings.HasPrefix(key, util.File_Audio_Id_Pre) || strings.HasPrefix(key, util.File_Img_Id_Pre) {
            oldIds = append(oldIds, key)
         }
      }

      var newIds []string
      for _, f := range util.FileArr {
         newIds = append(newIds, f.Id)
      }

      fileListUpdate := util.Difference(oldIds, newIds)
      logger.Info(fileListUpdate)

      for key, op := range fileListUpdate {
         if op == "add" {
            createCameraRecvServerAndListen(key)
         } else {
            deleteCameraRecvServer(key)
         }
      }
   }
}

func Recv(socket util.SocketContext) {

   tryCount := 0

   var recvmessage []byte
   var imagemsg protomsg.Image
   var err error
   for {
      select {
      case <-socket.Context.Done():
         fmt.Println("listen recv quit")
         socket.Sock.Close()
         logger.Error("listen recv quit")
         return
      default:
         if msg, err = socket.Sock.Recv(); err != nil {
            //fmt.Printf("%s ", err)
         if recvmessage, err = socket.Sock.Recv(); err != nil {

            // tryCount++
            // socket = util.MaybeRestartSocket(socket, &tryCount)

            if socket.UseSHM {
               if tryCount > util.ShmMaxTryCount {
                  socket.Sock.Close()
                  socket, err = util.NewSocketListen(socket.Mode, socket.URL, socket.UseSHM)
                  logger.Info("SDK SEND SHM TRY :", util.ShmMaxTryCount, " RESTART IT")
                  tryCount = 0
                  continue
               }
               tryCount++
            }
            continue
         }

         unmsg, err := util.UnCompress(recvmessage)
         if err != nil {
            logger.Error(err)
            continue
         }

         if err := proto.Unmarshal(unmsg, &imagemsg); err != nil {
            logger.Error("recv msg is not protomsgImage")
            continue
         }
         if faceExtractWebCID == imagemsg.Cid { //以图搜图
            logger.Info("id: ", faceExtractWebTaskID)
            doTaskList(imagemsg.Cid, "", faceExtractWebTaskID, recvmessage)
         } else {
            for _, taskid := range GetAlltask(cameraid) {
               Taskdolist(cameraid, taskid, msg)
               fmt.Println("receive: ", len(msg), "cameraid: ", cameraid, "taskid: ", taskid)
            taskIDs := GetAllTaskByID(imagemsg.Cid)
            for _, taskID := range taskIDs {
               doTaskList(imagemsg.Cid, "", taskID, recvmessage)
            }
         }
      }
   }
}

func send(socket SocketContext, cam Camerdata) {
   b, err := json.Marshal(cam)
   if err != nil {
      fmt.Println("can not json convert !", cam)
   }
   if err := socket.Sock.Send(b); err != nil {
      fmt.Println("failed send")
   }
}

func SendRecv(socket SocketContext, camera chan Camerdata) {
   socket.Sock.SetOption(mangos.OptionRecvDeadline, 5*time.Second)
   for cam := range camera {
      send(socket, cam)
      if _, ok := SocketManage[cam.Cameraid]; !ok {
         go func(id string) {
            fmt.Println("create cid server: ", id)
            cid, socketlisten, _ := NewCamerSocketListen(id, "tcp", "192.168.1.124", 0)
            fmt.Println("input id: ", id, " output id :", cid)
            Recv(cid, socketlisten)

         }(cam.Cameraid)
      }
   }
}

// new camera server
func NewCamerSocketListen(cameraid string, protocol string, ip string, port int) (cid string, socket SocketContext, err error) {

   ctx, cancel := context.WithCancel(context.Background())

   var url string

   socket.Context = ctx
   socket.Cancel = cancel

   switch protocol {
   case "tcp":
      if port == 0 {
         port = UrlPort
         UrlPort++
      }
      url = fmt.Sprintf("%s://%s:%d", protocol, ip, port)
   case "ipc":
      url = fmt.Sprintf("%s://%s", cameraid)
   }
   fmt.Println(url)

   if socket.Sock, err = pair.NewSocket(); err != nil {
      fmt.Println(cameraid, "can't get new pair socket: ", err.Error())
      return cameraid, socket, err
   }
   socket.Sock.AddTransport(tcp.NewTransport())
   socket.Sock.AddTransport(ipc.NewTransport())

   socket.Sock.SetOption(mangos.OptionMaxRecvSize, 32*1024*1024)
   socket.Sock.SetOption(mangos.OptionWriteQLen, 10)
   socket.Sock.SetOption(mangos.OptionReadQLen, 10)

   if err = socket.Sock.Listen(url); err != nil {
      fmt.Println("socket lisnte error ", cameraid)
   }
   fmt.Println(cameraid, "success")

   SocketManage[cameraid] = socket

   return cameraid, socket, err
}

// 获取 cid ， taskid, sdkid 关系
var CtsId []httpclient.Camerasingle

func CameraRelative() {
   CtsId = httpclient.GetEsDataReq("http://127.0.0.1:8000/data/api-v/camera/queryCameraAndTaskInfo")
}

//   根据cid 获取 所有的任务
func GetAlltask(cid string) (tasks []string) {
   for _, camsingle := range CtsId {
      if cid == camsingle.Cameraid {
         for _, tasksingle := range camsingle.TaskList {
//   据cid 获取 所有的任务
func GetAllTaskByID(cid string) (tasks []string) {
   for _, camsingle := range util.CameraTasks {
      if cid == camsingle.Camera.Id {
         for _, tasksingle := range camsingle.Tasks {
            if !tasksingle.Enable {
               continue
            }
            tasks = append(tasks, tasksingle.Taskid)
         }
         return
@@ -196,3 +229,32 @@
   }
   return
}

func doTaskList(cid string, caddr string, taskid string, data []byte) {

   //  数据加工(打标签)
   //logger.Info("taskid: ", taskid, "has ", len(data), "data[]byte")
   sdkmsg := sdk.ToSdkMsg(cid, caddr, taskid, data)
   if sdkmsg.Tasklab == nil {
      logger.Error(cid, " not have taskid: ", taskid)
      return
   }

   //  计算分发的主题
   SendTopic := sdk.GetSdkSendTopic(sdkmsg)
   //logger.Info(SendTopic)
   if "facedetect-sdk-no-track" == SendTopic || "virtual-faceextract-sdk-pull" == SendTopic {
      logger.Info(SendTopic)
   }
   if _, ok := sdk.SdkMap[SendTopic]; ok {
      if "facedetect-sdk-no-track" == SendTopic || "virtual-faceextract-sdk-pull" == SendTopic {
         logger.Info(SendTopic)
      }
      sdk.SdkMap[SendTopic] <- sdkmsg
      if "facedetect-sdk-no-track" == SendTopic || "virtual-faceextract-sdk-pull" == SendTopic {
         logger.Info("dispute sendtopic success", SendTopic)
      }
   } else {
      logger.Info("分发的主题不存在")
   }
}