opennebula 4.12.1 → 4.13.80.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c6786aa76e7311b0394bf5cec4c81ff2f340e157
-  data.tar.gz: 087e34af81a845a8c16cc45f260c2ca7bf0a1667
+  metadata.gz: 4c22ee052b29d751b16a22e9be737f1d4009a4ef
+  data.tar.gz: b882b0d31b1096e5287b47ec799f8f6b88fbcecd
 SHA512:
-  metadata.gz: aa41eb3150b17bb655173732982e19aa079ec249ad8f53494e5376cb0c754832ebbe5bf61762119f343fe18fc7888c5cdf2839212c640c557b0951ca44af7aca
-  data.tar.gz: 2ca43c16761cec13390635e9edd3483826515af310cd1324880fb2734f5d149862966a2c65a451359501a1ed5684097c04e65e725b51b0d4112d86da22b22681
+  metadata.gz: 2602b4e09ee0587d0eadd55f581209d3f5946f1bedc826a477fa2bf1b1238000df4801358ecf2042e4e769f7d9c21f01aa4da4799f81b6edca7417037ef9cecc
+  data.tar.gz: a89f6eabb2d2f196b2c82abf5cb7facc4a04ba7edb7b002fe1ed3bd47a90a88bf046e0386022782769d847625d81817eb25711920b764897a0868561bf2c4b47

data/NOTICE

@@ -1,6 +1,6 @@
 OpenNebula Open Source Project
 --------------------------------------------------------------------------------
-Copyright 2002-2014, OpenNebula Project, OpenNebula Systems (formerly C12G Labs)
+Copyright 2002-2015, OpenNebula Project, OpenNebula Systems (formerly C12G Labs)
 --------------------------------------------------------------------------------
 
 You can find  more information about the project, release notes and
@@ -21,11 +21,6 @@ The following people have contributed to the development of the technology
 - Daniel Molina Aranda (dmolina@opennebula.org)
 - Hector Sanjuan Redondo (hsanjuan@opennebula.org)
 
