add alarm message

chenshijun

2020-03-03 4c3c6e9dbfb046aedd0dbc30b78b8bdc61bae977

add alarm message

 alarm.pb.go

@@ -20,14 +20,63 @@
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type FaceTempInfo struct {
    AlarmVal             float32  `protobuf:"fixed32,1,opt,name=alarmVal,proto3" json:"alarmVal,omitempty"`
    SetVal               float32  `protobuf:"fixed32,2,opt,name=setVal,proto3" json:"setVal,omitempty"`
    FacePos              *Rect    `protobuf:"bytes,3,opt,name=facePos,proto3" json:"facePos,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *FaceTempInfo) Reset()         { *m = FaceTempInfo{} }
func (m *FaceTempInfo) String() string { return proto.CompactTextString(m) }
func (*FaceTempInfo) ProtoMessage()    {}
func (*FaceTempInfo) Descriptor() ([]byte, []int) {
    return fileDescriptor_4a4142572412ce8e, []int{0}
}
func (m *FaceTempInfo) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_FaceTempInfo.Unmarshal(m, b)
}
func (m *FaceTempInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_FaceTempInfo.Marshal(b, m, deterministic)
}
func (m *FaceTempInfo) XXX_Merge(src proto.Message) {
    xxx_messageInfo_FaceTempInfo.Merge(m, src)
}
func (m *FaceTempInfo) XXX_Size() int {
    return xxx_messageInfo_FaceTempInfo.Size(m)
}
func (m *FaceTempInfo) XXX_DiscardUnknown() {
    xxx_messageInfo_FaceTempInfo.DiscardUnknown(m)
}

var xxx_messageInfo_FaceTempInfo proto.InternalMessageInfo

func (m *FaceTempInfo) GetAlarmVal() float32 {
    if m != nil {
        return m.AlarmVal
    }
    return 0
}

func (m *FaceTempInfo) GetSetVal() float32 {
    if m != nil {
        return m.SetVal
    }
    return 0
}

func (m *FaceTempInfo) GetFacePos() *Rect {
    if m != nil {
        return m.FacePos
    }
    return nil
}

type AlarmInfo struct {
    Type                 string   `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
    DevId                string   `protobuf:"bytes,2,opt,name=devId,proto3" json:"devId,omitempty"`
    Time                 string   `protobuf:"bytes,3,opt,name=time,proto3" json:"time,omitempty"`
    AlarmVal             float32  `protobuf:"fixed32,4,opt,name=alarmVal,proto3" json:"alarmVal,omitempty"`
    SetVal               float32  `protobuf:"fixed32,5,opt,name=setVal,proto3" json:"setVal,omitempty"`
    FacePos              *Rect    `protobuf:"bytes,6,opt,name=facePos,proto3" json:"facePos,omitempty"`
    Image                *Image   `protobuf:"bytes,7,opt,name=image,proto3" json:"image,omitempty"`
    Data                 []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
@@ -37,7 +86,7 @@
func (m *AlarmInfo) String() string { return proto.CompactTextString(m) }
func (*AlarmInfo) ProtoMessage()    {}
func (*AlarmInfo) Descriptor() ([]byte, []int) {
    return fileDescriptor_4a4142572412ce8e, []int{0}
    return fileDescriptor_4a4142572412ce8e, []int{1}
}
func (m *AlarmInfo) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_AlarmInfo.Unmarshal(m, b)
@@ -64,125 +113,98 @@
    return ""
}

func (m *AlarmInfo) GetDevId() string {
func (m *AlarmInfo) GetData() []byte {
    if m != nil {
        return m.Data
    }
    return nil
}

type AlarmMessage struct {
    DevId                string       `protobuf:"bytes,1,opt,name=devId,proto3" json:"devId,omitempty"`
    Time                 string       `protobuf:"bytes,2,opt,name=time,proto3" json:"time,omitempty"`
    AlarmInfo            []*AlarmInfo `protobuf:"bytes,3,rep,name=alarmInfo,proto3" json:"alarmInfo,omitempty"`
    Data                 []byte       `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
    XXX_NoUnkeyedLiteral struct{}     `json:"-"`
    XXX_unrecognized     []byte       `json:"-"`
    XXX_sizecache        int32        `json:"-"`
}

func (m *AlarmMessage) Reset()         { *m = AlarmMessage{} }
func (m *AlarmMessage) String() string { return proto.CompactTextString(m) }
func (*AlarmMessage) ProtoMessage()    {}
func (*AlarmMessage) Descriptor() ([]byte, []int) {
    return fileDescriptor_4a4142572412ce8e, []int{2}
}
func (m *AlarmMessage) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_AlarmMessage.Unmarshal(m, b)
}
func (m *AlarmMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_AlarmMessage.Marshal(b, m, deterministic)
}
func (m *AlarmMessage) XXX_Merge(src proto.Message) {
    xxx_messageInfo_AlarmMessage.Merge(m, src)
}
func (m *AlarmMessage) XXX_Size() int {
    return xxx_messageInfo_AlarmMessage.Size(m)
}
func (m *AlarmMessage) XXX_DiscardUnknown() {
    xxx_messageInfo_AlarmMessage.DiscardUnknown(m)
}

var xxx_messageInfo_AlarmMessage proto.InternalMessageInfo

func (m *AlarmMessage) GetDevId() string {
    if m != nil {
        return m.DevId
    }
    return ""
}

func (m *AlarmInfo) GetTime() string {
func (m *AlarmMessage) GetTime() string {
    if m != nil {
        return m.Time
    }
    return ""
}

func (m *AlarmInfo) GetAlarmVal() float32 {
func (m *AlarmMessage) GetAlarmInfo() []*AlarmInfo {
    if m != nil {
        return m.AlarmVal
    }
    return 0
}

func (m *AlarmInfo) GetSetVal() float32 {
    if m != nil {
        return m.SetVal
    }
    return 0
}

func (m *AlarmInfo) GetFacePos() *Rect {
    if m != nil {
        return m.FacePos
        return m.AlarmInfo
    }
    return nil
}

func (m *AlarmInfo) GetImage() *Image {
func (m *AlarmMessage) GetData() []byte {
    if m != nil {
        return m.Image
    }
    return nil
}

type AlarmRuleMessage struct {
    Taskid               string     `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
    Taskname             string     `protobuf:"bytes,2,opt,name=taskname,proto3" json:"taskname,omitempty"`
    Alarminfo            *AlarmInfo `protobuf:"bytes,3,opt,name=alarminfo,proto3" json:"alarminfo,omitempty"`
    XXX_NoUnkeyedLiteral struct{}   `json:"-"`
    XXX_unrecognized     []byte     `json:"-"`
    XXX_sizecache        int32      `json:"-"`
}

func (m *AlarmRuleMessage) Reset()         { *m = AlarmRuleMessage{} }
func (m *AlarmRuleMessage) String() string { return proto.CompactTextString(m) }
func (*AlarmRuleMessage) ProtoMessage()    {}
func (*AlarmRuleMessage) Descriptor() ([]byte, []int) {
    return fileDescriptor_4a4142572412ce8e, []int{1}
}
func (m *AlarmRuleMessage) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_AlarmRuleMessage.Unmarshal(m, b)
}
func (m *AlarmRuleMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_AlarmRuleMessage.Marshal(b, m, deterministic)
}
func (m *AlarmRuleMessage) XXX_Merge(src proto.Message) {
    xxx_messageInfo_AlarmRuleMessage.Merge(m, src)
}
func (m *AlarmRuleMessage) XXX_Size() int {
    return xxx_messageInfo_AlarmRuleMessage.Size(m)
}
func (m *AlarmRuleMessage) XXX_DiscardUnknown() {
    xxx_messageInfo_AlarmRuleMessage.DiscardUnknown(m)
}

