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

data/lib/occi-api.rb

@@ -4,9 +4,13 @@ require 'rubygems/package'
 require 'occi-core'
 
 module Occi::Api; end
+module Occi::Api::Client; end
+module Occi::Api::Dsl; end
+module Occi::Api::Client::Errors; end
 
 require 'occi/api/version'
-require 'occi/api/client/client_base'
+require 'occi/api/client/authn_utils'
 require 'occi/api/client/errors'
+require 'occi/api/client/client_base'
 require 'occi/api/client/client_http'
 require 'occi/api/dsl'

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

@@ -4,84 +4,92 @@ if defined? JRUBY_VERSION
   require 'java'
 end
 
-module Occi
-  module Api
-    module Client
-
-      class AuthnUtils
-        CERT_REGEXP = /\n?(-----BEGIN CERTIFICATE-----\n.+?\n-----END CERTIFICATE-----)\n/m
-
-        # Reads credentials from a PKCS#12 compliant file. Returns
-        # X.509 certificate and decrypted private key in PEM
-        # formatted string.
-        #
-        # @example
-        #    extract_pem_from_pkcs12 "~/.globus/usercert.p12", "123456"
-        #      # => #<String>
-        #
-        # @param [String] Path to a PKCS#12 file with credentials
-        # @param [String] Password needed to unlock the PKCS#12 file
-        # @return [String] Decrypted credentials in a PEM formatted string
-        def self.extract_pem_from_pkcs12(path_to_p12_file, p12_password)
-          # decode certificate and its private key
-          pem_from_pkcs12 = ""
-          if defined? JRUBY_VERSION
-            # Java-based Ruby, read PKCS12 manually
-            # using KeyStore
-            keystore = Java::JavaSecurity::KeyStore.getInstance("PKCS12")
-            p12_input_stream = Java::JavaIo::FileInputStream.new(path_to_p12_file)
-            pass_char_array = Java::JavaLang::String.new(p12_password).to_char_array
-
-            # load and unlock PKCS#12 store
-            keystore.load p12_input_stream, pass_char_array
-
-            # read the first certificate and PK
-            cert = keystore.getCertificate("1")
-            pk = keystore.getKey("1", pass_char_array)
-
-            pem_from_pkcs12 << "-----BEGIN CERTIFICATE-----\n"
-            pem_from_pkcs12 << Java::JavaxXmlBind::DatatypeConverter.printBase64Binary(cert.getEncoded())
-            pem_from_pkcs12 << "\n-----END CERTIFICATE-----"
-
-            pem_from_pkcs12 << "\n"
-
-            pem_from_pkcs12 << "-----BEGIN PRIVATE KEY-----\n"
-            pem_from_pkcs12 << Java::JavaxXmlBind::DatatypeConverter.printBase64Binary(pk.getEncoded())
-            pem_from_pkcs12 << "\n-----END PRIVATE KEY-----"
-          else
-            # C-based Ruby, use OpenSSL::PKCS12
-            pkcs12 = OpenSSL::PKCS12.new(
-              File.open(
-                path_to_p12_file,
-                'rb'
-              ),
-              p12_password
-            )
-
-            # store cert and private key in a single PEM formatted string
-            pem_from_pkcs12 << pkcs12.certificate.to_pem << pkcs12.key.to_pem
-          end
-
-          pem_from_pkcs12
-        end
-
-        # Reads X.509 certificates from a file to an array.
-        #
-        # @example
-        #    certs_to_file_ary "~/.globus/usercert.pem"
-        #      # => [#<String>, #<String>, ...]
-        #
-        # @param [String] Path to a PEM file containing certificates
-        # @return [Array<String>] An array of read certificates
-        def self.certs_to_file_ary(ca_file)
-          # TODO: read and separate multiple certificates
-          certs_str = File.open(ca_file).read
-
-          certs_ary = certs_str.scan(CERT_REGEXP)
-          certs_ary ? certs_ary.flatten : []
-        end
+module Occi::Api::Client
+
+  class AuthnUtils
+
+    CERT_REGEXP = /\n?(-----BEGIN CERTIFICATE-----\n.+?\n-----END CERTIFICATE-----)\n/m
+
+    # Reads credentials from a PKCS#12 compliant file. Returns
+    # X.509 certificate and decrypted private key in PEM
+    # formatted string.
+    #
+    # @example
+    #    AuthnUtils.extract_pem_from_pkcs12 "~/.globus/usercert.p12", "123456"
+    #      # => #<String>
+    #
+    # @param [String] Path to a PKCS#12 file with credentials
+    # @param [String] Password needed to unlock the PKCS#12 file
+    # @return [String] Decrypted credentials in a PEM formatted string
+    def self.extract_pem_from_pkcs12(path_to_p12_file, p12_password)
+      # decode certificate and its private key
+      if defined? JRUBY_VERSION
+        extract_pem_from_pkcs12_java(path_to_p12_file, p12_password)
+      else
+        extract_pem_from_pkcs12_c(path_to_p12_file, p12_password)
       end
