更新dataprocess.proto解决编译问题

cheliequan

2023-02-10 a6e9a16da0fc1255ead73825fbc938b228d08ad2

更新dataprocess.proto解决编译问题

 dataprocess.pb.go

@@ -314,6 +314,93 @@
    return nil
}

type SoTarget struct {
    SrcTarget            *Target                `protobuf:"bytes,1,opt,name=SrcTarget,proto3" json:"SrcTarget,omitempty"`
    AreaId               string                 `protobuf:"bytes,2,opt,name=AreaId,proto3" json:"AreaId,omitempty"`
    AreaName             string                 `protobuf:"bytes,3,opt,name=AreaName,proto3" json:"AreaName,omitempty"`
    BelongsTargetID      string                 `protobuf:"bytes,4,opt,name=BelongsTargetID,proto3" json:"BelongsTargetID,omitempty"`
    CompDbInfo           []*RuleBaseCompareInfo `protobuf:"bytes,5,rep,name=CompDbInfo,proto3" json:"CompDbInfo,omitempty"`
    ImageId              int64                  `protobuf:"varint,6,opt,name=ImageId,proto3" json:"ImageId,omitempty"`
    XXX_NoUnkeyedLiteral struct{}               `json:"-"`
    XXX_unrecognized     []byte                 `json:"-"`
    XXX_sizecache        int32                  `json:"-"`
}

func (m *SoTarget) Reset()         { *m = SoTarget{} }
func (m *SoTarget) String() string { return proto.CompactTextString(m) }
func (*SoTarget) ProtoMessage()    {}
func (*SoTarget) Descriptor() ([]byte, []int) {
    return fileDescriptor_02f614a9207041cc, []int{3}
}
func (m *SoTarget) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *SoTarget) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_SoTarget.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *SoTarget) XXX_Merge(src proto.Message) {
    xxx_messageInfo_SoTarget.Merge(m, src)
}
func (m *SoTarget) XXX_Size() int {
    return m.Size()
}
func (m *SoTarget) XXX_DiscardUnknown() {
    xxx_messageInfo_SoTarget.DiscardUnknown(m)
}

var xxx_messageInfo_SoTarget proto.InternalMessageInfo

func (m *SoTarget) GetSrcTarget() *Target {
    if m != nil {
        return m.SrcTarget
    }
    return nil
}

func (m *SoTarget) GetAreaId() string {
    if m != nil {
        return m.AreaId
    }
    return ""
}

func (m *SoTarget) GetAreaName() string {
    if m != nil {
        return m.AreaName
    }
    return ""
}

func (m *SoTarget) GetBelongsTargetID() string {
    if m != nil {
        return m.BelongsTargetID
    }
    return ""
}

func (m *SoTarget) GetCompDbInfo() []*RuleBaseCompareInfo {
    if m != nil {
        return m.CompDbInfo
    }
    return nil
}

func (m *SoTarget) GetImageId() int64 {
    if m != nil {
        return m.ImageId
    }
    return 0
}

type SOResult struct {
    IsEvent              bool        `protobuf:"varint,1,opt,name=IsEvent,proto3" json:"IsEvent,omitempty"`
    IsEndRecord          bool        `protobuf:"varint,2,opt,name=IsEndRecord,proto3" json:"IsEndRecord,omitempty"`
@@ -332,7 +419,7 @@
func (m *SOResult) String() string { return proto.CompactTextString(m) }
func (*SOResult) ProtoMessage()    {}
func (*SOResult) Descriptor() ([]byte, []int) {
    return fileDescriptor_02f614a9207041cc, []int{3}
    return fileDescriptor_02f614a9207041cc, []int{4}
}
func (m *SOResult) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -415,93 +502,6 @@
        return m.SoType
    }
    return ""
}

