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



280
281
282
283
284
 
# File 'lib/opennebula/virtual_machine.rb', line 280

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:

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



265
266
267
268
269
270
271
272
273
 
# File 'lib/opennebula/virtual_machine.rb', line 265

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 



275
276
277
 
# File 'lib/opennebula/virtual_machine.rb', line 275

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:



306
307
308
 
# File 'lib/opennebula/virtual_machine.rb', line 306

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:



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

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:



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

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



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

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

#delete(recreate = false) ⇒ Object

Deletes a VM from the pool



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

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:



358
359
360
361
362
363
364
365
366
367
368
369
370
371
 
# File 'lib/opennebula/virtual_machine.rb', line 358

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)



769
770
771
 
# File 'lib/opennebula/virtual_machine.rb', line 769

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:



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

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:



436
437
438
 
# File 'lib/opennebula/virtual_machine.rb', line 436

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:



689
690
691
 
# File 'lib/opennebula/virtual_machine.rb', line 689

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



511
512
513
514
515
516
517
518
519
520
521
 
# File 'lib/opennebula/virtual_machine.rb', line 511

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:



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

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:



667
668
669
 
# File 'lib/opennebula/virtual_machine.rb', line 667

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:



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

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:



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

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



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

def gid
    self['GID'].to_i
end

#hold ⇒ Object

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



396
397
398
 
# File 'lib/opennebula/virtual_machine.rb', line 396

def hold
    action('hold')
end

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

Retrieves the information of the given VirtualMachine.



291
292
293
 
# File 'lib/opennebula/virtual_machine.rb', line 291

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

#lcm_state ⇒ Object

Returns the LCM state of the VirtualMachine (numeric value)



742
743
744
 
# File 'lib/opennebula/virtual_machine.rb', line 742

def lcm_state
    self['LCM_STATE'].to_i
end

#lcm_state_str ⇒ Object

Returns the LCM state of the VirtualMachine (string value)



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

def lcm_state_str
    LCM_STATE[lcm_state]
end

#live_migrate(host_id, enforce = false) ⇒ Object

Deprecated.

use #migrate instead



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

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:



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

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



583
584
585
 
# File 'lib/opennebula/virtual_machine.rb', line 583

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



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

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:



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

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:



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

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

#poweroff(hard = false) ⇒ Object

Powers off a running VM



386
387
388
 
# File 'lib/opennebula/virtual_machine.rb', line 386

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

#reboot(hard = false) ⇒ Object

Reboots an already deployed VM



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

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:



700
701
702
 
# File 'lib/opennebula/virtual_machine.rb', line 700

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

#release ⇒ Object

Releases a VM from hold state



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

def release
    action('release')
end

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

Renames this VM

Parameters:

  • name (String) —

    New name for the VM.

Returns:



602
603
604
 
# File 'lib/opennebula/virtual_machine.rb', line 602

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

#replace(opts = {}) ⇒ Object 



342
343
344
 
# File 'lib/opennebula/virtual_machine.rb', line 342

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

#resched ⇒ Object

Sets the re-scheduling flag for the VM



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

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:



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

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



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

def resume
    action('resume')
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



612
613
614
615
616
617
 
# File 'lib/opennebula/virtual_machine.rb', line 612

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:



635
636
637
 
# File 'lib/opennebula/virtual_machine.rb', line 635

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:



625
626
627
 
# File 'lib/opennebula/virtual_machine.rb', line 625

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)



732
733
734
 
# File 'lib/opennebula/virtual_machine.rb', line 732

def state
    self['STATE'].to_i
end

#state_str ⇒ Object

Returns the VM state of the VirtualMachine (string value)



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

def state_str
    VM_STATE[state]
end

#status ⇒ Object

Returns the short status string for the VirtualMachine



752
753
754
755
756
757
758
759
760
 
# File 'lib/opennebula/virtual_machine.rb', line 752

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



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

def stop
    action('stop')
end

#suspend ⇒ Object

Saves a running VM



411
412
413
 
# File 'lib/opennebula/virtual_machine.rb', line 411

def suspend
    action('suspend')
end

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

Shutdowns an already deployed VM



374
375
376
 
# File 'lib/opennebula/virtual_machine.rb', line 374

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



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

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

#unresched ⇒ Object

Unsets the re-scheduling flag for the VM



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

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:



318
319
320
 
# File 'lib/opennebula/virtual_machine.rb', line 318

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

#updateconf(new_conf) ⇒ nil, OpenNebula::Error

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

states
@param 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/{TYPE, BUS}; RAW/{TYPE, DATA, DATA_VMX},
OS/{BOOT, BOOTLOADER, ARCH, MACHINE, KERNEL, INITRD},
FEATURES/{ACPI, APIC, PAE, LOCALTIME, HYPERV, GUEST_AGENT},
and GRAPHICS/{TYPE, LISTEN, PASSWD, KEYMAP}

Returns:



723
724
725
 
# File 'lib/opennebula/virtual_machine.rb', line 723

def updateconf(new_conf)
    return call(VM_METHODS[:updateconf], @pe_id, new_conf)
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



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

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



334
335
336
337
338
339
340
 
# File 'lib/opennebula/virtual_machine.rb', line 334

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 



773
774
775
776
777
778
779
780
781
782
783
 
# File 'lib/opennebula/virtual_machine.rb', line 773

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 



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

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