-The new features for service elasticity (oneFlow) introduced in OpenNebula 4.2
-were funded by BlackBerry in the context of the Fund a Feature Program.
-
-OpenNebula Project also acknowledges the contributions of C12G Labs developers.
-
 LICENSE
 
 OpenNebula is licensed under the Apache License, Version 2.0 (the

data/lib/opennebula.rb

@@ -60,5 +60,5 @@ require 'opennebula/system'
 module OpenNebula
 
     # OpenNebula version
-    VERSION = '4.12.1'
+    VERSION = '4.13.80'
 end

data/lib/opennebula/client.rb

@@ -130,7 +130,7 @@ module OpenNebula
                 raise "ONE_AUTH file not present"
             end
 
-            @one_auth.rstrip!
+            @one_auth = @one_auth.rstrip
 
             if endpoint
                 @one_endpoint = endpoint
@@ -144,6 +144,8 @@ module OpenNebula
                 @one_endpoint = "http://localhost:2633/RPC2"
             end
 
+            @one_endpoint= @one_endpoint.rstrip
+
             @async = !options[:sync]
 
             timeout=nil

data/lib/opennebula/cluster.rb

@@ -188,7 +188,7 @@ module OpenNebula
 
         # Returns whether or not the host with 'id' is part of this cluster
         # @param id [Integer|Array] host ID
-        # @return [Boolean] true if found 
+        # @return [Boolean] true if found
         def contains_host?(id)
             contains_resource?('HOSTS/ID', id)
         end
@@ -207,7 +207,7 @@ module OpenNebula
 
         # Returns whether or not the datastore with 'id' is part of this cluster
         # @param id [Integer|Array] datastore ID
-        # @return [Boolean] true if found 
+        # @return [Boolean] true if found
         def contains_datastore?(id)
             contains_resource?('DATASTORES/ID', id)
         end
@@ -226,7 +226,7 @@ module OpenNebula
 
         # Returns whether or not the vnet with 'id' is part of this cluster
         # @param id [Integer|Arrray] vnet ID
-        # @return [Boolean] true if found 
+        # @return [Boolean] true if found
         def contains_vnet?(id)
             contains_resource?('VNETS/ID', id)
         end
@@ -252,7 +252,7 @@ module OpenNebula
 
             id = [id] if id.class != Array
 
-            id.each { |i| 
+            id.each { |i|
                 return false if !id_array.include?(i.to_s)
             }
 

data/lib/opennebula/document.rb

@@ -44,7 +44,9 @@ module OpenNebula
             :chown      => "document.chown",
             :chmod      => "document.chmod",
             :clone      => "document.clone",
-            :rename     => "document.rename"
+            :rename     => "document.rename",
+            :lock       => "document.lock",
+            :unlock     => "document.unlock"
         }
 
         # Creates a Document Object description with just its identifier
@@ -200,6 +202,32 @@ module OpenNebula
             return call(DOCUMENT_METHODS[:rename], @pe_id, name)
         end
 
+        # Locks this object
+        #
+        # @param owner [String] String to identify the application requestiong
+        #   the lock
+        #
+        # @return [Bool, OpenNebula::Error] In case of success, true if the
+        #   lock was granted, and false if the object is already locked.
+        def lock(owner="")
+            return Error.new('ID not defined') if !@pe_id
+
+            rc = @client.call(DOCUMENT_METHODS[:lock], @pe_id, owner)
+
+            return rc
+        end
+
+        # Unlocks this object
+        #
+        # @param owner [String] String to identify the application requestiong
+        #   the unlock
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def unlock(owner="")
+            return call(DOCUMENT_METHODS[:unlock], @pe_id, owner)
+        end
+
         #######################################################################
         # Helpers to get Document information
         #######################################################################

data/lib/opennebula/group.rb

@@ -249,7 +249,7 @@ module OpenNebula
         # Returns an array with the numeric user ids
         def user_ids
             ids = self.retrieve_elements("USERS/ID")
-            
+
             return [] if ids.nil?
 
             return ids.collect! {|x| x.to_i}

data/lib/opennebula/host.rb

@@ -16,6 +16,7 @@
 
 
 require 'opennebula/pool_element'
+require 'base64'
 
 module OpenNebula
     class Host < PoolElement
@@ -187,6 +188,37 @@ module OpenNebula
             return call(HOST_METHODS[:rename], @pe_id, name)
         end
 
+        # Imports a wild VM from the host and puts it in running state
+        #
+        # @param name [String] Name of the VM to import
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def import_wild(name)
+            vms = importable_wilds.select {|vm| vm['VM_NAME'] == name }
+
+            if vms.length == 0
+                return OpenNebula::Error.new("No importable wilds with name " <<
+                    "'#{name}' found.")
+            elsif vms.length > 1
+                return OpenNebula::Error.new("More than one importable wild " <<
+                    "with name '#{name}' found.")
+            end
+
+            wild = vms.first
+
+            template = Base64.decode64(wild['IMPORT_TEMPLATE'])
+
+            xml = OpenNebula::VirtualMachine.build_xml
+            vm = OpenNebula::VirtualMachine.new(xml, @client)
+
+            rc = vm.allocate(template)
+
+            return rc if OpenNebula.is_error?(rc)
+
+            vm.deploy(id, false)
+        end
+
         #######################################################################
         # Helpers to get Host information
         #######################################################################
@@ -206,6 +238,22 @@ module OpenNebula
             SHORT_HOST_STATES[state_str]
         end
 
+        # Returns the <TEMPLATE> element in text form
+        # indent:: _Boolean_ indents the resulting string, default true
+        def template_str(indent=true)
+            template_like_str('TEMPLATE', indent)
+        end
+
+        # Get wild VMs in the host
+        def wilds
+            [self.to_hash['HOST']['TEMPLATE']['VM']].flatten.compact
+        end
+
+        # Get importable wild VMs in the host
+        def importable_wilds
+            wilds.select {|w| Hash === w && w['IMPORT_TEMPLATE'] }
+        end
+
     private
         def set_enabled(enabled)
             return Error.new('ID not defined') if !@pe_id

data/lib/opennebula/host_pool.rb

@@ -45,7 +45,7 @@ module OpenNebula
         end
 
         #######################################################################
-        # XML-RPC Methods for the Host Pool 
+        # XML-RPC Methods for the Host Pool
         #######################################################################
 
         # Retrieves all the Hosts in the pool.

data/lib/opennebula/image.rb

@@ -24,7 +24,6 @@ module OpenNebula
         # Constants and Class Methods
         #######################################################################
 
-
         IMAGE_METHODS = {
             :info        => "image.info",
             :allocate    => "image.allocate",
@@ -36,7 +35,10 @@ module OpenNebula
             :chmod       => "image.chmod",
             :chtype      => "image.chtype",
             :clone       => "image.clone",
-            :rename      => "image.rename"
+            :rename      => "image.rename",
+            :snapshotdelete => "image.snapshotdelete",
+            :snapshotrevert => "image.snapshotrevert",
+            :snapshotflatten=> "image.snapshotflatten"
         }
 
         IMAGE_STATES=%w{INIT READY USED DISABLED LOCKED ERROR CLONE DELETE USED_PERS}
@@ -224,6 +226,32 @@ module OpenNebula
             return call(IMAGE_METHODS[:rename], @pe_id, name)
         end
 
+        # Deletes Image from snapshot
+        #
+        # @param snap_id [Integer] ID of the snapshot to delete
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success or Error
+        def snapshot_delete(snap_id)
+            return call(IMAGE_METHODS[:snapshotdelete], @pe_id, snap_id)
+        end
+
+        # Reverts Image state to a previous snapshot
+        #
+        # @param snap_id [Integer] ID of the snapshot to revert to
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success or Error
+        def snapshot_revert(snap_id)
+            return call(IMAGE_METHODS[:snapshotrevert], @pe_id, snap_id)
+        end
+
+        # Flattens an image snapshot
+        #
+        # @param snap_id [Integer] ID of the snapshot to flatten
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success or Error
+        def snapshot_flatten(snap_id)
+            return call(IMAGE_METHODS[:snapshotflatten], @pe_id, snap_id)
+        end
         #######################################################################
         # Helpers to get Image information
         #######################################################################

data/lib/opennebula/ldap_auth.rb

@@ -180,8 +180,6 @@ class OpenNebula::LdapAuth
         [@user['memberOf']].flatten.each do |group|
             if @mapping[group]
                 groups << @mapping[group]
-            else
-                groups << @options[:mapping_default]
             end
         end
 

data/lib/opennebula/oneflow_client.rb

@@ -31,7 +31,6 @@ module Role
         'stop',
         'suspend',
         'resume',
-        'boot',
         'delete',
         'delete-recreate',
         'reboot',

data/lib/opennebula/server_cipher_auth.rb

@@ -23,9 +23,9 @@ require 'fileutils'
 module OpenNebula; end
 
 # Server authentication class. This method can be used by OpenNebula services
-# to let access authenticated users by other means. It is based on OpenSSL 
+# to let access authenticated users by other means. It is based on OpenSSL
 # symmetric ciphers
-class OpenNebula::ServerCipherAuth 
+class OpenNebula::ServerCipherAuth
     ###########################################################################
     #Constants with paths to relevant files and defaults
     ###########################################################################
@@ -36,7 +36,7 @@ class OpenNebula::ServerCipherAuth
 
     def initialize(srv_user, srv_passwd)
         @srv_user   = srv_user
-        @srv_passwd = srv_passwd 
+        @srv_passwd = srv_passwd
 
         if !srv_passwd.empty?
             @key = Digest::SHA1.hexdigest(@srv_passwd)
@@ -53,7 +53,7 @@ class OpenNebula::ServerCipherAuth
 
     # Creates a ServerCipher for client usage
     def self.new_client(srv_user=nil, srv_passwd=nil)
-        if ( srv_user == nil || srv_passwd == nil ) 
+        if ( srv_user == nil || srv_passwd == nil )
             begin
                 if ENV["ONE_CIPHER_AUTH"] and !ENV["ONE_CIPHER_AUTH"].empty?
                     one_auth = File.read(ENV["ONE_CIPHER_AUTH"])
@@ -64,23 +64,23 @@ class OpenNebula::ServerCipherAuth
                 one_auth.rstrip!
 
                 rc =  one_auth.match(/(.*?):(.*)/)
-                
+
                 if rc.nil?
                     raise "Bad format for one_auth token (<user>:<passwd>)"
-                else 
+                else
                     srv_user   = rc[1]
                     srv_passwd = rc[2]
                 end
             rescue => e
                 raise e.message
             end
-        end 
+        end
 
         self.new(srv_user, srv_passwd)
     end
 
     # Generates a login token in the form:
-    #   - server_user:target_user:time_expires 
+    #   - server_user:target_user:time_expires
     # The token is then encrypted with the contents of one_auth
     def login_token(expire, target_user=nil)
         target_user ||= @srv_user
@@ -110,11 +110,11 @@ class OpenNebula::ServerCipherAuth
     def authenticate(srv_user,srv_pass, signed_text)
         begin
             @key = srv_pass
-            
+
             s_user, t_user, expires = decrypt(signed_text).split(':')
 
             return "User name missmatch" if s_user != srv_user
-             
+
             return "login token expired" if Time.now.to_i >= expires.to_i
 
             return true
@@ -125,20 +125,20 @@ class OpenNebula::ServerCipherAuth
 
     private
 
-    def encrypt(data) 
+    def encrypt(data)
         @cipher.encrypt
         @cipher.key = @key
-        
+
         rc = @cipher.update(data)
         rc << @cipher.final
 
         return rc
     end
 
-    def decrypt(data) 
+    def decrypt(data)
         @cipher.decrypt
         @cipher.key = @key
-        
+
         rc = @cipher.update(Base64::decode64(data))
         rc << @cipher.final
 

data/lib/opennebula/vdc.rb

@@ -98,7 +98,7 @@ module OpenNebula
         #   otherwise
         def update(new_template=nil, append=false)
             super(VDC_METHODS[:update], new_template, append ? 1 : 0)
-        end       
+        end
 
         # Deletes the Vdc
         # @return [nil, OpenNebula::Error] nil in case of success, Error

data/lib/opennebula/virtual_machine.rb

@@ -24,38 +24,96 @@ module OpenNebula
         #######################################################################
 
         VM_METHODS = {
-            :info       => "vm.info",
-            :allocate   => "vm.allocate",
-            :action     => "vm.action",
-            :migrate    => "vm.migrate",
-            :deploy     => "vm.deploy",
-            :savedisk   => "vm.savedisk",
-            :chown      => "vm.chown",
-            :chmod      => "vm.chmod",
-            :monitoring => "vm.monitoring",
-            :attach     => "vm.attach",
-            :detach     => "vm.detach",
-            :rename     => "vm.rename",
-            :update     => "vm.update",
-            :resize     => "vm.resize",
+            :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"
+            :attachnic      => "vm.attachnic",
+            :detachnic      => "vm.detachnic",
+            :recover        => "vm.recover",
+            :disksaveas     => "vm.disksaveas",
+            :disksnapshotcreate => "vm.disksnapshotcreate",
+            :disksnapshotrevert => "vm.disksnapshotrevert",
+            :disksnapshotdelete => "vm.disksnapshotdelete"
         }
 
         VM_STATE=%w{INIT PENDING HOLD ACTIVE STOPPED SUSPENDED DONE FAILED
             POWEROFF UNDEPLOYED}
 
-        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}
+        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
+        }
 
         SHORT_VM_STATES={
             "INIT"      => "init",
@@ -102,7 +160,34 @@ module OpenNebula
             "SHUTDOWN_UNDEPLOY" => "shut",
             "EPILOG_UNDEPLOY"   => "epil",
             "PROLOG_UNDEPLOY"   => "prol",
-            "BOOT_UNDEPLOY"     => "boot"
+            "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_REVERT" => "snap",
+            "DISK_SNAPSHOT_DELETE" => "snap"
         }
 
         MIGRATE_REASON=%w{NONE ERROR USER}
