@@ -139,7 +139,7 @@ clone git github.com/docker/docker-credential-helpers v0.3.0

 clone git github.com/docker/containerd 1b3a81545ca79456086dc2aa424357be98b962ee

 # cluster

-clone git github.com/docker/swarmkit 16fa595d3b6fec012830179dc8e9b2d90335527d

+clone git github.com/docker/swarmkit 6478bc19cf4bc1d7ba2d6f04ccaacf099508f4a0

 clone git github.com/golang/mock bd3c8e81be01eef76d4b503f5e687d2d1354d2d9

 clone git github.com/gogo/protobuf 43a2e0b1c32252bfbbdf81f7faa7a88fb3fa4028

 clone git github.com/cloudflare/cfssl b895b0549c0ff676f92cf09ba971ae02bb41367b

@@ -197,6 +197,11 @@ func (a *Agent) run(ctx context.Context) {

 			sessionq = nil

 			// if we're here before <-registered, do nothing for that event

 			registered = nil

+

+			// Bounce the connection.

+			if a.config.Picker != nil {

+				a.config.Picker.Reset()

+			}

 		case <-session.closed:

 			log.G(ctx).Debugf("agent: rebuild session")

@@ -19,9 +19,15 @@ type Config struct {

 	// updated with managers weights as observed by the agent.

 	Managers picker.Remotes

-	// Conn specifies the client connection Agent will use

+	// Conn specifies the client connection Agent will use.

 	Conn *grpc.ClientConn

+	// Picker is the picker used by Conn.

+	// TODO(aaronl): This is only part of the config to allow resetting the

+	// GRPC connection. This should be refactored to address the coupling

+	// between Conn and Picker.

+	Picker *picker.Picker

+

 	// Executor specifies the executor to use for the agent.

 	Executor exec.Executor

@@ -375,8 +375,9 @@ func (n *Node) runAgent(ctx context.Context, db *bolt.DB, creds credentials.Tran

 	if ctx.Err() != nil {

 		return ctx.Err()

 	}

+	picker := picker.NewPicker(n.remotes, manager.Addr)

 	conn, err := grpc.Dial(manager.Addr,

-		grpc.WithPicker(picker.NewPicker(n.remotes, manager.Addr)),

+		grpc.WithPicker(picker),

 		grpc.WithTransportCredentials(creds),

 		grpc.WithBackoffMaxDelay(maxSessionFailureBackoff))

 	if err != nil {

@@ -389,6 +390,7 @@ func (n *Node) runAgent(ctx context.Context, db *bolt.DB, creds credentials.Tran

 		Executor:         n.config.Executor,

 		DB:               db,

 		Conn:             conn,

+		Picker:           picker,

 		NotifyRoleChange: n.roleChangeReq,

 	})

 	if err != nil {

@@ -12,6 +12,8 @@ import (

 	"google.golang.org/grpc/codes"

 )

+const dispatcherRPCTimeout = 5 * time.Second

+

 var (

 	errSessionDisconnect = errors.New("agent: session disconnect") // instructed to disconnect

 	errSessionClosed     = errors.New("agent: session closed")

@@ -88,16 +90,39 @@ func (s *session) start(ctx context.Context) error {

 		description.Hostname = s.agent.config.Hostname

 	}

-	stream, err := client.Session(ctx, &api.SessionRequest{

-		Description: description,

-	})

-	if err != nil {

-		return err

-	}

+	errChan := make(chan error, 1)

+	var (

+		msg    *api.SessionMessage

+		stream api.Dispatcher_SessionClient

+	)

+	// Note: we don't defer cancellation of this context, because the

+	// streaming RPC is used after this function returned. We only cancel

+	// it in the timeout case to make sure the goroutine completes.

+	sessionCtx, cancelSession := context.WithCancel(ctx)

+

+	// Need to run Session in a goroutine since there's no way to set a

+	// timeout for an individual Recv call in a stream.

+	go func() {

+		stream, err = client.Session(sessionCtx, &api.SessionRequest{

+			Description: description,

+		})

+		if err != nil {

+			errChan <- err

+			return

+		}

-	msg, err := stream.Recv()

-	if err != nil {

-		return err

+		msg, err = stream.Recv()

+		errChan <- err

+	}()

+

+	select {

+	case err := <-errChan:

+		if err != nil {

+			return err

+		}

+	case <-time.After(dispatcherRPCTimeout):

+		cancelSession()

+		return errors.New("session initiation timed out")

 	}

 	s.sessionID = msg.SessionID

@@ -115,9 +140,11 @@ func (s *session) heartbeat(ctx context.Context) error {

 	for {

 		select {

 		case <-heartbeat.C:

-			resp, err := client.Heartbeat(ctx, &api.HeartbeatRequest{

+			heartbeatCtx, cancel := context.WithTimeout(ctx, dispatcherRPCTimeout)

+			resp, err := client.Heartbeat(heartbeatCtx, &api.HeartbeatRequest{

 				SessionID: s.sessionID,

 			})

+			cancel()

 			if err != nil {

 				if grpc.Code(err) == codes.NotFound {

 					err = errNodeNotRegistered

@@ -159,6 +159,15 @@ type Task struct {

 	// A copy of runtime state of service endpoint from Service

 	// object to be distributed to agents as part of the task.

 	Endpoint *Endpoint `protobuf:"bytes,12,opt,name=endpoint" json:"endpoint,omitempty"`

+	// LogDriver specifies the selected log driver to use for the task. Agent

+	// processes should always favor the value in this field.

+	//

+	// If present in the TaskSpec, this will be a copy of that value. The

+	// orchestrator may choose to insert a value here, which should be honored,

+	// such a cluster default or policy-based value.

+	//

+	// If not present, the daemon's default will be used.

+	LogDriver *Driver `protobuf:"bytes,13,opt,name=log_driver,json=logDriver" json:"log_driver,omitempty"`

 }

 func (m *Task) Reset()                    { *m = Task{} }

@@ -334,6 +343,7 @@ func (m *Task) Copy() *Task {

 		Status:             *m.Status.Copy(),

 		DesiredState:       m.DesiredState,

 		Endpoint:           m.Endpoint.Copy(),

+		LogDriver:          m.LogDriver.Copy(),

 	}

 	if m.Networks != nil {

@@ -498,7 +508,7 @@ func (this *Task) GoString() string {

 	if this == nil {

 		return "nil"

 	}

-	s := make([]string, 0, 16)

+	s := make([]string, 0, 17)

 	s = append(s, "&api.Task{")

 	s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")

 	s = append(s, "Meta: "+strings.Replace(this.Meta.GoString(), `&`, ``, 1)+",\n")

@@ -516,6 +526,9 @@ func (this *Task) GoString() string {

 	if this.Endpoint != nil {

 		s = append(s, "Endpoint: "+fmt.Sprintf("%#v", this.Endpoint)+",\n")

 	}

+	if this.LogDriver != nil {

+		s = append(s, "LogDriver: "+fmt.Sprintf("%#v", this.LogDriver)+",\n")

+	}

 	s = append(s, "}")

 	return strings.Join(s, "")

 }

@@ -962,6 +975,16 @@ func (m *Task) MarshalTo(data []byte) (int, error) {

 		}

 		i += n20

 	}

+	if m.LogDriver != nil {

+		data[i] = 0x6a

+		i++

+		i = encodeVarintObjects(data, i, uint64(m.LogDriver.Size()))

+		n21, err := m.LogDriver.MarshalTo(data[i:])

+		if err != nil {

+			return 0, err

+		}

+		i += n21

+	}

 	return i, nil

 }

@@ -984,11 +1007,11 @@ func (m *NetworkAttachment) MarshalTo(data []byte) (int, error) {

 		data[i] = 0xa

 		i++

 		i = encodeVarintObjects(data, i, uint64(m.Network.Size()))

-		n21, err := m.Network.MarshalTo(data[i:])

+		n22, err := m.Network.MarshalTo(data[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n21

+		i += n22

 	}

 	if len(m.Addresses) > 0 {

 		for _, s := range m.Addresses {

@@ -1047,38 +1070,38 @@ func (m *Network) MarshalTo(data []byte) (int, error) {

 	data[i] = 0x12

 	i++

 	i = encodeVarintObjects(data, i, uint64(m.Meta.Size()))

-	n22, err := m.Meta.MarshalTo(data[i:])

+	n23, err := m.Meta.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n22

+	i += n23

 	data[i] = 0x1a

 	i++

 	i = encodeVarintObjects(data, i, uint64(m.Spec.Size()))

-	n23, err := m.Spec.MarshalTo(data[i:])

+	n24, err := m.Spec.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n23

+	i += n24

 	if m.DriverState != nil {

 		data[i] = 0x22

 		i++

 		i = encodeVarintObjects(data, i, uint64(m.DriverState.Size()))

-		n24, err := m.DriverState.MarshalTo(data[i:])

+		n25, err := m.DriverState.MarshalTo(data[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n24

+		i += n25

 	}

 	if m.IPAM != nil {

 		data[i] = 0x2a

 		i++

 		i = encodeVarintObjects(data, i, uint64(m.IPAM.Size()))

-		n25, err := m.IPAM.MarshalTo(data[i:])

+		n26, err := m.IPAM.MarshalTo(data[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n25

+		i += n26

 	}

 	return i, nil

 }

@@ -1107,27 +1130,27 @@ func (m *Cluster) MarshalTo(data []byte) (int, error) {

 	data[i] = 0x12

 	i++

 	i = encodeVarintObjects(data, i, uint64(m.Meta.Size()))

-	n26, err := m.Meta.MarshalTo(data[i:])

+	n27, err := m.Meta.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n26

+	i += n27

 	data[i] = 0x1a

 	i++

 	i = encodeVarintObjects(data, i, uint64(m.Spec.Size()))

-	n27, err := m.Spec.MarshalTo(data[i:])

+	n28, err := m.Spec.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n27

+	i += n28

 	data[i] = 0x22

 	i++

 	i = encodeVarintObjects(data, i, uint64(m.RootCA.Size()))

-	n28, err := m.RootCA.MarshalTo(data[i:])

+	n29, err := m.RootCA.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n28

+	i += n29

 	if len(m.NetworkBootstrapKeys) > 0 {

 		for _, msg := range m.NetworkBootstrapKeys {

 			data[i] = 0x2a

@@ -1317,6 +1340,10 @@ func (m *Task) Size() (n int) {

 		l = m.Endpoint.Size()

 		n += 1 + l + sovObjects(uint64(l))

 	}

+	if m.LogDriver != nil {

+		l = m.LogDriver.Size()

+		n += 1 + l + sovObjects(uint64(l))

+	}

 	return n

 }

@@ -1484,6 +1511,7 @@ func (this *Task) String() string {

 		`DesiredState:` + fmt.Sprintf("%v", this.DesiredState) + `,`,

 		`Networks:` + strings.Replace(fmt.Sprintf("%v", this.Networks), "NetworkAttachment", "NetworkAttachment", 1) + `,`,

 		`Endpoint:` + strings.Replace(fmt.Sprintf("%v", this.Endpoint), "Endpoint", "Endpoint", 1) + `,`,

+		`LogDriver:` + strings.Replace(fmt.Sprintf("%v", this.LogDriver), "Driver", "Driver", 1) + `,`,

 		`}`,

 	}, "")

 	return s

@@ -2774,6 +2802,39 @@ func (m *Task) Unmarshal(data []byte) error {

 				return err

 			}

 			iNdEx = postIndex

+		case 13:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field LogDriver", wireType)

+			}

+			var msglen int

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowObjects

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := data[iNdEx]

+				iNdEx++

+				msglen |= (int(b) & 0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			if msglen < 0 {

+				return ErrInvalidLengthObjects

+			}

+			postIndex := iNdEx + msglen

+			if postIndex > l {

+				return io.ErrUnexpectedEOF

+			}

+			if m.LogDriver == nil {

+				m.LogDriver = &Driver{}

+			}

+			if err := m.LogDriver.Unmarshal(data[iNdEx:postIndex]); err != nil {

+				return err

+			}

+			iNdEx = postIndex

 		default:

 			iNdEx = preIndex

 			skippy, err := skipObjects(data[iNdEx:])

@@ -3466,66 +3527,67 @@ var (

 )

 var fileDescriptorObjects = []byte{

-	// 965 bytes of a gzipped FileDescriptorProto

+	// 981 bytes of a gzipped FileDescriptorProto

 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x56, 0x4f, 0x6f, 0x1b, 0x45,

-	0x14, 0xaf, 0xed, 0xad, 0xed, 0x7d, 0x4e, 0x22, 0x31, 0x54, 0xd5, 0x36, 0x84, 0xa4, 0xb8, 0x02,

+	0x14, 0xaf, 0xed, 0x8d, 0xed, 0x7d, 0x8e, 0x23, 0x31, 0x54, 0xd5, 0x36, 0x84, 0xa4, 0xb8, 0x02,

 	0x71, 0x40, 0xae, 0x28, 0x05, 0x81, 0xa0, 0x42, 0xb6, 0x13, 0x81, 0x05, 0x81, 0x68, 0x5a, 0x85,

-	0xa3, 0x35, 0xd9, 0x9d, 0x86, 0xc5, 0xf6, 0xee, 0x6a, 0x66, 0xe2, 0x2a, 0x37, 0xc4, 0x07, 0x40,

-	0xe2, 0x0b, 0xf0, 0x55, 0xb8, 0x46, 0x9c, 0x38, 0x72, 0xaa, 0x68, 0x6f, 0x9c, 0xe0, 0x23, 0xf0,

-	0x66, 0xf6, 0xad, 0xbd, 0x95, 0xd7, 0x51, 0x2b, 0xa1, 0x1c, 0x56, 0x9e, 0x3f, 0xbf, 0xdf, 0x6f,

-	0xde, 0x7b, 0xf3, 0xde, 0x1b, 0xc3, 0x66, 0x7a, 0xf2, 0x83, 0x0c, 0x8d, 0xee, 0x65, 0x2a, 0x35,

-	0x29, 0x63, 0x51, 0x1a, 0x4e, 0xa4, 0xea, 0xe9, 0x27, 0x42, 0xcd, 0x26, 0xb1, 0xe9, 0xcd, 0xdf,

-	0xdf, 0xee, 0x98, 0xf3, 0x4c, 0x12, 0x60, 0xbb, 0xa3, 0x33, 0x19, 0x16, 0x93, 0x5b, 0x26, 0x9e,

-	0x49, 0x6d, 0xc4, 0x2c, 0xbb, 0xbb, 0x18, 0xd1, 0xd6, 0x8d, 0xd3, 0xf4, 0x34, 0x75, 0xc3, 0xbb,

-	0x76, 0x94, 0xaf, 0x76, 0x7f, 0xab, 0x81, 0x77, 0x28, 0x8d, 0x60, 0x9f, 0x42, 0x6b, 0x2e, 0x95,

-	0x8e, 0xd3, 0x24, 0xa8, 0xdd, 0xae, 0xbd, 0xdb, 0xb9, 0xf7, 0x46, 0x6f, 0xf5, 0xe4, 0xde, 0x71,

-	0x0e, 0x19, 0x78, 0x17, 0x4f, 0xf7, 0xae, 0xf1, 0x82, 0xc1, 0x3e, 0x03, 0x08, 0x95, 0x14, 0x46,

-	0x46, 0x63, 0x61, 0x82, 0xba, 0xe3, 0xbf, 0x59, 0xc5, 0x7f, 0x54, 0x18, 0xc5, 0x7d, 0x22, 0xf4,

-	0x8d, 0x65, 0x9f, 0x65, 0x51, 0xc1, 0x6e, 0xbc, 0x14, 0x9b, 0x08, 0x7d, 0xd3, 0xfd, 0xbb, 0x01,

-	0xde, 0x37, 0x69, 0x24, 0xd9, 0x4d, 0xa8, 0xc7, 0x91, 0x33, 0xde, 0x1f, 0x34, 0x9f, 0x3f, 0xdd,

-	0xab, 0x8f, 0xf6, 0x39, 0xae, 0xb0, 0x7b, 0xe0, 0xcd, 0xd0, 0x43, 0x32, 0x2b, 0xa8, 0x12, 0xb6,

-	0x11, 0x20, 0x9f, 0x1c, 0x96, 0x7d, 0x04, 0x9e, 0x0d, 0x2b, 0x19, 0xb3, 0x53, 0xc5, 0xb1, 0x67,

-	0x3e, 0x44, 0x4c, 0xc1, 0xb3, 0x78, 0x76, 0x00, 0x9d, 0x48, 0xea, 0x50, 0xc5, 0x99, 0xb1, 0x91,

-	0xf4, 0x1c, 0xfd, 0xce, 0x3a, 0xfa, 0xfe, 0x12, 0xca, 0xcb, 0x3c, 0x8c, 0x48, 0x13, 0xfd, 0x34,

-	0x67, 0x3a, 0xb8, 0xee, 0x14, 0x76, 0xd7, 0x1a, 0xe0, 0x50, 0x64, 0x02, 0x71, 0xd8, 0x97, 0xb0,

-	0x35, 0x13, 0x89, 0x38, 0x95, 0x6a, 0x4c, 0x2a, 0x4d, 0xa7, 0xf2, 0x56, 0xa5, 0xeb, 0x39, 0x32,

-	0x17, 0xe2, 0x9b, 0xb3, 0xf2, 0x14, 0xdd, 0x01, 0x61, 0x8c, 0x08, 0xbf, 0x9f, 0xc9, 0xc4, 0x04,

-	0x2d, 0xa7, 0xf2, 0x76, 0xa5, 0x2d, 0xd2, 0x3c, 0x49, 0xd5, 0xa4, 0xbf, 0x00, 0xf3, 0x12, 0x91,

-	0x7d, 0x01, 0x9d, 0x50, 0x2a, 0x13, 0x3f, 0x8e, 0x43, 0xbc, 0xb4, 0xa0, 0xed, 0x74, 0xf6, 0xaa,

-	0x74, 0x86, 0x4b, 0x18, 0x39, 0x55, 0x66, 0x76, 0x7f, 0xaf, 0x41, 0xeb, 0xa1, 0x54, 0xf3, 0x38,

-	0xfc, 0x7f, 0xaf, 0xfb, 0x93, 0x17, 0xae, 0xbb, 0xd2, 0x32, 0x3a, 0x76, 0xe5, 0xc6, 0x3f, 0x86,

-	0xb6, 0x4c, 0xa2, 0x2c, 0x8d, 0x31, 0x40, 0xde, 0xfa, 0x6c, 0x39, 0x20, 0x0c, 0x5f, 0xa0, 0xbb,

-	0xbf, 0xd6, 0xa1, 0x5d, 0x2c, 0xb3, 0xfb, 0x64, 0x41, 0x5e, 0x7b, 0xb7, 0x2f, 0x93, 0xb0, 0x26,

-	0xd0, 0xe1, 0xf7, 0xe1, 0x7a, 0x96, 0x2a, 0xa3, 0xd1, 0xd9, 0xc6, 0xba, 0x34, 0x39, 0x42, 0xc0,

-	0x30, 0x4d, 0x1e, 0xc7, 0xa7, 0x3c, 0x07, 0xb3, 0xef, 0xa0, 0x33, 0x8f, 0x95, 0x39, 0x13, 0xd3,

-	0x71, 0x9c, 0x69, 0x74, 0xda, 0x72, 0xdf, 0xb9, 0xec, 0xc8, 0xde, 0x71, 0x8e, 0x1f, 0x1d, 0x0d,

-	0xb6, 0x30, 0xd4, 0xb0, 0x98, 0x6a, 0x0e, 0x24, 0x35, 0xca, 0xf4, 0xf6, 0x21, 0xf8, 0x8b, 0x1d,

-	0xf6, 0x1e, 0x40, 0x92, 0x67, 0xc5, 0x78, 0x71, 0x4f, 0x9b, 0x48, 0xf6, 0x29, 0x57, 0xf0, 0xba,

-	0x7c, 0x02, 0x8c, 0x22, 0xc6, 0xc0, 0x13, 0x51, 0xa4, 0xdc, 0xad, 0xf9, 0xdc, 0x8d, 0xbb, 0xbf,

-	0x5c, 0x07, 0xef, 0x91, 0xd0, 0x93, 0xab, 0xae, 0x6c, 0x7b, 0xe6, 0xca, 0x3d, 0xa3, 0x3b, 0x3a,

-	0x4f, 0x01, 0xeb, 0x8e, 0xb7, 0x74, 0x87, 0x12, 0xc3, 0xba, 0x43, 0x80, 0xdc, 0x1d, 0x3d, 0x4d,

-	0x8d, 0x2b, 0x5f, 0x8f, 0xbb, 0x31, 0xbb, 0x03, 0xad, 0x04, 0x4b, 0xd6, 0xd2, 0x9b, 0x8e, 0x0e,

-	0x48, 0x6f, 0xda, 0x2a, 0x46, 0x6e, 0xd3, 0x6e, 0x21, 0x11, 0x4b, 0x45, 0x24, 0x49, 0x8a, 0xe5,

-	0x87, 0x7d, 0x40, 0x53, 0xc9, 0x55, 0x26, 0x64, 0x7f, 0x09, 0x2b, 0x4a, 0xa5, 0xc4, 0x64, 0xc7,

-	0xf0, 0x7a, 0x61, 0x6f, 0x59, 0xb0, 0xfd, 0x2a, 0x82, 0x8c, 0x14, 0x4a, 0x3b, 0xa5, 0xd6, 0xe4,

-	0xaf, 0x6f, 0x4d, 0x2e, 0x82, 0x55, 0xad, 0x69, 0x00, 0x9b, 0xd8, 0xe7, 0x62, 0x85, 0xad, 0xde,

-	0xae, 0xc8, 0x00, 0x50, 0x64, 0x6b, 0x4d, 0xb7, 0x27, 0x11, 0xc9, 0x37, 0x88, 0xe3, 0x66, 0xac,

-	0x0f, 0x6d, 0xca, 0x1b, 0x1d, 0x74, 0x5c, 0xee, 0xbe, 0x64, 0x4b, 0x5a, 0xd0, 0x5e, 0x28, 0xda,

-	0x8d, 0x57, 0x2a, 0xda, 0x9f, 0x6a, 0xf0, 0xda, 0x8a, 0x32, 0xfb, 0x10, 0xaf, 0x36, 0x5f, 0xbc,

-	0xec, 0xf1, 0x24, 0x1e, 0x2f, 0xb0, 0x6c, 0x07, 0x7c, 0x9b, 0xe8, 0x52, 0x6b, 0x99, 0x97, 0xb0,

-	0xcf, 0x97, 0x0b, 0x2c, 0x80, 0x96, 0x98, 0xc6, 0xc2, 0xee, 0x35, 0xdc, 0x5e, 0x31, 0xed, 0xfe,

-	0x5c, 0x87, 0x16, 0x89, 0x5d, 0x75, 0x1b, 0xa4, 0x63, 0x57, 0xca, 0xe3, 0x01, 0x6c, 0x44, 0x2a,

-	0x9e, 0xd3, 0x93, 0x23, 0xa9, 0x15, 0x6e, 0x57, 0x49, 0xec, 0x3b, 0x1c, 0x3e, 0x78, 0xee, 0x37,

-	0xbf, 0xd3, 0x07, 0xe0, 0xc5, 0x99, 0x98, 0xd1, 0x73, 0x57, 0x79, 0xf2, 0xe8, 0xa8, 0x7f, 0xf8,

-	0x6d, 0x96, 0xa7, 0x67, 0x1b, 0x1d, 0xf5, 0xec, 0x02, 0x77, 0xb4, 0xee, 0x3f, 0x18, 0x90, 0xe1,

-	0xf4, 0x4c, 0x1b, 0xa9, 0xae, 0x3a, 0x20, 0x74, 0xec, 0x4a, 0x40, 0x86, 0xd0, 0x52, 0x69, 0x6a,

-	0xc6, 0xa1, 0xb8, 0x2c, 0x16, 0x1c, 0x21, 0xc3, 0xfe, 0x60, 0xcb, 0x12, 0x6d, 0x37, 0xc8, 0xe7,

-	0xbc, 0x69, 0xa9, 0x43, 0x81, 0x9d, 0xfa, 0x66, 0xd1, 0x43, 0x4f, 0x70, 0x45, 0x1b, 0x25, 0xb2,

-	0xf1, 0x44, 0x9e, 0xdb, 0xff, 0x05, 0x8d, 0x75, 0x2f, 0xfa, 0x41, 0x12, 0xaa, 0x73, 0x17, 0xa8,

-	0xaf, 0xe4, 0x39, 0xbf, 0x41, 0x02, 0x83, 0x82, 0x8f, 0x8b, 0x9a, 0x7d, 0x0e, 0x3b, 0x72, 0x01,

-	0xb3, 0x8a, 0xe3, 0x29, 0xfe, 0xad, 0xc2, 0xd7, 0x61, 0x1c, 0x4e, 0x51, 0xd1, 0x35, 0x28, 0x8f,

-	0xdf, 0x92, 0x65, 0xa9, 0xaf, 0x73, 0xc4, 0xd0, 0x02, 0x06, 0x3b, 0x17, 0xcf, 0x76, 0xaf, 0xfd,

-	0x89, 0xdf, 0xbf, 0xcf, 0x76, 0x6b, 0x3f, 0x3e, 0xdf, 0xad, 0x5d, 0xe0, 0xf7, 0x07, 0x7e, 0x7f,

-	0xe1, 0x77, 0xd2, 0x74, 0x7f, 0x2e, 0x3f, 0xf8, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x55, 0xec,

-	0x86, 0xcc, 0x0a, 0x00, 0x00,

+	0xe3, 0x6a, 0xb2, 0x3b, 0x35, 0x8b, 0xed, 0xdd, 0xd5, 0xcc, 0x24, 0x55, 0x6e, 0x88, 0x0f, 0xc0,

+	0x47, 0xe0, 0xab, 0x70, 0x8d, 0x10, 0x07, 0x8e, 0x9c, 0x2a, 0xda, 0x1b, 0x27, 0xf8, 0x08, 0xbc,

+	0xf9, 0xb3, 0xf6, 0x56, 0x5e, 0x87, 0x56, 0xaa, 0x72, 0x58, 0x69, 0xfe, 0xfc, 0x7e, 0xbf, 0x79,

+	0xef, 0xcd, 0x7b, 0x6f, 0x07, 0xba, 0xd9, 0xc9, 0x0f, 0x3c, 0x52, 0xb2, 0x9f, 0x8b, 0x4c, 0x65,

+	0x84, 0xc4, 0x59, 0x34, 0xe5, 0xa2, 0x2f, 0x1f, 0x33, 0x31, 0x9f, 0x26, 0xaa, 0x7f, 0xf6, 0xfe,

+	0x76, 0x47, 0x9d, 0xe7, 0xdc, 0x01, 0xb6, 0x3b, 0x32, 0xe7, 0x51, 0x31, 0xb9, 0xa9, 0x92, 0x39,

+	0x97, 0x8a, 0xcd, 0xf3, 0x3b, 0x8b, 0x91, 0xdb, 0xba, 0x3e, 0xc9, 0x26, 0x99, 0x19, 0xde, 0xd1,

+	0x23, 0xbb, 0xda, 0xfb, 0xb5, 0x06, 0xde, 0x21, 0x57, 0x8c, 0x7c, 0x0a, 0xad, 0x33, 0x2e, 0x64,

+	0x92, 0xa5, 0x41, 0xed, 0x56, 0xed, 0xdd, 0xce, 0xdd, 0x37, 0xfa, 0xab, 0x27, 0xf7, 0x8f, 0x2d,

+	0x64, 0xe8, 0x5d, 0x3c, 0xd9, 0xbb, 0x46, 0x0b, 0x06, 0xf9, 0x0c, 0x20, 0x12, 0x9c, 0x29, 0x1e,

+	0x87, 0x4c, 0x05, 0x75, 0xc3, 0x7f, 0xb3, 0x8a, 0xff, 0xb0, 0x30, 0x8a, 0xfa, 0x8e, 0x30, 0x50,

+	0x9a, 0x7d, 0x9a, 0xc7, 0x05, 0xbb, 0xf1, 0x42, 0x6c, 0x47, 0x18, 0xa8, 0xde, 0xdf, 0x0d, 0xf0,

+	0xbe, 0xc9, 0x62, 0x4e, 0x6e, 0x40, 0x3d, 0x89, 0x8d, 0xf1, 0xfe, 0xb0, 0xf9, 0xec, 0xc9, 0x5e,

+	0x7d, 0xbc, 0x4f, 0x71, 0x85, 0xdc, 0x05, 0x6f, 0x8e, 0x1e, 0x3a, 0xb3, 0x82, 0x2a, 0x61, 0x1d,

+	0x01, 0xe7, 0x93, 0xc1, 0x92, 0x8f, 0xc0, 0xd3, 0x61, 0x75, 0xc6, 0xec, 0x54, 0x71, 0xf4, 0x99,

+	0x0f, 0x10, 0x53, 0xf0, 0x34, 0x9e, 0x1c, 0x40, 0x27, 0xe6, 0x32, 0x12, 0x49, 0xae, 0x74, 0x24,

+	0x3d, 0x43, 0xbf, 0xbd, 0x8e, 0xbe, 0xbf, 0x84, 0xd2, 0x32, 0x0f, 0x23, 0xd2, 0x44, 0x3f, 0xd5,

+	0xa9, 0x0c, 0x36, 0x8c, 0xc2, 0xee, 0x5a, 0x03, 0x0c, 0xca, 0x99, 0xe0, 0x38, 0xe4, 0x4b, 0xd8,

+	0x9a, 0xb3, 0x94, 0x4d, 0xb8, 0x08, 0x9d, 0x4a, 0xd3, 0xa8, 0xbc, 0x55, 0xe9, 0xba, 0x45, 0x5a,

+	0x21, 0xda, 0x9d, 0x97, 0xa7, 0xe8, 0x0e, 0x30, 0xa5, 0x58, 0xf4, 0xfd, 0x9c, 0xa7, 0x2a, 0x68,

+	0x19, 0x95, 0xb7, 0x2b, 0x6d, 0xe1, 0xea, 0x71, 0x26, 0xa6, 0x83, 0x05, 0x98, 0x96, 0x88, 0xe4,

+	0x0b, 0xe8, 0x44, 0x5c, 0xa8, 0xe4, 0x51, 0x12, 0xe1, 0xa5, 0x05, 0x6d, 0xa3, 0xb3, 0x57, 0xa5,

+	0x33, 0x5a, 0xc2, 0x9c, 0x53, 0x65, 0x66, 0xef, 0xb7, 0x1a, 0xb4, 0x1e, 0x70, 0x71, 0x96, 0x44,

+	0xaf, 0xf6, 0xba, 0x3f, 0x79, 0xee, 0xba, 0x2b, 0x2d, 0x73, 0xc7, 0xae, 0xdc, 0xf8, 0xc7, 0xd0,

+	0xe6, 0x69, 0x9c, 0x67, 0x09, 0x06, 0xc8, 0x5b, 0x9f, 0x2d, 0x07, 0x0e, 0x43, 0x17, 0xe8, 0xde,

+	0x2f, 0x75, 0x68, 0x17, 0xcb, 0xe4, 0x9e, 0xb3, 0xc0, 0xd6, 0xde, 0xad, 0xcb, 0x24, 0xb4, 0x09,

+	0xee, 0xf0, 0x7b, 0xb0, 0x91, 0x67, 0x42, 0x49, 0x74, 0xb6, 0xb1, 0x2e, 0x4d, 0x8e, 0x10, 0x30,

+	0xca, 0xd2, 0x47, 0xc9, 0x84, 0x5a, 0x30, 0xf9, 0x0e, 0x3a, 0x67, 0x89, 0x50, 0xa7, 0x6c, 0x16,

+	0x26, 0xb9, 0x44, 0xa7, 0x35, 0xf7, 0x9d, 0xcb, 0x8e, 0xec, 0x1f, 0x5b, 0xfc, 0xf8, 0x68, 0xb8,

+	0x85, 0xa1, 0x86, 0xc5, 0x54, 0x52, 0x70, 0x52, 0xe3, 0x5c, 0x6e, 0x1f, 0x82, 0xbf, 0xd8, 0x21,

+	0xef, 0x01, 0xa4, 0x36, 0x2b, 0xc2, 0xc5, 0x3d, 0x75, 0x91, 0xec, 0xbb, 0x5c, 0xc1, 0xeb, 0xf2,

+	0x1d, 0x60, 0x1c, 0x13, 0x02, 0x1e, 0x8b, 0x63, 0x61, 0x6e, 0xcd, 0xa7, 0x66, 0xdc, 0xfb, 0x7d,

+	0x03, 0xbc, 0x87, 0x4c, 0x4e, 0xaf, 0xba, 0xb2, 0xf5, 0x99, 0x2b, 0xf7, 0x8c, 0xee, 0x48, 0x9b,

+	0x02, 0xda, 0x1d, 0x6f, 0xe9, 0x8e, 0x4b, 0x0c, 0xed, 0x8e, 0x03, 0x58, 0x77, 0xe4, 0x2c, 0x53,

+	0xa6, 0x7c, 0x3d, 0x6a, 0xc6, 0xe4, 0x36, 0xb4, 0x52, 0x2c, 0x59, 0x4d, 0x6f, 0x1a, 0x3a, 0x20,

+	0xbd, 0xa9, 0xab, 0x18, 0xb9, 0x4d, 0xbd, 0x85, 0x44, 0x2c, 0x15, 0x96, 0xa6, 0x19, 0x96, 0x1f,

+	0xf6, 0x01, 0xe9, 0x4a, 0xae, 0x32, 0x21, 0x07, 0x4b, 0x58, 0x51, 0x2a, 0x25, 0x26, 0x39, 0x86,

+	0xd7, 0x0b, 0x7b, 0xcb, 0x82, 0xed, 0x97, 0x11, 0x24, 0x4e, 0xa1, 0xb4, 0x53, 0x6a, 0x4d, 0xfe,

+	0xfa, 0xd6, 0x64, 0x22, 0x58, 0xd5, 0x9a, 0x86, 0xd0, 0xc5, 0x3e, 0x97, 0x08, 0x6c, 0xf5, 0x7a,

+	0x85, 0x07, 0x80, 0x22, 0x5b, 0x6b, 0xba, 0xbd, 0x13, 0xe1, 0x74, 0xd3, 0x71, 0xcc, 0x8c, 0x0c,

+	0xa0, 0xed, 0xf2, 0x46, 0x06, 0x1d, 0x93, 0xbb, 0x2f, 0xd8, 0x92, 0x16, 0xb4, 0xe7, 0x8a, 0x76,

+	0xf3, 0x65, 0x8a, 0x16, 0x3b, 0x05, 0xcc, 0xb2, 0x49, 0x18, 0x8b, 0x04, 0xff, 0x7d, 0x41, 0xd7,

+	0x70, 0xb7, 0xab, 0xb8, 0xfb, 0x06, 0x41, 0x7d, 0x44, 0xdb, 0x61, 0xef, 0xa7, 0x1a, 0xbc, 0xb6,

+	0x62, 0x14, 0xf9, 0x10, 0xb3, 0xc2, 0x2e, 0x5e, 0xf6, 0xdf, 0x75, 0x3c, 0x5a, 0x60, 0xc9, 0x0e,

+	0xf8, 0xba, 0x46, 0xb8, 0x94, 0xdc, 0x56, 0xbf, 0x4f, 0x97, 0x0b, 0x24, 0x80, 0x16, 0x9b, 0x25,

+	0x4c, 0xef, 0x35, 0xcc, 0x5e, 0x31, 0xed, 0xfd, 0x5c, 0x87, 0x96, 0x13, 0xbb, 0xea, 0x0e, 0xea,

+	0x8e, 0x5d, 0xa9, 0xac, 0xfb, 0xb0, 0x69, 0xc3, 0xe9, 0x52, 0xc2, 0xfb, 0xdf, 0xa0, 0x76, 0x2c,

+	0xde, 0xa6, 0xc3, 0x7d, 0xf0, 0x92, 0x9c, 0xcd, 0xdd, 0x9f, 0xb2, 0xf2, 0xe4, 0xf1, 0xd1, 0xe0,

+	0xf0, 0xdb, 0xdc, 0x66, 0x76, 0x1b, 0x1d, 0xf5, 0xf4, 0x02, 0x35, 0xb4, 0xde, 0x3f, 0x18, 0x90,

+	0xd1, 0xec, 0x54, 0x2a, 0x2e, 0xae, 0x3a, 0x20, 0xee, 0xd8, 0x95, 0x80, 0x8c, 0xa0, 0x25, 0xb2,

+	0x4c, 0x85, 0x11, 0xbb, 0x2c, 0x16, 0x14, 0x21, 0xa3, 0xc1, 0x70, 0x4b, 0x13, 0x75, 0x23, 0xb1,

+	0x73, 0xda, 0xd4, 0xd4, 0x11, 0xc3, 0x26, 0x7f, 0xa3, 0x68, 0xbf, 0x27, 0xb8, 0x22, 0x95, 0x60,

+	0x79, 0x38, 0xe5, 0xe7, 0xfa, 0x49, 0xd1, 0x58, 0xf7, 0x18, 0x38, 0x48, 0x23, 0x71, 0x6e, 0x02,

+	0xf5, 0x15, 0x3f, 0xa7, 0xd7, 0x9d, 0xc0, 0xb0, 0xe0, 0xe3, 0xa2, 0x24, 0x9f, 0xc3, 0x0e, 0x5f,

+	0xc0, 0xb4, 0x62, 0x38, 0xc3, 0x17, 0x19, 0xfe, 0x58, 0xc2, 0x68, 0x86, 0x8a, 0xa6, 0xb7, 0x79,

+	0xf4, 0x26, 0x2f, 0x4b, 0x7d, 0x6d, 0x11, 0x23, 0x0d, 0x18, 0xee, 0x5c, 0x3c, 0xdd, 0xbd, 0xf6,

+	0x27, 0x7e, 0xff, 0x3e, 0xdd, 0xad, 0xfd, 0xf8, 0x6c, 0xb7, 0x76, 0x81, 0xdf, 0x1f, 0xf8, 0xfd,

+	0x85, 0xdf, 0x49, 0xd3, 0xbc, 0x4b, 0x3f, 0xf8, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xb9, 0x27, 0xf6,

+	0x9e, 0x07, 0x0b, 0x00, 0x00,

 }

@@ -155,6 +155,16 @@ message Task {

 	// A copy of runtime state of service endpoint from Service

 	// object to be distributed to agents as part of the task.

 	Endpoint endpoint = 12;

+

+	// LogDriver specifies the selected log driver to use for the task. Agent

+	// processes should always favor the value in this field.

+	//

+	// If present in the TaskSpec, this will be a copy of that value. The

+	// orchestrator may choose to insert a value here, which should be honored,

+	// such a cluster default or policy-based value.

+	//

+	// If not present, the daemon's default will be used.

+	Driver log_driver = 13;

 }

 // NetworkAttachment specifies the network parameters of attachment to

@@ -308,6 +308,9 @@ type TaskSpec struct {

 	Restart *RestartPolicy `protobuf:"bytes,4,opt,name=restart" json:"restart,omitempty"`

 	// Placement specifies node selection constraints

 	Placement *Placement `protobuf:"bytes,5,opt,name=placement" json:"placement,omitempty"`

+	// LogDriver specifies the log driver to use for the task. Any runtime will

+	// direct logs into the specified driver for the duration of the task.

+	LogDriver *Driver `protobuf:"bytes,6,opt,name=log_driver,json=logDriver" json:"log_driver,omitempty"`

 }

 func (m *TaskSpec) Reset()                    { *m = TaskSpec{} }

@@ -500,6 +503,12 @@ type ClusterSpec struct {

 	Dispatcher DispatcherConfig `protobuf:"bytes,5,opt,name=dispatcher" json:"dispatcher"`

 	// CAConfig defines cluster-level certificate authority settings.

 	CAConfig CAConfig `protobuf:"bytes,6,opt,name=ca_config,json=caConfig" json:"ca_config"`

+	// DefaultLogDriver specifies the log driver to use for the cluster if not

+	// specified for each task.

+	//

+	// If this is changed, only new tasks will pick up the new log driver.

+	// Existing tasks will continue to use the previous default until rescheduled.

+	DefaultLogDriver *Driver `protobuf:"bytes,7,opt,name=default_log_driver,json=defaultLogDriver" json:"default_log_driver,omitempty"`

 }

 func (m *ClusterSpec) Reset()                    { *m = ClusterSpec{} }

@@ -625,6 +634,7 @@ func (m *TaskSpec) Copy() *TaskSpec {

 		Resources: m.Resources.Copy(),

 		Restart:   m.Restart.Copy(),

 		Placement: m.Placement.Copy(),

+		LogDriver: m.LogDriver.Copy(),

 	}

 	switch m.Runtime.(type) {

@@ -749,6 +759,7 @@ func (m *ClusterSpec) Copy() *ClusterSpec {

 		Raft:             *m.Raft.Copy(),

 		Dispatcher:       *m.Dispatcher.Copy(),

 		CAConfig:         *m.CAConfig.Copy(),

+		DefaultLogDriver: m.DefaultLogDriver.Copy(),

 	}

 	return o

@@ -840,7 +851,7 @@ func (this *TaskSpec) GoString() string {

 	if this == nil {

 		return "nil"

 	}

-	s := make([]string, 0, 8)

+	s := make([]string, 0, 9)

 	s = append(s, "&api.TaskSpec{")

 	if this.Runtime != nil {

 		s = append(s, "Runtime: "+fmt.Sprintf("%#v", this.Runtime)+",\n")

@@ -854,6 +865,9 @@ func (this *TaskSpec) GoString() string {

 	if this.Placement != nil {

 		s = append(s, "Placement: "+fmt.Sprintf("%#v", this.Placement)+",\n")

 	}

+	if this.LogDriver != nil {

+		s = append(s, "LogDriver: "+fmt.Sprintf("%#v", this.LogDriver)+",\n")

+	}

 	s = append(s, "}")

 	return strings.Join(s, "")

 }

@@ -947,7 +961,7 @@ func (this *ClusterSpec) GoString() string {

 	if this == nil {

 		return "nil"

 	}

-	s := make([]string, 0, 10)

+	s := make([]string, 0, 11)

 	s = append(s, "&api.ClusterSpec{")

 	s = append(s, "Annotations: "+strings.Replace(this.Annotations.GoString(), `&`, ``, 1)+",\n")

 	s = append(s, "AcceptancePolicy: "+strings.Replace(this.AcceptancePolicy.GoString(), `&`, ``, 1)+",\n")

@@ -955,6 +969,9 @@ func (this *ClusterSpec) GoString() string {

 	s = append(s, "Raft: "+strings.Replace(this.Raft.GoString(), `&`, ``, 1)+",\n")

 	s = append(s, "Dispatcher: "+strings.Replace(this.Dispatcher.GoString(), `&`, ``, 1)+",\n")

 	s = append(s, "CAConfig: "+strings.Replace(this.CAConfig.GoString(), `&`, ``, 1)+",\n")

+	if this.DefaultLogDriver != nil {

+		s = append(s, "DefaultLogDriver: "+fmt.Sprintf("%#v", this.DefaultLogDriver)+",\n")

+	}

 	s = append(s, "}")

 	return strings.Join(s, "")

 }

@@ -1257,6 +1274,16 @@ func (m *TaskSpec) MarshalTo(data []byte) (int, error) {

 		}

 		i += n12

 	}

+	if m.LogDriver != nil {

+		data[i] = 0x32

+		i++

+		i = encodeVarintSpecs(data, i, uint64(m.LogDriver.Size()))

+		n13, err := m.LogDriver.MarshalTo(data[i:])

+		if err != nil {

+			return 0, err

+		}

+		i += n13

+	}

 	return i, nil

 }

@@ -1266,11 +1293,11 @@ func (m *TaskSpec_Container) MarshalTo(data []byte) (int, error) {

 		data[i] = 0xa

 		i++

 		i = encodeVarintSpecs(data, i, uint64(m.Container.Size()))

-		n13, err := m.Container.MarshalTo(data[i:])

+		n14, err := m.Container.MarshalTo(data[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n13

+		i += n14

 	}

 	return i, nil

 }

@@ -1385,21 +1412,21 @@ func (m *ContainerSpec) MarshalTo(data []byte) (int, error) {

 		data[i] = 0x4a

 		i++

 		i = encodeVarintSpecs(data, i, uint64(m.StopGracePeriod.Size()))

-		n14, err := m.StopGracePeriod.MarshalTo(data[i:])

+		n15, err := m.StopGracePeriod.MarshalTo(data[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n14

+		i += n15

 	}

 	if m.PullOptions != nil {

 		data[i] = 0x52

 		i++

 		i = encodeVarintSpecs(data, i, uint64(m.PullOptions.Size()))

-		n15, err := m.PullOptions.MarshalTo(data[i:])

+		n16, err := m.PullOptions.MarshalTo(data[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n15

+		i += n16

 	}

 	return i, nil

 }

@@ -1483,20 +1510,20 @@ func (m *NetworkSpec) MarshalTo(data []byte) (int, error) {

 	data[i] = 0xa

 	i++

 	i = encodeVarintSpecs(data, i, uint64(m.Annotations.Size()))

-	n16, err := m.Annotations.MarshalTo(data[i:])

+	n17, err := m.Annotations.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n16

+	i += n17

 	if m.DriverConfig != nil {

 		data[i] = 0x12

 		i++

 		i = encodeVarintSpecs(data, i, uint64(m.DriverConfig.Size()))

-		n17, err := m.DriverConfig.MarshalTo(data[i:])

+		n18, err := m.DriverConfig.MarshalTo(data[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n17

+		i += n18

 	}

 	if m.Ipv6Enabled {

 		data[i] = 0x18

@@ -1522,11 +1549,11 @@ func (m *NetworkSpec) MarshalTo(data []byte) (int, error) {

 		data[i] = 0x2a

 		i++

 		i = encodeVarintSpecs(data, i, uint64(m.IPAM.Size()))

-		n18, err := m.IPAM.MarshalTo(data[i:])

+		n19, err := m.IPAM.MarshalTo(data[i:])

 		if err != nil {

 			return 0, err

 		}

-		i += n18

+		i += n19

 	}

 	return i, nil

 }

@@ -1549,51 +1576,61 @@ func (m *ClusterSpec) MarshalTo(data []byte) (int, error) {

 	data[i] = 0xa

 	i++

 	i = encodeVarintSpecs(data, i, uint64(m.Annotations.Size()))

-	n19, err := m.Annotations.MarshalTo(data[i:])

+	n20, err := m.Annotations.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n19

+	i += n20

 	data[i] = 0x12

 	i++

 	i = encodeVarintSpecs(data, i, uint64(m.AcceptancePolicy.Size()))

-	n20, err := m.AcceptancePolicy.MarshalTo(data[i:])

+	n21, err := m.AcceptancePolicy.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n20

+	i += n21

 	data[i] = 0x1a

 	i++

 	i = encodeVarintSpecs(data, i, uint64(m.Orchestration.Size()))

-	n21, err := m.Orchestration.MarshalTo(data[i:])

+	n22, err := m.Orchestration.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n21

+	i += n22

 	data[i] = 0x22

 	i++

 	i = encodeVarintSpecs(data, i, uint64(m.Raft.Size()))

-	n22, err := m.Raft.MarshalTo(data[i:])

+	n23, err := m.Raft.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n22

+	i += n23

 	data[i] = 0x2a

 	i++

 	i = encodeVarintSpecs(data, i, uint64(m.Dispatcher.Size()))

-	n23, err := m.Dispatcher.MarshalTo(data[i:])

+	n24, err := m.Dispatcher.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n23

+	i += n24

 	data[i] = 0x32

 	i++

 	i = encodeVarintSpecs(data, i, uint64(m.CAConfig.Size()))

-	n24, err := m.CAConfig.MarshalTo(data[i:])

+	n25, err := m.CAConfig.MarshalTo(data[i:])

 	if err != nil {

 		return 0, err

 	}

-	i += n24

+	i += n25

+	if m.DefaultLogDriver != nil {

+		data[i] = 0x3a

+		i++

+		i = encodeVarintSpecs(data, i, uint64(m.DefaultLogDriver.Size()))

+		n26, err := m.DefaultLogDriver.MarshalTo(data[i:])

+		if err != nil {

+			return 0, err

+		}

+		i += n26

+	}

 	return i, nil

 }

@@ -1736,6 +1773,10 @@ func (m *TaskSpec) Size() (n int) {

 		l = m.Placement.Size()

 		n += 1 + l + sovSpecs(uint64(l))

 	}

+	if m.LogDriver != nil {

+		l = m.LogDriver.Size()

+		n += 1 + l + sovSpecs(uint64(l))

+	}

 	return n

 }

@@ -1868,6 +1909,10 @@ func (m *ClusterSpec) Size() (n int) {

 	n += 1 + l + sovSpecs(uint64(l))

 	l = m.CAConfig.Size()

 	n += 1 + l + sovSpecs(uint64(l))

+	if m.DefaultLogDriver != nil {

+		l = m.DefaultLogDriver.Size()

+		n += 1 + l + sovSpecs(uint64(l))

+	}

 	return n

 }

@@ -1971,6 +2016,7 @@ func (this *TaskSpec) String() string {

 		`Resources:` + strings.Replace(fmt.Sprintf("%v", this.Resources), "ResourceRequirements", "ResourceRequirements", 1) + `,`,

 		`Restart:` + strings.Replace(fmt.Sprintf("%v", this.Restart), "RestartPolicy", "RestartPolicy", 1) + `,`,

 		`Placement:` + strings.Replace(fmt.Sprintf("%v", this.Placement), "Placement", "Placement", 1) + `,`,

+		`LogDriver:` + strings.Replace(fmt.Sprintf("%v", this.LogDriver), "Driver", "Driver", 1) + `,`,

 		`}`,

 	}, "")

 	return s

@@ -2060,6 +2106,7 @@ func (this *ClusterSpec) String() string {

 		`Raft:` + strings.Replace(strings.Replace(this.Raft.String(), "RaftConfig", "RaftConfig", 1), `&`, ``, 1) + `,`,

 		`Dispatcher:` + strings.Replace(strings.Replace(this.Dispatcher.String(), "DispatcherConfig", "DispatcherConfig", 1), `&`, ``, 1) + `,`,

 		`CAConfig:` + strings.Replace(strings.Replace(this.CAConfig.String(), "CAConfig", "CAConfig", 1), `&`, ``, 1) + `,`,

+		`DefaultLogDriver:` + strings.Replace(fmt.Sprintf("%v", this.DefaultLogDriver), "Driver", "Driver", 1) + `,`,

 		`}`,

 	}, "")

 	return s

@@ -2867,6 +2914,39 @@ func (m *TaskSpec) Unmarshal(data []byte) error {

 				return err

 			}

 			iNdEx = postIndex

+		case 6:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field LogDriver", wireType)

+			}

+			var msglen int

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowSpecs

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := data[iNdEx]

+				iNdEx++

+				msglen |= (int(b) & 0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			if msglen < 0 {

+				return ErrInvalidLengthSpecs

+			}

+			postIndex := iNdEx + msglen

+			if postIndex > l {

+				return io.ErrUnexpectedEOF

+			}

+			if m.LogDriver == nil {

+				m.LogDriver = &Driver{}

+			}

+			if err := m.LogDriver.Unmarshal(data[iNdEx:postIndex]); err != nil {

+				return err

+			}

+			iNdEx = postIndex

 		default:

 			iNdEx = preIndex

 			skippy, err := skipSpecs(data[iNdEx:])

@@ -3894,6 +3974,39 @@ func (m *ClusterSpec) Unmarshal(data []byte) error {

 				return err

 			}

 			iNdEx = postIndex

+		case 7:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field DefaultLogDriver", wireType)

+			}

+			var msglen int

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowSpecs

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := data[iNdEx]

+				iNdEx++

+				msglen |= (int(b) & 0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			if msglen < 0 {

+				return ErrInvalidLengthSpecs

+			}

+			postIndex := iNdEx + msglen

+			if postIndex > l {

+				return io.ErrUnexpectedEOF

+			}

+			if m.DefaultLogDriver == nil {

+				m.DefaultLogDriver = &Driver{}

+			}

+			if err := m.DefaultLogDriver.Unmarshal(data[iNdEx:postIndex]); err != nil {

+				return err

+			}

+			iNdEx = postIndex

 		default:

 			iNdEx = preIndex

 			skippy, err := skipSpecs(data[iNdEx:])

@@ -4021,85 +4134,88 @@ var (

 )

 var fileDescriptorSpecs = []byte{

-	// 1279 bytes of a gzipped FileDescriptorProto

-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x56, 0xcf, 0x72, 0x1b, 0xc5,

-	0x13, 0xb6, 0xec, 0xb5, 0x2c, 0xf7, 0xda, 0x89, 0x33, 0x95, 0x5f, 0xa2, 0x28, 0xf9, 0xd9, 0x8e,

-	0x08, 0x10, 0xa8, 0x42, 0x06, 0x41, 0x25, 0xe1, 0x5f, 0xc1, 0x5a, 0x16, 0x8e, 0x09, 0x76, 0xb6,

-	0xc6, 0x49, 0x38, 0xba, 0x46, 0xab, 0x89, 0xbc, 0xe5, 0xd5, 0xce, 0x32, 0x3b, 0x52, 0xca, 0x37,

-	0x8e, 0x29, 0x0e, 0xdc, 0xe0, 0x40, 0x15, 0x27, 0xde, 0x81, 0x67, 0xc8, 0x91, 0x1b, 0x9c, 0x52,

-	0x24, 0x4f, 0x40, 0x15, 0x2f, 0x40, 0xcf, 0xec, 0x48, 0x5a, 0x91, 0x75, 0xc2, 0xc1, 0x87, 0xad,

-	0x9a, 0x3f, 0xdf, 0xf7, 0xf5, 0x4c, 0x77, 0x4f, 0xf7, 0x82, 0x9b, 0x26, 0x3c, 0x48, 0x1b, 0x89,

-	0x14, 0x4a, 0x10, 0xd2, 0x15, 0xc1, 0x11, 0x97, 0x8d, 0xf4, 0x11, 0x93, 0xfd, 0xa3, 0x50, 0x35,

-	0x86, 0xef, 0xd5, 0x5c, 0x75, 0x9c, 0x70, 0x0b, 0xa8, 0x9d, 0xef, 0x89, 0x9e, 0x30, 0xc3, 0x0d,

-	0x3d, 0xb2, 0xab, 0x17, 0xbb, 0x03, 0xc9, 0x54, 0x28, 0xe2, 0x8d, 0xd1, 0x20, 0xdb, 0xa8, 0x7f,

-	0xef, 0x40, 0x65, 0x4f, 0x74, 0xf9, 0x3e, 0xda, 0x20, 0xdb, 0xe0, 0xb2, 0x38, 0x16, 0xca, 0x00,

-	0xd2, 0x6a, 0x69, 0xbd, 0x74, 0xdd, 0x6d, 0xae, 0x35, 0x5e, 0x34, 0xd9, 0xf0, 0x26, 0xb0, 0x4d,

-	0xe7, 0xc9, 0xd3, 0xb5, 0x19, 0x9a, 0x67, 0x92, 0x77, 0xc1, 0x91, 0x22, 0xe2, 0xd5, 0x59, 0x54,

-	0x38, 0xd3, 0xbc, 0x52, 0xa4, 0xa0, 0x8d, 0x52, 0xc4, 0x50, 0x83, 0x44, 0xd3, 0xd0, 0xe7, 0xfd,

-	0x0e, 0x97, 0xe9, 0x61, 0x98, 0x54, 0xe7, 0x0c, 0xef, 0xcd, 0x93, 0x78, 0xfa, 0xb0, 0x8d, 0xdd,

-	0x31, 0x9c, 0xe6, 0xa8, 0x64, 0x17, 0x96, 0xd8, 0x90, 0x85, 0x11, 0xeb, 0x84, 0x51, 0xa8, 0x8e,

-	0xab, 0x8e, 0x91, 0x7a, 0xeb, 0xa5, 0x52, 0x5e, 0x8e, 0x40, 0xa7, 0xe8, 0xf5, 0x2e, 0xc0, 0xc4,

-	0x10, 0x79, 0x03, 0x16, 0xfc, 0xf6, 0xde, 0xd6, 0xce, 0xde, 0xf6, 0xca, 0x4c, 0xed, 0xd2, 0x77,

-	0x3f, 0xaf, 0xff, 0x4f, 0x6b, 0x4c, 0x00, 0x3e, 0x8f, 0xbb, 0x61, 0xdc, 0x23, 0xd7, 0xa1, 0xe2,

-	0xb5, 0x5a, 0x6d, 0xff, 0x5e, 0x7b, 0x6b, 0xa5, 0x54, 0xab, 0x21, 0xf0, 0xc2, 0x34, 0xd0, 0x0b,

-	0x02, 0x9e, 0x28, 0xde, 0xad, 0x39, 0x8f, 0x7f, 0x59, 0x9d, 0xa9, 0x3f, 0x2e, 0xc1, 0x52, 0xfe,

-	0x10, 0x68, 0xa8, 0xec, 0xb5, 0xee, 0xed, 0x3c, 0x68, 0xa3, 0x9d, 0x31, 0x3d, 0x8f, 0xf0, 0x02,

-	0x15, 0x0e, 0x39, 0xb9, 0x06, 0xf3, 0xbe, 0x77, 0x7f, 0xbf, 0x8d, 0x56, 0xc6, 0xc7, 0xc9, 0xc3,

-	0x7c, 0x36, 0x48, 0x0d, 0x6a, 0x8b, 0x7a, 0x3b, 0x7b, 0x2b, 0xb3, 0xc5, 0xa8, 0x2d, 0xc9, 0xc2,

-	0xd8, 0x1e, 0xe5, 0x57, 0x07, 0xdc, 0x7d, 0x2e, 0x87, 0x61, 0x70, 0xca, 0x39, 0x71, 0x03, 0x1c,

-	0xc5, 0xd2, 0x23, 0x93, 0x13, 0x6e, 0x71, 0x4e, 0xdc, 0xc3, 0x7d, 0x6d, 0xd4, 0xd2, 0x0d, 0x5e,