opennebula 5.12.13 → 5.13.80.pre

data/lib/opennebula/flow/validator.rb

@@ -0,0 +1,499 @@
+# -------------------------------------------------------------------------- #
+# 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 'uri'
+
+class Hash
+    # Returns a new hash containing the contents of other_hash and the
+    #   contents of self. If the value for entries with duplicate keys
+    #   is a Hash, it will be merged recursively, otherwise it will be that
+    #   of other_hash.
+    #
+    # @param [Hash] other_hash
+    #
+    # @return [Hash] Containing the merged values
+    #
+    # @example Merging two hashes
+    #   h1 = {:a => 3, {:b => 3, :c => 7}}
+    #   h2 = {:a => 22, c => 4, {:b => 5}}
+    #
+    #   h1.deep_merge(h2) #=> {:a => 22, c => 4, {:b => 5, :c => 7}}
+    def deep_merge(other_hash)
+        target = dup
+
+        other_hash.each do |hash_key, hash_value|
+            if hash_value.is_a?(Hash) and self[hash_key].is_a?(Hash)
+                target[hash_key] = self[hash_key].deep_merge(hash_value)
+            elsif hash_value.is_a?(Array) and self[hash_key].is_a?(Array)
+                hash_value.each_with_index { |elem, i|
+                    if self[hash_key][i].is_a?(Hash) and elem.is_a?(Hash)
+                        target[hash_key][i] = self[hash_key][i].deep_merge(elem)
+                    else
+                        target[hash_key] = hash_value
+                    end
+                }
+            else
+                target[hash_key] = hash_value
+            end
+        end
+
+        target
+   end
+end
+
+module Validator
+
+class ParseException < StandardError; end
+class SchemaException < StandardError; end
+
+class Validator
+
+    # @param [Hash] opts the options to validate a body
+    # @option opts [Boolean] :default_values Set default values if the schema
+    #   specifies it (if true)
+    # @option opts [Boolean] :delete_extra_properties If the body contains properties
+    #   not specified in the schema delete them from the body (if true)
+    #   or raise an exception (if false)
+    # @option opts [Boolean] :allow_extra_properties Allow properties
+    #   not specified in the schema
+    def initialize(opts={})
+        @opts = {
+            :default_values => true,
+            :delete_extra_properties => false,
+            :allow_extra_properties => false
+        }.merge(opts)
+    end
+
+    # Recursively validate and modify a JSON body based on a schema.
+    #
+    # @see http://tools.ietf.org/html/draft-zyp-json-schema-03
+    #
+    # @param [Hash, Array, String, nil] body JSON represented as Ruby objects
+    # @param [Hash] schema that will be used to validate
+    # @param [String] key of the body that will be validated in this step
+    #
+    # @return [Hash, Array, String, nil] The modified body
+    #
+    # @raise [SchemaException] If the schema is not correctly defined
+    # @raise [ParseException] if the body does not meet the schema definition
+    #
+    # @example Validate a User
+    #   schema = {
+    #       :type => :object,
+    #       :properties => {
+    #           'username' => {
+    #               :type => :string
+    #           }
+    #       }
+    #   }
+    #
+    #   hash = {
+    #       'username' => 'pepe'
+    #   }
+    #
+    #   Validator.validate!(hash, schema)
+    #   #=> {'username' => 'pepe'}
+    #
+    # @note The parameter body will be modified
+    # @note Schema options supported
+    #   :extends
+    #   :type => [:object, :array, :string, :null]
+    #
+    def validate!(body, schema, key="")
+        if schema[:extends]
+            base_schema = schema.delete(:extends)
+            schema      = base_schema.deep_merge(schema)
+        end
+
+        case schema[:type]
+        when :object  then validate_object(body, schema, key)
+        when :array   then validate_array(body, schema, key)
+        when :string  then validate_string(body, schema, key)
+        when :integer then validate_integer(body, schema, key)
+        when :null    then validate_null(body, schema, key)
+        when :boolean then validate_boolean(body, schema, key)
+        else raise SchemaException, "type #{schema[:type]} is not a valid type"
+        end
+    end
+
+    private
+
+    # Validate an object type
+    #
+    # @param [Hash] body to be validated
+    # @param [Hash] schema_object of the objectto validate the body
+    # @param [String] key of the body that will be validated in this step
+    #
+    # @return [Hash] The modified body
+    #
+    # @raise [ParseException] if the body does not meet the schema definition
+    #
+    # @example Validate with default values
+    #   schema_body = {
+    #       :type => :object,
+    #       :properties => {
+    #           'username' => {
+    #               :type => :string,
+    #               :default => 'def'
+    #           }
+    #       }
+    #
+    #   body = {}
+    #
+    #   Validator.validate_object(body, schema_body)
+    #   #=> {'username' => 'def'}
+    #
+    # @note The parameter body will be modified
+    # @note Schema options supported
+    #   :properties
+    #   :required
+    #   :default
+    #
+    def validate_object(body, schema_object, key)
+        unless body.is_a?(Hash)
+            raise ParseException, "KEY: #{key} must be a Hash; SCHEMA:"
+        end
+
+        new_body = body.dup
+
+        schema_object[:properties].each{ |schema_key, schema_value|
+            body_value = new_body.delete(schema_key)
+
+            if body_value
+                body[schema_key] = validate!(body_value, schema_value,
+                                        schema_key)
+            else
+                if schema_value[:required]
+                    raise ParseException, "KEY: '#{schema_key}' is required;"
+                end
+
+                if @opts[:default_values] && schema_value[:default]
+                    body[schema_key] = schema_value[:default]
+                end
+            end
+        }
+
+        # raise error if body.keys is not empty
+        unless new_body.keys.empty?
+            if @opts[:delete_extra_properties]
+                new_body.keys.each{ |key|
+                    body.delete(key)
+                }
+            else
+                if @opts[:allow_extra_properties]
+                    return body
+                else
+                    raise ParseException, "KEY: #{new_body.keys.join(', ')} not"\
+                        " allowed;"
+                end
+            end
+        end
+
+        body
+    end
+
+    # Validate an array type
+    #
+    # @param [Array] body to be validated
+    # @param [Hash] schema_array of the object to validate the body
+    # @param [String] schema_key of the body that will be validated in this step
+    #
+    # @return [Hash] The modified body
+    #
+    # @raise [ParseException] if the body does not meet the schema definition
+    #
+    # @example Validate array
+    #   schema = {
+    #       :type => :array,
+    #       :items => {
+    #           :type => :string
+    #       }
+    #   }
+    #
+    #   body = ['pepe', 'luis', 'juan']
+    #
+    #   Validator.validate_array(body, schema)
+    #   #=> 'username' => ['pepe', 'luis', 'juan']
+    #
+    # @note The parameter body will be modified
+    # @note Schema options supported
+    #   :items
+    #
+    def validate_array(body, schema_array, schema_key)
+        if body.instance_of?(Array)
+            body.collect { |body_item|
+                validate!(body_item, schema_array[:items], schema_key)
+            }
+        else
+            raise ParseException, "KEY: '#{schema_key}' must be an Array;"
+        end
+    end
+
+    # Validate an integer type
+    #
+    # @param [Array] body to be validated
+    # @param [Hash] schema_array of the object to validate the body
+    # @param [String] schema_key of the body that will be validated in this step
+    #
+    # @return [Hash] The modified body
+    #
+    # @raise [ParseException] if the body does not meet the schema definition
+    #
+    # @example Validate array
+    #   schema = {
+    #       :type => :integer
+    #   }
+    #
+    #   body = 5
+    #
+    #   Validator.validate_integer(body, schema)
+    #   #=> 5
+    #
+    #
+    def validate_integer(body, schema_array, schema_key)
+        value = Integer(body)
+
+        if schema_array[:maximum]
+            excl = schema_array[:exclusiveMaximum]
+            max = schema_array[:maximum]
+            if !(excl ? value < max : value <= max)
+                raise ParseException, "KEY: '#{schema_key}' must be "\
+                    "lower than #{excl ? '' : 'or equal to'} #{max};"
+            end
+        end
+
+        if schema_array[:minimum]
+            excl = schema_array[:exclusiveMinimum]
+            min = schema_array[:minimum]
+            if !(excl ? value > min : value >= min)
+                raise ParseException, "KEY: '#{schema_key}' must be "\
+                    "greater than #{excl ? '' : 'or equal to'} #{min};"
+            end
+        end
+
+        value
+    rescue ArgumentError
+        raise ParseException, "KEY: '#{schema_key}' must be an Integer;"
+    end
+
+    # Validate an null type
+    #
+    # @param [nil] body to be validated
+    # @param [Hash] schema_null of the object to validate the body
+    # @param [String] schema_key of the body that will be validated in this step
+    #
+    # @return [nil]
+    #
+    # @raise [ParseException] if the body is not nil
+    #
+    # @example Validate array
+    #   schema = {
+    #       :type => :null
+    #   }
+    #
+    #   body = nil
+    #
+    #   Validator.validate_null(body, schema)
+    #   #=> nil
+    #
+    #
+    def validate_null(body, schema_null, schema_key)
+        if body != nil
+            raise ParseException, "KEY: '#{schema_key}' is not allowed;"
+        end
+    end
+
+    # Validate an boolean type
+    #
+    # @param [Object] body to be validated
+    # @param [Hash] schema_boolean of the object to validate the body
+    # @param [String] schema_key of the body that will be validated in this step
+    #
+    # @return [nil]
+    #
+    # @raise [ParseException] if the body is not a boolean
+    #
+    # @example Validate array
+    #   schema = {
+    #       :type => :boolean
+    #   }
+    #
+    #   body = true
+    #
+    #   Validator.validate_boolean(body, schema)
+    #   #=> nil
+    #
+    #
+    def validate_boolean(body, schema_boolean, schema_key)
+        if body != true && body != false
+            raise ParseException, "KEY: '#{schema_key}' is not allowed;"
+        end
+
+        body
+    end
+
+    # Validate an string type
+    #
+    # @param [String] body to be validated
+    # @param [Hash] schema_string of the object to validate the body
+    # @param [String] schema_key of the body that will be validated in this step
+    #
+    # @return [String] The modified body
+    #
+    # @raise [ParseException] if the body does not meet the schema definition
+    #
+    # @example Validate array
+    #   schema = {
+    #       :type => :string
+    #   }
+    #
+    #   body = "pepe"
+    #
+    #   Validator.validate_string(body, schema)
+    #   #=> "pepe"
+    #
+    # @note The parameter body will be modified
+    # @note Schema options supported
+    #   :format
+    #   :enum
+    #   :regex
+    #
+    def validate_string(body, schema_string, schema_key)
+        if body.instance_of?(String)
+            if schema_string[:format]
+                check_format(body, schema_string, schema_key)
+            elsif schema_string[:enum]
+                check_enum(body, schema_string, schema_key)
+            elsif schema_string[:regex]
+                check_regex(body, schema_string, schema_key)
+            else
+                body
+            end
+        else
+            raise ParseException, "KEY: '#{schema_key}' must be a String;"
+        end
+    end
+
+    # Validate an string format
+    #
+    # @param [String] body_value to be validated
+    # @param [Hash] schema_string of the object to validate the body
+    # @param [String] schema_key of the body that will be validated in this step
+    #
+    # @return [String] The modified body
+    #
+    # @raise [ParseException] if the body does not meet the schema definition
+    #
+    # @example Validate array
+    #   schema = {
+    #       :type => :string,
+    #       :format => :url
+    #   }
+    #
+    #   body = "http://localhost:4567"
+    #
+    #   Validator.check_format(body, schema)
+    #   #=> "http://localhost:4567"
+    #
+    # @note The parameter body will be modified
+    # @note Schema options supported
+    #   :url
+    #
+    def check_format(body_value, schema_string, schema_key)
+        case schema_string[:format]
+        when :uri
+            begin
+                require 'uri'
+                uri = URI.parse(body_value)
+            rescue
+                raise ParseException, "KEY: '#{schema_key}' must be a valid URL;"
+            end
+
+            body_value
+        end
+
+        body_value
+    end
+
+    # Validate an string enum
+    #
+    # @param [String] body_value to be validated
+    # @param [Hash] schema_string of the object to validate the body
+    # @param [String] schema_key of the body that will be validated in this step
+    #
+    # @return [String] The modified body
+    #
+    # @raise [ParseException] if the body does not meet the schema definition
+    #
+    # @example Validate array
+    #   schema = {
+    #       :type => :string,
+    #       :enum => ['juan', 'luis']
+    #   }
+    #
+    #   body = "juan"
+    #
+    #   Validator.check_enum(body, schema)
+    #   #=> "juan"
+    #
+    # @note The parameter body will be modified
+    # @note Schema options supported
+    #   :enum
+    #
+    def check_enum(body_value, schema_string, schema_key)
+        if schema_string[:enum].include?(body_value)
+            body_value
+        else
+            raise ParseException, "KEY: '#{schema_key}' must be one of"\
+                " #{schema_string[:enum].join(', ')};"
+        end
+    end
+
+    # Validate an string regex
+    #
+    # @param [String] body_value to be validated
+    # @param [Hash] schema_string of the object to validate the body
+    # @param [String] schema_key of the body that will be validated in this step
+    #
+    # @return [String] The modified body
+    #
+    # @raise [ParseException] if the body does not meet the schema definition
+    #
+    # @example Validate array
+    #   schema = {
+    #       :type => :string,
+    #       :regex =>  /^\w+$/
+    #   }
+    #
+    #   body = "juan"
+    #
+    #   Validator.check_regex(body, schema)
+    #   #=> "juan"
+    #
+    # @note The parameter body will be modified
+    # @note Schema options supported
+    #   :enum
+    #
+    def check_regex(body_value, schema_string, schema_key)
+        if schema_string[:regex] =~ body_value
+            body_value
+        else
+            raise ParseException, "KEY: '#{schema_key}' must match regexp #{schema_string[:regex].inspect};"
+        end
+    end
+end
+
+end

