occi-core 4.1.3 → 4.2.0

data/lib/occi/log.rb

@@ -5,21 +5,24 @@ module Occi
 
     include ::Logger::Severity
 
-    attr_reader :logger
+    attr_reader :logger, :log_prefix
 
     # creates a new OCCI logger
     # @param [IO,String] log_dev The log device.  This is a filename (String) or IO object (typically +STDOUT+,
+    # @param [String] log_prefix String placed in front of every logged message
     #  +STDERR+, or an open file).
-    def initialize(log_dev)
+    def initialize(log_dev, log_prefix = '[rOCCI-core]')
       if log_dev.kind_of? Logger
         @logger = log_dev
       else
         @logger = Logger.new(log_dev)
       end
 
+      @log_prefix = log_prefix.blank? ? '' : log_prefix.strip
+
       # 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
+      @log_subscriber = ActiveSupport::Notifications.subscribe("rOCCI-core.log") do |name, start, finish, id, payload|
+        @logger.log(payload[:level], "#{@log_prefix} #{payload[:message]}") if @logger
       end
     end
 
@@ -39,28 +42,28 @@ module Occi
 
     # @see info
     def self.debug(message)
-      ActiveSupport::Notifications.instrument("log", :level => Logger::DEBUG, :message => message)
+      ActiveSupport::Notifications.instrument("rOCCI-core.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)
+      ActiveSupport::Notifications.instrument("rOCCI-core.log", :level => Logger::INFO, :message => message)
     end
 
     # @see info
     def self.warn(message)
-      ActiveSupport::Notifications.instrument("log", :level => Logger::WARN, :message => message)
+      ActiveSupport::Notifications.instrument("rOCCI-core.log", :level => Logger::WARN, :message => message)
     end
 
     # @see info
     def self.error(message)
-      ActiveSupport::Notifications.instrument("log", :level => Logger::ERROR, :message => message)
+      ActiveSupport::Notifications.instrument("rOCCI-core.log", :level => Logger::ERROR, :message => message)
     end
 
     # @see info
     def self.fatal(message)
-      ActiveSupport::Notifications.instrument("log", :level => Logger::FATAL, :message => message)
+      ActiveSupport::Notifications.instrument("rOCCI-core.log", :level => Logger::FATAL, :message => message)
     end
   end
-end
+end

data/lib/occi/model.rb

@@ -14,7 +14,7 @@ module Occi
 
     # register Occi Core categories enitity, resource and link
     def register_core
-      Occi::Log.info "### Registering OCCI Core categories enitity, resource and link ###"
+      Occi::Log.info "[#{self.class}] Registering OCCI Core categories enitity, resource and link"
       register Occi::Core::Entity.kind
       register Occi::Core::Resource.kind
       register Occi::Core::Link.kind
@@ -22,7 +22,7 @@ module Occi
 
     # register Occi Infrastructure categories
     def register_infrastructure
-      Occi::Log.info "### Registering OCCI Infrastructure categories ###"
+      Occi::Log.info "[#{self.class}] Registering OCCI Infrastructure categories"
       Occi::Infrastructure.categories.each { |category| register category }
     end
 
@@ -32,7 +32,8 @@ 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 "[#{self.class}] Initializing OCCI Model from #{path}"
+      raise ArgumentError, "Directory \"#{path}\" does not exist" unless File.directory?(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
@@ -53,12 +54,12 @@ module Occi
 
     # clear all entities from all categories
     def reset()
-      categories.each { |category| category.entities = [] if category.respond_to? :entities }
+      categories.each { |category| category.entities = Occi::Core::Entities.new if category.respond_to? :entities }
     end
 
     # @param [Occi::Core::Category] category
     def register(category)
-      Occi::Log.debug "### Registering category #{category}"
+      Occi::Log.debug "[#{self.class}] 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
@@ -68,7 +69,7 @@ module Occi
 
     # @param [Occi::Core::Category] category
     def unregister(category)
-      Occi::Log.debug "### Unregistering category #{category.type_identifier}"
+      Occi::Log.debug "[#{self.class}] Unregistering category #{category.type_identifier}"
       @kinds.delete category
       @mixins.delete category
       @actions.delete category
@@ -79,8 +80,8 @@ module Occi
     # @param [Occi::Collection,Occi::Core::Category,String] filter
     # @return [Occi::Collection] collection
     def get(filter = nil)
-      filter ? self.get_related_to(filter) : self
+      (filter && !filter.empty? ) ? self.get_related_to(filter) : self
     end
 
   end
-end
+end

data/lib/occi/parser/json.rb

@@ -1,16 +1,17 @@
 module Occi
   module Parser
     module Json
-      # @param [String] string
+      # @param [String] body
       # @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.parent ||= 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.depends ||= mixin.related, mixin.actions, mixin.applies) } 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
+      def self.collection(body)
+
+        begin
+          hash = Hashie::Mash.new(JSON.parse(body))
+        rescue JSON::ParserError => perr
+          Occi::Log.error "[#{self}] Failed to parse JSON input: #{perr.message}"
+          raise Occi::Errors::ParserInputError, perr.message
+        end
+        collection = Occi::Collection.new(hash)
 
         if collection.resources.size == 1 && collection.links.size > 0
           if collection.resources.first.links.empty?
@@ -27,6 +28,7 @@ module Occi
             lnk ||= resource_link
           end
         end
+
         collection
       end
     end

data/lib/occi/parser/ova.rb

@@ -5,27 +5,33 @@ module Occi
       # @param [String] string
       # @return [Occi::Collection]
       def self.collection(string)
+        Occi::Log.debug "[#{self}] Parsing ova format"
         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
 
+        Occi::Log.debug "[#{self}] In ova found: #{ovf} #{mf} #{cert}"
+        raise Occi::Errors::ParserInputError, 'No ovf file found' unless ovf
+
         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
+          line = line.scan(/SHA1\(([^\)]*)\)= (.*)/).flatten
+          name = line.first
+          sha1 = line.last
 
-        raise 'no ovf file found' if ovf.nil?
+          Occi::Log.debug "[#{self}] SHA1 hash #{Digest::SHA1.hexdigest(files[name])}"
+          raise Occi::Errors::ParserInputError, "SHA1 mismatch for file #{name}" unless Digest::SHA1.hexdigest(File.read(files[name])) == sha1
+        end if mf
 
         Occi::Parser::Ovf.collection(File.read(ovf), files)
       end

data/lib/occi/parser/ovf.rb

@@ -9,145 +9,202 @@ module Occi
       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]
