fog-azure-rm 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b05e068c2570129a04ec59038987d96cd2daf5d
-  data.tar.gz: 9d2740ade94fed00b138a4d2ba58e0909fd0d44d
+  metadata.gz: 33c1b3dbf863e197bc2a541c66577f56bc7e4aac
+  data.tar.gz: 3a7d2a9906695e7be641e1d641bbb7f1bf89c798
 SHA512:
-  metadata.gz: 7610426c54b2015495ddd93f6fb8acf7aa409e823eefa30d6721834662392fdec228dd336c132e87ea0d532b245e4f02f0fbcbf7392ec71cd0cf410705b7b259
-  data.tar.gz: 750ad15a028ee91a40a35d0a3bd39c4e2efd700f0756a367c54ae3d32fa2d0fe5626b6933a7354cb72c68f91b270b2a5739f42b8cc16468939b8fb97b17f666f
+  metadata.gz: a37083a43154de9aae645b01e329b44856cc2ac5b74b6baf972937d996980d1b2e32b3752a0be8e1b0130827fff01533c4e1166642af2d6615f8704ac23af547
+  data.tar.gz: d5d45fd735a93a8c0e6c93f10cd613d6c59c247e97e688ac66f9278352a84e2ba2b3bf56a3b567c7ac6dd18e4bc0dd58318e189cd8c74a39b1be7daed414dae5

data/lib/fog/azurerm/docs/compute.md

@@ -38,6 +38,9 @@ Create a new linux server
 **Info:**
 Attribute **network_interface_card_ids** is an array of NICs ids. The NIC id at index zero will become primary NIC of this server(virtual machine) by default.
 
+**Info:**
+When using **managed_disk_storage_type** you should not pass the **vhd_path** as the managed disk will be used for the OS disk. Also, data disks cannot be attached to a VM which uses managed disks for the OS disk.
+
 ```ruby
     azure_compute_service.servers.create(
         name: '<VM Name>',
@@ -56,7 +59,8 @@ Attribute **network_interface_card_ids** is an array of NICs ids. The NIC id at
         platform: 'Linux',
         vhd_path: '<Path of VHD>',                 # Optional, if you want to create the VM from a custom image.
         custom_data: 'echo customData',            # Optional, if you want to add custom data in this VM.
-        os_disk_caching: Fog::ARM::Compute::Models::CachingTypes::None # Optional, can be one of None, ReadOnly, ReadWrite
+        os_disk_caching: Fog::ARM::Compute::Models::CachingTypes::None, # Optional, can be one of None, ReadOnly, ReadWrite
+        managed_disk_storage_type: Azure::ARM::Compute::Models::StorageAccountTypes::StandardLRS # Optional, can be StandardLRS or PremiumLRS
     )
 ```
 
@@ -79,7 +83,8 @@ Create a new windows server
         version: 'latest',                               # Not required if custom image is being used
         platform: 'Windows',
         vhd_path: '<Path of VHD>',                       # Optional, if you want to create the VM from a custom image.
-        custom_data: 'echo customData'                   # Optional, if you want to add custom data in this VM.
+        custom_data: 'echo customData',                   # Optional, if you want to add custom data in this VM.
+        managed_disk_storage_type: Azure::ARM::Compute::Models::StorageAccountTypes::StandardLRS # Optional, can be StandardLRS or PremiumLRS
     )
 ```
 
@@ -105,7 +110,8 @@ Create a new linux server asynchronously
         platform: 'Linux',
         vhd_path: '<Path of VHD>',                 # Optional, if you want to create the VM from a custom image.
         custom_data: 'echo customData',            # Optional, if you want to add custom data in this VM.
-        os_disk_caching: Fog::ARM::Compute::Models::CachingTypes::None # Optional, can be one of None, ReadOnly, ReadWrite
+        os_disk_caching: Fog::ARM::Compute::Models::CachingTypes::None, # Optional, can be one of None, ReadOnly, ReadWrite
+        managed_disk_storage_type: Azure::ARM::Compute::Models::StorageAccountTypes::StandardLRS # Optional, can be StandardLRS or PremiumLRS
     )
 ```
 Following methods are available to handle async respoonse:

data/lib/fog/azurerm/models/compute/server.rb

@@ -30,6 +30,7 @@ module Fog
         attribute :availability_set_id
         attribute :custom_data
         attribute :vhd_path
+        attribute :managed_disk_storage_type
 
         def self.parse(vm)
           hash = {}
@@ -40,8 +41,14 @@ module Fog
           hash['vm_size'] = vm.hardware_profile.vm_size unless vm.hardware_profile.vm_size.nil?
           unless vm.storage_profile.nil?
             hash['os_disk_name'] = vm.storage_profile.os_disk.name
-            hash['os_disk_vhd_uri'] = vm.storage_profile.os_disk.vhd.uri
-            hash['storage_account_name'] = hash['os_disk_vhd_uri'].split('/')[2].split('.')[0]
+
+            if vm.storage_profile.os_disk.vhd.nil?
+              hash['managed_disk_storage_type'] = vm.storage_profile.os_disk.managed_disk.storage_account_type
+            else
+              hash['os_disk_vhd_uri'] = vm.storage_profile.os_disk.vhd.uri
+              hash['storage_account_name'] = hash['os_disk_vhd_uri'].split('/')[2].split('.')[0]
+            end
+
             hash['os_disk_caching'] = vm.storage_profile.os_disk.caching
             unless vm.storage_profile.image_reference.nil?
               hash['publisher'] = vm.storage_profile.image_reference.publisher
