occi 2.5.19 → 3.0.0.beta.0

data/examples/dsl_example.rb

@@ -3,7 +3,7 @@ require 'pp'
 
 # load and include rOCCI client DSL
 require 'occi'
-extend OCCI::DSL
+extend Occi::Api::Dsl
 
                               ## options
 use_os_temlate = true         # use OS_TEMPLATE or NETWORK + STORAGE + INSTANCE TYPE
@@ -17,13 +17,13 @@ CA_PATH            = '/etc/grid-security/certificates'
 ENDPOINT           = 'https://localhost:3300'
 
 ## establish a connection
-connect(ENDPOINT,
+connect(:http, ENDPOINT,
         { :type               => "x509",
           :user_cert          => USER_CERT,
           :user_cert_password => USER_CERT_PASSWORD,
           :ca_path            => CA_PATH },
         { :out   => STDERR,
-          :level => OCCI::Log::DEBUG })
+          :level => Occi::Log::DEBUG })
 
 puts "\n\nListing all available resource types:"
 resource_types.each do |type|
@@ -114,8 +114,8 @@ unless use_os_temlate
 
   ## create links and attach them to the compure resource
   puts "\n Connecting to our compute:"
-  storagelink cmpt, storage_loc
-  networkinterface cmpt, network_loc
+  cmpt.storagelink storage_loc
+  cmpt.networkinterface network_loc
 else
   ## with OS template, we have to find the template by name
   ## optionally we can change its "size" by choosing an instance type
@@ -126,7 +126,7 @@ else
   ## attach chosen resources to the compute resource
   cmpt.mixins << os << size
   ## we can change some of the values manually
-  cmpt.attributes.occi!.core!.title = "My rOCCI x509 VM"
+  cmpt.title = "My rOCCI x509 VM"
 end
 
 ## create the compute resource and print its location

data/examples/x509auth_example.rb

@@ -13,14 +13,14 @@ USER_CERT_PASSWORD = 'mypassphrase'
 CA_PATH            = '/etc/grid-security/certificates'
 ENDPOINT           = 'https://localhost:3300'
 
-## get an OCCI::Client instance
-client = OCCI::Client.new(ENDPOINT,
+## get an OCCI::Api::Client::ClientHttp instance
+client = Occi::Api::Client::ClientHttp.new(ENDPOINT,
         { :type               => "x509",
           :user_cert          => USER_CERT,
           :user_cert_password => USER_CERT_PASSWORD,
           :ca_path            => CA_PATH },
         { :out   => STDERR,
-          :level => OCCI::Log::DEBUG })
+          :level => Occi::Log::DEBUG })
 
 puts "\n\nListing all available resource types:"
 client.get_resource_types.each do |type|
@@ -111,8 +111,8 @@ unless use_os_temlate
 
   ## create links and attach them to the compure resource
   puts "\n Connecting to our compute:"
-  client.storagelink cmpt, storage_loc
-  client.networkinterface cmpt, network_loc
+  cmpt.storagelink storage_loc
+  cmpt.networkinterface network_loc
 else
   ## with OS template, we have to find the template by name
   ## optionally we can change its "size" by choosing an instance type
@@ -123,7 +123,7 @@ else
   ## attach chosen resources to the compute resource
   cmpt.mixins << os << size
   ## we can change some of the values manually
-  cmpt.attributes.occi!.core!.title = "My rOCCI x509 VM"
+  cmpt.title = "My rOCCI x509 VM"
 end
 
 ## create the compute resource and print its location

data/features/common/step_definitions/common_steps.rb

@@ -0,0 +1,32 @@
+Given /^endpoint : (.*)$/ do |endpoint|
+  @endpoint = endpoint
+  @endpoint =~ URI::ABS_URI
+  @endpoint.should_not be_nil
+end
+
+Given /^transfer_protocol : (http|amqp)$/ do |protocol|
+  @transfer_protocol = protocol
+end
+
+Given /^accept type : (text\/occi|text\/plain|application\/json)$/ do |accept_type|
+  @accept_type = accept_type
+end
+
+Given /^category filter : (.*)$/ do |category_filter|
+  @category_filter = category_filter
+end
+
+Given /^have an initialize Client$/ do
+  @client = Occi::Api::Client::ClientHttp.new(
+      @endpoint, #141.5.99.69 #11.5.99.82
+      { :type  => "none" },
+      { :out   => "/dev/null",
+        :level => Occi::Log::DEBUG },
+      true,
+      @accept_type#"text/plain,text/occi"
+  )
+end
+
+Then /^the Client should have the response code (.*)$/ do |response_code|
+  @client.last_response.code.should == response_code.to_i
+end

data/features/occi/core/create/create.feature

