release task

554325746@qq.com

2019-06-16 5dafbd6b419cfc436aece4ac8b5580532f12afea

 camera/camera.go

@@ -3,29 +3,22 @@
import (
   "errors"

   "github.com/long/test/deliver"
   "github.com/long/test/httpclient"
   "basic.com/dbapi.git"
   "basic.com/valib/deliver.git"

   "github.com/long/test/sdk"
   "github.com/long/test/util"

   "context"
   "encoding/json"
   "fmt"
   "time"
   "sync"
   //"time"
)

/*
* 1.  获取 cid
* 2.  获取 cid和 taskid关系
* 3.  获取 cid ipc communication
 */
var SocketManage = make(map[string]SocketContext)
var Initchannel = make(chan Camerdata)
var UrlPort = 7000
//var SocketManage = make(map[string]SocketContext)
var SocketManage sync.Map

type Camerdata struct {
   Cameraid string
   Rtsp     string
}
var Initchannel = make(chan string)

type SocketContext struct {
   Sock    deliver.Deliver
@@ -33,115 +26,83 @@
   Cancel  context.CancelFunc
}

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

   fmt.Println("======================================")
   //  数据加工(打标签)
   sdkmsg := sdk.SdkData(cid, taskid, data)
   if sdkmsg.Tasklab == nil {
      fmt.Println("cid:%s 没有任务%s", cid, taskid)
      return
   }

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

}
var camval dbapi.CameraApi

func Init() {

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

   url := fmt.Sprintf("%s%d", "tcp://192.168.1.124:", UrlPort)
   _, socket, err := NewCamerSocketListen(deliver.Pair, "init", url)
   if err != nil {
      return
   fmt.Println("============ camera info ====================")
   for _, cd := range util.CameraIds {
      fmt.Println(cd)
      fmt.Println()
   }
   UrlPort++

   go SendRecv(socket, Initchannel)
   go CreateCamera(Initchannel)
   go AutoDelCamera(util.Cameraflag)

   var cameratodecode Camerdata
   for {
      time.Sleep(2 * time.Second)
      i := 0
      for _, cam := range CtsId {
   for _, cam := range util.CameraIds {
      Initchannel <- cam.Id
   }
}

         if i < 2 {
            cameratodecode.Cameraid = cam.Cameraid
            cameratodecode.Rtsp = cam.RtspUrl
            Initchannel <- cameratodecode
func CreateCamera(camera chan string) {
   for camid := range camera {
      if _, ok := SocketManage.Load(camid); !ok {
         url := fmt.Sprintf("ipc:///tmp/%s.ipc", camid)

         id, socketlisten, err := NewCamerSocketListen(deliver.PushPull, camid, url)
         if err != nil {
            fmt.Println("create socket error")
            continue
         }
         i++

         go func(cid string, sock SocketContext) {
            Recv(cid, sock)
         }(id, socketlisten)
      }
   }
}

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("camera info: failed send")
   }
}
//动态处理
func AutoDelCamera(cameraflag chan bool) {

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, urlport int) {
            fmt.Println("create cid server: ", id)
            url := fmt.Sprintf("%s%d", "tcp://192.168.1.124:", urlport)
            cid, socketlisten, err := NewCamerSocketListen(deliver.PushPull, id, url)
   for _ = range cameraflag {
      fmt.Println("test autodelcameraflag")
      var oldcamera []string

            if err != nil {
               return
      SocketManage.Range(func(k, v interface{}) bool {
         if str, ok := k.(string); ok {
            oldcamera = append(oldcamera, str)
         }
         return true
      })

      var newcamera []string

      for _, value := range util.CameraIds {
         newcamera = append(newcamera, value.Id)
      }

      cameraChanDel := util.Difference(oldcamera, newcamera)
      fmt.Println(cameraChanDel)

      for key, op := range cameraChanDel {
         if op == "add" {
            Initchannel <- key
         } else {
            if sock, ok := SocketManage.Load(key); ok {
               if socket, sok := sock.(SocketContext); sok {
                  socket.Cancel()
                  SocketManage.Delete(key)
               }
            }
            fmt.Println("input id: ", id, " output id :", cid)
            Recv(cid, socketlisten)

         }(cam.Cameraid, UrlPort)

         UrlPort++
      }
   }
}

// 获取 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 {
            tasks = append(tasks, tasksingle.Taskid)
            fmt.Println("删除camera server : ", key)
         }
         return
      }
   }
   return
}

// create server
func NewCamerSocketListen(mode int, cameraid string, url string) (cid string, socket SocketContext, err error) {
   fmt.Println("url is: ", url)
   ctx, cancel := context.WithCancel(context.Background())

   socket.Context = ctx
@@ -153,13 +114,11 @@
   if socket.Sock == nil {
      return cameraid, socket, errors.New("create listen error")
   }

   SocketManage[cameraid] = socket
   SocketManage.Store(cameraid, socket)
   return cameraid, socket, nil
}

func Recv(cameraid string, socket SocketContext) {
   //   socket.Sock.SetOption(mangos.OptionRecvDeadline, 5*time.Second)
   var msg []byte
   var err error
   for {
@@ -169,15 +128,50 @@
         return
      default:
         if msg, err = socket.Sock.Recv(); err != nil {
            //fmt.Printf("%s ", err)
            fmt.Println("err is: ", cameraid, err)
            continue
         } else {
            fmt.Println("cameraid: ", len(msg))
            fmt.Println()
            fmt.Println("============== one msg input ==========")
            for _, taskid := range GetAlltask(cameraid) {
               //time.Sleep(5 * time.Second)
               fmt.Println("cameraid: ", cameraid, " taskid: ", taskid)
               Taskdolist(cameraid, taskid, msg)
               //   fmt.Println("receive: ", len(msg), "cameraid: ", cameraid, "taskid: ", taskid)
            }
         }
      }
   }
}

//   根据cid 获取 所有的任务
func GetAlltask(cid string) (tasks []string) {
   for _, camsingle := range util.CameraTasks {
      if cid == camsingle.Camera.Id {
         for _, tasksingle := range camsingle.Tasks {
            tasks = append(tasks, tasksingle.Taskid)
         }
         return
      }
   }
   return
}

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

   //  数据加工(打标签)
   sdkmsg := sdk.SdkData(cid, taskid, data)
   if sdkmsg.Tasklab == nil {
      fmt.Printf("cid:%s 没有任务%s\n", cid, taskid)
      return
   }

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