occi 2.5.19 → 3.0.0.beta.0

data/lib/occi/bin/resource_output_factory.rb

@@ -0,0 +1,90 @@
+require 'json'
+require 'erb'
+
+module Occi
+  module Bin
+
+    class ResourceOutputFactory
+
+      @@allowed_formats = [:json, :plain].freeze
+      @@allowed_resource_types = [:compute, :storage, :network, :os_tpl, :resource_tpl].freeze
+      @@allowed_data_types = [:locations, :resources].freeze
+
+      attr_reader :output_format
+
+      def initialize(output_format = :plain)
+        raise "Unsupported output format!" unless @@allowed_formats.include? output_format
+        @output_format = output_format
+      end
+
+      def format(data, data_type, resource_type)
+        raise "Data has to be in an array!" unless data.is_a? Array
+        raise "Unsupported resource type! Got: #{resource_type.to_s}" unless @@allowed_resource_types.include? resource_type
+        raise "Unsupported data type! Got: #{data_type.to_s}" unless @@allowed_data_types.include? data_type
+
+        # validate incoming data
+        if data_type == :resources
+          data.each do |occi_collection|
+            raise "I need the resources to be in a Collection!" unless occi_collection.respond_to? :as_json
+          end
+        end
+
+        # construct method name from data type and output format
+        method = (data_type.to_s + "_to_" + output_format.to_s).to_sym
+
+        ResourceOutputFactory.send method, data, resource_type
+      end
+
+      def self.allowed_formats
+        @@allowed_formats
+      end
+
+      def self.allowed_resource_types
+        @@allowed_resource_types
+      end
+
+      def self.allowed_data_types
+        @@allowed_data_types
+      end
+
+      def self.resources_to_json(occi_resources, resource_type)
+        # generate JSON document from an array of JSON objects 
+        JSON.generate occi_resources
+      end
+
+      def self.resources_to_plain(occi_resources, resource_type)
+        # using ERB templates for known resource and mixin types
+        file = File.expand_path("..", __FILE__) + '/templates/' + resource_type.to_s + ".erb"
+        template = ERB.new File.new(file).read
+
+        template.result(binding)
+      end
+
+      def self.locations_to_json(url_locations, resource_type)
+        # give all locatios a common key and convert to JSON
+        locations = { resource_type => [] }
+
+        url_locations.each do |location|
+          location = location.split("/").last if [:os_tpl, :resource_tpl].include? resource_type
+          locations[resource_type] << location
+        end
+
+        locations.to_json
+      end
+
+      def self.locations_to_plain(url_locations, resource_type)
+        # just an attempt to make the array more readable 
+        output = "\n" + resource_type.to_s.capitalize + " locations:\n"
+
+        url_locations.each do |location|
+          location = location.split("/").last if [:os_tpl, :resource_tpl].include? resource_type
+          output << "\t" << location << "\n"
+        end
+
+        output
+      end
+
+    end
+
+  end
+end

data/lib/occi/bin/templates/compute.erb

@@ -0,0 +1,15 @@
+<%# We always get an array of OCCI::Collections %>
+Available COMPUTE resources:
+<% occi_resources.each do |occi_compute| %>
+  <% compute = occi_compute.as_json %>
+  COMPUTE resource "<%= compute.resources.first.attributes.occi.core.title %>":
+    ID:           <%= compute.resources.first.attributes.occi.core.id %>
+    TITLE:        <%= compute.resources.first.attributes.occi.core.title %>
+    STATE:        <%= compute.resources.first.attributes.occi.compute.state %>
+    LINKS:
+    <% if compute.links %><% compute.links.each do |link| %>
+      LINK "<%= link.attributes.occi.core.target.split("/")[1] %>":
+        ID:     <%= link.attributes.occi.core.id %>
+        TARGET: <%= link.attributes.occi.core.target %>
+    <% end %><% end %>
+<% end %>

data/lib/occi/bin/templates/network.erb

@@ -0,0 +1,11 @@
+<%# We always get an array of OCCI::Collections %>
+Available NETWORK resources:
+<% occi_resources.each do |occi_network| %>
+  <% network = occi_network.as_json %>
+  NETWORK resource "<%= network.resources.first.attributes.occi.core.title %>":
+    ID:           <%= network.resources.first.attributes.occi.core.id %>
+    TITLE:        <%= network.resources.first.attributes.occi.core.title %>
+    STATE:        <%= network.resources.first.attributes.occi.network.state %>
+    ALLOCATION:   <%= network.resources.first.attributes.occi.network.allocation %>
+    ADDRESS:      <%= network.resources.first.attributes.occi.network.address %>
+<% end %>

