occi-core 4.3.6 → 5.0.0.alpha.1

data/lib/occi/core/parsers/json/entity.rb

@@ -0,0 +1,156 @@
+module Occi
+  module Core
+    module Parsers
+      module Json
+        # Static parsing class responsible for extracting entities from JSON.
+        # Class supports 'application/json' via `json`. No other formats are supported.
+        #
+        # @attr model [Occi::Core::Model, Occi::Infrastructure::Model] model to use as a primary reference point
+        #
+        # @author Boris Parak <parak@cesnet.cz>
+        class Entity
+          include Yell::Loggable
+          include Helpers::ArgumentValidator
+          include Helpers::ErrorHandler
+          extend Helpers::RawJsonParser
+
+          # Constants
+          SINGLE_INSTANCE_TYPES = %i[resource link].freeze
+          MULTI_INSTANCE_TYPES  = %i[entity-collection].freeze
+
+          TYPECASTER_HASH = {
+            IPAddr  => ->(val) { IPAddr.new val },
+            URI     => ->(val) { URI.parse val },
+            Float   => ->(val) { val.to_f },
+            Integer => ->(val) { val.to_i }
+          }.freeze
+
+          attr_reader :model
+
+          # Constructs an instance of the entity parser. Only entities (their kinds) defined by the model are allowed.
+          #
+          # @param args [Hash] constructor arguments in a Hash
+          # @option args [Occi::Core::Model] :model model to use as a primary reference point
+          def initialize(args = {})
+            pre_initialize(args)
+            default_args! args
+
+            @model = args.fetch(:model)
+
+            post_initialize(args)
+          end
+
+          # Builds an entity instances from the lines provided as input.
+          #
+          # @param body [String] JSON body for parsing
+          # @param type [Symbol] `:resource`, `:link`, or `:'entity-collection'`
+          # @return [Array] constructed instances
+          def json(body, type)
+            case type
+            when *SINGLE_INSTANCE_TYPES
+              json_single self.class.raw_hash(body)
+            when *MULTI_INSTANCE_TYPES
+              json_collection self.class.raw_hash(body)
+            else
+              raise Occi::Core::Errors::ParserError, "#{self.class} -> #{type.to_s.inspect} is not a valid type"
+            end
+          end
+
+          # Builds an entity instance from the hash provided as input.
+          #
+          # @param hash [Hash] Hash body for parsing
+          # @return [Array] constructed instances
+          def json_single(hash)
+            instance = @_ib.get hash[:kind], mixins: lookup(hash[:mixins]), actions: lookup(hash[:actions])
+
+            set_attributes! instance.attributes, hash[:attributes]
+            set_links! instance.links, hash[:links] if instance.respond_to?(:links)
+            set_target! instance, hash[:target] if instance.respond_to?(:target)
+
+            Set.new [instance]
+          end
+
+          # Builds entity instances from the hash provided as input.
+          #
+          # @param hash [Hash] Hash body for parsing
+          # @return [Array] constructed instances
+          def json_collection(hash)
+            all = []
+
+            all.concat hash[:resources] if hash[:resources]
+            all.concat hash[:links] if hash[:links]
+            all.map! { |a| json_single(a) }
+
+            Set.new(all).flatten
+          end
+
+          # :nodoc:
+          def lookup(ary)
+            set = Set.new
+            return set if ary.blank?
+            ary.each { |i| set << handle(Occi::Core::Errors::ParsingError) { model.find_by_identifier!(i) } }
+            set
+          end
+
+          # :nodoc:
+          def set_attributes!(attributes, hash)
+            return if hash.blank?
+            hash.each_pair do |name, value|
+              attribute = attributes[name.to_s]
+              unless attribute
+                raise Occi::Core::Errors::ParsingError,
+                      "#{self.class} -> attribute #{name.to_s.inspect} is not allowed for this entity"
+              end
+              attribute.value = typecast(value, attribute.attribute_definition.type)
+            end
+          end
+
+          def set_links!(links, ary)
+            return if ary.blank?
+            ary.each { |l| links << json_single(l).first }
+          end
+
+          # :nodoc:
+          def set_target!(link, hash)
+            return unless link.respond_to?(:target_kind)
+            return if hash.blank? || hash[:kind].blank?
+
+            link.target_kind = lookup([hash[:kind]]).first
+          end
+
+          # :nodoc:
+          def typecast(value, type)
+            if value.nil? || type.nil?
+              raise Occi::Core::Errors::ParsingError,
+                    "#{self.class} -> Cannot typecast (un)set value to (un)set type"
+            end
+            return value unless TYPECASTER_HASH.key?(type)
+
+            TYPECASTER_HASH[type].call(value)
+          end
+
+          protected
+
+          # :nodoc:
+          def sufficient_args!(args)
+            return if args[:model]
+            raise Occi::Core::Errors::MandatoryArgumentError, "Model is a mandatory argument for #{self.class}"
+          end
+
+          # :nodoc:
+          def defaults
+            { model: nil }
+          end
+
+          # :nodoc:
+          def pre_initialize(args); end
+
+          # :nodoc:
+          def post_initialize(_args)
+            @_ib = model.instance_builder
+          end
+        end
+      end
+    end
+  end
+end

