fog-azure-rm 0.0.5 → 0.0.6

data/lib/fog/azurerm/requests/application_gateway/update_subnet_id_in_gateway_ip_configuration.rb

@@ -0,0 +1,29 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Real class for Application Gateway Request
+      class Real
+        def update_subnet_id_in_gateway_ip_configuration(gateway_params, subnet_id)
+          msg = 'Updating Subnet id of IP Configuration'
+          Fog::Logger.debug msg
+          gateway_params[:gateway_ip_configurations].each do |ip_configuration|
+            ip_configuration[:subnet_id] = subnet_id
+          end
+          begin
+            gateway = create_or_update_application_gateway(gateway_params)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug 'IP Configuration updated Successfully'
+          gateway
+        end
+      end
+
+      # Mock class for Application Gateway Request
+      class Mock
+        def update_subnet_id_in_gateway_ip_configuration(*)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/compute/create_virtual_machine.rb

@@ -1,3 +1,6 @@
+require 'base64'
+WHITE_SPACE = ' '.freeze
+
 module Fog
   module Compute
     class AzureRM
@@ -14,27 +17,32 @@ module Fog
             virtual_machine.availability_set = sub_resource
           end
 
+          string_data = vm_hash[:custom_data]
+          string_data = WHITE_SPACE if string_data.nil?
+          encoded_data = Base64.strict_encode64(string_data)
           virtual_machine.hardware_profile = define_hardware_profile(vm_hash[:vm_size])
           virtual_machine.storage_profile = define_storage_profile(vm_hash[:name],
-                                                                 vm_hash[:storage_account_name],
-                                                                 vm_hash[:publisher],
-                                                                 vm_hash[:offer],
-                                                                 vm_hash[:sku],
-                                                                 vm_hash[:version])
-          virtual_machine.os_profile = if vm_hash[:platform].casecmp(WINDOWS) == 0
-                                       define_windows_os_profile(vm_hash[:name],
+                                                                   vm_hash[:storage_account_name],
+                                                                   vm_hash[:publisher],
+                                                                   vm_hash[:offer],
+                                                                   vm_hash[:sku],
+                                                                   vm_hash[:version])
+          virtual_machine.os_profile = if vm_hash[:platform].casecmp(WINDOWS).zero?
+                                         define_windows_os_profile(vm_hash[:name],
+                                                                   vm_hash[:username],
+                                                                   vm_hash[:password],
+                                                                   vm_hash[:provision_vm_agent],
+                                                                   vm_hash[:enable_automatic_updates],
+                                                                   encoded_data)
+                                       else
+                                         define_linux_os_profile(vm_hash[:name],
                                                                  vm_hash[:username],
                                                                  vm_hash[:password],
-                                                                 vm_hash[:provision_vm_agent],
-                                                                 vm_hash[:enable_automatic_updates])
-                                     else
-                                       define_linux_os_profile(vm_hash[:name],
-                                                               vm_hash[:username],
-                                                               vm_hash[:password],
-                                                               vm_hash[:disable_password_authentication],
-                                                               vm_hash[:ssh_key_path],
-                                                               vm_hash[:ssh_key_data])
-                                     end
+                                                                 vm_hash[:disable_password_authentication],
+                                                                 vm_hash[:ssh_key_path],
+                                                                 vm_hash[:ssh_key_data],
+                                                                 encoded_data)
+                                       end
           virtual_machine.network_profile = define_network_profile(vm_hash[:network_interface_card_id])
           virtual_machine.location = vm_hash[:location]
           begin
@@ -73,7 +81,7 @@ module Fog
           storage_profile
         end
 
-        def define_windows_os_profile(vm_name, username, password, provision_vm_agent, enable_automatic_updates)
+        def define_windows_os_profile(vm_name, username, password, provision_vm_agent, enable_automatic_updates, encoded_data)
           os_profile = Azure::ARM::Compute::Models::OSProfile.new
           windows_config = Azure::ARM::Compute::Models::WindowsConfiguration.new
           windows_config.provision_vmagent = provision_vm_agent
@@ -83,10 +91,11 @@ module Fog
           os_profile.computer_name = vm_name
           os_profile.admin_username = username
           os_profile.admin_password = password
+          os_profile.custom_data = encoded_data
           os_profile
         end
 
