test all process

554325746@qq.com

2019-05-28 70df7b912014201e271a2966599b84d77addd0f9

 camera/camera.go

@@ -1,200 +1,141 @@
package camera

import (
   "github.com/long/test/httpclient"
   "github.com/long/test/sdk"
        "errors"

   "nanomsg.org/go-mangos"
   "nanomsg.org/go-mangos/protocol/pair"
   "nanomsg.org/go-mangos/transport/ipc"
   "nanomsg.org/go-mangos/transport/tcp"
        "basic.com/dbapi.git"
        "basic.com/valib/deliver.git"
        "basic.com/pubsub/protomsg.git"

   "context"
   "encoding/json"
   "fmt"
   "time"
)
        "github.com/long/test/sdk"

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

type Camerdata struct {
   Cameraid string
   Rtsp     string
}
//var SocketManage = make(map[string]SocketContext)
var SocketManage sync.Map

type SocketContext struct {
   Sock    mangos.Socket
   Context context.Context
   Cancel  context.CancelFunc
}
var Initchannel = make(chan string)

func Taskdolist(cid string, taskid string, data []byte) {
    type SocketContext struct {
        Sock    deliver.Deliver
            Context context.Context
            Cancel  context.CancelFunc
    }

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

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

}
//get camera with task
var cameraTasks []protomsg.CameraAndTaskInfo

func Init() {

   CameraRelative()
   fmt.Println()
   fmt.Println("cid,taskid , sid: ", CtsId)
    fmt.Println("============ camera info ====================")
    ctsid := camval.FindAll()

   _, socket, err := NewCamerSocketListen("init", "tcp", "192.168.1.124", 0)
   if err != nil {
      return
   }
    fmt.Println("==============camera camera with task ================")
    cameraTasks=camval.FindAllCameraAndTask()

   go SendRecv(socket, Initchannel)
    go CreateCamera(Initchannel)

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

         if i < 2 {
            cameratodecode.Cameraid = cam.Cameraid
            cameratodecode.Rtsp = cam.RtspUrl
            Initchannel <- cameratodecode
         }
         i++
      }
   }
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 
            }

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

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

        socket.Context = ctx
        socket.Cancel = cancel

        socket.Sock = deliver.NewServer(deliver.Mode(mode), url)
        fmt.Println("new socket.Sock: ", socket.Sock)

        if socket.Sock == nil {
            return cameraid, socket, errors.New("create listen error")
        }
        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 {
      select {
      case <-socket.Context.Done():
         fmt.Println("listen recv quit")
         return
      default:
         if msg, err = socket.Sock.Recv(); err != nil {
            //fmt.Printf("%s ", err)
            continue
         } else {
            for _, taskid := range GetAlltask(cameraid) {
               go Taskdolist(cameraid, taskid, msg)
               fmt.Println("receive: ", len(msg), "cameraid: ", cameraid, "taskid: ", taskid)
            }
         }
      }
   }
}

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")
        var msg []byte
        var err error
        for {
            select {
                case <-socket.Context.Done():
                    fmt.Println("listen recv quit")
                        return
                default:
                        if msg, err = socket.Sock.Recv(); err != nil {
                            fmt.Println("err is: ", cameraid, err)
                                continue
                        } else {
                            fmt.Println()
                            fmt.Println("============== one msg input ==========")
                            fmt.Println("cameraid: ",cameraid,  len(msg))
                            for _, taskid := range GetAlltask(cameraid) {
                                time.Sleep(5* time.Second)
                                fmt.Println("cameraid: ",cameraid," taskid: ", taskid)
                                Taskdolist(cameraid, taskid, msg)
                             }
                        }
            }
        }
}

//   根据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)
         }
         return
      }
   }
   return
    for _, camsingle := range 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.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("分发的主题不存在")
               }
}