kubernetes: Add provider + namespace resource

builtin/providers/kubernetes/provider.go

@@ -0,0 +1,171 @@
+package kubernetes
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/hashicorp/terraform/terraform"
+	"github.com/mitchellh/go-homedir"
+	kubernetes "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
+	"k8s.io/kubernetes/pkg/client/restclient"
+	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
+	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
+)
+
+func Provider() terraform.ResourceProvider {
+	return &schema.Provider{
+		Schema: map[string]*schema.Schema{
+			"host": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				DefaultFunc: schema.EnvDefaultFunc("KUBE_HOST", ""),
+				Description: "The hostname (in form of URI) of Kubernetes master.",
+			},
+			"username": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				DefaultFunc: schema.EnvDefaultFunc("KUBE_USER", ""),
+				Description: "The username to use for HTTP basic authentication when accessing the Kubernetes master endpoint.",
+			},
+			"password": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				DefaultFunc: schema.EnvDefaultFunc("KUBE_PASSWORD", ""),
+				Description: "The password to use for HTTP basic authentication when accessing the Kubernetes master endpoint.",
+			},
+			"insecure": {
+				Type:        schema.TypeBool,
+				Optional:    true,
+				DefaultFunc: schema.EnvDefaultFunc("KUBE_INSECURE", false),
+				Description: "Whether server should be accessed without verifying the TLS certificate.",
+			},
+			"client_certificate": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				DefaultFunc: schema.EnvDefaultFunc("KUBE_CLIENT_CERT_DATA", ""),
+				Description: "PEM-encoded client certificate for TLS authentication.",
+			},
+			"client_key": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				DefaultFunc: schema.EnvDefaultFunc("KUBE_CLIENT_KEY_DATA", ""),
+				Description: "PEM-encoded client certificate key for TLS authentication.",
+			},
+			"cluster_ca_certificate": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				DefaultFunc: schema.EnvDefaultFunc("KUBE_CLUSTER_CA_CERT_DATA", ""),
+				Description: "PEM-encoded root certificates bundle for TLS authentication.",
+			},
+			"config_path": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				DefaultFunc: schema.EnvDefaultFunc("KUBE_CONFIG", "~/.kube/config"),
+				Description: "Path to the kube config file, defaults to ~/.kube/config",
+			},
+			"config_context_auth_info": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				DefaultFunc: schema.EnvDefaultFunc("KUBE_CTX_AUTH_INFO", ""),
+				Description: "",
+			},
+			"config_context_cluster": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				DefaultFunc: schema.EnvDefaultFunc("KUBE_CTX_CLUSTER", ""),
+				Description: "",
+			},
+		},
+
+		ResourcesMap: map[string]*schema.Resource{
+			"kubernetes_namespace": resourceKubernetesNamespace(),
+		},
+		ConfigureFunc: providerConfigure,
+	}
+}
+
+func providerConfigure(d *schema.ResourceData) (interface{}, error) {
+	// Config file loading
+	cfg, err := tryLoadingConfigFile(d)
+	if err != nil {
+		return nil, err
+	}
+	if cfg == nil {
+		cfg = &restclient.Config{}
+	}
+
+	// Overriding with static configuration
+	cfg.UserAgent = fmt.Sprintf("HashiCorp/1.0 Terraform/%s", terraform.VersionString())
+
+	if v, ok := d.GetOk("host"); ok {
+		cfg.Host = v.(string)
+	}
+	if v, ok := d.GetOk("username"); ok {
+		cfg.Username = v.(string)
+	}
+	if v, ok := d.GetOk("password"); ok {
+		cfg.Password = v.(string)
+	}
+	if v, ok := d.GetOk("insecure"); ok {
+		cfg.Insecure = v.(bool)
+	}
+	if v, ok := d.GetOk("cluster_ca_certificate"); ok {
+		cfg.CAData = bytes.NewBufferString(v.(string)).Bytes()
+	}
+	if v, ok := d.GetOk("client_certificate"); ok {
+		cfg.CertData = bytes.NewBufferString(v.(string)).Bytes()
+	}
+	if v, ok := d.GetOk("client_key"); ok {
+		cfg.KeyData = bytes.NewBufferString(v.(string)).Bytes()
+	}
+
+	k, err := kubernetes.NewForConfig(cfg)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to configure: %s", err)
+	}
+
+	return k, nil
+}
+
+func tryLoadingConfigFile(d *schema.ResourceData) (*restclient.Config, error) {
+	path, err := homedir.Expand(d.Get("config_path").(string))
+	if err != nil {
+		return nil, err
+	}
+
+	loader := &clientcmd.ClientConfigLoadingRules{
+		ExplicitPath: path,
+	}
+	overrides := &clientcmd.ConfigOverrides{}
+	ctxSuffix := "; no context"
+	authInfo, authInfoOk := d.GetOk("config_context_auth_info")
+	cluster, clusterOk := d.GetOk("config_context_cluster")
+	if authInfoOk || clusterOk {
+		overrides.Context = clientcmdapi.Context{}
+		if authInfoOk {
+			overrides.Context.AuthInfo = authInfo.(string)
+		}
+		if clusterOk {
+			overrides.Context.Cluster = cluster.(string)
+		}
+		ctxSuffix = fmt.Sprintf("; auth_info: %s, cluster: %s",
+			overrides.Context.AuthInfo, overrides.Context.Cluster)
+	}
+	log.Printf("[DEBUG] Using override context: %#v", *overrides)
+
+	cc := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loader, overrides)
+	cfg, err := cc.ClientConfig()
+	if err != nil {
+		if pathErr, ok := err.(*os.PathError); ok && os.IsNotExist(pathErr.Err) {
+			log.Printf("[INFO] Unable to load config file as it doesn't exist at %q", path)
+			return nil, nil
+		}
+		return nil, fmt.Errorf("Failed to load config (%s%s): %s", path, ctxSuffix, err)
+	}
+
+	log.Printf("[INFO] Successfully loaded config file (%s%s)", path, ctxSuffix)
+	return cfg, nil
+}

builtin/providers/kubernetes/provider_test.go

@@ -0,0 +1,53 @@
+package kubernetes
+
+import (
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+var testAccProviders map[string]terraform.ResourceProvider
+var testAccProvider *schema.Provider
+
+func init() {
+	testAccProvider = Provider().(*schema.Provider)
+	testAccProviders = map[string]terraform.ResourceProvider{
+		"kubernetes": testAccProvider,
+	}
+}
+
+func TestProvider(t *testing.T) {
+	if err := Provider().(*schema.Provider).InternalValidate(); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+}
+
+func TestProvider_impl(t *testing.T) {
+	var _ terraform.ResourceProvider = Provider()
+}
+
+func testAccPreCheck(t *testing.T) {
+	hasFileCfg := (os.Getenv("KUBE_CTX_AUTH_INFO") != "" && os.Getenv("KUBE_CTX_CLUSTER") != "")
+	hasStaticCfg := (os.Getenv("KUBE_HOST") != "" &&
+		os.Getenv("KUBE_USER") != "" &&
+		os.Getenv("KUBE_PASSWORD") != "" &&
+		os.Getenv("KUBE_CLIENT_CERT_DATA") != "" &&
+		os.Getenv("KUBE_CLIENT_KEY_DATA") != "" &&
+		os.Getenv("KUBE_CLUSTER_CA_CERT_DATA") != "")
+
+	if !hasFileCfg && !hasStaticCfg {
+		t.Fatalf("File config (KUBE_CTX_AUTH_INFO and KUBE_CTX_CLUSTER) or static configuration"+
+			" (%s) must be set for acceptance tests",
+			strings.Join([]string{
+				"KUBE_HOST",
+				"KUBE_USER",
+				"KUBE_PASSWORD",
+				"KUBE_CLIENT_CERT_DATA",
+				"KUBE_CLIENT_KEY_DATA",
+				"KUBE_CLUSTER_CA_CERT_DATA",
+			}, ", "))
+	}
+}

builtin/providers/kubernetes/resource_kubernetes_namespace.go

@@ -0,0 +1,143 @@
+package kubernetes
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/helper/schema"
+	"k8s.io/kubernetes/pkg/api/errors"
+	api "k8s.io/kubernetes/pkg/api/v1"
+	kubernetes "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
+)
+
+func resourceKubernetesNamespace() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceKubernetesNamespaceCreate,
+		Read:   resourceKubernetesNamespaceRead,
+		Exists: resourceKubernetesNamespaceExists,
+		Update: resourceKubernetesNamespaceUpdate,
+		Delete: resourceKubernetesNamespaceDelete,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"metadata": metadataSchema("namespace"),
+		},
+	}
+}
+
+func resourceKubernetesNamespaceCreate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*kubernetes.Clientset)
+
+	metadata := expandMetadata(d.Get("metadata").([]interface{}))
+	namespace := api.Namespace{
+		ObjectMeta: metadata,
+	}
+	log.Printf("[INFO] Creating new namespace: %#v", namespace)
+	out, err := conn.CoreV1().Namespaces().Create(&namespace)
+	if err != nil {
+		return err
+	}
+	log.Printf("[INFO] Submitted new namespace: %#v", out)
+	d.SetId(out.Name)
+
+	return resourceKubernetesNamespaceRead(d, meta)
+}
+
+func resourceKubernetesNamespaceRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*kubernetes.Clientset)
+
+	name := d.Id()
+	log.Printf("[INFO] Reading namespace %s", name)
+	namespace, err := conn.CoreV1().Namespaces().Get(name)
+	if err != nil {
+		log.Printf("[DEBUG] Received error: %#v", err)
+		return err
+	}
+	log.Printf("[INFO] Received namespace: %#v", namespace)
+	err = d.Set("metadata", flattenMetadata(namespace.ObjectMeta))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func resourceKubernetesNamespaceUpdate(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*kubernetes.Clientset)
+
+	metadata := expandMetadata(d.Get("metadata").([]interface{}))
+	// This is necessary in case the name is generated
+	metadata.Name = d.Id()
+
+	namespace := api.Namespace{
+		ObjectMeta: metadata,
+	}
+	log.Printf("[INFO] Updating namespace: %#v", namespace)
+	out, err := conn.CoreV1().Namespaces().Update(&namespace)
+	if err != nil {
+		return err
+	}
+	log.Printf("[INFO] Submitted updated namespace: %#v", out)
+	d.SetId(out.Name)
+
+	return resourceKubernetesNamespaceRead(d, meta)
+}
+
+func resourceKubernetesNamespaceDelete(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*kubernetes.Clientset)
+
+	name := d.Id()
+	log.Printf("[INFO] Deleting namespace: %#v", name)
+	err := conn.CoreV1().Namespaces().Delete(name, &api.DeleteOptions{})
+	if err != nil {
+		return err
+	}
+
+	stateConf := &resource.StateChangeConf{
+		Target:  []string{},
+		Pending: []string{"Terminating"},
+		Timeout: 5 * time.Minute,
+		Refresh: func() (interface{}, string, error) {
+			out, err := conn.CoreV1().Namespaces().Get(name)
+			if err != nil {
+				if statusErr, ok := err.(*errors.StatusError); ok && statusErr.ErrStatus.Code == 404 {
+					return nil, "", nil
+				}
+				log.Printf("[ERROR] Received error: %#v", err)
+				return out, "Error", err
+			}
+
+			statusPhase := fmt.Sprintf("%v", out.Status.Phase)
+			log.Printf("[DEBUG] Namespace %s status received: %#v", out.Name, statusPhase)
+			return out, statusPhase, nil
+		},
+	}
+	_, err = stateConf.WaitForState()
+	if err != nil {
+		return err
+	}
+	log.Printf("[INFO] Namespace %s deleted", name)
+
+	d.SetId("")
+	return nil
+}
+
+func resourceKubernetesNamespaceExists(d *schema.ResourceData, meta interface{}) (bool, error) {
+	conn := meta.(*kubernetes.Clientset)
+
+	name := d.Id()
+	log.Printf("[INFO] Checking namespace %s", name)
+	_, err := conn.CoreV1().Namespaces().Get(name)
+	if err != nil {
+		if statusErr, ok := err.(*errors.StatusError); ok && statusErr.ErrStatus.Code == 404 {
+			return false, nil
+		}
+		log.Printf("[DEBUG] Received error: %#v", err)
+	}
+	log.Printf("[INFO] Namespace %s exists", name)
+	return true, err
+}