github.com/bpineau/terraform@v0.8.0-rc1.0.20161126184705-a8886012d185/builtin/providers/azurerm/resource_arm_sql_server.go (about)

     1  package azurerm
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/hashicorp/terraform/helper/schema"
     8  	"github.com/jen20/riviera/azure"
     9  	"github.com/jen20/riviera/sql"
    10  )
    11  
    12  func resourceArmSqlServer() *schema.Resource {
    13  	return &schema.Resource{
    14  		Create: resourceArmSqlServerCreate,
    15  		Read:   resourceArmSqlServerRead,
    16  		Update: resourceArmSqlServerCreate,
    17  		Delete: resourceArmSqlServerDelete,
    18  		Importer: &schema.ResourceImporter{
    19  			State: schema.ImportStatePassthrough,
    20  		},
    21  
    22  		Schema: map[string]*schema.Schema{
    23  			"name": &schema.Schema{
    24  				Type:     schema.TypeString,
    25  				Required: true,
    26  				ForceNew: true,
    27  			},
    28  
    29  			"location": &schema.Schema{
    30  				Type:      schema.TypeString,
    31  				Required:  true,
    32  				ForceNew:  true,
    33  				StateFunc: azureRMNormalizeLocation,
    34  			},
    35  
    36  			"resource_group_name": &schema.Schema{
    37  				Type:     schema.TypeString,
    38  				Required: true,
    39  				ForceNew: true,
    40  			},
    41  
    42  			"version": &schema.Schema{
    43  				Type:     schema.TypeString,
    44  				Required: true,
    45  			},
    46  
    47  			"administrator_login": &schema.Schema{
    48  				Type:     schema.TypeString,
    49  				Required: true,
    50  			},
    51  
    52  			"administrator_login_password": &schema.Schema{
    53  				Type:     schema.TypeString,
    54  				Required: true,
    55  			},
    56  
    57  			"fully_qualified_domain_name": &schema.Schema{
    58  				Type:     schema.TypeString,
    59  				Computed: true,
    60  			},
    61  
    62  			"tags": tagsSchema(),
    63  		},
    64  	}
    65  }
    66  
    67  func resourceArmSqlServerCreate(d *schema.ResourceData, meta interface{}) error {
    68  	client := meta.(*ArmClient)
    69  	rivieraClient := client.rivieraClient
    70  
    71  	tags := d.Get("tags").(map[string]interface{})
    72  	expandedTags := expandTags(tags)
    73  
    74  	createRequest := rivieraClient.NewRequest()
    75  	createRequest.Command = &sql.CreateOrUpdateServer{
    76  		Name:                       d.Get("name").(string),
    77  		Location:                   d.Get("location").(string),
    78  		ResourceGroupName:          d.Get("resource_group_name").(string),
    79  		AdministratorLogin:         azure.String(d.Get("administrator_login").(string)),
    80  		AdministratorLoginPassword: azure.String(d.Get("administrator_login_password").(string)),
    81  		Version:                    azure.String(d.Get("version").(string)),
    82  		Tags:                       *expandedTags,
    83  	}
    84  
    85  	createResponse, err := createRequest.Execute()
    86  	if err != nil {
    87  		return fmt.Errorf("Error creating SQL Server: %s", err)
    88  	}
    89  	if !createResponse.IsSuccessful() {
    90  		return fmt.Errorf("Error creating SQL Server: %s", createResponse.Error)
    91  	}
    92  
    93  	readRequest := rivieraClient.NewRequest()
    94  	readRequest.Command = &sql.GetServer{
    95  		Name:              d.Get("name").(string),
    96  		ResourceGroupName: d.Get("resource_group_name").(string),
    97  	}
    98  
    99  	readResponse, err := readRequest.Execute()
   100  	if err != nil {
   101  		return fmt.Errorf("Error reading SQL Server: %s", err)
   102  	}
   103  	if !readResponse.IsSuccessful() {
   104  		return fmt.Errorf("Error reading SQL Server: %s", readResponse.Error)
   105  	}
   106  
   107  	resp := readResponse.Parsed.(*sql.GetServerResponse)
   108  	d.SetId(*resp.ID)
   109  
   110  	return resourceArmSqlServerRead(d, meta)
   111  }
   112  
   113  func resourceArmSqlServerRead(d *schema.ResourceData, meta interface{}) error {
   114  	client := meta.(*ArmClient)
   115  	rivieraClient := client.rivieraClient
   116  
   117  	id, err := parseAzureResourceID(d.Id())
   118  	if err != nil {
   119  		return err
   120  	}
   121  
   122  	readRequest := rivieraClient.NewRequestForURI(d.Id())
   123  	readRequest.Command = &sql.GetServer{}
   124  
   125  	readResponse, err := readRequest.Execute()
   126  	if err != nil {
   127  		return fmt.Errorf("Error reading SQL Server: %s", err)
   128  	}
   129  	if !readResponse.IsSuccessful() {
   130  		log.Printf("[INFO] Error reading SQL Server %q - removing from state", d.Id())
   131  		d.SetId("")
   132  		return fmt.Errorf("Error reading SQL Server: %s", readResponse.Error)
   133  	}
   134  
   135  	resp := readResponse.Parsed.(*sql.GetServerResponse)
   136  
   137  	d.Set("name", id.Path["servers"])
   138  	d.Set("resource_group_name", id.ResourceGroup)
   139  	d.Set("location", azureRMNormalizeLocation(*resp.Location))
   140  	d.Set("fully_qualified_domain_name", resp.FullyQualifiedDomainName)
   141  	d.Set("administrator_login", resp.AdministratorLogin)
   142  	d.Set("version", resp.Version)
   143  
   144  	flattenAndSetTags(d, resp.Tags)
   145  
   146  	return nil
   147  }
   148  
   149  func resourceArmSqlServerDelete(d *schema.ResourceData, meta interface{}) error {
   150  	client := meta.(*ArmClient)
   151  	rivieraClient := client.rivieraClient
   152  
   153  	deleteRequest := rivieraClient.NewRequestForURI(d.Id())
   154  	deleteRequest.Command = &sql.DeleteServer{}
   155  
   156  	deleteResponse, err := deleteRequest.Execute()
   157  	if err != nil {
   158  		return fmt.Errorf("Error deleting SQL Server: %s", err)
   159  	}
   160  	if !deleteResponse.IsSuccessful() {
   161  		return fmt.Errorf("Error deleting SQL Server: %s", deleteResponse.Error)
   162  	}
   163  
   164  	return nil
   165  }