misty 1.3.3 → 1.4.0

data/lib/misty.rb

@@ -1,4 +1,3 @@
-require 'logger'
 require 'json'
 require 'net/http'
 require 'time'
@@ -6,3 +5,4 @@ require 'uri'
 require 'misty/misty'
 require 'misty/autoload'
 require 'misty/cloud'
+require 'misty/errors'

data/lib/misty/auth.rb

@@ -1,20 +1,29 @@
-require 'misty/auth/errors'
+require 'logger'
 require 'misty/auth/name'
 require 'misty/http/net_http'
+require 'misty/config'
 
 module Misty
+
+  # The credentials are a combination of "id" and "name" used to uniquely identify the context.
+  # +Misty::Auth+ is mixing the common interface between +Misty::AuthV3+ and +Misty::AuthV2+
+  #
   module Auth
     include Misty::HTTP::NetHTTP
 
     attr_reader :catalog, :token
 
-    def self.factory(auth, config)
+    def self.build(auth)
       version = auth[:tenant_id] || auth[:tenant] ? 'V2' : 'V3'
       klass = Object.const_get("Misty::Auth#{version}")
-      klass.new(auth, config)
+      klass.new(auth)
     end
 
-    def initialize(auth, config)
+    # ==== Attributes
+    #
+    # * +auth+ - Hash of credentials parameters for authentication
+    #
+    def initialize(auth)
       if auth[:context]
         # bypass the authentication by given token catalog and expire date
         @token   = auth[:context][:token]
@@ -23,15 +32,17 @@ module Misty
       else
         raise URLError, 'No URL provided' if auth[:url].nil? || auth[:url].empty?
         @uri = URI.parse(auth[:url])
-        @config = config
+        @ssl_verify_mode = auth[:ssl_verify_mode] ? auth[:ssl_verify_mode] : Misty::Config::SSL_VERIFY_MODE
         @credentials = set_credentials(auth)
         @token, @catalog, @expires = set(authenticate)
+        # TODO: Pass main log object
+        @log = Logger.new('/dev/null')
       end
     end
 
     def authenticate
       Misty::HTTP::NetHTTP.http_request(
-        @uri, ssl_verify_mode: @config.ssl_verify_mode, log: @config.log
+        @uri, ssl_verify_mode: @ssl_verify_mode, log: @log
       ) do |connection|
         response = connection.post(path, @credentials.to_json,
           { 'Content-Type' => 'application/json', 'Accept' => 'application/json' })

data/lib/misty/auth/auth_v2.rb

@@ -1,6 +1,9 @@
 require 'misty/auth'
 
 module Misty
+  #
+  # Openstack Identity service Keystone version 2.0, which is deprecated, uses a tenant name or id to authenticates
+  # +Misty::AuthV2+ is used if the authentication credentials contains a tenant name or id.
   class AuthV2
     include Misty::Auth
 

data/lib/misty/auth/auth_v3.rb

@@ -48,10 +48,11 @@ module Misty
 
     def set_credentials(auth)
       if auth[:project_id] || auth[:project]
-        # scope: project
-        project_domain_id = auth[:project_domain_id]
-        if project_domain_id.nil? && auth[:project_domain].nil?
+        if auth[:project_domain_id].nil? && auth[:project_domain].nil?
           project_domain_id = Misty::DOMAIN_ID
+        else
+          project_domain_id = auth[:project_domain_id] if auth[:project_domain_id]
+          project_domain = auth[:project_domain] if auth[:project_domain]
         end
 
         @project = Misty::Auth::ProjectScope.new(auth[:project_id], auth[:project])
@@ -69,10 +70,17 @@ module Misty
       if auth[:token]
         @token = auth[:token]
       else
-        user_domain_id = auth[:user_domain_id] ? auth[:user_domain_id] : Misty::DOMAIN_ID
         @user = Misty::Auth::User.new(auth[:user_id], auth[:user])
+
+        if auth[:user_domain_id].nil? && auth[:user_domain].nil?
+          user_domain_id = Misty::DOMAIN_ID
+        else
+          user_domain_id = auth[:user_domain_id] if auth[:user_domain_id]
+          user_domain = auth[:user_domain] if auth[:user_domain]
+        end
+
+        @user.domain = Misty::Auth::Name.new(user_domain_id, user_domain)
         @user.password = auth[:password]
-        @user.domain = Misty::Auth::Name.new(user_domain_id, auth[:user_domain])
       end
 
       credentials

data/lib/misty/auth/name.rb

@@ -11,7 +11,7 @@ module Misty
           data.merge!(to_h(:name))
           data.merge!({ :domain => @domain.identity })
         else