@@ -76,7 +83,7 @@ module Fog
         def save(async = false)
           requires :name, :location, :resource_group, :vm_size, :storage_account_name,
                    :username, :network_interface_card_ids
-          requires :publisher, :offer, :sku, :version if vhd_path.nil?
+          requires :publisher, :offer, :sku, :version if vhd_path.nil? && managed_disk_storage_type.nil?
 
           if platform_is_linux?(platform)
             requires :disable_password_authentication
@@ -94,50 +101,58 @@ module Fog
           end
         end
 
-        def destroy
-          service.delete_virtual_machine(resource_group, name)
+        def destroy(async = false)
+          response = service.delete_virtual_machine(resource_group, name, async)
+          async ? create_fog_async_response(response) : response
         end
 
-        def generalize
-          service.generalize_virtual_machine(resource_group, name)
+        def generalize(async = false)
+          response = service.generalize_virtual_machine(resource_group, name, async)
+          async ? create_fog_async_response(response) : response
         end
 
-        def power_off
-          service.power_off_virtual_machine(resource_group, name)
+        def power_off(async = false)
+          response = service.power_off_virtual_machine(resource_group, name, async)
+          async ? create_fog_async_response(response) : response
         end
 
-        def start
-          service.start_virtual_machine(resource_group, name)
+        def start(async = false)
+          response = service.start_virtual_machine(resource_group, name, async)
+          async ? create_fog_async_response(response) : response
         end
 
-        def restart
-          service.restart_virtual_machine(resource_group, name)
+        def restart(async = false)
+          response = service.restart_virtual_machine(resource_group, name, async)
+          async ? create_fog_async_response(response) : response
         end
 
-        def deallocate
-          service.deallocate_virtual_machine(resource_group, name)
+        def deallocate(async = false)
+          response = service.deallocate_virtual_machine(resource_group, name, async)
+          async ? create_fog_async_response(response) : response
         end
 
-        def redeploy
-          service.redeploy_virtual_machine(resource_group, name)
+        def redeploy(async = false)
+          response = service.redeploy_virtual_machine(resource_group, name, async)
+          async ? create_fog_async_response(response) : response
         end
 
-        def list_available_sizes
-          service.list_available_sizes_for_virtual_machine(resource_group, name)
+        def list_available_sizes(async = false)
+          response = service.list_available_sizes_for_virtual_machine(resource_group, name, async)
+          async ? create_fog_async_response(response) : response
         end
 
-        def vm_status
-          service.check_vm_status(resource_group, name)
+        def vm_status(async = false)
+          service.check_vm_status(resource_group, name, async)
         end
 
-        def attach_data_disk(disk_name, disk_size, storage_account_name)
-          vm = service.attach_data_disk_to_vm(resource_group, name, disk_name, disk_size, storage_account_name)
-          merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
+        def attach_data_disk(disk_name, disk_size, storage_account_name, async = false)
+          response = service.attach_data_disk_to_vm(resource_group, name, disk_name, disk_size, storage_account_name, async)
+          async ? create_fog_async_response(response) : merge_attributes(Fog::Compute::AzureRM::Server.parse(response))
         end
 
-        def detach_data_disk(disk_name)
-          vm = service.detach_data_disk_from_vm(resource_group, name, disk_name)
-          merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
+        def detach_data_disk(disk_name, async = false)
+          response = service.detach_data_disk_from_vm(resource_group, name, disk_name, async)
+          async ? create_fog_async_response(response) : merge_attributes(Fog::Compute::AzureRM::Server.parse(response))
         end
 
         private
@@ -146,6 +161,11 @@ module Fog
           platform.strip.casecmp(PLATFORM_LINUX).zero?
         end
 
+        def create_fog_async_response(response)
+          server = Fog::Compute::AzureRM::Server.new(service: service)
+          Fog::AzureRM::AsyncResponse.new(server, response)
+        end
+
         def virtual_machine_params(ssh_key_path)
           {
             resource_group: resource_group,
@@ -169,7 +189,8 @@ module Fog
             enable_automatic_updates: enable_automatic_updates,
             custom_data: custom_data,
             vhd_path: vhd_path,
-            os_disk_caching: os_disk_caching
+            os_disk_caching: os_disk_caching,
+            managed_disk_storage_type: managed_disk_storage_type
           }
         end
       end

data/lib/fog/azurerm/models/compute/servers.rb

@@ -22,14 +22,24 @@ module Fog
           Fog::AzureRM::AsyncResponse.new(server, async_response)
         end
 
