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_virtual_machine.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/list_available_sizes_for_virtual_machine.rb

Overview

This class provides the actual implemention for service calls.

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Real

Returns a new instance of Real.



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/fog/azurerm/compute.rb', line 49

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)
  @compute_mgmt_client.subscription_id = options[:subscription_id]
  @storage_mgmt_client = ::Azure::ARM::Storage::StorageManagementClient.new(credentials)
  @storage_mgmt_client.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
23
 
# 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, )
  Fog::Logger.debug "Attaching Data Disk #{disk_name} to Virtual Machine #{vm_name} in Resource Group #{resource_group}."
  vm = get_virtual_machine_instance(resource_group, vm_name, @compute_mgmt_client)
  lun = get_logical_unit_number(vm.properties.storage_profile.data_disks)
  access_key = get_storage_access_key(resource_group, , @storage_mgmt_client)
  data_disk = build_storage_profile(disk_name, disk_size, lun, , access_key)
  vm.properties.storage_profile.data_disks.push(data_disk)
  vm.resources = nil
  begin
    promise = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, vm_name, vm)
    result = promise.value!
    Fog::Logger.debug "Data Disk #{disk_name} attached to Virtual Machine #{vm_name} successfully."
    Azure::ARM::Compute::Models::VirtualMachine.serialize_object(result.body)
  rescue MsRestAzure::AzureOperationError => e
    msg = "Error Attaching Data Disk #{disk_name} to Virtual Machine #{vm_name} in Resource Group #{resource_group}. #{e.body['error']['message']}"
    raise msg
  end
end

#check_vm_status(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/fog/azurerm/requests/compute/check_vm_status.rb', line 6

def check_vm_status(resource_group, name)
  Fog::Logger.debug "Checking Virtual Machine #{name} status."
  begin
    # Pass 'instanceView' in get method, as argument, to get Virtual Machine status.

    promise = @compute_mgmt_client.virtual_machines.get(resource_group, name, 'instanceView')
    response = promise.value!
    virtual_machine = response.body
    get_status(virtual_machine)
  rescue  MsRestAzure::AzureOperationError => e
    msg = "Error in checking Virtual Machine '#{name}' status in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
end

#create_availability_set(resource_group, name, location) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/fog/azurerm/requests/compute/create_availability_set.rb', line 6

def create_availability_set(resource_group, name, location)
  begin
    Fog::Logger.debug "Creating Availability Set '#{name}' in #{location} region."
    avail_set_props = get_avail_set_properties(location)
    promise = @compute_mgmt_client.availability_sets.create_or_update(resource_group, name, avail_set_props)
    result = promise.value!
    Fog::Logger.debug "Availability Set #{name} created successfully."
    Azure::ARM::Compute::Models::AvailabilitySet.serialize_object(result.body)
  rescue MsRestAzure::AzureOperationError => e
    msg = "Exception creating Availability Set #{name} in Resource Group: #{resource_group}. #{e.body['error']['message']}"
    raise msg
  end
end

#create_virtual_machine(resource_group, name, location, vm_size, storage_account_name, username, password, disable_password_authentication, ssh_key_path, ssh_key_data, network_interface_card_id, availability_set_id, publisher, offer, sku, version, platform, provision_vm_agent, enable_automatic_updates) ⇒ Object 



6
7
8
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
 
# File 'lib/fog/azurerm/requests/compute/create_virtual_machine.rb', line 6

def create_virtual_machine(resource_group, name, location, vm_size, ,
                           username, password, disable_password_authentication,
                           ssh_key_path, ssh_key_data, network_interface_card_id,
                           availability_set_id, publisher, offer, sku, version,
                           platform, provision_vm_agent, enable_automatic_updates)
  Fog::Logger.debug "Creating Virtual Machine #{name} in Resource Group #{resource_group}."
  params = Azure::ARM::Compute::Models::VirtualMachine.new
  vm_properties = Azure::ARM::Compute::Models::VirtualMachineProperties.new

  unless availability_set_id.nil?
    sub_resource = MsRestAzure::SubResource.new
    sub_resource.id = availability_set_id
    vm_properties.availability_set = sub_resource
  end

  vm_properties.hardware_profile = define_hardware_profile(vm_size)
  vm_properties.storage_profile = define_storage_profile(name, , publisher, offer, sku, version)
  vm_properties.os_profile = if platform.casecmp('windows') == 0
                               define_windows_os_profile(name, username, password, provision_vm_agent, enable_automatic_updates)
                             else
                               define_linux_os_profile(name, username, password, disable_password_authentication, ssh_key_path, ssh_key_data)
                             end
  vm_properties.network_profile = define_network_profile(network_interface_card_id)
  params.properties = vm_properties
  params.location = location
  begin
    promise = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, name, params)
    result = promise.value!
    Fog::Logger.debug "Virtual Machine #{name} Created Successfully."
    Azure::ARM::Compute::Models::VirtualMachine.serialize_object(result.body)
  rescue MsRestAzure::AzureOperationError => e
    msg = "Error Creating Virtual Machine '#{name}' in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
