Class: OpenNebula::VirtualMachine

Inherits:
PoolElement show all
Defined in:
lib/opennebula/virtual_machine.rb

Defined Under Namespace

Modules: Driver

Constant Summary collapse

VM_METHODS =

Constants and Class Methods

{
    :info           => 'vm.info',
    :allocate       => 'vm.allocate',
    :action         => 'vm.action',
    :migrate        => 'vm.migrate',
    :deploy         => 'vm.deploy',
    :chown          => 'vm.chown',
    :chmod          => 'vm.chmod',
    :monitoring     => 'vm.monitoring',
    :attach         => 'vm.attach',
    :detach         => 'vm.detach',
    :rename         => 'vm.rename',
    :update         => 'vm.update',
    :resize         => 'vm.resize',
    :snapshotcreate => 'vm.snapshotcreate',
    :snapshotrevert => 'vm.snapshotrevert',
    :snapshotdelete => 'vm.snapshotdelete',
    :attachnic      => 'vm.attachnic',
    :detachnic      => 'vm.detachnic',
    :recover        => 'vm.recover',
    :disksaveas     => 'vm.disksaveas',
    :disksnapshotcreate => 'vm.disksnapshotcreate',
    :disksnapshotrevert => 'vm.disksnapshotrevert',
    :disksnapshotdelete => 'vm.disksnapshotdelete',
    :disksnapshotrename => 'vm.disksnapshotrename',
    :diskresize     => 'vm.diskresize',
    :updateconf     => 'vm.updateconf',
    :lock           => 'vm.lock',
    :unlock         => 'vm.unlock',
    :schedadd       => 'vm.schedadd',
    :scheddelete    => 'vm.scheddelete',
    :schedupdate    => 'vm.schedupdate',
    :attachsg       => 'vm.attachsg',
    :detachsg       => 'vm.detachsg',
    :backup         => 'vm.backup',
    :updatenic      => 'vm.updatenic',
    :backupcancel   => 'vm.backupcancel',
    :attachpci      => 'vm.attachpci',
    :detachpci      => 'vm.detachpci',
    :restore        => 'vm.restore'
}
VM_STATE = 
['INIT', 'PENDING', 'HOLD', 'ACTIVE', 'STOPPED', 'SUSPENDED', 'DONE', 'FAILED',
'POWEROFF', 'UNDEPLOYED', 'CLONING', 'CLONING_FAILURE']
LCM_STATE = 
[
    'LCM_INIT',
    'PROLOG',
    'BOOT',
    'RUNNING',
    'MIGRATE',
    'SAVE_STOP',
    'SAVE_SUSPEND',
    'SAVE_MIGRATE',
    'PROLOG_MIGRATE',
    'PROLOG_RESUME',
    'EPILOG_STOP',
    'EPILOG',
    'SHUTDOWN',
    'CANCEL',
    'FAILURE',
    'CLEANUP_RESUBMIT',
    'UNKNOWN',
    'HOTPLUG',
    'SHUTDOWN_POWEROFF',
    'BOOT_UNKNOWN',
    'BOOT_POWEROFF',
    'BOOT_SUSPENDED',
    'BOOT_STOPPED',
    'CLEANUP_DELETE',
    'HOTPLUG_SNAPSHOT',
    'HOTPLUG_NIC',
    'HOTPLUG_SAVEAS',
    'HOTPLUG_SAVEAS_POWEROFF',
    'HOTPLUG_SAVEAS_SUSPENDED',
    'SHUTDOWN_UNDEPLOY',
    'EPILOG_UNDEPLOY',
    'PROLOG_UNDEPLOY',
    'BOOT_UNDEPLOY',
    'HOTPLUG_PROLOG_POWEROFF',
    'HOTPLUG_EPILOG_POWEROFF',
    'BOOT_MIGRATE',
    'BOOT_FAILURE',
    'BOOT_MIGRATE_FAILURE',
    'PROLOG_MIGRATE_FAILURE',
    'PROLOG_FAILURE',
    'EPILOG_FAILURE',
    'EPILOG_STOP_FAILURE',
    'EPILOG_UNDEPLOY_FAILURE',
    'PROLOG_MIGRATE_POWEROFF',
    'PROLOG_MIGRATE_POWEROFF_FAILURE',
    'PROLOG_MIGRATE_SUSPEND',
    'PROLOG_MIGRATE_SUSPEND_FAILURE',
    'BOOT_UNDEPLOY_FAILURE',
    'BOOT_STOPPED_FAILURE',
    'PROLOG_RESUME_FAILURE',
    'PROLOG_UNDEPLOY_FAILURE',
    'DISK_SNAPSHOT_POWEROFF',
    'DISK_SNAPSHOT_REVERT_POWEROFF',
    'DISK_SNAPSHOT_DELETE_POWEROFF',
    'DISK_SNAPSHOT_SUSPENDED',
    'DISK_SNAPSHOT_REVERT_SUSPENDED',
    'DISK_SNAPSHOT_DELETE_SUSPENDED',
    'DISK_SNAPSHOT',
    'DISK_SNAPSHOT_REVERT',
    'DISK_SNAPSHOT_DELETE',
    'PROLOG_MIGRATE_UNKNOWN',
    'PROLOG_MIGRATE_UNKNOWN_FAILURE',
    'DISK_RESIZE',
    'DISK_RESIZE_POWEROFF',
    'DISK_RESIZE_UNDEPLOYED',
    'HOTPLUG_NIC_POWEROFF',
    'HOTPLUG_RESIZE',
    'HOTPLUG_SAVEAS_UNDEPLOYED',
    'HOTPLUG_SAVEAS_STOPPED',
    'BACKUP',
    'BACKUP_POWEROFF',
    'RESTORE'
]
SHORT_VM_STATES = 
{
    'INIT'              => 'init',
    'PENDING'           => 'pend',
    'HOLD'              => 'hold',
    'ACTIVE'            => 'actv',
    'STOPPED'           => 'stop',
    'SUSPENDED'         => 'susp',
    'DONE'              => 'done',
    'FAILED'            => 'fail',
    'POWEROFF'          => 'poff',
    'UNDEPLOYED'        => 'unde',
    'CLONING'           => 'clon',
    'CLONING_FAILURE'   => 'fail'
}
SHORT_LCM_STATES = 
{
    'PROLOG'            => 'prol',
    'BOOT'              => 'boot',
    'RUNNING'           => 'runn',
    'MIGRATE'           => 'migr',
    'SAVE_STOP'         => 'save',
    'SAVE_SUSPEND'      => 'save',
    'SAVE_MIGRATE'      => 'save',
    'PROLOG_MIGRATE'    => 'migr',
    'PROLOG_RESUME'     => 'prol',
    'EPILOG_STOP'       => 'epil',
    'EPILOG'            => 'epil',
    'SHUTDOWN'          => 'shut',
    'CANCEL'            => 'shut',
    'FAILURE'           => 'fail',
    'CLEANUP_RESUBMIT'  => 'clea',
    'UNKNOWN'           => 'unkn',
    'HOTPLUG'           => 'hotp',
    'SHUTDOWN_POWEROFF' => 'shut',
    'BOOT_UNKNOWN'      => 'boot',
    'BOOT_POWEROFF'     => 'boot',
    'BOOT_SUSPENDED'    => 'boot',
    'BOOT_STOPPED'      => 'boot',
    'CLEANUP_DELETE'    => 'clea',
    'HOTPLUG_SNAPSHOT'  => 'snap',
    'HOTPLUG_NIC'       => 'hotp',
    'HOTPLUG_SAVEAS'           => 'hotp',
    'HOTPLUG_SAVEAS_POWEROFF'  => 'hotp',
    'HOTPLUG_SAVEAS_SUSPENDED' => 'hotp',
    'SHUTDOWN_UNDEPLOY' => 'shut',
    'EPILOG_UNDEPLOY'   => 'epil',
    'PROLOG_UNDEPLOY'   => 'prol',
    'BOOT_UNDEPLOY'     => 'boot',
    'HOTPLUG_PROLOG_POWEROFF'   => 'hotp',
    'HOTPLUG_EPILOG_POWEROFF'   => 'hotp',
    'BOOT_MIGRATE'              => 'boot',
    'BOOT_FAILURE'              => 'fail',
    'BOOT_MIGRATE_FAILURE'      => 'fail',
    'PROLOG_MIGRATE_FAILURE'    => 'fail',
    'PROLOG_FAILURE'            => 'fail',
    'EPILOG_FAILURE'            => 'fail',
    'EPILOG_STOP_FAILURE'       => 'fail',
    'EPILOG_UNDEPLOY_FAILURE'   => 'fail',
    'PROLOG_MIGRATE_POWEROFF'   => 'migr',
    'PROLOG_MIGRATE_POWEROFF_FAILURE'   => 'fail',
    'PROLOG_MIGRATE_SUSPEND'            => 'migr',
    'PROLOG_MIGRATE_SUSPEND_FAILURE'    => 'fail',
    'BOOT_UNDEPLOY_FAILURE'     => 'fail',
    'BOOT_STOPPED_FAILURE'      => 'fail',
    'PROLOG_RESUME_FAILURE'     => 'fail',
    'PROLOG_UNDEPLOY_FAILURE'   => 'fail',
    'DISK_SNAPSHOT_POWEROFF'        => 'snap',
    'DISK_SNAPSHOT_REVERT_POWEROFF' => 'snap',
    'DISK_SNAPSHOT_DELETE_POWEROFF' => 'snap',
    'DISK_SNAPSHOT_SUSPENDED'       => 'snap',
    'DISK_SNAPSHOT_REVERT_SUSPENDED'=> 'snap',
    'DISK_SNAPSHOT_DELETE_SUSPENDED'=> 'snap',
    'DISK_SNAPSHOT'        => 'snap',
    'DISK_SNAPSHOT_DELETE' => 'snap',
    'PROLOG_MIGRATE_UNKNOWN' => 'migr',
    'PROLOG_MIGRATE_UNKNOWN_FAILURE' => 'fail',
    'DISK_RESIZE'            => 'drsz',
    'DISK_RESIZE_POWEROFF'   => 'drsz',
    'DISK_RESIZE_UNDEPLOYED' => 'drsz',
    'HOTPLUG_NIC_POWEROFF'   => 'hotp',
    'HOTPLUG_RESIZE'         => 'hotp',
    'HOTPLUG_SAVEAS_UNDEPLOYED'  => 'hotp',
    'HOTPLUG_SAVEAS_STOPPED'     => 'hotp',
    'BACKUP'            => 'back',
    'BACKUP_POWEROFF'   => 'back',
    'RESTORE'           => 'rest'
}
HISTORY_ACTION = 
[
  'none',
  'migrate',
  'live-migrate',
  'shutdown',
  'shutdown-hard',
  'undeploy',
  'undeploy-hard',
  'hold',
  'release',
  'stop',
  'suspend',
  'resume',
  'boot',
  'delete',
  'delete-recreate',
  'reboot',
  'reboot-hard',
  'resched',
  'unresched',
  'poweroff',
  'poweroff-hard',
  'disk-attach',
  'disk-detach',
  'nic-attach',
  'nic-detach',
  'disk-snapshot-create',
  'disk-snapshot-delete',
  'terminate',
  'terminate-hard',
  'disk-resize',
  'deploy',
  'chown',
  'chmod',
  'updateconf',
  'rename',
  'resize',
  'update',
  'snapshot-resize',
  'snapshot-delete',
  'snapshot-revert',
  'disk-saveas',
  'disk-snapshot-revert',
  'recover',
  'retry',
  'monitor',
  'disk-snapshot-rename',
  'alias-attach',
  'alias-detach',
  'poweroff-migrate',
  'poweroff-hard-migrate',
  'backup',
  'nic-update',
  'backup-cancel',
  'sched-add',
  'sched-update',
  'sched-delete',
  'sg-attach',
  'sg-detach',
  'pci-attach',
  'pci-detach',
  'restore'
]
EXTERNAL_IP_ATTRS = 
[
    'GUEST_IP',
    'AWS_IP_ADDRESS',
    'AWS_PUBLIC_IP_ADDRESS',
    'AWS_PRIVATE_IP_ADDRESS',
    'AZ_IPADDRESS',
    'SL_PRIMARYIPADDRESS'
]

