Generated code

Kubernetes-commit: 37a54d521afa6b65f86426826068a1499b22a4c9

pkg/apis/apps/types.go

@@ -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
+	// RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType.
-	// the StatefulSet when Type is PartitionStatefulSetStrategyType. This
+	RollingUpdate *RollingUpdateStatefulSetStrategy
-	// value must be set when Type is PartitionStatefulSetStrategyType,
-	// and it must be nil otherwise.
-	Partition *PartitionStatefulSetStrategy
 }
 
 // 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
+// RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType.
-// PartitionStatefulSetStrategyType.
+type RollingUpdateStatefulSetStrategy struct {
-type PartitionStatefulSetStrategy struct {
+	// Partition indicates the ordinal at which the StatefulSet should be
-	// Ordinal indicates the ordinal at which the StatefulSet should be
 	// partitioned.
-	Ordinal int32
+	Partition int32
 }
 
 // A StatefulSetSpec is the specification of a StatefulSet.

pkg/apis/apps/v1beta1/conversion.go

@@ -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 {
+	if in.RollingUpdate != nil {
-		out.Partition = new(apps.PartitionStatefulSetStrategy)
+		out.RollingUpdate = new(apps.RollingUpdateStatefulSetStrategy)
-		out.Partition.Ordinal = in.Partition.Ordinal
+		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 {
+	if in.RollingUpdate != nil {
-		out.Partition = new(PartitionStatefulSetStrategy)
+		out.RollingUpdate = new(RollingUpdateStatefulSetStrategy)
-		out.Partition.Ordinal = in.Partition.Ordinal
+		out.RollingUpdate.Partition = new(int32)
+		*out.RollingUpdate.Partition = in.RollingUpdate.Partition
 	} else {
-		out.Partition = nil
+		out.RollingUpdate = nil
 	}
 	return nil
 }

pkg/apis/apps/v1beta1/defaults.go

@@ -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
+	}
 
 }
 

pkg/apis/apps/v1beta1/generated.pb.go

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

pkg/apis/apps/v1beta1/generated.proto

@@ -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
+  // RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType.
-  // the StatefulSet when Type is PartitionStatefulSetStrategyType. This
+  optional RollingUpdateStatefulSetStrategy rollingUpdate = 2;
-  // value must be set when Type is PartitionStatefulSetStrategyType,
-  // and it must be nil otherwise.
-  optional PartitionStatefulSetStrategy partition = 2;
 }
 

pkg/apis/apps/v1beta1/types.generated.go

