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
# 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
# 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] 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) 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 126 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 78 def get_data_disk_object(disk_resource_group, disk_name, lun) 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 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
# 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
# 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
# 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
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 65 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
# 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
# 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
# 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
# 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
# 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
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 99 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
# 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
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 111 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
# 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
# File lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb, line 53 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
# 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
# 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
# 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
# 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
# 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
# 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