occi 2.5.19 → 3.0.0.beta.0

data/lib/occi/infrastructure/storagelink.rb

@@ -0,0 +1,73 @@
+module Occi
+  module Infrastructure
+    class Storagelink < Occi::Core::Link
+
+      class Online < Occi::Core::Action
+        def initialize(scheme='http://schemas.ogf.org/occi/infrastructure/storagelink/action#',
+            term='online',
+            title='activate storagelink')
+          super
+        end
+      end
+
+      class Offline < Occi::Core::Action
+        def initialize(scheme='http://schemas.ogf.org/occi/infrastructure/storagelink/action#',
+            term='offline',
+            title='deactivate storagelink')
+          super
+        end
+      end
+
+      def self.actions
+        Occi::Core::Actions.new << Online.new << Offline.new
+      end
+
+      begin
+      @kind = Occi::Core::Kind.new('http://schemas.ogf.org/occi/infrastructure#', 'storagelink')
+
+      @kind.title = "storage link"
+
+      @kind.related << Occi::Core::Link.kind
+
+      @kind.attributes.occi!.storagelink!.deviceid = Occi::Core::AttributeProperties.new(
+          { :mutable => true })
+
+      @kind.attributes.occi!.storagelink!.mountpoint = Occi::Core::AttributeProperties.new(
+          { :mutable => true })
+
+      @kind.attributes.occi!.storagelink!.state = Occi::Core::AttributeProperties.new(
+          { :pattern => 'active|inactive|error',
+            :default => 'inactive' })
+
+      @kind.location = '/storagelink/'
+
+      @kind.actions = self.actions
+      end
+
+      def deviceid
+        @attributes.occi.storagelink.deviceid if @attributes.occi.storagelink if @attributes.occi
+      end
+
+      def deviceid=(deviceid)
+        @attributes.occi!.storagelink!.deviceid = deviceid
+      end
+
+      def mountpoint
+        @attributes.occi.storagelink.mountpoint if @attributes.occi.storagelink if @attributes.occi
+      end
+
+      def mountpoint=(mountpoint)
+        @attributes.occi!.storagelink!.mountpoint = mountpoint
+      end
+
+      def state
+        @attributes.occi.storagelink.state if @attributes.occi.storagelink if @attributes.occi
+      end
+
+      def state=(state)
+        @attributes.occi!.storagelink!.state = state
+      end
+
+    end
+  end
+end

data/lib/occi/log.rb

@@ -1,6 +1,6 @@
 require 'logger'
 
-module OCCI
+module Occi
   class Log
 
     include ::Logger::Severity
@@ -19,10 +19,14 @@ module OCCI
 
       # 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])
+        @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

data/lib/occi/model.rb

@@ -1,31 +1,29 @@
-require 'hashie/mash'
-require 'occi/log'
+module Occi
+  class Model < Occi::Collection
 
-module OCCI
-  class Model
-    attr_accessor :categories
-    attr_accessor :locations
-
-    # @param [OCCI::Core::Collection] collection
+    # @param [Occi::Core::Collection] collection
     def initialize(collection=nil)
-      @categories = { }
-      @locations  = { }
+      super(nil, nil) # model must be empty for model class
       register_core
-      register_collection collection if collection.kind_of? OCCI::Collection
+      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
+    # 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_definition
-      register OCCI::Core::Resource.kind_definition
-      register OCCI::Core::Link.kind_definition
+      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
+    # register Occi Infrastructure categories
     def register_infrastructure
-      OCCI::Log.info "### Registering OCCI Infrastructure categories ###"
-      register_files  File.dirname(__FILE__) + '/../../etc/model/infrastructure'
+      Occi::Log.info "### Registering OCCI Infrastructure categories ###"
+      Occi::Infrastructure.categories.each { |category| register category }
     end
 
     # register OCCI categories from files
@@ -34,9 +32,9 @@ module OCCI
     #  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} ###"
+      Occi::Log.info "### Initializing OCCI Model from #{path} ###"
       Dir.glob(path + '/**/*.json').each do |file|
