opennebula 5.13.80.pre → 6.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc16996ef3b6218367420d87066688a52ee86042
-  data.tar.gz: dae462f84f7ec7bfed459506c56981be1e27974e
+  metadata.gz: f663dcec1594a07beb54bc3a4065b53818669846
+  data.tar.gz: 63d9ffe94c43fb81d6cc7e2a0563ed6d711ebc48
 SHA512:
-  metadata.gz: d6a40c0cbf0a2125a07d18348d0d13471562d81581c06318126a7d671025bdcf34a30c5228af30bd37014af65329714ada099de91fcde70db29198b2731c0fc8
-  data.tar.gz: 4a53d311862746b7712066d355120306a5b3d4311315dabf24513f5e20dc509acb4254e5d58556090b768f3aa33e89df2311c10127d87c918f7c0befe2b6c8a1
+  metadata.gz: 905fbdea52975558d07f8720c64c5f37365672d487a1bb334c94e0e4ea5026be94468c3320b667c2d7acc6f31f312e0e58b951cbf136bf45ebfc1d4efaa7e857
+  data.tar.gz: ddb7dadb1c1d2df3454b11a4c7f91385049ee2b134de1d75c0c27b7e59b554b2f9db5ca6135e85a9d0e8ff3b0e0565f3f4e34dd121830c151a1f468347187ad6

data/lib/cloud/CloudClient.rb

@@ -51,7 +51,7 @@ end
 module CloudClient
 
     # OpenNebula version
-    VERSION = '5.13.80'
+    VERSION = '6.0.1'
 
     # #########################################################################
     # Default location for the authentication file

data/lib/datacenter.rb

@@ -576,15 +576,14 @@ module VCenterDriver
             # Initialize opts hash used to inject data into one template
             opts = {}
 
-            if full_process
-                # Add network type to network hash
-                network_type = \
-                    VCenterDriver::Network.get_network_type(
-                        vc_network,
-                        vc_network_name
-                    )
-                network[vc_network_ref][:network_type] = network_type
-            end
+            # Add network type to network hash
+            network_type = \
+                VCenterDriver::Network.get_network_type(
+                    vc_network,
+                    vc_network_name
+                )
+            network[vc_network_ref][:network_type] = network_type
+            network[vc_network_ref][:type] = network_type
 
             # Determine if the network must be excluded
             network[vc_network_ref][:excluded] = exclude_network?(

data/lib/datastore.rb

@@ -653,8 +653,8 @@ module VCenterDriver
 
             wout.close
             size = rout.readlines.select do |l|
-                l.start_with?('Content-Length')
-            end[0].sub('Content-Length: ', '')
+                l.downcase.start_with?('content-length')
+            end[0].downcase.sub('content-length: ', '')
             rout.close
             size.chomp.to_i < 4096 # If <4k, then is a descriptor
         end

data/lib/network.rb

@@ -486,6 +486,70 @@ module VCenterDriver
             @defaults = { :size => '255', :type => 'ether' }
         end
 
+        def process_import(indexes, opts = {}, &_block)
+            indexes = indexes.gsub(/\s*\,\s*/, ',').strip.split(',')
+
+            dc_folder = VCenterDriver::DatacenterFolder.new(@vi_client)
+            vcenter_instance_name = @vi_client.vc_name
+            vcenter_uuid = @vi_client.vim.serviceContent.about.instanceUuid
+            hpool = VCenterDriver::VIHelper.one_pool(
+                OpenNebula::HostPool,
+                false
+            )
+
+            one_client = OpenNebula::Client.new
+            one_host = OpenNebula::Host.new_with_id(opts[:host], one_client)
+
+            rc = one_host.info
+            raise rc.message if OpenNebula.is_error? rc
+
+            # Get all networks in vcenter cluster (one_host)
+            vc_cluster_networks = dc_folder.cluster_networks(one_host)
+
+            vc_cluster_networks_map_ref = {}
+
+            # Iterate over vcenter networks
+            vc_cluster_networks.each do |vc_cluster_network|
+                vc_cluster_networks_map_ref[vc_cluster_network._ref] =
+                    vc_cluster_network
+            end
+
+            indexes.each do |index|
+                begin
+                    @rollback = []
+                    @info[index] = {}
+
+                    vc_cluster_network = vc_cluster_networks_map_ref[index]
+
+                    if hpool.respond_to?(:message)
+                        raise 'Could not get OpenNebula HostPool: ' \
+                              "#{hpool.message}"
+                    end
+
+                    params = {}
+                    params[:vc_network] = vc_cluster_network
+                    params[:vcenter_instance_name] = vcenter_instance_name
+                    params[:vcenter_uuid] = vcenter_uuid
+                    params[:_hpool] = hpool
+                    params[:one_host] = one_host
+                    params[:args] = {}
+
+                    selected = dc_folder.process_network(params)
+
+                    selected = selected[index]
+
+                    # import the object
+                    opts[index] ||= @defaults
+                    @info[:success] << import(selected, opts[index])
+                rescue StandardError => e
+                    @info[:error] << { index => e.message }
+                    @info[index][:e] = e
+
+                    apply_rollback
+                end
+            end
+        end
+
         def get_list(args = {})
             dc_folder = VCenterDriver::DatacenterFolder.new(@vi_client)
 
@@ -496,8 +560,8 @@ module VCenterDriver
                         false
                     )
             if npool.respond_to?(:message)
