[WIP] : Azure Load Balancer with separated resource

builtin/providers/azurerm/provider.go

@@ -47,37 +47,41 @@ func Provider() terraform.ResourceProvider {
 		},
 
 		ResourcesMap: map[string]*schema.Resource{
-			"azurerm_availability_set":       resourceArmAvailabilitySet(),
-			"azurerm_cdn_endpoint":           resourceArmCdnEndpoint(),
-			"azurerm_cdn_profile":            resourceArmCdnProfile(),
-			"azurerm_dns_a_record":           resourceArmDnsARecord(),
-			"azurerm_dns_aaaa_record":        resourceArmDnsAAAARecord(),
-			"azurerm_dns_cname_record":       resourceArmDnsCNameRecord(),
-			"azurerm_dns_mx_record":          resourceArmDnsMxRecord(),
-			"azurerm_dns_ns_record":          resourceArmDnsNsRecord(),
-			"azurerm_dns_srv_record":         resourceArmDnsSrvRecord(),
-			"azurerm_dns_txt_record":         resourceArmDnsTxtRecord(),
-			"azurerm_dns_zone":               resourceArmDnsZone(),
-			"azurerm_local_network_gateway":  resourceArmLocalNetworkGateway(),
-			"azurerm_network_interface":      resourceArmNetworkInterface(),
-			"azurerm_network_security_group": resourceArmNetworkSecurityGroup(),
-			"azurerm_network_security_rule":  resourceArmNetworkSecurityRule(),
-			"azurerm_public_ip":              resourceArmPublicIp(),
-			"azurerm_resource_group":         resourceArmResourceGroup(),
-			"azurerm_route":                  resourceArmRoute(),
-			"azurerm_route_table":            resourceArmRouteTable(),
-			"azurerm_search_service":         resourceArmSearchService(),
-			"azurerm_sql_database":           resourceArmSqlDatabase(),
-			"azurerm_sql_firewall_rule":      resourceArmSqlFirewallRule(),
-			"azurerm_sql_server":             resourceArmSqlServer(),
-			"azurerm_storage_account":        resourceArmStorageAccount(),
-			"azurerm_storage_blob":           resourceArmStorageBlob(),
-			"azurerm_storage_container":      resourceArmStorageContainer(),
-			"azurerm_storage_queue":          resourceArmStorageQueue(),
-			"azurerm_subnet":                 resourceArmSubnet(),
-			"azurerm_template_deployment":    resourceArmTemplateDeployment(),
-			"azurerm_virtual_machine":        resourceArmVirtualMachine(),
-			"azurerm_virtual_network":        resourceArmVirtualNetwork(),
+			"azurerm_availability_set":           resourceArmAvailabilitySet(),
+			"azurerm_cdn_endpoint":               resourceArmCdnEndpoint(),
+			"azurerm_cdn_profile":                resourceArmCdnProfile(),
+			"azurerm_dns_a_record":               resourceArmDnsARecord(),
+			"azurerm_dns_aaaa_record":            resourceArmDnsAAAARecord(),
+			"azurerm_dns_cname_record":           resourceArmDnsCNameRecord(),
+			"azurerm_dns_mx_record":              resourceArmDnsMxRecord(),
+			"azurerm_dns_ns_record":              resourceArmDnsNsRecord(),
+			"azurerm_dns_srv_record":             resourceArmDnsSrvRecord(),
+			"azurerm_dns_txt_record":             resourceArmDnsTxtRecord(),
+			"azurerm_dns_zone":                   resourceArmDnsZone(),
+			"azurerm_load_balancer":              resourceArmLoadBalancer(),
+			"azurerm_load_balancer_rule":         resourceArmLbRule(),
+			"azurerm_load_balancer_probe":        resourceArmProbe(),
+			"azurerm_load_balancer_backend_pool": resourceArmBackendPool(),
+			"azurerm_local_network_gateway":      resourceArmLocalNetworkGateway(),
+			"azurerm_network_interface":          resourceArmNetworkInterface(),
+			"azurerm_network_security_group":     resourceArmNetworkSecurityGroup(),
+			"azurerm_network_security_rule":      resourceArmNetworkSecurityRule(),
+			"azurerm_public_ip":                  resourceArmPublicIp(),
+			"azurerm_resource_group":             resourceArmResourceGroup(),
+			"azurerm_route":                      resourceArmRoute(),
+			"azurerm_route_table":                resourceArmRouteTable(),
+			"azurerm_search_service":             resourceArmSearchService(),
+			"azurerm_sql_database":               resourceArmSqlDatabase(),
+			"azurerm_sql_firewall_rule":          resourceArmSqlFirewallRule(),
+			"azurerm_sql_server":                 resourceArmSqlServer(),
+			"azurerm_storage_account":            resourceArmStorageAccount(),
+			"azurerm_storage_blob":               resourceArmStorageBlob(),
+			"azurerm_storage_container":          resourceArmStorageContainer(),
+			"azurerm_storage_queue":              resourceArmStorageQueue(),
+			"azurerm_subnet":                     resourceArmSubnet(),
+			"azurerm_template_deployment":        resourceArmTemplateDeployment(),
+			"azurerm_virtual_machine":            resourceArmVirtualMachine(),
+			"azurerm_virtual_network":            resourceArmVirtualNetwork(),
 		},
 		ConfigureFunc: providerConfigure,
 	}

