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

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"strconv"
     6  
     7  	"github.com/hashicorp/terraform/helper/resource"
     8  	"github.com/hashicorp/terraform/helper/schema"
     9  	"google.golang.org/api/compute/v1"
    10  )
    11  
    12  func resourceComputeSslCertificate() *schema.Resource {
    13  	return &schema.Resource{
    14  		Create: resourceComputeSslCertificateCreate,
    15  		Read:   resourceComputeSslCertificateRead,
    16  		Delete: resourceComputeSslCertificateDelete,
    17  
    18  		Schema: map[string]*schema.Schema{
    19  			"certificate": &schema.Schema{
    20  				Type:     schema.TypeString,
    21  				Required: true,
    22  				ForceNew: true,
    23  			},
    24  
    25  			"name": &schema.Schema{
    26  				Type:          schema.TypeString,
    27  				Optional:      true,
    28  				Computed:      true,
    29  				ForceNew:      true,
    30  				ConflictsWith: []string{"name_prefix"},
    31  				ValidateFunc: func(v interface{}, k string) (ws []string, errors []error) {
    32  					// https://cloud.google.com/compute/docs/reference/latest/sslCertificates#resource
    33  					value := v.(string)
    34  					if len(value) > 63 {
    35  						errors = append(errors, fmt.Errorf(
    36  							"%q cannot be longer than 63 characters", k))
    37  					}
    38  					return
    39  				},
    40  			},
    41  
    42  			"name_prefix": &schema.Schema{
    43  				Type:     schema.TypeString,
    44  				Optional: true,
    45  				ForceNew: true,
    46  				ValidateFunc: func(v interface{}, k string) (ws []string, errors []error) {
    47  					// https://cloud.google.com/compute/docs/reference/latest/sslCertificates#resource
    48  					// uuid is 26 characters, limit the prefix to 37.
    49  					value := v.(string)
    50  					if len(value) > 37 {
    51  						errors = append(errors, fmt.Errorf(
    52  							"%q cannot be longer than 37 characters, name is limited to 63", k))
    53  					}
    54  					return
    55  				},
    56  			},
    57  
    58  			"private_key": &schema.Schema{
    59  				Type:     schema.TypeString,
    60  				Required: true,
    61  				ForceNew: true,
    62  			},
    63  
    64  			"description": &schema.Schema{
    65  				Type:     schema.TypeString,
    66  				Optional: true,
    67  				ForceNew: true,
    68  			},
    69  
    70  			"id": &schema.Schema{
    71  				Type:     schema.TypeString,
    72  				Computed: true,
    73  			},
    74  
    75  			"project": &schema.Schema{
    76  				Type:     schema.TypeString,
    77  				Optional: true,
    78  				ForceNew: true,
    79  			},
    80  
    81  			"self_link": &schema.Schema{
    82  				Type:     schema.TypeString,
    83  				Computed: true,
    84  			},
    85  		},
    86  	}
    87  }
    88  
    89  func resourceComputeSslCertificateCreate(d *schema.ResourceData, meta interface{}) error {
    90  	config := meta.(*Config)
    91  
    92  	project, err := getProject(d, config)
    93  	if err != nil {
    94  		return err
    95  	}
    96  
    97  	var certName string
    98  	if v, ok := d.GetOk("name"); ok {
    99  		certName = v.(string)
   100  	} else if v, ok := d.GetOk("name_prefix"); ok {
   101  		certName = resource.PrefixedUniqueId(v.(string))
   102  	} else {
   103  		certName = resource.UniqueId()
   104  	}
   105  
   106  	// Build the certificate parameter
   107  	cert := &compute.SslCertificate{
   108  		Name:        certName,
   109  		Certificate: d.Get("certificate").(string),
   110  		PrivateKey:  d.Get("private_key").(string),
   111  	}
   112  
   113  	if v, ok := d.GetOk("description"); ok {
   114  		cert.Description = v.(string)
   115  	}
   116  
   117  	op, err := config.clientCompute.SslCertificates.Insert(
   118  		project, cert).Do()
   119  
   120  	if err != nil {
   121  		return fmt.Errorf("Error creating ssl certificate: %s", err)
   122  	}
   123  
   124  	err = computeOperationWaitGlobal(config, op, project, "Creating SslCertificate")
   125  	if err != nil {
   126  		return err
   127  	}
   128  
   129  	d.SetId(cert.Name)
   130  
   131  	return resourceComputeSslCertificateRead(d, meta)
   132  }
   133  
   134  func resourceComputeSslCertificateRead(d *schema.ResourceData, meta interface{}) error {
   135  	config := meta.(*Config)
   136  
   137  	project, err := getProject(d, config)
   138  	if err != nil {
   139  		return err
   140  	}
   141  
   142  	cert, err := config.clientCompute.SslCertificates.Get(
   143  		project, d.Id()).Do()
   144  	if err != nil {
   145  		return handleNotFoundError(err, d, fmt.Sprintf("SSL Certificate %q", d.Get("name").(string)))
   146  	}
   147  
   148  	d.Set("self_link", cert.SelfLink)
   149  	d.Set("id", strconv.FormatUint(cert.Id, 10))
   150  
   151  	return nil
   152  }
   153  
   154  func resourceComputeSslCertificateDelete(d *schema.ResourceData, meta interface{}) error {
   155  	config := meta.(*Config)
   156  
   157  	project, err := getProject(d, config)
   158  	if err != nil {
   159  		return err
   160  	}
   161  
   162  	op, err := config.clientCompute.SslCertificates.Delete(
   163  		project, d.Id()).Do()
   164  	if err != nil {
   165  		return fmt.Errorf("Error deleting ssl certificate: %s", err)
   166  	}
   167  
   168  	err = computeOperationWaitGlobal(config, op, project, "Deleting SslCertificate")
   169  	if err != nil {
   170  		return err
   171  	}
   172  
   173  	d.SetId("")
   174  	return nil
   175  }