From 03f07293c70c26ebcc0a19299493c3799aaaadc5 Mon Sep 17 00:00:00 2001 From: Diogo Monica Date: Fri, 12 Aug 2016 17:11:27 -0700 Subject: [PATCH 01/10] Initial secrets protobuf changes and dispatcher support Add a Secret top-level object type. Add a SecretReference that allows a service to reference the secrets it needs. Add dispatcher Assignments method which will replace Tasks going forward. This provides a stream with incremental task and secret updates. Additional object types can be supported in the assignment set in the future. The first message returned from the Assignments stream is the complete set of tasks and secrets for the node, and this is used to synchronize the node's view with the manager's. Additional messages returned by the stream are incremental updates that add, update, or remove one or more tasks or secrets. If the agent gets out of sync with the manager, it can reinitiate the Assignments stream to sync up. Signed-off-by: Aaron Lehmann --- api/dispatcher.pb.go | 893 +++++++++++++++++++++++++++++-- api/dispatcher.proto | 59 +- api/objects.pb.go | 419 ++++++++++++--- api/objects.proto | 12 + api/raft.pb.go | 227 ++++++-- api/raft.proto | 3 +- api/snapshot.pb.go | 116 +++- api/snapshot.proto | 1 + api/specs.pb.go | 542 +++++++++++++++---- api/specs.proto | 18 + api/types.pb.go | 734 +++++++++++++++++-------- api/types.proto | 24 + manager/dispatcher/dispatcher.go | 289 +++++++++- manager/state/store/secrets.go | 225 ++++++++ manager/state/watch.go | 81 +++ 15 files changed, 3120 insertions(+), 523 deletions(-) create mode 100644 manager/state/store/secrets.go diff --git a/api/dispatcher.pb.go b/api/dispatcher.pb.go index 818933dd31..e2bcf27543 100644 --- a/api/dispatcher.pb.go +++ b/api/dispatcher.pb.go @@ -34,6 +34,31 @@ var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf +// AssignmentType specifies whether this assignment message carries +// the full state, or is an update to an existing state. +type AssignmentsMessage_AssignmentType int32 + +const ( + AssignmentsMessage_COMPLETE AssignmentsMessage_AssignmentType = 0 + AssignmentsMessage_INCREMENTAL AssignmentsMessage_AssignmentType = 1 +) + +var AssignmentsMessage_AssignmentType_name = map[int32]string{ + 0: "COMPLETE", + 1: "INCREMENTAL", +} +var AssignmentsMessage_AssignmentType_value = map[string]int32{ + "COMPLETE": 0, + "INCREMENTAL": 1, +} + +func (x AssignmentsMessage_AssignmentType) String() string { + return proto.EnumName(AssignmentsMessage_AssignmentType_name, int32(x)) +} +func (AssignmentsMessage_AssignmentType) EnumDescriptor() ([]byte, []int) { + return fileDescriptorDispatcher, []int{9, 0} +} + // SessionRequest starts a session. type SessionRequest struct { Description *NodeDescription `protobuf:"bytes,1,opt,name=description" json:"description,omitempty"` @@ -180,6 +205,49 @@ func (m *TasksMessage) Reset() { *m = TasksMessage{} } func (*TasksMessage) ProtoMessage() {} func (*TasksMessage) Descriptor() ([]byte, []int) { return fileDescriptorDispatcher, []int{7} } +type AssignmentsRequest struct { + SessionID string `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"` +} + +func (m *AssignmentsRequest) Reset() { *m = AssignmentsRequest{} } +func (*AssignmentsRequest) ProtoMessage() {} +func (*AssignmentsRequest) Descriptor() ([]byte, []int) { return fileDescriptorDispatcher, []int{8} } + +type AssignmentsMessage struct { + Type AssignmentsMessage_AssignmentType `protobuf:"varint,1,opt,name=type,proto3,enum=docker.swarmkit.v1.AssignmentsMessage_AssignmentType" json:"type,omitempty"` + // AppliesTo references the previous ResultsIn value, to chain + // incremental updates together. For the first update in a stream, + // AppliesTo is empty. If AppliesTo does not match the previously + // received ResultsIn, the consumer of the stream should start a new + // Assignments stream to re-sync. + AppliesTo string `protobuf:"bytes,2,opt,name=applies_to,json=appliesTo,proto3" json:"applies_to,omitempty"` + // ResultsIn identifies the result of this assignments message, to + // match against the next message's AppliesTo value and protect + // against missed messages. + ResultsIn string `protobuf:"bytes,3,opt,name=results_in,json=resultsIn,proto3" json:"results_in,omitempty"` + // UpdateTasks is a set of new or updated tasks to run on this node. + // In the first assignments message, it contains all of the tasks + // to run on this node. Tasks outside of this set running on the node + // should be terminated. + UpdateTasks []*Task `protobuf:"bytes,4,rep,name=update_tasks,json=updateTasks" json:"update_tasks,omitempty"` + // RemoveTasks is a set of previously-assigned task IDs to remove from the + // assignment set. It is not used in the first assignments message of + // a stream. + RemoveTasks []string `protobuf:"bytes,5,rep,name=remove_tasks,json=removeTasks" json:"remove_tasks,omitempty"` + // UpdateSecrets is a set of new or updated secrets for this node. + // In the first assignments message, it contains all of the secrets + // the node needs for itself and its assigned tasks. + UpdateSecrets []*Secret `protobuf:"bytes,6,rep,name=update_secrets,json=updateSecrets" json:"update_secrets,omitempty"` + // RemoveSecrets is a set of previously-assigned secret names to remove + // from memory. It is not used in the first assignments message of + // a stream. + RemoveSecrets []string `protobuf:"bytes,7,rep,name=remove_secrets,json=removeSecrets" json:"remove_secrets,omitempty"` +} + +func (m *AssignmentsMessage) Reset() { *m = AssignmentsMessage{} } +func (*AssignmentsMessage) ProtoMessage() {} +func (*AssignmentsMessage) Descriptor() ([]byte, []int) { return fileDescriptorDispatcher, []int{9} } + func init() { proto.RegisterType((*SessionRequest)(nil), "docker.swarmkit.v1.SessionRequest") proto.RegisterType((*SessionMessage)(nil), "docker.swarmkit.v1.SessionMessage") @@ -190,6 +258,9 @@ func init() { proto.RegisterType((*UpdateTaskStatusResponse)(nil), "docker.swarmkit.v1.UpdateTaskStatusResponse") proto.RegisterType((*TasksRequest)(nil), "docker.swarmkit.v1.TasksRequest") proto.RegisterType((*TasksMessage)(nil), "docker.swarmkit.v1.TasksMessage") + proto.RegisterType((*AssignmentsRequest)(nil), "docker.swarmkit.v1.AssignmentsRequest") + proto.RegisterType((*AssignmentsMessage)(nil), "docker.swarmkit.v1.AssignmentsMessage") + proto.RegisterEnum("docker.swarmkit.v1.AssignmentsMessage_AssignmentType", AssignmentsMessage_AssignmentType_name, AssignmentsMessage_AssignmentType_value) } type authenticatedWrapperDispatcherServer struct { @@ -236,6 +307,14 @@ func (p *authenticatedWrapperDispatcherServer) Tasks(r *TasksRequest, stream Dis return p.local.Tasks(r, stream) } +func (p *authenticatedWrapperDispatcherServer) Assignments(r *AssignmentsRequest, stream Dispatcher_AssignmentsServer) error { + + if err := p.authorize(stream.Context(), []string{"swarm-worker", "swarm-manager"}); err != nil { + return err + } + return p.local.Assignments(r, stream) +} + func (m *SessionRequest) Copy() *SessionRequest { if m == nil { return nil @@ -371,6 +450,60 @@ func (m *TasksMessage) Copy() *TasksMessage { return o } +func (m *AssignmentsRequest) Copy() *AssignmentsRequest { + if m == nil { + return nil + } + + o := &AssignmentsRequest{ + SessionID: m.SessionID, + } + + return o +} + +func (m *AssignmentsMessage) Copy() *AssignmentsMessage { + if m == nil { + return nil + } + + o := &AssignmentsMessage{ + Type: m.Type, + AppliesTo: m.AppliesTo, + ResultsIn: m.ResultsIn, + } + + if m.UpdateTasks != nil { + o.UpdateTasks = make([]*Task, 0, len(m.UpdateTasks)) + for _, v := range m.UpdateTasks { + o.UpdateTasks = append(o.UpdateTasks, v.Copy()) + } + } + + if m.RemoveTasks != nil { + o.RemoveTasks = make([]string, 0, len(m.RemoveTasks)) + for _, v := range m.RemoveTasks { + o.RemoveTasks = append(o.RemoveTasks, v) + } + } + + if m.UpdateSecrets != nil { + o.UpdateSecrets = make([]*Secret, 0, len(m.UpdateSecrets)) + for _, v := range m.UpdateSecrets { + o.UpdateSecrets = append(o.UpdateSecrets, v.Copy()) + } + } + + if m.RemoveSecrets != nil { + o.RemoveSecrets = make([]string, 0, len(m.RemoveSecrets)) + for _, v := range m.RemoveSecrets { + o.RemoveSecrets = append(o.RemoveSecrets, v) + } + } + + return o +} + func (this *SessionRequest) GoString() string { if this == nil { return "nil" @@ -480,6 +613,36 @@ func (this *TasksMessage) GoString() string { s = append(s, "}") return strings.Join(s, "") } +func (this *AssignmentsRequest) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&api.AssignmentsRequest{") + s = append(s, "SessionID: "+fmt.Sprintf("%#v", this.SessionID)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AssignmentsMessage) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&api.AssignmentsMessage{") + s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n") + s = append(s, "AppliesTo: "+fmt.Sprintf("%#v", this.AppliesTo)+",\n") + s = append(s, "ResultsIn: "+fmt.Sprintf("%#v", this.ResultsIn)+",\n") + if this.UpdateTasks != nil { + s = append(s, "UpdateTasks: "+fmt.Sprintf("%#v", this.UpdateTasks)+",\n") + } + s = append(s, "RemoveTasks: "+fmt.Sprintf("%#v", this.RemoveTasks)+",\n") + if this.UpdateSecrets != nil { + s = append(s, "UpdateSecrets: "+fmt.Sprintf("%#v", this.UpdateSecrets)+",\n") + } + s = append(s, "RemoveSecrets: "+fmt.Sprintf("%#v", this.RemoveSecrets)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} func valueToGoStringDispatcher(v interface{}, typ string) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -541,6 +704,11 @@ type DispatcherClient interface { // of tasks which should be run on node, if task is not present in that list, // it should be terminated. Tasks(ctx context.Context, in *TasksRequest, opts ...grpc.CallOption) (Dispatcher_TasksClient, error) + // Assignments is a stream of assignments such as tasks and secrets for node. + // The first message in the stream contains all of the tasks and secrets + // that are relevant to the node. Future messages in the stream are updates to + // the set of assignments. + Assignments(ctx context.Context, in *AssignmentsRequest, opts ...grpc.CallOption) (Dispatcher_AssignmentsClient, error) } type dispatcherClient struct { @@ -633,6 +801,38 @@ func (x *dispatcherTasksClient) Recv() (*TasksMessage, error) { return m, nil } +func (c *dispatcherClient) Assignments(ctx context.Context, in *AssignmentsRequest, opts ...grpc.CallOption) (Dispatcher_AssignmentsClient, error) { + stream, err := grpc.NewClientStream(ctx, &_Dispatcher_serviceDesc.Streams[2], c.cc, "/docker.swarmkit.v1.Dispatcher/Assignments", opts...) + if err != nil { + return nil, err + } + x := &dispatcherAssignmentsClient{stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +type Dispatcher_AssignmentsClient interface { + Recv() (*AssignmentsMessage, error) + grpc.ClientStream +} + +type dispatcherAssignmentsClient struct { + grpc.ClientStream +} + +func (x *dispatcherAssignmentsClient) Recv() (*AssignmentsMessage, error) { + m := new(AssignmentsMessage) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + // Server API for Dispatcher service type DispatcherServer interface { @@ -660,6 +860,11 @@ type DispatcherServer interface { // of tasks which should be run on node, if task is not present in that list, // it should be terminated. Tasks(*TasksRequest, Dispatcher_TasksServer) error + // Assignments is a stream of assignments such as tasks and secrets for node. + // The first message in the stream contains all of the tasks and secrets + // that are relevant to the node. Future messages in the stream are updates to + // the set of assignments. + Assignments(*AssignmentsRequest, Dispatcher_AssignmentsServer) error } func RegisterDispatcherServer(s *grpc.Server, srv DispatcherServer) { @@ -744,6 +949,27 @@ func (x *dispatcherTasksServer) Send(m *TasksMessage) error { return x.ServerStream.SendMsg(m) } +func _Dispatcher_Assignments_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(AssignmentsRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(DispatcherServer).Assignments(m, &dispatcherAssignmentsServer{stream}) +} + +type Dispatcher_AssignmentsServer interface { + Send(*AssignmentsMessage) error + grpc.ServerStream +} + +type dispatcherAssignmentsServer struct { + grpc.ServerStream +} + +func (x *dispatcherAssignmentsServer) Send(m *AssignmentsMessage) error { + return x.ServerStream.SendMsg(m) +} + var _Dispatcher_serviceDesc = grpc.ServiceDesc{ ServiceName: "docker.swarmkit.v1.Dispatcher", HandlerType: (*DispatcherServer)(nil), @@ -768,6 +994,11 @@ var _Dispatcher_serviceDesc = grpc.ServiceDesc{ Handler: _Dispatcher_Tasks_Handler, ServerStreams: true, }, + { + StreamName: "Assignments", + Handler: _Dispatcher_Assignments_Handler, + ServerStreams: true, + }, }, } @@ -1055,6 +1286,119 @@ func (m *TasksMessage) MarshalTo(data []byte) (int, error) { return i, nil } +func (m *AssignmentsRequest) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AssignmentsRequest) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.SessionID) > 0 { + data[i] = 0xa + i++ + i = encodeVarintDispatcher(data, i, uint64(len(m.SessionID))) + i += copy(data[i:], m.SessionID) + } + return i, nil +} + +func (m *AssignmentsMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AssignmentsMessage) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Type != 0 { + data[i] = 0x8 + i++ + i = encodeVarintDispatcher(data, i, uint64(m.Type)) + } + if len(m.AppliesTo) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintDispatcher(data, i, uint64(len(m.AppliesTo))) + i += copy(data[i:], m.AppliesTo) + } + if len(m.ResultsIn) > 0 { + data[i] = 0x1a + i++ + i = encodeVarintDispatcher(data, i, uint64(len(m.ResultsIn))) + i += copy(data[i:], m.ResultsIn) + } + if len(m.UpdateTasks) > 0 { + for _, msg := range m.UpdateTasks { + data[i] = 0x22 + i++ + i = encodeVarintDispatcher(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.RemoveTasks) > 0 { + for _, s := range m.RemoveTasks { + data[i] = 0x2a + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.UpdateSecrets) > 0 { + for _, msg := range m.UpdateSecrets { + data[i] = 0x32 + i++ + i = encodeVarintDispatcher(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.RemoveSecrets) > 0 { + for _, s := range m.RemoveSecrets { + data[i] = 0x3a + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + return i, nil +} + func encodeFixed64Dispatcher(data []byte, offset int, v uint64) int { data[offset] = uint8(v) data[offset+1] = uint8(v >> 8) @@ -1280,6 +1624,41 @@ func (p *raftProxyDispatcherServer) Tasks(r *TasksRequest, stream Dispatcher_Tas return nil } +func (p *raftProxyDispatcherServer) Assignments(r *AssignmentsRequest, stream Dispatcher_AssignmentsServer) error { + + ctx := stream.Context() + conn, err := p.connSelector.LeaderConn(ctx) + if err != nil { + if err == raftselector.ErrIsLeader { + return p.local.Assignments(r, stream) + } + return err + } + ctx, err = p.runCtxMods(ctx) + if err != nil { + return err + } + clientStream, err := NewDispatcherClient(conn).Assignments(ctx, r) + + if err != nil { + return err + } + + for { + msg, err := clientStream.Recv() + if err == io.EOF { + break + } + if err != nil { + return err + } + if err := stream.Send(msg); err != nil { + return err + } + } + return nil +} + func (m *SessionRequest) Size() (n int) { var l int _ = l @@ -1396,6 +1775,57 @@ func (m *TasksMessage) Size() (n int) { return n } +func (m *AssignmentsRequest) Size() (n int) { + var l int + _ = l + l = len(m.SessionID) + if l > 0 { + n += 1 + l + sovDispatcher(uint64(l)) + } + return n +} + +func (m *AssignmentsMessage) Size() (n int) { + var l int + _ = l + if m.Type != 0 { + n += 1 + sovDispatcher(uint64(m.Type)) + } + l = len(m.AppliesTo) + if l > 0 { + n += 1 + l + sovDispatcher(uint64(l)) + } + l = len(m.ResultsIn) + if l > 0 { + n += 1 + l + sovDispatcher(uint64(l)) + } + if len(m.UpdateTasks) > 0 { + for _, e := range m.UpdateTasks { + l = e.Size() + n += 1 + l + sovDispatcher(uint64(l)) + } + } + if len(m.RemoveTasks) > 0 { + for _, s := range m.RemoveTasks { + l = len(s) + n += 1 + l + sovDispatcher(uint64(l)) + } + } + if len(m.UpdateSecrets) > 0 { + for _, e := range m.UpdateSecrets { + l = e.Size() + n += 1 + l + sovDispatcher(uint64(l)) + } + } + if len(m.RemoveSecrets) > 0 { + for _, s := range m.RemoveSecrets { + l = len(s) + n += 1 + l + sovDispatcher(uint64(l)) + } + } + return n +} + func sovDispatcher(x uint64) (n int) { for { n++ @@ -1504,16 +1934,42 @@ func (this *TasksMessage) String() string { }, "") return s } -func valueToStringDispatcher(v interface{}) string { - rv := reflect.ValueOf(v) - if rv.IsNil() { +func (this *AssignmentsRequest) String() string { + if this == nil { return "nil" } - pv := reflect.Indirect(rv).Interface() - return fmt.Sprintf("*%v", pv) + s := strings.Join([]string{`&AssignmentsRequest{`, + `SessionID:` + fmt.Sprintf("%v", this.SessionID) + `,`, + `}`, + }, "") + return s } -func (m *SessionRequest) Unmarshal(data []byte) error { - l := len(data) +func (this *AssignmentsMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AssignmentsMessage{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `AppliesTo:` + fmt.Sprintf("%v", this.AppliesTo) + `,`, + `ResultsIn:` + fmt.Sprintf("%v", this.ResultsIn) + `,`, + `UpdateTasks:` + strings.Replace(fmt.Sprintf("%v", this.UpdateTasks), "Task", "Task", 1) + `,`, + `RemoveTasks:` + fmt.Sprintf("%v", this.RemoveTasks) + `,`, + `UpdateSecrets:` + strings.Replace(fmt.Sprintf("%v", this.UpdateSecrets), "Secret", "Secret", 1) + `,`, + `RemoveSecrets:` + fmt.Sprintf("%v", this.RemoveSecrets) + `,`, + `}`, + }, "") + return s +} +func valueToStringDispatcher(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *SessionRequest) Unmarshal(data []byte) error { + l := len(data) iNdEx := 0 for iNdEx < l { preIndex := iNdEx @@ -2389,6 +2845,332 @@ func (m *TasksMessage) Unmarshal(data []byte) error { } return nil } +func (m *AssignmentsRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDispatcher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AssignmentsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AssignmentsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SessionID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDispatcher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDispatcher + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SessionID = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDispatcher(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthDispatcher + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AssignmentsMessage) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDispatcher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AssignmentsMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AssignmentsMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDispatcher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Type |= (AssignmentsMessage_AssignmentType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AppliesTo", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDispatcher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDispatcher + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AppliesTo = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResultsIn", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDispatcher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDispatcher + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ResultsIn = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UpdateTasks", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDispatcher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDispatcher + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UpdateTasks = append(m.UpdateTasks, &Task{}) + if err := m.UpdateTasks[len(m.UpdateTasks)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemoveTasks", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDispatcher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDispatcher + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RemoveTasks = append(m.RemoveTasks, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UpdateSecrets", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDispatcher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthDispatcher + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UpdateSecrets = append(m.UpdateSecrets, &Secret{}) + if err := m.UpdateSecrets[len(m.UpdateSecrets)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemoveSecrets", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDispatcher + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthDispatcher + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RemoveSecrets = append(m.RemoveSecrets, string(data[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipDispatcher(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthDispatcher + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipDispatcher(data []byte) (n int, err error) { l := len(data) iNdEx := 0 @@ -2495,46 +3277,59 @@ var ( ) var fileDescriptorDispatcher = []byte{ - // 645 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x95, 0xdf, 0x6a, 0x13, 0x4f, - 0x14, 0xc7, 0x3b, 0x69, 0x9a, 0xfe, 0x72, 0xd2, 0xfe, 0x88, 0x63, 0xb1, 0xcb, 0x52, 0xb7, 0x71, - 0xab, 0x50, 0xb0, 0x6e, 0x35, 0x82, 0x17, 0x52, 0x44, 0x42, 0x0a, 0x86, 0xe2, 0x1f, 0xb6, 0x6a, - 0x2f, 0xcb, 0x24, 0x7b, 0x48, 0xd7, 0xd8, 0x9d, 0x75, 0x66, 0x62, 0xcd, 0x85, 0x20, 0x88, 0xb7, - 0x22, 0x5e, 0xf9, 0x14, 0x3e, 0x47, 0xf1, 0xca, 0x4b, 0xaf, 0x8a, 0xcd, 0x03, 0x88, 0x8f, 0x20, - 0xbb, 0x3b, 0x9b, 0xd6, 0x74, 0x53, 0x9b, 0x5e, 0x65, 0xfe, 0x7c, 0xcf, 0xf7, 0x7c, 0x38, 0xe7, - 0x4c, 0x16, 0xca, 0x9e, 0x2f, 0x43, 0xa6, 0x5a, 0x3b, 0x28, 0x9c, 0x50, 0x70, 0xc5, 0x29, 0xf5, - 0x78, 0xab, 0x83, 0xc2, 0x91, 0x7b, 0x4c, 0xec, 0x76, 0x7c, 0xe5, 0xbc, 0xbe, 0x65, 0x96, 0x54, - 0x2f, 0x44, 0x99, 0x08, 0xcc, 0x59, 0xde, 0x7c, 0x81, 0x2d, 0x95, 0x6e, 0xe7, 0xda, 0xbc, 0xcd, - 0xe3, 0xe5, 0x6a, 0xb4, 0xd2, 0xa7, 0x17, 0xc3, 0x97, 0xdd, 0xb6, 0x1f, 0xac, 0x26, 0x3f, 0xfa, - 0x70, 0xde, 0xeb, 0x0a, 0xa6, 0x7c, 0x1e, 0xac, 0xa6, 0x8b, 0xe4, 0xc2, 0xfe, 0x40, 0xe0, 0xff, - 0x4d, 0x94, 0xd2, 0xe7, 0x81, 0x8b, 0xaf, 0xba, 0x28, 0x15, 0x5d, 0x87, 0x92, 0x87, 0xb2, 0x25, - 0xfc, 0x30, 0xd2, 0x19, 0xa4, 0x42, 0x96, 0x4b, 0xd5, 0x25, 0xe7, 0x24, 0x9c, 0xf3, 0x88, 0x7b, - 0x58, 0x3f, 0x92, 0xba, 0xc7, 0xe3, 0xe8, 0x0a, 0x80, 0x4c, 0x8c, 0xb7, 0x7d, 0xcf, 0xc8, 0x55, - 0xc8, 0x72, 0xb1, 0x36, 0xdb, 0x3f, 0x58, 0x2c, 0xea, 0x74, 0x8d, 0xba, 0x5b, 0xd4, 0x82, 0x86, - 0x67, 0xbf, 0xcf, 0x0d, 0x38, 0x1e, 0xa2, 0x94, 0xac, 0x8d, 0x43, 0x06, 0xe4, 0x74, 0x03, 0xba, - 0x02, 0xf9, 0x80, 0x7b, 0x18, 0x27, 0x2a, 0x55, 0x8d, 0x51, 0xb8, 0x6e, 0xac, 0xa2, 0x6b, 0xf0, - 0xdf, 0x2e, 0x0b, 0x58, 0x1b, 0x85, 0x34, 0x26, 0x2b, 0x93, 0xcb, 0xa5, 0x6a, 0x25, 0x2b, 0x62, - 0x0b, 0xfd, 0xf6, 0x8e, 0x42, 0xef, 0x09, 0xa2, 0x70, 0x07, 0x11, 0x74, 0x0b, 0x2e, 0x05, 0xa8, - 0xf6, 0xb8, 0xe8, 0x6c, 0x37, 0x39, 0x57, 0x52, 0x09, 0x16, 0x6e, 0x77, 0xb0, 0x27, 0x8d, 0x7c, - 0xec, 0x75, 0x25, 0xcb, 0x6b, 0x3d, 0x68, 0x89, 0x5e, 0x5c, 0x9a, 0x0d, 0xec, 0xb9, 0x73, 0xda, - 0xa0, 0x96, 0xc6, 0x6f, 0x60, 0x4f, 0xda, 0xf7, 0xa1, 0xfc, 0x00, 0x99, 0x50, 0x4d, 0x64, 0x2a, - 0x6d, 0xc7, 0x58, 0x65, 0xb0, 0x1f, 0xc3, 0x85, 0x63, 0x0e, 0x32, 0xe4, 0x81, 0x44, 0x7a, 0x17, - 0x0a, 0x21, 0x0a, 0x9f, 0x7b, 0xba, 0x99, 0x0b, 0x59, 0x7c, 0x75, 0x3d, 0x18, 0xb5, 0xfc, 0xfe, - 0xc1, 0xe2, 0x84, 0xab, 0x23, 0xec, 0x4f, 0x39, 0x98, 0x7f, 0x16, 0x7a, 0x4c, 0xe1, 0x53, 0x26, - 0x3b, 0x9b, 0x8a, 0xa9, 0xae, 0x3c, 0x17, 0x1a, 0x7d, 0x0e, 0xd3, 0xdd, 0xd8, 0x28, 0x2d, 0xf9, - 0x5a, 0x16, 0xc6, 0x88, 0x5c, 0xce, 0xd1, 0x49, 0xa2, 0x70, 0x53, 0x33, 0x93, 0x43, 0x79, 0xf8, - 0x92, 0x2e, 0xc1, 0xb4, 0x62, 0xb2, 0x73, 0x84, 0x05, 0xfd, 0x83, 0xc5, 0x42, 0x24, 0x6b, 0xd4, - 0xdd, 0x42, 0x74, 0xd5, 0xf0, 0xe8, 0x1d, 0x28, 0xc8, 0x38, 0x48, 0x0f, 0x8d, 0x95, 0xc5, 0x73, - 0x8c, 0x44, 0xab, 0x6d, 0x13, 0x8c, 0x93, 0x94, 0x49, 0xa9, 0xed, 0x35, 0x98, 0x89, 0x4e, 0xcf, - 0x57, 0x22, 0xfb, 0x9e, 0x8e, 0x4e, 0x9f, 0x80, 0x03, 0x53, 0x11, 0xab, 0x34, 0x48, 0x5c, 0x30, - 0x63, 0x14, 0xa0, 0x9b, 0xc8, 0xaa, 0x1f, 0xf3, 0x00, 0xf5, 0xc1, 0xdf, 0x0a, 0x7d, 0x03, 0xd3, - 0x3a, 0x0d, 0xb5, 0xb3, 0x42, 0xff, 0x7e, 0xf8, 0xe6, 0x69, 0x1a, 0x4d, 0x64, 0x2f, 0x7d, 0xfb, - 0xfa, 0xeb, 0x4b, 0xee, 0x32, 0xcc, 0xc4, 0x9a, 0x1b, 0xd1, 0x08, 0xa3, 0x80, 0xd9, 0x64, 0xa7, - 0x1f, 0xc8, 0x4d, 0x42, 0xdf, 0x42, 0x71, 0x30, 0x86, 0xf4, 0x6a, 0x96, 0xef, 0xf0, 0x9c, 0x9b, - 0xd7, 0xfe, 0xa1, 0xd2, 0x05, 0x3e, 0x0b, 0x00, 0xfd, 0x4c, 0xa0, 0x3c, 0xdc, 0x22, 0x7a, 0x7d, - 0x8c, 0x71, 0x33, 0x57, 0xce, 0x26, 0x1e, 0x07, 0x4a, 0xc0, 0x54, 0xdc, 0x5c, 0x5a, 0x19, 0xd5, - 0xc6, 0x41, 0xf6, 0xd1, 0x8a, 0xf1, 0xfa, 0x50, 0x5b, 0xd8, 0x3f, 0xb4, 0x26, 0x7e, 0x1c, 0x5a, - 0x13, 0xbf, 0x0f, 0x2d, 0xf2, 0xae, 0x6f, 0x91, 0xfd, 0xbe, 0x45, 0xbe, 0xf7, 0x2d, 0xf2, 0xb3, - 0x6f, 0x91, 0x66, 0x21, 0xfe, 0x06, 0xdc, 0xfe, 0x13, 0x00, 0x00, 0xff, 0xff, 0xa3, 0xfc, 0x50, - 0xc8, 0x8b, 0x06, 0x00, 0x00, + // 851 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x56, 0x41, 0x6f, 0x1b, 0x45, + 0x14, 0xce, 0xc6, 0x8e, 0x53, 0xbf, 0xb5, 0x8d, 0x19, 0x2a, 0xba, 0x5a, 0xb5, 0x1b, 0x77, 0x43, + 0xab, 0x48, 0x04, 0x07, 0x8c, 0xe0, 0x00, 0x11, 0x22, 0xae, 0x2d, 0x61, 0xb5, 0x49, 0xab, 0x8d, + 0xa1, 0x47, 0x6b, 0xed, 0x7d, 0x72, 0x17, 0xc7, 0x3b, 0xcb, 0xcc, 0xb8, 0xc5, 0x07, 0x24, 0x24, + 0xe0, 0x8e, 0x90, 0x90, 0xfa, 0x2b, 0xf8, 0x1d, 0x11, 0x27, 0x8e, 0x9c, 0x22, 0xe2, 0x1f, 0x80, + 0xf8, 0x09, 0x68, 0x77, 0x66, 0x1d, 0xd7, 0x59, 0x27, 0x76, 0x4e, 0xd9, 0x79, 0xf3, 0x7d, 0xdf, + 0xfb, 0xf4, 0xde, 0xbc, 0x17, 0x43, 0xd9, 0xf3, 0x79, 0xe8, 0x8a, 0xde, 0x0b, 0x64, 0xd5, 0x90, + 0x51, 0x41, 0x09, 0xf1, 0x68, 0x6f, 0x80, 0xac, 0xca, 0x5f, 0xb9, 0x6c, 0x38, 0xf0, 0x45, 0xf5, + 0xe5, 0x47, 0xa6, 0x2e, 0xc6, 0x21, 0x72, 0x09, 0x30, 0x8b, 0xb4, 0xfb, 0x2d, 0xf6, 0x44, 0x72, + 0xbc, 0xdd, 0xa7, 0x7d, 0x1a, 0x7f, 0xee, 0x45, 0x5f, 0x2a, 0xfa, 0x4e, 0x78, 0x32, 0xea, 0xfb, + 0xc1, 0x9e, 0xfc, 0xa3, 0x82, 0x77, 0xbc, 0x11, 0x73, 0x85, 0x4f, 0x83, 0xbd, 0xe4, 0x43, 0x5e, + 0xd8, 0xbf, 0x68, 0x50, 0x3a, 0x46, 0xce, 0x7d, 0x1a, 0x38, 0xf8, 0xdd, 0x08, 0xb9, 0x20, 0x4d, + 0xd0, 0x3d, 0xe4, 0x3d, 0xe6, 0x87, 0x11, 0xce, 0xd0, 0x2a, 0xda, 0x8e, 0x5e, 0xdb, 0xae, 0x5e, + 0x36, 0x57, 0x3d, 0xa2, 0x1e, 0x36, 0x2e, 0xa0, 0xce, 0x2c, 0x8f, 0xec, 0x02, 0x70, 0x29, 0xdc, + 0xf1, 0x3d, 0x63, 0xbd, 0xa2, 0xed, 0xe4, 0xeb, 0xc5, 0xc9, 0xd9, 0x56, 0x5e, 0xa5, 0x6b, 0x35, + 0x9c, 0xbc, 0x02, 0xb4, 0x3c, 0xfb, 0xa7, 0xf5, 0xa9, 0x8f, 0x43, 0xe4, 0xdc, 0xed, 0xe3, 0x9c, + 0x80, 0x76, 0xb5, 0x00, 0xd9, 0x85, 0x6c, 0x40, 0x3d, 0x8c, 0x13, 0xe9, 0x35, 0x63, 0x91, 0x5d, + 0x27, 0x46, 0x91, 0x7d, 0xb8, 0x35, 0x74, 0x03, 0xb7, 0x8f, 0x8c, 0x1b, 0x99, 0x4a, 0x66, 0x47, + 0xaf, 0x55, 0xd2, 0x18, 0xcf, 0xd1, 0xef, 0xbf, 0x10, 0xe8, 0x3d, 0x43, 0x64, 0xce, 0x94, 0x41, + 0x9e, 0xc3, 0xbb, 0x01, 0x8a, 0x57, 0x94, 0x0d, 0x3a, 0x5d, 0x4a, 0x05, 0x17, 0xcc, 0x0d, 0x3b, + 0x03, 0x1c, 0x73, 0x23, 0x1b, 0x6b, 0xdd, 0x4f, 0xd3, 0x6a, 0x06, 0x3d, 0x36, 0x8e, 0x4b, 0xf3, + 0x18, 0xc7, 0xce, 0x6d, 0x25, 0x50, 0x4f, 0xf8, 0x8f, 0x71, 0xcc, 0xed, 0x2f, 0xa1, 0xfc, 0x15, + 0xba, 0x4c, 0x74, 0xd1, 0x15, 0x49, 0x3b, 0x56, 0x2a, 0x83, 0xfd, 0x14, 0xde, 0x9e, 0x51, 0xe0, + 0x21, 0x0d, 0x38, 0x92, 0xcf, 0x20, 0x17, 0x22, 0xf3, 0xa9, 0xa7, 0x9a, 0x79, 0x37, 0xcd, 0x5f, + 0x43, 0x3d, 0x8c, 0x7a, 0xf6, 0xf4, 0x6c, 0x6b, 0xcd, 0x51, 0x0c, 0xfb, 0xd7, 0x75, 0xb8, 0xf3, + 0x75, 0xe8, 0xb9, 0x02, 0xdb, 0x2e, 0x1f, 0x1c, 0x0b, 0x57, 0x8c, 0xf8, 0x8d, 0xac, 0x91, 0x6f, + 0x60, 0x73, 0x14, 0x0b, 0x25, 0x25, 0xdf, 0x4f, 0xb3, 0xb1, 0x20, 0x57, 0xf5, 0x22, 0x22, 0x11, + 0x4e, 0x22, 0x66, 0x52, 0x28, 0xcf, 0x5f, 0x92, 0x6d, 0xd8, 0x14, 0x2e, 0x1f, 0x5c, 0xd8, 0x82, + 0xc9, 0xd9, 0x56, 0x2e, 0x82, 0xb5, 0x1a, 0x4e, 0x2e, 0xba, 0x6a, 0x79, 0xe4, 0x53, 0xc8, 0xf1, + 0x98, 0xa4, 0x1e, 0x8d, 0x95, 0xe6, 0x67, 0xc6, 0x89, 0x42, 0xdb, 0x26, 0x18, 0x97, 0x5d, 0xca, + 0x52, 0xdb, 0xfb, 0x50, 0x88, 0xa2, 0x37, 0x2b, 0x91, 0xfd, 0x85, 0x62, 0x27, 0x23, 0x50, 0x85, + 0x8d, 0xc8, 0x2b, 0x37, 0xb4, 0xb8, 0x60, 0xc6, 0x22, 0x83, 0x8e, 0x84, 0xd9, 0x75, 0x20, 0x07, + 0x9c, 0xfb, 0xfd, 0x60, 0x88, 0x81, 0xb8, 0xa1, 0x87, 0xd7, 0x99, 0x37, 0x44, 0x12, 0x2b, 0x2d, + 0xc8, 0x46, 0xab, 0x28, 0xa6, 0x97, 0x6a, 0x9f, 0xa4, 0x39, 0xb9, 0xcc, 0x9a, 0x09, 0xb5, 0xc7, + 0x21, 0x3a, 0xb1, 0x04, 0xb9, 0x07, 0xe0, 0x86, 0xe1, 0x89, 0x8f, 0xbc, 0x23, 0xa8, 0xdc, 0x0c, + 0x4e, 0x5e, 0x45, 0xda, 0x34, 0xba, 0x66, 0xc8, 0x47, 0x27, 0x82, 0x77, 0xfc, 0xc0, 0xc8, 0xc8, + 0x6b, 0x15, 0x69, 0x05, 0xe4, 0x73, 0x28, 0xc8, 0xce, 0x77, 0x64, 0x69, 0xb2, 0xd7, 0x94, 0x46, + 0x1f, 0x4d, 0x7b, 0xc5, 0xc9, 0x7d, 0x28, 0x30, 0x1c, 0xd2, 0x97, 0x09, 0x79, 0xa3, 0x92, 0xd9, + 0xc9, 0x3b, 0xba, 0x8c, 0x49, 0xc8, 0x01, 0x94, 0x94, 0x3e, 0xc7, 0x1e, 0x43, 0xc1, 0x8d, 0x5c, + 0x9c, 0xc1, 0x4c, 0xcb, 0x70, 0x1c, 0x43, 0x9c, 0xa2, 0x64, 0xc8, 0x13, 0x27, 0x0f, 0xa0, 0xa4, + 0xb2, 0x24, 0x12, 0x9b, 0x71, 0x9e, 0xa2, 0x8c, 0x2a, 0x98, 0xbd, 0x07, 0xa5, 0x37, 0xeb, 0x43, + 0x0a, 0x70, 0xeb, 0xd1, 0xd3, 0xc3, 0x67, 0x4f, 0x9a, 0xed, 0x66, 0x79, 0x8d, 0xbc, 0x05, 0x7a, + 0xeb, 0xe8, 0x91, 0xd3, 0x3c, 0x6c, 0x1e, 0xb5, 0x0f, 0x9e, 0x94, 0xb5, 0xda, 0xef, 0x1b, 0x00, + 0x8d, 0xe9, 0x7f, 0x0d, 0xf2, 0x3d, 0x6c, 0xaa, 0x0e, 0x12, 0x3b, 0xdd, 0xdc, 0xec, 0x5e, 0x37, + 0xaf, 0xc2, 0xa8, 0x7e, 0xd9, 0xdb, 0x7f, 0xfe, 0xf1, 0xef, 0xeb, 0xf5, 0x7b, 0x50, 0x88, 0x31, + 0x1f, 0x44, 0x1b, 0x0a, 0x19, 0x14, 0xe5, 0x49, 0xed, 0xbf, 0x0f, 0x35, 0xf2, 0x03, 0xe4, 0xa7, + 0x5b, 0x86, 0xbc, 0x97, 0xa6, 0x3b, 0xbf, 0xc6, 0xcc, 0x07, 0xd7, 0xa0, 0xd4, 0xfc, 0x2c, 0x63, + 0x80, 0xfc, 0xa6, 0x41, 0x79, 0x7e, 0x02, 0xc9, 0xfb, 0x2b, 0x6c, 0x13, 0x73, 0x77, 0x39, 0xf0, + 0x2a, 0xa6, 0x18, 0x6c, 0xc8, 0x07, 0x54, 0x59, 0xf4, 0x14, 0xa7, 0xd9, 0x17, 0x23, 0x56, 0xec, + 0xc3, 0xcf, 0x1a, 0xe8, 0x33, 0x53, 0x47, 0x1e, 0x5e, 0x33, 0x96, 0x89, 0x81, 0x87, 0xcb, 0x8d, + 0xef, 0x92, 0x36, 0xea, 0x77, 0x4f, 0xcf, 0xad, 0xb5, 0xbf, 0xcf, 0xad, 0xb5, 0xff, 0xce, 0x2d, + 0xed, 0xc7, 0x89, 0xa5, 0x9d, 0x4e, 0x2c, 0xed, 0xaf, 0x89, 0xa5, 0xfd, 0x33, 0xb1, 0xb4, 0x6e, + 0x2e, 0xfe, 0xa5, 0xf1, 0xf1, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd2, 0xf0, 0x33, 0x4d, 0xf1, + 0x08, 0x00, 0x00, } diff --git a/api/dispatcher.proto b/api/dispatcher.proto index acb8c72c33..15cc66ac1d 100644 --- a/api/dispatcher.proto +++ b/api/dispatcher.proto @@ -48,12 +48,20 @@ service Dispatcher { // maybe dispatch, al likes this rpc Tasks(TasksRequest) returns (stream TasksMessage) { option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-worker" roles: "swarm-manager" }; }; + + // Assignments is a stream of assignments such as tasks and secrets for node. + // The first message in the stream contains all of the tasks and secrets + // that are relevant to the node. Future messages in the stream are updates to + // the set of assignments. + rpc Assignments(AssignmentsRequest) returns (stream AssignmentsMessage) { + option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-worker" roles: "swarm-manager" }; + }; } // SessionRequest starts a session. message SessionRequest { NodeDescription description = 1; - // SessionID can be provided to attempt resuming an exising session. If the + // SessionID can be provided to attempt resuming an exising session. If the // SessionID is empty or invalid, a new SessionID will be assigned. // // See SessionMessage.SessionID for details. @@ -115,7 +123,7 @@ message SessionMessage { repeated WeightedPeer managers = 3; // Symmetric encryption key distributed by the lead manager. Used by agents - // for securing network bootstrapping and communication. + // for securing network bootstrapping and communication. repeated EncryptionKey network_bootstrap_keys = 4; } @@ -157,3 +165,50 @@ message TasksMessage { repeated Task tasks = 1; } +message AssignmentsRequest { + string session_id = 1 [(gogoproto.customname) = "SessionID"]; +} + +message AssignmentsMessage { + // AssignmentType specifies whether this assignment message carries + // the full state, or is an update to an existing state. + enum AssignmentType { + COMPLETE = 0; + INCREMENTAL = 1; + } + + AssignmentType type = 1; + + // AppliesTo references the previous ResultsIn value, to chain + // incremental updates together. For the first update in a stream, + // AppliesTo is empty. If AppliesTo does not match the previously + // received ResultsIn, the consumer of the stream should start a new + // Assignments stream to re-sync. + string applies_to = 2; + + // ResultsIn identifies the result of this assignments message, to + // match against the next message's AppliesTo value and protect + // against missed messages. + string results_in = 3; + + // UpdateTasks is a set of new or updated tasks to run on this node. + // In the first assignments message, it contains all of the tasks + // to run on this node. Tasks outside of this set running on the node + // should be terminated. + repeated Task update_tasks = 4; + + // RemoveTasks is a set of previously-assigned task IDs to remove from the + // assignment set. It is not used in the first assignments message of + // a stream. + repeated string remove_tasks = 5; + + // UpdateSecrets is a set of new or updated secrets for this node. + // In the first assignments message, it contains all of the secrets + // the node needs for itself and its assigned tasks. + repeated Secret update_secrets = 6; + + // RemoveSecrets is a set of previously-assigned secret names to remove + // from memory. It is not used in the first assignments message of + // a stream. + repeated string remove_secrets = 7; +} diff --git a/api/objects.pb.go b/api/objects.pb.go index e2671b6b7c..afa392a322 100644 --- a/api/objects.pb.go +++ b/api/objects.pb.go @@ -230,6 +230,19 @@ func (m *Cluster) Reset() { *m = Cluster{} } func (*Cluster) ProtoMessage() {} func (*Cluster) Descriptor() ([]byte, []int) { return fileDescriptorObjects, []int{7} } +// Secret +type Secret struct { + ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Meta Meta `protobuf:"bytes,2,opt,name=meta" json:"meta"` + Spec SecretSpec `protobuf:"bytes,3,opt,name=spec" json:"spec"` + // Version is a hash of the secret. + Version string `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"` +} + +func (m *Secret) Reset() { *m = Secret{} } +func (*Secret) ProtoMessage() {} +func (*Secret) Descriptor() ([]byte, []int) { return fileDescriptorObjects, []int{8} } + func init() { proto.RegisterType((*Meta)(nil), "docker.swarmkit.v1.Meta") proto.RegisterType((*Node)(nil), "docker.swarmkit.v1.Node") @@ -240,6 +253,7 @@ func init() { proto.RegisterType((*NetworkAttachment)(nil), "docker.swarmkit.v1.NetworkAttachment") proto.RegisterType((*Network)(nil), "docker.swarmkit.v1.Network") proto.RegisterType((*Cluster)(nil), "docker.swarmkit.v1.Cluster") + proto.RegisterType((*Secret)(nil), "docker.swarmkit.v1.Secret") } func (m *Meta) Copy() *Meta { @@ -425,6 +439,21 @@ func (m *Cluster) Copy() *Cluster { return o } +func (m *Secret) Copy() *Secret { + if m == nil { + return nil + } + + o := &Secret{ + ID: m.ID, + Meta: *m.Meta.Copy(), + Spec: *m.Spec.Copy(), + Version: m.Version, + } + + return o +} + func (this *Meta) GoString() string { if this == nil { return "nil" @@ -588,6 +617,19 @@ func (this *Cluster) GoString() string { s = append(s, "}") return strings.Join(s, "") } +func (this *Secret) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&api.Secret{") + s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n") + s = append(s, "Meta: "+strings.Replace(this.Meta.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Spec: "+strings.Replace(this.Spec.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Version: "+fmt.Sprintf("%#v", this.Version)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} func valueToGoStringObjects(v interface{}, typ string) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -1188,6 +1230,52 @@ func (m *Cluster) MarshalTo(data []byte) (int, error) { return i, nil } +func (m *Secret) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Secret) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.ID) > 0 { + data[i] = 0xa + i++ + i = encodeVarintObjects(data, i, uint64(len(m.ID))) + i += copy(data[i:], m.ID) + } + data[i] = 0x12 + i++ + i = encodeVarintObjects(data, i, uint64(m.Meta.Size())) + n31, err := m.Meta.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n31 + data[i] = 0x1a + i++ + i = encodeVarintObjects(data, i, uint64(m.Spec.Size())) + n32, err := m.Spec.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n32 + if len(m.Version) > 0 { + data[i] = 0x22 + i++ + i = encodeVarintObjects(data, i, uint64(len(m.Version))) + i += copy(data[i:], m.Version) + } + return i, nil +} + func encodeFixed64Objects(data []byte, offset int, v uint64) int { data[offset] = uint8(v) data[offset+1] = uint8(v >> 8) @@ -1437,6 +1525,24 @@ func (m *Cluster) Size() (n int) { return n } +func (m *Secret) Size() (n int) { + var l int + _ = l + l = len(m.ID) + if l > 0 { + n += 1 + l + sovObjects(uint64(l)) + } + l = m.Meta.Size() + n += 1 + l + sovObjects(uint64(l)) + l = m.Spec.Size() + n += 1 + l + sovObjects(uint64(l)) + l = len(m.Version) + if l > 0 { + n += 1 + l + sovObjects(uint64(l)) + } + return n +} + func sovObjects(x uint64) (n int) { for { n++ @@ -1579,6 +1685,19 @@ func (this *Cluster) String() string { }, "") return s } +func (this *Secret) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Secret{`, + `ID:` + fmt.Sprintf("%v", this.ID) + `,`, + `Meta:` + strings.Replace(strings.Replace(this.Meta.String(), "Meta", "Meta", 1), `&`, ``, 1) + `,`, + `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "SecretSpec", "SecretSpec", 1), `&`, ``, 1) + `,`, + `Version:` + fmt.Sprintf("%v", this.Version) + `,`, + `}`, + }, "") + return s +} func valueToStringObjects(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -3476,6 +3595,174 @@ func (m *Cluster) Unmarshal(data []byte) error { } return nil } +func (m *Secret) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObjects + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Secret: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Secret: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObjects + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthObjects + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ID = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Meta", 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 err := m.Meta.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", 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 err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowObjects + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthObjects + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipObjects(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthObjects + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipObjects(data []byte) (n int, err error) { l := len(data) iNdEx := 0 @@ -3582,69 +3869,71 @@ var ( ) var fileDescriptorObjects = []byte{ - // 1009 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x56, 0xcf, 0x6e, 0x1b, 0x45, - 0x1c, 0xce, 0xda, 0x1b, 0xdb, 0xfb, 0x73, 0x1c, 0x89, 0xa1, 0xaa, 0xb6, 0x21, 0xd8, 0xc1, 0x15, - 0xa8, 0x87, 0xca, 0x15, 0xa5, 0x20, 0x2a, 0x5a, 0x21, 0xff, 0x13, 0x58, 0x25, 0x10, 0x4d, 0x4b, - 0x7a, 0x5c, 0x4d, 0x76, 0xa7, 0x66, 0xb1, 0xbd, 0xb3, 0x9a, 0x19, 0xbb, 0xf2, 0x0d, 0xf1, 0x00, - 0x48, 0xbc, 0x00, 0xaf, 0xc2, 0x35, 0x07, 0x0e, 0x1c, 0x39, 0x59, 0xc4, 0x37, 0x4e, 0xf0, 0x08, - 0x68, 0x66, 0x67, 0xed, 0x8d, 0xbc, 0x0e, 0x8d, 0x84, 0x72, 0x9b, 0xd9, 0xf9, 0xbe, 0x6f, 0x7e, - 0xff, 0x67, 0xa1, 0xc6, 0xce, 0xbe, 0xa7, 0xbe, 0x14, 0xad, 0x98, 0x33, 0xc9, 0x10, 0x0a, 0x98, - 0x3f, 0xa2, 0xbc, 0x25, 0x5e, 0x13, 0x3e, 0x19, 0x85, 0xb2, 0x35, 0xfb, 0xf0, 0xa0, 0x2a, 0xe7, - 0x31, 0x35, 0x80, 0x83, 0xaa, 0x88, 0xa9, 0x9f, 0x6e, 0xee, 0xc8, 0x70, 0x42, 0x85, 0x24, 0x93, - 0xf8, 0xc1, 0x6a, 0x65, 0x8e, 0x6e, 0x0d, 0xd9, 0x90, 0xe9, 0xe5, 0x03, 0xb5, 0x4a, 0xbe, 0x36, - 0x7f, 0xb5, 0xc0, 0x3e, 0xa6, 0x92, 0xa0, 0xcf, 0xa0, 0x3c, 0xa3, 0x5c, 0x84, 0x2c, 0x72, 0xad, - 0x23, 0xeb, 0x5e, 0xf5, 0xe1, 0x3b, 0xad, 0xcd, 0x9b, 0x5b, 0xa7, 0x09, 0xa4, 0x63, 0x9f, 0x2f, - 0x1a, 0x3b, 0x38, 0x65, 0xa0, 0x27, 0x00, 0x3e, 0xa7, 0x44, 0xd2, 0xc0, 0x23, 0xd2, 0x2d, 0x68, - 0xfe, 0xbb, 0x79, 0xfc, 0x17, 0xa9, 0x51, 0xd8, 0x31, 0x84, 0xb6, 0x54, 0xec, 0x69, 0x1c, 0xa4, - 0xec, 0xe2, 0x1b, 0xb1, 0x0d, 0xa1, 0x2d, 0x9b, 0x7f, 0x15, 0xc1, 0xfe, 0x9a, 0x05, 0x14, 0xdd, - 0x86, 0x42, 0x18, 0x68, 0xe3, 0x9d, 0x4e, 0x69, 0xb9, 0x68, 0x14, 0x06, 0x3d, 0x5c, 0x08, 0x03, - 0xf4, 0x10, 0xec, 0x09, 0x95, 0xc4, 0x98, 0xe5, 0xe6, 0x09, 0xab, 0x08, 0x18, 0x9f, 0x34, 0x16, - 0x7d, 0x02, 0xb6, 0x0a, 0xab, 0x31, 0xe6, 0x30, 0x8f, 0xa3, 0xee, 0x7c, 0x1e, 0x53, 0x3f, 0xe5, - 0x29, 0x3c, 0xea, 0x43, 0x35, 0xa0, 0xc2, 0xe7, 0x61, 0x2c, 0x55, 0x24, 0x6d, 0x4d, 0xbf, 0xbb, - 0x8d, 0xde, 0x5b, 0x43, 0x71, 0x96, 0x87, 0x9e, 0x40, 0x49, 0x48, 0x22, 0xa7, 0xc2, 0xdd, 0xd5, - 0x0a, 0xf5, 0xad, 0x06, 0x68, 0x94, 0x31, 0xc1, 0x70, 0xd0, 0x97, 0xb0, 0x3f, 0x21, 0x11, 0x19, - 0x52, 0xee, 0x19, 0x95, 0x92, 0x56, 0x79, 0x2f, 0xd7, 0xf5, 0x04, 0x99, 0x08, 0xe1, 0xda, 0x24, - 0xbb, 0x45, 0x7d, 0x00, 0x22, 0x25, 0xf1, 0xbf, 0x9b, 0xd0, 0x48, 0xba, 0x65, 0xad, 0xf2, 0x7e, - 0xae, 0x2d, 0x54, 0xbe, 0x66, 0x7c, 0xd4, 0x5e, 0x81, 0x71, 0x86, 0x88, 0xbe, 0x80, 0xaa, 0x4f, - 0xb9, 0x0c, 0x5f, 0x85, 0x3e, 0x91, 0xd4, 0xad, 0x68, 0x9d, 0x46, 0x9e, 0x4e, 0x77, 0x0d, 0x33, - 0x4e, 0x65, 0x99, 0xcd, 0x9f, 0x0b, 0x50, 0x7e, 0x4e, 0xf9, 0x2c, 0xf4, 0xff, 0xdf, 0x74, 0x3f, - 0xbe, 0x94, 0xee, 0x5c, 0xcb, 0xcc, 0xb5, 0x1b, 0x19, 0xff, 0x14, 0x2a, 0x34, 0x0a, 0x62, 0x16, - 0x46, 0xd2, 0xa4, 0x3b, 0xb7, 0x5a, 0xfa, 0x06, 0x83, 0x57, 0x68, 0xd4, 0x87, 0x5a, 0x52, 0xc5, - 0xde, 0xa5, 0x5c, 0x1f, 0xe5, 0xd1, 0xbf, 0xd5, 0x40, 0x93, 0xa4, 0xbd, 0x69, 0x66, 0xd7, 0xfc, - 0xa5, 0x00, 0x95, 0x54, 0x1d, 0x3d, 0x32, 0x8e, 0x58, 0xdb, 0xa5, 0x52, 0xac, 0xf2, 0xc4, 0xf8, - 0xf0, 0x08, 0x76, 0x63, 0xc6, 0xa5, 0x70, 0x0b, 0x47, 0xc5, 0x6d, 0xd5, 0x76, 0xc2, 0xb8, 0xec, - 0xb2, 0xe8, 0x55, 0x38, 0xc4, 0x09, 0x18, 0xbd, 0x84, 0xea, 0x2c, 0xe4, 0x72, 0x4a, 0xc6, 0x5e, - 0x18, 0x0b, 0xb7, 0xa8, 0xb9, 0x1f, 0x5c, 0x75, 0x65, 0xeb, 0x34, 0xc1, 0x0f, 0x4e, 0x3a, 0xfb, - 0xcb, 0x45, 0x03, 0x56, 0x5b, 0x81, 0xc1, 0x48, 0x0d, 0x62, 0x71, 0x70, 0x0c, 0xce, 0xea, 0x04, - 0xdd, 0x07, 0x88, 0x92, 0xe2, 0xf2, 0x56, 0xe9, 0xae, 0x2d, 0x17, 0x0d, 0xc7, 0x94, 0xdc, 0xa0, - 0x87, 0x1d, 0x03, 0x18, 0x04, 0x08, 0x81, 0x4d, 0x82, 0x80, 0xeb, 0xe4, 0x3b, 0x58, 0xaf, 0x9b, - 0xbf, 0xed, 0x82, 0xfd, 0x82, 0x88, 0xd1, 0x4d, 0x0f, 0x08, 0x75, 0xe7, 0x46, 0xb9, 0xdc, 0x07, - 0x10, 0x49, 0x25, 0x29, 0x77, 0xec, 0xb5, 0x3b, 0xa6, 0xbe, 0x94, 0x3b, 0x06, 0x90, 0xb8, 0x23, - 0xc6, 0x4c, 0xea, 0xca, 0xb0, 0xb1, 0x5e, 0xa3, 0xbb, 0x50, 0x8e, 0x58, 0xa0, 0xe9, 0x25, 0x4d, - 0x87, 0xe5, 0xa2, 0x51, 0x52, 0xc3, 0x60, 0xd0, 0xc3, 0x25, 0x75, 0x34, 0x08, 0x54, 0xc7, 0x91, - 0x28, 0x62, 0x92, 0xa8, 0x71, 0x22, 0x4c, 0xe7, 0xe6, 0xd6, 0x75, 0x7b, 0x0d, 0x4b, 0x3b, 0x2e, - 0xc3, 0x44, 0xa7, 0xf0, 0x76, 0x6a, 0x6f, 0x56, 0xb0, 0x72, 0x1d, 0x41, 0x64, 0x14, 0x32, 0x27, - 0x99, 0x09, 0xe7, 0x6c, 0x9f, 0x70, 0x3a, 0x82, 0x79, 0x13, 0xae, 0x03, 0xb5, 0x80, 0x8a, 0x90, - 0xd3, 0x40, 0xf7, 0x0e, 0x75, 0xe1, 0xc8, 0xba, 0xb7, 0xbf, 0xe5, 0xd1, 0x30, 0x22, 0x14, 0xef, - 0x19, 0x8e, 0xde, 0xa1, 0x36, 0x54, 0x4c, 0xdd, 0x08, 0xb7, 0xaa, 0x6b, 0xf7, 0x0d, 0x27, 0xdb, - 0x8a, 0x76, 0xa9, 0xf7, 0xf7, 0xae, 0xd5, 0xfb, 0x8f, 0x01, 0xc6, 0x6c, 0xe8, 0x05, 0x3c, 0x9c, - 0x51, 0xee, 0xd6, 0x34, 0xf7, 0x20, 0x8f, 0xdb, 0xd3, 0x08, 0xec, 0x8c, 0xd9, 0x30, 0x59, 0x36, - 0x7f, 0xb4, 0xe0, 0xad, 0x0d, 0xa3, 0xd0, 0xc7, 0x50, 0x36, 0x66, 0x5d, 0xf5, 0x7c, 0x1b, 0x1e, - 0x4e, 0xb1, 0xe8, 0x10, 0x1c, 0xd5, 0x23, 0x54, 0x08, 0x9a, 0x74, 0xbf, 0x83, 0xd7, 0x1f, 0x90, - 0x0b, 0x65, 0x32, 0x0e, 0x89, 0x3a, 0x2b, 0xea, 0xb3, 0x74, 0xdb, 0xfc, 0xa9, 0x00, 0x65, 0x23, - 0x76, 0xd3, 0x83, 0xd8, 0x5c, 0xbb, 0xd1, 0x59, 0x4f, 0x61, 0x2f, 0x09, 0xa7, 0x29, 0x09, 0xfb, - 0x3f, 0x83, 0x5a, 0x4d, 0xf0, 0x49, 0x39, 0x3c, 0x05, 0x3b, 0x8c, 0xc9, 0xc4, 0x0c, 0xe1, 0xdc, - 0x9b, 0x07, 0x27, 0xed, 0xe3, 0x6f, 0xe2, 0xa4, 0xb2, 0x2b, 0xcb, 0x45, 0xc3, 0x56, 0x1f, 0xb0, - 0xa6, 0x35, 0xff, 0x2e, 0x40, 0xb9, 0x3b, 0x9e, 0x0a, 0x49, 0xf9, 0x4d, 0x07, 0xc4, 0x5c, 0xbb, - 0x11, 0x90, 0x2e, 0x94, 0x39, 0x63, 0xd2, 0xf3, 0xc9, 0x55, 0xb1, 0xc0, 0x8c, 0xc9, 0x6e, 0xbb, - 0xb3, 0xaf, 0x88, 0x6a, 0x90, 0x24, 0x7b, 0x5c, 0x52, 0xd4, 0x2e, 0x41, 0x2f, 0xe1, 0x76, 0x3a, - 0x7e, 0xcf, 0x18, 0x93, 0x42, 0x72, 0x12, 0x7b, 0x23, 0x3a, 0x57, 0xaf, 0x55, 0x71, 0xdb, 0x3f, - 0x45, 0x3f, 0xf2, 0xf9, 0x5c, 0x07, 0xea, 0x19, 0x9d, 0xe3, 0x5b, 0x46, 0xa0, 0x93, 0xf2, 0x9f, - 0xd1, 0xb9, 0x40, 0x9f, 0xc3, 0x21, 0x5d, 0xc1, 0x94, 0xa2, 0x37, 0x26, 0x13, 0xf5, 0xb0, 0x78, - 0xfe, 0x98, 0xf9, 0x23, 0x3d, 0xdb, 0x6c, 0x7c, 0x87, 0x66, 0xa5, 0xbe, 0x4a, 0x10, 0x5d, 0x05, - 0xe8, 0x1c, 0x9e, 0x5f, 0xd4, 0x77, 0xfe, 0xb8, 0xa8, 0xef, 0xfc, 0x73, 0x51, 0xb7, 0x7e, 0x58, - 0xd6, 0xad, 0xf3, 0x65, 0xdd, 0xfa, 0x7d, 0x59, 0xb7, 0xfe, 0x5c, 0xd6, 0xad, 0xb3, 0x92, 0xfe, - 0xbd, 0xfd, 0xe8, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x56, 0x49, 0xe6, 0x55, 0x4e, 0x0b, 0x00, - 0x00, + // 1045 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x56, 0x4f, 0x6f, 0x1b, 0x45, + 0x14, 0xcf, 0xda, 0x1b, 0xdb, 0xfb, 0x1c, 0x47, 0x62, 0xa8, 0xaa, 0x6d, 0x08, 0x76, 0x70, 0x05, + 0xea, 0xa1, 0x72, 0x45, 0x29, 0xa8, 0x15, 0xad, 0x90, 0xed, 0x58, 0x60, 0x95, 0x40, 0x34, 0x29, + 0xe9, 0x71, 0x35, 0xd9, 0x9d, 0x9a, 0xc5, 0xf6, 0xce, 0x6a, 0x66, 0xec, 0xca, 0x37, 0xc4, 0x07, + 0x40, 0xe2, 0x0b, 0x70, 0xe6, 0x5b, 0x70, 0xcd, 0x81, 0x03, 0x47, 0x4e, 0x16, 0xf1, 0x8d, 0x13, + 0x7c, 0x04, 0x34, 0xb3, 0xb3, 0xf6, 0x46, 0x5e, 0xa7, 0xad, 0x54, 0xe5, 0x36, 0xb3, 0xf3, 0xfb, + 0xfd, 0xde, 0x9f, 0x79, 0xef, 0xed, 0x40, 0x8d, 0x9d, 0xfd, 0x40, 0x7d, 0x29, 0x5a, 0x31, 0x67, + 0x92, 0x21, 0x14, 0x30, 0x7f, 0x48, 0x79, 0x4b, 0xbc, 0x24, 0x7c, 0x3c, 0x0c, 0x65, 0x6b, 0xfa, + 0xf1, 0x5e, 0x55, 0xce, 0x62, 0x6a, 0x00, 0x7b, 0x55, 0x11, 0x53, 0x3f, 0xdd, 0xdc, 0x92, 0xe1, + 0x98, 0x0a, 0x49, 0xc6, 0xf1, 0xbd, 0xe5, 0xca, 0x1c, 0xdd, 0x18, 0xb0, 0x01, 0xd3, 0xcb, 0x7b, + 0x6a, 0x95, 0x7c, 0x6d, 0xfe, 0x6e, 0x81, 0x7d, 0x44, 0x25, 0x41, 0x9f, 0x43, 0x79, 0x4a, 0xb9, + 0x08, 0x59, 0xe4, 0x5a, 0x07, 0xd6, 0x9d, 0xea, 0xfd, 0xf7, 0x5a, 0xeb, 0x96, 0x5b, 0xa7, 0x09, + 0xa4, 0x63, 0x9f, 0xcf, 0x1b, 0x5b, 0x38, 0x65, 0xa0, 0xc7, 0x00, 0x3e, 0xa7, 0x44, 0xd2, 0xc0, + 0x23, 0xd2, 0x2d, 0x68, 0xfe, 0xfb, 0x79, 0xfc, 0x67, 0xa9, 0x53, 0xd8, 0x31, 0x84, 0xb6, 0x54, + 0xec, 0x49, 0x1c, 0xa4, 0xec, 0xe2, 0x6b, 0xb1, 0x0d, 0xa1, 0x2d, 0x9b, 0xff, 0x14, 0xc1, 0xfe, + 0x86, 0x05, 0x14, 0xdd, 0x84, 0x42, 0x18, 0x68, 0xe7, 0x9d, 0x4e, 0x69, 0x31, 0x6f, 0x14, 0xfa, + 0x87, 0xb8, 0x10, 0x06, 0xe8, 0x3e, 0xd8, 0x63, 0x2a, 0x89, 0x71, 0xcb, 0xcd, 0x13, 0x56, 0x19, + 0x30, 0x31, 0x69, 0x2c, 0xfa, 0x0c, 0x6c, 0x95, 0x56, 0xe3, 0xcc, 0x7e, 0x1e, 0x47, 0xd9, 0x3c, + 0x89, 0xa9, 0x9f, 0xf2, 0x14, 0x1e, 0xf5, 0xa0, 0x1a, 0x50, 0xe1, 0xf3, 0x30, 0x96, 0x2a, 0x93, + 0xb6, 0xa6, 0xdf, 0xde, 0x44, 0x3f, 0x5c, 0x41, 0x71, 0x96, 0x87, 0x1e, 0x43, 0x49, 0x48, 0x22, + 0x27, 0xc2, 0xdd, 0xd6, 0x0a, 0xf5, 0x8d, 0x0e, 0x68, 0x94, 0x71, 0xc1, 0x70, 0xd0, 0x57, 0xb0, + 0x3b, 0x26, 0x11, 0x19, 0x50, 0xee, 0x19, 0x95, 0x92, 0x56, 0xf9, 0x20, 0x37, 0xf4, 0x04, 0x99, + 0x08, 0xe1, 0xda, 0x38, 0xbb, 0x45, 0x3d, 0x00, 0x22, 0x25, 0xf1, 0xbf, 0x1f, 0xd3, 0x48, 0xba, + 0x65, 0xad, 0xf2, 0x61, 0xae, 0x2f, 0x54, 0xbe, 0x64, 0x7c, 0xd8, 0x5e, 0x82, 0x71, 0x86, 0x88, + 0xbe, 0x84, 0xaa, 0x4f, 0xb9, 0x0c, 0x5f, 0x84, 0x3e, 0x91, 0xd4, 0xad, 0x68, 0x9d, 0x46, 0x9e, + 0x4e, 0x77, 0x05, 0x33, 0x41, 0x65, 0x99, 0xcd, 0x5f, 0x0a, 0x50, 0x3e, 0xa1, 0x7c, 0x1a, 0xfa, + 0x6f, 0xf7, 0xba, 0x1f, 0x5d, 0xba, 0xee, 0x5c, 0xcf, 0x8c, 0xd9, 0xb5, 0x1b, 0x7f, 0x08, 0x15, + 0x1a, 0x05, 0x31, 0x0b, 0x23, 0x69, 0xae, 0x3b, 0xb7, 0x5a, 0x7a, 0x06, 0x83, 0x97, 0x68, 0xd4, + 0x83, 0x5a, 0x52, 0xc5, 0xde, 0xa5, 0xbb, 0x3e, 0xc8, 0xa3, 0x7f, 0xa7, 0x81, 0xe6, 0x92, 0x76, + 0x26, 0x99, 0x5d, 0xf3, 0xd7, 0x02, 0x54, 0x52, 0x75, 0xf4, 0xc0, 0x04, 0x62, 0x6d, 0x96, 0x4a, + 0xb1, 0x2a, 0x12, 0x13, 0xc3, 0x03, 0xd8, 0x8e, 0x19, 0x97, 0xc2, 0x2d, 0x1c, 0x14, 0x37, 0x55, + 0xdb, 0x31, 0xe3, 0xb2, 0xcb, 0xa2, 0x17, 0xe1, 0x00, 0x27, 0x60, 0xf4, 0x1c, 0xaa, 0xd3, 0x90, + 0xcb, 0x09, 0x19, 0x79, 0x61, 0x2c, 0xdc, 0xa2, 0xe6, 0x7e, 0x74, 0x95, 0xc9, 0xd6, 0x69, 0x82, + 0xef, 0x1f, 0x77, 0x76, 0x17, 0xf3, 0x06, 0x2c, 0xb7, 0x02, 0x83, 0x91, 0xea, 0xc7, 0x62, 0xef, + 0x08, 0x9c, 0xe5, 0x09, 0xba, 0x0b, 0x10, 0x25, 0xc5, 0xe5, 0x2d, 0xaf, 0xbb, 0xb6, 0x98, 0x37, + 0x1c, 0x53, 0x72, 0xfd, 0x43, 0xec, 0x18, 0x40, 0x3f, 0x40, 0x08, 0x6c, 0x12, 0x04, 0x5c, 0x5f, + 0xbe, 0x83, 0xf5, 0xba, 0xf9, 0xc7, 0x36, 0xd8, 0xcf, 0x88, 0x18, 0x5e, 0xf7, 0x80, 0x50, 0x36, + 0xd7, 0xca, 0xe5, 0x2e, 0x80, 0x48, 0x2a, 0x49, 0x85, 0x63, 0xaf, 0xc2, 0x31, 0xf5, 0xa5, 0xc2, + 0x31, 0x80, 0x24, 0x1c, 0x31, 0x62, 0x52, 0x57, 0x86, 0x8d, 0xf5, 0x1a, 0xdd, 0x86, 0x72, 0xc4, + 0x02, 0x4d, 0x2f, 0x69, 0x3a, 0x2c, 0xe6, 0x8d, 0x92, 0x1a, 0x06, 0xfd, 0x43, 0x5c, 0x52, 0x47, + 0xfd, 0x40, 0x75, 0x1c, 0x89, 0x22, 0x26, 0x89, 0x1a, 0x27, 0xc2, 0x74, 0x6e, 0x6e, 0x5d, 0xb7, + 0x57, 0xb0, 0xb4, 0xe3, 0x32, 0x4c, 0x74, 0x0a, 0xef, 0xa6, 0xfe, 0x66, 0x05, 0x2b, 0x6f, 0x22, + 0x88, 0x8c, 0x42, 0xe6, 0x24, 0x33, 0xe1, 0x9c, 0xcd, 0x13, 0x4e, 0x67, 0x30, 0x6f, 0xc2, 0x75, + 0xa0, 0x16, 0x50, 0x11, 0x72, 0x1a, 0xe8, 0xde, 0xa1, 0x2e, 0x1c, 0x58, 0x77, 0x76, 0x37, 0xfc, + 0x34, 0x8c, 0x08, 0xc5, 0x3b, 0x86, 0xa3, 0x77, 0xa8, 0x0d, 0x15, 0x53, 0x37, 0xc2, 0xad, 0xea, + 0xda, 0x7d, 0xcd, 0xc9, 0xb6, 0xa4, 0x5d, 0xea, 0xfd, 0x9d, 0x37, 0xea, 0xfd, 0x47, 0x00, 0x23, + 0x36, 0xf0, 0x02, 0x1e, 0x4e, 0x29, 0x77, 0x6b, 0x9a, 0xbb, 0x97, 0xc7, 0x3d, 0xd4, 0x08, 0xec, + 0x8c, 0xd8, 0x20, 0x59, 0x36, 0x7f, 0xb2, 0xe0, 0x9d, 0x35, 0xa7, 0xd0, 0xa7, 0x50, 0x36, 0x6e, + 0x5d, 0xf5, 0xfb, 0x36, 0x3c, 0x9c, 0x62, 0xd1, 0x3e, 0x38, 0xaa, 0x47, 0xa8, 0x10, 0x34, 0xe9, + 0x7e, 0x07, 0xaf, 0x3e, 0x20, 0x17, 0xca, 0x64, 0x14, 0x12, 0x75, 0x56, 0xd4, 0x67, 0xe9, 0xb6, + 0xf9, 0x73, 0x01, 0xca, 0x46, 0xec, 0xba, 0x07, 0xb1, 0x31, 0xbb, 0xd6, 0x59, 0x4f, 0x60, 0x27, + 0x49, 0xa7, 0x29, 0x09, 0xfb, 0x95, 0x49, 0xad, 0x26, 0xf8, 0xa4, 0x1c, 0x9e, 0x80, 0x1d, 0xc6, + 0x64, 0x6c, 0x86, 0x70, 0xae, 0xe5, 0xfe, 0x71, 0xfb, 0xe8, 0xdb, 0x38, 0xa9, 0xec, 0xca, 0x62, + 0xde, 0xb0, 0xd5, 0x07, 0xac, 0x69, 0xcd, 0x7f, 0x0b, 0x50, 0xee, 0x8e, 0x26, 0x42, 0x52, 0x7e, + 0xdd, 0x09, 0x31, 0x66, 0xd7, 0x12, 0xd2, 0x85, 0x32, 0x67, 0x4c, 0x7a, 0x3e, 0xb9, 0x2a, 0x17, + 0x98, 0x31, 0xd9, 0x6d, 0x77, 0x76, 0x15, 0x51, 0x0d, 0x92, 0x64, 0x8f, 0x4b, 0x8a, 0xda, 0x25, + 0xe8, 0x39, 0xdc, 0x4c, 0xc7, 0xef, 0x19, 0x63, 0x52, 0x48, 0x4e, 0x62, 0x6f, 0x48, 0x67, 0xea, + 0x6f, 0x55, 0xdc, 0xf4, 0xa6, 0xe8, 0x45, 0x3e, 0x9f, 0xe9, 0x44, 0x3d, 0xa5, 0x33, 0x7c, 0xc3, + 0x08, 0x74, 0x52, 0xfe, 0x53, 0x3a, 0x13, 0xe8, 0x0b, 0xd8, 0xa7, 0x4b, 0x98, 0x52, 0xf4, 0x46, + 0x64, 0xac, 0x7e, 0x2c, 0x9e, 0x3f, 0x62, 0xfe, 0x50, 0xcf, 0x36, 0x1b, 0xdf, 0xa2, 0x59, 0xa9, + 0xaf, 0x13, 0x44, 0x57, 0x01, 0x9a, 0xbf, 0x59, 0x50, 0x3a, 0xa1, 0x3e, 0xa7, 0xf2, 0xad, 0x26, + 0xfc, 0xe1, 0xa5, 0x84, 0xd7, 0xf3, 0x9f, 0x02, 0xca, 0xea, 0x5a, 0xbe, 0xdd, 0xd5, 0x0b, 0x5a, + 0xcf, 0xf5, 0xe5, 0xf3, 0xb8, 0xb3, 0x7f, 0x7e, 0x51, 0xdf, 0xfa, 0xeb, 0xa2, 0xbe, 0xf5, 0xdf, + 0x45, 0xdd, 0xfa, 0x71, 0x51, 0xb7, 0xce, 0x17, 0x75, 0xeb, 0xcf, 0x45, 0xdd, 0xfa, 0x7b, 0x51, + 0xb7, 0xce, 0x4a, 0xfa, 0x25, 0xfe, 0xc9, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x23, 0x63, 0x5e, + 0xc5, 0xf9, 0x0b, 0x00, 0x00, } diff --git a/api/objects.proto b/api/objects.proto index b28fa935b5..3e7c2162d1 100644 --- a/api/objects.proto +++ b/api/objects.proto @@ -222,3 +222,15 @@ message Cluster { // a new key is allocated on key rotation. uint64 encryption_key_lamport_clock = 6; } + +// Secret +message Secret { + string id = 1 [(gogoproto.customname) = "ID"]; + + Meta meta = 2 [(gogoproto.nullable) = false]; + + SecretSpec spec = 3 [(gogoproto.nullable) = false]; + + // Version is a hash of the secret. + string version = 4; +} diff --git a/api/raft.pb.go b/api/raft.pb.go index 1cb2e3173f..3cee821a74 100644 --- a/api/raft.pb.go +++ b/api/raft.pb.go @@ -163,7 +163,7 @@ func (m *InternalRaftRequest) Reset() { *m = InternalRaftRequ func (*InternalRaftRequest) ProtoMessage() {} func (*InternalRaftRequest) Descriptor() ([]byte, []int) { return fileDescriptorRaft, []int{9} } -// StoreAction defines a taret and operation to apply on the storage system. +// StoreAction defines a target and operation to apply on the storage system. type StoreAction struct { Action StoreActionKind `protobuf:"varint,1,opt,name=action,proto3,enum=docker.swarmkit.v1.StoreActionKind" json:"action,omitempty"` // Types that are valid to be assigned to Target: @@ -172,6 +172,7 @@ type StoreAction struct { // *StoreAction_Task // *StoreAction_Network // *StoreAction_Cluster + // *StoreAction_Secret Target isStoreAction_Target `protobuf_oneof:"target"` } @@ -200,12 +201,16 @@ type StoreAction_Network struct { type StoreAction_Cluster struct { Cluster *Cluster `protobuf:"bytes,6,opt,name=cluster,oneof"` } +type StoreAction_Secret struct { + Secret *Secret `protobuf:"bytes,7,opt,name=secret,oneof"` +} func (*StoreAction_Node) isStoreAction_Target() {} func (*StoreAction_Service) isStoreAction_Target() {} func (*StoreAction_Task) isStoreAction_Target() {} func (*StoreAction_Network) isStoreAction_Target() {} func (*StoreAction_Cluster) isStoreAction_Target() {} +func (*StoreAction_Secret) isStoreAction_Target() {} func (m *StoreAction) GetTarget() isStoreAction_Target { if m != nil { @@ -249,6 +254,13 @@ func (m *StoreAction) GetCluster() *Cluster { return nil } +func (m *StoreAction) GetSecret() *Secret { + if x, ok := m.GetTarget().(*StoreAction_Secret); ok { + return x.Secret + } + return nil +} + // XXX_OneofFuncs is for the internal use of the proto package. func (*StoreAction) 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 _StoreAction_OneofMarshaler, _StoreAction_OneofUnmarshaler, _StoreAction_OneofSizer, []interface{}{ @@ -257,6 +269,7 @@ func (*StoreAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) e (*StoreAction_Task)(nil), (*StoreAction_Network)(nil), (*StoreAction_Cluster)(nil), + (*StoreAction_Secret)(nil), } } @@ -289,6 +302,11 @@ func _StoreAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { if err := b.EncodeMessage(x.Cluster); err != nil { return err } + case *StoreAction_Secret: + _ = b.EncodeVarint(7<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Secret); err != nil { + return err + } case nil: default: return fmt.Errorf("StoreAction.Target has unexpected type %T", x) @@ -339,6 +357,14 @@ func _StoreAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Bu err := b.DecodeMessage(msg) m.Target = &StoreAction_Cluster{msg} return true, err + case 7: // target.secret + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Secret) + err := b.DecodeMessage(msg) + m.Target = &StoreAction_Secret{msg} + return true, err default: return false, nil } @@ -373,6 +399,11 @@ func _StoreAction_OneofSizer(msg proto.Message) (n int) { n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s + case *StoreAction_Secret: + s := proto.Size(x.Secret) + n += proto.SizeVarint(7<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) @@ -618,6 +649,12 @@ func (m *StoreAction) Copy() *StoreAction { Cluster: m.GetCluster().Copy(), } + o.Target = i + case *StoreAction_Secret: + i := &StoreAction_Secret{ + Secret: m.GetSecret().Copy(), + } + o.Target = i } @@ -740,7 +777,7 @@ func (this *StoreAction) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 10) + s := make([]string, 0, 11) s = append(s, "&api.StoreAction{") s = append(s, "Action: "+fmt.Sprintf("%#v", this.Action)+",\n") if this.Target != nil { @@ -789,6 +826,14 @@ func (this *StoreAction_Cluster) GoString() string { `Cluster:` + fmt.Sprintf("%#v", this.Cluster) + `}`}, ", ") return s } +func (this *StoreAction_Secret) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&api.StoreAction_Secret{` + + `Secret:` + fmt.Sprintf("%#v", this.Secret) + `}`}, ", ") + return s +} func valueToGoStringRaft(v interface{}, typ string) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -1408,6 +1453,20 @@ func (m *StoreAction_Cluster) MarshalTo(data []byte) (int, error) { } return i, nil } +func (m *StoreAction_Secret) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Secret != nil { + data[i] = 0x3a + i++ + i = encodeVarintRaft(data, i, uint64(m.Secret.Size())) + n10, err := m.Secret.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n10 + } + return i, nil +} func encodeFixed64Raft(data []byte, offset int, v uint64) int { data[offset] = uint8(v) data[offset+1] = uint8(v >> 8) @@ -1814,6 +1873,15 @@ func (m *StoreAction_Cluster) Size() (n int) { } return n } +func (m *StoreAction_Secret) Size() (n int) { + var l int + _ = l + if m.Secret != nil { + l = m.Secret.Size() + n += 1 + l + sovRaft(uint64(l)) + } + return n +} func sovRaft(x uint64) (n int) { for { @@ -1993,6 +2061,16 @@ func (this *StoreAction_Cluster) String() string { }, "") return s } +func (this *StoreAction_Secret) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&StoreAction_Secret{`, + `Secret:` + strings.Replace(fmt.Sprintf("%v", this.Secret), "Secret", "Secret", 1) + `,`, + `}`, + }, "") + return s +} func valueToStringRaft(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -3079,6 +3157,38 @@ func (m *StoreAction) Unmarshal(data []byte) error { } m.Target = &StoreAction_Cluster{v} iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Secret", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRaft + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRaft + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Secret{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Target = &StoreAction_Secret{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaft(data[iNdEx:]) @@ -3206,60 +3316,61 @@ var ( ) var fileDescriptorRaft = []byte{ - // 868 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x95, 0x4f, 0x73, 0xdb, 0x44, - 0x18, 0xc6, 0xb5, 0xb2, 0xaa, 0xc0, 0xeb, 0x26, 0xce, 0x6c, 0x48, 0x70, 0x45, 0x47, 0x51, 0x55, - 0x66, 0xea, 0x76, 0x88, 0x3c, 0x88, 0x43, 0x19, 0xe0, 0x12, 0x27, 0x9e, 0xa9, 0x69, 0xeb, 0x74, - 0x94, 0x04, 0x7a, 0x0b, 0xb2, 0xb4, 0x71, 0x85, 0x63, 0xad, 0xd9, 0x5d, 0x3b, 0xc3, 0x85, 0xe9, - 0x91, 0xc9, 0x95, 0x19, 0xe0, 0xd2, 0x13, 0x9c, 0xfb, 0x01, 0xf8, 0x04, 0x19, 0x4e, 0xdc, 0xe0, - 0x14, 0x88, 0x3f, 0x00, 0xf0, 0x11, 0x98, 0xd5, 0x9f, 0x24, 0x38, 0x8a, 0xe3, 0x8b, 0x2d, 0xef, - 0xfe, 0x9e, 0xe7, 0xd9, 0x7d, 0x57, 0xef, 0x1a, 0x80, 0xf9, 0xfb, 0xc2, 0x19, 0x30, 0x2a, 0x28, - 0xc6, 0x21, 0x0d, 0x7a, 0x84, 0x39, 0xfc, 0xd0, 0x67, 0xfd, 0x5e, 0x24, 0x9c, 0xd1, 0xfb, 0xc6, - 0x3c, 0xed, 0x7c, 0x49, 0x02, 0xc1, 0x53, 0xc4, 0x28, 0x8b, 0xaf, 0x07, 0x24, 0xff, 0xb1, 0xd6, - 0x8d, 0xc4, 0x8b, 0x61, 0xc7, 0x09, 0x68, 0xbf, 0x1e, 0x50, 0x46, 0x28, 0xaf, 0x13, 0x11, 0x84, - 0x75, 0x69, 0x99, 0x7c, 0x0c, 0x3a, 0xf5, 0x73, 0x7b, 0xe3, 0xad, 0x2e, 0xed, 0xd2, 0xe4, 0xb1, - 0x2e, 0x9f, 0xb2, 0xd1, 0xa5, 0xc1, 0xc1, 0xb0, 0x1b, 0xc5, 0xf5, 0xf4, 0x2b, 0x1d, 0xb4, 0x5f, - 0x23, 0x00, 0xcf, 0xdf, 0x17, 0x4f, 0x49, 0xbf, 0x43, 0x18, 0xbe, 0x0b, 0x73, 0xd2, 0x67, 0x2f, - 0x0a, 0xab, 0xc8, 0x42, 0x35, 0xad, 0x01, 0xe3, 0x93, 0x55, 0x5d, 0x02, 0xad, 0x4d, 0x4f, 0x97, - 0x53, 0xad, 0x50, 0x42, 0x31, 0x0d, 0x89, 0x84, 0x54, 0x0b, 0xd5, 0xde, 0x4c, 0xa1, 0x36, 0x0d, - 0x89, 0x84, 0xe4, 0x54, 0x2b, 0xc4, 0x18, 0x34, 0x3f, 0x0c, 0x59, 0xb5, 0x24, 0x09, 0x2f, 0x79, - 0xc6, 0x0d, 0xd0, 0xb9, 0xf0, 0xc5, 0x90, 0x57, 0x35, 0x0b, 0xd5, 0xca, 0xee, 0xbb, 0xce, 0xe5, - 0x3a, 0x38, 0xe7, 0xab, 0xd9, 0x4e, 0xd8, 0x86, 0x76, 0x7c, 0xb2, 0xaa, 0x78, 0x99, 0xd2, 0xbe, - 0x03, 0xe5, 0x4f, 0x69, 0x14, 0x7b, 0xe4, 0xab, 0x21, 0xe1, 0xe2, 0x2c, 0x06, 0x9d, 0xc7, 0xd8, - 0xdf, 0x23, 0xb8, 0x99, 0x32, 0x7c, 0x40, 0x63, 0x4e, 0x66, 0xdb, 0xd5, 0x87, 0x30, 0xd7, 0x4f, - 0x62, 0x79, 0x55, 0xb5, 0x4a, 0xb5, 0xb2, 0x6b, 0x4e, 0x5f, 0x9d, 0x97, 0xe3, 0xf8, 0x1e, 0x54, - 0x18, 0xe9, 0xd3, 0x11, 0x09, 0xf7, 0x72, 0x87, 0x92, 0x55, 0xaa, 0x69, 0xde, 0x42, 0x36, 0x9c, - 0x0a, 0xb8, 0xdd, 0x80, 0x9b, 0x4f, 0x88, 0x3f, 0x22, 0xf9, 0xe2, 0x5d, 0xd0, 0x64, 0xb5, 0x92, - 0x45, 0x5d, 0x9f, 0x97, 0xb0, 0x76, 0x05, 0xe6, 0x33, 0x8f, 0x74, 0x73, 0xf6, 0x13, 0xb8, 0xf5, - 0x8c, 0xd1, 0x80, 0x70, 0x9e, 0xb2, 0x9c, 0xfb, 0xdd, 0xb3, 0x84, 0xfb, 0x72, 0x53, 0xc9, 0x48, - 0x16, 0x52, 0x71, 0xd2, 0xd7, 0xc5, 0xc9, 0xc1, 0x7c, 0xfe, 0x23, 0xed, 0xe5, 0x0f, 0xb6, 0x62, - 0xdf, 0x06, 0xa3, 0xc8, 0x2d, 0xcb, 0xfa, 0x04, 0x96, 0x3d, 0xc2, 0xe9, 0xc1, 0x88, 0xac, 0x87, - 0x21, 0x93, 0x50, 0x96, 0x33, 0x4b, 0x85, 0xed, 0xf7, 0x60, 0x65, 0x52, 0x9d, 0x1d, 0x50, 0xd1, - 0x29, 0xee, 0xc3, 0x52, 0x2b, 0x16, 0x84, 0xc5, 0xfe, 0x81, 0xf4, 0xc9, 0x93, 0x56, 0x40, 0x3d, - 0x0b, 0xd1, 0xc7, 0x27, 0xab, 0x6a, 0x6b, 0xd3, 0x53, 0xa3, 0x10, 0x3f, 0x04, 0xdd, 0x0f, 0x44, - 0x44, 0xe3, 0xec, 0xf4, 0x56, 0x8b, 0xaa, 0xb9, 0x2d, 0x28, 0x23, 0xeb, 0x09, 0xe6, 0x65, 0xb8, - 0xfd, 0xa7, 0x0a, 0xe5, 0x0b, 0xe3, 0xf8, 0xe3, 0x33, 0x23, 0x19, 0xb2, 0xe0, 0xde, 0xbd, 0xc6, - 0xe8, 0x71, 0x14, 0x87, 0xb9, 0x19, 0x76, 0xb2, 0x13, 0x55, 0x93, 0x62, 0x57, 0x8b, 0xa4, 0xb2, - 0x4f, 0x1e, 0x29, 0xe9, 0x69, 0xe2, 0x87, 0x30, 0xc7, 0x09, 0x1b, 0x45, 0x01, 0x49, 0x1a, 0xa5, - 0xec, 0xbe, 0x53, 0x98, 0x96, 0x22, 0x8f, 0x14, 0x2f, 0xa7, 0x65, 0x90, 0xf0, 0x79, 0x2f, 0x6b, - 0xa4, 0xc2, 0xa0, 0x1d, 0x9f, 0xf7, 0x64, 0x90, 0xe4, 0x64, 0x50, 0x4c, 0xc4, 0x21, 0x65, 0xbd, - 0xea, 0x8d, 0xab, 0x83, 0xda, 0x29, 0x22, 0x83, 0x32, 0x5a, 0x0a, 0x83, 0x83, 0x21, 0x17, 0x84, - 0x55, 0xf5, 0xab, 0x85, 0x1b, 0x29, 0x22, 0x85, 0x19, 0xdd, 0x78, 0x03, 0x74, 0xe1, 0xb3, 0x2e, - 0x11, 0x0f, 0xfe, 0x41, 0x50, 0x99, 0x28, 0x18, 0xbe, 0x07, 0x73, 0xbb, 0xed, 0xc7, 0xed, 0xad, - 0xcf, 0xdb, 0x8b, 0x8a, 0x61, 0x1c, 0xbd, 0xb2, 0x56, 0x26, 0x88, 0xdd, 0xb8, 0x17, 0xd3, 0xc3, - 0x18, 0xbb, 0xb0, 0xb4, 0xbd, 0xb3, 0xe5, 0x35, 0xf7, 0xd6, 0x37, 0x76, 0x5a, 0x5b, 0xed, 0xbd, - 0x0d, 0xaf, 0xb9, 0xbe, 0xd3, 0x5c, 0x44, 0xc6, 0xad, 0xa3, 0x57, 0xd6, 0xf2, 0x84, 0x68, 0x83, - 0x11, 0x5f, 0x90, 0x4b, 0x9a, 0xdd, 0x67, 0x9b, 0x52, 0xa3, 0x16, 0x6a, 0x76, 0x07, 0x61, 0x91, - 0xc6, 0x6b, 0x3e, 0xdd, 0xfa, 0xac, 0xb9, 0x58, 0x2a, 0xd4, 0x78, 0x49, 0x5f, 0x1b, 0x6f, 0x7f, - 0xfb, 0x93, 0xa9, 0xfc, 0xf2, 0xb3, 0x39, 0xb9, 0x3b, 0xf7, 0x3b, 0x15, 0x34, 0xf9, 0xd2, 0xe2, - 0x23, 0x04, 0xf8, 0x72, 0x3f, 0xe1, 0xb5, 0xa2, 0x1a, 0x5e, 0xd9, 0xc5, 0x86, 0x33, 0x2b, 0x9e, - 0xb5, 0xe9, 0xf2, 0xaf, 0xaf, 0xff, 0xfe, 0x51, 0xad, 0xc0, 0x7c, 0xc2, 0xaf, 0xf5, 0xfd, 0xd8, - 0xef, 0x12, 0x86, 0xbf, 0x81, 0x85, 0xff, 0xf7, 0x1f, 0xbe, 0x5f, 0x78, 0xe5, 0x14, 0x75, 0xb8, - 0xf1, 0x60, 0x16, 0x74, 0x6a, 0xbe, 0xfb, 0x3b, 0x82, 0x85, 0xf3, 0xfb, 0x8c, 0xbf, 0x88, 0x06, - 0xf8, 0x0b, 0xd0, 0xe4, 0x4d, 0x8d, 0x0b, 0xbb, 0xf5, 0xc2, 0x3d, 0x6f, 0x58, 0x57, 0x03, 0xd3, - 0x37, 0x1d, 0xc0, 0x8d, 0xe4, 0xbe, 0xc4, 0x85, 0x0e, 0x17, 0xaf, 0x63, 0xe3, 0xce, 0x14, 0x62, - 0x6a, 0x48, 0xe3, 0xf6, 0xf1, 0xa9, 0xa9, 0xfc, 0x71, 0x6a, 0x2a, 0xff, 0x9e, 0x9a, 0xe8, 0xe5, - 0xd8, 0x44, 0xc7, 0x63, 0x13, 0xfd, 0x36, 0x36, 0xd1, 0x5f, 0x63, 0x13, 0x3d, 0x2f, 0x3d, 0xd7, - 0x3a, 0x7a, 0xf2, 0x77, 0xfb, 0xc1, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd7, 0x61, 0x3c, 0x43, - 0x06, 0x08, 0x00, 0x00, + // 890 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x95, 0xcf, 0x73, 0xdb, 0x44, + 0x14, 0xc7, 0xbd, 0xb2, 0x2a, 0xc3, 0x73, 0x13, 0x67, 0x36, 0x24, 0xb8, 0xa2, 0xa3, 0xb8, 0x2a, + 0x33, 0x75, 0x3b, 0x44, 0x1e, 0x0c, 0x33, 0x65, 0x80, 0x4b, 0x9c, 0x78, 0x26, 0xa6, 0xad, 0xd3, + 0x51, 0x12, 0xe8, 0x2d, 0xc8, 0xd2, 0xc6, 0x15, 0x8e, 0xb5, 0x66, 0x77, 0xed, 0x0c, 0x17, 0xa6, + 0x47, 0x26, 0x57, 0x86, 0x1f, 0x97, 0x9e, 0xe0, 0xdc, 0x3f, 0x80, 0xbf, 0x20, 0xc3, 0x89, 0x1b, + 0x9c, 0x32, 0xc4, 0x7f, 0x00, 0xf0, 0x27, 0x30, 0xbb, 0x92, 0x92, 0xd4, 0x51, 0x1c, 0x5f, 0x92, + 0xf5, 0xea, 0xf3, 0x7d, 0xdf, 0x7d, 0x6f, 0xf5, 0x9e, 0x00, 0x98, 0xb7, 0x2f, 0x9c, 0x01, 0xa3, + 0x82, 0x62, 0x1c, 0x50, 0xbf, 0x47, 0x98, 0xc3, 0x0f, 0x3d, 0xd6, 0xef, 0x85, 0xc2, 0x19, 0xbd, + 0x6f, 0xce, 0xd1, 0xce, 0x57, 0xc4, 0x17, 0x3c, 0x46, 0xcc, 0xa2, 0xf8, 0x66, 0x40, 0xd2, 0x1f, + 0xab, 0xdd, 0x50, 0x3c, 0x1f, 0x76, 0x1c, 0x9f, 0xf6, 0x6b, 0x3e, 0x65, 0x84, 0xf2, 0x1a, 0x11, + 0x7e, 0x50, 0x93, 0x21, 0xd5, 0x9f, 0x41, 0xa7, 0x76, 0x1e, 0xde, 0x7c, 0xab, 0x4b, 0xbb, 0x54, + 0x2d, 0x6b, 0x72, 0x95, 0xec, 0x2e, 0x0e, 0x0e, 0x86, 0xdd, 0x30, 0xaa, 0xc5, 0xff, 0xe2, 0x4d, + 0xfb, 0x15, 0x02, 0x70, 0xbd, 0x7d, 0xf1, 0x84, 0xf4, 0x3b, 0x84, 0xe1, 0xbb, 0x50, 0x90, 0x71, + 0xf6, 0xc2, 0xa0, 0x8c, 0x2a, 0xa8, 0xaa, 0x37, 0x60, 0x7c, 0xb2, 0x62, 0x48, 0xa0, 0xb5, 0xe1, + 0x1a, 0xf2, 0x51, 0x2b, 0x90, 0x50, 0x44, 0x03, 0x22, 0x21, 0xad, 0x82, 0xaa, 0x6f, 0xc6, 0x50, + 0x9b, 0x06, 0x44, 0x42, 0xf2, 0x51, 0x2b, 0xc0, 0x18, 0x74, 0x2f, 0x08, 0x58, 0x39, 0x2f, 0x09, + 0x57, 0xad, 0x71, 0x03, 0x0c, 0x2e, 0x3c, 0x31, 0xe4, 0x65, 0xbd, 0x82, 0xaa, 0xc5, 0xfa, 0xbb, + 0xce, 0xe5, 0x3a, 0x38, 0xe7, 0xa7, 0xd9, 0x56, 0x6c, 0x43, 0x3f, 0x3e, 0x59, 0xc9, 0xb9, 0x89, + 0xd2, 0xbe, 0x03, 0xc5, 0xcf, 0x68, 0x18, 0xb9, 0xe4, 0xeb, 0x21, 0xe1, 0xe2, 0xcc, 0x06, 0x9d, + 0xdb, 0xd8, 0x3f, 0x22, 0xb8, 0x19, 0x33, 0x7c, 0x40, 0x23, 0x4e, 0x66, 0xcb, 0xea, 0x23, 0x28, + 0xf4, 0x95, 0x2d, 0x2f, 0x6b, 0x95, 0x7c, 0xb5, 0x58, 0xb7, 0xa6, 0x9f, 0xce, 0x4d, 0x71, 0x7c, + 0x0f, 0x4a, 0x8c, 0xf4, 0xe9, 0x88, 0x04, 0x7b, 0x69, 0x84, 0x7c, 0x25, 0x5f, 0xd5, 0xdd, 0xf9, + 0x64, 0x3b, 0x16, 0x70, 0xbb, 0x01, 0x37, 0x1f, 0x13, 0x6f, 0x44, 0xd2, 0xc3, 0xd7, 0x41, 0x97, + 0xd5, 0x52, 0x87, 0xba, 0xde, 0x4f, 0xb1, 0x76, 0x09, 0xe6, 0x92, 0x18, 0x71, 0x72, 0xf6, 0x63, + 0xb8, 0xf5, 0x94, 0x51, 0x9f, 0x70, 0x1e, 0xb3, 0x9c, 0x7b, 0xdd, 0x33, 0x87, 0xfb, 0x32, 0x29, + 0xb5, 0x93, 0x98, 0x94, 0x9c, 0xf8, 0x75, 0x71, 0x52, 0x30, 0x7d, 0xfe, 0xb1, 0xfe, 0xe2, 0x27, + 0x3b, 0x67, 0xdf, 0x06, 0x33, 0x2b, 0x5a, 0xe2, 0xf5, 0x29, 0x2c, 0xb9, 0x84, 0xd3, 0x83, 0x11, + 0x59, 0x0b, 0x02, 0x26, 0xa1, 0xc4, 0x67, 0x96, 0x0a, 0xdb, 0xef, 0xc1, 0xf2, 0xa4, 0x3a, 0xb9, + 0xa0, 0xac, 0x5b, 0xdc, 0x87, 0xc5, 0x56, 0x24, 0x08, 0x8b, 0xbc, 0x03, 0x19, 0x27, 0x75, 0x5a, + 0x06, 0xed, 0xcc, 0xc4, 0x18, 0x9f, 0xac, 0x68, 0xad, 0x0d, 0x57, 0x0b, 0x03, 0xfc, 0x10, 0x0c, + 0xcf, 0x17, 0x21, 0x8d, 0x92, 0xdb, 0x5b, 0xc9, 0xaa, 0xe6, 0xb6, 0xa0, 0x8c, 0xac, 0x29, 0xcc, + 0x4d, 0x70, 0xfb, 0x87, 0x3c, 0x14, 0x2f, 0xec, 0xe3, 0x4f, 0xce, 0x02, 0x49, 0x93, 0xf9, 0xfa, + 0xdd, 0x6b, 0x02, 0x3d, 0x0a, 0xa3, 0x20, 0x0d, 0x86, 0x9d, 0xe4, 0x46, 0x35, 0x55, 0xec, 0x72, + 0x96, 0x54, 0xf6, 0xc9, 0x66, 0x2e, 0xbe, 0x4d, 0xfc, 0x10, 0x0a, 0x9c, 0xb0, 0x51, 0xe8, 0x13, + 0xd5, 0x28, 0xc5, 0xfa, 0x3b, 0x99, 0x6e, 0x31, 0xb2, 0x99, 0x73, 0x53, 0x5a, 0x1a, 0x09, 0x8f, + 0xf7, 0x92, 0x46, 0xca, 0x34, 0xda, 0xf1, 0x78, 0x4f, 0x1a, 0x49, 0x4e, 0x1a, 0x45, 0x44, 0x1c, + 0x52, 0xd6, 0x2b, 0xdf, 0xb8, 0xda, 0xa8, 0x1d, 0x23, 0xd2, 0x28, 0xa1, 0xa5, 0xd0, 0x3f, 0x18, + 0x72, 0x41, 0x58, 0xd9, 0xb8, 0x5a, 0xb8, 0x1e, 0x23, 0x52, 0x98, 0xd0, 0xf8, 0x43, 0x30, 0x38, + 0xf1, 0x19, 0x11, 0xe5, 0x82, 0xd2, 0x99, 0xd9, 0x99, 0x49, 0x62, 0x53, 0xb6, 0xb7, 0x5a, 0x35, + 0xde, 0x00, 0x43, 0x78, 0xac, 0x4b, 0xc4, 0x83, 0x7f, 0x11, 0x94, 0x26, 0xca, 0x8c, 0xef, 0x41, + 0x61, 0xb7, 0xfd, 0xa8, 0xbd, 0xf5, 0x45, 0x7b, 0x21, 0x67, 0x9a, 0x47, 0x2f, 0x2b, 0xcb, 0x13, + 0xc4, 0x6e, 0xd4, 0x8b, 0xe8, 0x61, 0x84, 0xeb, 0xb0, 0xb8, 0xbd, 0xb3, 0xe5, 0x36, 0xf7, 0xd6, + 0xd6, 0x77, 0x5a, 0x5b, 0xed, 0xbd, 0x75, 0xb7, 0xb9, 0xb6, 0xd3, 0x5c, 0x40, 0xe6, 0xad, 0xa3, + 0x97, 0x95, 0xa5, 0x09, 0xd1, 0x3a, 0x23, 0x9e, 0x20, 0x97, 0x34, 0xbb, 0x4f, 0x37, 0xa4, 0x46, + 0xcb, 0xd4, 0xec, 0x0e, 0x82, 0x2c, 0x8d, 0xdb, 0x7c, 0xb2, 0xf5, 0x79, 0x73, 0x21, 0x9f, 0xa9, + 0x71, 0xd5, 0x34, 0x30, 0xdf, 0xfe, 0xee, 0x17, 0x2b, 0xf7, 0xdb, 0xaf, 0xd6, 0x64, 0x76, 0xf5, + 0xef, 0x35, 0xd0, 0xe5, 0xab, 0x8e, 0x8f, 0x10, 0xe0, 0xcb, 0x5d, 0x88, 0x57, 0xb3, 0x2a, 0x78, + 0x65, 0xef, 0x9b, 0xce, 0xac, 0x78, 0xd2, 0xdc, 0x4b, 0xbf, 0xbf, 0xfa, 0xe7, 0x67, 0xad, 0x04, + 0x73, 0x8a, 0x5f, 0xed, 0x7b, 0x91, 0xd7, 0x25, 0x0c, 0x7f, 0x0b, 0xf3, 0xaf, 0x77, 0x2d, 0xbe, + 0x9f, 0x39, 0xa8, 0xb2, 0xe6, 0x82, 0xf9, 0x60, 0x16, 0x74, 0xaa, 0x7f, 0xfd, 0x4f, 0x04, 0xf3, + 0xe7, 0x53, 0x90, 0x3f, 0x0f, 0x07, 0xf8, 0x4b, 0xd0, 0xe5, 0x7c, 0xc7, 0x99, 0x3d, 0x7e, 0xe1, + 0xeb, 0x60, 0x56, 0xae, 0x06, 0xa6, 0x27, 0xed, 0xc3, 0x0d, 0x35, 0x65, 0x71, 0x66, 0x84, 0x8b, + 0x43, 0xdc, 0xbc, 0x33, 0x85, 0x98, 0x6a, 0xd2, 0xb8, 0x7d, 0x7c, 0x6a, 0xe5, 0xfe, 0x3a, 0xb5, + 0x72, 0xff, 0x9d, 0x5a, 0xe8, 0xc5, 0xd8, 0x42, 0xc7, 0x63, 0x0b, 0xfd, 0x31, 0xb6, 0xd0, 0xdf, + 0x63, 0x0b, 0x3d, 0xcb, 0x3f, 0xd3, 0x3b, 0x86, 0xfa, 0x48, 0x7f, 0xf0, 0x7f, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x53, 0x4c, 0x9e, 0xad, 0x3c, 0x08, 0x00, 0x00, } diff --git a/api/raft.proto b/api/raft.proto index 911de323f4..e1d9c19568 100644 --- a/api/raft.proto +++ b/api/raft.proto @@ -115,7 +115,7 @@ enum StoreActionKind { STORE_ACTION_REMOVE = 3 [(gogoproto.enumvalue_customname) = "StoreActionKindRemove"]; } -// StoreAction defines a taret and operation to apply on the storage system. +// StoreAction defines a target and operation to apply on the storage system. message StoreAction { StoreActionKind action = 1; oneof target { @@ -124,5 +124,6 @@ message StoreAction { Task task = 4; Network network = 5; Cluster cluster = 6; + Secret secret = 7; } } diff --git a/api/snapshot.pb.go b/api/snapshot.pb.go index 6fdcd9707e..1fd82da8eb 100644 --- a/api/snapshot.pb.go +++ b/api/snapshot.pb.go @@ -49,6 +49,7 @@ type StoreSnapshot struct { Networks []*Network `protobuf:"bytes,3,rep,name=networks" json:"networks,omitempty"` Tasks []*Task `protobuf:"bytes,4,rep,name=tasks" json:"tasks,omitempty"` Clusters []*Cluster `protobuf:"bytes,5,rep,name=clusters" json:"clusters,omitempty"` + Secrets []*Secret `protobuf:"bytes,6,rep,name=secrets" json:"secrets,omitempty"` } func (m *StoreSnapshot) Reset() { *m = StoreSnapshot{} } @@ -124,6 +125,13 @@ func (m *StoreSnapshot) Copy() *StoreSnapshot { } } + if m.Secrets != nil { + o.Secrets = make([]*Secret, 0, len(m.Secrets)) + for _, v := range m.Secrets { + o.Secrets = append(o.Secrets, v.Copy()) + } + } + return o } @@ -169,7 +177,7 @@ func (this *StoreSnapshot) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 9) + s := make([]string, 0, 10) s = append(s, "&api.StoreSnapshot{") if this.Nodes != nil { s = append(s, "Nodes: "+fmt.Sprintf("%#v", this.Nodes)+",\n") @@ -186,6 +194,9 @@ func (this *StoreSnapshot) GoString() string { if this.Clusters != nil { s = append(s, "Clusters: "+fmt.Sprintf("%#v", this.Clusters)+",\n") } + if this.Secrets != nil { + s = append(s, "Secrets: "+fmt.Sprintf("%#v", this.Secrets)+",\n") + } s = append(s, "}") return strings.Join(s, "") } @@ -314,6 +325,18 @@ func (m *StoreSnapshot) MarshalTo(data []byte) (int, error) { i += n } } + if len(m.Secrets) > 0 { + for _, msg := range m.Secrets { + data[i] = 0x32 + i++ + i = encodeVarintSnapshot(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } return i, nil } @@ -454,6 +477,12 @@ func (m *StoreSnapshot) Size() (n int) { n += 1 + l + sovSnapshot(uint64(l)) } } + if len(m.Secrets) > 0 { + for _, e := range m.Secrets { + l = e.Size() + n += 1 + l + sovSnapshot(uint64(l)) + } + } return n } @@ -510,6 +539,7 @@ func (this *StoreSnapshot) String() string { `Networks:` + strings.Replace(fmt.Sprintf("%v", this.Networks), "Network", "Network", 1) + `,`, `Tasks:` + strings.Replace(fmt.Sprintf("%v", this.Tasks), "Task", "Task", 1) + `,`, `Clusters:` + strings.Replace(fmt.Sprintf("%v", this.Clusters), "Cluster", "Cluster", 1) + `,`, + `Secrets:` + strings.Replace(fmt.Sprintf("%v", this.Secrets), "Secret", "Secret", 1) + `,`, `}`, }, "") return s @@ -729,6 +759,37 @@ func (m *StoreSnapshot) Unmarshal(data []byte) error { return err } iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Secrets", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSnapshot + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSnapshot + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Secrets = append(m.Secrets, &Secret{}) + if err := m.Secrets[len(m.Secrets)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshot(data[iNdEx:]) @@ -1086,30 +1147,31 @@ var ( ) var fileDescriptorSnapshot = []byte{ - // 396 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x92, 0xbd, 0x6e, 0xdb, 0x30, - 0x14, 0x85, 0x45, 0xf9, 0x47, 0x06, 0x0d, 0xbb, 0x2d, 0xd1, 0x81, 0x70, 0x0b, 0xd6, 0x55, 0x3b, - 0x78, 0x52, 0x5b, 0x77, 0x68, 0x97, 0x76, 0x70, 0xa6, 0x0c, 0xf1, 0x40, 0x07, 0x46, 0x56, 0x59, - 0xa2, 0x6d, 0x45, 0x91, 0x68, 0x90, 0x8c, 0xbc, 0xe6, 0x39, 0xf2, 0x44, 0x1e, 0x33, 0x66, 0x0a, - 0x62, 0x2d, 0x59, 0xf3, 0x08, 0x81, 0x44, 0x49, 0x30, 0x10, 0x39, 0x1b, 0x75, 0xf1, 0x9d, 0x73, - 0xae, 0x2e, 0x0e, 0xec, 0xcb, 0xd8, 0xdd, 0xc8, 0x35, 0x57, 0xce, 0x46, 0x70, 0xc5, 0x11, 0xf2, - 0xb9, 0x17, 0x32, 0xe1, 0xc8, 0xad, 0x2b, 0xa2, 0x30, 0x50, 0x4e, 0xf2, 0x6b, 0xd0, 0xe3, 0x8b, - 0x4b, 0xe6, 0x29, 0xa9, 0x91, 0x01, 0x14, 0xee, 0xb2, 0xc0, 0x07, 0x1f, 0x57, 0x7c, 0xc5, 0xf3, - 0xe7, 0x8f, 0xec, 0xa5, 0xa7, 0xf6, 0xad, 0x09, 0x7b, 0x33, 0xc5, 0x05, 0x9b, 0x15, 0xe6, 0xc8, - 0x81, 0xad, 0x98, 0xfb, 0x4c, 0x62, 0x30, 0x6c, 0x8c, 0xba, 0x63, 0xec, 0xbc, 0x8e, 0x71, 0xa6, - 0xdc, 0x67, 0x54, 0x63, 0xe8, 0x0f, 0xec, 0x48, 0x26, 0x92, 0xc0, 0x63, 0x12, 0x9b, 0xb9, 0xe4, - 0x53, 0x9d, 0x64, 0xa6, 0x19, 0x5a, 0xc1, 0x99, 0x30, 0x66, 0x6a, 0xcb, 0x45, 0x28, 0x71, 0xe3, - 0xb8, 0x70, 0xaa, 0x19, 0x5a, 0xc1, 0xd9, 0x86, 0xca, 0x95, 0xa1, 0xc4, 0xcd, 0xe3, 0x1b, 0x9e, - 0xbb, 0x32, 0xa4, 0x1a, 0xcb, 0x82, 0xbc, 0xab, 0x6b, 0xa9, 0x98, 0x90, 0xb8, 0x75, 0x3c, 0xe8, - 0x44, 0x33, 0xb4, 0x82, 0x6d, 0x06, 0xdf, 0x15, 0xc3, 0xea, 0x3a, 0x7f, 0xa1, 0x15, 0xb1, 0x68, - 0x91, 0x59, 0xe9, 0xfb, 0x90, 0x3a, 0x2b, 0xea, 0x2e, 0xd5, 0x59, 0x8e, 0xd1, 0x12, 0x47, 0x18, - 0x5a, 0x82, 0x45, 0x3c, 0x61, 0x7e, 0x7e, 0xa6, 0x26, 0x2d, 0x3f, 0xed, 0x27, 0x00, 0x3b, 0x55, - 0xc0, 0x7f, 0x68, 0x25, 0x4c, 0xc8, 0x80, 0xc7, 0x18, 0x0c, 0xc1, 0xa8, 0x3f, 0xfe, 0x5e, 0x7b, - 0xcd, 0xb2, 0x0a, 0x73, 0xcd, 0xd2, 0x52, 0x84, 0x4e, 0x21, 0x2c, 0x12, 0xd7, 0xc1, 0x06, 0x9b, - 0x43, 0x30, 0xea, 0x8e, 0xbf, 0xbd, 0xf1, 0xbb, 0xa5, 0xd3, 0xa4, 0xb9, 0x7b, 0xf8, 0x62, 0xd0, - 0x03, 0x31, 0xfa, 0x07, 0x5b, 0x32, 0xab, 0x06, 0x6e, 0xe4, 0x2e, 0x5f, 0x6b, 0x17, 0x39, 0xec, - 0x4e, 0xe1, 0xa1, 0x55, 0xf6, 0x07, 0x68, 0x15, 0xdb, 0xa1, 0x36, 0x34, 0xe7, 0x3f, 0xdf, 0x1b, - 0x93, 0xcf, 0xbb, 0x3d, 0x31, 0xee, 0xf7, 0xc4, 0x78, 0xde, 0x13, 0x70, 0x93, 0x12, 0xb0, 0x4b, - 0x09, 0xb8, 0x4b, 0x09, 0x78, 0x4c, 0x09, 0xb8, 0x30, 0x17, 0xed, 0xbc, 0x94, 0xbf, 0x5f, 0x02, - 0x00, 0x00, 0xff, 0xff, 0xc9, 0xd9, 0x1a, 0xd9, 0xeb, 0x02, 0x00, 0x00, + // 409 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x92, 0xbf, 0x6f, 0xd3, 0x40, + 0x14, 0xc7, 0x73, 0xce, 0x0f, 0x57, 0xaf, 0x6a, 0x81, 0x13, 0xc3, 0x29, 0xa0, 0x23, 0x04, 0x86, + 0x4c, 0x06, 0x02, 0x12, 0x2c, 0x30, 0x94, 0x89, 0x81, 0x0e, 0x17, 0x54, 0xb1, 0x3a, 0xf6, 0x6b, + 0x6b, 0x8c, 0x7d, 0xd1, 0xbd, 0xc3, 0x5d, 0xf9, 0xf3, 0x32, 0x76, 0x64, 0x42, 0xc4, 0x0b, 0x2b, + 0x7f, 0x02, 0xb2, 0xcf, 0xb6, 0x22, 0xe1, 0xb0, 0x3d, 0x5b, 0x9f, 0xef, 0x8f, 0x7b, 0x7a, 0x70, + 0x4a, 0x79, 0xb8, 0xa1, 0x6b, 0x6d, 0x83, 0x8d, 0xd1, 0x56, 0x73, 0x1e, 0xeb, 0x28, 0x45, 0x13, + 0xd0, 0x4d, 0x68, 0xb2, 0x34, 0xb1, 0x41, 0xf1, 0x62, 0x7a, 0xa2, 0xd7, 0x5f, 0x30, 0xb2, 0xe4, + 0x90, 0x29, 0x98, 0xf0, 0xb2, 0xc1, 0xa7, 0xf7, 0xaf, 0xf4, 0x95, 0xae, 0xc7, 0x67, 0xd5, 0xe4, + 0xfe, 0xce, 0x6f, 0x3d, 0x38, 0x59, 0x59, 0x6d, 0x70, 0xd5, 0x98, 0xf3, 0x00, 0xc6, 0xb9, 0x8e, + 0x91, 0x04, 0x9b, 0x0d, 0x17, 0xc7, 0x4b, 0x11, 0xfc, 0x1b, 0x13, 0x9c, 0xeb, 0x18, 0x95, 0xc3, + 0xf8, 0x6b, 0x38, 0x22, 0x34, 0x45, 0x12, 0x21, 0x09, 0xaf, 0x96, 0x3c, 0xe8, 0x93, 0xac, 0x1c, + 0xa3, 0x3a, 0xb8, 0x12, 0xe6, 0x68, 0x6f, 0xb4, 0x49, 0x49, 0x0c, 0x0f, 0x0b, 0xcf, 0x1d, 0xa3, + 0x3a, 0xb8, 0x6a, 0x68, 0x43, 0x4a, 0x49, 0x8c, 0x0e, 0x37, 0xfc, 0x14, 0x52, 0xaa, 0x1c, 0x56, + 0x05, 0x45, 0x5f, 0xbf, 0x91, 0x45, 0x43, 0x62, 0x7c, 0x38, 0xe8, 0xbd, 0x63, 0x54, 0x07, 0xf3, + 0x57, 0xe0, 0x13, 0x46, 0x06, 0x2d, 0x89, 0x49, 0xad, 0x9b, 0xf6, 0xbf, 0xac, 0x42, 0x54, 0x8b, + 0xce, 0x11, 0xee, 0x34, 0x56, 0xdd, 0x4e, 0xdf, 0x80, 0x9f, 0x61, 0xb6, 0xae, 0x0a, 0xb8, 0xad, + 0xca, 0x3e, 0x23, 0x15, 0x5e, 0xda, 0x8f, 0x35, 0xa6, 0x5a, 0x9c, 0x0b, 0xf0, 0x0d, 0x66, 0xba, + 0xc0, 0xb8, 0x5e, 0xee, 0x48, 0xb5, 0x9f, 0xf3, 0xdf, 0x0c, 0x8e, 0xba, 0x80, 0x77, 0xe0, 0x17, + 0x68, 0x28, 0xd1, 0xb9, 0x60, 0x33, 0xb6, 0x38, 0x5d, 0x3e, 0xed, 0x6d, 0xda, 0x1e, 0xd0, 0x85, + 0x63, 0x55, 0x2b, 0xe2, 0x1f, 0x00, 0x9a, 0xc4, 0xeb, 0x64, 0x23, 0xbc, 0x19, 0x5b, 0x1c, 0x2f, + 0x9f, 0xfc, 0x67, 0x49, 0xad, 0xd3, 0xd9, 0x68, 0xfb, 0xf3, 0xd1, 0x40, 0xed, 0x89, 0xf9, 0x5b, + 0x18, 0x53, 0x75, 0x50, 0x62, 0x58, 0xbb, 0x3c, 0xee, 0x2d, 0xb2, 0x7f, 0x71, 0x8d, 0x87, 0x53, + 0xcd, 0xef, 0x81, 0xdf, 0xb4, 0xe3, 0x13, 0xf0, 0x2e, 0x9e, 0xdf, 0x1d, 0x9c, 0x3d, 0xdc, 0xee, + 0xe4, 0xe0, 0xc7, 0x4e, 0x0e, 0xfe, 0xec, 0x24, 0xfb, 0x5e, 0x4a, 0xb6, 0x2d, 0x25, 0xbb, 0x2d, + 0x25, 0xfb, 0x55, 0x4a, 0xf6, 0xd9, 0x5b, 0x4f, 0xea, 0x53, 0x7e, 0xf9, 0x37, 0x00, 0x00, 0xff, + 0xff, 0x48, 0xfb, 0x27, 0x26, 0x21, 0x03, 0x00, 0x00, } diff --git a/api/snapshot.proto b/api/snapshot.proto index 04751b1bd2..9054306d52 100644 --- a/api/snapshot.proto +++ b/api/snapshot.proto @@ -19,6 +19,7 @@ message StoreSnapshot { repeated Network networks = 3; repeated Task tasks = 4; repeated Cluster clusters = 5; + repeated Secret secrets = 6; } // ClusterSnapshot stores cluster membership information in snapshots. diff --git a/api/specs.pb.go b/api/specs.pb.go index d5d2a00bf2..f157843d00 100644 --- a/api/specs.pb.go +++ b/api/specs.pb.go @@ -473,6 +473,9 @@ type ContainerSpec struct { StopGracePeriod *docker_swarmkit_v11.Duration `protobuf:"bytes,9,opt,name=stop_grace_period,json=stopGracePeriod" json:"stop_grace_period,omitempty"` // PullOptions parameterize the behavior of image pulls. PullOptions *ContainerSpec_PullOptions `protobuf:"bytes,10,opt,name=pull_options,json=pullOptions" json:"pull_options,omitempty"` + // SecretReference contains references to zero or more secrets that + // will be exposed to the container. + Secrets []*SecretReference `protobuf:"bytes,12,rep,name=secrets" json:"secrets,omitempty"` } func (m *ContainerSpec) Reset() { *m = ContainerSpec{} } @@ -555,6 +558,21 @@ func (m *ClusterSpec) Reset() { *m = ClusterSpec{} } func (*ClusterSpec) ProtoMessage() {} func (*ClusterSpec) Descriptor() ([]byte, []int) { return fileDescriptorSpecs, []int{9} } +// SecretSpec specifies a user-provided secret. +type SecretSpec struct { + Annotations Annotations `protobuf:"bytes,1,opt,name=annotations" json:"annotations"` + // Type distinguishes the different kinds of secrets in the system. + Type SecretType `protobuf:"varint,2,opt,name=type,proto3,enum=docker.swarmkit.v1.SecretType" json:"type,omitempty"` + // Tags group secrets. + Tags []string `protobuf:"bytes,3,rep,name=tags" json:"tags,omitempty"` + // Secret payload. + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *SecretSpec) Reset() { *m = SecretSpec{} } +func (*SecretSpec) ProtoMessage() {} +func (*SecretSpec) Descriptor() ([]byte, []int) { return fileDescriptorSpecs, []int{10} } + func init() { proto.RegisterType((*NodeSpec)(nil), "docker.swarmkit.v1.NodeSpec") proto.RegisterType((*ServiceSpec)(nil), "docker.swarmkit.v1.ServiceSpec") @@ -567,6 +585,7 @@ func init() { proto.RegisterType((*EndpointSpec)(nil), "docker.swarmkit.v1.EndpointSpec") proto.RegisterType((*NetworkSpec)(nil), "docker.swarmkit.v1.NetworkSpec") proto.RegisterType((*ClusterSpec)(nil), "docker.swarmkit.v1.ClusterSpec") + proto.RegisterType((*SecretSpec)(nil), "docker.swarmkit.v1.SecretSpec") proto.RegisterEnum("docker.swarmkit.v1.NodeSpec_Membership", NodeSpec_Membership_name, NodeSpec_Membership_value) proto.RegisterEnum("docker.swarmkit.v1.NodeSpec_Availability", NodeSpec_Availability_name, NodeSpec_Availability_value) proto.RegisterEnum("docker.swarmkit.v1.EndpointSpec_ResolutionMode", EndpointSpec_ResolutionMode_name, EndpointSpec_ResolutionMode_value) @@ -750,6 +769,13 @@ func (m *ContainerSpec) Copy() *ContainerSpec { } } + if m.Secrets != nil { + o.Secrets = make([]*SecretReference, 0, len(m.Secrets)) + for _, v := range m.Secrets { + o.Secrets = append(o.Secrets, v.Copy()) + } + } + return o } @@ -819,6 +845,27 @@ func (m *ClusterSpec) Copy() *ClusterSpec { return o } +func (m *SecretSpec) Copy() *SecretSpec { + if m == nil { + return nil + } + + o := &SecretSpec{ + Annotations: *m.Annotations.Copy(), + Type: m.Type, + Data: m.Data, + } + + if m.Tags != nil { + o.Tags = make([]string, 0, len(m.Tags)) + for _, v := range m.Tags { + o.Tags = append(o.Tags, v) + } + } + + return o +} + func (this *NodeSpec) GoString() string { if this == nil { return "nil" @@ -947,7 +994,7 @@ func (this *ContainerSpec) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 15) + s := make([]string, 0, 16) s = append(s, "&api.ContainerSpec{") s = append(s, "Image: "+fmt.Sprintf("%#v", this.Image)+",\n") keysForLabels := make([]string, 0, len(this.Labels)) @@ -978,6 +1025,9 @@ func (this *ContainerSpec) GoString() string { if this.PullOptions != nil { s = append(s, "PullOptions: "+fmt.Sprintf("%#v", this.PullOptions)+",\n") } + if this.Secrets != nil { + s = append(s, "Secrets: "+fmt.Sprintf("%#v", this.Secrets)+",\n") + } s = append(s, "}") return strings.Join(s, "") } @@ -1039,6 +1089,19 @@ func (this *ClusterSpec) GoString() string { s = append(s, "}") return strings.Join(s, "") } +func (this *SecretSpec) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&api.SecretSpec{") + s = append(s, "Annotations: "+strings.Replace(this.Annotations.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n") + s = append(s, "Tags: "+fmt.Sprintf("%#v", this.Tags)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} func valueToGoStringSpecs(v interface{}, typ string) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -1518,6 +1581,18 @@ func (m *ContainerSpec) MarshalTo(data []byte) (int, error) { i += copy(data[i:], s) } } + if len(m.Secrets) > 0 { + for _, msg := range m.Secrets { + data[i] = 0x62 + i++ + i = encodeVarintSpecs(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } return i, nil } @@ -1732,6 +1807,58 @@ func (m *ClusterSpec) MarshalTo(data []byte) (int, error) { return i, nil } +func (m *SecretSpec) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *SecretSpec) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintSpecs(data, i, uint64(m.Annotations.Size())) + n28, err := m.Annotations.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n28 + if m.Type != 0 { + data[i] = 0x10 + i++ + i = encodeVarintSpecs(data, i, uint64(m.Type)) + } + if len(m.Tags) > 0 { + for _, s := range m.Tags { + data[i] = 0x1a + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Data) > 0 { + data[i] = 0x22 + i++ + i = encodeVarintSpecs(data, i, uint64(len(m.Data))) + i += copy(data[i:], m.Data) + } + return i, nil +} + func encodeFixed64Specs(data []byte, offset int, v uint64) int { data[offset] = uint8(v) data[offset+1] = uint8(v >> 8) @@ -1957,6 +2084,12 @@ func (m *ContainerSpec) Size() (n int) { n += 1 + l + sovSpecs(uint64(l)) } } + if len(m.Secrets) > 0 { + for _, e := range m.Secrets { + l = e.Size() + n += 1 + l + sovSpecs(uint64(l)) + } + } return n } @@ -2030,6 +2163,27 @@ func (m *ClusterSpec) Size() (n int) { return n } +func (m *SecretSpec) Size() (n int) { + var l int + _ = l + l = m.Annotations.Size() + n += 1 + l + sovSpecs(uint64(l)) + if m.Type != 0 { + n += 1 + sovSpecs(uint64(m.Type)) + } + if len(m.Tags) > 0 { + for _, s := range m.Tags { + l = len(s) + n += 1 + l + sovSpecs(uint64(l)) + } + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovSpecs(uint64(l)) + } + return n +} + func sovSpecs(x uint64) (n int) { for { n++ @@ -2181,6 +2335,7 @@ func (this *ContainerSpec) String() string { `StopGracePeriod:` + strings.Replace(fmt.Sprintf("%v", this.StopGracePeriod), "Duration", "docker_swarmkit_v11.Duration", 1) + `,`, `PullOptions:` + strings.Replace(fmt.Sprintf("%v", this.PullOptions), "ContainerSpec_PullOptions", "ContainerSpec_PullOptions", 1) + `,`, `Groups:` + fmt.Sprintf("%v", this.Groups) + `,`, + `Secrets:` + strings.Replace(fmt.Sprintf("%v", this.Secrets), "SecretReference", "SecretReference", 1) + `,`, `}`, }, "") return s @@ -2237,6 +2392,19 @@ func (this *ClusterSpec) String() string { }, "") return s } +func (this *SecretSpec) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SecretSpec{`, + `Annotations:` + strings.Replace(strings.Replace(this.Annotations.String(), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `Tags:` + fmt.Sprintf("%v", this.Tags) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `}`, + }, "") + return s +} func valueToStringSpecs(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -3568,6 +3736,37 @@ func (m *ContainerSpec) Unmarshal(data []byte) error { } m.Groups = append(m.Groups, string(data[iNdEx:postIndex])) iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Secrets", 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 + } + m.Secrets = append(m.Secrets, &SecretReference{}) + if err := m.Secrets[len(m.Secrets)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSpecs(data[iNdEx:]) @@ -4234,6 +4433,165 @@ func (m *ClusterSpec) Unmarshal(data []byte) error { } return nil } +func (m *SecretSpec) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSpecs + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SecretSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SecretSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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 err := m.Annotations.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSpecs + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Type |= (SecretType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSpecs + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSpecs + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Tags = append(m.Tags, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSpecs + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthSpecs + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], data[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSpecs(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSpecs + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipSpecs(data []byte) (n int, err error) { l := len(data) iNdEx := 0 @@ -4340,93 +4698,97 @@ var ( ) var fileDescriptorSpecs = []byte{ - // 1397 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x6f, 0xdb, 0xc6, - 0x12, 0x17, 0x6d, 0x5a, 0x96, 0x86, 0x72, 0xa2, 0x2c, 0xf2, 0x87, 0x51, 0xf2, 0x64, 0x45, 0x2f, - 0x2f, 0xcf, 0x79, 0x0f, 0xb5, 0x5b, 0xb5, 0x48, 0x93, 0xa6, 0x45, 0x2b, 0x4b, 0xaa, 0xa3, 0xba, - 0x76, 0x84, 0x75, 0x12, 0xa0, 0x27, 0x61, 0x4d, 0xae, 0x65, 0xc2, 0x14, 0x97, 0x5d, 0x2e, 0x15, - 0xf8, 0xd6, 0x63, 0xe0, 0x43, 0xbf, 0x81, 0x4f, 0x05, 0x7a, 0xec, 0xad, 0xdf, 0x21, 0xc7, 0x1e, - 0x7b, 0x32, 0x6a, 0x5f, 0x7b, 0x29, 0xd0, 0x2f, 0x50, 0xec, 0x72, 0x25, 0x51, 0x0d, 0x9d, 0x04, - 0x68, 0x6e, 0xbb, 0xc3, 0xdf, 0x6f, 0x76, 0x34, 0xf3, 0xdb, 0x99, 0x15, 0x58, 0x51, 0x48, 0x9d, - 0x68, 0x35, 0xe4, 0x4c, 0x30, 0x84, 0x5c, 0xe6, 0x1c, 0x50, 0xbe, 0x1a, 0x3d, 0x27, 0x7c, 0x78, - 0xe0, 0x89, 0xd5, 0xd1, 0x07, 0x15, 0x4b, 0x1c, 0x86, 0x54, 0x03, 0x2a, 0x97, 0x07, 0x6c, 0xc0, - 0xd4, 0x72, 0x4d, 0xae, 0xb4, 0xf5, 0x9a, 0x1b, 0x73, 0x22, 0x3c, 0x16, 0xac, 0x8d, 0x17, 0xc9, - 0x87, 0xfa, 0xf7, 0x26, 0x14, 0xb6, 0x99, 0x4b, 0x77, 0x42, 0xea, 0xa0, 0x0d, 0xb0, 0x48, 0x10, - 0x30, 0xa1, 0x00, 0x91, 0x6d, 0xd4, 0x8c, 0x15, 0xab, 0xb1, 0xbc, 0xfa, 0xea, 0x91, 0xab, 0xcd, - 0x29, 0x6c, 0xdd, 0x7c, 0x79, 0xb2, 0x9c, 0xc3, 0x69, 0x26, 0x7a, 0x1f, 0x4c, 0xce, 0x7c, 0x6a, - 0xcf, 0xd5, 0x8c, 0x95, 0x0b, 0x8d, 0x9b, 0x59, 0x1e, 0xe4, 0xa1, 0x98, 0xf9, 0x14, 0x2b, 0x24, - 0xda, 0x00, 0x18, 0xd2, 0xe1, 0x2e, 0xe5, 0xd1, 0xbe, 0x17, 0xda, 0xf3, 0x8a, 0xf7, 0xdf, 0xf3, - 0x78, 0x32, 0xd8, 0xd5, 0xad, 0x09, 0x1c, 0xa7, 0xa8, 0x68, 0x0b, 0x4a, 0x64, 0x44, 0x3c, 0x9f, - 0xec, 0x7a, 0xbe, 0x27, 0x0e, 0x6d, 0x53, 0xb9, 0xba, 0xfb, 0x5a, 0x57, 0xcd, 0x14, 0x01, 0xcf, - 0xd0, 0xeb, 0x2e, 0xc0, 0xf4, 0x20, 0x74, 0x07, 0x16, 0x7b, 0x9d, 0xed, 0x76, 0x77, 0x7b, 0xa3, - 0x9c, 0xab, 0x5c, 0x3f, 0x3a, 0xae, 0x5d, 0x91, 0x3e, 0xa6, 0x80, 0x1e, 0x0d, 0x5c, 0x2f, 0x18, - 0xa0, 0x15, 0x28, 0x34, 0x5b, 0xad, 0x4e, 0xef, 0x49, 0xa7, 0x5d, 0x36, 0x2a, 0x95, 0xa3, 0xe3, - 0xda, 0xd5, 0x59, 0x60, 0xd3, 0x71, 0x68, 0x28, 0xa8, 0x5b, 0x31, 0x5f, 0xfc, 0x50, 0xcd, 0xd5, - 0x5f, 0x18, 0x50, 0x4a, 0x07, 0x81, 0xee, 0x40, 0xbe, 0xd9, 0x7a, 0xd2, 0x7d, 0xd6, 0x29, 0xe7, - 0xa6, 0xf4, 0x34, 0xa2, 0xe9, 0x08, 0x6f, 0x44, 0xd1, 0x6d, 0x58, 0xe8, 0x35, 0x9f, 0xee, 0x74, - 0xca, 0xc6, 0x34, 0x9c, 0x34, 0xac, 0x47, 0xe2, 0x48, 0xa1, 0xda, 0xb8, 0xd9, 0xdd, 0x2e, 0xcf, - 0x65, 0xa3, 0xda, 0x9c, 0x78, 0x81, 0x0e, 0xe5, 0x74, 0x1e, 0xac, 0x1d, 0xca, 0x47, 0x9e, 0xf3, - 0x8e, 0x35, 0x71, 0x0f, 0x4c, 0x41, 0xa2, 0x03, 0xa5, 0x09, 0x2b, 0x5b, 0x13, 0x4f, 0x48, 0x74, - 0x20, 0x0f, 0xd5, 0x74, 0x85, 0x97, 0xca, 0xe0, 0x34, 0xf4, 0x3d, 0x87, 0x08, 0xea, 0x2a, 0x65, - 0x58, 0x8d, 0xff, 0x64, 0xb1, 0xf1, 0x04, 0xa5, 0xe3, 0x7f, 0x94, 0xc3, 0x29, 0x2a, 0x7a, 0x08, - 0xf9, 0x81, 0xcf, 0x76, 0x89, 0xaf, 0x34, 0x61, 0x35, 0x6e, 0x65, 0x39, 0xd9, 0x50, 0x88, 0xa9, - 0x03, 0x4d, 0x41, 0xf7, 0x21, 0x1f, 0x87, 0x2e, 0x11, 0xd4, 0xce, 0x2b, 0x72, 0x2d, 0x8b, 0xfc, - 0x54, 0x21, 0x5a, 0x2c, 0xd8, 0xf3, 0x06, 0x58, 0xe3, 0xd1, 0x26, 0x14, 0x02, 0x2a, 0x9e, 0x33, - 0x7e, 0x10, 0xd9, 0x8b, 0xb5, 0xf9, 0x15, 0xab, 0xf1, 0xff, 0x4c, 0x31, 0x26, 0x98, 0xa6, 0x10, - 0xc4, 0xd9, 0x1f, 0xd2, 0x40, 0x24, 0x6e, 0xd6, 0xe7, 0x6c, 0x03, 0x4f, 0x1c, 0xa0, 0x4f, 0xa1, - 0x40, 0x03, 0x37, 0x64, 0x5e, 0x20, 0xec, 0xc2, 0xf9, 0x81, 0x74, 0x34, 0x46, 0x26, 0x13, 0x4f, - 0x18, 0xeb, 0x79, 0x30, 0x87, 0xcc, 0xa5, 0xf5, 0x35, 0xb8, 0xf4, 0x4a, 0xb2, 0x50, 0x05, 0x0a, - 0x3a, 0x59, 0x49, 0x95, 0x4d, 0x3c, 0xd9, 0xd7, 0x2f, 0xc2, 0xd2, 0x4c, 0x62, 0xea, 0xbf, 0xcf, - 0x43, 0x61, 0x5c, 0x2d, 0xd4, 0x84, 0xa2, 0xc3, 0x02, 0x41, 0xbc, 0x80, 0x72, 0x2d, 0x90, 0xcc, - 0xdc, 0xb6, 0xc6, 0x20, 0xc9, 0x7a, 0x94, 0xc3, 0x53, 0x16, 0xfa, 0x12, 0x8a, 0x9c, 0x46, 0x2c, - 0xe6, 0x0e, 0x8d, 0xb4, 0x42, 0x56, 0xb2, 0x6b, 0x9c, 0x80, 0x30, 0xfd, 0x36, 0xf6, 0x38, 0x95, - 0x79, 0x8a, 0xf0, 0x94, 0x8a, 0x1e, 0xc2, 0x22, 0xa7, 0x91, 0x20, 0x5c, 0xbc, 0xae, 0xc8, 0x38, - 0x81, 0xf4, 0x98, 0xef, 0x39, 0x87, 0x78, 0xcc, 0x40, 0x0f, 0xa1, 0x18, 0xfa, 0xc4, 0x51, 0x5e, - 0xed, 0x05, 0x45, 0xff, 0x57, 0x16, 0xbd, 0x37, 0x06, 0xe1, 0x29, 0x1e, 0x3d, 0x00, 0xf0, 0xd9, - 0xa0, 0xef, 0x72, 0x6f, 0x44, 0xb9, 0x16, 0x49, 0x25, 0x8b, 0xdd, 0x56, 0x08, 0x5c, 0xf4, 0xd9, - 0x20, 0x59, 0xa2, 0x8d, 0x7f, 0xa4, 0x90, 0x94, 0x3a, 0x36, 0x01, 0xc8, 0xe4, 0xab, 0xd6, 0xc7, - 0xdd, 0xb7, 0x72, 0xa5, 0x2b, 0x92, 0xa2, 0xaf, 0x17, 0x61, 0x91, 0xc7, 0x81, 0xf0, 0x86, 0xb4, - 0xbe, 0x09, 0x57, 0x32, 0x19, 0xa8, 0x01, 0xa5, 0x49, 0x0d, 0xfb, 0x9e, 0xab, 0x8a, 0x5f, 0x5c, - 0xbf, 0x78, 0x76, 0xb2, 0x6c, 0x4d, 0x8a, 0xdd, 0x6d, 0x63, 0x6b, 0x02, 0xea, 0xba, 0xf5, 0x9f, - 0x4c, 0x58, 0x9a, 0x51, 0x02, 0xba, 0x0c, 0x0b, 0xde, 0x90, 0x0c, 0x68, 0x42, 0xc7, 0xc9, 0x06, - 0x75, 0x20, 0xef, 0x93, 0x5d, 0xea, 0x4b, 0x3d, 0xc8, 0x9c, 0xbc, 0xf7, 0x46, 0x49, 0xad, 0x7e, - 0xad, 0xf0, 0x9d, 0x40, 0xf0, 0x43, 0xac, 0xc9, 0xc8, 0x86, 0x45, 0x87, 0x0d, 0x87, 0x24, 0x90, - 0xbd, 0x63, 0x7e, 0xa5, 0x88, 0xc7, 0x5b, 0x84, 0xc0, 0x24, 0x7c, 0x10, 0xd9, 0xa6, 0x32, 0xab, - 0x35, 0x2a, 0xc3, 0x3c, 0x0d, 0x46, 0xf6, 0x82, 0x32, 0xc9, 0xa5, 0xb4, 0xb8, 0x5e, 0x52, 0xd0, - 0x22, 0x96, 0x4b, 0xc9, 0x8b, 0x23, 0xca, 0xed, 0x45, 0x65, 0x52, 0x6b, 0xf4, 0x31, 0xe4, 0x87, - 0x2c, 0x0e, 0x44, 0x64, 0x17, 0x54, 0xb0, 0xd7, 0xb3, 0x82, 0xdd, 0x92, 0x08, 0xdd, 0xdb, 0x34, - 0x1c, 0x3d, 0x82, 0x4b, 0x91, 0x60, 0x61, 0x7f, 0xc0, 0x89, 0x43, 0xfb, 0x21, 0xe5, 0x1e, 0x73, - 0xed, 0xe2, 0xf9, 0x2d, 0xb2, 0xad, 0xc7, 0x37, 0xbe, 0x28, 0x69, 0x1b, 0x92, 0xd5, 0x53, 0x24, - 0xd4, 0x83, 0x52, 0x18, 0xfb, 0x7e, 0x9f, 0x85, 0x49, 0xa7, 0x06, 0xe5, 0xe4, 0x2d, 0xb2, 0xd6, - 0x8b, 0x7d, 0xff, 0x71, 0x42, 0xc2, 0x56, 0x38, 0xdd, 0xa0, 0xab, 0x90, 0x1f, 0x70, 0x16, 0x87, - 0x91, 0x6d, 0xa9, 0x7c, 0xe8, 0x5d, 0xe5, 0x01, 0x58, 0xa9, 0x4c, 0xcb, 0x0c, 0x1d, 0xd0, 0x43, - 0x5d, 0x3c, 0xb9, 0x94, 0x05, 0x1d, 0x11, 0x3f, 0x4e, 0xe6, 0x7f, 0x11, 0x27, 0x9b, 0x4f, 0xe6, - 0xee, 0x1b, 0x95, 0x06, 0x58, 0xa9, 0xe3, 0xd0, 0xbf, 0x61, 0x89, 0xd3, 0x81, 0x17, 0x09, 0x7e, - 0xd8, 0x27, 0xb1, 0xd8, 0xb7, 0xbf, 0x50, 0x84, 0xd2, 0xd8, 0xd8, 0x8c, 0xc5, 0x7e, 0xfd, 0x4f, - 0x03, 0x4a, 0xe9, 0x86, 0x86, 0x5a, 0x49, 0x1b, 0x53, 0x27, 0x5e, 0x68, 0xac, 0xbd, 0xa9, 0x01, - 0xaa, 0xa6, 0xe1, 0xc7, 0xf2, 0xc4, 0x2d, 0xf9, 0xe8, 0x50, 0x64, 0xf4, 0x11, 0x2c, 0x84, 0x8c, - 0x8b, 0xb1, 0xba, 0xaa, 0x99, 0x17, 0x9d, 0xf1, 0xf1, 0x25, 0x4b, 0xc0, 0xf5, 0x7d, 0xb8, 0x30, - 0xeb, 0x0d, 0xdd, 0x86, 0xf9, 0x67, 0xdd, 0x5e, 0x39, 0x57, 0xb9, 0x71, 0x74, 0x5c, 0xbb, 0x36, - 0xfb, 0xf1, 0x99, 0xc7, 0x45, 0x4c, 0xfc, 0x6e, 0x0f, 0xfd, 0x0f, 0x16, 0xda, 0xdb, 0x3b, 0x18, - 0x97, 0x8d, 0xca, 0xf2, 0xd1, 0x71, 0xed, 0xc6, 0x2c, 0x4e, 0x7e, 0x62, 0x71, 0xe0, 0x62, 0xb6, - 0x3b, 0x99, 0xc3, 0x3f, 0xcf, 0x81, 0xa5, 0x2f, 0xdd, 0xbb, 0x9d, 0xc3, 0x9f, 0xc3, 0x52, 0xd2, - 0xa4, 0xfa, 0x8e, 0xfa, 0x69, 0xba, 0xdd, 0xbe, 0xae, 0x57, 0x95, 0x12, 0x42, 0x92, 0x0a, 0x74, - 0x0b, 0x4a, 0x5e, 0x38, 0xba, 0xd7, 0xa7, 0x01, 0xd9, 0xf5, 0xf5, 0x48, 0x2e, 0x60, 0x4b, 0xda, - 0x3a, 0x89, 0x49, 0xce, 0x12, 0x2f, 0x10, 0x94, 0x07, 0x7a, 0xd8, 0x16, 0xf0, 0x64, 0x8f, 0x3e, - 0x03, 0xd3, 0x0b, 0xc9, 0x50, 0x37, 0xd8, 0xcc, 0x5f, 0xd0, 0xed, 0x35, 0xb7, 0xb4, 0x44, 0xd6, - 0x0b, 0x67, 0x27, 0xcb, 0xa6, 0x34, 0x60, 0x45, 0x43, 0xd5, 0x71, 0x8f, 0x93, 0x27, 0xa9, 0x6b, - 0x59, 0xc0, 0x29, 0x4b, 0xfd, 0x47, 0x13, 0xac, 0x96, 0x1f, 0x47, 0x42, 0x37, 0x97, 0x77, 0x96, - 0xb7, 0x6f, 0xe0, 0x12, 0x51, 0xaf, 0x36, 0x12, 0xc8, 0x9b, 0xaa, 0x66, 0x87, 0xce, 0xdd, 0xed, - 0x4c, 0x77, 0x13, 0x70, 0x32, 0x67, 0xd6, 0xf3, 0xd2, 0xa7, 0x6d, 0xe0, 0x32, 0xf9, 0xdb, 0x17, - 0xb4, 0x03, 0x4b, 0x8c, 0x3b, 0xfb, 0x34, 0x12, 0xc9, 0xe5, 0xd6, 0xaf, 0x9c, 0xcc, 0xf7, 0xef, - 0xe3, 0x34, 0x50, 0xbf, 0x11, 0x92, 0x68, 0x67, 0x7d, 0xa0, 0xfb, 0x60, 0x72, 0xb2, 0x37, 0x9e, - 0x83, 0x99, 0xfa, 0xc6, 0x64, 0x4f, 0xcc, 0xb8, 0x50, 0x0c, 0xf4, 0x15, 0x80, 0xeb, 0x45, 0x21, - 0x11, 0xce, 0x3e, 0xe5, 0xba, 0x4e, 0x99, 0x3f, 0xb1, 0x3d, 0x41, 0xcd, 0x78, 0x49, 0xb1, 0xd1, - 0x26, 0x14, 0x1d, 0x32, 0x56, 0x5a, 0xfe, 0xfc, 0xbe, 0xd6, 0x6a, 0x6a, 0x17, 0x65, 0xe9, 0xe2, - 0xec, 0x64, 0xb9, 0x30, 0xb6, 0xe0, 0x82, 0x43, 0xb4, 0xf2, 0x36, 0x61, 0x49, 0x3e, 0x09, 0xfb, - 0x2e, 0xdd, 0x23, 0xb1, 0x2f, 0x22, 0xd5, 0x82, 0xcf, 0x79, 0x02, 0xc9, 0xd7, 0x49, 0x5b, 0xe3, - 0x74, 0x5c, 0x25, 0x91, 0xb6, 0xdd, 0x7c, 0x79, 0x5a, 0xcd, 0xfd, 0x7a, 0x5a, 0xcd, 0xfd, 0x71, - 0x5a, 0x35, 0xbe, 0x3b, 0xab, 0x1a, 0x2f, 0xcf, 0xaa, 0xc6, 0x2f, 0x67, 0x55, 0xe3, 0xb7, 0xb3, - 0xaa, 0xb1, 0x9b, 0x57, 0x7f, 0x8f, 0x3e, 0xfc, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x70, 0x4c, 0x36, - 0xfc, 0x7d, 0x0d, 0x00, 0x00, + // 1470 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x6f, 0xdb, 0xc8, + 0x15, 0x17, 0x6d, 0x5a, 0x96, 0x1e, 0xe5, 0x44, 0x19, 0xe4, 0x0f, 0xa3, 0xa4, 0xb2, 0xa2, 0xa4, + 0xa9, 0xd3, 0xa2, 0x76, 0xab, 0x16, 0x69, 0xd2, 0x34, 0x68, 0xf5, 0xaf, 0x8e, 0xea, 0xda, 0x11, + 0xc6, 0x4e, 0x80, 0x9e, 0x84, 0x31, 0x39, 0x96, 0x09, 0x53, 0x1c, 0x76, 0x38, 0x54, 0xe0, 0x5b, + 0x8f, 0x81, 0x0f, 0xfd, 0x06, 0x3e, 0x15, 0xe8, 0xbd, 0x87, 0x7e, 0x87, 0x1c, 0x7b, 0xec, 0xc9, + 0x58, 0xfb, 0xba, 0x58, 0x60, 0x81, 0xfd, 0x02, 0x8b, 0x19, 0x8e, 0x24, 0x6a, 0x43, 0x27, 0x01, + 0xd6, 0xb7, 0x99, 0xc7, 0xdf, 0xef, 0xcd, 0xe3, 0x7b, 0x3f, 0xbe, 0x37, 0x04, 0x2b, 0x0a, 0xa9, + 0x13, 0xad, 0x87, 0x9c, 0x09, 0x86, 0x90, 0xcb, 0x9c, 0x23, 0xca, 0xd7, 0xa3, 0x77, 0x84, 0x8f, + 0x8e, 0x3c, 0xb1, 0x3e, 0xfe, 0x75, 0xc5, 0x12, 0xc7, 0x21, 0xd5, 0x80, 0xca, 0xcd, 0x21, 0x1b, + 0x32, 0xb5, 0xdc, 0x90, 0x2b, 0x6d, 0xbd, 0xe3, 0xc6, 0x9c, 0x08, 0x8f, 0x05, 0x1b, 0x93, 0x45, + 0xf2, 0xa0, 0xfe, 0x4f, 0x13, 0x0a, 0x3b, 0xcc, 0xa5, 0xbb, 0x21, 0x75, 0xd0, 0x26, 0x58, 0x24, + 0x08, 0x98, 0x50, 0x80, 0xc8, 0x36, 0x6a, 0xc6, 0x9a, 0xd5, 0x58, 0x5d, 0xff, 0xf8, 0xc8, 0xf5, + 0xe6, 0x0c, 0xd6, 0x32, 0x3f, 0x9c, 0xad, 0xe6, 0x70, 0x9a, 0x89, 0x7e, 0x05, 0x26, 0x67, 0x3e, + 0xb5, 0x17, 0x6a, 0xc6, 0xda, 0xb5, 0xc6, 0xfd, 0x2c, 0x0f, 0xf2, 0x50, 0xcc, 0x7c, 0x8a, 0x15, + 0x12, 0x6d, 0x02, 0x8c, 0xe8, 0x68, 0x9f, 0xf2, 0xe8, 0xd0, 0x0b, 0xed, 0x45, 0xc5, 0xfb, 0xd9, + 0x65, 0x3c, 0x19, 0xec, 0xfa, 0xf6, 0x14, 0x8e, 0x53, 0x54, 0xb4, 0x0d, 0x25, 0x32, 0x26, 0x9e, + 0x4f, 0xf6, 0x3d, 0xdf, 0x13, 0xc7, 0xb6, 0xa9, 0x5c, 0x3d, 0xf9, 0xa4, 0xab, 0x66, 0x8a, 0x80, + 0xe7, 0xe8, 0x75, 0x17, 0x60, 0x76, 0x10, 0x7a, 0x0c, 0xcb, 0xfd, 0xee, 0x4e, 0xa7, 0xb7, 0xb3, + 0x59, 0xce, 0x55, 0xee, 0x9e, 0x9c, 0xd6, 0x6e, 0x49, 0x1f, 0x33, 0x40, 0x9f, 0x06, 0xae, 0x17, + 0x0c, 0xd1, 0x1a, 0x14, 0x9a, 0xed, 0x76, 0xb7, 0xbf, 0xd7, 0xed, 0x94, 0x8d, 0x4a, 0xe5, 0xe4, + 0xb4, 0x76, 0x7b, 0x1e, 0xd8, 0x74, 0x1c, 0x1a, 0x0a, 0xea, 0x56, 0xcc, 0xf7, 0xff, 0xaa, 0xe6, + 0xea, 0xef, 0x0d, 0x28, 0xa5, 0x83, 0x40, 0x8f, 0x21, 0xdf, 0x6c, 0xef, 0xf5, 0xde, 0x76, 0xcb, + 0xb9, 0x19, 0x3d, 0x8d, 0x68, 0x3a, 0xc2, 0x1b, 0x53, 0xf4, 0x08, 0x96, 0xfa, 0xcd, 0x37, 0xbb, + 0xdd, 0xb2, 0x31, 0x0b, 0x27, 0x0d, 0xeb, 0x93, 0x38, 0x52, 0xa8, 0x0e, 0x6e, 0xf6, 0x76, 0xca, + 0x0b, 0xd9, 0xa8, 0x0e, 0x27, 0x5e, 0xa0, 0x43, 0x39, 0x5f, 0x04, 0x6b, 0x97, 0xf2, 0xb1, 0xe7, + 0x5c, 0xb1, 0x26, 0x9e, 0x82, 0x29, 0x48, 0x74, 0xa4, 0x34, 0x61, 0x65, 0x6b, 0x62, 0x8f, 0x44, + 0x47, 0xf2, 0x50, 0x4d, 0x57, 0x78, 0xa9, 0x0c, 0x4e, 0x43, 0xdf, 0x73, 0x88, 0xa0, 0xae, 0x52, + 0x86, 0xd5, 0xf8, 0x69, 0x16, 0x1b, 0x4f, 0x51, 0x3a, 0xfe, 0x57, 0x39, 0x9c, 0xa2, 0xa2, 0x17, + 0x90, 0x1f, 0xfa, 0x6c, 0x9f, 0xf8, 0x4a, 0x13, 0x56, 0xe3, 0x41, 0x96, 0x93, 0x4d, 0x85, 0x98, + 0x39, 0xd0, 0x14, 0xf4, 0x0c, 0xf2, 0x71, 0xe8, 0x12, 0x41, 0xed, 0xbc, 0x22, 0xd7, 0xb2, 0xc8, + 0x6f, 0x14, 0xa2, 0xcd, 0x82, 0x03, 0x6f, 0x88, 0x35, 0x1e, 0x6d, 0x41, 0x21, 0xa0, 0xe2, 0x1d, + 0xe3, 0x47, 0x91, 0xbd, 0x5c, 0x5b, 0x5c, 0xb3, 0x1a, 0xbf, 0xc8, 0x14, 0x63, 0x82, 0x69, 0x0a, + 0x41, 0x9c, 0xc3, 0x11, 0x0d, 0x44, 0xe2, 0xa6, 0xb5, 0x60, 0x1b, 0x78, 0xea, 0x00, 0xfd, 0x01, + 0x0a, 0x34, 0x70, 0x43, 0xe6, 0x05, 0xc2, 0x2e, 0x5c, 0x1e, 0x48, 0x57, 0x63, 0x64, 0x32, 0xf1, + 0x94, 0xd1, 0xca, 0x83, 0x39, 0x62, 0x2e, 0xad, 0x6f, 0xc0, 0x8d, 0x8f, 0x92, 0x85, 0x2a, 0x50, + 0xd0, 0xc9, 0x4a, 0xaa, 0x6c, 0xe2, 0xe9, 0xbe, 0x7e, 0x1d, 0x56, 0xe6, 0x12, 0x53, 0xff, 0x7a, + 0x11, 0x0a, 0x93, 0x6a, 0xa1, 0x26, 0x14, 0x1d, 0x16, 0x08, 0xe2, 0x05, 0x94, 0x6b, 0x81, 0x64, + 0xe6, 0xb6, 0x3d, 0x01, 0x49, 0xd6, 0xab, 0x1c, 0x9e, 0xb1, 0xd0, 0x9f, 0xa1, 0xc8, 0x69, 0xc4, + 0x62, 0xee, 0xd0, 0x48, 0x2b, 0x64, 0x2d, 0xbb, 0xc6, 0x09, 0x08, 0xd3, 0xbf, 0xc7, 0x1e, 0xa7, + 0x32, 0x4f, 0x11, 0x9e, 0x51, 0xd1, 0x0b, 0x58, 0xe6, 0x34, 0x12, 0x84, 0x8b, 0x4f, 0x15, 0x19, + 0x27, 0x90, 0x3e, 0xf3, 0x3d, 0xe7, 0x18, 0x4f, 0x18, 0xe8, 0x05, 0x14, 0x43, 0x9f, 0x38, 0xca, + 0xab, 0xbd, 0xa4, 0xe8, 0x3f, 0xc9, 0xa2, 0xf7, 0x27, 0x20, 0x3c, 0xc3, 0xa3, 0xe7, 0x00, 0x3e, + 0x1b, 0x0e, 0x5c, 0xee, 0x8d, 0x29, 0xd7, 0x22, 0xa9, 0x64, 0xb1, 0x3b, 0x0a, 0x81, 0x8b, 0x3e, + 0x1b, 0x26, 0x4b, 0xb4, 0xf9, 0xa3, 0x14, 0x92, 0x52, 0xc7, 0x16, 0x00, 0x99, 0x3e, 0xd5, 0xfa, + 0x78, 0xf2, 0x45, 0xae, 0x74, 0x45, 0x52, 0xf4, 0x56, 0x11, 0x96, 0x79, 0x1c, 0x08, 0x6f, 0x44, + 0xeb, 0x5b, 0x70, 0x2b, 0x93, 0x81, 0x1a, 0x50, 0x9a, 0xd6, 0x70, 0xe0, 0xb9, 0xaa, 0xf8, 0xc5, + 0xd6, 0xf5, 0x8b, 0xb3, 0x55, 0x6b, 0x5a, 0xec, 0x5e, 0x07, 0x5b, 0x53, 0x50, 0xcf, 0xad, 0x7f, + 0x63, 0xc2, 0xca, 0x9c, 0x12, 0xd0, 0x4d, 0x58, 0xf2, 0x46, 0x64, 0x48, 0x13, 0x3a, 0x4e, 0x36, + 0xa8, 0x0b, 0x79, 0x9f, 0xec, 0x53, 0x5f, 0xea, 0x41, 0xe6, 0xe4, 0x97, 0x9f, 0x95, 0xd4, 0xfa, + 0x5f, 0x15, 0xbe, 0x1b, 0x08, 0x7e, 0x8c, 0x35, 0x19, 0xd9, 0xb0, 0xec, 0xb0, 0xd1, 0x88, 0x04, + 0xb2, 0x77, 0x2c, 0xae, 0x15, 0xf1, 0x64, 0x8b, 0x10, 0x98, 0x84, 0x0f, 0x23, 0xdb, 0x54, 0x66, + 0xb5, 0x46, 0x65, 0x58, 0xa4, 0xc1, 0xd8, 0x5e, 0x52, 0x26, 0xb9, 0x94, 0x16, 0xd7, 0x4b, 0x0a, + 0x5a, 0xc4, 0x72, 0x29, 0x79, 0x71, 0x44, 0xb9, 0xbd, 0xac, 0x4c, 0x6a, 0x8d, 0x7e, 0x07, 0xf9, + 0x11, 0x8b, 0x03, 0x11, 0xd9, 0x05, 0x15, 0xec, 0xdd, 0xac, 0x60, 0xb7, 0x25, 0x42, 0xf7, 0x36, + 0x0d, 0x47, 0xaf, 0xe0, 0x46, 0x24, 0x58, 0x38, 0x18, 0x72, 0xe2, 0xd0, 0x41, 0x48, 0xb9, 0xc7, + 0x5c, 0xbb, 0x78, 0x79, 0x8b, 0xec, 0xe8, 0xf1, 0x8d, 0xaf, 0x4b, 0xda, 0xa6, 0x64, 0xf5, 0x15, + 0x09, 0xf5, 0xa1, 0x14, 0xc6, 0xbe, 0x3f, 0x60, 0x61, 0xd2, 0xa9, 0x41, 0x39, 0xf9, 0x82, 0xac, + 0xf5, 0x63, 0xdf, 0x7f, 0x9d, 0x90, 0xb0, 0x15, 0xce, 0x36, 0xe8, 0x36, 0xe4, 0x87, 0x9c, 0xc5, + 0x61, 0x64, 0x5b, 0x2a, 0x1f, 0x7a, 0x87, 0x5e, 0xc2, 0x72, 0x44, 0x1d, 0x4e, 0x45, 0x64, 0x97, + 0xd4, 0xdb, 0x3e, 0xcc, 0x3a, 0x64, 0x57, 0x41, 0x30, 0x3d, 0xa0, 0x9c, 0x06, 0x0e, 0xc5, 0x13, + 0x4e, 0xe5, 0x39, 0x58, 0xa9, 0x42, 0xc9, 0x04, 0x1f, 0xd1, 0x63, 0x5d, 0x7b, 0xb9, 0x94, 0x7a, + 0x18, 0x13, 0x3f, 0x4e, 0xae, 0x0f, 0x45, 0x9c, 0x6c, 0x7e, 0xbf, 0xf0, 0xcc, 0xa8, 0x34, 0xc0, + 0x4a, 0x45, 0x8b, 0x1e, 0xc2, 0x0a, 0xa7, 0x43, 0x2f, 0x12, 0xfc, 0x78, 0x40, 0x62, 0x71, 0x68, + 0xff, 0x49, 0x11, 0x4a, 0x13, 0x63, 0x33, 0x16, 0x87, 0xf5, 0xef, 0x0c, 0x28, 0xa5, 0xfb, 0x21, + 0x6a, 0x27, 0x5d, 0x50, 0x9d, 0x78, 0xad, 0xb1, 0xf1, 0xb9, 0xfe, 0xa9, 0x7a, 0x8e, 0x1f, 0xcb, + 0x13, 0xb7, 0xe5, 0x9d, 0x45, 0x91, 0xd1, 0x6f, 0x61, 0x29, 0x64, 0x5c, 0x4c, 0xc4, 0x59, 0xcd, + 0xec, 0x13, 0x8c, 0x4f, 0xbe, 0xd1, 0x04, 0x5c, 0x3f, 0x84, 0x6b, 0xf3, 0xde, 0xd0, 0x23, 0x58, + 0x7c, 0xdb, 0xeb, 0x97, 0x73, 0x95, 0x7b, 0x27, 0xa7, 0xb5, 0x3b, 0xf3, 0x0f, 0xdf, 0x7a, 0x5c, + 0xc4, 0xc4, 0xef, 0xf5, 0xd1, 0xcf, 0x61, 0xa9, 0xb3, 0xb3, 0x8b, 0x71, 0xd9, 0xa8, 0xac, 0x9e, + 0x9c, 0xd6, 0xee, 0xcd, 0xe3, 0xe4, 0x23, 0x16, 0x07, 0x2e, 0x66, 0xfb, 0xd3, 0x31, 0xfe, 0xdf, + 0x05, 0xb0, 0xf4, 0x37, 0x7b, 0xb5, 0x63, 0xfc, 0x8f, 0xb0, 0x92, 0xf4, 0xb8, 0x81, 0xa3, 0x5e, + 0x4d, 0x77, 0xeb, 0x4f, 0xb5, 0xba, 0x52, 0x42, 0x48, 0x52, 0x81, 0x1e, 0x40, 0xc9, 0x0b, 0xc7, + 0x4f, 0x07, 0x34, 0x20, 0xfb, 0xbe, 0x9e, 0xe8, 0x05, 0x6c, 0x49, 0x5b, 0x37, 0x31, 0xc9, 0x51, + 0xe4, 0x05, 0x82, 0xf2, 0x40, 0xcf, 0xea, 0x02, 0x9e, 0xee, 0xd1, 0x4b, 0x30, 0xbd, 0x90, 0x8c, + 0x74, 0x7f, 0xce, 0x7c, 0x83, 0x5e, 0xbf, 0xb9, 0xad, 0x25, 0xd2, 0x2a, 0x5c, 0x9c, 0xad, 0x9a, + 0xd2, 0x80, 0x15, 0x0d, 0x55, 0x27, 0x2d, 0x52, 0x9e, 0xa4, 0xbe, 0xea, 0x02, 0x4e, 0x59, 0xea, + 0xff, 0x36, 0xc1, 0x6a, 0xfb, 0x71, 0x24, 0x74, 0x6f, 0xba, 0xb2, 0xbc, 0xfd, 0x0d, 0x6e, 0x10, + 0x75, 0xe9, 0x23, 0x81, 0xfc, 0xd0, 0xd5, 0xe8, 0xd1, 0xb9, 0x7b, 0x94, 0xe9, 0x6e, 0x0a, 0x4e, + 0xc6, 0x54, 0x2b, 0x2f, 0x7d, 0xda, 0x06, 0x2e, 0x93, 0x1f, 0x3c, 0x41, 0xbb, 0xb0, 0xc2, 0xb8, + 0x73, 0x48, 0x23, 0x91, 0xf4, 0x06, 0x7d, 0x49, 0xca, 0xbc, 0x3e, 0xbf, 0x4e, 0x03, 0xf5, 0x15, + 0x23, 0x89, 0x76, 0xde, 0x07, 0x7a, 0x06, 0x26, 0x27, 0x07, 0x93, 0x31, 0x9a, 0xa9, 0x6f, 0x4c, + 0x0e, 0xc4, 0x9c, 0x0b, 0xc5, 0x40, 0x7f, 0x01, 0x70, 0xbd, 0x28, 0x24, 0xc2, 0x39, 0xa4, 0x5c, + 0xd7, 0x29, 0xf3, 0x15, 0x3b, 0x53, 0xd4, 0x9c, 0x97, 0x14, 0x1b, 0x6d, 0x41, 0xd1, 0x21, 0x13, + 0xa5, 0xe5, 0x2f, 0x6f, 0x8b, 0xed, 0xa6, 0x76, 0x51, 0x96, 0x2e, 0x2e, 0xce, 0x56, 0x0b, 0x13, + 0x0b, 0x2e, 0x38, 0x44, 0x2b, 0x6f, 0x0b, 0x56, 0xe4, 0x8d, 0x72, 0xe0, 0xd2, 0x03, 0x12, 0xfb, + 0x22, 0x52, 0x1d, 0xfc, 0x92, 0x1b, 0x94, 0xbc, 0xdc, 0x74, 0x34, 0x4e, 0xc7, 0x55, 0x12, 0x29, + 0x5b, 0xfd, 0x3f, 0x06, 0x40, 0xd2, 0xe2, 0xae, 0x56, 0x27, 0x0d, 0x30, 0xe5, 0xef, 0x9c, 0xfe, + 0x75, 0xaa, 0x5e, 0xde, 0x59, 0xf7, 0x8e, 0x43, 0x8a, 0x15, 0x56, 0x4e, 0x24, 0x41, 0x86, 0x91, + 0x1e, 0x70, 0x6a, 0x2d, 0x6d, 0x2e, 0x11, 0x44, 0xd5, 0xaf, 0x84, 0xd5, 0xba, 0x75, 0xff, 0xc3, + 0x79, 0x35, 0xf7, 0xff, 0xf3, 0x6a, 0xee, 0xdb, 0xf3, 0xaa, 0xf1, 0x8f, 0x8b, 0xaa, 0xf1, 0xe1, + 0xa2, 0x6a, 0xfc, 0xef, 0xa2, 0x6a, 0x7c, 0x75, 0x51, 0x35, 0xf6, 0xf3, 0xea, 0x8f, 0xf0, 0x37, + 0xdf, 0x07, 0x00, 0x00, 0xff, 0xff, 0x1e, 0xd5, 0xdd, 0x17, 0x70, 0x0e, 0x00, 0x00, } diff --git a/api/specs.proto b/api/specs.proto index 9f51ec5979..25288ce6ec 100644 --- a/api/specs.proto +++ b/api/specs.proto @@ -188,6 +188,10 @@ message ContainerSpec { // PullOptions parameterize the behavior of image pulls. PullOptions pull_options = 10; + + // SecretReference contains references to zero or more secrets that + // will be exposed to the container. + repeated SecretReference secrets = 12; } // EndpointSpec defines the properties that can be configured to @@ -271,3 +275,17 @@ message ClusterSpec { // TaskDefaults specifies the default values to use for task creation. TaskDefaults task_defaults = 7 [(gogoproto.nullable) = false]; } + +// SecretSpec specifies a user-provided secret. +message SecretSpec { + Annotations annotations = 1 [(gogoproto.nullable) = false]; + + // Type distinguishes the different kinds of secrets in the system. + SecretType type = 2; + + // Tags group secrets. + repeated string tags = 3; + + // Secret payload. + bytes data = 4; +} diff --git a/api/types.pb.go b/api/types.pb.go index dbd8286cdc..90d0e49bf6 100644 --- a/api/types.pb.go +++ b/api/types.pb.go @@ -56,6 +56,7 @@ Certificate EncryptionKey ManagerStatus + SecretReference NodeSpec ServiceSpec ReplicatedService @@ -66,6 +67,7 @@ EndpointSpec NetworkSpec ClusterSpec + SecretSpec Meta Node Service @@ -74,6 +76,7 @@ NetworkAttachment Network Cluster + Secret GetNodeRequest GetNodeResponse ListNodesRequest @@ -121,6 +124,8 @@ UpdateTaskStatusResponse TasksRequest TasksMessage + AssignmentsRequest + AssignmentsMessage NodeCertificateStatusRequest NodeCertificateStatusResponse IssueNodeCertificateRequest @@ -255,6 +260,28 @@ func (x NodeRole) String() string { } func (NodeRole) EnumDescriptor() ([]byte, []int) { return fileDescriptorTypes, []int{1} } +// SecretType provides information about what kind of secret this is +type SecretType int32 + +const ( + SecretType_ContainerSecret SecretType = 0 + SecretType_NodeSecret SecretType = 1 +) + +var SecretType_name = map[int32]string{ + 0: "CONTAINER", + 1: "NODE", +} +var SecretType_value = map[string]int32{ + "CONTAINER": 0, + "NODE": 1, +} + +func (x SecretType) String() string { + return proto.EnumName(SecretType_name, int32(x)) +} +func (SecretType) EnumDescriptor() ([]byte, []int) { return fileDescriptorTypes, []int{2} } + type RaftMemberStatus_Reachability int32 const ( @@ -575,6 +602,28 @@ func (EncryptionKey_Algorithm) EnumDescriptor() ([]byte, []int) { return fileDescriptorTypes, []int{36, 0} } +// Mode specifies how this secret should be exposed inside the task. +type SecretReference_Mode int32 + +const ( + SecretReference_FILE SecretReference_Mode = 0 + SecretReference_ENV SecretReference_Mode = 1 +) + +var SecretReference_Mode_name = map[int32]string{ + 0: "FILE", + 1: "ENV", +} +var SecretReference_Mode_value = map[string]int32{ + "FILE": 0, + "ENV": 1, +} + +func (x SecretReference_Mode) String() string { + return proto.EnumName(SecretReference_Mode_name, int32(x)) +} +func (SecretReference_Mode) EnumDescriptor() ([]byte, []int) { return fileDescriptorTypes, []int{38, 0} } + // Version tracks the last time an object in the store was updated. type Version struct { Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` @@ -1287,6 +1336,20 @@ func (m *ManagerStatus) Reset() { *m = ManagerStatus{} } func (*ManagerStatus) ProtoMessage() {} func (*ManagerStatus) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{37} } +// SecretReference is the linkage between a service and a secret that it uses. +type SecretReference struct { + // Name is the name of the secret that this reference. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Mode is one or more ways the secret should be presented. + Mode []SecretReference_Mode `protobuf:"varint,2,rep,name=mode,enum=docker.swarmkit.v1.SecretReference_Mode" json:"mode,omitempty"` + // Target is the name by which the image accesses the secret. + Target string `protobuf:"bytes,3,opt,name=target,proto3" json:"target,omitempty"` +} + +func (m *SecretReference) Reset() { *m = SecretReference{} } +func (*SecretReference) ProtoMessage() {} +func (*SecretReference) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{38} } + func init() { proto.RegisterType((*Version)(nil), "docker.swarmkit.v1.Version") proto.RegisterType((*Annotations)(nil), "docker.swarmkit.v1.Annotations") @@ -1331,8 +1394,10 @@ func init() { proto.RegisterType((*Certificate)(nil), "docker.swarmkit.v1.Certificate") proto.RegisterType((*EncryptionKey)(nil), "docker.swarmkit.v1.EncryptionKey") proto.RegisterType((*ManagerStatus)(nil), "docker.swarmkit.v1.ManagerStatus") + proto.RegisterType((*SecretReference)(nil), "docker.swarmkit.v1.SecretReference") proto.RegisterEnum("docker.swarmkit.v1.TaskState", TaskState_name, TaskState_value) proto.RegisterEnum("docker.swarmkit.v1.NodeRole", NodeRole_name, NodeRole_value) + proto.RegisterEnum("docker.swarmkit.v1.SecretType", SecretType_name, SecretType_value) proto.RegisterEnum("docker.swarmkit.v1.RaftMemberStatus_Reachability", RaftMemberStatus_Reachability_name, RaftMemberStatus_Reachability_value) proto.RegisterEnum("docker.swarmkit.v1.NodeStatus_State", NodeStatus_State_name, NodeStatus_State_value) proto.RegisterEnum("docker.swarmkit.v1.Mount_MountType", Mount_MountType_name, Mount_MountType_value) @@ -1345,6 +1410,7 @@ func init() { proto.RegisterEnum("docker.swarmkit.v1.IssuanceStatus_State", IssuanceStatus_State_name, IssuanceStatus_State_value) proto.RegisterEnum("docker.swarmkit.v1.ExternalCA_CAProtocol", ExternalCA_CAProtocol_name, ExternalCA_CAProtocol_value) proto.RegisterEnum("docker.swarmkit.v1.EncryptionKey_Algorithm", EncryptionKey_Algorithm_name, EncryptionKey_Algorithm_value) + proto.RegisterEnum("docker.swarmkit.v1.SecretReference_Mode", SecretReference_Mode_name, SecretReference_Mode_value) } func (m *Version) Copy() *Version { @@ -2021,6 +2087,26 @@ func (m *ManagerStatus) Copy() *ManagerStatus { return o } +func (m *SecretReference) Copy() *SecretReference { + if m == nil { + return nil + } + + o := &SecretReference{ + Name: m.Name, + Target: m.Target, + } + + if m.Mode != nil { + o.Mode = make([]SecretReference_Mode, 0, len(m.Mode)) + for _, v := range m.Mode { + o.Mode = append(o.Mode, v) + } + } + + return o +} + func (this *Version) GoString() string { if this == nil { return "nil" @@ -2655,6 +2741,18 @@ func (this *ManagerStatus) GoString() string { s = append(s, "}") return strings.Join(s, "") } +func (this *SecretReference) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&api.SecretReference{") + s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") + s = append(s, "Mode: "+fmt.Sprintf("%#v", this.Mode)+",\n") + s = append(s, "Target: "+fmt.Sprintf("%#v", this.Target)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} func valueToGoStringTypes(v interface{}, typ string) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -4358,6 +4456,43 @@ func (m *ManagerStatus) MarshalTo(data []byte) (int, error) { return i, nil } +func (m *SecretReference) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *SecretReference) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintTypes(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if len(m.Mode) > 0 { + for _, num := range m.Mode { + data[i] = 0x10 + i++ + i = encodeVarintTypes(data, i, uint64(num)) + } + } + if len(m.Target) > 0 { + data[i] = 0x1a + i++ + i = encodeVarintTypes(data, i, uint64(len(m.Target))) + i += copy(data[i:], m.Target) + } + return i, nil +} + func encodeFixed64Types(data []byte, offset int, v uint64) int { data[offset] = uint8(v) data[offset+1] = uint8(v >> 8) @@ -5111,6 +5246,25 @@ func (m *ManagerStatus) Size() (n int) { return n } +func (m *SecretReference) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if len(m.Mode) > 0 { + for _, e := range m.Mode { + n += 1 + sovTypes(uint64(e)) + } + } + l = len(m.Target) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + func sovTypes(x uint64) (n int) { for { n++ @@ -5698,6 +5852,18 @@ func (this *ManagerStatus) String() string { }, "") return s } +func (this *SecretReference) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SecretReference{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Mode:` + fmt.Sprintf("%v", this.Mode) + `,`, + `Target:` + fmt.Sprintf("%v", this.Target) + `,`, + `}`, + }, "") + return s +} func valueToStringTypes(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -11442,6 +11608,134 @@ func (m *ManagerStatus) Unmarshal(data []byte) error { } return nil } +func (m *SecretReference) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SecretReference: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SecretReference: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) + } + var v SecretReference_Mode + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (SecretReference_Mode(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Mode = append(m.Mode, v) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Target = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTypes(data []byte) (n int, err error) { l := len(data) iNdEx := 0 @@ -11548,221 +11842,227 @@ var ( ) var fileDescriptorTypes = []byte{ - // 3442 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x59, 0x4d, 0x6c, 0x1b, 0x49, - 0x76, 0x16, 0x7f, 0x45, 0x3e, 0x52, 0x72, 0xbb, 0xec, 0xf5, 0xc8, 0x1c, 0x8f, 0xc4, 0x69, 0x8f, - 0x77, 0xbc, 0xb3, 0x13, 0xce, 0x8c, 0x66, 0x13, 0x78, 0xc7, 0xc9, 0xce, 0xb4, 0x48, 0xca, 0xe6, - 0x5a, 0xa2, 0x88, 0x22, 0x69, 0x63, 0x10, 0x20, 0x44, 0xa9, 0xbb, 0x44, 0xf6, 0xa8, 0xd9, 0xc5, - 0x74, 0x17, 0x25, 0x33, 0x41, 0x00, 0x27, 0x97, 0x04, 0x3a, 0xe5, 0x1e, 0x08, 0x8b, 0x20, 0x41, - 0x6e, 0x39, 0xe4, 0x14, 0x20, 0x27, 0x1f, 0xe7, 0xb8, 0x41, 0x80, 0x60, 0x91, 0x00, 0x42, 0x46, - 0x39, 0xe6, 0xb2, 0x40, 0x0e, 0x7b, 0x48, 0x0e, 0x41, 0xfd, 0x74, 0xf3, 0xc7, 0xb4, 0xc6, 0x93, - 0xdd, 0x13, 0xbb, 0x5e, 0x7d, 0xef, 0xd5, 0xab, 0xaa, 0x57, 0xaf, 0xbe, 0x57, 0x84, 0x02, 0x9f, - 0x8c, 0x68, 0x58, 0x19, 0x05, 0x8c, 0x33, 0x84, 0x1c, 0x66, 0x1f, 0xd3, 0xa0, 0x12, 0x9e, 0x92, - 0x60, 0x78, 0xec, 0xf2, 0xca, 0xc9, 0x27, 0xa5, 0xdb, 0xdc, 0x1d, 0xd2, 0x90, 0x93, 0xe1, 0xe8, - 0xa3, 0xf8, 0x4b, 0xc1, 0x4b, 0x6f, 0x39, 0xe3, 0x80, 0x70, 0x97, 0xf9, 0x1f, 0x45, 0x1f, 0xba, - 0xe3, 0x66, 0x9f, 0xf5, 0x99, 0xfc, 0xfc, 0x48, 0x7c, 0x29, 0xa9, 0xb9, 0x05, 0xab, 0x4f, 0x69, - 0x10, 0xba, 0xcc, 0x47, 0x37, 0x21, 0xe3, 0xfa, 0x0e, 0x7d, 0xbe, 0x91, 0x28, 0x27, 0xee, 0xa7, - 0xb1, 0x6a, 0x98, 0x7f, 0x9d, 0x80, 0x82, 0xe5, 0xfb, 0x8c, 0x4b, 0x5b, 0x21, 0x42, 0x90, 0xf6, - 0xc9, 0x90, 0x4a, 0x50, 0x1e, 0xcb, 0x6f, 0x54, 0x85, 0xac, 0x47, 0x0e, 0xa9, 0x17, 0x6e, 0x24, - 0xcb, 0xa9, 0xfb, 0x85, 0xed, 0x1f, 0x56, 0x5e, 0xf5, 0xb9, 0x32, 0x63, 0xa4, 0xb2, 0x27, 0xd1, - 0x75, 0x9f, 0x07, 0x13, 0xac, 0x55, 0x4b, 0x3f, 0x86, 0xc2, 0x8c, 0x18, 0x19, 0x90, 0x3a, 0xa6, - 0x13, 0x3d, 0x8c, 0xf8, 0x14, 0xfe, 0x9d, 0x10, 0x6f, 0x4c, 0x37, 0x92, 0x52, 0xa6, 0x1a, 0x9f, - 0x25, 0x1f, 0x24, 0xcc, 0x2f, 0x21, 0x8f, 0x69, 0xc8, 0xc6, 0x81, 0x4d, 0x43, 0xf4, 0x03, 0xc8, - 0xfb, 0xc4, 0x67, 0x3d, 0x7b, 0x34, 0x0e, 0xa5, 0x7a, 0x6a, 0xa7, 0x78, 0x79, 0xb1, 0x95, 0x6b, - 0x12, 0x9f, 0x55, 0x5b, 0xdd, 0x10, 0xe7, 0x44, 0x77, 0x75, 0x34, 0x0e, 0xd1, 0xbb, 0x50, 0x1c, - 0xd2, 0x21, 0x0b, 0x26, 0xbd, 0xc3, 0x09, 0xa7, 0xa1, 0x34, 0x9c, 0xc2, 0x05, 0x25, 0xdb, 0x11, - 0x22, 0xf3, 0x2f, 0x13, 0x70, 0x33, 0xb2, 0x8d, 0xe9, 0x1f, 0x8e, 0xdd, 0x80, 0x0e, 0xa9, 0xcf, - 0x43, 0xf4, 0xdb, 0x90, 0xf5, 0xdc, 0xa1, 0xcb, 0xd5, 0x18, 0x85, 0xed, 0x77, 0x96, 0xcd, 0x39, - 0xf6, 0x0a, 0x6b, 0x30, 0xb2, 0xa0, 0x18, 0xd0, 0x90, 0x06, 0x27, 0x6a, 0x25, 0xe4, 0x90, 0xdf, - 0xaa, 0x3c, 0xa7, 0x62, 0xee, 0x42, 0xae, 0xe5, 0x11, 0x7e, 0xc4, 0x82, 0x21, 0x32, 0xa1, 0x48, - 0x02, 0x7b, 0xe0, 0x72, 0x6a, 0xf3, 0x71, 0x10, 0xed, 0xca, 0x9c, 0x0c, 0xdd, 0x82, 0x24, 0x53, - 0x03, 0xe5, 0x77, 0xb2, 0x97, 0x17, 0x5b, 0xc9, 0x83, 0x36, 0x4e, 0xb2, 0xd0, 0x7c, 0x08, 0xd7, - 0x5b, 0xde, 0xb8, 0xef, 0xfa, 0x35, 0x1a, 0xda, 0x81, 0x3b, 0x12, 0xd6, 0xc5, 0xf6, 0x8a, 0xe0, - 0x8b, 0xb6, 0x57, 0x7c, 0xc7, 0x5b, 0x9e, 0x9c, 0x6e, 0xb9, 0xf9, 0xe7, 0x49, 0xb8, 0x5e, 0xf7, - 0xfb, 0xae, 0x4f, 0x67, 0xb5, 0xef, 0xc1, 0x3a, 0x95, 0xc2, 0xde, 0x89, 0x0a, 0x2a, 0x6d, 0x67, - 0x4d, 0x49, 0xa3, 0x48, 0x6b, 0x2c, 0xc4, 0xcb, 0x27, 0xcb, 0xa6, 0xff, 0x8a, 0xf5, 0x65, 0x51, - 0x83, 0xea, 0xb0, 0x3a, 0x92, 0x93, 0x08, 0x37, 0x52, 0xd2, 0xd6, 0xbd, 0x65, 0xb6, 0x5e, 0x99, - 0xe7, 0x4e, 0xfa, 0xeb, 0x8b, 0xad, 0x15, 0x1c, 0xe9, 0xfe, 0x3a, 0xc1, 0xf7, 0x9f, 0x09, 0xb8, - 0xd6, 0x64, 0xce, 0xdc, 0x3a, 0x94, 0x20, 0x37, 0x60, 0x21, 0x9f, 0x39, 0x28, 0x71, 0x1b, 0x3d, - 0x80, 0xdc, 0x48, 0x6f, 0x9f, 0xde, 0xfd, 0x3b, 0xcb, 0x5d, 0x56, 0x18, 0x1c, 0xa3, 0xd1, 0x43, - 0xc8, 0x07, 0x51, 0x4c, 0x6c, 0xa4, 0xde, 0x24, 0x70, 0xa6, 0x78, 0xf4, 0x7b, 0x90, 0x55, 0x9b, - 0xb0, 0x91, 0x96, 0x9a, 0xf7, 0xde, 0x68, 0xcd, 0xb1, 0x56, 0x32, 0x7f, 0x91, 0x00, 0x03, 0x93, - 0x23, 0xbe, 0x4f, 0x87, 0x87, 0x34, 0x68, 0x73, 0xc2, 0xc7, 0x21, 0xba, 0x05, 0x59, 0x8f, 0x12, - 0x87, 0x06, 0x72, 0x92, 0x39, 0xac, 0x5b, 0xa8, 0x2b, 0x82, 0x9c, 0xd8, 0x03, 0x72, 0xe8, 0x7a, - 0x2e, 0x9f, 0xc8, 0x69, 0xae, 0x2f, 0xdf, 0xe5, 0x45, 0x9b, 0x15, 0x3c, 0xa3, 0x88, 0xe7, 0xcc, - 0xa0, 0x0d, 0x58, 0x1d, 0xd2, 0x30, 0x24, 0x7d, 0x2a, 0x67, 0x9f, 0xc7, 0x51, 0xd3, 0x7c, 0x08, - 0xc5, 0x59, 0x3d, 0x54, 0x80, 0xd5, 0x6e, 0xf3, 0x49, 0xf3, 0xe0, 0x59, 0xd3, 0x58, 0x41, 0xd7, - 0xa0, 0xd0, 0x6d, 0xe2, 0xba, 0x55, 0x7d, 0x6c, 0xed, 0xec, 0xd5, 0x8d, 0x04, 0x5a, 0x83, 0xfc, - 0xb4, 0x99, 0x34, 0x7f, 0x96, 0x00, 0x10, 0x1b, 0xa8, 0x27, 0xf5, 0x19, 0x64, 0x42, 0x4e, 0xb8, - 0xda, 0xb8, 0xf5, 0xed, 0xf7, 0x96, 0x79, 0x3d, 0x85, 0x57, 0xc4, 0x0f, 0xc5, 0x4a, 0x65, 0xd6, - 0xc3, 0xe4, 0xa2, 0x87, 0x19, 0x89, 0x9c, 0x77, 0x2d, 0x07, 0xe9, 0x9a, 0xf8, 0x4a, 0xa0, 0x3c, - 0x64, 0x70, 0xdd, 0xaa, 0x7d, 0x69, 0x24, 0x91, 0x01, 0xc5, 0x5a, 0xa3, 0x5d, 0x3d, 0x68, 0x36, - 0xeb, 0xd5, 0x4e, 0xbd, 0x66, 0xa4, 0xcc, 0x7b, 0x90, 0x69, 0x0c, 0x49, 0x9f, 0xa2, 0x3b, 0x22, - 0x02, 0x8e, 0x68, 0x40, 0x7d, 0x3b, 0x0a, 0xac, 0xa9, 0xc0, 0xfc, 0x79, 0x1e, 0x32, 0xfb, 0x6c, - 0xec, 0x73, 0xb4, 0x3d, 0x73, 0x8a, 0xd7, 0xb7, 0x37, 0x97, 0x4d, 0x41, 0x02, 0x2b, 0x9d, 0xc9, - 0x88, 0xea, 0x53, 0x7e, 0x0b, 0xb2, 0x2a, 0x56, 0xb4, 0xeb, 0xba, 0x25, 0xe4, 0x9c, 0x04, 0x7d, - 0xca, 0xf5, 0xa2, 0xeb, 0x16, 0xba, 0x0f, 0xb9, 0x80, 0x12, 0x87, 0xf9, 0xde, 0x44, 0x86, 0x54, - 0x4e, 0xa5, 0x59, 0x4c, 0x89, 0x73, 0xe0, 0x7b, 0x13, 0x1c, 0xf7, 0xa2, 0xc7, 0x50, 0x3c, 0x74, - 0x7d, 0xa7, 0xc7, 0x46, 0x2a, 0xe7, 0x65, 0x5e, 0x1f, 0x80, 0xca, 0xab, 0x1d, 0xd7, 0x77, 0x0e, - 0x14, 0x18, 0x17, 0x0e, 0xa7, 0x0d, 0xd4, 0x84, 0xf5, 0x13, 0xe6, 0x8d, 0x87, 0x34, 0xb6, 0x95, - 0x95, 0xb6, 0xde, 0x7f, 0xbd, 0xad, 0xa7, 0x12, 0x1f, 0x59, 0x5b, 0x3b, 0x99, 0x6d, 0xa2, 0x27, - 0xb0, 0xc6, 0x87, 0xa3, 0xa3, 0x30, 0x36, 0xb7, 0x2a, 0xcd, 0x7d, 0xff, 0x8a, 0x05, 0x13, 0xf0, - 0xc8, 0x5a, 0x91, 0xcf, 0xb4, 0x4a, 0x7f, 0x96, 0x82, 0xc2, 0x8c, 0xe7, 0xa8, 0x0d, 0x85, 0x51, - 0xc0, 0x46, 0xa4, 0x2f, 0xf3, 0xb6, 0xde, 0x8b, 0x4f, 0xde, 0x68, 0xd6, 0x95, 0xd6, 0x54, 0x11, - 0xcf, 0x5a, 0x31, 0xcf, 0x93, 0x50, 0x98, 0xe9, 0x44, 0x1f, 0x40, 0x0e, 0xb7, 0x70, 0xe3, 0xa9, - 0xd5, 0xa9, 0x1b, 0x2b, 0xa5, 0x3b, 0x67, 0xe7, 0xe5, 0x0d, 0x69, 0x6d, 0xd6, 0x40, 0x2b, 0x70, - 0x4f, 0x44, 0xe8, 0xdd, 0x87, 0xd5, 0x08, 0x9a, 0x28, 0xbd, 0x7d, 0x76, 0x5e, 0x7e, 0x6b, 0x11, - 0x3a, 0x83, 0xc4, 0xed, 0xc7, 0x16, 0xae, 0xd7, 0x8c, 0xe4, 0x72, 0x24, 0x6e, 0x0f, 0x48, 0x40, - 0x1d, 0xf4, 0x7d, 0xc8, 0x6a, 0x60, 0xaa, 0x54, 0x3a, 0x3b, 0x2f, 0xdf, 0x5a, 0x04, 0x4e, 0x71, - 0xb8, 0xbd, 0x67, 0x3d, 0xad, 0x1b, 0xe9, 0xe5, 0x38, 0xdc, 0xf6, 0xc8, 0x09, 0x45, 0xef, 0x41, - 0x46, 0xc1, 0x32, 0xa5, 0xdb, 0x67, 0xe7, 0xe5, 0xef, 0xbd, 0x62, 0x4e, 0xa0, 0x4a, 0x1b, 0x7f, - 0xf1, 0x37, 0x9b, 0x2b, 0xff, 0xf4, 0xb7, 0x9b, 0xc6, 0x62, 0x77, 0xe9, 0x7f, 0x13, 0xb0, 0x36, - 0xb7, 0xe5, 0xc8, 0x84, 0xac, 0xcf, 0x6c, 0x36, 0x52, 0xe9, 0x3c, 0xb7, 0x03, 0x97, 0x17, 0x5b, - 0xd9, 0x26, 0xab, 0xb2, 0xd1, 0x04, 0xeb, 0x1e, 0xf4, 0x64, 0xe1, 0x42, 0xfa, 0xf4, 0x0d, 0xe3, - 0x69, 0xe9, 0x95, 0xf4, 0x39, 0xac, 0x39, 0x81, 0x7b, 0x42, 0x83, 0x9e, 0xcd, 0xfc, 0x23, 0xb7, - 0xaf, 0x53, 0x75, 0x69, 0x99, 0xcd, 0x9a, 0x04, 0xe2, 0xa2, 0x52, 0xa8, 0x4a, 0xfc, 0xaf, 0x71, - 0x19, 0x95, 0x9e, 0x42, 0x71, 0x36, 0x42, 0xd1, 0x3b, 0x00, 0xa1, 0xfb, 0x47, 0x54, 0xf3, 0x1b, - 0xc9, 0x86, 0x70, 0x5e, 0x48, 0x24, 0xbb, 0x41, 0xef, 0x43, 0x7a, 0xc8, 0x1c, 0x65, 0x27, 0xb3, - 0x73, 0x43, 0xdc, 0x89, 0xff, 0x76, 0xb1, 0x55, 0x60, 0x61, 0x65, 0xd7, 0xf5, 0xe8, 0x3e, 0x73, - 0x28, 0x96, 0x00, 0xf3, 0x04, 0xd2, 0x22, 0x55, 0xa0, 0xb7, 0x21, 0xbd, 0xd3, 0x68, 0xd6, 0x8c, - 0x95, 0xd2, 0xf5, 0xb3, 0xf3, 0xf2, 0x9a, 0x5c, 0x12, 0xd1, 0x21, 0x62, 0x17, 0x6d, 0x41, 0xf6, - 0xe9, 0xc1, 0x5e, 0x77, 0x5f, 0x84, 0xd7, 0x8d, 0xb3, 0xf3, 0xf2, 0xb5, 0xb8, 0x5b, 0x2d, 0x1a, - 0x7a, 0x07, 0x32, 0x9d, 0xfd, 0xd6, 0x6e, 0xdb, 0x48, 0x96, 0xd0, 0xd9, 0x79, 0x79, 0x3d, 0xee, - 0x97, 0x3e, 0x97, 0xae, 0xeb, 0x5d, 0xcd, 0xc7, 0x72, 0xf3, 0x7f, 0x92, 0xb0, 0x86, 0x05, 0xbf, - 0x0d, 0x78, 0x8b, 0x79, 0xae, 0x3d, 0x41, 0x2d, 0xc8, 0xdb, 0xcc, 0x77, 0xdc, 0x99, 0x33, 0xb5, - 0xfd, 0x9a, 0x4b, 0x70, 0xaa, 0x15, 0xb5, 0xaa, 0x91, 0x26, 0x9e, 0x1a, 0x41, 0xdb, 0x90, 0x71, - 0xa8, 0x47, 0x26, 0x57, 0xdd, 0xc6, 0x35, 0xcd, 0xa5, 0xb1, 0x82, 0x4a, 0xe6, 0x48, 0x9e, 0xf7, - 0x08, 0xe7, 0x74, 0x38, 0xe2, 0xea, 0x36, 0x4e, 0xe3, 0xc2, 0x90, 0x3c, 0xb7, 0xb4, 0x08, 0xfd, - 0x08, 0xb2, 0xa7, 0xae, 0xef, 0xb0, 0x53, 0x7d, 0xe1, 0x5e, 0x6d, 0x57, 0x63, 0xcd, 0x33, 0x71, - 0xcf, 0x2e, 0x38, 0x2b, 0x56, 0xbd, 0x79, 0xd0, 0xac, 0x47, 0xab, 0xae, 0xfb, 0x0f, 0xfc, 0x26, - 0xf3, 0xc5, 0x89, 0x81, 0x83, 0x66, 0x6f, 0xd7, 0x6a, 0xec, 0x75, 0xb1, 0x58, 0xf9, 0x9b, 0x67, - 0xe7, 0x65, 0x23, 0x86, 0xec, 0x12, 0xd7, 0x13, 0x24, 0xf0, 0x36, 0xa4, 0xac, 0xe6, 0x97, 0x46, - 0xb2, 0x64, 0x9c, 0x9d, 0x97, 0x8b, 0x71, 0xb7, 0xe5, 0x4f, 0xa6, 0x87, 0x69, 0x71, 0x5c, 0xf3, - 0xbf, 0x12, 0x50, 0xec, 0x8e, 0x1c, 0xc2, 0xa9, 0x8a, 0x4c, 0x54, 0x86, 0xc2, 0x88, 0x04, 0xc4, - 0xf3, 0xa8, 0xe7, 0x86, 0x43, 0x5d, 0x28, 0xcc, 0x8a, 0xd0, 0x83, 0xef, 0xb0, 0x98, 0x9a, 0x84, - 0xe9, 0x25, 0xed, 0xc2, 0xfa, 0x91, 0x72, 0xb6, 0x47, 0x6c, 0xb9, 0xbb, 0x29, 0xb9, 0xbb, 0x95, - 0x65, 0x26, 0x66, 0xbd, 0xaa, 0xe8, 0x39, 0x5a, 0x52, 0x0b, 0xaf, 0x1d, 0xcd, 0x36, 0xcd, 0xfb, - 0xb0, 0x36, 0xd7, 0x2f, 0x6e, 0xda, 0x96, 0xd5, 0x6d, 0xd7, 0x8d, 0x15, 0x54, 0x84, 0x5c, 0xf5, - 0xa0, 0xd9, 0x69, 0x34, 0xbb, 0x75, 0x23, 0x61, 0xfe, 0x43, 0x32, 0x9a, 0xad, 0x66, 0x02, 0x3b, - 0xf3, 0x4c, 0xe0, 0xc3, 0xd7, 0x3b, 0xa2, 0xb9, 0xc0, 0xb4, 0x11, 0x33, 0x82, 0xdf, 0x05, 0x90, - 0x8b, 0x4a, 0x9d, 0x1e, 0xe1, 0x57, 0xb1, 0xfd, 0x4e, 0x54, 0xc7, 0xe1, 0xbc, 0x56, 0xb0, 0x38, - 0xfa, 0x02, 0x8a, 0x36, 0x1b, 0x8e, 0x3c, 0xaa, 0xf5, 0x53, 0x6f, 0xa2, 0x5f, 0x88, 0x55, 0x2c, - 0x3e, 0xcb, 0x48, 0xd2, 0xf3, 0x8c, 0xa4, 0x0a, 0x85, 0x19, 0x7f, 0xe7, 0x79, 0x49, 0x11, 0x72, - 0xdd, 0x56, 0xcd, 0xea, 0x34, 0x9a, 0x8f, 0x8c, 0x04, 0x02, 0xc8, 0xca, 0x15, 0xab, 0x19, 0x49, - 0xc1, 0x9d, 0xaa, 0x07, 0xfb, 0xad, 0xbd, 0xba, 0x62, 0x26, 0x7f, 0x02, 0xd7, 0xaa, 0xcc, 0xe7, - 0xc4, 0xf5, 0x63, 0x52, 0xb8, 0x2d, 0x7c, 0xd6, 0xa2, 0x9e, 0xeb, 0xa8, 0xbc, 0xb5, 0x73, 0xed, - 0xf2, 0x62, 0xab, 0x10, 0x43, 0x1b, 0x35, 0xe1, 0x65, 0xd4, 0x70, 0x44, 0x74, 0x8e, 0x5c, 0x47, - 0xa7, 0xa1, 0xd5, 0xcb, 0x8b, 0xad, 0x54, 0xab, 0x51, 0xc3, 0x42, 0x86, 0xde, 0x86, 0x3c, 0x7d, - 0xee, 0xf2, 0x9e, 0x2d, 0xf2, 0x94, 0x98, 0x7f, 0x06, 0xe7, 0x84, 0xa0, 0x2a, 0xd2, 0xd2, 0x9f, - 0x26, 0x01, 0x3a, 0x24, 0x3c, 0xd6, 0x43, 0x3f, 0x84, 0x7c, 0x5c, 0x0e, 0x5f, 0x55, 0x96, 0xcd, - 0xac, 0x75, 0x8c, 0x47, 0x9f, 0x46, 0xbb, 0xad, 0xd8, 0xea, 0x72, 0x45, 0x3d, 0xd6, 0x32, 0xc2, - 0x37, 0x4f, 0x49, 0x45, 0xd6, 0xa6, 0x41, 0xa0, 0x17, 0x5d, 0x7c, 0xa2, 0xaa, 0xcc, 0x5c, 0x6a, - 0xce, 0x9a, 0x03, 0xdd, 0x5d, 0x36, 0xc8, 0xc2, 0x82, 0x3e, 0x5e, 0xc1, 0x53, 0xbd, 0x1d, 0x03, - 0xd6, 0x83, 0xb1, 0x2f, 0xbc, 0xee, 0x85, 0xb2, 0xdb, 0x74, 0xe1, 0xad, 0x26, 0xe5, 0xa7, 0x2c, - 0x38, 0xb6, 0x38, 0x27, 0xf6, 0x40, 0x94, 0xa7, 0xfa, 0xb8, 0x4e, 0xa9, 0x5b, 0x62, 0x8e, 0xba, - 0x6d, 0xc0, 0x2a, 0xf1, 0x5c, 0x12, 0x52, 0x75, 0xdf, 0xe5, 0x71, 0xd4, 0x14, 0x04, 0x93, 0x38, - 0x4e, 0x40, 0xc3, 0x90, 0xaa, 0x82, 0x2a, 0x8f, 0xa7, 0x02, 0xf3, 0x5f, 0x92, 0x00, 0x8d, 0x96, - 0xb5, 0xaf, 0xcd, 0xd7, 0x20, 0x7b, 0x44, 0x86, 0xae, 0x37, 0xb9, 0xea, 0x80, 0x4c, 0xf1, 0x15, - 0x4b, 0x19, 0xda, 0x95, 0x3a, 0x58, 0xeb, 0x4a, 0xde, 0x39, 0x3e, 0xf4, 0x29, 0x8f, 0x79, 0xa7, - 0x6c, 0x89, 0x4b, 0x2e, 0x20, 0x7e, 0xbc, 0xb0, 0xaa, 0x21, 0x5c, 0xef, 0x13, 0x4e, 0x4f, 0xc9, - 0x24, 0x8a, 0x67, 0xdd, 0x44, 0x8f, 0x05, 0x1f, 0x15, 0x65, 0x32, 0x75, 0x36, 0x32, 0xf2, 0x16, - 0xff, 0x36, 0x7f, 0xb0, 0x86, 0xab, 0xeb, 0x3b, 0xd6, 0x2e, 0x3d, 0x94, 0x77, 0xce, 0xb4, 0xeb, - 0x3b, 0x95, 0x83, 0x1f, 0xc3, 0xda, 0xdc, 0x3c, 0x5f, 0x21, 0xfc, 0x8d, 0xd6, 0xd3, 0x1f, 0x19, - 0x69, 0xfd, 0xf5, 0x3b, 0x46, 0xd6, 0xfc, 0xef, 0x04, 0x40, 0x8b, 0x05, 0xd1, 0xa6, 0x2d, 0x7f, - 0x60, 0xc9, 0xc9, 0xe7, 0x1a, 0x9b, 0x79, 0x3a, 0x3c, 0x97, 0x32, 0xde, 0xa9, 0x15, 0x41, 0x20, - 0x25, 0x1c, 0xc7, 0x8a, 0x68, 0x0b, 0x0a, 0x6a, 0xff, 0x7b, 0x23, 0x16, 0xa8, 0x5c, 0xb2, 0x86, - 0x41, 0x89, 0x84, 0xa6, 0xa8, 0xde, 0x47, 0xe3, 0x43, 0xcf, 0x0d, 0x07, 0xd4, 0x51, 0x98, 0xb4, - 0xc4, 0xac, 0xc5, 0x52, 0x01, 0x33, 0x6b, 0x90, 0x8b, 0xac, 0xa3, 0x0d, 0x48, 0x75, 0xaa, 0x2d, - 0x63, 0xa5, 0x74, 0xed, 0xec, 0xbc, 0x5c, 0x88, 0xc4, 0x9d, 0x6a, 0x4b, 0xf4, 0x74, 0x6b, 0x2d, - 0x23, 0x31, 0xdf, 0xd3, 0xad, 0xb5, 0x4a, 0x69, 0x71, 0xdf, 0x98, 0x7f, 0x95, 0x80, 0xac, 0x62, - 0x3f, 0x4b, 0x67, 0x6c, 0xc1, 0x6a, 0xc4, 0xc9, 0x15, 0x25, 0x7b, 0xff, 0xf5, 0xf4, 0xa9, 0xa2, - 0xd9, 0x8e, 0xda, 0xc7, 0x48, 0xaf, 0xf4, 0x19, 0x14, 0x67, 0x3b, 0xbe, 0xd3, 0x2e, 0xfe, 0x31, - 0x14, 0x44, 0xa0, 0x44, 0x34, 0x6a, 0x1b, 0xb2, 0x8a, 0xa1, 0xe9, 0xac, 0x72, 0x15, 0x97, 0xd3, - 0x48, 0xf4, 0x00, 0x56, 0x15, 0xff, 0x8b, 0x5e, 0x26, 0x36, 0xaf, 0x0e, 0x47, 0x1c, 0xc1, 0xcd, - 0xcf, 0x21, 0xdd, 0xa2, 0x34, 0x40, 0x77, 0x61, 0xd5, 0x67, 0x0e, 0x9d, 0x26, 0x51, 0x4d, 0x5d, - 0x1d, 0xda, 0xa8, 0x09, 0xea, 0xea, 0xd0, 0x86, 0x23, 0x16, 0x4f, 0x1c, 0xd0, 0xe8, 0x71, 0x46, - 0x7c, 0x9b, 0x1d, 0x28, 0x3e, 0xa3, 0x6e, 0x7f, 0xc0, 0xa9, 0x23, 0x0d, 0x7d, 0x08, 0xe9, 0x11, - 0x8d, 0x9d, 0xdf, 0x58, 0x1a, 0x3a, 0x94, 0x06, 0x58, 0xa2, 0xc4, 0x81, 0x3c, 0x95, 0xda, 0xfa, - 0x3d, 0x4c, 0xb7, 0xcc, 0xbf, 0x4f, 0xc2, 0x7a, 0x23, 0x0c, 0xc7, 0xc4, 0xb7, 0xa3, 0x1b, 0xf2, - 0x27, 0xf3, 0x37, 0xe4, 0xfd, 0xa5, 0x33, 0x9c, 0x53, 0x99, 0xaf, 0x97, 0x75, 0x92, 0x4c, 0xc6, - 0x49, 0xd2, 0xfc, 0x3a, 0x11, 0x15, 0xca, 0xf7, 0x66, 0xce, 0x4d, 0x69, 0xe3, 0xec, 0xbc, 0x7c, - 0x73, 0xd6, 0x12, 0xed, 0xfa, 0xc7, 0x3e, 0x3b, 0xf5, 0xd1, 0xbb, 0xa2, 0x70, 0x6e, 0xd6, 0x9f, - 0x19, 0x89, 0xd2, 0xad, 0xb3, 0xf3, 0x32, 0x9a, 0x03, 0x61, 0xea, 0xd3, 0x53, 0x61, 0xa9, 0x55, - 0x6f, 0xd6, 0xc4, 0x65, 0x96, 0x5c, 0x62, 0xa9, 0x45, 0x7d, 0xc7, 0xf5, 0xfb, 0xe8, 0x2e, 0x64, - 0x1b, 0xed, 0x76, 0x57, 0x96, 0x32, 0x6f, 0x9d, 0x9d, 0x97, 0x6f, 0xcc, 0xa1, 0x44, 0x83, 0x3a, - 0x02, 0x24, 0xa8, 0x56, 0xbd, 0x66, 0xa4, 0x97, 0x80, 0x04, 0xd3, 0xa0, 0x8e, 0x8e, 0xf0, 0x7f, - 0x4f, 0x82, 0x61, 0xd9, 0x36, 0x1d, 0x71, 0xd1, 0xaf, 0xe9, 0x6b, 0x07, 0x72, 0x23, 0xf1, 0xe5, - 0x4a, 0x3a, 0x2e, 0xc2, 0xe2, 0xc1, 0xd2, 0xc7, 0xd2, 0x05, 0xbd, 0x0a, 0x66, 0x1e, 0xb5, 0x9c, - 0xa1, 0x1b, 0x86, 0xa2, 0x4c, 0x93, 0x32, 0x1c, 0x5b, 0x2a, 0xfd, 0x32, 0x01, 0x37, 0x96, 0x20, - 0xd0, 0xc7, 0x90, 0x0e, 0x98, 0x17, 0x6d, 0xcf, 0x9d, 0xd7, 0x3d, 0x65, 0x08, 0x55, 0x2c, 0x91, - 0x68, 0x13, 0x80, 0x8c, 0x39, 0x23, 0x72, 0x7c, 0xb9, 0x31, 0x39, 0x3c, 0x23, 0x41, 0xcf, 0x20, - 0x1b, 0x52, 0x3b, 0xa0, 0x11, 0x17, 0xf9, 0xfc, 0xff, 0xeb, 0x7d, 0xa5, 0x2d, 0xcd, 0x60, 0x6d, - 0xae, 0x54, 0x81, 0xac, 0x92, 0x88, 0x88, 0x76, 0x08, 0x27, 0xd2, 0xe9, 0x22, 0x96, 0xdf, 0x22, - 0x50, 0x88, 0xd7, 0x8f, 0x02, 0x85, 0x78, 0x7d, 0xf3, 0x67, 0x49, 0x80, 0xfa, 0x73, 0x4e, 0x03, - 0x9f, 0x78, 0x55, 0x0b, 0xd5, 0x67, 0x32, 0xa4, 0x9a, 0xed, 0x0f, 0x96, 0x3e, 0x70, 0xc5, 0x1a, - 0x95, 0xaa, 0xb5, 0x24, 0x47, 0xde, 0x86, 0xd4, 0x38, 0xf0, 0xf4, 0x63, 0xa9, 0x24, 0x22, 0x5d, - 0xbc, 0x87, 0x85, 0x0c, 0xd5, 0xa7, 0x19, 0x29, 0xf5, 0xfa, 0x57, 0xee, 0x99, 0x01, 0x7e, 0xf3, - 0x59, 0xe9, 0x43, 0x80, 0xa9, 0xd7, 0x68, 0x13, 0x32, 0xd5, 0xdd, 0x76, 0x7b, 0xcf, 0x58, 0x51, - 0xd5, 0xd6, 0xb4, 0x4b, 0x8a, 0xcd, 0xbf, 0x4b, 0x40, 0xae, 0x6a, 0xe9, 0x5b, 0x65, 0x17, 0x0c, - 0x99, 0x4b, 0x6c, 0x1a, 0xf0, 0x1e, 0x7d, 0x3e, 0x72, 0x83, 0x89, 0x4e, 0x07, 0x57, 0xd7, 0x25, - 0xeb, 0x42, 0xab, 0x4a, 0x03, 0x5e, 0x97, 0x3a, 0x08, 0x43, 0x91, 0xea, 0x29, 0xf6, 0x6c, 0x12, - 0x25, 0xe7, 0xcd, 0xab, 0x97, 0x42, 0xb1, 0xbf, 0x69, 0x3b, 0xc4, 0x85, 0xc8, 0x48, 0x95, 0x84, - 0xe6, 0x53, 0xb8, 0x71, 0x10, 0xd8, 0x03, 0x1a, 0x72, 0x35, 0xa8, 0x76, 0xf9, 0x73, 0xb8, 0xc3, - 0x49, 0x78, 0xdc, 0x1b, 0xb8, 0x21, 0x67, 0xc1, 0xa4, 0x17, 0x50, 0x4e, 0x7d, 0xd1, 0xdf, 0x93, - 0x6f, 0xe9, 0xba, 0x9a, 0xbd, 0x2d, 0x30, 0x8f, 0x15, 0x04, 0x47, 0x88, 0x3d, 0x01, 0x30, 0x1b, - 0x50, 0x14, 0x84, 0xad, 0x46, 0x8f, 0xc8, 0xd8, 0xe3, 0x21, 0xfa, 0x31, 0x80, 0xc7, 0xfa, 0xbd, - 0x37, 0xce, 0xe4, 0x79, 0x8f, 0xf5, 0xd5, 0xa7, 0xf9, 0xfb, 0x60, 0xd4, 0xdc, 0x70, 0x44, 0xb8, - 0x3d, 0x88, 0xca, 0x74, 0xf4, 0x08, 0x8c, 0x01, 0x25, 0x01, 0x3f, 0xa4, 0x84, 0xf7, 0x46, 0x34, - 0x70, 0x99, 0xf3, 0x46, 0x4b, 0x7a, 0x2d, 0xd6, 0x6a, 0x49, 0x25, 0xf3, 0x57, 0x09, 0x00, 0x4c, - 0x8e, 0x22, 0x02, 0xf0, 0x43, 0xb8, 0x1e, 0xfa, 0x64, 0x14, 0x0e, 0x18, 0xef, 0xb9, 0x3e, 0xa7, - 0xc1, 0x09, 0xf1, 0x74, 0xa9, 0x65, 0x44, 0x1d, 0x0d, 0x2d, 0x47, 0x1f, 0x02, 0x3a, 0xa6, 0x74, - 0xd4, 0x63, 0x9e, 0xd3, 0x8b, 0x3a, 0xd5, 0x63, 0x7f, 0x1a, 0x1b, 0xa2, 0xe7, 0xc0, 0x73, 0xda, - 0x91, 0x1c, 0xed, 0xc0, 0xa6, 0x58, 0x01, 0xea, 0xf3, 0xc0, 0xa5, 0x61, 0xef, 0x88, 0x05, 0xbd, - 0xd0, 0x63, 0xa7, 0xbd, 0x23, 0xe6, 0x79, 0xec, 0x94, 0x06, 0x51, 0x21, 0x5b, 0xf2, 0x58, 0xbf, - 0xae, 0x40, 0xbb, 0x2c, 0x68, 0x7b, 0xec, 0x74, 0x37, 0x42, 0x08, 0x96, 0x30, 0x9d, 0x36, 0x77, - 0xed, 0xe3, 0x88, 0x25, 0xc4, 0xd2, 0x8e, 0x6b, 0x1f, 0xa3, 0xbb, 0xb0, 0x46, 0x3d, 0x2a, 0x4b, - 0x2e, 0x85, 0xca, 0x48, 0x54, 0x31, 0x12, 0x0a, 0x90, 0xf9, 0x5b, 0x90, 0x6f, 0x79, 0xc4, 0x96, - 0x7f, 0xa9, 0x88, 0xe2, 0xd2, 0x66, 0xbe, 0x08, 0x02, 0xd7, 0xe7, 0x2a, 0x3b, 0xe6, 0xf1, 0xac, - 0xc8, 0xfc, 0x09, 0xc0, 0x4f, 0x99, 0xeb, 0x77, 0xd8, 0x31, 0xf5, 0xe5, 0xeb, 0xb3, 0x60, 0xbd, - 0x7a, 0x2b, 0xf3, 0x58, 0xb7, 0x24, 0x27, 0x27, 0x3e, 0xe9, 0xd3, 0x20, 0x7e, 0x84, 0x55, 0x4d, - 0x71, 0xb9, 0x64, 0x31, 0x63, 0xbc, 0x6a, 0xa1, 0x32, 0x64, 0x6d, 0xd2, 0x8b, 0x4e, 0x5e, 0x71, - 0x27, 0x7f, 0x79, 0xb1, 0x95, 0xa9, 0x5a, 0x4f, 0xe8, 0x04, 0x67, 0x6c, 0xf2, 0x84, 0x4e, 0xc4, - 0xed, 0x6b, 0x13, 0x79, 0x5e, 0xa4, 0x99, 0xa2, 0xba, 0x7d, 0xab, 0x96, 0x38, 0x0c, 0x38, 0x6b, - 0x13, 0xf1, 0x8b, 0x3e, 0x86, 0xa2, 0x06, 0xf5, 0x06, 0x24, 0x1c, 0x28, 0xae, 0xba, 0xb3, 0x7e, - 0x79, 0xb1, 0x05, 0x0a, 0xf9, 0x98, 0x84, 0x03, 0x0c, 0x0a, 0x2d, 0xbe, 0x51, 0x1d, 0x0a, 0x5f, - 0x31, 0xd7, 0xef, 0x71, 0x39, 0x09, 0xfd, 0x36, 0xb0, 0xf4, 0xfc, 0x4c, 0xa7, 0xaa, 0x0b, 0x65, - 0xf8, 0x2a, 0x96, 0x98, 0xff, 0x9a, 0x80, 0x82, 0xb0, 0xe9, 0x1e, 0xb9, 0xb6, 0xb8, 0x2d, 0xbf, - 0x7b, 0xa6, 0xbf, 0x0d, 0x29, 0x3b, 0x0c, 0xf4, 0xdc, 0x64, 0xaa, 0xab, 0xb6, 0x31, 0x16, 0x32, - 0xf4, 0x05, 0x64, 0x55, 0x71, 0xa1, 0x93, 0xbc, 0xf9, 0xed, 0xf7, 0xba, 0x76, 0x51, 0xeb, 0xc9, - 0xbd, 0x9c, 0x7a, 0x27, 0x67, 0x59, 0xc4, 0xb3, 0x22, 0x74, 0x0b, 0x92, 0xb6, 0x2f, 0x83, 0x42, - 0xff, 0x2b, 0x55, 0x6d, 0xe2, 0xa4, 0xed, 0x9b, 0xff, 0x9c, 0x80, 0xb5, 0xba, 0x6f, 0x07, 0x13, - 0x99, 0x24, 0xc5, 0x46, 0xdc, 0x81, 0x7c, 0x38, 0x3e, 0x0c, 0x27, 0x21, 0xa7, 0xc3, 0xe8, 0xd1, - 0x3b, 0x16, 0xa0, 0x06, 0xe4, 0x89, 0xd7, 0x67, 0x81, 0xcb, 0x07, 0x43, 0xcd, 0x8d, 0x97, 0x27, - 0xe6, 0x59, 0x9b, 0x15, 0x2b, 0x52, 0xc1, 0x53, 0xed, 0x28, 0x15, 0xa7, 0xa4, 0xb3, 0x32, 0x15, - 0xbf, 0x0b, 0x45, 0x8f, 0x0c, 0x05, 0x15, 0xee, 0x89, 0x92, 0x4b, 0xce, 0x23, 0x8d, 0x0b, 0x5a, - 0x26, 0xca, 0x48, 0xd3, 0x84, 0x7c, 0x6c, 0x0c, 0x5d, 0x83, 0x82, 0x55, 0x6f, 0xf7, 0x3e, 0xd9, - 0x7e, 0xd0, 0x7b, 0x54, 0xdd, 0x37, 0x56, 0x34, 0x13, 0xf8, 0xc7, 0x04, 0xac, 0xed, 0xab, 0x18, - 0xd4, 0xc4, 0xe9, 0x2e, 0xac, 0x06, 0xe4, 0x88, 0x47, 0xd4, 0x2e, 0xad, 0x82, 0x4b, 0x24, 0x01, - 0x41, 0xed, 0x44, 0xd7, 0x72, 0x6a, 0x37, 0xf3, 0x97, 0x4b, 0xea, 0xca, 0xbf, 0x5c, 0xd2, 0xbf, - 0x91, 0xbf, 0x5c, 0x3e, 0xf8, 0x55, 0x0a, 0xf2, 0x71, 0xd1, 0x2b, 0x42, 0x46, 0x30, 0xad, 0x15, - 0xf5, 0x88, 0x14, 0xcb, 0x9b, 0x92, 0x63, 0xe5, 0xad, 0xbd, 0xbd, 0x83, 0xaa, 0xd5, 0xa9, 0xd7, - 0x8c, 0x2f, 0x14, 0x15, 0x8b, 0x01, 0x96, 0xe7, 0x31, 0xb1, 0xe9, 0x0e, 0x32, 0xa7, 0x54, 0xec, - 0x85, 0x7e, 0xaa, 0x8a, 0x51, 0x11, 0x0f, 0x7b, 0x0f, 0x72, 0x56, 0xbb, 0xdd, 0x78, 0xd4, 0xac, - 0xd7, 0x8c, 0x97, 0x89, 0xd2, 0xf7, 0xce, 0xce, 0xcb, 0xd7, 0xa7, 0xa6, 0xc2, 0xd0, 0xed, 0xfb, - 0xd4, 0x91, 0xa8, 0x6a, 0xb5, 0xde, 0x12, 0xe3, 0xbd, 0x48, 0x2e, 0xa2, 0x24, 0x01, 0x91, 0xcf, - 0xce, 0xf9, 0x16, 0xae, 0xb7, 0x2c, 0x2c, 0x46, 0x7c, 0x99, 0x5c, 0xf0, 0xab, 0x15, 0xd0, 0x11, - 0x09, 0xc4, 0x98, 0x9b, 0xd1, 0xdf, 0x2f, 0x2f, 0x52, 0xea, 0x69, 0x72, 0x5a, 0xe9, 0x53, 0xe2, - 0x4c, 0xc4, 0x68, 0xed, 0x8e, 0x85, 0xe5, 0x83, 0xc8, 0xcb, 0xd4, 0xc2, 0x68, 0x6d, 0x4e, 0x02, - 0x2e, 0xac, 0x98, 0xb0, 0x8a, 0xbb, 0xcd, 0xa6, 0x9c, 0x5d, 0x7a, 0x61, 0x76, 0x78, 0xec, 0xfb, - 0x02, 0x73, 0x0f, 0x72, 0xd1, 0x03, 0x8a, 0xf1, 0x32, 0xbd, 0xe0, 0x50, 0x35, 0x7a, 0xb9, 0x91, - 0x03, 0x3e, 0xee, 0x76, 0xe4, 0xbf, 0x43, 0x2f, 0x32, 0x8b, 0x03, 0x0e, 0xc6, 0xdc, 0x11, 0xe4, - 0xb7, 0x1c, 0xb3, 0xd1, 0x97, 0x19, 0x45, 0x02, 0x62, 0x8c, 0xa2, 0xa2, 0xc2, 0x0e, 0xae, 0xff, - 0x54, 0xfd, 0x91, 0xf4, 0x22, 0xbb, 0x60, 0x07, 0xd3, 0xaf, 0xa8, 0xcd, 0xa9, 0x33, 0x7d, 0x79, - 0x8d, 0xbb, 0x3e, 0xf8, 0x03, 0xc8, 0x45, 0x09, 0x03, 0x6d, 0x42, 0xf6, 0xd9, 0x01, 0x7e, 0x52, - 0xc7, 0xc6, 0x8a, 0x5a, 0x9d, 0xa8, 0xe7, 0x99, 0xca, 0xb8, 0x65, 0x58, 0xdd, 0xb7, 0x9a, 0xd6, - 0xa3, 0x3a, 0x8e, 0x5e, 0x7e, 0x23, 0x80, 0x8e, 0xfa, 0x92, 0xa1, 0x07, 0x88, 0x6d, 0xee, 0xdc, - 0xf9, 0xfa, 0x9b, 0xcd, 0x95, 0x5f, 0x7c, 0xb3, 0xb9, 0xf2, 0xcb, 0x6f, 0x36, 0x13, 0x2f, 0x2e, - 0x37, 0x13, 0x5f, 0x5f, 0x6e, 0x26, 0x7e, 0x7e, 0xb9, 0x99, 0xf8, 0x8f, 0xcb, 0xcd, 0xc4, 0x61, - 0x56, 0x32, 0xb2, 0x4f, 0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x7d, 0xe8, 0x50, 0x18, 0x0a, 0x21, - 0x00, 0x00, + // 3537 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x59, 0x4d, 0x6c, 0x23, 0x47, + 0x76, 0x56, 0xf3, 0x4f, 0xe4, 0x23, 0xa5, 0xe9, 0x29, 0xcf, 0x8e, 0x35, 0xf4, 0x58, 0xa2, 0x7b, + 0x3c, 0xeb, 0x59, 0xaf, 0x43, 0xdb, 0xf2, 0x26, 0x98, 0xf5, 0x6c, 0xd6, 0x6e, 0x91, 0xad, 0x19, + 0x7a, 0x24, 0x8a, 0x28, 0x92, 0x1a, 0x18, 0x01, 0x42, 0x94, 0xba, 0x4b, 0x54, 0x5b, 0xcd, 0x6e, + 0xa6, 0xbb, 0x28, 0x0d, 0x13, 0x04, 0x98, 0xe4, 0x92, 0x40, 0xa7, 0x9c, 0x72, 0x09, 0x84, 0x45, + 0x90, 0x20, 0xb7, 0x1c, 0x72, 0x0a, 0x90, 0xd3, 0x1c, 0x7d, 0xdc, 0x20, 0x40, 0xb0, 0x48, 0x00, + 0x21, 0x56, 0x8e, 0xb9, 0x2c, 0x90, 0xc3, 0x1e, 0x92, 0x43, 0x50, 0x3f, 0xdd, 0xfc, 0x19, 0x4a, + 0x1e, 0x67, 0xf7, 0xc4, 0xae, 0x57, 0xdf, 0x7b, 0xf5, 0xaa, 0xea, 0xd5, 0xab, 0xaf, 0x1e, 0xa1, + 0xc8, 0xc6, 0x43, 0x1a, 0x55, 0x87, 0x61, 0xc0, 0x02, 0x84, 0x9c, 0xc0, 0x3e, 0xa6, 0x61, 0x35, + 0x3a, 0x25, 0xe1, 0xe0, 0xd8, 0x65, 0xd5, 0x93, 0x8f, 0xcb, 0x77, 0x98, 0x3b, 0xa0, 0x11, 0x23, + 0x83, 0xe1, 0x87, 0xc9, 0x97, 0x84, 0x97, 0xdf, 0x74, 0x46, 0x21, 0x61, 0x6e, 0xe0, 0x7f, 0x18, + 0x7f, 0xa8, 0x8e, 0x5b, 0xfd, 0xa0, 0x1f, 0x88, 0xcf, 0x0f, 0xf9, 0x97, 0x94, 0x1a, 0x1b, 0xb0, + 0xbc, 0x4f, 0xc3, 0xc8, 0x0d, 0x7c, 0x74, 0x0b, 0xb2, 0xae, 0xef, 0xd0, 0xe7, 0x6b, 0x5a, 0x45, + 0x7b, 0x90, 0xc1, 0xb2, 0x61, 0xfc, 0xb5, 0x06, 0x45, 0xd3, 0xf7, 0x03, 0x26, 0x6c, 0x45, 0x08, + 0x41, 0xc6, 0x27, 0x03, 0x2a, 0x40, 0x05, 0x2c, 0xbe, 0x51, 0x0d, 0x72, 0x1e, 0x39, 0xa0, 0x5e, + 0xb4, 0x96, 0xaa, 0xa4, 0x1f, 0x14, 0x37, 0x7f, 0x58, 0x7d, 0xd5, 0xe7, 0xea, 0x94, 0x91, 0xea, + 0x8e, 0x40, 0x5b, 0x3e, 0x0b, 0xc7, 0x58, 0xa9, 0x96, 0x7f, 0x0c, 0xc5, 0x29, 0x31, 0xd2, 0x21, + 0x7d, 0x4c, 0xc7, 0x6a, 0x18, 0xfe, 0xc9, 0xfd, 0x3b, 0x21, 0xde, 0x88, 0xae, 0xa5, 0x84, 0x4c, + 0x36, 0x3e, 0x4d, 0x3d, 0xd4, 0x8c, 0x2f, 0xa1, 0x80, 0x69, 0x14, 0x8c, 0x42, 0x9b, 0x46, 0xe8, + 0x07, 0x50, 0xf0, 0x89, 0x1f, 0xf4, 0xec, 0xe1, 0x28, 0x12, 0xea, 0xe9, 0xad, 0xd2, 0xe5, 0xc5, + 0x46, 0xbe, 0x49, 0xfc, 0xa0, 0xd6, 0xea, 0x46, 0x38, 0xcf, 0xbb, 0x6b, 0xc3, 0x51, 0x84, 0xde, + 0x81, 0xd2, 0x80, 0x0e, 0x82, 0x70, 0xdc, 0x3b, 0x18, 0x33, 0x1a, 0x09, 0xc3, 0x69, 0x5c, 0x94, + 0xb2, 0x2d, 0x2e, 0x32, 0xfe, 0x42, 0x83, 0x5b, 0xb1, 0x6d, 0x4c, 0xff, 0x60, 0xe4, 0x86, 0x74, + 0x40, 0x7d, 0x16, 0xa1, 0xdf, 0x86, 0x9c, 0xe7, 0x0e, 0x5c, 0x26, 0xc7, 0x28, 0x6e, 0xbe, 0xbd, + 0x68, 0xce, 0x89, 0x57, 0x58, 0x81, 0x91, 0x09, 0xa5, 0x90, 0x46, 0x34, 0x3c, 0x91, 0x2b, 0x21, + 0x86, 0xfc, 0x56, 0xe5, 0x19, 0x15, 0x63, 0x1b, 0xf2, 0x2d, 0x8f, 0xb0, 0xc3, 0x20, 0x1c, 0x20, + 0x03, 0x4a, 0x24, 0xb4, 0x8f, 0x5c, 0x46, 0x6d, 0x36, 0x0a, 0xe3, 0x5d, 0x99, 0x91, 0xa1, 0xdb, + 0x90, 0x0a, 0xe4, 0x40, 0x85, 0xad, 0xdc, 0xe5, 0xc5, 0x46, 0x6a, 0xaf, 0x8d, 0x53, 0x41, 0x64, + 0x3c, 0x82, 0x9b, 0x2d, 0x6f, 0xd4, 0x77, 0xfd, 0x3a, 0x8d, 0xec, 0xd0, 0x1d, 0x72, 0xeb, 0x7c, + 0x7b, 0x79, 0xf0, 0xc5, 0xdb, 0xcb, 0xbf, 0x93, 0x2d, 0x4f, 0x4d, 0xb6, 0xdc, 0xf8, 0xb3, 0x14, + 0xdc, 0xb4, 0xfc, 0xbe, 0xeb, 0xd3, 0x69, 0xed, 0xfb, 0xb0, 0x4a, 0x85, 0xb0, 0x77, 0x22, 0x83, + 0x4a, 0xd9, 0x59, 0x91, 0xd2, 0x38, 0xd2, 0x1a, 0x73, 0xf1, 0xf2, 0xf1, 0xa2, 0xe9, 0xbf, 0x62, + 0x7d, 0x51, 0xd4, 0x20, 0x0b, 0x96, 0x87, 0x62, 0x12, 0xd1, 0x5a, 0x5a, 0xd8, 0xba, 0xbf, 0xc8, + 0xd6, 0x2b, 0xf3, 0xdc, 0xca, 0x7c, 0x7d, 0xb1, 0xb1, 0x84, 0x63, 0xdd, 0x5f, 0x27, 0xf8, 0xfe, + 0x53, 0x83, 0x1b, 0xcd, 0xc0, 0x99, 0x59, 0x87, 0x32, 0xe4, 0x8f, 0x82, 0x88, 0x4d, 0x1d, 0x94, + 0xa4, 0x8d, 0x1e, 0x42, 0x7e, 0xa8, 0xb6, 0x4f, 0xed, 0xfe, 0xdd, 0xc5, 0x2e, 0x4b, 0x0c, 0x4e, + 0xd0, 0xe8, 0x11, 0x14, 0xc2, 0x38, 0x26, 0xd6, 0xd2, 0xaf, 0x13, 0x38, 0x13, 0x3c, 0xfa, 0x5d, + 0xc8, 0xc9, 0x4d, 0x58, 0xcb, 0x08, 0xcd, 0xfb, 0xaf, 0xb5, 0xe6, 0x58, 0x29, 0x19, 0xbf, 0xd0, + 0x40, 0xc7, 0xe4, 0x90, 0xed, 0xd2, 0xc1, 0x01, 0x0d, 0xdb, 0x8c, 0xb0, 0x51, 0x84, 0x6e, 0x43, + 0xce, 0xa3, 0xc4, 0xa1, 0xa1, 0x98, 0x64, 0x1e, 0xab, 0x16, 0xea, 0xf2, 0x20, 0x27, 0xf6, 0x11, + 0x39, 0x70, 0x3d, 0x97, 0x8d, 0xc5, 0x34, 0x57, 0x17, 0xef, 0xf2, 0xbc, 0xcd, 0x2a, 0x9e, 0x52, + 0xc4, 0x33, 0x66, 0xd0, 0x1a, 0x2c, 0x0f, 0x68, 0x14, 0x91, 0x3e, 0x15, 0xb3, 0x2f, 0xe0, 0xb8, + 0x69, 0x3c, 0x82, 0xd2, 0xb4, 0x1e, 0x2a, 0xc2, 0x72, 0xb7, 0xf9, 0xb4, 0xb9, 0xf7, 0xac, 0xa9, + 0x2f, 0xa1, 0x1b, 0x50, 0xec, 0x36, 0xb1, 0x65, 0xd6, 0x9e, 0x98, 0x5b, 0x3b, 0x96, 0xae, 0xa1, + 0x15, 0x28, 0x4c, 0x9a, 0x29, 0xe3, 0x67, 0x1a, 0x00, 0xdf, 0x40, 0x35, 0xa9, 0x4f, 0x21, 0x1b, + 0x31, 0xc2, 0xe4, 0xc6, 0xad, 0x6e, 0xbe, 0xbb, 0xc8, 0xeb, 0x09, 0xbc, 0xca, 0x7f, 0x28, 0x96, + 0x2a, 0xd3, 0x1e, 0xa6, 0xe6, 0x3d, 0xcc, 0x0a, 0xe4, 0xac, 0x6b, 0x79, 0xc8, 0xd4, 0xf9, 0x97, + 0x86, 0x0a, 0x90, 0xc5, 0x96, 0x59, 0xff, 0x52, 0x4f, 0x21, 0x1d, 0x4a, 0xf5, 0x46, 0xbb, 0xb6, + 0xd7, 0x6c, 0x5a, 0xb5, 0x8e, 0x55, 0xd7, 0xd3, 0xc6, 0x7d, 0xc8, 0x36, 0x06, 0xa4, 0x4f, 0xd1, + 0x5d, 0x1e, 0x01, 0x87, 0x34, 0xa4, 0xbe, 0x1d, 0x07, 0xd6, 0x44, 0x60, 0xfc, 0xbc, 0x00, 0xd9, + 0xdd, 0x60, 0xe4, 0x33, 0xb4, 0x39, 0x75, 0x8a, 0x57, 0x37, 0xd7, 0x17, 0x4d, 0x41, 0x00, 0xab, + 0x9d, 0xf1, 0x90, 0xaa, 0x53, 0x7e, 0x1b, 0x72, 0x32, 0x56, 0x94, 0xeb, 0xaa, 0xc5, 0xe5, 0x8c, + 0x84, 0x7d, 0xca, 0xd4, 0xa2, 0xab, 0x16, 0x7a, 0x00, 0xf9, 0x90, 0x12, 0x27, 0xf0, 0xbd, 0xb1, + 0x08, 0xa9, 0xbc, 0x4c, 0xb3, 0x98, 0x12, 0x67, 0xcf, 0xf7, 0xc6, 0x38, 0xe9, 0x45, 0x4f, 0xa0, + 0x74, 0xe0, 0xfa, 0x4e, 0x2f, 0x18, 0xca, 0x9c, 0x97, 0xbd, 0x3a, 0x00, 0xa5, 0x57, 0x5b, 0xae, + 0xef, 0xec, 0x49, 0x30, 0x2e, 0x1e, 0x4c, 0x1a, 0xa8, 0x09, 0xab, 0x27, 0x81, 0x37, 0x1a, 0xd0, + 0xc4, 0x56, 0x4e, 0xd8, 0x7a, 0xef, 0x6a, 0x5b, 0xfb, 0x02, 0x1f, 0x5b, 0x5b, 0x39, 0x99, 0x6e, + 0xa2, 0xa7, 0xb0, 0xc2, 0x06, 0xc3, 0xc3, 0x28, 0x31, 0xb7, 0x2c, 0xcc, 0x7d, 0xff, 0x9a, 0x05, + 0xe3, 0xf0, 0xd8, 0x5a, 0x89, 0x4d, 0xb5, 0xca, 0x7f, 0x9a, 0x86, 0xe2, 0x94, 0xe7, 0xa8, 0x0d, + 0xc5, 0x61, 0x18, 0x0c, 0x49, 0x5f, 0xe4, 0x6d, 0xb5, 0x17, 0x1f, 0xbf, 0xd6, 0xac, 0xab, 0xad, + 0x89, 0x22, 0x9e, 0xb6, 0x62, 0x9c, 0xa7, 0xa0, 0x38, 0xd5, 0x89, 0xde, 0x87, 0x3c, 0x6e, 0xe1, + 0xc6, 0xbe, 0xd9, 0xb1, 0xf4, 0xa5, 0xf2, 0xdd, 0xb3, 0xf3, 0xca, 0x9a, 0xb0, 0x36, 0x6d, 0xa0, + 0x15, 0xba, 0x27, 0x3c, 0xf4, 0x1e, 0xc0, 0x72, 0x0c, 0xd5, 0xca, 0x6f, 0x9d, 0x9d, 0x57, 0xde, + 0x9c, 0x87, 0x4e, 0x21, 0x71, 0xfb, 0x89, 0x89, 0xad, 0xba, 0x9e, 0x5a, 0x8c, 0xc4, 0xed, 0x23, + 0x12, 0x52, 0x07, 0x7d, 0x1f, 0x72, 0x0a, 0x98, 0x2e, 0x97, 0xcf, 0xce, 0x2b, 0xb7, 0xe7, 0x81, + 0x13, 0x1c, 0x6e, 0xef, 0x98, 0xfb, 0x96, 0x9e, 0x59, 0x8c, 0xc3, 0x6d, 0x8f, 0x9c, 0x50, 0xf4, + 0x2e, 0x64, 0x25, 0x2c, 0x5b, 0xbe, 0x73, 0x76, 0x5e, 0xf9, 0xde, 0x2b, 0xe6, 0x38, 0xaa, 0xbc, + 0xf6, 0xe7, 0x7f, 0xb3, 0xbe, 0xf4, 0x4f, 0x7f, 0xbb, 0xae, 0xcf, 0x77, 0x97, 0xff, 0x57, 0x83, + 0x95, 0x99, 0x2d, 0x47, 0x06, 0xe4, 0xfc, 0xc0, 0x0e, 0x86, 0x32, 0x9d, 0xe7, 0xb7, 0xe0, 0xf2, + 0x62, 0x23, 0xd7, 0x0c, 0x6a, 0xc1, 0x70, 0x8c, 0x55, 0x0f, 0x7a, 0x3a, 0x77, 0x21, 0x7d, 0xf2, + 0x9a, 0xf1, 0xb4, 0xf0, 0x4a, 0xfa, 0x0c, 0x56, 0x9c, 0xd0, 0x3d, 0xa1, 0x61, 0xcf, 0x0e, 0xfc, + 0x43, 0xb7, 0xaf, 0x52, 0x75, 0x79, 0x91, 0xcd, 0xba, 0x00, 0xe2, 0x92, 0x54, 0xa8, 0x09, 0xfc, + 0xaf, 0x71, 0x19, 0x95, 0xf7, 0xa1, 0x34, 0x1d, 0xa1, 0xe8, 0x6d, 0x80, 0xc8, 0xfd, 0x43, 0xaa, + 0xf8, 0x8d, 0x60, 0x43, 0xb8, 0xc0, 0x25, 0x82, 0xdd, 0xa0, 0xf7, 0x20, 0x33, 0x08, 0x1c, 0x69, + 0x27, 0xbb, 0xf5, 0x06, 0xbf, 0x13, 0xff, 0xed, 0x62, 0xa3, 0x18, 0x44, 0xd5, 0x6d, 0xd7, 0xa3, + 0xbb, 0x81, 0x43, 0xb1, 0x00, 0x18, 0x27, 0x90, 0xe1, 0xa9, 0x02, 0xbd, 0x05, 0x99, 0xad, 0x46, + 0xb3, 0xae, 0x2f, 0x95, 0x6f, 0x9e, 0x9d, 0x57, 0x56, 0xc4, 0x92, 0xf0, 0x0e, 0x1e, 0xbb, 0x68, + 0x03, 0x72, 0xfb, 0x7b, 0x3b, 0xdd, 0x5d, 0x1e, 0x5e, 0x6f, 0x9c, 0x9d, 0x57, 0x6e, 0x24, 0xdd, + 0x72, 0xd1, 0xd0, 0xdb, 0x90, 0xed, 0xec, 0xb6, 0xb6, 0xdb, 0x7a, 0xaa, 0x8c, 0xce, 0xce, 0x2b, + 0xab, 0x49, 0xbf, 0xf0, 0xb9, 0x7c, 0x53, 0xed, 0x6a, 0x21, 0x91, 0x1b, 0xff, 0x93, 0x82, 0x15, + 0xcc, 0xf9, 0x6d, 0xc8, 0x5a, 0x81, 0xe7, 0xda, 0x63, 0xd4, 0x82, 0x82, 0x1d, 0xf8, 0x8e, 0x3b, + 0x75, 0xa6, 0x36, 0xaf, 0xb8, 0x04, 0x27, 0x5a, 0x71, 0xab, 0x16, 0x6b, 0xe2, 0x89, 0x11, 0xb4, + 0x09, 0x59, 0x87, 0x7a, 0x64, 0x7c, 0xdd, 0x6d, 0x5c, 0x57, 0x5c, 0x1a, 0x4b, 0xa8, 0x60, 0x8e, + 0xe4, 0x79, 0x8f, 0x30, 0x46, 0x07, 0x43, 0x26, 0x6f, 0xe3, 0x0c, 0x2e, 0x0e, 0xc8, 0x73, 0x53, + 0x89, 0xd0, 0x8f, 0x20, 0x77, 0xea, 0xfa, 0x4e, 0x70, 0xaa, 0x2e, 0xdc, 0xeb, 0xed, 0x2a, 0xac, + 0x71, 0xc6, 0xef, 0xd9, 0x39, 0x67, 0xf9, 0xaa, 0x37, 0xf7, 0x9a, 0x56, 0xbc, 0xea, 0xaa, 0x7f, + 0xcf, 0x6f, 0x06, 0x3e, 0x3f, 0x31, 0xb0, 0xd7, 0xec, 0x6d, 0x9b, 0x8d, 0x9d, 0x2e, 0xe6, 0x2b, + 0x7f, 0xeb, 0xec, 0xbc, 0xa2, 0x27, 0x90, 0x6d, 0xe2, 0x7a, 0x9c, 0x04, 0xde, 0x81, 0xb4, 0xd9, + 0xfc, 0x52, 0x4f, 0x95, 0xf5, 0xb3, 0xf3, 0x4a, 0x29, 0xe9, 0x36, 0xfd, 0xf1, 0xe4, 0x30, 0xcd, + 0x8f, 0x6b, 0xfc, 0x97, 0x06, 0xa5, 0xee, 0xd0, 0x21, 0x8c, 0xca, 0xc8, 0x44, 0x15, 0x28, 0x0e, + 0x49, 0x48, 0x3c, 0x8f, 0x7a, 0x6e, 0x34, 0x50, 0x0f, 0x85, 0x69, 0x11, 0x7a, 0xf8, 0x1d, 0x16, + 0x53, 0x91, 0x30, 0xb5, 0xa4, 0x5d, 0x58, 0x3d, 0x94, 0xce, 0xf6, 0x88, 0x2d, 0x76, 0x37, 0x2d, + 0x76, 0xb7, 0xba, 0xc8, 0xc4, 0xb4, 0x57, 0x55, 0x35, 0x47, 0x53, 0x68, 0xe1, 0x95, 0xc3, 0xe9, + 0xa6, 0xf1, 0x00, 0x56, 0x66, 0xfa, 0xf9, 0x4d, 0xdb, 0x32, 0xbb, 0x6d, 0x4b, 0x5f, 0x42, 0x25, + 0xc8, 0xd7, 0xf6, 0x9a, 0x9d, 0x46, 0xb3, 0x6b, 0xe9, 0x9a, 0xf1, 0x0f, 0xa9, 0x78, 0xb6, 0x8a, + 0x09, 0x6c, 0xcd, 0x32, 0x81, 0x0f, 0xae, 0x76, 0x44, 0x71, 0x81, 0x49, 0x23, 0x61, 0x04, 0x3f, + 0x01, 0x10, 0x8b, 0x4a, 0x9d, 0x1e, 0x61, 0xd7, 0xb1, 0xfd, 0x4e, 0xfc, 0x8e, 0xc3, 0x05, 0xa5, + 0x60, 0x32, 0xf4, 0x39, 0x94, 0xec, 0x60, 0x30, 0xf4, 0xa8, 0xd2, 0x4f, 0xbf, 0x8e, 0x7e, 0x31, + 0x51, 0x31, 0xd9, 0x34, 0x23, 0xc9, 0xcc, 0x32, 0x92, 0x1a, 0x14, 0xa7, 0xfc, 0x9d, 0xe5, 0x25, + 0x25, 0xc8, 0x77, 0x5b, 0x75, 0xb3, 0xd3, 0x68, 0x3e, 0xd6, 0x35, 0x04, 0x90, 0x13, 0x2b, 0x56, + 0xd7, 0x53, 0x9c, 0x3b, 0xd5, 0xf6, 0x76, 0x5b, 0x3b, 0x96, 0x64, 0x26, 0x7f, 0x0c, 0x37, 0x6a, + 0x81, 0xcf, 0x88, 0xeb, 0x27, 0xa4, 0x70, 0x93, 0xfb, 0xac, 0x44, 0x3d, 0xd7, 0x91, 0x79, 0x6b, + 0xeb, 0xc6, 0xe5, 0xc5, 0x46, 0x31, 0x81, 0x36, 0xea, 0xdc, 0xcb, 0xb8, 0xe1, 0xf0, 0xe8, 0x1c, + 0xba, 0x8e, 0x4a, 0x43, 0xcb, 0x97, 0x17, 0x1b, 0xe9, 0x56, 0xa3, 0x8e, 0xb9, 0x0c, 0xbd, 0x05, + 0x05, 0xfa, 0xdc, 0x65, 0x3d, 0x9b, 0xe7, 0x29, 0x3e, 0xff, 0x2c, 0xce, 0x73, 0x41, 0x8d, 0xa7, + 0xa5, 0x3f, 0x49, 0x01, 0x74, 0x48, 0x74, 0xac, 0x86, 0x7e, 0x04, 0x85, 0xe4, 0x39, 0x7c, 0xdd, + 0xb3, 0x6c, 0x6a, 0xad, 0x13, 0x3c, 0xfa, 0x24, 0xde, 0x6d, 0xc9, 0x56, 0x17, 0x2b, 0xaa, 0xb1, + 0x16, 0x11, 0xbe, 0x59, 0x4a, 0xca, 0xb3, 0x36, 0x0d, 0x43, 0xb5, 0xe8, 0xfc, 0x13, 0xd5, 0x44, + 0xe6, 0x92, 0x73, 0x56, 0x1c, 0xe8, 0xde, 0xa2, 0x41, 0xe6, 0x16, 0xf4, 0xc9, 0x12, 0x9e, 0xe8, + 0x6d, 0xe9, 0xb0, 0x1a, 0x8e, 0x7c, 0xee, 0x75, 0x2f, 0x12, 0xdd, 0x86, 0x0b, 0x6f, 0x36, 0x29, + 0x3b, 0x0d, 0xc2, 0x63, 0x93, 0x31, 0x62, 0x1f, 0xf1, 0xe7, 0xa9, 0x3a, 0xae, 0x13, 0xea, 0xa6, + 0xcd, 0x50, 0xb7, 0x35, 0x58, 0x26, 0x9e, 0x4b, 0x22, 0x2a, 0xef, 0xbb, 0x02, 0x8e, 0x9b, 0x9c, + 0x60, 0x12, 0xc7, 0x09, 0x69, 0x14, 0x51, 0xf9, 0xa0, 0x2a, 0xe0, 0x89, 0xc0, 0xf8, 0x97, 0x14, + 0x40, 0xa3, 0x65, 0xee, 0x2a, 0xf3, 0x75, 0xc8, 0x1d, 0x92, 0x81, 0xeb, 0x8d, 0xaf, 0x3b, 0x20, + 0x13, 0x7c, 0xd5, 0x94, 0x86, 0xb6, 0x85, 0x0e, 0x56, 0xba, 0x82, 0x77, 0x8e, 0x0e, 0x7c, 0xca, + 0x12, 0xde, 0x29, 0x5a, 0xfc, 0x92, 0x0b, 0x89, 0x9f, 0x2c, 0xac, 0x6c, 0x70, 0xd7, 0xfb, 0x84, + 0xd1, 0x53, 0x32, 0x8e, 0xe3, 0x59, 0x35, 0xd1, 0x13, 0xce, 0x47, 0xf9, 0x33, 0x99, 0x3a, 0x6b, + 0x59, 0x71, 0x8b, 0x7f, 0x9b, 0x3f, 0x58, 0xc1, 0xe5, 0xf5, 0x9d, 0x68, 0x97, 0x1f, 0x89, 0x3b, + 0x67, 0xd2, 0xf5, 0x9d, 0x9e, 0x83, 0x1f, 0xc1, 0xca, 0xcc, 0x3c, 0x5f, 0x21, 0xfc, 0x8d, 0xd6, + 0xfe, 0x8f, 0xf4, 0x8c, 0xfa, 0xfa, 0x1d, 0x3d, 0x67, 0xfc, 0xb7, 0x06, 0xd0, 0x0a, 0xc2, 0x78, + 0xd3, 0x16, 0x17, 0x58, 0xf2, 0xa2, 0x5c, 0x63, 0x07, 0x9e, 0x0a, 0xcf, 0x85, 0x8c, 0x77, 0x62, + 0x85, 0x13, 0x48, 0x01, 0xc7, 0x89, 0x22, 0xda, 0x80, 0xa2, 0xdc, 0xff, 0xde, 0x30, 0x08, 0x65, + 0x2e, 0x59, 0xc1, 0x20, 0x45, 0x5c, 0x93, 0xbf, 0xde, 0x87, 0xa3, 0x03, 0xcf, 0x8d, 0x8e, 0xa8, + 0x23, 0x31, 0x19, 0x81, 0x59, 0x49, 0xa4, 0x1c, 0x66, 0xd4, 0x21, 0x1f, 0x5b, 0x47, 0x6b, 0x90, + 0xee, 0xd4, 0x5a, 0xfa, 0x52, 0xf9, 0xc6, 0xd9, 0x79, 0xa5, 0x18, 0x8b, 0x3b, 0xb5, 0x16, 0xef, + 0xe9, 0xd6, 0x5b, 0xba, 0x36, 0xdb, 0xd3, 0xad, 0xb7, 0xca, 0x19, 0x7e, 0xdf, 0x18, 0x7f, 0xa5, + 0x41, 0x4e, 0xb2, 0x9f, 0x85, 0x33, 0x36, 0x61, 0x39, 0xe6, 0xe4, 0x92, 0x92, 0xbd, 0x77, 0x35, + 0x7d, 0xaa, 0x2a, 0xb6, 0x23, 0xf7, 0x31, 0xd6, 0x2b, 0x7f, 0x0a, 0xa5, 0xe9, 0x8e, 0xef, 0xb4, + 0x8b, 0x7f, 0x04, 0x45, 0x1e, 0x28, 0x31, 0x8d, 0xda, 0x84, 0x9c, 0x64, 0x68, 0x2a, 0xab, 0x5c, + 0xc7, 0xe5, 0x14, 0x12, 0x3d, 0x84, 0x65, 0xc9, 0xff, 0xe2, 0xca, 0xc4, 0xfa, 0xf5, 0xe1, 0x88, + 0x63, 0xb8, 0xf1, 0x19, 0x64, 0x5a, 0x94, 0x86, 0xe8, 0x1e, 0x2c, 0xfb, 0x81, 0x43, 0x27, 0x49, + 0x54, 0x51, 0x57, 0x87, 0x36, 0xea, 0x9c, 0xba, 0x3a, 0xb4, 0xe1, 0xf0, 0xc5, 0xe3, 0x07, 0x34, + 0x2e, 0xce, 0xf0, 0x6f, 0xa3, 0x03, 0xa5, 0x67, 0xd4, 0xed, 0x1f, 0x31, 0xea, 0x08, 0x43, 0x1f, + 0x40, 0x66, 0x48, 0x13, 0xe7, 0xd7, 0x16, 0x86, 0x0e, 0xa5, 0x21, 0x16, 0x28, 0x7e, 0x20, 0x4f, + 0x85, 0xb6, 0xaa, 0x87, 0xa9, 0x96, 0xf1, 0xf7, 0x29, 0x58, 0x6d, 0x44, 0xd1, 0x88, 0xf8, 0x76, + 0x7c, 0x43, 0xfe, 0x74, 0xf6, 0x86, 0x7c, 0xb0, 0x70, 0x86, 0x33, 0x2a, 0xb3, 0xef, 0x65, 0x95, + 0x24, 0x53, 0x49, 0x92, 0x34, 0xbe, 0xd6, 0xe2, 0x87, 0xf2, 0xfd, 0xa9, 0x73, 0x53, 0x5e, 0x3b, + 0x3b, 0xaf, 0xdc, 0x9a, 0xb6, 0x44, 0xbb, 0xfe, 0xb1, 0x1f, 0x9c, 0xfa, 0xe8, 0x1d, 0xfe, 0x70, + 0x6e, 0x5a, 0xcf, 0x74, 0xad, 0x7c, 0xfb, 0xec, 0xbc, 0x82, 0x66, 0x40, 0x98, 0xfa, 0xf4, 0x94, + 0x5b, 0x6a, 0x59, 0xcd, 0x3a, 0xbf, 0xcc, 0x52, 0x0b, 0x2c, 0xb5, 0xa8, 0xef, 0xb8, 0x7e, 0x1f, + 0xdd, 0x83, 0x5c, 0xa3, 0xdd, 0xee, 0x8a, 0xa7, 0xcc, 0x9b, 0x67, 0xe7, 0x95, 0x37, 0x66, 0x50, + 0xbc, 0x41, 0x1d, 0x0e, 0xe2, 0x54, 0xcb, 0xaa, 0xeb, 0x99, 0x05, 0x20, 0xce, 0x34, 0xa8, 0xa3, + 0x22, 0xfc, 0xdf, 0x53, 0xa0, 0x9b, 0xb6, 0x4d, 0x87, 0x8c, 0xf7, 0x2b, 0xfa, 0xda, 0x81, 0xfc, + 0x90, 0x7f, 0xb9, 0x82, 0x8e, 0xf3, 0xb0, 0x78, 0xb8, 0xb0, 0x58, 0x3a, 0xa7, 0x57, 0xc5, 0x81, + 0x47, 0x4d, 0x67, 0xe0, 0x46, 0x11, 0x7f, 0xa6, 0x09, 0x19, 0x4e, 0x2c, 0x95, 0x7f, 0xa9, 0xc1, + 0x1b, 0x0b, 0x10, 0xe8, 0x23, 0xc8, 0x84, 0x81, 0x17, 0x6f, 0xcf, 0xdd, 0xab, 0x4a, 0x19, 0x5c, + 0x15, 0x0b, 0x24, 0x5a, 0x07, 0x20, 0x23, 0x16, 0x10, 0x31, 0xbe, 0xd8, 0x98, 0x3c, 0x9e, 0x92, + 0xa0, 0x67, 0x90, 0x8b, 0xa8, 0x1d, 0xd2, 0x98, 0x8b, 0x7c, 0xf6, 0xff, 0xf5, 0xbe, 0xda, 0x16, + 0x66, 0xb0, 0x32, 0x57, 0xae, 0x42, 0x4e, 0x4a, 0x78, 0x44, 0x3b, 0x84, 0x11, 0xe1, 0x74, 0x09, + 0x8b, 0x6f, 0x1e, 0x28, 0xc4, 0xeb, 0xc7, 0x81, 0x42, 0xbc, 0xbe, 0xf1, 0xb3, 0x14, 0x80, 0xf5, + 0x9c, 0xd1, 0xd0, 0x27, 0x5e, 0xcd, 0x44, 0xd6, 0x54, 0x86, 0x94, 0xb3, 0xfd, 0xc1, 0xc2, 0x02, + 0x57, 0xa2, 0x51, 0xad, 0x99, 0x0b, 0x72, 0xe4, 0x1d, 0x48, 0x8f, 0x42, 0x4f, 0x15, 0x4b, 0x05, + 0x11, 0xe9, 0xe2, 0x1d, 0xcc, 0x65, 0xc8, 0x9a, 0x64, 0xa4, 0xf4, 0xd5, 0x55, 0xee, 0xa9, 0x01, + 0x7e, 0xf3, 0x59, 0xe9, 0x03, 0x80, 0x89, 0xd7, 0x68, 0x1d, 0xb2, 0xb5, 0xed, 0x76, 0x7b, 0x47, + 0x5f, 0x92, 0xaf, 0xad, 0x49, 0x97, 0x10, 0x1b, 0x7f, 0xa7, 0x41, 0xbe, 0x66, 0xaa, 0x5b, 0x65, + 0x1b, 0x74, 0x91, 0x4b, 0x6c, 0x1a, 0xb2, 0x1e, 0x7d, 0x3e, 0x74, 0xc3, 0xb1, 0x4a, 0x07, 0xd7, + 0xbf, 0x4b, 0x56, 0xb9, 0x56, 0x8d, 0x86, 0xcc, 0x12, 0x3a, 0x08, 0x43, 0x89, 0xaa, 0x29, 0xf6, + 0x6c, 0x12, 0x27, 0xe7, 0xf5, 0xeb, 0x97, 0x42, 0xb2, 0xbf, 0x49, 0x3b, 0xc2, 0xc5, 0xd8, 0x48, + 0x8d, 0x44, 0xc6, 0x3e, 0xbc, 0xb1, 0x17, 0xda, 0x47, 0x34, 0x62, 0x72, 0x50, 0xe5, 0xf2, 0x67, + 0x70, 0x97, 0x91, 0xe8, 0xb8, 0x77, 0xe4, 0x46, 0x2c, 0x08, 0xc7, 0xbd, 0x90, 0x32, 0xea, 0xf3, + 0xfe, 0x9e, 0xa8, 0xa5, 0xab, 0xd7, 0xec, 0x1d, 0x8e, 0x79, 0x22, 0x21, 0x38, 0x46, 0xec, 0x70, + 0x80, 0xd1, 0x80, 0x12, 0x27, 0x6c, 0x75, 0x7a, 0x48, 0x46, 0x1e, 0x8b, 0xd0, 0x8f, 0x01, 0xbc, + 0xa0, 0xdf, 0x7b, 0xed, 0x4c, 0x5e, 0xf0, 0x82, 0xbe, 0xfc, 0x34, 0x7e, 0x0f, 0xf4, 0xba, 0x1b, + 0x0d, 0x09, 0xb3, 0x8f, 0xe2, 0x67, 0x3a, 0x7a, 0x0c, 0xfa, 0x11, 0x25, 0x21, 0x3b, 0xa0, 0x84, + 0xf5, 0x86, 0x34, 0x74, 0x03, 0xe7, 0xb5, 0x96, 0xf4, 0x46, 0xa2, 0xd5, 0x12, 0x4a, 0xc6, 0xaf, + 0x34, 0x00, 0x4c, 0x0e, 0x63, 0x02, 0xf0, 0x43, 0xb8, 0x19, 0xf9, 0x64, 0x18, 0x1d, 0x05, 0xac, + 0xe7, 0xfa, 0x8c, 0x86, 0x27, 0xc4, 0x53, 0x4f, 0x2d, 0x3d, 0xee, 0x68, 0x28, 0x39, 0xfa, 0x00, + 0xd0, 0x31, 0xa5, 0xc3, 0x5e, 0xe0, 0x39, 0xbd, 0xb8, 0x53, 0x16, 0xfb, 0x33, 0x58, 0xe7, 0x3d, + 0x7b, 0x9e, 0xd3, 0x8e, 0xe5, 0x68, 0x0b, 0xd6, 0xf9, 0x0a, 0x50, 0x9f, 0x85, 0x2e, 0x8d, 0x7a, + 0x87, 0x41, 0xd8, 0x8b, 0xbc, 0xe0, 0xb4, 0x77, 0x18, 0x78, 0x5e, 0x70, 0x4a, 0xc3, 0xf8, 0x21, + 0x5b, 0xf6, 0x82, 0xbe, 0x25, 0x41, 0xdb, 0x41, 0xd8, 0xf6, 0x82, 0xd3, 0xed, 0x18, 0xc1, 0x59, + 0xc2, 0x64, 0xda, 0xcc, 0xb5, 0x8f, 0x63, 0x96, 0x90, 0x48, 0x3b, 0xae, 0x7d, 0x8c, 0xee, 0xc1, + 0x0a, 0xf5, 0xa8, 0x78, 0x72, 0x49, 0x54, 0x56, 0xa0, 0x4a, 0xb1, 0x90, 0x83, 0x8c, 0xdf, 0x82, + 0x42, 0xcb, 0x23, 0xb6, 0xf8, 0x4b, 0x85, 0x3f, 0x2e, 0xed, 0xc0, 0xe7, 0x41, 0xe0, 0xfa, 0x4c, + 0x66, 0xc7, 0x02, 0x9e, 0x16, 0x19, 0x3f, 0x05, 0xf8, 0x22, 0x70, 0xfd, 0x4e, 0x70, 0x4c, 0x7d, + 0x51, 0x7d, 0xe6, 0xac, 0x57, 0x6d, 0x65, 0x01, 0xab, 0x96, 0xe0, 0xe4, 0xc4, 0x27, 0x7d, 0x1a, + 0x26, 0x45, 0x58, 0xd9, 0xe4, 0x97, 0x4b, 0x0e, 0x07, 0x01, 0xab, 0x99, 0xa8, 0x02, 0x39, 0x9b, + 0xf4, 0xe2, 0x93, 0x57, 0xda, 0x2a, 0x5c, 0x5e, 0x6c, 0x64, 0x6b, 0xe6, 0x53, 0x3a, 0xc6, 0x59, + 0x9b, 0x3c, 0xa5, 0x63, 0x7e, 0xfb, 0xda, 0x44, 0x9c, 0x17, 0x61, 0xa6, 0x24, 0x6f, 0xdf, 0x9a, + 0xc9, 0x0f, 0x03, 0xce, 0xd9, 0x84, 0xff, 0xa2, 0x8f, 0xa0, 0xa4, 0x40, 0xbd, 0x23, 0x12, 0x1d, + 0x49, 0xae, 0xba, 0xb5, 0x7a, 0x79, 0xb1, 0x01, 0x12, 0xf9, 0x84, 0x44, 0x47, 0x18, 0x24, 0x9a, + 0x7f, 0x23, 0x0b, 0x8a, 0x5f, 0x05, 0xae, 0xdf, 0x63, 0x62, 0x12, 0xaa, 0x36, 0xb0, 0xf0, 0xfc, + 0x4c, 0xa6, 0xaa, 0x1e, 0xca, 0xf0, 0x55, 0x22, 0x31, 0xfe, 0x55, 0x83, 0x22, 0xb7, 0xe9, 0x1e, + 0xba, 0x36, 0xbf, 0x2d, 0xbf, 0x7b, 0xa6, 0xbf, 0x03, 0x69, 0x3b, 0x0a, 0xd5, 0xdc, 0x44, 0xaa, + 0xab, 0xb5, 0x31, 0xe6, 0x32, 0xf4, 0x39, 0xe4, 0xe4, 0xe3, 0x42, 0x25, 0x79, 0xe3, 0xdb, 0xef, + 0x75, 0xe5, 0xa2, 0xd2, 0x13, 0x7b, 0x39, 0xf1, 0x4e, 0xcc, 0xb2, 0x84, 0xa7, 0x45, 0xe8, 0x36, + 0xa4, 0x6c, 0x5f, 0x04, 0x85, 0xfa, 0x57, 0xaa, 0xd6, 0xc4, 0x29, 0xdb, 0x37, 0xfe, 0x59, 0x83, + 0x15, 0xcb, 0xb7, 0xc3, 0xb1, 0x48, 0x92, 0x7c, 0x23, 0xee, 0x42, 0x21, 0x1a, 0x1d, 0x44, 0xe3, + 0x88, 0xd1, 0x41, 0x5c, 0xf4, 0x4e, 0x04, 0xa8, 0x01, 0x05, 0xe2, 0xf5, 0x83, 0xd0, 0x65, 0x47, + 0x03, 0xc5, 0x8d, 0x17, 0x27, 0xe6, 0x69, 0x9b, 0x55, 0x33, 0x56, 0xc1, 0x13, 0xed, 0x38, 0x15, + 0xa7, 0x85, 0xb3, 0x22, 0x15, 0xbf, 0x03, 0x25, 0x8f, 0x0c, 0x38, 0x15, 0xee, 0xf1, 0x27, 0x97, + 0x98, 0x47, 0x06, 0x17, 0x95, 0x8c, 0x3f, 0x23, 0x0d, 0x03, 0x0a, 0x89, 0x31, 0x74, 0x03, 0x8a, + 0xa6, 0xd5, 0xee, 0x7d, 0xbc, 0xf9, 0xb0, 0xf7, 0xb8, 0xb6, 0xab, 0x2f, 0x29, 0x26, 0xf0, 0x8f, + 0x1a, 0xac, 0xec, 0xca, 0x18, 0x54, 0xc4, 0xe9, 0x1e, 0x2c, 0x87, 0xe4, 0x90, 0xc5, 0xd4, 0x2e, + 0x23, 0x83, 0x8b, 0x27, 0x01, 0x4e, 0xed, 0x78, 0xd7, 0x62, 0x6a, 0x37, 0xf5, 0x97, 0x4b, 0xfa, + 0xda, 0xbf, 0x5c, 0x32, 0xbf, 0x91, 0xbf, 0x5c, 0x8c, 0xbf, 0xd4, 0xe0, 0x86, 0xba, 0xa8, 0xe3, + 0xbf, 0x19, 0x16, 0xd2, 0xf5, 0x9f, 0x24, 0x85, 0xc4, 0xf4, 0x55, 0x3c, 0x70, 0xce, 0x4c, 0x75, + 0x52, 0x5d, 0xbc, 0xea, 0x2f, 0x06, 0xe3, 0x0e, 0x64, 0x38, 0x8a, 0xbf, 0x95, 0xb6, 0x1b, 0x3b, + 0x96, 0xbe, 0x84, 0x96, 0x21, 0x6d, 0x35, 0xf7, 0x75, 0xed, 0xfd, 0x5f, 0xa5, 0xa1, 0x90, 0xbc, + 0xc6, 0x79, 0x2c, 0x73, 0x0a, 0xb8, 0x24, 0xab, 0x5b, 0x89, 0xbc, 0x29, 0xc8, 0x5f, 0xc1, 0xdc, + 0xd9, 0xd9, 0xab, 0x99, 0x1d, 0xab, 0xae, 0x7f, 0x2e, 0x39, 0x62, 0x02, 0x30, 0x3d, 0x2f, 0xe0, + 0xd1, 0xe8, 0x20, 0x63, 0xc2, 0x11, 0x5f, 0xa8, 0x1a, 0x5a, 0x82, 0x8a, 0x09, 0xe2, 0xbb, 0x90, + 0x37, 0xdb, 0xed, 0xc6, 0xe3, 0xa6, 0x55, 0xd7, 0x5f, 0x6a, 0xe5, 0xef, 0x9d, 0x9d, 0x57, 0x6e, + 0x4e, 0x4c, 0x45, 0x91, 0xdb, 0xf7, 0xa9, 0x23, 0x50, 0xb5, 0x9a, 0xd5, 0xe2, 0xe3, 0xbd, 0x48, + 0xcd, 0xa3, 0x04, 0x33, 0x12, 0xf5, 0xf0, 0x42, 0x0b, 0x5b, 0x2d, 0x13, 0xf3, 0x11, 0x5f, 0xa6, + 0xe6, 0xfc, 0x6a, 0x85, 0x74, 0x48, 0x42, 0x3e, 0xe6, 0x7a, 0xfc, 0xbf, 0xd0, 0x8b, 0xb4, 0xac, + 0x99, 0x4e, 0x4a, 0x10, 0x94, 0x38, 0x63, 0x3e, 0x5a, 0xbb, 0x63, 0x62, 0x51, 0xa9, 0x79, 0x99, + 0x9e, 0x1b, 0xad, 0xcd, 0x48, 0xc8, 0xb8, 0x15, 0x03, 0x96, 0x71, 0xb7, 0xd9, 0x14, 0xb3, 0xcb, + 0xcc, 0xcd, 0x0e, 0x8f, 0x7c, 0x9f, 0x63, 0xee, 0x43, 0x3e, 0xae, 0xec, 0xe8, 0x2f, 0x33, 0x73, + 0x0e, 0xd5, 0xe2, 0x92, 0x92, 0x18, 0xf0, 0x49, 0xb7, 0x23, 0xfe, 0xb6, 0x7a, 0x91, 0x9d, 0x1f, + 0xf0, 0x68, 0xc4, 0x1c, 0xce, 0xca, 0x2b, 0x09, 0x4d, 0x7e, 0x99, 0x95, 0xec, 0x24, 0xc1, 0x48, + 0x8e, 0xcc, 0xed, 0x60, 0xeb, 0x0b, 0xf9, 0x0f, 0xd7, 0x8b, 0xdc, 0x9c, 0x1d, 0x4c, 0xbf, 0xa2, + 0x36, 0xa3, 0xce, 0xa4, 0x24, 0x9c, 0x74, 0xbd, 0xff, 0xfb, 0x90, 0x8f, 0x33, 0x19, 0x5a, 0x87, + 0xdc, 0xb3, 0x3d, 0xfc, 0xd4, 0xc2, 0xfa, 0x92, 0x5c, 0x9d, 0xb8, 0xe7, 0x99, 0xbc, 0x0a, 0x2a, + 0xb0, 0xbc, 0x6b, 0x36, 0xcd, 0xc7, 0x16, 0x8e, 0x4b, 0xd2, 0x31, 0x40, 0x1d, 0xc7, 0xb2, 0xae, + 0x06, 0x48, 0x6c, 0xbe, 0xff, 0x05, 0x80, 0x0c, 0x55, 0x51, 0xf0, 0x36, 0xa0, 0x50, 0xdb, 0x6b, + 0x76, 0xcc, 0x46, 0x53, 0x0c, 0x22, 0x89, 0x56, 0x52, 0xa0, 0x91, 0x84, 0x75, 0x0d, 0x32, 0xcd, + 0xbd, 0xba, 0xa5, 0x6b, 0xe5, 0xd5, 0xb3, 0xf3, 0x8a, 0xfc, 0x2f, 0x51, 0xf4, 0x6c, 0xdd, 0xfd, + 0xfa, 0x9b, 0xf5, 0xa5, 0x5f, 0x7c, 0xb3, 0xbe, 0xf4, 0xcb, 0x6f, 0xd6, 0xb5, 0x17, 0x97, 0xeb, + 0xda, 0xd7, 0x97, 0xeb, 0xda, 0xcf, 0x2f, 0xd7, 0xb5, 0xff, 0xb8, 0x5c, 0xd7, 0x0e, 0x72, 0x82, + 0x76, 0x7e, 0xf2, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9c, 0x7d, 0x41, 0xe9, 0xef, 0x21, 0x00, + 0x00, } diff --git a/api/types.proto b/api/types.proto index 61087ada38..576bf1ed9f 100644 --- a/api/types.proto +++ b/api/types.proto @@ -713,3 +713,27 @@ message ManagerStatus { // Reachability specifies whether this node is reachable. RaftMemberStatus.Reachability reachability = 4; } + +// SecretType provides information about what kind of secret this is +enum SecretType { + CONTAINER = 0 [(gogoproto.enumvalue_customname) = "ContainerSecret"]; + NODE = 1 [(gogoproto.enumvalue_customname) = "NodeSecret"]; +} + +// SecretReference is the linkage between a service and a secret that it uses. +message SecretReference { + // Name is the name of the secret that this reference. + string name = 1; + + // Mode specifies how this secret should be exposed inside the task. + enum Mode { + FILE = 0; + ENV = 1; + } + + // Mode is one or more ways the secret should be presented. + repeated Mode mode = 2; + + // Target is the name by which the image accesses the secret. + string target = 3; +} diff --git a/manager/dispatcher/dispatcher.go b/manager/dispatcher/dispatcher.go index 791f7a7882..db0dc27687 100644 --- a/manager/dispatcher/dispatcher.go +++ b/manager/dispatcher/dispatcher.go @@ -3,6 +3,7 @@ package dispatcher import ( "errors" "fmt" + "strconv" "sync" "time" @@ -41,6 +42,9 @@ const ( // into a single transaction. A fraction of a second feels about // right. maxBatchInterval = 100 * time.Millisecond + + modificationBatchLimit = 200 + batchingWaitTime = 50 * time.Millisecond ) var ( @@ -668,14 +672,10 @@ func (d *Dispatcher) Tasks(r *api.TasksRequest, stream api.Dispatcher_TasksServe } // bursty events should be processed in batches and sent out snapshot - const ( - modificationBatchLimit = 200 - eventPausedGap = 50 * time.Millisecond - ) var ( - modificationCnt int - eventPausedTimer *time.Timer - eventPausedTimeout <-chan time.Time + modificationCnt int + batchingTimer *time.Timer + batchingTimeout <-chan time.Time ) batchingLoop: @@ -703,13 +703,13 @@ func (d *Dispatcher) Tasks(r *api.TasksRequest, stream api.Dispatcher_TasksServe delete(tasksMap, v.Task.ID) modificationCnt++ } - if eventPausedTimer != nil { - eventPausedTimer.Reset(eventPausedGap) + if batchingTimer != nil { + batchingTimer.Reset(batchingWaitTime) } else { - eventPausedTimer = time.NewTimer(eventPausedGap) - eventPausedTimeout = eventPausedTimer.C + batchingTimer = time.NewTimer(batchingWaitTime) + batchingTimeout = batchingTimer.C } - case <-eventPausedTimeout: + case <-batchingTimeout: break batchingLoop case <-stream.Context().Done(): return stream.Context().Err() @@ -718,8 +718,269 @@ func (d *Dispatcher) Tasks(r *api.TasksRequest, stream api.Dispatcher_TasksServe } } - if eventPausedTimer != nil { - eventPausedTimer.Stop() + if batchingTimer != nil { + batchingTimer.Stop() + } + } +} + +// Assignments is a stream of assignments for a node. Each message contains +// either full list of tasks and secrets for the node, or an incremental update. +func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatcher_AssignmentsServer) error { + nodeInfo, err := ca.RemoteNode(stream.Context()) + if err != nil { + return err + } + nodeID := nodeInfo.NodeID + + if err := d.isRunningLocked(); err != nil { + return err + } + + fields := logrus.Fields{ + "node.id": nodeID, + "node.session": r.SessionID, + "method": "(*Dispatcher).Assignments", + } + if nodeInfo.ForwardedBy != nil { + fields["forwarder.id"] = nodeInfo.ForwardedBy.NodeID + } + log := log.G(stream.Context()).WithFields(fields) + log.Debugf("") + + if _, err = d.nodes.GetWithSession(nodeID, r.SessionID); err != nil { + return err + } + + var ( + sequence int64 + appliesTo string + initial api.AssignmentsMessage + ) + tasksMap := make(map[string]*api.Task) + tasksUsingSecret := make(map[string]map[string]struct{}) + + sendMessage := func(msg api.AssignmentsMessage, assignmentType api.AssignmentsMessage_AssignmentType) error { + sequence++ + msg.AppliesTo = appliesTo + msg.ResultsIn = strconv.FormatInt(sequence, 10) + appliesTo = msg.ResultsIn + msg.Type = assignmentType + + if err := stream.Send(&msg); err != nil { + return err + } + return nil + } + + addSecretsForTask := func(readTx store.ReadTx, t *api.Task, msg *api.AssignmentsMessage) { + container := t.Spec.GetContainer() + if container == nil { + return + } + for _, secretRef := range container.Secrets { + secretName := secretRef.Name + if tasksUsingSecret[secretName] == nil { + tasksUsingSecret[secretName] = make(map[string]struct{}) + + secrets, err := store.FindSecrets(readTx, store.ByName(secretName)) + if err != nil { + log.WithError(err).Errorf("error retrieving secret %s", secretName) + continue + } + if len(secrets) != 1 { + log.Debugf("secret not found: %s", secretName) + continue + } + + // If the secret was found and there was one result + // (there should never be more than one because of the + // uniqueness constraint), add this secret to our + // initial set that we send down. + msg.UpdateSecrets = append(msg.UpdateSecrets, secrets[0]) + } + tasksUsingSecret[secretName][t.ID] = struct{}{} + } + } + + // TODO(aaronl): Also send node secrets that should be exposed to + // this node. + nodeTasks, cancel, err := store.ViewAndWatch( + d.store, + func(readTx store.ReadTx) error { + tasks, err := store.FindTasks(readTx, store.ByNodeID(nodeID)) + if err != nil { + return err + } + + for _, t := range tasks { + // We only care about tasks that are ASSIGNED or + // higher. If the state is below ASSIGNED, the + // task may not meet the constraints for this + // node, so we have to be careful about sending + // secrets associated with it. + if t.Status.State < api.TaskStateAssigned { + continue + } + + tasksMap[t.ID] = t + initial.UpdateTasks = append(initial.UpdateTasks, t) + addSecretsForTask(readTx, t, &initial) + } + return nil + }, + state.EventUpdateTask{Task: &api.Task{NodeID: nodeID}, + Checks: []state.TaskCheckFunc{state.TaskCheckNodeID}}, + state.EventDeleteTask{Task: &api.Task{NodeID: nodeID}, + Checks: []state.TaskCheckFunc{state.TaskCheckNodeID}}, + state.EventUpdateSecret{}, + state.EventDeleteSecret{}, + ) + if err != nil { + return err + } + defer cancel() + + if err := sendMessage(initial, api.AssignmentsMessage_COMPLETE); err != nil { + return err + } + + for { + // Check for session expiration + if _, err := d.nodes.GetWithSession(nodeID, r.SessionID); err != nil { + return err + } + + var update api.AssignmentsMessage + + // bursty events should be processed in batches and sent out together + var ( + modificationCnt int + batchingTimer *time.Timer + batchingTimeout <-chan time.Time + ) + + oneModification := func() { + modificationCnt++ + + if batchingTimer != nil { + batchingTimer.Reset(batchingWaitTime) + } else { + batchingTimer = time.NewTimer(batchingWaitTime) + batchingTimeout = batchingTimer.C + } + } + + // The batching loop waits for 50 ms after the most recent + // change, or until modificationBatchLimit is reached. The + // worst case latency is modificationBatchLimit * batchingWaitTime, + // which is 10 seconds. + batchingLoop: + for modificationCnt < modificationBatchLimit { + select { + case event := <-nodeTasks: + switch v := event.(type) { + // We don't monitor EventCreateTask because tasks are + // never created in the ASSIGNED state. First tasks are + // created by the orchestrator, then the scheduler moves + // them to ASSIGNED. If this ever changes, we will need + // to monitor task creations as well. + case state.EventUpdateTask: + // We only care about tasks that are ASSIGNED or + // higher. + if v.Task.Status.State < api.TaskStateAssigned { + continue + } + + update.UpdateTasks = append(update.UpdateTasks, v.Task) + + if oldTask, exists := tasksMap[v.Task.ID]; exists { + // States ASSIGNED and below are set by the orchestrator/scheduler, + // not the agent, so tasks in these states need to be sent to the + // agent even if nothing else has changed. + if equality.TasksEqualStable(oldTask, v.Task) && v.Task.Status.State > api.TaskStateAssigned { + // this update should not trigger action at agent + tasksMap[v.Task.ID] = v.Task + continue + } + } else { + // If this task wasn't part of the assignment set before, + // add the secrets it references to the secrets assignment + // set. + d.store.View(func(readTx store.ReadTx) { + addSecretsForTask(readTx, v.Task, &update) + }) + } + tasksMap[v.Task.ID] = v.Task + + oneModification() + case state.EventDeleteTask: + if _, exists := tasksMap[v.Task.ID]; !exists { + continue + } + + update.RemoveTasks = append(update.RemoveTasks, v.Task.ID) + + delete(tasksMap, v.Task.ID) + + // Release the secrets references from this task + + container := v.Task.Spec.GetContainer() + if container == nil { + continue + } + for _, secretRef := range container.Secrets { + secretName := secretRef.Name + if tasksUsingSecret[secretName] == nil { + continue + } + delete(tasksUsingSecret[secretName], v.Task.ID) + if len(tasksUsingSecret[secretName]) == 0 { + // No tasks are using the secret anymore + delete(tasksUsingSecret, secretName) + update.RemoveSecrets = append(update.RemoveSecrets, secretName) + } + } + + oneModification() + // TODO(aaronl): For node secrets, we'll need to handle + // EventCreateSecret. + case state.EventUpdateSecret: + if _, exists := tasksUsingSecret[v.Secret.Spec.Annotations.Name]; !exists { + continue + } + + update.UpdateSecrets = append(update.UpdateSecrets, v.Secret) + + oneModification() + case state.EventDeleteSecret: + if _, exists := tasksUsingSecret[v.Secret.Spec.Annotations.Name]; !exists { + continue + } + + delete(tasksUsingSecret, v.Secret.Spec.Annotations.Name) + + update.RemoveSecrets = append(update.RemoveSecrets, v.Secret.Spec.Annotations.Name) + + oneModification() + } + case <-batchingTimeout: + break batchingLoop + case <-stream.Context().Done(): + return stream.Context().Err() + case <-d.ctx.Done(): + return d.ctx.Err() + } + } + + if batchingTimer != nil { + batchingTimer.Stop() + } + + if modificationCnt > 0 { + if err := sendMessage(update, api.AssignmentsMessage_INCREMENTAL); err != nil { + return err + } } } } diff --git a/manager/state/store/secrets.go b/manager/state/store/secrets.go new file mode 100644 index 0000000000..b8b25488af --- /dev/null +++ b/manager/state/store/secrets.go @@ -0,0 +1,225 @@ +package store + +import ( + "strings" + + "github.com/docker/swarmkit/api" + "github.com/docker/swarmkit/manager/state" + memdb "github.com/hashicorp/go-memdb" +) + +const tableSecret = "secret" + +func init() { + register(ObjectStoreConfig{ + Name: tableSecret, + Table: &memdb.TableSchema{ + Name: tableSecret, + Indexes: map[string]*memdb.IndexSchema{ + indexID: { + Name: indexID, + Unique: true, + Indexer: secretIndexerByID{}, + }, + indexName: { + Name: indexName, + Unique: true, + Indexer: secretIndexerByName{}, + }, + }, + }, + Save: func(tx ReadTx, snapshot *api.StoreSnapshot) error { + var err error + snapshot.Secrets, err = FindSecrets(tx, All) + return err + }, + Restore: func(tx Tx, snapshot *api.StoreSnapshot) error { + secrets, err := FindSecrets(tx, All) + if err != nil { + return err + } + for _, s := range secrets { + if err := DeleteSecret(tx, s.ID); err != nil { + return err + } + } + for _, s := range snapshot.Secrets { + if err := CreateSecret(tx, s); err != nil { + return err + } + } + return nil + }, + ApplyStoreAction: func(tx Tx, sa *api.StoreAction) error { + switch v := sa.Target.(type) { + case *api.StoreAction_Secret: + obj := v.Secret + switch sa.Action { + case api.StoreActionKindCreate: + return CreateSecret(tx, obj) + case api.StoreActionKindUpdate: + return UpdateSecret(tx, obj) + case api.StoreActionKindRemove: + return DeleteSecret(tx, obj.ID) + } + } + return errUnknownStoreAction + }, + NewStoreAction: func(c state.Event) (api.StoreAction, error) { + var sa api.StoreAction + switch v := c.(type) { + case state.EventCreateSecret: + sa.Action = api.StoreActionKindCreate + sa.Target = &api.StoreAction_Secret{ + Secret: v.Secret, + } + case state.EventUpdateSecret: + sa.Action = api.StoreActionKindUpdate + sa.Target = &api.StoreAction_Secret{ + Secret: v.Secret, + } + case state.EventDeleteSecret: + sa.Action = api.StoreActionKindRemove + sa.Target = &api.StoreAction_Secret{ + Secret: v.Secret, + } + default: + return api.StoreAction{}, errUnknownStoreAction + } + return sa, nil + }, + }) +} + +type secretEntry struct { + *api.Secret +} + +func (s secretEntry) ID() string { + return s.Secret.ID +} + +func (s secretEntry) Meta() api.Meta { + return s.Secret.Meta +} + +func (s secretEntry) SetMeta(meta api.Meta) { + s.Secret.Meta = meta +} + +func (s secretEntry) Copy() Object { + return secretEntry{s.Secret.Copy()} +} + +func (s secretEntry) EventCreate() state.Event { + return state.EventCreateSecret{Secret: s.Secret} +} + +func (s secretEntry) EventUpdate() state.Event { + return state.EventUpdateSecret{Secret: s.Secret} +} + +func (s secretEntry) EventDelete() state.Event { + return state.EventDeleteSecret{Secret: s.Secret} +} + +// CreateSecret adds a new secret to the store. +// Returns ErrExist if the ID is already taken. +func CreateSecret(tx Tx, s *api.Secret) error { + // Ensure the name is not already in use. + if tx.lookup(tableSecret, indexName, strings.ToLower(s.Spec.Annotations.Name)) != nil { + return ErrNameConflict + } + + return tx.create(tableSecret, secretEntry{s}) +} + +// UpdateSecret updates an existing secret in the store. +// Returns ErrNotExist if the secret doesn't exist. +func UpdateSecret(tx Tx, s *api.Secret) error { + // Ensure the name is either not in use or already used by this same Secret. + if existing := tx.lookup(tableSecret, indexName, strings.ToLower(s.Spec.Annotations.Name)); existing != nil { + if existing.ID() != s.ID { + return ErrNameConflict + } + } + + return tx.update(tableSecret, secretEntry{s}) +} + +// DeleteSecret removes a secret from the store. +// Returns ErrNotExist if the secret doesn't exist. +func DeleteSecret(tx Tx, id string) error { + return tx.delete(tableSecret, id) +} + +// GetSecret looks up a secret by ID. +// Returns nil if the secret doesn't exist. +func GetSecret(tx ReadTx, id string) *api.Secret { + n := tx.get(tableSecret, id) + if n == nil { + return nil + } + return n.(secretEntry).Secret +} + +// FindSecrets selects a set of secrets and returns them. +func FindSecrets(tx ReadTx, by By) ([]*api.Secret, error) { + checkType := func(by By) error { + switch by.(type) { + case byName, byNamePrefix, byIDPrefix: + return nil + default: + return ErrInvalidFindBy + } + } + + secretList := []*api.Secret{} + appendResult := func(o Object) { + secretList = append(secretList, o.(secretEntry).Secret) + } + + err := tx.find(tableSecret, by, checkType, appendResult) + return secretList, err +} + +type secretIndexerByID struct{} + +func (ci secretIndexerByID) FromArgs(args ...interface{}) ([]byte, error) { + return fromArgs(args...) +} + +func (ci secretIndexerByID) FromObject(obj interface{}) (bool, []byte, error) { + s, ok := obj.(secretEntry) + if !ok { + panic("unexpected type passed to FromObject") + } + + // Add the null character as a terminator + val := s.Secret.ID + "\x00" + return true, []byte(val), nil +} + +func (ci secretIndexerByID) PrefixFromArgs(args ...interface{}) ([]byte, error) { + return prefixFromArgs(args...) +} + +type secretIndexerByName struct{} + +func (ci secretIndexerByName) FromArgs(args ...interface{}) ([]byte, error) { + return fromArgs(args...) +} + +func (ci secretIndexerByName) FromObject(obj interface{}) (bool, []byte, error) { + s, ok := obj.(secretEntry) + if !ok { + panic("unexpected type passed to FromObject") + } + + // Add the null character as a terminator + return true, []byte(strings.ToLower(s.Spec.Annotations.Name) + "\x00"), nil +} + +func (ci secretIndexerByName) PrefixFromArgs(args ...interface{}) ([]byte, error) { + return prefixFromArgs(args...) +} diff --git a/manager/state/watch.go b/manager/state/watch.go index 0d0a742c4d..cf1f29b5e1 100644 --- a/manager/state/watch.go +++ b/manager/state/watch.go @@ -451,6 +451,87 @@ func (e EventDeleteCluster) matches(watchEvent events.Event) bool { return true } +// SecretCheckFunc is the type of function used to perform filtering checks on +// api.Secret structures. +type SecretCheckFunc func(v1, v2 *api.Secret) bool + +// SecretCheckID is a SecretCheckFunc for matching volume IDs. +func SecretCheckID(v1, v2 *api.Secret) bool { + return v1.ID == v2.ID +} + +// EventCreateSecret is the type used to put CreateSecret events on the +// publish/subscribe queue and filter these events in calls to Watch. +type EventCreateSecret struct { + Secret *api.Secret + // Checks is a list of functions to call to filter events for a watch + // stream. They are applied with AND logic. They are only applicable for + // calls to Watch. + Checks []SecretCheckFunc +} + +func (e EventCreateSecret) matches(watchEvent events.Event) bool { + typedEvent, ok := watchEvent.(EventCreateSecret) + if !ok { + return false + } + + for _, check := range e.Checks { + if !check(e.Secret, typedEvent.Secret) { + return false + } + } + return true +} + +// EventUpdateSecret is the type used to put UpdateSecret events on the +// publish/subscribe queue and filter these events in calls to Watch. +type EventUpdateSecret struct { + Secret *api.Secret + // Checks is a list of functions to call to filter events for a watch + // stream. They are applied with AND logic. They are only applicable for + // calls to Watch. + Checks []SecretCheckFunc +} + +func (e EventUpdateSecret) matches(watchEvent events.Event) bool { + typedEvent, ok := watchEvent.(EventUpdateSecret) + if !ok { + return false + } + + for _, check := range e.Checks { + if !check(e.Secret, typedEvent.Secret) { + return false + } + } + return true +} + +// EventDeleteSecret is the type used to put DeleteSecret events on the +// publish/subscribe queue and filter these events in calls to Watch. +type EventDeleteSecret struct { + Secret *api.Secret + // Checks is a list of functions to call to filter events for a watch + // stream. They are applied with AND logic. They are only applicable for + // calls to Watch. + Checks []SecretCheckFunc +} + +func (e EventDeleteSecret) matches(watchEvent events.Event) bool { + typedEvent, ok := watchEvent.(EventDeleteSecret) + if !ok { + return false + } + + for _, check := range e.Checks { + if !check(e.Secret, typedEvent.Secret) { + return false + } + } + return true +} + // Watch takes a variable number of events to match against. The subscriber // will receive events that match any of the arguments passed to Watch. // From d7695f37e557e339b3e15bca94624e5b80d0b506 Mon Sep 17 00:00:00 2001 From: cyli Date: Wed, 7 Sep 2016 13:41:28 -0700 Subject: [PATCH 02/10] Remove secrets part of previous commit Signed-off-by: cyli --- api/dispatcher.pb.go | 260 +++-------- api/dispatcher.proto | 10 - api/objects.pb.go | 419 +++--------------- api/objects.proto | 14 +- api/raft.pb.go | 225 +++------- api/raft.proto | 1 - api/snapshot.pb.go | 116 ++--- api/snapshot.proto | 1 - api/specs.pb.go | 542 ++++------------------- api/specs.proto | 20 +- api/types.pb.go | 732 +++++++++---------------------- api/types.proto | 26 +- manager/dispatcher/dispatcher.go | 80 ---- manager/state/store/secrets.go | 225 ---------- manager/state/watch.go | 81 ---- 15 files changed, 530 insertions(+), 2222 deletions(-) delete mode 100644 manager/state/store/secrets.go diff --git a/api/dispatcher.pb.go b/api/dispatcher.pb.go index e2bcf27543..df061bc136 100644 --- a/api/dispatcher.pb.go +++ b/api/dispatcher.pb.go @@ -234,14 +234,6 @@ type AssignmentsMessage struct { // assignment set. It is not used in the first assignments message of // a stream. RemoveTasks []string `protobuf:"bytes,5,rep,name=remove_tasks,json=removeTasks" json:"remove_tasks,omitempty"` - // UpdateSecrets is a set of new or updated secrets for this node. - // In the first assignments message, it contains all of the secrets - // the node needs for itself and its assigned tasks. - UpdateSecrets []*Secret `protobuf:"bytes,6,rep,name=update_secrets,json=updateSecrets" json:"update_secrets,omitempty"` - // RemoveSecrets is a set of previously-assigned secret names to remove - // from memory. It is not used in the first assignments message of - // a stream. - RemoveSecrets []string `protobuf:"bytes,7,rep,name=remove_secrets,json=removeSecrets" json:"remove_secrets,omitempty"` } func (m *AssignmentsMessage) Reset() { *m = AssignmentsMessage{} } @@ -487,20 +479,6 @@ func (m *AssignmentsMessage) Copy() *AssignmentsMessage { } } - if m.UpdateSecrets != nil { - o.UpdateSecrets = make([]*Secret, 0, len(m.UpdateSecrets)) - for _, v := range m.UpdateSecrets { - o.UpdateSecrets = append(o.UpdateSecrets, v.Copy()) - } - } - - if m.RemoveSecrets != nil { - o.RemoveSecrets = make([]string, 0, len(m.RemoveSecrets)) - for _, v := range m.RemoveSecrets { - o.RemoveSecrets = append(o.RemoveSecrets, v) - } - } - return o } @@ -627,7 +605,7 @@ func (this *AssignmentsMessage) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 11) + s := make([]string, 0, 9) s = append(s, "&api.AssignmentsMessage{") s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n") s = append(s, "AppliesTo: "+fmt.Sprintf("%#v", this.AppliesTo)+",\n") @@ -636,10 +614,6 @@ func (this *AssignmentsMessage) GoString() string { s = append(s, "UpdateTasks: "+fmt.Sprintf("%#v", this.UpdateTasks)+",\n") } s = append(s, "RemoveTasks: "+fmt.Sprintf("%#v", this.RemoveTasks)+",\n") - if this.UpdateSecrets != nil { - s = append(s, "UpdateSecrets: "+fmt.Sprintf("%#v", this.UpdateSecrets)+",\n") - } - s = append(s, "RemoveSecrets: "+fmt.Sprintf("%#v", this.RemoveSecrets)+",\n") s = append(s, "}") return strings.Join(s, "") } @@ -1369,33 +1343,6 @@ func (m *AssignmentsMessage) MarshalTo(data []byte) (int, error) { i += copy(data[i:], s) } } - if len(m.UpdateSecrets) > 0 { - for _, msg := range m.UpdateSecrets { - data[i] = 0x32 - i++ - i = encodeVarintDispatcher(data, i, uint64(msg.Size())) - n, err := msg.MarshalTo(data[i:]) - if err != nil { - return 0, err - } - i += n - } - } - if len(m.RemoveSecrets) > 0 { - for _, s := range m.RemoveSecrets { - data[i] = 0x3a - i++ - l = len(s) - for l >= 1<<7 { - data[i] = uint8(uint64(l)&0x7f | 0x80) - l >>= 7 - i++ - } - data[i] = uint8(l) - i++ - i += copy(data[i:], s) - } - } return i, nil } @@ -1626,18 +1573,30 @@ func (p *raftProxyDispatcherServer) Tasks(r *TasksRequest, stream Dispatcher_Tas func (p *raftProxyDispatcherServer) Assignments(r *AssignmentsRequest, stream Dispatcher_AssignmentsServer) error { - ctx := stream.Context() - conn, err := p.connSelector.LeaderConn(ctx) + if p.cluster.IsLeader() { + return p.local.Assignments(r, stream) + } + ctx, err := p.runCtxMods(stream.Context()) if err != nil { - if err == raftselector.ErrIsLeader { - return p.local.Assignments(r, stream) - } return err } - ctx, err = p.runCtxMods(ctx) + conn, err := p.connSelector.Conn() if err != nil { return err } + + defer func() { + if err != nil { + errStr := err.Error() + if strings.Contains(errStr, grpc.ErrClientConnClosing.Error()) || + strings.Contains(errStr, grpc.ErrClientConnTimeout.Error()) || + strings.Contains(errStr, "connection error") || + grpc.Code(err) == codes.Internal { + p.connSelector.Reset() + } + } + }() + clientStream, err := NewDispatcherClient(conn).Assignments(ctx, r) if err != nil { @@ -1811,18 +1770,6 @@ func (m *AssignmentsMessage) Size() (n int) { n += 1 + l + sovDispatcher(uint64(l)) } } - if len(m.UpdateSecrets) > 0 { - for _, e := range m.UpdateSecrets { - l = e.Size() - n += 1 + l + sovDispatcher(uint64(l)) - } - } - if len(m.RemoveSecrets) > 0 { - for _, s := range m.RemoveSecrets { - l = len(s) - n += 1 + l + sovDispatcher(uint64(l)) - } - } return n } @@ -1954,8 +1901,6 @@ func (this *AssignmentsMessage) String() string { `ResultsIn:` + fmt.Sprintf("%v", this.ResultsIn) + `,`, `UpdateTasks:` + strings.Replace(fmt.Sprintf("%v", this.UpdateTasks), "Task", "Task", 1) + `,`, `RemoveTasks:` + fmt.Sprintf("%v", this.RemoveTasks) + `,`, - `UpdateSecrets:` + strings.Replace(fmt.Sprintf("%v", this.UpdateSecrets), "Secret", "Secret", 1) + `,`, - `RemoveSecrets:` + fmt.Sprintf("%v", this.RemoveSecrets) + `,`, `}`, }, "") return s @@ -3090,66 +3035,6 @@ func (m *AssignmentsMessage) Unmarshal(data []byte) error { } m.RemoveTasks = append(m.RemoveTasks, string(data[iNdEx:postIndex])) iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UpdateSecrets", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDispatcher - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - msglen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthDispatcher - } - postIndex := iNdEx + msglen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.UpdateSecrets = append(m.UpdateSecrets, &Secret{}) - if err := m.UpdateSecrets[len(m.UpdateSecrets)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RemoveSecrets", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowDispatcher - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthDispatcher - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.RemoveSecrets = append(m.RemoveSecrets, string(data[iNdEx:postIndex])) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipDispatcher(data[iNdEx:]) @@ -3277,59 +3162,56 @@ var ( ) var fileDescriptorDispatcher = []byte{ - // 851 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x56, 0x41, 0x6f, 0x1b, 0x45, - 0x14, 0xce, 0xc6, 0x8e, 0x53, 0xbf, 0xb5, 0x8d, 0x19, 0x2a, 0xba, 0x5a, 0xb5, 0x1b, 0x77, 0x43, - 0xab, 0x48, 0x04, 0x07, 0x8c, 0xe0, 0x00, 0x11, 0x22, 0xae, 0x2d, 0x61, 0xb5, 0x49, 0xab, 0x8d, - 0xa1, 0x47, 0x6b, 0xed, 0x7d, 0x72, 0x17, 0xc7, 0x3b, 0xcb, 0xcc, 0xb8, 0xc5, 0x07, 0x24, 0x24, - 0xe0, 0x8e, 0x90, 0x90, 0xfa, 0x2b, 0xf8, 0x1d, 0x11, 0x27, 0x8e, 0x9c, 0x22, 0xe2, 0x1f, 0x80, - 0xf8, 0x09, 0x68, 0x77, 0x66, 0x1d, 0xd7, 0x59, 0x27, 0x76, 0x4e, 0xd9, 0x79, 0xf3, 0x7d, 0xdf, - 0xfb, 0xf4, 0xde, 0xbc, 0x17, 0x43, 0xd9, 0xf3, 0x79, 0xe8, 0x8a, 0xde, 0x0b, 0x64, 0xd5, 0x90, - 0x51, 0x41, 0x09, 0xf1, 0x68, 0x6f, 0x80, 0xac, 0xca, 0x5f, 0xb9, 0x6c, 0x38, 0xf0, 0x45, 0xf5, - 0xe5, 0x47, 0xa6, 0x2e, 0xc6, 0x21, 0x72, 0x09, 0x30, 0x8b, 0xb4, 0xfb, 0x2d, 0xf6, 0x44, 0x72, - 0xbc, 0xdd, 0xa7, 0x7d, 0x1a, 0x7f, 0xee, 0x45, 0x5f, 0x2a, 0xfa, 0x4e, 0x78, 0x32, 0xea, 0xfb, - 0xc1, 0x9e, 0xfc, 0xa3, 0x82, 0x77, 0xbc, 0x11, 0x73, 0x85, 0x4f, 0x83, 0xbd, 0xe4, 0x43, 0x5e, - 0xd8, 0xbf, 0x68, 0x50, 0x3a, 0x46, 0xce, 0x7d, 0x1a, 0x38, 0xf8, 0xdd, 0x08, 0xb9, 0x20, 0x4d, - 0xd0, 0x3d, 0xe4, 0x3d, 0xe6, 0x87, 0x11, 0xce, 0xd0, 0x2a, 0xda, 0x8e, 0x5e, 0xdb, 0xae, 0x5e, - 0x36, 0x57, 0x3d, 0xa2, 0x1e, 0x36, 0x2e, 0xa0, 0xce, 0x2c, 0x8f, 0xec, 0x02, 0x70, 0x29, 0xdc, - 0xf1, 0x3d, 0x63, 0xbd, 0xa2, 0xed, 0xe4, 0xeb, 0xc5, 0xc9, 0xd9, 0x56, 0x5e, 0xa5, 0x6b, 0x35, - 0x9c, 0xbc, 0x02, 0xb4, 0x3c, 0xfb, 0xa7, 0xf5, 0xa9, 0x8f, 0x43, 0xe4, 0xdc, 0xed, 0xe3, 0x9c, - 0x80, 0x76, 0xb5, 0x00, 0xd9, 0x85, 0x6c, 0x40, 0x3d, 0x8c, 0x13, 0xe9, 0x35, 0x63, 0x91, 0x5d, - 0x27, 0x46, 0x91, 0x7d, 0xb8, 0x35, 0x74, 0x03, 0xb7, 0x8f, 0x8c, 0x1b, 0x99, 0x4a, 0x66, 0x47, - 0xaf, 0x55, 0xd2, 0x18, 0xcf, 0xd1, 0xef, 0xbf, 0x10, 0xe8, 0x3d, 0x43, 0x64, 0xce, 0x94, 0x41, - 0x9e, 0xc3, 0xbb, 0x01, 0x8a, 0x57, 0x94, 0x0d, 0x3a, 0x5d, 0x4a, 0x05, 0x17, 0xcc, 0x0d, 0x3b, - 0x03, 0x1c, 0x73, 0x23, 0x1b, 0x6b, 0xdd, 0x4f, 0xd3, 0x6a, 0x06, 0x3d, 0x36, 0x8e, 0x4b, 0xf3, - 0x18, 0xc7, 0xce, 0x6d, 0x25, 0x50, 0x4f, 0xf8, 0x8f, 0x71, 0xcc, 0xed, 0x2f, 0xa1, 0xfc, 0x15, - 0xba, 0x4c, 0x74, 0xd1, 0x15, 0x49, 0x3b, 0x56, 0x2a, 0x83, 0xfd, 0x14, 0xde, 0x9e, 0x51, 0xe0, - 0x21, 0x0d, 0x38, 0x92, 0xcf, 0x20, 0x17, 0x22, 0xf3, 0xa9, 0xa7, 0x9a, 0x79, 0x37, 0xcd, 0x5f, - 0x43, 0x3d, 0x8c, 0x7a, 0xf6, 0xf4, 0x6c, 0x6b, 0xcd, 0x51, 0x0c, 0xfb, 0xd7, 0x75, 0xb8, 0xf3, - 0x75, 0xe8, 0xb9, 0x02, 0xdb, 0x2e, 0x1f, 0x1c, 0x0b, 0x57, 0x8c, 0xf8, 0x8d, 0xac, 0x91, 0x6f, - 0x60, 0x73, 0x14, 0x0b, 0x25, 0x25, 0xdf, 0x4f, 0xb3, 0xb1, 0x20, 0x57, 0xf5, 0x22, 0x22, 0x11, - 0x4e, 0x22, 0x66, 0x52, 0x28, 0xcf, 0x5f, 0x92, 0x6d, 0xd8, 0x14, 0x2e, 0x1f, 0x5c, 0xd8, 0x82, - 0xc9, 0xd9, 0x56, 0x2e, 0x82, 0xb5, 0x1a, 0x4e, 0x2e, 0xba, 0x6a, 0x79, 0xe4, 0x53, 0xc8, 0xf1, - 0x98, 0xa4, 0x1e, 0x8d, 0x95, 0xe6, 0x67, 0xc6, 0x89, 0x42, 0xdb, 0x26, 0x18, 0x97, 0x5d, 0xca, - 0x52, 0xdb, 0xfb, 0x50, 0x88, 0xa2, 0x37, 0x2b, 0x91, 0xfd, 0x85, 0x62, 0x27, 0x23, 0x50, 0x85, - 0x8d, 0xc8, 0x2b, 0x37, 0xb4, 0xb8, 0x60, 0xc6, 0x22, 0x83, 0x8e, 0x84, 0xd9, 0x75, 0x20, 0x07, - 0x9c, 0xfb, 0xfd, 0x60, 0x88, 0x81, 0xb8, 0xa1, 0x87, 0xd7, 0x99, 0x37, 0x44, 0x12, 0x2b, 0x2d, - 0xc8, 0x46, 0xab, 0x28, 0xa6, 0x97, 0x6a, 0x9f, 0xa4, 0x39, 0xb9, 0xcc, 0x9a, 0x09, 0xb5, 0xc7, - 0x21, 0x3a, 0xb1, 0x04, 0xb9, 0x07, 0xe0, 0x86, 0xe1, 0x89, 0x8f, 0xbc, 0x23, 0xa8, 0xdc, 0x0c, - 0x4e, 0x5e, 0x45, 0xda, 0x34, 0xba, 0x66, 0xc8, 0x47, 0x27, 0x82, 0x77, 0xfc, 0xc0, 0xc8, 0xc8, - 0x6b, 0x15, 0x69, 0x05, 0xe4, 0x73, 0x28, 0xc8, 0xce, 0x77, 0x64, 0x69, 0xb2, 0xd7, 0x94, 0x46, - 0x1f, 0x4d, 0x7b, 0xc5, 0xc9, 0x7d, 0x28, 0x30, 0x1c, 0xd2, 0x97, 0x09, 0x79, 0xa3, 0x92, 0xd9, - 0xc9, 0x3b, 0xba, 0x8c, 0x49, 0xc8, 0x01, 0x94, 0x94, 0x3e, 0xc7, 0x1e, 0x43, 0xc1, 0x8d, 0x5c, - 0x9c, 0xc1, 0x4c, 0xcb, 0x70, 0x1c, 0x43, 0x9c, 0xa2, 0x64, 0xc8, 0x13, 0x27, 0x0f, 0xa0, 0xa4, - 0xb2, 0x24, 0x12, 0x9b, 0x71, 0x9e, 0xa2, 0x8c, 0x2a, 0x98, 0xbd, 0x07, 0xa5, 0x37, 0xeb, 0x43, - 0x0a, 0x70, 0xeb, 0xd1, 0xd3, 0xc3, 0x67, 0x4f, 0x9a, 0xed, 0x66, 0x79, 0x8d, 0xbc, 0x05, 0x7a, - 0xeb, 0xe8, 0x91, 0xd3, 0x3c, 0x6c, 0x1e, 0xb5, 0x0f, 0x9e, 0x94, 0xb5, 0xda, 0xef, 0x1b, 0x00, - 0x8d, 0xe9, 0x7f, 0x0d, 0xf2, 0x3d, 0x6c, 0xaa, 0x0e, 0x12, 0x3b, 0xdd, 0xdc, 0xec, 0x5e, 0x37, - 0xaf, 0xc2, 0xa8, 0x7e, 0xd9, 0xdb, 0x7f, 0xfe, 0xf1, 0xef, 0xeb, 0xf5, 0x7b, 0x50, 0x88, 0x31, - 0x1f, 0x44, 0x1b, 0x0a, 0x19, 0x14, 0xe5, 0x49, 0xed, 0xbf, 0x0f, 0x35, 0xf2, 0x03, 0xe4, 0xa7, - 0x5b, 0x86, 0xbc, 0x97, 0xa6, 0x3b, 0xbf, 0xc6, 0xcc, 0x07, 0xd7, 0xa0, 0xd4, 0xfc, 0x2c, 0x63, - 0x80, 0xfc, 0xa6, 0x41, 0x79, 0x7e, 0x02, 0xc9, 0xfb, 0x2b, 0x6c, 0x13, 0x73, 0x77, 0x39, 0xf0, - 0x2a, 0xa6, 0x18, 0x6c, 0xc8, 0x07, 0x54, 0x59, 0xf4, 0x14, 0xa7, 0xd9, 0x17, 0x23, 0x56, 0xec, - 0xc3, 0xcf, 0x1a, 0xe8, 0x33, 0x53, 0x47, 0x1e, 0x5e, 0x33, 0x96, 0x89, 0x81, 0x87, 0xcb, 0x8d, - 0xef, 0x92, 0x36, 0xea, 0x77, 0x4f, 0xcf, 0xad, 0xb5, 0xbf, 0xcf, 0xad, 0xb5, 0xff, 0xce, 0x2d, - 0xed, 0xc7, 0x89, 0xa5, 0x9d, 0x4e, 0x2c, 0xed, 0xaf, 0x89, 0xa5, 0xfd, 0x33, 0xb1, 0xb4, 0x6e, - 0x2e, 0xfe, 0xa5, 0xf1, 0xf1, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd2, 0xf0, 0x33, 0x4d, 0xf1, - 0x08, 0x00, 0x00, + // 812 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x95, 0xdf, 0x6e, 0xe3, 0x44, + 0x14, 0xc6, 0xe3, 0xfc, 0xeb, 0xe6, 0x38, 0x2d, 0x61, 0x58, 0xb1, 0x56, 0xb4, 0xeb, 0x66, 0x5d, + 0x58, 0x45, 0xa2, 0x24, 0x10, 0x04, 0x17, 0x50, 0x21, 0x36, 0x9b, 0x48, 0x44, 0xbb, 0xed, 0x56, + 0x6e, 0xa0, 0x97, 0x91, 0x13, 0x1f, 0xa5, 0x26, 0x8d, 0xc7, 0xcc, 0x4c, 0x5a, 0x72, 0x81, 0x84, + 0x04, 0xdc, 0x23, 0x24, 0x24, 0x9e, 0xa2, 0xcf, 0x51, 0x71, 0xc5, 0x25, 0x57, 0x15, 0xcd, 0x03, + 0x20, 0x1e, 0x61, 0x65, 0x7b, 0x9c, 0xa6, 0xa9, 0xd3, 0x26, 0xbd, 0xca, 0xf8, 0xcc, 0x77, 0xbe, + 0xf9, 0xe9, 0xcc, 0x9c, 0x13, 0x28, 0xd8, 0x0e, 0xf7, 0x2c, 0xd1, 0x3b, 0x42, 0x56, 0xf1, 0x18, + 0x15, 0x94, 0x10, 0x9b, 0xf6, 0x06, 0xc8, 0x2a, 0xfc, 0xd4, 0x62, 0xc3, 0x81, 0x23, 0x2a, 0x27, + 0x1f, 0x17, 0x55, 0x31, 0xf6, 0x90, 0x87, 0x82, 0xe2, 0x3a, 0xed, 0x7e, 0x87, 0x3d, 0x11, 0x7d, + 0x3e, 0xec, 0xd3, 0x3e, 0x0d, 0x96, 0x55, 0x7f, 0x25, 0xa3, 0xef, 0x78, 0xc7, 0xa3, 0xbe, 0xe3, + 0x56, 0xc3, 0x1f, 0x19, 0x7c, 0x64, 0x8f, 0x98, 0x25, 0x1c, 0xea, 0x56, 0xa3, 0x45, 0xb8, 0x61, + 0xfc, 0xaa, 0xc0, 0xc6, 0x01, 0x72, 0xee, 0x50, 0xd7, 0xc4, 0xef, 0x47, 0xc8, 0x05, 0x69, 0x82, + 0x6a, 0x23, 0xef, 0x31, 0xc7, 0xf3, 0x75, 0x9a, 0x52, 0x52, 0xca, 0x6a, 0x6d, 0xab, 0x72, 0x13, + 0xae, 0xb2, 0x47, 0x6d, 0x6c, 0x5c, 0x49, 0xcd, 0xd9, 0x3c, 0xb2, 0x0d, 0xc0, 0x43, 0xe3, 0x8e, + 0x63, 0x6b, 0xc9, 0x92, 0x52, 0xce, 0xd5, 0xd7, 0x27, 0x17, 0x9b, 0x39, 0x79, 0x5c, 0xab, 0x61, + 0xe6, 0xa4, 0xa0, 0x65, 0x1b, 0x3f, 0x27, 0xa7, 0x1c, 0xbb, 0xc8, 0xb9, 0xd5, 0xc7, 0x39, 0x03, + 0xe5, 0x76, 0x03, 0xb2, 0x0d, 0x69, 0x97, 0xda, 0x18, 0x1c, 0xa4, 0xd6, 0xb4, 0x45, 0xb8, 0x66, + 0xa0, 0x22, 0x3b, 0xf0, 0x60, 0x68, 0xb9, 0x56, 0x1f, 0x19, 0xd7, 0x52, 0xa5, 0x54, 0x59, 0xad, + 0x95, 0xe2, 0x32, 0x0e, 0xd1, 0xe9, 0x1f, 0x09, 0xb4, 0xf7, 0x11, 0x99, 0x39, 0xcd, 0x20, 0x87, + 0xf0, 0xae, 0x8b, 0xe2, 0x94, 0xb2, 0x41, 0xa7, 0x4b, 0xa9, 0xe0, 0x82, 0x59, 0x5e, 0x67, 0x80, + 0x63, 0xae, 0xa5, 0x03, 0xaf, 0xa7, 0x71, 0x5e, 0x4d, 0xb7, 0xc7, 0xc6, 0x41, 0x69, 0x5e, 0xe2, + 0xd8, 0x7c, 0x28, 0x0d, 0xea, 0x51, 0xfe, 0x4b, 0x1c, 0x73, 0xe3, 0x2b, 0x28, 0x7c, 0x8d, 0x16, + 0x13, 0x5d, 0xb4, 0x44, 0x74, 0x1d, 0x2b, 0x95, 0xc1, 0x78, 0x0d, 0x6f, 0xcf, 0x38, 0x70, 0x8f, + 0xba, 0x1c, 0xc9, 0xe7, 0x90, 0xf5, 0x90, 0x39, 0xd4, 0x96, 0x97, 0xf9, 0x38, 0x8e, 0xaf, 0x21, + 0x1f, 0x46, 0x3d, 0x7d, 0x7e, 0xb1, 0x99, 0x30, 0x65, 0x86, 0xf1, 0x5b, 0x12, 0x1e, 0x7d, 0xe3, + 0xd9, 0x96, 0xc0, 0xb6, 0xc5, 0x07, 0x07, 0xc2, 0x12, 0x23, 0x7e, 0x2f, 0x34, 0xf2, 0x2d, 0xac, + 0x8d, 0x02, 0xa3, 0xa8, 0xe4, 0x3b, 0x71, 0x18, 0x0b, 0xce, 0xaa, 0x5c, 0x45, 0x42, 0x85, 0x19, + 0x99, 0x15, 0x29, 0x14, 0xe6, 0x37, 0xc9, 0x16, 0xac, 0x09, 0x8b, 0x0f, 0xae, 0xb0, 0x60, 0x72, + 0xb1, 0x99, 0xf5, 0x65, 0xad, 0x86, 0x99, 0xf5, 0xb7, 0x5a, 0x36, 0xf9, 0x0c, 0xb2, 0x3c, 0x48, + 0x92, 0x8f, 0x46, 0x8f, 0xe3, 0x99, 0x21, 0x91, 0x6a, 0xa3, 0x08, 0xda, 0x4d, 0xca, 0xb0, 0xd4, + 0xc6, 0x0e, 0xe4, 0xfd, 0xe8, 0xfd, 0x4a, 0x64, 0x7c, 0x29, 0xb3, 0xa3, 0x16, 0xa8, 0x40, 0xc6, + 0x67, 0xe5, 0x9a, 0x12, 0x14, 0x4c, 0x5b, 0x04, 0x68, 0x86, 0x32, 0xa3, 0x0e, 0xe4, 0x39, 0xe7, + 0x4e, 0xdf, 0x1d, 0xa2, 0x2b, 0xee, 0xc9, 0x70, 0x96, 0xbc, 0x66, 0x12, 0xa1, 0xb4, 0x20, 0xed, + 0x8f, 0xa2, 0x20, 0x7d, 0xa3, 0xf6, 0x69, 0x1c, 0xc9, 0xcd, 0xac, 0x99, 0x50, 0x7b, 0xec, 0xa1, + 0x19, 0x58, 0x90, 0x27, 0x00, 0x96, 0xe7, 0x1d, 0x3b, 0xc8, 0x3b, 0x82, 0x86, 0x93, 0xc1, 0xcc, + 0xc9, 0x48, 0x9b, 0xfa, 0xdb, 0x0c, 0xf9, 0xe8, 0x58, 0xf0, 0x8e, 0xe3, 0x6a, 0xa9, 0x70, 0x5b, + 0x46, 0x5a, 0x2e, 0xf9, 0x02, 0xf2, 0xe1, 0xcd, 0x77, 0xc2, 0xd2, 0xa4, 0xef, 0x28, 0x8d, 0x3a, + 0x9a, 0xde, 0x15, 0x27, 0x4f, 0x21, 0xcf, 0x70, 0x48, 0x4f, 0xa2, 0xe4, 0x4c, 0x29, 0x55, 0xce, + 0x99, 0x6a, 0x18, 0x0b, 0x24, 0x46, 0x15, 0x36, 0xae, 0x53, 0x93, 0x3c, 0x3c, 0x78, 0xf1, 0x7a, + 0x77, 0xff, 0x55, 0xb3, 0xdd, 0x2c, 0x24, 0xc8, 0x5b, 0xa0, 0xb6, 0xf6, 0x5e, 0x98, 0xcd, 0xdd, + 0xe6, 0x5e, 0xfb, 0xf9, 0xab, 0x82, 0x52, 0xfb, 0x23, 0x03, 0xd0, 0x98, 0xce, 0x72, 0xf2, 0x03, + 0xac, 0xc9, 0xba, 0x12, 0x23, 0x0e, 0xea, 0xfa, 0xb4, 0x2d, 0xde, 0xa6, 0x91, 0x55, 0x34, 0xb6, + 0xfe, 0x3a, 0xfb, 0xef, 0xcf, 0xe4, 0x13, 0xc8, 0x07, 0x9a, 0x0f, 0xfd, 0xb9, 0x81, 0x0c, 0xd6, + 0xc3, 0x2f, 0x39, 0x95, 0x3e, 0x52, 0xc8, 0x8f, 0x90, 0x9b, 0xf6, 0x3e, 0x79, 0x2f, 0xce, 0x77, + 0x7e, 0xb8, 0x14, 0xdf, 0xbf, 0x43, 0x25, 0x5f, 0xf5, 0x32, 0x00, 0xe4, 0x77, 0x05, 0x0a, 0xf3, + 0x7d, 0x41, 0x3e, 0x58, 0xa1, 0xc7, 0x8b, 0xdb, 0xcb, 0x89, 0x57, 0x81, 0x62, 0x90, 0x09, 0x6f, + 0xbe, 0xb4, 0xe8, 0x81, 0x4c, 0x4f, 0x5f, 0xac, 0x58, 0xf1, 0x1e, 0x7e, 0x51, 0x40, 0x9d, 0xe9, + 0x05, 0xf2, 0xec, 0x8e, 0x66, 0x89, 0x00, 0x9e, 0x2d, 0xd7, 0x54, 0x4b, 0x62, 0xd4, 0x1f, 0x9f, + 0x5f, 0xea, 0x89, 0x7f, 0x2e, 0xf5, 0xc4, 0xff, 0x97, 0xba, 0xf2, 0xd3, 0x44, 0x57, 0xce, 0x27, + 0xba, 0xf2, 0xf7, 0x44, 0x57, 0xfe, 0x9d, 0xe8, 0x4a, 0x37, 0x1b, 0xfc, 0xff, 0x7f, 0xf2, 0x26, + 0x00, 0x00, 0xff, 0xff, 0x85, 0xe6, 0xd0, 0x78, 0x87, 0x08, 0x00, 0x00, } diff --git a/api/dispatcher.proto b/api/dispatcher.proto index 15cc66ac1d..18d5516b85 100644 --- a/api/dispatcher.proto +++ b/api/dispatcher.proto @@ -201,14 +201,4 @@ message AssignmentsMessage { // assignment set. It is not used in the first assignments message of // a stream. repeated string remove_tasks = 5; - - // UpdateSecrets is a set of new or updated secrets for this node. - // In the first assignments message, it contains all of the secrets - // the node needs for itself and its assigned tasks. - repeated Secret update_secrets = 6; - - // RemoveSecrets is a set of previously-assigned secret names to remove - // from memory. It is not used in the first assignments message of - // a stream. - repeated string remove_secrets = 7; } diff --git a/api/objects.pb.go b/api/objects.pb.go index afa392a322..e2671b6b7c 100644 --- a/api/objects.pb.go +++ b/api/objects.pb.go @@ -230,19 +230,6 @@ func (m *Cluster) Reset() { *m = Cluster{} } func (*Cluster) ProtoMessage() {} func (*Cluster) Descriptor() ([]byte, []int) { return fileDescriptorObjects, []int{7} } -// Secret -type Secret struct { - ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - Meta Meta `protobuf:"bytes,2,opt,name=meta" json:"meta"` - Spec SecretSpec `protobuf:"bytes,3,opt,name=spec" json:"spec"` - // Version is a hash of the secret. - Version string `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"` -} - -func (m *Secret) Reset() { *m = Secret{} } -func (*Secret) ProtoMessage() {} -func (*Secret) Descriptor() ([]byte, []int) { return fileDescriptorObjects, []int{8} } - func init() { proto.RegisterType((*Meta)(nil), "docker.swarmkit.v1.Meta") proto.RegisterType((*Node)(nil), "docker.swarmkit.v1.Node") @@ -253,7 +240,6 @@ func init() { proto.RegisterType((*NetworkAttachment)(nil), "docker.swarmkit.v1.NetworkAttachment") proto.RegisterType((*Network)(nil), "docker.swarmkit.v1.Network") proto.RegisterType((*Cluster)(nil), "docker.swarmkit.v1.Cluster") - proto.RegisterType((*Secret)(nil), "docker.swarmkit.v1.Secret") } func (m *Meta) Copy() *Meta { @@ -439,21 +425,6 @@ func (m *Cluster) Copy() *Cluster { return o } -func (m *Secret) Copy() *Secret { - if m == nil { - return nil - } - - o := &Secret{ - ID: m.ID, - Meta: *m.Meta.Copy(), - Spec: *m.Spec.Copy(), - Version: m.Version, - } - - return o -} - func (this *Meta) GoString() string { if this == nil { return "nil" @@ -617,19 +588,6 @@ func (this *Cluster) GoString() string { s = append(s, "}") return strings.Join(s, "") } -func (this *Secret) GoString() string { - if this == nil { - return "nil" - } - s := make([]string, 0, 8) - s = append(s, "&api.Secret{") - s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n") - s = append(s, "Meta: "+strings.Replace(this.Meta.GoString(), `&`, ``, 1)+",\n") - s = append(s, "Spec: "+strings.Replace(this.Spec.GoString(), `&`, ``, 1)+",\n") - s = append(s, "Version: "+fmt.Sprintf("%#v", this.Version)+",\n") - s = append(s, "}") - return strings.Join(s, "") -} func valueToGoStringObjects(v interface{}, typ string) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -1230,52 +1188,6 @@ func (m *Cluster) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *Secret) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *Secret) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.ID) > 0 { - data[i] = 0xa - i++ - i = encodeVarintObjects(data, i, uint64(len(m.ID))) - i += copy(data[i:], m.ID) - } - data[i] = 0x12 - i++ - i = encodeVarintObjects(data, i, uint64(m.Meta.Size())) - n31, err := m.Meta.MarshalTo(data[i:]) - if err != nil { - return 0, err - } - i += n31 - data[i] = 0x1a - i++ - i = encodeVarintObjects(data, i, uint64(m.Spec.Size())) - n32, err := m.Spec.MarshalTo(data[i:]) - if err != nil { - return 0, err - } - i += n32 - if len(m.Version) > 0 { - data[i] = 0x22 - i++ - i = encodeVarintObjects(data, i, uint64(len(m.Version))) - i += copy(data[i:], m.Version) - } - return i, nil -} - func encodeFixed64Objects(data []byte, offset int, v uint64) int { data[offset] = uint8(v) data[offset+1] = uint8(v >> 8) @@ -1525,24 +1437,6 @@ func (m *Cluster) Size() (n int) { return n } -func (m *Secret) Size() (n int) { - var l int - _ = l - l = len(m.ID) - if l > 0 { - n += 1 + l + sovObjects(uint64(l)) - } - l = m.Meta.Size() - n += 1 + l + sovObjects(uint64(l)) - l = m.Spec.Size() - n += 1 + l + sovObjects(uint64(l)) - l = len(m.Version) - if l > 0 { - n += 1 + l + sovObjects(uint64(l)) - } - return n -} - func sovObjects(x uint64) (n int) { for { n++ @@ -1685,19 +1579,6 @@ func (this *Cluster) String() string { }, "") return s } -func (this *Secret) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&Secret{`, - `ID:` + fmt.Sprintf("%v", this.ID) + `,`, - `Meta:` + strings.Replace(strings.Replace(this.Meta.String(), "Meta", "Meta", 1), `&`, ``, 1) + `,`, - `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "SecretSpec", "SecretSpec", 1), `&`, ``, 1) + `,`, - `Version:` + fmt.Sprintf("%v", this.Version) + `,`, - `}`, - }, "") - return s -} func valueToStringObjects(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -3595,174 +3476,6 @@ func (m *Cluster) Unmarshal(data []byte) error { } return nil } -func (m *Secret) Unmarshal(data []byte) error { - l := len(data) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowObjects - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: Secret: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Secret: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowObjects - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthObjects - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ID = string(data[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Meta", 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 err := m.Meta.Unmarshal(data[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Spec", 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 err := m.Spec.Unmarshal(data[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowObjects - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthObjects - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Version = string(data[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipObjects(data[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthObjects - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func skipObjects(data []byte) (n int, err error) { l := len(data) iNdEx := 0 @@ -3869,71 +3582,69 @@ var ( ) var fileDescriptorObjects = []byte{ - // 1045 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x56, 0x4f, 0x6f, 0x1b, 0x45, - 0x14, 0xcf, 0xda, 0x1b, 0xdb, 0xfb, 0x1c, 0x47, 0x62, 0xa8, 0xaa, 0x6d, 0x08, 0x76, 0x70, 0x05, - 0xea, 0xa1, 0x72, 0x45, 0x29, 0xa8, 0x15, 0xad, 0x90, 0xed, 0x58, 0x60, 0x95, 0x40, 0x34, 0x29, - 0xe9, 0x71, 0x35, 0xd9, 0x9d, 0x9a, 0xc5, 0xf6, 0xce, 0x6a, 0x66, 0xec, 0xca, 0x37, 0xc4, 0x07, - 0x40, 0xe2, 0x0b, 0x70, 0xe6, 0x5b, 0x70, 0xcd, 0x81, 0x03, 0x47, 0x4e, 0x16, 0xf1, 0x8d, 0x13, - 0x7c, 0x04, 0x34, 0xb3, 0xb3, 0xf6, 0x46, 0x5e, 0xa7, 0xad, 0x54, 0xe5, 0x36, 0xb3, 0xf3, 0xfb, - 0xfd, 0xde, 0x9f, 0x79, 0xef, 0xed, 0x40, 0x8d, 0x9d, 0xfd, 0x40, 0x7d, 0x29, 0x5a, 0x31, 0x67, - 0x92, 0x21, 0x14, 0x30, 0x7f, 0x48, 0x79, 0x4b, 0xbc, 0x24, 0x7c, 0x3c, 0x0c, 0x65, 0x6b, 0xfa, - 0xf1, 0x5e, 0x55, 0xce, 0x62, 0x6a, 0x00, 0x7b, 0x55, 0x11, 0x53, 0x3f, 0xdd, 0xdc, 0x92, 0xe1, - 0x98, 0x0a, 0x49, 0xc6, 0xf1, 0xbd, 0xe5, 0xca, 0x1c, 0xdd, 0x18, 0xb0, 0x01, 0xd3, 0xcb, 0x7b, - 0x6a, 0x95, 0x7c, 0x6d, 0xfe, 0x6e, 0x81, 0x7d, 0x44, 0x25, 0x41, 0x9f, 0x43, 0x79, 0x4a, 0xb9, - 0x08, 0x59, 0xe4, 0x5a, 0x07, 0xd6, 0x9d, 0xea, 0xfd, 0xf7, 0x5a, 0xeb, 0x96, 0x5b, 0xa7, 0x09, - 0xa4, 0x63, 0x9f, 0xcf, 0x1b, 0x5b, 0x38, 0x65, 0xa0, 0xc7, 0x00, 0x3e, 0xa7, 0x44, 0xd2, 0xc0, - 0x23, 0xd2, 0x2d, 0x68, 0xfe, 0xfb, 0x79, 0xfc, 0x67, 0xa9, 0x53, 0xd8, 0x31, 0x84, 0xb6, 0x54, - 0xec, 0x49, 0x1c, 0xa4, 0xec, 0xe2, 0x6b, 0xb1, 0x0d, 0xa1, 0x2d, 0x9b, 0xff, 0x14, 0xc1, 0xfe, - 0x86, 0x05, 0x14, 0xdd, 0x84, 0x42, 0x18, 0x68, 0xe7, 0x9d, 0x4e, 0x69, 0x31, 0x6f, 0x14, 0xfa, - 0x87, 0xb8, 0x10, 0x06, 0xe8, 0x3e, 0xd8, 0x63, 0x2a, 0x89, 0x71, 0xcb, 0xcd, 0x13, 0x56, 0x19, - 0x30, 0x31, 0x69, 0x2c, 0xfa, 0x0c, 0x6c, 0x95, 0x56, 0xe3, 0xcc, 0x7e, 0x1e, 0x47, 0xd9, 0x3c, - 0x89, 0xa9, 0x9f, 0xf2, 0x14, 0x1e, 0xf5, 0xa0, 0x1a, 0x50, 0xe1, 0xf3, 0x30, 0x96, 0x2a, 0x93, - 0xb6, 0xa6, 0xdf, 0xde, 0x44, 0x3f, 0x5c, 0x41, 0x71, 0x96, 0x87, 0x1e, 0x43, 0x49, 0x48, 0x22, - 0x27, 0xc2, 0xdd, 0xd6, 0x0a, 0xf5, 0x8d, 0x0e, 0x68, 0x94, 0x71, 0xc1, 0x70, 0xd0, 0x57, 0xb0, - 0x3b, 0x26, 0x11, 0x19, 0x50, 0xee, 0x19, 0x95, 0x92, 0x56, 0xf9, 0x20, 0x37, 0xf4, 0x04, 0x99, - 0x08, 0xe1, 0xda, 0x38, 0xbb, 0x45, 0x3d, 0x00, 0x22, 0x25, 0xf1, 0xbf, 0x1f, 0xd3, 0x48, 0xba, - 0x65, 0xad, 0xf2, 0x61, 0xae, 0x2f, 0x54, 0xbe, 0x64, 0x7c, 0xd8, 0x5e, 0x82, 0x71, 0x86, 0x88, - 0xbe, 0x84, 0xaa, 0x4f, 0xb9, 0x0c, 0x5f, 0x84, 0x3e, 0x91, 0xd4, 0xad, 0x68, 0x9d, 0x46, 0x9e, - 0x4e, 0x77, 0x05, 0x33, 0x41, 0x65, 0x99, 0xcd, 0x5f, 0x0a, 0x50, 0x3e, 0xa1, 0x7c, 0x1a, 0xfa, - 0x6f, 0xf7, 0xba, 0x1f, 0x5d, 0xba, 0xee, 0x5c, 0xcf, 0x8c, 0xd9, 0xb5, 0x1b, 0x7f, 0x08, 0x15, - 0x1a, 0x05, 0x31, 0x0b, 0x23, 0x69, 0xae, 0x3b, 0xb7, 0x5a, 0x7a, 0x06, 0x83, 0x97, 0x68, 0xd4, - 0x83, 0x5a, 0x52, 0xc5, 0xde, 0xa5, 0xbb, 0x3e, 0xc8, 0xa3, 0x7f, 0xa7, 0x81, 0xe6, 0x92, 0x76, - 0x26, 0x99, 0x5d, 0xf3, 0xd7, 0x02, 0x54, 0x52, 0x75, 0xf4, 0xc0, 0x04, 0x62, 0x6d, 0x96, 0x4a, - 0xb1, 0x2a, 0x12, 0x13, 0xc3, 0x03, 0xd8, 0x8e, 0x19, 0x97, 0xc2, 0x2d, 0x1c, 0x14, 0x37, 0x55, - 0xdb, 0x31, 0xe3, 0xb2, 0xcb, 0xa2, 0x17, 0xe1, 0x00, 0x27, 0x60, 0xf4, 0x1c, 0xaa, 0xd3, 0x90, - 0xcb, 0x09, 0x19, 0x79, 0x61, 0x2c, 0xdc, 0xa2, 0xe6, 0x7e, 0x74, 0x95, 0xc9, 0xd6, 0x69, 0x82, - 0xef, 0x1f, 0x77, 0x76, 0x17, 0xf3, 0x06, 0x2c, 0xb7, 0x02, 0x83, 0x91, 0xea, 0xc7, 0x62, 0xef, - 0x08, 0x9c, 0xe5, 0x09, 0xba, 0x0b, 0x10, 0x25, 0xc5, 0xe5, 0x2d, 0xaf, 0xbb, 0xb6, 0x98, 0x37, - 0x1c, 0x53, 0x72, 0xfd, 0x43, 0xec, 0x18, 0x40, 0x3f, 0x40, 0x08, 0x6c, 0x12, 0x04, 0x5c, 0x5f, - 0xbe, 0x83, 0xf5, 0xba, 0xf9, 0xc7, 0x36, 0xd8, 0xcf, 0x88, 0x18, 0x5e, 0xf7, 0x80, 0x50, 0x36, - 0xd7, 0xca, 0xe5, 0x2e, 0x80, 0x48, 0x2a, 0x49, 0x85, 0x63, 0xaf, 0xc2, 0x31, 0xf5, 0xa5, 0xc2, - 0x31, 0x80, 0x24, 0x1c, 0x31, 0x62, 0x52, 0x57, 0x86, 0x8d, 0xf5, 0x1a, 0xdd, 0x86, 0x72, 0xc4, - 0x02, 0x4d, 0x2f, 0x69, 0x3a, 0x2c, 0xe6, 0x8d, 0x92, 0x1a, 0x06, 0xfd, 0x43, 0x5c, 0x52, 0x47, - 0xfd, 0x40, 0x75, 0x1c, 0x89, 0x22, 0x26, 0x89, 0x1a, 0x27, 0xc2, 0x74, 0x6e, 0x6e, 0x5d, 0xb7, - 0x57, 0xb0, 0xb4, 0xe3, 0x32, 0x4c, 0x74, 0x0a, 0xef, 0xa6, 0xfe, 0x66, 0x05, 0x2b, 0x6f, 0x22, - 0x88, 0x8c, 0x42, 0xe6, 0x24, 0x33, 0xe1, 0x9c, 0xcd, 0x13, 0x4e, 0x67, 0x30, 0x6f, 0xc2, 0x75, - 0xa0, 0x16, 0x50, 0x11, 0x72, 0x1a, 0xe8, 0xde, 0xa1, 0x2e, 0x1c, 0x58, 0x77, 0x76, 0x37, 0xfc, - 0x34, 0x8c, 0x08, 0xc5, 0x3b, 0x86, 0xa3, 0x77, 0xa8, 0x0d, 0x15, 0x53, 0x37, 0xc2, 0xad, 0xea, - 0xda, 0x7d, 0xcd, 0xc9, 0xb6, 0xa4, 0x5d, 0xea, 0xfd, 0x9d, 0x37, 0xea, 0xfd, 0x47, 0x00, 0x23, - 0x36, 0xf0, 0x02, 0x1e, 0x4e, 0x29, 0x77, 0x6b, 0x9a, 0xbb, 0x97, 0xc7, 0x3d, 0xd4, 0x08, 0xec, - 0x8c, 0xd8, 0x20, 0x59, 0x36, 0x7f, 0xb2, 0xe0, 0x9d, 0x35, 0xa7, 0xd0, 0xa7, 0x50, 0x36, 0x6e, - 0x5d, 0xf5, 0xfb, 0x36, 0x3c, 0x9c, 0x62, 0xd1, 0x3e, 0x38, 0xaa, 0x47, 0xa8, 0x10, 0x34, 0xe9, - 0x7e, 0x07, 0xaf, 0x3e, 0x20, 0x17, 0xca, 0x64, 0x14, 0x12, 0x75, 0x56, 0xd4, 0x67, 0xe9, 0xb6, - 0xf9, 0x73, 0x01, 0xca, 0x46, 0xec, 0xba, 0x07, 0xb1, 0x31, 0xbb, 0xd6, 0x59, 0x4f, 0x60, 0x27, - 0x49, 0xa7, 0x29, 0x09, 0xfb, 0x95, 0x49, 0xad, 0x26, 0xf8, 0xa4, 0x1c, 0x9e, 0x80, 0x1d, 0xc6, - 0x64, 0x6c, 0x86, 0x70, 0xae, 0xe5, 0xfe, 0x71, 0xfb, 0xe8, 0xdb, 0x38, 0xa9, 0xec, 0xca, 0x62, - 0xde, 0xb0, 0xd5, 0x07, 0xac, 0x69, 0xcd, 0x7f, 0x0b, 0x50, 0xee, 0x8e, 0x26, 0x42, 0x52, 0x7e, - 0xdd, 0x09, 0x31, 0x66, 0xd7, 0x12, 0xd2, 0x85, 0x32, 0x67, 0x4c, 0x7a, 0x3e, 0xb9, 0x2a, 0x17, - 0x98, 0x31, 0xd9, 0x6d, 0x77, 0x76, 0x15, 0x51, 0x0d, 0x92, 0x64, 0x8f, 0x4b, 0x8a, 0xda, 0x25, - 0xe8, 0x39, 0xdc, 0x4c, 0xc7, 0xef, 0x19, 0x63, 0x52, 0x48, 0x4e, 0x62, 0x6f, 0x48, 0x67, 0xea, - 0x6f, 0x55, 0xdc, 0xf4, 0xa6, 0xe8, 0x45, 0x3e, 0x9f, 0xe9, 0x44, 0x3d, 0xa5, 0x33, 0x7c, 0xc3, - 0x08, 0x74, 0x52, 0xfe, 0x53, 0x3a, 0x13, 0xe8, 0x0b, 0xd8, 0xa7, 0x4b, 0x98, 0x52, 0xf4, 0x46, - 0x64, 0xac, 0x7e, 0x2c, 0x9e, 0x3f, 0x62, 0xfe, 0x50, 0xcf, 0x36, 0x1b, 0xdf, 0xa2, 0x59, 0xa9, - 0xaf, 0x13, 0x44, 0x57, 0x01, 0x9a, 0xbf, 0x59, 0x50, 0x3a, 0xa1, 0x3e, 0xa7, 0xf2, 0xad, 0x26, - 0xfc, 0xe1, 0xa5, 0x84, 0xd7, 0xf3, 0x9f, 0x02, 0xca, 0xea, 0x5a, 0xbe, 0xdd, 0xd5, 0x0b, 0x5a, - 0xcf, 0xf5, 0xe5, 0xf3, 0xb8, 0xb3, 0x7f, 0x7e, 0x51, 0xdf, 0xfa, 0xeb, 0xa2, 0xbe, 0xf5, 0xdf, - 0x45, 0xdd, 0xfa, 0x71, 0x51, 0xb7, 0xce, 0x17, 0x75, 0xeb, 0xcf, 0x45, 0xdd, 0xfa, 0x7b, 0x51, - 0xb7, 0xce, 0x4a, 0xfa, 0x25, 0xfe, 0xc9, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x23, 0x63, 0x5e, - 0xc5, 0xf9, 0x0b, 0x00, 0x00, + // 1009 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x56, 0xcf, 0x6e, 0x1b, 0x45, + 0x1c, 0xce, 0xda, 0x1b, 0xdb, 0xfb, 0x73, 0x1c, 0x89, 0xa1, 0xaa, 0xb6, 0x21, 0xd8, 0xc1, 0x15, + 0xa8, 0x87, 0xca, 0x15, 0xa5, 0x20, 0x2a, 0x5a, 0x21, 0xff, 0x13, 0x58, 0x25, 0x10, 0x4d, 0x4b, + 0x7a, 0x5c, 0x4d, 0x76, 0xa7, 0x66, 0xb1, 0xbd, 0xb3, 0x9a, 0x19, 0xbb, 0xf2, 0x0d, 0xf1, 0x00, + 0x48, 0xbc, 0x00, 0xaf, 0xc2, 0x35, 0x07, 0x0e, 0x1c, 0x39, 0x59, 0xc4, 0x37, 0x4e, 0xf0, 0x08, + 0x68, 0x66, 0x67, 0xed, 0x8d, 0xbc, 0x0e, 0x8d, 0x84, 0x72, 0x9b, 0xd9, 0xf9, 0xbe, 0x6f, 0x7e, + 0xff, 0x67, 0xa1, 0xc6, 0xce, 0xbe, 0xa7, 0xbe, 0x14, 0xad, 0x98, 0x33, 0xc9, 0x10, 0x0a, 0x98, + 0x3f, 0xa2, 0xbc, 0x25, 0x5e, 0x13, 0x3e, 0x19, 0x85, 0xb2, 0x35, 0xfb, 0xf0, 0xa0, 0x2a, 0xe7, + 0x31, 0x35, 0x80, 0x83, 0xaa, 0x88, 0xa9, 0x9f, 0x6e, 0xee, 0xc8, 0x70, 0x42, 0x85, 0x24, 0x93, + 0xf8, 0xc1, 0x6a, 0x65, 0x8e, 0x6e, 0x0d, 0xd9, 0x90, 0xe9, 0xe5, 0x03, 0xb5, 0x4a, 0xbe, 0x36, + 0x7f, 0xb5, 0xc0, 0x3e, 0xa6, 0x92, 0xa0, 0xcf, 0xa0, 0x3c, 0xa3, 0x5c, 0x84, 0x2c, 0x72, 0xad, + 0x23, 0xeb, 0x5e, 0xf5, 0xe1, 0x3b, 0xad, 0xcd, 0x9b, 0x5b, 0xa7, 0x09, 0xa4, 0x63, 0x9f, 0x2f, + 0x1a, 0x3b, 0x38, 0x65, 0xa0, 0x27, 0x00, 0x3e, 0xa7, 0x44, 0xd2, 0xc0, 0x23, 0xd2, 0x2d, 0x68, + 0xfe, 0xbb, 0x79, 0xfc, 0x17, 0xa9, 0x51, 0xd8, 0x31, 0x84, 0xb6, 0x54, 0xec, 0x69, 0x1c, 0xa4, + 0xec, 0xe2, 0x1b, 0xb1, 0x0d, 0xa1, 0x2d, 0x9b, 0x7f, 0x15, 0xc1, 0xfe, 0x9a, 0x05, 0x14, 0xdd, + 0x86, 0x42, 0x18, 0x68, 0xe3, 0x9d, 0x4e, 0x69, 0xb9, 0x68, 0x14, 0x06, 0x3d, 0x5c, 0x08, 0x03, + 0xf4, 0x10, 0xec, 0x09, 0x95, 0xc4, 0x98, 0xe5, 0xe6, 0x09, 0xab, 0x08, 0x18, 0x9f, 0x34, 0x16, + 0x7d, 0x02, 0xb6, 0x0a, 0xab, 0x31, 0xe6, 0x30, 0x8f, 0xa3, 0xee, 0x7c, 0x1e, 0x53, 0x3f, 0xe5, + 0x29, 0x3c, 0xea, 0x43, 0x35, 0xa0, 0xc2, 0xe7, 0x61, 0x2c, 0x55, 0x24, 0x6d, 0x4d, 0xbf, 0xbb, + 0x8d, 0xde, 0x5b, 0x43, 0x71, 0x96, 0x87, 0x9e, 0x40, 0x49, 0x48, 0x22, 0xa7, 0xc2, 0xdd, 0xd5, + 0x0a, 0xf5, 0xad, 0x06, 0x68, 0x94, 0x31, 0xc1, 0x70, 0xd0, 0x97, 0xb0, 0x3f, 0x21, 0x11, 0x19, + 0x52, 0xee, 0x19, 0x95, 0x92, 0x56, 0x79, 0x2f, 0xd7, 0xf5, 0x04, 0x99, 0x08, 0xe1, 0xda, 0x24, + 0xbb, 0x45, 0x7d, 0x00, 0x22, 0x25, 0xf1, 0xbf, 0x9b, 0xd0, 0x48, 0xba, 0x65, 0xad, 0xf2, 0x7e, + 0xae, 0x2d, 0x54, 0xbe, 0x66, 0x7c, 0xd4, 0x5e, 0x81, 0x71, 0x86, 0x88, 0xbe, 0x80, 0xaa, 0x4f, + 0xb9, 0x0c, 0x5f, 0x85, 0x3e, 0x91, 0xd4, 0xad, 0x68, 0x9d, 0x46, 0x9e, 0x4e, 0x77, 0x0d, 0x33, + 0x4e, 0x65, 0x99, 0xcd, 0x9f, 0x0b, 0x50, 0x7e, 0x4e, 0xf9, 0x2c, 0xf4, 0xff, 0xdf, 0x74, 0x3f, + 0xbe, 0x94, 0xee, 0x5c, 0xcb, 0xcc, 0xb5, 0x1b, 0x19, 0xff, 0x14, 0x2a, 0x34, 0x0a, 0x62, 0x16, + 0x46, 0xd2, 0xa4, 0x3b, 0xb7, 0x5a, 0xfa, 0x06, 0x83, 0x57, 0x68, 0xd4, 0x87, 0x5a, 0x52, 0xc5, + 0xde, 0xa5, 0x5c, 0x1f, 0xe5, 0xd1, 0xbf, 0xd5, 0x40, 0x93, 0xa4, 0xbd, 0x69, 0x66, 0xd7, 0xfc, + 0xa5, 0x00, 0x95, 0x54, 0x1d, 0x3d, 0x32, 0x8e, 0x58, 0xdb, 0xa5, 0x52, 0xac, 0xf2, 0xc4, 0xf8, + 0xf0, 0x08, 0x76, 0x63, 0xc6, 0xa5, 0x70, 0x0b, 0x47, 0xc5, 0x6d, 0xd5, 0x76, 0xc2, 0xb8, 0xec, + 0xb2, 0xe8, 0x55, 0x38, 0xc4, 0x09, 0x18, 0xbd, 0x84, 0xea, 0x2c, 0xe4, 0x72, 0x4a, 0xc6, 0x5e, + 0x18, 0x0b, 0xb7, 0xa8, 0xb9, 0x1f, 0x5c, 0x75, 0x65, 0xeb, 0x34, 0xc1, 0x0f, 0x4e, 0x3a, 0xfb, + 0xcb, 0x45, 0x03, 0x56, 0x5b, 0x81, 0xc1, 0x48, 0x0d, 0x62, 0x71, 0x70, 0x0c, 0xce, 0xea, 0x04, + 0xdd, 0x07, 0x88, 0x92, 0xe2, 0xf2, 0x56, 0xe9, 0xae, 0x2d, 0x17, 0x0d, 0xc7, 0x94, 0xdc, 0xa0, + 0x87, 0x1d, 0x03, 0x18, 0x04, 0x08, 0x81, 0x4d, 0x82, 0x80, 0xeb, 0xe4, 0x3b, 0x58, 0xaf, 0x9b, + 0xbf, 0xed, 0x82, 0xfd, 0x82, 0x88, 0xd1, 0x4d, 0x0f, 0x08, 0x75, 0xe7, 0x46, 0xb9, 0xdc, 0x07, + 0x10, 0x49, 0x25, 0x29, 0x77, 0xec, 0xb5, 0x3b, 0xa6, 0xbe, 0x94, 0x3b, 0x06, 0x90, 0xb8, 0x23, + 0xc6, 0x4c, 0xea, 0xca, 0xb0, 0xb1, 0x5e, 0xa3, 0xbb, 0x50, 0x8e, 0x58, 0xa0, 0xe9, 0x25, 0x4d, + 0x87, 0xe5, 0xa2, 0x51, 0x52, 0xc3, 0x60, 0xd0, 0xc3, 0x25, 0x75, 0x34, 0x08, 0x54, 0xc7, 0x91, + 0x28, 0x62, 0x92, 0xa8, 0x71, 0x22, 0x4c, 0xe7, 0xe6, 0xd6, 0x75, 0x7b, 0x0d, 0x4b, 0x3b, 0x2e, + 0xc3, 0x44, 0xa7, 0xf0, 0x76, 0x6a, 0x6f, 0x56, 0xb0, 0x72, 0x1d, 0x41, 0x64, 0x14, 0x32, 0x27, + 0x99, 0x09, 0xe7, 0x6c, 0x9f, 0x70, 0x3a, 0x82, 0x79, 0x13, 0xae, 0x03, 0xb5, 0x80, 0x8a, 0x90, + 0xd3, 0x40, 0xf7, 0x0e, 0x75, 0xe1, 0xc8, 0xba, 0xb7, 0xbf, 0xe5, 0xd1, 0x30, 0x22, 0x14, 0xef, + 0x19, 0x8e, 0xde, 0xa1, 0x36, 0x54, 0x4c, 0xdd, 0x08, 0xb7, 0xaa, 0x6b, 0xf7, 0x0d, 0x27, 0xdb, + 0x8a, 0x76, 0xa9, 0xf7, 0xf7, 0xae, 0xd5, 0xfb, 0x8f, 0x01, 0xc6, 0x6c, 0xe8, 0x05, 0x3c, 0x9c, + 0x51, 0xee, 0xd6, 0x34, 0xf7, 0x20, 0x8f, 0xdb, 0xd3, 0x08, 0xec, 0x8c, 0xd9, 0x30, 0x59, 0x36, + 0x7f, 0xb4, 0xe0, 0xad, 0x0d, 0xa3, 0xd0, 0xc7, 0x50, 0x36, 0x66, 0x5d, 0xf5, 0x7c, 0x1b, 0x1e, + 0x4e, 0xb1, 0xe8, 0x10, 0x1c, 0xd5, 0x23, 0x54, 0x08, 0x9a, 0x74, 0xbf, 0x83, 0xd7, 0x1f, 0x90, + 0x0b, 0x65, 0x32, 0x0e, 0x89, 0x3a, 0x2b, 0xea, 0xb3, 0x74, 0xdb, 0xfc, 0xa9, 0x00, 0x65, 0x23, + 0x76, 0xd3, 0x83, 0xd8, 0x5c, 0xbb, 0xd1, 0x59, 0x4f, 0x61, 0x2f, 0x09, 0xa7, 0x29, 0x09, 0xfb, + 0x3f, 0x83, 0x5a, 0x4d, 0xf0, 0x49, 0x39, 0x3c, 0x05, 0x3b, 0x8c, 0xc9, 0xc4, 0x0c, 0xe1, 0xdc, + 0x9b, 0x07, 0x27, 0xed, 0xe3, 0x6f, 0xe2, 0xa4, 0xb2, 0x2b, 0xcb, 0x45, 0xc3, 0x56, 0x1f, 0xb0, + 0xa6, 0x35, 0xff, 0x2e, 0x40, 0xb9, 0x3b, 0x9e, 0x0a, 0x49, 0xf9, 0x4d, 0x07, 0xc4, 0x5c, 0xbb, + 0x11, 0x90, 0x2e, 0x94, 0x39, 0x63, 0xd2, 0xf3, 0xc9, 0x55, 0xb1, 0xc0, 0x8c, 0xc9, 0x6e, 0xbb, + 0xb3, 0xaf, 0x88, 0x6a, 0x90, 0x24, 0x7b, 0x5c, 0x52, 0xd4, 0x2e, 0x41, 0x2f, 0xe1, 0x76, 0x3a, + 0x7e, 0xcf, 0x18, 0x93, 0x42, 0x72, 0x12, 0x7b, 0x23, 0x3a, 0x57, 0xaf, 0x55, 0x71, 0xdb, 0x3f, + 0x45, 0x3f, 0xf2, 0xf9, 0x5c, 0x07, 0xea, 0x19, 0x9d, 0xe3, 0x5b, 0x46, 0xa0, 0x93, 0xf2, 0x9f, + 0xd1, 0xb9, 0x40, 0x9f, 0xc3, 0x21, 0x5d, 0xc1, 0x94, 0xa2, 0x37, 0x26, 0x13, 0xf5, 0xb0, 0x78, + 0xfe, 0x98, 0xf9, 0x23, 0x3d, 0xdb, 0x6c, 0x7c, 0x87, 0x66, 0xa5, 0xbe, 0x4a, 0x10, 0x5d, 0x05, + 0xe8, 0x1c, 0x9e, 0x5f, 0xd4, 0x77, 0xfe, 0xb8, 0xa8, 0xef, 0xfc, 0x73, 0x51, 0xb7, 0x7e, 0x58, + 0xd6, 0xad, 0xf3, 0x65, 0xdd, 0xfa, 0x7d, 0x59, 0xb7, 0xfe, 0x5c, 0xd6, 0xad, 0xb3, 0x92, 0xfe, + 0xbd, 0xfd, 0xe8, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x56, 0x49, 0xe6, 0x55, 0x4e, 0x0b, 0x00, + 0x00, } diff --git a/api/objects.proto b/api/objects.proto index 3e7c2162d1..ac046741ad 100644 --- a/api/objects.proto +++ b/api/objects.proto @@ -221,16 +221,4 @@ message Cluster { // and agents to unambiguously identify the older key to be deleted when // a new key is allocated on key rotation. uint64 encryption_key_lamport_clock = 6; -} - -// Secret -message Secret { - string id = 1 [(gogoproto.customname) = "ID"]; - - Meta meta = 2 [(gogoproto.nullable) = false]; - - SecretSpec spec = 3 [(gogoproto.nullable) = false]; - - // Version is a hash of the secret. - string version = 4; -} +} \ No newline at end of file diff --git a/api/raft.pb.go b/api/raft.pb.go index 3cee821a74..96180d389c 100644 --- a/api/raft.pb.go +++ b/api/raft.pb.go @@ -172,7 +172,6 @@ type StoreAction struct { // *StoreAction_Task // *StoreAction_Network // *StoreAction_Cluster - // *StoreAction_Secret Target isStoreAction_Target `protobuf_oneof:"target"` } @@ -201,16 +200,12 @@ type StoreAction_Network struct { type StoreAction_Cluster struct { Cluster *Cluster `protobuf:"bytes,6,opt,name=cluster,oneof"` } -type StoreAction_Secret struct { - Secret *Secret `protobuf:"bytes,7,opt,name=secret,oneof"` -} func (*StoreAction_Node) isStoreAction_Target() {} func (*StoreAction_Service) isStoreAction_Target() {} func (*StoreAction_Task) isStoreAction_Target() {} func (*StoreAction_Network) isStoreAction_Target() {} func (*StoreAction_Cluster) isStoreAction_Target() {} -func (*StoreAction_Secret) isStoreAction_Target() {} func (m *StoreAction) GetTarget() isStoreAction_Target { if m != nil { @@ -254,13 +249,6 @@ func (m *StoreAction) GetCluster() *Cluster { return nil } -func (m *StoreAction) GetSecret() *Secret { - if x, ok := m.GetTarget().(*StoreAction_Secret); ok { - return x.Secret - } - return nil -} - // XXX_OneofFuncs is for the internal use of the proto package. func (*StoreAction) 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 _StoreAction_OneofMarshaler, _StoreAction_OneofUnmarshaler, _StoreAction_OneofSizer, []interface{}{ @@ -269,7 +257,6 @@ func (*StoreAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) e (*StoreAction_Task)(nil), (*StoreAction_Network)(nil), (*StoreAction_Cluster)(nil), - (*StoreAction_Secret)(nil), } } @@ -302,11 +289,6 @@ func _StoreAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { if err := b.EncodeMessage(x.Cluster); err != nil { return err } - case *StoreAction_Secret: - _ = b.EncodeVarint(7<<3 | proto.WireBytes) - if err := b.EncodeMessage(x.Secret); err != nil { - return err - } case nil: default: return fmt.Errorf("StoreAction.Target has unexpected type %T", x) @@ -357,14 +339,6 @@ func _StoreAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Bu err := b.DecodeMessage(msg) m.Target = &StoreAction_Cluster{msg} return true, err - case 7: // target.secret - if wire != proto.WireBytes { - return true, proto.ErrInternalBadWireType - } - msg := new(Secret) - err := b.DecodeMessage(msg) - m.Target = &StoreAction_Secret{msg} - return true, err default: return false, nil } @@ -399,11 +373,6 @@ func _StoreAction_OneofSizer(msg proto.Message) (n int) { n += proto.SizeVarint(6<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s - case *StoreAction_Secret: - s := proto.Size(x.Secret) - n += proto.SizeVarint(7<<3 | proto.WireBytes) - n += proto.SizeVarint(uint64(s)) - n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) @@ -649,12 +618,6 @@ func (m *StoreAction) Copy() *StoreAction { Cluster: m.GetCluster().Copy(), } - o.Target = i - case *StoreAction_Secret: - i := &StoreAction_Secret{ - Secret: m.GetSecret().Copy(), - } - o.Target = i } @@ -777,7 +740,7 @@ func (this *StoreAction) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 11) + s := make([]string, 0, 10) s = append(s, "&api.StoreAction{") s = append(s, "Action: "+fmt.Sprintf("%#v", this.Action)+",\n") if this.Target != nil { @@ -826,14 +789,6 @@ func (this *StoreAction_Cluster) GoString() string { `Cluster:` + fmt.Sprintf("%#v", this.Cluster) + `}`}, ", ") return s } -func (this *StoreAction_Secret) GoString() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&api.StoreAction_Secret{` + - `Secret:` + fmt.Sprintf("%#v", this.Secret) + `}`}, ", ") - return s -} func valueToGoStringRaft(v interface{}, typ string) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -1453,20 +1408,6 @@ func (m *StoreAction_Cluster) MarshalTo(data []byte) (int, error) { } return i, nil } -func (m *StoreAction_Secret) MarshalTo(data []byte) (int, error) { - i := 0 - if m.Secret != nil { - data[i] = 0x3a - i++ - i = encodeVarintRaft(data, i, uint64(m.Secret.Size())) - n10, err := m.Secret.MarshalTo(data[i:]) - if err != nil { - return 0, err - } - i += n10 - } - return i, nil -} func encodeFixed64Raft(data []byte, offset int, v uint64) int { data[offset] = uint8(v) data[offset+1] = uint8(v >> 8) @@ -1873,15 +1814,6 @@ func (m *StoreAction_Cluster) Size() (n int) { } return n } -func (m *StoreAction_Secret) Size() (n int) { - var l int - _ = l - if m.Secret != nil { - l = m.Secret.Size() - n += 1 + l + sovRaft(uint64(l)) - } - return n -} func sovRaft(x uint64) (n int) { for { @@ -2061,16 +1993,6 @@ func (this *StoreAction_Cluster) String() string { }, "") return s } -func (this *StoreAction_Secret) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&StoreAction_Secret{`, - `Secret:` + strings.Replace(fmt.Sprintf("%v", this.Secret), "Secret", "Secret", 1) + `,`, - `}`, - }, "") - return s -} func valueToStringRaft(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -3157,38 +3079,6 @@ func (m *StoreAction) Unmarshal(data []byte) error { } m.Target = &StoreAction_Cluster{v} iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Secret", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRaft - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - msglen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthRaft - } - postIndex := iNdEx + msglen - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &Secret{} - if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { - return err - } - m.Target = &StoreAction_Secret{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRaft(data[iNdEx:]) @@ -3316,61 +3206,60 @@ var ( ) var fileDescriptorRaft = []byte{ - // 890 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x95, 0xcf, 0x73, 0xdb, 0x44, - 0x14, 0xc7, 0xbd, 0xb2, 0x2a, 0xc3, 0x73, 0x13, 0x67, 0x36, 0x24, 0xb8, 0xa2, 0xa3, 0xb8, 0x2a, - 0x33, 0x75, 0x3b, 0x44, 0x1e, 0x0c, 0x33, 0x65, 0x80, 0x4b, 0x9c, 0x78, 0x26, 0xa6, 0xad, 0xd3, - 0x51, 0x12, 0xe8, 0x2d, 0xc8, 0xd2, 0xc6, 0x15, 0x8e, 0xb5, 0x66, 0x77, 0xed, 0x0c, 0x17, 0xa6, - 0x47, 0x26, 0x57, 0x86, 0x1f, 0x97, 0x9e, 0xe0, 0xdc, 0x3f, 0x80, 0xbf, 0x20, 0xc3, 0x89, 0x1b, - 0x9c, 0x32, 0xc4, 0x7f, 0x00, 0xf0, 0x27, 0x30, 0xbb, 0x92, 0x92, 0xd4, 0x51, 0x1c, 0x5f, 0x92, - 0xf5, 0xea, 0xf3, 0x7d, 0xdf, 0x7d, 0x6f, 0xf5, 0x9e, 0x00, 0x98, 0xb7, 0x2f, 0x9c, 0x01, 0xa3, - 0x82, 0x62, 0x1c, 0x50, 0xbf, 0x47, 0x98, 0xc3, 0x0f, 0x3d, 0xd6, 0xef, 0x85, 0xc2, 0x19, 0xbd, - 0x6f, 0xce, 0xd1, 0xce, 0x57, 0xc4, 0x17, 0x3c, 0x46, 0xcc, 0xa2, 0xf8, 0x66, 0x40, 0xd2, 0x1f, - 0xab, 0xdd, 0x50, 0x3c, 0x1f, 0x76, 0x1c, 0x9f, 0xf6, 0x6b, 0x3e, 0x65, 0x84, 0xf2, 0x1a, 0x11, - 0x7e, 0x50, 0x93, 0x21, 0xd5, 0x9f, 0x41, 0xa7, 0x76, 0x1e, 0xde, 0x7c, 0xab, 0x4b, 0xbb, 0x54, - 0x2d, 0x6b, 0x72, 0x95, 0xec, 0x2e, 0x0e, 0x0e, 0x86, 0xdd, 0x30, 0xaa, 0xc5, 0xff, 0xe2, 0x4d, - 0xfb, 0x15, 0x02, 0x70, 0xbd, 0x7d, 0xf1, 0x84, 0xf4, 0x3b, 0x84, 0xe1, 0xbb, 0x50, 0x90, 0x71, - 0xf6, 0xc2, 0xa0, 0x8c, 0x2a, 0xa8, 0xaa, 0x37, 0x60, 0x7c, 0xb2, 0x62, 0x48, 0xa0, 0xb5, 0xe1, - 0x1a, 0xf2, 0x51, 0x2b, 0x90, 0x50, 0x44, 0x03, 0x22, 0x21, 0xad, 0x82, 0xaa, 0x6f, 0xc6, 0x50, - 0x9b, 0x06, 0x44, 0x42, 0xf2, 0x51, 0x2b, 0xc0, 0x18, 0x74, 0x2f, 0x08, 0x58, 0x39, 0x2f, 0x09, - 0x57, 0xad, 0x71, 0x03, 0x0c, 0x2e, 0x3c, 0x31, 0xe4, 0x65, 0xbd, 0x82, 0xaa, 0xc5, 0xfa, 0xbb, - 0xce, 0xe5, 0x3a, 0x38, 0xe7, 0xa7, 0xd9, 0x56, 0x6c, 0x43, 0x3f, 0x3e, 0x59, 0xc9, 0xb9, 0x89, - 0xd2, 0xbe, 0x03, 0xc5, 0xcf, 0x68, 0x18, 0xb9, 0xe4, 0xeb, 0x21, 0xe1, 0xe2, 0xcc, 0x06, 0x9d, - 0xdb, 0xd8, 0x3f, 0x22, 0xb8, 0x19, 0x33, 0x7c, 0x40, 0x23, 0x4e, 0x66, 0xcb, 0xea, 0x23, 0x28, - 0xf4, 0x95, 0x2d, 0x2f, 0x6b, 0x95, 0x7c, 0xb5, 0x58, 0xb7, 0xa6, 0x9f, 0xce, 0x4d, 0x71, 0x7c, - 0x0f, 0x4a, 0x8c, 0xf4, 0xe9, 0x88, 0x04, 0x7b, 0x69, 0x84, 0x7c, 0x25, 0x5f, 0xd5, 0xdd, 0xf9, - 0x64, 0x3b, 0x16, 0x70, 0xbb, 0x01, 0x37, 0x1f, 0x13, 0x6f, 0x44, 0xd2, 0xc3, 0xd7, 0x41, 0x97, - 0xd5, 0x52, 0x87, 0xba, 0xde, 0x4f, 0xb1, 0x76, 0x09, 0xe6, 0x92, 0x18, 0x71, 0x72, 0xf6, 0x63, - 0xb8, 0xf5, 0x94, 0x51, 0x9f, 0x70, 0x1e, 0xb3, 0x9c, 0x7b, 0xdd, 0x33, 0x87, 0xfb, 0x32, 0x29, - 0xb5, 0x93, 0x98, 0x94, 0x9c, 0xf8, 0x75, 0x71, 0x52, 0x30, 0x7d, 0xfe, 0xb1, 0xfe, 0xe2, 0x27, - 0x3b, 0x67, 0xdf, 0x06, 0x33, 0x2b, 0x5a, 0xe2, 0xf5, 0x29, 0x2c, 0xb9, 0x84, 0xd3, 0x83, 0x11, - 0x59, 0x0b, 0x02, 0x26, 0xa1, 0xc4, 0x67, 0x96, 0x0a, 0xdb, 0xef, 0xc1, 0xf2, 0xa4, 0x3a, 0xb9, - 0xa0, 0xac, 0x5b, 0xdc, 0x87, 0xc5, 0x56, 0x24, 0x08, 0x8b, 0xbc, 0x03, 0x19, 0x27, 0x75, 0x5a, - 0x06, 0xed, 0xcc, 0xc4, 0x18, 0x9f, 0xac, 0x68, 0xad, 0x0d, 0x57, 0x0b, 0x03, 0xfc, 0x10, 0x0c, - 0xcf, 0x17, 0x21, 0x8d, 0x92, 0xdb, 0x5b, 0xc9, 0xaa, 0xe6, 0xb6, 0xa0, 0x8c, 0xac, 0x29, 0xcc, - 0x4d, 0x70, 0xfb, 0x87, 0x3c, 0x14, 0x2f, 0xec, 0xe3, 0x4f, 0xce, 0x02, 0x49, 0x93, 0xf9, 0xfa, - 0xdd, 0x6b, 0x02, 0x3d, 0x0a, 0xa3, 0x20, 0x0d, 0x86, 0x9d, 0xe4, 0x46, 0x35, 0x55, 0xec, 0x72, - 0x96, 0x54, 0xf6, 0xc9, 0x66, 0x2e, 0xbe, 0x4d, 0xfc, 0x10, 0x0a, 0x9c, 0xb0, 0x51, 0xe8, 0x13, - 0xd5, 0x28, 0xc5, 0xfa, 0x3b, 0x99, 0x6e, 0x31, 0xb2, 0x99, 0x73, 0x53, 0x5a, 0x1a, 0x09, 0x8f, - 0xf7, 0x92, 0x46, 0xca, 0x34, 0xda, 0xf1, 0x78, 0x4f, 0x1a, 0x49, 0x4e, 0x1a, 0x45, 0x44, 0x1c, - 0x52, 0xd6, 0x2b, 0xdf, 0xb8, 0xda, 0xa8, 0x1d, 0x23, 0xd2, 0x28, 0xa1, 0xa5, 0xd0, 0x3f, 0x18, - 0x72, 0x41, 0x58, 0xd9, 0xb8, 0x5a, 0xb8, 0x1e, 0x23, 0x52, 0x98, 0xd0, 0xf8, 0x43, 0x30, 0x38, - 0xf1, 0x19, 0x11, 0xe5, 0x82, 0xd2, 0x99, 0xd9, 0x99, 0x49, 0x62, 0x53, 0xb6, 0xb7, 0x5a, 0x35, - 0xde, 0x00, 0x43, 0x78, 0xac, 0x4b, 0xc4, 0x83, 0x7f, 0x11, 0x94, 0x26, 0xca, 0x8c, 0xef, 0x41, - 0x61, 0xb7, 0xfd, 0xa8, 0xbd, 0xf5, 0x45, 0x7b, 0x21, 0x67, 0x9a, 0x47, 0x2f, 0x2b, 0xcb, 0x13, - 0xc4, 0x6e, 0xd4, 0x8b, 0xe8, 0x61, 0x84, 0xeb, 0xb0, 0xb8, 0xbd, 0xb3, 0xe5, 0x36, 0xf7, 0xd6, - 0xd6, 0x77, 0x5a, 0x5b, 0xed, 0xbd, 0x75, 0xb7, 0xb9, 0xb6, 0xd3, 0x5c, 0x40, 0xe6, 0xad, 0xa3, - 0x97, 0x95, 0xa5, 0x09, 0xd1, 0x3a, 0x23, 0x9e, 0x20, 0x97, 0x34, 0xbb, 0x4f, 0x37, 0xa4, 0x46, - 0xcb, 0xd4, 0xec, 0x0e, 0x82, 0x2c, 0x8d, 0xdb, 0x7c, 0xb2, 0xf5, 0x79, 0x73, 0x21, 0x9f, 0xa9, - 0x71, 0xd5, 0x34, 0x30, 0xdf, 0xfe, 0xee, 0x17, 0x2b, 0xf7, 0xdb, 0xaf, 0xd6, 0x64, 0x76, 0xf5, - 0xef, 0x35, 0xd0, 0xe5, 0xab, 0x8e, 0x8f, 0x10, 0xe0, 0xcb, 0x5d, 0x88, 0x57, 0xb3, 0x2a, 0x78, - 0x65, 0xef, 0x9b, 0xce, 0xac, 0x78, 0xd2, 0xdc, 0x4b, 0xbf, 0xbf, 0xfa, 0xe7, 0x67, 0xad, 0x04, - 0x73, 0x8a, 0x5f, 0xed, 0x7b, 0x91, 0xd7, 0x25, 0x0c, 0x7f, 0x0b, 0xf3, 0xaf, 0x77, 0x2d, 0xbe, - 0x9f, 0x39, 0xa8, 0xb2, 0xe6, 0x82, 0xf9, 0x60, 0x16, 0x74, 0xaa, 0x7f, 0xfd, 0x4f, 0x04, 0xf3, - 0xe7, 0x53, 0x90, 0x3f, 0x0f, 0x07, 0xf8, 0x4b, 0xd0, 0xe5, 0x7c, 0xc7, 0x99, 0x3d, 0x7e, 0xe1, - 0xeb, 0x60, 0x56, 0xae, 0x06, 0xa6, 0x27, 0xed, 0xc3, 0x0d, 0x35, 0x65, 0x71, 0x66, 0x84, 0x8b, - 0x43, 0xdc, 0xbc, 0x33, 0x85, 0x98, 0x6a, 0xd2, 0xb8, 0x7d, 0x7c, 0x6a, 0xe5, 0xfe, 0x3a, 0xb5, - 0x72, 0xff, 0x9d, 0x5a, 0xe8, 0xc5, 0xd8, 0x42, 0xc7, 0x63, 0x0b, 0xfd, 0x31, 0xb6, 0xd0, 0xdf, - 0x63, 0x0b, 0x3d, 0xcb, 0x3f, 0xd3, 0x3b, 0x86, 0xfa, 0x48, 0x7f, 0xf0, 0x7f, 0x00, 0x00, 0x00, - 0xff, 0xff, 0x53, 0x4c, 0x9e, 0xad, 0x3c, 0x08, 0x00, 0x00, + // 868 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x95, 0x4f, 0x73, 0xdb, 0x44, + 0x18, 0xc6, 0xb5, 0xb2, 0xaa, 0xc0, 0xeb, 0x26, 0xce, 0x6c, 0x48, 0x70, 0x45, 0x47, 0x51, 0x55, + 0x66, 0xea, 0x76, 0x88, 0x3c, 0x88, 0x43, 0x19, 0xe0, 0x12, 0x27, 0x9e, 0xa9, 0x69, 0xeb, 0x74, + 0x94, 0x04, 0x7a, 0x0b, 0xb2, 0xb4, 0x71, 0x85, 0x63, 0xad, 0xd9, 0x5d, 0x3b, 0xc3, 0x85, 0xe9, + 0x91, 0xc9, 0x95, 0x19, 0xe0, 0xd2, 0x13, 0x9c, 0xfb, 0x01, 0xf8, 0x04, 0x19, 0x4e, 0xdc, 0xe0, + 0x14, 0x88, 0x3f, 0x00, 0xf0, 0x11, 0x98, 0xd5, 0x9f, 0x24, 0x38, 0x8a, 0xe3, 0x8b, 0x2d, 0xef, + 0xfe, 0x9e, 0xe7, 0xd9, 0x7d, 0x57, 0xef, 0x1a, 0x80, 0xf9, 0xfb, 0xc2, 0x19, 0x30, 0x2a, 0x28, + 0xc6, 0x21, 0x0d, 0x7a, 0x84, 0x39, 0xfc, 0xd0, 0x67, 0xfd, 0x5e, 0x24, 0x9c, 0xd1, 0xfb, 0xc6, + 0x3c, 0xed, 0x7c, 0x49, 0x02, 0xc1, 0x53, 0xc4, 0x28, 0x8b, 0xaf, 0x07, 0x24, 0xff, 0xb1, 0xd6, + 0x8d, 0xc4, 0x8b, 0x61, 0xc7, 0x09, 0x68, 0xbf, 0x1e, 0x50, 0x46, 0x28, 0xaf, 0x13, 0x11, 0x84, + 0x75, 0x69, 0x99, 0x7c, 0x0c, 0x3a, 0xf5, 0x73, 0x7b, 0xe3, 0xad, 0x2e, 0xed, 0xd2, 0xe4, 0xb1, + 0x2e, 0x9f, 0xb2, 0xd1, 0xa5, 0xc1, 0xc1, 0xb0, 0x1b, 0xc5, 0xf5, 0xf4, 0x2b, 0x1d, 0xb4, 0x5f, + 0x23, 0x00, 0xcf, 0xdf, 0x17, 0x4f, 0x49, 0xbf, 0x43, 0x18, 0xbe, 0x0b, 0x73, 0xd2, 0x67, 0x2f, + 0x0a, 0xab, 0xc8, 0x42, 0x35, 0xad, 0x01, 0xe3, 0x93, 0x55, 0x5d, 0x02, 0xad, 0x4d, 0x4f, 0x97, + 0x53, 0xad, 0x50, 0x42, 0x31, 0x0d, 0x89, 0x84, 0x54, 0x0b, 0xd5, 0xde, 0x4c, 0xa1, 0x36, 0x0d, + 0x89, 0x84, 0xe4, 0x54, 0x2b, 0xc4, 0x18, 0x34, 0x3f, 0x0c, 0x59, 0xb5, 0x24, 0x09, 0x2f, 0x79, + 0xc6, 0x0d, 0xd0, 0xb9, 0xf0, 0xc5, 0x90, 0x57, 0x35, 0x0b, 0xd5, 0xca, 0xee, 0xbb, 0xce, 0xe5, + 0x3a, 0x38, 0xe7, 0xab, 0xd9, 0x4e, 0xd8, 0x86, 0x76, 0x7c, 0xb2, 0xaa, 0x78, 0x99, 0xd2, 0xbe, + 0x03, 0xe5, 0x4f, 0x69, 0x14, 0x7b, 0xe4, 0xab, 0x21, 0xe1, 0xe2, 0x2c, 0x06, 0x9d, 0xc7, 0xd8, + 0xdf, 0x23, 0xb8, 0x99, 0x32, 0x7c, 0x40, 0x63, 0x4e, 0x66, 0xdb, 0xd5, 0x87, 0x30, 0xd7, 0x4f, + 0x62, 0x79, 0x55, 0xb5, 0x4a, 0xb5, 0xb2, 0x6b, 0x4e, 0x5f, 0x9d, 0x97, 0xe3, 0xf8, 0x1e, 0x54, + 0x18, 0xe9, 0xd3, 0x11, 0x09, 0xf7, 0x72, 0x87, 0x92, 0x55, 0xaa, 0x69, 0xde, 0x42, 0x36, 0x9c, + 0x0a, 0xb8, 0xdd, 0x80, 0x9b, 0x4f, 0x88, 0x3f, 0x22, 0xf9, 0xe2, 0x5d, 0xd0, 0x64, 0xb5, 0x92, + 0x45, 0x5d, 0x9f, 0x97, 0xb0, 0x76, 0x05, 0xe6, 0x33, 0x8f, 0x74, 0x73, 0xf6, 0x13, 0xb8, 0xf5, + 0x8c, 0xd1, 0x80, 0x70, 0x9e, 0xb2, 0x9c, 0xfb, 0xdd, 0xb3, 0x84, 0xfb, 0x72, 0x53, 0xc9, 0x48, + 0x16, 0x52, 0x71, 0xd2, 0xd7, 0xc5, 0xc9, 0xc1, 0x7c, 0xfe, 0x23, 0xed, 0xe5, 0x0f, 0xb6, 0x62, + 0xdf, 0x06, 0xa3, 0xc8, 0x2d, 0xcb, 0xfa, 0x04, 0x96, 0x3d, 0xc2, 0xe9, 0xc1, 0x88, 0xac, 0x87, + 0x21, 0x93, 0x50, 0x96, 0x33, 0x4b, 0x85, 0xed, 0xf7, 0x60, 0x65, 0x52, 0x9d, 0x1d, 0x50, 0xd1, + 0x29, 0xee, 0xc3, 0x52, 0x2b, 0x16, 0x84, 0xc5, 0xfe, 0x81, 0xf4, 0xc9, 0x93, 0x56, 0x40, 0x3d, + 0x0b, 0xd1, 0xc7, 0x27, 0xab, 0x6a, 0x6b, 0xd3, 0x53, 0xa3, 0x10, 0x3f, 0x04, 0xdd, 0x0f, 0x44, + 0x44, 0xe3, 0xec, 0xf4, 0x56, 0x8b, 0xaa, 0xb9, 0x2d, 0x28, 0x23, 0xeb, 0x09, 0xe6, 0x65, 0xb8, + 0xfd, 0xa7, 0x0a, 0xe5, 0x0b, 0xe3, 0xf8, 0xe3, 0x33, 0x23, 0x19, 0xb2, 0xe0, 0xde, 0xbd, 0xc6, + 0xe8, 0x71, 0x14, 0x87, 0xb9, 0x19, 0x76, 0xb2, 0x13, 0x55, 0x93, 0x62, 0x57, 0x8b, 0xa4, 0xb2, + 0x4f, 0x1e, 0x29, 0xe9, 0x69, 0xe2, 0x87, 0x30, 0xc7, 0x09, 0x1b, 0x45, 0x01, 0x49, 0x1a, 0xa5, + 0xec, 0xbe, 0x53, 0x98, 0x96, 0x22, 0x8f, 0x14, 0x2f, 0xa7, 0x65, 0x90, 0xf0, 0x79, 0x2f, 0x6b, + 0xa4, 0xc2, 0xa0, 0x1d, 0x9f, 0xf7, 0x64, 0x90, 0xe4, 0x64, 0x50, 0x4c, 0xc4, 0x21, 0x65, 0xbd, + 0xea, 0x8d, 0xab, 0x83, 0xda, 0x29, 0x22, 0x83, 0x32, 0x5a, 0x0a, 0x83, 0x83, 0x21, 0x17, 0x84, + 0x55, 0xf5, 0xab, 0x85, 0x1b, 0x29, 0x22, 0x85, 0x19, 0xdd, 0x78, 0x03, 0x74, 0xe1, 0xb3, 0x2e, + 0x11, 0x0f, 0xfe, 0x41, 0x50, 0x99, 0x28, 0x18, 0xbe, 0x07, 0x73, 0xbb, 0xed, 0xc7, 0xed, 0xad, + 0xcf, 0xdb, 0x8b, 0x8a, 0x61, 0x1c, 0xbd, 0xb2, 0x56, 0x26, 0x88, 0xdd, 0xb8, 0x17, 0xd3, 0xc3, + 0x18, 0xbb, 0xb0, 0xb4, 0xbd, 0xb3, 0xe5, 0x35, 0xf7, 0xd6, 0x37, 0x76, 0x5a, 0x5b, 0xed, 0xbd, + 0x0d, 0xaf, 0xb9, 0xbe, 0xd3, 0x5c, 0x44, 0xc6, 0xad, 0xa3, 0x57, 0xd6, 0xf2, 0x84, 0x68, 0x83, + 0x11, 0x5f, 0x90, 0x4b, 0x9a, 0xdd, 0x67, 0x9b, 0x52, 0xa3, 0x16, 0x6a, 0x76, 0x07, 0x61, 0x91, + 0xc6, 0x6b, 0x3e, 0xdd, 0xfa, 0xac, 0xb9, 0x58, 0x2a, 0xd4, 0x78, 0x49, 0x5f, 0x1b, 0x6f, 0x7f, + 0xfb, 0x93, 0xa9, 0xfc, 0xf2, 0xb3, 0x39, 0xb9, 0x3b, 0xf7, 0x3b, 0x15, 0x34, 0xf9, 0xd2, 0xe2, + 0x23, 0x04, 0xf8, 0x72, 0x3f, 0xe1, 0xb5, 0xa2, 0x1a, 0x5e, 0xd9, 0xc5, 0x86, 0x33, 0x2b, 0x9e, + 0xb5, 0xe9, 0xf2, 0xaf, 0xaf, 0xff, 0xfe, 0x51, 0xad, 0xc0, 0x7c, 0xc2, 0xaf, 0xf5, 0xfd, 0xd8, + 0xef, 0x12, 0x86, 0xbf, 0x81, 0x85, 0xff, 0xf7, 0x1f, 0xbe, 0x5f, 0x78, 0xe5, 0x14, 0x75, 0xb8, + 0xf1, 0x60, 0x16, 0x74, 0x6a, 0xbe, 0xfb, 0x3b, 0x82, 0x85, 0xf3, 0xfb, 0x8c, 0xbf, 0x88, 0x06, + 0xf8, 0x0b, 0xd0, 0xe4, 0x4d, 0x8d, 0x0b, 0xbb, 0xf5, 0xc2, 0x3d, 0x6f, 0x58, 0x57, 0x03, 0xd3, + 0x37, 0x1d, 0xc0, 0x8d, 0xe4, 0xbe, 0xc4, 0x85, 0x0e, 0x17, 0xaf, 0x63, 0xe3, 0xce, 0x14, 0x62, + 0x6a, 0x48, 0xe3, 0xf6, 0xf1, 0xa9, 0xa9, 0xfc, 0x71, 0x6a, 0x2a, 0xff, 0x9e, 0x9a, 0xe8, 0xe5, + 0xd8, 0x44, 0xc7, 0x63, 0x13, 0xfd, 0x36, 0x36, 0xd1, 0x5f, 0x63, 0x13, 0x3d, 0x2f, 0x3d, 0xd7, + 0x3a, 0x7a, 0xf2, 0x77, 0xfb, 0xc1, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xd7, 0x61, 0x3c, 0x43, + 0x06, 0x08, 0x00, 0x00, } diff --git a/api/raft.proto b/api/raft.proto index e1d9c19568..e5a0ffb4d8 100644 --- a/api/raft.proto +++ b/api/raft.proto @@ -124,6 +124,5 @@ message StoreAction { Task task = 4; Network network = 5; Cluster cluster = 6; - Secret secret = 7; } } diff --git a/api/snapshot.pb.go b/api/snapshot.pb.go index 1fd82da8eb..6fdcd9707e 100644 --- a/api/snapshot.pb.go +++ b/api/snapshot.pb.go @@ -49,7 +49,6 @@ type StoreSnapshot struct { Networks []*Network `protobuf:"bytes,3,rep,name=networks" json:"networks,omitempty"` Tasks []*Task `protobuf:"bytes,4,rep,name=tasks" json:"tasks,omitempty"` Clusters []*Cluster `protobuf:"bytes,5,rep,name=clusters" json:"clusters,omitempty"` - Secrets []*Secret `protobuf:"bytes,6,rep,name=secrets" json:"secrets,omitempty"` } func (m *StoreSnapshot) Reset() { *m = StoreSnapshot{} } @@ -125,13 +124,6 @@ func (m *StoreSnapshot) Copy() *StoreSnapshot { } } - if m.Secrets != nil { - o.Secrets = make([]*Secret, 0, len(m.Secrets)) - for _, v := range m.Secrets { - o.Secrets = append(o.Secrets, v.Copy()) - } - } - return o } @@ -177,7 +169,7 @@ func (this *StoreSnapshot) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 10) + s := make([]string, 0, 9) s = append(s, "&api.StoreSnapshot{") if this.Nodes != nil { s = append(s, "Nodes: "+fmt.Sprintf("%#v", this.Nodes)+",\n") @@ -194,9 +186,6 @@ func (this *StoreSnapshot) GoString() string { if this.Clusters != nil { s = append(s, "Clusters: "+fmt.Sprintf("%#v", this.Clusters)+",\n") } - if this.Secrets != nil { - s = append(s, "Secrets: "+fmt.Sprintf("%#v", this.Secrets)+",\n") - } s = append(s, "}") return strings.Join(s, "") } @@ -325,18 +314,6 @@ func (m *StoreSnapshot) MarshalTo(data []byte) (int, error) { i += n } } - if len(m.Secrets) > 0 { - for _, msg := range m.Secrets { - data[i] = 0x32 - i++ - i = encodeVarintSnapshot(data, i, uint64(msg.Size())) - n, err := msg.MarshalTo(data[i:]) - if err != nil { - return 0, err - } - i += n - } - } return i, nil } @@ -477,12 +454,6 @@ func (m *StoreSnapshot) Size() (n int) { n += 1 + l + sovSnapshot(uint64(l)) } } - if len(m.Secrets) > 0 { - for _, e := range m.Secrets { - l = e.Size() - n += 1 + l + sovSnapshot(uint64(l)) - } - } return n } @@ -539,7 +510,6 @@ func (this *StoreSnapshot) String() string { `Networks:` + strings.Replace(fmt.Sprintf("%v", this.Networks), "Network", "Network", 1) + `,`, `Tasks:` + strings.Replace(fmt.Sprintf("%v", this.Tasks), "Task", "Task", 1) + `,`, `Clusters:` + strings.Replace(fmt.Sprintf("%v", this.Clusters), "Cluster", "Cluster", 1) + `,`, - `Secrets:` + strings.Replace(fmt.Sprintf("%v", this.Secrets), "Secret", "Secret", 1) + `,`, `}`, }, "") return s @@ -759,37 +729,6 @@ func (m *StoreSnapshot) Unmarshal(data []byte) error { return err } iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Secrets", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSnapshot - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - msglen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthSnapshot - } - postIndex := iNdEx + msglen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Secrets = append(m.Secrets, &Secret{}) - if err := m.Secrets[len(m.Secrets)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSnapshot(data[iNdEx:]) @@ -1147,31 +1086,30 @@ var ( ) var fileDescriptorSnapshot = []byte{ - // 409 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x92, 0xbf, 0x6f, 0xd3, 0x40, - 0x14, 0xc7, 0x73, 0xce, 0x0f, 0x57, 0xaf, 0x6a, 0x81, 0x13, 0xc3, 0x29, 0xa0, 0x23, 0x04, 0x86, - 0x4c, 0x06, 0x02, 0x12, 0x2c, 0x30, 0x94, 0x89, 0x81, 0x0e, 0x17, 0x54, 0xb1, 0x3a, 0xf6, 0x6b, - 0x6b, 0x8c, 0x7d, 0xd1, 0xbd, 0xc3, 0x5d, 0xf9, 0xf3, 0x32, 0x76, 0x64, 0x42, 0xc4, 0x0b, 0x2b, - 0x7f, 0x02, 0xb2, 0xcf, 0xb6, 0x22, 0xe1, 0xb0, 0x3d, 0x5b, 0x9f, 0xef, 0x8f, 0x7b, 0x7a, 0x70, - 0x4a, 0x79, 0xb8, 0xa1, 0x6b, 0x6d, 0x83, 0x8d, 0xd1, 0x56, 0x73, 0x1e, 0xeb, 0x28, 0x45, 0x13, - 0xd0, 0x4d, 0x68, 0xb2, 0x34, 0xb1, 0x41, 0xf1, 0x62, 0x7a, 0xa2, 0xd7, 0x5f, 0x30, 0xb2, 0xe4, - 0x90, 0x29, 0x98, 0xf0, 0xb2, 0xc1, 0xa7, 0xf7, 0xaf, 0xf4, 0x95, 0xae, 0xc7, 0x67, 0xd5, 0xe4, - 0xfe, 0xce, 0x6f, 0x3d, 0x38, 0x59, 0x59, 0x6d, 0x70, 0xd5, 0x98, 0xf3, 0x00, 0xc6, 0xb9, 0x8e, - 0x91, 0x04, 0x9b, 0x0d, 0x17, 0xc7, 0x4b, 0x11, 0xfc, 0x1b, 0x13, 0x9c, 0xeb, 0x18, 0x95, 0xc3, - 0xf8, 0x6b, 0x38, 0x22, 0x34, 0x45, 0x12, 0x21, 0x09, 0xaf, 0x96, 0x3c, 0xe8, 0x93, 0xac, 0x1c, - 0xa3, 0x3a, 0xb8, 0x12, 0xe6, 0x68, 0x6f, 0xb4, 0x49, 0x49, 0x0c, 0x0f, 0x0b, 0xcf, 0x1d, 0xa3, - 0x3a, 0xb8, 0x6a, 0x68, 0x43, 0x4a, 0x49, 0x8c, 0x0e, 0x37, 0xfc, 0x14, 0x52, 0xaa, 0x1c, 0x56, - 0x05, 0x45, 0x5f, 0xbf, 0x91, 0x45, 0x43, 0x62, 0x7c, 0x38, 0xe8, 0xbd, 0x63, 0x54, 0x07, 0xf3, - 0x57, 0xe0, 0x13, 0x46, 0x06, 0x2d, 0x89, 0x49, 0xad, 0x9b, 0xf6, 0xbf, 0xac, 0x42, 0x54, 0x8b, - 0xce, 0x11, 0xee, 0x34, 0x56, 0xdd, 0x4e, 0xdf, 0x80, 0x9f, 0x61, 0xb6, 0xae, 0x0a, 0xb8, 0xad, - 0xca, 0x3e, 0x23, 0x15, 0x5e, 0xda, 0x8f, 0x35, 0xa6, 0x5a, 0x9c, 0x0b, 0xf0, 0x0d, 0x66, 0xba, - 0xc0, 0xb8, 0x5e, 0xee, 0x48, 0xb5, 0x9f, 0xf3, 0xdf, 0x0c, 0x8e, 0xba, 0x80, 0x77, 0xe0, 0x17, - 0x68, 0x28, 0xd1, 0xb9, 0x60, 0x33, 0xb6, 0x38, 0x5d, 0x3e, 0xed, 0x6d, 0xda, 0x1e, 0xd0, 0x85, - 0x63, 0x55, 0x2b, 0xe2, 0x1f, 0x00, 0x9a, 0xc4, 0xeb, 0x64, 0x23, 0xbc, 0x19, 0x5b, 0x1c, 0x2f, - 0x9f, 0xfc, 0x67, 0x49, 0xad, 0xd3, 0xd9, 0x68, 0xfb, 0xf3, 0xd1, 0x40, 0xed, 0x89, 0xf9, 0x5b, - 0x18, 0x53, 0x75, 0x50, 0x62, 0x58, 0xbb, 0x3c, 0xee, 0x2d, 0xb2, 0x7f, 0x71, 0x8d, 0x87, 0x53, - 0xcd, 0xef, 0x81, 0xdf, 0xb4, 0xe3, 0x13, 0xf0, 0x2e, 0x9e, 0xdf, 0x1d, 0x9c, 0x3d, 0xdc, 0xee, - 0xe4, 0xe0, 0xc7, 0x4e, 0x0e, 0xfe, 0xec, 0x24, 0xfb, 0x5e, 0x4a, 0xb6, 0x2d, 0x25, 0xbb, 0x2d, - 0x25, 0xfb, 0x55, 0x4a, 0xf6, 0xd9, 0x5b, 0x4f, 0xea, 0x53, 0x7e, 0xf9, 0x37, 0x00, 0x00, 0xff, - 0xff, 0x48, 0xfb, 0x27, 0x26, 0x21, 0x03, 0x00, 0x00, + // 396 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x92, 0xbd, 0x6e, 0xdb, 0x30, + 0x14, 0x85, 0x45, 0xf9, 0x47, 0x06, 0x0d, 0xbb, 0x2d, 0xd1, 0x81, 0x70, 0x0b, 0xd6, 0x55, 0x3b, + 0x78, 0x52, 0x5b, 0x77, 0x68, 0x97, 0x76, 0x70, 0xa6, 0x0c, 0xf1, 0x40, 0x07, 0x46, 0x56, 0x59, + 0xa2, 0x6d, 0x45, 0x91, 0x68, 0x90, 0x8c, 0xbc, 0xe6, 0x39, 0xf2, 0x44, 0x1e, 0x33, 0x66, 0x0a, + 0x62, 0x2d, 0x59, 0xf3, 0x08, 0x81, 0x44, 0x49, 0x30, 0x10, 0x39, 0x1b, 0x75, 0xf1, 0x9d, 0x73, + 0xae, 0x2e, 0x0e, 0xec, 0xcb, 0xd8, 0xdd, 0xc8, 0x35, 0x57, 0xce, 0x46, 0x70, 0xc5, 0x11, 0xf2, + 0xb9, 0x17, 0x32, 0xe1, 0xc8, 0xad, 0x2b, 0xa2, 0x30, 0x50, 0x4e, 0xf2, 0x6b, 0xd0, 0xe3, 0x8b, + 0x4b, 0xe6, 0x29, 0xa9, 0x91, 0x01, 0x14, 0xee, 0xb2, 0xc0, 0x07, 0x1f, 0x57, 0x7c, 0xc5, 0xf3, + 0xe7, 0x8f, 0xec, 0xa5, 0xa7, 0xf6, 0xad, 0x09, 0x7b, 0x33, 0xc5, 0x05, 0x9b, 0x15, 0xe6, 0xc8, + 0x81, 0xad, 0x98, 0xfb, 0x4c, 0x62, 0x30, 0x6c, 0x8c, 0xba, 0x63, 0xec, 0xbc, 0x8e, 0x71, 0xa6, + 0xdc, 0x67, 0x54, 0x63, 0xe8, 0x0f, 0xec, 0x48, 0x26, 0x92, 0xc0, 0x63, 0x12, 0x9b, 0xb9, 0xe4, + 0x53, 0x9d, 0x64, 0xa6, 0x19, 0x5a, 0xc1, 0x99, 0x30, 0x66, 0x6a, 0xcb, 0x45, 0x28, 0x71, 0xe3, + 0xb8, 0x70, 0xaa, 0x19, 0x5a, 0xc1, 0xd9, 0x86, 0xca, 0x95, 0xa1, 0xc4, 0xcd, 0xe3, 0x1b, 0x9e, + 0xbb, 0x32, 0xa4, 0x1a, 0xcb, 0x82, 0xbc, 0xab, 0x6b, 0xa9, 0x98, 0x90, 0xb8, 0x75, 0x3c, 0xe8, + 0x44, 0x33, 0xb4, 0x82, 0x6d, 0x06, 0xdf, 0x15, 0xc3, 0xea, 0x3a, 0x7f, 0xa1, 0x15, 0xb1, 0x68, + 0x91, 0x59, 0xe9, 0xfb, 0x90, 0x3a, 0x2b, 0xea, 0x2e, 0xd5, 0x59, 0x8e, 0xd1, 0x12, 0x47, 0x18, + 0x5a, 0x82, 0x45, 0x3c, 0x61, 0x7e, 0x7e, 0xa6, 0x26, 0x2d, 0x3f, 0xed, 0x27, 0x00, 0x3b, 0x55, + 0xc0, 0x7f, 0x68, 0x25, 0x4c, 0xc8, 0x80, 0xc7, 0x18, 0x0c, 0xc1, 0xa8, 0x3f, 0xfe, 0x5e, 0x7b, + 0xcd, 0xb2, 0x0a, 0x73, 0xcd, 0xd2, 0x52, 0x84, 0x4e, 0x21, 0x2c, 0x12, 0xd7, 0xc1, 0x06, 0x9b, + 0x43, 0x30, 0xea, 0x8e, 0xbf, 0xbd, 0xf1, 0xbb, 0xa5, 0xd3, 0xa4, 0xb9, 0x7b, 0xf8, 0x62, 0xd0, + 0x03, 0x31, 0xfa, 0x07, 0x5b, 0x32, 0xab, 0x06, 0x6e, 0xe4, 0x2e, 0x5f, 0x6b, 0x17, 0x39, 0xec, + 0x4e, 0xe1, 0xa1, 0x55, 0xf6, 0x07, 0x68, 0x15, 0xdb, 0xa1, 0x36, 0x34, 0xe7, 0x3f, 0xdf, 0x1b, + 0x93, 0xcf, 0xbb, 0x3d, 0x31, 0xee, 0xf7, 0xc4, 0x78, 0xde, 0x13, 0x70, 0x93, 0x12, 0xb0, 0x4b, + 0x09, 0xb8, 0x4b, 0x09, 0x78, 0x4c, 0x09, 0xb8, 0x30, 0x17, 0xed, 0xbc, 0x94, 0xbf, 0x5f, 0x02, + 0x00, 0x00, 0xff, 0xff, 0xc9, 0xd9, 0x1a, 0xd9, 0xeb, 0x02, 0x00, 0x00, } diff --git a/api/snapshot.proto b/api/snapshot.proto index 9054306d52..04751b1bd2 100644 --- a/api/snapshot.proto +++ b/api/snapshot.proto @@ -19,7 +19,6 @@ message StoreSnapshot { repeated Network networks = 3; repeated Task tasks = 4; repeated Cluster clusters = 5; - repeated Secret secrets = 6; } // ClusterSnapshot stores cluster membership information in snapshots. diff --git a/api/specs.pb.go b/api/specs.pb.go index f157843d00..d5d2a00bf2 100644 --- a/api/specs.pb.go +++ b/api/specs.pb.go @@ -473,9 +473,6 @@ type ContainerSpec struct { StopGracePeriod *docker_swarmkit_v11.Duration `protobuf:"bytes,9,opt,name=stop_grace_period,json=stopGracePeriod" json:"stop_grace_period,omitempty"` // PullOptions parameterize the behavior of image pulls. PullOptions *ContainerSpec_PullOptions `protobuf:"bytes,10,opt,name=pull_options,json=pullOptions" json:"pull_options,omitempty"` - // SecretReference contains references to zero or more secrets that - // will be exposed to the container. - Secrets []*SecretReference `protobuf:"bytes,12,rep,name=secrets" json:"secrets,omitempty"` } func (m *ContainerSpec) Reset() { *m = ContainerSpec{} } @@ -558,21 +555,6 @@ func (m *ClusterSpec) Reset() { *m = ClusterSpec{} } func (*ClusterSpec) ProtoMessage() {} func (*ClusterSpec) Descriptor() ([]byte, []int) { return fileDescriptorSpecs, []int{9} } -// SecretSpec specifies a user-provided secret. -type SecretSpec struct { - Annotations Annotations `protobuf:"bytes,1,opt,name=annotations" json:"annotations"` - // Type distinguishes the different kinds of secrets in the system. - Type SecretType `protobuf:"varint,2,opt,name=type,proto3,enum=docker.swarmkit.v1.SecretType" json:"type,omitempty"` - // Tags group secrets. - Tags []string `protobuf:"bytes,3,rep,name=tags" json:"tags,omitempty"` - // Secret payload. - Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` -} - -func (m *SecretSpec) Reset() { *m = SecretSpec{} } -func (*SecretSpec) ProtoMessage() {} -func (*SecretSpec) Descriptor() ([]byte, []int) { return fileDescriptorSpecs, []int{10} } - func init() { proto.RegisterType((*NodeSpec)(nil), "docker.swarmkit.v1.NodeSpec") proto.RegisterType((*ServiceSpec)(nil), "docker.swarmkit.v1.ServiceSpec") @@ -585,7 +567,6 @@ func init() { proto.RegisterType((*EndpointSpec)(nil), "docker.swarmkit.v1.EndpointSpec") proto.RegisterType((*NetworkSpec)(nil), "docker.swarmkit.v1.NetworkSpec") proto.RegisterType((*ClusterSpec)(nil), "docker.swarmkit.v1.ClusterSpec") - proto.RegisterType((*SecretSpec)(nil), "docker.swarmkit.v1.SecretSpec") proto.RegisterEnum("docker.swarmkit.v1.NodeSpec_Membership", NodeSpec_Membership_name, NodeSpec_Membership_value) proto.RegisterEnum("docker.swarmkit.v1.NodeSpec_Availability", NodeSpec_Availability_name, NodeSpec_Availability_value) proto.RegisterEnum("docker.swarmkit.v1.EndpointSpec_ResolutionMode", EndpointSpec_ResolutionMode_name, EndpointSpec_ResolutionMode_value) @@ -769,13 +750,6 @@ func (m *ContainerSpec) Copy() *ContainerSpec { } } - if m.Secrets != nil { - o.Secrets = make([]*SecretReference, 0, len(m.Secrets)) - for _, v := range m.Secrets { - o.Secrets = append(o.Secrets, v.Copy()) - } - } - return o } @@ -845,27 +819,6 @@ func (m *ClusterSpec) Copy() *ClusterSpec { return o } -func (m *SecretSpec) Copy() *SecretSpec { - if m == nil { - return nil - } - - o := &SecretSpec{ - Annotations: *m.Annotations.Copy(), - Type: m.Type, - Data: m.Data, - } - - if m.Tags != nil { - o.Tags = make([]string, 0, len(m.Tags)) - for _, v := range m.Tags { - o.Tags = append(o.Tags, v) - } - } - - return o -} - func (this *NodeSpec) GoString() string { if this == nil { return "nil" @@ -994,7 +947,7 @@ func (this *ContainerSpec) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 16) + s := make([]string, 0, 15) s = append(s, "&api.ContainerSpec{") s = append(s, "Image: "+fmt.Sprintf("%#v", this.Image)+",\n") keysForLabels := make([]string, 0, len(this.Labels)) @@ -1025,9 +978,6 @@ func (this *ContainerSpec) GoString() string { if this.PullOptions != nil { s = append(s, "PullOptions: "+fmt.Sprintf("%#v", this.PullOptions)+",\n") } - if this.Secrets != nil { - s = append(s, "Secrets: "+fmt.Sprintf("%#v", this.Secrets)+",\n") - } s = append(s, "}") return strings.Join(s, "") } @@ -1089,19 +1039,6 @@ func (this *ClusterSpec) GoString() string { s = append(s, "}") return strings.Join(s, "") } -func (this *SecretSpec) GoString() string { - if this == nil { - return "nil" - } - s := make([]string, 0, 8) - s = append(s, "&api.SecretSpec{") - s = append(s, "Annotations: "+strings.Replace(this.Annotations.GoString(), `&`, ``, 1)+",\n") - s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n") - s = append(s, "Tags: "+fmt.Sprintf("%#v", this.Tags)+",\n") - s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") - s = append(s, "}") - return strings.Join(s, "") -} func valueToGoStringSpecs(v interface{}, typ string) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -1581,18 +1518,6 @@ func (m *ContainerSpec) MarshalTo(data []byte) (int, error) { i += copy(data[i:], s) } } - if len(m.Secrets) > 0 { - for _, msg := range m.Secrets { - data[i] = 0x62 - i++ - i = encodeVarintSpecs(data, i, uint64(msg.Size())) - n, err := msg.MarshalTo(data[i:]) - if err != nil { - return 0, err - } - i += n - } - } return i, nil } @@ -1807,58 +1732,6 @@ func (m *ClusterSpec) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *SecretSpec) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *SecretSpec) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - data[i] = 0xa - i++ - i = encodeVarintSpecs(data, i, uint64(m.Annotations.Size())) - n28, err := m.Annotations.MarshalTo(data[i:]) - if err != nil { - return 0, err - } - i += n28 - if m.Type != 0 { - data[i] = 0x10 - i++ - i = encodeVarintSpecs(data, i, uint64(m.Type)) - } - if len(m.Tags) > 0 { - for _, s := range m.Tags { - data[i] = 0x1a - i++ - l = len(s) - for l >= 1<<7 { - data[i] = uint8(uint64(l)&0x7f | 0x80) - l >>= 7 - i++ - } - data[i] = uint8(l) - i++ - i += copy(data[i:], s) - } - } - if len(m.Data) > 0 { - data[i] = 0x22 - i++ - i = encodeVarintSpecs(data, i, uint64(len(m.Data))) - i += copy(data[i:], m.Data) - } - return i, nil -} - func encodeFixed64Specs(data []byte, offset int, v uint64) int { data[offset] = uint8(v) data[offset+1] = uint8(v >> 8) @@ -2084,12 +1957,6 @@ func (m *ContainerSpec) Size() (n int) { n += 1 + l + sovSpecs(uint64(l)) } } - if len(m.Secrets) > 0 { - for _, e := range m.Secrets { - l = e.Size() - n += 1 + l + sovSpecs(uint64(l)) - } - } return n } @@ -2163,27 +2030,6 @@ func (m *ClusterSpec) Size() (n int) { return n } -func (m *SecretSpec) Size() (n int) { - var l int - _ = l - l = m.Annotations.Size() - n += 1 + l + sovSpecs(uint64(l)) - if m.Type != 0 { - n += 1 + sovSpecs(uint64(m.Type)) - } - if len(m.Tags) > 0 { - for _, s := range m.Tags { - l = len(s) - n += 1 + l + sovSpecs(uint64(l)) - } - } - l = len(m.Data) - if l > 0 { - n += 1 + l + sovSpecs(uint64(l)) - } - return n -} - func sovSpecs(x uint64) (n int) { for { n++ @@ -2335,7 +2181,6 @@ func (this *ContainerSpec) String() string { `StopGracePeriod:` + strings.Replace(fmt.Sprintf("%v", this.StopGracePeriod), "Duration", "docker_swarmkit_v11.Duration", 1) + `,`, `PullOptions:` + strings.Replace(fmt.Sprintf("%v", this.PullOptions), "ContainerSpec_PullOptions", "ContainerSpec_PullOptions", 1) + `,`, `Groups:` + fmt.Sprintf("%v", this.Groups) + `,`, - `Secrets:` + strings.Replace(fmt.Sprintf("%v", this.Secrets), "SecretReference", "SecretReference", 1) + `,`, `}`, }, "") return s @@ -2392,19 +2237,6 @@ func (this *ClusterSpec) String() string { }, "") return s } -func (this *SecretSpec) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&SecretSpec{`, - `Annotations:` + strings.Replace(strings.Replace(this.Annotations.String(), "Annotations", "Annotations", 1), `&`, ``, 1) + `,`, - `Type:` + fmt.Sprintf("%v", this.Type) + `,`, - `Tags:` + fmt.Sprintf("%v", this.Tags) + `,`, - `Data:` + fmt.Sprintf("%v", this.Data) + `,`, - `}`, - }, "") - return s -} func valueToStringSpecs(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -3736,37 +3568,6 @@ func (m *ContainerSpec) Unmarshal(data []byte) error { } m.Groups = append(m.Groups, string(data[iNdEx:postIndex])) iNdEx = postIndex - case 12: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Secrets", 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 - } - m.Secrets = append(m.Secrets, &SecretReference{}) - if err := m.Secrets[len(m.Secrets)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSpecs(data[iNdEx:]) @@ -4433,165 +4234,6 @@ func (m *ClusterSpec) Unmarshal(data []byte) error { } return nil } -func (m *SecretSpec) Unmarshal(data []byte) error { - l := len(data) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSpecs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: SecretSpec: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SecretSpec: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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 err := m.Annotations.Unmarshal(data[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) - } - m.Type = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSpecs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - m.Type |= (SecretType(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSpecs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthSpecs - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Tags = append(m.Tags, string(data[iNdEx:postIndex])) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSpecs - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - byteLen |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthSpecs - } - postIndex := iNdEx + byteLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Data = append(m.Data[:0], data[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipSpecs(data[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthSpecs - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func skipSpecs(data []byte) (n int, err error) { l := len(data) iNdEx := 0 @@ -4698,97 +4340,93 @@ var ( ) var fileDescriptorSpecs = []byte{ - // 1470 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x6f, 0xdb, 0xc8, - 0x15, 0x17, 0x6d, 0x5a, 0x96, 0x1e, 0xe5, 0x44, 0x19, 0xe4, 0x0f, 0xa3, 0xa4, 0xb2, 0xa2, 0xa4, - 0xa9, 0xd3, 0xa2, 0x76, 0xab, 0x16, 0x69, 0xd2, 0x34, 0x68, 0xf5, 0xaf, 0x8e, 0xea, 0xda, 0x11, - 0xc6, 0x4e, 0x80, 0x9e, 0x84, 0x31, 0x39, 0x96, 0x09, 0x53, 0x1c, 0x76, 0x38, 0x54, 0xe0, 0x5b, - 0x8f, 0x81, 0x0f, 0xfd, 0x06, 0x3e, 0x15, 0xe8, 0xbd, 0x87, 0x7e, 0x87, 0x1c, 0x7b, 0xec, 0xc9, - 0x58, 0xfb, 0xba, 0x58, 0x60, 0x81, 0xfd, 0x02, 0x8b, 0x19, 0x8e, 0x24, 0x6a, 0x43, 0x27, 0x01, - 0xd6, 0xb7, 0x99, 0xc7, 0xdf, 0xef, 0xcd, 0xe3, 0x7b, 0x3f, 0xbe, 0x37, 0x04, 0x2b, 0x0a, 0xa9, - 0x13, 0xad, 0x87, 0x9c, 0x09, 0x86, 0x90, 0xcb, 0x9c, 0x23, 0xca, 0xd7, 0xa3, 0x77, 0x84, 0x8f, - 0x8e, 0x3c, 0xb1, 0x3e, 0xfe, 0x75, 0xc5, 0x12, 0xc7, 0x21, 0xd5, 0x80, 0xca, 0xcd, 0x21, 0x1b, - 0x32, 0xb5, 0xdc, 0x90, 0x2b, 0x6d, 0xbd, 0xe3, 0xc6, 0x9c, 0x08, 0x8f, 0x05, 0x1b, 0x93, 0x45, - 0xf2, 0xa0, 0xfe, 0x4f, 0x13, 0x0a, 0x3b, 0xcc, 0xa5, 0xbb, 0x21, 0x75, 0xd0, 0x26, 0x58, 0x24, - 0x08, 0x98, 0x50, 0x80, 0xc8, 0x36, 0x6a, 0xc6, 0x9a, 0xd5, 0x58, 0x5d, 0xff, 0xf8, 0xc8, 0xf5, - 0xe6, 0x0c, 0xd6, 0x32, 0x3f, 0x9c, 0xad, 0xe6, 0x70, 0x9a, 0x89, 0x7e, 0x05, 0x26, 0x67, 0x3e, - 0xb5, 0x17, 0x6a, 0xc6, 0xda, 0xb5, 0xc6, 0xfd, 0x2c, 0x0f, 0xf2, 0x50, 0xcc, 0x7c, 0x8a, 0x15, - 0x12, 0x6d, 0x02, 0x8c, 0xe8, 0x68, 0x9f, 0xf2, 0xe8, 0xd0, 0x0b, 0xed, 0x45, 0xc5, 0xfb, 0xd9, - 0x65, 0x3c, 0x19, 0xec, 0xfa, 0xf6, 0x14, 0x8e, 0x53, 0x54, 0xb4, 0x0d, 0x25, 0x32, 0x26, 0x9e, - 0x4f, 0xf6, 0x3d, 0xdf, 0x13, 0xc7, 0xb6, 0xa9, 0x5c, 0x3d, 0xf9, 0xa4, 0xab, 0x66, 0x8a, 0x80, - 0xe7, 0xe8, 0x75, 0x17, 0x60, 0x76, 0x10, 0x7a, 0x0c, 0xcb, 0xfd, 0xee, 0x4e, 0xa7, 0xb7, 0xb3, - 0x59, 0xce, 0x55, 0xee, 0x9e, 0x9c, 0xd6, 0x6e, 0x49, 0x1f, 0x33, 0x40, 0x9f, 0x06, 0xae, 0x17, - 0x0c, 0xd1, 0x1a, 0x14, 0x9a, 0xed, 0x76, 0xb7, 0xbf, 0xd7, 0xed, 0x94, 0x8d, 0x4a, 0xe5, 0xe4, - 0xb4, 0x76, 0x7b, 0x1e, 0xd8, 0x74, 0x1c, 0x1a, 0x0a, 0xea, 0x56, 0xcc, 0xf7, 0xff, 0xaa, 0xe6, - 0xea, 0xef, 0x0d, 0x28, 0xa5, 0x83, 0x40, 0x8f, 0x21, 0xdf, 0x6c, 0xef, 0xf5, 0xde, 0x76, 0xcb, - 0xb9, 0x19, 0x3d, 0x8d, 0x68, 0x3a, 0xc2, 0x1b, 0x53, 0xf4, 0x08, 0x96, 0xfa, 0xcd, 0x37, 0xbb, - 0xdd, 0xb2, 0x31, 0x0b, 0x27, 0x0d, 0xeb, 0x93, 0x38, 0x52, 0xa8, 0x0e, 0x6e, 0xf6, 0x76, 0xca, - 0x0b, 0xd9, 0xa8, 0x0e, 0x27, 0x5e, 0xa0, 0x43, 0x39, 0x5f, 0x04, 0x6b, 0x97, 0xf2, 0xb1, 0xe7, - 0x5c, 0xb1, 0x26, 0x9e, 0x82, 0x29, 0x48, 0x74, 0xa4, 0x34, 0x61, 0x65, 0x6b, 0x62, 0x8f, 0x44, - 0x47, 0xf2, 0x50, 0x4d, 0x57, 0x78, 0xa9, 0x0c, 0x4e, 0x43, 0xdf, 0x73, 0x88, 0xa0, 0xae, 0x52, - 0x86, 0xd5, 0xf8, 0x69, 0x16, 0x1b, 0x4f, 0x51, 0x3a, 0xfe, 0x57, 0x39, 0x9c, 0xa2, 0xa2, 0x17, - 0x90, 0x1f, 0xfa, 0x6c, 0x9f, 0xf8, 0x4a, 0x13, 0x56, 0xe3, 0x41, 0x96, 0x93, 0x4d, 0x85, 0x98, - 0x39, 0xd0, 0x14, 0xf4, 0x0c, 0xf2, 0x71, 0xe8, 0x12, 0x41, 0xed, 0xbc, 0x22, 0xd7, 0xb2, 0xc8, - 0x6f, 0x14, 0xa2, 0xcd, 0x82, 0x03, 0x6f, 0x88, 0x35, 0x1e, 0x6d, 0x41, 0x21, 0xa0, 0xe2, 0x1d, - 0xe3, 0x47, 0x91, 0xbd, 0x5c, 0x5b, 0x5c, 0xb3, 0x1a, 0xbf, 0xc8, 0x14, 0x63, 0x82, 0x69, 0x0a, - 0x41, 0x9c, 0xc3, 0x11, 0x0d, 0x44, 0xe2, 0xa6, 0xb5, 0x60, 0x1b, 0x78, 0xea, 0x00, 0xfd, 0x01, - 0x0a, 0x34, 0x70, 0x43, 0xe6, 0x05, 0xc2, 0x2e, 0x5c, 0x1e, 0x48, 0x57, 0x63, 0x64, 0x32, 0xf1, - 0x94, 0xd1, 0xca, 0x83, 0x39, 0x62, 0x2e, 0xad, 0x6f, 0xc0, 0x8d, 0x8f, 0x92, 0x85, 0x2a, 0x50, - 0xd0, 0xc9, 0x4a, 0xaa, 0x6c, 0xe2, 0xe9, 0xbe, 0x7e, 0x1d, 0x56, 0xe6, 0x12, 0x53, 0xff, 0x7a, - 0x11, 0x0a, 0x93, 0x6a, 0xa1, 0x26, 0x14, 0x1d, 0x16, 0x08, 0xe2, 0x05, 0x94, 0x6b, 0x81, 0x64, - 0xe6, 0xb6, 0x3d, 0x01, 0x49, 0xd6, 0xab, 0x1c, 0x9e, 0xb1, 0xd0, 0x9f, 0xa1, 0xc8, 0x69, 0xc4, - 0x62, 0xee, 0xd0, 0x48, 0x2b, 0x64, 0x2d, 0xbb, 0xc6, 0x09, 0x08, 0xd3, 0xbf, 0xc7, 0x1e, 0xa7, - 0x32, 0x4f, 0x11, 0x9e, 0x51, 0xd1, 0x0b, 0x58, 0xe6, 0x34, 0x12, 0x84, 0x8b, 0x4f, 0x15, 0x19, - 0x27, 0x90, 0x3e, 0xf3, 0x3d, 0xe7, 0x18, 0x4f, 0x18, 0xe8, 0x05, 0x14, 0x43, 0x9f, 0x38, 0xca, - 0xab, 0xbd, 0xa4, 0xe8, 0x3f, 0xc9, 0xa2, 0xf7, 0x27, 0x20, 0x3c, 0xc3, 0xa3, 0xe7, 0x00, 0x3e, - 0x1b, 0x0e, 0x5c, 0xee, 0x8d, 0x29, 0xd7, 0x22, 0xa9, 0x64, 0xb1, 0x3b, 0x0a, 0x81, 0x8b, 0x3e, - 0x1b, 0x26, 0x4b, 0xb4, 0xf9, 0xa3, 0x14, 0x92, 0x52, 0xc7, 0x16, 0x00, 0x99, 0x3e, 0xd5, 0xfa, - 0x78, 0xf2, 0x45, 0xae, 0x74, 0x45, 0x52, 0xf4, 0x56, 0x11, 0x96, 0x79, 0x1c, 0x08, 0x6f, 0x44, - 0xeb, 0x5b, 0x70, 0x2b, 0x93, 0x81, 0x1a, 0x50, 0x9a, 0xd6, 0x70, 0xe0, 0xb9, 0xaa, 0xf8, 0xc5, - 0xd6, 0xf5, 0x8b, 0xb3, 0x55, 0x6b, 0x5a, 0xec, 0x5e, 0x07, 0x5b, 0x53, 0x50, 0xcf, 0xad, 0x7f, - 0x63, 0xc2, 0xca, 0x9c, 0x12, 0xd0, 0x4d, 0x58, 0xf2, 0x46, 0x64, 0x48, 0x13, 0x3a, 0x4e, 0x36, - 0xa8, 0x0b, 0x79, 0x9f, 0xec, 0x53, 0x5f, 0xea, 0x41, 0xe6, 0xe4, 0x97, 0x9f, 0x95, 0xd4, 0xfa, - 0x5f, 0x15, 0xbe, 0x1b, 0x08, 0x7e, 0x8c, 0x35, 0x19, 0xd9, 0xb0, 0xec, 0xb0, 0xd1, 0x88, 0x04, - 0xb2, 0x77, 0x2c, 0xae, 0x15, 0xf1, 0x64, 0x8b, 0x10, 0x98, 0x84, 0x0f, 0x23, 0xdb, 0x54, 0x66, - 0xb5, 0x46, 0x65, 0x58, 0xa4, 0xc1, 0xd8, 0x5e, 0x52, 0x26, 0xb9, 0x94, 0x16, 0xd7, 0x4b, 0x0a, - 0x5a, 0xc4, 0x72, 0x29, 0x79, 0x71, 0x44, 0xb9, 0xbd, 0xac, 0x4c, 0x6a, 0x8d, 0x7e, 0x07, 0xf9, - 0x11, 0x8b, 0x03, 0x11, 0xd9, 0x05, 0x15, 0xec, 0xdd, 0xac, 0x60, 0xb7, 0x25, 0x42, 0xf7, 0x36, - 0x0d, 0x47, 0xaf, 0xe0, 0x46, 0x24, 0x58, 0x38, 0x18, 0x72, 0xe2, 0xd0, 0x41, 0x48, 0xb9, 0xc7, - 0x5c, 0xbb, 0x78, 0x79, 0x8b, 0xec, 0xe8, 0xf1, 0x8d, 0xaf, 0x4b, 0xda, 0xa6, 0x64, 0xf5, 0x15, - 0x09, 0xf5, 0xa1, 0x14, 0xc6, 0xbe, 0x3f, 0x60, 0x61, 0xd2, 0xa9, 0x41, 0x39, 0xf9, 0x82, 0xac, - 0xf5, 0x63, 0xdf, 0x7f, 0x9d, 0x90, 0xb0, 0x15, 0xce, 0x36, 0xe8, 0x36, 0xe4, 0x87, 0x9c, 0xc5, - 0x61, 0x64, 0x5b, 0x2a, 0x1f, 0x7a, 0x87, 0x5e, 0xc2, 0x72, 0x44, 0x1d, 0x4e, 0x45, 0x64, 0x97, - 0xd4, 0xdb, 0x3e, 0xcc, 0x3a, 0x64, 0x57, 0x41, 0x30, 0x3d, 0xa0, 0x9c, 0x06, 0x0e, 0xc5, 0x13, - 0x4e, 0xe5, 0x39, 0x58, 0xa9, 0x42, 0xc9, 0x04, 0x1f, 0xd1, 0x63, 0x5d, 0x7b, 0xb9, 0x94, 0x7a, - 0x18, 0x13, 0x3f, 0x4e, 0xae, 0x0f, 0x45, 0x9c, 0x6c, 0x7e, 0xbf, 0xf0, 0xcc, 0xa8, 0x34, 0xc0, - 0x4a, 0x45, 0x8b, 0x1e, 0xc2, 0x0a, 0xa7, 0x43, 0x2f, 0x12, 0xfc, 0x78, 0x40, 0x62, 0x71, 0x68, - 0xff, 0x49, 0x11, 0x4a, 0x13, 0x63, 0x33, 0x16, 0x87, 0xf5, 0xef, 0x0c, 0x28, 0xa5, 0xfb, 0x21, - 0x6a, 0x27, 0x5d, 0x50, 0x9d, 0x78, 0xad, 0xb1, 0xf1, 0xb9, 0xfe, 0xa9, 0x7a, 0x8e, 0x1f, 0xcb, - 0x13, 0xb7, 0xe5, 0x9d, 0x45, 0x91, 0xd1, 0x6f, 0x61, 0x29, 0x64, 0x5c, 0x4c, 0xc4, 0x59, 0xcd, - 0xec, 0x13, 0x8c, 0x4f, 0xbe, 0xd1, 0x04, 0x5c, 0x3f, 0x84, 0x6b, 0xf3, 0xde, 0xd0, 0x23, 0x58, - 0x7c, 0xdb, 0xeb, 0x97, 0x73, 0x95, 0x7b, 0x27, 0xa7, 0xb5, 0x3b, 0xf3, 0x0f, 0xdf, 0x7a, 0x5c, - 0xc4, 0xc4, 0xef, 0xf5, 0xd1, 0xcf, 0x61, 0xa9, 0xb3, 0xb3, 0x8b, 0x71, 0xd9, 0xa8, 0xac, 0x9e, - 0x9c, 0xd6, 0xee, 0xcd, 0xe3, 0xe4, 0x23, 0x16, 0x07, 0x2e, 0x66, 0xfb, 0xd3, 0x31, 0xfe, 0xdf, - 0x05, 0xb0, 0xf4, 0x37, 0x7b, 0xb5, 0x63, 0xfc, 0x8f, 0xb0, 0x92, 0xf4, 0xb8, 0x81, 0xa3, 0x5e, - 0x4d, 0x77, 0xeb, 0x4f, 0xb5, 0xba, 0x52, 0x42, 0x48, 0x52, 0x81, 0x1e, 0x40, 0xc9, 0x0b, 0xc7, - 0x4f, 0x07, 0x34, 0x20, 0xfb, 0xbe, 0x9e, 0xe8, 0x05, 0x6c, 0x49, 0x5b, 0x37, 0x31, 0xc9, 0x51, - 0xe4, 0x05, 0x82, 0xf2, 0x40, 0xcf, 0xea, 0x02, 0x9e, 0xee, 0xd1, 0x4b, 0x30, 0xbd, 0x90, 0x8c, - 0x74, 0x7f, 0xce, 0x7c, 0x83, 0x5e, 0xbf, 0xb9, 0xad, 0x25, 0xd2, 0x2a, 0x5c, 0x9c, 0xad, 0x9a, - 0xd2, 0x80, 0x15, 0x0d, 0x55, 0x27, 0x2d, 0x52, 0x9e, 0xa4, 0xbe, 0xea, 0x02, 0x4e, 0x59, 0xea, - 0xff, 0x36, 0xc1, 0x6a, 0xfb, 0x71, 0x24, 0x74, 0x6f, 0xba, 0xb2, 0xbc, 0xfd, 0x0d, 0x6e, 0x10, - 0x75, 0xe9, 0x23, 0x81, 0xfc, 0xd0, 0xd5, 0xe8, 0xd1, 0xb9, 0x7b, 0x94, 0xe9, 0x6e, 0x0a, 0x4e, - 0xc6, 0x54, 0x2b, 0x2f, 0x7d, 0xda, 0x06, 0x2e, 0x93, 0x1f, 0x3c, 0x41, 0xbb, 0xb0, 0xc2, 0xb8, - 0x73, 0x48, 0x23, 0x91, 0xf4, 0x06, 0x7d, 0x49, 0xca, 0xbc, 0x3e, 0xbf, 0x4e, 0x03, 0xf5, 0x15, - 0x23, 0x89, 0x76, 0xde, 0x07, 0x7a, 0x06, 0x26, 0x27, 0x07, 0x93, 0x31, 0x9a, 0xa9, 0x6f, 0x4c, - 0x0e, 0xc4, 0x9c, 0x0b, 0xc5, 0x40, 0x7f, 0x01, 0x70, 0xbd, 0x28, 0x24, 0xc2, 0x39, 0xa4, 0x5c, - 0xd7, 0x29, 0xf3, 0x15, 0x3b, 0x53, 0xd4, 0x9c, 0x97, 0x14, 0x1b, 0x6d, 0x41, 0xd1, 0x21, 0x13, - 0xa5, 0xe5, 0x2f, 0x6f, 0x8b, 0xed, 0xa6, 0x76, 0x51, 0x96, 0x2e, 0x2e, 0xce, 0x56, 0x0b, 0x13, - 0x0b, 0x2e, 0x38, 0x44, 0x2b, 0x6f, 0x0b, 0x56, 0xe4, 0x8d, 0x72, 0xe0, 0xd2, 0x03, 0x12, 0xfb, - 0x22, 0x52, 0x1d, 0xfc, 0x92, 0x1b, 0x94, 0xbc, 0xdc, 0x74, 0x34, 0x4e, 0xc7, 0x55, 0x12, 0x29, - 0x5b, 0xfd, 0x3f, 0x06, 0x40, 0xd2, 0xe2, 0xae, 0x56, 0x27, 0x0d, 0x30, 0xe5, 0xef, 0x9c, 0xfe, - 0x75, 0xaa, 0x5e, 0xde, 0x59, 0xf7, 0x8e, 0x43, 0x8a, 0x15, 0x56, 0x4e, 0x24, 0x41, 0x86, 0x91, - 0x1e, 0x70, 0x6a, 0x2d, 0x6d, 0x2e, 0x11, 0x44, 0xd5, 0xaf, 0x84, 0xd5, 0xba, 0x75, 0xff, 0xc3, - 0x79, 0x35, 0xf7, 0xff, 0xf3, 0x6a, 0xee, 0xdb, 0xf3, 0xaa, 0xf1, 0x8f, 0x8b, 0xaa, 0xf1, 0xe1, - 0xa2, 0x6a, 0xfc, 0xef, 0xa2, 0x6a, 0x7c, 0x75, 0x51, 0x35, 0xf6, 0xf3, 0xea, 0x8f, 0xf0, 0x37, - 0xdf, 0x07, 0x00, 0x00, 0xff, 0xff, 0x1e, 0xd5, 0xdd, 0x17, 0x70, 0x0e, 0x00, 0x00, + // 1397 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x6f, 0xdb, 0xc6, + 0x12, 0x17, 0x6d, 0x5a, 0x96, 0x86, 0x72, 0xa2, 0x2c, 0xf2, 0x87, 0x51, 0xf2, 0x64, 0x45, 0x2f, + 0x2f, 0xcf, 0x79, 0x0f, 0xb5, 0x5b, 0xb5, 0x48, 0x93, 0xa6, 0x45, 0x2b, 0x4b, 0xaa, 0xa3, 0xba, + 0x76, 0x84, 0x75, 0x12, 0xa0, 0x27, 0x61, 0x4d, 0xae, 0x65, 0xc2, 0x14, 0x97, 0x5d, 0x2e, 0x15, + 0xf8, 0xd6, 0x63, 0xe0, 0x43, 0xbf, 0x81, 0x4f, 0x05, 0x7a, 0xec, 0xad, 0xdf, 0x21, 0xc7, 0x1e, + 0x7b, 0x32, 0x6a, 0x5f, 0x7b, 0x29, 0xd0, 0x2f, 0x50, 0xec, 0x72, 0x25, 0x51, 0x0d, 0x9d, 0x04, + 0x68, 0x6e, 0xbb, 0xc3, 0xdf, 0x6f, 0x76, 0x34, 0xf3, 0xdb, 0x99, 0x15, 0x58, 0x51, 0x48, 0x9d, + 0x68, 0x35, 0xe4, 0x4c, 0x30, 0x84, 0x5c, 0xe6, 0x1c, 0x50, 0xbe, 0x1a, 0x3d, 0x27, 0x7c, 0x78, + 0xe0, 0x89, 0xd5, 0xd1, 0x07, 0x15, 0x4b, 0x1c, 0x86, 0x54, 0x03, 0x2a, 0x97, 0x07, 0x6c, 0xc0, + 0xd4, 0x72, 0x4d, 0xae, 0xb4, 0xf5, 0x9a, 0x1b, 0x73, 0x22, 0x3c, 0x16, 0xac, 0x8d, 0x17, 0xc9, + 0x87, 0xfa, 0xf7, 0x26, 0x14, 0xb6, 0x99, 0x4b, 0x77, 0x42, 0xea, 0xa0, 0x0d, 0xb0, 0x48, 0x10, + 0x30, 0xa1, 0x00, 0x91, 0x6d, 0xd4, 0x8c, 0x15, 0xab, 0xb1, 0xbc, 0xfa, 0xea, 0x91, 0xab, 0xcd, + 0x29, 0x6c, 0xdd, 0x7c, 0x79, 0xb2, 0x9c, 0xc3, 0x69, 0x26, 0x7a, 0x1f, 0x4c, 0xce, 0x7c, 0x6a, + 0xcf, 0xd5, 0x8c, 0x95, 0x0b, 0x8d, 0x9b, 0x59, 0x1e, 0xe4, 0xa1, 0x98, 0xf9, 0x14, 0x2b, 0x24, + 0xda, 0x00, 0x18, 0xd2, 0xe1, 0x2e, 0xe5, 0xd1, 0xbe, 0x17, 0xda, 0xf3, 0x8a, 0xf7, 0xdf, 0xf3, + 0x78, 0x32, 0xd8, 0xd5, 0xad, 0x09, 0x1c, 0xa7, 0xa8, 0x68, 0x0b, 0x4a, 0x64, 0x44, 0x3c, 0x9f, + 0xec, 0x7a, 0xbe, 0x27, 0x0e, 0x6d, 0x53, 0xb9, 0xba, 0xfb, 0x5a, 0x57, 0xcd, 0x14, 0x01, 0xcf, + 0xd0, 0xeb, 0x2e, 0xc0, 0xf4, 0x20, 0x74, 0x07, 0x16, 0x7b, 0x9d, 0xed, 0x76, 0x77, 0x7b, 0xa3, + 0x9c, 0xab, 0x5c, 0x3f, 0x3a, 0xae, 0x5d, 0x91, 0x3e, 0xa6, 0x80, 0x1e, 0x0d, 0x5c, 0x2f, 0x18, + 0xa0, 0x15, 0x28, 0x34, 0x5b, 0xad, 0x4e, 0xef, 0x49, 0xa7, 0x5d, 0x36, 0x2a, 0x95, 0xa3, 0xe3, + 0xda, 0xd5, 0x59, 0x60, 0xd3, 0x71, 0x68, 0x28, 0xa8, 0x5b, 0x31, 0x5f, 0xfc, 0x50, 0xcd, 0xd5, + 0x5f, 0x18, 0x50, 0x4a, 0x07, 0x81, 0xee, 0x40, 0xbe, 0xd9, 0x7a, 0xd2, 0x7d, 0xd6, 0x29, 0xe7, + 0xa6, 0xf4, 0x34, 0xa2, 0xe9, 0x08, 0x6f, 0x44, 0xd1, 0x6d, 0x58, 0xe8, 0x35, 0x9f, 0xee, 0x74, + 0xca, 0xc6, 0x34, 0x9c, 0x34, 0xac, 0x47, 0xe2, 0x48, 0xa1, 0xda, 0xb8, 0xd9, 0xdd, 0x2e, 0xcf, + 0x65, 0xa3, 0xda, 0x9c, 0x78, 0x81, 0x0e, 0xe5, 0x74, 0x1e, 0xac, 0x1d, 0xca, 0x47, 0x9e, 0xf3, + 0x8e, 0x35, 0x71, 0x0f, 0x4c, 0x41, 0xa2, 0x03, 0xa5, 0x09, 0x2b, 0x5b, 0x13, 0x4f, 0x48, 0x74, + 0x20, 0x0f, 0xd5, 0x74, 0x85, 0x97, 0xca, 0xe0, 0x34, 0xf4, 0x3d, 0x87, 0x08, 0xea, 0x2a, 0x65, + 0x58, 0x8d, 0xff, 0x64, 0xb1, 0xf1, 0x04, 0xa5, 0xe3, 0x7f, 0x94, 0xc3, 0x29, 0x2a, 0x7a, 0x08, + 0xf9, 0x81, 0xcf, 0x76, 0x89, 0xaf, 0x34, 0x61, 0x35, 0x6e, 0x65, 0x39, 0xd9, 0x50, 0x88, 0xa9, + 0x03, 0x4d, 0x41, 0xf7, 0x21, 0x1f, 0x87, 0x2e, 0x11, 0xd4, 0xce, 0x2b, 0x72, 0x2d, 0x8b, 0xfc, + 0x54, 0x21, 0x5a, 0x2c, 0xd8, 0xf3, 0x06, 0x58, 0xe3, 0xd1, 0x26, 0x14, 0x02, 0x2a, 0x9e, 0x33, + 0x7e, 0x10, 0xd9, 0x8b, 0xb5, 0xf9, 0x15, 0xab, 0xf1, 0xff, 0x4c, 0x31, 0x26, 0x98, 0xa6, 0x10, + 0xc4, 0xd9, 0x1f, 0xd2, 0x40, 0x24, 0x6e, 0xd6, 0xe7, 0x6c, 0x03, 0x4f, 0x1c, 0xa0, 0x4f, 0xa1, + 0x40, 0x03, 0x37, 0x64, 0x5e, 0x20, 0xec, 0xc2, 0xf9, 0x81, 0x74, 0x34, 0x46, 0x26, 0x13, 0x4f, + 0x18, 0xeb, 0x79, 0x30, 0x87, 0xcc, 0xa5, 0xf5, 0x35, 0xb8, 0xf4, 0x4a, 0xb2, 0x50, 0x05, 0x0a, + 0x3a, 0x59, 0x49, 0x95, 0x4d, 0x3c, 0xd9, 0xd7, 0x2f, 0xc2, 0xd2, 0x4c, 0x62, 0xea, 0xbf, 0xcf, + 0x43, 0x61, 0x5c, 0x2d, 0xd4, 0x84, 0xa2, 0xc3, 0x02, 0x41, 0xbc, 0x80, 0x72, 0x2d, 0x90, 0xcc, + 0xdc, 0xb6, 0xc6, 0x20, 0xc9, 0x7a, 0x94, 0xc3, 0x53, 0x16, 0xfa, 0x12, 0x8a, 0x9c, 0x46, 0x2c, + 0xe6, 0x0e, 0x8d, 0xb4, 0x42, 0x56, 0xb2, 0x6b, 0x9c, 0x80, 0x30, 0xfd, 0x36, 0xf6, 0x38, 0x95, + 0x79, 0x8a, 0xf0, 0x94, 0x8a, 0x1e, 0xc2, 0x22, 0xa7, 0x91, 0x20, 0x5c, 0xbc, 0xae, 0xc8, 0x38, + 0x81, 0xf4, 0x98, 0xef, 0x39, 0x87, 0x78, 0xcc, 0x40, 0x0f, 0xa1, 0x18, 0xfa, 0xc4, 0x51, 0x5e, + 0xed, 0x05, 0x45, 0xff, 0x57, 0x16, 0xbd, 0x37, 0x06, 0xe1, 0x29, 0x1e, 0x3d, 0x00, 0xf0, 0xd9, + 0xa0, 0xef, 0x72, 0x6f, 0x44, 0xb9, 0x16, 0x49, 0x25, 0x8b, 0xdd, 0x56, 0x08, 0x5c, 0xf4, 0xd9, + 0x20, 0x59, 0xa2, 0x8d, 0x7f, 0xa4, 0x90, 0x94, 0x3a, 0x36, 0x01, 0xc8, 0xe4, 0xab, 0xd6, 0xc7, + 0xdd, 0xb7, 0x72, 0xa5, 0x2b, 0x92, 0xa2, 0xaf, 0x17, 0x61, 0x91, 0xc7, 0x81, 0xf0, 0x86, 0xb4, + 0xbe, 0x09, 0x57, 0x32, 0x19, 0xa8, 0x01, 0xa5, 0x49, 0x0d, 0xfb, 0x9e, 0xab, 0x8a, 0x5f, 0x5c, + 0xbf, 0x78, 0x76, 0xb2, 0x6c, 0x4d, 0x8a, 0xdd, 0x6d, 0x63, 0x6b, 0x02, 0xea, 0xba, 0xf5, 0x9f, + 0x4c, 0x58, 0x9a, 0x51, 0x02, 0xba, 0x0c, 0x0b, 0xde, 0x90, 0x0c, 0x68, 0x42, 0xc7, 0xc9, 0x06, + 0x75, 0x20, 0xef, 0x93, 0x5d, 0xea, 0x4b, 0x3d, 0xc8, 0x9c, 0xbc, 0xf7, 0x46, 0x49, 0xad, 0x7e, + 0xad, 0xf0, 0x9d, 0x40, 0xf0, 0x43, 0xac, 0xc9, 0xc8, 0x86, 0x45, 0x87, 0x0d, 0x87, 0x24, 0x90, + 0xbd, 0x63, 0x7e, 0xa5, 0x88, 0xc7, 0x5b, 0x84, 0xc0, 0x24, 0x7c, 0x10, 0xd9, 0xa6, 0x32, 0xab, + 0x35, 0x2a, 0xc3, 0x3c, 0x0d, 0x46, 0xf6, 0x82, 0x32, 0xc9, 0xa5, 0xb4, 0xb8, 0x5e, 0x52, 0xd0, + 0x22, 0x96, 0x4b, 0xc9, 0x8b, 0x23, 0xca, 0xed, 0x45, 0x65, 0x52, 0x6b, 0xf4, 0x31, 0xe4, 0x87, + 0x2c, 0x0e, 0x44, 0x64, 0x17, 0x54, 0xb0, 0xd7, 0xb3, 0x82, 0xdd, 0x92, 0x08, 0xdd, 0xdb, 0x34, + 0x1c, 0x3d, 0x82, 0x4b, 0x91, 0x60, 0x61, 0x7f, 0xc0, 0x89, 0x43, 0xfb, 0x21, 0xe5, 0x1e, 0x73, + 0xed, 0xe2, 0xf9, 0x2d, 0xb2, 0xad, 0xc7, 0x37, 0xbe, 0x28, 0x69, 0x1b, 0x92, 0xd5, 0x53, 0x24, + 0xd4, 0x83, 0x52, 0x18, 0xfb, 0x7e, 0x9f, 0x85, 0x49, 0xa7, 0x06, 0xe5, 0xe4, 0x2d, 0xb2, 0xd6, + 0x8b, 0x7d, 0xff, 0x71, 0x42, 0xc2, 0x56, 0x38, 0xdd, 0xa0, 0xab, 0x90, 0x1f, 0x70, 0x16, 0x87, + 0x91, 0x6d, 0xa9, 0x7c, 0xe8, 0x5d, 0xe5, 0x01, 0x58, 0xa9, 0x4c, 0xcb, 0x0c, 0x1d, 0xd0, 0x43, + 0x5d, 0x3c, 0xb9, 0x94, 0x05, 0x1d, 0x11, 0x3f, 0x4e, 0xe6, 0x7f, 0x11, 0x27, 0x9b, 0x4f, 0xe6, + 0xee, 0x1b, 0x95, 0x06, 0x58, 0xa9, 0xe3, 0xd0, 0xbf, 0x61, 0x89, 0xd3, 0x81, 0x17, 0x09, 0x7e, + 0xd8, 0x27, 0xb1, 0xd8, 0xb7, 0xbf, 0x50, 0x84, 0xd2, 0xd8, 0xd8, 0x8c, 0xc5, 0x7e, 0xfd, 0x4f, + 0x03, 0x4a, 0xe9, 0x86, 0x86, 0x5a, 0x49, 0x1b, 0x53, 0x27, 0x5e, 0x68, 0xac, 0xbd, 0xa9, 0x01, + 0xaa, 0xa6, 0xe1, 0xc7, 0xf2, 0xc4, 0x2d, 0xf9, 0xe8, 0x50, 0x64, 0xf4, 0x11, 0x2c, 0x84, 0x8c, + 0x8b, 0xb1, 0xba, 0xaa, 0x99, 0x17, 0x9d, 0xf1, 0xf1, 0x25, 0x4b, 0xc0, 0xf5, 0x7d, 0xb8, 0x30, + 0xeb, 0x0d, 0xdd, 0x86, 0xf9, 0x67, 0xdd, 0x5e, 0x39, 0x57, 0xb9, 0x71, 0x74, 0x5c, 0xbb, 0x36, + 0xfb, 0xf1, 0x99, 0xc7, 0x45, 0x4c, 0xfc, 0x6e, 0x0f, 0xfd, 0x0f, 0x16, 0xda, 0xdb, 0x3b, 0x18, + 0x97, 0x8d, 0xca, 0xf2, 0xd1, 0x71, 0xed, 0xc6, 0x2c, 0x4e, 0x7e, 0x62, 0x71, 0xe0, 0x62, 0xb6, + 0x3b, 0x99, 0xc3, 0x3f, 0xcf, 0x81, 0xa5, 0x2f, 0xdd, 0xbb, 0x9d, 0xc3, 0x9f, 0xc3, 0x52, 0xd2, + 0xa4, 0xfa, 0x8e, 0xfa, 0x69, 0xba, 0xdd, 0xbe, 0xae, 0x57, 0x95, 0x12, 0x42, 0x92, 0x0a, 0x74, + 0x0b, 0x4a, 0x5e, 0x38, 0xba, 0xd7, 0xa7, 0x01, 0xd9, 0xf5, 0xf5, 0x48, 0x2e, 0x60, 0x4b, 0xda, + 0x3a, 0x89, 0x49, 0xce, 0x12, 0x2f, 0x10, 0x94, 0x07, 0x7a, 0xd8, 0x16, 0xf0, 0x64, 0x8f, 0x3e, + 0x03, 0xd3, 0x0b, 0xc9, 0x50, 0x37, 0xd8, 0xcc, 0x5f, 0xd0, 0xed, 0x35, 0xb7, 0xb4, 0x44, 0xd6, + 0x0b, 0x67, 0x27, 0xcb, 0xa6, 0x34, 0x60, 0x45, 0x43, 0xd5, 0x71, 0x8f, 0x93, 0x27, 0xa9, 0x6b, + 0x59, 0xc0, 0x29, 0x4b, 0xfd, 0x47, 0x13, 0xac, 0x96, 0x1f, 0x47, 0x42, 0x37, 0x97, 0x77, 0x96, + 0xb7, 0x6f, 0xe0, 0x12, 0x51, 0xaf, 0x36, 0x12, 0xc8, 0x9b, 0xaa, 0x66, 0x87, 0xce, 0xdd, 0xed, + 0x4c, 0x77, 0x13, 0x70, 0x32, 0x67, 0xd6, 0xf3, 0xd2, 0xa7, 0x6d, 0xe0, 0x32, 0xf9, 0xdb, 0x17, + 0xb4, 0x03, 0x4b, 0x8c, 0x3b, 0xfb, 0x34, 0x12, 0xc9, 0xe5, 0xd6, 0xaf, 0x9c, 0xcc, 0xf7, 0xef, + 0xe3, 0x34, 0x50, 0xbf, 0x11, 0x92, 0x68, 0x67, 0x7d, 0xa0, 0xfb, 0x60, 0x72, 0xb2, 0x37, 0x9e, + 0x83, 0x99, 0xfa, 0xc6, 0x64, 0x4f, 0xcc, 0xb8, 0x50, 0x0c, 0xf4, 0x15, 0x80, 0xeb, 0x45, 0x21, + 0x11, 0xce, 0x3e, 0xe5, 0xba, 0x4e, 0x99, 0x3f, 0xb1, 0x3d, 0x41, 0xcd, 0x78, 0x49, 0xb1, 0xd1, + 0x26, 0x14, 0x1d, 0x32, 0x56, 0x5a, 0xfe, 0xfc, 0xbe, 0xd6, 0x6a, 0x6a, 0x17, 0x65, 0xe9, 0xe2, + 0xec, 0x64, 0xb9, 0x30, 0xb6, 0xe0, 0x82, 0x43, 0xb4, 0xf2, 0x36, 0x61, 0x49, 0x3e, 0x09, 0xfb, + 0x2e, 0xdd, 0x23, 0xb1, 0x2f, 0x22, 0xd5, 0x82, 0xcf, 0x79, 0x02, 0xc9, 0xd7, 0x49, 0x5b, 0xe3, + 0x74, 0x5c, 0x25, 0x91, 0xb6, 0xdd, 0x7c, 0x79, 0x5a, 0xcd, 0xfd, 0x7a, 0x5a, 0xcd, 0xfd, 0x71, + 0x5a, 0x35, 0xbe, 0x3b, 0xab, 0x1a, 0x2f, 0xcf, 0xaa, 0xc6, 0x2f, 0x67, 0x55, 0xe3, 0xb7, 0xb3, + 0xaa, 0xb1, 0x9b, 0x57, 0x7f, 0x8f, 0x3e, 0xfc, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x70, 0x4c, 0x36, + 0xfc, 0x7d, 0x0d, 0x00, 0x00, } diff --git a/api/specs.proto b/api/specs.proto index 25288ce6ec..a59b2a8b0f 100644 --- a/api/specs.proto +++ b/api/specs.proto @@ -188,10 +188,6 @@ message ContainerSpec { // PullOptions parameterize the behavior of image pulls. PullOptions pull_options = 10; - - // SecretReference contains references to zero or more secrets that - // will be exposed to the container. - repeated SecretReference secrets = 12; } // EndpointSpec defines the properties that can be configured to @@ -274,18 +270,4 @@ message ClusterSpec { // TaskDefaults specifies the default values to use for task creation. TaskDefaults task_defaults = 7 [(gogoproto.nullable) = false]; -} - -// SecretSpec specifies a user-provided secret. -message SecretSpec { - Annotations annotations = 1 [(gogoproto.nullable) = false]; - - // Type distinguishes the different kinds of secrets in the system. - SecretType type = 2; - - // Tags group secrets. - repeated string tags = 3; - - // Secret payload. - bytes data = 4; -} +} \ No newline at end of file diff --git a/api/types.pb.go b/api/types.pb.go index 90d0e49bf6..60d2a04441 100644 --- a/api/types.pb.go +++ b/api/types.pb.go @@ -56,7 +56,6 @@ Certificate EncryptionKey ManagerStatus - SecretReference NodeSpec ServiceSpec ReplicatedService @@ -67,7 +66,6 @@ EndpointSpec NetworkSpec ClusterSpec - SecretSpec Meta Node Service @@ -76,7 +74,6 @@ NetworkAttachment Network Cluster - Secret GetNodeRequest GetNodeResponse ListNodesRequest @@ -260,28 +257,6 @@ func (x NodeRole) String() string { } func (NodeRole) EnumDescriptor() ([]byte, []int) { return fileDescriptorTypes, []int{1} } -// SecretType provides information about what kind of secret this is -type SecretType int32 - -const ( - SecretType_ContainerSecret SecretType = 0 - SecretType_NodeSecret SecretType = 1 -) - -var SecretType_name = map[int32]string{ - 0: "CONTAINER", - 1: "NODE", -} -var SecretType_value = map[string]int32{ - "CONTAINER": 0, - "NODE": 1, -} - -func (x SecretType) String() string { - return proto.EnumName(SecretType_name, int32(x)) -} -func (SecretType) EnumDescriptor() ([]byte, []int) { return fileDescriptorTypes, []int{2} } - type RaftMemberStatus_Reachability int32 const ( @@ -602,28 +577,6 @@ func (EncryptionKey_Algorithm) EnumDescriptor() ([]byte, []int) { return fileDescriptorTypes, []int{36, 0} } -// Mode specifies how this secret should be exposed inside the task. -type SecretReference_Mode int32 - -const ( - SecretReference_FILE SecretReference_Mode = 0 - SecretReference_ENV SecretReference_Mode = 1 -) - -var SecretReference_Mode_name = map[int32]string{ - 0: "FILE", - 1: "ENV", -} -var SecretReference_Mode_value = map[string]int32{ - "FILE": 0, - "ENV": 1, -} - -func (x SecretReference_Mode) String() string { - return proto.EnumName(SecretReference_Mode_name, int32(x)) -} -func (SecretReference_Mode) EnumDescriptor() ([]byte, []int) { return fileDescriptorTypes, []int{38, 0} } - // Version tracks the last time an object in the store was updated. type Version struct { Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` @@ -1336,20 +1289,6 @@ func (m *ManagerStatus) Reset() { *m = ManagerStatus{} } func (*ManagerStatus) ProtoMessage() {} func (*ManagerStatus) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{37} } -// SecretReference is the linkage between a service and a secret that it uses. -type SecretReference struct { - // Name is the name of the secret that this reference. - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // Mode is one or more ways the secret should be presented. - Mode []SecretReference_Mode `protobuf:"varint,2,rep,name=mode,enum=docker.swarmkit.v1.SecretReference_Mode" json:"mode,omitempty"` - // Target is the name by which the image accesses the secret. - Target string `protobuf:"bytes,3,opt,name=target,proto3" json:"target,omitempty"` -} - -func (m *SecretReference) Reset() { *m = SecretReference{} } -func (*SecretReference) ProtoMessage() {} -func (*SecretReference) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{38} } - func init() { proto.RegisterType((*Version)(nil), "docker.swarmkit.v1.Version") proto.RegisterType((*Annotations)(nil), "docker.swarmkit.v1.Annotations") @@ -1394,10 +1333,8 @@ func init() { proto.RegisterType((*Certificate)(nil), "docker.swarmkit.v1.Certificate") proto.RegisterType((*EncryptionKey)(nil), "docker.swarmkit.v1.EncryptionKey") proto.RegisterType((*ManagerStatus)(nil), "docker.swarmkit.v1.ManagerStatus") - proto.RegisterType((*SecretReference)(nil), "docker.swarmkit.v1.SecretReference") proto.RegisterEnum("docker.swarmkit.v1.TaskState", TaskState_name, TaskState_value) proto.RegisterEnum("docker.swarmkit.v1.NodeRole", NodeRole_name, NodeRole_value) - proto.RegisterEnum("docker.swarmkit.v1.SecretType", SecretType_name, SecretType_value) proto.RegisterEnum("docker.swarmkit.v1.RaftMemberStatus_Reachability", RaftMemberStatus_Reachability_name, RaftMemberStatus_Reachability_value) proto.RegisterEnum("docker.swarmkit.v1.NodeStatus_State", NodeStatus_State_name, NodeStatus_State_value) proto.RegisterEnum("docker.swarmkit.v1.Mount_MountType", Mount_MountType_name, Mount_MountType_value) @@ -1410,7 +1347,6 @@ func init() { proto.RegisterEnum("docker.swarmkit.v1.IssuanceStatus_State", IssuanceStatus_State_name, IssuanceStatus_State_value) proto.RegisterEnum("docker.swarmkit.v1.ExternalCA_CAProtocol", ExternalCA_CAProtocol_name, ExternalCA_CAProtocol_value) proto.RegisterEnum("docker.swarmkit.v1.EncryptionKey_Algorithm", EncryptionKey_Algorithm_name, EncryptionKey_Algorithm_value) - proto.RegisterEnum("docker.swarmkit.v1.SecretReference_Mode", SecretReference_Mode_name, SecretReference_Mode_value) } func (m *Version) Copy() *Version { @@ -2087,26 +2023,6 @@ func (m *ManagerStatus) Copy() *ManagerStatus { return o } -func (m *SecretReference) Copy() *SecretReference { - if m == nil { - return nil - } - - o := &SecretReference{ - Name: m.Name, - Target: m.Target, - } - - if m.Mode != nil { - o.Mode = make([]SecretReference_Mode, 0, len(m.Mode)) - for _, v := range m.Mode { - o.Mode = append(o.Mode, v) - } - } - - return o -} - func (this *Version) GoString() string { if this == nil { return "nil" @@ -2741,18 +2657,6 @@ func (this *ManagerStatus) GoString() string { s = append(s, "}") return strings.Join(s, "") } -func (this *SecretReference) GoString() string { - if this == nil { - return "nil" - } - s := make([]string, 0, 7) - s = append(s, "&api.SecretReference{") - s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") - s = append(s, "Mode: "+fmt.Sprintf("%#v", this.Mode)+",\n") - s = append(s, "Target: "+fmt.Sprintf("%#v", this.Target)+",\n") - s = append(s, "}") - return strings.Join(s, "") -} func valueToGoStringTypes(v interface{}, typ string) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -4456,43 +4360,6 @@ func (m *ManagerStatus) MarshalTo(data []byte) (int, error) { return i, nil } -func (m *SecretReference) Marshal() (data []byte, err error) { - size := m.Size() - data = make([]byte, size) - n, err := m.MarshalTo(data) - if err != nil { - return nil, err - } - return data[:n], nil -} - -func (m *SecretReference) MarshalTo(data []byte) (int, error) { - var i int - _ = i - var l int - _ = l - if len(m.Name) > 0 { - data[i] = 0xa - i++ - i = encodeVarintTypes(data, i, uint64(len(m.Name))) - i += copy(data[i:], m.Name) - } - if len(m.Mode) > 0 { - for _, num := range m.Mode { - data[i] = 0x10 - i++ - i = encodeVarintTypes(data, i, uint64(num)) - } - } - if len(m.Target) > 0 { - data[i] = 0x1a - i++ - i = encodeVarintTypes(data, i, uint64(len(m.Target))) - i += copy(data[i:], m.Target) - } - return i, nil -} - func encodeFixed64Types(data []byte, offset int, v uint64) int { data[offset] = uint8(v) data[offset+1] = uint8(v >> 8) @@ -5246,25 +5113,6 @@ func (m *ManagerStatus) Size() (n int) { return n } -func (m *SecretReference) Size() (n int) { - var l int - _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) - } - if len(m.Mode) > 0 { - for _, e := range m.Mode { - n += 1 + sovTypes(uint64(e)) - } - } - l = len(m.Target) - if l > 0 { - n += 1 + l + sovTypes(uint64(l)) - } - return n -} - func sovTypes(x uint64) (n int) { for { n++ @@ -5852,18 +5700,6 @@ func (this *ManagerStatus) String() string { }, "") return s } -func (this *SecretReference) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&SecretReference{`, - `Name:` + fmt.Sprintf("%v", this.Name) + `,`, - `Mode:` + fmt.Sprintf("%v", this.Mode) + `,`, - `Target:` + fmt.Sprintf("%v", this.Target) + `,`, - `}`, - }, "") - return s -} func valueToStringTypes(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -11608,134 +11444,6 @@ func (m *ManagerStatus) Unmarshal(data []byte) error { } return nil } -func (m *SecretReference) Unmarshal(data []byte) error { - l := len(data) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: SecretReference: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SecretReference: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Name = string(data[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) - } - var v SecretReference_Mode - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - v |= (SecretReference_Mode(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - m.Mode = append(m.Mode, v) - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTypes - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := data[iNdEx] - iNdEx++ - stringLen |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthTypes - } - postIndex := iNdEx + intStringLen - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Target = string(data[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTypes(data[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthTypes - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func skipTypes(data []byte) (n int, err error) { l := len(data) iNdEx := 0 @@ -11842,227 +11550,221 @@ var ( ) var fileDescriptorTypes = []byte{ - // 3537 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x59, 0x4d, 0x6c, 0x23, 0x47, - 0x76, 0x56, 0xf3, 0x4f, 0xe4, 0x23, 0xa5, 0xe9, 0x29, 0xcf, 0x8e, 0x35, 0xf4, 0x58, 0xa2, 0x7b, - 0x3c, 0xeb, 0x59, 0xaf, 0x43, 0xdb, 0xf2, 0x26, 0x98, 0xf5, 0x6c, 0xd6, 0x6e, 0x91, 0xad, 0x19, - 0x7a, 0x24, 0x8a, 0x28, 0x92, 0x1a, 0x18, 0x01, 0x42, 0x94, 0xba, 0x4b, 0x54, 0x5b, 0xcd, 0x6e, - 0xa6, 0xbb, 0x28, 0x0d, 0x13, 0x04, 0x98, 0xe4, 0x92, 0x40, 0xa7, 0x9c, 0x72, 0x09, 0x84, 0x45, - 0x90, 0x20, 0xb7, 0x1c, 0x72, 0x0a, 0x90, 0xd3, 0x1c, 0x7d, 0xdc, 0x20, 0x40, 0xb0, 0x48, 0x00, - 0x21, 0x56, 0x8e, 0xb9, 0x2c, 0x90, 0xc3, 0x1e, 0x92, 0x43, 0x50, 0x3f, 0xdd, 0xfc, 0x19, 0x4a, - 0x1e, 0x67, 0xf7, 0xc4, 0xae, 0x57, 0xdf, 0x7b, 0xf5, 0xaa, 0xea, 0xd5, 0xab, 0xaf, 0x1e, 0xa1, - 0xc8, 0xc6, 0x43, 0x1a, 0x55, 0x87, 0x61, 0xc0, 0x02, 0x84, 0x9c, 0xc0, 0x3e, 0xa6, 0x61, 0x35, - 0x3a, 0x25, 0xe1, 0xe0, 0xd8, 0x65, 0xd5, 0x93, 0x8f, 0xcb, 0x77, 0x98, 0x3b, 0xa0, 0x11, 0x23, - 0x83, 0xe1, 0x87, 0xc9, 0x97, 0x84, 0x97, 0xdf, 0x74, 0x46, 0x21, 0x61, 0x6e, 0xe0, 0x7f, 0x18, - 0x7f, 0xa8, 0x8e, 0x5b, 0xfd, 0xa0, 0x1f, 0x88, 0xcf, 0x0f, 0xf9, 0x97, 0x94, 0x1a, 0x1b, 0xb0, - 0xbc, 0x4f, 0xc3, 0xc8, 0x0d, 0x7c, 0x74, 0x0b, 0xb2, 0xae, 0xef, 0xd0, 0xe7, 0x6b, 0x5a, 0x45, - 0x7b, 0x90, 0xc1, 0xb2, 0x61, 0xfc, 0xb5, 0x06, 0x45, 0xd3, 0xf7, 0x03, 0x26, 0x6c, 0x45, 0x08, - 0x41, 0xc6, 0x27, 0x03, 0x2a, 0x40, 0x05, 0x2c, 0xbe, 0x51, 0x0d, 0x72, 0x1e, 0x39, 0xa0, 0x5e, - 0xb4, 0x96, 0xaa, 0xa4, 0x1f, 0x14, 0x37, 0x7f, 0x58, 0x7d, 0xd5, 0xe7, 0xea, 0x94, 0x91, 0xea, - 0x8e, 0x40, 0x5b, 0x3e, 0x0b, 0xc7, 0x58, 0xa9, 0x96, 0x7f, 0x0c, 0xc5, 0x29, 0x31, 0xd2, 0x21, - 0x7d, 0x4c, 0xc7, 0x6a, 0x18, 0xfe, 0xc9, 0xfd, 0x3b, 0x21, 0xde, 0x88, 0xae, 0xa5, 0x84, 0x4c, - 0x36, 0x3e, 0x4d, 0x3d, 0xd4, 0x8c, 0x2f, 0xa1, 0x80, 0x69, 0x14, 0x8c, 0x42, 0x9b, 0x46, 0xe8, - 0x07, 0x50, 0xf0, 0x89, 0x1f, 0xf4, 0xec, 0xe1, 0x28, 0x12, 0xea, 0xe9, 0xad, 0xd2, 0xe5, 0xc5, - 0x46, 0xbe, 0x49, 0xfc, 0xa0, 0xd6, 0xea, 0x46, 0x38, 0xcf, 0xbb, 0x6b, 0xc3, 0x51, 0x84, 0xde, - 0x81, 0xd2, 0x80, 0x0e, 0x82, 0x70, 0xdc, 0x3b, 0x18, 0x33, 0x1a, 0x09, 0xc3, 0x69, 0x5c, 0x94, - 0xb2, 0x2d, 0x2e, 0x32, 0xfe, 0x42, 0x83, 0x5b, 0xb1, 0x6d, 0x4c, 0xff, 0x60, 0xe4, 0x86, 0x74, - 0x40, 0x7d, 0x16, 0xa1, 0xdf, 0x86, 0x9c, 0xe7, 0x0e, 0x5c, 0x26, 0xc7, 0x28, 0x6e, 0xbe, 0xbd, - 0x68, 0xce, 0x89, 0x57, 0x58, 0x81, 0x91, 0x09, 0xa5, 0x90, 0x46, 0x34, 0x3c, 0x91, 0x2b, 0x21, - 0x86, 0xfc, 0x56, 0xe5, 0x19, 0x15, 0x63, 0x1b, 0xf2, 0x2d, 0x8f, 0xb0, 0xc3, 0x20, 0x1c, 0x20, - 0x03, 0x4a, 0x24, 0xb4, 0x8f, 0x5c, 0x46, 0x6d, 0x36, 0x0a, 0xe3, 0x5d, 0x99, 0x91, 0xa1, 0xdb, - 0x90, 0x0a, 0xe4, 0x40, 0x85, 0xad, 0xdc, 0xe5, 0xc5, 0x46, 0x6a, 0xaf, 0x8d, 0x53, 0x41, 0x64, - 0x3c, 0x82, 0x9b, 0x2d, 0x6f, 0xd4, 0x77, 0xfd, 0x3a, 0x8d, 0xec, 0xd0, 0x1d, 0x72, 0xeb, 0x7c, - 0x7b, 0x79, 0xf0, 0xc5, 0xdb, 0xcb, 0xbf, 0x93, 0x2d, 0x4f, 0x4d, 0xb6, 0xdc, 0xf8, 0xb3, 0x14, - 0xdc, 0xb4, 0xfc, 0xbe, 0xeb, 0xd3, 0x69, 0xed, 0xfb, 0xb0, 0x4a, 0x85, 0xb0, 0x77, 0x22, 0x83, - 0x4a, 0xd9, 0x59, 0x91, 0xd2, 0x38, 0xd2, 0x1a, 0x73, 0xf1, 0xf2, 0xf1, 0xa2, 0xe9, 0xbf, 0x62, - 0x7d, 0x51, 0xd4, 0x20, 0x0b, 0x96, 0x87, 0x62, 0x12, 0xd1, 0x5a, 0x5a, 0xd8, 0xba, 0xbf, 0xc8, - 0xd6, 0x2b, 0xf3, 0xdc, 0xca, 0x7c, 0x7d, 0xb1, 0xb1, 0x84, 0x63, 0xdd, 0x5f, 0x27, 0xf8, 0xfe, - 0x53, 0x83, 0x1b, 0xcd, 0xc0, 0x99, 0x59, 0x87, 0x32, 0xe4, 0x8f, 0x82, 0x88, 0x4d, 0x1d, 0x94, - 0xa4, 0x8d, 0x1e, 0x42, 0x7e, 0xa8, 0xb6, 0x4f, 0xed, 0xfe, 0xdd, 0xc5, 0x2e, 0x4b, 0x0c, 0x4e, - 0xd0, 0xe8, 0x11, 0x14, 0xc2, 0x38, 0x26, 0xd6, 0xd2, 0xaf, 0x13, 0x38, 0x13, 0x3c, 0xfa, 0x5d, - 0xc8, 0xc9, 0x4d, 0x58, 0xcb, 0x08, 0xcd, 0xfb, 0xaf, 0xb5, 0xe6, 0x58, 0x29, 0x19, 0xbf, 0xd0, - 0x40, 0xc7, 0xe4, 0x90, 0xed, 0xd2, 0xc1, 0x01, 0x0d, 0xdb, 0x8c, 0xb0, 0x51, 0x84, 0x6e, 0x43, - 0xce, 0xa3, 0xc4, 0xa1, 0xa1, 0x98, 0x64, 0x1e, 0xab, 0x16, 0xea, 0xf2, 0x20, 0x27, 0xf6, 0x11, - 0x39, 0x70, 0x3d, 0x97, 0x8d, 0xc5, 0x34, 0x57, 0x17, 0xef, 0xf2, 0xbc, 0xcd, 0x2a, 0x9e, 0x52, - 0xc4, 0x33, 0x66, 0xd0, 0x1a, 0x2c, 0x0f, 0x68, 0x14, 0x91, 0x3e, 0x15, 0xb3, 0x2f, 0xe0, 0xb8, - 0x69, 0x3c, 0x82, 0xd2, 0xb4, 0x1e, 0x2a, 0xc2, 0x72, 0xb7, 0xf9, 0xb4, 0xb9, 0xf7, 0xac, 0xa9, - 0x2f, 0xa1, 0x1b, 0x50, 0xec, 0x36, 0xb1, 0x65, 0xd6, 0x9e, 0x98, 0x5b, 0x3b, 0x96, 0xae, 0xa1, - 0x15, 0x28, 0x4c, 0x9a, 0x29, 0xe3, 0x67, 0x1a, 0x00, 0xdf, 0x40, 0x35, 0xa9, 0x4f, 0x21, 0x1b, - 0x31, 0xc2, 0xe4, 0xc6, 0xad, 0x6e, 0xbe, 0xbb, 0xc8, 0xeb, 0x09, 0xbc, 0xca, 0x7f, 0x28, 0x96, - 0x2a, 0xd3, 0x1e, 0xa6, 0xe6, 0x3d, 0xcc, 0x0a, 0xe4, 0xac, 0x6b, 0x79, 0xc8, 0xd4, 0xf9, 0x97, - 0x86, 0x0a, 0x90, 0xc5, 0x96, 0x59, 0xff, 0x52, 0x4f, 0x21, 0x1d, 0x4a, 0xf5, 0x46, 0xbb, 0xb6, - 0xd7, 0x6c, 0x5a, 0xb5, 0x8e, 0x55, 0xd7, 0xd3, 0xc6, 0x7d, 0xc8, 0x36, 0x06, 0xa4, 0x4f, 0xd1, - 0x5d, 0x1e, 0x01, 0x87, 0x34, 0xa4, 0xbe, 0x1d, 0x07, 0xd6, 0x44, 0x60, 0xfc, 0xbc, 0x00, 0xd9, - 0xdd, 0x60, 0xe4, 0x33, 0xb4, 0x39, 0x75, 0x8a, 0x57, 0x37, 0xd7, 0x17, 0x4d, 0x41, 0x00, 0xab, - 0x9d, 0xf1, 0x90, 0xaa, 0x53, 0x7e, 0x1b, 0x72, 0x32, 0x56, 0x94, 0xeb, 0xaa, 0xc5, 0xe5, 0x8c, - 0x84, 0x7d, 0xca, 0xd4, 0xa2, 0xab, 0x16, 0x7a, 0x00, 0xf9, 0x90, 0x12, 0x27, 0xf0, 0xbd, 0xb1, - 0x08, 0xa9, 0xbc, 0x4c, 0xb3, 0x98, 0x12, 0x67, 0xcf, 0xf7, 0xc6, 0x38, 0xe9, 0x45, 0x4f, 0xa0, - 0x74, 0xe0, 0xfa, 0x4e, 0x2f, 0x18, 0xca, 0x9c, 0x97, 0xbd, 0x3a, 0x00, 0xa5, 0x57, 0x5b, 0xae, - 0xef, 0xec, 0x49, 0x30, 0x2e, 0x1e, 0x4c, 0x1a, 0xa8, 0x09, 0xab, 0x27, 0x81, 0x37, 0x1a, 0xd0, - 0xc4, 0x56, 0x4e, 0xd8, 0x7a, 0xef, 0x6a, 0x5b, 0xfb, 0x02, 0x1f, 0x5b, 0x5b, 0x39, 0x99, 0x6e, - 0xa2, 0xa7, 0xb0, 0xc2, 0x06, 0xc3, 0xc3, 0x28, 0x31, 0xb7, 0x2c, 0xcc, 0x7d, 0xff, 0x9a, 0x05, - 0xe3, 0xf0, 0xd8, 0x5a, 0x89, 0x4d, 0xb5, 0xca, 0x7f, 0x9a, 0x86, 0xe2, 0x94, 0xe7, 0xa8, 0x0d, - 0xc5, 0x61, 0x18, 0x0c, 0x49, 0x5f, 0xe4, 0x6d, 0xb5, 0x17, 0x1f, 0xbf, 0xd6, 0xac, 0xab, 0xad, - 0x89, 0x22, 0x9e, 0xb6, 0x62, 0x9c, 0xa7, 0xa0, 0x38, 0xd5, 0x89, 0xde, 0x87, 0x3c, 0x6e, 0xe1, - 0xc6, 0xbe, 0xd9, 0xb1, 0xf4, 0xa5, 0xf2, 0xdd, 0xb3, 0xf3, 0xca, 0x9a, 0xb0, 0x36, 0x6d, 0xa0, - 0x15, 0xba, 0x27, 0x3c, 0xf4, 0x1e, 0xc0, 0x72, 0x0c, 0xd5, 0xca, 0x6f, 0x9d, 0x9d, 0x57, 0xde, - 0x9c, 0x87, 0x4e, 0x21, 0x71, 0xfb, 0x89, 0x89, 0xad, 0xba, 0x9e, 0x5a, 0x8c, 0xc4, 0xed, 0x23, - 0x12, 0x52, 0x07, 0x7d, 0x1f, 0x72, 0x0a, 0x98, 0x2e, 0x97, 0xcf, 0xce, 0x2b, 0xb7, 0xe7, 0x81, - 0x13, 0x1c, 0x6e, 0xef, 0x98, 0xfb, 0x96, 0x9e, 0x59, 0x8c, 0xc3, 0x6d, 0x8f, 0x9c, 0x50, 0xf4, - 0x2e, 0x64, 0x25, 0x2c, 0x5b, 0xbe, 0x73, 0x76, 0x5e, 0xf9, 0xde, 0x2b, 0xe6, 0x38, 0xaa, 0xbc, - 0xf6, 0xe7, 0x7f, 0xb3, 0xbe, 0xf4, 0x4f, 0x7f, 0xbb, 0xae, 0xcf, 0x77, 0x97, 0xff, 0x57, 0x83, - 0x95, 0x99, 0x2d, 0x47, 0x06, 0xe4, 0xfc, 0xc0, 0x0e, 0x86, 0x32, 0x9d, 0xe7, 0xb7, 0xe0, 0xf2, - 0x62, 0x23, 0xd7, 0x0c, 0x6a, 0xc1, 0x70, 0x8c, 0x55, 0x0f, 0x7a, 0x3a, 0x77, 0x21, 0x7d, 0xf2, - 0x9a, 0xf1, 0xb4, 0xf0, 0x4a, 0xfa, 0x0c, 0x56, 0x9c, 0xd0, 0x3d, 0xa1, 0x61, 0xcf, 0x0e, 0xfc, - 0x43, 0xb7, 0xaf, 0x52, 0x75, 0x79, 0x91, 0xcd, 0xba, 0x00, 0xe2, 0x92, 0x54, 0xa8, 0x09, 0xfc, - 0xaf, 0x71, 0x19, 0x95, 0xf7, 0xa1, 0x34, 0x1d, 0xa1, 0xe8, 0x6d, 0x80, 0xc8, 0xfd, 0x43, 0xaa, - 0xf8, 0x8d, 0x60, 0x43, 0xb8, 0xc0, 0x25, 0x82, 0xdd, 0xa0, 0xf7, 0x20, 0x33, 0x08, 0x1c, 0x69, - 0x27, 0xbb, 0xf5, 0x06, 0xbf, 0x13, 0xff, 0xed, 0x62, 0xa3, 0x18, 0x44, 0xd5, 0x6d, 0xd7, 0xa3, - 0xbb, 0x81, 0x43, 0xb1, 0x00, 0x18, 0x27, 0x90, 0xe1, 0xa9, 0x02, 0xbd, 0x05, 0x99, 0xad, 0x46, - 0xb3, 0xae, 0x2f, 0x95, 0x6f, 0x9e, 0x9d, 0x57, 0x56, 0xc4, 0x92, 0xf0, 0x0e, 0x1e, 0xbb, 0x68, - 0x03, 0x72, 0xfb, 0x7b, 0x3b, 0xdd, 0x5d, 0x1e, 0x5e, 0x6f, 0x9c, 0x9d, 0x57, 0x6e, 0x24, 0xdd, - 0x72, 0xd1, 0xd0, 0xdb, 0x90, 0xed, 0xec, 0xb6, 0xb6, 0xdb, 0x7a, 0xaa, 0x8c, 0xce, 0xce, 0x2b, - 0xab, 0x49, 0xbf, 0xf0, 0xb9, 0x7c, 0x53, 0xed, 0x6a, 0x21, 0x91, 0x1b, 0xff, 0x93, 0x82, 0x15, - 0xcc, 0xf9, 0x6d, 0xc8, 0x5a, 0x81, 0xe7, 0xda, 0x63, 0xd4, 0x82, 0x82, 0x1d, 0xf8, 0x8e, 0x3b, - 0x75, 0xa6, 0x36, 0xaf, 0xb8, 0x04, 0x27, 0x5a, 0x71, 0xab, 0x16, 0x6b, 0xe2, 0x89, 0x11, 0xb4, - 0x09, 0x59, 0x87, 0x7a, 0x64, 0x7c, 0xdd, 0x6d, 0x5c, 0x57, 0x5c, 0x1a, 0x4b, 0xa8, 0x60, 0x8e, - 0xe4, 0x79, 0x8f, 0x30, 0x46, 0x07, 0x43, 0x26, 0x6f, 0xe3, 0x0c, 0x2e, 0x0e, 0xc8, 0x73, 0x53, - 0x89, 0xd0, 0x8f, 0x20, 0x77, 0xea, 0xfa, 0x4e, 0x70, 0xaa, 0x2e, 0xdc, 0xeb, 0xed, 0x2a, 0xac, - 0x71, 0xc6, 0xef, 0xd9, 0x39, 0x67, 0xf9, 0xaa, 0x37, 0xf7, 0x9a, 0x56, 0xbc, 0xea, 0xaa, 0x7f, - 0xcf, 0x6f, 0x06, 0x3e, 0x3f, 0x31, 0xb0, 0xd7, 0xec, 0x6d, 0x9b, 0x8d, 0x9d, 0x2e, 0xe6, 0x2b, - 0x7f, 0xeb, 0xec, 0xbc, 0xa2, 0x27, 0x90, 0x6d, 0xe2, 0x7a, 0x9c, 0x04, 0xde, 0x81, 0xb4, 0xd9, - 0xfc, 0x52, 0x4f, 0x95, 0xf5, 0xb3, 0xf3, 0x4a, 0x29, 0xe9, 0x36, 0xfd, 0xf1, 0xe4, 0x30, 0xcd, - 0x8f, 0x6b, 0xfc, 0x97, 0x06, 0xa5, 0xee, 0xd0, 0x21, 0x8c, 0xca, 0xc8, 0x44, 0x15, 0x28, 0x0e, - 0x49, 0x48, 0x3c, 0x8f, 0x7a, 0x6e, 0x34, 0x50, 0x0f, 0x85, 0x69, 0x11, 0x7a, 0xf8, 0x1d, 0x16, - 0x53, 0x91, 0x30, 0xb5, 0xa4, 0x5d, 0x58, 0x3d, 0x94, 0xce, 0xf6, 0x88, 0x2d, 0x76, 0x37, 0x2d, - 0x76, 0xb7, 0xba, 0xc8, 0xc4, 0xb4, 0x57, 0x55, 0x35, 0x47, 0x53, 0x68, 0xe1, 0x95, 0xc3, 0xe9, - 0xa6, 0xf1, 0x00, 0x56, 0x66, 0xfa, 0xf9, 0x4d, 0xdb, 0x32, 0xbb, 0x6d, 0x4b, 0x5f, 0x42, 0x25, - 0xc8, 0xd7, 0xf6, 0x9a, 0x9d, 0x46, 0xb3, 0x6b, 0xe9, 0x9a, 0xf1, 0x0f, 0xa9, 0x78, 0xb6, 0x8a, - 0x09, 0x6c, 0xcd, 0x32, 0x81, 0x0f, 0xae, 0x76, 0x44, 0x71, 0x81, 0x49, 0x23, 0x61, 0x04, 0x3f, - 0x01, 0x10, 0x8b, 0x4a, 0x9d, 0x1e, 0x61, 0xd7, 0xb1, 0xfd, 0x4e, 0xfc, 0x8e, 0xc3, 0x05, 0xa5, - 0x60, 0x32, 0xf4, 0x39, 0x94, 0xec, 0x60, 0x30, 0xf4, 0xa8, 0xd2, 0x4f, 0xbf, 0x8e, 0x7e, 0x31, - 0x51, 0x31, 0xd9, 0x34, 0x23, 0xc9, 0xcc, 0x32, 0x92, 0x1a, 0x14, 0xa7, 0xfc, 0x9d, 0xe5, 0x25, - 0x25, 0xc8, 0x77, 0x5b, 0x75, 0xb3, 0xd3, 0x68, 0x3e, 0xd6, 0x35, 0x04, 0x90, 0x13, 0x2b, 0x56, - 0xd7, 0x53, 0x9c, 0x3b, 0xd5, 0xf6, 0x76, 0x5b, 0x3b, 0x96, 0x64, 0x26, 0x7f, 0x0c, 0x37, 0x6a, - 0x81, 0xcf, 0x88, 0xeb, 0x27, 0xa4, 0x70, 0x93, 0xfb, 0xac, 0x44, 0x3d, 0xd7, 0x91, 0x79, 0x6b, - 0xeb, 0xc6, 0xe5, 0xc5, 0x46, 0x31, 0x81, 0x36, 0xea, 0xdc, 0xcb, 0xb8, 0xe1, 0xf0, 0xe8, 0x1c, - 0xba, 0x8e, 0x4a, 0x43, 0xcb, 0x97, 0x17, 0x1b, 0xe9, 0x56, 0xa3, 0x8e, 0xb9, 0x0c, 0xbd, 0x05, - 0x05, 0xfa, 0xdc, 0x65, 0x3d, 0x9b, 0xe7, 0x29, 0x3e, 0xff, 0x2c, 0xce, 0x73, 0x41, 0x8d, 0xa7, - 0xa5, 0x3f, 0x49, 0x01, 0x74, 0x48, 0x74, 0xac, 0x86, 0x7e, 0x04, 0x85, 0xe4, 0x39, 0x7c, 0xdd, - 0xb3, 0x6c, 0x6a, 0xad, 0x13, 0x3c, 0xfa, 0x24, 0xde, 0x6d, 0xc9, 0x56, 0x17, 0x2b, 0xaa, 0xb1, - 0x16, 0x11, 0xbe, 0x59, 0x4a, 0xca, 0xb3, 0x36, 0x0d, 0x43, 0xb5, 0xe8, 0xfc, 0x13, 0xd5, 0x44, - 0xe6, 0x92, 0x73, 0x56, 0x1c, 0xe8, 0xde, 0xa2, 0x41, 0xe6, 0x16, 0xf4, 0xc9, 0x12, 0x9e, 0xe8, - 0x6d, 0xe9, 0xb0, 0x1a, 0x8e, 0x7c, 0xee, 0x75, 0x2f, 0x12, 0xdd, 0x86, 0x0b, 0x6f, 0x36, 0x29, - 0x3b, 0x0d, 0xc2, 0x63, 0x93, 0x31, 0x62, 0x1f, 0xf1, 0xe7, 0xa9, 0x3a, 0xae, 0x13, 0xea, 0xa6, - 0xcd, 0x50, 0xb7, 0x35, 0x58, 0x26, 0x9e, 0x4b, 0x22, 0x2a, 0xef, 0xbb, 0x02, 0x8e, 0x9b, 0x9c, - 0x60, 0x12, 0xc7, 0x09, 0x69, 0x14, 0x51, 0xf9, 0xa0, 0x2a, 0xe0, 0x89, 0xc0, 0xf8, 0x97, 0x14, - 0x40, 0xa3, 0x65, 0xee, 0x2a, 0xf3, 0x75, 0xc8, 0x1d, 0x92, 0x81, 0xeb, 0x8d, 0xaf, 0x3b, 0x20, - 0x13, 0x7c, 0xd5, 0x94, 0x86, 0xb6, 0x85, 0x0e, 0x56, 0xba, 0x82, 0x77, 0x8e, 0x0e, 0x7c, 0xca, - 0x12, 0xde, 0x29, 0x5a, 0xfc, 0x92, 0x0b, 0x89, 0x9f, 0x2c, 0xac, 0x6c, 0x70, 0xd7, 0xfb, 0x84, - 0xd1, 0x53, 0x32, 0x8e, 0xe3, 0x59, 0x35, 0xd1, 0x13, 0xce, 0x47, 0xf9, 0x33, 0x99, 0x3a, 0x6b, - 0x59, 0x71, 0x8b, 0x7f, 0x9b, 0x3f, 0x58, 0xc1, 0xe5, 0xf5, 0x9d, 0x68, 0x97, 0x1f, 0x89, 0x3b, - 0x67, 0xd2, 0xf5, 0x9d, 0x9e, 0x83, 0x1f, 0xc1, 0xca, 0xcc, 0x3c, 0x5f, 0x21, 0xfc, 0x8d, 0xd6, - 0xfe, 0x8f, 0xf4, 0x8c, 0xfa, 0xfa, 0x1d, 0x3d, 0x67, 0xfc, 0xb7, 0x06, 0xd0, 0x0a, 0xc2, 0x78, - 0xd3, 0x16, 0x17, 0x58, 0xf2, 0xa2, 0x5c, 0x63, 0x07, 0x9e, 0x0a, 0xcf, 0x85, 0x8c, 0x77, 0x62, - 0x85, 0x13, 0x48, 0x01, 0xc7, 0x89, 0x22, 0xda, 0x80, 0xa2, 0xdc, 0xff, 0xde, 0x30, 0x08, 0x65, - 0x2e, 0x59, 0xc1, 0x20, 0x45, 0x5c, 0x93, 0xbf, 0xde, 0x87, 0xa3, 0x03, 0xcf, 0x8d, 0x8e, 0xa8, - 0x23, 0x31, 0x19, 0x81, 0x59, 0x49, 0xa4, 0x1c, 0x66, 0xd4, 0x21, 0x1f, 0x5b, 0x47, 0x6b, 0x90, - 0xee, 0xd4, 0x5a, 0xfa, 0x52, 0xf9, 0xc6, 0xd9, 0x79, 0xa5, 0x18, 0x8b, 0x3b, 0xb5, 0x16, 0xef, - 0xe9, 0xd6, 0x5b, 0xba, 0x36, 0xdb, 0xd3, 0xad, 0xb7, 0xca, 0x19, 0x7e, 0xdf, 0x18, 0x7f, 0xa5, - 0x41, 0x4e, 0xb2, 0x9f, 0x85, 0x33, 0x36, 0x61, 0x39, 0xe6, 0xe4, 0x92, 0x92, 0xbd, 0x77, 0x35, - 0x7d, 0xaa, 0x2a, 0xb6, 0x23, 0xf7, 0x31, 0xd6, 0x2b, 0x7f, 0x0a, 0xa5, 0xe9, 0x8e, 0xef, 0xb4, - 0x8b, 0x7f, 0x04, 0x45, 0x1e, 0x28, 0x31, 0x8d, 0xda, 0x84, 0x9c, 0x64, 0x68, 0x2a, 0xab, 0x5c, - 0xc7, 0xe5, 0x14, 0x12, 0x3d, 0x84, 0x65, 0xc9, 0xff, 0xe2, 0xca, 0xc4, 0xfa, 0xf5, 0xe1, 0x88, - 0x63, 0xb8, 0xf1, 0x19, 0x64, 0x5a, 0x94, 0x86, 0xe8, 0x1e, 0x2c, 0xfb, 0x81, 0x43, 0x27, 0x49, - 0x54, 0x51, 0x57, 0x87, 0x36, 0xea, 0x9c, 0xba, 0x3a, 0xb4, 0xe1, 0xf0, 0xc5, 0xe3, 0x07, 0x34, - 0x2e, 0xce, 0xf0, 0x6f, 0xa3, 0x03, 0xa5, 0x67, 0xd4, 0xed, 0x1f, 0x31, 0xea, 0x08, 0x43, 0x1f, - 0x40, 0x66, 0x48, 0x13, 0xe7, 0xd7, 0x16, 0x86, 0x0e, 0xa5, 0x21, 0x16, 0x28, 0x7e, 0x20, 0x4f, - 0x85, 0xb6, 0xaa, 0x87, 0xa9, 0x96, 0xf1, 0xf7, 0x29, 0x58, 0x6d, 0x44, 0xd1, 0x88, 0xf8, 0x76, - 0x7c, 0x43, 0xfe, 0x74, 0xf6, 0x86, 0x7c, 0xb0, 0x70, 0x86, 0x33, 0x2a, 0xb3, 0xef, 0x65, 0x95, - 0x24, 0x53, 0x49, 0x92, 0x34, 0xbe, 0xd6, 0xe2, 0x87, 0xf2, 0xfd, 0xa9, 0x73, 0x53, 0x5e, 0x3b, - 0x3b, 0xaf, 0xdc, 0x9a, 0xb6, 0x44, 0xbb, 0xfe, 0xb1, 0x1f, 0x9c, 0xfa, 0xe8, 0x1d, 0xfe, 0x70, - 0x6e, 0x5a, 0xcf, 0x74, 0xad, 0x7c, 0xfb, 0xec, 0xbc, 0x82, 0x66, 0x40, 0x98, 0xfa, 0xf4, 0x94, - 0x5b, 0x6a, 0x59, 0xcd, 0x3a, 0xbf, 0xcc, 0x52, 0x0b, 0x2c, 0xb5, 0xa8, 0xef, 0xb8, 0x7e, 0x1f, - 0xdd, 0x83, 0x5c, 0xa3, 0xdd, 0xee, 0x8a, 0xa7, 0xcc, 0x9b, 0x67, 0xe7, 0x95, 0x37, 0x66, 0x50, - 0xbc, 0x41, 0x1d, 0x0e, 0xe2, 0x54, 0xcb, 0xaa, 0xeb, 0x99, 0x05, 0x20, 0xce, 0x34, 0xa8, 0xa3, - 0x22, 0xfc, 0xdf, 0x53, 0xa0, 0x9b, 0xb6, 0x4d, 0x87, 0x8c, 0xf7, 0x2b, 0xfa, 0xda, 0x81, 0xfc, - 0x90, 0x7f, 0xb9, 0x82, 0x8e, 0xf3, 0xb0, 0x78, 0xb8, 0xb0, 0x58, 0x3a, 0xa7, 0x57, 0xc5, 0x81, - 0x47, 0x4d, 0x67, 0xe0, 0x46, 0x11, 0x7f, 0xa6, 0x09, 0x19, 0x4e, 0x2c, 0x95, 0x7f, 0xa9, 0xc1, - 0x1b, 0x0b, 0x10, 0xe8, 0x23, 0xc8, 0x84, 0x81, 0x17, 0x6f, 0xcf, 0xdd, 0xab, 0x4a, 0x19, 0x5c, - 0x15, 0x0b, 0x24, 0x5a, 0x07, 0x20, 0x23, 0x16, 0x10, 0x31, 0xbe, 0xd8, 0x98, 0x3c, 0x9e, 0x92, - 0xa0, 0x67, 0x90, 0x8b, 0xa8, 0x1d, 0xd2, 0x98, 0x8b, 0x7c, 0xf6, 0xff, 0xf5, 0xbe, 0xda, 0x16, - 0x66, 0xb0, 0x32, 0x57, 0xae, 0x42, 0x4e, 0x4a, 0x78, 0x44, 0x3b, 0x84, 0x11, 0xe1, 0x74, 0x09, - 0x8b, 0x6f, 0x1e, 0x28, 0xc4, 0xeb, 0xc7, 0x81, 0x42, 0xbc, 0xbe, 0xf1, 0xb3, 0x14, 0x80, 0xf5, - 0x9c, 0xd1, 0xd0, 0x27, 0x5e, 0xcd, 0x44, 0xd6, 0x54, 0x86, 0x94, 0xb3, 0xfd, 0xc1, 0xc2, 0x02, - 0x57, 0xa2, 0x51, 0xad, 0x99, 0x0b, 0x72, 0xe4, 0x1d, 0x48, 0x8f, 0x42, 0x4f, 0x15, 0x4b, 0x05, - 0x11, 0xe9, 0xe2, 0x1d, 0xcc, 0x65, 0xc8, 0x9a, 0x64, 0xa4, 0xf4, 0xd5, 0x55, 0xee, 0xa9, 0x01, - 0x7e, 0xf3, 0x59, 0xe9, 0x03, 0x80, 0x89, 0xd7, 0x68, 0x1d, 0xb2, 0xb5, 0xed, 0x76, 0x7b, 0x47, - 0x5f, 0x92, 0xaf, 0xad, 0x49, 0x97, 0x10, 0x1b, 0x7f, 0xa7, 0x41, 0xbe, 0x66, 0xaa, 0x5b, 0x65, - 0x1b, 0x74, 0x91, 0x4b, 0x6c, 0x1a, 0xb2, 0x1e, 0x7d, 0x3e, 0x74, 0xc3, 0xb1, 0x4a, 0x07, 0xd7, - 0xbf, 0x4b, 0x56, 0xb9, 0x56, 0x8d, 0x86, 0xcc, 0x12, 0x3a, 0x08, 0x43, 0x89, 0xaa, 0x29, 0xf6, - 0x6c, 0x12, 0x27, 0xe7, 0xf5, 0xeb, 0x97, 0x42, 0xb2, 0xbf, 0x49, 0x3b, 0xc2, 0xc5, 0xd8, 0x48, - 0x8d, 0x44, 0xc6, 0x3e, 0xbc, 0xb1, 0x17, 0xda, 0x47, 0x34, 0x62, 0x72, 0x50, 0xe5, 0xf2, 0x67, - 0x70, 0x97, 0x91, 0xe8, 0xb8, 0x77, 0xe4, 0x46, 0x2c, 0x08, 0xc7, 0xbd, 0x90, 0x32, 0xea, 0xf3, - 0xfe, 0x9e, 0xa8, 0xa5, 0xab, 0xd7, 0xec, 0x1d, 0x8e, 0x79, 0x22, 0x21, 0x38, 0x46, 0xec, 0x70, - 0x80, 0xd1, 0x80, 0x12, 0x27, 0x6c, 0x75, 0x7a, 0x48, 0x46, 0x1e, 0x8b, 0xd0, 0x8f, 0x01, 0xbc, - 0xa0, 0xdf, 0x7b, 0xed, 0x4c, 0x5e, 0xf0, 0x82, 0xbe, 0xfc, 0x34, 0x7e, 0x0f, 0xf4, 0xba, 0x1b, - 0x0d, 0x09, 0xb3, 0x8f, 0xe2, 0x67, 0x3a, 0x7a, 0x0c, 0xfa, 0x11, 0x25, 0x21, 0x3b, 0xa0, 0x84, - 0xf5, 0x86, 0x34, 0x74, 0x03, 0xe7, 0xb5, 0x96, 0xf4, 0x46, 0xa2, 0xd5, 0x12, 0x4a, 0xc6, 0xaf, - 0x34, 0x00, 0x4c, 0x0e, 0x63, 0x02, 0xf0, 0x43, 0xb8, 0x19, 0xf9, 0x64, 0x18, 0x1d, 0x05, 0xac, - 0xe7, 0xfa, 0x8c, 0x86, 0x27, 0xc4, 0x53, 0x4f, 0x2d, 0x3d, 0xee, 0x68, 0x28, 0x39, 0xfa, 0x00, - 0xd0, 0x31, 0xa5, 0xc3, 0x5e, 0xe0, 0x39, 0xbd, 0xb8, 0x53, 0x16, 0xfb, 0x33, 0x58, 0xe7, 0x3d, - 0x7b, 0x9e, 0xd3, 0x8e, 0xe5, 0x68, 0x0b, 0xd6, 0xf9, 0x0a, 0x50, 0x9f, 0x85, 0x2e, 0x8d, 0x7a, - 0x87, 0x41, 0xd8, 0x8b, 0xbc, 0xe0, 0xb4, 0x77, 0x18, 0x78, 0x5e, 0x70, 0x4a, 0xc3, 0xf8, 0x21, - 0x5b, 0xf6, 0x82, 0xbe, 0x25, 0x41, 0xdb, 0x41, 0xd8, 0xf6, 0x82, 0xd3, 0xed, 0x18, 0xc1, 0x59, - 0xc2, 0x64, 0xda, 0xcc, 0xb5, 0x8f, 0x63, 0x96, 0x90, 0x48, 0x3b, 0xae, 0x7d, 0x8c, 0xee, 0xc1, - 0x0a, 0xf5, 0xa8, 0x78, 0x72, 0x49, 0x54, 0x56, 0xa0, 0x4a, 0xb1, 0x90, 0x83, 0x8c, 0xdf, 0x82, - 0x42, 0xcb, 0x23, 0xb6, 0xf8, 0x4b, 0x85, 0x3f, 0x2e, 0xed, 0xc0, 0xe7, 0x41, 0xe0, 0xfa, 0x4c, - 0x66, 0xc7, 0x02, 0x9e, 0x16, 0x19, 0x3f, 0x05, 0xf8, 0x22, 0x70, 0xfd, 0x4e, 0x70, 0x4c, 0x7d, - 0x51, 0x7d, 0xe6, 0xac, 0x57, 0x6d, 0x65, 0x01, 0xab, 0x96, 0xe0, 0xe4, 0xc4, 0x27, 0x7d, 0x1a, - 0x26, 0x45, 0x58, 0xd9, 0xe4, 0x97, 0x4b, 0x0e, 0x07, 0x01, 0xab, 0x99, 0xa8, 0x02, 0x39, 0x9b, - 0xf4, 0xe2, 0x93, 0x57, 0xda, 0x2a, 0x5c, 0x5e, 0x6c, 0x64, 0x6b, 0xe6, 0x53, 0x3a, 0xc6, 0x59, - 0x9b, 0x3c, 0xa5, 0x63, 0x7e, 0xfb, 0xda, 0x44, 0x9c, 0x17, 0x61, 0xa6, 0x24, 0x6f, 0xdf, 0x9a, - 0xc9, 0x0f, 0x03, 0xce, 0xd9, 0x84, 0xff, 0xa2, 0x8f, 0xa0, 0xa4, 0x40, 0xbd, 0x23, 0x12, 0x1d, - 0x49, 0xae, 0xba, 0xb5, 0x7a, 0x79, 0xb1, 0x01, 0x12, 0xf9, 0x84, 0x44, 0x47, 0x18, 0x24, 0x9a, - 0x7f, 0x23, 0x0b, 0x8a, 0x5f, 0x05, 0xae, 0xdf, 0x63, 0x62, 0x12, 0xaa, 0x36, 0xb0, 0xf0, 0xfc, - 0x4c, 0xa6, 0xaa, 0x1e, 0xca, 0xf0, 0x55, 0x22, 0x31, 0xfe, 0x55, 0x83, 0x22, 0xb7, 0xe9, 0x1e, - 0xba, 0x36, 0xbf, 0x2d, 0xbf, 0x7b, 0xa6, 0xbf, 0x03, 0x69, 0x3b, 0x0a, 0xd5, 0xdc, 0x44, 0xaa, - 0xab, 0xb5, 0x31, 0xe6, 0x32, 0xf4, 0x39, 0xe4, 0xe4, 0xe3, 0x42, 0x25, 0x79, 0xe3, 0xdb, 0xef, - 0x75, 0xe5, 0xa2, 0xd2, 0x13, 0x7b, 0x39, 0xf1, 0x4e, 0xcc, 0xb2, 0x84, 0xa7, 0x45, 0xe8, 0x36, - 0xa4, 0x6c, 0x5f, 0x04, 0x85, 0xfa, 0x57, 0xaa, 0xd6, 0xc4, 0x29, 0xdb, 0x37, 0xfe, 0x59, 0x83, - 0x15, 0xcb, 0xb7, 0xc3, 0xb1, 0x48, 0x92, 0x7c, 0x23, 0xee, 0x42, 0x21, 0x1a, 0x1d, 0x44, 0xe3, - 0x88, 0xd1, 0x41, 0x5c, 0xf4, 0x4e, 0x04, 0xa8, 0x01, 0x05, 0xe2, 0xf5, 0x83, 0xd0, 0x65, 0x47, - 0x03, 0xc5, 0x8d, 0x17, 0x27, 0xe6, 0x69, 0x9b, 0x55, 0x33, 0x56, 0xc1, 0x13, 0xed, 0x38, 0x15, - 0xa7, 0x85, 0xb3, 0x22, 0x15, 0xbf, 0x03, 0x25, 0x8f, 0x0c, 0x38, 0x15, 0xee, 0xf1, 0x27, 0x97, - 0x98, 0x47, 0x06, 0x17, 0x95, 0x8c, 0x3f, 0x23, 0x0d, 0x03, 0x0a, 0x89, 0x31, 0x74, 0x03, 0x8a, - 0xa6, 0xd5, 0xee, 0x7d, 0xbc, 0xf9, 0xb0, 0xf7, 0xb8, 0xb6, 0xab, 0x2f, 0x29, 0x26, 0xf0, 0x8f, - 0x1a, 0xac, 0xec, 0xca, 0x18, 0x54, 0xc4, 0xe9, 0x1e, 0x2c, 0x87, 0xe4, 0x90, 0xc5, 0xd4, 0x2e, - 0x23, 0x83, 0x8b, 0x27, 0x01, 0x4e, 0xed, 0x78, 0xd7, 0x62, 0x6a, 0x37, 0xf5, 0x97, 0x4b, 0xfa, - 0xda, 0xbf, 0x5c, 0x32, 0xbf, 0x91, 0xbf, 0x5c, 0x8c, 0xbf, 0xd4, 0xe0, 0x86, 0xba, 0xa8, 0xe3, - 0xbf, 0x19, 0x16, 0xd2, 0xf5, 0x9f, 0x24, 0x85, 0xc4, 0xf4, 0x55, 0x3c, 0x70, 0xce, 0x4c, 0x75, - 0x52, 0x5d, 0xbc, 0xea, 0x2f, 0x06, 0xe3, 0x0e, 0x64, 0x38, 0x8a, 0xbf, 0x95, 0xb6, 0x1b, 0x3b, - 0x96, 0xbe, 0x84, 0x96, 0x21, 0x6d, 0x35, 0xf7, 0x75, 0xed, 0xfd, 0x5f, 0xa5, 0xa1, 0x90, 0xbc, - 0xc6, 0x79, 0x2c, 0x73, 0x0a, 0xb8, 0x24, 0xab, 0x5b, 0x89, 0xbc, 0x29, 0xc8, 0x5f, 0xc1, 0xdc, - 0xd9, 0xd9, 0xab, 0x99, 0x1d, 0xab, 0xae, 0x7f, 0x2e, 0x39, 0x62, 0x02, 0x30, 0x3d, 0x2f, 0xe0, - 0xd1, 0xe8, 0x20, 0x63, 0xc2, 0x11, 0x5f, 0xa8, 0x1a, 0x5a, 0x82, 0x8a, 0x09, 0xe2, 0xbb, 0x90, - 0x37, 0xdb, 0xed, 0xc6, 0xe3, 0xa6, 0x55, 0xd7, 0x5f, 0x6a, 0xe5, 0xef, 0x9d, 0x9d, 0x57, 0x6e, - 0x4e, 0x4c, 0x45, 0x91, 0xdb, 0xf7, 0xa9, 0x23, 0x50, 0xb5, 0x9a, 0xd5, 0xe2, 0xe3, 0xbd, 0x48, - 0xcd, 0xa3, 0x04, 0x33, 0x12, 0xf5, 0xf0, 0x42, 0x0b, 0x5b, 0x2d, 0x13, 0xf3, 0x11, 0x5f, 0xa6, - 0xe6, 0xfc, 0x6a, 0x85, 0x74, 0x48, 0x42, 0x3e, 0xe6, 0x7a, 0xfc, 0xbf, 0xd0, 0x8b, 0xb4, 0xac, - 0x99, 0x4e, 0x4a, 0x10, 0x94, 0x38, 0x63, 0x3e, 0x5a, 0xbb, 0x63, 0x62, 0x51, 0xa9, 0x79, 0x99, - 0x9e, 0x1b, 0xad, 0xcd, 0x48, 0xc8, 0xb8, 0x15, 0x03, 0x96, 0x71, 0xb7, 0xd9, 0x14, 0xb3, 0xcb, - 0xcc, 0xcd, 0x0e, 0x8f, 0x7c, 0x9f, 0x63, 0xee, 0x43, 0x3e, 0xae, 0xec, 0xe8, 0x2f, 0x33, 0x73, - 0x0e, 0xd5, 0xe2, 0x92, 0x92, 0x18, 0xf0, 0x49, 0xb7, 0x23, 0xfe, 0xb6, 0x7a, 0x91, 0x9d, 0x1f, - 0xf0, 0x68, 0xc4, 0x1c, 0xce, 0xca, 0x2b, 0x09, 0x4d, 0x7e, 0x99, 0x95, 0xec, 0x24, 0xc1, 0x48, - 0x8e, 0xcc, 0xed, 0x60, 0xeb, 0x0b, 0xf9, 0x0f, 0xd7, 0x8b, 0xdc, 0x9c, 0x1d, 0x4c, 0xbf, 0xa2, - 0x36, 0xa3, 0xce, 0xa4, 0x24, 0x9c, 0x74, 0xbd, 0xff, 0xfb, 0x90, 0x8f, 0x33, 0x19, 0x5a, 0x87, - 0xdc, 0xb3, 0x3d, 0xfc, 0xd4, 0xc2, 0xfa, 0x92, 0x5c, 0x9d, 0xb8, 0xe7, 0x99, 0xbc, 0x0a, 0x2a, - 0xb0, 0xbc, 0x6b, 0x36, 0xcd, 0xc7, 0x16, 0x8e, 0x4b, 0xd2, 0x31, 0x40, 0x1d, 0xc7, 0xb2, 0xae, - 0x06, 0x48, 0x6c, 0xbe, 0xff, 0x05, 0x80, 0x0c, 0x55, 0x51, 0xf0, 0x36, 0xa0, 0x50, 0xdb, 0x6b, - 0x76, 0xcc, 0x46, 0x53, 0x0c, 0x22, 0x89, 0x56, 0x52, 0xa0, 0x91, 0x84, 0x75, 0x0d, 0x32, 0xcd, - 0xbd, 0xba, 0xa5, 0x6b, 0xe5, 0xd5, 0xb3, 0xf3, 0x8a, 0xfc, 0x2f, 0x51, 0xf4, 0x6c, 0xdd, 0xfd, - 0xfa, 0x9b, 0xf5, 0xa5, 0x5f, 0x7c, 0xb3, 0xbe, 0xf4, 0xcb, 0x6f, 0xd6, 0xb5, 0x17, 0x97, 0xeb, - 0xda, 0xd7, 0x97, 0xeb, 0xda, 0xcf, 0x2f, 0xd7, 0xb5, 0xff, 0xb8, 0x5c, 0xd7, 0x0e, 0x72, 0x82, - 0x76, 0x7e, 0xf2, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9c, 0x7d, 0x41, 0xe9, 0xef, 0x21, 0x00, - 0x00, + // 3442 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x59, 0x4d, 0x6c, 0x1b, 0x49, + 0x76, 0x16, 0x7f, 0x45, 0x3e, 0x52, 0x72, 0xbb, 0xec, 0xf5, 0xc8, 0x1c, 0x8f, 0xc4, 0x69, 0x8f, + 0x77, 0xbc, 0xb3, 0x13, 0xce, 0x8c, 0x66, 0x13, 0x78, 0xc7, 0xc9, 0xce, 0xb4, 0x48, 0xca, 0xe6, + 0x5a, 0xa2, 0x88, 0x22, 0x69, 0x63, 0x10, 0x20, 0x44, 0xa9, 0xbb, 0x44, 0xf6, 0xa8, 0xd9, 0xc5, + 0x74, 0x17, 0x25, 0x33, 0x41, 0x00, 0x27, 0x97, 0x04, 0x3a, 0xe5, 0x1e, 0x08, 0x8b, 0x20, 0x41, + 0x6e, 0x39, 0xe4, 0x14, 0x20, 0x27, 0x1f, 0xe7, 0xb8, 0x41, 0x80, 0x60, 0x91, 0x00, 0x42, 0x46, + 0x39, 0xe6, 0xb2, 0x40, 0x0e, 0x7b, 0x48, 0x0e, 0x41, 0xfd, 0x74, 0xf3, 0xc7, 0xb4, 0xc6, 0x93, + 0xdd, 0x13, 0xbb, 0x5e, 0x7d, 0xef, 0xd5, 0xab, 0xaa, 0x57, 0xaf, 0xbe, 0x57, 0x84, 0x02, 0x9f, + 0x8c, 0x68, 0x58, 0x19, 0x05, 0x8c, 0x33, 0x84, 0x1c, 0x66, 0x1f, 0xd3, 0xa0, 0x12, 0x9e, 0x92, + 0x60, 0x78, 0xec, 0xf2, 0xca, 0xc9, 0x27, 0xa5, 0xdb, 0xdc, 0x1d, 0xd2, 0x90, 0x93, 0xe1, 0xe8, + 0xa3, 0xf8, 0x4b, 0xc1, 0x4b, 0x6f, 0x39, 0xe3, 0x80, 0x70, 0x97, 0xf9, 0x1f, 0x45, 0x1f, 0xba, + 0xe3, 0x66, 0x9f, 0xf5, 0x99, 0xfc, 0xfc, 0x48, 0x7c, 0x29, 0xa9, 0xb9, 0x05, 0xab, 0x4f, 0x69, + 0x10, 0xba, 0xcc, 0x47, 0x37, 0x21, 0xe3, 0xfa, 0x0e, 0x7d, 0xbe, 0x91, 0x28, 0x27, 0xee, 0xa7, + 0xb1, 0x6a, 0x98, 0x7f, 0x9d, 0x80, 0x82, 0xe5, 0xfb, 0x8c, 0x4b, 0x5b, 0x21, 0x42, 0x90, 0xf6, + 0xc9, 0x90, 0x4a, 0x50, 0x1e, 0xcb, 0x6f, 0x54, 0x85, 0xac, 0x47, 0x0e, 0xa9, 0x17, 0x6e, 0x24, + 0xcb, 0xa9, 0xfb, 0x85, 0xed, 0x1f, 0x56, 0x5e, 0xf5, 0xb9, 0x32, 0x63, 0xa4, 0xb2, 0x27, 0xd1, + 0x75, 0x9f, 0x07, 0x13, 0xac, 0x55, 0x4b, 0x3f, 0x86, 0xc2, 0x8c, 0x18, 0x19, 0x90, 0x3a, 0xa6, + 0x13, 0x3d, 0x8c, 0xf8, 0x14, 0xfe, 0x9d, 0x10, 0x6f, 0x4c, 0x37, 0x92, 0x52, 0xa6, 0x1a, 0x9f, + 0x25, 0x1f, 0x24, 0xcc, 0x2f, 0x21, 0x8f, 0x69, 0xc8, 0xc6, 0x81, 0x4d, 0x43, 0xf4, 0x03, 0xc8, + 0xfb, 0xc4, 0x67, 0x3d, 0x7b, 0x34, 0x0e, 0xa5, 0x7a, 0x6a, 0xa7, 0x78, 0x79, 0xb1, 0x95, 0x6b, + 0x12, 0x9f, 0x55, 0x5b, 0xdd, 0x10, 0xe7, 0x44, 0x77, 0x75, 0x34, 0x0e, 0xd1, 0xbb, 0x50, 0x1c, + 0xd2, 0x21, 0x0b, 0x26, 0xbd, 0xc3, 0x09, 0xa7, 0xa1, 0x34, 0x9c, 0xc2, 0x05, 0x25, 0xdb, 0x11, + 0x22, 0xf3, 0x2f, 0x13, 0x70, 0x33, 0xb2, 0x8d, 0xe9, 0x1f, 0x8e, 0xdd, 0x80, 0x0e, 0xa9, 0xcf, + 0x43, 0xf4, 0xdb, 0x90, 0xf5, 0xdc, 0xa1, 0xcb, 0xd5, 0x18, 0x85, 0xed, 0x77, 0x96, 0xcd, 0x39, + 0xf6, 0x0a, 0x6b, 0x30, 0xb2, 0xa0, 0x18, 0xd0, 0x90, 0x06, 0x27, 0x6a, 0x25, 0xe4, 0x90, 0xdf, + 0xaa, 0x3c, 0xa7, 0x62, 0xee, 0x42, 0xae, 0xe5, 0x11, 0x7e, 0xc4, 0x82, 0x21, 0x32, 0xa1, 0x48, + 0x02, 0x7b, 0xe0, 0x72, 0x6a, 0xf3, 0x71, 0x10, 0xed, 0xca, 0x9c, 0x0c, 0xdd, 0x82, 0x24, 0x53, + 0x03, 0xe5, 0x77, 0xb2, 0x97, 0x17, 0x5b, 0xc9, 0x83, 0x36, 0x4e, 0xb2, 0xd0, 0x7c, 0x08, 0xd7, + 0x5b, 0xde, 0xb8, 0xef, 0xfa, 0x35, 0x1a, 0xda, 0x81, 0x3b, 0x12, 0xd6, 0xc5, 0xf6, 0x8a, 0xe0, + 0x8b, 0xb6, 0x57, 0x7c, 0xc7, 0x5b, 0x9e, 0x9c, 0x6e, 0xb9, 0xf9, 0xe7, 0x49, 0xb8, 0x5e, 0xf7, + 0xfb, 0xae, 0x4f, 0x67, 0xb5, 0xef, 0xc1, 0x3a, 0x95, 0xc2, 0xde, 0x89, 0x0a, 0x2a, 0x6d, 0x67, + 0x4d, 0x49, 0xa3, 0x48, 0x6b, 0x2c, 0xc4, 0xcb, 0x27, 0xcb, 0xa6, 0xff, 0x8a, 0xf5, 0x65, 0x51, + 0x83, 0xea, 0xb0, 0x3a, 0x92, 0x93, 0x08, 0x37, 0x52, 0xd2, 0xd6, 0xbd, 0x65, 0xb6, 0x5e, 0x99, + 0xe7, 0x4e, 0xfa, 0xeb, 0x8b, 0xad, 0x15, 0x1c, 0xe9, 0xfe, 0x3a, 0xc1, 0xf7, 0x9f, 0x09, 0xb8, + 0xd6, 0x64, 0xce, 0xdc, 0x3a, 0x94, 0x20, 0x37, 0x60, 0x21, 0x9f, 0x39, 0x28, 0x71, 0x1b, 0x3d, + 0x80, 0xdc, 0x48, 0x6f, 0x9f, 0xde, 0xfd, 0x3b, 0xcb, 0x5d, 0x56, 0x18, 0x1c, 0xa3, 0xd1, 0x43, + 0xc8, 0x07, 0x51, 0x4c, 0x6c, 0xa4, 0xde, 0x24, 0x70, 0xa6, 0x78, 0xf4, 0x7b, 0x90, 0x55, 0x9b, + 0xb0, 0x91, 0x96, 0x9a, 0xf7, 0xde, 0x68, 0xcd, 0xb1, 0x56, 0x32, 0x7f, 0x91, 0x00, 0x03, 0x93, + 0x23, 0xbe, 0x4f, 0x87, 0x87, 0x34, 0x68, 0x73, 0xc2, 0xc7, 0x21, 0xba, 0x05, 0x59, 0x8f, 0x12, + 0x87, 0x06, 0x72, 0x92, 0x39, 0xac, 0x5b, 0xa8, 0x2b, 0x82, 0x9c, 0xd8, 0x03, 0x72, 0xe8, 0x7a, + 0x2e, 0x9f, 0xc8, 0x69, 0xae, 0x2f, 0xdf, 0xe5, 0x45, 0x9b, 0x15, 0x3c, 0xa3, 0x88, 0xe7, 0xcc, + 0xa0, 0x0d, 0x58, 0x1d, 0xd2, 0x30, 0x24, 0x7d, 0x2a, 0x67, 0x9f, 0xc7, 0x51, 0xd3, 0x7c, 0x08, + 0xc5, 0x59, 0x3d, 0x54, 0x80, 0xd5, 0x6e, 0xf3, 0x49, 0xf3, 0xe0, 0x59, 0xd3, 0x58, 0x41, 0xd7, + 0xa0, 0xd0, 0x6d, 0xe2, 0xba, 0x55, 0x7d, 0x6c, 0xed, 0xec, 0xd5, 0x8d, 0x04, 0x5a, 0x83, 0xfc, + 0xb4, 0x99, 0x34, 0x7f, 0x96, 0x00, 0x10, 0x1b, 0xa8, 0x27, 0xf5, 0x19, 0x64, 0x42, 0x4e, 0xb8, + 0xda, 0xb8, 0xf5, 0xed, 0xf7, 0x96, 0x79, 0x3d, 0x85, 0x57, 0xc4, 0x0f, 0xc5, 0x4a, 0x65, 0xd6, + 0xc3, 0xe4, 0xa2, 0x87, 0x19, 0x89, 0x9c, 0x77, 0x2d, 0x07, 0xe9, 0x9a, 0xf8, 0x4a, 0xa0, 0x3c, + 0x64, 0x70, 0xdd, 0xaa, 0x7d, 0x69, 0x24, 0x91, 0x01, 0xc5, 0x5a, 0xa3, 0x5d, 0x3d, 0x68, 0x36, + 0xeb, 0xd5, 0x4e, 0xbd, 0x66, 0xa4, 0xcc, 0x7b, 0x90, 0x69, 0x0c, 0x49, 0x9f, 0xa2, 0x3b, 0x22, + 0x02, 0x8e, 0x68, 0x40, 0x7d, 0x3b, 0x0a, 0xac, 0xa9, 0xc0, 0xfc, 0x79, 0x1e, 0x32, 0xfb, 0x6c, + 0xec, 0x73, 0xb4, 0x3d, 0x73, 0x8a, 0xd7, 0xb7, 0x37, 0x97, 0x4d, 0x41, 0x02, 0x2b, 0x9d, 0xc9, + 0x88, 0xea, 0x53, 0x7e, 0x0b, 0xb2, 0x2a, 0x56, 0xb4, 0xeb, 0xba, 0x25, 0xe4, 0x9c, 0x04, 0x7d, + 0xca, 0xf5, 0xa2, 0xeb, 0x16, 0xba, 0x0f, 0xb9, 0x80, 0x12, 0x87, 0xf9, 0xde, 0x44, 0x86, 0x54, + 0x4e, 0xa5, 0x59, 0x4c, 0x89, 0x73, 0xe0, 0x7b, 0x13, 0x1c, 0xf7, 0xa2, 0xc7, 0x50, 0x3c, 0x74, + 0x7d, 0xa7, 0xc7, 0x46, 0x2a, 0xe7, 0x65, 0x5e, 0x1f, 0x80, 0xca, 0xab, 0x1d, 0xd7, 0x77, 0x0e, + 0x14, 0x18, 0x17, 0x0e, 0xa7, 0x0d, 0xd4, 0x84, 0xf5, 0x13, 0xe6, 0x8d, 0x87, 0x34, 0xb6, 0x95, + 0x95, 0xb6, 0xde, 0x7f, 0xbd, 0xad, 0xa7, 0x12, 0x1f, 0x59, 0x5b, 0x3b, 0x99, 0x6d, 0xa2, 0x27, + 0xb0, 0xc6, 0x87, 0xa3, 0xa3, 0x30, 0x36, 0xb7, 0x2a, 0xcd, 0x7d, 0xff, 0x8a, 0x05, 0x13, 0xf0, + 0xc8, 0x5a, 0x91, 0xcf, 0xb4, 0x4a, 0x7f, 0x96, 0x82, 0xc2, 0x8c, 0xe7, 0xa8, 0x0d, 0x85, 0x51, + 0xc0, 0x46, 0xa4, 0x2f, 0xf3, 0xb6, 0xde, 0x8b, 0x4f, 0xde, 0x68, 0xd6, 0x95, 0xd6, 0x54, 0x11, + 0xcf, 0x5a, 0x31, 0xcf, 0x93, 0x50, 0x98, 0xe9, 0x44, 0x1f, 0x40, 0x0e, 0xb7, 0x70, 0xe3, 0xa9, + 0xd5, 0xa9, 0x1b, 0x2b, 0xa5, 0x3b, 0x67, 0xe7, 0xe5, 0x0d, 0x69, 0x6d, 0xd6, 0x40, 0x2b, 0x70, + 0x4f, 0x44, 0xe8, 0xdd, 0x87, 0xd5, 0x08, 0x9a, 0x28, 0xbd, 0x7d, 0x76, 0x5e, 0x7e, 0x6b, 0x11, + 0x3a, 0x83, 0xc4, 0xed, 0xc7, 0x16, 0xae, 0xd7, 0x8c, 0xe4, 0x72, 0x24, 0x6e, 0x0f, 0x48, 0x40, + 0x1d, 0xf4, 0x7d, 0xc8, 0x6a, 0x60, 0xaa, 0x54, 0x3a, 0x3b, 0x2f, 0xdf, 0x5a, 0x04, 0x4e, 0x71, + 0xb8, 0xbd, 0x67, 0x3d, 0xad, 0x1b, 0xe9, 0xe5, 0x38, 0xdc, 0xf6, 0xc8, 0x09, 0x45, 0xef, 0x41, + 0x46, 0xc1, 0x32, 0xa5, 0xdb, 0x67, 0xe7, 0xe5, 0xef, 0xbd, 0x62, 0x4e, 0xa0, 0x4a, 0x1b, 0x7f, + 0xf1, 0x37, 0x9b, 0x2b, 0xff, 0xf4, 0xb7, 0x9b, 0xc6, 0x62, 0x77, 0xe9, 0x7f, 0x13, 0xb0, 0x36, + 0xb7, 0xe5, 0xc8, 0x84, 0xac, 0xcf, 0x6c, 0x36, 0x52, 0xe9, 0x3c, 0xb7, 0x03, 0x97, 0x17, 0x5b, + 0xd9, 0x26, 0xab, 0xb2, 0xd1, 0x04, 0xeb, 0x1e, 0xf4, 0x64, 0xe1, 0x42, 0xfa, 0xf4, 0x0d, 0xe3, + 0x69, 0xe9, 0x95, 0xf4, 0x39, 0xac, 0x39, 0x81, 0x7b, 0x42, 0x83, 0x9e, 0xcd, 0xfc, 0x23, 0xb7, + 0xaf, 0x53, 0x75, 0x69, 0x99, 0xcd, 0x9a, 0x04, 0xe2, 0xa2, 0x52, 0xa8, 0x4a, 0xfc, 0xaf, 0x71, + 0x19, 0x95, 0x9e, 0x42, 0x71, 0x36, 0x42, 0xd1, 0x3b, 0x00, 0xa1, 0xfb, 0x47, 0x54, 0xf3, 0x1b, + 0xc9, 0x86, 0x70, 0x5e, 0x48, 0x24, 0xbb, 0x41, 0xef, 0x43, 0x7a, 0xc8, 0x1c, 0x65, 0x27, 0xb3, + 0x73, 0x43, 0xdc, 0x89, 0xff, 0x76, 0xb1, 0x55, 0x60, 0x61, 0x65, 0xd7, 0xf5, 0xe8, 0x3e, 0x73, + 0x28, 0x96, 0x00, 0xf3, 0x04, 0xd2, 0x22, 0x55, 0xa0, 0xb7, 0x21, 0xbd, 0xd3, 0x68, 0xd6, 0x8c, + 0x95, 0xd2, 0xf5, 0xb3, 0xf3, 0xf2, 0x9a, 0x5c, 0x12, 0xd1, 0x21, 0x62, 0x17, 0x6d, 0x41, 0xf6, + 0xe9, 0xc1, 0x5e, 0x77, 0x5f, 0x84, 0xd7, 0x8d, 0xb3, 0xf3, 0xf2, 0xb5, 0xb8, 0x5b, 0x2d, 0x1a, + 0x7a, 0x07, 0x32, 0x9d, 0xfd, 0xd6, 0x6e, 0xdb, 0x48, 0x96, 0xd0, 0xd9, 0x79, 0x79, 0x3d, 0xee, + 0x97, 0x3e, 0x97, 0xae, 0xeb, 0x5d, 0xcd, 0xc7, 0x72, 0xf3, 0x7f, 0x92, 0xb0, 0x86, 0x05, 0xbf, + 0x0d, 0x78, 0x8b, 0x79, 0xae, 0x3d, 0x41, 0x2d, 0xc8, 0xdb, 0xcc, 0x77, 0xdc, 0x99, 0x33, 0xb5, + 0xfd, 0x9a, 0x4b, 0x70, 0xaa, 0x15, 0xb5, 0xaa, 0x91, 0x26, 0x9e, 0x1a, 0x41, 0xdb, 0x90, 0x71, + 0xa8, 0x47, 0x26, 0x57, 0xdd, 0xc6, 0x35, 0xcd, 0xa5, 0xb1, 0x82, 0x4a, 0xe6, 0x48, 0x9e, 0xf7, + 0x08, 0xe7, 0x74, 0x38, 0xe2, 0xea, 0x36, 0x4e, 0xe3, 0xc2, 0x90, 0x3c, 0xb7, 0xb4, 0x08, 0xfd, + 0x08, 0xb2, 0xa7, 0xae, 0xef, 0xb0, 0x53, 0x7d, 0xe1, 0x5e, 0x6d, 0x57, 0x63, 0xcd, 0x33, 0x71, + 0xcf, 0x2e, 0x38, 0x2b, 0x56, 0xbd, 0x79, 0xd0, 0xac, 0x47, 0xab, 0xae, 0xfb, 0x0f, 0xfc, 0x26, + 0xf3, 0xc5, 0x89, 0x81, 0x83, 0x66, 0x6f, 0xd7, 0x6a, 0xec, 0x75, 0xb1, 0x58, 0xf9, 0x9b, 0x67, + 0xe7, 0x65, 0x23, 0x86, 0xec, 0x12, 0xd7, 0x13, 0x24, 0xf0, 0x36, 0xa4, 0xac, 0xe6, 0x97, 0x46, + 0xb2, 0x64, 0x9c, 0x9d, 0x97, 0x8b, 0x71, 0xb7, 0xe5, 0x4f, 0xa6, 0x87, 0x69, 0x71, 0x5c, 0xf3, + 0xbf, 0x12, 0x50, 0xec, 0x8e, 0x1c, 0xc2, 0xa9, 0x8a, 0x4c, 0x54, 0x86, 0xc2, 0x88, 0x04, 0xc4, + 0xf3, 0xa8, 0xe7, 0x86, 0x43, 0x5d, 0x28, 0xcc, 0x8a, 0xd0, 0x83, 0xef, 0xb0, 0x98, 0x9a, 0x84, + 0xe9, 0x25, 0xed, 0xc2, 0xfa, 0x91, 0x72, 0xb6, 0x47, 0x6c, 0xb9, 0xbb, 0x29, 0xb9, 0xbb, 0x95, + 0x65, 0x26, 0x66, 0xbd, 0xaa, 0xe8, 0x39, 0x5a, 0x52, 0x0b, 0xaf, 0x1d, 0xcd, 0x36, 0xcd, 0xfb, + 0xb0, 0x36, 0xd7, 0x2f, 0x6e, 0xda, 0x96, 0xd5, 0x6d, 0xd7, 0x8d, 0x15, 0x54, 0x84, 0x5c, 0xf5, + 0xa0, 0xd9, 0x69, 0x34, 0xbb, 0x75, 0x23, 0x61, 0xfe, 0x43, 0x32, 0x9a, 0xad, 0x66, 0x02, 0x3b, + 0xf3, 0x4c, 0xe0, 0xc3, 0xd7, 0x3b, 0xa2, 0xb9, 0xc0, 0xb4, 0x11, 0x33, 0x82, 0xdf, 0x05, 0x90, + 0x8b, 0x4a, 0x9d, 0x1e, 0xe1, 0x57, 0xb1, 0xfd, 0x4e, 0x54, 0xc7, 0xe1, 0xbc, 0x56, 0xb0, 0x38, + 0xfa, 0x02, 0x8a, 0x36, 0x1b, 0x8e, 0x3c, 0xaa, 0xf5, 0x53, 0x6f, 0xa2, 0x5f, 0x88, 0x55, 0x2c, + 0x3e, 0xcb, 0x48, 0xd2, 0xf3, 0x8c, 0xa4, 0x0a, 0x85, 0x19, 0x7f, 0xe7, 0x79, 0x49, 0x11, 0x72, + 0xdd, 0x56, 0xcd, 0xea, 0x34, 0x9a, 0x8f, 0x8c, 0x04, 0x02, 0xc8, 0xca, 0x15, 0xab, 0x19, 0x49, + 0xc1, 0x9d, 0xaa, 0x07, 0xfb, 0xad, 0xbd, 0xba, 0x62, 0x26, 0x7f, 0x02, 0xd7, 0xaa, 0xcc, 0xe7, + 0xc4, 0xf5, 0x63, 0x52, 0xb8, 0x2d, 0x7c, 0xd6, 0xa2, 0x9e, 0xeb, 0xa8, 0xbc, 0xb5, 0x73, 0xed, + 0xf2, 0x62, 0xab, 0x10, 0x43, 0x1b, 0x35, 0xe1, 0x65, 0xd4, 0x70, 0x44, 0x74, 0x8e, 0x5c, 0x47, + 0xa7, 0xa1, 0xd5, 0xcb, 0x8b, 0xad, 0x54, 0xab, 0x51, 0xc3, 0x42, 0x86, 0xde, 0x86, 0x3c, 0x7d, + 0xee, 0xf2, 0x9e, 0x2d, 0xf2, 0x94, 0x98, 0x7f, 0x06, 0xe7, 0x84, 0xa0, 0x2a, 0xd2, 0xd2, 0x9f, + 0x26, 0x01, 0x3a, 0x24, 0x3c, 0xd6, 0x43, 0x3f, 0x84, 0x7c, 0x5c, 0x0e, 0x5f, 0x55, 0x96, 0xcd, + 0xac, 0x75, 0x8c, 0x47, 0x9f, 0x46, 0xbb, 0xad, 0xd8, 0xea, 0x72, 0x45, 0x3d, 0xd6, 0x32, 0xc2, + 0x37, 0x4f, 0x49, 0x45, 0xd6, 0xa6, 0x41, 0xa0, 0x17, 0x5d, 0x7c, 0xa2, 0xaa, 0xcc, 0x5c, 0x6a, + 0xce, 0x9a, 0x03, 0xdd, 0x5d, 0x36, 0xc8, 0xc2, 0x82, 0x3e, 0x5e, 0xc1, 0x53, 0xbd, 0x1d, 0x03, + 0xd6, 0x83, 0xb1, 0x2f, 0xbc, 0xee, 0x85, 0xb2, 0xdb, 0x74, 0xe1, 0xad, 0x26, 0xe5, 0xa7, 0x2c, + 0x38, 0xb6, 0x38, 0x27, 0xf6, 0x40, 0x94, 0xa7, 0xfa, 0xb8, 0x4e, 0xa9, 0x5b, 0x62, 0x8e, 0xba, + 0x6d, 0xc0, 0x2a, 0xf1, 0x5c, 0x12, 0x52, 0x75, 0xdf, 0xe5, 0x71, 0xd4, 0x14, 0x04, 0x93, 0x38, + 0x4e, 0x40, 0xc3, 0x90, 0xaa, 0x82, 0x2a, 0x8f, 0xa7, 0x02, 0xf3, 0x5f, 0x92, 0x00, 0x8d, 0x96, + 0xb5, 0xaf, 0xcd, 0xd7, 0x20, 0x7b, 0x44, 0x86, 0xae, 0x37, 0xb9, 0xea, 0x80, 0x4c, 0xf1, 0x15, + 0x4b, 0x19, 0xda, 0x95, 0x3a, 0x58, 0xeb, 0x4a, 0xde, 0x39, 0x3e, 0xf4, 0x29, 0x8f, 0x79, 0xa7, + 0x6c, 0x89, 0x4b, 0x2e, 0x20, 0x7e, 0xbc, 0xb0, 0xaa, 0x21, 0x5c, 0xef, 0x13, 0x4e, 0x4f, 0xc9, + 0x24, 0x8a, 0x67, 0xdd, 0x44, 0x8f, 0x05, 0x1f, 0x15, 0x65, 0x32, 0x75, 0x36, 0x32, 0xf2, 0x16, + 0xff, 0x36, 0x7f, 0xb0, 0x86, 0xab, 0xeb, 0x3b, 0xd6, 0x2e, 0x3d, 0x94, 0x77, 0xce, 0xb4, 0xeb, + 0x3b, 0x95, 0x83, 0x1f, 0xc3, 0xda, 0xdc, 0x3c, 0x5f, 0x21, 0xfc, 0x8d, 0xd6, 0xd3, 0x1f, 0x19, + 0x69, 0xfd, 0xf5, 0x3b, 0x46, 0xd6, 0xfc, 0xef, 0x04, 0x40, 0x8b, 0x05, 0xd1, 0xa6, 0x2d, 0x7f, + 0x60, 0xc9, 0xc9, 0xe7, 0x1a, 0x9b, 0x79, 0x3a, 0x3c, 0x97, 0x32, 0xde, 0xa9, 0x15, 0x41, 0x20, + 0x25, 0x1c, 0xc7, 0x8a, 0x68, 0x0b, 0x0a, 0x6a, 0xff, 0x7b, 0x23, 0x16, 0xa8, 0x5c, 0xb2, 0x86, + 0x41, 0x89, 0x84, 0xa6, 0xa8, 0xde, 0x47, 0xe3, 0x43, 0xcf, 0x0d, 0x07, 0xd4, 0x51, 0x98, 0xb4, + 0xc4, 0xac, 0xc5, 0x52, 0x01, 0x33, 0x6b, 0x90, 0x8b, 0xac, 0xa3, 0x0d, 0x48, 0x75, 0xaa, 0x2d, + 0x63, 0xa5, 0x74, 0xed, 0xec, 0xbc, 0x5c, 0x88, 0xc4, 0x9d, 0x6a, 0x4b, 0xf4, 0x74, 0x6b, 0x2d, + 0x23, 0x31, 0xdf, 0xd3, 0xad, 0xb5, 0x4a, 0x69, 0x71, 0xdf, 0x98, 0x7f, 0x95, 0x80, 0xac, 0x62, + 0x3f, 0x4b, 0x67, 0x6c, 0xc1, 0x6a, 0xc4, 0xc9, 0x15, 0x25, 0x7b, 0xff, 0xf5, 0xf4, 0xa9, 0xa2, + 0xd9, 0x8e, 0xda, 0xc7, 0x48, 0xaf, 0xf4, 0x19, 0x14, 0x67, 0x3b, 0xbe, 0xd3, 0x2e, 0xfe, 0x31, + 0x14, 0x44, 0xa0, 0x44, 0x34, 0x6a, 0x1b, 0xb2, 0x8a, 0xa1, 0xe9, 0xac, 0x72, 0x15, 0x97, 0xd3, + 0x48, 0xf4, 0x00, 0x56, 0x15, 0xff, 0x8b, 0x5e, 0x26, 0x36, 0xaf, 0x0e, 0x47, 0x1c, 0xc1, 0xcd, + 0xcf, 0x21, 0xdd, 0xa2, 0x34, 0x40, 0x77, 0x61, 0xd5, 0x67, 0x0e, 0x9d, 0x26, 0x51, 0x4d, 0x5d, + 0x1d, 0xda, 0xa8, 0x09, 0xea, 0xea, 0xd0, 0x86, 0x23, 0x16, 0x4f, 0x1c, 0xd0, 0xe8, 0x71, 0x46, + 0x7c, 0x9b, 0x1d, 0x28, 0x3e, 0xa3, 0x6e, 0x7f, 0xc0, 0xa9, 0x23, 0x0d, 0x7d, 0x08, 0xe9, 0x11, + 0x8d, 0x9d, 0xdf, 0x58, 0x1a, 0x3a, 0x94, 0x06, 0x58, 0xa2, 0xc4, 0x81, 0x3c, 0x95, 0xda, 0xfa, + 0x3d, 0x4c, 0xb7, 0xcc, 0xbf, 0x4f, 0xc2, 0x7a, 0x23, 0x0c, 0xc7, 0xc4, 0xb7, 0xa3, 0x1b, 0xf2, + 0x27, 0xf3, 0x37, 0xe4, 0xfd, 0xa5, 0x33, 0x9c, 0x53, 0x99, 0xaf, 0x97, 0x75, 0x92, 0x4c, 0xc6, + 0x49, 0xd2, 0xfc, 0x3a, 0x11, 0x15, 0xca, 0xf7, 0x66, 0xce, 0x4d, 0x69, 0xe3, 0xec, 0xbc, 0x7c, + 0x73, 0xd6, 0x12, 0xed, 0xfa, 0xc7, 0x3e, 0x3b, 0xf5, 0xd1, 0xbb, 0xa2, 0x70, 0x6e, 0xd6, 0x9f, + 0x19, 0x89, 0xd2, 0xad, 0xb3, 0xf3, 0x32, 0x9a, 0x03, 0x61, 0xea, 0xd3, 0x53, 0x61, 0xa9, 0x55, + 0x6f, 0xd6, 0xc4, 0x65, 0x96, 0x5c, 0x62, 0xa9, 0x45, 0x7d, 0xc7, 0xf5, 0xfb, 0xe8, 0x2e, 0x64, + 0x1b, 0xed, 0x76, 0x57, 0x96, 0x32, 0x6f, 0x9d, 0x9d, 0x97, 0x6f, 0xcc, 0xa1, 0x44, 0x83, 0x3a, + 0x02, 0x24, 0xa8, 0x56, 0xbd, 0x66, 0xa4, 0x97, 0x80, 0x04, 0xd3, 0xa0, 0x8e, 0x8e, 0xf0, 0x7f, + 0x4f, 0x82, 0x61, 0xd9, 0x36, 0x1d, 0x71, 0xd1, 0xaf, 0xe9, 0x6b, 0x07, 0x72, 0x23, 0xf1, 0xe5, + 0x4a, 0x3a, 0x2e, 0xc2, 0xe2, 0xc1, 0xd2, 0xc7, 0xd2, 0x05, 0xbd, 0x0a, 0x66, 0x1e, 0xb5, 0x9c, + 0xa1, 0x1b, 0x86, 0xa2, 0x4c, 0x93, 0x32, 0x1c, 0x5b, 0x2a, 0xfd, 0x32, 0x01, 0x37, 0x96, 0x20, + 0xd0, 0xc7, 0x90, 0x0e, 0x98, 0x17, 0x6d, 0xcf, 0x9d, 0xd7, 0x3d, 0x65, 0x08, 0x55, 0x2c, 0x91, + 0x68, 0x13, 0x80, 0x8c, 0x39, 0x23, 0x72, 0x7c, 0xb9, 0x31, 0x39, 0x3c, 0x23, 0x41, 0xcf, 0x20, + 0x1b, 0x52, 0x3b, 0xa0, 0x11, 0x17, 0xf9, 0xfc, 0xff, 0xeb, 0x7d, 0xa5, 0x2d, 0xcd, 0x60, 0x6d, + 0xae, 0x54, 0x81, 0xac, 0x92, 0x88, 0x88, 0x76, 0x08, 0x27, 0xd2, 0xe9, 0x22, 0x96, 0xdf, 0x22, + 0x50, 0x88, 0xd7, 0x8f, 0x02, 0x85, 0x78, 0x7d, 0xf3, 0x67, 0x49, 0x80, 0xfa, 0x73, 0x4e, 0x03, + 0x9f, 0x78, 0x55, 0x0b, 0xd5, 0x67, 0x32, 0xa4, 0x9a, 0xed, 0x0f, 0x96, 0x3e, 0x70, 0xc5, 0x1a, + 0x95, 0xaa, 0xb5, 0x24, 0x47, 0xde, 0x86, 0xd4, 0x38, 0xf0, 0xf4, 0x63, 0xa9, 0x24, 0x22, 0x5d, + 0xbc, 0x87, 0x85, 0x0c, 0xd5, 0xa7, 0x19, 0x29, 0xf5, 0xfa, 0x57, 0xee, 0x99, 0x01, 0x7e, 0xf3, + 0x59, 0xe9, 0x43, 0x80, 0xa9, 0xd7, 0x68, 0x13, 0x32, 0xd5, 0xdd, 0x76, 0x7b, 0xcf, 0x58, 0x51, + 0xd5, 0xd6, 0xb4, 0x4b, 0x8a, 0xcd, 0xbf, 0x4b, 0x40, 0xae, 0x6a, 0xe9, 0x5b, 0x65, 0x17, 0x0c, + 0x99, 0x4b, 0x6c, 0x1a, 0xf0, 0x1e, 0x7d, 0x3e, 0x72, 0x83, 0x89, 0x4e, 0x07, 0x57, 0xd7, 0x25, + 0xeb, 0x42, 0xab, 0x4a, 0x03, 0x5e, 0x97, 0x3a, 0x08, 0x43, 0x91, 0xea, 0x29, 0xf6, 0x6c, 0x12, + 0x25, 0xe7, 0xcd, 0xab, 0x97, 0x42, 0xb1, 0xbf, 0x69, 0x3b, 0xc4, 0x85, 0xc8, 0x48, 0x95, 0x84, + 0xe6, 0x53, 0xb8, 0x71, 0x10, 0xd8, 0x03, 0x1a, 0x72, 0x35, 0xa8, 0x76, 0xf9, 0x73, 0xb8, 0xc3, + 0x49, 0x78, 0xdc, 0x1b, 0xb8, 0x21, 0x67, 0xc1, 0xa4, 0x17, 0x50, 0x4e, 0x7d, 0xd1, 0xdf, 0x93, + 0x6f, 0xe9, 0xba, 0x9a, 0xbd, 0x2d, 0x30, 0x8f, 0x15, 0x04, 0x47, 0x88, 0x3d, 0x01, 0x30, 0x1b, + 0x50, 0x14, 0x84, 0xad, 0x46, 0x8f, 0xc8, 0xd8, 0xe3, 0x21, 0xfa, 0x31, 0x80, 0xc7, 0xfa, 0xbd, + 0x37, 0xce, 0xe4, 0x79, 0x8f, 0xf5, 0xd5, 0xa7, 0xf9, 0xfb, 0x60, 0xd4, 0xdc, 0x70, 0x44, 0xb8, + 0x3d, 0x88, 0xca, 0x74, 0xf4, 0x08, 0x8c, 0x01, 0x25, 0x01, 0x3f, 0xa4, 0x84, 0xf7, 0x46, 0x34, + 0x70, 0x99, 0xf3, 0x46, 0x4b, 0x7a, 0x2d, 0xd6, 0x6a, 0x49, 0x25, 0xf3, 0x57, 0x09, 0x00, 0x4c, + 0x8e, 0x22, 0x02, 0xf0, 0x43, 0xb8, 0x1e, 0xfa, 0x64, 0x14, 0x0e, 0x18, 0xef, 0xb9, 0x3e, 0xa7, + 0xc1, 0x09, 0xf1, 0x74, 0xa9, 0x65, 0x44, 0x1d, 0x0d, 0x2d, 0x47, 0x1f, 0x02, 0x3a, 0xa6, 0x74, + 0xd4, 0x63, 0x9e, 0xd3, 0x8b, 0x3a, 0xd5, 0x63, 0x7f, 0x1a, 0x1b, 0xa2, 0xe7, 0xc0, 0x73, 0xda, + 0x91, 0x1c, 0xed, 0xc0, 0xa6, 0x58, 0x01, 0xea, 0xf3, 0xc0, 0xa5, 0x61, 0xef, 0x88, 0x05, 0xbd, + 0xd0, 0x63, 0xa7, 0xbd, 0x23, 0xe6, 0x79, 0xec, 0x94, 0x06, 0x51, 0x21, 0x5b, 0xf2, 0x58, 0xbf, + 0xae, 0x40, 0xbb, 0x2c, 0x68, 0x7b, 0xec, 0x74, 0x37, 0x42, 0x08, 0x96, 0x30, 0x9d, 0x36, 0x77, + 0xed, 0xe3, 0x88, 0x25, 0xc4, 0xd2, 0x8e, 0x6b, 0x1f, 0xa3, 0xbb, 0xb0, 0x46, 0x3d, 0x2a, 0x4b, + 0x2e, 0x85, 0xca, 0x48, 0x54, 0x31, 0x12, 0x0a, 0x90, 0xf9, 0x5b, 0x90, 0x6f, 0x79, 0xc4, 0x96, + 0x7f, 0xa9, 0x88, 0xe2, 0xd2, 0x66, 0xbe, 0x08, 0x02, 0xd7, 0xe7, 0x2a, 0x3b, 0xe6, 0xf1, 0xac, + 0xc8, 0xfc, 0x09, 0xc0, 0x4f, 0x99, 0xeb, 0x77, 0xd8, 0x31, 0xf5, 0xe5, 0xeb, 0xb3, 0x60, 0xbd, + 0x7a, 0x2b, 0xf3, 0x58, 0xb7, 0x24, 0x27, 0x27, 0x3e, 0xe9, 0xd3, 0x20, 0x7e, 0x84, 0x55, 0x4d, + 0x71, 0xb9, 0x64, 0x31, 0x63, 0xbc, 0x6a, 0xa1, 0x32, 0x64, 0x6d, 0xd2, 0x8b, 0x4e, 0x5e, 0x71, + 0x27, 0x7f, 0x79, 0xb1, 0x95, 0xa9, 0x5a, 0x4f, 0xe8, 0x04, 0x67, 0x6c, 0xf2, 0x84, 0x4e, 0xc4, + 0xed, 0x6b, 0x13, 0x79, 0x5e, 0xa4, 0x99, 0xa2, 0xba, 0x7d, 0xab, 0x96, 0x38, 0x0c, 0x38, 0x6b, + 0x13, 0xf1, 0x8b, 0x3e, 0x86, 0xa2, 0x06, 0xf5, 0x06, 0x24, 0x1c, 0x28, 0xae, 0xba, 0xb3, 0x7e, + 0x79, 0xb1, 0x05, 0x0a, 0xf9, 0x98, 0x84, 0x03, 0x0c, 0x0a, 0x2d, 0xbe, 0x51, 0x1d, 0x0a, 0x5f, + 0x31, 0xd7, 0xef, 0x71, 0x39, 0x09, 0xfd, 0x36, 0xb0, 0xf4, 0xfc, 0x4c, 0xa7, 0xaa, 0x0b, 0x65, + 0xf8, 0x2a, 0x96, 0x98, 0xff, 0x9a, 0x80, 0x82, 0xb0, 0xe9, 0x1e, 0xb9, 0xb6, 0xb8, 0x2d, 0xbf, + 0x7b, 0xa6, 0xbf, 0x0d, 0x29, 0x3b, 0x0c, 0xf4, 0xdc, 0x64, 0xaa, 0xab, 0xb6, 0x31, 0x16, 0x32, + 0xf4, 0x05, 0x64, 0x55, 0x71, 0xa1, 0x93, 0xbc, 0xf9, 0xed, 0xf7, 0xba, 0x76, 0x51, 0xeb, 0xc9, + 0xbd, 0x9c, 0x7a, 0x27, 0x67, 0x59, 0xc4, 0xb3, 0x22, 0x74, 0x0b, 0x92, 0xb6, 0x2f, 0x83, 0x42, + 0xff, 0x2b, 0x55, 0x6d, 0xe2, 0xa4, 0xed, 0x9b, 0xff, 0x9c, 0x80, 0xb5, 0xba, 0x6f, 0x07, 0x13, + 0x99, 0x24, 0xc5, 0x46, 0xdc, 0x81, 0x7c, 0x38, 0x3e, 0x0c, 0x27, 0x21, 0xa7, 0xc3, 0xe8, 0xd1, + 0x3b, 0x16, 0xa0, 0x06, 0xe4, 0x89, 0xd7, 0x67, 0x81, 0xcb, 0x07, 0x43, 0xcd, 0x8d, 0x97, 0x27, + 0xe6, 0x59, 0x9b, 0x15, 0x2b, 0x52, 0xc1, 0x53, 0xed, 0x28, 0x15, 0xa7, 0xa4, 0xb3, 0x32, 0x15, + 0xbf, 0x0b, 0x45, 0x8f, 0x0c, 0x05, 0x15, 0xee, 0x89, 0x92, 0x4b, 0xce, 0x23, 0x8d, 0x0b, 0x5a, + 0x26, 0xca, 0x48, 0xd3, 0x84, 0x7c, 0x6c, 0x0c, 0x5d, 0x83, 0x82, 0x55, 0x6f, 0xf7, 0x3e, 0xd9, + 0x7e, 0xd0, 0x7b, 0x54, 0xdd, 0x37, 0x56, 0x34, 0x13, 0xf8, 0xc7, 0x04, 0xac, 0xed, 0xab, 0x18, + 0xd4, 0xc4, 0xe9, 0x2e, 0xac, 0x06, 0xe4, 0x88, 0x47, 0xd4, 0x2e, 0xad, 0x82, 0x4b, 0x24, 0x01, + 0x41, 0xed, 0x44, 0xd7, 0x72, 0x6a, 0x37, 0xf3, 0x97, 0x4b, 0xea, 0xca, 0xbf, 0x5c, 0xd2, 0xbf, + 0x91, 0xbf, 0x5c, 0x3e, 0xf8, 0x55, 0x0a, 0xf2, 0x71, 0xd1, 0x2b, 0x42, 0x46, 0x30, 0xad, 0x15, + 0xf5, 0x88, 0x14, 0xcb, 0x9b, 0x92, 0x63, 0xe5, 0xad, 0xbd, 0xbd, 0x83, 0xaa, 0xd5, 0xa9, 0xd7, + 0x8c, 0x2f, 0x14, 0x15, 0x8b, 0x01, 0x96, 0xe7, 0x31, 0xb1, 0xe9, 0x0e, 0x32, 0xa7, 0x54, 0xec, + 0x85, 0x7e, 0xaa, 0x8a, 0x51, 0x11, 0x0f, 0x7b, 0x0f, 0x72, 0x56, 0xbb, 0xdd, 0x78, 0xd4, 0xac, + 0xd7, 0x8c, 0x97, 0x89, 0xd2, 0xf7, 0xce, 0xce, 0xcb, 0xd7, 0xa7, 0xa6, 0xc2, 0xd0, 0xed, 0xfb, + 0xd4, 0x91, 0xa8, 0x6a, 0xb5, 0xde, 0x12, 0xe3, 0xbd, 0x48, 0x2e, 0xa2, 0x24, 0x01, 0x91, 0xcf, + 0xce, 0xf9, 0x16, 0xae, 0xb7, 0x2c, 0x2c, 0x46, 0x7c, 0x99, 0x5c, 0xf0, 0xab, 0x15, 0xd0, 0x11, + 0x09, 0xc4, 0x98, 0x9b, 0xd1, 0xdf, 0x2f, 0x2f, 0x52, 0xea, 0x69, 0x72, 0x5a, 0xe9, 0x53, 0xe2, + 0x4c, 0xc4, 0x68, 0xed, 0x8e, 0x85, 0xe5, 0x83, 0xc8, 0xcb, 0xd4, 0xc2, 0x68, 0x6d, 0x4e, 0x02, + 0x2e, 0xac, 0x98, 0xb0, 0x8a, 0xbb, 0xcd, 0xa6, 0x9c, 0x5d, 0x7a, 0x61, 0x76, 0x78, 0xec, 0xfb, + 0x02, 0x73, 0x0f, 0x72, 0xd1, 0x03, 0x8a, 0xf1, 0x32, 0xbd, 0xe0, 0x50, 0x35, 0x7a, 0xb9, 0x91, + 0x03, 0x3e, 0xee, 0x76, 0xe4, 0xbf, 0x43, 0x2f, 0x32, 0x8b, 0x03, 0x0e, 0xc6, 0xdc, 0x11, 0xe4, + 0xb7, 0x1c, 0xb3, 0xd1, 0x97, 0x19, 0x45, 0x02, 0x62, 0x8c, 0xa2, 0xa2, 0xc2, 0x0e, 0xae, 0xff, + 0x54, 0xfd, 0x91, 0xf4, 0x22, 0xbb, 0x60, 0x07, 0xd3, 0xaf, 0xa8, 0xcd, 0xa9, 0x33, 0x7d, 0x79, + 0x8d, 0xbb, 0x3e, 0xf8, 0x03, 0xc8, 0x45, 0x09, 0x03, 0x6d, 0x42, 0xf6, 0xd9, 0x01, 0x7e, 0x52, + 0xc7, 0xc6, 0x8a, 0x5a, 0x9d, 0xa8, 0xe7, 0x99, 0xca, 0xb8, 0x65, 0x58, 0xdd, 0xb7, 0x9a, 0xd6, + 0xa3, 0x3a, 0x8e, 0x5e, 0x7e, 0x23, 0x80, 0x8e, 0xfa, 0x92, 0xa1, 0x07, 0x88, 0x6d, 0xee, 0xdc, + 0xf9, 0xfa, 0x9b, 0xcd, 0x95, 0x5f, 0x7c, 0xb3, 0xb9, 0xf2, 0xcb, 0x6f, 0x36, 0x13, 0x2f, 0x2e, + 0x37, 0x13, 0x5f, 0x5f, 0x6e, 0x26, 0x7e, 0x7e, 0xb9, 0x99, 0xf8, 0x8f, 0xcb, 0xcd, 0xc4, 0x61, + 0x56, 0x32, 0xb2, 0x4f, 0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x7d, 0xe8, 0x50, 0x18, 0x0a, 0x21, + 0x00, 0x00, } diff --git a/api/types.proto b/api/types.proto index 576bf1ed9f..b0e2639ff2 100644 --- a/api/types.proto +++ b/api/types.proto @@ -712,28 +712,4 @@ message ManagerStatus { // Reachability specifies whether this node is reachable. RaftMemberStatus.Reachability reachability = 4; -} - -// SecretType provides information about what kind of secret this is -enum SecretType { - CONTAINER = 0 [(gogoproto.enumvalue_customname) = "ContainerSecret"]; - NODE = 1 [(gogoproto.enumvalue_customname) = "NodeSecret"]; -} - -// SecretReference is the linkage between a service and a secret that it uses. -message SecretReference { - // Name is the name of the secret that this reference. - string name = 1; - - // Mode specifies how this secret should be exposed inside the task. - enum Mode { - FILE = 0; - ENV = 1; - } - - // Mode is one or more ways the secret should be presented. - repeated Mode mode = 2; - - // Target is the name by which the image accesses the secret. - string target = 3; -} +} \ No newline at end of file diff --git a/manager/dispatcher/dispatcher.go b/manager/dispatcher/dispatcher.go index db0dc27687..72290f7a56 100644 --- a/manager/dispatcher/dispatcher.go +++ b/manager/dispatcher/dispatcher.go @@ -758,7 +758,6 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche initial api.AssignmentsMessage ) tasksMap := make(map[string]*api.Task) - tasksUsingSecret := make(map[string]map[string]struct{}) sendMessage := func(msg api.AssignmentsMessage, assignmentType api.AssignmentsMessage_AssignmentType) error { sequence++ @@ -773,36 +772,6 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche return nil } - addSecretsForTask := func(readTx store.ReadTx, t *api.Task, msg *api.AssignmentsMessage) { - container := t.Spec.GetContainer() - if container == nil { - return - } - for _, secretRef := range container.Secrets { - secretName := secretRef.Name - if tasksUsingSecret[secretName] == nil { - tasksUsingSecret[secretName] = make(map[string]struct{}) - - secrets, err := store.FindSecrets(readTx, store.ByName(secretName)) - if err != nil { - log.WithError(err).Errorf("error retrieving secret %s", secretName) - continue - } - if len(secrets) != 1 { - log.Debugf("secret not found: %s", secretName) - continue - } - - // If the secret was found and there was one result - // (there should never be more than one because of the - // uniqueness constraint), add this secret to our - // initial set that we send down. - msg.UpdateSecrets = append(msg.UpdateSecrets, secrets[0]) - } - tasksUsingSecret[secretName][t.ID] = struct{}{} - } - } - // TODO(aaronl): Also send node secrets that should be exposed to // this node. nodeTasks, cancel, err := store.ViewAndWatch( @@ -825,7 +794,6 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche tasksMap[t.ID] = t initial.UpdateTasks = append(initial.UpdateTasks, t) - addSecretsForTask(readTx, t, &initial) } return nil }, @@ -833,8 +801,6 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche Checks: []state.TaskCheckFunc{state.TaskCheckNodeID}}, state.EventDeleteTask{Task: &api.Task{NodeID: nodeID}, Checks: []state.TaskCheckFunc{state.TaskCheckNodeID}}, - state.EventUpdateSecret{}, - state.EventDeleteSecret{}, ) if err != nil { return err @@ -903,13 +869,6 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche tasksMap[v.Task.ID] = v.Task continue } - } else { - // If this task wasn't part of the assignment set before, - // add the secrets it references to the secrets assignment - // set. - d.store.View(func(readTx store.ReadTx) { - addSecretsForTask(readTx, v.Task, &update) - }) } tasksMap[v.Task.ID] = v.Task @@ -923,45 +882,6 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche delete(tasksMap, v.Task.ID) - // Release the secrets references from this task - - container := v.Task.Spec.GetContainer() - if container == nil { - continue - } - for _, secretRef := range container.Secrets { - secretName := secretRef.Name - if tasksUsingSecret[secretName] == nil { - continue - } - delete(tasksUsingSecret[secretName], v.Task.ID) - if len(tasksUsingSecret[secretName]) == 0 { - // No tasks are using the secret anymore - delete(tasksUsingSecret, secretName) - update.RemoveSecrets = append(update.RemoveSecrets, secretName) - } - } - - oneModification() - // TODO(aaronl): For node secrets, we'll need to handle - // EventCreateSecret. - case state.EventUpdateSecret: - if _, exists := tasksUsingSecret[v.Secret.Spec.Annotations.Name]; !exists { - continue - } - - update.UpdateSecrets = append(update.UpdateSecrets, v.Secret) - - oneModification() - case state.EventDeleteSecret: - if _, exists := tasksUsingSecret[v.Secret.Spec.Annotations.Name]; !exists { - continue - } - - delete(tasksUsingSecret, v.Secret.Spec.Annotations.Name) - - update.RemoveSecrets = append(update.RemoveSecrets, v.Secret.Spec.Annotations.Name) - oneModification() } case <-batchingTimeout: diff --git a/manager/state/store/secrets.go b/manager/state/store/secrets.go deleted file mode 100644 index b8b25488af..0000000000 --- a/manager/state/store/secrets.go +++ /dev/null @@ -1,225 +0,0 @@ -package store - -import ( - "strings" - - "github.com/docker/swarmkit/api" - "github.com/docker/swarmkit/manager/state" - memdb "github.com/hashicorp/go-memdb" -) - -const tableSecret = "secret" - -func init() { - register(ObjectStoreConfig{ - Name: tableSecret, - Table: &memdb.TableSchema{ - Name: tableSecret, - Indexes: map[string]*memdb.IndexSchema{ - indexID: { - Name: indexID, - Unique: true, - Indexer: secretIndexerByID{}, - }, - indexName: { - Name: indexName, - Unique: true, - Indexer: secretIndexerByName{}, - }, - }, - }, - Save: func(tx ReadTx, snapshot *api.StoreSnapshot) error { - var err error - snapshot.Secrets, err = FindSecrets(tx, All) - return err - }, - Restore: func(tx Tx, snapshot *api.StoreSnapshot) error { - secrets, err := FindSecrets(tx, All) - if err != nil { - return err - } - for _, s := range secrets { - if err := DeleteSecret(tx, s.ID); err != nil { - return err - } - } - for _, s := range snapshot.Secrets { - if err := CreateSecret(tx, s); err != nil { - return err - } - } - return nil - }, - ApplyStoreAction: func(tx Tx, sa *api.StoreAction) error { - switch v := sa.Target.(type) { - case *api.StoreAction_Secret: - obj := v.Secret - switch sa.Action { - case api.StoreActionKindCreate: - return CreateSecret(tx, obj) - case api.StoreActionKindUpdate: - return UpdateSecret(tx, obj) - case api.StoreActionKindRemove: - return DeleteSecret(tx, obj.ID) - } - } - return errUnknownStoreAction - }, - NewStoreAction: func(c state.Event) (api.StoreAction, error) { - var sa api.StoreAction - switch v := c.(type) { - case state.EventCreateSecret: - sa.Action = api.StoreActionKindCreate - sa.Target = &api.StoreAction_Secret{ - Secret: v.Secret, - } - case state.EventUpdateSecret: - sa.Action = api.StoreActionKindUpdate - sa.Target = &api.StoreAction_Secret{ - Secret: v.Secret, - } - case state.EventDeleteSecret: - sa.Action = api.StoreActionKindRemove - sa.Target = &api.StoreAction_Secret{ - Secret: v.Secret, - } - default: - return api.StoreAction{}, errUnknownStoreAction - } - return sa, nil - }, - }) -} - -type secretEntry struct { - *api.Secret -} - -func (s secretEntry) ID() string { - return s.Secret.ID -} - -func (s secretEntry) Meta() api.Meta { - return s.Secret.Meta -} - -func (s secretEntry) SetMeta(meta api.Meta) { - s.Secret.Meta = meta -} - -func (s secretEntry) Copy() Object { - return secretEntry{s.Secret.Copy()} -} - -func (s secretEntry) EventCreate() state.Event { - return state.EventCreateSecret{Secret: s.Secret} -} - -func (s secretEntry) EventUpdate() state.Event { - return state.EventUpdateSecret{Secret: s.Secret} -} - -func (s secretEntry) EventDelete() state.Event { - return state.EventDeleteSecret{Secret: s.Secret} -} - -// CreateSecret adds a new secret to the store. -// Returns ErrExist if the ID is already taken. -func CreateSecret(tx Tx, s *api.Secret) error { - // Ensure the name is not already in use. - if tx.lookup(tableSecret, indexName, strings.ToLower(s.Spec.Annotations.Name)) != nil { - return ErrNameConflict - } - - return tx.create(tableSecret, secretEntry{s}) -} - -// UpdateSecret updates an existing secret in the store. -// Returns ErrNotExist if the secret doesn't exist. -func UpdateSecret(tx Tx, s *api.Secret) error { - // Ensure the name is either not in use or already used by this same Secret. - if existing := tx.lookup(tableSecret, indexName, strings.ToLower(s.Spec.Annotations.Name)); existing != nil { - if existing.ID() != s.ID { - return ErrNameConflict - } - } - - return tx.update(tableSecret, secretEntry{s}) -} - -// DeleteSecret removes a secret from the store. -// Returns ErrNotExist if the secret doesn't exist. -func DeleteSecret(tx Tx, id string) error { - return tx.delete(tableSecret, id) -} - -// GetSecret looks up a secret by ID. -// Returns nil if the secret doesn't exist. -func GetSecret(tx ReadTx, id string) *api.Secret { - n := tx.get(tableSecret, id) - if n == nil { - return nil - } - return n.(secretEntry).Secret -} - -// FindSecrets selects a set of secrets and returns them. -func FindSecrets(tx ReadTx, by By) ([]*api.Secret, error) { - checkType := func(by By) error { - switch by.(type) { - case byName, byNamePrefix, byIDPrefix: - return nil - default: - return ErrInvalidFindBy - } - } - - secretList := []*api.Secret{} - appendResult := func(o Object) { - secretList = append(secretList, o.(secretEntry).Secret) - } - - err := tx.find(tableSecret, by, checkType, appendResult) - return secretList, err -} - -type secretIndexerByID struct{} - -func (ci secretIndexerByID) FromArgs(args ...interface{}) ([]byte, error) { - return fromArgs(args...) -} - -func (ci secretIndexerByID) FromObject(obj interface{}) (bool, []byte, error) { - s, ok := obj.(secretEntry) - if !ok { - panic("unexpected type passed to FromObject") - } - - // Add the null character as a terminator - val := s.Secret.ID + "\x00" - return true, []byte(val), nil -} - -func (ci secretIndexerByID) PrefixFromArgs(args ...interface{}) ([]byte, error) { - return prefixFromArgs(args...) -} - -type secretIndexerByName struct{} - -func (ci secretIndexerByName) FromArgs(args ...interface{}) ([]byte, error) { - return fromArgs(args...) -} - -func (ci secretIndexerByName) FromObject(obj interface{}) (bool, []byte, error) { - s, ok := obj.(secretEntry) - if !ok { - panic("unexpected type passed to FromObject") - } - - // Add the null character as a terminator - return true, []byte(strings.ToLower(s.Spec.Annotations.Name) + "\x00"), nil -} - -func (ci secretIndexerByName) PrefixFromArgs(args ...interface{}) ([]byte, error) { - return prefixFromArgs(args...) -} diff --git a/manager/state/watch.go b/manager/state/watch.go index cf1f29b5e1..0d0a742c4d 100644 --- a/manager/state/watch.go +++ b/manager/state/watch.go @@ -451,87 +451,6 @@ func (e EventDeleteCluster) matches(watchEvent events.Event) bool { return true } -// SecretCheckFunc is the type of function used to perform filtering checks on -// api.Secret structures. -type SecretCheckFunc func(v1, v2 *api.Secret) bool - -// SecretCheckID is a SecretCheckFunc for matching volume IDs. -func SecretCheckID(v1, v2 *api.Secret) bool { - return v1.ID == v2.ID -} - -// EventCreateSecret is the type used to put CreateSecret events on the -// publish/subscribe queue and filter these events in calls to Watch. -type EventCreateSecret struct { - Secret *api.Secret - // Checks is a list of functions to call to filter events for a watch - // stream. They are applied with AND logic. They are only applicable for - // calls to Watch. - Checks []SecretCheckFunc -} - -func (e EventCreateSecret) matches(watchEvent events.Event) bool { - typedEvent, ok := watchEvent.(EventCreateSecret) - if !ok { - return false - } - - for _, check := range e.Checks { - if !check(e.Secret, typedEvent.Secret) { - return false - } - } - return true -} - -// EventUpdateSecret is the type used to put UpdateSecret events on the -// publish/subscribe queue and filter these events in calls to Watch. -type EventUpdateSecret struct { - Secret *api.Secret - // Checks is a list of functions to call to filter events for a watch - // stream. They are applied with AND logic. They are only applicable for - // calls to Watch. - Checks []SecretCheckFunc -} - -func (e EventUpdateSecret) matches(watchEvent events.Event) bool { - typedEvent, ok := watchEvent.(EventUpdateSecret) - if !ok { - return false - } - - for _, check := range e.Checks { - if !check(e.Secret, typedEvent.Secret) { - return false - } - } - return true -} - -// EventDeleteSecret is the type used to put DeleteSecret events on the -// publish/subscribe queue and filter these events in calls to Watch. -type EventDeleteSecret struct { - Secret *api.Secret - // Checks is a list of functions to call to filter events for a watch - // stream. They are applied with AND logic. They are only applicable for - // calls to Watch. - Checks []SecretCheckFunc -} - -func (e EventDeleteSecret) matches(watchEvent events.Event) bool { - typedEvent, ok := watchEvent.(EventDeleteSecret) - if !ok { - return false - } - - for _, check := range e.Checks { - if !check(e.Secret, typedEvent.Secret) { - return false - } - } - return true -} - // Watch takes a variable number of events to match against. The subscriber // will receive events that match any of the arguments passed to Watch. // From ee24218cacee3c6ac502de3d943a65bdea2afee9 Mon Sep 17 00:00:00 2001 From: Diogo Monica Date: Thu, 18 Aug 2016 14:40:51 -0700 Subject: [PATCH 03/10] Changing the agent to use Assignments instead of Tasks Signed-off-by: Diogo Monica --- agent/agent.go | 6 +-- agent/session.go | 30 ++++++------ agent/worker.go | 116 +++++++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 131 insertions(+), 21 deletions(-) diff --git a/agent/agent.go b/agent/agent.go index a5750e22ca..e0ea2ab73f 100644 --- a/agent/agent.go +++ b/agent/agent.go @@ -168,9 +168,9 @@ func (a *Agent) run(ctx context.Context) { select { case operation := <-sessionq: operation.response <- operation.fn(session) - case msg := <-session.tasks: - if err := a.worker.Assign(ctx, msg.Tasks); err != nil { - log.G(ctx).WithError(err).Error("task assignment failed") + case msg := <-session.assignments: + if err := a.worker.Update(ctx, msg.UpdateTasks, msg.RemoveTasks, msg.Type); err != nil { + log.G(ctx).WithError(err).Error("failed to update worker assignments") } case msg := <-session.messages: if err := a.handleSessionMessage(ctx, msg); err != nil { diff --git a/agent/session.go b/agent/session.go index c720a54f0c..9a0e5742b1 100644 --- a/agent/session.go +++ b/agent/session.go @@ -31,12 +31,12 @@ type session struct { conn *grpc.ClientConn addr string - agent *Agent - sessionID string - session api.Dispatcher_SessionClient - errs chan error - messages chan *api.SessionMessage - tasks chan *api.TasksMessage + agent *Agent + sessionID string + session api.Dispatcher_SessionClient + errs chan error + messages chan *api.SessionMessage + assignments chan *api.AssignmentsMessage registered chan struct{} // closed registration closed chan struct{} @@ -44,13 +44,13 @@ type session struct { func newSession(ctx context.Context, agent *Agent, delay time.Duration, sessionID string, description *api.NodeDescription) *session { s := &session{ - agent: agent, - sessionID: sessionID, - errs: make(chan error, 1), - messages: make(chan *api.SessionMessage), - tasks: make(chan *api.TasksMessage), - registered: make(chan struct{}), - closed: make(chan struct{}), + agent: agent, + sessionID: sessionID, + errs: make(chan error, 1), + messages: make(chan *api.SessionMessage), + assignments: make(chan *api.AssignmentsMessage), + registered: make(chan struct{}), + closed: make(chan struct{}), } peer, err := agent.config.Managers.Select() if err != nil { @@ -207,7 +207,7 @@ func (s *session) handleSessionMessage(ctx context.Context, msg *api.SessionMess func (s *session) watch(ctx context.Context) error { log.G(ctx).Debugf("(*session).watch") client := api.NewDispatcherClient(s.conn) - watch, err := client.Tasks(ctx, &api.TasksRequest{ + watch, err := client.Assignments(ctx, &api.AssignmentsRequest{ SessionID: s.sessionID}) if err != nil { return err @@ -220,7 +220,7 @@ func (s *session) watch(ctx context.Context) error { } select { - case s.tasks <- resp: + case s.assignments <- resp: case <-s.closed: return errSessionClosed case <-ctx.Done(): diff --git a/agent/worker.go b/agent/worker.go index 80e9ab07ab..b4d97fa22c 100644 --- a/agent/worker.go +++ b/agent/worker.go @@ -17,9 +17,8 @@ type Worker interface { // Init prepares the worker for task assignment. Init(ctx context.Context) error - // Assign the set of tasks to the worker. Tasks outside of this set will be - // removed. - Assign(ctx context.Context, tasks []*api.Task) error + // Update the set of tasks to the worker. + Update(ctx context.Context, added []*api.Task, removed []string, mode api.AssignmentsMessage_AssignmentType) error // Listen to updates about tasks controlled by the worker. When first // called, the reporter will receive all updates for all tasks controlled @@ -169,6 +168,117 @@ func (w *worker) Assign(ctx context.Context, tasks []*api.Task) error { return tx.Commit() } +// Update the set of tasks to the worker. +// Tasks in the added set will be added to the worker, and tasks in the removed set +// will be removed from the worker +func (w *worker) Update(ctx context.Context, added []*api.Task, removed []string, mode api.AssignmentsMessage_AssignmentType) error { + w.mu.Lock() + defer w.mu.Unlock() + + tx, err := w.db.Begin(true) + if err != nil { + log.G(ctx).WithError(err).Error("failed starting transaction against task database") + return err + } + defer tx.Rollback() + + log.G(ctx).WithField("len(added)", len(added)).WithField("len(removed)", len(removed)).Debug("(*worker).Update") + assigned := map[string]struct{}{} + + for _, task := range added { + log.G(ctx).WithFields( + logrus.Fields{ + "task.id": task.ID, + "task.desiredstate": task.DesiredState}).Debug("assigned") + if err := PutTask(tx, task); err != nil { + return err + } + + if err := SetTaskAssignment(tx, task.ID, true); err != nil { + return err + } + + if mgr, ok := w.taskManagers[task.ID]; ok { + if err := mgr.Update(ctx, task); err != nil && err != ErrClosed { + log.G(ctx).WithError(err).Error("failed updating assigned task") + } + } else { + // we may have still seen the task, let's grab the status from + // storage and replace it with our status, if we have it. + status, err := GetTaskStatus(tx, task.ID) + if err != nil { + if err != errTaskUnknown { + return err + } + + // never seen before, register the provided status + if err := PutTaskStatus(tx, task.ID, &task.Status); err != nil { + return err + } + + status = &task.Status + } else { + task.Status = *status // overwrite the stale manager status with ours. + } + + w.startTask(ctx, tx, task) + } + + assigned[task.ID] = struct{}{} + } + + closeManager := func(tm *taskManager) { + // when a task is no longer assigned, we shutdown the task manager for + // it and leave cleanup to the sweeper. + if err := tm.Close(); err != nil { + log.G(ctx).WithError(err).Error("error closing task manager") + } + } + + removeTaskAssignment := func(taskID string) error { + ctx := log.WithLogger(ctx, log.G(ctx).WithField("task.id", taskID)) + if err := SetTaskAssignment(tx, taskID, false); err != nil { + log.G(ctx).WithError(err).Error("error setting task assignment in database") + } + return err + } + + // If this was a complete set of assignments, we're going to remove all the remaining + // tasks. + if mode == api.AssignmentsMessage_COMPLETE { + for id, tm := range w.taskManagers { + if _, ok := assigned[id]; ok { + continue + } + + err := removeTaskAssignment(id) + if err == nil { + delete(w.taskManagers, id) + go closeManager(tm) + } + } + } + + // If this was an incremental set of assignments, we're going to remove only the tasks + // in the removed set + if mode == api.AssignmentsMessage_INCREMENTAL { + for _, taskID := range removed { + err := removeTaskAssignment(taskID) + if err != nil { + continue + } + + tm, ok := w.taskManagers[taskID] + if ok { + delete(w.taskManagers, taskID) + go closeManager(tm) + } + } + } + + return tx.Commit() +} + func (w *worker) Listen(ctx context.Context, reporter StatusReporter) { w.mu.Lock() defer w.mu.Unlock() From 2a2ffed9a1ee6d7f284ca2007c874e9a0ac179b6 Mon Sep 17 00:00:00 2001 From: Diogo Monica Date: Fri, 19 Aug 2016 16:07:17 -0700 Subject: [PATCH 04/10] Adding fallback from Assignments to tasks Signed-off-by: Diogo Monica --- agent/session.go | 33 +++++++++++++++++++++++++++------ agent/worker.go | 6 +++++- 2 files changed, 32 insertions(+), 7 deletions(-) diff --git a/agent/session.go b/agent/session.go index 9a0e5742b1..fd49941159 100644 --- a/agent/session.go +++ b/agent/session.go @@ -4,6 +4,7 @@ import ( "errors" "time" + "github.com/Sirupsen/logrus" "github.com/docker/swarmkit/api" "github.com/docker/swarmkit/log" "github.com/docker/swarmkit/protobuf/ptypes" @@ -205,18 +206,38 @@ func (s *session) handleSessionMessage(ctx context.Context, msg *api.SessionMess } func (s *session) watch(ctx context.Context) error { - log.G(ctx).Debugf("(*session).watch") + log := log.G(ctx).WithFields(logrus.Fields{"method": "(*session).watch"}) + log.Debugf("") + var ( + tasksWatch api.Dispatcher_TasksClient + resp *api.AssignmentsMessage + ) client := api.NewDispatcherClient(s.conn) - watch, err := client.Assignments(ctx, &api.AssignmentsRequest{ - SessionID: s.sessionID}) + assignmentWatch, err := client.Assignments(ctx, &api.AssignmentsRequest{SessionID: s.sessionID}) if err != nil { return err } for { - resp, err := watch.Recv() - if err != nil { - return err + if assignmentWatch != nil { + resp, err = assignmentWatch.Recv() + // If we get a code = 12 desc = unknown method Assignments, try to use tasks + if err != nil && grpc.Code(err) == codes.Unimplemented { + log.WithError(err).Errorf("falling back to Tasks") + assignmentWatch = nil + tasksWatch, err = client.Tasks(ctx, &api.TasksRequest{SessionID: s.sessionID}) + } + if err != nil { + return err + } + } + if tasksWatch != nil { + var taskResp *api.TasksMessage + taskResp, err = tasksWatch.Recv() + if err != nil { + return err + } + resp = &api.AssignmentsMessage{Type: api.AssignmentsMessage_COMPLETE, UpdateTasks: taskResp.Tasks} } select { diff --git a/agent/worker.go b/agent/worker.go index b4d97fa22c..45df999737 100644 --- a/agent/worker.go +++ b/agent/worker.go @@ -182,7 +182,11 @@ func (w *worker) Update(ctx context.Context, added []*api.Task, removed []string } defer tx.Rollback() - log.G(ctx).WithField("len(added)", len(added)).WithField("len(removed)", len(removed)).Debug("(*worker).Update") + log.G(ctx).WithFields(logrus.Fields{ + "len(added)": len(added), + "len(removed)": len(removed), + "mode": mode.String(), + }).Debug("(*worker).Update") assigned := map[string]struct{}{} for _, task := range added { From e997eb299747b7701fe1bd70df76d670f75b6aa3 Mon Sep 17 00:00:00 2001 From: cyli Date: Wed, 7 Sep 2016 13:52:33 -0700 Subject: [PATCH 05/10] Minor cleanup from a cherry-picked commit Signed-off-by: cyli --- agent/worker.go | 74 ++------------------------------ manager/dispatcher/dispatcher.go | 18 +++++--- 2 files changed, 16 insertions(+), 76 deletions(-) diff --git a/agent/worker.go b/agent/worker.go index 45df999737..9afd9fcf15 100644 --- a/agent/worker.go +++ b/agent/worker.go @@ -93,77 +93,9 @@ func (w *worker) Assign(ctx context.Context, tasks []*api.Task) error { w.mu.Lock() defer w.mu.Unlock() - tx, err := w.db.Begin(true) - if err != nil { - log.G(ctx).WithError(err).Error("failed starting transaction against task database") - return err - } - defer tx.Rollback() - - log.G(ctx).WithField("len(tasks)", len(tasks)).Debug("(*worker).Assign") - assigned := map[string]struct{}{} - - for _, task := range tasks { - log.G(ctx).WithFields( - logrus.Fields{ - "task.id": task.ID, - "task.desiredstate": task.DesiredState}).Debug("assigned") - if err := PutTask(tx, task); err != nil { - return err - } - - if err := SetTaskAssignment(tx, task.ID, true); err != nil { - return err - } - - if mgr, ok := w.taskManagers[task.ID]; ok { - if err := mgr.Update(ctx, task); err != nil && err != ErrClosed { - log.G(ctx).WithError(err).Error("failed updating assigned task") - } - } else { - // we may have still seen the task, let's grab the status from - // storage and replace it with our status, if we have it. - status, err := GetTaskStatus(tx, task.ID) - if err != nil { - if err != errTaskUnknown { - return err - } - - // never seen before, register the provided status - if err := PutTaskStatus(tx, task.ID, &task.Status); err != nil { - return err - } - } else { - task.Status = *status // overwrite the stale manager status with ours. - } - - w.startTask(ctx, tx, task) - } - - assigned[task.ID] = struct{}{} - } - - for id, tm := range w.taskManagers { - if _, ok := assigned[id]; ok { - continue - } - - ctx := log.WithLogger(ctx, log.G(ctx).WithField("task.id", id)) - if err := SetTaskAssignment(tx, id, false); err != nil { - log.G(ctx).WithError(err).Error("error setting task assignment in database") - continue - } - - delete(w.taskManagers, id) - - go func(tm *taskManager) { - // when a task is no longer assigned, we shutdown the task manager for - // it and leave cleanup to the sweeper. - if err := tm.Close(); err != nil { - log.G(ctx).WithError(err).Error("error closing task manager") - } - }(tm) - } + log.G(ctx).WithFields(logrus.Fields{ + "len(tasks)": len(tasks), + }).Debug("(*worker).Assign") return tx.Commit() } diff --git a/manager/dispatcher/dispatcher.go b/manager/dispatcher/dispatcher.go index 72290f7a56..ef94ee3539 100644 --- a/manager/dispatcher/dispatcher.go +++ b/manager/dispatcher/dispatcher.go @@ -817,13 +817,14 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche return err } - var update api.AssignmentsMessage - // bursty events should be processed in batches and sent out together var ( + update api.AssignmentsMessage modificationCnt int batchingTimer *time.Timer batchingTimeout <-chan time.Time + updateTasks = make(map[string]*api.Task) + removeTasks = make(map[string]struct{}) ) oneModification := func() { @@ -858,8 +859,6 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche continue } - update.UpdateTasks = append(update.UpdateTasks, v.Task) - if oldTask, exists := tasksMap[v.Task.ID]; exists { // States ASSIGNED and below are set by the orchestrator/scheduler, // not the agent, so tasks in these states need to be sent to the @@ -871,6 +870,7 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche } } tasksMap[v.Task.ID] = v.Task + updateTasks[v.Task.ID] = v.Task oneModification() case state.EventDeleteTask: @@ -878,7 +878,7 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche continue } - update.RemoveTasks = append(update.RemoveTasks, v.Task.ID) + removeTasks[v.Task.ID] = struct{}{} delete(tasksMap, v.Task.ID) @@ -898,6 +898,14 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche } if modificationCnt > 0 { + for id, task := range updateTasks { + if _, ok := removeTasks[id]; !ok { + update.UpdateTasks = append(update.UpdateTasks, task) + } + } + for id := range removeTasks { + update.RemoveTasks = append(update.RemoveTasks, id) + } if err := sendMessage(update, api.AssignmentsMessage_INCREMENTAL); err != nil { return err } From 4dc641a60941f01813cdc6f225dea7e662eb9d35 Mon Sep 17 00:00:00 2001 From: Diogo Monica Date: Mon, 29 Aug 2016 16:33:37 -0700 Subject: [PATCH 06/10] Changing protos and addressing comments (removed the proto parts - cyli) Signed-off-by: Diogo Monica Signed-off-by: cyli --- agent/agent.go | 11 +++++++++-- agent/worker.go | 42 +++++++++++++++++++++++------------------- 2 files changed, 32 insertions(+), 21 deletions(-) diff --git a/agent/agent.go b/agent/agent.go index e0ea2ab73f..f1c3686e64 100644 --- a/agent/agent.go +++ b/agent/agent.go @@ -169,8 +169,15 @@ func (a *Agent) run(ctx context.Context) { case operation := <-sessionq: operation.response <- operation.fn(session) case msg := <-session.assignments: - if err := a.worker.Update(ctx, msg.UpdateTasks, msg.RemoveTasks, msg.Type); err != nil { - log.G(ctx).WithError(err).Error("failed to update worker assignments") + switch msg.Type { + case api.AssignmentsMessage_COMPLETE: + if err := a.worker.Assign(ctx, msg.UpdateTasks); err != nil { + log.G(ctx).WithError(err).Error("failed to assign worker assignments") + } + case api.AssignmentsMessage_INCREMENTAL: + if err := a.worker.Update(ctx, msg.UpdateTasks, msg.RemoveTasks); err != nil { + log.G(ctx).WithError(err).Error("failed to update worker assignments") + } } case msg := <-session.messages: if err := a.handleSessionMessage(ctx, msg); err != nil { diff --git a/agent/worker.go b/agent/worker.go index 9afd9fcf15..d99e77ff0e 100644 --- a/agent/worker.go +++ b/agent/worker.go @@ -17,8 +17,13 @@ type Worker interface { // Init prepares the worker for task assignment. Init(ctx context.Context) error - // Update the set of tasks to the worker. - Update(ctx context.Context, added []*api.Task, removed []string, mode api.AssignmentsMessage_AssignmentType) error + // Assign a complete set of tasks to a worker. Any task not included in + // this set will be removed. + Assign(ctx context.Context, tasks []*api.Task) error + + // Update an incremental set of tasks to the worker. Any task not included + // either in added or removed will remain untouched. + Update(ctx context.Context, added []*api.Task, removed []string) error // Listen to updates about tasks controlled by the worker. When first // called, the reporter will receive all updates for all tasks controlled @@ -97,16 +102,25 @@ func (w *worker) Assign(ctx context.Context, tasks []*api.Task) error { "len(tasks)": len(tasks), }).Debug("(*worker).Assign") - return tx.Commit() + return reconcileTaskState(ctx, w, tasks, nil, true) } // Update the set of tasks to the worker. // Tasks in the added set will be added to the worker, and tasks in the removed set // will be removed from the worker -func (w *worker) Update(ctx context.Context, added []*api.Task, removed []string, mode api.AssignmentsMessage_AssignmentType) error { +func (w *worker) Update(ctx context.Context, added []*api.Task, removed []string) error { w.mu.Lock() defer w.mu.Unlock() + log.G(ctx).WithFields(logrus.Fields{ + "len(added)": len(added), + "len(removed)": len(removed), + }).Debug("(*worker).Update") + + return reconcileTaskState(ctx, w, added, removed, false) +} + +func reconcileTaskState(ctx context.Context, w *worker, added []*api.Task, removed []string, full_snapshot bool) error { tx, err := w.db.Begin(true) if err != nil { log.G(ctx).WithError(err).Error("failed starting transaction against task database") @@ -114,11 +128,6 @@ func (w *worker) Update(ctx context.Context, added []*api.Task, removed []string } defer tx.Rollback() - log.G(ctx).WithFields(logrus.Fields{ - "len(added)": len(added), - "len(removed)": len(removed), - "mode": mode.String(), - }).Debug("(*worker).Update") assigned := map[string]struct{}{} for _, task := range added { @@ -151,12 +160,9 @@ func (w *worker) Update(ctx context.Context, added []*api.Task, removed []string if err := PutTaskStatus(tx, task.ID, &task.Status); err != nil { return err } - - status = &task.Status } else { - task.Status = *status // overwrite the stale manager status with ours. + task.Status = *status } - w.startTask(ctx, tx, task) } @@ -181,7 +187,7 @@ func (w *worker) Update(ctx context.Context, added []*api.Task, removed []string // If this was a complete set of assignments, we're going to remove all the remaining // tasks. - if mode == api.AssignmentsMessage_COMPLETE { + if full_snapshot { for id, tm := range w.taskManagers { if _, ok := assigned[id]; ok { continue @@ -193,11 +199,9 @@ func (w *worker) Update(ctx context.Context, added []*api.Task, removed []string go closeManager(tm) } } - } - - // If this was an incremental set of assignments, we're going to remove only the tasks - // in the removed set - if mode == api.AssignmentsMessage_INCREMENTAL { + } else { + // If this was an incremental set of assignments, we're going to remove only the tasks + // in the removed set for _, taskID := range removed { err := removeTaskAssignment(taskID) if err != nil { From 3dd13bf78390ffa3659981a99e274ca71349dc5b Mon Sep 17 00:00:00 2001 From: Diogo Monica Date: Mon, 29 Aug 2016 20:38:52 -0700 Subject: [PATCH 07/10] Fixed small bug in Assignments and changed tests from Tasks to Assignments Signed-off-by: Diogo Monica --- agent/session.go | 43 +++++++++++++++----- manager/dispatcher/dispatcher.go | 5 ++- manager/dispatcher/dispatcher_test.go | 56 +++++++++++++++++++-------- 3 files changed, 75 insertions(+), 29 deletions(-) diff --git a/agent/session.go b/agent/session.go index fd49941159..e1d43be6b2 100644 --- a/agent/session.go +++ b/agent/session.go @@ -209,24 +209,39 @@ func (s *session) watch(ctx context.Context) error { log := log.G(ctx).WithFields(logrus.Fields{"method": "(*session).watch"}) log.Debugf("") var ( - tasksWatch api.Dispatcher_TasksClient - resp *api.AssignmentsMessage + resp *api.AssignmentsMessage + assignmentWatch api.Dispatcher_AssignmentsClient + tasksWatch api.Dispatcher_TasksClient + streamReference string + tasksFallback bool + err error ) - client := api.NewDispatcherClient(s.conn) - assignmentWatch, err := client.Assignments(ctx, &api.AssignmentsRequest{SessionID: s.sessionID}) - if err != nil { - return err - } + client := api.NewDispatcherClient(s.conn) for { + // If this is the first time we're running the loop, or there was a reference mismatch + // attempt to get the assignmentWatch + if assignmentWatch == nil && !tasksFallback { + assignmentWatch, err = client.Assignments(ctx, &api.AssignmentsRequest{SessionID: s.sessionID}) + if err != nil { + return err + } + } + // We have an assignmentWatch, let's try to receive an AssignmentMessage if assignmentWatch != nil { - resp, err = assignmentWatch.Recv() // If we get a code = 12 desc = unknown method Assignments, try to use tasks + resp, err = assignmentWatch.Recv() if err != nil && grpc.Code(err) == codes.Unimplemented { - log.WithError(err).Errorf("falling back to Tasks") + tasksFallback = true assignmentWatch = nil - tasksWatch, err = client.Tasks(ctx, &api.TasksRequest{SessionID: s.sessionID}) + log.WithError(err).Errorf("falling back to Tasks") } + } + + // This code is here for backwards compatibility (so that newer clients can use the + // older method Tasks) + if tasksWatch == nil && tasksFallback { + tasksWatch, err = client.Tasks(ctx, &api.TasksRequest{SessionID: s.sessionID}) if err != nil { return err } @@ -240,6 +255,14 @@ func (s *session) watch(ctx context.Context) error { resp = &api.AssignmentsMessage{Type: api.AssignmentsMessage_COMPLETE, UpdateTasks: taskResp.Tasks} } + // If there seems to be a gap in the stream, let's break out of the inner for and + // re-sync (by calling Assignments again). + if streamReference != "" && streamReference != resp.AppliesTo { + assignmentWatch = nil + } else { + streamReference = resp.ResultsIn + } + select { case s.assignments <- resp: case <-s.closed: diff --git a/manager/dispatcher/dispatcher.go b/manager/dispatcher/dispatcher.go index ef94ee3539..b5a8ea4828 100644 --- a/manager/dispatcher/dispatcher.go +++ b/manager/dispatcher/dispatcher.go @@ -43,8 +43,8 @@ const ( // right. maxBatchInterval = 100 * time.Millisecond - modificationBatchLimit = 200 - batchingWaitTime = 50 * time.Millisecond + modificationBatchLimit = 100 + batchingWaitTime = 100 * time.Millisecond ) var ( @@ -874,6 +874,7 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche oneModification() case state.EventDeleteTask: + if _, exists := tasksMap[v.Task.ID]; !exists { continue } diff --git a/manager/dispatcher/dispatcher_test.go b/manager/dispatcher/dispatcher_test.go index 9ca1fb3dfc..5f961ab0d5 100644 --- a/manager/dispatcher/dispatcher_test.go +++ b/manager/dispatcher/dispatcher_test.go @@ -360,7 +360,7 @@ func TestTasks(t *testing.T) { { // without correct SessionID should fail - stream, err := gd.Clients[0].Tasks(context.Background(), &api.TasksRequest{}) + stream, err := gd.Clients[0].Assignments(context.Background(), &api.AssignmentsRequest{}) assert.NoError(t, err) assert.NotNil(t, stream) resp, err := stream.Recv() @@ -369,7 +369,7 @@ func TestTasks(t *testing.T) { assert.Equal(t, grpc.Code(err), codes.InvalidArgument) } - stream, err := gd.Clients[0].Tasks(context.Background(), &api.TasksRequest{SessionID: expectedSessionID}) + stream, err := gd.Clients[0].Assignments(context.Background(), &api.AssignmentsRequest{SessionID: expectedSessionID}) assert.NoError(t, err) time.Sleep(100 * time.Millisecond) @@ -377,19 +377,26 @@ func TestTasks(t *testing.T) { resp, err := stream.Recv() assert.NoError(t, err) // initially no tasks - assert.Equal(t, 0, len(resp.Tasks)) + assert.Equal(t, 0, len(resp.UpdateTasks)) + // Creating the tasks will not create an event for assignments err = gd.Store.Update(func(tx store.Tx) error { assert.NoError(t, store.CreateTask(tx, testTask1)) assert.NoError(t, store.CreateTask(tx, testTask2)) return nil }) assert.NoError(t, err) + err = gd.Store.Update(func(tx store.Tx) error { + assert.NoError(t, store.UpdateTask(tx, testTask1)) + assert.NoError(t, store.UpdateTask(tx, testTask2)) + return nil + }) + assert.NoError(t, err) resp, err = stream.Recv() assert.NoError(t, err) - assert.Equal(t, len(resp.Tasks), 2) - assert.True(t, resp.Tasks[0].ID == "testTask1" && resp.Tasks[1].ID == "testTask2" || resp.Tasks[0].ID == "testTask2" && resp.Tasks[1].ID == "testTask1") + assert.Equal(t, len(resp.UpdateTasks), 2) + assert.True(t, resp.UpdateTasks[0].ID == "testTask1" && resp.UpdateTasks[1].ID == "testTask2" || resp.UpdateTasks[0].ID == "testTask2" && resp.UpdateTasks[1].ID == "testTask1") err = gd.Store.Update(func(tx store.Tx) error { assert.NoError(t, store.UpdateTask(tx, &api.Task{ @@ -404,8 +411,8 @@ func TestTasks(t *testing.T) { resp, err = stream.Recv() assert.NoError(t, err) - assert.Equal(t, len(resp.Tasks), 2) - for _, task := range resp.Tasks { + assert.Equal(t, 1, len(resp.UpdateTasks)) + for _, task := range resp.UpdateTasks { if task.ID == "testTask1" { assert.Equal(t, task.DesiredState, api.TaskStateRunning) } @@ -420,7 +427,7 @@ func TestTasks(t *testing.T) { resp, err = stream.Recv() assert.NoError(t, err) - assert.Equal(t, len(resp.Tasks), 0) + assert.Equal(t, len(resp.UpdateTasks), 0) } func TestTasksStatusChange(t *testing.T) { @@ -456,7 +463,7 @@ func TestTasksStatusChange(t *testing.T) { { // without correct SessionID should fail - stream, err := gd.Clients[0].Tasks(context.Background(), &api.TasksRequest{}) + stream, err := gd.Clients[0].Assignments(context.Background(), &api.AssignmentsRequest{}) assert.NoError(t, err) assert.NotNil(t, stream) resp, err := stream.Recv() @@ -465,7 +472,7 @@ func TestTasksStatusChange(t *testing.T) { assert.Equal(t, grpc.Code(err), codes.InvalidArgument) } - stream, err := gd.Clients[0].Tasks(context.Background(), &api.TasksRequest{SessionID: expectedSessionID}) + stream, err := gd.Clients[0].Assignments(context.Background(), &api.AssignmentsRequest{SessionID: expectedSessionID}) assert.NoError(t, err) time.Sleep(100 * time.Millisecond) @@ -473,19 +480,26 @@ func TestTasksStatusChange(t *testing.T) { resp, err := stream.Recv() assert.NoError(t, err) // initially no tasks - assert.Equal(t, 0, len(resp.Tasks)) + assert.Equal(t, 0, len(resp.UpdateTasks)) + // Creating the tasks will not create an event for assignments err = gd.Store.Update(func(tx store.Tx) error { assert.NoError(t, store.CreateTask(tx, testTask1)) assert.NoError(t, store.CreateTask(tx, testTask2)) return nil }) assert.NoError(t, err) + err = gd.Store.Update(func(tx store.Tx) error { + assert.NoError(t, store.UpdateTask(tx, testTask1)) + assert.NoError(t, store.UpdateTask(tx, testTask2)) + return nil + }) + assert.NoError(t, err) resp, err = stream.Recv() assert.NoError(t, err) - assert.Equal(t, len(resp.Tasks), 2) - assert.True(t, resp.Tasks[0].ID == "testTask1" && resp.Tasks[1].ID == "testTask2" || resp.Tasks[0].ID == "testTask2" && resp.Tasks[1].ID == "testTask1") + assert.Equal(t, len(resp.UpdateTasks), 2) + assert.True(t, resp.UpdateTasks[0].ID == "testTask1" && resp.UpdateTasks[1].ID == "testTask2" || resp.UpdateTasks[0].ID == "testTask2" && resp.UpdateTasks[1].ID == "testTask1") err = gd.Store.Update(func(tx store.Tx) error { assert.NoError(t, store.UpdateTask(tx, &api.Task{ @@ -542,20 +556,27 @@ func TestTasksBatch(t *testing.T) { Status: api.TaskStatus{State: api.TaskStateAssigned}, } - stream, err := gd.Clients[0].Tasks(context.Background(), &api.TasksRequest{SessionID: expectedSessionID}) + stream, err := gd.Clients[0].Assignments(context.Background(), &api.AssignmentsRequest{SessionID: expectedSessionID}) assert.NoError(t, err) resp, err := stream.Recv() assert.NoError(t, err) // initially no tasks - assert.Equal(t, 0, len(resp.Tasks)) + assert.Equal(t, 0, len(resp.UpdateTasks)) + // Create, Update and Delete tasks. err = gd.Store.Update(func(tx store.Tx) error { assert.NoError(t, store.CreateTask(tx, testTask1)) assert.NoError(t, store.CreateTask(tx, testTask2)) return nil }) assert.NoError(t, err) + err = gd.Store.Update(func(tx store.Tx) error { + assert.NoError(t, store.UpdateTask(tx, testTask1)) + assert.NoError(t, store.UpdateTask(tx, testTask2)) + return nil + }) + assert.NoError(t, err) err = gd.Store.Update(func(tx store.Tx) error { assert.NoError(t, store.DeleteTask(tx, testTask1.ID)) @@ -567,7 +588,8 @@ func TestTasksBatch(t *testing.T) { resp, err = stream.Recv() assert.NoError(t, err) // all tasks have been deleted - assert.Equal(t, len(resp.Tasks), 0) + assert.Equal(t, len(resp.UpdateTasks), 0) + assert.Equal(t, len(resp.RemoveTasks), 2) } func TestTasksNoCert(t *testing.T) { @@ -575,7 +597,7 @@ func TestTasksNoCert(t *testing.T) { assert.NoError(t, err) defer gd.Close() - stream, err := gd.Clients[2].Tasks(context.Background(), &api.TasksRequest{}) + stream, err := gd.Clients[2].Assignments(context.Background(), &api.AssignmentsRequest{}) assert.NoError(t, err) assert.NotNil(t, stream) resp, err := stream.Recv() From e92692abd0b398b9ed7531c68e3d2746aa617a67 Mon Sep 17 00:00:00 2001 From: cyli Date: Wed, 7 Sep 2016 15:46:38 -0700 Subject: [PATCH 08/10] Cherry-picked a partial commit Signed-off-by: cyli --- agent/agent.go | 4 ++-- agent/session.go | 6 ++++-- agent/worker.go | 24 ++++++++++++------------ agent/worker_test.go | 2 +- manager/dispatcher/dispatcher.go | 2 +- 5 files changed, 20 insertions(+), 18 deletions(-) diff --git a/agent/agent.go b/agent/agent.go index f1c3686e64..8be494d9a3 100644 --- a/agent/agent.go +++ b/agent/agent.go @@ -171,11 +171,11 @@ func (a *Agent) run(ctx context.Context) { case msg := <-session.assignments: switch msg.Type { case api.AssignmentsMessage_COMPLETE: - if err := a.worker.Assign(ctx, msg.UpdateTasks); err != nil { + if err := a.worker.AssignTasks(ctx, msg.UpdateTasks); err != nil { log.G(ctx).WithError(err).Error("failed to assign worker assignments") } case api.AssignmentsMessage_INCREMENTAL: - if err := a.worker.Update(ctx, msg.UpdateTasks, msg.RemoveTasks); err != nil { + if err := a.worker.UpdateTasks(ctx, msg.UpdateTasks, msg.RemoveTasks); err != nil { log.G(ctx).WithError(err).Error("failed to update worker assignments") } } diff --git a/agent/session.go b/agent/session.go index e1d43be6b2..fdee18d883 100644 --- a/agent/session.go +++ b/agent/session.go @@ -231,7 +231,10 @@ func (s *session) watch(ctx context.Context) error { if assignmentWatch != nil { // If we get a code = 12 desc = unknown method Assignments, try to use tasks resp, err = assignmentWatch.Recv() - if err != nil && grpc.Code(err) == codes.Unimplemented { + if err != nil { + if grpc.Code(err) != codes.Unimplemented { + return err + } tasksFallback = true assignmentWatch = nil log.WithError(err).Errorf("falling back to Tasks") @@ -275,7 +278,6 @@ func (s *session) watch(ctx context.Context) error { // sendTaskStatus uses the current session to send the status of a single task. func (s *session) sendTaskStatus(ctx context.Context, taskID string, status *api.TaskStatus) error { - client := api.NewDispatcherClient(s.conn) if _, err := client.UpdateTaskStatus(ctx, &api.UpdateTaskStatusRequest{ SessionID: s.sessionID, diff --git a/agent/worker.go b/agent/worker.go index d99e77ff0e..f19c9c957b 100644 --- a/agent/worker.go +++ b/agent/worker.go @@ -17,13 +17,13 @@ type Worker interface { // Init prepares the worker for task assignment. Init(ctx context.Context) error - // Assign a complete set of tasks to a worker. Any task not included in + // AssignTasks assigns a complete set of tasks to a worker. Any task not included in // this set will be removed. - Assign(ctx context.Context, tasks []*api.Task) error + AssignTasks(ctx context.Context, tasks []*api.Task) error - // Update an incremental set of tasks to the worker. Any task not included + // UpdateTasks updates an incremental set of tasks to the worker. Any task not included // either in added or removed will remain untouched. - Update(ctx context.Context, added []*api.Task, removed []string) error + UpdateTasks(ctx context.Context, added []*api.Task, removed []string) error // Listen to updates about tasks controlled by the worker. When first // called, the reporter will receive all updates for all tasks controlled @@ -90,37 +90,37 @@ func (w *worker) Init(ctx context.Context) error { }) } -// Assign the set of tasks to the worker. Any tasks not previously known will +// AssignTasks assigns the set of tasks to the worker. Any tasks not previously known will // be started. Any tasks that are in the task set and already running will be // updated, if possible. Any tasks currently running on the // worker outside the task set will be terminated. -func (w *worker) Assign(ctx context.Context, tasks []*api.Task) error { +func (w *worker) AssignTasks(ctx context.Context, tasks []*api.Task) error { w.mu.Lock() defer w.mu.Unlock() log.G(ctx).WithFields(logrus.Fields{ "len(tasks)": len(tasks), - }).Debug("(*worker).Assign") + }).Debug("(*worker).AssignTasks") return reconcileTaskState(ctx, w, tasks, nil, true) } -// Update the set of tasks to the worker. +// UpdateTasks the set of tasks to the worker. // Tasks in the added set will be added to the worker, and tasks in the removed set // will be removed from the worker -func (w *worker) Update(ctx context.Context, added []*api.Task, removed []string) error { +func (w *worker) UpdateTasks(ctx context.Context, added []*api.Task, removed []string) error { w.mu.Lock() defer w.mu.Unlock() log.G(ctx).WithFields(logrus.Fields{ "len(added)": len(added), "len(removed)": len(removed), - }).Debug("(*worker).Update") + }).Debug("(*worker).UpdateTasks") return reconcileTaskState(ctx, w, added, removed, false) } -func reconcileTaskState(ctx context.Context, w *worker, added []*api.Task, removed []string, full_snapshot bool) error { +func reconcileTaskState(ctx context.Context, w *worker, added []*api.Task, removed []string, fullSnapshot bool) error { tx, err := w.db.Begin(true) if err != nil { log.G(ctx).WithError(err).Error("failed starting transaction against task database") @@ -187,7 +187,7 @@ func reconcileTaskState(ctx context.Context, w *worker, added []*api.Task, remov // If this was a complete set of assignments, we're going to remove all the remaining // tasks. - if full_snapshot { + if fullSnapshot { for id, tm := range w.taskManagers { if _, ok := assigned[id]; ok { continue diff --git a/agent/worker_test.go b/agent/worker_test.go index d554b88f57..9504074203 100644 --- a/agent/worker_test.go +++ b/agent/worker_test.go @@ -53,7 +53,7 @@ func TestWorker(t *testing.T) { // TODO(stevvooe): There are a few more states here we need to get // covered to ensure correct during code changes. } { - assert.NoError(t, worker.Assign(ctx, testcase.taskSet)) + assert.NoError(t, worker.AssignTasks(ctx, testcase.taskSet)) var ( tasks []*api.Task diff --git a/manager/dispatcher/dispatcher.go b/manager/dispatcher/dispatcher.go index b5a8ea4828..d6dea3ed83 100644 --- a/manager/dispatcher/dispatcher.go +++ b/manager/dispatcher/dispatcher.go @@ -864,7 +864,7 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche // not the agent, so tasks in these states need to be sent to the // agent even if nothing else has changed. if equality.TasksEqualStable(oldTask, v.Task) && v.Task.Status.State > api.TaskStateAssigned { - // this update should not trigger action at agent + // this update should not trigger a task change for the agent tasksMap[v.Task.ID] = v.Task continue } From c2d82f64384f9ececb98a9eeefcf8439b92ea650 Mon Sep 17 00:00:00 2001 From: cyli Date: Wed, 7 Sep 2016 15:46:38 -0700 Subject: [PATCH 09/10] Cherry-picked a partial commit Signed-off-by: cyli --- agent/agent.go | 4 +- agent/session.go | 6 +- agent/worker.go | 24 +++--- agent/worker_test.go | 2 +- api/dispatcher.pb.go | 126 +++++++++++++++---------------- api/dispatcher.proto | 4 +- manager/dispatcher/dispatcher.go | 4 +- 7 files changed, 86 insertions(+), 84 deletions(-) diff --git a/agent/agent.go b/agent/agent.go index f1c3686e64..8be494d9a3 100644 --- a/agent/agent.go +++ b/agent/agent.go @@ -171,11 +171,11 @@ func (a *Agent) run(ctx context.Context) { case msg := <-session.assignments: switch msg.Type { case api.AssignmentsMessage_COMPLETE: - if err := a.worker.Assign(ctx, msg.UpdateTasks); err != nil { + if err := a.worker.AssignTasks(ctx, msg.UpdateTasks); err != nil { log.G(ctx).WithError(err).Error("failed to assign worker assignments") } case api.AssignmentsMessage_INCREMENTAL: - if err := a.worker.Update(ctx, msg.UpdateTasks, msg.RemoveTasks); err != nil { + if err := a.worker.UpdateTasks(ctx, msg.UpdateTasks, msg.RemoveTasks); err != nil { log.G(ctx).WithError(err).Error("failed to update worker assignments") } } diff --git a/agent/session.go b/agent/session.go index e1d43be6b2..fdee18d883 100644 --- a/agent/session.go +++ b/agent/session.go @@ -231,7 +231,10 @@ func (s *session) watch(ctx context.Context) error { if assignmentWatch != nil { // If we get a code = 12 desc = unknown method Assignments, try to use tasks resp, err = assignmentWatch.Recv() - if err != nil && grpc.Code(err) == codes.Unimplemented { + if err != nil { + if grpc.Code(err) != codes.Unimplemented { + return err + } tasksFallback = true assignmentWatch = nil log.WithError(err).Errorf("falling back to Tasks") @@ -275,7 +278,6 @@ func (s *session) watch(ctx context.Context) error { // sendTaskStatus uses the current session to send the status of a single task. func (s *session) sendTaskStatus(ctx context.Context, taskID string, status *api.TaskStatus) error { - client := api.NewDispatcherClient(s.conn) if _, err := client.UpdateTaskStatus(ctx, &api.UpdateTaskStatusRequest{ SessionID: s.sessionID, diff --git a/agent/worker.go b/agent/worker.go index d99e77ff0e..f19c9c957b 100644 --- a/agent/worker.go +++ b/agent/worker.go @@ -17,13 +17,13 @@ type Worker interface { // Init prepares the worker for task assignment. Init(ctx context.Context) error - // Assign a complete set of tasks to a worker. Any task not included in + // AssignTasks assigns a complete set of tasks to a worker. Any task not included in // this set will be removed. - Assign(ctx context.Context, tasks []*api.Task) error + AssignTasks(ctx context.Context, tasks []*api.Task) error - // Update an incremental set of tasks to the worker. Any task not included + // UpdateTasks updates an incremental set of tasks to the worker. Any task not included // either in added or removed will remain untouched. - Update(ctx context.Context, added []*api.Task, removed []string) error + UpdateTasks(ctx context.Context, added []*api.Task, removed []string) error // Listen to updates about tasks controlled by the worker. When first // called, the reporter will receive all updates for all tasks controlled @@ -90,37 +90,37 @@ func (w *worker) Init(ctx context.Context) error { }) } -// Assign the set of tasks to the worker. Any tasks not previously known will +// AssignTasks assigns the set of tasks to the worker. Any tasks not previously known will // be started. Any tasks that are in the task set and already running will be // updated, if possible. Any tasks currently running on the // worker outside the task set will be terminated. -func (w *worker) Assign(ctx context.Context, tasks []*api.Task) error { +func (w *worker) AssignTasks(ctx context.Context, tasks []*api.Task) error { w.mu.Lock() defer w.mu.Unlock() log.G(ctx).WithFields(logrus.Fields{ "len(tasks)": len(tasks), - }).Debug("(*worker).Assign") + }).Debug("(*worker).AssignTasks") return reconcileTaskState(ctx, w, tasks, nil, true) } -// Update the set of tasks to the worker. +// UpdateTasks the set of tasks to the worker. // Tasks in the added set will be added to the worker, and tasks in the removed set // will be removed from the worker -func (w *worker) Update(ctx context.Context, added []*api.Task, removed []string) error { +func (w *worker) UpdateTasks(ctx context.Context, added []*api.Task, removed []string) error { w.mu.Lock() defer w.mu.Unlock() log.G(ctx).WithFields(logrus.Fields{ "len(added)": len(added), "len(removed)": len(removed), - }).Debug("(*worker).Update") + }).Debug("(*worker).UpdateTasks") return reconcileTaskState(ctx, w, added, removed, false) } -func reconcileTaskState(ctx context.Context, w *worker, added []*api.Task, removed []string, full_snapshot bool) error { +func reconcileTaskState(ctx context.Context, w *worker, added []*api.Task, removed []string, fullSnapshot bool) error { tx, err := w.db.Begin(true) if err != nil { log.G(ctx).WithError(err).Error("failed starting transaction against task database") @@ -187,7 +187,7 @@ func reconcileTaskState(ctx context.Context, w *worker, added []*api.Task, remov // If this was a complete set of assignments, we're going to remove all the remaining // tasks. - if full_snapshot { + if fullSnapshot { for id, tm := range w.taskManagers { if _, ok := assigned[id]; ok { continue diff --git a/agent/worker_test.go b/agent/worker_test.go index d554b88f57..9504074203 100644 --- a/agent/worker_test.go +++ b/agent/worker_test.go @@ -53,7 +53,7 @@ func TestWorker(t *testing.T) { // TODO(stevvooe): There are a few more states here we need to get // covered to ensure correct during code changes. } { - assert.NoError(t, worker.Assign(ctx, testcase.taskSet)) + assert.NoError(t, worker.AssignTasks(ctx, testcase.taskSet)) var ( tasks []*api.Task diff --git a/api/dispatcher.pb.go b/api/dispatcher.pb.go index df061bc136..e58f2a148d 100644 --- a/api/dispatcher.pb.go +++ b/api/dispatcher.pb.go @@ -36,26 +36,26 @@ var _ = math.Inf // AssignmentType specifies whether this assignment message carries // the full state, or is an update to an existing state. -type AssignmentsMessage_AssignmentType int32 +type AssignmentsMessage_Type int32 const ( - AssignmentsMessage_COMPLETE AssignmentsMessage_AssignmentType = 0 - AssignmentsMessage_INCREMENTAL AssignmentsMessage_AssignmentType = 1 + AssignmentsMessage_COMPLETE AssignmentsMessage_Type = 0 + AssignmentsMessage_INCREMENTAL AssignmentsMessage_Type = 1 ) -var AssignmentsMessage_AssignmentType_name = map[int32]string{ +var AssignmentsMessage_Type_name = map[int32]string{ 0: "COMPLETE", 1: "INCREMENTAL", } -var AssignmentsMessage_AssignmentType_value = map[string]int32{ +var AssignmentsMessage_Type_value = map[string]int32{ "COMPLETE": 0, "INCREMENTAL": 1, } -func (x AssignmentsMessage_AssignmentType) String() string { - return proto.EnumName(AssignmentsMessage_AssignmentType_name, int32(x)) +func (x AssignmentsMessage_Type) String() string { + return proto.EnumName(AssignmentsMessage_Type_name, int32(x)) } -func (AssignmentsMessage_AssignmentType) EnumDescriptor() ([]byte, []int) { +func (AssignmentsMessage_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorDispatcher, []int{9, 0} } @@ -214,7 +214,7 @@ func (*AssignmentsRequest) ProtoMessage() {} func (*AssignmentsRequest) Descriptor() ([]byte, []int) { return fileDescriptorDispatcher, []int{8} } type AssignmentsMessage struct { - Type AssignmentsMessage_AssignmentType `protobuf:"varint,1,opt,name=type,proto3,enum=docker.swarmkit.v1.AssignmentsMessage_AssignmentType" json:"type,omitempty"` + Type AssignmentsMessage_Type `protobuf:"varint,1,opt,name=type,proto3,enum=docker.swarmkit.v1.AssignmentsMessage_Type" json:"type,omitempty"` // AppliesTo references the previous ResultsIn value, to chain // incremental updates together. For the first update in a stream, // AppliesTo is empty. If AppliesTo does not match the previously @@ -252,7 +252,7 @@ func init() { proto.RegisterType((*TasksMessage)(nil), "docker.swarmkit.v1.TasksMessage") proto.RegisterType((*AssignmentsRequest)(nil), "docker.swarmkit.v1.AssignmentsRequest") proto.RegisterType((*AssignmentsMessage)(nil), "docker.swarmkit.v1.AssignmentsMessage") - proto.RegisterEnum("docker.swarmkit.v1.AssignmentsMessage_AssignmentType", AssignmentsMessage_AssignmentType_name, AssignmentsMessage_AssignmentType_value) + proto.RegisterEnum("docker.swarmkit.v1.AssignmentsMessage_Type", AssignmentsMessage_Type_name, AssignmentsMessage_Type_value) } type authenticatedWrapperDispatcherServer struct { @@ -2912,7 +2912,7 @@ func (m *AssignmentsMessage) Unmarshal(data []byte) error { } b := data[iNdEx] iNdEx++ - m.Type |= (AssignmentsMessage_AssignmentType(b) & 0x7F) << shift + m.Type |= (AssignmentsMessage_Type(b) & 0x7F) << shift if b < 0x80 { break } @@ -3162,56 +3162,56 @@ var ( ) var fileDescriptorDispatcher = []byte{ - // 812 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x95, 0xdf, 0x6e, 0xe3, 0x44, - 0x14, 0xc6, 0xe3, 0xfc, 0xeb, 0xe6, 0x38, 0x2d, 0x61, 0x58, 0xb1, 0x56, 0xb4, 0xeb, 0x66, 0x5d, - 0x58, 0x45, 0xa2, 0x24, 0x10, 0x04, 0x17, 0x50, 0x21, 0x36, 0x9b, 0x48, 0x44, 0xbb, 0xed, 0x56, - 0x6e, 0xa0, 0x97, 0x91, 0x13, 0x1f, 0xa5, 0x26, 0x8d, 0xc7, 0xcc, 0x4c, 0x5a, 0x72, 0x81, 0x84, - 0x04, 0xdc, 0x23, 0x24, 0x24, 0x9e, 0xa2, 0xcf, 0x51, 0x71, 0xc5, 0x25, 0x57, 0x15, 0xcd, 0x03, - 0x20, 0x1e, 0x61, 0x65, 0x7b, 0x9c, 0xa6, 0xa9, 0xd3, 0x26, 0xbd, 0xca, 0xf8, 0xcc, 0x77, 0xbe, - 0xf9, 0xe9, 0xcc, 0x9c, 0x13, 0x28, 0xd8, 0x0e, 0xf7, 0x2c, 0xd1, 0x3b, 0x42, 0x56, 0xf1, 0x18, - 0x15, 0x94, 0x10, 0x9b, 0xf6, 0x06, 0xc8, 0x2a, 0xfc, 0xd4, 0x62, 0xc3, 0x81, 0x23, 0x2a, 0x27, - 0x1f, 0x17, 0x55, 0x31, 0xf6, 0x90, 0x87, 0x82, 0xe2, 0x3a, 0xed, 0x7e, 0x87, 0x3d, 0x11, 0x7d, - 0x3e, 0xec, 0xd3, 0x3e, 0x0d, 0x96, 0x55, 0x7f, 0x25, 0xa3, 0xef, 0x78, 0xc7, 0xa3, 0xbe, 0xe3, - 0x56, 0xc3, 0x1f, 0x19, 0x7c, 0x64, 0x8f, 0x98, 0x25, 0x1c, 0xea, 0x56, 0xa3, 0x45, 0xb8, 0x61, - 0xfc, 0xaa, 0xc0, 0xc6, 0x01, 0x72, 0xee, 0x50, 0xd7, 0xc4, 0xef, 0x47, 0xc8, 0x05, 0x69, 0x82, - 0x6a, 0x23, 0xef, 0x31, 0xc7, 0xf3, 0x75, 0x9a, 0x52, 0x52, 0xca, 0x6a, 0x6d, 0xab, 0x72, 0x13, - 0xae, 0xb2, 0x47, 0x6d, 0x6c, 0x5c, 0x49, 0xcd, 0xd9, 0x3c, 0xb2, 0x0d, 0xc0, 0x43, 0xe3, 0x8e, - 0x63, 0x6b, 0xc9, 0x92, 0x52, 0xce, 0xd5, 0xd7, 0x27, 0x17, 0x9b, 0x39, 0x79, 0x5c, 0xab, 0x61, - 0xe6, 0xa4, 0xa0, 0x65, 0x1b, 0x3f, 0x27, 0xa7, 0x1c, 0xbb, 0xc8, 0xb9, 0xd5, 0xc7, 0x39, 0x03, - 0xe5, 0x76, 0x03, 0xb2, 0x0d, 0x69, 0x97, 0xda, 0x18, 0x1c, 0xa4, 0xd6, 0xb4, 0x45, 0xb8, 0x66, - 0xa0, 0x22, 0x3b, 0xf0, 0x60, 0x68, 0xb9, 0x56, 0x1f, 0x19, 0xd7, 0x52, 0xa5, 0x54, 0x59, 0xad, - 0x95, 0xe2, 0x32, 0x0e, 0xd1, 0xe9, 0x1f, 0x09, 0xb4, 0xf7, 0x11, 0x99, 0x39, 0xcd, 0x20, 0x87, - 0xf0, 0xae, 0x8b, 0xe2, 0x94, 0xb2, 0x41, 0xa7, 0x4b, 0xa9, 0xe0, 0x82, 0x59, 0x5e, 0x67, 0x80, - 0x63, 0xae, 0xa5, 0x03, 0xaf, 0xa7, 0x71, 0x5e, 0x4d, 0xb7, 0xc7, 0xc6, 0x41, 0x69, 0x5e, 0xe2, - 0xd8, 0x7c, 0x28, 0x0d, 0xea, 0x51, 0xfe, 0x4b, 0x1c, 0x73, 0xe3, 0x2b, 0x28, 0x7c, 0x8d, 0x16, - 0x13, 0x5d, 0xb4, 0x44, 0x74, 0x1d, 0x2b, 0x95, 0xc1, 0x78, 0x0d, 0x6f, 0xcf, 0x38, 0x70, 0x8f, - 0xba, 0x1c, 0xc9, 0xe7, 0x90, 0xf5, 0x90, 0x39, 0xd4, 0x96, 0x97, 0xf9, 0x38, 0x8e, 0xaf, 0x21, - 0x1f, 0x46, 0x3d, 0x7d, 0x7e, 0xb1, 0x99, 0x30, 0x65, 0x86, 0xf1, 0x5b, 0x12, 0x1e, 0x7d, 0xe3, - 0xd9, 0x96, 0xc0, 0xb6, 0xc5, 0x07, 0x07, 0xc2, 0x12, 0x23, 0x7e, 0x2f, 0x34, 0xf2, 0x2d, 0xac, - 0x8d, 0x02, 0xa3, 0xa8, 0xe4, 0x3b, 0x71, 0x18, 0x0b, 0xce, 0xaa, 0x5c, 0x45, 0x42, 0x85, 0x19, - 0x99, 0x15, 0x29, 0x14, 0xe6, 0x37, 0xc9, 0x16, 0xac, 0x09, 0x8b, 0x0f, 0xae, 0xb0, 0x60, 0x72, - 0xb1, 0x99, 0xf5, 0x65, 0xad, 0x86, 0x99, 0xf5, 0xb7, 0x5a, 0x36, 0xf9, 0x0c, 0xb2, 0x3c, 0x48, - 0x92, 0x8f, 0x46, 0x8f, 0xe3, 0x99, 0x21, 0x91, 0x6a, 0xa3, 0x08, 0xda, 0x4d, 0xca, 0xb0, 0xd4, - 0xc6, 0x0e, 0xe4, 0xfd, 0xe8, 0xfd, 0x4a, 0x64, 0x7c, 0x29, 0xb3, 0xa3, 0x16, 0xa8, 0x40, 0xc6, - 0x67, 0xe5, 0x9a, 0x12, 0x14, 0x4c, 0x5b, 0x04, 0x68, 0x86, 0x32, 0xa3, 0x0e, 0xe4, 0x39, 0xe7, - 0x4e, 0xdf, 0x1d, 0xa2, 0x2b, 0xee, 0xc9, 0x70, 0x96, 0xbc, 0x66, 0x12, 0xa1, 0xb4, 0x20, 0xed, - 0x8f, 0xa2, 0x20, 0x7d, 0xa3, 0xf6, 0x69, 0x1c, 0xc9, 0xcd, 0xac, 0x99, 0x50, 0x7b, 0xec, 0xa1, - 0x19, 0x58, 0x90, 0x27, 0x00, 0x96, 0xe7, 0x1d, 0x3b, 0xc8, 0x3b, 0x82, 0x86, 0x93, 0xc1, 0xcc, - 0xc9, 0x48, 0x9b, 0xfa, 0xdb, 0x0c, 0xf9, 0xe8, 0x58, 0xf0, 0x8e, 0xe3, 0x6a, 0xa9, 0x70, 0x5b, - 0x46, 0x5a, 0x2e, 0xf9, 0x02, 0xf2, 0xe1, 0xcd, 0x77, 0xc2, 0xd2, 0xa4, 0xef, 0x28, 0x8d, 0x3a, - 0x9a, 0xde, 0x15, 0x27, 0x4f, 0x21, 0xcf, 0x70, 0x48, 0x4f, 0xa2, 0xe4, 0x4c, 0x29, 0x55, 0xce, - 0x99, 0x6a, 0x18, 0x0b, 0x24, 0x46, 0x15, 0x36, 0xae, 0x53, 0x93, 0x3c, 0x3c, 0x78, 0xf1, 0x7a, - 0x77, 0xff, 0x55, 0xb3, 0xdd, 0x2c, 0x24, 0xc8, 0x5b, 0xa0, 0xb6, 0xf6, 0x5e, 0x98, 0xcd, 0xdd, - 0xe6, 0x5e, 0xfb, 0xf9, 0xab, 0x82, 0x52, 0xfb, 0x23, 0x03, 0xd0, 0x98, 0xce, 0x72, 0xf2, 0x03, - 0xac, 0xc9, 0xba, 0x12, 0x23, 0x0e, 0xea, 0xfa, 0xb4, 0x2d, 0xde, 0xa6, 0x91, 0x55, 0x34, 0xb6, - 0xfe, 0x3a, 0xfb, 0xef, 0xcf, 0xe4, 0x13, 0xc8, 0x07, 0x9a, 0x0f, 0xfd, 0xb9, 0x81, 0x0c, 0xd6, - 0xc3, 0x2f, 0x39, 0x95, 0x3e, 0x52, 0xc8, 0x8f, 0x90, 0x9b, 0xf6, 0x3e, 0x79, 0x2f, 0xce, 0x77, - 0x7e, 0xb8, 0x14, 0xdf, 0xbf, 0x43, 0x25, 0x5f, 0xf5, 0x32, 0x00, 0xe4, 0x77, 0x05, 0x0a, 0xf3, - 0x7d, 0x41, 0x3e, 0x58, 0xa1, 0xc7, 0x8b, 0xdb, 0xcb, 0x89, 0x57, 0x81, 0x62, 0x90, 0x09, 0x6f, - 0xbe, 0xb4, 0xe8, 0x81, 0x4c, 0x4f, 0x5f, 0xac, 0x58, 0xf1, 0x1e, 0x7e, 0x51, 0x40, 0x9d, 0xe9, - 0x05, 0xf2, 0xec, 0x8e, 0x66, 0x89, 0x00, 0x9e, 0x2d, 0xd7, 0x54, 0x4b, 0x62, 0xd4, 0x1f, 0x9f, - 0x5f, 0xea, 0x89, 0x7f, 0x2e, 0xf5, 0xc4, 0xff, 0x97, 0xba, 0xf2, 0xd3, 0x44, 0x57, 0xce, 0x27, - 0xba, 0xf2, 0xf7, 0x44, 0x57, 0xfe, 0x9d, 0xe8, 0x4a, 0x37, 0x1b, 0xfc, 0xff, 0x7f, 0xf2, 0x26, - 0x00, 0x00, 0xff, 0xff, 0x85, 0xe6, 0xd0, 0x78, 0x87, 0x08, 0x00, 0x00, + // 811 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x55, 0x5d, 0x6f, 0xdb, 0x54, + 0x18, 0x8e, 0xf3, 0xd5, 0xe5, 0x75, 0x3a, 0xc2, 0x61, 0x62, 0x56, 0xb4, 0xb9, 0x99, 0xcb, 0xa6, + 0x48, 0x2b, 0x2e, 0x04, 0x89, 0x0b, 0xa8, 0x80, 0x65, 0x89, 0x44, 0xb4, 0xb5, 0x9b, 0xdc, 0x40, + 0x2f, 0x23, 0x27, 0x7e, 0x95, 0x9a, 0x34, 0x3e, 0xe6, 0x9c, 0x93, 0x96, 0x5c, 0x20, 0x21, 0x01, + 0xf7, 0x08, 0x09, 0x09, 0xf1, 0x23, 0xf8, 0x1d, 0x15, 0x57, 0x5c, 0x72, 0x55, 0xd1, 0xfc, 0x00, + 0xc4, 0x4f, 0x98, 0x6c, 0x1f, 0xa7, 0x69, 0xea, 0xb4, 0x49, 0xaf, 0x72, 0xfc, 0x9e, 0xe7, 0x79, + 0xce, 0xa3, 0xf7, 0x2b, 0x50, 0x72, 0x5c, 0xee, 0xdb, 0xa2, 0x77, 0x88, 0xcc, 0xf4, 0x19, 0x15, + 0x94, 0x10, 0x87, 0xf6, 0x06, 0xc8, 0x4c, 0x7e, 0x62, 0xb3, 0xe1, 0xc0, 0x15, 0xe6, 0xf1, 0x87, + 0x65, 0x55, 0x8c, 0x7d, 0xe4, 0x11, 0xa0, 0xbc, 0x4e, 0xbb, 0xdf, 0x60, 0x4f, 0xc4, 0x9f, 0xf7, + 0xfa, 0xb4, 0x4f, 0xc3, 0xe3, 0x76, 0x70, 0x92, 0xd1, 0x77, 0xfc, 0xa3, 0x51, 0xdf, 0xf5, 0xb6, + 0xa3, 0x1f, 0x19, 0xbc, 0xef, 0x8c, 0x98, 0x2d, 0x5c, 0xea, 0x6d, 0xc7, 0x87, 0xe8, 0xc2, 0xf8, + 0x59, 0x81, 0xbb, 0xfb, 0xc8, 0xb9, 0x4b, 0x3d, 0x0b, 0xbf, 0x1d, 0x21, 0x17, 0xa4, 0x09, 0xaa, + 0x83, 0xbc, 0xc7, 0x5c, 0x3f, 0xc0, 0x69, 0x4a, 0x45, 0xa9, 0xaa, 0xb5, 0x4d, 0xf3, 0xaa, 0x39, + 0x73, 0x8f, 0x3a, 0xd8, 0xb8, 0x80, 0x5a, 0xb3, 0x3c, 0xb2, 0x05, 0xc0, 0x23, 0xe1, 0x8e, 0xeb, + 0x68, 0xe9, 0x8a, 0x52, 0x2d, 0xd4, 0xd7, 0x27, 0x67, 0x1b, 0x05, 0xf9, 0x5c, 0xab, 0x61, 0x15, + 0x24, 0xa0, 0xe5, 0x18, 0x3f, 0xa6, 0xa7, 0x3e, 0x76, 0x91, 0x73, 0xbb, 0x8f, 0x73, 0x02, 0xca, + 0xf5, 0x02, 0x64, 0x0b, 0xb2, 0x1e, 0x75, 0x30, 0x7c, 0x48, 0xad, 0x69, 0x8b, 0xec, 0x5a, 0x21, + 0x8a, 0xec, 0xc0, 0x9d, 0xa1, 0xed, 0xd9, 0x7d, 0x64, 0x5c, 0xcb, 0x54, 0x32, 0x55, 0xb5, 0x56, + 0x49, 0x62, 0x1c, 0xa0, 0xdb, 0x3f, 0x14, 0xe8, 0xbc, 0x46, 0x64, 0xd6, 0x94, 0x41, 0x0e, 0xe0, + 0x5d, 0x0f, 0xc5, 0x09, 0x65, 0x83, 0x4e, 0x97, 0x52, 0xc1, 0x05, 0xb3, 0xfd, 0xce, 0x00, 0xc7, + 0x5c, 0xcb, 0x86, 0x5a, 0x8f, 0x92, 0xb4, 0x9a, 0x5e, 0x8f, 0x8d, 0xc3, 0xd4, 0xbc, 0xc0, 0xb1, + 0x75, 0x4f, 0x0a, 0xd4, 0x63, 0xfe, 0x0b, 0x1c, 0x73, 0xe3, 0x0b, 0x28, 0x7d, 0x89, 0x36, 0x13, + 0x5d, 0xb4, 0x45, 0x5c, 0x8e, 0x95, 0xd2, 0x60, 0xbc, 0x82, 0xb7, 0x67, 0x14, 0xb8, 0x4f, 0x3d, + 0x8e, 0xe4, 0x13, 0xc8, 0xfb, 0xc8, 0x5c, 0xea, 0xc8, 0x62, 0x3e, 0x48, 0xf2, 0xd7, 0x90, 0x8d, + 0x51, 0xcf, 0x9e, 0x9e, 0x6d, 0xa4, 0x2c, 0xc9, 0x30, 0x7e, 0x49, 0xc3, 0xfd, 0xaf, 0x7c, 0xc7, + 0x16, 0xd8, 0xb6, 0xf9, 0x60, 0x5f, 0xd8, 0x62, 0xc4, 0x6f, 0x65, 0x8d, 0x7c, 0x0d, 0x6b, 0xa3, + 0x50, 0x28, 0x4e, 0xf9, 0x4e, 0x92, 0x8d, 0x05, 0x6f, 0x99, 0x17, 0x91, 0x08, 0x61, 0xc5, 0x62, + 0x65, 0x0a, 0xa5, 0xf9, 0x4b, 0xb2, 0x09, 0x6b, 0xc2, 0xe6, 0x83, 0x0b, 0x5b, 0x30, 0x39, 0xdb, + 0xc8, 0x07, 0xb0, 0x56, 0xc3, 0xca, 0x07, 0x57, 0x2d, 0x87, 0x7c, 0x0c, 0x79, 0x1e, 0x92, 0x64, + 0xd3, 0xe8, 0x49, 0x7e, 0x66, 0x9c, 0x48, 0xb4, 0x51, 0x06, 0xed, 0xaa, 0xcb, 0x28, 0xd5, 0xc6, + 0x0e, 0x14, 0x83, 0xe8, 0xed, 0x52, 0x64, 0x7c, 0x26, 0xd9, 0xf1, 0x08, 0x98, 0x90, 0x0b, 0xbc, + 0x72, 0x4d, 0x09, 0x13, 0xa6, 0x2d, 0x32, 0x68, 0x45, 0x30, 0xa3, 0x0e, 0xe4, 0x19, 0xe7, 0x6e, + 0xdf, 0x1b, 0xa2, 0x27, 0x6e, 0xe9, 0xe1, 0x8f, 0xf4, 0x25, 0x91, 0xd8, 0xca, 0xe7, 0x90, 0x0d, + 0x56, 0x51, 0x48, 0xbf, 0x5b, 0x7b, 0x9a, 0xe4, 0xe4, 0x2a, 0xcb, 0x6c, 0x8f, 0x7d, 0xb4, 0x42, + 0x22, 0x79, 0x08, 0x60, 0xfb, 0xfe, 0x91, 0x8b, 0xbc, 0x23, 0x68, 0xb4, 0x0f, 0xac, 0x82, 0x8c, + 0xb4, 0x69, 0x70, 0xcd, 0x90, 0x8f, 0x8e, 0x04, 0xef, 0xb8, 0x9e, 0x96, 0x89, 0xae, 0x65, 0xa4, + 0xe5, 0x91, 0x4f, 0xa1, 0x18, 0xd5, 0xbb, 0x13, 0x25, 0x24, 0x7b, 0x43, 0x42, 0xd4, 0xd1, 0xb4, + 0x42, 0x9c, 0x3c, 0x82, 0x22, 0xc3, 0x21, 0x3d, 0x8e, 0xc9, 0xb9, 0x4a, 0xa6, 0x5a, 0xb0, 0xd4, + 0x28, 0x16, 0x42, 0x8c, 0xc7, 0x90, 0x0d, 0xbc, 0x92, 0x22, 0xdc, 0x79, 0xfe, 0x6a, 0xf7, 0xf5, + 0xcb, 0x66, 0xbb, 0x59, 0x4a, 0x91, 0xb7, 0x40, 0x6d, 0xed, 0x3d, 0xb7, 0x9a, 0xbb, 0xcd, 0xbd, + 0xf6, 0xb3, 0x97, 0x25, 0xa5, 0xf6, 0x5b, 0x0e, 0xa0, 0x31, 0xdd, 0xdb, 0xe4, 0x3b, 0x58, 0x93, + 0x39, 0x24, 0x46, 0x92, 0x95, 0xcb, 0x9b, 0xb5, 0x7c, 0x1d, 0x46, 0x66, 0xcc, 0xd8, 0xfc, 0xeb, + 0xcf, 0xff, 0x7e, 0x4f, 0x3f, 0x84, 0x62, 0x88, 0x79, 0x3f, 0xd8, 0x11, 0xc8, 0x60, 0x3d, 0xfa, + 0x92, 0x1b, 0xe8, 0x03, 0x85, 0x7c, 0x0f, 0x85, 0xe9, 0x9c, 0x93, 0xf7, 0x92, 0x74, 0xe7, 0x17, + 0x49, 0xf9, 0xf1, 0x0d, 0x28, 0xd9, 0xc1, 0xcb, 0x18, 0x20, 0xbf, 0x2a, 0x50, 0x9a, 0x9f, 0x01, + 0xf2, 0x74, 0x85, 0x79, 0x2e, 0x6f, 0x2d, 0x07, 0x5e, 0xc5, 0x14, 0x83, 0x5c, 0x54, 0xef, 0xca, + 0xa2, 0xb6, 0x98, 0xbe, 0xbe, 0x18, 0xb1, 0x62, 0x1d, 0x7e, 0x52, 0x40, 0x9d, 0xe9, 0x7b, 0xf2, + 0xe4, 0x86, 0xc1, 0x88, 0x0d, 0x3c, 0x59, 0x6e, 0x80, 0x96, 0xb4, 0x51, 0x7f, 0x70, 0x7a, 0xae, + 0xa7, 0xfe, 0x39, 0xd7, 0x53, 0xff, 0x9f, 0xeb, 0xca, 0x0f, 0x13, 0x5d, 0x39, 0x9d, 0xe8, 0xca, + 0xdf, 0x13, 0x5d, 0xf9, 0x77, 0xa2, 0x2b, 0xdd, 0x7c, 0xf8, 0x5f, 0xff, 0xd1, 0x9b, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xc9, 0x51, 0x05, 0xe0, 0x73, 0x08, 0x00, 0x00, } diff --git a/api/dispatcher.proto b/api/dispatcher.proto index 18d5516b85..67c3d42a3e 100644 --- a/api/dispatcher.proto +++ b/api/dispatcher.proto @@ -172,12 +172,12 @@ message AssignmentsRequest { message AssignmentsMessage { // AssignmentType specifies whether this assignment message carries // the full state, or is an update to an existing state. - enum AssignmentType { + enum Type { COMPLETE = 0; INCREMENTAL = 1; } - AssignmentType type = 1; + Type type = 1; // AppliesTo references the previous ResultsIn value, to chain // incremental updates together. For the first update in a stream, diff --git a/manager/dispatcher/dispatcher.go b/manager/dispatcher/dispatcher.go index b5a8ea4828..7622a00fc9 100644 --- a/manager/dispatcher/dispatcher.go +++ b/manager/dispatcher/dispatcher.go @@ -759,7 +759,7 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche ) tasksMap := make(map[string]*api.Task) - sendMessage := func(msg api.AssignmentsMessage, assignmentType api.AssignmentsMessage_AssignmentType) error { + sendMessage := func(msg api.AssignmentsMessage, assignmentType api.AssignmentsMessage_Type) error { sequence++ msg.AppliesTo = appliesTo msg.ResultsIn = strconv.FormatInt(sequence, 10) @@ -864,7 +864,7 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche // not the agent, so tasks in these states need to be sent to the // agent even if nothing else has changed. if equality.TasksEqualStable(oldTask, v.Task) && v.Task.Status.State > api.TaskStateAssigned { - // this update should not trigger action at agent + // this update should not trigger a task change for the agent tasksMap[v.Task.ID] = v.Task continue } From 1eb3402135d82118f60cd324db1de9dd82920666 Mon Sep 17 00:00:00 2001 From: Diogo Monica Date: Wed, 7 Sep 2016 16:40:29 -0700 Subject: [PATCH 10/10] Addressing reviewer comments Signed-off-by: Diogo Monica --- agent/agent.go | 2 +- agent/session.go | 2 +- api/dispatcher.pb.go | 105 ++++++++++++++++++++++--------------------- api/dispatcher.proto | 1 + api/objects.proto | 2 +- api/specs.proto | 2 +- api/types.proto | 2 +- 7 files changed, 59 insertions(+), 57 deletions(-) diff --git a/agent/agent.go b/agent/agent.go index 8be494d9a3..5972f8cb70 100644 --- a/agent/agent.go +++ b/agent/agent.go @@ -172,7 +172,7 @@ func (a *Agent) run(ctx context.Context) { switch msg.Type { case api.AssignmentsMessage_COMPLETE: if err := a.worker.AssignTasks(ctx, msg.UpdateTasks); err != nil { - log.G(ctx).WithError(err).Error("failed to assign worker assignments") + log.G(ctx).WithError(err).Error("failed to synchronize worker assignments") } case api.AssignmentsMessage_INCREMENTAL: if err := a.worker.UpdateTasks(ctx, msg.UpdateTasks, msg.RemoveTasks); err != nil { diff --git a/agent/session.go b/agent/session.go index fdee18d883..b4afc0d6f0 100644 --- a/agent/session.go +++ b/agent/session.go @@ -237,7 +237,7 @@ func (s *session) watch(ctx context.Context) error { } tasksFallback = true assignmentWatch = nil - log.WithError(err).Errorf("falling back to Tasks") + log.WithError(err).Infof("falling back to Tasks") } } diff --git a/api/dispatcher.pb.go b/api/dispatcher.pb.go index df061bc136..461e2c059f 100644 --- a/api/dispatcher.pb.go +++ b/api/dispatcher.pb.go @@ -3162,56 +3162,57 @@ var ( ) var fileDescriptorDispatcher = []byte{ - // 812 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x95, 0xdf, 0x6e, 0xe3, 0x44, - 0x14, 0xc6, 0xe3, 0xfc, 0xeb, 0xe6, 0x38, 0x2d, 0x61, 0x58, 0xb1, 0x56, 0xb4, 0xeb, 0x66, 0x5d, - 0x58, 0x45, 0xa2, 0x24, 0x10, 0x04, 0x17, 0x50, 0x21, 0x36, 0x9b, 0x48, 0x44, 0xbb, 0xed, 0x56, - 0x6e, 0xa0, 0x97, 0x91, 0x13, 0x1f, 0xa5, 0x26, 0x8d, 0xc7, 0xcc, 0x4c, 0x5a, 0x72, 0x81, 0x84, - 0x04, 0xdc, 0x23, 0x24, 0x24, 0x9e, 0xa2, 0xcf, 0x51, 0x71, 0xc5, 0x25, 0x57, 0x15, 0xcd, 0x03, - 0x20, 0x1e, 0x61, 0x65, 0x7b, 0x9c, 0xa6, 0xa9, 0xd3, 0x26, 0xbd, 0xca, 0xf8, 0xcc, 0x77, 0xbe, - 0xf9, 0xe9, 0xcc, 0x9c, 0x13, 0x28, 0xd8, 0x0e, 0xf7, 0x2c, 0xd1, 0x3b, 0x42, 0x56, 0xf1, 0x18, - 0x15, 0x94, 0x10, 0x9b, 0xf6, 0x06, 0xc8, 0x2a, 0xfc, 0xd4, 0x62, 0xc3, 0x81, 0x23, 0x2a, 0x27, - 0x1f, 0x17, 0x55, 0x31, 0xf6, 0x90, 0x87, 0x82, 0xe2, 0x3a, 0xed, 0x7e, 0x87, 0x3d, 0x11, 0x7d, - 0x3e, 0xec, 0xd3, 0x3e, 0x0d, 0x96, 0x55, 0x7f, 0x25, 0xa3, 0xef, 0x78, 0xc7, 0xa3, 0xbe, 0xe3, - 0x56, 0xc3, 0x1f, 0x19, 0x7c, 0x64, 0x8f, 0x98, 0x25, 0x1c, 0xea, 0x56, 0xa3, 0x45, 0xb8, 0x61, - 0xfc, 0xaa, 0xc0, 0xc6, 0x01, 0x72, 0xee, 0x50, 0xd7, 0xc4, 0xef, 0x47, 0xc8, 0x05, 0x69, 0x82, - 0x6a, 0x23, 0xef, 0x31, 0xc7, 0xf3, 0x75, 0x9a, 0x52, 0x52, 0xca, 0x6a, 0x6d, 0xab, 0x72, 0x13, - 0xae, 0xb2, 0x47, 0x6d, 0x6c, 0x5c, 0x49, 0xcd, 0xd9, 0x3c, 0xb2, 0x0d, 0xc0, 0x43, 0xe3, 0x8e, - 0x63, 0x6b, 0xc9, 0x92, 0x52, 0xce, 0xd5, 0xd7, 0x27, 0x17, 0x9b, 0x39, 0x79, 0x5c, 0xab, 0x61, - 0xe6, 0xa4, 0xa0, 0x65, 0x1b, 0x3f, 0x27, 0xa7, 0x1c, 0xbb, 0xc8, 0xb9, 0xd5, 0xc7, 0x39, 0x03, - 0xe5, 0x76, 0x03, 0xb2, 0x0d, 0x69, 0x97, 0xda, 0x18, 0x1c, 0xa4, 0xd6, 0xb4, 0x45, 0xb8, 0x66, - 0xa0, 0x22, 0x3b, 0xf0, 0x60, 0x68, 0xb9, 0x56, 0x1f, 0x19, 0xd7, 0x52, 0xa5, 0x54, 0x59, 0xad, - 0x95, 0xe2, 0x32, 0x0e, 0xd1, 0xe9, 0x1f, 0x09, 0xb4, 0xf7, 0x11, 0x99, 0x39, 0xcd, 0x20, 0x87, - 0xf0, 0xae, 0x8b, 0xe2, 0x94, 0xb2, 0x41, 0xa7, 0x4b, 0xa9, 0xe0, 0x82, 0x59, 0x5e, 0x67, 0x80, - 0x63, 0xae, 0xa5, 0x03, 0xaf, 0xa7, 0x71, 0x5e, 0x4d, 0xb7, 0xc7, 0xc6, 0x41, 0x69, 0x5e, 0xe2, - 0xd8, 0x7c, 0x28, 0x0d, 0xea, 0x51, 0xfe, 0x4b, 0x1c, 0x73, 0xe3, 0x2b, 0x28, 0x7c, 0x8d, 0x16, - 0x13, 0x5d, 0xb4, 0x44, 0x74, 0x1d, 0x2b, 0x95, 0xc1, 0x78, 0x0d, 0x6f, 0xcf, 0x38, 0x70, 0x8f, - 0xba, 0x1c, 0xc9, 0xe7, 0x90, 0xf5, 0x90, 0x39, 0xd4, 0x96, 0x97, 0xf9, 0x38, 0x8e, 0xaf, 0x21, - 0x1f, 0x46, 0x3d, 0x7d, 0x7e, 0xb1, 0x99, 0x30, 0x65, 0x86, 0xf1, 0x5b, 0x12, 0x1e, 0x7d, 0xe3, - 0xd9, 0x96, 0xc0, 0xb6, 0xc5, 0x07, 0x07, 0xc2, 0x12, 0x23, 0x7e, 0x2f, 0x34, 0xf2, 0x2d, 0xac, - 0x8d, 0x02, 0xa3, 0xa8, 0xe4, 0x3b, 0x71, 0x18, 0x0b, 0xce, 0xaa, 0x5c, 0x45, 0x42, 0x85, 0x19, - 0x99, 0x15, 0x29, 0x14, 0xe6, 0x37, 0xc9, 0x16, 0xac, 0x09, 0x8b, 0x0f, 0xae, 0xb0, 0x60, 0x72, - 0xb1, 0x99, 0xf5, 0x65, 0xad, 0x86, 0x99, 0xf5, 0xb7, 0x5a, 0x36, 0xf9, 0x0c, 0xb2, 0x3c, 0x48, - 0x92, 0x8f, 0x46, 0x8f, 0xe3, 0x99, 0x21, 0x91, 0x6a, 0xa3, 0x08, 0xda, 0x4d, 0xca, 0xb0, 0xd4, - 0xc6, 0x0e, 0xe4, 0xfd, 0xe8, 0xfd, 0x4a, 0x64, 0x7c, 0x29, 0xb3, 0xa3, 0x16, 0xa8, 0x40, 0xc6, - 0x67, 0xe5, 0x9a, 0x12, 0x14, 0x4c, 0x5b, 0x04, 0x68, 0x86, 0x32, 0xa3, 0x0e, 0xe4, 0x39, 0xe7, - 0x4e, 0xdf, 0x1d, 0xa2, 0x2b, 0xee, 0xc9, 0x70, 0x96, 0xbc, 0x66, 0x12, 0xa1, 0xb4, 0x20, 0xed, - 0x8f, 0xa2, 0x20, 0x7d, 0xa3, 0xf6, 0x69, 0x1c, 0xc9, 0xcd, 0xac, 0x99, 0x50, 0x7b, 0xec, 0xa1, - 0x19, 0x58, 0x90, 0x27, 0x00, 0x96, 0xe7, 0x1d, 0x3b, 0xc8, 0x3b, 0x82, 0x86, 0x93, 0xc1, 0xcc, - 0xc9, 0x48, 0x9b, 0xfa, 0xdb, 0x0c, 0xf9, 0xe8, 0x58, 0xf0, 0x8e, 0xe3, 0x6a, 0xa9, 0x70, 0x5b, - 0x46, 0x5a, 0x2e, 0xf9, 0x02, 0xf2, 0xe1, 0xcd, 0x77, 0xc2, 0xd2, 0xa4, 0xef, 0x28, 0x8d, 0x3a, - 0x9a, 0xde, 0x15, 0x27, 0x4f, 0x21, 0xcf, 0x70, 0x48, 0x4f, 0xa2, 0xe4, 0x4c, 0x29, 0x55, 0xce, - 0x99, 0x6a, 0x18, 0x0b, 0x24, 0x46, 0x15, 0x36, 0xae, 0x53, 0x93, 0x3c, 0x3c, 0x78, 0xf1, 0x7a, - 0x77, 0xff, 0x55, 0xb3, 0xdd, 0x2c, 0x24, 0xc8, 0x5b, 0xa0, 0xb6, 0xf6, 0x5e, 0x98, 0xcd, 0xdd, - 0xe6, 0x5e, 0xfb, 0xf9, 0xab, 0x82, 0x52, 0xfb, 0x23, 0x03, 0xd0, 0x98, 0xce, 0x72, 0xf2, 0x03, - 0xac, 0xc9, 0xba, 0x12, 0x23, 0x0e, 0xea, 0xfa, 0xb4, 0x2d, 0xde, 0xa6, 0x91, 0x55, 0x34, 0xb6, - 0xfe, 0x3a, 0xfb, 0xef, 0xcf, 0xe4, 0x13, 0xc8, 0x07, 0x9a, 0x0f, 0xfd, 0xb9, 0x81, 0x0c, 0xd6, - 0xc3, 0x2f, 0x39, 0x95, 0x3e, 0x52, 0xc8, 0x8f, 0x90, 0x9b, 0xf6, 0x3e, 0x79, 0x2f, 0xce, 0x77, - 0x7e, 0xb8, 0x14, 0xdf, 0xbf, 0x43, 0x25, 0x5f, 0xf5, 0x32, 0x00, 0xe4, 0x77, 0x05, 0x0a, 0xf3, - 0x7d, 0x41, 0x3e, 0x58, 0xa1, 0xc7, 0x8b, 0xdb, 0xcb, 0x89, 0x57, 0x81, 0x62, 0x90, 0x09, 0x6f, - 0xbe, 0xb4, 0xe8, 0x81, 0x4c, 0x4f, 0x5f, 0xac, 0x58, 0xf1, 0x1e, 0x7e, 0x51, 0x40, 0x9d, 0xe9, - 0x05, 0xf2, 0xec, 0x8e, 0x66, 0x89, 0x00, 0x9e, 0x2d, 0xd7, 0x54, 0x4b, 0x62, 0xd4, 0x1f, 0x9f, - 0x5f, 0xea, 0x89, 0x7f, 0x2e, 0xf5, 0xc4, 0xff, 0x97, 0xba, 0xf2, 0xd3, 0x44, 0x57, 0xce, 0x27, - 0xba, 0xf2, 0xf7, 0x44, 0x57, 0xfe, 0x9d, 0xe8, 0x4a, 0x37, 0x1b, 0xfc, 0xff, 0x7f, 0xf2, 0x26, - 0x00, 0x00, 0xff, 0xff, 0x85, 0xe6, 0xd0, 0x78, 0x87, 0x08, 0x00, 0x00, + // 822 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x56, 0x4f, 0x6f, 0x1b, 0x45, + 0x14, 0xcf, 0x38, 0xb6, 0x53, 0xbf, 0x75, 0x82, 0x19, 0x2a, 0xba, 0xb2, 0xda, 0x8d, 0xbb, 0x81, + 0xc8, 0x12, 0xc1, 0x2e, 0x46, 0x70, 0x80, 0x08, 0x51, 0xd7, 0x96, 0xb0, 0xda, 0xa4, 0xd5, 0xd6, + 0xd0, 0xa3, 0xb5, 0xf6, 0x3e, 0xb9, 0x8b, 0xe3, 0x9d, 0x65, 0x66, 0xb6, 0xc5, 0x07, 0x24, 0x24, + 0x40, 0xe2, 0x88, 0x38, 0xf5, 0x53, 0xf4, 0x73, 0x44, 0x9c, 0x38, 0x72, 0x8a, 0x88, 0x3f, 0x00, + 0xe2, 0x23, 0x54, 0xbb, 0x3b, 0xeb, 0x38, 0xce, 0xba, 0x71, 0x72, 0xf2, 0xec, 0x9b, 0xdf, 0xfb, + 0xcd, 0x4f, 0xbf, 0xf7, 0x47, 0x86, 0x92, 0xe3, 0x0a, 0xdf, 0x96, 0x83, 0xe7, 0xc8, 0x6b, 0x3e, + 0x67, 0x92, 0x51, 0xea, 0xb0, 0xc1, 0x08, 0x79, 0x4d, 0xbc, 0xb4, 0xf9, 0x78, 0xe4, 0xca, 0xda, + 0x8b, 0x4f, 0xca, 0x9a, 0x9c, 0xf8, 0x28, 0x62, 0x40, 0x79, 0x93, 0xf5, 0xbf, 0xc7, 0x81, 0x4c, + 0x3e, 0x6f, 0x0e, 0xd9, 0x90, 0x45, 0xc7, 0x7a, 0x78, 0x52, 0xd1, 0xf7, 0xfc, 0xa3, 0x60, 0xe8, + 0x7a, 0xf5, 0xf8, 0x47, 0x05, 0x6f, 0x39, 0x01, 0xb7, 0xa5, 0xcb, 0xbc, 0x7a, 0x72, 0x88, 0x2f, + 0xcc, 0xdf, 0x08, 0x6c, 0x3d, 0x45, 0x21, 0x5c, 0xe6, 0x59, 0xf8, 0x43, 0x80, 0x42, 0xd2, 0x36, + 0x68, 0x0e, 0x8a, 0x01, 0x77, 0xfd, 0x10, 0xa7, 0x93, 0x0a, 0xa9, 0x6a, 0x8d, 0x9d, 0xda, 0x45, + 0x71, 0xb5, 0x43, 0xe6, 0x60, 0xeb, 0x0c, 0x6a, 0xcd, 0xe7, 0xd1, 0x3d, 0x00, 0x11, 0x13, 0xf7, + 0x5c, 0x47, 0xcf, 0x54, 0x48, 0xb5, 0xd0, 0xdc, 0x9c, 0x9e, 0x6c, 0x17, 0xd4, 0x73, 0x9d, 0x96, + 0x55, 0x50, 0x80, 0x8e, 0x63, 0xfe, 0x92, 0x99, 0xe9, 0x38, 0x40, 0x21, 0xec, 0x21, 0x2e, 0x10, + 0x90, 0xb7, 0x13, 0xd0, 0x3d, 0xc8, 0x7a, 0xcc, 0xc1, 0xe8, 0x21, 0xad, 0xa1, 0x2f, 0x93, 0x6b, + 0x45, 0x28, 0xba, 0x0f, 0x37, 0xc6, 0xb6, 0x67, 0x0f, 0x91, 0x0b, 0x7d, 0xbd, 0xb2, 0x5e, 0xd5, + 0x1a, 0x95, 0xb4, 0x8c, 0x67, 0xe8, 0x0e, 0x9f, 0x4b, 0x74, 0x9e, 0x20, 0x72, 0x6b, 0x96, 0x41, + 0x9f, 0xc1, 0xfb, 0x1e, 0xca, 0x97, 0x8c, 0x8f, 0x7a, 0x7d, 0xc6, 0xa4, 0x90, 0xdc, 0xf6, 0x7b, + 0x23, 0x9c, 0x08, 0x3d, 0x1b, 0x71, 0xdd, 0x4d, 0xe3, 0x6a, 0x7b, 0x03, 0x3e, 0x89, 0xac, 0x79, + 0x88, 0x13, 0xeb, 0xa6, 0x22, 0x68, 0x26, 0xf9, 0x0f, 0x71, 0x22, 0xcc, 0xaf, 0xa1, 0xf4, 0x0d, + 0xda, 0x5c, 0xf6, 0xd1, 0x96, 0x49, 0x39, 0xae, 0x64, 0x83, 0xf9, 0x18, 0xde, 0x9d, 0x63, 0x10, + 0x3e, 0xf3, 0x04, 0xd2, 0x2f, 0x20, 0xef, 0x23, 0x77, 0x99, 0xa3, 0x8a, 0x79, 0x3b, 0x4d, 0x5f, + 0x4b, 0x35, 0x46, 0x33, 0x7b, 0x7c, 0xb2, 0xbd, 0x66, 0xa9, 0x0c, 0xf3, 0x8f, 0x0c, 0xdc, 0xfa, + 0xd6, 0x77, 0x6c, 0x89, 0x5d, 0x5b, 0x8c, 0x9e, 0x4a, 0x5b, 0x06, 0xe2, 0x5a, 0xd2, 0xe8, 0x77, + 0xb0, 0x11, 0x44, 0x44, 0x89, 0xe5, 0xfb, 0x69, 0x32, 0x96, 0xbc, 0x55, 0x3b, 0x8b, 0xc4, 0x08, + 0x2b, 0x21, 0x2b, 0x33, 0x28, 0x2d, 0x5e, 0xd2, 0x1d, 0xd8, 0x90, 0xb6, 0x18, 0x9d, 0xc9, 0x82, + 0xe9, 0xc9, 0x76, 0x3e, 0x84, 0x75, 0x5a, 0x56, 0x3e, 0xbc, 0xea, 0x38, 0xf4, 0x73, 0xc8, 0x8b, + 0x28, 0x49, 0x35, 0x8d, 0x91, 0xa6, 0x67, 0x4e, 0x89, 0x42, 0x9b, 0x65, 0xd0, 0x2f, 0xaa, 0x8c, + 0xad, 0x36, 0xf7, 0xa1, 0x18, 0x46, 0xaf, 0x67, 0x91, 0xf9, 0x95, 0xca, 0x4e, 0x46, 0xa0, 0x06, + 0xb9, 0x50, 0xab, 0xd0, 0x49, 0x64, 0x98, 0xbe, 0x4c, 0xa0, 0x15, 0xc3, 0xcc, 0x26, 0xd0, 0xfb, + 0x42, 0xb8, 0x43, 0x6f, 0x8c, 0x9e, 0xbc, 0xa6, 0x86, 0xd7, 0x99, 0x73, 0x24, 0x89, 0x94, 0x0e, + 0x64, 0xc3, 0x55, 0x14, 0xa5, 0x6f, 0x35, 0x3e, 0x4b, 0x53, 0x72, 0x31, 0x6b, 0x2e, 0xd4, 0x9d, + 0xf8, 0x68, 0x45, 0x14, 0xf4, 0x0e, 0x80, 0xed, 0xfb, 0x47, 0x2e, 0x8a, 0x9e, 0x64, 0xf1, 0x66, + 0xb0, 0x0a, 0x2a, 0xd2, 0x65, 0xe1, 0x35, 0x47, 0x11, 0x1c, 0x49, 0xd1, 0x73, 0x3d, 0x7d, 0x3d, + 0xbe, 0x56, 0x91, 0x8e, 0x47, 0xbf, 0x84, 0x62, 0x5c, 0xf9, 0x5e, 0x6c, 0x4d, 0xf6, 0x12, 0x6b, + 0xb4, 0x60, 0x56, 0x2b, 0x41, 0xef, 0x42, 0x91, 0xe3, 0x98, 0xbd, 0x48, 0x92, 0x73, 0x95, 0xf5, + 0x6a, 0xc1, 0xd2, 0xe2, 0x58, 0x04, 0x31, 0xeb, 0xb0, 0x75, 0x5e, 0x35, 0x2d, 0xc2, 0x8d, 0x07, + 0x8f, 0x0f, 0x9e, 0x3c, 0x6a, 0x77, 0xdb, 0xa5, 0x35, 0xfa, 0x0e, 0x68, 0x9d, 0xc3, 0x07, 0x56, + 0xfb, 0xa0, 0x7d, 0xd8, 0xbd, 0xff, 0xa8, 0x44, 0x1a, 0xaf, 0x72, 0x00, 0xad, 0xd9, 0x2e, 0xa7, + 0x3f, 0xc2, 0x86, 0xf2, 0x95, 0x9a, 0x69, 0xa2, 0xce, 0x6f, 0xdb, 0xf2, 0xdb, 0x30, 0xca, 0x45, + 0x73, 0xe7, 0xaf, 0xd7, 0xff, 0xbd, 0xca, 0xdc, 0x81, 0x62, 0x84, 0xf9, 0x38, 0xdc, 0x1b, 0xc8, + 0x61, 0x33, 0xfe, 0x52, 0x5b, 0xe9, 0x1e, 0xa1, 0x3f, 0x41, 0x61, 0x36, 0xfb, 0xf4, 0x83, 0x34, + 0xde, 0xc5, 0xe5, 0x52, 0xfe, 0xf0, 0x12, 0x94, 0xea, 0xea, 0x55, 0x04, 0xd0, 0x3f, 0x09, 0x94, + 0x16, 0xe7, 0x82, 0x7e, 0x74, 0x85, 0x19, 0x2f, 0xef, 0xad, 0x06, 0xbe, 0x8a, 0xa8, 0x00, 0x72, + 0x71, 0xe5, 0x2b, 0xcb, 0x1a, 0x64, 0xf6, 0xfa, 0x72, 0x44, 0x52, 0x87, 0xdd, 0x15, 0x5e, 0xfc, + 0x3d, 0x43, 0xee, 0x11, 0xfa, 0x2b, 0x01, 0x6d, 0x6e, 0x1c, 0xe8, 0xee, 0x25, 0xf3, 0x92, 0x68, + 0xd8, 0x5d, 0x6d, 0xae, 0x56, 0xec, 0x88, 0xe6, 0xed, 0xe3, 0x53, 0x63, 0xed, 0x9f, 0x53, 0x63, + 0xed, 0xff, 0x53, 0x83, 0xfc, 0x3c, 0x35, 0xc8, 0xf1, 0xd4, 0x20, 0x7f, 0x4f, 0x0d, 0xf2, 0xef, + 0xd4, 0x20, 0xfd, 0x7c, 0xf4, 0x17, 0xe0, 0xd3, 0x37, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe1, 0xdd, + 0xfa, 0x4f, 0x8a, 0x08, 0x00, 0x00, } diff --git a/api/dispatcher.proto b/api/dispatcher.proto index 18d5516b85..1ff4b91b85 100644 --- a/api/dispatcher.proto +++ b/api/dispatcher.proto @@ -47,6 +47,7 @@ service Dispatcher { // maybe dispatch, al likes this // it should be terminated. rpc Tasks(TasksRequest) returns (stream TasksMessage) { option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-worker" roles: "swarm-manager" }; + option deprecated = true; }; // Assignments is a stream of assignments such as tasks and secrets for node. diff --git a/api/objects.proto b/api/objects.proto index ac046741ad..b28fa935b5 100644 --- a/api/objects.proto +++ b/api/objects.proto @@ -221,4 +221,4 @@ message Cluster { // and agents to unambiguously identify the older key to be deleted when // a new key is allocated on key rotation. uint64 encryption_key_lamport_clock = 6; -} \ No newline at end of file +} diff --git a/api/specs.proto b/api/specs.proto index a59b2a8b0f..9f51ec5979 100644 --- a/api/specs.proto +++ b/api/specs.proto @@ -270,4 +270,4 @@ message ClusterSpec { // TaskDefaults specifies the default values to use for task creation. TaskDefaults task_defaults = 7 [(gogoproto.nullable) = false]; -} \ No newline at end of file +} diff --git a/api/types.proto b/api/types.proto index b0e2639ff2..61087ada38 100644 --- a/api/types.proto +++ b/api/types.proto @@ -712,4 +712,4 @@ message ManagerStatus { // Reachability specifies whether this node is reachable. RaftMemberStatus.Reachability reachability = 4; -} \ No newline at end of file +}