github/client-go
1
0
Fork 0
mirror of https://github.com/kubernetes/client-go.git synced 2025-07-31 23:00:26 +00:00
Code Issues Projects Releases Wiki Activity

Generated code

Browse Source 
Kubernetes-commit: 37a54d521afa6b65f86426826068a1499b22a4c9
This commit is contained in:
Kenneth Owens 2017-06-12 10:08:46 -07:00 committed by Kubernetes Publisher
parent e12b58626c
commit c2459566d6
11 changed files with 424 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
pkg/apis/apps/types.go
View File

@ -66,11 +66,8 @@ const (
type StatefulSetUpdateStrategy struct {
// Type indicates the type of the StatefulSetUpdateStrategy.
Type StatefulSetUpdateStrategyType
// Partition is used to communicate the ordinal at which to partition
// the StatefulSet when Type is PartitionStatefulSetStrategyType. This
// value must be set when Type is PartitionStatefulSetStrategyType,
// and it must be nil otherwise.
Partition *PartitionStatefulSetStrategy
// RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType.
RollingUpdate *RollingUpdateStatefulSetStrategy
}
// StatefulSetUpdateStrategyType is a string enumeration type that enumerates
@ -78,14 +75,6 @@ type StatefulSetUpdateStrategy struct {
type StatefulSetUpdateStrategyType string
const (
// PartitionStatefulSetStrategyType indicates that updates will only be
// applied to a partition of the StatefulSet. This is useful for canaries
// and phased roll outs. When a scale operation is performed with this
// strategy, new Pods will be created from the specification version indicated
// by the StatefulSet's currentRevision if there ordinal is less than the supplied
// Partition's ordinal. Otherwise, they will be created from the specification
// version indicated by the StatefulSet's updateRevision.
PartitionStatefulSetStrategyType StatefulSetUpdateStrategyType = "Partition"
// RollingUpdateStatefulSetStrategyType indicates that update will be
// applied to all Pods in the StatefulSet with respect to the StatefulSet
// ordering constraints. When a scale operation is performed with this
@ -100,12 +89,11 @@ const (
OnDeleteStatefulSetStrategyType = "OnDelete"
)
// PartitionStatefulSetStrategy contains the parameters used with the
// PartitionStatefulSetStrategyType.
type PartitionStatefulSetStrategy struct {
// Ordinal indicates the ordinal at which the StatefulSet should be
// RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType.
type RollingUpdateStatefulSetStrategy struct {
// Partition indicates the ordinal at which the StatefulSet should be
// partitioned.
Ordinal int32
Partition int32
}
// A StatefulSetSpec is the specification of a StatefulSet.

17
pkg/apis/apps/v1beta1/conversion.go
View File

@ -167,22 +167,23 @@ func Convert_apps_StatefulSetSpec_To_v1beta1_StatefulSetSpec(in *apps.StatefulSe
func Convert_v1beta1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(in *StatefulSetUpdateStrategy, out *apps.StatefulSetUpdateStrategy, s conversion.Scope) error {
out.Type = apps.StatefulSetUpdateStrategyType(in.Type)
if in.Partition != nil {
out.Partition = new(apps.PartitionStatefulSetStrategy)
out.Partition.Ordinal = in.Partition.Ordinal
if in.RollingUpdate != nil {
out.RollingUpdate = new(apps.RollingUpdateStatefulSetStrategy)
out.RollingUpdate.Partition = *in.RollingUpdate.Partition
} else {
out.Partition = nil
out.RollingUpdate = nil
}
return nil
}
func Convert_apps_StatefulSetUpdateStrategy_To_v1beta1_StatefulSetUpdateStrategy(in *apps.StatefulSetUpdateStrategy, out *StatefulSetUpdateStrategy, s conversion.Scope) error {
out.Type = StatefulSetUpdateStrategyType(in.Type)
if in.Partition != nil {
out.Partition = new(PartitionStatefulSetStrategy)
out.Partition.Ordinal = in.Partition.Ordinal
if in.RollingUpdate != nil {
out.RollingUpdate = new(RollingUpdateStatefulSetStrategy)
out.RollingUpdate.Partition = new(int32)
*out.RollingUpdate.Partition = in.RollingUpdate.Partition
} else {
out.Partition = nil
out.RollingUpdate = nil
}
return nil
}

6
pkg/apis/apps/v1beta1/defaults.go
View File

@ -53,6 +53,12 @@ func SetDefaults_StatefulSet(obj *StatefulSet) {
obj.Spec.RevisionHistoryLimit = new(int32)
*obj.Spec.RevisionHistoryLimit = 10
}
if obj.Spec.UpdateStrategy.Type == RollingUpdateStatefulSetStrategyType &&
obj.Spec.UpdateStrategy.RollingUpdate != nil &&
obj.Spec.UpdateStrategy.RollingUpdate.Partition == nil {
obj.Spec.UpdateStrategy.RollingUpdate.Partition = new(int32)
*obj.Spec.UpdateStrategy.RollingUpdate.Partition = 0
}
}

487
pkg/apis/apps/v1beta1/generated.pb.go
View File

@ -34,9 +34,9 @@ limitations under the License.
DeploymentSpec
DeploymentStatus
DeploymentStrategy
PartitionStatefulSetStrategy
RollbackConfig
RollingUpdateDeployment
RollingUpdateStatefulSetStrategy
Scale
ScaleSpec
ScaleStatus
@ -110,19 +110,19 @@ func (m *DeploymentStrategy) Reset() { *m = DeploymentStrateg
func (*DeploymentStrategy) ProtoMessage() {}
func (*DeploymentStrategy) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{8} }
func (m *PartitionStatefulSetStrategy) Reset() { *m = PartitionStatefulSetStrategy{} }
func (*PartitionStatefulSetStrategy) ProtoMessage() {}
func (*PartitionStatefulSetStrategy) Descriptor() ([]byte, []int) {
return fileDescriptorGenerated, []int{9}
}
func (m *RollbackConfig) Reset() { *m = RollbackConfig{} }
func (*RollbackConfig) ProtoMessage() {}
func (*RollbackConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{10} }
func (*RollbackConfig) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{9} }
func (m *RollingUpdateDeployment) Reset() { *m = RollingUpdateDeployment{} }
func (*RollingUpdateDeployment) ProtoMessage() {}
func (*RollingUpdateDeployment) Descriptor() ([]byte, []int) {
return fileDescriptorGenerated, []int{10}
}
func (m *RollingUpdateStatefulSetStrategy) Reset() { *m = RollingUpdateStatefulSetStrategy{} }
func (*RollingUpdateStatefulSetStrategy) ProtoMessage() {}
func (*RollingUpdateStatefulSetStrategy) Descriptor() ([]byte, []int) {
return fileDescriptorGenerated, []int{11}
}
@ -170,9 +170,9 @@ func init() {
proto.RegisterType((*DeploymentSpec)(nil), "k8s.io.client-go.pkg.apis.apps.v1beta1.DeploymentSpec")
proto.RegisterType((*DeploymentStatus)(nil), "k8s.io.client-go.pkg.apis.apps.v1beta1.DeploymentStatus")
proto.RegisterType((*DeploymentStrategy)(nil), "k8s.io.client-go.pkg.apis.apps.v1beta1.DeploymentStrategy")
proto.RegisterType((*PartitionStatefulSetStrategy)(nil), "k8s.io.client-go.pkg.apis.apps.v1beta1.PartitionStatefulSetStrategy")
proto.RegisterType((*RollbackConfig)(nil), "k8s.io.client-go.pkg.apis.apps.v1beta1.RollbackConfig")
proto.RegisterType((*RollingUpdateDeployment)(nil), "k8s.io.client-go.pkg.apis.apps.v1beta1.RollingUpdateDeployment")
proto.RegisterType((*RollingUpdateStatefulSetStrategy)(nil), "k8s.io.client-go.pkg.apis.apps.v1beta1.RollingUpdateStatefulSetStrategy")
proto.RegisterType((*Scale)(nil), "k8s.io.client-go.pkg.apis.apps.v1beta1.Scale")
proto.RegisterType((*ScaleSpec)(nil), "k8s.io.client-go.pkg.apis.apps.v1beta1.ScaleSpec")
proto.RegisterType((*ScaleStatus)(nil), "k8s.io.client-go.pkg.apis.apps.v1beta1.ScaleStatus")
@ -599,27 +599,6 @@ func (m *DeploymentStrategy) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *PartitionStatefulSetStrategy) 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 *PartitionStatefulSetStrategy) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
dAtA[i] = 0x8
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.Ordinal))
return i, nil
}
func (m *RollbackConfig) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -679,6 +658,29 @@ func (m *RollingUpdateDeployment) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *RollingUpdateStatefulSetStrategy) 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 *RollingUpdateStatefulSetStrategy) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
if m.Partition != nil {
dAtA[i] = 0x8
i++
i = encodeVarintGenerated(dAtA, i, uint64(*m.Partition))
}
return i, nil
}
func (m *Scale) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -1000,11 +1002,11 @@ func (m *StatefulSetUpdateStrategy) MarshalTo(dAtA []byte) (int, error) {
i++
i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
i += copy(dAtA[i:], m.Type)
if m.Partition != nil {
if m.RollingUpdate != nil {
dAtA[i] = 0x12
i++
i = encodeVarintGenerated(dAtA, i, uint64(m.Partition.Size()))
n28, err := m.Partition.MarshalTo(dAtA[i:])
i = encodeVarintGenerated(dAtA, i, uint64(m.RollingUpdate.Size()))
n28, err := m.RollingUpdate.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
@ -1189,13 +1191,6 @@ func (m *DeploymentStrategy) Size() (n int) {
return n
}
func (m *PartitionStatefulSetStrategy) Size() (n int) {
var l int
_ = l
n += 1 + sovGenerated(uint64(m.Ordinal))
return n
}
func (m *RollbackConfig) Size() (n int) {
var l int
_ = l
@ -1217,6 +1212,15 @@ func (m *RollingUpdateDeployment) Size() (n int) {
return n
}
func (m *RollingUpdateStatefulSetStrategy) Size() (n int) {
var l int
_ = l
if m.Partition != nil {
n += 1 + sovGenerated(uint64(*m.Partition))
}
return n
}
func (m *Scale) Size() (n int) {
var l int
_ = l
@ -1331,8 +1335,8 @@ func (m *StatefulSetUpdateStrategy) Size() (n int) {
_ = l
l = len(m.Type)
n += 1 + l + sovGenerated(uint64(l))
if m.Partition != nil {
l = m.Partition.Size()
if m.RollingUpdate != nil {
l = m.RollingUpdate.Size()
n += 1 + l + sovGenerated(uint64(l))
}
return n
@ -1480,16 +1484,6 @@ func (this *DeploymentStrategy) String() string {
}, "")
return s
}
func (this *PartitionStatefulSetStrategy) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&PartitionStatefulSetStrategy{`,
`Ordinal:` + fmt.Sprintf("%v", this.Ordinal) + `,`,
`}`,
}, "")
return s
}
func (this *RollbackConfig) String() string {
if this == nil {
return "nil"
@ -1511,6 +1505,16 @@ func (this *RollingUpdateDeployment) String() string {
}, "")
return s
}
func (this *RollingUpdateStatefulSetStrategy) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&RollingUpdateStatefulSetStrategy{`,
`Partition:` + valueToStringGenerated(this.Partition) + `,`,
`}`,
}, "")
return s
}
func (this *Scale) String() string {
if this == nil {
return "nil"
@ -1617,7 +1621,7 @@ func (this *StatefulSetUpdateStrategy) String() string {
}
s := strings.Join([]string{`&StatefulSetUpdateStrategy{`,
`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
`Partition:` + strings.Replace(fmt.Sprintf("%v", this.Partition), "PartitionStatefulSetStrategy", "PartitionStatefulSetStrategy", 1) + `,`,
`RollingUpdate:` + strings.Replace(fmt.Sprintf("%v", this.RollingUpdate), "RollingUpdateStatefulSetStrategy", "RollingUpdateStatefulSetStrategy", 1) + `,`,
`}`,
}, "")
return s
@ -3174,75 +3178,6 @@ func (m *DeploymentStrategy) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *PartitionStatefulSetStrategy) 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 ErrIntOverflowGenerated
}
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: PartitionStatefulSetStrategy: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: PartitionStatefulSetStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Ordinal", wireType)
}
m.Ordinal = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Ordinal |= (int32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *RollbackConfig) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -3428,6 +3363,76 @@ func (m *RollingUpdateDeployment) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *RollingUpdateStatefulSetStrategy) 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 ErrIntOverflowGenerated
}
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: RollingUpdateStatefulSetStrategy: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: RollingUpdateStatefulSetStrategy: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Partition", wireType)
}
var v int32
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= (int32(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
m.Partition = &v
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Scale) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -4638,7 +4643,7 @@ func (m *StatefulSetUpdateStrategy) Unmarshal(dAtA []byte) error {
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Partition", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field RollingUpdate", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@ -4662,10 +4667,10 @@ func (m *StatefulSetUpdateStrategy) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Partition == nil {
m.Partition = &PartitionStatefulSetStrategy{}
if m.RollingUpdate == nil {
m.RollingUpdate = &RollingUpdateStatefulSetStrategy{}
}
if err := m.Partition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
if err := m.RollingUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@ -4800,119 +4805,119 @@ func init() {
}
var fileDescriptorGenerated = []byte{
// 1818 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0x4f, 0x4f, 0x23, 0xc9,
0x15, 0xa7, 0xfd, 0x07, 0x4c, 0xb1, 0x98, 0xa1, 0x20, 0xe0, 0x65, 0x37, 0x06, 0xf9, 0xb0, 0xcb,
0x44, 0x4b, 0x3b, 0xc3, 0x4c, 0x76, 0x67, 0x20, 0x1a, 0x85, 0x66, 0xc8, 0x66, 0x22, 0x08, 0xa8,
0x0c, 0xa3, 0xec, 0x64, 0x23, 0x6d, 0xb9, 0x5d, 0xd3, 0xf4, 0xd2, 0xff, 0xd4, 0x5d, 0x76, 0xc6,
0xb7, 0x28, 0x52, 0x6e, 0x39, 0xe4, 0x0b, 0x44, 0xb9, 0x47, 0x91, 0xf2, 0x35, 0x50, 0x72, 0xc8,
0x6a, 0x4f, 0xa3, 0x1c, 0x50, 0xf0, 0x7c, 0x84, 0x28, 0x97, 0x39, 0x45, 0x55, 0x5d, 0xfd, 0xdf,
0x0d, 0xb6, 0xa3, 0x70, 0xc9, 0xcd, 0x5d, 0xef, 0xbd, 0xdf, 0x7b, 0x55, 0xf5, 0xde, 0xab, 0xdf,
0x33, 0xf8, 0xec, 0xe2, 0xb1, 0x27, 0xeb, 0x76, 0xf3, 0xa2, 0xdb, 0x26, 0xae, 0x45, 0x28, 0xf1,
0x9a, 0xce, 0x85, 0xd6, 0xc4, 0x8e, 0xee, 0x35, 0xb1, 0xe3, 0x78, 0xcd, 0xde, 0x83, 0x36, 0xa1,
0xf8, 0x41, 0x53, 0x23, 0x16, 0x71, 0x31, 0x25, 0x1d, 0xd9, 0x71, 0x6d, 0x6a, 0xc3, 0x8f, 0x7d,
0x43, 0x39, 0x32, 0x94, 0x9d, 0x0b, 0x4d, 0x66, 0x86, 0x32, 0x33, 0x94, 0x85, 0xe1, 0xda, 0x96,
0xa6, 0xd3, 0xf3, 0x6e, 0x5b, 0x56, 0x6d, 0xb3, 0xa9, 0xd9, 0x9a, 0xdd, 0xe4, 0xf6, 0xed, 0xee,
0x2b, 0xfe, 0xc5, 0x3f, 0xf8, 0x2f, 0x1f, 0x77, 0xed, 0x91, 0x08, 0x08, 0x3b, 0xba, 0x89, 0xd5,
0x73, 0xdd, 0x22, 0x6e, 0x3f, 0x0a, 0xc9, 0x24, 0x14, 0x37, 0x7b, 0x99, 0x68, 0xd6, 0x9a, 0x79,
0x56, 0x6e, 0xd7, 0xa2, 0xba, 0x49, 0x32, 0x06, 0x9f, 0xde, 0x66, 0xe0, 0xa9, 0xe7, 0xc4, 0xc4,
0x19, 0xbb, 0x87, 0x79, 0x76, 0x5d, 0xaa, 0x1b, 0x4d, 0xdd, 0xa2, 0x1e, 0x75, 0x33, 0x46, 0x9f,
0xe4, 0x1e, 0xf2, 0xb0, 0xbd, 0x3c, 0xb9, 0xe1, 0x4a, 0x1c, 0xdb, 0xd0, 0xd5, 0x7e, 0xde, 0xa5,
0x34, 0xfe, 0x2d, 0x01, 0xb8, 0x6f, 0x5b, 0xd4, 0xb5, 0x0d, 0x83, 0xb8, 0x88, 0xf4, 0x74, 0x4f,
0xb7, 0x2d, 0xf8, 0x15, 0xa8, 0xb0, 0x83, 0xeb, 0x60, 0x8a, 0x6b, 0xd2, 0x86, 0xb4, 0x39, 0xb7,
0xfd, 0x7d, 0x59, 0x5c, 0x5f, 0x7c, 0x1f, 0xd1, 0x05, 0x32, 0x6d, 0xb9, 0xf7, 0x40, 0x3e, 0x6e,
0x7f, 0x4d, 0x54, 0x7a, 0x44, 0x28, 0x56, 0xe0, 0xe5, 0xd5, 0xfa, 0xd4, 0xe0, 0x6a, 0x1d, 0x44,
0x6b, 0x28, 0x44, 0x85, 0xc7, 0xa0, 0xc4, 0xd1, 0x0b, 0x1c, 0x7d, 0x2b, 0x17, 0x5d, 0x9c, 0xae,
0x8c, 0xf0, 0xaf, 0x0e, 0x5e, 0x53, 0x62, 0xb1, 0xf0, 0x94, 0xf7, 0x04, 0x74, 0xe9, 0x19, 0xa6,
0x18, 0x71, 0x20, 0xf8, 0x09, 0xa8, 0xb8, 0x22, 0xfc, 0x5a, 0x71, 0x43, 0xda, 0x2c, 0x2a, 0xf7,
0x84, 0x56, 0x25, 0xd8, 0x16, 0x0a, 0x35, 0x1a, 0x6f, 0x24, 0xb0, 0x92, 0xdd, 0xf7, 0xa1, 0xee,
0x51, 0xf8, 0x65, 0x66, 0xef, 0xf2, 0x68, 0x7b, 0x67, 0xd6, 0x7c, 0xe7, 0xa1, 0xe3, 0x60, 0x25,
0xb6, 0xef, 0xaf, 0x40, 0x59, 0xa7, 0xc4, 0xf4, 0x6a, 0x85, 0x8d, 0xe2, 0xe6, 0xdc, 0xf6, 0xae,
0x3c, 0x62, 0x55, 0xc8, 0xd9, 0x68, 0x95, 0x79, 0xe1, 0xa7, 0xfc, 0x9c, 0x21, 0x22, 0x1f, 0xb8,
0xf1, 0xe7, 0x02, 0x00, 0xcf, 0x88, 0x63, 0xd8, 0x7d, 0x93, 0x58, 0xf4, 0x0e, 0xae, 0xf2, 0x0b,
0x50, 0xf2, 0x1c, 0xa2, 0x8a, 0xab, 0xfc, 0x6c, 0xe4, 0x1d, 0x45, 0x41, 0xb6, 0x1c, 0xa2, 0x46,
0x97, 0xca, 0xbe, 0x10, 0x87, 0x84, 0x18, 0x4c, 0x7b, 0x14, 0xd3, 0xae, 0xc7, 0xaf, 0x74, 0x6e,
0xfb, 0xc9, 0x24, 0xe0, 0x1c, 0x40, 0xa9, 0x0a, 0xf8, 0x69, 0xff, 0x1b, 0x09, 0xe0, 0xc6, 0x75,
0x11, 0x2c, 0x45, 0xca, 0xfb, 0xb6, 0xd5, 0xd1, 0x29, 0x2b, 0x81, 0x5d, 0x50, 0xa2, 0x7d, 0x87,
0xf0, 0x33, 0x9b, 0x55, 0x3e, 0x0e, 0x82, 0x3b, 0xed, 0x3b, 0xe4, 0xdd, 0xd5, 0xfa, 0xea, 0x10,
0x13, 0x26, 0x42, 0xdc, 0x08, 0xbe, 0x08, 0xe3, 0x2e, 0x70, 0xf3, 0xa7, 0x49, 0xe7, 0xef, 0xae,
0xd6, 0x6f, 0xac, 0x70, 0x39, 0xc4, 0x4c, 0x06, 0x0b, 0x3f, 0x02, 0xd3, 0x2e, 0xc1, 0x9e, 0x6d,
0xd5, 0x4a, 0x1c, 0x37, 0xdc, 0x14, 0xe2, 0xab, 0x48, 0x48, 0xe1, 0x7d, 0x30, 0x63, 0x12, 0xcf,
0xc3, 0x1a, 0xa9, 0x95, 0xb9, 0xe2, 0x82, 0x50, 0x9c, 0x39, 0xf2, 0x97, 0x51, 0x20, 0x87, 0x5f,
0x83, 0xaa, 0x81, 0x3d, 0x7a, 0xe6, 0x74, 0x30, 0x25, 0xa7, 0xba, 0x49, 0x6a, 0xd3, 0xfc, 0xa8,
0xbf, 0x37, 0x5a, 0x96, 0x30, 0x0b, 0x65, 0x45, 0xa0, 0x57, 0x0f, 0x13, 0x48, 0x28, 0x85, 0x0c,
0x7b, 0x00, 0xb2, 0x95, 0x53, 0x17, 0x5b, 0x9e, 0x7f, 0x64, 0xcc, 0xdf, 0xcc, 0xd8, 0xfe, 0xd6,
0x84, 0x3f, 0x78, 0x98, 0x41, 0x43, 0x43, 0x3c, 0x34, 0x2e, 0x25, 0x50, 0x8d, 0x2e, 0xec, 0x0e,
0xaa, 0xfc, 0xe7, 0xc9, 0x2a, 0x7f, 0x38, 0x41, 0xda, 0xe6, 0x54, 0xf7, 0xef, 0x8a, 0x00, 0x46,
0x4a, 0xc8, 0x36, 0x8c, 0x36, 0x56, 0x2f, 0xe0, 0x06, 0x28, 0x59, 0xd8, 0x0c, 0xb2, 0x35, 0x2c,
0xa5, 0x9f, 0x61, 0x93, 0x20, 0x2e, 0x81, 0x7f, 0x94, 0x00, 0xec, 0xf2, 0xab, 0xe8, 0xec, 0x59,
0x96, 0x4d, 0x31, 0x3b, 0x9d, 0x20, 0xc0, 0xd6, 0x04, 0x01, 0x06, 0xbe, 0xe5, 0xb3, 0x0c, 0xea,
0x81, 0x45, 0xdd, 0x7e, 0x74, 0x4b, 0x59, 0x05, 0x34, 0x24, 0x14, 0x78, 0x01, 0x80, 0x2b, 0x30,
0x4f, 0x6d, 0x51, 0xf0, 0xa3, 0x77, 0x93, 0x20, 0x9c, 0x7d, 0xdb, 0x7a, 0xa5, 0x6b, 0x51, 0xcb,
0x42, 0x21, 0x24, 0x8a, 0xc1, 0xaf, 0x1d, 0x80, 0xd5, 0x9c, 0xb8, 0xe1, 0x3d, 0x50, 0xbc, 0x20,
0x7d, 0xff, 0x28, 0x11, 0xfb, 0x09, 0x97, 0x41, 0xb9, 0x87, 0x8d, 0x2e, 0xf1, 0xab, 0x19, 0xf9,
0x1f, 0x3b, 0x85, 0xc7, 0x52, 0xe3, 0x1f, 0xe5, 0x78, 0x66, 0xb1, 0xce, 0x05, 0x37, 0xd9, 0x43,
0xe4, 0x18, 0xba, 0x8a, 0x3d, 0x8e, 0x51, 0x56, 0xde, 0xf3, 0x1f, 0x21, 0x7f, 0x0d, 0x85, 0x52,
0xf8, 0x4b, 0x50, 0xf1, 0x88, 0x41, 0x54, 0x6a, 0xbb, 0xa2, 0x79, 0x3e, 0x1c, 0x31, 0x07, 0x71,
0x9b, 0x18, 0x2d, 0x61, 0xea, 0xc3, 0x07, 0x5f, 0x28, 0x84, 0x84, 0xbf, 0x00, 0x15, 0x4a, 0x4c,
0xc7, 0xc0, 0x94, 0x88, 0xd3, 0xdc, 0xca, 0x3f, 0x4d, 0x06, 0x7b, 0x62, 0x77, 0x4e, 0x85, 0x01,
0xef, 0xc8, 0x61, 0x86, 0x07, 0xab, 0x28, 0x04, 0x84, 0x3a, 0xa8, 0x78, 0x94, 0x31, 0x09, 0xad,
0xcf, 0x7b, 0xd1, 0x38, 0x4f, 0x59, 0xbc, 0x37, 0xfb, 0x10, 0x91, 0xab, 0x60, 0x05, 0x85, 0xf0,
0x70, 0x0f, 0x2c, 0x98, 0xba, 0x85, 0x08, 0xee, 0xf4, 0x5b, 0x44, 0xb5, 0xad, 0x8e, 0xc7, 0x9b,
0x5a, 0x59, 0x59, 0x15, 0x46, 0x0b, 0x47, 0x49, 0x31, 0x4a, 0xeb, 0xc3, 0x43, 0xb0, 0x1c, 0x3c,
0xfd, 0x3f, 0xd1, 0x3d, 0x6a, 0xbb, 0xfd, 0x43, 0xdd, 0xd4, 0x29, 0x6f, 0x75, 0x65, 0xa5, 0x36,
0xb8, 0x5a, 0x5f, 0x46, 0x43, 0xe4, 0x68, 0xa8, 0x15, 0xeb, 0xc2, 0x0e, 0xee, 0x7a, 0xa4, 0xc3,
0x5b, 0x57, 0x25, 0xea, 0xc2, 0x27, 0x7c, 0x15, 0x09, 0x29, 0xd4, 0x12, 0x09, 0x5d, 0xf9, 0xef,
0x12, 0xba, 0x9a, 0x9f, 0xcc, 0xf0, 0x0c, 0xac, 0x3a, 0xae, 0xad, 0xb9, 0xc4, 0xf3, 0x9e, 0x11,
0xdc, 0x31, 0x74, 0x8b, 0x04, 0x27, 0x35, 0xcb, 0x77, 0xf8, 0xc1, 0xe0, 0x6a, 0x7d, 0xf5, 0x64,
0xb8, 0x0a, 0xca, 0xb3, 0x6d, 0x7c, 0x5b, 0x02, 0xf7, 0xd2, 0xef, 0x28, 0xfc, 0x29, 0x80, 0x76,
0xdb, 0x23, 0x6e, 0x8f, 0x74, 0x3e, 0xf7, 0xc9, 0x24, 0x63, 0x5c, 0x12, 0x67, 0x5c, 0x61, 0xc5,
0x1f, 0x67, 0x34, 0xd0, 0x10, 0x2b, 0x9f, 0xb3, 0x89, 0x52, 0x29, 0xf0, 0x40, 0x63, 0x9c, 0x2d,
0x53, 0x2e, 0x7b, 0x60, 0x41, 0x74, 0x8d, 0x40, 0xc8, 0xd3, 0x3a, 0x96, 0x07, 0x67, 0x49, 0x31,
0x4a, 0xeb, 0xc3, 0xcf, 0xc1, 0x22, 0xee, 0x61, 0xdd, 0xc0, 0x6d, 0x83, 0x84, 0x20, 0x25, 0x0e,
0xf2, 0xbe, 0x00, 0x59, 0xdc, 0x4b, 0x2b, 0xa0, 0xac, 0x0d, 0x3c, 0x02, 0x4b, 0x5d, 0x2b, 0x0b,
0xe5, 0xe7, 0xe5, 0x07, 0x02, 0x6a, 0xe9, 0x2c, 0xab, 0x82, 0x86, 0xd9, 0x41, 0x07, 0x00, 0x35,
0x78, 0xf2, 0xbd, 0xda, 0x34, 0xef, 0xc9, 0x3f, 0x9c, 0xa0, 0x9e, 0x42, 0xde, 0x10, 0xf5, 0xbf,
0x70, 0xc9, 0x43, 0x31, 0x1f, 0x70, 0x17, 0xcc, 0xbb, 0xac, 0x42, 0xc2, 0xd0, 0x67, 0x78, 0xe8,
0xdf, 0x11, 0x66, 0xf3, 0x28, 0x2e, 0x44, 0x49, 0x5d, 0xb8, 0x03, 0xaa, 0xaa, 0x6d, 0x18, 0xbc,
0x32, 0xf6, 0xed, 0xae, 0x45, 0x79, 0x72, 0x17, 0x15, 0xc8, 0x38, 0xc0, 0x7e, 0x42, 0x82, 0x52,
0x9a, 0x8d, 0xbf, 0x49, 0xf1, 0x07, 0x2c, 0x28, 0x77, 0xb8, 0x93, 0xa0, 0x5b, 0x1f, 0xa5, 0xe8,
0xd6, 0x4a, 0xd6, 0x22, 0xc6, 0xb6, 0xfa, 0x60, 0x9e, 0x15, 0x83, 0x6e, 0x69, 0x7e, 0x02, 0x88,
0x66, 0xfa, 0xa3, 0xb1, 0x4a, 0x2d, 0xb4, 0x8e, 0x3d, 0xc1, 0x8b, 0xfc, 0x24, 0xe2, 0x42, 0x94,
0xf4, 0xd4, 0x78, 0x0e, 0x3e, 0x3c, 0xc1, 0x2e, 0x0d, 0xb9, 0x1a, 0x79, 0xd5, 0x35, 0x5a, 0x24,
0xda, 0xd6, 0x7d, 0x30, 0x63, 0xbb, 0x1d, 0xdd, 0xc2, 0x86, 0x78, 0x0b, 0x42, 0x22, 0x76, 0xec,
0x2f, 0xa3, 0x40, 0xde, 0x78, 0x0a, 0xaa, 0xc9, 0x92, 0x4f, 0x8c, 0x34, 0xd2, 0xad, 0x23, 0xcd,
0x5b, 0x09, 0xac, 0xe6, 0x6c, 0x04, 0x1a, 0xa0, 0x6a, 0xe2, 0xd7, 0xb1, 0x74, 0xbc, 0x75, 0x14,
0x60, 0xd3, 0xa9, 0xec, 0x4f, 0xa7, 0xf2, 0x73, 0x8b, 0x1e, 0xbb, 0x2d, 0xea, 0xea, 0x96, 0xe6,
0x5f, 0xf1, 0x51, 0x02, 0x0b, 0xa5, 0xb0, 0xe1, 0x4b, 0x50, 0x31, 0xf1, 0xeb, 0x56, 0xd7, 0xd5,
0x82, 0xab, 0x18, 0xdf, 0x0f, 0x7f, 0xd4, 0x8e, 0x04, 0x0a, 0x0a, 0xf1, 0x1a, 0x7f, 0x28, 0x80,
0x72, 0x4b, 0xc5, 0x06, 0xb9, 0x83, 0xc1, 0xe6, 0x34, 0x31, 0xd8, 0x6c, 0x8f, 0x9c, 0x4e, 0x3c,
0xbe, 0xdc, 0x99, 0xe6, 0xcb, 0xd4, 0x4c, 0xf3, 0x68, 0x4c, 0xdc, 0x9b, 0xc7, 0x99, 0x27, 0x60,
0x36, 0x74, 0x9f, 0xe8, 0xaf, 0xd2, 0x6d, 0xfd, 0xb5, 0xf1, 0xa7, 0x02, 0x98, 0x8b, 0xb9, 0x18,
0xcf, 0x1a, 0x3a, 0x09, 0x32, 0xc3, 0x1a, 0x98, 0x32, 0xc9, 0xc6, 0xe4, 0x80, 0xc8, 0xf8, 0x1c,
0x32, 0xe2, 0x05, 0x59, 0x7e, 0xf3, 0x14, 0x54, 0x29, 0x76, 0x35, 0x42, 0x03, 0x19, 0x3f, 0xd0,
0xd9, 0x68, 0x1a, 0x39, 0x4d, 0x48, 0x51, 0x4a, 0x7b, 0x6d, 0x17, 0xcc, 0x27, 0x9c, 0x8d, 0x45,
0xfc, 0xfe, 0xc2, 0x0e, 0x2b, 0x2a, 0xf8, 0x3b, 0xc8, 0xc6, 0x97, 0x89, 0x6c, 0x7c, 0x3c, 0xfa,
0xe1, 0xc6, 0xda, 0x52, 0x5e, 0x4e, 0xb6, 0x53, 0x39, 0xb9, 0x33, 0x11, 0xfa, 0xcd, 0x99, 0xf9,
0x57, 0x09, 0x2c, 0xc4, 0xb4, 0xef, 0x60, 0x0a, 0xfb, 0x22, 0x39, 0x85, 0x3d, 0x9a, 0x64, 0x53,
0x39, 0x63, 0xd8, 0xbf, 0xca, 0x89, 0xcd, 0xfc, 0x1f, 0x11, 0xff, 0xdf, 0x4a, 0x60, 0xb9, 0x67,
0x1b, 0x5d, 0x93, 0xec, 0x1b, 0x58, 0x37, 0x03, 0x0d, 0x46, 0xa3, 0x6e, 0x19, 0x75, 0xb9, 0x27,
0xe2, 0x7a, 0xba, 0x47, 0x89, 0x45, 0x5f, 0x44, 0x18, 0xca, 0x87, 0xc2, 0xdf, 0xf2, 0x8b, 0x21,
0xc0, 0x68, 0xa8, 0x3b, 0xf8, 0x03, 0x30, 0xc7, 0xf8, 0xa4, 0xae, 0x12, 0x36, 0xe4, 0x8a, 0xbf,
0x39, 0x96, 0x04, 0xd0, 0x5c, 0x2b, 0x12, 0xa1, 0xb8, 0x1e, 0x3c, 0x07, 0x4b, 0x8e, 0xdd, 0x39,
0xc2, 0x16, 0xd6, 0x08, 0x7b, 0x1a, 0x4f, 0xf8, 0xff, 0xa3, 0x7c, 0x10, 0x98, 0x55, 0x3e, 0x0d,
0x88, 0xdb, 0x49, 0x56, 0xe5, 0x1d, 0x63, 0xd0, 0xd9, 0x65, 0x4e, 0x43, 0x86, 0x41, 0xc2, 0xdf,
0x48, 0xa0, 0xea, 0xf3, 0xcf, 0x80, 0x0d, 0x88, 0x7f, 0x3a, 0x94, 0x49, 0xf2, 0xf0, 0x2c, 0x81,
0x14, 0xf5, 0xb8, 0xe4, 0x3a, 0x4a, 0x79, 0xcc, 0x1d, 0x7c, 0x2a, 0x93, 0x0c, 0x3e, 0x8d, 0xbf,
0x17, 0xc1, 0x62, 0xa6, 0xe0, 0xe1, 0x8f, 0x6f, 0x98, 0x08, 0x56, 0xfe, 0x67, 0xd3, 0x40, 0x86,
0xc0, 0x16, 0xc7, 0x20, 0xb0, 0x7b, 0x60, 0x41, 0xed, 0xba, 0x2e, 0xb1, 0x68, 0x6a, 0x0a, 0x08,
0x47, 0x89, 0xfd, 0xa4, 0x18, 0xa5, 0xf5, 0x87, 0x4d, 0x23, 0xe5, 0x31, 0xa7, 0x91, 0x78, 0x14,
0x82, 0xe6, 0xf9, 0x79, 0x98, 0x8d, 0x42, 0xb0, 0xbd, 0xb4, 0x3e, 0x7b, 0x03, 0x7d, 0xd4, 0x10,
0x61, 0x26, 0xf9, 0x06, 0x9e, 0x25, 0xa4, 0x28, 0xa5, 0xdd, 0xf8, 0x56, 0x02, 0xef, 0xe7, 0x66,
0x19, 0xdc, 0x4b, 0x90, 0xf2, 0xad, 0x14, 0x29, 0xff, 0x6e, 0xae, 0x61, 0x8c, 0x9b, 0xbb, 0x60,
0xd6, 0x09, 0x08, 0xb2, 0xe8, 0x75, 0x07, 0x23, 0xe7, 0xff, 0x4d, 0xd4, 0x5a, 0x99, 0x1f, 0x5c,
0xad, 0xcf, 0x86, 0x1a, 0x28, 0x72, 0xa3, 0xdc, 0xbf, 0xbc, 0xae, 0x4f, 0x7d, 0x73, 0x5d, 0x9f,
0x7a, 0x73, 0x5d, 0x9f, 0xfa, 0xf5, 0xa0, 0x2e, 0x5d, 0x0e, 0xea, 0xd2, 0x37, 0x83, 0xba, 0xf4,
0xcf, 0x41, 0x5d, 0xfa, 0xfd, 0xdb, 0xfa, 0xd4, 0xcb, 0x19, 0xe1, 0xe1, 0x3f, 0x01, 0x00, 0x00,
0xff, 0xff, 0x4f, 0x0f, 0xec, 0xcc, 0xce, 0x1a, 0x00, 0x00,
// 1809 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0x4f, 0x6f, 0x23, 0x49,
0x15, 0x4f, 0xfb, 0x4f, 0xe2, 0x54, 0x36, 0xce, 0x4c, 0x25, 0x4c, 0xbc, 0x59, 0x70, 0x22, 0x1f,
0x76, 0xb3, 0xb0, 0x69, 0x33, 0x99, 0x61, 0x77, 0x26, 0x41, 0x23, 0xd2, 0x99, 0x61, 0x19, 0x94,
0x90, 0xa8, 0x9c, 0x8c, 0xd8, 0x61, 0x91, 0xb6, 0xdc, 0xae, 0xe9, 0xf4, 0xa6, 0xff, 0xa9, 0xbb,
0xda, 0x8c, 0x6f, 0x68, 0x25, 0x6e, 0x1c, 0xf8, 0x02, 0x88, 0x3b, 0x42, 0xe2, 0x6b, 0x44, 0x70,
0x60, 0xc5, 0x69, 0xc5, 0x21, 0x22, 0x9e, 0x8f, 0x80, 0xb8, 0xcc, 0x09, 0x55, 0x75, 0xf5, 0x7f,
0x77, 0x62, 0x1b, 0x91, 0x0b, 0x37, 0x77, 0xbd, 0xf7, 0x7e, 0xef, 0x55, 0xd5, 0x7b, 0xaf, 0x7e,
0xcf, 0xe0, 0x93, 0xf3, 0x47, 0x9e, 0xac, 0xdb, 0xed, 0x73, 0xbf, 0x4b, 0x5c, 0x8b, 0x50, 0xe2,
0xb5, 0x9d, 0x73, 0xad, 0x8d, 0x1d, 0xdd, 0x6b, 0x63, 0xc7, 0xf1, 0xda, 0xfd, 0xfb, 0x5d, 0x42,
0xf1, 0xfd, 0xb6, 0x46, 0x2c, 0xe2, 0x62, 0x4a, 0x7a, 0xb2, 0xe3, 0xda, 0xd4, 0x86, 0x1f, 0x04,
0x86, 0x72, 0x6c, 0x28, 0x3b, 0xe7, 0x9a, 0xcc, 0x0c, 0x65, 0x66, 0x28, 0x0b, 0xc3, 0xb5, 0x2d,
0x4d, 0xa7, 0x67, 0x7e, 0x57, 0x56, 0x6d, 0xb3, 0xad, 0xd9, 0x9a, 0xdd, 0xe6, 0xf6, 0x5d, 0xff,
0x15, 0xff, 0xe2, 0x1f, 0xfc, 0x57, 0x80, 0xbb, 0xf6, 0x50, 0x04, 0x84, 0x1d, 0xdd, 0xc4, 0xea,
0x99, 0x6e, 0x11, 0x77, 0x10, 0x87, 0x64, 0x12, 0x8a, 0xdb, 0xfd, 0x5c, 0x34, 0x6b, 0xed, 0x22,
0x2b, 0xd7, 0xb7, 0xa8, 0x6e, 0x92, 0x9c, 0xc1, 0xc7, 0x37, 0x19, 0x78, 0xea, 0x19, 0x31, 0x71,
0xce, 0xee, 0x41, 0x91, 0x9d, 0x4f, 0x75, 0xa3, 0xad, 0x5b, 0xd4, 0xa3, 0x6e, 0xce, 0xe8, 0xa3,
0xc2, 0x43, 0x1e, 0xb5, 0x97, 0xc7, 0xd7, 0x5c, 0x89, 0x63, 0x1b, 0xba, 0x3a, 0x28, 0xba, 0x94,
0xd6, 0xbf, 0x25, 0x00, 0xf7, 0x6d, 0x8b, 0xba, 0xb6, 0x61, 0x10, 0x17, 0x91, 0xbe, 0xee, 0xe9,
0xb6, 0x05, 0xbf, 0x00, 0x35, 0x76, 0x70, 0x3d, 0x4c, 0x71, 0x43, 0xda, 0x90, 0x36, 0x17, 0xb6,
0xbf, 0x2f, 0x8b, 0xeb, 0x4b, 0xee, 0x23, 0xbe, 0x40, 0xa6, 0x2d, 0xf7, 0xef, 0xcb, 0x47, 0xdd,
0x2f, 0x89, 0x4a, 0x0f, 0x09, 0xc5, 0x0a, 0xbc, 0xb8, 0x5c, 0x9f, 0x19, 0x5e, 0xae, 0x83, 0x78,
0x0d, 0x45, 0xa8, 0xf0, 0x08, 0x54, 0x38, 0x7a, 0x89, 0xa3, 0x6f, 0x15, 0xa2, 0x8b, 0xd3, 0x95,
0x11, 0xfe, 0xd5, 0xb3, 0xd7, 0x94, 0x58, 0x2c, 0x3c, 0xe5, 0x1d, 0x01, 0x5d, 0x79, 0x8a, 0x29,
0x46, 0x1c, 0x08, 0x7e, 0x04, 0x6a, 0xae, 0x08, 0xbf, 0x51, 0xde, 0x90, 0x36, 0xcb, 0xca, 0x1d,
0xa1, 0x55, 0x0b, 0xb7, 0x85, 0x22, 0x8d, 0xd6, 0x37, 0x12, 0xb8, 0x97, 0xdf, 0xf7, 0x81, 0xee,
0x51, 0xf8, 0x79, 0x6e, 0xef, 0xf2, 0x78, 0x7b, 0x67, 0xd6, 0x7c, 0xe7, 0x91, 0xe3, 0x70, 0x25,
0xb1, 0xef, 0x2f, 0x40, 0x55, 0xa7, 0xc4, 0xf4, 0x1a, 0xa5, 0x8d, 0xf2, 0xe6, 0xc2, 0xf6, 0xae,
0x3c, 0x66, 0x55, 0xc8, 0xf9, 0x68, 0x95, 0x45, 0xe1, 0xa7, 0xfa, 0x9c, 0x21, 0xa2, 0x00, 0xb8,
0xf5, 0xa7, 0x12, 0x00, 0x4f, 0x89, 0x63, 0xd8, 0x03, 0x93, 0x58, 0xf4, 0x16, 0xae, 0xf2, 0x33,
0x50, 0xf1, 0x1c, 0xa2, 0x8a, 0xab, 0xfc, 0x64, 0xec, 0x1d, 0xc5, 0x41, 0x76, 0x1c, 0xa2, 0xc6,
0x97, 0xca, 0xbe, 0x10, 0x87, 0x84, 0x18, 0xcc, 0x7a, 0x14, 0x53, 0xdf, 0xe3, 0x57, 0xba, 0xb0,
0xfd, 0x78, 0x1a, 0x70, 0x0e, 0xa0, 0xd4, 0x05, 0xfc, 0x6c, 0xf0, 0x8d, 0x04, 0x70, 0xeb, 0xaa,
0x0c, 0x96, 0x63, 0xe5, 0x7d, 0xdb, 0xea, 0xe9, 0x94, 0x95, 0xc0, 0x2e, 0xa8, 0xd0, 0x81, 0x43,
0xf8, 0x99, 0xcd, 0x2b, 0x1f, 0x84, 0xc1, 0x9d, 0x0c, 0x1c, 0xf2, 0xf6, 0x72, 0x7d, 0x75, 0x84,
0x09, 0x13, 0x21, 0x6e, 0x04, 0x5f, 0x44, 0x71, 0x97, 0xb8, 0xf9, 0x93, 0xb4, 0xf3, 0xb7, 0x97,
0xeb, 0xd7, 0x56, 0xb8, 0x1c, 0x61, 0xa6, 0x83, 0x85, 0xef, 0x83, 0x59, 0x97, 0x60, 0xcf, 0xb6,
0x1a, 0x15, 0x8e, 0x1b, 0x6d, 0x0a, 0xf1, 0x55, 0x24, 0xa4, 0xf0, 0x43, 0x30, 0x67, 0x12, 0xcf,
0xc3, 0x1a, 0x69, 0x54, 0xb9, 0xe2, 0x92, 0x50, 0x9c, 0x3b, 0x0c, 0x96, 0x51, 0x28, 0x87, 0x5f,
0x82, 0xba, 0x81, 0x3d, 0x7a, 0xea, 0xf4, 0x30, 0x25, 0x27, 0xba, 0x49, 0x1a, 0xb3, 0xfc, 0xa8,
0xbf, 0x3b, 0x5e, 0x96, 0x30, 0x0b, 0xe5, 0x9e, 0x40, 0xaf, 0x1f, 0xa4, 0x90, 0x50, 0x06, 0x19,
0xf6, 0x01, 0x64, 0x2b, 0x27, 0x2e, 0xb6, 0xbc, 0xe0, 0xc8, 0x98, 0xbf, 0xb9, 0x89, 0xfd, 0xad,
0x09, 0x7f, 0xf0, 0x20, 0x87, 0x86, 0x46, 0x78, 0x68, 0x5d, 0x48, 0xa0, 0x1e, 0x5f, 0xd8, 0x2d,
0x54, 0xf9, 0xcf, 0xd3, 0x55, 0xfe, 0x60, 0x8a, 0xb4, 0x2d, 0xa8, 0xee, 0xdf, 0x96, 0x01, 0x8c,
0x95, 0x90, 0x6d, 0x18, 0x5d, 0xac, 0x9e, 0xc3, 0x0d, 0x50, 0xb1, 0xb0, 0x19, 0x66, 0x6b, 0x54,
0x4a, 0x3f, 0xc3, 0x26, 0x41, 0x5c, 0x02, 0xff, 0x20, 0x01, 0xe8, 0xf3, 0xab, 0xe8, 0xed, 0x59,
0x96, 0x4d, 0x31, 0x3b, 0x9d, 0x30, 0xc0, 0xce, 0x14, 0x01, 0x86, 0xbe, 0xe5, 0xd3, 0x1c, 0xea,
0x33, 0x8b, 0xba, 0x83, 0xf8, 0x96, 0xf2, 0x0a, 0x68, 0x44, 0x28, 0xf0, 0x1c, 0x00, 0x57, 0x60,
0x9e, 0xd8, 0xa2, 0xe0, 0xc7, 0xef, 0x26, 0x61, 0x38, 0xfb, 0xb6, 0xf5, 0x4a, 0xd7, 0xe2, 0x96,
0x85, 0x22, 0x48, 0x94, 0x80, 0x5f, 0x7b, 0x06, 0x56, 0x0b, 0xe2, 0x86, 0x77, 0x40, 0xf9, 0x9c,
0x0c, 0x82, 0xa3, 0x44, 0xec, 0x27, 0x5c, 0x01, 0xd5, 0x3e, 0x36, 0x7c, 0x12, 0x54, 0x33, 0x0a,
0x3e, 0x76, 0x4a, 0x8f, 0xa4, 0xd6, 0x3f, 0xaa, 0xc9, 0xcc, 0x62, 0x9d, 0x0b, 0x6e, 0xb2, 0x87,
0xc8, 0x31, 0x74, 0x15, 0x7b, 0x1c, 0xa3, 0xaa, 0xbc, 0x13, 0x3c, 0x42, 0xc1, 0x1a, 0x8a, 0xa4,
0xf0, 0x97, 0xa0, 0xe6, 0x11, 0x83, 0xa8, 0xd4, 0x76, 0x45, 0xf3, 0x7c, 0x30, 0x66, 0x0e, 0xe2,
0x2e, 0x31, 0x3a, 0xc2, 0x34, 0x80, 0x0f, 0xbf, 0x50, 0x04, 0x09, 0x7f, 0x01, 0x6a, 0x94, 0x98,
0x8e, 0x81, 0x29, 0x11, 0xa7, 0xb9, 0x55, 0x7c, 0x9a, 0x0c, 0xf6, 0xd8, 0xee, 0x9d, 0x08, 0x03,
0xde, 0x91, 0xa3, 0x0c, 0x0f, 0x57, 0x51, 0x04, 0x08, 0x75, 0x50, 0xf3, 0x28, 0x63, 0x12, 0xda,
0x80, 0xf7, 0xa2, 0x49, 0x9e, 0xb2, 0x64, 0x6f, 0x0e, 0x20, 0x62, 0x57, 0xe1, 0x0a, 0x8a, 0xe0,
0xe1, 0x1e, 0x58, 0x32, 0x75, 0x0b, 0x11, 0xdc, 0x1b, 0x74, 0x88, 0x6a, 0x5b, 0x3d, 0x8f, 0x37,
0xb5, 0xaa, 0xb2, 0x2a, 0x8c, 0x96, 0x0e, 0xd3, 0x62, 0x94, 0xd5, 0x87, 0x07, 0x60, 0x25, 0x7c,
0xfa, 0x7f, 0xa2, 0x7b, 0xd4, 0x76, 0x07, 0x07, 0xba, 0xa9, 0x53, 0xde, 0xea, 0xaa, 0x4a, 0x63,
0x78, 0xb9, 0xbe, 0x82, 0x46, 0xc8, 0xd1, 0x48, 0x2b, 0xd6, 0x85, 0x1d, 0xec, 0x7b, 0xa4, 0xc7,
0x5b, 0x57, 0x2d, 0xee, 0xc2, 0xc7, 0x7c, 0x15, 0x09, 0x29, 0xd4, 0x52, 0x09, 0x5d, 0xfb, 0xef,
0x12, 0xba, 0x5e, 0x9c, 0xcc, 0xf0, 0x14, 0xac, 0x3a, 0xae, 0xad, 0xb9, 0xc4, 0xf3, 0x9e, 0x12,
0xdc, 0x33, 0x74, 0x8b, 0x84, 0x27, 0x35, 0xcf, 0x77, 0xf8, 0xde, 0xf0, 0x72, 0x7d, 0xf5, 0x78,
0xb4, 0x0a, 0x2a, 0xb2, 0x6d, 0xfd, 0xbd, 0x02, 0xee, 0x64, 0xdf, 0x51, 0xf8, 0x53, 0x00, 0xed,
0xae, 0x47, 0xdc, 0x3e, 0xe9, 0x7d, 0x1a, 0x90, 0x49, 0xc6, 0xb8, 0x24, 0xce, 0xb8, 0xa2, 0x8a,
0x3f, 0xca, 0x69, 0xa0, 0x11, 0x56, 0x01, 0x67, 0x13, 0xa5, 0x52, 0xe2, 0x81, 0x26, 0x38, 0x5b,
0xae, 0x5c, 0xf6, 0xc0, 0x92, 0xe8, 0x1a, 0xa1, 0x90, 0xa7, 0x75, 0x22, 0x0f, 0x4e, 0xd3, 0x62,
0x94, 0xd5, 0x87, 0x9f, 0x82, 0xbb, 0xb8, 0x8f, 0x75, 0x03, 0x77, 0x0d, 0x12, 0x81, 0x54, 0x38,
0xc8, 0xbb, 0x02, 0xe4, 0xee, 0x5e, 0x56, 0x01, 0xe5, 0x6d, 0xe0, 0x21, 0x58, 0xf6, 0xad, 0x3c,
0x54, 0x90, 0x97, 0xef, 0x09, 0xa8, 0xe5, 0xd3, 0xbc, 0x0a, 0x1a, 0x65, 0x07, 0x1d, 0x00, 0xd4,
0xf0, 0xc9, 0xf7, 0x1a, 0xb3, 0xbc, 0x27, 0xff, 0x70, 0x8a, 0x7a, 0x8a, 0x78, 0x43, 0xdc, 0xff,
0xa2, 0x25, 0x0f, 0x25, 0x7c, 0xc0, 0x5d, 0xb0, 0xe8, 0xb2, 0x0a, 0x89, 0x42, 0x9f, 0xe3, 0xa1,
0x7f, 0x4b, 0x98, 0x2d, 0xa2, 0xa4, 0x10, 0xa5, 0x75, 0xe1, 0x0e, 0xa8, 0xab, 0xb6, 0x61, 0xf0,
0xca, 0xd8, 0xb7, 0x7d, 0x8b, 0xf2, 0xe4, 0x2e, 0x2b, 0x90, 0x71, 0x80, 0xfd, 0x94, 0x04, 0x65,
0x34, 0x5b, 0x7f, 0x95, 0x92, 0x0f, 0x58, 0x58, 0xee, 0x70, 0x27, 0x45, 0xb7, 0xde, 0xcf, 0xd0,
0xad, 0x7b, 0x79, 0x8b, 0x04, 0xdb, 0x1a, 0x80, 0x45, 0x56, 0x0c, 0xba, 0xa5, 0x05, 0x09, 0x20,
0x9a, 0xe9, 0x8f, 0x26, 0x2a, 0xb5, 0xc8, 0x3a, 0xf1, 0x04, 0xdf, 0xe5, 0x27, 0x91, 0x14, 0xa2,
0xb4, 0xa7, 0xd6, 0x13, 0x50, 0x4f, 0xd7, 0x69, 0x6a, 0x0e, 0x91, 0x6e, 0x9c, 0x43, 0xde, 0x48,
0x60, 0xb5, 0xc0, 0x3b, 0x34, 0x40, 0xdd, 0xc4, 0xaf, 0x13, 0x39, 0x74, 0x23, 0x7f, 0x67, 0x23,
0xa5, 0x1c, 0x8c, 0x94, 0xf2, 0x73, 0x8b, 0x1e, 0xb9, 0x1d, 0xea, 0xea, 0x96, 0x16, 0xdc, 0xcb,
0x61, 0x0a, 0x0b, 0x65, 0xb0, 0xe1, 0x4b, 0x50, 0x33, 0xf1, 0xeb, 0x8e, 0xef, 0x6a, 0xe1, 0xf9,
0x4d, 0xee, 0x87, 0xbf, 0x44, 0x87, 0x02, 0x05, 0x45, 0x78, 0xad, 0x23, 0xb0, 0x91, 0xda, 0x24,
0x6b, 0x25, 0xe4, 0x95, 0x6f, 0x74, 0x48, 0x9c, 0x00, 0xdf, 0x03, 0xf3, 0x0e, 0x76, 0xa9, 0x1e,
0xb5, 0x93, 0xaa, 0xb2, 0x38, 0xbc, 0x5c, 0x9f, 0x3f, 0x0e, 0x17, 0x51, 0x2c, 0x6f, 0xfd, 0xbe,
0x04, 0xaa, 0x1d, 0x15, 0x1b, 0xe4, 0x16, 0xc6, 0x9b, 0x93, 0xd4, 0x78, 0xb3, 0x3d, 0x76, 0x52,
0xf1, 0xf8, 0x0a, 0x27, 0x9b, 0xcf, 0x33, 0x93, 0xcd, 0xc3, 0x09, 0x71, 0xaf, 0x1f, 0x6a, 0x1e,
0x83, 0xf9, 0xc8, 0x7d, 0xaa, 0xcb, 0x4a, 0x37, 0x75, 0xd9, 0xd6, 0x1f, 0x4b, 0x60, 0x21, 0xe1,
0x62, 0x32, 0x6b, 0xe8, 0xa4, 0x28, 0x0d, 0x6b, 0x63, 0xca, 0x34, 0x1b, 0x93, 0x43, 0x3a, 0x13,
0x30, 0xc9, 0x98, 0x1d, 0xe4, 0x59, 0xce, 0x13, 0x50, 0xa7, 0xd8, 0xd5, 0x08, 0x0d, 0x65, 0xfc,
0x40, 0xe7, 0xe3, 0x99, 0xe4, 0x24, 0x25, 0x45, 0x19, 0xed, 0xb5, 0x5d, 0xb0, 0x98, 0x72, 0x36,
0x11, 0xfd, 0xfb, 0x33, 0x3b, 0xac, 0x38, 0x99, 0x6f, 0x21, 0x1b, 0x5f, 0xa6, 0xb2, 0xf1, 0xd1,
0xf8, 0x87, 0x9b, 0x28, 0xb9, 0xa2, 0x9c, 0xec, 0x66, 0x72, 0x72, 0x67, 0x2a, 0xf4, 0xeb, 0x33,
0xf3, 0x2f, 0x12, 0x58, 0x4a, 0x68, 0xdf, 0xc2, 0x2c, 0xf6, 0x59, 0x7a, 0x16, 0x7b, 0x38, 0xcd,
0xa6, 0x0a, 0x86, 0xb1, 0x7f, 0x55, 0x53, 0x9b, 0xf9, 0x3f, 0xa2, 0xff, 0xbf, 0x91, 0xc0, 0x4a,
0xdf, 0x36, 0x7c, 0x93, 0xec, 0x1b, 0x58, 0x37, 0x43, 0x0d, 0x46, 0xa6, 0x6e, 0x18, 0x78, 0xb9,
0x27, 0xe2, 0x7a, 0xba, 0x47, 0x89, 0x45, 0x5f, 0xc4, 0x18, 0xca, 0xb7, 0x85, 0xbf, 0x95, 0x17,
0x23, 0x80, 0xd1, 0x48, 0x77, 0xf0, 0x07, 0x60, 0x81, 0xb1, 0x4a, 0x5d, 0x25, 0x6c, 0xd4, 0x15,
0x7f, 0x76, 0x2c, 0x0b, 0xa0, 0x85, 0x4e, 0x2c, 0x42, 0x49, 0x3d, 0x78, 0x06, 0x96, 0x1d, 0xbb,
0x77, 0x88, 0x2d, 0xac, 0x11, 0xf6, 0xd6, 0x1e, 0xf3, 0x7f, 0x49, 0xf9, 0x38, 0x30, 0xaf, 0x7c,
0x1c, 0xd2, 0xb7, 0xe3, 0xbc, 0xca, 0x5b, 0xc6, 0xa3, 0xf3, 0xcb, 0x9c, 0x8c, 0x8c, 0x82, 0x84,
0x5f, 0x49, 0xa0, 0xee, 0x8b, 0x47, 0x4f, 0x8c, 0x4b, 0xc1, 0xff, 0x1d, 0xca, 0x34, 0x79, 0x78,
0x9a, 0x42, 0x8a, 0x7b, 0x5c, 0x7a, 0x1d, 0x65, 0x3c, 0x16, 0x8e, 0x3f, 0xb5, 0x69, 0xc6, 0x9f,
0xd6, 0xdf, 0xca, 0xe0, 0x6e, 0xae, 0xe0, 0xe1, 0x8f, 0xaf, 0x99, 0x0b, 0xee, 0xfd, 0xcf, 0x66,
0x82, 0x1c, 0x8d, 0x2d, 0x4f, 0x40, 0x63, 0xf7, 0xc0, 0x92, 0xea, 0xbb, 0x2e, 0xb1, 0x68, 0x66,
0x16, 0x88, 0x06, 0x8a, 0xfd, 0xb4, 0x18, 0x65, 0xf5, 0x47, 0xcd, 0x24, 0xd5, 0x09, 0x67, 0x92,
0x64, 0x14, 0x82, 0x37, 0x06, 0x79, 0x98, 0x8f, 0x42, 0xd0, 0xc7, 0xac, 0x3e, 0x7b, 0x03, 0x03,
0xd4, 0x08, 0x61, 0x2e, 0xfd, 0x06, 0x9e, 0xa6, 0xa4, 0x28, 0xa3, 0xcd, 0x58, 0xe8, 0xbb, 0x85,
0x59, 0x06, 0xf7, 0x52, 0xd4, 0x7c, 0x2b, 0x43, 0xcd, 0xbf, 0x53, 0x68, 0x98, 0x60, 0xe8, 0x5f,
0x49, 0xa3, 0x29, 0xfa, 0xf3, 0xe9, 0x28, 0xfa, 0x08, 0xfe, 0x78, 0x33, 0x57, 0x57, 0x3e, 0xbc,
0xb8, 0x6a, 0xce, 0x7c, 0x7d, 0xd5, 0x9c, 0xf9, 0xe6, 0xaa, 0x39, 0xf3, 0xeb, 0x61, 0x53, 0xba,
0x18, 0x36, 0xa5, 0xaf, 0x87, 0x4d, 0xe9, 0x9f, 0xc3, 0xa6, 0xf4, 0xbb, 0x37, 0xcd, 0x99, 0x97,
0x73, 0xc2, 0xdb, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xf4, 0x2b, 0x6c, 0xd0, 0xe5, 0x1a, 0x00,
0x00,
}

22
pkg/apis/apps/v1beta1/generated.proto
View File

@ -224,14 +224,6 @@ message DeploymentStrategy {
optional RollingUpdateDeployment rollingUpdate = 2;
}
// PartitionStatefulSetStrategy contains the parameters used with the
// PartitionStatefulSetStrategyType.
message PartitionStatefulSetStrategy {
// Ordinal indicates the ordinal at which the StatefulSet should be
// partitioned.
optional int32 ordinal = 1;
}
message RollbackConfig {
// The revision to rollback to. If set to 0, rollback to the last revision.
// +optional
@ -268,6 +260,13 @@ message RollingUpdateDeployment {
optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxSurge = 2;
}
// RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType.
message RollingUpdateStatefulSetStrategy {
// Partition indicates the ordinal at which the StatefulSet should be
// partitioned.
optional int32 partition = 1;
}
// Scale represents a scaling request for a resource.
message Scale {
// Standard object metadata; More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata.
@ -436,10 +435,7 @@ message StatefulSetUpdateStrategy {
// Type indicates the type of the StatefulSetUpdateStrategy.
optional string type = 1;
// Partition is used to communicate the ordinal at which to partition
// the StatefulSet when Type is PartitionStatefulSetStrategyType. This
// value must be set when Type is PartitionStatefulSetStrategyType,
// and it must be nil otherwise.
optional PartitionStatefulSetStrategy partition = 2;
// RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType.
optional RollingUpdateStatefulSetStrategy rollingUpdate = 2;
}

107
pkg/apis/apps/v1beta1/types.generated.go
View File

@ -1386,7 +1386,7 @@ func (x *StatefulSetUpdateStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.Type != ""
yyq2[1] = x.Partition != nil
yyq2[1] = x.RollingUpdate != nil
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(2)
@ -1418,10 +1418,10 @@ func (x *StatefulSetUpdateStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
if yyq2[1] {
if x.Partition == nil {
if x.RollingUpdate == nil {
r.EncodeNil()
} else {
x.Partition.CodecEncodeSelf(e)
x.RollingUpdate.CodecEncodeSelf(e)
}
} else {
r.EncodeNil()
@ -1429,12 +1429,12 @@ func (x *StatefulSetUpdateStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
} else {
if yyq2[1] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("partition"))
r.EncodeString(codecSelferC_UTF81234, string("rollingUpdate"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Partition == nil {
if x.RollingUpdate == nil {
r.EncodeNil()
} else {
x.Partition.CodecEncodeSelf(e)
x.RollingUpdate.CodecEncodeSelf(e)
}
}
}
@ -1506,16 +1506,16 @@ func (x *StatefulSetUpdateStrategy) codecDecodeSelfFromMap(l int, d *codec1978.D
yyv4 := &x.Type
yyv4.CodecDecodeSelf(d)
}
case "partition":
case "rollingUpdate":
if r.TryDecodeAsNil() {
if x.Partition != nil {
x.Partition = nil
if x.RollingUpdate != nil {
x.RollingUpdate = nil
}
} else {
if x.Partition == nil {
x.Partition = new(PartitionStatefulSetStrategy)
if x.RollingUpdate == nil {
x.RollingUpdate = new(RollingUpdateStatefulSetStrategy)
}
x.Partition.CodecDecodeSelf(d)
x.RollingUpdate.CodecDecodeSelf(d)
}
default:
z.DecStructFieldNotFound(-1, yys3)
@ -1560,14 +1560,14 @@ func (x *StatefulSetUpdateStrategy) codecDecodeSelfFromArray(l int, d *codec1978
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
if x.Partition != nil {
x.Partition = nil
if x.RollingUpdate != nil {
x.RollingUpdate = nil
}
} else {
if x.Partition == nil {
x.Partition = new(PartitionStatefulSetStrategy)
if x.RollingUpdate == nil {
x.RollingUpdate = new(RollingUpdateStatefulSetStrategy)
}
x.Partition.CodecDecodeSelf(d)
x.RollingUpdate.CodecDecodeSelf(d)
}
for {
yyj6++
@ -1611,7 +1611,7 @@ func (x *StatefulSetUpdateStrategyType) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
func (x *PartitionStatefulSetStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
func (x *RollingUpdateStatefulSetStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperEncoder(e)
_, _, _ = h, z, r
@ -1628,11 +1628,12 @@ func (x *PartitionStatefulSetStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
var yyq2 [1]bool
_, _, _ = yysep2, yyq2, yy2arr2
const yyr2 bool = false
yyq2[0] = x.Partition != nil
var yynn2 int
if yyr2 || yy2arr2 {
r.EncodeArrayStart(1)
} else {
yynn2 = 1
yynn2 = 0
for _, b := range yyq2 {
if b {
yynn2++
@ -1643,21 +1644,37 @@ func (x *PartitionStatefulSetStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
}
if yyr2 || yy2arr2 {
z.EncSendContainerState(codecSelfer_containerArrayElem1234)
yym4 := z.EncBinary()
_ = yym4
if false {
if yyq2[0] {
if x.Partition == nil {
r.EncodeNil()
} else {
yy4 := *x.Partition
yym5 := z.EncBinary()
_ = yym5
if false {
} else {
r.EncodeInt(int64(yy4))
}
}
} else {
r.EncodeInt(int64(x.Ordinal))
r.EncodeNil()
}
} else {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("ordinal"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
yym5 := z.EncBinary()
_ = yym5
if false {
} else {
r.EncodeInt(int64(x.Ordinal))
if yyq2[0] {
z.EncSendContainerState(codecSelfer_containerMapKey1234)
r.EncodeString(codecSelferC_UTF81234, string("partition"))
z.EncSendContainerState(codecSelfer_containerMapValue1234)
if x.Partition == nil {
r.EncodeNil()
} else {
yy6 := *x.Partition
yym7 := z.EncBinary()
_ = yym7
if false {
} else {
r.EncodeInt(int64(yy6))
}
}
}
}
if yyr2 || yy2arr2 {
@ -1669,7 +1686,7 @@ func (x *PartitionStatefulSetStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
}
}
func (x *PartitionStatefulSetStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
func (x *RollingUpdateStatefulSetStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@ -1699,7 +1716,7 @@ func (x *PartitionStatefulSetStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
}
}
func (x *PartitionStatefulSetStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
func (x *RollingUpdateStatefulSetStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@ -1721,16 +1738,20 @@ func (x *PartitionStatefulSetStrategy) codecDecodeSelfFromMap(l int, d *codec197
yys3 := string(yys3Slc)
z.DecSendContainerState(codecSelfer_containerMapValue1234)
switch yys3 {
case "ordinal":
case "partition":
if r.TryDecodeAsNil() {
x.Ordinal = 0
if x.Partition != nil {
x.Partition = nil
}
} else {
yyv4 := &x.Ordinal
if x.Partition == nil {
x.Partition = new(int32)
}
yym5 := z.DecBinary()
_ = yym5
if false {
} else {
*((*int32)(yyv4)) = int32(r.DecodeInt(32))
*((*int32)(x.Partition)) = int32(r.DecodeInt(32))
}
}
default:
@ -1740,7 +1761,7 @@ func (x *PartitionStatefulSetStrategy) codecDecodeSelfFromMap(l int, d *codec197
z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}
func (x *PartitionStatefulSetStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
func (x *RollingUpdateStatefulSetStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
var h codecSelfer1234
z, r := codec1978.GenHelperDecoder(d)
_, _, _ = h, z, r
@ -1759,14 +1780,18 @@ func (x *PartitionStatefulSetStrategy) codecDecodeSelfFromArray(l int, d *codec1
}
z.DecSendContainerState(codecSelfer_containerArrayElem1234)
if r.TryDecodeAsNil() {
x.Ordinal = 0
if x.Partition != nil {
x.Partition = nil
}
} else {
yyv7 := &x.Ordinal
if x.Partition == nil {
x.Partition = new(int32)
}
yym8 := z.DecBinary()
_ = yym8
if false {
} else {
*((*int32)(yyv7)) = int32(r.DecodeInt(32))
*((*int32)(x.Partition)) = int32(r.DecodeInt(32))
}
}
for {

24
pkg/apis/apps/v1beta1/types.go
View File

@ -118,11 +118,8 @@ const (
type StatefulSetUpdateStrategy struct {
// Type indicates the type of the StatefulSetUpdateStrategy.
Type StatefulSetUpdateStrategyType `json:"type,omitempty" protobuf:"bytes,1,opt,name=type,casttype=StatefulSetStrategyType"`
// Partition is used to communicate the ordinal at which to partition
// the StatefulSet when Type is PartitionStatefulSetStrategyType. This
// value must be set when Type is PartitionStatefulSetStrategyType,
// and it must be nil otherwise.
Partition *PartitionStatefulSetStrategy `json:"partition,omitempty" protobuf:"bytes,2,opt,name=partition"`
// RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType.
RollingUpdate *RollingUpdateStatefulSetStrategy `json:"rollingUpdate,omitempty" protobuf:"bytes,2,opt,name=rollingUpdate"`
}
// StatefulSetUpdateStrategyType is a string enumeration type that enumerates
@ -130,14 +127,6 @@ type StatefulSetUpdateStrategy struct {
type StatefulSetUpdateStrategyType string
const (
// PartitionStatefulSetStrategyType indicates that updates will only be
// applied to a partition of the StatefulSet. This is useful for canaries
// and phased roll outs. When a scale operation is performed with this
// strategy, new Pods will be created from the specification version indicated
// by the StatefulSet's currentRevision if there ordinal is less than the supplied
// Partition's ordinal. Otherwise, they will be created from the specification
// version indicated by the StatefulSet's updateRevision.
PartitionStatefulSetStrategyType StatefulSetUpdateStrategyType = "Partition"
// RollingUpdateStatefulSetStrategyType indicates that update will be
// applied to all Pods in the StatefulSet with respect to the StatefulSet
// ordering constraints. When a scale operation is performed with this
@ -152,12 +141,11 @@ const (
OnDeleteStatefulSetStrategyType = "OnDelete"
)
// PartitionStatefulSetStrategy contains the parameters used with the
// PartitionStatefulSetStrategyType.
type PartitionStatefulSetStrategy struct {
// Ordinal indicates the ordinal at which the StatefulSet should be
// RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType.
type RollingUpdateStatefulSetStrategy struct {
// Partition indicates the ordinal at which the StatefulSet should be
// partitioned.
Ordinal int32 `json:"ordinal" protobuf:"varint,1,opt,name=ordinal"`
Partition *int32 `json:"partition,omitempty" protobuf:"varint,1,opt,name=partition"`
}
// A StatefulSetSpec is the specification of a StatefulSet.

24
pkg/apis/apps/v1beta1/types_swagger_doc_generated.go
View File

@ -137,15 +137,6 @@ func (DeploymentStrategy) SwaggerDoc() map[string]string {
return map_DeploymentStrategy
}
var map_PartitionStatefulSetStrategy = map[string]string{
"": "PartitionStatefulSetStrategy contains the parameters used with the PartitionStatefulSetStrategyType.",
"ordinal": "Ordinal indicates the ordinal at which the StatefulSet should be partitioned.",
}
func (PartitionStatefulSetStrategy) SwaggerDoc() map[string]string {
return map_PartitionStatefulSetStrategy
}
var map_RollbackConfig = map[string]string{
"revision": "The revision to rollback to. If set to 0, rollback to the last revision.",
}
@ -164,6 +155,15 @@ func (RollingUpdateDeployment) SwaggerDoc() map[string]string {
return map_RollingUpdateDeployment
}
var map_RollingUpdateStatefulSetStrategy = map[string]string{
"": "RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType.",
"partition": "Partition indicates the ordinal at which the StatefulSet should be partitioned.",
}
func (RollingUpdateStatefulSetStrategy) SwaggerDoc() map[string]string {
return map_RollingUpdateStatefulSetStrategy
}
var map_Scale = map[string]string{
"": "Scale represents a scaling request for a resource.",
"metadata": "Standard object metadata; More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata.",
@ -245,9 +245,9 @@ func (StatefulSetStatus) SwaggerDoc() map[string]string {
}
var map_StatefulSetUpdateStrategy = map[string]string{
"": "StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy.",
"type": "Type indicates the type of the StatefulSetUpdateStrategy.",
"partition": "Partition is used to communicate the ordinal at which to partition the StatefulSet when Type is PartitionStatefulSetStrategyType. This value must be set when Type is PartitionStatefulSetStrategyType, and it must be nil otherwise.",
"": "StatefulSetUpdateStrategy indicates the strategy that the StatefulSet controller will use to perform updates. It includes any additional parameters necessary to perform the update for the indicated strategy.",
"type": "Type indicates the type of the StatefulSetUpdateStrategy.",
"rollingUpdate": "RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType.",
}
func (StatefulSetUpdateStrategy) SwaggerDoc() map[string]string {

48
pkg/apis/apps/v1beta1/zz_generated.conversion.go
View File

@ -42,8 +42,8 @@ func RegisterConversions(scheme *runtime.Scheme) error {
Convert_apps_ControllerRevision_To_v1beta1_ControllerRevision,
Convert_v1beta1_ControllerRevisionList_To_apps_ControllerRevisionList,
Convert_apps_ControllerRevisionList_To_v1beta1_ControllerRevisionList,
Convert_v1beta1_PartitionStatefulSetStrategy_To_apps_PartitionStatefulSetStrategy,
Convert_apps_PartitionStatefulSetStrategy_To_v1beta1_PartitionStatefulSetStrategy,
Convert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy,
Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy,
Convert_v1beta1_StatefulSet_To_apps_StatefulSet,
Convert_apps_StatefulSet_To_v1beta1_StatefulSet,
Convert_v1beta1_StatefulSetList_To_apps_StatefulSetList,
@ -127,24 +127,28 @@ func Convert_apps_ControllerRevisionList_To_v1beta1_ControllerRevisionList(in *a
return autoConvert_apps_ControllerRevisionList_To_v1beta1_ControllerRevisionList(in, out, s)
}
func autoConvert_v1beta1_PartitionStatefulSetStrategy_To_apps_PartitionStatefulSetStrategy(in *PartitionStatefulSetStrategy, out *apps.PartitionStatefulSetStrategy, s conversion.Scope) error {
out.Ordinal = in.Ordinal
func autoConvert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in *RollingUpdateStatefulSetStrategy, out *apps.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
if err := v1.Convert_Pointer_int32_To_int32(&in.Partition, &out.Partition, s); err != nil {
return err
}
return nil
}
// Convert_v1beta1_PartitionStatefulSetStrategy_To_apps_PartitionStatefulSetStrategy is an autogenerated conversion function.
func Convert_v1beta1_PartitionStatefulSetStrategy_To_apps_PartitionStatefulSetStrategy(in *PartitionStatefulSetStrategy, out *apps.PartitionStatefulSetStrategy, s conversion.Scope) error {
return autoConvert_v1beta1_PartitionStatefulSetStrategy_To_apps_PartitionStatefulSetStrategy(in, out, s)
// Convert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy is an autogenerated conversion function.
func Convert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in *RollingUpdateStatefulSetStrategy, out *apps.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
return autoConvert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in, out, s)
}
func autoConvert_apps_PartitionStatefulSetStrategy_To_v1beta1_PartitionStatefulSetStrategy(in *apps.PartitionStatefulSetStrategy, out *PartitionStatefulSetStrategy, s conversion.Scope) error {
out.Ordinal = in.Ordinal
func autoConvert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy(in *apps.RollingUpdateStatefulSetStrategy, out *RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
if err := v1.Convert_int32_To_Pointer_int32(&in.Partition, &out.Partition, s); err != nil {
return err
}
return nil
}
// Convert_apps_PartitionStatefulSetStrategy_To_v1beta1_PartitionStatefulSetStrategy is an autogenerated conversion function.
func Convert_apps_PartitionStatefulSetStrategy_To_v1beta1_PartitionStatefulSetStrategy(in *apps.PartitionStatefulSetStrategy, out *PartitionStatefulSetStrategy, s conversion.Scope) error {
return autoConvert_apps_PartitionStatefulSetStrategy_To_v1beta1_PartitionStatefulSetStrategy(in, out, s)
// Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy is an autogenerated conversion function.
func Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy(in *apps.RollingUpdateStatefulSetStrategy, out *RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
return autoConvert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy(in, out, s)
}
func autoConvert_v1beta1_StatefulSet_To_apps_StatefulSet(in *StatefulSet, out *apps.StatefulSet, s conversion.Scope) error {
@ -291,12 +295,28 @@ func Convert_apps_StatefulSetStatus_To_v1beta1_StatefulSetStatus(in *apps.Statef
func autoConvert_v1beta1_StatefulSetUpdateStrategy_To_apps_StatefulSetUpdateStrategy(in *StatefulSetUpdateStrategy, out *apps.StatefulSetUpdateStrategy, s conversion.Scope) error {
out.Type = apps.StatefulSetUpdateStrategyType(in.Type)
out.Partition = (*apps.PartitionStatefulSetStrategy)(unsafe.Pointer(in.Partition))
if in.RollingUpdate != nil {
in, out := &in.RollingUpdate, &out.RollingUpdate
*out = new(apps.RollingUpdateStatefulSetStrategy)
if err := Convert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(*in, *out, s); err != nil {
return err
}
} else {
out.RollingUpdate = nil
}
return nil
}
func autoConvert_apps_StatefulSetUpdateStrategy_To_v1beta1_StatefulSetUpdateStrategy(in *apps.StatefulSetUpdateStrategy, out *StatefulSetUpdateStrategy, s conversion.Scope) error {
out.Type = StatefulSetUpdateStrategyType(in.Type)
out.Partition = (*PartitionStatefulSetStrategy)(unsafe.Pointer(in.Partition))
if in.RollingUpdate != nil {
in, out := &in.RollingUpdate, &out.RollingUpdate
*out = new(RollingUpdateStatefulSetStrategy)
if err := Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy(*in, *out, s); err != nil {
return err
}
} else {
out.RollingUpdate = nil
}
return nil
}

37
pkg/apis/apps/v1beta1/zz_generated.deepcopy.go
View File

@ -46,9 +46,9 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error {
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_v1beta1_DeploymentSpec, InType: reflect.TypeOf(&DeploymentSpec{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_v1beta1_DeploymentStatus, InType: reflect.TypeOf(&DeploymentStatus{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_v1beta1_DeploymentStrategy, InType: reflect.TypeOf(&DeploymentStrategy{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_v1beta1_PartitionStatefulSetStrategy, InType: reflect.TypeOf(&PartitionStatefulSetStrategy{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_v1beta1_RollbackConfig, InType: reflect.TypeOf(&RollbackConfig{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_v1beta1_RollingUpdateDeployment, InType: reflect.TypeOf(&RollingUpdateDeployment{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_v1beta1_RollingUpdateStatefulSetStrategy, InType: reflect.TypeOf(&RollingUpdateStatefulSetStrategy{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_v1beta1_Scale, InType: reflect.TypeOf(&Scale{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_v1beta1_ScaleSpec, InType: reflect.TypeOf(&ScaleSpec{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_v1beta1_ScaleStatus, InType: reflect.TypeOf(&ScaleStatus{})},
@ -253,16 +253,6 @@ func DeepCopy_v1beta1_DeploymentStrategy(in interface{}, out interface{}, c *con
}
}
// DeepCopy_v1beta1_PartitionStatefulSetStrategy is an autogenerated deepcopy function.
func DeepCopy_v1beta1_PartitionStatefulSetStrategy(in interface{}, out interface{}, c *conversion.Cloner) error {
{
in := in.(*PartitionStatefulSetStrategy)
out := out.(*PartitionStatefulSetStrategy)
*out = *in
return nil
}
}
// DeepCopy_v1beta1_RollbackConfig is an autogenerated deepcopy function.
func DeepCopy_v1beta1_RollbackConfig(in interface{}, out interface{}, c *conversion.Cloner) error {
{
@ -293,6 +283,21 @@ func DeepCopy_v1beta1_RollingUpdateDeployment(in interface{}, out interface{}, c
}
}
// DeepCopy_v1beta1_RollingUpdateStatefulSetStrategy is an autogenerated deepcopy function.
func DeepCopy_v1beta1_RollingUpdateStatefulSetStrategy(in interface{}, out interface{}, c *conversion.Cloner) error {
{
in := in.(*RollingUpdateStatefulSetStrategy)
out := out.(*RollingUpdateStatefulSetStrategy)
*out = *in
if in.Partition != nil {
in, out := &in.Partition, &out.Partition
*out = new(int32)
**out = **in
}
return nil
}
}
// DeepCopy_v1beta1_Scale is an autogenerated deepcopy function.
func DeepCopy_v1beta1_Scale(in interface{}, out interface{}, c *conversion.Cloner) error {
{
@ -442,10 +447,12 @@ func DeepCopy_v1beta1_StatefulSetUpdateStrategy(in interface{}, out interface{},
in := in.(*StatefulSetUpdateStrategy)
out := out.(*StatefulSetUpdateStrategy)
*out = *in
if in.Partition != nil {
in, out := &in.Partition, &out.Partition
*out = new(PartitionStatefulSetStrategy)
**out = **in
if in.RollingUpdate != nil {
in, out := &in.RollingUpdate, &out.RollingUpdate
*out = new(RollingUpdateStatefulSetStrategy)
if err := DeepCopy_v1beta1_RollingUpdateStatefulSetStrategy(*in, *out, c); err != nil {
return err
}
}
return nil
}

16
pkg/apis/apps/zz_generated.deepcopy.go
View File

@ -38,7 +38,7 @@ func RegisterDeepCopies(scheme *runtime.Scheme) error {
return scheme.AddGeneratedDeepCopyFuncs(
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_apps_ControllerRevision, InType: reflect.TypeOf(&ControllerRevision{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_apps_ControllerRevisionList, InType: reflect.TypeOf(&ControllerRevisionList{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_apps_PartitionStatefulSetStrategy, InType: reflect.TypeOf(&PartitionStatefulSetStrategy{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_apps_RollingUpdateStatefulSetStrategy, InType: reflect.TypeOf(&RollingUpdateStatefulSetStrategy{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_apps_StatefulSet, InType: reflect.TypeOf(&StatefulSet{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_apps_StatefulSetList, InType: reflect.TypeOf(&StatefulSetList{})},
conversion.GeneratedDeepCopyFunc{Fn: DeepCopy_apps_StatefulSetSpec, InType: reflect.TypeOf(&StatefulSetSpec{})},
@ -89,11 +89,11 @@ func DeepCopy_apps_ControllerRevisionList(in interface{}, out interface{}, c *co
}
}
// DeepCopy_apps_PartitionStatefulSetStrategy is an autogenerated deepcopy function.
func DeepCopy_apps_PartitionStatefulSetStrategy(in interface{}, out interface{}, c *conversion.Cloner) error {
// DeepCopy_apps_RollingUpdateStatefulSetStrategy is an autogenerated deepcopy function.
func DeepCopy_apps_RollingUpdateStatefulSetStrategy(in interface{}, out interface{}, c *conversion.Cloner) error {
{
in := in.(*PartitionStatefulSetStrategy)
out := out.(*PartitionStatefulSetStrategy)
in := in.(*RollingUpdateStatefulSetStrategy)
out := out.(*RollingUpdateStatefulSetStrategy)
*out = *in
return nil
}
@ -198,9 +198,9 @@ func DeepCopy_apps_StatefulSetUpdateStrategy(in interface{}, out interface{}, c
in := in.(*StatefulSetUpdateStrategy)
out := out.(*StatefulSetUpdateStrategy)
*out = *in
if in.Partition != nil {
in, out := &in.Partition, &out.Partition
*out = new(PartitionStatefulSetStrategy)
if in.RollingUpdate != nil {
in, out := &in.RollingUpdate, &out.RollingUpdate
*out = new(RollingUpdateStatefulSetStrategy)
**out = **in
}
return nil