From b80376ff8b71c456c85b0daac2f5e339a0426da5 Mon Sep 17 00:00:00 2001
From: Olivier Lemasle <o.lemasle@gmail.com>
Date: Sun, 8 Nov 2020 16:04:33 +0100
Subject: [PATCH] Update call to deprecated K8s function
AddConversionFuncs in k8s.io/apimachinery/pkg/runtime.Scheme
is deprecated and removed in k8s 1.18 (cf https://github.com/kubernetes/kubernetes/pull/85891)
This change replaces the deprecated registration code to this
(more verbose) registration code, which will continue to be
supported in K8s 1.18+.
Signed-off-by: Olivier Lemasle <o.lemasle@gmail.com>
---
internal/conversions/v1alpha3.go | 45 ++++++++++++++++++++++-----
internal/conversions/v1alpha3_test.go | 33 ++++++++++++++++++++
internal/conversions/v1beta1.go | 44 +++++++++++++++++++++-----
internal/conversions/v1beta2.go | 45 ++++++++++++++++++++++-----
4 files changed, 143 insertions(+), 24 deletions(-)
diff --git a/internal/conversions/v1alpha3.go b/internal/conversions/v1alpha3.go
index a5fe6749..0f0de2bd 100644
--- a/internal/conversions/v1alpha3.go
+++ b/internal/conversions/v1alpha3.go
@@ -16,14 +16,43 @@ import (
// RegisterV1alpha3Conversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterV1alpha3Conversions(scheme *runtime.Scheme) error {
- return scheme.AddConversionFuncs(
- ownerToInternalV1alpha3,
- ownerFromInternalV1alpha3,
- stackToInternalV1alpha3,
- stackFromInternalV1alpha3,
- stackListToInternalV1alpha3,
- stackListFromInternalV1alpha3,
- )
+ if err := scheme.AddConversionFunc((*v1alpha3.Owner)(nil), (*internalversion.Owner)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return ownerToInternalV1alpha3(a.(*v1alpha3.Owner), b.(*internalversion.Owner), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*internalversion.Owner)(nil), (*v1alpha3.Owner)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return ownerFromInternalV1alpha3(a.(*internalversion.Owner), b.(*v1alpha3.Owner), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*v1alpha3.Stack)(nil), (*internalversion.Stack)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackToInternalV1alpha3(a.(*v1alpha3.Stack), b.(*internalversion.Stack), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*internalversion.Stack)(nil), (*v1alpha3.Stack)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackFromInternalV1alpha3(a.(*internalversion.Stack), b.(*v1alpha3.Stack), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*v1alpha3.StackList)(nil), (*internalversion.StackList)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackListToInternalV1alpha3(a.(*v1alpha3.StackList), b.(*internalversion.StackList), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*internalversion.StackList)(nil), (*v1alpha3.StackList)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackListFromInternalV1alpha3(a.(*internalversion.StackList), b.(*v1alpha3.StackList), scope)
+ }); err != nil {
+ return err
+ }
+
+ return nil
}
func ownerToInternalV1alpha3(in *v1alpha3.Owner, out *internalversion.Owner, _ conversion.Scope) error {
diff --git a/internal/conversions/v1alpha3_test.go b/internal/conversions/v1alpha3_test.go
index 8bf7dc2b..e8d5b189 100644
--- a/internal/conversions/v1alpha3_test.go
+++ b/internal/conversions/v1alpha3_test.go
@@ -1 +1,34 @@
package conversions
+
+import (
+ "testing"
+
+ "github.com/docker/compose-on-kubernetes/api/compose/impersonation"
+ "github.com/docker/compose-on-kubernetes/api/compose/v1alpha3"
+ "github.com/docker/compose-on-kubernetes/internal/internalversion"
+ "github.com/stretchr/testify/assert"
+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ "k8s.io/apimachinery/pkg/runtime"
+)
+
+func TestRegisterV1alpha3Conversions(t *testing.T) {
+ scheme := runtime.NewScheme()
+ RegisterV1alpha3Conversions(scheme)
+
+ v1alpha3Owner := &v1alpha3.Owner{
+ ObjectMeta: metav1.ObjectMeta{
+ Name: "owner",
+ },
+ Owner: impersonation.Config{
+ UserName: "foo",
+ },
+ }
+ internalversionOwner := &internalversion.Owner{}
+ scheme.Convert(v1alpha3Owner, internalversionOwner, nil)
+ assert.Equal(t, "owner", internalversionOwner.ObjectMeta.Name)
+ assert.Equal(t, "foo", internalversionOwner.Owner.UserName)
+
+ internalversionOwner.Owner.UserName = "bar"
+ scheme.Convert(internalversionOwner, v1alpha3Owner, nil)
+ assert.Equal(t, "bar", v1alpha3Owner.Owner.UserName)
+}
diff --git a/internal/conversions/v1beta1.go b/internal/conversions/v1beta1.go
index 0990555d..e0886143 100644
--- a/internal/conversions/v1beta1.go
+++ b/internal/conversions/v1beta1.go
@@ -10,15 +10,43 @@ import (
// RegisterV1beta1Conversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterV1beta1Conversions(scheme *runtime.Scheme) error {
+ if err := scheme.AddConversionFunc((*v1beta1.Owner)(nil), (*internalversion.Owner)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return ownerToInternalV1beta1(a.(*v1beta1.Owner), b.(*internalversion.Owner), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*internalversion.Owner)(nil), (*v1beta1.Owner)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return ownerFromInternalV1beta1(a.(*internalversion.Owner), b.(*v1beta1.Owner), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*v1beta1.Stack)(nil), (*internalversion.Stack)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackToInternalV1beta1(a.(*v1beta1.Stack), b.(*internalversion.Stack), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*internalversion.Stack)(nil), (*v1beta1.Stack)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackFromInternalV1beta1(a.(*internalversion.Stack), b.(*v1beta1.Stack), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*v1beta1.StackList)(nil), (*internalversion.StackList)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackListToInternalV1beta1(a.(*v1beta1.StackList), b.(*internalversion.StackList), scope)
+ }); err != nil {
+ return err
+ }
- return scheme.AddConversionFuncs(
- ownerToInternalV1beta1,
- ownerFromInternalV1beta1,
- stackToInternalV1beta1,
- stackFromInternalV1beta1,
- stackListToInternalV1beta1,
- stackListFromInternalV1beta1,
- )
+ if err := scheme.AddConversionFunc((*internalversion.StackList)(nil), (*v1beta1.StackList)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackListFromInternalV1beta1(a.(*internalversion.StackList), b.(*v1beta1.StackList), scope)
+ }); err != nil {
+ return err
+ }
+
+ return nil
}
func ownerToInternalV1beta1(in *v1beta1.Owner, out *internalversion.Owner, _ conversion.Scope) error {
diff --git a/internal/conversions/v1beta2.go b/internal/conversions/v1beta2.go
index adcb34ca..e675ee30 100644
--- a/internal/conversions/v1beta2.go
+++ b/internal/conversions/v1beta2.go
@@ -11,14 +11,43 @@ import (
// RegisterV1beta2Conversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterV1beta2Conversions(scheme *runtime.Scheme) error {
- return scheme.AddConversionFuncs(
- ownerToInternalV1beta2,
- ownerFromInternalV1beta2,
- stackToInternalV1beta2,
- stackFromInternalV1beta2,
- stackListToInternalV1beta2,
- stackListFromInternalV1beta2,
- )
+ if err := scheme.AddConversionFunc((*v1beta2.Owner)(nil), (*internalversion.Owner)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return ownerToInternalV1beta2(a.(*v1beta2.Owner), b.(*internalversion.Owner), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*internalversion.Owner)(nil), (*v1beta2.Owner)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return ownerFromInternalV1beta2(a.(*internalversion.Owner), b.(*v1beta2.Owner), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*v1beta2.Stack)(nil), (*internalversion.Stack)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackToInternalV1beta2(a.(*v1beta2.Stack), b.(*internalversion.Stack), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*internalversion.Stack)(nil), (*v1beta2.Stack)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackFromInternalV1beta2(a.(*internalversion.Stack), b.(*v1beta2.Stack), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*v1beta2.StackList)(nil), (*internalversion.StackList)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackListToInternalV1beta2(a.(*v1beta2.StackList), b.(*internalversion.StackList), scope)
+ }); err != nil {
+ return err
+ }
+
+ if err := scheme.AddConversionFunc((*internalversion.StackList)(nil), (*v1beta2.StackList)(nil), func(a, b interface{}, scope conversion.Scope) error {
+ return stackListFromInternalV1beta2(a.(*internalversion.StackList), b.(*v1beta2.StackList), scope)
+ }); err != nil {
+ return err
+ }
+
+ return nil
}
func ownerToInternalV1beta2(in *v1beta2.Owner, out *internalversion.Owner, _ conversion.Scope) error {