github.com/meteor/terraform@v0.6.15-0.20210412225145-79ec4bc057c6/builtin/providers/google/resource_compute_backend_bucket.go (about)

     1  package google
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"regexp"
     7  
     8  	"github.com/hashicorp/terraform/helper/schema"
     9  	"google.golang.org/api/compute/v1"
    10  )
    11  
    12  func resourceComputeBackendBucket() *schema.Resource {
    13  	return &schema.Resource{
    14  		Create: resourceComputeBackendBucketCreate,
    15  		Read:   resourceComputeBackendBucketRead,
    16  		Update: resourceComputeBackendBucketUpdate,
    17  		Delete: resourceComputeBackendBucketDelete,
    18  
    19  		Schema: map[string]*schema.Schema{
    20  			"name": &schema.Schema{
    21  				Type:     schema.TypeString,
    22  				Required: true,
    23  				ForceNew: true,
    24  				ValidateFunc: func(v interface{}, k string) (ws []string, errors []error) {
    25  					value := v.(string)
    26  					re := `^(?:[a-z](?:[-a-z0-9]{0,61}[a-z0-9])?)$`
    27  					if !regexp.MustCompile(re).MatchString(value) {
    28  						errors = append(errors, fmt.Errorf(
    29  							"%q (%q) doesn't match regexp %q", k, value, re))
    30  					}
    31  					return
    32  				},
    33  			},
    34  
    35  			"bucket_name": &schema.Schema{
    36  				Type:     schema.TypeString,
    37  				Required: true,
    38  			},
    39  
    40  			"description": &schema.Schema{
    41  				Type:     schema.TypeString,
    42  				Optional: true,
    43  			},
    44  
    45  			"enable_cdn": &schema.Schema{
    46  				Type:     schema.TypeBool,
    47  				Optional: true,
    48  				Default:  false,
    49  			},
    50  
    51  			"project": &schema.Schema{
    52  				Type:     schema.TypeString,
    53  				Optional: true,
    54  				ForceNew: true,
    55  			},
    56  
    57  			"self_link": &schema.Schema{
    58  				Type:     schema.TypeString,
    59  				Computed: true,
    60  			},
    61  		},
    62  	}
    63  }
    64  
    65  func resourceComputeBackendBucketCreate(d *schema.ResourceData, meta interface{}) error {
    66  	config := meta.(*Config)
    67  
    68  	bucket := compute.BackendBucket{
    69  		Name:       d.Get("name").(string),
    70  		BucketName: d.Get("bucket_name").(string),
    71  	}
    72  
    73  	if v, ok := d.GetOk("description"); ok {
    74  		bucket.Description = v.(string)
    75  	}
    76  
    77  	if v, ok := d.GetOk("enable_cdn"); ok {
    78  		bucket.EnableCdn = v.(bool)
    79  	}
    80  
    81  	project, err := getProject(d, config)
    82  	if err != nil {
    83  		return err
    84  	}
    85  
    86  	log.Printf("[DEBUG] Creating new Backend Bucket: %#v", bucket)
    87  	op, err := config.clientCompute.BackendBuckets.Insert(
    88  		project, &bucket).Do()
    89  	if err != nil {
    90  		return fmt.Errorf("Error creating backend bucket: %s", err)
    91  	}
    92  
    93  	log.Printf("[DEBUG] Waiting for new backend bucket, operation: %#v", op)
    94  
    95  	// Store the ID now
    96  	d.SetId(bucket.Name)
    97  
    98  	// Wait for the operation to complete
    99  	waitErr := computeOperationWaitGlobal(config, op, project, "Creating Backend Bucket")
   100  	if waitErr != nil {
   101  		// The resource didn't actually create
   102  		d.SetId("")
   103  		return waitErr
   104  	}
   105  
   106  	return resourceComputeBackendBucketRead(d, meta)
   107  }
   108  
   109  func resourceComputeBackendBucketRead(d *schema.ResourceData, meta interface{}) error {
   110  	config := meta.(*Config)
   111  
   112  	project, err := getProject(d, config)
   113  	if err != nil {
   114  		return err
   115  	}
   116  
   117  	bucket, err := config.clientCompute.BackendBuckets.Get(
   118  		project, d.Id()).Do()
   119  	if err != nil {
   120  		return handleNotFoundError(err, d, fmt.Sprintf("Backend Bucket %q", d.Get("name").(string)))
   121  	}
   122  
   123  	d.Set("bucket_name", bucket.BucketName)
   124  	d.Set("description", bucket.Description)
   125  	d.Set("enable_cdn", bucket.EnableCdn)
   126  	d.Set("self_link", bucket.SelfLink)
   127  
   128  	return nil
   129  }
   130  
   131  func resourceComputeBackendBucketUpdate(d *schema.ResourceData, meta interface{}) error {
   132  	config := meta.(*Config)
   133  
   134  	project, err := getProject(d, config)
   135  	if err != nil {
   136  		return err
   137  	}
   138  
   139  	bucket := compute.BackendBucket{
   140  		Name:       d.Get("name").(string),
   141  		BucketName: d.Get("bucket_name").(string),
   142  	}
   143  
   144  	// Optional things
   145  	if v, ok := d.GetOk("description"); ok {
   146  		bucket.Description = v.(string)
   147  	}
   148  
   149  	if v, ok := d.GetOk("enable_cdn"); ok {
   150  		bucket.EnableCdn = v.(bool)
   151  	}
   152  
   153  	log.Printf("[DEBUG] Updating existing Backend Bucket %q: %#v", d.Id(), bucket)
   154  	op, err := config.clientCompute.BackendBuckets.Update(
   155  		project, d.Id(), &bucket).Do()
   156  	if err != nil {
   157  		return fmt.Errorf("Error updating backend bucket: %s", err)
   158  	}
   159  
   160  	d.SetId(bucket.Name)
   161  
   162  	err = computeOperationWaitGlobal(config, op, project, "Updating Backend Bucket")
   163  	if err != nil {
   164  		return err
   165  	}
   166  
   167  	return resourceComputeBackendBucketRead(d, meta)
   168  }
   169  
   170  func resourceComputeBackendBucketDelete(d *schema.ResourceData, meta interface{}) error {
   171  	config := meta.(*Config)
   172  
   173  	project, err := getProject(d, config)
   174  	if err != nil {
   175  		return err
   176  	}
   177  
   178  	log.Printf("[DEBUG] Deleting backend bucket %s", d.Id())
   179  	op, err := config.clientCompute.BackendBuckets.Delete(
   180  		project, d.Id()).Do()
   181  	if err != nil {
   182  		return fmt.Errorf("Error deleting backend bucket: %s", err)
   183  	}
   184  
   185  	err = computeOperationWaitGlobal(config, op, project, "Deleting Backend Bucket")
   186  	if err != nil {
   187  		return err
   188  	}
   189  
   190  	d.SetId("")
   191  	return nil
   192  }