增加SOResult相关结构体

cheliequan

2023-02-10 5d483655e888dbb97a1011c45f890669b7a74cc5

 sysset.pb.go

@@ -20,7 +20,7 @@
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type LocalConfig struct {
   ServerId           string `protobuf:"bytes,1,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
@@ -57,7 +57,7 @@
      return xxx_messageInfo_LocalConfig.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -224,7 +224,7 @@
      return xxx_messageInfo_PollConfig.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -300,7 +300,7 @@
      return xxx_messageInfo_Cluster.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -378,7 +378,7 @@
      return xxx_messageInfo_ClusterNode.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -467,7 +467,7 @@
      return xxx_messageInfo_ResourceConfig.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
@@ -514,67 +514,174 @@
   return 0
}

type Gb28181Config struct {
   Id           string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
   ServerIp     string `protobuf:"bytes,2,opt,name=ServerIp,proto3" json:"ServerIp,omitempty"`
   ServerPort   string `protobuf:"bytes,3,opt,name=ServerPort,proto3" json:"ServerPort,omitempty"`
   PublicId     string `protobuf:"bytes,4,opt,name=PublicId,proto3" json:"PublicId,omitempty"`
   GbServerPort string `protobuf:"bytes,5,opt,name=GbServerPort,proto3" json:"GbServerPort,omitempty"`
   IsAuth       bool   `protobuf:"varint,6,opt,name=IsAuth,proto3" json:"IsAuth,omitempty"`
   Password     string `protobuf:"bytes,7,opt,name=Password,proto3" json:"Password,omitempty"`
   UpdateTime   string `protobuf:"bytes,8,opt,name=UpdateTime,proto3" json:"UpdateTime,omitempty"`
}

func (m *Gb28181Config) Reset()         { *m = Gb28181Config{} }
func (m *Gb28181Config) String() string { return proto.CompactTextString(m) }
func (*Gb28181Config) ProtoMessage()    {}
func (*Gb28181Config) Descriptor() ([]byte, []int) {
   return fileDescriptor_5be590c6b2a0d755, []int{5}
}
func (m *Gb28181Config) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *Gb28181Config) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_Gb28181Config.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 *Gb28181Config) XXX_Merge(src proto.Message) {
   xxx_messageInfo_Gb28181Config.Merge(m, src)
}
func (m *Gb28181Config) XXX_Size() int {
   return m.Size()
}
func (m *Gb28181Config) XXX_DiscardUnknown() {
   xxx_messageInfo_Gb28181Config.DiscardUnknown(m)
}

var xxx_messageInfo_Gb28181Config proto.InternalMessageInfo

func (m *Gb28181Config) GetId() string {
   if m != nil {
      return m.Id
   }
   return ""
}

func (m *Gb28181Config) GetServerIp() string {
   if m != nil {
      return m.ServerIp
   }
   return ""
}

func (m *Gb28181Config) GetServerPort() string {
   if m != nil {
      return m.ServerPort
   }
   return ""
}

func (m *Gb28181Config) GetPublicId() string {
   if m != nil {
      return m.PublicId
   }
   return ""
}

func (m *Gb28181Config) GetGbServerPort() string {
   if m != nil {
      return m.GbServerPort
   }
   return ""
}

func (m *Gb28181Config) GetIsAuth() bool {
   if m != nil {
      return m.IsAuth
   }
   return false
}

func (m *Gb28181Config) GetPassword() string {
   if m != nil {
      return m.Password
   }
   return ""
}

func (m *Gb28181Config) GetUpdateTime() string {
   if m != nil {
      return m.UpdateTime
   }
   return ""
}

func init() {
   proto.RegisterType((*LocalConfig)(nil), "protomsg.LocalConfig")
   proto.RegisterType((*PollConfig)(nil), "protomsg.PollConfig")
   proto.RegisterType((*Cluster)(nil), "protomsg.Cluster")
   proto.RegisterType((*ClusterNode)(nil), "protomsg.ClusterNode")
   proto.RegisterType((*ResourceConfig)(nil), "protomsg.ResourceConfig")
   proto.RegisterType((*Gb28181Config)(nil), "protomsg.Gb28181Config")
}

func init() { proto.RegisterFile("sysset.proto", fileDescriptor_5be590c6b2a0d755) }

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

func (m *LocalConfig) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -582,136 +689,122 @@
}

func (m *LocalConfig) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LocalConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.AlarmThreshold != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.AlarmThreshold))
      i--
      dAtA[i] = 0x1
      i--
      dAtA[i] = 0x90
   }
   if m.AlarmThresholdType != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.AlarmThresholdType))
      i--
      dAtA[i] = 0x1
      i--
      dAtA[i] = 0x88
   }
   if m.RealMax != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.RealMax))
      i--
      dAtA[i] = 0x1
      i--
      dAtA[i] = 0x80
   }
   if len(m.NetMask) > 0 {
      i -= len(m.NetMask)
      copy(dAtA[i:], m.NetMask)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.NetMask)))
      i--
      dAtA[i] = 0x7a
   }
   if len(m.GateWay) > 0 {
      i -= len(m.GateWay)
      copy(dAtA[i:], m.GateWay)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.GateWay)))
      i--
      dAtA[i] = 0x72
   }
   if len(m.Reserved) > 0 {
      i -= len(m.Reserved)
      copy(dAtA[i:], m.Reserved)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Reserved)))
      i--
      dAtA[i] = 0x6a
   }
   if m.CutMinDuration != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.CutMinDuration))
      i--
      dAtA[i] = 0x60
   }
   if m.CutMaxDuration != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.CutMaxDuration))
      i--
      dAtA[i] = 0x58
   }
   if m.EsPicPort != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.EsPicPort))
      i--
      dAtA[i] = 0x50
   }
   if len(m.EsPicIp) > 0 {
      i -= len(m.EsPicIp)
      copy(dAtA[i:], m.EsPicIp)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.EsPicIp)))
      i--
      dAtA[i] = 0x4a
   }
   if m.WebPicPort != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.WebPicPort))
      i--
      dAtA[i] = 0x40
   }
   if len(m.WebPicIp) > 0 {
      i -= len(m.WebPicIp)
      copy(dAtA[i:], m.WebPicIp)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.WebPicIp)))
      i--
      dAtA[i] = 0x3a
   }
   if m.AlarmPort != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.AlarmPort))
      i--
      dAtA[i] = 0x30
   }
   if len(m.AlarmIp) > 0 {
      i -= len(m.AlarmIp)
      copy(dAtA[i:], m.AlarmIp)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.AlarmIp)))
      i--
      dAtA[i] = 0x2a
   }
   if len(m.ServerIp) > 0 {
      i -= len(m.ServerIp)
      copy(dAtA[i:], m.ServerIp)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerIp)))
      i--
      dAtA[i] = 0x22
   }
   if m.ServerType != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.ServerType))
      i--
      dAtA[i] = 0x18
   if len(m.ServerId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
      i += copy(dAtA[i:], m.ServerId)
   }
   if len(m.ServerName) > 0 {
      i -= len(m.ServerName)
      copy(dAtA[i:], m.ServerName)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerName)))
      i--
      dAtA[i] = 0x12
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerName)))
      i += copy(dAtA[i:], m.ServerName)
   }
   if len(m.ServerId) > 0 {
      i -= len(m.ServerId)
      copy(dAtA[i:], m.ServerId)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
      i--
      dAtA[i] = 0xa
   if m.ServerType != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.ServerType))
   }
   return len(dAtA) - i, nil
   if len(m.ServerIp) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerIp)))
      i += copy(dAtA[i:], m.ServerIp)
   }
   if len(m.AlarmIp) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.AlarmIp)))
      i += copy(dAtA[i:], m.AlarmIp)
   }
   if m.AlarmPort != 0 {
      dAtA[i] = 0x30
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.AlarmPort))
   }
   if len(m.WebPicIp) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.WebPicIp)))
      i += copy(dAtA[i:], m.WebPicIp)
   }
   if m.WebPicPort != 0 {
      dAtA[i] = 0x40
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.WebPicPort))
   }
   if len(m.EsPicIp) > 0 {
      dAtA[i] = 0x4a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.EsPicIp)))
      i += copy(dAtA[i:], m.EsPicIp)
   }
   if m.EsPicPort != 0 {
      dAtA[i] = 0x50
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.EsPicPort))
   }
   if m.CutMaxDuration != 0 {
      dAtA[i] = 0x58
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.CutMaxDuration))
   }
   if m.CutMinDuration != 0 {
      dAtA[i] = 0x60
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.CutMinDuration))
   }
   if len(m.Reserved) > 0 {
      dAtA[i] = 0x6a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Reserved)))
      i += copy(dAtA[i:], m.Reserved)
   }
   if len(m.GateWay) > 0 {
      dAtA[i] = 0x72
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.GateWay)))
      i += copy(dAtA[i:], m.GateWay)
   }
   if len(m.NetMask) > 0 {
      dAtA[i] = 0x7a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.NetMask)))
      i += copy(dAtA[i:], m.NetMask)
   }
   if m.RealMax != 0 {
      dAtA[i] = 0x80
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.RealMax))
   }
   if m.AlarmThresholdType != 0 {
      dAtA[i] = 0x88
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.AlarmThresholdType))
   }
   if m.AlarmThreshold != 0 {
      dAtA[i] = 0x90
      i++
      dAtA[i] = 0x1
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.AlarmThreshold))
   }
   return i, nil
}

func (m *PollConfig) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -719,54 +812,48 @@
}

func (m *PollConfig) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PollConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.PollChannelCount != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.PollChannelCount))
      i--
      dAtA[i] = 0x28
   if len(m.ServerId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
      i += copy(dAtA[i:], m.ServerId)
   }
   if m.PollPeriod != 0 {
      dAtA[i] = 0x10
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.PollPeriod))
   }
   if m.Delay != 0 {
      dAtA[i] = 0x18
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.Delay))
   }
   if m.Enable {
      i--
      dAtA[i] = 0x20
      i++
      if m.Enable {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i--
      dAtA[i] = 0x20
      i++
   }
   if m.Delay != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.Delay))
      i--
      dAtA[i] = 0x18
   if m.PollChannelCount != 0 {
      dAtA[i] = 0x28
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.PollChannelCount))
   }
   if m.PollPeriod != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.PollPeriod))
      i--
      dAtA[i] = 0x10
   }
   if len(m.ServerId) > 0 {
      i -= len(m.ServerId)
      copy(dAtA[i:], m.ServerId)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
      i--
      dAtA[i] = 0xa
   }
   return len(dAtA) - i, nil
   return i, nil
}

func (m *Cluster) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -774,64 +861,53 @@
}

func (m *Cluster) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Cluster) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Nodes) > 0 {
      for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
         {
            size, err := m.Nodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
            if err != nil {
               return 0, err
            }
            i -= size
            i = encodeVarintSysset(dAtA, i, uint64(size))
         }
         i--
         dAtA[i] = 0x2a
      }
   }
   if len(m.VirtualIp) > 0 {
      i -= len(m.VirtualIp)
      copy(dAtA[i:], m.VirtualIp)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.VirtualIp)))
      i--
      dAtA[i] = 0x22
   }
   if len(m.Password) > 0 {
      i -= len(m.Password)
      copy(dAtA[i:], m.Password)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Password)))
      i--
      dAtA[i] = 0x1a
   if len(m.ClusterId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterId)))
      i += copy(dAtA[i:], m.ClusterId)
   }
   if len(m.ClusterName) > 0 {
      i -= len(m.ClusterName)
      copy(dAtA[i:], m.ClusterName)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterName)))
      i--
      dAtA[i] = 0x12
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterName)))
      i += copy(dAtA[i:], m.ClusterName)
   }
   if len(m.ClusterId) > 0 {
      i -= len(m.ClusterId)
      copy(dAtA[i:], m.ClusterId)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterId)))
      i--
      dAtA[i] = 0xa
   if len(m.Password) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Password)))
      i += copy(dAtA[i:], m.Password)
   }
   return len(dAtA) - i, nil
   if len(m.VirtualIp) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.VirtualIp)))
      i += copy(dAtA[i:], m.VirtualIp)
   }
   if len(m.Nodes) > 0 {
      for _, msg := range m.Nodes {
         dAtA[i] = 0x2a
         i++
         i = encodeVarintSysset(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}

func (m *ClusterNode) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -839,71 +915,59 @@
}

func (m *ClusterNode) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ClusterNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if len(m.CreateTime) > 0 {
      i -= len(m.CreateTime)
      copy(dAtA[i:], m.CreateTime)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.CreateTime)))
      i--
      dAtA[i] = 0x3a
   }
   if len(m.NodeIp) > 0 {
      i -= len(m.NodeIp)
      copy(dAtA[i:], m.NodeIp)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.NodeIp)))
      i--
      dAtA[i] = 0x32
   }
   if len(m.NodeId) > 0 {
      i -= len(m.NodeId)
      copy(dAtA[i:], m.NodeId)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.NodeId)))
      i--
      dAtA[i] = 0x2a
   }
   if len(m.ServerName) > 0 {
      i -= len(m.ServerName)
      copy(dAtA[i:], m.ServerName)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerName)))
      i--
      dAtA[i] = 0x22
   }
   if len(m.ServerId) > 0 {
      i -= len(m.ServerId)
      copy(dAtA[i:], m.ServerId)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
      i--
      dAtA[i] = 0x1a
   if len(m.Id) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if len(m.ClusterId) > 0 {
      i -= len(m.ClusterId)
      copy(dAtA[i:], m.ClusterId)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterId)))
      i--
      dAtA[i] = 0x12
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ClusterId)))
      i += copy(dAtA[i:], m.ClusterId)
   }
   if len(m.Id) > 0 {
      i -= len(m.Id)
      copy(dAtA[i:], m.Id)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Id)))
      i--
      dAtA[i] = 0xa
   if len(m.ServerId) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerId)))
      i += copy(dAtA[i:], m.ServerId)
   }
   return len(dAtA) - i, nil
   if len(m.ServerName) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerName)))
      i += copy(dAtA[i:], m.ServerName)
   }
   if len(m.NodeId) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.NodeId)))
      i += copy(dAtA[i:], m.NodeId)
   }
   if len(m.NodeIp) > 0 {
      dAtA[i] = 0x32
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.NodeIp)))
      i += copy(dAtA[i:], m.NodeIp)
   }
   if len(m.CreateTime) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.CreateTime)))
      i += copy(dAtA[i:], m.CreateTime)
   }
   return i, nil
}

func (m *ResourceConfig) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
@@ -911,52 +975,113 @@
}

func (m *ResourceConfig) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ResourceConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   var i int
   _ = i
   var l int
   _ = l
   if m.FilePort != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.FilePort))
      i--
      dAtA[i] = 0x20
   }
   if len(m.Domain) > 0 {
      i -= len(m.Domain)
      copy(dAtA[i:], m.Domain)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Domain)))
      i--
      dAtA[i] = 0x1a
   if m.IpType != 0 {
      dAtA[i] = 0x8
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.IpType))
   }
   if len(m.ServiceIp) > 0 {
      i -= len(m.ServiceIp)
      copy(dAtA[i:], m.ServiceIp)
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServiceIp)))
      i--
      dAtA[i] = 0x12
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServiceIp)))
      i += copy(dAtA[i:], m.ServiceIp)
   }
   if m.IpType != 0 {
      i = encodeVarintSysset(dAtA, i, uint64(m.IpType))
      i--
      dAtA[i] = 0x8
   if len(m.Domain) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Domain)))
      i += copy(dAtA[i:], m.Domain)
   }
   return len(dAtA) - i, nil
   if m.FilePort != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintSysset(dAtA, i, uint64(m.FilePort))
   }
   return i, nil
}

func (m *Gb28181Config) 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 *Gb28181Config) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Id) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if len(m.ServerIp) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerIp)))
      i += copy(dAtA[i:], m.ServerIp)
   }
   if len(m.ServerPort) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.ServerPort)))
      i += copy(dAtA[i:], m.ServerPort)
   }
   if len(m.PublicId) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.PublicId)))
      i += copy(dAtA[i:], m.PublicId)
   }
   if len(m.GbServerPort) > 0 {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.GbServerPort)))
      i += copy(dAtA[i:], m.GbServerPort)
   }
   if m.IsAuth {
      dAtA[i] = 0x30
      i++
      if m.IsAuth {
         dAtA[i] = 1
      } else {
         dAtA[i] = 0
      }
      i++
   }
   if len(m.Password) > 0 {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.Password)))
      i += copy(dAtA[i:], m.Password)
   }
   if len(m.UpdateTime) > 0 {
      dAtA[i] = 0x42
      i++
      i = encodeVarintSysset(dAtA, i, uint64(len(m.UpdateTime)))
      i += copy(dAtA[i:], m.UpdateTime)
   }
   return i, nil
}

func encodeVarintSysset(dAtA []byte, offset int, v uint64) int {
   offset -= sovSysset(v)
   base := offset
   for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
      v >>= 7
      offset++
   }
   dAtA[offset] = uint8(v)
   return base
   return offset + 1
}
func (m *LocalConfig) Size() (n int) {
   if m == nil {
@@ -1142,6 +1267,46 @@
   }
   if m.FilePort != 0 {
      n += 1 + sovSysset(uint64(m.FilePort))
   }
   return n
}

func (m *Gb28181Config) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Id)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.ServerIp)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.ServerPort)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.PublicId)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.GbServerPort)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   if m.IsAuth {
      n += 2
   }
   l = len(m.Password)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   l = len(m.UpdateTime)
   if l > 0 {
      n += 1 + l + sovSysset(uint64(l))
   }
   return n
}
@@ -2473,10 +2638,306 @@
   }
   return nil
}
func (m *Gb28181Config) 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 ErrIntOverflowSysset
         }
         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: Gb28181Config: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: Gb28181Config: 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 ErrIntOverflowSysset
            }
            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 ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         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 ServerIp", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            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 ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.ServerIp = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ServerPort", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            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 ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.ServerPort = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field PublicId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            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 ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.PublicId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field GbServerPort", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            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 ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.GbServerPort = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 6:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field IsAuth", wireType)
         }
         var v int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            v |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         m.IsAuth = bool(v != 0)
      case 7:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            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 ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Password = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 8:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowSysset
            }
            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 ErrInvalidLengthSysset
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthSysset
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.UpdateTime = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipSysset(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthSysset
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthSysset
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func skipSysset(dAtA []byte) (n int, err error) {
   l := len(dAtA)
   iNdEx := 0
   depth := 0
   for iNdEx < l {
      var wire uint64
      for shift := uint(0); ; shift += 7 {
@@ -2508,8 +2969,10 @@
               break
            }
         }
         return iNdEx, nil
      case 1:
         iNdEx += 8
         return iNdEx, nil
      case 2:
         var length int
         for shift := uint(0); ; shift += 7 {
@@ -2530,30 +2993,55 @@
            return 0, ErrInvalidLengthSysset
         }
         iNdEx += length
      case 3:
         depth++
      case 4:
         if depth == 0 {
            return 0, ErrUnexpectedEndOfGroupSysset
         if iNdEx < 0 {
            return 0, ErrInvalidLengthSysset
         }
         depth--
         return iNdEx, nil
      case 3:
         for {
            var innerWire uint64
            var start int = iNdEx
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return 0, ErrIntOverflowSysset
               }
               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 := skipSysset(dAtA[start:])
            if err != nil {
               return 0, err
            }
            iNdEx = start + next
            if iNdEx < 0 {
               return 0, ErrInvalidLengthSysset
            }
         }
         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)
      }
      if iNdEx < 0 {
         return 0, ErrInvalidLengthSysset
      }
      if depth == 0 {
         return iNdEx, nil
      }
   }
   return 0, io.ErrUnexpectedEOF
   panic("unreachable")
}

var (
   ErrInvalidLengthSysset        = fmt.Errorf("proto: negative length found during unmarshaling")
   ErrIntOverflowSysset          = fmt.Errorf("proto: integer overflow")
   ErrUnexpectedEndOfGroupSysset = fmt.Errorf("proto: unexpected end of group")
   ErrInvalidLengthSysset = fmt.Errorf("proto: negative length found during unmarshaling")
   ErrIntOverflowSysset   = fmt.Errorf("proto: integer overflow")
)