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"
}
VM_STATE = 
%w{INIT PENDING HOLD ACTIVE STOPPED SUSPENDED DONE FAILED
POWEROFF UNDEPLOYED CLONING CLONING_FAILURE}
LCM_STATE = 
%w{
    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
}
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"
}
HISTORY_ACTION = 
%w{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
}
EXTERNAL_IP_ATTRS = 
[
    'GUEST_IP',
    'AWS_IP_ADDRESS',
    'AWS_PUBLIC_IP_ADDRESS',
    'AWS_PRIVATE_IP_ADDRESS',
    'AZ_IPADDRESS',
    'SL_PRIMARYIPADDRESS'
]

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from PoolElement

#id, #name, 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



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

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)



268
269
270
271
272
273
274
275
276
 
# File 'lib/opennebula/virtual_machine.rb', line 268

def VirtualMachine.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 



278
279
280
 
# File 'lib/opennebula/virtual_machine.rb', line 278

def VirtualMachine.get_history_action(action)
    return 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:



309
310
311
 
# File 'lib/opennebula/virtual_machine.rb', line 309

def allocate(description, hold=false)
    super(VM_METHODS[:allocate], description, hold)
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:



563
564
565
566
567
 
# File 'lib/opennebula/virtual_machine.rb', line 563

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:



554
555
556
 
# File 'lib/opennebula/virtual_machine.rb', line 554

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



545
546
547
 
# File 'lib/opennebula/virtual_machine.rb', line 545

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

#delete(recreate = false) ⇒ Object

Deletes a VM from the pool



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

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:



361
362
363
364
365
366
367
368
369
370
371
372
373
374
 
# File 'lib/opennebula/virtual_machine.rb', line 361

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

    self.info

    return 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)



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

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:



428
429
430
 
# File 'lib/opennebula/virtual_machine.rb', line 428

def disk_attach(disk_template)
    return 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:



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

def disk_detach(disk_id)
    return 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:



692
693
694
 
# File 'lib/opennebula/virtual_machine.rb', line 692

def disk_resize(disk_id, size)
    return 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



514
515
516
517
518
519
520
521
522
523
524
 
# File 'lib/opennebula/virtual_machine.rb', line 514

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

    rc = @client.call(VM_METHODS[:disksaveas],
                      @pe_id,
                      disk_id,
                      image_name,
                      image_type,
                      snap_id)
    return rc
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:



648
649
650
 
# File 'lib/opennebula/virtual_machine.rb', line 648

def disk_snapshot_create(disk_id, name)
  return 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:



670
671
672
 
# File 'lib/opennebula/virtual_machine.rb', line 670

def disk_snapshot_delete(disk_id, snap_id)
  return 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:



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

def disk_snapshot_rename(disk_id, snap_id, new_name)
    return 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:



659
660
661
 
# File 'lib/opennebula/virtual_machine.rb', line 659

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

#gid ⇒ Object

Returns the group identifier

return

Integer the element’s group ID



798
799
800
 
# File 'lib/opennebula/virtual_machine.rb', line 798

def gid
    self['GID'].to_i
end

#hold ⇒ Object

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



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

def hold
    action('hold')
end

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

Retrieves the information of the given VirtualMachine.



294
295
296
 
# File 'lib/opennebula/virtual_machine.rb', line 294

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

#lcm_state ⇒ Object

Returns the LCM state of the VirtualMachine (numeric value)



776
777
778
 
# File 'lib/opennebula/virtual_machine.rb', line 776

def lcm_state
    self['LCM_STATE'].to_i
end

#lcm_state_str ⇒ Object

Returns the LCM state of the VirtualMachine (string value)



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

def lcm_state_str
    LCM_STATE[lcm_state]
end

#live_migrate(host_id, enforce = false) ⇒ Object

Deprecated.

use #migrate instead



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

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:



492
493
494
495
 
# File 'lib/opennebula/virtual_machine.rb', line 492

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



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

def monitoring(xpath_expressions)
    return 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



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

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

    return @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:



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

def nic_attach(nic_template)
    return 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:



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

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

#poweroff(hard = false) ⇒ Object

Powers off a running VM



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

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

#reboot(hard = false) ⇒ Object

Reboots an already deployed VM



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

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:



703
704
705
 
# File 'lib/opennebula/virtual_machine.rb', line 703

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

#release ⇒ Object

Releases a VM from hold state



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

def release
    action('release')
end

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

Renames this VM

Parameters:

  • name (String) —

    New name for the VM.

Returns:



605
606
607
 
# File 'lib/opennebula/virtual_machine.rb', line 605

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

#replace(opts = {}) ⇒ Object 



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

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

#resched ⇒ Object

Sets the re-scheduling flag for the VM



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

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:



537
538
539
 
# File 'lib/opennebula/virtual_machine.rb', line 537

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

#resume ⇒ Object

Resumes the execution of a saved VM



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

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:



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

def sched_action_add(sched_template)
    return 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:



746
747
748
 
# File 'lib/opennebula/virtual_machine.rb', line 746

def sched_action_delete(sched_id)
    return 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:



756
757
758
759
 
# File 'lib/opennebula/virtual_machine.rb', line 756

def sched_action_update(sched_id, sched_template)
    return call(VM_METHODS[:schedupdate], @pe_id, sched_id.to_i,
        sched_template)
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



615
616
617
618
619
620
 
# File 'lib/opennebula/virtual_machine.rb', line 615

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

    name ||= ""
    return @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:



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

def snapshot_delete(snap_id)
    return 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:



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

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

#state ⇒ Object

Returns the VM state of the VirtualMachine (numeric value)



766
767
768
 
# File 'lib/opennebula/virtual_machine.rb', line 766

def state
    self['STATE'].to_i
end

#state_str ⇒ Object

Returns the VM state of the VirtualMachine (string value)



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

def state_str
    VM_STATE[state]
end

#status ⇒ Object

Returns the short status string for the VirtualMachine



786
787
788
789
790
791
792
793
794
 
# File 'lib/opennebula/virtual_machine.rb', line 786

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



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

def stop
    action('stop')
end

#suspend ⇒ Object

Saves a running VM



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

def suspend
    action('suspend')
end

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

Shutdowns an already deployed VM



377
378
379
 
# File 'lib/opennebula/virtual_machine.rb', line 377

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



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

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

#unresched ⇒ Object

Unsets the re-scheduling flag for the VM



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

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:



321
322
323
 
# File 'lib/opennebula/virtual_machine.rb', line 321

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:



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

def updateconf(new_conf, append = false)
    return 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



330
331
332
 
# File 'lib/opennebula/virtual_machine.rb', line 330

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



337
338
339
340
341
342
343
 
# File 'lib/opennebula/virtual_machine.rb', line 337

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 



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

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 



819
820
821
822
823
824
825
826
827
 
# File 'lib/opennebula/virtual_machine.rb', line 819

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