-                raise "Could not get \
-                OpenNebula VirtualNetworkPool: #{npool.message}"
+                raise 'Could not get ' \
+                "OpenNebula VirtualNetworkPool: #{npool.message}"
             end
 
             # Get OpenNebula's host pool
@@ -572,8 +636,8 @@ module VCenterDriver
             str
         end
 
-        def import(selected)
-            opts = @info[selected[:ref]][:opts]
+        def import(selected, opts = nil)
+            opts = @info[selected[:ref]][:opts] if opts.nil?
 
             net = VCenterDriver::Network
                   .new_from_ref(selected[:ref], @vi_client)

data/lib/opennebula.rb

@@ -77,5 +77,5 @@ require 'opennebula/flow'
 module OpenNebula
 
     # OpenNebula version
-    VERSION = '5.13.80'
+    VERSION = '6.0.1'
 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 > 128
+                    new_name = "#{template.name[0..(126 - 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

@@ -324,7 +324,7 @@ module OpenNebula::VirtualMachineExt
                 tmp.delete(true)
 
                 binfo[:apps].each do |id|
-                    log "Deleting applicance #{id}" if logger
+                    logger.info "Deleting applicance #{id}" if logger
 
                     papp = OpenNebula::MarketPlaceApp.new_with_id(id, @client)
 

data/lib/opennebula/wait_ext.rb

@@ -14,19 +14,117 @@
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
 
-require 'ffi-rzmq'
 
 require 'opennebula/host'
 require 'opennebula/image'
 require 'opennebula/virtual_machine'
 
+module OpenNebula::WaitExtEvent
+    def wait_event(ctx, event, timeout)
+        subscriber = ctx.socket(ZMQ::SUB)
+
+        # Create subscriber
+        key        = ''
+        content    = ''
+
+        subscriber.setsockopt(ZMQ::RCVTIMEO, timeout * 1000)
+        subscriber.setsockopt(ZMQ::SUBSCRIBE, event)
+        subscriber.connect(@client.one_zmq)
+
+        rc = subscriber.recv_string(key)
+        rc = subscriber.recv_string(content) if rc != -1
+
+        return if ZMQ::Util.errno == ZMQ::EAGAIN || rc == -1
+
+        content
+    ensure
+        subscriber.setsockopt(ZMQ::UNSUBSCRIBE, event)
+        subscriber.close
+    end
+
+    def wait2(sstr1, sstr2, timeout = 60, cycles = -1)
+        wfun = OpenNebula::WaitExt::WAIT[self.class]
+
+        # Start with a timeout of 2 seconds, to wait until the first
+        # info.
+        #
+        # The timeout is increased later, to avoid multiple info calls.
+        c_timeout = 2
+        recvs     = 0
+        in_state  = false
+
+        # Subscribe with timeout seconds
+        #
+        # Subscribe string:
+        #
+        #   EVENT STATE element_name/state_str//self.ID
+        #
+        #   - element_name: is the element name to find in the message
+        #   - self.ID: returns element ID to find in the message
+        ctx = ZMQ::Context.new(1)
+
+        until in_state || (cycles != -1 && recvs >= cycles)
+            content = wait_event(ctx,
+                                 wfun[:event].call(self, sstr1, sstr2),
+                                 c_timeout)
+
+            if content && !content.empty?
+                in_state = wfun[:in_state_e].call(sstr1, sstr2, content)
+
+                break if in_state
+            end
+
+            c_timeout *= 10
+            c_timeout  = timeout if c_timeout > timeout
+
+            rco = info
+
+            return false if OpenNebula.is_error?(rco)
+
+            in_state = wfun[:in_state].call(self, sstr1, sstr2)
+
+            recvs += 1
+        end
+
+        in_state
+    end
+
+end
+
+module OpenNebula::WaitExtPolling
+    def wait2(sstr1, sstr2, timeout = 60, cycles = -1)
+        wfun = OpenNebula::WaitExt::WAIT[self.class]
+
+        stime    = 5
+        recvs    = 0
+        cycles   = timeout / stime
+        in_state = false
+
+        loop do
+            rco = info
+
+            return false if OpenNebula.is_error?(rco)
+
+            in_state = wfun[:in_state].call(self, sstr1, sstr2)
+
+            recvs += 1
+
+            break if in_state || recvs >= cycles
+
+            sleep stime
+        end
+
+        in_state
+    end
+
+end
+
 # Module to decorate Wait classes with the following methods:
 #   - Wait
 #
 # rubocop:disable Style/ClassAndModuleChildren
 module OpenNebula::WaitExt
