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.

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.

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

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 73
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(resource_group, vm_name, disk_name, disk_size, storage_account_name) click to toggle source
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 6
def attach_data_disk_to_vm(resource_group, vm_name, disk_name, disk_size, storage_account_name)
  msg = "Attaching Data Disk #{disk_name} to Virtual Machine #{vm_name} in Resource Group #{resource_group}"
  Fog::Logger.debug msg
  vm = get_virtual_machine_instance(resource_group, vm_name, @compute_mgmt_client)
  lun = get_logical_unit_number(vm.storage_profile.data_disks)
  access_key = get_storage_access_key(resource_group, storage_account_name, @storage_mgmt_client)
  data_disk = get_data_disk_object(disk_name, disk_size, lun, storage_account_name, access_key)
  vm.storage_profile.data_disks.push(data_disk)
  vm.resources = nil
  begin
    virtual_machine = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, vm_name, vm)
  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
  Fog::Logger.debug "Data Disk #{disk_name} attached to Virtual Machine #{vm_name} successfully."
  virtual_machine
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 e.body['error']['code'] == 'ResourceNotFound'
      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 e.error_code == 'ResourceNotFound'
      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) click to toggle source
# File lib/fog/azurerm/requests/compute/check_vm_exists.rb, line 6
def check_vm_exists(resource_group, name)
  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
  rescue MsRestAzure::AzureOperationError => e
    if e.body['error']['code'] == 'ResourceNotFound'
      Fog::Logger.debug "Virtual machine #{name} doesn't exist."
      false
    else
      raise_azure_exception(e, msg)
    end
  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 e.body['error']['code'] == 'ResourceNotFound'
      Fog::Logger.debug "Virtual machine #{vm_extension_name} doesn't exist."
      false
    else
      raise_azure_exception(e, msg)
    end
  end
end
check_vm_status(resource_group, name) click to toggle source
# File lib/fog/azurerm/requests/compute/check_vm_status.rb, line 6
def check_vm_status(resource_group, name)
  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(resource_group, name, location) click to toggle source
# File lib/fog/azurerm/requests/compute/create_availability_set.rb, line 6
def create_availability_set(resource_group, name, location)
  msg = "Creating Availability Set '#{name}' in #{location} region."
  Fog::Logger.debug msg
  avail_set_params = get_availability_set_properties(location)
  begin
    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_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_hash, async = false) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 9
def create_virtual_machine(vm_hash, async = false)
  msg = "Creating Virtual Machine #{vm_hash[:name]} in Resource Group #{vm_hash[:resource_group]}."
  Fog::Logger.debug msg
  virtual_machine = Azure::ARM::Compute::Models::VirtualMachine.new

  unless vm_hash[:availability_set_id].nil?
    sub_resource = MsRestAzure::SubResource.new
    sub_resource.id = vm_hash[:availability_set_id]
    virtual_machine.availability_set = sub_resource
  end

  string_data = vm_hash[:custom_data]
  string_data = WHITE_SPACE if string_data.nil?
  encoded_data = Base64.strict_encode64(string_data)
  virtual_machine.hardware_profile = define_hardware_profile(vm_hash[:vm_size])
  virtual_machine.storage_profile = define_storage_profile(vm_hash[:name],
                                                           vm_hash[:storage_account_name],
                                                           vm_hash[:publisher],
                                                           vm_hash[:offer],
                                                           vm_hash[:sku],
                                                           vm_hash[:version],
                                                           vm_hash[:vhd_path],
                                                           vm_hash[:os_disk_caching],
                                                           vm_hash[:platform],
                                                           vm_hash[:resource_group])

  virtual_machine.os_profile = if vm_hash[:platform].casecmp(WINDOWS).zero?
                                 define_windows_os_profile(vm_hash[:name],
                                                           vm_hash[:username],
                                                           vm_hash[:password],
                                                           vm_hash[:provision_vm_agent],
                                                           vm_hash[:enable_automatic_updates],
                                                           encoded_data)
                               else
                                 define_linux_os_profile(vm_hash[:name],
                                                         vm_hash[:username],
                                                         vm_hash[:password],
                                                         vm_hash[:disable_password_authentication],
                                                         vm_hash[:ssh_key_path],
                                                         vm_hash[:ssh_key_data],
                                                         encoded_data)
                               end
  virtual_machine.network_profile = define_network_profile(vm_hash[:network_interface_card_ids])
  virtual_machine.location = vm_hash[:location]
  begin
    response = if async
                 @compute_mgmt_client.virtual_machines.create_or_update_async(vm_hash[:resource_group], vm_hash[:name], virtual_machine)
               else
                 @compute_mgmt_client.virtual_machines.create_or_update(vm_hash[:resource_group], vm_hash[:name], virtual_machine)
               end
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Virtual Machine #{vm_hash[:name]} Created Successfully." unless async
  response