data/lib/occi/bin/templates/os_tpl.erb

@@ -0,0 +1,9 @@
+<%# We always get an array of OCCI::Collections %>
+Available OS templates:
+<% occi_resources.each do |occi_os_tpl| %>
+  <% os_tpl = occi_os_tpl.as_json %>
+  OS template "os_tpl#<%= os_tpl.term %>":
+    TITLE:        <%= os_tpl.title %>
+    TERM:         <%= os_tpl.term %>
+    LOCATION:     <%= os_tpl.location %>
+<% end %>

data/lib/occi/bin/templates/resource_tpl.erb

@@ -0,0 +1,9 @@
+<%# We always get an array of OCCI::Collections %>
+Available RESOURCE templates:
+<% occi_resources.each do |occi_res_tpl| %>
+  <% res_tpl = occi_res_tpl.as_json %>
+  RESOURCE template "resource_tpl#<%= res_tpl.term %>":
+    TITLE:        <%= res_tpl.title %>
+    TERM:         <%= res_tpl.term %>
+    LOCATION:     <%= res_tpl.location %>
+<% end %>

data/lib/occi/bin/templates/storage.erb

@@ -0,0 +1,10 @@
+<%# We always get an array of OCCI::Collections %>
+Available STORAGE resources:
+<% occi_resources.each do |occi_storage| %>
+  <% storage = occi_storage.as_json %>
+  STORAGE resource "<%= storage.resources.first.attributes.occi.core.title %>":
+    ID:           <%= storage.resources.first.attributes.occi.core.id %>
+    TITLE:        <%= storage.resources.first.attributes.occi.core.title %>
+    STATE:        <%= storage.resources.first.attributes.occi.storage.state%>
+    DESCRIPTION:  <%= storage.resources.first.attributes.occi.core.summary %>
+<% end %>

data/lib/occi/collection.rb

@@ -1,26 +1,32 @@
-module OCCI
+module Occi
   class Collection
-    attr_accessor :kinds
-    attr_accessor :mixins
-    attr_accessor :actions
-    attr_accessor :resources
-    attr_accessor :links
+
+    attr_accessor :kinds, :mixins, :actions, :resources, :links, :action, :model
 
     # Initialize a new OCCI Collection by initializing all supplied OCCI objects
     #
     # @param [Hash] collection including one or more of the keys kinds, mixins, actions, resources, links
-    def initialize(collection={ })
-      collection = Hashie::Mash.new(collection)
-      @kinds     = []
-      @mixins    = []
-      @actions   = []
-      @resources = []
-      @links     = []
-      @kinds = collection.kinds.collect { |kind| OCCI::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) } if collection.kinds.instance_of? Array
-      @mixins = collection.mixins.collect { |mixin| OCCI::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) } if collection.mixins.instance_of? Array
-      @actions = collection.actions.collect { |action| OCCI::Core::Action.new(action.scheme, action.term, action.title, action.attributes) } if collection.actions.instance_of? Array
-      @resources = collection.resources.collect { |resource| OCCI::Core::Resource.new(resource.kind, resource.mixins, resource.attributes, resource.links) } if collection.resources.instance_of? Array
-      @links = collection.links { |link| OCCI::Core::Link.new(link.kind, link.mixins, link.attributes) } if collection.links.instance_of? Array
+    def initialize(collection={ }, model = Occi::Model.new)
+      collection = Hashie::Mash.new(collection) unless collection.kind_of? Occi::Collection
+
+      @kinds     = Occi::Core::Kinds.new
+      @mixins    = Occi::Core::Mixins.new
+      @actions   = Occi::Core::Actions.new
+      @resources = Occi::Core::Resources.new
+      @links     = Occi::Core::Links.new
+
+      self.model = model if model
+
+      @kinds.merge collection.kinds.to_a.collect { |kind| Occi::Core::Kind.new(kind.scheme, kind.term, kind.title, kind.attributes, kind.related, kind.actions) }
+      @mixins.merge collection.mixins.to_a.collect { |mixin| Occi::Core::Mixin.new(mixin.scheme, mixin.term, mixin.title, mixin.attributes, mixin.related, mixin.actions) }
+      @actions.merge collection.actions.to_a.collect { |action| Occi::Core::Action.new(action.scheme, action.term, action.title, action.attributes) }
+      @resources.merge collection.resources.to_a.collect { |resource| Occi::Core::Resource.new(resource.kind, resource.mixins, resource.attributes, resource.links) }
+      @links.merge collection.links.to_a.collect { |link| Occi::Core::Link.new(link.kind, link.mixins, link.attributes) }
+      @action = Occi::Core::Action_instance.new(collection.action, collection.attributes) if collection.action
+    end
+
+    def ==(category)
+      not intersect(category).empty?
     end
 
     # @return [Array] categories combined list of all kinds, mixins and actions