-          raise CredentialsError, "#{self.class}: An Id, or a name with its domain, must be provided"
+          raise Misty::Config::CredentialsError, "#{self.class}: An Id, or a name with its domain, must be provided"
         end
         data
       end
@@ -21,7 +21,7 @@ module Misty
       def identity
         return to_h(:id) unless id.nil?
         return to_h(:name) unless name.nil?
-        raise CredentialsError, "#{self.class}: No available id or name"
+        raise Misty::Config::CredentialsError, "#{self.class}: No available id or name"
       end
 
       def to_h(var)
@@ -50,7 +50,7 @@ module Misty
 
       def identity
         data = super
-        raise CredentialsError, "#{self.class}: No password available" if password.nil?
+        raise Misty::Config::CredentialsError, "#{self.class}: No password available" if password.nil?
         data.merge!(to_h(:password))
         { :user => data }
       end

data/lib/misty/client_pack.rb

@@ -1,4 +1,4 @@
-require 'misty/client'
+require 'misty/openstack/service'
 require 'misty/http/net_http'
 require 'misty/http/method_builder'
 require 'misty/http/request'
@@ -7,7 +7,7 @@ require 'misty/http/header'
 
 module Misty
   module ClientPack
-    include Misty::Client
+    include Misty::Openstack::Service
     include Misty::HTTP::NetHTTP
     include Misty::HTTP::MethodBuilder
     include Misty::HTTP::Request

data/lib/misty/cloud.rb

@@ -1,150 +1,185 @@
+require 'misty/config'
 require 'misty/auth/auth_v2'
 require 'misty/auth/auth_v3'
 require 'misty/http/header'
 
 module Misty
-  class Cloud
-    class Config
-      attr_accessor :auth, :content_type, :interface, :log, :region_id, :ssl_verify_mode, :headers
-    end
-
-    attr_reader :auth
 
+  # +Misty::Cloud+ is the main OpenStack cloud class.
+  # An instance holds authentication information such as token, catalog and contains all available services as methods.
+  #
+  class Cloud
     def self.dot_to_underscore(val)
       val.gsub(/\./,'_')
     end
 
-    def initialize(params)
-      @params = params
-      @config = self.class.set_configuration(params)
-      @auth = Misty::Auth.factory(params[:auth], @config)
-    end
-
-    def self.set_configuration(params)
-      config = Config.new
-      config.content_type = params[:content_type] ? params[:content_type] : Misty::CONTENT_TYPE
-      config.interface = params[:interface] ? params[:interface] : Misty::INTERFACE
-      config.log = Logger.new(params[:log_file] ? params[:log_file] : Misty::LOG_FILE)
-      config.log.level = params[:log_level] ? params[:log_level] : Misty::LOG_LEVEL
-      config.region_id = params[:region_id] ? params[:region_id] : Misty::REGION_ID
-      config.ssl_verify_mode = params.key?(:ssl_verify_mode) ? params[:ssl_verify_mode] : Misty::SSL_VERIFY_MODE
-      config.headers = Misty::HTTP::Header.new('Accept' => 'application/json; q=1.0')
-      config.headers.add(params[:headers]) if params[:headers] && !params[:headers].empty?
-      config
+    # ==== Attributes
+    #
+    # * +arg+ - Hash of configuration parameters for authentication, log, and services options.
+    #
+    def initialize(arg)
+      @config = Misty::Config.new(arg)
     end
 
-    def build_service(service_name)
-      service = Misty.services.find {|service| service.name == service_name}
-      options = @params[service.name] ? @params[service.name] : {}
-      version = self.class.dot_to_underscore(service.version(options[:api_version]))
+    def build_service(method)
+      service = Misty.services.find {|service| service.name == method}
+      service_config = @config.get_service(method)
+      version = self.class.dot_to_underscore(service.default_version(service_config[:config][:api_version]))
       klass = Object.const_get("Misty::Openstack::#{service.project.capitalize}::#{version.capitalize}")
-      klass.new(@auth, @config, options)
+      klass.new(service_config)
     end
 
-    def application_catalog
-      @application_catalog ||= build_service(:application_catalog)
+    def application_catalog(arg = {})
+      @application_catalog ||= build_service(__method__)
+      @application_catalog.request_config(arg)
+      @application_catalog
     end
 
-    def alarming
-      @alarming ||= build_service(:alarming)
+    def alarming(arg = {})
+      @alarming ||= build_service(__method__)
+      @alarming.request_config(arg)
+      @alarming
     end
 
-    def backup
-      @backup ||= build_service(:backup)
+    def backup(arg = {})
+      @backup ||= build_service(__method__)
+      @backup.request_config(arg)
+      @backup
     end
 
-    def baremetal
-      @baremetal ||= build_service(:baremetal)
+    def baremetal(arg = {})
+      @baremetal ||= build_service(__method__)
+      @baremetal.request_config(arg)
+      @baremetal
     end
 
