occi-core 4.0.0.alpha.1

data/lib/occi/log.rb

@@ -0,0 +1,66 @@
+require 'logger'
+
+module Occi
+  class Log
+
+    include ::Logger::Severity
+
+    attr_reader :logger
+
+    # creates a new OCCI logger
+    # @param [IO,String] log_dev The log device.  This is a filename (String) or IO object (typically +STDOUT+,
+    #  +STDERR+, or an open file).
+    def initialize(log_dev)
+      if log_dev.kind_of? Logger
+        @logger = log_dev
+      else
+        @logger = Logger.new(log_dev)
+      end
+
+      # subscribe to log messages and send to logger
+      @log_subscriber = ActiveSupport::Notifications.subscribe("log") do |name, start, finish, id, payload|
+        @logger.log(payload[:level], payload[:message]) if @logger
+      end
+    end
+
+    def close
+      ActiveSupport::Notifications.unsubscribe(@log_subscriber)
+    end
+
+    # @param [Logger::Severity] severity
+    def level=(severity)
+      @logger.level = severity
+    end
+
+    # @return [Logger::Severity]
+    def level
+      @logger.level
+    end
+
+    # @see info
+    def self.debug(message)
+      ActiveSupport::Notifications.instrument("log", :level => Logger::DEBUG, :message => message)
+    end
+
+    # Log an +INFO+ message
+    # @param [String] message the message to log; does not need to be a String
+    def self.info(message)
+      ActiveSupport::Notifications.instrument("log", :level => Logger::INFO, :message => message)
+    end
+
+    # @see info
+    def self.warn(message)
+      ActiveSupport::Notifications.instrument("log", :level => Logger::WARN, :message => message)
+    end
+
+    # @see info
+    def self.error(message)
+      ActiveSupport::Notifications.instrument("log", :level => Logger::ERROR, :message => message)
+    end
+
+    # @see info
+    def self.fatal(message)
+      ActiveSupport::Notifications.instrument("log", :level => Logger::FATAL, :message => message)
+    end
+  end
+end

data/lib/occi/model.rb

@@ -0,0 +1,86 @@
+module Occi
+  class Model < Occi::Collection
+
+    # @param [Occi::Core::Collection] collection
+    def initialize(collection=nil)
+      super(nil, nil) # model must be empty for model class
+      register_core
+      register_collection collection if collection.kind_of? Occi::Collection
+    end
+
+    def model=(model)
+      # will not assign a model inside a model
+    end
+
+    # register Occi Core categories enitity, resource and link
+    def register_core
+      Occi::Log.info "### Registering OCCI Core categories enitity, resource and link ###"
+      register Occi::Core::Entity.kind
+      register Occi::Core::Resource.kind
+      register Occi::Core::Link.kind
+    end
+
+    # register Occi Infrastructure categories
+    def register_infrastructure
+      Occi::Log.info "### Registering OCCI Infrastructure categories ###"
+      Occi::Infrastructure.categories.each { |category| register category }
+    end
+
+    # register OCCI categories from files
+    #
+    # @param [String] path to a folder containing files which include OCCI collections in JSON format. The path is
+    #  recursively searched for files with the extension .json .
+    # @param [Sting] scheme_base_url base location for provider specific extensions of the OCCI model
+    def register_files(path, scheme_base_url='http://localhost')
+      Occi::Log.info "### Initializing OCCI Model from #{path} ###"
+      Dir.glob(path + '/**/*.json').each do |file|
+        collection = Occi::Collection.new(JSON.parse(File.read(file)))
+        # add location of service provider to scheme if it has a relative location
+        collection.kinds.collect { |kind| kind.scheme = scheme_base_url + kind.scheme if kind.scheme.start_with? '/' } if collection.kinds
+        collection.mixins.collect { |mixin| mixin.scheme = scheme_base_url + mixin.scheme if mixin.scheme.start_with? '/' } if collection.mixins
+        collection.actions.collect { |action| action.scheme = scheme_base_url + action.scheme if action.scheme.start_with? '/' } if collection.actions
+        register_collection collection
+      end
+    end
+
+    # register OCCI categories from OCCI collection
+    def register_collection(collection)
+      collection.kinds.each { |kind| kind.model = self }
+      collection.mixins.each { |mixin| mixin.model = self }
+      collection.actions.each { |action| action.model = self }
+      merge! collection
+    end
+
+    # clear all entities from all categories
+    def reset()
+      categories.each { |category| category.entities = [] if category.respond_to? :entities }
+    end
+
+    # @param [Occi::Core::Category] category
+    def register(category)
+      Occi::Log.debug "### Registering category #{category}"
+      # add model to category as back reference
+      category.model = self
+      @kinds << category unless get_by_id(category.to_s) if category.class.ancestors.include? Occi::Core::Kind
+      @mixins << category unless get_by_id(category.to_s) if category.class.ancestors.include? Occi::Core::Mixin
+      @actions << category unless get_by_id(category.to_s) if category.class.ancestors.include? Occi::Core::Action
+    end
+
+    # @param [Occi::Core::Category] category
+    def unregister(category)
+      Occi::Log.debug "### Unregistering category #{category.type_identifier}"
+      @kinds.delete category
+      @mixins.delete category
+      @actions.delete category
+    end
+
+    # Return all categories from model. If filter is present, return only the categories specified by filter
+    #
+    # @param [Occi::Collection,Occi::Core::Category,String] filter
+    # @return [Occi::Collection] collection
+    def get(filter = nil)
+      filter ? self.get_related_to(filter) : self
+    end
+
+  end
+end