Instance Attribute Summary

Attributes inherited from PoolElement

#name

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from PoolElement

#id, new_with_id, #to_str

Methods inherited from XMLElement

#[], #add_element, #attr, #delete_element, #each, #each_xpath, #element_xml, #has_elements?, #initialize_xml, #name, #retrieve_elements, #retrieve_xmlelements, #set_content, #template_like_str, #template_str, #template_xml, #text, #to_hash, #to_xml, #xml_nil?

Constructor Details

#initialize(xml, client) ⇒ VirtualMachine

Class constructor



354
355
356
357
358
 
# File 'lib/opennebula/virtual_machine.rb', line 354

def initialize(xml, client)
    LockableExt.make_lockable(self, VM_METHODS)

    super(xml, client)
end

Class Method Details

.build_xml(pe_id = nil) ⇒ Object

Creates a VirtualMachine description with just its identifier this method should be used to create plain VirtualMachine objects. id the id of the vm

Example:

vm = VirtualMachine.new(VirtualMachine.build_xml(3),rpc_client)



339
340
341
342
343
344
345
346
347
 
# File 'lib/opennebula/virtual_machine.rb', line 339

def self.build_xml(pe_id = nil)
    if pe_id
        vm_xml = "<VM><ID>#{pe_id}</ID></VM>"
    else
        vm_xml = '<VM></VM>'
    end

    XMLElement.build_xml(vm_xml, 'VM')