@@ -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 {
+				if x.RollingUpdate != nil {
-					x.Partition = nil
+					x.RollingUpdate = nil
 				}
 			} else {
-				if x.Partition == nil {
+				if x.RollingUpdate == nil {
-					x.Partition = new(PartitionStatefulSetStrategy)
+					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 {
+		if x.RollingUpdate != nil {
-			x.Partition = nil
+			x.RollingUpdate = nil
 		}
 	} else {
-		if x.Partition == nil {
+		if x.RollingUpdate == nil {
-			x.Partition = new(PartitionStatefulSetStrategy)
+			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()
+				if yyq2[0] {
-				_ = yym4
+					if x.Partition == nil {
-				if false {
+						r.EncodeNil()
 					} else {
-					r.EncodeInt(int64(x.Ordinal))
+						yy4 := *x.Partition
-				}
-			} 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))
+							r.EncodeInt(int64(yy4))
+						}
+					}
+				} else {
+					r.EncodeNil()
+				}
+			} else {
+				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 {

pkg/apis/apps/v1beta1/types.go

@@ -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
+	// RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType.
-	// the StatefulSet when Type is PartitionStatefulSetStrategyType. This
+	RollingUpdate *RollingUpdateStatefulSetStrategy `json:"rollingUpdate,omitempty" protobuf:"bytes,2,opt,name=rollingUpdate"`
-	// 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"`
 }
 
 // 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
+// RollingUpdateStatefulSetStrategy is used to communicate parameter for RollingUpdateStatefulSetStrategyType.
-// PartitionStatefulSetStrategyType.
+type RollingUpdateStatefulSetStrategy struct {
-type PartitionStatefulSetStrategy struct {
+	// Partition indicates the ordinal at which the StatefulSet should be
-	// Ordinal 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.

pkg/apis/apps/v1beta1/types_swagger_doc_generated.go

@@ -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.",
@@ -247,7 +247,7 @@ 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.",
+	"rollingUpdate": "RollingUpdate is used to communicate parameters when Type is RollingUpdateStatefulSetStrategyType.",
 }
 
 func (StatefulSetUpdateStrategy) SwaggerDoc() map[string]string {

pkg/apis/apps/v1beta1/zz_generated.conversion.go

@@ -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_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy,
-		Convert_apps_PartitionStatefulSetStrategy_To_v1beta1_PartitionStatefulSetStrategy,
+		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 {
+func autoConvert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in *RollingUpdateStatefulSetStrategy, out *apps.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
-	out.Ordinal = in.Ordinal
+	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.
+// Convert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy is an autogenerated conversion function.
-func Convert_v1beta1_PartitionStatefulSetStrategy_To_apps_PartitionStatefulSetStrategy(in *PartitionStatefulSetStrategy, out *apps.PartitionStatefulSetStrategy, s conversion.Scope) error {
+func Convert_v1beta1_RollingUpdateStatefulSetStrategy_To_apps_RollingUpdateStatefulSetStrategy(in *RollingUpdateStatefulSetStrategy, out *apps.RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
-	return autoConvert_v1beta1_PartitionStatefulSetStrategy_To_apps_PartitionStatefulSetStrategy(in, out, s)
+	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 {
+func autoConvert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy(in *apps.RollingUpdateStatefulSetStrategy, out *RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
-	out.Ordinal = in.Ordinal
+	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.
+// Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy is an autogenerated conversion function.
-func Convert_apps_PartitionStatefulSetStrategy_To_v1beta1_PartitionStatefulSetStrategy(in *apps.PartitionStatefulSetStrategy, out *PartitionStatefulSetStrategy, s conversion.Scope) error {
+func Convert_apps_RollingUpdateStatefulSetStrategy_To_v1beta1_RollingUpdateStatefulSetStrategy(in *apps.RollingUpdateStatefulSetStrategy, out *RollingUpdateStatefulSetStrategy, s conversion.Scope) error {
-	return autoConvert_apps_PartitionStatefulSetStrategy_To_v1beta1_PartitionStatefulSetStrategy(in, out, s)
+	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
 }

pkg/apis/apps/v1beta1/zz_generated.deepcopy.go

@@ -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 {
+		if in.RollingUpdate != nil {
-			in, out := &in.Partition, &out.Partition
+			in, out := &in.RollingUpdate, &out.RollingUpdate
-			*out = new(PartitionStatefulSetStrategy)
+			*out = new(RollingUpdateStatefulSetStrategy)
-			**out = **in
+			if err := DeepCopy_v1beta1_RollingUpdateStatefulSetStrategy(*in, *out, c); err != nil {
+				return err
+			}
 		}
 		return nil
 	}

pkg/apis/apps/zz_generated.deepcopy.go

@@ -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.
+// DeepCopy_apps_RollingUpdateStatefulSetStrategy is an autogenerated deepcopy function.
-func DeepCopy_apps_PartitionStatefulSetStrategy(in interface{}, out interface{}, c *conversion.Cloner) error {
+func DeepCopy_apps_RollingUpdateStatefulSetStrategy(in interface{}, out interface{}, c *conversion.Cloner) error {
 	{
-		in := in.(*PartitionStatefulSetStrategy)
+		in := in.(*RollingUpdateStatefulSetStrategy)
-		out := out.(*PartitionStatefulSetStrategy)
+		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 {
+		if in.RollingUpdate != nil {
-			in, out := &in.Partition, &out.Partition
+			in, out := &in.RollingUpdate, &out.RollingUpdate
-			*out = new(PartitionStatefulSetStrategy)
+			*out = new(RollingUpdateStatefulSetStrategy)
 			**out = **in
 		}
 		return nil