chef-provisioning-azurerm 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7da0fd81aef0e92d574dc529def0eed41cda66ad
-  data.tar.gz: dc963917313890dc4deca22f3654063e19993ac2
+  metadata.gz: e622074ff9caf91886b46f9ed52ea099edbe0a6a
+  data.tar.gz: 6a1295a76fda9698d7c7ee3a42c8b1492e621d8c
 SHA512:
-  metadata.gz: 63fd59b7295bafbc79bd840e5752a81eef01a1fb57ed4014d9e4332bd920b9b3c044001d1cc5637336a768ce944f88ab9f47d754fa303f53e0c2556d8c4a80f4
-  data.tar.gz: 72f6bcf3afde3b61a7787cab7a1d218ca8fc93842e86a232e03e7f8d434e2788ba99e17dc3f1198a3bc13b190f4aab4b626c791735134bd9069b3c1b94b84ff0
+  metadata.gz: af8e73f71ed1882a3c760101a55a4ed4cb91b5985edc7d60be0ede524c25a5d2afcef7e699b20059e67029e3cdc780221f6007ef98c2f84f9d4434db55c98fdd
+  data.tar.gz: a7ca2425c44dcf520bd37a564a5d015a7ac7e2e36c4d058138f3b11ae1fa06384c899a05a53176312383d7f47d7d73c03e37a3939ae4ad70a5e07d776541d006

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # chef-provisioning-azurerm Changelog
 
+## [0.3.2] - 2015-10-07
+### Changed
+- References to Azure SDK updated, supports Linux
+- Adding more resources
+
 ## [0.3.1] - 2015-09-05
 ### Changed
 - :destroy action on azure_resource_group now correctly detects existence of resource group before attempting deletion

data/README.md

@@ -60,15 +60,15 @@ The following resources are provided:
 - azure_resource_group
 - azure_resource_template
 - azure_storage_account
+- azure_virtual_network
+- azure_network_interface
+- azure_public_ip_address
 
 The following resources are planned (note: these resources may be renamed as they are implemented):
 
-- azure_virtual_network
 - azure_availability_set
 - azure_load_balancer
-- azure_network_interface
 - azure_network_security_group
-- azure_public_ip_address
 - azure_virtual_machine
 - PaaS resources such as TrafficManager, SQL Server etc.
 
