github.com/koding/terraform@v0.6.4-0.20170608090606-5d7e0339779d/builtin/providers/digitalocean/resource_digitalocean_ssh_key.go (about)

     1  package digitalocean
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"log"
     7  	"strconv"
     8  	"strings"
     9  
    10  	"github.com/digitalocean/godo"
    11  	"github.com/hashicorp/terraform/helper/schema"
    12  )
    13  
    14  func resourceDigitalOceanSSHKey() *schema.Resource {
    15  	return &schema.Resource{
    16  		Create: resourceDigitalOceanSSHKeyCreate,
    17  		Read:   resourceDigitalOceanSSHKeyRead,
    18  		Update: resourceDigitalOceanSSHKeyUpdate,
    19  		Delete: resourceDigitalOceanSSHKeyDelete,
    20  		Importer: &schema.ResourceImporter{
    21  			State: schema.ImportStatePassthrough,
    22  		},
    23  
    24  		Schema: map[string]*schema.Schema{
    25  			"id": {
    26  				Type:     schema.TypeString,
    27  				Computed: true,
    28  			},
    29  
    30  			"name": {
    31  				Type:     schema.TypeString,
    32  				Required: true,
    33  			},
    34  
    35  			"public_key": {
    36  				Type:             schema.TypeString,
    37  				Required:         true,
    38  				ForceNew:         true,
    39  				DiffSuppressFunc: resourceDigitalOceanSSHKeyPublicKeyDiffSuppress,
    40  			},
    41  
    42  			"fingerprint": {
    43  				Type:     schema.TypeString,
    44  				Computed: true,
    45  			},
    46  		},
    47  	}
    48  }
    49  
    50  func resourceDigitalOceanSSHKeyPublicKeyDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
    51  	return strings.TrimSpace(old) == strings.TrimSpace(new)
    52  }
    53  
    54  func resourceDigitalOceanSSHKeyCreate(d *schema.ResourceData, meta interface{}) error {
    55  	client := meta.(*godo.Client)
    56  
    57  	// Build up our creation options
    58  	opts := &godo.KeyCreateRequest{
    59  		Name:      d.Get("name").(string),
    60  		PublicKey: d.Get("public_key").(string),
    61  	}
    62  
    63  	log.Printf("[DEBUG] SSH Key create configuration: %#v", opts)
    64  	key, _, err := client.Keys.Create(context.Background(), opts)
    65  	if err != nil {
    66  		return fmt.Errorf("Error creating SSH Key: %s", err)
    67  	}
    68  
    69  	d.SetId(strconv.Itoa(key.ID))
    70  	log.Printf("[INFO] SSH Key: %d", key.ID)
    71  
    72  	return resourceDigitalOceanSSHKeyRead(d, meta)
    73  }
    74  
    75  func resourceDigitalOceanSSHKeyRead(d *schema.ResourceData, meta interface{}) error {
    76  	client := meta.(*godo.Client)
    77  
    78  	id, err := strconv.Atoi(d.Id())
    79  	if err != nil {
    80  		return fmt.Errorf("invalid SSH key id: %v", err)
    81  	}
    82  
    83  	key, resp, err := client.Keys.GetByID(context.Background(), id)
    84  	if err != nil {
    85  		// If the key is somehow already destroyed, mark as
    86  		// successfully gone
    87  		if resp != nil && resp.StatusCode == 404 {
    88  			d.SetId("")
    89  			return nil
    90  		}
    91  
    92  		return fmt.Errorf("Error retrieving SSH key: %s", err)
    93  	}
    94  
    95  	d.Set("name", key.Name)
    96  	d.Set("fingerprint", key.Fingerprint)
    97  	d.Set("public_key", key.PublicKey)
    98  
    99  	return nil
   100  }
   101  
   102  func resourceDigitalOceanSSHKeyUpdate(d *schema.ResourceData, meta interface{}) error {
   103  	client := meta.(*godo.Client)
   104  
   105  	id, err := strconv.Atoi(d.Id())
   106  	if err != nil {
   107  		return fmt.Errorf("invalid SSH key id: %v", err)
   108  	}
   109  
   110  	var newName string
   111  	if v, ok := d.GetOk("name"); ok {
   112  		newName = v.(string)
   113  	}
   114  
   115  	log.Printf("[DEBUG] SSH key update name: %#v", newName)
   116  	opts := &godo.KeyUpdateRequest{
   117  		Name: newName,
   118  	}
   119  	_, _, err = client.Keys.UpdateByID(context.Background(), id, opts)
   120  	if err != nil {
   121  		return fmt.Errorf("Failed to update SSH key: %s", err)
   122  	}
   123  
   124  	return resourceDigitalOceanSSHKeyRead(d, meta)
   125  }
   126  
   127  func resourceDigitalOceanSSHKeyDelete(d *schema.ResourceData, meta interface{}) error {
   128  	client := meta.(*godo.Client)
   129  
   130  	id, err := strconv.Atoi(d.Id())
   131  	if err != nil {
   132  		return fmt.Errorf("invalid SSH key id: %v", err)
   133  	}
   134  
   135  	log.Printf("[INFO] Deleting SSH key: %d", id)
   136  	_, err = client.Keys.DeleteByID(context.Background(), id)
   137  	if err != nil {
   138  		return fmt.Errorf("Error deleting SSH key: %s", err)
   139  	}
   140  
   141  	d.SetId("")
   142  	return nil
   143  }