opennebula 5.12.13 → 5.13.80.pre

data/lib/opennebula/image_pool.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2023, OpenNebula Project, OpenNebula Systems                #
+# Copyright 2002-2021, OpenNebula Project, OpenNebula Systems                #
 #                                                                            #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may    #
 # not use this file except in compliance with the License. You may obtain    #

data/lib/opennebula/ldap_auth.rb

@@ -1,5 +1,5 @@
 # ---------------------------------------------------------------------------- #
-# Copyright 2002-2023, OpenNebula Project, OpenNebula Systems                  #
+# Copyright 2002-2021, OpenNebula Project, OpenNebula Systems                  #
 #                                                                              #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may      #
 # not use this file except in compliance with the License. You may obtain      #

data/lib/opennebula/ldap_auth_spec.rb

@@ -1,5 +1,5 @@
 # ---------------------------------------------------------------------------- #
-# Copyright 2002-2023, OpenNebula Project, OpenNebula Systems                  #
+# Copyright 2002-2021, OpenNebula Project, OpenNebula Systems                  #
 #                                                                              #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may      #
 # not use this file except in compliance with the License. You may obtain      #

data/lib/opennebula/lockable_ext.rb

@@ -0,0 +1,163 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2021, OpenNebula Project, OpenNebula Systems                #
+#                                                                            #
+# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
+# not use this file except in compliance with the License. You may obtain    #
+# 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.   #
+# See the License for the specific language governing permissions and        #
+# limitations under the License.                                             #
+#--------------------------------------------------------------------------- #
+
+require 'date'
+
+require 'opennebula/document'
+require 'opennebula/hook'
+require 'opennebula/image'
+require 'opennebula/marketplaceapp'
+require 'opennebula/template'
+require 'opennebula/virtual_machine'
+require 'opennebula/virtual_network'
+require 'opennebula/virtual_router'
+require 'opennebula/vm_group'
+require 'opennebula/vntemplate'
+
+# Module to decorate Lockable classes with the following methods:
+#   - Lock
+#   - Unlock
+#   - Synchronize
+#
+# rubocop:disable Style/ClassAndModuleChildren
+module OpenNebula::LockableExt
+
+    # Expire timeout for locking operation
+    LOCK_TIMEOUT = 120
+
+    def self.make_lockable(obj, methods)
+        obj.instance_variable_set(:@lock_method, methods[:lock])
+        obj.instance_variable_set(:@unlock_method, methods[:unlock])
+
+        obj.extend(OpenNebula::LockableExt)
+    end
+
+    def self.extend_object(obj)
+        lockable?(obj)
+
+        class << obj
+
+            # Locks the object
+            #
+            # @param level [Integer] Lock level
+            # @param test  [Boolean] Check if the object is already locked
+            #
+            # use    -> level = 1
+            # manage -> level = 2
+            # admin  -> level = 3
+            # all    -> level = 4
+            #
+            # @return [Integer, OpenNebula::Error]
+            #   - Object ID if the lock was granted
+            #   - Error otherwise
+            def lock(level, test = false)
+                return Error.new('ID not defined') unless @pe_id
+
+                @client.call(@lock_method, @pe_id, level, test)
+            end
+
+            # Unlocks this object
+            #
+            # @return [nil, OpenNebula::Error]
+            #   - nil in case of success
+            #   - Error otherwise
+            def unlock
+                @client.call(@unlock_method, @pe_id)
+            end
+
+            # Executes an operation with lock granted
+            #
+            # @param level [Integer] Lock level
+            #
+            # @return [Operation rc, OpenNebula::Error]
+            #   - Operation return code
+            #   - Error otherwise
+            def synchronize(level)
+                rc = lock(level, true)
+
+                if OpenNebula.is_error?(rc)
+                    # If test check, core returns timestamp when it was locked
+                    lock_time = Time.at(Integer(rc.message.split(' ')[1]))
+                    c_time    = Time.now
+
+                    # If the timeout has not yet expired, return error
+                    if (c_time - lock_time) < LOCK_TIMEOUT
+                        return Error.new('Object is locked')
+                    end
+
+                    rc = lock(level)
+
+                    return rc if OpenNebula.is_error?(rc)
+                end
+
+                ret = yield if block_given?
+
+                unless OpenNebula.is_error?(info)
+                    rc = unlock
+
+                    return rc if OpenNebula.is_error?(rc)
+                end
+
+                ret
+            end
+
+        end
+
+        super
+    end
+
+    # Check if object is lockable or not
+    #
+    # @param obj [Object or Class] Object to check class
+    def self.lockable?(obj)
+        # Lockable classes
+        lockable = [
+            OpenNebula::Document,
+            OpenNebula::Hook,
+            OpenNebula::Image,
+            OpenNebula::MarketPlaceApp,
+            OpenNebula::Template,
+            OpenNebula::VirtualMachine,
+            OpenNebula::VirtualNetwork,
+            OpenNebula::VirtualRouter,
+            OpenNebula::VMGroup,
+            OpenNebula::VNTemplate
+        ]
+
+        # Get obj class to find parents in lockable class
+        # rubocop:disable Style/TernaryParentheses
+        (obj.is_a? Class) ? o_class = obj : o_class = obj.class
+        # rubocop:enable Style/TernaryParentheses
+
+        found   = false
+        i_class = o_class
+
+        while i_class
+            if lockable.include?(i_class)
+                found = true
+                break
+            end
+
+            i_class = i_class.superclass
+        end
+
+        return if found
+
+        raise StandardError, "Cannot extend #{o_class} with LockableExt"
+    end
+
+end
+# rubocop:enable Style/ClassAndModuleChildren