end

#deallocate_virtual_machine(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/fog/azurerm/requests/compute/deallocate_virtual_machine.rb', line 6

def deallocate_virtual_machine(resource_group, name)
  Fog::Logger.debug "Deallocating Virtual Machine #{name} in Resource Group #{resource_group}."
  begin
    promise = @compute_mgmt_client.virtual_machines.deallocate(resource_group, name)
    promise.value!
    Fog::Logger.debug "Virtual Machine #{name} Deallocated Successfully."
    true
  rescue  MsRestAzure::AzureOperationError => e
    msg = "Error Deallocating Virtual Machine '#{name}' in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
end

#delete_availability_set(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/fog/azurerm/requests/compute/delete_availability_set.rb', line 6

def delete_availability_set(resource_group, name)
  begin
    Fog::Logger.debug "Deleting Availability Set: #{name}."
    promise = @compute_mgmt_client.availability_sets.delete(resource_group, name)
    promise.value!
    Fog::Logger.debug "Availability Set #{name} deleted successfully."
    true
  rescue MsRestAzure::AzureOperationError => e
    msg = "Exception deleting Availability Set #{name} in Resourse Group #{resource_group}. #{e.body['error']['message']}"
    raise msg
  end
end

#delete_virtual_machine(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/fog/azurerm/requests/compute/delete_virtual_machine.rb', line 6

def delete_virtual_machine(resource_group, name)
  Fog::Logger.debug "Deleting Virtual Machine #{name} from Resource Group #{resource_group}."
  begin
    promise = @compute_mgmt_client.virtual_machines.delete(resource_group, name)
    promise.value!
    Fog::Logger.debug "Virtual Machine #{name} Deleted Successfully."
    true
  rescue  MsRestAzure::AzureOperationError => e
    msg = "Error Deleting Virtual Machine '#{name}' from Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
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
24
 
# 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)
  Fog::Logger.debug "Detaching Data Disk #{disk_name} from Virtual Machine #{vm_name} in Resource Group #{resource_group}."
  vm = get_virtual_machine_instance(resource_group, vm_name, @compute_mgmt_client)
  vm.properties.storage_profile.data_disks.each_with_index do |disk, index|
    if disk.name == disk_name
      vm.properties.storage_profile.data_disks.delete_at(index)
    end
  end
  vm.resources = nil
  begin
    promise = @compute_mgmt_client.virtual_machines.create_or_update(resource_group, vm_name, vm)
    result = promise.value!
    Fog::Logger.debug "Data Disk #{disk_name} detached from Virtual Machine #{vm_name} successfully."
    Azure::ARM::Compute::Models::VirtualMachine.serialize_object(result.body)
  rescue MsRestAzure::AzureOperationError => e
    msg = "Error Detaching Data Disk #{disk_name} from Virtual Machine #{vm_name} in Resource Group #{resource_group}. #{e.body['error']['message']}"
    raise msg
  end
end

#generalize_virtual_machine(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/fog/azurerm/requests/compute/generalize_virtual_machine.rb', line 6

def generalize_virtual_machine(resource_group, name)
  Fog::Logger.debug "Generalizing Virtual Machine #{name} in Resource Group #{resource_group}."
  begin
    promise = @compute_mgmt_client.virtual_machines.generalize(resource_group, name)
    promise.value!
    Fog::Logger.debug "Virtual Machine #{name} Generalized Successfully."
    true
  rescue  MsRestAzure::AzureOperationError => e
    msg = "Error Generalizing Virtual Machine '#{name}' in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
end

#get_avail_set_properties(location) ⇒ Object

create the properties object for creating availability sets



21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/fog/azurerm/requests/compute/create_availability_set.rb', line 21

def get_avail_set_properties(location)
  avail_set_props = Azure::ARM::Compute::Models::AvailabilitySetProperties.new
  # At least two domain faults

  avail_set_props.platform_fault_domain_count = 2
  avail_set_props.platform_update_domain_count = 2
  # At this point we do not have virtual machines to include

  avail_set_props.virtual_machines = []
  avail_set_props.statuses = []
  avail_set = Azure::ARM::Compute::Models::AvailabilitySet.new
  avail_set.location = location
  avail_set.properties = avail_set_props
  avail_set