@@ -141,6 +141,86 @@ azure_storage_account 'mystorageaccount02' do
 end
 ```
  
+## Example Recipe 3 - deployment of Virtual Network
+This example creates a virtual network named 'myvnet' in the pendrica-demo 
+resource group in the West US region.  This virtual network contains 4 subnets
+in the 10.123.123.0/24 CIDR block.  The specified DNS servers will be used
+used by VMs in this virtual network.
+
+**Note that if dns_servers are not specified, the default azure dns will
+be used.
+
+### example3.rb
+
+```ruby
+require 'chef/provisioning/azurerm'
+with_driver 'AzureRM:abcd1234-YOUR-GUID-HERE-abcdef123456'
+
+azure_resource_group 'pendrica-demo' do
+  location 'West US'
+end
+
+azure_virtual_network 'myvnet' do
+  action :create
+  resource_group 'pendrica-demo'
+  location 'West US'
+  address_prefixes ['10.123.123.0/24' ] 
+  subnets [
+  { name: 'infrastructure', address_prefix: '10.123.123.0/28' },
+  { name: 'data', address_prefix: '10.123.123.32/27' },
+  { name: 'app', address_prefix: '10.123.123.64/26' },
+  { name: 'web', address_prefix: '10.123.123.128/25' },
+  ]
+  dns_servers ['10.123.123.5', '10.123.123.6']
+  tags environment: 'test', 
+       owner: 'jsmyth'  
+end
+
+
+```
+
+## Example Recipe 4 - deployment of Network Interface
+This example creates a network interface named mynic2 on  the 'web' subnet of a virtual network named 'myvnet'.  
+
+### example4.rb
+
+```ruby
+azure_network_interface 'mynic2' do
+  action :create
+  resource_group 'pendrica-demo'
+  location 'West US'
+  virtual_network 'myvnet'
+  subnet 'web' 
+end
+```
+
+## Example Recipe 5 - deployment of Network Interface with a private static address and a public IP
+This example creates a network interface named mynic on the 'web' subnet of a virtual network named 'myvnet'.  This interface
+has a statically assigned IP address and dns servers, as well as a dynamically assigned Public IP address.
+
+### example5.rb
+
+```ruby
+azure_network_interface 'mynic' do
+  action :create
+  resource_group 'pendrica-demo'
+  location 'West US'
+  virtual_network 'myvnet'
+  subnet 'web' 
+  private_ip_allocation_method 'static'
+  private_ip_address '10.123.123.250'
+  dns_servers ['10.123.123.5', '10.123.123.6']
+  public_ip 'mynic-pip' do
+    public_ip_allocation_method 'dynamic'
+    domain_name_label 'mydnsname'
+    idle_timeout_in_minutes 15
+    tags environment: 'test', 
+        owner: 'jsmyth'  
+  end
+end
+
+```
+
 ## Contributing
 
 Contributions to the project are welcome via submitting Pull Requests.

data/lib/chef/provider/azure_network_interface.rb

@@ -0,0 +1,159 @@
+require 'chef/provisioning/azurerm/azure_provider'
+
+class Chef
+  class Provider
+    class AzureNetworkInterface < Chef::Provisioning::AzureRM::AzureProvider
+      provides :azure_network_interface
+
+      def whyrun_supported?
+        true
+      end
+
+      action :create do
+        network_interface_exists = does_network_interface_exist
+        if network_interface_exists
+          converge_by("update network interface #{new_resource.name}") do
+            # currently, we let ARM manage the idempotence, so crete and update are the same
+            new_resource.public_ip_resource.run_action(:create) if new_resource.public_ip_resource
+            create_or_update_network_interface # are create and update different (and should they be??)
+          end
+        else
+          converge_by("create network interface #{new_resource.name}") do
+            new_resource.public_ip_resource.run_action(:create) if new_resource.public_ip_resource
+            create_or_update_network_interface
+          end
+        end
+      end
+
+      action :destroy do
+        converge_by("destroy network interface: #{new_resource.name}") do
+          if does_network_interface_exist
+            destroy_network_interface
+            new_resource.public_ip_resource.run_action(:destroy) if new_resource.public_ip_resource
+          else
+            action_handler.report_progress "network interface #{new_resource.name} was not found."
+          end
+        end
+      end
+
+      def load_current_resource
+        if new_resource.public_ip_resource
+          new_resource.public_ip_resource.location(new_resource.location)
+          new_resource.public_ip_resource.resource_group(new_resource.resource_group) unless new_resource.public_ip_resource.resource_group
+        end
+      end
+
+      def does_network_interface_exist
+        network_interface_list = try_azure_operation('enumerating network interfaces') do
+          network_management_client.network_interfaces.list(new_resource.resource_group).value!
+        end
+
+        network_interface_list.body.value.each do |network_interface|
+          return true if network_interface.name == new_resource.name
+        end
+        false
+      end
+
+      def destroy_network_interface
+        action_handler.report_progress 'Destroying network interface...'
+        try_azure_operation 'destroying network interface' do
+          network_management_client.network_interfaces.delete(new_resource.resource_group, new_resource.name).value!
+        end
+      end
+
+      def create_or_update_network_interface
+        network_interface_params = create_network_interface_params
+        action_handler.report_progress 'Creating or Updating network interface...'
+        try_azure_operation 'Creating or Updating network interface' do
+          network_management_client.network_interfaces.create_or_update(new_resource.resource_group, new_resource.name, network_interface_params).value!
+        end
+      end
+
+      def create_network_interface_params
+        network_interface = create_network_interface(new_resource.name, new_resource.tags, new_resource.location)
+
+        new_resource.virtual_network_resource_group(new_resource.resource_group) unless new_resource.virtual_network_resource_group
+        subnet_ref = get_subnet_ref(new_resource.virtual_network_resource_group,
+                                    new_resource.virtual_network, new_resource.subnet)
+
+        if new_resource.public_ip_resource
+          public_ip_ref = get_public_ip(new_resource.public_ip_resource.resource_group, new_resource.public_ip_resource.name)
+        end
+
+        network_interface.properties = create_network_interface_properties(
+          new_resource.name, new_resource.private_ip_allocation_method,
+          new_resource.private_ip_address, subnet_ref, new_resource.dns_servers, public_ip_ref)
+
+        network_interface
+      end
+
+      def create_network_interface(name, tags, location)
+        network_interface = Azure::ARM::Network::Models::NetworkInterface.new
+        network_interface.name = name
+        network_interface.tags = tags
+        network_interface.location = location
+
+        network_interface
+      end
+
+      def create_network_interface_properties(interface_name, private_ip_type, private_ip, subnet_ref, dns_servers, public_ip_ref)
+        nic_properties = Azure::ARM::Network::Models::NetworkInterfacePropertiesFormat.new
+
+        nic_properties.dns_settings = create_network_interface_dns_settings(dns_servers) if dns_servers
+
+        ip_config =  create_network_interface_ip_configuration("#{interface_name}-ipconfig", private_ip_type, private_ip, subnet_ref, public_ip_ref)
+        nic_properties.ip_configurations = [ip_config]
+
+        nic_properties
+      end
+
+      def create_network_interface_dns_settings(dns_servers)
+        dns_settings = Azure::ARM::Network::Models::NetworkInterfaceDnsSettings.new
+        dns_settings.dns_servers = dns_servers
+        dns_settings
+      end
+
+      def create_network_interface_ip_configuration(ipconfig_name, private_ip_type, private_ip, subnet_ref, public_ip_ref)
+        ip_config = Azure::ARM::Network::Models::NetworkInterfaceIpConfiguration.new
+        ip_config.name = ipconfig_name
+        ip_config.properties = Azure::ARM::Network::Models::NetworkInterfaceIpConfigurationPropertiesFormat.new
+        ip_config.properties.private_ipallocation_method = private_ip_type if  private_ip_type
+        ip_config.properties.private_ipaddress = private_ip if private_ip
+
+        if subnet_ref
+          ip_config.properties.subnet = Azure::ARM::Network::Models::Subnet.new
+          ip_config.properties.subnet.id = subnet_ref
+        end
+
+        if public_ip_ref
+          ip_config.properties.public_ipaddress = Azure::ARM::Network::Models::PublicIpAddress.new
+          ip_config.properties.public_ipaddress.id =  public_ip_ref
+        end
+
+        ip_config
+      end
+
+      def get_public_ip(resource_group, resource_name)
+        result =  try_azure_operation('getting public IP') do
+          network_management_client.public_ip_addresses.get(resource_group, resource_name).value!
+        end
+
+        public_ip = result.body
+        public_ip.id
+      end
+
+      def get_subnet_ref(resource_group_name, vnet_name, subnet_name)
+        [resource_group_name, vnet_name, subnet_name].each do |v|
+          return nil if v.nil? || v.empty?
+        end
+
+        result =  try_azure_operation('getting subnet') do
+          network_management_client.subnets.get(resource_group_name, vnet_name, subnet_name).value!
+        end
+        subnet = result.body
+
+        subnet.id
+      end
+    end # class AzureNetworkInterface
+  end # class Provider
+end # class Chef

data/lib/chef/provider/azure_public_ip_address.rb

@@ -0,0 +1,72 @@
+require 'chef/provisioning/azurerm/azure_provider'
+
+class Chef
+  class Provider
+    class AzurePublicIPAddress < Chef::Provisioning::AzureRM::AzureProvider
+      provides :azure_public_ip_address
+
+      def whyrun_supported?
+        true
+      end
+
+      action :create do
+        converge_by("create or update public IP address #{new_resource.name}") do
+          create_public_ip_address
+        end
+      end
+
+      action :destroy do
+        converge_by("destroy public IP address #{new_resource.name}") do
+          if public_ip_address_exists
+            destroy_public_ip_address
+          else
+            action_handler.report_progress "public IP address #{new_resource.name} was not found."
+          end
+        end
+      end
+
+      def public_ip_address_exists
+        public_ip_address_list = network_management_client.public_ip_addresses.list(new_resource.resource_group).value!
+        public_ip_address_list.body.value.each do |public_ip_address|
+          return true if public_ip_address.name == new_resource.name
+        end
+
+        false
+      end
+
+      def create_public_ip_address
+        public_ip_address = Azure::ARM::Network::Models::PublicIpAddress.new
+        public_ip_address.location = new_resource.location
+        public_ip_address.tags = new_resource.tags
+
+        public_ip_address_properties = Azure::ARM::Network::Models::PublicIpAddressPropertiesFormat.new
+        public_ip_address_properties.public_ipallocation_method = new_resource.public_ip_allocation_method
+        public_ip_address_properties.idle_timeout_in_minutes = new_resource.idle_timeout_in_minutes
+
+        if new_resource.domain_name_label || new_resource.reverse_fqdn
+          public_ip_address_properties.dns_settings = create_public_ip_dns_settings(new_resource.domain_name_label, new_resource.reverse_fqdn)
+        end
+
+        public_ip_address.properties = public_ip_address_properties
+
+        try_azure_operation('creating or updating public ip') do
+          network_management_client.public_ip_addresses.create_or_update(new_resource.resource_group, new_resource.name, public_ip_address).value!
+        end
+      end
+
+      def destroy_public_ip_address
+        try_azure_operation('destroyinh public ip') do
+          network_management_client.public_ip_addresses.delete(new_resource.resource_group, new_resource.name).value!
+        end
+      end
+
+      def create_public_ip_dns_settings(domain_name_label, reverse_fqdn)
+        dns_settings = Azure::ARM::Network::Models::PublicIpAddressDnsSettings.new
+        dns_settings.domain_name_label = domain_name_label
+        dns_settings.reverse_fqdn = reverse_fqdn
+
+        dns_settings
+      end
+    end
+  end
+end

data/lib/chef/provider/azure_resource_group.rb

@@ -15,6 +15,7 @@ class Chef
           resource_group.location = new_resource.location
           resource_group.tags = new_resource.tags
           result = resource_management_client.resource_groups.create_or_update(new_resource.name, resource_group).value!
+          Chef::Log.debug("result: #{result.body.inspect}")
         end
       end
 
@@ -23,6 +24,7 @@ class Chef
           resource_group_exists = resource_management_client.resource_groups.check_existence(new_resource.name).value!
           if resource_group_exists.body
             result = resource_management_client.resource_groups.delete(new_resource.name).value!
+            Chef::Log.debug("result: #{result.body.inspect}")
           else
             action_handler.report_progress "Resource Group #{new_resource.name} was not found."
           end

data/lib/chef/provider/azure_storage_account.rb

@@ -1,7 +1,5 @@
 require 'chef/provisioning/azurerm/azure_provider'
 
-# MSDN: https://msdn.microsoft.com/en-us/library/azure/mt163564.aspx
-
 class Chef
   class Provider
     class AzureStorageAccount < Chef::Provisioning::AzureRM::AzureProvider
@@ -12,28 +10,86 @@ class Chef
       end
 
       action :create do
-        url = "https://management.azure.com/subscriptions/#{new_resource.subscription_id}/resourcegroups/" \
-              "#{new_resource.resource_group}/providers/Microsoft.Storage/storageAccounts/#{new_resource.name}" \
-              '?api-version=2015-05-01-preview'
-        doc = {
-          location: new_resource.location,
-          tags: new_resource.tags,
-          properties: {
-            accountType: "#{new_resource.account_type}"
-          }
-        }
-        converge_by("create or update Storage Account: #{new_resource.name}") do
-          azure_call_until_expected_response(:put, url, doc.to_json, '201,200', 600)
+        # Does the storage account already exist in the specified resource group?
+        storage_account_exists = does_storage_account_exist
+
+        # If the storage account already exists, do an update
+        if storage_account_exists
+          converge_by("update Storage Account #{new_resource.name}") do
+            update_storage_account
+          end
+        else
+          # Create the storage account complete with tags and properties
+          converge_by("create Storage Account #{new_resource.name}") do
+            create_storage_account
+            # now update the resource with properties that are not settable in the create operation (e.g. create domain)
+            update_storage_account
+          end
         end
       end
 
       action :destroy do
-        url = "https://management.azure.com/subscriptions/#{new_resource.subscription_id}/resourcegroups/" \
-              "#{new_resource.resource_group}/providers/Microsoft.Storage/storageAccounts/#{new_resource.name}" \
-              '?api-version=2015-05-01-preview'
         converge_by("destroy Storage Account: #{new_resource.name}") do
-          azure_call_until_expected_response(:delete, url, nil, '404', 600)
+          storage_account_exists = does_storage_account_exist
+          if storage_account_exists
+            action_handler.report_progress 'destroying Storage Account'
+            storage_management_client.storage_accounts.delete(new_resource.resource_group, new_resource.name).value!
+          else
+            action_handler.report_progress "Storage Account #{new_resource.name} was not found."
+          end
+        end
+      end
+
+      def does_storage_account_exist
+        storage_account_list = storage_management_client.storage_accounts.list_by_resource_group(new_resource.resource_group).value!
+        storage_account_list.body.value.each do |storage_account|
+          return true if storage_account.name == new_resource.name
         end
+        false
+      end
+
+      def create_storage_account
+        storage_account = Azure::ARM::Storage::Models::StorageAccountCreateParameters.new
+        storage_account.location = new_resource.location
+        storage_account.tags = new_resource.tags
+        storage_account.properties = Azure::ARM::Storage::Models::StorageAccountPropertiesCreateParameters.new
+        storage_account.properties.account_type = new_resource.account_type
+        action_handler.report_progress 'creating Storage Account'
+        result = storage_management_client.storage_accounts.create(new_resource.resource_group, new_resource.name, storage_account).value!
+        Chef::Log.debug(result)
+      end
+
+      def update_storage_account
+        update_storage_account_tags
+        update_storage_account_account_type
+        update_storage_account_custom_domain
+      end
+
+      def update_storage_account_tags
+        storage_account = Azure::ARM::Storage::Models::StorageAccountUpdateParameters.new
+        storage_account.tags = new_resource.tags
+        storage_account.properties = Azure::ARM::Storage::Models::StorageAccountPropertiesUpdateParameters.new
+        action_handler.report_progress 'updating Tags'
+        result = storage_management_client.storage_accounts.update(new_resource.resource_group, new_resource.name, storage_account).value!
+        Chef::Log.debug(result)
+      end
+
+      def update_storage_account_account_type
+        storage_account = Azure::ARM::Storage::Models::StorageAccountUpdateParameters.new
+        storage_account.properties = Azure::ARM::Storage::Models::StorageAccountPropertiesUpdateParameters.new
+        storage_account.properties.account_type = new_resource.account_type
+        action_handler.report_progress 'updating Properties'
+        result = storage_management_client.storage_accounts.update(new_resource.resource_group, new_resource.name, storage_account).value!
+        Chef::Log.debug(result)
+      end
+
+      def update_storage_account_custom_domain
+        storage_account = Azure::ARM::Storage::Models::StorageAccountUpdateParameters.new
+        storage_account.properties = Azure::ARM::Storage::Models::StorageAccountPropertiesUpdateParameters.new
+        storage_account.properties.custom_domain = new_resource.custom_domain
+        action_handler.report_progress 'updating Custom Domain'
+        result = storage_management_client.storage_accounts.update(new_resource.resource_group, new_resource.name, storage_account).value!
+        Chef::Log.debug(result)
       end
     end
   end

data/lib/chef/provider/azure_virtual_network.rb

@@ -0,0 +1,100 @@
+require 'chef/provisioning/azurerm/azure_provider'
+
+class Chef
+  class Provider
+    class AzureVirtualNetwork < Chef::Provisioning::AzureRM::AzureProvider
+      provides :azure_virtual_network
+
+      def whyrun_supported?
+        true
+      end
+
+      action :create do
+        virtual_network_exists = does_virtual_network_exist
+
+        if virtual_network_exists
+          converge_by("update virtual network #{new_resource.name}") do
+            # currently, we let ARM manage the idempotence, so crete and update are the same
+            create_or_update_virtual_network # are create and update different (and should they be??)
+          end
+        else
+          converge_by("create virtual network #{new_resource.name}") do
+            create_or_update_virtual_network
+          end
+        end
+      end
+
+      action :destroy do
+        converge_by("destroy virtual network: #{new_resource.name}") do
+          if does_virtual_network_exist
+            destroy_virtual_network
+          else
+            action_handler.report_progress "virtual network #{new_resource.name} was not found."
+          end
+        end
+      end
+
+      def does_virtual_network_exist
+        virtual_network_list = try_azure_operation('listing virtual networks') do
+          network_management_client.virtual_networks.list(new_resource.resource_group).value!
+        end
+
+        virtual_network_list.body.value.each do |virtual_network|
+          return true if virtual_network.name == new_resource.name
+        end
+        false
+      end
+
+      def destroy_virtual_network
+        action_handler.report_progress 'Destroying Virtual Network...'
+        try_azure_operation('destroying virtual network') do
+          network_management_client.virtual_networks.delete(new_resource.resource_group, new_resource.name).value!
+        end
+      end
+
+      def create_or_update_virtual_network
+        virtual_network = Azure::ARM::Network::Models::VirtualNetwork.new
+
+        virtual_network.tags = new_resource.tags
+        virtual_network.location = new_resource.location
+
+        virtual_network.properties = create_virtual_network_properties(
+          new_resource.address_prefixes, new_resource.subnets, new_resource.dns_servers)
+
+        action_handler.report_progress 'Creating or Updating Virtual Network...'
+
+        try_azure_operation('creating or updating network interface') do
+          network_management_client.virtual_networks.create_or_update(new_resource.resource_group, new_resource.name, virtual_network).value!
+        end
+      end
+
+      def create_virtual_network_properties(address_prefixes, subnets, dns_servers)
+        props = Azure::ARM::Network::Models::VirtualNetworkPropertiesFormat.new
+
+        props.address_space = Azure::ARM::Network::Models::AddressSpace.new
+        props.address_space.address_prefixes = address_prefixes
+
+        if dns_servers
+          props.dhcp_options = Azure::ARM::Network::Models::DhcpOptions.new
+          props.dhcp_options.dns_servers = dns_servers
+        end
+
+        props.subnets = []
+        subnets.each do |subnet|
+          props.subnets.push(create_subnet(subnet[:name], subnet[:address_prefix]))
+        end
+
+        props
+      end
+
+      def create_subnet(subnet_name, subnet_address)
+        subnet = Azure::ARM::Network::Models::Subnet.new
+        subnet.name = subnet_name
+        subnet.properties = Azure::ARM::Network::Models::SubnetPropertiesFormat.new
+        subnet.properties.address_prefix = subnet_address
+
+        subnet
+      end
+    end # class AzureVirtualNetwork
+  end # class Provider
+end # class Chef

data/lib/chef/provisioning/azurerm.rb

@@ -3,11 +3,14 @@ require 'chef/provisioning/version'
 require 'chef/provisioning/azurerm/driver'
 require 'chef/provisioning/azurerm/version'
 require 'azure_mgmt_resources'
+require 'azure_mgmt_storage'
+require 'azure_mgmt_compute'
+require 'azure_mgmt_network'
 
 Chef::Log.info("chef-provisioning-azurerm #{Chef::Provisioning::AzureRM::VERSION}")
 Chef::Log.info("chef-provisioning #{Chef::Provisioning::VERSION}")
 
-resources = %w(resource_group resource_template storage_account)
+resources = %w(resource_group resource_template storage_account virtual_network network_interface public_ip_address)
 resources.each do |r|
   require "chef/resource/azure_#{r}"
   require "chef/provider/azure_#{r}"

data/lib/chef/provisioning/azurerm/azure_provider.rb

@@ -18,6 +18,41 @@ class Chef
           client.subscription_id = new_resource.subscription_id
           client
         end
+
+        def storage_management_client
+          credentials = Credentials.new.azure_credentials_for_subscription(new_resource.subscription_id)
+          client = Azure::ARM::Storage::StorageManagementClient.new(credentials)
+          client.subscription_id = new_resource.subscription_id
+          client
+        end
+
+        def compute_management_client
+          credentials = Credentials.new.azure_credentials_for_subscription(new_resource.subscription_id)
+          client = Azure::ARM::Compute::ComputeManagementClient.new(credentials)
+          client.subscription_id = new_resource.subscription_id
+          client
+        end
+
+        def network_management_client
+          credentials = Credentials.new.azure_credentials_for_subscription(new_resource.subscription_id)
+          client = Azure::ARM::Network::NetworkResourceProviderClient.new(credentials)
+          client.subscription_id = new_resource.subscription_id
+          client
+        end
+
+        def try_azure_operation(description, silently_continue_on_error = false)
+          begin
+            result = yield
+          rescue MsRestAzure::AzureOperationError => operation_error
+            unless silently_continue_on_error
+              error = operation_error.body['error']
+              Chef::Log.error "ERROR #{description} - #{error}"
+              raise operation_error
+            end
+          end
+
+          result
+        end
       end
     end
   end

data/lib/chef/provisioning/azurerm/version.rb

@@ -1,7 +1,7 @@
 class Chef
   module Provisioning
     module AzureRM
-      VERSION = '0.3.1'
+      VERSION = '0.3.2'
     end
   end
 end

data/lib/chef/resource/azure_network_interface.rb

@@ -0,0 +1,39 @@
+require 'chef/provisioning/azurerm/azure_resource'
+
+class Chef
+  class Resource
+    class AzureNetworkInterface < Chef::Provisioning::AzureRM::AzureResource
+      resource_name :azure_network_interface
+
+      actions :create, :destroy, :nothing
+
+      default_action :create
+
+      attribute :name, kind_of: String, name_attribute: true, regex: /^[\w\-\(\)\.]{0,80}$+(?<!\.)$/i
+      attribute :resource_group, kind_of: String
+      attribute :location, kind_of: String, default: 'westus'
+      attribute :tags, kind_of: Hash
+      attribute :private_ip_allocation_method, kind_of: String, equal_to: %w(static dynamic), default: 'dynamic'
+      attribute :private_ip_address, kind_of: String, regex: /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/
+      attribute :virtual_network, kind_of: String
+      attribute :virtual_network_resource_group, kind_of: String
+      attribute :subnet, kind_of: String
+      attribute :dns_servers, kind_of: Array, callbacks: {
+        'should be an array of ip addresses' => lambda do |arg_array|
+          arg_array.each do |subnet|
+            return false unless subnet =~ /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/
+          end
+          return true
+        end
+      }
+
+      attr_reader :public_ip_resource
+
+      def public_ip(resource_name, &resource_block)
+        @public_ip_resource =  Chef::Resource::AzurePublicIPAddress.new(resource_name.to_s, run_context)
+        @public_ip_resource.action :nothing
+        @public_ip_resource.instance_eval(&resource_block)
+      end
+    end
+  end
+end

data/lib/chef/resource/azure_public_ip_address.rb

@@ -0,0 +1,19 @@
+require 'chef/provisioning/azurerm/azure_resource'
+
+class Chef
+  class Resource
+    class AzurePublicIPAddress < Chef::Provisioning::AzureRM::AzureResource
+      resource_name :azure_public_ip_address
+      actions :create, :destroy, :nothing
+      default_action :create
+      attribute :name, kind_of: String, name_attribute: true
+      attribute :location, kind_of: String, default: 'westus'
+      attribute :tags, kind_of: Hash
+      attribute :resource_group, kind_of: String
+      attribute :public_ip_allocation_method, kind_of: String, equal_to: %w(dynamic static), default: 'dynamic'
+      attribute :domain_name_label, kind_of: String
+      attribute :reverse_fqdn, kind_of: String
+      attribute :idle_timeout_in_minutes, kind_of: Integer
+    end
+  end
+end

data/lib/chef/resource/azure_storage_account.rb

@@ -13,6 +13,7 @@ class Chef
       attribute :location, kind_of: String, default: 'westus'
       attribute :tags, kind_of: Hash
       attribute :account_type, kind_of: String, equal_to: %w(Standard_LRS Standard_ZRS Standard_GRS Standard_RAGRS Premium_LRS), default: 'Standard_LRS'
+      attribute :custom_domain, kind_of: String
     end
   end
 end

data/lib/chef/resource/azure_virtual_network.rb

@@ -0,0 +1,39 @@
+require 'chef/provisioning/azurerm/azure_resource'
+
+class Chef
+  class Resource
+    class AzureVirtualNetwork < Chef::Provisioning::AzureRM::AzureResource
+      resource_name :azure_virtual_network
+      actions :create, :destroy, :nothing
+      default_action :create
+      attribute :name, kind_of: String, name_attribute: true
+      attribute :resource_group, kind_of: String
+      attribute :location, kind_of: String, default: 'westus'
+      attribute :tags, kind_of: Hash
+      attribute :address_prefixes, kind_of: Array, callbacks: {
+        'should be an array of subnets in CIDR format (nnn.nnn.nnn.nnn/nn)' => lambda do |arg_array|
+          arg_array.each do |subnet|
+            return false unless subnet =~ %r{^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])(\/([0-9]|[1-2][0-9]|3[0-2]))$}
+          end
+          return true
+        end
+      }
+      attribute :subnets, kind_of: Array, callbacks: {
+        'should be an array of subnet hashes, each with a :name and :address_prefix' => lambda do |arg_array|
+          arg_array.each do |subnet|
+            return false unless ([:name, :address_prefix].sort == subnet.keys.sort)
+          end
+          return true
+        end
+      }
+      attribute :dns_servers, kind_of: Array, callbacks: {
+        'should be an array of ip addresses' => lambda do |arg_array|
+          arg_array.each do |subnet|
+            return false unless subnet =~ /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/
+          end
+          return true
+        end
+      }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-provisioning-azurerm
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Stuart Preston
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-05 00:00:00.000000000 Z
+date: 2015-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -82,16 +82,58 @@ dependencies:
   name: azure_mgmt_resources
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: azure_mgmt_storage
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: azure_mgmt_compute
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: azure_mgmt_network
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -130,9 +172,12 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- lib/chef/provider/azure_network_interface.rb
+- lib/chef/provider/azure_public_ip_address.rb
 - lib/chef/provider/azure_resource_group.rb
 - lib/chef/provider/azure_resource_template.rb
 - lib/chef/provider/azure_storage_account.rb
+- lib/chef/provider/azure_virtual_network.rb
 - lib/chef/provisioning/azurerm.rb
 - lib/chef/provisioning/azurerm/azure_provider.rb
 - lib/chef/provisioning/azurerm/azure_resource.rb
@@ -140,9 +185,12 @@ files:
 - lib/chef/provisioning/azurerm/driver.rb
 - lib/chef/provisioning/azurerm/version.rb
 - lib/chef/provisioning/driver_init/azurerm.rb
+- lib/chef/resource/azure_network_interface.rb
+- lib/chef/resource/azure_public_ip_address.rb
 - lib/chef/resource/azure_resource_group.rb
 - lib/chef/resource/azure_resource_template.rb
 - lib/chef/resource/azure_storage_account.rb
+- lib/chef/resource/azure_virtual_network.rb
 homepage: https://github.com/pendrica/chef-provisioning-azurerm
 licenses:
 - Apache-2.0
@@ -163,7 +211,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.4
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Chef Provisioner for the Azure Resource Management (ARM) REST API.