move k8s base functions into k8s package

cli/app/app.go

@@ -17,31 +17,25 @@ limitations under the License.
 package app
 
 import (
+	"fmt"
+
 	"github.com/Sirupsen/logrus"
 	"github.com/urfave/cli"
 
 	// install kubernetes api
 	_ "k8s.io/kubernetes/pkg/api/install"
 	_ "k8s.io/kubernetes/pkg/apis/extensions/install"
-
-	"k8s.io/kubernetes/pkg/api"
-	"k8s.io/kubernetes/pkg/apis/extensions"
 	client "k8s.io/kubernetes/pkg/client/unversioned"
 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/runtime"
 
 	// install kubernetes api
 	_ "github.com/openshift/origin/pkg/deploy/api/install"
-
 	"github.com/skippbox/kompose/pkg/kobject"
 	"github.com/skippbox/kompose/pkg/loader"
 	"github.com/skippbox/kompose/pkg/loader/bundle"
 	"github.com/skippbox/kompose/pkg/loader/compose"
 	"github.com/skippbox/kompose/pkg/transformer"
-	"github.com/docker/libcompose/lookup"
-	"github.com/docker/libcompose/config"
-	"github.com/docker/libcompose/project"
-	"fmt"
-	"strings"
 	"github.com/skippbox/kompose/pkg/transformer/kubernetes"
 	"github.com/skippbox/kompose/pkg/transformer/openshift"
 )
@@ -195,201 +189,6 @@ func Scale(c *cli.Context) {
 	//}
 }
 