+      class << self
+
+        # @param [String] string
+        # @param [Hash] files key value pairs of file names and paths to the file
+        def collection(string, files={})
+          collection = Occi::Collection.new
+          doc = Nokogiri::XML(string)
+
+          references = parse_references(doc, files)
+          parse_storage(doc, references, collection)
+          parse_network(doc, collection)
+          parse_compute(doc, references, collection)
+
+          collection
+        end
+
+        def parse_references(doc, files)
+          references = {}
+
+          doc.xpath('envelope:Envelope/envelope:References/envelope:File', 'envelope' => "#{OVF}").each do |file|
+            href = URI.parse(file.attributes['href'].to_s)
+            references[file.attributes['id'].to_s] = if href.relative?
+              files[href.to_s] ? "file://#{files[href.to_s]}" : "file://#{href.to_s}"
             else
-              references[file.attributes['id'].to_s] = 'file://' + href.to_s
+              href.to_s
             end
-          else
-            references[file.attributes['id'].to_s] = href.to_s
           end
+
+          references
         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
+        def parse_storage(doc, references, collection)
+          doc.xpath('envelope:Envelope/envelope:DiskSection/envelope:Disk', 'envelope' => "#{OVF}").each do |disk|
+            storage = Occi::Infrastructure::Storage.new
+
+            if disk.attributes['fileRef']
+              parse_storage_disk_file(disk, storage, references)
             else