-        def define_linux_os_profile(vm_name, username, password, disable_password_authentication, ssh_key_path, ssh_key_data)
+        def define_linux_os_profile(vm_name, username, password, disable_password_authentication, ssh_key_path, ssh_key_data, encoded_data)
           os_profile = Azure::ARM::Compute::Models::OSProfile.new
           linux_config = Azure::ARM::Compute::Models::LinuxConfiguration.new
 
@@ -104,6 +113,7 @@ module Fog
           os_profile.computer_name = vm_name
           os_profile.admin_username = username
           os_profile.admin_password = password
+          os_profile.custom_data = encoded_data
           os_profile
         end
 
@@ -159,7 +169,8 @@ module Fog
                     {
                       'disablePasswordAuthentication' => true
                     },
-                  'secrets' => []
+                  'secrets' => [],
+                  'customData' => 'ZWNobyBjdXN0b21EYXRh'
                 },
               'networkProfile' =>
                 {

data/lib/fog/azurerm/requests/compute/get_virtual_machine.rb

@@ -40,7 +40,7 @@ module Fog
                     },
                   'osDisk' =>
                     {
-                      'name' => "fog-test-server_os_disk",
+                      'name' => 'fog-test-server_os_disk',
                       'vhd' =>
                         {
                           'uri' => 'http://fogtestsafirst.blob.core.windows.net/vhds/fog-test-server_os_disk.vhd'

data/lib/fog/azurerm/requests/network/create_or_update_express_route_circuit.rb

@@ -4,7 +4,7 @@ module Fog
       # Real class for Network Request
       class Real
         def create_or_update_express_route_circuit(circuit_parameters)
-          msg = "Exception creating/updating Express Route Circuit #{circuit_parameters[:circuit_name]} in Resource Group: #{circuit_parameters[:resource_group_name]}."
+          msg = "Creating/updating Express Route Circuit #{circuit_parameters[:circuit_name]} in Resource Group: #{circuit_parameters[:resource_group_name]}."
           Fog::Logger.debug msg
           circuit = get_express_route_circuit_object(circuit_parameters)
           begin

data/lib/fog/azurerm/requests/network/create_or_update_express_route_circuit_authorization.rb

@@ -0,0 +1,49 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Express Route Circuit Authorization Request
+      class Real
+        def create_or_update_express_route_circuit_authorization(circuit_authorization_params)
+          msg = "Creating/updating Express Route Circuit Authorization #{circuit_authorization_params[:authorization_name]} in Resource Group: #{circuit_authorization_params[:resource_group]}."
+          Fog::Logger.debug msg
+          circuit_authorization = get_circuit_authorization_object(circuit_authorization_params)
+          begin
+            authorization = @network_client.express_route_circuit_authorizations.create_or_update(circuit_authorization_params[:resource_group], circuit_authorization_params[:circuit_name], circuit_authorization_params[:authorization_name], circuit_authorization)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Express Route Circuit Authorization #{circuit_authorization_params[:authorization_name]} created/updated successfully."
+          authorization
+        end
+
+        private
+
+        def get_circuit_authorization_object(circuit_authorization_params)
+          circuit_authorization = Azure::ARM::Network::Models::ExpressRouteCircuitAuthorization.new
+          circuit_authorization.name = circuit_authorization_params[:authorization_name]
+          circuit_authorization.authorization_key = circuit_authorization_params[:authorization_key]
+          circuit_authorization.authorization_use_status = circuit_authorization_params[:authorization_status]
+          circuit_authorization.provisioning_state = circuit_authorization_params[:provisioning_state]
+          circuit_authorization.etag = circuit_authorization_params[:etag]
+
+          circuit_authorization
+        end
+      end
+
+      # Mock class for Express Route Circuit Authorization Request
+      class Mock
+        def create_or_update_express_route_circuit_authorization(*)
+          authorization = {
+            'name' => 'authorization-name',
+            'properties' => {
+              'authorizationKey' => 'authorization-key',
+              'authorizationUseStatus' => 'Available'
+            }
+          }
+          authorization_mapper = Azure::ARM::Network::Models::ExpressRouteCircuitAuthorization.mapper
+          @network_client.deserialize(authorization_mapper, authorization, 'result.body')
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/create_or_update_local_network_gateway.rb

@@ -0,0 +1,78 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Local Network Gateway Request
+      class Real
+        def create_or_update_local_network_gateway(local_network_gateway_params)
+          msg = "Creating/Updating Local Network Gateway: #{local_network_gateway_params[:name]} in Resource Group: #{local_network_gateway_params[:resource_group]}."
+          Fog::Logger.debug msg
+          local_network_gateway = get_local_network_gateway_object(local_network_gateway_params)
+          begin
+            local_network_gateway = @network_client.local_network_gateways.create_or_update(local_network_gateway_params[:resource_group], local_network_gateway.name, local_network_gateway)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Local Network Gateway #{local_network_gateway_params[:name]} created/updated successfully."
+          local_network_gateway
+        end
+
+        private
+
+        def get_local_network_gateway_object(local_network_gateway_params)
+          local_network_gateway = Azure::ARM::Network::Models::LocalNetworkGateway.new
+          local_network_gateway.local_network_address_space = get_local_network_address_space_object(local_network_gateway_params[:local_network_address_space_prefixes]) if local_network_gateway_params[:local_network_address_space_prefixes]
+          local_network_gateway.gateway_ip_address = local_network_gateway_params[:gateway_ip_address] if local_network_gateway_params[:gateway_ip_address]
+          local_network_gateway.bgp_settings = get_bgp_settings_object(local_network_gateway_params)
+
+          local_network_gateway.name = local_network_gateway_params[:name]
+          local_network_gateway.type = local_network_gateway_params[:type]
+          local_network_gateway.location = local_network_gateway_params[:location]
+          local_network_gateway.tags = local_network_gateway_params[:tags] if local_network_gateway.tags.nil?
+          local_network_gateway.provisioning_state = local_network_gateway_params[:provisioning_state]
+
+          local_network_gateway
+        end
+
+        def get_local_network_address_space_object(local_network_address_space_prefixes)
+          address_space = Azure::ARM::Network::Models::AddressSpace.new
+          address_space.address_prefixes = local_network_address_space_prefixes
+          address_space
+        end
+
+        def get_bgp_settings_object(local_network_gateway_params)
+          bgp_settings = Azure::ARM::Network::Models::BgpSettings.new
+          bgp_settings.asn = local_network_gateway_params[:asn]
+          bgp_settings.bgp_peering_address = local_network_gateway_params[:bgp_peering_address]
+          bgp_settings.peer_weight = local_network_gateway_params[:peer_weight]
+          bgp_settings
+        end
+      end
+
+      # Mock class for Local Network Gateway Request
+      class Mock
+        def create_or_update_virtual_network_gateway(*)
+          local_network_gateway = {
+            'id' => '/subscriptions/<Subscription_id>/resourceGroups/learn_fog/providers/Microsoft.Network/localNetworkGateways/testLocalNetworkGateway',
+            'name' => 'testLocalNetworkGateway',
+            'type' => 'Microsoft.Network/localNetworkGateways',
+            'location' => 'eastus',
+            'properties' =>
+              {
+                'local_network_address_space' => {
+                  'address_prefixes' => []
+                },
+                'gateway_ip_address' => '192.168.1.1',
+                'bgp_settings' => {
+                  'asn' => 100,
+                  'bgp_peering_address' => '192.168.1.2',
+                  'peer_weight' => 3
+                }
+              }
+          }
+          local_network_gateway_mapper = Azure::ARM::Network::Models::LocalNetworkGateway.mapper
+          @network_client.deserialize(local_network_gateway_mapper, local_network_gateway, 'result.body')
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/{create_public_ip.rb → create_or_update_public_ip.rb}

@@ -3,18 +3,32 @@ module Fog
     class AzureRM
       # Real class for Network Request
       class Real
-        def create_public_ip(resource_group, name, location, public_ip_allocation_method)
-          Fog::Logger.debug "Creating PublicIP #{name} in Resource Group #{resource_group}."
-          public_ip = Azure::ARM::Network::Models::PublicIPAddress.new
-          public_ip.name = name
-          public_ip.location = location
-          public_ip.public_ipallocation_method = public_ip_allocation_method
+        def create_or_update_public_ip(resource_group, name, location, public_ip_allocation_method, idle_timeout_in_minutes, domain_name_label)
+          msg = "Creating/Updating PublicIP #{name} in Resource Group #{resource_group}."
+          Fog::Logger.debug msg
+          public_ip = get_public_ip_object(name, location, public_ip_allocation_method, idle_timeout_in_minutes, domain_name_label)
           begin
-            public_ip = @network_client.public_ipaddresses.create_or_update(resource_group, name, public_ip)
+            public_ip_obj = @network_client.public_ipaddresses.create_or_update(resource_group, name, public_ip)
           rescue MsRestAzure::AzureOperationError => e
-            raise_azure_exception(e, "Creating PublicIP #{name} in Resource Group #{resource_group}")
+            raise_azure_exception(e, msg)
           end
           Fog::Logger.debug "PublicIP #{name} Created Successfully!"
+          public_ip_obj
+        end
+
+        private
+
+        def get_public_ip_object(name, location, public_ip_allocation_method, idle_timeout_in_minutes, domain_name_label)
+          public_ip = Azure::ARM::Network::Models::PublicIPAddress.new
+          public_ip.name = name
+          public_ip.location = location
+          public_ip.public_ipallocation_method = public_ip_allocation_method unless public_ip_allocation_method.nil?
+          public_ip.idle_timeout_in_minutes = idle_timeout_in_minutes unless idle_timeout_in_minutes.nil?
+          unless domain_name_label.nil?
+            public_ip.dns_settings = Azure::ARM::Network::Models::PublicIPAddressDnsSettings.new
+            public_ip.dns_settings.domain_name_label = domain_name_label
+          end
+
           public_ip
         end
       end

data/lib/fog/azurerm/requests/network/create_or_update_virtual_network_gateway_connection.rb

@@ -0,0 +1,81 @@
+
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Network Request
+      class Real
+        def create_or_update_virtual_network_gateway_connection(gateway_connection_params)
+          msg = "Creating/Updating Virtual Network Gateway Connection: #{gateway_connection_params[:name]} in Resource Group: #{gateway_connection_params[:resource_group_name]}."
+          Fog::Logger.debug msg
+          gateway_connection = get_network_gateway_connection_object(gateway_connection_params)
+          begin
+            network_gateway_connection = @network_client.virtual_network_gateway_connections.create_or_update(gateway_connection_params[:resource_group_name], gateway_connection_params[:name], gateway_connection)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Virtual Network Gateway Connection #{gateway_connection_params[:name]} created/updated successfully."
+          network_gateway_connection
+        end
+
+        private
+
+        def get_network_gateway_connection_object(gateway_connection_params)
+          gateway_connection = Azure::ARM::Network::Models::VirtualNetworkGatewayConnection.new
+
+          gateway_connection.name = gateway_connection_params[:name]
+          gateway_connection.location = gateway_connection_params[:location]
+          gateway_connection.tags = gateway_connection_params[:tags] if gateway_connection.tags.nil?
+
+          if gateway_connection_params[:virtual_network_gateway1]
+            gateway_connection.virtual_network_gateway1 = get_virtual_network_gateway(gateway_connection_params[:virtual_network_gateway1][:resource_group], gateway_connection_params[:virtual_network_gateway1][:name])
+          end
+
+          if gateway_connection_params[:virtual_network_gateway2]
+            gateway_connection.virtual_network_gateway2 = get_virtual_network_gateway(gateway_connection_params[:virtual_network_gateway2][:resource_group], gateway_connection_params[:virtual_network_gateway2][:name])
+          end
+
+          gateway_connection.authorization_key = gateway_connection_params[:authorization_key]
+          gateway_connection.connection_type = gateway_connection_params[:connection_type]
+          gateway_connection.routing_weight = gateway_connection_params[:routing_weight]
+          gateway_connection.shared_key = gateway_connection_params[:shared_key]
+          gateway_connection.connection_status = gateway_connection_params[:connection_status]
+          gateway_connection.egress_bytes_transferred = gateway_connection_params[:egress_bytes_transferred]
+          gateway_connection.ingress_bytes_transferred = gateway_connection_params[:ingress_bytes_transferred]
+          if gateway_connection_params[:peer]
+            peer = MsRestAzure::SubResource.new
+            peer.id = gateway_connection_params[:peer]
+            gateway_connection.peer = peer
+          end
+          gateway_connection.resource_guid = gateway_connection_params[:resource_guid]
+          gateway_connection.enable_bgp = gateway_connection_params[:enable_bgp]
+          gateway_connection.provisioning_state = gateway_connection_params[:provisioning_state]
+
+          gateway_connection
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def create_or_update_virtual_network_gateway_connection(*)
+          connection = {
+            'name' => 'cn1',
+            'location' => 'West US',
+            'tags' => { 'key1' => 'value1' },
+            'properties' => {
+              'virtualNetworkGateway1' => {
+                'name' => 'firstgateway'
+              },
+              'virtualNetworkGateway2' => {
+                'name' => 'secondgateway'
+              },
+              'connectionType' => 'SiteToSite',
+              'connectivityState' => 'Connected'
+            }
+          }
+          connection_mapper = Azure::ARM::Network::Models::VirtualNetworkGatewayConnection.mapper
+          @network_client.deserialize(connection_mapper, connection, 'result.body')
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/delete_express_route_circuit_authorization.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Express Route Circuit Authorization Request
+      class Real
+        def delete_express_route_circuit_authorization(resource_group_name, circuit_name, authorization_name)
+          msg = "Deleting Express Route Circuit Authorization #{authorization_name} from Resource Group #{resource_group_name}."
+          Fog::Logger.debug msg
+          begin
+            @network_client.express_route_circuit_authorizations.delete(resource_group_name, circuit_name, authorization_name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Express Route Circuit Authorization #{authorization_name} Deleted Successfully."
+          true
+        end
+      end
+
+      # Mock class for Express Route Circuit Authorization Request
+      class Mock
+        def delete_express_route_circuit_authorization(*)
+          Fog::Logger.debug 'Express Route Circuit Authorization {authorization_name} from Resource group {resource_group_name} deleted successfully.'
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/delete_local_network_gateway.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Local Network Gateway Request
+      class Real
+        def delete_local_network_gateway(resource_group_name, local_network_gateway_name)
+          msg = "Deleting Local Network Gateway: #{local_network_gateway_name}"
+          Fog::Logger.debug msg
+          begin
+            @network_client.local_network_gateways.delete(resource_group_name, local_network_gateway_name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Local Network Gateway #{local_network_gateway_name} from Resource group #{resource_group_name} deleted successfully."
+          true
+        end
+      end
+
+      # Mock class for Local Network Gateway Request
+      class Mock
+        def delete_local_network_gateway(*)
+          Fog::Logger.debug 'Local Network Gateway testLocalNetworkGateway from Resource group learn_fog deleted successfully.'
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/delete_virtual_network_gateway_connection.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Network Request
+      class Real
+        def delete_virtual_network_gateway_connection(resource_group_name, gateway_connection_name)
+          msg = "Deleting Virtual Network Gateway Connection #{gateway_connection_name} from Resource Group #{resource_group_name}."
+          Fog::Logger.debug msg
+          begin
+            @network_client.virtual_network_gateway_connections.delete(resource_group_name, gateway_connection_name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Virtual Network Gateway Connection #{gateway_connection_name} Deleted Successfully."
+          true
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def delete_virtual_network_gateway_connection(*)
+          Fog::Logger.debug 'Virtual Network Gateway Connection deleted successfully.'
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/get_connection_shared_key.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Network Request
+      class Real
+        def get_connection_shared_key(resource_group_name, connection_shared_key_name)
+          msg = "Getting the shared key of Connection #{connection_shared_key_name} from Resource Group #{resource_group_name}."
+          Fog::Logger.debug msg
+          begin
+            @network_client.virtual_network_gateway_connections.get_shared_key(resource_group_name, connection_shared_key_name).value
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def get_connection_shared_key(*)
+          Fog::Logger.debug 'Get the shared key of Connection successfully.'
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/requests/network/get_express_route_circuit_authorization.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Express Route Circuit Authorization Request
+      class Real
+        def get_express_route_circuit_authorization(resource_group_name, circuit_name, authorization_name)
+          msg = "Getting Express Route Circuit Authorization #{authorization_name} from Resource Group #{resource_group_name}."
+          Fog::Logger.debug msg
+          begin
+            circuit_authorization = @network_client.express_route_circuit_authorizations.get(resource_group_name, circuit_name, authorization_name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          circuit_authorization
+        end
+      end
+
+      # Mock class for Express Route Circuit Authorization Request
+      class Mock
+        def get_express_route_circuit_authorization(*)
+          authorization = {
+            'name' => 'authorization-name',
+            'properties' => {
+              'authorizationKey' => 'authorization-key',
+              'authorizationUseStatus' => 'Available'
+            }
+          }
+          authorization_mapper = Azure::ARM::Network::Models::ExpressRouteCircuitAuthorization.mapper
+          @network_client.deserialize(authorization_mapper, authorization, 'result.body')
+        end
+      end
+    end
+  end
+end