-// Convert komposeObject to K8S controllers
-func komposeConvert(komposeObject KomposeObject, opt convertOptions) []runtime.Object {
-	var svcnames []string
-
-	// this will hold all the converted data
-	var allobjects []runtime.Object
-	for name, service := range komposeObject.ServiceConfigs {
-		var objects []runtime.Object
-		svcnames = append(svcnames, name)
-		sc := initSC(name, service)
-
-		if opt.createD {
-			objects = append(objects, initDC(name, service, opt.replicas))
-		}
-		if opt.createDS {
-			objects = append(objects, initDS(name, service))
-		}
-		if opt.createRC {
-			objects = append(objects, initRC(name, service, opt.replicas))
-		}
-		if opt.createDeploymentConfig {
-			objects = append(objects, initDeploymentConfig(name, service, opt.replicas)) // OpenShift DeploymentConfigs
-		}
-
-		// Configure the environment variables.
-		envs := configEnvs(name, service)
-
-		// Configure the container command.
-		var cmds []string
-		for _, cmd := range service.Command {
-			cmds = append(cmds, cmd)
-		}
-		// Configure the container volumes.
-		volumesMount, volumes := configVolumes(service)
-
-		// Configure the container ports.
-		ports := configPorts(name, service)
-
-		// Configure the service ports.
-		servicePorts := configServicePorts(name, service)
-		sc.Spec.Ports = servicePorts
-
-		// Configure labels
-		labels := map[string]string{"service": name}
-		sc.ObjectMeta.Labels = labels
-		// Configure annotations
-		annotations := map[string]string{}
-		for key, value := range service.Annotations {
-			annotations[key] = value
-		}
-		sc.ObjectMeta.Annotations = annotations
-
-		// fillTemplate fills the pod template with the value calculated from config
-		fillTemplate := func(template *api.PodTemplateSpec) {
-			template.Spec.Containers[0].Env = envs
-			template.Spec.Containers[0].Command = cmds
-			template.Spec.Containers[0].WorkingDir = service.WorkingDir
-			template.Spec.Containers[0].VolumeMounts = volumesMount
-			template.Spec.Volumes = volumes
-			// Configure the container privileged mode
-			if service.Privileged == true {
-				template.Spec.Containers[0].SecurityContext = &api.SecurityContext{
-					Privileged: &service.Privileged,
-				}
-			}
-			template.Spec.Containers[0].Ports = ports
-			template.ObjectMeta.Labels = labels
-			// Configure the container restart policy.
-			switch service.Restart {
-			case "", "always":
-				template.Spec.RestartPolicy = api.RestartPolicyAlways
-			case "no":
-				template.Spec.RestartPolicy = api.RestartPolicyNever
-			case "on-failure":
-				template.Spec.RestartPolicy = api.RestartPolicyOnFailure
-			default:
-				logrus.Fatalf("Unknown restart policy %s for service %s", service.Restart, name)
-			}
-		}
-
-		// fillObjectMeta fills the metadata with the value calculated from config
-		fillObjectMeta := func(meta *api.ObjectMeta) {
-			meta.Labels = labels
-			meta.Annotations = annotations
-		}
-
-		// update supported controller
-		for _, obj := range objects {
-			updateController(obj, fillTemplate, fillObjectMeta)
-		}
-
-		// If ports not provided in configuration we will not make service
-		if len(ports) == 0 {
-			logrus.Warningf("[%s] Service cannot be created because of missing port.", name)
-		} else {
-			objects = append(objects, sc)
-		}
-		allobjects = append(allobjects, objects...)
-	}
-	return allobjects
-}
-
-// PrintList will take the data converted and decide on the commandline attributes given
-func PrintList(objects []runtime.Object, opt convertOptions) error {
-	f := createOutFile(opt.outFile)
-	defer f.Close()
-
-	var err error
-	var files []string
-
-	// if asked to print to stdout or to put in single file
-	// we will create a list
-	if opt.toStdout || f != nil {
-		list := &api.List{}
-		list.Items = objects
-
-		// version each object in the list
-		list.Items, err = ConvertToVersion(list.Items)
-		if err != nil {
-			return err
-		}
-
-		// version list itself
-		listVersion := unversioned.GroupVersion{Group: "", Version: "v1"}
-		convertedList, err := api.Scheme.ConvertToVersion(list, listVersion)
-		if err != nil {
-			return err
-		}
-		data, err := marshal(convertedList, opt.generateYaml)
-		if err != nil {
-			return fmt.Errorf("Error in marshalling the List: %v", err)
-		}
-		files = append(files, print("", "", data, opt.toStdout, opt.generateYaml, f))
-	} else {
-		var file string
-		// create a separate file for each provider
-		for _, v := range objects {
-			data, err := marshal(v, opt.generateYaml)
-			if err != nil {
-				return err
-			}
-			switch t := v.(type) {
-			case *api.ReplicationController:
-				file = print(t.Name, strings.ToLower(t.Kind), data, opt.toStdout, opt.generateYaml, f)
-			case *extensions.Deployment:
-				file = print(t.Name, strings.ToLower(t.Kind), data, opt.toStdout, opt.generateYaml, f)
-			case *extensions.DaemonSet:
-				file = print(t.Name, strings.ToLower(t.Kind), data, opt.toStdout, opt.generateYaml, f)
-			case *deployapi.DeploymentConfig:
-				file = print(t.Name, strings.ToLower(t.Kind), data, opt.toStdout, opt.generateYaml, f)
-			case *api.Service:
-				file = print(t.Name, strings.ToLower(t.Kind), data, opt.toStdout, opt.generateYaml, f)
-			}
-			files = append(files, file)
-
-		}
-	}
-	if opt.createChart {
-		generateHelm(opt.inputFile, files)
-	}
-	return nil
-}
-
-// marshal object runtime.Object and return byte array
-func marshal(obj runtime.Object, yamlFormat bool) (data []byte, err error) {
-	// convert data to yaml or json
-	if yamlFormat {
-		data, err = yaml.Marshal(obj)
-	} else {
-		data, err = json.MarshalIndent(obj, "", "  ")
-	}
-	if err != nil {
-		data = nil
-	}
-	return
-}
-
-// Convert all objects in objs to versioned objects
-func ConvertToVersion(objs []runtime.Object) ([]runtime.Object, error) {
-	ret := []runtime.Object{}
-
-	for _, obj := range objs {
-
-		objectVersion := obj.GetObjectKind().GroupVersionKind()
-		version := unversioned.GroupVersion{Group: objectVersion.Group, Version: objectVersion.Version}
-		convertedObject, err := api.Scheme.ConvertToVersion(obj, version)
-		if err != nil {
-			return nil, err
-		}
-		ret = append(ret, convertedObject)
-	}
-
-	return ret, nil
-}
-
 func validateFlags(opt kobject.ConvertOptions, singleOutput bool, dabFile, inputFile string) {
 	if len(opt.OutFile) != 0 && opt.ToStdout {
 		logrus.Fatalf("Error: --out and --stdout can't be set at the same time")
@@ -453,19 +252,6 @@ func Convert(c *cli.Context) {
 		file = dabFile
 	}
 
-	// loader parses input from file into komposeObject.
-	var l loader.Loader
-	switch inputFormat {
-	case "bundle":
-		l = new(bundle.Bundle)
-	case "compose":
-		l = new(compose.Compose)
-	default:
-		logrus.Fatalf("Input file format is not supported")
-	}
-
-	komposeObject = l.LoadFile(file)
-
 	opt := kobject.ConvertOptions{
 		ToStdout:               toStdout,
 		CreateD:                createD,
@@ -481,7 +267,20 @@ func Convert(c *cli.Context) {
 
 	validateFlags(opt, singleOutput, dabFile, inputFile)
 
-	// transformer maps komposeObject to provider(K8S, OpenShift) primitives
+	// loader parses input from file into komposeObject.
+	var l loader.Loader
+	switch inputFormat {
+	case "bundle":
+		l = new(bundle.Bundle)
+	case "compose":
+		l = new(compose.Compose)
+	default:
+		logrus.Fatalf("Input file format is not supported")
+	}
+
+	komposeObject = l.LoadFile(file)
+
+	// transformer maps komposeObject to provider's primitives
 	var t transformer.Transformer
 	if !createDeploymentConfig {
 		t = new(kubernetes.Kubernetes)
@@ -489,11 +288,10 @@ func Convert(c *cli.Context) {
 		t = new(openshift.OpenShift)
 	}
 
-	mServices, mDeployments, mDaemonSets, mReplicationControllers, mDeploymentConfigs, svcnames := t.Transform(komposeObject, opt)
+	objects := t.Transform(komposeObject, opt)
 
 	// Print output
-	transformer.PrintControllers(mServices, mDeployments, mDaemonSets, mReplicationControllers, mDeploymentConfigs, svcnames, opt)
-
+	kubernetes.PrintList(objects, opt)
 }
 
 // Up brings up deployment, svc.
@@ -511,52 +309,52 @@ func Up(c *cli.Context) {
 	inputFile := c.String("file")
 	dabFile := c.String("bundle")
 
-	komposeObject := KomposeObject{}
-	opt := convertOptions{
-		replicas: 1,
-		createD:  true,
+	komposeObject := kobject.KomposeObject{
+		ServiceConfigs: make(map[string]kobject.ServiceConfig),
+	}
+
+	file := inputFile
+	if len(dabFile) > 0 {
+		inputFormat = "bundle"
+		file = dabFile
+	}
+
+	opt := kobject.ConvertOptions{
+		Replicas: 1,
+		CreateD:  true,
 	}
 
 	validateFlags(opt, false, dabFile, inputFile)
 
-	if len(dabFile) > 0 {
-		komposeObject = loadBundlesFile(dabFile)
-	} else {
-		komposeObject = loadComposeFile(inputFile)
+	// loader parses input from file into komposeObject.
+	var l loader.Loader
+	switch inputFormat {
+	case "bundle":
+		l = new(bundle.Bundle)
+	case "compose":
+		l = new(compose.Compose)
+	default:
+		logrus.Fatalf("Input file format is not supported")
 	}
+	komposeObject = l.LoadFile(file)
+
+	t := new(kubernetes.Kubernetes)
 
 	//Convert komposeObject to K8S controllers
-	objects := komposeConvert(komposeObject, opt)
-	objects = sortServicesFirst(objects)
+	objects := t.Transform(komposeObject, opt)
+	sortServicesFirst(&objects)
 
-	for _, v := range objects {
-		switch t := v.(type) {
-		case *extensions.Deployment:
-			_, err := client.Deployments(api.NamespaceDefault).Create(t)
-			if err != nil {
-				logrus.Fatalf("Error: '%v' while creating deployment: %s", err, t.Name)
-			}
-			logrus.Infof("Successfully created deployment: %s", t.Name)
-		case *api.Service:
-			_, err := client.Services(api.NamespaceDefault).Create(t)
-			if err != nil {
-				logrus.Fatalf("Error: '%v' while creating service: %s", err, t.Name)
-			}
-			logrus.Infof("Successfully created service: %s", t.Name)
-		}
-	}
-	fmt.Println("\nApplication has been deployed to Kubernetes. You can run 'kubectl get deployment,svc' for details.")
+	//Submit objects to K8s endpoint
+	kubernetes.CreateObjects(client, objects)
 }
 
 // the objects that we get can be in any order this keeps services first
 // according to best practice kubernetes services should be created first
 // http://kubernetes.io/docs/user-guide/config-best-practices/
-func sortServicesFirst(objs []runtime.Object) []runtime.Object {
-	var svc []runtime.Object
-	var others []runtime.Object
-	var ret []runtime.Object
+func sortServicesFirst(objs *[]runtime.Object) {
+	var svc, others, ret []runtime.Object
 
-	for _, obj := range objs {
+	for _, obj := range *objs {
 		if obj.GetObjectKind().GroupVersionKind().Kind == "Service" {
 			svc = append(svc, obj)
 		} else {
@@ -565,5 +363,5 @@ func sortServicesFirst(objs []runtime.Object) []runtime.Object {
 	}
 	ret = append(ret, svc...)
 	ret = append(ret, others...)
-	return ret
+	*objs = ret
 }

cli/app/app_test.go

@@ -19,6 +19,7 @@ package app
 import (
 	"fmt"
 	"testing"
+	"github.com/skippbox/kompose/pkg/transformer"
 )
 
 func TestParseVolume(t *testing.T) {
@@ -99,7 +100,7 @@ func TestParseVolume(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		name, host, container, mode, err := parseVolume(test.volume)
+		name, host, container, mode, err := transformer.ParseVolume(test.volume)
 		if err != nil {
 			t.Errorf("In test case %q, returned unexpected error %v", test.test, err)
 		}