@@ -0,0 +1,17 @@
+
+Feature:
+  In order to create an OCCI Resource on the OCCI Server
+  As an OCCI Client
+  I want to get an success report of the create operation and receive the URI of the new Resource by the OCCI Server
+
+  Scenario Outline: Create an OCCI Resource
+    Given endpoint : <endpoint>
+    And transfer_protocol : <protocol>
+    And accept type : <accept_type>
+    And have an initialize Client
+    When
+    Then the Client should have the response code <response_code>
+
+  Scenarios:
+    | protocol  | endpoint                  | accept_type       | response_code |
+    |  http     | http://141.5.99.69/       | text/plain        | 201           |

data/features/occi/core/delete/delete.feature

@@ -0,0 +1,14 @@
+Feature:
+  ...
+
+  Scenario Outline: ...
+    Given endpoint : <endpoint>
+    And transfer_protocol : <protocol>
+    And accept type : <accept_type>
+    And have an initialize Client
+    When
+    Then the Client should have the response code <response_code>
+
+  Scenarios:
+    | protocol  | endpoint                  | accept_type       | response_code |
+    |  http     | http://141.5.99.69/       | text/plain        | 201           |

data/features/occi/core/discovery_interface/discovery_interface.feature

@@ -0,0 +1,35 @@
+# language: en
+
+Feature: Discovery Interface
+  In order to discover the capabilities of an OCCI Server
+  As an OCCI Client
+  I want to receive all OCCI Categories supported by the OCCI Server
+
+  Scenario Outline: Retrieving all OCCI Categories supported by the OCCI Server
+    Given endpoint : <endpoint>
+    And transfer_protocol : <protocol>
+    And accept type : <accept_type>
+    And category filter : <category_filter>
+    And have an initialize Client
+    When OCCI Client request all OCCI Categories supported by the OCCI Server
+    Then the Client should have the response code <response_code>
+    And OCCI Client should display the OCCI Categories received from the OCCI Server
+
+  Scenarios:
+  | protocol | endpoint                  | accept_type       | response_code | category_filter |
+  | http     | http://141.5.99.69/       | application/json  |      200      |                 |
+  | http     | http://141.5.99.69/       | text/occi         |      200      |                 |
+  | http     | http://141.5.99.69/       | text/plain        |      200      |                 |
+  | http     | http://46.231.128.85:8086/| text/occi         |      200      |                 |
+  | http     | http://141.5.99.69/       | text/plain        |      200      | action          |
+
+  #Scenario: Retrieving the OCCI Categories with an OCCI Category filter from the OCCI Server
+  #  Given an "http" OCCI Server with endpoint "http://141.5.99.69/"
+  #  And the client accept "text/plain"
+  #  And OCCI Client requests all OCCI Categories supported by the OCCI Server
+  #  And select "action" Category from the OCCI Server
+  #  When OCCI Client requests from the OCCI Server the OCCI Categories related to the selected OCCI Category
+  #  Then OCCI Client should display the OCCI Categories received from the OCCI Server
+  #  And displayed Categories should related to the selected OCCI Category
+  #  And should be some
+

data/features/occi/core/discovery_interface/step_definitions/discovery_interface_steps.rb

@@ -0,0 +1,19 @@
+When /^OCCI Client request all OCCI Categories supported by the OCCI Server$/ do
+  if @category_filter.length > 0
+    @category_filter   = @category_filter.pluralize
+    @selected_category = @client.model.send @category_filter.to_sym
+    @selected_category.should have_at_least(1).bla
+    pending
+  else
+    @client.refresh
+  end
+end
+
+Then /^OCCI Client should display the OCCI Categories received from the OCCI Server$/ do
+  @client.model.should_not be_empty
+
+#  @client.model.actions  .should have_at_least(1).actions
+  @client.model.kinds    .should have_at_least(4).kinds
+  @client.model.links    .should be_empty
+  @client.model.resources.should be_empty
+end

data/features/occi/core/miscellaneous/miscellaneous.feature

@@ -0,0 +1,14 @@
+Feature:
+  ...
+
+  Scenario Outline: ...
+    Given endpoint : <endpoint>
+    And transfer_protocol : <protocol>
+    And accept type : <accept_type>
+    And have an initialize Client
+    When
+    Then the Client should have the response code <response_code>
+
+  Scenarios:
+    | protocol  | endpoint                  | accept_type       | response_code |
+    |  http     | http://141.5.99.69/       | text/plain        | 201           |

data/features/occi/core/read/read.feature

@@ -0,0 +1,14 @@
+Feature:
+  ...
+
+  Scenario Outline: ...
+    Given endpoint : <endpoint>
+    And transfer_protocol : <protocol>
+    And accept type : <accept_type>
+    And have an initialize Client
+    When
+    Then the Client should have the response code <response_code>
+
+  Scenarios:
+    | protocol  | endpoint                  | accept_type       | response_code |
+    |  http     | http://141.5.99.69/       | text/plain        | 201           |

