kotovalexarian-likes-github/moby--moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
Code Releases Activity

Vendor commit for VXLAN UDP Port configuration support

Browse source 
This commit brings Swarmkit and Libnetwork library changes
Signed-off-by: selansen <elango.siva@docker.com>
This commit is contained in:
selansen 2018-11-20 16:48:47 -05:00
parent c58cd154f5
commit a7ce3140f5
16 changed files with 304 additions and 131 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
vendor.conf
View file

@ -37,7 +37,7 @@ github.com/mitchellh/hashstructure 2bca23e0e452137f789efbc8610126fd8b94f73b
#get libnetwork packages
# When updating, also update LIBNETWORK_COMMIT in hack/dockerfile/install/proxy.installer accordingly
github.com/docker/libnetwork 49627167f0585504fd78ed8827529aec57a9618d
github.com/docker/libnetwork 1f28166bb386cf9223d2d00a28382b0e474be314
github.com/docker/go-events 9461782956ad83b30282bf90e31fa6a70c255ba9
github.com/armon/go-radix e39d623f12e8e41c7b5529e9a9dd67a1e2261f80
github.com/armon/go-metrics eb0af217e5e9747e41dd5303755356b62d28e3ec
@ -130,7 +130,7 @@ github.com/containerd/ttrpc 2a805f71863501300ae1976d29f0454ae003e85a
github.com/gogo/googleapis 08a7655d27152912db7aaf4f983275eaf8d128ef
# cluster
github.com/docker/swarmkit bc032e24784ea618044ee438fedec3458abb2ef9
github.com/docker/swarmkit 8af8c420f491f006ab1730e08d446a795b1667d7
github.com/gogo/protobuf v1.0.0
github.com/cloudflare/cfssl 1.3.2
github.com/fernet/fernet-go 1b2437bc582b3cfbb341ee5a29f8ef5b42912ff2

5
vendor/github.com/docker/libnetwork/drivers/overlay/encryption.go generated vendored
View file