-              alloc_unit_bytes = self.alloc_units_bytes(alloc_units)
-              capacity = self.calculate_capacity_bytes(disk.attributes['capacity'].to_s, alloc_unit_bytes)
+              parse_storage_disk_alloc(disk, storage, references)
             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']
+
+            collection.resources << storage
+          end
+
+          collection
+        end
+
+        def parse_storage_disk_file(disk, storage, references)
+          storagelink = Occi::Infrastructure::Storagelink.new
+          storagelink.title = disk.attributes['fileRef'].to_s
+          storagelink.target = references[disk.attributes['fileRef'].to_s]
+
+          storage.title = disk.attributes['diskId'].to_s
+          storage.links << storagelink
+
+          storage
+        end
+
+        def parse_storage_disk_alloc(disk, storage)
+          #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.to_i
+          else
+            alloc_unit_bytes = alloc_units_bytes(alloc_units)
+            capacity = calculate_capacity_bytes(disk.attributes['capacity'].to_s, alloc_unit_bytes)
+          end
+
+          capacity_gb = calculate_capacity_gb(capacity)
+          storage.size = capacity_gb.to_s if capacity_gb
+          storage.title = disk.attributes['diskId'].to_s if disk.attributes['diskId']
+
+          storage
+        end
+
+        def parse_network(doc, collection)
+          doc.xpath('envelope:Envelope/envelope:NetworkSection/envelope:Network', 'envelope' => "#{OVF}").each do |nw|
+            network = Occi::Infrastructure::Network.new
+            network.title = nw.attributes['name'].to_s
+            collection.resources << network
           end
-          collection.resources << storage
+
+          collection
         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
+        def parse_compute(doc, references, collection)
+          # 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::Infrastructure::Compute.new
+
+            doc.xpath('envelope:Envelope/envelope:VirtualSystem/envelope:VirtualHardwareSection', 'envelope' => "#{OVF}").each do |virthwsec|
+              compute.summary = virthwsec.xpath("item:Info/text()", 'item' => "#{RASD}").to_s
+              parse_compute_resources(collection, compute, virthwsec)
+            end
+
+            collection.resources << compute
+          end
+
+          collection
         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
+        def parse_compute_resources(collection, compute, virthwsec)
+          virthwsec.xpath('envelope:Item', 'envelope' => "#{OVF}").each do |resource_alloc|
+            resType = resource_alloc.xpath("item:ResourceType/text()", 'item' => "#{RASD}")
+
+            case resType.to_s
+            when "4" then
+              # 4 is the ResourceType for memory in the CIM_ResourceAllocationSettingData
+              parse_compute_memory(resource_alloc, compute)
+            when "3" then
+              # 3 is the ResourceType for processor in the CIM_ResourceAllocationSettingData
+              compute.cores = resource_alloc.xpath("item:VirtualQuantity/text()", 'item' => "#{RASD}").to_s.to_i
+            when "10" then
+              # extract the network
+              parse_compute_network(resource_alloc, compute, collection)
+            when "17" then
+              # extract the mountpoint
+              parse_compute_storage(resource_alloc, compute, collection)
             end
+
+            ##Add the cpu architecture
+            #system_sec = virthwsec.xpath('envelope:System', 'envelope' => "#{OVF}")
+            #compute.architecture = system_sec.xpath('vssd_:VirtualSystemType/text()', 'vssd_' => "#{VSSD}")
           end
-          collection.resources << compute
+
+          compute
         end
-        collection
-      end
 
-      ####################Helper method for calculation of storage size based on allocation units configured###########
+        def parse_compute_memory(resource_alloc, compute)
+          alloc_units = resource_alloc.xpath("item:AllocationUnits/text()", 'item' => "#{RASD}").to_s
 