data/features/occi/core/update/update.feature

@@ -0,0 +1,14 @@
+Feature:
+  ...
+
+  Scenario Outline: ...
+    Given endpoint : <endpoint>
+    And transfer_protocol : <protocol>
+    And accept type : <accept_type>
+    And have an initialize Client
+    When
+    Then the Client should have the response code <response_code>
+
+  Scenarios:
+    | protocol  | endpoint                  | accept_type       | response_code |
+    |  http     | http://141.5.99.69/       | text/plain        | 201           |

data/features/occi/infrastructure/create/create.feature

@@ -0,0 +1,14 @@
+Feature:
+  ...
+
+  Scenario Outline: ...
+    Given endpoint : <endpoint>
+    And transfer_protocol : <protocol>
+    And accept type : <accept_type>
+    And have an initialize Client
+    When
+    Then the Client should have the response code <response_code>
+
+  Scenarios:
+    | protocol  | endpoint                  | accept_type       | response_code |
+    |  http     | http://141.5.99.69/       | text/plain        | 201           |

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+
+require 'rubygems'
+require 'occi'

data/lib/occi.rb

@@ -1,3 +1,6 @@
+require 'rubygems'
+
+require 'set'
 require 'hashie/mash'
 
 require 'active_support/json'
@@ -19,13 +22,36 @@ require 'zlib'
 require 'tempfile'
 
 require 'occi/version'
+require 'occi/collection'
 require 'occi/parser'
 require 'occi/model'
 require 'occi/log'
-require 'occi/api/dsl'
-require 'occi/api/client'
-require 'occi/collection'
 require 'occi/core'
+require 'occi/infrastructure'
 
 require 'occiantlr/OCCIANTLRLexer'
 require 'occiantlr/OCCIANTLRParser'
+
+require 'occi/api/dsl'
+require 'occi/api/client/client_http'
+require 'occi/api/client/client_amqp'
+
+module Occi
+
+  def kinds
+    Occi::Core::Kinds.new
+  end
+
+  def mixins
+    Occi::Core::Mixins.new
+  end
+
+  def actions
+    Occi::Core::Actions.new
+  end
+
+  # @return [Array] list of Occi::Core::Categories
+  def categories
+    self.kinds + self.mixins + self.actions
+  end
+end

data/lib/occi/api/client/client_amqp.rb

