Adds --distribution flag, refactor k8s generation

This commit adds the --distribution flag as well as refactors the
generate.go file to one single file, kubernetes.go.

This allows for all future changes to simply be made within
kubernetes.go rather than two separate files with similar code
(generate.go + kubernetes.go)

cmd/apply.go

@@ -43,7 +43,7 @@ var applyCmd = &cobra.Command{
 			kubectlCommand = append(kubectlCommand, "--namespace", Namespace)
 		}
 
-		if err := pkgcmd.ExecuteKubectl(InputFiles, kubectlCommand...); err != nil {
+		if err := pkgcmd.CreateKubernetesArtifacts(InputFiles, false, kubectlCommand...); err != nil {
 			fmt.Println(err)
 			os.Exit(-1)
 		}

cmd/create.go

@@ -42,7 +42,7 @@ var createCmd = &cobra.Command{
 			kubectlCommand = append(kubectlCommand, "--namespace", Namespace)
 		}
 
-		if err := pkgcmd.ExecuteKubectl(InputFiles, kubectlCommand...); err != nil {
+		if err := pkgcmd.CreateKubernetesArtifacts(InputFiles, false, kubectlCommand...); err != nil {
 			fmt.Println(err)
 			os.Exit(-1)
 		}

cmd/delete.go

@@ -42,7 +42,7 @@ var deleteCmd = &cobra.Command{
 			kubectlCommand = append(kubectlCommand, "--namespace", Namespace)
 		}
 
-		if err := pkgcmd.ExecuteKubectl(InputFiles, kubectlCommand...); err != nil {
+		if err := pkgcmd.CreateKubernetesArtifacts(InputFiles, false, kubectlCommand...); err != nil {
 			fmt.Println(err)
 			os.Exit(-1)
 		}

cmd/generate.go

@@ -33,7 +33,7 @@ var generateCmd = &cobra.Command{
 			fmt.Println(err)
 			os.Exit(-1)
 		}
-		if err := pkgcmd.Generate(InputFiles); err != nil {
+		if err := pkgcmd.CreateKubernetesArtifacts(InputFiles, true, ""); err != nil {
 			fmt.Println(err)
 			os.Exit(-1)
 		}

cmd/root.go

@@ -19,14 +19,16 @@ package cmd
 import (
 	"fmt"
 	"os"
+	"strings"
 
 	log "github.com/Sirupsen/logrus"
 	"github.com/spf13/cobra"
 )
 
 // Global variables
 var (
-	GlobalVerbose bool
+	GlobalVerbose  bool
+	GlobalProvider string
 )
 
 // RootCmd represents the base command when called without any subcommands
@@ -40,6 +42,12 @@ var RootCmd = &cobra.Command{
 			log.SetLevel(log.DebugLevel)
 		}
 
+		// Error out of the user has not chosen Kubernetes or OpenShift
+		provider := strings.ToLower(GlobalProvider)
+		if provider != "kubernetes" && provider != "openshift" {
+			log.Fatalf("%s is an unsupported provider. Supported providers are: 'kubernetes', 'openshift'.", GlobalProvider)
+		}
+
 	},
 }
 
@@ -53,4 +61,5 @@ func Execute() {
 // Initialize all flags
 func init() {
 	RootCmd.PersistentFlags().BoolVarP(&GlobalVerbose, "verbose", "v", false, "verbose output")
+	RootCmd.PersistentFlags().StringVar(&GlobalProvider, "provider", "kubernetes", "Specify a provider. Kubernetes or OpenShift.")
 }

pkg/cmd/kubernetes.go

@@ -19,15 +19,20 @@ package cmd
 import (
 	"fmt"
 	"io"
+	"io/ioutil"
+	"os"
 	"os/exec"
+	"path/filepath"
 
 	"github.com/kedgeproject/kedge/pkg/spec"
 
 	"github.com/ghodss/yaml"
 	"github.com/pkg/errors"
 )
 
-func ExecuteKubectl(paths []string, args ...string) error {
+// Generate Kubernetes Artifacts and either writes to file
+// or uses kubectl to deploy.
+func CreateKubernetesArtifacts(paths []string, generate bool, args ...string) error {
 
 	files, err := GetAllYAMLFiles(paths)
 	if err != nil {
@@ -46,38 +51,61 @@ func ExecuteKubectl(paths []string, args ...string) error {
 			return errors.Wrap(err, "unable to perform controller operations")
 		}
 
-		for _, o := range ros {
-			data, err := yaml.Marshal(o)
+		for _, runtimeObject := range ros {
+
+			// Unmarshal said object
+			data, err := yaml.Marshal(runtimeObject)
 			if err != nil {
 				return errors.Wrap(err, "failed to marshal object")
 			}
-			// We need to add "-f -" at the end of the command passed to us to
-			// pass the generated files.
-			// e.g. If the command and arguments are "apply --namespace staging", then the
-			// final command becomes "kubectl apply --namespace staging -f -"
-			arguments := append(args, "-f", "-")
-			err = runKubectl(arguments, data)
-			if err != nil {
-				return errors.Wrap(err, "kubectl error")
+
+			// Write to file if generate = true
+			if generate {
+				err = writeObject(data)
+				if err != nil {
+					return errors.Wrap(err, "failed to write object")
+				}
+			} else {
+				// We need to add "-f -" at the end of the command passed to us to
+				// pass the generated files.
+				// e.g. If the command and arguments are "apply --namespace staging", then the
+				// final command becomes "kubectl apply --namespace staging -f -"
+				arguments := append(args, "-f", "-")
+				err = runKubectl(arguments, data)
+				if err != nil {
+					return errors.Wrap(err, "kubectl error")
+				}
 			}
+
 		}
 
 		for _, file := range extraResources {
 			// change the file name to absolute file name
 			file = findAbsPath(input.fileName, file)
 
-			// We need to add "-f absolute-filename" at the end of the command passed to us to
-			// pass the generated files.
-			// e.g. If the command and arguments are "apply --namespace staging", then the
-			// final command becomes "kubectl apply --namespace staging -f absolute-filename"
-			arguments := append(args, "-f", file)
-			err = runKubectl(arguments, nil)
-			if err != nil {
-				return errors.Wrap(err, "kubectl error")
+			if generate {
+				data, err := ioutil.ReadFile(file)
+				if err != nil {
+					return errors.Wrap(err, "file reading failed")
+				}
+				err = writeObject(data)
+				if err != nil {
+					return errors.Wrap(err, "failed to write object")
+				}
+			} else {
+
+				// We need to add "-f absolute-filename" at the end of the command passed to us to
+				// pass the generated files.
+				// e.g. If the command and arguments are "apply --namespace staging", then the
+				// final command becomes "kubectl apply --namespace staging -f absolute-filename"
+				arguments := append(args, "-f", file)
+				err = runKubectl(arguments, nil)
+				if err != nil {
+					return errors.Wrap(err, "kubectl error")
+				}
 			}
 		}
 	}
-
 	return nil
 }
 
@@ -105,3 +133,25 @@ func runKubectl(args []string, data []byte) error {
 	fmt.Printf("%s", string(out))
 	return nil
 }
+
+func writeObject(data []byte) error {
+	_, err := fmt.Fprintln(os.Stdout, "---")
+	if err != nil {
+		return errors.Wrap(err, "could not print to STDOUT")
+	}
+
+	_, err = os.Stdout.Write(data)
+	return errors.Wrap(err, "could not write to STDOUT")
+}
+
+func findAbsPath(baseFilePath, path string) string {
+	// TODO: if the baseFilePath is empty then just take the
+	// pwd as basefilePath, here we will force user to
+	// use the kedge binary from the directory that has files
+	// otherwise there is no way of knowing where the files will be
+	// this condition will happen when we add support for reading from the stdin
+	if filepath.IsAbs(path) {
+		return path
+	}
+	return filepath.Join(filepath.Dir(baseFilePath), path)
+}

pkg/cmd/kubernetes_test.go

@@ -0,0 +1,46 @@
+/*
+Copyright 2017 The Kedge Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package cmd
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func TestWriteObject(t *testing.T) {
+
+	err := writeObject([]byte("foobar"))
+	if err != nil {
+		t.Fatalf("Error FindAbsPath: %s", err)
+	}
+
+}
+
+func TestFindAbsPath(t *testing.T) {
+	tmpDir, err := ioutil.TempDir("", "absPathTest")
+	if err != nil {
+		t.Fatal("creating temp dir:", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	path := findAbsPath("", tmpDir)
+
+	if path != tmpDir {
+		t.Fatal("Error getting correct absolute path")
+	}
+}