opennebula 5.13.80.pre → 6.0.0.2

data/lib/nsx_rule.rb

@@ -33,14 +33,27 @@ module NSXDriver
             unless defined?(GEMS_LOCATION)
     end
 
-    if File.directory?(GEMS_LOCATION)
-        real_gems_path = File.realpath(GEMS_LOCATION)
-        if !defined?(Gem) || Gem.path != [real_gems_path]
-            $LOAD_PATH.reject! {|l| l =~ /vendor_ruby/ }
+# rubocop: disable all
+# %%RUBYGEMS_SETUP_BEGIN%%
+if File.directory?(GEMS_LOCATION)
+    real_gems_path = File.realpath(GEMS_LOCATION)
+    if !defined?(Gem) || Gem.path != [real_gems_path]
+        $LOAD_PATH.reject! {|l| l =~ /vendor_ruby/ }
+
+        # Suppress warnings from Rubygems
+        # https://github.com/OpenNebula/one/issues/5379
+        begin
+            verb = $VERBOSE
+            $VERBOSE = nil
             require 'rubygems'
             Gem.use_paths(real_gems_path)
+        ensure
+            $VERBOSE = verb
         end
     end
+end
+# %%RUBYGEMS_SETUP_END%%
+# rubocop: enable all
 
     $LOAD_PATH << RUBY_LIB_LOCATION
 

data/lib/nsxt_client.rb

@@ -29,14 +29,27 @@ module NSXDriver
             unless defined?(GEMS_LOCATION)
     end
 
-    if File.directory?(GEMS_LOCATION)
-        real_gems_path = File.realpath(GEMS_LOCATION)
-        if !defined?(Gem) || Gem.path != [real_gems_path]
-            $LOAD_PATH.reject! {|l| l =~ /vendor_ruby/ }
+# rubocop: disable all
+# %%RUBYGEMS_SETUP_BEGIN%%
+if File.directory?(GEMS_LOCATION)
+    real_gems_path = File.realpath(GEMS_LOCATION)
+    if !defined?(Gem) || Gem.path != [real_gems_path]
+        $LOAD_PATH.reject! {|l| l =~ /vendor_ruby/ }
+
+        # Suppress warnings from Rubygems
+        # https://github.com/OpenNebula/one/issues/5379
+        begin
+            verb = $VERBOSE
+            $VERBOSE = nil
             require 'rubygems'
             Gem.use_paths(real_gems_path)
+        ensure
+            $VERBOSE = verb
         end
     end
+end
+# %%RUBYGEMS_SETUP_END%%
+# rubocop: enable all
 
     $LOAD_PATH << RUBY_LIB_LOCATION
 

data/lib/nsxv_client.rb

@@ -29,14 +29,27 @@ module NSXDriver
             unless defined?(GEMS_LOCATION)
     end
 
-    if File.directory?(GEMS_LOCATION)
-        real_gems_path = File.realpath(GEMS_LOCATION)
-        if !defined?(Gem) || Gem.path != [real_gems_path]
-            $LOAD_PATH.reject! {|l| l =~ /vendor_ruby/ }
+# rubocop: disable all
+# %%RUBYGEMS_SETUP_BEGIN%%
+if File.directory?(GEMS_LOCATION)
+    real_gems_path = File.realpath(GEMS_LOCATION)
+    if !defined?(Gem) || Gem.path != [real_gems_path]
+        $LOAD_PATH.reject! {|l| l =~ /vendor_ruby/ }
+
+        # Suppress warnings from Rubygems
+        # https://github.com/OpenNebula/one/issues/5379
+        begin
+            verb = $VERBOSE
+            $VERBOSE = nil
             require 'rubygems'
             Gem.use_paths(real_gems_path)
+        ensure
+            $VERBOSE = verb
         end
     end
+end
+# %%RUBYGEMS_SETUP_END%%
+# rubocop: enable all
 
     $LOAD_PATH << RUBY_LIB_LOCATION
 

data/lib/opennebula.rb

@@ -77,5 +77,5 @@ require 'opennebula/flow'
 module OpenNebula
 
     # OpenNebula version
-    VERSION = '5.13.80'
+    VERSION = '6.0.0.2'
 end

data/lib/opennebula/client.rb

