From 30d9fe30b1c1bf52f15a41e0b106a1542a167e04 Mon Sep 17 00:00:00 2001 From: Drew Erny Date: Wed, 11 Dec 2019 10:05:03 -0600 Subject: [PATCH] Add swarm jobs Adds support for ReplicatedJob and GlobalJob service modes. These modes allow running service which execute tasks that exit upon success, instead of daemon-type tasks. Signed-off-by: Drew Erny --- api/server/router/swarm/helpers.go | 6 + api/swagger.yaml | 53 + api/types/swarm/service.go | 61 +- api/types/swarm/task.go | 6 + daemon/cluster/convert/service.go | 58 +- daemon/cluster/convert/task.go | 6 + daemon/cluster/services.go | 9 +- docs/api/version-history.md | 21 +- integration/internal/swarm/service.go | 9 +- integration/internal/swarm/states.go | 81 ++ integration/service/jobs_test.go | 143 +++ vendor.conf | 2 +- .../docker/swarmkit/api/control.pb.go | 383 +++--- .../docker/swarmkit/api/control.proto | 7 + .../docker/swarmkit/api/objects.pb.go | 501 +++++--- .../docker/swarmkit/api/objects.proto | 8 + .../docker/swarmkit/api/specs.pb.go | 1067 +++++++++++++---- .../docker/swarmkit/api/specs.proto | 22 + .../docker/swarmkit/api/types.pb.go | 920 +++++++++----- .../docker/swarmkit/api/types.proto | 16 + .../swarmkit/manager/controlapi/service.go | 106 +- .../docker/swarmkit/manager/manager.go | 11 + .../constraintenforcer/constraint_enforcer.go | 4 +- .../orchestrator/jobs/global/reconciler.go | 301 +++++ .../manager/orchestrator/jobs/orchestrator.go | 250 ++++ .../jobs/replicated/reconciler.go | 296 +++++ .../manager/orchestrator/restart/restart.go | 48 +- .../swarmkit/manager/orchestrator/service.go | 20 + .../manager/orchestrator/taskinit/init.go | 4 +- .../swarmkit/manager/scheduler/nodeinfo.go | 8 +- .../swarmkit/manager/scheduler/scheduler.go | 7 +- vendor/github.com/docker/swarmkit/vendor.conf | 9 + 32 files changed, 3463 insertions(+), 980 deletions(-) create mode 100644 integration/service/jobs_test.go create mode 100644 vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/global/reconciler.go create mode 100644 vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/orchestrator.go create mode 100644 vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/replicated/reconciler.go diff --git a/api/server/router/swarm/helpers.go b/api/server/router/swarm/helpers.go index 51fa86a178..cda883044a 100644 --- a/api/server/router/swarm/helpers.go +++ b/api/server/router/swarm/helpers.go @@ -101,5 +101,11 @@ func adjustForAPIVersion(cliVersion string, service *swarm.ServiceSpec) { // API version 1.41 service.TaskTemplate.ContainerSpec.Capabilities = nil } + + // jobs were only introduced in API version 1.41. Nil out both Job + // modes; if the service is one of these modes and subsequently has no + // mode, then something down the pipe will thrown an error. + service.Mode.ReplicatedJob = nil + service.Mode.GlobalJob = nil } } diff --git a/api/swagger.yaml b/api/swagger.yaml index e7527f0ba6..4328d18276 100644 --- a/api/swagger.yaml +++ b/api/swagger.yaml @@ -3183,6 +3183,12 @@ definitions: type: "integer" DesiredState: $ref: "#/definitions/TaskState" + JobIteration: + description: | + If the Service this Task belongs to is a job-mode service, contains + the JobIteration of the Service this Task was created for. Absent if + the Task was created for a Replicated or Global Service. + $ref: "#/definitions/ObjectVersion" example: ID: "0kzzo1i0y4jz6027t0k7aezc7" Version: @@ -3275,6 +3281,22 @@ definitions: format: "int64" Global: type: "object" + ReplicatedJob: + description: "The mode used for services with a finite number of tasks that run to a completed state." + type: "object" + properties: + MaxConcurrent: + description: "The maximum number of replicas to run simultaneously." + type: "integer" + format: "int64" + default: 1 + TotalCompletions: + description: "The total number of replicas desired to reach the Completed state. If unset, will default to the value of MaxConcurrent" + type: "integer" + format: "int64" + GlobalJob: + description: "The mode used for services which run a task to the completed state on each valid node." + type: "object" UpdateConfig: description: "Specification for the update strategy of the service." type: "object" @@ -3475,6 +3497,37 @@ definitions: type: "integer" format: "uint64" example: 10 + CompletedTasks: + description: | + The number of tasks for a job that are in the Completed state. + This field must be cross-referenced with the service type, as the + value of 0 may mean the service is not in a job mode, or it may + mean the job-mode service has no tasks yet Completed. + type: "integer" + format: "uint64" + JobStatus: + description: | + The status of the service when it is in one of ReplicatedJob or + GlobalJob modes. Absent on Replicated and Global mode services. The + JobIteration is an ObjectVersion, but unlike the Service's version, + does not need to be sent with an update request. + type: "object" + properties: + JobIteration: + description: | + JobIteration is a value increased each time a Job is executed, + successfully or otherwise. "Executed", in this case, means the + job as a whole has been started, not that an individual Task has + been launched. A job is "Executed" when its ServiceSpec is + updated. JobIteration can be used to disambiguate Tasks belonging + to different executions of a job. Though JobIteration will + increase with each subsequent execution, it may not necessarily + increase by 1, and so JobIteration should not be used to + $ref: "#/definitions/ObjectVersion" + LastExecution: + description: "The last time, as observed by the server, that this job was started" + type: "string" + format: "dateTime" example: ID: "9mnpnzenvg8p8tdbtq4wvbkcz" Version: diff --git a/api/types/swarm/service.go b/api/types/swarm/service.go index 6b59711ab2..6eb452d24d 100644 --- a/api/types/swarm/service.go +++ b/api/types/swarm/service.go @@ -17,6 +17,10 @@ type Service struct { // listing all tasks for a service, an operation that could be // computation and network expensive. ServiceStatus *ServiceStatus `json:",omitempty"` + + // JobStatus is the status of a Service which is in one of ReplicatedJob or + // GlobalJob modes. It is absent on Replicated and Global services. + JobStatus *JobStatus `json:",omitempty"` } // ServiceSpec represents the spec of a service. @@ -39,8 +43,10 @@ type ServiceSpec struct { // ServiceMode represents the mode of a service. type ServiceMode struct { - Replicated *ReplicatedService `json:",omitempty"` - Global *GlobalService `json:",omitempty"` + Replicated *ReplicatedService `json:",omitempty"` + Global *GlobalService `json:",omitempty"` + ReplicatedJob *ReplicatedJob `json:",omitempty"` + GlobalJob *GlobalJob `json:",omitempty"` } // UpdateState is the state of a service update. @@ -77,6 +83,32 @@ type ReplicatedService struct { // GlobalService is a kind of ServiceMode. type GlobalService struct{} +// ReplicatedJob is the a type of Service which executes a defined Tasks +// in parallel until the specified number of Tasks have succeeded. +type ReplicatedJob struct { + // MaxConcurrent indicates the maximum number of Tasks that should be + // executing simultaneously for this job at any given time. There may be + // fewer Tasks that MaxConcurrent executing simultaneously; for example, if + // there are fewer than MaxConcurrent tasks needed to reach + // TotalCompletions. + // + // If this field is empty, it will default to a max concurrency of 1. + MaxConcurrent *uint64 `json:",omitempty"` + + // TotalCompletions is the total number of Tasks desired to run to + // completion. + // + // If this field is empty, the value of MaxConcurrent will be used. + TotalCompletions *uint64 `json:",omitempty"` +} + +// GlobalJob is the type of a Service which executes a Task on every Node +// matching the Service's placement constraints. These tasks run to completion +// and then exit. +// +// This type is deliberately empty. +type GlobalJob struct{} + const ( // UpdateFailureActionPause PAUSE UpdateFailureActionPause = "pause" @@ -142,4 +174,29 @@ type ServiceStatus struct { // services, this is computed by taking the number of tasks with desired // state of not-Shutdown. DesiredTasks uint64 + + // CompletedTasks is the number of tasks in the state Completed, if this + // service is in ReplicatedJob or GlobalJob mode. This field must be + // cross-referenced with the service type, because the default value of 0 + // may mean that a service is not in a job mode, or it may mean that the + // job has yet to complete any tasks. + CompletedTasks uint64 +} + +// JobStatus is the status of a job-type service. +type JobStatus struct { + // JobIteration is a value increased each time a Job is executed, + // successfully or otherwise. "Executed", in this case, means the job as a + // whole has been started, not that an individual Task has been launched. A + // job is "Executed" when its ServiceSpec is updated. JobIteration can be + // used to disambiguate Tasks belonging to different executions of a job. + // + // Though JobIteration will increase with each subsequent execution, it may + // not necessarily increase by 1, and so JobIteration should not be used to + // keep track of the number of times a job has been executed. + JobIteration Version + + // LastExecution is the time that the job was last executed, as observed by + // Swarm manager. + LastExecution time.Time `json:",omitempty"` } diff --git a/api/types/swarm/task.go b/api/types/swarm/task.go index d5a57df5db..9f193df37c 100644 --- a/api/types/swarm/task.go +++ b/api/types/swarm/task.go @@ -56,6 +56,12 @@ type Task struct { DesiredState TaskState `json:",omitempty"` NetworksAttachments []NetworkAttachment `json:",omitempty"` GenericResources []GenericResource `json:",omitempty"` + + // JobIteration is the JobIteration of the Service that this Task was + // spawned from, if the Service is a ReplicatedJob or GlobalJob. This is + // used to determine which Tasks belong to which run of the job. This field + // is absent if the Service mode is Replicated or Global. + JobIteration *Version `json:",omitempty"` } // TaskSpec represents the spec of a task. diff --git a/daemon/cluster/convert/service.go b/daemon/cluster/convert/service.go index 2b72342590..144bc4cc93 100644 --- a/daemon/cluster/convert/service.go +++ b/daemon/cluster/convert/service.go @@ -44,6 +44,15 @@ func ServiceFromGRPC(s swarmapi.Service) (types.Service, error) { service.CreatedAt, _ = gogotypes.TimestampFromProto(s.Meta.CreatedAt) service.UpdatedAt, _ = gogotypes.TimestampFromProto(s.Meta.UpdatedAt) + if s.JobStatus != nil { + service.JobStatus = &types.JobStatus{ + JobIteration: types.Version{ + Index: s.JobStatus.JobIteration.Index, + }, + } + service.JobStatus.LastExecution, _ = gogotypes.TimestampFromProto(s.JobStatus.LastExecution) + } + // UpdateStatus if s.UpdateStatus != nil { service.UpdateStatus = &types.UpdateStatus{} @@ -131,6 +140,13 @@ func serviceSpecFromGRPC(spec *swarmapi.ServiceSpec) (*types.ServiceSpec, error) convertedSpec.Mode.Replicated = &types.ReplicatedService{ Replicas: &t.Replicated.Replicas, } + case *swarmapi.ServiceSpec_ReplicatedJob: + convertedSpec.Mode.ReplicatedJob = &types.ReplicatedJob{ + MaxConcurrent: &t.ReplicatedJob.MaxConcurrent, + TotalCompletions: &t.ReplicatedJob.TotalCompletions, + } + case *swarmapi.ServiceSpec_GlobalJob: + convertedSpec.Mode.GlobalJob = &types.GlobalJob{} } return convertedSpec, nil @@ -283,14 +299,52 @@ func ServiceSpecToGRPC(s types.ServiceSpec) (swarmapi.ServiceSpec, error) { } // Mode - if s.Mode.Global != nil && s.Mode.Replicated != nil { - return swarmapi.ServiceSpec{}, fmt.Errorf("cannot specify both replicated mode and global mode") + numModes := 0 + if s.Mode.Global != nil { + numModes++ + } + if s.Mode.Replicated != nil { + numModes++ + } + if s.Mode.ReplicatedJob != nil { + numModes++ + } + if s.Mode.GlobalJob != nil { + numModes++ + } + + if numModes > 1 { + return swarmapi.ServiceSpec{}, fmt.Errorf("must specify only one service mode") } if s.Mode.Global != nil { spec.Mode = &swarmapi.ServiceSpec_Global{ Global: &swarmapi.GlobalService{}, } + } else if s.Mode.GlobalJob != nil { + spec.Mode = &swarmapi.ServiceSpec_GlobalJob{ + GlobalJob: &swarmapi.GlobalJob{}, + } + } else if s.Mode.ReplicatedJob != nil { + // if the service is a replicated job, we have two different kinds of + // values that might need to be defaulted. + + r := &swarmapi.ReplicatedJob{} + if s.Mode.ReplicatedJob.MaxConcurrent != nil { + r.MaxConcurrent = *s.Mode.ReplicatedJob.MaxConcurrent + } else { + r.MaxConcurrent = 1 + } + + if s.Mode.ReplicatedJob.TotalCompletions != nil { + r.TotalCompletions = *s.Mode.ReplicatedJob.TotalCompletions + } else { + r.TotalCompletions = r.MaxConcurrent + } + + spec.Mode = &swarmapi.ServiceSpec_ReplicatedJob{ + ReplicatedJob: r, + } } else if s.Mode.Replicated != nil && s.Mode.Replicated.Replicas != nil { spec.Mode = &swarmapi.ServiceSpec_Replicated{ Replicated: &swarmapi.ReplicatedService{Replicas: *s.Mode.Replicated.Replicas}, diff --git a/daemon/cluster/convert/task.go b/daemon/cluster/convert/task.go index 72e2805e1e..e218dc0320 100644 --- a/daemon/cluster/convert/task.go +++ b/daemon/cluster/convert/task.go @@ -65,5 +65,11 @@ func TaskFromGRPC(t swarmapi.Task) (types.Task, error) { }) } + if t.JobIteration != nil { + task.JobIteration = &types.Version{ + Index: t.JobIteration.Index, + } + } + return task, nil } diff --git a/daemon/cluster/services.go b/daemon/cluster/services.go index 0c9a98080e..a484b6d285 100644 --- a/daemon/cluster/services.go +++ b/daemon/cluster/services.go @@ -91,6 +91,10 @@ func (c *Cluster) GetServices(options apitypes.ServiceListOptions) ([]types.Serv mode = "global" case *swarmapi.ServiceSpec_Replicated: mode = "replicated" + case *swarmapi.ServiceSpec_ReplicatedJob: + mode = "replicatedjob" + case *swarmapi.ServiceSpec_GlobalJob: + mode = "globaljob" } if !options.Filters.ExactMatch("mode", mode) { @@ -131,8 +135,9 @@ func (c *Cluster) GetServices(options apitypes.ServiceListOptions) ([]types.Serv serviceMap := map[string]*types.ServiceStatus{} for _, status := range resp.Statuses { serviceMap[status.ServiceID] = &types.ServiceStatus{ - RunningTasks: status.RunningTasks, - DesiredTasks: status.DesiredTasks, + RunningTasks: status.RunningTasks, + DesiredTasks: status.DesiredTasks, + CompletedTasks: status.CompletedTasks, } } diff --git a/docs/api/version-history.md b/docs/api/version-history.md index a91bbc1dd5..ea474b76c4 100644 --- a/docs/api/version-history.md +++ b/docs/api/version-history.md @@ -32,8 +32,25 @@ keywords: "API, Docker, rcli, REST, documentation" version. This change is not versioned, and affects all API versions if the daemon has this patch. * `GET /services` now accepts query parameter `status`. When set `true`, - services returned will include `ServiceStatus`, which provides Desired and - Running task counts for the service. + services returned will include `ServiceStatus`, which provides Desired, + Running, and Completed task counts for the service. +* `GET /services` may now include `ReplicatedJob` or `GlobalJob` as the `Mode` + in a `ServiceSpec`. +* `GET /services/{id}` may now include `ReplicatedJob` or `GlobalJob` as the + `Mode` in a `ServiceSpec`. +* `POST /services/create` now accepts `ReplicatedJob or `GlobalJob` as the `Mode` + in the `ServiceSpec. +* `POST /services/{id}/update` accepts updating the fields of the + `ReplicatedJob` object in the `ServiceSpec.Mode`. The service mode still + cannot be changed, however. +* `GET /services` now includes `JobStatus` on Services with mode + `ReplicatedJob` or `GlobalJob`. +* `GET /services/{id}` now includes `JobStatus` on Services with mode + `ReplicatedJob` or `GlobalJob`. +* `GET /tasks` now includes `JobIteration` on Tasks spawned from a job-mode + service. +* `GET /tasks/{id}` now includes `JobIteration` on the task if spawned from a + job-mode service. ## v1.40 API changes diff --git a/integration/internal/swarm/service.go b/integration/internal/swarm/service.go index ac0bded03c..ccf945b6fa 100644 --- a/integration/internal/swarm/service.go +++ b/integration/internal/swarm/service.go @@ -20,7 +20,7 @@ import ( // ServicePoll tweaks the pollSettings for `service` func ServicePoll(config *poll.Settings) { // Override the default pollSettings for `service` resource here ... - config.Timeout = 30 * time.Second + config.Timeout = 15 * time.Second config.Delay = 100 * time.Millisecond if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" { config.Timeout = 90 * time.Second @@ -91,6 +91,13 @@ func CreateServiceSpec(t *testing.T, opts ...ServiceSpecOpt) swarmtypes.ServiceS return spec } +// ServiceWithMode sets the mode of the service to the provided mode. +func ServiceWithMode(mode swarmtypes.ServiceMode) func(*swarmtypes.ServiceSpec) { + return func(spec *swarmtypes.ServiceSpec) { + spec.Mode = mode + } +} + // ServiceWithInit sets whether the service should use init or not func ServiceWithInit(b *bool) func(*swarmtypes.ServiceSpec) { return func(spec *swarmtypes.ServiceSpec) { diff --git a/integration/internal/swarm/states.go b/integration/internal/swarm/states.go index bf95b786ca..77b3f30209 100644 --- a/integration/internal/swarm/states.go +++ b/integration/internal/swarm/states.go @@ -2,6 +2,7 @@ package swarm import ( "context" + "fmt" "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/filters" @@ -82,3 +83,83 @@ func RunningTasksCount(client client.ServiceAPIClient, serviceID string, instanc } } } + +// JobComplete is a poll function for determining that a ReplicatedJob is +// completed additionally, while polling, it verifies that the job never +// exceeds MaxConcurrent running tasks +func JobComplete(client client.CommonAPIClient, service swarmtypes.Service) func(log poll.LogT) poll.Result { + filter := filters.NewArgs() + filter.Add("service", service.ID) + + var jobIteration swarmtypes.Version + if service.JobStatus != nil { + jobIteration = service.JobStatus.JobIteration + } + + maxRaw := service.Spec.Mode.ReplicatedJob.MaxConcurrent + totalRaw := service.Spec.Mode.ReplicatedJob.TotalCompletions + + max := int(*maxRaw) + total := int(*totalRaw) + + previousResult := "" + + return func(log poll.LogT) poll.Result { + tasks, err := client.TaskList(context.Background(), types.TaskListOptions{ + Filters: filter, + }) + + if err != nil { + poll.Error(err) + } + + var running int + var completed int + + var runningSlot []int + var runningID []string + + for _, task := range tasks { + // make sure the task has the same job iteration + if task.JobIteration == nil || task.JobIteration.Index != jobIteration.Index { + continue + } + switch task.Status.State { + case swarmtypes.TaskStateRunning: + running++ + runningSlot = append(runningSlot, task.Slot) + runningID = append(runningID, task.ID) + case swarmtypes.TaskStateComplete: + completed++ + } + } + + switch { + case running > max: + return poll.Error(fmt.Errorf( + "number of running tasks (%v) exceeds max (%v)", running, max, + )) + case (completed + running) > total: + return poll.Error(fmt.Errorf( + "number of tasks exceeds total (%v), %v running and %v completed", + total, running, completed, + )) + case completed == total && running == 0: + return poll.Success() + default: + newRes := fmt.Sprintf( + "Completed: %2d Running: %v\n\t%v", + completed, runningSlot, runningID, + ) + if newRes == previousResult { + } else { + previousResult = newRes + } + + return poll.Continue( + "Job not yet finished, %v completed and %v running out of %v total", + completed, running, total, + ) + } + } +} diff --git a/integration/service/jobs_test.go b/integration/service/jobs_test.go new file mode 100644 index 0000000000..6c1ac06f88 --- /dev/null +++ b/integration/service/jobs_test.go @@ -0,0 +1,143 @@ +package service + +import ( + "context" + "testing" + + "github.com/docker/docker/api/types" + swarmtypes "github.com/docker/docker/api/types/swarm" + "github.com/docker/docker/integration/internal/swarm" + "gotest.tools/assert" + "gotest.tools/poll" + "gotest.tools/skip" +) + +// The file jobs_test.go contains tests that verify that services which are in +// the mode ReplicatedJob or GlobalJob. + +// TestCreateJob tests that a Service can be created and run with +// mode ReplicatedJob +func TestCreateJob(t *testing.T) { + skip.If(t, testEnv.IsRemoteDaemon) + skip.If(t, testEnv.DaemonInfo.OSType == "windows") + + defer setupTest(t) + + d := swarm.NewSwarm(t, testEnv) + defer d.Stop(t) + + client := d.NewClientT(t) + defer client.Close() + + for _, mode := range []swarmtypes.ServiceMode{ + {ReplicatedJob: &swarmtypes.ReplicatedJob{}}, + {GlobalJob: &swarmtypes.GlobalJob{}}, + } { + id := swarm.CreateService(t, d, swarm.ServiceWithMode(mode)) + + poll.WaitOn(t, swarm.RunningTasksCount(client, id, 1), swarm.ServicePoll) + } +} + +// TestReplicatedJob tests that running a replicated job starts the requisite +// number of tasks, +func TestReplicatedJob(t *testing.T) { + skip.If(t, testEnv.IsRemoteDaemon) + skip.If(t, testEnv.DaemonInfo.OSType == "windows") + + // we need variables, because the replicas field takes a pointer + maxConcurrent := uint64(2) + // there is overhead, especially in the test environment, associated with + // starting tasks. if total is set too high, then the time needed to + // complete the test, even if everything is proceeding ideally, may exceed + // the time the test has to execute + // + // in CI,the test has been seen to time out with as few as 7 completions + // after 15 seconds. this means 7 completions ought not be too many. + total := uint64(7) + + defer setupTest(t) + + d := swarm.NewSwarm(t, testEnv) + defer d.Stop(t) + + client := d.NewClientT(t) + defer client.Close() + + id := swarm.CreateService(t, d, + swarm.ServiceWithMode(swarmtypes.ServiceMode{ + ReplicatedJob: &swarmtypes.ReplicatedJob{ + MaxConcurrent: &maxConcurrent, + TotalCompletions: &total, + }, + }), + // just run a command to execute and exit peacefully. + swarm.ServiceWithCommand([]string{"true"}), + ) + + service, _, err := client.ServiceInspectWithRaw( + context.Background(), id, types.ServiceInspectOptions{}, + ) + assert.NilError(t, err) + + poll.WaitOn(t, swarm.JobComplete(client, service), swarm.ServicePoll) +} + +// TestUpdateJob tests that a job can be updated, and that it runs with the +// correct parameters. +func TestUpdateReplicatedJob(t *testing.T) { + skip.If(t, testEnv.IsRemoteDaemon) + skip.If(t, testEnv.DaemonInfo.OSType == "windows") + + defer setupTest(t)() + + d := swarm.NewSwarm(t, testEnv) + defer d.Stop(t) + + client := d.NewClientT(t) + defer client.Close() + + // avoid writing "context.Background()" over and over again + ctx := context.Background() + + // Create the job service + id := swarm.CreateService(t, d, + swarm.ServiceWithMode(swarmtypes.ServiceMode{ + ReplicatedJob: &swarmtypes.ReplicatedJob{ + // use the default, empty values. + }, + }), + // run "true" so the task exits with 0 + swarm.ServiceWithCommand([]string{"true"}), + ) + + service, _, err := client.ServiceInspectWithRaw( + ctx, id, types.ServiceInspectOptions{}, + ) + assert.NilError(t, err) + + // wait for the job to completed + poll.WaitOn(t, swarm.JobComplete(client, service), swarm.ServicePoll) + + // update the job. + spec := service.Spec + spec.TaskTemplate.ForceUpdate++ + + _, err = client.ServiceUpdate( + ctx, id, service.Version, spec, types.ServiceUpdateOptions{}, + ) + assert.NilError(t, err) + + service2, _, err := client.ServiceInspectWithRaw( + ctx, id, types.ServiceInspectOptions{}, + ) + assert.NilError(t, err) + + // assert that the job iteration has increased + assert.Assert(t, + service.JobStatus.JobIteration.Index < service2.JobStatus.JobIteration.Index, + ) + + // now wait for the service to complete a second time. + poll.WaitOn(t, swarm.JobComplete(client, service2), swarm.ServicePoll) +} diff --git a/vendor.conf b/vendor.conf index dd127e53f0..0aa383e3b0 100644 --- a/vendor.conf +++ b/vendor.conf @@ -128,7 +128,7 @@ github.com/containerd/ttrpc 92c8520ef9f86600c650dd540266 github.com/gogo/googleapis d31c731455cb061f42baff3bda55bad0118b126b # v1.2.0 # cluster -github.com/docker/swarmkit 24fb4cfe8af56803640180c5592bf32da732ced2 +github.com/docker/swarmkit ef128ab4f5d50ffe4851d937b2b296e55562d10f github.com/gogo/protobuf ba06b47c162d49f2af050fb4c75bcbc86a159d5c # v1.2.1 github.com/golang/protobuf aa810b61a9c79d51363740d207bb46cf8e620ed5 # v1.2.0 github.com/cloudflare/cfssl 5d63dbd981b5c408effbb58c442d54761ff94fbd # 1.3.2 diff --git a/vendor/github.com/docker/swarmkit/api/control.pb.go b/vendor/github.com/docker/swarmkit/api/control.pb.go index dc66167f97..8c106ff16b 100644 --- a/vendor/github.com/docker/swarmkit/api/control.pb.go +++ b/vendor/github.com/docker/swarmkit/api/control.pb.go @@ -1167,6 +1167,12 @@ type ListServiceStatusesResponse_ServiceStatus struct { // request time. This may be larger than desired tasks if, for example, a // service has been scaled down. RunningTasks uint64 `protobuf:"varint,3,opt,name=running_tasks,json=runningTasks,proto3" json:"running_tasks,omitempty"` + // CompletedTasks is the number of tasks in state Completed, if this + // service is in mode ReplicatedJob or GlobalJob. This must be + // cross-referenced with the service type, because the default value of 0 + // may mean that a service is not in a Job mode, or it may mean the Job has + // yet to complete any Tasks. + CompletedTasks uint64 `protobuf:"varint,4,opt,name=completed_tasks,json=completedTasks,proto3" json:"completed_tasks,omitempty"` } func (m *ListServiceStatusesResponse_ServiceStatus) Reset() { @@ -3435,180 +3441,181 @@ func init() { } var fileDescriptor_b37401dd08bf8930 = []byte{ - // 2760 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0x49, 0x6f, 0x1b, 0xc9, - 0x15, 0x16, 0x29, 0x4a, 0x22, 0x1f, 0xb5, 0xb9, 0x2c, 0x8f, 0x35, 0xb4, 0x23, 0x19, 0xed, 0x8d, - 0x76, 0x1c, 0x72, 0x86, 0xce, 0x64, 0x1c, 0xcf, 0x38, 0x89, 0x65, 0x79, 0xa1, 0x17, 0xd9, 0x68, - 0xc9, 0x46, 0x72, 0x08, 0x04, 0x8a, 0x2c, 0x69, 0xda, 0xa4, 0xba, 0x99, 0xee, 0xa6, 0xc7, 0x42, - 0x90, 0x20, 0x8b, 0x83, 0x39, 0x05, 0xc8, 0x25, 0x40, 0x90, 0x43, 0x80, 0x9c, 0x02, 0xe4, 0x90, - 0x43, 0x4e, 0x39, 0xe4, 0x07, 0x18, 0x39, 0xcd, 0x71, 0x4e, 0x4a, 0x46, 0x46, 0x80, 0x9c, 0xf2, - 0x17, 0x12, 0xd4, 0xd6, 0x4b, 0xb1, 0x7a, 0xe1, 0x02, 0x78, 0x4e, 0x12, 0xab, 0xbf, 0xb7, 0x54, - 0xbd, 0xd7, 0x5f, 0x55, 0xbf, 0x57, 0x70, 0x65, 0xcf, 0x70, 0x3f, 0xe9, 0xed, 0x54, 0x9a, 0xd6, - 0x7e, 0xb5, 0x65, 0x35, 0xdb, 0xd8, 0xae, 0x3a, 0x9f, 0x36, 0xec, 0xfd, 0xb6, 0xe1, 0x56, 0x1b, - 0x5d, 0xa3, 0xda, 0xb4, 0x4c, 0xd7, 0xb6, 0x3a, 0x95, 0xae, 0x6d, 0xb9, 0x16, 0x42, 0x0c, 0x52, - 0x11, 0x90, 0xca, 0x8b, 0xf7, 0x4b, 0x97, 0x13, 0x34, 0x38, 0x5d, 0xdc, 0x74, 0x98, 0x7c, 0x29, - 0xc9, 0x9a, 0xb5, 0xf3, 0x1c, 0x37, 0x5d, 0x81, 0x4e, 0xd2, 0xec, 0x1e, 0x74, 0xb1, 0xc0, 0x2e, - 0xed, 0x59, 0x7b, 0x16, 0xfd, 0xb7, 0x4a, 0xfe, 0xe3, 0xa3, 0xef, 0xee, 0x59, 0xd6, 0x5e, 0x07, - 0x57, 0xe9, 0xaf, 0x9d, 0xde, 0x6e, 0xb5, 0x61, 0x1e, 0xf0, 0x47, 0x1f, 0xc6, 0x28, 0xf7, 0xe0, - 0xdd, 0x4e, 0x6f, 0xcf, 0x30, 0xf9, 0x1f, 0x26, 0xa8, 0x7d, 0x00, 0xf3, 0x77, 0xb1, 0xbb, 0x61, - 0xb5, 0xb0, 0x8e, 0x7f, 0xd4, 0xc3, 0x8e, 0x8b, 0xce, 0xc2, 0x8c, 0x69, 0xb5, 0xf0, 0xb6, 0xd1, - 0x5a, 0xce, 0x9c, 0xc9, 0x94, 0x0b, 0x6b, 0x70, 0x74, 0xb8, 0x3a, 0x4d, 0x10, 0xf5, 0x75, 0x7d, - 0x9a, 0x3c, 0xaa, 0xb7, 0xb4, 0xef, 0xc2, 0x82, 0x27, 0xe6, 0x74, 0x2d, 0xd3, 0xc1, 0xe8, 0x0a, - 0xe4, 0xc8, 0x43, 0x2a, 0x54, 0xac, 0x2d, 0x57, 0xfa, 0x17, 0xb7, 0x42, 0xf1, 0x14, 0xa5, 0xbd, - 0x9a, 0x82, 0xc5, 0x87, 0x86, 0x43, 0x55, 0x38, 0xc2, 0xf4, 0x1d, 0x98, 0xd9, 0x35, 0x3a, 0x2e, - 0xb6, 0x1d, 0xae, 0xe5, 0x8a, 0x4a, 0x8b, 0x2c, 0x56, 0xb9, 0xc3, 0x64, 0x74, 0x21, 0x5c, 0xfa, - 0x53, 0x0e, 0x66, 0xf8, 0x20, 0x5a, 0x82, 0x29, 0xb3, 0xb1, 0x8f, 0x89, 0xc6, 0xc9, 0x72, 0x41, - 0x67, 0x3f, 0x50, 0x15, 0x8a, 0x46, 0x6b, 0xbb, 0x6b, 0xe3, 0x5d, 0xe3, 0x25, 0x76, 0x96, 0xb3, - 0xe4, 0xd9, 0xda, 0xfc, 0xd1, 0xe1, 0x2a, 0xd4, 0xd7, 0x9f, 0xf0, 0x51, 0x1d, 0x8c, 0x96, 0xf8, - 0x1f, 0x3d, 0x81, 0xe9, 0x4e, 0x63, 0x07, 0x77, 0x9c, 0xe5, 0xc9, 0x33, 0x93, 0xe5, 0x62, 0xed, - 0xda, 0x20, 0x9e, 0x55, 0x1e, 0x52, 0xd1, 0xdb, 0xa6, 0x6b, 0x1f, 0xe8, 0x5c, 0x0f, 0xfa, 0x21, - 0x14, 0xe9, 0x3a, 0x73, 0xb5, 0x33, 0x54, 0xed, 0xc7, 0x03, 0xa9, 0x25, 0x83, 0x41, 0xd5, 0x60, - 0x7a, 0x03, 0xe8, 0x11, 0x14, 0xf7, 0xf1, 0xfe, 0x0e, 0xb6, 0x9d, 0x4f, 0x8c, 0xae, 0xb3, 0x9c, - 0x3b, 0x33, 0x59, 0x9e, 0xaf, 0x5d, 0x8c, 0x8a, 0xca, 0x66, 0x17, 0x37, 0x2b, 0x8f, 0x3c, 0xfc, - 0x5a, 0x76, 0x71, 0x42, 0x0f, 0xca, 0xa3, 0x6f, 0xc1, 0x94, 0x6d, 0x75, 0xb0, 0xb3, 0x3c, 0x45, - 0x15, 0x9d, 0x8e, 0x0c, 0xaf, 0xd5, 0xc1, 0x54, 0x9a, 0xc1, 0xd1, 0x59, 0x98, 0x23, 0x2b, 0xee, - 0x2f, 0xf5, 0x34, 0x0d, 0xc3, 0x2c, 0x19, 0x14, 0x8b, 0x5b, 0xfa, 0x36, 0x14, 0x03, 0xd3, 0x40, - 0x8b, 0x30, 0xd9, 0xc6, 0x07, 0x2c, 0xfb, 0x74, 0xf2, 0x2f, 0x09, 0xe2, 0x8b, 0x46, 0xa7, 0x87, - 0x97, 0xb3, 0x74, 0x8c, 0xfd, 0xb8, 0x9e, 0xbd, 0x96, 0x29, 0xdd, 0x80, 0x05, 0x69, 0x15, 0x06, - 0x11, 0xd7, 0x6e, 0xc1, 0xb1, 0xc0, 0xea, 0xf2, 0x4c, 0xae, 0xc0, 0x14, 0x59, 0x48, 0x96, 0x32, - 0x71, 0xa9, 0xcc, 0x60, 0xda, 0x9f, 0x33, 0x70, 0xec, 0x69, 0xb7, 0xd5, 0x70, 0xf1, 0xa0, 0xef, - 0x11, 0xfa, 0x0e, 0xcc, 0x52, 0xd0, 0x0b, 0x6c, 0x3b, 0x86, 0x65, 0x52, 0x07, 0x8b, 0xb5, 0x53, - 0x2a, 0x8b, 0xcf, 0x18, 0x44, 0xa7, 0x59, 0xc3, 0x7f, 0xa0, 0xf7, 0x20, 0x47, 0x18, 0x69, 0x79, - 0x92, 0xca, 0x9d, 0x8e, 0x0b, 0xaf, 0x4e, 0x91, 0xda, 0x1a, 0xa0, 0xa0, 0xaf, 0x43, 0xbd, 0xbc, - 0x1b, 0x70, 0x4c, 0xc7, 0xfb, 0xd6, 0x8b, 0xc1, 0xe7, 0xbb, 0x04, 0x53, 0xbb, 0x96, 0xdd, 0x64, - 0x91, 0xc8, 0xeb, 0xec, 0x87, 0xb6, 0x04, 0x28, 0xa8, 0x8f, 0xf9, 0xc4, 0xa9, 0x69, 0xab, 0xe1, - 0xb4, 0x03, 0x26, 0xdc, 0x86, 0xd3, 0x96, 0x4c, 0x10, 0x04, 0x31, 0x41, 0x1e, 0x79, 0xd4, 0xc4, - 0xc4, 0xfc, 0xd9, 0x91, 0x87, 0x71, 0xb3, 0xa3, 0x78, 0x8a, 0xd2, 0xae, 0x89, 0xd9, 0x0d, 0x6c, - 0xda, 0x9b, 0x47, 0xd0, 0xba, 0xf6, 0xf7, 0x1c, 0xa3, 0x3a, 0x32, 0x38, 0x04, 0xd5, 0x05, 0xc5, - 0xfa, 0xa9, 0xee, 0x9f, 0x93, 0x6f, 0x8f, 0xea, 0x54, 0x9e, 0x29, 0xa9, 0xae, 0x0a, 0x45, 0x07, - 0xdb, 0x2f, 0x8c, 0x26, 0xc9, 0x0e, 0xc6, 0x45, 0xdc, 0x85, 0x4d, 0x36, 0x5c, 0x5f, 0x77, 0x74, - 0xe0, 0x90, 0x7a, 0xcb, 0x41, 0x17, 0x20, 0xcf, 0x73, 0x89, 0x11, 0x4e, 0x61, 0xad, 0x78, 0x74, - 0xb8, 0x3a, 0xc3, 0x92, 0xc9, 0xd1, 0x67, 0x58, 0x36, 0x39, 0xe8, 0x1e, 0xcc, 0xb7, 0xb0, 0x63, - 0xd8, 0xb8, 0xb5, 0xed, 0xb8, 0x0d, 0x97, 0xd3, 0xcb, 0x7c, 0xed, 0x6b, 0x51, 0x21, 0xde, 0x24, - 0x28, 0xca, 0x4f, 0x73, 0x5c, 0x90, 0x8e, 0x28, 0x78, 0x6a, 0xa6, 0x9f, 0xa7, 0x50, 0x09, 0xf2, - 0x76, 0xcf, 0x74, 0x0d, 0xb2, 0xc6, 0x05, 0xfa, 0xdc, 0xfb, 0x8d, 0x4e, 0x03, 0xf4, 0xba, 0xdb, - 0xae, 0xb5, 0x4d, 0xde, 0xad, 0xe5, 0x3c, 0x4d, 0xef, 0x7c, 0xaf, 0xbb, 0x65, 0xad, 0x37, 0x5c, - 0x3c, 0x02, 0xc3, 0x09, 0x8a, 0xe2, 0x8b, 0xed, 0x53, 0x14, 0xc9, 0xb9, 0x58, 0x8a, 0xa2, 0x49, - 0xc8, 0x60, 0xda, 0x03, 0x58, 0xba, 0x65, 0xe3, 0x86, 0x8b, 0xf9, 0x82, 0x8b, 0x34, 0xbc, 0xca, - 0xf9, 0x83, 0xe5, 0xe0, 0xaa, 0x4a, 0x0d, 0x97, 0x08, 0x50, 0xc8, 0x06, 0x9c, 0x90, 0x94, 0x71, - 0xaf, 0x3e, 0x80, 0x19, 0x1e, 0x44, 0xae, 0xf0, 0x54, 0x8c, 0x42, 0x5d, 0x60, 0xb5, 0xe7, 0x70, - 0xec, 0x2e, 0x76, 0x25, 0xcf, 0xae, 0x00, 0xf8, 0x39, 0xc3, 0xdf, 0xb9, 0xb9, 0xa3, 0xc3, 0xd5, - 0x82, 0x97, 0x32, 0x7a, 0xc1, 0xcb, 0x18, 0x74, 0x11, 0x16, 0x0c, 0xd3, 0xc1, 0xb6, 0xbb, 0xdd, - 0xc2, 0xbb, 0x8d, 0x5e, 0xc7, 0x75, 0x38, 0xc3, 0xcc, 0xb3, 0xe1, 0x75, 0x3e, 0xaa, 0x3d, 0x00, - 0x14, 0xb4, 0x35, 0x9a, 0xe3, 0x7f, 0xcd, 0xc2, 0x12, 0x23, 0xd3, 0x91, 0x9c, 0x5f, 0x87, 0x05, - 0x81, 0x1e, 0x60, 0x1f, 0x98, 0xe7, 0x32, 0x62, 0x2b, 0xb8, 0x1a, 0xda, 0x0a, 0xd2, 0x85, 0x12, - 0x3d, 0x82, 0xbc, 0x6d, 0x75, 0x3a, 0x3b, 0x8d, 0x66, 0x7b, 0x39, 0x77, 0x26, 0x53, 0x9e, 0xaf, - 0xbd, 0xaf, 0x12, 0x54, 0x4d, 0xb2, 0xa2, 0x73, 0x41, 0xdd, 0x53, 0xa1, 0x69, 0x90, 0x17, 0xa3, - 0x28, 0x0f, 0xb9, 0x8d, 0xc7, 0x1b, 0xb7, 0x17, 0x27, 0xd0, 0x2c, 0xe4, 0x9f, 0xe8, 0xb7, 0x9f, - 0xd5, 0x1f, 0x3f, 0xdd, 0x5c, 0xcc, 0x90, 0xec, 0x91, 0xd4, 0x8d, 0x16, 0x84, 0x75, 0x58, 0x62, - 0xa4, 0x3b, 0x4a, 0x0c, 0xb4, 0x93, 0x70, 0x42, 0xd2, 0xc2, 0xd9, 0xfb, 0xd5, 0x24, 0x1c, 0x27, - 0xef, 0x1f, 0x1f, 0xf7, 0x08, 0xbc, 0x2e, 0x13, 0x78, 0x35, 0x8a, 0x26, 0x25, 0xc9, 0x7e, 0x0e, - 0xff, 0x63, 0x76, 0xec, 0x1c, 0xbe, 0x29, 0x71, 0xf8, 0x47, 0x03, 0x3a, 0xa7, 0xa4, 0xf1, 0x3e, - 0x8e, 0xcc, 0x25, 0x70, 0xe4, 0x54, 0x98, 0x23, 0x47, 0x61, 0xc1, 0xc7, 0xb0, 0x14, 0x76, 0x97, - 0x27, 0xcd, 0x87, 0x90, 0xe7, 0x41, 0x14, 0x5c, 0x18, 0x9b, 0x35, 0x1e, 0x58, 0xbb, 0x06, 0xa5, - 0x80, 0x42, 0xb2, 0x0b, 0xf4, 0x1c, 0x3f, 0xba, 0x25, 0x49, 0x6d, 0x21, 0x20, 0xf9, 0x8b, 0x2c, - 0x9c, 0x52, 0x8a, 0x72, 0x97, 0x7e, 0x00, 0x79, 0x87, 0x8f, 0x71, 0x97, 0x6e, 0x24, 0xac, 0xbe, - 0xac, 0xa2, 0x12, 0x1a, 0xd7, 0x3d, 0x75, 0xa5, 0xcf, 0x32, 0x30, 0x17, 0x7a, 0x36, 0x20, 0xd3, - 0x9c, 0x05, 0xb1, 0xed, 0x6d, 0xb3, 0xed, 0x83, 0xac, 0x73, 0x4e, 0x9f, 0xe5, 0x83, 0x74, 0x8f, - 0x21, 0x20, 0xbb, 0x67, 0x9a, 0x86, 0xb9, 0xc7, 0x41, 0x93, 0x0c, 0xc4, 0x07, 0xb7, 0xc2, 0x1b, - 0xca, 0x06, 0x76, 0x3f, 0xb5, 0xec, 0xf6, 0x00, 0x1b, 0x0a, 0x97, 0x50, 0x6d, 0x28, 0x9e, 0x32, - 0x9f, 0x12, 0x4c, 0x36, 0x14, 0x47, 0x09, 0x42, 0x4a, 0x60, 0xb5, 0xa7, 0x74, 0x43, 0x91, 0x3c, - 0x43, 0x90, 0x23, 0x89, 0xca, 0xd3, 0x8d, 0xfe, 0x4f, 0x56, 0x8f, 0xcb, 0x90, 0xd5, 0xcb, 0xfa, - 0xab, 0xc7, 0x65, 0xc9, 0xea, 0x71, 0x40, 0xbd, 0xc5, 0xf7, 0x8e, 0x31, 0xf9, 0xf8, 0x7d, 0x41, - 0x5b, 0x63, 0x77, 0xd3, 0xa3, 0x32, 0xc9, 0x53, 0xed, 0x3f, 0x59, 0x46, 0x65, 0x7c, 0x7c, 0x08, - 0x2a, 0x93, 0x24, 0xfb, 0xa9, 0xec, 0x57, 0x6f, 0x91, 0xca, 0x22, 0x9c, 0x1b, 0x9a, 0xca, 0xc6, - 0x40, 0x57, 0xbe, 0x4b, 0x3e, 0x5d, 0xf1, 0x40, 0xc5, 0xd2, 0x95, 0x88, 0x9c, 0x07, 0xd6, 0x6e, - 0xd2, 0x94, 0xbe, 0xd5, 0xe9, 0x39, 0x2e, 0xb6, 0x03, 0x5b, 0x5c, 0x93, 0x8d, 0x48, 0x2f, 0x3f, - 0xc7, 0x91, 0xbc, 0xe0, 0x00, 0x2f, 0x7d, 0x3d, 0x15, 0x7e, 0xfa, 0x72, 0x48, 0x5c, 0xfa, 0x0a, - 0x29, 0x81, 0xf5, 0x72, 0x89, 0x3f, 0x18, 0x22, 0x97, 0x24, 0xc9, 0xaf, 0x56, 0x2e, 0x45, 0x38, - 0xf7, 0x36, 0x73, 0xc9, 0x77, 0xc9, 0xcf, 0x25, 0x1e, 0x8d, 0xd8, 0x5c, 0x12, 0xa1, 0xf3, 0xc0, - 0xda, 0x6f, 0x33, 0x50, 0x7c, 0x80, 0x0f, 0x74, 0xcb, 0x6d, 0xb8, 0xe4, 0xe4, 0x78, 0x19, 0x8e, - 0x91, 0x24, 0xc3, 0xf6, 0xf6, 0x73, 0xcb, 0x30, 0xb7, 0x5d, 0xab, 0x8d, 0x4d, 0xea, 0x5a, 0x5e, - 0x5f, 0x60, 0x0f, 0xee, 0x5b, 0x86, 0xb9, 0x45, 0x86, 0xd1, 0x15, 0x40, 0xfb, 0x0d, 0xb3, 0xb1, - 0x17, 0x06, 0xb3, 0xb3, 0xf6, 0x22, 0x7f, 0xa2, 0x44, 0xf7, 0xcc, 0x8e, 0xd5, 0x6c, 0x6f, 0x93, - 0x59, 0x4f, 0x86, 0xd0, 0x4f, 0xe9, 0x83, 0x07, 0xf8, 0x80, 0x6c, 0xac, 0xfc, 0x38, 0x3d, 0x4a, - 0x9e, 0x93, 0xe3, 0xb4, 0x40, 0x0f, 0x72, 0x9c, 0xe6, 0x32, 0x03, 0x1c, 0xa7, 0xb9, 0xf5, 0xc0, - 0x71, 0xfa, 0x26, 0x39, 0x4e, 0xb3, 0x55, 0xa5, 0xc7, 0xe9, 0x08, 0xc1, 0xc0, 0xe2, 0xaf, 0xe5, - 0x5e, 0x1f, 0xae, 0x4e, 0xe8, 0x9e, 0x98, 0x7f, 0x3c, 0x1e, 0xd3, 0x8b, 0x7a, 0x03, 0x16, 0xe9, - 0x07, 0x4f, 0xd3, 0xc6, 0xae, 0x58, 0xcf, 0x4b, 0x50, 0x70, 0xe8, 0x80, 0xbf, 0x9c, 0xb3, 0x47, - 0x87, 0xab, 0x79, 0x86, 0xaa, 0xaf, 0x93, 0xc3, 0x0e, 0xfd, 0xaf, 0xa5, 0xdd, 0xe5, 0xdf, 0x66, - 0x4c, 0x9c, 0xbb, 0x52, 0x83, 0x69, 0x06, 0xe0, 0x9e, 0x94, 0xd4, 0x47, 0x2e, 0x2a, 0xc3, 0x91, - 0xda, 0xdf, 0x32, 0x70, 0x5c, 0x9c, 0xfb, 0x87, 0xf3, 0x05, 0xad, 0xc1, 0x3c, 0x87, 0x0e, 0x10, - 0xd7, 0x39, 0x26, 0x22, 0xc2, 0x5a, 0x0b, 0x85, 0x75, 0x25, 0xda, 0xf1, 0xc0, 0xf1, 0xe4, 0xbe, - 0xff, 0x95, 0x37, 0xf2, 0x32, 0xfc, 0x3b, 0x0b, 0x88, 0x9d, 0xfc, 0xc8, 0x4f, 0x8f, 0x36, 0xef, - 0xc9, 0xb4, 0x59, 0x89, 0x3e, 0x32, 0x06, 0x05, 0xfb, 0x59, 0xf3, 0xd5, 0xf8, 0x59, 0x53, 0x97, - 0x58, 0xf3, 0xfa, 0x60, 0xbe, 0xbd, 0x15, 0xd2, 0x7c, 0x20, 0xbe, 0xda, 0xb8, 0x47, 0x3c, 0x64, - 0xdf, 0x24, 0xdf, 0x98, 0x74, 0x88, 0x53, 0x66, 0x5c, 0xcc, 0x04, 0x54, 0xab, 0xc3, 0x71, 0x51, - 0xf0, 0x08, 0xa6, 0x6e, 0x2d, 0x74, 0xd6, 0x4d, 0x9d, 0x4b, 0x61, 0x55, 0x23, 0xe4, 0xd2, 0xf7, - 0xe0, 0xb8, 0xf8, 0x66, 0x1d, 0xf2, 0xed, 0x7e, 0xc7, 0xff, 0x76, 0x0e, 0x7a, 0xc3, 0x49, 0xe3, - 0x96, 0x65, 0xee, 0x1a, 0x7b, 0x01, 0xb5, 0x4d, 0x3a, 0x20, 0xa9, 0x65, 0x28, 0xa2, 0x96, 0x3d, - 0xf6, 0x48, 0x43, 0x88, 0xfb, 0x33, 0x64, 0x80, 0xb8, 0x19, 0x72, 0x19, 0x8e, 0x0c, 0x90, 0xc6, - 0xb0, 0xbe, 0x10, 0xd2, 0xe0, 0xd0, 0x41, 0x48, 0x83, 0x89, 0x0c, 0x40, 0x1a, 0xcc, 0xb2, 0x8a, - 0x34, 0xc6, 0xb0, 0x0c, 0x82, 0x34, 0xd8, 0xf0, 0x10, 0xa4, 0x11, 0x16, 0xfc, 0x6a, 0x91, 0x86, - 0xda, 0xb7, 0xb7, 0x49, 0x1a, 0x9e, 0x47, 0x3e, 0x69, 0xb0, 0x40, 0xc4, 0x92, 0x06, 0x8f, 0x99, - 0x80, 0xfa, 0xa4, 0x11, 0x4e, 0xdd, 0x14, 0xa4, 0xa1, 0xca, 0xa5, 0xb0, 0xaa, 0x11, 0x72, 0xc9, - 0x23, 0x8d, 0xa1, 0xdf, 0x6e, 0x8f, 0x34, 0xc2, 0xde, 0x68, 0x3f, 0x81, 0x77, 0x98, 0x97, 0xb7, - 0x5f, 0xba, 0xd8, 0xa4, 0xef, 0x11, 0x57, 0x7e, 0x13, 0x8a, 0x0d, 0xd3, 0xe4, 0x27, 0x1c, 0x27, - 0xae, 0x36, 0x70, 0xd3, 0x87, 0xe9, 0x41, 0x19, 0x74, 0x06, 0x8a, 0x2d, 0xec, 0x34, 0x6d, 0xa3, - 0xeb, 0x8a, 0x77, 0xb8, 0xa0, 0x07, 0x87, 0xb4, 0x67, 0x70, 0xb2, 0xcf, 0x3c, 0x5f, 0xa7, 0x8f, - 0xa0, 0x80, 0xc5, 0x20, 0xb7, 0xae, 0xec, 0x10, 0xf8, 0x92, 0x3e, 0x5e, 0x7b, 0x08, 0xef, 0xb0, - 0xe9, 0xf6, 0x4d, 0xab, 0x06, 0xb3, 0x1e, 0xcc, 0x5f, 0xb6, 0x85, 0xa3, 0xc3, 0xd5, 0xa2, 0x87, - 0xad, 0xaf, 0xeb, 0x45, 0x0f, 0x54, 0x6f, 0x69, 0xef, 0xc2, 0xc9, 0x3e, 0x6d, 0x7c, 0xfd, 0xea, - 0x70, 0xfc, 0x2e, 0x76, 0xc7, 0x62, 0x65, 0x13, 0x96, 0xc2, 0xaa, 0xc6, 0xb1, 0x10, 0x7f, 0xc8, - 0x88, 0x32, 0x8d, 0x8e, 0x1d, 0xab, 0x67, 0xfb, 0xa5, 0xd6, 0x31, 0xc4, 0x17, 0x41, 0xae, 0x6d, - 0x98, 0xbc, 0xb8, 0xa1, 0xd3, 0xff, 0x51, 0x05, 0x66, 0xba, 0x8d, 0x83, 0x8e, 0xd5, 0x68, 0x71, - 0xe6, 0x5d, 0xaa, 0xb0, 0x1b, 0x10, 0x15, 0x71, 0xa5, 0xa1, 0x72, 0xd3, 0x3c, 0xd0, 0x05, 0x48, - 0xd3, 0x45, 0x02, 0xfa, 0xfe, 0xf1, 0x79, 0x5f, 0x83, 0xbc, 0xcd, 0xc7, 0xb8, 0x77, 0xca, 0x56, - 0xa9, 0x27, 0xe7, 0xa1, 0xb5, 0x7b, 0xa2, 0x98, 0x22, 0xcf, 0xb9, 0x0a, 0x45, 0x01, 0xf2, 0xa3, - 0x42, 0x09, 0x51, 0x20, 0xeb, 0xeb, 0x3a, 0x08, 0x48, 0xbd, 0xa5, 0x2d, 0x8b, 0x3c, 0x92, 0xbd, - 0xd3, 0x7e, 0x99, 0x15, 0x67, 0xfe, 0x51, 0x8d, 0xa0, 0x3b, 0xb0, 0xe8, 0x09, 0x0c, 0xb0, 0xdf, - 0x2d, 0x08, 0x21, 0xb1, 0xe3, 0x49, 0x11, 0x9d, 0x1c, 0x22, 0xa2, 0x81, 0xe8, 0xe5, 0x52, 0x46, - 0x4f, 0x5e, 0x84, 0x91, 0xa3, 0x77, 0x9b, 0x96, 0x3c, 0x46, 0x0e, 0xdd, 0x63, 0xfa, 0x66, 0x8e, - 0xd1, 0xaf, 0xff, 0x65, 0xd9, 0x37, 0xbd, 0x78, 0xe4, 0x6d, 0xe9, 0xf7, 0xe5, 0x2d, 0xfd, 0xbd, - 0xa8, 0x6d, 0x53, 0x16, 0xed, 0xdf, 0xd4, 0x7f, 0x3f, 0xfe, 0x4d, 0x7d, 0x4b, 0xda, 0xd4, 0x3f, - 0x1e, 0xd4, 0xbb, 0xe1, 0xfb, 0x0a, 0x82, 0x20, 0xa6, 0x7c, 0x82, 0x18, 0x65, 0xab, 0xdf, 0x84, - 0x13, 0x92, 0x9f, 0x3c, 0xa8, 0xd7, 0xa1, 0x20, 0xc2, 0x24, 0xb6, 0xfb, 0xf8, 0xa8, 0xfa, 0xf0, - 0xda, 0x67, 0xe7, 0x60, 0xe6, 0x16, 0xbb, 0x62, 0x86, 0x0c, 0x98, 0xe1, 0x37, 0xa4, 0x90, 0xa6, - 0x92, 0x0f, 0xdf, 0xba, 0x2a, 0x9d, 0x8d, 0xc5, 0x70, 0xa2, 0x38, 0xf1, 0x8f, 0xbf, 0xfc, 0xf7, - 0x77, 0xd9, 0x05, 0x98, 0xa3, 0xa0, 0x6f, 0xf0, 0x02, 0x0a, 0xb2, 0xa0, 0xe0, 0x5d, 0x62, 0x41, - 0xe7, 0xd2, 0xdc, 0x20, 0x2a, 0x9d, 0x4f, 0x40, 0xc5, 0x1b, 0xb4, 0x01, 0xfc, 0x3b, 0x24, 0xe8, - 0x7c, 0x74, 0xc7, 0x30, 0x38, 0xc3, 0x0b, 0x49, 0xb0, 0x44, 0x9b, 0xfe, 0x1d, 0x11, 0xb5, 0xcd, - 0xbe, 0x3b, 0x29, 0x6a, 0x9b, 0x8a, 0xab, 0x26, 0x11, 0x36, 0x59, 0x0c, 0xb7, 0x1a, 0x4e, 0x3b, - 0x32, 0x86, 0x81, 0x3b, 0x22, 0x91, 0x31, 0x0c, 0xdd, 0x06, 0x89, 0x8f, 0x21, 0xeb, 0xc0, 0x9c, - 0x4b, 0x73, 0xe3, 0x22, 0x3a, 0x86, 0xa1, 0xab, 0x02, 0x89, 0xeb, 0x49, 0xa7, 0x17, 0xb3, 0x9e, - 0xc1, 0x19, 0x5e, 0x48, 0x82, 0x25, 0xda, 0xf4, 0x9b, 0xef, 0x6a, 0x9b, 0x7d, 0x17, 0x01, 0xd4, - 0x36, 0xfb, 0x7b, 0xf8, 0x51, 0x36, 0x5f, 0xc2, 0x6c, 0xb0, 0x71, 0x88, 0x2e, 0xa6, 0xec, 0x84, - 0x96, 0xca, 0xc9, 0xc0, 0x78, 0xcb, 0x3f, 0x86, 0xb9, 0xd0, 0x35, 0x09, 0xa4, 0xd4, 0xa8, 0xba, - 0x96, 0x51, 0xba, 0x94, 0x02, 0x99, 0x68, 0x3c, 0xd4, 0x65, 0x57, 0x1b, 0x57, 0xf5, 0xf5, 0xd5, - 0xc6, 0x95, 0x2d, 0xfb, 0x18, 0xe3, 0xa1, 0x66, 0xba, 0xda, 0xb8, 0xaa, 0x6b, 0xaf, 0x36, 0xae, - 0xee, 0xcc, 0x47, 0x18, 0xff, 0x75, 0x26, 0xd4, 0xb0, 0x17, 0xbd, 0x55, 0x54, 0x49, 0xdd, 0x84, - 0x65, 0x9e, 0x54, 0x07, 0x6c, 0xda, 0xc6, 0x27, 0x3d, 0xef, 0xe8, 0x44, 0x26, 0x7d, 0xb8, 0x0b, - 0x18, 0x99, 0xf4, 0x72, 0x4b, 0x2f, 0x3e, 0xe9, 0x45, 0xfb, 0x29, 0x3a, 0xe9, 0xa5, 0x9e, 0x59, - 0x74, 0xd2, 0xcb, 0x9d, 0xac, 0xc4, 0xa4, 0x17, 0x13, 0x8e, 0x49, 0x7a, 0x69, 0xce, 0x97, 0x52, - 0x20, 0x53, 0xe6, 0x5d, 0xac, 0x71, 0x55, 0xdb, 0x35, 0x2e, 0xef, 0x52, 0x1a, 0x67, 0x71, 0xe6, - 0xf5, 0xf7, 0xc8, 0x38, 0x87, 0x3b, 0x1b, 0x91, 0x71, 0x96, 0x8a, 0xff, 0x09, 0x71, 0x16, 0xad, - 0xa1, 0xe8, 0x38, 0x4b, 0xfd, 0xac, 0xe8, 0x38, 0xcb, 0x5d, 0xa6, 0x44, 0x7e, 0x11, 0x13, 0x8e, - 0xe1, 0x17, 0x69, 0xce, 0x97, 0x52, 0x20, 0x13, 0x37, 0x4b, 0xaf, 0x29, 0xa1, 0xde, 0x2c, 0xe5, - 0x96, 0x47, 0xe9, 0x7c, 0x02, 0x2a, 0x71, 0x9d, 0x83, 0x1d, 0x00, 0xf5, 0x3a, 0x2b, 0xba, 0x1b, - 0xa5, 0x72, 0x32, 0x30, 0xde, 0x72, 0x0f, 0x8a, 0x81, 0x3a, 0x36, 0xba, 0x90, 0xae, 0xf4, 0x5e, - 0xba, 0x98, 0x88, 0x4b, 0x9c, 0x70, 0xb0, 0x4c, 0xad, 0x9e, 0xb0, 0xa2, 0x26, 0x5e, 0x2a, 0x27, - 0x03, 0x13, 0x2d, 0x07, 0x4b, 0xd2, 0x6a, 0xcb, 0x8a, 0xb2, 0x77, 0xa9, 0x9c, 0x0c, 0x4c, 0x93, - 0x55, 0xac, 0xa8, 0x15, 0x99, 0x55, 0xa1, 0xaa, 0x59, 0x64, 0x56, 0x49, 0x95, 0xb1, 0xa4, 0xac, - 0xe2, 0x36, 0x63, 0xb2, 0x2a, 0x6c, 0xb6, 0x9c, 0x0c, 0x4c, 0x95, 0x55, 0xbc, 0xd0, 0x19, 0x9d, - 0x55, 0xe1, 0xda, 0x6c, 0x74, 0x56, 0x49, 0x15, 0xd3, 0xc4, 0xac, 0x8a, 0x9b, 0xb0, 0xa2, 0x68, - 0x1a, 0x97, 0x55, 0xa9, 0x97, 0x3a, 0x58, 0xb3, 0x8c, 0xcb, 0xaa, 0x14, 0x96, 0x95, 0xe5, 0xcf, - 0x68, 0xcb, 0xc1, 0x52, 0x9c, 0xda, 0xb2, 0xa2, 0xee, 0xa7, 0xb6, 0xac, 0xaa, 0xea, 0x45, 0x59, - 0xfe, 0x79, 0x06, 0x16, 0xa4, 0x8a, 0x28, 0xba, 0x1c, 0xbd, 0x90, 0x7d, 0x0e, 0x7c, 0x3d, 0x15, - 0x36, 0xd9, 0x07, 0xa9, 0xde, 0xa9, 0xf6, 0x41, 0x5d, 0x62, 0x55, 0xfb, 0x10, 0x55, 0x40, 0x8d, - 0x4e, 0xf6, 0x40, 0xf5, 0x06, 0x45, 0x6d, 0xb9, 0x52, 0x95, 0xa8, 0x74, 0x31, 0x11, 0x17, 0x6f, - 0xf6, 0xa7, 0x30, 0x1f, 0xae, 0x67, 0xa1, 0x98, 0x8d, 0x4f, 0x36, 0x7e, 0x39, 0x0d, 0x34, 0x71, - 0x87, 0x0e, 0x55, 0x38, 0x50, 0x39, 0x6d, 0xb1, 0x46, 0xbd, 0x43, 0x2b, 0xcb, 0x25, 0x31, 0x93, - 0x0f, 0x97, 0x62, 0x51, 0xcc, 0xe9, 0x2e, 0xd5, 0xe4, 0xd5, 0x95, 0xdd, 0x18, 0xfb, 0xe1, 0x62, - 0x2b, 0x8a, 0x39, 0xe0, 0xa5, 0xb2, 0x1f, 0x51, 0xbb, 0x55, 0xdb, 0x5f, 0x3b, 0xf7, 0xfa, 0xcb, - 0x95, 0x89, 0x2f, 0xbe, 0x5c, 0x99, 0xf8, 0xd9, 0xd1, 0x4a, 0xe6, 0xf5, 0xd1, 0x4a, 0xe6, 0xf3, - 0xa3, 0x95, 0xcc, 0xbf, 0x8e, 0x56, 0x32, 0xbf, 0x79, 0xb3, 0x32, 0xf1, 0xf9, 0x9b, 0x95, 0x89, - 0x2f, 0xde, 0xac, 0x4c, 0xec, 0x4c, 0xd3, 0x4a, 0xe8, 0xd5, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, - 0x61, 0x29, 0x54, 0xa3, 0xb7, 0x38, 0x00, 0x00, + // 2778 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xdb, 0x6f, 0x1b, 0x59, + 0x19, 0x8f, 0x1d, 0x27, 0xb6, 0x3f, 0x27, 0x4e, 0x7a, 0x9a, 0xb6, 0x5e, 0xb7, 0x24, 0xd5, 0xf4, + 0x12, 0xb7, 0x14, 0x7b, 0xd7, 0x65, 0xd9, 0xd2, 0xdd, 0x02, 0x4d, 0xd3, 0x8b, 0x7b, 0x49, 0xab, + 0x49, 0x5a, 0xc1, 0x03, 0x8a, 0x1c, 0xfb, 0x24, 0x3b, 0xb5, 0x33, 0x63, 0x66, 0xc6, 0xdd, 0x46, + 0x08, 0xc4, 0xa5, 0x88, 0x27, 0x24, 0x5e, 0x90, 0x10, 0x0f, 0x48, 0x3c, 0x21, 0x81, 0x84, 0x10, + 0x4f, 0x3c, 0xf0, 0x07, 0x54, 0x3c, 0xed, 0xe3, 0x3e, 0x05, 0x36, 0x15, 0x12, 0x4f, 0xfc, 0x0b, + 0xac, 0xce, 0x6d, 0x6e, 0x3e, 0x73, 0xf1, 0x45, 0xea, 0x3e, 0x25, 0x3e, 0xf3, 0xfb, 0x2e, 0xe7, + 0xfb, 0xbe, 0xf9, 0x9d, 0x33, 0xdf, 0x39, 0x70, 0x65, 0x4f, 0xb3, 0x3f, 0xee, 0xef, 0x54, 0x5b, + 0xc6, 0x7e, 0xad, 0x6d, 0xb4, 0x3a, 0xd8, 0xac, 0x59, 0x9f, 0x34, 0xcd, 0xfd, 0x8e, 0x66, 0xd7, + 0x9a, 0x3d, 0xad, 0xd6, 0x32, 0x74, 0xdb, 0x34, 0xba, 0xd5, 0x9e, 0x69, 0xd8, 0x06, 0x42, 0x0c, + 0x52, 0x15, 0x90, 0xea, 0x8b, 0xf7, 0xca, 0x97, 0x63, 0x34, 0x58, 0x3d, 0xdc, 0xb2, 0x98, 0x7c, + 0x39, 0xce, 0x9a, 0xb1, 0xf3, 0x1c, 0xb7, 0x6c, 0x81, 0x8e, 0xd3, 0x6c, 0x1f, 0xf4, 0xb0, 0xc0, + 0x2e, 0xed, 0x19, 0x7b, 0x06, 0xfd, 0xb7, 0x46, 0xfe, 0xe3, 0xa3, 0xef, 0xec, 0x19, 0xc6, 0x5e, + 0x17, 0xd7, 0xe8, 0xaf, 0x9d, 0xfe, 0x6e, 0xad, 0xa9, 0x1f, 0xf0, 0x47, 0x1f, 0x44, 0x28, 0x77, + 0xe0, 0xbd, 0x6e, 0x7f, 0x4f, 0xd3, 0xf9, 0x1f, 0x26, 0xa8, 0xbc, 0x0f, 0xc5, 0xbb, 0xd8, 0xde, + 0x30, 0xda, 0x58, 0xc5, 0x3f, 0xe8, 0x63, 0xcb, 0x46, 0xe7, 0x20, 0xab, 0x1b, 0x6d, 0xbc, 0xad, + 0xb5, 0x4b, 0xa9, 0xb3, 0xa9, 0x4a, 0x7e, 0x0d, 0x8e, 0x0e, 0x57, 0x66, 0x09, 0xa2, 0xb1, 0xae, + 0xce, 0x92, 0x47, 0x8d, 0xb6, 0xf2, 0x6d, 0x58, 0x70, 0xc4, 0xac, 0x9e, 0xa1, 0x5b, 0x18, 0x5d, + 0x81, 0x0c, 0x79, 0x48, 0x85, 0x0a, 0xf5, 0x52, 0x75, 0x30, 0xb8, 0x55, 0x8a, 0xa7, 0x28, 0xe5, + 0xd5, 0x0c, 0x2c, 0x3e, 0xd4, 0x2c, 0xaa, 0xc2, 0x12, 0xa6, 0xef, 0x40, 0x76, 0x57, 0xeb, 0xda, + 0xd8, 0xb4, 0xb8, 0x96, 0x2b, 0x32, 0x2d, 0x41, 0xb1, 0xea, 0x1d, 0x26, 0xa3, 0x0a, 0xe1, 0xf2, + 0x1f, 0x33, 0x90, 0xe5, 0x83, 0x68, 0x09, 0x66, 0xf4, 0xe6, 0x3e, 0x26, 0x1a, 0xa7, 0x2b, 0x79, + 0x95, 0xfd, 0x40, 0x35, 0x28, 0x68, 0xed, 0xed, 0x9e, 0x89, 0x77, 0xb5, 0x97, 0xd8, 0x2a, 0xa5, + 0xc9, 0xb3, 0xb5, 0xe2, 0xd1, 0xe1, 0x0a, 0x34, 0xd6, 0x9f, 0xf0, 0x51, 0x15, 0xb4, 0xb6, 0xf8, + 0x1f, 0x3d, 0x81, 0xd9, 0x6e, 0x73, 0x07, 0x77, 0xad, 0xd2, 0xf4, 0xd9, 0xe9, 0x4a, 0xa1, 0x7e, + 0x6d, 0x18, 0xcf, 0xaa, 0x0f, 0xa9, 0xe8, 0x6d, 0xdd, 0x36, 0x0f, 0x54, 0xae, 0x07, 0x7d, 0x1f, + 0x0a, 0x34, 0xce, 0x5c, 0x6d, 0x96, 0xaa, 0xfd, 0x68, 0x28, 0xb5, 0x64, 0xd0, 0xab, 0x1a, 0x74, + 0x67, 0x00, 0x3d, 0x82, 0xc2, 0x3e, 0xde, 0xdf, 0xc1, 0xa6, 0xf5, 0xb1, 0xd6, 0xb3, 0x4a, 0x99, + 0xb3, 0xd3, 0x95, 0x62, 0x7d, 0x35, 0x2c, 0x2b, 0x9b, 0x3d, 0xdc, 0xaa, 0x3e, 0x72, 0xf0, 0x6b, + 0xe9, 0xc5, 0x29, 0xd5, 0x2b, 0x8f, 0xbe, 0x01, 0x33, 0xa6, 0xd1, 0xc5, 0x56, 0x69, 0x86, 0x2a, + 0x3a, 0x13, 0x9a, 0x5e, 0xa3, 0x8b, 0xa9, 0x34, 0x83, 0xa3, 0x73, 0x30, 0x4f, 0x22, 0xee, 0x86, + 0x7a, 0x96, 0xa6, 0x61, 0x8e, 0x0c, 0x8a, 0xe0, 0x96, 0xbf, 0x09, 0x05, 0xcf, 0x34, 0xd0, 0x22, + 0x4c, 0x77, 0xf0, 0x01, 0xab, 0x3e, 0x95, 0xfc, 0x4b, 0x92, 0xf8, 0xa2, 0xd9, 0xed, 0xe3, 0x52, + 0x9a, 0x8e, 0xb1, 0x1f, 0xd7, 0xd3, 0xd7, 0x52, 0xe5, 0x1b, 0xb0, 0x10, 0x88, 0xc2, 0x30, 0xe2, + 0xca, 0x2d, 0x38, 0xe6, 0x89, 0x2e, 0xaf, 0xe4, 0x2a, 0xcc, 0x90, 0x40, 0xb2, 0x92, 0x89, 0x2a, + 0x65, 0x06, 0x53, 0xfe, 0x94, 0x82, 0x63, 0x4f, 0x7b, 0xed, 0xa6, 0x8d, 0x87, 0x7d, 0x8f, 0xd0, + 0xb7, 0x60, 0x8e, 0x82, 0x5e, 0x60, 0xd3, 0xd2, 0x0c, 0x9d, 0x3a, 0x58, 0xa8, 0x9f, 0x96, 0x59, + 0x7c, 0xc6, 0x20, 0x2a, 0xad, 0x1a, 0xfe, 0x03, 0xbd, 0x0b, 0x19, 0xc2, 0x48, 0xa5, 0x69, 0x2a, + 0x77, 0x26, 0x2a, 0xbd, 0x2a, 0x45, 0x2a, 0x6b, 0x80, 0xbc, 0xbe, 0x8e, 0xf4, 0xf2, 0x6e, 0xc0, + 0x31, 0x15, 0xef, 0x1b, 0x2f, 0x86, 0x9f, 0xef, 0x12, 0xcc, 0xec, 0x1a, 0x66, 0x8b, 0x65, 0x22, + 0xa7, 0xb2, 0x1f, 0xca, 0x12, 0x20, 0xaf, 0x3e, 0xe6, 0x13, 0xa7, 0xa6, 0xad, 0xa6, 0xd5, 0xf1, + 0x98, 0xb0, 0x9b, 0x56, 0x27, 0x60, 0x82, 0x20, 0x88, 0x09, 0xf2, 0xc8, 0xa1, 0x26, 0x26, 0xe6, + 0xce, 0x8e, 0x3c, 0x8c, 0x9a, 0x1d, 0xc5, 0x53, 0x94, 0x72, 0x4d, 0xcc, 0x6e, 0x68, 0xd3, 0xce, + 0x3c, 0xbc, 0xd6, 0x95, 0x7f, 0x64, 0x18, 0xd5, 0x91, 0xc1, 0x11, 0xa8, 0xce, 0x2b, 0x36, 0x48, + 0x75, 0xff, 0x9a, 0x7e, 0x7b, 0x54, 0x27, 0xf3, 0x4c, 0x4a, 0x75, 0x35, 0x28, 0x58, 0xd8, 0x7c, + 0xa1, 0xb5, 0x48, 0x75, 0x30, 0x2e, 0xe2, 0x2e, 0x6c, 0xb2, 0xe1, 0xc6, 0xba, 0xa5, 0x02, 0x87, + 0x34, 0xda, 0x16, 0xba, 0x08, 0x39, 0x5e, 0x4b, 0x8c, 0x70, 0xf2, 0x6b, 0x85, 0xa3, 0xc3, 0x95, + 0x2c, 0x2b, 0x26, 0x4b, 0xcd, 0xb2, 0x6a, 0xb2, 0xd0, 0x3d, 0x28, 0xb6, 0xb1, 0xa5, 0x99, 0xb8, + 0xbd, 0x6d, 0xd9, 0x4d, 0x9b, 0xd3, 0x4b, 0xb1, 0xfe, 0x95, 0xb0, 0x14, 0x6f, 0x12, 0x14, 0xe5, + 0xa7, 0x79, 0x2e, 0x48, 0x47, 0x24, 0x3c, 0x95, 0x1d, 0xe4, 0x29, 0x54, 0x86, 0x9c, 0xd9, 0xd7, + 0x6d, 0x8d, 0xc4, 0x38, 0x4f, 0x9f, 0x3b, 0xbf, 0xd1, 0x19, 0x80, 0x7e, 0x6f, 0xdb, 0x36, 0xb6, + 0xc9, 0xbb, 0x55, 0xca, 0xd1, 0xf2, 0xce, 0xf5, 0x7b, 0x5b, 0xc6, 0x7a, 0xd3, 0xc6, 0x63, 0x30, + 0x9c, 0xa0, 0x28, 0x1e, 0x6c, 0x97, 0xa2, 0x48, 0xcd, 0x45, 0x52, 0x14, 0x2d, 0x42, 0x06, 0x53, + 0x1e, 0xc0, 0xd2, 0x2d, 0x13, 0x37, 0x6d, 0xcc, 0x03, 0x2e, 0xca, 0xf0, 0x2a, 0xe7, 0x0f, 0x56, + 0x83, 0x2b, 0x32, 0x35, 0x5c, 0xc2, 0x43, 0x21, 0x1b, 0x70, 0x22, 0xa0, 0x8c, 0x7b, 0xf5, 0x3e, + 0x64, 0x79, 0x12, 0xb9, 0xc2, 0xd3, 0x11, 0x0a, 0x55, 0x81, 0x55, 0x9e, 0xc3, 0xb1, 0xbb, 0xd8, + 0x0e, 0x78, 0x76, 0x05, 0xc0, 0xad, 0x19, 0xfe, 0xce, 0xcd, 0x1f, 0x1d, 0xae, 0xe4, 0x9d, 0x92, + 0x51, 0xf3, 0x4e, 0xc5, 0xa0, 0x55, 0x58, 0xd0, 0x74, 0x0b, 0x9b, 0xf6, 0x76, 0x1b, 0xef, 0x36, + 0xfb, 0x5d, 0xdb, 0xe2, 0x0c, 0x53, 0x64, 0xc3, 0xeb, 0x7c, 0x54, 0x79, 0x00, 0xc8, 0x6b, 0x6b, + 0x3c, 0xc7, 0xff, 0x96, 0x86, 0x25, 0x46, 0xa6, 0x63, 0x39, 0xbf, 0x0e, 0x0b, 0x02, 0x3d, 0xc4, + 0x3a, 0x50, 0xe4, 0x32, 0x62, 0x29, 0xb8, 0xea, 0x5b, 0x0a, 0x92, 0xa5, 0x12, 0x3d, 0x82, 0x9c, + 0x69, 0x74, 0xbb, 0x3b, 0xcd, 0x56, 0xa7, 0x94, 0x39, 0x9b, 0xaa, 0x14, 0xeb, 0xef, 0xc9, 0x04, + 0x65, 0x93, 0xac, 0xaa, 0x5c, 0x50, 0x75, 0x54, 0x28, 0x0a, 0xe4, 0xc4, 0x28, 0xca, 0x41, 0x66, + 0xe3, 0xf1, 0xc6, 0xed, 0xc5, 0x29, 0x34, 0x07, 0xb9, 0x27, 0xea, 0xed, 0x67, 0x8d, 0xc7, 0x4f, + 0x37, 0x17, 0x53, 0xa4, 0x7a, 0x02, 0xea, 0xc6, 0x4b, 0xc2, 0x3a, 0x2c, 0x31, 0xd2, 0x1d, 0x27, + 0x07, 0xca, 0x29, 0x38, 0x11, 0xd0, 0xc2, 0xd9, 0xfb, 0xd5, 0x34, 0x1c, 0x27, 0xef, 0x1f, 0x1f, + 0x77, 0x08, 0xbc, 0x11, 0x24, 0xf0, 0x5a, 0x18, 0x4d, 0x06, 0x24, 0x07, 0x39, 0xfc, 0x0f, 0xe9, + 0x89, 0x73, 0xf8, 0x66, 0x80, 0xc3, 0x3f, 0x1c, 0xd2, 0x39, 0x29, 0x8d, 0x0f, 0x70, 0x64, 0x26, + 0x86, 0x23, 0x67, 0xfc, 0x1c, 0x39, 0x0e, 0x0b, 0x3e, 0x86, 0x25, 0xbf, 0xbb, 0xbc, 0x68, 0x3e, + 0x80, 0x1c, 0x4f, 0xa2, 0xe0, 0xc2, 0xc8, 0xaa, 0x71, 0xc0, 0xca, 0x35, 0x28, 0x7b, 0x14, 0x92, + 0x55, 0xa0, 0x6f, 0xb9, 0xd9, 0x2d, 0x07, 0xd4, 0xe6, 0x3d, 0x92, 0x7f, 0x4e, 0xc3, 0x69, 0xa9, + 0x28, 0x77, 0xe9, 0x7b, 0x90, 0xb3, 0xf8, 0x18, 0x77, 0xe9, 0x46, 0x4c, 0xf4, 0x83, 0x2a, 0xaa, + 0xbe, 0x71, 0xd5, 0x51, 0x57, 0xfe, 0x6b, 0x0a, 0xe6, 0x7d, 0xcf, 0x86, 0x64, 0x9a, 0x73, 0x20, + 0x96, 0xbd, 0x6d, 0xb6, 0x7c, 0x90, 0x38, 0x67, 0xd4, 0x39, 0x3e, 0x48, 0xd7, 0x18, 0x02, 0x32, + 0xfb, 0xba, 0xae, 0xe9, 0x7b, 0x1c, 0x34, 0xcd, 0x40, 0x7c, 0x90, 0x81, 0x56, 0x61, 0xa1, 0x65, + 0xec, 0xf7, 0xba, 0xd8, 0x76, 0x74, 0x65, 0x28, 0xac, 0xe8, 0x0c, 0x6f, 0xf9, 0x57, 0x9e, 0x0d, + 0x6c, 0x7f, 0x62, 0x98, 0x9d, 0x21, 0x56, 0x1e, 0x2e, 0x21, 0x5b, 0x79, 0x1c, 0x65, 0x2e, 0x77, + 0xe8, 0x6c, 0x28, 0x8a, 0x3b, 0x84, 0x94, 0xc0, 0x2a, 0x4f, 0xe9, 0xca, 0x13, 0xf0, 0x0c, 0x41, + 0x86, 0x54, 0x34, 0xaf, 0x4b, 0xfa, 0x3f, 0x09, 0x33, 0x97, 0x21, 0x61, 0x4e, 0xbb, 0x61, 0xe6, + 0xb2, 0x24, 0xcc, 0x1c, 0xd0, 0x68, 0xf3, 0x45, 0x66, 0x42, 0x3e, 0x7e, 0x57, 0xf0, 0xdb, 0xc4, + 0xdd, 0x74, 0x38, 0x2f, 0xe0, 0xa9, 0xf2, 0xdf, 0x34, 0xe3, 0x3c, 0x3e, 0x3e, 0x02, 0xe7, 0x05, + 0x24, 0x07, 0x39, 0xef, 0x17, 0x6f, 0x91, 0xf3, 0x42, 0x9c, 0x1b, 0x99, 0xf3, 0x26, 0xc0, 0x6b, + 0xae, 0x4b, 0x2e, 0xaf, 0xf1, 0x44, 0x45, 0xf2, 0x9a, 0xc8, 0x9c, 0x03, 0x56, 0x6e, 0xd2, 0x92, + 0xbe, 0xd5, 0xed, 0x5b, 0x36, 0x36, 0x3d, 0x6b, 0x61, 0x8b, 0x8d, 0x04, 0x58, 0x82, 0xe3, 0x48, + 0x5d, 0x70, 0x80, 0x53, 0xbe, 0x8e, 0x0a, 0xb7, 0x7c, 0x39, 0x24, 0xaa, 0x7c, 0x85, 0x94, 0xc0, + 0x3a, 0xb5, 0xc4, 0x1f, 0x8c, 0x50, 0x4b, 0x01, 0xc9, 0x2f, 0x57, 0x2d, 0x85, 0x38, 0xf7, 0x36, + 0x6b, 0xc9, 0x75, 0xc9, 0xad, 0x25, 0x9e, 0x8d, 0xc8, 0x5a, 0x12, 0xa9, 0x73, 0xc0, 0xca, 0x6f, + 0x52, 0x50, 0x78, 0x80, 0x0f, 0x54, 0xc3, 0x6e, 0xda, 0x64, 0x8b, 0x79, 0x19, 0x8e, 0x91, 0x22, + 0xc3, 0xe6, 0xf6, 0x73, 0x43, 0xd3, 0xb7, 0x6d, 0xa3, 0x83, 0x75, 0xea, 0x5a, 0x4e, 0x5d, 0x60, + 0x0f, 0xee, 0x1b, 0x9a, 0xbe, 0x45, 0x86, 0xd1, 0x15, 0x40, 0xfb, 0x4d, 0xbd, 0xb9, 0xe7, 0x07, + 0xb3, 0x4d, 0xf9, 0x22, 0x7f, 0x22, 0x45, 0xf7, 0xf5, 0xae, 0xd1, 0xea, 0x6c, 0x93, 0x59, 0x4f, + 0xfb, 0xd0, 0x4f, 0xe9, 0x83, 0x07, 0xf8, 0x40, 0xf9, 0x99, 0xb3, 0xef, 0x1e, 0xa7, 0xce, 0xc9, + 0xbe, 0x5b, 0xa0, 0x87, 0xd9, 0x77, 0x73, 0x99, 0x21, 0xf6, 0xdd, 0xdc, 0xba, 0x67, 0xdf, 0x7d, + 0x93, 0xec, 0xbb, 0x59, 0x54, 0xe9, 0xba, 0x19, 0x22, 0xe8, 0x09, 0xfe, 0x5a, 0xe6, 0xf5, 0xe1, + 0xca, 0x94, 0xea, 0x88, 0xb9, 0xfb, 0xe8, 0x09, 0xbd, 0xa8, 0x37, 0x60, 0x91, 0x7e, 0x19, 0xb5, + 0x4c, 0x6c, 0x8b, 0x78, 0x5e, 0x82, 0xbc, 0x45, 0x07, 0xdc, 0x70, 0xce, 0x1d, 0x1d, 0xae, 0xe4, + 0x18, 0xaa, 0xb1, 0x4e, 0x76, 0x45, 0xf4, 0xbf, 0xb6, 0x72, 0x97, 0x7f, 0xc4, 0x31, 0x71, 0xee, + 0x4a, 0x1d, 0x66, 0x19, 0x80, 0x7b, 0x52, 0x96, 0xef, 0xcd, 0xa8, 0x0c, 0x47, 0x2a, 0x7f, 0x4f, + 0xc1, 0x71, 0xf1, 0x81, 0x30, 0x9a, 0x2f, 0x68, 0x0d, 0x8a, 0x1c, 0x3a, 0x44, 0x5e, 0xe7, 0x99, + 0x88, 0x48, 0x6b, 0xdd, 0x97, 0xd6, 0xe5, 0x70, 0xc7, 0x3d, 0xdb, 0x93, 0xfb, 0xee, 0xe7, 0xe0, + 0xd8, 0x61, 0xf8, 0x4f, 0x1a, 0x10, 0xdb, 0x22, 0x92, 0x9f, 0x0e, 0x6d, 0xde, 0x0b, 0xd2, 0x66, + 0x35, 0x7c, 0x6f, 0xe9, 0x15, 0x1c, 0x64, 0xcd, 0x57, 0x93, 0x67, 0x4d, 0x35, 0xc0, 0x9a, 0xd7, + 0x87, 0xf3, 0xed, 0xad, 0x90, 0xe6, 0x03, 0xf1, 0x79, 0xc7, 0x3d, 0xe2, 0x29, 0xfb, 0x3a, 0xf9, + 0x18, 0xa5, 0x43, 0x9c, 0x32, 0xa3, 0x72, 0x26, 0xa0, 0x4a, 0x03, 0x8e, 0x8b, 0xce, 0x88, 0xb7, + 0x74, 0xeb, 0xbe, 0xbd, 0x6e, 0xe2, 0x5a, 0xf2, 0xab, 0x1a, 0xa3, 0x96, 0xbe, 0x03, 0xc7, 0xc5, + 0xc7, 0xed, 0x88, 0x6f, 0xf7, 0x49, 0xf7, 0x23, 0xdb, 0xeb, 0x0d, 0x27, 0x8d, 0x5b, 0x86, 0xbe, + 0xab, 0xed, 0x79, 0xd4, 0xb6, 0xe8, 0x40, 0x40, 0x2d, 0x43, 0x11, 0xb5, 0xec, 0xb1, 0x43, 0x1a, + 0x42, 0xdc, 0x9d, 0x21, 0x03, 0x44, 0xcd, 0x90, 0xcb, 0x70, 0xa4, 0x87, 0x34, 0x46, 0xf5, 0x85, + 0x90, 0x06, 0x87, 0x0e, 0x43, 0x1a, 0x4c, 0x64, 0x08, 0xd2, 0x60, 0x96, 0x65, 0xa4, 0x31, 0x81, + 0x30, 0x08, 0xd2, 0x60, 0xc3, 0x23, 0x90, 0x86, 0x5f, 0xf0, 0xcb, 0x45, 0x1a, 0x72, 0xdf, 0xde, + 0x26, 0x69, 0x38, 0x1e, 0xb9, 0xa4, 0xc1, 0x12, 0x11, 0x49, 0x1a, 0x3c, 0x67, 0x02, 0xea, 0x92, + 0x86, 0xbf, 0x74, 0x13, 0x90, 0x86, 0xac, 0x96, 0xfc, 0xaa, 0xc6, 0xa8, 0x25, 0x87, 0x34, 0x46, + 0x7e, 0xbb, 0x1d, 0xd2, 0xf0, 0x7b, 0xa3, 0xfc, 0x08, 0x4e, 0x32, 0x2f, 0x6f, 0xbf, 0xb4, 0xb1, + 0x4e, 0xdf, 0x23, 0xae, 0xfc, 0x26, 0x14, 0x9a, 0xba, 0xce, 0x77, 0x38, 0x56, 0x54, 0x6f, 0xe0, + 0xa6, 0x0b, 0x53, 0xbd, 0x32, 0xe8, 0x2c, 0x14, 0xda, 0xd8, 0x6a, 0x99, 0x5a, 0xcf, 0x16, 0xef, + 0x70, 0x5e, 0xf5, 0x0e, 0x29, 0xcf, 0xe0, 0xd4, 0x80, 0x79, 0x1e, 0xa7, 0x0f, 0x21, 0x8f, 0xc5, + 0x20, 0xb7, 0x2e, 0x3d, 0x4a, 0x70, 0x25, 0x5d, 0xbc, 0xf2, 0x10, 0x4e, 0xb2, 0xe9, 0x0e, 0x4c, + 0xab, 0x0e, 0x73, 0x0e, 0xcc, 0x0d, 0xdb, 0xc2, 0xd1, 0xe1, 0x4a, 0xc1, 0xc1, 0x36, 0xd6, 0xd5, + 0x82, 0x03, 0x6a, 0xb4, 0x95, 0x77, 0xe0, 0xd4, 0x80, 0x36, 0x1e, 0xbf, 0x06, 0x1c, 0xbf, 0x8b, + 0xed, 0x89, 0x58, 0xd9, 0x84, 0x25, 0xbf, 0xaa, 0x49, 0x04, 0xe2, 0xf7, 0x29, 0xd1, 0xa6, 0x51, + 0xb1, 0x65, 0xf4, 0x4d, 0xb7, 0x27, 0x3b, 0x81, 0xfc, 0x22, 0xc8, 0x74, 0x34, 0x9d, 0x37, 0x37, + 0x54, 0xfa, 0x3f, 0xaa, 0x42, 0xb6, 0xd7, 0x3c, 0xe8, 0x1a, 0xcd, 0x36, 0x67, 0xde, 0xa5, 0x2a, + 0xbb, 0x2a, 0x51, 0x15, 0x77, 0x1f, 0xaa, 0x37, 0xf5, 0x03, 0x55, 0x80, 0x14, 0x55, 0x14, 0xa0, + 0xeb, 0x1f, 0x9f, 0xf7, 0x35, 0xc8, 0x99, 0x7c, 0x8c, 0x7b, 0x27, 0x3d, 0x53, 0x75, 0xe4, 0x1c, + 0xb4, 0x72, 0x4f, 0x34, 0x53, 0x82, 0x73, 0xae, 0x41, 0x41, 0x80, 0xdc, 0xac, 0x50, 0x42, 0x14, + 0xc8, 0xc6, 0xba, 0x0a, 0x02, 0xd2, 0x68, 0x2b, 0x25, 0x51, 0x47, 0x41, 0xef, 0x94, 0x9f, 0xa7, + 0xc5, 0x9e, 0x7f, 0x5c, 0x23, 0xe8, 0x0e, 0x2c, 0x3a, 0x02, 0x43, 0xac, 0x77, 0x0b, 0x42, 0x48, + 0xac, 0x78, 0x81, 0x8c, 0x4e, 0x8f, 0x90, 0x51, 0x4f, 0xf6, 0x32, 0x09, 0xb3, 0x17, 0x0c, 0xc2, + 0xd8, 0xd9, 0xbb, 0x4d, 0x5b, 0x1e, 0x63, 0xa7, 0xee, 0x31, 0x7d, 0x33, 0x27, 0xe8, 0xd7, 0xff, + 0xd3, 0xec, 0x9b, 0x5e, 0x3c, 0x72, 0x96, 0xf4, 0xfb, 0xc1, 0x25, 0xfd, 0xdd, 0xb0, 0x65, 0x33, + 0x28, 0x3a, 0xb8, 0xa8, 0xff, 0x6e, 0xf2, 0x8b, 0xfa, 0x56, 0x60, 0x51, 0xff, 0x68, 0x58, 0xef, + 0x46, 0x3f, 0x80, 0x10, 0x04, 0x31, 0xe3, 0x12, 0xc4, 0x38, 0x4b, 0xfd, 0x26, 0x9c, 0x08, 0xf8, + 0xc9, 0x93, 0x7a, 0x1d, 0xf2, 0x22, 0x4d, 0x62, 0xb9, 0x8f, 0xce, 0xaa, 0x0b, 0xaf, 0xff, 0xf2, + 0x3c, 0x64, 0x6f, 0xb1, 0xbb, 0x68, 0x48, 0x83, 0x2c, 0xbf, 0x4a, 0x85, 0x14, 0x99, 0xbc, 0xff, + 0x7a, 0x56, 0xf9, 0x5c, 0x24, 0x86, 0x13, 0xc5, 0x89, 0x7f, 0xfe, 0xe5, 0x7f, 0xbf, 0x4d, 0x2f, + 0xc0, 0x3c, 0x05, 0x7d, 0x8d, 0x37, 0x50, 0x90, 0x01, 0x79, 0xe7, 0xb6, 0x0b, 0x3a, 0x9f, 0xe4, + 0xaa, 0x51, 0xf9, 0x42, 0x0c, 0x2a, 0xda, 0xa0, 0x09, 0xe0, 0x5e, 0x36, 0x41, 0x17, 0xc2, 0x8f, + 0x16, 0xbd, 0x33, 0xbc, 0x18, 0x07, 0x8b, 0xb5, 0xe9, 0x5e, 0x26, 0x91, 0xdb, 0x1c, 0xb8, 0xbc, + 0x22, 0xb7, 0x29, 0xb9, 0x93, 0x12, 0x62, 0x93, 0xe5, 0x70, 0xab, 0x69, 0x75, 0x42, 0x73, 0xe8, + 0xb9, 0x4c, 0x12, 0x9a, 0x43, 0xdf, 0xb5, 0x91, 0xe8, 0x1c, 0xb2, 0x53, 0x98, 0xf3, 0x49, 0xae, + 0x66, 0x84, 0xe7, 0xd0, 0x77, 0xa7, 0x20, 0x36, 0x9e, 0x74, 0x7a, 0x11, 0xf1, 0xf4, 0xce, 0xf0, + 0x62, 0x1c, 0x2c, 0xd6, 0xa6, 0x7b, 0x4a, 0x2f, 0xb7, 0x39, 0x70, 0x63, 0x40, 0x6e, 0x73, 0xf0, + 0xb0, 0x3f, 0xcc, 0xe6, 0x4b, 0x98, 0xf3, 0x9e, 0x30, 0xa2, 0xd5, 0x84, 0x47, 0xa6, 0xe5, 0x4a, + 0x3c, 0x30, 0xda, 0xf2, 0x0f, 0x61, 0xde, 0x77, 0x9f, 0x02, 0x49, 0x35, 0xca, 0xee, 0x6f, 0x94, + 0x2f, 0x25, 0x40, 0xc6, 0x1a, 0xf7, 0x1d, 0xc7, 0xcb, 0x8d, 0xcb, 0x2e, 0x00, 0xc8, 0x8d, 0x4b, + 0xcf, 0xf6, 0x23, 0x8c, 0xfb, 0x4e, 0xdd, 0xe5, 0xc6, 0x65, 0xc7, 0xfb, 0x72, 0xe3, 0xf2, 0x23, + 0xfc, 0x10, 0xe3, 0xbf, 0x4a, 0xf9, 0x4e, 0xf6, 0xc5, 0x21, 0x2c, 0xaa, 0x26, 0x3e, 0xad, 0x65, + 0x9e, 0xd4, 0x86, 0x3c, 0xdd, 0x8d, 0x2e, 0x7a, 0x7e, 0xa2, 0x13, 0x5a, 0xf4, 0xfe, 0x53, 0xc0, + 0xd0, 0xa2, 0x0f, 0x1e, 0xe9, 0x45, 0x17, 0xbd, 0x38, 0x7e, 0x0a, 0x2f, 0xfa, 0xc0, 0x99, 0x59, + 0x78, 0xd1, 0x07, 0x4f, 0xb2, 0x62, 0x8b, 0x5e, 0x4c, 0x38, 0xa2, 0xe8, 0x03, 0x73, 0xbe, 0x94, + 0x00, 0x99, 0xb0, 0xee, 0x22, 0x8d, 0xcb, 0x8e, 0x5d, 0xa3, 0xea, 0x2e, 0xa1, 0x71, 0x96, 0x67, + 0xde, 0x7f, 0x0f, 0xcd, 0xb3, 0xff, 0x64, 0x23, 0x34, 0xcf, 0x81, 0xe6, 0x7f, 0x4c, 0x9e, 0xc5, + 0xd1, 0x50, 0x78, 0x9e, 0x03, 0xe7, 0x59, 0xe1, 0x79, 0x0e, 0x9e, 0x32, 0xc5, 0xf2, 0x8b, 0x98, + 0x70, 0x04, 0xbf, 0x04, 0xe6, 0x7c, 0x29, 0x01, 0x32, 0x76, 0xb1, 0x74, 0x0e, 0x25, 0xe4, 0x8b, + 0x65, 0xf0, 0xc8, 0xa3, 0x7c, 0x21, 0x06, 0x15, 0x1b, 0x67, 0xef, 0x09, 0x80, 0x3c, 0xce, 0x92, + 0xd3, 0x8d, 0x72, 0x25, 0x1e, 0x18, 0x6d, 0xb9, 0x0f, 0x05, 0x4f, 0x1f, 0x1b, 0x5d, 0x4c, 0xd6, + 0x7a, 0x2f, 0xaf, 0xc6, 0xe2, 0x62, 0x27, 0xec, 0x6d, 0x53, 0xcb, 0x27, 0x2c, 0xe9, 0x89, 0x97, + 0x2b, 0xf1, 0xc0, 0x58, 0xcb, 0xde, 0x96, 0xb4, 0xdc, 0xb2, 0xa4, 0xed, 0x5d, 0xae, 0xc4, 0x03, + 0x93, 0x54, 0x15, 0x6b, 0x6a, 0x85, 0x56, 0x95, 0xaf, 0x6b, 0x16, 0x5a, 0x55, 0x81, 0xce, 0x58, + 0x5c, 0x55, 0x71, 0x9b, 0x11, 0x55, 0xe5, 0x37, 0x5b, 0x89, 0x07, 0x26, 0xaa, 0x2a, 0xde, 0xe8, + 0x0c, 0xaf, 0x2a, 0x7f, 0x6f, 0x36, 0xbc, 0xaa, 0x02, 0x1d, 0xd3, 0xd8, 0xaa, 0x8a, 0x9a, 0xb0, + 0xa4, 0x69, 0x1a, 0x55, 0x55, 0x89, 0x43, 0xed, 0xed, 0x59, 0x46, 0x55, 0x55, 0x02, 0xcb, 0xd2, + 0xf6, 0x67, 0xb8, 0x65, 0x6f, 0x2b, 0x4e, 0x6e, 0x59, 0xd2, 0xf7, 0x93, 0x5b, 0x96, 0x75, 0xf5, + 0xc2, 0x2c, 0xff, 0x34, 0x05, 0x0b, 0x81, 0x8e, 0x28, 0xba, 0x1c, 0x1e, 0xc8, 0x01, 0x07, 0xbe, + 0x9a, 0x08, 0x1b, 0xef, 0x43, 0xa0, 0xdf, 0x29, 0xf7, 0x41, 0xde, 0x62, 0x95, 0xfb, 0x10, 0xd6, + 0x40, 0x0d, 0x2f, 0x76, 0x4f, 0xf7, 0x06, 0x85, 0x2d, 0xb9, 0x81, 0x2e, 0x51, 0x79, 0x35, 0x16, + 0x17, 0x6d, 0xf6, 0xc7, 0x50, 0xf4, 0xf7, 0xb3, 0x50, 0xc4, 0xc2, 0x17, 0x34, 0x7e, 0x39, 0x09, + 0x34, 0x76, 0x85, 0xf6, 0x75, 0x38, 0x50, 0x25, 0x69, 0xb3, 0x46, 0xbe, 0x42, 0x4b, 0xdb, 0x25, + 0x11, 0x93, 0xf7, 0xb7, 0x62, 0x51, 0xc4, 0xee, 0x2e, 0xd1, 0xe4, 0xe5, 0x9d, 0xdd, 0x08, 0xfb, + 0xfe, 0x66, 0x2b, 0x8a, 0xd8, 0xe0, 0x25, 0xb2, 0x1f, 0xd2, 0xbb, 0x95, 0xdb, 0x5f, 0x3b, 0xff, + 0xfa, 0xf3, 0xe5, 0xa9, 0xcf, 0x3e, 0x5f, 0x9e, 0xfa, 0xc9, 0xd1, 0x72, 0xea, 0xf5, 0xd1, 0x72, + 0xea, 0xd3, 0xa3, 0xe5, 0xd4, 0xbf, 0x8f, 0x96, 0x53, 0xbf, 0x7e, 0xb3, 0x3c, 0xf5, 0xe9, 0x9b, + 0xe5, 0xa9, 0xcf, 0xde, 0x2c, 0x4f, 0xed, 0xcc, 0xd2, 0x4e, 0xe8, 0xd5, 0x2f, 0x02, 0x00, 0x00, + 0xff, 0xff, 0xf1, 0x75, 0x17, 0x2e, 0xe0, 0x38, 0x00, 0x00, } type authenticatedWrapperControlServer struct { @@ -8269,6 +8276,11 @@ func (m *ListServiceStatusesResponse_ServiceStatus) MarshalTo(dAtA []byte) (int, i++ i = encodeVarintControl(dAtA, i, uint64(m.RunningTasks)) } + if m.CompletedTasks != 0 { + dAtA[i] = 0x20 + i++ + i = encodeVarintControl(dAtA, i, uint64(m.CompletedTasks)) + } return i, nil } @@ -12102,6 +12114,9 @@ func (m *ListServiceStatusesResponse_ServiceStatus) Size() (n int) { if m.RunningTasks != 0 { n += 1 + sovControl(uint64(m.RunningTasks)) } + if m.CompletedTasks != 0 { + n += 1 + sovControl(uint64(m.CompletedTasks)) + } return n } @@ -13373,6 +13388,7 @@ func (this *ListServiceStatusesResponse_ServiceStatus) String() string { `ServiceID:` + fmt.Sprintf("%v", this.ServiceID) + `,`, `DesiredTasks:` + fmt.Sprintf("%v", this.DesiredTasks) + `,`, `RunningTasks:` + fmt.Sprintf("%v", this.RunningTasks) + `,`, + `CompletedTasks:` + fmt.Sprintf("%v", this.CompletedTasks) + `,`, `}`, }, "") return s @@ -17797,6 +17813,25 @@ func (m *ListServiceStatusesResponse_ServiceStatus) Unmarshal(dAtA []byte) error break } } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CompletedTasks", wireType) + } + m.CompletedTasks = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowControl + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CompletedTasks |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipControl(dAtA[iNdEx:]) diff --git a/vendor/github.com/docker/swarmkit/api/control.proto b/vendor/github.com/docker/swarmkit/api/control.proto index bda699cc6d..c90b78d9b8 100644 --- a/vendor/github.com/docker/swarmkit/api/control.proto +++ b/vendor/github.com/docker/swarmkit/api/control.proto @@ -433,6 +433,13 @@ message ListServiceStatusesResponse { // request time. This may be larger than desired tasks if, for example, a // service has been scaled down. uint64 running_tasks = 3; + + // CompletedTasks is the number of tasks in state Completed, if this + // service is in mode ReplicatedJob or GlobalJob. This must be + // cross-referenced with the service type, because the default value of 0 + // may mean that a service is not in a Job mode, or it may mean the Job has + // yet to complete any Tasks. + uint64 completed_tasks = 4; } repeated ServiceStatus statuses = 1; diff --git a/vendor/github.com/docker/swarmkit/api/objects.pb.go b/vendor/github.com/docker/swarmkit/api/objects.pb.go index 4fbfe10958..41099f206a 100644 --- a/vendor/github.com/docker/swarmkit/api/objects.pb.go +++ b/vendor/github.com/docker/swarmkit/api/objects.pb.go @@ -164,6 +164,9 @@ type Service struct { // UpdateStatus contains the status of an update, if one is in // progress. UpdateStatus *UpdateStatus `protobuf:"bytes,5,opt,name=update_status,json=updateStatus,proto3" json:"update_status,omitempty"` + // JobStatus contains the status of a Service that is in one of the Job + // modes. It is absent on Replicated and Global services. + JobStatus *JobStatus `protobuf:"bytes,12,opt,name=job_status,json=jobStatus,proto3" json:"job_status,omitempty"` // PendingDelete indicates that this service's deletion has been requested. // Services, as well as all service-level resources, can only be deleted // after all of the service's containers have properly shut down. @@ -359,6 +362,9 @@ type Task struct { // If not present, the daemon's default will be used. LogDriver *Driver `protobuf:"bytes,13,opt,name=log_driver,json=logDriver,proto3" json:"log_driver,omitempty"` AssignedGenericResources []*GenericResource `protobuf:"bytes,15,rep,name=assigned_generic_resources,json=assignedGenericResources,proto3" json:"assigned_generic_resources,omitempty"` + // JobIteration is the iteration number of the Job-mode Service that this + // task belongs to. + JobIteration *Version `protobuf:"bytes,16,opt,name=job_iteration,json=jobIteration,proto3" json:"job_iteration,omitempty"` } func (m *Task) Reset() { *m = Task{} } @@ -767,111 +773,114 @@ func init() { } var fileDescriptor_6218a23329ef342d = []byte{ - // 1654 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x73, 0x23, 0x47, - 0x15, 0xf7, 0xc8, 0xb3, 0xfa, 0x78, 0xfa, 0x60, 0xe9, 0x18, 0x33, 0x2b, 0x8c, 0x64, 0x14, 0x42, - 0x6d, 0xa5, 0xb6, 0xe4, 0xb0, 0x04, 0xf0, 0x1a, 0x42, 0x22, 0x59, 0x66, 0xa3, 0x4a, 0x36, 0xeb, - 0x6a, 0x27, 0x9b, 0xdc, 0x86, 0xd6, 0x4c, 0x5b, 0x3b, 0x68, 0x34, 0x3d, 0x35, 0xdd, 0x52, 0x10, - 0x27, 0xce, 0xcb, 0x85, 0xdb, 0xde, 0x38, 0x00, 0xff, 0x04, 0x17, 0x0e, 0x1c, 0xa8, 0xe5, 0x96, - 0x13, 0x95, 0x93, 0x8b, 0xd5, 0xfe, 0x15, 0xdc, 0xa8, 0xee, 0xe9, 0x91, 0xc6, 0xd6, 0xf8, 0x8b, - 0xda, 0x72, 0x71, 0x52, 0x7f, 0xfc, 0x7e, 0xaf, 0xdf, 0x7b, 0xdd, 0xef, 0x63, 0x04, 0xf7, 0x86, - 0x9e, 0x78, 0x3a, 0x19, 0xb4, 0x1d, 0x36, 0xde, 0x71, 0x99, 0x33, 0xa2, 0xd1, 0x0e, 0xff, 0x92, - 0x44, 0xe3, 0x91, 0x27, 0x76, 0x48, 0xe8, 0xed, 0xb0, 0xc1, 0xaf, 0xa9, 0x23, 0x78, 0x3b, 0x8c, - 0x98, 0x60, 0x08, 0xc5, 0x90, 0x76, 0x02, 0x69, 0x4f, 0x7f, 0x58, 0x7f, 0xfb, 0x12, 0x09, 0x62, - 0x16, 0x52, 0xcd, 0xbf, 0x14, 0xcb, 0x43, 0xea, 0x24, 0xd8, 0xe6, 0x90, 0xb1, 0xa1, 0x4f, 0x77, - 0xd4, 0x6c, 0x30, 0x39, 0xde, 0x11, 0xde, 0x98, 0x72, 0x41, 0xc6, 0xa1, 0x06, 0x6c, 0x0c, 0xd9, - 0x90, 0xa9, 0xe1, 0x8e, 0x1c, 0xe9, 0xd5, 0x3b, 0x67, 0x69, 0x24, 0x98, 0xe9, 0xad, 0x9f, 0x5e, - 0x70, 0xfa, 0x02, 0x1e, 0xfa, 0x93, 0xa1, 0x17, 0xe8, 0x9f, 0x98, 0xd8, 0xfa, 0xab, 0x01, 0xe6, - 0x23, 0x2a, 0x08, 0xfa, 0x19, 0x14, 0xa6, 0x34, 0xe2, 0x1e, 0x0b, 0x2c, 0x63, 0xdb, 0xb8, 0x5b, - 0xbe, 0xff, 0x9d, 0xf6, 0xaa, 0x47, 0xda, 0x4f, 0x62, 0x48, 0xd7, 0x7c, 0x71, 0xd2, 0x5c, 0xc3, - 0x09, 0x03, 0x3d, 0x00, 0x70, 0x22, 0x4a, 0x04, 0x75, 0x6d, 0x22, 0xac, 0x9c, 0xe2, 0xd7, 0xdb, - 0xb1, 0xba, 0xed, 0xe4, 0xfc, 0xf6, 0xa7, 0x89, 0x95, 0xb8, 0xa4, 0xd1, 0x1d, 0x21, 0xa9, 0x93, - 0xd0, 0x4d, 0xa8, 0xeb, 0x97, 0x53, 0x35, 0xba, 0x23, 0x5a, 0x7f, 0xb9, 0x05, 0xe6, 0x27, 0xcc, - 0xa5, 0x68, 0x13, 0x72, 0x9e, 0xab, 0xd4, 0x2e, 0x75, 0xf3, 0xf3, 0x93, 0x66, 0xae, 0xdf, 0xc3, - 0x39, 0xcf, 0x45, 0xf7, 0xc1, 0x1c, 0x53, 0x41, 0xb4, 0x42, 0x56, 0x96, 0x41, 0xd2, 0x76, 0x6d, - 0x8d, 0xc2, 0xa2, 0x9f, 0x80, 0x29, 0xaf, 0x4a, 0x6b, 0xb2, 0x95, 0xc5, 0x91, 0x67, 0x1e, 0x85, - 0xd4, 0x49, 0x78, 0x12, 0x8f, 0x0e, 0xa0, 0xec, 0x52, 0xee, 0x44, 0x5e, 0x28, 0xa4, 0x0f, 0x4d, - 0x45, 0x7f, 0xf3, 0x3c, 0x7a, 0x6f, 0x09, 0xc5, 0x69, 0x1e, 0xfa, 0x39, 0xe4, 0xb9, 0x20, 0x62, - 0xc2, 0xad, 0x5b, 0x4a, 0x42, 0xe3, 0x5c, 0x05, 0x14, 0x4a, 0xab, 0xa0, 0x39, 0xe8, 0x43, 0xa8, - 0x8d, 0x49, 0x40, 0x86, 0x34, 0xb2, 0xb5, 0x94, 0xbc, 0x92, 0xf2, 0xbd, 0x4c, 0xd3, 0x63, 0x64, - 0x2c, 0x08, 0x57, 0xc7, 0xe9, 0x29, 0xea, 0x03, 0x10, 0x21, 0x88, 0xf3, 0x74, 0x4c, 0x03, 0x61, - 0x15, 0x94, 0x94, 0xb7, 0x32, 0x75, 0xa1, 0xe2, 0x4b, 0x16, 0x8d, 0x3a, 0x0b, 0x70, 0x37, 0x67, - 0x19, 0x38, 0x45, 0x46, 0x0f, 0xa1, 0xec, 0xd0, 0x48, 0x78, 0xc7, 0x9e, 0x43, 0x04, 0xb5, 0x8a, - 0x4a, 0x56, 0x33, 0x4b, 0xd6, 0xfe, 0x12, 0xa6, 0x0d, 0x4b, 0x33, 0xd1, 0x3b, 0x60, 0x46, 0xcc, - 0xa7, 0x56, 0x69, 0xdb, 0xb8, 0x5b, 0x3b, 0xff, 0x6a, 0x30, 0xf3, 0x29, 0x56, 0x48, 0x79, 0xf4, - 0x52, 0x11, 0x6e, 0xc1, 0xf6, 0xfa, 0x95, 0xcd, 0xc0, 0x69, 0x26, 0x6a, 0x41, 0xe5, 0xc9, 0x17, - 0x1f, 0x77, 0x3e, 0xf9, 0xac, 0x77, 0x78, 0xc8, 0x22, 0x61, 0x95, 0xb7, 0x8d, 0xbb, 0x55, 0x7c, - 0x6a, 0x6d, 0x6f, 0xf3, 0xd9, 0xf3, 0x16, 0x82, 0xdb, 0x45, 0xe3, 0xb6, 0xa1, 0xde, 0xa2, 0xf1, - 0x8e, 0xf1, 0x85, 0xf1, 0x2b, 0xa3, 0xf5, 0x67, 0x13, 0x0a, 0x47, 0x34, 0x9a, 0x7a, 0xce, 0xeb, - 0x7d, 0xa9, 0x0f, 0x4e, 0xbd, 0xd4, 0x4c, 0x87, 0xea, 0x63, 0x57, 0x1e, 0xeb, 0x2f, 0xa0, 0x22, - 0x7f, 0xed, 0x24, 0xe2, 0xe1, 0xd2, 0x88, 0xc7, 0x65, 0x49, 0xd0, 0x13, 0xd4, 0x83, 0x6a, 0x18, - 0xd1, 0xa9, 0xc7, 0x26, 0xdc, 0x56, 0x3a, 0xe4, 0xaf, 0xa4, 0x03, 0xae, 0x24, 0x2c, 0x39, 0x43, - 0x8f, 0xe1, 0x5b, 0xa7, 0xa4, 0x2c, 0xd4, 0x29, 0x5f, 0xae, 0xce, 0x1b, 0x69, 0x49, 0x89, 0x5a, - 0xbb, 0x50, 0xa4, 0x81, 0x1b, 0x32, 0x2f, 0x10, 0x3a, 0x00, 0x33, 0x1f, 0xc9, 0x81, 0xc6, 0xe0, - 0x05, 0x1a, 0x1d, 0x40, 0x35, 0xce, 0x2b, 0xf6, 0xa9, 0xe8, 0xdb, 0xce, 0xa2, 0x7f, 0xa6, 0x80, - 0x3a, 0x6c, 0x2a, 0x93, 0xd4, 0x0c, 0xbd, 0x05, 0xb5, 0x90, 0x06, 0xae, 0x17, 0x0c, 0x6d, 0x97, - 0xfa, 0x54, 0x50, 0x15, 0x39, 0x45, 0x5c, 0xd5, 0xab, 0x3d, 0xb5, 0xb8, 0x87, 0x9e, 0x3d, 0x6f, - 0xd5, 0xa0, 0x92, 0x7e, 0x29, 0xad, 0x3f, 0xe6, 0xa0, 0x98, 0x28, 0x86, 0xde, 0xd5, 0x57, 0x6b, - 0x9c, 0xaf, 0x45, 0x82, 0x55, 0x7e, 0x8d, 0x6f, 0xf5, 0x5d, 0xb8, 0x15, 0xb2, 0x48, 0x70, 0x2b, - 0xa7, 0xde, 0x79, 0x66, 0xea, 0x90, 0x2f, 0x75, 0x9f, 0x05, 0xc7, 0xde, 0x10, 0xc7, 0x60, 0xf4, - 0x39, 0x94, 0xa7, 0x5e, 0x24, 0x26, 0xc4, 0xb7, 0xbd, 0x90, 0x5b, 0xeb, 0x8a, 0xfb, 0x83, 0x8b, - 0x8e, 0x6c, 0x3f, 0x89, 0xf1, 0xfd, 0xc3, 0x6e, 0x6d, 0x7e, 0xd2, 0x84, 0xc5, 0x94, 0x63, 0xd0, - 0xa2, 0xfa, 0x21, 0xaf, 0x3f, 0x82, 0xd2, 0x62, 0x07, 0xdd, 0x03, 0x08, 0xe2, 0x10, 0xb3, 0x17, - 0x01, 0x50, 0x9d, 0x9f, 0x34, 0x4b, 0x3a, 0xf0, 0xfa, 0x3d, 0x5c, 0xd2, 0x80, 0xbe, 0x8b, 0x10, - 0x98, 0xc4, 0x75, 0x23, 0x15, 0x0e, 0x25, 0xac, 0xc6, 0xad, 0xdf, 0x17, 0xc0, 0xfc, 0x94, 0xf0, - 0xd1, 0x4d, 0x67, 0x7b, 0x79, 0xe6, 0xa5, 0x01, 0x54, 0xbb, 0x66, 0x00, 0xdd, 0x03, 0xe0, 0x71, - 0x5c, 0x48, 0x77, 0x98, 0x4b, 0x77, 0xe8, 0x68, 0x91, 0xee, 0xd0, 0x80, 0xd8, 0x1d, 0xdc, 0x67, - 0x42, 0x3d, 0x4a, 0x13, 0xab, 0x31, 0x7a, 0x13, 0x0a, 0x01, 0x73, 0x15, 0x3d, 0xaf, 0xe8, 0x30, - 0x3f, 0x69, 0xe6, 0x65, 0xfe, 0xeb, 0xf7, 0x70, 0x5e, 0x6e, 0xf5, 0x5d, 0x95, 0xff, 0x82, 0x80, - 0x09, 0x22, 0x6b, 0x0b, 0xd7, 0x69, 0x3c, 0x33, 0x4a, 0x3b, 0x4b, 0x58, 0x92, 0x7a, 0x53, 0x4c, - 0xf4, 0x04, 0xde, 0x48, 0xf4, 0x4d, 0x0b, 0x2c, 0x5e, 0x47, 0x20, 0xd2, 0x12, 0x52, 0x3b, 0xa9, - 0x72, 0x57, 0x3a, 0xbf, 0xdc, 0xa9, 0x1b, 0xc8, 0x2a, 0x77, 0x5d, 0xa8, 0xba, 0x94, 0x7b, 0x11, - 0x75, 0x55, 0xd8, 0x52, 0x95, 0xc7, 0x6a, 0xf7, 0xbf, 0x7b, 0x91, 0x10, 0x8a, 0x2b, 0x9a, 0xa3, - 0x66, 0xa8, 0x03, 0x45, 0xfd, 0xee, 0xb8, 0x55, 0xbe, 0x4e, 0x7d, 0x58, 0xd0, 0x4e, 0xa5, 0x9d, - 0xca, 0xb5, 0xd2, 0xce, 0x03, 0x00, 0x9f, 0x0d, 0x6d, 0x37, 0xf2, 0xa6, 0x34, 0xb2, 0xaa, 0xba, - 0xf9, 0xc9, 0xe0, 0xf6, 0x14, 0x02, 0x97, 0x7c, 0x36, 0x8c, 0x87, 0x88, 0x40, 0x9d, 0x70, 0xee, - 0x0d, 0x03, 0xea, 0xda, 0x43, 0x1a, 0xd0, 0xc8, 0x73, 0xec, 0x88, 0x72, 0x36, 0x89, 0x1c, 0xca, - 0xad, 0x6f, 0x28, 0x4b, 0x32, 0xdb, 0x8f, 0x87, 0x31, 0x18, 0x6b, 0x2c, 0xb6, 0x12, 0x31, 0x67, - 0x36, 0xf8, 0x5e, 0xfd, 0xd9, 0xf3, 0xd6, 0x26, 0x6c, 0xa4, 0xd3, 0xd4, 0xae, 0xf1, 0x81, 0xf1, - 0xa1, 0x71, 0x68, 0xb4, 0xfe, 0x9e, 0x83, 0x6f, 0xae, 0xf8, 0x04, 0xfd, 0x18, 0x0a, 0xda, 0x2b, - 0x17, 0x35, 0x91, 0x9a, 0x87, 0x13, 0x2c, 0xda, 0x82, 0x92, 0x0c, 0x71, 0xca, 0x39, 0x8d, 0x93, - 0x57, 0x09, 0x2f, 0x17, 0x90, 0x05, 0x05, 0xe2, 0x7b, 0x44, 0xee, 0xad, 0xab, 0xbd, 0x64, 0x8a, - 0x26, 0xb0, 0x19, 0xbb, 0xce, 0x5e, 0xd6, 0x6a, 0x9b, 0x85, 0x82, 0x5b, 0xa6, 0xb2, 0xff, 0xfd, - 0x2b, 0xdd, 0xa4, 0x76, 0xee, 0x72, 0xe1, 0x71, 0x28, 0xf8, 0x41, 0x20, 0xa2, 0x19, 0xde, 0x70, - 0x33, 0xb6, 0xea, 0x0f, 0xe1, 0xce, 0xb9, 0x14, 0x74, 0x1b, 0xd6, 0x47, 0x74, 0x16, 0xa7, 0x27, - 0x2c, 0x87, 0x68, 0x03, 0x6e, 0x4d, 0x89, 0x3f, 0xa1, 0x3a, 0x9b, 0xc5, 0x93, 0xbd, 0xdc, 0xae, - 0xd1, 0xfa, 0x67, 0x0e, 0x0a, 0x5a, 0x9d, 0x9b, 0xee, 0x0c, 0xf4, 0xb1, 0x2b, 0x89, 0xed, 0x3d, - 0xa8, 0x68, 0x97, 0xc6, 0x11, 0x65, 0x5e, 0xfa, 0x26, 0xcb, 0x31, 0x3e, 0x8e, 0xa6, 0xf7, 0xc0, - 0xf4, 0x42, 0x32, 0xd6, 0xe5, 0x33, 0xf3, 0xe4, 0xfe, 0x61, 0xe7, 0xd1, 0xe3, 0x30, 0x4e, 0x0c, - 0xc5, 0xf9, 0x49, 0xd3, 0x94, 0x0b, 0x58, 0xd1, 0x32, 0xea, 0x67, 0xfe, 0xaa, 0xf5, 0xf3, 0x1f, - 0x79, 0x28, 0xec, 0xfb, 0x13, 0x2e, 0x68, 0x74, 0xd3, 0xbe, 0xd4, 0xc7, 0xae, 0xf8, 0x72, 0x1f, - 0x0a, 0x11, 0x63, 0xc2, 0x76, 0xc8, 0x45, 0x6e, 0xc4, 0x8c, 0x89, 0xfd, 0x4e, 0xb7, 0x26, 0x89, - 0x32, 0x85, 0xc7, 0x73, 0x9c, 0x97, 0xd4, 0x7d, 0x82, 0x3e, 0x87, 0xcd, 0xa4, 0x70, 0x0e, 0x18, - 0x13, 0x5c, 0x44, 0x24, 0xb4, 0x47, 0x74, 0x26, 0x5b, 0x94, 0xf5, 0xf3, 0x5a, 0xfb, 0x83, 0xc0, - 0x89, 0x66, 0xca, 0xc7, 0x1f, 0xd1, 0x19, 0xde, 0xd0, 0x02, 0xba, 0x09, 0xff, 0x23, 0x3a, 0xe3, - 0xe8, 0x7d, 0xd8, 0xa2, 0x0b, 0x98, 0x94, 0x68, 0xfb, 0x64, 0x2c, 0x5b, 0x02, 0xdb, 0xf1, 0x99, - 0x33, 0x52, 0x9e, 0x37, 0xf1, 0x1d, 0x9a, 0x16, 0xf5, 0x71, 0x8c, 0xd8, 0x97, 0x00, 0xc4, 0xc1, - 0x1a, 0xf8, 0xc4, 0x19, 0xf9, 0x1e, 0x97, 0x5f, 0x6f, 0xa9, 0x4e, 0x5d, 0x16, 0x06, 0xa9, 0xdb, - 0xee, 0x05, 0xde, 0x6a, 0x77, 0x97, 0xdc, 0x54, 0xdf, 0xaf, 0x03, 0xef, 0xdb, 0x83, 0xec, 0x5d, - 0xd4, 0x85, 0xf2, 0x24, 0x90, 0xc7, 0xc7, 0x3e, 0x28, 0x5d, 0xd5, 0x07, 0x10, 0xb3, 0x94, 0xe5, - 0x5b, 0x60, 0x1e, 0xcb, 0x56, 0x47, 0x56, 0x8b, 0x62, 0xfc, 0x06, 0x7f, 0xd9, 0x3f, 0x3c, 0xc2, - 0x6a, 0x15, 0xb5, 0x01, 0xb9, 0xf4, 0x98, 0x4c, 0x7c, 0xd1, 0x89, 0x53, 0xd0, 0x21, 0x63, 0xbe, - 0x2a, 0x0d, 0x25, 0x9c, 0xb1, 0x83, 0x1a, 0x00, 0x7c, 0x32, 0x08, 0xa8, 0x38, 0xf2, 0x7e, 0x4b, - 0x55, 0xfe, 0xaf, 0xe2, 0xd4, 0xca, 0xca, 0xa7, 0x43, 0x75, 0xf5, 0xd3, 0xa1, 0x3e, 0x85, 0xad, - 0x8b, 0xdc, 0x91, 0x91, 0x54, 0x3e, 0x48, 0x27, 0x95, 0xf2, 0xfd, 0xb7, 0xb3, 0x3c, 0x90, 0x2d, - 0x32, 0x95, 0x80, 0x32, 0x03, 0xe9, 0x6f, 0x06, 0xe4, 0x8f, 0xa8, 0x13, 0x51, 0xf1, 0x5a, 0xe3, - 0x68, 0xf7, 0x54, 0x1c, 0x35, 0xb2, 0xbf, 0x14, 0xe4, 0xa9, 0x2b, 0x61, 0x54, 0x87, 0xa2, 0x17, - 0x08, 0x1a, 0x05, 0xc4, 0x57, 0x71, 0x54, 0xc4, 0x8b, 0x79, 0xa6, 0x01, 0x7f, 0x32, 0x20, 0x1f, - 0xb7, 0xb8, 0x37, 0x6d, 0x40, 0x7c, 0xea, 0x59, 0x03, 0x32, 0x95, 0xfc, 0x8f, 0x01, 0xc5, 0xa4, - 0xd2, 0xbe, 0x56, 0x35, 0xcf, 0xb4, 0x7c, 0xeb, 0xff, 0x73, 0xcb, 0x87, 0xc0, 0x1c, 0x79, 0x81, - 0x6e, 0x4e, 0xb1, 0x1a, 0xa3, 0x36, 0x14, 0x42, 0x32, 0xf3, 0x19, 0x71, 0x75, 0x86, 0xdf, 0x58, - 0xf9, 0xa7, 0xa6, 0x13, 0xcc, 0x70, 0x02, 0xda, 0xdb, 0x78, 0xf6, 0xbc, 0x75, 0x1b, 0x6a, 0x69, - 0xcb, 0x9f, 0x1a, 0xad, 0x7f, 0x19, 0x50, 0x3a, 0xf8, 0x8d, 0xa0, 0x81, 0x6a, 0x85, 0xff, 0x2f, - 0x8d, 0xdf, 0x5e, 0xfd, 0x37, 0xa7, 0x74, 0xea, 0x8f, 0x9a, 0xac, 0x4b, 0xed, 0x7e, 0xff, 0xc5, - 0xcb, 0xc6, 0xda, 0xd7, 0x2f, 0x1b, 0x6b, 0xbf, 0x9b, 0x37, 0x8c, 0x17, 0xf3, 0x86, 0xf1, 0xd5, - 0xbc, 0x61, 0xfc, 0x7b, 0xde, 0x30, 0xfe, 0xf0, 0xaa, 0xb1, 0xf6, 0xd5, 0xab, 0xc6, 0xda, 0xd7, - 0xaf, 0x1a, 0x6b, 0x83, 0xbc, 0xf2, 0xd5, 0x8f, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x53, 0x14, - 0x4d, 0x41, 0xa0, 0x14, 0x00, 0x00, + // 1700 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x73, 0x1b, 0x49, + 0x15, 0xf7, 0xc8, 0x13, 0x49, 0xf3, 0xf4, 0x81, 0xe9, 0x35, 0x66, 0x62, 0x8c, 0x6c, 0xb4, 0x2c, + 0x95, 0xda, 0x4a, 0xc9, 0x4b, 0x58, 0xc0, 0x31, 0xbb, 0x6c, 0x24, 0xdb, 0x64, 0xc5, 0x6e, 0x36, + 0xae, 0xf6, 0x6e, 0x76, 0x6f, 0x43, 0x6b, 0xa6, 0xad, 0x4c, 0x34, 0x9a, 0x9e, 0x9a, 0x6e, 0x69, + 0x11, 0x27, 0xce, 0x39, 0x71, 0xcb, 0x8d, 0x03, 0xc5, 0x3f, 0xc1, 0x85, 0x03, 0x07, 0x2a, 0x1c, + 0xa8, 0xda, 0x13, 0x95, 0x93, 0x8b, 0x28, 0x7f, 0x05, 0x37, 0xaa, 0x7b, 0x7a, 0xa4, 0x71, 0x34, + 0xb6, 0x1c, 0x2a, 0x95, 0xe2, 0xa4, 0xfe, 0xf8, 0xfd, 0x5e, 0xbf, 0xf7, 0xe6, 0x7d, 0x74, 0x0b, + 0x6e, 0xf6, 0x7d, 0xf1, 0x70, 0xd4, 0x6b, 0xb9, 0x6c, 0xb8, 0xeb, 0x31, 0x77, 0x40, 0xe3, 0x5d, + 0xfe, 0x35, 0x89, 0x87, 0x03, 0x5f, 0xec, 0x92, 0xc8, 0xdf, 0x65, 0xbd, 0x47, 0xd4, 0x15, 0xbc, + 0x15, 0xc5, 0x4c, 0x30, 0x84, 0x12, 0x48, 0x2b, 0x85, 0xb4, 0xc6, 0x3f, 0xde, 0x7c, 0x77, 0x89, + 0x04, 0x31, 0x89, 0xa8, 0xe6, 0x2f, 0xc5, 0xf2, 0x88, 0xba, 0x29, 0x76, 0xbb, 0xcf, 0x58, 0x3f, + 0xa0, 0xbb, 0x6a, 0xd6, 0x1b, 0x9d, 0xee, 0x0a, 0x7f, 0x48, 0xb9, 0x20, 0xc3, 0x48, 0x03, 0xd6, + 0xfb, 0xac, 0xcf, 0xd4, 0x70, 0x57, 0x8e, 0xf4, 0xea, 0xf5, 0x97, 0x69, 0x24, 0x9c, 0xe8, 0xad, + 0x9f, 0x5f, 0x72, 0xfa, 0x0c, 0x1e, 0x05, 0xa3, 0xbe, 0x1f, 0xea, 0x9f, 0x84, 0xd8, 0xfc, 0x8b, + 0x01, 0xe6, 0x3d, 0x2a, 0x08, 0xfa, 0x05, 0x94, 0xc6, 0x34, 0xe6, 0x3e, 0x0b, 0x6d, 0x63, 0xc7, + 0xb8, 0x51, 0xb9, 0xf5, 0xbd, 0xd6, 0xa2, 0x47, 0x5a, 0x0f, 0x12, 0x48, 0xc7, 0x7c, 0x7a, 0xb6, + 0xbd, 0x82, 0x53, 0x06, 0xba, 0x0d, 0xe0, 0xc6, 0x94, 0x08, 0xea, 0x39, 0x44, 0xd8, 0x05, 0xc5, + 0xdf, 0x6c, 0x25, 0xea, 0xb6, 0xd2, 0xf3, 0x5b, 0x9f, 0xa7, 0x56, 0x62, 0x4b, 0xa3, 0xdb, 0x42, + 0x52, 0x47, 0x91, 0x97, 0x52, 0x57, 0x97, 0x53, 0x35, 0xba, 0x2d, 0x9a, 0x7f, 0xbe, 0x06, 0xe6, + 0x67, 0xcc, 0xa3, 0x68, 0x03, 0x0a, 0xbe, 0xa7, 0xd4, 0xb6, 0x3a, 0xc5, 0xe9, 0xd9, 0x76, 0xa1, + 0x7b, 0x88, 0x0b, 0xbe, 0x87, 0x6e, 0x81, 0x39, 0xa4, 0x82, 0x68, 0x85, 0xec, 0x3c, 0x83, 0xa4, + 0xed, 0xda, 0x1a, 0x85, 0x45, 0x3f, 0x03, 0x53, 0x7e, 0x2a, 0xad, 0xc9, 0x56, 0x1e, 0x47, 0x9e, + 0x79, 0x12, 0x51, 0x37, 0xe5, 0x49, 0x3c, 0x3a, 0x82, 0x8a, 0x47, 0xb9, 0x1b, 0xfb, 0x91, 0x90, + 0x3e, 0x34, 0x15, 0xfd, 0xed, 0x8b, 0xe8, 0x87, 0x73, 0x28, 0xce, 0xf2, 0xd0, 0x07, 0x50, 0xe4, + 0x82, 0x88, 0x11, 0xb7, 0xaf, 0x29, 0x09, 0x8d, 0x0b, 0x15, 0x50, 0x28, 0xad, 0x82, 0xe6, 0xa0, + 0x8f, 0xa1, 0x3e, 0x24, 0x21, 0xe9, 0xd3, 0xd8, 0xd1, 0x52, 0x8a, 0x4a, 0xca, 0x0f, 0x72, 0x4d, + 0x4f, 0x90, 0x89, 0x20, 0x5c, 0x1b, 0x66, 0xa7, 0xa8, 0x0b, 0x40, 0x84, 0x20, 0xee, 0xc3, 0x21, + 0x0d, 0x85, 0x5d, 0x52, 0x52, 0xde, 0xc9, 0xd5, 0x85, 0x8a, 0xaf, 0x59, 0x3c, 0x68, 0xcf, 0xc0, + 0x9d, 0x82, 0x6d, 0xe0, 0x0c, 0x19, 0xdd, 0x85, 0x8a, 0x4b, 0x63, 0xe1, 0x9f, 0xfa, 0x2e, 0x11, + 0xd4, 0x2e, 0x2b, 0x59, 0xdb, 0x79, 0xb2, 0x0e, 0xe6, 0x30, 0x6d, 0x58, 0x96, 0x89, 0xde, 0x03, + 0x33, 0x66, 0x01, 0xb5, 0xad, 0x1d, 0xe3, 0x46, 0xfd, 0xe2, 0x4f, 0x83, 0x59, 0x40, 0xb1, 0x42, + 0xca, 0xa3, 0xe7, 0x8a, 0x70, 0x1b, 0x76, 0x56, 0xaf, 0x6c, 0x06, 0xce, 0x32, 0x51, 0x13, 0xaa, + 0x0f, 0xbe, 0xfa, 0xb4, 0xfd, 0xd9, 0x17, 0x87, 0xc7, 0xc7, 0x2c, 0x16, 0x76, 0x65, 0xc7, 0xb8, + 0x51, 0xc3, 0xe7, 0xd6, 0xf6, 0x37, 0x1e, 0x3f, 0x69, 0x22, 0x58, 0x2b, 0x1b, 0x6b, 0x86, 0x8a, + 0x45, 0xe3, 0x3d, 0xe3, 0x2b, 0xe3, 0x37, 0x46, 0xf3, 0xb9, 0x09, 0xa5, 0x13, 0x1a, 0x8f, 0x7d, + 0xf7, 0xf5, 0x46, 0xea, 0xed, 0x73, 0x91, 0x9a, 0xeb, 0x50, 0x7d, 0xec, 0x42, 0xb0, 0xfe, 0x12, + 0xaa, 0xf2, 0xd7, 0x49, 0x33, 0x1e, 0x96, 0x66, 0x3c, 0xae, 0x48, 0x82, 0x9e, 0xa0, 0x43, 0xa8, + 0x45, 0x31, 0x1d, 0xfb, 0x6c, 0xc4, 0x1d, 0xa5, 0x43, 0xf1, 0x4a, 0x3a, 0xe0, 0x6a, 0xca, 0x92, + 0x33, 0x74, 0x1f, 0xbe, 0x73, 0x4e, 0xca, 0x4c, 0x9d, 0xca, 0x72, 0x75, 0xde, 0xca, 0x4a, 0x4a, + 0xd5, 0xda, 0x83, 0x32, 0x0d, 0xbd, 0x88, 0xf9, 0xa1, 0xd0, 0x09, 0x98, 0x1b, 0x24, 0x47, 0x1a, + 0x83, 0x67, 0x68, 0x74, 0x04, 0xb5, 0xa4, 0xae, 0x38, 0xe7, 0xb2, 0x6f, 0x27, 0x8f, 0xfe, 0x85, + 0x02, 0xea, 0xb4, 0xa9, 0x8e, 0x32, 0x33, 0xf4, 0x01, 0xc0, 0x23, 0xd6, 0x4b, 0x65, 0x54, 0x95, + 0x8c, 0xef, 0xe7, 0xc9, 0xf8, 0x35, 0xeb, 0x69, 0x01, 0xd6, 0xa3, 0x74, 0x88, 0xde, 0x81, 0x7a, + 0x44, 0x43, 0xcf, 0x0f, 0xfb, 0x8e, 0x47, 0x03, 0x2a, 0xa8, 0xca, 0xbb, 0x32, 0xae, 0xe9, 0xd5, + 0x43, 0xb5, 0xb8, 0x8f, 0x1e, 0x3f, 0x69, 0xd6, 0xa1, 0x9a, 0x8d, 0xb3, 0xe6, 0x1f, 0x0b, 0x50, + 0x4e, 0xcd, 0x42, 0xef, 0xeb, 0xc0, 0x30, 0x2e, 0xb6, 0x21, 0xc5, 0xaa, 0xaf, 0x92, 0xc4, 0xc4, + 0xfb, 0x70, 0x2d, 0x62, 0xb1, 0xe0, 0x76, 0x41, 0x65, 0x49, 0x6e, 0xe1, 0x91, 0x71, 0x7e, 0xc0, + 0xc2, 0x53, 0xbf, 0x8f, 0x13, 0x30, 0xfa, 0x12, 0x2a, 0x63, 0x3f, 0x16, 0x23, 0x12, 0x38, 0x7e, + 0xc4, 0xed, 0x55, 0xc5, 0xfd, 0xd1, 0x65, 0x47, 0xb6, 0x1e, 0x24, 0xf8, 0xee, 0x71, 0xa7, 0x3e, + 0x3d, 0xdb, 0x86, 0xd9, 0x94, 0x63, 0xd0, 0xa2, 0xba, 0x11, 0xdf, 0xbc, 0x07, 0xd6, 0x6c, 0x07, + 0xdd, 0x04, 0x08, 0x93, 0x04, 0x75, 0x66, 0xe9, 0x53, 0x9b, 0x9e, 0x6d, 0x5b, 0x3a, 0x6d, 0xbb, + 0x87, 0xd8, 0xd2, 0x80, 0xae, 0x87, 0x10, 0x98, 0xc4, 0xf3, 0x62, 0x95, 0x4c, 0x16, 0x56, 0xe3, + 0xe6, 0x3f, 0x4b, 0x60, 0x7e, 0x4e, 0xf8, 0xe0, 0x4d, 0xf7, 0x0a, 0x79, 0xe6, 0xd2, 0xf4, 0xab, + 0xbf, 0x62, 0xfa, 0xdd, 0x04, 0xe0, 0x49, 0x56, 0x49, 0x77, 0x98, 0x73, 0x77, 0xe8, 0x5c, 0x93, + 0xee, 0xd0, 0x80, 0xc4, 0x1d, 0x3c, 0x60, 0x42, 0x85, 0xb4, 0x89, 0xd5, 0x18, 0xbd, 0x0d, 0xa5, + 0x90, 0x79, 0x8a, 0x5e, 0x54, 0x74, 0x98, 0x9e, 0x6d, 0x17, 0x65, 0xf5, 0xec, 0x1e, 0xe2, 0xa2, + 0xdc, 0xea, 0x7a, 0xaa, 0x7a, 0x86, 0x21, 0x13, 0x44, 0x76, 0x26, 0xae, 0x9b, 0x40, 0x6e, 0x8e, + 0xb7, 0xe7, 0xb0, 0xb4, 0x70, 0x67, 0x98, 0xe8, 0x01, 0xbc, 0x95, 0xea, 0x9b, 0x15, 0x58, 0x7e, + 0x15, 0x81, 0x48, 0x4b, 0xc8, 0xec, 0x64, 0x9a, 0xa5, 0x75, 0x71, 0xb3, 0x54, 0x5f, 0x20, 0xaf, + 0x59, 0x76, 0xa0, 0xe6, 0x51, 0xee, 0xc7, 0xd4, 0x53, 0x09, 0x4b, 0x55, 0x15, 0xac, 0xe7, 0xe7, + 0x6b, 0x2a, 0x84, 0xe2, 0xaa, 0xe6, 0xa8, 0x19, 0x6a, 0x43, 0x59, 0xc7, 0x1d, 0xb7, 0x2b, 0xaf, + 0xd2, 0x5d, 0x66, 0xb4, 0x73, 0x45, 0xab, 0xfa, 0x4a, 0x45, 0xeb, 0x36, 0x40, 0xc0, 0xfa, 0x8e, + 0x17, 0xfb, 0x63, 0x1a, 0xdb, 0x35, 0x7d, 0x75, 0xca, 0xe1, 0x1e, 0x2a, 0x04, 0xb6, 0x02, 0xd6, + 0x4f, 0x86, 0x88, 0xc0, 0x26, 0xe1, 0xdc, 0xef, 0x87, 0xd4, 0x73, 0xfa, 0x34, 0xa4, 0xb1, 0xef, + 0x3a, 0x31, 0xe5, 0x6c, 0x14, 0xbb, 0x94, 0xdb, 0xdf, 0x52, 0x96, 0xe4, 0x5e, 0x5e, 0xee, 0x26, + 0x60, 0xac, 0xb1, 0xd8, 0x4e, 0xc5, 0xbc, 0xb4, 0xc1, 0xd1, 0x1d, 0xa8, 0xc9, 0x5a, 0xe8, 0x0b, + 0x1a, 0xab, 0xcf, 0x65, 0xaf, 0x2d, 0x8f, 0xf2, 0xea, 0x23, 0xd6, 0xeb, 0xa6, 0x84, 0xfd, 0xcd, + 0xc7, 0x4f, 0x9a, 0x1b, 0xb0, 0x9e, 0x2d, 0x74, 0x7b, 0xc6, 0x1d, 0xe3, 0x63, 0xe3, 0xd8, 0x68, + 0xfe, 0xad, 0x00, 0xdf, 0x5e, 0xf0, 0x2a, 0xfa, 0x29, 0x94, 0xb4, 0x5f, 0x2f, 0xbb, 0xc4, 0x6a, + 0x1e, 0x4e, 0xb1, 0x68, 0x0b, 0x2c, 0x59, 0x24, 0x28, 0xe7, 0x34, 0x29, 0x7f, 0x16, 0x9e, 0x2f, + 0x20, 0x1b, 0x4a, 0x24, 0xf0, 0x89, 0xdc, 0x5b, 0x55, 0x7b, 0xe9, 0x14, 0x8d, 0x60, 0x23, 0x71, + 0xbe, 0x33, 0xbf, 0x2b, 0x38, 0x2c, 0x12, 0xdc, 0x36, 0x95, 0x07, 0x3f, 0xba, 0x52, 0x2c, 0xe8, + 0xcf, 0x33, 0x5f, 0xb8, 0x1f, 0x09, 0x7e, 0x14, 0x8a, 0x78, 0x82, 0xd7, 0xbd, 0x9c, 0xad, 0xcd, + 0xbb, 0x70, 0xfd, 0x42, 0x0a, 0x5a, 0x83, 0xd5, 0x01, 0x9d, 0x24, 0x05, 0x0e, 0xcb, 0x21, 0x5a, + 0x87, 0x6b, 0x63, 0x12, 0x8c, 0xa8, 0xae, 0x87, 0xc9, 0x64, 0xbf, 0xb0, 0x67, 0x34, 0xff, 0x51, + 0x80, 0x92, 0x56, 0xe7, 0x4d, 0xdf, 0x4c, 0xf4, 0xb1, 0x0b, 0xa5, 0xf1, 0x43, 0xa8, 0x6a, 0x97, + 0x26, 0x39, 0x69, 0x2e, 0x8d, 0xea, 0x4a, 0x82, 0x4f, 0xf2, 0xf1, 0x43, 0x30, 0xfd, 0x88, 0x0c, + 0x75, 0xfb, 0xce, 0x3d, 0xb9, 0x7b, 0xdc, 0xbe, 0x77, 0x3f, 0x4a, 0x4a, 0x4b, 0x79, 0x7a, 0xb6, + 0x6d, 0xca, 0x05, 0xac, 0x68, 0x39, 0x1d, 0xb8, 0x78, 0xd5, 0x0e, 0xfc, 0xf7, 0x22, 0x94, 0x0e, + 0x82, 0x11, 0x17, 0x34, 0x7e, 0xd3, 0xbe, 0xd4, 0xc7, 0x2e, 0xf8, 0xf2, 0x00, 0x4a, 0x31, 0x63, + 0xc2, 0x71, 0xc9, 0x65, 0x6e, 0xc4, 0x8c, 0x89, 0x83, 0x76, 0xa7, 0x2e, 0x89, 0xb2, 0x09, 0x24, + 0x73, 0x5c, 0x94, 0xd4, 0x03, 0x82, 0xbe, 0x84, 0x8d, 0xb4, 0xf5, 0xf6, 0x18, 0x13, 0x5c, 0xc4, + 0x24, 0x72, 0x06, 0x74, 0x22, 0xaf, 0x48, 0xab, 0x17, 0x3d, 0x2d, 0x8e, 0x42, 0x37, 0x9e, 0x28, + 0x1f, 0x7f, 0x42, 0x27, 0x78, 0x5d, 0x0b, 0xe8, 0xa4, 0xfc, 0x4f, 0xe8, 0x84, 0xa3, 0x8f, 0x60, + 0x8b, 0xce, 0x60, 0x52, 0xa2, 0x13, 0x90, 0xa1, 0xbc, 0x54, 0x38, 0x6e, 0xc0, 0xdc, 0x81, 0xf2, + 0xbc, 0x89, 0xaf, 0xd3, 0xac, 0xa8, 0x4f, 0x13, 0xc4, 0x81, 0x04, 0x20, 0x0e, 0x76, 0x2f, 0x20, + 0xee, 0x20, 0xf0, 0xb9, 0x7c, 0x3d, 0x66, 0x5e, 0x0a, 0xb2, 0xb5, 0x48, 0xdd, 0xf6, 0x2e, 0xf1, + 0x56, 0xab, 0x33, 0xe7, 0x66, 0xde, 0x1d, 0x3a, 0xf1, 0xbe, 0xdb, 0xcb, 0xdf, 0x45, 0x1d, 0xa8, + 0x8c, 0x42, 0x79, 0x7c, 0xe2, 0x03, 0xeb, 0xaa, 0x3e, 0x80, 0x84, 0xa5, 0x2c, 0xdf, 0x02, 0xf3, + 0x54, 0x5e, 0x96, 0x64, 0xbf, 0x29, 0x27, 0x31, 0xf8, 0xab, 0xee, 0xf1, 0x09, 0x56, 0xab, 0xa8, + 0x05, 0xc8, 0xa3, 0xa7, 0x64, 0x14, 0x88, 0x76, 0x52, 0x82, 0x8e, 0x19, 0x0b, 0x54, 0x73, 0xb1, + 0x70, 0xce, 0x0e, 0x6a, 0x00, 0xf0, 0x51, 0x2f, 0xa4, 0xe2, 0xc4, 0xff, 0x1d, 0x55, 0x1d, 0xa4, + 0x86, 0x33, 0x2b, 0x0b, 0x4f, 0x97, 0xda, 0xe2, 0xd3, 0x65, 0x73, 0x0c, 0x5b, 0x97, 0xb9, 0x23, + 0xa7, 0xa8, 0xdc, 0xc9, 0x16, 0x95, 0xca, 0xad, 0x77, 0xf3, 0x3c, 0x90, 0x2f, 0x32, 0x53, 0x80, + 0x72, 0x13, 0xe9, 0xaf, 0x06, 0x14, 0x4f, 0xa8, 0x1b, 0x53, 0xf1, 0x5a, 0xf3, 0x68, 0xef, 0x5c, + 0x1e, 0x35, 0xf2, 0x5f, 0x2a, 0xf2, 0xd4, 0x85, 0x34, 0xda, 0x84, 0xb2, 0x1f, 0x0a, 0x1a, 0x87, + 0x24, 0x50, 0x79, 0x54, 0xc6, 0xb3, 0x79, 0xae, 0x01, 0x7f, 0x32, 0xa0, 0x98, 0x5c, 0x92, 0xdf, + 0xb4, 0x01, 0xc9, 0xa9, 0x2f, 0x1b, 0x90, 0xab, 0xe4, 0x7f, 0x0c, 0x28, 0xa7, 0xbd, 0xfa, 0xb5, + 0xaa, 0xf9, 0xd2, 0xa5, 0x71, 0xf5, 0x7f, 0xbe, 0x34, 0x22, 0x30, 0x07, 0x7e, 0xa8, 0xaf, 0xb7, + 0x58, 0x8d, 0x51, 0x0b, 0x4a, 0x11, 0x99, 0x04, 0x8c, 0x78, 0xba, 0xc2, 0xaf, 0x2f, 0xfc, 0x53, + 0xd4, 0x0e, 0x27, 0x38, 0x05, 0xed, 0xaf, 0x3f, 0x7e, 0xd2, 0x5c, 0x83, 0x7a, 0xd6, 0xf2, 0x87, + 0x46, 0xf3, 0x5f, 0x06, 0x58, 0x47, 0xbf, 0x15, 0x34, 0x54, 0x97, 0xe9, 0xff, 0x4b, 0xe3, 0x77, + 0x16, 0xff, 0x4d, 0xb2, 0xce, 0xfd, 0x51, 0x94, 0xf7, 0x51, 0x3b, 0x3f, 0x7c, 0xfa, 0xbc, 0xb1, + 0xf2, 0xec, 0x79, 0x63, 0xe5, 0xf7, 0xd3, 0x86, 0xf1, 0x74, 0xda, 0x30, 0xbe, 0x99, 0x36, 0x8c, + 0x7f, 0x4f, 0x1b, 0xc6, 0x1f, 0x5e, 0x34, 0x56, 0xbe, 0x79, 0xd1, 0x58, 0x79, 0xf6, 0xa2, 0xb1, + 0xd2, 0x2b, 0x2a, 0x5f, 0xfd, 0xe4, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9e, 0xda, 0xee, 0xd3, + 0x20, 0x15, 0x00, 0x00, } func (m *Meta) Copy() *Meta { @@ -972,6 +981,10 @@ func (m *Service) CopyFrom(src interface{}) { m.UpdateStatus = &UpdateStatus{} github_com_docker_swarmkit_api_deepcopy.Copy(m.UpdateStatus, o.UpdateStatus) } + if o.JobStatus != nil { + m.JobStatus = &JobStatus{} + github_com_docker_swarmkit_api_deepcopy.Copy(m.JobStatus, o.JobStatus) + } } func (m *Endpoint) Copy() *Endpoint { @@ -1070,6 +1083,10 @@ func (m *Task) CopyFrom(src interface{}) { } } + if o.JobIteration != nil { + m.JobIteration = &Version{} + github_com_docker_swarmkit_api_deepcopy.Copy(m.JobIteration, o.JobIteration) + } } func (m *NetworkAttachment) Copy() *NetworkAttachment { @@ -1503,6 +1520,16 @@ func (m *Service) MarshalTo(dAtA []byte) (int, error) { } i += n17 } + if m.JobStatus != nil { + dAtA[i] = 0x62 + i++ + i = encodeVarintObjects(dAtA, i, uint64(m.JobStatus.Size())) + n18, err := m.JobStatus.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n18 + } return i, nil } @@ -1525,11 +1552,11 @@ func (m *Endpoint) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size())) - n18, err := m.Spec.MarshalTo(dAtA[i:]) + n19, err := m.Spec.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n18 + i += n19 } if len(m.Ports) > 0 { for _, msg := range m.Ports { @@ -1612,19 +1639,19 @@ func (m *Task) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size())) - n19, err := m.Meta.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n19 - dAtA[i] = 0x1a - i++ - i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size())) - n20, err := m.Spec.MarshalTo(dAtA[i:]) + n20, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n20 + dAtA[i] = 0x1a + i++ + i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size())) + n21, err := m.Spec.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n21 if len(m.ServiceID) > 0 { dAtA[i] = 0x22 i++ @@ -1645,27 +1672,27 @@ func (m *Task) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x3a i++ i = encodeVarintObjects(dAtA, i, uint64(m.Annotations.Size())) - n21, err := m.Annotations.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n21 - dAtA[i] = 0x42 - i++ - i = encodeVarintObjects(dAtA, i, uint64(m.ServiceAnnotations.Size())) - n22, err := m.ServiceAnnotations.MarshalTo(dAtA[i:]) + n22, err := m.Annotations.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n22 - dAtA[i] = 0x4a + dAtA[i] = 0x42 i++ - i = encodeVarintObjects(dAtA, i, uint64(m.Status.Size())) - n23, err := m.Status.MarshalTo(dAtA[i:]) + i = encodeVarintObjects(dAtA, i, uint64(m.ServiceAnnotations.Size())) + n23, err := m.ServiceAnnotations.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n23 + dAtA[i] = 0x4a + i++ + i = encodeVarintObjects(dAtA, i, uint64(m.Status.Size())) + n24, err := m.Status.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n24 if m.DesiredState != 0 { dAtA[i] = 0x50 i++ @@ -1687,32 +1714,32 @@ func (m *Task) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x62 i++ i = encodeVarintObjects(dAtA, i, uint64(m.Endpoint.Size())) - n24, err := m.Endpoint.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n24 - } - if m.LogDriver != nil { - dAtA[i] = 0x6a - i++ - i = encodeVarintObjects(dAtA, i, uint64(m.LogDriver.Size())) - n25, err := m.LogDriver.MarshalTo(dAtA[i:]) + n25, err := m.Endpoint.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n25 } - if m.SpecVersion != nil { - dAtA[i] = 0x72 + if m.LogDriver != nil { + dAtA[i] = 0x6a i++ - i = encodeVarintObjects(dAtA, i, uint64(m.SpecVersion.Size())) - n26, err := m.SpecVersion.MarshalTo(dAtA[i:]) + i = encodeVarintObjects(dAtA, i, uint64(m.LogDriver.Size())) + n26, err := m.LogDriver.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n26 } + if m.SpecVersion != nil { + dAtA[i] = 0x72 + i++ + i = encodeVarintObjects(dAtA, i, uint64(m.SpecVersion.Size())) + n27, err := m.SpecVersion.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n27 + } if len(m.AssignedGenericResources) > 0 { for _, msg := range m.AssignedGenericResources { dAtA[i] = 0x7a @@ -1725,6 +1752,18 @@ func (m *Task) MarshalTo(dAtA []byte) (int, error) { i += n } } + if m.JobIteration != nil { + dAtA[i] = 0x82 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintObjects(dAtA, i, uint64(m.JobIteration.Size())) + n28, err := m.JobIteration.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n28 + } return i, nil } @@ -1747,11 +1786,11 @@ func (m *NetworkAttachment) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintObjects(dAtA, i, uint64(m.Network.Size())) - n27, err := m.Network.MarshalTo(dAtA[i:]) + n29, err := m.Network.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n27 + i += n29 } if len(m.Addresses) > 0 { for _, s := range m.Addresses { @@ -1827,38 +1866,38 @@ func (m *Network) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size())) - n28, err := m.Meta.MarshalTo(dAtA[i:]) + n30, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n28 + i += n30 dAtA[i] = 0x1a i++ i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size())) - n29, err := m.Spec.MarshalTo(dAtA[i:]) + n31, err := m.Spec.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n29 + i += n31 if m.DriverState != nil { dAtA[i] = 0x22 i++ i = encodeVarintObjects(dAtA, i, uint64(m.DriverState.Size())) - n30, err := m.DriverState.MarshalTo(dAtA[i:]) + n32, err := m.DriverState.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n30 + i += n32 } if m.IPAM != nil { dAtA[i] = 0x2a i++ i = encodeVarintObjects(dAtA, i, uint64(m.IPAM.Size())) - n31, err := m.IPAM.MarshalTo(dAtA[i:]) + n33, err := m.IPAM.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n31 + i += n33 } if m.PendingDelete { dAtA[i] = 0x30 @@ -1897,27 +1936,27 @@ func (m *Cluster) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size())) - n32, err := m.Meta.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n32 - dAtA[i] = 0x1a - i++ - i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size())) - n33, err := m.Spec.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n33 - dAtA[i] = 0x22 - i++ - i = encodeVarintObjects(dAtA, i, uint64(m.RootCA.Size())) - n34, err := m.RootCA.MarshalTo(dAtA[i:]) + n34, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n34 + dAtA[i] = 0x1a + i++ + i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size())) + n35, err := m.Spec.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n35 + dAtA[i] = 0x22 + i++ + i = encodeVarintObjects(dAtA, i, uint64(m.RootCA.Size())) + n36, err := m.RootCA.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n36 if len(m.NetworkBootstrapKeys) > 0 { for _, msg := range m.NetworkBootstrapKeys { dAtA[i] = 0x2a @@ -1955,11 +1994,11 @@ func (m *Cluster) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintObjects(dAtA, i, uint64(v.Size())) - n35, err := v.MarshalTo(dAtA[i:]) + n37, err := v.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n35 + i += n37 } } } @@ -2037,19 +2076,19 @@ func (m *Secret) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size())) - n36, err := m.Meta.MarshalTo(dAtA[i:]) + n38, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n36 + i += n38 dAtA[i] = 0x1a i++ i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size())) - n37, err := m.Spec.MarshalTo(dAtA[i:]) + n39, err := m.Spec.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n37 + i += n39 if m.Internal { dAtA[i] = 0x20 i++ @@ -2087,19 +2126,19 @@ func (m *Config) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size())) - n38, err := m.Meta.MarshalTo(dAtA[i:]) + n40, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n38 + i += n40 dAtA[i] = 0x1a i++ i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size())) - n39, err := m.Spec.MarshalTo(dAtA[i:]) + n41, err := m.Spec.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n39 + i += n41 return i, nil } @@ -2127,19 +2166,19 @@ func (m *Resource) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size())) - n40, err := m.Meta.MarshalTo(dAtA[i:]) + n42, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n40 + i += n42 dAtA[i] = 0x1a i++ i = encodeVarintObjects(dAtA, i, uint64(m.Annotations.Size())) - n41, err := m.Annotations.MarshalTo(dAtA[i:]) + n43, err := m.Annotations.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n41 + i += n43 if len(m.Kind) > 0 { dAtA[i] = 0x22 i++ @@ -2150,11 +2189,11 @@ func (m *Resource) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x2a i++ i = encodeVarintObjects(dAtA, i, uint64(m.Payload.Size())) - n42, err := m.Payload.MarshalTo(dAtA[i:]) + n44, err := m.Payload.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n42 + i += n44 } return i, nil } @@ -2183,19 +2222,19 @@ func (m *Extension) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size())) - n43, err := m.Meta.MarshalTo(dAtA[i:]) + n45, err := m.Meta.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n43 + i += n45 dAtA[i] = 0x1a i++ i = encodeVarintObjects(dAtA, i, uint64(m.Annotations.Size())) - n44, err := m.Annotations.MarshalTo(dAtA[i:]) + n46, err := m.Annotations.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n44 + i += n46 if len(m.Description) > 0 { dAtA[i] = 0x22 i++ @@ -2315,6 +2354,10 @@ func (m *Service) Size() (n int) { l = m.PreviousSpecVersion.Size() n += 1 + l + sovObjects(uint64(l)) } + if m.JobStatus != nil { + l = m.JobStatus.Size() + n += 1 + l + sovObjects(uint64(l)) + } return n } @@ -2418,6 +2461,10 @@ func (m *Task) Size() (n int) { n += 1 + l + sovObjects(uint64(l)) } } + if m.JobIteration != nil { + l = m.JobIteration.Size() + n += 2 + l + sovObjects(uint64(l)) + } return n } @@ -5323,6 +5370,7 @@ func (this *Service) String() string { `PendingDelete:` + fmt.Sprintf("%v", this.PendingDelete) + `,`, `SpecVersion:` + strings.Replace(fmt.Sprintf("%v", this.SpecVersion), "Version", "Version", 1) + `,`, `PreviousSpecVersion:` + strings.Replace(fmt.Sprintf("%v", this.PreviousSpecVersion), "Version", "Version", 1) + `,`, + `JobStatus:` + strings.Replace(fmt.Sprintf("%v", this.JobStatus), "JobStatus", "JobStatus", 1) + `,`, `}`, }, "") return s @@ -5370,6 +5418,7 @@ func (this *Task) String() string { `LogDriver:` + strings.Replace(fmt.Sprintf("%v", this.LogDriver), "Driver", "Driver", 1) + `,`, `SpecVersion:` + strings.Replace(fmt.Sprintf("%v", this.SpecVersion), "Version", "Version", 1) + `,`, `AssignedGenericResources:` + strings.Replace(fmt.Sprintf("%v", this.AssignedGenericResources), "GenericResource", "GenericResource", 1) + `,`, + `JobIteration:` + strings.Replace(fmt.Sprintf("%v", this.JobIteration), "Version", "Version", 1) + `,`, `}`, }, "") return s @@ -6385,6 +6434,42 @@ func (m *Service) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobStatus", 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 < 0 { + return ErrInvalidLengthObjects + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JobStatus == nil { + m.JobStatus = &JobStatus{} + } + if err := m.JobStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipObjects(dAtA[iNdEx:]) @@ -7187,6 +7272,42 @@ func (m *Task) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobIteration", 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 < 0 { + return ErrInvalidLengthObjects + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.JobIteration == nil { + m.JobIteration = &Version{} + } + if err := m.JobIteration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipObjects(dAtA[iNdEx:]) diff --git a/vendor/github.com/docker/swarmkit/api/objects.proto b/vendor/github.com/docker/swarmkit/api/objects.proto index b91c27ef2d..4baf58af0a 100644 --- a/vendor/github.com/docker/swarmkit/api/objects.proto +++ b/vendor/github.com/docker/swarmkit/api/objects.proto @@ -127,6 +127,10 @@ message Service { // progress. UpdateStatus update_status = 5; + // JobStatus contains the status of a Service that is in one of the Job + // modes. It is absent on Replicated and Global services. + JobStatus job_status = 12; + // PendingDelete indicates that this service's deletion has been requested. // Services, as well as all service-level resources, can only be deleted // after all of the service's containers have properly shut down. @@ -261,6 +265,10 @@ message Task { Driver log_driver = 13; repeated GenericResource assigned_generic_resources = 15; + + // JobIteration is the iteration number of the Job-mode Service that this + // task belongs to. + Version job_iteration = 16; } // NetworkAttachment specifies the network parameters of attachment to diff --git a/vendor/github.com/docker/swarmkit/api/specs.pb.go b/vendor/github.com/docker/swarmkit/api/specs.pb.go index c94e95b556..dbfc2ab2e1 100644 --- a/vendor/github.com/docker/swarmkit/api/specs.pb.go +++ b/vendor/github.com/docker/swarmkit/api/specs.pb.go @@ -113,7 +113,7 @@ func (x ContainerSpec_Isolation) String() string { } func (ContainerSpec_Isolation) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{8, 0} + return fileDescriptor_6589acc608f7d4fd, []int{10, 0} } // ResolutionMode specifies the mode of resolution to use for @@ -151,7 +151,7 @@ func (x EndpointSpec_ResolutionMode) String() string { } func (EndpointSpec_ResolutionMode) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{9, 0} + return fileDescriptor_6589acc608f7d4fd, []int{11, 0} } type NodeSpec struct { @@ -210,6 +210,8 @@ type ServiceSpec struct { // Types that are valid to be assigned to Mode: // *ServiceSpec_Replicated // *ServiceSpec_Global + // *ServiceSpec_ReplicatedJob + // *ServiceSpec_GlobalJob Mode isServiceSpec_Mode `protobuf_oneof:"mode"` // Update contains settings which affect updates. Update *UpdateConfig `protobuf:"bytes,6,opt,name=update,proto3" json:"update,omitempty"` @@ -270,9 +272,17 @@ type ServiceSpec_Replicated struct { type ServiceSpec_Global struct { Global *GlobalService `protobuf:"bytes,4,opt,name=global,proto3,oneof"` } +type ServiceSpec_ReplicatedJob struct { + ReplicatedJob *ReplicatedJob `protobuf:"bytes,10,opt,name=replicated_job,json=replicatedJob,proto3,oneof"` +} +type ServiceSpec_GlobalJob struct { + GlobalJob *GlobalJob `protobuf:"bytes,11,opt,name=global_job,json=globalJob,proto3,oneof"` +} -func (*ServiceSpec_Replicated) isServiceSpec_Mode() {} -func (*ServiceSpec_Global) isServiceSpec_Mode() {} +func (*ServiceSpec_Replicated) isServiceSpec_Mode() {} +func (*ServiceSpec_Global) isServiceSpec_Mode() {} +func (*ServiceSpec_ReplicatedJob) isServiceSpec_Mode() {} +func (*ServiceSpec_GlobalJob) isServiceSpec_Mode() {} func (m *ServiceSpec) GetMode() isServiceSpec_Mode { if m != nil { @@ -295,11 +305,27 @@ func (m *ServiceSpec) GetGlobal() *GlobalService { return nil } +func (m *ServiceSpec) GetReplicatedJob() *ReplicatedJob { + if x, ok := m.GetMode().(*ServiceSpec_ReplicatedJob); ok { + return x.ReplicatedJob + } + return nil +} + +func (m *ServiceSpec) GetGlobalJob() *GlobalJob { + if x, ok := m.GetMode().(*ServiceSpec_GlobalJob); ok { + return x.GlobalJob + } + return nil +} + // XXX_OneofFuncs is for the internal use of the proto package. func (*ServiceSpec) 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 _ServiceSpec_OneofMarshaler, _ServiceSpec_OneofUnmarshaler, _ServiceSpec_OneofSizer, []interface{}{ (*ServiceSpec_Replicated)(nil), (*ServiceSpec_Global)(nil), + (*ServiceSpec_ReplicatedJob)(nil), + (*ServiceSpec_GlobalJob)(nil), } } @@ -317,6 +343,16 @@ func _ServiceSpec_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { if err := b.EncodeMessage(x.Global); err != nil { return err } + case *ServiceSpec_ReplicatedJob: + _ = b.EncodeVarint(10<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ReplicatedJob); err != nil { + return err + } + case *ServiceSpec_GlobalJob: + _ = b.EncodeVarint(11<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.GlobalJob); err != nil { + return err + } case nil: default: return fmt.Errorf("ServiceSpec.Mode has unexpected type %T", x) @@ -343,6 +379,22 @@ func _ServiceSpec_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Bu err := b.DecodeMessage(msg) m.Mode = &ServiceSpec_Global{msg} return true, err + case 10: // mode.replicated_job + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(ReplicatedJob) + err := b.DecodeMessage(msg) + m.Mode = &ServiceSpec_ReplicatedJob{msg} + return true, err + case 11: // mode.global_job + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(GlobalJob) + err := b.DecodeMessage(msg) + m.Mode = &ServiceSpec_GlobalJob{msg} + return true, err default: return false, nil } @@ -362,6 +414,16 @@ func _ServiceSpec_OneofSizer(msg proto.Message) (n int) { n += 1 // tag and wire n += proto.SizeVarint(uint64(s)) n += s + case *ServiceSpec_ReplicatedJob: + s := proto.Size(x.ReplicatedJob) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s + case *ServiceSpec_GlobalJob: + s := proto.Size(x.GlobalJob) + n += 1 // tag and wire + n += proto.SizeVarint(uint64(s)) + n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) @@ -442,6 +504,88 @@ func (m *GlobalService) XXX_DiscardUnknown() { var xxx_messageInfo_GlobalService proto.InternalMessageInfo +// ReplicatedJob is a certain type of one-off job which executes many Tasks in +// parallel until the specified number of Tasks have succeeded. +type ReplicatedJob struct { + // MaxConcurrent indicates the maximum number of Tasks that should be + // executing simultaneously at any given time. + MaxConcurrent uint64 `protobuf:"varint,1,opt,name=max_concurrent,json=maxConcurrent,proto3" json:"max_concurrent,omitempty"` + // TotalCompletions sets the total number of Tasks desired to run to + // completion. This is also the absolute maximum number of Tasks that will + // be executed in parallel. That is, if this number is smaller than + // MaxConcurrent, only this many replicas will run. + TotalCompletions uint64 `protobuf:"varint,2,opt,name=total_completions,json=totalCompletions,proto3" json:"total_completions,omitempty"` +} + +func (m *ReplicatedJob) Reset() { *m = ReplicatedJob{} } +func (*ReplicatedJob) ProtoMessage() {} +func (*ReplicatedJob) Descriptor() ([]byte, []int) { + return fileDescriptor_6589acc608f7d4fd, []int{4} +} +func (m *ReplicatedJob) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ReplicatedJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ReplicatedJob.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ReplicatedJob) XXX_Merge(src proto.Message) { + xxx_messageInfo_ReplicatedJob.Merge(m, src) +} +func (m *ReplicatedJob) XXX_Size() int { + return m.Size() +} +func (m *ReplicatedJob) XXX_DiscardUnknown() { + xxx_messageInfo_ReplicatedJob.DiscardUnknown(m) +} + +var xxx_messageInfo_ReplicatedJob proto.InternalMessageInfo + +// GlobalJob is a type of one-off job which executes one Task on every node +// matching the service's placement constraints. +type GlobalJob struct { +} + +func (m *GlobalJob) Reset() { *m = GlobalJob{} } +func (*GlobalJob) ProtoMessage() {} +func (*GlobalJob) Descriptor() ([]byte, []int) { + return fileDescriptor_6589acc608f7d4fd, []int{5} +} +func (m *GlobalJob) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GlobalJob) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GlobalJob.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *GlobalJob) XXX_Merge(src proto.Message) { + xxx_messageInfo_GlobalJob.Merge(m, src) +} +func (m *GlobalJob) XXX_Size() int { + return m.Size() +} +func (m *GlobalJob) XXX_DiscardUnknown() { + xxx_messageInfo_GlobalJob.DiscardUnknown(m) +} + +var xxx_messageInfo_GlobalJob proto.InternalMessageInfo + type TaskSpec struct { // Types that are valid to be assigned to Runtime: // *TaskSpec_Attachment @@ -480,7 +624,7 @@ type TaskSpec struct { func (m *TaskSpec) Reset() { *m = TaskSpec{} } func (*TaskSpec) ProtoMessage() {} func (*TaskSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{4} + return fileDescriptor_6589acc608f7d4fd, []int{6} } func (m *TaskSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -658,7 +802,7 @@ type ResourceReference struct { func (m *ResourceReference) Reset() { *m = ResourceReference{} } func (*ResourceReference) ProtoMessage() {} func (*ResourceReference) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{5} + return fileDescriptor_6589acc608f7d4fd, []int{7} } func (m *ResourceReference) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -695,7 +839,7 @@ type GenericRuntimeSpec struct { func (m *GenericRuntimeSpec) Reset() { *m = GenericRuntimeSpec{} } func (*GenericRuntimeSpec) ProtoMessage() {} func (*GenericRuntimeSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{6} + return fileDescriptor_6589acc608f7d4fd, []int{8} } func (m *GenericRuntimeSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -735,7 +879,7 @@ type NetworkAttachmentSpec struct { func (m *NetworkAttachmentSpec) Reset() { *m = NetworkAttachmentSpec{} } func (*NetworkAttachmentSpec) ProtoMessage() {} func (*NetworkAttachmentSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{7} + return fileDescriptor_6589acc608f7d4fd, []int{9} } func (m *NetworkAttachmentSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -882,7 +1026,7 @@ type ContainerSpec struct { func (m *ContainerSpec) Reset() { *m = ContainerSpec{} } func (*ContainerSpec) ProtoMessage() {} func (*ContainerSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{8} + return fileDescriptor_6589acc608f7d4fd, []int{10} } func (m *ContainerSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -923,7 +1067,7 @@ type ContainerSpec_PullOptions struct { func (m *ContainerSpec_PullOptions) Reset() { *m = ContainerSpec_PullOptions{} } func (*ContainerSpec_PullOptions) ProtoMessage() {} func (*ContainerSpec_PullOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{8, 1} + return fileDescriptor_6589acc608f7d4fd, []int{10, 1} } func (m *ContainerSpec_PullOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -968,7 +1112,7 @@ type ContainerSpec_DNSConfig struct { func (m *ContainerSpec_DNSConfig) Reset() { *m = ContainerSpec_DNSConfig{} } func (*ContainerSpec_DNSConfig) ProtoMessage() {} func (*ContainerSpec_DNSConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{8, 2} + return fileDescriptor_6589acc608f7d4fd, []int{10, 2} } func (m *ContainerSpec_DNSConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1009,7 +1153,7 @@ type EndpointSpec struct { func (m *EndpointSpec) Reset() { *m = EndpointSpec{} } func (*EndpointSpec) ProtoMessage() {} func (*EndpointSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{9} + return fileDescriptor_6589acc608f7d4fd, []int{11} } func (m *EndpointSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1072,7 +1216,7 @@ type NetworkSpec struct { func (m *NetworkSpec) Reset() { *m = NetworkSpec{} } func (*NetworkSpec) ProtoMessage() {} func (*NetworkSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{10} + return fileDescriptor_6589acc608f7d4fd, []int{12} } func (m *NetworkSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1202,7 +1346,7 @@ type ClusterSpec struct { func (m *ClusterSpec) Reset() { *m = ClusterSpec{} } func (*ClusterSpec) ProtoMessage() {} func (*ClusterSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{11} + return fileDescriptor_6589acc608f7d4fd, []int{13} } func (m *ClusterSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1249,7 +1393,7 @@ type SecretSpec struct { func (m *SecretSpec) Reset() { *m = SecretSpec{} } func (*SecretSpec) ProtoMessage() {} func (*SecretSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{12} + return fileDescriptor_6589acc608f7d4fd, []int{14} } func (m *SecretSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1296,7 +1440,7 @@ type ConfigSpec struct { func (m *ConfigSpec) Reset() { *m = ConfigSpec{} } func (*ConfigSpec) ProtoMessage() {} func (*ConfigSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_6589acc608f7d4fd, []int{13} + return fileDescriptor_6589acc608f7d4fd, []int{15} } func (m *ConfigSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1334,6 +1478,8 @@ func init() { proto.RegisterType((*ServiceSpec)(nil), "docker.swarmkit.v1.ServiceSpec") proto.RegisterType((*ReplicatedService)(nil), "docker.swarmkit.v1.ReplicatedService") proto.RegisterType((*GlobalService)(nil), "docker.swarmkit.v1.GlobalService") + proto.RegisterType((*ReplicatedJob)(nil), "docker.swarmkit.v1.ReplicatedJob") + proto.RegisterType((*GlobalJob)(nil), "docker.swarmkit.v1.GlobalJob") proto.RegisterType((*TaskSpec)(nil), "docker.swarmkit.v1.TaskSpec") proto.RegisterType((*ResourceReference)(nil), "docker.swarmkit.v1.ResourceReference") proto.RegisterType((*GenericRuntimeSpec)(nil), "docker.swarmkit.v1.GenericRuntimeSpec") @@ -1355,144 +1501,150 @@ func init() { } var fileDescriptor_6589acc608f7d4fd = []byte{ - // 2193 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x4d, 0x73, 0x1b, 0xb9, - 0xd1, 0x26, 0x25, 0x8a, 0x1f, 0x3d, 0x94, 0x4d, 0x61, 0xbd, 0xde, 0x11, 0x6d, 0x53, 0x34, 0xd7, - 0xeb, 0x57, 0xbb, 0x5b, 0x2f, 0x55, 0x51, 0xb6, 0x36, 0x5e, 0x3b, 0x9b, 0x84, 0x14, 0xb9, 0x32, - 0x63, 0x5b, 0x62, 0x81, 0xb2, 0x12, 0x57, 0xa5, 0x8a, 0x05, 0xcd, 0x40, 0xe4, 0x94, 0x86, 0x83, - 0x09, 0x00, 0xca, 0xc5, 0x5b, 0x8e, 0x5b, 0xca, 0x25, 0x7f, 0x40, 0x95, 0x43, 0x2a, 0xf7, 0xe4, - 0x5f, 0xf8, 0xb8, 0xc7, 0xcd, 0x45, 0x95, 0x95, 0x7f, 0x42, 0x6e, 0xb9, 0x24, 0x05, 0x0c, 0x86, - 0x1f, 0x32, 0x65, 0x39, 0x15, 0x1f, 0x72, 0x03, 0x7a, 0x9e, 0xa7, 0xd1, 0x0d, 0x74, 0x37, 0x1a, - 0x03, 0x9f, 0xf5, 0x3c, 0xd9, 0x1f, 0x1e, 0x54, 0x1d, 0x36, 0xd8, 0x70, 0x99, 0x73, 0x44, 0xf9, - 0x86, 0x78, 0x49, 0xf8, 0xe0, 0xc8, 0x93, 0x1b, 0x24, 0xf4, 0x36, 0x44, 0x48, 0x1d, 0x51, 0x0d, - 0x39, 0x93, 0x0c, 0xa1, 0x08, 0x50, 0x8d, 0x01, 0xd5, 0xe3, 0x1f, 0x15, 0xaf, 0xe2, 0xcb, 0x51, - 0x48, 0x0d, 0xbf, 0x78, 0xa3, 0xc7, 0x7a, 0x4c, 0x0f, 0x37, 0xd4, 0xc8, 0x48, 0x4b, 0x3d, 0xc6, - 0x7a, 0x3e, 0xdd, 0xd0, 0xb3, 0x83, 0xe1, 0xe1, 0x86, 0x3b, 0xe4, 0x44, 0x7a, 0x2c, 0x30, 0xdf, - 0x57, 0x2f, 0x7e, 0x27, 0xc1, 0xe8, 0x32, 0xea, 0x4b, 0x4e, 0xc2, 0x90, 0x72, 0xb3, 0x60, 0xe5, - 0x34, 0x05, 0xd9, 0x1d, 0xe6, 0xd2, 0x4e, 0x48, 0x1d, 0xb4, 0x0d, 0x16, 0x09, 0x02, 0x26, 0xb5, - 0x6e, 0x61, 0x27, 0xcb, 0xc9, 0x75, 0x6b, 0x73, 0xad, 0xfa, 0xa6, 0x4f, 0xd5, 0xda, 0x04, 0x56, - 0x4f, 0xbd, 0x3a, 0x5b, 0x4b, 0xe0, 0x69, 0x26, 0xfa, 0x39, 0xe4, 0x5d, 0x2a, 0x3c, 0x4e, 0xdd, - 0x2e, 0x67, 0x3e, 0xb5, 0x17, 0xca, 0xc9, 0xf5, 0x6b, 0x9b, 0xb7, 0xe7, 0x69, 0x52, 0x8b, 0x63, - 0xe6, 0x53, 0x6c, 0x19, 0x86, 0x9a, 0xa0, 0x6d, 0x80, 0x01, 0x1d, 0x1c, 0x50, 0x2e, 0xfa, 0x5e, - 0x68, 0x2f, 0x6a, 0xfa, 0xff, 0x5d, 0x46, 0x57, 0xb6, 0x57, 0x9f, 0x8d, 0xe1, 0x78, 0x8a, 0x8a, - 0x9e, 0x41, 0x9e, 0x1c, 0x13, 0xcf, 0x27, 0x07, 0x9e, 0xef, 0xc9, 0x91, 0x9d, 0xd2, 0xaa, 0x3e, - 0x7d, 0xab, 0xaa, 0xda, 0x14, 0x01, 0xcf, 0xd0, 0x2b, 0x2e, 0xc0, 0x64, 0x21, 0x74, 0x1f, 0x32, - 0xed, 0xe6, 0x4e, 0xa3, 0xb5, 0xb3, 0x5d, 0x48, 0x14, 0x57, 0x4f, 0x4e, 0xcb, 0x1f, 0x2a, 0x1d, - 0x13, 0x40, 0x9b, 0x06, 0xae, 0x17, 0xf4, 0xd0, 0x3a, 0x64, 0x6b, 0x5b, 0x5b, 0xcd, 0xf6, 0x5e, - 0xb3, 0x51, 0x48, 0x16, 0x8b, 0x27, 0xa7, 0xe5, 0x9b, 0xb3, 0xc0, 0x9a, 0xe3, 0xd0, 0x50, 0x52, - 0xb7, 0x98, 0xfa, 0xf6, 0x4f, 0xa5, 0x44, 0xe5, 0xdb, 0x24, 0xe4, 0xa7, 0x8d, 0x40, 0xf7, 0x21, - 0x5d, 0xdb, 0xda, 0x6b, 0xed, 0x37, 0x0b, 0x89, 0x09, 0x7d, 0x1a, 0x51, 0x73, 0xa4, 0x77, 0x4c, - 0xd1, 0x3d, 0x58, 0x6a, 0xd7, 0x9e, 0x77, 0x9a, 0x85, 0xe4, 0xc4, 0x9c, 0x69, 0x58, 0x9b, 0x0c, - 0x85, 0x46, 0x35, 0x70, 0xad, 0xb5, 0x53, 0x58, 0x98, 0x8f, 0x6a, 0x70, 0xe2, 0x05, 0xc6, 0x94, - 0x3f, 0xa6, 0xc0, 0xea, 0x50, 0x7e, 0xec, 0x39, 0xef, 0x39, 0x44, 0xbe, 0x84, 0x94, 0x24, 0xe2, - 0x48, 0x87, 0x86, 0x35, 0x3f, 0x34, 0xf6, 0x88, 0x38, 0x52, 0x8b, 0x1a, 0xba, 0xc6, 0xab, 0xc8, - 0xe0, 0x34, 0xf4, 0x3d, 0x87, 0x48, 0xea, 0xea, 0xc8, 0xb0, 0x36, 0x3f, 0x99, 0xc7, 0xc6, 0x63, - 0x94, 0xb1, 0xff, 0x71, 0x02, 0x4f, 0x51, 0xd1, 0x23, 0x48, 0xf7, 0x7c, 0x76, 0x40, 0x7c, 0x1d, - 0x13, 0xd6, 0xe6, 0xdd, 0x79, 0x4a, 0xb6, 0x35, 0x62, 0xa2, 0xc0, 0x50, 0xd0, 0x03, 0x48, 0x0f, - 0x43, 0x97, 0x48, 0x6a, 0xa7, 0x35, 0xb9, 0x3c, 0x8f, 0xfc, 0x5c, 0x23, 0xb6, 0x58, 0x70, 0xe8, - 0xf5, 0xb0, 0xc1, 0xa3, 0x9f, 0x42, 0x96, 0x33, 0xdf, 0x3f, 0x20, 0xce, 0x91, 0x9d, 0x7b, 0x47, - 0xee, 0x98, 0x81, 0x9e, 0x40, 0x36, 0xa0, 0xf2, 0x25, 0xe3, 0x47, 0xc2, 0xce, 0x94, 0x17, 0xd7, - 0xad, 0xcd, 0xcf, 0xe7, 0x86, 0x72, 0x84, 0xa9, 0x49, 0x49, 0x9c, 0xfe, 0x80, 0x06, 0x32, 0x52, - 0x54, 0x5f, 0xb0, 0x93, 0x78, 0xac, 0x40, 0x99, 0x42, 0x03, 0x37, 0x64, 0x5e, 0x20, 0xed, 0xec, - 0xe5, 0xa6, 0x34, 0x0d, 0x46, 0x1d, 0x05, 0x1e, 0x33, 0xea, 0x69, 0x48, 0x0d, 0x98, 0x4b, 0x2b, - 0x1b, 0xb0, 0xf2, 0xc6, 0x56, 0xa3, 0x22, 0x64, 0xcd, 0x56, 0x47, 0x31, 0x92, 0xc2, 0xe3, 0x79, - 0xe5, 0x3a, 0x2c, 0xcf, 0x6c, 0x6b, 0xe5, 0x2f, 0x4b, 0x90, 0x8d, 0xcf, 0x1a, 0x3d, 0x01, 0x20, - 0x63, 0xb3, 0x8d, 0x59, 0x9f, 0xbe, 0x93, 0x8f, 0x8a, 0xae, 0xce, 0x78, 0x42, 0x47, 0x35, 0xc8, - 0x39, 0x2c, 0x90, 0xc4, 0x0b, 0x28, 0x37, 0xb1, 0x3a, 0xf7, 0x98, 0xb7, 0x62, 0x90, 0xd1, 0x31, - 0x61, 0xa1, 0x3a, 0x64, 0x7a, 0x34, 0xa0, 0xdc, 0x73, 0x6c, 0xd0, 0x0a, 0xee, 0xcf, 0x8d, 0x93, - 0x08, 0x82, 0x87, 0x81, 0xf4, 0x06, 0xd4, 0x68, 0x89, 0x89, 0xe8, 0x1b, 0xc8, 0x71, 0x2a, 0xd8, - 0x90, 0x3b, 0x54, 0x98, 0x80, 0x5f, 0x9f, 0x1f, 0xb2, 0x11, 0x08, 0xd3, 0xdf, 0x0e, 0x3d, 0x4e, - 0x95, 0x0b, 0x02, 0x4f, 0xa8, 0xe8, 0x11, 0x64, 0x38, 0x15, 0x92, 0x70, 0xf9, 0xb6, 0x98, 0xc5, - 0x11, 0xa4, 0xcd, 0x7c, 0xcf, 0x19, 0xe1, 0x98, 0x81, 0x1e, 0x41, 0x2e, 0xf4, 0x89, 0xa3, 0xb5, - 0xda, 0x4b, 0x9a, 0x7e, 0x67, 0x1e, 0xbd, 0x1d, 0x83, 0xf0, 0x04, 0x8f, 0xbe, 0x02, 0xf0, 0x59, - 0xaf, 0xeb, 0x72, 0xef, 0x98, 0x72, 0x13, 0xf3, 0xc5, 0x79, 0xec, 0x86, 0x46, 0xe0, 0x9c, 0xcf, - 0x7a, 0xd1, 0x10, 0x6d, 0xff, 0x57, 0x21, 0x3b, 0x15, 0xae, 0x77, 0x21, 0x7f, 0xc8, 0xb8, 0x43, - 0xbb, 0x26, 0xf3, 0x72, 0x3a, 0xae, 0x2c, 0x2d, 0x8b, 0xd2, 0x05, 0xfd, 0x06, 0x3e, 0x88, 0x77, - 0xab, 0xcb, 0xe9, 0x21, 0xe5, 0x34, 0x50, 0x5b, 0x6e, 0xe9, 0x65, 0x3f, 0x79, 0xfb, 0x96, 0x1b, - 0xb4, 0x29, 0x36, 0x88, 0x5f, 0xfc, 0x20, 0xea, 0x39, 0xc8, 0xf0, 0xe8, 0x80, 0x2b, 0xbf, 0x4f, - 0xaa, 0xa8, 0xbf, 0x80, 0x40, 0x1b, 0x60, 0x8d, 0x97, 0xf7, 0x5c, 0x1d, 0x70, 0xb9, 0xfa, 0xb5, - 0xf3, 0xb3, 0x35, 0x88, 0xb1, 0xad, 0x86, 0xaa, 0x41, 0x66, 0xec, 0xa2, 0x26, 0x2c, 0x8f, 0x09, - 0xaa, 0x0d, 0x30, 0x17, 0x65, 0xf9, 0x6d, 0x96, 0xee, 0x8d, 0x42, 0x8a, 0xf3, 0x7c, 0x6a, 0x56, - 0xf9, 0x35, 0xa0, 0x37, 0x03, 0x10, 0x21, 0x48, 0x1d, 0x79, 0x81, 0x31, 0x03, 0xeb, 0x31, 0xaa, - 0x42, 0x26, 0x24, 0x23, 0x9f, 0x11, 0xd7, 0xc4, 0xe1, 0x8d, 0x6a, 0xd4, 0x20, 0x54, 0xe3, 0x06, - 0xa1, 0x5a, 0x0b, 0x46, 0x38, 0x06, 0x55, 0x9e, 0xc0, 0x87, 0x73, 0xf3, 0x0c, 0x6d, 0x42, 0x7e, - 0x9c, 0x23, 0x13, 0x5f, 0xaf, 0x9f, 0x9f, 0xad, 0x59, 0xe3, 0x64, 0x6a, 0x35, 0xb0, 0x35, 0x06, - 0xb5, 0xdc, 0xca, 0xc9, 0x32, 0x2c, 0xcf, 0x64, 0x1a, 0xba, 0x01, 0x4b, 0xde, 0x80, 0xf4, 0xa8, - 0xb1, 0x31, 0x9a, 0xa0, 0x26, 0xa4, 0x7d, 0x72, 0x40, 0x7d, 0x95, 0x2b, 0xea, 0xe0, 0xfe, 0xff, - 0xca, 0x94, 0xad, 0x3e, 0xd5, 0xf8, 0x66, 0x20, 0xf9, 0x08, 0x1b, 0x32, 0xb2, 0x21, 0xe3, 0xb0, - 0xc1, 0x80, 0x04, 0xea, 0x9a, 0x58, 0x5c, 0xcf, 0xe1, 0x78, 0xaa, 0x76, 0x86, 0xf0, 0x9e, 0xb0, - 0x53, 0x5a, 0xac, 0xc7, 0xaa, 0x62, 0xf5, 0x99, 0x90, 0x01, 0x19, 0x50, 0xfb, 0x9a, 0xb6, 0x66, - 0x3c, 0x47, 0x05, 0x58, 0xa4, 0xc1, 0xb1, 0xbd, 0xa4, 0xe1, 0x6a, 0xa8, 0x24, 0xae, 0x17, 0x25, - 0x42, 0x0e, 0xab, 0xa1, 0xd2, 0x39, 0x14, 0x94, 0xdb, 0x99, 0x68, 0xb7, 0xd5, 0x18, 0xdd, 0x84, - 0x74, 0x8f, 0xb3, 0x61, 0x18, 0x45, 0x60, 0x0e, 0x9b, 0x19, 0xfa, 0x19, 0x40, 0xc8, 0xbd, 0x63, - 0xcf, 0xa7, 0x3d, 0x2a, 0xec, 0x9b, 0xfa, 0x20, 0x4a, 0x73, 0x73, 0x71, 0x8c, 0xc2, 0x53, 0x0c, - 0x54, 0x85, 0x94, 0x17, 0x78, 0xd2, 0xfe, 0xc8, 0xe4, 0xe1, 0xc5, 0x23, 0xac, 0x33, 0xe6, 0xef, - 0x13, 0x7f, 0x48, 0xb1, 0xc6, 0xa1, 0x55, 0x58, 0x94, 0x72, 0x64, 0x2f, 0x97, 0x93, 0xeb, 0xd9, - 0x7a, 0xe6, 0xfc, 0x6c, 0x6d, 0x71, 0x6f, 0xef, 0x05, 0x56, 0x32, 0x74, 0x07, 0x80, 0x85, 0x34, - 0xe8, 0x0a, 0xe9, 0x7a, 0x81, 0x8d, 0x14, 0x02, 0xe7, 0x94, 0xa4, 0xa3, 0x04, 0xe8, 0x96, 0xaa, - 0x5c, 0xc4, 0xed, 0xb2, 0xc0, 0x1f, 0xd9, 0x1f, 0xe8, 0xaf, 0x59, 0x25, 0xd8, 0x0d, 0xfc, 0x11, - 0x5a, 0x03, 0x4b, 0x48, 0x16, 0x76, 0x85, 0xd7, 0x0b, 0x88, 0x6f, 0xdf, 0xd0, 0x9e, 0x83, 0x12, - 0x75, 0xb4, 0x04, 0xfd, 0x04, 0xd2, 0x03, 0x36, 0x0c, 0xa4, 0xb0, 0xb3, 0xfa, 0x20, 0x57, 0xe7, - 0xf9, 0xf8, 0x4c, 0x21, 0x4c, 0xd6, 0x19, 0x38, 0x6a, 0xc2, 0x8a, 0xd6, 0xdc, 0xe3, 0xc4, 0xa1, - 0xdd, 0x90, 0x72, 0x8f, 0xb9, 0xe6, 0xb6, 0x5c, 0x7d, 0xc3, 0xdb, 0x86, 0x69, 0x86, 0xf1, 0x75, - 0xc5, 0xd9, 0x56, 0x94, 0xb6, 0x66, 0xa0, 0x36, 0xe4, 0xc3, 0xa1, 0xef, 0x77, 0x59, 0x18, 0x75, - 0x2b, 0x51, 0x01, 0x7f, 0x87, 0x70, 0x6a, 0x0f, 0x7d, 0x7f, 0x37, 0x22, 0x61, 0x2b, 0x9c, 0x4c, - 0xd0, 0xd7, 0x90, 0x11, 0xd4, 0xe1, 0x54, 0x0a, 0x3b, 0xaf, 0x5d, 0xfa, 0x78, 0x9e, 0xb2, 0x8e, - 0x86, 0x8c, 0xeb, 0x02, 0x8e, 0x39, 0x8a, 0xee, 0xe8, 0xb2, 0x26, 0xec, 0x0f, 0x2f, 0xa7, 0x9b, - 0xca, 0x37, 0xa1, 0x1b, 0x8e, 0x4a, 0x17, 0x15, 0x93, 0xc2, 0x5e, 0xd1, 0xe1, 0x14, 0x4d, 0xd0, - 0x0b, 0x00, 0x37, 0x10, 0xdd, 0x08, 0x64, 0x5f, 0xd7, 0x3e, 0x7e, 0x7e, 0xb5, 0x8f, 0x8d, 0x9d, - 0x8e, 0xe9, 0x0a, 0x96, 0xcf, 0xcf, 0xd6, 0x72, 0xe3, 0x29, 0xce, 0xb9, 0x81, 0x88, 0x86, 0xa8, - 0x0e, 0x56, 0x9f, 0x12, 0x5f, 0xf6, 0x9d, 0x3e, 0x75, 0x8e, 0xec, 0xc2, 0xe5, 0x4d, 0xc2, 0x63, - 0x0d, 0x33, 0x1a, 0xa6, 0x49, 0xa8, 0x05, 0x39, 0x4f, 0x30, 0x5f, 0x1f, 0x91, 0x6d, 0xeb, 0xfa, - 0xf6, 0x0e, 0xd6, 0xb5, 0x62, 0x0a, 0x9e, 0xb0, 0xd1, 0x6d, 0xc8, 0x85, 0x9e, 0x2b, 0x9e, 0x7a, - 0x03, 0x4f, 0xda, 0xab, 0xe5, 0xe4, 0xfa, 0x22, 0x9e, 0x08, 0xd0, 0x63, 0xc8, 0x88, 0x91, 0x70, - 0xa4, 0x2f, 0xec, 0xa2, 0xde, 0xdc, 0xea, 0xd5, 0xcb, 0x74, 0x22, 0x42, 0x54, 0x38, 0x62, 0x3a, - 0xaa, 0x40, 0xde, 0x21, 0x61, 0xd4, 0x0d, 0x7b, 0x54, 0xd8, 0xb7, 0xf4, 0x76, 0xcf, 0xc8, 0x8a, - 0x5f, 0x81, 0x35, 0x55, 0x74, 0x54, 0x41, 0x38, 0xa2, 0x23, 0x53, 0xc7, 0xd4, 0x50, 0x1d, 0xd6, - 0xb1, 0xca, 0x41, 0x5d, 0x68, 0x73, 0x38, 0x9a, 0x3c, 0x5c, 0x78, 0x90, 0x2c, 0x6e, 0x82, 0x35, - 0x15, 0x60, 0xe8, 0x63, 0x75, 0x09, 0xf4, 0x3c, 0x21, 0xf9, 0xa8, 0x4b, 0x86, 0xb2, 0x6f, 0xff, - 0x42, 0x13, 0xf2, 0xb1, 0xb0, 0x36, 0x94, 0xfd, 0x62, 0x17, 0x26, 0x27, 0x84, 0xca, 0x60, 0xa9, - 0xba, 0x24, 0x28, 0x3f, 0xa6, 0x5c, 0x35, 0x58, 0xca, 0xbc, 0x69, 0x91, 0xaa, 0x3c, 0x82, 0x12, - 0xee, 0xf4, 0x75, 0x09, 0xcd, 0x61, 0x33, 0x53, 0x35, 0x31, 0x4e, 0x06, 0x53, 0x13, 0xcd, 0xb4, - 0xf8, 0x10, 0xf2, 0xd3, 0x9b, 0xf1, 0x9f, 0x38, 0x54, 0xf9, 0x6b, 0x12, 0x72, 0xe3, 0x03, 0x43, - 0x5f, 0xc0, 0x4a, 0xab, 0xb3, 0xfb, 0xb4, 0xb6, 0xd7, 0xda, 0xdd, 0xe9, 0x36, 0x9a, 0xdf, 0xd4, - 0x9e, 0x3f, 0xdd, 0x2b, 0x24, 0x8a, 0x77, 0x4e, 0x4e, 0xcb, 0xab, 0x93, 0xbb, 0x21, 0x86, 0x37, - 0xe8, 0x21, 0x19, 0xfa, 0x72, 0x96, 0xd5, 0xc6, 0xbb, 0x5b, 0xcd, 0x4e, 0xa7, 0x90, 0xbc, 0x8c, - 0xd5, 0xe6, 0xcc, 0xa1, 0x42, 0xa0, 0x4d, 0x28, 0x4c, 0x58, 0x8f, 0x5f, 0xb4, 0x9b, 0x78, 0xbf, - 0xb0, 0x50, 0xbc, 0x7d, 0x72, 0x5a, 0xb6, 0xdf, 0x24, 0x3d, 0x1e, 0x85, 0x94, 0xef, 0x9b, 0x87, - 0xcd, 0x3f, 0x92, 0x90, 0x9f, 0xee, 0x6c, 0xd1, 0x56, 0xd4, 0xcf, 0x6a, 0x8f, 0xaf, 0x6d, 0x6e, - 0x5c, 0xd5, 0x09, 0xeb, 0xfb, 0xd8, 0x1f, 0x2a, 0xbd, 0xcf, 0xd4, 0x13, 0x56, 0x93, 0xd1, 0x17, - 0xb0, 0x14, 0x32, 0x2e, 0xe3, 0x9b, 0x6b, 0x7e, 0x51, 0x67, 0x3c, 0x6e, 0x6e, 0x22, 0x70, 0xa5, - 0x0f, 0xd7, 0x66, 0xb5, 0xa1, 0x7b, 0xb0, 0xb8, 0xdf, 0x6a, 0x17, 0x12, 0xc5, 0x5b, 0x27, 0xa7, - 0xe5, 0x8f, 0x66, 0x3f, 0xee, 0x7b, 0x5c, 0x0e, 0x89, 0xdf, 0x6a, 0xa3, 0xcf, 0x60, 0xa9, 0xb1, - 0xd3, 0xc1, 0xb8, 0x90, 0x2c, 0xae, 0x9d, 0x9c, 0x96, 0x6f, 0xcd, 0xe2, 0xd4, 0x27, 0x36, 0x0c, - 0x5c, 0xcc, 0x0e, 0xc6, 0xcf, 0xb9, 0x7f, 0x2e, 0x80, 0x65, 0x2e, 0xf4, 0xf7, 0xfd, 0xe2, 0x5f, - 0x8e, 0x9a, 0xc3, 0xb8, 0x0e, 0x2d, 0x5c, 0xd9, 0x23, 0xe6, 0x23, 0x82, 0x89, 0xe9, 0xbb, 0x90, - 0xf7, 0xc2, 0xe3, 0x2f, 0xbb, 0x34, 0x20, 0x07, 0xbe, 0x79, 0xd9, 0x65, 0xb1, 0xa5, 0x64, 0xcd, - 0x48, 0xa4, 0xae, 0x68, 0x2f, 0x90, 0x94, 0x07, 0xe6, 0xcd, 0x96, 0xc5, 0xe3, 0x39, 0xfa, 0x1a, - 0x52, 0x5e, 0x48, 0x06, 0xa6, 0xb1, 0x9d, 0xeb, 0x41, 0xab, 0x5d, 0x7b, 0x66, 0x72, 0xae, 0x9e, - 0x3d, 0x3f, 0x5b, 0x4b, 0x29, 0x01, 0xd6, 0x34, 0x54, 0x8a, 0x5f, 0x1d, 0x6a, 0x25, 0x7d, 0xad, - 0x67, 0xf1, 0x94, 0x44, 0xe5, 0x8d, 0x17, 0xf4, 0x38, 0x15, 0x42, 0x5f, 0xf0, 0x59, 0x1c, 0x4f, - 0x51, 0x11, 0x32, 0xa6, 0x43, 0xd5, 0x8f, 0x95, 0x9c, 0xea, 0xfb, 0x8d, 0xa0, 0xbe, 0x0c, 0x56, - 0xb4, 0x1b, 0xdd, 0x43, 0xce, 0x06, 0x95, 0x7f, 0xa5, 0xc0, 0xda, 0xf2, 0x87, 0x42, 0x9a, 0xee, - 0xe7, 0xbd, 0x6d, 0xfe, 0x0b, 0x58, 0x21, 0xfa, 0x0f, 0x02, 0x09, 0xd4, 0x75, 0xa9, 0x1b, 0x7f, - 0x73, 0x00, 0xf7, 0xe6, 0xaa, 0x1b, 0x83, 0xa3, 0x47, 0x42, 0x3d, 0xad, 0x74, 0xda, 0x49, 0x5c, - 0x20, 0x17, 0xbe, 0xa0, 0x0e, 0x2c, 0x33, 0xee, 0xf4, 0xa9, 0x90, 0xd1, 0x25, 0x6b, 0x5e, 0xdc, - 0x73, 0xff, 0xc5, 0xec, 0x4e, 0x03, 0xcd, 0xdd, 0x12, 0x59, 0x3b, 0xab, 0x03, 0x3d, 0x80, 0x14, - 0x27, 0x87, 0xf1, 0x23, 0x66, 0x6e, 0x92, 0x60, 0x72, 0x28, 0x67, 0x54, 0x68, 0x06, 0xfa, 0x25, - 0x80, 0xeb, 0x89, 0x90, 0x48, 0xa7, 0x4f, 0xb9, 0x39, 0xec, 0xb9, 0x2e, 0x36, 0xc6, 0xa8, 0x19, - 0x2d, 0x53, 0x6c, 0xf4, 0x04, 0x72, 0x0e, 0x89, 0xc3, 0x35, 0x7d, 0xf9, 0x6f, 0x88, 0xad, 0x9a, - 0x51, 0x51, 0x50, 0x2a, 0xce, 0xcf, 0xd6, 0xb2, 0xb1, 0x04, 0x67, 0x1d, 0x62, 0xc2, 0xf7, 0x09, - 0x2c, 0x4b, 0x22, 0x8e, 0xba, 0x6e, 0x54, 0xce, 0xa2, 0x30, 0xb9, 0xe4, 0xae, 0x54, 0x6f, 0x5d, - 0x53, 0xf6, 0xe2, 0xe3, 0xcc, 0xcb, 0x29, 0x19, 0xfa, 0x15, 0xac, 0xd0, 0xc0, 0xe1, 0x23, 0x1d, - 0xac, 0xb1, 0x85, 0xd9, 0xcb, 0x9d, 0x6d, 0x8e, 0xc1, 0x33, 0xce, 0x16, 0xe8, 0x05, 0x79, 0xe5, - 0x6f, 0x49, 0x80, 0xa8, 0x39, 0x79, 0xbf, 0x01, 0x88, 0x20, 0xe5, 0x12, 0x49, 0x74, 0xcc, 0xe5, - 0xb1, 0x1e, 0xa3, 0x87, 0x00, 0x92, 0x0e, 0x42, 0x55, 0x7a, 0x83, 0x9e, 0x09, 0x9b, 0xb7, 0x95, - 0x83, 0x29, 0x34, 0xda, 0x84, 0xb4, 0x79, 0x6a, 0xa6, 0xae, 0xe4, 0x19, 0x64, 0xe5, 0xcf, 0x49, - 0x80, 0xc8, 0xcd, 0xff, 0x69, 0xdf, 0xea, 0xf7, 0x5e, 0xfd, 0x50, 0x4a, 0x7c, 0xff, 0x43, 0x29, - 0xf1, 0xbb, 0xf3, 0x52, 0xf2, 0xd5, 0x79, 0x29, 0xf9, 0xdd, 0x79, 0x29, 0xf9, 0xf7, 0xf3, 0x52, - 0xf2, 0x0f, 0xaf, 0x4b, 0x89, 0xef, 0x5e, 0x97, 0x12, 0xdf, 0xbf, 0x2e, 0x25, 0x0e, 0xd2, 0xba, - 0xbd, 0xfd, 0xf1, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x96, 0x6c, 0xd9, 0x32, 0x7d, 0x16, 0x00, + // 2289 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x4d, 0x73, 0x23, 0xb7, + 0xd1, 0x26, 0x25, 0x8a, 0x1f, 0x3d, 0xa4, 0x96, 0x82, 0xd7, 0xf6, 0x88, 0x6b, 0x53, 0x34, 0xbd, + 0xf6, 0x2b, 0xdb, 0xf5, 0x52, 0x15, 0xc5, 0xe5, 0xf8, 0x23, 0x4e, 0x42, 0x8a, 0xb4, 0x44, 0xef, + 0xae, 0xc4, 0x02, 0x65, 0x25, 0x5b, 0x95, 0x2a, 0x16, 0x38, 0x03, 0x91, 0x13, 0x0d, 0x07, 0x13, + 0x0c, 0x28, 0x9b, 0xb7, 0x1c, 0x5d, 0xca, 0x25, 0x7f, 0x40, 0xa7, 0x54, 0x4e, 0xb9, 0x24, 0xff, + 0x62, 0x8f, 0x3e, 0x3a, 0x17, 0x55, 0xac, 0xfd, 0x09, 0xb9, 0xe5, 0x92, 0x14, 0x30, 0x98, 0x21, + 0xa9, 0x25, 0x57, 0x9b, 0xca, 0x1e, 0x72, 0x03, 0x7a, 0x9e, 0xa7, 0xd1, 0x0d, 0x74, 0x37, 0x1a, + 0x03, 0xef, 0x0f, 0x1c, 0x31, 0x1c, 0xf7, 0x6b, 0x16, 0x1b, 0xed, 0xd8, 0xcc, 0x3a, 0xa3, 0x7c, + 0x27, 0xf8, 0x9a, 0xf0, 0xd1, 0x99, 0x23, 0x76, 0x88, 0xef, 0xec, 0x04, 0x3e, 0xb5, 0x82, 0x9a, + 0xcf, 0x99, 0x60, 0x08, 0x85, 0x80, 0x5a, 0x04, 0xa8, 0x9d, 0xff, 0xa8, 0x74, 0x1b, 0x5f, 0x4c, + 0x7c, 0xaa, 0xf9, 0xa5, 0xbb, 0x03, 0x36, 0x60, 0x6a, 0xb8, 0x23, 0x47, 0x5a, 0x5a, 0x1e, 0x30, + 0x36, 0x70, 0xe9, 0x8e, 0x9a, 0xf5, 0xc7, 0xa7, 0x3b, 0xf6, 0x98, 0x13, 0xe1, 0x30, 0x4f, 0x7f, + 0xdf, 0xbc, 0xf9, 0x9d, 0x78, 0x93, 0x65, 0xd4, 0xaf, 0x39, 0xf1, 0x7d, 0xca, 0xf5, 0x82, 0xd5, + 0xcb, 0x14, 0x64, 0x0f, 0x99, 0x4d, 0xbb, 0x3e, 0xb5, 0xd0, 0x3e, 0x18, 0xc4, 0xf3, 0x98, 0x50, + 0xba, 0x03, 0x33, 0x59, 0x49, 0x6e, 0x1b, 0xbb, 0x5b, 0xb5, 0x67, 0x7d, 0xaa, 0xd5, 0xa7, 0xb0, + 0x46, 0xea, 0xc9, 0xd5, 0x56, 0x02, 0xcf, 0x32, 0xd1, 0xcf, 0x21, 0x6f, 0xd3, 0xc0, 0xe1, 0xd4, + 0xee, 0x71, 0xe6, 0x52, 0x73, 0xa5, 0x92, 0xdc, 0x5e, 0xdf, 0x7d, 0x63, 0x91, 0x26, 0xb9, 0x38, + 0x66, 0x2e, 0xc5, 0x86, 0x66, 0xc8, 0x09, 0xda, 0x07, 0x18, 0xd1, 0x51, 0x9f, 0xf2, 0x60, 0xe8, + 0xf8, 0xe6, 0xaa, 0xa2, 0xff, 0xdf, 0x32, 0xba, 0xb4, 0xbd, 0xf6, 0x28, 0x86, 0xe3, 0x19, 0x2a, + 0x7a, 0x04, 0x79, 0x72, 0x4e, 0x1c, 0x97, 0xf4, 0x1d, 0xd7, 0x11, 0x13, 0x33, 0xa5, 0x54, 0xbd, + 0xf7, 0x5c, 0x55, 0xf5, 0x19, 0x02, 0x9e, 0xa3, 0x57, 0x6d, 0x80, 0xe9, 0x42, 0xe8, 0x5d, 0xc8, + 0x74, 0x5a, 0x87, 0xcd, 0xf6, 0xe1, 0x7e, 0x31, 0x51, 0xda, 0xbc, 0xb8, 0xac, 0xbc, 0x2a, 0x75, + 0x4c, 0x01, 0x1d, 0xea, 0xd9, 0x8e, 0x37, 0x40, 0xdb, 0x90, 0xad, 0xef, 0xed, 0xb5, 0x3a, 0xc7, + 0xad, 0x66, 0x31, 0x59, 0x2a, 0x5d, 0x5c, 0x56, 0x5e, 0x9b, 0x07, 0xd6, 0x2d, 0x8b, 0xfa, 0x82, + 0xda, 0xa5, 0xd4, 0xb7, 0x7f, 0x2c, 0x27, 0xaa, 0xdf, 0x26, 0x21, 0x3f, 0x6b, 0x04, 0x7a, 0x17, + 0xd2, 0xf5, 0xbd, 0xe3, 0xf6, 0x49, 0xab, 0x98, 0x98, 0xd2, 0x67, 0x11, 0x75, 0x4b, 0x38, 0xe7, + 0x14, 0xdd, 0x87, 0xb5, 0x4e, 0xfd, 0xab, 0x6e, 0xab, 0x98, 0x9c, 0x9a, 0x33, 0x0b, 0xeb, 0x90, + 0x71, 0xa0, 0x50, 0x4d, 0x5c, 0x6f, 0x1f, 0x16, 0x57, 0x16, 0xa3, 0x9a, 0x9c, 0x38, 0x9e, 0x36, + 0xe5, 0xcf, 0x6b, 0x60, 0x74, 0x29, 0x3f, 0x77, 0xac, 0x97, 0x1c, 0x22, 0x1f, 0x41, 0x4a, 0x90, + 0xe0, 0x4c, 0x85, 0x86, 0xb1, 0x38, 0x34, 0x8e, 0x49, 0x70, 0x26, 0x17, 0xd5, 0x74, 0x85, 0x97, + 0x91, 0xc1, 0xa9, 0xef, 0x3a, 0x16, 0x11, 0xd4, 0x56, 0x91, 0x61, 0xec, 0xbe, 0xb3, 0x88, 0x8d, + 0x63, 0x94, 0xb6, 0xff, 0x20, 0x81, 0x67, 0xa8, 0xe8, 0x33, 0x48, 0x0f, 0x5c, 0xd6, 0x27, 0xae, + 0x8a, 0x09, 0x63, 0xf7, 0xad, 0x45, 0x4a, 0xf6, 0x15, 0x62, 0xaa, 0x40, 0x53, 0xd0, 0x97, 0xb0, + 0x3e, 0x55, 0xd5, 0xfb, 0x0d, 0xeb, 0x9b, 0xb0, 0x5c, 0xc9, 0xd4, 0x92, 0x2f, 0x59, 0xff, 0x20, + 0x81, 0x0b, 0x7c, 0x56, 0x80, 0x7e, 0x06, 0x10, 0x6a, 0x55, 0x7a, 0x0c, 0xa5, 0xe7, 0xcd, 0xe5, + 0xc6, 0x84, 0x3a, 0x72, 0x83, 0x68, 0x82, 0x3e, 0x86, 0xf4, 0xd8, 0xb7, 0x89, 0xa0, 0x66, 0x5a, + 0x71, 0x2b, 0x8b, 0xb8, 0x5f, 0x29, 0xc4, 0x1e, 0xf3, 0x4e, 0x9d, 0x01, 0xd6, 0x78, 0xf4, 0x53, + 0xc8, 0x72, 0xe6, 0xba, 0x7d, 0x62, 0x9d, 0x99, 0xb9, 0x17, 0xe4, 0xc6, 0x0c, 0xf4, 0x00, 0xb2, + 0x1e, 0x15, 0x5f, 0x33, 0x7e, 0x16, 0x98, 0x99, 0xca, 0xea, 0xb6, 0xb1, 0xfb, 0xc1, 0xc2, 0xb4, + 0x0a, 0x31, 0x75, 0x21, 0x88, 0x35, 0x1c, 0x51, 0x4f, 0x84, 0x8a, 0x1a, 0x2b, 0x66, 0x12, 0xc7, + 0x0a, 0xa4, 0x29, 0xd4, 0xb3, 0x7d, 0xe6, 0x78, 0xc2, 0xcc, 0x2e, 0x37, 0xa5, 0xa5, 0x31, 0x32, + 0x2c, 0x70, 0xcc, 0x68, 0xa4, 0x21, 0x35, 0x62, 0x36, 0xad, 0xee, 0xc0, 0xc6, 0x33, 0xc7, 0x8e, + 0x4a, 0x90, 0xd5, 0x1b, 0x1e, 0xc6, 0x6b, 0x0a, 0xc7, 0xf3, 0xea, 0x1d, 0x28, 0xcc, 0x1d, 0x71, + 0xd5, 0x82, 0xc2, 0xdc, 0x71, 0xa1, 0x77, 0x60, 0x7d, 0x44, 0xbe, 0xe9, 0x59, 0xcc, 0xb3, 0xc6, + 0x9c, 0x53, 0x4f, 0x68, 0x1d, 0x85, 0x11, 0xf9, 0x66, 0x2f, 0x16, 0xa2, 0x0f, 0x60, 0x43, 0x30, + 0x41, 0xdc, 0x9e, 0xc5, 0x46, 0xbe, 0x4b, 0xc3, 0xec, 0x58, 0x51, 0xc8, 0xa2, 0xfa, 0xb0, 0x37, + 0x95, 0x57, 0x0d, 0xc8, 0xc5, 0x67, 0x59, 0xfd, 0xcb, 0x1a, 0x64, 0xa3, 0x48, 0x47, 0x0f, 0x00, + 0x48, 0xbc, 0x51, 0x7a, 0x23, 0xde, 0x7b, 0xa1, 0x5d, 0x95, 0x74, 0x19, 0xe1, 0x53, 0x3a, 0xaa, + 0x43, 0xce, 0x62, 0x9e, 0x20, 0x8e, 0x47, 0xb9, 0xce, 0xd4, 0x85, 0xf1, 0xb9, 0x17, 0x81, 0xb4, + 0x8e, 0x29, 0x0b, 0x35, 0x20, 0x33, 0xa0, 0x1e, 0xe5, 0x8e, 0xa5, 0x03, 0xfc, 0xdd, 0x85, 0x81, + 0x19, 0x42, 0xf0, 0xd8, 0x13, 0xce, 0x88, 0x6a, 0x2d, 0x11, 0x11, 0x7d, 0x01, 0x39, 0x4e, 0x03, + 0x36, 0xe6, 0x16, 0x0d, 0x74, 0xba, 0x6f, 0x2f, 0x4e, 0x93, 0x10, 0x84, 0xe9, 0x6f, 0xc7, 0x0e, + 0xa7, 0xd2, 0x85, 0x00, 0x4f, 0xa9, 0xe8, 0x33, 0xc8, 0x70, 0x1a, 0x08, 0xc2, 0xc5, 0xf3, 0x32, + 0x16, 0x87, 0x90, 0x0e, 0x73, 0x1d, 0x6b, 0x82, 0x23, 0x06, 0xfa, 0x0c, 0x72, 0xbe, 0x4b, 0x2c, + 0xa5, 0xd5, 0x5c, 0x5b, 0x9e, 0x63, 0x9d, 0x08, 0x84, 0xa7, 0x78, 0xf4, 0x09, 0x80, 0xcb, 0x06, + 0x3d, 0x9b, 0x3b, 0xe7, 0x94, 0xeb, 0x2c, 0x2b, 0x2d, 0x62, 0x37, 0x15, 0x02, 0xe7, 0x5c, 0x36, + 0x08, 0x87, 0x68, 0xff, 0xbf, 0x4a, 0x92, 0x99, 0x04, 0x79, 0x0b, 0xf2, 0xa7, 0x8c, 0x5b, 0xb4, + 0xa7, 0x73, 0x3d, 0xa7, 0x62, 0xcb, 0x50, 0xb2, 0x30, 0x41, 0xd1, 0xaf, 0xe1, 0x95, 0x68, 0xb7, + 0x7a, 0x9c, 0x9e, 0x52, 0x4e, 0x3d, 0xb9, 0xe5, 0x86, 0x5a, 0xf6, 0x9d, 0xe7, 0x6f, 0xb9, 0x46, + 0xeb, 0x52, 0x8b, 0xf8, 0xcd, 0x0f, 0x41, 0x23, 0x07, 0x19, 0x1e, 0x1e, 0x70, 0xf5, 0xf7, 0x49, + 0x99, 0x67, 0x37, 0x10, 0x68, 0x07, 0x8c, 0x78, 0x79, 0xc7, 0x56, 0x01, 0x97, 0x6b, 0xac, 0x5f, + 0x5f, 0x6d, 0x41, 0x84, 0x6d, 0x37, 0x65, 0x05, 0xd6, 0x63, 0x1b, 0xb5, 0xa0, 0x10, 0x13, 0x64, + 0x13, 0xa4, 0xdb, 0x84, 0xca, 0xf3, 0x2c, 0x3d, 0x9e, 0xf8, 0x14, 0xe7, 0xf9, 0xcc, 0xac, 0xfa, + 0x2b, 0x40, 0xcf, 0x06, 0x20, 0x42, 0x90, 0x3a, 0x73, 0x3c, 0x6d, 0x06, 0x56, 0x63, 0x54, 0x83, + 0x8c, 0x4f, 0x26, 0x2e, 0x23, 0xb6, 0x8e, 0xc3, 0xbb, 0xb5, 0xb0, 0x3d, 0xaa, 0x45, 0xed, 0x51, + 0xad, 0xee, 0x4d, 0x70, 0x04, 0xaa, 0x3e, 0x80, 0x57, 0x17, 0xe6, 0x19, 0xda, 0x85, 0x7c, 0x9c, + 0x23, 0x53, 0x5f, 0xef, 0x5c, 0x5f, 0x6d, 0x19, 0x71, 0x32, 0xb5, 0x9b, 0xd8, 0x88, 0x41, 0x6d, + 0xbb, 0x7a, 0x51, 0x80, 0xc2, 0x5c, 0xa6, 0xa1, 0xbb, 0xb0, 0xe6, 0x8c, 0xc8, 0x80, 0x6a, 0x1b, + 0xc3, 0x09, 0x6a, 0x41, 0xda, 0x25, 0x7d, 0xea, 0xca, 0x5c, 0x91, 0x07, 0xf7, 0xff, 0xb7, 0xa6, + 0x6c, 0xed, 0xa1, 0xc2, 0xb7, 0x3c, 0xc1, 0x27, 0x58, 0x93, 0x91, 0x09, 0x19, 0x8b, 0x8d, 0x46, + 0xc4, 0x93, 0x97, 0xe4, 0xea, 0x76, 0x0e, 0x47, 0x53, 0xb9, 0x33, 0x84, 0x0f, 0x02, 0x33, 0xa5, + 0xc4, 0x6a, 0x2c, 0x6b, 0xe4, 0x90, 0x05, 0xc2, 0x23, 0x23, 0x6a, 0xae, 0x2b, 0x6b, 0xe2, 0x39, + 0x2a, 0xc2, 0x2a, 0xf5, 0xce, 0xcd, 0x35, 0x05, 0x97, 0x43, 0x29, 0xb1, 0x9d, 0x30, 0x11, 0x72, + 0x58, 0x0e, 0xa5, 0xce, 0x71, 0x40, 0xb9, 0x99, 0x09, 0x77, 0x5b, 0x8e, 0xd1, 0x6b, 0x90, 0x1e, + 0x70, 0x36, 0xf6, 0xc3, 0x08, 0xcc, 0x61, 0x3d, 0x93, 0xf7, 0x9d, 0xcf, 0x9d, 0x73, 0xc7, 0xa5, + 0x03, 0x1a, 0x98, 0xaf, 0xa9, 0x83, 0x28, 0x2f, 0xcc, 0xc5, 0x18, 0x85, 0x67, 0x18, 0xa8, 0x06, + 0x29, 0xc7, 0x73, 0x84, 0xf9, 0xba, 0xce, 0xc3, 0x9b, 0x47, 0xd8, 0x60, 0xcc, 0x3d, 0x21, 0xee, + 0x98, 0x62, 0x85, 0x43, 0x9b, 0xb0, 0x2a, 0xc4, 0xc4, 0x2c, 0x54, 0x92, 0xdb, 0xd9, 0x46, 0xe6, + 0xfa, 0x6a, 0x6b, 0xf5, 0xf8, 0xf8, 0x31, 0x96, 0x32, 0xf4, 0x26, 0x00, 0xf3, 0xa9, 0xd7, 0x0b, + 0x84, 0xed, 0x78, 0x26, 0x92, 0x08, 0x9c, 0x93, 0x92, 0xae, 0x14, 0xa0, 0x7b, 0xb2, 0x72, 0x11, + 0xbb, 0xc7, 0x3c, 0x77, 0x62, 0xbe, 0xa2, 0xbe, 0x66, 0xa5, 0xe0, 0xc8, 0x73, 0x27, 0x68, 0x0b, + 0x8c, 0x40, 0x30, 0xbf, 0x17, 0x38, 0x03, 0x8f, 0xb8, 0xe6, 0x5d, 0xe5, 0x39, 0x48, 0x51, 0x57, + 0x49, 0xd0, 0x4f, 0x20, 0x3d, 0x62, 0x63, 0x4f, 0x04, 0x66, 0x56, 0x1d, 0xe4, 0xe6, 0x22, 0x1f, + 0x1f, 0x49, 0x84, 0xce, 0x3a, 0x0d, 0x47, 0x2d, 0xd8, 0x50, 0x9a, 0x07, 0x9c, 0x58, 0xb4, 0xe7, + 0x53, 0xee, 0x30, 0x5b, 0xdf, 0xcf, 0x9b, 0xcf, 0x78, 0xdb, 0xd4, 0x4f, 0x01, 0x7c, 0x47, 0x72, + 0xf6, 0x25, 0xa5, 0xa3, 0x18, 0xa8, 0x03, 0x79, 0x7f, 0xec, 0xba, 0x3d, 0xe6, 0x87, 0xb7, 0x51, + 0x58, 0xc0, 0x5f, 0x20, 0x9c, 0x3a, 0x63, 0xd7, 0x3d, 0x0a, 0x49, 0xd8, 0xf0, 0xa7, 0x13, 0xf4, + 0x39, 0x64, 0x02, 0x6a, 0x71, 0x2a, 0x02, 0x33, 0xaf, 0x5c, 0x7a, 0x7b, 0x91, 0xb2, 0xae, 0x82, + 0xc4, 0x75, 0x01, 0x47, 0x1c, 0x49, 0xb7, 0x54, 0x59, 0x0b, 0xcc, 0x57, 0x97, 0xd3, 0x75, 0xe5, + 0x9b, 0xd2, 0x35, 0x47, 0xa6, 0x8b, 0x8c, 0xc9, 0xc0, 0xdc, 0x50, 0xe1, 0x14, 0x4e, 0xd0, 0x63, + 0x00, 0xdb, 0x0b, 0x7a, 0x21, 0xc8, 0xbc, 0xa3, 0x7c, 0xfc, 0xe0, 0x76, 0x1f, 0x9b, 0x87, 0x5d, + 0xdd, 0x87, 0x14, 0xae, 0xaf, 0xb6, 0x72, 0xf1, 0x14, 0xe7, 0x6c, 0x2f, 0x08, 0x87, 0xa8, 0x01, + 0xc6, 0x90, 0x12, 0x57, 0x0c, 0xad, 0x21, 0xb5, 0xce, 0xcc, 0xe2, 0xf2, 0xb6, 0xe4, 0x40, 0xc1, + 0xb4, 0x86, 0x59, 0x12, 0x6a, 0x43, 0xce, 0x09, 0x98, 0xab, 0x8e, 0xc8, 0x34, 0x55, 0x7d, 0x7b, + 0x01, 0xeb, 0xda, 0x11, 0x05, 0x4f, 0xd9, 0xe8, 0x0d, 0xc8, 0xf9, 0x8e, 0x1d, 0x3c, 0x74, 0x46, + 0x8e, 0x30, 0x37, 0x2b, 0xc9, 0xed, 0x55, 0x3c, 0x15, 0xa0, 0x03, 0xc8, 0x04, 0x93, 0xc0, 0x12, + 0x6e, 0x60, 0x96, 0xd4, 0xe6, 0xd6, 0x6e, 0x5f, 0xa6, 0x1b, 0x12, 0xc2, 0xc2, 0x11, 0xd1, 0x51, + 0x15, 0xf2, 0x16, 0xf1, 0xc3, 0xb7, 0x80, 0x43, 0x03, 0xf3, 0x9e, 0xda, 0xee, 0x39, 0x59, 0xe9, + 0x13, 0x30, 0x66, 0x8a, 0x8e, 0x2c, 0x08, 0x67, 0x74, 0xa2, 0xeb, 0x98, 0x1c, 0xca, 0xc3, 0x3a, + 0x97, 0x39, 0xa8, 0x0a, 0x6d, 0x0e, 0x87, 0x93, 0x4f, 0x57, 0x3e, 0x4e, 0x96, 0x76, 0xc1, 0x98, + 0x09, 0x30, 0xf4, 0xb6, 0xbc, 0x04, 0x06, 0x4e, 0x20, 0xf8, 0xa4, 0x47, 0xc6, 0x62, 0x68, 0xfe, + 0x42, 0x11, 0xf2, 0x91, 0xb0, 0x3e, 0x16, 0xc3, 0x52, 0x0f, 0xa6, 0x27, 0x84, 0x2a, 0x60, 0xc8, + 0xba, 0x14, 0x50, 0x7e, 0x4e, 0xb9, 0x6c, 0xe9, 0xa4, 0x79, 0xb3, 0x22, 0x59, 0x79, 0x02, 0x4a, + 0xb8, 0x35, 0x54, 0x25, 0x34, 0x87, 0xf5, 0x4c, 0xd6, 0xc4, 0x28, 0x19, 0x74, 0x4d, 0xd4, 0xd3, + 0xd2, 0xa7, 0x90, 0x9f, 0xdd, 0x8c, 0xff, 0xc4, 0xa1, 0xea, 0x5f, 0x93, 0x90, 0x8b, 0x0f, 0x0c, + 0x7d, 0x08, 0x1b, 0xed, 0xee, 0xd1, 0xc3, 0xfa, 0x71, 0xfb, 0xe8, 0xb0, 0xd7, 0x6c, 0x7d, 0x51, + 0xff, 0xea, 0xe1, 0x71, 0x31, 0x51, 0x7a, 0xf3, 0xe2, 0xb2, 0xb2, 0x39, 0xbd, 0x1b, 0x22, 0x78, + 0x93, 0x9e, 0x92, 0xb1, 0x2b, 0xe6, 0x59, 0x1d, 0x7c, 0xb4, 0xd7, 0xea, 0x76, 0x8b, 0xc9, 0x65, + 0xac, 0x0e, 0x67, 0x16, 0x0d, 0x02, 0xb4, 0x0b, 0xc5, 0x29, 0xeb, 0xe0, 0x71, 0xa7, 0x85, 0x4f, + 0x8a, 0x2b, 0xa5, 0x37, 0x2e, 0x2e, 0x2b, 0xe6, 0xb3, 0xa4, 0x83, 0x89, 0x4f, 0xf9, 0x89, 0x7e, + 0xd6, 0xfd, 0x23, 0x09, 0xf9, 0xd9, 0x5e, 0x1a, 0xed, 0x85, 0x1d, 0xb4, 0xf2, 0x78, 0x7d, 0x77, + 0xe7, 0xb6, 0xde, 0x5b, 0xdd, 0xc7, 0xee, 0x58, 0xea, 0x7d, 0x24, 0x1f, 0xf0, 0x8a, 0x8c, 0x3e, + 0x84, 0x35, 0x9f, 0x71, 0x11, 0xdd, 0x5c, 0x8b, 0x8b, 0x3a, 0xe3, 0x51, 0x73, 0x13, 0x82, 0xab, + 0x43, 0x58, 0x9f, 0xd7, 0x86, 0xee, 0xc3, 0xea, 0x49, 0xbb, 0x53, 0x4c, 0x94, 0xee, 0x5d, 0x5c, + 0x56, 0x5e, 0x9f, 0xff, 0x78, 0xe2, 0x70, 0x31, 0x26, 0x6e, 0xbb, 0x83, 0xde, 0x87, 0xb5, 0xe6, + 0x61, 0x17, 0xe3, 0x62, 0xb2, 0xb4, 0x75, 0x71, 0x59, 0xb9, 0x37, 0x8f, 0x93, 0x9f, 0xd8, 0xd8, + 0xb3, 0x31, 0xeb, 0xc7, 0x8f, 0xd9, 0x7f, 0xae, 0x80, 0xa1, 0x2f, 0xf4, 0x97, 0xfd, 0xbf, 0xa3, + 0x10, 0x36, 0x87, 0x51, 0x1d, 0x5a, 0xb9, 0xb5, 0x47, 0xcc, 0x87, 0x04, 0x1d, 0xd3, 0x6f, 0x41, + 0xde, 0xf1, 0xcf, 0x3f, 0xea, 0x51, 0x8f, 0xf4, 0x5d, 0xfd, 0xae, 0xcd, 0x62, 0x43, 0xca, 0x5a, + 0xa1, 0x48, 0x5e, 0xd1, 0x8e, 0x27, 0x28, 0xf7, 0xf4, 0x8b, 0x35, 0x8b, 0xe3, 0x39, 0xfa, 0x1c, + 0x52, 0x8e, 0x4f, 0x46, 0xba, 0xb1, 0x5d, 0xe8, 0x41, 0xbb, 0x53, 0x7f, 0xa4, 0x73, 0xae, 0x91, + 0xbd, 0xbe, 0xda, 0x4a, 0x49, 0x01, 0x56, 0x34, 0x54, 0x8e, 0x5e, 0x1d, 0x72, 0x25, 0x75, 0xad, + 0x67, 0xf1, 0x8c, 0x44, 0xe6, 0x8d, 0xe3, 0x0d, 0x38, 0x0d, 0x02, 0x75, 0xc1, 0x67, 0x71, 0x34, + 0x45, 0x25, 0xc8, 0xe8, 0x0e, 0x55, 0x3d, 0x56, 0x72, 0xb2, 0xef, 0xd7, 0x82, 0x46, 0x01, 0x8c, + 0x70, 0x37, 0x7a, 0xa7, 0x9c, 0x8d, 0xaa, 0xff, 0x4a, 0x81, 0xb1, 0xe7, 0x8e, 0x03, 0xa1, 0xbb, + 0x9f, 0x97, 0xb6, 0xf9, 0x8f, 0x61, 0x83, 0xa8, 0xff, 0x27, 0xc4, 0x93, 0xd7, 0xa5, 0x6a, 0xfc, + 0xf5, 0x01, 0xdc, 0x5f, 0xa8, 0x2e, 0x06, 0x87, 0x8f, 0x84, 0x46, 0x5a, 0xea, 0x34, 0x93, 0xb8, + 0x48, 0x6e, 0x7c, 0x41, 0x5d, 0x28, 0x30, 0x6e, 0x0d, 0x69, 0x20, 0xc2, 0x4b, 0x56, 0xff, 0x6f, + 0x58, 0xf8, 0x27, 0xea, 0x68, 0x16, 0xa8, 0xef, 0x96, 0xd0, 0xda, 0x79, 0x1d, 0xe8, 0x63, 0x48, + 0x71, 0x72, 0x1a, 0x3d, 0x62, 0x16, 0x26, 0x09, 0x26, 0xa7, 0x62, 0x4e, 0x85, 0x62, 0xa0, 0x2f, + 0x01, 0x6c, 0x27, 0xf0, 0x89, 0xb0, 0x86, 0x94, 0xeb, 0xc3, 0x5e, 0xe8, 0x62, 0x33, 0x46, 0xcd, + 0x69, 0x99, 0x61, 0xa3, 0x07, 0x90, 0xb3, 0x48, 0x14, 0xae, 0xe9, 0xe5, 0x3f, 0x61, 0xf6, 0xea, + 0x5a, 0x45, 0x51, 0xaa, 0xb8, 0xbe, 0xda, 0xca, 0x46, 0x12, 0x9c, 0xb5, 0x88, 0x0e, 0xdf, 0x07, + 0x50, 0x10, 0x24, 0x38, 0xeb, 0xd9, 0x61, 0x39, 0x0b, 0xc3, 0x64, 0xc9, 0x5d, 0x29, 0xdf, 0xba, + 0xba, 0xec, 0x45, 0xc7, 0x99, 0x17, 0x33, 0x32, 0xf4, 0x4b, 0xd8, 0xa0, 0x9e, 0xc5, 0x27, 0x2a, + 0x58, 0x23, 0x0b, 0xb3, 0xcb, 0x9d, 0x6d, 0xc5, 0xe0, 0x39, 0x67, 0x8b, 0xf4, 0x86, 0xbc, 0xfa, + 0xb7, 0x24, 0x40, 0xd8, 0x9c, 0xbc, 0xdc, 0x00, 0x44, 0x90, 0xb2, 0x89, 0x20, 0x2a, 0xe6, 0xf2, + 0x58, 0x8d, 0xd1, 0xa7, 0x00, 0x82, 0x8e, 0x7c, 0x59, 0x7a, 0xbd, 0x81, 0x0e, 0x9b, 0xe7, 0x95, + 0x83, 0x19, 0x34, 0xda, 0x85, 0xb4, 0x7e, 0x6a, 0xa6, 0x6e, 0xe5, 0x69, 0x64, 0xf5, 0x4f, 0x49, + 0x80, 0xd0, 0xcd, 0xff, 0x69, 0xdf, 0x1a, 0xf7, 0x9f, 0xfc, 0x50, 0x4e, 0x7c, 0xff, 0x43, 0x39, + 0xf1, 0xbb, 0xeb, 0x72, 0xf2, 0xc9, 0x75, 0x39, 0xf9, 0xdd, 0x75, 0x39, 0xf9, 0xf7, 0xeb, 0x72, + 0xf2, 0x0f, 0x4f, 0xcb, 0x89, 0xef, 0x9e, 0x96, 0x13, 0xdf, 0x3f, 0x2d, 0x27, 0xfa, 0x69, 0xd5, + 0xde, 0xfe, 0xf8, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x91, 0x6d, 0x50, 0x31, 0x7b, 0x17, 0x00, 0x00, } @@ -1561,6 +1713,18 @@ func (m *ServiceSpec) CopyFrom(src interface{}) { } github_com_docker_swarmkit_api_deepcopy.Copy(v.Global, o.GetGlobal()) m.Mode = &v + case *ServiceSpec_ReplicatedJob: + v := ServiceSpec_ReplicatedJob{ + ReplicatedJob: &ReplicatedJob{}, + } + github_com_docker_swarmkit_api_deepcopy.Copy(v.ReplicatedJob, o.GetReplicatedJob()) + m.Mode = &v + case *ServiceSpec_GlobalJob: + v := ServiceSpec_GlobalJob{ + GlobalJob: &GlobalJob{}, + } + github_com_docker_swarmkit_api_deepcopy.Copy(v.GlobalJob, o.GetGlobalJob()) + m.Mode = &v } } @@ -1591,6 +1755,31 @@ func (m *GlobalService) Copy() *GlobalService { } func (m *GlobalService) CopyFrom(src interface{}) {} +func (m *ReplicatedJob) Copy() *ReplicatedJob { + if m == nil { + return nil + } + o := &ReplicatedJob{} + o.CopyFrom(m) + return o +} + +func (m *ReplicatedJob) CopyFrom(src interface{}) { + + o := src.(*ReplicatedJob) + *m = *o +} + +func (m *GlobalJob) Copy() *GlobalJob { + if m == nil { + return nil + } + o := &GlobalJob{} + o.CopyFrom(m) + return o +} + +func (m *GlobalJob) CopyFrom(src interface{}) {} func (m *TaskSpec) Copy() *TaskSpec { if m == nil { return nil @@ -2144,6 +2333,34 @@ func (m *ServiceSpec_Global) MarshalTo(dAtA []byte) (int, error) { } return i, nil } +func (m *ServiceSpec_ReplicatedJob) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.ReplicatedJob != nil { + dAtA[i] = 0x52 + i++ + i = encodeVarintSpecs(dAtA, i, uint64(m.ReplicatedJob.Size())) + n10, err := m.ReplicatedJob.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n10 + } + return i, nil +} +func (m *ServiceSpec_GlobalJob) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.GlobalJob != nil { + dAtA[i] = 0x5a + i++ + i = encodeVarintSpecs(dAtA, i, uint64(m.GlobalJob.Size())) + n11, err := m.GlobalJob.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n11 + } + return i, nil +} func (m *ReplicatedService) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2185,6 +2402,52 @@ func (m *GlobalService) MarshalTo(dAtA []byte) (int, error) { return i, nil } +func (m *ReplicatedJob) 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 *ReplicatedJob) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.MaxConcurrent != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintSpecs(dAtA, i, uint64(m.MaxConcurrent)) + } + if m.TotalCompletions != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintSpecs(dAtA, i, uint64(m.TotalCompletions)) + } + return i, nil +} + +func (m *GlobalJob) 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 *GlobalJob) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + func (m *TaskSpec) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2201,52 +2464,52 @@ func (m *TaskSpec) MarshalTo(dAtA []byte) (int, error) { var l int _ = l if m.Runtime != nil { - nn10, err := m.Runtime.MarshalTo(dAtA[i:]) + nn12, err := m.Runtime.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += nn10 + i += nn12 } if m.Resources != nil { dAtA[i] = 0x12 i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Resources.Size())) - n11, err := m.Resources.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n11 - } - if m.Restart != nil { - dAtA[i] = 0x22 - i++ - i = encodeVarintSpecs(dAtA, i, uint64(m.Restart.Size())) - n12, err := m.Restart.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n12 - } - if m.Placement != nil { - dAtA[i] = 0x2a - i++ - i = encodeVarintSpecs(dAtA, i, uint64(m.Placement.Size())) - n13, err := m.Placement.MarshalTo(dAtA[i:]) + n13, err := m.Resources.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n13 } - if m.LogDriver != nil { - dAtA[i] = 0x32 + if m.Restart != nil { + dAtA[i] = 0x22 i++ - i = encodeVarintSpecs(dAtA, i, uint64(m.LogDriver.Size())) - n14, err := m.LogDriver.MarshalTo(dAtA[i:]) + i = encodeVarintSpecs(dAtA, i, uint64(m.Restart.Size())) + n14, err := m.Restart.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n14 } + if m.Placement != nil { + dAtA[i] = 0x2a + i++ + i = encodeVarintSpecs(dAtA, i, uint64(m.Placement.Size())) + n15, err := m.Placement.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n15 + } + if m.LogDriver != nil { + dAtA[i] = 0x32 + i++ + i = encodeVarintSpecs(dAtA, i, uint64(m.LogDriver.Size())) + n16, err := m.LogDriver.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n16 + } if len(m.Networks) > 0 { for _, msg := range m.Networks { dAtA[i] = 0x3a @@ -2285,11 +2548,11 @@ func (m *TaskSpec_Container) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Container.Size())) - n15, err := m.Container.MarshalTo(dAtA[i:]) + n17, err := m.Container.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n15 + i += n17 } return i, nil } @@ -2299,11 +2562,11 @@ func (m *TaskSpec_Attachment) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x42 i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Attachment.Size())) - n16, err := m.Attachment.MarshalTo(dAtA[i:]) + n18, err := m.Attachment.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n16 + i += n18 } return i, nil } @@ -2313,11 +2576,11 @@ func (m *TaskSpec_Generic) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x52 i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Generic.Size())) - n17, err := m.Generic.MarshalTo(dAtA[i:]) + n19, err := m.Generic.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n17 + i += n19 } return i, nil } @@ -2375,11 +2638,11 @@ func (m *GenericRuntimeSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x12 i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Payload.Size())) - n18, err := m.Payload.MarshalTo(dAtA[i:]) + n20, err := m.Payload.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n18 + i += n20 } return i, nil } @@ -2519,21 +2782,21 @@ func (m *ContainerSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x4a i++ i = encodeVarintSpecs(dAtA, i, uint64(m.StopGracePeriod.Size())) - n19, err := m.StopGracePeriod.MarshalTo(dAtA[i:]) + n21, err := m.StopGracePeriod.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n19 + i += n21 } if m.PullOptions != nil { dAtA[i] = 0x52 i++ i = encodeVarintSpecs(dAtA, i, uint64(m.PullOptions.Size())) - n20, err := m.PullOptions.MarshalTo(dAtA[i:]) + n22, err := m.PullOptions.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n20 + i += n22 } if len(m.Groups) > 0 { for _, s := range m.Groups { @@ -2582,11 +2845,11 @@ func (m *ContainerSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x7a i++ i = encodeVarintSpecs(dAtA, i, uint64(m.DNSConfig.Size())) - n21, err := m.DNSConfig.MarshalTo(dAtA[i:]) + n23, err := m.DNSConfig.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n21 + i += n23 } if m.Healthcheck != nil { dAtA[i] = 0x82 @@ -2594,11 +2857,11 @@ func (m *ContainerSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x1 i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Healthcheck.Size())) - n22, err := m.Healthcheck.MarshalTo(dAtA[i:]) + n24, err := m.Healthcheck.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n22 + i += n24 } if len(m.Hosts) > 0 { for _, s := range m.Hosts { @@ -2669,11 +2932,11 @@ func (m *ContainerSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x1 i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Privileges.Size())) - n23, err := m.Privileges.MarshalTo(dAtA[i:]) + n25, err := m.Privileges.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n23 + i += n25 } if m.Init != nil { dAtA[i] = 0xba @@ -2681,11 +2944,11 @@ func (m *ContainerSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x1 i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Init.Size())) - n24, err := m.Init.MarshalTo(dAtA[i:]) + n26, err := m.Init.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n24 + i += n26 } if m.Isolation != 0 { dAtA[i] = 0xc0 @@ -2882,20 +3145,20 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size())) - n25, err := m.Annotations.MarshalTo(dAtA[i:]) + n27, err := m.Annotations.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n25 + i += n27 if m.DriverConfig != nil { dAtA[i] = 0x12 i++ i = encodeVarintSpecs(dAtA, i, uint64(m.DriverConfig.Size())) - n26, err := m.DriverConfig.MarshalTo(dAtA[i:]) + n28, err := m.DriverConfig.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n26 + i += n28 } if m.Ipv6Enabled { dAtA[i] = 0x18 @@ -2921,11 +3184,11 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x2a i++ i = encodeVarintSpecs(dAtA, i, uint64(m.IPAM.Size())) - n27, err := m.IPAM.MarshalTo(dAtA[i:]) + n29, err := m.IPAM.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n27 + i += n29 } if m.Attachable { dAtA[i] = 0x30 @@ -2948,11 +3211,11 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) { i++ } if m.ConfigFrom != nil { - nn28, err := m.ConfigFrom.MarshalTo(dAtA[i:]) + nn30, err := m.ConfigFrom.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += nn28 + i += nn30 } return i, nil } @@ -2983,67 +3246,67 @@ func (m *ClusterSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size())) - n29, err := m.Annotations.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n29 - dAtA[i] = 0x12 - i++ - i = encodeVarintSpecs(dAtA, i, uint64(m.AcceptancePolicy.Size())) - n30, err := m.AcceptancePolicy.MarshalTo(dAtA[i:]) - if err != nil { - return 0, err - } - i += n30 - dAtA[i] = 0x1a - i++ - i = encodeVarintSpecs(dAtA, i, uint64(m.Orchestration.Size())) - n31, err := m.Orchestration.MarshalTo(dAtA[i:]) + n31, err := m.Annotations.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n31 - dAtA[i] = 0x22 + dAtA[i] = 0x12 i++ - i = encodeVarintSpecs(dAtA, i, uint64(m.Raft.Size())) - n32, err := m.Raft.MarshalTo(dAtA[i:]) + i = encodeVarintSpecs(dAtA, i, uint64(m.AcceptancePolicy.Size())) + n32, err := m.AcceptancePolicy.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n32 - dAtA[i] = 0x2a + dAtA[i] = 0x1a i++ - i = encodeVarintSpecs(dAtA, i, uint64(m.Dispatcher.Size())) - n33, err := m.Dispatcher.MarshalTo(dAtA[i:]) + i = encodeVarintSpecs(dAtA, i, uint64(m.Orchestration.Size())) + n33, err := m.Orchestration.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n33 - dAtA[i] = 0x32 + dAtA[i] = 0x22 i++ - i = encodeVarintSpecs(dAtA, i, uint64(m.CAConfig.Size())) - n34, err := m.CAConfig.MarshalTo(dAtA[i:]) + i = encodeVarintSpecs(dAtA, i, uint64(m.Raft.Size())) + n34, err := m.Raft.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n34 - dAtA[i] = 0x3a + dAtA[i] = 0x2a i++ - i = encodeVarintSpecs(dAtA, i, uint64(m.TaskDefaults.Size())) - n35, err := m.TaskDefaults.MarshalTo(dAtA[i:]) + i = encodeVarintSpecs(dAtA, i, uint64(m.Dispatcher.Size())) + n35, err := m.Dispatcher.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n35 - dAtA[i] = 0x42 + dAtA[i] = 0x32 i++ - i = encodeVarintSpecs(dAtA, i, uint64(m.EncryptionConfig.Size())) - n36, err := m.EncryptionConfig.MarshalTo(dAtA[i:]) + i = encodeVarintSpecs(dAtA, i, uint64(m.CAConfig.Size())) + n36, err := m.CAConfig.MarshalTo(dAtA[i:]) if err != nil { return 0, err } i += n36 + dAtA[i] = 0x3a + i++ + i = encodeVarintSpecs(dAtA, i, uint64(m.TaskDefaults.Size())) + n37, err := m.TaskDefaults.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n37 + dAtA[i] = 0x42 + i++ + i = encodeVarintSpecs(dAtA, i, uint64(m.EncryptionConfig.Size())) + n38, err := m.EncryptionConfig.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n38 return i, nil } @@ -3065,11 +3328,11 @@ func (m *SecretSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size())) - n37, err := m.Annotations.MarshalTo(dAtA[i:]) + n39, err := m.Annotations.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n37 + i += n39 if len(m.Data) > 0 { dAtA[i] = 0x12 i++ @@ -3080,21 +3343,21 @@ func (m *SecretSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x1a i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Templating.Size())) - n38, err := m.Templating.MarshalTo(dAtA[i:]) + n40, err := m.Templating.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n38 + i += n40 } if m.Driver != nil { dAtA[i] = 0x22 i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Driver.Size())) - n39, err := m.Driver.MarshalTo(dAtA[i:]) + n41, err := m.Driver.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n39 + i += n41 } return i, nil } @@ -3117,11 +3380,11 @@ func (m *ConfigSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0xa i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size())) - n40, err := m.Annotations.MarshalTo(dAtA[i:]) + n42, err := m.Annotations.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n40 + i += n42 if len(m.Data) > 0 { dAtA[i] = 0x12 i++ @@ -3132,11 +3395,11 @@ func (m *ConfigSpec) MarshalTo(dAtA []byte) (int, error) { dAtA[i] = 0x1a i++ i = encodeVarintSpecs(dAtA, i, uint64(m.Templating.Size())) - n41, err := m.Templating.MarshalTo(dAtA[i:]) + n43, err := m.Templating.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i += n41 + i += n43 } return i, nil } @@ -3228,6 +3491,30 @@ func (m *ServiceSpec_Global) Size() (n int) { } return n } +func (m *ServiceSpec_ReplicatedJob) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ReplicatedJob != nil { + l = m.ReplicatedJob.Size() + n += 1 + l + sovSpecs(uint64(l)) + } + return n +} +func (m *ServiceSpec_GlobalJob) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.GlobalJob != nil { + l = m.GlobalJob.Size() + n += 1 + l + sovSpecs(uint64(l)) + } + return n +} func (m *ReplicatedService) Size() (n int) { if m == nil { return 0 @@ -3249,6 +3536,30 @@ func (m *GlobalService) Size() (n int) { return n } +func (m *ReplicatedJob) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MaxConcurrent != 0 { + n += 1 + sovSpecs(uint64(m.MaxConcurrent)) + } + if m.TotalCompletions != 0 { + n += 1 + sovSpecs(uint64(m.TotalCompletions)) + } + return n +} + +func (m *GlobalJob) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func (m *TaskSpec) Size() (n int) { if m == nil { return 0 @@ -3743,6 +4054,26 @@ func (this *ServiceSpec_Global) String() string { }, "") return s } +func (this *ServiceSpec_ReplicatedJob) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ServiceSpec_ReplicatedJob{`, + `ReplicatedJob:` + strings.Replace(fmt.Sprintf("%v", this.ReplicatedJob), "ReplicatedJob", "ReplicatedJob", 1) + `,`, + `}`, + }, "") + return s +} +func (this *ServiceSpec_GlobalJob) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ServiceSpec_GlobalJob{`, + `GlobalJob:` + strings.Replace(fmt.Sprintf("%v", this.GlobalJob), "GlobalJob", "GlobalJob", 1) + `,`, + `}`, + }, "") + return s +} func (this *ReplicatedService) String() string { if this == nil { return "nil" @@ -3762,6 +4093,26 @@ func (this *GlobalService) String() string { }, "") return s } +func (this *ReplicatedJob) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ReplicatedJob{`, + `MaxConcurrent:` + fmt.Sprintf("%v", this.MaxConcurrent) + `,`, + `TotalCompletions:` + fmt.Sprintf("%v", this.TotalCompletions) + `,`, + `}`, + }, "") + return s +} +func (this *GlobalJob) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&GlobalJob{`, + `}`, + }, "") + return s +} func (this *TaskSpec) String() string { if this == nil { return "nil" @@ -4457,6 +4808,76 @@ func (m *ServiceSpec) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ReplicatedJob", 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 < 0 { + return ErrInvalidLengthSpecs + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ReplicatedJob{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Mode = &ServiceSpec_ReplicatedJob{v} + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GlobalJob", 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 < 0 { + return ErrInvalidLengthSpecs + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &GlobalJob{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Mode = &ServiceSpec_GlobalJob{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSpecs(dAtA[iNdEx:]) @@ -4606,6 +5027,150 @@ func (m *GlobalService) Unmarshal(dAtA []byte) error { } return nil } +func (m *ReplicatedJob) 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: ReplicatedJob: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ReplicatedJob: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxConcurrent", wireType) + } + m.MaxConcurrent = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSpecs + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MaxConcurrent |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalCompletions", wireType) + } + m.TotalCompletions = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSpecs + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalCompletions |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipSpecs(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSpecs + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthSpecs + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *GlobalJob) 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: GlobalJob: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GlobalJob: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipSpecs(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSpecs + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthSpecs + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *TaskSpec) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/vendor/github.com/docker/swarmkit/api/specs.proto b/vendor/github.com/docker/swarmkit/api/specs.proto index 6858a30b3e..a0510d5e02 100644 --- a/vendor/github.com/docker/swarmkit/api/specs.proto +++ b/vendor/github.com/docker/swarmkit/api/specs.proto @@ -69,6 +69,8 @@ message ServiceSpec { oneof mode { ReplicatedService replicated = 3; GlobalService global = 4; + ReplicatedJob replicated_job = 10; + GlobalJob global_job = 11; } // Update contains settings which affect updates. @@ -99,6 +101,26 @@ message GlobalService { // Empty message for now. } +// ReplicatedJob is a certain type of one-off job which executes many Tasks in +// parallel until the specified number of Tasks have succeeded. +message ReplicatedJob { + // MaxConcurrent indicates the maximum number of Tasks that should be + // executing simultaneously at any given time. + uint64 max_concurrent = 1; + + // TotalCompletions sets the total number of Tasks desired to run to + // completion. This is also the absolute maximum number of Tasks that will + // be executed in parallel. That is, if this number is smaller than + // MaxConcurrent, only this many replicas will run. + uint64 total_completions = 2; +} + +// GlobalJob is a type of one-off job which executes one Task on every node +// matching the service's placement constraints. +message GlobalJob { + // Empty message for now. +} + message TaskSpec { oneof runtime { NetworkAttachmentSpec attachment = 8; diff --git a/vendor/github.com/docker/swarmkit/api/types.pb.go b/vendor/github.com/docker/swarmkit/api/types.pb.go index 825513e8e7..69f052cefa 100644 --- a/vendor/github.com/docker/swarmkit/api/types.pb.go +++ b/vendor/github.com/docker/swarmkit/api/types.pb.go @@ -4014,6 +4014,53 @@ func (m *Privileges_SELinuxContext) XXX_DiscardUnknown() { var xxx_messageInfo_Privileges_SELinuxContext proto.InternalMessageInfo +// JobStatus indicates the status of a Service that is in one of the Job modes. +type JobStatus struct { + // JobIteration is the count of how many times the Job has been excecuted, + // successfully or otherwise. "Executed" refers to the job as a whole being + // started, not to the individual Tasks being launched. This is used to + // disambiguate which Tasks belong to which iteration of a Job. + JobIteration Version `protobuf:"bytes,1,opt,name=job_iteration,json=jobIteration,proto3" json:"job_iteration"` + // LastExecution is the time that the job was last executed. This is set by + // the orchestrator in the same transaction that JobIteration is incremented. + // While time is a fungible concept in distributed systems like Swarmkit, + // this value gives us a best-effort attempt to prevent weird behavior like + // newly added nodes executing long-forgotten jobs. + LastExecution *types.Timestamp `protobuf:"bytes,2,opt,name=last_execution,json=lastExecution,proto3" json:"last_execution,omitempty"` +} + +func (m *JobStatus) Reset() { *m = JobStatus{} } +func (*JobStatus) ProtoMessage() {} +func (*JobStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_0b5eafd0404ded3d, []int{56} +} +func (m *JobStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *JobStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_JobStatus.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalTo(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *JobStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_JobStatus.Merge(m, src) +} +func (m *JobStatus) XXX_Size() int { + return m.Size() +} +func (m *JobStatus) XXX_DiscardUnknown() { + xxx_messageInfo_JobStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_JobStatus proto.InternalMessageInfo + func init() { proto.RegisterEnum("docker.swarmkit.v1.ResourceType", ResourceType_name, ResourceType_value) proto.RegisterEnum("docker.swarmkit.v1.TaskState", TaskState_name, TaskState_value) @@ -4104,6 +4151,7 @@ func init() { proto.RegisterType((*Privileges)(nil), "docker.swarmkit.v1.Privileges") proto.RegisterType((*Privileges_CredentialSpec)(nil), "docker.swarmkit.v1.Privileges.CredentialSpec") proto.RegisterType((*Privileges_SELinuxContext)(nil), "docker.swarmkit.v1.Privileges.SELinuxContext") + proto.RegisterType((*JobStatus)(nil), "docker.swarmkit.v1.JobStatus") } func init() { @@ -4111,338 +4159,342 @@ func init() { } var fileDescriptor_0b5eafd0404ded3d = []byte{ - // 5289 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x3a, 0x4d, 0x6c, 0x23, 0x59, - 0x5a, 0xb1, 0x63, 0x3b, 0xf6, 0x67, 0x27, 0xa9, 0x7e, 0x9d, 0xed, 0x49, 0x7b, 0x7a, 0x12, 0x4f, - 0xcd, 0xf4, 0xce, 0x6c, 0xef, 0xe0, 0xfe, 0x9b, 0x1d, 0xf5, 0xcc, 0x30, 0x3b, 0xe3, 0xbf, 0x74, - 0xbc, 0x9d, 0xd8, 0xd6, 0xb3, 0xd3, 0xbd, 0x8b, 0x04, 0x45, 0xa5, 0xea, 0xc5, 0xa9, 0x49, 0xb9, - 0x5e, 0x51, 0x55, 0x4e, 0xda, 0x2c, 0x88, 0x39, 0x01, 0xca, 0x09, 0x2e, 0xcb, 0xae, 0x50, 0x24, - 0x24, 0xb8, 0x71, 0xe0, 0xc0, 0x81, 0x85, 0xd3, 0x20, 0x21, 0xb4, 0xe2, 0xc2, 0x2e, 0x48, 0xb0, - 0x02, 0x14, 0x98, 0xac, 0xc4, 0x0d, 0xc1, 0x05, 0x71, 0xe1, 0x80, 0xde, 0x4f, 0x95, 0x2b, 0xee, - 0x4a, 0x32, 0xb3, 0xcb, 0x25, 0xf1, 0xfb, 0xfe, 0xde, 0xf7, 0xbe, 0xf7, 0xbd, 0xef, 0x7d, 0xdf, - 0xf7, 0x0a, 0xee, 0x0c, 0xad, 0x60, 0x7f, 0xbc, 0x5b, 0x35, 0xe8, 0xe8, 0xae, 0x49, 0x8d, 0x03, - 0xe2, 0xdd, 0xf5, 0x8f, 0x74, 0x6f, 0x74, 0x60, 0x05, 0x77, 0x75, 0xd7, 0xba, 0x1b, 0x4c, 0x5c, - 0xe2, 0x57, 0x5d, 0x8f, 0x06, 0x14, 0x21, 0x41, 0x50, 0x0d, 0x09, 0xaa, 0x87, 0xf7, 0xcb, 0xeb, - 0x43, 0x4a, 0x87, 0x36, 0xb9, 0xcb, 0x29, 0x76, 0xc7, 0x7b, 0x77, 0x03, 0x6b, 0x44, 0xfc, 0x40, - 0x1f, 0xb9, 0x82, 0xa9, 0xbc, 0x36, 0x4b, 0x60, 0x8e, 0x3d, 0x3d, 0xb0, 0xa8, 0x73, 0x11, 0xfe, - 0xc8, 0xd3, 0x5d, 0x97, 0x78, 0x72, 0xd2, 0xf2, 0xca, 0x90, 0x0e, 0x29, 0xff, 0x79, 0x97, 0xfd, - 0x12, 0x50, 0x75, 0x1d, 0x16, 0x9e, 0x12, 0xcf, 0xb7, 0xa8, 0x83, 0x56, 0x20, 0x6b, 0x39, 0x26, - 0x79, 0xbe, 0x9a, 0xaa, 0xa4, 0xde, 0xcc, 0x60, 0x31, 0x50, 0xef, 0x01, 0xb4, 0xd9, 0x8f, 0x96, - 0x13, 0x78, 0x13, 0xa4, 0xc0, 0xfc, 0x01, 0x99, 0x70, 0x8a, 0x02, 0x66, 0x3f, 0x19, 0xe4, 0x50, - 0xb7, 0x57, 0xd3, 0x02, 0x72, 0xa8, 0xdb, 0xea, 0x67, 0x29, 0x28, 0xd6, 0x1c, 0x87, 0x06, 0x5c, - 0x3b, 0x1f, 0x21, 0xc8, 0x38, 0xfa, 0x88, 0x48, 0x26, 0xfe, 0x1b, 0x35, 0x20, 0x67, 0xeb, 0xbb, - 0xc4, 0xf6, 0x57, 0xd3, 0x95, 0xf9, 0x37, 0x8b, 0x0f, 0xbe, 0x5a, 0x7d, 0xd1, 0x24, 0xd5, 0x98, - 0x90, 0xea, 0x16, 0xa7, 0xe6, 0x4a, 0x60, 0xc9, 0x8a, 0xbe, 0x0e, 0x0b, 0x96, 0x63, 0x5a, 0x06, - 0xf1, 0x57, 0x33, 0x5c, 0xca, 0x5a, 0x92, 0x94, 0xa9, 0xf6, 0xf5, 0xcc, 0x0f, 0x4e, 0xd7, 0xe7, - 0x70, 0xc8, 0x54, 0x7e, 0x17, 0x8a, 0x31, 0xb1, 0x09, 0x6b, 0x5b, 0x81, 0xec, 0xa1, 0x6e, 0x8f, - 0x89, 0x5c, 0x9d, 0x18, 0xbc, 0x97, 0x7e, 0x94, 0x52, 0x3f, 0x82, 0x95, 0x8e, 0x3e, 0x22, 0xe6, - 0x63, 0xe2, 0x10, 0xcf, 0x32, 0x30, 0xf1, 0xe9, 0xd8, 0x33, 0x08, 0x5b, 0xeb, 0x81, 0xe5, 0x98, - 0xe1, 0x5a, 0xd9, 0xef, 0x64, 0x29, 0x6a, 0x03, 0x5e, 0x6a, 0x5a, 0xbe, 0xe1, 0x91, 0x80, 0x7c, - 0x61, 0x21, 0xf3, 0xa1, 0x90, 0xd3, 0x14, 0x2c, 0xcf, 0x72, 0xff, 0x02, 0x5c, 0x67, 0x26, 0x36, - 0x35, 0x4f, 0x42, 0x34, 0xdf, 0x25, 0x06, 0x17, 0x56, 0x7c, 0xf0, 0x66, 0x92, 0x85, 0x92, 0x56, - 0xb2, 0x39, 0x87, 0xaf, 0x71, 0x31, 0x21, 0xa0, 0xef, 0x12, 0x03, 0x19, 0x70, 0xc3, 0x94, 0x4a, - 0xcf, 0x88, 0x4f, 0x73, 0xf1, 0x89, 0xdb, 0x78, 0xc1, 0x32, 0x37, 0xe7, 0xf0, 0x4a, 0x28, 0x2c, - 0x3e, 0x49, 0x1d, 0x20, 0x1f, 0xca, 0x56, 0xbf, 0x9b, 0x82, 0x42, 0x88, 0xf4, 0xd1, 0x57, 0xa0, - 0xe0, 0xe8, 0x0e, 0xd5, 0x0c, 0x77, 0xec, 0xf3, 0x05, 0xcd, 0xd7, 0x4b, 0x67, 0xa7, 0xeb, 0xf9, - 0x8e, 0xee, 0xd0, 0x46, 0x6f, 0xc7, 0xc7, 0x79, 0x86, 0x6e, 0xb8, 0x63, 0x1f, 0xbd, 0x0a, 0xa5, - 0x11, 0x19, 0x51, 0x6f, 0xa2, 0xed, 0x4e, 0x02, 0xe2, 0x4b, 0xb3, 0x15, 0x05, 0xac, 0xce, 0x40, - 0xe8, 0x03, 0x58, 0x18, 0x0a, 0x95, 0x56, 0xe7, 0xb9, 0xfb, 0xbc, 0x96, 0xa4, 0xfd, 0x8c, 0xd6, - 0x38, 0xe4, 0x51, 0xbf, 0x93, 0x86, 0x95, 0x08, 0x4a, 0x7e, 0x65, 0x6c, 0x79, 0x64, 0x44, 0x9c, - 0xc0, 0x47, 0x5f, 0x83, 0x9c, 0x6d, 0x8d, 0xac, 0xc0, 0x97, 0x36, 0x7f, 0x25, 0x49, 0x6c, 0xb4, - 0x28, 0x2c, 0x89, 0x51, 0x0d, 0x4a, 0x1e, 0xf1, 0x89, 0x77, 0x28, 0x3c, 0x5e, 0x5a, 0xf4, 0x0a, - 0xe6, 0x73, 0x2c, 0xe8, 0x3d, 0x00, 0xff, 0x48, 0x77, 0xe5, 0x92, 0xe7, 0xb9, 0x80, 0x97, 0xab, - 0x22, 0x2e, 0x54, 0xc3, 0xb8, 0x50, 0x6d, 0x3b, 0xc1, 0x3b, 0x6f, 0x3f, 0x65, 0xfe, 0x83, 0x0b, - 0x8c, 0x5c, 0x58, 0x63, 0x13, 0xae, 0x49, 0x83, 0x31, 0x98, 0x6b, 0x39, 0xc4, 0x67, 0xc7, 0xea, - 0x4a, 0x11, 0x8a, 0xe0, 0xea, 0x47, 0x4c, 0xea, 0x06, 0xe4, 0x7b, 0xb6, 0x1e, 0xec, 0x51, 0x6f, - 0x84, 0x54, 0x28, 0xe9, 0x9e, 0xb1, 0x6f, 0x05, 0xc4, 0x08, 0xc6, 0x5e, 0x18, 0x03, 0xce, 0xc1, - 0xd0, 0x0d, 0x48, 0x53, 0xb1, 0xdc, 0x42, 0x3d, 0x77, 0x76, 0xba, 0x9e, 0xee, 0xf6, 0x71, 0x9a, - 0xfa, 0xea, 0xfb, 0x70, 0xad, 0x67, 0x8f, 0x87, 0x96, 0xd3, 0x24, 0xbe, 0xe1, 0x59, 0x2e, 0x5b, - 0x23, 0x3b, 0x1b, 0x2c, 0x92, 0x86, 0x67, 0x83, 0xfd, 0x8e, 0x02, 0x4c, 0x7a, 0x1a, 0x60, 0xd4, - 0xdf, 0x4a, 0xc3, 0xb5, 0x96, 0x33, 0xb4, 0x1c, 0x12, 0xe7, 0xbe, 0x0d, 0x4b, 0x84, 0x03, 0xb5, - 0x43, 0x11, 0xf4, 0xa4, 0x9c, 0x45, 0x01, 0x0d, 0x23, 0x61, 0x7b, 0x26, 0x3a, 0xdd, 0x4f, 0xda, - 0x84, 0x17, 0xa4, 0x27, 0xc6, 0xa8, 0x16, 0x2c, 0xb8, 0x7c, 0x11, 0xbe, 0x74, 0xb2, 0xdb, 0x49, - 0xb2, 0x5e, 0x58, 0x67, 0x18, 0xaa, 0x24, 0xef, 0xcf, 0x12, 0xaa, 0xfe, 0x26, 0x0d, 0xcb, 0x1d, - 0x6a, 0x9e, 0xb3, 0x43, 0x19, 0xf2, 0xfb, 0xd4, 0x0f, 0x62, 0x61, 0x39, 0x1a, 0xa3, 0x47, 0x90, - 0x77, 0xe5, 0xf6, 0x49, 0x1f, 0xbc, 0x95, 0xac, 0xb2, 0xa0, 0xc1, 0x11, 0x35, 0x7a, 0x1f, 0x0a, - 0xe1, 0xc1, 0x0d, 0xbd, 0xef, 0x0a, 0xf7, 0x9d, 0xd2, 0xa3, 0x0f, 0x20, 0x27, 0x36, 0x41, 0x3a, - 0xdd, 0xed, 0xcf, 0x65, 0x73, 0x2c, 0x99, 0xd0, 0x63, 0xc8, 0x07, 0xb6, 0xaf, 0x59, 0xce, 0x1e, - 0x5d, 0xcd, 0x72, 0x01, 0xeb, 0x89, 0xa1, 0x8e, 0x9a, 0x64, 0xb0, 0xd5, 0x6f, 0x3b, 0x7b, 0xb4, - 0x5e, 0x3c, 0x3b, 0x5d, 0x5f, 0x90, 0x03, 0xbc, 0x10, 0xd8, 0x3e, 0xfb, 0x81, 0x6e, 0x41, 0x66, - 0xcf, 0x72, 0xfd, 0xd5, 0x5c, 0x25, 0xf5, 0x66, 0xbe, 0x9e, 0x3f, 0x3b, 0x5d, 0xcf, 0x6c, 0xb4, - 0x7b, 0x7d, 0xcc, 0xa1, 0xea, 0xef, 0xa6, 0xa0, 0x18, 0x93, 0x81, 0x5e, 0x01, 0x08, 0xbc, 0xb1, - 0x1f, 0x68, 0x1e, 0xa5, 0x01, 0x37, 0x65, 0x09, 0x17, 0x38, 0x04, 0x53, 0x1a, 0xa0, 0x2a, 0x5c, - 0x37, 0x88, 0x17, 0x68, 0x96, 0xef, 0x8f, 0x89, 0xa7, 0xf9, 0xe3, 0xdd, 0x8f, 0x89, 0x11, 0x70, - 0xb3, 0x96, 0xf0, 0x35, 0x86, 0x6a, 0x73, 0x4c, 0x5f, 0x20, 0xd0, 0x43, 0xb8, 0x11, 0xa7, 0x77, - 0xc7, 0xbb, 0xb6, 0x65, 0x68, 0x6c, 0xab, 0xe7, 0x39, 0xcb, 0xf5, 0x29, 0x4b, 0x8f, 0xe3, 0x9e, - 0x90, 0x89, 0xfa, 0xe3, 0x14, 0x28, 0x58, 0xdf, 0x0b, 0xb6, 0xc9, 0x68, 0x97, 0x78, 0xfd, 0x40, - 0x0f, 0xc6, 0x3e, 0xba, 0x01, 0x39, 0x9b, 0xe8, 0x26, 0xf1, 0xb8, 0x52, 0x79, 0x2c, 0x47, 0x68, - 0x87, 0x45, 0x19, 0xdd, 0xd8, 0xd7, 0x77, 0x2d, 0xdb, 0x0a, 0x26, 0x5c, 0x95, 0xa5, 0x64, 0x07, - 0x9f, 0x95, 0x59, 0xc5, 0x31, 0x46, 0x7c, 0x4e, 0x0c, 0x5a, 0x85, 0x85, 0x11, 0xf1, 0x7d, 0x7d, - 0x48, 0xb8, 0xa6, 0x05, 0x1c, 0x0e, 0xd5, 0xf7, 0xa1, 0x14, 0xe7, 0x43, 0x45, 0x58, 0xd8, 0xe9, - 0x3c, 0xe9, 0x74, 0x9f, 0x75, 0x94, 0x39, 0xb4, 0x0c, 0xc5, 0x9d, 0x0e, 0x6e, 0xd5, 0x1a, 0x9b, - 0xb5, 0xfa, 0x56, 0x4b, 0x49, 0xa1, 0x45, 0x28, 0x4c, 0x87, 0x69, 0xf5, 0x4f, 0x53, 0x00, 0xcc, - 0xdc, 0x72, 0x51, 0xef, 0x41, 0xd6, 0x0f, 0xf4, 0x40, 0xf8, 0xec, 0xd2, 0x83, 0xd7, 0x2f, 0xda, - 0x61, 0xa9, 0x2f, 0xfb, 0x47, 0xb0, 0x60, 0x89, 0x6b, 0x98, 0x3e, 0xa7, 0x21, 0x0b, 0x1f, 0xba, - 0x69, 0x7a, 0x52, 0x71, 0xfe, 0x5b, 0x7d, 0x1f, 0xb2, 0x9c, 0xfb, 0xbc, 0xba, 0x79, 0xc8, 0x34, - 0xd9, 0xaf, 0x14, 0x2a, 0x40, 0x16, 0xb7, 0x6a, 0xcd, 0x6f, 0x29, 0x69, 0xa4, 0x40, 0xa9, 0xd9, - 0xee, 0x37, 0xba, 0x9d, 0x4e, 0xab, 0x31, 0x68, 0x35, 0x95, 0x79, 0xf5, 0x36, 0x64, 0xdb, 0x23, - 0x26, 0xf9, 0x16, 0x3b, 0x10, 0x7b, 0xc4, 0x23, 0x8e, 0x11, 0x9e, 0xb3, 0x29, 0x40, 0xfd, 0xac, - 0x04, 0xd9, 0x6d, 0x3a, 0x76, 0x02, 0xf4, 0x20, 0x16, 0xd4, 0x96, 0x92, 0xb3, 0x18, 0x4e, 0x58, - 0x1d, 0x4c, 0x5c, 0x22, 0x83, 0xde, 0x0d, 0xc8, 0x89, 0xa3, 0x23, 0x97, 0x23, 0x47, 0x0c, 0x1e, - 0xe8, 0xde, 0x90, 0x04, 0x72, 0x3d, 0x72, 0x84, 0xde, 0x64, 0xb7, 0xaa, 0x6e, 0x52, 0xc7, 0x9e, - 0xf0, 0x13, 0x96, 0x17, 0x57, 0x27, 0x26, 0xba, 0xd9, 0x75, 0xec, 0x09, 0x8e, 0xb0, 0xe8, 0x31, - 0x14, 0x0d, 0xea, 0xf8, 0x96, 0x1f, 0x10, 0xc7, 0x98, 0xac, 0xe6, 0xb9, 0x52, 0xb7, 0x2f, 0x56, - 0xaa, 0x31, 0x25, 0xc6, 0x71, 0x4e, 0xb4, 0x09, 0xa5, 0x5d, 0xcb, 0x31, 0x35, 0xea, 0x8a, 0x1b, - 0x2d, 0x7b, 0xf1, 0xc1, 0x16, 0x92, 0xea, 0x96, 0x63, 0x76, 0x05, 0x31, 0x2e, 0xee, 0x4e, 0x07, - 0xa8, 0x03, 0x4b, 0x87, 0xd4, 0x1e, 0x8f, 0x48, 0x24, 0x2b, 0xc7, 0x65, 0xbd, 0x71, 0xb1, 0xac, - 0xa7, 0x9c, 0x3e, 0x94, 0xb6, 0x78, 0x18, 0x1f, 0xa2, 0x27, 0xb0, 0x18, 0x8c, 0xdc, 0x3d, 0x3f, - 0x12, 0xb7, 0xc0, 0xc5, 0x7d, 0xf9, 0x12, 0xcb, 0x33, 0xf2, 0x50, 0x5a, 0x29, 0x88, 0x8d, 0xca, - 0xdf, 0x9f, 0x87, 0x62, 0x4c, 0x73, 0xd4, 0x87, 0xa2, 0xeb, 0x51, 0x57, 0x1f, 0xf2, 0x5b, 0x59, - 0x6e, 0xea, 0xfd, 0xcf, 0xb5, 0xea, 0x6a, 0x6f, 0xca, 0x88, 0xe3, 0x52, 0xd0, 0xdb, 0x50, 0x72, - 0xa8, 0xe3, 0x11, 0x63, 0xec, 0xf9, 0xd6, 0xa1, 0xd8, 0xf4, 0x7c, 0x5d, 0x39, 0x3b, 0x5d, 0x2f, - 0x75, 0xa8, 0x83, 0x43, 0x38, 0x3e, 0x47, 0xa5, 0x9e, 0xa4, 0xa1, 0x18, 0x13, 0x89, 0xee, 0x40, - 0x1e, 0xf7, 0x70, 0xfb, 0x69, 0x6d, 0xd0, 0x52, 0xe6, 0xca, 0xb7, 0x8e, 0x4f, 0x2a, 0xab, 0x5c, - 0x87, 0xf8, 0xb4, 0x3d, 0xcf, 0x3a, 0x64, 0x9e, 0xff, 0x26, 0x2c, 0x84, 0xa4, 0xa9, 0xf2, 0xcb, - 0xc7, 0x27, 0x95, 0x97, 0x66, 0x49, 0x63, 0x94, 0xb8, 0xbf, 0x59, 0xc3, 0xad, 0xa6, 0x92, 0x4e, - 0xa6, 0xc4, 0xfd, 0x7d, 0xdd, 0x23, 0x26, 0xfa, 0x32, 0xe4, 0x24, 0xe1, 0x7c, 0xb9, 0x7c, 0x7c, - 0x52, 0xb9, 0x31, 0x4b, 0x38, 0xa5, 0xc3, 0xfd, 0xad, 0xda, 0xd3, 0x96, 0x92, 0x49, 0xa6, 0xc3, - 0x7d, 0x5b, 0x3f, 0x24, 0xe8, 0x75, 0xc8, 0x0a, 0xb2, 0x6c, 0xf9, 0xe6, 0xf1, 0x49, 0xe5, 0x4b, - 0x2f, 0x88, 0x63, 0x54, 0xe5, 0xd5, 0xdf, 0xfe, 0xc3, 0xb5, 0xb9, 0xbf, 0xf8, 0xa3, 0x35, 0x65, - 0x16, 0x5d, 0xfe, 0xdf, 0x14, 0x2c, 0x9e, 0x73, 0x14, 0xa4, 0x42, 0xce, 0xa1, 0x06, 0x75, 0xc5, - 0xe5, 0x9a, 0xaf, 0xc3, 0xd9, 0xe9, 0x7a, 0xae, 0x43, 0x1b, 0xd4, 0x9d, 0x60, 0x89, 0x41, 0x4f, - 0x66, 0xd2, 0x83, 0x87, 0x9f, 0xd3, 0x0b, 0x13, 0x13, 0x84, 0x0f, 0x61, 0xd1, 0xf4, 0xac, 0x43, - 0xe2, 0x69, 0x06, 0x75, 0xf6, 0xac, 0xa1, 0xbc, 0x38, 0xcb, 0x89, 0x99, 0x34, 0x27, 0xc4, 0x25, - 0xc1, 0xd0, 0xe0, 0xf4, 0x3f, 0x43, 0x6a, 0x50, 0x76, 0xa1, 0x14, 0xf7, 0x6b, 0x76, 0x9b, 0xf9, - 0xd6, 0xaf, 0x12, 0x99, 0x3f, 0xf2, 0x04, 0x1b, 0x17, 0x18, 0x44, 0xa4, 0x88, 0x6f, 0x40, 0x66, - 0x44, 0x4d, 0x21, 0x67, 0xb1, 0x7e, 0x9d, 0x65, 0x28, 0xff, 0x74, 0xba, 0x5e, 0xa4, 0x7e, 0x75, - 0xc3, 0xb2, 0xc9, 0x36, 0x35, 0x09, 0xe6, 0x04, 0x2c, 0xd6, 0x86, 0x07, 0x4b, 0xde, 0x06, 0x72, - 0xa8, 0x7e, 0x2f, 0x05, 0x19, 0x16, 0xc4, 0xd0, 0xcb, 0x90, 0xa9, 0xb7, 0x3b, 0x4d, 0x65, 0xae, - 0x7c, 0xed, 0xf8, 0xa4, 0xb2, 0xc8, 0xad, 0xc5, 0x10, 0xec, 0x30, 0xa0, 0x75, 0xc8, 0x3d, 0xed, - 0x6e, 0xed, 0x6c, 0x33, 0xcf, 0xbb, 0x7e, 0x7c, 0x52, 0x59, 0x8e, 0xd0, 0xc2, 0x9e, 0xe8, 0x15, - 0xc8, 0x0e, 0xb6, 0x7b, 0x1b, 0x7d, 0x25, 0x5d, 0x46, 0xc7, 0x27, 0x95, 0xa5, 0x08, 0xcf, 0x97, - 0x83, 0x5e, 0x85, 0x6c, 0xa7, 0xd7, 0xee, 0xb5, 0x94, 0xf9, 0xf2, 0x8d, 0xe3, 0x93, 0x0a, 0x8a, - 0xd0, 0xbc, 0xd2, 0xe9, 0x59, 0x2e, 0x29, 0x5f, 0x93, 0x3e, 0x51, 0x88, 0x70, 0xea, 0x8f, 0x52, - 0x50, 0x8c, 0xc5, 0x32, 0xe6, 0xd6, 0xcd, 0xd6, 0x46, 0x6d, 0x67, 0x6b, 0xa0, 0xcc, 0xc5, 0xdc, - 0x3a, 0x46, 0xd2, 0x24, 0x7b, 0xfa, 0xd8, 0x66, 0xb1, 0x15, 0x1a, 0xdd, 0x4e, 0xbf, 0xdd, 0x1f, - 0xb4, 0x3a, 0x03, 0x25, 0x55, 0x5e, 0x3d, 0x3e, 0xa9, 0xac, 0xcc, 0x12, 0x6f, 0x8c, 0x6d, 0x9b, - 0x39, 0x76, 0xa3, 0xd6, 0xd8, 0xe4, 0x27, 0x65, 0xea, 0xd8, 0x31, 0xaa, 0x86, 0x6e, 0xec, 0x13, - 0x13, 0xbd, 0x05, 0x85, 0x66, 0x6b, 0xab, 0xf5, 0xb8, 0xc6, 0x6f, 0x94, 0xf2, 0x2b, 0xc7, 0x27, - 0x95, 0x9b, 0x2f, 0xce, 0x6e, 0x93, 0xa1, 0x1e, 0x10, 0x73, 0xc6, 0xc1, 0x63, 0x24, 0xea, 0x7f, - 0xa7, 0x61, 0x11, 0x13, 0x3f, 0xd0, 0xbd, 0xa0, 0x47, 0x6d, 0xcb, 0x98, 0xa0, 0x1e, 0x14, 0x0c, - 0xea, 0x98, 0x56, 0x2c, 0x36, 0x3d, 0xb8, 0x20, 0x49, 0x9b, 0x72, 0x85, 0xa3, 0x46, 0xc8, 0x89, - 0xa7, 0x42, 0xd0, 0x5d, 0xc8, 0x9a, 0xc4, 0xd6, 0x27, 0x32, 0x5b, 0xbc, 0xf9, 0x42, 0xb5, 0xd0, - 0x94, 0x8d, 0x0a, 0x2c, 0xe8, 0x78, 0x6d, 0xa6, 0x3f, 0xd7, 0xf4, 0x20, 0x20, 0x23, 0x37, 0x10, - 0x3e, 0x92, 0xc1, 0xc5, 0x91, 0xfe, 0xbc, 0x26, 0x41, 0xe8, 0x3e, 0xe4, 0x8e, 0x2c, 0xc7, 0xa4, - 0x47, 0x32, 0x1b, 0xbc, 0x44, 0xa8, 0x24, 0x54, 0x8f, 0x59, 0x1a, 0x34, 0xa3, 0x26, 0x73, 0xb3, - 0x4e, 0xb7, 0xd3, 0x0a, 0xdd, 0x4c, 0xe2, 0xbb, 0x4e, 0x87, 0x3a, 0x2c, 0x7a, 0x40, 0xb7, 0xa3, - 0x6d, 0xd4, 0xda, 0x5b, 0x3b, 0x98, 0xb9, 0xda, 0xca, 0xf1, 0x49, 0x45, 0x89, 0x48, 0x36, 0x74, - 0xcb, 0x66, 0xe5, 0xc9, 0x4d, 0x98, 0xaf, 0x75, 0xbe, 0xa5, 0xa4, 0xcb, 0xca, 0xf1, 0x49, 0xa5, - 0x14, 0xa1, 0x6b, 0xce, 0x64, 0x6a, 0xf7, 0xd9, 0x79, 0xd5, 0xbf, 0x9d, 0x87, 0xd2, 0x8e, 0x6b, - 0xea, 0x01, 0x11, 0xa7, 0x14, 0x55, 0xa0, 0xe8, 0xea, 0x9e, 0x6e, 0xdb, 0xc4, 0xb6, 0xfc, 0x91, - 0x6c, 0xb1, 0xc4, 0x41, 0xe8, 0xdd, 0xcf, 0x6b, 0xc6, 0x7a, 0x9e, 0x9d, 0xbc, 0xef, 0xfe, 0xeb, - 0x7a, 0x2a, 0x34, 0xe8, 0x0e, 0x2c, 0xed, 0x09, 0x6d, 0x35, 0xdd, 0xe0, 0x1b, 0x3b, 0xcf, 0x37, - 0xb6, 0x9a, 0xb4, 0xb1, 0x71, 0xb5, 0xaa, 0x72, 0x91, 0x35, 0xce, 0x85, 0x17, 0xf7, 0xe2, 0x43, - 0xf4, 0x10, 0x16, 0x46, 0xd4, 0xb1, 0x02, 0xea, 0x5d, 0xbd, 0x0b, 0x21, 0x25, 0xba, 0x03, 0xd7, - 0xd8, 0xe6, 0x86, 0xfa, 0x70, 0x34, 0xbf, 0xf9, 0xd3, 0x78, 0x79, 0xa4, 0x3f, 0x97, 0x13, 0x62, - 0x06, 0x46, 0x75, 0xc8, 0x52, 0x8f, 0xe5, 0xa8, 0x39, 0xae, 0xee, 0x5b, 0x57, 0xaa, 0x2b, 0x06, - 0x5d, 0xc6, 0x83, 0x05, 0xab, 0xfa, 0x0e, 0x2c, 0x9e, 0x5b, 0x04, 0x4b, 0xcd, 0x7a, 0xb5, 0x9d, - 0x7e, 0x4b, 0x99, 0x43, 0x25, 0xc8, 0x37, 0xba, 0x9d, 0x41, 0xbb, 0xb3, 0xc3, 0x72, 0xcb, 0x12, - 0xe4, 0x71, 0x77, 0x6b, 0xab, 0x5e, 0x6b, 0x3c, 0x51, 0xd2, 0x6a, 0x15, 0x8a, 0x31, 0x69, 0x68, - 0x09, 0xa0, 0x3f, 0xe8, 0xf6, 0xb4, 0x8d, 0x36, 0xee, 0x0f, 0x44, 0x66, 0xda, 0x1f, 0xd4, 0xf0, - 0x40, 0x02, 0x52, 0xea, 0x7f, 0xa6, 0xc3, 0x1d, 0x95, 0xc9, 0x68, 0xfd, 0x7c, 0x32, 0x7a, 0x89, - 0xf2, 0x32, 0x1d, 0x9d, 0x0e, 0xa2, 0xa4, 0xf4, 0x5d, 0x00, 0xee, 0x38, 0xc4, 0xd4, 0xf4, 0x40, - 0x6e, 0x7c, 0xf9, 0x05, 0x23, 0x0f, 0xc2, 0x4e, 0x20, 0x2e, 0x48, 0xea, 0x5a, 0x80, 0x3e, 0x80, - 0x92, 0x41, 0x47, 0xae, 0x4d, 0x24, 0xf3, 0xfc, 0x95, 0xcc, 0xc5, 0x88, 0xbe, 0x16, 0xc4, 0xd3, - 0xe1, 0xcc, 0xf9, 0x84, 0xfd, 0x37, 0x53, 0xa1, 0x65, 0x12, 0x32, 0xe0, 0x12, 0xe4, 0x77, 0x7a, - 0xcd, 0xda, 0xa0, 0xdd, 0x79, 0xac, 0xa4, 0x10, 0x40, 0x8e, 0x9b, 0xba, 0xa9, 0xa4, 0x59, 0xe6, - 0xde, 0xe8, 0x6e, 0xf7, 0xb6, 0x5a, 0x3c, 0x62, 0xa1, 0x15, 0x50, 0x42, 0x63, 0x6b, 0xdc, 0x90, - 0xad, 0xa6, 0x92, 0x41, 0xd7, 0x61, 0x39, 0x82, 0x4a, 0xce, 0x2c, 0xba, 0x01, 0x28, 0x02, 0x4e, - 0x45, 0xe4, 0xd4, 0x5f, 0x87, 0xe5, 0x06, 0x75, 0x02, 0xdd, 0x72, 0xa2, 0xaa, 0xe6, 0x01, 0x5b, - 0xb4, 0x04, 0x69, 0x96, 0xec, 0x90, 0xd5, 0x97, 0xcf, 0x4e, 0xd7, 0x8b, 0x11, 0x69, 0xbb, 0xc9, - 0xb3, 0x50, 0x39, 0x30, 0xd9, 0xf9, 0x75, 0x2d, 0x93, 0x1b, 0x37, 0x5b, 0x5f, 0x38, 0x3b, 0x5d, - 0x9f, 0xef, 0xb5, 0x9b, 0x98, 0xc1, 0xd0, 0xcb, 0x50, 0x20, 0xcf, 0xad, 0x40, 0x33, 0xd8, 0xad, - 0xc6, 0x0c, 0x98, 0xc5, 0x79, 0x06, 0x68, 0x50, 0x93, 0xa8, 0x75, 0x80, 0x1e, 0xf5, 0x02, 0x39, - 0xf3, 0xdb, 0x90, 0x75, 0xa9, 0xc7, 0x7b, 0x3a, 0x17, 0x76, 0x1a, 0x19, 0xb9, 0x70, 0x54, 0x2c, - 0x88, 0xd5, 0xef, 0xcd, 0x03, 0x0c, 0x74, 0xff, 0x40, 0x0a, 0x79, 0x04, 0x85, 0xa8, 0xab, 0x2b, - 0x9b, 0x43, 0x97, 0xee, 0x76, 0x44, 0x8c, 0x1e, 0x86, 0xce, 0x26, 0xea, 0xb5, 0xc4, 0xb2, 0x3a, - 0x9c, 0x28, 0xa9, 0xe4, 0x39, 0x5f, 0x94, 0xb1, 0x24, 0x81, 0x78, 0x9e, 0xdc, 0x79, 0xf6, 0x13, - 0x35, 0xf8, 0xb5, 0x20, 0x8c, 0x26, 0x13, 0xf5, 0xc4, 0x76, 0xd8, 0xcc, 0x8e, 0x6c, 0xce, 0xe1, - 0x29, 0x1f, 0xfa, 0x10, 0x8a, 0x6c, 0xdd, 0x9a, 0xcf, 0x71, 0x32, 0x47, 0xbf, 0xd0, 0x54, 0x42, - 0x02, 0x06, 0x77, 0x6a, 0xe5, 0x57, 0x00, 0x74, 0xd7, 0xb5, 0x2d, 0x62, 0x6a, 0xbb, 0x13, 0x9e, - 0x94, 0x17, 0x70, 0x41, 0x42, 0xea, 0x13, 0x76, 0x5c, 0x42, 0xb4, 0x1e, 0xf0, 0xc2, 0xe4, 0x0a, - 0x03, 0x4a, 0xea, 0x5a, 0x50, 0x57, 0x60, 0xc9, 0x1b, 0x3b, 0xcc, 0xa0, 0x52, 0x3b, 0xf5, 0x4f, - 0xd2, 0xf0, 0x52, 0x87, 0x04, 0x47, 0xd4, 0x3b, 0xa8, 0x05, 0x81, 0x6e, 0xec, 0x8f, 0x88, 0x23, - 0xb7, 0x2f, 0x56, 0x44, 0xa5, 0xce, 0x15, 0x51, 0xab, 0xb0, 0xa0, 0xdb, 0x96, 0xee, 0x13, 0x91, - 0xfa, 0x15, 0x70, 0x38, 0x64, 0xa5, 0x1e, 0x2b, 0x1c, 0x89, 0xef, 0x13, 0xd1, 0xe9, 0x61, 0x8a, - 0x87, 0x00, 0xf4, 0x6d, 0xb8, 0x21, 0x93, 0x3c, 0x3d, 0x9a, 0x8a, 0xd5, 0x1e, 0x61, 0xe3, 0xba, - 0x95, 0x58, 0xc9, 0x26, 0x2b, 0x27, 0xb3, 0xc0, 0x29, 0xb8, 0xeb, 0x06, 0x32, 0xa7, 0x5c, 0x31, - 0x13, 0x50, 0xe5, 0xc7, 0x70, 0xf3, 0x42, 0x96, 0x2f, 0xd4, 0x49, 0xfa, 0xfb, 0x34, 0x40, 0xbb, - 0x57, 0xdb, 0x96, 0x46, 0x6a, 0x42, 0x6e, 0x4f, 0x1f, 0x59, 0xf6, 0xe4, 0xb2, 0x08, 0x38, 0xa5, - 0xaf, 0xd6, 0x84, 0x39, 0x36, 0x38, 0x0f, 0x96, 0xbc, 0xbc, 0x8e, 0x1d, 0xef, 0x3a, 0x24, 0x88, - 0xea, 0x58, 0x3e, 0x62, 0x6a, 0x78, 0xba, 0x13, 0xb9, 0xae, 0x18, 0xb0, 0x0d, 0x60, 0x29, 0xcf, - 0x91, 0x3e, 0x09, 0xc3, 0x96, 0x1c, 0xa2, 0x4d, 0xde, 0x35, 0x26, 0xde, 0x21, 0x31, 0x57, 0xb3, - 0xdc, 0xa8, 0x57, 0xe9, 0x83, 0x25, 0xb9, 0xb0, 0x5d, 0xc4, 0x5d, 0x7e, 0x9f, 0xa7, 0x4c, 0x53, - 0xd4, 0x17, 0xb2, 0xd1, 0x3d, 0x58, 0x3c, 0xb7, 0xce, 0x17, 0x1a, 0x08, 0xed, 0xde, 0xd3, 0xb7, - 0x95, 0x8c, 0xfc, 0xf5, 0x8e, 0x92, 0x53, 0xff, 0x7a, 0x5e, 0x04, 0x1a, 0x69, 0xd5, 0xe4, 0xd7, - 0x92, 0x3c, 0xf7, 0x6e, 0x83, 0xda, 0x32, 0x00, 0xbc, 0x71, 0x79, 0xfc, 0x61, 0x75, 0x24, 0x27, - 0xc7, 0x11, 0x23, 0x5a, 0x87, 0xa2, 0xf0, 0x62, 0x8d, 0x1d, 0x38, 0x6e, 0xd6, 0x45, 0x0c, 0x02, - 0xc4, 0x38, 0xd1, 0x6d, 0x58, 0xe2, 0x0d, 0x27, 0x7f, 0x9f, 0x98, 0x82, 0x26, 0xc3, 0x69, 0x16, - 0x23, 0x28, 0x27, 0xdb, 0x86, 0x92, 0x04, 0x68, 0xbc, 0x1a, 0xc8, 0x72, 0x85, 0xee, 0x5c, 0xa5, - 0x90, 0x60, 0xe1, 0x45, 0x42, 0xd1, 0x9d, 0x0e, 0xd4, 0x5f, 0x86, 0x7c, 0xa8, 0x2c, 0x5a, 0x85, - 0xf9, 0x41, 0xa3, 0xa7, 0xcc, 0x95, 0x97, 0x8f, 0x4f, 0x2a, 0xc5, 0x10, 0x3c, 0x68, 0xf4, 0x18, - 0x66, 0xa7, 0xd9, 0x53, 0x52, 0xe7, 0x31, 0x3b, 0xcd, 0x1e, 0x2a, 0x43, 0xa6, 0xdf, 0x18, 0xf4, - 0xc2, 0xfc, 0x2c, 0x44, 0x31, 0x58, 0x39, 0xc3, 0xf2, 0x33, 0x75, 0x0f, 0x8a, 0xb1, 0xd9, 0xd1, - 0x6b, 0xb0, 0xd0, 0xee, 0x3c, 0xc6, 0xad, 0x7e, 0x5f, 0x99, 0x13, 0xe5, 0x41, 0x0c, 0xdb, 0x76, - 0x86, 0x6c, 0xef, 0xd0, 0x2b, 0x90, 0xd9, 0xec, 0xb2, 0x7b, 0x5f, 0xd4, 0x1f, 0x31, 0x8a, 0x4d, - 0xea, 0x07, 0xe5, 0xeb, 0x32, 0xf1, 0x8b, 0x0b, 0x56, 0x7f, 0x3f, 0x05, 0x39, 0x71, 0xd0, 0x12, - 0x37, 0xb1, 0x36, 0x2d, 0x8a, 0x44, 0xd9, 0xf8, 0xc6, 0xc5, 0x25, 0x5e, 0x55, 0x56, 0x64, 0xc2, - 0x35, 0x43, 0xbe, 0xf2, 0x7b, 0x50, 0x8a, 0x23, 0xbe, 0x90, 0x63, 0x7e, 0x1b, 0x8a, 0xcc, 0xf7, - 0xc3, 0x52, 0xef, 0x01, 0xe4, 0x44, 0xb0, 0x88, 0xee, 0xa1, 0x8b, 0xeb, 0x4d, 0x49, 0x89, 0x1e, - 0xc1, 0x82, 0xa8, 0x51, 0xc3, 0x5e, 0xf6, 0xda, 0xe5, 0x27, 0x0c, 0x87, 0xe4, 0xea, 0x87, 0x90, - 0xe9, 0x11, 0xe2, 0x31, 0xdb, 0x3b, 0xd4, 0x24, 0xd3, 0xab, 0x5b, 0x96, 0xd7, 0x26, 0x69, 0x37, - 0x59, 0x79, 0x6d, 0x92, 0xb6, 0x19, 0xf5, 0xe3, 0xd2, 0xb1, 0x7e, 0xdc, 0x00, 0x4a, 0xcf, 0x88, - 0x35, 0xdc, 0x0f, 0x88, 0xc9, 0x05, 0xbd, 0x05, 0x19, 0x97, 0x44, 0xca, 0xaf, 0x26, 0x3a, 0x1f, - 0x21, 0x1e, 0xe6, 0x54, 0x2c, 0xc6, 0x1c, 0x71, 0x6e, 0xf9, 0x0c, 0x24, 0x47, 0xea, 0xdf, 0xa5, - 0x61, 0xa9, 0xed, 0xfb, 0x63, 0xdd, 0x31, 0xc2, 0xac, 0xee, 0xeb, 0xe7, 0xb3, 0xba, 0xc4, 0xf7, - 0xb2, 0xf3, 0x2c, 0xe7, 0xdb, 0x8c, 0xf2, 0x66, 0x4d, 0x47, 0x37, 0xab, 0xfa, 0x1f, 0xa9, 0xb0, - 0x97, 0x78, 0x3b, 0x16, 0x0a, 0x44, 0x8d, 0x18, 0x97, 0x44, 0x76, 0x9c, 0x03, 0x87, 0x1e, 0x39, - 0xac, 0x7a, 0xc5, 0xad, 0x4e, 0xeb, 0x99, 0x92, 0x12, 0xee, 0x79, 0x8e, 0x08, 0x13, 0x87, 0x1c, - 0x31, 0x49, 0xbd, 0x56, 0xa7, 0xc9, 0xb2, 0xb0, 0x74, 0x82, 0xa4, 0x1e, 0x71, 0x4c, 0xcb, 0x19, - 0xa2, 0xd7, 0x20, 0xd7, 0xee, 0xf7, 0x77, 0x78, 0x09, 0xf9, 0xd2, 0xf1, 0x49, 0xe5, 0xfa, 0x39, - 0x2a, 0xde, 0x47, 0x36, 0x19, 0x11, 0x2b, 0x81, 0x58, 0x7e, 0x96, 0x40, 0xc4, 0x72, 0x6b, 0x41, - 0x84, 0xbb, 0x83, 0xda, 0xa0, 0xa5, 0x64, 0x13, 0x88, 0x30, 0x65, 0x7f, 0xe5, 0x71, 0xfb, 0xe7, - 0x34, 0x28, 0x35, 0xc3, 0x20, 0x6e, 0xc0, 0xf0, 0xb2, 0xea, 0x1c, 0x40, 0xde, 0x65, 0xbf, 0x2c, - 0x12, 0x66, 0x50, 0x8f, 0x12, 0x5f, 0x7c, 0x67, 0xf8, 0xaa, 0x98, 0xda, 0xa4, 0x66, 0x8e, 0x2c, - 0xdf, 0xb7, 0xa8, 0x23, 0x60, 0x38, 0x92, 0x54, 0xfe, 0xaf, 0x14, 0x5c, 0x4f, 0xa0, 0x40, 0xf7, - 0x20, 0xe3, 0x51, 0x3b, 0xdc, 0xc3, 0x5b, 0x17, 0xb5, 0x89, 0x19, 0x2b, 0xe6, 0x94, 0x68, 0x0d, - 0x40, 0x1f, 0x07, 0x54, 0xe7, 0xf3, 0x8b, 0xe6, 0x1a, 0x8e, 0x41, 0xd0, 0x33, 0xc8, 0xf9, 0xc4, - 0xf0, 0x48, 0x98, 0x67, 0x7f, 0xf8, 0xd3, 0x6a, 0x5f, 0xed, 0x73, 0x31, 0x58, 0x8a, 0x2b, 0x57, - 0x21, 0x27, 0x20, 0xcc, 0xed, 0x4d, 0x3d, 0xd0, 0xe5, 0x23, 0x02, 0xff, 0xcd, 0xbc, 0x49, 0xb7, - 0x87, 0xa1, 0x37, 0xe9, 0xf6, 0x50, 0xfd, 0xab, 0x34, 0x40, 0xeb, 0x79, 0x40, 0x3c, 0x47, 0xb7, - 0x1b, 0x35, 0xd4, 0x8a, 0xdd, 0x0c, 0x62, 0xb5, 0x5f, 0x49, 0x7c, 0x37, 0x89, 0x38, 0xaa, 0x8d, - 0x5a, 0xc2, 0xdd, 0x70, 0x13, 0xe6, 0xc7, 0x9e, 0x7c, 0xc4, 0x17, 0x39, 0xf2, 0x0e, 0xde, 0xc2, - 0x0c, 0x86, 0x5a, 0xf1, 0x5e, 0xce, 0x85, 0x4f, 0xf5, 0xb1, 0x09, 0x12, 0x43, 0x17, 0x3b, 0xf9, - 0x86, 0xae, 0x19, 0x44, 0xde, 0x2a, 0x25, 0x71, 0xf2, 0x1b, 0xb5, 0x06, 0xf1, 0x02, 0x9c, 0x33, - 0x74, 0xf6, 0xff, 0x67, 0x8a, 0x6f, 0x6f, 0x01, 0x4c, 0x97, 0x86, 0xd6, 0x20, 0xdb, 0xd8, 0xe8, - 0xf7, 0xb7, 0x94, 0x39, 0x11, 0xc0, 0xa7, 0x28, 0x0e, 0x56, 0xff, 0x3c, 0x0d, 0xf9, 0x46, 0x4d, - 0x5e, 0xb9, 0x0d, 0x50, 0x78, 0x54, 0xe2, 0x4f, 0x2f, 0xe4, 0xb9, 0x6b, 0x79, 0x13, 0x19, 0x58, - 0x2e, 0x29, 0x78, 0x97, 0x18, 0x0b, 0xd3, 0xba, 0xc5, 0x19, 0x10, 0x86, 0x12, 0x91, 0x46, 0xd0, - 0x0c, 0x3d, 0x8c, 0xf1, 0x6b, 0x97, 0x1b, 0x4b, 0x94, 0x2e, 0xd3, 0xb1, 0x8f, 0x8b, 0xa1, 0x90, - 0x86, 0xee, 0xa3, 0x77, 0x61, 0xd9, 0xb7, 0x86, 0x8e, 0xe5, 0x0c, 0xb5, 0xd0, 0x78, 0xfc, 0x1d, - 0xa8, 0x7e, 0xed, 0xec, 0x74, 0x7d, 0xb1, 0x2f, 0x50, 0xd2, 0x86, 0x8b, 0x92, 0xb2, 0xc1, 0x4d, - 0x89, 0xde, 0x81, 0xa5, 0x18, 0x2b, 0xb3, 0xa2, 0x30, 0x3b, 0xef, 0x18, 0x47, 0x9c, 0x4f, 0xc8, - 0x04, 0x97, 0x22, 0xc6, 0x27, 0x84, 0xf7, 0x66, 0xf6, 0xa8, 0x67, 0x10, 0xcd, 0xe3, 0x67, 0x9a, - 0xdf, 0xee, 0x19, 0x5c, 0xe4, 0x30, 0x71, 0xcc, 0xd5, 0xa7, 0x70, 0xbd, 0xeb, 0x19, 0xfb, 0xc4, - 0x0f, 0x84, 0x29, 0xa4, 0x15, 0x3f, 0x84, 0x5b, 0x81, 0xee, 0x1f, 0x68, 0xfb, 0x96, 0x1f, 0x50, - 0x6f, 0xa2, 0x79, 0x24, 0x20, 0x0e, 0xc3, 0x6b, 0xfc, 0x81, 0x5b, 0xb6, 0x13, 0x6f, 0x32, 0x9a, - 0x4d, 0x41, 0x82, 0x43, 0x8a, 0x2d, 0x46, 0xa0, 0xb6, 0xa1, 0xc4, 0x4a, 0x18, 0xd9, 0x54, 0x63, - 0xab, 0x07, 0x9b, 0x0e, 0xb5, 0xcf, 0x7d, 0x4d, 0x15, 0x6c, 0x3a, 0x14, 0x3f, 0xd5, 0x6f, 0x82, - 0xd2, 0xb4, 0x7c, 0x57, 0x0f, 0x8c, 0xfd, 0xb0, 0x4f, 0x8a, 0x9a, 0xa0, 0xec, 0x13, 0xdd, 0x0b, - 0x76, 0x89, 0x1e, 0x68, 0x2e, 0xf1, 0x2c, 0x6a, 0x5e, 0xbd, 0xcb, 0xcb, 0x11, 0x4b, 0x8f, 0x73, - 0xa8, 0xff, 0x93, 0x02, 0xc0, 0xfa, 0x5e, 0x98, 0xad, 0x7d, 0x15, 0xae, 0xf9, 0x8e, 0xee, 0xfa, - 0xfb, 0x34, 0xd0, 0x2c, 0x27, 0x20, 0xde, 0xa1, 0x6e, 0xcb, 0xe6, 0x8e, 0x12, 0x22, 0xda, 0x12, - 0x8e, 0xde, 0x02, 0x74, 0x40, 0x88, 0xab, 0x51, 0xdb, 0xd4, 0x42, 0xa4, 0x78, 0xf8, 0xce, 0x60, - 0x85, 0x61, 0xba, 0xb6, 0xd9, 0x0f, 0xe1, 0xa8, 0x0e, 0x6b, 0x6c, 0xf9, 0xc4, 0x09, 0x3c, 0x8b, - 0xf8, 0xda, 0x1e, 0xf5, 0x34, 0xdf, 0xa6, 0x47, 0xda, 0x1e, 0xb5, 0x6d, 0x7a, 0x44, 0xbc, 0xb0, - 0x6f, 0x56, 0xb6, 0xe9, 0xb0, 0x25, 0x88, 0x36, 0xa8, 0xd7, 0xb7, 0xe9, 0xd1, 0x46, 0x48, 0xc1, - 0x52, 0xba, 0xe9, 0x9a, 0x03, 0xcb, 0x38, 0x08, 0x53, 0xba, 0x08, 0x3a, 0xb0, 0x8c, 0x03, 0xf4, - 0x1a, 0x2c, 0x12, 0x9b, 0xf0, 0xf6, 0x89, 0xa0, 0xca, 0x72, 0xaa, 0x52, 0x08, 0x64, 0x44, 0xea, - 0x47, 0xa0, 0xb4, 0x1c, 0xc3, 0x9b, 0xb8, 0xb1, 0x3d, 0x7f, 0x0b, 0x10, 0x0b, 0x92, 0x9a, 0x4d, - 0x8d, 0x03, 0x6d, 0xa4, 0x3b, 0xfa, 0x90, 0xe9, 0x25, 0x5e, 0x1c, 0x15, 0x86, 0xd9, 0xa2, 0xc6, - 0xc1, 0xb6, 0x84, 0xab, 0xef, 0x02, 0xf4, 0x5d, 0x8f, 0xe8, 0x66, 0x97, 0x65, 0x13, 0xcc, 0x74, - 0x7c, 0xa4, 0x99, 0xf2, 0x3d, 0x97, 0x7a, 0xf2, 0xa8, 0x2b, 0x02, 0xd1, 0x8c, 0xe0, 0xea, 0x2f, - 0xc2, 0xf5, 0x9e, 0xad, 0x1b, 0xfc, 0x0b, 0x8b, 0x5e, 0xf4, 0x84, 0x86, 0x1e, 0x41, 0x4e, 0x90, - 0xca, 0x9d, 0x4c, 0x3c, 0x6e, 0xd3, 0x39, 0x37, 0xe7, 0xb0, 0xa4, 0xaf, 0x97, 0x00, 0xa6, 0x72, - 0xd4, 0x7f, 0x4c, 0x41, 0x21, 0x92, 0x8f, 0x2a, 0xe2, 0x01, 0x2c, 0xf0, 0x74, 0xcb, 0x91, 0x15, - 0x7f, 0x01, 0xc7, 0x41, 0xa8, 0x0d, 0x45, 0x37, 0xe2, 0xbe, 0x34, 0x9f, 0x4b, 0xd0, 0x1a, 0xc7, - 0x79, 0xd1, 0x7b, 0x50, 0x08, 0x1f, 0xd0, 0xc3, 0x08, 0x7b, 0xf9, 0x7b, 0xfb, 0x94, 0x3c, 0x6c, - 0xa4, 0x7a, 0xc4, 0xb5, 0x2d, 0x16, 0x73, 0x32, 0x51, 0x23, 0x15, 0x4b, 0x90, 0xfa, 0x75, 0x80, - 0x6f, 0x50, 0xcb, 0x19, 0xd0, 0x03, 0xe2, 0xf0, 0x57, 0x61, 0x56, 0x52, 0x92, 0xd0, 0xd0, 0x72, - 0xc4, 0x3b, 0x05, 0x62, 0x97, 0xa2, 0xc7, 0x51, 0x31, 0x54, 0xff, 0x32, 0x0d, 0x39, 0x4c, 0x69, - 0xd0, 0xa8, 0xa1, 0x0a, 0xe4, 0x64, 0x28, 0xe1, 0x57, 0x54, 0xbd, 0x70, 0x76, 0xba, 0x9e, 0x15, - 0x31, 0x24, 0x6b, 0xf0, 0xe0, 0x11, 0x0b, 0xf2, 0xe9, 0x8b, 0x82, 0x3c, 0xba, 0x07, 0x25, 0x49, - 0xa4, 0xed, 0xeb, 0xfe, 0xbe, 0xa8, 0xef, 0xea, 0x4b, 0x67, 0xa7, 0xeb, 0x20, 0x28, 0x37, 0x75, - 0x7f, 0x1f, 0x83, 0xa0, 0x66, 0xbf, 0x51, 0x0b, 0x8a, 0x1f, 0x53, 0xcb, 0xd1, 0x02, 0xbe, 0x08, - 0xd9, 0x8b, 0x4c, 0xdc, 0xea, 0xe9, 0x52, 0xe5, 0x07, 0x14, 0xf0, 0xf1, 0x74, 0xf1, 0x2d, 0x58, - 0xf4, 0x28, 0x0d, 0x44, 0x64, 0xb3, 0xa8, 0x23, 0xdb, 0x1c, 0x95, 0xc4, 0xee, 0x37, 0xa5, 0x01, - 0x96, 0x74, 0xb8, 0xe4, 0xc5, 0x46, 0xe8, 0x1e, 0xac, 0xd8, 0xba, 0x1f, 0x68, 0x3c, 0x24, 0x9a, - 0x53, 0x69, 0x39, 0x6e, 0x7c, 0xc4, 0x70, 0x1b, 0x1c, 0x15, 0x72, 0xa8, 0xff, 0x90, 0x82, 0x22, - 0x5b, 0x8c, 0xb5, 0x67, 0x19, 0x2c, 0x0f, 0xfc, 0xe2, 0xe9, 0xc9, 0x4d, 0x98, 0x37, 0x7c, 0x4f, - 0x1a, 0x95, 0xdf, 0xcf, 0x8d, 0x3e, 0xc6, 0x0c, 0x86, 0x3e, 0x82, 0x9c, 0x6c, 0xb7, 0x88, 0xcc, - 0x44, 0xbd, 0x3a, 0x63, 0x95, 0xb6, 0x91, 0x7c, 0xdc, 0xdd, 0xa7, 0xda, 0x89, 0x7b, 0x02, 0xc7, - 0x41, 0xe8, 0x06, 0xa4, 0x0d, 0x61, 0x2e, 0xf9, 0x85, 0x4e, 0xa3, 0x83, 0xd3, 0x86, 0xa3, 0xfe, - 0x28, 0x05, 0x8b, 0xd3, 0x98, 0xc0, 0x3c, 0xe0, 0x16, 0x14, 0xfc, 0xf1, 0xae, 0x3f, 0xf1, 0x03, - 0x32, 0x0a, 0x5f, 0xbc, 0x23, 0x00, 0x6a, 0x43, 0x41, 0xb7, 0x87, 0xd4, 0xb3, 0x82, 0xfd, 0x91, - 0x2c, 0x64, 0x93, 0xb3, 0x89, 0xb8, 0xcc, 0x6a, 0x2d, 0x64, 0xc1, 0x53, 0xee, 0x30, 0x35, 0x10, - 0x9f, 0x45, 0xf0, 0xd4, 0xe0, 0x55, 0x28, 0xd9, 0xfa, 0x88, 0xf7, 0x9f, 0x02, 0x6b, 0x44, 0xc2, - 0xc3, 0x20, 0x61, 0x03, 0x6b, 0x44, 0x54, 0x15, 0x0a, 0x91, 0x30, 0xb4, 0x0c, 0xc5, 0x5a, 0xab, - 0xaf, 0xdd, 0x7f, 0xf0, 0x48, 0x7b, 0xdc, 0xd8, 0x56, 0xe6, 0x64, 0xfa, 0xfa, 0x67, 0x29, 0x58, - 0x94, 0x11, 0x4b, 0x96, 0x04, 0xaf, 0xc1, 0x82, 0xa7, 0xef, 0x05, 0x61, 0xd1, 0x92, 0x11, 0x5e, - 0xcd, 0x2e, 0x01, 0x56, 0xb4, 0x30, 0x54, 0x72, 0xd1, 0x12, 0xfb, 0x06, 0x63, 0xfe, 0xd2, 0x6f, - 0x30, 0x32, 0xff, 0x2f, 0xdf, 0x60, 0xa8, 0xbf, 0x01, 0xb0, 0x61, 0xd9, 0x64, 0x20, 0x5a, 0x55, - 0x49, 0x25, 0x28, 0x4b, 0xf3, 0x64, 0x2b, 0x34, 0x4c, 0xf3, 0xda, 0x4d, 0xcc, 0x60, 0x0c, 0x35, - 0xb4, 0x4c, 0x79, 0x18, 0x39, 0xea, 0x31, 0x43, 0x0d, 0x2d, 0x33, 0x7a, 0xf6, 0xcb, 0x5c, 0xf1, - 0xec, 0xa7, 0x2e, 0xc3, 0x22, 0x16, 0x3d, 0x36, 0xa1, 0x83, 0x7a, 0x92, 0x82, 0x65, 0x99, 0xef, - 0x46, 0x21, 0xfb, 0x2b, 0x50, 0x10, 0xa9, 0xef, 0xb4, 0x08, 0xe4, 0x1f, 0x22, 0x08, 0xba, 0x76, - 0x13, 0xe7, 0x05, 0xba, 0x6d, 0xa2, 0x75, 0x28, 0x4a, 0xd2, 0xd8, 0xe7, 0x5d, 0x20, 0x40, 0x1d, - 0xb6, 0x9e, 0xb7, 0x21, 0xb3, 0x67, 0xd9, 0x44, 0x7a, 0x7e, 0x62, 0x44, 0x98, 0x5a, 0x64, 0x73, - 0x0e, 0x73, 0xea, 0x7a, 0x3e, 0x6c, 0xee, 0xa9, 0xff, 0x92, 0xe2, 0x2d, 0x66, 0x56, 0xaa, 0xc6, - 0xf5, 0x13, 0x55, 0xeb, 0x8c, 0x7e, 0x82, 0x8e, 0xe9, 0x27, 0xd0, 0x42, 0x3f, 0x49, 0x1a, 0xd7, - 0x4f, 0x80, 0x7e, 0x7a, 0xfd, 0xd0, 0x07, 0xb0, 0x20, 0x5b, 0x95, 0x32, 0xd4, 0xbd, 0x9a, 0xe8, - 0x19, 0x71, 0x4b, 0x6f, 0xce, 0xe1, 0x90, 0x27, 0xb6, 0xbc, 0x2d, 0xb8, 0x51, 0xb7, 0x75, 0xe3, - 0xc0, 0xb6, 0xfc, 0x80, 0x98, 0xf1, 0x08, 0xf4, 0x00, 0x72, 0xe7, 0xf2, 0xdc, 0xcb, 0x9a, 0xa8, - 0x92, 0x52, 0xfd, 0xf7, 0x14, 0x94, 0x36, 0x89, 0x6e, 0x07, 0xfb, 0xd3, 0x4e, 0x55, 0x40, 0xfc, - 0x40, 0xde, 0x8f, 0xfc, 0x37, 0xfa, 0x1a, 0xe4, 0xa3, 0x34, 0xe8, 0xca, 0xe7, 0xc0, 0x88, 0x14, - 0x3d, 0x84, 0x05, 0xa6, 0x3b, 0x1d, 0x87, 0xf5, 0xd5, 0x65, 0x2f, 0x4d, 0x92, 0x92, 0x5d, 0x5a, - 0x1e, 0xe1, 0x79, 0x0f, 0xb7, 0x53, 0x16, 0x87, 0x43, 0xf4, 0xf3, 0x50, 0xe2, 0x0f, 0x25, 0x61, - 0x9a, 0x97, 0xbd, 0x4a, 0x66, 0x51, 0xbc, 0x75, 0x8a, 0x14, 0xef, 0x8f, 0xd3, 0xb0, 0xb2, 0xad, - 0x4f, 0x76, 0x89, 0x0c, 0x43, 0xc4, 0xc4, 0xc4, 0xa0, 0x9e, 0x89, 0x7a, 0xf1, 0xf0, 0x75, 0xc9, - 0xd3, 0x69, 0x12, 0x73, 0x72, 0x14, 0x0b, 0x6b, 0xbe, 0x74, 0xac, 0xe6, 0x5b, 0x81, 0xac, 0x43, - 0x1d, 0x83, 0xc8, 0xd8, 0x26, 0x06, 0xea, 0x77, 0x52, 0xf1, 0xd8, 0x55, 0x8e, 0x9e, 0x35, 0x79, - 0xd3, 0xab, 0x43, 0x83, 0x68, 0x3a, 0xf4, 0x11, 0x94, 0xfb, 0xad, 0x06, 0x6e, 0x0d, 0xea, 0xdd, - 0x6f, 0x6a, 0xfd, 0xda, 0x56, 0xbf, 0xf6, 0xe0, 0x9e, 0xd6, 0xeb, 0x6e, 0x7d, 0xeb, 0xfe, 0xc3, - 0x7b, 0x5f, 0x53, 0x52, 0xe5, 0xca, 0xf1, 0x49, 0xe5, 0x56, 0xa7, 0xd6, 0xd8, 0x12, 0x27, 0x6e, - 0x97, 0x3e, 0xef, 0xeb, 0xb6, 0xaf, 0x3f, 0xb8, 0xd7, 0xa3, 0xf6, 0x84, 0xd1, 0xa0, 0xaf, 0x02, - 0xda, 0x68, 0xe1, 0x4e, 0x6b, 0xa0, 0x85, 0x01, 0xb2, 0x51, 0x6f, 0x28, 0x69, 0x51, 0x49, 0x6d, - 0x10, 0xcf, 0x21, 0x41, 0xad, 0xd5, 0xbf, 0xff, 0xe0, 0x51, 0xa3, 0xde, 0x60, 0x67, 0xbc, 0x14, - 0xbf, 0x2d, 0xe3, 0x49, 0x40, 0xea, 0xc2, 0x24, 0x60, 0x9a, 0x4b, 0xa4, 0x2f, 0xc8, 0x25, 0x36, - 0x60, 0xc5, 0xf0, 0xa8, 0xef, 0x6b, 0xac, 0x3c, 0x21, 0xe6, 0x4c, 0x01, 0xf4, 0xa5, 0xb3, 0xd3, - 0xf5, 0x6b, 0x0d, 0x86, 0xef, 0x73, 0xb4, 0x14, 0x7f, 0xcd, 0x88, 0x81, 0xf8, 0x4c, 0xea, 0xf7, - 0xe7, 0x59, 0xa6, 0x67, 0x1d, 0x5a, 0x36, 0x19, 0x12, 0x1f, 0x3d, 0x85, 0x65, 0xc3, 0x23, 0x26, - 0xab, 0x3b, 0x74, 0x3b, 0xfe, 0x65, 0xf4, 0xcf, 0x25, 0x26, 0x5d, 0x11, 0x63, 0xb5, 0x11, 0x71, - 0xf5, 0x5d, 0x62, 0xe0, 0x25, 0xe3, 0xdc, 0x18, 0x7d, 0x0c, 0xcb, 0x3e, 0xb1, 0x2d, 0x67, 0xfc, - 0x5c, 0x33, 0xa8, 0x13, 0x90, 0xe7, 0xe1, 0x73, 0xde, 0x55, 0x72, 0xfb, 0xad, 0x2d, 0xc6, 0xd5, - 0x10, 0x4c, 0x75, 0x74, 0x76, 0xba, 0xbe, 0x74, 0x1e, 0x86, 0x97, 0xa4, 0x64, 0x39, 0x2e, 0xef, - 0xc3, 0xd2, 0x79, 0x6d, 0xd0, 0x8a, 0x0c, 0x34, 0x3c, 0x5e, 0x45, 0x81, 0xe4, 0x16, 0xe4, 0x3d, - 0x32, 0xb4, 0xfc, 0xc0, 0x13, 0x66, 0x66, 0x98, 0x08, 0x82, 0x56, 0x21, 0x17, 0xfb, 0xe2, 0x84, - 0xe1, 0xe4, 0x98, 0x45, 0x10, 0xf1, 0x31, 0x59, 0xf9, 0xd7, 0x60, 0x46, 0x17, 0x76, 0xe8, 0x4c, - 0xcb, 0xd7, 0x77, 0xe5, 0x64, 0x79, 0x1c, 0x0e, 0x99, 0x2f, 0x8f, 0xfd, 0x28, 0x81, 0xe4, 0xbf, - 0x19, 0x8c, 0x67, 0x3a, 0xf2, 0xd3, 0x3a, 0x9e, 0xcb, 0x84, 0x5f, 0xf0, 0x66, 0x62, 0x5f, 0xf0, - 0xae, 0x40, 0xd6, 0x26, 0x87, 0xc4, 0x16, 0x39, 0x06, 0x16, 0x83, 0x3b, 0xf7, 0xa0, 0x14, 0x7e, - 0x2a, 0xca, 0xbf, 0x19, 0xc9, 0x43, 0x66, 0x50, 0xeb, 0x3f, 0x51, 0xe6, 0x10, 0x40, 0x4e, 0xf8, - 0xb8, 0x78, 0x84, 0x6c, 0x74, 0x3b, 0x1b, 0xed, 0xc7, 0x4a, 0xfa, 0xce, 0xef, 0x65, 0xa0, 0x10, - 0x3d, 0x83, 0xb1, 0x3b, 0xad, 0xd3, 0x7a, 0x16, 0x1e, 0x92, 0x08, 0xde, 0x21, 0x47, 0xe8, 0xd5, - 0x69, 0x03, 0xed, 0x23, 0xf1, 0xee, 0x1f, 0xa1, 0xc3, 0xe6, 0xd9, 0xeb, 0x90, 0xaf, 0xf5, 0xfb, - 0xed, 0xc7, 0x9d, 0x56, 0x53, 0xf9, 0x34, 0x55, 0xfe, 0xd2, 0xf1, 0x49, 0xe5, 0x5a, 0x44, 0x54, - 0xf3, 0x85, 0x5b, 0x72, 0xaa, 0x46, 0xa3, 0xd5, 0x1b, 0xb4, 0x9a, 0xca, 0x27, 0xe9, 0x59, 0x2a, - 0xde, 0x10, 0xe2, 0xdf, 0x33, 0x15, 0x7a, 0xb8, 0xd5, 0xab, 0x61, 0x36, 0xe1, 0xa7, 0x69, 0xd1, - 0xd7, 0x9b, 0xce, 0xe8, 0x11, 0x57, 0xf7, 0xd8, 0x9c, 0x6b, 0xe1, 0x67, 0x85, 0x9f, 0xcc, 0x8b, - 0x0f, 0x5b, 0xa6, 0x6f, 0x7a, 0x44, 0x37, 0x27, 0x6c, 0x36, 0xfe, 0x98, 0xca, 0xc5, 0xcc, 0xcf, - 0xcc, 0xd6, 0x67, 0x31, 0x8c, 0x49, 0x51, 0x61, 0x01, 0xef, 0x74, 0x3a, 0x8c, 0xe8, 0x93, 0xcc, - 0xcc, 0xea, 0xf0, 0xd8, 0x61, 0xc5, 0x3e, 0xba, 0x0d, 0xf9, 0xf0, 0xad, 0x55, 0xf9, 0x34, 0x33, - 0xa3, 0x50, 0x23, 0x7c, 0x28, 0xe6, 0x13, 0x6e, 0xee, 0x0c, 0xf8, 0x57, 0x8f, 0x9f, 0x64, 0x67, - 0x27, 0xdc, 0x1f, 0x07, 0x26, 0x3d, 0x72, 0xd8, 0x69, 0x96, 0x2d, 0xc4, 0x4f, 0xb3, 0x22, 0x4a, - 0x44, 0x34, 0xb2, 0x7f, 0xf8, 0x3a, 0xe4, 0x71, 0xeb, 0x1b, 0xe2, 0x03, 0xc9, 0x4f, 0x72, 0x33, - 0x72, 0x30, 0xf9, 0x98, 0x18, 0x6c, 0xb6, 0x0a, 0xe4, 0x70, 0x6b, 0xbb, 0xfb, 0xb4, 0xa5, 0xfc, - 0x41, 0x6e, 0x46, 0x0e, 0x26, 0x23, 0xca, 0x3f, 0xf8, 0xca, 0x77, 0x71, 0x6f, 0xb3, 0xc6, 0x37, - 0x65, 0x56, 0x4e, 0xd7, 0x73, 0xf7, 0x75, 0x87, 0x98, 0xd3, 0x8f, 0x7b, 0x22, 0xd4, 0x9d, 0x5f, - 0x82, 0x7c, 0x98, 0x53, 0xa3, 0x35, 0xc8, 0x3d, 0xeb, 0xe2, 0x27, 0x2d, 0xac, 0xcc, 0x09, 0x2b, - 0x87, 0x98, 0x67, 0xa2, 0x1a, 0xaa, 0xc0, 0xc2, 0x76, 0xad, 0x53, 0x7b, 0xdc, 0xc2, 0x61, 0xff, - 0x3f, 0x24, 0x90, 0x89, 0x61, 0x59, 0x91, 0x13, 0x44, 0x32, 0xeb, 0xaf, 0xff, 0xe0, 0xb3, 0xb5, - 0xb9, 0x1f, 0x7f, 0xb6, 0x36, 0xf7, 0xc9, 0xd9, 0x5a, 0xea, 0x07, 0x67, 0x6b, 0xa9, 0x1f, 0x9e, - 0xad, 0xa5, 0xfe, 0xed, 0x6c, 0x2d, 0xf5, 0x3b, 0x3f, 0x59, 0x9b, 0xfb, 0xe1, 0x4f, 0xd6, 0xe6, - 0x7e, 0xfc, 0x93, 0xb5, 0xb9, 0xdd, 0x1c, 0xbf, 0x7a, 0x1e, 0xfe, 0x5f, 0x00, 0x00, 0x00, 0xff, - 0xff, 0x4e, 0x60, 0x1a, 0x9d, 0x2d, 0x34, 0x00, 0x00, + // 5345 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x3a, 0x4b, 0x6c, 0x24, 0x49, + 0x56, 0xae, 0x72, 0x55, 0xb9, 0xea, 0x55, 0xd9, 0xce, 0x8e, 0xf6, 0xf6, 0xb8, 0x6b, 0x7a, 0x6c, + 0x4f, 0xce, 0xf4, 0xce, 0xec, 0xec, 0xe0, 0xfe, 0xcd, 0x8e, 0x7a, 0x66, 0x98, 0x9d, 0xa9, 0x4f, + 0xba, 0x5d, 0xdb, 0x76, 0x55, 0x29, 0xaa, 0xdc, 0xbd, 0x8b, 0x04, 0x49, 0x3a, 0x33, 0x5c, 0xce, + 0x76, 0x56, 0x46, 0x92, 0x99, 0x65, 0x77, 0xb1, 0x20, 0xe6, 0x04, 0xc8, 0x27, 0xb8, 0x2c, 0xbb, + 0x42, 0x96, 0x90, 0xe0, 0xc6, 0x81, 0x03, 0x07, 0x16, 0x4e, 0x83, 0x84, 0xd0, 0x8a, 0x0b, 0xbb, + 0x20, 0xc1, 0x0a, 0x90, 0x61, 0xbc, 0x12, 0x37, 0x04, 0x17, 0xc4, 0x85, 0x03, 0x8a, 0x4f, 0x66, + 0xa5, 0xab, 0xd3, 0xf6, 0xcc, 0x2e, 0x17, 0xbb, 0xe2, 0xfd, 0xf2, 0xc5, 0x8b, 0x17, 0x2f, 0xde, + 0x7b, 0x11, 0xf0, 0xd6, 0xc0, 0x0e, 0xf7, 0x47, 0xbb, 0xeb, 0x26, 0x1d, 0xde, 0xb1, 0xa8, 0x79, + 0x40, 0xfc, 0x3b, 0xc1, 0x91, 0xe1, 0x0f, 0x0f, 0xec, 0xf0, 0x8e, 0xe1, 0xd9, 0x77, 0xc2, 0xb1, + 0x47, 0x82, 0x75, 0xcf, 0xa7, 0x21, 0x45, 0x48, 0x10, 0xac, 0x47, 0x04, 0xeb, 0x87, 0xf7, 0xaa, + 0xab, 0x03, 0x4a, 0x07, 0x0e, 0xb9, 0xc3, 0x29, 0x76, 0x47, 0x7b, 0x77, 0x42, 0x7b, 0x48, 0x82, + 0xd0, 0x18, 0x7a, 0x82, 0xa9, 0xba, 0x32, 0x4d, 0x60, 0x8d, 0x7c, 0x23, 0xb4, 0xa9, 0x7b, 0x11, + 0xfe, 0xc8, 0x37, 0x3c, 0x8f, 0xf8, 0xf2, 0xa3, 0xd5, 0xa5, 0x01, 0x1d, 0x50, 0xfe, 0xf3, 0x0e, + 0xfb, 0x25, 0xa0, 0xea, 0x2a, 0xcc, 0x3d, 0x21, 0x7e, 0x60, 0x53, 0x17, 0x2d, 0x41, 0xde, 0x76, + 0x2d, 0xf2, 0x7c, 0x39, 0xb3, 0x96, 0x79, 0x33, 0x87, 0xc5, 0x40, 0xbd, 0x0b, 0xd0, 0x62, 0x3f, + 0x34, 0x37, 0xf4, 0xc7, 0x48, 0x81, 0xd9, 0x03, 0x32, 0xe6, 0x14, 0x25, 0xcc, 0x7e, 0x32, 0xc8, + 0xa1, 0xe1, 0x2c, 0x67, 0x05, 0xe4, 0xd0, 0x70, 0xd4, 0xcf, 0x32, 0x50, 0xae, 0xb9, 0x2e, 0x0d, + 0xb9, 0x76, 0x01, 0x42, 0x90, 0x73, 0x8d, 0x21, 0x91, 0x4c, 0xfc, 0x37, 0x6a, 0x40, 0xc1, 0x31, + 0x76, 0x89, 0x13, 0x2c, 0x67, 0xd7, 0x66, 0xdf, 0x2c, 0xdf, 0xff, 0xea, 0xfa, 0x8b, 0x26, 0x59, + 0x4f, 0x08, 0x59, 0xdf, 0xe2, 0xd4, 0x5c, 0x09, 0x2c, 0x59, 0xd1, 0xd7, 0x61, 0xce, 0x76, 0x2d, + 0xdb, 0x24, 0xc1, 0x72, 0x8e, 0x4b, 0x59, 0x49, 0x93, 0x32, 0xd1, 0xbe, 0x9e, 0xfb, 0xc1, 0xe9, + 0xea, 0x0c, 0x8e, 0x98, 0xaa, 0xef, 0x41, 0x39, 0x21, 0x36, 0x65, 0x6e, 0x4b, 0x90, 0x3f, 0x34, + 0x9c, 0x11, 0x91, 0xb3, 0x13, 0x83, 0xf7, 0xb3, 0x0f, 0x33, 0xea, 0xc7, 0xb0, 0xd4, 0x36, 0x86, + 0xc4, 0x7a, 0x44, 0x5c, 0xe2, 0xdb, 0x26, 0x26, 0x01, 0x1d, 0xf9, 0x26, 0x61, 0x73, 0x3d, 0xb0, + 0x5d, 0x2b, 0x9a, 0x2b, 0xfb, 0x9d, 0x2e, 0x45, 0x6d, 0xc0, 0x4b, 0x4d, 0x3b, 0x30, 0x7d, 0x12, + 0x92, 0x2f, 0x2c, 0x64, 0x36, 0x12, 0x72, 0x9a, 0x81, 0xc5, 0x69, 0xee, 0x5f, 0x80, 0xeb, 0xcc, + 0xc4, 0x96, 0xee, 0x4b, 0x88, 0x1e, 0x78, 0xc4, 0xe4, 0xc2, 0xca, 0xf7, 0xdf, 0x4c, 0xb3, 0x50, + 0xda, 0x4c, 0x36, 0x67, 0xf0, 0x35, 0x2e, 0x26, 0x02, 0xf4, 0x3c, 0x62, 0x22, 0x13, 0x6e, 0x58, + 0x52, 0xe9, 0x29, 0xf1, 0x59, 0x2e, 0x3e, 0x75, 0x19, 0x2f, 0x98, 0xe6, 0xe6, 0x0c, 0x5e, 0x8a, + 0x84, 0x25, 0x3f, 0x52, 0x07, 0x28, 0x46, 0xb2, 0xd5, 0xef, 0x66, 0xa0, 0x14, 0x21, 0x03, 0xf4, + 0x15, 0x28, 0xb9, 0x86, 0x4b, 0x75, 0xd3, 0x1b, 0x05, 0x7c, 0x42, 0xb3, 0xf5, 0xca, 0xd9, 0xe9, + 0x6a, 0xb1, 0x6d, 0xb8, 0xb4, 0xd1, 0xdd, 0x09, 0x70, 0x91, 0xa1, 0x1b, 0xde, 0x28, 0x40, 0xaf, + 0x42, 0x65, 0x48, 0x86, 0xd4, 0x1f, 0xeb, 0xbb, 0xe3, 0x90, 0x04, 0xd2, 0x6c, 0x65, 0x01, 0xab, + 0x33, 0x10, 0xfa, 0x10, 0xe6, 0x06, 0x42, 0xa5, 0xe5, 0x59, 0xee, 0x3e, 0xaf, 0xa5, 0x69, 0x3f, + 0xa5, 0x35, 0x8e, 0x78, 0xd4, 0xef, 0x64, 0x61, 0x29, 0x86, 0x92, 0x5f, 0x19, 0xd9, 0x3e, 0x19, + 0x12, 0x37, 0x0c, 0xd0, 0xd7, 0xa0, 0xe0, 0xd8, 0x43, 0x3b, 0x0c, 0xa4, 0xcd, 0x5f, 0x49, 0x13, + 0x1b, 0x4f, 0x0a, 0x4b, 0x62, 0x54, 0x83, 0x8a, 0x4f, 0x02, 0xe2, 0x1f, 0x0a, 0x8f, 0x97, 0x16, + 0xbd, 0x82, 0xf9, 0x1c, 0x0b, 0x7a, 0x1f, 0x20, 0x38, 0x32, 0x3c, 0x39, 0xe5, 0x59, 0x2e, 0xe0, + 0xe5, 0x75, 0x11, 0x17, 0xd6, 0xa3, 0xb8, 0xb0, 0xde, 0x72, 0xc3, 0x77, 0xdf, 0x79, 0xc2, 0xfc, + 0x07, 0x97, 0x18, 0xb9, 0xb0, 0xc6, 0x26, 0x5c, 0x93, 0x06, 0x63, 0x30, 0xcf, 0x76, 0x49, 0xc0, + 0xb6, 0xd5, 0x95, 0x22, 0x14, 0xc1, 0xd5, 0x8b, 0x99, 0xd4, 0x0d, 0x28, 0x76, 0x1d, 0x23, 0xdc, + 0xa3, 0xfe, 0x10, 0xa9, 0x50, 0x31, 0x7c, 0x73, 0xdf, 0x0e, 0x89, 0x19, 0x8e, 0xfc, 0x28, 0x06, + 0x9c, 0x83, 0xa1, 0x1b, 0x90, 0xa5, 0x62, 0xba, 0xa5, 0x7a, 0xe1, 0xec, 0x74, 0x35, 0xdb, 0xe9, + 0xe1, 0x2c, 0x0d, 0xd4, 0x0f, 0xe0, 0x5a, 0xd7, 0x19, 0x0d, 0x6c, 0xb7, 0x49, 0x02, 0xd3, 0xb7, + 0x3d, 0x36, 0x47, 0xb6, 0x37, 0x58, 0x24, 0x8d, 0xf6, 0x06, 0xfb, 0x1d, 0x07, 0x98, 0xec, 0x24, + 0xc0, 0xa8, 0xbf, 0x95, 0x85, 0x6b, 0x9a, 0x3b, 0xb0, 0x5d, 0x92, 0xe4, 0xbe, 0x0d, 0x0b, 0x84, + 0x03, 0xf5, 0x43, 0x11, 0xf4, 0xa4, 0x9c, 0x79, 0x01, 0x8d, 0x22, 0x61, 0x6b, 0x2a, 0x3a, 0xdd, + 0x4b, 0x5b, 0x84, 0x17, 0xa4, 0xa7, 0xc6, 0x28, 0x0d, 0xe6, 0x3c, 0x3e, 0x89, 0x40, 0x3a, 0xd9, + 0xed, 0x34, 0x59, 0x2f, 0xcc, 0x33, 0x0a, 0x55, 0x92, 0xf7, 0x67, 0x09, 0x55, 0x7f, 0x93, 0x85, + 0xc5, 0x36, 0xb5, 0xce, 0xd9, 0xa1, 0x0a, 0xc5, 0x7d, 0x1a, 0x84, 0x89, 0xb0, 0x1c, 0x8f, 0xd1, + 0x43, 0x28, 0x7a, 0x72, 0xf9, 0xa4, 0x0f, 0xde, 0x4a, 0x57, 0x59, 0xd0, 0xe0, 0x98, 0x1a, 0x7d, + 0x00, 0xa5, 0x68, 0xe3, 0x46, 0xde, 0x77, 0x85, 0xfb, 0x4e, 0xe8, 0xd1, 0x87, 0x50, 0x10, 0x8b, + 0x20, 0x9d, 0xee, 0xf6, 0xe7, 0xb2, 0x39, 0x96, 0x4c, 0xe8, 0x11, 0x14, 0x43, 0x27, 0xd0, 0x6d, + 0x77, 0x8f, 0x2e, 0xe7, 0xb9, 0x80, 0xd5, 0xd4, 0x50, 0x47, 0x2d, 0xd2, 0xdf, 0xea, 0xb5, 0xdc, + 0x3d, 0x5a, 0x2f, 0x9f, 0x9d, 0xae, 0xce, 0xc9, 0x01, 0x9e, 0x0b, 0x9d, 0x80, 0xfd, 0x40, 0xb7, + 0x20, 0xb7, 0x67, 0x7b, 0xc1, 0x72, 0x61, 0x2d, 0xf3, 0x66, 0xb1, 0x5e, 0x3c, 0x3b, 0x5d, 0xcd, + 0x6d, 0xb4, 0xba, 0x3d, 0xcc, 0xa1, 0xea, 0xef, 0x66, 0xa0, 0x9c, 0x90, 0x81, 0x5e, 0x01, 0x08, + 0xfd, 0x51, 0x10, 0xea, 0x3e, 0xa5, 0x21, 0x37, 0x65, 0x05, 0x97, 0x38, 0x04, 0x53, 0x1a, 0xa2, + 0x75, 0xb8, 0x6e, 0x12, 0x3f, 0xd4, 0xed, 0x20, 0x18, 0x11, 0x5f, 0x0f, 0x46, 0xbb, 0xcf, 0x88, + 0x19, 0x72, 0xb3, 0x56, 0xf0, 0x35, 0x86, 0x6a, 0x71, 0x4c, 0x4f, 0x20, 0xd0, 0x03, 0xb8, 0x91, + 0xa4, 0xf7, 0x46, 0xbb, 0x8e, 0x6d, 0xea, 0x6c, 0xa9, 0x67, 0x39, 0xcb, 0xf5, 0x09, 0x4b, 0x97, + 0xe3, 0x1e, 0x93, 0xb1, 0xfa, 0xe3, 0x0c, 0x28, 0xd8, 0xd8, 0x0b, 0xb7, 0xc9, 0x70, 0x97, 0xf8, + 0xbd, 0xd0, 0x08, 0x47, 0x01, 0xba, 0x01, 0x05, 0x87, 0x18, 0x16, 0xf1, 0xb9, 0x52, 0x45, 0x2c, + 0x47, 0x68, 0x87, 0x45, 0x19, 0xc3, 0xdc, 0x37, 0x76, 0x6d, 0xc7, 0x0e, 0xc7, 0x5c, 0x95, 0x85, + 0x74, 0x07, 0x9f, 0x96, 0xb9, 0x8e, 0x13, 0x8c, 0xf8, 0x9c, 0x18, 0xb4, 0x0c, 0x73, 0x43, 0x12, + 0x04, 0xc6, 0x80, 0x70, 0x4d, 0x4b, 0x38, 0x1a, 0xaa, 0x1f, 0x40, 0x25, 0xc9, 0x87, 0xca, 0x30, + 0xb7, 0xd3, 0x7e, 0xdc, 0xee, 0x3c, 0x6d, 0x2b, 0x33, 0x68, 0x11, 0xca, 0x3b, 0x6d, 0xac, 0xd5, + 0x1a, 0x9b, 0xb5, 0xfa, 0x96, 0xa6, 0x64, 0xd0, 0x3c, 0x94, 0x26, 0xc3, 0xac, 0xfa, 0xa7, 0x19, + 0x00, 0x66, 0x6e, 0x39, 0xa9, 0xf7, 0x21, 0x1f, 0x84, 0x46, 0x28, 0x7c, 0x76, 0xe1, 0xfe, 0xeb, + 0x17, 0xad, 0xb0, 0xd4, 0x97, 0xfd, 0x23, 0x58, 0xb0, 0x24, 0x35, 0xcc, 0x9e, 0xd3, 0x90, 0x85, + 0x0f, 0xc3, 0xb2, 0x7c, 0xa9, 0x38, 0xff, 0xad, 0x7e, 0x00, 0x79, 0xce, 0x7d, 0x5e, 0xdd, 0x22, + 0xe4, 0x9a, 0xec, 0x57, 0x06, 0x95, 0x20, 0x8f, 0xb5, 0x5a, 0xf3, 0x5b, 0x4a, 0x16, 0x29, 0x50, + 0x69, 0xb6, 0x7a, 0x8d, 0x4e, 0xbb, 0xad, 0x35, 0xfa, 0x5a, 0x53, 0x99, 0x55, 0x6f, 0x43, 0xbe, + 0x35, 0x64, 0x92, 0x6f, 0xb1, 0x0d, 0xb1, 0x47, 0x7c, 0xe2, 0x9a, 0xd1, 0x3e, 0x9b, 0x00, 0xd4, + 0xcf, 0x2a, 0x90, 0xdf, 0xa6, 0x23, 0x37, 0x44, 0xf7, 0x13, 0x41, 0x6d, 0x21, 0x3d, 0x8b, 0xe1, + 0x84, 0xeb, 0xfd, 0xb1, 0x47, 0x64, 0xd0, 0xbb, 0x01, 0x05, 0xb1, 0x75, 0xe4, 0x74, 0xe4, 0x88, + 0xc1, 0x43, 0xc3, 0x1f, 0x90, 0x50, 0xce, 0x47, 0x8e, 0xd0, 0x9b, 0xec, 0x54, 0x35, 0x2c, 0xea, + 0x3a, 0x63, 0xbe, 0xc3, 0x8a, 0xe2, 0xe8, 0xc4, 0xc4, 0xb0, 0x3a, 0xae, 0x33, 0xc6, 0x31, 0x16, + 0x3d, 0x82, 0xb2, 0x49, 0xdd, 0xc0, 0x0e, 0x42, 0xe2, 0x9a, 0xe3, 0xe5, 0x22, 0x57, 0xea, 0xf6, + 0xc5, 0x4a, 0x35, 0x26, 0xc4, 0x38, 0xc9, 0x89, 0x36, 0xa1, 0xb2, 0x6b, 0xbb, 0x96, 0x4e, 0x3d, + 0x71, 0xa2, 0xe5, 0x2f, 0xde, 0xd8, 0x42, 0x52, 0xdd, 0x76, 0xad, 0x8e, 0x20, 0xc6, 0xe5, 0xdd, + 0xc9, 0x00, 0xb5, 0x61, 0xe1, 0x90, 0x3a, 0xa3, 0x21, 0x89, 0x65, 0x15, 0xb8, 0xac, 0x37, 0x2e, + 0x96, 0xf5, 0x84, 0xd3, 0x47, 0xd2, 0xe6, 0x0f, 0x93, 0x43, 0xf4, 0x18, 0xe6, 0xc3, 0xa1, 0xb7, + 0x17, 0xc4, 0xe2, 0xe6, 0xb8, 0xb8, 0x2f, 0x5f, 0x62, 0x79, 0x46, 0x1e, 0x49, 0xab, 0x84, 0x89, + 0x51, 0xf5, 0xfb, 0xb3, 0x50, 0x4e, 0x68, 0x8e, 0x7a, 0x50, 0xf6, 0x7c, 0xea, 0x19, 0x03, 0x7e, + 0x2a, 0xcb, 0x45, 0xbd, 0xf7, 0xb9, 0x66, 0xbd, 0xde, 0x9d, 0x30, 0xe2, 0xa4, 0x14, 0xf4, 0x0e, + 0x54, 0x5c, 0xea, 0xfa, 0xc4, 0x1c, 0xf9, 0x81, 0x7d, 0x28, 0x16, 0xbd, 0x58, 0x57, 0xce, 0x4e, + 0x57, 0x2b, 0x6d, 0xea, 0xe2, 0x08, 0x8e, 0xcf, 0x51, 0xa9, 0x27, 0x59, 0x28, 0x27, 0x44, 0xa2, + 0xb7, 0xa0, 0x88, 0xbb, 0xb8, 0xf5, 0xa4, 0xd6, 0xd7, 0x94, 0x99, 0xea, 0xad, 0xe3, 0x93, 0xb5, + 0x65, 0xae, 0x43, 0xf2, 0xb3, 0x5d, 0xdf, 0x3e, 0x64, 0x9e, 0xff, 0x26, 0xcc, 0x45, 0xa4, 0x99, + 0xea, 0xcb, 0xc7, 0x27, 0x6b, 0x2f, 0x4d, 0x93, 0x26, 0x28, 0x71, 0x6f, 0xb3, 0x86, 0xb5, 0xa6, + 0x92, 0x4d, 0xa7, 0xc4, 0xbd, 0x7d, 0xc3, 0x27, 0x16, 0xfa, 0x32, 0x14, 0x24, 0xe1, 0x6c, 0xb5, + 0x7a, 0x7c, 0xb2, 0x76, 0x63, 0x9a, 0x70, 0x42, 0x87, 0x7b, 0x5b, 0xb5, 0x27, 0x9a, 0x92, 0x4b, + 0xa7, 0xc3, 0x3d, 0xc7, 0x38, 0x24, 0xe8, 0x75, 0xc8, 0x0b, 0xb2, 0x7c, 0xf5, 0xe6, 0xf1, 0xc9, + 0xda, 0x97, 0x5e, 0x10, 0xc7, 0xa8, 0xaa, 0xcb, 0xbf, 0xfd, 0x87, 0x2b, 0x33, 0x7f, 0xf1, 0x47, + 0x2b, 0xca, 0x34, 0xba, 0xfa, 0xbf, 0x19, 0x98, 0x3f, 0xe7, 0x28, 0x48, 0x85, 0x82, 0x4b, 0x4d, + 0xea, 0x89, 0xc3, 0xb5, 0x58, 0x87, 0xb3, 0xd3, 0xd5, 0x42, 0x9b, 0x36, 0xa8, 0x37, 0xc6, 0x12, + 0x83, 0x1e, 0x4f, 0xa5, 0x07, 0x0f, 0x3e, 0xa7, 0x17, 0xa6, 0x26, 0x08, 0x1f, 0xc1, 0xbc, 0xe5, + 0xdb, 0x87, 0xc4, 0xd7, 0x4d, 0xea, 0xee, 0xd9, 0x03, 0x79, 0x70, 0x56, 0x53, 0x33, 0x69, 0x4e, + 0x88, 0x2b, 0x82, 0xa1, 0xc1, 0xe9, 0x7f, 0x86, 0xd4, 0xa0, 0xea, 0x41, 0x25, 0xe9, 0xd7, 0xec, + 0x34, 0x0b, 0xec, 0x5f, 0x25, 0x32, 0x7f, 0xe4, 0x09, 0x36, 0x2e, 0x31, 0x88, 0x48, 0x11, 0xdf, + 0x80, 0xdc, 0x90, 0x5a, 0x42, 0xce, 0x7c, 0xfd, 0x3a, 0xcb, 0x50, 0xfe, 0xe9, 0x74, 0xb5, 0x4c, + 0x83, 0xf5, 0x0d, 0xdb, 0x21, 0xdb, 0xd4, 0x22, 0x98, 0x13, 0xb0, 0x58, 0x1b, 0x6d, 0x2c, 0x79, + 0x1a, 0xc8, 0xa1, 0xfa, 0xbd, 0x0c, 0xe4, 0x58, 0x10, 0x43, 0x2f, 0x43, 0xae, 0xde, 0x6a, 0x37, + 0x95, 0x99, 0xea, 0xb5, 0xe3, 0x93, 0xb5, 0x79, 0x6e, 0x2d, 0x86, 0x60, 0x9b, 0x01, 0xad, 0x42, + 0xe1, 0x49, 0x67, 0x6b, 0x67, 0x9b, 0x79, 0xde, 0xf5, 0xe3, 0x93, 0xb5, 0xc5, 0x18, 0x2d, 0xec, + 0x89, 0x5e, 0x81, 0x7c, 0x7f, 0xbb, 0xbb, 0xd1, 0x53, 0xb2, 0x55, 0x74, 0x7c, 0xb2, 0xb6, 0x10, + 0xe3, 0xf9, 0x74, 0xd0, 0xab, 0x90, 0x6f, 0x77, 0x5b, 0x5d, 0x4d, 0x99, 0xad, 0xde, 0x38, 0x3e, + 0x59, 0x43, 0x31, 0x9a, 0x57, 0x3a, 0x5d, 0xdb, 0x23, 0xd5, 0x6b, 0xd2, 0x27, 0x4a, 0x31, 0x4e, + 0xfd, 0x51, 0x06, 0xca, 0x89, 0x58, 0xc6, 0xdc, 0xba, 0xa9, 0x6d, 0xd4, 0x76, 0xb6, 0xfa, 0xca, + 0x4c, 0xc2, 0xad, 0x13, 0x24, 0x4d, 0xb2, 0x67, 0x8c, 0x1c, 0x16, 0x5b, 0xa1, 0xd1, 0x69, 0xf7, + 0x5a, 0xbd, 0xbe, 0xd6, 0xee, 0x2b, 0x99, 0xea, 0xf2, 0xf1, 0xc9, 0xda, 0xd2, 0x34, 0xf1, 0xc6, + 0xc8, 0x71, 0x98, 0x63, 0x37, 0x6a, 0x8d, 0x4d, 0xbe, 0x53, 0x26, 0x8e, 0x9d, 0xa0, 0x6a, 0x18, + 0xe6, 0x3e, 0xb1, 0xd0, 0xdb, 0x50, 0x6a, 0x6a, 0x5b, 0xda, 0xa3, 0x1a, 0x3f, 0x51, 0xaa, 0xaf, + 0x1c, 0x9f, 0xac, 0xdd, 0x7c, 0xf1, 0xeb, 0x0e, 0x19, 0x18, 0x21, 0xb1, 0xa6, 0x1c, 0x3c, 0x41, + 0xa2, 0xfe, 0x77, 0x16, 0xe6, 0x31, 0x09, 0x42, 0xc3, 0x0f, 0xbb, 0xd4, 0xb1, 0xcd, 0x31, 0xea, + 0x42, 0xc9, 0xa4, 0xae, 0x65, 0x27, 0x62, 0xd3, 0xfd, 0x0b, 0x92, 0xb4, 0x09, 0x57, 0x34, 0x6a, + 0x44, 0x9c, 0x78, 0x22, 0x04, 0xdd, 0x81, 0xbc, 0x45, 0x1c, 0x63, 0x2c, 0xb3, 0xc5, 0x9b, 0x2f, + 0x54, 0x0b, 0x4d, 0xd9, 0xa8, 0xc0, 0x82, 0x8e, 0xd7, 0x66, 0xc6, 0x73, 0xdd, 0x08, 0x43, 0x32, + 0xf4, 0x42, 0xe1, 0x23, 0x39, 0x5c, 0x1e, 0x1a, 0xcf, 0x6b, 0x12, 0x84, 0xee, 0x41, 0xe1, 0xc8, + 0x76, 0x2d, 0x7a, 0x24, 0xb3, 0xc1, 0x4b, 0x84, 0x4a, 0x42, 0xf5, 0x98, 0xa5, 0x41, 0x53, 0x6a, + 0x32, 0x37, 0x6b, 0x77, 0xda, 0x5a, 0xe4, 0x66, 0x12, 0xdf, 0x71, 0xdb, 0xd4, 0x65, 0xd1, 0x03, + 0x3a, 0x6d, 0x7d, 0xa3, 0xd6, 0xda, 0xda, 0xc1, 0xcc, 0xd5, 0x96, 0x8e, 0x4f, 0xd6, 0x94, 0x98, + 0x64, 0xc3, 0xb0, 0x1d, 0x56, 0x9e, 0xdc, 0x84, 0xd9, 0x5a, 0xfb, 0x5b, 0x4a, 0xb6, 0xaa, 0x1c, + 0x9f, 0xac, 0x55, 0x62, 0x74, 0xcd, 0x1d, 0x4f, 0xec, 0x3e, 0xfd, 0x5d, 0xf5, 0x6f, 0x67, 0xa1, + 0xb2, 0xe3, 0x59, 0x46, 0x48, 0xc4, 0x2e, 0x45, 0x6b, 0x50, 0xf6, 0x0c, 0xdf, 0x70, 0x1c, 0xe2, + 0xd8, 0xc1, 0x50, 0xb6, 0x58, 0x92, 0x20, 0xf4, 0xde, 0xe7, 0x35, 0x63, 0xbd, 0xc8, 0x76, 0xde, + 0x77, 0xff, 0x75, 0x35, 0x13, 0x19, 0x74, 0x07, 0x16, 0xf6, 0x84, 0xb6, 0xba, 0x61, 0xf2, 0x85, + 0x9d, 0xe5, 0x0b, 0xbb, 0x9e, 0xb6, 0xb0, 0x49, 0xb5, 0xd6, 0xe5, 0x24, 0x6b, 0x9c, 0x0b, 0xcf, + 0xef, 0x25, 0x87, 0xe8, 0x01, 0xcc, 0x0d, 0xa9, 0x6b, 0x87, 0xd4, 0xbf, 0x7a, 0x15, 0x22, 0x4a, + 0xf4, 0x16, 0x5c, 0x63, 0x8b, 0x1b, 0xe9, 0xc3, 0xd1, 0xfc, 0xe4, 0xcf, 0xe2, 0xc5, 0xa1, 0xf1, + 0x5c, 0x7e, 0x10, 0x33, 0x30, 0xaa, 0x43, 0x9e, 0xfa, 0x2c, 0x47, 0x2d, 0x70, 0x75, 0xdf, 0xbe, + 0x52, 0x5d, 0x31, 0xe8, 0x30, 0x1e, 0x2c, 0x58, 0xd5, 0x77, 0x61, 0xfe, 0xdc, 0x24, 0x58, 0x6a, + 0xd6, 0xad, 0xed, 0xf4, 0x34, 0x65, 0x06, 0x55, 0xa0, 0xd8, 0xe8, 0xb4, 0xfb, 0xad, 0xf6, 0x0e, + 0xcb, 0x2d, 0x2b, 0x50, 0xc4, 0x9d, 0xad, 0xad, 0x7a, 0xad, 0xf1, 0x58, 0xc9, 0xaa, 0xeb, 0x50, + 0x4e, 0x48, 0x43, 0x0b, 0x00, 0xbd, 0x7e, 0xa7, 0xab, 0x6f, 0xb4, 0x70, 0xaf, 0x2f, 0x32, 0xd3, + 0x5e, 0xbf, 0x86, 0xfb, 0x12, 0x90, 0x51, 0xff, 0x33, 0x1b, 0xad, 0xa8, 0x4c, 0x46, 0xeb, 0xe7, + 0x93, 0xd1, 0x4b, 0x94, 0x97, 0xe9, 0xe8, 0x64, 0x10, 0x27, 0xa5, 0xef, 0x01, 0x70, 0xc7, 0x21, + 0x96, 0x6e, 0x84, 0x72, 0xe1, 0xab, 0x2f, 0x18, 0xb9, 0x1f, 0x75, 0x02, 0x71, 0x49, 0x52, 0xd7, + 0x42, 0xf4, 0x21, 0x54, 0x4c, 0x3a, 0xf4, 0x1c, 0x22, 0x99, 0x67, 0xaf, 0x64, 0x2e, 0xc7, 0xf4, + 0xb5, 0x30, 0x99, 0x0e, 0xe7, 0xce, 0x27, 0xec, 0xbf, 0x99, 0x89, 0x2c, 0x93, 0x92, 0x01, 0x57, + 0xa0, 0xb8, 0xd3, 0x6d, 0xd6, 0xfa, 0xad, 0xf6, 0x23, 0x25, 0x83, 0x00, 0x0a, 0xdc, 0xd4, 0x4d, + 0x25, 0xcb, 0x32, 0xf7, 0x46, 0x67, 0xbb, 0xbb, 0xa5, 0xf1, 0x88, 0x85, 0x96, 0x40, 0x89, 0x8c, + 0xad, 0x73, 0x43, 0x6a, 0x4d, 0x25, 0x87, 0xae, 0xc3, 0x62, 0x0c, 0x95, 0x9c, 0x79, 0x74, 0x03, + 0x50, 0x0c, 0x9c, 0x88, 0x28, 0xa8, 0xbf, 0x0e, 0x8b, 0x0d, 0xea, 0x86, 0x86, 0xed, 0xc6, 0x55, + 0xcd, 0x7d, 0x36, 0x69, 0x09, 0xd2, 0x6d, 0xd9, 0x21, 0xab, 0x2f, 0x9e, 0x9d, 0xae, 0x96, 0x63, + 0xd2, 0x56, 0x93, 0x67, 0xa1, 0x72, 0x60, 0xb1, 0xfd, 0xeb, 0xd9, 0x16, 0x37, 0x6e, 0xbe, 0x3e, + 0x77, 0x76, 0xba, 0x3a, 0xdb, 0x6d, 0x35, 0x31, 0x83, 0xa1, 0x97, 0xa1, 0x44, 0x9e, 0xdb, 0xa1, + 0x6e, 0xb2, 0x53, 0x8d, 0x19, 0x30, 0x8f, 0x8b, 0x0c, 0xd0, 0xa0, 0x16, 0x51, 0xeb, 0x00, 0x5d, + 0xea, 0x87, 0xf2, 0xcb, 0xef, 0x40, 0xde, 0xa3, 0x3e, 0xef, 0xe9, 0x5c, 0xd8, 0x69, 0x64, 0xe4, + 0xc2, 0x51, 0xb1, 0x20, 0x56, 0xbf, 0x37, 0x0b, 0xd0, 0x37, 0x82, 0x03, 0x29, 0xe4, 0x21, 0x94, + 0xe2, 0xae, 0xae, 0x6c, 0x0e, 0x5d, 0xba, 0xda, 0x31, 0x31, 0x7a, 0x10, 0x39, 0x9b, 0xa8, 0xd7, + 0x52, 0xcb, 0xea, 0xe8, 0x43, 0x69, 0x25, 0xcf, 0xf9, 0xa2, 0x8c, 0x25, 0x09, 0xc4, 0xf7, 0xe5, + 0xca, 0xb3, 0x9f, 0xa8, 0xc1, 0x8f, 0x05, 0x61, 0x34, 0x99, 0xa8, 0xa7, 0xb6, 0xc3, 0xa6, 0x56, + 0x64, 0x73, 0x06, 0x4f, 0xf8, 0xd0, 0x47, 0x50, 0x66, 0xf3, 0xd6, 0x03, 0x8e, 0x93, 0x39, 0xfa, + 0x85, 0xa6, 0x12, 0x12, 0x30, 0x78, 0x13, 0x2b, 0xbf, 0x02, 0x60, 0x78, 0x9e, 0x63, 0x13, 0x4b, + 0xdf, 0x1d, 0xf3, 0xa4, 0xbc, 0x84, 0x4b, 0x12, 0x52, 0x1f, 0xb3, 0xed, 0x12, 0xa1, 0x8d, 0x90, + 0x17, 0x26, 0x57, 0x18, 0x50, 0x52, 0xd7, 0xc2, 0xba, 0x02, 0x0b, 0xfe, 0xc8, 0x65, 0x06, 0x95, + 0xda, 0xa9, 0x7f, 0x92, 0x85, 0x97, 0xda, 0x24, 0x3c, 0xa2, 0xfe, 0x41, 0x2d, 0x0c, 0x0d, 0x73, + 0x7f, 0x48, 0x5c, 0xb9, 0x7c, 0x89, 0x22, 0x2a, 0x73, 0xae, 0x88, 0x5a, 0x86, 0x39, 0xc3, 0xb1, + 0x8d, 0x80, 0x88, 0xd4, 0xaf, 0x84, 0xa3, 0x21, 0x2b, 0xf5, 0x58, 0xe1, 0x48, 0x82, 0x80, 0x88, + 0x4e, 0x0f, 0x53, 0x3c, 0x02, 0xa0, 0x6f, 0xc3, 0x0d, 0x99, 0xe4, 0x19, 0xf1, 0xa7, 0x58, 0xed, + 0x11, 0x35, 0xae, 0xb5, 0xd4, 0x4a, 0x36, 0x5d, 0x39, 0x99, 0x05, 0x4e, 0xc0, 0x1d, 0x2f, 0x94, + 0x39, 0xe5, 0x92, 0x95, 0x82, 0xaa, 0x3e, 0x82, 0x9b, 0x17, 0xb2, 0x7c, 0xa1, 0x4e, 0xd2, 0xdf, + 0x67, 0x01, 0x5a, 0xdd, 0xda, 0xb6, 0x34, 0x52, 0x13, 0x0a, 0x7b, 0xc6, 0xd0, 0x76, 0xc6, 0x97, + 0x45, 0xc0, 0x09, 0xfd, 0x7a, 0x4d, 0x98, 0x63, 0x83, 0xf3, 0x60, 0xc9, 0xcb, 0xeb, 0xd8, 0xd1, + 0xae, 0x4b, 0xc2, 0xb8, 0x8e, 0xe5, 0x23, 0xa6, 0x86, 0x6f, 0xb8, 0xb1, 0xeb, 0x8a, 0x01, 0x5b, + 0x00, 0x96, 0xf2, 0x1c, 0x19, 0xe3, 0x28, 0x6c, 0xc9, 0x21, 0xda, 0xe4, 0x5d, 0x63, 0xe2, 0x1f, + 0x12, 0x6b, 0x39, 0xcf, 0x8d, 0x7a, 0x95, 0x3e, 0x58, 0x92, 0x0b, 0xdb, 0xc5, 0xdc, 0xd5, 0x0f, + 0x78, 0xca, 0x34, 0x41, 0x7d, 0x21, 0x1b, 0xdd, 0x85, 0xf9, 0x73, 0xf3, 0x7c, 0xa1, 0x81, 0xd0, + 0xea, 0x3e, 0x79, 0x47, 0xc9, 0xc9, 0x5f, 0xef, 0x2a, 0x05, 0xf5, 0xaf, 0x67, 0x45, 0xa0, 0x91, + 0x56, 0x4d, 0xbf, 0x2d, 0x29, 0x72, 0xef, 0x36, 0xa9, 0x23, 0x03, 0xc0, 0x1b, 0x97, 0xc7, 0x1f, + 0x56, 0x47, 0x72, 0x72, 0x1c, 0x33, 0xa2, 0x55, 0x28, 0x0b, 0x2f, 0xd6, 0xd9, 0x86, 0xe3, 0x66, + 0x9d, 0xc7, 0x20, 0x40, 0x8c, 0x13, 0xdd, 0x86, 0x05, 0xde, 0x70, 0x0a, 0xf6, 0x89, 0x25, 0x68, + 0x72, 0x9c, 0x66, 0x3e, 0x86, 0x72, 0xb2, 0x6d, 0xa8, 0x48, 0x80, 0xce, 0xab, 0x81, 0x3c, 0x57, + 0xe8, 0xad, 0xab, 0x14, 0x12, 0x2c, 0xbc, 0x48, 0x28, 0x7b, 0x93, 0x81, 0xfa, 0xcb, 0x50, 0x8c, + 0x94, 0x45, 0xcb, 0x30, 0xdb, 0x6f, 0x74, 0x95, 0x99, 0xea, 0xe2, 0xf1, 0xc9, 0x5a, 0x39, 0x02, + 0xf7, 0x1b, 0x5d, 0x86, 0xd9, 0x69, 0x76, 0x95, 0xcc, 0x79, 0xcc, 0x4e, 0xb3, 0x8b, 0xaa, 0x90, + 0xeb, 0x35, 0xfa, 0xdd, 0x28, 0x3f, 0x8b, 0x50, 0x0c, 0x56, 0xcd, 0xb1, 0xfc, 0x4c, 0xdd, 0x83, + 0x72, 0xe2, 0xeb, 0xe8, 0x35, 0x98, 0x6b, 0xb5, 0x1f, 0x61, 0xad, 0xd7, 0x53, 0x66, 0x44, 0x79, + 0x90, 0xc0, 0xb6, 0xdc, 0x01, 0x5b, 0x3b, 0xf4, 0x0a, 0xe4, 0x36, 0x3b, 0xec, 0xdc, 0x17, 0xf5, + 0x47, 0x82, 0x62, 0x93, 0x06, 0x61, 0xf5, 0xba, 0x4c, 0xfc, 0x92, 0x82, 0xd5, 0xdf, 0xcf, 0x40, + 0x41, 0x6c, 0xb4, 0xd4, 0x45, 0xac, 0x4d, 0x8a, 0x22, 0x51, 0x36, 0xbe, 0x71, 0x71, 0x89, 0xb7, + 0x2e, 0x2b, 0x32, 0xe1, 0x9a, 0x11, 0x5f, 0xf5, 0x7d, 0xa8, 0x24, 0x11, 0x5f, 0xc8, 0x31, 0xbf, + 0x0d, 0x65, 0xe6, 0xfb, 0x51, 0xa9, 0x77, 0x1f, 0x0a, 0x22, 0x58, 0xc4, 0xe7, 0xd0, 0xc5, 0xf5, + 0xa6, 0xa4, 0x44, 0x0f, 0x61, 0x4e, 0xd4, 0xa8, 0x51, 0x2f, 0x7b, 0xe5, 0xf2, 0x1d, 0x86, 0x23, + 0x72, 0xf5, 0x23, 0xc8, 0x75, 0x09, 0xf1, 0x99, 0xed, 0x5d, 0x6a, 0x91, 0xc9, 0xd1, 0x2d, 0xcb, + 0x6b, 0x8b, 0xb4, 0x9a, 0xac, 0xbc, 0xb6, 0x48, 0xcb, 0x8a, 0xfb, 0x71, 0xd9, 0x44, 0x3f, 0xae, + 0x0f, 0x95, 0xa7, 0xc4, 0x1e, 0xec, 0x87, 0xc4, 0xe2, 0x82, 0xde, 0x86, 0x9c, 0x47, 0x62, 0xe5, + 0x97, 0x53, 0x9d, 0x8f, 0x10, 0x1f, 0x73, 0x2a, 0x16, 0x63, 0x8e, 0x38, 0xb7, 0xbc, 0x06, 0x92, + 0x23, 0xf5, 0xef, 0xb2, 0xb0, 0xd0, 0x0a, 0x82, 0x91, 0xe1, 0x9a, 0x51, 0x56, 0xf7, 0xf5, 0xf3, + 0x59, 0x5d, 0xea, 0x7d, 0xd9, 0x79, 0x96, 0xf3, 0x6d, 0x46, 0x79, 0xb2, 0x66, 0xe3, 0x93, 0x55, + 0xfd, 0x8f, 0x4c, 0xd4, 0x4b, 0xbc, 0x9d, 0x08, 0x05, 0xa2, 0x46, 0x4c, 0x4a, 0x22, 0x3b, 0xee, + 0x81, 0x4b, 0x8f, 0x5c, 0x56, 0xbd, 0x62, 0xad, 0xad, 0x3d, 0x55, 0x32, 0xc2, 0x3d, 0xcf, 0x11, + 0x61, 0xe2, 0x92, 0x23, 0x26, 0xa9, 0xab, 0xb5, 0x9b, 0x2c, 0x0b, 0xcb, 0xa6, 0x48, 0xea, 0x12, + 0xd7, 0xb2, 0xdd, 0x01, 0x7a, 0x0d, 0x0a, 0xad, 0x5e, 0x6f, 0x87, 0x97, 0x90, 0x2f, 0x1d, 0x9f, + 0xac, 0x5d, 0x3f, 0x47, 0xc5, 0xfb, 0xc8, 0x16, 0x23, 0x62, 0x25, 0x10, 0xcb, 0xcf, 0x52, 0x88, + 0x58, 0x6e, 0x2d, 0x88, 0x70, 0xa7, 0x5f, 0xeb, 0x6b, 0x4a, 0x3e, 0x85, 0x08, 0x53, 0xf6, 0x57, + 0x6e, 0xb7, 0x7f, 0xce, 0x82, 0x52, 0x33, 0x4d, 0xe2, 0x85, 0x0c, 0x2f, 0xab, 0xce, 0x3e, 0x14, + 0x3d, 0xf6, 0xcb, 0x26, 0x51, 0x06, 0xf5, 0x30, 0xf5, 0xc6, 0x77, 0x8a, 0x6f, 0x1d, 0x53, 0x87, + 0xd4, 0xac, 0xa1, 0x1d, 0x04, 0x36, 0x75, 0x05, 0x0c, 0xc7, 0x92, 0xaa, 0xff, 0x95, 0x81, 0xeb, + 0x29, 0x14, 0xe8, 0x2e, 0xe4, 0x7c, 0xea, 0x44, 0x6b, 0x78, 0xeb, 0xa2, 0x36, 0x31, 0x63, 0xc5, + 0x9c, 0x12, 0xad, 0x00, 0x18, 0xa3, 0x90, 0x1a, 0xfc, 0xfb, 0xa2, 0xb9, 0x86, 0x13, 0x10, 0xf4, + 0x14, 0x0a, 0x01, 0x31, 0x7d, 0x12, 0xe5, 0xd9, 0x1f, 0xfd, 0xb4, 0xda, 0xaf, 0xf7, 0xb8, 0x18, + 0x2c, 0xc5, 0x55, 0xd7, 0xa1, 0x20, 0x20, 0xcc, 0xed, 0x2d, 0x23, 0x34, 0xe4, 0x25, 0x02, 0xff, + 0xcd, 0xbc, 0xc9, 0x70, 0x06, 0x91, 0x37, 0x19, 0xce, 0x40, 0xfd, 0xab, 0x2c, 0x80, 0xf6, 0x3c, + 0x24, 0xbe, 0x6b, 0x38, 0x8d, 0x1a, 0xd2, 0x12, 0x27, 0x83, 0x98, 0xed, 0x57, 0x52, 0xef, 0x4d, + 0x62, 0x8e, 0xf5, 0x46, 0x2d, 0xe5, 0x6c, 0xb8, 0x09, 0xb3, 0x23, 0x5f, 0x5e, 0xe2, 0x8b, 0x1c, + 0x79, 0x07, 0x6f, 0x61, 0x06, 0x43, 0x5a, 0xb2, 0x97, 0x73, 0xe1, 0x55, 0x7d, 0xe2, 0x03, 0xa9, + 0xa1, 0x8b, 0xed, 0x7c, 0xd3, 0xd0, 0x4d, 0x22, 0x4f, 0x95, 0x8a, 0xd8, 0xf9, 0x8d, 0x5a, 0x83, + 0xf8, 0x21, 0x2e, 0x98, 0x06, 0xfb, 0xff, 0x33, 0xc5, 0xb7, 0xb7, 0x01, 0x26, 0x53, 0x43, 0x2b, + 0x90, 0x6f, 0x6c, 0xf4, 0x7a, 0x5b, 0xca, 0x8c, 0x08, 0xe0, 0x13, 0x14, 0x07, 0xab, 0x7f, 0x9e, + 0x85, 0x62, 0xa3, 0x26, 0x8f, 0xdc, 0x06, 0x28, 0x3c, 0x2a, 0xf1, 0xab, 0x17, 0xf2, 0xdc, 0xb3, + 0xfd, 0xb1, 0x0c, 0x2c, 0x97, 0x14, 0xbc, 0x0b, 0x8c, 0x85, 0x69, 0xad, 0x71, 0x06, 0x84, 0xa1, + 0x42, 0xa4, 0x11, 0x74, 0xd3, 0x88, 0x62, 0xfc, 0xca, 0xe5, 0xc6, 0x12, 0xa5, 0xcb, 0x64, 0x1c, + 0xe0, 0x72, 0x24, 0xa4, 0x61, 0x04, 0xe8, 0x3d, 0x58, 0x0c, 0xec, 0x81, 0x6b, 0xbb, 0x03, 0x3d, + 0x32, 0x1e, 0xbf, 0x07, 0xaa, 0x5f, 0x3b, 0x3b, 0x5d, 0x9d, 0xef, 0x09, 0x94, 0xb4, 0xe1, 0xbc, + 0xa4, 0x6c, 0x70, 0x53, 0xa2, 0x77, 0x61, 0x21, 0xc1, 0xca, 0xac, 0x28, 0xcc, 0xce, 0x3b, 0xc6, + 0x31, 0xe7, 0x63, 0x32, 0xc6, 0x95, 0x98, 0xf1, 0x31, 0xe1, 0xbd, 0x99, 0x3d, 0xea, 0x9b, 0x44, + 0xf7, 0xf9, 0x9e, 0xe6, 0xa7, 0x7b, 0x0e, 0x97, 0x39, 0x4c, 0x6c, 0x73, 0xf5, 0x09, 0x5c, 0xef, + 0xf8, 0xe6, 0x3e, 0x09, 0x42, 0x61, 0x0a, 0x69, 0xc5, 0x8f, 0xe0, 0x56, 0x68, 0x04, 0x07, 0xfa, + 0xbe, 0x1d, 0x84, 0xd4, 0x1f, 0xeb, 0x3e, 0x09, 0x89, 0xcb, 0xf0, 0x3a, 0xbf, 0xe0, 0x96, 0xed, + 0xc4, 0x9b, 0x8c, 0x66, 0x53, 0x90, 0xe0, 0x88, 0x62, 0x8b, 0x11, 0xa8, 0x2d, 0xa8, 0xb0, 0x12, + 0x46, 0x36, 0xd5, 0xd8, 0xec, 0xc1, 0xa1, 0x03, 0xfd, 0x73, 0x1f, 0x53, 0x25, 0x87, 0x0e, 0xc4, + 0x4f, 0xf5, 0x9b, 0xa0, 0x34, 0xed, 0xc0, 0x33, 0x42, 0x73, 0x3f, 0xea, 0x93, 0xa2, 0x26, 0x28, + 0xfb, 0xc4, 0xf0, 0xc3, 0x5d, 0x62, 0x84, 0xba, 0x47, 0x7c, 0x9b, 0x5a, 0x57, 0xaf, 0xf2, 0x62, + 0xcc, 0xd2, 0xe5, 0x1c, 0xea, 0xff, 0x64, 0x00, 0xb0, 0xb1, 0x17, 0x65, 0x6b, 0x5f, 0x85, 0x6b, + 0x81, 0x6b, 0x78, 0xc1, 0x3e, 0x0d, 0x75, 0xdb, 0x0d, 0x89, 0x7f, 0x68, 0x38, 0xb2, 0xb9, 0xa3, + 0x44, 0x88, 0x96, 0x84, 0xa3, 0xb7, 0x01, 0x1d, 0x10, 0xe2, 0xe9, 0xd4, 0xb1, 0xf4, 0x08, 0x29, + 0x2e, 0xbe, 0x73, 0x58, 0x61, 0x98, 0x8e, 0x63, 0xf5, 0x22, 0x38, 0xaa, 0xc3, 0x0a, 0x9b, 0x3e, + 0x71, 0x43, 0xdf, 0x26, 0x81, 0xbe, 0x47, 0x7d, 0x3d, 0x70, 0xe8, 0x91, 0xbe, 0x47, 0x1d, 0x87, + 0x1e, 0x11, 0x3f, 0xea, 0x9b, 0x55, 0x1d, 0x3a, 0xd0, 0x04, 0xd1, 0x06, 0xf5, 0x7b, 0x0e, 0x3d, + 0xda, 0x88, 0x28, 0x58, 0x4a, 0x37, 0x99, 0x73, 0x68, 0x9b, 0x07, 0x51, 0x4a, 0x17, 0x43, 0xfb, + 0xb6, 0x79, 0x80, 0x5e, 0x83, 0x79, 0xe2, 0x10, 0xde, 0x3e, 0x11, 0x54, 0x79, 0x4e, 0x55, 0x89, + 0x80, 0x8c, 0x48, 0xfd, 0x18, 0x14, 0xcd, 0x35, 0xfd, 0xb1, 0x97, 0x58, 0xf3, 0xb7, 0x01, 0xb1, + 0x20, 0xa9, 0x3b, 0xd4, 0x3c, 0xd0, 0x87, 0x86, 0x6b, 0x0c, 0x98, 0x5e, 0xe2, 0xc6, 0x51, 0x61, + 0x98, 0x2d, 0x6a, 0x1e, 0x6c, 0x4b, 0xb8, 0xfa, 0x1e, 0x40, 0xcf, 0xf3, 0x89, 0x61, 0x75, 0x58, + 0x36, 0xc1, 0x4c, 0xc7, 0x47, 0xba, 0x25, 0xef, 0x73, 0xa9, 0x2f, 0xb7, 0xba, 0x22, 0x10, 0xcd, + 0x18, 0xae, 0xfe, 0x22, 0x5c, 0xef, 0x3a, 0x86, 0xc9, 0x5f, 0x58, 0x74, 0xe3, 0x2b, 0x34, 0xf4, + 0x10, 0x0a, 0x82, 0x54, 0xae, 0x64, 0xea, 0x76, 0x9b, 0x7c, 0x73, 0x73, 0x06, 0x4b, 0xfa, 0x7a, + 0x05, 0x60, 0x22, 0x47, 0xfd, 0xc7, 0x0c, 0x94, 0x62, 0xf9, 0x68, 0x4d, 0x5c, 0x80, 0x85, 0xbe, + 0x61, 0xbb, 0xb2, 0xe2, 0x2f, 0xe1, 0x24, 0x08, 0xb5, 0xa0, 0xec, 0xc5, 0xdc, 0x97, 0xe6, 0x73, + 0x29, 0x5a, 0xe3, 0x24, 0x2f, 0x7a, 0x1f, 0x4a, 0xd1, 0x05, 0x7a, 0x14, 0x61, 0x2f, 0xbf, 0x6f, + 0x9f, 0x90, 0x47, 0x8d, 0x54, 0x9f, 0x78, 0x8e, 0xcd, 0x62, 0x4e, 0x2e, 0x6e, 0xa4, 0x62, 0x09, + 0x52, 0xbf, 0x0e, 0xf0, 0x0d, 0x6a, 0xbb, 0x7d, 0x7a, 0x40, 0x5c, 0x7e, 0x2b, 0xcc, 0x4a, 0x4a, + 0x12, 0x19, 0x5a, 0x8e, 0x78, 0xa7, 0x40, 0xac, 0x52, 0x7c, 0x39, 0x2a, 0x86, 0xea, 0x5f, 0x66, + 0xa1, 0x80, 0x29, 0x0d, 0x1b, 0x35, 0xb4, 0x06, 0x05, 0x19, 0x4a, 0xf8, 0x11, 0x55, 0x2f, 0x9d, + 0x9d, 0xae, 0xe6, 0x45, 0x0c, 0xc9, 0x9b, 0x3c, 0x78, 0x24, 0x82, 0x7c, 0xf6, 0xa2, 0x20, 0x8f, + 0xee, 0x42, 0x45, 0x12, 0xe9, 0xfb, 0x46, 0xb0, 0x2f, 0xea, 0xbb, 0xfa, 0xc2, 0xd9, 0xe9, 0x2a, + 0x08, 0xca, 0x4d, 0x23, 0xd8, 0xc7, 0x20, 0xa8, 0xd9, 0x6f, 0xa4, 0x41, 0xf9, 0x19, 0xb5, 0x5d, + 0x3d, 0xe4, 0x93, 0x90, 0xbd, 0xc8, 0xd4, 0xa5, 0x9e, 0x4c, 0x55, 0x3e, 0xa0, 0x80, 0x67, 0x93, + 0xc9, 0x6b, 0x30, 0xef, 0x53, 0x1a, 0x8a, 0xc8, 0x66, 0x53, 0x57, 0xb6, 0x39, 0xd6, 0x52, 0xbb, + 0xdf, 0x94, 0x86, 0x58, 0xd2, 0xe1, 0x8a, 0x9f, 0x18, 0xa1, 0xbb, 0xb0, 0xe4, 0x18, 0x41, 0xa8, + 0xf3, 0x90, 0x68, 0x4d, 0xa4, 0x15, 0xb8, 0xf1, 0x11, 0xc3, 0x6d, 0x70, 0x54, 0xc4, 0xa1, 0xfe, + 0x43, 0x06, 0xca, 0x6c, 0x32, 0xf6, 0x9e, 0x6d, 0xb2, 0x3c, 0xf0, 0x8b, 0xa7, 0x27, 0x37, 0x61, + 0xd6, 0x0c, 0x7c, 0x69, 0x54, 0x7e, 0x3e, 0x37, 0x7a, 0x18, 0x33, 0x18, 0xfa, 0x18, 0x0a, 0xb2, + 0xdd, 0x22, 0x32, 0x13, 0xf5, 0xea, 0x8c, 0x55, 0xda, 0x46, 0xf2, 0x71, 0x77, 0x9f, 0x68, 0x27, + 0xce, 0x09, 0x9c, 0x04, 0xa1, 0x1b, 0x90, 0x35, 0x85, 0xb9, 0xe4, 0x0b, 0x9d, 0x46, 0x1b, 0x67, + 0x4d, 0x57, 0xfd, 0x51, 0x06, 0xe6, 0x27, 0x31, 0x81, 0x79, 0xc0, 0x2d, 0x28, 0x05, 0xa3, 0xdd, + 0x60, 0x1c, 0x84, 0x64, 0x18, 0xdd, 0x78, 0xc7, 0x00, 0xd4, 0x82, 0x92, 0xe1, 0x0c, 0xa8, 0x6f, + 0x87, 0xfb, 0x43, 0x59, 0xc8, 0xa6, 0x67, 0x13, 0x49, 0x99, 0xeb, 0xb5, 0x88, 0x05, 0x4f, 0xb8, + 0xa3, 0xd4, 0x40, 0x3c, 0x8b, 0xe0, 0xa9, 0xc1, 0xab, 0x50, 0x71, 0x8c, 0x21, 0xef, 0x3f, 0x85, + 0xf6, 0x90, 0x44, 0x9b, 0x41, 0xc2, 0xfa, 0xf6, 0x90, 0xa8, 0x2a, 0x94, 0x62, 0x61, 0x68, 0x11, + 0xca, 0x35, 0xad, 0xa7, 0xdf, 0xbb, 0xff, 0x50, 0x7f, 0xd4, 0xd8, 0x56, 0x66, 0x64, 0xfa, 0xfa, + 0x67, 0x19, 0x98, 0x97, 0x11, 0x4b, 0x96, 0x04, 0xaf, 0xc1, 0x9c, 0x6f, 0xec, 0x85, 0x51, 0xd1, + 0x92, 0x13, 0x5e, 0xcd, 0x0e, 0x01, 0x56, 0xb4, 0x30, 0x54, 0x7a, 0xd1, 0x92, 0x78, 0x83, 0x31, + 0x7b, 0xe9, 0x1b, 0x8c, 0xdc, 0xff, 0xcb, 0x1b, 0x0c, 0xf5, 0x37, 0x00, 0x36, 0x6c, 0x87, 0xf4, + 0x45, 0xab, 0x2a, 0xad, 0x04, 0x65, 0x69, 0x9e, 0x6c, 0x85, 0x46, 0x69, 0x5e, 0xab, 0x89, 0x19, + 0x8c, 0xa1, 0x06, 0xb6, 0x25, 0x37, 0x23, 0x47, 0x3d, 0x62, 0xa8, 0x81, 0x6d, 0xc5, 0xd7, 0x7e, + 0xb9, 0x2b, 0xae, 0xfd, 0xd4, 0x45, 0x98, 0xc7, 0xa2, 0xc7, 0x26, 0x74, 0x50, 0x4f, 0x32, 0xb0, + 0x28, 0xf3, 0xdd, 0x38, 0x64, 0x7f, 0x05, 0x4a, 0x22, 0xf5, 0x9d, 0x14, 0x81, 0xfc, 0x21, 0x82, + 0xa0, 0x6b, 0x35, 0x71, 0x51, 0xa0, 0x5b, 0x16, 0x5a, 0x85, 0xb2, 0x24, 0x4d, 0x3c, 0xef, 0x02, + 0x01, 0x6a, 0xb3, 0xf9, 0xbc, 0x03, 0xb9, 0x3d, 0xdb, 0x21, 0xd2, 0xf3, 0x53, 0x23, 0xc2, 0xc4, + 0x22, 0x9b, 0x33, 0x98, 0x53, 0xd7, 0x8b, 0x51, 0x73, 0x4f, 0xfd, 0x97, 0x0c, 0x6f, 0x31, 0xb3, + 0x52, 0x35, 0xa9, 0x9f, 0xa8, 0x5a, 0xa7, 0xf4, 0x13, 0x74, 0x4c, 0x3f, 0x81, 0x16, 0xfa, 0x49, + 0xd2, 0xa4, 0x7e, 0x02, 0xf4, 0xd3, 0xeb, 0x87, 0x3e, 0x84, 0x39, 0xd9, 0xaa, 0x94, 0xa1, 0xee, + 0xd5, 0x54, 0xcf, 0x48, 0x5a, 0x7a, 0x73, 0x06, 0x47, 0x3c, 0x89, 0xe9, 0x6d, 0xc1, 0x8d, 0xba, + 0x63, 0x98, 0x07, 0x8e, 0x1d, 0x84, 0xc4, 0x4a, 0x46, 0xa0, 0xfb, 0x50, 0x38, 0x97, 0xe7, 0x5e, + 0xd6, 0x44, 0x95, 0x94, 0xea, 0xbf, 0x67, 0xa0, 0xb2, 0x49, 0x0c, 0x27, 0xdc, 0x9f, 0x74, 0xaa, + 0x42, 0x12, 0x84, 0xf2, 0x7c, 0xe4, 0xbf, 0xd1, 0xd7, 0xa0, 0x18, 0xa7, 0x41, 0x57, 0x5e, 0x07, + 0xc6, 0xa4, 0xe8, 0x01, 0xcc, 0x31, 0xdd, 0xe9, 0x28, 0xaa, 0xaf, 0x2e, 0xbb, 0x69, 0x92, 0x94, + 0xec, 0xd0, 0xf2, 0x09, 0xcf, 0x7b, 0xb8, 0x9d, 0xf2, 0x38, 0x1a, 0xa2, 0x9f, 0x87, 0x0a, 0xbf, + 0x28, 0x89, 0xd2, 0xbc, 0xfc, 0x55, 0x32, 0xcb, 0xe2, 0xae, 0x53, 0xa4, 0x78, 0x7f, 0x9c, 0x85, + 0xa5, 0x6d, 0x63, 0xbc, 0x4b, 0x64, 0x18, 0x22, 0x16, 0x26, 0x26, 0xf5, 0x2d, 0xd4, 0x4d, 0x86, + 0xaf, 0x4b, 0xae, 0x4e, 0xd3, 0x98, 0xd3, 0xa3, 0x58, 0x54, 0xf3, 0x65, 0x13, 0x35, 0xdf, 0x12, + 0xe4, 0x5d, 0xea, 0x9a, 0x44, 0xc6, 0x36, 0x31, 0x50, 0xbf, 0x93, 0x49, 0xc6, 0xae, 0x6a, 0x7c, + 0xad, 0xc9, 0x9b, 0x5e, 0x6d, 0x1a, 0xc6, 0x9f, 0x43, 0x1f, 0x43, 0xb5, 0xa7, 0x35, 0xb0, 0xd6, + 0xaf, 0x77, 0xbe, 0xa9, 0xf7, 0x6a, 0x5b, 0xbd, 0xda, 0xfd, 0xbb, 0x7a, 0xb7, 0xb3, 0xf5, 0xad, + 0x7b, 0x0f, 0xee, 0x7e, 0x4d, 0xc9, 0x54, 0xd7, 0x8e, 0x4f, 0xd6, 0x6e, 0xb5, 0x6b, 0x8d, 0x2d, + 0xb1, 0xe3, 0x76, 0xe9, 0xf3, 0x9e, 0xe1, 0x04, 0xc6, 0xfd, 0xbb, 0x5d, 0xea, 0x8c, 0x19, 0x0d, + 0xfa, 0x2a, 0xa0, 0x0d, 0x0d, 0xb7, 0xb5, 0xbe, 0x1e, 0x05, 0xc8, 0x46, 0xbd, 0xa1, 0x64, 0x45, + 0x25, 0xb5, 0x41, 0x7c, 0x97, 0x84, 0x35, 0xad, 0x77, 0xef, 0xfe, 0xc3, 0x46, 0xbd, 0xc1, 0xf6, + 0x78, 0x25, 0x79, 0x5a, 0x26, 0x93, 0x80, 0xcc, 0x85, 0x49, 0xc0, 0x24, 0x97, 0xc8, 0x5e, 0x90, + 0x4b, 0x6c, 0xc0, 0x92, 0xe9, 0xd3, 0x20, 0xd0, 0x59, 0x79, 0x42, 0xac, 0xa9, 0x02, 0xe8, 0x4b, + 0x67, 0xa7, 0xab, 0xd7, 0x1a, 0x0c, 0xdf, 0xe3, 0x68, 0x29, 0xfe, 0x9a, 0x99, 0x00, 0xf1, 0x2f, + 0xa9, 0xdf, 0x9f, 0x65, 0x99, 0x9e, 0x7d, 0x68, 0x3b, 0x64, 0x40, 0x02, 0xf4, 0x04, 0x16, 0x4d, + 0x9f, 0x58, 0xac, 0xee, 0x30, 0x9c, 0xe4, 0xcb, 0xe8, 0x9f, 0x4b, 0x4d, 0xba, 0x62, 0xc6, 0xf5, + 0x46, 0xcc, 0xd5, 0xf3, 0x88, 0x89, 0x17, 0xcc, 0x73, 0x63, 0xf4, 0x0c, 0x16, 0x03, 0xe2, 0xd8, + 0xee, 0xe8, 0xb9, 0x6e, 0x52, 0x37, 0x24, 0xcf, 0xa3, 0xeb, 0xbc, 0xab, 0xe4, 0xf6, 0xb4, 0x2d, + 0xc6, 0xd5, 0x10, 0x4c, 0x75, 0x74, 0x76, 0xba, 0xba, 0x70, 0x1e, 0x86, 0x17, 0xa4, 0x64, 0x39, + 0xae, 0xee, 0xc3, 0xc2, 0x79, 0x6d, 0xd0, 0x92, 0x0c, 0x34, 0x3c, 0x5e, 0xc5, 0x81, 0xe4, 0x16, + 0x14, 0x7d, 0x32, 0xb0, 0x83, 0xd0, 0x17, 0x66, 0x66, 0x98, 0x18, 0x82, 0x96, 0xa1, 0x90, 0x78, + 0x71, 0xc2, 0x70, 0x72, 0xcc, 0x22, 0x88, 0x78, 0x4c, 0x56, 0xfd, 0x35, 0x98, 0xd2, 0x85, 0x6d, + 0x3a, 0xcb, 0x0e, 0x8c, 0x5d, 0xf9, 0xb1, 0x22, 0x8e, 0x86, 0xcc, 0x97, 0x47, 0x41, 0x9c, 0x40, + 0xf2, 0xdf, 0x0c, 0xc6, 0x33, 0x1d, 0xf9, 0xb4, 0x8e, 0xe7, 0x32, 0xd1, 0x0b, 0xde, 0x5c, 0xe2, + 0x05, 0xef, 0x12, 0xe4, 0x1d, 0x72, 0x48, 0x1c, 0x91, 0x63, 0x60, 0x31, 0xe0, 0x3e, 0xff, 0x0d, + 0xba, 0x2b, 0x8f, 0xe1, 0x0d, 0x98, 0x7f, 0x46, 0x77, 0x75, 0x3b, 0x24, 0xfe, 0xe4, 0x61, 0x55, + 0xf9, 0xfe, 0xcb, 0x69, 0xf6, 0x95, 0x0f, 0x79, 0x65, 0xa2, 0x53, 0x79, 0x46, 0x77, 0x5b, 0x11, + 0x1b, 0xaa, 0xc1, 0x02, 0xcf, 0xdf, 0xc8, 0x73, 0x62, 0x8e, 0xb8, 0xa0, 0xab, 0xef, 0x5d, 0xe7, + 0x19, 0x87, 0x16, 0x31, 0xbc, 0x75, 0x17, 0x2a, 0xd1, 0x1b, 0x56, 0xfe, 0x98, 0xa5, 0x08, 0xb9, + 0x7e, 0xad, 0xf7, 0x58, 0x99, 0x41, 0x00, 0x05, 0xb1, 0xf9, 0xc4, 0xed, 0x68, 0xa3, 0xd3, 0xde, + 0x68, 0x3d, 0x52, 0xb2, 0x6f, 0xfd, 0x5e, 0x0e, 0x4a, 0xf1, 0xfd, 0x1c, 0x3b, 0x6c, 0xdb, 0xda, + 0xd3, 0x68, 0xf7, 0xc6, 0xf0, 0x36, 0x39, 0x42, 0xaf, 0x4e, 0x3a, 0x7b, 0x1f, 0x8b, 0x07, 0x09, + 0x31, 0x3a, 0xea, 0xea, 0xbd, 0x0e, 0xc5, 0x5a, 0xaf, 0xd7, 0x7a, 0xd4, 0xd6, 0x9a, 0xca, 0xa7, + 0x99, 0xea, 0x97, 0x8e, 0x4f, 0xd6, 0xae, 0xc5, 0x44, 0xb5, 0x40, 0xec, 0x17, 0x4e, 0xd5, 0x68, + 0x68, 0xdd, 0xbe, 0xd6, 0x54, 0x3e, 0xc9, 0x4e, 0x53, 0xf1, 0x4e, 0x15, 0x7f, 0x68, 0x55, 0xea, + 0x62, 0xad, 0x5b, 0xc3, 0xec, 0x83, 0x9f, 0x66, 0x45, 0xc3, 0x71, 0xf2, 0x45, 0x9f, 0x78, 0x86, + 0xcf, 0xbe, 0xb9, 0x12, 0xbd, 0x77, 0xfc, 0x64, 0x56, 0xbc, 0xb8, 0x99, 0x5c, 0x36, 0x12, 0xc3, + 0x1a, 0xb3, 0xaf, 0xf1, 0x5b, 0x5e, 0x2e, 0x66, 0x76, 0xea, 0x6b, 0x3d, 0x16, 0x5c, 0x99, 0x14, + 0x15, 0xe6, 0xf0, 0x4e, 0xbb, 0xcd, 0x88, 0x3e, 0xc9, 0x4d, 0xcd, 0x0e, 0x8f, 0x5c, 0x97, 0xd1, + 0xdc, 0x86, 0x62, 0x74, 0x09, 0xac, 0x7c, 0x9a, 0x9b, 0x52, 0xa8, 0x11, 0xdd, 0x60, 0xf3, 0x0f, + 0x6e, 0xee, 0xf4, 0xf9, 0x73, 0xcc, 0x4f, 0xf2, 0xd3, 0x1f, 0xdc, 0x1f, 0x85, 0x16, 0x3d, 0x72, + 0x59, 0x98, 0x91, 0xbd, 0xcd, 0x4f, 0xf3, 0x22, 0x7c, 0xc5, 0x34, 0xb2, 0xb1, 0xf9, 0x3a, 0x14, + 0xb1, 0xf6, 0x0d, 0xf1, 0x72, 0xf3, 0x93, 0xc2, 0x94, 0x1c, 0x4c, 0x9e, 0x11, 0x93, 0x7d, 0x6d, + 0x0d, 0x0a, 0x58, 0xdb, 0xee, 0x3c, 0xd1, 0x94, 0x3f, 0x28, 0x4c, 0xc9, 0xc1, 0x64, 0x48, 0xf9, + 0x4b, 0xb4, 0x62, 0x07, 0x77, 0x37, 0x6b, 0x7c, 0x51, 0xa6, 0xe5, 0x74, 0x7c, 0x6f, 0xdf, 0x70, + 0x89, 0x35, 0x79, 0x75, 0x14, 0xa3, 0xde, 0xfa, 0x25, 0x28, 0x46, 0xc9, 0x3e, 0x5a, 0x81, 0xc2, + 0xd3, 0x0e, 0x7e, 0xac, 0x61, 0x65, 0x46, 0x58, 0x39, 0xc2, 0x3c, 0x15, 0x65, 0xda, 0x1a, 0xcc, + 0x6d, 0xd7, 0xda, 0xb5, 0x47, 0x1a, 0x8e, 0x2e, 0x26, 0x22, 0x02, 0x99, 0xb1, 0x56, 0x15, 0xf9, + 0x81, 0x58, 0x66, 0xfd, 0xf5, 0x1f, 0x7c, 0xb6, 0x32, 0xf3, 0xe3, 0xcf, 0x56, 0x66, 0x3e, 0x39, + 0x5b, 0xc9, 0xfc, 0xe0, 0x6c, 0x25, 0xf3, 0xc3, 0xb3, 0x95, 0xcc, 0xbf, 0x9d, 0xad, 0x64, 0x7e, + 0xe7, 0x27, 0x2b, 0x33, 0x3f, 0xfc, 0xc9, 0xca, 0xcc, 0x8f, 0x7f, 0xb2, 0x32, 0xb3, 0x5b, 0xe0, + 0x4e, 0xff, 0xe0, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xde, 0x15, 0x00, 0xb1, 0xc6, 0x34, 0x00, + 0x00, } func (m *Version) Copy() *Version { @@ -5814,6 +5866,26 @@ func (m *Privileges_SELinuxContext) CopyFrom(src interface{}) { *m = *o } +func (m *JobStatus) Copy() *JobStatus { + if m == nil { + return nil + } + o := &JobStatus{} + o.CopyFrom(m) + return o +} + +func (m *JobStatus) CopyFrom(src interface{}) { + + o := src.(*JobStatus) + *m = *o + github_com_docker_swarmkit_api_deepcopy.Copy(&m.JobIteration, &o.JobIteration) + if o.LastExecution != nil { + m.LastExecution = &types.Timestamp{} + github_com_docker_swarmkit_api_deepcopy.Copy(m.LastExecution, o.LastExecution) + } +} + func (m *Version) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -8499,6 +8571,42 @@ func (m *Privileges_SELinuxContext) MarshalTo(dAtA []byte) (int, error) { return i, nil } +func (m *JobStatus) 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 *JobStatus) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + dAtA[i] = 0xa + i++ + i = encodeVarintTypes(dAtA, i, uint64(m.JobIteration.Size())) + n50, err := m.JobIteration.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n50 + if m.LastExecution != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintTypes(dAtA, i, uint64(m.LastExecution.Size())) + n51, err := m.LastExecution.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n51 + } + return i, nil +} + func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) @@ -9927,6 +10035,21 @@ func (m *Privileges_SELinuxContext) Size() (n int) { return n } +func (m *JobStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.JobIteration.Size() + n += 1 + l + sovTypes(uint64(l)) + if m.LastExecution != nil { + l = m.LastExecution.Size() + n += 1 + l + sovTypes(uint64(l)) + } + return n +} + func sovTypes(x uint64) (n int) { for { n++ @@ -10865,6 +10988,17 @@ func (this *Privileges_SELinuxContext) String() string { }, "") return s } +func (this *JobStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&JobStatus{`, + `JobIteration:` + strings.Replace(strings.Replace(this.JobIteration.String(), "Version", "Version", 1), `&`, ``, 1) + `,`, + `LastExecution:` + strings.Replace(fmt.Sprintf("%v", this.LastExecution), "Timestamp", "types.Timestamp", 1) + `,`, + `}`, + }, "") + return s +} func valueToStringTypes(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -20502,6 +20636,128 @@ func (m *Privileges_SELinuxContext) Unmarshal(dAtA []byte) error { } return nil } +func (m *JobStatus) 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: JobStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: JobStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field JobIteration", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.JobIteration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastExecution", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LastExecution == nil { + m.LastExecution = &types.Timestamp{} + } + if err := m.LastExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + 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 diff --git a/vendor/github.com/docker/swarmkit/api/types.proto b/vendor/github.com/docker/swarmkit/api/types.proto index 0eb97c4bbe..bdd1972ca9 100644 --- a/vendor/github.com/docker/swarmkit/api/types.proto +++ b/vendor/github.com/docker/swarmkit/api/types.proto @@ -1115,3 +1115,19 @@ message Privileges { } SELinuxContext selinux_context = 2 [(gogoproto.customname) = "SELinuxContext"]; } + +// JobStatus indicates the status of a Service that is in one of the Job modes. +message JobStatus { + // JobIteration is the count of how many times the Job has been excecuted, + // successfully or otherwise. "Executed" refers to the job as a whole being + // started, not to the individual Tasks being launched. This is used to + // disambiguate which Tasks belong to which iteration of a Job. + Version job_iteration = 1 [(gogoproto.nullable) = false]; + + // LastExecution is the time that the job was last executed. This is set by + // the orchestrator in the same transaction that JobIteration is incremented. + // While time is a fungible concept in distributed systems like Swarmkit, + // this value gives us a best-effort attempt to prevent weird behavior like + // newly added nodes executing long-forgotten jobs. + google.protobuf.Timestamp last_execution = 2; +} diff --git a/vendor/github.com/docker/swarmkit/manager/controlapi/service.go b/vendor/github.com/docker/swarmkit/manager/controlapi/service.go index a9e4b35922..e4db20b17f 100644 --- a/vendor/github.com/docker/swarmkit/manager/controlapi/service.go +++ b/vendor/github.com/docker/swarmkit/manager/controlapi/service.go @@ -474,12 +474,32 @@ func (s *Server) validateNetworks(networks []*api.NetworkAttachmentConfig) error func validateMode(s *api.ServiceSpec) error { m := s.GetMode() - switch m.(type) { + switch mode := m.(type) { case *api.ServiceSpec_Replicated: - if int64(m.(*api.ServiceSpec_Replicated).Replicated.Replicas) < 0 { + if int64(mode.Replicated.Replicas) < 0 { return status.Errorf(codes.InvalidArgument, "Number of replicas must be non-negative") } case *api.ServiceSpec_Global: + case *api.ServiceSpec_ReplicatedJob: + // this check shouldn't be required as the point of uint64 is to + // constrain the possible values to positive numbers, but it almost + // certainly is required because there are almost certainly blind casts + // from int64 to uint64, and uint64(-1) is almost certain to crash the + // cluster because of how large it is. + if int64(mode.ReplicatedJob.MaxConcurrent) < 0 { + return status.Errorf( + codes.InvalidArgument, + "Maximum concurrent jobs must not be negative", + ) + } + + if int64(mode.ReplicatedJob.TotalCompletions) < 0 { + return status.Errorf( + codes.InvalidArgument, + "Total completed jobs must not be negative", + ) + } + case *api.ServiceSpec_GlobalJob: default: return status.Errorf(codes.InvalidArgument, "Unrecognized service mode") } @@ -487,6 +507,13 @@ func validateMode(s *api.ServiceSpec) error { return nil } +func validateJob(spec *api.ServiceSpec) error { + if spec.Update != nil { + return status.Errorf(codes.InvalidArgument, "Jobs may not have an update config") + } + return nil +} + func validateServiceSpec(spec *api.ServiceSpec) error { if spec == nil { return status.Errorf(codes.InvalidArgument, errInvalidArgument.Error()) @@ -497,13 +524,32 @@ func validateServiceSpec(spec *api.ServiceSpec) error { if err := validateTaskSpec(spec.Task); err != nil { return err } - if err := validateUpdate(spec.Update); err != nil { + err := validateMode(spec) + if err != nil { return err } - if err := validateEndpointSpec(spec.Endpoint); err != nil { - return err + + // job-mode services are validated differently. most notably, they do not + // have UpdateConfigs, which is why this case statement skips update + // validation. + if isJobSpec(spec) { + if err := validateJob(spec); err != nil { + return err + } + } else { + if err := validateUpdate(spec.Update); err != nil { + return err + } } - return validateMode(spec) + + return validateEndpointSpec(spec.Endpoint) +} + +func isJobSpec(spec *api.ServiceSpec) bool { + mode := spec.GetMode() + _, isGlobalJob := mode.(*api.ServiceSpec_GlobalJob) + _, isReplicatedJob := mode.(*api.ServiceSpec_ReplicatedJob) + return isGlobalJob || isReplicatedJob } // checkPortConflicts does a best effort to find if the passed in spec has port @@ -689,6 +735,12 @@ func (s *Server) CreateService(ctx context.Context, request *api.CreateServiceRe SpecVersion: &api.Version{}, } + if isJobSpec(request.Spec) { + service.JobStatus = &api.JobStatus{ + LastExecution: gogotypes.TimestampNow(), + } + } + if allocator.IsIngressNetworkNeeded(service) { if _, err := allocator.GetIngressNetwork(s.store); err == allocator.ErrNoIngress { return nil, status.Errorf(codes.FailedPrecondition, "service needs ingress network, but no ingress network is present") @@ -819,6 +871,13 @@ func (s *Server) UpdateService(ctx context.Context, request *api.UpdateServiceRe service.Meta.Version = *request.ServiceVersion + // if the service has a JobStatus, that means it must be a Job, and we + // should increment the JobIteration + if service.JobStatus != nil { + service.JobStatus.JobIteration.Index = service.JobStatus.JobIteration.Index + 1 + service.JobStatus.LastExecution = gogotypes.TimestampNow() + } + if request.Rollback == api.UpdateServiceRequest_PREVIOUS { if service.PreviousSpec == nil { return status.Errorf(codes.FailedPrecondition, "service %s does not have a previous spec", request.ServiceID) @@ -999,6 +1058,10 @@ func (s *Server) ListServiceStatuses(ctx context.Context, req *api.ListServiceSt // use a boolean to see global vs replicated. this avoids us having to // iterate the task list twice. global := false + // jobIteration is the iteration that the Job is currently + // operating on, to distinguish Tasks in old executions from tasks + // in the current one. if nil, service is not a Job + var jobIteration *api.Version service := store.GetService(tx, id) // a service might be deleted, but it may still have tasks. in that // case, we will be using 0 as the desired task count. @@ -1009,23 +1072,52 @@ func (s *Server) ListServiceStatuses(ctx context.Context, req *api.ListServiceSt // numbercrunchin if replicated := service.Spec.GetReplicated(); replicated != nil { status.DesiredTasks = replicated.Replicas + } else if replicatedJob := service.Spec.GetReplicatedJob(); replicatedJob != nil { + status.DesiredTasks = replicatedJob.MaxConcurrent } else { + // global applies to both GlobalJob and regular Global global = true } + + if service.JobStatus != nil { + jobIteration = &service.JobStatus.JobIteration + } } // now, figure out how many tasks are running. Pretty easy, and // universal across both global and replicated services for _, task := range tasks { + // if the service is a Job, jobIteration will be non-nil. This + // means we should check if the task belongs to the current job + // iteration. If not, skip accounting the task. + if jobIteration != nil { + if task.JobIteration == nil || task.JobIteration.Index != jobIteration.Index { + continue + } + + // additionally, since we've verified that the service is a + // job and the task belongs to this iteration, we should + // increment CompletedTasks + if task.Status.State == api.TaskStateCompleted { + status.CompletedTasks++ + } + } if task.Status.State == api.TaskStateRunning { status.RunningTasks++ } - // if the service is global, a shortcut for figuring out the + + // if the service is global, a shortcut for figuring out the // number of tasks desired is to look at all tasks, and take a // count of the ones whose desired state is not Shutdown. if global && task.DesiredState == api.TaskStateRunning { status.DesiredTasks++ } + + // for jobs, this is any task with desired state Completed + // which is not actually in that state. + if global && task.Status.State != api.TaskStateCompleted && task.DesiredState == api.TaskStateCompleted { + status.DesiredTasks++ + } } } }) diff --git a/vendor/github.com/docker/swarmkit/manager/manager.go b/vendor/github.com/docker/swarmkit/manager/manager.go index cba72c232f..27820eca84 100644 --- a/vendor/github.com/docker/swarmkit/manager/manager.go +++ b/vendor/github.com/docker/swarmkit/manager/manager.go @@ -33,6 +33,7 @@ import ( "github.com/docker/swarmkit/manager/metrics" "github.com/docker/swarmkit/manager/orchestrator/constraintenforcer" "github.com/docker/swarmkit/manager/orchestrator/global" + "github.com/docker/swarmkit/manager/orchestrator/jobs" "github.com/docker/swarmkit/manager/orchestrator/replicated" "github.com/docker/swarmkit/manager/orchestrator/taskreaper" "github.com/docker/swarmkit/manager/resourceapi" @@ -146,6 +147,7 @@ type Manager struct { watchServer *watchapi.Server replicatedOrchestrator *replicated.Orchestrator globalOrchestrator *global.Orchestrator + jobsOrchestrator *jobs.Orchestrator taskReaper *taskreaper.TaskReaper constraintEnforcer *constraintenforcer.ConstraintEnforcer scheduler *scheduler.Scheduler @@ -681,6 +683,9 @@ func (m *Manager) Stop(ctx context.Context, clearData bool) { if m.globalOrchestrator != nil { m.globalOrchestrator.Stop() } + if m.jobsOrchestrator != nil { + m.jobsOrchestrator.Stop() + } if m.taskReaper != nil { m.taskReaper.Stop() } @@ -994,6 +999,7 @@ func (m *Manager) becomeLeader(ctx context.Context) { m.replicatedOrchestrator = replicated.NewReplicatedOrchestrator(s) m.constraintEnforcer = constraintenforcer.New(s) m.globalOrchestrator = global.NewGlobalOrchestrator(s) + m.jobsOrchestrator = jobs.NewOrchestrator(s) m.taskReaper = taskreaper.New(s) m.scheduler = scheduler.New(s) m.keyManager = keymanager.New(s, keymanager.DefaultConfig()) @@ -1090,6 +1096,11 @@ func (m *Manager) becomeLeader(ctx context.Context) { } }(m.replicatedOrchestrator) + go func(orchestrator *jobs.Orchestrator) { + // jobs orchestrator does not return errors. + orchestrator.Run(ctx) + }(m.jobsOrchestrator) + go func(globalOrchestrator *global.Orchestrator) { if err := globalOrchestrator.Run(ctx); err != nil { log.G(ctx).WithError(err).Error("global orchestrator exited with an error") diff --git a/vendor/github.com/docker/swarmkit/manager/orchestrator/constraintenforcer/constraint_enforcer.go b/vendor/github.com/docker/swarmkit/manager/orchestrator/constraintenforcer/constraint_enforcer.go index 1b0ceab69a..6b179de3f7 100644 --- a/vendor/github.com/docker/swarmkit/manager/orchestrator/constraintenforcer/constraint_enforcer.go +++ b/vendor/github.com/docker/swarmkit/manager/orchestrator/constraintenforcer/constraint_enforcer.go @@ -115,7 +115,7 @@ func (ce *ConstraintEnforcer) rejectNoncompliantTasks(node *api.Node) { // to remove the most resource-intensive tasks. loop: for _, t := range tasks { - if t.DesiredState < api.TaskStateAssigned || t.DesiredState > api.TaskStateRunning { + if t.DesiredState < api.TaskStateAssigned || t.DesiredState > api.TaskStateCompleted { continue } @@ -195,7 +195,7 @@ loop: for _, t := range removeTasks { err := batch.Update(func(tx store.Tx) error { t = store.GetTask(tx, t.ID) - if t == nil || t.DesiredState > api.TaskStateRunning { + if t == nil || t.DesiredState > api.TaskStateCompleted { return nil } diff --git a/vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/global/reconciler.go b/vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/global/reconciler.go new file mode 100644 index 0000000000..00e95804c3 --- /dev/null +++ b/vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/global/reconciler.go @@ -0,0 +1,301 @@ +package global + +import ( + "context" + + "github.com/docker/swarmkit/api" + "github.com/docker/swarmkit/manager/constraint" + "github.com/docker/swarmkit/manager/orchestrator" + "github.com/docker/swarmkit/manager/state/store" +) + +// restartSupervisor is an interface representing the methods from the +// restart.SupervisorInterface that are actually needed by the reconciler. This +// more limited interface allows us to write a less ugly fake for unit testing. +type restartSupervisor interface { + Restart(context.Context, store.Tx, *api.Cluster, *api.Service, api.Task) error +} + +// Reconciler is an object that manages reconciliation of global jobs. It is +// blocking and non-asynchronous, for ease of testing. It implements the +// Reconciler interface from the orchestrator package above it, and the +// taskinit.InitHandler interface. +type Reconciler struct { + store *store.MemoryStore + + restart restartSupervisor +} + +// NewReconciler creates a new global job reconciler. +func NewReconciler(store *store.MemoryStore, restart restartSupervisor) *Reconciler { + return &Reconciler{ + store: store, + restart: restart, + } +} + +// ReconcileService reconciles one global job service. +func (r *Reconciler) ReconcileService(id string) error { + var ( + service *api.Service + cluster *api.Cluster + tasks []*api.Task + nodes []*api.Node + viewErr error + ) + + // we need to first get the latest iteration of the service, its tasks, and + // the nodes in the cluster. + r.store.View(func(tx store.ReadTx) { + service = store.GetService(tx, id) + if service == nil { + return + } + + // getting tasks with FindTasks should only return an error if we've + // made a mistake coding; there's no user-input or even reasonable + // system state that can cause it. If it returns an error, we'll just + // panic and crash. + tasks, viewErr = store.FindTasks(tx, store.ByServiceID(id)) + if viewErr != nil { + return + } + + // same as with FindTasks + nodes, viewErr = store.FindNodes(tx, store.All) + if viewErr != nil { + return + } + + clusters, _ := store.FindClusters(tx, store.All) + if len(clusters) == 1 { + cluster = clusters[0] + } else if len(clusters) > 1 { + panic("there should never be more than one cluster object") + } + }) + + if viewErr != nil { + return viewErr + } + + // the service may be nil if the service has been deleted before we entered + // the View. + if service == nil { + return nil + } + + if service.JobStatus == nil { + service.JobStatus = &api.JobStatus{} + } + + // we need to compute the constraints on the service so we know which nodes + // to schedule it on + var constraints []constraint.Constraint + if service.Spec.Task.Placement != nil && len(service.Spec.Task.Placement.Constraints) != 0 { + // constraint.Parse does return an error, but we don't need to check + // it, because it was already checked when the service was created or + // updated. + constraints, _ = constraint.Parse(service.Spec.Task.Placement.Constraints) + } + + var candidateNodes []string + var invalidNodes []string + for _, node := range nodes { + // instead of having a big ugly multi-line boolean expression in the + // if-statement, we'll have several if-statements, and bail out of + // this loop iteration with continue if the node is not acceptable + if !constraint.NodeMatches(constraints, node) { + continue + } + + // if a node is invalid, we should remove any tasks that might be on it + if orchestrator.InvalidNode(node) { + invalidNodes = append(invalidNodes, node.ID) + continue + } + + if node.Spec.Availability != api.NodeAvailabilityActive { + continue + } + if node.Status.State != api.NodeStatus_READY { + continue + } + // you can append to a nil slice and get a non-nil slice, which is + // pretty slick. + candidateNodes = append(candidateNodes, node.ID) + } + + // now, we have a list of all nodes that match constraints. it's time to + // match running tasks to the nodes. we need to identify all nodes that + // need new tasks, which is any node that doesn't have a task of this job + // iteration. trade some space for some time by building a node ID to task + // ID mapping, so that we're just doing 2x linear operation, instead of a + // quadratic operation. + nodeToTask := map[string]string{} + // additionally, while we're iterating through tasks, if any of those tasks + // are failed, we'll hand them to the restart supervisor to handle + restartTasks := []string{} + // and if there are any tasks belonging to old job iterations, set them to + // be removed + removeTasks := []string{} + for _, task := range tasks { + // match all tasks belonging to this job iteration which are in desired + // state completed, including failed tasks. We only want to create + // tasks for nodes on which there are no existing tasks. + if task.JobIteration != nil { + if task.JobIteration.Index == service.JobStatus.JobIteration.Index && + task.DesiredState <= api.TaskStateCompleted { + // we already know the task is desired to be executing (because its + // desired state is Completed). Check here to see if it's already + // failed, so we can restart it + if task.Status.State > api.TaskStateCompleted { + restartTasks = append(restartTasks, task.ID) + } + nodeToTask[task.NodeID] = task.ID + } + + if task.JobIteration.Index != service.JobStatus.JobIteration.Index { + if task.DesiredState != api.TaskStateRemove { + removeTasks = append(removeTasks, task.ID) + } + } + } + } + + return r.store.Batch(func(batch *store.Batch) error { + // first, create any new tasks required. + for _, node := range candidateNodes { + // check if there is a task for this node ID. If not, then we need + // to create one. + if _, ok := nodeToTask[node]; !ok { + if err := batch.Update(func(tx store.Tx) error { + // if the node does not already have a running or completed + // task, create a task for this node. + task := orchestrator.NewTask(cluster, service, 0, node) + task.JobIteration = &service.JobStatus.JobIteration + task.DesiredState = api.TaskStateCompleted + return store.CreateTask(tx, task) + }); err != nil { + return err + } + } + } + + // then, restart any tasks that are failed + for _, taskID := range restartTasks { + if err := batch.Update(func(tx store.Tx) error { + // get the latest version of the task for the restart + t := store.GetTask(tx, taskID) + // if it's deleted, nothing to do + if t == nil { + return nil + } + + // if it's not still desired to be running, then don't restart + // it. + if t.DesiredState > api.TaskStateCompleted { + return nil + } + + // Finally, restart it + // TODO(dperny): pass in context to ReconcileService, so we can + // pass it in here. + return r.restart.Restart(context.Background(), tx, cluster, service, *t) + }); err != nil { + // TODO(dperny): probably should log like in the other + // orchestrators instead of returning here. + return err + } + } + + // remove tasks that need to be removed + for _, taskID := range removeTasks { + if err := batch.Update(func(tx store.Tx) error { + t := store.GetTask(tx, taskID) + if t == nil { + return nil + } + + if t.DesiredState == api.TaskStateRemove { + return nil + } + + t.DesiredState = api.TaskStateRemove + return store.UpdateTask(tx, t) + }); err != nil { + return err + } + } + + // finally, shut down any tasks on invalid nodes + for _, nodeID := range invalidNodes { + if taskID, ok := nodeToTask[nodeID]; ok { + if err := batch.Update(func(tx store.Tx) error { + t := store.GetTask(tx, taskID) + if t == nil { + return nil + } + // if the task is still desired to be running, and is still + // actually, running, then it still needs to be shut down. + if t.DesiredState > api.TaskStateCompleted || t.Status.State <= api.TaskStateRunning { + t.DesiredState = api.TaskStateShutdown + return store.UpdateTask(tx, t) + } + return nil + }); err != nil { + return err + } + } + } + return nil + }) +} + +// IsRelatedService returns true if the task is a global job. This method +// fulfills the taskinit.InitHandler interface. Because it is just a wrapper +// around a well-tested function call, it has no tests of its own. +func (r *Reconciler) IsRelatedService(service *api.Service) bool { + return orchestrator.IsGlobalJob(service) +} + +// FixTask validates that a task is compliant with the rest of the cluster +// state, and fixes it if it's not. This covers some main scenarios: +// +// * The node that the task is running on is now paused or drained. we do not +// need to check if the node still meets constraints -- that is the purview +// of the constraint enforcer. +// * The task has failed and needs to be restarted. +// +// This implements the FixTask method of the taskinit.InitHandler interface. +func (r *Reconciler) FixTask(ctx context.Context, batch *store.Batch, t *api.Task) { + // tasks already desired to be shut down need no action. + if t.DesiredState > api.TaskStateCompleted { + return + } + + batch.Update(func(tx store.Tx) error { + node := store.GetNode(tx, t.NodeID) + // if the node is no longer a valid node for this task, we need to shut + // it down + if orchestrator.InvalidNode(node) { + task := store.GetTask(tx, t.ID) + if task != nil && task.DesiredState < api.TaskStateShutdown { + task.DesiredState = api.TaskStateShutdown + return store.UpdateTask(tx, task) + } + } + // we will reconcile all services after fixing the tasks, so we don't + // need to restart tasks right now; we'll do so after this. + return nil + }) +} + +// SlotTuple returns a slot tuple representing this task. It implements the +// taskinit.InitHandler interface. +func (r *Reconciler) SlotTuple(t *api.Task) orchestrator.SlotTuple { + return orchestrator.SlotTuple{ + ServiceID: t.ServiceID, + NodeID: t.NodeID, + } +} diff --git a/vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/orchestrator.go b/vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/orchestrator.go new file mode 100644 index 0000000000..d244d3c65b --- /dev/null +++ b/vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/orchestrator.go @@ -0,0 +1,250 @@ +package jobs + +import ( + "context" + "sync" + + "github.com/docker/go-events" + + "github.com/docker/swarmkit/api" + "github.com/docker/swarmkit/log" + "github.com/docker/swarmkit/manager/orchestrator" + "github.com/docker/swarmkit/manager/orchestrator/jobs/global" + "github.com/docker/swarmkit/manager/orchestrator/jobs/replicated" + "github.com/docker/swarmkit/manager/orchestrator/restart" + "github.com/docker/swarmkit/manager/orchestrator/taskinit" + "github.com/docker/swarmkit/manager/state/store" +) + +// Reconciler is the type that holds the reconciliation logic for the +// orchestrator. It exists so that the logic of actually reconciling and +// writing to the store is separated from the orchestrator, to make the event +// handling logic in the orchestrator easier to test. +type Reconciler interface { + taskinit.InitHandler + + ReconcileService(id string) error +} + +// Orchestrator is the combined orchestrator controlling both Global and +// Replicated Jobs. Initially, these job types were two separate orchestrators, +// like the Replicated and Global orchestrators. However, it became apparent +// that because of the simplicity of Jobs as compared to Services, one combined +// orchestrator suffices for both job types. +type Orchestrator struct { + store *store.MemoryStore + + // two reconcilers, one for each service type + + replicatedReconciler Reconciler + globalReconciler Reconciler + + // startOnce is a function that stops the orchestrator from being started + // multiple times. + startOnce sync.Once + + // restartSupervisor is the component that handles restarting tasks + restartSupervisor restart.SupervisorInterface + + // stopChan is a channel that is closed to signal the orchestrator to stop + // running + stopChan chan struct{} + // stopOnce is used to ensure that stopChan can only be closed once, just + // in case some freak accident causes subsequent calls to Stop. + stopOnce sync.Once + // doneChan is closed when the orchestrator actually stops running + doneChan chan struct{} + + // checkTasksFunc is a variable that hold taskinit.CheckTasks, but allows + // swapping it out in testing. + checkTasksFunc func(context.Context, *store.MemoryStore, store.ReadTx, taskinit.InitHandler, restart.SupervisorInterface) error + + // the watchChan and watchCancel provide the event stream + watchChan chan events.Event + watchCancel func() +} + +func NewOrchestrator(store *store.MemoryStore) *Orchestrator { + return &Orchestrator{ + store: store, + stopChan: make(chan struct{}), + doneChan: make(chan struct{}), + } +} + +// Run runs the Orchestrator reconciliation loop. It takes a context as an +// argument, but canceling this context will not stop the routine; this context +// is only for passing in logging information. Call Stop to stop the +// Orchestrator +func (o *Orchestrator) Run(ctx context.Context) { + o.startOnce.Do(func() { o.run(ctx) }) +} + +// init runs the once-off initialization logic for the orchestrator. This +// includes initializing the sub-components, starting the channel watch, and +// running the initial reconciliation pass. this runs as part of the run +// method, but is broken out for the purpose of testing. +func (o *Orchestrator) init(ctx context.Context) { + var ( + services []*api.Service + ) + + // there are several components to the Orchestrator that are interfaces + // designed to be swapped out in testing. in production, these fields will + // all be unset, and be initialized here. in testing, we will set fakes, + // and this initialization will be skipped. + + if o.restartSupervisor == nil { + o.restartSupervisor = restart.NewSupervisor(o.store) + } + + if o.replicatedReconciler == nil { + // the cluster might be nil, but that doesn't matter. + o.replicatedReconciler = replicated.NewReconciler(o.store, o.restartSupervisor) + } + + if o.globalReconciler == nil { + o.globalReconciler = global.NewReconciler(o.store, o.restartSupervisor) + } + + if o.checkTasksFunc == nil { + o.checkTasksFunc = taskinit.CheckTasks + } + + o.watchChan, o.watchCancel, _ = store.ViewAndWatch(o.store, func(tx store.ReadTx) error { + services, _ = store.FindServices(tx, store.All) + return nil + }) + + // checkTasksFunc is used to resume any in-progress restarts that were + // interrupted by a leadership change. In other orchestrators, this + // additionally queues up some tasks to be restarted. However, the jobs + // orchestrator will make a reconciliation pass across all services + // immediately after this, and so does not need to restart any tasks; they + // will be restarted during this pass. + // + // we cannot call o.checkTasksFunc inside of store.ViewAndWatch above. + // despite taking a callback with a ReadTx, it actually performs an Update, + // which acquires a lock and will result in a deadlock. instead, do + // o.checkTasksFunc here. + o.store.View(func(tx store.ReadTx) { + o.checkTasksFunc(ctx, o.store, tx, o.replicatedReconciler, o.restartSupervisor) + o.checkTasksFunc(ctx, o.store, tx, o.globalReconciler, o.restartSupervisor) + }) + + for _, service := range services { + if orchestrator.IsReplicatedJob(service) { + if err := o.replicatedReconciler.ReconcileService(service.ID); err != nil { + log.G(ctx).WithField( + "service.id", service.ID, + ).WithError(err).Error("error reconciling replicated job") + } + } + + if orchestrator.IsGlobalJob(service) { + if err := o.globalReconciler.ReconcileService(service.ID); err != nil { + log.G(ctx).WithField( + "service.id", service.ID, + ).WithError(err).Error("error reconciling global job") + } + } + } +} + +// run provides the actual meat of the the run operation. The call to run is +// made inside of Run, and is enclosed in a sync.Once to stop this from being +// called multiple times +func (o *Orchestrator) run(ctx context.Context) { + ctx = log.WithModule(ctx, "orchestrator/jobs") + + // closing doneChan should be the absolute last thing that happens in this + // method, and so should be the absolute first thing we defer. + defer close(o.doneChan) + + o.init(ctx) + defer o.watchCancel() + + for { + // first, before taking any action, see if we should stop the + // orchestrator. if both the stop channel and the watch channel are + // available to read, the channel that gets read is picked at random, + // but we always want to stop if it's possible. + select { + case <-o.stopChan: + return + default: + } + + select { + case event := <-o.watchChan: + o.handleEvent(ctx, event) + case <-o.stopChan: + // we also need to check for stop in here, in case there are no + // updates to cause the loop to turn over. + return + } + } +} + +// handle event does the logic of handling one event message and calling the +// reconciler as needed. by handling the event logic in this function, we can +// make an end-run around the run-loop and avoid being at the mercy of the go +// scheduler when testing the orchestrator. +func (o *Orchestrator) handleEvent(ctx context.Context, event events.Event) { + var ( + service *api.Service + task *api.Task + ) + + switch ev := event.(type) { + case api.EventCreateService: + service = ev.Service + case api.EventUpdateService: + service = ev.Service + case api.EventUpdateTask: + task = ev.Task + } + + // if this is a task event, we should check if it means the service + // should be reconciled. + if task != nil { + // only bother with all this if the task has entered a terminal + // state and we don't want that to have happened. + if task.Status.State > api.TaskStateRunning && task.DesiredState <= api.TaskStateCompleted { + o.store.View(func(tx store.ReadTx) { + // if for any reason the service ID is invalid, then + // service will just be nil and nothing needs to be + // done + service = store.GetService(tx, task.ServiceID) + }) + } + } + + if orchestrator.IsReplicatedJob(service) { + if err := o.replicatedReconciler.ReconcileService(service.ID); err != nil { + log.G(ctx).WithField( + "service.id", service.ID, + ).WithError(err).Error("error reconciling replicated job") + } + } + + if orchestrator.IsGlobalJob(service) { + if err := o.globalReconciler.ReconcileService(service.ID); err != nil { + log.G(ctx).WithField( + "service.id", service.ID, + ).WithError(err).Error("error reconciling global job") + } + } +} + +// Stop stops the Orchestrator +func (o *Orchestrator) Stop() { + // close stopChan inside of the Once so that there can be no races + // involving multiple attempts to close stopChan. + o.stopOnce.Do(func() { + close(o.stopChan) + }) + // now, we wait for the Orchestrator to stop. this wait is unqualified; we + // will not return until Orchestrator has stopped successfully. + <-o.doneChan +} diff --git a/vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/replicated/reconciler.go b/vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/replicated/reconciler.go new file mode 100644 index 0000000000..886ac8d91e --- /dev/null +++ b/vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/replicated/reconciler.go @@ -0,0 +1,296 @@ +package replicated + +import ( + "context" + "fmt" + + "github.com/docker/swarmkit/api" + "github.com/docker/swarmkit/manager/orchestrator" + "github.com/docker/swarmkit/manager/state/store" +) + +// restartSupervisor is an interface representing the methods from the +// restart.SupervisorInterface that are actually needed by the reconciler. This +// more limited interface allows us to write a less ugly fake for unit testing. +type restartSupervisor interface { + Restart(context.Context, store.Tx, *api.Cluster, *api.Service, api.Task) error +} + +// Reconciler is an object that manages reconciliation of replicated jobs. It +// is blocking and non-asynchronous, for ease of testing. It implements two +// interfaces. The first is the Reconciler interface of the Orchestrator +// package above this one. The second is the taskinit.InitHandler interface. +type Reconciler struct { + // we need the store, of course, to do updates + store *store.MemoryStore + + restart restartSupervisor +} + +// newReconciler creates a new reconciler object +func NewReconciler(store *store.MemoryStore, restart restartSupervisor) *Reconciler { + return &Reconciler{ + store: store, + restart: restart, + } +} + +// ReconcileService reconciles the replicated job service with the given ID by +// checking to see if new replicas should be created. reconcileService returns +// an error if there is some case prevent it from correctly reconciling the +// service. +func (r *Reconciler) ReconcileService(id string) error { + var ( + service *api.Service + tasks []*api.Task + cluster *api.Cluster + viewErr error + ) + // first, get the service and all of its tasks + r.store.View(func(tx store.ReadTx) { + service = store.GetService(tx, id) + + tasks, viewErr = store.FindTasks(tx, store.ByServiceID(id)) + + // there should only ever be 1 cluster object, but for reasons + // forgotten by me, it needs to be retrieved in a rather roundabout way + // from the store + var clusters []*api.Cluster + clusters, viewErr = store.FindClusters(tx, store.All) + if len(clusters) == 1 { + cluster = clusters[0] + } else if len(clusters) > 1 { + // this should never happen, and indicates that the system is + // broken. + panic("there should never be more than one cluster object") + } + }) + + // errors during view should only happen in a few rather catastrophic + // cases, but here it's not unreasonable to just return an error anyway. + if viewErr != nil { + return viewErr + } + + // if the service has already been deleted, there's nothing to do here. + if service == nil { + return nil + } + + // if this is the first iteration of the service, it may not yet have a + // JobStatus, so we should create one if so. this won't actually be + // committed, though. + if service.JobStatus == nil { + service.JobStatus = &api.JobStatus{} + } + + // Jobs can be run in multiple iterations. The JobStatus of the service + // indicates which Version of iteration we're on. We should only be looking + // at tasks of the latest Version + + jobVersion := service.JobStatus.JobIteration.Index + + // now, check how many tasks we need and how many we have running. note + // that some of these Running tasks may complete before we even finish this + // code block, and so we might have to immediately re-enter reconciliation, + // so this number is 100% definitive, but it is accurate for this + // particular moment in time, and it won't result in us going OVER the + // needed task count + // + // importantly, we are computing only how many _new_ tasks are needed. Some + // tasks may need to be restarted as well, but we don't do this directly; + // restarting tasks is under the purview of the restartSupervisor. + // + // also also, for the math later, we need these values to be of type uint64. + runningTasks := uint64(0) + completeTasks := uint64(0) + restartTasks := []string{} + removeTasks := []string{} + + // for replicated jobs, each task will get a different slot number, so that + // when the job has completed, there will be one Completed task in every + // slot number [0, TotalCompletions-1]. + // + // By assigning each task to a unique slot, we simply handling of + // restarting failed tasks through the restart manager. + slots := map[uint64]bool{} + for _, task := range tasks { + // we only care about tasks from this job iteration. tasks from the + // previous job iteration are not important + if task.JobIteration != nil { + if task.JobIteration.Index == jobVersion { + if task.Status.State == api.TaskStateCompleted { + completeTasks++ + slots[task.Slot] = true + } + + // the Restart Manager may put a task in the desired state Ready, + // so we should match not only tasks in desired state Completed, + // but also those in any valid running state. + if task.Status.State != api.TaskStateCompleted && task.DesiredState <= api.TaskStateCompleted { + runningTasks++ + slots[task.Slot] = true + + // if the task is in a terminal state, we might need to restart + // it. throw it on the pile if so. this is still counted as a + // running task for the purpose of determining how many new + // tasks to create. + if task.Status.State > api.TaskStateCompleted { + restartTasks = append(restartTasks, task.ID) + } + } + } else { + // tasks belonging to a previous iteration of the job may + // exist. if any such tasks exist, they should have their task + // state set to Remove + if task.Status.State <= api.TaskStateRunning && task.DesiredState != api.TaskStateRemove { + removeTasks = append(removeTasks, task.ID) + } + } + } + } + + // now that we have our counts, we need to see how many new tasks to + // create. this number can never exceed MaxConcurrent, but also should not + // result in us exceeding TotalCompletions. first, get these numbers out of + // the service spec. + rj := service.Spec.GetReplicatedJob() + + // possibleNewTasks gives us the upper bound for how many tasks we'll + // create. also, ugh, subtracting uints. there's no way this can ever go + // wrong. + possibleNewTasks := rj.MaxConcurrent - runningTasks + + // allowedNewTasks is how many tasks we could create, if there were no + // restriction on maximum concurrency. This is the total number of tasks + // we want completed, minus the tasks that are already completed, minus + // the tasks that are in progress. + // + // seriously, ugh, subtracting unsigned ints. totally a fine and not at all + // risky operation, with no possibility for catastrophe + allowedNewTasks := rj.TotalCompletions - completeTasks - runningTasks + + // the lower number of allowedNewTasks and possibleNewTasks is how many we + // can create. we'll just use an if statement instead of some fancy floor + // function. + actualNewTasks := allowedNewTasks + if possibleNewTasks < allowedNewTasks { + actualNewTasks = possibleNewTasks + } + + // this check might seem odd, but it protects us from an underflow of the + // above subtractions, which, again, is a totally impossible thing that can + // never happen, ever, obviously. + if actualNewTasks > rj.TotalCompletions { + return fmt.Errorf( + "uint64 underflow, we're not going to create %v tasks", + actualNewTasks, + ) + } + + // finally, we can create these tasks. do this in a batch operation, to + // avoid exceeding transaction size limits + err := r.store.Batch(func(batch *store.Batch) error { + for i := uint64(0); i < actualNewTasks; i++ { + if err := batch.Update(func(tx store.Tx) error { + var slot uint64 + // each task will go into a unique slot, and at the end, there + // should be the same number of slots as there are desired + // total completions. We could simplify this logic by simply + // assuming that slots are filled in order, but it's a more + // robust solution to not assume that, and instead assure that + // the slot is unoccupied. + for s := uint64(0); s < rj.TotalCompletions; s++ { + // when we're iterating through, if the service has slots + // that haven't been used yet (for example, if this is the + // first time we're running this iteration), then doing + // a map lookup for the number will return the 0-value + // (false) even if the number doesn't exist in the map. + if !slots[s] { + slot = s + // once we've found a slot, mark it as occupied, so we + // don't double assign in subsequent iterations. + slots[slot] = true + break + } + } + + task := orchestrator.NewTask(cluster, service, slot, "") + // when we create the task, we also need to set the + // JobIteration. + task.JobIteration = &api.Version{Index: jobVersion} + task.DesiredState = api.TaskStateCompleted + + // finally, create the task in the store. + return store.CreateTask(tx, task) + }); err != nil { + return err + } + } + + for _, taskID := range restartTasks { + if err := batch.Update(func(tx store.Tx) error { + t := store.GetTask(tx, taskID) + if t == nil { + return nil + } + + if t.DesiredState > api.TaskStateCompleted { + return nil + } + + // TODO(dperny): pass in context from above + return r.restart.Restart(context.Background(), tx, cluster, service, *t) + }); err != nil { + return err + } + } + + for _, taskID := range removeTasks { + if err := batch.Update(func(tx store.Tx) error { + t := store.GetTask(tx, taskID) + if t == nil { + return nil + } + + // don't do unnecessary updates + if t.DesiredState == api.TaskStateRemove { + return nil + } + t.DesiredState = api.TaskStateRemove + return store.UpdateTask(tx, t) + }); err != nil { + return err + } + } + + return nil + }) + + return err +} + +// IsRelatedService returns true if the task is a replicated job. This method +// fulfills the taskinit.InitHandler interface. Because it is just a wrapper +// around a well-tested function call, it has no tests of its own. +func (r *Reconciler) IsRelatedService(service *api.Service) bool { + return orchestrator.IsReplicatedJob(service) +} + +// FixTask ostensibly validates that a task is compliant with the rest of the +// cluster state. However, in the replicated jobs case, the only action we +// can take with a noncompliant task is to restart it. Because the replicated +// jobs orchestrator reconciles the whole service at once, any tasks that +// need to be restarted will be done when we make the reconiliation pass over +// all services. Therefore, in this instance, FixTask does nothing except +// implement the FixTask method of the taskinit.InitHandler interface. +func (r *Reconciler) FixTask(_ context.Context, _ *store.Batch, _ *api.Task) {} + +// SlotTuple returns an orchestrator.SlotTuple object for this task. It +// implements the taskinit.InitHandler interface +func (r *Reconciler) SlotTuple(t *api.Task) orchestrator.SlotTuple { + return orchestrator.SlotTuple{ + ServiceID: t.ServiceID, + Slot: t.Slot, + } +} diff --git a/vendor/github.com/docker/swarmkit/manager/orchestrator/restart/restart.go b/vendor/github.com/docker/swarmkit/manager/orchestrator/restart/restart.go index 2b2a087aac..44e1309f6c 100644 --- a/vendor/github.com/docker/swarmkit/manager/orchestrator/restart/restart.go +++ b/vendor/github.com/docker/swarmkit/manager/orchestrator/restart/restart.go @@ -49,6 +49,20 @@ type delayedStart struct { waiter bool } +// SupervisorInterface is an interface implemented by the Supervisor. It exists +// to make testing easier, by allowing the restart supervisor to be mocked or +// faked where desired. +type SupervisorInterface interface { + Restart(context.Context, store.Tx, *api.Cluster, *api.Service, api.Task) error + UpdatableTasksInSlot(context.Context, orchestrator.Slot, *api.Service) orchestrator.Slot + RecordRestartHistory(orchestrator.SlotTuple, *api.Task) + DelayStart(context.Context, store.Tx, *api.Task, string, time.Duration, bool) <-chan struct{} + StartNow(store.Tx, string) error + Cancel(string) + CancelAll() + ClearServiceHistory(string) +} + // Supervisor initiates and manages restarts. It's responsible for // delaying restarts when applicable. type Supervisor struct { @@ -121,7 +135,7 @@ func (r *Supervisor) Restart(ctx context.Context, tx store.Tx, cluster *api.Clus // Sanity check: was the task shut down already by a separate call to // Restart? If so, we must avoid restarting it, because this will create // an extra task. This should never happen unless there is a bug. - if t.DesiredState > api.TaskStateRunning { + if t.DesiredState > api.TaskStateCompleted { return errors.New("Restart called on task that was already shut down") } @@ -138,15 +152,21 @@ func (r *Supervisor) Restart(ctx context.Context, tx store.Tx, cluster *api.Clus var restartTask *api.Task - if orchestrator.IsReplicatedService(service) { + if orchestrator.IsReplicatedService(service) || orchestrator.IsReplicatedJob(service) { restartTask = orchestrator.NewTask(cluster, service, t.Slot, "") - } else if orchestrator.IsGlobalService(service) { + } else if orchestrator.IsGlobalService(service) || orchestrator.IsGlobalJob(service) { restartTask = orchestrator.NewTask(cluster, service, 0, t.NodeID) } else { log.G(ctx).Error("service not supported by restart supervisor") return nil } + if orchestrator.IsReplicatedJob(service) || orchestrator.IsGlobalJob(service) { + restartTask.JobIteration = &api.Version{ + Index: service.JobStatus.JobIteration.Index, + } + } + n := store.GetNode(tx, t.NodeID) restartTask.DesiredState = api.TaskStateReady @@ -197,7 +217,17 @@ func (r *Supervisor) shouldRestart(ctx context.Context, t *api.Task, service *ap // There are 3 possible restart policies. switch orchestrator.RestartCondition(t) { case api.RestartOnAny: - // we will be restarting, we just need to do a few more checks + // we will be restarting, we just need to do a few more checks. + // however, if the task belongs to a job, then we will treat + // RestartOnAny the same as RestartOnFailure, as it would be + // nonsensical to restart completed jobs. + if orchestrator.IsReplicatedJob(service) || orchestrator.IsGlobalJob(service) { + // it'd be nice to put a fallthrough here, but we can't fallthrough + // from inside of an if statement. + if t.Status.State == api.TaskStateCompleted { + return false + } + } case api.RestartOnFailure: // we won't restart if the task is in TaskStateCompleted, as this is a // not a failed state -- it indicates that the task exited with 0 @@ -498,7 +528,15 @@ func (r *Supervisor) StartNow(tx store.Tx, taskID string) error { if t == nil || t.DesiredState >= api.TaskStateRunning { return nil } - t.DesiredState = api.TaskStateRunning + + // only tasks belonging to jobs will have a JobIteration, so this can be + // used to distinguish whether this is a job task without looking at the + // service. + if t.JobIteration != nil { + t.DesiredState = api.TaskStateCompleted + } else { + t.DesiredState = api.TaskStateRunning + } return store.UpdateTask(tx, t) } diff --git a/vendor/github.com/docker/swarmkit/manager/orchestrator/service.go b/vendor/github.com/docker/swarmkit/manager/orchestrator/service.go index c5d298c516..adc5181b50 100644 --- a/vendor/github.com/docker/swarmkit/manager/orchestrator/service.go +++ b/vendor/github.com/docker/swarmkit/manager/orchestrator/service.go @@ -28,6 +28,26 @@ func IsGlobalService(service *api.Service) bool { return ok } +// IsReplicatedJob returns true if the service is a replicated job. +func IsReplicatedJob(service *api.Service) bool { + if service == nil { + return false + } + + _, ok := service.Spec.GetMode().(*api.ServiceSpec_ReplicatedJob) + return ok +} + +// IsGlobalJob returns true if the service is a global job. +func IsGlobalJob(service *api.Service) bool { + if service == nil { + return false + } + + _, ok := service.Spec.GetMode().(*api.ServiceSpec_GlobalJob) + return ok +} + // SetServiceTasksRemove sets the desired state of tasks associated with a service // to REMOVE, so that they can be properly shut down by the agent and later removed // by the task reaper. diff --git a/vendor/github.com/docker/swarmkit/manager/orchestrator/taskinit/init.go b/vendor/github.com/docker/swarmkit/manager/orchestrator/taskinit/init.go index be319cc25d..5636c3c699 100644 --- a/vendor/github.com/docker/swarmkit/manager/orchestrator/taskinit/init.go +++ b/vendor/github.com/docker/swarmkit/manager/orchestrator/taskinit/init.go @@ -23,7 +23,7 @@ type InitHandler interface { // CheckTasks fixes tasks in the store before orchestrator runs. The previous leader might // not have finished processing their updates and left them in an inconsistent state. -func CheckTasks(ctx context.Context, s *store.MemoryStore, readTx store.ReadTx, initHandler InitHandler, startSupervisor *restart.Supervisor) error { +func CheckTasks(ctx context.Context, s *store.MemoryStore, readTx store.ReadTx, initHandler InitHandler, startSupervisor restart.SupervisorInterface) error { instances := make(map[orchestrator.SlotTuple][]*api.Task) err := s.Batch(func(batch *store.Batch) error { tasks, err := store.FindTasks(readTx, store.All) @@ -59,7 +59,7 @@ func CheckTasks(ctx context.Context, s *store.MemoryStore, readTx store.ReadTx, // desired state ready is a transient state that it should be started. // however previous leader may not have started it, retry start here - if t.DesiredState != api.TaskStateReady || t.Status.State > api.TaskStateRunning { + if t.DesiredState != api.TaskStateReady || t.Status.State > api.TaskStateCompleted { continue } restartDelay, _ := gogotypes.DurationFromProto(defaults.Service.Task.Restart.Delay) diff --git a/vendor/github.com/docker/swarmkit/manager/scheduler/nodeinfo.go b/vendor/github.com/docker/swarmkit/manager/scheduler/nodeinfo.go index 8f1ad331b5..a854ab63e6 100644 --- a/vendor/github.com/docker/swarmkit/manager/scheduler/nodeinfo.go +++ b/vendor/github.com/docker/swarmkit/manager/scheduler/nodeinfo.go @@ -70,7 +70,7 @@ func (nodeInfo *NodeInfo) removeTask(t *api.Task) bool { } delete(nodeInfo.Tasks, t.ID) - if oldTask.DesiredState <= api.TaskStateRunning { + if oldTask.DesiredState <= api.TaskStateCompleted { nodeInfo.ActiveTasksCount-- nodeInfo.ActiveTasksCountByService[t.ServiceID]-- } @@ -108,12 +108,12 @@ func (nodeInfo *NodeInfo) removeTask(t *api.Task) bool { func (nodeInfo *NodeInfo) addTask(t *api.Task) bool { oldTask, ok := nodeInfo.Tasks[t.ID] if ok { - if t.DesiredState <= api.TaskStateRunning && oldTask.DesiredState > api.TaskStateRunning { + if t.DesiredState <= api.TaskStateCompleted && oldTask.DesiredState > api.TaskStateCompleted { nodeInfo.Tasks[t.ID] = t nodeInfo.ActiveTasksCount++ nodeInfo.ActiveTasksCountByService[t.ServiceID]++ return true - } else if t.DesiredState > api.TaskStateRunning && oldTask.DesiredState <= api.TaskStateRunning { + } else if t.DesiredState > api.TaskStateCompleted && oldTask.DesiredState <= api.TaskStateCompleted { nodeInfo.Tasks[t.ID] = t nodeInfo.ActiveTasksCount-- nodeInfo.ActiveTasksCountByService[t.ServiceID]-- @@ -145,7 +145,7 @@ func (nodeInfo *NodeInfo) addTask(t *api.Task) bool { } } - if t.DesiredState <= api.TaskStateRunning { + if t.DesiredState <= api.TaskStateCompleted { nodeInfo.ActiveTasksCount++ nodeInfo.ActiveTasksCountByService[t.ServiceID]++ } diff --git a/vendor/github.com/docker/swarmkit/manager/scheduler/scheduler.go b/vendor/github.com/docker/swarmkit/manager/scheduler/scheduler.go index 939fc6f96d..fda0089511 100644 --- a/vendor/github.com/docker/swarmkit/manager/scheduler/scheduler.go +++ b/vendor/github.com/docker/swarmkit/manager/scheduler/scheduler.go @@ -74,9 +74,10 @@ func (s *Scheduler) setupTasksList(tx store.ReadTx) error { continue } - // Also ignore tasks that have not yet been assigned but desired state is beyond TaskStateRunning - // This can happen if you update, delete or scale down a service before its tasks were assigned. - if t.Status.State == api.TaskStatePending && t.DesiredState > api.TaskStateRunning { + // Also ignore tasks that have not yet been assigned but desired state + // is beyond TaskStateCompleted. This can happen if you update, delete + // or scale down a service before its tasks were assigned. + if t.Status.State == api.TaskStatePending && t.DesiredState > api.TaskStateCompleted { continue } diff --git a/vendor/github.com/docker/swarmkit/vendor.conf b/vendor/github.com/docker/swarmkit/vendor.conf index 81dcfd4cf9..1220bc9f1e 100644 --- a/vendor/github.com/docker/swarmkit/vendor.conf +++ b/vendor/github.com/docker/swarmkit/vendor.conf @@ -65,3 +65,12 @@ golang.org/x/net f3200d17e092c607f615320ecaad13d87ad9a2b3 golang.org/x/sys 9eafafc0a87e0fd0aeeba439a4573537970c44c7 golang.org/x/text f21a4dfb5e38f5895301dc265a8def02365cc3d0 # v0.3.0 golang.org/x/time fbb02b2291d28baffd63558aa44b4b56f178d650 + +# ginkgo is used for testing in some places in the code. this is it and its +# sub-dependencies. +github.com/onsi/ginkgo v1.8.0 +github.com/onsi/gomega v1.5.0 +gopkg.in/yaml.v2 v2.2.1 +github.com/hpcloud/tail v1.0.0 +gopkg.in/fsnotify.v1 v1.4.7 +gopkg.in/tomb.v1 v1