type SoTarget struct {
    SrcTarget            *Target                `protobuf:"bytes,1,opt,name=SrcTarget,proto3" json:"SrcTarget,omitempty"`
    AreaId               string                 `protobuf:"bytes,2,opt,name=AreaId,proto3" json:"AreaId,omitempty"`
    AreaName             string                 `protobuf:"bytes,3,opt,name=AreaName,proto3" json:"AreaName,omitempty"`
    BelongsTargetID      string                 `protobuf:"bytes,4,opt,name=BelongsTargetID,proto3" json:"BelongsTargetID,omitempty"`
    CompDbInfo           []*RuleBaseCompareInfo `protobuf:"bytes,5,rep,name=CompDbInfo,proto3" json:"CompDbInfo,omitempty"`
    ImageId              int64                  `protobuf:"varint,6,opt,name=ImageId,proto3" json:"ImageId,omitempty"`
    XXX_NoUnkeyedLiteral struct{}               `json:"-"`
    XXX_unrecognized     []byte                 `json:"-"`
    XXX_sizecache        int32                  `json:"-"`
}

func (m *SoTarget) Reset()         { *m = SoTarget{} }
func (m *SoTarget) String() string { return proto.CompactTextString(m) }
func (*SoTarget) ProtoMessage()    {}
func (*SoTarget) Descriptor() ([]byte, []int) {
    return fileDescriptor_02f614a9207041cc, []int{4}
}
func (m *SoTarget) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *SoTarget) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_SoTarget.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *SoTarget) XXX_Merge(src proto.Message) {
    xxx_messageInfo_SoTarget.Merge(m, src)
}
func (m *SoTarget) XXX_Size() int {
    return m.Size()
}
func (m *SoTarget) XXX_DiscardUnknown() {
    xxx_messageInfo_SoTarget.DiscardUnknown(m)
}

var xxx_messageInfo_SoTarget proto.InternalMessageInfo

func (m *SoTarget) GetSrcTarget() *Target {
    if m != nil {
        return m.SrcTarget
    }
    return nil
}

func (m *SoTarget) GetAreaId() string {
    if m != nil {
        return m.AreaId
    }
    return ""
}

func (m *SoTarget) GetAreaName() string {
    if m != nil {
        return m.AreaName
    }
    return ""
}

func (m *SoTarget) GetBelongsTargetID() string {
    if m != nil {
        return m.BelongsTargetID
    }
    return ""
}

func (m *SoTarget) GetCompDbInfo() []*RuleBaseCompareInfo {
    if m != nil {
        return m.CompDbInfo
    }
    return nil
}

func (m *SoTarget) GetImageId() int64 {
    if m != nil {
        return m.ImageId
    }
    return 0
}

type EventCache struct {
@@ -697,8 +697,8 @@
    proto.RegisterType((*TaskBasicInfo)(nil), "protomsg.TaskBasicInfo")
    proto.RegisterType((*RuleParams)(nil), "protomsg.RuleParams")
    proto.RegisterType((*SoRule)(nil), "protomsg.SoRule")
    proto.RegisterType((*SOResult)(nil), "protomsg.SOResult")
    proto.RegisterType((*SoTarget)(nil), "protomsg.SoTarget")
    proto.RegisterType((*SOResult)(nil), "protomsg.SOResult")
    proto.RegisterType((*EventCache)(nil), "protomsg.EventCache")
    proto.RegisterMapType((map[int64]*Image)(nil), "protomsg.EventCache.ImagesEntry")
    proto.RegisterMapType((map[string]*GroupRule)(nil), "protomsg.EventCache.RuleGroupsEntry")
@@ -713,65 +713,65 @@
func init() { proto.RegisterFile("dataprocess.proto", fileDescriptor_02f614a9207041cc) }

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

func (m *TaskBasicInfo) Marshal() (dAtA []byte, err error) {
@@ -981,6 +981,72 @@
    return i, nil
}

func (m *SoTarget) 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 *SoTarget) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.SrcTarget != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.SrcTarget.Size()))
        n1, err1 := m.SrcTarget.MarshalTo(dAtA[i:])
        if err1 != nil {
            return 0, err1
        }
        i += n1
    }
    if len(m.AreaId) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaId)))
        i += copy(dAtA[i:], m.AreaId)
    }
    if len(m.AreaName) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaName)))
        i += copy(dAtA[i:], m.AreaName)
    }
    if len(m.BelongsTargetID) > 0 {
        dAtA[i] = 0x22
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.BelongsTargetID)))
        i += copy(dAtA[i:], m.BelongsTargetID)
    }
    if len(m.CompDbInfo) > 0 {
        for _, msg := range m.CompDbInfo {
            dAtA[i] = 0x2a
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i += n
        }
    }
    if m.ImageId != 0 {
        dAtA[i] = 0x30
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}

