occi-api 4.2.0.beta.4 → 4.2.0.beta.6

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

@@ -1,4 +1,2 @@
-module Occi::Api::Client::Errors; end
-
 # load all
 Dir[File.join(File.dirname(__FILE__), 'errors', '*.rb')].each { |file| require file.gsub('.rb', '') }

data/lib/occi/api/client/http/authn_plugins.rb

@@ -1,6 +1,3 @@
-require 'occi/api/client/http/authn_plugins/base'
-require 'occi/api/client/http/authn_plugins/dummy'
-require 'occi/api/client/http/authn_plugins/basic'
-require 'occi/api/client/http/authn_plugins/digest'
-require 'occi/api/client/http/authn_plugins/x509'
-require 'occi/api/client/http/authn_plugins/keystone'
+# load all plugins
+require File.join(File.dirname(__FILE__), 'authn_plugins', 'base')
+Dir[File.join(File.dirname(__FILE__), 'authn_plugins', '*.rb')].each { |file| require file.gsub('.rb', '') }

data/lib/occi/api/client/http/code_helpers.rb

@@ -0,0 +1,64 @@
+module Occi::Api::Client
+  module Http
+
+    module CodeHelpers
+
+      # 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"
+      }
+
+      # Converts HTTP response codes to human-readable phrases.
+      #
+      # @example
+      #    reason_phrase(500) # => "Internal Server Error"
+      #
+      # @param [Integer] HTTP response code
+      # @return [String] human-readable phrase
+      def reason_phrase(code)
+        HTTP_CODES[code.to_s]
+      end
+
+    end
+
+  end
+end

data/lib/occi/api/client/http/helpers.rb

@@ -0,0 +1,99 @@
+module Occi::Api::Client
+  module Http
+
+    module Helpers
+
+      # @see Occi::Api::Client::ClientBase
+      def get_logger(log_options)
+        logger = super(log_options)
+        self.class.debug_output $stderr if logger.level == Occi::Log::DEBUG
+
+        logger
+      end
+
+      # @see Occi::Api::Client::ClientBase
+      def get_auth(auth_options, fallback = false)
+        # select appropriate authN type
+        case auth_options[:type]
+        when "basic"
+          @authn_plugin = Http::AuthnPlugins::Basic.new self, auth_options
+        when "digest"
+          @authn_plugin = Http::AuthnPlugins::Digest.new self, auth_options
+        when "x509"
+          @authn_plugin = Http::AuthnPlugins::X509.new self, auth_options
+        when "keystone"
+          raise ::Occi::Api::Client::Errors::AuthnError, "This authN method is for fallback only!" unless fallback
+          @authn_plugin = Http::AuthnPlugins::Keystone.new self, auth_options
+        when "none", nil
+          @authn_plugin = Http::AuthnPlugins::Dummy.new self
+        else
+          raise ::Occi::Api::Client::Errors::AuthnError, "Unknown authN method [#{@auth_options[:type]}]!"
+        end
+
+        @authn_plugin.setup
+
+        auth_options
+      end
+
+      # @see Occi::Api::Client::ClientBase
+      def preauthenticate
+        begin
+          @authn_plugin.authenticate
+        rescue ::Occi::Api::Client::Errors::AuthnError => e
+          Occi::Log.debug e.message
+
+          if @authn_plugin.fallbacks.any?
+            # TODO: multiple fallbacks
+            @auth_options[:original_type] = @auth_options[:type]
+            @auth_options[:type] = @authn_plugin.fallbacks.first
+
+            @auth_options = get_auth(@auth_options, true)
+            @authn_plugin.authenticate
+          else
+            raise e
+          end
+        end
+      end
+
+      # @see Occi::Api::Client::ClientBase
+      def get_media_type(force_type = nil)
+        # force media_type if provided
+        unless force_type.blank?
+          self.class.headers 'Accept' => force_type
+          media_type = force_type
+        else
+          media_types = self.class.head(@endpoint.to_s).headers['accept']
+
+          Occi::Log.debug("Available media types: #{media_types.inspect}")
+          media_type = case media_types
+          when /application\/occi\+json/
+            'application/occi+json'
+          when /application\/occi\+xml/
+            'application/occi+xml'
+          when /text\/occi/
+            'text/occi'
+          else
+            'text/plain'
+          end
+        end
+
+        media_type
+      end
+
+      # Generates a human-readable response message based on the HTTP response code.
+      #
+      # @example
+      #    response_message self.class.delete(path)
+      #     # =>  'HTTP Response status: [200] OK'
+      #
+      # @param [HTTParty::Response] HTTParty response object
+      # @return [String] message
+      def response_message(response)
+        @last_response = response
+        "HTTP Response status: [#{response.code.to_s}] #{reason_phrase(response.code)}"
+      end
+
+    end
+
+  end
+end

