Bug 1844471: bump kubernetes to 1.19.0-rc.2

hack/update-generated-conversions.sh

@@ -17,6 +17,8 @@ ALL_FQ_APIS=(
     github.com/openshift/openshift-apiserver/pkg/authorization/apis/authorization/v1
     github.com/openshift/openshift-apiserver/pkg/build/apis/build/v1
     github.com/openshift/openshift-apiserver/pkg/image/apis/image/v1
+    github.com/openshift/openshift-apiserver/pkg/image/apis/image/dockerpre012
+    github.com/openshift/openshift-apiserver/pkg/image/apis/image/docker10
     github.com/openshift/openshift-apiserver/pkg/oauth/apis/oauth/v1
     github.com/openshift/openshift-apiserver/pkg/project/apis/project/v1
     github.com/openshift/openshift-apiserver/pkg/project/apiserver/admission/apis/requestlimit/v1

pkg/api/compatibility_test.go

@@ -40,7 +40,8 @@ func TestCompatibility_v1_Pod(t *testing.T) {
 	testCompatibility(
 		t, "v1", input,
 		func(obj runtime.Object) field.ErrorList {
-			return validation.ValidatePod(obj.(*api.Pod), validation.PodValidationOptions{})
+			pod := obj.(*api.Pod)
+			return validation.ValidatePodSpec(&pod.Spec, &pod.ObjectMeta, field.NewPath("spec"))
 		},
 		map[string]string{
 			"spec.serviceAccount":     expectedServiceAccount,

pkg/api/legacy/image.go

@@ -12,6 +12,8 @@ import (
 	imagev1 "github.com/openshift/api/image/v1"
 	"github.com/openshift/openshift-apiserver/pkg/api/apihelpers"
 	"github.com/openshift/openshift-apiserver/pkg/image/apis/image"
+	imagedocker10helpers "github.com/openshift/openshift-apiserver/pkg/image/apis/image/docker10"
+	imagedockerpre012helpers "github.com/openshift/openshift-apiserver/pkg/image/apis/image/dockerpre012"
 	imagev1helpers "github.com/openshift/openshift-apiserver/pkg/image/apis/image/v1"
 )
 
@@ -28,6 +30,8 @@ func InstallInternalLegacyImage(scheme *runtime.Scheme) {
 		addLegacyImageFieldSelectorKeyConversions,
 		imagev1helpers.RegisterDefaults,
 		imagev1helpers.RegisterConversions,
+		imagedockerpre012helpers.RegisterConversions,
+		imagedocker10helpers.RegisterConversions,
 	)
 	utilruntime.Must(schemeBuilder.AddToScheme(scheme))
 }

pkg/api/validation/validation_test.go

@@ -232,16 +232,28 @@ func TestPodSpecNodeSelectorUpdateDisallowed(t *testing.T) {
 	oldPod := &kapi.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			ResourceVersion: "1",
+			Name:            "test",
+			Namespace:       "test",
 		},
 		Spec: kapi.PodSpec{
+			Containers: []kapi.Container{
+				{
+					Name:                     "test",
+					Image:                    "test",
+					TerminationMessagePolicy: kapi.TerminationMessageFallbackToLogsOnError,
+					ImagePullPolicy:          kapi.PullAlways,
+				},
+			},
+			RestartPolicy: kapi.RestartPolicyAlways,
+			DNSPolicy:     kapi.DNSClusterFirst,
 			NodeSelector: map[string]string{
 				"foo": "bar",
 			},
 		},
 	}
 
 	if errs := validation.ValidatePodUpdate(oldPod, oldPod, validation.PodValidationOptions{}); len(errs) != 0 {
-		t.Fatal("expected no errors")
+		t.Fatalf("expected no errors, got: %+v", errs)
 	}
 
 	newPod := *oldPod

pkg/apps/apis/apps/v1/conversion.go

@@ -3,6 +3,7 @@ package v1
 import (
 	"strings"
 
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/conversion"
 	"k8s.io/apimachinery/pkg/util/intstr"
 
@@ -45,7 +46,7 @@ func Convert_apps_DeploymentTriggerImageChangeParams_To_v1_DeploymentTriggerImag
 	return nil
 }
 
-func Convert_v1_RollingDeploymentStrategyParams_To_apps_RollingDeploymentStrategyParams(in *v1.RollingDeploymentStrategyParams, out *newer.RollingDeploymentStrategyParams, s conversion.Scope) error {
+func Convert_v1_RollingDeploymentStrategyParams_To_apps_RollingDeploymentStrategyParams(in *v1.RollingDeploymentStrategyParams, out *newer.RollingDeploymentStrategyParams, _ conversion.Scope) error {
 	SetDefaults_RollingDeploymentStrategyParams(in)
 
 	out.UpdatePeriodSeconds = in.UpdatePeriodSeconds
@@ -54,43 +55,44 @@ func Convert_v1_RollingDeploymentStrategyParams_To_apps_RollingDeploymentStrateg
 
 	if in.Pre != nil {
 		out.Pre = &newer.LifecycleHook{}
-		if err := Convert_v1_LifecycleHook_To_apps_LifecycleHook(in.Pre, out.Pre, s); err != nil {
+		if err := Convert_v1_LifecycleHook_To_apps_LifecycleHook(in.Pre, out.Pre, nil); err != nil {
 			return err
 		}
 	}
 	if in.Post != nil {
 		out.Post = &newer.LifecycleHook{}
-		if err := Convert_v1_LifecycleHook_To_apps_LifecycleHook(in.Post, out.Post, s); err != nil {
+		if err := Convert_v1_LifecycleHook_To_apps_LifecycleHook(in.Post, out.Post, nil); err != nil {
 			return err
 		}
 	}
 	if in.MaxUnavailable != nil {
-		if err := s.Convert(in.MaxUnavailable, &out.MaxUnavailable, 0); err != nil {
+		if err := metav1.Convert_intstr_IntOrString_To_intstr_IntOrString(in.MaxUnavailable, &out.MaxUnavailable, nil); err != nil {
 			return err
 		}
 	}
 	if in.MaxSurge != nil {
-		if err := s.Convert(in.MaxSurge, &out.MaxSurge, 0); err != nil {
+		if err := metav1.Convert_intstr_IntOrString_To_intstr_IntOrString(in.MaxSurge, &out.MaxSurge, nil); err != nil {
 			return err
 		}
 	}
+
 	return nil
 }
 
-func Convert_apps_RollingDeploymentStrategyParams_To_v1_RollingDeploymentStrategyParams(in *newer.RollingDeploymentStrategyParams, out *v1.RollingDeploymentStrategyParams, s conversion.Scope) error {
+func Convert_apps_RollingDeploymentStrategyParams_To_v1_RollingDeploymentStrategyParams(in *newer.RollingDeploymentStrategyParams, out *v1.RollingDeploymentStrategyParams, _ conversion.Scope) error {
 	out.UpdatePeriodSeconds = in.UpdatePeriodSeconds
 	out.IntervalSeconds = in.IntervalSeconds
 	out.TimeoutSeconds = in.TimeoutSeconds
 
 	if in.Pre != nil {
 		out.Pre = &v1.LifecycleHook{}
-		if err := Convert_apps_LifecycleHook_To_v1_LifecycleHook(in.Pre, out.Pre, s); err != nil {
+		if err := Convert_apps_LifecycleHook_To_v1_LifecycleHook(in.Pre, out.Pre, nil); err != nil {
 			return err
 		}
 	}
 	if in.Post != nil {
 		out.Post = &v1.LifecycleHook{}
-		if err := Convert_apps_LifecycleHook_To_v1_LifecycleHook(in.Post, out.Post, s); err != nil {
+		if err := Convert_apps_LifecycleHook_To_v1_LifecycleHook(in.Post, out.Post, nil); err != nil {
 			return err
 		}
 	}
@@ -101,11 +103,13 @@ func Convert_apps_RollingDeploymentStrategyParams_To_v1_RollingDeploymentStrateg
 	if out.MaxSurge == nil {
 		out.MaxSurge = &intstr.IntOrString{}
 	}
-	if err := s.Convert(&in.MaxUnavailable, out.MaxUnavailable, 0); err != nil {
+
+	if err := metav1.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.MaxUnavailable, out.MaxUnavailable, nil); err != nil {
 		return err
 	}
-	if err := s.Convert(&in.MaxSurge, out.MaxSurge, 0); err != nil {
+	if err := metav1.Convert_intstr_IntOrString_To_intstr_IntOrString(&in.MaxSurge, out.MaxSurge, nil); err != nil {
 		return err
 	}
+
 	return nil
 }

pkg/apps/apiserver/registry/appstest/testutil.go

@@ -1,21 +1,14 @@
 package appstest
 
 import (
-	"testing"
-
+	appsv1 "github.com/openshift/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/sets"
-	"k8s.io/kubernetes/pkg/api/legacyscheme"
-
-	appsv1 "github.com/openshift/api/apps/v1"
 )
 
 const (
-	ImageStreamName      = "test-image-stream"
-	ImageID              = "0000000000000000000000000000000000000000000000000000000000000001"
-	DockerImageReference = "registry:5000/openshift/test-image-stream@sha256:0000000000000000000000000000000000000000000000000000000000000001"
+	ImageStreamName = "test-image-stream"
 )
 
 func OkDeploymentConfig(version int64) *appsv1.DeploymentConfig {
@@ -49,31 +42,13 @@ func OkDeploymentConfigStatus(version int64) appsv1.DeploymentConfigStatus {
 	}
 }
 
-func OkImageChangeDetails() *appsv1.DeploymentDetails {
-	return &appsv1.DeploymentDetails{
-		Causes: []appsv1.DeploymentCause{{
-			Type: appsv1.DeploymentTriggerOnImageChange,
-			ImageTrigger: &appsv1.DeploymentCauseImageTrigger{
-				From: corev1.ObjectReference{
-					Name: ImageStreamName + ":latest",
-					Kind: "ImageStreamTag",
-				}}}}}
-}
-
-func OkConfigChangeDetails() *appsv1.DeploymentDetails {
-	return &appsv1.DeploymentDetails{
-		Causes: []appsv1.DeploymentCause{{
-			Type: appsv1.DeploymentTriggerOnConfigChange,
-		}}}
-}
-
 func OkStrategy() appsv1.DeploymentStrategy {
 	return appsv1.DeploymentStrategy{
 		Type: appsv1.DeploymentStrategyTypeRecreate,
 		Resources: corev1.ResourceRequirements{
 			Limits: corev1.ResourceList{
-				corev1.ResourceName(corev1.ResourceCPU):    resource.MustParse("10"),
-				corev1.ResourceName(corev1.ResourceMemory): resource.MustParse("10G"),
+				corev1.ResourceCPU:    resource.MustParse("10"),
+				corev1.ResourceMemory: resource.MustParse("10G"),
 			},
 		},
 		RecreateParams: &appsv1.RecreateDeploymentStrategyParams{
@@ -83,54 +58,11 @@ func OkStrategy() appsv1.DeploymentStrategy {
 	}
 }
 
-func OkCustomStrategy() appsv1.DeploymentStrategy {
-	return appsv1.DeploymentStrategy{
-		Type:         appsv1.DeploymentStrategyTypeCustom,
-		CustomParams: OkCustomParams(),
-		Resources: corev1.ResourceRequirements{
-			Limits: corev1.ResourceList{
-				corev1.ResourceName(corev1.ResourceCPU):    resource.MustParse("10"),
-				corev1.ResourceName(corev1.ResourceMemory): resource.MustParse("10G"),
-			},
-		},
-	}
-}
-
-func OkCustomParams() *appsv1.CustomDeploymentStrategyParams {
-	return &appsv1.CustomDeploymentStrategyParams{
-		Image: "openshift/origin-deployer",
-		Environment: []corev1.EnvVar{
-			{
-				Name:  "ENV1",
-				Value: "VAL1",
-			},
-		},
-		Command: []string{"/bin/echo", "hello", "world"},
-	}
-}
-
 func mkintp(i int) *int64 {
 	v := int64(i)
 	return &v
 }
 
-func OkRollingStrategy() appsv1.DeploymentStrategy {
-	return appsv1.DeploymentStrategy{
-		Type: appsv1.DeploymentStrategyTypeRolling,
-		RollingParams: &appsv1.RollingDeploymentStrategyParams{
-			UpdatePeriodSeconds: mkintp(1),
-			IntervalSeconds:     mkintp(1),
-			TimeoutSeconds:      mkintp(20),
-		},
-		Resources: corev1.ResourceRequirements{
-			Limits: corev1.ResourceList{
-				corev1.ResourceName(corev1.ResourceCPU):    resource.MustParse("10"),
-				corev1.ResourceName(corev1.ResourceMemory): resource.MustParse("10G"),
-			},
-		},
-	}
-}
-
 func OkSelector() map[string]string {
 	return map[string]string{"a": "b"}
 }
@@ -173,24 +105,6 @@ func OkPodTemplate() *corev1.PodTemplateSpec {
 	}
 }
 
-func OkPodTemplateChanged() *corev1.PodTemplateSpec {
-	template := OkPodTemplate()
-	template.Spec.Containers[0].Image = DockerImageReference
-	return template
-}
-
-func OkPodTemplateMissingImage(missing ...string) *corev1.PodTemplateSpec {
-	set := sets.NewString(missing...)
-	template := OkPodTemplate()
-	for i, c := range template.Spec.Containers {
-		if set.Has(c.Name) {
-			// remember that slices use copies, so have to ref array entry explicitly
-			template.Spec.Containers[i].Image = ""
-		}
-	}
-	return template
-}
-
 func OkConfigChangeTrigger() appsv1.DeploymentTriggerPolicy {
 	return appsv1.DeploymentTriggerPolicy{
 		Type: appsv1.DeploymentTriggerOnConfigChange,
@@ -212,57 +126,3 @@ func OkImageChangeTrigger() appsv1.DeploymentTriggerPolicy {
 		},
 	}
 }
-
-func OkTriggeredImageChange() appsv1.DeploymentTriggerPolicy {
-	ict := OkImageChangeTrigger()
-	ict.ImageChangeParams.LastTriggeredImage = DockerImageReference
-	return ict
-}
-
-func OkNonAutomaticICT() appsv1.DeploymentTriggerPolicy {
-	ict := OkImageChangeTrigger()
-	ict.ImageChangeParams.Automatic = false
-	return ict
-}
-
-func OkTriggeredNonAutomatic() appsv1.DeploymentTriggerPolicy {
-	ict := OkNonAutomaticICT()
-	ict.ImageChangeParams.LastTriggeredImage = DockerImageReference
-	return ict
-}
-
-func TestDeploymentConfig(config *appsv1.DeploymentConfig) *appsv1.DeploymentConfig {
-	config.Spec.Test = true
-	return config
-}
-
-func RemoveTriggerTypes(config *appsv1.DeploymentConfig, triggerTypes ...appsv1.DeploymentTriggerType) {
-	types := sets.NewString()
-	for _, triggerType := range triggerTypes {
-		types.Insert(string(triggerType))
-	}
-
-	remaining := []appsv1.DeploymentTriggerPolicy{}
-	for _, trigger := range config.Spec.Triggers {
-		if types.Has(string(trigger.Type)) {
-			continue
-		}
-		remaining = append(remaining, trigger)
-	}
-
-	config.Spec.Triggers = remaining
-}
-
-func RoundTripConfig(t *testing.T, config *appsv1.DeploymentConfig) *appsv1.DeploymentConfig {
-	versioned, err := legacyscheme.Scheme.ConvertToVersion(config, appsv1.SchemeGroupVersion)
-	if err != nil {
-		t.Errorf("unexpected conversion error: %v", err)
-		return nil
-	}
-	defaulted, err := legacyscheme.Scheme.ConvertToVersion(versioned, appsv1.SchemeGroupVersion)
-	if err != nil {
-		t.Errorf("unexpected conversion error: %v", err)
-		return nil
-	}
-	return defaulted.(*appsv1.DeploymentConfig)
-}

pkg/apps/apiserver/registry/instantiate/rest.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 
+	v1 "github.com/openshift/openshift-apiserver/pkg/apps/apis/apps/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -290,7 +291,7 @@ func canTrigger(
 
 	canTriggerByConfigChange := false
 	externalConfig := &appsv1.DeploymentConfig{}
-	if err := legacyscheme.Scheme.Convert(config, externalConfig, nil); err != nil {
+	if err := v1.Convert_apps_DeploymentConfig_To_v1_DeploymentConfig(config, externalConfig, nil); err != nil {
 		return false, nil, err
 	}
 	if appsutil.HasChangeTrigger(externalConfig) && // Our deployment config has a config change trigger
@@ -313,7 +314,7 @@ func decodeFromLatestDeployment(ctx context.Context, config *appsapi.DeploymentC
 		return config, nil
 	}
 	externalConfig := &appsv1.DeploymentConfig{}
-	if err := legacyscheme.Scheme.Convert(config, externalConfig, nil); err != nil {
+	if err := v1.Convert_apps_DeploymentConfig_To_v1_DeploymentConfig(config, externalConfig, nil); err != nil {
 		return nil, err
 	}
 	latestDeploymentName := appsutil.LatestDeploymentNameForConfig(externalConfig)
@@ -329,7 +330,7 @@ func decodeFromLatestDeployment(ctx context.Context, config *appsapi.DeploymentC
 		return nil, errors.NewInternalError(err)
 	}
 	internalConfig := &appsapi.DeploymentConfig{}
-	if err := legacyscheme.Scheme.Convert(decoded, internalConfig, nil); err != nil {
+	if err := v1.Convert_v1_DeploymentConfig_To_apps_DeploymentConfig(decoded, internalConfig, nil); err != nil {
 		return nil, err
 	}
 	return internalConfig, nil