func (m *SOResult) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
@@ -1032,113 +1098,47 @@
        dAtA[i] = 0x22
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.FirstImage.Size()))
        n1, err1 := m.FirstImage.MarshalTo(dAtA[i:])
        if err1 != nil {
            return 0, err1
        }
        i += n1
    }
    if m.CacheImage != nil {
        dAtA[i] = 0x2a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.CacheImage.Size()))
        n2, err2 := m.CacheImage.MarshalTo(dAtA[i:])
        n2, err2 := m.FirstImage.MarshalTo(dAtA[i:])
        if err2 != nil {
            return 0, err2
        }
        i += n2
    }
    if m.SoRule != nil {
        dAtA[i] = 0x32
    if m.CacheImage != nil {
        dAtA[i] = 0x2a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.SoRule.Size()))
        n3, err3 := m.SoRule.MarshalTo(dAtA[i:])
        i = encodeVarintDataprocess(dAtA, i, uint64(m.CacheImage.Size()))
        n3, err3 := m.CacheImage.MarshalTo(dAtA[i:])
        if err3 != nil {
            return 0, err3
        }
        i += n3
    }
    if m.GroupRule != nil {
        dAtA[i] = 0x3a
    if m.SoRule != nil {
        dAtA[i] = 0x32
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.GroupRule.Size()))
        n4, err4 := m.GroupRule.MarshalTo(dAtA[i:])
        i = encodeVarintDataprocess(dAtA, i, uint64(m.SoRule.Size()))
        n4, err4 := m.SoRule.MarshalTo(dAtA[i:])
        if err4 != nil {
            return 0, err4
        }
        i += n4
    }
    if m.GroupRule != nil {
        dAtA[i] = 0x3a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.GroupRule.Size()))
        n5, err5 := m.GroupRule.MarshalTo(dAtA[i:])
        if err5 != nil {
            return 0, err5
        }
        i += n5
    }
    if len(m.SoType) > 0 {
        dAtA[i] = 0x42
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SoType)))
        i += copy(dAtA[i:], m.SoType)
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
    }
    return i, nil
}

func (m *SoTarget) 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 *SoTarget) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.SrcTarget != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.SrcTarget.Size()))
        n5, err5 := m.SrcTarget.MarshalTo(dAtA[i:])
        if err5 != nil {
            return 0, err5
        }
        i += n5
    }
    if len(m.AreaId) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaId)))
        i += copy(dAtA[i:], m.AreaId)
    }
    if len(m.AreaName) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaName)))
        i += copy(dAtA[i:], m.AreaName)
    }
    if len(m.BelongsTargetID) > 0 {
        dAtA[i] = 0x22
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(len(m.BelongsTargetID)))
        i += copy(dAtA[i:], m.BelongsTargetID)
    }
    if len(m.CompDbInfo) > 0 {
        for _, msg := range m.CompDbInfo {
            dAtA[i] = 0x2a
            i++
            i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i += n
        }
    }
    if m.ImageId != 0 {
        dAtA[i] = 0x30
        i++
        i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
    }
    if m.XXX_unrecognized != nil {
        i += copy(dAtA[i:], m.XXX_unrecognized)
@@ -1538,6 +1538,43 @@
    return n
}

