add ResourceConfig

liuxiaolong

2019-12-14 d14cd01b7d110dbcc6e2ef98314bb129bd1f1103

add ResourceConfig

 sysset.pb.go

@@ -446,57 +446,120 @@
    return ""
}

type ResourceConfig struct {
    IpType    int32  `protobuf:"varint,1,opt,name=ipType,proto3" json:"ipType,omitempty"`
    ServiceIp string `protobuf:"bytes,2,opt,name=serviceIp,proto3" json:"serviceIp,omitempty"`
    Domain    string `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain,omitempty"`
}

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

var xxx_messageInfo_ResourceConfig proto.InternalMessageInfo

func (m *ResourceConfig) GetIpType() int32 {
    if m != nil {
        return m.IpType
    }
    return 0
}

func (m *ResourceConfig) GetServiceIp() string {
    if m != nil {
        return m.ServiceIp
    }
    return ""
}

func (m *ResourceConfig) GetDomain() string {
    if m != nil {
        return m.Domain
    }
    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")
}

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

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

func (m *LocalConfig) Marshal() (dAtA []byte, err error) {
@@ -785,6 +848,41 @@
    return i, nil
}

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

func encodeVarintSysset(dAtA []byte, offset int, v uint64) int {
    for v >= 1<<7 {
        dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -953,6 +1051,26 @@
        n += 1 + l + sovSysset(uint64(l))
    }
    l = len(m.CreateTime)
    if l > 0 {
        n += 1 + l + sovSysset(uint64(l))
    }
    return n
}

func (m *ResourceConfig) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.IpType != 0 {
        n += 1 + sovSysset(uint64(m.IpType))
    }
    l = len(m.ServiceIp)
    if l > 0 {
        n += 1 + l + sovSysset(uint64(l))
    }
    l = len(m.Domain)
    if l > 0 {
        n += 1 + l + sovSysset(uint64(l))
    }
@@ -2131,6 +2249,142 @@
    }
    return nil
}
func (m *ResourceConfig) 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: ResourceConfig: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: ResourceConfig: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field IpType", wireType)
            }
            m.IpType = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowSysset
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.IpType |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field ServiceIp", 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.ServiceIp = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Domain", 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.Domain = 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

 sysset.proto

@@ -48,4 +48,10 @@
    string node_id = 5;
    string node_ip = 6;
    string create_time = 7;
}

message ResourceConfig {
    int32 ipType = 1;
    string serviceIp = 2;
    string domain = 3;
}