end
deallocate_virtual_machine(resource_group, name) click to toggle source
# File lib/fog/azurerm/requests/compute/deallocate_virtual_machine.rb, line 6
def deallocate_virtual_machine(resource_group, name)
  msg = "Deallocating Virtual Machine #{name} in Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.virtual_machines.deallocate(resource_group, name)
  rescue  MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Virtual Machine #{name} Deallocated Successfully."
  true
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_managed_disk(resource_group_name, disk_name) 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)
  msg = "Deleting Managed Disk: #{disk_name}"
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.disks.delete(resource_group_name, disk_name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Managed Disk #{disk_name} deleted successfully."
  true
end
delete_virtual_machine(resource_group, name) click to toggle source
# File lib/fog/azurerm/requests/compute/delete_virtual_machine.rb, line 6
def delete_virtual_machine(resource_group, name)
  msg = "Deleting Virtual Machine #{name} from Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.virtual_machines.delete(resource_group, name)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Virtual Machine #{name} Deleted Successfully."
  true
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) 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)
  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)
  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
  vm.resources = nil
  begin
    virtual_machine = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, vm_name, vm)
  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
end
generalize_virtual_machine(resource_group, name) click to toggle source
# File lib/fog/azurerm/requests/compute/generalize_virtual_machine.rb, line 6
def generalize_virtual_machine(resource_group, name)
  msg = "Generalizing Virtual Machine #{name} in Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.virtual_machines.generalize(resource_group, name)
  rescue  MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Virtual Machine #{name} Generalized Successfully."
  true
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) click to toggle source

create the properties object for creating availability sets

# File lib/fog/azurerm/requests/compute/create_availability_set.rb, line 20
def get_availability_set_properties(location)
  avail_set = Azure::ARM::Compute::Models::AvailabilitySet.new
  avail_set.platform_fault_domain_count = FAULT_DOMAIN_COUNT
  avail_set.platform_update_domain_count = UPDATE_DOMAIN_COUNT
  avail_set.virtual_machines = []
  avail_set.statuses = []
  avail_set.location = location
  avail_set
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) click to toggle source
# File lib/fog/azurerm/requests/compute/get_virtual_machine.rb, line 6
def get_virtual_machine(resource_group, name)
  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)
  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
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) 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)
  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)
  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
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) 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)
  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)
  rescue  MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Virtual Machine #{name} Powered off Successfully."
  true
end
redeploy_virtual_machine(resource_group, name) click to toggle source
# File lib/fog/azurerm/requests/compute/redeploy_virtual_machine.rb, line 6
def redeploy_virtual_machine(resource_group, name)
  msg = "Redeploying Virtual Machine #{name} in Resource Group #{resource_group}."
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.virtual_machines.redeploy(resource_group, name)
  rescue  MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Virtual Machine #{name} Redeployed Successfully."
  true
