provider/azurerm: Load Balancer resources

builtin/providers/azurerm/loadbalancer.go

@@ -0,0 +1,144 @@
+package azurerm
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/Azure/azure-sdk-for-go/arm/network"
+	"github.com/hashicorp/errwrap"
+	"github.com/hashicorp/terraform/helper/resource"
+)
+
+func resourceGroupAndLBNameFromId(loadBalancerId string) (string, string, error) {
+	id, err := parseAzureResourceID(loadBalancerId)
+	if err != nil {
+		return "", "", err
+	}
+	name := id.Path["loadBalancers"]
+	resGroup := id.ResourceGroup
+
+	return resGroup, name, nil
+}
+
+func retrieveLoadbalancerById(loadBalancerId string, meta interface{}) (*network.LoadBalancer, bool, error) {
+	loadBalancerClient := meta.(*ArmClient).loadBalancerClient
+
+	resGroup, name, err := resourceGroupAndLBNameFromId(loadBalancerId)
+	if err != nil {
+		return nil, false, errwrap.Wrapf("Error Getting LoadBalancer Name and Group: {{err}}", err)
+	}
+
+	resp, err := loadBalancerClient.Get(resGroup, name, "")
+	if err != nil {
+		if resp.StatusCode == http.StatusNotFound {
+			return nil, false, nil
+		}
+		return nil, false, fmt.Errorf("Error making Read request on Azure LoadBalancer %s: %s", name, err)
+	}
+
+	return &resp, true, nil
+}
+
+func findLoadBalancerBackEndAddressPoolByName(lb *network.LoadBalancer, name string) (*network.BackendAddressPool, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.BackendAddressPools == nil {
+		return nil, -1, false
+	}
+
+	for i, apc := range *lb.Properties.BackendAddressPools {
+		if apc.Name != nil && *apc.Name == name {
+			return &apc, i, true
+		}
+	}
+
+	return nil, -1, false
+}
+
+func findLoadBalancerFrontEndIpConfigurationByName(lb *network.LoadBalancer, name string) (*network.FrontendIPConfiguration, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.FrontendIPConfigurations == nil {
+		return nil, -1, false
+	}
+
+	for i, feip := range *lb.Properties.FrontendIPConfigurations {
+		if feip.Name != nil && *feip.Name == name {
+			return &feip, i, true
+		}
+	}
+
+	return nil, -1, false
+}
+
+func findLoadBalancerRuleByName(lb *network.LoadBalancer, name string) (*network.LoadBalancingRule, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.LoadBalancingRules == nil {
+		return nil, -1, false
+	}
+
+	for i, lbr := range *lb.Properties.LoadBalancingRules {
+		if lbr.Name != nil && *lbr.Name == name {
+			return &lbr, i, true
+		}
+	}
+
+	return nil, -1, false
+}
+
+func findLoadBalancerNatRuleByName(lb *network.LoadBalancer, name string) (*network.InboundNatRule, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.InboundNatRules == nil {
+		return nil, -1, false
+	}
+
+	for i, nr := range *lb.Properties.InboundNatRules {
+		if nr.Name != nil && *nr.Name == name {
+			return &nr, i, true
+		}
+	}
+
+	return nil, -1, false
+}
+
+func findLoadBalancerNatPoolByName(lb *network.LoadBalancer, name string) (*network.InboundNatPool, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.InboundNatPools == nil {
+		return nil, -1, false
+	}
+
+	for i, np := range *lb.Properties.InboundNatPools {
+		if np.Name != nil && *np.Name == name {
+			return &np, i, true
+		}
+	}
+
+	return nil, -1, false
+}
+
+func findLoadBalancerProbeByName(lb *network.LoadBalancer, name string) (*network.Probe, int, bool) {
+	if lb == nil || lb.Properties == nil || lb.Properties.Probes == nil {
+		return nil, -1, false
+	}
+
+	for i, p := range *lb.Properties.Probes {
+		if p.Name != nil && *p.Name == name {
+			return &p, i, true
+		}
+	}
+
+	return nil, -1, false
+}
+
+func loadbalancerStateRefreshFunc(client *ArmClient, resourceGroupName string, loadbalancer string) resource.StateRefreshFunc {
+	return func() (interface{}, string, error) {
+		res, err := client.loadBalancerClient.Get(resourceGroupName, loadbalancer, "")
+		if err != nil {
+			return nil, "", fmt.Errorf("Error issuing read request in loadbalancerStateRefreshFunc to Azure ARM for LoadBalancer '%s' (RG: '%s'): %s", loadbalancer, resourceGroupName, err)
+		}
+
+		return res, *res.Properties.ProvisioningState, nil
+	}
+}
+
+func validateLoadbalancerPrivateIpAddressAllocation(v interface{}, k string) (ws []string, errors []error) {
+	value := strings.ToLower(v.(string))
+	if value != "static" && value != "dynamic" {
+		errors = append(errors, fmt.Errorf("LoadBalancer Allocations can only be Static or Dynamic"))
+	}
+	return
+}

builtin/providers/azurerm/provider.go

@@ -46,9 +46,17 @@ func Provider() terraform.ResourceProvider {
 
 		ResourcesMap: map[string]*schema.Resource{
 			// These resources use the Azure ARM SDK
-			"azurerm_availability_set":          resourceArmAvailabilitySet(),
-			"azurerm_cdn_endpoint":              resourceArmCdnEndpoint(),
-			"azurerm_cdn_profile":               resourceArmCdnProfile(),
+			"azurerm_availability_set": resourceArmAvailabilitySet(),
+			"azurerm_cdn_endpoint":     resourceArmCdnEndpoint(),
+			"azurerm_cdn_profile":      resourceArmCdnProfile(),
+
+			"azurerm_lb":                      resourceArmLoadbalancer(),
+			"azurerm_lb_backend_address_pool": resourceArmLoadbalancerBackendAddressPool(),
+			"azurerm_lb_nat_rule":             resourceArmLoadbalancerNatRule(),
+			"azurerm_lb_nat_pool":             resourceArmLoadbalancerNatPool(),
+			"azurerm_lb_probe":                resourceArmLoadbalancerProbe(),
+			"azurerm_lb_rule":                 resourceArmLoadbalancerRule(),
+
 			"azurerm_local_network_gateway":     resourceArmLocalNetworkGateway(),
 			"azurerm_network_interface":         resourceArmNetworkInterface(),
 			"azurerm_network_security_group":    resourceArmNetworkSecurityGroup(),