p4u1/docker-cli
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge component 'engine' from git@github.com:moby/moby master

Browse Source
This commit is contained in:
Andrew Hsu
2017-09-28 10:34:35 -07:00
parent 747646833d e25514ef0c
commit ae273c63d1
40 changed files with 469 additions and 735 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
components/engine/Dockerfile
View File

@ -55,6 +55,7 @@ RUN apt-get update && apt-get install -y \
libnl-3-dev \
libprotobuf-c0-dev \
libprotobuf-dev \
libseccomp-dev \
libsystemd-dev \
libtool \
libudev-dev \
@ -80,21 +81,6 @@ RUN apt-get update && apt-get install -y \
--no-install-recommends \
&& pip install awscli==1.10.15
# Install seccomp: the version shipped upstream is too old
ENV SECCOMP_VERSION 2.3.2
RUN set -x \
&& export SECCOMP_PATH="$(mktemp -d)" \
&& curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
| tar -xzC "$SECCOMP_PATH" --strip-components=1 \
&& ( \
cd "$SECCOMP_PATH" \
&& ./configure --prefix=/usr/local \
&& make \
&& make install \
&& ldconfig \
) \
&& rm -rf "$SECCOMP_PATH"
# Install Go
# IMPORTANT: If the version of Go is updated, the Windows to Linux CI machines
# will need updating, to avoid errors. Ping #docker-maintainers on IRC

16
components/engine/Dockerfile.aarch64
View File

@ -48,6 +48,7 @@ RUN apt-get update && apt-get install -y \
libnl-3-dev \
libprotobuf-c0-dev \
libprotobuf-dev \
libseccomp-dev \
libsystemd-dev \
libtool \
libudev-dev \
@ -72,21 +73,6 @@ RUN apt-get update && apt-get install -y \
zip \
--no-install-recommends
# Install seccomp: the version shipped upstream is too old
ENV SECCOMP_VERSION 2.3.2
RUN set -x \
&& export SECCOMP_PATH="$(mktemp -d)" \
&& curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
| tar -xzC "$SECCOMP_PATH" --strip-components=1 \
&& ( \
cd "$SECCOMP_PATH" \
&& ./configure --prefix=/usr/local \
&& make \
&& make install \
&& ldconfig \
) \
&& rm -rf "$SECCOMP_PATH"
# Install Go
# We don't have official binary golang 1.7.5 tarballs for ARM64, either for Go or
# bootstrap, so we use Debian golang (1.7) as bootstrap to build Go from source code.

16
components/engine/Dockerfile.armhf
View File

@ -40,6 +40,7 @@ RUN apt-get update && apt-get install -y \
libapparmor-dev \
libcap-dev \
libdevmapper-dev \
libseccomp-dev \
libsystemd-dev \
libtool \
libudev-dev \
@ -72,21 +73,6 @@ ENV GOPATH /go
ENV GOARCH arm
ENV GOARM 7
# Install seccomp: the version shipped upstream is too old
ENV SECCOMP_VERSION 2.3.2
RUN set -x \
&& export SECCOMP_PATH="$(mktemp -d)" \
&& curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
| tar -xzC "$SECCOMP_PATH" --strip-components=1 \
&& ( \
cd "$SECCOMP_PATH" \
&& ./configure --prefix=/usr/local \
&& make \
&& make install \
&& ldconfig \
) \
&& rm -rf "$SECCOMP_PATH"
# Install two versions of the registry. The first is an older version that
# only supports schema1 manifests. The second is a newer version that supports
# both. This allows integration-cli tests to cover push/pull with both schema1

17
components/engine/Dockerfile.ppc64le
View File

@ -41,6 +41,7 @@ RUN apt-get update && apt-get install -y \
libapparmor-dev \
libcap-dev \
libdevmapper-dev \
libseccomp-dev \
libsystemd-dev \
libtool \
libudev-dev \
@ -60,22 +61,6 @@ RUN apt-get update && apt-get install -y \
vim-common \
--no-install-recommends
# Install seccomp: the version shipped upstream is too old
ENV SECCOMP_VERSION 2.3.2
RUN set -x \
&& export SECCOMP_PATH="$(mktemp -d)" \
&& curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
| tar -xzC "$SECCOMP_PATH" --strip-components=1 \
&& ( \
cd "$SECCOMP_PATH" \
&& ./configure --prefix=/usr/local \
&& make \
&& make install \
&& ldconfig \
) \
&& rm -rf "$SECCOMP_PATH"
# Install Go
# NOTE: official ppc64le go binaries weren't available until go 1.6.4 and 1.7.4
# IMPORTANT: When updating this please note that stdlib archive/tar pkg is vendored

16
components/engine/Dockerfile.s390x
View File

@ -37,6 +37,7 @@ RUN apt-get update && apt-get install -y \
libapparmor-dev \
libcap-dev \
libdevmapper-dev \
libseccomp-dev \
libsystemd-dev \
libtool \
libudev-dev \
@ -56,21 +57,6 @@ RUN apt-get update && apt-get install -y \
vim-common \
--no-install-recommends
# Install seccomp: the version shipped upstream is too old
ENV SECCOMP_VERSION 2.3.2
RUN set -x \
&& export SECCOMP_PATH="$(mktemp -d)" \
&& curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
| tar -xzC "$SECCOMP_PATH" --strip-components=1 \
&& ( \
cd "$SECCOMP_PATH" \
&& ./configure --prefix=/usr/local \
&& make \
&& make install \
&& ldconfig \
) \
&& rm -rf "$SECCOMP_PATH"
# IMPORTANT: When updating this please note that stdlib archive/tar pkg is vendored
ENV GO_VERSION 1.8.3
RUN curl -fsSL "https://golang.org/dl/go${GO_VERSION}.linux-s390x.tar.gz" \

16
components/engine/Dockerfile.simple
View File

@ -23,6 +23,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
git \
libapparmor-dev \
libdevmapper-dev \
libseccomp-dev \
ca-certificates \
e2fsprogs \
iptables \
@ -34,21 +35,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
vim-common \
&& rm -rf /var/lib/apt/lists/*
# Install seccomp: the version shipped upstream is too old
ENV SECCOMP_VERSION 2.3.2
RUN set -x \
&& export SECCOMP_PATH="$(mktemp -d)" \
&& curl -fsSL "https://github.com/seccomp/libseccomp/releases/download/v${SECCOMP_VERSION}/libseccomp-${SECCOMP_VERSION}.tar.gz" \
| tar -xzC "$SECCOMP_PATH" --strip-components=1 \
&& ( \
cd "$SECCOMP_PATH" \
&& ./configure --prefix=/usr/local \
&& make \
&& make install \
&& ldconfig \
) \
&& rm -rf "$SECCOMP_PATH"
# Install Go
# IMPORTANT: If the version of Go is updated, the Windows to Linux CI machines
# will need updating, to avoid errors. Ping #docker-maintainers on IRC

10
components/engine/builder/dockerfile/parser/parser.go
View File

@ -290,6 +290,10 @@ func Parse(rwc io.Reader) (*Result, error) {
}
currentLine++
if isComment(scanner.Bytes()) {
// original line was a comment (processLine strips comments)
continue
}
if isEmptyContinuationLine(bytesRead) {
hasEmptyContinuationLine = true
continue
@ -331,8 +335,12 @@ func trimWhitespace(src []byte) []byte {
return bytes.TrimLeftFunc(src, unicode.IsSpace)
}
func isComment(line []byte) bool {
return tokenComment.Match(trimWhitespace(line))
}
func isEmptyContinuationLine(line []byte) bool {
return len(trimComments(trimWhitespace(line))) == 0
return len(trimWhitespace(line)) == 0
}
var utf8bom = []byte{0xEF, 0xBB, 0xBF}

7
components/engine/builder/dockerfile/parser/parser_test.go
View File

@ -141,6 +141,13 @@ RUN something \
RUN another \
thing
RUN non-indented \
# this is a comment
after-comment
RUN indented \
# this is an indented comment
comment
`)
result, err := Parse(dockerfile)

2
components/engine/daemon/cluster/executor/backend.go
View File

@ -62,5 +62,5 @@ type Backend interface {
LookupImage(name string) (*types.ImageInspect, error)
PluginManager() *plugin.Manager
PluginGetter() *plugin.Store
GetLBAttachmentStore() *networkSettings.LBAttachmentStore
GetAttachmentStore() *networkSettings.AttachmentStore
}

10
components/engine/daemon/cluster/executor/container/executor.go
View File

@ -137,18 +137,18 @@ func (e *executor) Describe(ctx context.Context) (*api.NodeDescription, error) {
func (e *executor) Configure(ctx context.Context, node *api.Node) error {
var ingressNA *api.NetworkAttachment
lbAttachments := make(map[string]string)
attachments := make(map[string]string)
for _, na := range node.LbAttachments {
for _, na := range node.Attachments {
if na.Network.Spec.Ingress {
ingressNA = na
}
lbAttachments[na.Network.ID] = na.Addresses[0]
attachments[na.Network.ID] = na.Addresses[0]
}
if ingressNA == nil {
e.backend.ReleaseIngress()
return e.backend.GetLBAttachmentStore().ResetLBAttachments(lbAttachments)
return e.backend.GetAttachmentStore().ResetAttachments(attachments)
}
options := types.NetworkCreate{
@ -181,7 +181,7 @@ func (e *executor) Configure(ctx context.Context, node *api.Node) error {
return err
}
return e.backend.GetLBAttachmentStore().ResetLBAttachments(lbAttachments)
return e.backend.GetAttachmentStore().ResetAttachments(attachments)
}
// Controller returns a docker container runner.

10
components/engine/daemon/daemon.go
View File

@ -125,7 +125,7 @@ type Daemon struct {
hosts map[string]bool // hosts stores the addresses the daemon is listening on
startupDone chan struct{}
lbAttachmentStore network.LBAttachmentStore
attachmentStore network.AttachmentStore
}
// StoreHosts stores the addresses the daemon is listening on
@ -491,7 +491,7 @@ func (daemon *Daemon) DaemonLeavesCluster() {
logrus.Warnf("failed to initiate ingress network removal: %v", err)
}
daemon.lbAttachmentStore.ClearLBAttachments()
daemon.attachmentStore.ClearAttachments()
}
// setClusterProvider sets a component for querying the current cluster state.
@ -1251,7 +1251,7 @@ func fixMemorySwappiness(resources *containertypes.Resources) {
}
}
// GetLBAttachmentStore returns current load balancer store associated with the daemon
func (daemon *Daemon) GetLBAttachmentStore() *network.LBAttachmentStore {
return &daemon.lbAttachmentStore
// GetAttachmentStore returns current attachment store associated with the daemon
func (daemon *Daemon) GetAttachmentStore() *network.AttachmentStore {
return &daemon.attachmentStore
}

2
components/engine/daemon/network.go
View File

@ -370,7 +370,7 @@ func (daemon *Daemon) createNetwork(create types.NetworkCreateRequest, id string
daemon.LogNetworkEvent(n, "create")
if agent && !n.Info().Ingress() && n.Type() == "overlay" {
nodeIP, exists := daemon.GetLBAttachmentStore().GetLBIPForNetwork(id)
nodeIP, exists := daemon.GetAttachmentStore().GetIPForNetwork(id)
if !exists {
return nil, fmt.Errorf("Failed to find a load balancer IP to use for network: %v", id)
}

30
components/engine/daemon/network/settings.go
View File

@ -35,35 +35,35 @@ type EndpointSettings struct {
IPAMOperational bool
}
// LBAttachmentStore stores the load balancer IP address for a network id.
type LBAttachmentStore struct {
// AttachmentStore stores the load balancer IP address for a network id.
type AttachmentStore struct {
//key: networkd id
//value: load balancer ip address
networkToNodeLBIP map[string]net.IP
}
// ResetLBAttachments clears any exsiting load balancer IP to network mapping and
// sets the mapping to the given lbAttachments.
func (lbStore *LBAttachmentStore) ResetLBAttachments(lbAttachments map[string]string) error {
lbStore.ClearLBAttachments()
for nid, nodeIP := range lbAttachments {
// ResetAttachments clears any exsiting load balancer IP to network mapping and
// sets the mapping to the given attachments.
func (store *AttachmentStore) ResetAttachments(attachments map[string]string) error {
store.ClearAttachments()
for nid, nodeIP := range attachments {
ip, _, err := net.ParseCIDR(nodeIP)
if err != nil {
lbStore.networkToNodeLBIP = make(map[string]net.IP)
store.networkToNodeLBIP = make(map[string]net.IP)
return errors.Wrapf(err, "Failed to parse load balancer address %s", nodeIP)
}
lbStore.networkToNodeLBIP[nid] = ip
store.networkToNodeLBIP[nid] = ip
}
return nil
}
// ClearLBAttachments clears all the mappings of network to load balancer IP Address.
func (lbStore *LBAttachmentStore) ClearLBAttachments() {
lbStore.networkToNodeLBIP = make(map[string]net.IP)
// ClearAttachments clears all the mappings of network to load balancer IP Address.
func (store *AttachmentStore) ClearAttachments() {
store.networkToNodeLBIP = make(map[string]net.IP)
}
// GetLBIPForNetwork return the load balancer IP address for the given network.
func (lbStore *LBAttachmentStore) GetLBIPForNetwork(networkID string) (net.IP, bool) {
ip, exists := lbStore.networkToNodeLBIP[networkID]
// GetIPForNetwork return the load balancer IP address for the given network.
func (store *AttachmentStore) GetIPForNetwork(networkID string) (net.IP, bool) {
ip, exists := store.networkToNodeLBIP[networkID]
return ip, exists
}

6
components/engine/integration-cli/docker_api_swarm_service_test.go
View File

@ -186,7 +186,7 @@ func (s *DockerSwarmSuite) TestAPISwarmServicesUpdate(c *check.C) {
// Roll back to the previous version. This uses the CLI because
// rollback used to be a client-side operation.
out, err := daemons[0].Cmd("service", "update", "--rollback", id)
out, err := daemons[0].Cmd("service", "update", "--detach", "--rollback", id)
c.Assert(err, checker.IsNil, check.Commentf(out))
// first batch
@ -295,7 +295,7 @@ func (s *DockerSwarmSuite) TestAPISwarmServicesUpdateStartFirst(c *check.C) {
// Roll back to the previous version. This uses the CLI because
// rollback is a client-side operation.
out, err := d.Cmd("service", "update", "--rollback", id)
out, err := d.Cmd("service", "update", "--detach", "--rollback", id)
c.Assert(err, checker.IsNil, check.Commentf(out))
// first batch
@ -340,7 +340,7 @@ func (s *DockerSwarmSuite) TestAPISwarmServicesFailedUpdate(c *check.C) {
// Roll back to the previous version. This uses the CLI because
// rollback used to be a client-side operation.
out, err := daemons[0].Cmd("service", "update", "--rollback", id)
out, err := daemons[0].Cmd("service", "update", "--detach", "--rollback", id)
c.Assert(err, checker.IsNil, check.Commentf(out))
waitAndAssert(c, defaultReconciliationTimeout, daemons[0].CheckRunningTaskImages, checker.DeepEquals,

2
components/engine/integration-cli/docker_cli_prune_unix_test.go
View File

@ -54,7 +54,7 @@ func (s *DockerSwarmSuite) TestPruneNetwork(c *check.C) {
serviceName := "testprunesvc"
replicas := 1
out, err := d.Cmd("service", "create", "--no-resolve-image",
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image",
"--name", serviceName,
"--replicas", strconv.Itoa(replicas),
"--network", "n3",

12
components/engine/integration-cli/docker_cli_service_create_test.go
View File

@ -76,7 +76,7 @@ func (s *DockerSwarmSuite) TestServiceCreateWithSecretSimple(c *check.C) {
})
c.Assert(id, checker.Not(checker.Equals), "", check.Commentf("secrets: %s", id))
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", serviceName, "--secret", testName, "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "--secret", testName, "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
out, err = d.Cmd("service", "inspect", "--format", "{{ json .Spec.TaskTemplate.ContainerSpec.Secrets }}", serviceName)
@ -122,7 +122,7 @@ func (s *DockerSwarmSuite) TestServiceCreateWithSecretSourceTargetPaths(c *check
}
serviceName := "svc"
serviceCmd := []string{"service", "create", "--no-resolve-image", "--name", serviceName}
serviceCmd := []string{"service", "create", "--detach", "--no-resolve-image", "--name", serviceName}
serviceCmd = append(serviceCmd, secretFlags...)
serviceCmd = append(serviceCmd, "busybox", "top")
out, err := d.Cmd(serviceCmd...)
@ -175,7 +175,7 @@ func (s *DockerSwarmSuite) TestServiceCreateWithSecretReferencedTwice(c *check.C
c.Assert(id, checker.Not(checker.Equals), "", check.Commentf("secrets: %s", id))
serviceName := "svc"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", serviceName, "--secret", "source=mysecret,target=target1", "--secret", "source=mysecret,target=target2", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "--secret", "source=mysecret,target=target1", "--secret", "source=mysecret,target=target2", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
out, err = d.Cmd("service", "inspect", "--format", "{{ json .Spec.TaskTemplate.ContainerSpec.Secrets }}", serviceName)
@ -224,7 +224,7 @@ func (s *DockerSwarmSuite) TestServiceCreateWithConfigSimple(c *check.C) {
})
c.Assert(id, checker.Not(checker.Equals), "", check.Commentf("configs: %s", id))
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", serviceName, "--config", testName, "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "--config", testName, "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
out, err = d.Cmd("service", "inspect", "--format", "{{ json .Spec.TaskTemplate.ContainerSpec.Configs }}", serviceName)
@ -269,7 +269,7 @@ func (s *DockerSwarmSuite) TestServiceCreateWithConfigSourceTargetPaths(c *check
}
serviceName := "svc"
serviceCmd := []string{"service", "create", "--no-resolve-image", "--name", serviceName}
serviceCmd := []string{"service", "create", "--detach", "--no-resolve-image", "--name", serviceName}
serviceCmd = append(serviceCmd, configFlags...)
serviceCmd = append(serviceCmd, "busybox", "top")
out, err := d.Cmd(serviceCmd...)
@ -322,7 +322,7 @@ func (s *DockerSwarmSuite) TestServiceCreateWithConfigReferencedTwice(c *check.C
c.Assert(id, checker.Not(checker.Equals), "", check.Commentf("configs: %s", id))
serviceName := "svc"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", serviceName, "--config", "source=myconfig,target=target1", "--config", "source=myconfig,target=target2", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "--config", "source=myconfig,target=target1", "--config", "source=myconfig,target=target2", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
out, err = d.Cmd("service", "inspect", "--format", "{{ json .Spec.TaskTemplate.ContainerSpec.Configs }}", serviceName)

18
components/engine/integration-cli/docker_cli_service_logs_test.go
View File

@ -31,7 +31,7 @@ func (s *DockerSwarmSuite) TestServiceLogs(c *check.C) {
}
for name, message := range services {
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "busybox",
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "busybox",
"sh", "-c", fmt.Sprintf("echo %s; tail -f /dev/null", message))
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
@ -74,7 +74,7 @@ func (s *DockerSwarmSuite) TestServiceLogsCompleteness(c *check.C) {
name := "TestServiceLogsCompleteness"
// make a service that prints 6 lines
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "busybox", "sh", "-c", "for line in $(seq 0 5); do echo log test $line; done; sleep 100000")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "busybox", "sh", "-c", "for line in $(seq 0 5); do echo log test $line; done; sleep 100000")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
@ -101,7 +101,7 @@ func (s *DockerSwarmSuite) TestServiceLogsTail(c *check.C) {
name := "TestServiceLogsTail"
// make a service that prints 6 lines
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "busybox", "sh", "-c", "for line in $(seq 1 6); do echo log test $line; done; sleep 100000")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "busybox", "sh", "-c", "for line in $(seq 1 6); do echo log test $line; done; sleep 100000")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
@ -125,7 +125,7 @@ func (s *DockerSwarmSuite) TestServiceLogsSince(c *check.C) {
name := "TestServiceLogsSince"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "busybox", "sh", "-c", "for i in $(seq 1 3); do sleep .1; echo log$i; done; sleep 10000000")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "busybox", "sh", "-c", "for i in $(seq 1 3); do sleep .1; echo log$i; done; sleep 10000000")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
@ -159,7 +159,7 @@ func (s *DockerSwarmSuite) TestServiceLogsFollow(c *check.C) {
name := "TestServiceLogsFollow"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "busybox", "sh", "-c", "while true; do echo log test; sleep 0.1; done")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "busybox", "sh", "-c", "while true; do echo log test; sleep 0.1; done")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
@ -207,7 +207,7 @@ func (s *DockerSwarmSuite) TestServiceLogsTaskLogs(c *check.C) {
result := icmd.RunCmd(d.Command(
// create a service with the name
"service", "create", "--no-resolve-image", "--name", name,
"service", "create", "--detach", "--no-resolve-image", "--name", name,
// which has some number of replicas
fmt.Sprintf("--replicas=%v", replicas),
// which has this the task id as an environment variable templated in
@ -259,7 +259,7 @@ func (s *DockerSwarmSuite) TestServiceLogsTTY(c *check.C) {
result := icmd.RunCmd(d.Command(
// create a service
"service", "create", "--no-resolve-image",
"service", "create", "--detach", "--no-resolve-image",
// name it $name
"--name", name,
// use a TTY
@ -297,7 +297,7 @@ func (s *DockerSwarmSuite) TestServiceLogsNoHangDeletedContainer(c *check.C) {
result := icmd.RunCmd(d.Command(
// create a service
"service", "create", "--no-resolve-image",
"service", "create", "--detach", "--no-resolve-image",
// name it $name
"--name", name,
// busybox image, shell string
@ -346,7 +346,7 @@ func (s *DockerSwarmSuite) TestServiceLogsDetails(c *check.C) {
result := icmd.RunCmd(d.Command(
// create a service
"service", "create", "--no-resolve-image",
"service", "create", "--detach", "--no-resolve-image",
// name it $name
"--name", name,
// add an environment variable

4
components/engine/integration-cli/docker_cli_service_scale_test.go
View File

@ -14,11 +14,11 @@ func (s *DockerSwarmSuite) TestServiceScale(c *check.C) {
d := s.AddDaemon(c, true, true)
service1Name := "TestService1"
service1Args := append([]string{"service", "create", "--no-resolve-image", "--name", service1Name, defaultSleepImage}, sleepCommandForDaemonPlatform()...)
service1Args := append([]string{"service", "create", "--detach", "--no-resolve-image", "--name", service1Name, defaultSleepImage}, sleepCommandForDaemonPlatform()...)
// global mode
service2Name := "TestService2"
service2Args := append([]string{"service", "create", "--no-resolve-image", "--name", service2Name, "--mode=global", defaultSleepImage}, sleepCommandForDaemonPlatform()...)
service2Args := append([]string{"service", "create", "--detach", "--no-resolve-image", "--name", service2Name, "--mode=global", defaultSleepImage}, sleepCommandForDaemonPlatform()...)
// Create services
out, err := d.Cmd(service1Args...)

28
components/engine/integration-cli/docker_cli_service_update_test.go
View File

@ -15,7 +15,7 @@ func (s *DockerSwarmSuite) TestServiceUpdatePort(c *check.C) {
d := s.AddDaemon(c, true, true)
serviceName := "TestServiceUpdatePort"
serviceArgs := append([]string{"service", "create", "--no-resolve-image", "--name", serviceName, "-p", "8080:8081", defaultSleepImage}, sleepCommandForDaemonPlatform()...)
serviceArgs := append([]string{"service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "-p", "8080:8081", defaultSleepImage}, sleepCommandForDaemonPlatform()...)
// Create a service with a port mapping of 8080:8081.
out, err := d.Cmd(serviceArgs...)
@ -23,7 +23,7 @@ func (s *DockerSwarmSuite) TestServiceUpdatePort(c *check.C) {
waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
// Update the service: changed the port mapping from 8080:8081 to 8082:8083.
_, err = d.Cmd("service", "update", "--publish-add", "8082:8083", "--publish-rm", "8081", serviceName)
_, err = d.Cmd("service", "update", "--detach", "--publish-add", "8082:8083", "--publish-rm", "8081", serviceName)
c.Assert(err, checker.IsNil)
// Inspect the service and verify port mapping
@ -48,39 +48,39 @@ func (s *DockerSwarmSuite) TestServiceUpdatePort(c *check.C) {
func (s *DockerSwarmSuite) TestServiceUpdateLabel(c *check.C) {
d := s.AddDaemon(c, true, true)
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name=test", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name=test", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
service := d.GetService(c, "test")
c.Assert(service.Spec.Labels, checker.HasLen, 0)
// add label to empty set
out, err = d.Cmd("service", "update", "test", "--label-add", "foo=bar")
out, err = d.Cmd("service", "update", "--detach", "test", "--label-add", "foo=bar")
c.Assert(err, checker.IsNil, check.Commentf(out))
service = d.GetService(c, "test")
c.Assert(service.Spec.Labels, checker.HasLen, 1)
c.Assert(service.Spec.Labels["foo"], checker.Equals, "bar")
// add label to non-empty set
out, err = d.Cmd("service", "update", "test", "--label-add", "foo2=bar")
out, err = d.Cmd("service", "update", "--detach", "test", "--label-add", "foo2=bar")
c.Assert(err, checker.IsNil, check.Commentf(out))
service = d.GetService(c, "test")
c.Assert(service.Spec.Labels, checker.HasLen, 2)
c.Assert(service.Spec.Labels["foo2"], checker.Equals, "bar")
out, err = d.Cmd("service", "update", "test", "--label-rm", "foo2")
out, err = d.Cmd("service", "update", "--detach", "test", "--label-rm", "foo2")
c.Assert(err, checker.IsNil, check.Commentf(out))
service = d.GetService(c, "test")
c.Assert(service.Spec.Labels, checker.HasLen, 1)
c.Assert(service.Spec.Labels["foo2"], checker.Equals, "")
out, err = d.Cmd("service", "update", "test", "--label-rm", "foo")
out, err = d.Cmd("service", "update", "--detach", "test", "--label-rm", "foo")
c.Assert(err, checker.IsNil, check.Commentf(out))
service = d.GetService(c, "test")
c.Assert(service.Spec.Labels, checker.HasLen, 0)
c.Assert(service.Spec.Labels["foo"], checker.Equals, "")
// now make sure we can add again
out, err = d.Cmd("service", "update", "test", "--label-add", "foo=bar")
out, err = d.Cmd("service", "update", "--detach", "test", "--label-add", "foo=bar")
c.Assert(err, checker.IsNil, check.Commentf(out))
service = d.GetService(c, "test")
c.Assert(service.Spec.Labels, checker.HasLen, 1)
@ -100,11 +100,11 @@ func (s *DockerSwarmSuite) TestServiceUpdateSecrets(c *check.C) {
testTarget := "testing"
serviceName := "test"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", serviceName, "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
// add secret
out, err = d.CmdRetryOutOfSequence("service", "update", "test", "--secret-add", fmt.Sprintf("source=%s,target=%s", testName, testTarget))
out, err = d.CmdRetryOutOfSequence("service", "update", "--detach", "test", "--secret-add", fmt.Sprintf("source=%s,target=%s", testName, testTarget))
c.Assert(err, checker.IsNil, check.Commentf(out))
out, err = d.Cmd("service", "inspect", "--format", "{{ json .Spec.TaskTemplate.ContainerSpec.Secrets }}", serviceName)
@ -119,7 +119,7 @@ func (s *DockerSwarmSuite) TestServiceUpdateSecrets(c *check.C) {
c.Assert(refs[0].File.Name, checker.Equals, testTarget)
// remove
out, err = d.CmdRetryOutOfSequence("service", "update", "test", "--secret-rm", testName)
out, err = d.CmdRetryOutOfSequence("service", "update", "--detach", "test", "--secret-rm", testName)
c.Assert(err, checker.IsNil, check.Commentf(out))
out, err = d.Cmd("service", "inspect", "--format", "{{ json .Spec.TaskTemplate.ContainerSpec.Secrets }}", serviceName)
@ -142,11 +142,11 @@ func (s *DockerSwarmSuite) TestServiceUpdateConfigs(c *check.C) {
testTarget := "/testing"
serviceName := "test"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", serviceName, "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
// add config
out, err = d.CmdRetryOutOfSequence("service", "update", "test", "--config-add", fmt.Sprintf("source=%s,target=%s", testName, testTarget))
out, err = d.CmdRetryOutOfSequence("service", "update", "--detach", "test", "--config-add", fmt.Sprintf("source=%s,target=%s", testName, testTarget))
c.Assert(err, checker.IsNil, check.Commentf(out))
out, err = d.Cmd("service", "inspect", "--format", "{{ json .Spec.TaskTemplate.ContainerSpec.Configs }}", serviceName)
@ -161,7 +161,7 @@ func (s *DockerSwarmSuite) TestServiceUpdateConfigs(c *check.C) {
c.Assert(refs[0].File.Name, checker.Equals, testTarget)
// remove
out, err = d.CmdRetryOutOfSequence("service", "update", "test", "--config-rm", testName)
out, err = d.CmdRetryOutOfSequence("service", "update", "--detach", "test", "--config-rm", testName)
c.Assert(err, checker.IsNil, check.Commentf(out))
out, err = d.Cmd("service", "inspect", "--format", "{{ json .Spec.TaskTemplate.ContainerSpec.Configs }}", serviceName)

84
components/engine/integration-cli/docker_cli_swarm_test.go
View File

@ -172,7 +172,7 @@ func (s *DockerSwarmSuite) TestSwarmServiceTemplatingHostname(c *check.C) {
hostname, err := d.Cmd("node", "inspect", "--format", "{{.Description.Hostname}}", "self")
c.Assert(err, checker.IsNil, check.Commentf(hostname))
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", "test", "--hostname", "{{.Service.Name}}-{{.Task.Slot}}-{{.Node.Hostname}}", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", "test", "--hostname", "{{.Service.Name}}-{{.Task.Slot}}-{{.Node.Hostname}}", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
// make sure task has been deployed.
@ -191,15 +191,15 @@ func (s *DockerSwarmSuite) TestSwarmServiceListFilter(c *check.C) {
name1 := "redis-cluster-md5"
name2 := "redis-cluster"
name3 := "other-cluster"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name1, "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name1, "busybox", "top")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
out, err = d.Cmd("service", "create", "--no-resolve-image", "--name", name2, "busybox", "top")
out, err = d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name2, "busybox", "top")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
out, err = d.Cmd("service", "create", "--no-resolve-image", "--name", name3, "busybox", "top")
out, err = d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name3, "busybox", "top")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
@ -249,7 +249,7 @@ func (s *DockerSwarmSuite) TestSwarmNodeTaskListFilter(c *check.C) {
d := s.AddDaemon(c, true, true)
name := "redis-cluster-md5"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "--replicas=3", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "--replicas=3", "busybox", "top")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
@ -276,17 +276,17 @@ func (s *DockerSwarmSuite) TestSwarmPublishAdd(c *check.C) {
d := s.AddDaemon(c, true, true)
name := "top"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "--label", "x=y", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "--label", "x=y", "busybox", "top")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
out, err = d.Cmd("service", "update", "--publish-add", "80:80", name)
out, err = d.Cmd("service", "update", "--detach", "--publish-add", "80:80", name)
c.Assert(err, checker.IsNil)
out, err = d.CmdRetryOutOfSequence("service", "update", "--publish-add", "80:80", name)
out, err = d.CmdRetryOutOfSequence("service", "update", "--detach", "--publish-add", "80:80", name)
c.Assert(err, checker.IsNil)
out, err = d.CmdRetryOutOfSequence("service", "update", "--publish-add", "80:80", "--publish-add", "80:20", name)
out, err = d.CmdRetryOutOfSequence("service", "update", "--detach", "--publish-add", "80:80", "--publish-add", "80:20", name)
c.Assert(err, checker.NotNil)
out, err = d.Cmd("service", "inspect", "--format", "{{ .Spec.EndpointSpec.Ports }}", name)
@ -298,7 +298,7 @@ func (s *DockerSwarmSuite) TestSwarmServiceWithGroup(c *check.C) {
d := s.AddDaemon(c, true, true)
name := "top"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "--user", "root:root", "--group", "wheel", "--group", "audio", "--group", "staff", "--group", "777", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "--user", "root:root", "--group", "wheel", "--group", "audio", "--group", "staff", "--group", "777", "busybox", "top")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
@ -487,7 +487,7 @@ func (s *DockerSwarmSuite) TestSwarmIngressNetwork(c *check.C) {
c.Assert(strings.TrimSpace(out), checker.Contains, "is already present")
// It cannot be removed if it is being used
out, err = d.Cmd("service", "create", "--no-resolve-image", "--name", "srv1", "-p", "9000:8000", "busybox", "top")
out, err = d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", "srv1", "-p", "9000:8000", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
result = removeNetwork("new-ingress")
@ -497,24 +497,24 @@ func (s *DockerSwarmSuite) TestSwarmIngressNetwork(c *check.C) {
})
// But it can be removed once no more services depend on it
out, err = d.Cmd("service", "update", "--publish-rm", "9000:8000", "srv1")
out, err = d.Cmd("service", "update", "--detach", "--publish-rm", "9000:8000", "srv1")
c.Assert(err, checker.IsNil, check.Commentf(out))
result = removeNetwork("new-ingress")
result.Assert(c, icmd.Success)
// A service which needs the ingress network cannot be created if no ingress is present
out, err = d.Cmd("service", "create", "--no-resolve-image", "--name", "srv2", "-p", "500:500", "busybox", "top")
out, err = d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", "srv2", "-p", "500:500", "busybox", "top")
c.Assert(err, checker.NotNil)
c.Assert(strings.TrimSpace(out), checker.Contains, "no ingress network is present")
// An existing service cannot be updated to use the ingress nw if the nw is not present
out, err = d.Cmd("service", "update", "--publish-add", "9000:8000", "srv1")
out, err = d.Cmd("service", "update", "--detach", "--publish-add", "9000:8000", "srv1")
c.Assert(err, checker.NotNil)
c.Assert(strings.TrimSpace(out), checker.Contains, "no ingress network is present")
// But services which do not need routing mesh can be created regardless
out, err = d.Cmd("service", "create", "--no-resolve-image", "--name", "srv3", "--endpoint-mode", "dnsrr", "busybox", "top")
out, err = d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", "srv3", "--endpoint-mode", "dnsrr", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
}
@ -531,7 +531,7 @@ func (s *DockerSwarmSuite) TestSwarmCreateServiceWithNoIngressNetwork(c *check.C
// Make sure nothing panics because ingress network is missing
out, err := d.Cmd("network", "create", "-d", "overlay", "another-network")
c.Assert(err, checker.IsNil, check.Commentf(out))
out, err = d.Cmd("service", "create", "--no-resolve-image", "--name", "srv4", "--network", "another-network", "busybox", "top")
out, err = d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", "srv4", "--network", "another-network", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
}
@ -541,7 +541,7 @@ func (s *DockerSwarmSuite) TestSwarmTaskListFilter(c *check.C) {
d := s.AddDaemon(c, true, true)
name := "redis-cluster-md5"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "--replicas=3", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "--replicas=3", "busybox", "top")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
@ -575,7 +575,7 @@ func (s *DockerSwarmSuite) TestSwarmTaskListFilter(c *check.C) {
c.Assert(out, checker.Not(checker.Contains), name+".3")
name = "redis-cluster-sha1"
out, err = d.Cmd("service", "create", "--no-resolve-image", "--name", name, "--mode=global", "busybox", "top")
out, err = d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "--mode=global", "busybox", "top")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
@ -604,7 +604,7 @@ func (s *DockerSwarmSuite) TestPsListContainersFilterIsTask(c *check.C) {
bareID := strings.TrimSpace(out)[:12]
// Create a service
name := "busybox-top"
out, err = d.Cmd("service", "create", "--no-resolve-image", "--name", name, "busybox", "top")
out, err = d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "busybox", "top")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
@ -823,7 +823,7 @@ func (s *DockerSwarmSuite) TestSwarmServiceEnvFile(c *check.C) {
c.Assert(err, checker.IsNil)
name := "worker"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--env-file", path, "--env", "VAR1=B", "--env", "VAR1=C", "--env", "VAR2=", "--env", "VAR2", "--name", name, "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--env-file", path, "--env", "VAR1=B", "--env", "VAR1=C", "--env", "VAR2=", "--env", "VAR2", "--name", name, "busybox", "top")
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
@ -842,7 +842,7 @@ func (s *DockerSwarmSuite) TestSwarmServiceTTY(c *check.C) {
// Without --tty
expectedOutput := "none"
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "busybox", "sh", "-c", ttyCheck)
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "busybox", "sh", "-c", ttyCheck)
c.Assert(err, checker.IsNil)
// Make sure task has been deployed.
@ -865,7 +865,7 @@ func (s *DockerSwarmSuite) TestSwarmServiceTTY(c *check.C) {
// With --tty
expectedOutput = "TTY"
out, err = d.Cmd("service", "create", "--no-resolve-image", "--name", name, "--tty", "busybox", "sh", "-c", ttyCheck)
out, err = d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "--tty", "busybox", "sh", "-c", ttyCheck)
c.Assert(err, checker.IsNil)
// Make sure task has been deployed.
@ -886,7 +886,7 @@ func (s *DockerSwarmSuite) TestSwarmServiceTTYUpdate(c *check.C) {
// Create a service
name := "top"
_, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "busybox", "top")
_, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "busybox", "top")
c.Assert(err, checker.IsNil)
// Make sure task has been deployed.
@ -896,7 +896,7 @@ func (s *DockerSwarmSuite) TestSwarmServiceTTYUpdate(c *check.C) {
c.Assert(err, checker.IsNil)
c.Assert(strings.TrimSpace(out), checker.Equals, "false")
_, err = d.Cmd("service", "update", "--tty", name)
_, err = d.Cmd("service", "update", "--detach", "--tty", name)
c.Assert(err, checker.IsNil)
out, err = d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.TTY }}", name)
@ -921,7 +921,7 @@ func (s *DockerSwarmSuite) TestSwarmServiceNetworkUpdate(c *check.C) {
// Create a service
name := "top"
result = icmd.RunCmd(d.Command("service", "create", "--no-resolve-image", "--network", "foo", "--network", "bar", "--name", name, "busybox", "top"))
result = icmd.RunCmd(d.Command("service", "create", "--detach", "--no-resolve-image", "--network", "foo", "--network", "bar", "--name", name, "busybox", "top"))
result.Assert(c, icmd.Success)
// Make sure task has been deployed.
@ -929,14 +929,14 @@ func (s *DockerSwarmSuite) TestSwarmServiceNetworkUpdate(c *check.C) {
map[string]int{fooNetwork: 1, barNetwork: 1})
// Remove a network
result = icmd.RunCmd(d.Command("service", "update", "--network-rm", "foo", name))
result = icmd.RunCmd(d.Command("service", "update", "--detach", "--network-rm", "foo", name))
result.Assert(c, icmd.Success)
waitAndAssert(c, defaultReconciliationTimeout, d.CheckRunningTaskNetworks, checker.DeepEquals,
map[string]int{barNetwork: 1})
// Add a network
result = icmd.RunCmd(d.Command("service", "update", "--network-add", "baz", name))
result = icmd.RunCmd(d.Command("service", "update", "--detach", "--network-add", "baz", name))
result.Assert(c, icmd.Success)
waitAndAssert(c, defaultReconciliationTimeout, d.CheckRunningTaskNetworks, checker.DeepEquals,
@ -948,7 +948,7 @@ func (s *DockerSwarmSuite) TestDNSConfig(c *check.C) {
// Create a service
name := "top"
_, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "--dns=1.2.3.4", "--dns-search=example.com", "--dns-option=timeout:3", "busybox", "top")
_, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "--dns=1.2.3.4", "--dns-search=example.com", "--dns-option=timeout:3", "busybox", "top")
c.Assert(err, checker.IsNil)
// Make sure task has been deployed.
@ -975,13 +975,13 @@ func (s *DockerSwarmSuite) TestDNSConfigUpdate(c *check.C) {
// Create a service
name := "top"
_, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "busybox", "top")
_, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "busybox", "top")
c.Assert(err, checker.IsNil)
// Make sure task has been deployed.
waitAndAssert(c, defaultReconciliationTimeout, d.CheckActiveContainerCount, checker.Equals, 1)
_, err = d.Cmd("service", "update", "--dns-add=1.2.3.4", "--dns-search-add=example.com", "--dns-option-add=timeout:3", name)
_, err = d.Cmd("service", "update", "--detach", "--dns-add=1.2.3.4", "--dns-search-add=example.com", "--dns-option-add=timeout:3", name)
c.Assert(err, checker.IsNil)
out, err := d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.DNSConfig }}", name)
@ -1497,7 +1497,7 @@ func (s *DockerSwarmSuite) TestExtraHosts(c *check.C) {
// Create a service
name := "top"
_, err := d.Cmd("service", "create", "--no-resolve-image", "--name", name, "--host=example.com:1.2.3.4", "busybox", "top")
_, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", name, "--host=example.com:1.2.3.4", "busybox", "top")
c.Assert(err, checker.IsNil)
// Make sure task has been deployed.
@ -1547,7 +1547,7 @@ func (s *DockerSwarmSuite) TestSwarmNetworkIPAMOptions(c *check.C) {
c.Assert(err, checker.IsNil, check.Commentf(out))
c.Assert(strings.TrimSpace(out), checker.Equals, "map[foo:bar]")
out, err = d.Cmd("service", "create", "--no-resolve-image", "--network=foo", "--name", "top", "busybox", "top")
out, err = d.Cmd("service", "create", "--detach", "--no-resolve-image", "--network=foo", "--name", "top", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
// make sure task has been deployed.
@ -1565,7 +1565,7 @@ func (s *DockerTrustedSwarmSuite) TestTrustedServiceCreate(c *check.C) {
repoName := s.trustSuite.setupTrustedImage(c, "trusted-pull")
name := "trusted"
cli.Docker(cli.Args("-D", "service", "create", "--no-resolve-image", "--name", name, repoName, "top"), trustedCmd, cli.Daemon(d.Daemon)).Assert(c, icmd.Expected{
cli.Docker(cli.Args("-D", "service", "create", "--detach", "--no-resolve-image", "--name", name, repoName, "top"), trustedCmd, cli.Daemon(d.Daemon)).Assert(c, icmd.Expected{
Err: "resolved image tag to",
})
@ -1582,7 +1582,7 @@ func (s *DockerTrustedSwarmSuite) TestTrustedServiceCreate(c *check.C) {
cli.DockerCmd(c, "rmi", repoName)
name = "untrusted"
cli.Docker(cli.Args("service", "create", "--no-resolve-image", "--name", name, repoName, "top"), trustedCmd, cli.Daemon(d.Daemon)).Assert(c, icmd.Expected{
cli.Docker(cli.Args("service", "create", "--detach", "--no-resolve-image", "--name", name, repoName, "top"), trustedCmd, cli.Daemon(d.Daemon)).Assert(c, icmd.Expected{
ExitCode: 1,
Err: "Error: remote trust data does not exist",
})
@ -1600,7 +1600,7 @@ func (s *DockerTrustedSwarmSuite) TestTrustedServiceUpdate(c *check.C) {
name := "myservice"
// Create a service without content trust
cli.Docker(cli.Args("service", "create", "--no-resolve-image", "--name", name, repoName, "top"), cli.Daemon(d.Daemon)).Assert(c, icmd.Success)
cli.Docker(cli.Args("service", "create", "--detach", "--no-resolve-image", "--name", name, repoName, "top"), cli.Daemon(d.Daemon)).Assert(c, icmd.Success)
result := cli.Docker(cli.Args("service", "inspect", "--pretty", name), cli.Daemon(d.Daemon))
c.Assert(result.Error, checker.IsNil, check.Commentf(result.Combined()))
@ -1608,7 +1608,7 @@ func (s *DockerTrustedSwarmSuite) TestTrustedServiceUpdate(c *check.C) {
// DOCKER_SERVICE_PREFER_OFFLINE_IMAGE.
c.Assert(result.Combined(), check.Not(checker.Contains), repoName+"@", check.Commentf(result.Combined()))
cli.Docker(cli.Args("-D", "service", "update", "--no-resolve-image", "--image", repoName, name), trustedCmd, cli.Daemon(d.Daemon)).Assert(c, icmd.Expected{
cli.Docker(cli.Args("-D", "service", "update", "--detach", "--no-resolve-image", "--image", repoName, name), trustedCmd, cli.Daemon(d.Daemon)).Assert(c, icmd.Expected{
Err: "resolved image tag to",
})
@ -1624,7 +1624,7 @@ func (s *DockerTrustedSwarmSuite) TestTrustedServiceUpdate(c *check.C) {
cli.DockerCmd(c, "push", repoName)
cli.DockerCmd(c, "rmi", repoName)
cli.Docker(cli.Args("service", "update", "--no-resolve-image", "--image", repoName, name), trustedCmd, cli.Daemon(d.Daemon)).Assert(c, icmd.Expected{
cli.Docker(cli.Args("service", "update", "--detach", "--no-resolve-image", "--image", repoName, name), trustedCmd, cli.Daemon(d.Daemon)).Assert(c, icmd.Expected{
ExitCode: 1,
Err: "Error: remote trust data does not exist",
})
@ -1740,7 +1740,7 @@ func (s *DockerSwarmSuite) TestSwarmReadonlyRootfs(c *check.C) {
d := s.AddDaemon(c, true, true)
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", "top", "--read-only", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", "top", "--read-only", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
// make sure task has been deployed.
@ -1827,7 +1827,7 @@ func (s *DockerSwarmSuite) TestSwarmStopSignal(c *check.C) {
d := s.AddDaemon(c, true, true)
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", "top", "--stop-signal=SIGHUP", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", "top", "--stop-signal=SIGHUP", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
// make sure task has been deployed.
@ -1842,7 +1842,7 @@ func (s *DockerSwarmSuite) TestSwarmStopSignal(c *check.C) {
c.Assert(err, checker.IsNil, check.Commentf(out))
c.Assert(strings.TrimSpace(out), checker.Equals, "SIGHUP")
out, err = d.Cmd("service", "update", "--stop-signal=SIGUSR1", "top")
out, err = d.Cmd("service", "update", "--detach", "--stop-signal=SIGUSR1", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
out, err = d.Cmd("service", "inspect", "--format", "{{ .Spec.TaskTemplate.ContainerSpec.StopSignal }}", "top")
@ -1853,11 +1853,11 @@ func (s *DockerSwarmSuite) TestSwarmStopSignal(c *check.C) {
func (s *DockerSwarmSuite) TestSwarmServiceLsFilterMode(c *check.C) {
d := s.AddDaemon(c, true, true)
out, err := d.Cmd("service", "create", "--no-resolve-image", "--name", "top1", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", "top1", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")
out, err = d.Cmd("service", "create", "--no-resolve-image", "--name", "top2", "--mode=global", "busybox", "top")
out, err = d.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", "top2", "--mode=global", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
c.Assert(strings.TrimSpace(out), checker.Not(checker.Equals), "")

6
components/engine/integration-cli/docker_cli_swarm_unix_test.go
View File

@ -15,7 +15,7 @@ import (
func (s *DockerSwarmSuite) TestSwarmVolumePlugin(c *check.C) {
d := s.AddDaemon(c, true, true)
out, err := d.Cmd("service", "create", "--no-resolve-image", "--mount", "type=volume,source=my-volume,destination=/foo,volume-driver=customvolumedriver", "--name", "top", "busybox", "top")
out, err := d.Cmd("service", "create", "--detach", "--no-resolve-image", "--mount", "type=volume,source=my-volume,destination=/foo,volume-driver=customvolumedriver", "--name", "top", "busybox", "top")
c.Assert(err, checker.IsNil, check.Commentf(out))
// Make sure task stays pending before plugin is available
@ -74,7 +74,7 @@ func (s *DockerSwarmSuite) TestSwarmNetworkPluginV2(c *check.C) {
// create a global service to ensure that both nodes will have an instance
serviceName := "my-service"
_, err = d1.Cmd("service", "create", "--no-resolve-image", "--name", serviceName, "--mode=global", "--network", networkName, "busybox", "top")
_, err = d1.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "--mode=global", "--network", networkName, "busybox", "top")
c.Assert(err, checker.IsNil)
// wait for tasks ready
@ -96,7 +96,7 @@ func (s *DockerSwarmSuite) TestSwarmNetworkPluginV2(c *check.C) {
image := "busybox:latest"
// create a new global service again.
_, err = d1.Cmd("service", "create", "--no-resolve-image", "--name", serviceName, "--mode=global", "--network", networkName, image, "top")
_, err = d1.Cmd("service", "create", "--detach", "--no-resolve-image", "--name", serviceName, "--mode=global", "--network", networkName, image, "top")
c.Assert(err, checker.IsNil)
waitAndAssert(c, defaultReconciliationTimeout, d1.CheckRunningTaskImages, checker.DeepEquals,

2
components/engine/vendor.conf
View File

@ -110,7 +110,7 @@ github.com/tonistiigi/fifo 1405643975692217d6720f8b54aeee1bf2cd5cf4
github.com/stevvooe/continuity cd7a8e21e2b6f84799f5dd4b65faf49c8d3ee02d
# cluster
github.com/docker/swarmkit bd7bafb8a61de1f5f23c8215ce7b9ecbcb30ff21
github.com/docker/swarmkit 941a01844b89c56aa61086fecb167ab3af1de22b
github.com/gogo/protobuf v0.4
github.com/cloudflare/cfssl 7fb22c8cba7ecaf98e4082d22d65800cf45e042a
github.com/google/certificate-transparency d90e65c3a07988180c5b1ece71791c0b6506826e

7
components/engine/vendor/github.com/docker/swarmkit/README.md generated vendored
View File

@ -153,6 +153,12 @@ $ swarmd -d /tmp/node-2 --hostname node-2 --join-addr 127.0.0.1:4242 --join-toke
$ swarmd -d /tmp/node-3 --hostname node-3 --join-addr 127.0.0.1:4242 --join-token <Worker Token>
```
If joining as a manager, also specify the listen-control-api.
```sh
$ swarmd -d /tmp/node-4 --hostname node-4 --join-addr 127.0.0.1:4242 --join-token <Manager Token> --listen-control-api /tmp/node-4/swarm.sock --listen-remote-api 127.0.0.1:4245
```
In a fourth terminal, use `swarmctl` to explore and control the cluster. Before
running `swarmctl`, set the `SWARM_SOCKET` environment variable to the path of the
manager socket that was specified in `--listen-control-api` when starting the
@ -168,6 +174,7 @@ ID Name Membership Status Availability Manager Sta
3x12fpoi36eujbdkgdnbvbi6r node-2 ACCEPTED READY ACTIVE
4spl3tyipofoa2iwqgabsdcve node-1 ACCEPTED READY ACTIVE REACHABLE *
dknwk1uqxhnyyujq66ho0h54t node-3 ACCEPTED READY ACTIVE
zw3rwfawdasdewfq66ho34eaw node-4 ACCEPTED READY ACTIVE REACHABLE
```

228
components/engine/vendor/github.com/docker/swarmkit/api/objects.pb.go generated vendored
View File

@ -72,10 +72,10 @@ type Node struct {
// shows the privilege level that the CA would currently grant when
// issuing or renewing the node's certificate.
Role NodeRole `protobuf:"varint,9,opt,name=role,proto3,enum=docker.swarmkit.v1.NodeRole" json:"role,omitempty"`
// Each node uses the network attachment to set up an endpoint on the
// node to be used for load balancing. Each overlay network, including
// ingress network, will have an NetworkAttachment.
LbAttachments []*NetworkAttachment `protobuf:"bytes,10,rep,name=lb_attachments,json=lbAttachments" json:"lb_attachments,omitempty"`
// Attachments enumerates the network attachments for the node to set up an
// endpoint on the node to be used for load balancing. Each overlay
// network, including ingress network, will have an NetworkAttachment.
Attachments []*NetworkAttachment `protobuf:"bytes,10,rep,name=attachments" json:"attachments,omitempty"`
}
func (m *Node) Reset() { *m = Node{} }
@ -408,11 +408,11 @@ func (m *Node) CopyFrom(src interface{}) {
github_com_docker_swarmkit_api_deepcopy.Copy(m.Attachment, o.Attachment)
}
github_com_docker_swarmkit_api_deepcopy.Copy(&m.Certificate, &o.Certificate)
if o.LbAttachments != nil {
m.LbAttachments = make([]*NetworkAttachment, len(o.LbAttachments))
for i := range m.LbAttachments {
m.LbAttachments[i] = &NetworkAttachment{}
github_com_docker_swarmkit_api_deepcopy.Copy(m.LbAttachments[i], o.LbAttachments[i])
if o.Attachments != nil {
m.Attachments = make([]*NetworkAttachment, len(o.Attachments))
for i := range m.Attachments {
m.Attachments[i] = &NetworkAttachment{}
github_com_docker_swarmkit_api_deepcopy.Copy(m.Attachments[i], o.Attachments[i])
}
}
@ -862,8 +862,8 @@ func (m *Node) MarshalTo(dAtA []byte) (int, error) {
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Role))
}
if len(m.LbAttachments) > 0 {
for _, msg := range m.LbAttachments {
if len(m.Attachments) > 0 {
for _, msg := range m.Attachments {
dAtA[i] = 0x52
i++
i = encodeVarintObjects(dAtA, i, uint64(msg.Size()))
@ -1695,8 +1695,8 @@ func (m *Node) Size() (n int) {
if m.Role != 0 {
n += 1 + sovObjects(uint64(m.Role))
}
if len(m.LbAttachments) > 0 {
for _, e := range m.LbAttachments {
if len(m.Attachments) > 0 {
for _, e := range m.Attachments {
l = e.Size()
n += 1 + l + sovObjects(uint64(l))
}
@ -4414,7 +4414,7 @@ func (this *Node) String() string {
`Attachment:` + strings.Replace(fmt.Sprintf("%v", this.Attachment), "NetworkAttachment", "NetworkAttachment", 1) + `,`,
`Certificate:` + strings.Replace(strings.Replace(this.Certificate.String(), "Certificate", "Certificate", 1), `&`, ``, 1) + `,`,
`Role:` + fmt.Sprintf("%v", this.Role) + `,`,
`LbAttachments:` + strings.Replace(fmt.Sprintf("%v", this.LbAttachments), "NetworkAttachment", "NetworkAttachment", 1) + `,`,
`Attachments:` + strings.Replace(fmt.Sprintf("%v", this.Attachments), "NetworkAttachment", "NetworkAttachment", 1) + `,`,
`}`,
}, "")
return s
@ -5051,7 +5051,7 @@ func (m *Node) Unmarshal(dAtA []byte) error {
}
case 10:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field LbAttachments", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Attachments", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@ -5075,8 +5075,8 @@ func (m *Node) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.LbAttachments = append(m.LbAttachments, &NetworkAttachment{})
if err := m.LbAttachments[len(m.LbAttachments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
m.Attachments = append(m.Attachments, &NetworkAttachment{})
if err := m.Attachments[len(m.Attachments)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@ -7752,101 +7752,101 @@ var (
func init() { proto.RegisterFile("github.com/docker/swarmkit/api/objects.proto", fileDescriptorObjects) }
var fileDescriptorObjects = []byte{
// 1536 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x72, 0x1b, 0x4b,
0x15, 0xce, 0x48, 0x63, 0xfd, 0x1c, 0xd9, 0xc2, 0xf4, 0x35, 0x66, 0x22, 0x8c, 0x64, 0x74, 0x0b,
0xea, 0xd6, 0xad, 0x94, 0x1c, 0x4c, 0x00, 0xc7, 0x10, 0x12, 0xc9, 0x76, 0x25, 0xaa, 0x24, 0xc4,
0xd5, 0x09, 0x09, 0xbb, 0xa1, 0x35, 0xd3, 0x51, 0x06, 0x8d, 0xa6, 0xa7, 0xa6, 0x5b, 0x0a, 0xda,
0xb1, 0x61, 0x63, 0x1e, 0xc0, 0x3b, 0x16, 0x79, 0x06, 0x36, 0x6c, 0x58, 0xb0, 0xca, 0x92, 0x15,
0xc5, 0xca, 0x45, 0xf4, 0x16, 0x54, 0xb1, 0xa0, 0xba, 0xa7, 0x47, 0x1a, 0x5b, 0xe3, 0x3f, 0x2a,
0xe5, 0x62, 0xe5, 0xee, 0xe9, 0xef, 0x3b, 0x7f, 0x7d, 0xce, 0xe9, 0x63, 0xc1, 0x9d, 0xbe, 0x27,
0xde, 0x8d, 0x7a, 0x2d, 0x87, 0x0d, 0xb7, 0x5c, 0xe6, 0x0c, 0x68, 0xb4, 0xc5, 0xdf, 0x93, 0x68,
0x38, 0xf0, 0xc4, 0x16, 0x09, 0xbd, 0x2d, 0xd6, 0xfb, 0x2d, 0x75, 0x04, 0x6f, 0x85, 0x11, 0x13,
0x0c, 0xa1, 0x18, 0xd2, 0x4a, 0x20, 0xad, 0xf1, 0x0f, 0x6b, 0x5f, 0x5f, 0x22, 0x41, 0x4c, 0x42,
0xaa, 0xf9, 0x97, 0x62, 0x79, 0x48, 0x9d, 0x04, 0xdb, 0xe8, 0x33, 0xd6, 0xf7, 0xe9, 0x96, 0xda,
0xf5, 0x46, 0x6f, 0xb7, 0x84, 0x37, 0xa4, 0x5c, 0x90, 0x61, 0xa8, 0x01, 0x6b, 0x7d, 0xd6, 0x67,
0x6a, 0xb9, 0x25, 0x57, 0xfa, 0xeb, 0xed, 0xb3, 0x34, 0x12, 0x4c, 0xf4, 0xd1, 0x4f, 0x2f, 0xd0,
0x3e, 0x83, 0x87, 0xfe, 0xa8, 0xef, 0x05, 0xfa, 0x4f, 0x4c, 0x6c, 0xfe, 0xc5, 0x00, 0xf3, 0x39,
0x15, 0x04, 0xfd, 0x0c, 0x8a, 0x63, 0x1a, 0x71, 0x8f, 0x05, 0x96, 0xb1, 0x69, 0x7c, 0x55, 0xd9,
0xfe, 0x4e, 0x6b, 0x31, 0x22, 0xad, 0xd7, 0x31, 0xa4, 0x63, 0x7e, 0x3c, 0x69, 0xdc, 0xc2, 0x09,
0x03, 0xdd, 0x07, 0x70, 0x22, 0x4a, 0x04, 0x75, 0x6d, 0x22, 0xac, 0x9c, 0xe2, 0xd7, 0x5a, 0xb1,
0xb9, 0xad, 0x44, 0x7f, 0xeb, 0x55, 0xe2, 0x25, 0x2e, 0x6b, 0x74, 0x5b, 0x48, 0xea, 0x28, 0x74,
0x13, 0x6a, 0xfe, 0x72, 0xaa, 0x46, 0xb7, 0x45, 0xf3, 0x0f, 0x4b, 0x60, 0xfe, 0x92, 0xb9, 0x14,
0xad, 0x43, 0xce, 0x73, 0x95, 0xd9, 0xe5, 0x4e, 0x61, 0x7a, 0xd2, 0xc8, 0x75, 0xf7, 0x71, 0xce,
0x73, 0xd1, 0x36, 0x98, 0x43, 0x2a, 0x88, 0x36, 0xc8, 0xca, 0x72, 0x48, 0xfa, 0xae, 0xbd, 0x51,
0x58, 0xf4, 0x13, 0x30, 0xe5, 0x55, 0x69, 0x4b, 0x36, 0xb2, 0x38, 0x52, 0xe7, 0xcb, 0x90, 0x3a,
0x09, 0x4f, 0xe2, 0xd1, 0x01, 0x54, 0x5c, 0xca, 0x9d, 0xc8, 0x0b, 0x85, 0x8c, 0xa1, 0xa9, 0xe8,
0x5f, 0x9e, 0x47, 0xdf, 0x9f, 0x43, 0x71, 0x9a, 0x87, 0x7e, 0x0e, 0x05, 0x2e, 0x88, 0x18, 0x71,
0x6b, 0x49, 0x49, 0xa8, 0x9f, 0x6b, 0x80, 0x42, 0x69, 0x13, 0x34, 0x07, 0x3d, 0x81, 0xea, 0x90,
0x04, 0xa4, 0x4f, 0x23, 0x5b, 0x4b, 0x29, 0x28, 0x29, 0xdf, 0xcb, 0x74, 0x3d, 0x46, 0xc6, 0x82,
0xf0, 0xca, 0x30, 0xbd, 0x45, 0x5d, 0x00, 0x22, 0x04, 0x71, 0xde, 0x0d, 0x69, 0x20, 0xac, 0xa2,
0x92, 0xf2, 0xfd, 0x4c, 0x5b, 0xa8, 0x78, 0xcf, 0xa2, 0x41, 0x7b, 0x06, 0xee, 0xe4, 0x2c, 0x03,
0xa7, 0xc8, 0xe8, 0x31, 0x54, 0x1c, 0x1a, 0x09, 0xef, 0xad, 0xe7, 0x10, 0x41, 0xad, 0x92, 0x92,
0xd5, 0xc8, 0x92, 0xb5, 0x37, 0x87, 0x69, 0xc7, 0xd2, 0x4c, 0x74, 0x17, 0xcc, 0x88, 0xf9, 0xd4,
0x2a, 0x6f, 0x1a, 0x5f, 0x55, 0xcf, 0xbf, 0x1a, 0xcc, 0x7c, 0x8a, 0x15, 0x12, 0x3d, 0x83, 0xaa,
0xdf, 0xb3, 0xe7, 0xb6, 0x70, 0x0b, 0x36, 0xf3, 0x57, 0xf6, 0x04, 0xaf, 0xf8, 0xbd, 0xf9, 0x8e,
0xef, 0xae, 0x1f, 0x1d, 0x37, 0x11, 0xac, 0x96, 0x8c, 0x55, 0x43, 0x25, 0x9b, 0x71, 0xd7, 0xf8,
0xb5, 0xf1, 0x1b, 0xa3, 0xf9, 0x9f, 0x3c, 0x14, 0x5f, 0xd2, 0x68, 0xec, 0x39, 0x9f, 0x37, 0x15,
0xef, 0x9f, 0x4a, 0xc5, 0xcc, 0x88, 0x69, 0xb5, 0x0b, 0xd9, 0xb8, 0x03, 0x25, 0x1a, 0xb8, 0x21,
0xf3, 0x02, 0xa1, 0x53, 0x31, 0x33, 0x5c, 0x07, 0x1a, 0x83, 0x67, 0x68, 0x74, 0x00, 0x2b, 0x71,
0x85, 0xd9, 0xa7, 0xf2, 0x70, 0x33, 0x8b, 0xfe, 0x2b, 0x05, 0xd4, 0x09, 0xb4, 0x3c, 0x4a, 0xed,
0xd0, 0x3e, 0xac, 0x84, 0x11, 0x1d, 0x7b, 0x6c, 0xc4, 0x6d, 0xe5, 0x44, 0xe1, 0x4a, 0x4e, 0xe0,
0xe5, 0x84, 0x25, 0x77, 0xe8, 0x17, 0xb0, 0x2c, 0xc9, 0x76, 0xd2, 0x99, 0xe0, 0xd2, 0xce, 0x84,
0x2b, 0x92, 0xa0, 0x37, 0xe8, 0x05, 0x7c, 0xeb, 0x94, 0x15, 0x33, 0x41, 0x95, 0xcb, 0x05, 0x7d,
0x91, 0xb6, 0x44, 0x7f, 0xdc, 0x45, 0x47, 0xc7, 0xcd, 0x2a, 0x2c, 0xa7, 0x53, 0xa0, 0xf9, 0xa7,
0x1c, 0x94, 0x92, 0x40, 0xa2, 0x7b, 0xfa, 0xce, 0x8c, 0xf3, 0xa3, 0x96, 0x60, 0x95, 0xbf, 0xf1,
0x75, 0xdd, 0x83, 0xa5, 0x90, 0x45, 0x82, 0x5b, 0x39, 0x95, 0x9e, 0x99, 0x45, 0x7f, 0xc8, 0x22,
0xb1, 0xc7, 0x82, 0xb7, 0x5e, 0x1f, 0xc7, 0x60, 0xf4, 0x06, 0x2a, 0x63, 0x2f, 0x12, 0x23, 0xe2,
0xdb, 0x5e, 0xc8, 0xad, 0xbc, 0xe2, 0xfe, 0xe0, 0x22, 0x95, 0xad, 0xd7, 0x31, 0xbe, 0x7b, 0xd8,
0xa9, 0x4e, 0x4f, 0x1a, 0x30, 0xdb, 0x72, 0x0c, 0x5a, 0x54, 0x37, 0xe4, 0xb5, 0xe7, 0x50, 0x9e,
0x9d, 0xa0, 0x3b, 0x00, 0x41, 0x5c, 0x19, 0xf6, 0x2c, 0xb3, 0x57, 0xa6, 0x27, 0x8d, 0xb2, 0xae,
0x97, 0xee, 0x3e, 0x2e, 0x6b, 0x40, 0xd7, 0x45, 0x08, 0x4c, 0xe2, 0xba, 0x91, 0xca, 0xf3, 0x32,
0x56, 0xeb, 0xe6, 0x1f, 0x8b, 0x60, 0xbe, 0x22, 0x7c, 0x70, 0xd3, 0x7d, 0x5a, 0xea, 0x5c, 0xa8,
0x8c, 0x3b, 0x00, 0x3c, 0xce, 0x37, 0xe9, 0x8e, 0x39, 0x77, 0x47, 0x67, 0xa1, 0x74, 0x47, 0x03,
0x62, 0x77, 0xb8, 0xcf, 0x84, 0x2a, 0x02, 0x13, 0xab, 0x35, 0xfa, 0x12, 0x8a, 0x01, 0x73, 0x15,
0xbd, 0xa0, 0xe8, 0x30, 0x3d, 0x69, 0x14, 0x64, 0xe7, 0xe9, 0xee, 0xe3, 0x82, 0x3c, 0xea, 0xba,
0xb2, 0xe9, 0x91, 0x20, 0x60, 0x82, 0xc8, 0xae, 0xce, 0x75, 0x03, 0xcd, 0xcc, 0xfe, 0xf6, 0x1c,
0x96, 0x34, 0xbd, 0x14, 0x13, 0xbd, 0x86, 0x2f, 0x12, 0x7b, 0xd3, 0x02, 0x4b, 0xd7, 0x11, 0x88,
0xb4, 0x84, 0xd4, 0x49, 0xea, 0xa1, 0x29, 0x9f, 0xff, 0xd0, 0xa8, 0x08, 0x66, 0x3d, 0x34, 0x1d,
0x58, 0x71, 0x29, 0xf7, 0x22, 0xea, 0xaa, 0x36, 0x41, 0x55, 0x65, 0x56, 0xb7, 0xbf, 0x7b, 0x91,
0x10, 0x8a, 0x97, 0x35, 0x47, 0xed, 0x50, 0x1b, 0x4a, 0x3a, 0x6f, 0xb8, 0x55, 0xb9, 0x4e, 0x5b,
0x9e, 0xd1, 0x4e, 0xb5, 0xb9, 0xe5, 0x6b, 0xb5, 0xb9, 0xfb, 0x00, 0x3e, 0xeb, 0xdb, 0x6e, 0xe4,
0x8d, 0x69, 0x64, 0xad, 0xe8, 0xb1, 0x23, 0x83, 0xbb, 0xaf, 0x10, 0xb8, 0xec, 0xb3, 0x7e, 0xbc,
0x5c, 0x68, 0x4a, 0xd5, 0x6b, 0x36, 0x25, 0x02, 0x35, 0xc2, 0xb9, 0xd7, 0x0f, 0xa8, 0x6b, 0xf7,
0x69, 0x40, 0x23, 0xcf, 0xb1, 0x23, 0xca, 0xd9, 0x28, 0x72, 0x28, 0xb7, 0xbe, 0xa1, 0x22, 0x91,
0x39, 0x38, 0x3c, 0x8e, 0xc1, 0x58, 0x63, 0xb1, 0x95, 0x88, 0x39, 0x73, 0xc0, 0x77, 0x6b, 0x47,
0xc7, 0xcd, 0x75, 0x58, 0x4b, 0xb7, 0xa9, 0x1d, 0xe3, 0x91, 0xf1, 0xc4, 0x38, 0x34, 0x9a, 0x7f,
0xcb, 0xc1, 0x37, 0x17, 0x62, 0x8a, 0x7e, 0x0c, 0x45, 0x1d, 0xd5, 0x8b, 0xc6, 0x3f, 0xcd, 0xc3,
0x09, 0x16, 0x6d, 0x40, 0x59, 0x96, 0x38, 0xe5, 0x9c, 0xc6, 0xcd, 0xab, 0x8c, 0xe7, 0x1f, 0x90,
0x05, 0x45, 0xe2, 0x7b, 0x44, 0x9e, 0xe5, 0xd5, 0x59, 0xb2, 0x45, 0x23, 0x58, 0x8f, 0x43, 0x9f,
0x7a, 0x9c, 0x6d, 0x16, 0x0a, 0x6e, 0x99, 0xca, 0xff, 0x87, 0x57, 0xca, 0x04, 0x7d, 0x39, 0xf3,
0x0f, 0x2f, 0x42, 0xc1, 0x0f, 0x02, 0x11, 0x4d, 0xf0, 0x9a, 0x9b, 0x71, 0x54, 0x7b, 0x0c, 0xb7,
0xcf, 0xa5, 0xa0, 0x55, 0xc8, 0x0f, 0xe8, 0x24, 0x6e, 0x4f, 0x58, 0x2e, 0xd1, 0x1a, 0x2c, 0x8d,
0x89, 0x3f, 0xa2, 0xba, 0x9b, 0xc5, 0x9b, 0xdd, 0xdc, 0x8e, 0xd1, 0xfc, 0x90, 0x83, 0xa2, 0x36,
0xe7, 0xa6, 0x9f, 0x7c, 0xad, 0x76, 0xa1, 0xb1, 0x3d, 0x80, 0x65, 0x1d, 0xd2, 0xb8, 0x22, 0xcd,
0x4b, 0x73, 0xba, 0x12, 0xe3, 0xe3, 0x6a, 0x7c, 0x00, 0xa6, 0x17, 0x92, 0xa1, 0x7e, 0xee, 0x33,
0x35, 0x77, 0x0f, 0xdb, 0xcf, 0x5f, 0x84, 0x71, 0x63, 0x29, 0x4d, 0x4f, 0x1a, 0xa6, 0xfc, 0x80,
0x15, 0x2d, 0xf3, 0x61, 0xfc, 0xf3, 0x12, 0x14, 0xf7, 0xfc, 0x11, 0x17, 0x34, 0xba, 0xe9, 0x20,
0x69, 0xb5, 0x0b, 0x41, 0xda, 0x83, 0x62, 0xc4, 0x98, 0xb0, 0x1d, 0x72, 0x51, 0x7c, 0x30, 0x63,
0x62, 0xaf, 0xdd, 0xa9, 0x4a, 0xa2, 0xec, 0xed, 0xf1, 0x1e, 0x17, 0x24, 0x75, 0x8f, 0xa0, 0x37,
0xb0, 0x9e, 0xbc, 0x88, 0x3d, 0xc6, 0x04, 0x17, 0x11, 0x09, 0xed, 0x01, 0x9d, 0xc8, 0x59, 0x29,
0x7f, 0xde, 0xb4, 0x7d, 0x10, 0x38, 0xd1, 0x44, 0x05, 0xef, 0x29, 0x9d, 0xe0, 0x35, 0x2d, 0xa0,
0x93, 0xf0, 0x9f, 0xd2, 0x09, 0x47, 0x0f, 0x61, 0x83, 0xce, 0x60, 0x52, 0xa2, 0xed, 0x93, 0xa1,
0x7c, 0xeb, 0x6d, 0xc7, 0x67, 0xce, 0x40, 0x3d, 0x37, 0x26, 0xbe, 0x4d, 0xd3, 0xa2, 0x9e, 0xc5,
0x88, 0x3d, 0x09, 0x40, 0x1c, 0xac, 0x9e, 0x4f, 0x9c, 0x81, 0xef, 0x71, 0xf9, 0x0f, 0x55, 0x6a,
0x78, 0x96, 0x2f, 0x86, 0xb4, 0x6d, 0xe7, 0x82, 0x68, 0xb5, 0x3a, 0x73, 0x6e, 0x6a, 0x14, 0xd7,
0x15, 0xf5, 0xed, 0x5e, 0xf6, 0x29, 0xea, 0x40, 0x65, 0x14, 0x48, 0xf5, 0x71, 0x0c, 0xca, 0x57,
0x8d, 0x01, 0xc4, 0x2c, 0xe9, 0x79, 0x6d, 0x0c, 0x1b, 0x17, 0x29, 0xcf, 0xa8, 0xcd, 0x47, 0xe9,
0xda, 0xac, 0x6c, 0x7f, 0x9d, 0xa5, 0x2f, 0x5b, 0x64, 0xaa, 0x8e, 0x33, 0xd3, 0xf6, 0xaf, 0x06,
0x14, 0x5e, 0x52, 0x27, 0xa2, 0xe2, 0xb3, 0x66, 0xed, 0xce, 0xa9, 0xac, 0xad, 0x67, 0x0f, 0xc2,
0x52, 0xeb, 0x42, 0xd2, 0xd6, 0xa0, 0xe4, 0x05, 0x82, 0x46, 0x01, 0xf1, 0x55, 0xd6, 0x96, 0xf0,
0x6c, 0x9f, 0xe9, 0xc0, 0x07, 0x03, 0x0a, 0xf1, 0xa4, 0x78, 0xd3, 0x0e, 0xc4, 0x5a, 0xcf, 0x3a,
0x90, 0x69, 0xe4, 0xbf, 0x0d, 0x28, 0x25, 0x0f, 0xd6, 0x67, 0x35, 0xf3, 0xcc, 0xe4, 0x95, 0xff,
0x9f, 0x27, 0x2f, 0x04, 0xe6, 0xc0, 0x0b, 0xf4, 0x8c, 0x88, 0xd5, 0x1a, 0xb5, 0xa0, 0x18, 0x92,
0x89, 0xcf, 0x88, 0xab, 0x1b, 0xe5, 0xda, 0xc2, 0x4f, 0x15, 0xed, 0x60, 0x82, 0x13, 0xd0, 0xee,
0xda, 0xd1, 0x71, 0x73, 0x15, 0xaa, 0x69, 0xcf, 0xdf, 0x19, 0xcd, 0x7f, 0x18, 0x50, 0x3e, 0xf8,
0x9d, 0xa0, 0x81, 0x9a, 0x07, 0xfe, 0x2f, 0x9d, 0xdf, 0x5c, 0xfc, 0x39, 0xa3, 0x7c, 0xea, 0x97,
0x8a, 0xac, 0x4b, 0xed, 0x58, 0x1f, 0x3f, 0xd5, 0x6f, 0xfd, 0xf3, 0x53, 0xfd, 0xd6, 0xef, 0xa7,
0x75, 0xe3, 0xe3, 0xb4, 0x6e, 0xfc, 0x7d, 0x5a, 0x37, 0xfe, 0x35, 0xad, 0x1b, 0xbd, 0x82, 0x8a,
0xcf, 0x8f, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xbd, 0x5c, 0xf5, 0x06, 0x95, 0x13, 0x00, 0x00,
// 1527 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcf, 0x6f, 0x1b, 0x4f,
0x15, 0xef, 0xda, 0x1b, 0xff, 0x78, 0x4e, 0x4c, 0x98, 0x86, 0xb0, 0x35, 0xc1, 0x0e, 0xae, 0x40,
0x55, 0x55, 0x39, 0x25, 0x14, 0x48, 0x03, 0xa5, 0xb5, 0x93, 0xa8, 0xb5, 0x4a, 0x69, 0x34, 0x2d,
0x2d, 0xb7, 0x65, 0xb2, 0x3b, 0x75, 0x17, 0xaf, 0x77, 0x56, 0x3b, 0x63, 0x17, 0xdf, 0x7a, 0x0e,
0x7f, 0x40, 0x6e, 0x1c, 0xfa, 0x37, 0x70, 0xe1, 0xc2, 0x81, 0x53, 0x8f, 0x9c, 0x10, 0xa7, 0x88,
0xfa, 0xbf, 0x40, 0xe2, 0x80, 0x66, 0x76, 0xd6, 0xde, 0xc4, 0x9b, 0x5f, 0xa8, 0x8a, 0xbe, 0xa7,
0xcc, 0xec, 0x7c, 0x3e, 0xef, 0xd7, 0xbc, 0xf7, 0xe6, 0xc5, 0x70, 0xaf, 0xe7, 0x89, 0xf7, 0xc3,
0x83, 0x96, 0xc3, 0x06, 0x1b, 0x2e, 0x73, 0xfa, 0x34, 0xda, 0xe0, 0x1f, 0x48, 0x34, 0xe8, 0x7b,
0x62, 0x83, 0x84, 0xde, 0x06, 0x3b, 0xf8, 0x03, 0x75, 0x04, 0x6f, 0x85, 0x11, 0x13, 0x0c, 0xa1,
0x18, 0xd2, 0x4a, 0x20, 0xad, 0xd1, 0x8f, 0x6b, 0x77, 0x2f, 0x90, 0x20, 0xc6, 0x21, 0xd5, 0xfc,
0x0b, 0xb1, 0x3c, 0xa4, 0x4e, 0x82, 0x6d, 0xf4, 0x18, 0xeb, 0xf9, 0x74, 0x43, 0xed, 0x0e, 0x86,
0xef, 0x36, 0x84, 0x37, 0xa0, 0x5c, 0x90, 0x41, 0xa8, 0x01, 0x2b, 0x3d, 0xd6, 0x63, 0x6a, 0xb9,
0x21, 0x57, 0xfa, 0xeb, 0xad, 0xd3, 0x34, 0x12, 0x8c, 0xf5, 0xd1, 0xcf, 0xcf, 0xd1, 0x3e, 0x85,
0x87, 0xfe, 0xb0, 0xe7, 0x05, 0xfa, 0x4f, 0x4c, 0x6c, 0xfe, 0xd5, 0x00, 0xf3, 0x05, 0x15, 0x04,
0xfd, 0x02, 0x8a, 0x23, 0x1a, 0x71, 0x8f, 0x05, 0x96, 0xb1, 0x6e, 0xdc, 0xa9, 0x6c, 0x7e, 0xaf,
0x35, 0x1f, 0x91, 0xd6, 0x9b, 0x18, 0xd2, 0x31, 0x3f, 0x1f, 0x37, 0x6e, 0xe0, 0x84, 0x81, 0x1e,
0x02, 0x38, 0x11, 0x25, 0x82, 0xba, 0x36, 0x11, 0x56, 0x4e, 0xf1, 0x6b, 0xad, 0xd8, 0xdc, 0x56,
0xa2, 0xbf, 0xf5, 0x3a, 0xf1, 0x12, 0x97, 0x35, 0xba, 0x2d, 0x24, 0x75, 0x18, 0xba, 0x09, 0x35,
0x7f, 0x31, 0x55, 0xa3, 0xdb, 0xa2, 0xf9, 0x71, 0x01, 0xcc, 0xdf, 0x30, 0x97, 0xa2, 0x55, 0xc8,
0x79, 0xae, 0x32, 0xbb, 0xdc, 0x29, 0x4c, 0x8e, 0x1b, 0xb9, 0xee, 0x2e, 0xce, 0x79, 0x2e, 0xda,
0x04, 0x73, 0x40, 0x05, 0xd1, 0x06, 0x59, 0x59, 0x0e, 0x49, 0xdf, 0xb5, 0x37, 0x0a, 0x8b, 0x7e,
0x06, 0xa6, 0xbc, 0x2a, 0x6d, 0xc9, 0x5a, 0x16, 0x47, 0xea, 0x7c, 0x15, 0x52, 0x27, 0xe1, 0x49,
0x3c, 0xda, 0x83, 0x8a, 0x4b, 0xb9, 0x13, 0x79, 0xa1, 0x90, 0x31, 0x34, 0x15, 0xfd, 0xf6, 0x59,
0xf4, 0xdd, 0x19, 0x14, 0xa7, 0x79, 0xe8, 0x97, 0x50, 0xe0, 0x82, 0x88, 0x21, 0xb7, 0x16, 0x94,
0x84, 0xfa, 0x99, 0x06, 0x28, 0x94, 0x36, 0x41, 0x73, 0xd0, 0x33, 0xa8, 0x0e, 0x48, 0x40, 0x7a,
0x34, 0xb2, 0xb5, 0x94, 0x82, 0x92, 0xf2, 0x83, 0x4c, 0xd7, 0x63, 0x64, 0x2c, 0x08, 0x2f, 0x0d,
0xd2, 0x5b, 0xd4, 0x05, 0x20, 0x42, 0x10, 0xe7, 0xfd, 0x80, 0x06, 0xc2, 0x2a, 0x2a, 0x29, 0x3f,
0xcc, 0xb4, 0x85, 0x8a, 0x0f, 0x2c, 0xea, 0xb7, 0xa7, 0xe0, 0x4e, 0xce, 0x32, 0x70, 0x8a, 0x8c,
0x9e, 0x42, 0xc5, 0xa1, 0x91, 0xf0, 0xde, 0x79, 0x0e, 0x11, 0xd4, 0x2a, 0x29, 0x59, 0x8d, 0x2c,
0x59, 0x3b, 0x33, 0x98, 0x76, 0x2c, 0xcd, 0x44, 0xf7, 0xc1, 0x8c, 0x98, 0x4f, 0xad, 0xf2, 0xba,
0x71, 0xa7, 0x7a, 0xf6, 0xd5, 0x60, 0xe6, 0x53, 0xac, 0x90, 0x52, 0xf5, 0xcc, 0x10, 0x6e, 0xc1,
0x7a, 0xfe, 0xd2, 0x6e, 0xe0, 0x34, 0x73, 0x7b, 0xf5, 0xf0, 0xa8, 0x89, 0x60, 0xb9, 0x64, 0x2c,
0x1b, 0x2a, 0xcf, 0x8c, 0xfb, 0xc6, 0xef, 0x8c, 0xdf, 0x1b, 0xcd, 0xff, 0xe6, 0xa1, 0xf8, 0x8a,
0x46, 0x23, 0xcf, 0xf9, 0xba, 0x59, 0xf8, 0xf0, 0x44, 0x16, 0x66, 0x06, 0x4b, 0xab, 0x9d, 0x4b,
0xc4, 0x2d, 0x28, 0xd1, 0xc0, 0x0d, 0x99, 0x17, 0x08, 0x9d, 0x85, 0x99, 0x91, 0xda, 0xd3, 0x18,
0x3c, 0x45, 0xa3, 0x3d, 0x58, 0x8a, 0x8b, 0xcb, 0x3e, 0x91, 0x82, 0xeb, 0x59, 0xf4, 0xdf, 0x2a,
0xa0, 0xce, 0x9d, 0xc5, 0x61, 0x6a, 0x87, 0x76, 0x61, 0x29, 0x8c, 0xe8, 0xc8, 0x63, 0x43, 0x6e,
0x2b, 0x27, 0x0a, 0x97, 0x72, 0x02, 0x2f, 0x26, 0x2c, 0xb9, 0x43, 0xbf, 0x82, 0x45, 0x49, 0xb6,
0x93, 0xa6, 0x04, 0x17, 0x36, 0x25, 0x5c, 0x91, 0x04, 0xbd, 0x41, 0x2f, 0xe1, 0x3b, 0x27, 0xac,
0x98, 0x0a, 0xaa, 0x5c, 0x2c, 0xe8, 0x66, 0xda, 0x12, 0xfd, 0x71, 0x1b, 0x1d, 0x1e, 0x35, 0xab,
0xb0, 0x98, 0x4e, 0x81, 0xe6, 0x9f, 0x73, 0x50, 0x4a, 0x02, 0x89, 0x1e, 0xe8, 0x3b, 0x33, 0xce,
0x8e, 0x5a, 0x82, 0x55, 0xfe, 0xc6, 0xd7, 0xf5, 0x00, 0x16, 0x42, 0x16, 0x09, 0x6e, 0xe5, 0x54,
0x72, 0x66, 0xd6, 0xfb, 0x3e, 0x8b, 0xc4, 0x0e, 0x0b, 0xde, 0x79, 0x3d, 0x1c, 0x83, 0xd1, 0x5b,
0xa8, 0x8c, 0xbc, 0x48, 0x0c, 0x89, 0x6f, 0x7b, 0x21, 0xb7, 0xf2, 0x8a, 0xfb, 0xa3, 0xf3, 0x54,
0xb6, 0xde, 0xc4, 0xf8, 0xee, 0x7e, 0xa7, 0x3a, 0x39, 0x6e, 0xc0, 0x74, 0xcb, 0x31, 0x68, 0x51,
0xdd, 0x90, 0xd7, 0x5e, 0x40, 0x79, 0x7a, 0x82, 0xee, 0x01, 0x04, 0x71, 0x5d, 0xd8, 0xd3, 0xcc,
0x5e, 0x9a, 0x1c, 0x37, 0xca, 0xba, 0x5a, 0xba, 0xbb, 0xb8, 0xac, 0x01, 0x5d, 0x17, 0x21, 0x30,
0x89, 0xeb, 0x46, 0x2a, 0xcf, 0xcb, 0x58, 0xad, 0x9b, 0x7f, 0x2a, 0x82, 0xf9, 0x9a, 0xf0, 0xfe,
0x75, 0xb7, 0x68, 0xa9, 0x73, 0xae, 0x32, 0xee, 0x01, 0xf0, 0x38, 0xdf, 0xa4, 0x3b, 0xe6, 0xcc,
0x1d, 0x9d, 0x85, 0xd2, 0x1d, 0x0d, 0x88, 0xdd, 0xe1, 0x3e, 0x13, 0xaa, 0x08, 0x4c, 0xac, 0xd6,
0xe8, 0x36, 0x14, 0x03, 0xe6, 0x2a, 0x7a, 0x41, 0xd1, 0x61, 0x72, 0xdc, 0x28, 0xc8, 0xa6, 0xd3,
0xdd, 0xc5, 0x05, 0x79, 0xd4, 0x75, 0x55, 0xd3, 0x09, 0x02, 0x26, 0x88, 0x6c, 0xe8, 0x5c, 0xf7,
0xce, 0xcc, 0xec, 0x6f, 0xcf, 0x60, 0x49, 0xbf, 0x4b, 0x31, 0xd1, 0x1b, 0xb8, 0x99, 0xd8, 0x9b,
0x16, 0x58, 0xba, 0x8a, 0x40, 0xa4, 0x25, 0xa4, 0x4e, 0x52, 0x6f, 0x4c, 0xf9, 0xec, 0x37, 0x46,
0x45, 0x30, 0xeb, 0x8d, 0xe9, 0xc0, 0x92, 0x4b, 0xb9, 0x17, 0x51, 0x57, 0xb5, 0x09, 0xaa, 0x2a,
0xb3, 0xba, 0xf9, 0xfd, 0xf3, 0x84, 0x50, 0xbc, 0xa8, 0x39, 0x6a, 0x87, 0xda, 0x50, 0xd2, 0x79,
0xc3, 0xad, 0xca, 0x55, 0x9a, 0xf2, 0x94, 0x76, 0xa2, 0xcd, 0x2d, 0x5e, 0xa9, 0xcd, 0x3d, 0x04,
0xf0, 0x59, 0xcf, 0x76, 0x23, 0x6f, 0x44, 0x23, 0x6b, 0x49, 0x4f, 0x1c, 0x19, 0xdc, 0x5d, 0x85,
0xc0, 0x65, 0x9f, 0xf5, 0xe2, 0xe5, 0x5c, 0x53, 0xaa, 0x5e, 0xb1, 0x29, 0x11, 0xa8, 0x11, 0xce,
0xbd, 0x5e, 0x40, 0x5d, 0xbb, 0x47, 0x03, 0x1a, 0x79, 0x8e, 0x1d, 0x51, 0xce, 0x86, 0x91, 0x43,
0xb9, 0xf5, 0x2d, 0x15, 0x89, 0xcc, 0x99, 0xe1, 0x69, 0x0c, 0xc6, 0x1a, 0x8b, 0xad, 0x44, 0xcc,
0xa9, 0x03, 0xbe, 0x5d, 0x3b, 0x3c, 0x6a, 0xae, 0xc2, 0x4a, 0xba, 0x4d, 0x6d, 0x19, 0x4f, 0x8c,
0x67, 0xc6, 0xbe, 0xd1, 0xfc, 0x7b, 0x0e, 0xbe, 0x3d, 0x17, 0x53, 0xf4, 0x53, 0x28, 0xea, 0xa8,
0x9e, 0x37, 0xf9, 0x69, 0x1e, 0x4e, 0xb0, 0x68, 0x0d, 0xca, 0xb2, 0xc4, 0x29, 0xe7, 0x34, 0x6e,
0x5e, 0x65, 0x3c, 0xfb, 0x80, 0x2c, 0x28, 0x12, 0xdf, 0x23, 0xf2, 0x2c, 0xaf, 0xce, 0x92, 0x2d,
0x1a, 0xc2, 0x6a, 0x1c, 0x7a, 0x7b, 0xf6, 0xc0, 0xda, 0x2c, 0x14, 0xdc, 0x32, 0x95, 0xff, 0x8f,
0x2f, 0x95, 0x09, 0xfa, 0x72, 0x66, 0x1f, 0x5e, 0x86, 0x82, 0xef, 0x05, 0x22, 0x1a, 0xe3, 0x15,
0x37, 0xe3, 0xa8, 0xf6, 0x14, 0x6e, 0x9d, 0x49, 0x41, 0xcb, 0x90, 0xef, 0xd3, 0x71, 0xdc, 0x9e,
0xb0, 0x5c, 0xa2, 0x15, 0x58, 0x18, 0x11, 0x7f, 0x48, 0x75, 0x37, 0x8b, 0x37, 0xdb, 0xb9, 0x2d,
0xa3, 0xf9, 0x29, 0x07, 0x45, 0x6d, 0xce, 0x75, 0x3f, 0xf9, 0x5a, 0xed, 0x5c, 0x63, 0x7b, 0x04,
0x8b, 0x3a, 0xa4, 0x71, 0x45, 0x9a, 0x17, 0xe6, 0x74, 0x25, 0xc6, 0xc7, 0xd5, 0xf8, 0x08, 0x4c,
0x2f, 0x24, 0x03, 0xfd, 0xdc, 0x67, 0x6a, 0xee, 0xee, 0xb7, 0x5f, 0xbc, 0x0c, 0xe3, 0xc6, 0x52,
0x9a, 0x1c, 0x37, 0x4c, 0xf9, 0x01, 0x2b, 0x5a, 0xe6, 0xc3, 0xf8, 0x97, 0x05, 0x28, 0xee, 0xf8,
0x43, 0x2e, 0x68, 0x74, 0xdd, 0x41, 0xd2, 0x6a, 0xe7, 0x82, 0xb4, 0x03, 0xc5, 0x88, 0x31, 0x61,
0x3b, 0xe4, 0xbc, 0xf8, 0x60, 0xc6, 0xc4, 0x4e, 0xbb, 0x53, 0x95, 0x44, 0xd9, 0xdb, 0xe3, 0x3d,
0x2e, 0x48, 0xea, 0x0e, 0x41, 0x6f, 0x61, 0x35, 0x79, 0x11, 0x0f, 0x18, 0x13, 0x5c, 0x44, 0x24,
0xb4, 0xfb, 0x74, 0x2c, 0x67, 0xa5, 0xfc, 0x59, 0x83, 0xf6, 0x5e, 0xe0, 0x44, 0x63, 0x15, 0xbc,
0xe7, 0x74, 0x8c, 0x57, 0xb4, 0x80, 0x4e, 0xc2, 0x7f, 0x4e, 0xc7, 0x1c, 0x3d, 0x86, 0x35, 0x3a,
0x85, 0x49, 0x89, 0xb6, 0x4f, 0x06, 0xf2, 0xad, 0xb7, 0x1d, 0x9f, 0x39, 0x7d, 0xf5, 0xdc, 0x98,
0xf8, 0x16, 0x4d, 0x8b, 0xfa, 0x75, 0x8c, 0xd8, 0x91, 0x00, 0xc4, 0xc1, 0x3a, 0xf0, 0x89, 0xd3,
0xf7, 0x3d, 0x2e, 0xff, 0x97, 0x4a, 0xcd, 0xcd, 0xf2, 0xc5, 0x90, 0xb6, 0x6d, 0x9d, 0x13, 0xad,
0x56, 0x67, 0xc6, 0x4d, 0x4d, 0xe1, 0xba, 0xa2, 0xbe, 0x7b, 0x90, 0x7d, 0x8a, 0x3a, 0x50, 0x19,
0x06, 0x52, 0x7d, 0x1c, 0x83, 0xf2, 0x65, 0x63, 0x00, 0x31, 0x4b, 0x7a, 0x5e, 0x1b, 0xc1, 0xda,
0x79, 0xca, 0x33, 0x6a, 0xf3, 0x49, 0xba, 0x36, 0x2b, 0x9b, 0x77, 0xb3, 0xf4, 0x65, 0x8b, 0x4c,
0xd5, 0x71, 0x66, 0xda, 0xfe, 0xcd, 0x80, 0xc2, 0x2b, 0xea, 0x44, 0x54, 0x7c, 0xd5, 0xac, 0xdd,
0x3a, 0x91, 0xb5, 0xf5, 0xec, 0x41, 0x58, 0x6a, 0x9d, 0x4b, 0xda, 0x1a, 0x94, 0xbc, 0x40, 0xd0,
0x28, 0x20, 0xbe, 0xca, 0xda, 0x12, 0x9e, 0xee, 0x33, 0x1d, 0xf8, 0x64, 0x40, 0x21, 0x9e, 0x14,
0xaf, 0xdb, 0x81, 0x58, 0xeb, 0x69, 0x07, 0x32, 0x8d, 0xfc, 0x8f, 0x01, 0xa5, 0xe4, 0xc1, 0xfa,
0xaa, 0x66, 0x9e, 0x9a, 0xbc, 0xf2, 0xff, 0xf7, 0xe4, 0x85, 0xc0, 0xec, 0x7b, 0x81, 0x9e, 0x11,
0xb1, 0x5a, 0xa3, 0x16, 0x14, 0x43, 0x32, 0xf6, 0x19, 0x71, 0x75, 0xa3, 0x5c, 0x99, 0xfb, 0x95,
0xa2, 0x1d, 0x8c, 0x71, 0x02, 0xda, 0x5e, 0x39, 0x3c, 0x6a, 0x2e, 0x43, 0x35, 0xed, 0xf9, 0x7b,
0xa3, 0xf9, 0x4f, 0x03, 0xca, 0x7b, 0x7f, 0x14, 0x34, 0x50, 0xf3, 0xc0, 0x37, 0xd2, 0xf9, 0xf5,
0xf9, 0x5f, 0x32, 0xca, 0x27, 0x7e, 0xa4, 0xc8, 0xba, 0xd4, 0x8e, 0xf5, 0xf9, 0x4b, 0xfd, 0xc6,
0xbf, 0xbe, 0xd4, 0x6f, 0x7c, 0x9c, 0xd4, 0x8d, 0xcf, 0x93, 0xba, 0xf1, 0x8f, 0x49, 0xdd, 0xf8,
0xf7, 0xa4, 0x6e, 0x1c, 0x14, 0x54, 0x7c, 0x7e, 0xf2, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf9,
0xa1, 0x26, 0x54, 0x90, 0x13, 0x00, 0x00,
}

8
components/engine/vendor/github.com/docker/swarmkit/api/objects.proto generated vendored
View File

@ -77,10 +77,10 @@ message Node {
// issuing or renewing the node's certificate.
NodeRole role = 9;
// Each node uses the network attachment to set up an endpoint on the
// node to be used for load balancing. Each overlay network, including
// ingress network, will have an NetworkAttachment.
repeated NetworkAttachment lb_attachments = 10;
// Attachments enumerates the network attachments for the node to set up an
// endpoint on the node to be used for load balancing. Each overlay
// network, including ingress network, will have an NetworkAttachment.
repeated NetworkAttachment attachments = 10;
}
message Service {

498
components/engine/vendor/github.com/docker/swarmkit/api/specs.pb.go generated vendored
View File

@ -585,97 +585,12 @@ type ContainerSpec struct {
// task will exit and a new task will be rescheduled elsewhere. A container
// is considered unhealthy after `Retries` number of consecutive failures.
Healthcheck *HealthConfig `protobuf:"bytes,16,opt,name=healthcheck" json:"healthcheck,omitempty"`
// Run a custom init inside the container, if null, use the daemon's configured settings
//
// Types that are valid to be assigned to Init:
// *ContainerSpec_InitValue
Init isContainerSpec_Init `protobuf_oneof:"init"`
}
func (m *ContainerSpec) Reset() { *m = ContainerSpec{} }
func (*ContainerSpec) ProtoMessage() {}
func (*ContainerSpec) Descriptor() ([]byte, []int) { return fileDescriptorSpecs, []int{8} }
type isContainerSpec_Init interface {
isContainerSpec_Init()
MarshalTo([]byte) (int, error)
Size() int
}
type ContainerSpec_InitValue struct {
InitValue bool `protobuf:"varint,23,opt,name=init_value,json=initValue,proto3,oneof"`
}
func (*ContainerSpec_InitValue) isContainerSpec_Init() {}
func (m *ContainerSpec) GetInit() isContainerSpec_Init {
if m != nil {
return m.Init
}
return nil
}
func (m *ContainerSpec) GetInitValue() bool {
if x, ok := m.GetInit().(*ContainerSpec_InitValue); ok {
return x.InitValue
}
return false
}
// XXX_OneofFuncs is for the internal use of the proto package.
func (*ContainerSpec) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
return _ContainerSpec_OneofMarshaler, _ContainerSpec_OneofUnmarshaler, _ContainerSpec_OneofSizer, []interface{}{
(*ContainerSpec_InitValue)(nil),
}
}
func _ContainerSpec_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
m := msg.(*ContainerSpec)
// init
switch x := m.Init.(type) {
case *ContainerSpec_InitValue:
t := uint64(0)
if x.InitValue {
t = 1
}
_ = b.EncodeVarint(23<<3 | proto.WireVarint)
_ = b.EncodeVarint(t)
case nil:
default:
return fmt.Errorf("ContainerSpec.Init has unexpected type %T", x)
}
return nil
}
func _ContainerSpec_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
m := msg.(*ContainerSpec)
switch tag {
case 23: // init.init_value
if wire != proto.WireVarint {
return true, proto.ErrInternalBadWireType
}
x, err := b.DecodeVarint()
m.Init = &ContainerSpec_InitValue{x != 0}
return true, err
default:
return false, nil
}
}
func _ContainerSpec_OneofSizer(msg proto.Message) (n int) {
m := msg.(*ContainerSpec)
// init
switch x := m.Init.(type) {
case *ContainerSpec_InitValue:
n += proto.SizeVarint(23<<3 | proto.WireVarint)
n += 1
case nil:
default:
panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
}
return n
}
// PullOptions allows one to parameterize an image pull.
type ContainerSpec_PullOptions struct {
// RegistryAuth is the registry auth token obtained from the client, required
@ -1219,16 +1134,6 @@ func (m *ContainerSpec) CopyFrom(src interface{}) {
m.Healthcheck = &HealthConfig{}
github_com_docker_swarmkit_api_deepcopy.Copy(m.Healthcheck, o.Healthcheck)
}
if o.Init != nil {
switch o.Init.(type) {
case *ContainerSpec_InitValue:
v := ContainerSpec_InitValue{
InitValue: o.GetInitValue(),
}
m.Init = &v
}
}
}
func (m *ContainerSpec_PullOptions) Copy() *ContainerSpec_PullOptions {
@ -2091,30 +1996,9 @@ func (m *ContainerSpec) MarshalTo(dAtA []byte) (int, error) {
}
i += n23
}
if m.Init != nil {
nn24, err := m.Init.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += nn24
}
return i, nil
}
func (m *ContainerSpec_InitValue) MarshalTo(dAtA []byte) (int, error) {
i := 0
dAtA[i] = 0xb8
i++
dAtA[i] = 0x1
i++
if m.InitValue {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i++
return i, nil
}
func (m *ContainerSpec_PullOptions) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -2257,20 +2141,20 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
n25, err := m.Annotations.MarshalTo(dAtA[i:])
n24, err := m.Annotations.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n25
i += n24
if m.DriverConfig != nil {
dAtA[i] = 0x12
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.DriverConfig.Size()))
n26, err := m.DriverConfig.MarshalTo(dAtA[i:])
n25, err := m.DriverConfig.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n26
i += n25
}
if m.Ipv6Enabled {
dAtA[i] = 0x18
@ -2296,11 +2180,11 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x2a
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.IPAM.Size()))
n27, err := m.IPAM.MarshalTo(dAtA[i:])
n26, err := m.IPAM.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n27
i += n26
}
if m.Attachable {
dAtA[i] = 0x30
@ -2323,11 +2207,11 @@ func (m *NetworkSpec) MarshalTo(dAtA []byte) (int, error) {
i++
}
if m.ConfigFrom != nil {
nn28, err := m.ConfigFrom.MarshalTo(dAtA[i:])
nn27, err := m.ConfigFrom.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += nn28
i += nn27
}
return i, nil
}
@ -2358,67 +2242,67 @@ func (m *ClusterSpec) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
n29, err := m.Annotations.MarshalTo(dAtA[i:])
n28, err := m.Annotations.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n28
dAtA[i] = 0x12
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.AcceptancePolicy.Size()))
n29, err := m.AcceptancePolicy.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n29
dAtA[i] = 0x12
dAtA[i] = 0x1a
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.AcceptancePolicy.Size()))
n30, err := m.AcceptancePolicy.MarshalTo(dAtA[i:])
i = encodeVarintSpecs(dAtA, i, uint64(m.Orchestration.Size()))
n30, err := m.Orchestration.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n30
dAtA[i] = 0x1a
dAtA[i] = 0x22
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.Orchestration.Size()))
n31, err := m.Orchestration.MarshalTo(dAtA[i:])
i = encodeVarintSpecs(dAtA, i, uint64(m.Raft.Size()))
n31, err := m.Raft.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n31
dAtA[i] = 0x22
dAtA[i] = 0x2a
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.Raft.Size()))
n32, err := m.Raft.MarshalTo(dAtA[i:])
i = encodeVarintSpecs(dAtA, i, uint64(m.Dispatcher.Size()))
n32, err := m.Dispatcher.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n32
dAtA[i] = 0x2a
dAtA[i] = 0x32
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.Dispatcher.Size()))
n33, err := m.Dispatcher.MarshalTo(dAtA[i:])
i = encodeVarintSpecs(dAtA, i, uint64(m.CAConfig.Size()))
n33, err := m.CAConfig.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n33
dAtA[i] = 0x32
dAtA[i] = 0x3a
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.CAConfig.Size()))
n34, err := m.CAConfig.MarshalTo(dAtA[i:])
i = encodeVarintSpecs(dAtA, i, uint64(m.TaskDefaults.Size()))
n34, err := m.TaskDefaults.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n34
dAtA[i] = 0x3a
dAtA[i] = 0x42
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.TaskDefaults.Size()))
n35, err := m.TaskDefaults.MarshalTo(dAtA[i:])
i = encodeVarintSpecs(dAtA, i, uint64(m.EncryptionConfig.Size()))
n35, err := m.EncryptionConfig.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n35
dAtA[i] = 0x42
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.EncryptionConfig.Size()))
n36, err := m.EncryptionConfig.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n36
return i, nil
}
@ -2440,11 +2324,11 @@ func (m *SecretSpec) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
n37, err := m.Annotations.MarshalTo(dAtA[i:])
n36, err := m.Annotations.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n37
i += n36
if len(m.Data) > 0 {
dAtA[i] = 0x12
i++
@ -2455,21 +2339,21 @@ func (m *SecretSpec) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x1a
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.Templating.Size()))
n38, err := m.Templating.MarshalTo(dAtA[i:])
n37, err := m.Templating.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n38
i += n37
}
if m.Driver != nil {
dAtA[i] = 0x22
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.Driver.Size()))
n39, err := m.Driver.MarshalTo(dAtA[i:])
n38, err := m.Driver.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n39
i += n38
}
return i, nil
}
@ -2492,11 +2376,11 @@ func (m *ConfigSpec) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.Annotations.Size()))
n40, err := m.Annotations.MarshalTo(dAtA[i:])
n39, err := m.Annotations.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n40
i += n39
if len(m.Data) > 0 {
dAtA[i] = 0x12
i++
@ -2507,11 +2391,11 @@ func (m *ConfigSpec) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x1a
i++
i = encodeVarintSpecs(dAtA, i, uint64(m.Templating.Size()))
n41, err := m.Templating.MarshalTo(dAtA[i:])
n40, err := m.Templating.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n41
i += n40
}
return i, nil
}
@ -2837,18 +2721,9 @@ func (m *ContainerSpec) Size() (n int) {
l = m.Privileges.Size()
n += 2 + l + sovSpecs(uint64(l))
}
if m.Init != nil {
n += m.Init.Size()
}
return n
}
func (m *ContainerSpec_InitValue) Size() (n int) {
var l int
_ = l
n += 3
return n
}
func (m *ContainerSpec_PullOptions) Size() (n int) {
var l int
_ = l
@ -3191,17 +3066,6 @@ func (this *ContainerSpec) String() string {
`StopSignal:` + fmt.Sprintf("%v", this.StopSignal) + `,`,
`Configs:` + strings.Replace(fmt.Sprintf("%v", this.Configs), "ConfigReference", "ConfigReference", 1) + `,`,
`Privileges:` + strings.Replace(fmt.Sprintf("%v", this.Privileges), "Privileges", "Privileges", 1) + `,`,
`Init:` + fmt.Sprintf("%v", this.Init) + `,`,
`}`,
}, "")
return s
}
func (this *ContainerSpec_InitValue) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&ContainerSpec_InitValue{`,
`InitValue:` + fmt.Sprintf("%v", this.InitValue) + `,`,
`}`,
}, "")
return s
@ -5277,27 +5141,6 @@ func (m *ContainerSpec) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 23:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field InitValue", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSpecs
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
b := bool(v != 0)
m.Init = &ContainerSpec_InitValue{b}
default:
iNdEx = preIndex
skippy, err := skipSpecs(dAtA[iNdEx:])
@ -6609,130 +6452,129 @@ var (
func init() { proto.RegisterFile("github.com/docker/swarmkit/api/specs.proto", fileDescriptorSpecs) }
var fileDescriptorSpecs = []byte{
// 2000 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0x4f, 0x6f, 0x1b, 0xb9,
0x15, 0xb7, 0x6c, 0x59, 0x7f, 0xde, 0xc8, 0x89, 0xc2, 0x4d, 0xb2, 0x13, 0xa5, 0x6b, 0x29, 0xda,
0x6c, 0xea, 0xdd, 0x45, 0x65, 0xd4, 0x2d, 0xb6, 0xd9, 0x4d, 0xb7, 0xad, 0x64, 0xa9, 0x8e, 0x9b,
0xc6, 0x11, 0x68, 0x6f, 0xda, 0x00, 0x05, 0x04, 0x7a, 0x86, 0x96, 0x08, 0x8f, 0x86, 0x53, 0x0e,
0xc7, 0x0b, 0xdd, 0x7a, 0x5c, 0xa4, 0x9f, 0x21, 0xe8, 0xa1, 0xe8, 0xbd, 0x1f, 0xa0, 0x1f, 0x20,
0xc7, 0x1e, 0xdb, 0x8b, 0xd1, 0xd5, 0x57, 0xe8, 0xad, 0x97, 0x16, 0xe4, 0x70, 0x46, 0xa3, 0x64,
0x1c, 0x07, 0x68, 0x0e, 0x7b, 0x23, 0xdf, 0xfc, 0x7e, 0x6f, 0x1e, 0xc9, 0xdf, 0xe3, 0x7b, 0x84,
0x4f, 0xc6, 0x4c, 0x4e, 0xa2, 0xe3, 0x8e, 0xc3, 0xa7, 0xdb, 0x2e, 0x77, 0x4e, 0xa9, 0xd8, 0x0e,
0xbf, 0x26, 0x62, 0x7a, 0xca, 0xe4, 0x36, 0x09, 0xd8, 0x76, 0x18, 0x50, 0x27, 0xec, 0x04, 0x82,
0x4b, 0x8e, 0x50, 0x0c, 0xe8, 0x24, 0x80, 0xce, 0xd9, 0x0f, 0x1b, 0x97, 0xf1, 0xe5, 0x2c, 0xa0,
0x86, 0xdf, 0xb8, 0x3e, 0xe6, 0x63, 0xae, 0x87, 0xdb, 0x6a, 0x64, 0xac, 0x9b, 0x63, 0xce, 0xc7,
0x1e, 0xdd, 0xd6, 0xb3, 0xe3, 0xe8, 0x64, 0xdb, 0x8d, 0x04, 0x91, 0x8c, 0xfb, 0xe6, 0xfb, 0xad,
0x57, 0xbf, 0x13, 0x7f, 0x16, 0x7f, 0x6a, 0xbf, 0x28, 0x42, 0xe5, 0x80, 0xbb, 0xf4, 0x30, 0xa0,
0x0e, 0xda, 0x03, 0x8b, 0xf8, 0x3e, 0x97, 0x9a, 0x1b, 0xda, 0x85, 0x56, 0x61, 0xcb, 0xda, 0x69,
0x76, 0x5e, 0x8f, 0xb9, 0xd3, 0x5d, 0xc0, 0x7a, 0xc5, 0x97, 0xe7, 0xcd, 0x15, 0x9c, 0x65, 0xa2,
0x9f, 0x43, 0xcd, 0xa5, 0x21, 0x13, 0xd4, 0x1d, 0x09, 0xee, 0x51, 0x7b, 0xb5, 0x55, 0xd8, 0xba,
0xb2, 0xf3, 0xbd, 0x3c, 0x4f, 0xea, 0xe7, 0x98, 0x7b, 0x14, 0x5b, 0x86, 0xa1, 0x26, 0x68, 0x0f,
0x60, 0x4a, 0xa7, 0xc7, 0x54, 0x84, 0x13, 0x16, 0xd8, 0x6b, 0x9a, 0xfe, 0xfd, 0x8b, 0xe8, 0x2a,
0xf6, 0xce, 0xe3, 0x14, 0x8e, 0x33, 0x54, 0xf4, 0x18, 0x6a, 0xe4, 0x8c, 0x30, 0x8f, 0x1c, 0x33,
0x8f, 0xc9, 0x99, 0x5d, 0xd4, 0xae, 0x3e, 0x7e, 0xa3, 0xab, 0x6e, 0x86, 0x80, 0x97, 0xe8, 0x6d,
0x17, 0x60, 0xf1, 0x23, 0x74, 0x0f, 0xca, 0xc3, 0xc1, 0x41, 0x7f, 0xff, 0x60, 0xaf, 0xbe, 0xd2,
0xb8, 0xf5, 0xfc, 0x45, 0xeb, 0x86, 0xf2, 0xb1, 0x00, 0x0c, 0xa9, 0xef, 0x32, 0x7f, 0x8c, 0xb6,
0xa0, 0xd2, 0xdd, 0xdd, 0x1d, 0x0c, 0x8f, 0x06, 0xfd, 0x7a, 0xa1, 0xd1, 0x78, 0xfe, 0xa2, 0x75,
0x73, 0x19, 0xd8, 0x75, 0x1c, 0x1a, 0x48, 0xea, 0x36, 0x8a, 0xdf, 0xfc, 0x79, 0x73, 0xa5, 0xfd,
0x4d, 0x01, 0x6a, 0xd9, 0x20, 0xd0, 0x3d, 0x28, 0x75, 0x77, 0x8f, 0xf6, 0x9f, 0x0e, 0xea, 0x2b,
0x0b, 0x7a, 0x16, 0xd1, 0x75, 0x24, 0x3b, 0xa3, 0xe8, 0x2e, 0xac, 0x0f, 0xbb, 0x5f, 0x1d, 0x0e,
0xea, 0x85, 0x45, 0x38, 0x59, 0xd8, 0x90, 0x44, 0xa1, 0x46, 0xf5, 0x71, 0x77, 0xff, 0xa0, 0xbe,
0x9a, 0x8f, 0xea, 0x0b, 0xc2, 0x7c, 0x13, 0xca, 0x9f, 0x8a, 0x60, 0x1d, 0x52, 0x71, 0xc6, 0x9c,
0x77, 0x2c, 0x91, 0xcf, 0xa0, 0x28, 0x49, 0x78, 0xaa, 0xa5, 0x61, 0xe5, 0x4b, 0xe3, 0x88, 0x84,
0xa7, 0xea, 0xa7, 0x86, 0xae, 0xf1, 0x4a, 0x19, 0x82, 0x06, 0x1e, 0x73, 0x88, 0xa4, 0xae, 0x56,
0x86, 0xb5, 0xf3, 0x51, 0x1e, 0x1b, 0xa7, 0x28, 0x13, 0xff, 0xc3, 0x15, 0x9c, 0xa1, 0xa2, 0x07,
0x50, 0x1a, 0x7b, 0xfc, 0x98, 0x78, 0x5a, 0x13, 0xd6, 0xce, 0x9d, 0x3c, 0x27, 0x7b, 0x1a, 0xb1,
0x70, 0x60, 0x28, 0xe8, 0x3e, 0x94, 0xa2, 0xc0, 0x25, 0x92, 0xda, 0x25, 0x4d, 0x6e, 0xe5, 0x91,
0xbf, 0xd2, 0x88, 0x5d, 0xee, 0x9f, 0xb0, 0x31, 0x36, 0x78, 0xf4, 0x08, 0x2a, 0x3e, 0x95, 0x5f,
0x73, 0x71, 0x1a, 0xda, 0xe5, 0xd6, 0xda, 0x96, 0xb5, 0xf3, 0x69, 0xae, 0x18, 0x63, 0x4c, 0x57,
0x4a, 0xe2, 0x4c, 0xa6, 0xd4, 0x97, 0xb1, 0x9b, 0xde, 0xaa, 0x5d, 0xc0, 0xa9, 0x03, 0xf4, 0x53,
0xa8, 0x50, 0xdf, 0x0d, 0x38, 0xf3, 0xa5, 0x5d, 0xb9, 0x38, 0x90, 0x81, 0xc1, 0xa8, 0xcd, 0xc4,
0x29, 0x43, 0xb1, 0x05, 0xf7, 0xbc, 0x63, 0xe2, 0x9c, 0xda, 0xd5, 0xb7, 0x5c, 0x46, 0xca, 0xe8,
0x95, 0xa0, 0x38, 0xe5, 0x2e, 0x6d, 0x6f, 0xc3, 0xb5, 0xd7, 0xb6, 0x1a, 0x35, 0xa0, 0x62, 0xb6,
0x3a, 0xd6, 0x48, 0x11, 0xa7, 0xf3, 0xf6, 0x55, 0xd8, 0x58, 0xda, 0xd6, 0xf6, 0x5f, 0xd7, 0xa1,
0x92, 0x9c, 0x35, 0xea, 0x42, 0xd5, 0xe1, 0xbe, 0x24, 0xcc, 0xa7, 0xc2, 0xc8, 0x2b, 0xf7, 0x64,
0x76, 0x13, 0x90, 0x62, 0x3d, 0x5c, 0xc1, 0x0b, 0x16, 0xfa, 0x25, 0x54, 0x05, 0x0d, 0x79, 0x24,
0x1c, 0x1a, 0x1a, 0x7d, 0x6d, 0xe5, 0x2b, 0x24, 0x06, 0x61, 0xfa, 0xfb, 0x88, 0x09, 0xaa, 0x76,
0x39, 0xc4, 0x0b, 0x2a, 0x7a, 0x00, 0x65, 0x41, 0x43, 0x49, 0x84, 0x7c, 0x93, 0x44, 0x70, 0x0c,
0x19, 0x72, 0x8f, 0x39, 0x33, 0x9c, 0x30, 0xd0, 0x03, 0xa8, 0x06, 0x1e, 0x71, 0xb4, 0x57, 0x7b,
0x5d, 0xd3, 0x3f, 0xc8, 0xa3, 0x0f, 0x13, 0x10, 0x5e, 0xe0, 0xd1, 0xe7, 0x00, 0x1e, 0x1f, 0x8f,
0x5c, 0xc1, 0xce, 0xa8, 0x30, 0x12, 0x6b, 0xe4, 0xb1, 0xfb, 0x1a, 0x81, 0xab, 0x1e, 0x1f, 0xc7,
0x43, 0xb4, 0xf7, 0x7f, 0xe9, 0x2b, 0xa3, 0xad, 0x47, 0x00, 0x24, 0xfd, 0x6a, 0xd4, 0xf5, 0xf1,
0x5b, 0xb9, 0x32, 0x27, 0x92, 0xa1, 0xa3, 0x3b, 0x50, 0x3b, 0xe1, 0xc2, 0xa1, 0x23, 0x93, 0x35,
0x55, 0xad, 0x09, 0x4b, 0xdb, 0x62, 0x7d, 0xa1, 0x1e, 0x94, 0xc7, 0xd4, 0xa7, 0x82, 0x39, 0x36,
0xe8, 0x9f, 0xdd, 0xcb, 0x4d, 0xc8, 0x18, 0x82, 0x23, 0x5f, 0xb2, 0x29, 0x35, 0x7f, 0x4a, 0x88,
0xe8, 0x77, 0xf0, 0x5e, 0x72, 0x7c, 0x23, 0x41, 0x4f, 0xa8, 0xa0, 0xbe, 0xd2, 0x80, 0xa5, 0xf7,
0xe1, 0xa3, 0x37, 0x6b, 0xc0, 0xa0, 0xcd, 0x65, 0x83, 0xc4, 0xab, 0x1f, 0xc2, 0x5e, 0x15, 0xca,
0x22, 0xfe, 0x6f, 0xfb, 0x8f, 0x05, 0xa5, 0xfa, 0x57, 0x10, 0x68, 0x1b, 0xac, 0xf4, 0xf7, 0xcc,
0xd5, 0xea, 0xad, 0xf6, 0xae, 0xcc, 0xcf, 0x9b, 0x90, 0x60, 0xf7, 0xfb, 0xea, 0x0e, 0x32, 0x63,
0x17, 0x0d, 0x60, 0x23, 0x25, 0xa8, 0x32, 0x6f, 0x0a, 0x65, 0xeb, 0x4d, 0x91, 0x1e, 0xcd, 0x02,
0x8a, 0x6b, 0x22, 0x33, 0x6b, 0xff, 0x16, 0xd0, 0xeb, 0xfb, 0x82, 0x10, 0x14, 0x4f, 0x99, 0x6f,
0xc2, 0xc0, 0x7a, 0x8c, 0x3a, 0x50, 0x0e, 0xc8, 0xcc, 0xe3, 0xc4, 0x35, 0x89, 0x71, 0xbd, 0x13,
0xf7, 0x06, 0x9d, 0xa4, 0x37, 0xe8, 0x74, 0xfd, 0x19, 0x4e, 0x40, 0xed, 0x47, 0x70, 0x23, 0xf7,
0x78, 0xd1, 0x0e, 0xd4, 0xd2, 0x84, 0x5b, 0xac, 0xf5, 0xea, 0xfc, 0xbc, 0x69, 0xa5, 0x99, 0xb9,
0xdf, 0xc7, 0x56, 0x0a, 0xda, 0x77, 0xdb, 0x7f, 0xab, 0xc2, 0xc6, 0x52, 0xda, 0xa2, 0xeb, 0xb0,
0xce, 0xa6, 0x64, 0x4c, 0x4d, 0x8c, 0xf1, 0x04, 0x0d, 0xa0, 0xe4, 0x91, 0x63, 0xea, 0xa9, 0xe4,
0x55, 0x07, 0xf7, 0x83, 0x4b, 0xf3, 0xbf, 0xf3, 0x6b, 0x8d, 0x1f, 0xf8, 0x52, 0xcc, 0xb0, 0x21,
0x23, 0x1b, 0xca, 0x0e, 0x9f, 0x4e, 0x89, 0xaf, 0xca, 0xc4, 0xda, 0x56, 0x15, 0x27, 0x53, 0xb5,
0x33, 0x44, 0x8c, 0x43, 0xbb, 0xa8, 0xcd, 0x7a, 0x8c, 0xea, 0xb0, 0x46, 0xfd, 0x33, 0x7b, 0x5d,
0x9b, 0xd4, 0x50, 0x59, 0x5c, 0x16, 0x67, 0x5f, 0x15, 0xab, 0xa1, 0xe2, 0x45, 0x21, 0x15, 0x76,
0x39, 0xde, 0x51, 0x35, 0x46, 0x3f, 0x81, 0xd2, 0x94, 0x47, 0xbe, 0x0c, 0xed, 0x8a, 0x0e, 0xf6,
0x56, 0x5e, 0xb0, 0x8f, 0x15, 0xc2, 0x28, 0xcb, 0xc0, 0xd1, 0x00, 0xae, 0x85, 0x92, 0x07, 0xa3,
0xb1, 0x20, 0x0e, 0x1d, 0x05, 0x54, 0x30, 0xee, 0x9a, 0x6b, 0xf8, 0xd6, 0x6b, 0x87, 0xd2, 0x37,
0x0d, 0x1d, 0xbe, 0xaa, 0x38, 0x7b, 0x8a, 0x32, 0xd4, 0x0c, 0x34, 0x84, 0x5a, 0x10, 0x79, 0xde,
0x88, 0x07, 0x71, 0x45, 0x8e, 0x73, 0xe7, 0x2d, 0xb6, 0x6c, 0x18, 0x79, 0xde, 0x93, 0x98, 0x84,
0xad, 0x60, 0x31, 0x41, 0x37, 0xa1, 0x34, 0x16, 0x3c, 0x0a, 0xe2, 0xbc, 0xa9, 0x62, 0x33, 0x43,
0x5f, 0x42, 0x39, 0xa4, 0x8e, 0xa0, 0x32, 0xb4, 0x6b, 0x7a, 0xa9, 0x1f, 0xe6, 0xfd, 0xe4, 0x50,
0x43, 0xd2, 0x9c, 0xc0, 0x09, 0x07, 0xdd, 0x82, 0x35, 0x29, 0x67, 0xf6, 0x46, 0xab, 0xb0, 0x55,
0xe9, 0x95, 0xe7, 0xe7, 0xcd, 0xb5, 0xa3, 0xa3, 0x67, 0x58, 0xd9, 0x54, 0xb5, 0x98, 0xf0, 0x50,
0xfa, 0x64, 0x4a, 0xed, 0x2b, 0x7a, 0x6f, 0xd3, 0x39, 0x7a, 0x06, 0xe0, 0xfa, 0xe1, 0xc8, 0xd1,
0xd7, 0x93, 0x7d, 0x55, 0xaf, 0xee, 0xd3, 0xcb, 0x57, 0xd7, 0x3f, 0x38, 0x34, 0x15, 0x73, 0x63,
0x7e, 0xde, 0xac, 0xa6, 0x53, 0x5c, 0x75, 0xfd, 0x30, 0x1e, 0xa2, 0x1e, 0x58, 0x13, 0x4a, 0x3c,
0x39, 0x71, 0x26, 0xd4, 0x39, 0xb5, 0xeb, 0x17, 0x97, 0xc0, 0x87, 0x1a, 0x66, 0x3c, 0x64, 0x49,
0x4a, 0xc1, 0x2a, 0xd4, 0xd0, 0xbe, 0xa6, 0xf7, 0x2a, 0x9e, 0xa0, 0x0f, 0x00, 0x78, 0x40, 0xfd,
0x51, 0x28, 0x5d, 0xe6, 0xdb, 0x48, 0x2d, 0x19, 0x57, 0x95, 0xe5, 0x50, 0x19, 0xd0, 0x6d, 0x55,
0xa0, 0x88, 0x3b, 0xe2, 0xbe, 0x37, 0xb3, 0xdf, 0xd3, 0x5f, 0x2b, 0xca, 0xf0, 0xc4, 0xf7, 0x66,
0xa8, 0x09, 0x96, 0xd6, 0x45, 0xc8, 0xc6, 0x3e, 0xf1, 0xec, 0xeb, 0x7a, 0x3f, 0x40, 0x99, 0x0e,
0xb5, 0x45, 0x9d, 0x43, 0xbc, 0x1b, 0xa1, 0x7d, 0xe3, 0xe2, 0x73, 0x30, 0xc1, 0x2e, 0xce, 0xc1,
0x70, 0xd0, 0xcf, 0x00, 0x02, 0xc1, 0xce, 0x98, 0x47, 0xc7, 0x34, 0xb4, 0x6f, 0xea, 0x45, 0x6f,
0xe6, 0x56, 0xa6, 0x14, 0x85, 0x33, 0x0c, 0xd4, 0x04, 0x60, 0x3e, 0x93, 0xa3, 0x33, 0xe2, 0x45,
0xd4, 0x7e, 0x5f, 0x45, 0xaf, 0xca, 0xaf, 0xb2, 0x3d, 0x55, 0xa6, 0xc6, 0xe7, 0x60, 0x65, 0xd2,
0x51, 0xa5, 0xd1, 0x29, 0x9d, 0x99, 0x0c, 0x57, 0x43, 0xb5, 0x67, 0x31, 0x79, 0x35, 0xce, 0x7a,
0x3d, 0xf9, 0x62, 0xf5, 0x7e, 0xa1, 0xb1, 0x03, 0x56, 0x46, 0x96, 0xe8, 0x43, 0x75, 0x3d, 0x8e,
0x59, 0x28, 0xc5, 0x6c, 0x44, 0x22, 0x39, 0xb1, 0x7f, 0xa1, 0x09, 0xb5, 0xc4, 0xd8, 0x8d, 0xe4,
0xa4, 0x31, 0x82, 0xc5, 0xe9, 0xa2, 0x16, 0x58, 0x4a, 0x35, 0x21, 0x15, 0x67, 0x54, 0xa8, 0xd6,
0x43, 0x1d, 0x4a, 0xd6, 0xa4, 0xd4, 0x1d, 0x52, 0x22, 0x9c, 0x89, 0xbe, 0x5c, 0xaa, 0xd8, 0xcc,
0xd4, 0x6d, 0x91, 0xa4, 0x90, 0xb9, 0x2d, 0xcc, 0x54, 0x35, 0x3a, 0x6a, 0x71, 0xed, 0x7f, 0x17,
0xa0, 0x96, 0xed, 0xa4, 0xd0, 0x6e, 0xdc, 0x01, 0xe9, 0xa5, 0x5d, 0xd9, 0xd9, 0xbe, 0xac, 0xf3,
0xd2, 0x37, 0xb8, 0x17, 0x29, 0xa7, 0x8f, 0xd5, 0xa3, 0x47, 0x93, 0xd1, 0x8f, 0x61, 0x3d, 0xe0,
0x42, 0x26, 0x77, 0x5d, 0xfe, 0x49, 0x70, 0x91, 0xd4, 0xe7, 0x18, 0xdc, 0x9e, 0xc0, 0x95, 0x65,
0x6f, 0xe8, 0x2e, 0xac, 0x3d, 0xdd, 0x1f, 0xd6, 0x57, 0x1a, 0xb7, 0x9f, 0xbf, 0x68, 0xbd, 0xbf,
0xfc, 0xf1, 0x29, 0x13, 0x32, 0x22, 0xde, 0xfe, 0x10, 0x7d, 0x02, 0xeb, 0xfd, 0x83, 0x43, 0x8c,
0xeb, 0x85, 0x46, 0xf3, 0xf9, 0x8b, 0xd6, 0xed, 0x65, 0x9c, 0xfa, 0xc4, 0x23, 0xdf, 0xc5, 0xfc,
0x38, 0x7d, 0x00, 0xfc, 0x67, 0x15, 0x2c, 0x53, 0x02, 0xde, 0xf5, 0x1b, 0x71, 0x23, 0xee, 0x6f,
0x92, 0xdc, 0x5e, 0xbd, 0xb4, 0xcd, 0xa9, 0xc5, 0x04, 0x73, 0xd6, 0x77, 0xa0, 0xc6, 0x82, 0xb3,
0xcf, 0x46, 0xd4, 0x27, 0xc7, 0x9e, 0x79, 0x0b, 0x54, 0xb0, 0xa5, 0x6c, 0x83, 0xd8, 0xa4, 0x2e,
0x16, 0xe6, 0x4b, 0x2a, 0x7c, 0xd3, 0xe5, 0x57, 0x70, 0x3a, 0x47, 0x5f, 0x42, 0x91, 0x05, 0x64,
0x6a, 0x7a, 0xb3, 0xdc, 0x15, 0xec, 0x0f, 0xbb, 0x8f, 0x8d, 0x16, 0x7b, 0x95, 0xf9, 0x79, 0xb3,
0xa8, 0x0c, 0x58, 0xd3, 0xd0, 0x66, 0xd2, 0x1e, 0xa9, 0x3f, 0xe9, 0x22, 0x51, 0xc1, 0x19, 0x8b,
0xd2, 0x13, 0xf3, 0xc7, 0x82, 0x86, 0xa1, 0x2e, 0x17, 0x15, 0x9c, 0x4c, 0x51, 0x03, 0xca, 0xa6,
0xc9, 0xd2, 0x5d, 0x55, 0x55, 0x35, 0x30, 0xc6, 0xd0, 0xdb, 0x00, 0x2b, 0xde, 0x8d, 0xd1, 0x89,
0xe0, 0xd3, 0xf6, 0x7f, 0x8b, 0x60, 0xed, 0x7a, 0x51, 0x28, 0x4d, 0xbd, 0x7c, 0x67, 0x9b, 0xff,
0x0c, 0xae, 0x11, 0xfd, 0xe6, 0x24, 0xbe, 0x2a, 0x3e, 0xba, 0x77, 0x35, 0x07, 0x70, 0x37, 0xd7,
0x5d, 0x0a, 0x8e, 0xfb, 0xdc, 0x5e, 0x49, 0xf9, 0xb4, 0x0b, 0xb8, 0x4e, 0x5e, 0xf9, 0x82, 0x0e,
0x61, 0x83, 0x0b, 0x67, 0x42, 0x43, 0x19, 0x97, 0x2c, 0xf3, 0x46, 0xcb, 0x7d, 0xbd, 0x3f, 0xc9,
0x02, 0xcd, 0x7d, 0x1d, 0x47, 0xbb, 0xec, 0x03, 0xdd, 0x87, 0xa2, 0x20, 0x27, 0x49, 0x1f, 0x9e,
0x9b, 0x24, 0x98, 0x9c, 0xc8, 0x25, 0x17, 0x9a, 0x81, 0x7e, 0x05, 0xe0, 0xb2, 0x30, 0x20, 0xd2,
0x99, 0x50, 0x61, 0x0e, 0x3b, 0x77, 0x89, 0xfd, 0x14, 0xb5, 0xe4, 0x25, 0xc3, 0x46, 0x8f, 0xa0,
0xea, 0x90, 0x44, 0xae, 0xa5, 0x8b, 0x1f, 0xae, 0xbb, 0x5d, 0xe3, 0xa2, 0xae, 0x5c, 0xcc, 0xcf,
0x9b, 0x95, 0xc4, 0x82, 0x2b, 0x0e, 0x31, 0xf2, 0x7d, 0x04, 0x1b, 0xea, 0x41, 0x3b, 0x72, 0xe9,
0x09, 0x89, 0x3c, 0x19, 0xcb, 0xe4, 0x82, 0xfa, 0xa3, 0x5e, 0x47, 0x7d, 0x83, 0x33, 0x71, 0xd5,
0x64, 0xc6, 0x86, 0x7e, 0x03, 0xd7, 0xa8, 0xef, 0x88, 0x99, 0x16, 0x6b, 0x12, 0x61, 0xe5, 0xe2,
0xc5, 0x0e, 0x52, 0xf0, 0xd2, 0x62, 0xeb, 0xf4, 0x15, 0x7b, 0xfb, 0x9f, 0x05, 0x80, 0xb8, 0xa4,
0xbf, 0x5b, 0x01, 0x22, 0x28, 0xba, 0x44, 0x12, 0xad, 0xb9, 0x1a, 0xd6, 0x63, 0xf4, 0x05, 0x80,
0xa4, 0xd3, 0xc0, 0x23, 0x92, 0xf9, 0x63, 0x23, 0x9b, 0x37, 0x5d, 0x07, 0x19, 0x34, 0xda, 0x81,
0x92, 0x79, 0x2d, 0x15, 0x2f, 0xe5, 0x19, 0x64, 0xfb, 0x2f, 0x05, 0x80, 0x78, 0x99, 0xdf, 0xe9,
0xb5, 0xf5, 0xec, 0x97, 0xdf, 0x6e, 0xae, 0xfc, 0xe3, 0xdb, 0xcd, 0x95, 0x3f, 0xcc, 0x37, 0x0b,
0x2f, 0xe7, 0x9b, 0x85, 0xbf, 0xcf, 0x37, 0x0b, 0xff, 0x9a, 0x6f, 0x16, 0x8e, 0x4b, 0xba, 0x41,
0xfc, 0xd1, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x4f, 0xdf, 0x5d, 0x60, 0x83, 0x14, 0x00, 0x00,
// 1975 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xcf, 0x6f, 0x1b, 0xb9,
0x15, 0xb6, 0x6c, 0x59, 0x3f, 0xde, 0xc8, 0x89, 0xc2, 0xcd, 0xa6, 0x13, 0xa5, 0x6b, 0x2b, 0xda,
0x6c, 0xea, 0xdd, 0x45, 0x25, 0xd4, 0x2d, 0xb6, 0xd9, 0x4d, 0xb7, 0xad, 0x64, 0xa9, 0x8e, 0x9b,
0xc6, 0x11, 0x68, 0x6f, 0xda, 0x00, 0x05, 0x04, 0x6a, 0x86, 0x1e, 0x0d, 0x3c, 0x1a, 0x4e, 0x39,
0x1c, 0x2d, 0x74, 0xeb, 0x71, 0x91, 0x1e, 0x7b, 0x0e, 0x7a, 0x28, 0x7a, 0xef, 0x9f, 0x91, 0x63,
0x8f, 0xed, 0xc5, 0xe8, 0xea, 0x5f, 0xe8, 0xad, 0x97, 0x16, 0xe4, 0x70, 0x46, 0xa3, 0x64, 0x6c,
0x07, 0x68, 0x0e, 0xbd, 0x91, 0x8f, 0xdf, 0xf7, 0x48, 0x3e, 0x7e, 0x8f, 0x7c, 0x84, 0x4f, 0x1c,
0x57, 0x4c, 0xa2, 0x71, 0xdb, 0x62, 0xd3, 0x8e, 0xcd, 0xac, 0x33, 0xca, 0x3b, 0xe1, 0xd7, 0x84,
0x4f, 0xcf, 0x5c, 0xd1, 0x21, 0x81, 0xdb, 0x09, 0x03, 0x6a, 0x85, 0xed, 0x80, 0x33, 0xc1, 0x10,
0x8a, 0x01, 0xed, 0x04, 0xd0, 0x9e, 0xfd, 0xa0, 0x71, 0x15, 0x5f, 0xcc, 0x03, 0xaa, 0xf9, 0x8d,
0x9b, 0x0e, 0x73, 0x98, 0x6a, 0x76, 0x64, 0x4b, 0x5b, 0xb7, 0x1d, 0xc6, 0x1c, 0x8f, 0x76, 0x54,
0x6f, 0x1c, 0x9d, 0x76, 0xec, 0x88, 0x13, 0xe1, 0x32, 0x5f, 0x8f, 0xdf, 0x7e, 0x7d, 0x9c, 0xf8,
0xf3, 0x78, 0xa8, 0xf5, 0xb2, 0x08, 0x95, 0x23, 0x66, 0xd3, 0xe3, 0x80, 0x5a, 0xe8, 0x00, 0x0c,
0xe2, 0xfb, 0x4c, 0x28, 0x6e, 0x68, 0x16, 0x9a, 0x85, 0x5d, 0x63, 0x6f, 0xa7, 0xfd, 0xe6, 0x9a,
0xdb, 0xdd, 0x25, 0xac, 0x57, 0x7c, 0x75, 0xbe, 0xb3, 0x86, 0xb3, 0x4c, 0xf4, 0x33, 0xa8, 0xd9,
0x34, 0x74, 0x39, 0xb5, 0x47, 0x9c, 0x79, 0xd4, 0x5c, 0x6f, 0x16, 0x76, 0xaf, 0xed, 0x7d, 0x37,
0xcf, 0x93, 0x9c, 0x1c, 0x33, 0x8f, 0x62, 0x43, 0x33, 0x64, 0x07, 0x1d, 0x00, 0x4c, 0xe9, 0x74,
0x4c, 0x79, 0x38, 0x71, 0x03, 0x73, 0x43, 0xd1, 0xbf, 0x77, 0x11, 0x5d, 0xae, 0xbd, 0xfd, 0x24,
0x85, 0xe3, 0x0c, 0x15, 0x3d, 0x81, 0x1a, 0x99, 0x11, 0xd7, 0x23, 0x63, 0xd7, 0x73, 0xc5, 0xdc,
0x2c, 0x2a, 0x57, 0x1f, 0x5f, 0xea, 0xaa, 0x9b, 0x21, 0xe0, 0x15, 0x7a, 0xcb, 0x06, 0x58, 0x4e,
0x84, 0xee, 0x43, 0x79, 0x38, 0x38, 0xea, 0x1f, 0x1e, 0x1d, 0xd4, 0xd7, 0x1a, 0xb7, 0x5f, 0xbc,
0x6c, 0xbe, 0x2f, 0x7d, 0x2c, 0x01, 0x43, 0xea, 0xdb, 0xae, 0xef, 0xa0, 0x5d, 0xa8, 0x74, 0xf7,
0xf7, 0x07, 0xc3, 0x93, 0x41, 0xbf, 0x5e, 0x68, 0x34, 0x5e, 0xbc, 0x6c, 0xde, 0x5a, 0x05, 0x76,
0x2d, 0x8b, 0x06, 0x82, 0xda, 0x8d, 0xe2, 0x37, 0x7f, 0xde, 0x5e, 0x6b, 0x7d, 0x53, 0x80, 0x5a,
0x76, 0x11, 0xe8, 0x3e, 0x94, 0xba, 0xfb, 0x27, 0x87, 0xcf, 0x06, 0xf5, 0xb5, 0x25, 0x3d, 0x8b,
0xe8, 0x5a, 0xc2, 0x9d, 0x51, 0x74, 0x0f, 0x36, 0x87, 0xdd, 0xaf, 0x8e, 0x07, 0xf5, 0xc2, 0x72,
0x39, 0x59, 0xd8, 0x90, 0x44, 0xa1, 0x42, 0xf5, 0x71, 0xf7, 0xf0, 0xa8, 0xbe, 0x9e, 0x8f, 0xea,
0x73, 0xe2, 0xfa, 0x7a, 0x29, 0x7f, 0x2a, 0x82, 0x71, 0x4c, 0xf9, 0xcc, 0xb5, 0xde, 0xb1, 0x44,
0x3e, 0x83, 0xa2, 0x20, 0xe1, 0x99, 0x92, 0x86, 0x91, 0x2f, 0x8d, 0x13, 0x12, 0x9e, 0xc9, 0x49,
0x35, 0x5d, 0xe1, 0xa5, 0x32, 0x38, 0x0d, 0x3c, 0xd7, 0x22, 0x82, 0xda, 0x4a, 0x19, 0xc6, 0xde,
0x47, 0x79, 0x6c, 0x9c, 0xa2, 0xf4, 0xfa, 0x1f, 0xad, 0xe1, 0x0c, 0x15, 0x3d, 0x84, 0x92, 0xe3,
0xb1, 0x31, 0xf1, 0x94, 0x26, 0x8c, 0xbd, 0xbb, 0x79, 0x4e, 0x0e, 0x14, 0x62, 0xe9, 0x40, 0x53,
0xd0, 0x03, 0x28, 0x45, 0x81, 0x4d, 0x04, 0x35, 0x4b, 0x8a, 0xdc, 0xcc, 0x23, 0x7f, 0xa5, 0x10,
0xfb, 0xcc, 0x3f, 0x75, 0x1d, 0xac, 0xf1, 0xe8, 0x31, 0x54, 0x7c, 0x2a, 0xbe, 0x66, 0xfc, 0x2c,
0x34, 0xcb, 0xcd, 0x8d, 0x5d, 0x63, 0xef, 0xd3, 0x5c, 0x31, 0xc6, 0x98, 0xae, 0x10, 0xc4, 0x9a,
0x4c, 0xa9, 0x2f, 0x62, 0x37, 0xbd, 0x75, 0xb3, 0x80, 0x53, 0x07, 0xe8, 0x27, 0x50, 0xa1, 0xbe,
0x1d, 0x30, 0xd7, 0x17, 0x66, 0xe5, 0xe2, 0x85, 0x0c, 0x34, 0x46, 0x06, 0x13, 0xa7, 0x0c, 0xc9,
0xe6, 0xcc, 0xf3, 0xc6, 0xc4, 0x3a, 0x33, 0xab, 0x6f, 0xb9, 0x8d, 0x94, 0xd1, 0x2b, 0x41, 0x71,
0xca, 0x6c, 0xda, 0xea, 0xc0, 0x8d, 0x37, 0x42, 0x8d, 0x1a, 0x50, 0xd1, 0xa1, 0x8e, 0x35, 0x52,
0xc4, 0x69, 0xbf, 0x75, 0x1d, 0xb6, 0x56, 0xc2, 0xda, 0xfa, 0xeb, 0x26, 0x54, 0x92, 0xb3, 0x46,
0x5d, 0xa8, 0x5a, 0xcc, 0x17, 0xc4, 0xf5, 0x29, 0xd7, 0xf2, 0xca, 0x3d, 0x99, 0xfd, 0x04, 0x24,
0x59, 0x8f, 0xd6, 0xf0, 0x92, 0x85, 0x7e, 0x01, 0x55, 0x4e, 0x43, 0x16, 0x71, 0x8b, 0x86, 0x5a,
0x5f, 0xbb, 0xf9, 0x0a, 0x89, 0x41, 0x98, 0xfe, 0x2e, 0x72, 0x39, 0x95, 0x51, 0x0e, 0xf1, 0x92,
0x8a, 0x1e, 0x42, 0x99, 0xd3, 0x50, 0x10, 0x2e, 0x2e, 0x93, 0x08, 0x8e, 0x21, 0x43, 0xe6, 0xb9,
0xd6, 0x1c, 0x27, 0x0c, 0xf4, 0x10, 0xaa, 0x81, 0x47, 0x2c, 0xe5, 0xd5, 0xdc, 0x54, 0xf4, 0x0f,
0xf2, 0xe8, 0xc3, 0x04, 0x84, 0x97, 0x78, 0xf4, 0x39, 0x80, 0xc7, 0x9c, 0x91, 0xcd, 0xdd, 0x19,
0xe5, 0x5a, 0x62, 0x8d, 0x3c, 0x76, 0x5f, 0x21, 0x70, 0xd5, 0x63, 0x4e, 0xdc, 0x44, 0x07, 0xff,
0x93, 0xbe, 0x32, 0xda, 0x7a, 0x0c, 0x40, 0xd2, 0x51, 0xad, 0xae, 0x8f, 0xdf, 0xca, 0x95, 0x3e,
0x91, 0x0c, 0x1d, 0xdd, 0x85, 0xda, 0x29, 0xe3, 0x16, 0x1d, 0xe9, 0xac, 0xa9, 0x2a, 0x4d, 0x18,
0xca, 0x16, 0xeb, 0x0b, 0xf5, 0xa0, 0xec, 0x50, 0x9f, 0x72, 0xd7, 0x32, 0x41, 0x4d, 0x76, 0x3f,
0x37, 0x21, 0x63, 0x08, 0x8e, 0x7c, 0xe1, 0x4e, 0xa9, 0x9e, 0x29, 0x21, 0xa2, 0xdf, 0xc2, 0x7b,
0xc9, 0xf1, 0x8d, 0x38, 0x3d, 0xa5, 0x9c, 0xfa, 0x52, 0x03, 0x86, 0x8a, 0xc3, 0x47, 0x97, 0x6b,
0x40, 0xa3, 0xf5, 0x65, 0x83, 0xf8, 0xeb, 0x03, 0x61, 0xaf, 0x0a, 0x65, 0x1e, 0xcf, 0xdb, 0xfa,
0x43, 0x41, 0xaa, 0xfe, 0x35, 0x04, 0xea, 0x80, 0x91, 0x4e, 0xef, 0xda, 0x4a, 0xbd, 0xd5, 0xde,
0xb5, 0xc5, 0xf9, 0x0e, 0x24, 0xd8, 0xc3, 0xbe, 0xbc, 0x83, 0x74, 0xdb, 0x46, 0x03, 0xd8, 0x4a,
0x09, 0xf2, 0x99, 0xd7, 0x0f, 0x65, 0xf3, 0xb2, 0x95, 0x9e, 0xcc, 0x03, 0x8a, 0x6b, 0x3c, 0xd3,
0x6b, 0xfd, 0x06, 0xd0, 0x9b, 0x71, 0x41, 0x08, 0x8a, 0x67, 0xae, 0xaf, 0x97, 0x81, 0x55, 0x1b,
0xb5, 0xa1, 0x1c, 0x90, 0xb9, 0xc7, 0x88, 0xad, 0x13, 0xe3, 0x66, 0x3b, 0xae, 0x0d, 0xda, 0x49,
0x6d, 0xd0, 0xee, 0xfa, 0x73, 0x9c, 0x80, 0x5a, 0x8f, 0xe1, 0xfd, 0xdc, 0xe3, 0x45, 0x7b, 0x50,
0x4b, 0x13, 0x6e, 0xb9, 0xd7, 0xeb, 0x8b, 0xf3, 0x1d, 0x23, 0xcd, 0xcc, 0xc3, 0x3e, 0x36, 0x52,
0xd0, 0xa1, 0xdd, 0xfa, 0x63, 0x15, 0xb6, 0x56, 0xd2, 0x16, 0xdd, 0x84, 0x4d, 0x77, 0x4a, 0x1c,
0xaa, 0xd7, 0x18, 0x77, 0xd0, 0x00, 0x4a, 0x1e, 0x19, 0x53, 0x4f, 0x26, 0xaf, 0x3c, 0xb8, 0xef,
0x5f, 0x99, 0xff, 0xed, 0x5f, 0x29, 0xfc, 0xc0, 0x17, 0x7c, 0x8e, 0x35, 0x19, 0x99, 0x50, 0xb6,
0xd8, 0x74, 0x4a, 0x7c, 0xf9, 0x4c, 0x6c, 0xec, 0x56, 0x71, 0xd2, 0x95, 0x91, 0x21, 0xdc, 0x09,
0xcd, 0xa2, 0x32, 0xab, 0x36, 0xaa, 0xc3, 0x06, 0xf5, 0x67, 0xe6, 0xa6, 0x32, 0xc9, 0xa6, 0xb4,
0xd8, 0x6e, 0x9c, 0x7d, 0x55, 0x2c, 0x9b, 0x92, 0x17, 0x85, 0x94, 0x9b, 0xe5, 0x38, 0xa2, 0xb2,
0x8d, 0x7e, 0x0c, 0xa5, 0x29, 0x8b, 0x7c, 0x11, 0x9a, 0x15, 0xb5, 0xd8, 0xdb, 0x79, 0x8b, 0x7d,
0x22, 0x11, 0x5a, 0x59, 0x1a, 0x8e, 0x06, 0x70, 0x23, 0x14, 0x2c, 0x18, 0x39, 0x9c, 0x58, 0x74,
0x14, 0x50, 0xee, 0x32, 0x5b, 0x5f, 0xc3, 0xb7, 0xdf, 0x38, 0x94, 0xbe, 0x2e, 0xe8, 0xf0, 0x75,
0xc9, 0x39, 0x90, 0x94, 0xa1, 0x62, 0xa0, 0x21, 0xd4, 0x82, 0xc8, 0xf3, 0x46, 0x2c, 0x88, 0x5f,
0xe4, 0x38, 0x77, 0xde, 0x22, 0x64, 0xc3, 0xc8, 0xf3, 0x9e, 0xc6, 0x24, 0x6c, 0x04, 0xcb, 0x0e,
0xba, 0x05, 0x25, 0x87, 0xb3, 0x28, 0x88, 0xf3, 0xa6, 0x8a, 0x75, 0x0f, 0x7d, 0x09, 0xe5, 0x90,
0x5a, 0x9c, 0x8a, 0xd0, 0xac, 0xa9, 0xad, 0x7e, 0x98, 0x37, 0xc9, 0xb1, 0x82, 0xa4, 0x39, 0x81,
0x13, 0x0e, 0xba, 0x0d, 0x1b, 0x42, 0xcc, 0xcd, 0xad, 0x66, 0x61, 0xb7, 0xd2, 0x2b, 0x2f, 0xce,
0x77, 0x36, 0x4e, 0x4e, 0x9e, 0x63, 0x69, 0x93, 0xaf, 0xc5, 0x84, 0x85, 0xc2, 0x27, 0x53, 0x6a,
0x5e, 0x53, 0xb1, 0x4d, 0xfb, 0xe8, 0x39, 0x80, 0xed, 0x87, 0x23, 0x4b, 0x5d, 0x4f, 0xe6, 0x75,
0xb5, 0xbb, 0x4f, 0xaf, 0xde, 0x5d, 0xff, 0xe8, 0x58, 0xbf, 0x98, 0x5b, 0x8b, 0xf3, 0x9d, 0x6a,
0xda, 0xc5, 0x55, 0xdb, 0x0f, 0xe3, 0x26, 0xea, 0x81, 0x31, 0xa1, 0xc4, 0x13, 0x13, 0x6b, 0x42,
0xad, 0x33, 0xb3, 0x7e, 0xf1, 0x13, 0xf8, 0x48, 0xc1, 0xb4, 0x87, 0x2c, 0x49, 0x2a, 0x58, 0x2e,
0x35, 0x34, 0x6f, 0xa8, 0x58, 0xc5, 0x1d, 0xf4, 0x01, 0x00, 0x0b, 0xa8, 0x3f, 0x0a, 0x85, 0xed,
0xfa, 0x26, 0x92, 0x5b, 0xc6, 0x55, 0x69, 0x39, 0x96, 0x06, 0x74, 0x47, 0x3e, 0x50, 0xc4, 0x1e,
0x31, 0xdf, 0x9b, 0x9b, 0xef, 0xa9, 0xd1, 0x8a, 0x34, 0x3c, 0xf5, 0xbd, 0x39, 0xda, 0x01, 0x43,
0xe9, 0x22, 0x74, 0x1d, 0x9f, 0x78, 0xe6, 0x4d, 0x15, 0x0f, 0x90, 0xa6, 0x63, 0x65, 0x91, 0xe7,
0x10, 0x47, 0x23, 0x34, 0xdf, 0xbf, 0xf8, 0x1c, 0xf4, 0x62, 0x97, 0xe7, 0xa0, 0x39, 0xe8, 0xa7,
0x00, 0x01, 0x77, 0x67, 0xae, 0x47, 0x1d, 0x1a, 0x9a, 0xb7, 0xd4, 0xa6, 0xb7, 0x73, 0x5f, 0xa6,
0x14, 0x85, 0x33, 0x8c, 0xc6, 0xe7, 0x60, 0x64, 0xb2, 0x4d, 0x66, 0xc9, 0x19, 0x9d, 0xeb, 0x04,
0x96, 0x4d, 0x19, 0x92, 0x19, 0xf1, 0xa2, 0xf8, 0x32, 0xab, 0xe2, 0xb8, 0xf3, 0xc5, 0xfa, 0x83,
0x42, 0x63, 0x0f, 0x8c, 0x8c, 0xea, 0xd0, 0x87, 0xf2, 0xf6, 0x73, 0xdc, 0x50, 0xf0, 0xf9, 0x88,
0x44, 0x62, 0x62, 0xfe, 0x5c, 0x11, 0x6a, 0x89, 0xb1, 0x1b, 0x89, 0x49, 0x63, 0x04, 0xcb, 0xc3,
0x43, 0x4d, 0x30, 0xa4, 0x28, 0x42, 0xca, 0x67, 0x94, 0xcb, 0xca, 0x42, 0xc6, 0x3c, 0x6b, 0x92,
0xe2, 0x0d, 0x29, 0xe1, 0xd6, 0x44, 0xdd, 0x1d, 0x55, 0xac, 0x7b, 0xf2, 0x32, 0x48, 0x32, 0x44,
0x5f, 0x06, 0xba, 0xdb, 0xfa, 0x57, 0x01, 0x6a, 0xd9, 0x02, 0x09, 0xed, 0xc7, 0x85, 0x8d, 0xda,
0xd2, 0xb5, 0xbd, 0xce, 0x55, 0x05, 0x95, 0xba, 0x98, 0xbd, 0x48, 0x3a, 0x7b, 0x22, 0xff, 0x32,
0x8a, 0x8c, 0x7e, 0x04, 0x9b, 0x01, 0xe3, 0x22, 0xb9, 0xc2, 0xf2, 0x03, 0xcc, 0x78, 0xf2, 0xec,
0xc6, 0xe0, 0xd6, 0x04, 0xae, 0xad, 0x7a, 0x43, 0xf7, 0x60, 0xe3, 0xd9, 0xe1, 0xb0, 0xbe, 0xd6,
0xb8, 0xf3, 0xe2, 0x65, 0xf3, 0x3b, 0xab, 0x83, 0xcf, 0x5c, 0x2e, 0x22, 0xe2, 0x1d, 0x0e, 0xd1,
0x27, 0xb0, 0xd9, 0x3f, 0x3a, 0xc6, 0xb8, 0x5e, 0x68, 0xec, 0xbc, 0x78, 0xd9, 0xbc, 0xb3, 0x8a,
0x93, 0x43, 0x2c, 0xf2, 0x6d, 0xcc, 0xc6, 0x69, 0x5d, 0xff, 0xef, 0x75, 0x30, 0xf4, 0xcd, 0xfe,
0xae, 0xbf, 0x7e, 0x5b, 0x71, 0xd9, 0x92, 0xa4, 0xec, 0xfa, 0x95, 0xd5, 0x4b, 0x2d, 0x26, 0xe8,
0x33, 0xbe, 0x0b, 0x35, 0x37, 0x98, 0x7d, 0x36, 0xa2, 0x3e, 0x19, 0x7b, 0xba, 0xc4, 0xaf, 0x60,
0x43, 0xda, 0x06, 0xb1, 0x49, 0xde, 0x17, 0xae, 0x2f, 0x28, 0xf7, 0x75, 0xf1, 0x5e, 0xc1, 0x69,
0x1f, 0x7d, 0x09, 0x45, 0x37, 0x20, 0x53, 0x5d, 0x72, 0xe5, 0xee, 0xe0, 0x70, 0xd8, 0x7d, 0xa2,
0x35, 0xd8, 0xab, 0x2c, 0xce, 0x77, 0x8a, 0xd2, 0x80, 0x15, 0x0d, 0x6d, 0x27, 0x55, 0x8f, 0x9c,
0x49, 0xdd, 0xfd, 0x15, 0x9c, 0xb1, 0x48, 0x1d, 0xb9, 0xbe, 0xc3, 0x69, 0x18, 0xaa, 0x57, 0xa0,
0x82, 0x93, 0x2e, 0x6a, 0x40, 0x59, 0xd7, 0x4e, 0xaa, 0x58, 0xaa, 0xca, 0xba, 0x44, 0x1b, 0x7a,
0x5b, 0x60, 0xc4, 0xd1, 0x18, 0x9d, 0x72, 0x36, 0x6d, 0xfd, 0xa7, 0x08, 0xc6, 0xbe, 0x17, 0x85,
0x42, 0x3f, 0x83, 0xef, 0x2c, 0xf8, 0xcf, 0xe1, 0x06, 0x51, 0x5f, 0x49, 0xe2, 0xcb, 0x37, 0x45,
0x95, 0xa4, 0xfa, 0x00, 0xee, 0xe5, 0xba, 0x4b, 0xc1, 0x71, 0xf9, 0xda, 0x2b, 0x49, 0x9f, 0x66,
0x01, 0xd7, 0xc9, 0x6b, 0x23, 0xe8, 0x18, 0xb6, 0x18, 0xb7, 0x26, 0x34, 0x14, 0xf1, 0x4b, 0xa4,
0xbf, 0x5e, 0xb9, 0x9f, 0xf2, 0xa7, 0x59, 0xa0, 0xbe, 0x86, 0xe3, 0xd5, 0xae, 0xfa, 0x40, 0x0f,
0xa0, 0xc8, 0xc9, 0x69, 0x52, 0x5e, 0xe7, 0x26, 0x09, 0x26, 0xa7, 0x62, 0xc5, 0x85, 0x62, 0xa0,
0x5f, 0x02, 0xd8, 0x6e, 0x18, 0x10, 0x61, 0x4d, 0x28, 0xd7, 0x87, 0x9d, 0xbb, 0xc5, 0x7e, 0x8a,
0x5a, 0xf1, 0x92, 0x61, 0xa3, 0xc7, 0x50, 0xb5, 0x48, 0x22, 0xd7, 0xd2, 0xc5, 0xff, 0xd1, 0xfd,
0xae, 0x76, 0x51, 0x97, 0x2e, 0x16, 0xe7, 0x3b, 0x95, 0xc4, 0x82, 0x2b, 0x16, 0xd1, 0xf2, 0x7d,
0x0c, 0x5b, 0xf2, 0x9f, 0x3a, 0xb2, 0xe9, 0x29, 0x89, 0x3c, 0x11, 0xcb, 0xe4, 0x82, 0x67, 0x45,
0x7e, 0x7a, 0xfa, 0x1a, 0xa7, 0xd7, 0x55, 0x13, 0x19, 0x1b, 0xfa, 0x35, 0xdc, 0xa0, 0xbe, 0xc5,
0xe7, 0x4a, 0xac, 0xc9, 0x0a, 0x2b, 0x17, 0x6f, 0x76, 0x90, 0x82, 0x57, 0x36, 0x5b, 0xa7, 0xaf,
0xd9, 0x5b, 0xff, 0x28, 0x00, 0xc4, 0x2f, 0xf5, 0xbb, 0x15, 0x20, 0x82, 0xa2, 0x4d, 0x04, 0x51,
0x9a, 0xab, 0x61, 0xd5, 0x46, 0x5f, 0x00, 0x08, 0x3a, 0x0d, 0x3c, 0x22, 0x5c, 0xdf, 0xd1, 0xb2,
0xb9, 0xec, 0x3a, 0xc8, 0xa0, 0xd1, 0x1e, 0x94, 0xf4, 0x27, 0xa8, 0x78, 0x25, 0x4f, 0x23, 0x5b,
0x7f, 0x29, 0x00, 0xc4, 0xdb, 0xfc, 0xbf, 0xde, 0x5b, 0xcf, 0x7c, 0xf5, 0xed, 0xf6, 0xda, 0xdf,
0xbf, 0xdd, 0x5e, 0xfb, 0xfd, 0x62, 0xbb, 0xf0, 0x6a, 0xb1, 0x5d, 0xf8, 0xdb, 0x62, 0xbb, 0xf0,
0xcf, 0xc5, 0x76, 0x61, 0x5c, 0x52, 0x75, 0xdf, 0x0f, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xae,
0x88, 0xf9, 0x3c, 0x5a, 0x14, 0x00, 0x00,
}

5
components/engine/vendor/github.com/docker/swarmkit/api/specs.proto generated vendored
View File

@ -293,11 +293,6 @@ message ContainerSpec {
// task will exit and a new task will be rescheduled elsewhere. A container
// is considered unhealthy after `Retries` number of consecutive failures.
HealthConfig healthcheck = 16;
// Run a custom init inside the container, if null, use the daemon's configured settings
oneof init {
bool init_value = 23;
}
}
// EndpointSpec defines the properties that can be configured to

5
components/engine/vendor/github.com/docker/swarmkit/ca/keyreadwriter.go generated vendored
View File

@ -187,10 +187,7 @@ func (k *KeyReadWriter) ViewAndRotateKEK(cb func(KEKData, PEMKeyHeaders) (KEKDat
return err
}
if err := k.writeKey(keyBlock, updatedKEK, updatedHeaderObj); err != nil {
return err
}
return nil
return k.writeKey(keyBlock, updatedKEK, updatedHeaderObj)
}
// ViewAndUpdateHeaders updates the header manager, and updates any headers on the existing key

12
components/engine/vendor/github.com/docker/swarmkit/manager/allocator/cnmallocator/networkallocator.go generated vendored
View File

@ -459,8 +459,8 @@ func (na *cnmNetworkAllocator) DeallocateTask(t *api.Task) error {
return na.releaseEndpoints(t.Networks)
}
// IsLBAttachmentAllocated returns if the passed node and network has resources allocated or not.
func (na *cnmNetworkAllocator) IsLBAttachmentAllocated(node *api.Node, networkAttachment *api.NetworkAttachment) bool {
// IsAttachmentAllocated returns if the passed node and network has resources allocated or not.
func (na *cnmNetworkAllocator) IsAttachmentAllocated(node *api.Node, networkAttachment *api.NetworkAttachment) bool {
if node == nil {
return false
}
@ -500,9 +500,9 @@ func (na *cnmNetworkAllocator) IsLBAttachmentAllocated(node *api.Node, networkAt
return true
}
// AllocateLBAttachment allocates the IP addresses for a LB in a network
// AllocateAttachment allocates the IP addresses for a LB in a network
// on a given node
func (na *cnmNetworkAllocator) AllocateLBAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error {
func (na *cnmNetworkAllocator) AllocateAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error {
if err := na.allocateNetworkIPs(networkAttachment); err != nil {
return err
@ -516,9 +516,9 @@ func (na *cnmNetworkAllocator) AllocateLBAttachment(node *api.Node, networkAttac
return nil
}
// DeallocateLBAttachment deallocates the IP addresses for a LB in a network to
// DeallocateAttachment deallocates the IP addresses for a LB in a network to
// which the node is attached.
func (na *cnmNetworkAllocator) DeallocateLBAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error {
func (na *cnmNetworkAllocator) DeallocateAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error {
delete(na.nodes[node.ID], networkAttachment.Network.ID)
if len(na.nodes[node.ID]) == 0 {

36
components/engine/vendor/github.com/docker/swarmkit/manager/allocator/network.go generated vendored
View File

@ -172,11 +172,7 @@ func (a *Allocator) doNetworkInit(ctx context.Context) (err error) {
if err := a.allocateServices(ctx, false); err != nil {
return err
}
if err := a.allocateTasks(ctx, false); err != nil {
return err
}
return nil
return a.allocateTasks(ctx, false)
}
func (a *Allocator) doNetworkAlloc(ctx context.Context, ev events.Event) {
@ -510,7 +506,7 @@ func (a *Allocator) deallocateNodeAttachments(ctx context.Context, nid string) e
var networkAttachment *api.NetworkAttachment
var naIndex int
for index, na := range node.LbAttachments {
for index, na := range node.Attachments {
if na.Network.ID == nid {
networkAttachment = na
naIndex = index
@ -523,15 +519,15 @@ func (a *Allocator) deallocateNodeAttachments(ctx context.Context, nid string) e
continue
}
if nc.nwkAllocator.IsLBAttachmentAllocated(node, networkAttachment) {
if err := nc.nwkAllocator.DeallocateLBAttachment(node, networkAttachment); err != nil {
if nc.nwkAllocator.IsAttachmentAllocated(node, networkAttachment) {
if err := nc.nwkAllocator.DeallocateAttachment(node, networkAttachment); err != nil {
log.G(ctx).WithError(err).Errorf("Failed to commit deallocation of network resources for node %s", node.ID)
} else {
// Delete the lbattachment
node.LbAttachments[naIndex] = node.LbAttachments[len(node.LbAttachments)-1]
node.LbAttachments[len(node.LbAttachments)-1] = nil
node.LbAttachments = node.LbAttachments[:len(node.LbAttachments)-1]
node.Attachments[naIndex] = node.Attachments[len(node.Attachments)-1]
node.Attachments[len(node.Attachments)-1] = nil
node.Attachments = node.Attachments[:len(node.Attachments)-1]
if err := a.store.Batch(func(batch *store.Batch) error {
return a.commitAllocatedNode(ctx, batch, node)
@ -551,15 +547,15 @@ func (a *Allocator) deallocateNode(node *api.Node) error {
nc = a.netCtx
)
for _, na := range node.LbAttachments {
if nc.nwkAllocator.IsLBAttachmentAllocated(node, na) {
if err := nc.nwkAllocator.DeallocateLBAttachment(node, na); err != nil {
for _, na := range node.Attachments {
if nc.nwkAllocator.IsAttachmentAllocated(node, na) {
if err := nc.nwkAllocator.DeallocateAttachment(node, na); err != nil {
return err
}
}
}
node.LbAttachments = nil
node.Attachments = nil
return nil
}
@ -855,7 +851,7 @@ func (a *Allocator) allocateNode(ctx context.Context, node *api.Node, existingAd
for _, network := range networks {
var lbAttachment *api.NetworkAttachment
for _, na := range node.LbAttachments {
for _, na := range node.Attachments {
if na.Network != nil && na.Network.ID == network.ID {
lbAttachment = na
break
@ -863,14 +859,14 @@ func (a *Allocator) allocateNode(ctx context.Context, node *api.Node, existingAd
}
if lbAttachment != nil {
if nc.nwkAllocator.IsLBAttachmentAllocated(node, lbAttachment) {
if nc.nwkAllocator.IsAttachmentAllocated(node, lbAttachment) {
continue
}
}
if lbAttachment == nil {
lbAttachment = &api.NetworkAttachment{}
node.LbAttachments = append(node.LbAttachments, lbAttachment)
node.Attachments = append(node.Attachments, lbAttachment)
}
if existingAddressesOnly && len(lbAttachment.Addresses) == 0 {
@ -878,7 +874,7 @@ func (a *Allocator) allocateNode(ctx context.Context, node *api.Node, existingAd
}
lbAttachment.Network = network.Copy()
if err := a.netCtx.nwkAllocator.AllocateLBAttachment(node, lbAttachment); err != nil {
if err := a.netCtx.nwkAllocator.AllocateAttachment(node, lbAttachment); err != nil {
log.G(ctx).WithError(err).Errorf("Failed to allocate network resources for node %s", node.ID)
// TODO: Should we add a unallocatedNode and retry allocating resources like we do for network, tasks, services?
// right now, we will only retry allocating network resources for the node when the node is updated.
@ -897,7 +893,7 @@ func (a *Allocator) commitAllocatedNode(ctx context.Context, batch *store.Batch,
if err == store.ErrSequenceConflict {
storeNode := store.GetNode(tx, node.ID)
storeNode.LbAttachments = node.LbAttachments
storeNode.Attachments = node.Attachments
err = store.UpdateNode(tx, storeNode)
}

12
components/engine/vendor/github.com/docker/swarmkit/manager/allocator/networkallocator/networkallocator.go generated vendored
View File

@ -81,14 +81,14 @@ type NetworkAllocator interface {
// networks that a task is attached to.
DeallocateTask(t *api.Task) error
// AllocateLBAttachment Allocates a load balancer endpoint for the node
AllocateLBAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error
// AllocateAttachment Allocates a load balancer endpoint for the node
AllocateAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error
// DeallocateLBAttachment Deallocates a load balancer endpoint for the node
DeallocateLBAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error
// DeallocateAttachment Deallocates a load balancer endpoint for the node
DeallocateAttachment(node *api.Node, networkAttachment *api.NetworkAttachment) error
//IsLBAttachmentAllocated If lb endpoint is allocated on the node
IsLBAttachmentAllocated(node *api.Node, networkAttachment *api.NetworkAttachment) bool
// IsAttachmentAllocated If lb endpoint is allocated on the node
IsAttachmentAllocated(node *api.Node, networkAttachment *api.NetworkAttachment) bool
}
// IsIngressNetwork check if the network is an ingress network

6
components/engine/vendor/github.com/docker/swarmkit/manager/controlapi/network.go generated vendored
View File

@ -96,11 +96,7 @@ func validateNetworkSpec(spec *api.NetworkSpec, pg plugingetter.PluginGetter) er
return err
}
if err := validateIPAM(spec.IPAM, pg); err != nil {
return err
}
return nil
return validateIPAM(spec.IPAM, pg)
}
// CreateNetwork creates and returns a Network based on the provided NetworkSpec.

17
components/engine/vendor/github.com/docker/swarmkit/manager/controlapi/service.go generated vendored
View File

@ -56,10 +56,7 @@ func validateResourceRequirements(r *api.ResourceRequirements) error {
if err := validateResources(r.Limits); err != nil {
return err
}
if err := validateResources(r.Reservations); err != nil {
return err
}
return nil
return validateResources(r.Reservations)
}
func validateRestartPolicy(rp *api.RestartPolicy) error {
@ -161,11 +158,7 @@ func validateContainerSpec(taskSpec api.TaskSpec) error {
return err
}
if err := validateHealthCheck(container.Healthcheck); err != nil {
return err
}
return nil
return validateHealthCheck(container.Healthcheck)
}
// validateImage validates image name in containerSpec
@ -481,11 +474,7 @@ func validateServiceSpec(spec *api.ServiceSpec) error {
if err := validateEndpointSpec(spec.Endpoint); err != nil {
return err
}
if err := validateMode(spec); err != nil {
return err
}
return nil
return validateMode(spec)
}
// checkPortConflicts does a best effort to find if the passed in spec has port

5
components/engine/vendor/github.com/docker/swarmkit/manager/dispatcher/dispatcher.go generated vendored
View File

@ -854,10 +854,7 @@ func (d *Dispatcher) Assignments(r *api.AssignmentsRequest, stream api.Dispatche
appliesTo = msg.ResultsIn
msg.Type = assignmentType
if err := stream.Send(&msg); err != nil {
return err
}
return nil
return stream.Send(&msg)
}
// TODO(aaronl): Also send node secrets that should be exposed to

4
components/engine/vendor/github.com/docker/swarmkit/manager/manager.go generated vendored
View File

@ -54,6 +54,9 @@ import (
const (
// defaultTaskHistoryRetentionLimit is the number of tasks to keep.
defaultTaskHistoryRetentionLimit = 5
// Default value for grpc max message size.
grpcMaxMessageSize = 128 << 20
)
// RemoteAddrs provides a listening address and an optional advertise address
@ -231,6 +234,7 @@ func New(config *Config) (*Manager, error) {
grpc.Creds(config.SecurityConfig.ServerTLSCreds),
grpc.StreamInterceptor(grpc_prometheus.StreamServerInterceptor),
grpc.UnaryInterceptor(grpc_prometheus.UnaryServerInterceptor),
grpc.MaxMsgSize(grpcMaxMessageSize),
}
m := &Manager{

5
components/engine/vendor/github.com/docker/swarmkit/manager/orchestrator/update/updater.go generated vendored
View File

@ -384,10 +384,7 @@ func (u *Updater) updateTask(ctx context.Context, slot orchestrator.Slot, update
return errors.New("service was deleted")
}
if err := store.CreateTask(tx, updated); err != nil {
return err
}
return nil
return store.CreateTask(tx, updated)
})
if err != nil {
return err

6
components/engine/vendor/github.com/docker/swarmkit/manager/scheduler/scheduler.go generated vendored
View File

@ -92,11 +92,7 @@ func (s *Scheduler) setupTasksList(tx store.ReadTx) error {
tasksByNode[t.NodeID][t.ID] = t
}
if err := s.buildNodeSet(tx, tasksByNode); err != nil {
return err
}
return nil
return s.buildNodeSet(tx, tasksByNode)
}
// Run is the scheduler event loop.

10
components/engine/vendor/github.com/docker/swarmkit/manager/state/raft/raft.go generated vendored
View File

@ -1283,10 +1283,7 @@ func (n *Node) reportNewAddress(ctx context.Context, id uint64) error {
return err
}
newAddr := net.JoinHostPort(newHost, officialPort)
if err := n.transport.UpdatePeerAddr(id, newAddr); err != nil {
return err
}
return nil
return n.transport.UpdatePeerAddr(id, newAddr)
}
// ProcessRaftMessage calls 'Step' which advances the
@ -1848,10 +1845,7 @@ func (n *Node) applyAddNode(cc raftpb.ConfChange) error {
return nil
}
if err = n.registerNode(member); err != nil {
return err
}
return nil
return n.registerNode(member)
}
// applyUpdateNode is called when we receive a ConfChange from a member in the

5
components/engine/vendor/github.com/docker/swarmkit/manager/state/raft/storage/storage.go generated vendored
View File

@ -226,10 +226,7 @@ func (e *EncryptedRaftLogger) SaveSnapshot(snapshot raftpb.Snapshot) error {
if err := snapshotter.SaveSnap(snapshot); err != nil {
return err
}
if err := e.wal.ReleaseLockTo(snapshot.Metadata.Index); err != nil {
return err
}
return nil
return e.wal.ReleaseLockTo(snapshot.Metadata.Index)
}
// GC garbage collects snapshots and wals older than the provided index and term

5
components/engine/vendor/github.com/docker/swarmkit/manager/state/raft/transport/transport.go generated vendored
View File

@ -235,10 +235,7 @@ func (t *Transport) UpdatePeerAddr(id uint64, addr string) error {
if !ok {
return ErrIsNotFound
}
if err := p.updateAddr(addr); err != nil {
return err
}
return nil
return p.updateAddr(addr)
}
// PeerConn returns raw grpc connection to peer.