Merge pull request #38102 from selansen/master

VXLAN UDP Port configuration support

api/server/router/swarm/cluster_routes.go

@@ -28,11 +28,16 @@ func (sr *swarmRouter) initCluster(ctx context.Context, w http.ResponseWriter, r
 		return errdefs.InvalidParameter(err)
 	}
 	version := httputils.VersionFromContext(ctx)
+
 	// DefaultAddrPool and SubnetSize were added in API 1.39. Ignore on older API versions.
 	if versions.LessThan(version, "1.39") {
 		req.DefaultAddrPool = nil
 		req.SubnetSize = 0
 	}
+	// DataPathPort was added in API 1.40. Ignore this option on older API versions.
+	if versions.LessThan(version, "1.40") {
+		req.DataPathPort = 0
+	}
 	nodeID, err := sr.backend.Init(req)
 	if err != nil {
 		logrus.Errorf("Error initializing swarm: %v", err)

api/swagger.yaml

@@ -2465,6 +2465,15 @@ definitions:
         description: "Whether there is currently a root CA rotation in progress for the swarm"
         type: "boolean"
         example: false
+      DataPathPort:
+        description: |
+          DataPathPort specifies the data path port number for data traffic.
+          Acceptable port range is 1024 to 49151.
+          If no port is set or is set to 0, the default port (4789) is used.
+        type: "integer"
+        format: "uint32"
+        default: 4789
+        example: 4789
       DefaultAddrPool:
         description: |
           Default Address Pool specifies default subnet pools for global scope networks.
@@ -8877,6 +8886,13 @@ paths:
                   nodes in order to reach the containers running on this node. Using this parameter it is possible to
                   separate the container data traffic from the management traffic of the cluster.
                 type: "string"
+              DataPathPort:
+                description: |
+                  DataPathPort specifies the data path port number for data traffic.
+                  Acceptable port range is 1024 to 49151.
+                  if no port is set or is set to 0, default port 4789 will be used.
+                type: "integer"
+                format: "uint32"
               DefaultAddrPool:
                 description: |
                   Default Address Pool specifies default subnet pools for global scope networks.
@@ -8897,6 +8913,7 @@ paths:
             example:
               ListenAddr: "0.0.0.0:2377"
               AdvertiseAddr: "192.168.1.1:2377"
+              DataPathPort: 4789
               DefaultAddrPool: ["10.10.0.0/8", "20.20.0.0/8"]
               SubnetSize: 24
               ForceNewCluster: false

api/types/swarm/swarm.go

@@ -14,6 +14,7 @@ type ClusterInfo struct {
 	RootRotationInProgress bool
 	DefaultAddrPool        []string
 	SubnetSize             uint32
+	DataPathPort           uint32
 }
 
 // Swarm represents a swarm.
@@ -153,6 +154,7 @@ type InitRequest struct {
 	ListenAddr       string
 	AdvertiseAddr    string
 	DataPathAddr     string
+	DataPathPort     uint32
 	ForceNewCluster  bool
 	Spec             Spec
 	AutoLockManagers bool

daemon/cluster/convert/swarm.go

@@ -42,6 +42,7 @@ func SwarmFromGRPC(c swarmapi.Cluster) types.Swarm {
 			RootRotationInProgress: c.RootCA.RootRotation != nil,
 			DefaultAddrPool:        c.DefaultAddressPool,
 			SubnetSize:             c.SubnetSize,
+			DataPathPort:           c.VXLANUDPPort,
 		},
 		JoinTokens: types.JoinTokens{
 			Worker:  c.RootCA.JoinTokens.Worker,

daemon/cluster/listen_addr.go

@@ -123,6 +123,25 @@ func validateDefaultAddrPool(defaultAddrPool []string, size uint32) error {
 	return nil
 }
 
+// getDataPathPort validates vxlan udp port (data path port) number.
+// if no port is set, the default (4789) is returned
+// valid port numbers are between 1024 and 49151
+func getDataPathPort(portNum uint32) (uint32, error) {
+	// if the value comes as 0 by any reason we set it to default value 4789
+	if portNum == 0 {
+		portNum = 4789
+		return portNum, nil
+	}
+	// 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 portNum < 1024 || portNum > 49151 {
+		return 0, fmt.Errorf("Datapath port number is not in valid range (1024-49151) : %d", portNum)
+	}
+	return portNum, nil
+}
 func resolveDataPathAddr(dataPathAddr string) (string, error) {
 	if dataPathAddr == "" {
 		// dataPathAddr is not defined

daemon/cluster/noderunner.go

@@ -57,6 +57,8 @@ type nodeStartConfig struct {
 	DefaultAddressPool []string
 	// SubnetSize contains subnet size of DefaultAddressPool
 	SubnetSize uint32
+	// DataPathPort contains Data path port (VXLAN UDP port) number that is used for data traffic.
+	DataPathPort uint32
 	// JoinInProgress is set to true if a join operation has started, but
 	// not completed yet.
 	JoinInProgress bool
@@ -125,6 +127,7 @@ func (n *nodeRunner) start(conf nodeStartConfig) error {
 		NetworkConfig: &swarmallocator.NetworkConfig{
 			DefaultAddrPool: conf.DefaultAddressPool,
 			SubnetSize:      conf.SubnetSize,
+			VXLANUDPPort:    conf.DataPathPort,
 		},
 		JoinAddr:  joinAddr,
 		StateDir:  n.cluster.root,

daemon/cluster/swarm.go

@@ -96,6 +96,12 @@ func (c *Cluster) Init(req types.InitRequest) (string, error) {
 	if err := validateDefaultAddrPool(req.DefaultAddrPool, req.SubnetSize); err != nil {
 		return "", err
 	}
+
+	port, err := getDataPathPort(req.DataPathPort)
+	if err != nil {
+		return "", err
+	}
+
 	nr, err := c.newNodeRunner(nodeStartConfig{
 		forceNewCluster:    req.ForceNewCluster,
 		autolock:           req.AutoLockManagers,
@@ -106,6 +112,7 @@ func (c *Cluster) Init(req types.InitRequest) (string, error) {
 		DefaultAddressPool: req.DefaultAddrPool,
 		SubnetSize:         req.SubnetSize,
 		availability:       req.Availability,
+		DataPathPort:       port,
 	})
 	if err != nil {
 		return "", err

docs/api/version-history.md

@@ -29,6 +29,9 @@ keywords: "API, Docker, rcli, REST, documentation"
   to return those without the specified labels.
 * `POST /containers/create`, `GET /containers/{id}/json`, and `GET /containers/json` now supports
   `BindOptions.NonRecursive`.
+* `POST /swarm/init` now accepts a `DataPathPort` property to set data path port number.
+* `GET /info` now returns information about `DataPathPort` that is currently used in swarm
+* `GET /swarm` endpoint now returns DataPathPort info
 
 ## V1.39 API changes
 

integration/network/service_test.go

@@ -321,6 +321,65 @@ func noServices(client client.ServiceAPIClient) func(log poll.LogT) poll.Result
 	}
 }
 
+func TestServiceWithDataPathPortInit(t *testing.T) {
+	skip.If(t, testEnv.OSType == "windows")
+	skip.If(t, versions.LessThan(testEnv.DaemonAPIVersion(), "1.40"), "DataPathPort was added in API v1.40")
+	defer setupTest(t)()
+	var ops = []func(*daemon.Daemon){}
+	var datapathPort uint32 = 7777
+	ops = append(ops, daemon.WithSwarmDataPathPort(datapathPort))
+	d := swarm.NewSwarm(t, testEnv, ops...)
+
+	cli := d.NewClientT(t)
+	defer cli.Close()
+
+	// Create a overlay network
+	name := "saanvisthira" + t.Name()
+	network.CreateNoError(t, context.Background(), cli, name,
+		network.WithDriver("overlay"))
+
+	var instances uint64 = 1
+	serviceID := swarm.CreateService(t, d,
+		swarm.ServiceWithReplicas(instances),
+		swarm.ServiceWithNetwork(name),
+	)
+
+	poll.WaitOn(t, serviceRunningCount(cli, serviceID, instances), swarm.ServicePoll)
+
+	info := d.Info(t)
+	assert.Equal(t, info.Swarm.Cluster.DataPathPort, datapathPort)
+	err := cli.ServiceRemove(context.Background(), serviceID)
+	assert.NilError(t, err)
+	d.SwarmLeave(true)
+	d.Stop(t)
+
+	// Clean up , set it back to original one to make sure other tests don't fail
+	// call without datapath port option.
+	ops = []func(*daemon.Daemon){}
+	d = swarm.NewSwarm(t, testEnv, ops...)
+	cli = d.NewClientT(t)
+
+	// Create a overlay network
+	name = "saanvisthira" + t.Name()
+	network.CreateNoError(t, context.Background(), cli, name,
+		network.WithDriver("overlay"))
+
+	serviceID = swarm.CreateService(t, d,
+		swarm.ServiceWithReplicas(instances),
+		swarm.ServiceWithNetwork(name),
+	)
+
+	poll.WaitOn(t, serviceRunningCount(cli, serviceID, instances), swarm.ServicePoll)
+
+	info = d.Info(t)
+	var defaultDataPathPort uint32 = 4789
+	assert.Equal(t, info.Swarm.Cluster.DataPathPort, defaultDataPathPort)
+	err = cli.ServiceRemove(context.Background(), serviceID)
+	assert.NilError(t, err)
+	d.SwarmLeave(true)
+	defer d.Stop(t)
+}
+
 func TestServiceWithDefaultAddressPoolInit(t *testing.T) {
 	skip.If(t, testEnv.OSType == "windows")
 	defer setupTest(t)()

internal/test/daemon/daemon.go

@@ -76,6 +76,7 @@ type Daemon struct {
 	SwarmPort       int // FIXME(vdemeester) should probably not be exported
 	DefaultAddrPool []string
 	SubnetSize      uint32
+	DataPathPort    uint32
 	// cached information
 	CachedInfo types.Info
 }

internal/test/daemon/ops.go

@@ -48,6 +48,13 @@ func WithSwarmDefaultAddrPoolSubnetSize(subnetSize uint32) func(*Daemon) {
 	}
 }
 
+// WithSwarmDataPathPort sets the  swarm datapath port to use for swarm mode
+func WithSwarmDataPathPort(datapathPort uint32) func(*Daemon) {
+	return func(d *Daemon) {
+		d.DataPathPort = datapathPort
+	}
+}
+
 // WithEnvironment sets options from internal/test/environment.Execution struct
 func WithEnvironment(e environment.Execution) func(*Daemon) {
 	return func(d *Daemon) {

internal/test/daemon/swarm.go

@@ -85,6 +85,9 @@ func (d *Daemon) SwarmInit(t assert.TestingT, req swarm.InitRequest) {
 		req.DefaultAddrPool = d.DefaultAddrPool
 		req.SubnetSize = d.SubnetSize
 	}
+	if d.DataPathPort > 0 {
+		req.DataPathPort = d.DataPathPort
+	}
 	cli := d.NewClientT(t)
 	defer cli.Close()
 	_, err := cli.SwarmInit(context.Background(), req)

vendor.conf

@@ -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

vendor/github.com/docker/libnetwork/drivers/overlay/encryption.go

@@ -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...)

vendor/github.com/docker/libnetwork/drivers/overlay/ov_utils.go

@@ -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,

vendor/github.com/docker/libnetwork/drivers/overlay/overlay.go

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

vendor/github.com/docker/libnetwork/drivers/overlay/overlayutils/utils.go

@@ -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
+}

vendor/github.com/docker/swarmkit/api/objects.pb.go

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

vendor/github.com/docker/swarmkit/api/objects.proto

@@ -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,

vendor/github.com/docker/swarmkit/ca/server.go

@@ -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 {

vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/drivers_ipam.go

@@ -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

vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/networkallocator.go

@@ -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

vendor/github.com/docker/swarmkit/manager/allocator/network.go

@@ -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 {
+	// There are two ways user can invoke swarm init
-		netConfig = &cnmallocator.NetworkConfig{
+	// with default address pool & vxlan port  or with only vxlan port
-			DefaultAddrPool: a.networkConfig.DefaultAddrPool,
+	// hence we need two different way to construct netconfig
-			SubnetSize:      a.networkConfig.SubnetSize,
+	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,
+			}
 		}
 	}
 

vendor/github.com/docker/swarmkit/manager/controlapi/cluster.go

@@ -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)
 	}
 

vendor/github.com/docker/swarmkit/manager/controlapi/service.go

@@ -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 {

vendor/github.com/docker/swarmkit/manager/manager.go

@@ -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 {
+		// If VXLANUDPPort is not 0 then we call update cluster object with new value
-			clusterObj.DefaultAddressPool = m.config.NetworkConfig.DefaultAddrPool
+		if m.config.NetworkConfig != nil {
-			clusterObj.SubnetSize = m.config.NetworkConfig.SubnetSize
+			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,
 	}
 }
 

vendor/github.com/docker/swarmkit/node/node.go

@@ -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.

vendor/github.com/docker/swarmkit/vendor.conf

@@ -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