misty 1.4.0 → 1.5.1

data/lib/misty/auth/token.rb

@@ -0,0 +1,70 @@
+require 'misty/http/net_http'
+module Misty
+  module Auth
+    module Token
+      include Misty::HTTP::NetHTTP
+      attr_reader :catalog, :token
+
+      # Default Domain ID
+      DOMAIN_ID = 'default'
+
+      def self.build(auth)
+        if auth[:tenant_id] || auth[:tenant]
+          Misty::Auth::Token::V2.new(auth)
+        else
+          Misty::Auth::Token::V3.new(auth)
+        end
+      end
+
+      def initialize(auth)
+        @log = auth[:log]
+
+        if auth[:context] && auth[:context][:token] && auth[:context][:expires] && auth[:context][:catalog]
+          # Bypass authentication
+          @catalog = Misty::Auth::Catalog.new(auth[:context][:catalog])
+          @expires = auth[:context][:expires]
+          @token = auth[:context][:token]
+        else
+          raise URLError, 'No URL provided' if auth[:url].nil? || auth[:url].empty?
+          @creds = {
+            :data            => set_credentials(auth),
+            :ssl_verify_mode => auth[:ssl_verify_mode].nil? ? Misty::Config::SSL_VERIFY_MODE : auth[:ssl_verify_mode],
+            :uri             => URI.parse(auth[:url])
+          }
+          set(authenticate(@creds))
+        end
+      end
+
+      def get
+        set(authenticate(@creds)) if expired?
+        @token
+      end
+
+      private
+
+      def authenticate(creds)
+        Misty::HTTP::NetHTTP.http_request(
+          creds[:uri], ssl_verify_mode: creds[:ssl_verify_mode], log: @log
+        ) do |connection|
+          response = connection.post(path, creds[:data].to_json,
+            { 'Content-Type' => 'application/json', 'Accept' => 'application/json' })
+          unless response.code =~ /200|201/
+            raise AuthenticationError, "Response code=#{response.code}, Msg=#{response.msg}"
+          end
+          response
+        end
+      end
+
+      def expired?
+        if @expires.nil? || @expires.empty?
+          raise ExpiryError, 'Missing token expiration data'
+        end
+        Time.parse(@expires) < Time.now.utc
+      end
+
+      def refresh
+        raise StandardError, "__method__ not implemented yet!"
+      end
+    end
+  end
+end

data/lib/misty/auth/token/v2.rb

@@ -0,0 +1,63 @@
+require 'misty/auth/token'
+require 'misty/auth/name'
+
+module Misty
+  module Auth
+    module Token
+      class V2
+        include Misty::Auth::Token
+
+        def credentials
+          if @token
+            identity = { 'token': { 'id': @token } }
+          else
+            raise CredentialsError, "#{self.class}: User name is required" if @user.name.nil?
+            raise CredentialsError, "#{self.class}: User password is required" if @user.password.nil?
+            identity = { 'passwordCredentials': user_credentials }
+          end
+
+          if @tenant.id
+            identity.merge!('tenantId': @tenant.id)
+          elsif @tenant.name
+            identity.merge!('tenantName': @tenant.name)
+          else
+            raise CredentialsError, "#{self.class}: No tenant available"
+          end
+
+          { 'auth': identity }
+        end
+
+        def path
+          '/v2.0/tokens'
+        end
+
+        def user_credentials
+          {
+            'username': @user.name,
+            'password': @user.password
+          }
+        end
+
+        def set(response)
+          payload = JSON.load(response.body)
+          @token   = payload['access']['token']['id']
+          @expires = payload['access']['token']['expires']
+          catalog = payload['access']['serviceCatalog']
+          @catalog = Misty::Auth::Catalog::V2.new(catalog)
+        end
+
+        def set_credentials(auth)
+          if auth[:token]
+            @token = auth[:token]
+          else
+            @user = Misty::Auth::User.new(auth[:user_id], auth[:user])
+            @user.password = auth[:password]
+          end
+
+          @tenant = Misty::Auth::Name.new(auth[:tenant_id], auth[:tenant])
+          credentials
+        end
+      end
+    end
+  end
+end

data/lib/misty/auth/token/v3.rb

