class Fog::Compute::AzureRM::Real

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

Real class for Compute Request

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

Real class for Compute Request

Real class for Compute Request

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

Real class for Compute Request

This class provides the actual implementation for service calls.

Real class for Compute Request

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

This class provides the actual implementation for service call.

Real class for Compute Request

Real class for Compute Request

This class provides the actual implementation for service calls.

Real class for Compute Request

Real class for Compute Request

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

Real class for Compute Request

Real class for Compute Request

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

This class provides the actual implementation for service calls.

Real class for Compute Request

This class provides the actual implementation for service calls.

Public Class Methods

new(options) click to toggle source
# File lib/fog/azurerm/compute.rb, line 77
def initialize(options)
  begin
    require 'azure_mgmt_compute'
    require 'azure_mgmt_storage'
    require 'azure/storage'
  rescue LoadError => e
    retry if require('rubygems')
    raise e.message
  end

  options[:environment] = 'AzureCloud' if options[:environment].nil?

  telemetry = "fog-azure-rm/#{Fog::AzureRM::VERSION}"
  credentials = Fog::Credentials::AzureRM.get_credentials(options[:tenant_id], options[:client_id], options[:client_secret], options[:environment])
  @compute_mgmt_client = ::Azure::ARM::Compute::ComputeManagementClient.new(credentials, resource_manager_endpoint_url(options[:environment]))
  @compute_mgmt_client.subscription_id = options[:subscription_id]
  @compute_mgmt_client.add_user_agent_information(telemetry)
  @storage_mgmt_client = ::Azure::ARM::Storage::StorageManagementClient.new(credentials, resource_manager_endpoint_url(options[:environment]))
  @storage_mgmt_client.subscription_id = options[:subscription_id]
  @storage_mgmt_client.add_user_agent_information(telemetry)
  @storage_service = Fog::Storage::AzureRM.new(tenant_id: options[:tenant_id], client_id: options[:client_id], client_secret: options[:client_secret], subscription_id: options[:subscription_id], environment: options[:environment])
end

Public Instance Methods