var xxx_messageInfo_AlarmRuleMessage proto.InternalMessageInfo

func (m *AlarmRuleMessage) GetTaskid() string {
    if m != nil {
        return m.Taskid
    }
    return ""
}

func (m *AlarmRuleMessage) GetTaskname() string {
    if m != nil {
        return m.Taskname
    }
    return ""
}

func (m *AlarmRuleMessage) GetAlarminfo() *AlarmInfo {
    if m != nil {
        return m.Alarminfo
        return m.Data
    }
    return nil
}

func init() {
    proto.RegisterType((*FaceTempInfo)(nil), "protomsg.FaceTempInfo")
    proto.RegisterType((*AlarmInfo)(nil), "protomsg.AlarmInfo")
    proto.RegisterType((*AlarmRuleMessage)(nil), "protomsg.AlarmRuleMessage")
    proto.RegisterType((*AlarmMessage)(nil), "protomsg.AlarmMessage")
}

func init() { proto.RegisterFile("alarm.proto", fileDescriptor_4a4142572412ce8e) }

var fileDescriptor_4a4142572412ce8e = []byte{
    // 253 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x44, 0x50, 0x5d, 0x6b, 0x83, 0x30,
    0x14, 0x25, 0x5d, 0xb5, 0xf5, 0x0a, 0xdb, 0xc8, 0xc6, 0x08, 0x3e, 0x49, 0x61, 0xe0, 0x93, 0xb0,
    0xee, 0x17, 0xec, 0xd1, 0x87, 0xc1, 0xc8, 0xc3, 0xde, 0xd3, 0x7a, 0x95, 0x50, 0x63, 0x4a, 0x93,
    0x0d, 0xfa, 0x27, 0xf7, 0x9b, 0x46, 0xae, 0xa9, 0x3e, 0x79, 0xcf, 0x87, 0x9c, 0x73, 0x02, 0xb9,
    0x1a, 0xd4, 0xc5, 0xd4, 0xe7, 0x8b, 0xf5, 0x96, 0x6f, 0xe9, 0x63, 0x5c, 0x5f, 0xc0, 0x41, 0x39,
    0x9c, 0xd8, 0x22, 0x73, 0xed, 0x69, 0x3a, 0x77, 0x7f, 0x0c, 0xb2, 0x8f, 0xf0, 0x43, 0x33, 0x76,
    0x96, 0x73, 0x58, 0xfb, 0xeb, 0x19, 0x05, 0x2b, 0x59, 0x95, 0x49, 0xba, 0xf9, 0x33, 0x24, 0x2d,
    0xfe, 0x36, 0xad, 0x58, 0x11, 0x39, 0x01, 0x72, 0x6a, 0x83, 0xe2, 0x2e, 0x3a, 0xb5, 0x41, 0x5e,
    0xc0, 0x96, 0xb2, 0xbf, 0xd5, 0x20, 0xd6, 0x25, 0xab, 0x56, 0x72, 0xc6, 0xfc, 0x05, 0x52, 0x87,
    0x3e, 0x28, 0x09, 0x29, 0x11, 0xf1, 0x0a, 0x36, 0x9d, 0x3a, 0xe2, 0x97, 0x75, 0x22, 0x2d, 0x59,
    0x95, 0xef, 0xef, 0xeb, 0x5b, 0xe5, 0x5a, 0xe2, 0xd1, 0xcb, 0x9b, 0xcc, 0x5f, 0x21, 0xd1, 0x46,
    0xf5, 0x28, 0x36, 0xe4, 0x7b, 0x58, 0x7c, 0x4d, 0xa0, 0xe5, 0xa4, 0xee, 0xae, 0xf0, 0x48, 0x7b,
    0xe4, 0xcf, 0x80, 0x9f, 0xe8, 0x9c, 0xea, 0x31, 0x84, 0x7b, 0xe5, 0x4e, 0xba, 0x8d, 0xc3, 0x22,
    0x0a, 0x85, 0xc3, 0x35, 0x2a, 0x83, 0x71, 0xdd, 0x8c, 0xf9, 0x1b, 0x64, 0x54, 0x5e, 0x8f, 0x9d,
    0xa5, 0x95, 0xf9, 0xfe, 0x69, 0x89, 0x9c, 0x9f, 0x4c, 0x2e, 0xae, 0x43, 0x4a, 0xf2, 0xfb, 0x7f,
    0x00, 0x00, 0x00, 0xff, 0xff, 0x3f, 0xc6, 0x49, 0x95, 0x82, 0x01, 0x00, 0x00,
    // 227 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x44, 0x8e, 0x4f, 0x6b, 0x84, 0x30,
    0x10, 0xc5, 0x71, 0xdd, 0x6e, 0xd7, 0x51, 0x7a, 0x48, 0x4b, 0x91, 0x3d, 0x89, 0xa7, 0x9c, 0x84,
    0xee, 0x7e, 0x82, 0x5e, 0x0a, 0x1e, 0x0a, 0x25, 0x94, 0xde, 0x47, 0x1d, 0x45, 0x30, 0x8d, 0x98,
    0x50, 0xe8, 0xa9, 0x5f, 0xbd, 0x64, 0xfc, 0x77, 0xca, 0xcc, 0xbc, 0xbc, 0xf7, 0x7b, 0x10, 0xe3,
    0x80, 0x93, 0x2e, 0xc6, 0xc9, 0x38, 0x23, 0xce, 0xfc, 0x68, 0xdb, 0x5d, 0xa0, 0x42, 0x4b, 0xf3,
    0x35, 0x1f, 0x20, 0x79, 0xc3, 0x9a, 0x3e, 0x49, 0x8f, 0xe5, 0x77, 0x6b, 0xc4, 0x05, 0xce, 0x6c,
    0xfa, 0xc2, 0x21, 0x0d, 0xb2, 0x40, 0x1e, 0xd4, 0xb6, 0x8b, 0x67, 0x38, 0x59, 0x72, 0x5e, 0x39,
    0xb0, 0xb2, 0x6c, 0x42, 0xc2, 0x7d, 0x8b, 0x35, 0x7d, 0x18, 0x9b, 0x86, 0x59, 0x20, 0xe3, 0xeb,
    0x43, 0xb1, 0xb2, 0x0a, 0x45, 0xb5, 0x53, 0xab, 0x9c, 0xdf, 0x20, 0x7a, 0xf5, 0x69, 0x8c, 0x12,
    0x70, 0x74, 0xbf, 0x23, 0x31, 0x26, 0x52, 0x3c, 0xfb, 0x5b, 0x83, 0x0e, 0x19, 0x90, 0x28, 0x9e,
    0xf3, 0x3f, 0x48, 0xd8, 0xf4, 0x4e, 0xd6, 0x62, 0x47, 0xe2, 0x09, 0xee, 0x1a, 0xfa, 0x29, 0x9b,
    0xc5, 0x38, 0x2f, 0x9c, 0xd6, 0x6b, 0x62, 0xa7, 0x4f, 0xeb, 0x35, 0x89, 0x17, 0x88, 0x70, 0xc5,
    0xa5, 0x61, 0x16, 0xca, 0xf8, 0xfa, 0xb8, 0x57, 0xdb, 0x9a, 0xa8, 0xfd, 0xd7, 0x56, 0xe0, 0xb8,
    0x17, 0xa8, 0x4e, 0x6c, 0xb9, 0xfd, 0x07, 0x00, 0x00, 0xff, 0xff, 0x08, 0xd2, 0x1d, 0x4f, 0x4f,
    0x01, 0x00, 0x00,
}

 alarm.proto

