github.com/cbroglie/terraform@v0.7.0-rc3.0.20170410193827-735dfc416d46/builtin/providers/kubernetes/provider.go (about)

     1  package kubernetes
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"log"
     7  	"os"
     8  
     9  	"github.com/hashicorp/terraform/helper/schema"
    10  	"github.com/hashicorp/terraform/terraform"
    11  	"github.com/mitchellh/go-homedir"
    12  	kubernetes "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
    13  	"k8s.io/kubernetes/pkg/client/restclient"
    14  	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
    15  	clientcmdapi "k8s.io/kubernetes/pkg/client/unversioned/clientcmd/api"
    16  )
    17  
    18  func Provider() terraform.ResourceProvider {
    19  	return &schema.Provider{
    20  		Schema: map[string]*schema.Schema{
    21  			"host": {
    22  				Type:        schema.TypeString,
    23  				Optional:    true,
    24  				DefaultFunc: schema.EnvDefaultFunc("KUBE_HOST", ""),
    25  				Description: "The hostname (in form of URI) of Kubernetes master.",
    26  			},
    27  			"username": {
    28  				Type:        schema.TypeString,
    29  				Optional:    true,
    30  				DefaultFunc: schema.EnvDefaultFunc("KUBE_USER", ""),
    31  				Description: "The username to use for HTTP basic authentication when accessing the Kubernetes master endpoint.",
    32  			},
    33  			"password": {
    34  				Type:        schema.TypeString,
    35  				Optional:    true,
    36  				DefaultFunc: schema.EnvDefaultFunc("KUBE_PASSWORD", ""),
    37  				Description: "The password to use for HTTP basic authentication when accessing the Kubernetes master endpoint.",
    38  			},
    39  			"insecure": {
    40  				Type:        schema.TypeBool,
    41  				Optional:    true,
    42  				DefaultFunc: schema.EnvDefaultFunc("KUBE_INSECURE", false),
    43  				Description: "Whether server should be accessed without verifying the TLS certificate.",
    44  			},
    45  			"client_certificate": {
    46  				Type:        schema.TypeString,
    47  				Optional:    true,
    48  				DefaultFunc: schema.EnvDefaultFunc("KUBE_CLIENT_CERT_DATA", ""),
    49  				Description: "PEM-encoded client certificate for TLS authentication.",
    50  			},
    51  			"client_key": {
    52  				Type:        schema.TypeString,
    53  				Optional:    true,
    54  				DefaultFunc: schema.EnvDefaultFunc("KUBE_CLIENT_KEY_DATA", ""),
    55  				Description: "PEM-encoded client certificate key for TLS authentication.",
    56  			},
    57  			"cluster_ca_certificate": {
    58  				Type:        schema.TypeString,
    59  				Optional:    true,
    60  				DefaultFunc: schema.EnvDefaultFunc("KUBE_CLUSTER_CA_CERT_DATA", ""),
    61  				Description: "PEM-encoded root certificates bundle for TLS authentication.",
    62  			},
    63  			"config_path": {
    64  				Type:        schema.TypeString,
    65  				Optional:    true,
    66  				DefaultFunc: schema.EnvDefaultFunc("KUBE_CONFIG", "~/.kube/config"),
    67  				Description: "Path to the kube config file, defaults to ~/.kube/config",
    68  			},
    69  			"config_context": {
    70  				Type:        schema.TypeString,
    71  				Optional:    true,
    72  				DefaultFunc: schema.EnvDefaultFunc("KUBE_CTX", ""),
    73  			},
    74  			"config_context_auth_info": {
    75  				Type:        schema.TypeString,
    76  				Optional:    true,
    77  				DefaultFunc: schema.EnvDefaultFunc("KUBE_CTX_AUTH_INFO", ""),
    78  				Description: "",
    79  			},
    80  			"config_context_cluster": {
    81  				Type:        schema.TypeString,
    82  				Optional:    true,
    83  				DefaultFunc: schema.EnvDefaultFunc("KUBE_CTX_CLUSTER", ""),
    84  				Description: "",
    85  			},
    86  		},
    87  
    88  		ResourcesMap: map[string]*schema.Resource{
    89  			"kubernetes_config_map": resourceKubernetesConfigMap(),
    90  			"kubernetes_namespace":  resourceKubernetesNamespace(),
    91  			"kubernetes_secret":     resourceKubernetesSecret(),
    92  		},
    93  		ConfigureFunc: providerConfigure,
    94  	}
    95  }
    96  
    97  func providerConfigure(d *schema.ResourceData) (interface{}, error) {
    98  	// Config file loading
    99  	cfg, err := tryLoadingConfigFile(d)
   100  	if err != nil {
   101  		return nil, err
   102  	}
   103  	if cfg == nil {
   104  		cfg = &restclient.Config{}
   105  	}
   106  
   107  	// Overriding with static configuration
   108  	cfg.UserAgent = fmt.Sprintf("HashiCorp/1.0 Terraform/%s", terraform.VersionString())
   109  
   110  	if v, ok := d.GetOk("host"); ok {
   111  		cfg.Host = v.(string)
   112  	}
   113  	if v, ok := d.GetOk("username"); ok {
   114  		cfg.Username = v.(string)
   115  	}
   116  	if v, ok := d.GetOk("password"); ok {
   117  		cfg.Password = v.(string)
   118  	}
   119  	if v, ok := d.GetOk("insecure"); ok {
   120  		cfg.Insecure = v.(bool)
   121  	}
   122  	if v, ok := d.GetOk("cluster_ca_certificate"); ok {
   123  		cfg.CAData = bytes.NewBufferString(v.(string)).Bytes()
   124  	}
   125  	if v, ok := d.GetOk("client_certificate"); ok {
   126  		cfg.CertData = bytes.NewBufferString(v.(string)).Bytes()
   127  	}
   128  	if v, ok := d.GetOk("client_key"); ok {
   129  		cfg.KeyData = bytes.NewBufferString(v.(string)).Bytes()
   130  	}
   131  
   132  	k, err := kubernetes.NewForConfig(cfg)
   133  	if err != nil {
   134  		return nil, fmt.Errorf("Failed to configure: %s", err)
   135  	}
   136  
   137  	return k, nil
   138  }
   139  
   140  func tryLoadingConfigFile(d *schema.ResourceData) (*restclient.Config, error) {
   141  	path, err := homedir.Expand(d.Get("config_path").(string))
   142  	if err != nil {
   143  		return nil, err
   144  	}
   145  
   146  	loader := &clientcmd.ClientConfigLoadingRules{
   147  		ExplicitPath: path,
   148  	}
   149  
   150  	overrides := &clientcmd.ConfigOverrides{}
   151  	ctxSuffix := "; default context"
   152  
   153  	ctx, ctxOk := d.GetOk("config_context")
   154  	authInfo, authInfoOk := d.GetOk("config_context_auth_info")
   155  	cluster, clusterOk := d.GetOk("config_context_cluster")
   156  	if ctxOk || authInfoOk || clusterOk {
   157  		ctxSuffix = "; overriden context"
   158  		if ctxOk {
   159  			overrides.CurrentContext = ctx.(string)
   160  			ctxSuffix += fmt.Sprintf("; config ctx: %s", overrides.CurrentContext)
   161  			log.Printf("[DEBUG] Using custom current context: %q", overrides.CurrentContext)
   162  		}
   163  
   164  		overrides.Context = clientcmdapi.Context{}
   165  		if authInfoOk {
   166  			overrides.Context.AuthInfo = authInfo.(string)
   167  			ctxSuffix += fmt.Sprintf("; auth_info: %s", overrides.Context.AuthInfo)
   168  		}
   169  		if clusterOk {
   170  			overrides.Context.Cluster = cluster.(string)
   171  			ctxSuffix += fmt.Sprintf("; cluster: %s", overrides.Context.Cluster)
   172  		}
   173  		log.Printf("[DEBUG] Using overidden context: %#v", overrides.Context)
   174  	}
   175  
   176  	cc := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loader, overrides)
   177  	cfg, err := cc.ClientConfig()
   178  	if err != nil {
   179  		if pathErr, ok := err.(*os.PathError); ok && os.IsNotExist(pathErr.Err) {
   180  			log.Printf("[INFO] Unable to load config file as it doesn't exist at %q", path)
   181  			return nil, nil
   182  		}
   183  		return nil, fmt.Errorf("Failed to load config (%s%s): %s", path, ctxSuffix, err)
   184  	}
   185  
   186  	log.Printf("[INFO] Successfully loaded config file (%s%s)", path, ctxSuffix)
   187  	return cfg, nil
   188  }