@ -12,6 +12,7 @@ import (
"strconv"
"github.com/docker/libnetwork/drivers/overlay/overlayutils"
"github.com/docker/libnetwork/iptables"
"github.com/docker/libnetwork/ns"
"github.com/docker/libnetwork/types"
@ -200,7 +201,7 @@ func removeEncryption(localIP, remoteIP net.IP, em *encrMap) error {
func programMangle(vni uint32, add bool) (err error) {
var (
p = strconv.FormatUint(uint64(vxlanPort), 10)
p = strconv.FormatUint(uint64(overlayutils.VXLANUDPPort()), 10)
c = fmt.Sprintf("0>>22&0x3C@12&0xFFFFFF00=%d", int(vni)<<8)
m = strconv.FormatUint(uint64(r), 10)
chain = "OUTPUT"
@ -227,7 +228,7 @@ func programMangle(vni uint32, add bool) (err error) {
func programInput(vni uint32, add bool) (err error) {
var (
port = strconv.FormatUint(uint64(vxlanPort), 10)
port = strconv.FormatUint(uint64(overlayutils.VXLANUDPPort()), 10)
vniMatch = fmt.Sprintf("0>>22&0x3C@12&0xFFFFFF00=%d", int(vni)<<8)
plainVxlan = []string{"-p", "udp", "--dport", port, "-m", "u32", "--u32", vniMatch, "-j"}
ipsecVxlan = append([]string{"-m", "policy", "--dir", "in", "--pol", "ipsec"}, plainVxlan...)

3
vendor/github.com/docker/libnetwork/drivers/overlay/ov_utils.go generated vendored
View file

@ -5,6 +5,7 @@ import (
"strings"
"syscall"
"github.com/docker/libnetwork/drivers/overlay/overlayutils"
"github.com/docker/libnetwork/netutils"
"github.com/docker/libnetwork/ns"
"github.com/docker/libnetwork/osl"
@ -61,7 +62,7 @@ func createVxlan(name string, vni uint32, mtu int) error {
LinkAttrs: netlink.LinkAttrs{Name: name, MTU: mtu},
VxlanId: int(vni),
Learning: true,
Port: vxlanPort,
Port: int(overlayutils.VXLANUDPPort()),
Proxy: true,
L3miss: true,
L2miss: true,

1
vendor/github.com/docker/libnetwork/drivers/overlay/overlay.go generated vendored
View file

@ -25,7 +25,6 @@ const (
vethLen = 7
vxlanIDStart = 256
vxlanIDEnd = (1 << 24) - 1
vxlanPort = 4789
vxlanEncap = 50
secureOption = "encrypted"
)

46
vendor/github.com/docker/libnetwork/drivers/overlay/overlayutils/utils.go generated vendored Normal file
View file

@ -0,0 +1,46 @@
// Package overlayutils provides utility functions for overlay networks
package overlayutils
import (
"fmt"
"sync"
)
var (
vxlanUDPPort uint32
mutex sync.Mutex
)
const defaultVXLANUDPPort = 4789
func init() {
vxlanUDPPort = defaultVXLANUDPPort
}
// ConfigVXLANUDPPort configures vxlan udp port number.
func ConfigVXLANUDPPort(vxlanPort uint32) error {
mutex.Lock()
defer mutex.Unlock()
// if the value comes as 0 by any reason we set it to default value 4789
if vxlanPort == 0 {
vxlanPort = defaultVXLANUDPPort
}
// IANA procedures for each range in detail
// The Well Known Ports, aka the System Ports, from 0-1023
// The Registered Ports, aka the User Ports, from 1024-49151
// The Dynamic Ports, aka the Private Ports, from 49152-65535
// So we can allow range between 1024 to 49151
if vxlanPort < 1024 || vxlanPort > 49151 {
return fmt.Errorf("ConfigVxlanUDPPort Vxlan UDP port number is not in valid range %d", vxlanPort)
}
vxlanUDPPort = vxlanPort
return nil
}
// VXLANUDPPort returns Vxlan UDP port number
func VXLANUDPPort() uint32 {
mutex.Lock()
defer mutex.Unlock()
return vxlanUDPPort
}

267
vendor/github.com/docker/swarmkit/api/objects.pb.go generated vendored
View file

@ -75,6 +75,9 @@ type Node struct {
// endpoint on the node to be used for load balancing. Each overlay
// network, including ingress network, will have an NetworkAttachment.
Attachments []*NetworkAttachment `protobuf:"bytes,10,rep,name=attachments" json:"attachments,omitempty"`
// VXLANUDPPort specifies the UDP port for VXLAN traffic.
// This information is passed from cluster object to individual nodes.
VXLANUDPPort uint32 `protobuf:"varint,11,opt,name=VXLANUDPPort,proto3" json:"VXLANUDPPort,omitempty"`
}
func (m *Node) Reset() { *m = Node{} }
@ -303,6 +306,8 @@ type Cluster struct {
// This flag specifies the default subnet size of global scope networks by giving
// the length of the subnet masks for every such network
SubnetSize uint32 `protobuf:"varint,12,opt,name=subnetSize,proto3" json:"subnetSize,omitempty"`
// VXLANUDPPort specifies the UDP port for VXLAN traffic.
VXLANUDPPort uint32 `protobuf:"varint,13,opt,name=VXLANUDPPort,proto3" json:"VXLANUDPPort,omitempty"`
}
func (m *Cluster) Reset() { *m = Cluster{} }
@ -912,6 +917,11 @@ func (m *Node) MarshalTo(dAtA []byte) (int, error) {
i += n
}
}
if m.VXLANUDPPort != 0 {
dAtA[i] = 0x58
i++
i = encodeVarintObjects(dAtA, i, uint64(m.VXLANUDPPort))
}
return i, nil
}
@ -1514,6 +1524,11 @@ func (m *Cluster) MarshalTo(dAtA []byte) (int, error) {
i++
i = encodeVarintObjects(dAtA, i, uint64(m.SubnetSize))
}
if m.VXLANUDPPort != 0 {
dAtA[i] = 0x68
i++
i = encodeVarintObjects(dAtA, i, uint64(m.VXLANUDPPort))
}
return i, nil
}
@ -1771,6 +1786,9 @@ func (m *Node) Size() (n int) {
n += 1 + l + sovObjects(uint64(l))
}
}
if m.VXLANUDPPort != 0 {
n += 1 + sovObjects(uint64(m.VXLANUDPPort))
}
return n
}
@ -2013,6 +2031,9 @@ func (m *Cluster) Size() (n int) {
if m.SubnetSize != 0 {
n += 1 + sovObjects(uint64(m.SubnetSize))
}
if m.VXLANUDPPort != 0 {
n += 1 + sovObjects(uint64(m.VXLANUDPPort))
}
return n
}
@ -4764,6 +4785,7 @@ func (this *Node) String() string {
`Certificate:` + strings.Replace(strings.Replace(this.Certificate.String(), "Certificate", "Certificate", 1), `&`, ``, 1) + `,`,
`Role:` + fmt.Sprintf("%v", this.Role) + `,`,
`Attachments:` + strings.Replace(fmt.Sprintf("%v", this.Attachments), "NetworkAttachment", "NetworkAttachment", 1) + `,`,
`VXLANUDPPort:` + fmt.Sprintf("%v", this.VXLANUDPPort) + `,`,
`}`,
}, "")
return s
@ -4897,6 +4919,7 @@ func (this *Cluster) String() string {
`FIPS:` + fmt.Sprintf("%v", this.FIPS) + `,`,
`DefaultAddressPool:` + fmt.Sprintf("%v", this.DefaultAddressPool) + `,`,
`SubnetSize:` + fmt.Sprintf("%v", this.SubnetSize) + `,`,
`VXLANUDPPort:` + fmt.Sprintf("%v", this.VXLANUDPPort) + `,`,
`}`,
}, "")
return s
@ -5434,6 +5457,25 @@ func (m *Node) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 11:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field VXLANUDPPort", wireType)
}
m.VXLANUDPPort = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowObjects
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.VXLANUDPPort |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipObjects(dAtA[iNdEx:])
@ -7422,6 +7464,25 @@ func (m *Cluster) Unmarshal(dAtA []byte) error {
break
}
}
case 13:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field VXLANUDPPort", wireType)
}
m.VXLANUDPPort = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowObjects
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.VXLANUDPPort |= (uint32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipObjects(dAtA[iNdEx:])
@ -8218,106 +8279,108 @@ var (
func init() { proto.RegisterFile("github.com/docker/swarmkit/api/objects.proto", fileDescriptorObjects) }
var fileDescriptorObjects = []byte{
// 1610 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x73, 0x1b, 0x49,
0x15, 0xcf, 0xc8, 0x63, 0x7d, 0x3c, 0x59, 0xc2, 0xf4, 0x1a, 0x33, 0x11, 0x46, 0x32, 0xda, 0x5a,
0x6a, 0x6b, 0x2b, 0x25, 0x2f, 0x66, 0x01, 0xc7, 0xb0, 0x6c, 0x24, 0xdb, 0x24, 0xaa, 0x10, 0xe2,
0x6a, 0x87, 0x84, 0xdb, 0xd0, 0x9a, 0x69, 0x2b, 0x83, 0x46, 0xd3, 0x53, 0xd3, 0x2d, 0x05, 0x71,
0xca, 0xd9, 0xfc, 0x01, 0xbe, 0x71, 0x80, 0xbf, 0x82, 0x0b, 0x07, 0x4e, 0xe1, 0xc6, 0x89, 0xe2,
0xe4, 0x22, 0xfa, 0x2f, 0xb8, 0x51, 0xdd, 0xd3, 0x23, 0x8d, 0xad, 0xf1, 0x17, 0x95, 0x72, 0xed,
0xc9, 0xfd, 0xf1, 0xfb, 0xbd, 0x7e, 0xef, 0xcd, 0xfb, 0xb2, 0xe0, 0x41, 0xdf, 0x13, 0xaf, 0x47,
0xbd, 0x96, 0xc3, 0x86, 0x5b, 0x2e, 0x73, 0x06, 0x34, 0xda, 0xe2, 0x6f, 0x48, 0x34, 0x1c, 0x78,
0x62, 0x8b, 0x84, 0xde, 0x16, 0xeb, 0xfd, 0x8e, 0x3a, 0x82, 0xb7, 0xc2, 0x88, 0x09, 0x86, 0x50,
0x0c, 0x69, 0x25, 0x90, 0xd6, 0xf8, 0x07, 0xb5, 0xcf, 0xae, 0x91, 0x20, 0x26, 0x21, 0xd5, 0xfc,
0x6b, 0xb1, 0x3c, 0xa4, 0x4e, 0x82, 0x6d, 0xf4, 0x19, 0xeb, 0xfb, 0x74, 0x4b, 0xed, 0x7a, 0xa3,
0xe3, 0x2d, 0xe1, 0x0d, 0x29, 0x17, 0x64, 0x18, 0x6a, 0xc0, 0x5a, 0x9f, 0xf5, 0x99, 0x5a, 0x6e,
0xc9, 0x95, 0x3e, 0xbd, 0x7f, 0x91, 0x46, 0x82, 0x89, 0xbe, 0xfa, 0xc9, 0x15, 0xaf, 0xcf, 0xe0,
0xa1, 0x3f, 0xea, 0x7b, 0x81, 0xfe, 0x13, 0x13, 0x9b, 0x7f, 0x35, 0xc0, 0x7c, 0x46, 0x05, 0x41,
0x3f, 0x85, 0xc2, 0x98, 0x46, 0xdc, 0x63, 0x81, 0x65, 0x6c, 0x1a, 0x9f, 0x96, 0xb7, 0xbf, 0xd3,
0x5a, 0xf4, 0x48, 0xeb, 0x65, 0x0c, 0xe9, 0x98, 0xef, 0xce, 0x1a, 0xf7, 0x70, 0xc2, 0x40, 0x0f,
0x01, 0x9c, 0x88, 0x12, 0x41, 0x5d, 0x9b, 0x08, 0x2b, 0xa7, 0xf8, 0xb5, 0x56, 0xac, 0x6e, 0x2b,
0x79, 0xbf, 0xf5, 0x22, 0xb1, 0x12, 0x97, 0x34, 0xba, 0x2d, 0x24, 0x75, 0x14, 0xba, 0x09, 0x75,
0xe9, 0x7a, 0xaa, 0x46, 0xb7, 0x45, 0xf3, 0xed, 0x32, 0x98, 0xbf, 0x62, 0x2e, 0x45, 0xeb, 0x90,
0xf3, 0x5c, 0xa5, 0x76, 0xa9, 0x93, 0x9f, 0x9e, 0x35, 0x72, 0xdd, 0x7d, 0x9c, 0xf3, 0x5c, 0xb4,
0x0d, 0xe6, 0x90, 0x0a, 0xa2, 0x15, 0xb2, 0xb2, 0x0c, 0x92, 0xb6, 0x6b, 0x6b, 0x14, 0x16, 0xfd,
0x18, 0x4c, 0xf9, 0xa9, 0xb4, 0x26, 0x1b, 0x59, 0x1c, 0xf9, 0xe6, 0x51, 0x48, 0x9d, 0x84, 0x27,
0xf1, 0xe8, 0x00, 0xca, 0x2e, 0xe5, 0x4e, 0xe4, 0x85, 0x42, 0xfa, 0xd0, 0x54, 0xf4, 0x8f, 0x2f,
0xa3, 0xef, 0xcf, 0xa1, 0x38, 0xcd, 0x43, 0x3f, 0x83, 0x3c, 0x17, 0x44, 0x8c, 0xb8, 0xb5, 0xac,
0x24, 0xd4, 0x2f, 0x55, 0x40, 0xa1, 0xb4, 0x0a, 0x9a, 0x83, 0x9e, 0x40, 0x75, 0x48, 0x02, 0xd2,
0xa7, 0x91, 0xad, 0xa5, 0xe4, 0x95, 0x94, 0xef, 0x65, 0x9a, 0x1e, 0x23, 0x63, 0x41, 0xb8, 0x32,
0x4c, 0x6f, 0x51, 0x17, 0x80, 0x08, 0x41, 0x9c, 0xd7, 0x43, 0x1a, 0x08, 0xab, 0xa0, 0xa4, 0x7c,
0x92, 0xa9, 0x0b, 0x15, 0x6f, 0x58, 0x34, 0x68, 0xcf, 0xc0, 0x9d, 0x9c, 0x65, 0xe0, 0x14, 0x19,
0x3d, 0x86, 0xb2, 0x43, 0x23, 0xe1, 0x1d, 0x7b, 0x0e, 0x11, 0xd4, 0x2a, 0x2a, 0x59, 0x8d, 0x2c,
0x59, 0x7b, 0x73, 0x98, 0x36, 0x2c, 0xcd, 0x44, 0x9f, 0x83, 0x19, 0x31, 0x9f, 0x5a, 0xa5, 0x4d,
0xe3, 0xd3, 0xea, 0xe5, 0x9f, 0x06, 0x33, 0x9f, 0x62, 0x85, 0x94, 0x4f, 0xcf, 0x15, 0xe1, 0x16,
0x6c, 0x2e, 0xdd, 0xd8, 0x0c, 0x9c, 0x66, 0xee, 0xae, 0x9f, 0x9c, 0x36, 0x11, 0xac, 0x16, 0x8d,
0x55, 0x43, 0xc5, 0x99, 0xf1, 0xb9, 0xf1, 0x1b, 0xe3, 0xb7, 0x46, 0xf3, 0x2f, 0x26, 0x14, 0x8e,
0x68, 0x34, 0xf6, 0x9c, 0x0f, 0x1b, 0x85, 0x0f, 0xcf, 0x45, 0x61, 0xa6, 0xb3, 0xf4, 0xb3, 0x0b,
0x81, 0xb8, 0x03, 0x45, 0x1a, 0xb8, 0x21, 0xf3, 0x02, 0xa1, 0xa3, 0x30, 0xd3, 0x53, 0x07, 0x1a,
0x83, 0x67, 0x68, 0x74, 0x00, 0x95, 0x38, 0xb9, 0xec, 0x73, 0x21, 0xb8, 0x99, 0x45, 0xff, 0xb5,
0x02, 0xea, 0xd8, 0x59, 0x19, 0xa5, 0x76, 0x68, 0x1f, 0x2a, 0x61, 0x44, 0xc7, 0x1e, 0x1b, 0x71,
0x5b, 0x19, 0x91, 0xbf, 0x91, 0x11, 0x78, 0x25, 0x61, 0xc9, 0x1d, 0xfa, 0x04, 0xaa, 0x21, 0x0d,
0x5c, 0x2f, 0xe8, 0xdb, 0x2e, 0xf5, 0xa9, 0xa0, 0x2a, 0x08, 0x8b, 0xb8, 0xa2, 0x4f, 0xf7, 0xd5,
0x21, 0xfa, 0x39, 0xac, 0xc8, 0x37, 0xec, 0xa4, 0x76, 0xc1, 0xb5, 0xb5, 0x0b, 0x97, 0x25, 0x41,
0x6f, 0xd0, 0x73, 0xf8, 0xd6, 0x39, 0x65, 0x67, 0x82, 0xca, 0xd7, 0x0b, 0xfa, 0x28, 0xad, 0xb0,
0x3e, 0xdc, 0x45, 0x27, 0xa7, 0xcd, 0x2a, 0xac, 0xa4, 0x23, 0xa5, 0xf9, 0xa7, 0x1c, 0x14, 0x13,
0x7f, 0xa3, 0x2f, 0xf4, 0xa7, 0x35, 0x2e, 0x77, 0x6e, 0x82, 0x55, 0x6e, 0x89, 0xbf, 0xea, 0x17,
0xb0, 0x1c, 0xb2, 0x48, 0x70, 0x2b, 0xa7, 0x62, 0x38, 0xb3, 0x2c, 0x1c, 0xb2, 0x48, 0xec, 0xb1,
0xe0, 0xd8, 0xeb, 0xe3, 0x18, 0x8c, 0x5e, 0x41, 0x79, 0xec, 0x45, 0x62, 0x44, 0x7c, 0xdb, 0x0b,
0xb9, 0xb5, 0xa4, 0xb8, 0xdf, 0xbf, 0xea, 0xc9, 0xd6, 0xcb, 0x18, 0xdf, 0x3d, 0xec, 0x54, 0xa7,
0x67, 0x0d, 0x98, 0x6d, 0x39, 0x06, 0x2d, 0xaa, 0x1b, 0xf2, 0xda, 0x33, 0x28, 0xcd, 0x6e, 0xd0,
0x03, 0x80, 0x20, 0x4e, 0x1f, 0x7b, 0x96, 0x00, 0x95, 0xe9, 0x59, 0xa3, 0xa4, 0x93, 0xaa, 0xbb,
0x8f, 0x4b, 0x1a, 0xd0, 0x75, 0x11, 0x02, 0x93, 0xb8, 0x6e, 0xa4, 0xd2, 0xa1, 0x84, 0xd5, 0xba,
0xf9, 0xc7, 0x02, 0x98, 0x2f, 0x08, 0x1f, 0xdc, 0x75, 0x25, 0x97, 0x6f, 0x2e, 0x24, 0xd0, 0x03,
0x00, 0x1e, 0x87, 0xa5, 0x34, 0xc7, 0x9c, 0x9b, 0xa3, 0x83, 0x55, 0x9a, 0xa3, 0x01, 0xb1, 0x39,
0xdc, 0x67, 0x42, 0xe5, 0x8a, 0x89, 0xd5, 0x1a, 0x7d, 0x0c, 0x85, 0x80, 0xb9, 0x8a, 0x9e, 0x57,
0x74, 0x98, 0x9e, 0x35, 0xf2, 0xb2, 0x36, 0x75, 0xf7, 0x71, 0x5e, 0x5e, 0x75, 0x5d, 0x55, 0x9b,
0x82, 0x80, 0x09, 0x22, 0xeb, 0x3e, 0xd7, 0x25, 0x36, 0x33, 0x49, 0xda, 0x73, 0x58, 0x52, 0x16,
0x53, 0x4c, 0xf4, 0x12, 0x3e, 0x4a, 0xf4, 0x4d, 0x0b, 0x2c, 0xde, 0x46, 0x20, 0xd2, 0x12, 0x52,
0x37, 0xa9, 0x56, 0x54, 0xba, 0xbc, 0x15, 0x29, 0x0f, 0x66, 0xb5, 0xa2, 0x0e, 0x54, 0x5c, 0xca,
0xbd, 0x88, 0xba, 0xaa, 0x9a, 0x50, 0x95, 0x99, 0xd5, 0xed, 0xef, 0x5e, 0x25, 0x84, 0xe2, 0x15,
0xcd, 0x51, 0x3b, 0xd4, 0x86, 0xa2, 0x8e, 0x1b, 0x6e, 0x95, 0x6f, 0x53, 0xbb, 0x67, 0xb4, 0x73,
0xd5, 0x70, 0xe5, 0x56, 0xd5, 0xf0, 0x21, 0x80, 0xcf, 0xfa, 0xb6, 0x1b, 0x79, 0x63, 0x1a, 0x59,
0x15, 0x3d, 0x98, 0x64, 0x70, 0xf7, 0x15, 0x02, 0x97, 0x7c, 0xd6, 0x8f, 0x97, 0x0b, 0x45, 0xa9,
0x7a, 0xcb, 0xa2, 0x44, 0xa0, 0x46, 0x38, 0xf7, 0xfa, 0x01, 0x75, 0xed, 0x3e, 0x0d, 0x68, 0xe4,
0x39, 0x76, 0x44, 0x39, 0x1b, 0x45, 0x0e, 0xe5, 0xd6, 0x37, 0x94, 0x27, 0x32, 0x47, 0x8b, 0xc7,
0x31, 0x18, 0x6b, 0x2c, 0xb6, 0x12, 0x31, 0x17, 0x2e, 0xf8, 0x6e, 0xed, 0xe4, 0xb4, 0xb9, 0x0e,
0x6b, 0xe9, 0x32, 0xb5, 0x63, 0x3c, 0x32, 0x9e, 0x18, 0x87, 0x46, 0xf3, 0xef, 0x39, 0xf8, 0xe6,
0x82, 0x4f, 0xd1, 0x8f, 0xa0, 0xa0, 0xbd, 0x7a, 0xd5, 0x80, 0xa8, 0x79, 0x38, 0xc1, 0xa2, 0x0d,
0x28, 0xc9, 0x14, 0xa7, 0x9c, 0xd3, 0xb8, 0x78, 0x95, 0xf0, 0xfc, 0x00, 0x59, 0x50, 0x20, 0xbe,
0x47, 0xe4, 0xdd, 0x92, 0xba, 0x4b, 0xb6, 0x68, 0x04, 0xeb, 0xb1, 0xeb, 0xed, 0x79, 0x1f, 0xb6,
0x59, 0x28, 0xb8, 0x65, 0x2a, 0xfb, 0xbf, 0xba, 0x51, 0x24, 0xe8, 0x8f, 0x33, 0x3f, 0x78, 0x1e,
0x0a, 0x7e, 0x10, 0x88, 0x68, 0x82, 0xd7, 0xdc, 0x8c, 0xab, 0xda, 0x63, 0xb8, 0x7f, 0x29, 0x05,
0xad, 0xc2, 0xd2, 0x80, 0x4e, 0xe2, 0xf2, 0x84, 0xe5, 0x12, 0xad, 0xc1, 0xf2, 0x98, 0xf8, 0x23,
0xaa, 0xab, 0x59, 0xbc, 0xd9, 0xcd, 0xed, 0x18, 0xcd, 0x7f, 0xe4, 0xa0, 0xa0, 0xd5, 0xb9, 0xeb,
0xc9, 0x40, 0x3f, 0xbb, 0x50, 0xd8, 0xbe, 0x84, 0x15, 0xed, 0xd2, 0x38, 0x23, 0xcd, 0x6b, 0x63,
0xba, 0x1c, 0xe3, 0xe3, 0x6c, 0xfc, 0x12, 0x4c, 0x2f, 0x24, 0x43, 0x3d, 0x15, 0x64, 0xbe, 0xdc,
0x3d, 0x6c, 0x3f, 0x7b, 0x1e, 0xc6, 0x85, 0xa5, 0x38, 0x3d, 0x6b, 0x98, 0xf2, 0x00, 0x2b, 0x5a,
0x46, 0x43, 0xcf, 0x67, 0x34, 0xf4, 0xcc, 0xfe, 0xf9, 0xe7, 0x3c, 0x14, 0xf6, 0xfc, 0x11, 0x17,
0x34, 0xba, 0x6b, 0x5f, 0xea, 0x67, 0x17, 0x7c, 0xb9, 0x07, 0x85, 0x88, 0x31, 0x61, 0x3b, 0xe4,
0x2a, 0x37, 0x62, 0xc6, 0xc4, 0x5e, 0xbb, 0x53, 0x95, 0x44, 0xd9, 0x02, 0xe2, 0x3d, 0xce, 0x4b,
0xea, 0x1e, 0x41, 0xaf, 0x60, 0x3d, 0x69, 0x9c, 0x3d, 0xc6, 0x04, 0x17, 0x11, 0x09, 0xed, 0x01,
0x9d, 0xc8, 0xc9, 0x6b, 0xe9, 0xb2, 0xb1, 0xfd, 0x20, 0x70, 0xa2, 0x89, 0xf2, 0xf1, 0x53, 0x3a,
0xc1, 0x6b, 0x5a, 0x40, 0x27, 0xe1, 0x3f, 0xa5, 0x13, 0x8e, 0xbe, 0x82, 0x0d, 0x3a, 0x83, 0x49,
0x89, 0xb6, 0x4f, 0x86, 0x72, 0x24, 0xb0, 0x1d, 0x9f, 0x39, 0x03, 0xe5, 0x79, 0x13, 0xdf, 0xa7,
0x69, 0x51, 0xbf, 0x8c, 0x11, 0x7b, 0x12, 0x80, 0x38, 0x58, 0x3d, 0x9f, 0x38, 0x03, 0xdf, 0xe3,
0xf2, 0x3f, 0xb3, 0xd4, 0x14, 0x2e, 0x1b, 0x8b, 0xd4, 0x6d, 0xe7, 0x0a, 0x6f, 0xb5, 0x3a, 0x73,
0x6e, 0x6a, 0xa6, 0xd7, 0x89, 0xf7, 0xed, 0x5e, 0xf6, 0x2d, 0xea, 0x40, 0x79, 0x14, 0xc8, 0xe7,
0x63, 0x1f, 0x94, 0x6e, 0xea, 0x03, 0x88, 0x59, 0xca, 0xf2, 0x0d, 0x30, 0x8f, 0xe5, 0xa8, 0x23,
0xbb, 0x4d, 0x31, 0x8e, 0xc1, 0x5f, 0x74, 0x0f, 0x8f, 0xb0, 0x3a, 0x45, 0x2d, 0x40, 0x2e, 0x3d,
0x26, 0x23, 0x5f, 0xb4, 0xe3, 0x12, 0x74, 0xc8, 0x98, 0xaf, 0x5a, 0x4b, 0x09, 0x67, 0xdc, 0xa0,
0x3a, 0x00, 0x1f, 0xf5, 0x02, 0x2a, 0x8e, 0xbc, 0x3f, 0x50, 0xd5, 0x3f, 0x2a, 0x38, 0x75, 0x52,
0x1b, 0xc3, 0xc6, 0x55, 0xa6, 0x66, 0x14, 0x8c, 0x47, 0xe9, 0x82, 0x51, 0xde, 0xfe, 0x2c, 0xcb,
0xba, 0x6c, 0x91, 0xa9, 0xe2, 0x92, 0x99, 0x24, 0x7f, 0x33, 0x20, 0x7f, 0x44, 0x9d, 0x88, 0x8a,
0x0f, 0x9a, 0x23, 0x3b, 0xe7, 0x72, 0xa4, 0x9e, 0x3d, 0xc4, 0xcb, 0x57, 0x17, 0x52, 0xa4, 0x06,
0x45, 0x2f, 0x10, 0x34, 0x0a, 0x88, 0xaf, 0x72, 0xa4, 0x88, 0x67, 0xfb, 0xec, 0x2c, 0x37, 0x20,
0x1f, 0x8f, 0xaf, 0x77, 0x6d, 0x40, 0xfc, 0xea, 0x45, 0x03, 0x32, 0x95, 0xfc, 0xaf, 0x01, 0xc5,
0xa4, 0x8b, 0x7e, 0x50, 0x35, 0x2f, 0x8c, 0x83, 0x4b, 0xff, 0xf7, 0x38, 0x88, 0xc0, 0x1c, 0x78,
0x81, 0x1e, 0x5c, 0xb1, 0x5a, 0xa3, 0x16, 0x14, 0x42, 0x32, 0xf1, 0x19, 0x71, 0x75, 0xf5, 0x5e,
0x5b, 0xf8, 0x85, 0xa5, 0x1d, 0x4c, 0x70, 0x02, 0xda, 0x5d, 0x3b, 0x39, 0x6d, 0xae, 0x42, 0x35,
0x6d, 0xf9, 0x6b, 0xa3, 0xf9, 0x2f, 0x03, 0x4a, 0x07, 0xbf, 0x17, 0x34, 0x50, 0x43, 0xca, 0xd7,
0xd2, 0xf8, 0xcd, 0xc5, 0x5f, 0x61, 0x4a, 0xe7, 0x7e, 0x60, 0xc9, 0xfa, 0xa8, 0x1d, 0xeb, 0xdd,
0xfb, 0xfa, 0xbd, 0x7f, 0xbf, 0xaf, 0xdf, 0x7b, 0x3b, 0xad, 0x1b, 0xef, 0xa6, 0x75, 0xe3, 0x9f,
0xd3, 0xba, 0xf1, 0x9f, 0x69, 0xdd, 0xe8, 0xe5, 0x95, 0x7f, 0x7e, 0xf8, 0xbf, 0x00, 0x00, 0x00,
0xff, 0xff, 0xea, 0x67, 0xde, 0xa7, 0x4c, 0x14, 0x00, 0x00,
// 1643 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x73, 0x23, 0x47,
0x15, 0xdf, 0x91, 0x67, 0xf5, 0xf1, 0xf4, 0xc1, 0xd2, 0x31, 0x66, 0x56, 0x18, 0xc9, 0x28, 0x15,
0x6a, 0x2b, 0xb5, 0x25, 0x87, 0x25, 0x80, 0xd7, 0x10, 0x12, 0xc9, 0x32, 0x1b, 0x55, 0xb2, 0x59,
0x57, 0x3b, 0x71, 0x72, 0x1b, 0x5a, 0x33, 0x6d, 0xed, 0xa0, 0xd1, 0xf4, 0xd4, 0x74, 0x4b, 0x41,
0x9c, 0x38, 0x9b, 0x3f, 0xc0, 0x37, 0x0e, 0xc0, 0x3f, 0xc1, 0x85, 0x03, 0x07, 0x6a, 0xb9, 0x71,
0xa2, 0x38, 0xb9, 0x58, 0xfd, 0x17, 0xdc, 0xa8, 0xee, 0xe9, 0x91, 0xc6, 0xd6, 0xf8, 0x8b, 0xda,
0x72, 0x71, 0x72, 0x7f, 0xfc, 0x7e, 0xaf, 0xdf, 0x7b, 0xf3, 0xbe, 0x2c, 0x78, 0x3c, 0xf4, 0xc4,
0xcb, 0xc9, 0xa0, 0xed, 0xb0, 0xf1, 0xb6, 0xcb, 0x9c, 0x11, 0x8d, 0xb6, 0xf9, 0xd7, 0x24, 0x1a,
0x8f, 0x3c, 0xb1, 0x4d, 0x42, 0x6f, 0x9b, 0x0d, 0x7e, 0x45, 0x1d, 0xc1, 0xdb, 0x61, 0xc4, 0x04,
0x43, 0x28, 0x86, 0xb4, 0x13, 0x48, 0x7b, 0xfa, 0x83, 0xfa, 0xbb, 0xd7, 0x48, 0x10, 0xb3, 0x90,
0x6a, 0xfe, 0xb5, 0x58, 0x1e, 0x52, 0x27, 0xc1, 0x36, 0x87, 0x8c, 0x0d, 0x7d, 0xba, 0xad, 0x76,
0x83, 0xc9, 0xf1, 0xb6, 0xf0, 0xc6, 0x94, 0x0b, 0x32, 0x0e, 0x35, 0x60, 0x7d, 0xc8, 0x86, 0x4c,
0x2d, 0xb7, 0xe5, 0x4a, 0x9f, 0x3e, 0xbc, 0x48, 0x23, 0xc1, 0x4c, 0x5f, 0xfd, 0xe4, 0x8a, 0xd7,
0x17, 0xf0, 0xd0, 0x9f, 0x0c, 0xbd, 0x40, 0xff, 0x89, 0x89, 0xad, 0x3f, 0x1b, 0x60, 0x3e, 0xa7,
0x82, 0xa0, 0x9f, 0x42, 0x61, 0x4a, 0x23, 0xee, 0xb1, 0xc0, 0x32, 0xb6, 0x8c, 0x47, 0xe5, 0x27,
0xdf, 0x69, 0xaf, 0x7a, 0xa4, 0x7d, 0x14, 0x43, 0xba, 0xe6, 0xab, 0xb3, 0xe6, 0x3d, 0x9c, 0x30,
0xd0, 0x53, 0x00, 0x27, 0xa2, 0x44, 0x50, 0xd7, 0x26, 0xc2, 0xca, 0x29, 0x7e, 0xbd, 0x1d, 0xab,
0xdb, 0x4e, 0xde, 0x6f, 0x7f, 0x9e, 0x58, 0x89, 0x4b, 0x1a, 0xdd, 0x11, 0x92, 0x3a, 0x09, 0xdd,
0x84, 0xba, 0x76, 0x3d, 0x55, 0xa3, 0x3b, 0xa2, 0xf5, 0xa7, 0xfb, 0x60, 0x7e, 0xc6, 0x5c, 0x8a,
0x36, 0x20, 0xe7, 0xb9, 0x4a, 0xed, 0x52, 0x37, 0x3f, 0x3f, 0x6b, 0xe6, 0xfa, 0x3d, 0x9c, 0xf3,
0x5c, 0xf4, 0x04, 0xcc, 0x31, 0x15, 0x44, 0x2b, 0x64, 0x65, 0x19, 0x24, 0x6d, 0xd7, 0xd6, 0x28,
0x2c, 0xfa, 0x31, 0x98, 0xf2, 0x53, 0x69, 0x4d, 0x36, 0xb3, 0x38, 0xf2, 0xcd, 0xc3, 0x90, 0x3a,
0x09, 0x4f, 0xe2, 0xd1, 0x3e, 0x94, 0x5d, 0xca, 0x9d, 0xc8, 0x0b, 0x85, 0xf4, 0xa1, 0xa9, 0xe8,
0x6f, 0x5f, 0x46, 0xef, 0x2d, 0xa1, 0x38, 0xcd, 0x43, 0x3f, 0x83, 0x3c, 0x17, 0x44, 0x4c, 0xb8,
0x75, 0x5f, 0x49, 0x68, 0x5c, 0xaa, 0x80, 0x42, 0x69, 0x15, 0x34, 0x07, 0x7d, 0x0c, 0xb5, 0x31,
0x09, 0xc8, 0x90, 0x46, 0xb6, 0x96, 0x92, 0x57, 0x52, 0xbe, 0x97, 0x69, 0x7a, 0x8c, 0x8c, 0x05,
0xe1, 0xea, 0x38, 0xbd, 0x45, 0x7d, 0x00, 0x22, 0x04, 0x71, 0x5e, 0x8e, 0x69, 0x20, 0xac, 0x82,
0x92, 0xf2, 0x4e, 0xa6, 0x2e, 0x54, 0x7c, 0xcd, 0xa2, 0x51, 0x67, 0x01, 0xee, 0xe6, 0x2c, 0x03,
0xa7, 0xc8, 0xe8, 0x19, 0x94, 0x1d, 0x1a, 0x09, 0xef, 0xd8, 0x73, 0x88, 0xa0, 0x56, 0x51, 0xc9,
0x6a, 0x66, 0xc9, 0xda, 0x5b, 0xc2, 0xb4, 0x61, 0x69, 0x26, 0x7a, 0x0f, 0xcc, 0x88, 0xf9, 0xd4,
0x2a, 0x6d, 0x19, 0x8f, 0x6a, 0x97, 0x7f, 0x1a, 0xcc, 0x7c, 0x8a, 0x15, 0x52, 0x3e, 0xbd, 0x54,
0x84, 0x5b, 0xb0, 0xb5, 0x76, 0x63, 0x33, 0x70, 0x9a, 0x89, 0x5a, 0x50, 0x39, 0xfa, 0xea, 0xd3,
0xce, 0x67, 0x5f, 0xf4, 0x0e, 0x0e, 0x58, 0x24, 0xac, 0xf2, 0x96, 0xf1, 0xa8, 0x8a, 0xcf, 0x9d,
0xed, 0x6e, 0x9c, 0x9c, 0xb6, 0x10, 0x3c, 0x28, 0x1a, 0x0f, 0x0c, 0x15, 0x8b, 0xc6, 0x7b, 0xc6,
0x57, 0xc6, 0x2f, 0x8d, 0xd6, 0x1f, 0x4d, 0x28, 0x1c, 0xd2, 0x68, 0xea, 0x39, 0x6f, 0x36, 0x52,
0x9f, 0x9e, 0x8b, 0xd4, 0x4c, 0x87, 0xea, 0x67, 0x57, 0x82, 0x75, 0x07, 0x8a, 0x34, 0x70, 0x43,
0xe6, 0x05, 0x42, 0x47, 0x6a, 0xa6, 0x37, 0xf7, 0x35, 0x06, 0x2f, 0xd0, 0x68, 0x1f, 0xaa, 0x71,
0x02, 0xda, 0xe7, 0xc2, 0x74, 0x2b, 0x8b, 0xfe, 0x85, 0x02, 0xea, 0xf8, 0xaa, 0x4c, 0x52, 0x3b,
0xd4, 0x83, 0x6a, 0x18, 0xd1, 0xa9, 0xc7, 0x26, 0xdc, 0x56, 0x46, 0xe4, 0x6f, 0x64, 0x04, 0xae,
0x24, 0x2c, 0xb9, 0x43, 0xef, 0x40, 0x2d, 0xa4, 0x81, 0xeb, 0x05, 0x43, 0xdb, 0xa5, 0x3e, 0x15,
0x54, 0x05, 0x6a, 0x11, 0x57, 0xf5, 0x69, 0x4f, 0x1d, 0xa2, 0x9f, 0x43, 0x45, 0xbe, 0x61, 0x27,
0xf5, 0x0d, 0xae, 0xad, 0x6f, 0xb8, 0x2c, 0x09, 0x7a, 0x83, 0x5e, 0xc0, 0xb7, 0xce, 0x29, 0xbb,
0x10, 0x54, 0xbe, 0x5e, 0xd0, 0x5b, 0x69, 0x85, 0xf5, 0xe1, 0x2e, 0x3a, 0x39, 0x6d, 0xd5, 0xa0,
0x92, 0x8e, 0x94, 0xd6, 0xef, 0x73, 0x50, 0x4c, 0xfc, 0x8d, 0xde, 0xd7, 0x9f, 0xd6, 0xb8, 0xdc,
0xb9, 0x09, 0x56, 0xb9, 0x25, 0xfe, 0xaa, 0xef, 0xc3, 0xfd, 0x90, 0x45, 0x82, 0x5b, 0x39, 0x15,
0xe7, 0x99, 0xa5, 0x43, 0x46, 0xea, 0x1e, 0x0b, 0x8e, 0xbd, 0x21, 0x8e, 0xc1, 0xe8, 0x4b, 0x28,
0x4f, 0xbd, 0x48, 0x4c, 0x88, 0x6f, 0x7b, 0x21, 0xb7, 0xd6, 0x14, 0xf7, 0xfb, 0x57, 0x3d, 0xd9,
0x3e, 0x8a, 0xf1, 0xfd, 0x83, 0x6e, 0x6d, 0x7e, 0xd6, 0x84, 0xc5, 0x96, 0x63, 0xd0, 0xa2, 0xfa,
0x21, 0xaf, 0x3f, 0x87, 0xd2, 0xe2, 0x06, 0x3d, 0x06, 0x08, 0xe2, 0x14, 0xb3, 0x17, 0x09, 0x50,
0x9d, 0x9f, 0x35, 0x4b, 0x3a, 0xf1, 0xfa, 0x3d, 0x5c, 0xd2, 0x80, 0xbe, 0x8b, 0x10, 0x98, 0xc4,
0x75, 0x23, 0x95, 0x0e, 0x25, 0xac, 0xd6, 0xad, 0xdf, 0x15, 0xc0, 0xfc, 0x9c, 0xf0, 0xd1, 0x5d,
0x57, 0x7b, 0xf9, 0xe6, 0x4a, 0x02, 0x3d, 0x06, 0xe0, 0x71, 0x58, 0x4a, 0x73, 0xcc, 0xa5, 0x39,
0x3a, 0x58, 0xa5, 0x39, 0x1a, 0x10, 0x9b, 0xc3, 0x7d, 0x26, 0x54, 0xae, 0x98, 0x58, 0xad, 0xd1,
0xdb, 0x50, 0x08, 0x98, 0xab, 0xe8, 0x79, 0x45, 0x87, 0xf9, 0x59, 0x33, 0x2f, 0xeb, 0x57, 0xbf,
0x87, 0xf3, 0xf2, 0xaa, 0xef, 0xaa, 0xfa, 0x15, 0x04, 0x4c, 0x10, 0xd9, 0x1b, 0xb8, 0x2e, 0xc3,
0x99, 0x49, 0xd2, 0x59, 0xc2, 0x92, 0xd2, 0x99, 0x62, 0xa2, 0x23, 0x78, 0x2b, 0xd1, 0x37, 0x2d,
0xb0, 0x78, 0x1b, 0x81, 0x48, 0x4b, 0x48, 0xdd, 0xa4, 0xda, 0x55, 0xe9, 0xf2, 0x76, 0xa5, 0x3c,
0x98, 0xd5, 0xae, 0xba, 0x50, 0x75, 0x29, 0xf7, 0x22, 0xea, 0xaa, 0x6a, 0x42, 0x55, 0x66, 0xd6,
0x9e, 0x7c, 0xf7, 0x2a, 0x21, 0x14, 0x57, 0x34, 0x47, 0xed, 0x50, 0x07, 0x8a, 0x3a, 0x6e, 0xb8,
0x55, 0xbe, 0x4d, 0x7d, 0x5f, 0xd0, 0xce, 0x55, 0xc3, 0xca, 0xad, 0xaa, 0xe1, 0x53, 0x00, 0x9f,
0x0d, 0x6d, 0x37, 0xf2, 0xa6, 0x34, 0xb2, 0xaa, 0x7a, 0x78, 0xc9, 0xe0, 0xf6, 0x14, 0x02, 0x97,
0x7c, 0x36, 0x8c, 0x97, 0x2b, 0x45, 0xa9, 0x76, 0xcb, 0xa2, 0x44, 0xa0, 0x4e, 0x38, 0xf7, 0x86,
0x01, 0x75, 0xed, 0x21, 0x0d, 0x68, 0xe4, 0x39, 0x76, 0x44, 0x39, 0x9b, 0x44, 0x0e, 0xe5, 0xd6,
0x37, 0x94, 0x27, 0x32, 0xc7, 0x8f, 0x67, 0x31, 0x18, 0x6b, 0x2c, 0xb6, 0x12, 0x31, 0x17, 0x2e,
0xf8, 0x6e, 0xfd, 0xe4, 0xb4, 0xb5, 0x01, 0xeb, 0xe9, 0x32, 0xb5, 0x63, 0x7c, 0x64, 0x7c, 0x6c,
0x1c, 0x18, 0xad, 0xbf, 0xe6, 0xe0, 0x9b, 0x2b, 0x3e, 0x45, 0x3f, 0x82, 0x82, 0xf6, 0xea, 0x55,
0x43, 0xa4, 0xe6, 0xe1, 0x04, 0x8b, 0x36, 0xa1, 0x24, 0x53, 0x9c, 0x72, 0x4e, 0xe3, 0xe2, 0x55,
0xc2, 0xcb, 0x03, 0x64, 0x41, 0x81, 0xf8, 0x1e, 0x91, 0x77, 0x6b, 0xea, 0x2e, 0xd9, 0xa2, 0x09,
0x6c, 0xc4, 0xae, 0xb7, 0x97, 0xbd, 0xda, 0x66, 0xa1, 0xe0, 0x96, 0xa9, 0xec, 0xff, 0xf0, 0x46,
0x91, 0xa0, 0x3f, 0xce, 0xf2, 0xe0, 0x45, 0x28, 0xf8, 0x7e, 0x20, 0xa2, 0x19, 0x5e, 0x77, 0x33,
0xae, 0xea, 0xcf, 0xe0, 0xe1, 0xa5, 0x14, 0xf4, 0x00, 0xd6, 0x46, 0x74, 0x16, 0x97, 0x27, 0x2c,
0x97, 0x68, 0x1d, 0xee, 0x4f, 0x89, 0x3f, 0xa1, 0xba, 0x9a, 0xc5, 0x9b, 0xdd, 0xdc, 0x8e, 0xd1,
0xfa, 0x7b, 0x0e, 0x0a, 0x5a, 0x9d, 0xbb, 0x9e, 0x0c, 0xf4, 0xb3, 0x2b, 0x85, 0xed, 0x03, 0xa8,
0x68, 0x97, 0xc6, 0x19, 0x69, 0x5e, 0x1b, 0xd3, 0xe5, 0x18, 0x1f, 0x67, 0xe3, 0x07, 0x60, 0x7a,
0x21, 0x19, 0xeb, 0xa9, 0x20, 0xf3, 0xe5, 0xfe, 0x41, 0xe7, 0xf9, 0x8b, 0x30, 0x2e, 0x2c, 0xc5,
0xf9, 0x59, 0xd3, 0x94, 0x07, 0x58, 0xd1, 0x32, 0x1a, 0x7a, 0x3e, 0xa3, 0xa1, 0x67, 0xf6, 0xcf,
0xbf, 0xe5, 0xa1, 0xb0, 0xe7, 0x4f, 0xb8, 0xa0, 0xd1, 0x5d, 0xfb, 0x52, 0x3f, 0xbb, 0xe2, 0xcb,
0x3d, 0x28, 0x44, 0x8c, 0x09, 0xdb, 0x21, 0x57, 0xb9, 0x11, 0x33, 0x26, 0xf6, 0x3a, 0xdd, 0x9a,
0x24, 0xca, 0x16, 0x10, 0xef, 0x71, 0x5e, 0x52, 0xf7, 0x08, 0xfa, 0x12, 0x36, 0x92, 0xc6, 0x39,
0x60, 0x4c, 0x70, 0x11, 0x91, 0xd0, 0x1e, 0xd1, 0x99, 0x9c, 0xbc, 0xd6, 0x2e, 0x1b, 0xed, 0xf7,
0x03, 0x27, 0x9a, 0x29, 0x1f, 0x7f, 0x42, 0x67, 0x78, 0x5d, 0x0b, 0xe8, 0x26, 0xfc, 0x4f, 0xe8,
0x8c, 0xa3, 0x0f, 0x61, 0x93, 0x2e, 0x60, 0x52, 0xa2, 0xed, 0x93, 0xb1, 0x1c, 0x09, 0x6c, 0xc7,
0x67, 0xce, 0x48, 0x79, 0xde, 0xc4, 0x0f, 0x69, 0x5a, 0xd4, 0xa7, 0x31, 0x62, 0x4f, 0x02, 0x10,
0x07, 0x6b, 0xe0, 0x13, 0x67, 0xe4, 0x7b, 0x5c, 0xfe, 0xf7, 0x96, 0x9a, 0xd4, 0x65, 0x63, 0x91,
0xba, 0xed, 0x5c, 0xe1, 0xad, 0x76, 0x77, 0xc9, 0x4d, 0xcd, 0xfd, 0x3a, 0xf1, 0xbe, 0x3d, 0xc8,
0xbe, 0x45, 0x5d, 0x28, 0x4f, 0x02, 0xf9, 0x7c, 0xec, 0x83, 0xd2, 0x4d, 0x7d, 0x00, 0x31, 0x4b,
0x59, 0xbe, 0x09, 0xe6, 0xb1, 0x1c, 0x75, 0x64, 0xb7, 0x29, 0xc6, 0x31, 0xf8, 0x8b, 0xfe, 0xc1,
0x21, 0x56, 0xa7, 0xa8, 0x0d, 0xc8, 0xa5, 0xc7, 0x64, 0xe2, 0x8b, 0x4e, 0x5c, 0x82, 0x0e, 0x18,
0xf3, 0x55, 0x6b, 0x29, 0xe1, 0x8c, 0x1b, 0xd4, 0x00, 0xe0, 0x93, 0x41, 0x40, 0xc5, 0xa1, 0xf7,
0x1b, 0xaa, 0xfa, 0x47, 0x15, 0xa7, 0x4e, 0x56, 0xfe, 0x75, 0xa8, 0xae, 0xfe, 0xeb, 0x50, 0x9f,
0xc2, 0xe6, 0x55, 0xee, 0xc8, 0x28, 0x2a, 0x1f, 0xa5, 0x8b, 0x4a, 0xf9, 0xc9, 0xbb, 0x59, 0x1e,
0xc8, 0x16, 0x99, 0x2a, 0x40, 0x99, 0x89, 0xf4, 0x17, 0x03, 0xf2, 0x87, 0xd4, 0x89, 0xa8, 0x78,
0xa3, 0x79, 0xb4, 0x73, 0x2e, 0x8f, 0x1a, 0xd9, 0x83, 0xbe, 0x7c, 0x75, 0x25, 0x8d, 0xea, 0x50,
0xf4, 0x02, 0x41, 0xa3, 0x80, 0xf8, 0x2a, 0x8f, 0x8a, 0x78, 0xb1, 0xcf, 0x34, 0xe0, 0x0f, 0x06,
0xe4, 0xe3, 0x11, 0xf7, 0xae, 0x0d, 0x88, 0x5f, 0xbd, 0x68, 0x40, 0xa6, 0x92, 0xff, 0x31, 0xa0,
0x98, 0x74, 0xda, 0x37, 0xaa, 0xe6, 0x85, 0x91, 0x71, 0xed, 0x7f, 0x1e, 0x19, 0x11, 0x98, 0x23,
0x2f, 0xd0, 0xc3, 0x2d, 0x56, 0x6b, 0xd4, 0x86, 0x42, 0x48, 0x66, 0x3e, 0x23, 0xae, 0xae, 0xf0,
0xeb, 0x2b, 0xbf, 0xd4, 0x74, 0x82, 0x19, 0x4e, 0x40, 0xbb, 0xeb, 0x27, 0xa7, 0xad, 0x07, 0x50,
0x4b, 0x5b, 0xfe, 0xd2, 0x68, 0xfd, 0xd3, 0x80, 0xd2, 0xfe, 0xaf, 0x05, 0x0d, 0xd4, 0x20, 0xf3,
0x7f, 0x69, 0xfc, 0xd6, 0xea, 0xaf, 0x39, 0xa5, 0x73, 0x3f, 0xd4, 0x64, 0x7d, 0xd4, 0xae, 0xf5,
0xea, 0x75, 0xe3, 0xde, 0xbf, 0x5e, 0x37, 0xee, 0xfd, 0x76, 0xde, 0x30, 0x5e, 0xcd, 0x1b, 0xc6,
0x3f, 0xe6, 0x0d, 0xe3, 0xdf, 0xf3, 0x86, 0x31, 0xc8, 0x2b, 0xff, 0xfc, 0xf0, 0xbf, 0x01, 0x00,
0x00, 0xff, 0xff, 0xc3, 0x37, 0x09, 0x2f, 0x94, 0x14, 0x00, 0x00,
}

7
vendor/github.com/docker/swarmkit/api/objects.proto generated vendored
View file

@ -81,6 +81,10 @@ message Node {
// endpoint on the node to be used for load balancing. Each overlay
// network, including ingress network, will have an NetworkAttachment.
repeated NetworkAttachment attachments = 10;
// VXLANUDPPort specifies the UDP port for VXLAN traffic.
// This information is passed from cluster object to individual nodes.
uint32 VXLANUDPPort = 11;
}
message Service {
@ -375,6 +379,9 @@ message Cluster {
// This flag specifies the default subnet size of global scope networks by giving
// the length of the subnet masks for every such network
uint32 subnetSize = 12;
// VXLANUDPPort specifies the UDP port for VXLAN traffic.
uint32 VXLANUDPPort = 13;
}
// Secret represents a secret that should be passed to a container or a node,

2
vendor/github.com/docker/swarmkit/ca/server.go generated vendored
View file

@ -323,7 +323,7 @@ func (s *Server) IssueNodeCertificate(ctx context.Context, request *api.IssueNod
Availability: request.Availability,
},
}
node.VXLANUDPPort = clusters[0].VXLANUDPPort
return store.CreateNode(tx, node)
})
if err == nil {

1
vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/drivers_ipam.go generated vendored
View file

@ -31,6 +31,7 @@ func initIPAMDrivers(r *drvregistry.DrvRegistry, netConfig *NetworkConfig) error
}
str.WriteString(": Size ")
str.WriteString(strconv.Itoa(int(netConfig.SubnetSize)))
}
if err := ipamutils.ConfigGlobalScopeDefaultNetworks(addressPool); err != nil {
return err

3
vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/networkallocator.go generated vendored
View file

@ -94,6 +94,9 @@ type NetworkConfig struct {
// SubnetSize specifies the subnet size of the networks created from
// the default subnet pool
SubnetSize uint32
// VXLANUDPPort specifies the UDP port number for VXLAN traffic
VXLANUDPPort uint32
}
// New returns a new NetworkAllocator handle

20
vendor/github.com/docker/swarmkit/manager/allocator/network.go generated vendored
View file

@ -69,10 +69,22 @@ type networkContext struct {
func (a *Allocator) doNetworkInit(ctx context.Context) (err error) {
var netConfig *cnmallocator.NetworkConfig
if a.networkConfig != nil && a.networkConfig.DefaultAddrPool != nil {
netConfig = &cnmallocator.NetworkConfig{
DefaultAddrPool: a.networkConfig.DefaultAddrPool,
SubnetSize: a.networkConfig.SubnetSize,
// There are two ways user can invoke swarm init
// with default address pool & vxlan port or with only vxlan port
// hence we need two different way to construct netconfig
if a.networkConfig != nil {
if a.networkConfig.DefaultAddrPool != nil {
netConfig = &cnmallocator.NetworkConfig{
DefaultAddrPool: a.networkConfig.DefaultAddrPool,
SubnetSize: a.networkConfig.SubnetSize,
VXLANUDPPort: a.networkConfig.VXLANUDPPort,
}
} else if a.networkConfig.VXLANUDPPort != 0 {
netConfig = &cnmallocator.NetworkConfig{
DefaultAddrPool: nil,
SubnetSize: 0,
VXLANUDPPort: a.networkConfig.VXLANUDPPort,
}
}
}

6
vendor/github.com/docker/swarmkit/manager/controlapi/cluster.go generated vendored
View file

@ -21,6 +21,8 @@ const (
expiredCertGrace = 24 * time.Hour * 7
// inbuilt default subnet size
inbuiltSubnetSize = 24
// VXLAN default port
defaultVXLANPort = 4789
)
var (
@ -274,6 +276,7 @@ func redactClusters(clusters []*api.Cluster) []*api.Cluster {
BlacklistedCertificates: cluster.BlacklistedCertificates,
DefaultAddressPool: cluster.DefaultAddressPool,
SubnetSize: cluster.SubnetSize,
VXLANUDPPort: cluster.VXLANUDPPort,
}
if newCluster.DefaultAddressPool == nil {
// This is just for CLI display. Set the inbuilt default pool for
@ -281,6 +284,9 @@ func redactClusters(clusters []*api.Cluster) []*api.Cluster {
newCluster.DefaultAddressPool = inbuiltDefaultAddressPool
newCluster.SubnetSize = inbuiltSubnetSize
}
if newCluster.VXLANUDPPort == 0 {
newCluster.VXLANUDPPort = defaultVXLANPort
}
redactedClusters = append(redactedClusters, newCluster)
}

18
vendor/github.com/docker/swarmkit/manager/controlapi/service.go generated vendored
View file

@ -680,13 +680,14 @@ func (s *Server) CreateService(ctx context.Context, request *api.CreateServiceRe
return store.CreateService(tx, service)
})
if err != nil {
switch err {
case store.ErrNameConflict:
return nil, status.Errorf(codes.AlreadyExists, "service %s already exists", request.Spec.Annotations.Name)
case nil:
return &api.CreateServiceResponse{Service: service}, nil
default:
return nil, err
}
return &api.CreateServiceResponse{
Service: service,
}, nil
}
// GetService returns a Service given a ServiceID.
@ -896,7 +897,12 @@ func (s *Server) ListServices(ctx context.Context, request *api.ListServicesRequ
}
})
if err != nil {
return nil, err
switch err {
case store.ErrInvalidFindBy:
return nil, status.Errorf(codes.InvalidArgument, err.Error())
default:
return nil, err
}
}
if request.Filters != nil {

32
vendor/github.com/docker/swarmkit/manager/manager.go generated vendored
View file

@ -942,14 +942,21 @@ func (m *Manager) becomeLeader(ctx context.Context) {
rootCA,
m.config.FIPS,
nil,
0,
0)
// If defaultAddrPool is valid we update cluster object with new value
if m.config.NetworkConfig != nil && m.config.NetworkConfig.DefaultAddrPool != nil {
clusterObj.DefaultAddressPool = m.config.NetworkConfig.DefaultAddrPool
clusterObj.SubnetSize = m.config.NetworkConfig.SubnetSize
}
// If VXLANUDPPort is not 0 then we call update cluster object with new value
if m.config.NetworkConfig != nil {
if m.config.NetworkConfig.DefaultAddrPool != nil {
clusterObj.DefaultAddressPool = m.config.NetworkConfig.DefaultAddrPool
clusterObj.SubnetSize = m.config.NetworkConfig.SubnetSize
}
if m.config.NetworkConfig.VXLANUDPPort != 0 {
clusterObj.VXLANUDPPort = m.config.NetworkConfig.VXLANUDPPort
}
}
err := store.CreateCluster(tx, clusterObj)
if err != nil && err != store.ErrExist {
@ -958,7 +965,7 @@ func (m *Manager) becomeLeader(ctx context.Context) {
// Add Node entry for ourself, if one
// doesn't exist already.
freshCluster := nil == store.CreateNode(tx, managerNode(nodeID, m.config.Availability))
freshCluster := nil == store.CreateNode(tx, managerNode(nodeID, m.config.Availability, clusterObj.VXLANUDPPort))
if freshCluster {
// This is a fresh swarm cluster. Add to store now any initial
@ -991,12 +998,13 @@ func (m *Manager) becomeLeader(ctx context.Context) {
m.roleManager = newRoleManager(s, m.raftNode)
// TODO(stevvooe): Allocate a context that can be used to
// shutdown underlying manager processes when leadership is
// shutdown underlying manager processes when leadership isTestUpdaterRollback
// lost.
// If DefaultAddrPool is null, Read from store and check if
// DefaultAddrPool info is stored in cluster object
if m.config.NetworkConfig == nil || m.config.NetworkConfig.DefaultAddrPool == nil {
// If VXLANUDPPort is 0, read it from the store - cluster object
if m.config.NetworkConfig == nil || m.config.NetworkConfig.DefaultAddrPool == nil || m.config.NetworkConfig.VXLANUDPPort == 0 {
var cluster *api.Cluster
s.View(func(tx store.ReadTx) {
cluster = store.GetCluster(tx, clusterID)
@ -1005,6 +1013,9 @@ func (m *Manager) becomeLeader(ctx context.Context) {
m.config.NetworkConfig.DefaultAddrPool = append(m.config.NetworkConfig.DefaultAddrPool, cluster.DefaultAddressPool...)
m.config.NetworkConfig.SubnetSize = cluster.SubnetSize
}
if cluster.VXLANUDPPort != 0 {
m.config.NetworkConfig.VXLANUDPPort = cluster.VXLANUDPPort
}
}
m.allocator, err = allocator.New(s, m.config.PluginGetter, m.config.NetworkConfig)
@ -1131,7 +1142,8 @@ func defaultClusterObject(
rootCA *ca.RootCA,
fips bool,
defaultAddressPool []string,
subnetSize uint32) *api.Cluster {
subnetSize uint32,
vxlanUDPPort uint32) *api.Cluster {
var caKey []byte
if rcaSigner, err := rootCA.Signer(); err == nil {
caKey = rcaSigner.Key
@ -1166,11 +1178,12 @@ func defaultClusterObject(
FIPS: fips,
DefaultAddressPool: defaultAddressPool,
SubnetSize: subnetSize,
VXLANUDPPort: vxlanUDPPort,
}
}
// managerNode creates a new node with NodeRoleManager role.
func managerNode(nodeID string, availability api.NodeSpec_Availability) *api.Node {
func managerNode(nodeID string, availability api.NodeSpec_Availability, vxlanPort uint32) *api.Node {
return &api.Node{
ID: nodeID,
Certificate: api.Certificate{
@ -1185,6 +1198,7 @@ func managerNode(nodeID string, availability api.NodeSpec_Availability) *api.Nod
Membership: api.NodeMembershipAccepted,
Availability: availability,
},
VXLANUDPPort: vxlanPort,
}
}

18
vendor/github.com/docker/swarmkit/node/node.go generated vendored
View file

@ -19,7 +19,8 @@ import (
"github.com/docker/swarmkit/identity"
"github.com/docker/docker/pkg/plugingetter"
metrics "github.com/docker/go-metrics"
"github.com/docker/go-metrics"
"github.com/docker/libnetwork/drivers/overlay/overlayutils"
"github.com/docker/swarmkit/agent"
"github.com/docker/swarmkit/agent/exec"
"github.com/docker/swarmkit/api"
@ -32,7 +33,7 @@ import (
"github.com/docker/swarmkit/manager/encryption"
"github.com/docker/swarmkit/remotes"
"github.com/docker/swarmkit/xnet"
grpc_prometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
"github.com/grpc-ecosystem/go-grpc-prometheus"
"github.com/pkg/errors"
"github.com/sirupsen/logrus"
bolt "go.etcd.io/bbolt"
@ -161,6 +162,7 @@ type Node struct {
manager *manager.Manager
notifyNodeChange chan *agent.NodeChanges // used by the agent to relay node updates from the dispatcher Session stream to (*Node).run
unlockKey []byte
vxlanUDPPort uint32
}
type lastSeenRole struct {
@ -269,6 +271,14 @@ func (n *Node) currentRole() api.NodeRole {
return currentRole
}
// configVXLANUDPPort sets vxlan port in libnetwork
func configVXLANUDPPort(ctx context.Context, vxlanUDPPort uint32) {
if err := overlayutils.ConfigVXLANUDPPort(vxlanUDPPort); err != nil {
log.G(ctx).WithError(err).Error("Configuring VXLAN port failed")
}
logrus.Infof(" Swarm successfully initialized VXLAN UDP Port to %d ", vxlanUDPPort)
}
func (n *Node) run(ctx context.Context) (err error) {
defer func() {
n.err = err
@ -358,6 +368,10 @@ func (n *Node) run(ctx context.Context) (err error) {
return
case nodeChanges := <-n.notifyNodeChange:
if nodeChanges.Node != nil {
if nodeChanges.Node.VXLANUDPPort != 0 {
n.vxlanUDPPort = nodeChanges.Node.VXLANUDPPort
configVXLANUDPPort(ctx, n.vxlanUDPPort)
}
// This is a bit complex to be backward compatible with older CAs that
// don't support the Node.Role field. They only use what's presently
// called DesiredRole.

2
vendor/github.com/docker/swarmkit/vendor.conf generated vendored
View file

@ -33,7 +33,7 @@ github.com/docker/go-connections 7beb39f0b969b075d1325fecb092faf27fd357b6
github.com/docker/go-events 9461782956ad83b30282bf90e31fa6a70c255ba9
github.com/docker/go-units 9e638d38cf6977a37a8ea0078f3ee75a7cdb2dd1
github.com/docker/libkv 1d8431073ae03cdaedb198a89722f3aab6d418ef
github.com/docker/libnetwork a79d3687931697244b8e03485bf7b2042f8ec6b6
github.com/docker/libnetwork 1f28166bb386cf9223d2d00a28382b0e474be314
github.com/opencontainers/runc ad0f5255060d36872be04de22f8731f38ef2d7b1
github.com/opencontainers/go-digest v1.0.0-rc1
github.com/opencontainers/image-spec v1.0.1