-    def block_storage
-      @block_storage ||= build_service(:block_storage)
+    def block_storage(arg = {})
+      @block_storage ||= build_service(__method__)
+      @block_storage.request_config(arg)
+      @block_storage
     end
 
-    def clustering
-      @clustering ||= build_service(:clustering)
+    def clustering(arg = {})
+      @clustering ||= build_service(__method__)
+      @clustering.request_config(arg)
+      @clustering
     end
 
-    def compute
-      @compute ||= build_service(:compute)
+    def compute(arg = {})
+      @compute ||= build_service(__method__)
+      @compute.request_config(arg)
+      @compute
     end
 
-    def container_infrastructure_management
-      @container_infrastructure_management ||= build_service(:container_infrastructure_management)
+    def container_infrastructure_management(arg = {})
+      @container_infrastructure_management ||= build_service(__method__)
+      @container_infrastructure_management.request_config(arg)
+      @container_infrastructure_management
     end
 
-    def data_processing
-      @data_processing ||= build_service(:data_processing)
+    def data_processing(arg = {})
+      @data_processing ||= build_service(__method__)
+      @data_processing.request_config(arg)
+      @data_processing
     end
 
-    def data_protection_orchestration
-      @data_protection_orchestration ||= build_service(:data_protection_orchestration)
+    def data_protection_orchestration(arg = {})
+      @data_protection_orchestration ||= build_service(__method__)
+      @data_protection_orchestration.request_config(arg)
+      @data_protection_orchestration
     end
 
-    def database
-      @database ||= build_service(:database)
+    def database(arg = {})
+      @database ||= build_service(__method__)
+      @database.request_config(arg)
+      @database
     end
 
-    def domain_name_server
-      @domain_name_server ||= build_service(:domain_name_server)
+    def dns(arg = {})
+      @dns ||= build_service(__method__)
+      @dns.request_config(arg)
+      @dns
     end
 
-    def identity
-      @identity ||= build_service(:identity)
+    def identity(arg = {})
+      @identity ||= build_service(__method__)
+      @identity.request_config(arg)
+      @identity
     end
 
-    def image
-      @image ||= build_service(:image)
+    def image(arg = {})
+      @image ||= build_service(__method__)
+      @image.request_config(arg)
+      @image
     end
 
-    def load_balancer
-      @load_balancer ||= build_service(:load_balancer)
+    def load_balancer(arg = {})
+      @load_balancer ||= build_service(__method__)
+      @load_balancer.request_config(arg)
+      @load_balancer
     end
 
-    def messaging
-      @messaging ||= build_service(:messaging)
+    def messaging(arg = {})
+      @messaging ||= build_service(__method__)
+      @messaging.request_config(arg)
+      @messaging
     end
 
-    def metering
-      @metering ||= build_service(:metering)
+    def metering(arg = {})
+      @metering ||= build_service(__method__)
+      @metering.request_config(arg)
+      @metering
     end
 
-    def networking
-      @networking ||= build_service(:networking)
+    def networking(arg = {})
+      @networking ||= build_service(__method__)
+      @networking.request_config(arg)
+      @networking
     end
 
-    def nfv_orchestration
-      @nfv_orchestration ||= build_service(:nfv_orchestration)
+    def nfv_orchestration(arg = {})
+      @nfv_orchestration ||= build_service(__method__)
+      @nfv_orchestration.request_config(arg)
+      @nfv_orchestration
     end
 
-    def object_storage
-      @object_storage ||= build_service(:object_storage)
+    def object_storage(arg = {})
+      @object_storage ||= build_service(__method__)
+      @object_storage.request_config(arg)
+      @object_storage
     end
 
-    def orchestration
-      @orchestration ||= build_service(:orchestration)
+    def orchestration(arg = {})
+      @orchestration ||= build_service(__method__)
+      @orchestration.request_config(arg)
+      @orchestration
     end
 
-    def search
-      @search ||= build_service(:search)
+    def search(arg = {})
+      @search ||= build_service(__method__)
+      @search.request_config(arg)
+      @search
     end
 
-    def shared_file_systems
-      @shared_file_systems ||= build_service(:shared_file_systems)
+    def shared_file_systems(arg = {})
+      @shared_file_systems ||= build_service(__method__)
+      @shared_file_systems.request_config(arg)
+      @shared_file_systems
     end
 
-    alias dns domain_name_server
+    alias domain_name_server dns
     alias volume block_storage
 
     private
 
-    def method_missing(method_name)
+    def method_missing(method_name) # TODO, *args)
       services_avail = []
       Misty.services.names.each do |service_name|
         services_avail << service_name if /#{method_name}/.match(service_name)
       end
 
       if services_avail.size == 1