func (m *SoTarget) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.SrcTarget != nil {
        l = m.SrcTarget.Size()
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.AreaId)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.AreaName)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.BelongsTargetID)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    if len(m.CompDbInfo) > 0 {
        for _, e := range m.CompDbInfo {
            l = e.Size()
            n += 1 + l + sovDataprocess(uint64(l))
        }
    }
    if m.ImageId != 0 {
        n += 1 + sovDataprocess(uint64(m.ImageId))
    }
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
    }
    return n
}

func (m *SOResult) Size() (n int) {
    if m == nil {
        return 0
@@ -1575,43 +1612,6 @@
    l = len(m.SoType)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
    }
    return n
}

func (m *SoTarget) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.SrcTarget != nil {
        l = m.SrcTarget.Size()
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.AreaId)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.AreaName)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    l = len(m.BelongsTargetID)
    if l > 0 {
        n += 1 + l + sovDataprocess(uint64(l))
    }
    if len(m.CompDbInfo) > 0 {
        for _, e := range m.CompDbInfo {
            l = e.Size()
            n += 1 + l + sovDataprocess(uint64(l))
        }
    }
    if m.ImageId != 0 {
        n += 1 + sovDataprocess(uint64(m.ImageId))
    }
    if m.XXX_unrecognized != nil {
        n += len(m.XXX_unrecognized)
@@ -2578,6 +2578,245 @@
    }
    return nil
}
func (m *SoTarget) 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 ErrIntOverflowDataprocess
            }
            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: SoTarget: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: SoTarget: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SrcTarget", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.SrcTarget == nil {
                m.SrcTarget = &Target{}
            }
            if err := m.SrcTarget.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field AreaId", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                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 ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.AreaId = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field AreaName", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                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 ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.AreaName = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field BelongsTargetID", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                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 ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.BelongsTargetID = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 5:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field CompDbInfo", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.CompDbInfo = append(m.CompDbInfo, &RuleBaseCompareInfo{})
            if err := m.CompDbInfo[len(m.CompDbInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 6:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field ImageId", wireType)
            }
            m.ImageId = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.ImageId |= int64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipDataprocess(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *SOResult) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
@@ -2857,245 +3096,6 @@
            }
            m.SoType = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipDataprocess(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthDataprocess
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *SoTarget) 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 ErrIntOverflowDataprocess
            }
            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: SoTarget: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: SoTarget: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SrcTarget", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.SrcTarget == nil {
                m.SrcTarget = &Target{}
            }
            if err := m.SrcTarget.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field AreaId", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                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 ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.AreaId = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field AreaName", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                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 ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.AreaName = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field BelongsTargetID", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                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 ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.BelongsTargetID = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 5:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field CompDbInfo", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthDataprocess
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthDataprocess
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.CompDbInfo = append(m.CompDbInfo, &RuleBaseCompareInfo{})
            if err := m.CompDbInfo[len(m.CompDbInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 6:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field ImageId", wireType)
            }
            m.ImageId = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowDataprocess
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.ImageId |= int64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipDataprocess(dAtA[iNdEx:])

 dataprocess.proto

@@ -36,6 +36,15 @@
    repeated RuleParams Params = 9;
}

message SoTarget {
    Target SrcTarget = 1;       
    string AreaId = 2;      
    string AreaName = 3;      
    string BelongsTargetID = 4;
    repeated RuleBaseCompareInfo CompDbInfo = 5;
    int64 ImageId = 6;      
}

message SOResult {
    bool IsEvent = 1;    
    bool IsEndRecord = 2;
@@ -47,14 +56,8 @@
    string SoType = 8;
}

message SoTarget {
    Target SrcTarget = 1;       
    string AreaId = 2;      
    string AreaName = 3;      
    string BelongsTargetID = 4;
    repeated RuleBaseCompareInfo CompDbInfo = 5;
    int64 ImageId = 6;      
}



message EventCache {
    map<uint64, SoTarget> Targets = 1;