@@ -88,7 +88,7 @@ module OpenNebula
         NO_ONE_AUTH_ERROR = "ONE_AUTH file not present"
 
         attr_accessor :one_auth
-        attr_reader   :one_endpoint
+        attr_reader   :one_endpoint, :one_zmq
 
         begin
             require 'xmlparser'
@@ -152,6 +152,14 @@ module OpenNebula
 
             @async = !options[:sync]
 
+            if options[:subscriber_endpoint]
+                @one_zmq = options[:subscriber_endpoint]
+            elsif ENV["ONE_ZMQ"]
+                @one_zmq = ENV["ONE_ZMQ"]
+            else
+                @one_zmq = 'tcp://localhost:2101'
+            end
+
             timeout=nil
             if options[:timeout]
                 timeout = options[:timeout]

data/lib/opennebula/flow/service_template.rb

@@ -357,7 +357,15 @@ module OpenNebula
 
                 break rc if OpenNebula.is_error?(rc)
 
-                rc = template.clone("#{template.name}-#{name}", recursive)
+                # The maximum size is 128, so crop the template name if it
+                # exceeds the limit
+                new_name = "#{template.name}-#{name}"
+
+                if new_name.size > 119
+                    new_name = "#{template.name[0..(119 - name.size)]}-#{name}"
+                end
+
+                rc = template.clone(new_name, recursive)
 
                 break rc if OpenNebula.is_error?(rc)
 
@@ -384,6 +392,9 @@ module OpenNebula
                 return rc
             end
 
+            # add registration time, as the template is new
+            body['registration_time'] = Integer(Time.now)
+
             # update the template with the new body
             doc.update(body.to_json)
 
@@ -391,6 +402,31 @@ module OpenNebula
             new_id
         end
 
+        # Clones a service template
+        #
+        # @param name [Stirng] New name
+        #
+        # @return [Integer] New template ID
+        def clone(name)
+            new_id = super
+
+            doc = OpenNebula::ServiceTemplate.new_with_id(new_id, @client)
+            rc  = doc.info
+
+            return rc if OpenNebula.is_error?(rc)
+
+            body = JSON.parse(doc["TEMPLATE/#{TEMPLATE_TAG}"])
+
+            # add registration time, as the template is new
+            body['registration_time'] = Integer(Time.now)
+
+            # update the template with the new body
+            DocumentJSON.instance_method(:update).bind(doc).call(body.to_json)
+
+            # return the new document ID
+            new_id
+        end
+
         # Replaces the raw template contents
         #
         # @param template [String] New template contents, in the form KEY = VAL

data/lib/opennebula/image.rb

@@ -308,6 +308,8 @@ module OpenNebula
         end
 
         def wait_state(state, timeout=120)
+            require 'opennebula/wait_ext'
+
             extend OpenNebula::WaitExt
 
             rc = wait(state, timeout)

data/lib/opennebula/marketplaceapp_ext.rb

@@ -155,6 +155,10 @@ module OpenNebula::MarketPlaceAppExt
                 is_vcenter = !OpenNebula.is_error?(rc) &&
                              (ds['TEMPLATE/DRIVER'] == 'vcenter')
 
+                if is_vcenter && options[:template].nil?
+                    options = update_options_with_template(options)
+                end
+
                 #---------------------------------------------------------------
                 # Allocate the image in OpenNebula
                 #---------------------------------------------------------------
@@ -181,15 +185,17 @@ module OpenNebula::MarketPlaceAppExt
                 #---------------------------------------------------------------
                 # Created an associated VMTemplate if needed
                 #---------------------------------------------------------------
-                if self['TEMPLATE/VMTEMPLATE64'].nil? || options[:notemplate]
+                if (self['TEMPLATE/VMTEMPLATE64'].nil? && !is_vcenter) ||
+                    options[:notemplate] ||
+                    options[:template] == -1
                     return rc_info
                 end
 
                 if !options[:template].nil?
                     template_id = options[:template]
 
-                    if template_id == -1
-                        template_id = options[:default_template]
+                    if template_id < 0
+                        raise 'Invalid option, template_id must be a valid ID'
                     end
 
                     template = Template.new_with_id(template_id, @client)
@@ -280,6 +286,33 @@ module OpenNebula::MarketPlaceAppExt
                 rc
             end
 
