occi 2.5.19 → 3.0.0.beta.0

data/lib/occi/core/links.rb

@@ -0,0 +1,34 @@
+module Occi
+  module Core
+    class Links < Occi::Core::Entities
+
+      def initialize(links=[])
+        links.collect! {|link| convert link} if links
+        super links
+      end
+
+      def <<(link)
+        super convert link
+      end
+
+      def create(*args)
+        link       = Occi::Core::Link.new(*args)
+        link.model = @model
+        self << link
+        link
+      end
+
+      private
+
+      def convert(link)
+        if link.kind_of? String
+          target      = link
+          link        = Occi::Core::Link.new
+          link.target = target
+        end
+        link
+      end
+
+    end
+  end
+end

data/lib/occi/core/mixin.rb

@@ -1,48 +1,53 @@
-require 'active_support/json'
-require 'occi/core/category'
-
-module OCCI
+module Occi
   module Core
-    class Mixin < OCCI::Core::Category
+    class Mixin < Occi::Core::Category
 
-      attr_accessor :entities, :related, :actions
+      attr_accessor :entities, :related, :actions, :location
 
       # @param [String ] scheme
       # @param [String] term
       # @param [String] title
-      # @param [OCCI::Core::AttributeProperties] attributes
-      # @param [Array] related
-      # @param [Array] actions
-      def initialize(scheme, term, title=nil, attributes=nil, related=nil, actions=nil)
-        @entities = []
-        @related  = related.to_a
-        @actions  = actions.to_a
+      # @param [Occi::Core::Attributes,Hash,NilClass] attributes
+      # @param [Occi::Core::Categories,Hash,NilClass] related
+      # @param [Occi::Core::Actions,Hash,NilClass] actions
+      def initialize(scheme='http://schemas.ogf.org/occi/core#',
+          term='mixin',
+          title=nil,
+          attributes=Occi::Core::Attributes.new,
+          related=Occi::Core::Related.new,
+          actions=Occi::Core::Actions.new,
+          location='')
+
         super(scheme, term, title, attributes)
+        @related  = Occi::Core::Related.new(related)
+        @actions  = Occi::Core::Actions.new(actions)
+        @entities = Occi::Core::Entities.new
+        location.blank? ? @location = '/mixins/' + term + '/' : @location = location
       end
 
-      # @return [String] string containing location URI of mixin
       def location
-        '/mixins/' + @term + '/'
+        @location.clone
       end
 
       # @param [Hash] options
       # @return [Hashie::Mash] json representation
       def as_json(options={ })
         mixin = Hashie::Mash.new
-        mixin.related = @related if @related.any?
+        mixin.related = @related.join(' ').split(' ') if @related.any?
         mixin.actions = @actions if @actions.any?
+        mixin.location = @location if @location
         mixin.merge! super
         mixin
       end
 
       # @return [String] text representation
-      def to_text
-        text = super
-        text << ';rel=' + @related.join(' ').inspect if @related.any?
-        text << ';location=' + self.location.inspect
-        text << ';attributes=' + @attributes.combine.join(' ').inspect if @attributes.any?
-        text << ';actions=' + @actions.join(' ').inspect if @actions.any?
-        text
+      def to_string
+        string = super
+        string << ';rel=' + @related.join(' ').inspect if @related.any?
+        string << ';location=' + self.location.inspect
+        string << ';attributes=' + @attributes.combine.keys.join(' ').inspect if @attributes.any?
+        string << ';actions=' + @actions.join(' ').inspect if @actions.any?
+        string
       end
 
     end

data/lib/occi/core/mixins.rb

@@ -0,0 +1,22 @@
+module Occi
+  module Core
+    class Mixins < 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::Mixin.new]
+          category = klass.new(scheme, term)
+        end
+        category
+      end
+
+    end
+  end
+end

data/lib/occi/core/related.rb

@@ -0,0 +1,20 @@
+module Occi
+  module Core
+    class Related < Occi::Core::Categories
+
+      private
+
+      def convert(category)
+        if category.kind_of? String
+          model_category=nil
+          model_category = @model.get_by_id category if @model
+          if model_category
+            return model_category
+          end
+        end
+        category
+      end
+
+    end
+  end
+end

data/lib/occi/core/resource.rb

@@ -1,52 +1,35 @@
-require 'hashie/mash'
-require 'active_support/json'
-require 'occi/core/entity'
-require 'occi/core/kind'
-
-module OCCI
+module Occi
   module Core
-    class Resource < Entity
+    class Resource < Occi::Core::Entity
 
       attr_accessor :links
 
