far-gem 0.5.1

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

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class provides the actual implementation for service calls.
+      class Real
+        def check_vm_extension_exists(resource_group_name, virtual_machine_name, vm_extension_name)
+          msg = "Checking Virtual Machine Extension #{vm_extension_name}"
+          Fog::Logger.debug msg
+          begin
+            @compute_mgmt_client.virtual_machine_extensions.get(resource_group_name, virtual_machine_name, vm_extension_name)
+            Fog::Logger.debug "Virtual Machine Extension #{vm_extension_name} exists."
+            true
+          rescue MsRestAzure::AzureOperationError => e
+            if resource_not_found?(e)
+              Fog::Logger.debug "Virtual Machine Extension #{vm_extension_name} doesn't exist."
+              false
+            else
+              raise_azure_exception(e, msg)
+            end
+          end
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def check_vm_extension_exists(*)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class provides the actual implementation for service calls.
+      class Real
+        def check_vm_status(resource_group, name, async)
+          msg = "Checking Virtual Machine #{name} status"
+          Fog::Logger.debug msg
+          begin
+            virtual_machine = @compute_mgmt_client.virtual_machines.get(resource_group, name, 'instanceView')
+          rescue  MsRestAzure::AzureOperationError => e
+            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.instance_view.statuses
+          vm_status = nil
+          vm_statuses.each do |status|
+            if status.code.include? 'PowerState'
+              Fog::Logger.debug status.display_status.to_s
+              vm_status = status.code.split('/')[1]
+            end
+          end
+          vm_status
+        end
+      end
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def check_vm_status(_resource_group, _name)
+          'running'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class provides the actual implementation for service calls.
+      class Real
+        def create_availability_set(availability_set_params)
+          name = availability_set_params[:name]
+          location = availability_set_params[:location]
+          resource_group = availability_set_params[:resource_group]
+          fault_domain_count = availability_set_params[:platform_fault_domain_count]
+          update_domain_count = availability_set_params[:platform_update_domain_count]
+          use_managed_disk = availability_set_params[:use_managed_disk].nil? ? false : availability_set_params[:use_managed_disk]
+          tags = availability_set_params[:tags]
+
+          msg = "Creating Availability Set '#{name}' in #{location} region."
+          Fog::Logger.debug msg
+          avail_set_params = get_availability_set_properties(location, fault_domain_count, update_domain_count, use_managed_disk, tags)
+
+          begin
+            availability_set = @compute_mgmt_client.availability_sets.create_or_update(resource_group, name, avail_set_params)
+          rescue MsRestAzure::AzureOperationError => e
+            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_availability_set_properties(location, fault_domain_count, update_domain_count, use_managed_disk, tags)
+          avail_set = Azure::ARM::Compute::Models::AvailabilitySet.new
+          avail_set.location = location
+          avail_set.sku = create_availability_set_sku(use_managed_disk)
+          avail_set.platform_fault_domain_count = fault_domain_count.nil? ? FAULT_DOMAIN_COUNT : fault_domain_count
+          avail_set.platform_update_domain_count = update_domain_count.nil? ? UPDATE_DOMAIN_COUNT : update_domain_count
+          avail_set.tags = tags
+          avail_set
+        end
+
+        def create_availability_set_sku(use_managed_disk)
+          sku = Azure::ARM::Compute::Models::Sku.new
+          sku.name = use_managed_disk ? AS_SKU_ALIGNED : AS_SKU_CLASSIC
+          sku
+        end
+      end
+
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def create_availability_set(availability_set_params)
+          {
+            'location' => availability_set_params[:location],
+            'id' => "/subscriptions/########-####-####-####-############/resourceGroups/#{availability_set_params[:resource_group]}/providers/Microsoft.Compute/availabilitySets/#{availability_set_params[:name]}",
+            'name' => availability_set_params[:name],
+            'type' => 'Microsoft.Compute/availabilitySets',
+            'properties' =>
+            {
+              'platformUpdateDomainCount' => FAULT_DOMAIN_COUNT,
+              'platformFaultDomainCount' => FAULT_DOMAIN_COUNT
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class provides the actual implementation for service calls.
+      class Real
+        def create_image(image_config)
+          msg = "Creating/Updating Image: #{image_config[:vm_name]}-osImage"
+          Fog::Logger.debug msg
+          image_name = "#{image_config[:vm_name]}-osImage"
+          image = setup_params(image_config)
+          begin
+            image_obj = @compute_mgmt_client.images.create_or_update(image_config[:resource_group], image_name, image)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Image #{image_name} created/updated successfully."
+          image_obj
+        end
+
+        private
+
+        def setup_params(image_config)
+          storage_profile_image = Azure::ARM::Compute::Models::ImageStorageProfile.new
+          storage_profile_image.os_disk = create_generalized_os_disk_image(image_config)
+          image = Azure::ARM::Compute::Models::Image.new
+          image.storage_profile = storage_profile_image
+          image.location = image_config[:location]
+          image
+        end
+
+        def create_generalized_os_disk_image(image_config)
+          os_disk_image = Azure::ARM::Compute::Models::ImageOSDisk.new
+          os_disk_image.os_type = image_config[:platform]
+          os_disk_image.os_state = 'Generalized'
+          os_disk_image.blob_uri = image_config[:new_vhd_path]
+          os_disk_image.caching = Azure::ARM::Compute::Models::CachingTypes::ReadWrite
+          os_disk_image
+        end
+      end
+
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def create_image(*)
+          image_obj = {
+            'location' => 'West US',
+            'tags' => {
+              'key' => 'value'
+            },
+            'properties' => {
+              'storageProfile' => {
+                'osDisk' => {
+                  'osType' => 'Linux',
+                  'blobUri' => 'https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd',
+                  'osState' => 'generalized',
+                  'hostCaching' => 'readwrite',
+                  'storageAccountType' => 'Standard_LRS'
+                },
+                'provisioningState' => 'Succeeded'
+              }
+            }
+          }
+          image_mapper = Azure::ARM::Compute::Models::Image.mapper
+          @compute_mgmt_client.deserialize(image_mapper, image_obj, 'result.body')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+module Fog
+  module Compute
+    class AzureRM
+      # Real class for Compute Request
+      class Real
+        def create_or_update_managed_disk(managed_disk_params)
+          msg = "Creating/Updating Managed Disk: #{managed_disk_params[:name]}"
+          Fog::Logger.debug msg
+          disk = get_managed_disk_object(managed_disk_params)
+          begin
+            managed_disk = @compute_mgmt_client.disks.create_or_update(managed_disk_params[:resource_group_name], managed_disk_params[:name], disk)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Managed Disk #{managed_disk_params[:name]} created/updated successfully."
+          managed_disk
+        end
+
+        private
+
+        def get_managed_disk_object(managed_disk_params)
+          managed_disk = Azure::ARM::Compute::Models::Disk.new
+          managed_disk.name = managed_disk_params[:name]
+          managed_disk.type = DISK_PREFIX
+          managed_disk.location = managed_disk_params[:location]
+          managed_disk.account_type = managed_disk_params[:account_type]
+          managed_disk.os_type = managed_disk_params[:os_type]
+          managed_disk.disk_size_gb = managed_disk_params[:disk_size_gb]
+          managed_disk.tags = managed_disk_params[:tags] if managed_disk.tags.nil?
+
+          creation_data = managed_disk_params[:creation_data]
+          managed_disk.creation_data = get_creation_data_object(creation_data) unless creation_data.nil?
+
+          encryption_settings = managed_disk_params[:encryption_settings]
+          managed_disk.encryption_settings = get_encryption_settings_object(encryption_settings) unless encryption_settings.nil?
+
+          managed_disk
+        end
+
+        def get_creation_data_object(data)
+          creation_data = Azure::ARM::Compute::Models::CreationData.new
+          creation_data.create_option = data[:create_option]
+          creation_data.storage_account_id = data[:storage_account_id]
+          creation_data.source_uri = data[:source_uri]
+          creation_data.source_resource_id = data[:source_resource_id]
+
+          image_reference = data[:image_reference]
+          unless image_reference.nil?
+            image_disk_reference = Azure::ARM::Compute::Models::ImageDiskReference.new
+            image_disk_reference.id = image_reference[:id]
+            image_disk_reference.lun = image_reference[:lun]
+
+            creation_data.image_reference = image_disk_reference
+          end
+          creation_data
+        end
+
+        def get_encryption_settings_object(settings)
+          encryption_settings = Azure::ARM::Compute::Models::EncryptionSettings.new
+          disk_encryption_key = Azure::ARM::Compute::Models::KeyVaultAndSecretReference.new
+          disk_encryption_key.secret_url = settings[:secret_url]
+          disk_encryption_key.source_vault.id = settings[:disk_source_vault_id]
+          encryption_settings.disk_encryption_key = disk_encryption_key
+
+          encryption_settings.enabled = settings[:enabled]
+
+          key_encryption_key = Azure::ARM::Compute::Models::KeyVaultAndKeyReference.new
+          key_encryption_key.key_url = settings[:key_uri]
+          key_encryption_key.source_vault = settings[:key_source_vault_id]
+          encryption_settings.key_encryption_key = key_encryption_key
+
+          encryption_settings
+        end
+      end
+
+      # Mock class for Compute Request
+      class Mock
+        def create_or_update_managed_disk(*)
+          disk = {
+            'accountType' => 'Standard_LRS',
+            'properties' => {
+              'osType' => 'Windows',
+              'creationData' => {
+                'createOption' => 'Empty'
+              },
+              'diskSizeGB' => 10,
+              'encryptionSettings' => {
+                'enabled' => true,
+                'diskEncryptionKey' => {
+                  'sourceVault' => {
+                    'id' => '/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.KeyVault/vaults/myVMVault'
+                  },
+                  'secretUrl' => 'https://myvmvault.vault-int.azure-int.net/secrets/{secret}'
+                },
+                'keyEncryptionKey' => {
+                  'sourceVault' => {
+                    'id' => '/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.KeyVault/vaults/myVMVault'
+                  },
+                  'keyUrl' => 'https://myvmvault.vault-int.azure-int.net/keys/{key}'
+                }
+              },
+              'timeCreated' => '2016-12-28T02:46:21.3322041+00:00',
+              'provisioningState' => 'Succeeded',
+              'diskState' => 'Unattached'
+            },
+            'type' => 'Microsoft.Compute/disks',
+            'location' => 'westus',
+            'tags' => {
+              'department' => 'Development',
+              'project' => 'ManagedDisks'
+            },
+            'id' => '/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk1',
+            'name' => 'myManagedDisk1'
+          }
+          disk_mapper = Azure::ARM::Compute::Models::Disk.mapper
+          @compute_mgmt_client.deserialize(disk_mapper, disk, 'result.body')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Fog
+  module Compute
+    class AzureRM
+      # Real class for Compute Request
+      class Real
+        def create_or_update_vm_extension(vm_extension_params)
+          msg = "Creating/Updating Extension #{vm_extension_params[:name]} for Virtual Machine #{vm_extension_params[:vm_name]} in Resource Group #{vm_extension_params[:resource_group]}"
+          Fog::Logger.debug msg
+
+          vm_extension = create_virtual_machine_extension_object(vm_extension_params)
+          begin
+            vm_extension_obj = @compute_mgmt_client.virtual_machine_extensions.create_or_update(vm_extension_params[:resource_group], vm_extension_params[:vm_name], vm_extension_params[:name], vm_extension)
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+          Fog::Logger.debug "Extension #{vm_extension.name} for Virtual Machine #{vm_extension_params[:vm_name]} in Resource Group #{vm_extension_params[:resource_group]} created/updated successfully"
+          vm_extension_obj
+        end
+
+        private
+
+        def create_virtual_machine_extension_object(virtual_machine_extension)
+          vm_extension = Azure::ARM::Compute::Models::VirtualMachineExtension.new
+          vm_extension.name = virtual_machine_extension[:name]
+          vm_extension.location = virtual_machine_extension[:location]
+          vm_extension.virtual_machine_extension_type = virtual_machine_extension[:type]
+          vm_extension.publisher = virtual_machine_extension[:publisher]
+          vm_extension.type_handler_version = virtual_machine_extension[:type_handler_version]
+          vm_extension.auto_upgrade_minor_version = virtual_machine_extension[:auto_upgrade_minor_version]
+          vm_extension.settings = virtual_machine_extension[:settings]
+          vm_extension.protected_settings = virtual_machine_extension[:protected_settings]
+          vm_extension
+        end
+      end
+
+      # Mock class for Compute Request
+      class Mock
+        def add_or_update_vm_extension(*)
+          body = {
+            'id' => '/subscriptions/########-####-####-####-############/resourceGroups/TestRG/providers/Microsoft.Compute/virtualMachines/TestVM/extensions/IaaSAntimalware',
+            'name' => 'IaasAntimalware',
+            'resource_group' => 'fog-test-rg',
+            'location' => 'West US',
+            'properties' => {
+              'publisher' => 'Microsoft.Azure.Security',
+              'type' => 'IaaSAntimalware',
+              'typeHandlerVersion' => '1.3',
+              'autoUpgradeMinorVersion' => 'true',
+              'forceUpdateTag' => 'RerunExtension',
+              'settings' => {
+                'AnitmalwareEnabled' => 'true',
+                'RealtimeProtectionEnabled' => 'false'
+              },
+              'protected_settings' => {}
+            }
+          }
+          extension_mapper = Azure::ARM::Compute::Models::VirtualMachineExtension.mapper
+          @compute_mgmt_client.deserialize(extension_mapper, body, 'result.body')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,403 @@
+require 'base64'
+
+WHITE_SPACE = ' '.freeze
+
+module Fog
+  module Compute
+    class AzureRM
+      # This class provides the actual implementation for service calls.
+      class Real
+        def create_virtual_machine(vm_config, async = false)
+          vm_name = vm_config[:name]
+          rg_name = vm_config[:resource_group]
+
+          msg = "Creating Virtual Machine '#{vm_name}' in Resource Group '#{rg_name}'..."
+          Fog::Logger.debug msg
+
+          vm = Azure::ARM::Compute::Models::VirtualMachine.new
+          vm.location = vm_config[:location]
+          vm.tags = vm_config[:tags]
+          vm.availability_set = get_vm_availability_set(vm_config[:availability_set_id])
+          vm.hardware_profile = get_hardware_profile(vm_config[:vm_size])
+          vm.os_profile = get_os_profile(vm_config)
+          vm.network_profile = get_network_profile(vm_config[:network_interface_card_ids])
+          vm.storage_profile = get_storage_profile(vm_config)
+
+          begin
+            response = if async
+                         @compute_mgmt_client.virtual_machines.create_or_update_async(rg_name, vm_name, vm)
+                       else
+                         @compute_mgmt_client.virtual_machines.create_or_update(rg_name, vm_name, vm)
+                       end
+          rescue MsRestAzure::AzureOperationError => e
+            raise_azure_exception(e, msg)
+          end
+
+          unless async
+            unless vm_config[:vhd_path].nil? || vm_config[:managed_disk_storage_type].nil?
+              delete_image(rg_name, vm_name)
+              delete_storage_account_or_container(rg_name, vm_config[:storage_account_name], vm_name)
+            end
+          end
+
+          Fog::Logger.debug "Virtual Machine #{vm_name} created successfully!" unless async
+          response
+        end
+
+        private
+
+        def get_vm_availability_set(availability_set_id)
+          sub_resource = nil
+          unless availability_set_id.nil?
+            sub_resource = MsRestAzure::SubResource.new
+            sub_resource.id = availability_set_id
+          end
+          sub_resource
+        end
+
+        def get_hardware_profile(vm_size)
+          hw_profile = Azure::ARM::Compute::Models::HardwareProfile.new
+          hw_profile.vm_size = vm_size
+          hw_profile
+        end
+
+        def get_os_profile(vm_config)
+          # Arguments unpacking
+          platform = vm_config[:platform]
+          vm_name = vm_config[:name]
+          username = vm_config[:username]
+          password = vm_config[:password]
+          custom_data = vm_config[:custom_data]
+          provision_vm_agent = vm_config[:provision_vm_agent]
+          enable_automatic_updates = vm_config[:enable_automatic_updates]
+          disable_password_auth = vm_config[:disable_password_authentication]
+          ssh_key_path = vm_config[:ssh_key_path]
+          ssh_key_data = vm_config[:ssh_key_data]
+
+          # Build and return os profile object
+          os_profile = Azure::ARM::Compute::Models::OSProfile.new
+          os_profile.computer_name = vm_name
+          os_profile.admin_username = username
+          os_profile.admin_password = password
+          os_profile.custom_data = Base64.strict_encode64(custom_data.nil? ? WHITE_SPACE : custom_data)
+
+          if platform.casecmp(WINDOWS).zero?
+            os_profile.windows_configuration = get_windows_config(provision_vm_agent, enable_automatic_updates)
+          else
+            os_profile.linux_configuration = get_linux_config(disable_password_auth, ssh_key_path, ssh_key_data)
+          end
+
+          os_profile
+        end
+
+        def get_windows_config(provision_vm_agent, enable_automatic_updates)
+          windows_config = Azure::ARM::Compute::Models::WindowsConfiguration.new
+          windows_config.provision_vmagent = provision_vm_agent
+          windows_config.enable_automatic_updates = enable_automatic_updates
+          windows_config
+        end
+
+        def get_linux_config(disable_password_auth, ssh_key_path, ssh_key_data)
+          linux_config = Azure::ARM::Compute::Models::LinuxConfiguration.new
+          linux_config.disable_password_authentication = disable_password_auth
+
+          unless ssh_key_path.nil? || ssh_key_data.nil?
+            ssh_config = Azure::ARM::Compute::Models::SshConfiguration.new
+            ssh_public_key = Azure::ARM::Compute::Models::SshPublicKey.new
+            ssh_public_key.path = ssh_key_path
+            ssh_public_key.key_data = ssh_key_data
+            ssh_config.public_keys = [ssh_public_key]
+            linux_config.ssh = ssh_config
+          end
+
+          linux_config
+        end
+
+        def get_network_profile(network_interface_card_ids)
+          network_interface_cards = []
+          network_interface_card_ids.each_with_index do |id, index|
+            nic = Azure::ARM::Compute::Models::NetworkInterfaceReference.new
+            nic.id = id
+            nic.primary = index == PRIMARY_NIC_INDEX
+            network_interface_cards << nic
+          end
+
+          network_profile = Azure::ARM::Compute::Models::NetworkProfile.new
+          network_profile.network_interfaces = network_interface_cards
+          network_profile
+        end
+
+        def get_storage_profile(vm_config)
+          # Arguments unpacking
+          managed_disk_storage_type = vm_config[:managed_disk_storage_type]
+
+          storage_profile = if managed_disk_storage_type.nil?
+                              get_unmanaged_vm_storage_profile(vm_config)
+                            else
+                              get_managed_vm_storage_profile(vm_config)
+                            end
+          storage_profile
+        end
+
+        def get_unmanaged_vm_storage_profile(vm_config)
+          # Arguments unpacking
+          vm_name = vm_config[:name]
+          storage_account_name = vm_config[:storage_account_name]
+          publisher = vm_config[:publisher]
+          offer = vm_config[:offer]
+          sku = vm_config[:sku]
+          version = vm_config[:version]
+          vhd_path = vm_config[:vhd_path]
+          os_disk_caching = vm_config[:os_disk_caching]
+          platform = vm_config[:platform]
+          resource_group = vm_config[:resource_group]
+          os_disk_size = vm_config[:os_disk_size]
+          location = vm_config[:location]
+          image_ref = vm_config[:image_ref]
+
+          storage_profile = Azure::ARM::Compute::Models::StorageProfile.new
+          # Set OS disk VHD path
+          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"
+          os_disk.vhd = vhd
+
+          if vhd_path.nil? && image_ref.nil?
+            # Marketplace
+            storage_profile.image_reference = image_reference(publisher, offer, sku, version)
+          elsif !vhd_path.nil? && image_ref.nil?
+            # VHD
+            new_vhd_path = copy_vhd_to_storage_account(resource_group, storage_account_name, vhd_path, location, vm_name)
+            img_vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
+            img_vhd.uri = new_vhd_path
+            os_disk.image = img_vhd
+          else
+            # Image
+            image_resource_group = get_resource_group_from_id(image_ref)
+            image_name = get_image_name(image_ref)
+            image = get_image(image_resource_group, image_name)
+            storage_profile.image_reference = Azure::ARM::Compute::Models::ImageReference.new
+            storage_profile.image_reference.id = image.id
+          end
+
+          storage_profile.os_disk = configure_os_disk_object(os_disk, os_disk_caching, os_disk_size, platform, vm_name)
+          storage_profile
+        end
+
+        def get_managed_vm_storage_profile(vm_config)
+          # Argument unpacking
+          managed_disk_storage_type = vm_config[:managed_disk_storage_type]
+          vhd_path = vm_config[:vhd_path]
+          resource_group = vm_config[:resource_group]
+          storage_account_name = vm_config[:storage_account_name]
+          location = vm_config[:location]
+          publisher = vm_config[:publisher]
+          offer = vm_config[:offer]
+          sku = vm_config[:sku]
+          version = vm_config[:version]
+          os_disk_caching = vm_config[:os_disk_caching]
+          os_disk_size = vm_config[:os_disk_size]
+          platform = vm_config[:platform]
+          vm_name = vm_config[:name]
+          image_ref = vm_config[:image_ref]
+
+          # Build storage profile
+          storage_profile = Azure::ARM::Compute::Models::StorageProfile.new
+          os_disk = Azure::ARM::Compute::Models::OSDisk.new
+          managed_disk = Azure::ARM::Compute::Models::ManagedDiskParameters.new
+          managed_disk.storage_account_type = managed_disk_storage_type
+          os_disk.managed_disk = managed_disk
+
+          if vhd_path.nil? && image_ref.nil?
+            # Marketplace
+            storage_profile.image_reference = image_reference(publisher, offer, sku, version)
+          elsif !vhd_path.nil? && image_ref.nil?
+            # VHD
+            new_vhd_path = copy_vhd_to_storage_account(resource_group, storage_account_name, vhd_path, location, vm_name)
+            image = create_image(image_config_params(location, new_vhd_path, platform, resource_group, vm_name))
+            storage_profile.image_reference = Azure::ARM::Compute::Models::ImageReference.new
+            storage_profile.image_reference.id = image.id
+          else
+            # Image
+            image_resource_group = get_resource_group_from_id(image_ref)
+            image_name = get_image_name(image_ref)
+            image = get_image(image_resource_group, image_name)
+            storage_profile.image_reference = Azure::ARM::Compute::Models::ImageReference.new
+            storage_profile.image_reference.id = image.id
+          end
+
+          storage_profile.os_disk = configure_os_disk_object(os_disk, os_disk_caching, os_disk_size, platform, vm_name)
+          storage_profile
+        end
+
+        def image_reference(publisher, offer, sku, version)
+          image_reference = Azure::ARM::Compute::Models::ImageReference.new
+          image_reference.publisher = publisher
+          image_reference.offer = offer
+          image_reference.sku = sku
+          image_reference.version = version
+          image_reference
+        end
+
+        def image_config_params(location, new_vhd_path, platform, resource_group, vm_name)
+          {
+            location: location,
+            new_vhd_path: new_vhd_path,
+            platform: platform,
+            resource_group: resource_group,
+            vm_name: vm_name
+          }
+        end
+
+        def configure_os_disk_object(os_disk, os_disk_caching, os_disk_size, platform, vm_name)
+          os_disk.name = "#{vm_name}_os_disk"
+          os_disk.os_type = platform
+          os_disk.disk_size_gb = os_disk_size unless os_disk_size.nil?
+          os_disk.create_option = Azure::ARM::Compute::Models::DiskCreateOptionTypes::FromImage
+          os_disk.caching = unless os_disk_caching.nil?
+                              case os_disk_caching
+                              when 'None'
+                                Azure::ARM::Compute::Models::CachingTypes::None
+                              when 'ReadOnly'
+                                Azure::ARM::Compute::Models::CachingTypes::ReadOnly
+                              when 'ReadWrite'
+                                Azure::ARM::Compute::Models::CachingTypes::ReadWrite
+                              end
+                            end
+          os_disk
+        end
+
+        def copy_vhd_to_storage_account(resource_group, storage_account_name, vhd_path, location, vm_name)
+          # Copy if VHD does not exist belongs to same storage account.
+          vhd_storage_account_name = (vhd_path.split('/')[2]).split('.')[0]
+          if storage_account_name != vhd_storage_account_name
+            if storage_account_name.nil?
+              new_time = current_time
+              storage_account_name = "sa#{new_time}"
+              storage_account_config = storage_account_config_params(location, resource_group, storage_account_name)
+              storage_account = @storage_service.storage_accounts.create(storage_account_config)
+            else
+              storage_account = @storage_service.storage_accounts.get(resource_group, storage_account_name)
+            end
+
+            access_key = storage_account.get_access_keys.first.value
+            storage_data = Fog::Storage::AzureRM.new(azure_storage_account_name: storage_account_name, azure_storage_access_key: access_key)
+            new_time = current_time
+            container_name = "customvhd-#{vm_name.downcase}-os-image"
+            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)
+            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
+        end
+
+        def storage_account_config_params(location, resource_group, storage_account_name)
+          {
+            name: storage_account_name,
+            location: location,
+            resource_group: resource_group,
+            account_type: 'Standard',
+            replication: 'LRS',
+            tags:
+            {
+              TEMPORARY_STORAGE_ACCOUNT_TAG_KEY => TEMPORARY_STORAGE_ACCOUNT_TAG_VALUE
+            }
+          }
+        end
+
+        def delete_storage_account_or_container(resource_group, storage_account_name, vm_name)
+          delete_storage_account(resource_group) if storage_account_name.nil?
+          delete_storage_container(resource_group, storage_account_name, vm_name) unless storage_account_name.nil?
+        end
+
+        def delete_storage_container(resource_group, storage_account_name, vm_name)
+          access_key = @storage_service.get_storage_access_keys(resource_group, storage_account_name).first.value
+          container_name = "customvhd-#{vm_name.downcase}-os-image"
+          @storage_service.directories.delete_temporary_container(storage_account_name, access_key, container_name)
+        end
+
+        def delete_storage_account(resource_group)
+          @storage_service.storage_accounts.delete_storage_account_from_tag(resource_group,
+                                                                            TEMPORARY_STORAGE_ACCOUNT_TAG_KEY,
+                                                                            TEMPORARY_STORAGE_ACCOUNT_TAG_VALUE)
+        end
+      end
+
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        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' => 'Standard_A0'
+                },
+              'storageProfile' =>
+                {
+                  'imageReference' =>
+                    {
+                      'publisher' => 'MicrosoftWindowsServerEssentials',
+                      'offer' => 'WindowsServerEssentials',
+                      'sku' => 'WindowsServerEssentials',
+                      'version' => 'latest'
+                    },
+                  'osDisk' =>
+                    {
+                      'name' => 'fog-test-server_os_disk',
+                      'vhd' =>
+                        {
+                          'uri' => 'http://mystorage1.blob.core.windows.net/vhds/fog-test-server_os_disk.vhd'
+                        },
+                      'createOption' => 'FromImage',
+                      'osType' => 'Linux',
+                      'caching' => 'ReadWrite'
+                    },
+                  'dataDisks' => []
+                },
+              'osProfile' =>
+                {
+                  'computerName' => 'fog-test-server',
+                  'adminUsername' => 'fog',
+                  'linuxConfiguration' =>
+                    {
+                      'disablePasswordAuthentication' => true
+                    },
+                  'secrets' => [],
+                  'customData' => 'ZWNobyBjdXN0b21EYXRh'
+                },
+              'networkProfile' =>
+                {
+                  'networkInterfaces' =>
+                    [
+                      {
+                        '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
+  end
+end