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

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



345
346
347
348
349
 
# File 'lib/opennebula/virtual_machine.rb', line 345

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)



330
331
332
333
334
335
336
337
338
 
# File 'lib/opennebula/virtual_machine.rb', line 330

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 



340
341
342
 
# File 'lib/opennebula/virtual_machine.rb', line 340

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



371
372
373
 
# File 'lib/opennebula/virtual_machine.rb', line 371

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)



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

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



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

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



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

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.



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

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



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

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

#delete(recreate = false) ⇒ Object

Deletes a VM from the pool



800
801
802
803
804
805
806
 
# File 'lib/opennebula/virtual_machine.rb', line 800

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.



423
424
425
426
427
428
429
430
431
432
433
434
435
436
 
# File 'lib/opennebula/virtual_machine.rb', line 423

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)



939
940
941
 
# File 'lib/opennebula/virtual_machine.rb', line 939

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



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

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



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

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



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

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



607
608
609
610
611
612
613
614
615
616
 
# File 'lib/opennebula/virtual_machine.rb', line 607

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



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

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



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

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



774
775
776
 
# File 'lib/opennebula/virtual_machine.rb', line 774

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



751
752
753
 
# File 'lib/opennebula/virtual_machine.rb', line 751

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

#get_history_record(seq) ⇒ Object 



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

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



934
935
936
 
# File 'lib/opennebula/virtual_machine.rb', line 934

def gid
    self['GID'].to_i
end

#hold ⇒ Object

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



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

def hold
    action('hold')
end

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

Retrieves the information of the given VirtualMachine.



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

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

#lcm_state ⇒ Object

Returns the LCM state of the VirtualMachine (numeric value)



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

def lcm_state
    self['LCM_STATE'].to_i
end

#lcm_state_str ⇒ Object

Returns the LCM state of the VirtualMachine (string value)



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

def lcm_state_str
    LCM_STATE[lcm_state]
end

#live_migrate(host_id, enforce = false) ⇒ Object

Deprecated.

use #migrate instead



591
592
593
 
# File 'lib/opennebula/virtual_machine.rb', line 591

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.



585
586
587
588
 
# File 'lib/opennebula/virtual_machine.rb', line 585

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


678
679
680
 
# File 'lib/opennebula/virtual_machine.rb', line 678

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

#monitoring_xml ⇒ String

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



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

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



512
513
514
 
# File 'lib/opennebula/virtual_machine.rb', line 512

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



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

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



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

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



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

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



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

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

#poweroff(hard = false) ⇒ Object

Powers off a running VM



451
452
453
 
# File 'lib/opennebula/virtual_machine.rb', line 451

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

#reboot(hard = false) ⇒ Object

Reboots an already deployed VM



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

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)



795
796
797
 
# File 'lib/opennebula/virtual_machine.rb', line 795

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

#release ⇒ Object

Releases a VM from hold state



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

def release
    action('release')
end

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

Renames this VM



697
698
699
 
# File 'lib/opennebula/virtual_machine.rb', line 697

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

#replace(opts = {}) ⇒ Object 



407
408
409
 
# File 'lib/opennebula/virtual_machine.rb', line 407

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

#resched ⇒ Object

Sets the re-scheduling flag for the VM



557
558
559
 
# File 'lib/opennebula/virtual_machine.rb', line 557

def resched
    action('resched')
end

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

Resize the VM



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

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



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

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



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

def resume
    action('resume')
end

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

Add sched actions



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

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



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

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



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

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



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

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



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

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



707
708
709
710
711
712
 
# File 'lib/opennebula/virtual_machine.rb', line 707

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



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

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



720
721
722
 
# File 'lib/opennebula/virtual_machine.rb', line 720

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)



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

def state
    self['STATE'].to_i
end

#state_str ⇒ Object

Returns the VM state of the VirtualMachine (string value)



907
908
909
 
# File 'lib/opennebula/virtual_machine.rb', line 907

def state_str
    VM_STATE[state]
end

#status ⇒ Object

Returns the short status string for the VirtualMachine



922
923
924
925
926
927
928
929
930
 
# File 'lib/opennebula/virtual_machine.rb', line 922

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



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

def stop
    action('stop')
end

#suspend ⇒ Object

Saves a running VM



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

def suspend
    action('suspend')
end

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

Shutdowns an already deployed VM



439
440
441
 
# File 'lib/opennebula/virtual_machine.rb', line 439

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



446
447
448
 
# File 'lib/opennebula/virtual_machine.rb', line 446

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

#unresched ⇒ Object

Unsets the re-scheduling flag for the VM



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

def unresched
    action('unresched')
end

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

Replaces the template contents



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

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



821
822
823
 
# File 'lib/opennebula/virtual_machine.rb', line 821

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



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

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



399
400
401
402
403
404
405
 
# File 'lib/opennebula/virtual_machine.rb', line 399

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 



947
948
949
950
951
952
953
954
955
956
957
 
# File 'lib/opennebula/virtual_machine.rb', line 947

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 



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

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