github.com/shvar/terraform@v0.6.9-0.20151215234924-3365cd2231df/builtin/providers/azurerm/resource_arm_resource_group.go (about)

     1  package azurerm
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  	"net/http"
     7  	"regexp"
     8  	"strings"
     9  	"time"
    10  
    11  	"github.com/Azure/azure-sdk-for-go/arm/resources"
    12  	"github.com/hashicorp/terraform/helper/resource"
    13  	"github.com/hashicorp/terraform/helper/schema"
    14  )
    15  
    16  func resourceArmResourceGroup() *schema.Resource {
    17  	return &schema.Resource{
    18  		Create: resourceArmResourceGroupCreate,
    19  		Read:   resourceArmResourceGroupRead,
    20  		Exists: resourceArmResourceGroupExists,
    21  		Delete: resourceArmResourceGroupDelete,
    22  
    23  		Schema: map[string]*schema.Schema{
    24  			"name": &schema.Schema{
    25  				Type:         schema.TypeString,
    26  				Required:     true,
    27  				ForceNew:     true,
    28  				ValidateFunc: validateArmResourceGroupName,
    29  			},
    30  			"location": &schema.Schema{
    31  				Type:      schema.TypeString,
    32  				Required:  true,
    33  				ForceNew:  true,
    34  				StateFunc: azureRMNormalizeLocation,
    35  			},
    36  		},
    37  	}
    38  }
    39  
    40  func validateArmResourceGroupName(v interface{}, k string) (ws []string, es []error) {
    41  	value := v.(string)
    42  
    43  	if len(value) > 80 {
    44  		es = append(es, fmt.Errorf("%q may not exceed 80 characters in length", k))
    45  	}
    46  
    47  	if strings.HasSuffix(value, ".") {
    48  		es = append(es, fmt.Errorf("%q may not end with a period", k))
    49  	}
    50  
    51  	if matched := regexp.MustCompile(`[\(\)\.a-zA-Z0-9_-]`).Match([]byte(value)); !matched {
    52  		es = append(es, fmt.Errorf("%q may only contain alphanumeric characters, dash, underscores, parentheses and periods", k))
    53  	}
    54  
    55  	return
    56  }
    57  
    58  func resourceArmResourceGroupCreate(d *schema.ResourceData, meta interface{}) error {
    59  	client := meta.(*ArmClient)
    60  	resGroupClient := client.resourceGroupClient
    61  
    62  	name := d.Get("name").(string)
    63  	location := d.Get("location").(string)
    64  
    65  	rg := resources.ResourceGroup{
    66  		Name:     &name,
    67  		Location: &location,
    68  	}
    69  
    70  	resp, err := resGroupClient.CreateOrUpdate(name, rg)
    71  	if err != nil {
    72  		return fmt.Errorf("Error issuing Azure ARM create request for resource group '%s': %s", name, err)
    73  	}
    74  
    75  	d.SetId(*resp.ID)
    76  
    77  	log.Printf("[DEBUG] Waiting for Resource Group (%s) to become available", name)
    78  	stateConf := &resource.StateChangeConf{
    79  		Pending: []string{"Accepted"},
    80  		Target:  "Succeeded",
    81  		Refresh: resourceGroupStateRefreshFunc(client, name),
    82  		Timeout: 10 * time.Minute,
    83  	}
    84  	if _, err := stateConf.WaitForState(); err != nil {
    85  		return fmt.Errorf("Error waiting for Resource Group (%s) to become available: %s", name, err)
    86  	}
    87  
    88  	return resourceArmResourceGroupRead(d, meta)
    89  }
    90  
    91  func resourceArmResourceGroupRead(d *schema.ResourceData, meta interface{}) error {
    92  	resGroupClient := meta.(*ArmClient).resourceGroupClient
    93  
    94  	id, err := parseAzureResourceID(d.Id())
    95  	if err != nil {
    96  		return err
    97  	}
    98  	name := id.ResourceGroup
    99  
   100  	res, err := resGroupClient.Get(name)
   101  	if err != nil {
   102  		if res.StatusCode == http.StatusNotFound {
   103  			d.SetId("")
   104  			return nil
   105  		}
   106  		return fmt.Errorf("Error issuing read request to Azure ARM for resource group '%s': %s", name, err)
   107  	}
   108  
   109  	d.Set("name", res.Name)
   110  	d.Set("location", res.Location)
   111  
   112  	return nil
   113  }
   114  
   115  func resourceArmResourceGroupExists(d *schema.ResourceData, meta interface{}) (bool, error) {
   116  	resGroupClient := meta.(*ArmClient).resourceGroupClient
   117  
   118  	id, err := parseAzureResourceID(d.Id())
   119  	if err != nil {
   120  		return false, err
   121  	}
   122  	name := id.ResourceGroup
   123  
   124  	resp, err := resGroupClient.CheckExistence(name)
   125  	if err != nil {
   126  		if resp.StatusCode != 200 {
   127  			return false, err
   128  		}
   129  
   130  		return true, nil
   131  	}
   132  
   133  	return true, nil
   134  }
   135  
   136  func resourceArmResourceGroupDelete(d *schema.ResourceData, meta interface{}) error {
   137  	resGroupClient := meta.(*ArmClient).resourceGroupClient
   138  
   139  	id, err := parseAzureResourceID(d.Id())
   140  	if err != nil {
   141  		return err
   142  	}
   143  	name := id.ResourceGroup
   144  
   145  	_, err = resGroupClient.Delete(name)
   146  	if err != nil {
   147  		return err
   148  	}
   149  
   150  	return nil
   151  }
   152  
   153  func resourceGroupStateRefreshFunc(client *ArmClient, id string) resource.StateRefreshFunc {
   154  	return func() (interface{}, string, error) {
   155  		res, err := client.resourceGroupClient.Get(id)
   156  		if err != nil {
   157  			return nil, "", fmt.Errorf("Error issuing read request in resourceGroupStateRefreshFunc to Azure ARM for resource group '%s': %s", id, err)
   158  		}
   159  
   160  		return res, *res.Properties.ProvisioningState, nil
   161  	}
   162  }