@@ -116,7 +201,15 @@ module OpenNebula
         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}
+            poweroff-hard disk-attach disk-detach nic-attach nic-detach
+            snap-create snap-delete}
+
+        EXTERNAL_IP_ATTRS = [
+            'GUEST_IP',
+            'AWS_IP_ADDRESS',
+            'AZ_IPADDRESS',
+            'SL_PRIMARYIPADDRESS'
+        ]
 
         # Creates a VirtualMachine description with just its identifier
         # this method should be used to create plain VirtualMachine objects.
@@ -339,13 +432,6 @@ module OpenNebula
             delete(recreate)
         end
 
-        # Forces a re-deployment of a VM in UNKNOWN or BOOT state
-        def boot
-            action('boot')
-        end
-
-        alias_method :restart, :boot
-
         # @deprecated use {#delete} instead
         def resubmit
             action('delete-recreate')
@@ -371,12 +457,14 @@ module OpenNebula
         # @param enforce [true|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
+        # @param ds_id [Integer] The System Datastore where to migrate the VM.
+        #   To use the current one, set it to -1
         #
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
-        def migrate(host_id, live=false, enforce=false)
+        def migrate(host_id, live=false, enforce=false, ds_id=-1)
             call(VM_METHODS[:migrate], @pe_id, host_id.to_i, live==true,
-                enforce)
+                enforce, ds_id.to_i)
         end
 
         # @deprecated use {#migrate} instead