+    end
+
+    def self.extract_pem_from_pkcs12_java(path_to_p12_file, p12_password)
+      # Java-based Ruby, read PKCS12 manually
+      # using KeyStore
+      keystore = Java::JavaSecurity::KeyStore.getInstance("PKCS12")
+      p12_input_stream = Java::JavaIo::FileInputStream.new(path_to_p12_file)
+      pass_char_array = Java::JavaLang::String.new(p12_password).to_char_array
+
+      # load and unlock PKCS#12 store
+      keystore.load p12_input_stream, pass_char_array
+
+      # read the first certificate and PK
+      cert = keystore.getCertificate("1")
+      pk = keystore.getKey("1", pass_char_array)
+
+      pem_from_pkcs12 = ""
+
+      pem_from_pkcs12 << "-----BEGIN CERTIFICATE-----\n"
+      pem_from_pkcs12 << Java::JavaxXmlBind::DatatypeConverter.printBase64Binary(cert.getEncoded())
+      pem_from_pkcs12 << "\n-----END CERTIFICATE-----"
+
+      pem_from_pkcs12 << "\n"
+
+      pem_from_pkcs12 << "-----BEGIN PRIVATE KEY-----\n"
+      pem_from_pkcs12 << Java::JavaxXmlBind::DatatypeConverter.printBase64Binary(pk.getEncoded())
+      pem_from_pkcs12 << "\n-----END PRIVATE KEY-----"
 
+      pem_from_pkcs12
     end
+
+    def self.extract_pem_from_pkcs12_c(path_to_p12_file, p12_password)
+      # C-based Ruby, use OpenSSL::PKCS12
+      pem_from_pkcs12 = ""
+
+      pkcs12 = OpenSSL::PKCS12.new(
+        File.open(path_to_p12_file, 'rb'),
+        p12_password
+      )
+
+      # store cert and private key in a single PEM formatted string
+      pem_from_pkcs12 << pkcs12.certificate.to_pem << pkcs12.key.to_pem
+
+      pem_from_pkcs12
+    end
+
+    # Reads X.509 certificates from a file to an array.
+    #
+    # @example
+    #    AuthnUtils.certs_to_file_ary "~/.globus/usercert.pem"
+    #      # => [#<String>, #<String>, ...]
+    #
+    # @param [String] Path to a PEM file containing certificates
+    # @return [Array<String>] An array of read certificates
+    def self.certs_to_file_ary(ca_file)
+      # TODO: read and separate multiple certificates
+      certs_str = File.open(ca_file).read
+
+      certs_ary = certs_str.scan(CERT_REGEXP)
+      certs_ary ? certs_ary.flatten : []
+    end
+
   end
+
 end

data/lib/occi/api/client/base/category_methods.rb