-        def get(resource_group_name, virtual_machine_name)
-          virtual_machine = service.get_virtual_machine(resource_group_name, virtual_machine_name)
-          virtual_machine_fog = Fog::Compute::AzureRM::Server.new(service: service)
-          virtual_machine_fog.merge_attributes(Fog::Compute::AzureRM::Server.parse(virtual_machine))
+        def get(resource_group_name, virtual_machine_name, async = false)
+          response = service.get_virtual_machine(resource_group_name, virtual_machine_name, async)
+          virtual_machine = Fog::Compute::AzureRM::Server.new(service: service)
+          if async
+            Fog::AzureRM::AsyncResponse.new(virtual_machine, response)
+          else
+            virtual_machine.merge_attributes(Fog::Compute::AzureRM::Server.parse(response))
+          end
         end
 
-        def check_vm_exists(resource_group, name)
-          service.check_vm_exists(resource_group, name)
+        def check_vm_exists(resource_group, name, async = false)
+          response = service.check_vm_exists(resource_group, name, async)
+          if async
+            server = Fog::Compute::AzureRM::Server.new(service: service)
+            Fog::AzureRM::AsyncResponse.new(server, response)
+          else
+            response
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@ module Fog
     class AzureRM
       # 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)
+        def attach_data_disk_to_vm(resource_group, vm_name, disk_name, disk_size, storage_account_name, async)
           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)
@@ -13,7 +13,11 @@ module Fog
           vm.storage_profile.data_disks.push(data_disk)
           vm.resources = nil
           begin
-            virtual_machine = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, vm_name, vm)
+            if async
+              response = @compute_mgmt_client.virtual_machines.create_or_update_async(resource_group, vm_name, vm)
+            else
+              virtual_machine = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, vm_name, vm)
+            end
           rescue MsRestAzure::AzureOperationError => e
             if e.body.to_s =~ /InvalidParameter/ && e.body.to_s =~ /already exists/
               Fog::Logger.debug 'The disk is already attached'
@@ -21,8 +25,12 @@ module Fog
             raise_azure_exception(e, msg)
             end
           end
-          Fog::Logger.debug "Data Disk #{disk_name} attached to Virtual Machine #{vm_name} successfully."
-          virtual_machine
+          if async
+            response
+          else
+            Fog::Logger.debug "Data Disk #{disk_name} attached to Virtual Machine #{vm_name} successfully."
+            virtual_machine
+          end
         end
 
         private

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

@@ -3,21 +3,29 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def check_vm_exists(resource_group, name)
+        def check_vm_exists(resource_group, name, async)
           msg = "Checking Virtual Machine #{name}"
           Fog::Logger.debug msg
           begin
-            @compute_mgmt_client.virtual_machines.get(resource_group, name, 'instanceView')
-            Fog::Logger.debug "Virtual machine #{name} exists."
-            true
+            if async
+              response = @compute_mgmt_client.virtual_machines.get_async(resource_group, name, 'instanceView')
+            else
+              @compute_mgmt_client.virtual_machines.get(resource_group, name, 'instanceView')
+            end
           rescue MsRestAzure::AzureOperationError => e
             if e.body['error']['code'] == 'ResourceNotFound'
               Fog::Logger.debug "Virtual machine #{name} doesn't exist."
-              false
+              return false
             else
               raise_azure_exception(e, msg)
             end
           end
+          if async
+            response
+          else
+            Fog::Logger.debug "Virtual machine #{name} exists."
+            true
+          end
         end
       end
       # This class provides the mock implementation for unit tests.

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

@@ -3,7 +3,7 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def check_vm_status(resource_group, name)
+        def check_vm_status(resource_group, name, async)
           msg = "Checking Virtual Machine #{name} status"
           Fog::Logger.debug msg
           begin

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

@@ -30,7 +30,8 @@ module Fog
                                                                    vm_hash[:vhd_path],
                                                                    vm_hash[:os_disk_caching],
                                                                    vm_hash[:platform],