end

.get_history_action(action) ⇒ Object 



349
350
351
 
# File 'lib/opennebula/virtual_machine.rb', line 349

def self.get_history_action(action)
    HISTORY_ACTION[action.to_i]
end

Instance Method Details

#allocate(description, hold = false) ⇒ nil, OpenNebula::Error

Allocates a new VirtualMachine in OpenNebula

Parameters:

  • description (String) —

    A string containing the template of the VirtualMachine.

  • hold (true, false) (defaults to: false) —

    false to create the VM in pending state, true to create it on hold

Returns:



380
381
382
 
# File 'lib/opennebula/virtual_machine.rb', line 380

def allocate(description, hold = false)
    super(VM_METHODS[:allocate], description, hold)
end

#backup(ds_id = -1,, reset = false) ⇒ Integer, OpenNebula::Error

Generate a backup for the VM (backup config must be set)

in case of success, Error otherwise.

Parameters:

  • ds_id (Integer) (defaults to: -1,) —

    Id of the datastore to save the backup

Returns:



868
869
870
 
# File 'lib/opennebula/virtual_machine.rb', line 868

def backup(ds_id = -1, reset = false)
    @client.call(VM_METHODS[:backup], @pe_id, ds_id, reset)
end

#backup_cancel ⇒ nil, OpenNebula::Error

Cancel ongoing backup operation for the VM

Returns:



876
877
878
 
# File 'lib/opennebula/virtual_machine.rb', line 876

def backup_cancel
    @client.call(VM_METHODS[:backupcancel], @pe_id)
end

