diff --git a/vendor.conf b/vendor.conf
index 6641dea1da..f08533fd28 100644
--- a/vendor.conf
+++ b/vendor.conf
@@ -110,7 +110,7 @@ github.com/tonistiigi/fifo 1405643975692217d6720f8b54aeee1bf2cd5cf4
 github.com/stevvooe/continuity cd7a8e21e2b6f84799f5dd4b65faf49c8d3ee02d
 
 # cluster
-github.com/docker/swarmkit bd7bafb8a61de1f5f23c8215ce7b9ecbcb30ff21
+github.com/docker/swarmkit 941a01844b89c56aa61086fecb167ab3af1de22b
 github.com/gogo/protobuf v0.4
 github.com/cloudflare/cfssl 7fb22c8cba7ecaf98e4082d22d65800cf45e042a
 github.com/google/certificate-transparency d90e65c3a07988180c5b1ece71791c0b6506826e
diff --git a/vendor/github.com/docker/swarmkit/README.md b/vendor/github.com/docker/swarmkit/README.md
index 4900fe3625..ffc744c313 100644
--- a/vendor/github.com/docker/swarmkit/README.md
+++ b/vendor/github.com/docker/swarmkit/README.md
@@ -153,6 +153,12 @@ $ swarmd -d /tmp/node-2 --hostname node-2 --join-addr 127.0.0.1:4242 --join-toke
 $ swarmd -d /tmp/node-3 --hostname node-3 --join-addr 127.0.0.1:4242 --join-token <Worker Token>
 ```
 
+If joining as a manager, also specify the listen-control-api.
+
+```sh
+$ swarmd -d /tmp/node-4 --hostname node-4 --join-addr 127.0.0.1:4242 --join-token <Manager Token> --listen-control-api /tmp/node-4/swarm.sock --listen-remote-api 127.0.0.1:4245
+```
+
 In a fourth terminal, use `swarmctl` to explore and control the cluster. Before
 running `swarmctl`, set the `SWARM_SOCKET` environment variable to the path of the
 manager socket that was specified in `--listen-control-api` when starting the
@@ -168,6 +174,7 @@ ID                         Name    Membership  Status  Availability  Manager Sta
 3x12fpoi36eujbdkgdnbvbi6r  node-2  ACCEPTED    READY   ACTIVE
 4spl3tyipofoa2iwqgabsdcve  node-1  ACCEPTED    READY   ACTIVE        REACHABLE *
 dknwk1uqxhnyyujq66ho0h54t  node-3  ACCEPTED    READY   ACTIVE
+zw3rwfawdasdewfq66ho34eaw  node-4  ACCEPTED    READY   ACTIVE        REACHABLE
 
 
 ```
diff --git a/vendor/github.com/docker/swarmkit/api/objects.pb.go b/vendor/github.com/docker/swarmkit/api/objects.pb.go
index cc1a6480fc..01abbe5076 100644
--- a/vendor/github.com/docker/swarmkit/api/objects.pb.go
+++ b/vendor/github.com/docker/swarmkit/api/objects.pb.go
@@ -72,10 +72,10 @@ type Node struct {
 	// shows the privilege level that the CA would currently grant when
 	// issuing or renewing the node's certificate.
 	Role NodeRole `protobuf:"varint,9,opt,name=role,proto3,enum=docker.swarmkit.v1.NodeRole" json:"role,omitempty"`
-	// Each node uses the network attachment to set up an endpoint on the
-	// node to be used for load balancing.  Each overlay network, including
-	// ingress network, will have an NetworkAttachment.
-	LbAttachments []*NetworkAttachment `protobuf:"bytes,10,rep,name=lb_attachments,json=lbAttachments" json:"lb_attachments,omitempty"`
+	// Attachments enumerates the network attachments for the node to set up an
+	// 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"`
 }
 
 func (m *Node) Reset()                    { *m = Node{} }
@@ -408,11 +408,11 @@ func (m *Node) CopyFrom(src interface{}) {
 		github_com_docker_swarmkit_api_deepcopy.Copy(m.Attachment, o.Attachment)
 	}
 	github_com_docker_swarmkit_api_deepcopy.Copy(&m.Certificate, &o.Certificate)