data/lib/opennebula/flow.rb

@@ -0,0 +1,23 @@
+# -------------------------------------------------------------------------- #
+# 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 'treetop'
+require 'treetop/version'
+require 'opennebula/flow/grammar'
+require 'opennebula/flow/service_pool'
+require 'opennebula/flow/service_template_pool'
+require 'opennebula/flow/service_template'
+require 'opennebula/flow/validator'

data/lib/opennebula/group.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/group_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/hook.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,7 @@
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
 
+require 'opennebula/lockable_ext'
 require 'opennebula/pool_element'
 
 module OpenNebula
@@ -54,13 +55,15 @@ module OpenNebula
 
         # Class constructor
         def initialize(xml, client)
+            LockableExt.make_lockable(self, HOOK_METHODS)
+
             super(xml, client)
 
             @client = client
         end
 
         #######################################################################
-        # XML-RPC Methods for the Template Object
+        # XML-RPC Methods for the Hook Object
         #######################################################################
 
         # Retrieves the information of the given Hook.
@@ -146,16 +149,6 @@ module OpenNebula
             self['UID'].to_i
         end
 
-        # Lock a Hook
-        def lock(level)
-            call(HOOK_METHODS[:lock], @pe_id, level)
-        end
-
-        # Unlock a Hook
-        def unlock
-            call(HOOK_METHODS[:unlock], @pe_id)
-        end
-
     end
 
 end