@@ -384,40 +472,30 @@ module OpenNebula
             migrate(host_id, true, enforce)
         end
 
-        # Set the specified vm's disk to be saved in a new image
-        # when the VirtualMachine shutdowns
+        # Set the specified vm's disk to be saved as a new image
         #
         # @param disk_id [Integer] ID of the disk to be saved
         # @param image_name [String] Name for the new image where the
         #   disk will be saved
         # @param image_type [String] Type of the new image. Set to empty string
         #   to use the default type
-        # @param hot [true|false] True to save the disk immediately, false will
-        #   perform the operation when the VM shuts down
-        # @param do_template [true|false] True to clone also the VM originating
-        # template and replace the disk with the saved image
+        # @param snap_id [Integer] ID of the snapshot to save, -1 to use the
+        # current disk image state
         #
         # @return [Integer, OpenNebula::Error] the new Image ID in case of
         #   success, error otherwise
-        def disk_snapshot(disk_id, image_name, image_type="", hot=false,
-            do_template=false)
+        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[:savedisk],
+            rc = @client.call(VM_METHODS[:disksaveas],
                               @pe_id,
                               disk_id,
                               image_name,
                               image_type,
-                              hot,
-                              do_template)
+                              snap_id)
             return rc
         end
 
-        # @deprecated use {#disk_snapshot}
-        def save_as(disk_id, image_name, image_type="", hot=false)
-            return disk_snapshot(disk_id, image_name, image_type, hot)
-        end
-
         # Resize the VM
         #
         # @param capacity_template [String] Template containing the new capacity