@@ -1,22 +1,23 @@
syntax = "proto3";

import "base.proto";
import "sdk.proto";

package protomsg;

message AlarmInfo {
    string type = 1;
    string devId = 2;
    string time = 3;
    float alarmVal = 4;
    float setVal = 5;
    Rect facePos = 6;
    Image image = 7;
message FaceTempInfo {
    float alarmVal = 1;
    float setVal = 2;
    Rect facePos = 3;
}

message AlarmRuleMessage {
    string taskid = 1;
    string taskname = 2;
    AlarmInfo alarminfo = 3;
message AlarmInfo {
    string type = 1;
    bytes data = 2;
}

message AlarmMessage {
    string devId = 1;
    string time = 2;
    repeated AlarmInfo alarmInfo = 3;
    bytes data = 4;
}

 commsg.pb.go

@@ -6,9 +6,7 @@
import (
    fmt "fmt"
    proto "github.com/gogo/protobuf/proto"
    io "io"
    math "math"
    math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
@@ -23,9 +21,12 @@
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type SdkmsgWithTask struct {
    Ipcid   string `protobuf:"bytes,1,opt,name=ipcid,proto3" json:"ipcid,omitempty"`
    Sdktype string `protobuf:"bytes,2,opt,name=sdktype,proto3" json:"sdktype,omitempty"`
    Sdkdata []byte `protobuf:"bytes,4,opt,name=sdkdata,proto3" json:"sdkdata,omitempty"`
    Ipcid                string   `protobuf:"bytes,1,opt,name=ipcid,proto3" json:"ipcid,omitempty"`
    Sdktype              string   `protobuf:"bytes,2,opt,name=sdktype,proto3" json:"sdktype,omitempty"`
    Sdkdata              []byte   `protobuf:"bytes,4,opt,name=sdkdata,proto3" json:"sdkdata,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *SdkmsgWithTask) Reset()         { *m = SdkmsgWithTask{} }
@@ -35,25 +36,16 @@
    return fileDescriptor_968fba5e415d8aac, []int{0}
}
func (m *SdkmsgWithTask) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
    return xxx_messageInfo_SdkmsgWithTask.Unmarshal(m, b)
}
func (m *SdkmsgWithTask) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_SdkmsgWithTask.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
    return xxx_messageInfo_SdkmsgWithTask.Marshal(b, m, deterministic)
}
func (m *SdkmsgWithTask) XXX_Merge(src proto.Message) {
    xxx_messageInfo_SdkmsgWithTask.Merge(m, src)
}
func (m *SdkmsgWithTask) XXX_Size() int {
    return m.Size()
    return xxx_messageInfo_SdkmsgWithTask.Size(m)
}
func (m *SdkmsgWithTask) XXX_DiscardUnknown() {
    xxx_messageInfo_SdkmsgWithTask.DiscardUnknown(m)
@@ -83,10 +75,13 @@
}

type TaskLabel struct {
    Taskid   string            `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
    Taskname string            `protobuf:"bytes,2,opt,name=taskname,proto3" json:"taskname,omitempty"`
    Sdkinfos []*SdkmsgWithTask `protobuf:"bytes,3,rep,name=sdkinfos,proto3" json:"sdkinfos,omitempty"`
    Index    int32             `protobuf:"varint,4,opt,name=index,proto3" json:"index,omitempty"`
    Taskid               string            `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
    Taskname             string            `protobuf:"bytes,2,opt,name=taskname,proto3" json:"taskname,omitempty"`
    Sdkinfos             []*SdkmsgWithTask `protobuf:"bytes,3,rep,name=sdkinfos,proto3" json:"sdkinfos,omitempty"`
    Index                int32             `protobuf:"varint,4,opt,name=index,proto3" json:"index,omitempty"`
    XXX_NoUnkeyedLiteral struct{}          `json:"-"`
    XXX_unrecognized     []byte            `json:"-"`
    XXX_sizecache        int32             `json:"-"`
}

func (m *TaskLabel) Reset()         { *m = TaskLabel{} }
@@ -96,25 +91,16 @@
    return fileDescriptor_968fba5e415d8aac, []int{1}
}
func (m *TaskLabel) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
    return xxx_messageInfo_TaskLabel.Unmarshal(m, b)
}
func (m *TaskLabel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_TaskLabel.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
    return xxx_messageInfo_TaskLabel.Marshal(b, m, deterministic)
}
func (m *TaskLabel) XXX_Merge(src proto.Message) {
    xxx_messageInfo_TaskLabel.Merge(m, src)
}
func (m *TaskLabel) XXX_Size() int {
    return m.Size()
    return xxx_messageInfo_TaskLabel.Size(m)
}
func (m *TaskLabel) XXX_DiscardUnknown() {
    xxx_messageInfo_TaskLabel.DiscardUnknown(m)
@@ -151,11 +137,14 @@
}

type SdkMessage struct {
    Cid     string      `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
    Caddr   string      `protobuf:"bytes,2,opt,name=caddr,proto3" json:"caddr,omitempty"`
    Tasklab *TaskLabel  `protobuf:"bytes,3,opt,name=tasklab,proto3" json:"tasklab,omitempty"`
    Data    []byte      `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
    Push    *PushAttach `protobuf:"bytes,5,opt,name=push,proto3" json:"push,omitempty"`
    Cid                  string      `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
    Caddr                string      `protobuf:"bytes,2,opt,name=caddr,proto3" json:"caddr,omitempty"`
    Tasklab              *TaskLabel  `protobuf:"bytes,3,opt,name=tasklab,proto3" json:"tasklab,omitempty"`
    Data                 []byte      `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
    Push                 *PushAttach `protobuf:"bytes,5,opt,name=push,proto3" json:"push,omitempty"`
    XXX_NoUnkeyedLiteral struct{}    `json:"-"`
    XXX_unrecognized     []byte      `json:"-"`
    XXX_sizecache        int32       `json:"-"`
}

func (m *SdkMessage) Reset()         { *m = SdkMessage{} }
@@ -165,25 +154,16 @@
    return fileDescriptor_968fba5e415d8aac, []int{2}
}
func (m *SdkMessage) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
    return xxx_messageInfo_SdkMessage.Unmarshal(m, b)
}
func (m *SdkMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_SdkMessage.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
    return xxx_messageInfo_SdkMessage.Marshal(b, m, deterministic)
}
func (m *SdkMessage) XXX_Merge(src proto.Message) {
    xxx_messageInfo_SdkMessage.Merge(m, src)
}
func (m *SdkMessage) XXX_Size() int {
    return m.Size()
    return xxx_messageInfo_SdkMessage.Size(m)
}
func (m *SdkMessage) XXX_DiscardUnknown() {
    xxx_messageInfo_SdkMessage.DiscardUnknown(m)
@@ -227,9 +207,12 @@
}

type Recvmsg struct {
    Id      string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
    Addr    string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
    Picdata []byte `protobuf:"bytes,3,opt,name=picdata,proto3" json:"picdata,omitempty"`
    Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
    Addr                 string   `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
    Picdata              []byte   `protobuf:"bytes,3,opt,name=picdata,proto3" json:"picdata,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *Recvmsg) Reset()         { *m = Recvmsg{} }
@@ -239,25 +222,16 @@
    return fileDescriptor_968fba5e415d8aac, []int{3}
}
func (m *Recvmsg) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
    return xxx_messageInfo_Recvmsg.Unmarshal(m, b)
}
func (m *Recvmsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_Recvmsg.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
    return xxx_messageInfo_Recvmsg.Marshal(b, m, deterministic)
}
func (m *Recvmsg) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Recvmsg.Merge(m, src)
}
func (m *Recvmsg) XXX_Size() int {
    return m.Size()
    return xxx_messageInfo_Recvmsg.Size(m)
}
func (m *Recvmsg) XXX_DiscardUnknown() {
    xxx_messageInfo_Recvmsg.DiscardUnknown(m)
@@ -287,9 +261,14 @@
}

type RuleMessage struct {
    Taskid   string      `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
    Taskname string      `protobuf:"bytes,2,opt,name=taskname,proto3" json:"taskname,omitempty"`
    Sdkmsg   *SdkMessage `protobuf:"bytes,3,opt,name=sdkmsg,proto3" json:"sdkmsg,omitempty"`
    Taskid               string        `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
    Taskname             string        `protobuf:"bytes,2,opt,name=taskname,proto3" json:"taskname,omitempty"`
    Msgtype              string        `protobuf:"bytes,3,opt,name=msgtype,proto3" json:"msgtype,omitempty"`
    Sdkmsg               *SdkMessage   `protobuf:"bytes,4,opt,name=sdkmsg,proto3" json:"sdkmsg,omitempty"`
    Alarmmsg             *AlarmMessage `protobuf:"bytes,5,opt,name=alarmmsg,proto3" json:"alarmmsg,omitempty"`
    XXX_NoUnkeyedLiteral struct{}      `json:"-"`
    XXX_unrecognized     []byte        `json:"-"`
    XXX_sizecache        int32         `json:"-"`
}

func (m *RuleMessage) Reset()         { *m = RuleMessage{} }
@@ -299,25 +278,16 @@
    return fileDescriptor_968fba5e415d8aac, []int{4}
}
func (m *RuleMessage) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
    return xxx_messageInfo_RuleMessage.Unmarshal(m, b)
}
func (m *RuleMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_RuleMessage.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
    return xxx_messageInfo_RuleMessage.Marshal(b, m, deterministic)
}
func (m *RuleMessage) XXX_Merge(src proto.Message) {
    xxx_messageInfo_RuleMessage.Merge(m, src)
}
func (m *RuleMessage) XXX_Size() int {
    return m.Size()
    return xxx_messageInfo_RuleMessage.Size(m)
}
func (m *RuleMessage) XXX_DiscardUnknown() {
    xxx_messageInfo_RuleMessage.DiscardUnknown(m)
@@ -339,9 +309,23 @@
    return ""
}

func (m *RuleMessage) GetMsgtype() string {
    if m != nil {
        return m.Msgtype
    }
    return ""
}

func (m *RuleMessage) GetSdkmsg() *SdkMessage {
    if m != nil {
        return m.Sdkmsg
    }
    return nil
}

func (m *RuleMessage) GetAlarmmsg() *AlarmMessage {
    if m != nil {
        return m.Alarmmsg
    }
    return nil
}
@@ -357,1336 +341,29 @@
func init() { proto.RegisterFile("commsg.proto", fileDescriptor_968fba5e415d8aac) }

var fileDescriptor_968fba5e415d8aac = []byte{
    // 374 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x50, 0x3d, 0x4e, 0xf3, 0x40,
    0x14, 0xcc, 0xc6, 0xf9, 0x7d, 0x89, 0xa2, 0x4f, 0xfb, 0x45, 0x9f, 0x56, 0x29, 0x2c, 0xcb, 0x95,
    0x8b, 0x8f, 0x14, 0x81, 0x0b, 0x40, 0x43, 0x03, 0x12, 0xda, 0x20, 0x21, 0xd1, 0x6d, 0xbc, 0xc6,
    0xb6, 0x1c, 0xc7, 0x56, 0x9e, 0x83, 0xe0, 0x0c, 0x34, 0x5c, 0x81, 0xdb, 0x50, 0xa6, 0xa4, 0x44,
    0xc9, 0x45, 0xd0, 0xae, 0xd7, 0x4e, 0xd2, 0x52, 0x79, 0xc6, 0xef, 0xbd, 0xd9, 0x99, 0x81, 0xa1,
    0x9f, 0xa5, 0x29, 0x86, 0xd3, 0x7c, 0x9d, 0x15, 0x19, 0xed, 0xe9, 0x4f, 0x8a, 0xe1, 0x64, 0x54,
    0xa1, 0x72, 0xe2, 0x3e, 0xc2, 0x68, 0x2e, 0x93, 0x14, 0xc3, 0x87, 0xb8, 0x88, 0xee, 0x05, 0x26,
    0x74, 0x0c, 0xed, 0x38, 0xf7, 0x63, 0xc9, 0x88, 0x43, 0xbc, 0x3e, 0x2f, 0x09, 0x65, 0xd0, 0x45,
    0x99, 0x14, 0xaf, 0x79, 0xc0, 0x9a, 0xfa, 0x7f, 0x45, 0xcd, 0x44, 0x8a, 0x42, 0xb0, 0x96, 0x43,
    0xbc, 0x21, 0xaf, 0xa8, 0xfb, 0x46, 0xa0, 0xaf, 0x24, 0x6f, 0xc4, 0x22, 0x58, 0xd2, 0x7f, 0xd0,
    0x29, 0x04, 0x26, 0xb5, 0xb0, 0x61, 0x74, 0x02, 0x3d, 0x85, 0x56, 0x22, 0xad, 0xa4, 0x6b, 0x4e,
    0x2f, 0xa0, 0x87, 0x32, 0x89, 0x57, 0x4f, 0x19, 0x32, 0xcb, 0xb1, 0xbc, 0xc1, 0x8c, 0x4d, 0xeb,
    0x00, 0xa7, 0xbe, 0x79, 0xbd, 0xa9, 0x13, 0xac, 0x64, 0xf0, 0xa2, 0xfd, 0xb4, 0x79, 0x49, 0xdc,
    0x0f, 0x02, 0x30, 0x97, 0xc9, 0x6d, 0x80, 0x28, 0xc2, 0x80, 0xfe, 0x01, 0xeb, 0x10, 0x52, 0x41,
    0x75, 0xe6, 0x0b, 0x29, 0xd7, 0xc6, 0x45, 0x49, 0xe8, 0x19, 0x74, 0x95, 0x9d, 0xa5, 0x58, 0x30,
    0xcb, 0x21, 0xde, 0x60, 0xf6, 0xf7, 0xe0, 0xa0, 0x0e, 0xc7, 0xab, 0x1d, 0x4a, 0xa1, 0x75, 0x54,
    0x85, 0xc6, 0xd4, 0x83, 0x56, 0xbe, 0xc1, 0x88, 0xb5, 0xf5, 0xfd, 0xf8, 0x70, 0x7f, 0xb7, 0xc1,
    0xe8, 0xb2, 0x28, 0x84, 0x1f, 0x71, 0xbd, 0xe1, 0x5e, 0x43, 0x77, 0x1d, 0xf8, 0xcf, 0x29, 0x86,
    0x74, 0x04, 0xcd, 0xda, 0x5e, 0x33, 0x96, 0x4a, 0xf8, 0xc8, 0x9c, 0xc6, 0xaa, 0xfa, 0x3c, 0xf6,
    0xf5, 0x7b, 0x56, 0x59, 0xbd, 0xa1, 0x6e, 0x06, 0x03, 0xbe, 0x59, 0x06, 0x55, 0xd8, 0xdf, 0x74,
    0xff, 0x1f, 0x3a, 0xa8, 0x1b, 0x36, 0xb9, 0xc7, 0x27, 0xcd, 0x1b, 0x65, 0x6e, 0x76, 0xae, 0xd8,
    0xe7, 0xce, 0x26, 0xdb, 0x9d, 0x4d, 0xbe, 0x77, 0x36, 0x79, 0xdf, 0xdb, 0x8d, 0xed, 0xde, 0x6e,
    0x7c, 0xed, 0xed, 0xc6, 0xa2, 0xa3, 0xcf, 0xce, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x56, 0x3f,
    0xf7, 0xf6, 0x92, 0x02, 0x00, 0x00,
    // 376 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x52, 0xcd, 0x4e, 0x83, 0x40,
    0x18, 0x0c, 0xa5, 0x2d, 0xf4, 0xa3, 0x69, 0xcc, 0xda, 0x34, 0x9b, 0x9e, 0x08, 0x27, 0x0e, 0xda,
    0x43, 0xf5, 0x05, 0x7a, 0xf2, 0xa2, 0x89, 0xd9, 0x9a, 0x98, 0x78, 0xdb, 0xb2, 0x08, 0x04, 0xb6,
    0x10, 0x3e, 0x6a, 0xf4, 0x19, 0x7c, 0x0a, 0x1f, 0xc4, 0x77, 0x33, 0xbb, 0xcb, 0x4f, 0x7b, 0xf5,
    0xc4, 0x0c, 0x3b, 0xdf, 0xc7, 0xcc, 0x2c, 0x30, 0x8f, 0x4a, 0x29, 0x31, 0xd9, 0x54, 0x75, 0xd9,
    0x94, 0xc4, 0xd5, 0x0f, 0x89, 0xc9, 0x7a, 0xd1, 0x21, 0x73, 0xb2, 0xf6, 0x78, 0xc1, 0x6b, 0x69,
    0x48, 0xf0, 0x06, 0x8b, 0xbd, 0xc8, 0x25, 0x26, 0xaf, 0x59, 0x93, 0xbe, 0x70, 0xcc, 0xc9, 0x12,
    0x26, 0x59, 0x15, 0x65, 0x82, 0x5a, 0xbe, 0x15, 0xce, 0x98, 0x21, 0x84, 0x82, 0x83, 0x22, 0x6f,
    0xbe, 0xaa, 0x98, 0x8e, 0xf4, 0xfb, 0x8e, 0xb6, 0x27, 0x82, 0x37, 0x9c, 0x8e, 0x7d, 0x2b, 0x9c,
    0xb3, 0x8e, 0x06, 0xdf, 0x16, 0xcc, 0xd4, 0xca, 0x47, 0x7e, 0x88, 0x0b, 0xb2, 0x82, 0x69, 0xc3,
    0x31, 0xef, 0x17, 0xb7, 0x8c, 0xac, 0xc1, 0x55, 0xe8, 0xc8, 0x65, 0xb7, 0xba, 0xe7, 0xe4, 0x1e,
    0x5c, 0x14, 0x79, 0x76, 0x7c, 0x2f, 0x91, 0xda, 0xbe, 0x1d, 0x7a, 0x5b, 0xba, 0xe9, 0xd3, 0x5c,
    0xfa, 0x66, 0xbd, 0x52, 0x27, 0x38, 0x8a, 0xf8, 0x53, 0xfb, 0x99, 0x30, 0x43, 0x82, 0x1f, 0x0b,
    0x60, 0x2f, 0xf2, 0xa7, 0x18, 0x91, 0x27, 0x31, 0xb9, 0x02, 0x7b, 0x08, 0xa9, 0xa0, 0x1a, 0x8b,
    0xb8, 0x10, 0x75, 0xeb, 0xc2, 0x10, 0x72, 0x0b, 0x8e, 0xb2, 0x53, 0xf0, 0x03, 0xb5, 0x7d, 0x2b,
    0xf4, 0xb6, 0xd7, 0x83, 0x83, 0x3e, 0x1c, 0xeb, 0x34, 0x84, 0xc0, 0xf8, 0xac, 0x0a, 0x8d, 0x49,
    0x08, 0xe3, 0xea, 0x84, 0x29, 0x9d, 0xe8, 0xf9, 0xe5, 0x30, 0xff, 0x7c, 0xc2, 0x74, 0xd7, 0x34,
    0x3c, 0x4a, 0x99, 0x56, 0x04, 0x0f, 0xe0, 0xd4, 0x71, 0xf4, 0x21, 0x31, 0x21, 0x0b, 0x18, 0xf5,
    0xf6, 0x46, 0x99, 0x50, 0x8b, 0xcf, 0xcc, 0x69, 0xac, 0xaa, 0xaf, 0xb2, 0x48, 0x7f, 0xcf, 0x36,
    0xd5, 0xb7, 0x34, 0xf8, 0xb5, 0xc0, 0x63, 0xa7, 0x22, 0xee, 0xd2, 0xfe, 0xa7, 0x7c, 0x0a, 0x8e,
    0xc4, 0x44, 0x5f, 0xb9, 0x6d, 0xae, 0xbc, 0xa5, 0xe4, 0x06, 0xa6, 0xa8, 0xcb, 0xd7, 0x31, 0x2f,
    0x22, 0x0d, 0x0d, 0xb3, 0x56, 0x43, 0xb6, 0xe0, 0xea, 0x3f, 0x4e, 0xe9, 0x4d, 0x05, 0xab, 0x41,
    0xbf, 0x53, 0x27, 0xdd, 0x44, 0xaf, 0x3b, 0x4c, 0xb5, 0xe0, 0xee, 0x2f, 0x00, 0x00, 0xff, 0xff,
    0xc8, 0xc5, 0x13, 0x57, 0xd4, 0x02, 0x00, 0x00,
}

func (m *SdkmsgWithTask) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *SdkmsgWithTask) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Ipcid) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Ipcid)))
        i += copy(dAtA[i:], m.Ipcid)
    }
    if len(m.Sdktype) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Sdktype)))
        i += copy(dAtA[i:], m.Sdktype)
    }
    if len(m.Sdkdata) > 0 {
        dAtA[i] = 0x22
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Sdkdata)))
        i += copy(dAtA[i:], m.Sdkdata)
    }
    return i, nil
}

func (m *TaskLabel) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *TaskLabel) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Taskid) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Taskid)))
        i += copy(dAtA[i:], m.Taskid)
    }
    if len(m.Taskname) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Taskname)))
        i += copy(dAtA[i:], m.Taskname)
    }
    if len(m.Sdkinfos) > 0 {
        for _, msg := range m.Sdkinfos {
            dAtA[i] = 0x1a
            i++
            i = encodeVarintCommsg(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i += n
        }
    }
    if m.Index != 0 {
        dAtA[i] = 0x20
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(m.Index))
    }
    return i, nil
}

func (m *SdkMessage) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *SdkMessage) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Cid) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Cid)))
        i += copy(dAtA[i:], m.Cid)
    }
    if len(m.Caddr) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Caddr)))
        i += copy(dAtA[i:], m.Caddr)
    }
    if m.Tasklab != nil {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(m.Tasklab.Size()))
        n1, err1 := m.Tasklab.MarshalTo(dAtA[i:])
        if err1 != nil {
            return 0, err1
        }
        i += n1
    }
    if len(m.Data) > 0 {
        dAtA[i] = 0x22
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Data)))
        i += copy(dAtA[i:], m.Data)
    }
    if m.Push != nil {
        dAtA[i] = 0x2a
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(m.Push.Size()))
        n2, err2 := m.Push.MarshalTo(dAtA[i:])
        if err2 != nil {
            return 0, err2
        }
        i += n2
    }
    return i, nil
}

func (m *Recvmsg) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *Recvmsg) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Id) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Id)))
        i += copy(dAtA[i:], m.Id)
    }
    if len(m.Addr) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Addr)))
        i += copy(dAtA[i:], m.Addr)
    }
    if len(m.Picdata) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Picdata)))
        i += copy(dAtA[i:], m.Picdata)
    }
    return i, nil
}

func (m *RuleMessage) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *RuleMessage) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Taskid) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Taskid)))
        i += copy(dAtA[i:], m.Taskid)
    }
    if len(m.Taskname) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Taskname)))
        i += copy(dAtA[i:], m.Taskname)
    }
    if m.Sdkmsg != nil {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(m.Sdkmsg.Size()))
        n3, err3 := m.Sdkmsg.MarshalTo(dAtA[i:])
        if err3 != nil {
            return 0, err3
        }
        i += n3
    }
    return i, nil
}

func encodeVarintCommsg(dAtA []byte, offset int, v uint64) int {
    for v >= 1<<7 {
        dAtA[offset] = uint8(v&0x7f | 0x80)
        v >>= 7
        offset++
    }
    dAtA[offset] = uint8(v)
    return offset + 1
}
func (m *SdkmsgWithTask) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.Ipcid)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    l = len(m.Sdktype)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    l = len(m.Sdkdata)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    return n
}

func (m *TaskLabel) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.Taskid)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    l = len(m.Taskname)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    if len(m.Sdkinfos) > 0 {
        for _, e := range m.Sdkinfos {
            l = e.Size()
            n += 1 + l + sovCommsg(uint64(l))
        }
    }
    if m.Index != 0 {
        n += 1 + sovCommsg(uint64(m.Index))
    }
    return n
}

func (m *SdkMessage) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.Cid)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    l = len(m.Caddr)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    if m.Tasklab != nil {
        l = m.Tasklab.Size()
        n += 1 + l + sovCommsg(uint64(l))
    }
    l = len(m.Data)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    if m.Push != nil {
        l = m.Push.Size()
        n += 1 + l + sovCommsg(uint64(l))
    }
    return n
}

func (m *Recvmsg) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.Id)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    l = len(m.Addr)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    l = len(m.Picdata)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    return n
}

func (m *RuleMessage) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.Taskid)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    l = len(m.Taskname)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    if m.Sdkmsg != nil {
        l = m.Sdkmsg.Size()
        n += 1 + l + sovCommsg(uint64(l))
    }
    return n
}

func sovCommsg(x uint64) (n int) {
    return (math_bits.Len64(x|1) + 6) / 7
}
func sozCommsg(x uint64) (n int) {
    return sovCommsg(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *SdkmsgWithTask) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: SdkmsgWithTask: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: SdkmsgWithTask: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Ipcid", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Ipcid = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Sdktype", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Sdktype = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Sdkdata", wireType)
            }
            var byteLen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Sdkdata = append(m.Sdkdata[:0], dAtA[iNdEx:postIndex]...)
            if m.Sdkdata == nil {
                m.Sdkdata = []byte{}
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipCommsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthCommsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthCommsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *TaskLabel) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: TaskLabel: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: TaskLabel: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Taskid", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Taskid = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Taskname", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Taskname = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Sdkinfos", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Sdkinfos = append(m.Sdkinfos, &SdkmsgWithTask{})
            if err := m.Sdkinfos[len(m.Sdkinfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 4:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
            }
            m.Index = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Index |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipCommsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthCommsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthCommsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *SdkMessage) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: SdkMessage: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: SdkMessage: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Cid", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Cid = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Caddr", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Caddr = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Tasklab", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.Tasklab == nil {
                m.Tasklab = &TaskLabel{}
            }
            if err := m.Tasklab.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
            }
            var byteLen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
            if m.Data == nil {
                m.Data = []byte{}
            }
            iNdEx = postIndex
        case 5:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Push", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.Push == nil {
                m.Push = &PushAttach{}
            }
            if err := m.Push.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipCommsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthCommsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthCommsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *Recvmsg) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: recvmsg: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: recvmsg: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Id = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Addr = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Picdata", wireType)
            }
            var byteLen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Picdata = append(m.Picdata[:0], dAtA[iNdEx:postIndex]...)
            if m.Picdata == nil {
                m.Picdata = []byte{}
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipCommsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthCommsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthCommsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *RuleMessage) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: RuleMessage: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: RuleMessage: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Taskid", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Taskid = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Taskname", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Taskname = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Sdkmsg", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.Sdkmsg == nil {
                m.Sdkmsg = &SdkMessage{}
            }
            if err := m.Sdkmsg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipCommsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthCommsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthCommsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func skipCommsg(dAtA []byte) (n int, err error) {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return 0, ErrIntOverflowCommsg
            }
            if iNdEx >= l {
                return 0, io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= (uint64(b) & 0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        wireType := int(wire & 0x7)
        switch wireType {
        case 0:
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return 0, ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return 0, io.ErrUnexpectedEOF
                }
                iNdEx++
                if dAtA[iNdEx-1] < 0x80 {
                    break
                }
            }
            return iNdEx, nil
        case 1:
            iNdEx += 8
            return iNdEx, nil
        case 2:
            var length int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return 0, ErrIntOverflowCommsg
                }
                if iNdEx >= l {
                    return 0, io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                length |= (int(b) & 0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if length < 0 {
                return 0, ErrInvalidLengthCommsg
            }
            iNdEx += length
            if iNdEx < 0 {
                return 0, ErrInvalidLengthCommsg
            }
            return iNdEx, nil
        case 3:
            for {
                var innerWire uint64
                var start int = iNdEx
                for shift := uint(0); ; shift += 7 {
                    if shift >= 64 {
                        return 0, ErrIntOverflowCommsg
                    }
                    if iNdEx >= l {
                        return 0, io.ErrUnexpectedEOF
                    }
                    b := dAtA[iNdEx]
                    iNdEx++
                    innerWire |= (uint64(b) & 0x7F) << shift
                    if b < 0x80 {
                        break
                    }
                }
                innerWireType := int(innerWire & 0x7)
                if innerWireType == 4 {
                    break
                }
                next, err := skipCommsg(dAtA[start:])
                if err != nil {
                    return 0, err
                }
                iNdEx = start + next
                if iNdEx < 0 {
                    return 0, ErrInvalidLengthCommsg
                }
            }
            return iNdEx, nil
        case 4:
            return iNdEx, nil
        case 5:
            iNdEx += 4
            return iNdEx, nil
        default:
            return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
        }
    }
    panic("unreachable")
}

var (
    ErrInvalidLengthCommsg = fmt.Errorf("proto: negative length found during unmarshaling")
    ErrIntOverflowCommsg   = fmt.Errorf("proto: integer overflow")
)

 commsg.proto

@@ -3,6 +3,7 @@
package protomsg;

import "protomsg.proto";
import "alarm.proto";

message SdkmsgWithTask {
    string ipcid = 1;
@@ -34,5 +35,7 @@
message RuleMessage {
    string taskid = 1;
    string taskname = 2;
    SdkMessage sdkmsg = 3;
    string msgtype = 3;
    SdkMessage sdkmsg = 4;
    AlarmMessage alarmmsg = 5;
}