data/lib/opennebula/marketplace.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2023, OpenNebula Project, OpenNebula Systems                #
+# Copyright 2002-2021, OpenNebula Project, OpenNebula Systems                #
 #                                                                            #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may    #
 # not use this file except in compliance with the License. You may obtain    #

data/lib/opennebula/marketplace_pool.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2023, OpenNebula Project, OpenNebula Systems                #
+# Copyright 2002-2021, OpenNebula Project, OpenNebula Systems                #
 #                                                                            #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may    #
 # not use this file except in compliance with the License. You may obtain    #

data/lib/opennebula/marketplaceapp.rb

@@ -1,5 +1,5 @@
 # -------------------------------------------------------------------------- #
-# Copyright 2002-2023, OpenNebula Project, OpenNebula Systems                #
+# Copyright 2002-2021, OpenNebula Project, OpenNebula Systems                #
 #                                                                            #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may    #
 # not use this file except in compliance with the License. You may obtain    #
@@ -14,6 +14,8 @@
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
 
+require 'opennebula/lockable_ext'
+require 'opennebula/marketplaceapp_ext'
 require 'opennebula/pool_element'
 
 module OpenNebula
@@ -47,7 +49,10 @@ module OpenNebula
             'DISABLED'  => 'dis'
         }
 
-        MARKETPLACEAPP_TYPES = %w{UNKNOWN IMAGE VMTEMPLATE SERVICE_TEMPLATE}
+        MARKETPLACEAPP_TYPES = %w{UNKNOWN
+                                  IMAGE
+                                  VMTEMPLATE
+                                  SERVICE_TEMPLATE}
 
         SHORT_MARKETPLACEAPP_TYPES = {
             'UNKNOWN'          => 'unk',
@@ -75,6 +80,8 @@ module OpenNebula
 
         # Class constructor
         def initialize(xml, client)
+            LockableExt.make_lockable(self, MARKETPLACEAPP_METHODS)
+
             super(xml, client)
         end
 
@@ -158,92 +165,6 @@ module OpenNebula
             call(MARKETPLACEAPP_METHODS[:rename], @pe_id, name)
         end
 
-        # Exports this app to a suitable OpenNebula object
-        # @param appid [Integer] id of the marketplace app
-        # @param options [Hash] to control the export behavior
-        #   dsid [Integer] datastore to save images
-        #   name [String] of the new object
-        #   vmtemplate_name [String] name for the VM Template, if the App has one
-        #
-        # @return [Hash, OpenNebula::Error] with the ID and type of the created
-        # objects. Instead of an ID, the array may contain OpenNebula::Error with
-        # specific object creation errors
-        #   { :vm => [ vm ids/OpenNebula::Error ],
-        #     :vmtemplate => [ vmtemplates ids/OpenNebula::Error ],
-        #     :image => [ vm ids/OpenNebula::Error ] }
-        def export(options = {})
-            rc = info
-            return rc if OpenNebula.is_error?(rc)
-            return Error.new('App is not READY') if state_str != 'READY'
-
-            if options[:dsid].nil? && type_str != 'VMTEMPLATE'
-                return Error.new('Missing datastore id')
-            end
-
-            return Error.new('Missing name to export app') if options[:name].nil?
-
-            if !self['APPTEMPLATE64'].nil?
-                tmpl = Base64.decode64(self['APPTEMPLATE64'])
-            else
-                tmpl = ''
-            end
-
-            name = options[:name] || "marketapp-#{id}"
-            options[:vmtemplate_name] = name unless options[:vmtemplate_name]
-
-            tmpl << "\n"
-            tmpl << 'NAME="' << name << "\"\n"
-            tmpl << 'FROM_APP="' << self['ID'] << "\"\n"
-            tmpl << 'URL_ARGS="' << options[:url_args] << "\"\n" if options[:url_args]
-
-            case type_str
-            when 'IMAGE'
-                image = Image.new(Image.build_xml, @client)
-                rc    = image.allocate(tmpl, options[:dsid])
-
-                ds = OpenNebula::Datastore.new_with_id(options[:dsid], @client)
-
-                rc_image = image.info
-                rc_ds    = ds.info
-
-                image_error = OpenNebula.is_error?(rc_image)
-                ds_error    = OpenNebula.is_error?(rc_ds)
-
-                xpath  = 'TEMPLATE/DRIVER'
-                format = self['FORMAT']
-                type   = ds[xpath]
-
-                if !image_error && !ds_error
-                    if type == 'vcenter' && format == 'qcow2'
-                        image.replace('DEV_PREFIX' => 'sd')
-                        image.delete_element('TEMPLATE/FORMAT')
-                        image.delete_element('TEMPLATE/DRIVER')
-
-                        image.update(image.template_like_str("TEMPLATE"))
-                    elsif type == 'vcenter' && format != 'iso' && format != 'vmdk'
-                        image.replace('FORMAT' => 'vmdk')
-                    elsif type && type != 'vcenter' && format == 'vmdk'
-                        image.replace('FORMAT' => type)
-                    end
-                end
-
-                return { :image => [rc] } if OpenNebula.is_error?(rc)
-
-                vmtpl_id = create_vmtemplate(options, image.id)
-
-                return { :image => [image.id], :vmtemplate => [vmtpl_id] }
-
-            when 'VMTEMPLATE'
-                # TODO import all the images associated to a VMTEMPLATE app
-                # current version only support no-image based apps (e.g. hybrid)
-                vmtpl_id = create_vmtemplate(options)
-
-                return { :image => [], :vmtemplate => [vmtpl_id] }
-            else
-                return Error.new("App type #{type_str} not supported")
-            end
-        end
-
         # Enables this app
         def enable
             call(MARKETPLACEAPP_METHODS[:enable], @pe_id, true)
@@ -288,37 +209,6 @@ module OpenNebula
             SHORT_MARKETPLACEAPP_STATES[state_str]
         end
 
-        # Locked a MarketplaceApp
-        def lock(level)
-            call(MARKETPLACEAPP_METHODS[:lock], @pe_id, level)
-        end
-
-        # Unlocked a MarketplaceApp
-        def unlock()
-            call(MARKETPLACEAPP_METHODS[:unlock], @pe_id)
-        end
-
-        private
-
-        # Creates a VM template based on the VMTEMPLATE64 attribute
-        # @return [Integer, OpenNebula::Error] template id or error
-        # TODO this method needs to be extended to support [image_ids]
-        def create_vmtemplate(options, image_id = nil)
-            return -1 if self['TEMPLATE/VMTEMPLATE64'].nil?
-
-            tmpl = Base64.decode64(self['TEMPLATE/VMTEMPLATE64'])
-
-            tmpl << "\nNAME=\"#{options[:vmtemplate_name]}\"\n"
-            tmpl << "DISK=[ IMAGE_ID = #{image_id} ]\n" if image_id
-
-            vmtpl = Template.new(Template.build_xml, @client)
-            rc    = vmtpl.allocate(tmpl)
-
-            return rc if OpenNebula.is_error?(rc)
-
-            vmtpl.id
-        end
-
     end
 
 end