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

     1  package digitalocean
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"log"
     7  
     8  	"github.com/digitalocean/godo"
     9  	"github.com/hashicorp/terraform/helper/schema"
    10  )
    11  
    12  func resourceDigitalOceanCertificate() *schema.Resource {
    13  	return &schema.Resource{
    14  		Create: resourceDigitalOceanCertificateCreate,
    15  		Read:   resourceDigitalOceanCertificateRead,
    16  		Delete: resourceDigitalOceanCertificateDelete,
    17  
    18  		Schema: map[string]*schema.Schema{
    19  			"name": {
    20  				Type:     schema.TypeString,
    21  				Required: true,
    22  				ForceNew: true,
    23  			},
    24  
    25  			"private_key": {
    26  				Type:     schema.TypeString,
    27  				Required: true,
    28  				ForceNew: true,
    29  			},
    30  
    31  			"leaf_certificate": {
    32  				Type:     schema.TypeString,
    33  				Required: true,
    34  				ForceNew: true,
    35  			},
    36  
    37  			"certificate_chain": {
    38  				Type:     schema.TypeString,
    39  				Optional: true,
    40  				ForceNew: true,
    41  			},
    42  
    43  			"not_after": {
    44  				Type:     schema.TypeString,
    45  				Computed: true,
    46  			},
    47  
    48  			"sha1_fingerprint": {
    49  				Type:     schema.TypeString,
    50  				Computed: true,
    51  			},
    52  		},
    53  	}
    54  }
    55  
    56  func buildCertificateRequest(d *schema.ResourceData) (*godo.CertificateRequest, error) {
    57  	req := &godo.CertificateRequest{
    58  		Name:             d.Get("name").(string),
    59  		PrivateKey:       d.Get("private_key").(string),
    60  		LeafCertificate:  d.Get("leaf_certificate").(string),
    61  		CertificateChain: d.Get("certificate_chain").(string),
    62  	}
    63  
    64  	return req, nil
    65  }
    66  
    67  func resourceDigitalOceanCertificateCreate(d *schema.ResourceData, meta interface{}) error {
    68  	client := meta.(*godo.Client)
    69  
    70  	log.Printf("[INFO] Create a Certificate Request")
    71  
    72  	certReq, err := buildCertificateRequest(d)
    73  	if err != nil {
    74  		return err
    75  	}
    76  
    77  	log.Printf("[DEBUG] Certificate Create: %#v", certReq)
    78  	cert, _, err := client.Certificates.Create(context.Background(), certReq)
    79  	if err != nil {
    80  		return fmt.Errorf("Error creating Certificate: %s", err)
    81  	}
    82  
    83  	d.SetId(cert.ID)
    84  
    85  	return resourceDigitalOceanCertificateRead(d, meta)
    86  }
    87  
    88  func resourceDigitalOceanCertificateRead(d *schema.ResourceData, meta interface{}) error {
    89  	client := meta.(*godo.Client)
    90  
    91  	log.Printf("[INFO] Reading the details of the Certificate %s", d.Id())
    92  	cert, _, err := client.Certificates.Get(context.Background(), d.Id())
    93  	if err != nil {
    94  		return fmt.Errorf("Error retrieving Certificate: %s", err)
    95  	}
    96  
    97  	d.Set("name", cert.Name)
    98  	d.Set("not_after", cert.NotAfter)
    99  	d.Set("sha1_fingerprint", cert.SHA1Fingerprint)
   100  
   101  	return nil
   102  
   103  }
   104  
   105  func resourceDigitalOceanCertificateDelete(d *schema.ResourceData, meta interface{}) error {
   106  	client := meta.(*godo.Client)
   107  
   108  	log.Printf("[INFO] Deleting Certificate: %s", d.Id())
   109  	_, err := client.Certificates.Delete(context.Background(), d.Id())
   110  	if err != nil {
   111  		return fmt.Errorf("Error deleting Certificate: %s", err)
   112  	}
   113  
   114  	return nil
   115  
   116  }