data/lib/occi/api/client/http/monkey_patches.rb

@@ -0,0 +1,2 @@
+# load all fixes
+Dir[File.join(File.dirname(__FILE__), 'monkey_patches', '*.rb')].each { |file| require file.gsub('.rb', '') }

data/lib/occi/api/client/http/{httparty_fix.rb → monkey_patches/httparty_fix.rb}

@@ -1,3 +1,7 @@
+##############################################################################
+## HTTParty hack allowing the use of X.509 proxy certificates.
+##############################################################################
+
 module HTTParty
   class ConnectionAdapter
 

data/lib/occi/api/client/http/party_wrappers.rb

@@ -0,0 +1,173 @@
+module Occi::Api::Client
+  module Http
+
+    module PartyWrappers
+
+      # Performs GET request and parses the responses to collections.
+      #
+      # @example
+      #    get "/-/" # => #<Occi::Collection>
+      #    get "/compute/" # => #<Occi::Collection>
+      #    get "/compute/fs65g4fs6g-sf54g54gsf-aa12faddf52" # => #<Occi::Collection>
+      #
+      # @param [String] path for the GET request
+      # @param [Occi::Collection] collection of filters
+      # @return [Occi::Collection] parsed result of the request
+      def get(path='/', filter=nil)
+        # apply filters if present
+        response = if filter
+          categories = filter.categories.collect { |category| category.to_text }.join(',')
+          attributes = filter.entities.collect { |entity| entity.attributes.combine.collect { |k, v| k + '=' + v } }.join(',')
+
+          headers = self.class.headers.clone
+          headers['Content-Type'] = 'text/occi'
+          headers['Category'] = categories unless categories.empty?
+          headers['X-OCCI-Attributes'] = attributes unless attributes.empty?
+
+          self.class.get(path, :headers => headers)
+        else
+          self.class.get(path)
+        end
+
+        response_msg = response_message response
+        raise "HTTP GET failed! #{response_msg}" unless response.code.between? 200, 300
+
+        Occi::Log.debug "Response location: #{path.inspect}"
+        kind = @model.get_by_location(path) if @model
+
+        Occi::Log.debug "Response kind: #{kind.inspect}"
+
+        entity_type = nil
+        if kind && kind.related_to?(Occi::Core::Link)
+          entity_type = Occi::Core::Link
+        end
+
+        entity_type = Occi::Core::Resource unless entity_type
+
+        Occi::Log.debug "Parser call: #{response.content_type} #{path.include?('/-/')} #{entity_type} #{response.headers.inspect}"
+        collection = Occi::Parser.parse(response.content_type, response.body, path.include?('/-/'), entity_type, response.headers)
+
+        Occi::Log.debug "Parsed collection: empty? #{collection.empty?}"
+        collection
+      end
+
+      # Performs POST requests and returns URI locations. Resource data must be provided
+      # in an Occi::Collection instance.
+      #
+      # @example
+      #    collection = Occi::Collection.new
+      #    collection.resources << entity if entity.kind_of? Occi::Core::Resource
+      #    collection.links << entity if entity.kind_of? Occi::Core::Link
+      #
+      #    post "/compute/", collection # => "http://localhost:3300/compute/23sf4g65as-asdgsg2-sdfgsf2g"
+      #    post "/network/", collection # => "http://localhost:3300/network/23sf4g65as-asdgsg2-sdfgsf2g"
+      #    post "/storage/", collection # => "http://localhost:3300/storage/23sf4g65as-asdgsg2-sdfgsf2g"
+      #
+      # @param [String] path for the POST request
+      # @param [Occi::Collection] resource data to be POSTed
+      # @return [String] URI location
+      def post(path, collection)
+        raise ArgumentError, "Path is a required argument!" if path.blank?
+
+        headers = self.class.headers.clone
+        headers['Content-Type'] = @media_type
+
+        response = case @media_type
+        when 'application/occi+json'
+          self.class.post(path,
+                          :body => collection.to_json,
+                          :headers => headers)
+        when 'text/occi'
+          self.class.post(path,
+                          :headers => collection.to_header.merge(headers))
+        else
+          self.class.post(path,
+                          :body => collection.to_text,
+                          :headers => headers)
+        end
+
+        response_msg = response_message(response)
+
+        case response.code
+        when 200
+          collection = Occi::Parser.parse(response.header["content-type"].split(";").first, response.body)
+
+          if collection.empty?
+            Occi::Parser.locations(response.header["content-type"].split(";").first, response.body, response.headers).first
+          else
+            collection.resources.first.location if collection.resources.first
+          end
+        when 201
+          # TODO: OCCI-OS hack, look for header Location instead of uri-list
+          # This should be probably implemented in Occi::Parser.locations
+          if response.header['location']
+            response.header['location']
+          else
+            Occi::Parser.locations(response.header["content-type"].split(";").first, response.body, response.headers).first
+          end
+        else
+          raise "HTTP POST failed! #{response_msg}"
+        end
+      end
+
+      # Performs PUT requests and parses responses to collections.
+      #
+      # @example
+      #    TODO: add examples
+      #
+      # @param [String] path for the PUT request
+      # @param [Occi::Collection] resource data to send
+      # @return [Occi::Collection] parsed result of the request
+      def put(path, collection)
+        raise ArgumentError, "Path is a required argument!" if path.blank?
+
+        headers = self.class.headers.clone
+        headers['Content-Type'] = @media_type
+
+        response = case @media_type
+        when 'application/occi+json'
+          self.class.post(path,
+                          :body => collection.to_json,
+                          :headers => headers)
+        when 'text/occi'
+          self.class.post(path,
+                          :headers => collection.to_header.merge(headers))
+        else
+          self.class.post(path,
+                          :body => collection.to_text,
+                          :headers => headers)
+        end
+
+        response_msg = response_message(response)
+
+        case response.code
+        when 200, 201
+          Occi::Parser.parse(response.header["content-type"].split(";").first, response.body)
+        else
+          raise "HTTP POST failed! #{response_msg}"
+        end
+      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)
+        raise ArgumentError, "Path is a required argument!" if path.blank?
+
+        response = self.class.delete(path)
+
+        response_msg = response_message(response)
+        raise "HTTP DELETE failed! #{response_msg}" unless response.code.between? 200, 300
+
+        true
+      end
+
+    end
+
+  end
+end