@@ -469,19 +547,15 @@ module OpenNebula
         #   the requested xpath expressions, and an Array of 'timestamp, value'.
         #
         # @example
-        #   vm.monitoring( ['CPU', 'NET_TX', 'TEMPLATE/CUSTOM_PROBE'] )
-        #
-        #   { "NET_TX" =>
-        #       [["1337264510", "210"],
-        #        ["1337264553", "220"],
-        #        ["1337264584", "230"]],
-        #     "TEMPLATE/CUSTOM_PROBE" =>
-        #       [],
-        #     "CPU" =>
-        #       [["1337264510", "0"],
-        #        ["1337264553", "0"],
-        #        ["1337264584", "0"]]
+        #   vm.monitoring( ['MONITORING/CPU', 'MONITORING/NETTX'] )
+        #
+        #   {
+        #    "MONITORING/CPU"=>[["1435085098", "47"], ["1435085253", "5"],
+        #      ["1435085410", "48"], ["1435085566", "3"], ["1435088136", "2"]],
+        #    "MONITORING/NETTX"=>[["1435085098", "0"], ["1435085253", "50"],
+        #      ["1435085410", "50"], ["1435085566", "50"], ["1435085723", "50"]]
         #   }
+        #
         def monitoring(xpath_expressions)
             return super(VM_METHODS[:monitoring], 'VM',
                 'LAST_POLL', xpath_expressions)
