Class: Fog::Compute::AzureRM::Real

Inherits:
Object
  • Object
show all
Defined in:
lib/fog/azurerm/compute.rb,
lib/fog/azurerm/requests/compute/check_vm_status.rb,
lib/fog/azurerm/requests/compute/get_vm_extension.rb,
lib/fog/azurerm/requests/compute/delete_vm_extension.rb,
lib/fog/azurerm/requests/compute/get_virtual_machine.rb,
lib/fog/azurerm/requests/compute/get_availability_set.rb,
lib/fog/azurerm/requests/compute/list_virtual_machines.rb,
lib/fog/azurerm/requests/compute/start_virtual_machine.rb,
lib/fog/azurerm/requests/compute/attach_data_disk_to_vm.rb,
lib/fog/azurerm/requests/compute/create_virtual_machine.rb,
lib/fog/azurerm/requests/compute/delete_virtual_machine.rb,
lib/fog/azurerm/requests/compute/list_availability_sets.rb,
lib/fog/azurerm/requests/compute/create_availability_set.rb,
lib/fog/azurerm/requests/compute/delete_availability_set.rb,
lib/fog/azurerm/requests/compute/restart_virtual_machine.rb,
lib/fog/azurerm/requests/compute/detach_data_disk_from_vm.rb,
lib/fog/azurerm/requests/compute/redeploy_virtual_machine.rb,
lib/fog/azurerm/requests/compute/power_off_virtual_machine.rb,
lib/fog/azurerm/requests/compute/deallocate_virtual_machine.rb,
lib/fog/azurerm/requests/compute/generalize_virtual_machine.rb,
lib/fog/azurerm/requests/compute/create_or_update_vm_extension.rb,
lib/fog/azurerm/requests/compute/list_available_sizes_for_virtual_machine.rb

Overview

This class provides the actual implementation for service calls.

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Real

Returns a new instance of Real.



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/fog/azurerm/compute.rb', line 54

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

  credentials = Fog::Credentials::AzureRM.get_credentials(options[:tenant_id], options[:client_id], options[:client_secret])
  @compute_mgmt_client = ::Azure::ARM::Compute::ComputeManagementClient.new(credentials, resource_manager_endpoint_url)
  @compute_mgmt_client.subscription_id = options[:subscription_id]
  @storage_mgmt_client = ::Azure::ARM::Storage::StorageManagementClient.new(credentials, resource_manager_endpoint_url)
  @storage_mgmt_client.subscription_id = options[:subscription_id]
  @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])
end

Instance Method Details

#attach_data_disk_to_vm(resource_group, vm_name, disk_name, disk_size, storage_account_name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# 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, )
  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_mgmt_client)
  data_disk = get_data_disk_object(disk_name, disk_size, lun, , 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
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Data Disk #{disk_name} attached to Virtual Machine #{vm_name} successfully."
  virtual_machine
end

#check_vm_status(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# 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_vm_extension(vm_extension_params) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
 
# 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) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/fog/azurerm/requests/compute/create_virtual_machine.rb', line 9

def create_virtual_machine(vm_hash)
  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[: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_id])
  virtual_machine.location = vm_hash[:location]
  begin
    vm = @compute_mgmt_client.virtual_machines.create_or_update(vm_hash[:resource_group], vm_hash[:name], virtual_machine)
  rescue MsRestAzure::AzureOperationError => e
    raise_azure_exception(e, msg)
  end
  Fog::Logger.debug "Virtual Machine #{vm_hash[:name]} Created Successfully."
  vm
end

#deallocate_virtual_machine(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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_virtual_machine(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
 
# 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) ⇒ Object

create the properties object for creating availability sets



20
21
22
23
24
25
26
27
28
 
# 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_status(virtual_machine) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
28
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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

#list_availability_sets(resource_group) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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_virtual_machines(resource_group) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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

#start_virtual_machine(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# 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