github.com/recobe182/terraform@v0.8.5-0.20170117231232-49ab22a935b7/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": locationSchema(),
    30  
    31  			"resource_group_name": &schema.Schema{
    32  				Type:     schema.TypeString,
    33  				Required: true,
    34  				ForceNew: true,
    35  			},
    36  
    37  			"version": &schema.Schema{
    38  				Type:     schema.TypeString,
    39  				Required: true,
    40  			},
    41  
    42  			"administrator_login": &schema.Schema{
    43  				Type:     schema.TypeString,
    44  				Required: true,
    45  			},
    46  
    47  			"administrator_login_password": &schema.Schema{
    48  				Type:     schema.TypeString,
    49  				Required: true,
    50  			},
    51  
    52  			"fully_qualified_domain_name": &schema.Schema{
    53  				Type:     schema.TypeString,
    54  				Computed: true,
    55  			},
    56  
    57  			"tags": tagsSchema(),
    58  		},
    59  	}
    60  }
    61  
    62  func resourceArmSqlServerCreate(d *schema.ResourceData, meta interface{}) error {
    63  	client := meta.(*ArmClient)
    64  	rivieraClient := client.rivieraClient
    65  
    66  	tags := d.Get("tags").(map[string]interface{})
    67  	expandedTags := expandTags(tags)
    68  
    69  	createRequest := rivieraClient.NewRequest()
    70  	createRequest.Command = &sql.CreateOrUpdateServer{
    71  		Name:                       d.Get("name").(string),
    72  		Location:                   d.Get("location").(string),
    73  		ResourceGroupName:          d.Get("resource_group_name").(string),
    74  		AdministratorLogin:         azure.String(d.Get("administrator_login").(string)),
    75  		AdministratorLoginPassword: azure.String(d.Get("administrator_login_password").(string)),
    76  		Version:                    azure.String(d.Get("version").(string)),
    77  		Tags:                       *expandedTags,
    78  	}
    79  
    80  	createResponse, err := createRequest.Execute()
    81  	if err != nil {
    82  		return fmt.Errorf("Error creating SQL Server: %s", err)
    83  	}
    84  	if !createResponse.IsSuccessful() {
    85  		return fmt.Errorf("Error creating SQL Server: %s", createResponse.Error)
    86  	}
    87  
    88  	readRequest := rivieraClient.NewRequest()
    89  	readRequest.Command = &sql.GetServer{
    90  		Name:              d.Get("name").(string),
    91  		ResourceGroupName: d.Get("resource_group_name").(string),
    92  	}
    93  
    94  	readResponse, err := readRequest.Execute()
    95  	if err != nil {
    96  		return fmt.Errorf("Error reading SQL Server: %s", err)
    97  	}
    98  	if !readResponse.IsSuccessful() {
    99  		return fmt.Errorf("Error reading SQL Server: %s", readResponse.Error)
   100  	}
   101  
   102  	resp := readResponse.Parsed.(*sql.GetServerResponse)
   103  	d.SetId(*resp.ID)
   104  
   105  	return resourceArmSqlServerRead(d, meta)
   106  }
   107  
   108  func resourceArmSqlServerRead(d *schema.ResourceData, meta interface{}) error {
   109  	client := meta.(*ArmClient)
   110  	rivieraClient := client.rivieraClient
   111  
   112  	id, err := parseAzureResourceID(d.Id())
   113  	if err != nil {
   114  		return err
   115  	}
   116  
   117  	readRequest := rivieraClient.NewRequestForURI(d.Id())
   118  	readRequest.Command = &sql.GetServer{}
   119  
   120  	readResponse, err := readRequest.Execute()
   121  	if err != nil {
   122  		return fmt.Errorf("Error reading SQL Server: %s", err)
   123  	}
   124  	if !readResponse.IsSuccessful() {
   125  		log.Printf("[INFO] Error reading SQL Server %q - removing from state", d.Id())
   126  		d.SetId("")
   127  		return fmt.Errorf("Error reading SQL Server: %s", readResponse.Error)
   128  	}
   129  
   130  	resp := readResponse.Parsed.(*sql.GetServerResponse)
   131  
   132  	d.Set("name", id.Path["servers"])
   133  	d.Set("resource_group_name", id.ResourceGroup)
   134  	d.Set("location", azureRMNormalizeLocation(*resp.Location))
   135  	d.Set("fully_qualified_domain_name", resp.FullyQualifiedDomainName)
   136  	d.Set("administrator_login", resp.AdministratorLogin)
   137  	d.Set("version", resp.Version)
   138  
   139  	flattenAndSetTags(d, resp.Tags)
   140  
   141  	return nil
   142  }
   143  
   144  func resourceArmSqlServerDelete(d *schema.ResourceData, meta interface{}) error {
   145  	client := meta.(*ArmClient)
   146  	rivieraClient := client.rivieraClient
   147  
   148  	deleteRequest := rivieraClient.NewRequestForURI(d.Id())
   149  	deleteRequest.Command = &sql.DeleteServer{}
   150  
   151  	deleteResponse, err := deleteRequest.Execute()
   152  	if err != nil {
   153  		return fmt.Errorf("Error deleting SQL Server: %s", err)
   154  	}
   155  	if !deleteResponse.IsSuccessful() {
   156  		return fmt.Errorf("Error deleting SQL Server: %s", deleteResponse.Error)
   157  	}
   158  
   159  	return nil
   160  }