-      def self.calculate_capacity_bytes(capacity, alloc_units_bytes)
-        total_capacity_bytes = alloc_units_bytes * capacity.to_i
-        total_capacity_bytes
-      end
+          alloc_unit_bytes = alloc_units_bytes(alloc_units)
+          capacity = calculate_capacity_bytes(resource_alloc.xpath("item:VirtualQuantity/text()", 'item' => "#{RASD}").to_s, alloc_unit_bytes)
+          capacity_gb = calculate_capacity_gb(capacity)
 
+          compute.memory = capacity_gb
+          # compute.attributes.occi!.compute!.memory = resource_alloc.xpath("item:VirtualQuantity/text()", 'item' => "#{RASD}").to_s.to_i
 
-      def self.calculate_capacity_gb(capacity)
-        capacity_gb = capacity.to_f/(2**30)
-        capacity_gb
-      end
+          compute
+        end
 
+        def parse_compute_network(resource_alloc, compute, collection)
+          id = resource_alloc.xpath("item:Connection/text()", 'item' => "#{RASD}").to_s
+          network = collection.resources.select { |resource| resource.title == id }.first
+          raise Occi::Errors::ParserInputError, "Network with id #{id} not found" unless network
 
-      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
+          networkinterface = compute.networkinterface(network)
+          networkinterface.title = resource_alloc.xpath("item:ElementName/text()", 'item' => "#{RASD}").to_s
 
-      ###############End of Helper methods for OVF Parsing ##################################################################
+          compute
+        end
+
+        def parse_compute_storage(resource_alloc, compute, collection)
+          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.title == id }.first
+            raise Occi::Errors::ParserInputError, "Disk with id #{id} not found" unless storage
+          elsif host_resource.start_with? 'ovf:/file/'
+            raise Occi::Errors::ParserInputError, 'OVF files are not supported!'
+            #id = host_resource.gsub('ovf:/file/', '')
+            #storagelink.attributes.occi!.core!.target = references[id]
+          end
+
+          storagelink = compute.storagelink(storage)
+          storagelink.title = resource_alloc.xpath("item:ElementName/text()", 'item' => "#{RASD}").to_s
 
+          compute
+        end
+
+        def calculate_capacity_bytes(capacity, alloc_units_bytes)
+          total_capacity_bytes = alloc_units_bytes * capacity.to_i
+          total_capacity_bytes
+        end
+
+        def calculate_capacity_gb(capacity)
+          capacity_gb = capacity.to_f/(2**30)
+          capacity_gb
+        end
+
+        def 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
 
     end
   end

data/lib/occi/parser/text/constants.rb

