opennebula 6.0.0.1 → 6.0.3

data/lib/network.rb

@@ -534,7 +534,13 @@ module VCenterDriver
                     params[:one_host] = one_host
                     params[:args] = {}
 
-                    selected = dc_folder.process_network(params)
+                    selected, _networks_type, _hosts_list, _clusters_list =
+                        dc_folder.process_network(
+                            params,
+                            {},
+                            {},
+                            {}
+                        )
 
                     selected = selected[index]
 

data/lib/nsx_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/nsx_constants.rb

@@ -6,7 +6,7 @@
 # a copy of the License at                                                   #
 #                                                                            #
 # http://www.apache.org/licenses/LICENSE-2.0                                 #
-#                                                                             #
+#                                                                            #
 # Unless required by applicable law or agreed to in writing, software        #
 # distributed under the License is distributed on an "AS IS" BASIS,          #
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
@@ -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/nsx_driver.rb

@@ -36,14 +36,27 @@ end
 
 ENV['LANG'] = 'C'
 
+# 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/ }
-        require 'rubygems'
-        Gem.use_paths(real_gems_path)
+
+        # 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 << LIB_LOCATION + '/ruby'
 $LOAD_PATH << LIB_LOCATION + '/ruby/nsx_driver'

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 = '6.0.0.1'
+    VERSION = '6.0.3'
 end

data/lib/opennebula/flow/service_template.rb

@@ -361,8 +361,8 @@ module OpenNebula
                 # exceeds the limit
                 new_name = "#{template.name}-#{name}"
 
-                if new_name.size > 128
-                    new_name = "#{template.name[0..(126 - name.size)]}-#{name}"
+                if new_name.size > 119
+                    new_name = "#{template.name[0..(119 - name.size)]}-#{name}"
                 end
 
                 rc = template.clone(new_name, recursive)
@@ -451,6 +451,16 @@ module OpenNebula
             validate_values(template)
         end
 
+        def self.validate_role(template)
+            validator = Validator::Validator.new(
+                :default_values => true,
+                :delete_extra_properties => false,
+                :allow_extra_properties => true
+            )
+
+            validator.validate!(template, ROLE_SCHEMA)
+        end
+
         def instantiate(merge_template)
             rc = nil
 

data/lib/opennebula/marketplace.rb

@@ -29,7 +29,15 @@ module OpenNebula
             :update     => "market.update",
             :chown      => "market.chown",
             :chmod      => "market.chmod",
-            :rename     => "market.rename"
+            :rename     => "market.rename",
+            :enable     => "market.enable"
+        }
+
+        MARKETPLACE_STATES=%w{ENABLED DISABLED}
+
+        SHORT_MARKETPLACE_STATES={
+            "ENABLED"              => "on",
+            "DISABLED"             => "off"
         }
 
         # Creates a MarketPlace description with just its identifier
@@ -130,13 +138,33 @@ module OpenNebula
         # @return [nil, OpenNebula::Error] nil in case of success, Error
         #   otherwise
         def rename(name)
-            return call(MARKETPLACE_METHODS[:rename], @pe_id, name)
+            call(MARKETPLACE_METHODS[:rename], @pe_id, name)
+        end
+
+        # Enables this marketplace
+        def enable
+            call(MARKETPLACE_METHODS[:enable], @pe_id, true)
+        end
+
+        # Enables this marketplace
+        def disable
+            call(MARKETPLACE_METHODS[:enable], @pe_id, false)
         end
 
         # ---------------------------------------------------------------------
         # Helpers to get information
         # ---------------------------------------------------------------------
 
+        # Returns the state of the Zone (numeric value)
+        def state
+            self['STATE'].to_i
+        end
+
+        # Returns the state of the Zone (string value)
+        def state_str
+            MARKETPLACE_STATES[state]
+        end
+
         # Returns whether or not the marketplace app with id 'id' is part of
         # this marketplace
         def contains(id)

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
 
-                    binfo = backup_info
+                raise rc.message if OpenNebula.is_error?(rc)
+
+                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|
-                    logger.info "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
 

data/lib/opennebula/wait_ext.rb

@@ -14,107 +14,118 @@
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
 