+        # TODO: Add args
         self.send(services_avail[0])
         return self.instance_variable_get("@#{services_avail[0]}")
       elsif services_avail.size > 1

data/lib/misty/config.rb

@@ -0,0 +1,138 @@
+require 'logger'
+require 'misty/auth/auth_v2'
+require 'misty/auth/auth_v3'
+require 'misty/http/header'
+
+module Misty
+  class Config
+    # Default REST content type. Use :json or :hash
+    CONTENT_TYPE = :hash
+
+    # Valid content format
+    CONTENT_TYPES = %i{hash json}
+
+    # Default Interface
+    INTERFACE = 'public'
+
+    # Valid endpoint interfaces
+    INTERFACES = %w{admin public internal}
+
+    # Default Log file
+    LOG_FILE  = '/dev/null'
+
+    # Default Log level
+    LOG_LEVEL = Logger::INFO
+
+    # Default Region
+    REGION_ID = 'regionOne'
+
+    # Default when uri.scheme is https
+    SSL_VERIFY_MODE = true
+
+    # ==== Attributes
+    #
+    # * +arg+ - +Hash+ of configuration options
+
+    attr_reader :auth, :log, :services
+
+    def initialize(arg)
+      raise CredentialsError if arg.nil? || arg.empty? || arg[:auth].nil? || arg[:auth].empty?
+      @auth = Misty::Auth.build(arg[:auth]) # TODO: pass @log
+      @log = set_log(arg[:log_file], arg[:log_level])
+      @globals = set_config(arg)
+      @services = {}
+      # TODO: Adjust Services to use enumerable
+      arg.each do |e, k|
+        Misty::SERVICES.each do |serv|
+          @services[e] = k if serv[:name] == e
+        end
+      end
+    end
+
+    def get_service(method)
+      set = {}
+      set[:auth] = @auth
+      set[:log] = @log
+      service_config = @services.key?(method) ? @services[method] : {}
+      if service_config
+        set[:config] = set_config(service_config, @globals)
+        set[:config].merge!(set_service(service_config))
+      else
+        set[:config] = @globals
+      end
+      set
+    end
+
+    def set_service(arg)
+      set = {}
+      set[:base_path] = arg[:base_path] ? arg[:base_path] : nil
+      set[:base_url] = arg[:base_url] ? arg[:base_url] : nil
+      set[:version] = arg[:version] ? arg[:version] : nil
+      set[:api_version] = arg[:api_version] ? arg[:api_version] : nil
+      set
+    end
+
+    private
+
+    def get_defaults
+      set = {}
+      set[:content_type] = CONTENT_TYPE
+      set[:headers] = HTTP::Header.new('Accept' => 'application/json; q=1.0')
+      set[:interface] = INTERFACE
+      set[:region_id] = REGION_ID
+      set[:ssl_verify_mode] = SSL_VERIFY_MODE
+      set
+    end
+
+    def set_config(arg = {}, defaults = get_defaults)
+      set = {}
+      set[:content_type] = set_content_type(arg[:content_type], defaults[:content_type])
+      set[:headers] = set_headers(arg[:headers], defaults[:headers])
+      set[:interface] = set_interface(arg[:interface], defaults[:interface])
+      set[:region_id] = set_region_id(arg[:region_id], defaults[:region_id])
+      set[:ssl_verify_mode] = set_ssl_verify_mode(arg[:ssl_verify_mode], defaults[:ssl_verify_mode])
+      set
+    end
+
+
+    def set_content_type(val, default)
+      res = val.nil? ? default : val
+      raise InvalidDataError, "Config ':content_type' must be one of #{CONTENT_TYPES}" unless CONTENT_TYPES.include?(res)
+      res
+    end
+
+    def set_headers(val, default)
+      res = if val && !val.empty?
+              default.add(val)
+              default
+            else default
+              default
+            end
+      res
+    end
+
+    def set_interface(val, default)
+        res = val.nil? ? default : val
+      raise InvalidDataError, "Config ':interface' must be one of #{INTERFACES}" unless INTERFACES.include?(res)
+      res
+    end
+
+    def set_log(file, level)
+      log = Logger.new(file ? file : LOG_FILE)
+      log.level = level ? level : LOG_LEVEL
+      log
+    end
+
+    def set_region_id(val, default)
+        res = val.nil? ? default : val
+      raise InvalidDataError, "Config ':region_id' must be a String" unless res.kind_of? String
+      res
+    end
+
+    def set_ssl_verify_mode(val, default)
+        res = val.nil? ? default : val
+      raise InvalidDataError, "Config ':ssl_verify_mode' must be a Boolean" unless res == !!res
+      res
+    end
+  end
+end