@@ -539,9 +613,42 @@ module OpenNebula
             return call(VM_METHODS[:snapshotdelete], @pe_id, snap_id)
         end
 
+        # Takes a new snapshot of a disk
+        #
+        # @param disk_id [Integer] Id of the disk
+        # @param name [String] description for the snapshot
+        #
+        # @return [Integer, OpenNebula::Error] The new snapshot ID or error
+        def disk_snapshot_create(disk_id, name)
+          return call(VM_METHODS[:disksnapshotcreate], @pe_id, disk_id, name)
+        end
+
+        # Reverts disk state to a previously taken snapshot
+        #
+        # @param disk_id [Integer] Id of the disk
+        # @param snap_id [Integer] Id of the snapshot
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def disk_snapshot_revert(disk_id, snap_id)
+          return call(VM_METHODS[:disksnapshotrevert], @pe_id, disk_id, snap_id)
+        end
+
+        # Deletes a disk snapshot
+        #
+        # @param disk_id [Integer] Id of the disk
+        # @param snap_id [Integer] Id of the snapshot
+        #
+        # @return [nil, OpenNebula::Error] nil in case of success, Error
+        #   otherwise
+        def disk_snapshot_delete(disk_id, snap_id)
+          return call(VM_METHODS[:disksnapshotdelete], @pe_id, disk_id, snap_id)
+        end
+
         # Recovers an ACTIVE VM
         #
-        # @param result [Boolean] Recover with success (true) or failure (false)
+        # @param result [Integer] Recover with failure (0), success (1) or
+        # retry (2)
         # @param result [info] Additional information needed to recover the VM
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
@@ -595,6 +702,124 @@ module OpenNebula
             self['DEPLOY_ID']
         end
 