-        collection = OCCI::Collection.new(JSON.parse(File.read(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
@@ -47,71 +45,41 @@ module OCCI
 
     # register OCCI categories from OCCI collection
     def register_collection(collection)
-      collection.categories.each { |category| register category }
+      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_value.each { |category| category.entities = [] if category.respond_to? :entities }
+      categories.each { |category| category.entities = [] if category.respond_to? :entities }
     end
 
-    # @param [OCCI::Core::Category] category
+    # @param [Occi::Core::Category] category
     def register(category)
-      OCCI::Log.debug "### Registering category #{category.type_identifier}"
-      @categories[category.type_identifier] = category
-      @locations[category.location] = category.type_identifier unless category.kind_of? OCCI::Core::Action
+      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
+    # @param [Occi::Core::Category] category
     def unregister(category)
-      OCCI::Log.debug "### Unregistering category #{category.type_identifier}"
-      @categories.delete category.type_identifier
-      @locations.delete category.location unless category.kind_of? OCCI :Core::Action
-    end
-
-    # Returns the category corresponding to a given type identifier
-    #
-    # @param [URI] id type identifier of a category
-    # @return [OCCI::Core::Category]
-    def get_by_id(id)
-      @categories.fetch(id) { OCCI::Log.debug("Category with id #{id} not found"); nil }
-    end
-
-    # Returns the category corresponding to a given location
-    #
-    # @param [URI] location
-    # @return [OCCI::Core::Category]
-    def get_by_location(location)
-      id = @locations.fetch(location) { OCCI::Log.debug("Category with location #{location} not found"); nil }
-      get_by_id id
+      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] filter
-    # @return [OCCI::Collection] collection
-    def get(filter = OCCI::Collection.new)
-      collection = OCCI::Collection.new
-      if filter.empty?
-        @categories.each_value do |category|
-          collection.kinds << category if category.kind_of? OCCI::Core::Kind
-          collection.mixins << category if category.kind_of? OCCI::Core::Mixin
-          collection.actions << category if category.kind_of? OCCI::Core::Action
-        end
-      else
-        categories = filter.categories
-        OCCI::Log.debug("### Filtering categories #{categories.collect { |c| c.type_identifier }.inspect}")
-        while categories.any? do
-          category = categories.pop
-          categories.concat @categories.each_value.select { |cat| cat.related_to?(category.type_identifier) }
-          collection.kinds << get_by_id(category.type_identifier) if category.kind_of? OCCI::Core::Kind
-          collection.mixins << get_by_id(category.type_identifier) if category.kind_of? OCCI::Core::Mixin
-          collection.actions << get_by_id(category.type_identifier) if category.kind_of? OCCI::Core::Action
-        end
-      end
-      collection
+    # @param [Occi::Collection] filter
+    # @return [Occi::Collection] collection
+    def get(filter = nil)
+      filter ? intersect(filter) : self
     end
 
   end

data/lib/occi/parser.rb

@@ -1,4 +1,4 @@
-module OCCI
+module Occi
   class Parser
 
     # Declaring Class constants for OVF XML namespaces (defined in OVF specification ver.1.1)
@@ -12,24 +12,25 @@ module OCCI
     # @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 [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 [Array<Array, OCCI::Collection>] list consisting of an array of locations and the OCCI object collection
-    def self.parse(media_type, body, category=false, entity_type=OCCI::Core::Resource, header={ })
-      OCCI::Log.debug '### Parsing request data to OCCI data structure ###'
-      collection = OCCI::Collection.new
+    # @return [Occi::Collection] list consisting of an array of locations and the OCCI object collection
+    def self.parse(media_type, body, category=false, entity_type=Occi::Core::Resource, header={ })
+      Occi::Log.debug '### Parsing request data to OCCI Collection ###'
+      collection = Occi::Collection.new
 
-      locations = self.header_locations(header)
-      category ? collection = self.header_categories(header) : collection = self.header_entity(header, entity_type) if locations.empty?
+      # remove trailing HTTP_ prefix if present
+      header = Hash[header.map {|k, v| [k.gsub('HTTP_','').upcase, v] }]
+
+      category ? collection = self.header_categories(header) : collection = self.header_entity(header, entity_type)
 
       case media_type
         when 'text/uri-list'
-          body.each_line { |line| locations << URI.parse(line.chomp) }
+          nil
         when 'text/occi'
           nil
         when 'text/plain', nil
-          locations.concat self.text_locations(body)
-          category ? collection = self.text_categories(body) : collection = self.text_entity(body, entity_type) if locations.empty? && collection.empty?
+          category ? collection = self.text_categories(body) : collection = self.text_entity(body, entity_type) if collection.empty?
         when 'application/occi+json', 'application/json'
           collection = self.json(body)
         when 'application/occi+xml', 'application/xml'
@@ -41,7 +42,20 @@ module OCCI
         else
           raise "Content Type not supported"
       end
-      return locations, collection
+      collection
+    end
+
+    def self.locations(media_type, body, header)
+      locations = self.header_locations(header)
+      case media_type
+        when 'text/uri-list'
+          body.each_line { |line| locations << URI.parse(line.chomp) }
+        when 'text/plain', nil
+          locations.concat self.text_locations(body)
+        else
+          nil
+      end
+      locations
     end
 
     private
@@ -49,33 +63,33 @@ module OCCI
     # @param [Hash] header
     # @return [Array] list of URIs
     def self.header_locations(header)
-      x_occi_location_strings = header['HTTP_X_OCCI_LOCATION'].to_s.split(',')
+      x_occi_location_strings = header['X_OCCI_LOCATION'].to_s.split(',')
       x_occi_location_strings.collect { |loc| OCCIANTLR::Parser.new('X-OCCI-Location: ' + loc).x_occi_location }
     end
 
     # @param [Hash] header
-    # @return [OCCI::Collection]
+    # @return [Occi::Collection]
     def self.header_categories(header)
-      collection       = OCCI::Collection.new
-      category_strings = header['HTTP_CATEGORY'].to_s.split(',')
+      collection       = Occi::Collection.new
+      category_strings = header['CATEGORY'].to_s.split(',')
       category_strings.each do |cat|
         category = OCCIANTLR::Parser.new('Category: ' + cat).category
-        collection.kinds.concat category.kinds.collect { |kind| OCCI::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) }
-        collection.mixins.concat category.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) }
-        collection.actions.concat category.actions.collect { |action| OCCI::Core::Action.new(action.scheme, action.term, action.title, action.attributes) }
+        collection.kinds.merge category.kinds.collect { |kind| Occi::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) }
+        collection.mixins.merge category.mixins.collect { |mixin| Occi::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) }
+        collection.actions.merge category.actions.collect { |action| Occi::Core::Action.new(action.scheme, action.term, action.title, action.attributes) }
       end
       collection
     end
 
     # @param [Hash] header
     # @param [Class] entity_type