data/lib/occi/api/dsl.rb

@@ -1,207 +1,46 @@
-module Occi
-  module Api
-    module Dsl
+# load all parts of the DSL
+Dir[File.join(File.dirname(__FILE__), 'dsl', '*.rb')].each { |file| require file.gsub('.rb', '') }
 
-      def connect(protocol, *args)
+module Occi::Api::Dsl
 
-        case protocol
-        when :http 
-          @client = Occi::Api::Client::ClientHttp.new(*args)
-        else
-          raise "Protocol #{protocol.to_s} is not supported!"
-        end
+  def connect(protocol = :http, options = {})
+    raise ArgumentError, 'Protocol is a required argument!' unless protocol
 
-        true
-      end
-
-      def list(*args)
-        check
-        @client.list(*args)
-      end
-
-      def describe(*args)
-        check
-        @client.describe(*args)
-      end
-
-      def create(*args)
-        check
-        @client.create(*args)
-      end
-
-      def delete(*args)
-        check
-        @client.delete(*args)
-      end
-
-      def trigger(*args)
-        check
-        @client.trigger(*args)
-      end
-
-      def refresh
-        check
-        @client.refresh
-      end
-
-      def model
-        check
-        @client.model
-      end
-
-      ###
-
-      def kind_types
-        check
-        @client.get_kind_types
-      end
-
-      def kind_type_identifier(*args)
-        check
-        @client.get_kind_type_identifier(*args)
-      end
-
-      def kind_type_identifiers
-        check
-        @client.get_kind_type_identifiers
-      end
-
-      def kind_type_identifiers_related_to(*args)
-        check
-        @client.get_kind_type_identifiers_related_to(*args)
-      end
-
-      def category_types
-        check
-        @client.get_category_types
-      end
-
-      def category_type_identifier(*args)
-        check
-        @client.get_category_type_identifier(*args)
-      end
-
-      def category_type_identifiers
-        check
-        @client.get_category_type_identifiers
-      end
-
-      def resource_types
-        check
-        @client.get_resource_types
-      end
-
-      def resource_type_identifier(*args)
-        check
-        @client.get_resource_type_identifier(*args)
-      end
-
-      def resource_type_identifiers
-        check
-        @client.get_resource_type_identifiers
-      end
-
-      def mixin_types
-        check
-        @client.get_mixin_types
-      end
-
-      def mixin_type_identifier(*args)
-        check
-        @client.get_mixin_type_identifier(*args)
-      end
-
-      def mixin_type_identifiers
-        check
-        @client.get_mixin_type_identifiers
-      end
-
-      def entity_types
-        check
-        @client.get_entity_types
-      end
-
-      def entity_type_identifier(*args)
-        check
-        @client.get_entity_type_identifier(*args)
-      end
-
-      def entity_type_identifiers
-        check
-        @client.get_entity_type_identifiers
-      end
-
-      def link_types
-        check
-        @client.get_link_types
-      end
-
-      def link_type_identifier(*args)
-        check
-        @client.get_link_type_identifier(*args)
-      end
-
-      def link_type_identifiers
-        check
-        @client.get_link_type_identifiers
-      end
-
-      ###
-
-      def mixins(*args)
-        check
-        @client.get_mixins(*args)
-      end
-
-      def os_templates
-        check
-        @client.get_os_templates
-      end
-
-      def resource_templates
-        check
-        @client.get_resource_templates
-      end
-
-      def mixin_list(*args)
-        check
-        @client.list_mixins(*args)
-      end
+    if block_given?
+      options = options.marshal_dump if options.is_a?(OpenStruct)
+      options = Hashie::Mash.new(options)
+      yield(options)
+    end
 
