diff --git a/agent/agent.go b/agent/agent.go index 284d078ebf..7bd2c9e76d 100644 --- a/agent/agent.go +++ b/agent/agent.go @@ -158,9 +158,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 50cd649d02..f842400b03 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/picker" @@ -31,12 +32,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 +45,13 @@ type session struct { func newSession(ctx context.Context, agent *Agent, delay time.Duration, sessionID string) *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 { @@ -215,22 +216,42 @@ 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.Tasks(ctx, &api.TasksRequest{ - 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 { - 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 cbe276988d..d4fad100ac 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 @@ -171,6 +170,121 @@ 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).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 { + 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() diff --git a/api/dispatcher.pb.go b/api/dispatcher.pb.go index 818933dd31..dcdec05427 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,53 @@ func (p *raftProxyDispatcherServer) Tasks(r *TasksRequest, stream Dispatcher_Tas return nil } +func (p *raftProxyDispatcherServer) Assignments(r *AssignmentsRequest, stream Dispatcher_AssignmentsServer) error { + + if p.cluster.IsLeader() { + return p.local.Assignments(r, stream) + } + ctx, err := p.runCtxMods(stream.Context()) + if err != nil { + return err + } + 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 { + 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,33 +1787,84 @@ func (m *TasksMessage) Size() (n int) { return n } -func sovDispatcher(x uint64) (n int) { - for { - n++ - x >>= 7 - if x == 0 { - break - } +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 sozDispatcher(x uint64) (n int) { - return sovDispatcher(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (this *SessionRequest) String() string { - if this == nil { - return "nil" + +func (m *AssignmentsMessage) Size() (n int) { + var l int + _ = l + if m.Type != 0 { + n += 1 + sovDispatcher(uint64(m.Type)) } - s := strings.Join([]string{`&SessionRequest{`, - `Description:` + strings.Replace(fmt.Sprintf("%v", this.Description), "NodeDescription", "NodeDescription", 1) + `,`, - `SessionID:` + fmt.Sprintf("%v", this.SessionID) + `,`, - `}`, - }, "") - return s -} -func (this *SessionMessage) String() string { - if this == nil { - return "nil" + 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++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozDispatcher(x uint64) (n int) { + return sovDispatcher(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *SessionRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SessionRequest{`, + `Description:` + strings.Replace(fmt.Sprintf("%v", this.Description), "NodeDescription", "NodeDescription", 1) + `,`, + `SessionID:` + fmt.Sprintf("%v", this.SessionID) + `,`, + `}`, + }, "") + return s +} +func (this *SessionMessage) String() string { + if this == nil { + return "nil" } s := strings.Join([]string{`&SessionMessage{`, `SessionID:` + fmt.Sprintf("%v", this.SessionID) + `,`, @@ -1504,6 +1946,32 @@ func (this *TasksMessage) String() string { }, "") return s } +func (this *AssignmentsRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AssignmentsRequest{`, + `SessionID:` + fmt.Sprintf("%v", this.SessionID) + `,`, + `}`, + }, "") + return s +} +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() { @@ -2389,6 +2857,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 +3289,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 b83a16f85b..07ed892849 100644 --- a/api/specs.pb.go +++ b/api/specs.pb.go @@ -445,6 +445,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{} } @@ -519,6 +522,21 @@ func (m *ClusterSpec) Reset() { *m = ClusterSpec{} } func (*ClusterSpec) ProtoMessage() {} func (*ClusterSpec) Descriptor() ([]byte, []int) { return fileDescriptorSpecs, []int{8} } +// 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{9} } + func init() { proto.RegisterType((*NodeSpec)(nil), "docker.swarmkit.v1.NodeSpec") proto.RegisterType((*ServiceSpec)(nil), "docker.swarmkit.v1.ServiceSpec") @@ -531,6 +549,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) @@ -708,6 +727,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 } @@ -776,6 +802,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" @@ -894,7 +941,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)) @@ -925,6 +972,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, "") } @@ -985,6 +1035,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() { @@ -1453,6 +1516,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 } @@ -1657,6 +1732,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())) + n27, err := m.Annotations.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n27 + 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) @@ -1873,6 +2000,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 } @@ -1943,6 +2076,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++ @@ -2084,6 +2238,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 @@ -2139,6 +2294,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() { @@ -3436,6 +3604,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:]) @@ -4082,6 +4281,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 @@ -4188,91 +4546,95 @@ var ( ) var fileDescriptorSpecs = []byte{ - // 1361 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0x4d, 0x6f, 0x1b, 0xb7, - 0x16, 0xd5, 0xd8, 0x63, 0x59, 0xba, 0x23, 0x27, 0x0a, 0x91, 0x97, 0x4c, 0x94, 0x3c, 0x59, 0xd1, - 0xcb, 0x4b, 0xdd, 0x02, 0x95, 0x5b, 0xb5, 0xc8, 0x47, 0xd3, 0xa2, 0x95, 0x25, 0xd5, 0x71, 0x53, - 0x3b, 0x02, 0x9d, 0x04, 0xe8, 0x4a, 0xa0, 0x67, 0x68, 0x99, 0xf0, 0x68, 0x38, 0xe5, 0x70, 0x14, - 0x78, 0xd7, 0x65, 0xe0, 0x45, 0x77, 0x5d, 0x7a, 0x55, 0xa0, 0xcb, 0x2e, 0xfb, 0x1b, 0xb2, 0xec, - 0xa6, 0x40, 0x57, 0x41, 0xe3, 0x5f, 0x50, 0xa0, 0x7f, 0xa0, 0x20, 0x87, 0xfa, 0x6a, 0xc6, 0x49, - 0x17, 0xd9, 0x91, 0x57, 0xe7, 0x1c, 0xde, 0xb9, 0x3c, 0xbc, 0xa4, 0xc0, 0x89, 0x23, 0xea, 0xc5, - 0x8d, 0x48, 0x70, 0xc9, 0x11, 0xf2, 0xb9, 0x77, 0x48, 0x45, 0x23, 0x7e, 0x4a, 0xc4, 0xf0, 0x90, - 0xc9, 0xc6, 0xe8, 0xc3, 0x8a, 0x23, 0x8f, 0x22, 0x6a, 0x00, 0x95, 0x8b, 0x03, 0x3e, 0xe0, 0x7a, - 0xb8, 0xae, 0x46, 0x26, 0x7a, 0xd9, 0x4f, 0x04, 0x91, 0x8c, 0x87, 0xeb, 0xe3, 0x41, 0xfa, 0x43, - 0xfd, 0x7b, 0x1b, 0x0a, 0x3b, 0xdc, 0xa7, 0xbb, 0x11, 0xf5, 0xd0, 0x26, 0x38, 0x24, 0x0c, 0xb9, - 0xd4, 0x80, 0xd8, 0xb5, 0x6a, 0xd6, 0x9a, 0xd3, 0x5c, 0x6d, 0xbc, 0xba, 0x64, 0xa3, 0x35, 0x85, - 0x6d, 0xd8, 0xcf, 0x5f, 0xac, 0xe6, 0xf0, 0x2c, 0x13, 0x7d, 0x00, 0xb6, 0xe0, 0x01, 0x75, 0x17, - 0x6a, 0xd6, 0xda, 0xb9, 0xe6, 0xb5, 0x2c, 0x05, 0xb5, 0x28, 0xe6, 0x01, 0xc5, 0x1a, 0x89, 0x36, - 0x01, 0x86, 0x74, 0xb8, 0x47, 0x45, 0x7c, 0xc0, 0x22, 0x77, 0x51, 0xf3, 0xde, 0x39, 0x8b, 0xa7, - 0x92, 0x6d, 0x6c, 0x4f, 0xe0, 0x78, 0x86, 0x8a, 0xb6, 0xa1, 0x44, 0x46, 0x84, 0x05, 0x64, 0x8f, - 0x05, 0x4c, 0x1e, 0xb9, 0xb6, 0x96, 0x7a, 0xf7, 0xb5, 0x52, 0xad, 0x19, 0x02, 0x9e, 0xa3, 0xd7, - 0x7d, 0x80, 0xe9, 0x42, 0xe8, 0x26, 0x2c, 0xf7, 0xba, 0x3b, 0x9d, 0xad, 0x9d, 0xcd, 0x72, 0xae, - 0x72, 0xe5, 0xf8, 0xa4, 0xf6, 0x1f, 0xa5, 0x31, 0x05, 0xf4, 0x68, 0xe8, 0xb3, 0x70, 0x80, 0xd6, - 0xa0, 0xd0, 0x6a, 0xb7, 0xbb, 0xbd, 0x47, 0xdd, 0x4e, 0xd9, 0xaa, 0x54, 0x8e, 0x4f, 0x6a, 0x97, - 0xe6, 0x81, 0x2d, 0xcf, 0xa3, 0x91, 0xa4, 0x7e, 0xc5, 0x7e, 0xf6, 0x63, 0x35, 0x57, 0x7f, 0x66, - 0x41, 0x69, 0x36, 0x09, 0x74, 0x13, 0xf2, 0xad, 0xf6, 0xa3, 0xad, 0x27, 0xdd, 0x72, 0x6e, 0x4a, - 0x9f, 0x45, 0xb4, 0x3c, 0xc9, 0x46, 0x14, 0xdd, 0x80, 0xa5, 0x5e, 0xeb, 0xf1, 0x6e, 0xb7, 0x6c, - 0x4d, 0xd3, 0x99, 0x85, 0xf5, 0x48, 0x12, 0x6b, 0x54, 0x07, 0xb7, 0xb6, 0x76, 0xca, 0x0b, 0xd9, - 0xa8, 0x8e, 0x20, 0x2c, 0x34, 0xa9, 0xfc, 0x62, 0x83, 0xb3, 0x4b, 0xc5, 0x88, 0x79, 0x6f, 0xd9, - 0x13, 0xb7, 0xc0, 0x96, 0x24, 0x3e, 0xd4, 0x9e, 0x70, 0xb2, 0x3d, 0xf1, 0x88, 0xc4, 0x87, 0x6a, - 0x51, 0x43, 0xd7, 0x78, 0xe5, 0x0c, 0x41, 0xa3, 0x80, 0x79, 0x44, 0x52, 0x5f, 0x3b, 0xc3, 0x69, - 0xfe, 0x3f, 0x8b, 0x8d, 0x27, 0x28, 0x93, 0xff, 0xfd, 0x1c, 0x9e, 0xa1, 0xa2, 0x7b, 0x90, 0x1f, - 0x04, 0x7c, 0x8f, 0x04, 0xda, 0x13, 0x4e, 0xf3, 0x7a, 0x96, 0xc8, 0xa6, 0x46, 0x4c, 0x05, 0x0c, - 0x05, 0xdd, 0x81, 0x7c, 0x12, 0xf9, 0x44, 0x52, 0x37, 0xaf, 0xc9, 0xb5, 0x2c, 0xf2, 0x63, 0x8d, - 0x68, 0xf3, 0x70, 0x9f, 0x0d, 0xb0, 0xc1, 0xa3, 0x5d, 0x28, 0x84, 0x54, 0x3e, 0xe5, 0xe2, 0x30, - 0x76, 0x97, 0x6b, 0x8b, 0x6b, 0x4e, 0xf3, 0x76, 0x16, 0x77, 0xa6, 0xe6, 0x8d, 0x9d, 0x14, 0xdf, - 0x92, 0x92, 0x78, 0x07, 0x43, 0x1a, 0x4a, 0x23, 0x39, 0x11, 0x42, 0x9f, 0x42, 0x81, 0x86, 0x7e, - 0xc4, 0x59, 0x28, 0xdd, 0xc2, 0xd9, 0x09, 0x75, 0x0d, 0x46, 0xa9, 0xe2, 0x09, 0xa3, 0xf2, 0x00, - 0x2e, 0x9f, 0xb1, 0x04, 0xba, 0x04, 0x79, 0x49, 0xc4, 0x80, 0x4a, 0xbd, 0xd3, 0x45, 0x6c, 0x66, - 0xc8, 0x85, 0x65, 0x12, 0x30, 0x12, 0xd3, 0xd8, 0x5d, 0xa8, 0x2d, 0xae, 0x15, 0xf1, 0x78, 0xba, - 0x91, 0x07, 0x7b, 0xc8, 0x7d, 0x5a, 0x5f, 0x87, 0x0b, 0xaf, 0xec, 0x00, 0xaa, 0x40, 0xc1, 0xec, - 0x40, 0x6a, 0x1d, 0x1b, 0x4f, 0xe6, 0xf5, 0xf3, 0xb0, 0x32, 0x57, 0xed, 0xfa, 0x6f, 0x0b, 0x50, - 0x18, 0x5b, 0x00, 0xb5, 0xa0, 0xe8, 0xf1, 0x50, 0x12, 0x16, 0x52, 0x61, 0x5c, 0x97, 0xb9, 0x61, - 0xed, 0x31, 0x48, 0xb1, 0xee, 0xe7, 0xf0, 0x94, 0x85, 0xbe, 0x84, 0xa2, 0xa0, 0x31, 0x4f, 0x84, - 0xa7, 0xb3, 0x56, 0x12, 0x6b, 0xd9, 0xc6, 0x49, 0x41, 0x98, 0x7e, 0x9b, 0x30, 0x41, 0x55, 0x35, - 0x62, 0x3c, 0xa5, 0xa2, 0x7b, 0xb0, 0x2c, 0x68, 0x2c, 0x89, 0x90, 0xaf, 0x73, 0x0e, 0x4e, 0x21, - 0x3d, 0x1e, 0x30, 0xef, 0x08, 0x8f, 0x19, 0xe8, 0x1e, 0x14, 0xa3, 0x80, 0x78, 0x5a, 0xd5, 0x5d, - 0xd2, 0xf4, 0xff, 0x66, 0xd1, 0x7b, 0x63, 0x10, 0x9e, 0xe2, 0xd1, 0x5d, 0x80, 0x80, 0x0f, 0xfa, - 0xbe, 0x60, 0x23, 0x2a, 0x8c, 0xf3, 0x2a, 0x59, 0xec, 0x8e, 0x46, 0xe0, 0x62, 0xc0, 0x07, 0xe9, - 0x70, 0xa3, 0x08, 0xcb, 0x22, 0x09, 0x25, 0x1b, 0xd2, 0xfa, 0xcf, 0x36, 0xac, 0xcc, 0x95, 0x09, - 0x5d, 0x84, 0x25, 0x36, 0x24, 0x03, 0x6a, 0x36, 0x39, 0x9d, 0xa0, 0x2e, 0xe4, 0x03, 0xb2, 0x47, - 0x83, 0x74, 0x8b, 0x9d, 0xe6, 0xfb, 0x6f, 0xac, 0x77, 0xe3, 0x6b, 0x8d, 0xef, 0x86, 0x52, 0x1c, - 0x61, 0x43, 0x56, 0x56, 0xf1, 0xf8, 0x70, 0x48, 0x42, 0x75, 0x5a, 0xb5, 0x55, 0xcc, 0x14, 0x21, - 0xb0, 0x89, 0x18, 0xc4, 0xae, 0xad, 0xc3, 0x7a, 0x8c, 0xca, 0xb0, 0x48, 0xc3, 0x91, 0xbb, 0xa4, - 0x43, 0x6a, 0xa8, 0x22, 0x3e, 0x4b, 0xbf, 0xb6, 0x88, 0xd5, 0x50, 0xf1, 0x92, 0x98, 0x0a, 0x77, - 0x59, 0x87, 0xf4, 0x18, 0xdd, 0x86, 0xfc, 0x90, 0x27, 0xa1, 0x8c, 0xdd, 0x82, 0x4e, 0xf6, 0x4a, - 0x56, 0xb2, 0xdb, 0x0a, 0x61, 0xba, 0x89, 0x81, 0xa3, 0xfb, 0x70, 0x21, 0x96, 0x3c, 0xea, 0x0f, - 0x04, 0xf1, 0x68, 0x3f, 0xa2, 0x82, 0x71, 0xdf, 0x2d, 0x9e, 0xdd, 0x94, 0x3a, 0xe6, 0xc2, 0xc4, - 0xe7, 0x15, 0x6d, 0x53, 0xb1, 0x7a, 0x9a, 0x84, 0x7a, 0x50, 0x8a, 0x92, 0x20, 0xe8, 0xf3, 0x28, - 0xed, 0x8d, 0xa0, 0x45, 0xfe, 0x45, 0xd5, 0x7a, 0x49, 0x10, 0x3c, 0x4c, 0x49, 0xd8, 0x89, 0xa6, - 0x13, 0x75, 0xfa, 0x06, 0x82, 0x27, 0x51, 0xec, 0x3a, 0xba, 0x1e, 0x66, 0x56, 0xb9, 0x0b, 0xce, - 0x4c, 0xa5, 0x55, 0x85, 0x0e, 0xe9, 0x91, 0xd9, 0x3c, 0x35, 0x54, 0x1b, 0x3a, 0x22, 0x41, 0x92, - 0xde, 0xb8, 0x45, 0x9c, 0x4e, 0x3e, 0x59, 0xb8, 0x63, 0x55, 0x9a, 0xe0, 0xcc, 0x2c, 0x87, 0xfe, - 0x07, 0x2b, 0x82, 0x0e, 0x58, 0x2c, 0xc5, 0x51, 0x9f, 0x24, 0xf2, 0xc0, 0xfd, 0x42, 0x13, 0x4a, - 0xe3, 0x60, 0x2b, 0x91, 0x07, 0xf5, 0xbf, 0x2c, 0x28, 0xcd, 0xb6, 0x0e, 0xd4, 0x4e, 0xcf, 0xb8, - 0x5e, 0xf1, 0x5c, 0x73, 0xfd, 0x4d, 0xad, 0x46, 0x9f, 0xa8, 0x20, 0x51, 0x2b, 0x6e, 0xab, 0x6b, - 0x5e, 0x93, 0xd1, 0xc7, 0xb0, 0x14, 0x71, 0x21, 0xc7, 0xee, 0xaa, 0x66, 0x9e, 0x02, 0x2e, 0xc6, - 0xcd, 0x2e, 0x05, 0xd7, 0x0f, 0xe0, 0xdc, 0xbc, 0x1a, 0xba, 0x01, 0x8b, 0x4f, 0xb6, 0x7a, 0xe5, - 0x5c, 0xe5, 0xea, 0xf1, 0x49, 0xed, 0xf2, 0xfc, 0x8f, 0x4f, 0x98, 0x90, 0x09, 0x09, 0xb6, 0x7a, - 0xe8, 0x3d, 0x58, 0xea, 0xec, 0xec, 0x62, 0x5c, 0xb6, 0x2a, 0xab, 0xc7, 0x27, 0xb5, 0xab, 0xf3, - 0x38, 0xf5, 0x13, 0x4f, 0x42, 0x1f, 0xf3, 0xbd, 0xc9, 0xcd, 0xf7, 0xc3, 0x02, 0x38, 0xa6, 0x2d, - 0xbe, 0xdd, 0x9b, 0xef, 0x73, 0x58, 0x49, 0x4f, 0x70, 0xdf, 0xd3, 0x9f, 0x66, 0x7a, 0xd1, 0xeb, - 0x0e, 0x72, 0x29, 0x25, 0x98, 0xa6, 0x7c, 0x1d, 0x4a, 0x2c, 0x1a, 0xdd, 0xea, 0xd3, 0x90, 0xec, - 0x05, 0xe6, 0x12, 0x2c, 0x60, 0x47, 0xc5, 0xba, 0x69, 0x48, 0x35, 0x5a, 0x16, 0x4a, 0x2a, 0x42, - 0x73, 0xbd, 0x15, 0xf0, 0x64, 0x8e, 0x3e, 0x03, 0x9b, 0x45, 0x64, 0x68, 0xba, 0x4f, 0xe6, 0x17, - 0x6c, 0xf5, 0x5a, 0xdb, 0xc6, 0x22, 0x1b, 0x85, 0xd3, 0x17, 0xab, 0xb6, 0x0a, 0x60, 0x4d, 0xab, - 0xff, 0x64, 0x83, 0xd3, 0x0e, 0x92, 0x58, 0x9a, 0xe6, 0xf1, 0xd6, 0xea, 0xf2, 0x0d, 0x5c, 0x20, - 0xfa, 0x1d, 0x44, 0x42, 0x75, 0x12, 0x75, 0xe3, 0x34, 0xb5, 0xb9, 0x91, 0x29, 0x37, 0x01, 0xa7, - 0x4d, 0x76, 0x23, 0xaf, 0x34, 0x5d, 0x0b, 0x97, 0xc9, 0x3f, 0x7e, 0x41, 0xbb, 0xb0, 0xc2, 0x85, - 0x77, 0x40, 0x63, 0x99, 0x1e, 0x5e, 0xf3, 0x6e, 0xc8, 0x7c, 0x51, 0x3e, 0x9c, 0x05, 0xa6, 0x15, - 0x37, 0xd9, 0xce, 0x6b, 0xa0, 0x3b, 0x60, 0x0b, 0xb2, 0x3f, 0xbe, 0x04, 0x32, 0xfd, 0x8b, 0xc9, - 0xbe, 0x9c, 0x93, 0xd0, 0x0c, 0xf4, 0x15, 0x80, 0xcf, 0xe2, 0x88, 0x48, 0xef, 0x80, 0x0a, 0xb3, - 0x0f, 0x99, 0x9f, 0xd8, 0x99, 0xa0, 0xe6, 0x54, 0x66, 0xd8, 0xe8, 0x01, 0x14, 0x3d, 0x32, 0x76, - 0x52, 0xfe, 0xec, 0xbe, 0xd5, 0x6e, 0x19, 0x89, 0xb2, 0x92, 0x38, 0x7d, 0xb1, 0x5a, 0x18, 0x47, - 0x70, 0xc1, 0x23, 0xc6, 0x59, 0x0f, 0x60, 0x45, 0x3d, 0xb2, 0xfa, 0x3e, 0xdd, 0x27, 0x49, 0x20, - 0x63, 0xdd, 0x62, 0xcf, 0x78, 0x4c, 0xa8, 0xab, 0xb9, 0x63, 0x70, 0x26, 0xaf, 0x92, 0x9c, 0x8d, - 0x5d, 0x7b, 0xfe, 0xb2, 0x9a, 0xfb, 0xfd, 0x65, 0x35, 0xf7, 0xe7, 0xcb, 0xaa, 0xf5, 0xdd, 0x69, - 0xd5, 0x7a, 0x7e, 0x5a, 0xb5, 0x7e, 0x3d, 0xad, 0x5a, 0x7f, 0x9c, 0x56, 0xad, 0xbd, 0xbc, 0xfe, - 0xc3, 0xf1, 0xd1, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa4, 0x46, 0x7c, 0xf6, 0xcf, 0x0c, 0x00, - 0x00, + // 1432 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0xcf, 0x6f, 0x1b, 0xc5, + 0x17, 0xf7, 0x26, 0x1b, 0xc7, 0x7e, 0xeb, 0xb4, 0xee, 0xa8, 0xdf, 0x76, 0xeb, 0xf6, 0xeb, 0xb8, + 0x6e, 0x29, 0x01, 0x09, 0x07, 0x0c, 0xea, 0x0f, 0x4a, 0x05, 0x8e, 0x6d, 0xd2, 0x50, 0x92, 0x5a, + 0x93, 0xb4, 0x12, 0x27, 0x6b, 0xb2, 0x3b, 0x71, 0x56, 0x59, 0xef, 0x2c, 0xb3, 0xb3, 0xae, 0x72, + 0xe3, 0x58, 0xe5, 0xc0, 0x8d, 0x63, 0x4e, 0x48, 0xdc, 0xb9, 0xf0, 0x37, 0xf4, 0xc8, 0x05, 0x89, + 0x53, 0x45, 0x73, 0x47, 0x42, 0xe2, 0x1f, 0x40, 0x33, 0x3b, 0xb6, 0xd7, 0x74, 0xd3, 0x72, 0xc8, + 0xed, 0xcd, 0xdb, 0xcf, 0xe7, 0xcd, 0x9b, 0x37, 0x6f, 0x3e, 0x33, 0x0b, 0x56, 0x14, 0x52, 0x27, + 0x6a, 0x84, 0x9c, 0x09, 0x86, 0x90, 0xcb, 0x9c, 0x03, 0xca, 0x1b, 0xd1, 0x33, 0xc2, 0x87, 0x07, + 0x9e, 0x68, 0x8c, 0x3e, 0xaa, 0x58, 0xe2, 0x30, 0xa4, 0x1a, 0x50, 0xb9, 0x38, 0x60, 0x03, 0xa6, + 0xcc, 0x55, 0x69, 0x69, 0xef, 0x65, 0x37, 0xe6, 0x44, 0x78, 0x2c, 0x58, 0x1d, 0x1b, 0xc9, 0x87, + 0xfa, 0xf7, 0x26, 0x14, 0xb6, 0x98, 0x4b, 0xb7, 0x43, 0xea, 0xa0, 0x75, 0xb0, 0x48, 0x10, 0x30, + 0xa1, 0x00, 0x91, 0x6d, 0xd4, 0x8c, 0x15, 0xab, 0xb9, 0xdc, 0x78, 0x7d, 0xca, 0x46, 0x6b, 0x0a, + 0x5b, 0x33, 0x5f, 0xbc, 0x5c, 0xce, 0xe1, 0x34, 0x13, 0x7d, 0x08, 0x26, 0x67, 0x3e, 0xb5, 0xe7, + 0x6a, 0xc6, 0xca, 0xb9, 0xe6, 0xb5, 0xac, 0x08, 0x72, 0x52, 0xcc, 0x7c, 0x8a, 0x15, 0x12, 0xad, + 0x03, 0x0c, 0xe9, 0x70, 0x97, 0xf2, 0x68, 0xdf, 0x0b, 0xed, 0x79, 0xc5, 0x7b, 0xf7, 0x34, 0x9e, + 0x4c, 0xb6, 0xb1, 0x39, 0x81, 0xe3, 0x14, 0x15, 0x6d, 0x42, 0x89, 0x8c, 0x88, 0xe7, 0x93, 0x5d, + 0xcf, 0xf7, 0xc4, 0xa1, 0x6d, 0xaa, 0x50, 0xef, 0xbd, 0x31, 0x54, 0x2b, 0x45, 0xc0, 0x33, 0xf4, + 0xba, 0x0b, 0x30, 0x9d, 0x08, 0xdd, 0x82, 0xc5, 0x5e, 0x77, 0xab, 0xb3, 0xb1, 0xb5, 0x5e, 0xce, + 0x55, 0xae, 0x1c, 0x1d, 0xd7, 0xfe, 0x27, 0x63, 0x4c, 0x01, 0x3d, 0x1a, 0xb8, 0x5e, 0x30, 0x40, + 0x2b, 0x50, 0x68, 0xb5, 0xdb, 0xdd, 0xde, 0x4e, 0xb7, 0x53, 0x36, 0x2a, 0x95, 0xa3, 0xe3, 0xda, + 0xa5, 0x59, 0x60, 0xcb, 0x71, 0x68, 0x28, 0xa8, 0x5b, 0x31, 0x9f, 0xff, 0x58, 0xcd, 0xd5, 0x9f, + 0x1b, 0x50, 0x4a, 0x27, 0x81, 0x6e, 0x41, 0xbe, 0xd5, 0xde, 0xd9, 0x78, 0xda, 0x2d, 0xe7, 0xa6, + 0xf4, 0x34, 0xa2, 0xe5, 0x08, 0x6f, 0x44, 0xd1, 0x4d, 0x58, 0xe8, 0xb5, 0x9e, 0x6c, 0x77, 0xcb, + 0xc6, 0x34, 0x9d, 0x34, 0xac, 0x47, 0xe2, 0x48, 0xa1, 0x3a, 0xb8, 0xb5, 0xb1, 0x55, 0x9e, 0xcb, + 0x46, 0x75, 0x38, 0xf1, 0x02, 0x9d, 0xca, 0x2f, 0x26, 0x58, 0xdb, 0x94, 0x8f, 0x3c, 0xe7, 0x8c, + 0x7b, 0xe2, 0x36, 0x98, 0x82, 0x44, 0x07, 0xaa, 0x27, 0xac, 0xec, 0x9e, 0xd8, 0x21, 0xd1, 0x81, + 0x9c, 0x54, 0xd3, 0x15, 0x5e, 0x76, 0x06, 0xa7, 0xa1, 0xef, 0x39, 0x44, 0x50, 0x57, 0x75, 0x86, + 0xd5, 0x7c, 0x27, 0x8b, 0x8d, 0x27, 0x28, 0x9d, 0xff, 0xc3, 0x1c, 0x4e, 0x51, 0xd1, 0x7d, 0xc8, + 0x0f, 0x7c, 0xb6, 0x4b, 0x7c, 0xd5, 0x13, 0x56, 0xf3, 0x7a, 0x56, 0x90, 0x75, 0x85, 0x98, 0x06, + 0xd0, 0x14, 0x74, 0x17, 0xf2, 0x71, 0xe8, 0x12, 0x41, 0xed, 0xbc, 0x22, 0xd7, 0xb2, 0xc8, 0x4f, + 0x14, 0xa2, 0xcd, 0x82, 0x3d, 0x6f, 0x80, 0x35, 0x1e, 0x6d, 0x43, 0x21, 0xa0, 0xe2, 0x19, 0xe3, + 0x07, 0x91, 0xbd, 0x58, 0x9b, 0x5f, 0xb1, 0x9a, 0x77, 0xb2, 0xb8, 0xa9, 0x9a, 0x37, 0xb6, 0x12, + 0x7c, 0x4b, 0x08, 0xe2, 0xec, 0x0f, 0x69, 0x20, 0x74, 0xc8, 0x49, 0x20, 0xf4, 0x19, 0x14, 0x68, + 0xe0, 0x86, 0xcc, 0x0b, 0x84, 0x5d, 0x38, 0x3d, 0xa1, 0xae, 0xc6, 0xc8, 0xa8, 0x78, 0xc2, 0xa8, + 0x3c, 0x82, 0xcb, 0xa7, 0x4c, 0x81, 0x2e, 0x41, 0x5e, 0x10, 0x3e, 0xa0, 0x42, 0xed, 0x74, 0x11, + 0xeb, 0x11, 0xb2, 0x61, 0x91, 0xf8, 0x1e, 0x89, 0x68, 0x64, 0xcf, 0xd5, 0xe6, 0x57, 0x8a, 0x78, + 0x3c, 0x5c, 0xcb, 0x83, 0x39, 0x64, 0x2e, 0xad, 0xaf, 0xc2, 0x85, 0xd7, 0x76, 0x00, 0x55, 0xa0, + 0xa0, 0x77, 0x20, 0x69, 0x1d, 0x13, 0x4f, 0xc6, 0xf5, 0xf3, 0xb0, 0x34, 0x53, 0xed, 0xfa, 0x6f, + 0x73, 0x50, 0x18, 0xb7, 0x00, 0x6a, 0x41, 0xd1, 0x61, 0x81, 0x20, 0x5e, 0x40, 0xb9, 0xee, 0xba, + 0xcc, 0x0d, 0x6b, 0x8f, 0x41, 0x92, 0xf5, 0x30, 0x87, 0xa7, 0x2c, 0xf4, 0x25, 0x14, 0x39, 0x8d, + 0x58, 0xcc, 0x1d, 0x95, 0xb5, 0x0c, 0xb1, 0x92, 0xdd, 0x38, 0x09, 0x08, 0xd3, 0x6f, 0x63, 0x8f, + 0x53, 0x59, 0x8d, 0x08, 0x4f, 0xa9, 0xe8, 0x3e, 0x2c, 0x72, 0x1a, 0x09, 0xc2, 0xc5, 0x9b, 0x3a, + 0x07, 0x27, 0x90, 0x1e, 0xf3, 0x3d, 0xe7, 0x10, 0x8f, 0x19, 0xe8, 0x3e, 0x14, 0x43, 0x9f, 0x38, + 0x2a, 0xaa, 0xbd, 0xa0, 0xe8, 0xff, 0xcf, 0xa2, 0xf7, 0xc6, 0x20, 0x3c, 0xc5, 0xa3, 0x7b, 0x00, + 0x3e, 0x1b, 0xf4, 0x5d, 0xee, 0x8d, 0x28, 0xd7, 0x9d, 0x57, 0xc9, 0x62, 0x77, 0x14, 0x02, 0x17, + 0x7d, 0x36, 0x48, 0xcc, 0xb5, 0x22, 0x2c, 0xf2, 0x38, 0x10, 0xde, 0x90, 0xd6, 0xff, 0x34, 0x61, + 0x69, 0xa6, 0x4c, 0xe8, 0x22, 0x2c, 0x78, 0x43, 0x32, 0xa0, 0x7a, 0x93, 0x93, 0x01, 0xea, 0x42, + 0xde, 0x27, 0xbb, 0xd4, 0x4f, 0xb6, 0xd8, 0x6a, 0x7e, 0xf0, 0xd6, 0x7a, 0x37, 0xbe, 0x56, 0xf8, + 0x6e, 0x20, 0xf8, 0x21, 0xd6, 0x64, 0xd9, 0x2a, 0x0e, 0x1b, 0x0e, 0x49, 0x20, 0x4f, 0xab, 0x6a, + 0x15, 0x3d, 0x44, 0x08, 0x4c, 0xc2, 0x07, 0x91, 0x6d, 0x2a, 0xb7, 0xb2, 0x51, 0x19, 0xe6, 0x69, + 0x30, 0xb2, 0x17, 0x94, 0x4b, 0x9a, 0xd2, 0xe3, 0x7a, 0xc9, 0x6a, 0x8b, 0x58, 0x9a, 0x92, 0x17, + 0x47, 0x94, 0xdb, 0x8b, 0xca, 0xa5, 0x6c, 0x74, 0x07, 0xf2, 0x43, 0x16, 0x07, 0x22, 0xb2, 0x0b, + 0x2a, 0xd9, 0x2b, 0x59, 0xc9, 0x6e, 0x4a, 0x84, 0x56, 0x13, 0x0d, 0x47, 0x0f, 0xe1, 0x42, 0x24, + 0x58, 0xd8, 0x1f, 0x70, 0xe2, 0xd0, 0x7e, 0x48, 0xb9, 0xc7, 0x5c, 0xbb, 0x78, 0xba, 0x28, 0x75, + 0xf4, 0x85, 0x89, 0xcf, 0x4b, 0xda, 0xba, 0x64, 0xf5, 0x14, 0x09, 0xf5, 0xa0, 0x14, 0xc6, 0xbe, + 0xdf, 0x67, 0x61, 0xa2, 0x8d, 0xa0, 0x82, 0xfc, 0x87, 0xaa, 0xf5, 0x62, 0xdf, 0x7f, 0x9c, 0x90, + 0xb0, 0x15, 0x4e, 0x07, 0xf2, 0xf4, 0x0d, 0x38, 0x8b, 0xc3, 0xc8, 0xb6, 0x54, 0x3d, 0xf4, 0x08, + 0x3d, 0x80, 0xc5, 0x88, 0x3a, 0x9c, 0x8a, 0xc8, 0x2e, 0xa9, 0xd5, 0xde, 0xc8, 0x96, 0x10, 0x09, + 0xc1, 0x74, 0x8f, 0x72, 0x1a, 0x38, 0x14, 0x8f, 0x39, 0x95, 0x7b, 0x60, 0xa5, 0x36, 0x4a, 0x16, + 0xf8, 0x80, 0x1e, 0xea, 0xbd, 0x97, 0xa6, 0xec, 0x87, 0x11, 0xf1, 0xe3, 0xe4, 0xc2, 0x2e, 0xe2, + 0x64, 0xf0, 0xe9, 0xdc, 0x5d, 0xa3, 0xd2, 0x04, 0x2b, 0x95, 0x2d, 0xba, 0x01, 0x4b, 0x9c, 0x0e, + 0xbc, 0x48, 0xf0, 0xc3, 0x3e, 0x89, 0xc5, 0xbe, 0xfd, 0x85, 0x22, 0x94, 0xc6, 0xce, 0x56, 0x2c, + 0xf6, 0xeb, 0x7f, 0x1b, 0x50, 0x4a, 0x2b, 0x0f, 0x6a, 0x27, 0x12, 0xa1, 0x66, 0x3c, 0xd7, 0x5c, + 0x7d, 0x9b, 0x52, 0xa9, 0x03, 0xe9, 0xc7, 0x72, 0xc6, 0x4d, 0xf9, 0x4a, 0x50, 0x64, 0xf4, 0x09, + 0x2c, 0x84, 0x8c, 0x8b, 0x71, 0x73, 0x56, 0x33, 0x0f, 0x11, 0xe3, 0x63, 0xad, 0x4c, 0xc0, 0xf5, + 0x7d, 0x38, 0x37, 0x1b, 0x0d, 0xdd, 0x84, 0xf9, 0xa7, 0x1b, 0xbd, 0x72, 0xae, 0x72, 0xf5, 0xe8, + 0xb8, 0x76, 0x79, 0xf6, 0xe3, 0x53, 0x8f, 0x8b, 0x98, 0xf8, 0x1b, 0x3d, 0xf4, 0x3e, 0x2c, 0x74, + 0xb6, 0xb6, 0x31, 0x2e, 0x1b, 0x95, 0xe5, 0xa3, 0xe3, 0xda, 0xd5, 0x59, 0x9c, 0xfc, 0xc4, 0xe2, + 0xc0, 0xc5, 0x6c, 0x77, 0x72, 0x71, 0xfe, 0x30, 0x07, 0x96, 0x56, 0xd5, 0xb3, 0xbd, 0x38, 0x3f, + 0x87, 0xa5, 0x44, 0x00, 0xfa, 0x8e, 0x5a, 0x9a, 0x96, 0xb2, 0x37, 0xe9, 0x40, 0x29, 0x21, 0x68, + 0x4d, 0xbf, 0x0e, 0x25, 0x2f, 0x1c, 0xdd, 0xee, 0xd3, 0x80, 0xec, 0xfa, 0xfa, 0x0e, 0x2d, 0x60, + 0x4b, 0xfa, 0xba, 0x89, 0x4b, 0xea, 0xb4, 0x17, 0x08, 0xca, 0x03, 0x7d, 0x3b, 0x16, 0xf0, 0x64, + 0x8c, 0x1e, 0x80, 0xe9, 0x85, 0x64, 0xa8, 0xc5, 0x2b, 0x73, 0x05, 0x1b, 0xbd, 0xd6, 0xa6, 0x6e, + 0x91, 0xb5, 0xc2, 0xc9, 0xcb, 0x65, 0x53, 0x3a, 0xb0, 0xa2, 0xd5, 0x7f, 0x32, 0xc1, 0x6a, 0xfb, + 0x71, 0x24, 0xb4, 0xf6, 0x9c, 0x59, 0x5d, 0xbe, 0x81, 0x0b, 0x44, 0x3d, 0xa3, 0x48, 0x20, 0x0f, + 0xb2, 0xd2, 0x5d, 0x5d, 0x9b, 0x9b, 0x99, 0xe1, 0x26, 0xe0, 0x44, 0xa3, 0xd7, 0xf2, 0x32, 0xa6, + 0x6d, 0xe0, 0x32, 0xf9, 0xd7, 0x17, 0xb4, 0x0d, 0x4b, 0x8c, 0x3b, 0xfb, 0x34, 0x12, 0xc9, 0xd9, + 0xd7, 0xcf, 0x8e, 0xcc, 0x07, 0xe9, 0xe3, 0x34, 0x30, 0xa9, 0xb8, 0xce, 0x76, 0x36, 0x06, 0xba, + 0x0b, 0x26, 0x27, 0x7b, 0xe3, 0x3b, 0x24, 0xb3, 0x7f, 0x31, 0xd9, 0x13, 0x33, 0x21, 0x14, 0x03, + 0x7d, 0x05, 0xe0, 0x7a, 0x51, 0x48, 0x84, 0xb3, 0x4f, 0xb9, 0xde, 0x87, 0xcc, 0x25, 0x76, 0x26, + 0xa8, 0x99, 0x28, 0x29, 0x36, 0x7a, 0x04, 0x45, 0x87, 0x8c, 0x3b, 0x29, 0x7f, 0xba, 0xec, 0xb5, + 0x5b, 0x3a, 0x44, 0x59, 0x86, 0x38, 0x79, 0xb9, 0x5c, 0x18, 0x7b, 0x70, 0xc1, 0x21, 0xba, 0xb3, + 0x1e, 0xc1, 0x92, 0x7c, 0xa3, 0xf5, 0x5d, 0xba, 0x47, 0x62, 0x5f, 0x44, 0x4a, 0xa1, 0x4f, 0x79, + 0x8b, 0xc8, 0x9b, 0xbd, 0xa3, 0x71, 0x3a, 0xaf, 0x92, 0x48, 0xf9, 0xea, 0x3f, 0x1b, 0x00, 0x89, + 0x84, 0x9d, 0x6d, 0x9f, 0x34, 0xc1, 0x94, 0x3f, 0x48, 0xfa, 0x67, 0xa4, 0x7a, 0xba, 0x72, 0xee, + 0x1c, 0x86, 0x14, 0x2b, 0xac, 0xbc, 0x71, 0x04, 0x19, 0x44, 0xfa, 0x02, 0x53, 0xb6, 0xf4, 0xb9, + 0x44, 0x10, 0xb5, 0x7f, 0x25, 0xac, 0xec, 0xb5, 0x6b, 0x2f, 0x5e, 0x55, 0x73, 0xbf, 0xbf, 0xaa, + 0xe6, 0xfe, 0x7a, 0x55, 0x35, 0xbe, 0x3b, 0xa9, 0x1a, 0x2f, 0x4e, 0xaa, 0xc6, 0xaf, 0x27, 0x55, + 0xe3, 0x8f, 0x93, 0xaa, 0xb1, 0x9b, 0x57, 0xff, 0x58, 0x1f, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, + 0x21, 0x71, 0xc5, 0x55, 0xc2, 0x0d, 0x00, 0x00, } diff --git a/api/specs.proto b/api/specs.proto index 73d3fe4279..e121627d7a 100644 --- a/api/specs.proto +++ b/api/specs.proto @@ -186,6 +186,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 @@ -260,3 +264,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 5a8288a0b3..3b95d46188 100644 --- a/api/types.pb.go +++ b/api/types.pb.go @@ -54,6 +54,7 @@ Certificate EncryptionKey ManagerStatus + SecretReference NodeSpec ServiceSpec ReplicatedService @@ -63,6 +64,7 @@ EndpointSpec NetworkSpec ClusterSpec + SecretSpec Meta Node Service @@ -71,6 +73,7 @@ NetworkAttachment Network Cluster + Secret GetNodeRequest GetNodeResponse ListNodesRequest @@ -118,6 +121,8 @@ UpdateTaskStatusResponse TasksRequest TasksMessage + AssignmentsRequest + AssignmentsMessage NodeCertificateStatusRequest NodeCertificateStatusResponse IssueNodeCertificateRequest @@ -248,6 +253,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 ( @@ -568,6 +595,28 @@ func (EncryptionKey_Algorithm) EnumDescriptor() ([]byte, []int) { return fileDescriptorTypes, []int{35, 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{37, 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"` @@ -1259,6 +1308,20 @@ func (m *ManagerStatus) Reset() { *m = ManagerStatus{} } func (*ManagerStatus) ProtoMessage() {} func (*ManagerStatus) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{36} } +// 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{37} } + func init() { proto.RegisterType((*Version)(nil), "docker.swarmkit.v1.Version") proto.RegisterType((*Annotations)(nil), "docker.swarmkit.v1.Annotations") @@ -1302,8 +1365,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) @@ -1316,6 +1381,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 { @@ -1966,6 +2032,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" @@ -2588,6 +2674,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() { @@ -4237,6 +4335,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) @@ -4968,6 +5103,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++ @@ -5543,6 +5697,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() { @@ -11150,6 +11316,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 @@ -11256,218 +11550,224 @@ var ( ) var fileDescriptorTypes = []byte{ - // 3398 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, 0xa2, 0x68, 0x63, 0x10, 0x20, 0x44, 0xa9, 0xbb, 0x44, 0xf5, 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, 0xb3, 0x49, 0xd3, 0x1a, 0x4f, - 0x76, 0x4f, 0xec, 0x7a, 0xf5, 0xbd, 0x57, 0xef, 0x55, 0xbd, 0x7a, 0xf5, 0x55, 0x11, 0x4a, 0x7c, - 0x32, 0xa2, 0x61, 0x6d, 0x14, 0x30, 0xce, 0x10, 0x72, 0x98, 0x7d, 0x4c, 0x83, 0x5a, 0x78, 0x4a, - 0x82, 0xe1, 0xb1, 0xcb, 0x6b, 0x27, 0x9f, 0x54, 0x6e, 0x73, 0x77, 0x48, 0x43, 0x4e, 0x86, 0xa3, - 0x8f, 0xe2, 0x2f, 0x05, 0xaf, 0xbc, 0xe5, 0x8c, 0x03, 0xc2, 0x5d, 0xe6, 0x7f, 0x14, 0x7d, 0xe8, - 0x8e, 0x9b, 0x03, 0x36, 0x60, 0xf2, 0xf3, 0x23, 0xf1, 0xa5, 0xa4, 0xe6, 0x06, 0x2c, 0x3f, 0xa5, - 0x41, 0xe8, 0x32, 0x1f, 0xdd, 0x84, 0x9c, 0xeb, 0x3b, 0xf4, 0xf9, 0x5a, 0xaa, 0x9a, 0xba, 0x9f, - 0xc5, 0xaa, 0x61, 0xfe, 0x75, 0x0a, 0x4a, 0x96, 0xef, 0x33, 0x2e, 0x6d, 0x85, 0x08, 0x41, 0xd6, - 0x27, 0x43, 0x2a, 0x41, 0x45, 0x2c, 0xbf, 0x51, 0x1d, 0xf2, 0x1e, 0x39, 0xa0, 0x5e, 0xb8, 0x96, - 0xae, 0x66, 0xee, 0x97, 0x36, 0x7f, 0x58, 0x7b, 0xd5, 0xe7, 0x5a, 0xc2, 0x48, 0x6d, 0x47, 0xa2, - 0x9b, 0x3e, 0x0f, 0x26, 0x58, 0xab, 0x56, 0x7e, 0x0c, 0xa5, 0x84, 0x18, 0x19, 0x90, 0x39, 0xa6, - 0x13, 0x3d, 0x8c, 0xf8, 0x14, 0xfe, 0x9d, 0x10, 0x6f, 0x4c, 0xd7, 0xd2, 0x52, 0xa6, 0x1a, 0x9f, - 0xa5, 0x1f, 0xa4, 0xcc, 0x2f, 0xa1, 0x88, 0x69, 0xc8, 0xc6, 0x81, 0x4d, 0x43, 0xf4, 0x03, 0x28, - 0xfa, 0xc4, 0x67, 0x7d, 0x7b, 0x34, 0x0e, 0xa5, 0x7a, 0x66, 0xab, 0x7c, 0x79, 0xb1, 0x51, 0x68, - 0x13, 0x9f, 0xd5, 0x3b, 0xbd, 0x10, 0x17, 0x44, 0x77, 0x7d, 0x34, 0x0e, 0xd1, 0xbb, 0x50, 0x1e, - 0xd2, 0x21, 0x0b, 0x26, 0xfd, 0x83, 0x09, 0xa7, 0xa1, 0x34, 0x9c, 0xc1, 0x25, 0x25, 0xdb, 0x12, - 0x22, 0xf3, 0x2f, 0x53, 0x70, 0x33, 0xb2, 0x8d, 0xe9, 0x1f, 0x8e, 0xdd, 0x80, 0x0e, 0xa9, 0xcf, - 0x43, 0xf4, 0xdb, 0x90, 0xf7, 0xdc, 0xa1, 0xcb, 0xd5, 0x18, 0xa5, 0xcd, 0x77, 0x16, 0xc5, 0x1c, - 0x7b, 0x85, 0x35, 0x18, 0x59, 0x50, 0x0e, 0x68, 0x48, 0x83, 0x13, 0x35, 0x13, 0x72, 0xc8, 0x6f, - 0x55, 0x9e, 0x51, 0x31, 0xb7, 0xa1, 0xd0, 0xf1, 0x08, 0x3f, 0x64, 0xc1, 0x10, 0x99, 0x50, 0x26, - 0x81, 0x7d, 0xe4, 0x72, 0x6a, 0xf3, 0x71, 0x10, 0xad, 0xca, 0x8c, 0x0c, 0xdd, 0x82, 0x34, 0x53, - 0x03, 0x15, 0xb7, 0xf2, 0x97, 0x17, 0x1b, 0xe9, 0xbd, 0x2e, 0x4e, 0xb3, 0xd0, 0x7c, 0x08, 0xd7, - 0x3b, 0xde, 0x78, 0xe0, 0xfa, 0x0d, 0x1a, 0xda, 0x81, 0x3b, 0x12, 0xd6, 0xc5, 0xf2, 0x8a, 0xe4, - 0x8b, 0x96, 0x57, 0x7c, 0xc7, 0x4b, 0x9e, 0x9e, 0x2e, 0xb9, 0xf9, 0xe7, 0x69, 0xb8, 0xde, 0xf4, - 0x07, 0xae, 0x4f, 0x93, 0xda, 0xf7, 0x60, 0x95, 0x4a, 0x61, 0xff, 0x44, 0x25, 0x95, 0xb6, 0xb3, - 0xa2, 0xa4, 0x51, 0xa6, 0xb5, 0xe6, 0xf2, 0xe5, 0x93, 0x45, 0xe1, 0xbf, 0x62, 0x7d, 0x51, 0xd6, - 0xa0, 0x26, 0x2c, 0x8f, 0x64, 0x10, 0xe1, 0x5a, 0x46, 0xda, 0xba, 0xb7, 0xc8, 0xd6, 0x2b, 0x71, - 0x6e, 0x65, 0xbf, 0xbe, 0xd8, 0x58, 0xc2, 0x91, 0xee, 0xaf, 0x93, 0x7c, 0xff, 0x99, 0x82, 0x6b, - 0x6d, 0xe6, 0xcc, 0xcc, 0x43, 0x05, 0x0a, 0x47, 0x2c, 0xe4, 0x89, 0x8d, 0x12, 0xb7, 0xd1, 0x03, - 0x28, 0x8c, 0xf4, 0xf2, 0xe9, 0xd5, 0xbf, 0xb3, 0xd8, 0x65, 0x85, 0xc1, 0x31, 0x1a, 0x3d, 0x84, - 0x62, 0x10, 0xe5, 0xc4, 0x5a, 0xe6, 0x4d, 0x12, 0x67, 0x8a, 0x47, 0xbf, 0x07, 0x79, 0xb5, 0x08, - 0x6b, 0x59, 0xa9, 0x79, 0xef, 0x8d, 0xe6, 0x1c, 0x6b, 0x25, 0xf3, 0x17, 0x29, 0x30, 0x30, 0x39, - 0xe4, 0xbb, 0x74, 0x78, 0x40, 0x83, 0x2e, 0x27, 0x7c, 0x1c, 0xa2, 0x5b, 0x90, 0xf7, 0x28, 0x71, - 0x68, 0x20, 0x83, 0x2c, 0x60, 0xdd, 0x42, 0x3d, 0x91, 0xe4, 0xc4, 0x3e, 0x22, 0x07, 0xae, 0xe7, - 0xf2, 0x89, 0x0c, 0x73, 0x75, 0xf1, 0x2a, 0xcf, 0xdb, 0xac, 0xe1, 0x84, 0x22, 0x9e, 0x31, 0x83, - 0xd6, 0x60, 0x79, 0x48, 0xc3, 0x90, 0x0c, 0xa8, 0x8c, 0xbe, 0x88, 0xa3, 0xa6, 0xf9, 0x10, 0xca, - 0x49, 0x3d, 0x54, 0x82, 0xe5, 0x5e, 0xfb, 0x49, 0x7b, 0xef, 0x59, 0xdb, 0x58, 0x42, 0xd7, 0xa0, - 0xd4, 0x6b, 0xe3, 0xa6, 0x55, 0x7f, 0x6c, 0x6d, 0xed, 0x34, 0x8d, 0x14, 0x5a, 0x81, 0xe2, 0xb4, - 0x99, 0x36, 0x7f, 0x96, 0x02, 0x10, 0x0b, 0xa8, 0x83, 0xfa, 0x0c, 0x72, 0x21, 0x27, 0x5c, 0x2d, - 0xdc, 0xea, 0xe6, 0x7b, 0x8b, 0xbc, 0x9e, 0xc2, 0x6b, 0xe2, 0x87, 0x62, 0xa5, 0x92, 0xf4, 0x30, - 0x3d, 0xef, 0x61, 0x4e, 0x22, 0x67, 0x5d, 0x2b, 0x40, 0xb6, 0x21, 0xbe, 0x52, 0xa8, 0x08, 0x39, - 0xdc, 0xb4, 0x1a, 0x5f, 0x1a, 0x69, 0x64, 0x40, 0xb9, 0xd1, 0xea, 0xd6, 0xf7, 0xda, 0xed, 0x66, - 0x7d, 0xbf, 0xd9, 0x30, 0x32, 0xe6, 0x3d, 0xc8, 0xb5, 0x86, 0x64, 0x40, 0xd1, 0x1d, 0x91, 0x01, - 0x87, 0x34, 0xa0, 0xbe, 0x1d, 0x25, 0xd6, 0x54, 0x60, 0xfe, 0xbc, 0x08, 0xb9, 0x5d, 0x36, 0xf6, - 0x39, 0xda, 0x4c, 0xec, 0xe2, 0xd5, 0xcd, 0xf5, 0x45, 0x21, 0x48, 0x60, 0x6d, 0x7f, 0x32, 0xa2, - 0x7a, 0x97, 0xdf, 0x82, 0xbc, 0xca, 0x15, 0xed, 0xba, 0x6e, 0x09, 0x39, 0x27, 0xc1, 0x80, 0x72, - 0x3d, 0xe9, 0xba, 0x85, 0xee, 0x43, 0x21, 0xa0, 0xc4, 0x61, 0xbe, 0x37, 0x91, 0x29, 0x55, 0x50, - 0x65, 0x16, 0x53, 0xe2, 0xec, 0xf9, 0xde, 0x04, 0xc7, 0xbd, 0xe8, 0x31, 0x94, 0x0f, 0x5c, 0xdf, - 0xe9, 0xb3, 0x91, 0xaa, 0x79, 0xb9, 0xd7, 0x27, 0xa0, 0xf2, 0x6a, 0xcb, 0xf5, 0x9d, 0x3d, 0x05, - 0xc6, 0xa5, 0x83, 0x69, 0x03, 0xb5, 0x61, 0xf5, 0x84, 0x79, 0xe3, 0x21, 0x8d, 0x6d, 0xe5, 0xa5, - 0xad, 0xf7, 0x5f, 0x6f, 0xeb, 0xa9, 0xc4, 0x47, 0xd6, 0x56, 0x4e, 0x92, 0x4d, 0xf4, 0x04, 0x56, - 0xf8, 0x70, 0x74, 0x18, 0xc6, 0xe6, 0x96, 0xa5, 0xb9, 0xef, 0x5f, 0x31, 0x61, 0x02, 0x1e, 0x59, - 0x2b, 0xf3, 0x44, 0xab, 0xf2, 0x67, 0x19, 0x28, 0x25, 0x3c, 0x47, 0x5d, 0x28, 0x8d, 0x02, 0x36, - 0x22, 0x03, 0x59, 0xb7, 0xf5, 0x5a, 0x7c, 0xf2, 0x46, 0x51, 0xd7, 0x3a, 0x53, 0x45, 0x9c, 0xb4, - 0x62, 0x9e, 0xa7, 0xa1, 0x94, 0xe8, 0x44, 0x1f, 0x40, 0x01, 0x77, 0x70, 0xeb, 0xa9, 0xb5, 0xdf, - 0x34, 0x96, 0x2a, 0x77, 0xce, 0xce, 0xab, 0x6b, 0xd2, 0x5a, 0xd2, 0x40, 0x27, 0x70, 0x4f, 0x44, - 0xea, 0xdd, 0x87, 0xe5, 0x08, 0x9a, 0xaa, 0xbc, 0x7d, 0x76, 0x5e, 0x7d, 0x6b, 0x1e, 0x9a, 0x40, - 0xe2, 0xee, 0x63, 0x0b, 0x37, 0x1b, 0x46, 0x7a, 0x31, 0x12, 0x77, 0x8f, 0x48, 0x40, 0x1d, 0xf4, - 0x7d, 0xc8, 0x6b, 0x60, 0xa6, 0x52, 0x39, 0x3b, 0xaf, 0xde, 0x9a, 0x07, 0x4e, 0x71, 0xb8, 0xbb, - 0x63, 0x3d, 0x6d, 0x1a, 0xd9, 0xc5, 0x38, 0xdc, 0xf5, 0xc8, 0x09, 0x45, 0xef, 0x41, 0x4e, 0xc1, - 0x72, 0x95, 0xdb, 0x67, 0xe7, 0xd5, 0xef, 0xbd, 0x62, 0x4e, 0xa0, 0x2a, 0x6b, 0x7f, 0xf1, 0x37, - 0xeb, 0x4b, 0xff, 0xf4, 0xb7, 0xeb, 0xc6, 0x7c, 0x77, 0xe5, 0x7f, 0x53, 0xb0, 0x32, 0xb3, 0xe4, - 0xc8, 0x84, 0xbc, 0xcf, 0x6c, 0x36, 0x52, 0xe5, 0xbc, 0xb0, 0x05, 0x97, 0x17, 0x1b, 0xf9, 0x36, - 0xab, 0xb3, 0xd1, 0x04, 0xeb, 0x1e, 0xf4, 0x64, 0xee, 0x40, 0xfa, 0xf4, 0x0d, 0xf3, 0x69, 0xe1, - 0x91, 0xf4, 0x39, 0xac, 0x38, 0x81, 0x7b, 0x42, 0x83, 0xbe, 0xcd, 0xfc, 0x43, 0x77, 0xa0, 0x4b, - 0x75, 0x65, 0x91, 0xcd, 0x86, 0x04, 0xe2, 0xb2, 0x52, 0xa8, 0x4b, 0xfc, 0xaf, 0x71, 0x18, 0x55, - 0x9e, 0x42, 0x39, 0x99, 0xa1, 0xe8, 0x1d, 0x80, 0xd0, 0xfd, 0x23, 0xaa, 0xf9, 0x8d, 0x64, 0x43, - 0xb8, 0x28, 0x24, 0x92, 0xdd, 0xa0, 0xf7, 0x21, 0x3b, 0x64, 0x8e, 0xb2, 0x93, 0xdb, 0xba, 0x21, - 0xce, 0xc4, 0x7f, 0xbb, 0xd8, 0x28, 0xb1, 0xb0, 0xb6, 0xed, 0x7a, 0x74, 0x97, 0x39, 0x14, 0x4b, - 0x80, 0x79, 0x02, 0x59, 0x51, 0x2a, 0xd0, 0xdb, 0x90, 0xdd, 0x6a, 0xb5, 0x1b, 0xc6, 0x52, 0xe5, - 0xfa, 0xd9, 0x79, 0x75, 0x45, 0x4e, 0x89, 0xe8, 0x10, 0xb9, 0x8b, 0x36, 0x20, 0xff, 0x74, 0x6f, - 0xa7, 0xb7, 0x2b, 0xd2, 0xeb, 0xc6, 0xd9, 0x79, 0xf5, 0x5a, 0xdc, 0xad, 0x26, 0x0d, 0xbd, 0x03, - 0xb9, 0xfd, 0xdd, 0xce, 0x76, 0xd7, 0x48, 0x57, 0xd0, 0xd9, 0x79, 0x75, 0x35, 0xee, 0x97, 0x3e, - 0x57, 0xae, 0xeb, 0x55, 0x2d, 0xc6, 0x72, 0xf3, 0x7f, 0xd2, 0xb0, 0x82, 0x05, 0xbf, 0x0d, 0x78, - 0x87, 0x79, 0xae, 0x3d, 0x41, 0x1d, 0x28, 0xda, 0xcc, 0x77, 0xdc, 0xc4, 0x9e, 0xda, 0x7c, 0xcd, - 0x21, 0x38, 0xd5, 0x8a, 0x5a, 0xf5, 0x48, 0x13, 0x4f, 0x8d, 0xa0, 0x4d, 0xc8, 0x39, 0xd4, 0x23, - 0x93, 0xab, 0x4e, 0xe3, 0x86, 0xe6, 0xd2, 0x58, 0x41, 0x25, 0x73, 0x24, 0xcf, 0xfb, 0x84, 0x73, - 0x3a, 0x1c, 0x71, 0x75, 0x1a, 0x67, 0x71, 0x69, 0x48, 0x9e, 0x5b, 0x5a, 0x84, 0x7e, 0x04, 0xf9, - 0x53, 0xd7, 0x77, 0xd8, 0xa9, 0x3e, 0x70, 0xaf, 0xb6, 0xab, 0xb1, 0xe6, 0x99, 0x38, 0x67, 0xe7, - 0x9c, 0x15, 0xb3, 0xde, 0xde, 0x6b, 0x37, 0xa3, 0x59, 0xd7, 0xfd, 0x7b, 0x7e, 0x9b, 0xf9, 0x62, - 0xc7, 0xc0, 0x5e, 0xbb, 0xbf, 0x6d, 0xb5, 0x76, 0x7a, 0x58, 0xcc, 0xfc, 0xcd, 0xb3, 0xf3, 0xaa, - 0x11, 0x43, 0xb6, 0x89, 0xeb, 0x09, 0x12, 0x78, 0x1b, 0x32, 0x56, 0xfb, 0x4b, 0x23, 0x5d, 0x31, - 0xce, 0xce, 0xab, 0xe5, 0xb8, 0xdb, 0xf2, 0x27, 0xd3, 0xcd, 0x34, 0x3f, 0xae, 0xf9, 0x5f, 0x29, - 0x28, 0xf7, 0x46, 0x0e, 0xe1, 0x54, 0x65, 0x26, 0xaa, 0x42, 0x69, 0x44, 0x02, 0xe2, 0x79, 0xd4, - 0x73, 0xc3, 0xa1, 0xbe, 0x28, 0x24, 0x45, 0xe8, 0xc1, 0x77, 0x98, 0x4c, 0x4d, 0xc2, 0xf4, 0x94, - 0xf6, 0x60, 0xf5, 0x50, 0x39, 0xdb, 0x27, 0xb6, 0x5c, 0xdd, 0x8c, 0x5c, 0xdd, 0xda, 0x22, 0x13, - 0x49, 0xaf, 0x6a, 0x3a, 0x46, 0x4b, 0x6a, 0xe1, 0x95, 0xc3, 0x64, 0xd3, 0xbc, 0x0f, 0x2b, 0x33, - 0xfd, 0xe2, 0xa4, 0xed, 0x58, 0xbd, 0x6e, 0xd3, 0x58, 0x42, 0x65, 0x28, 0xd4, 0xf7, 0xda, 0xfb, - 0xad, 0x76, 0xaf, 0x69, 0xa4, 0xcc, 0x7f, 0x48, 0x47, 0xd1, 0x6a, 0x26, 0xb0, 0x35, 0xcb, 0x04, - 0x3e, 0x7c, 0xbd, 0x23, 0x9a, 0x0b, 0x4c, 0x1b, 0x31, 0x23, 0xf8, 0x5d, 0x00, 0x39, 0xa9, 0xd4, - 0xe9, 0x13, 0x7e, 0x15, 0xdb, 0xdf, 0x8f, 0xee, 0x71, 0xb8, 0xa8, 0x15, 0x2c, 0x8e, 0xbe, 0x80, - 0xb2, 0xcd, 0x86, 0x23, 0x8f, 0x6a, 0xfd, 0xcc, 0x9b, 0xe8, 0x97, 0x62, 0x15, 0x8b, 0x27, 0x19, - 0x49, 0x76, 0x96, 0x91, 0xd4, 0xa1, 0x94, 0xf0, 0x77, 0x96, 0x97, 0x94, 0xa1, 0xd0, 0xeb, 0x34, - 0xac, 0xfd, 0x56, 0xfb, 0x91, 0x91, 0x42, 0x00, 0x79, 0x39, 0x63, 0x0d, 0x23, 0x2d, 0xb8, 0x53, - 0x7d, 0x6f, 0xb7, 0xb3, 0xd3, 0x54, 0xcc, 0xe4, 0x4f, 0xe0, 0x5a, 0x9d, 0xf9, 0x9c, 0xb8, 0x7e, - 0x4c, 0x0a, 0x37, 0x85, 0xcf, 0x5a, 0xd4, 0x77, 0x1d, 0x55, 0xb7, 0xb6, 0xae, 0x5d, 0x5e, 0x6c, - 0x94, 0x62, 0x68, 0xab, 0x21, 0xbc, 0x8c, 0x1a, 0x8e, 0xc8, 0xce, 0x91, 0xeb, 0xe8, 0x32, 0xb4, - 0x7c, 0x79, 0xb1, 0x91, 0xe9, 0xb4, 0x1a, 0x58, 0xc8, 0xd0, 0xdb, 0x50, 0xa4, 0xcf, 0x5d, 0xde, - 0xb7, 0x45, 0x9d, 0x12, 0xf1, 0xe7, 0x70, 0x41, 0x08, 0xea, 0xa2, 0x2c, 0xfd, 0x69, 0x1a, 0x60, - 0x9f, 0x84, 0xc7, 0x7a, 0xe8, 0x87, 0x50, 0x8c, 0xaf, 0xc3, 0x57, 0x5d, 0xcb, 0x12, 0x73, 0x1d, - 0xe3, 0xd1, 0xa7, 0xd1, 0x6a, 0x2b, 0xb6, 0xba, 0x58, 0x51, 0x8f, 0xb5, 0x88, 0xf0, 0xcd, 0x52, - 0x52, 0x51, 0xb5, 0x69, 0x10, 0xe8, 0x49, 0x17, 0x9f, 0xa8, 0x2e, 0x2b, 0x97, 0x8a, 0x59, 0x73, - 0xa0, 0xbb, 0x8b, 0x06, 0x99, 0x9b, 0xd0, 0xc7, 0x4b, 0x78, 0xaa, 0xb7, 0x65, 0xc0, 0x6a, 0x30, - 0xf6, 0x85, 0xd7, 0xfd, 0x50, 0x76, 0x9b, 0xff, 0x92, 0x06, 0x68, 0x75, 0xac, 0x5d, 0xbd, 0x45, - 0x1b, 0x90, 0x3f, 0x24, 0x43, 0xd7, 0x9b, 0x5c, 0x95, 0xb5, 0x53, 0x7c, 0xcd, 0x72, 0x9c, 0x80, - 0x86, 0xe1, 0xb6, 0xd4, 0xc1, 0x5a, 0x57, 0x92, 0xc1, 0xf1, 0x81, 0x4f, 0x79, 0x4c, 0x06, 0x65, - 0x4b, 0x9c, 0x3c, 0x01, 0xf1, 0xe3, 0x68, 0x55, 0x43, 0xcc, 0xc2, 0x80, 0x70, 0x7a, 0x4a, 0x26, - 0x51, 0x92, 0xe9, 0x26, 0x7a, 0x2c, 0x48, 0xa2, 0xb8, 0xbb, 0x52, 0x67, 0x2d, 0x27, 0x8f, 0xd6, - 0x6f, 0xf3, 0x07, 0x6b, 0xb8, 0x3a, 0x53, 0x63, 0xed, 0xca, 0x43, 0x79, 0x10, 0x4c, 0xbb, 0xbe, - 0xd3, 0x1d, 0xed, 0x63, 0x58, 0x99, 0x89, 0xf3, 0x15, 0x16, 0xde, 0xea, 0x3c, 0xfd, 0x91, 0x91, - 0xd5, 0x5f, 0xbf, 0x63, 0xe4, 0xcd, 0xff, 0x4e, 0x01, 0x74, 0x98, 0x2c, 0x86, 0x62, 0x56, 0x17, - 0xbf, 0x7a, 0x14, 0xe4, 0x1b, 0x8a, 0xcd, 0x3c, 0x9d, 0x33, 0x0b, 0x69, 0xe8, 0xd4, 0x8a, 0x60, - 0x75, 0x12, 0x8e, 0x63, 0x45, 0xb4, 0x01, 0x25, 0xc5, 0xa7, 0xfb, 0x23, 0x16, 0xa8, 0x0d, 0xbe, - 0x82, 0x41, 0x89, 0x84, 0xa6, 0xb8, 0x52, 0x8f, 0xc6, 0x07, 0x9e, 0x1b, 0x1e, 0x51, 0x47, 0x61, - 0xb2, 0x12, 0xb3, 0x12, 0x4b, 0x05, 0xcc, 0x6c, 0x40, 0x21, 0xb2, 0x8e, 0xd6, 0x20, 0xb3, 0x5f, - 0xef, 0x18, 0x4b, 0x95, 0x6b, 0x67, 0xe7, 0xd5, 0x52, 0x24, 0xde, 0xaf, 0x77, 0x44, 0x4f, 0xaf, - 0xd1, 0x31, 0x52, 0xb3, 0x3d, 0xbd, 0x46, 0xa7, 0x92, 0x15, 0x87, 0x80, 0xf9, 0x57, 0x29, 0xc8, - 0x2b, 0x4a, 0xb2, 0x30, 0x62, 0x0b, 0x96, 0x23, 0xa2, 0xac, 0x78, 0xd2, 0xfb, 0xaf, 0xe7, 0x34, - 0x35, 0x4d, 0x41, 0xd4, 0x3a, 0x46, 0x7a, 0x95, 0xcf, 0xa0, 0x9c, 0xec, 0xf8, 0x4e, 0xab, 0xf8, - 0xc7, 0x50, 0x12, 0x89, 0x12, 0x71, 0x9b, 0x4d, 0xc8, 0x2b, 0xda, 0xa4, 0xb7, 0xfa, 0x55, 0x04, - 0x4b, 0x23, 0xd1, 0x03, 0x58, 0x56, 0xa4, 0x2c, 0x7a, 0x2e, 0x58, 0xbf, 0x3a, 0x1d, 0x71, 0x04, - 0x37, 0x3f, 0x87, 0x6c, 0x87, 0xd2, 0x00, 0xdd, 0x85, 0x65, 0x9f, 0x39, 0x74, 0x5a, 0xd9, 0x34, - 0x9f, 0x74, 0x68, 0xab, 0x21, 0xf8, 0xa4, 0x43, 0x5b, 0x8e, 0x98, 0x3c, 0xe2, 0x38, 0x41, 0xf4, - 0x62, 0x22, 0xbe, 0xcd, 0x7d, 0x28, 0x3f, 0xa3, 0xee, 0xe0, 0x88, 0x53, 0x47, 0x1a, 0xfa, 0x10, - 0xb2, 0x23, 0x1a, 0x3b, 0xbf, 0xb6, 0x30, 0x75, 0x28, 0x0d, 0xb0, 0x44, 0x89, 0x0d, 0x79, 0x2a, - 0xb5, 0xf5, 0x23, 0x95, 0x6e, 0x99, 0x7f, 0x9f, 0x86, 0xd5, 0x56, 0x18, 0x8e, 0x89, 0x6f, 0x47, - 0xc7, 0xd6, 0x4f, 0x66, 0x8f, 0xad, 0xfb, 0x0b, 0x23, 0x9c, 0x51, 0x99, 0xbd, 0xc4, 0xea, 0xca, - 0x95, 0x8e, 0x2b, 0x97, 0xf9, 0x75, 0x2a, 0xba, 0xbd, 0xde, 0x4b, 0xec, 0x9b, 0xca, 0xda, 0xd9, - 0x79, 0xf5, 0x66, 0xd2, 0x12, 0xed, 0xf9, 0xc7, 0x3e, 0x3b, 0xf5, 0xd1, 0xbb, 0xe2, 0x36, 0xdb, - 0x6e, 0x3e, 0x33, 0x52, 0x95, 0x5b, 0x67, 0xe7, 0x55, 0x34, 0x03, 0xc2, 0xd4, 0xa7, 0xa7, 0xc2, - 0x52, 0xa7, 0xd9, 0x6e, 0x88, 0x13, 0x26, 0xbd, 0xc0, 0x52, 0x87, 0xfa, 0x8e, 0xeb, 0x0f, 0xd0, - 0x5d, 0xc8, 0xb7, 0xba, 0xdd, 0x9e, 0xbc, 0x5f, 0xbc, 0x75, 0x76, 0x5e, 0xbd, 0x31, 0x83, 0x12, - 0x0d, 0xea, 0x08, 0x90, 0xe0, 0x3f, 0xcd, 0x86, 0x91, 0x5d, 0x00, 0x12, 0xc7, 0x3f, 0x75, 0x74, - 0x86, 0xff, 0x7b, 0x1a, 0x0c, 0xcb, 0xb6, 0xe9, 0x88, 0x8b, 0x7e, 0xcd, 0x29, 0xf7, 0xa1, 0x30, - 0x12, 0x5f, 0xae, 0xe4, 0xc8, 0x22, 0x2d, 0x1e, 0x2c, 0x7c, 0xc1, 0x9c, 0xd3, 0xab, 0x61, 0xe6, - 0x51, 0xcb, 0x19, 0xba, 0x61, 0x28, 0xee, 0x4e, 0x52, 0x86, 0x63, 0x4b, 0x95, 0x5f, 0xa6, 0xe0, - 0xc6, 0x02, 0x04, 0xfa, 0x18, 0xb2, 0x01, 0xf3, 0xa2, 0xe5, 0xb9, 0xf3, 0xba, 0xf7, 0x05, 0xa1, - 0x8a, 0x25, 0x12, 0xad, 0x03, 0x90, 0x31, 0x67, 0x44, 0x8e, 0x2f, 0x17, 0xa6, 0x80, 0x13, 0x12, - 0xf4, 0x0c, 0xf2, 0x21, 0xb5, 0x03, 0x1a, 0x11, 0x84, 0xcf, 0xff, 0xbf, 0xde, 0xd7, 0xba, 0xd2, - 0x0c, 0xd6, 0xe6, 0x2a, 0x35, 0xc8, 0x2b, 0x89, 0xc8, 0x68, 0x87, 0x70, 0x22, 0x9d, 0x2e, 0x63, - 0xf9, 0x2d, 0x12, 0x85, 0x78, 0x83, 0x28, 0x51, 0x88, 0x37, 0x30, 0x7f, 0x96, 0x06, 0x68, 0x3e, - 0xe7, 0x34, 0xf0, 0x89, 0x57, 0xb7, 0x50, 0x33, 0x51, 0x21, 0x55, 0xb4, 0x3f, 0x58, 0xf8, 0xea, - 0x14, 0x6b, 0xd4, 0xea, 0xd6, 0x82, 0x1a, 0x79, 0x1b, 0x32, 0xe3, 0xc0, 0xd3, 0x2f, 0x98, 0x92, - 0x1d, 0xf4, 0xf0, 0x0e, 0x16, 0x32, 0xd4, 0x9c, 0x56, 0xa4, 0xcc, 0xeb, 0x9f, 0x9e, 0x13, 0x03, - 0xfc, 0xe6, 0xab, 0xd2, 0x87, 0x00, 0x53, 0xaf, 0xd1, 0x3a, 0xe4, 0xea, 0xdb, 0xdd, 0xee, 0x8e, - 0xb1, 0xa4, 0xae, 0x40, 0xd3, 0x2e, 0x29, 0x36, 0xff, 0x2e, 0x05, 0x85, 0xba, 0xa5, 0x4f, 0x95, - 0x6d, 0x30, 0x64, 0x2d, 0xb1, 0x69, 0xc0, 0xfb, 0xf4, 0xf9, 0xc8, 0x0d, 0x26, 0xba, 0x1c, 0x5c, - 0x7d, 0x59, 0x58, 0x15, 0x5a, 0x75, 0x1a, 0xf0, 0xa6, 0xd4, 0x41, 0x18, 0xca, 0x54, 0x87, 0xd8, - 0xb7, 0x49, 0x54, 0x9c, 0xd7, 0xaf, 0x9e, 0x0a, 0x45, 0xc9, 0xa6, 0xed, 0x10, 0x97, 0x22, 0x23, - 0x75, 0x12, 0x9a, 0x4f, 0xe1, 0xc6, 0x5e, 0x60, 0x1f, 0xd1, 0x90, 0xab, 0x41, 0xb5, 0xcb, 0x9f, - 0xc3, 0x1d, 0x4e, 0xc2, 0xe3, 0xfe, 0x91, 0x1b, 0x72, 0x16, 0x4c, 0xfa, 0x01, 0xe5, 0xd4, 0x17, - 0xfd, 0x7d, 0xf9, 0xc0, 0xad, 0xaf, 0x98, 0xb7, 0x05, 0xe6, 0xb1, 0x82, 0xe0, 0x08, 0xb1, 0x23, - 0x00, 0x66, 0x0b, 0xca, 0x82, 0x45, 0x35, 0xe8, 0x21, 0x19, 0x7b, 0x3c, 0x44, 0x3f, 0x06, 0xf0, - 0xd8, 0xa0, 0xff, 0xc6, 0x95, 0xbc, 0xe8, 0xb1, 0x81, 0xfa, 0x34, 0x7f, 0x1f, 0x8c, 0x86, 0x1b, - 0x8e, 0x08, 0xb7, 0x8f, 0xa2, 0xbb, 0x33, 0x7a, 0x04, 0xc6, 0x11, 0x25, 0x01, 0x3f, 0xa0, 0x84, - 0xf7, 0x47, 0x34, 0x70, 0x99, 0xf3, 0x46, 0x53, 0x7a, 0x2d, 0xd6, 0xea, 0x48, 0x25, 0xf3, 0x57, - 0x29, 0x00, 0x4c, 0x0e, 0x23, 0x02, 0xf0, 0x43, 0xb8, 0x1e, 0xfa, 0x64, 0x14, 0x1e, 0x31, 0xde, - 0x77, 0x7d, 0x4e, 0x83, 0x13, 0xe2, 0xe9, 0xfb, 0x8f, 0x11, 0x75, 0xb4, 0xb4, 0x1c, 0x7d, 0x08, - 0xe8, 0x98, 0xd2, 0x51, 0x9f, 0x79, 0x4e, 0x3f, 0xea, 0x54, 0x2f, 0xf0, 0x59, 0x6c, 0x88, 0x9e, - 0x3d, 0xcf, 0xe9, 0x46, 0x72, 0xb4, 0x05, 0xeb, 0x62, 0x06, 0xa8, 0xcf, 0x03, 0x97, 0x86, 0xfd, - 0x43, 0x16, 0xf4, 0x43, 0x8f, 0x9d, 0xf6, 0x0f, 0x99, 0xe7, 0xb1, 0x53, 0x1a, 0x44, 0xb7, 0xcb, - 0x8a, 0xc7, 0x06, 0x4d, 0x05, 0xda, 0x66, 0x41, 0xd7, 0x63, 0xa7, 0xdb, 0x11, 0x42, 0xb0, 0x84, - 0x69, 0xd8, 0xdc, 0xb5, 0x8f, 0x23, 0x96, 0x10, 0x4b, 0xf7, 0x5d, 0xfb, 0x18, 0xdd, 0x85, 0x15, - 0xea, 0x51, 0x79, 0x0f, 0x52, 0xa8, 0x9c, 0x44, 0x95, 0x23, 0xa1, 0x00, 0x99, 0xbf, 0x05, 0xc5, - 0x8e, 0x47, 0x6c, 0xf9, 0x3f, 0x87, 0xb8, 0xf1, 0xd9, 0xcc, 0x17, 0x49, 0xe0, 0xfa, 0x5c, 0x55, - 0xc7, 0x22, 0x4e, 0x8a, 0xcc, 0x9f, 0x00, 0xfc, 0x94, 0xb9, 0xfe, 0x3e, 0x3b, 0xa6, 0xbe, 0x7c, - 0x12, 0x3e, 0x65, 0xc1, 0xb1, 0x5e, 0xca, 0x22, 0xd6, 0x2d, 0x49, 0x94, 0x89, 0x4f, 0x06, 0x34, - 0x88, 0x5f, 0x46, 0x55, 0x53, 0x1c, 0x2e, 0x79, 0xcc, 0x18, 0xaf, 0x5b, 0xa8, 0x0a, 0x79, 0x9b, - 0xf4, 0xa3, 0x9d, 0x57, 0xde, 0x2a, 0x5e, 0x5e, 0x6c, 0xe4, 0xea, 0xd6, 0x13, 0x3a, 0xc1, 0x39, - 0x9b, 0x3c, 0xa1, 0x13, 0x71, 0xfa, 0xda, 0x44, 0xee, 0x17, 0x69, 0xa6, 0xac, 0x4e, 0xdf, 0xba, - 0x25, 0x36, 0x03, 0xce, 0xdb, 0x44, 0xfc, 0xa2, 0x8f, 0xa1, 0xac, 0x41, 0xfd, 0x23, 0x12, 0x1e, - 0x29, 0xae, 0xba, 0xb5, 0x7a, 0x79, 0xb1, 0x01, 0x0a, 0xf9, 0x98, 0x84, 0x47, 0x18, 0x14, 0x5a, - 0x7c, 0xa3, 0x26, 0x94, 0xbe, 0x62, 0xae, 0xdf, 0xe7, 0x32, 0x08, 0x7d, 0x61, 0x5f, 0xb8, 0x7f, - 0xa6, 0xa1, 0xea, 0xdb, 0x2b, 0x7c, 0x15, 0x4b, 0xcc, 0x7f, 0x4d, 0x41, 0x49, 0xd8, 0x74, 0x0f, - 0x5d, 0x5b, 0x9c, 0x96, 0xdf, 0xbd, 0xd2, 0xdf, 0x86, 0x8c, 0x1d, 0x06, 0x3a, 0x36, 0x59, 0xea, - 0xea, 0x5d, 0x8c, 0x85, 0x0c, 0x7d, 0x01, 0x79, 0xc5, 0xf8, 0x75, 0x91, 0x37, 0xbf, 0xfd, 0x5c, - 0xd7, 0x2e, 0x6a, 0x3d, 0xb9, 0x96, 0x53, 0xef, 0x64, 0x94, 0x65, 0x9c, 0x14, 0xa1, 0x5b, 0x90, - 0xb6, 0x7d, 0x99, 0x14, 0xfa, 0xaf, 0xa2, 0x7a, 0x1b, 0xa7, 0x6d, 0xdf, 0xfc, 0xe7, 0x14, 0xac, - 0x34, 0x7d, 0x3b, 0x98, 0xc8, 0x22, 0x29, 0x16, 0xe2, 0x0e, 0x14, 0xc3, 0xf1, 0x41, 0x38, 0x09, - 0x39, 0x1d, 0x46, 0x2f, 0xd1, 0xb1, 0x00, 0xb5, 0xa0, 0x48, 0xbc, 0x01, 0x0b, 0x5c, 0x7e, 0x34, - 0xd4, 0xdc, 0x78, 0x71, 0x61, 0x4e, 0xda, 0xac, 0x59, 0x91, 0x0a, 0x9e, 0x6a, 0x47, 0xa5, 0x38, - 0x23, 0x9d, 0x95, 0xa5, 0xf8, 0x5d, 0x28, 0x7b, 0x64, 0x28, 0xa8, 0x70, 0x5f, 0xdc, 0x83, 0x64, - 0x1c, 0x59, 0x5c, 0xd2, 0x32, 0x71, 0xb7, 0x33, 0x4d, 0x28, 0xc6, 0xc6, 0xd0, 0x35, 0x28, 0x59, - 0xcd, 0x6e, 0xff, 0x93, 0xcd, 0x07, 0xfd, 0x47, 0xf5, 0x5d, 0x63, 0x49, 0x33, 0x81, 0x7f, 0x4c, - 0xc1, 0xca, 0xae, 0xca, 0x41, 0x4d, 0x9c, 0xee, 0xc2, 0x72, 0x40, 0x0e, 0x79, 0x44, 0xed, 0xb2, - 0x2a, 0xb9, 0x44, 0x11, 0x10, 0xd4, 0x4e, 0x74, 0x2d, 0xa6, 0x76, 0x89, 0xff, 0x41, 0x32, 0x57, - 0xfe, 0x0f, 0x92, 0xfd, 0x8d, 0xfc, 0x0f, 0xf2, 0xc1, 0xaf, 0x32, 0x50, 0x8c, 0x6f, 0xa2, 0x22, - 0x65, 0x04, 0xd3, 0x5a, 0x52, 0x2f, 0x3b, 0xb1, 0xbc, 0x2d, 0x39, 0x56, 0xd1, 0xda, 0xd9, 0xd9, - 0xab, 0x5b, 0xe2, 0xb2, 0xfe, 0x85, 0xa2, 0x62, 0x31, 0xc0, 0xf2, 0x3c, 0x26, 0x16, 0xdd, 0x41, - 0xe6, 0x94, 0x8a, 0xbd, 0xd0, 0xef, 0x47, 0x31, 0x2a, 0xe2, 0x61, 0xef, 0x41, 0xc1, 0xea, 0x76, - 0x5b, 0x8f, 0xda, 0xcd, 0x86, 0xf1, 0x32, 0x55, 0xf9, 0xde, 0xd9, 0x79, 0xf5, 0xfa, 0xd4, 0x54, - 0x18, 0xba, 0x03, 0x9f, 0x3a, 0x12, 0x55, 0xaf, 0x37, 0x3b, 0x62, 0xbc, 0x17, 0xe9, 0x79, 0x94, - 0x24, 0x20, 0xf2, 0x2d, 0xb8, 0xd8, 0xc1, 0xcd, 0x8e, 0x85, 0xc5, 0x88, 0x2f, 0xd3, 0x73, 0x7e, - 0x75, 0x02, 0x3a, 0x22, 0x81, 0x18, 0x73, 0x3d, 0xfa, 0x4f, 0xe4, 0x45, 0x46, 0xbd, 0x17, 0x4e, - 0xaf, 0xdf, 0x94, 0x38, 0x13, 0x31, 0x5a, 0x77, 0xdf, 0xc2, 0xf2, 0x95, 0xe2, 0x65, 0x66, 0x6e, - 0xb4, 0x2e, 0x27, 0x01, 0x17, 0x56, 0x4c, 0x58, 0xc6, 0xbd, 0x76, 0x5b, 0x46, 0x97, 0x9d, 0x8b, - 0x0e, 0x8f, 0x7d, 0x5f, 0x60, 0xee, 0x41, 0x21, 0x7a, 0xd5, 0x30, 0x5e, 0x66, 0xe7, 0x1c, 0xaa, - 0x47, 0xcf, 0x29, 0x72, 0xc0, 0xc7, 0xbd, 0x7d, 0xf9, 0x97, 0xcd, 0x8b, 0xdc, 0xfc, 0x80, 0x47, - 0x63, 0xee, 0x08, 0xf2, 0x5b, 0x8d, 0xd9, 0xe8, 0xcb, 0x9c, 0x22, 0x01, 0x31, 0x46, 0x51, 0x51, - 0x61, 0x07, 0x37, 0x7f, 0xaa, 0xfe, 0xdd, 0x79, 0x91, 0x9f, 0xb3, 0x83, 0xe9, 0x57, 0xd4, 0xe6, - 0xd4, 0x99, 0x3e, 0x87, 0xc6, 0x5d, 0x1f, 0xfc, 0x01, 0x14, 0xa2, 0x82, 0x81, 0xd6, 0x21, 0xff, - 0x6c, 0x0f, 0x3f, 0x69, 0x62, 0x63, 0x49, 0xcd, 0x4e, 0xd4, 0xf3, 0x4c, 0x55, 0xdc, 0x2a, 0x2c, - 0xef, 0x5a, 0x6d, 0xeb, 0x51, 0x13, 0x47, 0xcf, 0xb1, 0x11, 0x40, 0x67, 0x7d, 0xc5, 0xd0, 0x03, - 0xc4, 0x36, 0xb7, 0xee, 0x7c, 0xfd, 0xcd, 0xfa, 0xd2, 0x2f, 0xbe, 0x59, 0x5f, 0xfa, 0xe5, 0x37, - 0xeb, 0xa9, 0x17, 0x97, 0xeb, 0xa9, 0xaf, 0x2f, 0xd7, 0x53, 0x3f, 0xbf, 0x5c, 0x4f, 0xfd, 0xc7, - 0xe5, 0x7a, 0xea, 0x20, 0x2f, 0x19, 0xd9, 0xa7, 0xff, 0x17, 0x00, 0x00, 0xff, 0xff, 0x84, 0x8b, - 0x50, 0xe8, 0x9f, 0x20, 0x00, 0x00, + // 3493 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, 0x25, 0xf5, 0xd4, 0xcc, 0x8e, 0x35, 0xf4, 0x58, 0xa2, 0x7b, + 0x3c, 0xeb, 0x59, 0xaf, 0x43, 0xdb, 0xf2, 0x26, 0x98, 0xf5, 0x6c, 0xd6, 0x6e, 0x35, 0x5b, 0x33, + 0xf4, 0x48, 0x24, 0x51, 0x24, 0x35, 0x30, 0x02, 0x84, 0x28, 0x75, 0x97, 0xa8, 0xb6, 0x9a, 0xdd, + 0x4c, 0x77, 0x53, 0x1a, 0x26, 0x08, 0x30, 0xc9, 0x25, 0x81, 0x4e, 0x39, 0xe5, 0x12, 0x08, 0x8b, + 0x20, 0x41, 0x6e, 0x39, 0xe4, 0x14, 0x20, 0xa7, 0x39, 0xfa, 0xb8, 0x41, 0x80, 0x60, 0x91, 0x00, + 0x42, 0xac, 0x1c, 0x73, 0x59, 0x20, 0x87, 0x3d, 0x24, 0x87, 0xa0, 0x7e, 0xba, 0xf9, 0x33, 0x94, + 0x3c, 0x93, 0xdd, 0x13, 0xbb, 0x5e, 0x7d, 0xef, 0xd5, 0xab, 0xaa, 0x57, 0xaf, 0xbe, 0x7a, 0x84, + 0x62, 0x34, 0x1e, 0xd2, 0xb0, 0x3a, 0x0c, 0xfc, 0xc8, 0x47, 0xc8, 0xf6, 0xad, 0x63, 0x1a, 0x54, + 0xc3, 0x53, 0x12, 0x0c, 0x8e, 0x9d, 0xa8, 0x7a, 0xf2, 0x49, 0xf9, 0x4e, 0xe4, 0x0c, 0x68, 0x18, + 0x91, 0xc1, 0xf0, 0xa3, 0xe4, 0x4b, 0xc0, 0xcb, 0x6f, 0xd9, 0xa3, 0x80, 0x44, 0x8e, 0xef, 0x7d, + 0x14, 0x7f, 0xc8, 0x8e, 0x5b, 0x7d, 0xbf, 0xef, 0xf3, 0xcf, 0x8f, 0xd8, 0x97, 0x90, 0x6a, 0x9b, + 0xb0, 0xbc, 0x4f, 0x83, 0xd0, 0xf1, 0x3d, 0x74, 0x0b, 0xb2, 0x8e, 0x67, 0xd3, 0xe7, 0xeb, 0x4a, + 0x45, 0x79, 0x90, 0xc1, 0xa2, 0xa1, 0xfd, 0xb5, 0x02, 0x45, 0xdd, 0xf3, 0xfc, 0x88, 0xdb, 0x0a, + 0x11, 0x82, 0x8c, 0x47, 0x06, 0x94, 0x83, 0x0a, 0x98, 0x7f, 0x23, 0x03, 0x72, 0x2e, 0x39, 0xa0, + 0x6e, 0xb8, 0x9e, 0xaa, 0xa4, 0x1f, 0x14, 0xb7, 0x7e, 0x58, 0x7d, 0xd5, 0xe7, 0xea, 0x94, 0x91, + 0xea, 0x2e, 0x47, 0x9b, 0x5e, 0x14, 0x8c, 0xb1, 0x54, 0x2d, 0xff, 0x18, 0x8a, 0x53, 0x62, 0xa4, + 0x42, 0xfa, 0x98, 0x8e, 0xe5, 0x30, 0xec, 0x93, 0xf9, 0x77, 0x42, 0xdc, 0x11, 0x5d, 0x4f, 0x71, + 0x99, 0x68, 0x7c, 0x96, 0x7a, 0xa8, 0x68, 0x5f, 0x41, 0x01, 0xd3, 0xd0, 0x1f, 0x05, 0x16, 0x0d, + 0xd1, 0x0f, 0xa0, 0xe0, 0x11, 0xcf, 0xef, 0x59, 0xc3, 0x51, 0xc8, 0xd5, 0xd3, 0xdb, 0xa5, 0xcb, + 0x8b, 0xcd, 0x7c, 0x83, 0x78, 0xbe, 0xd1, 0xea, 0x86, 0x38, 0xcf, 0xba, 0x8d, 0xe1, 0x28, 0x44, + 0xef, 0x42, 0x69, 0x40, 0x07, 0x7e, 0x30, 0xee, 0x1d, 0x8c, 0x23, 0x1a, 0x72, 0xc3, 0x69, 0x5c, + 0x14, 0xb2, 0x6d, 0x26, 0xd2, 0xfe, 0x42, 0x81, 0x5b, 0xb1, 0x6d, 0x4c, 0xff, 0x60, 0xe4, 0x04, + 0x74, 0x40, 0xbd, 0x28, 0x44, 0xbf, 0x0d, 0x39, 0xd7, 0x19, 0x38, 0x91, 0x18, 0xa3, 0xb8, 0xf5, + 0xce, 0xa2, 0x39, 0x27, 0x5e, 0x61, 0x09, 0x46, 0x3a, 0x94, 0x02, 0x1a, 0xd2, 0xe0, 0x44, 0xac, + 0x04, 0x1f, 0xf2, 0x3b, 0x95, 0x67, 0x54, 0xb4, 0x1d, 0xc8, 0xb7, 0x5c, 0x12, 0x1d, 0xfa, 0xc1, + 0x00, 0x69, 0x50, 0x22, 0x81, 0x75, 0xe4, 0x44, 0xd4, 0x8a, 0x46, 0x41, 0xbc, 0x2b, 0x33, 0x32, + 0x74, 0x1b, 0x52, 0xbe, 0x18, 0xa8, 0xb0, 0x9d, 0xbb, 0xbc, 0xd8, 0x4c, 0x35, 0xdb, 0x38, 0xe5, + 0x87, 0xda, 0x23, 0xb8, 0xd1, 0x72, 0x47, 0x7d, 0xc7, 0xab, 0xd1, 0xd0, 0x0a, 0x9c, 0x21, 0xb3, + 0xce, 0xb6, 0x97, 0x05, 0x5f, 0xbc, 0xbd, 0xec, 0x3b, 0xd9, 0xf2, 0xd4, 0x64, 0xcb, 0xb5, 0x3f, + 0x4b, 0xc1, 0x0d, 0xd3, 0xeb, 0x3b, 0x1e, 0x9d, 0xd6, 0xbe, 0x0f, 0xab, 0x94, 0x0b, 0x7b, 0x27, + 0x22, 0xa8, 0xa4, 0x9d, 0x15, 0x21, 0x8d, 0x23, 0xad, 0x3e, 0x17, 0x2f, 0x9f, 0x2c, 0x9a, 0xfe, + 0x2b, 0xd6, 0x17, 0x45, 0x0d, 0x32, 0x61, 0x79, 0xc8, 0x27, 0x11, 0xae, 0xa7, 0xb9, 0xad, 0xfb, + 0x8b, 0x6c, 0xbd, 0x32, 0xcf, 0xed, 0xcc, 0x37, 0x17, 0x9b, 0x4b, 0x38, 0xd6, 0xfd, 0x75, 0x82, + 0xef, 0x3f, 0x15, 0x58, 0x6b, 0xf8, 0xf6, 0xcc, 0x3a, 0x94, 0x21, 0x7f, 0xe4, 0x87, 0xd1, 0xd4, + 0x41, 0x49, 0xda, 0xe8, 0x21, 0xe4, 0x87, 0x72, 0xfb, 0xe4, 0xee, 0xdf, 0x5d, 0xec, 0xb2, 0xc0, + 0xe0, 0x04, 0x8d, 0x1e, 0x41, 0x21, 0x88, 0x63, 0x62, 0x3d, 0xfd, 0x3a, 0x81, 0x33, 0xc1, 0xa3, + 0xdf, 0x85, 0x9c, 0xd8, 0x84, 0xf5, 0x0c, 0xd7, 0xbc, 0xff, 0x5a, 0x6b, 0x8e, 0xa5, 0x92, 0xf6, + 0x0b, 0x05, 0x54, 0x4c, 0x0e, 0xa3, 0x3d, 0x3a, 0x38, 0xa0, 0x41, 0x3b, 0x22, 0xd1, 0x28, 0x44, + 0xb7, 0x21, 0xe7, 0x52, 0x62, 0xd3, 0x80, 0x4f, 0x32, 0x8f, 0x65, 0x0b, 0x75, 0x59, 0x90, 0x13, + 0xeb, 0x88, 0x1c, 0x38, 0xae, 0x13, 0x8d, 0xf9, 0x34, 0x57, 0x17, 0xef, 0xf2, 0xbc, 0xcd, 0x2a, + 0x9e, 0x52, 0xc4, 0x33, 0x66, 0xd0, 0x3a, 0x2c, 0x0f, 0x68, 0x18, 0x92, 0x3e, 0xe5, 0xb3, 0x2f, + 0xe0, 0xb8, 0xa9, 0x3d, 0x82, 0xd2, 0xb4, 0x1e, 0x2a, 0xc2, 0x72, 0xb7, 0xf1, 0xb4, 0xd1, 0x7c, + 0xd6, 0x50, 0x97, 0xd0, 0x1a, 0x14, 0xbb, 0x0d, 0x6c, 0xea, 0xc6, 0x13, 0x7d, 0x7b, 0xd7, 0x54, + 0x15, 0xb4, 0x02, 0x85, 0x49, 0x33, 0xa5, 0xfd, 0x4c, 0x01, 0x60, 0x1b, 0x28, 0x27, 0xf5, 0x19, + 0x64, 0xc3, 0x88, 0x44, 0x62, 0xe3, 0x56, 0xb7, 0xde, 0x5b, 0xe4, 0xf5, 0x04, 0x5e, 0x65, 0x3f, + 0x14, 0x0b, 0x95, 0x69, 0x0f, 0x53, 0xf3, 0x1e, 0x66, 0x39, 0x72, 0xd6, 0xb5, 0x3c, 0x64, 0x6a, + 0xec, 0x4b, 0x41, 0x05, 0xc8, 0x62, 0x53, 0xaf, 0x7d, 0xa5, 0xa6, 0x90, 0x0a, 0xa5, 0x5a, 0xbd, + 0x6d, 0x34, 0x1b, 0x0d, 0xd3, 0xe8, 0x98, 0x35, 0x35, 0xad, 0xdd, 0x87, 0x6c, 0x7d, 0x40, 0xfa, + 0x14, 0xdd, 0x65, 0x11, 0x70, 0x48, 0x03, 0xea, 0x59, 0x71, 0x60, 0x4d, 0x04, 0xda, 0xcf, 0x0b, + 0x90, 0xdd, 0xf3, 0x47, 0x5e, 0x84, 0xb6, 0xa6, 0x4e, 0xf1, 0xea, 0xd6, 0xc6, 0xa2, 0x29, 0x70, + 0x60, 0xb5, 0x33, 0x1e, 0x52, 0x79, 0xca, 0x6f, 0x43, 0x4e, 0xc4, 0x8a, 0x74, 0x5d, 0xb6, 0x98, + 0x3c, 0x22, 0x41, 0x9f, 0x46, 0x72, 0xd1, 0x65, 0x0b, 0x3d, 0x80, 0x7c, 0x40, 0x89, 0xed, 0x7b, + 0xee, 0x98, 0x87, 0x54, 0x5e, 0xa4, 0x59, 0x4c, 0x89, 0xdd, 0xf4, 0xdc, 0x31, 0x4e, 0x7a, 0xd1, + 0x13, 0x28, 0x1d, 0x38, 0x9e, 0xdd, 0xf3, 0x87, 0x22, 0xe7, 0x65, 0xaf, 0x0e, 0x40, 0xe1, 0xd5, + 0xb6, 0xe3, 0xd9, 0x4d, 0x01, 0xc6, 0xc5, 0x83, 0x49, 0x03, 0x35, 0x60, 0xf5, 0xc4, 0x77, 0x47, + 0x03, 0x9a, 0xd8, 0xca, 0x71, 0x5b, 0xef, 0x5f, 0x6d, 0x6b, 0x9f, 0xe3, 0x63, 0x6b, 0x2b, 0x27, + 0xd3, 0x4d, 0xf4, 0x14, 0x56, 0xa2, 0xc1, 0xf0, 0x30, 0x4c, 0xcc, 0x2d, 0x73, 0x73, 0xdf, 0xbf, + 0x66, 0xc1, 0x18, 0x3c, 0xb6, 0x56, 0x8a, 0xa6, 0x5a, 0xe5, 0x3f, 0x4d, 0x43, 0x71, 0xca, 0x73, + 0xd4, 0x86, 0xe2, 0x30, 0xf0, 0x87, 0xa4, 0xcf, 0xf3, 0xb6, 0xdc, 0x8b, 0x4f, 0x5e, 0x6b, 0xd6, + 0xd5, 0xd6, 0x44, 0x11, 0x4f, 0x5b, 0xd1, 0xce, 0x53, 0x50, 0x9c, 0xea, 0x44, 0x1f, 0x40, 0x1e, + 0xb7, 0x70, 0x7d, 0x5f, 0xef, 0x98, 0xea, 0x52, 0xf9, 0xee, 0xd9, 0x79, 0x65, 0x9d, 0x5b, 0x9b, + 0x36, 0xd0, 0x0a, 0x9c, 0x13, 0x16, 0x7a, 0x0f, 0x60, 0x39, 0x86, 0x2a, 0xe5, 0xb7, 0xcf, 0xce, + 0x2b, 0x6f, 0xcd, 0x43, 0xa7, 0x90, 0xb8, 0xfd, 0x44, 0xc7, 0x66, 0x4d, 0x4d, 0x2d, 0x46, 0xe2, + 0xf6, 0x11, 0x09, 0xa8, 0x8d, 0xbe, 0x0f, 0x39, 0x09, 0x4c, 0x97, 0xcb, 0x67, 0xe7, 0x95, 0xdb, + 0xf3, 0xc0, 0x09, 0x0e, 0xb7, 0x77, 0xf5, 0x7d, 0x53, 0xcd, 0x2c, 0xc6, 0xe1, 0xb6, 0x4b, 0x4e, + 0x28, 0x7a, 0x0f, 0xb2, 0x02, 0x96, 0x2d, 0xdf, 0x39, 0x3b, 0xaf, 0x7c, 0xef, 0x15, 0x73, 0x0c, + 0x55, 0x5e, 0xff, 0xf3, 0xbf, 0xd9, 0x58, 0xfa, 0xa7, 0xbf, 0xdd, 0x50, 0xe7, 0xbb, 0xcb, 0xff, + 0xab, 0xc0, 0xca, 0xcc, 0x96, 0x23, 0x0d, 0x72, 0x9e, 0x6f, 0xf9, 0x43, 0x91, 0xce, 0xf3, 0xdb, + 0x70, 0x79, 0xb1, 0x99, 0x6b, 0xf8, 0x86, 0x3f, 0x1c, 0x63, 0xd9, 0x83, 0x9e, 0xce, 0x5d, 0x48, + 0x9f, 0xbe, 0x66, 0x3c, 0x2d, 0xbc, 0x92, 0x3e, 0x87, 0x15, 0x3b, 0x70, 0x4e, 0x68, 0xd0, 0xb3, + 0x7c, 0xef, 0xd0, 0xe9, 0xcb, 0x54, 0x5d, 0x5e, 0x64, 0xb3, 0xc6, 0x81, 0xb8, 0x24, 0x14, 0x0c, + 0x8e, 0xff, 0x35, 0x2e, 0xa3, 0xf2, 0x3e, 0x94, 0xa6, 0x23, 0x14, 0xbd, 0x03, 0x10, 0x3a, 0x7f, + 0x48, 0x25, 0xbf, 0xe1, 0x6c, 0x08, 0x17, 0x98, 0x84, 0xb3, 0x1b, 0xf4, 0x3e, 0x64, 0x06, 0xbe, + 0x2d, 0xec, 0x64, 0xb7, 0x6f, 0xb2, 0x3b, 0xf1, 0xdf, 0x2e, 0x36, 0x8b, 0x7e, 0x58, 0xdd, 0x71, + 0x5c, 0xba, 0xe7, 0xdb, 0x14, 0x73, 0x80, 0x76, 0x02, 0x19, 0x96, 0x2a, 0xd0, 0xdb, 0x90, 0xd9, + 0xae, 0x37, 0x6a, 0xea, 0x52, 0xf9, 0xc6, 0xd9, 0x79, 0x65, 0x85, 0x2f, 0x09, 0xeb, 0x60, 0xb1, + 0x8b, 0x36, 0x21, 0xb7, 0xdf, 0xdc, 0xed, 0xee, 0xb1, 0xf0, 0xba, 0x79, 0x76, 0x5e, 0x59, 0x4b, + 0xba, 0xc5, 0xa2, 0xa1, 0x77, 0x20, 0xdb, 0xd9, 0x6b, 0xed, 0xb4, 0xd5, 0x54, 0x19, 0x9d, 0x9d, + 0x57, 0x56, 0x93, 0x7e, 0xee, 0x73, 0xf9, 0x86, 0xdc, 0xd5, 0x42, 0x22, 0xd7, 0xfe, 0x27, 0x05, + 0x2b, 0x98, 0xf1, 0xdb, 0x20, 0x6a, 0xf9, 0xae, 0x63, 0x8d, 0x51, 0x0b, 0x0a, 0x96, 0xef, 0xd9, + 0xce, 0xd4, 0x99, 0xda, 0xba, 0xe2, 0x12, 0x9c, 0x68, 0xc5, 0x2d, 0x23, 0xd6, 0xc4, 0x13, 0x23, + 0x68, 0x0b, 0xb2, 0x36, 0x75, 0xc9, 0xf8, 0xba, 0xdb, 0xb8, 0x26, 0xb9, 0x34, 0x16, 0x50, 0xce, + 0x1c, 0xc9, 0xf3, 0x1e, 0x89, 0x22, 0x3a, 0x18, 0x46, 0xe2, 0x36, 0xce, 0xe0, 0xe2, 0x80, 0x3c, + 0xd7, 0xa5, 0x08, 0xfd, 0x08, 0x72, 0xa7, 0x8e, 0x67, 0xfb, 0xa7, 0xf2, 0xc2, 0xbd, 0xde, 0xae, + 0xc4, 0x6a, 0x67, 0xec, 0x9e, 0x9d, 0x73, 0x96, 0xad, 0x7a, 0xa3, 0xd9, 0x30, 0xe3, 0x55, 0x97, + 0xfd, 0x4d, 0xaf, 0xe1, 0x7b, 0xec, 0xc4, 0x40, 0xb3, 0xd1, 0xdb, 0xd1, 0xeb, 0xbb, 0x5d, 0xcc, + 0x56, 0xfe, 0xd6, 0xd9, 0x79, 0x45, 0x4d, 0x20, 0x3b, 0xc4, 0x71, 0x19, 0x09, 0xbc, 0x03, 0x69, + 0xbd, 0xf1, 0x95, 0x9a, 0x2a, 0xab, 0x67, 0xe7, 0x95, 0x52, 0xd2, 0xad, 0x7b, 0xe3, 0xc9, 0x61, + 0x9a, 0x1f, 0x57, 0xfb, 0x2f, 0x05, 0x4a, 0xdd, 0xa1, 0x4d, 0x22, 0x2a, 0x22, 0x13, 0x55, 0xa0, + 0x38, 0x24, 0x01, 0x71, 0x5d, 0xea, 0x3a, 0xe1, 0x40, 0x3e, 0x14, 0xa6, 0x45, 0xe8, 0xe1, 0x1b, + 0x2c, 0xa6, 0x24, 0x61, 0x72, 0x49, 0xbb, 0xb0, 0x7a, 0x28, 0x9c, 0xed, 0x11, 0x8b, 0xef, 0x6e, + 0x9a, 0xef, 0x6e, 0x75, 0x91, 0x89, 0x69, 0xaf, 0xaa, 0x72, 0x8e, 0x3a, 0xd7, 0xc2, 0x2b, 0x87, + 0xd3, 0x4d, 0xed, 0x01, 0xac, 0xcc, 0xf4, 0xb3, 0x9b, 0xb6, 0xa5, 0x77, 0xdb, 0xa6, 0xba, 0x84, + 0x4a, 0x90, 0x37, 0x9a, 0x8d, 0x4e, 0xbd, 0xd1, 0x35, 0x55, 0x45, 0xfb, 0x87, 0x54, 0x3c, 0x5b, + 0xc9, 0x04, 0xb6, 0x67, 0x99, 0xc0, 0x87, 0x57, 0x3b, 0x22, 0xb9, 0xc0, 0xa4, 0x91, 0x30, 0x82, + 0x9f, 0x00, 0xf0, 0x45, 0xa5, 0x76, 0x8f, 0x44, 0xd7, 0xb1, 0xfd, 0x4e, 0xfc, 0x8e, 0xc3, 0x05, + 0xa9, 0xa0, 0x47, 0xe8, 0x0b, 0x28, 0x59, 0xfe, 0x60, 0xe8, 0x52, 0xa9, 0x9f, 0x7e, 0x1d, 0xfd, + 0x62, 0xa2, 0xa2, 0x47, 0xd3, 0x8c, 0x24, 0x33, 0xcb, 0x48, 0x0c, 0x28, 0x4e, 0xf9, 0x3b, 0xcb, + 0x4b, 0x4a, 0x90, 0xef, 0xb6, 0x6a, 0x7a, 0xa7, 0xde, 0x78, 0xac, 0x2a, 0x08, 0x20, 0xc7, 0x57, + 0xac, 0xa6, 0xa6, 0x18, 0x77, 0x32, 0x9a, 0x7b, 0xad, 0x5d, 0x53, 0x30, 0x93, 0x3f, 0x86, 0x35, + 0xc3, 0xf7, 0x22, 0xe2, 0x78, 0x09, 0x29, 0xdc, 0x62, 0x3e, 0x4b, 0x51, 0xcf, 0xb1, 0x45, 0xde, + 0xda, 0x5e, 0xbb, 0xbc, 0xd8, 0x2c, 0x26, 0xd0, 0x7a, 0x8d, 0x79, 0x19, 0x37, 0x6c, 0x16, 0x9d, + 0x43, 0xc7, 0x96, 0x69, 0x68, 0xf9, 0xf2, 0x62, 0x33, 0xdd, 0xaa, 0xd7, 0x30, 0x93, 0xa1, 0xb7, + 0xa1, 0x40, 0x9f, 0x3b, 0x51, 0xcf, 0x62, 0x79, 0x8a, 0xcd, 0x3f, 0x8b, 0xf3, 0x4c, 0x60, 0xb0, + 0xb4, 0xf4, 0x27, 0x29, 0x80, 0x0e, 0x09, 0x8f, 0xe5, 0xd0, 0x8f, 0xa0, 0x90, 0x3c, 0x87, 0xaf, + 0x7b, 0x96, 0x4d, 0xad, 0x75, 0x82, 0x47, 0x9f, 0xc6, 0xbb, 0x2d, 0xd8, 0xea, 0x62, 0x45, 0x39, + 0xd6, 0x22, 0xc2, 0x37, 0x4b, 0x49, 0x59, 0xd6, 0xa6, 0x41, 0x20, 0x17, 0x9d, 0x7d, 0x22, 0x83, + 0x67, 0x2e, 0x31, 0x67, 0xc9, 0x81, 0xee, 0x2d, 0x1a, 0x64, 0x6e, 0x41, 0x9f, 0x2c, 0xe1, 0x89, + 0xde, 0xb6, 0x0a, 0xab, 0xc1, 0xc8, 0x63, 0x5e, 0xf7, 0x42, 0xde, 0xad, 0xfd, 0x4b, 0x0a, 0xa0, + 0xde, 0xd2, 0xf7, 0xe4, 0x11, 0xad, 0x41, 0xee, 0x90, 0x0c, 0x1c, 0x77, 0x7c, 0x5d, 0xd4, 0x4e, + 0xf0, 0x55, 0xdd, 0xb6, 0x03, 0x1a, 0x86, 0x3b, 0x5c, 0x07, 0x4b, 0x5d, 0x4e, 0x06, 0x47, 0x07, + 0x1e, 0x8d, 0x12, 0x32, 0xc8, 0x5b, 0xec, 0xe6, 0x09, 0x88, 0x97, 0xcc, 0x56, 0x34, 0xd8, 0x2a, + 0xf4, 0x49, 0x44, 0x4f, 0xc9, 0x38, 0x0e, 0x32, 0xd9, 0x44, 0x4f, 0x18, 0x49, 0x64, 0x6f, 0x57, + 0x6a, 0xaf, 0x67, 0xf9, 0xd5, 0xfa, 0x5d, 0xfe, 0x60, 0x09, 0x17, 0x77, 0x6a, 0xa2, 0x5d, 0x7e, + 0xc4, 0x2f, 0x82, 0x49, 0xd7, 0x1b, 0xbd, 0xd1, 0x3e, 0x86, 0x95, 0x99, 0x79, 0xbe, 0xc2, 0xc2, + 0xeb, 0xad, 0xfd, 0x1f, 0xa9, 0x19, 0xf9, 0xf5, 0x3b, 0x6a, 0x4e, 0xfb, 0x6f, 0x05, 0xa0, 0xe5, + 0xf3, 0x64, 0xc8, 0x56, 0x75, 0x71, 0xd5, 0x23, 0xcf, 0x6b, 0x28, 0x96, 0xef, 0xca, 0x98, 0x59, + 0x48, 0x43, 0x27, 0x56, 0x18, 0xab, 0xe3, 0x70, 0x9c, 0x28, 0xa2, 0x4d, 0x28, 0x0a, 0x3e, 0xdd, + 0x1b, 0xfa, 0x81, 0x38, 0xe0, 0x2b, 0x18, 0x84, 0x88, 0x69, 0xb2, 0x27, 0xf5, 0x70, 0x74, 0xe0, + 0x3a, 0xe1, 0x11, 0xb5, 0x05, 0x26, 0xc3, 0x31, 0x2b, 0x89, 0x94, 0xc1, 0xb4, 0x1a, 0xe4, 0x63, + 0xeb, 0x68, 0x1d, 0xd2, 0x1d, 0xa3, 0xa5, 0x2e, 0x95, 0xd7, 0xce, 0xce, 0x2b, 0xc5, 0x58, 0xdc, + 0x31, 0x5a, 0xac, 0xa7, 0x5b, 0x6b, 0xa9, 0xca, 0x6c, 0x4f, 0xb7, 0xd6, 0x2a, 0x67, 0xd8, 0x25, + 0xa0, 0xfd, 0x95, 0x02, 0x39, 0x41, 0x49, 0x16, 0xce, 0x58, 0x87, 0xe5, 0x98, 0x28, 0x0b, 0x9e, + 0xf4, 0xfe, 0xd5, 0x9c, 0xa6, 0x2a, 0x29, 0x88, 0xd8, 0xc7, 0x58, 0xaf, 0xfc, 0x19, 0x94, 0xa6, + 0x3b, 0xde, 0x68, 0x17, 0xff, 0x08, 0x8a, 0x2c, 0x50, 0x62, 0x6e, 0xb3, 0x05, 0x39, 0x41, 0x9b, + 0xe4, 0x51, 0xbf, 0x8e, 0x60, 0x49, 0x24, 0x7a, 0x08, 0xcb, 0x82, 0x94, 0xc5, 0xe5, 0x82, 0x8d, + 0xeb, 0xc3, 0x11, 0xc7, 0x70, 0xed, 0x73, 0xc8, 0xb4, 0x28, 0x0d, 0xd0, 0x3d, 0x58, 0xf6, 0x7c, + 0x9b, 0x4e, 0x32, 0x9b, 0xe4, 0x93, 0x36, 0xad, 0xd7, 0x18, 0x9f, 0xb4, 0x69, 0xdd, 0x66, 0x8b, + 0x47, 0x6c, 0x3b, 0x88, 0x2b, 0x26, 0xec, 0x5b, 0xeb, 0x40, 0xe9, 0x19, 0x75, 0xfa, 0x47, 0x11, + 0xb5, 0xb9, 0xa1, 0x0f, 0x21, 0x33, 0xa4, 0x89, 0xf3, 0xeb, 0x0b, 0x43, 0x87, 0xd2, 0x00, 0x73, + 0x14, 0x3b, 0x90, 0xa7, 0x5c, 0x5b, 0x16, 0xa9, 0x64, 0x4b, 0xfb, 0xfb, 0x14, 0xac, 0xd6, 0xc3, + 0x70, 0x44, 0x3c, 0x2b, 0xbe, 0xb6, 0x7e, 0x3a, 0x7b, 0x6d, 0x3d, 0x58, 0x38, 0xc3, 0x19, 0x95, + 0xd9, 0x47, 0xac, 0xcc, 0x5c, 0xa9, 0x24, 0x73, 0x69, 0xdf, 0x28, 0xf1, 0xeb, 0xf5, 0xfe, 0xd4, + 0xb9, 0x29, 0xaf, 0x9f, 0x9d, 0x57, 0x6e, 0x4d, 0x5b, 0xa2, 0x5d, 0xef, 0xd8, 0xf3, 0x4f, 0x3d, + 0xf4, 0x2e, 0x7b, 0xcd, 0x36, 0xcc, 0x67, 0xaa, 0x52, 0xbe, 0x7d, 0x76, 0x5e, 0x41, 0x33, 0x20, + 0x4c, 0x3d, 0x7a, 0xca, 0x2c, 0xb5, 0xcc, 0x46, 0x8d, 0xdd, 0x30, 0xa9, 0x05, 0x96, 0x5a, 0xd4, + 0xb3, 0x1d, 0xaf, 0x8f, 0xee, 0x41, 0xae, 0xde, 0x6e, 0x77, 0xf9, 0xfb, 0xe2, 0xad, 0xb3, 0xf3, + 0xca, 0xcd, 0x19, 0x14, 0x6b, 0x50, 0x9b, 0x81, 0x18, 0xff, 0x31, 0x6b, 0x6a, 0x66, 0x01, 0x88, + 0x5d, 0xff, 0xd4, 0x96, 0x11, 0xfe, 0xef, 0x29, 0x50, 0x75, 0xcb, 0xa2, 0xc3, 0x88, 0xf5, 0x4b, + 0x4e, 0xd9, 0x81, 0xfc, 0x90, 0x7d, 0x39, 0x9c, 0x23, 0xb3, 0xb0, 0x78, 0xb8, 0xb0, 0x82, 0x39, + 0xa7, 0x57, 0xc5, 0xbe, 0x4b, 0x75, 0x7b, 0xe0, 0x84, 0x21, 0x7b, 0x3b, 0x71, 0x19, 0x4e, 0x2c, + 0x95, 0x7f, 0xa9, 0xc0, 0xcd, 0x05, 0x08, 0xf4, 0x31, 0x64, 0x02, 0xdf, 0x8d, 0xb7, 0xe7, 0xee, + 0x55, 0xf5, 0x05, 0xa6, 0x8a, 0x39, 0x12, 0x6d, 0x00, 0x90, 0x51, 0xe4, 0x13, 0x3e, 0x3e, 0xdf, + 0x98, 0x3c, 0x9e, 0x92, 0xa0, 0x67, 0x90, 0x0b, 0xa9, 0x15, 0xd0, 0x98, 0x20, 0x7c, 0xfe, 0xff, + 0xf5, 0xbe, 0xda, 0xe6, 0x66, 0xb0, 0x34, 0x57, 0xae, 0x42, 0x4e, 0x48, 0x58, 0x44, 0xdb, 0x24, + 0x22, 0xdc, 0xe9, 0x12, 0xe6, 0xdf, 0x2c, 0x50, 0x88, 0xdb, 0x8f, 0x03, 0x85, 0xb8, 0x7d, 0xed, + 0x67, 0x29, 0x00, 0xf3, 0x79, 0x44, 0x03, 0x8f, 0xb8, 0x86, 0x8e, 0xcc, 0xa9, 0x0c, 0x29, 0x66, + 0xfb, 0x83, 0x85, 0x55, 0xa7, 0x44, 0xa3, 0x6a, 0xe8, 0x0b, 0x72, 0xe4, 0x1d, 0x48, 0x8f, 0x02, + 0x57, 0x56, 0x30, 0x39, 0x3b, 0xe8, 0xe2, 0x5d, 0xcc, 0x64, 0xc8, 0x9c, 0x64, 0xa4, 0xf4, 0xd5, + 0xa5, 0xe7, 0xa9, 0x01, 0x7e, 0xf3, 0x59, 0xe9, 0x43, 0x80, 0x89, 0xd7, 0x68, 0x03, 0xb2, 0xc6, + 0x4e, 0xbb, 0xbd, 0xab, 0x2e, 0x89, 0x27, 0xd0, 0xa4, 0x8b, 0x8b, 0xb5, 0xbf, 0x53, 0x20, 0x6f, + 0xe8, 0xf2, 0x56, 0xd9, 0x01, 0x95, 0xe7, 0x12, 0x8b, 0x06, 0x51, 0x8f, 0x3e, 0x1f, 0x3a, 0xc1, + 0x58, 0xa6, 0x83, 0xeb, 0x1f, 0x0b, 0xab, 0x4c, 0xcb, 0xa0, 0x41, 0x64, 0x72, 0x1d, 0x84, 0xa1, + 0x44, 0xe5, 0x14, 0x7b, 0x16, 0x89, 0x93, 0xf3, 0xc6, 0xf5, 0x4b, 0x21, 0x28, 0xd9, 0xa4, 0x1d, + 0xe2, 0x62, 0x6c, 0xc4, 0x20, 0xa1, 0xb6, 0x0f, 0x37, 0x9b, 0x81, 0x75, 0x44, 0xc3, 0x48, 0x0c, + 0x2a, 0x5d, 0xfe, 0x1c, 0xee, 0x46, 0x24, 0x3c, 0xee, 0x1d, 0x39, 0x61, 0xe4, 0x07, 0xe3, 0x5e, + 0x40, 0x23, 0xea, 0xb1, 0xfe, 0x1e, 0x2f, 0x70, 0xcb, 0x27, 0xe6, 0x1d, 0x86, 0x79, 0x22, 0x20, + 0x38, 0x46, 0xec, 0x32, 0x80, 0x56, 0x87, 0x12, 0x63, 0x51, 0x35, 0x7a, 0x48, 0x46, 0x6e, 0x14, + 0xa2, 0x1f, 0x03, 0xb8, 0x7e, 0xbf, 0xf7, 0xda, 0x99, 0xbc, 0xe0, 0xfa, 0x7d, 0xf1, 0xa9, 0xfd, + 0x1e, 0xa8, 0x35, 0x27, 0x1c, 0x92, 0xc8, 0x3a, 0x8a, 0xdf, 0xce, 0xe8, 0x31, 0xa8, 0x47, 0x94, + 0x04, 0xd1, 0x01, 0x25, 0x51, 0x6f, 0x48, 0x03, 0xc7, 0xb7, 0x5f, 0x6b, 0x49, 0xd7, 0x12, 0xad, + 0x16, 0x57, 0xd2, 0x7e, 0xa5, 0x00, 0x60, 0x72, 0x18, 0x13, 0x80, 0x1f, 0xc2, 0x8d, 0xd0, 0x23, + 0xc3, 0xf0, 0xc8, 0x8f, 0x7a, 0x8e, 0x17, 0xd1, 0xe0, 0x84, 0xb8, 0xf2, 0xfd, 0xa3, 0xc6, 0x1d, + 0x75, 0x29, 0x47, 0x1f, 0x02, 0x3a, 0xa6, 0x74, 0xd8, 0xf3, 0x5d, 0xbb, 0x17, 0x77, 0x8a, 0x0a, + 0x7c, 0x06, 0xab, 0xac, 0xa7, 0xe9, 0xda, 0xed, 0x58, 0x8e, 0xb6, 0x61, 0x83, 0xad, 0x00, 0xf5, + 0xa2, 0xc0, 0xa1, 0x61, 0xef, 0xd0, 0x0f, 0x7a, 0xa1, 0xeb, 0x9f, 0xf6, 0x0e, 0x7d, 0xd7, 0xf5, + 0x4f, 0x69, 0x10, 0xbf, 0x2e, 0xcb, 0xae, 0xdf, 0x37, 0x05, 0x68, 0xc7, 0x0f, 0xda, 0xae, 0x7f, + 0xba, 0x13, 0x23, 0x18, 0x4b, 0x98, 0x4c, 0x3b, 0x72, 0xac, 0xe3, 0x98, 0x25, 0x24, 0xd2, 0x8e, + 0x63, 0x1d, 0xa3, 0x7b, 0xb0, 0x42, 0x5d, 0xca, 0xdf, 0x41, 0x02, 0x95, 0xe5, 0xa8, 0x52, 0x2c, + 0x64, 0x20, 0xed, 0xb7, 0xa0, 0xd0, 0x72, 0x89, 0xc5, 0xff, 0xe7, 0x60, 0x2f, 0x3e, 0xcb, 0xf7, + 0x58, 0x10, 0x38, 0x5e, 0x24, 0xb2, 0x63, 0x01, 0x4f, 0x8b, 0xb4, 0x9f, 0x02, 0x7c, 0xe9, 0x3b, + 0x5e, 0xc7, 0x3f, 0xa6, 0x1e, 0x2f, 0x09, 0x9f, 0xfa, 0xc1, 0xb1, 0xdc, 0xca, 0x02, 0x96, 0x2d, + 0x4e, 0x94, 0x89, 0x47, 0xfa, 0x34, 0x48, 0x2a, 0xa3, 0xa2, 0xc9, 0x2e, 0x97, 0x1c, 0xf6, 0xfd, + 0xc8, 0xd0, 0x51, 0x05, 0x72, 0x16, 0xe9, 0xc5, 0x27, 0xaf, 0xb4, 0x5d, 0xb8, 0xbc, 0xd8, 0xcc, + 0x1a, 0xfa, 0x53, 0x3a, 0xc6, 0x59, 0x8b, 0x3c, 0xa5, 0x63, 0x76, 0xfb, 0x5a, 0x84, 0x9f, 0x17, + 0x6e, 0xa6, 0x24, 0x6e, 0x5f, 0x43, 0x67, 0x87, 0x01, 0xe7, 0x2c, 0xc2, 0x7e, 0xd1, 0xc7, 0x50, + 0x92, 0xa0, 0xde, 0x11, 0x09, 0x8f, 0x04, 0x57, 0xdd, 0x5e, 0xbd, 0xbc, 0xd8, 0x04, 0x81, 0x7c, + 0x42, 0xc2, 0x23, 0x0c, 0x02, 0xcd, 0xbe, 0x91, 0x09, 0xc5, 0xaf, 0x7d, 0xc7, 0xeb, 0x45, 0x7c, + 0x12, 0xf2, 0xc1, 0xbe, 0xf0, 0xfc, 0x4c, 0xa6, 0x2a, 0x5f, 0xaf, 0xf0, 0x75, 0x22, 0xd1, 0xfe, + 0x55, 0x81, 0x22, 0xb3, 0xe9, 0x1c, 0x3a, 0x16, 0xbb, 0x2d, 0xdf, 0x3c, 0xd3, 0xdf, 0x81, 0xb4, + 0x15, 0x06, 0x72, 0x6e, 0x3c, 0xd5, 0x19, 0x6d, 0x8c, 0x99, 0x0c, 0x7d, 0x01, 0x39, 0xc1, 0xf8, + 0x65, 0x92, 0xd7, 0xbe, 0xfb, 0x5e, 0x97, 0x2e, 0x4a, 0x3d, 0xbe, 0x97, 0x13, 0xef, 0xf8, 0x2c, + 0x4b, 0x78, 0x5a, 0x84, 0x6e, 0x43, 0xca, 0xf2, 0x78, 0x50, 0xc8, 0xbf, 0x8a, 0x8c, 0x06, 0x4e, + 0x59, 0x9e, 0xf6, 0xcf, 0x0a, 0xac, 0x98, 0x9e, 0x15, 0x8c, 0x79, 0x92, 0x64, 0x1b, 0x71, 0x17, + 0x0a, 0xe1, 0xe8, 0x20, 0x1c, 0x87, 0x11, 0x1d, 0xc4, 0x95, 0xe8, 0x44, 0x80, 0xea, 0x50, 0x20, + 0x6e, 0xdf, 0x0f, 0x9c, 0xe8, 0x68, 0x20, 0xb9, 0xf1, 0xe2, 0xc4, 0x3c, 0x6d, 0xb3, 0xaa, 0xc7, + 0x2a, 0x78, 0xa2, 0x1d, 0xa7, 0xe2, 0x34, 0x77, 0x96, 0xa7, 0xe2, 0x77, 0xa1, 0xe4, 0x92, 0x01, + 0xa3, 0xc2, 0x3d, 0xf6, 0x0e, 0xe2, 0xf3, 0xc8, 0xe0, 0xa2, 0x94, 0xb1, 0xb7, 0x9d, 0xa6, 0x41, + 0x21, 0x31, 0x86, 0xd6, 0xa0, 0xa8, 0x9b, 0xed, 0xde, 0x27, 0x5b, 0x0f, 0x7b, 0x8f, 0x8d, 0x3d, + 0x75, 0x49, 0x32, 0x81, 0x7f, 0x54, 0x60, 0x65, 0x4f, 0xc4, 0xa0, 0x24, 0x4e, 0xf7, 0x60, 0x39, + 0x20, 0x87, 0x51, 0x4c, 0xed, 0x32, 0x22, 0xb8, 0x58, 0x12, 0x60, 0xd4, 0x8e, 0x75, 0x2d, 0xa6, + 0x76, 0x53, 0xff, 0x83, 0xa4, 0xaf, 0xfd, 0x1f, 0x24, 0xf3, 0x1b, 0xf9, 0x1f, 0x44, 0xfb, 0x4b, + 0x05, 0xd6, 0xe4, 0x45, 0x1d, 0xd7, 0xfe, 0x17, 0xd2, 0xf5, 0x9f, 0x24, 0xd5, 0xbd, 0xf4, 0x55, + 0x3c, 0x70, 0xce, 0x4c, 0x75, 0x52, 0xf2, 0xbb, 0xaa, 0xee, 0xaf, 0xdd, 0x81, 0x0c, 0x43, 0xb1, + 0xb7, 0xd2, 0x4e, 0x7d, 0xd7, 0x54, 0x97, 0xd0, 0x32, 0xa4, 0xcd, 0xc6, 0xbe, 0xaa, 0x7c, 0xf0, + 0xab, 0x34, 0x14, 0x92, 0x27, 0x32, 0x8b, 0x65, 0x46, 0x01, 0x97, 0x44, 0xc9, 0x29, 0x91, 0x37, + 0x38, 0xf9, 0x2b, 0xe8, 0xbb, 0xbb, 0x4d, 0x43, 0xef, 0x98, 0x35, 0xf5, 0x0b, 0xc1, 0x11, 0x13, + 0x80, 0xee, 0xba, 0x3e, 0x8b, 0x46, 0x1b, 0x69, 0x13, 0x8e, 0xf8, 0x42, 0x16, 0xb6, 0x12, 0x54, + 0x4c, 0x10, 0xdf, 0x83, 0xbc, 0xde, 0x6e, 0xd7, 0x1f, 0x37, 0xcc, 0x9a, 0xfa, 0x52, 0x29, 0x7f, + 0xef, 0xec, 0xbc, 0x72, 0x63, 0x62, 0x2a, 0x0c, 0x9d, 0xbe, 0x47, 0x6d, 0x8e, 0x32, 0x0c, 0xb3, + 0xc5, 0xc6, 0x7b, 0x91, 0x9a, 0x47, 0x71, 0x66, 0xc4, 0x8b, 0xd4, 0x85, 0x16, 0x36, 0x5b, 0x3a, + 0x66, 0x23, 0xbe, 0x4c, 0xcd, 0xf9, 0xd5, 0x0a, 0xe8, 0x90, 0x04, 0x6c, 0xcc, 0x8d, 0xf8, 0xcf, + 0x9a, 0x17, 0x69, 0x51, 0xc8, 0x9c, 0xd4, 0x05, 0x28, 0xb1, 0xc7, 0x6c, 0xb4, 0x76, 0x47, 0xc7, + 0xbc, 0x7c, 0xf2, 0x32, 0x3d, 0x37, 0x5a, 0x3b, 0x22, 0x41, 0xc4, 0xac, 0x68, 0xb0, 0x8c, 0xbb, + 0x8d, 0x06, 0x9f, 0x5d, 0x66, 0x6e, 0x76, 0x78, 0xe4, 0x79, 0x0c, 0x73, 0x1f, 0xf2, 0x71, 0xb9, + 0x45, 0x7d, 0x99, 0x99, 0x73, 0xc8, 0x88, 0xeb, 0x3c, 0x7c, 0xc0, 0x27, 0xdd, 0x0e, 0xff, 0x2f, + 0xe9, 0x45, 0x76, 0x7e, 0xc0, 0xa3, 0x51, 0x64, 0x33, 0x56, 0x5e, 0x49, 0x68, 0xf2, 0xcb, 0xac, + 0x60, 0x27, 0x09, 0x46, 0x70, 0x64, 0x66, 0x07, 0x9b, 0x5f, 0x8a, 0xbf, 0x9d, 0x5e, 0xe4, 0xe6, + 0xec, 0x60, 0xfa, 0x35, 0xb5, 0x22, 0x6a, 0x4f, 0xea, 0xb4, 0x49, 0xd7, 0x07, 0xbf, 0x0f, 0xf9, + 0x38, 0x93, 0xa1, 0x0d, 0xc8, 0x3d, 0x6b, 0xe2, 0xa7, 0x26, 0x56, 0x97, 0xc4, 0xea, 0xc4, 0x3d, + 0xcf, 0xc4, 0x55, 0x50, 0x81, 0xe5, 0x3d, 0xbd, 0xa1, 0x3f, 0x36, 0x71, 0x5c, 0x27, 0x8e, 0x01, + 0xf2, 0x38, 0x96, 0x55, 0x39, 0x40, 0x62, 0xf3, 0x83, 0x2f, 0x01, 0x44, 0xa8, 0xf2, 0x2a, 0xb4, + 0x06, 0x05, 0xa3, 0xd9, 0xe8, 0xe8, 0xf5, 0x06, 0x1f, 0x44, 0x10, 0xad, 0xa4, 0x6a, 0x22, 0x08, + 0xeb, 0x3a, 0x64, 0x1a, 0xcd, 0x9a, 0xa9, 0x2a, 0xe5, 0xd5, 0xb3, 0xf3, 0x8a, 0xf8, 0x83, 0x8f, + 0xf7, 0x6c, 0xdf, 0xfd, 0xe6, 0xdb, 0x8d, 0xa5, 0x5f, 0x7c, 0xbb, 0xb1, 0xf4, 0xcb, 0x6f, 0x37, + 0x94, 0x17, 0x97, 0x1b, 0xca, 0x37, 0x97, 0x1b, 0xca, 0xcf, 0x2f, 0x37, 0x94, 0xff, 0xb8, 0xdc, + 0x50, 0x0e, 0x72, 0x9c, 0x76, 0x7e, 0xfa, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x12, 0x88, 0x9b, + 0x68, 0x84, 0x21, 0x00, 0x00, } diff --git a/api/types.proto b/api/types.proto index 1a2743111e..bccb3bcf6d 100644 --- a/api/types.proto +++ b/api/types.proto @@ -696,3 +696,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 ac3b87feb8..a1d9daa2f6 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 ( @@ -654,14 +658,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: @@ -689,13 +689,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() @@ -704,8 +704,297 @@ 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 + } + + // returns a slice of new secrets to send down + addSecretsForTask := func(readTx store.ReadTx, t *api.Task) []*api.Secret { + container := t.Spec.GetContainer() + if container == nil { + return nil + } + var newSecrets []*api.Secret + 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. + newSecrets = append(newSecrets, secrets[0]) + } + tasksUsingSecret[secretName][t.ID] = struct{}{} + } + + return newSecrets + } + + // 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) + newSecrets := addSecretsForTask(readTx, t) + initial.UpdateSecrets = append(initial.UpdateSecrets, newSecrets...) + } + 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 + } + + // 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) + updateSecrets = make(map[string]*api.Secret) + removeTasks = make(map[string]struct{}) + removeSecrets = make(map[string]struct{}) + ) + + 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 + } + + 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. + var newSecrets []*api.Secret + d.store.View(func(readTx store.ReadTx) { + newSecrets = addSecretsForTask(readTx, v.Task) + }) + for _, secret := range newSecrets { + updateSecrets[secret.ID] = secret + } + } + tasksMap[v.Task.ID] = v.Task + updateTasks[v.Task.ID] = v.Task + + oneModification() + case state.EventDeleteTask: + if _, exists := tasksMap[v.Task.ID]; !exists { + continue + } + + removeTasks[v.Task.ID] = struct{}{} + + 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) + removeSecrets[secretName] = struct{}{} + } + } + + 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 + } + + updateSecrets[v.Secret.ID] = v.Secret + + oneModification() + case state.EventDeleteSecret: + if _, exists := tasksUsingSecret[v.Secret.Spec.Annotations.Name]; !exists { + continue + } + + delete(tasksUsingSecret, v.Secret.Spec.Annotations.Name) + + removeSecrets[v.Secret.ID] = struct{}{} + + 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 { + for id, task := range updateTasks { + if _, ok := removeTasks[id]; !ok { + update.UpdateTasks = append(update.UpdateTasks, task) + } + } + for id, secret := range updateSecrets { + if _, ok := removeSecrets[id]; !ok { + update.UpdateSecrets = append(update.UpdateSecrets, secret) + } + } + for id := range removeTasks { + update.RemoveTasks = append(update.RemoveTasks, id) + } + for id := range removeSecrets { + update.RemoveSecrets = append(update.RemoveSecrets, id) + } + + 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. //