add tiller installation

embark/cmd/embark/main.go

@@ -5,23 +5,21 @@ import (
 	"os"
 	"path"
 
-	"io/ioutil"
-
 	"github.com/containerum/containerum/embark/pkg/builder"
 	"github.com/containerum/containerum/embark/pkg/cli/flags"
 	"github.com/octago/sflags/gen/gpflag"
 	"github.com/spf13/cobra"
-	"gopkg.in/yaml.v2"
-	kubeClientAPI "k8s.io/client-go/tools/clientcmd/api"
+	"k8s.io/client-go/tools/clientcmd"
 )
 
 func main() {
-	if err := cmdDownloadRequirements().Execute(); err != nil {
+	if err := cmdInstall().Execute(); err != nil {
 		fmt.Println(err)
+		return
 	}
 }
 
-func cmdDownloadRequirements() *cobra.Command {
+func cmdInstall() *cobra.Command {
 	var install = flags.Install{}
 	var cmd = &cobra.Command{
 		Use: "embark",
@@ -34,20 +32,16 @@ func cmdDownloadRequirements() *cobra.Command {
 					install.KubeConfig = path.Join(os.Getenv("HOME"), ".kube", "config")
 				}
 			}
-			var kubeConfigData, err = ioutil.ReadFile(install.KubeConfig)
-			if err != nil {
-				fmt.Println(err)
-				os.Exit(1)
-			}
-			var config kubeClientAPI.Config
-			if err := yaml.Unmarshal(kubeConfigData, &config); err != nil {
-				fmt.Println(err)
+			var config, configLoadFilerErr = clientcmd.LoadFromFile(install.KubeConfig)
+			if configLoadFilerErr != nil {
+				fmt.Printf("unable to load kube config from %q: %v\n", install.KubeConfig, configLoadFilerErr)
 				os.Exit(1)
 			}
-			if err := client.InstallTiller(config); err != nil {
+			if _, err := client.InstallTiller(*config); err != nil {
 				fmt.Println(err)
 				os.Exit(1)
 			}
+
 			if install.Host == "" {
 				for _, cluster := range config.Clusters {
 					install.Host = cluster.Server

embark/pkg/builder/tiler_istall.go

@@ -1,8 +1,10 @@
 package builder
 
 import (
-	"github.com/go-yaml/yaml"
 	kubeAppsV1 "k8s.io/api/apps/v1"
+	kubeCoreV1 "k8s.io/api/core/v1"
+	kubeAPIv1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
@@ -16,7 +18,74 @@ type Kube struct {
 }
 
 // goto init()
-var defaulTiler = kubeAppsV1.Deployment{}
+var defaulTiler = kubeAppsV1.Deployment{
+	TypeMeta: kubeAPIv1.TypeMeta{
+		Kind:       "deployment",
+		APIVersion: "extensions/v1beta1",
+	},
+
+	ObjectMeta: kubeAPIv1.ObjectMeta{
+		Name:      "tiller-deploy",
+		Namespace: "kube-system",
+		Labels: map[string]string{
+			"app":  "helm",
+			"name": "tiller",
+		},
+	},
+	Spec: kubeAppsV1.DeploymentSpec{
+		Selector: &kubeAPIv1.LabelSelector{
+			MatchLabels: map[string]string{
+				"app": "helm",
+			},
+		},
+		Replicas: newInt32(1),
+		Template: kubeCoreV1.PodTemplateSpec{
+			ObjectMeta: kubeAPIv1.ObjectMeta{
+				Labels: map[string]string{
+					"app":  "helm",
+					"name": "tiller",
+				},
+			},
+			Spec: kubeCoreV1.PodSpec{
+				Containers: []kubeCoreV1.Container{
+					{
+						Image:           "gcr.io/kubernetes-helm/tiller:v2.9.1",
+						Name:            "tiller",
+						ImagePullPolicy: "IfNotPresent",
+						LivenessProbe: &kubeCoreV1.Probe{
+							InitialDelaySeconds: 1,
+							TimeoutSeconds:      1,
+							Handler: kubeCoreV1.Handler{
+								HTTPGet: &kubeCoreV1.HTTPGetAction{
+									Path: "/liveness",
+									Port: intstr.FromInt(44135),
+								},
+							},
+						},
+						Env: []kubeCoreV1.EnvVar{
+							{Name: "TILLER_NAMESPACE", Value: ""},
+							{Name: "TILLER_HISTORY_MAX", Value: "0"},
+						},
+						Ports: []kubeCoreV1.ContainerPort{
+							{ContainerPort: 44134, Name: "tiller"},
+							{ContainerPort: 44135, Name: "http"},
+						},
+						ReadinessProbe: &kubeCoreV1.Probe{
+							InitialDelaySeconds: 1,
+							TimeoutSeconds:      1,
+							Handler: kubeCoreV1.Handler{
+								HTTPGet: &kubeCoreV1.HTTPGetAction{
+									Path: "/readiness",
+									Port: intstr.FromInt(44135),
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	},
+}
 
 func NewKubeClient(config kubeClientAPI.Config) (*Kube, error) {
 	var kube Kube
@@ -35,15 +104,50 @@ func NewKubeClient(config kubeClientAPI.Config) (*Kube, error) {
 	return &kube, nil
 }
 
-func (client *Client) InstallTiller(config kubeClientAPI.Config) error {
+func (client *Client) InstallTiller(config kubeClientAPI.Config) (port int32, e error) {
 	var kube, err = NewKubeClient(config)
 	if err != nil {
-		return err
+		return 0, ErrUnableToInstallTiler{Prefix: "unable to init kube client", Reason: err}
+	}
+
+	var deployments, fetchDeploymentsListErr = kube.AppsV1().
+		Deployments(defaulTiler.Namespace).List(kubeAPIv1.ListOptions{})
+	if fetchDeploymentsListErr != nil {
+		return 0, fetchDeploymentsListErr
+	}
+	var depl, deploymentAlreadyExists = findDepl(deployments.Items, defaulTiler.Name)
+	if !deploymentAlreadyExists {
+		var d, createTilerErr = kube.AppsV1().
+			Deployments(defaulTiler.Namespace).
+			Create(&defaulTiler)
+		if createTilerErr != nil {
+			return 0, ErrUnableToInstallTiler{Prefix: "unable to create tiller deploy", Reason: createTilerErr}
+		}
+		depl = *d
 	}
-	var _, createTilerErr = kube.AppsV1().
-		Deployments(defaulTiler.Namespace).
-		Create(&defaulTiler)
-	return createTilerErr
+
+	var services, fetchServicesErr = kube.CoreV1().
+		Services(defaulTiler.Namespace).List(kubeAPIv1.ListOptions{})
+	if fetchServicesErr != nil {
+		return 0, fetchServicesErr
+	}
+	var serv, serviceAlreadyExists = findServ(services.Items, defaultTillerService.Name)
+	if !serviceAlreadyExists {
+		if !deploymentAlreadyExists {
+			var port, ok = getFirstPort(depl)
+			if !ok {
+				return 0, ErrUnableToInstallTiler{Prefix: "invalid tiller deployment: no container ports!"}
+			}
+			defaultTillerService.Spec.Ports[0].Port = port
+		}
+		var s, createTillerService = kube.CoreV1().
+			Services(defaulTiler.Namespace).Create(&defaultTillerService)
+		if createTillerService != nil {
+			return 0, ErrUnableToInstallTiler{Prefix: "unable to install tiller service", Reason: createTillerService}
+		}
+		serv = *s
+	}
+	return serv.Spec.Ports[0].Port, nil
 }
 
 func init() {
@@ -94,11 +198,41 @@ spec:
           initialDelaySeconds: 1
           timeoutSeconds: 1
 `
-	if err := yaml.Unmarshal([]byte(paragonTiller), &defaulTiler); err != nil {
-		panic(err)
-	}
+	_ = paragonTiller
+	//if err := yaml.Unmarshal([]byte(paragonTiller), &defaulTiler); err != nil {
+	//	panic(err)
+	//}
+
+	//	fmt.Printf("default Tiller deployment name: %+v\n", defaulTiler)
 }
 
 func newInt32(i int32) *int32 {
 	return &i
 }
+
+func findDepl(list []kubeAppsV1.Deployment, name string) (kubeAppsV1.Deployment, bool) {
+	for _, depl := range list {
+		if depl.Name == name {
+			return *depl.DeepCopy(), true
+		}
+	}
+	return kubeAppsV1.Deployment{}, false
+}
+
+func findServ(list []kubeCoreV1.Service, name string) (kubeCoreV1.Service, bool) {
+	for _, serv := range list {
+		if serv.Name == name {
+			return *serv.DeepCopy(), true
+		}
+	}
+	return kubeCoreV1.Service{}, false
+}
+
+func getFirstPort(depl kubeAppsV1.Deployment) (int32, bool) {
+	for _, container := range depl.Spec.Template.Spec.Containers {
+		for _, p := range container.Ports {
+			return p.ContainerPort, true
+		}
+	}
+	return -1, false
+}

embark/pkg/builder/tiller_service.go

@@ -0,0 +1,33 @@
+package builder
+
+import (
+	kubeCoreV1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/intstr"
+)
+
+var defaultTillerService = kubeCoreV1.Service{
+	TypeMeta: v1.TypeMeta{
+		Kind:       "Service",
+		APIVersion: "v1",
+	},
+	ObjectMeta: v1.ObjectMeta{
+		Name:      "tiller-deploy",
+		Namespace: "kube-system",
+		Labels: map[string]string{
+			"app":  "helm",
+			"name": "tiller",
+		},
+	},
+	Spec: kubeCoreV1.ServiceSpec{
+		Ports: []kubeCoreV1.ServicePort{
+			{Name: "tiller", Port: 44134, Protocol: kubeCoreV1.ProtocolTCP, TargetPort: intstr.FromString("tiller")},
+		},
+		Type:            kubeCoreV1.ServiceTypeClusterIP,
+		SessionAffinity: "None",
+		Selector: map[string]string{
+			"app":  "helm",
+			"name": "tiller",
+		},
+	},
+}