-      def resource(*args)
-        check
-        @client.get_resource(*args)
-      end
+    case protocol.to_sym
+    when :http 
+      @client = Occi::Api::Client::ClientHttp.new(options)
+    else
+      raise "Protocol #{protocol.to_s} is not supported!"
+    end
 
-      def mixin(*args)
-        check
-        @client.get_mixin(*args)
-      end
+    @client.connect unless @client.connected
 
-      ###
+    true
+  end
 
-      def path_for_kind_type_identifier(*args)
-        check
-        @client.path_for_kind_type_identifier(*args)
-      end
+  # include main request methods
+  include Occi::Api::Dsl::MainMethods
 
-      def path_for_instance(*args)
-        check
-        @client.path_for_instance(*args)
-      end
+  # include methods converting between types and type identifiers
+  include Occi::Api::Dsl::TypeMethods
 
-      def sanitize_instance_link(*args)
-        check
-        @client.sanitize_instance_link(*args)
-      end
+  # include methods helping with mixins
+  include Occi::Api::Dsl::MixinMethods
 
-      private
+  # include general helpers, normalizers etc.
+  include Occi::Api::Dsl::HelperMethods
 
-      def check
-        raise "You have to issue 'connect' first!" if @client.nil?
-        raise "Client is disconnected!" unless @client.connected
-      end
+  private
 
-    end
+  def check
+    raise "You have to issue 'connect' first!" unless @client
+    raise "Client is disconnected!" unless @client.connected
   end
+
 end