-
-    # Wait classes and the name published in ZMQ
+    # Wait classes and the name published in ZMQ/STATE
     WAIT = {
         OpenNebula::Host  => {
             :event => lambda {|o, s1, _s2|
@@ -78,7 +176,7 @@ module OpenNebula::WaitExt
             },
 
             :in_state => lambda {|o, s1, s2|
-                obj_s1 = Integer(o['STATE'])
+              obj_s1 = Integer(o['STATE'])
                 inx_s1 = OpenNebula::VirtualMachine::VM_STATE.index(s1)
 
                 obj_s2 = Integer(o['LCM_STATE'])
@@ -105,93 +203,30 @@ module OpenNebula::WaitExt
         wait?(obj)
 
         class << obj
+          begin
+            require 'ffi-rzmq'
 
-            # Wait until the element reaches some specific state
-            # It waits until the state can be found in ZMQ event message
-            #
-            # @param state_str [String]  State name to wait
-            # @param timeout   [Integer] Number of seconds to timeout event recv
-            # @param cycles    [Integer] Number of recv cycles. After each one
-            #                            object status is checked in OpenNebula.
-            #                            Use -1 (default) to wait forever.
-            def wait(state_str, timeout = 60, cycles = -1)
-                wait2(state_str, '', timeout, cycles)
-            end
-
-            def wait_event(ctx, event, timeout)
-                subscriber = ctx.socket(ZMQ::SUB)
-
-                # Create subscriber
-                key        = ''
-                content    = ''
-
-                subscriber.setsockopt(ZMQ::RCVTIMEO, timeout * 1000)
-                subscriber.setsockopt(ZMQ::SUBSCRIBE, event)
-                subscriber.connect('tcp://localhost:2101')
-
-                rc = subscriber.recv_string(key)
-                rc = subscriber.recv_string(content) if rc != -1
-
-                return if ZMQ::Util.errno == ZMQ::EAGAIN || rc == -1
-
-                content
-            ensure
-                subscriber.setsockopt(ZMQ::UNSUBSCRIBE, event)
-                subscriber.close
-            end
-
-            def wait2(sstr1, sstr2, timeout = 60, cycles = -1)
-                wfun = WAIT[self.class]
-
-                # Start with a timeout of 2 seconds, to wait until the first
-                # info.
-                #
-                # The timeout is increased later, to avoid multiple info calls.
-                c_timeout = 2
-                recvs     = 0
-                in_state  = false
-
-                # Subscribe with timeout seconds
-                #
-                # Subscribe string:
-                #
-                #   EVENT STATE element_name/state_str//self.ID
-                #
-                #   - element_name: is the element name to find in the message
-                #   - self.ID: returns element ID to find in the message
-                ctx = ZMQ::Context.new(1)
-
-                until in_state || (cycles != -1 && recvs >= cycles)
-                    content = wait_event(ctx,
-                                         wfun[:event].call(self, sstr1, sstr2),
-                                         c_timeout)
-
-                    if content && !content.empty?
-                        in_state = wfun[:in_state_e].call(sstr1, sstr2, content)
-
-                        break if in_state
-                    end
-
-                    c_timeout *= 10
-                    c_timeout  = timeout if c_timeout > timeout
-
-                    rco = info
-
-                    return false if OpenNebula.is_error?(rco)
-
-                    in_state = wfun[:in_state].call(self, sstr1, sstr2)
-
-                    recvs += 1
-                end
-
-                in_state
-            end
-
+            include OpenNebula::WaitExtEvent
+          rescue LoadError
+            include OpenNebula::WaitExtPolling
+          end
         end
 
         super
     end
 
+    # Wait until the element reaches some specific state
+    # It waits until the state can be found in ZMQ event message
+    #
+    # @param state_str [String]  State name to wait
+    # @param timeout   [Integer] Number of seconds to timeout event recv
+    # @param cycles    [Integer] Number of recv cycles. After each one
+    #                            object status is checked in OpenNebula.
+    #                            Use -1 (default) to wait forever.
+    def wait(state_str, timeout = 60, cycles = -1)
+        wait2(state_str, '', timeout, cycles)
+    end
+
     # Check if object has the method wait or not
     #
     # @param obj [Object or Class] Object to check class

data/lib/scripts_common.rb

@@ -14,6 +14,8 @@
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
 
+require 'shellwords'
+
 module OpenNebula
 
     # Generic log function
@@ -76,6 +78,7 @@ module OpenNebula
     # If a second parameter is present it is used as the error message when
     # the command fails
     def self.exec_and_log(command, message=nil, allowed_return_code=0)
+        command = command.shellsplit.shelljoin # escape
         output=`#{command} 2>&1 1>/dev/null`
         code=$?.exitstatus
 

data/lib/vi_helper.rb

@@ -231,10 +231,11 @@ module VCenterDriver
             @ref_hash[attribute][refkey]
         end
 
+        require 'addressable'
         def self.find_image_by(att, the_class, path, ds_id, pool = nil)
             pool = one_pool(the_class, false) if pool.nil?
             pool.find do |e|
-                e[att] == path &&
+                e[att] == Addressable::URI.escape(path) &&
                     e['DATASTORE_ID'] == ds_id
             end
         end

data/lib/virtual_machine.rb

@@ -1961,7 +1961,7 @@ module VCenterDriver
             end
 
             card_spec = {
-                :key => 0,
+                :key => Time.now.utc.strftime('%Y%m%d%M%S%L').to_i,
                 :deviceInfo => {
                     :label => 'net' + card_num.to_s,
                     :summary => pg_name
@@ -2107,7 +2107,7 @@ module VCenterDriver
             end
 
             card_spec = {
-                :key => 0,
+                :key => Time.now.utc.strftime('%Y%m%d%M%S%L').to_i,
                 :deviceInfo => {
                     :label => 'net' + card_num.to_s,
                     :summary => pg_name
@@ -3032,7 +3032,7 @@ module VCenterDriver
         # Create a snapshot for the VM
         def create_snapshot(snap_id, snap_name)
             memory_dumps = true
-            memory_dumps = CONFIG[:memory_dumps] if CONFIG[:memory_dumps]
+            memory_dumps = CONFIG[:memory_dumps] unless CONFIG[:memory_dumps].nil?
 
             snapshot_hash = {
                 :name        => snap_id,

data/lib/vm_template.rb

@@ -602,7 +602,7 @@ module VCenterDriver
         def nic_alias_from_nic(id, nic, nic_index, network_found, vm_object)
             nic_tmp = ''
 
-            nic_alias_index = 1
+            nic_alias_index = 0
             if nic[:ipv4_additionals]
                 nic[:ipv4_additionals].split(',').each do |ipv4_additional|
                     ipv4, ipv6 =
@@ -625,8 +625,8 @@ module VCenterDriver
                     nic_tmp << "NETWORK_ID=\"#{id}\",\n"
                     nic_tmp << "IP=\"#{ipv4_additional}\",\n"
                     nic_tmp <<
-                        "NAME=\"NIC#{nic_index}_ALIAS#{nic_alias_index}\",\n"
-                    nic_tmp << "PARENT=\"NIC#{nic_index}\"\n"
+                        "NAME=\"VC_NIC#{nic_index}_ALIAS#{nic_alias_index}\",\n"
+                    nic_tmp << "PARENT=\"VC_NIC#{nic_index}\"\n"
                     nic_tmp << "]\n"
                     nic_alias_index += 1
                 end
@@ -653,8 +653,8 @@ module VCenterDriver
                     nic_tmp << "NETWORK_ID=\"#{id}\",\n"
                     nic_tmp << "IP6=\"#{ipv6_additional}\",\n"
                     nic_tmp <<
-                        "NAME=\"NIC#{nic_index}_ALIAS#{nic_alias_index}\",\n"
-                    nic_tmp << "PARENT=\"NIC#{nic_index}\"\n"
+                        "NAME=\"VC_NIC#{nic_index}_ALIAS#{nic_alias_index}\",\n"
+                    nic_tmp << "PARENT=\"VC_NIC#{nic_index}\"\n"
                     nic_tmp << "]\n"
                     nic_alias_index += 1
                 end
@@ -666,7 +666,7 @@ module VCenterDriver
         def nic_from_network_created(one_vn, nic, nic_index, vm_object, _ar_ids)
             nic_tmp = "NIC=[\n"
             nic_tmp << "NETWORK_ID=\"#{one_vn.id}\",\n"
-            nic_tmp << "NAME =\"NIC#{nic_index}\",\n"
+            nic_tmp << "NAME =\"VC_NIC#{nic_index}\",\n"
 
             if vm?
                 if nic[:mac]
@@ -716,7 +716,7 @@ module VCenterDriver
         )
             nic_tmp = "NIC=[\n"
             nic_tmp << "NETWORK_ID=\"#{network_found['ID']}\",\n"
-            nic_tmp << "NAME =\"NIC#{nic_index}\",\n"
+            nic_tmp << "NAME =\"VC_NIC#{nic_index}\",\n"
 
             if vm?
                 ipv4, ipv6 = find_ips_in_network(network_found, vm_object,
@@ -1014,7 +1014,7 @@ module VCenterDriver
                 # Track allocated networks for rollback
                 allocated_networks = []
 
-                nic_index = 1
+                nic_index = 0
 
                 vc_nics.each do |nic|
                     # Check if the network already exists
@@ -1659,10 +1659,12 @@ module VCenterDriver
                 folders = []
                 until item.instance_of? RbVmomi::VIM::Datacenter
                     item = item.parent
-                    first_condition = item.instance_of? RbVmomi::VIM::Datacenter
-                    second_condition = item.name != 'vm'
+                    first_condition =
+                        !(item.instance_of? RbVmomi::VIM::Datacenter)
+                    second_condition =
+                        item.name != 'vm'
 
-                    unless first_condition && second_condition
+                    if first_condition && second_condition
                         folders << item.name
                     end
                     if item.nil?
@@ -1693,8 +1695,8 @@ module VCenterDriver
                 one_tmp[:dc_name]               = dc_name
                 one_tmp[:template_name]         = template_name
                 one_tmp[:sunstone_template_name]=
-                    "#{template_name} [ Cluster: #{template_ccr_name} \
-                    - Template location: #{location} ]"
+                    "#{template_name} [ Cluster: #{template_ccr_name}" \
+                    " - Template location: #{location} ]"
                 one_tmp[:template_location]     = location
                 one_tmp[:vcenter_ccr_ref]       = template_ccr_ref
                 one_tmp[:vcenter_ref]           = template_ref

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opennebula
 version: !ruby/object:Gem::Version
-  version: 5.13.80.pre
+  version: 6.0.1
 platform: ruby
 authors:
 - OpenNebula
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-28 00:00:00.000000000 Z
+date: 2021-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -223,8 +223,8 @@ files:
 - lib/opennebula/xml_element.rb
 - lib/opennebula/xml_pool.rb
 - lib/opennebula/xml_utils.rb
-- lib/opennebula/zone.rb
 - lib/opennebula/zone_pool.rb
+- lib/opennebula/zone.rb
 - lib/opennebula/flow/grammar.rb
 - lib/opennebula/flow/service_pool.rb
 - lib/opennebula/flow/service_template.rb
@@ -255,9 +255,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.14.1