@@ -33,9 +39,87 @@ module OCCI
       @resources + @links
     end
 
+    # @param [Occi::Core::Model] model
+    # @return [Occi::Core::Model]
+    def model=(model)
+      @model           = model
+      @kinds.model     = model
+      @mixins.model    = model
+      @actions.model   = model
+      @resources.model = model
+      @links.model     = model
+    end
+
+    def check
+      @resources.check
+      @links.check
+      # TODO: check action instance format, should check be applicable?
+      #@action.check
+    end
+
+    # @param [Occi::Collection] other_collection
+    # @return [Occi::Collection]
+    def merge!(other_collection)
+      merge other_collection, self
+    end
+
+    # @param [Occi::Collection] other_collection
+    # @param [Occi::Collection] collection
+    # @return [Occi::Collection]
+    def merge(other_collection, collection=self.clone)
+      collection.kinds.merge other_collection.kinds.select { |kind| get_by_id(kind.type_identifier).nil? }
+      collection.mixins.merge other_collection.mixins.select { |mixin| get_by_id(mixin.type_identifier).nil? }
+      collection.actions.merge other_collection.actions.select { |action| get_by_id(action.type_identifier).nil? }
+      collection.resources.merge other_collection.resources.select { |resource| get_by_id(resource.id).nil? }
+      collection.links.merge other_collection.links.select { |link| get_by_id(link.type_identifier).nil? }
+      collection.action = other_collection.action if other_collection.action
+      collection
+    end
+
+    # @param [Occi::Collection] other_collection
+    # @return [Occi::Collection]
+    def intersect!(other_collection)
+      intersect other_collection, self
+    end
+
+    # @param [Occi::Collection] other_collection
+    # @param [Occi::Collection] collection
+    # @return [Occi::Collection]
+    def intersect(other_collection, collection=self.clone)
+      collection.kinds.replace other_collection.kinds.select { |kind| get_by_id(kind.type_identifier) }
+      collection.mixins.replace other_collection.mixins.select { |mixin| get_by_id(mixin.type_identifier) }
+      collection.actions.replace other_collection.actions.select { |action| get_by_id(action.type_identifier) }
+      collection.resources.replace other_collection.resources.select { |resource| get_by_id(resource.id) }
+      collection.links.replace other_collection.links.select { |link| get_by_id(link.type_identifier) }
+      if collection.action == other_collection.action
+        collection.action = other_collection.action
+      else
+        collection.action = nil
+      end
+      collection
+    end
+
+    # Returns the category corresponding to a given id
+    #
+    # @param [String] id
+    # @return [Occi::Core::Category]
+    def get_by_id(id)
+      object = self.categories.select { |category| category.type_identifier == id }
+      object = self.entities.select { |entity| entity.id == id } if object.empty?
+      object.first
+    end
+
+    # Returns the category corresponding to a given location
+    #
+    # @param [URI] location
+    # @return [Occi::Core::Category]
+    def get_by_location(location)
+      self.categories.select { |category| category.location == location }.first
+    end
+
     # @return [true,false] true if collection is empty, false otherwise
     def empty?
-      @kinds.empty? && @mixins.empty? && @actions.empty? && @resources.empty? && @links.empty?
+      @kinds.empty? && @mixins.empty? && @actions.empty? && @resources.empty? && @links.empty? && @action.nil?
     end
 
     # @return [Hashie::Mash] json representation
@@ -43,9 +127,17 @@ module OCCI
       collection = Hashie::Mash.new
       collection.kinds = @kinds.collect { |kind| kind.as_json } if @kinds.any?
       collection.mixins = @mixins.collect { |mixin| mixin.as_json } if @mixins.any?
-      collection.actions = @actions.collect { |action| action.as_json } if @actions.any?
+      collection.actions = @actions.collect { |action_category| action_category.as_json } if @actions.any?
       collection.resources = @resources.collect { |resource| resource.as_json } if @resources.any?
-      collection.links = @links.collect { |link| link.as_json } if @links.any?
+      # if there is only one resource and the links inside the resource have no location,
+      # then these links must be rendered as separate links inside the collection
+      if !collection.resources.nil? && collection.resources.size == 1
+        lnks = @resources.first.links if collection.resources.first.links.blank? && @links.empty?
+      else
+        lnks = @links
+      end
+      collection.links = lnks.collect { |link| link.as_json } if lnks.to_a.any?
+      collection.action = @action.as_json if @action
       collection
     end
 