-                                                                   vm_hash[:resource_group])
+                                                                   vm_hash[:resource_group],
+                                                                   vm_hash[:managed_disk_storage_type])
 
           virtual_machine.os_profile = if vm_hash[:platform].casecmp(WINDOWS).zero?
                                          define_windows_os_profile(vm_hash[:name],
@@ -80,48 +81,55 @@ module Fog
           image_reference
         end
 
-        def define_storage_profile(vm_name, storage_account_name, publisher, offer, sku, version, vhd_path, os_disk_caching, platform, resource_group)
+        def define_storage_profile(vm_name, storage_account_name, publisher, offer, sku, version, vhd_path, os_disk_caching, platform, resource_group, managed_disk_storage_type)
           storage_profile = Azure::ARM::Compute::Models::StorageProfile.new
+          storage_profile.image_reference = image_reference(publisher, offer, sku, version)
           os_disk = Azure::ARM::Compute::Models::OSDisk.new
-          vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
 
-          vhd.uri = get_blob_endpoint(storage_account_name) + "/vhds/#{vm_name}_os_disk.vhd"
+          if managed_disk_storage_type.nil?  
+            vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
+            vhd.uri = get_blob_endpoint(storage_account_name) + "/vhds/#{vm_name}_os_disk.vhd"
 
-          if vhd_path.nil?
-            storage_profile.image_reference = image_reference(publisher, offer, sku, version)
-          else
-            # Copy if VHD does not exist belongs to same storage account.
-            vhd_storage_account = (vhd_path.split('/')[2]).split('.')[0]
-            if storage_account_name != vhd_storage_account
-              storage_account = @storage_service.storage_accounts.get(resource_group, storage_account_name)
-              access_key = storage_account.get_access_keys.first.value
-              storage_data = Fog::Storage::AzureRM.new(provider: 'AzureRM', azure_storage_account_name: storage_account_name, azure_storage_access_key: access_key)
-              new_time = current_time
-              container_name = "customvhd#{new_time}"
-              blob_name = "vhd_image#{new_time}.vhd"
-              storage_data.directories.create(
-                key: container_name
-              )
+            unless vhd_path.nil?
+              # Copy if VHD does not exist belongs to same storage account.
+              vhd_storage_account = (vhd_path.split('/')[2]).split('.')[0]
+              if storage_account_name != vhd_storage_account
+                storage_account = @storage_service.storage_accounts.get(resource_group, storage_account_name)
+                access_key = storage_account.get_access_keys.first.value
+                storage_data = Fog::Storage::AzureRM.new(provider: 'AzureRM', azure_storage_account_name: storage_account_name, azure_storage_access_key: access_key)
+                new_time = current_time
+                container_name = "customvhd#{new_time}"
+                blob_name = "vhd_image#{new_time}.vhd"
+                storage_data.directories.create(
+                  key: container_name
+                )
 
-              storage_data.copy_blob_from_uri(container_name, blob_name, vhd_path)
-              until storage_data.get_blob_properties(container_name, blob_name).properties[:copy_status] == 'success'
-                Fog::Logger.debug 'Waiting disk to ready'
-                sleep(10)
+                storage_data.copy_blob_from_uri(container_name, blob_name, vhd_path)
+                until storage_data.get_blob_properties(container_name, blob_name).properties[:copy_status] == 'success'
+                  Fog::Logger.debug 'Waiting disk to ready'
+                  sleep(10)
+                end
+                new_vhd_path = get_blob_endpoint(storage_account_name) + "/#{container_name}/#{blob_name}"
+                Fog::Logger.debug "Path:#{new_vhd_path}. | Copy done"
+              else
+                new_vhd_path = vhd_path
               end
-              new_vhd_path = get_blob_endpoint(storage_account_name) + "/#{container_name}/#{blob_name}"
-              Fog::Logger.debug "Path:#{new_vhd_path}. | Copy done"
-            else
-              new_vhd_path = vhd_path
+
+              img_vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
+              img_vhd.uri = new_vhd_path
+              os_disk.image = img_vhd
             end
 
-            img_vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
-            img_vhd.uri = new_vhd_path
-            os_disk.image = img_vhd
-            os_disk.os_type = platform
+            os_disk.vhd = vhd
+          else
+            managed_disk = Azure::ARM::Compute::Models::ManagedDiskParameters.new
+            managed_disk.storage_account_type = managed_disk_storage_type
+            os_disk.managed_disk = managed_disk
           end
-
+        
           os_disk.name = "#{vm_name}_os_disk"
-          os_disk.vhd = vhd
+          os_disk.os_type = platform
+          
           os_disk.create_option = Azure::ARM::Compute::Models::DiskCreateOptionTypes::FromImage
           os_disk.caching = unless os_disk_caching.nil?
                               case os_disk_caching
@@ -133,7 +141,7 @@ module Fog
                                 Azure::ARM::Compute::Models::CachingTypes::ReadWrite
                               end
                             end
-
+          
           storage_profile.os_disk = os_disk
           storage_profile
         end

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

@@ -3,16 +3,24 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def deallocate_virtual_machine(resource_group, name)
+        def deallocate_virtual_machine(resource_group, name, async)
           msg = "Deallocating Virtual Machine #{name} in Resource Group #{resource_group}"
           Fog::Logger.debug msg
           begin
-            @compute_mgmt_client.virtual_machines.deallocate(resource_group, name)
+            if async
+              response = @compute_mgmt_client.virtual_machines.deallocate_async(resource_group, name)
+            else
+              @compute_mgmt_client.virtual_machines.deallocate(resource_group, name)
+            end
           rescue  MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Virtual Machine #{name} Deallocated Successfully."
-          true
+          if async
+            response
+          else
+            Fog::Logger.debug "Virtual Machine #{name} Deallocated Successfully."
+            true
+          end
         end
       end
       # This class provides the mock implementation for unit tests.

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

@@ -3,16 +3,24 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def delete_virtual_machine(resource_group, name)
+        def delete_virtual_machine(resource_group, name, async)
           msg = "Deleting Virtual Machine #{name} from Resource Group #{resource_group}"
           Fog::Logger.debug msg
           begin
-            @compute_mgmt_client.virtual_machines.delete(resource_group, name)
+            if async
+              response = @compute_mgmt_client.virtual_machines.delete_async(resource_group, name)
+            else
+              @compute_mgmt_client.virtual_machines.delete(resource_group, name)
+            end
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Virtual Machine #{name} Deleted Successfully."
-          true
+          if async
+            response
+          else
+            Fog::Logger.debug "Virtual Machine #{name} Deleted Successfully."
+            true
+          end
         end
       end
       # This class provides the mock implementation for unit tests.

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

@@ -3,7 +3,7 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def detach_data_disk_from_vm(resource_group, vm_name, disk_name)
+        def detach_data_disk_from_vm(resource_group, vm_name, disk_name, async)
           msg = "Detaching Data Disk #{disk_name} from 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)
@@ -14,12 +14,20 @@ module Fog
           end
           vm.resources = nil
           begin
-            virtual_machine = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, vm_name, vm)
+            if async
+              response = @compute_mgmt_client.virtual_machines.create_or_update_async(resource_group, vm_name, vm)
+            else
+              virtual_machine = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, vm_name, vm)
+            end
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Data Disk #{disk_name} detached from Virtual Machine #{vm_name} successfully."
-          virtual_machine
+          if async
+            response
+          else
+            Fog::Logger.debug "Data Disk #{disk_name} detached from Virtual Machine #{vm_name} successfully."
+            virtual_machine
+          end
         end
       end
       # This class provides the mock implementation for unit tests.

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