-    # @return [OCCI::Collection]
+    # @return [Occi::Collection]
     def self.header_entity(header, entity_type)
-      collection       = OCCI::Collection.new
+      collection       = Occi::Collection.new
       entity           = Hashie::Mash.new
-      category_strings = header['HTTP_CATEGORY'].to_s.split(',')
+      category_strings = header['CATEGORY'].to_s.split(',')
       return collection if category_strings.empty?
-      attribute_strings = header['HTTP_X_OCCI_ATTRIBUTE'].to_s.split(',')
+      attribute_strings = header['X_OCCI_ATTRIBUTE'].to_s.split(',')
       categories        = Hashie::Mash.new({ :kinds => [], :mixins => [], :actions => [] })
       category_strings.each do |category|
         cat = OCCIANTLR::Parser.new('Category: ' + category).category
@@ -88,16 +102,16 @@ module OCCI
       entity.kind = categories.kinds.first.scheme + categories.kinds.first.term
       entity.mixins = categories.mixins.collect { |mixin| mixin.scheme + mixin.term } if categories.mixins.any?
       attribute_strings.each { |attr| entity.attributes!.merge!(OCCIANTLR::Parser.new('X-OCCI-Attribute: ' + attr).x_occi_attribute) }
-      if entity_type == OCCI::Core::Link
+      if entity_type == Occi::Core::Link
         entity.target = link.attributes!.occi!.core!.target
         entity.source = link.attributes!.occi!.core!.source
         cats          = entity.categories.split(' ')
         kind          = cats.reverse!.pop
         mixins        = cats.categories
