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'
}
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'
]
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'
}
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']
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



288
289
290
291
292
 
# File 'lib/opennebula/virtual_machine.rb', line 288

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)



273
274
275
276
277
278
279
280
281
 
# File 'lib/opennebula/virtual_machine.rb', line 273

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 



283
284
285
 
# File 'lib/opennebula/virtual_machine.rb', line 283

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:



314
315
316
 
# File 'lib/opennebula/virtual_machine.rb', line 314

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:



801
802
803
 
# File 'lib/opennebula/virtual_machine.rb', line 801

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:



809
810
811
 
# File 'lib/opennebula/virtual_machine.rb', line 809

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:



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

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:



589
590
591
 
# File 'lib/opennebula/virtual_machine.rb', line 589

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



580
581
582
 
# File 'lib/opennebula/virtual_machine.rb', line 580

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

#delete(recreate = false) ⇒ Object

Deletes a VM from the pool



743
744
745
746
747
748
749
 
# File 'lib/opennebula/virtual_machine.rb', line 743

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:



366
367
368
369
370
371
372
373
374
375
376
377
378
379
 
# File 'lib/opennebula/virtual_machine.rb', line 366

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)



855
856
857
 
# File 'lib/opennebula/virtual_machine.rb', line 855

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:



433
434
435
 
# File 'lib/opennebula/virtual_machine.rb', line 433

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:



444
445
446
 
# File 'lib/opennebula/virtual_machine.rb', line 444

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:



727
728
729
 
# File 'lib/opennebula/virtual_machine.rb', line 727

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



550
551
552
553
554
555
556
557
558
559
 
# File 'lib/opennebula/virtual_machine.rb', line 550

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:



683
684
685
 
# File 'lib/opennebula/virtual_machine.rb', line 683

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:



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

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:



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

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:



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

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

#get_history_record(seq) ⇒ Object 



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

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



850
851
852
 
# File 'lib/opennebula/virtual_machine.rb', line 850

def gid
    self['GID'].to_i
end

#hold ⇒ Object

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



404
405
406
 
# File 'lib/opennebula/virtual_machine.rb', line 404

def hold
    action('hold')
end

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

Retrieves the information of the given VirtualMachine.



299
300
301
 
# File 'lib/opennebula/virtual_machine.rb', line 299

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

#lcm_state ⇒ Object

Returns the LCM state of the VirtualMachine (numeric value)



828
829
830
 
# File 'lib/opennebula/virtual_machine.rb', line 828

def lcm_state
    self['LCM_STATE'].to_i
end

#lcm_state_str ⇒ Object

Returns the LCM state of the VirtualMachine (string value)



833
834
835
 
# File 'lib/opennebula/virtual_machine.rb', line 833

def lcm_state_str
    LCM_STATE[lcm_state]
end

#live_migrate(host_id, enforce = false) ⇒ Object

Deprecated.

use #migrate instead



534
535
536
 
# File 'lib/opennebula/virtual_machine.rb', line 534

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:



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

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’.



621
622
623
 
# File 'lib/opennebula/virtual_machine.rb', line 621

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



628
629
630
631
632
 
# File 'lib/opennebula/virtual_machine.rb', line 628

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:



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

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:



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

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:



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

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

#poweroff(hard = false) ⇒ Object

Powers off a running VM



394
395
396
 
# File 'lib/opennebula/virtual_machine.rb', line 394

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

#reboot(hard = false) ⇒ Object

Reboots an already deployed VM



399
400
401
 
# File 'lib/opennebula/virtual_machine.rb', line 399

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:



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

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

#release ⇒ Object

Releases a VM from hold state



409
410
411
 
# File 'lib/opennebula/virtual_machine.rb', line 409

def release
    action('release')
end

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

Renames this VM

Parameters:

  • name (String) —

    New name for the VM.

Returns:



640
641
642
 
# File 'lib/opennebula/virtual_machine.rb', line 640

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

#replace(opts = {}) ⇒ Object 



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

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

#resched ⇒ Object

Sets the re-scheduling flag for the VM



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

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:



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

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

#resume ⇒ Object

Resumes the execution of a saved VM



424
425
426
 
# File 'lib/opennebula/virtual_machine.rb', line 424

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:



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

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:



781
782
783
 
# File 'lib/opennebula/virtual_machine.rb', line 781

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:



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

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:



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

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:



495
496
497
 
# File 'lib/opennebula/virtual_machine.rb', line 495

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



650
651
652
653
654
655
 
# File 'lib/opennebula/virtual_machine.rb', line 650

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:



673
674
675
 
# File 'lib/opennebula/virtual_machine.rb', line 673

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:



663
664
665
 
# File 'lib/opennebula/virtual_machine.rb', line 663

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)



818
819
820
 
# File 'lib/opennebula/virtual_machine.rb', line 818

def state
    self['STATE'].to_i
end

#state_str ⇒ Object

Returns the VM state of the VirtualMachine (string value)



823
824
825
 
# File 'lib/opennebula/virtual_machine.rb', line 823

def state_str
    VM_STATE[state]
end

#status ⇒ Object

Returns the short status string for the VirtualMachine



838
839
840
841
842
843
844
845
846
 
# File 'lib/opennebula/virtual_machine.rb', line 838

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



414
415
416
 
# File 'lib/opennebula/virtual_machine.rb', line 414

def stop
    action('stop')
end

#suspend ⇒ Object

Saves a running VM



419
420
421
 
# File 'lib/opennebula/virtual_machine.rb', line 419

def suspend
    action('suspend')
end

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

Shutdowns an already deployed VM



382
383
384
 
# File 'lib/opennebula/virtual_machine.rb', line 382

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



389
390
391
 
# File 'lib/opennebula/virtual_machine.rb', line 389

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

#unresched ⇒ Object

Unsets the re-scheduling flag for the VM



505
506
507
 
# File 'lib/opennebula/virtual_machine.rb', line 505

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:



326
327
328
 
# File 'lib/opennebula/virtual_machine.rb', line 326

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, and GRAPHICS/LISTEN, PASSWD, KEYMAP

  • append, —

    append template, do not delete empty attributes

Returns:



763
764
765
 
# File 'lib/opennebula/virtual_machine.rb', line 763

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



335
336
337
 
# File 'lib/opennebula/virtual_machine.rb', line 335

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



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

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 



863
864
865
866
867
868
869
870
871
872
873
 
# File 'lib/opennebula/virtual_machine.rb', line 863

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 



875
876
877
878
879
880
881
882
883
 
# File 'lib/opennebula/virtual_machine.rb', line 875

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