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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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 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
# 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
# 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_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) 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
# 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) 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
# 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
# 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 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
# 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 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
# 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) 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
# 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) 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
# 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
# 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
# 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) 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
# 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
# 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 68 def define_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 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
# 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
# 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
# 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
# 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 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
# 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/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
# 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/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
# 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
# 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