-        collection.links << OCCI::Core::Link.new(kind, mixins, entity.attributes)
-      elsif entity_type == OCCI::Core::Resource
+        collection.links << Occi::Core::Link.new(kind, mixins, entity.attributes)
+      elsif entity_type == Occi::Core::Resource
         entity.links = []
-        link_strings = header['HTTP_LINK'].to_s.split(',')
+        link_strings = header['LINK'].to_s.split(',')
         link_strings.each do |link_string|
           link = OCCIANTLR::Parser.new('Link: ' + link_string).link
           if link.rel.include? 'action#'
@@ -105,15 +119,14 @@ module OCCI
           else
             link.attributes!.occi!.core!.target = link.target
 
-            link.category ||= 'http://schemas.ogf.org/occi/core#link'
-            cats          = link.category.split(' ')
-            kind          = cats.reverse!.pop
-            mixins        = cats
+            link.categories = (link.categories.presence || %w'http://schemas.ogf.org/occi/core#link')
+            kind            = link.categories.reverse!.pop
+            mixins          = link.categories
 
-            entity.links << OCCI::Core::Link.new(kind, mixins, link.attributes, link.actions, link.rel, link.target, link.source)
+            entity.links << Occi::Core::Link.new(kind, mixins, link.attributes, link.actions, link.rel, link.target, link.source)
           end
         end
-        collection.resources << OCCI::Core::Resource.new(entity.kind, entity.mixins, entity.attributes, entity.actions, entity.links)
+        collection.resources << Occi::Core::Resource.new(entity.kind, entity.mixins, entity.attributes, entity.actions, entity.links)
       end
       collection
     end
@@ -125,28 +138,27 @@ module OCCI
     end
 
     # @param [String] text
-    # @return [OCCI::Collection]
+    # @return [Occi::Collection]
     def self.text_categories(text)
-      collection = OCCI::Collection.new
+      collection = Occi::Collection.new
       text.each_line do |line|
         category = OCCIANTLR::Parser.new(line.chomp).category
         next if category.nil?
-        collection.kinds.concat category.kinds.collect { |kind| OCCI::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) }
-        collection.mixins.concat category.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) }
-        collection.actions.concat category.actions.collect { |action| OCCI::Core::Action.new(action.scheme, action.term, action.title, action.attributes) }
+        collection.kinds.merge category.kinds.collect { |kind| Occi::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) }
+        collection.mixins.merge category.mixins.collect { |mixin| Occi::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) }
+        collection.actions.merge category.actions.collect { |action| Occi::Core::Action.new(action.scheme, action.term, action.title, action.attributes) }
       end
       collection
     end
 
     # @param [String] text
     # @param [Class] entity_type
-    # @return [OCCI::Collection]
+    # @return [Occi::Collection]
     def self.text_entity(text, entity_type)
-      collection   = OCCI::Collection.new
-      entity       = Hashie::Mash.new
-      links        = []
-      entity.links = []
-      categories   = Hashie::Mash.new({ :kinds => [], :mixins => [], :actions => [] })
+      collection = Occi::Collection.new
+      entity     = Hashie::Mash.new
+      links      = []
+      categories = Hashie::Mash.new({ :kinds => [], :mixins => [], :actions => [] })
       text.each_line do |line|
         if line.include? 'Category'
           cat = (OCCIANTLR::Parser.new(line.chomp).category)
@@ -159,49 +171,48 @@ module OCCI
       end
       entity.kind = categories.kinds.first.scheme + categories.kinds.first.term if categories.kinds.first
       entity.mixins = categories.mixins.collect { |mixin| mixin.scheme + mixin.term } if categories.mixins
-      if entity_type == OCCI::Core::Link
+      if entity_type == Occi::Core::Link
         entity.target = links.first.attributes!.occi!.core!.target
         entity.source = links.first.attributes!.occi!.core!.source
         cats          = entity.categories.split(' ')
         kind          = cats.reverse!.pop
