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