data/lib/occi/parser/json.rb

@@ -0,0 +1,34 @@
+module Occi
+  module Parser
+    module Json
+      # @param [String] string
+      # @return [Occi::Collection]
+      def self.collection(string)
+        collection = Occi::Collection.new
+        hash = Hashie::Mash.new(JSON.parse(string))
+        collection.kinds.merge hash.kinds.collect { |kind| Occi::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) } if hash.kinds
+        collection.mixins.merge hash.mixins.collect { |mixin| Occi::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) } if hash.mixins
+        collection.actions.merge hash.actions.collect { |action| Occi::Core::Action.new(action.scheme, action.term, action.title, action.attributes) } if hash.actions
+        collection.resources.merge hash.resources.collect { |resource| Occi::Core::Resource.new(resource.kind, resource.mixins, resource.attributes, resource.actions, resource.links) } if hash.resources
+        collection.links.merge hash.links.collect { |link| Occi::Core::Link.new(link.kind, link.mixins, link.attributes, [], nil, link.target) } if hash.links
+
+        if collection.resources.size == 1 && collection.links.size > 0
+          if collection.resources.first.links.empty?
+            collection.links.each { |link| link.source = collection.resources.first }
+            collection.resources.first.links = collection.links
+          end
+        end
+
+        # TODO: replace the following mechanism with one in the Links class
+        # replace link locations with link objects in all resources
+        collection.resources.each do |resource|
+          resource.links.collect! do |resource_link|
+            lnk = collection.links.select { |link| resource_link == link.to_s }.first
+            lnk ||= resource_link
+          end
+        end
+        collection
+      end
+    end
+  end
+end

data/lib/occi/parser/ova.rb

@@ -0,0 +1,35 @@
+module Occi
+  module Parser
+    module Ova
+
+      # @param [String] string
+      # @return [Occi::Collection]
+      def self.collection(string)
+        tar = Gem::Package::TarReader.new(StringIO.new(string))
+        ovf = mf = cert = nil
+        files = {}
+        tar.each do |entry|
+          tempfile = Tempfile.new(entry.full_name)
+          tempfile.write(entry.read)
+          tempfile.close
+          files[entry.full_name] = tempfile.path
+          ovf = tempfile.path if entry.full_name.end_with? '.ovf'
+          mf = tempfile.path if entry.full_name.end_with? '.mf'
+          cert = tempfile.path if entry.full_name.end_with? '.cert'
+        end
+
+        File.read(mf).each_line do |line|
+          name = line.scan(/SHA1\(([^\)]*)\)= (.*)/).flatten.first
+          sha1 = line.scan(/SHA1\(([^\)]*)\)= (.*)/).flatten.last
+          Occi::Log.debug "SHA1 hash #{Digest::SHA1.hexdigest(files[name])}"
+          raise "SHA1 mismatch for file #{name}" if Digest::SHA1.hexdigest(File.read(files[name])) != sha1
+        end if mf
+
+        raise 'no ovf file found' if ovf.nil?
+
+        Occi::Parser::Ovf.collection(File.read(ovf), files)
+      end
+
+    end
+  end
+end