@@ -3,16 +3,24 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def generalize_virtual_machine(resource_group, name)
+        def generalize_virtual_machine(resource_group, name, async)
           msg = "Generalizing Virtual Machine #{name} in Resource Group #{resource_group}"
           Fog::Logger.debug msg
           begin
-            @compute_mgmt_client.virtual_machines.generalize(resource_group, name)
+            if async
+              response = @compute_mgmt_client.virtual_machines.generalize_async(resource_group, name)
+            else
+              @compute_mgmt_client.virtual_machines.generalize(resource_group, name)
+            end
           rescue  MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Virtual Machine #{name} Generalized Successfully."
-          true
+          if async
+            response
+          else
+            Fog::Logger.debug "Virtual Machine #{name} Generalized Successfully."
+            true
+          end
         end
       end
       # This class provides the mock implementation for unit tests.

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

@@ -3,16 +3,20 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def get_virtual_machine(resource_group, name)
+        def get_virtual_machine(resource_group, name, async)
           msg = "Getting Virtual Machine #{name} from Resource Group '#{resource_group}'"
           Fog::Logger.debug msg
           begin
-            virtual_machine = @compute_mgmt_client.virtual_machines.get(resource_group, name)
+            if async
+              response = @compute_mgmt_client.virtual_machines.get_async(resource_group, name)
+            else
+              response = @compute_mgmt_client.virtual_machines.get(resource_group, name)
+            end
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Getting Virtual Machine #{name} from Resource Group '#{resource_group}' successful"
-          virtual_machine
+          Fog::Logger.debug "Getting Virtual Machine #{name} from Resource Group '#{resource_group}' successful" unless async
+          response
         end
       end
       # This class provides the mock implementation for unit tests.

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

@@ -3,16 +3,24 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def list_available_sizes_for_virtual_machine(resource_group, name)
+        def list_available_sizes_for_virtual_machine(resource_group, name, async)
           msg = "Listing sizes for Virtual Machine #{name} in Resource Group #{resource_group}"
           Fog::Logger.debug msg
           begin
-            vm_sizes = @compute_mgmt_client.virtual_machines.list_available_sizes(resource_group, name)
+            if async
+              response = @compute_mgmt_client.virtual_machines.list_available_sizes_async(resource_group, name)
+            else
+              vm_sizes = @compute_mgmt_client.virtual_machines.list_available_sizes(resource_group, name)
+            end
           rescue MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Successfully listed sizes for Virtual Machine #{name} in Resource Group #{resource_group}"
-          vm_sizes.value
+          if async
+            response
+          else
+            Fog::Logger.debug "Successfully listed sizes for Virtual Machine #{name} in Resource Group #{resource_group}"
+            vm_sizes.value
+          end
         end
       end
       # This class provides the mock implementation for unit tests.

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

@@ -3,16 +3,24 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def power_off_virtual_machine(resource_group, name)
+        def power_off_virtual_machine(resource_group, name, async)
           msg = "Powering off Virtual Machine #{name} in Resource Group #{resource_group}"
           Fog::Logger.debug msg
           begin
-            @compute_mgmt_client.virtual_machines.power_off(resource_group, name)
+            if async 
+              response = @compute_mgmt_client.virtual_machines.power_off_async(resource_group, name)
+            else
+              @compute_mgmt_client.virtual_machines.power_off(resource_group, name)
+            end
           rescue  MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Virtual Machine #{name} Powered off Successfully."
-          true
+          if async
+            response
+          else
+            Fog::Logger.debug "Virtual Machine #{name} Powered off Successfully."
+            true
+          end
         end
       end
       # This class provides the mock implementation for unit tests.

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

@@ -3,16 +3,24 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def redeploy_virtual_machine(resource_group, name)
+        def redeploy_virtual_machine(resource_group, name, async)
           msg = "Redeploying Virtual Machine #{name} in Resource Group #{resource_group}."
           Fog::Logger.debug msg
           begin