@@ -0,0 +1,54 @@
+module Occi::Api::Client
+  module Base
+
+    module CategoryMethods
+
+      # Retrieves all available category types.
+      #
+      # @example
+      #    client.get_category_types # => [ "entity", "resource", "link" ]
+      #
+      # @return [Array<String>] list of available category types in a human-readable format
+      def get_category_types
+        @model.categories.to_a.collect { |category| category.term }
+      end
+
+      # Retrieves all available category type identifiers.
+      #
+      # @example
+      #    client.get_category_type_identifiers
+      #    # => [ "http://schemas.ogf.org/occi/core#entity",
+      #    #      "http://schemas.ogf.org/occi/core#resource",
+      #    #      "http://schemas.ogf.org/occi/core#link" ]
+      #
+      # @return [Array<String>] list of available category type identifiers
+      def get_category_type_identifiers
+        @model.categories.to_a.collect { |category| category.type_identifier }
+      end
+
+      # Retrieves available category type identifier for the given category type.
+      #
+      # @example
+      #    client.get_category_type_identifier("compute")
+      #     # => 'http://schemas.ogf.org/occi/infrastructure#compute'
+      #
+      # @return [String, nil] category type identifier for the given category type
+      def get_category_type_identifier(type)
+        return type if (type =~ URI::ABS_URI) || (type && type.start_with?('/'))
+
+        cats = @model.categories.to_a.select { |k| k.term == type }
+        tis = cats.collect { |c| c.type_identifier }
+        tis.uniq!
+
+        if tis.length > 1
+          raise Occi::Api::Client::Errors::AmbiguousNameError,
+                "Category type #{type.inspect} is ambiguous, use a type identifier!"
+        end
+
+        tis.first
+      end
+
+    end
+
+  end
+end

data/lib/occi/api/client/base/entity_methods.rb