#chmod(owner_u, owner_m, owner_a, group_u, group_m, group_a, other_u, other_m, other_a) ⇒ nil, OpenNebula::Error

Changes the permissions. Each [Integer] argument must be 1 to allow, 0 deny, -1 do not change

Returns:



664
665
666
667
668
 
# File 'lib/opennebula/virtual_machine.rb', line 664

def chmod(owner_u, owner_m, owner_a, group_u, group_m, group_a, other_u,
          other_m, other_a)
    super(VM_METHODS[:chmod], owner_u, owner_m, owner_a, group_u,
        group_m, group_a, other_u, other_m, other_a)
end

#chmod_octet(octet) ⇒ nil, OpenNebula::Error

Changes the permissions.

Parameters:

  • octet (String) —

    Permissions octed , e.g. 640

Returns:



655
656
657
 
# File 'lib/opennebula/virtual_machine.rb', line 655

def chmod_octet(octet)
    super(VM_METHODS[:chmod], octet)
end

#chown(uid, gid) ⇒ Object

Changes the owner/group

uid

Integer the new owner id. Set to -1 to leave the current one

gid

Integer the new group id. Set to -1 to leave the current one

return

nil in case of success or an Error object



646
647
648
 
# File 'lib/opennebula/virtual_machine.rb', line 646

def chown(uid, gid)
    super(VM_METHODS[:chown], uid, gid)
end

#delete(recreate = false) ⇒ Object

Deletes a VM from the pool



809
810
811
812
813
814
815
 
# File 'lib/opennebula/virtual_machine.rb', line 809

def delete(recreate = false)
    if recreate
        recover(4)
    else
        recover(3)
    end
end

#deploy(host_id, enforce = false, ds_id = -1,, extra_template = '') ⇒ nil, OpenNebula::Error

Initiates the instance of the VM on the target host.

Parameters:

  • host_id (Interger) —

    The host id (hid) of the target host where the VM will be instantiated.

  • enforce (true|false) (defaults to: false) —

    If it is set to true, the host capacity will be checked, and the deployment will fail if the host is overcommited. Defaults to false

  • ds_id (Integer) (defaults to: -1,) —

    The System Datastore where to deploy the VM. To use the default, set it to -1

Returns:



432
433
434
435
436
437
438
439
440
441
442
443
444
445
 
# File 'lib/opennebula/virtual_machine.rb', line 432

def deploy(host_id, enforce = false, ds_id = -1, extra_template = '')
    enforce ||= false
    ds_id ||= -1
    extra_template ||= ''

    info

    call(VM_METHODS[:deploy],
         @pe_id,
         host_id.to_i,
         enforce,
         ds_id.to_i,
         extra_template)
end

#deploy_id ⇒ Object

Returns the deploy_id of the VirtualMachine (numeric value)



948
949
950
 
# File 'lib/opennebula/virtual_machine.rb', line 948

def deploy_id
    self['DEPLOY_ID']
end

#disk_attach(disk_template) ⇒ nil, OpenNebula::Error Also known as: attachdisk

Attaches a disk to a running VM

Parameters:

  • disk_template (String) —

    Template containing a DISK element

Returns:



499
500
501
 
# File 'lib/opennebula/virtual_machine.rb', line 499

def disk_attach(disk_template)
    call(VM_METHODS[:attach], @pe_id, disk_template)
end

#disk_detach(disk_id) ⇒ nil, OpenNebula::Error Also known as: detachdisk

Detaches a disk from a running VM

Parameters:

  • disk_id (Integer) —

    Id of the disk to be detached

Returns:



510
511
512
 
# File 'lib/opennebula/virtual_machine.rb', line 510

def disk_detach(disk_id)
    call(VM_METHODS[:detach], @pe_id, disk_id)
end

#disk_resize(disk_id, size) ⇒ nil, OpenNebula::Error

Changes the size of a disk

Parameters:

  • disk_id (Integer) —

    Id of the disk

  • size (Integer) —

    new size in MiB

Returns:



793
794
795
 
# File 'lib/opennebula/virtual_machine.rb', line 793

def disk_resize(disk_id, size)
    call(VM_METHODS[:diskresize], @pe_id, disk_id, size.to_s)
end

#disk_saveas(disk_id, image_name, image_type = '', snap_id = -1)) ⇒ Integer, OpenNebula::Error

Set the specified vm’s disk to be saved as a new image

current disk image state

Parameters:

  • disk_id (Integer) —

    ID of the disk to be saved

  • image_name (String) —

    Name for the new image where the disk will be saved

  • image_type (String) (defaults to: '') —

    Type of the new image. Set to empty string to use the default type

  • snap_id (Integer) (defaults to: -1)) —

    ID of the snapshot to save, -1 to use the

Returns:

  • (Integer, OpenNebula::Error) —

    the new Image ID in case of success, error otherwise



616
617
618
619
620
621
622
623
624
625
 
# File 'lib/opennebula/virtual_machine.rb', line 616

def disk_saveas(disk_id, image_name, image_type = '', snap_id = -1)
    return Error.new('ID not defined') unless @pe_id

    @client.call(VM_METHODS[:disksaveas],
                 @pe_id,
                 disk_id,
                 image_name,
                 image_type,
                 snap_id)