-            @compute_mgmt_client.virtual_machines.redeploy(resource_group, name)
+            if async
+              response = @compute_mgmt_client.virtual_machines.redeploy_async(resource_group, name)
+            else
+              @compute_mgmt_client.virtual_machines.redeploy(resource_group, name)
+            end
           rescue  MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Virtual Machine #{name} Redeployed Successfully."
-          true
+          if async
+            response
+          else
+            Fog::Logger.debug "Virtual Machine #{name} Redeployed Successfully."
+            true
+          end
         end
       end
       # This class provides the mock implementation for unit tests.

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

@@ -3,16 +3,24 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def restart_virtual_machine(resource_group, name)
+        def restart_virtual_machine(resource_group, name, async)
           msg = "Restarting Virtual Machine #{name} in Resource Group #{resource_group}"
           Fog::Logger.debug msg
           begin
-            @compute_mgmt_client.virtual_machines.restart(resource_group, name)
+            if async
+              response = @compute_mgmt_client.virtual_machines.restart_async(resource_group, name)
+            else
+              @compute_mgmt_client.virtual_machines.restart(resource_group, name)
+            end
           rescue  MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Virtual Machine #{name} Restarted Successfully."
-          true
+          if async
+            response
+          else
+            Fog::Logger.debug "Virtual Machine #{name} Restarted Successfully."
+            true
+          end
         end
       end
       # This class provides the mock implementation for unit tests.

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

@@ -3,16 +3,24 @@ module Fog
     class AzureRM
       # This class provides the actual implementation for service calls.
       class Real
-        def start_virtual_machine(resource_group, name)
+        def start_virtual_machine(resource_group, name, async)
           msg = "Starting Virtual Machine #{name} in Resource Group #{resource_group}."
           Fog::Logger.debug msg
           begin
-            @compute_mgmt_client.virtual_machines.start(resource_group, name)
+            if async
+              response = @compute_mgmt_client.virtual_machines.start_async(resource_group, name)
+            else
+              @compute_mgmt_client.virtual_machines.start(resource_group, name)
+            end
           rescue  MsRestAzure::AzureOperationError => e
             raise_azure_exception(e, msg)
           end
-          Fog::Logger.debug "Virtual Machine #{name} started Successfully."
-          true
+          if async
+            response
+          else
+            Fog::Logger.debug "Virtual Machine #{name} started Successfully."
+            true
+          end
         end
       end
       # This class provides the mock implementation for unit tests.

data/lib/fog/azurerm/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module AzureRM
-    VERSION = '0.3.1'.freeze
+    VERSION = '0.3.2'.freeze
   end
 end

data/test/models/compute/test_server.rb

@@ -84,42 +84,77 @@ class TestServer < Minitest::Test
     @service.stub :delete_virtual_machine, true do
       assert @server.destroy
     end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :delete_virtual_machine, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.destroy(true)
+    end
   end
 
   def test_generalize_method_response
     @service.stub :generalize_virtual_machine, true do
       assert @server.generalize
     end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :generalize_virtual_machine, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.generalize(true)
+    end
   end
 
   def test_power_off_method_response
     @service.stub :power_off_virtual_machine, true do
       assert @server.power_off
     end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :power_off_virtual_machine, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.power_off(true)
+    end
   end
 
   def test_start_method_response
     @service.stub :start_virtual_machine, true do
       assert @server.start
     end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :start_virtual_machine, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.start(true)
+    end
   end
 
   def test_restart_method_response
     @service.stub :restart_virtual_machine, true do
       assert @server.restart
     end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :restart_virtual_machine, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.restart(true)
+    end
   end
 
   def test_deallocate_method_response
     @service.stub :deallocate_virtual_machine, true do
       assert @server.deallocate
     end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :deallocate_virtual_machine, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.deallocate(true)
+    end
   end
 
   def test_redeploy_method_response
     @service.stub :redeploy_virtual_machine, true do
       assert @server.redeploy
     end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :redeploy_virtual_machine, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.redeploy(true)
+    end
   end
 
   def test_vm_status_method_response
@@ -131,7 +166,12 @@ class TestServer < Minitest::Test
   def test_list_available_sizes_method_response
     response = ApiStub::Models::Compute::Server.list_available_sizes_for_virtual_machine_response(@compute_client)
     @service.stub :list_available_sizes_for_virtual_machine, response do
-      assert_instance_of Array, @server.list_available_sizes
+      assert_instance_of Array, @server.list_available_sizes(false)
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :list_available_sizes_for_virtual_machine, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.list_available_sizes(true)
     end
   end
 
@@ -140,6 +180,11 @@ class TestServer < Minitest::Test
     @service.stub :attach_data_disk_to_vm, response do
       assert_instance_of Fog::Compute::AzureRM::Server, @server.attach_data_disk('disk1', '10', 'mystorage1')
     end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :attach_data_disk_to_vm, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.attach_data_disk('disk', '10', 'mystorage1', true)
+    end
   end
 
   def test_detach_data_disk_response
@@ -147,5 +192,10 @@ class TestServer < Minitest::Test
     @service.stub :detach_data_disk_from_vm, response do
       assert_instance_of Fog::Compute::AzureRM::Server, @server.detach_data_disk('disk1')
     end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @service.stub :detach_data_disk_from_vm, async_response do