end
restart_virtual_machine(resource_group, name) click to toggle source
# File lib/fog/azurerm/requests/compute/restart_virtual_machine.rb, line 6
def restart_virtual_machine(resource_group, name)
  msg = "Restarting Virtual Machine #{name} in Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.virtual_machines.restart(resource_group, name)
  rescue  MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Virtual Machine #{name} Restarted Successfully."
  true
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) click to toggle source
# File lib/fog/azurerm/requests/compute/start_virtual_machine.rb, line 6
def start_virtual_machine(resource_group, name)
  msg = "Starting Virtual Machine #{name} in Resource Group #{resource_group}."
  Fog::Logger.debug msg
  begin
    @compute_mgmt_client.virtual_machines.start(resource_group, name)
  rescue  MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Virtual Machine #{name} started Successfully."
  true
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 82
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
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
define_hardware_profile(vm_size) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 68
def define_hardware_profile(vm_size)
  hw_profile = Azure::ARM::Compute::Models::HardwareProfile.new
  hw_profile.vm_size = vm_size
  hw_profile
end
define_linux_os_profile(vm_name, username, password, disable_password_authentication, ssh_key_path, ssh_key_data, encoded_data) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 155
def define_linux_os_profile(vm_name, username, password, disable_password_authentication, ssh_key_path, ssh_key_data, encoded_data)
  os_profile = Azure::ARM::Compute::Models::OSProfile.new
  linux_config = Azure::ARM::Compute::Models::LinuxConfiguration.new

  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.disable_password_authentication = disable_password_authentication
  os_profile.linux_configuration = linux_config
  os_profile.computer_name = vm_name
  os_profile.admin_username = username
  os_profile.admin_password = password
  os_profile.custom_data = encoded_data
  os_profile
end
define_network_profile(network_interface_card_ids) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 177
def define_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 ? true : false
    network_interface_cards << nic
  end

  network_profile = Azure::ARM::Compute::Models::NetworkProfile.new
  network_profile.network_interfaces = network_interface_cards
  network_profile
end
define_storage_profile(vm_name, storage_account_name, publisher, offer, sku, version, vhd_path, os_disk_caching, platform, resource_group) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 83
def define_storage_profile(vm_name, storage_account_name, publisher, offer, sku, version, vhd_path, os_disk_caching, platform, resource_group)
  storage_profile = Azure::ARM::Compute::Models::StorageProfile.new
  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 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
      )

      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

    img_vhd = Azure::ARM::Compute::Models::VirtualHardDisk.new
    img_vhd.uri = new_vhd_path
    os_disk.image = img_vhd
    os_disk.os_type = platform
  end

  os_disk.name = "#{vm_name}_os_disk"
  os_disk.vhd = vhd
  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

  storage_profile.os_disk = os_disk
  storage_profile
end
define_windows_os_profile(vm_name, username, password, provision_vm_agent, enable_automatic_updates, encoded_data) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 141
def define_windows_os_profile(vm_name, username, password, provision_vm_agent, enable_automatic_updates, encoded_data)
  os_profile = Azure::ARM::Compute::Models::OSProfile.new
  windows_config = Azure::ARM::Compute::Models::WindowsConfiguration.new
  windows_config.provision_vmagent = provision_vm_agent
  windows_config.enable_automatic_updates = enable_automatic_updates

  os_profile.windows_configuration = windows_config
  os_profile.computer_name = vm_name
  os_profile.admin_username = username
  os_profile.admin_password = password
  os_profile.custom_data = encoded_data
  os_profile
end
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_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 67
def get_data_disk_object(disk_name, disk_size, lun, storage_account_name, access_key)
  data_disk = Azure::ARM::Compute::Models::DataDisk.new
  data_disk.name = disk_name
  data_disk.lun = lun
  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_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_logical_unit_number(data_disks) click to toggle source
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 42
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_storage_access_key(resource_group, storage_account_name, storage_client) click to toggle source
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 55
def get_storage_access_key(resource_group, storage_account_name, storage_client)
  msg = "Getting Storage Access Keys from Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    storage_account_keys = storage_client.storage_accounts.list_keys(resource_group, storage_account_name)
  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_virtual_machine_instance(resource_group, vm_name, client) click to toggle source
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 30
def get_virtual_machine_instance(resource_group, vm_name, client)
  msg = "Getting Virtual Machine #{vm_name} from Resource Group #{resource_group}"
  Fog::Logger.debug msg
  begin
    virtual_machine = 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
image_reference(publisher, offer, sku, version) click to toggle source
# File lib/fog/azurerm/requests/compute/create_virtual_machine.rb, line 74
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