+        # Clones the VM's source Template, replacing the disks with live snapshots
+        # of the current disks. The VM capacity and NICs are also preserved
+        #
+        # @param name [String] Name for the new Template
+        #
+        # @return [Integer, OpenNebula::Error] the new Template ID in case of
+        #   success, error otherwise
+        def save_as_template(name)
+            rc = info()
+            return rc if OpenNebula.is_error?(rc)
+
+            tid = self['TEMPLATE/TEMPLATE_ID']
+            if tid.nil? || tid.empty?
+                return Error.new('VM has no template to be saved')
+            end
+
+            if state_str() != "POWEROFF"
+                return Error.new("VM state must be POWEROFF, "<<
+                    "current state is #{state_str()}, #{lcm_state_str()}")
+            end
+
+            # Clone the source template
+            new_tid = OpenNebula::Template.new_with_id(tid, @client).clone(name)
+            return new_tid if OpenNebula.is_error?(new_tid)
+
+            # Replace the original template's capacity with the actual VM values
+            replace = ""
+
+            cpu = self['TEMPLATE/CPU']
+            if !cpu.nil? && !cpu.empty?
+                replace << "CPU = #{cpu}\n"
+            end
+
+            vcpu = self['TEMPLATE/VCPU']
+            if !vcpu.nil? && !vcpu.empty?
+                replace << "VCPU = #{vcpu}\n"
+            end
+
+            mem = self['TEMPLATE/MEMORY']
+            if !mem.nil? && !mem.empty?
+                replace << "MEMORY = #{mem}\n"
+            end
+
+            self.each('TEMPLATE/DISK') do |disk|
+                # While the previous snapshot is still in progress, we wait
+                # indefinitely
+                rc = info()
+                return rc if OpenNebula.is_error?(rc)
+
+                steps = 0
+                while lcm_state_str() == "HOTPLUG_SAVEAS_POWEROFF"
+                    if steps < 30
+                        sleep 1
+                    else
+                        sleep 15
+                    end
+
+                    rc = info()
+                    return rc if OpenNebula.is_error?(rc)
+
+                    steps += 1
+                end
+
+                # If the VM is not busy with a previous disk snapshot, we wait
+                # but this time with a timeout
+                rc = wait_state("POWEROFF")
+                return rc if OpenNebula.is_error?(rc)
+
+                disk_id = disk["DISK_ID"]
+                if disk_id.nil? || disk_id.empty?
+                    return Error.new('The DISK_ID is missing from the VM template')
+                end
+
+                image_id = disk["IMAGE_ID"]
+
+                if !image_id.nil? && !image_id.empty?
+                    rc = disk_saveas(disk_id.to_i,"#{name}-disk-#{disk_id}","",-1)
+
+                    return rc if OpenNebula.is_error?(rc)
+
+                    replace << "DISK = [ IMAGE_ID = #{rc} ]\n"
+                else
+                    # Volatile disks cannot be saved, so the definition is copied
+                    replace << self.template_like_str(
+                        "TEMPLATE", true, "DISK[DISK_ID=#{disk_id}]") << "\n"
+                end
+            end
+
+            self.each('TEMPLATE/NIC') do |nic|
+                nic_id = nic["NIC_ID"]
+                if nic_id.nil? || nic_id.empty?
+                    return Error.new('The NIC_ID is missing from the VM template')
+                end
+
+                net_id = nic["NETWORK_ID"]
+
+                if !net_id.nil? && !net_id.empty?
+                    replace << "NIC = [ NETWORK_ID = #{net_id} ]\n"
+                else
+                    # This NIC does not use a Virtual Network
+                    replace << self.template_like_str(
+                        "TEMPLATE", true, "NIC[NIC_ID=#{nic_id}]") << "\n"
+                end
+            end
+
+            # Required by the Sunstone Cloud View
+            replace << "SAVED_TEMPLATE_ID = #{tid}\n"
+
+            new_tmpl = OpenNebula::Template.new_with_id(new_tid, @client)
+
+            rc = new_tmpl.update(replace, true)
+            return rc if OpenNebula.is_error?(rc)
+
+            return new_tid
+
+            # TODO: rollback in case of error
+        end
+
     private
         def action(name)
             return Error.new('ID not defined') if !@pe_id
@@ -604,5 +829,49 @@ module OpenNebula
 
             return rc
         end
+
+        def wait_state(state, timeout=10)
+            vm_state = ""
+            lcm_state = ""
+
+            timeout.times do
+                rc = info()
+                return rc if OpenNebula.is_error?(rc)
+
+                vm_state = state_str()
+                lcm_state = lcm_state_str()
+
+                if vm_state == state
+                    return true
+                end
+
+                sleep 1
+            end
+
+            return Error.new("Timeout expired for state #{state}. "<<
+                "VM is in state #{vm_state}, #{lcm_state}")
+        end
+
+        def wait_lcm_state(state, timeout=10)
+            vm_state = ""
+            lcm_state = ""
+
+            timeout.times do
+                rc = info()
+                return rc if OpenNebula.is_error?(rc)
+
+                vm_state = state_str()
+                lcm_state = lcm_state_str()
+
+                if lcm_state == state
+                    return true
+                end
+
+                sleep 1
+            end
+
+            return Error.new("Timeout expired for state #{state}. "<<
+                "VM is in state #{vm_state}, #{lcm_state}")
+        end
     end
 end

