mirror of
https://github.com/OpenNebula/one.git
synced 2026-11-21 04:12:37 +09:00
435 lines
14 KiB
Ruby
435 lines
14 KiB
Ruby
# -------------------------------------------------------------------------- #
|
|
# Copyright 2010-2013, C12G Labs S.L. #
|
|
# #
|
|
# 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 [Booblean] :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)
|
|
def initialize(opts={})
|
|
@opts = {
|
|
:default_values => true,
|
|
:delete_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)
|
|
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:"\
|
|
"#{schema_object}"
|
|
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;"\
|
|
" SCHEMA: #{schema_value}"
|
|
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
|
|
raise ParseException, "KEY: #{new_body.keys.join(', ')} not"\
|
|
" allowed; SCHEMA: #{schema_object}"
|
|
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;"\
|
|
" SCHEMA: #{schema_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};"\
|
|
" SCHEMA: #{schema_array}"
|
|
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};"\
|
|
" SCHEMA: #{schema_array}"
|
|
end
|
|
end
|
|
|
|
value
|
|
rescue ArgumentError
|
|
raise ParseException, "KEY: '#{schema_key}' must be an Integer;"\
|
|
" SCHEMA: #{schema_array}"
|
|
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;"\
|
|
" SCHEMA: #{schema_null}"
|
|
end
|
|
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
|
|
#
|
|
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)
|
|
else
|
|
body
|
|
end
|
|
else
|
|
raise ParseException, "KEY: '#{schema_key}' must be a String;"\
|
|
" SCHEMA: #{schema_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;"\
|
|
" SCHEMA: #{schema_string} #{$!.message}"
|
|
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(', ')}; SCHEMA: #{schema_string}"
|
|
end
|
|
end
|
|
end
|
|
|
|
end |