data/lib/occi/core/parsers/json/validator/action-instance.json

@@ -0,0 +1,3 @@
+{
+	"$ref": "occi-schema.json#/definitions/action_instance"
+}

data/lib/occi/core/parsers/json/validator/entity-collection.json

@@ -0,0 +1,3 @@
+{
+	"$ref": "occi-schema.json#/definitions/entity_collection"
+}

data/lib/occi/core/parsers/json/validator/link-collection.json

@@ -0,0 +1,3 @@
+{
+	"$ref": "occi-schema.json#/definitions/link_collection"
+}

data/lib/occi/core/parsers/json/validator/link.json

@@ -0,0 +1,3 @@
+{
+	"$ref": "occi-schema.json#/definitions/link"
+}

data/lib/occi/core/parsers/json/validator/locations.json

@@ -0,0 +1,3 @@
+{
+	"$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray"
+}

data/lib/occi/core/parsers/json/validator/mixin-collection.json

@@ -0,0 +1,3 @@
+{
+	"$ref": "occi-schema.json#/definitions/mixin_collection"
+}

data/lib/occi/core/parsers/json/validator/model.json

@@ -0,0 +1,3 @@
+{
+	"$ref": "occi-schema.json#/definitions/model"
+}

data/lib/occi/core/parsers/json/validator/occi-schema.json

