Extract StackConverter from the StackClient

It makes it easier to get the correct stack from a compose config
struct without requiring the client (and thus talking to k8s API)

Signed-off-by: Vincent Demeester <vincent@sbr.pm>

Author: vdemeester

cli/command/stack/kubernetes/convert.go

@@ -8,13 +8,72 @@ import (
 	"strings"
 
 	"github.com/docker/cli/cli/compose/loader"
+	"github.com/docker/cli/cli/compose/schema"
 	composeTypes "github.com/docker/cli/cli/compose/types"
 	composetypes "github.com/docker/cli/cli/compose/types"
 	"github.com/docker/cli/kubernetes/compose/v1beta1"
 	"github.com/docker/cli/kubernetes/compose/v1beta2"
+	"github.com/pkg/errors"
+	yaml "gopkg.in/yaml.v2"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
+// NewStackConverter returns a converter from types.Config (compose) to the specified
+// stack version or error out if the version is not supported or existent.
+func NewStackConverter(version string) (StackConverter, error) {
+	switch version {
+	case "v1beta1":
+		return stackV1Beta1Converter{}, nil
+	case "v1beta2":
+		return stackV1Beta2Converter{}, nil
+	default:
+		return nil, errors.Errorf("stack version %s unsupported", version)
+	}
+}
+
+// StackConverter converts a compose types.Config to a Stack
+type StackConverter interface {
+	FromCompose(stderr io.Writer, name string, cfg *composetypes.Config) (Stack, error)
+}
+
+type stackV1Beta1Converter struct{}
+
+func (s stackV1Beta1Converter) FromCompose(stderr io.Writer, name string, cfg *composetypes.Config) (Stack, error) {
+	cfg.Version = v1beta1.MaxComposeVersion
+	st, err := fromCompose(stderr, name, cfg)
+	if err != nil {
+		return Stack{}, err
+	}
+	res, err := yaml.Marshal(cfg)
+	if err != nil {
+		return Stack{}, err
+	}
+	// reload the result to check that it produced a valid 3.5 compose file
+	resparsedConfig, err := loader.ParseYAML(res)
+	if err != nil {
+		return Stack{}, err
+	}
+	if err = schema.Validate(resparsedConfig, v1beta1.MaxComposeVersion); err != nil {
+		return Stack{}, errors.Wrapf(err, "the compose yaml file is invalid with v%s", v1beta1.MaxComposeVersion)
+	}
+
+	st.ComposeFile = string(res)
+	return st, nil
+}
+
+type stackV1Beta2Converter struct{}
+
+func (s stackV1Beta2Converter) FromCompose(stderr io.Writer, name string, cfg *composetypes.Config) (Stack, error) {
+	return fromCompose(stderr, name, cfg)
+}
+
+func fromCompose(stderr io.Writer, name string, cfg *composetypes.Config) (Stack, error) {
+	return Stack{
+		Name: name,
+		Spec: fromComposeConfig(stderr, cfg),
+	}, nil
+}
+
 func loadStackData(composefile string) (*composetypes.Config, error) {
 	parsed, err := loader.ParseYAML([]byte(composefile))
 	if err != nil {
@@ -30,44 +89,44 @@ func loadStackData(composefile string) (*composetypes.Config, error) {
 }
 
 // Conversions from internal stack to different stack compose component versions.
-func stackFromV1beta1(in *v1beta1.Stack) (stack, error) {
+func stackFromV1beta1(in *v1beta1.Stack) (Stack, error) {
 	cfg, err := loadStackData(in.Spec.ComposeFile)
 	if err != nil {
-		return stack{}, err
+		return Stack{}, err
 	}
-	return stack{
-		name:        in.ObjectMeta.Name,
-		namespace:   in.ObjectMeta.Namespace,
-		composeFile: in.Spec.ComposeFile,
-		spec:        fromComposeConfig(ioutil.Discard, cfg),
+	return Stack{
+		Name:        in.ObjectMeta.Name,
+		Namespace:   in.ObjectMeta.Namespace,
+		ComposeFile: in.Spec.ComposeFile,
+		Spec:        fromComposeConfig(ioutil.Discard, cfg),
 	}, nil
 }
 
-func stackToV1beta1(s stack) *v1beta1.Stack {
+func stackToV1beta1(s Stack) *v1beta1.Stack {
 	return &v1beta1.Stack{
 		ObjectMeta: metav1.ObjectMeta{
-			Name: s.name,
+			Name: s.Name,
 		},
 		Spec: v1beta1.StackSpec{
-			ComposeFile: s.composeFile,
+			ComposeFile: s.ComposeFile,
 		},
 	}
 }
 
-func stackFromV1beta2(in *v1beta2.Stack) stack {
-	return stack{
-		name:      in.ObjectMeta.Name,
-		namespace: in.ObjectMeta.Namespace,
-		spec:      in.Spec,
+func stackFromV1beta2(in *v1beta2.Stack) Stack {
+	return Stack{
+		Name:      in.ObjectMeta.Name,
+		Namespace: in.ObjectMeta.Namespace,
+		Spec:      in.Spec,
 	}
 }
 
-func stackToV1beta2(s stack) *v1beta2.Stack {
+func stackToV1beta2(s Stack) *v1beta2.Stack {
 	return &v1beta2.Stack{
 		ObjectMeta: metav1.ObjectMeta{
-			Name: s.name,
+			Name: s.Name,
 		},
-		Spec: s.spec,
+		Spec: s.Spec,
 	}
 }
 

cli/command/stack/kubernetes/convert_test.go

@@ -0,0 +1,18 @@
+package kubernetes
+
+import (
+	"testing"
+
+	"gotest.tools/assert"
+	is "gotest.tools/assert/cmp"
+)
+
+func TestNewStackConverter(t *testing.T) {
+	_, err := NewStackConverter("v1alpha1")
+	assert.Check(t, is.ErrorContains(err, "stack version v1alpha1 unsupported"))
+
+	_, err = NewStackConverter("v1beta1")
+	assert.NilError(t, err)
+	_, err = NewStackConverter("v1beta2")
+	assert.NilError(t, err)
+}

cli/command/stack/kubernetes/deploy.go

@@ -75,13 +75,13 @@ func RunDeploy(dockerCli *KubeCli, opts options.Deploy, cfg *composetypes.Config
 		}
 	}()
 
-	err = watcher.Watch(stack.name, stack.getServices(), statusUpdates)
+	err = watcher.Watch(stack.Name, stack.getServices(), statusUpdates)
 	close(statusUpdates)
 	<-displayDone
 	if err != nil {
 		return err
 	}
-	fmt.Fprintf(cmdOut, "\nStack %s is stable and running\n\n", stack.name)
+	fmt.Fprintf(cmdOut, "\nStack %s is stable and running\n\n", stack.Name)
 	return nil
 
 }

cli/command/stack/kubernetes/list.go

@@ -48,10 +48,10 @@ func getStacks(kubeCli *KubeCli, opts options.List) ([]*formatter.Stack, error)
 	var formattedStacks []*formatter.Stack
 	for _, stack := range stacks {
 		formattedStacks = append(formattedStacks, &formatter.Stack{
-			Name:         stack.name,
+			Name:         stack.Name,
 			Services:     len(stack.getServices()),
 			Orchestrator: "Kubernetes",
-			Namespace:    stack.namespace,
+			Namespace:    stack.Namespace,
 		})
 	}
 	return formattedStacks, nil

cli/command/stack/kubernetes/stack.go

@@ -12,27 +12,27 @@ import (
 	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
 )
 
-// stack is the main type used by stack commands so they remain independent from kubernetes compose component version.
-type stack struct {
-	name        string
-	namespace   string
-	composeFile string
-	spec        *v1beta2.StackSpec
+// Stack is the main type used by stack commands so they remain independent from kubernetes compose component version.
+type Stack struct {
+	Name        string
+	Namespace   string
+	ComposeFile string
+	Spec        *v1beta2.StackSpec
 }
 
 // getServices returns all the stack service names, sorted lexicographically
-func (s *stack) getServices() []string {
-	services := make([]string, len(s.spec.Services))
-	for i, service := range s.spec.Services {
+func (s *Stack) getServices() []string {
+	services := make([]string, len(s.Spec.Services))
+	for i, service := range s.Spec.Services {
 		services[i] = service.Name
 	}
 	sort.Strings(services)
 	return services
 }
 
 // createFileBasedConfigMaps creates a Kubernetes ConfigMap for each Compose global file-based config.
-func (s *stack) createFileBasedConfigMaps(configMaps corev1.ConfigMapInterface) error {
-	for name, config := range s.spec.Configs {
+func (s *Stack) createFileBasedConfigMaps(configMaps corev1.ConfigMapInterface) error {
+	for name, config := range s.Spec.Configs {
 		if config.File == "" {
 			continue
 		}
@@ -43,7 +43,7 @@ func (s *stack) createFileBasedConfigMaps(configMaps corev1.ConfigMapInterface)
 			return err
 		}
 
-		if _, err := configMaps.Create(toConfigMap(s.name, name, fileName, content)); err != nil {
+		if _, err := configMaps.Create(toConfigMap(s.Name, name, fileName, content)); err != nil {
 			return err
 		}
 	}
@@ -71,8 +71,8 @@ func toConfigMap(stackName, name, key string, content []byte) *apiv1.ConfigMap {
 }
 
 // createFileBasedSecrets creates a Kubernetes Secret for each Compose global file-based secret.
-func (s *stack) createFileBasedSecrets(secrets corev1.SecretInterface) error {
-	for name, secret := range s.spec.Secrets {
+func (s *Stack) createFileBasedSecrets(secrets corev1.SecretInterface) error {
+	for name, secret := range s.Spec.Secrets {
 		if secret.File == "" {
 			continue
 		}
@@ -83,7 +83,7 @@ func (s *stack) createFileBasedSecrets(secrets corev1.SecretInterface) error {
 			return err
 		}
 
-		if _, err := secrets.Create(toSecret(s.name, name, fileName, content)); err != nil {
+		if _, err := secrets.Create(toSecret(s.Name, name, fileName, content)); err != nil {
 			return err
 		}
 	}