-        mixins        = cats.categories
-
-        collection.links << OCCI::Core::Link.new(kind, mixins, entity.attributes)
-      elsif entity_type == OCCI::Core::Resource
+        mixins        = cats
+        collection.links << Occi::Core::Link.new(kind, mixins, entity.attributes)
+      elsif entity_type == Occi::Core::Resource
+        entity.links = []
         links.each do |link|
           if link.rel.include? 'action#'
             entity.actions = [link.rel] + entity.actions.to_a
           else
             link.attributes!.occi!.core!.target = link.target
-            link.category                       ||= 'http://schemas.ogf.org/occi/core#link'
-            cats                                = link.category.split(' ')
-            kind                                = cats.reverse!.pop
-            mixins                              = cats
 
-            link = OCCI::Core::Link.new(kind, mixins, link.attributes, link.actions, link.rel, link.target, link.source)
-            collection.links << link
+            link.categories = (link.categories.presence || %w'http://schemas.ogf.org/occi/core#link')
+            cats            = link.categories
+            kind            = link.categories.reverse!.pop
+            mixins          = link.categories
+
+            link = Occi::Core::Link.new(kind, mixins, link.attributes, link.actions, link.rel, link.target, link.source)
             entity.links << link
           end
         end
-        collection.resources << OCCI::Core::Resource.new(entity.kind, entity.mixins, entity.attributes, entity.actions, entity.links)
+        collection.resources << Occi::Core::Resource.new(entity.kind, entity.mixins, entity.attributes, entity.actions, entity.links)
       end unless entity.kind.nil?
       collection
     end
 
     # @param [String] json
-    # @return [OCCI::Collection]
+    # @return [Occi::Collection]
     def self.json(json)
-      collection = OCCI::Collection.new
-      hash = Hashie::Mash.new(JSON.parse(json))
-      collection.kinds.concat 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.concat 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.concat hash.actions.collect { |action| OCCI::Core::Action.new(action.scheme, action.term, action.title, action.attributes) } if hash.actions
-      collection.resources.concat hash.resources.collect { |resource| OCCI::Core::Resource.new(resource.kind, resource.mixins, resource.attributes, resource.actions, resource.links) } if hash.resources
-      collection.links.concat hash.links.collect { |link| OCCI::Core::Link.new(link.kind, link.mixins, link.attributes, link.actions, link.rel, link.target, link.source) } if hash.links
-
-      if collection.resources.size == 1 && collection.links.size > 0
+      collection = Occi::Collection.new
+      hash       = Hashie::Mash.new(JSON.parse(json))
+      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
+
+      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
@@ -218,14 +229,15 @@ module OCCI
     end
 
     # @param [String] xml
-    # @return [OCCI::Collection]
+    # @return [Occi::Collection]
     def self.xml(xml)
-      collection = OCCI::Collection.new
+      collection = Occi::Collection.new
       hash       = Hashie::Mash.new(Hash.from_xml(Nokogiri::XML(xml)))
-      collection.kinds.concat 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.concat hash.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) } if hash.mixins
-      collection.resources.concat hash.resources.collect { |resource| OCCI::Core::Resource.new(resource.kind, resource.mixins, resource.attributes, resource.actions, resource.links) } if hash.resources
-      collection.links.concat hash.links.collect { |link| OCCI::Core::Link.new(link.kind, link.mixins, link.attributes) } if hash.links
+      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
 
@@ -239,7 +251,7 @@ module OCCI
 
 
     def self.calculate_capacity_gb(capacity)
-      capacity_gb = capacity/(2**30)
+      capacity_gb = capacity.to_f/(2**30)
       capacity_gb
     end
 
@@ -256,7 +268,7 @@ module OCCI
     ###############End of Helper methods for OVF Parsing ##################################################################
 
     # @param [String] ova
-    # @return [OCCI::Collection]
+    # @return [Occi::Collection]
     def self.ova(ova)
       tar   = Gem::Package::TarReader.new(StringIO.new(ova))
       ovf   = mf = cert = nil
@@ -274,7 +286,7 @@ module OCCI
       File.read(mf).each_line do |line|
         name = line.scan(/SHA1\(([^\)]*)\)= (.*)/).flatten.first
         sha1 = line.scan(/SHA1\(([^\)]*)\)= (.*)/).flatten.last
-        puts Digest::SHA1.hexdigest(files[name])
+        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
 