@@ -0,0 +1,277 @@
+{
+	"id": "occi-schema.json",
+	"$schema": "http://json-schema.org/draft-04/schema#",
+	"title": "OCCI v1.2 JSON Rendering Schema",
+	"definitions": {
+		"kinded_uri": {
+			"id": "#kinded_uri",
+			"type": "object",
+			"required": ["location"],
+			"additionalProperties": false,
+			"properties": {
+				"location": { "type": "string" },
+				"kind": { "type": "string" }
+			}
+		},
+		"resource": {
+			"id": "#resource",
+			"type": "object",
+			"required": ["kind", "id", "attributes"],
+			"additionalProperties": false,
+			"properties": {
+				"kind": { "type": "string" },
+				"mixins": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray" },
+				"attributes": { "$ref": "#/definitions/attributes" },
+				"actions": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray" },
+				"id": { "type": "string" },
+				"links": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"$ref": "#/definitions/link"
+					}
+				},
+				"summary": { "type": "string" },
+				"title": { "type": "string" }
+			}
+		},
+		"action_instance": {
+			"id": "#action_instance",
+			"type": "object",
+			"required": ["action"],
+			"additionalProperties": false,
+			"properties": {
+				"action": { "type": "string" },
+				"attributes": { "$ref": "#/definitions/attributes" }
+			}
+		},
+		"link": {
+			"id": "#link",
+			"type": "object",
+			"required": ["kind", "id", "target", "source", "attributes"],
+			"additionalProperties": false,
+			"properties": {
+				"kind": { "type": "string" },
+				"mixins": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray" },
+				"attributes": { "$ref": "#/definitions/attributes" },
+				"actions": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray" },
+				"id": { "type": "string" },
+				"source": { "$ref": "#/definitions/kinded_uri" },
+				"target": { "$ref": "#/definitions/kinded_uri" },
+				"title": { "type": "string" }
+			}
+		},
+		"kind": {
+			"id": "#kind",
+			"type": "object",
+			"required": ["term", "scheme", "location"],
+			"additionalProperties": false,
+			"properties": {
+				"term": { "type": "string" },
+				"scheme": { "type": "string" },
+				"title": { "type": "string" },
+				"attributes": { "$ref": "#/definitions/attribute_definitions" },
+				"actions": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray" },
+				"parent": { "type": "string" },
+				"location": { "type": "string" }
+			}
+		},
+		"mixin": {
+			"id": "#mixin",
+			"type": "object",
+			"required": ["term", "scheme", "location"],
+			"additionalProperties": false,
+			"properties": {
+				"term": { "type": "string" },
+				"scheme": { "type": "string" },
+				"title": { "type": "string" },
+				"attributes": { "$ref": "#/definitions/attribute_definitions" },
+				"actions": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray" },
+				"depends": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray" },
+				"applies": { "$ref": "http://json-schema.org/draft-04/schema#/definitions/stringArray" },
+				"location": { "type": "string" }
+			}
+		},
+		"action": {
+			"id": "#action",
+			"type": "object",
+			"required": ["term", "scheme"],
+			"additionalProperties": false,
+			"properties": {
+				"term": { "type": "string" },
+				"scheme": { "type": "string" },
+				"title": { "type": "string" },
+				"attributes": { "$ref": "#/definitions/attribute_definitions" }
+			}
+		},
+		"resource_collection": {
+			"id": "#resource_collection",
+			"type": "object",
+			"required": ["resources"],
+			"additionalProperties": false,
+			"properties": {
+				"resources": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"$ref": "#/definitions/resource"
+					}
+				}
+			}
+		},
+		"link_collection": {
+			"id": "#link_collection",
+			"type": "object",
+			"required": ["links"],
+			"additionalProperties": false,
+			"properties": {
+				"links": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"$ref": "#/definitions/link"
+					}
+				}
+			}
+		},
+		"entity_collection": {
+			"id": "#entity_collection",
+			"type": "object",
+			"additionalProperties": false,
+			"properties": {
+				"resources": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"$ref": "#/definitions/resource"
+					}
+				},
+				"links": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"$ref": "#/definitions/link"
+					}
+				}
+			}
+		},
+		"kind_collection": {
+			"id": "#kind_collection",
+			"type": "object",
+			"required": ["kinds"],
+			"additionalProperties": false,
+			"properties": {
+				"kinds": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"$ref": "#/definitions/kind"
+					}
+				}
+			}
+		},
+		"mixin_collection": {
+			"id": "#mixin_collection",
+			"type": "object",
+			"required": ["mixins"],
+			"additionalProperties": false,
+			"properties": {
+				"mixins": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"$ref": "#/definitions/mixin"
+					}
+				}
+			}
+		},
+		"action_collection": {
+			"id": "#action_collection",
+			"type": "object",
+			"required": ["actions"],
+			"additionalProperties": false,
+			"properties": {
+				"actions": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"$ref": "#/definitions/action"
+					}
+				}
+			}
+		},
+		"attributes": {
+			"id": "#attributes",
+			"type": "object",
+			"additionalProperties": {
+				"oneOf": [
+					{ "type": "number" },
+					{ "type": "boolean" },
+					{ "type": "string" },
+					{ "type": "object" },
+					{ "type": "array" }
+				]
+			}
+		},
+		"attribute_definition": {
+			"id": "#attribute_definition",
+			"type": "object",
+			"additionalProperties": false,
+			"required": ["type", "mutable", "required"],
+			"properties": {
+				"mutable": { "type": "boolean" },
+				"required": { "type": "boolean" },
+				"type": { "type": "string" },
+				"default": {
+					"oneOf": [
+						{ "type": "number" },
+						{ "type": "string" },
+						{ "type": "boolean" },
+						{ "type": "object" },
+						{ "type": "array" }
+					]
+				},
+				"description": { "type": "string" },
+				"pattern": { "type": "string" }
+			}
+		},
+		"attribute_definitions": {
+			"id": "#attribute_definitions",
+			"type": "object",
+			"additionalProperties": false,
+			"patternProperties": {
+				".+": {
+					"$ref": "#/definitions/attribute_definition"
+				}
+			}
+		},
+		"model": {
+			"id": "#model",
+			"type": "object",
+			"additionalProperties": false,
+			"properties": {
+				"mixins": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"$ref": "#/definitions/mixin"
+					}
+				},
+				"kinds": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"$ref": "#/definitions/kind"
+					}
+				},
+				"actions": {
+					"type": "array",
+					"minItems": 1,
+					"items": {
+						"$ref": "#/definitions/action"
+					}
+				}
+			}
+		}
+	}
+}