+      assert_instance_of Fog::AzureRM::AsyncResponse, @server.detach_data_disk('disk1', true)
+    end
   end
 end

data/test/requests/compute/test_deallocate_virtual_machine.rb

@@ -10,14 +10,23 @@ class TestDeallocateVirtualMachine < Minitest::Test
 
   def test_deallocate_virtual_machine_success
     @virtual_machines.stub :deallocate, true do
-      assert @service.deallocate_virtual_machine('fog-test-rg', 'fog-test-server')
+      assert @service.deallocate_virtual_machine('fog-test-rg', 'fog-test-server', false)
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @virtual_machines.stub :deallocate_async, async_response do
+      assert @service.deallocate_virtual_machine('fog-test-rg', 'fog-test-server', true), async_response
     end
   end
 
   def test_deallocate_virtual_machine_failure
     response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
     @virtual_machines.stub :deallocate, response do
-      assert_raises(RuntimeError) { @service.deallocate_virtual_machine('fog-test-rg', 'fog-test-server') }
+      assert_raises(RuntimeError) { @service.deallocate_virtual_machine('fog-test-rg', 'fog-test-server', false) }
+    end
+
+    @virtual_machines.stub :deallocate_async, response do
+      assert_raises(RuntimeError) { @service.deallocate_virtual_machine('fog-test-rg', 'fog-test-server', true) }
     end
   end
 end

data/test/requests/compute/test_delete_virtual_machine.rb

@@ -10,14 +10,23 @@ class TestDeleteVirtualMachine < Minitest::Test
 
   def test_delete_virtual_machine_success
     @virtual_machines.stub :delete, true do
-      assert @service.delete_virtual_machine('fog-test-rg', 'fog-test-server')
+      assert @service.delete_virtual_machine('fog-test-rg', 'fog-test-server', false)
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @virtual_machines.stub :delete_async, async_response do
+      assert @service.delete_virtual_machine('fog-test-rg', 'fog-test-server', true), async_response
     end
   end
 
   def test_delete_virtual_machine_failure
     response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
     @virtual_machines.stub :delete, response do
-      assert_raises(RuntimeError) { @service.delete_virtual_machine('fog-test-rg', 'fog-test-server') }
+      assert_raises(RuntimeError) { @service.delete_virtual_machine('fog-test-rg', 'fog-test-server', false) }
+    end
+
+    @virtual_machines.stub :delete_async, response do
+      assert_raises(RuntimeError) { @service.delete_virtual_machine('fog-test-rg', 'fog-test-server', true) }
     end
   end
 end

data/test/requests/compute/test_generalize_virtual_machine.rb

@@ -10,14 +10,23 @@ class TestGeneralizeVirtualMachine < Minitest::Test
 
   def test_generalize_virtual_machine_success
     @virtual_machines.stub :generalize, true do
-      assert @service.generalize_virtual_machine('fog-test-rg', 'fog-test-server')
+      assert @service.generalize_virtual_machine('fog-test-rg', 'fog-test-server', false)
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @virtual_machines.stub :generalize_async, async_response do
+      assert @service.generalize_virtual_machine('fog-test-rg', 'fog-test-server', true), async_response
     end
   end
 
   def test_generalize_virtual_machine_failure
     response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
     @virtual_machines.stub :generalize, response do
-      assert_raises(RuntimeError) { @service.generalize_virtual_machine('fog-test-rg', 'fog-test-server') }
+      assert_raises(RuntimeError) { @service.generalize_virtual_machine('fog-test-rg', 'fog-test-server', false) }
+    end
+
+    @virtual_machines.stub :generalize_async, response do
+      assert_raises(RuntimeError) { @service.generalize_virtual_machine('fog-test-rg', 'fog-test-server', true) }
     end
   end
 end

data/test/requests/compute/test_list_available_sizes_for_virtual_machine.rb

@@ -11,14 +11,23 @@ class TestListAvailableSizesForVirtualMachine < Minitest::Test
   def test_list_available_sizes_for_virtual_machine_success
     response = ApiStub::Requests::Compute::VirtualMachine.list_available_sizes_for_virtual_machine_response(@compute_client)
     @virtual_machines.stub :list_available_sizes, response do
-      assert_equal @service.list_available_sizes_for_virtual_machine('fog-test-rg', 'fog-test-server'), response.value
+      assert_equal @service.list_available_sizes_for_virtual_machine('fog-test-rg', 'fog-test-server', false), response.value
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @virtual_machines.stub :list_available_sizes_async, async_response do
+      assert @service.list_available_sizes_for_virtual_machine('fog-test-rg', 'fog-test-server', true), async_response
     end
   end
 
   def test_list_available_sizes_for_virtual_machine_failure
     response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
     @virtual_machines.stub :list_available_sizes, response do
-      assert_raises(RuntimeError) { @service.list_available_sizes_for_virtual_machine('fog-test-rg', 'fog-test-server') }
+      assert_raises(RuntimeError) { @service.list_available_sizes_for_virtual_machine('fog-test-rg', 'fog-test-server', false) }
+    end
+
+    @virtual_machines.stub :list_available_sizes_async, response do
+      assert_raises(RuntimeError) { @service.list_available_sizes_for_virtual_machine('fog-test-rg', 'fog-test-server', true) }
     end
   end
 end