@@ -0,0 +1,87 @@
+module Occi
+  module Parser
+    module Text
+      module Constants
+
+        # Regular expressions
+        REGEXP_QUOTED_STRING = /([^"\\]|\\.)*/
+        REGEXP_LOALPHA = /[a-z]/
+        REGEXP_ALPHA = /[a-zA-Z]/
+        REGEXP_DIGIT = /[0-9]/
+        REGEXP_INT = /#{REGEXP_DIGIT}+/
+        REGEXP_FLOAT = /#{REGEXP_INT}\.#{REGEXP_INT}/
+        REGEXP_NUMBER = /#{REGEXP_FLOAT}|#{REGEXP_INT}/
+        REGEXP_BOOL = /\b(?<!\|)true(?!\|)\b|\b(?<!\|)false(?!\|)\b/
+
+        # Regular expressions for OCCI
+        REGEXP_TERM = /(#{REGEXP_ALPHA}|#{REGEXP_DIGIT})(#{REGEXP_ALPHA}|#{REGEXP_DIGIT}|-|_)*/# Compatibility with terms starting with a number
+        REGEXP_TERM_STRICT = /#{REGEXP_LOALPHA}(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT}|-|_)*/
+        REGEXP_SCHEME = /#{URI::ABS_URI_REF}#/
+        REGEXP_TYPE_IDENTIFIER = /#{REGEXP_SCHEME}#{REGEXP_TERM}/
+        REGEXP_TYPE_IDENTIFIER_STRICT = /#{REGEXP_SCHEME}#{REGEXP_TERM_STRICT}/
+        REGEXP_CLASS = /\b(?<!\|)action(?!\|)\b|\b(?<!\|)mixin(?!\|)\b|\b(?<!\|)kind(?!\|)\b/
+
+        REGEXP_ATTR_COMPONENT = /#{REGEXP_LOALPHA}(#{REGEXP_LOALPHA}|#{REGEXP_DIGIT}|-|_)*/
+        REGEXP_ATTRIBUTE_NAME = /#{REGEXP_ATTR_COMPONENT}(\.#{REGEXP_ATTR_COMPONENT})*/
+        REGEXP_ATTRIBUTE_PROPERTY = /\b(?<!\|)immutable(?!\|)\b|\b(?<!\|)required(?!\|)\b/
+        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_STRICT = /#{REGEXP_TYPE_IDENTIFIER_STRICT}/
+        REGEXP_ACTION_LIST = /#{REGEXP_ACTION}(\s+#{REGEXP_ACTION})*/
+        REGEXP_ACTION_LIST_STRICT = /#{REGEXP_ACTION_STRICT}(\s+#{REGEXP_ACTION_STRICT})*/
+
+        REGEXP_RESOURCE_TYPE = /#{REGEXP_TYPE_IDENTIFIER}(\s+#{REGEXP_TYPE_IDENTIFIER})*/
+        REGEXP_RESOURCE_TYPE_STRICT = /#{REGEXP_TYPE_IDENTIFIER_STRICT}(\s+#{REGEXP_TYPE_IDENTIFIER_STRICT})*/
+        REGEXP_LINK_INSTANCE = /#{URI::URI_REF}/
+        REGEXP_LINK_TYPE = /#{REGEXP_TYPE_IDENTIFIER}(\s+#{REGEXP_TYPE_IDENTIFIER})*/
+        REGEXP_LINK_TYPE_STRICT = /#{REGEXP_TYPE_IDENTIFIER_STRICT}(\s+#{REGEXP_TYPE_IDENTIFIER_STRICT})*/
+
+        # Regular expression for OCCI Categories
+        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)
+        REGEXP_CATEGORY_STRICT = "Category:\\s*(?<term>#{REGEXP_TERM_STRICT})" << # 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_STRICT})\")?"<< # rel (optional)
+            "(;\\s*location=\"(?<location>#{URI::URI_REF})\")?" << # location (optional)
+            "(;\\s*attributes=\"(?<attributes>#{REGEXP_ATTRIBUTE_LIST})\")?" << # attributes (optional)
+            "(;\\s*actions=\"(?<actions>#{REGEXP_ACTION_LIST_STRICT})\")?" << # actions (optional)
+            ';?' # additional semicolon at the end (not specified, for interoperability)
+
+        # 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>(;?\\s*(#{REGEXP_LINK_TYPE}))+)\")?" << # category (optional)
+            "(?<attributes>(;?\\s*(#{REGEXP_ATTRIBUTE_REPR}))*)" << # attributes (optional)
+            ';?' # additional semicolon at the end (not specified, for interoperability)
+        REGEXP_LINK_STRICT = "Link:\\s*\\<(?<uri>#{URI::URI_REF})\\>" << # uri (mandatory)
+            ";\\s*rel=\"(?<rel>#{REGEXP_RESOURCE_TYPE_STRICT})\"" << # rel (mandatory)
+            "(;\\s*self=\"(?<self>#{REGEXP_LINK_INSTANCE})\")?" << # self (optional)
+            "(;\\s*category=\"(?<category>(;?\\s*(#{REGEXP_LINK_TYPE_STRICT}))+)\")?" << # 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)
+
+      end
+    end
+  end
+end