Implement kubectl deployment method

Author: FabianKramm

cmd/up.go

@@ -344,14 +344,14 @@ func (cmd *UpCmd) buildAndDeploy() {
 			var deployClient deploy.Interface
 
 			if deployConfig.Kubectl != nil {
-				log.StartWait("Deploying " + *deployConfig.Name + " with kubectl")
+				log.Info("Deploying " + *deployConfig.Name + " with kubectl")
 
 				deployClient, err = deployKubectl.New(cmd.kubectl, deployConfig, log.GetInstance())
 				if err != nil {
 					log.Fatalf("Error deploying devspace: deployment %s error: %v", *deployConfig.Name, err)
 				}
 			} else if deployConfig.Helm != nil {
-				log.StartWait("Deploying " + *deployConfig.Name + " with helm")
+				log.Info("Deploying " + *deployConfig.Name + " with helm")
 
 				deployClient, err = deployHelm.New(cmd.kubectl, deployConfig, log.GetInstance())
 				if err != nil {
@@ -366,7 +366,6 @@ func (cmd *UpCmd) buildAndDeploy() {
 				log.Fatalf("Error deploying %s: %v", *deployConfig.Name, err)
 			}
 
-			log.StopWait()
 			log.Donef("Successfully deployed %s", *deployConfig.Name)
 		}
 

pkg/devspace/deploy/kubectl/kubectl.go

@@ -2,7 +2,8 @@ package kubectl
 
 import (
 	"errors"
-	"path/filepath"
+	"os/exec"
+	"strings"
 
 	"k8s.io/client-go/kubernetes"
 
@@ -11,7 +12,6 @@ import (
 
 	"github.com/covexo/devspace/pkg/devspace/config/v1"
 	"github.com/covexo/devspace/pkg/util/log"
-	"github.com/covexo/devspace/pkg/util/yamlutil"
 )
 
 // DeployConfig holds the necessary information for kubectl deployment
@@ -67,55 +67,98 @@ func New(kubectl *kubernetes.Clientset, deployConfig *v1.DeploymentConfig, log l
 
 // Status prints the status of all matched manifests from kubernetes
 func (d *DeployConfig) Status() ([][]string, error) {
-	return nil, nil
+	// TODO: parse kubectl get output into the required string array
+	return [][]string{}, nil
 }
 
 // Delete deletes all matched manifests from kubernetes
 func (d *DeployConfig) Delete() error {
-	return nil
+	manifests, err := loadManifests(d.Manifests, d.Log)
+	if err != nil {
+		return err
+	}
+
+	joinedManifests, err := joinManifests(manifests)
+	if err != nil {
+		return err
+	}
+
+	stringReader := strings.NewReader(joinedManifests)
+	args := d.getCmdArgs("delete", "--ignore-not-found=true")
+
+	cmd := exec.Command(d.CmdPath, args...)
+
+	cmd.Stdin = stringReader
+	cmd.Stdout = d.Log
+	cmd.Stderr = d.Log
+
+	return cmd.Run()
 }
 
 // Deploy deploys all specified manifests via kubectl apply and adds to the specified image names the corresponding tags
 func (d *DeployConfig) Deploy(generatedConfig *generated.Config, forceDeploy bool) error {
-	return nil
-}
+	manifests, err := loadManifests(d.Manifests, d.Log)
+	if err != nil {
+		return err
+	}
 
-func (d *DeployConfig) internalDeploy(images []string, tags map[string]string) error {
-	for _, pattern := range d.Manifests {
-		files, err := filepath.Glob(pattern)
-		if err != nil {
-			return err
-		}
+	for _, manifest := range manifests {
+		replaceManifest(manifest, generatedConfig.ImageTags)
+	}
 
-		for _, file := range files {
-			err = applyFile(d.Context, file, d.Namespace, images, tags)
-			if err != nil {
-				return err
-			}
-		}
+	joinedManifests, err := joinManifests(manifests)
+	if err != nil {
+		return err
 	}
 
-	return nil
+	stringReader := strings.NewReader(joinedManifests)
+	args := d.getCmdArgs("apply", "--force")
+
+	cmd := exec.Command(d.CmdPath, args...)
+
+	cmd.Stdin = stringReader
+	cmd.Stdout = d.Log
+	cmd.Stderr = d.Log
+
+	return cmd.Run()
 }
 
-func applyFile(context, file, namespace string, images []string, tags map[string]string) error {
-	y := make(map[interface{}]interface{})
-	yamlutil.ReadYamlFromFile(file, y)
+func (d *DeployConfig) getCmdArgs(method string, additionalArgs ...string) []string {
+	args := []string{}
 
+	if d.Namespace != "" {
+		args = append(args, "-n", d.Namespace)
+	}
+
+	if d.Context != "" {
+		args = append(args, "--context", d.Context)
+	}
+
+	args = append(args, method)
+
+	if additionalArgs != nil {
+		args = append(args, additionalArgs...)
+	}
+
+	args = append(args, "-f", "-")
+
+	return args
+}
+
+func replaceManifest(manifest Manifest, tags map[string]string) {
 	match := func(key, value string) bool {
+		if key == "image" {
+			if _, ok := tags[value]; ok {
+				return true
+			}
+		}
+
 		return false
 	}
 
 	replace := func(value string) string {
-		return ""
+		return value + ":" + tags[value]
 	}
 
-	Walk(y, match, replace)
-
-	//changedManifest, err := yaml.Marshal(y)
-	//if err != nil {
-	//	return err
-	//}
-
-	return nil
+	Walk(manifest, match, replace)
 }

pkg/devspace/deploy/kubectl/manifests.go

@@ -0,0 +1,89 @@
+package kubectl
+
+import (
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+
+	"github.com/covexo/devspace/pkg/util/log"
+
+	yaml "gopkg.in/yaml.v2"
+)
+
+// Manifest is the type that holds the data of a single kubernetes manifest
+type Manifest map[interface{}]interface{}
+
+func joinManifests(manifests []Manifest) (string, error) {
+	retString := ""
+
+	for _, manifest := range manifests {
+		out, err := yaml.Marshal(manifest)
+		if err != nil {
+			return "", nil
+		}
+
+		if retString != "" {
+			retString += "\n---\n"
+		}
+
+		retString += string(out)
+	}
+
+	return retString, nil
+}
+
+func loadManifests(globPatterns []string, log log.Logger) ([]Manifest, error) {
+	manifests := []Manifest{}
+
+	for _, pattern := range globPatterns {
+		files, err := filepath.Glob(pattern)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, file := range files {
+			if isValidFile(file) {
+				loadedManifests, err := getManifestsFromFile(file)
+				if err != nil {
+					return nil, err
+				}
+
+				manifests = append(manifests, loadedManifests...)
+			} else {
+				log.Warnf("Manifest %s skipped because it does not have a valid ending (.yml or .yaml expected)", file)
+			}
+		}
+	}
+
+	return manifests, nil
+}
+
+func isValidFile(filepath string) bool {
+	return strings.HasSuffix(filepath, ".yml") || strings.HasSuffix(filepath, ".yaml")
+}
+
+func getManifestsFromFile(filepath string) ([]Manifest, error) {
+	data, err := ioutil.ReadFile(filepath)
+	if err != nil {
+		return nil, err
+	}
+
+	retManifests := []Manifest{}
+	manifests := strings.Split(string(data), "\n---")
+
+	for _, manifest := range manifests {
+		manifest = strings.TrimLeft(manifest, "\r\n")
+		manifest = strings.TrimRight(manifest, "\r\n")
+
+		manifestData := Manifest{}
+
+		err = yaml.Unmarshal([]byte(manifest), manifestData)
+		if err != nil {
+			return nil, err
+		}
+
+		retManifests = append(retManifests, manifestData)
+	}
+
+	return retManifests, nil
+}