github.com/daveadams/terraform@v0.6.4-0.20160830094355-13ce74975936/builtin/providers/google/resource_compute_instance.go (about) 1 package google 2 3 import ( 4 "fmt" 5 "log" 6 "strings" 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 stringScopeHashcode(v interface{}) int { 14 v = canonicalizeServiceScope(v.(string)) 15 return schema.HashString(v) 16 } 17 18 func resourceComputeInstance() *schema.Resource { 19 return &schema.Resource{ 20 Create: resourceComputeInstanceCreate, 21 Read: resourceComputeInstanceRead, 22 Update: resourceComputeInstanceUpdate, 23 Delete: resourceComputeInstanceDelete, 24 25 SchemaVersion: 2, 26 MigrateState: resourceComputeInstanceMigrateState, 27 28 Schema: map[string]*schema.Schema{ 29 "disk": &schema.Schema{ 30 Type: schema.TypeList, 31 Required: true, 32 ForceNew: true, 33 Elem: &schema.Resource{ 34 Schema: map[string]*schema.Schema{ 35 // TODO(mitchellh): one of image or disk is required 36 37 "disk": &schema.Schema{ 38 Type: schema.TypeString, 39 Optional: true, 40 ForceNew: true, 41 }, 42 43 "image": &schema.Schema{ 44 Type: schema.TypeString, 45 Optional: true, 46 ForceNew: true, 47 }, 48 49 "type": &schema.Schema{ 50 Type: schema.TypeString, 51 Optional: true, 52 ForceNew: true, 53 }, 54 55 "scratch": &schema.Schema{ 56 Type: schema.TypeBool, 57 Optional: true, 58 ForceNew: true, 59 }, 60 61 "auto_delete": &schema.Schema{ 62 Type: schema.TypeBool, 63 Optional: true, 64 Default: true, 65 ForceNew: true, 66 }, 67 68 "size": &schema.Schema{ 69 Type: schema.TypeInt, 70 Optional: true, 71 ForceNew: true, 72 }, 73 74 "device_name": &schema.Schema{ 75 Type: schema.TypeString, 76 Optional: true, 77 }, 78 }, 79 }, 80 }, 81 82 "machine_type": &schema.Schema{ 83 Type: schema.TypeString, 84 Required: true, 85 ForceNew: true, 86 }, 87 88 "name": &schema.Schema{ 89 Type: schema.TypeString, 90 Required: true, 91 ForceNew: true, 92 }, 93 94 "zone": &schema.Schema{ 95 Type: schema.TypeString, 96 Required: true, 97 ForceNew: true, 98 }, 99 100 "can_ip_forward": &schema.Schema{ 101 Type: schema.TypeBool, 102 Optional: true, 103 Default: false, 104 ForceNew: true, 105 }, 106 107 "description": &schema.Schema{ 108 Type: schema.TypeString, 109 Optional: true, 110 ForceNew: true, 111 }, 112 113 "metadata": &schema.Schema{ 114 Type: schema.TypeMap, 115 Optional: true, 116 Elem: schema.TypeString, 117 ValidateFunc: validateInstanceMetadata, 118 }, 119 120 "metadata_startup_script": &schema.Schema{ 121 Type: schema.TypeString, 122 Optional: true, 123 ForceNew: true, 124 }, 125 126 "metadata_fingerprint": &schema.Schema{ 127 Type: schema.TypeString, 128 Computed: true, 129 }, 130 131 "network_interface": &schema.Schema{ 132 Type: schema.TypeList, 133 Optional: true, 134 ForceNew: true, 135 Elem: &schema.Resource{ 136 Schema: map[string]*schema.Schema{ 137 "network": &schema.Schema{ 138 Type: schema.TypeString, 139 Optional: true, 140 ForceNew: true, 141 }, 142 143 "subnetwork": &schema.Schema{ 144 Type: schema.TypeString, 145 Optional: true, 146 ForceNew: true, 147 }, 148 149 "name": &schema.Schema{ 150 Type: schema.TypeString, 151 Computed: true, 152 }, 153 154 "address": &schema.Schema{ 155 Type: schema.TypeString, 156 Optional: true, 157 ForceNew: true, 158 Computed: true, 159 }, 160 161 "access_config": &schema.Schema{ 162 Type: schema.TypeList, 163 Optional: true, 164 Elem: &schema.Resource{ 165 Schema: map[string]*schema.Schema{ 166 "nat_ip": &schema.Schema{ 167 Type: schema.TypeString, 168 Optional: true, 169 }, 170 171 "assigned_nat_ip": &schema.Schema{ 172 Type: schema.TypeString, 173 Computed: true, 174 }, 175 }, 176 }, 177 }, 178 }, 179 }, 180 }, 181 182 "network": &schema.Schema{ 183 Type: schema.TypeList, 184 Optional: true, 185 ForceNew: true, 186 Deprecated: "Please use network_interface", 187 Elem: &schema.Resource{ 188 Schema: map[string]*schema.Schema{ 189 "source": &schema.Schema{ 190 Type: schema.TypeString, 191 Required: true, 192 ForceNew: true, 193 }, 194 195 "address": &schema.Schema{ 196 Type: schema.TypeString, 197 Optional: true, 198 ForceNew: true, 199 }, 200 201 "name": &schema.Schema{ 202 Type: schema.TypeString, 203 Computed: true, 204 }, 205 206 "internal_address": &schema.Schema{ 207 Type: schema.TypeString, 208 Computed: true, 209 }, 210 211 "external_address": &schema.Schema{ 212 Type: schema.TypeString, 213 Computed: true, 214 }, 215 }, 216 }, 217 }, 218 219 "project": &schema.Schema{ 220 Type: schema.TypeString, 221 Optional: true, 222 ForceNew: true, 223 }, 224 225 "self_link": &schema.Schema{ 226 Type: schema.TypeString, 227 Computed: true, 228 }, 229 230 "scheduling": &schema.Schema{ 231 Type: schema.TypeList, 232 Optional: true, 233 Elem: &schema.Resource{ 234 Schema: map[string]*schema.Schema{ 235 "on_host_maintenance": &schema.Schema{ 236 Type: schema.TypeString, 237 Optional: true, 238 }, 239 240 "automatic_restart": &schema.Schema{ 241 Type: schema.TypeBool, 242 Optional: true, 243 }, 244 245 "preemptible": &schema.Schema{ 246 Type: schema.TypeBool, 247 Optional: true, 248 }, 249 }, 250 }, 251 }, 252 253 "service_account": &schema.Schema{ 254 Type: schema.TypeList, 255 MaxItems: 1, 256 Optional: true, 257 ForceNew: true, 258 Elem: &schema.Resource{ 259 Schema: map[string]*schema.Schema{ 260 "email": &schema.Schema{ 261 Type: schema.TypeString, 262 ForceNew: true, 263 Optional: true, 264 Computed: true, 265 }, 266 267 "scopes": &schema.Schema{ 268 Type: schema.TypeSet, 269 Required: true, 270 ForceNew: true, 271 Elem: &schema.Schema{ 272 Type: schema.TypeString, 273 StateFunc: func(v interface{}) string { 274 return canonicalizeServiceScope(v.(string)) 275 }, 276 }, 277 Set: stringScopeHashcode, 278 }, 279 }, 280 }, 281 }, 282 283 "tags": &schema.Schema{ 284 Type: schema.TypeSet, 285 Optional: true, 286 Elem: &schema.Schema{Type: schema.TypeString}, 287 Set: schema.HashString, 288 }, 289 290 "tags_fingerprint": &schema.Schema{ 291 Type: schema.TypeString, 292 Computed: true, 293 }, 294 }, 295 } 296 } 297 298 func getInstance(config *Config, d *schema.ResourceData) (*compute.Instance, error) { 299 project, err := getProject(d, config) 300 if err != nil { 301 return nil, err 302 } 303 304 instance, err := config.clientCompute.Instances.Get( 305 project, d.Get("zone").(string), d.Id()).Do() 306 if err != nil { 307 if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 { 308 log.Printf("[WARN] Removing Instance %q because it's gone", d.Get("name").(string)) 309 // The resource doesn't exist anymore 310 id := d.Id() 311 d.SetId("") 312 313 return nil, fmt.Errorf("Resource %s no longer exists", id) 314 } 315 316 return nil, fmt.Errorf("Error reading instance: %s", err) 317 } 318 319 return instance, nil 320 } 321 322 func resourceComputeInstanceCreate(d *schema.ResourceData, meta interface{}) error { 323 config := meta.(*Config) 324 325 project, err := getProject(d, config) 326 if err != nil { 327 return err 328 } 329 330 // Get the zone 331 log.Printf("[DEBUG] Loading zone: %s", d.Get("zone").(string)) 332 zone, err := config.clientCompute.Zones.Get( 333 project, d.Get("zone").(string)).Do() 334 if err != nil { 335 return fmt.Errorf( 336 "Error loading zone '%s': %s", d.Get("zone").(string), err) 337 } 338 339 // Get the machine type 340 log.Printf("[DEBUG] Loading machine type: %s", d.Get("machine_type").(string)) 341 machineType, err := config.clientCompute.MachineTypes.Get( 342 project, zone.Name, d.Get("machine_type").(string)).Do() 343 if err != nil { 344 return fmt.Errorf( 345 "Error loading machine type: %s", 346 err) 347 } 348 349 // Build up the list of disks 350 disksCount := d.Get("disk.#").(int) 351 disks := make([]*compute.AttachedDisk, 0, disksCount) 352 for i := 0; i < disksCount; i++ { 353 prefix := fmt.Sprintf("disk.%d", i) 354 355 // var sourceLink string 356 357 // Build the disk 358 var disk compute.AttachedDisk 359 disk.Type = "PERSISTENT" 360 disk.Mode = "READ_WRITE" 361 disk.Boot = i == 0 362 disk.AutoDelete = d.Get(prefix + ".auto_delete").(bool) 363 364 // Load up the disk for this disk if specified 365 if v, ok := d.GetOk(prefix + ".disk"); ok { 366 diskName := v.(string) 367 diskData, err := config.clientCompute.Disks.Get( 368 project, zone.Name, diskName).Do() 369 if err != nil { 370 return fmt.Errorf( 371 "Error loading disk '%s': %s", 372 diskName, err) 373 } 374 375 disk.Source = diskData.SelfLink 376 } else { 377 // Create a new disk 378 disk.InitializeParams = &compute.AttachedDiskInitializeParams{} 379 } 380 381 if v, ok := d.GetOk(prefix + ".scratch"); ok { 382 if v.(bool) { 383 disk.Type = "SCRATCH" 384 } 385 } 386 387 // Load up the image for this disk if specified 388 if v, ok := d.GetOk(prefix + ".image"); ok { 389 imageName := v.(string) 390 391 imageUrl, err := resolveImage(config, imageName) 392 if err != nil { 393 return fmt.Errorf( 394 "Error resolving image name '%s': %s", 395 imageName, err) 396 } 397 398 disk.InitializeParams.SourceImage = imageUrl 399 } 400 401 if v, ok := d.GetOk(prefix + ".type"); ok { 402 diskTypeName := v.(string) 403 diskType, err := readDiskType(config, zone, diskTypeName) 404 if err != nil { 405 return fmt.Errorf( 406 "Error loading disk type '%s': %s", 407 diskTypeName, err) 408 } 409 410 disk.InitializeParams.DiskType = diskType.SelfLink 411 } 412 413 if v, ok := d.GetOk(prefix + ".size"); ok { 414 diskSizeGb := v.(int) 415 disk.InitializeParams.DiskSizeGb = int64(diskSizeGb) 416 } 417 418 if v, ok := d.GetOk(prefix + ".device_name"); ok { 419 disk.DeviceName = v.(string) 420 } 421 422 disks = append(disks, &disk) 423 } 424 425 networksCount := d.Get("network.#").(int) 426 networkInterfacesCount := d.Get("network_interface.#").(int) 427 428 if networksCount > 0 && networkInterfacesCount > 0 { 429 return fmt.Errorf("Error: cannot define both networks and network_interfaces.") 430 } 431 if networksCount == 0 && networkInterfacesCount == 0 { 432 return fmt.Errorf("Error: Must define at least one network_interface.") 433 } 434 435 var networkInterfaces []*compute.NetworkInterface 436 437 if networksCount > 0 { 438 // TODO: Delete this block when removing network { } 439 // Build up the list of networkInterfaces 440 networkInterfaces = make([]*compute.NetworkInterface, 0, networksCount) 441 for i := 0; i < networksCount; i++ { 442 prefix := fmt.Sprintf("network.%d", i) 443 // Load up the name of this network 444 networkName := d.Get(prefix + ".source").(string) 445 network, err := config.clientCompute.Networks.Get( 446 project, networkName).Do() 447 if err != nil { 448 return fmt.Errorf( 449 "Error loading network '%s': %s", 450 networkName, err) 451 } 452 453 // Build the networkInterface 454 var iface compute.NetworkInterface 455 iface.AccessConfigs = []*compute.AccessConfig{ 456 &compute.AccessConfig{ 457 Type: "ONE_TO_ONE_NAT", 458 NatIP: d.Get(prefix + ".address").(string), 459 }, 460 } 461 iface.Network = network.SelfLink 462 463 networkInterfaces = append(networkInterfaces, &iface) 464 } 465 } 466 467 if networkInterfacesCount > 0 { 468 // Build up the list of networkInterfaces 469 networkInterfaces = make([]*compute.NetworkInterface, 0, networkInterfacesCount) 470 for i := 0; i < networkInterfacesCount; i++ { 471 prefix := fmt.Sprintf("network_interface.%d", i) 472 // Load up the name of this network_interface 473 networkName := d.Get(prefix + ".network").(string) 474 subnetworkName := d.Get(prefix + ".subnetwork").(string) 475 address := d.Get(prefix + ".address").(string) 476 var networkLink, subnetworkLink string 477 478 if networkName != "" && subnetworkName != "" { 479 return fmt.Errorf("Cannot specify both network and subnetwork values.") 480 } else if networkName != "" { 481 network, err := config.clientCompute.Networks.Get( 482 project, networkName).Do() 483 if err != nil { 484 return fmt.Errorf( 485 "Error referencing network '%s': %s", 486 networkName, err) 487 } 488 networkLink = network.SelfLink 489 } else { 490 region := getRegionFromZone(d.Get("zone").(string)) 491 subnetwork, err := config.clientCompute.Subnetworks.Get( 492 project, region, subnetworkName).Do() 493 if err != nil { 494 return fmt.Errorf( 495 "Error referencing subnetwork '%s' in region '%s': %s", 496 subnetworkName, region, err) 497 } 498 subnetworkLink = subnetwork.SelfLink 499 } 500 501 // Build the networkInterface 502 var iface compute.NetworkInterface 503 iface.Network = networkLink 504 iface.Subnetwork = subnetworkLink 505 iface.NetworkIP = address 506 507 // Handle access_config structs 508 accessConfigsCount := d.Get(prefix + ".access_config.#").(int) 509 iface.AccessConfigs = make([]*compute.AccessConfig, accessConfigsCount) 510 for j := 0; j < accessConfigsCount; j++ { 511 acPrefix := fmt.Sprintf("%s.access_config.%d", prefix, j) 512 iface.AccessConfigs[j] = &compute.AccessConfig{ 513 Type: "ONE_TO_ONE_NAT", 514 NatIP: d.Get(acPrefix + ".nat_ip").(string), 515 } 516 } 517 518 networkInterfaces = append(networkInterfaces, &iface) 519 } 520 } 521 522 serviceAccountsCount := d.Get("service_account.#").(int) 523 serviceAccounts := make([]*compute.ServiceAccount, 0, serviceAccountsCount) 524 for i := 0; i < serviceAccountsCount; i++ { 525 prefix := fmt.Sprintf("service_account.%d", i) 526 527 scopesSet := d.Get(prefix + ".scopes").(*schema.Set) 528 scopes := make([]string, scopesSet.Len()) 529 for i, v := range scopesSet.List() { 530 scopes[i] = canonicalizeServiceScope(v.(string)) 531 } 532 533 email := "default" 534 if v := d.Get(prefix + ".email"); v != nil { 535 email = v.(string) 536 } 537 538 serviceAccount := &compute.ServiceAccount{ 539 Email: email, 540 Scopes: scopes, 541 } 542 543 serviceAccounts = append(serviceAccounts, serviceAccount) 544 } 545 546 prefix := "scheduling.0" 547 scheduling := &compute.Scheduling{} 548 549 if val, ok := d.GetOk(prefix + ".automatic_restart"); ok { 550 scheduling.AutomaticRestart = val.(bool) 551 } 552 553 if val, ok := d.GetOk(prefix + ".preemptible"); ok { 554 scheduling.Preemptible = val.(bool) 555 } 556 557 if val, ok := d.GetOk(prefix + ".on_host_maintenance"); ok { 558 scheduling.OnHostMaintenance = val.(string) 559 } 560 561 metadata, err := resourceInstanceMetadata(d) 562 if err != nil { 563 return fmt.Errorf("Error creating metadata: %s", err) 564 } 565 566 // Create the instance information 567 instance := compute.Instance{ 568 CanIpForward: d.Get("can_ip_forward").(bool), 569 Description: d.Get("description").(string), 570 Disks: disks, 571 MachineType: machineType.SelfLink, 572 Metadata: metadata, 573 Name: d.Get("name").(string), 574 NetworkInterfaces: networkInterfaces, 575 Tags: resourceInstanceTags(d), 576 ServiceAccounts: serviceAccounts, 577 Scheduling: scheduling, 578 } 579 580 log.Printf("[INFO] Requesting instance creation") 581 op, err := config.clientCompute.Instances.Insert( 582 project, zone.Name, &instance).Do() 583 if err != nil { 584 return fmt.Errorf("Error creating instance: %s", err) 585 } 586 587 // Store the ID now 588 d.SetId(instance.Name) 589 590 // Wait for the operation to complete 591 waitErr := computeOperationWaitZone(config, op, project, zone.Name, "instance to create") 592 if waitErr != nil { 593 // The resource didn't actually create 594 d.SetId("") 595 return waitErr 596 } 597 598 return resourceComputeInstanceRead(d, meta) 599 } 600 601 func resourceComputeInstanceRead(d *schema.ResourceData, meta interface{}) error { 602 config := meta.(*Config) 603 604 id := d.Id() 605 instance, err := getInstance(config, d) 606 if err != nil { 607 if strings.Contains(err.Error(), "no longer exists") { 608 log.Printf("[WARN] Google Compute Instance (%s) not found", id) 609 return nil 610 } 611 return err 612 } 613 614 // Synch metadata 615 md := instance.Metadata 616 617 _md := MetadataFormatSchema(d.Get("metadata").(map[string]interface{}), md) 618 delete(_md, "startup-script") 619 620 if script, scriptExists := d.GetOk("metadata_startup_script"); scriptExists { 621 d.Set("metadata_startup_script", script) 622 } 623 624 if err = d.Set("metadata", _md); err != nil { 625 return fmt.Errorf("Error setting metadata: %s", err) 626 } 627 628 d.Set("can_ip_forward", instance.CanIpForward) 629 630 // Set the service accounts 631 serviceAccounts := make([]map[string]interface{}, 0, 1) 632 for _, serviceAccount := range instance.ServiceAccounts { 633 scopes := make([]interface{}, len(serviceAccount.Scopes)) 634 for i, scope := range serviceAccount.Scopes { 635 scopes[i] = scope 636 } 637 serviceAccounts = append(serviceAccounts, map[string]interface{}{ 638 "email": serviceAccount.Email, 639 "scopes": schema.NewSet(stringScopeHashcode, scopes), 640 }) 641 } 642 d.Set("service_account", serviceAccounts) 643 644 networksCount := d.Get("network.#").(int) 645 networkInterfacesCount := d.Get("network_interface.#").(int) 646 647 if networksCount > 0 && networkInterfacesCount > 0 { 648 return fmt.Errorf("Error: cannot define both networks and network_interfaces.") 649 } 650 if networksCount == 0 && networkInterfacesCount == 0 { 651 return fmt.Errorf("Error: Must define at least one network_interface.") 652 } 653 654 // Set the networks 655 // Use the first external IP found for the default connection info. 656 externalIP := "" 657 internalIP := "" 658 networks := make([]map[string]interface{}, 0, 1) 659 if networksCount > 0 { 660 // TODO: Remove this when realizing deprecation of .network 661 for i, iface := range instance.NetworkInterfaces { 662 var natIP string 663 for _, config := range iface.AccessConfigs { 664 if config.Type == "ONE_TO_ONE_NAT" { 665 natIP = config.NatIP 666 break 667 } 668 } 669 670 if externalIP == "" && natIP != "" { 671 externalIP = natIP 672 } 673 674 network := make(map[string]interface{}) 675 network["name"] = iface.Name 676 network["external_address"] = natIP 677 network["internal_address"] = iface.NetworkIP 678 network["source"] = d.Get(fmt.Sprintf("network.%d.source", i)) 679 networks = append(networks, network) 680 } 681 } 682 d.Set("network", networks) 683 684 networkInterfaces := make([]map[string]interface{}, 0, 1) 685 if networkInterfacesCount > 0 { 686 for i, iface := range instance.NetworkInterfaces { 687 // The first non-empty ip is left in natIP 688 var natIP string 689 accessConfigs := make( 690 []map[string]interface{}, 0, len(iface.AccessConfigs)) 691 for j, config := range iface.AccessConfigs { 692 accessConfigs = append(accessConfigs, map[string]interface{}{ 693 "nat_ip": d.Get(fmt.Sprintf("network_interface.%d.access_config.%d.nat_ip", i, j)), 694 "assigned_nat_ip": config.NatIP, 695 }) 696 697 if natIP == "" { 698 natIP = config.NatIP 699 } 700 } 701 702 if externalIP == "" { 703 externalIP = natIP 704 } 705 706 if internalIP == "" { 707 internalIP = iface.NetworkIP 708 } 709 710 networkInterfaces = append(networkInterfaces, map[string]interface{}{ 711 "name": iface.Name, 712 "address": iface.NetworkIP, 713 "network": d.Get(fmt.Sprintf("network_interface.%d.network", i)), 714 "subnetwork": d.Get(fmt.Sprintf("network_interface.%d.subnetwork", i)), 715 "access_config": accessConfigs, 716 }) 717 } 718 } 719 d.Set("network_interface", networkInterfaces) 720 721 // Fall back on internal ip if there is no external ip. This makes sense in the situation where 722 // terraform is being used on a cloud instance and can therefore access the instances it creates 723 // via their internal ips. 724 sshIP := externalIP 725 if sshIP == "" { 726 sshIP = internalIP 727 } 728 729 // Initialize the connection info 730 d.SetConnInfo(map[string]string{ 731 "type": "ssh", 732 "host": sshIP, 733 }) 734 735 // Set the metadata fingerprint if there is one. 736 if instance.Metadata != nil { 737 d.Set("metadata_fingerprint", instance.Metadata.Fingerprint) 738 } 739 740 // Set the tags fingerprint if there is one. 741 if instance.Tags != nil { 742 d.Set("tags_fingerprint", instance.Tags.Fingerprint) 743 } 744 745 d.Set("self_link", instance.SelfLink) 746 d.SetId(instance.Name) 747 748 return nil 749 } 750 751 func resourceComputeInstanceUpdate(d *schema.ResourceData, meta interface{}) error { 752 config := meta.(*Config) 753 754 project, err := getProject(d, config) 755 if err != nil { 756 return err 757 } 758 759 zone := d.Get("zone").(string) 760 761 instance, err := getInstance(config, d) 762 if err != nil { 763 return err 764 } 765 766 // Enable partial mode for the resource since it is possible 767 d.Partial(true) 768 769 // If the Metadata has changed, then update that. 770 if d.HasChange("metadata") { 771 o, n := d.GetChange("metadata") 772 if script, scriptExists := d.GetOk("metadata_startup_script"); scriptExists { 773 if _, ok := n.(map[string]interface{})["startup-script"]; ok { 774 return fmt.Errorf("Only one of metadata.startup-script and metadata_startup_script may be defined") 775 } 776 777 n.(map[string]interface{})["startup-script"] = script 778 } 779 780 updateMD := func() error { 781 // Reload the instance in the case of a fingerprint mismatch 782 instance, err = getInstance(config, d) 783 if err != nil { 784 return err 785 } 786 787 md := instance.Metadata 788 789 MetadataUpdate(o.(map[string]interface{}), n.(map[string]interface{}), md) 790 791 if err != nil { 792 return fmt.Errorf("Error updating metadata: %s", err) 793 } 794 op, err := config.clientCompute.Instances.SetMetadata( 795 project, zone, d.Id(), md).Do() 796 if err != nil { 797 return fmt.Errorf("Error updating metadata: %s", err) 798 } 799 800 opErr := computeOperationWaitZone(config, op, project, zone, "metadata to update") 801 if opErr != nil { 802 return opErr 803 } 804 805 d.SetPartial("metadata") 806 return nil 807 } 808 809 MetadataRetryWrapper(updateMD) 810 } 811 812 if d.HasChange("tags") { 813 tags := resourceInstanceTags(d) 814 op, err := config.clientCompute.Instances.SetTags( 815 project, zone, d.Id(), tags).Do() 816 if err != nil { 817 return fmt.Errorf("Error updating tags: %s", err) 818 } 819 820 opErr := computeOperationWaitZone(config, op, project, zone, "tags to update") 821 if opErr != nil { 822 return opErr 823 } 824 825 d.SetPartial("tags") 826 } 827 828 if d.HasChange("scheduling") { 829 prefix := "scheduling.0" 830 scheduling := &compute.Scheduling{} 831 832 if val, ok := d.GetOk(prefix + ".automatic_restart"); ok { 833 scheduling.AutomaticRestart = val.(bool) 834 } 835 836 if val, ok := d.GetOk(prefix + ".preemptible"); ok { 837 scheduling.Preemptible = val.(bool) 838 } 839 840 if val, ok := d.GetOk(prefix + ".on_host_maintenance"); ok { 841 scheduling.OnHostMaintenance = val.(string) 842 } 843 844 op, err := config.clientCompute.Instances.SetScheduling(project, 845 zone, d.Id(), scheduling).Do() 846 847 if err != nil { 848 return fmt.Errorf("Error updating scheduling policy: %s", err) 849 } 850 851 opErr := computeOperationWaitZone(config, op, project, zone, 852 "scheduling policy update") 853 if opErr != nil { 854 return opErr 855 } 856 857 d.SetPartial("scheduling") 858 } 859 860 networkInterfacesCount := d.Get("network_interface.#").(int) 861 if networkInterfacesCount > 0 { 862 // Sanity check 863 if networkInterfacesCount != len(instance.NetworkInterfaces) { 864 return fmt.Errorf("Instance had unexpected number of network interfaces: %d", len(instance.NetworkInterfaces)) 865 } 866 for i := 0; i < networkInterfacesCount; i++ { 867 prefix := fmt.Sprintf("network_interface.%d", i) 868 instNetworkInterface := instance.NetworkInterfaces[i] 869 networkName := d.Get(prefix + ".name").(string) 870 871 // TODO: This sanity check is broken by #929, disabled for now (by forcing the equality) 872 networkName = instNetworkInterface.Name 873 // Sanity check 874 if networkName != instNetworkInterface.Name { 875 return fmt.Errorf("Instance networkInterface had unexpected name: %s", instNetworkInterface.Name) 876 } 877 878 if d.HasChange(prefix + ".access_config") { 879 880 // TODO: This code deletes then recreates accessConfigs. This is bad because it may 881 // leave the machine inaccessible from either ip if the creation part fails (network 882 // timeout etc). However right now there is a GCE limit of 1 accessConfig so it is 883 // the only way to do it. In future this should be revised to only change what is 884 // necessary, and also add before removing. 885 886 // Delete any accessConfig that currently exists in instNetworkInterface 887 for _, ac := range instNetworkInterface.AccessConfigs { 888 op, err := config.clientCompute.Instances.DeleteAccessConfig( 889 project, zone, d.Id(), ac.Name, networkName).Do() 890 if err != nil { 891 return fmt.Errorf("Error deleting old access_config: %s", err) 892 } 893 opErr := computeOperationWaitZone(config, op, project, zone, 894 "old access_config to delete") 895 if opErr != nil { 896 return opErr 897 } 898 } 899 900 // Create new ones 901 accessConfigsCount := d.Get(prefix + ".access_config.#").(int) 902 for j := 0; j < accessConfigsCount; j++ { 903 acPrefix := fmt.Sprintf("%s.access_config.%d", prefix, j) 904 ac := &compute.AccessConfig{ 905 Type: "ONE_TO_ONE_NAT", 906 NatIP: d.Get(acPrefix + ".nat_ip").(string), 907 } 908 op, err := config.clientCompute.Instances.AddAccessConfig( 909 project, zone, d.Id(), networkName, ac).Do() 910 if err != nil { 911 return fmt.Errorf("Error adding new access_config: %s", err) 912 } 913 opErr := computeOperationWaitZone(config, op, project, zone, 914 "new access_config to add") 915 if opErr != nil { 916 return opErr 917 } 918 } 919 } 920 } 921 } 922 923 // We made it, disable partial mode 924 d.Partial(false) 925 926 return resourceComputeInstanceRead(d, meta) 927 } 928 929 func resourceComputeInstanceDelete(d *schema.ResourceData, meta interface{}) error { 930 config := meta.(*Config) 931 932 project, err := getProject(d, config) 933 if err != nil { 934 return err 935 } 936 937 zone := d.Get("zone").(string) 938 log.Printf("[INFO] Requesting instance deletion: %s", d.Id()) 939 op, err := config.clientCompute.Instances.Delete(project, zone, d.Id()).Do() 940 if err != nil { 941 return fmt.Errorf("Error deleting instance: %s", err) 942 } 943 944 // Wait for the operation to complete 945 opErr := computeOperationWaitZone(config, op, project, zone, "instance to delete") 946 if opErr != nil { 947 return opErr 948 } 949 950 d.SetId("") 951 return nil 952 } 953 954 func resourceInstanceMetadata(d *schema.ResourceData) (*compute.Metadata, error) { 955 m := &compute.Metadata{} 956 mdMap := d.Get("metadata").(map[string]interface{}) 957 if v, ok := d.GetOk("metadata_startup_script"); ok && v.(string) != "" { 958 mdMap["startup-script"] = v 959 } 960 if len(mdMap) > 0 { 961 m.Items = make([]*compute.MetadataItems, 0, len(mdMap)) 962 for key, val := range mdMap { 963 v := val.(string) 964 m.Items = append(m.Items, &compute.MetadataItems{ 965 Key: key, 966 Value: &v, 967 }) 968 } 969 970 // Set the fingerprint. If the metadata has never been set before 971 // then this will just be blank. 972 m.Fingerprint = d.Get("metadata_fingerprint").(string) 973 } 974 975 return m, nil 976 } 977 978 func resourceInstanceTags(d *schema.ResourceData) *compute.Tags { 979 // Calculate the tags 980 var tags *compute.Tags 981 if v := d.Get("tags"); v != nil { 982 vs := v.(*schema.Set) 983 tags = new(compute.Tags) 984 tags.Items = make([]string, vs.Len()) 985 for i, v := range vs.List() { 986 tags.Items[i] = v.(string) 987 } 988 989 tags.Fingerprint = d.Get("tags_fingerprint").(string) 990 } 991 992 return tags 993 } 994 995 func validateInstanceMetadata(v interface{}, k string) (ws []string, es []error) { 996 mdMap := v.(map[string]interface{}) 997 if _, ok := mdMap["startup-script"]; ok { 998 es = append(es, fmt.Errorf( 999 "Use metadata_startup_script instead of a startup-script key in %q.", k)) 1000 } 1001 return 1002 }