-	if o.LbAttachments != nil {
-		m.LbAttachments = make([]*NetworkAttachment, len(o.LbAttachments))
-		for i := range m.LbAttachments {
-			m.LbAttachments[i] = &NetworkAttachment{}
-			github_com_docker_swarmkit_api_deepcopy.Copy(m.LbAttachments[i], o.LbAttachments[i])
+	if o.Attachments != nil {
+		m.Attachments = make([]*NetworkAttachment, len(o.Attachments))
+		for i := range m.Attachments {
+			m.Attachments[i] = &NetworkAttachment{}
+			github_com_docker_swarmkit_api_deepcopy.Copy(m.Attachments[i], o.Attachments[i])
 		}
 	}
 
@@ -862,8 +862,8 @@ func (m *Node) MarshalTo(dAtA []byte) (int, error) {
 		i++
 		i = encodeVarintObjects(dAtA, i, uint64(m.Role))
 	}
-	if len(m.LbAttachments) > 0 {
-		for _, msg := range m.LbAttachments {
+	if len(m.Attachments) > 0 {
+		for _, msg := range m.Attachments {
 			dAtA[i] = 0x52
 			i++
 			i = encodeVarintObjects(dAtA, i, uint64(msg.Size()))
@@ -1695,8 +1695,8 @@ func (m *Node) Size() (n int) {
 	if m.Role != 0 {
 		n += 1 + sovObjects(uint64(m.Role))
 	}
-	if len(m.LbAttachments) > 0 {
-		for _, e := range m.LbAttachments {
+	if len(m.Attachments) > 0 {
+		for _, e := range m.Attachments {
 			l = e.Size()
 			n += 1 + l + sovObjects(uint64(l))
 		}
@@ -4414,7 +4414,7 @@ func (this *Node) String() string {
 		`Attachment:` + strings.Replace(fmt.Sprintf("%v", this.Attachment), "NetworkAttachment", "NetworkAttachment", 1) + `,`,
 		`Certificate:` + strings.Replace(strings.Replace(this.Certificate.String(), "Certificate", "Certificate", 1), `&`, ``, 1) + `,`,
 		`Role:` + fmt.Sprintf("%v", this.Role) + `,`,
-		`LbAttachments:` + strings.Replace(fmt.Sprintf("%v", this.LbAttachments), "NetworkAttachment", "NetworkAttachment", 1) + `,`,
+		`Attachments:` + strings.Replace(fmt.Sprintf("%v", this.Attachments), "NetworkAttachment", "NetworkAttachment", 1) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -5051,7 +5051,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 			}
 		case 10:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field LbAttachments", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Attachments", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5075,8 +5075,8 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.LbAttachments = append(m.LbAttachments, &NetworkAttachment{})
-			if err := m.LbAttachments[len(m.LbAttachments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Attachments = append(m.Attachments, &NetworkAttachment{})
+			if err := m.Attachments[len(m.Attachments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -7752,101 +7752,101 @@ var (
 func init() { proto.RegisterFile("github.com/docker/swarmkit/api/objects.proto", fileDescriptorObjects) }
 
 var fileDescriptorObjects = []byte{
-	// 1536 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x72, 0x1b, 0x4b,
-	0x15, 0xce, 0x48, 0x63, 0xfd, 0x1c, 0xd9, 0xc2, 0xf4, 0x35, 0x66, 0x22, 0x8c, 0x64, 0x74, 0x0b,
-	0xea, 0xd6, 0xad, 0x94, 0x1c, 0x4c, 0x00, 0xc7, 0x10, 0x12, 0xc9, 0x76, 0x25, 0xaa, 0x24, 0xc4,
-	0xd5, 0x09, 0x09, 0xbb, 0xa1, 0x35, 0xd3, 0x51, 0x06, 0x8d, 0xa6, 0xa7, 0xa6, 0x5b, 0x0a, 0xda,
-	0xb1, 0x61, 0x63, 0x1e, 0xc0, 0x3b, 0x16, 0x79, 0x06, 0x36, 0x6c, 0x58, 0xb0, 0xca, 0x92, 0x15,
-	0xc5, 0xca, 0x45, 0xf4, 0x16, 0x54, 0xb1, 0xa0, 0xba, 0xa7, 0x47, 0x1a, 0x5b, 0xe3, 0x3f, 0x2a,
-	0xe5, 0x62, 0xe5, 0xee, 0xe9, 0xef, 0x3b, 0x7f, 0x7d, 0xce, 0xe9, 0x63, 0xc1, 0x9d, 0xbe, 0x27,
-	0xde, 0x8d, 0x7a, 0x2d, 0x87, 0x0d, 0xb7, 0x5c, 0xe6, 0x0c, 0x68, 0xb4, 0xc5, 0xdf, 0x93, 0x68,
-	0x38, 0xf0, 0xc4, 0x16, 0x09, 0xbd, 0x2d, 0xd6, 0xfb, 0x2d, 0x75, 0x04, 0x6f, 0x85, 0x11, 0x13,
-	0x0c, 0xa1, 0x18, 0xd2, 0x4a, 0x20, 0xad, 0xf1, 0x0f, 0x6b, 0x5f, 0x5f, 0x22, 0x41, 0x4c, 0x42,
-	0xaa, 0xf9, 0x97, 0x62, 0x79, 0x48, 0x9d, 0x04, 0xdb, 0xe8, 0x33, 0xd6, 0xf7, 0xe9, 0x96, 0xda,
-	0xf5, 0x46, 0x6f, 0xb7, 0x84, 0x37, 0xa4, 0x5c, 0x90, 0x61, 0xa8, 0x01, 0x6b, 0x7d, 0xd6, 0x67,
-	0x6a, 0xb9, 0x25, 0x57, 0xfa, 0xeb, 0xed, 0xb3, 0x34, 0x12, 0x4c, 0xf4, 0xd1, 0x4f, 0x2f, 0xd0,
-	0x3e, 0x83, 0x87, 0xfe, 0xa8, 0xef, 0x05, 0xfa, 0x4f, 0x4c, 0x6c, 0xfe, 0xc5, 0x00, 0xf3, 0x39,
-	0x15, 0x04, 0xfd, 0x0c, 0x8a, 0x63, 0x1a, 0x71, 0x8f, 0x05, 0x96, 0xb1, 0x69, 0x7c, 0x55, 0xd9,
-	0xfe, 0x4e, 0x6b, 0x31, 0x22, 0xad, 0xd7, 0x31, 0xa4, 0x63, 0x7e, 0x3c, 0x69, 0xdc, 0xc2, 0x09,
-	0x03, 0xdd, 0x07, 0x70, 0x22, 0x4a, 0x04, 0x75, 0x6d, 0x22, 0xac, 0x9c, 0xe2, 0xd7, 0x5a, 0xb1,
-	0xb9, 0xad, 0x44, 0x7f, 0xeb, 0x55, 0xe2, 0x25, 0x2e, 0x6b, 0x74, 0x5b, 0x48, 0xea, 0x28, 0x74,
-	0x13, 0x6a, 0xfe, 0x72, 0xaa, 0x46, 0xb7, 0x45, 0xf3, 0x0f, 0x4b, 0x60, 0xfe, 0x92, 0xb9, 0x14,
-	0xad, 0x43, 0xce, 0x73, 0x95, 0xd9, 0xe5, 0x4e, 0x61, 0x7a, 0xd2, 0xc8, 0x75, 0xf7, 0x71, 0xce,
-	0x73, 0xd1, 0x36, 0x98, 0x43, 0x2a, 0x88, 0x36, 0xc8, 0xca, 0x72, 0x48, 0xfa, 0xae, 0xbd, 0x51,
-	0x58, 0xf4, 0x13, 0x30, 0xe5, 0x55, 0x69, 0x4b, 0x36, 0xb2, 0x38, 0x52, 0xe7, 0xcb, 0x90, 0x3a,
-	0x09, 0x4f, 0xe2, 0xd1, 0x01, 0x54, 0x5c, 0xca, 0x9d, 0xc8, 0x0b, 0x85, 0x8c, 0xa1, 0xa9, 0xe8,
-	0x5f, 0x9e, 0x47, 0xdf, 0x9f, 0x43, 0x71, 0x9a, 0x87, 0x7e, 0x0e, 0x05, 0x2e, 0x88, 0x18, 0x71,
-	0x6b, 0x49, 0x49, 0xa8, 0x9f, 0x6b, 0x80, 0x42, 0x69, 0x13, 0x34, 0x07, 0x3d, 0x81, 0xea, 0x90,
-	0x04, 0xa4, 0x4f, 0x23, 0x5b, 0x4b, 0x29, 0x28, 0x29, 0xdf, 0xcb, 0x74, 0x3d, 0x46, 0xc6, 0x82,
-	0xf0, 0xca, 0x30, 0xbd, 0x45, 0x5d, 0x00, 0x22, 0x04, 0x71, 0xde, 0x0d, 0x69, 0x20, 0xac, 0xa2,
-	0x92, 0xf2, 0xfd, 0x4c, 0x5b, 0xa8, 0x78, 0xcf, 0xa2, 0x41, 0x7b, 0x06, 0xee, 0xe4, 0x2c, 0x03,
-	0xa7, 0xc8, 0xe8, 0x31, 0x54, 0x1c, 0x1a, 0x09, 0xef, 0xad, 0xe7, 0x10, 0x41, 0xad, 0x92, 0x92,
-	0xd5, 0xc8, 0x92, 0xb5, 0x37, 0x87, 0x69, 0xc7, 0xd2, 0x4c, 0x74, 0x17, 0xcc, 0x88, 0xf9, 0xd4,
-	0x2a, 0x6f, 0x1a, 0x5f, 0x55, 0xcf, 0xbf, 0x1a, 0xcc, 0x7c, 0x8a, 0x15, 0x12, 0x3d, 0x83, 0xaa,
-	0xdf, 0xb3, 0xe7, 0xb6, 0x70, 0x0b, 0x36, 0xf3, 0x57, 0xf6, 0x04, 0xaf, 0xf8, 0xbd, 0xf9, 0x8e,
-	0xef, 0xae, 0x1f, 0x1d, 0x37, 0x11, 0xac, 0x96, 0x8c, 0x55, 0x43, 0x25, 0x9b, 0x71, 0xd7, 0xf8,
-	0xb5, 0xf1, 0x1b, 0xa3, 0xf9, 0x9f, 0x3c, 0x14, 0x5f, 0xd2, 0x68, 0xec, 0x39, 0x9f, 0x37, 0x15,
-	0xef, 0x9f, 0x4a, 0xc5, 0xcc, 0x88, 0x69, 0xb5, 0x0b, 0xd9, 0xb8, 0x03, 0x25, 0x1a, 0xb8, 0x21,
-	0xf3, 0x02, 0xa1, 0x53, 0x31, 0x33, 0x5c, 0x07, 0x1a, 0x83, 0x67, 0x68, 0x74, 0x00, 0x2b, 0x71,
-	0x85, 0xd9, 0xa7, 0xf2, 0x70, 0x33, 0x8b, 0xfe, 0x2b, 0x05, 0xd4, 0x09, 0xb4, 0x3c, 0x4a, 0xed,
-	0xd0, 0x3e, 0xac, 0x84, 0x11, 0x1d, 0x7b, 0x6c, 0xc4, 0x6d, 0xe5, 0x44, 0xe1, 0x4a, 0x4e, 0xe0,
-	0xe5, 0x84, 0x25, 0x77, 0xe8, 0x17, 0xb0, 0x2c, 0xc9, 0x76, 0xd2, 0x99, 0xe0, 0xd2, 0xce, 0x84,
-	0x2b, 0x92, 0xa0, 0x37, 0xe8, 0x05, 0x7c, 0xeb, 0x94, 0x15, 0x33, 0x41, 0x95, 0xcb, 0x05, 0x7d,
-	0x91, 0xb6, 0x44, 0x7f, 0xdc, 0x45, 0x47, 0xc7, 0xcd, 0x2a, 0x2c, 0xa7, 0x53, 0xa0, 0xf9, 0xa7,
-	0x1c, 0x94, 0x92, 0x40, 0xa2, 0x7b, 0xfa, 0xce, 0x8c, 0xf3, 0xa3, 0x96, 0x60, 0x95, 0xbf, 0xf1,
-	0x75, 0xdd, 0x83, 0xa5, 0x90, 0x45, 0x82, 0x5b, 0x39, 0x95, 0x9e, 0x99, 0x45, 0x7f, 0xc8, 0x22,
-	0xb1, 0xc7, 0x82, 0xb7, 0x5e, 0x1f, 0xc7, 0x60, 0xf4, 0x06, 0x2a, 0x63, 0x2f, 0x12, 0x23, 0xe2,
-	0xdb, 0x5e, 0xc8, 0xad, 0xbc, 0xe2, 0xfe, 0xe0, 0x22, 0x95, 0xad, 0xd7, 0x31, 0xbe, 0x7b, 0xd8,
-	0xa9, 0x4e, 0x4f, 0x1a, 0x30, 0xdb, 0x72, 0x0c, 0x5a, 0x54, 0x37, 0xe4, 0xb5, 0xe7, 0x50, 0x9e,
-	0x9d, 0xa0, 0x3b, 0x00, 0x41, 0x5c, 0x19, 0xf6, 0x2c, 0xb3, 0x57, 0xa6, 0x27, 0x8d, 0xb2, 0xae,
-	0x97, 0xee, 0x3e, 0x2e, 0x6b, 0x40, 0xd7, 0x45, 0x08, 0x4c, 0xe2, 0xba, 0x91, 0xca, 0xf3, 0x32,
-	0x56, 0xeb, 0xe6, 0x1f, 0x8b, 0x60, 0xbe, 0x22, 0x7c, 0x70, 0xd3, 0x7d, 0x5a, 0xea, 0x5c, 0xa8,
-	0x8c, 0x3b, 0x00, 0x3c, 0xce, 0x37, 0xe9, 0x8e, 0x39, 0x77, 0x47, 0x67, 0xa1, 0x74, 0x47, 0x03,
-	0x62, 0x77, 0xb8, 0xcf, 0x84, 0x2a, 0x02, 0x13, 0xab, 0x35, 0xfa, 0x12, 0x8a, 0x01, 0x73, 0x15,
-	0xbd, 0xa0, 0xe8, 0x30, 0x3d, 0x69, 0x14, 0x64, 0xe7, 0xe9, 0xee, 0xe3, 0x82, 0x3c, 0xea, 0xba,
-	0xb2, 0xe9, 0x91, 0x20, 0x60, 0x82, 0xc8, 0xae, 0xce, 0x75, 0x03, 0xcd, 0xcc, 0xfe, 0xf6, 0x1c,
-	0x96, 0x34, 0xbd, 0x14, 0x13, 0xbd, 0x86, 0x2f, 0x12, 0x7b, 0xd3, 0x02, 0x4b, 0xd7, 0x11, 0x88,
-	0xb4, 0x84, 0xd4, 0x49, 0xea, 0xa1, 0x29, 0x9f, 0xff, 0xd0, 0xa8, 0x08, 0x66, 0x3d, 0x34, 0x1d,
-	0x58, 0x71, 0x29, 0xf7, 0x22, 0xea, 0xaa, 0x36, 0x41, 0x55, 0x65, 0x56, 0xb7, 0xbf, 0x7b, 0x91,
-	0x10, 0x8a, 0x97, 0x35, 0x47, 0xed, 0x50, 0x1b, 0x4a, 0x3a, 0x6f, 0xb8, 0x55, 0xb9, 0x4e, 0x5b,
-	0x9e, 0xd1, 0x4e, 0xb5, 0xb9, 0xe5, 0x6b, 0xb5, 0xb9, 0xfb, 0x00, 0x3e, 0xeb, 0xdb, 0x6e, 0xe4,
-	0x8d, 0x69, 0x64, 0xad, 0xe8, 0xb1, 0x23, 0x83, 0xbb, 0xaf, 0x10, 0xb8, 0xec, 0xb3, 0x7e, 0xbc,
-	0x5c, 0x68, 0x4a, 0xd5, 0x6b, 0x36, 0x25, 0x02, 0x35, 0xc2, 0xb9, 0xd7, 0x0f, 0xa8, 0x6b, 0xf7,
-	0x69, 0x40, 0x23, 0xcf, 0xb1, 0x23, 0xca, 0xd9, 0x28, 0x72, 0x28, 0xb7, 0xbe, 0xa1, 0x22, 0x91,
-	0x39, 0x38, 0x3c, 0x8e, 0xc1, 0x58, 0x63, 0xb1, 0x95, 0x88, 0x39, 0x73, 0xc0, 0x77, 0x6b, 0x47,
-	0xc7, 0xcd, 0x75, 0x58, 0x4b, 0xb7, 0xa9, 0x1d, 0xe3, 0x91, 0xf1, 0xc4, 0x38, 0x34, 0x9a, 0x7f,
-	0xcb, 0xc1, 0x37, 0x17, 0x62, 0x8a, 0x7e, 0x0c, 0x45, 0x1d, 0xd5, 0x8b, 0xc6, 0x3f, 0xcd, 0xc3,
-	0x09, 0x16, 0x6d, 0x40, 0x59, 0x96, 0x38, 0xe5, 0x9c, 0xc6, 0xcd, 0xab, 0x8c, 0xe7, 0x1f, 0x90,
-	0x05, 0x45, 0xe2, 0x7b, 0x44, 0x9e, 0xe5, 0xd5, 0x59, 0xb2, 0x45, 0x23, 0x58, 0x8f, 0x43, 0x9f,
-	0x7a, 0x9c, 0x6d, 0x16, 0x0a, 0x6e, 0x99, 0xca, 0xff, 0x87, 0x57, 0xca, 0x04, 0x7d, 0x39, 0xf3,
-	0x0f, 0x2f, 0x42, 0xc1, 0x0f, 0x02, 0x11, 0x4d, 0xf0, 0x9a, 0x9b, 0x71, 0x54, 0x7b, 0x0c, 0xb7,
-	0xcf, 0xa5, 0xa0, 0x55, 0xc8, 0x0f, 0xe8, 0x24, 0x6e, 0x4f, 0x58, 0x2e, 0xd1, 0x1a, 0x2c, 0x8d,
-	0x89, 0x3f, 0xa2, 0xba, 0x9b, 0xc5, 0x9b, 0xdd, 0xdc, 0x8e, 0xd1, 0xfc, 0x90, 0x83, 0xa2, 0x36,
-	0xe7, 0xa6, 0x9f, 0x7c, 0xad, 0x76, 0xa1, 0xb1, 0x3d, 0x80, 0x65, 0x1d, 0xd2, 0xb8, 0x22, 0xcd,
-	0x4b, 0x73, 0xba, 0x12, 0xe3, 0xe3, 0x6a, 0x7c, 0x00, 0xa6, 0x17, 0x92, 0xa1, 0x7e, 0xee, 0x33,
-	0x35, 0x77, 0x0f, 0xdb, 0xcf, 0x5f, 0x84, 0x71, 0x63, 0x29, 0x4d, 0x4f, 0x1a, 0xa6, 0xfc, 0x80,
-	0x15, 0x2d, 0xf3, 0x61, 0xfc, 0xf3, 0x12, 0x14, 0xf7, 0xfc, 0x11, 0x17, 0x34, 0xba, 0xe9, 0x20,
-	0x69, 0xb5, 0x0b, 0x41, 0xda, 0x83, 0x62, 0xc4, 0x98, 0xb0, 0x1d, 0x72, 0x51, 0x7c, 0x30, 0x63,
-	0x62, 0xaf, 0xdd, 0xa9, 0x4a, 0xa2, 0xec, 0xed, 0xf1, 0x1e, 0x17, 0x24, 0x75, 0x8f, 0xa0, 0x37,
-	0xb0, 0x9e, 0xbc, 0x88, 0x3d, 0xc6, 0x04, 0x17, 0x11, 0x09, 0xed, 0x01, 0x9d, 0xc8, 0x59, 0x29,
-	0x7f, 0xde, 0xb4, 0x7d, 0x10, 0x38, 0xd1, 0x44, 0x05, 0xef, 0x29, 0x9d, 0xe0, 0x35, 0x2d, 0xa0,
-	0x93, 0xf0, 0x9f, 0xd2, 0x09, 0x47, 0x0f, 0x61, 0x83, 0xce, 0x60, 0x52, 0xa2, 0xed, 0x93, 0xa1,
-	0x7c, 0xeb, 0x6d, 0xc7, 0x67, 0xce, 0x40, 0x3d, 0x37, 0x26, 0xbe, 0x4d, 0xd3, 0xa2, 0x9e, 0xc5,
-	0x88, 0x3d, 0x09, 0x40, 0x1c, 0xac, 0x9e, 0x4f, 0x9c, 0x81, 0xef, 0x71, 0xf9, 0x0f, 0x55, 0x6a,
-	0x78, 0x96, 0x2f, 0x86, 0xb4, 0x6d, 0xe7, 0x82, 0x68, 0xb5, 0x3a, 0x73, 0x6e, 0x6a, 0x14, 0xd7,
-	0x15, 0xf5, 0xed, 0x5e, 0xf6, 0x29, 0xea, 0x40, 0x65, 0x14, 0x48, 0xf5, 0x71, 0x0c, 0xca, 0x57,
-	0x8d, 0x01, 0xc4, 0x2c, 0xe9, 0x79, 0x6d, 0x0c, 0x1b, 0x17, 0x29, 0xcf, 0xa8, 0xcd, 0x47, 0xe9,
-	0xda, 0xac, 0x6c, 0x7f, 0x9d, 0xa5, 0x2f, 0x5b, 0x64, 0xaa, 0x8e, 0x33, 0xd3, 0xf6, 0xaf, 0x06,
-	0x14, 0x5e, 0x52, 0x27, 0xa2, 0xe2, 0xb3, 0x66, 0xed, 0xce, 0xa9, 0xac, 0xad, 0x67, 0x0f, 0xc2,
-	0x52, 0xeb, 0x42, 0xd2, 0xd6, 0xa0, 0xe4, 0x05, 0x82, 0x46, 0x01, 0xf1, 0x55, 0xd6, 0x96, 0xf0,
-	0x6c, 0x9f, 0xe9, 0xc0, 0x07, 0x03, 0x0a, 0xf1, 0xa4, 0x78, 0xd3, 0x0e, 0xc4, 0x5a, 0xcf, 0x3a,
-	0x90, 0x69, 0xe4, 0xbf, 0x0d, 0x28, 0x25, 0x0f, 0xd6, 0x67, 0x35, 0xf3, 0xcc, 0xe4, 0x95, 0xff,
-	0x9f, 0x27, 0x2f, 0x04, 0xe6, 0xc0, 0x0b, 0xf4, 0x8c, 0x88, 0xd5, 0x1a, 0xb5, 0xa0, 0x18, 0x92,
-	0x89, 0xcf, 0x88, 0xab, 0x1b, 0xe5, 0xda, 0xc2, 0x4f, 0x15, 0xed, 0x60, 0x82, 0x13, 0xd0, 0xee,
-	0xda, 0xd1, 0x71, 0x73, 0x15, 0xaa, 0x69, 0xcf, 0xdf, 0x19, 0xcd, 0x7f, 0x18, 0x50, 0x3e, 0xf8,
-	0x9d, 0xa0, 0x81, 0x9a, 0x07, 0xfe, 0x2f, 0x9d, 0xdf, 0x5c, 0xfc, 0x39, 0xa3, 0x7c, 0xea, 0x97,
-	0x8a, 0xac, 0x4b, 0xed, 0x58, 0x1f, 0x3f, 0xd5, 0x6f, 0xfd, 0xf3, 0x53, 0xfd, 0xd6, 0xef, 0xa7,
-	0x75, 0xe3, 0xe3, 0xb4, 0x6e, 0xfc, 0x7d, 0x5a, 0x37, 0xfe, 0x35, 0xad, 0x1b, 0xbd, 0x82, 0x8a,
-	0xcf, 0x8f, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xbd, 0x5c, 0xf5, 0x06, 0x95, 0x13, 0x00, 0x00,
+	// 1527 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcf, 0x6f, 0x1b, 0x4f,
+	0x15, 0xef, 0xda, 0x1b, 0xff, 0x78, 0x4e, 0x4c, 0x98, 0x86, 0xb0, 0x35, 0xc1, 0x0e, 0xae, 0x40,
+	0x55, 0x55, 0x39, 0x25, 0x14, 0x48, 0x03, 0xa5, 0xb5, 0x93, 0xa8, 0xb5, 0x4a, 0x69, 0x34, 0x2d,
+	0x2d, 0xb7, 0x65, 0xb2, 0x3b, 0x75, 0x17, 0xaf, 0x77, 0x56, 0x3b, 0x63, 0x17, 0xdf, 0x7a, 0x0e,
+	0x7f, 0x40, 0x6e, 0x1c, 0xfa, 0x37, 0x70, 0xe1, 0xc2, 0x81, 0x53, 0x8f, 0x9c, 0x10, 0xa7, 0x88,
+	0xfa, 0xbf, 0x40, 0xe2, 0x80, 0x66, 0x76, 0xd6, 0xde, 0xc4, 0x9b, 0x5f, 0xa8, 0x8a, 0xbe, 0xa7,
+	0xcc, 0xec, 0x7c, 0x3e, 0xef, 0xd7, 0xbc, 0xf7, 0xe6, 0xc5, 0x70, 0xaf, 0xe7, 0x89, 0xf7, 0xc3,
+	0x83, 0x96, 0xc3, 0x06, 0x1b, 0x2e, 0x73, 0xfa, 0x34, 0xda, 0xe0, 0x1f, 0x48, 0x34, 0xe8, 0x7b,
+	0x62, 0x83, 0x84, 0xde, 0x06, 0x3b, 0xf8, 0x03, 0x75, 0x04, 0x6f, 0x85, 0x11, 0x13, 0x0c, 0xa1,
+	0x18, 0xd2, 0x4a, 0x20, 0xad, 0xd1, 0x8f, 0x6b, 0x77, 0x2f, 0x90, 0x20, 0xc6, 0x21, 0xd5, 0xfc,
+	0x0b, 0xb1, 0x3c, 0xa4, 0x4e, 0x82, 0x6d, 0xf4, 0x18, 0xeb, 0xf9, 0x74, 0x43, 0xed, 0x0e, 0x86,
+	0xef, 0x36, 0x84, 0x37, 0xa0, 0x5c, 0x90, 0x41, 0xa8, 0x01, 0x2b, 0x3d, 0xd6, 0x63, 0x6a, 0xb9,
+	0x21, 0x57, 0xfa, 0xeb, 0xad, 0xd3, 0x34, 0x12, 0x8c, 0xf5, 0xd1, 0xcf, 0xcf, 0xd1, 0x3e, 0x85,
+	0x87, 0xfe, 0xb0, 0xe7, 0x05, 0xfa, 0x4f, 0x4c, 0x6c, 0xfe, 0xd5, 0x00, 0xf3, 0x05, 0x15, 0x04,
+	0xfd, 0x02, 0x8a, 0x23, 0x1a, 0x71, 0x8f, 0x05, 0x96, 0xb1, 0x6e, 0xdc, 0xa9, 0x6c, 0x7e, 0xaf,
+	0x35, 0x1f, 0x91, 0xd6, 0x9b, 0x18, 0xd2, 0x31, 0x3f, 0x1f, 0x37, 0x6e, 0xe0, 0x84, 0x81, 0x1e,
+	0x02, 0x38, 0x11, 0x25, 0x82, 0xba, 0x36, 0x11, 0x56, 0x4e, 0xf1, 0x6b, 0xad, 0xd8, 0xdc, 0x56,
+	0xa2, 0xbf, 0xf5, 0x3a, 0xf1, 0x12, 0x97, 0x35, 0xba, 0x2d, 0x24, 0x75, 0x18, 0xba, 0x09, 0x35,
+	0x7f, 0x31, 0x55, 0xa3, 0xdb, 0xa2, 0xf9, 0x71, 0x01, 0xcc, 0xdf, 0x30, 0x97, 0xa2, 0x55, 0xc8,
+	0x79, 0xae, 0x32, 0xbb, 0xdc, 0x29, 0x4c, 0x8e, 0x1b, 0xb9, 0xee, 0x2e, 0xce, 0x79, 0x2e, 0xda,
+	0x04, 0x73, 0x40, 0x05, 0xd1, 0x06, 0x59, 0x59, 0x0e, 0x49, 0xdf, 0xb5, 0x37, 0x0a, 0x8b, 0x7e,
+	0x06, 0xa6, 0xbc, 0x2a, 0x6d, 0xc9, 0x5a, 0x16, 0x47, 0xea, 0x7c, 0x15, 0x52, 0x27, 0xe1, 0x49,
+	0x3c, 0xda, 0x83, 0x8a, 0x4b, 0xb9, 0x13, 0x79, 0xa1, 0x90, 0x31, 0x34, 0x15, 0xfd, 0xf6, 0x59,
+	0xf4, 0xdd, 0x19, 0x14, 0xa7, 0x79, 0xe8, 0x97, 0x50, 0xe0, 0x82, 0x88, 0x21, 0xb7, 0x16, 0x94,
+	0x84, 0xfa, 0x99, 0x06, 0x28, 0x94, 0x36, 0x41, 0x73, 0xd0, 0x33, 0xa8, 0x0e, 0x48, 0x40, 0x7a,
+	0x34, 0xb2, 0xb5, 0x94, 0x82, 0x92, 0xf2, 0x83, 0x4c, 0xd7, 0x63, 0x64, 0x2c, 0x08, 0x2f, 0x0d,
+	0xd2, 0x5b, 0xd4, 0x05, 0x20, 0x42, 0x10, 0xe7, 0xfd, 0x80, 0x06, 0xc2, 0x2a, 0x2a, 0x29, 0x3f,
+	0xcc, 0xb4, 0x85, 0x8a, 0x0f, 0x2c, 0xea, 0xb7, 0xa7, 0xe0, 0x4e, 0xce, 0x32, 0x70, 0x8a, 0x8c,
+	0x9e, 0x42, 0xc5, 0xa1, 0x91, 0xf0, 0xde, 0x79, 0x0e, 0x11, 0xd4, 0x2a, 0x29, 0x59, 0x8d, 0x2c,
+	0x59, 0x3b, 0x33, 0x98, 0x76, 0x2c, 0xcd, 0x44, 0xf7, 0xc1, 0x8c, 0x98, 0x4f, 0xad, 0xf2, 0xba,
+	0x71, 0xa7, 0x7a, 0xf6, 0xd5, 0x60, 0xe6, 0x53, 0xac, 0x90, 0x52, 0xf5, 0xcc, 0x10, 0x6e, 0xc1,
+	0x7a, 0xfe, 0xd2, 0x6e, 0xe0, 0x34, 0x73, 0x7b, 0xf5, 0xf0, 0xa8, 0x89, 0x60, 0xb9, 0x64, 0x2c,
+	0x1b, 0x2a, 0xcf, 0x8c, 0xfb, 0xc6, 0xef, 0x8c, 0xdf, 0x1b, 0xcd, 0xff, 0xe6, 0xa1, 0xf8, 0x8a,
+	0x46, 0x23, 0xcf, 0xf9, 0xba, 0x59, 0xf8, 0xf0, 0x44, 0x16, 0x66, 0x06, 0x4b, 0xab, 0x9d, 0x4b,
+	0xc4, 0x2d, 0x28, 0xd1, 0xc0, 0x0d, 0x99, 0x17, 0x08, 0x9d, 0x85, 0x99, 0x91, 0xda, 0xd3, 0x18,
+	0x3c, 0x45, 0xa3, 0x3d, 0x58, 0x8a, 0x8b, 0xcb, 0x3e, 0x91, 0x82, 0xeb, 0x59, 0xf4, 0xdf, 0x2a,
+	0xa0, 0xce, 0x9d, 0xc5, 0x61, 0x6a, 0x87, 0x76, 0x61, 0x29, 0x8c, 0xe8, 0xc8, 0x63, 0x43, 0x6e,
+	0x2b, 0x27, 0x0a, 0x97, 0x72, 0x02, 0x2f, 0x26, 0x2c, 0xb9, 0x43, 0xbf, 0x82, 0x45, 0x49, 0xb6,
+	0x93, 0xa6, 0x04, 0x17, 0x36, 0x25, 0x5c, 0x91, 0x04, 0xbd, 0x41, 0x2f, 0xe1, 0x3b, 0x27, 0xac,
+	0x98, 0x0a, 0xaa, 0x5c, 0x2c, 0xe8, 0x66, 0xda, 0x12, 0xfd, 0x71, 0x1b, 0x1d, 0x1e, 0x35, 0xab,
+	0xb0, 0x98, 0x4e, 0x81, 0xe6, 0x9f, 0x73, 0x50, 0x4a, 0x02, 0x89, 0x1e, 0xe8, 0x3b, 0x33, 0xce,
+	0x8e, 0x5a, 0x82, 0x55, 0xfe, 0xc6, 0xd7, 0xf5, 0x00, 0x16, 0x42, 0x16, 0x09, 0x6e, 0xe5, 0x54,
+	0x72, 0x66, 0xd6, 0xfb, 0x3e, 0x8b, 0xc4, 0x0e, 0x0b, 0xde, 0x79, 0x3d, 0x1c, 0x83, 0xd1, 0x5b,
+	0xa8, 0x8c, 0xbc, 0x48, 0x0c, 0x89, 0x6f, 0x7b, 0x21, 0xb7, 0xf2, 0x8a, 0xfb, 0xa3, 0xf3, 0x54,
+	0xb6, 0xde, 0xc4, 0xf8, 0xee, 0x7e, 0xa7, 0x3a, 0x39, 0x6e, 0xc0, 0x74, 0xcb, 0x31, 0x68, 0x51,
+	0xdd, 0x90, 0xd7, 0x5e, 0x40, 0x79, 0x7a, 0x82, 0xee, 0x01, 0x04, 0x71, 0x5d, 0xd8, 0xd3, 0xcc,
+	0x5e, 0x9a, 0x1c, 0x37, 0xca, 0xba, 0x5a, 0xba, 0xbb, 0xb8, 0xac, 0x01, 0x5d, 0x17, 0x21, 0x30,
+	0x89, 0xeb, 0x46, 0x2a, 0xcf, 0xcb, 0x58, 0xad, 0x9b, 0x7f, 0x2a, 0x82, 0xf9, 0x9a, 0xf0, 0xfe,
+	0x75, 0xb7, 0x68, 0xa9, 0x73, 0xae, 0x32, 0xee, 0x01, 0xf0, 0x38, 0xdf, 0xa4, 0x3b, 0xe6, 0xcc,
+	0x1d, 0x9d, 0x85, 0xd2, 0x1d, 0x0d, 0x88, 0xdd, 0xe1, 0x3e, 0x13, 0xaa, 0x08, 0x4c, 0xac, 0xd6,
+	0xe8, 0x36, 0x14, 0x03, 0xe6, 0x2a, 0x7a, 0x41, 0xd1, 0x61, 0x72, 0xdc, 0x28, 0xc8, 0xa6, 0xd3,
+	0xdd, 0xc5, 0x05, 0x79, 0xd4, 0x75, 0x55, 0xd3, 0x09, 0x02, 0x26, 0x88, 0x6c, 0xe8, 0x5c, 0xf7,
+	0xce, 0xcc, 0xec, 0x6f, 0xcf, 0x60, 0x49, 0xbf, 0x4b, 0x31, 0xd1, 0x1b, 0xb8, 0x99, 0xd8, 0x9b,
+	0x16, 0x58, 0xba, 0x8a, 0x40, 0xa4, 0x25, 0xa4, 0x4e, 0x52, 0x6f, 0x4c, 0xf9, 0xec, 0x37, 0x46,
+	0x45, 0x30, 0xeb, 0x8d, 0xe9, 0xc0, 0x92, 0x4b, 0xb9, 0x17, 0x51, 0x57, 0xb5, 0x09, 0xaa, 0x2a,
+	0xb3, 0xba, 0xf9, 0xfd, 0xf3, 0x84, 0x50, 0xbc, 0xa8, 0x39, 0x6a, 0x87, 0xda, 0x50, 0xd2, 0x79,
+	0xc3, 0xad, 0xca, 0x55, 0x9a, 0xf2, 0x94, 0x76, 0xa2, 0xcd, 0x2d, 0x5e, 0xa9, 0xcd, 0x3d, 0x04,
+	0xf0, 0x59, 0xcf, 0x76, 0x23, 0x6f, 0x44, 0x23, 0x6b, 0x49, 0x4f, 0x1c, 0x19, 0xdc, 0x5d, 0x85,
+	0xc0, 0x65, 0x9f, 0xf5, 0xe2, 0xe5, 0x5c, 0x53, 0xaa, 0x5e, 0xb1, 0x29, 0x11, 0xa8, 0x11, 0xce,
+	0xbd, 0x5e, 0x40, 0x5d, 0xbb, 0x47, 0x03, 0x1a, 0x79, 0x8e, 0x1d, 0x51, 0xce, 0x86, 0x91, 0x43,
+	0xb9, 0xf5, 0x2d, 0x15, 0x89, 0xcc, 0x99, 0xe1, 0x69, 0x0c, 0xc6, 0x1a, 0x8b, 0xad, 0x44, 0xcc,
+	0xa9, 0x03, 0xbe, 0x5d, 0x3b, 0x3c, 0x6a, 0xae, 0xc2, 0x4a, 0xba, 0x4d, 0x6d, 0x19, 0x4f, 0x8c,
+	0x67, 0xc6, 0xbe, 0xd1, 0xfc, 0x7b, 0x0e, 0xbe, 0x3d, 0x17, 0x53, 0xf4, 0x53, 0x28, 0xea, 0xa8,
+	0x9e, 0x37, 0xf9, 0x69, 0x1e, 0x4e, 0xb0, 0x68, 0x0d, 0xca, 0xb2, 0xc4, 0x29, 0xe7, 0x34, 0x6e,
+	0x5e, 0x65, 0x3c, 0xfb, 0x80, 0x2c, 0x28, 0x12, 0xdf, 0x23, 0xf2, 0x2c, 0xaf, 0xce, 0x92, 0x2d,
+	0x1a, 0xc2, 0x6a, 0x1c, 0x7a, 0x7b, 0xf6, 0xc0, 0xda, 0x2c, 0x14, 0xdc, 0x32, 0x95, 0xff, 0x8f,
+	0x2f, 0x95, 0x09, 0xfa, 0x72, 0x66, 0x1f, 0x5e, 0x86, 0x82, 0xef, 0x05, 0x22, 0x1a, 0xe3, 0x15,
+	0x37, 0xe3, 0xa8, 0xf6, 0x14, 0x6e, 0x9d, 0x49, 0x41, 0xcb, 0x90, 0xef, 0xd3, 0x71, 0xdc, 0x9e,
+	0xb0, 0x5c, 0xa2, 0x15, 0x58, 0x18, 0x11, 0x7f, 0x48, 0x75, 0x37, 0x8b, 0x37, 0xdb, 0xb9, 0x2d,
+	0xa3, 0xf9, 0x29, 0x07, 0x45, 0x6d, 0xce, 0x75, 0x3f, 0xf9, 0x5a, 0xed, 0x5c, 0x63, 0x7b, 0x04,
+	0x8b, 0x3a, 0xa4, 0x71, 0x45, 0x9a, 0x17, 0xe6, 0x74, 0x25, 0xc6, 0xc7, 0xd5, 0xf8, 0x08, 0x4c,
+	0x2f, 0x24, 0x03, 0xfd, 0xdc, 0x67, 0x6a, 0xee, 0xee, 0xb7, 0x5f, 0xbc, 0x0c, 0xe3, 0xc6, 0x52,
+	0x9a, 0x1c, 0x37, 0x4c, 0xf9, 0x01, 0x2b, 0x5a, 0xe6, 0xc3, 0xf8, 0x97, 0x05, 0x28, 0xee, 0xf8,
+	0x43, 0x2e, 0x68, 0x74, 0xdd, 0x41, 0xd2, 0x6a, 0xe7, 0x82, 0xb4, 0x03, 0xc5, 0x88, 0x31, 0x61,
+	0x3b, 0xe4, 0xbc, 0xf8, 0x60, 0xc6, 0xc4, 0x4e, 0xbb, 0x53, 0x95, 0x44, 0xd9, 0xdb, 0xe3, 0x3d,
+	0x2e, 0x48, 0xea, 0x0e, 0x41, 0x6f, 0x61, 0x35, 0x79, 0x11, 0x0f, 0x18, 0x13, 0x5c, 0x44, 0x24,
+	0xb4, 0xfb, 0x74, 0x2c, 0x67, 0xa5, 0xfc, 0x59, 0x83, 0xf6, 0x5e, 0xe0, 0x44, 0x63, 0x15, 0xbc,
+	0xe7, 0x74, 0x8c, 0x57, 0xb4, 0x80, 0x4e, 0xc2, 0x7f, 0x4e, 0xc7, 0x1c, 0x3d, 0x86, 0x35, 0x3a,
+	0x85, 0x49, 0x89, 0xb6, 0x4f, 0x06, 0xf2, 0xad, 0xb7, 0x1d, 0x9f, 0x39, 0x7d, 0xf5, 0xdc, 0x98,
+	0xf8, 0x16, 0x4d, 0x8b, 0xfa, 0x75, 0x8c, 0xd8, 0x91, 0x00, 0xc4, 0xc1, 0x3a, 0xf0, 0x89, 0xd3,
+	0xf7, 0x3d, 0x2e, 0xff, 0x97, 0x4a, 0xcd, 0xcd, 0xf2, 0xc5, 0x90, 0xb6, 0x6d, 0x9d, 0x13, 0xad,
+	0x56, 0x67, 0xc6, 0x4d, 0x4d, 0xe1, 0xba, 0xa2, 0xbe, 0x7b, 0x90, 0x7d, 0x8a, 0x3a, 0x50, 0x19,
+	0x06, 0x52, 0x7d, 0x1c, 0x83, 0xf2, 0x65, 0x63, 0x00, 0x31, 0x4b, 0x7a, 0x5e, 0x1b, 0xc1, 0xda,
+	0x79, 0xca, 0x33, 0x6a, 0xf3, 0x49, 0xba, 0x36, 0x2b, 0x9b, 0x77, 0xb3, 0xf4, 0x65, 0x8b, 0x4c,
+	0xd5, 0x71, 0x66, 0xda, 0xfe, 0xcd, 0x80, 0xc2, 0x2b, 0xea, 0x44, 0x54, 0x7c, 0xd5, 0xac, 0xdd,
+	0x3a, 0x91, 0xb5, 0xf5, 0xec, 0x41, 0x58, 0x6a, 0x9d, 0x4b, 0xda, 0x1a, 0x94, 0xbc, 0x40, 0xd0,
+	0x28, 0x20, 0xbe, 0xca, 0xda, 0x12, 0x9e, 0xee, 0x33, 0x1d, 0xf8, 0x64, 0x40, 0x21, 0x9e, 0x14,
+	0xaf, 0xdb, 0x81, 0x58, 0xeb, 0x69, 0x07, 0x32, 0x8d, 0xfc, 0x8f, 0x01, 0xa5, 0xe4, 0xc1, 0xfa,
+	0xaa, 0x66, 0x9e, 0x9a, 0xbc, 0xf2, 0xff, 0xf7, 0xe4, 0x85, 0xc0, 0xec, 0x7b, 0x81, 0x9e, 0x11,
+	0xb1, 0x5a, 0xa3, 0x16, 0x14, 0x43, 0x32, 0xf6, 0x19, 0x71, 0x75, 0xa3, 0x5c, 0x99, 0xfb, 0x95,
+	0xa2, 0x1d, 0x8c, 0x71, 0x02, 0xda, 0x5e, 0x39, 0x3c, 0x6a, 0x2e, 0x43, 0x35, 0xed, 0xf9, 0x7b,
+	0xa3, 0xf9, 0x4f, 0x03, 0xca, 0x7b, 0x7f, 0x14, 0x34, 0x50, 0xf3, 0xc0, 0x37, 0xd2, 0xf9, 0xf5,
+	0xf9, 0x5f, 0x32, 0xca, 0x27, 0x7e, 0xa4, 0xc8, 0xba, 0xd4, 0x8e, 0xf5, 0xf9, 0x4b, 0xfd, 0xc6,
+	0xbf, 0xbe, 0xd4, 0x6f, 0x7c, 0x9c, 0xd4, 0x8d, 0xcf, 0x93, 0xba, 0xf1, 0x8f, 0x49, 0xdd, 0xf8,
+	0xf7, 0xa4, 0x6e, 0x1c, 0x14, 0x54, 0x7c, 0x7e, 0xf2, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf9,
+	0xa1, 0x26, 0x54, 0x90, 0x13, 0x00, 0x00,
 }
diff --git a/vendor/github.com/docker/swarmkit/api/objects.proto b/vendor/github.com/docker/swarmkit/api/objects.proto
index 43bffca381..c3ee4195b5 100644
--- a/vendor/github.com/docker/swarmkit/api/objects.proto
+++ b/vendor/github.com/docker/swarmkit/api/objects.proto
@@ -77,10 +77,10 @@ message Node {
 	// issuing or renewing the node's certificate.
 	NodeRole role = 9;
 
-	// Each node uses the network attachment to set up an endpoint on the 
-	// node to be used for load balancing.  Each overlay network, including 
-	// ingress network, will have an NetworkAttachment.
-	repeated NetworkAttachment lb_attachments = 10;
+	// Attachments enumerates the network attachments for the node to set up an
+	// endpoint on the node to be used for load balancing. Each overlay
+	// network, including ingress network, will have an NetworkAttachment.
+	repeated NetworkAttachment attachments = 10;
 }
 
 message Service {
diff --git a/vendor/github.com/docker/swarmkit/api/specs.pb.go b/vendor/github.com/docker/swarmkit/api/specs.pb.go
index 3d000fbc39..bda30a3dfc 100644
--- a/vendor/github.com/docker/swarmkit/api/specs.pb.go
+++ b/vendor/github.com/docker/swarmkit/api/specs.pb.go
@@ -585,97 +585,12 @@ type ContainerSpec struct {
 	// task will exit and a new task will be rescheduled elsewhere. A container
 	// is considered unhealthy after `Retries` number of consecutive failures.
 	Healthcheck *HealthConfig `protobuf:"bytes,16,opt,name=healthcheck" json:"healthcheck,omitempty"`
-	// Run a custom init inside the container, if null, use the daemon's configured settings
-	//
-	// Types that are valid to be assigned to Init:
-	//	*ContainerSpec_InitValue
-	Init isContainerSpec_Init `protobuf_oneof:"init"`
 }
 
 func (m *ContainerSpec) Reset()                    { *m = ContainerSpec{} }
 func (*ContainerSpec) ProtoMessage()               {}
 func (*ContainerSpec) Descriptor() ([]byte, []int) { return fileDescriptorSpecs, []int{8} }
 
-type isContainerSpec_Init interface {
-	isContainerSpec_Init()
-	MarshalTo([]byte) (int, error)
-	Size() int
-}
-
-type ContainerSpec_InitValue struct {
-	InitValue bool `protobuf:"varint,23,opt,name=init_value,json=initValue,proto3,oneof"`
-}
-
-func (*ContainerSpec_InitValue) isContainerSpec_Init() {}
-
-func (m *ContainerSpec) GetInit() isContainerSpec_Init {
-	if m != nil {
-		return m.Init
-	}
-	return nil
-}
-
-func (m *ContainerSpec) GetInitValue() bool {
-	if x, ok := m.GetInit().(*ContainerSpec_InitValue); ok {
-		return x.InitValue
-	}
-	return false
-}
-
-// XXX_OneofFuncs is for the internal use of the proto package.
-func (*ContainerSpec) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _ContainerSpec_OneofMarshaler, _ContainerSpec_OneofUnmarshaler, _ContainerSpec_OneofSizer, []interface{}{
-		(*ContainerSpec_InitValue)(nil),
-	}
-}
-
-func _ContainerSpec_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*ContainerSpec)
-	// init
-	switch x := m.Init.(type) {
-	case *ContainerSpec_InitValue:
-		t := uint64(0)
-		if x.InitValue {
-			t = 1
-		}
-		_ = b.EncodeVarint(23<<3 | proto.WireVarint)
-		_ = b.EncodeVarint(t)
-	case nil:
-	default:
-		return fmt.Errorf("ContainerSpec.Init has unexpected type %T", x)
-	}
-	return nil
-}
-
-func _ContainerSpec_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*ContainerSpec)
-	switch tag {
-	case 23: // init.init_value
-		if wire != proto.WireVarint {
-			return true, proto.ErrInternalBadWireType
-		}
-		x, err := b.DecodeVarint()
-		m.Init = &ContainerSpec_InitValue{x != 0}
-		return true, err
-	default:
-		return false, nil
-	}
-}
-
-func _ContainerSpec_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*ContainerSpec)
-	// init
-	switch x := m.Init.(type) {
-	case *ContainerSpec_InitValue:
-		n += proto.SizeVarint(23<<3 | proto.WireVarint)
-		n += 1
-	case nil:
-	default:
-		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
-	}
-	return n
-}
-
 // PullOptions allows one to parameterize an image pull.
 type ContainerSpec_PullOptions struct {
 	// RegistryAuth is the registry auth token obtained from the client, required
@@ -1219,16 +1134,6 @@ func (m *ContainerSpec) CopyFrom(src interface{}) {
 		m.Healthcheck = &HealthConfig{}
 		github_com_docker_swarmkit_api_deepcopy.Copy(m.Healthcheck, o.Healthcheck)
 	}
-	if o.Init != nil {
-		switch o.Init.(type) {
-		case *ContainerSpec_InitValue:
-			v := ContainerSpec_InitValue{
-				InitValue: o.GetInitValue(),
-			}
-			m.Init = &v
-		}
-	}
-
 }
 
 func (m *ContainerSpec_PullOptions) Copy() *ContainerSpec_PullOptions {
@@ -2091,30 +1996,9 @@ func (m *ContainerSpec) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n23
 	}
-	if m.Init != nil {
-		nn24, err := m.Init.MarshalTo(dAtA[i:])
-		if err != nil {
-			return 0, err
-		}
-		i += nn24
-	}
 	return i, nil
 }
 
-func (m *ContainerSpec_InitValue) MarshalTo(dAtA []byte) (int, error) {
-	i := 0
-	dAtA[i] = 0xb8
-	i++
-	dAtA[i] = 0x1
-	i++
-	if m.InitValue {
-		dAtA[i] = 1
-	} else {
-		dAtA[i] = 0
-	}
-	i++
-	return i, nil
-}
 func (m *ContainerSpec_PullOptions) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -2257,20 +2141,20 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) {
 	dAtA[i] = 0xa
 	i++
 	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
-	n25, err := m.Annotations.MarshalTo(dAtA[i:])
+	n24, err := m.Annotations.MarshalTo(dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
-	i += n25
+	i += n24
 	if m.DriverConfig != nil {
 		dAtA[i] = 0x12
 		i++
 		i = encodeVarintSpecs(dAtA, i, uint64(m.DriverConfig.Size()))
-		n26, err := m.DriverConfig.MarshalTo(dAtA[i:])
+		n25, err := m.DriverConfig.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n26
+		i += n25
 	}
 	if m.Ipv6Enabled {
 		dAtA[i] = 0x18
@@ -2296,11 +2180,11 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x2a
 		i++
 		i = encodeVarintSpecs(dAtA, i, uint64(m.IPAM.Size()))
-		n27, err := m.IPAM.MarshalTo(dAtA[i:])
+		n26, err := m.IPAM.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n27
+		i += n26
 	}
 	if m.Attachable {
 		dAtA[i] = 0x30
@@ -2323,11 +2207,11 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) {
 		i++
 	}
 	if m.ConfigFrom != nil {
-		nn28, err := m.ConfigFrom.MarshalTo(dAtA[i:])
+		nn27, err := m.ConfigFrom.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += nn28
+		i += nn27
 	}
 	return i, nil
 }
@@ -2358,67 +2242,67 @@ func (m *ClusterSpec) MarshalTo(dAtA []byte) (int, error) {
 	dAtA[i] = 0xa
 	i++
 	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
-	n29, err := m.Annotations.MarshalTo(dAtA[i:])
+	n28, err := m.Annotations.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
+	}
+	i += n28
+	dAtA[i] = 0x12
+	i++
+	i = encodeVarintSpecs(dAtA, i, uint64(m.AcceptancePolicy.Size()))
+	n29, err := m.AcceptancePolicy.MarshalTo(dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
 	i += n29
-	dAtA[i] = 0x12
+	dAtA[i] = 0x1a
 	i++
-	i = encodeVarintSpecs(dAtA, i, uint64(m.AcceptancePolicy.Size()))
-	n30, err := m.AcceptancePolicy.MarshalTo(dAtA[i:])
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Orchestration.Size()))
+	n30, err := m.Orchestration.MarshalTo(dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
 	i += n30
-	dAtA[i] = 0x1a
+	dAtA[i] = 0x22
 	i++
-	i = encodeVarintSpecs(dAtA, i, uint64(m.Orchestration.Size()))
-	n31, err := m.Orchestration.MarshalTo(dAtA[i:])
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Raft.Size()))
+	n31, err := m.Raft.MarshalTo(dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
 	i += n31
-	dAtA[i] = 0x22
+	dAtA[i] = 0x2a
 	i++
-	i = encodeVarintSpecs(dAtA, i, uint64(m.Raft.Size()))
-	n32, err := m.Raft.MarshalTo(dAtA[i:])
+	i = encodeVarintSpecs(dAtA, i, uint64(m.Dispatcher.Size()))
+	n32, err := m.Dispatcher.MarshalTo(dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
 	i += n32
-	dAtA[i] = 0x2a
+	dAtA[i] = 0x32
 	i++
-	i = encodeVarintSpecs(dAtA, i, uint64(m.Dispatcher.Size()))
-	n33, err := m.Dispatcher.MarshalTo(dAtA[i:])
+	i = encodeVarintSpecs(dAtA, i, uint64(m.CAConfig.Size()))
+	n33, err := m.CAConfig.MarshalTo(dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
 	i += n33
-	dAtA[i] = 0x32
+	dAtA[i] = 0x3a
 	i++
-	i = encodeVarintSpecs(dAtA, i, uint64(m.CAConfig.Size()))
-	n34, err := m.CAConfig.MarshalTo(dAtA[i:])
+	i = encodeVarintSpecs(dAtA, i, uint64(m.TaskDefaults.Size()))
+	n34, err := m.TaskDefaults.MarshalTo(dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
 	i += n34
-	dAtA[i] = 0x3a
+	dAtA[i] = 0x42
 	i++
-	i = encodeVarintSpecs(dAtA, i, uint64(m.TaskDefaults.Size()))
-	n35, err := m.TaskDefaults.MarshalTo(dAtA[i:])
+	i = encodeVarintSpecs(dAtA, i, uint64(m.EncryptionConfig.Size()))
+	n35, err := m.EncryptionConfig.MarshalTo(dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
 	i += n35
-	dAtA[i] = 0x42
-	i++
-	i = encodeVarintSpecs(dAtA, i, uint64(m.EncryptionConfig.Size()))
-	n36, err := m.EncryptionConfig.MarshalTo(dAtA[i:])
-	if err != nil {
-		return 0, err
-	}
-	i += n36
 	return i, nil
 }
 
@@ -2440,11 +2324,11 @@ func (m *SecretSpec) MarshalTo(dAtA []byte) (int, error) {
 	dAtA[i] = 0xa
 	i++
 	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
-	n37, err := m.Annotations.MarshalTo(dAtA[i:])
+	n36, err := m.Annotations.MarshalTo(dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
-	i += n37
+	i += n36
 	if len(m.Data) > 0 {
 		dAtA[i] = 0x12
 		i++
@@ -2455,21 +2339,21 @@ func (m *SecretSpec) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x1a
 		i++
 		i = encodeVarintSpecs(dAtA, i, uint64(m.Templating.Size()))
-		n38, err := m.Templating.MarshalTo(dAtA[i:])
+		n37, err := m.Templating.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n38
+		i += n37
 	}
 	if m.Driver != nil {
 		dAtA[i] = 0x22
 		i++
 		i = encodeVarintSpecs(dAtA, i, uint64(m.Driver.Size()))
-		n39, err := m.Driver.MarshalTo(dAtA[i:])
+		n38, err := m.Driver.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n39
+		i += n38
 	}
 	return i, nil
 }
@@ -2492,11 +2376,11 @@ func (m *ConfigSpec) MarshalTo(dAtA []byte) (int, error) {
 	dAtA[i] = 0xa
 	i++
 	i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
-	n40, err := m.Annotations.MarshalTo(dAtA[i:])
+	n39, err := m.Annotations.MarshalTo(dAtA[i:])
 	if err != nil {
 		return 0, err
 	}
-	i += n40
+	i += n39
 	if len(m.Data) > 0 {
 		dAtA[i] = 0x12
 		i++
@@ -2507,11 +2391,11 @@ func (m *ConfigSpec) MarshalTo(dAtA []byte) (int, error) {
 		dAtA[i] = 0x1a
 		i++
 		i = encodeVarintSpecs(dAtA, i, uint64(m.Templating.Size()))
-		n41, err := m.Templating.MarshalTo(dAtA[i:])
+		n40, err := m.Templating.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
-		i += n41
+		i += n40
 	}
 	return i, nil
 }
@@ -2837,18 +2721,9 @@ func (m *ContainerSpec) Size() (n int) {
 		l = m.Privileges.Size()
 		n += 2 + l + sovSpecs(uint64(l))
 	}
-	if m.Init != nil {
-		n += m.Init.Size()
-	}
 	return n
 }
 
-func (m *ContainerSpec_InitValue) Size() (n int) {
-	var l int
-	_ = l
-	n += 3
-	return n
-}
 func (m *ContainerSpec_PullOptions) Size() (n int) {
 	var l int
 	_ = l
@@ -3191,17 +3066,6 @@ func (this *ContainerSpec) String() string {
 		`StopSignal:` + fmt.Sprintf("%v", this.StopSignal) + `,`,
 		`Configs:` + strings.Replace(fmt.Sprintf("%v", this.Configs), "ConfigReference", "ConfigReference", 1) + `,`,
 		`Privileges:` + strings.Replace(fmt.Sprintf("%v", this.Privileges), "Privileges", "Privileges", 1) + `,`,
-		`Init:` + fmt.Sprintf("%v", this.Init) + `,`,
-		`}`,
-	}, "")
-	return s
-}
-func (this *ContainerSpec_InitValue) String() string {
-	if this == nil {
-		return "nil"
-	}
-	s := strings.Join([]string{`&ContainerSpec_InitValue{`,
-		`InitValue:` + fmt.Sprintf("%v", this.InitValue) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -5277,27 +5141,6 @@ func (m *ContainerSpec) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 23:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field InitValue", wireType)
-			}
-			var v int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowSpecs
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				v |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			b := bool(v != 0)
-			m.Init = &ContainerSpec_InitValue{b}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipSpecs(dAtA[iNdEx:])
@@ -6609,130 +6452,129 @@ var (
 func init() { proto.RegisterFile("github.com/docker/swarmkit/api/specs.proto", fileDescriptorSpecs) }
 
 var fileDescriptorSpecs = []byte{
-	// 2000 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0x4f, 0x6f, 0x1b, 0xb9,
-	0x15, 0xb7, 0x6c, 0x59, 0x7f, 0xde, 0xc8, 0x89, 0xc2, 0x4d, 0xb2, 0x13, 0xa5, 0x6b, 0x29, 0xda,
-	0x6c, 0xea, 0xdd, 0x45, 0x65, 0xd4, 0x2d, 0xb6, 0xd9, 0x4d, 0xb7, 0xad, 0x64, 0xa9, 0x8e, 0x9b,
-	0xc6, 0x11, 0x68, 0x6f, 0xda, 0x00, 0x05, 0x04, 0x7a, 0x86, 0x96, 0x08, 0x8f, 0x86, 0x53, 0x0e,
-	0xc7, 0x0b, 0xdd, 0x7a, 0x5c, 0xa4, 0x9f, 0x21, 0xe8, 0xa1, 0xe8, 0xbd, 0x1f, 0xa0, 0x1f, 0x20,
-	0xc7, 0x1e, 0xdb, 0x8b, 0xd1, 0xd5, 0x57, 0xe8, 0xad, 0x97, 0x16, 0xe4, 0x70, 0x46, 0xa3, 0x64,
-	0x1c, 0x07, 0x68, 0x0e, 0x7b, 0x23, 0xdf, 0xfc, 0x7e, 0x6f, 0x1e, 0xc9, 0xdf, 0xe3, 0x7b, 0x84,
-	0x4f, 0xc6, 0x4c, 0x4e, 0xa2, 0xe3, 0x8e, 0xc3, 0xa7, 0xdb, 0x2e, 0x77, 0x4e, 0xa9, 0xd8, 0x0e,
-	0xbf, 0x26, 0x62, 0x7a, 0xca, 0xe4, 0x36, 0x09, 0xd8, 0x76, 0x18, 0x50, 0x27, 0xec, 0x04, 0x82,
-	0x4b, 0x8e, 0x50, 0x0c, 0xe8, 0x24, 0x80, 0xce, 0xd9, 0x0f, 0x1b, 0x97, 0xf1, 0xe5, 0x2c, 0xa0,
-	0x86, 0xdf, 0xb8, 0x3e, 0xe6, 0x63, 0xae, 0x87, 0xdb, 0x6a, 0x64, 0xac, 0x9b, 0x63, 0xce, 0xc7,
-	0x1e, 0xdd, 0xd6, 0xb3, 0xe3, 0xe8, 0x64, 0xdb, 0x8d, 0x04, 0x91, 0x8c, 0xfb, 0xe6, 0xfb, 0xad,
-	0x57, 0xbf, 0x13, 0x7f, 0x16, 0x7f, 0x6a, 0xbf, 0x28, 0x42, 0xe5, 0x80, 0xbb, 0xf4, 0x30, 0xa0,
-	0x0e, 0xda, 0x03, 0x8b, 0xf8, 0x3e, 0x97, 0x9a, 0x1b, 0xda, 0x85, 0x56, 0x61, 0xcb, 0xda, 0x69,
-	0x76, 0x5e, 0x8f, 0xb9, 0xd3, 0x5d, 0xc0, 0x7a, 0xc5, 0x97, 0xe7, 0xcd, 0x15, 0x9c, 0x65, 0xa2,
-	0x9f, 0x43, 0xcd, 0xa5, 0x21, 0x13, 0xd4, 0x1d, 0x09, 0xee, 0x51, 0x7b, 0xb5, 0x55, 0xd8, 0xba,
-	0xb2, 0xf3, 0xbd, 0x3c, 0x4f, 0xea, 0xe7, 0x98, 0x7b, 0x14, 0x5b, 0x86, 0xa1, 0x26, 0x68, 0x0f,
-	0x60, 0x4a, 0xa7, 0xc7, 0x54, 0x84, 0x13, 0x16, 0xd8, 0x6b, 0x9a, 0xfe, 0xfd, 0x8b, 0xe8, 0x2a,
-	0xf6, 0xce, 0xe3, 0x14, 0x8e, 0x33, 0x54, 0xf4, 0x18, 0x6a, 0xe4, 0x8c, 0x30, 0x8f, 0x1c, 0x33,
-	0x8f, 0xc9, 0x99, 0x5d, 0xd4, 0xae, 0x3e, 0x7e, 0xa3, 0xab, 0x6e, 0x86, 0x80, 0x97, 0xe8, 0x6d,
-	0x17, 0x60, 0xf1, 0x23, 0x74, 0x0f, 0xca, 0xc3, 0xc1, 0x41, 0x7f, 0xff, 0x60, 0xaf, 0xbe, 0xd2,
-	0xb8, 0xf5, 0xfc, 0x45, 0xeb, 0x86, 0xf2, 0xb1, 0x00, 0x0c, 0xa9, 0xef, 0x32, 0x7f, 0x8c, 0xb6,
-	0xa0, 0xd2, 0xdd, 0xdd, 0x1d, 0x0c, 0x8f, 0x06, 0xfd, 0x7a, 0xa1, 0xd1, 0x78, 0xfe, 0xa2, 0x75,
-	0x73, 0x19, 0xd8, 0x75, 0x1c, 0x1a, 0x48, 0xea, 0x36, 0x8a, 0xdf, 0xfc, 0x79, 0x73, 0xa5, 0xfd,
-	0x4d, 0x01, 0x6a, 0xd9, 0x20, 0xd0, 0x3d, 0x28, 0x75, 0x77, 0x8f, 0xf6, 0x9f, 0x0e, 0xea, 0x2b,
-	0x0b, 0x7a, 0x16, 0xd1, 0x75, 0x24, 0x3b, 0xa3, 0xe8, 0x2e, 0xac, 0x0f, 0xbb, 0x5f, 0x1d, 0x0e,
-	0xea, 0x85, 0x45, 0x38, 0x59, 0xd8, 0x90, 0x44, 0xa1, 0x46, 0xf5, 0x71, 0x77, 0xff, 0xa0, 0xbe,
-	0x9a, 0x8f, 0xea, 0x0b, 0xc2, 0x7c, 0x13, 0xca, 0x9f, 0x8a, 0x60, 0x1d, 0x52, 0x71, 0xc6, 0x9c,
-	0x77, 0x2c, 0x91, 0xcf, 0xa0, 0x28, 0x49, 0x78, 0xaa, 0xa5, 0x61, 0xe5, 0x4b, 0xe3, 0x88, 0x84,
-	0xa7, 0xea, 0xa7, 0x86, 0xae, 0xf1, 0x4a, 0x19, 0x82, 0x06, 0x1e, 0x73, 0x88, 0xa4, 0xae, 0x56,
-	0x86, 0xb5, 0xf3, 0x51, 0x1e, 0x1b, 0xa7, 0x28, 0x13, 0xff, 0xc3, 0x15, 0x9c, 0xa1, 0xa2, 0x07,
-	0x50, 0x1a, 0x7b, 0xfc, 0x98, 0x78, 0x5a, 0x13, 0xd6, 0xce, 0x9d, 0x3c, 0x27, 0x7b, 0x1a, 0xb1,
-	0x70, 0x60, 0x28, 0xe8, 0x3e, 0x94, 0xa2, 0xc0, 0x25, 0x92, 0xda, 0x25, 0x4d, 0x6e, 0xe5, 0x91,
-	0xbf, 0xd2, 0x88, 0x5d, 0xee, 0x9f, 0xb0, 0x31, 0x36, 0x78, 0xf4, 0x08, 0x2a, 0x3e, 0x95, 0x5f,
-	0x73, 0x71, 0x1a, 0xda, 0xe5, 0xd6, 0xda, 0x96, 0xb5, 0xf3, 0x69, 0xae, 0x18, 0x63, 0x4c, 0x57,
-	0x4a, 0xe2, 0x4c, 0xa6, 0xd4, 0x97, 0xb1, 0x9b, 0xde, 0xaa, 0x5d, 0xc0, 0xa9, 0x03, 0xf4, 0x53,
-	0xa8, 0x50, 0xdf, 0x0d, 0x38, 0xf3, 0xa5, 0x5d, 0xb9, 0x38, 0x90, 0x81, 0xc1, 0xa8, 0xcd, 0xc4,
-	0x29, 0x43, 0xb1, 0x05, 0xf7, 0xbc, 0x63, 0xe2, 0x9c, 0xda, 0xd5, 0xb7, 0x5c, 0x46, 0xca, 0xe8,
-	0x95, 0xa0, 0x38, 0xe5, 0x2e, 0x6d, 0x6f, 0xc3, 0xb5, 0xd7, 0xb6, 0x1a, 0x35, 0xa0, 0x62, 0xb6,
-	0x3a, 0xd6, 0x48, 0x11, 0xa7, 0xf3, 0xf6, 0x55, 0xd8, 0x58, 0xda, 0xd6, 0xf6, 0x5f, 0xd7, 0xa1,
-	0x92, 0x9c, 0x35, 0xea, 0x42, 0xd5, 0xe1, 0xbe, 0x24, 0xcc, 0xa7, 0xc2, 0xc8, 0x2b, 0xf7, 0x64,
-	0x76, 0x13, 0x90, 0x62, 0x3d, 0x5c, 0xc1, 0x0b, 0x16, 0xfa, 0x25, 0x54, 0x05, 0x0d, 0x79, 0x24,
-	0x1c, 0x1a, 0x1a, 0x7d, 0x6d, 0xe5, 0x2b, 0x24, 0x06, 0x61, 0xfa, 0xfb, 0x88, 0x09, 0xaa, 0x76,
-	0x39, 0xc4, 0x0b, 0x2a, 0x7a, 0x00, 0x65, 0x41, 0x43, 0x49, 0x84, 0x7c, 0x93, 0x44, 0x70, 0x0c,
-	0x19, 0x72, 0x8f, 0x39, 0x33, 0x9c, 0x30, 0xd0, 0x03, 0xa8, 0x06, 0x1e, 0x71, 0xb4, 0x57, 0x7b,
-	0x5d, 0xd3, 0x3f, 0xc8, 0xa3, 0x0f, 0x13, 0x10, 0x5e, 0xe0, 0xd1, 0xe7, 0x00, 0x1e, 0x1f, 0x8f,
-	0x5c, 0xc1, 0xce, 0xa8, 0x30, 0x12, 0x6b, 0xe4, 0xb1, 0xfb, 0x1a, 0x81, 0xab, 0x1e, 0x1f, 0xc7,
-	0x43, 0xb4, 0xf7, 0x7f, 0xe9, 0x2b, 0xa3, 0xad, 0x47, 0x00, 0x24, 0xfd, 0x6a, 0xd4, 0xf5, 0xf1,
-	0x5b, 0xb9, 0x32, 0x27, 0x92, 0xa1, 0xa3, 0x3b, 0x50, 0x3b, 0xe1, 0xc2, 0xa1, 0x23, 0x93, 0x35,
-	0x55, 0xad, 0x09, 0x4b, 0xdb, 0x62, 0x7d, 0xa1, 0x1e, 0x94, 0xc7, 0xd4, 0xa7, 0x82, 0x39, 0x36,
-	0xe8, 0x9f, 0xdd, 0xcb, 0x4d, 0xc8, 0x18, 0x82, 0x23, 0x5f, 0xb2, 0x29, 0x35, 0x7f, 0x4a, 0x88,
-	0xe8, 0x77, 0xf0, 0x5e, 0x72, 0x7c, 0x23, 0x41, 0x4f, 0xa8, 0xa0, 0xbe, 0xd2, 0x80, 0xa5, 0xf7,
-	0xe1, 0xa3, 0x37, 0x6b, 0xc0, 0xa0, 0xcd, 0x65, 0x83, 0xc4, 0xab, 0x1f, 0xc2, 0x5e, 0x15, 0xca,
-	0x22, 0xfe, 0x6f, 0xfb, 0x8f, 0x05, 0xa5, 0xfa, 0x57, 0x10, 0x68, 0x1b, 0xac, 0xf4, 0xf7, 0xcc,
-	0xd5, 0xea, 0xad, 0xf6, 0xae, 0xcc, 0xcf, 0x9b, 0x90, 0x60, 0xf7, 0xfb, 0xea, 0x0e, 0x32, 0x63,
-	0x17, 0x0d, 0x60, 0x23, 0x25, 0xa8, 0x32, 0x6f, 0x0a, 0x65, 0xeb, 0x4d, 0x91, 0x1e, 0xcd, 0x02,
-	0x8a, 0x6b, 0x22, 0x33, 0x6b, 0xff, 0x16, 0xd0, 0xeb, 0xfb, 0x82, 0x10, 0x14, 0x4f, 0x99, 0x6f,
-	0xc2, 0xc0, 0x7a, 0x8c, 0x3a, 0x50, 0x0e, 0xc8, 0xcc, 0xe3, 0xc4, 0x35, 0x89, 0x71, 0xbd, 0x13,
-	0xf7, 0x06, 0x9d, 0xa4, 0x37, 0xe8, 0x74, 0xfd, 0x19, 0x4e, 0x40, 0xed, 0x47, 0x70, 0x23, 0xf7,
-	0x78, 0xd1, 0x0e, 0xd4, 0xd2, 0x84, 0x5b, 0xac, 0xf5, 0xea, 0xfc, 0xbc, 0x69, 0xa5, 0x99, 0xb9,
-	0xdf, 0xc7, 0x56, 0x0a, 0xda, 0x77, 0xdb, 0x7f, 0xab, 0xc2, 0xc6, 0x52, 0xda, 0xa2, 0xeb, 0xb0,
-	0xce, 0xa6, 0x64, 0x4c, 0x4d, 0x8c, 0xf1, 0x04, 0x0d, 0xa0, 0xe4, 0x91, 0x63, 0xea, 0xa9, 0xe4,
-	0x55, 0x07, 0xf7, 0x83, 0x4b, 0xf3, 0xbf, 0xf3, 0x6b, 0x8d, 0x1f, 0xf8, 0x52, 0xcc, 0xb0, 0x21,
-	0x23, 0x1b, 0xca, 0x0e, 0x9f, 0x4e, 0x89, 0xaf, 0xca, 0xc4, 0xda, 0x56, 0x15, 0x27, 0x53, 0xb5,
-	0x33, 0x44, 0x8c, 0x43, 0xbb, 0xa8, 0xcd, 0x7a, 0x8c, 0xea, 0xb0, 0x46, 0xfd, 0x33, 0x7b, 0x5d,
-	0x9b, 0xd4, 0x50, 0x59, 0x5c, 0x16, 0x67, 0x5f, 0x15, 0xab, 0xa1, 0xe2, 0x45, 0x21, 0x15, 0x76,
-	0x39, 0xde, 0x51, 0x35, 0x46, 0x3f, 0x81, 0xd2, 0x94, 0x47, 0xbe, 0x0c, 0xed, 0x8a, 0x0e, 0xf6,
-	0x56, 0x5e, 0xb0, 0x8f, 0x15, 0xc2, 0x28, 0xcb, 0xc0, 0xd1, 0x00, 0xae, 0x85, 0x92, 0x07, 0xa3,
-	0xb1, 0x20, 0x0e, 0x1d, 0x05, 0x54, 0x30, 0xee, 0x9a, 0x6b, 0xf8, 0xd6, 0x6b, 0x87, 0xd2, 0x37,
-	0x0d, 0x1d, 0xbe, 0xaa, 0x38, 0x7b, 0x8a, 0x32, 0xd4, 0x0c, 0x34, 0x84, 0x5a, 0x10, 0x79, 0xde,
-	0x88, 0x07, 0x71, 0x45, 0x8e, 0x73, 0xe7, 0x2d, 0xb6, 0x6c, 0x18, 0x79, 0xde, 0x93, 0x98, 0x84,
-	0xad, 0x60, 0x31, 0x41, 0x37, 0xa1, 0x34, 0x16, 0x3c, 0x0a, 0xe2, 0xbc, 0xa9, 0x62, 0x33, 0x43,
-	0x5f, 0x42, 0x39, 0xa4, 0x8e, 0xa0, 0x32, 0xb4, 0x6b, 0x7a, 0xa9, 0x1f, 0xe6, 0xfd, 0xe4, 0x50,
-	0x43, 0xd2, 0x9c, 0xc0, 0x09, 0x07, 0xdd, 0x82, 0x35, 0x29, 0x67, 0xf6, 0x46, 0xab, 0xb0, 0x55,
-	0xe9, 0x95, 0xe7, 0xe7, 0xcd, 0xb5, 0xa3, 0xa3, 0x67, 0x58, 0xd9, 0x54, 0xb5, 0x98, 0xf0, 0x50,
-	0xfa, 0x64, 0x4a, 0xed, 0x2b, 0x7a, 0x6f, 0xd3, 0x39, 0x7a, 0x06, 0xe0, 0xfa, 0xe1, 0xc8, 0xd1,
-	0xd7, 0x93, 0x7d, 0x55, 0xaf, 0xee, 0xd3, 0xcb, 0x57, 0xd7, 0x3f, 0x38, 0x34, 0x15, 0x73, 0x63,
-	0x7e, 0xde, 0xac, 0xa6, 0x53, 0x5c, 0x75, 0xfd, 0x30, 0x1e, 0xa2, 0x1e, 0x58, 0x13, 0x4a, 0x3c,
-	0x39, 0x71, 0x26, 0xd4, 0x39, 0xb5, 0xeb, 0x17, 0x97, 0xc0, 0x87, 0x1a, 0x66, 0x3c, 0x64, 0x49,
-	0x4a, 0xc1, 0x2a, 0xd4, 0xd0, 0xbe, 0xa6, 0xf7, 0x2a, 0x9e, 0xa0, 0x0f, 0x00, 0x78, 0x40, 0xfd,
-	0x51, 0x28, 0x5d, 0xe6, 0xdb, 0x48, 0x2d, 0x19, 0x57, 0x95, 0xe5, 0x50, 0x19, 0xd0, 0x6d, 0x55,
-	0xa0, 0x88, 0x3b, 0xe2, 0xbe, 0x37, 0xb3, 0xdf, 0xd3, 0x5f, 0x2b, 0xca, 0xf0, 0xc4, 0xf7, 0x66,
-	0xa8, 0x09, 0x96, 0xd6, 0x45, 0xc8, 0xc6, 0x3e, 0xf1, 0xec, 0xeb, 0x7a, 0x3f, 0x40, 0x99, 0x0e,
-	0xb5, 0x45, 0x9d, 0x43, 0xbc, 0x1b, 0xa1, 0x7d, 0xe3, 0xe2, 0x73, 0x30, 0xc1, 0x2e, 0xce, 0xc1,
-	0x70, 0xd0, 0xcf, 0x00, 0x02, 0xc1, 0xce, 0x98, 0x47, 0xc7, 0x34, 0xb4, 0x6f, 0xea, 0x45, 0x6f,
-	0xe6, 0x56, 0xa6, 0x14, 0x85, 0x33, 0x0c, 0xd4, 0x04, 0x60, 0x3e, 0x93, 0xa3, 0x33, 0xe2, 0x45,
-	0xd4, 0x7e, 0x5f, 0x45, 0xaf, 0xca, 0xaf, 0xb2, 0x3d, 0x55, 0xa6, 0xc6, 0xe7, 0x60, 0x65, 0xd2,
-	0x51, 0xa5, 0xd1, 0x29, 0x9d, 0x99, 0x0c, 0x57, 0x43, 0xb5, 0x67, 0x31, 0x79, 0x35, 0xce, 0x7a,
-	0x3d, 0xf9, 0x62, 0xf5, 0x7e, 0xa1, 0xb1, 0x03, 0x56, 0x46, 0x96, 0xe8, 0x43, 0x75, 0x3d, 0x8e,
-	0x59, 0x28, 0xc5, 0x6c, 0x44, 0x22, 0x39, 0xb1, 0x7f, 0xa1, 0x09, 0xb5, 0xc4, 0xd8, 0x8d, 0xe4,
-	0xa4, 0x31, 0x82, 0xc5, 0xe9, 0xa2, 0x16, 0x58, 0x4a, 0x35, 0x21, 0x15, 0x67, 0x54, 0xa8, 0xd6,
-	0x43, 0x1d, 0x4a, 0xd6, 0xa4, 0xd4, 0x1d, 0x52, 0x22, 0x9c, 0x89, 0xbe, 0x5c, 0xaa, 0xd8, 0xcc,
-	0xd4, 0x6d, 0x91, 0xa4, 0x90, 0xb9, 0x2d, 0xcc, 0x54, 0x35, 0x3a, 0x6a, 0x71, 0xed, 0x7f, 0x17,
-	0xa0, 0x96, 0xed, 0xa4, 0xd0, 0x6e, 0xdc, 0x01, 0xe9, 0xa5, 0x5d, 0xd9, 0xd9, 0xbe, 0xac, 0xf3,
-	0xd2, 0x37, 0xb8, 0x17, 0x29, 0xa7, 0x8f, 0xd5, 0xa3, 0x47, 0x93, 0xd1, 0x8f, 0x61, 0x3d, 0xe0,
-	0x42, 0x26, 0x77, 0x5d, 0xfe, 0x49, 0x70, 0x91, 0xd4, 0xe7, 0x18, 0xdc, 0x9e, 0xc0, 0x95, 0x65,
-	0x6f, 0xe8, 0x2e, 0xac, 0x3d, 0xdd, 0x1f, 0xd6, 0x57, 0x1a, 0xb7, 0x9f, 0xbf, 0x68, 0xbd, 0xbf,
-	0xfc, 0xf1, 0x29, 0x13, 0x32, 0x22, 0xde, 0xfe, 0x10, 0x7d, 0x02, 0xeb, 0xfd, 0x83, 0x43, 0x8c,
-	0xeb, 0x85, 0x46, 0xf3, 0xf9, 0x8b, 0xd6, 0xed, 0x65, 0x9c, 0xfa, 0xc4, 0x23, 0xdf, 0xc5, 0xfc,
-	0x38, 0x7d, 0x00, 0xfc, 0x67, 0x15, 0x2c, 0x53, 0x02, 0xde, 0xf5, 0x1b, 0x71, 0x23, 0xee, 0x6f,
-	0x92, 0xdc, 0x5e, 0xbd, 0xb4, 0xcd, 0xa9, 0xc5, 0x04, 0x73, 0xd6, 0x77, 0xa0, 0xc6, 0x82, 0xb3,
-	0xcf, 0x46, 0xd4, 0x27, 0xc7, 0x9e, 0x79, 0x0b, 0x54, 0xb0, 0xa5, 0x6c, 0x83, 0xd8, 0xa4, 0x2e,
-	0x16, 0xe6, 0x4b, 0x2a, 0x7c, 0xd3, 0xe5, 0x57, 0x70, 0x3a, 0x47, 0x5f, 0x42, 0x91, 0x05, 0x64,
-	0x6a, 0x7a, 0xb3, 0xdc, 0x15, 0xec, 0x0f, 0xbb, 0x8f, 0x8d, 0x16, 0x7b, 0x95, 0xf9, 0x79, 0xb3,
-	0xa8, 0x0c, 0x58, 0xd3, 0xd0, 0x66, 0xd2, 0x1e, 0xa9, 0x3f, 0xe9, 0x22, 0x51, 0xc1, 0x19, 0x8b,
-	0xd2, 0x13, 0xf3, 0xc7, 0x82, 0x86, 0xa1, 0x2e, 0x17, 0x15, 0x9c, 0x4c, 0x51, 0x03, 0xca, 0xa6,
-	0xc9, 0xd2, 0x5d, 0x55, 0x55, 0x35, 0x30, 0xc6, 0xd0, 0xdb, 0x00, 0x2b, 0xde, 0x8d, 0xd1, 0x89,
-	0xe0, 0xd3, 0xf6, 0x7f, 0x8b, 0x60, 0xed, 0x7a, 0x51, 0x28, 0x4d, 0xbd, 0x7c, 0x67, 0x9b, 0xff,
-	0x0c, 0xae, 0x11, 0xfd, 0xe6, 0x24, 0xbe, 0x2a, 0x3e, 0xba, 0x77, 0x35, 0x07, 0x70, 0x37, 0xd7,
-	0x5d, 0x0a, 0x8e, 0xfb, 0xdc, 0x5e, 0x49, 0xf9, 0xb4, 0x0b, 0xb8, 0x4e, 0x5e, 0xf9, 0x82, 0x0e,
-	0x61, 0x83, 0x0b, 0x67, 0x42, 0x43, 0x19, 0x97, 0x2c, 0xf3, 0x46, 0xcb, 0x7d, 0xbd, 0x3f, 0xc9,
-	0x02, 0xcd, 0x7d, 0x1d, 0x47, 0xbb, 0xec, 0x03, 0xdd, 0x87, 0xa2, 0x20, 0x27, 0x49, 0x1f, 0x9e,
-	0x9b, 0x24, 0x98, 0x9c, 0xc8, 0x25, 0x17, 0x9a, 0x81, 0x7e, 0x05, 0xe0, 0xb2, 0x30, 0x20, 0xd2,
-	0x99, 0x50, 0x61, 0x0e, 0x3b, 0x77, 0x89, 0xfd, 0x14, 0xb5, 0xe4, 0x25, 0xc3, 0x46, 0x8f, 0xa0,
-	0xea, 0x90, 0x44, 0xae, 0xa5, 0x8b, 0x1f, 0xae, 0xbb, 0x5d, 0xe3, 0xa2, 0xae, 0x5c, 0xcc, 0xcf,
-	0x9b, 0x95, 0xc4, 0x82, 0x2b, 0x0e, 0x31, 0xf2, 0x7d, 0x04, 0x1b, 0xea, 0x41, 0x3b, 0x72, 0xe9,
-	0x09, 0x89, 0x3c, 0x19, 0xcb, 0xe4, 0x82, 0xfa, 0xa3, 0x5e, 0x47, 0x7d, 0x83, 0x33, 0x71, 0xd5,
-	0x64, 0xc6, 0x86, 0x7e, 0x03, 0xd7, 0xa8, 0xef, 0x88, 0x99, 0x16, 0x6b, 0x12, 0x61, 0xe5, 0xe2,
-	0xc5, 0x0e, 0x52, 0xf0, 0xd2, 0x62, 0xeb, 0xf4, 0x15, 0x7b, 0xfb, 0x9f, 0x05, 0x80, 0xb8, 0xa4,
-	0xbf, 0x5b, 0x01, 0x22, 0x28, 0xba, 0x44, 0x12, 0xad, 0xb9, 0x1a, 0xd6, 0x63, 0xf4, 0x05, 0x80,
-	0xa4, 0xd3, 0xc0, 0x23, 0x92, 0xf9, 0x63, 0x23, 0x9b, 0x37, 0x5d, 0x07, 0x19, 0x34, 0xda, 0x81,
-	0x92, 0x79, 0x2d, 0x15, 0x2f, 0xe5, 0x19, 0x64, 0xfb, 0x2f, 0x05, 0x80, 0x78, 0x99, 0xdf, 0xe9,
-	0xb5, 0xf5, 0xec, 0x97, 0xdf, 0x6e, 0xae, 0xfc, 0xe3, 0xdb, 0xcd, 0x95, 0x3f, 0xcc, 0x37, 0x0b,
-	0x2f, 0xe7, 0x9b, 0x85, 0xbf, 0xcf, 0x37, 0x0b, 0xff, 0x9a, 0x6f, 0x16, 0x8e, 0x4b, 0xba, 0x41,
-	0xfc, 0xd1, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x4f, 0xdf, 0x5d, 0x60, 0x83, 0x14, 0x00, 0x00,
+	// 1975 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xcf, 0x6f, 0x1b, 0xb9,
+	0x15, 0xb6, 0x6c, 0x59, 0x3f, 0xde, 0xc8, 0x89, 0xc2, 0xcd, 0xa6, 0x13, 0xa5, 0x6b, 0x2b, 0xda,
+	0x6c, 0xea, 0xdd, 0x45, 0x25, 0xd4, 0x2d, 0xb6, 0xd9, 0x4d, 0xb7, 0xad, 0x64, 0xa9, 0x8e, 0x9b,
+	0xc6, 0x11, 0x68, 0x6f, 0xda, 0x00, 0x05, 0x04, 0x6a, 0x86, 0x1e, 0x0d, 0x3c, 0x1a, 0x4e, 0x39,
+	0x1c, 0x2d, 0x74, 0xeb, 0x71, 0x91, 0x1e, 0x7b, 0x0e, 0x7a, 0x28, 0x7a, 0xef, 0x9f, 0x91, 0x63,
+	0x8f, 0xed, 0xc5, 0xe8, 0xea, 0x5f, 0xe8, 0xad, 0x97, 0x16, 0xe4, 0x70, 0x46, 0xa3, 0x64, 0x6c,
+	0x07, 0x68, 0x0e, 0xbd, 0x91, 0x8f, 0xdf, 0xf7, 0x48, 0x3e, 0x7e, 0x8f, 0x7c, 0x84, 0x4f, 0x1c,
+	0x57, 0x4c, 0xa2, 0x71, 0xdb, 0x62, 0xd3, 0x8e, 0xcd, 0xac, 0x33, 0xca, 0x3b, 0xe1, 0xd7, 0x84,
+	0x4f, 0xcf, 0x5c, 0xd1, 0x21, 0x81, 0xdb, 0x09, 0x03, 0x6a, 0x85, 0xed, 0x80, 0x33, 0xc1, 0x10,
+	0x8a, 0x01, 0xed, 0x04, 0xd0, 0x9e, 0xfd, 0xa0, 0x71, 0x15, 0x5f, 0xcc, 0x03, 0xaa, 0xf9, 0x8d,
+	0x9b, 0x0e, 0x73, 0x98, 0x6a, 0x76, 0x64, 0x4b, 0x5b, 0xb7, 0x1d, 0xc6, 0x1c, 0x8f, 0x76, 0x54,
+	0x6f, 0x1c, 0x9d, 0x76, 0xec, 0x88, 0x13, 0xe1, 0x32, 0x5f, 0x8f, 0xdf, 0x7e, 0x7d, 0x9c, 0xf8,
+	0xf3, 0x78, 0xa8, 0xf5, 0xb2, 0x08, 0x95, 0x23, 0x66, 0xd3, 0xe3, 0x80, 0x5a, 0xe8, 0x00, 0x0c,
+	0xe2, 0xfb, 0x4c, 0x28, 0x6e, 0x68, 0x16, 0x9a, 0x85, 0x5d, 0x63, 0x6f, 0xa7, 0xfd, 0xe6, 0x9a,
+	0xdb, 0xdd, 0x25, 0xac, 0x57, 0x7c, 0x75, 0xbe, 0xb3, 0x86, 0xb3, 0x4c, 0xf4, 0x33, 0xa8, 0xd9,
+	0x34, 0x74, 0x39, 0xb5, 0x47, 0x9c, 0x79, 0xd4, 0x5c, 0x6f, 0x16, 0x76, 0xaf, 0xed, 0x7d, 0x37,
+	0xcf, 0x93, 0x9c, 0x1c, 0x33, 0x8f, 0x62, 0x43, 0x33, 0x64, 0x07, 0x1d, 0x00, 0x4c, 0xe9, 0x74,
+	0x4c, 0x79, 0x38, 0x71, 0x03, 0x73, 0x43, 0xd1, 0xbf, 0x77, 0x11, 0x5d, 0xae, 0xbd, 0xfd, 0x24,
+	0x85, 0xe3, 0x0c, 0x15, 0x3d, 0x81, 0x1a, 0x99, 0x11, 0xd7, 0x23, 0x63, 0xd7, 0x73, 0xc5, 0xdc,
+	0x2c, 0x2a, 0x57, 0x1f, 0x5f, 0xea, 0xaa, 0x9b, 0x21, 0xe0, 0x15, 0x7a, 0xcb, 0x06, 0x58, 0x4e,
+	0x84, 0xee, 0x43, 0x79, 0x38, 0x38, 0xea, 0x1f, 0x1e, 0x1d, 0xd4, 0xd7, 0x1a, 0xb7, 0x5f, 0xbc,
+	0x6c, 0xbe, 0x2f, 0x7d, 0x2c, 0x01, 0x43, 0xea, 0xdb, 0xae, 0xef, 0xa0, 0x5d, 0xa8, 0x74, 0xf7,
+	0xf7, 0x07, 0xc3, 0x93, 0x41, 0xbf, 0x5e, 0x68, 0x34, 0x5e, 0xbc, 0x6c, 0xde, 0x5a, 0x05, 0x76,
+	0x2d, 0x8b, 0x06, 0x82, 0xda, 0x8d, 0xe2, 0x37, 0x7f, 0xde, 0x5e, 0x6b, 0x7d, 0x53, 0x80, 0x5a,
+	0x76, 0x11, 0xe8, 0x3e, 0x94, 0xba, 0xfb, 0x27, 0x87, 0xcf, 0x06, 0xf5, 0xb5, 0x25, 0x3d, 0x8b,
+	0xe8, 0x5a, 0xc2, 0x9d, 0x51, 0x74, 0x0f, 0x36, 0x87, 0xdd, 0xaf, 0x8e, 0x07, 0xf5, 0xc2, 0x72,
+	0x39, 0x59, 0xd8, 0x90, 0x44, 0xa1, 0x42, 0xf5, 0x71, 0xf7, 0xf0, 0xa8, 0xbe, 0x9e, 0x8f, 0xea,
+	0x73, 0xe2, 0xfa, 0x7a, 0x29, 0x7f, 0x2a, 0x82, 0x71, 0x4c, 0xf9, 0xcc, 0xb5, 0xde, 0xb1, 0x44,
+	0x3e, 0x83, 0xa2, 0x20, 0xe1, 0x99, 0x92, 0x86, 0x91, 0x2f, 0x8d, 0x13, 0x12, 0x9e, 0xc9, 0x49,
+	0x35, 0x5d, 0xe1, 0xa5, 0x32, 0x38, 0x0d, 0x3c, 0xd7, 0x22, 0x82, 0xda, 0x4a, 0x19, 0xc6, 0xde,
+	0x47, 0x79, 0x6c, 0x9c, 0xa2, 0xf4, 0xfa, 0x1f, 0xad, 0xe1, 0x0c, 0x15, 0x3d, 0x84, 0x92, 0xe3,
+	0xb1, 0x31, 0xf1, 0x94, 0x26, 0x8c, 0xbd, 0xbb, 0x79, 0x4e, 0x0e, 0x14, 0x62, 0xe9, 0x40, 0x53,
+	0xd0, 0x03, 0x28, 0x45, 0x81, 0x4d, 0x04, 0x35, 0x4b, 0x8a, 0xdc, 0xcc, 0x23, 0x7f, 0xa5, 0x10,
+	0xfb, 0xcc, 0x3f, 0x75, 0x1d, 0xac, 0xf1, 0xe8, 0x31, 0x54, 0x7c, 0x2a, 0xbe, 0x66, 0xfc, 0x2c,
+	0x34, 0xcb, 0xcd, 0x8d, 0x5d, 0x63, 0xef, 0xd3, 0x5c, 0x31, 0xc6, 0x98, 0xae, 0x10, 0xc4, 0x9a,
+	0x4c, 0xa9, 0x2f, 0x62, 0x37, 0xbd, 0x75, 0xb3, 0x80, 0x53, 0x07, 0xe8, 0x27, 0x50, 0xa1, 0xbe,
+	0x1d, 0x30, 0xd7, 0x17, 0x66, 0xe5, 0xe2, 0x85, 0x0c, 0x34, 0x46, 0x06, 0x13, 0xa7, 0x0c, 0xc9,
+	0xe6, 0xcc, 0xf3, 0xc6, 0xc4, 0x3a, 0x33, 0xab, 0x6f, 0xb9, 0x8d, 0x94, 0xd1, 0x2b, 0x41, 0x71,
+	0xca, 0x6c, 0xda, 0xea, 0xc0, 0x8d, 0x37, 0x42, 0x8d, 0x1a, 0x50, 0xd1, 0xa1, 0x8e, 0x35, 0x52,
+	0xc4, 0x69, 0xbf, 0x75, 0x1d, 0xb6, 0x56, 0xc2, 0xda, 0xfa, 0xeb, 0x26, 0x54, 0x92, 0xb3, 0x46,
+	0x5d, 0xa8, 0x5a, 0xcc, 0x17, 0xc4, 0xf5, 0x29, 0xd7, 0xf2, 0xca, 0x3d, 0x99, 0xfd, 0x04, 0x24,
+	0x59, 0x8f, 0xd6, 0xf0, 0x92, 0x85, 0x7e, 0x01, 0x55, 0x4e, 0x43, 0x16, 0x71, 0x8b, 0x86, 0x5a,
+	0x5f, 0xbb, 0xf9, 0x0a, 0x89, 0x41, 0x98, 0xfe, 0x2e, 0x72, 0x39, 0x95, 0x51, 0x0e, 0xf1, 0x92,
+	0x8a, 0x1e, 0x42, 0x99, 0xd3, 0x50, 0x10, 0x2e, 0x2e, 0x93, 0x08, 0x8e, 0x21, 0x43, 0xe6, 0xb9,
+	0xd6, 0x1c, 0x27, 0x0c, 0xf4, 0x10, 0xaa, 0x81, 0x47, 0x2c, 0xe5, 0xd5, 0xdc, 0x54, 0xf4, 0x0f,
+	0xf2, 0xe8, 0xc3, 0x04, 0x84, 0x97, 0x78, 0xf4, 0x39, 0x80, 0xc7, 0x9c, 0x91, 0xcd, 0xdd, 0x19,
+	0xe5, 0x5a, 0x62, 0x8d, 0x3c, 0x76, 0x5f, 0x21, 0x70, 0xd5, 0x63, 0x4e, 0xdc, 0x44, 0x07, 0xff,
+	0x93, 0xbe, 0x32, 0xda, 0x7a, 0x0c, 0x40, 0xd2, 0x51, 0xad, 0xae, 0x8f, 0xdf, 0xca, 0x95, 0x3e,
+	0x91, 0x0c, 0x1d, 0xdd, 0x85, 0xda, 0x29, 0xe3, 0x16, 0x1d, 0xe9, 0xac, 0xa9, 0x2a, 0x4d, 0x18,
+	0xca, 0x16, 0xeb, 0x0b, 0xf5, 0xa0, 0xec, 0x50, 0x9f, 0x72, 0xd7, 0x32, 0x41, 0x4d, 0x76, 0x3f,
+	0x37, 0x21, 0x63, 0x08, 0x8e, 0x7c, 0xe1, 0x4e, 0xa9, 0x9e, 0x29, 0x21, 0xa2, 0xdf, 0xc2, 0x7b,
+	0xc9, 0xf1, 0x8d, 0x38, 0x3d, 0xa5, 0x9c, 0xfa, 0x52, 0x03, 0x86, 0x8a, 0xc3, 0x47, 0x97, 0x6b,
+	0x40, 0xa3, 0xf5, 0x65, 0x83, 0xf8, 0xeb, 0x03, 0x61, 0xaf, 0x0a, 0x65, 0x1e, 0xcf, 0xdb, 0xfa,
+	0x43, 0x41, 0xaa, 0xfe, 0x35, 0x04, 0xea, 0x80, 0x91, 0x4e, 0xef, 0xda, 0x4a, 0xbd, 0xd5, 0xde,
+	0xb5, 0xc5, 0xf9, 0x0e, 0x24, 0xd8, 0xc3, 0xbe, 0xbc, 0x83, 0x74, 0xdb, 0x46, 0x03, 0xd8, 0x4a,
+	0x09, 0xf2, 0x99, 0xd7, 0x0f, 0x65, 0xf3, 0xb2, 0x95, 0x9e, 0xcc, 0x03, 0x8a, 0x6b, 0x3c, 0xd3,
+	0x6b, 0xfd, 0x06, 0xd0, 0x9b, 0x71, 0x41, 0x08, 0x8a, 0x67, 0xae, 0xaf, 0x97, 0x81, 0x55, 0x1b,
+	0xb5, 0xa1, 0x1c, 0x90, 0xb9, 0xc7, 0x88, 0xad, 0x13, 0xe3, 0x66, 0x3b, 0xae, 0x0d, 0xda, 0x49,
+	0x6d, 0xd0, 0xee, 0xfa, 0x73, 0x9c, 0x80, 0x5a, 0x8f, 0xe1, 0xfd, 0xdc, 0xe3, 0x45, 0x7b, 0x50,
+	0x4b, 0x13, 0x6e, 0xb9, 0xd7, 0xeb, 0x8b, 0xf3, 0x1d, 0x23, 0xcd, 0xcc, 0xc3, 0x3e, 0x36, 0x52,
+	0xd0, 0xa1, 0xdd, 0xfa, 0x63, 0x15, 0xb6, 0x56, 0xd2, 0x16, 0xdd, 0x84, 0x4d, 0x77, 0x4a, 0x1c,
+	0xaa, 0xd7, 0x18, 0x77, 0xd0, 0x00, 0x4a, 0x1e, 0x19, 0x53, 0x4f, 0x26, 0xaf, 0x3c, 0xb8, 0xef,
+	0x5f, 0x99, 0xff, 0xed, 0x5f, 0x29, 0xfc, 0xc0, 0x17, 0x7c, 0x8e, 0x35, 0x19, 0x99, 0x50, 0xb6,
+	0xd8, 0x74, 0x4a, 0x7c, 0xf9, 0x4c, 0x6c, 0xec, 0x56, 0x71, 0xd2, 0x95, 0x91, 0x21, 0xdc, 0x09,
+	0xcd, 0xa2, 0x32, 0xab, 0x36, 0xaa, 0xc3, 0x06, 0xf5, 0x67, 0xe6, 0xa6, 0x32, 0xc9, 0xa6, 0xb4,
+	0xd8, 0x6e, 0x9c, 0x7d, 0x55, 0x2c, 0x9b, 0x92, 0x17, 0x85, 0x94, 0x9b, 0xe5, 0x38, 0xa2, 0xb2,
+	0x8d, 0x7e, 0x0c, 0xa5, 0x29, 0x8b, 0x7c, 0x11, 0x9a, 0x15, 0xb5, 0xd8, 0xdb, 0x79, 0x8b, 0x7d,
+	0x22, 0x11, 0x5a, 0x59, 0x1a, 0x8e, 0x06, 0x70, 0x23, 0x14, 0x2c, 0x18, 0x39, 0x9c, 0x58, 0x74,
+	0x14, 0x50, 0xee, 0x32, 0x5b, 0x5f, 0xc3, 0xb7, 0xdf, 0x38, 0x94, 0xbe, 0x2e, 0xe8, 0xf0, 0x75,
+	0xc9, 0x39, 0x90, 0x94, 0xa1, 0x62, 0xa0, 0x21, 0xd4, 0x82, 0xc8, 0xf3, 0x46, 0x2c, 0x88, 0x5f,
+	0xe4, 0x38, 0x77, 0xde, 0x22, 0x64, 0xc3, 0xc8, 0xf3, 0x9e, 0xc6, 0x24, 0x6c, 0x04, 0xcb, 0x0e,
+	0xba, 0x05, 0x25, 0x87, 0xb3, 0x28, 0x88, 0xf3, 0xa6, 0x8a, 0x75, 0x0f, 0x7d, 0x09, 0xe5, 0x90,
+	0x5a, 0x9c, 0x8a, 0xd0, 0xac, 0xa9, 0xad, 0x7e, 0x98, 0x37, 0xc9, 0xb1, 0x82, 0xa4, 0x39, 0x81,
+	0x13, 0x0e, 0xba, 0x0d, 0x1b, 0x42, 0xcc, 0xcd, 0xad, 0x66, 0x61, 0xb7, 0xd2, 0x2b, 0x2f, 0xce,
+	0x77, 0x36, 0x4e, 0x4e, 0x9e, 0x63, 0x69, 0x93, 0xaf, 0xc5, 0x84, 0x85, 0xc2, 0x27, 0x53, 0x6a,
+	0x5e, 0x53, 0xb1, 0x4d, 0xfb, 0xe8, 0x39, 0x80, 0xed, 0x87, 0x23, 0x4b, 0x5d, 0x4f, 0xe6, 0x75,
+	0xb5, 0xbb, 0x4f, 0xaf, 0xde, 0x5d, 0xff, 0xe8, 0x58, 0xbf, 0x98, 0x5b, 0x8b, 0xf3, 0x9d, 0x6a,
+	0xda, 0xc5, 0x55, 0xdb, 0x0f, 0xe3, 0x26, 0xea, 0x81, 0x31, 0xa1, 0xc4, 0x13, 0x13, 0x6b, 0x42,
+	0xad, 0x33, 0xb3, 0x7e, 0xf1, 0x13, 0xf8, 0x48, 0xc1, 0xb4, 0x87, 0x2c, 0x49, 0x2a, 0x58, 0x2e,
+	0x35, 0x34, 0x6f, 0xa8, 0x58, 0xc5, 0x1d, 0xf4, 0x01, 0x00, 0x0b, 0xa8, 0x3f, 0x0a, 0x85, 0xed,
+	0xfa, 0x26, 0x92, 0x5b, 0xc6, 0x55, 0x69, 0x39, 0x96, 0x06, 0x74, 0x47, 0x3e, 0x50, 0xc4, 0x1e,
+	0x31, 0xdf, 0x9b, 0x9b, 0xef, 0xa9, 0xd1, 0x8a, 0x34, 0x3c, 0xf5, 0xbd, 0x39, 0xda, 0x01, 0x43,
+	0xe9, 0x22, 0x74, 0x1d, 0x9f, 0x78, 0xe6, 0x4d, 0x15, 0x0f, 0x90, 0xa6, 0x63, 0x65, 0x91, 0xe7,
+	0x10, 0x47, 0x23, 0x34, 0xdf, 0xbf, 0xf8, 0x1c, 0xf4, 0x62, 0x97, 0xe7, 0xa0, 0x39, 0xe8, 0xa7,
+	0x00, 0x01, 0x77, 0x67, 0xae, 0x47, 0x1d, 0x1a, 0x9a, 0xb7, 0xd4, 0xa6, 0xb7, 0x73, 0x5f, 0xa6,
+	0x14, 0x85, 0x33, 0x8c, 0xc6, 0xe7, 0x60, 0x64, 0xb2, 0x4d, 0x66, 0xc9, 0x19, 0x9d, 0xeb, 0x04,
+	0x96, 0x4d, 0x19, 0x92, 0x19, 0xf1, 0xa2, 0xf8, 0x32, 0xab, 0xe2, 0xb8, 0xf3, 0xc5, 0xfa, 0x83,
+	0x42, 0x63, 0x0f, 0x8c, 0x8c, 0xea, 0xd0, 0x87, 0xf2, 0xf6, 0x73, 0xdc, 0x50, 0xf0, 0xf9, 0x88,
+	0x44, 0x62, 0x62, 0xfe, 0x5c, 0x11, 0x6a, 0x89, 0xb1, 0x1b, 0x89, 0x49, 0x63, 0x04, 0xcb, 0xc3,
+	0x43, 0x4d, 0x30, 0xa4, 0x28, 0x42, 0xca, 0x67, 0x94, 0xcb, 0xca, 0x42, 0xc6, 0x3c, 0x6b, 0x92,
+	0xe2, 0x0d, 0x29, 0xe1, 0xd6, 0x44, 0xdd, 0x1d, 0x55, 0xac, 0x7b, 0xf2, 0x32, 0x48, 0x32, 0x44,
+	0x5f, 0x06, 0xba, 0xdb, 0xfa, 0x57, 0x01, 0x6a, 0xd9, 0x02, 0x09, 0xed, 0xc7, 0x85, 0x8d, 0xda,
+	0xd2, 0xb5, 0xbd, 0xce, 0x55, 0x05, 0x95, 0xba, 0x98, 0xbd, 0x48, 0x3a, 0x7b, 0x22, 0xff, 0x32,
+	0x8a, 0x8c, 0x7e, 0x04, 0x9b, 0x01, 0xe3, 0x22, 0xb9, 0xc2, 0xf2, 0x03, 0xcc, 0x78, 0xf2, 0xec,
+	0xc6, 0xe0, 0xd6, 0x04, 0xae, 0xad, 0x7a, 0x43, 0xf7, 0x60, 0xe3, 0xd9, 0xe1, 0xb0, 0xbe, 0xd6,
+	0xb8, 0xf3, 0xe2, 0x65, 0xf3, 0x3b, 0xab, 0x83, 0xcf, 0x5c, 0x2e, 0x22, 0xe2, 0x1d, 0x0e, 0xd1,
+	0x27, 0xb0, 0xd9, 0x3f, 0x3a, 0xc6, 0xb8, 0x5e, 0x68, 0xec, 0xbc, 0x78, 0xd9, 0xbc, 0xb3, 0x8a,
+	0x93, 0x43, 0x2c, 0xf2, 0x6d, 0xcc, 0xc6, 0x69, 0x5d, 0xff, 0xef, 0x75, 0x30, 0xf4, 0xcd, 0xfe,
+	0xae, 0xbf, 0x7e, 0x5b, 0x71, 0xd9, 0x92, 0xa4, 0xec, 0xfa, 0x95, 0xd5, 0x4b, 0x2d, 0x26, 0xe8,
+	0x33, 0xbe, 0x0b, 0x35, 0x37, 0x98, 0x7d, 0x36, 0xa2, 0x3e, 0x19, 0x7b, 0xba, 0xc4, 0xaf, 0x60,
+	0x43, 0xda, 0x06, 0xb1, 0x49, 0xde, 0x17, 0xae, 0x2f, 0x28, 0xf7, 0x75, 0xf1, 0x5e, 0xc1, 0x69,
+	0x1f, 0x7d, 0x09, 0x45, 0x37, 0x20, 0x53, 0x5d, 0x72, 0xe5, 0xee, 0xe0, 0x70, 0xd8, 0x7d, 0xa2,
+	0x35, 0xd8, 0xab, 0x2c, 0xce, 0x77, 0x8a, 0xd2, 0x80, 0x15, 0x0d, 0x6d, 0x27, 0x55, 0x8f, 0x9c,
+	0x49, 0xdd, 0xfd, 0x15, 0x9c, 0xb1, 0x48, 0x1d, 0xb9, 0xbe, 0xc3, 0x69, 0x18, 0xaa, 0x57, 0xa0,
+	0x82, 0x93, 0x2e, 0x6a, 0x40, 0x59, 0xd7, 0x4e, 0xaa, 0x58, 0xaa, 0xca, 0xba, 0x44, 0x1b, 0x7a,
+	0x5b, 0x60, 0xc4, 0xd1, 0x18, 0x9d, 0x72, 0x36, 0x6d, 0xfd, 0xa7, 0x08, 0xc6, 0xbe, 0x17, 0x85,
+	0x42, 0x3f, 0x83, 0xef, 0x2c, 0xf8, 0xcf, 0xe1, 0x06, 0x51, 0x5f, 0x49, 0xe2, 0xcb, 0x37, 0x45,
+	0x95, 0xa4, 0xfa, 0x00, 0xee, 0xe5, 0xba, 0x4b, 0xc1, 0x71, 0xf9, 0xda, 0x2b, 0x49, 0x9f, 0x66,
+	0x01, 0xd7, 0xc9, 0x6b, 0x23, 0xe8, 0x18, 0xb6, 0x18, 0xb7, 0x26, 0x34, 0x14, 0xf1, 0x4b, 0xa4,
+	0xbf, 0x5e, 0xb9, 0x9f, 0xf2, 0xa7, 0x59, 0xa0, 0xbe, 0x86, 0xe3, 0xd5, 0xae, 0xfa, 0x40, 0x0f,
+	0xa0, 0xc8, 0xc9, 0x69, 0x52, 0x5e, 0xe7, 0x26, 0x09, 0x26, 0xa7, 0x62, 0xc5, 0x85, 0x62, 0xa0,
+	0x5f, 0x02, 0xd8, 0x6e, 0x18, 0x10, 0x61, 0x4d, 0x28, 0xd7, 0x87, 0x9d, 0xbb, 0xc5, 0x7e, 0x8a,
+	0x5a, 0xf1, 0x92, 0x61, 0xa3, 0xc7, 0x50, 0xb5, 0x48, 0x22, 0xd7, 0xd2, 0xc5, 0xff, 0xd1, 0xfd,
+	0xae, 0x76, 0x51, 0x97, 0x2e, 0x16, 0xe7, 0x3b, 0x95, 0xc4, 0x82, 0x2b, 0x16, 0xd1, 0xf2, 0x7d,
+	0x0c, 0x5b, 0xf2, 0x9f, 0x3a, 0xb2, 0xe9, 0x29, 0x89, 0x3c, 0x11, 0xcb, 0xe4, 0x82, 0x67, 0x45,
+	0x7e, 0x7a, 0xfa, 0x1a, 0xa7, 0xd7, 0x55, 0x13, 0x19, 0x1b, 0xfa, 0x35, 0xdc, 0xa0, 0xbe, 0xc5,
+	0xe7, 0x4a, 0xac, 0xc9, 0x0a, 0x2b, 0x17, 0x6f, 0x76, 0x90, 0x82, 0x57, 0x36, 0x5b, 0xa7, 0xaf,
+	0xd9, 0x5b, 0xff, 0x28, 0x00, 0xc4, 0x2f, 0xf5, 0xbb, 0x15, 0x20, 0x82, 0xa2, 0x4d, 0x04, 0x51,
+	0x9a, 0xab, 0x61, 0xd5, 0x46, 0x5f, 0x00, 0x08, 0x3a, 0x0d, 0x3c, 0x22, 0x5c, 0xdf, 0xd1, 0xb2,
+	0xb9, 0xec, 0x3a, 0xc8, 0xa0, 0xd1, 0x1e, 0x94, 0xf4, 0x27, 0xa8, 0x78, 0x25, 0x4f, 0x23, 0x5b,
+	0x7f, 0x29, 0x00, 0xc4, 0xdb, 0xfc, 0xbf, 0xde, 0x5b, 0xcf, 0x7c, 0xf5, 0xed, 0xf6, 0xda, 0xdf,
+	0xbf, 0xdd, 0x5e, 0xfb, 0xfd, 0x62, 0xbb, 0xf0, 0x6a, 0xb1, 0x5d, 0xf8, 0xdb, 0x62, 0xbb, 0xf0,
+	0xcf, 0xc5, 0x76, 0x61, 0x5c, 0x52, 0x75, 0xdf, 0x0f, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xae,
+	0x88, 0xf9, 0x3c, 0x5a, 0x14, 0x00, 0x00,
 }
diff --git a/vendor/github.com/docker/swarmkit/api/specs.proto b/vendor/github.com/docker/swarmkit/api/specs.proto
index c7c365b85f..8955027b55 100644
--- a/vendor/github.com/docker/swarmkit/api/specs.proto
+++ b/vendor/github.com/docker/swarmkit/api/specs.proto
@@ -293,11 +293,6 @@ message ContainerSpec {
 	// task will exit and a new task will be rescheduled elsewhere. A container
 	// is considered unhealthy after `Retries` number of consecutive failures.
 	HealthConfig healthcheck = 16;
-	
-	// Run a custom init inside the container, if null, use the daemon's configured settings
-	oneof init {
-		bool init_value = 23;
-	}
 }
 
 // EndpointSpec defines the properties that can be configured to
diff --git a/vendor/github.com/docker/swarmkit/ca/keyreadwriter.go b/vendor/github.com/docker/swarmkit/ca/keyreadwriter.go
index 964cb3ee84..4a7c0a0eee 100644
--- a/vendor/github.com/docker/swarmkit/ca/keyreadwriter.go
+++ b/vendor/github.com/docker/swarmkit/ca/keyreadwriter.go
@@ -187,10 +187,7 @@ func (k *KeyReadWriter) ViewAndRotateKEK(cb func(KEKData, PEMKeyHeaders) (KEKDat
 		return err
 	}
 
-	if err := k.writeKey(keyBlock, updatedKEK, updatedHeaderObj); err != nil {
-		return err
-	}
-	return nil
+	return k.writeKey(keyBlock, updatedKEK, updatedHeaderObj)
 }
 
 // ViewAndUpdateHeaders updates the header manager, and updates any headers on the existing key
diff --git a/vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/networkallocator.go b/vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/networkallocator.go
index 3b31d07817..ab1b6d6a47 100644
--- a/vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/networkallocator.go
+++ b/vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/networkallocator.go
@@ -459,8 +459,8 @@ func (na *cnmNetworkAllocator) DeallocateTask(t *api.Task) error {
 	return na.releaseEndpoints(t.Networks)
 }
 
-// IsLBAttachmentAllocated returns if the passed node and network has resources allocated or not.
-func (na *cnmNetworkAllocator) IsLBAttachmentAllocated(node *api.Node, networkAttachment *api.NetworkAttachment) bool {
+// IsAttachmentAllocated returns if the passed node and network has resources allocated or not.
+func (na *cnmNetworkAllocator) IsAttachmentAllocated(node *api.Node, networkAttachment *api.NetworkAttachment) bool {
 	if node == nil {
 		return false
 	}
@@ -500,9 +500,9 @@ func (na *cnmNetworkAllocator) IsLBAttachmentAllocated(node *api.Node, networkAt
 	return true
 }
 
-// AllocateLBAttachment allocates the IP addresses for a LB in a network
+// AllocateAttachment allocates the IP addresses for a LB in a network
 // on a given node
-func (na *cnmNetworkAllocator) AllocateLBAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error {
+func (na *cnmNetworkAllocator) AllocateAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error {
 
 	if err := na.allocateNetworkIPs(networkAttachment); err != nil {
 		return err
@@ -516,9 +516,9 @@ func (na *cnmNetworkAllocator) AllocateLBAttachment(node *api.Node, networkAttac
 	return nil
 }
 
-// DeallocateLBAttachment deallocates the IP addresses for a LB in a network to
+// DeallocateAttachment deallocates the IP addresses for a LB in a network to
 // which the node is attached.
-func (na *cnmNetworkAllocator) DeallocateLBAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error {
+func (na *cnmNetworkAllocator) DeallocateAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error {
 
 	delete(na.nodes[node.ID], networkAttachment.Network.ID)
 	if len(na.nodes[node.ID]) == 0 {
diff --git a/vendor/github.com/docker/swarmkit/manager/allocator/network.go b/vendor/github.com/docker/swarmkit/manager/allocator/network.go
index 794e616c10..c7715128a1 100644
--- a/vendor/github.com/docker/swarmkit/manager/allocator/network.go
+++ b/vendor/github.com/docker/swarmkit/manager/allocator/network.go
@@ -172,11 +172,7 @@ func (a *Allocator) doNetworkInit(ctx context.Context) (err error) {
 	if err := a.allocateServices(ctx, false); err != nil {
 		return err
 	}
-	if err := a.allocateTasks(ctx, false); err != nil {
-		return err
-	}
-
-	return nil
+	return a.allocateTasks(ctx, false)
 }
 
 func (a *Allocator) doNetworkAlloc(ctx context.Context, ev events.Event) {
@@ -510,7 +506,7 @@ func (a *Allocator) deallocateNodeAttachments(ctx context.Context, nid string) e
 
 		var networkAttachment *api.NetworkAttachment
 		var naIndex int
-		for index, na := range node.LbAttachments {
+		for index, na := range node.Attachments {
 			if na.Network.ID == nid {
 				networkAttachment = na
 				naIndex = index
@@ -523,15 +519,15 @@ func (a *Allocator) deallocateNodeAttachments(ctx context.Context, nid string) e
 			continue
 		}
 
-		if nc.nwkAllocator.IsLBAttachmentAllocated(node, networkAttachment) {
-			if err := nc.nwkAllocator.DeallocateLBAttachment(node, networkAttachment); err != nil {
+		if nc.nwkAllocator.IsAttachmentAllocated(node, networkAttachment) {
+			if err := nc.nwkAllocator.DeallocateAttachment(node, networkAttachment); err != nil {
 				log.G(ctx).WithError(err).Errorf("Failed to commit deallocation of network resources for node %s", node.ID)
 			} else {
 
 				// Delete the lbattachment
-				node.LbAttachments[naIndex] = node.LbAttachments[len(node.LbAttachments)-1]
-				node.LbAttachments[len(node.LbAttachments)-1] = nil
-				node.LbAttachments = node.LbAttachments[:len(node.LbAttachments)-1]
+				node.Attachments[naIndex] = node.Attachments[len(node.Attachments)-1]
+				node.Attachments[len(node.Attachments)-1] = nil
+				node.Attachments = node.Attachments[:len(node.Attachments)-1]
 
 				if err := a.store.Batch(func(batch *store.Batch) error {
 					return a.commitAllocatedNode(ctx, batch, node)
@@ -551,15 +547,15 @@ func (a *Allocator) deallocateNode(node *api.Node) error {
 		nc = a.netCtx
 	)
 
-	for _, na := range node.LbAttachments {
-		if nc.nwkAllocator.IsLBAttachmentAllocated(node, na) {
-			if err := nc.nwkAllocator.DeallocateLBAttachment(node, na); err != nil {
+	for _, na := range node.Attachments {
+		if nc.nwkAllocator.IsAttachmentAllocated(node, na) {
+			if err := nc.nwkAllocator.DeallocateAttachment(node, na); err != nil {
 				return err
 			}
 		}
 	}
 
-	node.LbAttachments = nil
+	node.Attachments = nil
 
 	return nil
 }
@@ -855,7 +851,7 @@ func (a *Allocator) allocateNode(ctx context.Context, node *api.Node, existingAd
 	for _, network := range networks {
 
 		var lbAttachment *api.NetworkAttachment
-		for _, na := range node.LbAttachments {
+		for _, na := range node.Attachments {
 			if na.Network != nil && na.Network.ID == network.ID {
 				lbAttachment = na
 				break
@@ -863,14 +859,14 @@ func (a *Allocator) allocateNode(ctx context.Context, node *api.Node, existingAd
 		}
 
 		if lbAttachment != nil {
-			if nc.nwkAllocator.IsLBAttachmentAllocated(node, lbAttachment) {
+			if nc.nwkAllocator.IsAttachmentAllocated(node, lbAttachment) {
 				continue
 			}
 		}
 
 		if lbAttachment == nil {
 			lbAttachment = &api.NetworkAttachment{}
-			node.LbAttachments = append(node.LbAttachments, lbAttachment)
+			node.Attachments = append(node.Attachments, lbAttachment)
 		}
 
 		if existingAddressesOnly && len(lbAttachment.Addresses) == 0 {
@@ -878,7 +874,7 @@ func (a *Allocator) allocateNode(ctx context.Context, node *api.Node, existingAd
 		}
 
 		lbAttachment.Network = network.Copy()
-		if err := a.netCtx.nwkAllocator.AllocateLBAttachment(node, lbAttachment); err != nil {
+		if err := a.netCtx.nwkAllocator.AllocateAttachment(node, lbAttachment); err != nil {
 			log.G(ctx).WithError(err).Errorf("Failed to allocate network resources for node %s", node.ID)
 			// TODO: Should we add a unallocatedNode and retry allocating resources like we do for network, tasks, services?
 			// right now, we will only retry allocating network resources for the node when the node is updated.
@@ -897,7 +893,7 @@ func (a *Allocator) commitAllocatedNode(ctx context.Context, batch *store.Batch,
 
 		if err == store.ErrSequenceConflict {
 			storeNode := store.GetNode(tx, node.ID)
-			storeNode.LbAttachments = node.LbAttachments
+			storeNode.Attachments = node.Attachments
 			err = store.UpdateNode(tx, storeNode)
 		}
 
diff --git a/vendor/github.com/docker/swarmkit/manager/allocator/networkallocator/networkallocator.go b/vendor/github.com/docker/swarmkit/manager/allocator/networkallocator/networkallocator.go
index 5fc5801d49..f6b69b4d81 100644
--- a/vendor/github.com/docker/swarmkit/manager/allocator/networkallocator/networkallocator.go
+++ b/vendor/github.com/docker/swarmkit/manager/allocator/networkallocator/networkallocator.go
@@ -81,14 +81,14 @@ type NetworkAllocator interface {
 	// networks that a task is attached to.
 	DeallocateTask(t *api.Task) error
 
-	// AllocateLBAttachment Allocates a load balancer endpoint for the node
-	AllocateLBAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error
+	// AllocateAttachment Allocates a load balancer endpoint for the node
+	AllocateAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error
 
-	// DeallocateLBAttachment Deallocates a load balancer endpoint for the node
-	DeallocateLBAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error
+	// DeallocateAttachment Deallocates a load balancer endpoint for the node
+	DeallocateAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error
 
-	//IsLBAttachmentAllocated If lb endpoint is allocated on the node
-	IsLBAttachmentAllocated(node *api.Node, networkAttachment *api.NetworkAttachment) bool
+	// IsAttachmentAllocated If lb endpoint is allocated on the node
+	IsAttachmentAllocated(node *api.Node, networkAttachment *api.NetworkAttachment) bool
 }
 
 // IsIngressNetwork check if the network is an ingress network
diff --git a/vendor/github.com/docker/swarmkit/manager/controlapi/network.go b/vendor/github.com/docker/swarmkit/manager/controlapi/network.go
index 708f36b8f6..b150de0e78 100644
--- a/vendor/github.com/docker/swarmkit/manager/controlapi/network.go
+++ b/vendor/github.com/docker/swarmkit/manager/controlapi/network.go
@@ -96,11 +96,7 @@ func validateNetworkSpec(spec *api.NetworkSpec, pg plugingetter.PluginGetter) er
 		return err
 	}
 
-	if err := validateIPAM(spec.IPAM, pg); err != nil {
-		return err
-	}
-
-	return nil
+	return validateIPAM(spec.IPAM, pg)
 }
 
 // CreateNetwork creates and returns a Network based on the provided NetworkSpec.
diff --git a/vendor/github.com/docker/swarmkit/manager/controlapi/service.go b/vendor/github.com/docker/swarmkit/manager/controlapi/service.go
index 0a0a9ffa2a..951c27b01e 100644
--- a/vendor/github.com/docker/swarmkit/manager/controlapi/service.go
+++ b/vendor/github.com/docker/swarmkit/manager/controlapi/service.go
@@ -56,10 +56,7 @@ func validateResourceRequirements(r *api.ResourceRequirements) error {
 	if err := validateResources(r.Limits); err != nil {
 		return err
 	}
-	if err := validateResources(r.Reservations); err != nil {
-		return err
-	}
-	return nil
+	return validateResources(r.Reservations)
 }
 
 func validateRestartPolicy(rp *api.RestartPolicy) error {
@@ -161,11 +158,7 @@ func validateContainerSpec(taskSpec api.TaskSpec) error {
 		return err
 	}
 
-	if err := validateHealthCheck(container.Healthcheck); err != nil {
-		return err
-	}
-
-	return nil
+	return validateHealthCheck(container.Healthcheck)
 }
 
 // validateImage validates image name in containerSpec
@@ -481,11 +474,7 @@ func validateServiceSpec(spec *api.ServiceSpec) error {
 	if err := validateEndpointSpec(spec.Endpoint); err != nil {
 		return err
 	}
-	if err := validateMode(spec); err != nil {
-		return err
-	}
-
-	return nil
+	return validateMode(spec)
 }
 
 // checkPortConflicts does a best effort to find if the passed in spec has port
diff --git a/vendor/github.com/docker/swarmkit/manager/dispatcher/dispatcher.go b/vendor/github.com/docker/swarmkit/manager/dispatcher/dispatcher.go
index 8ad1df397f..4de6a30c4d 100644
--- a/vendor/github.com/docker/swarmkit/manager/dispatcher/dispatcher.go
+++ b/vendor/github.com/docker/swarmkit/manager/dispatcher/dispatcher.go
@@ -854,10 +854,7 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche
 		appliesTo = msg.ResultsIn
 		msg.Type = assignmentType
 
-		if err := stream.Send(&msg); err != nil {
-			return err
-		}
-		return nil
+		return stream.Send(&msg)
 	}
 
 	// TODO(aaronl): Also send node secrets that should be exposed to
diff --git a/vendor/github.com/docker/swarmkit/manager/manager.go b/vendor/github.com/docker/swarmkit/manager/manager.go
index d3e88fd648..39db22b09a 100644
--- a/vendor/github.com/docker/swarmkit/manager/manager.go
+++ b/vendor/github.com/docker/swarmkit/manager/manager.go
@@ -54,6 +54,9 @@ import (
 const (
 	// defaultTaskHistoryRetentionLimit is the number of tasks to keep.
 	defaultTaskHistoryRetentionLimit = 5
+
+	// Default value for grpc max message size.
+	grpcMaxMessageSize = 128 << 20
 )
 
 // RemoteAddrs provides a listening address and an optional advertise address
@@ -231,6 +234,7 @@ func New(config *Config) (*Manager, error) {
 		grpc.Creds(config.SecurityConfig.ServerTLSCreds),
 		grpc.StreamInterceptor(grpc_prometheus.StreamServerInterceptor),
 		grpc.UnaryInterceptor(grpc_prometheus.UnaryServerInterceptor),
+		grpc.MaxMsgSize(grpcMaxMessageSize),
 	}
 
 	m := &Manager{
diff --git a/vendor/github.com/docker/swarmkit/manager/orchestrator/update/updater.go b/vendor/github.com/docker/swarmkit/manager/orchestrator/update/updater.go
index 0bda96e9a6..f7e4ff52ad 100644
--- a/vendor/github.com/docker/swarmkit/manager/orchestrator/update/updater.go
+++ b/vendor/github.com/docker/swarmkit/manager/orchestrator/update/updater.go
@@ -384,10 +384,7 @@ func (u *Updater) updateTask(ctx context.Context, slot orchestrator.Slot, update
 				return errors.New("service was deleted")
 			}
 
-			if err := store.CreateTask(tx, updated); err != nil {
-				return err
-			}
-			return nil
+			return store.CreateTask(tx, updated)
 		})
 		if err != nil {
 			return err
diff --git a/vendor/github.com/docker/swarmkit/manager/scheduler/scheduler.go b/vendor/github.com/docker/swarmkit/manager/scheduler/scheduler.go
index 73349e391f..99685959bc 100644
--- a/vendor/github.com/docker/swarmkit/manager/scheduler/scheduler.go
+++ b/vendor/github.com/docker/swarmkit/manager/scheduler/scheduler.go
@@ -92,11 +92,7 @@ func (s *Scheduler) setupTasksList(tx store.ReadTx) error {
 		tasksByNode[t.NodeID][t.ID] = t
 	}
 
-	if err := s.buildNodeSet(tx, tasksByNode); err != nil {
-		return err
-	}
-
-	return nil
+	return s.buildNodeSet(tx, tasksByNode)
 }
 
 // Run is the scheduler event loop.
diff --git a/vendor/github.com/docker/swarmkit/manager/state/raft/raft.go b/vendor/github.com/docker/swarmkit/manager/state/raft/raft.go
index cfbec992f1..ec2c9c0f5e 100644
--- a/vendor/github.com/docker/swarmkit/manager/state/raft/raft.go
+++ b/vendor/github.com/docker/swarmkit/manager/state/raft/raft.go
@@ -1283,10 +1283,7 @@ func (n *Node) reportNewAddress(ctx context.Context, id uint64) error {
 		return err
 	}
 	newAddr := net.JoinHostPort(newHost, officialPort)
-	if err := n.transport.UpdatePeerAddr(id, newAddr); err != nil {
-		return err
-	}
-	return nil
+	return n.transport.UpdatePeerAddr(id, newAddr)
 }
 
 // ProcessRaftMessage calls 'Step' which advances the
@@ -1848,10 +1845,7 @@ func (n *Node) applyAddNode(cc raftpb.ConfChange) error {
 		return nil
 	}
 
-	if err = n.registerNode(member); err != nil {
-		return err
-	}
-	return nil
+	return n.registerNode(member)
 }
 
 // applyUpdateNode is called when we receive a ConfChange from a member in the
diff --git a/vendor/github.com/docker/swarmkit/manager/state/raft/storage/storage.go b/vendor/github.com/docker/swarmkit/manager/state/raft/storage/storage.go
index a737aabde3..539e05d5ce 100644
--- a/vendor/github.com/docker/swarmkit/manager/state/raft/storage/storage.go
+++ b/vendor/github.com/docker/swarmkit/manager/state/raft/storage/storage.go
@@ -226,10 +226,7 @@ func (e *EncryptedRaftLogger) SaveSnapshot(snapshot raftpb.Snapshot) error {
 	if err := snapshotter.SaveSnap(snapshot); err != nil {
 		return err
 	}
-	if err := e.wal.ReleaseLockTo(snapshot.Metadata.Index); err != nil {
-		return err
-	}
-	return nil
+	return e.wal.ReleaseLockTo(snapshot.Metadata.Index)
 }
 
 // GC garbage collects snapshots and wals older than the provided index and term
diff --git a/vendor/github.com/docker/swarmkit/manager/state/raft/transport/transport.go b/vendor/github.com/docker/swarmkit/manager/state/raft/transport/transport.go
index 69057f6246..b259013d8a 100644
--- a/vendor/github.com/docker/swarmkit/manager/state/raft/transport/transport.go
+++ b/vendor/github.com/docker/swarmkit/manager/state/raft/transport/transport.go
@@ -235,10 +235,7 @@ func (t *Transport) UpdatePeerAddr(id uint64, addr string) error {
 	if !ok {
 		return ErrIsNotFound
 	}
-	if err := p.updateAddr(addr); err != nil {
-		return err
-	}
-	return nil
+	return p.updateAddr(addr)
 }
 
 // PeerConn returns raw grpc connection to peer.