+            def update_options_with_template(options, _validate = false)
+                vcenterrc_path =
+                    "#{VAR_LOCATION}/remotes/etc/vmm/vcenter/vcenterrc"
+
+                if File.file?(vcenterrc_path)
+                    config_vcenter = YAML.load_file(vcenterrc_path)
+
+                    if config_vcenter.key?(:default_template)
+                        options[:template] =
+                            config_vcenter[:default_template]
+
+                        options
+                    else
+                        raise "Couldn't find default_template " \
+                              'configuration in vcenterrc conf ' \
+                              'file. Please use the --template ' \
+                              'file to define a VM Template ID if ' \
+                              'needed or add default_template to' \
+                              ' vcenterrc conf file'
+                    end
+                else
+                    raise "Couldn't find vcenterrc conf file. " \
+                          ' Please use the --template file to define' \
+                          ' a VM Template ID if needed.'
+                end
+            end
+
             # Creates a VM template based on the APPTEMPLATE64 attribute
             #    @param [Hash] options
             #       :export_name [String] name of the vm template
@@ -288,19 +321,50 @@ module OpenNebula::MarketPlaceAppExt
             #
             #    @return [Integer, OpenNebula::Error] template id or error
             def create_vm_template(options, disks)
-                # --------------------------------------------------------------
-                # Allocate Template
-                # --------------------------------------------------------------
-                if self['TEMPLATE/APPTEMPLATE64'].nil?
-                    return Error.new("Missing APPTEMPLATE64 for App #{id}")
-                end
+                dsid = options[:dsid]
+                ds = OpenNebula::Datastore.new_with_id(dsid, @client)
+                rc = ds.info
 
-                tmpl = Base64.decode64(self['TEMPLATE/APPTEMPLATE64'])
+                is_vcenter =
+                    !OpenNebula.is_error?(rc) &&
+                        (ds['TEMPLATE/DRIVER'] == 'vcenter')
+
+                if is_vcenter
+                    if options[:template].nil?
+                        options = update_options_with_template(options)
+                    end
+
+                    template_id = options[:template]
+
+                    if template_id < 0
+                        return
+                    end
+
+                    template = Template.new_with_id(template_id, @client)
+
+                    vmtpl_id = template.clone(
+                        options[:vmtemplate_name] || options[:name]
+                    )
+
+                    vmtpl = Template.new_with_id(vmtpl_id, @client)
+                    rc = vmtpl.info
+                else
+                    # ----------------------------------------------------------
+                    # Allocate Template
+                    # ----------------------------------------------------------
+                    if self['TEMPLATE/APPTEMPLATE64'].nil?
+                        return Error.new(
+                            "Missing APPTEMPLATE64 for App #{id}"
+                        )
+                    end
+
+                    tmpl = Base64.decode64(self['TEMPLATE/APPTEMPLATE64'])
 
-                tmpl << "\nNAME=\"#{options[:name]}\"\n"
+                    tmpl << "\nNAME=\"#{options[:name]}\"\n"
 
-                vmtpl = Template.new(Template.build_xml, @client)
-                rc    = vmtpl.allocate(tmpl)
+                    vmtpl = Template.new(Template.build_xml, @client)
+                    rc    = vmtpl.allocate(tmpl)
+                end
 
                 return rc if OpenNebula.is_error?(rc)
 

data/lib/opennebula/pool.rb

@@ -322,5 +322,7 @@ module OpenNebula
         def is_paginated?
             PAGINATED_POOLS.include?(@pool_name)
         end
+
     end
+
 end

data/lib/opennebula/template_ext.rb

@@ -75,6 +75,17 @@ module OpenNebula::TemplateExt
                         return [image, ids]
                     end
 
+                    i_state = OpenNebula::Image::IMAGE_STATES[
+                        image['STATE'].to_i
+                    ]
+
+                    unless %w[LOCKED READY USED].include?(i_state)
+                        logger.fatal "Wrong image state #{i_state}" if logger
+
+                        rollback(ids)
+                        return [image, ids]
+                    end
+
                     logger.info "Adding disk with image #{image.id}" if logger
 
                     tmpl, main = create_app_template(image, idx)
@@ -209,8 +220,14 @@ module OpenNebula::TemplateExt
             #   - content for VM template
             #-------------------------------------------------------------------
             def create_app_template(image, idx = 0)