@@ -0,0 +1,756 @@
+require 'rubygems'
+require "amqp"
+require "json"
+
+module Occi
+  module Api
+    module Client
+
+    class ClientAmqp
+      attr_reader :endpoint, :auth_options, :connected, :last_response_status
+      attr_accessor :media_type, :model
+
+      CONNECTION_SETTING = {
+          :host => 'localhost', #IP of the MessageBroker (RabbitMQ)
+          :port => 5672,
+          :vhost => '/' ,
+          :password => 'password'
+      }
+
+      # hash mapping HTTP response codes to human-readable messages
+      HTTP_CODES = {
+          "100" => "Continue",
+          "101" => "Switching Protocols",
+          "200" => "OK",
+          "201" => "Created",
+          "202" => "Accepted",
+          "203" => "Non-Authoritative Information",
+          "204" => "No Content",
+          "205" => "Reset Content",
+          "206" => "Partial Content",
+          "300" => "Multiple Choices",
+          "301" => "Moved Permanently",
+          "302" => "Found",
+          "303" => "See Other",
+          "304" => "Not Modified",
+          "305" => "Use Proxy",
+          "307" => "Temporary Redirect",
+          "400" => "Bad Request",
+          "401" => "Unauthorized",
+          "402" => "Payment Required",
+          "403" => "Forbidden",
+          "404" => "Not Found",
+          "405" => "Method Not Allowed",
+          "406" => "Not Acceptable",
+          "407" => "Proxy Authentication Required",
+          "408" => "Request Time-out",
+          "409" => "Conflict",
+          "410" => "Gone",
+          "411" => "Length Required",
+          "412" => "Precondition Failed",
+          "413" => "Request Entity Too Large",
+          "414" => "Request-URI Too Large",
+          "415" => "Unsupported Media Type",
+          "416" => "Requested range not satisfiable",
+          "417" => "Expectation Failed",
+          "500" => "Internal Server Error",
+          "501" => "Not Implemented",
+          "502" => "Bad Gateway",
+          "503" => "Service Unavailable",
+          "504" => "Gateway Time-out",
+          "505" => "HTTP Version not supported"
+      }
+
+      #TODO Should a client have some kind of timeout
+
+      # Initializes client data structures and retrieves OCCI model
+      # from the server.
+      #
+      # @example
+      #    Occi::Api::Client::ClientAmqp.new # => #<Occi::Api::Client::ClientAmqp>
+      #
+      # @param [String] endpoint URI
+      # @param [Hash] auth options in a hash
+      # @param [Hash] logging options in a hash
+      # @param [Boolean] enable autoconnect
+      # @param [String] media type identifier
+      # @return [Occi::Api::Client::ClientAmqp] client instance
+      def initialize(endpoint = "http://localhost:3000/", auth_options = { :type => "none" },
+          log_options = { :out => STDERR, :level => Occi::Log::WARN, :logger => nil },
+          media_type = "text/plain")
+
+        # check the validity and canonize the endpoint URI
+        prepare_endpoint endpoint
+
+        # set Occi::Log
+        set_logger log_options
+
+        # pass auth options to HTTParty
+        change_auth auth_options
+
+        @media_type = media_type
+
+        Occi::Log.debug("Media Type: #{@media_type}")
+
+        @connected = false
+
+        Thread.new { run }
+
+        print "Waiting for connection amqp ..."
+
+        #TODO find a better solution for the thread issue
+        while(!@thread_error && !@connected)
+          #dont use sleep - it blocks the eventmachine
+        end
+
+        # get model information from the endpoint
+        # and create Occi::Model instance
+        set_model unless @thread_error
+      end
+
+      # @describe Retrieves available resources represented by resource locations (URIs).
+      # If no type identifier is specified, all available resource are listed.
+      # Type identifier can be specified in its shortened format (e.g. "compute",
+      # "storage", "network").
+      #
+      # @example
+      #    client.list
+      #     # => [ "http://localhost:3300/compute/jh425jhj3h413-7dj29d7djd9e3-djh2jh4j4j",
+      #     #      "http://localhost:3300/network/kh425jhj3h413-7dj29d7djd9e3-djh2jh4j4j",
+      #     #      "http://localhost:3300/storage/lh425jhj3h413-7dj29d7djd9e3-djh2jh4j4j" ]
+      #    client.list "compute"
+      #     # => [ "http://localhost:3300/compute/jh425jhj3h413-7dj29d7djd9e3-djh2jh4j4j" ]
+      #    client.list "http://schemas.ogf.org/occi/infrastructure#compute"
+      #     # => [ "http://localhost:3300/compute/jh425jhj3h413-7dj29d7djd9e3-djh2jh4j4j" ]
+      #
+      # @param [String] resource type identifier or just type name
+      # @return [Array<String>] list of links
+      def list(resource_type_identifier = nil, is_wait = true, is_parse_response = true)
+
+        if resource_type_identifier
+          # convert type to type identifier
+          resource_type_identifier = @model.kinds.select {
+              |kind| kind.term == resource_type_identifier
+          }.first.type_identifier if @model.kinds.select {
+              |kind| kind.term == resource_type_identifier
+          }.any?
+
+          # check some basic pre-conditions
+          raise "Endpoint is not connected!" unless @connected
+          raise "Unkown resource type identifier! [#{resource_type_identifier}]" unless @model.get_by_id resource_type_identifier
+
+          # split the type identifier and get the most important part
+          uri_part = resource_type_identifier.split('#').last
+
+          # request uri-list from the server
+          path = uri_part + '/'
+        else
+          path = '/'
+        end
+
+        message_id = get(path, true)
+
+        return response_value(message_id, is_wait, is_parse_response)
+      end
+
+      # @describe Retrieves descriptions for available resources specified by a type
+      # identifier or resource location. If no type identifier or location
+      # is specified, all available resources in all available resource types
+      # will be described.
+      #
+      # @example
+      #    client.describe
+      #     # => [#<Occi::Collection>, #<Occi::Collection>, #<Occi::Collection>]
+      #    client.describe "compute"
+      #     # => [#<Occi::Collection>, #<Occi::Collection>, #<Occi::Collection>]
+      #    client.describe "http://schemas.ogf.org/occi/infrastructure#compute"
+      #     # => [#<Occi::Collection>, #<Occi::Collection>, #<Occi::Collection>]
+      #    client.describe "http://localhost:3300/compute/j5hk1234jk2524-2j3j2k34jjh234-adfaf1234"
+      #     # => [#<Occi::Collection>]
+      #
+      # @param [String] resource type identifier, type name or resource location
+      # @return [Array<Occi::Collection>] list of resource descriptions
+      def describe(resource_type_identifier=nil, is_wait = true, is_parse_response = true)
+
+        raise "Endpoint is not connected!" unless @connected
+
+        # convert type to type identifier
+        resource_type_identifier = @model.kinds.select {
+            |kind| kind.term == resource_type_identifier
+        }.first.type_identifier if @model.kinds.select {
+            |kind| kind.term == resource_type_identifier
+        }.any?
+
+        descriptions = []
+
+        if resource_type_identifier.nil?
+          descriptions << response_value(get('/'), is_wait, is_parse_response)
+        elsif @model.get_by_id resource_type_identifier
+          # we got type identifier
+          # get all available resources of this type
+          locations     = list resource_type_identifier
+
+          # make the requests
+          locations.each do |location|
+            descriptions << response_value(get(sanitize_resource_link(location)), is_wait, is_parse_response)
+          end
+        elsif resource_type_identifier.start_with? @endpoint
+          # we got resource link
+          # make the request
+          descriptions << response_value(get(sanitize_resource_link(resource_type_identifier)), is_wait, is_parse_response)
+        else
+          raise "Unkown resource type identifier! [#{resource_type_identifier}]"
+        end
+
+        descriptions
+      end
+
+      # Creates a new resource on the server. Resource must be provided
+      # as an instance of Occi::Core::Entity, e.g. instantiated using
+      # the get_resource method.
+      #
+      # @example
+      #    res = client.get_resource "compute"
+      #
+      #    res.title = "MyComputeResource1"
+      #    res.mixins << client.find_mixin('small', "resource_tpl")
+      #    res.mixins << client.find_mixin('debian6', "os_tpl")
+      #
+      #    client.create res # => "http://localhost:3300/compute/df7698...f987fa"
+      #
+      def create(entity, is_wait = true, is_parse_response = true)
+
+        # check some basic pre-conditions
+        raise "Endpoint is not connected!" unless @connected
+        raise "#{entity} not an entity" unless entity.kind_of? Occi::Core::Entity
+
+        # is this entity valid?
+        entity.model = @model
+        entity.check
+        kind = entity.kind
+        raise "No kind found for #{entity}" unless kind
+
+        # get location for this kind of entity
+        location   = entity.kind.location
+        collection = Occi::Collection.new
+
+        # is this entity a Resource or a Link?
+        collection.resources << entity if entity.kind_of? Occi::Core::Resource
+        collection.links << entity if entity.kind_of? Occi::Core::Link
+
+        # make the request
+        response_value(post(location, collection), is_wait, is_parse_response)
+      end
+
+      # Deletes a resource or all resource of a certain resource type
+      # from the server.
+      #
+      # @example
+      #    client.delete "compute" # => true
+      #    client.delete "http://schemas.ogf.org/occi/infrastructure#compute" # => true
+      #    client.delete "http://localhost:3300/compute/245j42594...98s9df8s9f" # => true
+      #
+      # @param [String] resource type identifier, type name or location
+      # @return [Boolean] status
+      def delete(resource_type_identifier, is_wait = true, is_parse_response = true)
+        # convert type to type identifier
+        resource_type_identifier = @model.kinds.select {
+            |kind| kind.term == resource_type_identifier
+        }.first.type_identifier if @model.kinds.select {
+            |kind| kind.term == resource_type_identifier
+        }.any?
+
+        # check some basic pre-conditions
+        raise "Endpoint is not connected!" unless @connected
+
+        if resource_type_identifier.nil? || resource_type_identifier == "/"
+          path = "/"
+        else
+          raise "Unknown resource identifier! #{resource_type_identifier}" unless resource_type_identifier.start_with? @endpoint
+          path = sanitize_resource_link(resource_type_identifier)
+        end
+
+        # make the request
+        response_value(del(path), is_wait, is_parse_response)
+      end
+
+      # Triggers given action on a specific resource.
+      #
+      # @example
+      #    TODO: add examples
+      #
+      # @param [String] resource location
+      # @param [String] type of action
+      # @return [String] resource location
+      def trigger(resource_type_identifier, action, is_wait = true, is_parse_response = true)
+
+        # TODO: not tested
+        resource_type_identifier = @model.kinds.select {
+            |kind| kind.term == resource_type_identifier
+        }.first.type_identifier if @model.kinds.select {
+            |kind| kind.term == resource_type_identifier
+        }.any?
+
+        # check some basic pre-conditions
+        raise "Endpoint is not connected!" unless @connected
+
+        if resource_type_identifier.nil? || resource_type_identifier == "/"
+          path = "/"
+        else
+          raise "Unknown resource identifier! #{resource_type_identifier}" unless resource_type_identifier.start_with? @endpoint
+          path = sanitize_resource_link(resource_type_identifier)
+        end
+
+        # encapsulate the acion in a collection
+        collection   = Occi::Collection.new
+        scheme, term = action.split('#')
+        collection.actions << Occi::Core::Action.new(scheme + '#', term)
+
+        #@media_type = "text/plain"
+
+        # make the request
+        path =  path + '?action=' + term
+        response_value(post(path, collection))
+      end
+
+      def parse_message(message_id, delete_response = true)
+        raise "message is empty for message_id(#{ message_id })" if @response_messages.nil? || @response_messages[message_id].nil?
+
+        payload  = @response_messages[message_id][:payload]
+        type     = @response_messages[message_id][:type]
+        metadata = @response_messages[message_id][:metadata]
+
+        @last_response_status = metadata.headers["status_code"]
+
+        @response_messages.delete(message_id) if delete_response
+
+        raise "OCCI-Server raise error: #{ payload } server status: #{ @last_response_status }" if metadata.headers["is_error"]
+
+        begin
+          return method("parse_#{ type }").call(payload, metadata)
+        rescue Exception => e
+          error_msg = e.message + "\n" + e.backtrace.to_s
+          Occi::Log.error error_msg
+          raise "Can not parse #{ type } payload: #{ payload } metadata: #{ metadata.inspect }"
+        end
+      end
+
+      # Looks up a mixin using its name and, optionally, a type as well.
+      # Will return mixin's full location (a link) or a description.
+      #
+      # @example
+      #    client.find_mixin "debian6"
+      #     # => "http://my.occi.service/occi/infrastructure/os_tpl#debian6"
+      #    client.find_mixin "debian6", "os_tpl"
+      #     # => "http://my.occi.service/occi/infrastructure/os_tpl#debian6"
+      #    client.find_mixin "large", "resource_tpl"
+      #     # => "http://my.occi.service/occi/infrastructure/resource_tpl#large"
+      #    client.find_mixin "debian6", "resource_tpl" # => nil
+      #
+      # @param [String] name of the mixin
+      # @param [String] type of the mixin
+      # @param [Boolean] should we describe the mixin or return its link?
+      # @return [String, Occi::Collection, nil] link, mixin description or nothing found
+      def find_mixin(name, type = nil, describe = false)
+
+        Occi::Log.debug("Looking for mixin #{name} + #{type} + #{describe}")
+
+        # is type valid?
+        if type
+          raise "Unknown mixin type! [#{type}]" unless @mixins.has_key? type.to_sym
+        end
+
+        # TODO: extend this code to support multiple matches and regex filters
+        # should we look for links or descriptions?
+        if describe
+          # we are looking for descriptions
+          if type
+            # get the first match from either os_tpls or resource_tpls
+            case
+              when type == "os_tpl"
+                get_os_templates.select { |mixin| mixin.term == name }.first
+              when type == "resource_tpl"
+                get_resource_templates.select { |template| template.term == name }.first
+              else
+                nil
+            end
+          else
+            # try in os_tpls first
+            found = get_os_templates.select { |os| os.term == name }.first
+
+            # then try in resource_tpls
+            found = get_resource_templates.select {
+                |template| template.term == name
+            }.first unless found
+
+            found
+          end
+        else
+          # we are looking for links
+          # prefix mixin name with '#' to simplify the search
+          name = "#" + name
+          if type
+            # return the first match with the selected type
+            @mixins[type.to_sym].select {
+                |mixin| mixin.to_s.reverse.start_with? name.reverse
+            }.first
+          else
+            # there is no type preference, return first global match
+            @mixins.flatten(2).select {
+                |mixin| mixin.to_s.reverse.start_with? name.reverse
+            }.first
+          end
+        end
+      end
+
+      # Creates a new resource instance, resource should be specified
+      # by its name or identifier.
+      #
+      # @example
+      #   client.get_resource "compute" # => Occi::Core::Resource
+      #   client.get_resource "storage" # => Occi::Core::Resource
+      #   client.get_resource "http://schemas.ogf.org/occi/infrastructure#network"
+      #    # => Occi::Core::Resource
+      #
+      # @param [String] resource name or resource identifier
+      # @return [Occi::Core::Resource] new resource instance
+      def get_resource(resource_type)
+
+        Occi::Log.debug("Instantiating #{resource_type} ...")
+
+        if @model.get_by_id resource_type
+          # we got a resource type identifier
+          Occi::Core::Resource.new resource_type
+        elsif @model.kinds.select { |kind| kind.term == resource_type }.any?
+          # we got a resource type name
+          Occi::Core::Resource.new @model.kinds.select {
+              |kind| kind.term == resource_type
+          }.first.type_identifier
+        else
+          raise "Unknown resource type! [#{resource_type}]"
+        end
+
+      end
+
+      # Retrieves available os_tpls from the model.
+      #
+      # @example
+      #    get_os_templates # => #<Occi::Collection>
+      #
+      # @return [Occi::Collection] collection containing all registered OS templates
+      def get_os_templates
+        @model.get.mixins.select { |mixin| mixin.related.select { |rel| rel.end_with? 'os_tpl' }.any? }
+      end
+
+      # Retrieves available resource_tpls from the model.
+      #
+      # @example
+      #    get_resource_templates # => #<Occi::Collection>
+      #
+      # @return [Occi::Collection] collection containing all registered resource templates
+      def get_resource_templates
+        @model.get.mixins.select { |mixin| mixin.related.select { |rel| rel.end_with? 'resource_tpl' }.any? }
+      end
+
+      # Refreshes the Occi::Model used inside the client. Useful for
+      # updating the model without creating a new instance or
+      # reconnecting. Saves a lot of time in an interactive mode.
+      #
+      # @example
+      #    client.refresh
+      def refresh
+        # re-download the model from the server
+        set_model
+      end
+
+      # private stuff --------------------------------------------------------------------------------------------------
+      private
+
+      def parse_get(payload, metadata)
+        if metadata.content_type == "text/uri-list"
+          return payload.split("\n")
+        else
+          path = metadata.headers["path_info"]
+          kind = @model.get_by_location(('/' + path).match(/\/.*\//).to_s) if @model
+          kind ? entity_type = kind.entity_type : entity_type = nil
+          collection = Occi::Parser.parse(metadata.content_type, payload, path.include?("/-/"), entity_type)
+          return collection
+        end
+      end
+
+      def parse_post(payload, metadata)
+        return URI.parse(payload).to_s
+      end
+
+      def parse_delete(payload, metadata)
+        return true
+      end
+
+      def run
+        begin
+          AMQP.start(CONNECTION_SETTING) do |connection, open_ok|
+            @channel  = AMQP::Channel.new(connection)
+            @exchange = @channel.default_exchange
+
+            @channel.on_error(&method(:handle_channel_exception))
+
+            @replies_queue = @channel.queue(Time.now.to_f.to_s + Kernel.rand().to_s, :exclusive => true)
+            @replies_queue.subscribe(&method(:handle_message))
+
+            @connected = true;
+          end
+        rescue Exception => e
+          @thread_error = true
+          Occi::Log.error "Amqp Thread get an Error: #{e.message} \n #{e.backtrace.join("\n")}"
+        end
+      end
+
+      def handle_message(metadata, payload)
+
+        correlation_id = metadata.correlation_id
+
+        unless correlation_id.size > 0
+          raise "Message has no correlation_id (message_id)"
+        end
+
+        @response_messages = Hash.new                             if @response_messages.nil?
+        raise "Double Response Message ID: (#{ correlation_id })" if @response_messages.has_key?(correlation_id)
+
+        #save responses message
+        @response_messages[correlation_id] = {:payload => payload, :metadata => metadata, :type => @response_waiting[correlation_id][:options][:type]}
+
+        #delete message_id from waiting stack
+        @response_waiting.delete(correlation_id) unless @response_waiting.nil?
+      end
+
+      def set_model
+        collection = response_value(get('/-/'))
+        @model     = Occi::Model.new(collection)
+
+        @mixins = {
+            :os_tpl => [],
+            :resource_tpl => [],
+            :simulation => []
+        }
+
+        #
+        get_os_templates.each do |os_tpl|
+          @mixins[:os_tpl] << os_tpl.type_identifier unless os_tpl.nil? or os_tpl.type_identifier.nil?
+        end
+
+        #
+        get_resource_templates.each do |res_tpl|
+          @mixins[:resource_tpl] << res_tpl.type_identifier unless res_tpl.nil? or res_tpl.type_identifier.nil?
+        end
+      end
+
+      # Extracts the resource path from a resource link. It will remove the leading @endpoint
+      # and replace it with a slash.
+      #
+      # @example
+      #    sanitize_resource_link "http://localhost:3300/compute/35ad4f45gsf-gsfg524s6gsfg-sfgsf4gsfg"
+      #     # => "/compute/35ad4f45gsf-gsfg524s6gsfg-sfgsf4gsfg"
+      #
+      # @param [String] string containing the full resource link
+      # @return [String] extracted path, with a leading slash
+      def sanitize_resource_link(resource_link)
+        raise "Resource link #{resource_link} is not valid!" unless resource_link.start_with? @endpoint
+
+        resource_link.gsub @endpoint, '/'
+      end
+
+      #TODO filter
+      def get(path='', is_uri_list = false, filter=nil)
+        raise "OCCI AMQP is not connected!" if !@connected
+
+        options = {
+            :routing_key  => @endpoint_queue,
+            :type         => "get",
+            :content_type => "text/plain",
+            :reply_to     => reply_queue_name,
+            :message_id   => next_message_id,
+            :headers => {
+                :accept    => is_uri_list ? "text/uri-list" : @media_type,
+                :path_info => "/" + path.gsub(/\A\//, '')
+            }
+        }
+
+        publish('', options)
+
+        return options[:message_id]
+      end
+
+      #@description
+      #@param [String] path path to the resource
+      #@param [OCCI::Collection] collection
+      def post(path, collection=nil)
+        path       = path.reverse.chomp('/').reverse
+
+        if @media_type == 'application/occi+json'
+          message = collection.to_json
+          content_type = 'application/occi+json'
+        else
+          message = collection.to_text
+          content_type = 'text/plain'
+        end
+
+        options = {
+            :routing_key  => @endpoint_queue,
+            :content_type => content_type,
+            :type         => "post",
+            :reply_to     => reply_queue_name,  #queue for response from the rOCCI
+            :message_id   => next_message_id,  #Identifier for message so that the client can match the answer from the rOCCI
+            :headers => {
+                :accept    => "text/uri-list",
+                :path_info => "/#{ path }",
+                :auth => {
+                    :type     => "basic",
+                    :username => "user",
+                    :password => "mypass",
+                },
+            }
+        }
+
+        publish(message, options)
+
+        return options[:message_id]
+      end
+
+      # Performs DELETE requests and returns True on success.
+      #
+      # @example
+      #    del "/compute/65sf4g65sf4g-sf6g54sf5g-sfgsf32g3" # => true
+      #
+      # @param [String] path for the DELETE request
+      # @param [Occi::Collection] collection of filters (currently NOT used)
+      # @return [Boolean] status
+      def del(path, filter=nil)
+        # remove the leading slash
+        path.gsub!(/\A\//, '')
+
+        options = {
+            :routing_key  => @endpoint_queue,
+            :content_type => "text/plain",
+            :type         => "delete",
+            :reply_to     => reply_queue_name,  #queue for response from the rOCCI
+            :message_id   => next_message_id,  #Identifier for message so that the client can match the answer from the rOCCI
+            :headers => {
+                :accept    => @media_type,
+                :path_info => "/#{ path }",
+                :auth => {
+                    :type     => "basic",
+                    :username => "user",
+                    :password => "mypass",
+                },
+            }
+        }
+
+        publish('', options)
+
+        return options[:message_id]
+      end
+
+      def response_value(message_id, is_wait = true, is_parse_response = true)
+        waiting_for_response(message_id) if is_wait || is_parse_response
+
+        if is_parse_response
+          value = parse_message(message_id)
+        else
+          value = message_id
+        end
+
+        return value
+      end
+
+      # @param [String] message_id '' == all
+      def waiting_for_response(message_id = '')
+        return if @response_waiting.nil?
+
+        if message_id.size > 0
+          while !@response_waiting[message_id].nil?
+            sleep(0.1)
+          end
+        else
+          while size(@response_waiting) > 0
+            sleep(0.1)
+          end
+        end
+      end
+
+      def publish(message, options = {})
+        raise "No Message Id found" if options[:message_id] == nil?
+
+        @exchange.publish(message, options)
+
+        @response_waiting                       = Hash.new if @response_waiting.nil?
+        @response_waiting[options[:message_id]] = {:options => options, :message => message}
+      end
+
+      def reply_queue_name
+        @replies_queue.name
+      end
+
+      def next_message_id
+        @message_id  = 0 if @message_id.nil?
+        @message_id += 1
+        @message_id.to_s;
+      end
+
+      # Sets auth method and appropriate httparty attributes. Supported auth methods
+      # are: ["none"] and nil
+      #
+      # @example
+      #    change_auth { :type => "none" }
+      #
+      # @param [Hash] authentication options
+      def change_auth(auth_options)
+        @auth_options = auth_options
+
+        case @auth_options[:type]
+          when "none", nil
+            # do nothing
+          else
+            raise ArgumentError, "Unknown AUTH method [#{@auth_options[:type]}]!"
+        end
+      end
+
+      def handle_channel_exception(channel, channel_close)
+        Occi::Log.error "OCCI/AMQP: Channel-level exception [ code = #{channel_close.reply_code}, message = #{channel_close.reply_text} ]"
+      end
+
+      # Sets the logger and log levels. This allows users to pass existing logger
+      # instances to the rOCCI client.
+      #
+      # @example
+      #    set_logger { :out => STDERR, :level => Occi::Log::WARN, :logger => nil }
+      #
+      # @param [Hash] logger options
+      def set_logger(log_options)
+        if log_options[:logger].nil? or (not log_options[:logger].kind_of? Occi::Log)
+          logger       = Occi::Log.new(log_options[:out])
+          logger.level = log_options[:level]
+        end
+
+        self.class.debug_output $stderr if log_options[:level] == Occi::Log::DEBUG
+      end
+
+      # Checks whether the given endpoint URI is valid and adds a trailing
+      # slash if necessary.
+      #
+      # @example
+      #    prepare_endpoint "http://localhost:3300" # => "http://localhost:3300/"
+      #
+      # @param [String] endpoint URI in a non-canonical string
+      # @return [String] canonical endpoint URI in a string, with a trailing slash
+      def prepare_endpoint(endpoint)
+        raise 'Endpoint not a valid URI' if (endpoint =~ URI::ABS_URI).nil?
+
+        @endpoint       = endpoint.chomp('/') + '/'
+        @endpoint_queue = "amqp.occi.#{@endpoint}"
+      end
+
+    end
+
+    end
+  end
+end