data/lib/occi/parser/ovf.rb

@@ -0,0 +1,154 @@
+module Occi
+  module Parser
+    module Ovf
+
+      # Declaring Class constants for OVF XML namespaces (defined in OVF specification ver.1.1)
+      OVF ="http://schemas.dmtf.org/ovf/envelope/1"
+      RASD ="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"
+      VSSD ="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData"
+      OVFENV="http://schemas.dmtf.org/ovf/environment/1"
+      CIM ="http://schemas.dmtf.org/wbem/wscim/1/common"
+
+      # @param [String] string
+      # @param [Hash] files key value pairs of file names and paths to the file
+      def self.collection(string, files={})
+        collection = Occi::Collection.new
+        doc = Nokogiri::XML(string)
+        references = {}
+
+        doc.xpath('envelope:Envelope/envelope:References/envelope:File', 'envelope' => "#{OVF}").each do |file|
+          href = URI.parse(file.attributes['href'].to_s)
+          if href.relative?
+            if files[href.to_s]
+              references[file.attributes['id'].to_s] = 'file://' + files[href.to_s]
+            else
+              references[file.attributes['id'].to_s] = 'file://' + href.to_s
+            end
+          else
+            references[file.attributes['id'].to_s] = href.to_s
+          end
+        end
+
+        doc.xpath('envelope:Envelope/envelope:DiskSection/envelope:Disk', 'envelope' => "#{OVF}").each do |disk|
+          storage = Occi::Core::Resource.new('http://schemas.ogf.org/occi/infrastructure#storage')
+          if disk.attributes['fileRef']
+            storagelink = Occi::Core::Link.new("http://schemas.ogf.org/occi/infrastructure#storagelink")
+            storagelink.attributes.occi!.core!.title = disk.attributes['fileRef'].to_s
+            storagelink.attributes.occi!.core!.target = references[disk.attributes['fileRef'].to_s]
+            storage.attributes.occi!.core!.title = disk.attributes['diskId'].to_s
+            storage.links << storagelink
+          else
+            #OCCI accepts storage size in GB
+            #OVF ver 1.1: The capacity of a virtual disk shall be specified by the ovf:capacity attribute with an xs:long integer
+            #value. The default unit odf allocation shall be bytes. The optional string attribute
+            #ovf:capacityAllocationUnits may be used to specify a particular unit of allocation.
+            alloc_units = disk.attributes['capacityAllocationUnits'].to_s
+            if alloc_units.empty?
+              # The capacity is defined in bytes , convert to GB and pass it to OCCI
+              capacity = disk.attributes['capacity'].to_s
+              capacity =capacity.to_i
+            else
+              alloc_unit_bytes = self.alloc_units_bytes(alloc_units)
+              capacity = self.calculate_capacity_bytes(disk.attributes['capacity'].to_s, alloc_unit_bytes)
+            end
+            capacity_gb = self.calculate_capacity_gb(capacity)
+            Occi::Log.debug('capacity in gb ' + capacity_gb.to_s)
+            storage.attributes.occi!.storage!.size = capacity_gb.to_s if capacity_gb
+            storage.attributes.occi!.core!.title = disk.attributes['diskId'].to_s if disk.attributes['diskId']
+          end
+          collection.resources << storage
+        end
+
+        doc.xpath('envelope:Envelope/envelope:NetworkSection/envelope:Network', 'envelope' => "#{OVF}").each do |nw|
+          network = Occi::Core::Resource.new('http://schemas.ogf.org/occi/infrastructure#network')
+          network.attributes.occi!.core!.title = nw.attributes['name'].to_s
+          collection.resources << network
+        end
+
+        # Iteration through all the virtual hardware sections,and a sub-iteration on each Item defined in the Virtual Hardware section
+        doc.xpath('envelope:Envelope/envelope:VirtualSystem', 'envelope' => "#{OVF}").each do |virtsys|
+          compute = Occi::Core::Resource.new('http://schemas.ogf.org/occi/infrastructure#compute')
+
+          doc.xpath('envelope:Envelope/envelope:VirtualSystem/envelope:VirtualHardwareSection', 'envelope' => "#{OVF}").each do |virthwsec|
+            compute.attributes.occi!.core!.summary = virthwsec.xpath("item:Info/text()", 'item' => "#{RASD}").to_s
+
+            virthwsec.xpath('envelope:Item', 'envelope' => "#{OVF}").each do |resource_alloc|
+              resType = resource_alloc.xpath("item:ResourceType/text()", 'item' => "#{RASD}")
+              case resType.to_s
+                # 4 is the ResourceType for memory in the CIM_ResourceAllocationSettingData
+                when "4" then
+                  Occi::Log.debug('calculating memory in gb ')
+                  alloc_units = resource_alloc.xpath("item:AllocationUnits/text()", 'item' => "#{RASD}").to_s
+                  Occi::Log.debug('allocated units in ovf file: ' + alloc_units)
+                  alloc_unit_bytes = self.alloc_units_bytes(alloc_units)
+                  capacity = self.calculate_capacity_bytes(resource_alloc.xpath("item:VirtualQuantity/text()", 'item' => "#{RASD}").to_s, alloc_unit_bytes)
+                  capacity_gb = self.calculate_capacity_gb(capacity)
+                  Occi::Log.debug('virtual quantity of memory configured in gb: ' + capacity_gb.to_s)
+                  compute.attributes.occi!.compute!.memory = capacity_gb
+                #  compute.attributes.occi!.compute!.memory = resource_alloc.xpath("item:VirtualQuantity/text()", 'item' => "#{RASD}").to_s.to_i
+                # 3 is the ResourceType for processor in the CIM_ResourceAllocationSettingData
+                when "3" then
+                  compute.attributes.occi!.compute!.cores = resource_alloc.xpath("item:VirtualQuantity/text()", 'item' => "#{RASD}").to_s.to_i
+                when "10" then
+                  networkinterface = Occi::Core::Link.new('http://schemas.ogf.org/occi/infrastructure#networkinterface')
+                  networkinterface.attributes.occi!.core!.title = resource_alloc.xpath("item:ElementName/text()", 'item' => "#{RASD}").to_s
+                  id = resource_alloc.xpath("item:Connection/text()", 'item' => "#{RASD}").to_s
+                  network = collection.resources.select { |resource| resource.attributes.occi!.core!.title.to_s == id }.first
+                  raise "Network with id #{id} not found" unless network
+                  networkinterface.attributes.occi!.core!.target = network
+                when "17" then
+                  storagelink = Occi::Core::Link.new("http://schemas.ogf.org/occi/infrastructure#storagelink")
+                  storagelink.attributes.occi!.core!.title = resource_alloc.xpath("item:ElementName/text()", 'item' => "#{RASD}").to_s
+                  # extract the mountpoint
+                  host_resource = resource_alloc.xpath("item:HostResource/text()", 'item' => "#{RASD}").to_s
+                  if host_resource.start_with? 'ovf:/disk/'
+                    id = host_resource.gsub('ovf:/disk/', '')
+                    storage = collection.resources.select { |resource| resource.attributes.occi!.core!.title.to_s == id }.first
+                    raise "Disk with id #{id} not found" unless storage
+                    storagelink.attributes.occi!.core!.target = storage
+                  elsif host_resource.start_with? 'ovf:/file/'
+                    id = host_resource.gsub('ovf:/file/', '')
+                    storagelink.attributes.occi!.core!.target = references[id]
+                  end
+                  compute.links << storagelink
+              end
+              ##Add the cpu architecture
+              #system_sec                                      = virthwsec.xpath('envelope:System', 'envelope' => "#{OVF}")
+              #virtsys_type                                    = system_sec.xpath('vssd_:VirtualSystemType/text()', 'vssd_' => "#{VSSD}")
+              #compute.attributes.occi!.compute!.architecture = virtsys_type
+            end
+          end
+          collection.resources << compute
+        end
+        collection
+      end
+
+      ####################Helper method for calculation of storage size based on allocation units configured###########
+
+      def self.calculate_capacity_bytes(capacity, alloc_units_bytes)
+        total_capacity_bytes = alloc_units_bytes * capacity.to_i
+        total_capacity_bytes
+      end
+
+
+      def self.calculate_capacity_gb(capacity)
+        capacity_gb = capacity.to_f/(2**30)
+        capacity_gb
+      end
+
+
+      def self.alloc_units_bytes(alloc_units)
+        units = alloc_units.split('*')
+        #check units[1] is nil??
+        units[1].strip!
+        alloc_vars = units[1].split('^')
+        alloc_units_bytes = (alloc_vars[0].to_i**alloc_vars[1].to_i)
+        alloc_units_bytes
+      end
+
+      ###############End of Helper methods for OVF Parsing ##################################################################
+
+
+    end
+  end
+end