builtin/providers/azurerm/resource_arm_load_balancer.go

@@ -0,0 +1,233 @@
+package azurerm
+
+import (
+	"fmt"
+	"github.com/Azure/azure-sdk-for-go/arm/network"
+	"github.com/hashicorp/terraform/helper/schema"
+	"log"
+)
+
+func resourceArmLoadBalancer() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceArmLoadBalancerCreate,
+		Read:   resourceArmLoadBalancerRead,
+		Update: resourceArmLoadBalancerUpdate,
+		Delete: resourceArmLoadBalancerDelete,
+
+		Schema: map[string]*schema.Schema{
+			"id": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"type": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+
+			"resource_group_name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+
+			"location": &schema.Schema{
+				Type:      schema.TypeString,
+				Required:  true,
+				StateFunc: azureRMNormalizeLocation,
+			},
+			"frontend_ip_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"frontend_ip_name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"frontend_ip_subnet_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+
+			"frontend_ip_private_ip_address": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+
+			"frontend_ip_public_ip_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+
+			"frontend_ip_private_ip_allocation": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"tags": tagsSchema(),
+		},
+	}
+}
+
+func resourceArmLoadBalancerCreate(d *schema.ResourceData, meta interface{}) error {
+	log.Printf("[resourceArmLoadBalancer] resourceArmLoadBalancerCreate[enter]")
+	defer log.Printf("[resourceArmLoadBalancer] resourceArmLoadBalancerCreate[exit]")
+
+	lbClient := meta.(*ArmClient).loadBalancerClient
+
+	// first; fetch a bunch of fields:
+	typ := d.Get("type").(string)
+	name := d.Get("name").(string)
+	location := d.Get("location").(string)
+	resGrp := d.Get("resource_group_name").(string)
+	tags := d.Get("tags").(map[string]interface{})
+
+	ipConfs, err := expandArmFrontendIp(d)
+	ipProps := network.LoadBalancerPropertiesFormat{FrontendIPConfigurations: ipConfs}
+
+	if err != nil {
+		return err
+	}
+
+	loadBalancer := network.LoadBalancer{
+		Name:       &name,
+		Type:       &typ,
+		Location:   &location,
+		Tags:       expandTags(tags),
+		Properties: &ipProps,
+	}
+
+	resp, err := lbClient.CreateOrUpdate(resGrp, name, loadBalancer)
+	if err != nil {
+		log.Printf("[resourceArmLoadBalancer] ERROR LB got status %s", err.Error())
+		return fmt.Errorf("Error issuing Azure ARM creation request for load balancer '%s': %s", name, err)
+	}
+
+	return ResourceArmLoadBalancerSetFromResponse(d, &resp)
+}
+
+func resourceArmLoadBalancerUpdate(d *schema.ResourceData, meta interface{}) error {
+	log.Printf("[resourceArmSimpleLb] resourceArmLoadBalancerUpdate[enter]")
+	defer log.Printf("[resourceArmSimpleLb] resourceArmLoadBalancerUpdate[exit]")
+	return resourceArmLoadBalancerCreate(d, meta)
+}
+
+func resourceArmLoadBalancerDelete(d *schema.ResourceData, meta interface{}) error {
+	log.Printf("[resourceArmLoadBalancer] resourceArmLoadBalancerDelete[enter]")
+	defer log.Printf("[resourceArmLoadBalancer] resourceArmLoadBalancerDelete[exit]")
+
+	lbClient := meta.(*ArmClient).loadBalancerClient
+
+	name := d.Get("name").(string)
+	resGroup := d.Get("resource_group_name").(string)
+
+	log.Printf("[INFO] Issuing deletion request to Azure ARM for load balancer '%s'.", name)
+
+	resp, err := lbClient.Delete(resGroup, name)
+	if err != nil {
+		return fmt.Errorf("Error issuing Azure ARM delete request for load balancer '%s': %s", name, err)
+	}
+
+	log.Printf("[resourceArmLoadBalancer] delete response %d %s", resp.StatusCode, resp.Status)
+
+	return nil
+}
+
+// resourceArmLoadBalancerRead goes ahead and reads the state of the corresponding ARM load balancer.
+func ResourceArmLoadBalancerSetFromResponse(d *schema.ResourceData, loadBalancer *network.LoadBalancer) error {
+	log.Printf("[resourceArmLoadBalancer] iResourceArmLoadBalancerRead[enter]")
+	defer log.Printf("[resourceArmLoadBalancer] iResourceArmLoadBalancerRead[exit]")
+
+	d.Set("location", loadBalancer.Location)
+	d.Set("type", loadBalancer.Type)
+	flattenAndSetTags(d, loadBalancer.Tags)
+	err := flattenArmFrontendIps(d, loadBalancer.Properties.FrontendIPConfigurations)
+	if err != nil {
+		return err
+	}
+	d.SetId(*loadBalancer.ID)
+
+	return nil
+}
+
+// resourceArmLoadBalancerRead goes ahead and reads the state of the corresponding ARM load balancer.
+func resourceArmLoadBalancerRead(d *schema.ResourceData, meta interface{}) error {
+	log.Printf("[resourceArmLoadBalancer] resourceArmSimpleLbRead[enter]")
+	defer log.Printf("[resourceArmLoadBalancer] resourceArmSimpleLbRead[exit]")
+	lbClient := meta.(*ArmClient).loadBalancerClient
+
+	name := d.Get("name").(string)
+	resGrp := d.Get("resource_group_name").(string)
+
+	log.Printf("[INFO] Issuing read request of load balancer '%s' off Azure.", name)
+
+	loadBalancer, err := lbClient.Get(resGrp, name, "")
+	if err != nil {
+		return fmt.Errorf("Error reading the state of the load balancer off Azure: %s", err)
+	}
+	return ResourceArmLoadBalancerSetFromResponse(d, &loadBalancer)
+}
+
+func expandArmFrontendIp(d *schema.ResourceData) (*[]network.FrontendIPConfiguration, error) {
+	frontendProperties := network.FrontendIPConfigurationPropertiesFormat{}
+	frontendName := d.Get("frontend_ip_name").(string)
+	subnetId := d.Get("frontend_ip_subnet_id").(string)
+	publicIpId := d.Get("frontend_ip_public_ip_id").(string)
+	privateIpAddress := d.Get("frontend_ip_private_ip_address").(string)
+	privateIpAllocation := d.Get("frontend_ip_private_ip_address").(string)
+
+	if subnetId != "" && publicIpId != "" {
+		return nil, fmt.Errorf("The frontend IP configuration %s cannot use both a subnet and a public IP address", frontendName)
+	}
+
+	if subnetId != "" {
+		frontendProperties.Subnet = &network.Subnet{ID: &subnetId}
+	}
+	if publicIpId != "" {
+		frontendProperties.PublicIPAddress = &network.PublicIPAddress{ID: &publicIpId}
+	}
+	if privateIpAddress != "" {
+		frontendProperties.PrivateIPAddress = &privateIpAddress
+	}
+	if privateIpAllocation != "" {
+		frontendProperties.PrivateIPAllocationMethod = network.IPAllocationMethod(privateIpAllocation)
+	}
+
+	frontendIpConf := network.FrontendIPConfiguration{
+		Name:       &frontendName,
+		Properties: &frontendProperties,
+	}
+
+	return &[]network.FrontendIPConfiguration{frontendIpConf}, nil
+}
+
+func flattenArmFrontendIps(d *schema.ResourceData, frontendIps *[]network.FrontendIPConfiguration) error {
+
+	if len(*frontendIps) != 1 {
+		return fmt.Errorf("The load balancer must have exactly 1 frontend IP")
+	}
+
+	fIpConf := (*frontendIps)[0]
+	if fIpConf.Properties.Subnet != nil && fIpConf.Properties.Subnet.ID != nil {
+		d.Set("frontend_ip_subnet_id", *fIpConf.Properties.Subnet.ID)
+	}
+	if fIpConf.Properties.PublicIPAddress != nil && fIpConf.Properties.PublicIPAddress.ID != nil {
+		d.Set("frontend_ip_public_ip_id", *fIpConf.Properties.PublicIPAddress.ID)
+	}
+	if fIpConf.Properties.PrivateIPAddress != nil {
+		d.Set("frontend_ip_private_ip_address", *fIpConf.Properties.PrivateIPAddress)
+	}
+
+	d.Set("frontend_ip_name", *fIpConf.Name)
+	d.Set("frontend_ip_id", *fIpConf.ID)
+	d.Set("frontend_ip_private_ip_allocation", string(fIpConf.Properties.PrivateIPAllocationMethod))
+
+	return nil
+}