-      # @return [OCCI::Core::Kind] kind definition of Resource type
-      def self.kind_definition
-        kind = OCCI::Core::Kind.new('http://schemas.ogf.org/occi/core#', 'resource')
-
-        kind.related = %w{http://schemas.ogf.org/occi/core#entity}
-        kind.title   = 'Resource'
+      @kind = Occi::Core::Kind.new('http://schemas.ogf.org/occi/core#', 'resource')
 
-        kind.attributes.occi!.core!.summary!.Type     = 'string'
-        kind.attributes.occi!.core!.summary!.Pattern  = '.*'
-        kind.attributes.occi!.core!.summary!.Required = false
-        kind.attributes.occi!.core!.summary!.Mutable  = true
+      @kind.related << Occi::Core::Entity.kind
+      @kind.title   = 'resource'
 
-        kind
-      end
+      @kind.attributes.occi!.core!.summary = Occi::Core::AttributeProperties.new(
+          { :mutable => true })
 
       # @param [String] kind
       # @param [Array] mixins
-      # @param [OCCI::Core::Attributes,Hash] attributes
+      # @param [Occi::Core::Attributes,Hash] attributes
       # @param [Array] links
-      def initialize(kind, mixins=[], attributes={ }, actions=[], links=[])
+      # @return [Occi::Core::Resource]
+      def initialize(kind=self.kind, mixins=[], attributes={ }, actions=[], links=[])
         super(kind, mixins, attributes, actions)
-        @links = []
-        links.to_a.each do |link|
-          link = OCCI::Core::Link.new(link.kind,link.mixins,link.attributes,link.actions,link.rel) unless link.kind_of? OCCI::Core::Link
-          @links << link
-        end
+        @links = Occi::Core::Links.new(links)
       end
 
-      # set id for resource and update the the source of all links
-      # @param [UUIDTools::UUID] id
-      def id=(id)
-        super(id)
-        @links.each { |link| link.attributes.occi!.core!.source = self.location }
+      def model=(model)
+        super model
+        @links.model = model
       end
 
       # @return [String] summary attribute of the resource
       def summary
-        self.attributes.occi!.core!.summary
+        self.attributes.occi.core.summary if @attributes.occi.core if @attributes.occi
       end
 
       # set summary attribute of resource
@@ -55,22 +38,39 @@ module OCCI
         self.attributes.occi!.core!.summary = summary
       end
 
-      # @param [Hash] options
-      # @return [Hashie::Mash] link as Hashie::Mash to be parsed into a JSON object
-      def as_json(options={ })
-        resource = Hashie::Mash.new
-        resource.links = @links.collect { |link| link.as_json } if @links.any?
-        resource.merge! super
-        resource
+      def link(target, kind=Occi::Core::Link.kind, mixins=[], attributes=Occi::Core::Attributes.new, rel=Occi::Core::Resource.type_identifier)
+        link            = kind.entity_type.new
+        link.rel        = rel
+        link.attributes = attributes
+        link.target     = target
+        link.source     = self
+        link.mixins     = mixins
+        @links << link
+        link
       end
 
       # @return [String] text representation
       def to_text
         text = super
-        @links.each { |link| text << 'Link: ' + link.to_reference_text + "\n" }
+        @links.each { |link| text << link.to_text_link + "\n" }
         text
       end
 
+      # @return [Hash] hash containing the HTTP headers of the text/occi rendering
+      def to_header
+        header = super
+        header['Links'] = @links.join(',')
+      end
+
+      # @param [Hash] options
+      # @return [Hashie::Mash] link as Hashie::Mash to be parsed into a JSON object
+      def as_json(options={ })
+        resource     = super
+        link_strings = @links.collect { |link| link.to_s if link.to_s }.compact
+        resource.links = link_strings unless link_strings.empty?
+        resource
+      end
+
     end
   end
 end

data/lib/occi/core/resources.rb

@@ -0,0 +1,14 @@
+module Occi
+  module Core
+    class Resources < Occi::Core::Entities
+
+      def create(*args)
+        resource       = Occi::Core::Resource.new(*args)
+        resource.model = @model
+        self << resource
+        resource
+      end
+
+    end
+  end
+end

data/lib/occi/infrastructure.rb

@@ -0,0 +1,27 @@
+require 'occi/infrastructure/compute'
+require 'occi/infrastructure/storage'
+require 'occi/infrastructure/storagelink'
+require 'occi/infrastructure/network'
+require 'occi/infrastructure/networkinterface'
+require 'occi/infrastructure/os_tpl'
+require 'occi/infrastructure/resource_tpl'
+
+module Occi
+  module Infrastructure
+
+    extend Occi
+
+    def self.kinds
+      Occi::Core::Kinds.new << Occi::Infrastructure::Compute.kind << Occi::Infrastructure::Storage.kind << Occi::Infrastructure::Network.kind << Occi::Infrastructure::Networkinterface.kind << Occi::Infrastructure::Storagelink.kind
+    end
+
+    def self.mixins
+      Occi::Infrastructure::Compute.mixins + Occi::Infrastructure::Storage.mixins + Occi::Infrastructure::Network.mixins + Occi::Infrastructure::Networkinterface.mixins + Occi::Infrastructure::Storagelink.mixins
+    end
+
+    def self.actions
+      Occi::Infrastructure::Compute.actions + Occi::Infrastructure::Storage.actions + Occi::Infrastructure::Network.actions + Occi::Infrastructure::Networkinterface.actions + Occi::Infrastructure::Storagelink.actions
+    end
+
+  end
+end

data/lib/occi/infrastructure/compute.rb

@@ -0,0 +1,159 @@
+module Occi
+  module Infrastructure
+    class Compute < Occi::Core::Resource
+
+      class Start < Occi::Core::Action
+        def initialize(scheme='http://schemas.ogf.org/occi/infrastructure/compute/action#',
+            term='start',
+            title='start compute instance')
+          super
+        end
+      end
+
+      class Stop < Occi::Core::Action
+        def initialize(scheme='http://schemas.ogf.org/occi/infrastructure/compute/action#',
+            term='stop',
+            title='stop compute instance')
+          super
+          @attributes.method = Occi::Core::AttributeProperties.new(
+              { :mutable => true,
+                :pattern => 'graceful|acpioff|poweroff',
+                :default => 'poweroff' })
+        end
+      end
+
+      class Restart < Occi::Core::Action
+        def initialize(scheme='http://schemas.ogf.org/occi/infrastructure/compute/action#',
+            term='restart',
+            title='restart compute instance')
+          super
+          @attributes.method = Occi::Core::AttributeProperties.new(
+              { :mutable => true,
+                :pattern => 'graceful|warm|cold',
+                :default => 'cold' })
+        end
+      end
+
+      class Suspend < Occi::Core::Action
+        def initialize(scheme='http://schemas.ogf.org/occi/infrastructure/compute/action#',
+            term='suspend',
+            title='suspend compute instance')
+          super
+          @attributes.method = Occi::Core::AttributeProperties.new(
+              { :mutable => true,
+                :pattern => 'hibernate|suspend',
+                :default => 'suspend' })
+        end
+      end
+
+      def self.mixins
+        Occi::Core::Mixins.new << Occi::Infrastructure::Resource_tpl.new << Occi::Infrastructure::Os_tpl.new
+      end
+
+      def self.actions
+        Occi::Core::Actions.new << Start.new << Stop.new << Restart.new << Suspend.new
+      end
+
+      begin
+        @kind = Occi::Core::Kind.new('http://schemas.ogf.org/occi/infrastructure#', 'compute')
+
+        @kind.title = "compute resource"
+
+        @kind.related << Occi::Core::Resource.kind
+
+        @kind.attributes.occi!.compute!.architecture = Occi::Core::AttributeProperties.new(
+            { :mutable => true,
+              :pattern => 'x86|x64' })
+
+        @kind.attributes.occi!.compute!.cores = Occi::Core::AttributeProperties.new(
+            { :type    => 'number',
+              :mutable => true })
+
+        @kind.attributes.occi!.compute!.hostname = Occi::Core::AttributeProperties.new(
+            { :mutable => true,
+              :pattern => '(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*' })
+
+        @kind.attributes.occi!.compute!.speed = Occi::Core::AttributeProperties.new(
+            { :type    => 'number',
+              :mutable => true })
+
+        @kind.attributes.occi!.compute!.memory = Occi::Core::AttributeProperties.new(
+            { :type    => 'number',
+              :mutable => true })
+
+        @kind.attributes.occi!.compute!.state = Occi::Core::AttributeProperties.new(
+            { :pattern => 'inactive|active|suspended|error',
+              :default => 'inactive' })
+
+        @kind.location = '/compute/'
+
+        @kind.actions = self.actions
+      end
+
+      def architecture
+        @attributes.occi.compute.architecture if @attributes.occi.compute if @attributes.occi
+      end
+
+      def architecture=(architecture)
+        @attributes.occi!.compute!.architecture = architecture
+      end
+
+      def cores
+        @attributes.occi.compute.cores if @attributes.occi.compute if @attributes.occi
+      end
+
+      def cores=(cores)
+        @attributes.occi!.compute!.cores = cores
+      end
+
+      def hostname
+        @attributes.occi.compute.hostname if @attributes.occi.compute if @attributes.occi
+      end
+
+      def hostname=(hostname)
+        @attributes.occi!.compute!.hostname = hostname
+      end
+
+      def speed
+        @attributes.occi.compute.speed if @attributes.occi.compute if @attributes.occi
+      end
+
+      def speed=(speed)
+        @attributes.occi!.compute!.speed = speed
+      end
+
+      def memory
+        @attributes.occi.compute.memory if @attributes.occi.compute if @attributes.occi
+      end
+
+      def memory=(memory)
+        @attributes.occi!.compute!.memory = memory
+      end
+
+      def state
+        @attributes.occi.compute.state if @attributes.occi.compute if @attributes.occi
+      end
+
+      def state=(state)
+        @attributes.occi!.compute!.state = state
+      end
+
+      def storagelink(target, mixins=[], attributes=Occi::Core::Attributes.new)
+        link(target, Occi::Infrastructure::Storagelink.kind, mixins, attributes, rel=Occi::Infrastructure::Storage.type_identifier)
+      end
+
+      def networkinterface(target, mixins=[], attributes=Occi::Core::Attributes.new)
+        link(target, Occi::Infrastructure::Networkinterface.kind, mixins, attributes)
+      end
+
+      def storagelinks
+        @links.select { |link| link.kind == Occi::Infrastructure::Storagelink.kind }
+      end
+
+      def networkinterfaces
+        @links.select { |link| link.kind == Occi::Infrastructure::Networkinterface.kind }
+      end
+
+    end
+  end
+end