data/lib/occi/core/parsers/json/validator/resource-collection.json

@@ -0,0 +1,3 @@
+{
+	"$ref": "occi-schema.json#/definitions/resource_collection"
+}

data/lib/occi/core/parsers/json/validator/resource.json

@@ -0,0 +1,3 @@
+{
+	"$ref": "occi-schema.json#definitions/resource"
+}

data/lib/occi/core/parsers/json/validator.rb

@@ -0,0 +1,87 @@
+module Occi
+  module Core
+    module Parsers
+      module Json
+        # Class responsible for validating JSON content before parsing. This should be called from
+        # every parsing class.
+        #
+        # @author Boris Parak <parak@cesnet.cz>
+        class Validator
+          # Repository constants
+          SCHEMA_DIR   = 'validator'.freeze
+          SCHEMA_REPO  = File.join(File.expand_path(File.dirname(__FILE__)), SCHEMA_DIR)
+          BASE_SCHEMAS = %i[occi-schema].freeze
+
+          class << self
+            # Validates given `json` text with the appropriate schema for `type`.
+            # This method raises `Occi::Core::Errors::ParsingError` on failure.
+            #
+            # @param json [String] JSON text to validate
+            # @param type [Symbol] schema selector
+            # @raise [Occi::Core::Errors::ParsingError] on validation failure
+            def validate!(json, type)
+              JSON::Validator.schema_reader = JSON::Schema::Reader.new(accept_uri: false, accept_file: true)
+              JSON::Validator.validate!(schema_for(type), json, json: true)
+            rescue JSON::Schema::JsonParseError, JSON::Schema::ValidationError => e
+              raise Occi::Core::Errors::ParsingError, "#{self} -> #{e.message}"
+            end
+
+            # :nodoc:
+            def validate_model!(json)
+              validate! json, :model
+            end
+
+            # :nodoc:
+            def validate_resource!(json)
+              validate! json, :resource
+            end
+
+            # :nodoc:
+            def validate_link!(json)
+              validate! json, :link
+            end
+
+            # :nodoc:
+            def validate_action_instance!(json)
+              validate! json, :'action-instance'
+            end
+
+            # :nodoc:
+            def validate_entity_collection!(json)
+              validate! json, :'entity-collection'
+            end
+
+            # :nodoc:
+            def validate_link_collection!(json)
+              validate! json, :'link-collection'
+            end
+
+            # :nodoc:
+            def validate_resource_collection!(json)
+              validate! json, :'resource-collection'
+            end
+
+            # :nodoc:
+            def validate_mixin_collection!(json)
+              validate! json, :'mixin-collection'
+            end
+
+            # :nodoc:
+            def validate_locations!(json)
+              validate! json, :locations
+            end
+
+            # :nodoc:
+            def schema_for(type)
+              if type.blank? || BASE_SCHEMAS.include?(type)
+                raise Occi::Core::Errors::ParserError, "Schema type #{type.inspect} is not allowed"
+              end
+              File.join(SCHEMA_REPO, "#{type}.json")
+            end
+            private :schema_for
+          end
+        end
+      end
+    end
+  end
+end