1// Code generated by protoc-gen-gogo. DO NOT EDIT. 2// source: proto/pbservice/node.proto 3 4package pbservice 5 6import ( 7 fmt "fmt" 8 _ "github.com/gogo/protobuf/gogoproto" 9 proto "github.com/golang/protobuf/proto" 10 github_com_hashicorp_consul_agent_structs "github.com/hashicorp/consul/agent/structs" 11 pbcommon "github.com/hashicorp/consul/proto/pbcommon" 12 github_com_hashicorp_consul_types "github.com/hashicorp/consul/types" 13 io "io" 14 math "math" 15 math_bits "math/bits" 16) 17 18// Reference imports to suppress errors if they are not otherwise used. 19var _ = proto.Marshal 20var _ = fmt.Errorf 21var _ = math.Inf 22 23// This is a compile-time assertion to ensure that this generated file 24// is compatible with the proto package it is being compiled against. 25// A compilation error at this line likely means your copy of the 26// proto package needs to be updated. 27const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package 28 29// CheckServiceNode is used to provide the node, its service 30// definition, as well as a HealthCheck that is associated. 31type CheckServiceNode struct { 32 Node *Node `protobuf:"bytes,1,opt,name=Node,proto3" json:"Node,omitempty"` 33 Service *NodeService `protobuf:"bytes,2,opt,name=Service,proto3" json:"Service,omitempty"` 34 Checks []*HealthCheck `protobuf:"bytes,3,rep,name=Checks,proto3" json:"Checks,omitempty"` 35} 36 37func (m *CheckServiceNode) Reset() { *m = CheckServiceNode{} } 38func (m *CheckServiceNode) String() string { return proto.CompactTextString(m) } 39func (*CheckServiceNode) ProtoMessage() {} 40func (*CheckServiceNode) Descriptor() ([]byte, []int) { 41 return fileDescriptor_bbc215b78fa95fe5, []int{0} 42} 43func (m *CheckServiceNode) XXX_Unmarshal(b []byte) error { 44 return m.Unmarshal(b) 45} 46func (m *CheckServiceNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 47 if deterministic { 48 return xxx_messageInfo_CheckServiceNode.Marshal(b, m, deterministic) 49 } else { 50 b = b[:cap(b)] 51 n, err := m.MarshalToSizedBuffer(b) 52 if err != nil { 53 return nil, err 54 } 55 return b[:n], nil 56 } 57} 58func (m *CheckServiceNode) XXX_Merge(src proto.Message) { 59 xxx_messageInfo_CheckServiceNode.Merge(m, src) 60} 61func (m *CheckServiceNode) XXX_Size() int { 62 return m.Size() 63} 64func (m *CheckServiceNode) XXX_DiscardUnknown() { 65 xxx_messageInfo_CheckServiceNode.DiscardUnknown(m) 66} 67 68var xxx_messageInfo_CheckServiceNode proto.InternalMessageInfo 69 70// Node contains information about a node. 71// 72// mog annotation: 73// 74// target=github.com/hashicorp/consul/agent/structs.Node 75// output=node.gen.go 76// name=Structs 77type Node struct { 78 ID github_com_hashicorp_consul_types.NodeID `protobuf:"bytes,1,opt,name=ID,proto3,casttype=github.com/hashicorp/consul/types.NodeID" json:"ID,omitempty"` 79 Node string `protobuf:"bytes,2,opt,name=Node,proto3" json:"Node,omitempty"` 80 Address string `protobuf:"bytes,3,opt,name=Address,proto3" json:"Address,omitempty"` 81 Datacenter string `protobuf:"bytes,4,opt,name=Datacenter,proto3" json:"Datacenter,omitempty"` 82 TaggedAddresses map[string]string `protobuf:"bytes,5,rep,name=TaggedAddresses,proto3" json:"TaggedAddresses,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` 83 Meta map[string]string `protobuf:"bytes,6,rep,name=Meta,proto3" json:"Meta,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` 84 // mog: func-to=RaftIndexToStructs func-from=NewRaftIndexFromStructs 85 pbcommon.RaftIndex `protobuf:"bytes,7,opt,name=RaftIndex,proto3,embedded=RaftIndex" json:"RaftIndex"` 86} 87 88func (m *Node) Reset() { *m = Node{} } 89func (m *Node) String() string { return proto.CompactTextString(m) } 90func (*Node) ProtoMessage() {} 91func (*Node) Descriptor() ([]byte, []int) { 92 return fileDescriptor_bbc215b78fa95fe5, []int{1} 93} 94func (m *Node) XXX_Unmarshal(b []byte) error { 95 return m.Unmarshal(b) 96} 97func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 98 if deterministic { 99 return xxx_messageInfo_Node.Marshal(b, m, deterministic) 100 } else { 101 b = b[:cap(b)] 102 n, err := m.MarshalToSizedBuffer(b) 103 if err != nil { 104 return nil, err 105 } 106 return b[:n], nil 107 } 108} 109func (m *Node) XXX_Merge(src proto.Message) { 110 xxx_messageInfo_Node.Merge(m, src) 111} 112func (m *Node) XXX_Size() int { 113 return m.Size() 114} 115func (m *Node) XXX_DiscardUnknown() { 116 xxx_messageInfo_Node.DiscardUnknown(m) 117} 118 119var xxx_messageInfo_Node proto.InternalMessageInfo 120 121// NodeService is a service provided by a node 122// 123// mog annotation: 124// 125// target=github.com/hashicorp/consul/agent/structs.NodeService 126// output=node.gen.go 127// name=Structs 128type NodeService struct { 129 // Kind is the kind of service this is. Different kinds of services may 130 // have differing validation, DNS behavior, etc. An empty kind will default 131 // to the Default kind. See ServiceKind for the full list of kinds. 132 Kind github_com_hashicorp_consul_agent_structs.ServiceKind `protobuf:"bytes,1,opt,name=Kind,proto3,casttype=github.com/hashicorp/consul/agent/structs.ServiceKind" json:"Kind,omitempty"` 133 ID string `protobuf:"bytes,2,opt,name=ID,proto3" json:"ID,omitempty"` 134 Service string `protobuf:"bytes,3,opt,name=Service,proto3" json:"Service,omitempty"` 135 Tags []string `protobuf:"bytes,4,rep,name=Tags,proto3" json:"Tags,omitempty"` 136 Address string `protobuf:"bytes,5,opt,name=Address,proto3" json:"Address,omitempty"` 137 // mog: func-to=MapStringServiceAddressToStructs func-from=NewMapStringServiceAddressFromStructs 138 TaggedAddresses map[string]ServiceAddress `protobuf:"bytes,15,rep,name=TaggedAddresses,proto3" json:"TaggedAddresses" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` 139 Meta map[string]string `protobuf:"bytes,6,rep,name=Meta,proto3" json:"Meta,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` 140 // mog: func-to=int func-from=int32 141 Port int32 `protobuf:"varint,7,opt,name=Port,proto3" json:"Port,omitempty"` 142 SocketPath string `protobuf:"bytes,17,opt,name=SocketPath,proto3" json:"SocketPath,omitempty"` 143 // mog: func-to=WeightsPtrToStructs func-from=NewWeightsPtrFromStructs 144 Weights *Weights `protobuf:"bytes,8,opt,name=Weights,proto3" json:"Weights,omitempty"` 145 EnableTagOverride bool `protobuf:"varint,9,opt,name=EnableTagOverride,proto3" json:"EnableTagOverride,omitempty"` 146 // Proxy is the configuration set for Kind = connect-proxy. It is mandatory in 147 // that case and an error to be set for any other kind. This config is part of 148 // a proxy service definition and is distinct from but shares some fields with 149 // the Connect.Proxy which configures a managed proxy as part of the actual 150 // service's definition. This duplication is ugly but seemed better than the 151 // alternative which was to re-use the same struct fields for both cases even 152 // though the semantics are different and the non-shred fields make no sense 153 // in the other case. ProxyConfig may be a more natural name here, but it's 154 // confusing for the UX because one of the fields in ConnectProxyConfig is 155 // also called just "Config" 156 Proxy ConnectProxyConfig `protobuf:"bytes,11,opt,name=Proxy,proto3" json:"Proxy"` 157 // Connect are the Connect settings for a service. This is purposely NOT 158 // a pointer so that we never have to nil-check this. 159 Connect ServiceConnect `protobuf:"bytes,12,opt,name=Connect,proto3" json:"Connect"` 160 // LocallyRegisteredAsSidecar is private as it is only used by a local agent 161 // state to track if the service was registered from a nested sidecar_service 162 // block. We need to track that so we can know whether we need to deregister 163 // it automatically too if it's removed from the service definition or if the 164 // parent service is deregistered. Relying only on ID would cause us to 165 // deregister regular services if they happen to be registered using the same 166 // ID scheme as our sidecars do by default. We could use meta but that gets 167 // unpleasant because we can't use the consul- prefix from an agent (reserved 168 // for use internally but in practice that means within the state store or in 169 // responses only), and it leaks the detail publicly which people might rely 170 // on which is a bit unpleasant for something that is meant to be config-file 171 // syntax sugar. Note this is not translated to ServiceNode and friends and 172 // may not be set on a NodeService that isn't the one the agent registered and 173 // keeps in it's local state. We never want this rendered in JSON as it's 174 // internal only. Right now our agent endpoints return api structs which don't 175 // include it but this is a safety net incase we change that or there is 176 // somewhere this is used in API output. 177 LocallyRegisteredAsSidecar bool `protobuf:"varint,13,opt,name=LocallyRegisteredAsSidecar,proto3" json:"LocallyRegisteredAsSidecar,omitempty"` 178 // mog: func-to=EnterpriseMetaToStructs func-from=NewEnterpriseMetaFromStructs 179 EnterpriseMeta pbcommon.EnterpriseMeta `protobuf:"bytes,16,opt,name=EnterpriseMeta,proto3" json:"EnterpriseMeta"` 180 // mog: func-to=RaftIndexToStructs func-from=NewRaftIndexFromStructs 181 pbcommon.RaftIndex `protobuf:"bytes,14,opt,name=RaftIndex,proto3,embedded=RaftIndex" json:"RaftIndex"` 182} 183 184func (m *NodeService) Reset() { *m = NodeService{} } 185func (m *NodeService) String() string { return proto.CompactTextString(m) } 186func (*NodeService) ProtoMessage() {} 187func (*NodeService) Descriptor() ([]byte, []int) { 188 return fileDescriptor_bbc215b78fa95fe5, []int{2} 189} 190func (m *NodeService) XXX_Unmarshal(b []byte) error { 191 return m.Unmarshal(b) 192} 193func (m *NodeService) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 194 if deterministic { 195 return xxx_messageInfo_NodeService.Marshal(b, m, deterministic) 196 } else { 197 b = b[:cap(b)] 198 n, err := m.MarshalToSizedBuffer(b) 199 if err != nil { 200 return nil, err 201 } 202 return b[:n], nil 203 } 204} 205func (m *NodeService) XXX_Merge(src proto.Message) { 206 xxx_messageInfo_NodeService.Merge(m, src) 207} 208func (m *NodeService) XXX_Size() int { 209 return m.Size() 210} 211func (m *NodeService) XXX_DiscardUnknown() { 212 xxx_messageInfo_NodeService.DiscardUnknown(m) 213} 214 215var xxx_messageInfo_NodeService proto.InternalMessageInfo 216 217func init() { 218 proto.RegisterType((*CheckServiceNode)(nil), "pbservice.CheckServiceNode") 219 proto.RegisterType((*Node)(nil), "pbservice.Node") 220 proto.RegisterMapType((map[string]string)(nil), "pbservice.Node.MetaEntry") 221 proto.RegisterMapType((map[string]string)(nil), "pbservice.Node.TaggedAddressesEntry") 222 proto.RegisterType((*NodeService)(nil), "pbservice.NodeService") 223 proto.RegisterMapType((map[string]string)(nil), "pbservice.NodeService.MetaEntry") 224 proto.RegisterMapType((map[string]ServiceAddress)(nil), "pbservice.NodeService.TaggedAddressesEntry") 225} 226 227func init() { proto.RegisterFile("proto/pbservice/node.proto", fileDescriptor_bbc215b78fa95fe5) } 228 229var fileDescriptor_bbc215b78fa95fe5 = []byte{ 230 // 757 bytes of a gzipped FileDescriptorProto 231 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcd, 0x4e, 0x1b, 0x3b, 232 0x14, 0xce, 0x24, 0x13, 0x42, 0xcc, 0xbd, 0xfc, 0x58, 0xe8, 0xca, 0x37, 0x57, 0x4c, 0x72, 0x69, 233 0x17, 0x48, 0xd0, 0x99, 0xaa, 0x3f, 0x6a, 0x53, 0x55, 0x95, 0x08, 0x41, 0x6a, 0xd4, 0x42, 0xd1, 234 0x80, 0x54, 0xa9, 0x55, 0x17, 0xce, 0x8c, 0x99, 0x19, 0x11, 0xc6, 0x91, 0xed, 0x20, 0xf2, 0x16, 235 0x5d, 0xb6, 0x2f, 0xd0, 0x67, 0xa1, 0x3b, 0x96, 0x5d, 0x45, 0x2d, 0x79, 0x0b, 0x56, 0x95, 0x3d, 236 0x4e, 0x98, 0x0c, 0x29, 0x2a, 0x52, 0x57, 0xf6, 0x9c, 0xf3, 0x9d, 0xcf, 0xc7, 0xfe, 0xbe, 0x93, 237 0x80, 0x4a, 0x97, 0x51, 0x41, 0x9d, 0x6e, 0x9b, 0x13, 0x76, 0x12, 0x79, 0xc4, 0x89, 0xa9, 0x4f, 238 0x6c, 0x15, 0x84, 0xe5, 0x71, 0xb4, 0xf2, 0xdf, 0x08, 0xe6, 0xd1, 0xe3, 0x63, 0x1a, 0x3b, 0xc9, 239 0x92, 0xe0, 0x2a, 0xff, 0x67, 0x39, 0x42, 0x82, 0x3b, 0x22, 0xf4, 0x42, 0xe2, 0x1d, 0x69, 0xc8, 240 0x4a, 0x16, 0xa2, 0x57, 0x9d, 0x5e, 0x0e, 0x68, 0x40, 0x13, 0x88, 0xdc, 0x25, 0xd1, 0xd5, 0xcf, 241 0x06, 0x58, 0xdc, 0x92, 0x24, 0xfb, 0x09, 0x78, 0x97, 0xfa, 0x04, 0xde, 0x01, 0xa6, 0x5c, 0x91, 242 0x51, 0x33, 0xd6, 0xe6, 0x1e, 0x2c, 0xd8, 0x63, 0x4a, 0x5b, 0x86, 0x5d, 0x95, 0x84, 0xf7, 0x41, 243 0x49, 0xd7, 0xa0, 0xbc, 0xc2, 0xfd, 0x93, 0xc1, 0xe9, 0xac, 0x3b, 0x82, 0x41, 0x1b, 0xcc, 0xa8, 244 0xa3, 0x38, 0x2a, 0xd4, 0x0a, 0x99, 0x82, 0x97, 0xea, 0x3a, 0x2a, 0xed, 0x6a, 0xd4, 0xea, 0xd7, 245 0x42, 0xd2, 0x07, 0x7c, 0x0e, 0xf2, 0xad, 0xa6, 0xea, 0xa6, 0xdc, 0xd8, 0xb8, 0x1c, 0x54, 0xd7, 246 0x82, 0x48, 0x84, 0xbd, 0xb6, 0xed, 0xd1, 0x63, 0x27, 0xc4, 0x3c, 0x8c, 0x3c, 0xca, 0xba, 0x8e, 247 0x47, 0x63, 0xde, 0xeb, 0x38, 0xa2, 0xdf, 0x25, 0x5c, 0x35, 0xd0, 0x6a, 0xba, 0xf9, 0x56, 0x13, 248 0x42, 0x7d, 0x1b, 0xd9, 0x65, 0x59, 0x37, 0x8f, 0x40, 0x69, 0xd3, 0xf7, 0x19, 0xe1, 0xb2, 0x17, 249 0x19, 0x1e, 0x7d, 0x42, 0x0b, 0x80, 0x26, 0x16, 0xd8, 0x23, 0xb1, 0x20, 0x0c, 0x99, 0x2a, 0x99, 250 0x8a, 0xc0, 0x5d, 0xb0, 0x70, 0x80, 0x83, 0x80, 0xf8, 0xba, 0x80, 0x70, 0x54, 0x54, 0xb7, 0xb9, 251 0x9b, 0xb9, 0xbe, 0x9d, 0x81, 0x6d, 0xc7, 0x82, 0xf5, 0xdd, 0x6c, 0x31, 0xbc, 0x07, 0xcc, 0x1d, 252 0x22, 0x30, 0x9a, 0x51, 0x24, 0xff, 0x66, 0x49, 0x64, 0x2e, 0xa9, 0x54, 0x30, 0x58, 0x07, 0x65, 253 0x17, 0x1f, 0x8a, 0x56, 0xec, 0x93, 0x53, 0x54, 0x52, 0xef, 0xbe, 0x64, 0x6b, 0xa7, 0x8c, 0x13, 254 0x8d, 0xd9, 0xb3, 0x41, 0x35, 0x77, 0x3e, 0xa8, 0x1a, 0xee, 0x15, 0xba, 0xd2, 0x00, 0xcb, 0xd3, 255 0x5a, 0x82, 0x8b, 0xa0, 0x70, 0x44, 0xfa, 0xc9, 0xf3, 0xba, 0x72, 0x0b, 0x97, 0x41, 0xf1, 0x04, 256 0x77, 0x7a, 0xa3, 0x27, 0x4b, 0x3e, 0x9e, 0xe5, 0x9f, 0x1a, 0x95, 0x27, 0xa0, 0x3c, 0xee, 0xe8, 257 0x36, 0x85, 0xab, 0x5f, 0x4a, 0x60, 0x2e, 0x65, 0x0a, 0xb8, 0x03, 0xcc, 0x57, 0x51, 0xec, 0x6b, 258 0x51, 0xeb, 0x97, 0x83, 0xea, 0xe3, 0x9b, 0x44, 0xc5, 0x01, 0x89, 0x85, 0xc3, 0x05, 0xeb, 0x79, 259 0x82, 0xdb, 0x9a, 0x44, 0x12, 0xb8, 0x8a, 0x06, 0xce, 0x2b, 0x87, 0x24, 0xa7, 0x4a, 0xcd, 0xd1, 260 0x95, 0x39, 0xb5, 0xbe, 0xa3, 0x83, 0x21, 0x30, 0x0f, 0x70, 0xc0, 0x91, 0x59, 0x2b, 0x48, 0x37, 261 0xc8, 0x7d, 0xda, 0x0d, 0xc5, 0x49, 0x37, 0xbc, 0xbf, 0xae, 0xf6, 0x82, 0x12, 0x6a, 0x7d, 0xba, 262 0xd9, 0xa7, 0x8a, 0xde, 0x30, 0xa5, 0x1c, 0xd7, 0xa5, 0x7f, 0x34, 0x21, 0x7d, 0xed, 0x17, 0x8c, 263 0x59, 0x07, 0x40, 0x60, 0xee, 0x51, 0x26, 0x94, 0xf8, 0x45, 0x57, 0xed, 0xa5, 0x69, 0xf7, 0xa9, 264 0x77, 0x44, 0xc4, 0x1e, 0x16, 0x21, 0x5a, 0x4a, 0x4c, 0x7b, 0x15, 0x81, 0x1b, 0xa0, 0xf4, 0x96, 265 0x44, 0x41, 0x28, 0x38, 0x9a, 0x55, 0x9e, 0x81, 0xa9, 0xc3, 0x74, 0xc6, 0x1d, 0x41, 0xe0, 0x06, 266 0x58, 0xda, 0x8e, 0x71, 0xbb, 0x43, 0x0e, 0x70, 0xf0, 0xe6, 0x84, 0x30, 0x16, 0xf9, 0x04, 0x95, 267 0x6b, 0xc6, 0xda, 0xac, 0x7b, 0x3d, 0x01, 0xeb, 0xa0, 0xb8, 0xc7, 0xe8, 0x69, 0x1f, 0xcd, 0x29, 268 0xe6, 0x95, 0x14, 0xf3, 0x16, 0x8d, 0x63, 0xe2, 0x09, 0x95, 0xde, 0xa2, 0xf1, 0x61, 0x14, 0xe8, 269 0xa7, 0x48, 0x2a, 0x60, 0x1d, 0x94, 0x34, 0x04, 0xfd, 0xa5, 0x8a, 0xd3, 0xf6, 0xd7, 0xf7, 0xd7, 270 0x00, 0x5d, 0x38, 0xc2, 0xc3, 0x17, 0xa0, 0xf2, 0x9a, 0x7a, 0xb8, 0xd3, 0xe9, 0xbb, 0x24, 0x88, 271 0xb8, 0x20, 0x8c, 0xf8, 0x9b, 0x7c, 0x3f, 0xf2, 0x89, 0x87, 0x19, 0xfa, 0x5b, 0x35, 0x7b, 0x03, 272 0x02, 0x36, 0xc1, 0xfc, 0xb6, 0x9c, 0xe7, 0x2e, 0x8b, 0x38, 0x51, 0x2a, 0x2c, 0xea, 0x1f, 0x31, 273 0x3d, 0x4c, 0x93, 0x59, 0x7d, 0x7c, 0xa6, 0x66, 0x72, 0x1a, 0xe7, 0x6f, 0x35, 0x8d, 0x1f, 0x7e, 274 0x7b, 0x1a, 0x9d, 0xf4, 0x50, 0x4d, 0x7d, 0x23, 0x4d, 0xf1, 0x27, 0x06, 0xb5, 0xb1, 0x73, 0xf6, 275 0xc3, 0xca, 0x9d, 0x5d, 0x58, 0xc6, 0xf9, 0x85, 0x65, 0x7c, 0xbf, 0xb0, 0x8c, 0x8f, 0x43, 0x2b, 276 0xf7, 0x69, 0x68, 0xe5, 0xce, 0x87, 0x56, 0xee, 0xdb, 0xd0, 0xca, 0xbd, 0x5b, 0xbf, 0x69, 0x50, 277 0x33, 0xff, 0x41, 0xed, 0x19, 0x15, 0x78, 0xf8, 0x33, 0x00, 0x00, 0xff, 0xff, 0x17, 0xe3, 0xec, 278 0x0a, 0x04, 0x07, 0x00, 0x00, 279} 280 281func (m *CheckServiceNode) Marshal() (dAtA []byte, err error) { 282 size := m.Size() 283 dAtA = make([]byte, size) 284 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 285 if err != nil { 286 return nil, err 287 } 288 return dAtA[:n], nil 289} 290 291func (m *CheckServiceNode) MarshalTo(dAtA []byte) (int, error) { 292 size := m.Size() 293 return m.MarshalToSizedBuffer(dAtA[:size]) 294} 295 296func (m *CheckServiceNode) MarshalToSizedBuffer(dAtA []byte) (int, error) { 297 i := len(dAtA) 298 _ = i 299 var l int 300 _ = l 301 if len(m.Checks) > 0 { 302 for iNdEx := len(m.Checks) - 1; iNdEx >= 0; iNdEx-- { 303 { 304 size, err := m.Checks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 305 if err != nil { 306 return 0, err 307 } 308 i -= size 309 i = encodeVarintNode(dAtA, i, uint64(size)) 310 } 311 i-- 312 dAtA[i] = 0x1a 313 } 314 } 315 if m.Service != nil { 316 { 317 size, err := m.Service.MarshalToSizedBuffer(dAtA[:i]) 318 if err != nil { 319 return 0, err 320 } 321 i -= size 322 i = encodeVarintNode(dAtA, i, uint64(size)) 323 } 324 i-- 325 dAtA[i] = 0x12 326 } 327 if m.Node != nil { 328 { 329 size, err := m.Node.MarshalToSizedBuffer(dAtA[:i]) 330 if err != nil { 331 return 0, err 332 } 333 i -= size 334 i = encodeVarintNode(dAtA, i, uint64(size)) 335 } 336 i-- 337 dAtA[i] = 0xa 338 } 339 return len(dAtA) - i, nil 340} 341 342func (m *Node) Marshal() (dAtA []byte, err error) { 343 size := m.Size() 344 dAtA = make([]byte, size) 345 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 346 if err != nil { 347 return nil, err 348 } 349 return dAtA[:n], nil 350} 351 352func (m *Node) MarshalTo(dAtA []byte) (int, error) { 353 size := m.Size() 354 return m.MarshalToSizedBuffer(dAtA[:size]) 355} 356 357func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) { 358 i := len(dAtA) 359 _ = i 360 var l int 361 _ = l 362 { 363 size, err := m.RaftIndex.MarshalToSizedBuffer(dAtA[:i]) 364 if err != nil { 365 return 0, err 366 } 367 i -= size 368 i = encodeVarintNode(dAtA, i, uint64(size)) 369 } 370 i-- 371 dAtA[i] = 0x3a 372 if len(m.Meta) > 0 { 373 for k := range m.Meta { 374 v := m.Meta[k] 375 baseI := i 376 i -= len(v) 377 copy(dAtA[i:], v) 378 i = encodeVarintNode(dAtA, i, uint64(len(v))) 379 i-- 380 dAtA[i] = 0x12 381 i -= len(k) 382 copy(dAtA[i:], k) 383 i = encodeVarintNode(dAtA, i, uint64(len(k))) 384 i-- 385 dAtA[i] = 0xa 386 i = encodeVarintNode(dAtA, i, uint64(baseI-i)) 387 i-- 388 dAtA[i] = 0x32 389 } 390 } 391 if len(m.TaggedAddresses) > 0 { 392 for k := range m.TaggedAddresses { 393 v := m.TaggedAddresses[k] 394 baseI := i 395 i -= len(v) 396 copy(dAtA[i:], v) 397 i = encodeVarintNode(dAtA, i, uint64(len(v))) 398 i-- 399 dAtA[i] = 0x12 400 i -= len(k) 401 copy(dAtA[i:], k) 402 i = encodeVarintNode(dAtA, i, uint64(len(k))) 403 i-- 404 dAtA[i] = 0xa 405 i = encodeVarintNode(dAtA, i, uint64(baseI-i)) 406 i-- 407 dAtA[i] = 0x2a 408 } 409 } 410 if len(m.Datacenter) > 0 { 411 i -= len(m.Datacenter) 412 copy(dAtA[i:], m.Datacenter) 413 i = encodeVarintNode(dAtA, i, uint64(len(m.Datacenter))) 414 i-- 415 dAtA[i] = 0x22 416 } 417 if len(m.Address) > 0 { 418 i -= len(m.Address) 419 copy(dAtA[i:], m.Address) 420 i = encodeVarintNode(dAtA, i, uint64(len(m.Address))) 421 i-- 422 dAtA[i] = 0x1a 423 } 424 if len(m.Node) > 0 { 425 i -= len(m.Node) 426 copy(dAtA[i:], m.Node) 427 i = encodeVarintNode(dAtA, i, uint64(len(m.Node))) 428 i-- 429 dAtA[i] = 0x12 430 } 431 if len(m.ID) > 0 { 432 i -= len(m.ID) 433 copy(dAtA[i:], m.ID) 434 i = encodeVarintNode(dAtA, i, uint64(len(m.ID))) 435 i-- 436 dAtA[i] = 0xa 437 } 438 return len(dAtA) - i, nil 439} 440 441func (m *NodeService) Marshal() (dAtA []byte, err error) { 442 size := m.Size() 443 dAtA = make([]byte, size) 444 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 445 if err != nil { 446 return nil, err 447 } 448 return dAtA[:n], nil 449} 450 451func (m *NodeService) MarshalTo(dAtA []byte) (int, error) { 452 size := m.Size() 453 return m.MarshalToSizedBuffer(dAtA[:size]) 454} 455 456func (m *NodeService) MarshalToSizedBuffer(dAtA []byte) (int, error) { 457 i := len(dAtA) 458 _ = i 459 var l int 460 _ = l 461 if len(m.SocketPath) > 0 { 462 i -= len(m.SocketPath) 463 copy(dAtA[i:], m.SocketPath) 464 i = encodeVarintNode(dAtA, i, uint64(len(m.SocketPath))) 465 i-- 466 dAtA[i] = 0x1 467 i-- 468 dAtA[i] = 0x8a 469 } 470 { 471 size, err := m.EnterpriseMeta.MarshalToSizedBuffer(dAtA[:i]) 472 if err != nil { 473 return 0, err 474 } 475 i -= size 476 i = encodeVarintNode(dAtA, i, uint64(size)) 477 } 478 i-- 479 dAtA[i] = 0x1 480 i-- 481 dAtA[i] = 0x82 482 if len(m.TaggedAddresses) > 0 { 483 for k := range m.TaggedAddresses { 484 v := m.TaggedAddresses[k] 485 baseI := i 486 { 487 size, err := (&v).MarshalToSizedBuffer(dAtA[:i]) 488 if err != nil { 489 return 0, err 490 } 491 i -= size 492 i = encodeVarintNode(dAtA, i, uint64(size)) 493 } 494 i-- 495 dAtA[i] = 0x12 496 i -= len(k) 497 copy(dAtA[i:], k) 498 i = encodeVarintNode(dAtA, i, uint64(len(k))) 499 i-- 500 dAtA[i] = 0xa 501 i = encodeVarintNode(dAtA, i, uint64(baseI-i)) 502 i-- 503 dAtA[i] = 0x7a 504 } 505 } 506 { 507 size, err := m.RaftIndex.MarshalToSizedBuffer(dAtA[:i]) 508 if err != nil { 509 return 0, err 510 } 511 i -= size 512 i = encodeVarintNode(dAtA, i, uint64(size)) 513 } 514 i-- 515 dAtA[i] = 0x72 516 if m.LocallyRegisteredAsSidecar { 517 i-- 518 if m.LocallyRegisteredAsSidecar { 519 dAtA[i] = 1 520 } else { 521 dAtA[i] = 0 522 } 523 i-- 524 dAtA[i] = 0x68 525 } 526 { 527 size, err := m.Connect.MarshalToSizedBuffer(dAtA[:i]) 528 if err != nil { 529 return 0, err 530 } 531 i -= size 532 i = encodeVarintNode(dAtA, i, uint64(size)) 533 } 534 i-- 535 dAtA[i] = 0x62 536 { 537 size, err := m.Proxy.MarshalToSizedBuffer(dAtA[:i]) 538 if err != nil { 539 return 0, err 540 } 541 i -= size 542 i = encodeVarintNode(dAtA, i, uint64(size)) 543 } 544 i-- 545 dAtA[i] = 0x5a 546 if m.EnableTagOverride { 547 i-- 548 if m.EnableTagOverride { 549 dAtA[i] = 1 550 } else { 551 dAtA[i] = 0 552 } 553 i-- 554 dAtA[i] = 0x48 555 } 556 if m.Weights != nil { 557 { 558 size, err := m.Weights.MarshalToSizedBuffer(dAtA[:i]) 559 if err != nil { 560 return 0, err 561 } 562 i -= size 563 i = encodeVarintNode(dAtA, i, uint64(size)) 564 } 565 i-- 566 dAtA[i] = 0x42 567 } 568 if m.Port != 0 { 569 i = encodeVarintNode(dAtA, i, uint64(m.Port)) 570 i-- 571 dAtA[i] = 0x38 572 } 573 if len(m.Meta) > 0 { 574 for k := range m.Meta { 575 v := m.Meta[k] 576 baseI := i 577 i -= len(v) 578 copy(dAtA[i:], v) 579 i = encodeVarintNode(dAtA, i, uint64(len(v))) 580 i-- 581 dAtA[i] = 0x12 582 i -= len(k) 583 copy(dAtA[i:], k) 584 i = encodeVarintNode(dAtA, i, uint64(len(k))) 585 i-- 586 dAtA[i] = 0xa 587 i = encodeVarintNode(dAtA, i, uint64(baseI-i)) 588 i-- 589 dAtA[i] = 0x32 590 } 591 } 592 if len(m.Address) > 0 { 593 i -= len(m.Address) 594 copy(dAtA[i:], m.Address) 595 i = encodeVarintNode(dAtA, i, uint64(len(m.Address))) 596 i-- 597 dAtA[i] = 0x2a 598 } 599 if len(m.Tags) > 0 { 600 for iNdEx := len(m.Tags) - 1; iNdEx >= 0; iNdEx-- { 601 i -= len(m.Tags[iNdEx]) 602 copy(dAtA[i:], m.Tags[iNdEx]) 603 i = encodeVarintNode(dAtA, i, uint64(len(m.Tags[iNdEx]))) 604 i-- 605 dAtA[i] = 0x22 606 } 607 } 608 if len(m.Service) > 0 { 609 i -= len(m.Service) 610 copy(dAtA[i:], m.Service) 611 i = encodeVarintNode(dAtA, i, uint64(len(m.Service))) 612 i-- 613 dAtA[i] = 0x1a 614 } 615 if len(m.ID) > 0 { 616 i -= len(m.ID) 617 copy(dAtA[i:], m.ID) 618 i = encodeVarintNode(dAtA, i, uint64(len(m.ID))) 619 i-- 620 dAtA[i] = 0x12 621 } 622 if len(m.Kind) > 0 { 623 i -= len(m.Kind) 624 copy(dAtA[i:], m.Kind) 625 i = encodeVarintNode(dAtA, i, uint64(len(m.Kind))) 626 i-- 627 dAtA[i] = 0xa 628 } 629 return len(dAtA) - i, nil 630} 631 632func encodeVarintNode(dAtA []byte, offset int, v uint64) int { 633 offset -= sovNode(v) 634 base := offset 635 for v >= 1<<7 { 636 dAtA[offset] = uint8(v&0x7f | 0x80) 637 v >>= 7 638 offset++ 639 } 640 dAtA[offset] = uint8(v) 641 return base 642} 643func (m *CheckServiceNode) Size() (n int) { 644 if m == nil { 645 return 0 646 } 647 var l int 648 _ = l 649 if m.Node != nil { 650 l = m.Node.Size() 651 n += 1 + l + sovNode(uint64(l)) 652 } 653 if m.Service != nil { 654 l = m.Service.Size() 655 n += 1 + l + sovNode(uint64(l)) 656 } 657 if len(m.Checks) > 0 { 658 for _, e := range m.Checks { 659 l = e.Size() 660 n += 1 + l + sovNode(uint64(l)) 661 } 662 } 663 return n 664} 665 666func (m *Node) Size() (n int) { 667 if m == nil { 668 return 0 669 } 670 var l int 671 _ = l 672 l = len(m.ID) 673 if l > 0 { 674 n += 1 + l + sovNode(uint64(l)) 675 } 676 l = len(m.Node) 677 if l > 0 { 678 n += 1 + l + sovNode(uint64(l)) 679 } 680 l = len(m.Address) 681 if l > 0 { 682 n += 1 + l + sovNode(uint64(l)) 683 } 684 l = len(m.Datacenter) 685 if l > 0 { 686 n += 1 + l + sovNode(uint64(l)) 687 } 688 if len(m.TaggedAddresses) > 0 { 689 for k, v := range m.TaggedAddresses { 690 _ = k 691 _ = v 692 mapEntrySize := 1 + len(k) + sovNode(uint64(len(k))) + 1 + len(v) + sovNode(uint64(len(v))) 693 n += mapEntrySize + 1 + sovNode(uint64(mapEntrySize)) 694 } 695 } 696 if len(m.Meta) > 0 { 697 for k, v := range m.Meta { 698 _ = k 699 _ = v 700 mapEntrySize := 1 + len(k) + sovNode(uint64(len(k))) + 1 + len(v) + sovNode(uint64(len(v))) 701 n += mapEntrySize + 1 + sovNode(uint64(mapEntrySize)) 702 } 703 } 704 l = m.RaftIndex.Size() 705 n += 1 + l + sovNode(uint64(l)) 706 return n 707} 708 709func (m *NodeService) Size() (n int) { 710 if m == nil { 711 return 0 712 } 713 var l int 714 _ = l 715 l = len(m.Kind) 716 if l > 0 { 717 n += 1 + l + sovNode(uint64(l)) 718 } 719 l = len(m.ID) 720 if l > 0 { 721 n += 1 + l + sovNode(uint64(l)) 722 } 723 l = len(m.Service) 724 if l > 0 { 725 n += 1 + l + sovNode(uint64(l)) 726 } 727 if len(m.Tags) > 0 { 728 for _, s := range m.Tags { 729 l = len(s) 730 n += 1 + l + sovNode(uint64(l)) 731 } 732 } 733 l = len(m.Address) 734 if l > 0 { 735 n += 1 + l + sovNode(uint64(l)) 736 } 737 if len(m.Meta) > 0 { 738 for k, v := range m.Meta { 739 _ = k 740 _ = v 741 mapEntrySize := 1 + len(k) + sovNode(uint64(len(k))) + 1 + len(v) + sovNode(uint64(len(v))) 742 n += mapEntrySize + 1 + sovNode(uint64(mapEntrySize)) 743 } 744 } 745 if m.Port != 0 { 746 n += 1 + sovNode(uint64(m.Port)) 747 } 748 if m.Weights != nil { 749 l = m.Weights.Size() 750 n += 1 + l + sovNode(uint64(l)) 751 } 752 if m.EnableTagOverride { 753 n += 2 754 } 755 l = m.Proxy.Size() 756 n += 1 + l + sovNode(uint64(l)) 757 l = m.Connect.Size() 758 n += 1 + l + sovNode(uint64(l)) 759 if m.LocallyRegisteredAsSidecar { 760 n += 2 761 } 762 l = m.RaftIndex.Size() 763 n += 1 + l + sovNode(uint64(l)) 764 if len(m.TaggedAddresses) > 0 { 765 for k, v := range m.TaggedAddresses { 766 _ = k 767 _ = v 768 l = v.Size() 769 mapEntrySize := 1 + len(k) + sovNode(uint64(len(k))) + 1 + l + sovNode(uint64(l)) 770 n += mapEntrySize + 1 + sovNode(uint64(mapEntrySize)) 771 } 772 } 773 l = m.EnterpriseMeta.Size() 774 n += 2 + l + sovNode(uint64(l)) 775 l = len(m.SocketPath) 776 if l > 0 { 777 n += 2 + l + sovNode(uint64(l)) 778 } 779 return n 780} 781 782func sovNode(x uint64) (n int) { 783 return (math_bits.Len64(x|1) + 6) / 7 784} 785func sozNode(x uint64) (n int) { 786 return sovNode(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 787} 788func (m *CheckServiceNode) Unmarshal(dAtA []byte) error { 789 l := len(dAtA) 790 iNdEx := 0 791 for iNdEx < l { 792 preIndex := iNdEx 793 var wire uint64 794 for shift := uint(0); ; shift += 7 { 795 if shift >= 64 { 796 return ErrIntOverflowNode 797 } 798 if iNdEx >= l { 799 return io.ErrUnexpectedEOF 800 } 801 b := dAtA[iNdEx] 802 iNdEx++ 803 wire |= uint64(b&0x7F) << shift 804 if b < 0x80 { 805 break 806 } 807 } 808 fieldNum := int32(wire >> 3) 809 wireType := int(wire & 0x7) 810 if wireType == 4 { 811 return fmt.Errorf("proto: CheckServiceNode: wiretype end group for non-group") 812 } 813 if fieldNum <= 0 { 814 return fmt.Errorf("proto: CheckServiceNode: illegal tag %d (wire type %d)", fieldNum, wire) 815 } 816 switch fieldNum { 817 case 1: 818 if wireType != 2 { 819 return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType) 820 } 821 var msglen int 822 for shift := uint(0); ; shift += 7 { 823 if shift >= 64 { 824 return ErrIntOverflowNode 825 } 826 if iNdEx >= l { 827 return io.ErrUnexpectedEOF 828 } 829 b := dAtA[iNdEx] 830 iNdEx++ 831 msglen |= int(b&0x7F) << shift 832 if b < 0x80 { 833 break 834 } 835 } 836 if msglen < 0 { 837 return ErrInvalidLengthNode 838 } 839 postIndex := iNdEx + msglen 840 if postIndex < 0 { 841 return ErrInvalidLengthNode 842 } 843 if postIndex > l { 844 return io.ErrUnexpectedEOF 845 } 846 if m.Node == nil { 847 m.Node = &Node{} 848 } 849 if err := m.Node.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 850 return err 851 } 852 iNdEx = postIndex 853 case 2: 854 if wireType != 2 { 855 return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType) 856 } 857 var msglen int 858 for shift := uint(0); ; shift += 7 { 859 if shift >= 64 { 860 return ErrIntOverflowNode 861 } 862 if iNdEx >= l { 863 return io.ErrUnexpectedEOF 864 } 865 b := dAtA[iNdEx] 866 iNdEx++ 867 msglen |= int(b&0x7F) << shift 868 if b < 0x80 { 869 break 870 } 871 } 872 if msglen < 0 { 873 return ErrInvalidLengthNode 874 } 875 postIndex := iNdEx + msglen 876 if postIndex < 0 { 877 return ErrInvalidLengthNode 878 } 879 if postIndex > l { 880 return io.ErrUnexpectedEOF 881 } 882 if m.Service == nil { 883 m.Service = &NodeService{} 884 } 885 if err := m.Service.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 886 return err 887 } 888 iNdEx = postIndex 889 case 3: 890 if wireType != 2 { 891 return fmt.Errorf("proto: wrong wireType = %d for field Checks", wireType) 892 } 893 var msglen int 894 for shift := uint(0); ; shift += 7 { 895 if shift >= 64 { 896 return ErrIntOverflowNode 897 } 898 if iNdEx >= l { 899 return io.ErrUnexpectedEOF 900 } 901 b := dAtA[iNdEx] 902 iNdEx++ 903 msglen |= int(b&0x7F) << shift 904 if b < 0x80 { 905 break 906 } 907 } 908 if msglen < 0 { 909 return ErrInvalidLengthNode 910 } 911 postIndex := iNdEx + msglen 912 if postIndex < 0 { 913 return ErrInvalidLengthNode 914 } 915 if postIndex > l { 916 return io.ErrUnexpectedEOF 917 } 918 m.Checks = append(m.Checks, &HealthCheck{}) 919 if err := m.Checks[len(m.Checks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 920 return err 921 } 922 iNdEx = postIndex 923 default: 924 iNdEx = preIndex 925 skippy, err := skipNode(dAtA[iNdEx:]) 926 if err != nil { 927 return err 928 } 929 if (skippy < 0) || (iNdEx+skippy) < 0 { 930 return ErrInvalidLengthNode 931 } 932 if (iNdEx + skippy) > l { 933 return io.ErrUnexpectedEOF 934 } 935 iNdEx += skippy 936 } 937 } 938 939 if iNdEx > l { 940 return io.ErrUnexpectedEOF 941 } 942 return nil 943} 944func (m *Node) Unmarshal(dAtA []byte) error { 945 l := len(dAtA) 946 iNdEx := 0 947 for iNdEx < l { 948 preIndex := iNdEx 949 var wire uint64 950 for shift := uint(0); ; shift += 7 { 951 if shift >= 64 { 952 return ErrIntOverflowNode 953 } 954 if iNdEx >= l { 955 return io.ErrUnexpectedEOF 956 } 957 b := dAtA[iNdEx] 958 iNdEx++ 959 wire |= uint64(b&0x7F) << shift 960 if b < 0x80 { 961 break 962 } 963 } 964 fieldNum := int32(wire >> 3) 965 wireType := int(wire & 0x7) 966 if wireType == 4 { 967 return fmt.Errorf("proto: Node: wiretype end group for non-group") 968 } 969 if fieldNum <= 0 { 970 return fmt.Errorf("proto: Node: illegal tag %d (wire type %d)", fieldNum, wire) 971 } 972 switch fieldNum { 973 case 1: 974 if wireType != 2 { 975 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 976 } 977 var stringLen uint64 978 for shift := uint(0); ; shift += 7 { 979 if shift >= 64 { 980 return ErrIntOverflowNode 981 } 982 if iNdEx >= l { 983 return io.ErrUnexpectedEOF 984 } 985 b := dAtA[iNdEx] 986 iNdEx++ 987 stringLen |= uint64(b&0x7F) << shift 988 if b < 0x80 { 989 break 990 } 991 } 992 intStringLen := int(stringLen) 993 if intStringLen < 0 { 994 return ErrInvalidLengthNode 995 } 996 postIndex := iNdEx + intStringLen 997 if postIndex < 0 { 998 return ErrInvalidLengthNode 999 } 1000 if postIndex > l { 1001 return io.ErrUnexpectedEOF 1002 } 1003 m.ID = github_com_hashicorp_consul_types.NodeID(dAtA[iNdEx:postIndex]) 1004 iNdEx = postIndex 1005 case 2: 1006 if wireType != 2 { 1007 return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType) 1008 } 1009 var stringLen uint64 1010 for shift := uint(0); ; shift += 7 { 1011 if shift >= 64 { 1012 return ErrIntOverflowNode 1013 } 1014 if iNdEx >= l { 1015 return io.ErrUnexpectedEOF 1016 } 1017 b := dAtA[iNdEx] 1018 iNdEx++ 1019 stringLen |= uint64(b&0x7F) << shift 1020 if b < 0x80 { 1021 break 1022 } 1023 } 1024 intStringLen := int(stringLen) 1025 if intStringLen < 0 { 1026 return ErrInvalidLengthNode 1027 } 1028 postIndex := iNdEx + intStringLen 1029 if postIndex < 0 { 1030 return ErrInvalidLengthNode 1031 } 1032 if postIndex > l { 1033 return io.ErrUnexpectedEOF 1034 } 1035 m.Node = string(dAtA[iNdEx:postIndex]) 1036 iNdEx = postIndex 1037 case 3: 1038 if wireType != 2 { 1039 return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) 1040 } 1041 var stringLen uint64 1042 for shift := uint(0); ; shift += 7 { 1043 if shift >= 64 { 1044 return ErrIntOverflowNode 1045 } 1046 if iNdEx >= l { 1047 return io.ErrUnexpectedEOF 1048 } 1049 b := dAtA[iNdEx] 1050 iNdEx++ 1051 stringLen |= uint64(b&0x7F) << shift 1052 if b < 0x80 { 1053 break 1054 } 1055 } 1056 intStringLen := int(stringLen) 1057 if intStringLen < 0 { 1058 return ErrInvalidLengthNode 1059 } 1060 postIndex := iNdEx + intStringLen 1061 if postIndex < 0 { 1062 return ErrInvalidLengthNode 1063 } 1064 if postIndex > l { 1065 return io.ErrUnexpectedEOF 1066 } 1067 m.Address = string(dAtA[iNdEx:postIndex]) 1068 iNdEx = postIndex 1069 case 4: 1070 if wireType != 2 { 1071 return fmt.Errorf("proto: wrong wireType = %d for field Datacenter", wireType) 1072 } 1073 var stringLen uint64 1074 for shift := uint(0); ; shift += 7 { 1075 if shift >= 64 { 1076 return ErrIntOverflowNode 1077 } 1078 if iNdEx >= l { 1079 return io.ErrUnexpectedEOF 1080 } 1081 b := dAtA[iNdEx] 1082 iNdEx++ 1083 stringLen |= uint64(b&0x7F) << shift 1084 if b < 0x80 { 1085 break 1086 } 1087 } 1088 intStringLen := int(stringLen) 1089 if intStringLen < 0 { 1090 return ErrInvalidLengthNode 1091 } 1092 postIndex := iNdEx + intStringLen 1093 if postIndex < 0 { 1094 return ErrInvalidLengthNode 1095 } 1096 if postIndex > l { 1097 return io.ErrUnexpectedEOF 1098 } 1099 m.Datacenter = string(dAtA[iNdEx:postIndex]) 1100 iNdEx = postIndex 1101 case 5: 1102 if wireType != 2 { 1103 return fmt.Errorf("proto: wrong wireType = %d for field TaggedAddresses", wireType) 1104 } 1105 var msglen int 1106 for shift := uint(0); ; shift += 7 { 1107 if shift >= 64 { 1108 return ErrIntOverflowNode 1109 } 1110 if iNdEx >= l { 1111 return io.ErrUnexpectedEOF 1112 } 1113 b := dAtA[iNdEx] 1114 iNdEx++ 1115 msglen |= int(b&0x7F) << shift 1116 if b < 0x80 { 1117 break 1118 } 1119 } 1120 if msglen < 0 { 1121 return ErrInvalidLengthNode 1122 } 1123 postIndex := iNdEx + msglen 1124 if postIndex < 0 { 1125 return ErrInvalidLengthNode 1126 } 1127 if postIndex > l { 1128 return io.ErrUnexpectedEOF 1129 } 1130 if m.TaggedAddresses == nil { 1131 m.TaggedAddresses = make(map[string]string) 1132 } 1133 var mapkey string 1134 var mapvalue string 1135 for iNdEx < postIndex { 1136 entryPreIndex := iNdEx 1137 var wire uint64 1138 for shift := uint(0); ; shift += 7 { 1139 if shift >= 64 { 1140 return ErrIntOverflowNode 1141 } 1142 if iNdEx >= l { 1143 return io.ErrUnexpectedEOF 1144 } 1145 b := dAtA[iNdEx] 1146 iNdEx++ 1147 wire |= uint64(b&0x7F) << shift 1148 if b < 0x80 { 1149 break 1150 } 1151 } 1152 fieldNum := int32(wire >> 3) 1153 if fieldNum == 1 { 1154 var stringLenmapkey uint64 1155 for shift := uint(0); ; shift += 7 { 1156 if shift >= 64 { 1157 return ErrIntOverflowNode 1158 } 1159 if iNdEx >= l { 1160 return io.ErrUnexpectedEOF 1161 } 1162 b := dAtA[iNdEx] 1163 iNdEx++ 1164 stringLenmapkey |= uint64(b&0x7F) << shift 1165 if b < 0x80 { 1166 break 1167 } 1168 } 1169 intStringLenmapkey := int(stringLenmapkey) 1170 if intStringLenmapkey < 0 { 1171 return ErrInvalidLengthNode 1172 } 1173 postStringIndexmapkey := iNdEx + intStringLenmapkey 1174 if postStringIndexmapkey < 0 { 1175 return ErrInvalidLengthNode 1176 } 1177 if postStringIndexmapkey > l { 1178 return io.ErrUnexpectedEOF 1179 } 1180 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 1181 iNdEx = postStringIndexmapkey 1182 } else if fieldNum == 2 { 1183 var stringLenmapvalue uint64 1184 for shift := uint(0); ; shift += 7 { 1185 if shift >= 64 { 1186 return ErrIntOverflowNode 1187 } 1188 if iNdEx >= l { 1189 return io.ErrUnexpectedEOF 1190 } 1191 b := dAtA[iNdEx] 1192 iNdEx++ 1193 stringLenmapvalue |= uint64(b&0x7F) << shift 1194 if b < 0x80 { 1195 break 1196 } 1197 } 1198 intStringLenmapvalue := int(stringLenmapvalue) 1199 if intStringLenmapvalue < 0 { 1200 return ErrInvalidLengthNode 1201 } 1202 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 1203 if postStringIndexmapvalue < 0 { 1204 return ErrInvalidLengthNode 1205 } 1206 if postStringIndexmapvalue > l { 1207 return io.ErrUnexpectedEOF 1208 } 1209 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 1210 iNdEx = postStringIndexmapvalue 1211 } else { 1212 iNdEx = entryPreIndex 1213 skippy, err := skipNode(dAtA[iNdEx:]) 1214 if err != nil { 1215 return err 1216 } 1217 if (skippy < 0) || (iNdEx+skippy) < 0 { 1218 return ErrInvalidLengthNode 1219 } 1220 if (iNdEx + skippy) > postIndex { 1221 return io.ErrUnexpectedEOF 1222 } 1223 iNdEx += skippy 1224 } 1225 } 1226 m.TaggedAddresses[mapkey] = mapvalue 1227 iNdEx = postIndex 1228 case 6: 1229 if wireType != 2 { 1230 return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) 1231 } 1232 var msglen int 1233 for shift := uint(0); ; shift += 7 { 1234 if shift >= 64 { 1235 return ErrIntOverflowNode 1236 } 1237 if iNdEx >= l { 1238 return io.ErrUnexpectedEOF 1239 } 1240 b := dAtA[iNdEx] 1241 iNdEx++ 1242 msglen |= int(b&0x7F) << shift 1243 if b < 0x80 { 1244 break 1245 } 1246 } 1247 if msglen < 0 { 1248 return ErrInvalidLengthNode 1249 } 1250 postIndex := iNdEx + msglen 1251 if postIndex < 0 { 1252 return ErrInvalidLengthNode 1253 } 1254 if postIndex > l { 1255 return io.ErrUnexpectedEOF 1256 } 1257 if m.Meta == nil { 1258 m.Meta = make(map[string]string) 1259 } 1260 var mapkey string 1261 var mapvalue string 1262 for iNdEx < postIndex { 1263 entryPreIndex := iNdEx 1264 var wire uint64 1265 for shift := uint(0); ; shift += 7 { 1266 if shift >= 64 { 1267 return ErrIntOverflowNode 1268 } 1269 if iNdEx >= l { 1270 return io.ErrUnexpectedEOF 1271 } 1272 b := dAtA[iNdEx] 1273 iNdEx++ 1274 wire |= uint64(b&0x7F) << shift 1275 if b < 0x80 { 1276 break 1277 } 1278 } 1279 fieldNum := int32(wire >> 3) 1280 if fieldNum == 1 { 1281 var stringLenmapkey uint64 1282 for shift := uint(0); ; shift += 7 { 1283 if shift >= 64 { 1284 return ErrIntOverflowNode 1285 } 1286 if iNdEx >= l { 1287 return io.ErrUnexpectedEOF 1288 } 1289 b := dAtA[iNdEx] 1290 iNdEx++ 1291 stringLenmapkey |= uint64(b&0x7F) << shift 1292 if b < 0x80 { 1293 break 1294 } 1295 } 1296 intStringLenmapkey := int(stringLenmapkey) 1297 if intStringLenmapkey < 0 { 1298 return ErrInvalidLengthNode 1299 } 1300 postStringIndexmapkey := iNdEx + intStringLenmapkey 1301 if postStringIndexmapkey < 0 { 1302 return ErrInvalidLengthNode 1303 } 1304 if postStringIndexmapkey > l { 1305 return io.ErrUnexpectedEOF 1306 } 1307 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 1308 iNdEx = postStringIndexmapkey 1309 } else if fieldNum == 2 { 1310 var stringLenmapvalue uint64 1311 for shift := uint(0); ; shift += 7 { 1312 if shift >= 64 { 1313 return ErrIntOverflowNode 1314 } 1315 if iNdEx >= l { 1316 return io.ErrUnexpectedEOF 1317 } 1318 b := dAtA[iNdEx] 1319 iNdEx++ 1320 stringLenmapvalue |= uint64(b&0x7F) << shift 1321 if b < 0x80 { 1322 break 1323 } 1324 } 1325 intStringLenmapvalue := int(stringLenmapvalue) 1326 if intStringLenmapvalue < 0 { 1327 return ErrInvalidLengthNode 1328 } 1329 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 1330 if postStringIndexmapvalue < 0 { 1331 return ErrInvalidLengthNode 1332 } 1333 if postStringIndexmapvalue > l { 1334 return io.ErrUnexpectedEOF 1335 } 1336 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 1337 iNdEx = postStringIndexmapvalue 1338 } else { 1339 iNdEx = entryPreIndex 1340 skippy, err := skipNode(dAtA[iNdEx:]) 1341 if err != nil { 1342 return err 1343 } 1344 if (skippy < 0) || (iNdEx+skippy) < 0 { 1345 return ErrInvalidLengthNode 1346 } 1347 if (iNdEx + skippy) > postIndex { 1348 return io.ErrUnexpectedEOF 1349 } 1350 iNdEx += skippy 1351 } 1352 } 1353 m.Meta[mapkey] = mapvalue 1354 iNdEx = postIndex 1355 case 7: 1356 if wireType != 2 { 1357 return fmt.Errorf("proto: wrong wireType = %d for field RaftIndex", wireType) 1358 } 1359 var msglen int 1360 for shift := uint(0); ; shift += 7 { 1361 if shift >= 64 { 1362 return ErrIntOverflowNode 1363 } 1364 if iNdEx >= l { 1365 return io.ErrUnexpectedEOF 1366 } 1367 b := dAtA[iNdEx] 1368 iNdEx++ 1369 msglen |= int(b&0x7F) << shift 1370 if b < 0x80 { 1371 break 1372 } 1373 } 1374 if msglen < 0 { 1375 return ErrInvalidLengthNode 1376 } 1377 postIndex := iNdEx + msglen 1378 if postIndex < 0 { 1379 return ErrInvalidLengthNode 1380 } 1381 if postIndex > l { 1382 return io.ErrUnexpectedEOF 1383 } 1384 if err := m.RaftIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1385 return err 1386 } 1387 iNdEx = postIndex 1388 default: 1389 iNdEx = preIndex 1390 skippy, err := skipNode(dAtA[iNdEx:]) 1391 if err != nil { 1392 return err 1393 } 1394 if (skippy < 0) || (iNdEx+skippy) < 0 { 1395 return ErrInvalidLengthNode 1396 } 1397 if (iNdEx + skippy) > l { 1398 return io.ErrUnexpectedEOF 1399 } 1400 iNdEx += skippy 1401 } 1402 } 1403 1404 if iNdEx > l { 1405 return io.ErrUnexpectedEOF 1406 } 1407 return nil 1408} 1409func (m *NodeService) Unmarshal(dAtA []byte) error { 1410 l := len(dAtA) 1411 iNdEx := 0 1412 for iNdEx < l { 1413 preIndex := iNdEx 1414 var wire uint64 1415 for shift := uint(0); ; shift += 7 { 1416 if shift >= 64 { 1417 return ErrIntOverflowNode 1418 } 1419 if iNdEx >= l { 1420 return io.ErrUnexpectedEOF 1421 } 1422 b := dAtA[iNdEx] 1423 iNdEx++ 1424 wire |= uint64(b&0x7F) << shift 1425 if b < 0x80 { 1426 break 1427 } 1428 } 1429 fieldNum := int32(wire >> 3) 1430 wireType := int(wire & 0x7) 1431 if wireType == 4 { 1432 return fmt.Errorf("proto: NodeService: wiretype end group for non-group") 1433 } 1434 if fieldNum <= 0 { 1435 return fmt.Errorf("proto: NodeService: illegal tag %d (wire type %d)", fieldNum, wire) 1436 } 1437 switch fieldNum { 1438 case 1: 1439 if wireType != 2 { 1440 return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) 1441 } 1442 var stringLen uint64 1443 for shift := uint(0); ; shift += 7 { 1444 if shift >= 64 { 1445 return ErrIntOverflowNode 1446 } 1447 if iNdEx >= l { 1448 return io.ErrUnexpectedEOF 1449 } 1450 b := dAtA[iNdEx] 1451 iNdEx++ 1452 stringLen |= uint64(b&0x7F) << shift 1453 if b < 0x80 { 1454 break 1455 } 1456 } 1457 intStringLen := int(stringLen) 1458 if intStringLen < 0 { 1459 return ErrInvalidLengthNode 1460 } 1461 postIndex := iNdEx + intStringLen 1462 if postIndex < 0 { 1463 return ErrInvalidLengthNode 1464 } 1465 if postIndex > l { 1466 return io.ErrUnexpectedEOF 1467 } 1468 m.Kind = github_com_hashicorp_consul_agent_structs.ServiceKind(dAtA[iNdEx:postIndex]) 1469 iNdEx = postIndex 1470 case 2: 1471 if wireType != 2 { 1472 return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) 1473 } 1474 var stringLen uint64 1475 for shift := uint(0); ; shift += 7 { 1476 if shift >= 64 { 1477 return ErrIntOverflowNode 1478 } 1479 if iNdEx >= l { 1480 return io.ErrUnexpectedEOF 1481 } 1482 b := dAtA[iNdEx] 1483 iNdEx++ 1484 stringLen |= uint64(b&0x7F) << shift 1485 if b < 0x80 { 1486 break 1487 } 1488 } 1489 intStringLen := int(stringLen) 1490 if intStringLen < 0 { 1491 return ErrInvalidLengthNode 1492 } 1493 postIndex := iNdEx + intStringLen 1494 if postIndex < 0 { 1495 return ErrInvalidLengthNode 1496 } 1497 if postIndex > l { 1498 return io.ErrUnexpectedEOF 1499 } 1500 m.ID = string(dAtA[iNdEx:postIndex]) 1501 iNdEx = postIndex 1502 case 3: 1503 if wireType != 2 { 1504 return fmt.Errorf("proto: wrong wireType = %d for field Service", wireType) 1505 } 1506 var stringLen uint64 1507 for shift := uint(0); ; shift += 7 { 1508 if shift >= 64 { 1509 return ErrIntOverflowNode 1510 } 1511 if iNdEx >= l { 1512 return io.ErrUnexpectedEOF 1513 } 1514 b := dAtA[iNdEx] 1515 iNdEx++ 1516 stringLen |= uint64(b&0x7F) << shift 1517 if b < 0x80 { 1518 break 1519 } 1520 } 1521 intStringLen := int(stringLen) 1522 if intStringLen < 0 { 1523 return ErrInvalidLengthNode 1524 } 1525 postIndex := iNdEx + intStringLen 1526 if postIndex < 0 { 1527 return ErrInvalidLengthNode 1528 } 1529 if postIndex > l { 1530 return io.ErrUnexpectedEOF 1531 } 1532 m.Service = string(dAtA[iNdEx:postIndex]) 1533 iNdEx = postIndex 1534 case 4: 1535 if wireType != 2 { 1536 return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType) 1537 } 1538 var stringLen uint64 1539 for shift := uint(0); ; shift += 7 { 1540 if shift >= 64 { 1541 return ErrIntOverflowNode 1542 } 1543 if iNdEx >= l { 1544 return io.ErrUnexpectedEOF 1545 } 1546 b := dAtA[iNdEx] 1547 iNdEx++ 1548 stringLen |= uint64(b&0x7F) << shift 1549 if b < 0x80 { 1550 break 1551 } 1552 } 1553 intStringLen := int(stringLen) 1554 if intStringLen < 0 { 1555 return ErrInvalidLengthNode 1556 } 1557 postIndex := iNdEx + intStringLen 1558 if postIndex < 0 { 1559 return ErrInvalidLengthNode 1560 } 1561 if postIndex > l { 1562 return io.ErrUnexpectedEOF 1563 } 1564 m.Tags = append(m.Tags, string(dAtA[iNdEx:postIndex])) 1565 iNdEx = postIndex 1566 case 5: 1567 if wireType != 2 { 1568 return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) 1569 } 1570 var stringLen uint64 1571 for shift := uint(0); ; shift += 7 { 1572 if shift >= 64 { 1573 return ErrIntOverflowNode 1574 } 1575 if iNdEx >= l { 1576 return io.ErrUnexpectedEOF 1577 } 1578 b := dAtA[iNdEx] 1579 iNdEx++ 1580 stringLen |= uint64(b&0x7F) << shift 1581 if b < 0x80 { 1582 break 1583 } 1584 } 1585 intStringLen := int(stringLen) 1586 if intStringLen < 0 { 1587 return ErrInvalidLengthNode 1588 } 1589 postIndex := iNdEx + intStringLen 1590 if postIndex < 0 { 1591 return ErrInvalidLengthNode 1592 } 1593 if postIndex > l { 1594 return io.ErrUnexpectedEOF 1595 } 1596 m.Address = string(dAtA[iNdEx:postIndex]) 1597 iNdEx = postIndex 1598 case 6: 1599 if wireType != 2 { 1600 return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType) 1601 } 1602 var msglen int 1603 for shift := uint(0); ; shift += 7 { 1604 if shift >= 64 { 1605 return ErrIntOverflowNode 1606 } 1607 if iNdEx >= l { 1608 return io.ErrUnexpectedEOF 1609 } 1610 b := dAtA[iNdEx] 1611 iNdEx++ 1612 msglen |= int(b&0x7F) << shift 1613 if b < 0x80 { 1614 break 1615 } 1616 } 1617 if msglen < 0 { 1618 return ErrInvalidLengthNode 1619 } 1620 postIndex := iNdEx + msglen 1621 if postIndex < 0 { 1622 return ErrInvalidLengthNode 1623 } 1624 if postIndex > l { 1625 return io.ErrUnexpectedEOF 1626 } 1627 if m.Meta == nil { 1628 m.Meta = make(map[string]string) 1629 } 1630 var mapkey string 1631 var mapvalue string 1632 for iNdEx < postIndex { 1633 entryPreIndex := iNdEx 1634 var wire uint64 1635 for shift := uint(0); ; shift += 7 { 1636 if shift >= 64 { 1637 return ErrIntOverflowNode 1638 } 1639 if iNdEx >= l { 1640 return io.ErrUnexpectedEOF 1641 } 1642 b := dAtA[iNdEx] 1643 iNdEx++ 1644 wire |= uint64(b&0x7F) << shift 1645 if b < 0x80 { 1646 break 1647 } 1648 } 1649 fieldNum := int32(wire >> 3) 1650 if fieldNum == 1 { 1651 var stringLenmapkey uint64 1652 for shift := uint(0); ; shift += 7 { 1653 if shift >= 64 { 1654 return ErrIntOverflowNode 1655 } 1656 if iNdEx >= l { 1657 return io.ErrUnexpectedEOF 1658 } 1659 b := dAtA[iNdEx] 1660 iNdEx++ 1661 stringLenmapkey |= uint64(b&0x7F) << shift 1662 if b < 0x80 { 1663 break 1664 } 1665 } 1666 intStringLenmapkey := int(stringLenmapkey) 1667 if intStringLenmapkey < 0 { 1668 return ErrInvalidLengthNode 1669 } 1670 postStringIndexmapkey := iNdEx + intStringLenmapkey 1671 if postStringIndexmapkey < 0 { 1672 return ErrInvalidLengthNode 1673 } 1674 if postStringIndexmapkey > l { 1675 return io.ErrUnexpectedEOF 1676 } 1677 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 1678 iNdEx = postStringIndexmapkey 1679 } else if fieldNum == 2 { 1680 var stringLenmapvalue uint64 1681 for shift := uint(0); ; shift += 7 { 1682 if shift >= 64 { 1683 return ErrIntOverflowNode 1684 } 1685 if iNdEx >= l { 1686 return io.ErrUnexpectedEOF 1687 } 1688 b := dAtA[iNdEx] 1689 iNdEx++ 1690 stringLenmapvalue |= uint64(b&0x7F) << shift 1691 if b < 0x80 { 1692 break 1693 } 1694 } 1695 intStringLenmapvalue := int(stringLenmapvalue) 1696 if intStringLenmapvalue < 0 { 1697 return ErrInvalidLengthNode 1698 } 1699 postStringIndexmapvalue := iNdEx + intStringLenmapvalue 1700 if postStringIndexmapvalue < 0 { 1701 return ErrInvalidLengthNode 1702 } 1703 if postStringIndexmapvalue > l { 1704 return io.ErrUnexpectedEOF 1705 } 1706 mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) 1707 iNdEx = postStringIndexmapvalue 1708 } else { 1709 iNdEx = entryPreIndex 1710 skippy, err := skipNode(dAtA[iNdEx:]) 1711 if err != nil { 1712 return err 1713 } 1714 if (skippy < 0) || (iNdEx+skippy) < 0 { 1715 return ErrInvalidLengthNode 1716 } 1717 if (iNdEx + skippy) > postIndex { 1718 return io.ErrUnexpectedEOF 1719 } 1720 iNdEx += skippy 1721 } 1722 } 1723 m.Meta[mapkey] = mapvalue 1724 iNdEx = postIndex 1725 case 7: 1726 if wireType != 0 { 1727 return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) 1728 } 1729 m.Port = 0 1730 for shift := uint(0); ; shift += 7 { 1731 if shift >= 64 { 1732 return ErrIntOverflowNode 1733 } 1734 if iNdEx >= l { 1735 return io.ErrUnexpectedEOF 1736 } 1737 b := dAtA[iNdEx] 1738 iNdEx++ 1739 m.Port |= int32(b&0x7F) << shift 1740 if b < 0x80 { 1741 break 1742 } 1743 } 1744 case 8: 1745 if wireType != 2 { 1746 return fmt.Errorf("proto: wrong wireType = %d for field Weights", wireType) 1747 } 1748 var msglen int 1749 for shift := uint(0); ; shift += 7 { 1750 if shift >= 64 { 1751 return ErrIntOverflowNode 1752 } 1753 if iNdEx >= l { 1754 return io.ErrUnexpectedEOF 1755 } 1756 b := dAtA[iNdEx] 1757 iNdEx++ 1758 msglen |= int(b&0x7F) << shift 1759 if b < 0x80 { 1760 break 1761 } 1762 } 1763 if msglen < 0 { 1764 return ErrInvalidLengthNode 1765 } 1766 postIndex := iNdEx + msglen 1767 if postIndex < 0 { 1768 return ErrInvalidLengthNode 1769 } 1770 if postIndex > l { 1771 return io.ErrUnexpectedEOF 1772 } 1773 if m.Weights == nil { 1774 m.Weights = &Weights{} 1775 } 1776 if err := m.Weights.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1777 return err 1778 } 1779 iNdEx = postIndex 1780 case 9: 1781 if wireType != 0 { 1782 return fmt.Errorf("proto: wrong wireType = %d for field EnableTagOverride", wireType) 1783 } 1784 var v int 1785 for shift := uint(0); ; shift += 7 { 1786 if shift >= 64 { 1787 return ErrIntOverflowNode 1788 } 1789 if iNdEx >= l { 1790 return io.ErrUnexpectedEOF 1791 } 1792 b := dAtA[iNdEx] 1793 iNdEx++ 1794 v |= int(b&0x7F) << shift 1795 if b < 0x80 { 1796 break 1797 } 1798 } 1799 m.EnableTagOverride = bool(v != 0) 1800 case 11: 1801 if wireType != 2 { 1802 return fmt.Errorf("proto: wrong wireType = %d for field Proxy", wireType) 1803 } 1804 var msglen int 1805 for shift := uint(0); ; shift += 7 { 1806 if shift >= 64 { 1807 return ErrIntOverflowNode 1808 } 1809 if iNdEx >= l { 1810 return io.ErrUnexpectedEOF 1811 } 1812 b := dAtA[iNdEx] 1813 iNdEx++ 1814 msglen |= int(b&0x7F) << shift 1815 if b < 0x80 { 1816 break 1817 } 1818 } 1819 if msglen < 0 { 1820 return ErrInvalidLengthNode 1821 } 1822 postIndex := iNdEx + msglen 1823 if postIndex < 0 { 1824 return ErrInvalidLengthNode 1825 } 1826 if postIndex > l { 1827 return io.ErrUnexpectedEOF 1828 } 1829 if err := m.Proxy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1830 return err 1831 } 1832 iNdEx = postIndex 1833 case 12: 1834 if wireType != 2 { 1835 return fmt.Errorf("proto: wrong wireType = %d for field Connect", wireType) 1836 } 1837 var msglen int 1838 for shift := uint(0); ; shift += 7 { 1839 if shift >= 64 { 1840 return ErrIntOverflowNode 1841 } 1842 if iNdEx >= l { 1843 return io.ErrUnexpectedEOF 1844 } 1845 b := dAtA[iNdEx] 1846 iNdEx++ 1847 msglen |= int(b&0x7F) << shift 1848 if b < 0x80 { 1849 break 1850 } 1851 } 1852 if msglen < 0 { 1853 return ErrInvalidLengthNode 1854 } 1855 postIndex := iNdEx + msglen 1856 if postIndex < 0 { 1857 return ErrInvalidLengthNode 1858 } 1859 if postIndex > l { 1860 return io.ErrUnexpectedEOF 1861 } 1862 if err := m.Connect.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1863 return err 1864 } 1865 iNdEx = postIndex 1866 case 13: 1867 if wireType != 0 { 1868 return fmt.Errorf("proto: wrong wireType = %d for field LocallyRegisteredAsSidecar", wireType) 1869 } 1870 var v int 1871 for shift := uint(0); ; shift += 7 { 1872 if shift >= 64 { 1873 return ErrIntOverflowNode 1874 } 1875 if iNdEx >= l { 1876 return io.ErrUnexpectedEOF 1877 } 1878 b := dAtA[iNdEx] 1879 iNdEx++ 1880 v |= int(b&0x7F) << shift 1881 if b < 0x80 { 1882 break 1883 } 1884 } 1885 m.LocallyRegisteredAsSidecar = bool(v != 0) 1886 case 14: 1887 if wireType != 2 { 1888 return fmt.Errorf("proto: wrong wireType = %d for field RaftIndex", wireType) 1889 } 1890 var msglen int 1891 for shift := uint(0); ; shift += 7 { 1892 if shift >= 64 { 1893 return ErrIntOverflowNode 1894 } 1895 if iNdEx >= l { 1896 return io.ErrUnexpectedEOF 1897 } 1898 b := dAtA[iNdEx] 1899 iNdEx++ 1900 msglen |= int(b&0x7F) << shift 1901 if b < 0x80 { 1902 break 1903 } 1904 } 1905 if msglen < 0 { 1906 return ErrInvalidLengthNode 1907 } 1908 postIndex := iNdEx + msglen 1909 if postIndex < 0 { 1910 return ErrInvalidLengthNode 1911 } 1912 if postIndex > l { 1913 return io.ErrUnexpectedEOF 1914 } 1915 if err := m.RaftIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1916 return err 1917 } 1918 iNdEx = postIndex 1919 case 15: 1920 if wireType != 2 { 1921 return fmt.Errorf("proto: wrong wireType = %d for field TaggedAddresses", wireType) 1922 } 1923 var msglen int 1924 for shift := uint(0); ; shift += 7 { 1925 if shift >= 64 { 1926 return ErrIntOverflowNode 1927 } 1928 if iNdEx >= l { 1929 return io.ErrUnexpectedEOF 1930 } 1931 b := dAtA[iNdEx] 1932 iNdEx++ 1933 msglen |= int(b&0x7F) << shift 1934 if b < 0x80 { 1935 break 1936 } 1937 } 1938 if msglen < 0 { 1939 return ErrInvalidLengthNode 1940 } 1941 postIndex := iNdEx + msglen 1942 if postIndex < 0 { 1943 return ErrInvalidLengthNode 1944 } 1945 if postIndex > l { 1946 return io.ErrUnexpectedEOF 1947 } 1948 if m.TaggedAddresses == nil { 1949 m.TaggedAddresses = make(map[string]ServiceAddress) 1950 } 1951 var mapkey string 1952 mapvalue := &ServiceAddress{} 1953 for iNdEx < postIndex { 1954 entryPreIndex := iNdEx 1955 var wire uint64 1956 for shift := uint(0); ; shift += 7 { 1957 if shift >= 64 { 1958 return ErrIntOverflowNode 1959 } 1960 if iNdEx >= l { 1961 return io.ErrUnexpectedEOF 1962 } 1963 b := dAtA[iNdEx] 1964 iNdEx++ 1965 wire |= uint64(b&0x7F) << shift 1966 if b < 0x80 { 1967 break 1968 } 1969 } 1970 fieldNum := int32(wire >> 3) 1971 if fieldNum == 1 { 1972 var stringLenmapkey uint64 1973 for shift := uint(0); ; shift += 7 { 1974 if shift >= 64 { 1975 return ErrIntOverflowNode 1976 } 1977 if iNdEx >= l { 1978 return io.ErrUnexpectedEOF 1979 } 1980 b := dAtA[iNdEx] 1981 iNdEx++ 1982 stringLenmapkey |= uint64(b&0x7F) << shift 1983 if b < 0x80 { 1984 break 1985 } 1986 } 1987 intStringLenmapkey := int(stringLenmapkey) 1988 if intStringLenmapkey < 0 { 1989 return ErrInvalidLengthNode 1990 } 1991 postStringIndexmapkey := iNdEx + intStringLenmapkey 1992 if postStringIndexmapkey < 0 { 1993 return ErrInvalidLengthNode 1994 } 1995 if postStringIndexmapkey > l { 1996 return io.ErrUnexpectedEOF 1997 } 1998 mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) 1999 iNdEx = postStringIndexmapkey 2000 } else if fieldNum == 2 { 2001 var mapmsglen int 2002 for shift := uint(0); ; shift += 7 { 2003 if shift >= 64 { 2004 return ErrIntOverflowNode 2005 } 2006 if iNdEx >= l { 2007 return io.ErrUnexpectedEOF 2008 } 2009 b := dAtA[iNdEx] 2010 iNdEx++ 2011 mapmsglen |= int(b&0x7F) << shift 2012 if b < 0x80 { 2013 break 2014 } 2015 } 2016 if mapmsglen < 0 { 2017 return ErrInvalidLengthNode 2018 } 2019 postmsgIndex := iNdEx + mapmsglen 2020 if postmsgIndex < 0 { 2021 return ErrInvalidLengthNode 2022 } 2023 if postmsgIndex > l { 2024 return io.ErrUnexpectedEOF 2025 } 2026 mapvalue = &ServiceAddress{} 2027 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { 2028 return err 2029 } 2030 iNdEx = postmsgIndex 2031 } else { 2032 iNdEx = entryPreIndex 2033 skippy, err := skipNode(dAtA[iNdEx:]) 2034 if err != nil { 2035 return err 2036 } 2037 if (skippy < 0) || (iNdEx+skippy) < 0 { 2038 return ErrInvalidLengthNode 2039 } 2040 if (iNdEx + skippy) > postIndex { 2041 return io.ErrUnexpectedEOF 2042 } 2043 iNdEx += skippy 2044 } 2045 } 2046 m.TaggedAddresses[mapkey] = *mapvalue 2047 iNdEx = postIndex 2048 case 16: 2049 if wireType != 2 { 2050 return fmt.Errorf("proto: wrong wireType = %d for field EnterpriseMeta", wireType) 2051 } 2052 var msglen int 2053 for shift := uint(0); ; shift += 7 { 2054 if shift >= 64 { 2055 return ErrIntOverflowNode 2056 } 2057 if iNdEx >= l { 2058 return io.ErrUnexpectedEOF 2059 } 2060 b := dAtA[iNdEx] 2061 iNdEx++ 2062 msglen |= int(b&0x7F) << shift 2063 if b < 0x80 { 2064 break 2065 } 2066 } 2067 if msglen < 0 { 2068 return ErrInvalidLengthNode 2069 } 2070 postIndex := iNdEx + msglen 2071 if postIndex < 0 { 2072 return ErrInvalidLengthNode 2073 } 2074 if postIndex > l { 2075 return io.ErrUnexpectedEOF 2076 } 2077 if err := m.EnterpriseMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 2078 return err 2079 } 2080 iNdEx = postIndex 2081 case 17: 2082 if wireType != 2 { 2083 return fmt.Errorf("proto: wrong wireType = %d for field SocketPath", wireType) 2084 } 2085 var stringLen uint64 2086 for shift := uint(0); ; shift += 7 { 2087 if shift >= 64 { 2088 return ErrIntOverflowNode 2089 } 2090 if iNdEx >= l { 2091 return io.ErrUnexpectedEOF 2092 } 2093 b := dAtA[iNdEx] 2094 iNdEx++ 2095 stringLen |= uint64(b&0x7F) << shift 2096 if b < 0x80 { 2097 break 2098 } 2099 } 2100 intStringLen := int(stringLen) 2101 if intStringLen < 0 { 2102 return ErrInvalidLengthNode 2103 } 2104 postIndex := iNdEx + intStringLen 2105 if postIndex < 0 { 2106 return ErrInvalidLengthNode 2107 } 2108 if postIndex > l { 2109 return io.ErrUnexpectedEOF 2110 } 2111 m.SocketPath = string(dAtA[iNdEx:postIndex]) 2112 iNdEx = postIndex 2113 default: 2114 iNdEx = preIndex 2115 skippy, err := skipNode(dAtA[iNdEx:]) 2116 if err != nil { 2117 return err 2118 } 2119 if (skippy < 0) || (iNdEx+skippy) < 0 { 2120 return ErrInvalidLengthNode 2121 } 2122 if (iNdEx + skippy) > l { 2123 return io.ErrUnexpectedEOF 2124 } 2125 iNdEx += skippy 2126 } 2127 } 2128 2129 if iNdEx > l { 2130 return io.ErrUnexpectedEOF 2131 } 2132 return nil 2133} 2134func skipNode(dAtA []byte) (n int, err error) { 2135 l := len(dAtA) 2136 iNdEx := 0 2137 depth := 0 2138 for iNdEx < l { 2139 var wire uint64 2140 for shift := uint(0); ; shift += 7 { 2141 if shift >= 64 { 2142 return 0, ErrIntOverflowNode 2143 } 2144 if iNdEx >= l { 2145 return 0, io.ErrUnexpectedEOF 2146 } 2147 b := dAtA[iNdEx] 2148 iNdEx++ 2149 wire |= (uint64(b) & 0x7F) << shift 2150 if b < 0x80 { 2151 break 2152 } 2153 } 2154 wireType := int(wire & 0x7) 2155 switch wireType { 2156 case 0: 2157 for shift := uint(0); ; shift += 7 { 2158 if shift >= 64 { 2159 return 0, ErrIntOverflowNode 2160 } 2161 if iNdEx >= l { 2162 return 0, io.ErrUnexpectedEOF 2163 } 2164 iNdEx++ 2165 if dAtA[iNdEx-1] < 0x80 { 2166 break 2167 } 2168 } 2169 case 1: 2170 iNdEx += 8 2171 case 2: 2172 var length int 2173 for shift := uint(0); ; shift += 7 { 2174 if shift >= 64 { 2175 return 0, ErrIntOverflowNode 2176 } 2177 if iNdEx >= l { 2178 return 0, io.ErrUnexpectedEOF 2179 } 2180 b := dAtA[iNdEx] 2181 iNdEx++ 2182 length |= (int(b) & 0x7F) << shift 2183 if b < 0x80 { 2184 break 2185 } 2186 } 2187 if length < 0 { 2188 return 0, ErrInvalidLengthNode 2189 } 2190 iNdEx += length 2191 case 3: 2192 depth++ 2193 case 4: 2194 if depth == 0 { 2195 return 0, ErrUnexpectedEndOfGroupNode 2196 } 2197 depth-- 2198 case 5: 2199 iNdEx += 4 2200 default: 2201 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 2202 } 2203 if iNdEx < 0 { 2204 return 0, ErrInvalidLengthNode 2205 } 2206 if depth == 0 { 2207 return iNdEx, nil 2208 } 2209 } 2210 return 0, io.ErrUnexpectedEOF 2211} 2212 2213var ( 2214 ErrInvalidLengthNode = fmt.Errorf("proto: negative length found during unmarshaling") 2215 ErrIntOverflowNode = fmt.Errorf("proto: integer overflow") 2216 ErrUnexpectedEndOfGroupNode = fmt.Errorf("proto: unexpected end of group") 2217) 2218