data/lib/opennebula/hook_log.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/hook_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/host.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/host_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/image.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,8 +14,9 @@
 # limitations under the License.                                             #
 #--------------------------------------------------------------------------- #
 
-
+require 'opennebula/lockable_ext'
 require 'opennebula/pool_element'
+
 require 'fileutils'
 
 module OpenNebula
@@ -92,9 +93,9 @@ module OpenNebula
 
         # Class constructor
         def initialize(xml, client)
-            super(xml,client)
+            LockableExt.make_lockable(self, IMAGE_METHODS)
 
-            @client = client
+            super(xml,client)
         end
 
         #######################################################################
@@ -102,8 +103,8 @@ module OpenNebula
         #######################################################################
 
         # Retrieves the information of the given Image.
-        def info()
-            super(IMAGE_METHODS[:info], 'IMAGE')
+        def info(decrypt = false)
+            super(IMAGE_METHODS[:info], 'IMAGE', decrypt)
         end
 
         alias_method :info!, :info
@@ -298,14 +299,6 @@ module OpenNebula
             self['GID'].to_i
         end
 
-        def lock(level)
-            return call(IMAGE_METHODS[:lock], @pe_id, level)
-        end
-
-        def unlock()
-            return call(IMAGE_METHODS[:unlock], @pe_id)
-        end
-
         def public?
             if self['PERMISSIONS/GROUP_U'] == "1" || self['PERMISSIONS/OTHER_U'] == "1"
                 true
@@ -314,6 +307,16 @@ module OpenNebula
             end
         end
 
+        def wait_state(state, timeout=120)
+            extend OpenNebula::WaitExt
+
+            rc = wait(state, timeout)
+
+            return Error.new("Timeout expired for state #{state}.") unless rc
+
+            true
+        end
+
     private
 
         def set_enabled(enabled)