@@ -54,15 +146,20 @@ module OCCI
       text = ""
       text << self.categories.collect { |category| category.to_text }.join("\n")
       text << "\n" if self.categories.any?
-      raise "Only one entity allowed for rendering to plain text" if self.entities.size > 1
-      text << self.entities.collect {|entity| entity.to_text}.join("\n")
+      raise "Only one resource allowed for rendering to text/plain" if self.resources.size > 1
+      text << self.resources.collect { |resource| resource.to_text }.join("\n")
+      text << self.links.collect { |link| link.to_text_link }.join("\n")
+      text << self.action.to_text if self.action
       text
     end
 
     def to_header
       header = Hashie::Mash.new
-      header[:Category] = self.categories.collect {|category| category.to_text}.join(',') if self.categories.any?
-      header = self.entities.first.to_header if self.entities.any?
+      header['Category'] = self.categories.collect { |category| category.to_string_short }.join(',') if self.categories.any?
+      raise "Only one resource allowed for rendering to text/occi" if self.resources.size > 1
+      header = self.resources.first.to_header if self.resources.any?
+      header['Link'] = self.links.collect { |link| link.to_string }.join(',') if self.links.any?
+      header = self.action.to_header if self.action
       header
     end
 

data/lib/occi/core.rb

@@ -1,21 +1,30 @@
+require 'occi/core/attributes'
+require 'occi/core/attribute_properties'
 require 'occi/core/category'
+require 'occi/core/categories'
+require 'occi/core/related'
 require 'occi/core/kind'
+require 'occi/core/kinds'
 require 'occi/core/mixin'
+require 'occi/core/mixins'
 require 'occi/core/action'
+require 'occi/core/action_instance'
+require 'occi/core/actions'
+require 'occi/core/entities'
 require 'occi/core/entity'
 require 'occi/core/link'
+require 'occi/core/links'
 require 'occi/core/resource'
-#require 'occi/core/attribute'
-require 'occi/core/attributes'
+require 'occi/core/resources'
 
-module OCCI
+module Occi
   module Core
-    # @return [Array] list of OCCI::Core::Categories
-    def self.categories
-      categories = []
-      categories << OCCI::Core::Entity.kind
-      categories << OCCI::Core::Link.kind
-      categories << OCCI::Core::Resource.kind
+
+    extend Occi
+
+    def self.kinds
+      Occi::Core::Kinds.new << Occi::Core::Entity.kind << Occi::Core::Link.kind << Occi::Core::Resource.kind
     end
+
   end
 end

data/lib/occi/core/action.rb

@@ -1,8 +1,17 @@
-require 'occi/core/category'
-
-module OCCI
+module Occi
   module Core
-    class Action < OCCI::Core::Category
+    class Action < Occi::Core::Category
+
+      # @param [String ] scheme
+      # @param [String] term
+      # @param [String] title
+      # @param [Hash] attributes
+      def initialize(scheme='http://schemas.ogf.org/occi/core#',
+          term='action',
+          title=nil,
+          attributes=Occi::Core::Attributes.new)
+        super scheme, term, title, attributes
+      end
 
       # @return [String] text representation
       def to_text
@@ -11,6 +20,13 @@ module OCCI
         text
       end
 
+      # @return [Hash] hash containing the HTTP headers of the text/occi rendering
+      def to_header
+        header = super
+        header["Category"] << ';attributes=' + @attributes.combine.join(' ').inspect if @attributes.any?
+        header
+      end
+
     end
   end
 end

data/lib/occi/core/action_instance.rb

@@ -0,0 +1,24 @@
+module Occi
+  module Core
+    class Action_instance
+
+      class << self
+        attr_accessor :actions
+      end
+
+      attr_accessor :action, :attributes, :model
+
+      @action = Occi::Core::Action.new('http://schemas.ogf.org/occi/core#', 'action_instance')
+
+      def initialize(action = self.action, attributes={ })
+        if action.kind_of? String
+          scheme, term = action.split '#'
+          action = Occi::Core::Action.new(scheme, term)
+        end
+        @action     = action
+        @attributes = attributes
+      end
+
+    end
+  end
+end

data/lib/occi/core/actions.rb

@@ -0,0 +1,22 @@
+module Occi
+  module Core
+    class Actions < Occi::Core::Categories
+
+      private
+
+      def convert(category)
+        category = super category
+
+        if category.kind_of? String
+          scheme, term = category.split '#'
+          scheme       += '#'
+
+          klass    = Occi::Core::Category.get_class scheme, term, [Occi::Core::Action.new]
+          category = klass.new(scheme, term)
+        end
+        category
+      end
+
+    end
+  end
+end