@@ -286,7 +298,7 @@ module OCCI
     # @param [String] ovf
     # @param [Hash] files key value pairs of file names and paths to the file
     def self.ovf(ovf, files={ })
-      collection = OCCI::Collection.new
+      collection = Occi::Collection.new
       doc        = Nokogiri::XML(ovf)
       references = { }
 
@@ -304,9 +316,9 @@ module OCCI
       end
 
       doc.xpath('envelope:Envelope/envelope:DiskSection/envelope:Disk', 'envelope' => "#{Parser::OVF}").each do |disk|
-        storage = OCCI::Core::Resource.new('http://schemas.ogf.org/occi/infrastructure#storage')
+        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                               = 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
@@ -326,7 +338,7 @@ module OCCI
             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)
+          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
@@ -334,14 +346,14 @@ module OCCI
       end
 
       doc.xpath('envelope:Envelope/envelope:NetworkSection/envelope:Network', 'envelope' => "#{Parser::OVF}").each do |nw|
-        network                              = OCCI::Core::Resource.new('http://schemas.ogf.org/occi/infrastructure#network')
+        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' => "#{Parser::OVF}").each do |virtsys|
-        compute = OCCI::Core::Resource.new('http://schemas.ogf.org/occi/infrastructure#compute')
+        compute = Occi::Core::Resource.new('http://schemas.ogf.org/occi/infrastructure#compute')
 
         doc.xpath('envelope:Envelope/envelope:VirtualSystem/envelope:VirtualHardwareSection', 'envelope' => "#{Parser::OVF}").each do |virthwsec|
           compute.attributes.occi!.core!.summary = virthwsec.xpath("item:Info/text()", 'item' => "#{Parser::RASD}").to_s
@@ -351,27 +363,35 @@ module OCCI
             case resType.to_s
               # 4 is the ResourceType for memory in the CIM_ResourceAllocationSettingData
               when "4" then
-                compute.attributes.occi!.compute!.memory = resource_alloc.xpath("item:VirtualQuantity/text()", 'item' => "#{Parser::RASD}").to_s.to_i
+                Occi::Log.debug('calculating memory in gb ')
+                alloc_units = resource_alloc.xpath("item:AllocationUnits/text()", 'item' => "#{Parser::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' => "#{Parser::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' => "#{Parser::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' => "#{Parser::RASD}").to_s.to_i
               when "10" then
-                networkinterface                              = OCCI::Core::Link.new('http://schemas.ogf.org/occi/infrastructure#networkinterface')
+                networkinterface                              = Occi::Core::Link.new('http://schemas.ogf.org/occi/infrastructure#networkinterface')
                 networkinterface.attributes.occi!.core!.title = resource_alloc.xpath("item:ElementName/text()", 'item' => "#{Parser::RASD}").to_s
                 id                                            = resource_alloc.xpath("item:Connection/text()", 'item' => "#{Parser::RASD}").to_s
                 network                                       = collection.resources.select { |resource| resource.attributes.occi!.core!.title == id }.first
                 raise "Network with id #{id} not found" unless network
-                networkinterface.attributes.occi!.core!.target = network.location
+                networkinterface.attributes.occi!.core!.target = network
               when "17" then
-                storagelink                              = OCCI::Core::Link.new("http://schemas.ogf.org/occi/infrastructure#storagelink")
+                storagelink                              = Occi::Core::Link.new("http://schemas.ogf.org/occi/infrastructure#storagelink")
                 storagelink.attributes.occi!.core!.title = resource_alloc.xpath("item:ElementName/text()", 'item' => "#{Parser::RASD}").to_s
                 # extract the mountpoint
                 host_resource                            = resource_alloc.xpath("item:HostResource/text()", 'item' => "#{Parser::RASD}").to_s
                 if host_resource.start_with? 'ovf:/disk/'
-                  id = host_resource.gsub('ovf:/disk/', '')
+                  id      = host_resource.gsub('ovf:/disk/', '')
                   storage = collection.resources.select { |resource| resource.attributes.occi!.core!.title == id }.first
                   raise "Disk with id #{id} not found" unless storage
-                  storagelink.attributes.occi!.core!.target = storage.location
+                  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]