end

#get_status(virtual_machine) ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/fog/azurerm/requests/compute/check_vm_status.rb', line 20

def get_status(virtual_machine)
  vm_statuses = virtual_machine.properties.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
 
# File 'lib/fog/azurerm/requests/compute/get_virtual_machine.rb', line 6

def get_virtual_machine(resource_group, name)
  begin
    promise = @compute_mgmt_client.virtual_machines.get(resource_group, name)
    response = promise.value!
    Azure::ARM::Compute::Models::VirtualMachine.serialize_object(response.body)
  rescue MsRestAzure::AzureOperationError => e
    msg = "Exception getting Virtual Machine #{name} from Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
end

#list_availability_sets(resource_group) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/azurerm/requests/compute/list_availability_sets.rb', line 6

def list_availability_sets(resource_group)
  begin
    promise = @compute_mgmt_client.availability_sets.list(resource_group)
    response = promise.value!
    Azure::ARM::Compute::Models::AvailabilitySetListResult.serialize_object(response.body)['value']
  rescue MsRestAzure::AzureOperationError => e
    msg = "Exception listing availability sets in Resource Group #{resource_group}. #{e.body['error']['message']}"
    raise msg
  end
end

#list_available_sizes_for_virtual_machine(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# 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)
  begin
    response = @compute_mgmt_client.virtual_machines.list_available_sizes(resource_group, name)
    result = response.value!
    Azure::ARM::Compute::Models::VirtualMachineSizeListResult.serialize_object(result.body)['value']
  rescue MsRestAzure::AzureOperationError => e
    msg = "Error listing Sizes for Virtual Machine #{name} in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
end

#list_virtual_machines(resource_group) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/azurerm/requests/compute/list_virtual_machines.rb', line 6

def list_virtual_machines(resource_group)
  begin
    response = @compute_mgmt_client.virtual_machines.list(resource_group)
    result = response.value!
    Azure::ARM::Compute::Models::VirtualMachineListResult.serialize_object(result.body)['value']
  rescue MsRestAzure::AzureOperationError => e
    msg = "Error listing Virtual Machines in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
end

#power_off_virtual_machine(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/fog/azurerm/requests/compute/power_off_virtual_machine.rb', line 6

def power_off_virtual_machine(resource_group, name)
  Fog::Logger.debug "Powering off Virtual Machine #{name} in Resource Group #{resource_group}."
  begin
    promise = @compute_mgmt_client.virtual_machines.power_off(resource_group, name)
    promise.value!
    Fog::Logger.debug "Virtual Machine #{name} Powered off Successfully."
    true
  rescue  MsRestAzure::AzureOperationError => e
    msg = "Error Powering off Virtual Machine '#{name}' in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
end

#redeploy_virtual_machine(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/fog/azurerm/requests/compute/redeploy_virtual_machine.rb', line 6

def redeploy_virtual_machine(resource_group, name)
  Fog::Logger.debug "Redeploying Virtual Machine #{name} in Resource Group #{resource_group}."
  begin
    promise = @compute_mgmt_client.virtual_machines.redeploy(resource_group, name)
    promise.value!
    Fog::Logger.debug "Virtual Machine #{name} Redeployed Successfully."
    true
  rescue  MsRestAzure::AzureOperationError => e
    msg = "Error Redeploying Virtual Machine '#{name}' in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
end

#restart_virtual_machine(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/fog/azurerm/requests/compute/restart_virtual_machine.rb', line 6

def restart_virtual_machine(resource_group, name)
  Fog::Logger.debug "Restarting Virtual Machine #{name} in Resource Group #{resource_group}."
  begin
    promise = @compute_mgmt_client.virtual_machines.restart(resource_group, name)
    promise.value!
    Fog::Logger.debug "Virtual Machine #{name} Restarted Successfully."
    true
  rescue  MsRestAzure::AzureOperationError => e
    msg = "Error Restarting Virtual Machine '#{name}' in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
end

#start_virtual_machine(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/fog/azurerm/requests/compute/start_virtual_machine.rb', line 6

def start_virtual_machine(resource_group, name)
  Fog::Logger.debug "Starting Virtual Machine #{name} in Resource Group #{resource_group}."
  begin
    promise = @compute_mgmt_client.virtual_machines.start(resource_group, name)
    promise.value!
    Fog::Logger.debug "Virtual Machine #{name} started Successfully."
    true
  rescue  MsRestAzure::AzureOperationError => e
    msg = "Error starting Virtual Machine '#{name}' in Resource Group '#{resource_group}'. #{e.body['error']['message']}"
    raise msg
  end
end