attach_data_disk_to_vm(disk_params, async) click to toggle source
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 6
def attach_data_disk_to_vm(disk_params, async)
  # Variable un-packing for easy access
  vm_name = disk_params[:vm_name]
  vm_resource_group = disk_params[:vm_resource_group]
  disk_name = disk_params[:disk_name]
  disk_resource_group = disk_params[:disk_resource_group]
  disk_size = disk_params[:disk_size_gb]
  storage_account_name = disk_params[:storage_account_name]
  caching = disk_params[:caching] || nil

  msg = "Attaching Data Disk #{disk_name} to Virtual Machine #{vm_name} in Resource Group #{vm_resource_group}"
  Fog::Logger.debug msg
  vm = get_virtual_machine_instance(vm_resource_group, vm_name)
  lun = get_logical_unit_number(vm.storage_profile.data_disks)

  # Attach data disk to VM
  if storage_account_name
    # Un-managed data disk
    access_key = get_storage_access_key(vm_resource_group, storage_account_name)
    data_disk = get_unmanaged_disk_object(disk_name, disk_size, lun, storage_account_name, access_key)
  elsif disk_resource_group
    # Managed data disk
    data_disk = get_data_disk_object(disk_resource_group, disk_name, lun, caching)
  end
  vm.storage_profile.data_disks.push(data_disk)
  begin
    if async
      response = @compute_mgmt_client.virtual_machines.create_or_update_async(vm_resource_group, vm_name, vm)
    else
      virtual_machine = @compute_mgmt_client.virtual_machines.create_or_update(vm_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'
    else
    raise_azure_exception(e, msg)
    end
  end
  if async
    response
  else
    Fog::Logger.debug "Data Disk #{disk_name} attached to Virtual Machine #{vm_name} successfully."
    virtual_machine
  end
end
check_availability_set_exists(resource_group, name) click to toggle source
# File lib/fog/azurerm/requests/compute/check_availability_set_exists.rb, line 6
def check_availability_set_exists(resource_group, name)
  msg = "Checking Availability set: #{name}"
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.availability_sets.get(resource_group, name)
    Fog::Logger.debug "Availability set #{name} exists."
    true
  rescue MsRestAzure::AzureOperationError => e
    if resource_not_found?(e)
      Fog::Logger.debug "Availability set #{name} doesn't exist."
      false
    else
      raise_azure_exception(e, msg)
    end
  end
end
check_managed_disk_exists(resource_group_name, disk_name) click to toggle source
# File lib/fog/azurerm/requests/compute/check_managed_disk_exists.rb, line 6
def check_managed_disk_exists(resource_group_name, disk_name)
  msg = "Checking if Managed Disk: #{disk_name} exists"
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.disks.get(resource_group_name, disk_name)
    Fog::Logger.debug "Managed Disk #{disk_name} exist."
    true
  rescue MsRestAzure::AzureOperationError => e
    if resource_not_found?(e)
      Fog::Logger.debug "Managed Disk #{disk_name} doesn't exist."
      false
    else
      raise_azure_exception(e, msg)
    end
  end
end
check_vm_exists(resource_group, name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/check_vm_exists.rb, line 6
def check_vm_exists(resource_group, name, async)
  msg = "Checking Virtual Machine #{name}"
  Fog::Logger.debug msg
  begin
    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 resource_not_found?(e)
      Fog::Logger.debug "Virtual machine #{name} doesn't exist."
      return false
    else
      raise_azure_exception(e, msg)
    end
  end
  if async
    response
  else
    Fog::Logger.debug "Virtual machine #{name} exists."
    true
  end
end
check_vm_extension_exists(resource_group_name, virtual_machine_name, vm_extension_name) click to toggle source
# File lib/fog/azurerm/requests/compute/check_vm_extension_exists.rb, line 6
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
check_vm_status(resource_group, name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/check_vm_status.rb, line 6
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
create_availability_set(availability_set_params) click to toggle source
# File lib/fog/azurerm/requests/compute/create_availability_set.rb, line 6
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_availability_set_sku(use_managed_disk) click to toggle source
# File lib/fog/azurerm/requests/compute/create_availability_set.rb, line 39
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
create_image(image_config) click to toggle source
# File lib/fog/azurerm/requests/compute/create_image.rb, line 6
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
create_or_update_managed_disk(managed_disk_params) click to toggle source
# File lib/fog/azurerm/requests/compute/create_or_update_managed_disk.rb, line 6
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
create_or_update_vm_extension(vm_extension_params) click to toggle source
# File lib/fog/azurerm/requests/compute/create_or_update_vm_extension.rb, line 6
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
create_virtual_machine(vm_config, async = false) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 10
def create_virtual_machine(vm_config, async = false)
  vm_name = vm_config[:name]
  rg_name = vm_config[:resource_group]

  # In case of updating the VM, we check if the user has passed any value for os_disk_name
  # If the user has not passed any value, we try to retrieve the value of os_disk_name from the VM
  # If the VM exists then the os_disk_name is retrieved; else it remains nil
  os_disk_parameters = get_os_disk_parameters(rg_name, vm_name) if vm_config[:os_disk_name].nil? || vm_config[:os_disk_vhd_uri].nil?
  vm_config[:os_disk_name] = os_disk_parameters[:os_disk_name] if vm_config[:os_disk_name].nil?
  vm_config[:os_disk_vhd_uri] = os_disk_parameters[:os_disk_vhd_uri] if vm_config[:os_disk_vhd_uri].nil?

  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
deallocate_virtual_machine(resource_group, name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/deallocate_virtual_machine.rb, line 6
def deallocate_virtual_machine(resource_group, name, async)
  msg = "Deallocating Virtual Machine #{name} in Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    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
  if async
    response
  else
    Fog::Logger.debug "Virtual Machine #{name} Deallocated Successfully."
    true
  end
end
delete_availability_set(resource_group, name) click to toggle source
# File lib/fog/azurerm/requests/compute/delete_availability_set.rb, line 6
def delete_availability_set(resource_group, name)
  msg = "Deleting Availability Set: #{name}."
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.availability_sets.delete(resource_group, name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Availability Set #{name} deleted successfully."
  true
end
delete_image(resource_group, vm_name) click to toggle source
# File lib/fog/azurerm/requests/compute/delete_image.rb, line 6
def delete_image(resource_group, vm_name)
  msg = "Deleting Image: #{vm_name}-osImage"
  Fog::Logger.debug msg
  image_name = "#{vm_name}-osImage"
  begin
    @compute_mgmt_client.images.delete(resource_group, image_name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Image #{image_name} deleted successfully."
  true
end
delete_managed_disk(resource_group_name, disk_name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/delete_managed_disk.rb, line 7
def delete_managed_disk(resource_group_name, disk_name, async)
  msg = "Deleting Managed Disk: #{disk_name}"
  Fog::Logger.debug msg
  begin
    if async
      response = @compute_mgmt_client.disks.delete_async(resource_group_name, disk_name)
    else
      @compute_mgmt_client.disks.delete(resource_group_name, disk_name)
    end
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  if async
    response
  else
    Fog::Logger.debug "Managed Disk #{disk_name} deleted successfully."
    true
  end
end
delete_virtual_machine(resource_group, name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/delete_virtual_machine.rb, line 6
def delete_virtual_machine(resource_group, name, async)
  msg = "Deleting Virtual Machine #{name} from Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    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
  if async
    response
  else
    Fog::Logger.debug "Virtual Machine #{name} Deleted Successfully."
    true
  end
end
delete_vm_extension(resource_group, vm_name, extension_name) click to toggle source
# File lib/fog/azurerm/requests/compute/delete_vm_extension.rb, line 6
def delete_vm_extension(resource_group, vm_name, extension_name)
  msg = "Deleting Extension #{extension_name} of Virtual Machine #{vm_name} in Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.virtual_machine_extensions.delete(resource_group, vm_name, extension_name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Extension #{extension_name} of Virtual Machine #{vm_name} in Resource Group #{resource_group} deleted successfully"
  true
end
detach_data_disk_from_vm(resource_group, vm_name, disk_name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/detach_data_disk_from_vm.rb, line 6
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)
  vm.storage_profile.data_disks.each_with_index do |disk, index|
    if disk.name == disk_name
      vm.storage_profile.data_disks.delete_at(index)
    end
  end
  begin
    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
  if async
    response
  else
    Fog::Logger.debug "Data Disk #{disk_name} detached from Virtual Machine #{vm_name} successfully."
    virtual_machine
  end
end
generalize_virtual_machine(resource_group, name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/generalize_virtual_machine.rb, line 6
def generalize_virtual_machine(resource_group, name, async)
  msg = "Generalizing Virtual Machine #{name} in Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    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
  if async
    response
  else
    Fog::Logger.debug "Virtual Machine #{name} Generalized Successfully."
    true
  end
end
get_availability_set(resource_group, name) click to toggle source
# File lib/fog/azurerm/requests/compute/get_availability_set.rb, line 6
def get_availability_set(resource_group, name)
  msg = "Listing Availability Set: #{name} in Resource Group: #{resource_group}"
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.availability_sets.get(resource_group, name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
end
get_availability_set_properties(location, fault_domain_count, update_domain_count, use_managed_disk, tags) click to toggle source

create the properties object for creating availability sets

# File lib/fog/azurerm/requests/compute/create_availability_set.rb, line 29
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
get_image(resource_group_name, image_name) click to toggle source
# File lib/fog/azurerm/requests/compute/get_image.rb, line 6
def get_image(resource_group_name, image_name)
  msg = "Getting Image #{image_name} in Resource Group #{resource_group_name}"
  Fog::Logger.debug msg
  begin
    image = @compute_mgmt_client.images.get(resource_group_name, image_name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "#{msg} successful"
  image
end
get_managed_disk(resource_group_name, disk_name) click to toggle source
# File lib/fog/azurerm/requests/compute/get_managed_disk.rb, line 6
def get_managed_disk(resource_group_name, disk_name)
  msg = "Getting Managed Disk: #{disk_name}"
  Fog::Logger.debug msg
  begin
    managed_disk = @compute_mgmt_client.disks.get(resource_group_name, disk_name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Managed Disk #{disk_name} returned successfully."
  managed_disk
end
get_status(virtual_machine) click to toggle source
# File lib/fog/azurerm/requests/compute/check_vm_status.rb, line 18
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
get_virtual_machine(resource_group, name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/get_virtual_machine.rb, line 8
def get_virtual_machine(resource_group, name, async)
  msg = "Getting Virtual Machine #{name} from Resource Group '#{resource_group}'"
  Fog::Logger.debug msg
  begin
    if async
      response = @compute_mgmt_client.virtual_machines.get_async(resource_group, name, INSTANCE_VIEW)
    else
      response = @compute_mgmt_client.virtual_machines.get(resource_group, name, INSTANCE_VIEW)
    end
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Getting Virtual Machine #{name} from Resource Group '#{resource_group}' successful" unless async
  response
end
get_vm_extension(resource_group_name, virtual_machine_name, vm_extension_name) click to toggle source
# File lib/fog/azurerm/requests/compute/get_vm_extension.rb, line 6
def get_vm_extension(resource_group_name, virtual_machine_name, vm_extension_name)
  msg = "Getting Extension #{vm_extension_name} of Virtual Machine #{virtual_machine_name} in Resource Group #{resource_group_name}"
  Fog::Logger.debug msg
  begin
    vm_extension = @compute_mgmt_client.virtual_machine_extensions.get(resource_group_name, virtual_machine_name, vm_extension_name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "#{msg} successful"
  vm_extension
end
grant_access_to_managed_disk(resource_group_name, disk_name, access_type, duration_in_sec) click to toggle source
# File lib/fog/azurerm/requests/compute/grant_access_to_managed_disk.rb, line 6
def grant_access_to_managed_disk(resource_group_name, disk_name, access_type, duration_in_sec)
  msg = "Granting access to Managed Disk: #{disk_name}"
  Fog::Logger.debug msg
  access_data = Azure::ARM::Compute::Models::GrantAccessData.new
  access_data.access = access_type
  access_data.duration_in_seconds = duration_in_sec
  begin
    access_uri = @compute_mgmt_client.disks.grant_access(resource_group_name, disk_name, access_data)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Access granted to managed disk: #{disk_name} successfully."
  access_uri.access_sas
end
list_availability_sets(resource_group) click to toggle source
# File lib/fog/azurerm/requests/compute/list_availability_sets.rb, line 6
def list_availability_sets(resource_group)
  msg = "Listing Availability Sets in Resource Group: #{resource_group}"
  Fog::Logger.debug msg
  begin
    avail_sets = @compute_mgmt_client.availability_sets.list(resource_group)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Listing Availability Sets in Resource Group: #{resource_group} successful."
  avail_sets.value
end
list_available_sizes_for_virtual_machine(resource_group, name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/list_available_sizes_for_virtual_machine.rb, line 6
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
    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
  if async
    response
  else
    Fog::Logger.debug "Successfully listed sizes for Virtual Machine #{name} in Resource Group #{resource_group}"
    vm_sizes.value
  end
end
list_managed_disks_by_rg(resource_group_name) click to toggle source
# File lib/fog/azurerm/requests/compute/list_managed_disks_by_rg.rb, line 6
def list_managed_disks_by_rg(resource_group_name)
  msg = "Listing all Managed Disks in resource group: #{resource_group_name}"
  Fog::Logger.debug msg
  begin
    managed_disks = @compute_mgmt_client.disks.list_by_resource_group(resource_group_name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug 'Managed Disks listed successfully.'
  managed_disks
end
list_managed_disks_in_subscription() click to toggle source
# File lib/fog/azurerm/requests/compute/list_managed_disks_in_subscription.rb, line 6
def list_managed_disks_in_subscription
  msg = 'Listing all Managed Disks'
  Fog::Logger.debug msg
  begin
    managed_disks = @compute_mgmt_client.disks.list
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug 'Managed Disks listed successfully.'
  managed_disks
end
list_virtual_machines(resource_group) click to toggle source
# File lib/fog/azurerm/requests/compute/list_virtual_machines.rb, line 6
def list_virtual_machines(resource_group)
  msg = "Listing Virtual Machines in Resource Group '#{resource_group}'"
  Fog::Logger.debug msg
  begin
    virtual_machines = @compute_mgmt_client.virtual_machines.list_as_lazy(resource_group)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "listing Virtual Machines in Resource Group '#{resource_group}' successful"
  virtual_machines.value
end
power_off_virtual_machine(resource_group, name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/power_off_virtual_machine.rb, line 6
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
    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
  if async
    response
  else
    Fog::Logger.debug "Virtual Machine #{name} Powered off Successfully."
    true
  end
end
redeploy_virtual_machine(resource_group, name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/redeploy_virtual_machine.rb, line 6
def redeploy_virtual_machine(resource_group, name, async)
  msg = "Redeploying Virtual Machine #{name} in Resource Group #{resource_group}."
  Fog::Logger.debug msg
  begin
    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
  if async
    response
  else
    Fog::Logger.debug "Virtual Machine #{name} Redeployed Successfully."
    true
  end
end
restart_virtual_machine(resource_group, name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/restart_virtual_machine.rb, line 6
def restart_virtual_machine(resource_group, name, async)
  msg = "Restarting Virtual Machine #{name} in Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    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
  if async
    response
  else
    Fog::Logger.debug "Virtual Machine #{name} Restarted Successfully."
    true
  end
end
revoke_access_to_managed_disk(resource_group_name, disk_name) click to toggle source
# File lib/fog/azurerm/requests/compute/revoke_access_to_managed_disk.rb, line 6
def revoke_access_to_managed_disk(resource_group_name, disk_name)
  msg = "Revoking access to Managed Disk: #{disk_name}"
  Fog::Logger.debug msg
  begin
    response = @compute_mgmt_client.disks.revoke_access(resource_group_name, disk_name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Access revoked to managed disk: #{disk_name} successfully."
  response
end
start_virtual_machine(resource_group, name, async) click to toggle source
# File lib/fog/azurerm/requests/compute/start_virtual_machine.rb, line 6
def start_virtual_machine(resource_group, name, async)
  msg = "Starting Virtual Machine #{name} in Resource Group #{resource_group}."
  Fog::Logger.debug msg
  begin
    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
  if async
    response
  else
    Fog::Logger.debug "Virtual Machine #{name} started Successfully."
    true
  end
end

Private Instance Methods

check_blob_exist(storage_account_name, blob_name, access_key) click to toggle source
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 139
def check_blob_exist(storage_account_name, blob_name, access_key)
  client = Azure::Storage::Client.new(storage_account_name: storage_account_name, storage_access_key: access_key)
  blob_service = Azure::Storage::Blob::BlobService.new(client: client)
  begin
    blob_prop = blob_service.get_blob_properties('vhds', blob_name)
    true unless blob_prop.nil?
  rescue Azure::Core::Http::HTTPError => e
    return false if e.status_code == 404
    raise_azure_exception(e, 'Checking blob existence')
  end
end
configure_os_disk_object(os_disk, os_disk_name, os_disk_caching, os_disk_size, platform, vm_name) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 262
def configure_os_disk_object(os_disk, os_disk_name, os_disk_caching, os_disk_size, platform, vm_name)
  # It will use the os_disk_name provided or it will generate a name for itself if it is nil
  os_disk.name = os_disk_name.nil? ? "#{vm_name}_os_disk" : os_disk_name
  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
copy_vhd_to_storage_account(resource_group, storage_account_name, vhd_path, location, vm_name) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 281
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
create_generalized_os_disk_image(image_config) click to toggle source
# File lib/fog/azurerm/requests/compute/create_image.rb, line 31
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
create_virtual_machine_extension_object(virtual_machine_extension) click to toggle source
# File lib/fog/azurerm/requests/compute/create_or_update_vm_extension.rb, line 22
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
delete_storage_account(resource_group) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 341
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
delete_storage_account_or_container(resource_group, storage_account_name, vm_name) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 330
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
delete_storage_container(resource_group, storage_account_name, vm_name) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 335
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
get_creation_data_object(data) click to toggle source
# File lib/fog/azurerm/requests/compute/create_or_update_managed_disk.rb, line 40
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
get_data_disk_object(disk_resource_group, disk_name, lun, caching) click to toggle source
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 79
def get_data_disk_object(disk_resource_group, disk_name, lun, caching)
  msg = "Getting Managed Disk #{disk_name} from Resource Group #{disk_resource_group}"
  begin
    disk = @compute_mgmt_client.disks.get(disk_resource_group, disk_name)
  rescue MsRestAzure::AzureOperationError => e
    Fog::Logger.debug msg
    raise_azure_exception(e, msg)
  end
  managed_disk = Azure::ARM::Compute::Models::DataDisk.new
  managed_disk.name = disk_name
  managed_disk.lun = lun
  managed_disk.create_option = Azure::ARM::Compute::Models::DiskCreateOptionTypes::Attach

  # Managed Disk Caching Type
  managed_disk.caching = case caching
                         when 'ReadOnly'
                           Azure::ARM::Compute::Models::CachingTypes::ReadOnly
                         when 'ReadWrite'
                           Azure::ARM::Compute::Models::CachingTypes::ReadWrite
                         when 'None', nil
                           Azure::ARM::Compute::Models::CachingTypes::None
                         else
                           raise "Invalid Disk Caching Option: #{caching}"
                         end

  # Managed disk parameter
  managed_disk_params = Azure::ARM::Compute::Models::ManagedDiskParameters.new
  managed_disk_params.id = disk.id
  managed_disk.managed_disk = managed_disk_params

  managed_disk
end
get_encryption_settings_object(settings) click to toggle source
# File lib/fog/azurerm/requests/compute/create_or_update_managed_disk.rb, line 58
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
get_hardware_profile(vm_size) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 65
def get_hardware_profile(vm_size)
  hw_profile = Azure::ARM::Compute::Models::HardwareProfile.new
  hw_profile.vm_size = vm_size
  hw_profile
end
get_linux_config(disable_password_auth, ssh_key_path, ssh_key_data) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 107
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
get_logical_unit_number(data_disks) click to toggle source
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 66
def get_logical_unit_number(data_disks)
  lun_range_list = (0..15).to_a
  data_disks.each do |disk|
    lun_range_list.delete(disk.lun)
  end

  if lun_range_list.empty?
    msg = 'Error Attaching Data Disk to Virtual Machine. No slot available.'
    raise msg
  end
  lun_range_list[0]
end
get_managed_disk_object(managed_disk_params) click to toggle source
# File lib/fog/azurerm/requests/compute/create_or_update_managed_disk.rb, line 21
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
get_managed_vm_storage_profile(vm_config) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 196
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]
  os_disk_name = vm_config[:os_disk_name]

  # 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_name, os_disk_caching, os_disk_size, platform, vm_name)
  storage_profile
end
get_network_profile(network_interface_card_ids) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 123
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
get_os_disk_parameters(resource_group, virtual_machine_name) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 347
def get_os_disk_parameters(resource_group, virtual_machine_name)
  os_disk_parameters = {}

  begin
    vm = get_virtual_machine(resource_group, virtual_machine_name, false)
  rescue
    return os_disk_parameters
  end

  unless vm.storage_profile.nil?
    os_disk_parameters[:os_disk_name] = vm.storage_profile.os_disk.name
    os_disk_parameters[:os_disk_vhd_uri] = vm.storage_profile.os_disk.vhd.uri unless vm.storage_profile.os_disk.vhd.nil?
  end

  os_disk_parameters
end
get_os_profile(vm_config) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 71
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] unless vm_config[:custom_data].nil?
  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) unless vm_config[:custom_data].nil?

  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
get_storage_access_key(resource_group, storage_account_name) click to toggle source
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 112
def get_storage_access_key(resource_group, storage_account_name)
  msg = "Getting Storage Access Keys from Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    storage_account_keys = @storage_mgmt_client.storage_accounts.list_keys(resource_group, storage_account_name)
  rescue MsRestAzure::AzureOperationError => e
    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
get_storage_profile(vm_config) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 137
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
get_unmanaged_disk_object(disk_name, disk_size, lun, storage_account_name, access_key) click to toggle source
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 124
def get_unmanaged_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
  data_disk.disk_size_gb = disk_size.to_s
  data_disk.vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
  data_disk.vhd.uri = "https://#{storage_account_name}.blob.core.windows.net/vhds/#{storage_account_name}-#{disk_name}.vhd"
  data_disk.caching = Azure::ARM::Compute::Models::CachingTypes::ReadWrite
  blob_name = "#{storage_account_name}-#{disk_name}.vhd"
  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
get_unmanaged_vm_storage_profile(vm_config) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 149
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]
  os_disk_name = vm_config[:os_disk_name]
  os_disk_vhd_uri = vm_config[:os_disk_vhd_uri]

  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 = os_disk_vhd_uri.nil? ? get_blob_endpoint(storage_account_name) + "/vhds/#{vm_name}_os_disk.vhd" : os_disk_vhd_uri
  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_name, os_disk_caching, os_disk_size, platform, vm_name)
  storage_profile
end
get_virtual_machine_instance(resource_group, vm_name) click to toggle source
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 54
def get_virtual_machine_instance(resource_group, vm_name)
  msg = "Getting Virtual Machine #{vm_name} from Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    virtual_machine = @compute_mgmt_client.virtual_machines.get(resource_group, vm_name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Getting Virtual Machine #{vm_name} from Resource Group #{resource_group} successful"
  virtual_machine
end
get_vm_availability_set(availability_set_id) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 56
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
get_windows_config(provision_vm_agent, enable_automatic_updates) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 100
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
image_config_params(location, new_vhd_path, platform, resource_group, vm_name) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 252
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
image_reference(publisher, offer, sku, version) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 243
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
setup_params(image_config) click to toggle source
# File lib/fog/azurerm/requests/compute/create_image.rb, line 22
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
storage_account_config_params(location, resource_group, storage_account_name) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 316
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