data/test/requests/compute/test_power_off_virtual_machine.rb

@@ -10,14 +10,23 @@ class TestPowerOffVirtualMachine < Minitest::Test
 
   def test_power_off_virtual_machine_success
     @virtual_machines.stub :power_off, true do
-      assert @service.power_off_virtual_machine('fog-test-rg', 'fog-test-server')
+      assert @service.power_off_virtual_machine('fog-test-rg', 'fog-test-server' ,false)
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @virtual_machines.stub :power_off_async, async_response do
+      assert @service.power_off_virtual_machine('fog-test-rg', 'fog-test-server', true), async_response
     end
   end
 
   def test_power_off_virtual_machine_failure
     response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
     @virtual_machines.stub :power_off, response do
-      assert_raises(RuntimeError) { @service.power_off_virtual_machine('fog-test-rg', 'fog-test-server') }
+      assert_raises(RuntimeError) { @service.power_off_virtual_machine('fog-test-rg', 'fog-test-server', false) }
+    end
+
+    @virtual_machines.stub :power_off_async, response do
+      assert_raises(RuntimeError) { @service.power_off_virtual_machine('fog-test-rg', 'fog-test-server', true) }
     end
   end
 end

data/test/requests/compute/test_redeploy_virtual_machine.rb

@@ -10,14 +10,24 @@ class TestRedeployVirtualMachine < Minitest::Test
 
   def test_redeploy_virtual_machine_success
     @virtual_machines.stub :redeploy, true do
-      assert @service.redeploy_virtual_machine('fog-test-rg', 'fog-test-server')
+      assert @service.redeploy_virtual_machine('fog-test-rg', 'fog-test-server', false)
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @virtual_machines.stub :redeploy_async, async_response do
+      assert @service.redeploy_virtual_machine('fog-test-rg', 'fog-test-server', true), async_response
     end
   end
 
   def test_redeploy_virtual_machine_failure
     response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
     @virtual_machines.stub :redeploy, response do
-      assert_raises(RuntimeError) { @service.redeploy_virtual_machine('fog-test-rg', 'fog-test-server') }
+      assert_raises(RuntimeError) { @service.redeploy_virtual_machine('fog-test-rg', 'fog-test-server', false) }
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @virtual_machines.stub :redeploy_async, response do
+      assert_raises(RuntimeError) { @service.redeploy_virtual_machine('fog-test-rg', 'fog-test-server', true) }
     end
   end
 end

data/test/requests/compute/test_restart_virtual_machine.rb

@@ -10,14 +10,23 @@ class TestRestartVirtualMachine < Minitest::Test
 
   def test_restart_virtual_machine_success
     @virtual_machines.stub :restart, true do
-      assert @service.restart_virtual_machine('fog-test-rg', 'fog-test-server')
+      assert @service.restart_virtual_machine('fog-test-rg', 'fog-test-server', false)
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @virtual_machines.stub :restart_async, async_response do
+      assert @service.restart_virtual_machine('fog-test-rg', 'fog-test-server', true), async_response
     end
   end
 
   def test_restart_virtual_machine_failure
     response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
     @virtual_machines.stub :restart, response do
-      assert_raises(RuntimeError) { @service.restart_virtual_machine('fog-test-rg', 'fog-test-server') }
+      assert_raises(RuntimeError) { @service.restart_virtual_machine('fog-test-rg', 'fog-test-server', false) }
+    end
+
+    @virtual_machines.stub :restart_async, response do
+      assert_raises(RuntimeError) { @service.restart_virtual_machine('fog-test-rg', 'fog-test-server', true) }
     end
   end
 end

data/test/requests/compute/test_start_virtual_machine.rb

@@ -10,14 +10,23 @@ class TestStartVirtualMachine < Minitest::Test
 
   def test_start_virtual_machine_success
     @virtual_machines.stub :start, true do
-      assert @service.start_virtual_machine('fog-test-rg', 'fog-test-server')
+      assert @service.start_virtual_machine('fog-test-rg', 'fog-test-server', false)
+    end
+
+    async_response = Concurrent::Promise.execute { 10 }
+    @virtual_machines.stub :start_async, async_response do
+      assert @service.start_virtual_machine('fog-test-rg', 'fog-test-server', true), async_response
     end
   end
 
   def test_start_virtual_machine_failure
     response = proc { fail MsRestAzure::AzureOperationError.new(nil, nil, 'error' => { 'message' => 'mocked exception' }) }
     @virtual_machines.stub :start, response do
-      assert_raises(RuntimeError) { @service.start_virtual_machine('fog-test-rg', 'fog-test-server') }
+      assert_raises(RuntimeError) { @service.start_virtual_machine('fog-test-rg', 'fog-test-server', false) }
+    end
+
+    @virtual_machines.stub :start_async, response do
+      assert_raises(RuntimeError) { @service.start_virtual_machine('fog-test-rg', 'fog-test-server', true) }
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fog-azure-rm
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Shaffan Chaudhry
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-03 00:00:00.000000000 Z
+date: 2017-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake