docker
/
docs
mirror of https://github.com/docker/docs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #23551 from tonistiigi/update-swarmkit 

Update swarmkit to 25572005f
This commit is contained in:
Arnaud Porterie 2016-06-15 02:25:31 +00:00 committed by GitHub
parent c0677565dc b38408fd02
commit 574f7d2149
32 changed files with 1477 additions and 1154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
daemon/cluster/cluster.go
View File

@ -998,13 +998,13 @@ func (c *Cluster) managerStats() (current bool, reachable int, unreachable int,
}
for _, n := range nodes.Nodes {
if n.ManagerStatus != nil {
if n.ManagerStatus.Raft.Status.Reachability == swarmapi.RaftMemberStatus_REACHABLE {
if n.ManagerStatus.Reachability == swarmapi.RaftMemberStatus_REACHABLE {
reachable++
if n.ID == c.node.NodeID() {
current = true
}
}
if n.ManagerStatus.Raft.Status.Reachability == swarmapi.RaftMemberStatus_UNREACHABLE {
if n.ManagerStatus.Reachability == swarmapi.RaftMemberStatus_UNREACHABLE {
unreachable++
}
}

6
daemon/cluster/convert/node.go
View File

@ -56,9 +56,9 @@ func NodeFromGRPC(n swarmapi.Node) types.Node {
//Manager
if n.ManagerStatus != nil {
node.ManagerStatus = &types.ManagerStatus{
Leader: n.ManagerStatus.Raft.Status.Leader,
Reachability: types.Reachability(strings.ToLower(n.ManagerStatus.Raft.Status.Reachability.String())),
Addr: n.ManagerStatus.Raft.Addr,
Leader: n.ManagerStatus.Leader,
Reachability: types.Reachability(strings.ToLower(n.ManagerStatus.Reachability.String())),
Addr: n.ManagerStatus.Addr,
}
}

2
hack/vendor.sh
View File

@ -139,7 +139,7 @@ clone git github.com/docker/docker-credential-helpers v0.3.0
clone git github.com/docker/containerd 860f3a94940894ac0a106eff4bd1616a67407ee2
# cluster
clone git github.com/docker/swarmkit 45094b473cbdb2d45e4d8f703fb615989399ae29
clone git github.com/docker/swarmkit 25572005febb76c2cc5f7e37d878615e6fe330f9
clone git github.com/golang/mock bd3c8e81be01eef76d4b503f5e687d2d1354d2d9
clone git github.com/gogo/protobuf 43a2e0b1c32252bfbbdf81f7faa7a88fb3fa4028
clone git github.com/cloudflare/cfssl 92f037e39eb103fb30f9151be40d9ed267fc4ae2

17
integration-cli/docker_api_swarm_test.go
View File

@ -432,14 +432,13 @@ func (s *DockerSwarmSuite) TestApiSwarmNodeDrainPause(c *check.C) {
n.Spec.Availability = swarm.NodeAvailabilityActive
})
// change environment variable, resulting balanced rescheduling
d1.updateService(c, d1.getService(c, id), func(s *swarm.Service) {
s.Spec.TaskTemplate.ContainerSpec.Env = []string{"FOO=BAR"}
s.Spec.UpdateConfig = &swarm.UpdateConfig{
Parallelism: 2,
Delay: 250 * time.Millisecond,
}
})
instances = 1
d1.updateService(c, d1.getService(c, id), setInstances(instances))
waitAndAssert(c, defaultReconciliationTimeout*2, reducedCheck(sumAsIntegers, d1.checkActiveContainerCount, d2.checkActiveContainerCount), checker.Equals, instances)
instances = 8
d1.updateService(c, d1.getService(c, id), setInstances(instances))
// drained node first so we don't get any old containers
waitAndAssert(c, defaultReconciliationTimeout, d2.checkActiveContainerCount, checker.GreaterThan, 0)
@ -453,8 +452,6 @@ func (s *DockerSwarmSuite) TestApiSwarmNodeDrainPause(c *check.C) {
n.Spec.Availability = swarm.NodeAvailabilityPause
})
c.Skip("known flakiness with scaling up from this state")
instances = 14
d1.updateService(c, d1.getService(c, id), setInstances(instances))

5
vendor/src/github.com/docker/swarmkit/agent/node.go vendored
View File

@ -622,15 +622,18 @@ func (n *Node) runManager(ctx context.Context, securityConfig *ca.SecurityConfig
select {
case <-ctx.Done():
m.Stop(context.Background()) // todo: this should be sync like other components
case <-n.waitRole(ctx, ca.AgentRole):
}
m.Stop(context.Background()) // todo: this should be sync like other components
<-done
ready = nil // ready event happens once, even on multiple starts
n.Lock()
n.manager = nil
if n.conn != nil {
n.conn.Close()
}
n.Unlock()
if ctx.Err() != nil {

300
vendor/src/github.com/docker/swarmkit/api/control.pb.go vendored
View File

@ -349,20 +349,13 @@ func (m *ListNetworksResponse) Reset() { *m = ListNetworksRes
func (*ListNetworksResponse) ProtoMessage() {}
func (*ListNetworksResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{31} }
type RemoveManagerResponse struct {
}
func (m *RemoveManagerResponse) Reset() { *m = RemoveManagerResponse{} }
func (*RemoveManagerResponse) ProtoMessage() {}
func (*RemoveManagerResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{32} }
type GetClusterRequest struct {
ClusterID string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
}
func (m *GetClusterRequest) Reset() { *m = GetClusterRequest{} }
func (*GetClusterRequest) ProtoMessage() {}
func (*GetClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{33} }
func (*GetClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{32} }
type GetClusterResponse struct {
Cluster *Cluster `protobuf:"bytes,1,opt,name=cluster" json:"cluster,omitempty"`
@ -370,7 +363,7 @@ type GetClusterResponse struct {
func (m *GetClusterResponse) Reset() { *m = GetClusterResponse{} }
func (*GetClusterResponse) ProtoMessage() {}
func (*GetClusterResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{34} }
func (*GetClusterResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{33} }
type ListClustersRequest struct {
Filters *ListClustersRequest_Filters `protobuf:"bytes,1,opt,name=filters" json:"filters,omitempty"`
@ -378,7 +371,7 @@ type ListClustersRequest struct {
func (m *ListClustersRequest) Reset() { *m = ListClustersRequest{} }
func (*ListClustersRequest) ProtoMessage() {}
func (*ListClustersRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{35} }
func (*ListClustersRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{34} }
type ListClustersRequest_Filters struct {
Names []string `protobuf:"bytes,1,rep,name=names" json:"names,omitempty"`
@ -389,7 +382,7 @@ type ListClustersRequest_Filters struct {
func (m *ListClustersRequest_Filters) Reset() { *m = ListClustersRequest_Filters{} }
func (*ListClustersRequest_Filters) ProtoMessage() {}
func (*ListClustersRequest_Filters) Descriptor() ([]byte, []int) {
return fileDescriptorControl, []int{35, 0}
return fileDescriptorControl, []int{34, 0}
}
type ListClustersResponse struct {
@ -398,7 +391,7 @@ type ListClustersResponse struct {
func (m *ListClustersResponse) Reset() { *m = ListClustersResponse{} }
func (*ListClustersResponse) ProtoMessage() {}
func (*ListClustersResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{36} }
func (*ListClustersResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{35} }
type UpdateClusterRequest struct {
// ClusterID is the cluster ID to update.
@ -411,7 +404,7 @@ type UpdateClusterRequest struct {
func (m *UpdateClusterRequest) Reset() { *m = UpdateClusterRequest{} }
func (*UpdateClusterRequest) ProtoMessage() {}
func (*UpdateClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{37} }
func (*UpdateClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{36} }
type UpdateClusterResponse struct {
Cluster *Cluster `protobuf:"bytes,1,opt,name=cluster" json:"cluster,omitempty"`
@ -419,7 +412,7 @@ type UpdateClusterResponse struct {
func (m *UpdateClusterResponse) Reset() { *m = UpdateClusterResponse{} }
func (*UpdateClusterResponse) ProtoMessage() {}
func (*UpdateClusterResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{38} }
func (*UpdateClusterResponse) Descriptor() ([]byte, []int) { return fileDescriptorControl, []int{37} }
func init() {
proto.RegisterType((*GetNodeRequest)(nil), "docker.swarmkit.v1.GetNodeRequest")
@ -458,7 +451,6 @@ func init() {
proto.RegisterType((*ListNetworksRequest)(nil), "docker.swarmkit.v1.ListNetworksRequest")
proto.RegisterType((*ListNetworksRequest_Filters)(nil), "docker.swarmkit.v1.ListNetworksRequest.Filters")
proto.RegisterType((*ListNetworksResponse)(nil), "docker.swarmkit.v1.ListNetworksResponse")
proto.RegisterType((*RemoveManagerResponse)(nil), "docker.swarmkit.v1.RemoveManagerResponse")
proto.RegisterType((*GetClusterRequest)(nil), "docker.swarmkit.v1.GetClusterRequest")
proto.RegisterType((*GetClusterResponse)(nil), "docker.swarmkit.v1.GetClusterResponse")
proto.RegisterType((*ListClustersRequest)(nil), "docker.swarmkit.v1.ListClustersRequest")
@ -1193,16 +1185,6 @@ func (m *ListNetworksResponse) Copy() *ListNetworksResponse {
return o
}
func (m *RemoveManagerResponse) Copy() *RemoveManagerResponse {
if m == nil {
return nil
}
o := &RemoveManagerResponse{}
return o
}
func (m *GetClusterRequest) Copy() *GetClusterRequest {
if m == nil {
return nil
@ -1780,15 +1762,6 @@ func (this *ListNetworksResponse) GoString() string {
s = append(s, "}")
return strings.Join(s, "")
}
func (this *RemoveManagerResponse) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 4)
s = append(s, "&api.RemoveManagerResponse{")
s = append(s, "}")
return strings.Join(s, "")
}
func (this *GetClusterRequest) GoString() string {
if this == nil {
return "nil"
@ -3765,24 +3738,6 @@ func (m *ListNetworksResponse) MarshalTo(data []byte) (int, error) {
return i, nil
}
func (m *RemoveManagerResponse) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *RemoveManagerResponse) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
return i, nil
}
func (m *GetClusterRequest) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
@ -4874,12 +4829,6 @@ func (m *ListNetworksResponse) Size() (n int) {
return n
}
func (m *RemoveManagerResponse) Size() (n int) {
var l int
_ = l
return n
}
func (m *GetClusterRequest) Size() (n int) {
var l int
_ = l
@ -5404,15 +5353,6 @@ func (this *ListNetworksResponse) String() string {
}, "")
return s
}
func (this *RemoveManagerResponse) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&RemoveManagerResponse{`,
`}`,
}, "")
return s
}
func (this *GetClusterRequest) String() string {
if this == nil {
return "nil"
@ -9165,56 +9105,6 @@ func (m *ListNetworksResponse) Unmarshal(data []byte) error {
}
return nil
}
func (m *RemoveManagerResponse) Unmarshal(data []byte) error {
l := len(data)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowControl
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: RemoveManagerResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: RemoveManagerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
default:
iNdEx = preIndex
skippy, err := skipControl(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthControl
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *GetClusterRequest) Unmarshal(data []byte) error {
l := len(data)
iNdEx := 0
@ -10094,92 +9984,92 @@ var (
)
var fileDescriptorControl = []byte{
// 1391 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x59, 0x4f, 0x6f, 0x1b, 0x45,
0x14, 0xc7, 0x4e, 0x1b, 0xd7, 0xcf, 0x75, 0xd2, 0x4c, 0x1d, 0x11, 0xb9, 0x21, 0x45, 0x5b, 0x48,
0x13, 0x29, 0x38, 0xe0, 0xa8, 0x22, 0x80, 0x04, 0x22, 0x09, 0x45, 0x16, 0x6d, 0xa8, 0x36, 0x14,
0x71, 0x8b, 0x1c, 0x7b, 0x1a, 0x96, 0xd8, 0x5e, 0xb3, 0xbb, 0x49, 0x1b, 0x71, 0xe1, 0x63, 0xf0,
0x19, 0x38, 0x70, 0xe7, 0xc4, 0x81, 0x4b, 0xc5, 0x89, 0x0b, 0x12, 0x48, 0x08, 0xb5, 0xfd, 0x00,
0x88, 0x0f, 0xc0, 0x81, 0x99, 0x9d, 0x37, 0xbb, 0xeb, 0xf1, 0xec, 0xac, 0x1d, 0xa7, 0xa2, 0x07,
0xab, 0xde, 0xd9, 0xdf, 0xfb, 0x37, 0xef, 0xf7, 0x5e, 0xde, 0x73, 0xa1, 0xdc, 0x72, 0x7b, 0x81,
0xe7, 0x76, 0x6a, 0x7d, 0xcf, 0x0d, 0x5c, 0x42, 0xda, 0x6e, 0xeb, 0x88, 0x7a, 0x35, 0xff, 0x61,
0xd3, 0xeb, 0x1e, 0x39, 0x41, 0xed, 0xe4, 0xad, 0x6a, 0xc9, 0xef, 0xd3, 0x96, 0x2f, 0x00, 0xd5,
0xb2, 0x7b, 0xf0, 0x15, 0x6d, 0x05, 0xf2, 0xb1, 0x14, 0x9c, 0xf6, 0xa9, 0x7c, 0xa8, 0x1c, 0xba,
0x87, 0x6e, 0xf8, 0x75, 0x9d, 0x7f, 0xc3, 0xd3, 0xab, 0xfd, 0xce, 0xf1, 0xa1, 0xd3, 0x5b, 0x17,
0xff, 0x88, 0x43, 0xeb, 0x16, 0xcc, 0x7c, 0x4c, 0x83, 0x5d, 0xb7, 0x4d, 0x6d, 0xfa, 0xf5, 0x31,
0xf5, 0x03, 0x72, 0x03, 0x0a, 0x3d, 0xf6, 0xb8, 0xef, 0xb4, 0x17, 0x72, 0xaf, 0xe6, 0x56, 0x8a,
0x5b, 0xf0, 0xec, 0xaf, 0xeb, 0xd3, 0x1c, 0xd1, 0xd8, 0xb1, 0xa7, 0xf9, 0xab, 0x46, 0xdb, 0xfa,
0x00, 0x66, 0x23, 0x31, 0xbf, 0xef, 0xf6, 0x7c, 0x4a, 0xd6, 0xe0, 0x02, 0x7f, 0x19, 0x0a, 0x95,
0xea, 0x0b, 0xb5, 0xe1, 0x00, 0x6a, 0x21, 0x3e, 0x44, 0x59, 0x3f, 0x4e, 0xc1, 0x95, 0x3b, 0x8e,
0x1f, 0xaa, 0xf0, 0xa5, 0xe9, 0xdb, 0x50, 0x78, 0xe0, 0x74, 0x02, 0xea, 0xf9, 0xa8, 0x65, 0x4d,
0xa7, 0x45, 0x15, 0xab, 0xdd, 0x16, 0x32, 0xb6, 0x14, 0xae, 0xfe, 0x99, 0x87, 0x02, 0x1e, 0x92,
0x0a, 0x5c, 0xec, 0x35, 0xbb, 0x94, 0x6b, 0x9c, 0x5a, 0x29, 0xda, 0xe2, 0x81, 0xac, 0x43, 0xc9,
0x69, 0xef, 0xf7, 0x3d, 0xfa, 0xc0, 0x79, 0xc4, 0xde, 0xe5, 0xf9, 0xbb, 0xad, 0x19, 0x16, 0x28,
0x34, 0x76, 0xee, 0xe1, 0xa9, 0x0d, 0x4e, 0x5b, 0x7e, 0x27, 0xf7, 0x60, 0xba, 0xd3, 0x3c, 0xa0,
0x1d, 0x7f, 0x61, 0x8a, 0x61, 0x4b, 0xf5, 0xcd, 0x71, 0x3c, 0xab, 0xdd, 0x09, 0x45, 0x3f, 0x62,
0x09, 0x3e, 0xb5, 0x51, 0x0f, 0x69, 0x40, 0xa9, 0x4b, 0xbb, 0x07, 0xec, 0xf5, 0x97, 0x4e, 0xdf,
0x5f, 0xb8, 0xc0, 0xd4, 0xce, 0xd4, 0x6f, 0xa6, 0x5d, 0xdb, 0x1e, 0x4b, 0x7d, 0xed, 0x6e, 0x84,
0xb7, 0x93, 0xb2, 0xa4, 0x0e, 0x17, 0x19, 0x73, 0x58, 0x1c, 0x17, 0x43, 0x25, 0x8b, 0xa9, 0x77,
0xcf, 0x40, 0xb6, 0x80, 0x56, 0xdf, 0x81, 0x52, 0xc2, 0x2b, 0x72, 0x05, 0xa6, 0x8e, 0xe8, 0xa9,
0xc8, 0xb8, 0xcd, 0xbf, 0xf2, 0x8b, 0x3b, 0x69, 0x76, 0x8e, 0x29, 0xbb, 0x1c, 0x7e, 0x26, 0x1e,
0xde, 0xcd, 0x6f, 0xe6, 0xac, 0x6d, 0x98, 0x4b, 0x44, 0x8a, 0xe9, 0xaf, 0xb1, 0x7b, 0xe6, 0x07,
0xe1, 0x3d, 0x9b, 0xf2, 0x2f, 0x60, 0xd6, 0xf7, 0x39, 0x98, 0xbb, 0xdf, 0x6f, 0x37, 0x03, 0x3a,
0x2e, 0xf9, 0xc8, 0xfb, 0x70, 0x39, 0x04, 0x9d, 0xb0, 0xf8, 0x1d, 0xb7, 0x17, 0x3a, 0x58, 0xaa,
0x5f, 0xd3, 0x59, 0xfc, 0x5c, 0x40, 0xec, 0x12, 0x17, 0xc0, 0x07, 0xf2, 0x26, 0x5c, 0xe0, 0x95,
0xc4, 0x32, 0xc9, 0xe5, 0x16, 0x4d, 0x57, 0x6e, 0x87, 0x48, 0x6b, 0x0b, 0x48, 0xd2, 0xd7, 0x33,
0x31, 0x7e, 0x13, 0xe6, 0x6c, 0xda, 0x75, 0x4f, 0xc6, 0x8e, 0xd7, 0xaa, 0x00, 0x49, 0x4a, 0x0a,
0xeb, 0x58, 0xb9, 0x9f, 0x35, 0xfd, 0xa3, 0x84, 0xb2, 0x80, 0x3d, 0x2a, 0xca, 0x38, 0x82, 0x2b,
0xe3, 0xaf, 0xa2, 0xca, 0x15, 0x62, 0x71, 0x1c, 0xfc, 0xa5, 0x29, 0x8e, 0x10, 0x1f, 0xa2, 0xe2,
0x38, 0xc6, 0x36, 0x1d, 0xc5, 0x91, 0xb4, 0x6e, 0xfd, 0x81, 0x9d, 0x80, 0x1f, 0x9e, 0xa1, 0x13,
0x24, 0xc5, 0x86, 0x3b, 0xc1, 0xbf, 0xff, 0x63, 0x27, 0xd0, 0x79, 0xa6, 0xed, 0x04, 0xcc, 0x05,
0x9f, 0x7a, 0x27, 0x4e, 0x8b, 0xf3, 0x40, 0x74, 0x02, 0x74, 0x61, 0x4f, 0x1c, 0x37, 0x76, 0x98,
0x0b, 0x08, 0x69, 0xb4, 0x7d, 0xb2, 0x0c, 0x97, 0x90, 0x35, 0xa2, 0xe4, 0x8b, 0x5b, 0x25, 0x86,
0x2e, 0x08, 0xda, 0xb0, 0xe8, 0x05, 0x6f, 0x7c, 0xb2, 0x03, 0x33, 0xac, 0xd4, 0x1c, 0x8f, 0xb6,
0xf7, 0xfd, 0x80, 0xb1, 0xd7, 0x5f, 0x98, 0x0e, 0x1b, 0xc4, 0x2b, 0x69, 0x29, 0xde, 0xe3, 0x28,
0xbb, 0x8c, 0x42, 0xe1, 0xd3, 0x79, 0x74, 0x0a, 0xbc, 0x89, 0xb8, 0x53, 0x70, 0x42, 0x18, 0x3b,
0x45, 0xc8, 0x10, 0x01, 0xb3, 0x3e, 0x81, 0xca, 0xb6, 0x47, 0x99, 0x2b, 0x78, 0x1b, 0x92, 0x23,
0x1b, 0x58, 0xc6, 0x82, 0x20, 0xd7, 0x75, 0x6a, 0x50, 0x22, 0x51, 0xc9, 0xbb, 0x30, 0xaf, 0x28,
0x43, 0xaf, 0x6e, 0x41, 0x01, 0x6f, 0x18, 0x15, 0x5e, 0x33, 0x28, 0xb4, 0x25, 0xd6, 0xfa, 0x10,
0xe6, 0x58, 0x39, 0x29, 0x9e, 0xad, 0x01, 0xc4, 0x09, 0xc5, 0x82, 0x28, 0xb3, 0x0c, 0x15, 0xa3,
0x7c, 0xda, 0xc5, 0x28, 0x9d, 0x2c, 0x3e, 0x92, 0x54, 0x31, 0x99, 0x3f, 0x3f, 0xe5, 0xa0, 0x22,
0x5a, 0xd5, 0x24, 0x3e, 0x31, 0xe6, 0xcc, 0x4a, 0xf4, 0x18, 0x5d, 0x76, 0x06, 0x65, 0x64, 0xa3,
0xdd, 0x18, 0x68, 0xb4, 0xa3, 0x67, 0x48, 0x09, 0x60, 0xb2, 0x1b, 0xd9, 0x81, 0x8a, 0xe8, 0x3a,
0x13, 0x25, 0xe9, 0x65, 0x98, 0x57, 0xb4, 0x60, 0xfb, 0xfa, 0x39, 0x0f, 0x57, 0x39, 0xc7, 0xf1,
0x3c, 0xea, 0x60, 0x0d, 0xb5, 0x83, 0xad, 0xa7, 0xf5, 0x09, 0x45, 0x72, 0xb8, 0x89, 0x3d, 0xc9,
0x9d, 0x7b, 0x13, 0xdb, 0x53, 0x9a, 0xd8, 0x7b, 0x63, 0x3a, 0xa7, 0xeb, 0x63, 0x93, 0x34, 0x8a,
0x4f, 0xa1, 0x32, 0x68, 0x0d, 0x73, 0xfe, 0x36, 0x5c, 0xc2, 0x1c, 0xc8, 0x76, 0x61, 0x4c, 0x7a,
0x04, 0x8e, 0x9b, 0xc6, 0x2e, 0x0d, 0x1e, 0xba, 0xde, 0xd1, 0x18, 0x4d, 0x03, 0x25, 0x74, 0x4d,
0x23, 0x52, 0x16, 0x53, 0xb2, 0x27, 0x8e, 0x4c, 0x94, 0x94, 0x52, 0x12, 0x6b, 0xdd, 0x0f, 0x9b,
0x86, 0xe2, 0x19, 0x61, 0xd3, 0x04, 0x4b, 0x26, 0xde, 0x57, 0xf8, 0x9d, 0x73, 0x14, 0x65, 0x38,
0x47, 0xf3, 0x31, 0x47, 0x51, 0x96, 0x73, 0x14, 0x01, 0x51, 0x23, 0x39, 0x27, 0x1f, 0xbf, 0x90,
0x65, 0x73, 0xee, 0x6e, 0x46, 0xa5, 0xa4, 0x78, 0x1a, 0x95, 0x12, 0x9e, 0x9f, 0xa1, 0x94, 0x14,
0xc9, 0x17, 0xab, 0x94, 0x52, 0x9c, 0x7b, 0x4e, 0xa5, 0x14, 0x5b, 0x8b, 0x4b, 0x09, 0x73, 0x60,
0x2c, 0x25, 0x99, 0x94, 0x08, 0x1c, 0xe7, 0xeb, 0x6e, 0xb3, 0xd7, 0x3c, 0xa4, 0x5e, 0x94, 0x2f,
0xf1, 0xb7, 0x6f, 0xbb, 0x73, 0xec, 0x07, 0xfc, 0x34, 0x6a, 0xab, 0x2d, 0x71, 0xa2, 0xb4, 0x55,
0xc4, 0x71, 0x2e, 0x20, 0x20, 0xa2, 0x6c, 0xa4, 0x22, 0xa6, 0x2c, 0x42, 0x4c, 0x94, 0x95, 0x52,
0x12, 0x1b, 0xf1, 0x07, 0x5f, 0x9c, 0x81, 0x3f, 0x8a, 0xe4, 0x8b, 0xc5, 0x9f, 0x14, 0xe7, 0x9e,
0x13, 0x7f, 0x62, 0x6b, 0x31, 0x7f, 0xf0, 0xa2, 0x8d, 0xfc, 0x91, 0x59, 0x89, 0xc0, 0x89, 0x91,
0x64, 0x12, 0xaa, 0xf0, 0x91, 0x44, 0xa2, 0xc7, 0x19, 0x49, 0x50, 0x66, 0x8c, 0x91, 0x04, 0xad,
0xeb, 0x46, 0x92, 0xf3, 0x21, 0x6a, 0xfd, 0xb7, 0x39, 0x28, 0x6c, 0x8b, 0x9f, 0x7b, 0x88, 0x03,
0x05, 0xfc, 0x25, 0x85, 0x58, 0x3a, 0xe1, 0xc1, 0x5f, 0x67, 0xaa, 0x37, 0x8c, 0x18, 0x2c, 0xcc,
0xf9, 0x5f, 0x7e, 0xf8, 0xfb, 0xbb, 0xfc, 0x2c, 0x94, 0x43, 0xd0, 0x1b, 0x5d, 0x51, 0xb7, 0xc4,
0x85, 0x62, 0xb4, 0xb7, 0x93, 0xd7, 0x46, 0xf9, 0x01, 0xa3, 0xfa, 0x7a, 0x06, 0xca, 0x6c, 0xd0,
0x03, 0x88, 0xd7, 0x66, 0xa2, 0xd5, 0x35, 0xf4, 0x13, 0x40, 0x75, 0x39, 0x0b, 0x96, 0x69, 0x33,
0x5e, 0x96, 0xf5, 0x36, 0x87, 0xd6, 0x70, 0xbd, 0x4d, 0xcd, 0xce, 0x9d, 0x62, 0x53, 0xe4, 0x90,
0xef, 0x2c, 0xa9, 0x39, 0x4c, 0x2c, 0xcb, 0xa9, 0x39, 0x1c, 0x58, 0x8b, 0xcd, 0x39, 0x0c, 0x37,
0xaa, 0xf4, 0x1c, 0x26, 0x57, 0xcf, 0xf4, 0x1c, 0x0e, 0xac, 0x65, 0x99, 0xf7, 0x19, 0x86, 0x67,
0xb8, 0xcf, 0x64, 0x84, 0xcb, 0x59, 0xb0, 0x4c, 0x9b, 0xf1, 0x46, 0xa4, 0xb7, 0x39, 0xb4, 0x74,
0xe9, 0x6d, 0x0e, 0x2f, 0x56, 0x69, 0x36, 0x1f, 0xc1, 0xe5, 0xe4, 0x04, 0x4a, 0x6e, 0x8e, 0x38,
0x11, 0x57, 0x57, 0xb2, 0x81, 0x66, 0xcb, 0xdf, 0x40, 0x79, 0x60, 0x25, 0x25, 0x5a, 0x8d, 0xba,
0x15, 0xb8, 0xba, 0x3a, 0x02, 0x32, 0xd3, 0xf8, 0xc0, 0xb6, 0xa5, 0x37, 0xae, 0xdb, 0x28, 0xf5,
0xc6, 0xb5, 0xab, 0x9b, 0xc1, 0xf8, 0xc0, 0x52, 0xa5, 0x37, 0xae, 0xdb, 0xde, 0xf4, 0xc6, 0xf5,
0x1b, 0x9a, 0x91, 0x64, 0x38, 0xee, 0xa4, 0x92, 0x6c, 0x70, 0xfa, 0x4d, 0x25, 0x99, 0x3a, 0xca,
0x9a, 0x49, 0x26, 0x67, 0xb3, 0x74, 0x92, 0x29, 0xb3, 0x62, 0x3a, 0xc9, 0xd4, 0x31, 0x2f, 0x93,
0x64, 0x32, 0x60, 0x03, 0xc9, 0x94, 0x98, 0x57, 0x47, 0x40, 0x8e, 0x98, 0x67, 0xa3, 0x71, 0xdd,
0xba, 0x61, 0xca, 0xf3, 0x88, 0xc6, 0x45, 0x9e, 0xf1, 0x6f, 0x70, 0x6a, 0x9e, 0x07, 0x47, 0x93,
0xd4, 0x3c, 0x2b, 0x03, 0x40, 0x46, 0x9e, 0xe5, 0x0c, 0x95, 0x9e, 0x67, 0x65, 0xa6, 0x4b, 0xcf,
0xb3, 0x3a, 0x8e, 0x65, 0xd6, 0xb3, 0x0c, 0xd8, 0x50, 0xcf, 0x4a, 0xcc, 0xab, 0x23, 0x20, 0x8d,
0xc6, 0xb7, 0x16, 0x1f, 0x3f, 0x5d, 0x7a, 0xe9, 0x77, 0xf6, 0xf9, 0xe7, 0xe9, 0x52, 0xee, 0xdb,
0x67, 0x4b, 0xb9, 0xc7, 0xec, 0xf3, 0x2b, 0xfb, 0x3c, 0x61, 0x9f, 0x83, 0xe9, 0xf0, 0x7f, 0x9c,
0x36, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x43, 0x84, 0x5f, 0x00, 0xea, 0x1a, 0x00, 0x00,
// 1384 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0x59, 0xcf, 0x6f, 0x1b, 0xc5,
0x17, 0xff, 0xda, 0x69, 0xe2, 0xfa, 0xb9, 0x4e, 0x9a, 0xa9, 0xa3, 0x6f, 0xe4, 0x86, 0x14, 0x6d,
0x21, 0x4d, 0xa4, 0xe0, 0x80, 0xa3, 0x8a, 0x00, 0x12, 0x88, 0x24, 0x14, 0x59, 0x94, 0x50, 0x6d,
0x28, 0xe2, 0x16, 0x39, 0xf6, 0x34, 0x2c, 0xb1, 0xbd, 0x66, 0x77, 0x93, 0x36, 0xe2, 0xc2, 0x9f,
0xc1, 0xdf, 0xc0, 0x81, 0x3b, 0x27, 0x0e, 0x5c, 0x2a, 0x4e, 0x5c, 0x90, 0x40, 0x42, 0xa8, 0xed,
0x1f, 0x80, 0xf8, 0x03, 0x38, 0x30, 0xb3, 0xf3, 0x66, 0x77, 0x3d, 0x9e, 0x9d, 0xb5, 0xe3, 0x54,
0xf4, 0x60, 0xd5, 0x3b, 0xfb, 0x79, 0xbf, 0xe6, 0x7d, 0xde, 0xcb, 0x7b, 0x2e, 0x94, 0x5b, 0x6e,
0x2f, 0xf0, 0xdc, 0x4e, 0xad, 0xef, 0xb9, 0x81, 0x4b, 0x48, 0xdb, 0x6d, 0x1d, 0x53, 0xaf, 0xe6,
0x3f, 0x6c, 0x7a, 0xdd, 0x63, 0x27, 0xa8, 0x9d, 0xbe, 0x51, 0x2d, 0xf9, 0x7d, 0xda, 0xf2, 0x05,
0xa0, 0x5a, 0x76, 0x0f, 0xbf, 0xa4, 0xad, 0x40, 0x3e, 0x96, 0x82, 0xb3, 0x3e, 0x95, 0x0f, 0x95,
0x23, 0xf7, 0xc8, 0x0d, 0xbf, 0x6e, 0xf0, 0x6f, 0x78, 0x7a, 0xad, 0xdf, 0x39, 0x39, 0x72, 0x7a,
0x1b, 0xe2, 0x1f, 0x71, 0x68, 0xdd, 0x86, 0xd9, 0x0f, 0x69, 0xb0, 0xe7, 0xb6, 0xa9, 0x4d, 0xbf,
0x3a, 0xa1, 0x7e, 0x40, 0x6e, 0x42, 0xa1, 0xc7, 0x1e, 0x0f, 0x9c, 0xf6, 0x62, 0xee, 0xe5, 0xdc,
0x6a, 0x71, 0x1b, 0x9e, 0xfd, 0x79, 0x63, 0x86, 0x23, 0x1a, 0xbb, 0xf6, 0x0c, 0x7f, 0xd5, 0x68,
0x5b, 0xef, 0xc1, 0x5c, 0x24, 0xe6, 0xf7, 0xdd, 0x9e, 0x4f, 0xc9, 0x3a, 0x5c, 0xe2, 0x2f, 0x43,
0xa1, 0x52, 0x7d, 0xb1, 0x36, 0x1c, 0x40, 0x2d, 0xc4, 0x87, 0x28, 0xeb, 0x87, 0x29, 0xb8, 0x7a,
0xd7, 0xf1, 0x43, 0x15, 0xbe, 0x34, 0x7d, 0x07, 0x0a, 0x0f, 0x9c, 0x4e, 0x40, 0x3d, 0x1f, 0xb5,
0xac, 0xeb, 0xb4, 0xa8, 0x62, 0xb5, 0x3b, 0x42, 0xc6, 0x96, 0xc2, 0xd5, 0x3f, 0xf2, 0x50, 0xc0,
0x43, 0x52, 0x81, 0xe9, 0x5e, 0xb3, 0x4b, 0xb9, 0xc6, 0xa9, 0xd5, 0xa2, 0x2d, 0x1e, 0xc8, 0x06,
0x94, 0x9c, 0xf6, 0x41, 0xdf, 0xa3, 0x0f, 0x9c, 0x47, 0xec, 0x5d, 0x9e, 0xbf, 0xdb, 0x9e, 0x65,
0x81, 0x42, 0x63, 0xf7, 0x1e, 0x9e, 0xda, 0xe0, 0xb4, 0xe5, 0x77, 0x72, 0x0f, 0x66, 0x3a, 0xcd,
0x43, 0xda, 0xf1, 0x17, 0xa7, 0x18, 0xb6, 0x54, 0xdf, 0x1a, 0xc7, 0xb3, 0xda, 0xdd, 0x50, 0xf4,
0x03, 0x96, 0xe0, 0x33, 0x1b, 0xf5, 0x90, 0x06, 0x94, 0xba, 0xb4, 0x7b, 0xc8, 0x5e, 0x7f, 0xe1,
0xf4, 0xfd, 0xc5, 0x4b, 0x4c, 0xed, 0x6c, 0xfd, 0x56, 0xda, 0xb5, 0xed, 0xb3, 0xd4, 0xd7, 0x3e,
0x8e, 0xf0, 0x76, 0x52, 0x96, 0xd4, 0x61, 0x9a, 0x31, 0x87, 0xc5, 0x31, 0x1d, 0x2a, 0x59, 0x4a,
0xbd, 0x7b, 0x06, 0xb2, 0x05, 0xb4, 0xfa, 0x16, 0x94, 0x12, 0x5e, 0x91, 0xab, 0x30, 0x75, 0x4c,
0xcf, 0x44, 0xc6, 0x6d, 0xfe, 0x95, 0x5f, 0xdc, 0x69, 0xb3, 0x73, 0x42, 0xd9, 0xe5, 0xf0, 0x33,
0xf1, 0xf0, 0x76, 0x7e, 0x2b, 0x67, 0xed, 0xc0, 0x7c, 0x22, 0x52, 0x4c, 0x7f, 0x8d, 0xdd, 0x33,
0x3f, 0x08, 0xef, 0xd9, 0x94, 0x7f, 0x01, 0xb3, 0xbe, 0xcb, 0xc1, 0xfc, 0xfd, 0x7e, 0xbb, 0x19,
0xd0, 0x71, 0xc9, 0x47, 0xde, 0x85, 0x2b, 0x21, 0xe8, 0x94, 0xc5, 0xef, 0xb8, 0xbd, 0xd0, 0xc1,
0x52, 0xfd, 0xba, 0xce, 0xe2, 0x67, 0x02, 0x62, 0x97, 0xb8, 0x00, 0x3e, 0x90, 0xd7, 0xe1, 0x12,
0xaf, 0x24, 0x96, 0x49, 0x2e, 0xb7, 0x64, 0xba, 0x72, 0x3b, 0x44, 0x5a, 0xdb, 0x40, 0x92, 0xbe,
0x9e, 0x8b, 0xf1, 0x5b, 0x30, 0x6f, 0xd3, 0xae, 0x7b, 0x3a, 0x76, 0xbc, 0x56, 0x05, 0x48, 0x52,
0x52, 0x58, 0xc7, 0xca, 0xfd, 0xb4, 0xe9, 0x1f, 0x27, 0x94, 0x05, 0xec, 0x51, 0x51, 0xc6, 0x11,
0x5c, 0x19, 0x7f, 0x15, 0x55, 0xae, 0x10, 0x8b, 0xe3, 0xe0, 0x2f, 0x4d, 0x71, 0x84, 0xf8, 0x10,
0x15, 0xc7, 0x31, 0xb6, 0xe9, 0x28, 0x8e, 0xa4, 0x75, 0xeb, 0x77, 0xec, 0x04, 0xfc, 0xf0, 0x1c,
0x9d, 0x20, 0x29, 0x36, 0xdc, 0x09, 0xfe, 0xf9, 0x0f, 0x3b, 0x81, 0xce, 0x33, 0x6d, 0x27, 0x60,
0x2e, 0xf8, 0xd4, 0x3b, 0x75, 0x5a, 0x9c, 0x07, 0xa2, 0x13, 0xa0, 0x0b, 0xfb, 0xe2, 0xb8, 0xb1,
0xcb, 0x5c, 0x40, 0x48, 0xa3, 0xed, 0x93, 0x15, 0xb8, 0x8c, 0xac, 0x11, 0x25, 0x5f, 0xdc, 0x2e,
0x31, 0x74, 0x41, 0xd0, 0x86, 0x45, 0x2f, 0x78, 0xe3, 0x93, 0x5d, 0x98, 0x65, 0xa5, 0xe6, 0x78,
0xb4, 0x7d, 0xe0, 0x07, 0x8c, 0xbd, 0xfe, 0xe2, 0x4c, 0xd8, 0x20, 0x5e, 0x4a, 0x4b, 0xf1, 0x3e,
0x47, 0xd9, 0x65, 0x14, 0x0a, 0x9f, 0x2e, 0xa2, 0x53, 0xe0, 0x4d, 0xc4, 0x9d, 0x82, 0x13, 0xc2,
0xd8, 0x29, 0x42, 0x86, 0x08, 0x98, 0xf5, 0x11, 0x54, 0x76, 0x3c, 0xca, 0x5c, 0xc1, 0xdb, 0x90,
0x1c, 0xd9, 0xc4, 0x32, 0x16, 0x04, 0xb9, 0xa1, 0x53, 0x83, 0x12, 0x89, 0x4a, 0xde, 0x83, 0x05,
0x45, 0x19, 0x7a, 0x75, 0x1b, 0x0a, 0x78, 0xc3, 0xa8, 0xf0, 0xba, 0x41, 0xa1, 0x2d, 0xb1, 0xd6,
0xfb, 0x30, 0xcf, 0xca, 0x49, 0xf1, 0x6c, 0x1d, 0x20, 0x4e, 0x28, 0x16, 0x44, 0x99, 0x65, 0xa8,
0x18, 0xe5, 0xd3, 0x2e, 0x46, 0xe9, 0x64, 0xf1, 0x91, 0xa4, 0x8a, 0xc9, 0xfc, 0xf9, 0x31, 0x07,
0x15, 0xd1, 0xaa, 0x26, 0xf1, 0x89, 0x31, 0x67, 0x4e, 0xa2, 0xc7, 0xe8, 0xb2, 0xb3, 0x28, 0x23,
0x1b, 0xed, 0xe6, 0x40, 0xa3, 0x1d, 0x3d, 0x43, 0x4a, 0x00, 0x93, 0xdd, 0xc8, 0x2e, 0x54, 0x44,
0xd7, 0x99, 0x28, 0x49, 0xff, 0x87, 0x05, 0x45, 0x0b, 0xb6, 0xaf, 0x9f, 0xf2, 0x70, 0x8d, 0x73,
0x1c, 0xcf, 0xa3, 0x0e, 0xd6, 0x50, 0x3b, 0xd8, 0x46, 0x5a, 0x9f, 0x50, 0x24, 0x87, 0x9b, 0xd8,
0x93, 0xdc, 0x85, 0x37, 0xb1, 0x7d, 0xa5, 0x89, 0xbd, 0x33, 0xa6, 0x73, 0xba, 0x3e, 0x36, 0x49,
0xa3, 0xf8, 0x04, 0x2a, 0x83, 0xd6, 0x30, 0xe7, 0x6f, 0xc2, 0x65, 0xcc, 0x81, 0x6c, 0x17, 0xc6,
0xa4, 0x47, 0xe0, 0xb8, 0x69, 0xec, 0xd1, 0xe0, 0xa1, 0xeb, 0x1d, 0x8f, 0xd1, 0x34, 0x50, 0x42,
0xd7, 0x34, 0x22, 0x65, 0x31, 0x25, 0x7b, 0xe2, 0xc8, 0x44, 0x49, 0x29, 0x25, 0xb1, 0xd6, 0xfd,
0xb0, 0x69, 0x28, 0x9e, 0x11, 0x36, 0x4d, 0xb0, 0x64, 0xe2, 0x7d, 0x85, 0xdf, 0x39, 0x47, 0x51,
0x86, 0x73, 0x34, 0x1f, 0x73, 0x14, 0x65, 0x39, 0x47, 0x11, 0x10, 0x35, 0x92, 0x0b, 0xf2, 0xf1,
0x73, 0x59, 0x36, 0x17, 0xee, 0x66, 0x54, 0x4a, 0x8a, 0xa7, 0x51, 0x29, 0xe1, 0xf9, 0x39, 0x4a,
0x49, 0x91, 0x7c, 0xb1, 0x4a, 0x29, 0xc5, 0xb9, 0xe7, 0x54, 0x4a, 0xb1, 0xb5, 0xb8, 0x94, 0x30,
0x07, 0xc6, 0x52, 0x92, 0x49, 0x89, 0xc0, 0xf8, 0x27, 0x6e, 0xa7, 0x73, 0xe2, 0x33, 0x77, 0x13,
0xdd, 0xb3, 0x25, 0x4e, 0x94, 0xee, 0x89, 0x38, 0x9e, 0x72, 0x04, 0x44, 0xcc, 0x8c, 0x54, 0xc4,
0xcc, 0x44, 0x88, 0x89, 0x99, 0x52, 0x4a, 0x62, 0x23, 0x9a, 0xe0, 0x8b, 0x73, 0xd0, 0x44, 0x91,
0x7c, 0xb1, 0x68, 0x92, 0xe2, 0xdc, 0x73, 0xa2, 0x49, 0x6c, 0x2d, 0xa6, 0x09, 0x5e, 0xb4, 0x91,
0x26, 0x32, 0x2b, 0x11, 0x38, 0x31, 0x79, 0x4c, 0x42, 0x15, 0x3e, 0x79, 0x48, 0xf4, 0x38, 0x93,
0x07, 0xca, 0x8c, 0x31, 0x79, 0xa0, 0x75, 0xdd, 0xe4, 0x71, 0x31, 0x44, 0xad, 0xff, 0x3a, 0x0f,
0x85, 0x1d, 0xf1, 0xab, 0x0e, 0x71, 0xa0, 0x80, 0x3f, 0x98, 0x10, 0x4b, 0x27, 0x3c, 0xf8, 0x23,
0x4c, 0xf5, 0xa6, 0x11, 0x83, 0xfd, 0x72, 0xe1, 0xe7, 0xef, 0xff, 0xfa, 0x36, 0x3f, 0x07, 0xe5,
0x10, 0xf4, 0x5a, 0xb7, 0xd9, 0x6b, 0x1e, 0x51, 0x8f, 0xb8, 0x50, 0x8c, 0xd6, 0x73, 0xf2, 0xca,
0x28, 0xbf, 0x53, 0x54, 0x5f, 0xcd, 0x40, 0x99, 0x0d, 0x7a, 0x00, 0xf1, 0x76, 0x4c, 0xb4, 0xba,
0x86, 0x36, 0xfd, 0xea, 0x4a, 0x16, 0x2c, 0xd3, 0x66, 0xbc, 0x13, 0xeb, 0x6d, 0x0e, 0x6d, 0xdb,
0x7a, 0x9b, 0x9a, 0xd5, 0x3a, 0xc5, 0xa6, 0xc8, 0x21, 0x5f, 0x4d, 0x52, 0x73, 0x98, 0xd8, 0x89,
0x53, 0x73, 0x38, 0xb0, 0xfd, 0x9a, 0x73, 0x18, 0x2e, 0x4e, 0xe9, 0x39, 0x4c, 0x6e, 0x98, 0xe9,
0x39, 0x1c, 0xd8, 0xbe, 0x32, 0xef, 0x33, 0x0c, 0xcf, 0x70, 0x9f, 0xc9, 0x08, 0x57, 0xb2, 0x60,
0x99, 0x36, 0xe3, 0xc5, 0x47, 0x6f, 0x73, 0x68, 0xb7, 0xd2, 0xdb, 0x1c, 0xde, 0x9f, 0xd2, 0x6c,
0x3e, 0x82, 0x2b, 0xc9, 0x41, 0x93, 0xdc, 0x1a, 0x71, 0xf0, 0xad, 0xae, 0x66, 0x03, 0xcd, 0x96,
0xbf, 0x86, 0xf2, 0xc0, 0xe6, 0x49, 0xb4, 0x1a, 0x75, 0x9b, 0x6e, 0x75, 0x6d, 0x04, 0x64, 0xa6,
0xf1, 0x81, 0xa5, 0x4a, 0x6f, 0x5c, 0xb7, 0x38, 0xea, 0x8d, 0x6b, 0x37, 0x34, 0x83, 0xf1, 0x81,
0xdd, 0x49, 0x6f, 0x5c, 0xb7, 0xa4, 0xe9, 0x8d, 0xeb, 0x17, 0x31, 0x23, 0xc9, 0x70, 0xaa, 0x49,
0x25, 0xd9, 0xe0, 0x90, 0x9b, 0x4a, 0x32, 0x75, 0x62, 0x35, 0x93, 0x4c, 0x8e, 0x60, 0xe9, 0x24,
0x53, 0x46, 0xc2, 0x74, 0x92, 0xa9, 0xd3, 0x5c, 0x26, 0xc9, 0x64, 0xc0, 0x06, 0x92, 0x29, 0x31,
0xaf, 0x8d, 0x80, 0x1c, 0x31, 0xcf, 0x46, 0xe3, 0xba, 0xad, 0xc2, 0x94, 0xe7, 0x11, 0x8d, 0x8b,
0x3c, 0xe3, 0xdf, 0xe0, 0xd4, 0x3c, 0x0f, 0x8e, 0x26, 0xa9, 0x79, 0x56, 0x06, 0x80, 0x8c, 0x3c,
0xcb, 0x19, 0x2a, 0x3d, 0xcf, 0xca, 0x4c, 0x97, 0x9e, 0x67, 0x75, 0x1c, 0xcb, 0xac, 0x67, 0x19,
0xb0, 0xa1, 0x9e, 0x95, 0x98, 0xd7, 0x46, 0x40, 0x1a, 0x8d, 0x6f, 0x2f, 0x3d, 0x7e, 0xba, 0xfc,
0xbf, 0xdf, 0xd8, 0xe7, 0xef, 0xa7, 0xcb, 0xb9, 0x6f, 0x9e, 0x2d, 0xe7, 0x1e, 0xb3, 0xcf, 0x2f,
0xec, 0xf3, 0x84, 0x7d, 0x0e, 0x67, 0xc2, 0xff, 0x58, 0xda, 0xfc, 0x37, 0x00, 0x00, 0xff, 0xff,
0x35, 0x0f, 0xc7, 0x5a, 0xd1, 0x1a, 0x00, 0x00,
}

2
vendor/src/github.com/docker/swarmkit/api/control.proto vendored
View File

@ -235,8 +235,6 @@ message ListNetworksResponse {
repeated Network networks = 1;
}
message RemoveManagerResponse {}
message GetClusterRequest {
string cluster_id = 1 [(gogoproto.customname) = "ClusterID"];
}

4
vendor/src/github.com/docker/swarmkit/api/objects.pb.go vendored
View File

@ -49,8 +49,8 @@ type Node struct {
Description *NodeDescription `protobuf:"bytes,4,opt,name=description" json:"description,omitempty"`
// Status provides the current status of the node, as seen by the manager.
Status NodeStatus `protobuf:"bytes,5,opt,name=status" json:"status"`
// Status of the manager. If the node is not a manager, this field will not
// be set.
// ManagerStatus provides the current status of the node's manager
// component, if the node is a manager.
ManagerStatus *ManagerStatus `protobuf:"bytes,6,opt,name=manager_status,json=managerStatus" json:"manager_status,omitempty"`
// The node attachment to the ingress network.
Attachment *NetworkAttachment `protobuf:"bytes,7,opt,name=attachment" json:"attachment,omitempty"`

4
vendor/src/github.com/docker/swarmkit/api/objects.proto vendored
View File

@ -39,8 +39,8 @@ message Node {
// Status provides the current status of the node, as seen by the manager.
NodeStatus status = 5 [(gogoproto.nullable) = false];
// Status of the manager. If the node is not a manager, this field will not
// be set.
// ManagerStatus provides the current status of the node's manager
// component, if the node is a manager.
ManagerStatus manager_status = 6;
// The node attachment to the ingress network.

795
vendor/src/github.com/docker/swarmkit/api/raft.pb.go vendored
View File

File diff suppressed because it is too large Load Diff

43
vendor/src/github.com/docker/swarmkit/api/raft.proto vendored
View File

@ -10,16 +10,6 @@ import weak "plugin/plugin.proto";
// Raft defines the RPC communication between raft nodes.
service Raft {
// Join adds a RaftMember to the raft cluster.
rpc Join(JoinRequest) returns (JoinResponse) {
option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-manager" };
};
// Leave removes a RaftMember from the raft cluster.
rpc Leave(LeaveRequest) returns (LeaveResponse) {
option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-manager" };
};
// ProcessRaftMessage sends a raft message to be processed on a raft member, it is
// called from the RaftMember willing to send a message to its destination ('To' field)
rpc ProcessRaftMessage(ProcessRaftMessageRequest) returns (ProcessRaftMessageResponse) {
@ -32,13 +22,44 @@ service Raft {
};
}
// RaftMembership defines RPCs for adding and removing members from the
// cluster. These RPCs must always run on the leader, so they are in a separate
// service to support the raft proxy.
service RaftMembership {
// Join adds a RaftMember to the raft cluster.
rpc Join(JoinRequest) returns (JoinResponse) {
option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-manager" };
};
// Leave removes a RaftMember from the raft cluster.
rpc Leave(LeaveRequest) returns (LeaveResponse) {
option (docker.protobuf.plugin.tls_authorization) = { roles: "swarm-manager" };
};
}
message RaftMember {
// RaftID specifies the internal ID used by the manager in a raft context, it can never be modified
// and is used only for information purposes
uint64 raft_id = 1 [(gogoproto.customname) = "RaftID"];
// NodeID is the node's ID.
string node_id = 2 [(gogoproto.customname) = "NodeID"];
// Addr specifies the address of the member
string addr = 3;
// Status provides the current status of the manager from the perspective of another manager.
RaftMemberStatus status = 4 [(gogoproto.nullable) = false];
}
message JoinRequest {
// Addr specifies the address of the member
string addr = 1;
}
message JoinResponse {
repeated RaftMember members = 1;
uint64 raft_id = 1 [(gogoproto.customname) = "RaftID"];
repeated RaftMember members = 2;
}
message LeaveRequest {

50
vendor/src/github.com/docker/swarmkit/api/snapshot.pb.go vendored
View File

@ -1086,30 +1086,30 @@ var (
)
var fileDescriptorSnapshot = []byte{
// 387 bytes of a gzipped FileDescriptorProto
// 386 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x92, 0xbf, 0x4e, 0xf3, 0x30,
0x14, 0xc5, 0x9b, 0xf4, 0x4f, 0x2a, 0x57, 0xed, 0xf7, 0x61, 0x31, 0x44, 0x05, 0x05, 0x08, 0x0c,
0x9d, 0x02, 0x94, 0x01, 0x16, 0x18, 0xca, 0xc4, 0x40, 0x07, 0x17, 0x55, 0xac, 0x69, 0x6a, 0xda,
0x50, 0x12, 0x47, 0xb6, 0x49, 0xc5, 0xc6, 0x73, 0xf0, 0x44, 0x1d, 0x19, 0x99, 0x10, 0x65, 0x61,
0xe5, 0x11, 0xb0, 0xe3, 0x24, 0xaa, 0x44, 0xca, 0x70, 0x25, 0xdb, 0xfa, 0x9d, 0x73, 0x6e, 0x6e,
0x2e, 0x68, 0xb1, 0xd0, 0x8d, 0xd8, 0x94, 0x70, 0x27, 0xa2, 0x84, 0x13, 0x08, 0xc7, 0xc4, 0x9b,
0x61, 0xea, 0xb0, 0xb9, 0x4b, 0x83, 0x99, 0xcf, 0x9d, 0xf8, 0xb8, 0xdd, 0x24, 0xa3, 0x7b, 0xec,
0x71, 0xa6, 0x90, 0x76, 0x83, 0x3f, 0x45, 0x38, 0xbb, 0x6c, 0x4e, 0xc8, 0x84, 0x24, 0xc7, 0x43,
0x79, 0x52, 0xaf, 0xf6, 0x8b, 0x0e, 0x9a, 0x03, 0x4e, 0x28, 0x1e, 0xa4, 0xee, 0xd0, 0x01, 0xd5,
0x90, 0x8c, 0x31, 0x33, 0xb5, 0xdd, 0x72, 0xa7, 0xd1, 0x35, 0x9d, 0xdf, 0x39, 0x4e, 0x5f, 0x00,
0x48, 0x61, 0xf0, 0x14, 0xd4, 0x19, 0xa6, 0xb1, 0xef, 0x09, 0x89, 0x9e, 0x48, 0xb6, 0x8a, 0x24,
0x03, 0xc5, 0xa0, 0x1c, 0x96, 0xc2, 0x10, 0xf3, 0x39, 0xa1, 0x33, 0x66, 0x96, 0xd7, 0x0b, 0xfb,
0x8a, 0x41, 0x39, 0x2c, 0x3b, 0xe4, 0x2e, 0x13, 0xaa, 0xca, 0xfa, 0x0e, 0x6f, 0x04, 0x80, 0x14,
0x26, 0x83, 0xbc, 0x87, 0x47, 0xc6, 0x31, 0x65, 0x66, 0x75, 0x7d, 0xd0, 0xa5, 0x62, 0x50, 0x0e,
0xdb, 0x18, 0xfc, 0x4b, 0x1f, 0xf3, 0xe9, 0x9c, 0x01, 0x23, 0xc0, 0xc1, 0x48, 0x5a, 0xa9, 0xf9,
0x58, 0x45, 0x56, 0xc8, 0xbd, 0xe3, 0xd7, 0x09, 0x86, 0x32, 0x1c, 0x9a, 0xc0, 0xa0, 0x38, 0x20,
0x31, 0x1e, 0x27, 0x63, 0xaa, 0xa0, 0xec, 0x6a, 0x7f, 0x69, 0xa0, 0x9e, 0x07, 0x5c, 0x00, 0x23,
0x16, 0xb8, 0x4f, 0x42, 0x11, 0xa0, 0x75, 0x5a, 0xdd, 0x83, 0xc2, 0x69, 0x66, 0xbb, 0x30, 0x54,
0x2c, 0xca, 0x44, 0xf0, 0x0a, 0x80, 0x34, 0x71, 0xea, 0x47, 0x22, 0x49, 0x13, 0x3d, 0xee, 0xff,
0xf1, 0xb9, 0x99, 0x53, 0xaf, 0xb2, 0x78, 0xdf, 0x29, 0xa1, 0x15, 0x31, 0x3c, 0x07, 0x55, 0x26,
0x57, 0x43, 0xfc, 0x1d, 0xe9, 0xb2, 0x57, 0xd8, 0xc8, 0xea, 0xee, 0xa4, 0x1e, 0x4a, 0x65, 0x6f,
0x00, 0x23, 0xed, 0x0e, 0xd6, 0x80, 0x3e, 0x3c, 0xfa, 0x5f, 0xea, 0x6d, 0x2f, 0x96, 0x56, 0xe9,
0x4d, 0xd4, 0xf7, 0xd2, 0xd2, 0x9e, 0x3f, 0x2d, 0x6d, 0x21, 0xea, 0x55, 0xd4, 0x87, 0xa8, 0x5b,
0x7d, 0x54, 0x4b, 0x96, 0xf2, 0xe4, 0x27, 0x00, 0x00, 0xff, 0xff, 0x16, 0x1e, 0xaa, 0x44, 0xec,
0x02, 0x00, 0x00,
0x14, 0xc5, 0x9b, 0xf4, 0x4f, 0xaa, 0xfb, 0xa9, 0xfd, 0xc0, 0x62, 0x88, 0x0a, 0x0a, 0x10, 0x18,
0x3a, 0x05, 0x28, 0x03, 0x2c, 0x30, 0x94, 0x89, 0x81, 0x0e, 0x2e, 0xaa, 0x58, 0xd3, 0xd4, 0xb4,
0xa1, 0x24, 0xae, 0x6c, 0x93, 0xae, 0x3c, 0x07, 0x4f, 0xd4, 0x91, 0x91, 0x09, 0x51, 0x16, 0x56,
0x1e, 0x01, 0x27, 0x4e, 0xa2, 0x4a, 0xa4, 0x0c, 0x57, 0x72, 0xac, 0xdf, 0x39, 0xe7, 0xe6, 0xfa,
0x42, 0x93, 0x87, 0xee, 0x8c, 0x4f, 0xa8, 0x70, 0x66, 0x8c, 0x0a, 0x8a, 0xd0, 0x88, 0x7a, 0x53,
0xc2, 0x1c, 0x3e, 0x77, 0x59, 0x30, 0xf5, 0x85, 0x13, 0x9d, 0xb4, 0x1a, 0x74, 0xf8, 0x40, 0x3c,
0xc1, 0x15, 0xd2, 0x02, 0xe6, 0xde, 0xa7, 0x78, 0x6b, 0x6b, 0x4c, 0xc7, 0x34, 0x39, 0x1e, 0xc5,
0x27, 0x75, 0x6b, 0xbf, 0xe8, 0xd0, 0xe8, 0x0b, 0xca, 0x48, 0x3f, 0x35, 0x47, 0x0e, 0x54, 0x43,
0x3a, 0x22, 0xdc, 0xd4, 0xf6, 0xca, 0xed, 0x7f, 0x1d, 0xd3, 0xf9, 0x1d, 0xe3, 0xf4, 0x24, 0x80,
0x15, 0x86, 0xce, 0xa0, 0xce, 0x09, 0x8b, 0x7c, 0x4f, 0x4a, 0xf4, 0x44, 0xb2, 0x5d, 0x24, 0xe9,
0x2b, 0x06, 0xe7, 0x70, 0x2c, 0x0c, 0x89, 0x98, 0x53, 0x36, 0xe5, 0x66, 0x79, 0xbd, 0xb0, 0xa7,
0x18, 0x9c, 0xc3, 0x71, 0x87, 0xc2, 0xe5, 0x52, 0x55, 0x59, 0xdf, 0xe1, 0xad, 0x04, 0xb0, 0xc2,
0xe2, 0x20, 0xef, 0xf1, 0x89, 0x0b, 0xc2, 0xb8, 0x59, 0x5d, 0x1f, 0x74, 0xa5, 0x18, 0x9c, 0xc3,
0x36, 0x81, 0xff, 0xe9, 0x65, 0x3e, 0x9d, 0x73, 0x30, 0x02, 0x12, 0x0c, 0x63, 0x2b, 0x35, 0x1f,
0xab, 0xc8, 0x0a, 0xcb, 0xb1, 0xdf, 0x24, 0x18, 0xce, 0x70, 0x64, 0x82, 0xc1, 0x48, 0x40, 0x23,
0x32, 0x4a, 0xc6, 0x54, 0xc1, 0xd9, 0xa7, 0xfd, 0xa5, 0x41, 0x3d, 0x0f, 0xb8, 0x04, 0x23, 0x92,
0xb8, 0x4f, 0x43, 0x19, 0xa0, 0xb5, 0x9b, 0x9d, 0xc3, 0xc2, 0x69, 0x66, 0xab, 0x30, 0x50, 0x2c,
0xce, 0x44, 0xe8, 0x1a, 0x20, 0x4d, 0x9c, 0xf8, 0x33, 0x99, 0xa4, 0xc9, 0x1e, 0x0f, 0xfe, 0xf8,
0xdd, 0xcc, 0xa9, 0x5b, 0x59, 0xbc, 0xef, 0x96, 0xf0, 0x8a, 0x18, 0x5d, 0x40, 0x95, 0xc7, 0xab,
0x21, 0x5f, 0x27, 0x76, 0xd9, 0x2f, 0x6c, 0x64, 0x75, 0x77, 0x52, 0x0f, 0xa5, 0xb2, 0x37, 0xc1,
0x48, 0xbb, 0x43, 0x35, 0xd0, 0x07, 0xc7, 0x1b, 0xa5, 0xee, 0xce, 0x62, 0x69, 0x95, 0xde, 0x64,
0x7d, 0x2f, 0x2d, 0xed, 0xf9, 0xd3, 0xd2, 0x16, 0xb2, 0x5e, 0x65, 0x7d, 0xc8, 0xba, 0xd3, 0x87,
0xb5, 0x64, 0x29, 0x4f, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xc9, 0xd9, 0x1a, 0xd9, 0xeb, 0x02,
0x00, 0x00,
}

2
vendor/src/github.com/docker/swarmkit/api/snapshot.proto vendored
View File

@ -3,7 +3,7 @@ syntax = "proto3";
package docker.swarmkit.v1;
import "objects.proto";
import "types.proto";
import "raft.proto";
import weak "gogoproto/gogo.proto";
// StoreSnapshot is used to store snapshots of the store.

208
vendor/src/github.com/docker/swarmkit/api/specs.pb.go vendored
View File

@ -405,6 +405,10 @@ type ContainerSpec struct {
// service definitions will used immutable references, either through tags
// that don't change or verifiable digests.
Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
// RegistryAuth is the registry auth token obtained from the client, required
// to pull private images
// TODO(nishanttotla): This field will later be deprecated
RegistryAuth string `protobuf:"bytes,64,opt,name=registry_auth,json=registryAuth,proto3" json:"registry_auth,omitempty"`
// Labels defines labels to be added to the container at creation time. If
// collisions with system labels occur, these labels will be overridden.
//
@ -625,6 +629,7 @@ func (m *ContainerSpec) Copy() *ContainerSpec {
o := &ContainerSpec{
Image: m.Image,
RegistryAuth: m.RegistryAuth,
Dir: m.Dir,
User: m.User,
StopGracePeriod: m.StopGracePeriod.Copy(),
@ -835,9 +840,10 @@ func (this *ContainerSpec) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 13)
s := make([]string, 0, 14)
s = append(s, "&api.ContainerSpec{")
s = append(s, "Image: "+fmt.Sprintf("%#v", this.Image)+",\n")
s = append(s, "RegistryAuth: "+fmt.Sprintf("%#v", this.RegistryAuth)+",\n")
keysForLabels := make([]string, 0, len(this.Labels))
for k, _ := range this.Labels {
keysForLabels = append(keysForLabels, k)
@ -1344,6 +1350,14 @@ func (m *ContainerSpec) MarshalTo(data []byte) (int, error) {
}
i += n14
}
if len(m.RegistryAuth) > 0 {
data[i] = 0x82
i++
data[i] = 0x4
i++
i = encodeVarintSpecs(data, i, uint64(len(m.RegistryAuth)))
i += copy(data[i:], m.RegistryAuth)
}
return i, nil
}
@ -1716,6 +1730,10 @@ func (m *ContainerSpec) Size() (n int) {
l = m.StopGracePeriod.Size()
n += 1 + l + sovSpecs(uint64(l))
}
l = len(m.RegistryAuth)
if l > 0 {
n += 2 + l + sovSpecs(uint64(l))
}
return n
}
@ -1912,6 +1930,7 @@ func (this *ContainerSpec) String() string {
`User:` + fmt.Sprintf("%v", this.User) + `,`,
`Mounts:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Mounts), "Mount", "Mount", 1), `&`, ``, 1) + `,`,
`StopGracePeriod:` + strings.Replace(fmt.Sprintf("%v", this.StopGracePeriod), "Duration", "docker_swarmkit_v11.Duration", 1) + `,`,
`RegistryAuth:` + fmt.Sprintf("%v", this.RegistryAuth) + `,`,
`}`,
}, "")
return s
@ -3158,6 +3177,35 @@ func (m *ContainerSpec) Unmarshal(data []byte) error {
return err
}
iNdEx = postIndex
case 64:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RegistryAuth", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSpecs
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthSpecs
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.RegistryAuth = string(data[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSpecs(data[iNdEx:])
@ -3801,82 +3849,84 @@ var (
)
var fileDescriptorSpecs = []byte{
// 1224 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x56, 0x4d, 0x6f, 0x1b, 0x45,
0x18, 0x8e, 0xe3, 0x8d, 0xb3, 0x9e, 0x4d, 0x5a, 0x77, 0x54, 0x5a, 0xd7, 0x2d, 0x49, 0x6a, 0x15,
0x28, 0x48, 0x38, 0x60, 0x50, 0x5b, 0xbe, 0x84, 0xb6, 0xb6, 0x49, 0x4d, 0x89, 0x6b, 0x4d, 0xda,
0x70, 0x8c, 0xc6, 0xbb, 0x53, 0x67, 0x95, 0xf5, 0xce, 0x32, 0x3b, 0x76, 0x95, 0x1b, 0xc7, 0x8a,
0x03, 0xe2, 0xc2, 0x05, 0x89, 0x13, 0xff, 0x81, 0xdf, 0x90, 0x23, 0x37, 0x38, 0x55, 0xb4, 0xbf,
0x00, 0x89, 0x3f, 0xc0, 0x3b, 0xb3, 0x63, 0x7b, 0x4d, 0x37, 0xed, 0x25, 0x87, 0x95, 0xe6, 0xe3,
0x79, 0x9e, 0x99, 0x79, 0x3f, 0x17, 0x39, 0x49, 0xcc, 0xbc, 0xa4, 0x11, 0x0b, 0x2e, 0x39, 0xc6,
0x3e, 0xf7, 0x8e, 0x98, 0x68, 0x24, 0x4f, 0xa8, 0x18, 0x1d, 0x05, 0xb2, 0x31, 0xf9, 0xb0, 0xe6,
0xc8, 0xe3, 0x98, 0x19, 0x40, 0xed, 0xe2, 0x90, 0x0f, 0xb9, 0x1e, 0x6e, 0xab, 0x91, 0x59, 0xbd,
0xec, 0x8f, 0x05, 0x95, 0x01, 0x8f, 0xb6, 0xa7, 0x83, 0x74, 0xa3, 0xfe, 0xa3, 0x85, 0xec, 0x1e,
0xf7, 0xd9, 0x1e, 0x9c, 0x81, 0x77, 0x90, 0x43, 0xa3, 0x88, 0x4b, 0x0d, 0x48, 0xaa, 0x85, 0xad,
0xc2, 0x4d, 0xa7, 0xb9, 0xd9, 0x78, 0xf9, 0xc8, 0x86, 0x3b, 0x87, 0xdd, 0xb5, 0x4e, 0x9e, 0x6d,
0x2e, 0x91, 0x2c, 0x13, 0x7f, 0x80, 0x2c, 0xc1, 0x43, 0x56, 0x5d, 0x06, 0x85, 0x73, 0xcd, 0x6b,
0x79, 0x0a, 0xea, 0x50, 0x02, 0x18, 0xa2, 0x91, 0x70, 0x34, 0x1a, 0xb1, 0xd1, 0x80, 0x89, 0xe4,
0x30, 0x88, 0xab, 0x45, 0xcd, 0x7b, 0xe7, 0x34, 0x9e, 0xba, 0x6c, 0x63, 0x77, 0x06, 0x27, 0x19,
0x2a, 0xde, 0x45, 0x6b, 0x74, 0x42, 0x83, 0x90, 0x0e, 0x82, 0x30, 0x90, 0xc7, 0x55, 0x4b, 0x4b,
0xbd, 0xfb, 0x4a, 0x29, 0x37, 0x43, 0x20, 0x0b, 0xf4, 0xba, 0x8f, 0xd0, 0xfc, 0x20, 0xfc, 0x36,
0x5a, 0xed, 0x77, 0x7a, 0xed, 0x6e, 0x6f, 0xa7, 0xb2, 0x54, 0xbb, 0xf2, 0xc3, 0xaf, 0x5b, 0x6f,
0x28, 0x8d, 0x39, 0xa0, 0xcf, 0x22, 0x3f, 0x88, 0x86, 0xf8, 0x26, 0xb2, 0xdd, 0x56, 0xab, 0xd3,
0x7f, 0xd8, 0x69, 0x57, 0x0a, 0xb5, 0x1a, 0x00, 0x2f, 0x2d, 0x02, 0x5d, 0xcf, 0x63, 0xb1, 0x64,
0x7e, 0xcd, 0x7a, 0xfa, 0xdb, 0xc6, 0x52, 0xfd, 0x69, 0x01, 0xad, 0x65, 0x2f, 0x01, 0x07, 0x95,
0xdc, 0xd6, 0xc3, 0xee, 0x7e, 0x07, 0xce, 0x99, 0xd1, 0xb3, 0x08, 0xd7, 0x93, 0xc1, 0x84, 0xe1,
0x1b, 0x68, 0xa5, 0xef, 0x3e, 0xda, 0xeb, 0xc0, 0x29, 0xb3, 0xeb, 0x64, 0x61, 0x7d, 0x3a, 0x4e,
0x34, 0xaa, 0x4d, 0xdc, 0x6e, 0xaf, 0xb2, 0x9c, 0x8f, 0x6a, 0x0b, 0x1a, 0x44, 0xe6, 0x2a, 0xbf,
0x5b, 0xc8, 0xd9, 0x63, 0x62, 0x12, 0x78, 0x67, 0x1c, 0x13, 0xb7, 0x90, 0x25, 0x69, 0x72, 0xa4,
0x63, 0xc2, 0xc9, 0x8f, 0x89, 0x87, 0xb0, 0xaf, 0x0e, 0x35, 0x74, 0x8d, 0x57, 0x91, 0x21, 0x58,
0x1c, 0x06, 0x1e, 0x05, 0x7b, 0xe9, 0xc8, 0x70, 0x9a, 0x6f, 0xe5, 0xb1, 0xc9, 0x0c, 0x65, 0xee,
0x7f, 0x6f, 0x89, 0x64, 0xa8, 0xf8, 0x33, 0x54, 0x1a, 0x86, 0x7c, 0x40, 0x43, 0x1d, 0x13, 0x4e,
0xf3, 0x7a, 0x9e, 0xc8, 0x8e, 0x46, 0xcc, 0x05, 0x0c, 0x05, 0xdf, 0x41, 0xa5, 0x71, 0xec, 0x83,
0x4e, 0xb5, 0xa4, 0xc9, 0x5b, 0x79, 0xe4, 0x47, 0x1a, 0xd1, 0xe2, 0xd1, 0xe3, 0x60, 0x48, 0x0c,
0x1e, 0xef, 0x21, 0x3b, 0x62, 0xf2, 0x09, 0x17, 0x47, 0x49, 0x75, 0x75, 0xab, 0x08, 0xdc, 0xdb,
0x79, 0xdc, 0x8c, 0xcd, 0x1b, 0xbd, 0x14, 0xef, 0x4a, 0x49, 0xbd, 0xc3, 0x11, 0x8b, 0xa4, 0x91,
0x9c, 0x09, 0xe1, 0xcf, 0x91, 0x0d, 0xa1, 0x16, 0xf3, 0x20, 0x92, 0x55, 0xfb, 0xf4, 0x0b, 0x75,
0x0c, 0x46, 0xa9, 0x92, 0x19, 0xa3, 0x76, 0x1f, 0x5d, 0x3e, 0xe5, 0x08, 0x7c, 0x09, 0x95, 0x24,
0x15, 0x43, 0x26, 0xb5, 0xa7, 0xcb, 0xc4, 0xcc, 0x70, 0x15, 0xad, 0xd2, 0x30, 0xa0, 0x09, 0x4b,
0xc0, 0x81, 0x45, 0xd8, 0x98, 0x4e, 0xef, 0x96, 0x90, 0x35, 0x82, 0x78, 0xaa, 0x6f, 0xa3, 0x0b,
0x2f, 0x79, 0x00, 0xd7, 0x90, 0x6d, 0x3c, 0x90, 0x86, 0x8e, 0x45, 0x66, 0xf3, 0xfa, 0x79, 0xb4,
0xbe, 0x60, 0xed, 0xfa, 0x2f, 0xcb, 0xc8, 0x9e, 0x86, 0x00, 0x76, 0x51, 0xd9, 0xe3, 0x91, 0x84,
0xc0, 0x64, 0xc2, 0x44, 0x5d, 0xae, 0xc3, 0x5a, 0x53, 0x90, 0x62, 0x81, 0xc3, 0xe6, 0x2c, 0xfc,
0x15, 0x2a, 0x0b, 0x96, 0xf0, 0xb1, 0xf0, 0xf4, 0xad, 0x95, 0xc4, 0xcd, 0xfc, 0xc0, 0x49, 0x41,
0x84, 0x7d, 0x37, 0x0e, 0x04, 0x53, 0xd6, 0x48, 0xc8, 0x9c, 0x0a, 0x81, 0xb3, 0x0a, 0x13, 0x30,
0x84, 0x7c, 0x55, 0xe4, 0x90, 0x14, 0xd2, 0xe7, 0xf0, 0xba, 0x63, 0x32, 0x65, 0x00, 0xb9, 0x1c,
0x87, 0xd4, 0xd3, 0xaa, 0xd5, 0x15, 0x4d, 0x7f, 0x33, 0x8f, 0xde, 0x9f, 0x82, 0xc8, 0x1c, 0x7f,
0xb7, 0x0c, 0x27, 0x8f, 0x23, 0x19, 0x8c, 0x58, 0xfd, 0xa7, 0x22, 0x5a, 0x5f, 0x78, 0x2b, 0xbe,
0x88, 0x56, 0x82, 0x11, 0x1d, 0x32, 0xe3, 0xa9, 0x74, 0x82, 0x3b, 0xa8, 0x04, 0x69, 0xcd, 0xc2,
0xd4, 0x4f, 0x4e, 0xf3, 0xfd, 0xd7, 0x1a, 0xad, 0xf1, 0x8d, 0xc6, 0x77, 0x22, 0x29, 0x8e, 0x89,
0x21, 0x2b, 0x7f, 0x7b, 0x7c, 0x34, 0xa2, 0x91, 0x4a, 0x39, 0xed, 0x6f, 0x33, 0xc5, 0x18, 0x59,
0x10, 0x12, 0x09, 0x98, 0x42, 0x2d, 0xeb, 0x31, 0xae, 0xa0, 0x22, 0x8b, 0x26, 0xf0, 0x3c, 0xb5,
0xa4, 0x86, 0x6a, 0xc5, 0x0f, 0x84, 0x4e, 0x16, 0x58, 0x81, 0xa1, 0xe2, 0x41, 0x2d, 0x12, 0x90,
0x03, 0x6a, 0x49, 0x8f, 0xf1, 0x6d, 0x54, 0x1a, 0x71, 0x78, 0x60, 0x02, 0x41, 0xac, 0x2e, 0x7b,
0x25, 0xef, 0xb2, 0xbb, 0x0a, 0x61, 0x4a, 0x82, 0x81, 0xe3, 0x7b, 0xe8, 0x42, 0x22, 0x79, 0x7c,
0x30, 0x14, 0x60, 0xaa, 0x83, 0x98, 0x89, 0x80, 0xfb, 0xd5, 0xf2, 0xe9, 0x95, 0xa5, 0x6d, 0xba,
0x1e, 0x39, 0xaf, 0x68, 0x3b, 0x8a, 0xd5, 0xd7, 0xa4, 0xda, 0x27, 0xc8, 0xc9, 0xbc, 0x5f, 0xdd,
0xfb, 0x88, 0x1d, 0x1b, 0x93, 0xaa, 0xa1, 0x32, 0xf3, 0x84, 0x86, 0xe3, 0xb4, 0x99, 0x81, 0x99,
0xf5, 0xe4, 0xd3, 0xe5, 0x3b, 0x85, 0xfa, 0xbf, 0x50, 0xb5, 0xb3, 0x19, 0x86, 0x5b, 0x69, 0x2a,
0x68, 0xf6, 0xb9, 0xe6, 0xf6, 0xeb, 0x32, 0x52, 0x07, 0x5e, 0x38, 0x56, 0xf7, 0xda, 0x55, 0xdd,
0x50, 0x93, 0xf1, 0xc7, 0x68, 0x25, 0xe6, 0x42, 0x4e, 0xfd, 0xb7, 0x91, 0x1b, 0x2c, 0x00, 0x30,
0x35, 0x21, 0x05, 0xd7, 0x0f, 0xd1, 0xb9, 0x45, 0x35, 0x28, 0xfa, 0xc5, 0xfd, 0x6e, 0x1f, 0xfa,
0xc7, 0x55, 0x28, 0xf9, 0x97, 0x17, 0x37, 0xf7, 0x03, 0x21, 0xc7, 0x34, 0xec, 0xf6, 0xf1, 0x7b,
0xd0, 0x1a, 0x7a, 0x7b, 0x84, 0x40, 0x03, 0xd9, 0x04, 0xdc, 0xd5, 0x45, 0x9c, 0xda, 0x02, 0x83,
0xfb, 0x84, 0x0f, 0x66, 0x0d, 0xe2, 0xe7, 0x65, 0xe4, 0x98, 0xea, 0x71, 0xb6, 0x0d, 0xe2, 0x4b,
0xb4, 0xee, 0x0b, 0x68, 0x6a, 0xe2, 0xc0, 0xd3, 0x4f, 0x33, 0x29, 0x5b, 0xcb, 0xf5, 0xa7, 0x06,
0x92, 0xb5, 0x94, 0x60, 0x6a, 0xd7, 0x75, 0xb4, 0x16, 0xc4, 0x93, 0x5b, 0x07, 0x2c, 0xa2, 0x83,
0xd0, 0xf4, 0x0a, 0x9b, 0x38, 0x6a, 0xad, 0x93, 0x2e, 0xa9, 0x7a, 0x04, 0xc6, 0x67, 0x22, 0x32,
0x5d, 0xc0, 0x26, 0xb3, 0x39, 0xfe, 0x02, 0x59, 0x41, 0x4c, 0x47, 0x26, 0x49, 0x73, 0x5f, 0xd0,
0xed, 0xbb, 0xbb, 0x0f, 0xe2, 0xf4, 0x05, 0xf6, 0x8b, 0x67, 0x9b, 0x96, 0x5a, 0x20, 0x9a, 0x56,
0xff, 0xb3, 0x88, 0x9c, 0x56, 0x38, 0x4e, 0xa4, 0x49, 0xcf, 0x33, 0xb3, 0xcb, 0xb7, 0xe8, 0x02,
0xd5, 0xbf, 0x0b, 0x34, 0x52, 0xb1, 0xae, 0xeb, 0x8b, 0xb1, 0xcd, 0x8d, 0x5c, 0xb9, 0x19, 0x38,
0xad, 0x45, 0x46, 0xb3, 0x42, 0xff, 0xb7, 0x0e, 0x9d, 0x69, 0x9d, 0x0b, 0xef, 0x10, 0x0a, 0x55,
0x9a, 0x1c, 0xa6, 0xb9, 0xe6, 0xfe, 0x76, 0x3d, 0xc8, 0x02, 0x53, 0x7b, 0x1b, 0xdd, 0x45, 0x0d,
0x68, 0x94, 0x96, 0xa0, 0x8f, 0xa7, 0x95, 0x32, 0x37, 0x7a, 0x09, 0xec, 0x2f, 0x48, 0x68, 0x06,
0xfe, 0x1a, 0x21, 0x3f, 0x48, 0x62, 0x2a, 0x41, 0x4e, 0x18, 0x2f, 0xe4, 0x3e, 0xb0, 0x3d, 0x43,
0x2d, 0xa8, 0x64, 0xd8, 0xf8, 0x3e, 0x74, 0x0f, 0x3a, 0x8d, 0xa3, 0xd2, 0xe9, 0x75, 0xa1, 0xe5,
0x1a, 0x89, 0x8a, 0x92, 0x00, 0x8f, 0xda, 0xd3, 0x15, 0x62, 0x7b, 0xd4, 0xec, 0x5d, 0x3b, 0x79,
0xbe, 0xb1, 0xf4, 0x17, 0x7c, 0xff, 0x3c, 0xdf, 0x28, 0x7c, 0xff, 0x62, 0xa3, 0x70, 0x02, 0xdf,
0x1f, 0xf0, 0xfd, 0x0d, 0xdf, 0xa0, 0xa4, 0x7f, 0xa4, 0x3f, 0xfa, 0x2f, 0x00, 0x00, 0xff, 0xff,
0x4e, 0xfb, 0xdd, 0xf6, 0xa7, 0x0b, 0x00, 0x00,
// 1249 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x56, 0x4f, 0x73, 0x1b, 0x35,
0x14, 0x8f, 0xe3, 0x8d, 0xb3, 0xd6, 0x26, 0xad, 0xab, 0x29, 0xad, 0xeb, 0x96, 0x24, 0x35, 0x05,
0x0a, 0x33, 0x38, 0x60, 0x98, 0xb6, 0xfc, 0x1b, 0xd8, 0xda, 0x26, 0x35, 0x25, 0xae, 0x47, 0x69,
0xcb, 0x31, 0x23, 0xef, 0xaa, 0x8e, 0x26, 0xeb, 0xdd, 0x45, 0x2b, 0xbb, 0x93, 0x1b, 0xc7, 0x0e,
0x07, 0x6e, 0x5c, 0x98, 0xe1, 0xc4, 0x67, 0x80, 0xcf, 0x90, 0x23, 0x37, 0x38, 0x75, 0x68, 0x3f,
0x01, 0x33, 0x7c, 0x01, 0x9e, 0xb4, 0xb2, 0xbd, 0xa6, 0x9b, 0xf6, 0x92, 0xc3, 0xce, 0x48, 0x4f,
0xbf, 0xdf, 0x4f, 0xd2, 0x7b, 0x4f, 0xef, 0x2d, 0x72, 0x92, 0x98, 0x79, 0x49, 0x23, 0x16, 0x91,
0x8c, 0x30, 0xf6, 0x23, 0xef, 0x90, 0x89, 0x46, 0xf2, 0x98, 0x8a, 0xd1, 0x21, 0x97, 0x8d, 0xc9,
0x07, 0x35, 0x47, 0x1e, 0xc5, 0xcc, 0x00, 0x6a, 0xe7, 0x87, 0xd1, 0x30, 0xd2, 0xc3, 0x6d, 0x35,
0x32, 0xd6, 0x8b, 0xfe, 0x58, 0x50, 0xc9, 0xa3, 0x70, 0x7b, 0x3a, 0x48, 0x17, 0xea, 0x3f, 0x5a,
0xc8, 0xee, 0x45, 0x3e, 0xdb, 0x83, 0x3d, 0xf0, 0x0e, 0x72, 0x68, 0x18, 0x46, 0x52, 0x03, 0x92,
0x6a, 0x61, 0xab, 0x70, 0xdd, 0x69, 0x6e, 0x36, 0x5e, 0xdc, 0xb2, 0xe1, 0xce, 0x61, 0xb7, 0xad,
0xe3, 0xa7, 0x9b, 0x4b, 0x24, 0xcb, 0xc4, 0xef, 0x23, 0x4b, 0x44, 0x01, 0xab, 0x2e, 0x83, 0xc2,
0x99, 0xe6, 0x95, 0x3c, 0x05, 0xb5, 0x29, 0x01, 0x0c, 0xd1, 0x48, 0xd8, 0x1a, 0x8d, 0xd8, 0x68,
0xc0, 0x44, 0x72, 0xc0, 0xe3, 0x6a, 0x51, 0xf3, 0xde, 0x3e, 0x89, 0xa7, 0x0e, 0xdb, 0xd8, 0x9d,
0xc1, 0x49, 0x86, 0x8a, 0x77, 0xd1, 0x1a, 0x9d, 0x50, 0x1e, 0xd0, 0x01, 0x0f, 0xb8, 0x3c, 0xaa,
0x5a, 0x5a, 0xea, 0x9d, 0x97, 0x4a, 0xb9, 0x19, 0x02, 0x59, 0xa0, 0xd7, 0x7d, 0x84, 0xe6, 0x1b,
0xe1, 0xb7, 0xd0, 0x6a, 0xbf, 0xd3, 0x6b, 0x77, 0x7b, 0x3b, 0x95, 0xa5, 0xda, 0xa5, 0x1f, 0x7e,
0xd9, 0x7a, 0x4d, 0x69, 0xcc, 0x01, 0x7d, 0x16, 0xfa, 0x3c, 0x1c, 0xe2, 0xeb, 0xc8, 0x76, 0x5b,
0xad, 0x4e, 0xff, 0x7e, 0xa7, 0x5d, 0x29, 0xd4, 0x6a, 0x00, 0xbc, 0xb0, 0x08, 0x74, 0x3d, 0x8f,
0xc5, 0x92, 0xf9, 0x35, 0xeb, 0xc9, 0xaf, 0x1b, 0x4b, 0xf5, 0x27, 0x05, 0xb4, 0x96, 0x3d, 0x04,
0x6c, 0x54, 0x72, 0x5b, 0xf7, 0xbb, 0x0f, 0x3b, 0xb0, 0xcf, 0x8c, 0x9e, 0x45, 0xb8, 0x9e, 0xe4,
0x13, 0x86, 0xaf, 0xa1, 0x95, 0xbe, 0xfb, 0x60, 0xaf, 0x03, 0xbb, 0xcc, 0x8e, 0x93, 0x85, 0xf5,
0xe9, 0x38, 0xd1, 0xa8, 0x36, 0x71, 0xbb, 0xbd, 0xca, 0x72, 0x3e, 0xaa, 0x2d, 0x28, 0x0f, 0xcd,
0x51, 0x7e, 0xb7, 0x90, 0xb3, 0xc7, 0xc4, 0x84, 0x7b, 0xa7, 0x9c, 0x13, 0x37, 0x90, 0x25, 0x69,
0x72, 0xa8, 0x73, 0xc2, 0xc9, 0xcf, 0x89, 0xfb, 0xb0, 0xae, 0x36, 0x35, 0x74, 0x8d, 0x57, 0x99,
0x21, 0x58, 0x1c, 0x70, 0x8f, 0x82, 0xbf, 0x74, 0x66, 0x38, 0xcd, 0x37, 0xf3, 0xd8, 0x64, 0x86,
0x32, 0xe7, 0xbf, 0xb3, 0x44, 0x32, 0x54, 0xfc, 0x29, 0x2a, 0x0d, 0x83, 0x68, 0x40, 0x03, 0x9d,
0x13, 0x4e, 0xf3, 0x6a, 0x9e, 0xc8, 0x8e, 0x46, 0xcc, 0x05, 0x0c, 0x05, 0xdf, 0x42, 0xa5, 0x71,
0xec, 0x83, 0x4e, 0xb5, 0xa4, 0xc9, 0x5b, 0x79, 0xe4, 0x07, 0x1a, 0xd1, 0x8a, 0xc2, 0x47, 0x7c,
0x48, 0x0c, 0x1e, 0xef, 0x21, 0x3b, 0x64, 0xf2, 0x71, 0x24, 0x0e, 0x93, 0xea, 0xea, 0x56, 0x11,
0xb8, 0x37, 0xf3, 0xb8, 0x19, 0x9f, 0x37, 0x7a, 0x29, 0xde, 0x95, 0x92, 0x7a, 0x07, 0x23, 0x16,
0x4a, 0x23, 0x39, 0x13, 0xc2, 0x9f, 0x21, 0x1b, 0x52, 0x2d, 0x8e, 0x78, 0x28, 0xab, 0xf6, 0xc9,
0x07, 0xea, 0x18, 0x8c, 0x52, 0x25, 0x33, 0x46, 0xed, 0x2e, 0xba, 0x78, 0xc2, 0x16, 0xf8, 0x02,
0x2a, 0x49, 0x2a, 0x86, 0x4c, 0xea, 0x48, 0x97, 0x89, 0x99, 0xe1, 0x2a, 0x5a, 0xa5, 0x01, 0xa7,
0x09, 0x4b, 0x20, 0x80, 0x45, 0x58, 0x98, 0x4e, 0x6f, 0x97, 0x90, 0x35, 0x82, 0x7c, 0xaa, 0x6f,
0xa3, 0x73, 0x2f, 0x44, 0x00, 0xd7, 0x90, 0x6d, 0x22, 0x90, 0xa6, 0x8e, 0x45, 0x66, 0xf3, 0xfa,
0x59, 0xb4, 0xbe, 0xe0, 0xed, 0xfa, 0xcf, 0xcb, 0xc8, 0x9e, 0xa6, 0x00, 0x76, 0x51, 0xd9, 0x8b,
0x42, 0x09, 0x89, 0xc9, 0x84, 0xc9, 0xba, 0xdc, 0x80, 0xb5, 0xa6, 0x20, 0xc5, 0x82, 0x80, 0xcd,
0x59, 0xf8, 0x2b, 0x54, 0x16, 0x2c, 0x89, 0xc6, 0xc2, 0xd3, 0xa7, 0x56, 0x12, 0xd7, 0xf3, 0x13,
0x27, 0x05, 0x11, 0xf6, 0xdd, 0x98, 0x0b, 0xa6, 0xbc, 0x91, 0x90, 0x39, 0x15, 0x12, 0x67, 0x15,
0x26, 0xe0, 0x08, 0xf9, 0xb2, 0xcc, 0x21, 0x29, 0xa4, 0x1f, 0xc1, 0xed, 0x8e, 0xc8, 0x94, 0x01,
0xe4, 0x72, 0x1c, 0x50, 0x4f, 0xab, 0x56, 0x57, 0x34, 0xfd, 0xf5, 0x3c, 0x7a, 0x7f, 0x0a, 0x22,
0x73, 0xfc, 0xed, 0x32, 0xec, 0x3c, 0x0e, 0x25, 0x1f, 0xb1, 0xfa, 0x6f, 0x45, 0xb4, 0xbe, 0x70,
0x57, 0x7c, 0x1e, 0xad, 0xf0, 0x11, 0x1d, 0x32, 0x13, 0xa9, 0x74, 0x82, 0x3b, 0xa8, 0x04, 0xcf,
0x9a, 0x05, 0x69, 0x9c, 0x9c, 0xe6, 0x7b, 0xaf, 0x74, 0x5a, 0xe3, 0x1b, 0x8d, 0xef, 0x84, 0x52,
0x1c, 0x11, 0x43, 0x56, 0xf1, 0xf6, 0xa2, 0xd1, 0x88, 0x86, 0xea, 0xc9, 0xe9, 0x78, 0x9b, 0x29,
0xc6, 0xc8, 0x82, 0x94, 0x48, 0xc0, 0x15, 0xca, 0xac, 0xc7, 0xb8, 0x82, 0x8a, 0x2c, 0x9c, 0xc0,
0xf5, 0x94, 0x49, 0x0d, 0x95, 0xc5, 0xe7, 0x42, 0x3f, 0x16, 0xb0, 0xc0, 0x50, 0xf1, 0xa0, 0x16,
0x09, 0x78, 0x03, 0xca, 0xa4, 0xc7, 0xf8, 0x26, 0x2a, 0x8d, 0x22, 0xb8, 0x60, 0x02, 0x49, 0xac,
0x0e, 0x7b, 0x29, 0xef, 0xb0, 0xbb, 0x0a, 0x61, 0x4a, 0x82, 0x81, 0xe3, 0x3b, 0xe8, 0x5c, 0x22,
0xa3, 0x78, 0x7f, 0x28, 0xc0, 0x55, 0xfb, 0x31, 0x13, 0x3c, 0xf2, 0xab, 0xe5, 0x93, 0x2b, 0x4b,
0xdb, 0x74, 0x3d, 0x72, 0x56, 0xd1, 0x76, 0x14, 0xab, 0xaf, 0x49, 0xf8, 0x0d, 0xb4, 0x2e, 0xd8,
0x90, 0x27, 0x70, 0xf9, 0x7d, 0x3a, 0x96, 0x07, 0xd5, 0x2f, 0xf5, 0xf9, 0xd6, 0xa6, 0x46, 0x17,
0x6c, 0xb5, 0x8f, 0x91, 0x93, 0x71, 0x92, 0xba, 0xdc, 0x21, 0x3b, 0x32, 0x7e, 0x57, 0x43, 0x15,
0x8b, 0x09, 0x0d, 0xc6, 0x69, 0xc7, 0x83, 0x58, 0xe8, 0xc9, 0x27, 0xcb, 0xb7, 0x0a, 0xf5, 0x7f,
0xa1, 0xb4, 0x67, 0x9f, 0x21, 0x6e, 0xa5, 0xef, 0x45, 0xb3, 0xcf, 0x34, 0xb7, 0x5f, 0xf5, 0x6c,
0x75, 0x76, 0x06, 0x63, 0x75, 0xf8, 0x5d, 0xd5, 0x32, 0x35, 0x19, 0x7f, 0x84, 0x56, 0xe2, 0x48,
0xc8, 0x69, 0x90, 0x37, 0x72, 0x33, 0x0a, 0x00, 0xa6, 0x70, 0xa4, 0xe0, 0xfa, 0x01, 0x3a, 0xb3,
0xa8, 0x06, 0x9d, 0xa1, 0xf8, 0xb0, 0xdb, 0x87, 0x26, 0x73, 0x19, 0xfa, 0xc2, 0xc5, 0xc5, 0xc5,
0x87, 0x5c, 0xc8, 0x31, 0x0d, 0xba, 0x7d, 0xfc, 0x2e, 0xf4, 0x8f, 0xde, 0x1e, 0x21, 0xd0, 0x65,
0x36, 0x01, 0x77, 0x79, 0x11, 0xa7, 0x96, 0x20, 0x2a, 0x3e, 0x89, 0x06, 0xb3, 0x2e, 0xf2, 0xd3,
0x32, 0x72, 0x4c, 0x89, 0x39, 0xdd, 0x2e, 0xf2, 0x05, 0x5a, 0xf7, 0x05, 0x74, 0x3e, 0xb1, 0xef,
0xe9, 0xab, 0x99, 0x77, 0x5d, 0xcb, 0x0d, 0xba, 0x06, 0x92, 0xb5, 0x94, 0x60, 0x0a, 0xdc, 0x55,
0xb4, 0xc6, 0xe3, 0xc9, 0x8d, 0x7d, 0x16, 0xd2, 0x41, 0x60, 0x1a, 0x8a, 0x4d, 0x1c, 0x65, 0xeb,
0xa4, 0x26, 0x55, 0xb4, 0xc0, 0xf9, 0x4c, 0x84, 0xa6, 0x55, 0xd8, 0x64, 0x36, 0xc7, 0x9f, 0x23,
0x8b, 0xc7, 0x74, 0x64, 0x5e, 0x72, 0xee, 0x0d, 0xba, 0x7d, 0x77, 0xf7, 0x5e, 0x9c, 0xde, 0xc0,
0x7e, 0xfe, 0x74, 0xd3, 0x52, 0x06, 0xa2, 0x69, 0xf5, 0x3f, 0x8b, 0xc8, 0x69, 0x05, 0xe3, 0x44,
0x9a, 0x37, 0x7c, 0x6a, 0x7e, 0xf9, 0x16, 0x9d, 0xa3, 0xfa, 0x9f, 0x82, 0x86, 0xea, 0x41, 0xe8,
0x22, 0x64, 0x7c, 0x73, 0x2d, 0x57, 0x6e, 0x06, 0x4e, 0x0b, 0x96, 0xd1, 0xac, 0xd0, 0xff, 0xd9,
0xa1, 0x7d, 0xad, 0x47, 0xc2, 0x3b, 0x80, 0x6a, 0x96, 0xbe, 0x20, 0xd3, 0x81, 0x73, 0xff, 0xcd,
0xee, 0x65, 0x81, 0xa9, 0xbf, 0x8d, 0xee, 0xa2, 0x06, 0x74, 0x53, 0x4b, 0xd0, 0x47, 0xd3, 0x72,
0x9a, 0x9b, 0xbd, 0x04, 0xd6, 0x17, 0x24, 0x34, 0x03, 0x7f, 0x8d, 0x90, 0xcf, 0x93, 0x98, 0x4a,
0x90, 0x13, 0x26, 0x0a, 0xb9, 0x17, 0x6c, 0xcf, 0x50, 0x0b, 0x2a, 0x19, 0x36, 0xbe, 0x0b, 0x2d,
0x86, 0x4e, 0xf3, 0xa8, 0x74, 0x72, 0xf1, 0x68, 0xb9, 0x46, 0xa2, 0xa2, 0x24, 0x20, 0xa2, 0xf6,
0xd4, 0x42, 0x6c, 0x8f, 0x9a, 0xb5, 0x2b, 0xc7, 0xcf, 0x36, 0x96, 0xfe, 0x82, 0xef, 0x9f, 0x67,
0x1b, 0x85, 0xef, 0x9f, 0x6f, 0x14, 0x8e, 0xe1, 0xfb, 0x03, 0xbe, 0xbf, 0xe1, 0x1b, 0x94, 0xf4,
0xdf, 0xf6, 0x87, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x3c, 0x6e, 0x60, 0xc5, 0xcc, 0x0b, 0x00,
0x00,
}

5
vendor/src/github.com/docker/swarmkit/api/specs.proto vendored
View File

@ -127,6 +127,11 @@ message ContainerSpec {
// that don't change or verifiable digests.
string image = 1;
// RegistryAuth is the registry auth token obtained from the client, required
// to pull private images
// TODO(nishanttotla): This field will later be deprecated
string registry_auth = 64;
// Labels defines labels to be added to the container at creation time. If
// collisions with system labels occur, these labels will be overridden.
//

772
vendor/src/github.com/docker/swarmkit/api/types.pb.go vendored
View File

@ -44,7 +44,6 @@
OrchestrationConfig
DispatcherConfig
RaftConfig
RaftMember
Placement
RootCA
Certificate
@ -99,7 +98,6 @@
RemoveNetworkResponse
ListNetworksRequest
ListNetworksResponse
RemoveManagerResponse
GetClusterRequest
GetClusterResponse
ListClustersRequest
@ -123,6 +121,7 @@
StoreSnapshot
ClusterSnapshot
Snapshot
RaftMember
JoinRequest
JoinResponse
LeaveRequest
@ -481,7 +480,7 @@ func (x EncryptionKey_Algorithm) String() string {
return proto.EnumName(EncryptionKey_Algorithm_name, int32(x))
}
func (EncryptionKey_Algorithm) EnumDescriptor() ([]byte, []int) {
return fileDescriptorTypes, []int{32, 0}
return fileDescriptorTypes, []int{31, 0}
}
// Version tracks the last time an object in the store was updated.
@ -1009,20 +1008,6 @@ func (m *RaftConfig) Reset() { *m = RaftConfig{} }
func (*RaftConfig) ProtoMessage() {}
func (*RaftConfig) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{27} }
type RaftMember struct {
// RaftID specifies the internal ID used by the manager in a raft context, it can never be modified
// and is used only for information purposes
RaftID uint64 `protobuf:"varint,1,opt,name=raft_id,json=raftId,proto3" json:"raft_id,omitempty"`
// Addr specifies the address of the member
Addr string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
// Status provides the current status of the manager from the perspective of another manager.
Status RaftMemberStatus `protobuf:"bytes,3,opt,name=status" json:"status"`
}
func (m *RaftMember) Reset() { *m = RaftMember{} }
func (*RaftMember) ProtoMessage() {}
func (*RaftMember) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{28} }
// Placement specifies task distribution constraints.
type Placement struct {
// constraints specifies a set of requirements a node should meet for a task.
@ -1031,7 +1016,7 @@ type Placement struct {
func (m *Placement) Reset() { *m = Placement{} }
func (*Placement) ProtoMessage() {}
func (*Placement) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{29} }
func (*Placement) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{28} }
type RootCA struct {
// CAKey is the root CA private key.
@ -1044,7 +1029,7 @@ type RootCA struct {
func (m *RootCA) Reset() { *m = RootCA{} }
func (*RootCA) ProtoMessage() {}
func (*RootCA) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{30} }
func (*RootCA) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{29} }
type Certificate struct {
Role NodeRole `protobuf:"varint,1,opt,name=role,proto3,enum=docker.swarmkit.v1.NodeRole" json:"role,omitempty"`
@ -1057,7 +1042,7 @@ type Certificate struct {
func (m *Certificate) Reset() { *m = Certificate{} }
func (*Certificate) ProtoMessage() {}
func (*Certificate) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{31} }
func (*Certificate) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{30} }
// Symmetric keys to encrypt inter-agent communication.
type EncryptionKey struct {
@ -1073,16 +1058,24 @@ type EncryptionKey struct {
func (m *EncryptionKey) Reset() { *m = EncryptionKey{} }
func (*EncryptionKey) ProtoMessage() {}
func (*EncryptionKey) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{32} }
func (*EncryptionKey) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{31} }
// ManagerStatus provides information about the status of a manager in the cluster.
// ManagerStatus provides informations about the state of a manager in the cluster.
type ManagerStatus struct {
Raft RaftMember `protobuf:"bytes,1,opt,name=raft" json:"raft"`
// RaftID specifies the internal ID used by the manager in a raft context, it can never be modified
// and is used only for information purposes
RaftID uint64 `protobuf:"varint,1,opt,name=raft_id,json=raftId,proto3" json:"raft_id,omitempty"`
// Addr is the address advertised to raft.
Addr string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
// Leader is set to true if this node is the raft leader.
Leader bool `protobuf:"varint,3,opt,name=leader,proto3" json:"leader,omitempty"`
// Reachability specifies whether this node is reachable.
Reachability RaftMemberStatus_Reachability `protobuf:"varint,4,opt,name=reachability,proto3,enum=docker.swarmkit.v1.RaftMemberStatus_Reachability" json:"reachability,omitempty"`
}
func (m *ManagerStatus) Reset() { *m = ManagerStatus{} }
func (*ManagerStatus) ProtoMessage() {}
func (*ManagerStatus) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{33} }
func (*ManagerStatus) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{32} }
func init() {
proto.RegisterType((*Version)(nil), "docker.swarmkit.v1.Version")
@ -1117,7 +1110,6 @@ func init() {
proto.RegisterType((*OrchestrationConfig)(nil), "docker.swarmkit.v1.OrchestrationConfig")
proto.RegisterType((*DispatcherConfig)(nil), "docker.swarmkit.v1.DispatcherConfig")
proto.RegisterType((*RaftConfig)(nil), "docker.swarmkit.v1.RaftConfig")
proto.RegisterType((*RaftMember)(nil), "docker.swarmkit.v1.RaftMember")
proto.RegisterType((*Placement)(nil), "docker.swarmkit.v1.Placement")
proto.RegisterType((*RootCA)(nil), "docker.swarmkit.v1.RootCA")
proto.RegisterType((*Certificate)(nil), "docker.swarmkit.v1.Certificate")
@ -1624,20 +1616,6 @@ func (m *RaftConfig) Copy() *RaftConfig {
return o
}
func (m *RaftMember) Copy() *RaftMember {
if m == nil {
return nil
}
o := &RaftMember{
RaftID: m.RaftID,
Addr: m.Addr,
Status: *m.Status.Copy(),
}
return o
}
func (m *Placement) Copy() *Placement {
if m == nil {
return nil
@ -1706,7 +1684,10 @@ func (m *ManagerStatus) Copy() *ManagerStatus {
}
o := &ManagerStatus{
Raft: *m.Raft.Copy(),
RaftID: m.RaftID,
Addr: m.Addr,
Leader: m.Leader,
Reachability: m.Reachability,
}
return o
@ -2187,18 +2168,6 @@ func (this *RaftConfig) GoString() string {
s = append(s, "}")
return strings.Join(s, "")
}
func (this *RaftMember) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 7)
s = append(s, "&api.RaftMember{")
s = append(s, "RaftID: "+fmt.Sprintf("%#v", this.RaftID)+",\n")
s = append(s, "Addr: "+fmt.Sprintf("%#v", this.Addr)+",\n")
s = append(s, "Status: "+strings.Replace(this.Status.GoString(), `&`, ``, 1)+",\n")
s = append(s, "}")
return strings.Join(s, "")
}
func (this *Placement) GoString() string {
if this == nil {
return "nil"
@ -2252,9 +2221,12 @@ func (this *ManagerStatus) GoString() string {
if this == nil {
return "nil"
}
s := make([]string, 0, 5)
s := make([]string, 0, 8)
s = append(s, "&api.ManagerStatus{")
s = append(s, "Raft: "+strings.Replace(this.Raft.GoString(), `&`, ``, 1)+",\n")
s = append(s, "RaftID: "+fmt.Sprintf("%#v", this.RaftID)+",\n")
s = append(s, "Addr: "+fmt.Sprintf("%#v", this.Addr)+",\n")
s = append(s, "Leader: "+fmt.Sprintf("%#v", this.Leader)+",\n")
s = append(s, "Reachability: "+fmt.Sprintf("%#v", this.Reachability)+",\n")
s = append(s, "}")
return strings.Join(s, "")
}
@ -3484,43 +3456,6 @@ func (m *RaftConfig) MarshalTo(data []byte) (int, error) {
return i, nil
}
func (m *RaftMember) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
n, err := m.MarshalTo(data)
if err != nil {
return nil, err
}
return data[:n], nil
}
func (m *RaftMember) MarshalTo(data []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.RaftID != 0 {
data[i] = 0x8
i++
i = encodeVarintTypes(data, i, uint64(m.RaftID))
}
if len(m.Addr) > 0 {
data[i] = 0x12
i++
i = encodeVarintTypes(data, i, uint64(len(m.Addr)))
i += copy(data[i:], m.Addr)
}
data[i] = 0x1a
i++
i = encodeVarintTypes(data, i, uint64(m.Status.Size()))
n19, err := m.Status.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n19
return i, nil
}
func (m *Placement) Marshal() (data []byte, err error) {
size := m.Size()
data = make([]byte, size)
@ -3619,11 +3554,11 @@ func (m *Certificate) MarshalTo(data []byte) (int, error) {
data[i] = 0x1a
i++
i = encodeVarintTypes(data, i, uint64(m.Status.Size()))
n20, err := m.Status.MarshalTo(data[i:])
n19, err := m.Status.MarshalTo(data[i:])
if err != nil {
return 0, err
}
i += n20
i += n19
if len(m.Certificate) > 0 {
data[i] = 0x22
i++
@ -3694,14 +3629,32 @@ func (m *ManagerStatus) MarshalTo(data []byte) (int, error) {
_ = i
var l int
_ = l
data[i] = 0xa
i++
i = encodeVarintTypes(data, i, uint64(m.Raft.Size()))
n21, err := m.Raft.MarshalTo(data[i:])
if err != nil {
return 0, err
if m.RaftID != 0 {
data[i] = 0x8
i++
i = encodeVarintTypes(data, i, uint64(m.RaftID))
}
if len(m.Addr) > 0 {
data[i] = 0x12
i++
i = encodeVarintTypes(data, i, uint64(len(m.Addr)))
i += copy(data[i:], m.Addr)
}
if m.Leader {
data[i] = 0x18
i++
if m.Leader {
data[i] = 1
} else {
data[i] = 0
}
i++
}
if m.Reachability != 0 {
data[i] = 0x20
i++
i = encodeVarintTypes(data, i, uint64(m.Reachability))
}
i += n21
return i, nil
}
@ -4250,21 +4203,6 @@ func (m *RaftConfig) Size() (n int) {
return n
}
func (m *RaftMember) Size() (n int) {
var l int
_ = l
if m.RaftID != 0 {
n += 1 + sovTypes(uint64(m.RaftID))
}
l = len(m.Addr)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = m.Status.Size()
n += 1 + l + sovTypes(uint64(l))
return n
}
func (m *Placement) Size() (n int) {
var l int
_ = l
@ -4341,8 +4279,19 @@ func (m *EncryptionKey) Size() (n int) {
func (m *ManagerStatus) Size() (n int) {
var l int
_ = l
l = m.Raft.Size()
n += 1 + l + sovTypes(uint64(l))
if m.RaftID != 0 {
n += 1 + sovTypes(uint64(m.RaftID))
}
l = len(m.Addr)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.Leader {
n += 2
}
if m.Reachability != 0 {
n += 1 + sovTypes(uint64(m.Reachability))
}
return n
}
@ -4788,18 +4737,6 @@ func (this *RaftConfig) String() string {
}, "")
return s
}
func (this *RaftMember) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&RaftMember{`,
`RaftID:` + fmt.Sprintf("%v", this.RaftID) + `,`,
`Addr:` + fmt.Sprintf("%v", this.Addr) + `,`,
`Status:` + strings.Replace(strings.Replace(this.Status.String(), "RaftMemberStatus", "RaftMemberStatus", 1), `&`, ``, 1) + `,`,
`}`,
}, "")
return s
}
func (this *Placement) String() string {
if this == nil {
return "nil"
@ -4854,7 +4791,10 @@ func (this *ManagerStatus) String() string {
return "nil"
}
s := strings.Join([]string{`&ManagerStatus{`,
`Raft:` + strings.Replace(strings.Replace(this.Raft.String(), "RaftMember", "RaftMember", 1), `&`, ``, 1) + `,`,
`RaftID:` + fmt.Sprintf("%v", this.RaftID) + `,`,
`Addr:` + fmt.Sprintf("%v", this.Addr) + `,`,
`Leader:` + fmt.Sprintf("%v", this.Leader) + `,`,
`Reachability:` + fmt.Sprintf("%v", this.Reachability) + `,`,
`}`,
}, "")
return s
@ -8992,134 +8932,6 @@ func (m *RaftConfig) Unmarshal(data []byte) error {
}
return nil
}
func (m *RaftMember) Unmarshal(data []byte) error {
l := len(data)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: RaftMember: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: RaftMember: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field RaftID", wireType)
}
m.RaftID = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
m.RaftID |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Addr = string(data[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Status.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTypes(data[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Placement) Unmarshal(data []byte) error {
l := len(data)
iNdEx := 0
@ -9708,10 +9520,10 @@ func (m *ManagerStatus) Unmarshal(data []byte) error {
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Raft", wireType)
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field RaftID", wireType)
}
var msglen int
m.RaftID = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
@ -9721,22 +9533,79 @@ func (m *ManagerStatus) Unmarshal(data []byte) error {
}
b := data[iNdEx]
iNdEx++
msglen |= (int(b) & 0x7F) << shift
m.RaftID |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
stringLen |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
postIndex := iNdEx + intStringLen
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Raft.Unmarshal(data[iNdEx:postIndex]); err != nil {
return err
}
m.Addr = string(data[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
v |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Leader = bool(v != 0)
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Reachability", wireType)
}
m.Reachability = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := data[iNdEx]
iNdEx++
m.Reachability |= (RaftMemberStatus_Reachability(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipTypes(data[iNdEx:])
@ -9864,189 +9733,188 @@ var (
)
var fileDescriptorTypes = []byte{
// 2940 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x58, 0xcb, 0x73, 0x1b, 0xc7,
0xd1, 0x27, 0x9e, 0x04, 0x06, 0x20, 0x09, 0xad, 0x64, 0x99, 0x82, 0xf9, 0x51, 0xfa, 0xd6, 0x52,
0x2c, 0x3f, 0x02, 0x5b, 0xb4, 0x93, 0x52, 0xec, 0x72, 0xec, 0xc5, 0x83, 0x22, 0x22, 0x12, 0x44,
0x0d, 0x48, 0xaa, 0x7c, 0x48, 0x50, 0xcb, 0xc5, 0x90, 0x58, 0x73, 0xb1, 0x8b, 0xec, 0x2e, 0x48,
0xa1, 0x52, 0xa9, 0x92, 0x73, 0x49, 0xe2, 0x53, 0xee, 0x29, 0x57, 0x2a, 0x95, 0x5c, 0xf3, 0x0f,
0xe4, 0xa4, 0xa3, 0x8e, 0x49, 0xa5, 0x2a, 0xe5, 0x93, 0x2b, 0x76, 0x0e, 0xb9, 0xa6, 0x2a, 0xa9,
0xf8, 0x90, 0x1c, 0xd2, 0x3d, 0x8f, 0xc5, 0x43, 0x2b, 0x5a, 0x8a, 0x0f, 0x28, 0xec, 0xf4, 0xfc,
0xba, 0xa7, 0xbb, 0xa7, 0xa7, 0xbb, 0x67, 0x48, 0x21, 0x1c, 0x0f, 0x59, 0x50, 0x19, 0xfa, 0x5e,
0xe8, 0x69, 0x5a, 0xcf, 0xb3, 0x4e, 0x98, 0x5f, 0x09, 0xce, 0x4c, 0x7f, 0x70, 0x62, 0x87, 0x95,
0xd3, 0x5b, 0xe5, 0x2b, 0xa1, 0x3d, 0x60, 0x41, 0x68, 0x0e, 0x86, 0xaf, 0x47, 0x5f, 0x02, 0x5e,
0x7e, 0xbe, 0x37, 0xf2, 0xcd, 0xd0, 0xf6, 0xdc, 0xd7, 0xd5, 0x87, 0x9c, 0xb8, 0x74, 0xec, 0x1d,
0x7b, 0xfc, 0xf3, 0x75, 0xfc, 0x12, 0x54, 0xfd, 0x2a, 0x59, 0x3c, 0x60, 0x7e, 0x00, 0x30, 0xed,
0x12, 0xc9, 0xd8, 0x6e, 0x8f, 0xdd, 0x5f, 0x4d, 0x5c, 0x4b, 0xdc, 0x4c, 0x53, 0x31, 0xd0, 0x7f,
0x9d, 0x20, 0x05, 0xc3, 0x75, 0xbd, 0x90, 0xcb, 0x0a, 0x34, 0x8d, 0xa4, 0x5d, 0x73, 0xc0, 0x38,
0x28, 0x4f, 0xf9, 0xb7, 0x56, 0x23, 0x59, 0xc7, 0x3c, 0x64, 0x4e, 0xb0, 0x9a, 0xbc, 0x96, 0xba,
0x59, 0xd8, 0x78, 0xb5, 0xf2, 0xb8, 0xce, 0x95, 0x29, 0x21, 0x95, 0x6d, 0x8e, 0x6e, 0xb8, 0xa1,
0x3f, 0xa6, 0x92, 0xb5, 0xfc, 0x1d, 0x52, 0x98, 0x22, 0x6b, 0x25, 0x92, 0x3a, 0x61, 0x63, 0xb9,
0x0c, 0x7e, 0xa2, 0x7e, 0xa7, 0xa6, 0x33, 0x62, 0xb0, 0x08, 0xd2, 0xc4, 0xe0, 0xed, 0xe4, 0xed,
0x84, 0xfe, 0x01, 0xc9, 0x53, 0x16, 0x78, 0x23, 0xdf, 0x62, 0x81, 0xf6, 0x32, 0xc9, 0xbb, 0xa6,
0xeb, 0x75, 0xad, 0xe1, 0x28, 0xe0, 0xec, 0xa9, 0x6a, 0xf1, 0x8b, 0xcf, 0xae, 0xe6, 0x5a, 0x40,
0xac, 0xb5, 0xf7, 0x03, 0x9a, 0xc3, 0xe9, 0x1a, 0xcc, 0x6a, 0xff, 0x4f, 0x8a, 0x03, 0x36, 0xf0,
0xfc, 0x71, 0xf7, 0x70, 0x1c, 0xb2, 0x80, 0x0b, 0x4e, 0xd1, 0x82, 0xa0, 0x55, 0x91, 0xa4, 0xff,
0x22, 0x41, 0x2e, 0x29, 0xd9, 0x94, 0xfd, 0x70, 0x64, 0xfb, 0x6c, 0xc0, 0xdc, 0x30, 0xd0, 0xbe,
0x05, 0x36, 0xdb, 0x03, 0x3b, 0x14, 0x6b, 0x14, 0x36, 0xfe, 0x2f, 0xce, 0xe6, 0x48, 0x2b, 0x2a,
0xc1, 0x9a, 0x41, 0x8a, 0x3e, 0x0b, 0x98, 0x7f, 0x2a, 0x3c, 0xc1, 0x97, 0xfc, 0x4a, 0xe6, 0x19,
0x16, 0x7d, 0x93, 0xe4, 0xda, 0x8e, 0x19, 0x1e, 0x79, 0xfe, 0x40, 0xd3, 0x49, 0xd1, 0xf4, 0xad,
0xbe, 0x1d, 0x32, 0x2b, 0x1c, 0xf9, 0x6a, 0x57, 0x66, 0x68, 0xda, 0x65, 0x92, 0xf4, 0xc4, 0x42,
0xf9, 0x6a, 0x16, 0x3c, 0x91, 0xdc, 0xed, 0x50, 0xa0, 0xe8, 0xef, 0x90, 0x0b, 0x6d, 0x67, 0x74,
0x6c, 0xbb, 0x75, 0x16, 0x58, 0xbe, 0x3d, 0x44, 0xe9, 0xb8, 0xbd, 0x18, 0x7c, 0x6a, 0x7b, 0xf1,
0x3b, 0xda, 0xf2, 0xe4, 0x64, 0xcb, 0xf5, 0x9f, 0x26, 0xc9, 0x85, 0x86, 0x0b, 0xcc, 0x6c, 0x9a,
0xfb, 0x06, 0x59, 0x66, 0x9c, 0xd8, 0x3d, 0x15, 0x41, 0x25, 0xe5, 0x2c, 0x09, 0xaa, 0x8a, 0xb4,
0xe6, 0x5c, 0xbc, 0xdc, 0x8a, 0x33, 0xff, 0x31, 0xe9, 0x71, 0x51, 0xa3, 0x35, 0xc8, 0xe2, 0x90,
0x1b, 0x11, 0xac, 0xa6, 0xb8, 0xac, 0x1b, 0x71, 0xb2, 0x1e, 0xb3, 0xb3, 0x9a, 0x7e, 0xf4, 0xd9,
0xd5, 0x05, 0xaa, 0x78, 0xbf, 0x4e, 0xf0, 0xfd, 0x35, 0x41, 0x56, 0x5a, 0x5e, 0x6f, 0xc6, 0x0f,
0x65, 0x92, 0xeb, 0x7b, 0x41, 0x38, 0x75, 0x50, 0xa2, 0xb1, 0x76, 0x9b, 0xe4, 0x86, 0x72, 0xfb,
0xe4, 0xee, 0xaf, 0xc5, 0xab, 0x2c, 0x30, 0x34, 0x42, 0x6b, 0xef, 0x90, 0xbc, 0xaf, 0x62, 0x02,
0xac, 0x7d, 0x8a, 0xc0, 0x99, 0xe0, 0xb5, 0x77, 0x49, 0x56, 0x6c, 0xc2, 0x6a, 0x9a, 0x73, 0xde,
0x78, 0x2a, 0x9f, 0x53, 0xc9, 0xa4, 0x7f, 0x9a, 0x20, 0x25, 0x6a, 0x1e, 0x85, 0x3b, 0x6c, 0x70,
0xc8, 0xfc, 0x0e, 0x1c, 0x64, 0x38, 0x3f, 0x97, 0x61, 0x1f, 0x99, 0xd9, 0x63, 0x3e, 0x37, 0x32,
0x47, 0xe5, 0x48, 0xdb, 0xc7, 0x20, 0x37, 0xad, 0xbe, 0x79, 0x68, 0x3b, 0x76, 0x38, 0xe6, 0x66,
0x2e, 0xc7, 0xef, 0xf2, 0xbc, 0x4c, 0x50, 0x7e, 0xc2, 0x48, 0x67, 0xc4, 0x68, 0xab, 0x64, 0x11,
0x72, 0x5d, 0x60, 0x1e, 0x33, 0x6e, 0x7d, 0x9e, 0xaa, 0x21, 0x84, 0x72, 0x71, 0x9a, 0x4f, 0x2b,
0x90, 0xc5, 0xfd, 0xd6, 0xdd, 0xd6, 0xee, 0xbd, 0x56, 0x69, 0x41, 0x5b, 0x21, 0x85, 0xfd, 0x16,
0x6d, 0x18, 0xb5, 0x2d, 0xa3, 0xba, 0xdd, 0x28, 0x25, 0xb4, 0x25, 0x48, 0x17, 0xd1, 0x30, 0xa9,
0xff, 0x2a, 0x41, 0x08, 0x6e, 0xa0, 0x34, 0xea, 0x6d, 0x92, 0x81, 0x7c, 0x1a, 0x8a, 0x8d, 0x5b,
0xde, 0xb8, 0x1e, 0xa7, 0xf5, 0x04, 0x5e, 0xc1, 0x3f, 0x46, 0x05, 0xcb, 0xb4, 0x86, 0xc9, 0x79,
0x0d, 0x33, 0x1c, 0x39, 0xab, 0x5a, 0x8e, 0xa4, 0xeb, 0xf8, 0x95, 0xd0, 0xf2, 0x24, 0x03, 0x3a,
0xd5, 0x3f, 0x28, 0x25, 0x21, 0xf8, 0x8a, 0xf5, 0x66, 0xa7, 0xb6, 0xdb, 0x6a, 0x35, 0x6a, 0x7b,
0x8d, 0x7a, 0x29, 0xa5, 0xdf, 0x20, 0x99, 0xe6, 0x00, 0xa4, 0x68, 0x6b, 0x18, 0x01, 0x47, 0xcc,
0x67, 0xae, 0xa5, 0x02, 0x6b, 0x42, 0xd0, 0xff, 0xb5, 0x48, 0x32, 0x3b, 0xde, 0xc8, 0x0d, 0xb5,
0x8d, 0xa9, 0x53, 0xbc, 0xbc, 0xb1, 0x1e, 0x67, 0x02, 0x07, 0x56, 0xf6, 0x00, 0x25, 0x4f, 0x39,
0x6c, 0xa6, 0x88, 0x15, 0xa9, 0xba, 0x1c, 0x21, 0x3d, 0x34, 0xfd, 0x63, 0x16, 0x4a, 0xa7, 0xcb,
0x11, 0xc6, 0xf8, 0x99, 0x6f, 0x87, 0xe6, 0xa1, 0x23, 0x42, 0x2a, 0x47, 0xa3, 0xb1, 0xb6, 0x45,
0x8a, 0x87, 0x50, 0x3e, 0xba, 0xde, 0x50, 0x64, 0xb9, 0xcc, 0x93, 0x43, 0x4e, 0xe8, 0x51, 0x05,
0xf4, 0xae, 0x00, 0xd3, 0xc2, 0xe1, 0x64, 0xa0, 0xb5, 0xc8, 0xf2, 0xa9, 0xe7, 0x8c, 0x06, 0x2c,
0x92, 0x95, 0xe5, 0xb2, 0x5e, 0x7a, 0xb2, 0xac, 0x03, 0x8e, 0x57, 0xd2, 0x96, 0x4e, 0xa7, 0x87,
0xe5, 0x9f, 0xa4, 0x48, 0x61, 0x6a, 0x31, 0xad, 0x43, 0x0a, 0x50, 0x08, 0x87, 0xe6, 0x31, 0x4f,
0xae, 0xd2, 0x61, 0xb7, 0x9e, 0x4a, 0xd1, 0x4a, 0x7b, 0xc2, 0x48, 0xa7, 0xa5, 0xe8, 0x9f, 0x24,
0x49, 0x61, 0x6a, 0x52, 0x7b, 0x85, 0xe4, 0x68, 0x9b, 0x36, 0x0f, 0x8c, 0xbd, 0x46, 0x69, 0xa1,
0xbc, 0xf6, 0xf1, 0x27, 0xd7, 0x56, 0xb9, 0xb4, 0x69, 0x01, 0x6d, 0xdf, 0x3e, 0xc5, 0xf8, 0xb8,
0x49, 0x16, 0x15, 0x34, 0x51, 0x7e, 0x01, 0xa0, 0xcf, 0xcf, 0x43, 0xa7, 0x90, 0xb4, 0xb3, 0x65,
0x50, 0x08, 0x91, 0x64, 0x3c, 0x92, 0x76, 0xfa, 0xa6, 0xcf, 0x7a, 0xda, 0x37, 0x48, 0x56, 0x02,
0x53, 0xe5, 0x32, 0x00, 0x2f, 0xcf, 0x03, 0x27, 0x38, 0xda, 0xd9, 0x36, 0x0e, 0x1a, 0xa5, 0x74,
0x3c, 0x8e, 0x76, 0x1c, 0xf3, 0x94, 0x69, 0xd7, 0x21, 0x98, 0x39, 0x2c, 0x53, 0xbe, 0x02, 0xb0,
0xe7, 0x1e, 0x13, 0x87, 0xa8, 0xf2, 0xea, 0xcf, 0x7e, 0xb3, 0xbe, 0xf0, 0xfb, 0xdf, 0xae, 0x97,
0xe6, 0xa7, 0xcb, 0xff, 0x4c, 0x90, 0xa5, 0x99, 0x5d, 0xc2, 0x60, 0x1a, 0x7a, 0xc3, 0x91, 0xa3,
0xce, 0x1d, 0x04, 0x93, 0x1a, 0x6b, 0x77, 0xe7, 0xaa, 0xc5, 0x9b, 0x4f, 0xb9, 0xf5, 0xb1, 0xf5,
0xe2, 0x3d, 0xb2, 0xd4, 0x03, 0xff, 0x31, 0xbf, 0x6b, 0x79, 0xee, 0x91, 0x7d, 0x2c, 0xf3, 0x68,
0x39, 0x4e, 0x66, 0x9d, 0x03, 0x69, 0x51, 0x30, 0xd4, 0x38, 0xfe, 0xeb, 0x54, 0x8a, 0x7b, 0x24,
0x8d, 0xe7, 0x4d, 0x7b, 0x81, 0xa4, 0xab, 0xcd, 0x56, 0x1d, 0x42, 0xe1, 0x02, 0x78, 0x6f, 0x89,
0xab, 0x8e, 0x13, 0x18, 0x5b, 0xda, 0x55, 0x92, 0x3d, 0xd8, 0xdd, 0xde, 0xdf, 0xc1, 0xed, 0xbf,
0x08, 0xd3, 0x2b, 0xd1, 0xb4, 0x30, 0xae, 0x7c, 0x41, 0xba, 0x35, 0x1f, 0x4d, 0xe8, 0xff, 0x4e,
0x92, 0x25, 0x8a, 0x5d, 0xa0, 0x1f, 0xb6, 0x3d, 0xc7, 0xb6, 0xc6, 0x5a, 0x9b, 0xe4, 0xc1, 0xbe,
0x9e, 0x3d, 0x15, 0xd4, 0x1b, 0x4f, 0x28, 0x15, 0x13, 0x2e, 0x35, 0xaa, 0x29, 0x4e, 0x3a, 0x11,
0x02, 0x29, 0x25, 0xd3, 0x63, 0x8e, 0x39, 0x3e, 0xaf, 0x66, 0xd5, 0x65, 0xc7, 0x49, 0x05, 0x94,
0xf7, 0x57, 0xe6, 0xfd, 0xae, 0x19, 0x86, 0x6c, 0x30, 0x0c, 0x45, 0xcd, 0x4a, 0x43, 0x7f, 0x65,
0xde, 0x37, 0x24, 0x49, 0x7b, 0x8b, 0x64, 0xcf, 0xc0, 0x6c, 0xef, 0x4c, 0x96, 0xa5, 0xf3, 0xe5,
0x4a, 0xac, 0xfe, 0x31, 0x56, 0xa3, 0x39, 0x65, 0xd1, 0xad, 0xad, 0xdd, 0x56, 0x43, 0xb9, 0x55,
0xce, 0xef, 0xba, 0x2d, 0xcf, 0xc5, 0x90, 0x25, 0xbb, 0xad, 0xee, 0xa6, 0xd1, 0xdc, 0xde, 0xa7,
0xe8, 0xda, 0x4b, 0x00, 0x29, 0x45, 0x90, 0x4d, 0xd3, 0x76, 0xb0, 0x55, 0xba, 0x42, 0x52, 0x46,
0x0b, 0x72, 0x70, 0xb9, 0x04, 0xd3, 0xc5, 0x68, 0xda, 0x70, 0xc7, 0x93, 0x68, 0x9e, 0x5f, 0x57,
0xff, 0x90, 0x14, 0xf7, 0x87, 0x3d, 0x88, 0x54, 0x11, 0x21, 0xda, 0x35, 0x48, 0x29, 0xa6, 0x6f,
0x3a, 0x0e, 0x73, 0xec, 0x60, 0x20, 0xbb, 0xe9, 0x69, 0x12, 0xb4, 0x00, 0x4f, 0xef, 0x4b, 0xd9,
0xa9, 0x08, 0x06, 0xfd, 0xc7, 0x64, 0x05, 0x56, 0x09, 0x4d, 0x28, 0xc9, 0xaa, 0x08, 0x6f, 0x90,
0xa2, 0xa5, 0x48, 0x5d, 0xbb, 0x27, 0x42, 0xb1, 0xba, 0x02, 0x8d, 0x5e, 0x21, 0x82, 0x36, 0xeb,
0xb4, 0x10, 0x81, 0x9a, 0x3d, 0xb4, 0x73, 0x08, 0x50, 0x5c, 0x3e, 0x53, 0x5d, 0x04, 0x68, 0xaa,
0x0d, 0x10, 0xa4, 0x81, 0x17, 0xf3, 0xec, 0xbe, 0x1d, 0xc2, 0xf1, 0xe8, 0x89, 0x32, 0x9b, 0xa1,
0x39, 0x24, 0xd4, 0x60, 0xac, 0x7f, 0x94, 0x24, 0x64, 0xcf, 0x0c, 0x4e, 0xe4, 0xd2, 0xd0, 0x90,
0x44, 0xd7, 0x8f, 0xf3, 0xda, 0xe0, 0x3d, 0x05, 0xa2, 0x13, 0xbc, 0xf6, 0xa6, 0xaa, 0xb3, 0xa2,
0x3b, 0x88, 0x67, 0x94, 0x6b, 0xc5, 0x15, 0xd8, 0xd9, 0x16, 0x00, 0x0f, 0x22, 0xf3, 0x7d, 0x1e,
0x45, 0x70, 0x10, 0xe1, 0x13, 0x6e, 0x25, 0xf9, 0xc8, 0x66, 0x59, 0x81, 0x5e, 0x8c, 0x5b, 0x64,
0xce, 0xa1, 0x5b, 0x0b, 0x74, 0xc2, 0x57, 0x2d, 0x91, 0x65, 0x1f, 0x8e, 0x19, 0x68, 0xdd, 0x0d,
0xf8, 0xb4, 0xfe, 0x27, 0xf0, 0x41, 0xb3, 0x6d, 0xec, 0xc8, 0xdd, 0xae, 0x93, 0xec, 0x91, 0x39,
0xb0, 0x9d, 0xb1, 0x3c, 0x66, 0xaf, 0xc5, 0x2d, 0x31, 0xc1, 0x57, 0x8c, 0x5e, 0x0f, 0x9a, 0xb2,
0x60, 0x93, 0xf3, 0x50, 0xc9, 0xcb, 0x8b, 0xef, 0xe8, 0xd0, 0x85, 0x22, 0xab, 0x8a, 0x2f, 0x1f,
0x61, 0x32, 0xf1, 0x4d, 0x37, 0xb2, 0x56, 0x0c, 0xd0, 0x0b, 0x90, 0x49, 0xd9, 0x19, 0x44, 0x90,
0xb0, 0x57, 0x0d, 0xa1, 0xf0, 0xe6, 0xc4, 0x5d, 0x81, 0xf5, 0xc0, 0x64, 0xcc, 0x96, 0x5f, 0xa5,
0x0f, 0x95, 0x70, 0x91, 0x26, 0x23, 0xee, 0xf2, 0x3b, 0x3c, 0xa5, 0x4c, 0xa6, 0x9e, 0x29, 0xd3,
0xbd, 0x41, 0x96, 0x66, 0xec, 0x7c, 0xac, 0xeb, 0x69, 0xb6, 0x0f, 0xde, 0x2a, 0xa5, 0xe5, 0xd7,
0xb7, 0x4b, 0x59, 0xfd, 0x1f, 0xd0, 0x84, 0xb5, 0x3d, 0x7e, 0xac, 0xd0, 0xab, 0xf1, 0xb7, 0xcc,
0x1c, 0xbf, 0xb3, 0x5a, 0x9e, 0x23, 0x63, 0x26, 0xb6, 0x09, 0x98, 0x48, 0xc1, 0x02, 0xcd, 0xe1,
0x34, 0x62, 0x84, 0xf4, 0x5a, 0x10, 0xfd, 0x4b, 0x77, 0x08, 0x38, 0xee, 0xd6, 0x25, 0x4a, 0x04,
0x09, 0x39, 0xf1, 0x0a, 0x33, 0x1c, 0x1d, 0xc2, 0x31, 0xed, 0xb3, 0x9e, 0xc0, 0xa4, 0x39, 0x66,
0x29, 0xa2, 0x22, 0x4c, 0xaf, 0xc3, 0x25, 0x4c, 0xc9, 0x5c, 0x25, 0xa9, 0xbd, 0x5a, 0x1b, 0xf2,
0xce, 0x0a, 0x64, 0x8d, 0x82, 0x22, 0x03, 0x09, 0x67, 0xf6, 0xeb, 0x6d, 0x48, 0x37, 0x33, 0x33,
0x40, 0x2a, 0xa7, 0x31, 0x9d, 0xe8, 0xbf, 0x4c, 0x90, 0xac, 0xa8, 0x32, 0xb1, 0x16, 0x1b, 0x64,
0x51, 0x75, 0x3d, 0xa2, 0xf4, 0xbd, 0xf4, 0xe4, 0x32, 0x55, 0x91, 0x55, 0x4f, 0xec, 0xa3, 0xe2,
0x2b, 0xbf, 0x4d, 0x8a, 0xd3, 0x13, 0xcf, 0xb4, 0x8b, 0x3f, 0x22, 0x05, 0x0c, 0x14, 0x55, 0xa3,
0x37, 0x48, 0x56, 0x54, 0x42, 0x79, 0xd4, 0xcf, 0xab, 0x99, 0x12, 0x09, 0x99, 0x6e, 0x51, 0xd4,
0x59, 0x75, 0x3d, 0x5b, 0x3f, 0x3f, 0x1c, 0xa9, 0x82, 0xeb, 0xef, 0x91, 0x74, 0x9b, 0x81, 0x84,
0x17, 0xc9, 0xa2, 0x0b, 0xa9, 0x67, 0x92, 0xd9, 0x08, 0xa4, 0xab, 0x2c, 0x36, 0xe0, 0x90, 0xb1,
0xb2, 0x38, 0x05, 0xf9, 0x0c, 0x9c, 0x67, 0x42, 0xbc, 0xa9, 0x1b, 0x2a, 0x7e, 0xeb, 0x7b, 0xa4,
0x78, 0x8f, 0xd9, 0xc7, 0xfd, 0x10, 0x76, 0x0c, 0x05, 0xbd, 0x46, 0xd2, 0x43, 0x16, 0x29, 0xbf,
0x1a, 0x1b, 0x3a, 0x30, 0x4f, 0x39, 0x0a, 0x0f, 0xe4, 0x19, 0xe7, 0x96, 0x8f, 0x02, 0x72, 0xa4,
0xff, 0x2e, 0x49, 0x96, 0x9b, 0x41, 0x30, 0x32, 0xa1, 0xe1, 0x96, 0x59, 0xf0, 0xbb, 0xb3, 0x17,
0x86, 0x9b, 0xb1, 0x16, 0xce, 0xb0, 0xcc, 0x5e, 0x1a, 0x64, 0xe6, 0x4a, 0x46, 0x99, 0x4b, 0x7f,
0x94, 0x50, 0xb7, 0x85, 0x1b, 0x53, 0xe7, 0xa6, 0xbc, 0x0a, 0x41, 0x74, 0x69, 0x5a, 0x12, 0xdb,
0x77, 0x4f, 0x5c, 0xef, 0xcc, 0x85, 0x42, 0x0b, 0xb7, 0x87, 0x56, 0xe3, 0x1e, 0x44, 0xda, 0x65,
0x00, 0x69, 0x33, 0x20, 0xca, 0x5c, 0x76, 0x86, 0x92, 0xda, 0x8d, 0x56, 0xbd, 0xd9, 0xba, 0x03,
0xe5, 0xed, 0x71, 0x49, 0x6d, 0x06, 0xe5, 0xcc, 0x3d, 0x06, 0x77, 0x67, 0x9b, 0x9d, 0xce, 0x3e,
0x6f, 0x15, 0x9f, 0x07, 0xd4, 0xc5, 0x19, 0x14, 0x0e, 0xa0, 0x4f, 0x04, 0x10, 0x56, 0x52, 0x00,
0xa5, 0x63, 0x40, 0x58, 0x4c, 0x21, 0x81, 0x88, 0x08, 0xff, 0x5b, 0x92, 0x94, 0x0c, 0xcb, 0x62,
0xc3, 0x10, 0xe7, 0x65, 0x77, 0xb2, 0x87, 0xdd, 0x1e, 0x7c, 0xd9, 0x0c, 0x5f, 0x4f, 0x30, 0x2c,
0x6e, 0xc7, 0xbe, 0x18, 0xcd, 0xf1, 0x55, 0xa8, 0xe7, 0x30, 0xa3, 0x37, 0xb0, 0x03, 0x7c, 0x45,
0x10, 0x34, 0x1a, 0x49, 0x2a, 0xff, 0x27, 0x41, 0x2e, 0xc6, 0x20, 0xb4, 0x37, 0x48, 0xda, 0x07,
0xb2, 0xdc, 0x9e, 0xb5, 0x27, 0xdd, 0xe7, 0x90, 0x95, 0x72, 0xa4, 0xb6, 0x4e, 0x88, 0x39, 0x0a,
0x3d, 0x93, 0xaf, 0xcf, 0x37, 0x26, 0x47, 0xa7, 0x28, 0xda, 0xf7, 0x21, 0x5b, 0x33, 0xcb, 0x97,
0x57, 0xa2, 0xc2, 0x46, 0xe3, 0x7f, 0xd5, 0xbe, 0xb2, 0x65, 0x62, 0x46, 0xe9, 0x70, 0x61, 0x54,
0x0a, 0x2d, 0xbf, 0x45, 0x8a, 0xd3, 0x74, 0x8c, 0x6e, 0x68, 0x2f, 0x4c, 0x6e, 0x40, 0x91, 0xf2,
0x6f, 0x0c, 0x1a, 0xd3, 0x39, 0x56, 0x41, 0x03, 0x9f, 0x3a, 0x25, 0xb9, 0x9a, 0x21, 0xd3, 0xe7,
0x26, 0x29, 0xf1, 0x43, 0x63, 0x31, 0x3f, 0xec, 0xb2, 0xfb, 0x43, 0xdb, 0x1f, 0xcb, 0xb8, 0x3f,
0xbf, 0xbf, 0x5a, 0x46, 0xae, 0x1a, 0x30, 0x35, 0x38, 0x8f, 0x7e, 0x40, 0x2e, 0xee, 0xfa, 0x56,
0x1f, 0x2a, 0xb6, 0x00, 0x48, 0xf1, 0xef, 0x91, 0xb5, 0x10, 0x2a, 0x73, 0xb7, 0x6f, 0x07, 0x21,
0xbe, 0x9e, 0x81, 0x92, 0xcc, 0xc5, 0xf9, 0x2e, 0x7f, 0xe5, 0x12, 0xaf, 0x6e, 0xf4, 0x0a, 0x62,
0xb6, 0x04, 0x84, 0x2a, 0xc4, 0x36, 0x02, 0xf4, 0x77, 0x49, 0xa9, 0x6e, 0x07, 0x43, 0x33, 0x04,
0xd9, 0xb2, 0xb1, 0xd6, 0x5e, 0x26, 0xa5, 0x3e, 0x83, 0xc6, 0xea, 0x90, 0x99, 0x90, 0x9c, 0x99,
0x6f, 0x7b, 0x3d, 0xd9, 0x3b, 0xad, 0x44, 0xf4, 0x36, 0x27, 0xeb, 0x5f, 0x42, 0xb1, 0xc0, 0x87,
0x03, 0xc9, 0xf9, 0x2a, 0xb9, 0x10, 0xb8, 0xe6, 0x30, 0xe8, 0x7b, 0x61, 0xd7, 0x76, 0x43, 0x7c,
0x29, 0x73, 0x24, 0x6b, 0x49, 0x4d, 0x34, 0x25, 0x1d, 0xd2, 0x80, 0x76, 0xc2, 0xd8, 0xb0, 0xeb,
0x39, 0xbd, 0xae, 0x9a, 0x14, 0xaf, 0x63, 0x80, 0xc6, 0x99, 0x5d, 0xa7, 0xd7, 0x51, 0x74, 0xad,
0x4a, 0xd6, 0x1d, 0xef, 0xb8, 0x0b, 0xba, 0xfb, 0x10, 0x62, 0xdd, 0x23, 0xcf, 0xef, 0x06, 0x8e,
0x77, 0x06, 0x1f, 0x0e, 0xfc, 0x31, 0x5f, 0xf5, 0xb4, 0x65, 0x40, 0x35, 0x04, 0x68, 0xd3, 0xf3,
0x3b, 0x30, 0xb7, 0xa9, 0x10, 0x58, 0x51, 0x26, 0x86, 0x85, 0xb6, 0x75, 0xa2, 0x2a, 0x4a, 0x44,
0xdd, 0x03, 0x22, 0x1c, 0xaa, 0x25, 0xe6, 0x30, 0x8b, 0xbb, 0x91, 0xa3, 0x32, 0x1c, 0x55, 0x54,
0x44, 0x04, 0xe9, 0x3f, 0x97, 0x96, 0x8b, 0x27, 0x13, 0x4c, 0x8e, 0x3e, 0x8c, 0x54, 0x72, 0x4c,
0x8b, 0xe4, 0x88, 0x00, 0x4c, 0x8e, 0x38, 0x15, 0x9f, 0x1c, 0xc1, 0xae, 0xac, 0x68, 0x67, 0x64,
0x04, 0x5f, 0x7f, 0x9a, 0xb7, 0x19, 0xd9, 0x8a, 0x4a, 0x4e, 0xfd, 0x9b, 0x24, 0xdf, 0x76, 0x4c,
0x8b, 0xbf, 0x87, 0x62, 0xd3, 0x0b, 0x99, 0x1b, 0xe3, 0x04, 0x76, 0x40, 0x9c, 0xea, 0x3c, 0x9d,
0x26, 0xe9, 0x1f, 0x41, 0xad, 0xa3, 0x9e, 0x17, 0xd6, 0x0c, 0x00, 0x67, 0x2d, 0xb3, 0xab, 0xea,
0x50, 0xb1, 0x9a, 0x07, 0xad, 0x33, 0x35, 0xe3, 0x2e, 0x1b, 0xd3, 0x8c, 0x65, 0xc2, 0x1f, 0x1a,
0x06, 0x08, 0x0c, 0x5f, 0xae, 0x76, 0x51, 0x18, 0x06, 0xf1, 0x0d, 0x14, 0x0a, 0xcc, 0xf8, 0x0f,
0x07, 0xbb, 0x28, 0x41, 0xdd, 0x3e, 0x9c, 0x17, 0xd1, 0x23, 0x55, 0x97, 0x01, 0x49, 0x04, 0x12,
0x4f, 0x11, 0x25, 0x02, 0x8d, 0xdf, 0xfa, 0x9f, 0x13, 0xa4, 0x80, 0x03, 0xfb, 0xc8, 0xb6, 0x30,
0xbd, 0x3e, 0x7b, 0x6a, 0x80, 0xce, 0xd9, 0x0a, 0x7c, 0xa9, 0x14, 0xef, 0x9c, 0x6b, 0x1d, 0x4a,
0x91, 0xa6, 0xbd, 0x3f, 0xe7, 0x53, 0xfd, 0xab, 0x0b, 0xc1, 0xac, 0x47, 0xb9, 0x13, 0x27, 0xda,
0xf1, 0x30, 0x29, 0xd2, 0x69, 0x12, 0xbe, 0xe5, 0x5a, 0x2e, 0x8f, 0x0c, 0xf9, 0x96, 0x5b, 0x6b,
0x51, 0xa0, 0xe8, 0x7f, 0x84, 0x1b, 0x75, 0xc3, 0xb5, 0xfc, 0x31, 0xaf, 0xd5, 0xe8, 0xc1, 0x35,
0x92, 0x87, 0x1e, 0x32, 0x18, 0x07, 0x70, 0xd1, 0x52, 0x4f, 0x45, 0x11, 0x41, 0x6b, 0x92, 0x3c,
0xe4, 0x0c, 0xcf, 0xb7, 0xc3, 0xfe, 0x40, 0x36, 0x53, 0xaf, 0xc6, 0x3f, 0x08, 0x4e, 0xc9, 0xac,
0x18, 0x8a, 0x85, 0x4e, 0xb8, 0x55, 0x47, 0x91, 0xe2, 0xca, 0xf2, 0x8e, 0x02, 0xae, 0x7d, 0x0e,
0x74, 0xf8, 0xd0, 0x26, 0x75, 0xb1, 0x71, 0xe6, 0x76, 0xc0, 0x0d, 0x48, 0xd2, 0xf0, 0x32, 0xa0,
0xeb, 0x24, 0x1f, 0x09, 0xc3, 0x07, 0x3a, 0xa3, 0xd1, 0xe9, 0xde, 0xda, 0xb8, 0xdd, 0xbd, 0x53,
0xdb, 0x81, 0x42, 0x27, 0x4a, 0x47, 0x93, 0x2c, 0xed, 0x98, 0x2e, 0xf4, 0xf6, 0xea, 0xa6, 0x73,
0x1b, 0x76, 0x0b, 0x42, 0x52, 0x66, 0xb2, 0xf5, 0xf3, 0x43, 0x56, 0xba, 0x96, 0x73, 0xbc, 0xf2,
0x65, 0x8a, 0xe4, 0xa3, 0xbb, 0x04, 0xee, 0x21, 0xd6, 0xca, 0x05, 0x71, 0xcb, 0x8b, 0xe8, 0x2d,
0x5e, 0x25, 0xf3, 0xc6, 0xf6, 0xf6, 0x6e, 0xcd, 0xc0, 0x87, 0xb7, 0xf7, 0x45, 0x31, 0x8d, 0x00,
0x06, 0x9c, 0x68, 0xdc, 0x85, 0x9e, 0xa6, 0x4f, 0x8a, 0xe9, 0x03, 0x79, 0x97, 0x8c, 0x50, 0xaa,
0x92, 0x5e, 0x27, 0x39, 0xa3, 0xd3, 0x69, 0xde, 0x69, 0x81, 0xa4, 0x87, 0x89, 0xf2, 0x73, 0x00,
0xba, 0x30, 0x11, 0x05, 0x45, 0xe0, 0xd8, 0x05, 0x49, 0x88, 0xaa, 0xd5, 0x1a, 0x6d, 0x5c, 0xef,
0x41, 0x72, 0x1e, 0xc5, 0x4b, 0x08, 0x7f, 0x98, 0xc9, 0xb7, 0x69, 0xa3, 0x6d, 0x50, 0x5c, 0xf1,
0x61, 0x72, 0x4e, 0xaf, 0xb6, 0xcf, 0xe0, 0x76, 0x89, 0x6b, 0xae, 0xab, 0x57, 0xc4, 0x07, 0xa9,
0xb2, 0x06, 0x98, 0xe5, 0xc9, 0x05, 0x8a, 0x99, 0xbd, 0x31, 0xae, 0xd6, 0xd9, 0x33, 0xe8, 0x1e,
0x17, 0x93, 0x9a, 0x5b, 0xad, 0x83, 0xd7, 0x5a, 0x94, 0x02, 0xd6, 0xd1, 0xfd, 0x56, 0x8b, 0x5b,
0x97, 0x9e, 0xb3, 0x8e, 0x8e, 0x5c, 0x17, 0x31, 0x37, 0xa0, 0xda, 0xec, 0xee, 0xb4, 0xb7, 0x1b,
0x7b, 0x8d, 0xd2, 0xc3, 0xf4, 0x9c, 0x42, 0x35, 0x6f, 0x30, 0x74, 0x58, 0x28, 0xcc, 0xeb, 0x6c,
0xed, 0xef, 0xf1, 0x47, 0xce, 0x07, 0x99, 0xf9, 0x05, 0xfb, 0xa3, 0xb0, 0x87, 0xed, 0xcb, 0xb5,
0xa8, 0x9f, 0x78, 0x98, 0x11, 0x8f, 0x1e, 0x11, 0x46, 0x34, 0x13, 0x28, 0x87, 0x36, 0xbe, 0x27,
0xde, 0x43, 0x1f, 0x64, 0xe7, 0xe4, 0x50, 0xf6, 0x21, 0xa4, 0x48, 0x68, 0x39, 0xa2, 0xa7, 0x91,
0x68, 0xea, 0x95, 0x1f, 0x90, 0x9c, 0x3a, 0xc1, 0xe0, 0x9d, 0xec, 0xbd, 0x5d, 0x7a, 0xb7, 0x41,
0x61, 0xeb, 0xb9, 0x77, 0xd4, 0xcc, 0x3d, 0xcf, 0x87, 0x40, 0x02, 0x35, 0x16, 0x77, 0x8c, 0x96,
0x71, 0x07, 0x00, 0xf2, 0xed, 0x45, 0x01, 0x64, 0x1c, 0x96, 0x4b, 0x72, 0x81, 0x48, 0x66, 0x75,
0xed, 0xd1, 0xe7, 0xeb, 0x0b, 0x9f, 0xc2, 0xef, 0xef, 0x9f, 0xaf, 0x27, 0x1e, 0x7c, 0xb1, 0x9e,
0x78, 0x04, 0xbf, 0x3f, 0xc0, 0xef, 0x2f, 0xf0, 0x3b, 0xcc, 0xf2, 0x7b, 0xc7, 0x9b, 0xff, 0x0d,
0x00, 0x00, 0xff, 0xff, 0x6c, 0xaf, 0xb7, 0x57, 0xd1, 0x1b, 0x00, 0x00,
// 2920 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x58, 0x4d, 0x6c, 0x1b, 0xc7,
0x15, 0x16, 0x7f, 0x45, 0x0e, 0x29, 0x89, 0x5e, 0x3b, 0x8e, 0xcc, 0xa8, 0xb2, 0xbb, 0x89, 0x1b,
0xe7, 0xa7, 0x4c, 0xac, 0xa4, 0x85, 0x9b, 0x20, 0x4d, 0x96, 0x3f, 0xb2, 0x58, 0x4b, 0x14, 0x31,
0x94, 0x64, 0xe4, 0xd0, 0x12, 0xab, 0xe5, 0x48, 0xdc, 0x68, 0xb9, 0xcb, 0xee, 0x2e, 0x25, 0x13,
0x45, 0x01, 0xa7, 0x97, 0x16, 0x39, 0xf5, 0x5e, 0x04, 0x45, 0xd1, 0x5e, 0x7b, 0x2e, 0xd0, 0x93,
0x8f, 0x3e, 0xb6, 0x28, 0x50, 0xe4, 0x14, 0x34, 0xe9, 0xa1, 0xd7, 0x02, 0x2d, 0x9a, 0x43, 0x7b,
0xe8, 0x7b, 0xf3, 0xb3, 0xfc, 0xf1, 0x5a, 0xb1, 0x9b, 0x1e, 0x08, 0xee, 0xbc, 0xf9, 0xde, 0x9b,
0x79, 0x6f, 0xde, 0xdf, 0x0c, 0x29, 0x84, 0xe3, 0x21, 0x0b, 0x2a, 0x43, 0xdf, 0x0b, 0x3d, 0x4d,
0xeb, 0x79, 0xd6, 0x09, 0xf3, 0x2b, 0xc1, 0x99, 0xe9, 0x0f, 0x4e, 0xec, 0xb0, 0x72, 0x7a, 0xb3,
0x7c, 0x25, 0xb4, 0x07, 0x2c, 0x08, 0xcd, 0xc1, 0xf0, 0xb5, 0xe8, 0x4b, 0xc0, 0xcb, 0xcf, 0xf6,
0x46, 0xbe, 0x19, 0xda, 0x9e, 0xfb, 0x9a, 0xfa, 0x90, 0x13, 0x97, 0x8e, 0xbd, 0x63, 0x8f, 0x7f,
0xbe, 0x86, 0x5f, 0x82, 0xaa, 0x5f, 0x25, 0x8b, 0x07, 0xcc, 0x0f, 0x00, 0xa6, 0x5d, 0x22, 0x19,
0xdb, 0xed, 0xb1, 0x7b, 0xab, 0x89, 0x6b, 0x89, 0x1b, 0x69, 0x2a, 0x06, 0xfa, 0xaf, 0x12, 0xa4,
0x60, 0xb8, 0xae, 0x17, 0x72, 0x59, 0x81, 0xa6, 0x91, 0xb4, 0x6b, 0x0e, 0x18, 0x07, 0xe5, 0x29,
0xff, 0xd6, 0x6a, 0x24, 0xeb, 0x98, 0x87, 0xcc, 0x09, 0x56, 0x93, 0xd7, 0x52, 0x37, 0x0a, 0x1b,
0xaf, 0x54, 0x1e, 0xdd, 0x73, 0x65, 0x4a, 0x48, 0x65, 0x9b, 0xa3, 0x1b, 0x6e, 0xe8, 0x8f, 0xa9,
0x64, 0x2d, 0x7f, 0x87, 0x14, 0xa6, 0xc8, 0x5a, 0x89, 0xa4, 0x4e, 0xd8, 0x58, 0x2e, 0x83, 0x9f,
0xb8, 0xbf, 0x53, 0xd3, 0x19, 0x31, 0x58, 0x04, 0x69, 0x62, 0xf0, 0x56, 0xf2, 0x56, 0x42, 0x7f,
0x9f, 0xe4, 0x29, 0x0b, 0xbc, 0x91, 0x6f, 0xb1, 0x40, 0x7b, 0x89, 0xe4, 0x5d, 0xd3, 0xf5, 0xba,
0xd6, 0x70, 0x14, 0x70, 0xf6, 0x54, 0xb5, 0xf8, 0xf9, 0xa7, 0x57, 0x73, 0x2d, 0x20, 0xd6, 0xda,
0xfb, 0x01, 0xcd, 0xe1, 0x74, 0x0d, 0x66, 0xb5, 0xaf, 0x93, 0xe2, 0x80, 0x0d, 0x3c, 0x7f, 0xdc,
0x3d, 0x1c, 0x87, 0x2c, 0xe0, 0x82, 0x53, 0xb4, 0x20, 0x68, 0x55, 0x24, 0xe9, 0x3f, 0x4f, 0x90,
0x4b, 0x4a, 0x36, 0x65, 0x3f, 0x1c, 0xd9, 0x3e, 0x1b, 0x30, 0x37, 0x0c, 0xb4, 0x6f, 0x81, 0xce,
0xf6, 0xc0, 0x0e, 0xc5, 0x1a, 0x85, 0x8d, 0xaf, 0xc5, 0xe9, 0x1c, 0xed, 0x8a, 0x4a, 0xb0, 0x66,
0x90, 0xa2, 0xcf, 0x02, 0xe6, 0x9f, 0x0a, 0x4b, 0xf0, 0x25, 0xbf, 0x94, 0x79, 0x86, 0x45, 0xdf,
0x24, 0xb9, 0xb6, 0x63, 0x86, 0x47, 0x9e, 0x3f, 0xd0, 0x74, 0x52, 0x34, 0x7d, 0xab, 0x6f, 0x87,
0xcc, 0x0a, 0x47, 0xbe, 0x3a, 0x95, 0x19, 0x9a, 0x76, 0x99, 0x24, 0x3d, 0xb1, 0x50, 0xbe, 0x9a,
0x05, 0x4b, 0x24, 0x77, 0x3b, 0x14, 0x28, 0xfa, 0xdb, 0xe4, 0x42, 0xdb, 0x19, 0x1d, 0xdb, 0x6e,
0x9d, 0x05, 0x96, 0x6f, 0x0f, 0x51, 0x3a, 0x1e, 0x2f, 0x3a, 0x9f, 0x3a, 0x5e, 0xfc, 0x8e, 0x8e,
0x3c, 0x39, 0x39, 0x72, 0xfd, 0xa7, 0x49, 0x72, 0xa1, 0xe1, 0x02, 0x33, 0x9b, 0xe6, 0xbe, 0x4e,
0x96, 0x19, 0x27, 0x76, 0x4f, 0x85, 0x53, 0x49, 0x39, 0x4b, 0x82, 0xaa, 0x3c, 0xad, 0x39, 0xe7,
0x2f, 0x37, 0xe3, 0xd4, 0x7f, 0x44, 0x7a, 0x9c, 0xd7, 0x68, 0x0d, 0xb2, 0x38, 0xe4, 0x4a, 0x04,
0xab, 0x29, 0x2e, 0xeb, 0x7a, 0x9c, 0xac, 0x47, 0xf4, 0xac, 0xa6, 0x1f, 0x7e, 0x7a, 0x75, 0x81,
0x2a, 0xde, 0xaf, 0xe2, 0x7c, 0x7f, 0x4d, 0x90, 0x95, 0x96, 0xd7, 0x9b, 0xb1, 0x43, 0x99, 0xe4,
0xfa, 0x5e, 0x10, 0x4e, 0x05, 0x4a, 0x34, 0xd6, 0x6e, 0x91, 0xdc, 0x50, 0x1e, 0x9f, 0x3c, 0xfd,
0xb5, 0xf8, 0x2d, 0x0b, 0x0c, 0x8d, 0xd0, 0xda, 0xdb, 0x24, 0xef, 0x2b, 0x9f, 0x00, 0x6d, 0x9f,
0xc0, 0x71, 0x26, 0x78, 0xed, 0x1d, 0x92, 0x15, 0x87, 0xb0, 0x9a, 0xe6, 0x9c, 0xd7, 0x9f, 0xc8,
0xe6, 0x54, 0x32, 0xe9, 0x9f, 0x24, 0x48, 0x89, 0x9a, 0x47, 0xe1, 0x0e, 0x1b, 0x1c, 0x32, 0xbf,
0x03, 0x81, 0x0c, 0xf1, 0x73, 0x19, 0xce, 0x91, 0x99, 0x3d, 0xe6, 0x73, 0x25, 0x73, 0x54, 0x8e,
0xb4, 0x7d, 0x74, 0x72, 0xd3, 0xea, 0x9b, 0x87, 0xb6, 0x63, 0x87, 0x63, 0xae, 0xe6, 0x72, 0xfc,
0x29, 0xcf, 0xcb, 0x84, 0xcd, 0x4f, 0x18, 0xe9, 0x8c, 0x18, 0x6d, 0x95, 0x2c, 0x42, 0xae, 0x0b,
0xcc, 0x63, 0xc6, 0xb5, 0xcf, 0x53, 0x35, 0x04, 0x57, 0x2e, 0x4e, 0xf3, 0x69, 0x05, 0xb2, 0xb8,
0xdf, 0xba, 0xd3, 0xda, 0xbd, 0xdb, 0x2a, 0x2d, 0x68, 0x2b, 0xa4, 0xb0, 0xdf, 0xa2, 0x0d, 0xa3,
0xb6, 0x65, 0x54, 0xb7, 0x1b, 0xa5, 0x84, 0xb6, 0x04, 0xe9, 0x22, 0x1a, 0x26, 0xf5, 0x5f, 0x26,
0x08, 0xc1, 0x03, 0x94, 0x4a, 0xbd, 0x45, 0x32, 0x90, 0x4f, 0x43, 0x71, 0x70, 0xcb, 0x1b, 0x2f,
0xc4, 0xed, 0x7a, 0x02, 0xaf, 0xe0, 0x1f, 0xa3, 0x82, 0x65, 0x7a, 0x87, 0xc9, 0xf9, 0x1d, 0x66,
0x38, 0x72, 0x76, 0x6b, 0x39, 0x92, 0xae, 0xe3, 0x57, 0x42, 0xcb, 0x93, 0x0c, 0xec, 0xa9, 0xfe,
0x7e, 0x29, 0x09, 0xce, 0x57, 0xac, 0x37, 0x3b, 0xb5, 0xdd, 0x56, 0xab, 0x51, 0xdb, 0x6b, 0xd4,
0x4b, 0x29, 0xfd, 0x3a, 0xc9, 0x34, 0x07, 0x20, 0x45, 0x5b, 0x43, 0x0f, 0x38, 0x62, 0x3e, 0x73,
0x2d, 0xe5, 0x58, 0x13, 0x82, 0xfe, 0xaf, 0x45, 0x92, 0xd9, 0xf1, 0x46, 0x6e, 0xa8, 0x6d, 0x4c,
0x45, 0xf1, 0xf2, 0xc6, 0x7a, 0x9c, 0x0a, 0x1c, 0x58, 0xd9, 0x03, 0x94, 0x8c, 0x72, 0x38, 0x4c,
0xe1, 0x2b, 0x72, 0xeb, 0x72, 0x84, 0xf4, 0xd0, 0xf4, 0x8f, 0x59, 0x28, 0x8d, 0x2e, 0x47, 0xe8,
0xe3, 0x67, 0xbe, 0x1d, 0x9a, 0x87, 0x8e, 0x70, 0xa9, 0x1c, 0x8d, 0xc6, 0xda, 0x16, 0x29, 0x1e,
0x42, 0xf9, 0xe8, 0x7a, 0x43, 0x91, 0xe5, 0x32, 0x8f, 0x77, 0x39, 0xb1, 0x8f, 0x2a, 0xa0, 0x77,
0x05, 0x98, 0x16, 0x0e, 0x27, 0x03, 0xad, 0x45, 0x96, 0x4f, 0x3d, 0x67, 0x34, 0x60, 0x91, 0xac,
0x2c, 0x97, 0xf5, 0xe2, 0xe3, 0x65, 0x1d, 0x70, 0xbc, 0x92, 0xb6, 0x74, 0x3a, 0x3d, 0x2c, 0xff,
0x24, 0x45, 0x0a, 0x53, 0x8b, 0x69, 0x1d, 0x52, 0x80, 0x42, 0x38, 0x34, 0x8f, 0x79, 0x72, 0x95,
0x06, 0xbb, 0xf9, 0x44, 0x1b, 0xad, 0xb4, 0x27, 0x8c, 0x74, 0x5a, 0x8a, 0xfe, 0x71, 0x92, 0x14,
0xa6, 0x26, 0xb5, 0x97, 0x49, 0x8e, 0xb6, 0x69, 0xf3, 0xc0, 0xd8, 0x6b, 0x94, 0x16, 0xca, 0x6b,
0x1f, 0x7d, 0x7c, 0x6d, 0x95, 0x4b, 0x9b, 0x16, 0xd0, 0xf6, 0xed, 0x53, 0xf4, 0x8f, 0x1b, 0x64,
0x51, 0x41, 0x13, 0xe5, 0xe7, 0x00, 0xfa, 0xec, 0x3c, 0x74, 0x0a, 0x49, 0x3b, 0x5b, 0x06, 0x05,
0x17, 0x49, 0xc6, 0x23, 0x69, 0xa7, 0x6f, 0xfa, 0xac, 0xa7, 0x7d, 0x83, 0x64, 0x25, 0x30, 0x55,
0x2e, 0x03, 0xf0, 0xf2, 0x3c, 0x70, 0x82, 0xa3, 0x9d, 0x6d, 0xe3, 0xa0, 0x51, 0x4a, 0xc7, 0xe3,
0x68, 0xc7, 0x31, 0x4f, 0x99, 0xf6, 0x02, 0x38, 0x33, 0x87, 0x65, 0xca, 0x57, 0x00, 0xf6, 0xcc,
0x23, 0xe2, 0x10, 0x55, 0x5e, 0xfd, 0xd9, 0xaf, 0xd7, 0x17, 0x7e, 0xff, 0x9b, 0xf5, 0xd2, 0xfc,
0x74, 0xf9, 0x9f, 0x09, 0xb2, 0x34, 0x73, 0x4a, 0xe8, 0x4c, 0x43, 0x6f, 0x38, 0x72, 0x54, 0xdc,
0x81, 0x33, 0xa9, 0xb1, 0x76, 0x67, 0xae, 0x5a, 0xbc, 0xf1, 0x84, 0x47, 0x1f, 0x5b, 0x2f, 0xde,
0x25, 0x4b, 0x3d, 0xb0, 0x1f, 0xf3, 0xbb, 0x96, 0xe7, 0x1e, 0xd9, 0xc7, 0x32, 0x8f, 0x96, 0xe3,
0x64, 0xd6, 0x39, 0x90, 0x16, 0x05, 0x43, 0x8d, 0xe3, 0xbf, 0x4a, 0xa5, 0xb8, 0x4b, 0xd2, 0x18,
0x6f, 0xda, 0x73, 0x24, 0x5d, 0x6d, 0xb6, 0xea, 0xe0, 0x0a, 0x17, 0xc0, 0x7a, 0x4b, 0x7c, 0xeb,
0x38, 0x81, 0xbe, 0xa5, 0x5d, 0x25, 0xd9, 0x83, 0xdd, 0xed, 0xfd, 0x1d, 0x3c, 0xfe, 0x8b, 0x30,
0xbd, 0x12, 0x4d, 0x0b, 0xe5, 0xca, 0x17, 0xa4, 0x59, 0xf3, 0xd1, 0x84, 0xfe, 0xef, 0x24, 0x59,
0xa2, 0xd8, 0x05, 0xfa, 0x61, 0xdb, 0x73, 0x6c, 0x6b, 0xac, 0xb5, 0x49, 0x1e, 0xf4, 0xeb, 0xd9,
0x53, 0x4e, 0xbd, 0xf1, 0x98, 0x52, 0x31, 0xe1, 0x52, 0xa3, 0x9a, 0xe2, 0xa4, 0x13, 0x21, 0x90,
0x52, 0x32, 0x3d, 0xe6, 0x98, 0xe3, 0xf3, 0x6a, 0x56, 0x5d, 0x76, 0x9c, 0x54, 0x40, 0x79, 0x7f,
0x65, 0xde, 0xeb, 0x9a, 0x61, 0xc8, 0x06, 0xc3, 0x50, 0xd4, 0xac, 0x34, 0xf4, 0x57, 0xe6, 0x3d,
0x43, 0x92, 0xb4, 0x37, 0x49, 0xf6, 0x0c, 0xd4, 0xf6, 0xce, 0x64, 0x59, 0x3a, 0x5f, 0xae, 0xc4,
0xea, 0x1f, 0x61, 0x35, 0x9a, 0xdb, 0x2c, 0x9a, 0xb5, 0xb5, 0xdb, 0x6a, 0x28, 0xb3, 0xca, 0xf9,
0x5d, 0xb7, 0xe5, 0xb9, 0xe8, 0xb2, 0x64, 0xb7, 0xd5, 0xdd, 0x34, 0x9a, 0xdb, 0xfb, 0x14, 0x4d,
0x7b, 0x09, 0x20, 0xa5, 0x08, 0xb2, 0x69, 0xda, 0x0e, 0xb6, 0x4a, 0x57, 0x48, 0xca, 0x68, 0x41,
0x0e, 0x2e, 0x97, 0x60, 0xba, 0x18, 0x4d, 0x1b, 0xee, 0x78, 0xe2, 0xcd, 0xf3, 0xeb, 0xea, 0x1f,
0x90, 0xe2, 0xfe, 0xb0, 0x07, 0x9e, 0x2a, 0x3c, 0x44, 0xbb, 0x06, 0x29, 0xc5, 0xf4, 0x4d, 0xc7,
0x61, 0x8e, 0x1d, 0x0c, 0x64, 0x37, 0x3d, 0x4d, 0x82, 0x16, 0xe0, 0xc9, 0x6d, 0x29, 0x3b, 0x15,
0xc1, 0xa0, 0xff, 0x98, 0xac, 0xc0, 0x2a, 0xa1, 0x09, 0x25, 0x59, 0x15, 0xe1, 0x0d, 0x52, 0xb4,
0x14, 0xa9, 0x6b, 0xf7, 0x84, 0x2b, 0x56, 0x57, 0xa0, 0xd1, 0x2b, 0x44, 0xd0, 0x66, 0x9d, 0x16,
0x22, 0x50, 0xb3, 0x87, 0x7a, 0x0e, 0x01, 0x8a, 0xcb, 0x67, 0xaa, 0x8b, 0x00, 0x4d, 0xb5, 0x01,
0x82, 0x34, 0xb0, 0x62, 0x9e, 0xdd, 0xb3, 0x43, 0x08, 0x8f, 0x9e, 0x28, 0xb3, 0x19, 0x9a, 0x43,
0x42, 0x0d, 0xc6, 0xfa, 0x87, 0x49, 0x42, 0xf6, 0xcc, 0xe0, 0x44, 0x2e, 0x0d, 0x0d, 0x49, 0x74,
0xfd, 0x38, 0xaf, 0x0d, 0xde, 0x53, 0x20, 0x3a, 0xc1, 0x6b, 0x6f, 0xa8, 0x3a, 0x2b, 0xba, 0x83,
0x78, 0x46, 0xb9, 0x56, 0x5c, 0x81, 0x9d, 0x6d, 0x01, 0x30, 0x10, 0x99, 0xef, 0x73, 0x2f, 0x82,
0x40, 0x84, 0x4f, 0xb8, 0x95, 0xe4, 0x23, 0x9d, 0x65, 0x05, 0x7a, 0x3e, 0x6e, 0x91, 0x39, 0x83,
0x6e, 0x2d, 0xd0, 0x09, 0x5f, 0xb5, 0x44, 0x96, 0x7d, 0x08, 0x33, 0xd8, 0x75, 0x37, 0xe0, 0xd3,
0xfa, 0x9f, 0xc0, 0x06, 0xcd, 0xb6, 0xb1, 0x23, 0x4f, 0xbb, 0x4e, 0xb2, 0x47, 0xe6, 0xc0, 0x76,
0xc6, 0x32, 0xcc, 0x5e, 0x8d, 0x5b, 0x62, 0x82, 0xaf, 0x18, 0xbd, 0x1e, 0x34, 0x65, 0xc1, 0x26,
0xe7, 0xa1, 0x92, 0x97, 0x17, 0xdf, 0xd1, 0xa1, 0x0b, 0x45, 0x56, 0x15, 0x5f, 0x3e, 0xc2, 0x64,
0xe2, 0x9b, 0x6e, 0xa4, 0xad, 0x18, 0xa0, 0x15, 0x20, 0x93, 0xb2, 0x33, 0xf0, 0x20, 0xa1, 0xaf,
0x1a, 0x42, 0xe1, 0xcd, 0x89, 0xbb, 0x02, 0xeb, 0x81, 0xca, 0x98, 0x2d, 0xbf, 0x6c, 0x3f, 0x54,
0xc2, 0x45, 0x9a, 0x8c, 0xb8, 0xcb, 0x6f, 0xf3, 0x94, 0x32, 0x99, 0x7a, 0xaa, 0x4c, 0xf7, 0x3a,
0x59, 0x9a, 0xd1, 0xf3, 0x91, 0xae, 0xa7, 0xd9, 0x3e, 0x78, 0xb3, 0x94, 0x96, 0x5f, 0xdf, 0x2e,
0x65, 0xf5, 0x7f, 0x40, 0x13, 0xd6, 0xf6, 0x78, 0x58, 0xa1, 0x55, 0xe3, 0x6f, 0x99, 0x39, 0x7e,
0x67, 0xb5, 0x3c, 0x47, 0xfa, 0x4c, 0x6c, 0x13, 0x30, 0x91, 0x82, 0x05, 0x9a, 0xc3, 0x69, 0xc4,
0x08, 0xe9, 0xb5, 0x20, 0xfa, 0x97, 0xee, 0x10, 0x70, 0xdc, 0xac, 0x4b, 0x94, 0x08, 0x12, 0x72,
0xe2, 0x15, 0x66, 0x38, 0x3a, 0x84, 0x30, 0xed, 0xb3, 0x9e, 0xc0, 0xa4, 0x39, 0x66, 0x29, 0xa2,
0x22, 0x4c, 0xaf, 0xc3, 0x25, 0x4c, 0xc9, 0x5c, 0x25, 0xa9, 0xbd, 0x5a, 0x1b, 0xf2, 0xce, 0x0a,
0x64, 0x8d, 0x82, 0x22, 0x03, 0x09, 0x67, 0xf6, 0xeb, 0x6d, 0x48, 0x37, 0x33, 0x33, 0x40, 0x2a,
0xa7, 0x31, 0x9d, 0xe8, 0xbf, 0x48, 0x90, 0xac, 0xa8, 0x32, 0xb1, 0x1a, 0x1b, 0x64, 0x51, 0x75,
0x3d, 0xa2, 0xf4, 0xbd, 0xf8, 0xf8, 0x32, 0x55, 0x91, 0x55, 0x4f, 0x9c, 0xa3, 0xe2, 0x2b, 0xbf,
0x45, 0x8a, 0xd3, 0x13, 0x4f, 0x75, 0x8a, 0x3f, 0x22, 0x05, 0x74, 0x14, 0x55, 0xa3, 0x37, 0x48,
0x56, 0x54, 0x42, 0x19, 0xea, 0xe7, 0xd5, 0x4c, 0x89, 0x84, 0x4c, 0xb7, 0x28, 0xea, 0xac, 0xba,
0x9e, 0xad, 0x9f, 0xef, 0x8e, 0x54, 0xc1, 0xf5, 0x77, 0x49, 0xba, 0xcd, 0x40, 0xc2, 0xf3, 0x64,
0xd1, 0x85, 0xd4, 0x33, 0xc9, 0x6c, 0x04, 0xd2, 0x55, 0x16, 0x1b, 0x70, 0xc8, 0x58, 0x59, 0x9c,
0x82, 0x7c, 0x06, 0xc6, 0x33, 0xc1, 0xdf, 0xd4, 0x0d, 0x15, 0xbf, 0xf5, 0x3d, 0x52, 0xbc, 0xcb,
0xec, 0xe3, 0x7e, 0x08, 0x27, 0x86, 0x82, 0x5e, 0x25, 0xe9, 0x21, 0x8b, 0x36, 0xbf, 0x1a, 0xeb,
0x3a, 0x30, 0x4f, 0x39, 0x0a, 0x03, 0xf2, 0x8c, 0x73, 0xcb, 0x47, 0x01, 0x39, 0xd2, 0x7f, 0x9b,
0x24, 0xcb, 0xcd, 0x20, 0x18, 0x99, 0xd0, 0x70, 0xcb, 0x2c, 0xf8, 0xdd, 0xd9, 0x0b, 0xc3, 0x8d,
0x58, 0x0d, 0x67, 0x58, 0x66, 0x2f, 0x0d, 0x32, 0x73, 0x25, 0xa3, 0xcc, 0xa5, 0x3f, 0x4c, 0xa8,
0xdb, 0xc2, 0xf5, 0xa9, 0xb8, 0x29, 0xaf, 0x82, 0x13, 0x5d, 0x9a, 0x96, 0xc4, 0xf6, 0xdd, 0x13,
0xd7, 0x3b, 0x73, 0xa1, 0xd0, 0xc2, 0xed, 0xa1, 0xd5, 0xb8, 0x0b, 0x9e, 0x76, 0x19, 0x40, 0xda,
0x0c, 0x88, 0x32, 0x97, 0x9d, 0xa1, 0xa4, 0x76, 0xa3, 0x55, 0x6f, 0xb6, 0x6e, 0x43, 0x79, 0x7b,
0x54, 0x52, 0x9b, 0x41, 0x39, 0x73, 0x8f, 0xc1, 0xdc, 0xd9, 0x66, 0xa7, 0xb3, 0xcf, 0x5b, 0xc5,
0x67, 0x01, 0x75, 0x71, 0x06, 0x85, 0x03, 0xe8, 0x13, 0x01, 0x84, 0x95, 0x14, 0x40, 0xe9, 0x18,
0x10, 0x16, 0x53, 0x48, 0x20, 0xc2, 0xc3, 0xff, 0x96, 0x24, 0x25, 0xc3, 0xb2, 0xd8, 0x30, 0xc4,
0x79, 0xd9, 0x9d, 0xec, 0x61, 0xb7, 0x07, 0x5f, 0x36, 0xc3, 0xd7, 0x13, 0x74, 0x8b, 0x5b, 0xb1,
0x2f, 0x46, 0x73, 0x7c, 0x15, 0xea, 0x39, 0xcc, 0xe8, 0x0d, 0xec, 0x00, 0x5f, 0x11, 0x04, 0x8d,
0x46, 0x92, 0xca, 0xff, 0x49, 0x90, 0x8b, 0x31, 0x08, 0xed, 0x75, 0x92, 0xf6, 0x81, 0x2c, 0x8f,
0x67, 0xed, 0x71, 0xf7, 0x39, 0x64, 0xa5, 0x1c, 0xa9, 0xad, 0x13, 0x62, 0x8e, 0x42, 0xcf, 0xe4,
0xeb, 0xf3, 0x83, 0xc9, 0xd1, 0x29, 0x8a, 0xf6, 0x7d, 0xc8, 0xd6, 0xcc, 0xf2, 0xe5, 0x95, 0xa8,
0xb0, 0xd1, 0xf8, 0x5f, 0x77, 0x5f, 0xd9, 0x32, 0x31, 0xa3, 0x74, 0xb8, 0x30, 0x2a, 0x85, 0x96,
0xdf, 0x24, 0xc5, 0x69, 0x3a, 0x7a, 0x37, 0xb4, 0x17, 0x26, 0x57, 0xa0, 0x48, 0xf9, 0x37, 0x3a,
0x8d, 0xe9, 0x1c, 0x2b, 0xa7, 0x81, 0x4f, 0x9d, 0x92, 0x5c, 0xcd, 0x90, 0xe9, 0x73, 0x93, 0x94,
0x78, 0xd0, 0x58, 0xcc, 0x0f, 0xbb, 0xec, 0xde, 0xd0, 0xf6, 0xc7, 0xd2, 0xef, 0xcf, 0xef, 0xaf,
0x96, 0x91, 0xab, 0x06, 0x4c, 0x0d, 0xce, 0xa3, 0x1f, 0x90, 0x8b, 0xbb, 0xbe, 0xd5, 0x87, 0x8a,
0x2d, 0x00, 0x52, 0xfc, 0xbb, 0x64, 0x2d, 0x84, 0xca, 0xdc, 0xed, 0xdb, 0x41, 0x88, 0xaf, 0x67,
0xb0, 0x49, 0xe6, 0xe2, 0x7c, 0x97, 0xbf, 0x72, 0x89, 0x57, 0x37, 0x7a, 0x05, 0x31, 0x5b, 0x02,
0x42, 0x15, 0x62, 0x1b, 0x01, 0xfa, 0x3b, 0xa4, 0x54, 0xb7, 0x83, 0xa1, 0x19, 0x82, 0x6c, 0xd9,
0x58, 0x6b, 0x2f, 0x91, 0x52, 0x9f, 0x41, 0x63, 0x75, 0xc8, 0x4c, 0x48, 0xce, 0xcc, 0xb7, 0xbd,
0x9e, 0xec, 0x9d, 0x56, 0x22, 0x7a, 0x9b, 0x93, 0xf5, 0x2f, 0xa0, 0x58, 0xe0, 0xc3, 0x81, 0xe4,
0x7c, 0x85, 0x5c, 0x08, 0x5c, 0x73, 0x18, 0xf4, 0xbd, 0xb0, 0x6b, 0xbb, 0x21, 0xbe, 0x94, 0x39,
0x92, 0xb5, 0xa4, 0x26, 0x9a, 0x92, 0x0e, 0x69, 0x40, 0x3b, 0x61, 0x6c, 0xd8, 0xf5, 0x9c, 0x5e,
0x57, 0x4d, 0x8a, 0xd7, 0x31, 0x40, 0xe3, 0xcc, 0xae, 0xd3, 0xeb, 0x28, 0xba, 0x56, 0x25, 0xeb,
0x8e, 0x77, 0xdc, 0x85, 0xbd, 0xfb, 0xe0, 0x62, 0xdd, 0x23, 0xcf, 0xef, 0x06, 0x8e, 0x77, 0x06,
0x1f, 0x0e, 0xfc, 0x31, 0x5f, 0xf5, 0xb4, 0x65, 0x40, 0x35, 0x04, 0x68, 0xd3, 0xf3, 0x3b, 0x30,
0xb7, 0xa9, 0x10, 0x58, 0x51, 0x26, 0x8a, 0x85, 0xb6, 0x75, 0xa2, 0x2a, 0x4a, 0x44, 0xdd, 0x03,
0x22, 0x04, 0xd5, 0x12, 0x73, 0x98, 0xc5, 0xcd, 0xc8, 0x51, 0x19, 0x8e, 0x2a, 0x2a, 0x22, 0x82,
0xf4, 0x6f, 0x92, 0x7c, 0xdb, 0x31, 0x2d, 0xfe, 0x06, 0x89, 0x8d, 0x26, 0x64, 0x4b, 0x3c, 0x1b,
0xd0, 0x5a, 0x44, 0x52, 0x9e, 0x4e, 0x93, 0xf4, 0x0f, 0xa1, 0xbe, 0x50, 0xcf, 0x0b, 0x6b, 0x06,
0x80, 0xb3, 0x96, 0xd9, 0x55, 0xb9, 0xbf, 0x58, 0xcd, 0x43, 0x1a, 0xcd, 0xd4, 0x8c, 0x3b, 0x6c,
0x4c, 0x33, 0x96, 0x09, 0x7f, 0x98, 0x69, 0x01, 0x81, 0x2e, 0xc3, 0xcd, 0x51, 0x14, 0x99, 0x16,
0x7c, 0x0a, 0x28, 0x14, 0x98, 0xf1, 0x1f, 0x82, 0xa9, 0x28, 0x41, 0xdd, 0x3e, 0xf8, 0xa8, 0xe8,
0x4b, 0xaa, 0xcb, 0x80, 0x24, 0x02, 0x89, 0x9e, 0x4b, 0x89, 0x40, 0xe3, 0xb7, 0xfe, 0xe7, 0x04,
0x29, 0xe0, 0xc0, 0x3e, 0xb2, 0x2d, 0x4c, 0x69, 0x4f, 0x1f, 0x8e, 0xd0, 0xad, 0x5a, 0x81, 0x2f,
0x37, 0xc5, 0xbb, 0xd5, 0x5a, 0x87, 0x52, 0xa4, 0x69, 0xef, 0x41, 0x24, 0xf2, 0x94, 0x2a, 0x23,
0x51, 0xff, 0xf2, 0xe4, 0x2b, 0x1b, 0x6a, 0xc9, 0xc7, 0x8d, 0x38, 0xd9, 0x1d, 0x3f, 0x9a, 0x22,
0x9d, 0x26, 0xe1, 0xfb, 0xa9, 0xe5, 0xf2, 0xd3, 0x90, 0xef, 0xa7, 0xb5, 0x16, 0x05, 0x8a, 0xfe,
0x47, 0xb8, 0xc5, 0x36, 0x5c, 0xcb, 0x1f, 0xf3, 0xfa, 0x88, 0x16, 0x5c, 0x23, 0x79, 0xe8, 0xdb,
0x82, 0x71, 0x00, 0x97, 0x1b, 0xf5, 0x3c, 0x13, 0x11, 0xb4, 0x26, 0xc9, 0x43, 0x9c, 0x7a, 0xbe,
0x1d, 0xf6, 0x07, 0xb2, 0x81, 0x79, 0x25, 0xfe, 0x11, 0x6e, 0x4a, 0x66, 0xc5, 0x50, 0x2c, 0x74,
0xc2, 0xad, 0xaa, 0x78, 0x8a, 0x6f, 0x96, 0x57, 0x71, 0xb8, 0x6a, 0x39, 0xd0, 0x55, 0x43, 0x6b,
0xd2, 0xc5, 0x66, 0x95, 0xeb, 0x01, 0xb7, 0x0e, 0x49, 0xc3, 0x06, 0x5c, 0xd7, 0x49, 0x3e, 0x12,
0x86, 0x8f, 0x62, 0x46, 0xa3, 0xd3, 0xbd, 0xb9, 0x71, 0xab, 0x7b, 0xbb, 0xb6, 0x03, 0xc5, 0x45,
0xa4, 0xeb, 0xdf, 0x81, 0x4e, 0x3b, 0xa6, 0x0b, 0x0d, 0xb5, 0xba, 0x5e, 0x80, 0x57, 0xf8, 0x10,
0x6a, 0xaa, 0xfe, 0xa6, 0x85, 0x57, 0x60, 0xf4, 0x61, 0xfd, 0xc5, 0xa9, 0xf8, 0xfa, 0x3b, 0xf5,
0x38, 0x98, 0x3a, 0xf7, 0x71, 0x30, 0xfd, 0x7f, 0x79, 0x1c, 0x7c, 0xf9, 0x8b, 0x14, 0xc9, 0x47,
0xd7, 0x05, 0x74, 0x19, 0x2c, 0x87, 0x0b, 0xe2, 0x22, 0x17, 0xd1, 0x5b, 0xbc, 0x10, 0xe6, 0x8d,
0xed, 0xed, 0xdd, 0x9a, 0x81, 0x6f, 0x6b, 0xef, 0x89, 0x7a, 0x19, 0x01, 0x0c, 0x08, 0x5a, 0x3c,
0xf4, 0x9e, 0xa6, 0x4f, 0xea, 0xe5, 0x7d, 0x79, 0x5d, 0x8c, 0x50, 0xaa, 0x58, 0xbe, 0x40, 0x72,
0x46, 0xa7, 0xd3, 0xbc, 0xdd, 0x02, 0x49, 0x0f, 0x12, 0xe5, 0x67, 0x00, 0x74, 0x61, 0x22, 0x0a,
0xf2, 0xfc, 0xb1, 0x0b, 0x92, 0x10, 0x55, 0xab, 0x35, 0xda, 0xb8, 0xde, 0xfd, 0xe4, 0x3c, 0x8a,
0x57, 0x09, 0xfe, 0xf6, 0x92, 0x6f, 0xd3, 0x46, 0xdb, 0xa0, 0xb8, 0xe2, 0x83, 0xe4, 0xdc, 0xbe,
0xda, 0x3e, 0x83, 0x0b, 0x24, 0xae, 0xb9, 0xae, 0x1e, 0x0a, 0xef, 0xa7, 0xca, 0x1a, 0x60, 0x96,
0x27, 0x77, 0x24, 0xb0, 0xef, 0x18, 0x57, 0xeb, 0xec, 0x19, 0x74, 0x8f, 0x8b, 0x49, 0xcd, 0xad,
0xd6, 0xc1, 0x9b, 0x2b, 0x4a, 0x01, 0xed, 0xe8, 0x7e, 0xab, 0xc5, 0xb5, 0x4b, 0xcf, 0x69, 0x47,
0x47, 0xae, 0x8b, 0x98, 0xeb, 0x50, 0x50, 0x76, 0x77, 0xda, 0xdb, 0x8d, 0xbd, 0x46, 0xe9, 0x41,
0x7a, 0x6e, 0x43, 0x35, 0x6f, 0x30, 0x74, 0x58, 0x28, 0xd4, 0xeb, 0x6c, 0xed, 0xef, 0xf1, 0x77,
0xcc, 0xfb, 0x99, 0xf9, 0x05, 0xfb, 0xa3, 0xb0, 0x87, 0x1d, 0xca, 0xb5, 0xa8, 0x65, 0x78, 0x90,
0x11, 0xef, 0x1a, 0x11, 0x46, 0xf4, 0x0b, 0x28, 0x87, 0x36, 0xbe, 0x27, 0x9e, 0x3c, 0xef, 0x67,
0xe7, 0xe4, 0x50, 0xf6, 0x01, 0x64, 0x41, 0xe8, 0x2a, 0xa2, 0xd7, 0x8f, 0x68, 0xea, 0xe5, 0x1f,
0x90, 0x9c, 0x4a, 0x18, 0x60, 0x9d, 0xec, 0xdd, 0x5d, 0x7a, 0xa7, 0x41, 0xe1, 0xe8, 0xb9, 0x75,
0xd4, 0xcc, 0x5d, 0xcf, 0x07, 0xef, 0x82, 0x6d, 0x2c, 0xee, 0x18, 0x2d, 0xe3, 0x36, 0x00, 0xe4,
0xf3, 0x8a, 0x02, 0x48, 0xaf, 0x2f, 0x97, 0xe4, 0x02, 0x91, 0xcc, 0xea, 0xda, 0xc3, 0xcf, 0xd6,
0x17, 0x3e, 0x81, 0xdf, 0xdf, 0x3f, 0x5b, 0x4f, 0xdc, 0xff, 0x7c, 0x3d, 0xf1, 0x10, 0x7e, 0x7f,
0x80, 0xdf, 0x5f, 0xe0, 0x77, 0x98, 0xe5, 0x57, 0x8b, 0x37, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff,
0xe7, 0xbe, 0x71, 0xe8, 0xb4, 0x1b, 0x00, 0x00,
}

29
vendor/src/github.com/docker/swarmkit/api/types.proto vendored
View File

@ -484,18 +484,6 @@ message RaftConfig {
uint32 election_tick = 5;
}
message RaftMember {
// RaftID specifies the internal ID used by the manager in a raft context, it can never be modified
// and is used only for information purposes
uint64 raft_id = 1 [(gogoproto.customname) = "RaftID"];
// Addr specifies the address of the member
string addr = 2;
// Status provides the current status of the manager from the perspective of another manager.
RaftMemberStatus status = 3 [(gogoproto.nullable) = false];
}
// Placement specifies task distribution constraints.
message Placement {
// constraints specifies a set of requirements a node should meet for a task.
@ -558,7 +546,18 @@ message EncryptionKey {
uint64 lamport_time = 4;
}
// ManagerStatus provides information about the status of a manager in the cluster.
// ManagerStatus provides informations about the state of a manager in the cluster.
message ManagerStatus {
RaftMember raft = 1 [(gogoproto.nullable) = false];
}
// RaftID specifies the internal ID used by the manager in a raft context, it can never be modified
// and is used only for information purposes
uint64 raft_id = 1 [(gogoproto.customname) = "RaftID"];
// Addr is the address advertised to raft.
string addr = 2;
// Leader is set to true if this node is the raft leader.
bool leader = 3;
// Reachability specifies whether this node is reachable.
RaftMemberStatus.Reachability reachability = 4;
}

2
vendor/src/github.com/docker/swarmkit/ca/certificates.go vendored
View File

@ -476,7 +476,7 @@ func BootstrapCluster(baseCertDir string) error {
return err
}
nodeID := identity.NewNodeID()
nodeID := identity.NewID()
newOrg := identity.NewID()
_, err = GenerateAndSignNewTLSCert(rootCA, nodeID, ManagerRole, newOrg, paths.Node)

2
vendor/src/github.com/docker/swarmkit/ca/config.go vendored
View File

@ -194,7 +194,7 @@ func LoadOrCreateSecurityConfig(ctx context.Context, baseCertDir, caHash, secret
if rootCA.CanSign() {
// Create a new random ID for this certificate
cn := identity.NewNodeID()
cn := identity.NewID()
org := identity.NewID()
if nodeInfo != nil {

9
vendor/src/github.com/docker/swarmkit/ca/server.go vendored
View File

@ -30,6 +30,10 @@ type Server struct {
store *store.MemoryStore
securityConfig *SecurityConfig
acceptancePolicy *api.AcceptancePolicy
// Started is a channel which gets closed once the server is running
// and able to service RPCs.
Started chan struct{}
}
// DefaultAcceptancePolicy returns the default acceptance policy.
@ -60,6 +64,7 @@ func NewServer(store *store.MemoryStore, securityConfig *SecurityConfig) *Server
return &Server{
store: store,
securityConfig: securityConfig,
Started: make(chan struct{}),
}
}
@ -200,7 +205,7 @@ func (s *Server) IssueNodeCertificate(ctx context.Context, request *api.IssueNod
maxRetries := 3
// Generate a random ID for this new node
for i := 0; ; i++ {
nodeID = identity.NewNodeID()
nodeID = identity.NewID()
// Create a new node
err := s.store.Update(func(tx store.Tx) error {
@ -353,6 +358,8 @@ func (s *Server) Run(ctx context.Context) error {
s.ctx, s.cancel = context.WithCancel(ctx)
s.mu.Unlock()
close(s.Started)
// Retrieve the channels to keep track of changes in the cluster
// Retrieve all the currently registered nodes
var nodes []*api.Node

31
vendor/src/github.com/docker/swarmkit/identity/randomid.go vendored
View File

@ -2,12 +2,9 @@ package identity
import (
"crypto/rand"
"encoding/binary"
"errors"
"fmt"
"io"
"math/big"
"strconv"
)
var (
@ -53,31 +50,3 @@ func NewID() string {
nn.SetBytes(p[:])
return fmt.Sprintf("%0[1]*s", maxRandomIDLength, nn.Text(randomIDBase))
}
// NewNodeID generates a new identifier for identifying a node. These IDs
// are shorter than the IDs returned by NewID, so they can be used directly
// by Raft. Because they are short, they MUST be checked for collisions.
func NewNodeID() string {
var p [randomNodeIDEntropyBytes]byte
if _, err := io.ReadFull(idReader, p[:]); err != nil {
panic(fmt.Errorf("failed to read random bytes: %v", err))
}
randomInt := binary.LittleEndian.Uint64(p[:])
return FormatNodeID(randomInt)
}
// FormatNodeID converts a node ID from uint64 to string format.
// A string-formatted node ID looks like 1w8ynjwhcy4zd.
func FormatNodeID(nodeID uint64) string {
return fmt.Sprintf("%0[1]*s", maxRandomNodeIDLength, strconv.FormatUint(nodeID, 36))
}
// ParseNodeID converts a node ID from string format to uint64.
func ParseNodeID(nodeID string) (uint64, error) {
if len(nodeID) != maxRandomNodeIDLength {
return 0, errors.New("node ID has invalid length")
}
return strconv.ParseUint(nodeID, 36, 64)
}

12
vendor/src/github.com/docker/swarmkit/manager/controlapi/cluster.go vendored
View File

@ -169,6 +169,7 @@ func redactClusters(clusters []*api.Cluster) []*api.Cluster {
// Only add public fields to the new clusters
for _, cluster := range clusters {
// Copy all the mandatory fields
// Do not copy secret key
newCluster := &api.Cluster{
ID: cluster.ID,
Meta: cluster.Meta,
@ -179,17 +180,6 @@ func redactClusters(clusters []*api.Cluster) []*api.Cluster {
},
}
// Redact the acceptance policy secrets
if len(newCluster.Spec.AcceptancePolicy.Policies) > 0 {
for _, policy := range newCluster.Spec.AcceptancePolicy.Policies {
// Adding [REDACTED] to the api client so they know there is a
// a secret configured, but without telling them what it is.
if policy.Secret != nil {
policy.Secret.Data = []byte("[REDACTED]")
}
}
}
redactedClusters = append(redactedClusters, newCluster)
}

56
vendor/src/github.com/docker/swarmkit/manager/controlapi/node.go vendored
View File

@ -2,7 +2,6 @@ package controlapi
import (
"github.com/docker/swarmkit/api"
"github.com/docker/swarmkit/identity"
"github.com/docker/swarmkit/manager/state/store"
"golang.org/x/net/context"
"google.golang.org/grpc"
@ -34,9 +33,16 @@ func (s *Server) GetNode(ctx context.Context, request *api.GetNodeRequest) (*api
if s.raft != nil {
memberlist := s.raft.GetMemberlist()
raftID, err := identity.ParseNodeID(request.NodeID)
if err == nil && memberlist[raftID] != nil {
node.ManagerStatus = &api.ManagerStatus{Raft: *memberlist[raftID]}
for _, member := range memberlist {
if member.NodeID == node.ID {
node.ManagerStatus = &api.ManagerStatus{
RaftID: member.RaftID,
Addr: member.Addr,
Leader: member.Status.Leader,
Reachability: member.Status.Reachability,
}
break
}
}
}
@ -148,10 +154,17 @@ func (s *Server) ListNodes(ctx context.Context, request *api.ListNodesRequest) (
if s.raft != nil {
memberlist := s.raft.GetMemberlist()
for _, n := range nodes {
raftID, err := identity.ParseNodeID(n.ID)
if err == nil && memberlist[raftID] != nil {
n.ManagerStatus = &api.ManagerStatus{Raft: *memberlist[raftID]}
for _, node := range nodes {
for _, member := range memberlist {
if member.NodeID == node.ID {
node.ManagerStatus = &api.ManagerStatus{
RaftID: member.RaftID,
Addr: member.Addr,
Leader: member.Status.Leader,
Reachability: member.Status.Reachability,
}
break
}
}
}
}
@ -173,7 +186,10 @@ func (s *Server) UpdateNode(ctx context.Context, request *api.UpdateNodeRequest)
return nil, err
}
var node *api.Node
var (
node *api.Node
demote bool
)
err := s.store.Update(func(tx store.Tx) error {
node = store.GetNode(tx, request.NodeID)
if node == nil {
@ -182,6 +198,7 @@ func (s *Server) UpdateNode(ctx context.Context, request *api.UpdateNodeRequest)
// Demotion sanity checks.
if node.Spec.Role == api.NodeRoleManager && request.Spec.Role == api.NodeRoleWorker {
demote = true
managers, err := store.FindNodes(tx, store.ByRole(api.NodeRoleManager))
if err != nil {
return grpc.Errorf(codes.Internal, "internal store error: %v", err)
@ -201,6 +218,19 @@ func (s *Server) UpdateNode(ctx context.Context, request *api.UpdateNodeRequest)
if node == nil {
return nil, grpc.Errorf(codes.NotFound, "node %s not found", request.NodeID)
}
if demote && s.raft != nil {
memberlist := s.raft.GetMemberlist()
for raftID, member := range memberlist {
if member.NodeID == request.NodeID {
if err := s.raft.RemoveMember(ctx, raftID); err != nil {
return nil, err
}
break
}
}
}
return &api.UpdateNodeResponse{
Node: node,
}, nil
@ -217,9 +247,11 @@ func (s *Server) RemoveNode(ctx context.Context, request *api.RemoveNodeRequest)
}
if s.raft != nil {
memberlist := s.raft.GetMemberlist()
raftID, err := identity.ParseNodeID(request.NodeID)
if err == nil && memberlist[raftID] != nil {
return nil, grpc.Errorf(codes.FailedPrecondition, "node %s is a cluster manager and is part of the quorum. It must be demoted to worker before removal", request.NodeID)
for _, member := range memberlist {
if member.NodeID == request.NodeID {
return nil, grpc.Errorf(codes.FailedPrecondition, "node %s is a cluster manager and is part of the quorum. It must be demoted to worker before removal", request.NodeID)
}
}
}

3
vendor/src/github.com/docker/swarmkit/manager/dispatcher/dispatcher.go vendored
View File

@ -15,7 +15,6 @@ import (
"github.com/Sirupsen/logrus"
"github.com/docker/swarmkit/api"
"github.com/docker/swarmkit/ca"
"github.com/docker/swarmkit/identity"
"github.com/docker/swarmkit/log"
"github.com/docker/swarmkit/manager/state"
"github.com/docker/swarmkit/manager/state/store"
@ -136,7 +135,7 @@ func getWeightedPeers(cluster Cluster) []*api.WeightedPeer {
for _, m := range members {
mgrs = append(mgrs, &api.WeightedPeer{
Peer: &api.Peer{
NodeID: identity.FormatNodeID(m.RaftID),
NodeID: m.NodeID,
Addr: m.Addr,
},
Weight: 1,

5
vendor/src/github.com/docker/swarmkit/manager/manager.go vendored
View File

@ -443,10 +443,12 @@ func (m *Manager) Run(parent context.Context) error {
authenticatedCAAPI := api.NewAuthenticatedWrapperCAServer(m.caserver, authorize)
authenticatedNodeCAAPI := api.NewAuthenticatedWrapperNodeCAServer(m.caserver, authorize)
authenticatedRaftAPI := api.NewAuthenticatedWrapperRaftServer(m.RaftNode, authorize)
authenticatedRaftMembershipAPI := api.NewAuthenticatedWrapperRaftMembershipServer(m.RaftNode, authorize)
proxyDispatcherAPI := api.NewRaftProxyDispatcherServer(authenticatedDispatcherAPI, cs, m.RaftNode, ca.WithMetadataForwardTLSInfo)
proxyCAAPI := api.NewRaftProxyCAServer(authenticatedCAAPI, cs, m.RaftNode, ca.WithMetadataForwardTLSInfo)
proxyNodeCAAPI := api.NewRaftProxyNodeCAServer(authenticatedNodeCAAPI, cs, m.RaftNode, ca.WithMetadataForwardTLSInfo)
proxyRaftMembershipAPI := api.NewRaftProxyRaftMembershipServer(authenticatedRaftMembershipAPI, cs, m.RaftNode, ca.WithMetadataForwardTLSInfo)
// localProxyControlAPI is a special kind of proxy. It is only wired up
// to receive requests from a trusted local socket, and these requests
@ -462,6 +464,7 @@ func (m *Manager) Run(parent context.Context) error {
api.RegisterCAServer(m.server, proxyCAAPI)
api.RegisterNodeCAServer(m.server, proxyNodeCAAPI)
api.RegisterRaftServer(m.server, authenticatedRaftAPI)
api.RegisterRaftMembershipServer(m.server, proxyRaftMembershipAPI)
api.RegisterControlServer(m.localserver, localProxyControlAPI)
api.RegisterControlServer(m.server, authenticatedControlAPI)
api.RegisterDispatcherServer(m.server, proxyDispatcherAPI)
@ -570,7 +573,7 @@ func (m *Manager) Stop(ctx context.Context) {
}
m.RaftNode.Shutdown()
// some time after this point, Run will recieve an error from one of these
// some time after this point, Run will receive an error from one of these
m.server.Stop()
m.localserver.Stop()

45
vendor/src/github.com/docker/swarmkit/manager/orchestrator/services.go vendored
View File

@ -99,29 +99,34 @@ func (r *ReplicatedOrchestrator) reconcile(ctx context.Context, service *api.Ser
// TODO(aaronl): Add support for restart delays.
_, err = r.store.Batch(func(batch *store.Batch) error {
switch {
case specifiedInstances > numTasks:
log.G(ctx).Debugf("Service %s was scaled up from %d to %d instances", service.ID, numTasks, specifiedInstances)
// Update all current tasks then add missing tasks
r.updater.Update(ctx, service, runningTasks)
switch {
case specifiedInstances > numTasks:
log.G(ctx).Debugf("Service %s was scaled up from %d to %d instances", service.ID, numTasks, specifiedInstances)
// Update all current tasks then add missing tasks
r.updater.Update(ctx, service, runningTasks)
_, err = r.store.Batch(func(batch *store.Batch) error {
r.addTasks(ctx, batch, service, runningInstances, specifiedInstances-numTasks)
case specifiedInstances < numTasks:
// Update up to N tasks then remove the extra
log.G(ctx).Debugf("Service %s was scaled down from %d to %d instances", service.ID, numTasks, specifiedInstances)
r.updater.Update(ctx, service, runningTasks[:specifiedInstances])
r.removeTasks(ctx, batch, service, runningTasks[specifiedInstances:])
case specifiedInstances == numTasks:
// Simple update, no scaling - update all tasks.
r.updater.Update(ctx, service, runningTasks)
return nil
})
if err != nil {
log.G(ctx).WithError(err).Errorf("reconcile batch failed")
}
return nil
})
if err != nil {
log.G(ctx).WithError(err).Errorf("reconcile batch failed")
case specifiedInstances < numTasks:
// Update up to N tasks then remove the extra
log.G(ctx).Debugf("Service %s was scaled down from %d to %d instances", service.ID, numTasks, specifiedInstances)
r.updater.Update(ctx, service, runningTasks[:specifiedInstances])
_, err = r.store.Batch(func(batch *store.Batch) error {
r.removeTasks(ctx, batch, service, runningTasks[specifiedInstances:])
return nil
})
if err != nil {
log.G(ctx).WithError(err).Errorf("reconcile batch failed")
}
case specifiedInstances == numTasks:
// Simple update, no scaling - update all tasks.
r.updater.Update(ctx, service, runningTasks)
}
}

3
vendor/src/github.com/docker/swarmkit/manager/scheduler/filter.go vendored
View File

@ -53,6 +53,9 @@ func (f *ResourceFilter) SetTask(t *api.Task) bool {
// Check returns true if the task can be scheduled into the given node.
func (f *ResourceFilter) Check(n *NodeInfo) bool {
if n.AvailableResources == nil {
return false
}
if f.reservations.NanoCPUs > n.AvailableResources.NanoCPUs {
return false
}

20
vendor/src/github.com/docker/swarmkit/manager/scheduler/nodeinfo.go vendored
View File

@ -6,10 +6,10 @@ import "github.com/docker/swarmkit/api"
type NodeInfo struct {
*api.Node
Tasks map[string]*api.Task
AvailableResources api.Resources
AvailableResources *api.Resources
}
func newNodeInfo(n *api.Node, tasks map[string]*api.Task, availableResources api.Resources) NodeInfo {
func newNodeInfo(n *api.Node, tasks map[string]*api.Task, availableResources *api.Resources) NodeInfo {
nodeInfo := NodeInfo{
Node: n,
Tasks: make(map[string]*api.Task),
@ -31,9 +31,11 @@ func (nodeInfo *NodeInfo) removeTask(t *api.Task) bool {
}
delete(nodeInfo.Tasks, t.ID)
reservations := taskReservations(t.Spec)
nodeInfo.AvailableResources.MemoryBytes += reservations.MemoryBytes
nodeInfo.AvailableResources.NanoCPUs += reservations.NanoCPUs
if nodeInfo.AvailableResources != nil {
reservations := taskReservations(t.Spec)
nodeInfo.AvailableResources.MemoryBytes += reservations.MemoryBytes
nodeInfo.AvailableResources.NanoCPUs += reservations.NanoCPUs
}
return true
}
@ -47,9 +49,11 @@ func (nodeInfo *NodeInfo) addTask(t *api.Task) bool {
}
if _, ok := nodeInfo.Tasks[t.ID]; !ok {
nodeInfo.Tasks[t.ID] = t
reservations := taskReservations(t.Spec)
nodeInfo.AvailableResources.MemoryBytes -= reservations.MemoryBytes
nodeInfo.AvailableResources.NanoCPUs -= reservations.NanoCPUs
if nodeInfo.AvailableResources != nil {
reservations := taskReservations(t.Spec)
nodeInfo.AvailableResources.MemoryBytes -= reservations.MemoryBytes
nodeInfo.AvailableResources.NanoCPUs -= reservations.NanoCPUs
}
return true
}

19
vendor/src/github.com/docker/swarmkit/manager/scheduler/scheduler.go vendored
View File

@ -242,13 +242,17 @@ func (s *Scheduler) deleteTask(ctx context.Context, t *api.Task) {
}
func (s *Scheduler) createOrUpdateNode(n *api.Node) {
var resources api.Resources
if n.Description != nil && n.Description.Resources != nil {
resources = *n.Description.Resources
}
nodeInfo := s.nodeHeap.nodeInfo(n.ID)
if n.Description != nil && n.Description.Resources != nil {
if nodeInfo.AvailableResources == nil {
// if nodeInfo.AvailableResources hasn't been initialized
// we copy resources information from node description and
// pass it to nodeInfo
resources := *n.Description.Resources
nodeInfo.AvailableResources = &resources
}
}
nodeInfo.Node = n
nodeInfo.AvailableResources = resources
s.nodeHeap.addOrUpdateNode(nodeInfo)
}
@ -418,9 +422,10 @@ func (s *Scheduler) buildNodeHeap(tx store.ReadTx, tasksByNode map[string]map[st
i := 0
for _, n := range nodes {
var resources api.Resources
var resources *api.Resources
if n.Description != nil && n.Description.Resources != nil {
resources = *n.Description.Resources
resources = &api.Resources{NanoCPUs: n.Description.Resources.NanoCPUs,
MemoryBytes: n.Description.Resources.MemoryBytes}
}
s.nodeHeap.heap = append(s.nodeHeap.heap, newNodeInfo(n, tasksByNode[n.ID], resources))
s.nodeHeap.index[n.ID] = i

108
vendor/src/github.com/docker/swarmkit/manager/state/raft/raft.go vendored
View File

@ -3,6 +3,7 @@ package raft
import (
"errors"
"math"
"math/rand"
"sync"
"sync/atomic"
"time"
@ -22,7 +23,6 @@ import (
"github.com/docker/go-events"
"github.com/docker/swarmkit/api"
"github.com/docker/swarmkit/ca"
"github.com/docker/swarmkit/identity"
"github.com/docker/swarmkit/log"
"github.com/docker/swarmkit/manager/state/raft/membership"
"github.com/docker/swarmkit/manager/state/store"
@ -109,6 +109,8 @@ type Node struct {
// used to coordinate shutdown
stopMu sync.RWMutex
// used for membership management checks
membershipLock sync.Mutex
snapshotInProgress chan uint64
asyncTasks sync.WaitGroup
@ -142,6 +144,10 @@ type NewNodeOptions struct {
TLSCredentials credentials.TransportAuthenticator
}
func init() {
rand.Seed(time.Now().UnixNano())
}
// NewNode generates a new Raft node
func NewNode(ctx context.Context, opts NewNodeOptions) (*Node, error) {
cfg := opts.Config
@ -152,11 +158,6 @@ func NewNode(ctx context.Context, opts NewNodeOptions) (*Node, error) {
opts.TickInterval = time.Second
}
raftID, err := identity.ParseNodeID(opts.ID)
if err != nil {
return nil, err
}
raftStore := raft.NewMemoryStorage()
ctx, cancel := context.WithCancel(ctx)
@ -175,7 +176,6 @@ func NewNode(ctx context.Context, opts NewNodeOptions) (*Node, error) {
MaxSizePerMsg: cfg.MaxSizePerMsg,
MaxInflightMsgs: cfg.MaxInflightMsgs,
Logger: cfg.Logger,
ID: raftID,
},
forceNewCluster: opts.ForceNewCluster,
stopCh: make(chan struct{}),
@ -196,9 +196,10 @@ func NewNode(ctx context.Context, opts NewNodeOptions) (*Node, error) {
n.sendTimeout = opts.SendTimeout
}
if err := n.loadAndStart(ctx, opts.ForceNewCluster); err != nil {
loadAndStartErr := n.loadAndStart(ctx, opts.ForceNewCluster)
if loadAndStartErr != nil && loadAndStartErr != errNoWAL {
n.ticker.Stop()
return nil, err
return nil, loadAndStartErr
}
snapshot, err := raftStore.Snapshot()
@ -213,32 +214,45 @@ func NewNode(ctx context.Context, opts NewNodeOptions) (*Node, error) {
n.reqIDGen = idutil.NewGenerator(uint16(n.Config.ID), time.Now())
n.wait = newWait()
if n.startNodePeers != nil {
if loadAndStartErr == errNoWAL {
if n.joinAddr != "" {
c, err := n.ConnectToMember(n.joinAddr, 10*time.Second)
if err != nil {
return nil, err
}
client := api.NewRaftMembershipClient(c.Conn)
defer func() {
_ = c.Conn.Close()
}()
ctx, cancel := context.WithTimeout(n.Ctx, 10*time.Second)
defer cancel()
resp, err := c.Join(ctx, &api.JoinRequest{
resp, err := client.Join(ctx, &api.JoinRequest{
Addr: n.Address,
})
if err != nil {
return nil, err
}
n.Config.ID = resp.RaftID
if _, err := n.createWAL(opts.ID); err != nil {
return nil, err
}
n.Node = raft.StartNode(n.Config, []raft.Peer{})
if err := n.registerNodes(resp.Members); err != nil {
return nil, err
}
} else {
n.Node = raft.StartNode(n.Config, n.startNodePeers)
// First member in the cluster, self-assign ID
n.Config.ID = uint64(rand.Int63()) + 1
peer, err := n.createWAL(opts.ID)
if err != nil {
return nil, err
}
n.Node = raft.StartNode(n.Config, []raft.Peer{peer})
if err := n.Campaign(n.Ctx); err != nil {
return nil, err
}
@ -363,6 +377,14 @@ func (n *Node) Run(ctx context.Context) error {
// send back an error to the caller to start
// the shutdown process.
if n.mustStop() {
n.stop()
// Move WAL and snapshot out of the way, since
// they are no longer usable.
if err := n.moveWALAndSnap(); err != nil {
n.Config.Logger.Error(err)
}
return ErrMemberRemoved
}
@ -387,7 +409,6 @@ func (n *Node) Run(ctx context.Context) error {
func (n *Node) Shutdown() {
select {
case <-n.doneCh:
n.stop()
default:
close(n.stopCh)
<-n.doneCh
@ -409,7 +430,7 @@ func (n *Node) stop() {
}
n.Stop()
if err := n.wal.Close(); err != nil {
n.Config.Logger.Error(err)
n.Config.Logger.Errorf("raft: error closing WAL: %v", err)
}
// TODO(stevvooe): Handle ctx.Done()
}
@ -446,45 +467,55 @@ func (n *Node) Join(ctx context.Context, req *api.JoinRequest) (*api.JoinRespons
}
log := log.G(ctx).WithFields(fields)
raftID, err := identity.ParseNodeID(nodeInfo.NodeID)
if err != nil {
return nil, err
}
// can't stop the raft node while an async RPC is in progress
n.stopMu.RLock()
defer n.stopMu.RUnlock()
n.membershipLock.Lock()
defer n.membershipLock.Unlock()
if n.Node == nil {
log.WithError(ErrStopped).Errorf(ErrStopped.Error())
return nil, ErrStopped
}
// We submit a configuration change only if the node was not registered yet
if n.cluster.GetMember(raftID) == nil {
err = n.addMember(ctx, req.Addr, raftID)
if err != nil {
log.WithError(err).Errorf("failed to add member")
return nil, err
if !n.IsLeader() {
return nil, ErrLostLeadership
}
// Find a unique ID for the joining member.
var raftID uint64
for {
raftID = uint64(rand.Int63()) + 1
if n.cluster.GetMember(raftID) == nil && !n.cluster.IsIDRemoved(raftID) {
break
}
}
err = n.addMember(ctx, req.Addr, raftID, nodeInfo.NodeID)
if err != nil {
log.WithError(err).Errorf("failed to add member")
return nil, err
}
var nodes []*api.RaftMember
for _, node := range n.cluster.Members() {
nodes = append(nodes, &api.RaftMember{
RaftID: node.RaftID,
NodeID: node.NodeID,
Addr: node.Addr,
})
}
log.Debugf("node joined")
return &api.JoinResponse{Members: nodes}, nil
return &api.JoinResponse{Members: nodes, RaftID: raftID}, nil
}
// addMember submits a configuration change to add a new member on the raft cluster.
func (n *Node) addMember(ctx context.Context, addr string, raftID uint64) error {
func (n *Node) addMember(ctx context.Context, addr string, raftID uint64, nodeID string) error {
node := api.RaftMember{
RaftID: raftID,
NodeID: nodeID,
Addr: addr,
}
@ -531,6 +562,10 @@ func (n *Node) Leave(ctx context.Context, req *api.LeaveRequest) (*api.LeaveResp
return nil, ErrStopped
}
if !n.IsLeader() {
return nil, ErrLostLeadership
}
err = n.RemoveMember(ctx, req.Node.RaftID)
if err != nil {
return nil, err
@ -541,8 +576,9 @@ func (n *Node) Leave(ctx context.Context, req *api.LeaveRequest) (*api.LeaveResp
// RemoveMember submits a configuration change to remove a member from the raft cluster.
func (n *Node) RemoveMember(ctx context.Context, id uint64) error {
// TODO(abronan): this can race if multiple removes are processed, we should
// send all the requests to the Leader and track pending removals.
n.membershipLock.Lock()
defer n.membershipLock.Unlock()
if n.cluster.CanRemoveMember(n.Config.ID, id) {
cc := raftpb.ConfChange{
ID: id,
@ -600,7 +636,7 @@ func (n *Node) ResolveAddress(ctx context.Context, msg *api.ResolveAddressReques
member := n.cluster.GetMember(msg.RaftID)
if member == nil {
return nil, grpc.Errorf(codes.NotFound, "member %s not found", identity.FormatNodeID(msg.RaftID))
return nil, grpc.Errorf(codes.NotFound, "member %x not found", msg.RaftID)
}
return &api.ResolveAddressResponse{Addr: member.Addr}, nil
}
@ -630,6 +666,11 @@ func (n *Node) LeaderAddr() (string, error) {
func (n *Node) registerNode(node *api.RaftMember) error {
member := &membership.Member{}
if n.cluster.GetMember(node.RaftID) != nil {
// member already exists
return nil
}
// Avoid opening a connection to the local node
if node.RaftID != n.Config.ID {
// We don't want to impose a timeout on the grpc connection. It
@ -702,6 +743,7 @@ func (n *Node) GetMemberlist() map[uint64]*api.RaftMember {
memberlist[id] = &api.RaftMember{
RaftID: member.RaftID,
NodeID: member.NodeID,
Addr: member.Addr,
Status: api.RaftMemberStatus{
Leader: leader,
@ -787,7 +829,7 @@ func (n *Node) sendToMember(members map[uint64]*membership.Member, m raftpb.Mess
// If we are being asked to send to a member that's not in
// our member list, that could indicate that the current leader
// was added while we were offline. Try to resolve its address.
n.Config.Logger.Warningf("sending message to an unrecognized member ID %s", identity.FormatNodeID(m.To))
n.Config.Logger.Warningf("sending message to an unrecognized member ID %x", m.To)
// Choose a random member
var (
@ -807,12 +849,12 @@ func (n *Node) sendToMember(members map[uint64]*membership.Member, m raftpb.Mess
resp, err := queryMember.ResolveAddress(ctx, &api.ResolveAddressRequest{RaftID: m.To})
if err != nil {
n.Config.Logger.Errorf("could not resolve address of member ID %s: %v", identity.FormatNodeID(m.To), err)
n.Config.Logger.Errorf("could not resolve address of member ID %x: %v", m.To, err)
return
}
conn, err = n.ConnectToMember(resp.Addr, n.sendTimeout)
if err != nil {
n.Config.Logger.Errorf("could connect to member ID %s at %s: %v", identity.FormatNodeID(m.To), resp.Addr, err)
n.Config.Logger.Errorf("could connect to member ID %x at %s: %v", m.To, resp.Addr, err)
return
}
// The temporary connection is only used for this message.

67
vendor/src/github.com/docker/swarmkit/manager/state/raft/storage.go vendored
View File

@ -1,6 +1,7 @@
package raft
import (
"errors"
"fmt"
"io"
"io/ioutil"
@ -21,6 +22,8 @@ import (
"golang.org/x/net/context"
)
var errNoWAL = errors.New("no WAL present")
func (n *Node) walDir() string {
return filepath.Join(n.StateDir, "wal")
}
@ -41,23 +44,7 @@ func (n *Node) loadAndStart(ctx context.Context, forceNewCluster bool) error {
n.snapshotter = snap.New(snapDir)
if !wal.Exist(walDir) {
raftNode := &api.RaftMember{
RaftID: n.Config.ID,
Addr: n.Address,
}
metadata, err := raftNode.Marshal()
if err != nil {
return fmt.Errorf("error marshalling raft node: %v", err)
}
n.wal, err = wal.Create(walDir, metadata)
if err != nil {
return fmt.Errorf("create wal error: %v", err)
}
n.cluster.AddMember(&membership.Member{RaftMember: raftNode})
n.startNodePeers = []raft.Peer{{ID: n.Config.ID, Context: metadata}}
return nil
return errNoWAL
}
// Load snapshot data
@ -82,6 +69,49 @@ func (n *Node) loadAndStart(ctx context.Context, forceNewCluster bool) error {
return nil
}
func (n *Node) createWAL(nodeID string) (raft.Peer, error) {
raftNode := &api.RaftMember{
RaftID: n.Config.ID,
NodeID: nodeID,
Addr: n.Address,
}
metadata, err := raftNode.Marshal()
if err != nil {
return raft.Peer{}, fmt.Errorf("error marshalling raft node: %v", err)
}
n.wal, err = wal.Create(n.walDir(), metadata)
if err != nil {
return raft.Peer{}, fmt.Errorf("create wal error: %v", err)
}
n.cluster.AddMember(&membership.Member{RaftMember: raftNode})
return raft.Peer{ID: n.Config.ID, Context: metadata}, nil
}
// moveWALAndSnap moves away the WAL and snapshot because we were removed
// from the cluster and will need to recreate them if we are readded.
func (n *Node) moveWALAndSnap() error {
newWALDir, err := ioutil.TempDir(n.StateDir, "wal.")
if err != nil {
return err
}
err = os.Rename(n.walDir(), newWALDir)
if err != nil {
return err
}
newSnapDir, err := ioutil.TempDir(n.StateDir, "snap.")
if err != nil {
return err
}
err = os.Rename(n.snapDir(), newSnapDir)
if err != nil {
return err
}
return nil
}
func (n *Node) readWAL(ctx context.Context, snapshot *raftpb.Snapshot, forceNewCluster bool) (err error) {
var (
walsnap walpb.Snapshot
@ -238,6 +268,7 @@ func (n *Node) doSnapshot(raftConfig *api.RaftConfig) {
for _, member := range n.cluster.Members() {
snapshot.Membership.Members = append(snapshot.Membership.Members,
&api.RaftMember{
NodeID: member.NodeID,
RaftID: member.RaftID,
Addr: member.Addr,
})
@ -312,7 +343,7 @@ func (n *Node) restoreFromSnapshot(data []byte, forceNewCluster bool) error {
if !forceNewCluster {
for _, member := range snapshot.Membership.Members {
if err := n.registerNode(&api.RaftMember{RaftID: member.RaftID, Addr: member.Addr}); err != nil {
if err := n.registerNode(&api.RaftMember{RaftID: member.RaftID, NodeID: member.NodeID, Addr: member.Addr}); err != nil {
return err
}
}

1
vendor/src/github.com/docker/swarmkit/manager/state/raft/util.go vendored
View File

@ -29,6 +29,7 @@ func dial(addr string, protocol string, creds credentials.TransportAuthenticator
// Register registers the node raft server
func Register(server *grpc.Server, node *Node) {
api.RegisterRaftServer(server, node)
api.RegisterRaftMembershipServer(server, node)
}
// WaitForLeader waits until node observe some leader in cluster. It returns