@@ -0,0 +1,90 @@
+require 'misty/auth/token'
+require 'misty/auth/name'
+
+module Misty
+  module Auth
+    module Token
+      class V3
+        include Misty::Auth::Token
+
+        def credentials
+          if @token
+            identity = {
+              'methods': ['token'],
+              'token': { 'id': @token }
+            }
+          else
+            identity = {
+              'methods': ['password'],
+              'password': @user.identity
+            }
+          end
+          {
+            'auth': {
+              'identity': identity,
+              'scope': scope
+            }
+          }
+        end
+
+        def path
+          '/v3/auth/tokens'
+        end
+
+        def scope
+          return @project.identity if @project
+          return @domain.identity if @domain
+          raise DomainScopeError, "#{self.class}: No scope available"
+        end
+
+        def set(response)
+          payload = JSON.load(response.body)
+          @token = response['x-subject-token']
+          @expires = payload['token']['expires_at']
+          catalog = payload['token']['catalog']
+          @catalog = Misty::Auth::Catalog::V3.new(catalog)
+        end
+
+        def set_credentials(auth)
+          if auth[:project_id] || auth[:project]
+            if auth[:project_domain_id].nil? && auth[:project_domain].nil?
+              project_domain_id = 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])
+            @project.domain = Misty::Auth::Name.new(project_domain_id, auth[:project_domain])
+          else
+            # scope: domain
+            if auth[:domain_id] || auth[:domain]
+              @domain = Misty::Auth::DomainScope.new(auth[:domain_id], auth[:domain])
+            else
+              # Use default Domain
+              @domain = Misty::Auth::DomainScope.new(DOMAIN_ID, nil)
+            end
+          end
+
+          if auth[:token]
+            @token = auth[:token]
+          else
+            @user = Misty::Auth::User.new(auth[:user_id], auth[:user])
+
+            if auth[:user_domain_id].nil? && auth[:user_domain].nil?
+              user_domain_id = 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]
+          end
+
+          credentials
+        end
+      end
+    end
+  end
+end

data/lib/misty/cloud.rb

@@ -1,6 +1,4 @@
 require 'misty/config'
-require 'misty/auth/auth_v2'
-require 'misty/auth/auth_v3'
 require 'misty/http/header'
 
 module Misty
@@ -22,10 +20,10 @@ module Misty
     end
 
     def build_service(method)
-      service = Misty.services.find {|service| service.name == method}
+      service = Misty.services.find {|service| service.type == 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}")
+      api_version = self.class.dot_to_underscore(service.default_version(service_config[:config][:api_version]))
+      klass = Object.const_get("Misty::Openstack::API::#{service.project.capitalize}::#{api_version.capitalize}")
       klass.new(service_config)
     end
 
@@ -77,6 +75,12 @@ module Misty
       @container_infrastructure_management
     end
 
+    def container_service(arg = {})
+      @container_service ||= build_service(__method__)
+      @container_service.request_config(args)
+      @container_service
+    end
+
     def data_processing(arg = {})
       @data_processing ||= build_service(__method__)
       @data_processing.request_config(arg)
@@ -101,6 +105,12 @@ module Misty
       @dns
     end
 
+    def event(arg = {})
+      @event ||= build_service(__method__)
+      @event.request_config(args)
+      @event
+    end
+
     def identity(arg = {})
       @identity ||= build_service(__method__)
       @identity.request_config(arg)
@@ -113,6 +123,18 @@ module Misty
       @image
     end
 
+    def instance_ha(arg = {})
+      @instance_ha ||= build_service(__method__)
+      @instance_ha.request_config(args)
+      @instance_ha
+    end
+
+    def key_manager(arg = {})
+      @key_manager ||= build_service(__method__)
+      @key_manager.request_config(args)
+      @key_manager
+    end
+
     def load_balancer(arg = {})
       @load_balancer ||= build_service(__method__)
       @load_balancer.request_config(arg)
@@ -131,10 +153,22 @@ module Misty
       @metering
     end
 
-    def networking(arg = {})
-      @networking ||= build_service(__method__)
-      @networking.request_config(arg)
-      @networking
+    def metric(arg = {})
+      @metric ||= build_service(__method__)
+      @metric.request_config(args)
+      @metric
+    end
+
+    def monitoring(arg = {})
+      @monitoring ||= build_service(__method__)
+      @monitoring.request_config(args)
+      @monitoring
+    end
+
+    def network(arg = {})
+      @network ||= build_service(__method__)
+      @network.request_config(arg)
+      @network
     end
 
     def nfv_orchestration(arg = {})
@@ -155,6 +189,24 @@ module Misty
       @orchestration
     end
 
+    def placement(arg = {})
+      @placement ||= build_service(__method__)
+      @placement.request_config(args)
+      @placement
+    end
+
+    def reservation(arg = {})
+      @reservation ||= build_service(__method__)
+      @reservation.request_config(args)
+      @reservation
+    end
+
+    def resource_optimization(arg = {})
+      @resource_optimization ||= build_service(__method__)
+      @resource_optimization.request_config(args)
+      @resource_optimization
+    end
+
     def search(arg = {})
       @search ||= build_service(__method__)
       @search.request_config(arg)
@@ -167,26 +219,33 @@ module Misty
       @shared_file_systems
     end
 
+    def workflow(arg = {})
+      @workflow ||= build_service(__method__)
+      @workflow.request_config(args)
+      @workflow
+    end
+
     alias domain_name_server dns
     alias volume block_storage
 
     private
 
-    def method_missing(method_name) # TODO, *args)
+    def method_missing(method_name, arg = {})
       services_avail = []
-      Misty.services.names.each do |service_name|
-        services_avail << service_name if /#{method_name}/.match(service_name)
+      Misty.services.types.each do |serv|
+        services_avail << serv if /^#{method_name}/.match(serv)
       end
 
       if services_avail.size == 1
-        # TODO: Add args
-        self.send(services_avail[0])
-        return self.instance_variable_get("@#{services_avail[0]}")
+        type = services_avail[0]
+        raise NoMethodError, "No such Cloud Service: #{method_name}" unless self.class.method_defined?(type)
       elsif services_avail.size > 1
         raise NoMethodError, "Ambiguous Cloud Service: #{method_name}"
       else
         raise NoMethodError, "No such Cloud Service: #{method_name}"
       end
+
+      send(type, arg)
     end
   end
 end

data/lib/misty/config.rb

@@ -1,7 +1,5 @@
 require 'logger'
-require 'misty/auth/auth_v2'
-require 'misty/auth/auth_v3'
-require 'misty/http/header'
+require 'misty/auth/token'
 
 module Misty
   class Config
@@ -15,7 +13,7 @@ module Misty
     INTERFACE = 'public'
 
     # Valid endpoint interfaces
-    INTERFACES = %w{admin public internal}
+    INTERFACES = %w(admin public internal)
 
     # Default Log file
     LOG_FILE  = '/dev/null'
@@ -24,34 +22,25 @@ module Misty
     LOG_LEVEL = Logger::INFO
 
     # Default Region
-    REGION_ID = 'regionOne'
+    REGION = 'regionOne'
 
     # Default when uri.scheme is https
     SSL_VERIFY_MODE = true
 
-    # ==== Attributes
-    #
-    # * +arg+ - +Hash+ of configuration options
-
-    attr_reader :auth, :log, :services
+    attr_reader :catalog, :token, :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
+      @services = set_services(arg)
+      arg[:log] = @log
+      @token = Misty::Auth::Token.build(arg[:auth])
     end
 
     def get_service(method)
       set = {}
-      set[:auth] = @auth
+      set[:token] = @token
       set[:log] = @log
       service_config = @services.key?(method) ? @services[method] : {}
       if service_config
@@ -65,54 +54,51 @@ module Misty
 
     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[:base_path] = arg[:base_path] ? arg[:base_path].chomp('/') : nil
+      set[:endpoint] = arg[:endpoint] ? arg[:endpoint] : nil
+      set[:service_name] = arg[:service_name] ? arg[:service_name] : nil
+      set[:version] = arg[:version] ? arg[: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[:region] = set_region(arg[:region], defaults[:region])
       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 get_defaults
+      set = {}
+      set[:content_type] = CONTENT_TYPE
+      set[:headers] = HTTP::Header.new('Accept' => 'application/json; q=1.0')
+      set[:interface] = INTERFACE
+      set[:region] = REGION
+      set[:ssl_verify_mode] = SSL_VERIFY_MODE
+      set
+    end
+
     def set_headers(val, default)
-      res = if val && !val.empty?
-              default.add(val)
-              default
-            else default
-              default
-            end
+      res = HTTP::Header.new
+      res.add(default.get)
+      res.add(val) if !val.nil? && !val.empty?
       res
     end
 
     def set_interface(val, default)
-        res = val.nil? ? default : val
+      res = val.nil? ? default : val
       raise InvalidDataError, "Config ':interface' must be one of #{INTERFACES}" unless INTERFACES.include?(res)
       res
     end
@@ -123,12 +109,20 @@ module Misty
       log
     end
 
-    def set_region_id(val, default)
+    def set_region(val, default)
         res = val.nil? ? default : val
-      raise InvalidDataError, "Config ':region_id' must be a String" unless res.kind_of? String
+      raise InvalidDataError, "Config ':region' must be a String" unless res.kind_of? String
       res
     end
 
+    def set_services(arg)
+      set = {}
+      arg.each do |e, k|
+        set[e] = k if Misty.services.find {|s| s.type == e}
+      end
+      set
+    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