github.com/sixgill/terraform@v0.9.0-beta2.0.20170316214032-033f6226ae50/builtin/providers/kubernetes/resource_kubernetes_namespace.go (about)

     1  package kubernetes
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"time"
     7  
     8  	"github.com/hashicorp/terraform/helper/resource"
     9  	"github.com/hashicorp/terraform/helper/schema"
    10  	"k8s.io/kubernetes/pkg/api/errors"
    11  	api "k8s.io/kubernetes/pkg/api/v1"
    12  	kubernetes "k8s.io/kubernetes/pkg/client/clientset_generated/release_1_5"
    13  )
    14  
    15  func resourceKubernetesNamespace() *schema.Resource {
    16  	return &schema.Resource{
    17  		Create: resourceKubernetesNamespaceCreate,
    18  		Read:   resourceKubernetesNamespaceRead,
    19  		Exists: resourceKubernetesNamespaceExists,
    20  		Update: resourceKubernetesNamespaceUpdate,
    21  		Delete: resourceKubernetesNamespaceDelete,
    22  		Importer: &schema.ResourceImporter{
    23  			State: schema.ImportStatePassthrough,
    24  		},
    25  
    26  		Schema: map[string]*schema.Schema{
    27  			"metadata": metadataSchema("namespace"),
    28  		},
    29  	}
    30  }
    31  
    32  func resourceKubernetesNamespaceCreate(d *schema.ResourceData, meta interface{}) error {
    33  	conn := meta.(*kubernetes.Clientset)
    34  
    35  	metadata := expandMetadata(d.Get("metadata").([]interface{}))
    36  	namespace := api.Namespace{
    37  		ObjectMeta: metadata,
    38  	}
    39  	log.Printf("[INFO] Creating new namespace: %#v", namespace)
    40  	out, err := conn.CoreV1().Namespaces().Create(&namespace)
    41  	if err != nil {
    42  		return err
    43  	}
    44  	log.Printf("[INFO] Submitted new namespace: %#v", out)
    45  	d.SetId(out.Name)
    46  
    47  	return resourceKubernetesNamespaceRead(d, meta)
    48  }
    49  
    50  func resourceKubernetesNamespaceRead(d *schema.ResourceData, meta interface{}) error {
    51  	conn := meta.(*kubernetes.Clientset)
    52  
    53  	name := d.Id()
    54  	log.Printf("[INFO] Reading namespace %s", name)
    55  	namespace, err := conn.CoreV1().Namespaces().Get(name)
    56  	if err != nil {
    57  		log.Printf("[DEBUG] Received error: %#v", err)
    58  		return err
    59  	}
    60  	log.Printf("[INFO] Received namespace: %#v", namespace)
    61  	err = d.Set("metadata", flattenMetadata(namespace.ObjectMeta))
    62  	if err != nil {
    63  		return err
    64  	}
    65  
    66  	return nil
    67  }
    68  
    69  func resourceKubernetesNamespaceUpdate(d *schema.ResourceData, meta interface{}) error {
    70  	conn := meta.(*kubernetes.Clientset)
    71  
    72  	metadata := expandMetadata(d.Get("metadata").([]interface{}))
    73  	// This is necessary in case the name is generated
    74  	metadata.Name = d.Id()
    75  
    76  	namespace := api.Namespace{
    77  		ObjectMeta: metadata,
    78  	}
    79  	log.Printf("[INFO] Updating namespace: %#v", namespace)
    80  	out, err := conn.CoreV1().Namespaces().Update(&namespace)
    81  	if err != nil {
    82  		return err
    83  	}
    84  	log.Printf("[INFO] Submitted updated namespace: %#v", out)
    85  	d.SetId(out.Name)
    86  
    87  	return resourceKubernetesNamespaceRead(d, meta)
    88  }
    89  
    90  func resourceKubernetesNamespaceDelete(d *schema.ResourceData, meta interface{}) error {
    91  	conn := meta.(*kubernetes.Clientset)
    92  
    93  	name := d.Id()
    94  	log.Printf("[INFO] Deleting namespace: %#v", name)
    95  	err := conn.CoreV1().Namespaces().Delete(name, &api.DeleteOptions{})
    96  	if err != nil {
    97  		return err
    98  	}
    99  
   100  	stateConf := &resource.StateChangeConf{
   101  		Target:  []string{},
   102  		Pending: []string{"Terminating"},
   103  		Timeout: 5 * time.Minute,
   104  		Refresh: func() (interface{}, string, error) {
   105  			out, err := conn.CoreV1().Namespaces().Get(name)
   106  			if err != nil {
   107  				if statusErr, ok := err.(*errors.StatusError); ok && statusErr.ErrStatus.Code == 404 {
   108  					return nil, "", nil
   109  				}
   110  				log.Printf("[ERROR] Received error: %#v", err)
   111  				return out, "Error", err
   112  			}
   113  
   114  			statusPhase := fmt.Sprintf("%v", out.Status.Phase)
   115  			log.Printf("[DEBUG] Namespace %s status received: %#v", out.Name, statusPhase)
   116  			return out, statusPhase, nil
   117  		},
   118  	}
   119  	_, err = stateConf.WaitForState()
   120  	if err != nil {
   121  		return err
   122  	}
   123  	log.Printf("[INFO] Namespace %s deleted", name)
   124  
   125  	d.SetId("")
   126  	return nil
   127  }
   128  
   129  func resourceKubernetesNamespaceExists(d *schema.ResourceData, meta interface{}) (bool, error) {
   130  	conn := meta.(*kubernetes.Clientset)
   131  
   132  	name := d.Id()
   133  	log.Printf("[INFO] Checking namespace %s", name)
   134  	_, err := conn.CoreV1().Namespaces().Get(name)
   135  	if err != nil {
   136  		if statusErr, ok := err.(*errors.StatusError); ok && statusErr.ErrStatus.Code == 404 {
   137  			return false, nil
   138  		}
   139  		log.Printf("[DEBUG] Received error: %#v", err)
   140  	}
   141  	log.Printf("[INFO] Namespace %s exists", name)
   142  	return true, err
   143  }