data/lib/opennebula/virtual_machine_pool.rb

@@ -132,23 +132,24 @@ module OpenNebula
         #   and an Array of 'timestamp, value'.
         #
         # @example
-        #   vm_pool.monitoring( ['CPU', 'NET_TX', 'TEMPLATE/CUSTOM_PROBE'] )
+        #   vm_pool.monitoring( ['MONITORING/CPU', 'MONITORING/NETTX'] )
         #
-        #   {"1"=>
-        #    {"CPU"=>
-        #      [["1337608271", "0"], ["1337608301", "0"], ["1337608331", "0"]],
-        #     "NET_TX"=>
-        #      [["1337608271", "510"], ["1337608301", "510"], ["1337608331", "520"]],
-        #     "TEMPLATE/CUSTOM_PROBE"=>
-        #      []},
+        #   {"3"=>
+        #     {
+        #     "MONITORING/CPU"=>[["1435085098", "47"], ["1435085253", "5"],
+        #       ["1435085410", "48"], ["1435085566", "3"], ["1435088136", "2"]],
+        #     "MONITORING/NETTX"=>[["1435085098", "0"], ["1435085253", "50"],
+        #     ["1435085410", "50"], ["1435085566", "50"], ["1435085723", "50"]]
+        #     },
+        #    "43" =>
+        #     {
+        #     "MONITORING/CPU"=>[["1435085098", "47"], ["1435085253", "5"],
+        #       ["1435085410", "48"], ["1435085566", "3"], ["1435088136", "2"]],
+        #     "MONITORING/NETTX"=>[["1435085098", "0"], ["1435085253", "50"],
+        #     ["1435085410", "50"], ["1435085566", "50"], ["1435085723", "50"]]
+        #     }
+        #   }
         #
-        #   "0"=>
-        #    {"CPU"=>
-        #      [["1337608271", "0"], ["1337608301", "0"], ["1337608331", "0"]],
-        #     "NET_TX"=>
-        #      [["1337608271", "510"], ["1337608301", "510"], ["1337608331", "520"]],
-        #     "TEMPLATE/CUSTOM_PROBE"=>
-        #      []}}
         def monitoring(xpath_expressions, filter_flag=INFO_ALL)
             return super(VM_POOL_METHODS[:monitoring],
                 'VM', 'LAST_POLL', xpath_expressions, filter_flag)

data/lib/opennebula/xml_element.rb

@@ -139,7 +139,7 @@ module OpenNebula
             }
         end
 
-        # Gets an array of text from elemenets extracted
+        # Gets an array of text from elements extracted
         # using  the XPATH  expression passed as filter
         def retrieve_elements(filter)
             elements_array = Array.new
@@ -162,7 +162,7 @@ module OpenNebula
 
         end
 
-        # Gets an attribute from an elemenT
+        # Gets an attribute from an element
         # key:: _String_ xpath for the element
         # name:: _String_ name of the attribute
         def attr(key,name)

data/lib/opennebula/zone.rb

@@ -85,7 +85,7 @@ module OpenNebula
         #   otherwise
         def update(new_template=nil, append=false)
             super(ZONE_METHODS[:update], new_template, append ? 1 : 0)
-        end       
+        end
 
         # Deletes the Zone
         # @return [nil, OpenNebula::Error] nil in case of success, Error

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opennebula
 version: !ruby/object:Gem::Version
-  version: 4.12.1
+  version: 4.13.80.beta1
 platform: ruby
 authors:
 - OpenNebula
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-08 00:00:00.000000000 Z
+date: 2015-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -121,9 +121,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.5