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 {