provider/azurerm: network interfaces and public IP support.

builtin/providers/azurerm/provider.go

@@ -40,6 +40,8 @@ func Provider() terraform.ResourceProvider {
 			"azurerm_resource_group":        resourceArmResourceGroup(),
 			"azurerm_virtual_network":       resourceArmVirtualNetwork(),
 			"azurerm_local_network_gateway": resourceArmLocalNetworkGateway(),
+			"azurerm_network_interface":     resourceArmNetworkInterface(),
+			"azurerm_public_ip":             resourceArmPublicIP(),
 		},
 
 		ConfigureFunc: providerConfigure,

builtin/providers/azurerm/resource_arm_network_interface.go

@@ -0,0 +1,374 @@
+package azurerm
+
+import (
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/Azure/azure-sdk-for-go/arm/network"
+	"github.com/hashicorp/terraform/helper/resource"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+// resourceArmNetworkInterface returns the *schema.Resource
+// associated to network interface resources on ARM.
+func resourceArmNetworkInterface() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceArmNetworkInterfaceCreate,
+		Read:   resourceArmNetworkInterfaceRead,
+		Update: resourceArmNetworkInterfaceCreate,
+		Delete: resourceArmNetworkInterfaceDelete,
+
+		Schema: map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"resource_group_name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"location": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"vm_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"mac_address": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"network_security_group_id": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+			},
+
+			"ip_config": &schema.Schema{
+				Type:     schema.TypeList,
+				Optional: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"id": &schema.Schema{
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"name": &schema.Schema{
+							Type:     schema.TypeString,
+							Required: true,
+							ForceNew: true,
+						},
+						"private_ip_address": &schema.Schema{
+							Type: schema.TypeString,
+							// required only when 'dynamic_provate_ip' is NOT set.
+							Optional:      true,
+							ConflictsWith: []string{"dynamic_private_ip"},
+						},
+						"dynamic_private_ip": &schema.Schema{
+							Type:          schema.TypeBool,
+							Optional:      true,
+							Default:       true,
+							ConflictsWith: []string{"private_ip_address"},
+						},
+						"subnet_id": &schema.Schema{
+							Type:     schema.TypeString,
+							Required: true,
+						},
+						"public_ip_id": &schema.Schema{
+							Type:     schema.TypeString,
+							Optional: true,
+						},
+						"load_balancer_backend_pool_ids": &schema.Schema{
+							Type:     schema.TypeList,
+							Optional: true,
+							Elem:     schema.TypeString,
+						},
+						"load_balancer_inbound_nat_rule_ids": &schema.Schema{
+							Type:     schema.TypeList,
+							Optional: true,
+							Elem:     schema.TypeString,
+						},
+					},
+				},
+			},
+
+			"dns_servers": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
+
+			"applied_dns_servers": &schema.Schema{
+				Type:     schema.TypeList,
+				Optional: true,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+			},
+
+			"internal_name": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"internal_fqdn": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+// resourceArmNetworkInterfaceCreate goes ahead and creates the specified ARM network interface.
+func resourceArmNetworkInterfaceCreate(d *schema.ResourceData, meta interface{}) error {
+	ifaceClient := meta.(*ArmClient).ifaceClient
+
+	name := d.Get("name").(string)
+	location := d.Get("location").(string)
+	resGrp := d.Get("resource_group_name").(string)
+	vmId := d.Get("vm_id").(string)
+	// TODO: netSecGrp := d.Get("network_security_group_id").(string)
+
+	// get dns servers:
+	var dnses []string
+	if v, ok := d.GetOk("dns_servers"); ok {
+		for _, dns := range v.([]interface{}) {
+			dnses = append(dnses, dns.(string))
+		}
+	}
+
+	// get applied dns servers:
+	var usedDnses []string
+	if v, ok := d.GetOk("applied_dns_servers"); ok {
+		for _, adns := range v.([]interface{}) {
+			usedDnses = append(usedDnses, adns.(string))
+		}
+	}
+
+	// get ip configurations:
+	var ipconfigs []network.InterfaceIPConfiguration
+	if configs := d.Get("ip_config").([]interface{}); len(configs) > 0 {
+		for _, ipconfig := range configs {
+			conf := ipconfig.(map[string]interface{})
+
+			name := conf["name"].(string)
+			sub := conf["subnet_id"].(string)
+
+			// set the allocation method and respective address:
+			var addr string
+			var allocMeth network.IPAllocationMethod
+			if b, ok := conf["dynamic_private_ip"]; ok && b.(bool) {
+				allocMeth = network.Dynamic
+				addr = ""
+			} else {
+				allocMeth = network.Static
+				addr = conf["private_ip_address"].(string)
+			}
+
+			// get the optional public IP to bind to:
+			var pubip string
+			if v, ok := conf["public_ip_id"]; ok {
+				pubip = v.(string)
+			}
+
+			// check and get the ids of the associated load balancer
+			// backend address pools:
+			var backpools []network.SubResource
+			if bps, ok := d.GetOk("load_balancer_backend_pool_ids"); ok {
+				for _, bp := range bps.([]interface{}) {
+					b := bp.(string)
+					backpools = append(backpools, network.SubResource{&b})
+				}
+			}
+
+			// now; check for any load balancer inbound nat rules:
+			var natrules []network.SubResource
+			if nrs, ok := d.GetOk("load_balancer_inbound_nat_rule_ids"); ok {
+				for _, nr := range nrs.([]interface{}) {
+					n := nr.(string)
+					natrules = append(natrules, network.SubResource{&n})
+				}
+			}
+
+			// finally, make and append the ipconfigs:
+			ipconfigs = append(ipconfigs, network.InterfaceIPConfiguration{
+				Name: &name,
+				Properties: &network.InterfaceIPConfigurationPropertiesFormat{
+					PrivateIPAddress:          &addr,
+					PrivateIPAllocationMethod: allocMeth,
+					Subnet:                          &network.SubResource{&sub},
+					PublicIPAddress:                 &network.SubResource{&pubip},
+					LoadBalancerBackendAddressPools: &backpools,
+					LoadBalancerInboundNatRules:     &natrules,
+				},
+			})
+		}
+	}
+
+	resp, err := ifaceClient.CreateOrUpdate(resGrp, name, network.Interface{
+		Name:     &name,
+		Location: &location,
+		Properties: &network.InterfacePropertiesFormat{
+			VirtualMachine:   &network.SubResource{&vmId},
+			IPConfigurations: &ipconfigs,
+			// TODO: NetworkSecurityGroup: &network.SubResource{&netSecGrp},
+			DNSSettings: &network.InterfaceDNSSettings{
+				DNSServers:        &dnses,
+				AppliedDNSServers: &usedDnses,
+			},
+		},
+	})
+	if err != nil {
+		return fmt.Errorf("Error encountered while issuing ARM interface %q creation: %s", name, err)
+	}
+
+	d.SetId(*resp.ID)
+
+	stateConf := &resource.StateChangeConf{
+		Pending: []string{"Accepted", "Updating"},
+		Target:  "Succeded",
+		Refresh: interfaceStateRefreshFunc(meta, name, resGrp),
+		Timeout: 10 * time.Minute,
+	}
+	if _, err := stateConf.WaitForState(); err != nil {
+		return fmt.Errorf("Error waiting for ARM interface %q creation: %s", name, err)
+	}
+
+	return resourceArmNetworkInterfaceRead(d, meta)
+}
+
+// resourceArmNetworkInterfaceRead goes ahead and reads the state of the corresponding ARM network interface.
+func resourceArmNetworkInterfaceRead(d *schema.ResourceData, meta interface{}) error {
+	ifaceClient := meta.(*ArmClient).ifaceClient
+
+	// parse the id to get the name of the interface
+	// and containing resource group:
+	id, err := parseAzureResourceID(d.Id())
+	if err != nil {
+		return fmt.Errorf("Error parsing id of ARM interface: %s", err)
+	}
+
+	resGrp := id.ResourceGroup
+	name := id.Path["networkInterfaces"]
+
+	// fetch the interface off Azure:
+	iface, err := ifaceClient.Get(resGrp, name)
+	if iface.StatusCode == http.StatusNotFound {
+		d.SetId("")
+		return nil
+	}
+	if err != nil {
+		return fmt.Errorf("Error reading the state of network interface %q off Azure: %s", name, err)
+	}
+
+	// now update all the variable fields:
+	props := *iface.Properties
+
+	d.Set("vm_id", *props.VirtualMachine.ID)
+	// TODO: d.Set("network_security_group_id", *props.NetworkSecurityGroup.ID)
+	d.Set("mac_address", *props.MacAddress)
+
+	// get the ip configs:
+	var ipConfigs []map[string]interface{}
+	for _, ipconf := range *props.IPConfigurations {
+		v := map[string]interface{}{}
+
+		v["id"] = *ipconf.ID
+		v["name"] = *ipconf.Name
+
+		// check for the allocation method and the address it could imply:
+		if ipconf.Properties.PrivateIPAllocationMethod == network.Static {
+			v["private_ip_address"] = *ipconf.Properties.PrivateIPAddress
+			v["dynamic_private_ip"] = false
+		} else { // guaranteed to be network.Dynamic
+			v["private_ip_address"] = ""
+			v["dynamic_private_ip"] = true
+		}
+
+		v["subnet_id"] = *ipconf.Properties.Subnet.ID
+		v["public_ip_id"] = *ipconf.Properties.PublicIPAddress.ID
+
+		// get the load balancer backpools and inbound nat rules:
+		var backpools []string
+		if bps := ipconf.Properties.LoadBalancerBackendAddressPools; bps != nil {
+			for _, bp := range *bps {
+				backpools = append(backpools, *bp.ID)
+			}
+
+			v["load_balancer_backend_pool_ids"] = backpools
+		} else {
+
+		}
+
+		var natrules []string
+		if nrs := ipconf.Properties.LoadBalancerInboundNatRules; nrs != nil {
+			for _, nr := range *nrs {
+				natrules = append(natrules, *nr.ID)
+			}
+
+			v["load_balancer_inbound_nat_rule_ids"] = natrules
+		}
+
+		// and finally, append the new list element:
+		ipConfigs = append(ipConfigs, v)
+	}
+	d.Set("ipConfig", ipConfigs)
+
+	// and finally; read the DNS settings:
+	d.Set("dns_servers", *iface.Properties.DNSSettings.DNSServers)
+	d.Set("applied_dns_servers", *iface.Properties.DNSSettings.AppliedDNSServers)
+	d.Set("internal_name", *iface.Properties.DNSSettings.InternalDNSNameLabel)
+	d.Set("internal_fqdn", *iface.Properties.DNSSettings.InternalFqdn)
+
+	return nil
+}
+
+// resourceArmNetworkInterfaceDelete deletes the specified ARM network interface.
+func resourceArmNetworkInterfaceDelete(d *schema.ResourceData, meta interface{}) error {
+	ifaceClient := meta.(*ArmClient).ifaceClient
+
+	// fetch the name of the network interface and the containing
+	// resource group from the given parser.
+	id, err := parseAzureResourceID(d.Id())
+	if err != nil {
+		return fmt.Errorf("Error parsing ID of ARM network interface: %s")
+	}
+	resGrp := id.ResourceGroup
+	name := id.Path["networkInterfaces"]
+
+	// then, issue the actual deletion:
+	resp, err := ifaceClient.Delete(resGrp, name)
+	if resp.StatusCode == http.StatusNotFound {
+		return nil
+	}
+	if err != nil {
+		return fmt.Errorf("Error issuing deletion fo ARM network interface %q: %s", name, err)
+	}
+
+	return nil
+}
+
+// interfaceStateRefreshFunc returns the resource.StateRefreshFunc for the
+// given interface under the given resource group.
+func interfaceStateRefreshFunc(meta interface{}, name, resGrp string) resource.StateRefreshFunc {
+	return func() (interface{}, string, error) {
+		resp, err := meta.(*ArmClient).ifaceClient.Get(resGrp, name)
+		if err != nil {
+			return nil, "", err
+		}
+
+		return resp, *resp.Properties.ProvisioningState, nil
+	}
+}