-
 require 'opennebula/host'
 require 'opennebula/image'
 require 'opennebula/virtual_machine'
 
-module OpenNebula::WaitExtEvent
-    def wait_event(ctx, event, timeout)
-        subscriber = ctx.socket(ZMQ::SUB)
+module OpenNebula
 
-        # Create subscriber
-        key        = ''
-        content    = ''
+    # Module to wait OpenNebula objects events using ZMQ
+    module WaitExtEvent
 
-        subscriber.setsockopt(ZMQ::RCVTIMEO, timeout * 1000)
-        subscriber.setsockopt(ZMQ::SUBSCRIBE, event)
-        subscriber.connect(@client.one_zmq)
+        def wait_event(ctx, event, timeout)
+            subscriber = ctx.socket(ZMQ::SUB)
 
-        rc = subscriber.recv_string(key)
-        rc = subscriber.recv_string(content) if rc != -1
+            # Create subscriber
+            key        = ''
+            content    = ''
 
-        return if ZMQ::Util.errno == ZMQ::EAGAIN || rc == -1
+            subscriber.setsockopt(ZMQ::RCVTIMEO, timeout * 1000)
+            subscriber.setsockopt(ZMQ::SUBSCRIBE, event)
+            subscriber.connect(@client.one_zmq)
 
-        content
-    ensure
-        subscriber.setsockopt(ZMQ::UNSUBSCRIBE, event)
-        subscriber.close
-    end
+            rc = subscriber.recv_string(key)
+            rc = subscriber.recv_string(content) if rc != -1
 
-    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
+            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
+                c_timeout *= 10
+                c_timeout  = timeout if c_timeout > timeout
 
-            rco = info
+                rco = info
 
-            return false if OpenNebula.is_error?(rco)
+                return false if OpenNebula.is_error?(rco)
 
-            in_state = wfun[:in_state].call(self, sstr1, sstr2)
+                in_state = wfun[:in_state].call(self, sstr1, sstr2)
 
-            recvs += 1
+                recvs += 1
+            end
+
+            in_state
         end
 
-        in_state
     end
 
 end
 
-module OpenNebula::WaitExtPolling
-    def wait2(sstr1, sstr2, timeout = 60, cycles = -1)
-        wfun = OpenNebula::WaitExt::WAIT[self.class]
+module OpenNebula
+
+    # Module to wait OpenNebula objects events using polling
+    module WaitExtPolling
+
+        def wait2(sstr1, sstr2, timeout = 60, cycles = -1)
+            wfun = OpenNebula::WaitExt::WAIT[self.class]
+
+            stime    = 5
+            recvs    = 0
+            cycles   = timeout / stime if cycles == -1
+            in_state = false
 
-        stime    = 5
-        recvs    = 0
-        cycles   = timeout / stime
-        in_state = false
+            loop do
+                rco = info
 
-        loop do
-            rco = info
+                return false if OpenNebula.is_error?(rco)
 
-            return false if OpenNebula.is_error?(rco)
+                in_state = wfun[:in_state].call(self, sstr1, sstr2)
 
-            in_state = wfun[:in_state].call(self, sstr1, sstr2)
+                recvs += 1
 
-            recvs += 1
+                break if in_state || recvs >= cycles
 
-            break if in_state || recvs >= cycles
+                sleep stime
+            end
 
-            sleep stime
+            in_state
         end
 
-        in_state
     end
 
 end
@@ -124,6 +135,7 @@ end
 #
 # rubocop:disable Style/ClassAndModuleChildren
 module OpenNebula::WaitExt
+
     # Wait classes and the name published in ZMQ/STATE
     WAIT = {
         OpenNebula::Host  => {
@@ -176,7 +188,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'])
@@ -203,13 +215,15 @@ module OpenNebula::WaitExt
         wait?(obj)
 
         class << obj
-          begin
-            require 'ffi-rzmq'
 
-            include OpenNebula::WaitExtEvent
-          rescue LoadError
-            include OpenNebula::WaitExtPolling
-          end
+            begin
+                require 'ffi-rzmq'
+
+                include OpenNebula::WaitExtEvent
+            rescue LoadError
+                include OpenNebula::WaitExtPolling
+            end
+
         end
 
         super