occi-core 4.3.6 → 5.0.0.alpha.1

data/lib/occi/parser/text.rb

@@ -1,280 +0,0 @@
-Dir[File.join(File.dirname(__FILE__), 'text', '*.rb')].each { |file| require file.gsub('.rb', '') }
-
-module Occi
-  module Parser
-    module Text
-
-      class << self
-
-        include Occi::Parser::Text::Constants
-
-        def categories(lines)
-          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.categories"
-          collection = Occi::Collection.new
-
-          block = Proc.new { |line|
-            line.strip!
-            category = category(line) if line.start_with? 'Category:'
-            collection << category if category.kind_of? Occi::Core::Category
-          }
-
-          lines.respond_to?(:each) ? lines.each(&block) : lines.each_line(&block)
-          collection
-        end
-
-        def resource(lines)
-          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.resource"
-          collection = Occi::Collection.new
-          resource = Occi::Core::Resource.new
-          resource.id = nil
-          links = []
-
-          block = Proc.new { |line|
-            line.strip!
-            case line
-            when /^Category:/
-              category = category(line)
-
-              if category.kind_of? Occi::Core::Kind
-                resource = Occi::Core::Resource.new category.type_identifier
-                resource.id = nil
-                resource.kind = category
-              end
-
-              resource.mixins << category if category.kind_of? Occi::Core::Mixin
-            when /^X-OCCI-Attribute:/
-              resource.attributes.merge! attribute(line)
-            when /^Link:/
-              link = link_string(line, resource)
-
-              if link.kind_of? Occi::Core::Link
-                resource.links << link
-                links << link
-              elsif link.kind_of? Occi::Core::Action
-                resource.actions << link
-              else
-                raise Occi::Errors::ParserInputError, "Could not recognize resource link! #{link.inspect}"
-              end
-            end
-          }
-          lines.respond_to?(:each) ? lines.each(&block) : lines.each_line(&block)
-
-          if resource.kind_of?(Occi::Core::Resource) && !resource.empty?
-            collection << resource
-            links.each { |link| collection << link }
-          end
-
-          collection
-        end
-
-        def link(lines)
-          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.link"
-          collection = Occi::Collection.new
-          link = Occi::Core::Link.new
-          link.id = nil
-
-          block = Proc.new { |line|
-            line.strip!
-            case line
-            when /^Category:/
-              category = category(line)
-
-              if category.kind_of? Occi::Core::Kind
-                link = Occi::Core::Link.new category.type_identifier
-                link.id = nil
-                link.kind = category
-              end
-
-              link.mixins << category if category.kind_of? Occi::Core::Mixin
-            when /^X-OCCI-Attribute:/
-              link.attributes.merge! attribute(line)
-            end
-          }
-          lines.respond_to?(:each) ? lines.each(&block) : lines.each_line(&block)
-
-          collection << link if link.kind_of?(Occi::Core::Link) && !link.empty?
-          collection
-        end
-
-        def locations(lines)
-          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.locations"
-          locations = []
-
-          block = Proc.new { |line|
-            line.strip!
-            locations << location(line) if line.start_with? 'X-OCCI-Location:'
-          }
-          lines.respond_to?(:each) ? lines.each(&block) : lines.each_line(&block)
-
-          locations
-        end
-
-        def category(string)
-          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.category"
-          # create regular expression from regexp string
-          regexp = Regexp.new( Occi::Settings.compatibility ?  REGEXP_CATEGORY : REGEXP_CATEGORY_STRICT )
-          # match string to regular expression
-          match = regexp.match string
-
-          raise Occi::Errors::ParserInputError, "Could not match #{string.inspect}" unless match
-
-          term = match[:term].downcase
-          scheme = match[:scheme]
-          title = match[:title]
-          related = match[:rel].to_s.split(/\s+/)
-
-          attributes = category_attributes(match[:attributes])
-          actions = match[:actions].to_s.split
-          location = match[:location]
-
-          case match[:class]
-          when 'kind'
-            Occi::Log.debug "[#{self}] class #{match[:class].inspect} identified as kind"
-            Occi::Core::Kind.new scheme, term, title, attributes, related, actions, location
-          when 'mixin'
-            Occi::Log.debug "[#{self}] class #{match[:class].inspect} identified as mixin"
-            Occi::Core::Mixin.new scheme, term, title, attributes, related, actions, location
-          when 'action'
-            Occi::Log.debug "[#{self}] class #{match[:class].inspect} identified as action"
-            Occi::Core::Action.new scheme, term, title, attributes
-          else
-            raise Occi::Errors::ParserInputError, "Category with class #{match[:class].inspect} not recognized in string: #{string}"
-          end
-        end
-
-        def category_attributes(matched_attributes)
-          attributes = Occi::Core::Attributes.new
-          return attributes unless matched_attributes
-
-          # TODO: find a better approach to fixing split
-          matched_attributes.gsub! /\{(immutable|required)\s+(required|immutable)\}/, '{\1_\2}'
-
-          matched_attributes.split.each do |attribute|
-            attribute.gsub! /\{(immutable|required)_(required|immutable)\}/, '{\1 \2}'
-            property_string = attribute[/#{REGEXP_ATTRIBUTE_DEF}/, -2]
-            properties = Occi::Core::Properties.new
-
-            if property_string
-              properties.required = property_string.include?('required')
-              properties.mutable = !property_string.include?('immutable')
-            end
-
-            name = attribute[/#{REGEXP_ATTRIBUTE_DEF}/, 1]
-            attributes.merge! name.split('.').reverse.inject(properties) { |a, n| Occi::Core::Attributes.new(n => a) }
-          end
-
-          attributes
-        end
-
-        def attribute(string)
-          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.attribute"
-          # create regular expression from regexp string
-          regexp = Regexp.new(REGEXP_ATTRIBUTE)
-          # match string to regular expression
-          match = regexp.match string
-
-          raise Occi::Errors::ParserInputError, "Could not match #{string.inspect}" unless match
-
-          value = match[:string] if match[:string]
-
-          if match[:number]
-            match[:number].include?('.') ? value = match[:number].to_f : value = match[:number].to_i
-          end
-
-          value = match[:bool] == "true" if match[:bool]
-          Occi::Core::Attributes.split match[:name] => value
-        end
-
-        def link_string(string, source)
-          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.link_string"
-          # create regular expression from regexp string
-          regexp = Regexp.new( Occi::Settings.compatibility ? REGEXP_LINK : REGEXP_LINK_STRICT )
-          # match string to regular expression
-          match = regexp.match string
-
-          raise Occi::Errors::ParserInputError, "Could not match #{string.inspect}" unless match
-
-          if match[:uri].include?('?action=')
-            link_string_action match
-          else
-            link_string_link match, source
-          end
-        end
-
-        def link_string_action(match)
-          scheme, term = match[:rel].split('#')
-          Occi::Core::Action.new scheme, term
-        end
-
-        def link_string_link(match, source)
-          target = match[:uri]
-          rel = match[:rel]
-
-          if match[:category].blank?
-            kind = Occi::Core::Link.kind
-          else
-            categories = match[:category].split
-            kind = categories.shift
-            mixins = categories
-          end
-          actions = nil
-          location = match[:self]
-
-          # create an array of the list of attributes
-          attributes = []
-          regexp = Regexp.new '(\\s*'+REGEXP_ATTRIBUTE_REPR.to_s+')'
-          attr_line = match[:attributes].sub(/^\s*;\s*/, ' ')
-          attributes = attr_line.scan(regexp).collect {|matches| matches.first}
-
-          # parse each attribute and create an OCCI Attribute object from it
-          attributes = attributes.inject(Hashie::Mash.new) { |hsh, attribute|
-            hsh.merge!(Occi::Parser::Text.attribute("X-OCCI-Attribute: #{attribute}"))
-          }
-
-          Occi::Core::Link.new kind, mixins, attributes, actions, rel, target, source, location
-        end
-
-        def location(string)
-          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.location"
-          # create regular expression from regexp string
-          regexp = Regexp.new(REGEXP_LOCATION)
-          # match string to regular expression
-          match = regexp.match string
-
-          raise Occi::Errors::ParserInputError, "Could not match #{string.inspect}" unless match
-
-          match[:location]
-        end
-
-        def action(lines)
-          Occi::Log.debug "[#{self}] Parsing through Occi::Parser::Text.action"
-          collection = Occi::Collection.new
-          action_instance = nil
-
-          block = Proc.new { |line|
-            line.strip!
-
-            case line
-            when /^Category:/
-              action_instance = Occi::Core::ActionInstance.new
-              action_instance.action = category(line)
-            when /^X-OCCI-Attribute:/
-              raise Occi::Errors::ParserInputError,
-                    "Line #{line.inspect} arrived out of order!" unless action_instance
-              action_instance.attributes.merge! attribute(line)
-            end
-          }
-          lines.respond_to?(:each) ? lines.each(&block) : lines.each_line(&block)
-
-          unless action_instance.blank?
-            collection << action_instance
-          end
-
-          collection
-        end
-
-      end
-
-    end
-  end
-end

data/lib/occi/parser.rb

@@ -1,144 +0,0 @@
-Dir[File.join(File.dirname(__FILE__), 'parser', '*.rb')].each { |file| require file.gsub('.rb', '') }
-
-module Occi
-  module Parser
-
-    class << self
-
-      OCCI_HEADERS = ['Category', 'Link', 'X-OCCI-Location', 'X-OCCI-Attribute', 'Location'].freeze
-
-      # Parses an OCCI message and extracts OCCI relevant information
-      # @param [String] media_type the media type of the OCCI message
-      # @param [String] body the body of the OCCI message
-      # @param [true, false] category for text/plain and text/occi media types information e.g. from the HTTP request location is needed to determine if the OCCI message includes a category or an entity
-      # @param [Occi::Core::Resource,Occi::Core::Link] entity_type entity type to use for parsing of text plain entities
-      # @param [Hash] header optional header of the OCCI message
-      # @return [Occi::Collection] list consisting of an array of locations and the OCCI object collection
-      def parse(media_type, body, category=false, entity_type=Occi::Core::Resource, header={})
-        Occi::Log.debug "[#{self}] Parsing request data to OCCI Collection"
-        header = headers_to_arys(header)
-
-        Occi::Log.debug "[#{self}] Parsing headers: #{header.inspect}"
-        collection = parse_headers(header, category, entity_type)
-
-        Occi::Log.debug "[#{self}] Parsing #{media_type} from body"
-        coll_body = parse_body(media_type, body || '', category, entity_type)
-        collection.merge! coll_body if coll_body && !coll_body.empty?
-
-        collection
-      end
-
-      def locations(media_type, body, header)
-        locations = []
-        locations << header['Location'] if header['Location'] && !header['Location'].blank?
-        header = headers_to_arys(header)
-
-        Occi::Log.debug "[#{self}] Parsing locations from request headers: #{header.inspect}"
-        locations << Occi::Parser::Text.locations(header)
-
-        Occi::Log.debug "[#{self}] Parsing #{media_type} locations from body"
-        case media_type
-        when 'text/uri-list'
-          locations << body.split("\n")
-        when 'text/plain', nil
-          locations << Occi::Parser::Text.locations(body.split "\n")
-        else
-          nil
-        end
-
-        locations.flatten
-      end
-
-      private
-
-      def parse_headers(header, category, entity_type)
-        if category
-          Occi::Log.debug "[#{self}] Parsing categories from headers"
-          collection = Occi::Parser::Text.categories(header)
-        else
-          if entity_type == Occi::Core::Resource
-            Occi::Log.debug "[#{self}] Parsing a resource from headers"
-            collection = Occi::Parser::Text.resource(header)
-          elsif entity_type == Occi::Core::Link
-            Occi::Log.debug "[#{self}] Parsing a link from headers"
-            collection = Occi::Parser::Text.link(header)
-          elsif entity_type == Occi::Core::ActionInstance
-            Occi::Log.debug "[#{self}] Parsing an action instance from headers"
-            collection = Occi::Parser::Text.action(header)
-          else
-            raise Occi::Errors::ParserTypeError, "Entity type '#{entity_type}' not supported"
-          end
-        end
-
-        collection
-      end
-
-      def parse_body(media_type, body, category, entity_type)
-        collection = Occi::Collection.new
-
-        case media_type
-        when 'text/uri-list'
-          raise Occi::Errors::ParserTypeError, "Type 'text/uri-list' not supported by parse(). Call method #{self}.locations() to parse URI lists"
-        when 'text/occi'
-          Occi::Log.warn "Input type text/occi was passed to the parser in request body. All text/occi content MUST be passed in headers. Request body was not processed. The unprocessed content follows\n#{body}" unless body.blank?
-          nil
-        when 'text/plain', nil
-          collection = parse_body_plain(body, category, entity_type)
-        when 'application/occi+json', 'application/json'
-          collection = Occi::Parser::Json.collection body
-        else
-          raise Occi::Errors::ParserTypeError, "Content type #{media_type} not supported"
-        end
-
-        collection
-      end
-
-      def parse_body_plain(body, category, entity_type)
-        if category
-          collection = Occi::Parser::Text.categories body.split("\n")
-        else
-          if entity_type == Occi::Core::Resource
-            collection = Occi::Parser::Text.resource body.split("\n")
-          elsif entity_type == Occi::Core::Link
-            collection = Occi::Parser::Text.link body.split("\n")
-          elsif entity_type == Occi::Core::ActionInstance
-            collection = Occi::Parser::Text.action body.split("\n")
-          else
-            raise Occi::Errors::ParserTypeError, "Entity type #{entity_type} not supported"
-          end
-        end
-
-        collection
-      end
-
-      def headers_to_arys(header)
-        # remove the HTTP_ prefix if present and capitalize keys
-        header = Hash[header.map { |k, v| [k.gsub('HTTP_', '').capitalize, v] }]
-
-        # normalize different header-passing mechanisms and representations
-        if header['X-OCCI-Location'].blank?
-          header['X-OCCI-Location'] = header['X_occi_location'] unless header['X_occi_location'].blank?
-          header['X-OCCI-Location'] = header['X-occi-location'] unless header['X-occi-location'].blank?
-        end
-
-        if header['X-OCCI-Attribute'].blank?
-          header['X-OCCI-Attribute'] = header['X_occi_attribute'] unless header['X_occi_attribute'].blank?
-          header['X-OCCI-Attribute'] = header['X-occi-attribute'] unless header['X-occi-attribute'].blank?
-        end
-
-        # clean-up
-        header.delete_if { |k, v| v.blank? || !OCCI_HEADERS.include?(k) }
-
-        header = header.map do |k, v|
-          # sometimes header values arrive as single-value arrays!
-          v = v.first if v.kind_of?(Array)
-          v.to_s.split(',').collect { |w| "#{k}: #{w}".strip }
-        end
-
-        header.flatten.sort
-      end
-
-    end
-
-  end
-end

data/lib/occi/settings.rb

@@ -1,10 +0,0 @@
-module Occi
-  class Settings < Settingslogic
-    gem_root = File.expand_path '../../..', __FILE__
-
-    source "#{ENV['HOME']}/.occi" if File.readable?("#{ENV['HOME']}/.occi")
-    source "#{gem_root}/config/occi.yml"
-
-    namespace 'core'
-  end
-end

data/lib/occi/version.rb

@@ -1,3 +0,0 @@
-module Occi
-  VERSION = "4.3.6" unless defined?(::Occi::VERSION)
-end

data/lib/occi-core.rb

@@ -1,53 +0,0 @@
-require 'rubygems'
-
-require 'active_support'
-require 'active_support/core_ext'
-require 'active_support/json'
-require 'active_support/inflector'
-require 'active_support/notifications'
-
-require 'set'
-require 'uri'
-require 'hashie/mash'
-
-require 'logger'
-require 'uuidtools'
-require 'rubygems/package'
-require 'zlib'
-require 'tempfile'
-require 'settingslogic'
-
-require 'occi/extensions/hashie'
-
-require 'occi/helpers/inspect'
-require 'occi/helpers/comparators'
-
-require 'occi/errors'
-require 'occi/settings'
-require 'occi/log'
-require 'occi/version'
-require 'occi/core'
-require 'occi/infrastructure'
-require 'occi/collection'
-require 'occi/parser'
-require 'occi/model'
-
-module Occi
-
-  def kinds
-    Occi::Core::Kinds.new
-  end
-
-  def mixins
-    Occi::Core::Mixins.new
-  end
-
-  def actions
-    Occi::Core::Actions.new
-  end
-
-  # @return [Array] list of Occi::Core::Categories
-  def categories
-    self.kinds + self.mixins + self.actions
-  end
-end

data/spec/helpers/to_plain.rb

@@ -1,39 +0,0 @@
-require 'psych'
-
-class ToPlain < Psych::Visitors::Visitor
-
-  # Scalars are just strings.
-  def visit_Psych_Nodes_Scalar o
-    o.value
-  end
-
-  # Sequences are arrays.
-  def visit_Psych_Nodes_Sequence o
-    o.children.each_with_object([]) do |child, list|
-      list << accept(child)
-    end
-  end
-
-  # Mappings are hashes.
-  def visit_Psych_Nodes_Mapping o
-    o.children.each_slice(2).each_with_object({}) do |(k,v), h|
-      h[accept(k)] = accept(v)
-    end
-  end
-
-  # We also need to handle documents...
-  def visit_Psych_Nodes_Document o
-    accept o.root
-  end
-
-  # ... and streams.
-  def visit_Psych_Nodes_Stream o
-    o.children.map { |c| accept c }
-  end
-
-  # Aliases aren't handles here :-(
-  def visit_Psych_Nodes_Alias o
-    # Not implemented!
-  end
-
-end

data/spec/helpers/yaml_hash.rb

@@ -1,32 +0,0 @@
-require 'hashie'
-
-class YAMLHash < Hashie::Mash
-
-  def load_file fs
-    f = File.open(fs, "rt")
-    self.load f.read
-    f.close
-  end
-
-  def load s
-    lin = s.lines
-    stack = Array.new
-    while (true) do
-      begin 
-        line = lin.next
-      rescue
-        break
-      end
-
-      next if /^---/.match(line)
-
-      currentDepth = line.scan(/^\s*/).first.length / 2
-      while (currentDepth) < stack.length
-        stack.pop
-      end
-
-      stack.push(line.lstrip.chomp.gsub(/\s*$/, "").gsub(/[\*\&]\d+/, "Ptr-Emptied").gsub(/[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}/, "ID-Emptied").gsub(/ ! /, " "))
-      self[stack] = nil
-    end
-  end
-end

data/spec/occi/collection_samples/collection1.json

@@ -1 +0,0 @@
-{"kinds":[{"parent":"http://schemas.ogf.org/occi/core#resource","related":["http://schemas.ogf.org/occi/core#resource"],"actions":["http://schemas.ogf.org/occi/infrastructure/compute/action#start","http://schemas.ogf.org/occi/infrastructure/compute/action#stop","http://schemas.ogf.org/occi/infrastructure/compute/action#restart","http://schemas.ogf.org/occi/infrastructure/compute/action#suspend"],"location":"/compute/","scheme":"http://schemas.ogf.org/occi/infrastructure#","term":"compute","title":"compute resource","attributes":{"occi":{"core":{"id":{"type":"string","pattern":"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}"},"title":{"type":"string","mutable":true,"pattern":".*"},"summary":{"type":"string","mutable":true,"pattern":".*"}},"compute":{"architecture":{"type":"string","mutable":true,"pattern":"x86|x64"},"cores":{"type":"number","mutable":true,"pattern":".*"},"hostname":{"type":"string","mutable":true,"pattern":"(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*"},"memory":{"type":"number","mutable":true,"pattern":".*"},"speed":{"type":"number","mutable":true,"pattern":".*"},"state":{"type":"string","pattern":"inactive|active|suspended|error"}}}}}],"mixins":[{"location":"/mixins/my_mixin/","scheme":"http://example.com/occi/tags#","term":"my_mixin","attributes":{}}],"actions":[{"scheme":"http://schemas.ogf.org/occi/infrastructure/compute/action#","term":"start","attributes":{}}],"resources":[{"kind":"http://schemas.ogf.org/occi/core#resource","attributes":{"occi":{"core":{"id":"d51cc509-e1b7-4796-98a4-ccae05964ea8"}}},"id":"d51cc509-e1b7-4796-98a4-ccae05964ea8"}],"links":[{"kind":"http://schemas.ogf.org/occi/core#link","attributes":{"occi":{"core":{"id":"35e6f510-4617-465d-9f92-e1079b78f420"}}},"id":"35e6f510-4617-465d-9f92-e1079b78f420","rel":"http://schemas.ogf.org/occi/core#link"}],"action":{"action":"http://schemas.ogf.org/occi/core#action_instance"}}

data/spec/occi/collection_samples/directory2/collection2.json

@@ -1 +0,0 @@
-{"kinds":[{"parent":"http://schemas.ogf.org/occi/core#resource","related":["http://schemas.ogf.org/occi/core#resource"],"actions":["http://schemas.ogf.org/occi/infrastructure/storage/action#online","http://schemas.ogf.org/occi/infrastructure/storage/action#offline","http://schemas.ogf.org/occi/infrastructure/storage/action#backup","http://schemas.ogf.org/occi/infrastructure/storage/action#snapshot","http://schemas.ogf.org/occi/infrastructure/storage/action#resize"],"location":"/storage/","scheme":"http://schemas.ogf.org/occi/infrastructure#","term":"storage","title":"storage resource","attributes":{"occi":{"core":{"id":{"type":"string","pattern":"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}"},"title":{"type":"string","mutable":true,"pattern":".*"},"summary":{"type":"string","mutable":true,"pattern":".*"}},"storage":{"size":{"type":"number","mutable":true,"pattern":".*"},"state":{"type":"string","pattern":"online|offline|backup|snapshot|resize|degraded"}}}}}],"mixins":[{"location":"/mixins/another_mixin/","scheme":"http://example.com/occi/tags#","term":"another_mixin","attributes":{}}],"actions":[{"scheme":"http://schemas.ogf.org/occi/infrastructure/compute/action#","term":"stop","attributes":{}}],"resources":[{"kind":"http://schemas.ogf.org/occi/core#resource","attributes":{"occi":{"core":{"id":"556ed1b1-183d-4ece-8649-a2d1a0825cde"}}},"id":"556ed1b1-183d-4ece-8649-a2d1a0825cde"}],"links":[{"kind":"http://schemas.ogf.org/occi/core#link","attributes":{"occi":{"core":{"id":"3dbfbd1e-5fcd-4ad2-98a3-fd167838431d"}}},"id":"3dbfbd1e-5fcd-4ad2-98a3-fd167838431d","rel":"http://schemas.ogf.org/occi/core#link"}],"action":{"action":"http://schemas.ogf.org/occi/core/entity/action#testaction","attributes":{}}}