- package message
- import (
- "container/list"
- "data_manager"
- "encoding/json"
- "errors"
- "fmt"
- "sync"
- "github.com/pojoin/golis"
- )
- var once sync.Once
- type CommandProperty int
- type Command interface {
- //BuildResponse(info interface{}) (string, error)
- CommandHandle(session *golis.Iosession, CmdInfo interface{}) error
- GetCommandName() string
- IsProvidedResult() bool
- }
- type CommandAttribute struct {
- CommandName string
- IsProvidedResult bool //CommandProperty
- }
- ////////////////////////////dmc command ////////////////////////////
- ////////////////////// dmc_register /////////////////////
- type DmcRegist struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- RoomId int32 `json:"room_id"`
- }
- type DmcCommandRegist struct {
- cmdAtt CommandAttribute
- }
- ////////////////////// dmc_heart_beat //////////////////
- type DmcHeartBeat struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- DmcId int32 `json:"dmc_id"`
- }
- type DmcCommandHeartBeat struct {
- cmdAtt CommandAttribute
- }
- ////////////////////// dmc_unregister //////////////////
- type DmcUnregister struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- DmcId int32 `json:"dmc_id"`
- }
- type DmcCommandUnregister struct {
- cmdAtt CommandAttribute
- }
- ////////////////////// dmc_stream_query //////////////////
- type DmcStreamQuery struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- DmcId int32 `json:"dmc_id"`
- StreamName string `json:"stream_name"`
- }
- type DmcCommandStreamQuery struct {
- cmdAtt CommandAttribute
- }
- ////////////////// dmc _all_stream_update ////////////////
- type DmcAllStreamUpdate struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- DmcId int32 `json:"dmc_id"`
- StreamInfoList []data_manager.StreamAttributes `json:"stream_info"`
- }
- type DmcCommandAllStreamUpdate struct {
- cmdAtt CommandAttribute
- }
- ////////////////// dmc _capability_update ////////////////
- type DmcCapabilityUpdate struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- DmcId int32 `json:"dmc_id"`
- Cap Capability `json:"capability"`
- NCap NetworkCapability `json:"network_capability"`
- Ld Load `json:"load"`
- NLd NetworkLoad `json:"network_load"`
- }
- type DmcCommandCapabilityUpdate struct {
- cmdAtt CommandAttribute
- }
- //////////////////// dmc _stream_ update ////////////////
- type DmcStreamUpdate struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- DmcId int32 `json:"dmc_id"`
- ////////////////// StreamAttributes /////////////////
- Operate data_manager.StreamOperate `json:"operate"`
- Name string `json:"stream_name"`
- Status data_manager.StreamState `json:"status"`
- Attributes data_manager.StreamAttribute `json:"attributes"`
- Type data_manager.StreamType `json:"type"`
- DmsInfo []string `json:"dms_info"`
- }
- type DmcCommandStreamUpdate struct {
- cmdAtt CommandAttribute
- }
- //////////////////// dmc_get_dms_request ////////////////
- type DmcGetDmsRequest struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- DmcId int32 `json:"dmc_id"`
- Type data_manager.StreamType `json:"type"`
- }
- type DmcCommandGetDmsRequest struct {
- cmdAtt CommandAttribute
- }
- ////////// dmc_get_dms_response /////////////
- type DmcGetDmsResponse struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- DmcId int32 `json:"dmc_id"`
- DmsInfo []string `json:"dms_info"`
- }
- type DmcCommandGetDmsResponse struct {
- cmdAtt CommandAttribute
- }
- //////////////////////////////////////////////////////////////////
- ////////////////////////// gmc request & response /////////////////////////////
- func AddFrameTail(input []byte) []byte {
- buf := make([]byte, len(input)+1)
- copy(buf, input[:])
- buf[len(input)] = 0x00
- return buf
- }
- func JsonMarshal(msgStruct interface{}) ([]byte, error) {
- b, err := json.Marshal(msgStruct)
- if err != nil {
- fmt.Println("encoding faild")
- return nil, errors.New("encoding faild")
- } else {
- fmt.Println("encoded data : ")
- //fmt.Println(b)
- fmt.Println(string(b))
- }
- return b, err
- }
- type GmcMessage interface {
- BuildMessage() ([]byte, error)
- }
- /////// gmc_reg_response ///////
- type GmcRegResponse struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- DmcId int32 `json:"dmc_id"`
- }
- func (gm *GmcRegResponse) BuildMessage() ([]byte, error) {
- //gmcRegResponse := &GmcRegResponse{"gmc_reg_response", gm.MsgId, gm.DmcId}
- b, err := JsonMarshal(*gm)
- if b == nil {
- return b, err
- }
- buf := AddFrameTail(b)
- return buf, nil
- }
- /////// gmc_response ///////
- type GmcResponse struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- }
- func (gm *GmcResponse) BuildMessage() ([]byte, error) {
- //gmcResponse := &GmcResponse{"gmc_response", gm.MsgId}
- b, err := JsonMarshal(*gm)
- if b == nil {
- return b, err
- }
- buf := AddFrameTail(b)
- return buf, nil
- }
- /////// gmc_stream_query_result ///////
- type GmcStreamQueryResult struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- Result string `json:"result"`
- StreamName string `json:"stream_name"`
- DmsInfo *list.List `json:"dms_info"`
- }
- func (gm *GmcStreamQueryResult) BuildMessage() ([]byte, error) {
- b, err := JsonMarshal(*gm)
- if b == nil {
- return b, err
- }
- buf := AddFrameTail(b)
- return buf, nil
- }
- //////// gmc_get_dms_request //////////
- type GmcGetDmsRequest struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- }
- func (gm *GmcGetDmsRequest) BuildMessage() ([]byte, error) {
- //gmcResponse := &GmcGetDmsRequest{"gmc_get_dms_request", gm.MsgId}
- b, err := JsonMarshal(*gm)
- if b == nil {
- return b, err
- }
- buf := AddFrameTail(b)
- return buf, nil
- }
- /////////// gmc_get_dms_response /////////
- type GmcGetDmsResponse struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- DmcId int32 `json:"dmc_id"`
- DmsInfo []string `json:"dms_info"`
- }
- func (gm *GmcGetDmsResponse) BuildMessage() ([]byte, error) {
- b, err := JsonMarshal(*gm)
- if b == nil {
- return b, err
- }
- buf := AddFrameTail(b)
- return buf, nil
- }
- /////// gmc_stream_published_notify //////
- type GmcStreamPublishedNotify struct {
- Command string `json:"command"`
- MsgId string `json:"msg_id"`
- StreamName string `json:"stream_name"`
- DmsInfo []string `json:"dms_info"`
- }
- func (gm *GmcStreamPublishedNotify) BuildMessage() ([]byte, error) {
- b, err := JsonMarshal(*gm)
- if b == nil {
- return b, err
- }
- buf := AddFrameTail(b)
- return buf, nil
- }
- /////////// func BuildGmcMessage ////////////
- func BuildGmcMessage(gmcMsg GmcMessage) ([]byte, error) {
- msg, err := gmcMsg.BuildMessage()
- if err != nil {
- return nil, err
- }
- return msg, nil
- }
- ///////////////////////////////////////////////////////////////////////////////////
- func (dcr *DmcCommandRegist) CommandHandle(session *golis.Iosession, CmdInfo interface{}) error {
- fmt.Println("register command handle ........ ")
- cmd := CmdInfo.(*DmcRegist)
- fmt.Println("cmd:", cmd.Command, " msgid:", cmd.MsgId, " roomid:", cmd.RoomId)
- dmc_instance := data_manager.GetDmcInstance()
- dmc_id := dmc_instance.GetDmcId()
- dmc_info := data_manager.DmcInfo{dmc_id, list.New(), list.New(), cmd.RoomId, session}
- dmc_instance.AddDmcInfo(dmc_id, dmc_info)
- gmcResponse := &GmcRegResponse{"gmc_reg_response", cmd.MsgId, dmc_id}
- buf, err := BuildGmcMessage(gmcResponse)
- if err != nil {
- return err
- }
- fmt.Println("------------- Session write frame: ---")
- session.Write(buf)
- return nil
- }
- func (dcr *DmcCommandRegist) GetCommandName() string {
- return dcr.cmdAtt.CommandName
- }
- func (dcr *DmcCommandRegist) IsProvidedResult() bool {
- return dcr.cmdAtt.IsProvidedResult
- }
- ///////////////////// dmc_heart_beat ////////////////////////
- func (dcr *DmcCommandHeartBeat) CommandHandle(session *golis.Iosession, CmdInfo interface{}) error {
- fmt.Println("heart beat command handle ........ ")
- cmd := CmdInfo.(*DmcHeartBeat)
- fmt.Println("cmd:", cmd.Command, " msgid:", cmd.MsgId, " dmcid:", cmd.DmcId)
- return nil
- }
- func (dcr *DmcCommandHeartBeat) GetCommandName() string {
- return dcr.cmdAtt.CommandName
- }
- func (dcr *DmcCommandHeartBeat) IsProvidedResult() bool {
- return dcr.cmdAtt.IsProvidedResult
- }
- ////////////////////// dmc_unregister //////////////////
- func (dcr *DmcCommandUnregister) CommandHandle(session *golis.Iosession, CmdInfo interface{}) error {
- fmt.Println("unregister command handle ........ ")
- cmd := CmdInfo.(*DmcUnregister)
- fmt.Println("cmd:", cmd.Command, " msgid:", cmd.MsgId, " dmcid:", cmd.DmcId)
- dmc_instance := data_manager.GetDmcInstance()
- dmc_instance.DelDmcInfo(cmd.DmcId)
- gmcResponse := &GmcResponse{"gmc_response", cmd.MsgId}
- buf, err := BuildGmcMessage(gmcResponse)
- if err != nil {
- return err
- }
- fmt.Println("------------- Session write frame: ---")
- session.Write(buf)
- return nil
- }
- func (dcr *DmcCommandUnregister) GetCommandName() string {
- return dcr.cmdAtt.CommandName
- }
- func (dcr *DmcCommandUnregister) IsProvidedResult() bool {
- return dcr.cmdAtt.IsProvidedResult
- }
- ////////////////////// dmc_stream_query //////////////////
- func (dcr *DmcCommandStreamQuery) CommandHandle(session *golis.Iosession, CmdInfo interface{}) error {
- fmt.Println("stream query command handle ........ ")
- cmd := CmdInfo.(*DmcStreamQuery)
- fmt.Println("cmd:", cmd.Command, " msgid:", cmd.MsgId, " dmcid:", cmd.DmcId, "streamname:", cmd.StreamName)
- stream_instance := data_manager.GetStreamInstance()
- stream_info, result := stream_instance.GetStreamInfo(cmd.StreamName)
- var queryresponse *GmcStreamQueryResult
- if result == true {
- queryresponse = &GmcStreamQueryResult{"gmc_stream_query_result", cmd.MsgId, "Found", cmd.StreamName, stream_info.DmsInfo}
- } else {
- queryresponse = &GmcStreamQueryResult{"gmc_stream_query_result", cmd.MsgId, "Not Found", cmd.StreamName, nil}
- }
- b, err := json.Marshal(queryresponse)
- if err != nil {
- fmt.Println("encoding faild")
- return errors.New("encoding faild")
- } else {
- fmt.Println("encoded data : ")
- //fmt.Println(b)
- fmt.Println(string(b))
- }
- buf := make([]byte, len(b)+1)
- copy(buf, b[:])
- buf[len(b)] = 0x00
- fmt.Println("------------- Session write frame: ---")
- session.Write(buf)
- return nil
- }
- func (dcr *DmcCommandStreamQuery) GetCommandName() string {
- return dcr.cmdAtt.CommandName
- }
- func (dcr *DmcCommandStreamQuery) IsProvidedResult() bool {
- return dcr.cmdAtt.IsProvidedResult
- }
- ////////////////// dmc_all_stream_update ////////////////
- func (dcr *DmcCommandAllStreamUpdate) CommandHandle(session *golis.Iosession, CmdInfo interface{}) error {
- fmt.Println("all stream update command handle ........ ")
- cmd := CmdInfo.(*DmcAllStreamUpdate)
- fmt.Printf("------------------ len=%d cap=%d slice=%v\n", len(cmd.StreamInfoList), cap(cmd.StreamInfoList), cmd.StreamInfoList)
- fmt.Println("cmd:", cmd.Command, " dmc id:", cmd.DmcId, " msg id:", cmd.MsgId)
- stream_instance := data_manager.GetStreamInstance()
- stream_lst := cmd.StreamInfoList
- for _, stream_info := range stream_lst {
- temp_stream_info := data_manager.NewStreamInfo(stream_info.Name, cmd.DmcId, stream_info.State, stream_info.Attributes, stream_info.Type, list.New())
- stream_instance.AddStreamInfo(stream_info.Name, temp_stream_info)
- }
- gmcResponse := &GmcResponse{"gmc_response", cmd.MsgId}
- buf, err := BuildGmcMessage(gmcResponse)
- if err != nil {
- return err
- }
- fmt.Println("------------- Session write frame: ---")
- session.Write(buf)
- return nil
- }
- func (dcr *DmcCommandAllStreamUpdate) GetCommandName() string {
- return dcr.cmdAtt.CommandName
- }
- func (dcr *DmcCommandAllStreamUpdate) IsProvidedResult() bool {
- return dcr.cmdAtt.IsProvidedResult
- }
- ////////////////// dmc_capability_update ////////////////
- func (dcr *DmcCommandCapabilityUpdate) CommandHandle(session *golis.Iosession, CmdInfo interface{}) error {
- fmt.Println("capability update command handle ........ ")
- cmd := CmdInfo.(*DmcCapabilityUpdate)
- fmt.Println("cmd:", cmd.Command, " msgid:", cmd.MsgId, " dmcid:", cmd.DmcId, " cap item:", cmd.Cap.Item, " ld item", cmd.Ld.Item, " nld item:", cmd.NLd.Item)
- return nil
- }
- func (dcr *DmcCommandCapabilityUpdate) GetCommandName() string {
- return dcr.cmdAtt.CommandName
- }
- func (dcr *DmcCommandCapabilityUpdate) IsProvidedResult() bool {
- return dcr.cmdAtt.IsProvidedResult
- }
- //////////////////// dmc_stream_update ////////////////
- func (dcr *DmcCommandStreamUpdate) CommandHandle(session *golis.Iosession, CmdInfo interface{}) error {
- fmt.Println("stream update command handle ........ ")
- cmd := CmdInfo.(*DmcStreamUpdate)
- fmt.Println(" cmd:", cmd.Command, " dmc id:", cmd.DmcId, " msg id:", cmd.MsgId, " stream name:", cmd.Name)
- stream_instance := data_manager.GetStreamInstance()
- if cmd.Operate == data_manager.ADDStream {
- temp_stream_info := data_manager.NewStreamInfo(cmd.Name, cmd.DmcId, cmd.Status, cmd.Attributes, cmd.Type, list.New())
- stream_instance.AddStreamInfo(cmd.Name, temp_stream_info)
- } else if cmd.Operate == data_manager.DELStream {
- stream_instance.DelStreamInfo(cmd.Name)
- } else {
- temp_stream_info := data_manager.NewStreamInfo(cmd.Name, cmd.DmcId, cmd.Status, cmd.Attributes, cmd.Type, list.New())
- stream_instance.ModStreamInfo(cmd.Name, temp_stream_info)
- }
- gmcResponse := &GmcResponse{"gmc_response", cmd.MsgId}
- buf, err := BuildGmcMessage(gmcResponse)
- if err != nil {
- return err
- }
- fmt.Println("------------- Session write frame: ---")
- session.Write(buf)
- return nil
- }
- func (dcr *DmcCommandStreamUpdate) GetCommandName() string {
- return dcr.cmdAtt.CommandName
- }
- func (dcr *DmcCommandStreamUpdate) IsProvidedResult() bool {
- return dcr.cmdAtt.IsProvidedResult
- }
- //////////////////// dmc_get_dms_request ////////////////
- func (dcr *DmcCommandGetDmsRequest) CommandHandle(session *golis.Iosession, CmdInfo interface{}) error {
- fmt.Println("get dms request command handle ........ ")
- cmd := CmdInfo.(*DmcGetDmsRequest)
- fmt.Println(" cmd:", cmd.Command, " msg id:", cmd.MsgId, " dmc id:", cmd.DmcId)
- dmcManager := data_manager.GetDmcInstance()
- dmc, err1 := dmcManager.GetDmc(data_manager.GET_A_USEFUL_DMS)
- if err1 != nil {
- return errors.New("source dmc session is nil")
- }
- session_source_dmc := dmc.Session
- gmcGetDmsRequest := &GmcGetDmsRequest{"gmc_get_dms_request", cmd.MsgId}
- buf, err := BuildGmcMessage(gmcGetDmsRequest)
- if err != nil {
- return err
- }
- fmt.Println("------------- Session write gmcGetDmsRequest frame: ---")
- session_source_dmc.Write(buf)
- return nil
- }
- func (dcr *DmcCommandGetDmsRequest) GetCommandName() string {
- return dcr.cmdAtt.CommandName
- }
- func (dcr *DmcCommandGetDmsRequest) IsProvidedResult() bool {
- return dcr.cmdAtt.IsProvidedResult
- }