end

#disk_snapshot_create(disk_id, name) ⇒ Integer, OpenNebula::Error

Takes a new snapshot of a disk

Parameters:

  • disk_id (Integer) —

    Id of the disk

  • name (String) —

    description for the snapshot

Returns:



749
750
751
 
# File 'lib/opennebula/virtual_machine.rb', line 749

def disk_snapshot_create(disk_id, name)
    call(VM_METHODS[:disksnapshotcreate], @pe_id, disk_id, name)
end

#disk_snapshot_delete(disk_id, snap_id) ⇒ nil, OpenNebula::Error

Deletes a disk snapshot

Parameters:

  • disk_id (Integer) —

    Id of the disk

  • snap_id (Integer) —

    Id of the snapshot

Returns:



771
772
773
 
# File 'lib/opennebula/virtual_machine.rb', line 771

def disk_snapshot_delete(disk_id, snap_id)
    call(VM_METHODS[:disksnapshotdelete], @pe_id, disk_id, snap_id)
end

#disk_snapshot_rename(disk_id, snap_id, new_name) ⇒ nil, OpenNebula::Error

Renames a disk snapshot

Parameters:

  • disk_id (Integer) —

    Id of the disk

  • snap_id (Integer) —

    Id of the snapshot

  • new_name (String) —

    New name for the snapshot

Returns:



783
784
785
 
# File 'lib/opennebula/virtual_machine.rb', line 783

def disk_snapshot_rename(disk_id, snap_id, new_name)
    call(VM_METHODS[:disksnapshotrename], @pe_id, disk_id, snap_id, new_name)
end

#disk_snapshot_revert(disk_id, snap_id) ⇒ nil, OpenNebula::Error

Reverts disk state to a previously taken snapshot

Parameters:

  • disk_id (Integer) —

    Id of the disk

  • snap_id (Integer) —

    Id of the snapshot

Returns:



760
761
762
 
# File 'lib/opennebula/virtual_machine.rb', line 760

def disk_snapshot_revert(disk_id, snap_id)
    call(VM_METHODS[:disksnapshotrevert], @pe_id, disk_id, snap_id)
end

#get_history_record(seq) ⇒ Object 



952
953
954
 
# File 'lib/opennebula/virtual_machine.rb', line 952

def get_history_record(seq)
    retrieve_xmlelements('//HISTORY')[seq].to_xml
end

#gid ⇒ Object

Returns the group identifier

return

Integer the element’s group ID



943
944
945
 
# File 'lib/opennebula/virtual_machine.rb', line 943

def gid
    self['GID'].to_i
end

#hold ⇒ Object

Sets a VM to hold state, scheduler will not deploy it



470
471
472
 
# File 'lib/opennebula/virtual_machine.rb', line 470

def hold
    action('hold')
end

#info(decrypt = false) ⇒ Object Also known as: info!

Retrieves the information of the given VirtualMachine.



365
366
367
 
# File 'lib/opennebula/virtual_machine.rb', line 365

def info(decrypt = false)
    super(VM_METHODS[:info], 'VM', decrypt)
end

#lcm_state ⇒ Object

Returns the LCM state of the VirtualMachine (numeric value)



921
922
923
 
# File 'lib/opennebula/virtual_machine.rb', line 921

def lcm_state
    self['LCM_STATE'].to_i
end

#lcm_state_str ⇒ Object

Returns the LCM state of the VirtualMachine (string value)



926
927
928
 
# File 'lib/opennebula/virtual_machine.rb', line 926

def lcm_state_str
    LCM_STATE[lcm_state]
end

#live_migrate(host_id, enforce = false) ⇒ Object

Deprecated.

use #migrate instead



600
601
602
 
# File 'lib/opennebula/virtual_machine.rb', line 600

def live_migrate(host_id, enforce = false)
    migrate(host_id, true, enforce)
end

#migrate(host_id, live = false, enforce = false, ds_id = -1,, mtype = 0) ⇒ nil, OpenNebula::Error

Moves a running VM to the specified host. With live=true the migration is done withdout downtime.

Parameters:

  • host_id (Interger) —

    The host id (hid) of the target host where the VM will be migrated.

  • live (true|false) (defaults to: false) —

    If true the migration is done without downtime. Defaults to false

  • enforce (true|false) (defaults to: false) —

    If it is set to true, the host capacity will be checked, and the deployment will fail if the host is overcommited. Defaults to false

  • ds_id (Integer) (defaults to: -1,) —

    The System Datastore where to migrate the VM. To use the current one, set it to -1

  • mtype (Integer) (defaults to: 0) —

    How to perform the cold migration:

    • 0: save - restore,

    • 1: power off - boot

    • 2: power off hard - boot

Returns:



594
595
596
597
 
# File 'lib/opennebula/virtual_machine.rb', line 594

def migrate(host_id, live = false, enforce = false, ds_id = -1, mtype = 0)
    call(VM_METHODS[:migrate], @pe_id, host_id.to_i, live==true,
         enforce, ds_id.to_i, mtype)
end

#monitoring(xpath_expressions) ⇒ Hash<String, Array<Array<int>>>, OpenNebula::Error