@@ -0,0 +1,172 @@
+module Occi::Api::Client
+  module Base
+
+    module EntityMethods
+
+      # 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.inspect}")
+
+        type_id = get_resource_type_identifier(resource_type)
+        raise "Unknown resource type! #{resource_type.inspect}" unless type_id
+
+        new_resource = Occi::Core::Resource.new(type_id)
+        new_resource.model = @model
+
+        new_resource
+      end
+
+      # Retrieves all available entity types.
+      #
+      # @example
+      #    client.get_entity_types # => [ "entity", "resource", "link" ]
+      #
+      # @return [Array<String>] list of available entity types in a human-readable format
+      def get_entity_types
+        collection = @model.get(Occi::Core::Entity.kind.type_identifier)
+        collection.kinds.to_a.collect { |kind| kind.term }
+      end
+
+      # Retrieves all available entity type identifiers.
+      #
+      # @example
+      #    client.get_kind_type_identifiers
+      #    # => [ "http://schemas.ogf.org/occi/core#entity",
+      #    #      "http://schemas.ogf.org/occi/core#resource",
+      #    #      "http://schemas.ogf.org/occi/core#link" ]
+      #
+      # @return [Array<String>] list of available entity types in a OCCI ID format
+      def get_entity_type_identifiers
+        get_kind_type_identifiers_related_to Occi::Core::Entity.kind.type_identifier
+      end
+
+      # Retrieves available entity type identifier for the given entity type.
+      #
+      # @example
+      #    client.get_entity_type_identifier("compute")
+      #     # => 'http://schemas.ogf.org/occi/infrastructure#compute'
+      #
+      # @return [String, nil] entity type identifier for the given entity type
+      def get_entity_type_identifier(type)
+        return type if (type =~ URI::ABS_URI) || (type && type.start_with?('/'))
+
+        collection = @model.get(Occi::Core::Entity.kind.type_identifier)
+        e_kinds = collection.kinds.to_a.select { |e| e.term == type }
+        tis = e_kinds.collect { |e| e.type_identifier }
+        tis.uniq!
+
+        if tis.length > 1
+          raise Occi::Api::Client::Errors::AmbiguousNameError,
+                "Entity type #{type.inspect} is ambiguous, use a type identifier!"
+        end
+
+        tis.first
+      end
+
+      # Retrieves all available resource types.
+      #
+      # @example
+      #    client.get_resource_types # => [ "compute", "storage", "network" ]
+      #
+      # @return [Array<String>] list of available resource types in a human-readable format
+      def get_resource_types
+        collection = @model.get(Occi::Core::Resource.kind.type_identifier)
+        collection.kinds.to_a.collect { |kind| kind.term }
+      end
+
+      # Retrieves all available resource type identifiers.
+      #
+      # @example
+      #    client.get_resource_type_identifiers
+      #    # => [ "http://schemas.ogf.org/occi/infrastructure#compute",
+      #    #      "http://schemas.ogf.org/occi/infrastructure#storage",
+      #    #      "http://schemas.ogf.org/occi/infrastructure#network" ]
+      #
+      # @return [Array<String>] list of available resource types in a Occi ID format
+      def get_resource_type_identifiers
+        get_kind_type_identifiers_related_to Occi::Core::Resource.kind.type_identifier
+      end
+
+      # Retrieves available resource type identifier for the given resource type.
+      #
+      # @example
+      #    client.get_resource_type_identifier("compute")
+      #     # => 'http://schemas.ogf.org/occi/infrastructure#compute'
+      #
+      # @return [String, nil] resource type identifier for the given resource type
+      def get_resource_type_identifier(type)
+        return type if (type =~ URI::ABS_URI) || (type && type.start_with?('/'))
+
+        collection = @model.get(Occi::Core::Resource.kind.type_identifier)
+        r_kinds = collection.kinds.to_a.select { |r| r.term == type }
+        tis = r_kinds.collect { |r| r.type_identifier }
+        tis.uniq!
+
+        if tis.length > 1
+          raise Occi::Api::Client::Errors::AmbiguousNameError,
+                "Resource type #{type.inspect} is ambiguous, use a type identifier!"
+        end
+
+        tis.first
+      end
+
+      # Retrieves all available link types.
+      #
+      # @example
+      #    client.get_link_types # => [ "storagelink", "networkinterface" ]
+      #
+      # @return [Array<String>] list of available link types in a human-readable format
+      def get_link_types
+        collection = @model.get(Occi::Core::Link.kind.type_identifier)
+        collection.kinds.to_a.collect { |kind| kind.term }
+      end
+
+      # Retrieves all available link type identifiers.
+      #
+      # @example
+      #    client.get_link_type_identifiers
+      #    # => [ "http://schemas.ogf.org/occi/infrastructure#storagelink",
+      #    #      "http://schemas.ogf.org/occi/infrastructure#networkinterface" ]
+      #
+      # @return [Array<String>] list of available link types in a OCCI ID format
+      def get_link_type_identifiers
+        get_kind_type_identifiers_related_to Occi::Core::Link.kind.type_identifier
+      end
+
+      # Retrieves available link type identifier for the given link type.
+      #
+      # @example
+      #    client.get_link_type_identifier("storagelink")
+      #     # => 'http://schemas.ogf.org/occi/infrastructure#storagelink'
+      #
+      # @return [String, nil] link type identifier for the given link type
+      def get_link_type_identifier(type)
+        return type if (type =~ URI::ABS_URI) || (type && type.start_with?('/'))
+
+        collection = @model.get(Occi::Core::Link.kind.type_identifier)
+        l_kinds = collection.kinds.to_a.select { |r| r.term == type }
+        tis = l_kinds.collect { |r| r.type_identifier }
+        tis.uniq!
+
+        if tis.length > 1
+          raise Occi::Api::Client::Errors::AmbiguousNameError,
+                "Link type #{type.inspect} is ambiguous, use a type identifier!"
+        end
+
+        tis.first
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,91 @@
+module Occi::Api::Client
+  module Base
+
+    module Helpers
+
+      # Returns the path for a given kind type identifier
+      #
+      # @example
+      #    path_for_kind_type_identifier "http://schemas.ogf.org/occi/infrastructure#compute"
+      #     # => "/compute/"
+      #    path_for_kind_type_identifier "http://localhost:3300/compute/35ad4f45gsf-gsfg524s6gsfg-sfgsf4gsfg"
+      #     # => "/compute/35ad4f45gsf-gsfg524s6gsfg-sfgsf4gsfg"
+      #
+      # @param [String] kind type identifier
+      # @return [String] 
+      def path_for_kind_type_identifier(kind_type_identifier)
+        raise ArgumentError,
+              "Kind type identifier is a required argument!" if kind_type_identifier.blank?
+
+        if kind_type_identifier.start_with?(@endpoint.to_s) || kind_type_identifier.start_with?('/')
+          #we got an instance link
+          return sanitize_instance_link(kind_type_identifier)
+        end
+
+        kind_type_id = get_kind_type_identifier(kind_type_identifier)
+        unless kind_type_id
+          raise ArgumentError,
+                "There is no such kind type registered in the model! #{kind_type_identifier.inspect}"
+        end
+
+        kinds = @model.kinds.select { |kind| kind.type_identifier == kind_type_id }
+        path_for_instance(kinds.first)
+      end
+
+      # Returns the path for a given instance, instances not providing
+      # path information will raise an exception.
+      #
+      # @example
+      #    path_for_instance Occi::Infrastructure::Network.new
+      #     # => "/network/35ad4f45gsf-gsfg524s6gsfg-sfgsf4gsfg"
+      #    path_for_instance Occi::Infrastructure::Compute.new
+      #     # => "/compute/35ad4f45gsf-gsfg524s6gsfg-sfgsf4gsfg"
+      #    path_for_instance Occi::Core::Mixin.new
+      #     # => "/mixin/my_mixin/"
+      #    path_for_instance Occi::Infrastructure::Storagelink.new
+      #     # => "/link/storagelink/35ad4f45gsf-gsfg524s6gsfg-sfgsf4gsfg"
+      #
+      # @param [Object] instance
+      # @return [String] path for the given instance
+      def path_for_instance(instance)
+        unless instance.respond_to?(:location)
+          raise Occi::Api::Client::Errors::TypeMismatchError,
+                "Expected an instance responding to #location, " \
+                "got #{instance.class.name.inspect}"
+        end
+
+        if instance.location.blank?
+          raise Occi::Api::Client::Errors::LocationError,
+                "Instance of #{instance.class.name.inspect} has " \
+                "an empty location"
+        end
+
+        instance.location
+      end
+
+      # Extracts path from an instance link. It will remove the leading @endpoint
+      # and replace it with a slash.
+      #
+      # @example
+      #    sanitize_instance_link "http://localhost:3300/compute/35ad4f45gsf-gsfg524s6gsfg-sfgsf4gsfg"
+      #     # => "/compute/35ad4f45gsf-gsfg524s6gsfg-sfgsf4gsfg"
+      #    sanitize_instance_link "/compute/35ad4f45gsf-gsfg524s6gsfg-sfgsf4gsfg"
+      #     # => "/compute/35ad4f45gsf-gsfg524s6gsfg-sfgsf4gsfg"
+      #
+      # @param [String] string containing the full instance link
+      # @return [String] extracted path, with a leading slash
+      def sanitize_instance_link(instance_link)
+        # everything starting with '/' is considered to be a resource path
+        return instance_link if instance_link.start_with? '/'
+
+        unless instance_link.start_with?(@endpoint.to_s)
+          raise ArgumentError, "Resource link #{instance_link.inspect} is not valid!"
+        end
+
+        URI(instance_link).request_uri
+      end
+
+    end
+
+  end
+end