-                # Wait until the image is READY to safe copy it to the MP
-                image.wait('READY') if Integer(image['STATE']) != 1
+                i_state = OpenNebula::Image::IMAGE_STATES[image['STATE'].to_i]
+
+                # If the image is used, there is no need to wait until it is
+                # ready because the image is already ready to be copied
+                if i_state != 'USED' && Integer(image['STATE']) != 1
+                    # Wait until the image is READY to safe copy it to the MP
+                    image.wait('READY')
+                end
 
                 # Rename to avoid clashing names
                 app_name = "#{image['NAME']}-#{SecureRandom.hex[0..9]}"

data/lib/opennebula/virtual_machine.rb

@@ -771,6 +771,8 @@ module OpenNebula
         end
 
         def wait_state(state, timeout=120)
+            require 'opennebula/wait_ext'
+
             extend OpenNebula::WaitExt
 
             rc = wait2(state, 'LCM_INIT', timeout)

data/lib/opennebula/virtual_machine_ext.rb

@@ -267,17 +267,20 @@ module OpenNebula::VirtualMachineExt
                 # --------------------------------------------------------------
                 # Check backup consistency
                 # --------------------------------------------------------------
-                unless binfo
-                    rc = info
-                    raise rc.message if OpenNebula.is_error?(rc)
+                rc = info
+
+                raise rc.message if OpenNebula.is_error?(rc)
 
-                    binfo = backup_info
+                binfo.merge!(backup_info) do |key, old_val, new_val|
+                    new_val.nil? ? old_val : new_val
                 end
 
                 raise 'No backup information' if binfo.nil?
 
                 raise 'No frequency defined' unless valid?(binfo[:freq])
 
+                raise 'No marketplace defined' unless valid?(binfo[:market])
+
                 return if Time.now.to_i - binfo[:last].to_i < binfo[:freq].to_i
 
                 # --------------------------------------------------------------
@@ -319,19 +322,12 @@ module OpenNebula::VirtualMachineExt
                 # --------------------------------------------------------------
                 # Cleanup
                 # --------------------------------------------------------------
-                logger.info "Deleting template #{tmp.id}" if logger
-
-                tmp.delete(true)
-
-                binfo[:apps].each do |id|
-                    log "Deleting applicance #{id}" if logger
-
-                    papp = OpenNebula::MarketPlaceApp.new_with_id(id, @client)
-
-                    papp.delete
-                end if !keep && binfo[:apps]
+                backup_cleanup(keep, logger, binfo, tmp)
             rescue Error, StandardError => e
+                backup_cleanup(keep, logger, binfo, tmp)
+
                 logger.fatal(e.inspect) if logger
+
                 raise
             end
 
@@ -421,9 +417,9 @@ module OpenNebula::VirtualMachineExt
 
             private
 
-            # --------------------------------------------------------------
+            #-------------------------------------------------------------------
             # Check an attribute is defined and valid
-            # --------------------------------------------------------------
+            #-------------------------------------------------------------------
             def valid?(att)
                 return false if att.nil?
 
@@ -454,6 +450,9 @@ module OpenNebula::VirtualMachineExt
                 binfo
             end
 
+            #-------------------------------------------------------------------
+            # Generate backup information string
+            #-------------------------------------------------------------------
             def backup_attr(binfo, ids)
                 'BACKUP=[' \
                 "  MARKETPLACE_APP_IDS = \"#{ids.join(',')}\"," \
@@ -462,6 +461,25 @@ module OpenNebula::VirtualMachineExt
                 "  MARKETPLACE_ID      = \"#{binfo[:market]}\" ]"
             end
 
+            #-------------------------------------------------------------------
+            # Cleanup backup leftovers in case of failure
+            #-------------------------------------------------------------------
+            def backup_cleanup(keep, logger, binfo, template)
+                if template
+                    logger.info "Deleting template #{template.id}" if logger
+
+                    template.delete(true)
+                end
+
+                binfo[:apps].each do |id|
+                    logger.info "Deleting applicance #{id}" if logger
+
+                    papp = OpenNebula::MarketPlaceApp.new_with_id(id, @client)
+
+                    papp.delete
+                end if !keep && binfo[:apps]
+            end
+
         end
     end