Retrieves this VM’s monitoring data from OpenNebula

Examples:

vm.monitoring( ['CPU', 'NETTX'] )

{
 "CPU"=>[["1435085098", "47"], ["1435085253", "5"],
   ["1435085410", "48"], ["1435085566", "3"], ["1435088136", "2"]],
 "NETTX"=>[["1435085098", "0"], ["1435085253", "50"],
   ["1435085410", "50"], ["1435085566", "50"], ["1435085723", "50"]]
}

Parameters:

  • xpath_expressions (Array<String>) —

    Elements to retrieve.

Returns:

  • (Hash<String, Array<Array<int>>>, OpenNebula::Error) —

    Hash with the requested xpath expressions, and an Array of ‘timestamp, value’.



687
688
689
 
# File 'lib/opennebula/virtual_machine.rb', line 687

def monitoring(xpath_expressions)
    super(VM_METHODS[:monitoring], xpath_expressions)
end

#monitoring_xml ⇒ String

Retrieves this VM’s monitoring data from OpenNebula, in XML

Returns:

  • (String) —

    VM monitoring data, in XML



694
695
696
697
698
 
# File 'lib/opennebula/virtual_machine.rb', line 694

def monitoring_xml
    return Error.new('ID not defined') unless @pe_id

    @client.call(VM_METHODS[:monitoring], @pe_id)
end

#nic_attach(nic_template) ⇒ nil, OpenNebula::Error

Attaches a NIC to a running VM

Parameters:

  • nic_template (String) —

    Template containing a NIC element

Returns:



521
522
523
 
# File 'lib/opennebula/virtual_machine.rb', line 521

def nic_attach(nic_template)
    call(VM_METHODS[:attachnic], @pe_id, nic_template)
end

#nic_detach(nic_id) ⇒ nil, OpenNebula::Error

Detaches a NIC from a running VM

Parameters:

  • nic_id (Integer) —

    Id of the NIC to be detached

Returns:



530
531
532
 
# File 'lib/opennebula/virtual_machine.rb', line 530

def nic_detach(nic_id)
    call(VM_METHODS[:detachnic], @pe_id, nic_id)
end

#nic_update(nic_id, nic_template, append = false) ⇒ nil, OpenNebula::Error

Updates a NIC for a running VM

Parameters:

  • nic_id (Integer) —

    Id of the NIC to be updated

  • nic_template (String) —

    Template with updated attributes

  • append (true|false) (defaults to: false) —

    True to append new attributes instead of replace the whole template

Returns:



542
543
544
 
# File 'lib/opennebula/virtual_machine.rb', line 542

def nic_update(nic_id, nic_template, append = false)
    call(VM_METHODS[:updatenic], @pe_id, nic_id, nic_template, append ? 1 : 0)
end

#pci_attach(pci) ⇒ nil, OpenNebula::Error

Attaches a PCI to a VM

Parameters:

  • pci (String) —

    Template containing a PCI element

Returns:



885
886
887
 
# File 'lib/opennebula/virtual_machine.rb', line 885

def pci_attach(pci)
    call(VM_METHODS[:attachpci], @pe_id, pci)
end

#pci_detach(pci_id) ⇒ nil, OpenNebula::Error

Detaches a PCI from a VM

Parameters:

  • pci_id (Integer) —

    Id of the PCI to be detached

Returns:



894
895
896
 
# File 'lib/opennebula/virtual_machine.rb', line 894

def pci_detach(pci_id)
    call(VM_METHODS[:detachpci], @pe_id, pci_id)
end

#poweroff(hard = false) ⇒ Object

Powers off a running VM



460
461
462
 
# File 'lib/opennebula/virtual_machine.rb', line 460

def poweroff(hard = false)
    action(hard ? 'poweroff-hard' : 'poweroff')
end

#reboot(hard = false) ⇒ Object

Reboots an already deployed VM



465
466
467
 
# File 'lib/opennebula/virtual_machine.rb', line 465

def reboot(hard = false)
    action(hard ? 'reboot-hard' : 'reboot')
end

#recover(result) ⇒ nil, OpenNebula::Error

Recovers an ACTIVE VM

retry (2), delete (3), delete-recreate (4), delete-db (5)

Parameters:

  • result (Integer) —

    Recover with failure (0), success (1),

  • result (info) —

    Additional information needed to recover the VM

Returns:



804
805
806
 
# File 'lib/opennebula/virtual_machine.rb', line 804

def recover(result)
    call(VM_METHODS[:recover], @pe_id, result)
end

#release ⇒ Object

Releases a VM from hold state



475
476
477
 
# File 'lib/opennebula/virtual_machine.rb', line 475

def release
    action('release')
end

#rename(name) ⇒ nil, OpenNebula::Error

Renames this VM

Parameters:

  • name (String) —

    New name for the VM.

Returns:



706
707
708
 
# File 'lib/opennebula/virtual_machine.rb', line 706

def rename(name)
    call(VM_METHODS[:rename], @pe_id, name)
end

#replace(opts = {}) ⇒ Object 



416
417
418
 
# File 'lib/opennebula/virtual_machine.rb', line 416