data/lib/occi/parser/text.rb

@@ -0,0 +1,234 @@
+module Occi
+  module Parser
+    module Text
+      # Backwards compatibility for Ruby 1.8.7 and named groups in regular expressions
+      if RUBY_VERSION =~ /1.8/
+        require 'oniguruma'
+        REGEXP = Oniguruma::ORegexp
+      else
+        REGEXP = Regexp
+      end
+
+      # Regular expressions
+      REGEXP_QUOTED_STRING = /([^"\\]|\\.)*/
+      REGEXP_LOALPHA = /[a-z]/
+      REGEXP_DIGIT = /[0-9]/
+      REGEXP_INT = /#{REGEXP_DIGIT}*/
+      REGEXP_FLOAT = /#{REGEXP_DIGIT}*\.#{REGEXP_DIGIT}*/
+      REGEXP_NUMBER = /#{REGEXP_INT}|#{REGEXP_FLOAT}/
+      REGEXP_BOOL = /true|false/
+
+      # Regular expressions for OCCI
+      if Occi::Settings.compatibility
+        # Compatibility with terms starting with a number
+        REGEXP_TERM = /(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT})(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT}|-|_)*/
+      else
+        REGEXP_TERM = /#{REGEXP_LOALPHA}(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT}|-|_)*/
+      end
+      REGEXP_SCHEME = /#{URI::ABS_URI_REF}#/
+      REGEXP_TYPE_IDENTIFIER = /#{REGEXP_SCHEME}#{REGEXP_TERM}/
+      REGEXP_CLASS = /action|mixin|kind/
+
+      REGEXP_ATTR_COMPONENT = /#{REGEXP_LOALPHA}(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT}|-|_)*/
+      REGEXP_ATTRIBUTE_NAME = /#{REGEXP_ATTR_COMPONENT}(\.#{REGEXP_ATTR_COMPONENT})*/
+      REGEXP_ATTRIBUTE_PROPERTY = /immutable|required/
+      REGEXP_ATTRIBUTE_DEF = /(#{REGEXP_ATTRIBUTE_NAME})(\{#{REGEXP_ATTRIBUTE_PROPERTY}(\s+#{REGEXP_ATTRIBUTE_PROPERTY})*\})?/
+      REGEXP_ATTRIBUTE_LIST = /#{REGEXP_ATTRIBUTE_DEF}(\s+#{REGEXP_ATTRIBUTE_DEF})*/
+      REGEXP_ATTRIBUTE_REPR = /#{REGEXP_ATTRIBUTE_NAME}=("#{REGEXP_QUOTED_STRING}"|#{REGEXP_NUMBER}|#{REGEXP_BOOL})/
+
+      REGEXP_ACTION = /#{REGEXP_TYPE_IDENTIFIER}/
+      REGEXP_ACTION_LIST = /#{REGEXP_ACTION}(\s+#{REGEXP_ACTION})*/
+
+      REGEXP_RESOURCE_TYPE = /#{REGEXP_TYPE_IDENTIFIER}(\s+#{REGEXP_TYPE_IDENTIFIER})*/
+      REGEXP_LINK_INSTANCE = /#{URI::URI_REF}/
+      REGEXP_LINK_TYPE = /#{REGEXP_TYPE_IDENTIFIER}(\s+#{REGEXP_TYPE_IDENTIFIER})*/
+
+      # Regular expression for OCCI Categories
+      if Occi::Settings.compatibility
+        REGEXP_CATEGORY = "Category:\\s*(?<term>#{REGEXP_TERM})" << # term (mandatory)
+            ";\\s*scheme=\"(?<scheme>#{REGEXP_SCHEME})#{REGEXP_TERM}?\"" << # scheme (mandatory)
+            ";\\s*class=\"(?<class>#{REGEXP_CLASS})\"" << # class (mandatory)
+            "(;\\s*title=\"(?<title>#{REGEXP_QUOTED_STRING})\")?" << # title (optional)
+            "(;\\s*rel=\"(?<rel>#{REGEXP_TYPE_IDENTIFIER})\")?"<< # rel (optional)
+            "(;\\s*location=\"(?<location>#{URI::URI_REF})\")?" << # location (optional)
+            "(;\\s*attributes=\"(?<attributes>#{REGEXP_ATTRIBUTE_LIST})\")?" << # attributes (optional)
+            "(;\\s*actions=\"(?<actions>#{REGEXP_ACTION_LIST})\")?" << # actions (optional)
+            ';?' # additional semicolon at the end (not specified, for interoperability)
+      else
+        REGEXP_CATEGORY = "Category:\\s*(?<term>#{REGEXP_TERM})" << # term (mandatory)
+            ";\\s*scheme=\"(?<scheme>#{REGEXP_SCHEME})\"" << # scheme (mandatory)
+            ";\\s*class=\"(?<class>#{REGEXP_CLASS})\"" << # class (mandatory)
+            "(;\\s*title=\"(?<title>#{REGEXP_QUOTED_STRING})\")?" << # title (optional)
+            "(;\\s*rel=\"(?<rel>#{REGEXP_TYPE_IDENTIFIER})\")?"<< # rel (optional)
+            "(;\\s*location=\"(?<location>#{URI::URI_REF})\")?" << # location (optional)
+            "(;\\s*attributes=\"(?<attributes>#{REGEXP_ATTRIBUTE_LIST})\")?" << # attributes (optional)
+            "(;\\s*actions=\"(?<actions>#{REGEXP_ACTION_LIST})\")?" << # actions (optional)
+            ';?' # additional semicolon at the end (not specified, for interoperability)
+      end
+
+      # Regular expression for OCCI Link Instance References
+      REGEXP_LINK = "Link:\\s*\\<(?<uri>#{URI::URI_REF})\\>" << # uri (mandatory)
+          ";\\s*rel=\"(?<rel>#{REGEXP_RESOURCE_TYPE})\"" << # rel (mandatory)
+          "(;\\s*self=\"(?<self>#{REGEXP_LINK_INSTANCE})\")?" << # self (optional)
+          "(;\\s*category=\"(?<category>#{REGEXP_LINK_TYPE})\")?" << # category (optional)
+          "(?<attributes>(;\\s*(#{REGEXP_ATTRIBUTE_REPR}))*)" << # attributes (optional)
+          ';?' # additional semicolon at the end (not specified, for interoperability)
+
+      # Regular expression for OCCI Entity Attributes
+      REGEXP_ATTRIBUTE = "X-OCCI-Attribute:\\s*(?<name>#{REGEXP_ATTRIBUTE_NAME})=(\"(?<string>#{REGEXP_QUOTED_STRING})\"|(?<number>#{REGEXP_NUMBER})|(?<bool>#{REGEXP_BOOL}))" <<
+          ';?' # additional semicolon at the end (not specified, for interoperability)
+
+      # Regular expression for OCCI Location
+      REGEXP_LOCATION = "X-OCCI-Location:\\s*(?<location>#{URI::URI_REF})" <<
+          ';?' # additional semicolon at the end (not specified, for interoperability)
+
+
+      def self.categories(lines)
+        collection = Occi::Collection.new
+        lines.each do |line|
+          line.strip!
+          category = self.category(line) if line.start_with? 'Category:'
+          collection << category if category.kind_of? Occi::Core::Category
+        end
+        collection
+      end
+
+      def self.resource(lines)
+        collection = Occi::Collection.new
+        resource = Occi::Core::Resource.new
+        lines.each do |line|
+          line.strip!
+          case line
+            when /^Category:/
+              category = self.category(line)
+              resource.kind = category if category.kind_of? Occi::Core::Kind
+              resource.mixins << category if category.kind_of? Occi::Core::Mixin
+            when /^X-OCCI-Attribute:/
+              resource.attributes.merge! self.attribute(line)
+            when /^Link:/
+              resource.links << self.link_string(line, resource)
+          end
+        end
+        collection << resource if resource.kind_of? Occi::Core::Resource
+        collection
+      end
+
+      def self.link(lines)
+        collection = Occi::Collection.new
+        link = Occi::Core::Link.new
+        lines.each do |line|
+          line.strip!
+          case line
+            when /^Category:/
+              category = self.category(line)
+              link.kind = category if category.kind_of? Occi::Core::Kind
+              link.mixins << category if category.kind_of? Occi::Core::Mixin
+            when /^X-OCCI-Attribute:/
+              link.attributes.merge! self.attribute(line)
+          end
+        end
+        collection << link if link.kind_of? Occi::Core::Link
+        collection
+      end
+
+      def self.locations(lines)
+        locations = []
+        lines.each do |line|
+          line.strip!
+          locations << self.location(line) if line.start_with? 'X-OCCI-Location:'
+        end
+        locations
+      end
+
+      private
+
+      def self.category(string)
+        # create regular expression from regexp string
+        regexp = REGEXP.new(REGEXP_CATEGORY)
+        # match string to regular expression
+        match = regexp.match string
+
+        raise "could not match #{string}" unless match
+
+        term = match[:term]
+        scheme = match[:scheme]
+        title = match[:title]
+        related = match[:rel].to_s.split
+        attributes = Occi::Core::Attributes.new
+        if match[:attributes]
+          match[:attributes].split.each do |attribute|
+            property_string = attribute[/#{REGEXP_ATTRIBUTE_DEF}/, -2]
+            properties = Occi::Core::Properties.new
+            if property_string
+              properties.required = true if property_string.include? 'required'
+              properties.mutable = false if 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
+        end
+        actions = match[:actions].to_s.split
+        location = match[:location]
+        case match[:class]
+          when 'kind'
+            Occi::Core::Kind.new scheme, term, title, attributes, related, actions, location
+          when 'mixin'
+            Occi::Core::Mixin.new scheme, term, title, attributes, related, actions, location
+          when 'action'
+            Occi::Core::Action.new scheme, term, title, attributes
+          else
+            raise "Category with class #{match[:class]} not recognized in string: #{string}"
+        end
+      end
+
+      def self.attribute(string)
+        # create regular expression from regexp string
+        regexp = REGEXP.new(REGEXP_ATTRIBUTE)
+        # match string to regular expression
+        match = regexp.match string
+
+        raise "could not match #{string}" unless match
+
+        value = match[:string] if match[:string]
+        value = match[:number].to_i if match[:number]
+        value = match[:bool] == "true" if match[:bool]
+        Occi::Core::Attributes.split match[:name] => value
+      end
+
+      def self.link_string(string, source)
+        # create regular expression from regexp string
+        regexp = REGEXP.new(REGEXP_LINK)
+        # match string to regular expression
+        match = regexp.match string
+
+        raise "could not match #{string}" unless match
+
+        categories = match[:category].split
+        kind = categories.shift
+        mixins = categories
+        actions = nil
+        rel = match[:rel]
+        target = match[:uri]
+        location = match[:self]
+
+        # create an array of the list of attributes
+        attributes = match[:attributes].sub(/^\s*;\s*/, '').split ';'
+        # 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 self.location(string)
+        # create regular expression from regexp string
+        regexp = REGEXP.new(REGEXP_LOCATION)
+        # match string to regular expression
+        match = regexp.match string
+
+        raise "could not match #{string}" unless match
+
+        match[:location]
+      end
+
+    end
+  end
+end

data/lib/occi/parser/xml.rb

@@ -0,0 +1,18 @@
+module Occi
+  module Parser
+    module Xml
+      # @param [String] string
+      # @return [Occi::Collection]
+      def self.collection(string)
+        collection = Occi::Collection.new
+        hash = Hashie::Mash.new(Hash.from_xml(Nokogiri::XML(string)))
+        collection.kinds.merge hash.kinds.collect { |kind| Occi::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) } if hash.kinds
+        collection.mixins.merge hash.mixins.collect { |mixin| Occi::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) } if hash.mixins
+        collection.actions.merge hash.actions.collect { |action| Occi::Core::Action.new(action.scheme, action.term, action.title, action.attributes) } if hash.actions
+        collection.resources.merge hash.resources.collect { |resource| Occi::Core::Resource.new(resource.kind, resource.mixins, resource.attributes, resource.actions, resource.links) } if hash.resources
+        collection.links.merge hash.links.collect { |link| Occi::Core::Link.new(link.kind, link.mixins, link.attributes) } if hash.links
+        collection
+      end
+    end
+  end
+end