fog-azure-rm 0.0.4 → 0.0.5

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

@@ -0,0 +1,26 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Real class for Application Gateway Request
+      class Real
+        def delete_application_gateway(resource_group, name)
+          msg = "Deleting Application_Gateway #{name} from Resource Group #{resource_group}."
+          Fog::Logger.debug msg
+          begin
+            @network_client.application_gateways.delete(resource_group, name)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Application Gateway #{name} Deleted Successfully."
+          true
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def delete_application_gateway(_resource_group, _name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module ApplicationGateway
+    class AzureRM
+      # Real class for Application Gateway Request
+      class Real
+        def list_application_gateways(resource_group)
+          msg = "Getting list of Application-Gateway from Resource Group #{resource_group}."
+          Fog::Logger.debug msg
+          begin
+            gateways = @network_client.application_gateways.list_as_lazy(resource_group)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          gateways.value
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def list_application_gateways(_resource_group)
+          ag = Azure::ARM::Network::Models::ApplicationGateway.new
+          ag.name = 'fogtestgateway'
+          ag.location = 'East US'
+          [ag]
+        end
+      end
+    end
+  end
+end

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

@@ -4,35 +4,35 @@ module Fog
       # This class provides the actual implementation for service calls.
       class Real
         def attach_data_disk_to_vm(resource_group, vm_name, disk_name, disk_size, storage_account_name)
-          Fog::Logger.debug "Attaching Data Disk #{disk_name} to Virtual Machine #{vm_name} in Resource Group #{resource_group}."
+          msg = "Attaching Data Disk #{disk_name} to Virtual Machine #{vm_name} in Resource Group #{resource_group}"
+          Fog::Logger.debug msg
           vm = get_virtual_machine_instance(resource_group, vm_name, @compute_mgmt_client)
-          lun = get_logical_unit_number(vm.properties.storage_profile.data_disks)
+          lun = get_logical_unit_number(vm.storage_profile.data_disks)
           access_key = get_storage_access_key(resource_group, storage_account_name, @storage_mgmt_client)
-          data_disk = build_storage_profile(disk_name, disk_size, lun, storage_account_name, access_key)
-          vm.properties.storage_profile.data_disks.push(data_disk)
+          data_disk = get_data_disk_object(disk_name, disk_size, lun, storage_account_name, access_key)
+          vm.storage_profile.data_disks.push(data_disk)
           vm.resources = nil
           begin
-            promise = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, vm_name, vm)
-            result = promise.value!
-            Fog::Logger.debug "Data Disk #{disk_name} attached to Virtual Machine #{vm_name} successfully."
-            Azure::ARM::Compute::Models::VirtualMachine.serialize_object(result.body)
+            virtual_machine = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, vm_name, vm)
           rescue MsRestAzure::AzureOperationError => e
-            msg = "Error Attaching Data Disk #{disk_name} to Virtual Machine #{vm_name} in Resource Group #{resource_group}. #{e.body['error']['message']}"
-            raise msg
+            raise_azure_exception(e, msg)
           end
+          Fog::Logger.debug "Data Disk #{disk_name} attached to Virtual Machine #{vm_name} successfully."
+          virtual_machine
         end
 
         private
 
         def get_virtual_machine_instance(resource_group, vm_name, client)
+          msg = "Getting Virtual Machine #{vm_name} from Resource Group #{resource_group}"
+          Fog::Logger.debug msg
           begin
-            promise = client.virtual_machines.get(resource_group, vm_name)
-            result = promise.value!
-            result.body
+            virtual_machine = client.virtual_machines.get(resource_group, vm_name)
           rescue MsRestAzure::AzureOperationError => e
-            msg = "Error Attaching Data Disk to Virtual Machine. #{e.body['error']['message']}"
-            raise msg
+            raise_azure_exception(e, msg)
           end
+          Fog::Logger.debug "Getting Virtual Machine #{vm_name} from Resource Group #{resource_group} successful"
+          virtual_machine
         end
 
         def get_logical_unit_number(data_disks)
@@ -49,16 +49,18 @@ module Fog
         end
 
         def get_storage_access_key(resource_group, storage_account_name, storage_client)
+          msg = "Getting Storage Access Keys from Resource Group #{resource_group}"
+          Fog::Logger.debug msg
           begin
-            storage_account_keys = storage_client.storage_accounts.list_keys(resource_group, storage_account_name).value!
-            storage_account_keys.body.key2
+            storage_account_keys = storage_client.storage_accounts.list_keys(resource_group, storage_account_name)
           rescue MsRestAzure::AzureOperationError => e
-            msg = "Error Attaching Data Disk to Virtual Machine. #{e.body['error']['message']}"
-            raise msg
+            raise_azure_exception(e, msg)
           end
+          Fog::Logger.debug "Getting Storage Access Keys from Resource Group #{resource_group} successful"
+          storage_account_keys.keys[0].value
         end
 
-        def build_storage_profile(disk_name, disk_size, lun, storage_account_name, access_key)
+        def get_data_disk_object(disk_name, disk_size, lun, storage_account_name, access_key)
           data_disk = Azure::ARM::Compute::Models::DataDisk.new
           data_disk.name = disk_name
           data_disk.lun = lun
@@ -67,12 +69,9 @@ module Fog
           data_disk.vhd.uri = "https://#{storage_account_name}.blob.core.windows.net/vhds/#{disk_name}.vhd"
           data_disk.caching = Azure::ARM::Compute::Models::CachingTypes::ReadWrite
           blob_name = "#{disk_name}.vhd"
-          is_new_disk_or_old = check_blob_exist(storage_account_name, blob_name, access_key)
-          data_disk.create_option = if is_new_disk_or_old == true
-                                      Azure::ARM::Compute::Models::DiskCreateOptionTypes::Attach
-                                    else
-                                      Azure::ARM::Compute::Models::DiskCreateOptionTypes::Empty
-                                    end
+          disk_exist = check_blob_exist(storage_account_name, blob_name, access_key)
+          data_disk.create_option = Azure::ARM::Compute::Models::DiskCreateOptionTypes::Empty
+          data_disk.create_option = Azure::ARM::Compute::Models::DiskCreateOptionTypes::Attach if disk_exist
           data_disk
         end
 
@@ -84,18 +83,17 @@ module Fog
             true unless blob_prop.nil?
           rescue Azure::Core::Http::HTTPError => e
             return false if e.status_code == 404
-            msg = "Error Attaching Data Disk to Virtual Machine. #{e.description}"
-            raise msg
+            raise_azure_exception(e, 'Checking blob existence')
           end
         end
       end
       # This class provides the mock implementation for unit tests.
       class Mock
-        def attach_data_disk_to_vm(resource_group, vm_name, disk_name, disk_size, storage_account_name)
-          {
+        def attach_data_disk_to_vm(*)
+          vm = {
             'location' => 'West US',
-            'id' => "/subscriptions/########-####-####-####-############/resourceGroups/#{resource_group}/providers/Microsoft.Compute/virtualMachines/#{name}",
-            'name' => vm_name,
+            'id' => '/subscriptions/########-####-####-####-############/resourceGroups/fog-test-rg/providers/Microsoft.Compute/virtualMachines/fog-test-server',
+            'name' => 'fog-test-server',
             'type' => 'Microsoft.Compute/virtualMachines',
             'properties' =>
               {
@@ -114,10 +112,10 @@ module Fog
                       },
                     'osDisk' =>
                       {
-                        'name' => "#{vm_name}_os_disk",
+                        'name' => 'fog-test-server_os_disk',
                         'vhd' =>
                           {
-                            'uri' => "http://#{storage_account_name}.blob.core.windows.net/vhds/#{vm_name}_os_disk.vhd"
+                            'uri' => 'http://mystorage1.blob.core.windows.net/vhds/fog-test-server_os_disk.vhd'
                           },
                         'createOption' => 'FromImage',
                         'osType' => 'Linux',
@@ -125,10 +123,10 @@ module Fog
                       },
                     'dataDisks' => [{
                       'lun' => 0,
-                      'name' => disk_name,
-                      'vhd_uri' => "https://confizrg7443.blob.core.windows.net/vhds/#{disk_name}.vhd",
+                      'name' => 'fog-test-server_data_disk',
+                      'vhd_uri' => 'https://confizrg7443.blob.core.windows.net/vhds/fog-test-server_data_disk.vhd',
                       'create_option' => 'empty',
-                      'disk_size_gb' => disk_size
+                      'disk_size_gb' => 1
                     }]
                   },
                 'osProfile' =>
@@ -146,13 +144,15 @@ module Fog
                     'networkInterfaces' =>
                       [
                         {
-                          'id' => "/subscriptions/########-####-####-####-############/resourceGroups/#{resource_group}/providers/Microsoft.Network/networkInterfaces/fog-test-vnet"
+                          'id' => '/subscriptions/########-####-####-####-############/resourceGroups/fog-test-rg/providers/Microsoft.Network/networkInterfaces/fog-test-vnet'
                         }
                       ]
                   },
                 'provisioningState' => 'Succeeded'
               }
           }
+          vm_mapper = Azure::ARM::Compute::Models::VirtualMachine.mapper
+          @compute_mgmt_client.deserialize(vm_mapper, vm, 'result.body')
         end
       end
     end

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

@@ -1,24 +1,22 @@
 module Fog
   module Compute
     class AzureRM
-      # This class provides the actual implemention for service calls.
+      # This class provides the actual implementation for service calls.
       class Real
         def check_vm_status(resource_group, name)
-          Fog::Logger.debug "Checking Virtual Machine #{name} status."
+          msg = "Checking Virtual Machine #{name} status"
+          Fog::Logger.debug msg
           begin
-            # Pass 'instanceView' in get method, as argument, to get Virtual Machine status.
-            promise = @compute_mgmt_client.virtual_machines.get(resource_group, name, 'instanceView')
-            response = promise.value!
-            virtual_machine = response.body
-            get_status(virtual_machine)
+            virtual_machine = @compute_mgmt_client.virtual_machines.get(resource_group, name, 'instanceView')
           rescue  MsRestAzure::AzureOperationError => e
-            msg = "Error in checking Virtual Machine '#{name}' status in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
-            raise msg
+            raise_azure_exception(e, msg)
           end
+          Fog::Logger.debug "Successfully returned status of Virtual Machine #{name} in Resource Group #{resource_group}"
+          get_status(virtual_machine)
         end
 
         def get_status(virtual_machine)
-          vm_statuses = virtual_machine.properties.instance_view.statuses
+          vm_statuses = virtual_machine.instance_view.statuses
           vm_status = nil
           vm_statuses.each do |status|
             if status.code.include? 'PowerState'

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

@@ -1,34 +1,29 @@
 module Fog
   module Compute
     class AzureRM
-      # This class provides the actual implemention for service calls.
+      # This class provides the actual implementation for service calls.
       class Real
         def create_availability_set(resource_group, name, location)
+          msg = "Creating Availability Set '#{name}' in #{location} region."
+          Fog::Logger.debug msg
+          avail_set_params = get_availability_set_properties(location)
           begin
-            Fog::Logger.debug "Creating Availability Set '#{name}' in #{location} region."
-            avail_set_props = get_avail_set_properties(location)
-            promise = @compute_mgmt_client.availability_sets.create_or_update(resource_group, name, avail_set_props)
-            result = promise.value!
-            Fog::Logger.debug "Availability Set #{name} created successfully."
-            Azure::ARM::Compute::Models::AvailabilitySet.serialize_object(result.body)
+            availability_set = @compute_mgmt_client.availability_sets.create_or_update(resource_group, name, avail_set_params)
           rescue MsRestAzure::AzureOperationError => e
-            msg = "Exception creating Availability Set #{name} in Resource Group: #{resource_group}. #{e.body['error']['message']}"
-            raise msg
+            raise_azure_exception(e, msg)
           end
+          Fog::Logger.debug "Availability Set #{name} created successfully."
+          availability_set
         end
 
         # create the properties object for creating availability sets
-        def get_avail_set_properties(location)
-          avail_set_props = Azure::ARM::Compute::Models::AvailabilitySetProperties.new
-          # At least two domain faults
-          avail_set_props.platform_fault_domain_count = 2
-          avail_set_props.platform_update_domain_count = 2
-          # At this point we do not have virtual machines to include
-          avail_set_props.virtual_machines = []
-          avail_set_props.statuses = []
+        def get_availability_set_properties(location)
           avail_set = Azure::ARM::Compute::Models::AvailabilitySet.new
+          avail_set.platform_fault_domain_count = FAULT_DOMAIN_COUNT
+          avail_set.platform_update_domain_count = UPDATE_DOMAIN_COUNT
+          avail_set.virtual_machines = []
+          avail_set.statuses = []
           avail_set.location = location
-          avail_set.properties = avail_set_props
           avail_set
         end
       end
@@ -42,8 +37,8 @@ module Fog
             'type' => 'Microsoft.Compute/availabilitySets',
             'properties' =>
             {
-              'platformUpdateDomainCount' => 2,
-              'platformFaultDomainCount' => 2
+              'platformUpdateDomainCount' => FAULT_DOMAIN_COUNT,
+              'platformFaultDomainCount' => FAULT_DOMAIN_COUNT
             }
           }
         end

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

@@ -3,40 +3,47 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def create_virtual_machine(resource_group, name, location, vm_size, storage_account_name,
-                                   username, password, disable_password_authentication,
-                                   ssh_key_path, ssh_key_data, network_interface_card_id,
-                                   availability_set_id, publisher, offer, sku, version,
-                                   platform, provision_vm_agent, enable_automatic_updates)
-          Fog::Logger.debug "Creating Virtual Machine #{name} in Resource Group #{resource_group}."
-          params = Azure::ARM::Compute::Models::VirtualMachine.new
-          vm_properties = Azure::ARM::Compute::Models::VirtualMachineProperties.new
+        def create_virtual_machine(vm_hash)
+          msg = "Creating Virtual Machine #{vm_hash[:name]} in Resource Group #{vm_hash[:resource_group]}."
+          Fog::Logger.debug msg
+          virtual_machine = Azure::ARM::Compute::Models::VirtualMachine.new
 
-          unless availability_set_id.nil?
+          unless vm_hash[:availability_set_id].nil?
             sub_resource = MsRestAzure::SubResource.new
-            sub_resource.id = availability_set_id
-            vm_properties.availability_set = sub_resource
+            sub_resource.id = vm_hash[:availability_set_id]
+            virtual_machine.availability_set = sub_resource
           end
 
-          vm_properties.hardware_profile = define_hardware_profile(vm_size)
-          vm_properties.storage_profile = define_storage_profile(name, storage_account_name, publisher, offer, sku, version)
-          vm_properties.os_profile = if platform.casecmp('windows') == 0
-                                       define_windows_os_profile(name, username, password, provision_vm_agent, enable_automatic_updates)
+          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[:username],
+                                                                 vm_hash[:password],
+                                                                 vm_hash[:provision_vm_agent],
+                                                                 vm_hash[:enable_automatic_updates])
                                      else
-                                       define_linux_os_profile(name, username, password, disable_password_authentication, ssh_key_path, ssh_key_data)
+                                       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_properties.network_profile = define_network_profile(network_interface_card_id)
-          params.properties = vm_properties
-          params.location = location
+          virtual_machine.network_profile = define_network_profile(vm_hash[:network_interface_card_id])
+          virtual_machine.location = vm_hash[:location]
           begin
-            promise = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, name, params)
-            result = promise.value!
-            Fog::Logger.debug "Virtual Machine #{name} Created Successfully."
-            Azure::ARM::Compute::Models::VirtualMachine.serialize_object(result.body)
+            vm = @compute_mgmt_client.virtual_machines.create_or_update(vm_hash[:resource_group], vm_hash[:name], virtual_machine)
           rescue MsRestAzure::AzureOperationError => e
-            msg = "Error Creating Virtual Machine '#{name}' in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
-            raise msg
+            raise_azure_exception(e, msg)
           end
+          Fog::Logger.debug "Virtual Machine #{vm_hash[:name]} Created Successfully."
+          vm
         end
 
         private
@@ -110,37 +117,33 @@ module Fog
       end
       # This class provides the mock implementation for unit tests.
       class Mock
-        def create_virtual_machine(resource_group, name, location, vm_size, storage_account_name,
-                                   username, _password, disable_password_authentication,
-                                   _ssh_key_path, _ssh_key_data, network_interface_card_id,
-                                   _availability_set_id, publisher, offer, sku, version,
-                                   _platform, _provision_vm_agent, _enable_automatic_updates)
-          {
-            'location' => location,
-            'id' => "/subscriptions/########-####-####-####-############/resourceGroups/#{resource_group}/providers/Microsoft.Compute/virtualMachines/#{name}",
-            'name' => name,
+        def create_virtual_machine(*)
+          vm = {
+            'location' => 'westus',
+            'id' => '/subscriptions/########-####-####-####-############/resourceGroups/fog-test-rg/providers/Microsoft.Compute/virtualMachines/fog-test-server',
+            'name' => 'fog-test-server',
             'type' => 'Microsoft.Compute/virtualMachines',
             'properties' =>
             {
               'hardwareProfile' =>
                 {
-                  'vmSize' => vm_size
+                  'vmSize' => 'Standard_A0'
                 },
               'storageProfile' =>
                 {
                   'imageReference' =>
                     {
-                      'publisher' => publisher,
-                      'offer' => offer,
-                      'sku' => sku,
-                      'version' => version
+                      'publisher' => 'MicrosoftWindowsServerEssentials',
+                      'offer' => 'WindowsServerEssentials',
+                      'sku' => 'WindowsServerEssentials',
+                      'version' => 'latest'
                     },
                   'osDisk' =>
                     {
-                      'name' => "#{name}_os_disk",
+                      'name' => 'fog-test-server_os_disk',
                       'vhd' =>
                         {
-                          'uri' => "http://#{storage_account_name}.blob.core.windows.net/vhds/#{name}_os_disk.vhd"
+                          'uri' => 'http://mystorage1.blob.core.windows.net/vhds/fog-test-server_os_disk.vhd'
                         },
                       'createOption' => 'FromImage',
                       'osType' => 'Linux',
@@ -150,11 +153,11 @@ module Fog
                 },
               'osProfile' =>
                 {
-                  'computerName' => name,
-                  'adminUsername' => username,
+                  'computerName' => 'fog-test-server',
+                  'adminUsername' => 'fog',
                   'linuxConfiguration' =>
                     {
-                      'disablePasswordAuthentication' => disable_password_authentication
+                      'disablePasswordAuthentication' => true
                     },
                   'secrets' => []
                 },
@@ -163,13 +166,15 @@ module Fog
                   'networkInterfaces' =>
                     [
                       {
-                        'id' => "/subscriptions/########-####-####-####-############/resourceGroups/#{resource_group}/providers/Microsoft.Network/networkInterfaces/#{network_interface_card_id.split('/')[8]}"
+                        'id' => '/subscriptions/########-####-####-####-############/resourceGroups/fog-test-rg/providers/Microsoft.Network/networkInterfaces/fog-test-vnet'
                       }
                     ]
                 },
               'provisioningState' => 'Succeeded'
             }
           }
+          vm_mapper = Azure::ARM::Compute::Models::VirtualMachine.mapper
+          @compute_mgmt_client.deserialize(vm_mapper, vm, 'result.body')
         end
       end
     end