def replace(opts = {})
    super(opts, 'USER_TEMPLATE')
end

#resched ⇒ Object

Sets the re-scheduling flag for the VM



566
567
568
 
# File 'lib/opennebula/virtual_machine.rb', line 566

def resched
    action('resched')
end

#resize(capacity_template, enforce) ⇒ nil, OpenNebula::Error

Resize the VM

Parameters:

  • capacity_template (String) —

    Template containing the new capacity elements CPU, VCPU, MEMORY. If one of them is not present, or its value is 0, it will not be resized

  • enforce (true|false) —

    If it is set to true, the host capacity will be checked. This will only affect oneadmin requests, regular users resize requests will always be enforced

Returns:



638
639
640
 
# File 'lib/opennebula/virtual_machine.rb', line 638

def resize(capacity_template, enforce)
    call(VM_METHODS[:resize], @pe_id, capacity_template, enforce)
end

#restore(img_id, inc_id, disk_id) ⇒ nil, OpenNebula::Error

Restore the VM from backup Image

Returns:



902
903
904
 
# File 'lib/opennebula/virtual_machine.rb', line 902

def restore(img_id, inc_id, disk_id)
    @client.call(VM_METHODS[:restore], @pe_id, img_id, inc_id, disk_id)
end

#resume ⇒ Object

Resumes the execution of a saved VM



490
491
492
 
# File 'lib/opennebula/virtual_machine.rb', line 490

def resume
    action('resume')
end

#sched_action_add(sched_template) ⇒ nil, OpenNebula::Error

Add sched actions

Parameters:

  • sched_template (String) —

    Template with SCHED_ACTIONs

Returns:



839
840
841
 
# File 'lib/opennebula/virtual_machine.rb', line 839

def sched_action_add(sched_template)
    call(VM_METHODS[:schedadd], @pe_id, sched_template)
end

#sched_action_delete(sched_id) ⇒ nil, OpenNebula::Error

Delete sched action

Parameters:

  • sched_id (Int) —

    id of the SCHED_ACTION

Returns:



848
849
850
 
# File 'lib/opennebula/virtual_machine.rb', line 848

def sched_action_delete(sched_id)
    call(VM_METHODS[:scheddelete], @pe_id, sched_id.to_i)
end

#sched_action_update(sched_id, sched_template) ⇒ nil, OpenNebula::Error

Update sched_action

Parameters:

  • sched_id (Int) —

    id of the SCHED_ACTION

  • sched_template (String) —

    Template containing a SCHED_ACTION

Returns:



858
859
860
861
 
# File 'lib/opennebula/virtual_machine.rb', line 858

def sched_action_update(sched_id, sched_template)
    call(VM_METHODS[:schedupdate], @pe_id, sched_id.to_i,
         sched_template)
end

#sg_attach(nic_id, sg_id) ⇒ nil, OpenNebula::Error

Attaches a Security Groupt to a running VM

Parameters:

  • nic_id (Integer) —

    Id of the NIC, where to attach SG

  • sg_id (Integer) —

    Id of the SG to be attached

Returns:



552
553
554
 
# File 'lib/opennebula/virtual_machine.rb', line 552

def sg_attach(nic_id, sg_id)
    call(VM_METHODS[:attachsg], @pe_id, nic_id, sg_id)
end

#sg_detach(nic_id, sg_id) ⇒ nil, OpenNebula::Error

Detaches a Security Group from a running VM

Parameters:

  • sg_id (Integer) —

    Id of the SG to be detached

Returns:



561
562
563
 
# File 'lib/opennebula/virtual_machine.rb', line 561

def sg_detach(nic_id, sg_id)
    call(VM_METHODS[:detachsg], @pe_id, nic_id, sg_id)
end

#snapshot_create(name = '') ⇒ Integer, OpenNebula::Error

Creates a new VM snapshot

Parameters:

  • name (String) (defaults to: '') —

    Name for the snapshot.

Returns:

  • (Integer, OpenNebula::Error) —

    The new snaphost ID in case of success, Error otherwise



716
717
718
719
720
721
 
# File 'lib/opennebula/virtual_machine.rb', line 716

def snapshot_create(name = '')
    return Error.new('ID not defined') unless @pe_id

    name ||= ''
    @client.call(VM_METHODS[:snapshotcreate], @pe_id, name)
end

#snapshot_delete(snap_id) ⇒ nil, OpenNebula::Error

Deletes a VM snapshot

Parameters:

  • snap_id (Integer) —

    Id of the snapshot

Returns:



739
740
741
 
# File 'lib/opennebula/virtual_machine.rb', line 739

def snapshot_delete(snap_id)
    call(VM_METHODS[:snapshotdelete], @pe_id, snap_id)
end

#snapshot_revert(snap_id) ⇒ nil, OpenNebula::Error

Reverts to a snapshot

Parameters:

  • snap_id (Integer) —

    Id of the snapshot

Returns:



729
730
731
 
# File 'lib/opennebula/virtual_machine.rb', line 729

def snapshot_revert(snap_id)
    call(VM_METHODS[:snapshotrevert], @pe_id, snap_id)
end

#state ⇒ Object

Returns the VM state of the VirtualMachine (numeric value)



911
912
913
 
# File 'lib/opennebula/virtual_machine.rb', line 911

def state
    self['STATE'].to_i
end

#state_str ⇒ Object

Returns the VM state of the VirtualMachine (string value)



916
917
918
 
# File 'lib/opennebula/virtual_machine.rb', line 916

def state_str
    VM_STATE[state]
end

#status ⇒ Object

Returns the short status string for the VirtualMachine



931
932
933
934
935
936
937
938
939
 
# File 'lib/opennebula/virtual_machine.rb', line 931

def status
    short_state_str=SHORT_VM_STATES[state_str]

    if short_state_str=='actv'
        short_state_str=SHORT_LCM_STATES[lcm_state_str]
    end

    short_state_str
end

#stop ⇒ Object

Stops a running VM



480
481
482
 
# File 'lib/opennebula/virtual_machine.rb', line 480

def stop
    action('stop')
end

#suspend ⇒ Object

Saves a running VM



485
486
487
 
# File 'lib/opennebula/virtual_machine.rb', line 485

def suspend
    action('suspend')
end

#terminate(hard = false) ⇒ Object Also known as: shutdown

Shutdowns an already deployed VM



448
449
450
 
# File 'lib/opennebula/virtual_machine.rb', line 448

def terminate(hard = false)
    action(hard ? 'terminate-hard' : 'terminate')
end

#undeploy(hard = false) ⇒ Object

Shuts down an already deployed VM, saving its state in the system DS



455
456
457
 
# File 'lib/opennebula/virtual_machine.rb', line 455

def undeploy(hard = false)
    action(hard ? 'undeploy-hard' : 'undeploy')
end

#unresched ⇒ Object

Unsets the re-scheduling flag for the VM



571
572
573
 
# File 'lib/opennebula/virtual_machine.rb', line 571

def unresched
    action('unresched')
end

#update(new_template = nil, append = false) ⇒ nil, OpenNebula::Error

Replaces the template contents

Parameters:

  • new_template (String) (defaults to: nil) —

    New template contents

  • append (true, false) (defaults to: false) —

    True to append new attributes instead of replace the whole template

Returns:



392
393
394
 
# File 'lib/opennebula/virtual_machine.rb', line 392

def update(new_template = nil, append = false)
    super(VM_METHODS[:update], new_template, append ? 1 : 0)
end

#updateconf(new_conf, append = false) ⇒ nil, OpenNebula::Error

Changes the attributes of a VM in power off, failure and undeploy

states

Parameters:

  • new_conf, —

    string describing the new attributes. Each attribute will replace the existing ones or delete it if empty. Attributes that can be updated are: INPUT/BUS; RAW/DATA, DATA_VMX, OS/BOOTLOADER, ARCH, MACHINE, KERNEL, INITRD, FEATURES/APIC, PAE, LOCALTIME, HYPERV, GUEST_AGENT, VIRTIO_SCSI_QUEUES, VIRTIO_BLK_QUEUES, IOTHREADS, GRAPHICS/LISTEN, PASSWD, KEYMAP, and VIDEO/IOMMU, ATS, VRAM, RESOLUTION

  • append, —

    append template, do not delete empty attributes

Returns:



830
831
832
 
# File 'lib/opennebula/virtual_machine.rb', line 830

def updateconf(new_conf, append = false)
    call(VM_METHODS[:updateconf], @pe_id, new_conf, append ? 1 : 0)
end

#user_template_str(indent = true) ⇒ String

Returns the <USER_TEMPLATE> element in text form

Parameters:

  • indent (true, false) (defaults to: true) —

    indents the resulting string, defaults to true

Returns:

  • (String) —

    The USER_TEMPLATE



401
402
403
 
# File 'lib/opennebula/virtual_machine.rb', line 401

def user_template_str(indent = true)
    template_like_str('USER_TEMPLATE', indent)
end

#user_template_xml ⇒ String

Returns the <USER_TEMPLATE> element in XML form

Returns:

  • (String) —

    The USER_TEMPLATE



408
409
410
411
412
413
414
 
# File 'lib/opennebula/virtual_machine.rb', line 408

def user_template_xml
    if NOKOGIRI
        @xml.xpath('USER_TEMPLATE').to_s
    else
        @xml.elements['USER_TEMPLATE'].to_s
    end
end

#wait_state(state, timeout = 120) ⇒ Object 



956
957
958
959
960
961
962
963
964
965
966
 
# File 'lib/opennebula/virtual_machine.rb', line 956

def wait_state(state, timeout = 120)
    require 'opennebula/wait_ext'

    extend OpenNebula::WaitExt

    rc = wait2(state, 'LCM_INIT', timeout)

    return Error.new("Timeout expired for state #{state}.") unless rc

    true
end

#wait_state2(state, lcm_state, timeout = 120) ⇒ Object 



968
969
970
971
972
973
974
975
976
 
# File 'lib/opennebula/virtual_machine.rb', line 968

def wait_state2(state, lcm_state, timeout = 120)
    extend OpenNebula::WaitExt

    rc = wait2(state, lcm_state, timeout)

    return Error.new("Timeout expired for state #{state}.") unless rc

    true
end