misty 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '0108d5bb9451b9500d689c21f6cf43b4ae90186c'
-  data.tar.gz: a6d0744f4806007d55044ad7fe3f96e4be645ec0
+  metadata.gz: 8f77fca7e84ccf06eb7cf92b3c2ee1a9233d0427
+  data.tar.gz: d8d73c45718a708d0da3f5bf076aa0cc802c0f4c
 SHA512:
-  metadata.gz: b73c8d875c03a7495c5e84be31ca00e9b6b13667d0a576334e710f76a6586ec47a7400022ef29f6e896cea866793ac2d41f174cbfb9b81b6b016137875957335
-  data.tar.gz: 8df0ce513d52b08551537a0fe6dc702ce1d6f7e9f06ac43082c1f14a7c27d33952d136273592a8eb8ba6a936077c9eca8450bc49a897ef3dfcc85caae4d5a943
+  metadata.gz: 5a98bcc69158a796d55ee9ce9ba7ccb5cc6d6f99bc0fc9217137e00905a243cc1608aea11dd9dc996423dcfdc9c2ad25a1435bc17cbbe66cfc03c1c9e491ed78
+  data.tar.gz: 72475d27ad43c025522654ce010b520a837cfd70c403ae8ac70b632300ab7c900e03eda7f860d2fe53b095ce6324e3438304143e9957ff4866ee8c7849b68b84

data/README.md

@@ -152,6 +152,10 @@ The following parameters can be used:
   User domain id
 * `:user_domain`  
   User domain name  
+* `:password`
+  Password for user. Cannot be used together with `:token`.
+* `:token`
+  Previous Keystone v3 token for user. Can only be used with Keystone v3. Overrides all user and password parameters.
 
 #### Keystone v3
 Keystone v3 is default recommended version:
@@ -212,10 +216,6 @@ The following options are applied to each service unless specifically provided f
   Type: String  
   Allowed values: "public", "internal", "admin"  
   Default: "public"  
-* :http_proxy  
-  For example: `"http://userid:password@somewhere.com:8080/"` or `ENV["http_proxy"]`  
-  Type: String  
-  Default: `""`  
 * :ssl_verify_mode  
   When using SSL mode (defined by URI scheme => "https://")  
   Type: Boolean  
@@ -276,8 +276,12 @@ openstack.network.post("/v2.0/qos/policies/48985e6b8da145699d411f12a3459fca/dscp
 # Requirements
 
 ## Ruby versions tested
+* Ruby 2.4.1
 * Ruby 2.4.0
+* Ruby 2.3.4
 * Ruby 2.3.3
+* Ruby 2.3.2
+* Ruby 2.3.1
 * Ruby 2.3.0
 
 # Contributing

data/lib/misty/auth.rb

@@ -14,31 +14,27 @@ module Misty
 
     include Misty::HTTP::NetHTTP
 
-    def self.factory(options, *args)
-      if options[:tenant_id] || options[:tenant]
-        return Misty::AuthV2.new(options, *args)
+    attr_reader :catalog
+
+    def self.factory(auth, config)
+      if auth[:tenant_id] || auth[:tenant]
+        return Misty::AuthV2.new(auth, config)
       else
-        return Misty::AuthV3.new(options, *args)
+        return Misty::AuthV3.new(auth, config)
       end
     end
 
-    attr_reader :catalog
-
-    def initialize(options, proxy, ssl_verify_mode, log)
-      @ssl_verify_mode, @log =  ssl_verify_mode, log
-      @credentials = scoped_authentication
-
-      raise URLError, "No URL provided" unless options[:url] && !options[:url].empty?
-      @uri = URI.parse(options[:url])
-      @proxy = proxy
+    def initialize(auth, config)
+      raise URLError, "No URL provided" unless auth[:url] && !auth[:url].empty?
+      @credentials = set_credentials(auth)
+      @http = net_http(URI.parse(auth[:url]), config.ssl_verify_mode, config.log)
       @token = nil
-      setup(authenticate)
+      @token, @catalog, @expires = set(authenticate)
       raise CatalogError, "No catalog provided during authentication" if @catalog.empty?
     end
 
     def authenticate
-      http = net_http(@uri, @proxy, @ssl_verify_mode, @log)
-      response = http.post(self.class.path, @credentials.to_json, Misty::HEADER_JSON)
+      response = @http.post(self.class.path, @credentials.to_json, Misty::HEADER_JSON)
       raise AuthenticationError, "Response code=#{response.code}, Msg=#{response.msg}" unless response.code =~ /200|201/
       response
     end
@@ -58,7 +54,7 @@ module Misty
     end
 
     def get_token
-      authenticate if expired?
+      @token, @catalog, @expires = set(authenticate) if expired?
       @token
     end
   end

data/lib/misty/auth/auth_v2.rb

@@ -6,13 +6,6 @@ module Misty
       "/v2.0/tokens"
     end
 
-    def initialize(options, *args)
-      @user = Misty::Auth::User.new(options[:user_id], options[:user])
-      @user.password = options[:password]
-      @tenant = Misty::Auth::Name.new(options[:tenant_id], options[:tenant])
-      super(options, *args)
-    end
-
     def catalog_endpoints(endpoints, region, interface)
       endpoints.each do |endpoint|
         if endpoint["region"] == region && endpoint["#{interface}URL"]
@@ -21,50 +14,58 @@ module Misty
       end
     end
 
-    def get_endpoint_url(endpoints, region, interface)
-      endpoint = endpoints.select { |ep| !ep[interface].empty? }
-      raise CatalogError, "No endpoint available for region '#{region}' and interface '#{interface}'" unless endpoint
-      endpoint[0][interface]
-    end
-
-    def setup(response)
-      payload = JSON.load(response.body)
-      @token   = payload["access"]["token"]["id"]
-      @catalog = payload["access"]["serviceCatalog"]
-      @expires = payload["access"]["token"]["expires"]
-    end
-
-    def scoped_authentication
+    def credentials
       raise Misty::Auth::CredentialsError, "#{self.class}: User name is required" if @user.name.nil?
       raise Misty::Auth::CredentialsError, "#{self.class}: User password is required" if @user.password.nil?
-      return auth_by_id if @tenant.id
-      return auth_by_name if @tenant.name
+      return creds_by_id if @tenant.id
+      return creds_by_name if @tenant.name
       raise Misty::Auth::CredentialsError, "#{self.class}: No tenant available"
     end
 
-    def auth_by_name
+    def credentials_data
+      {
+        "username": @user.name,
+        "password": @user.password
+      }
+    end
+
+    def creds_by_name
       {
         "auth": {
-          "passwordCredentials": credentials,
+          "passwordCredentials": credentials_data,
           "tenantName": @tenant.name
         }
       }
     end
 
-    def auth_by_id
+    def creds_by_id
       {
         "auth": {
-          "passwordCredentials": credentials,
+          "passwordCredentials": credentials_data,
           "tenantId": @tenant.id
         }
       }
     end
 
-    def credentials
-      {
-        "username": @user.name,
-        "password": @user.password
-      }
+    def get_endpoint_url(endpoints, region, interface)
+      endpoint = endpoints.select { |ep| !ep[interface].empty? }
+      raise CatalogError, "No endpoint available for region '#{region}' and interface '#{interface}'" unless endpoint
+      endpoint[0][interface]
+    end
+
+    def set(response)
+      payload = JSON.load(response.body)
+      token   = payload["access"]["token"]["id"]
+      catalog = payload["access"]["serviceCatalog"]
+      expires = payload["access"]["token"]["expires"]
+      [token, catalog, expires]
+    end
+
+    def set_credentials(auth)
+      @user = Misty::Auth::User.new(auth[:user_id], auth[:user])
+      @user.password = auth[:password]
+      @tenant = Misty::Auth::Name.new(auth[:tenant_id], auth[:tenant])
+      credentials
     end
   end
 end

data/lib/misty/auth/auth_v3.rb

@@ -2,26 +2,6 @@ require 'misty/auth'
 
 module Misty
   class AuthV3 < Misty::Auth
-    def initialize(options, *args)
-      if options[:project_id] || options[:project]
-        # scope: project
-        project_domain_id = options[:project_domain_id] ? options[:project_domain_id] : Misty::DOMAIN_ID
-        @project = Misty::Auth::ProjectScope.new(options[:project_id], options[:project])
-        @project.domain = Misty::Auth::Name.new(project_domain_id, options[:user_domain])
-      else
-        # scope: domain
-        domain_id = options[:domain_id] ? options[:domain_id] : Misty::DOMAIN_ID
-        @domain = Misty::Auth::DomainScope.new(domain_id, options[:domain]) if domain_id || options[:domain]
-      end
-
-      user_domain_id = options[:user_domain_id] ? options[:user_domain_id] : Misty::DOMAIN_ID
-      @user =  Misty::Auth::User.new(options[:user_id], options[:user])
-      @user.password = options[:password]
-      @user.domain = Misty::Auth::Name.new(user_domain_id, options[:user_domain])
-
-      super(options, *args)
-    end
-
     def self.path
       "/v3/auth/tokens"
     end
@@ -34,35 +14,68 @@ module Misty
       end
     end
 
-    def get_endpoint_url(endpoints, region, interface)
-      endpoint = endpoints.select { |ep| ep["region_id"] == region && ep["interface"] == interface }
-      raise CatalogError, "No endpoint available for region '#{region}' and interface '#{interface}'" unless endpoint
-      endpoint[0]["url"]
-    end
-
-    def scoped_authentication
+    def credentials
+      if @token
+        identity = {
+          "methods": ["token"],
+          "token": { "id": @token }
+        }
+      else
+        identity = {
+          "methods": ["password"],
+          "password": @user.identity
+        }
+      end
       {
         "auth": {
-          "identity": {
-            "methods": ["password"],
-            "password":  @user.identity
-          },
+          "identity": identity,
           "scope": scope
         }
       }
     end
 
+    def get_endpoint_url(endpoints, region, interface)
+      endpoint = endpoints.select { |ep| ep["region_id"] == region && ep["interface"] == interface }
+      raise CatalogError, "No endpoint available for region '#{region}' and interface '#{interface}'" unless endpoint
+      endpoint[0]["url"]
+    end
+
     def scope
       return @project.identity if @project
       return @domain.identity if @domain
       raise Misty::Auth::CredentialsError, "#{self.class}: No scope available"
     end
 
-    def setup(response)
+    def set(response)
       payload = JSON.load(response.body)
-      @token = response["x-subject-token"]
-      @catalog = payload["token"]["catalog"]
-      @expires = payload["token"]["expires_at"]
+      token = response["x-subject-token"]
+      catalog = payload["token"]["catalog"]
+      expires = payload["token"]["expires_at"]
+      [token, catalog, expires]
+    end
+
+    def set_credentials(auth)
+      if auth[:project_id] || auth[:project]
+        # scope: project
+        project_domain_id = auth[:project_domain_id] ? auth[:project_domain_id] : Misty::DOMAIN_ID
+        @project = Misty::Auth::ProjectScope.new(auth[:project_id], auth[:project])
+        @project.domain = Misty::Auth::Name.new(project_domain_id, auth[:user_domain])
+      else
+        # scope: domain
+        domain_id = auth[:domain_id] ? auth[:domain_id] : Misty::DOMAIN_ID
+        @domain = Misty::Auth::DomainScope.new(domain_id, auth[:domain]) if domain_id || auth[:domain]
+      end
+
+      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])
+        @user.password = auth[:password]
+        @user.domain = Misty::Auth::Name.new(user_domain_id, auth[:user_domain])
+      end
+
+      credentials
     end
   end
 end

data/lib/misty/cloud.rb

@@ -3,62 +3,39 @@ require 'misty/auth/auth_v3'
 
 module Misty
   class Cloud
-    class Setup
-      attr_accessor :auth, :content_type, :log, :interface, :proxy, :region_id, :ssl_verify_mode
+    class Config
+      attr_accessor :auth, :content_type, :interface, :log, :region_id, :ssl_verify_mode
     end
 
-    Options = Struct.new(:alarming, :baremetal, :block_storage, :clustering, :compute, :container, :data_processing,
-      :database, :data_protection, :dns, :identity, :image, :messaging, :metering, :network, :object_storage,
-      :orchestration, :search, :shared_file_systems)
-
-    attr_reader :services
-
-    def initialize(params = {:auth => {}})
-      @setup = self.class.setup(params)
-      @options = Options.new
-      @services = setup_services(params)
+    def self.dot_to_underscore(val)
+      val.gsub(/\./,'_')
     end
 
-    def self.setup(params)
-      setup = Setup.new
-      setup.content_type = params[:content_type] ? params[:content_type] : Misty::CONTENT_TYPE
-      setup.interface = params[:interface] ? params[:interface] : Misty::INTERFACE
-      setup.log = Logger.new(params[:log_file] ? params[:log_file] : Misty::LOG_FILE)
-      setup.log.level = params[:log_level] ? params[:log_level] : Misty::LOG_LEVEL
-      setup.region_id = params[:region_id] ? params[:region_id] : Misty::REGION_ID
-      setup.ssl_verify_mode = params.key?(:ssl_verify_mode) ? params[:ssl_verify_mode] : Misty::SSL_VERIFY_MODE
-      http_proxy = params[:http_proxy] ? params[:http_proxy] : ""
-      setup.proxy = URI.parse(http_proxy)
-      setup.auth = Misty::Auth.factory(params[:auth], setup.proxy, setup.ssl_verify_mode, setup.log)
-      setup
+    def initialize(params)# = {:auth => {}})
+      @params = params
+      @config = self.class.set_configuration(params)
+      @services = Misty.services
+      @auth = Misty::Auth.factory(params[:auth], @config)
     end
 
-    def setup_services(params)
-      services = {}
-      Misty.services.each do |service|
-        @options.send("#{service.name}=".to_sym, params[service.name] ? params[service.name] : {})
-
-        if params[service.name] && params[service.name][:api_version] \
-          && service.versions.include?(params[service.name][:api_version])
-          services.merge!(service.name => {service.project => params[service.name][:api_version]})
-        else
-          # Highest version is used by default!
-          services.merge!(service.name => {service.project => service.versions.sort[-1]})
-        end
-      end
-      services
+    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
     end
 
     def build_service(service_name)
-      project = @services[service_name].keys[0]
-      version = @services[service_name].fetch(project)
-      version = self.class.dot_to_underscore(version)
-      klass = Object.const_get("Misty::Openstack::#{project.capitalize}::#{version.capitalize}")
-      klass.new(@setup, @options[service_name])
-    end
-
-    def self.dot_to_underscore(val)
-      val.gsub(/\./,'_')
+      service = @services.find {|service| service.name == service_name}
+      service.options = @params[service.name] if @params[service.name]
+      service.version = service.options[:api_version]
+      version = self.class.dot_to_underscore(service.version)
+      klass = Object.const_get("Misty::Openstack::#{service.project.capitalize}::#{version.capitalize}")
+      klass.new(@auth, @config, service.options)
     end
 
     def alarming

data/lib/misty/http/client.rb

@@ -6,6 +6,10 @@ require 'misty/http/direct'
 module Misty
   module HTTP
     class Client
+      class Options
+        attr_accessor :base_path, :base_url, :interface, :region_id, :service_names, :ssl_verify_mode, :version
+      end
+
       class InvalidDataError < StandardError; end
 
       include Misty::HTTP::NetHTTP
@@ -17,8 +21,6 @@ module Misty
 
       attr_reader :microversion
 
-      Options = Struct.new(:base_path, :base_url, :interface, :region_id, :service_names, :ssl_verify_mode, :version)
-
       def requests
         list = []
         self.class.api.each do |_path, verbs|
@@ -45,13 +47,14 @@ module Misty
       #     :ssl_verify_mode => true
       #   (micro)version: Can be numbered (3.1) or by state (CURRENT, LATEST or SUPPORTED)
       #     :version => "CURRENT"
-      def initialize(setup, options)
-        @setup = setup
+      def initialize(auth, config, options)
+        @auth = auth
+        @config = config
         @options = setup(options)
-        @uri = URI.parse(@setup.auth.get_endpoint(@options.service_names, @options.region_id, @options.interface))
+        @uri = URI.parse(@auth.get_endpoint(@options.service_names, @options.region_id, @options.interface))
         @base_path = @options.base_path ? @options.base_path : @uri.path
         @base_path = @base_path.chomp("/")
-        @http = net_http(@uri, @setup.proxy, @options[:ssl_verify_mode], @setup.log)
+        @http = net_http(@uri, @options.ssl_verify_mode, @config.log)
         @version = nil
         @microversion = false
       end
@@ -72,7 +75,7 @@ module Misty
       end
 
       def headers
-        h = headers_default.merge("X-Auth-Token" => "#{@setup.auth.get_token}")
+        h = headers_default.merge("X-Auth-Token" => "#{@auth.get_token}")
         h.merge!(microversion_header) if microversion
         h
       end
@@ -87,10 +90,10 @@ module Misty
         options = Options.new()
         options.base_path       = params[:base_path]       ? params[:base_path] : nil
         options.base_url        = params[:base_url]        ? params[:base_url] : nil
-        options.interface       = params[:interface]       ? params[:interface] : @setup.interface
-        options.region_id       = params[:region_id]       ? params[:region_id] : @setup.region_id
+        options.interface       = params[:interface]       ? params[:interface] : @config.interface
+        options.region_id       = params[:region_id]       ? params[:region_id] : @config.region_id
         options.service_names   = params[:service_name]    ? self.class.service_names << params[:service_name] : self.class.service_names
-        options.ssl_verify_mode = params[:ssl_verify_mode] ? params[:ssl_verify_mode] : @setup.ssl_verify_mode
+        options.ssl_verify_mode = params[:ssl_verify_mode] ? params[:ssl_verify_mode] : @config.ssl_verify_mode
         options.version         = params[:version]         ? params[:version] : "CURRENT"
 
         unless INTERFACES.include?(options.interface)

data/lib/misty/http/method_builder.rb

@@ -85,11 +85,18 @@ module Misty
       end
 
       def query_param(data)
+        result = nil
         if data.is_a? String
-          str = '?'
-          str.force_encoding('ASCII-8BIT')
-          str << data unless data.empty?
+          result = ''
+          if data != ''
+            result = '?'
+            result.force_encoding('ASCII-8BIT')
+            result << data
+          end
+        elsif data.is_a? Hash
+          result = data.empty? ? '' : '?' + URI.encode_www_form(data)
         end
+        return result
       end
     end
   end

data/lib/misty/http/net_http.rb

@@ -1,8 +1,8 @@
 module Misty
   module HTTP
     module NetHTTP
-      def net_http(endpoint, proxy, ssl_verify_mode, log)
-        http = Net::HTTP.new(endpoint.host, endpoint.port, proxy.host, proxy.port, proxy.user, proxy.password)
+      def net_http(endpoint, ssl_verify_mode, log)
+        http = Net::HTTP.new(endpoint.host, endpoint.port)
         http.set_debug_output(log) if log.level == Logger::DEBUG
         if endpoint.scheme == "https"
           http.use_ssl = true

data/lib/misty/http/request.rb

@@ -2,7 +2,7 @@ module Misty
   module HTTP
     module Request
       def decode?(response)
-        if @setup.content_type != :json && response.code =~ /2??/  && !response.is_a?(Net::HTTPNoContent) \
+        if @config.content_type != :json && response.code =~ /2??/  && !response.is_a?(Net::HTTPNoContent) \
           && !response.is_a?(Net::HTTPResetContent) && response.header["content-type"] \
           && response.header["content-type"].include?("application/json")
           true
@@ -16,51 +16,51 @@ module Misty
       end
 
       def http_delete(path, headers)
-        @setup.log.info(http_to_s(path, headers))
+        @config.log.info(http_to_s(path, headers))
         request = Net::HTTP::Delete.new(path, headers)
         http(request)
       end
 
       def http_copy(path, headers)
-        @setup.log.info(http_to_s(path, headers))
+        @config.log.info(http_to_s(path, headers))
         request = Net::HTTP::Copy.new(path, headers)
         http(request)
       end
 
       def http_get(path, headers)
-        @setup.log.info(http_to_s(path, headers))
+        @config.log.info(http_to_s(path, headers))
         request = Net::HTTP::Get.new(path, headers)
         http(request)
       end
 
       def http_head(path, headers)
-        @setup.log.info(http_to_s(path, headers))
+        @config.log.info(http_to_s(path, headers))
         request = Net::HTTP::Head.new(path, headers)
         http(request)
       end
 
       def http_options(path, headers)
-        @setup.log.info(http_to_s(path, headers))
+        @config.log.info(http_to_s(path, headers))
         request = Net::HTTP::Options.new(path, headers)
         http(request)
       end
 
       def http_patch(path, headers, data)
-        @setup.log.info(http_to_s(path, headers, data))
+        @config.log.info(http_to_s(path, headers, data))
         request = Net::HTTP::Patch.new(path, headers)
         request.body = Misty.to_json(data)
         http(request)
       end
 
       def http_post(path, headers, data)
-        @setup.log.info(http_to_s(path, headers, data))
+        @config.log.info(http_to_s(path, headers, data))
         request = Net::HTTP::Post.new(path, headers)
         request.body = Misty.to_json(data)
         http(request)
       end
 
       def http_put(path, headers, data)
-        @setup.log.info(http_to_s(path, headers, data))
+        @config.log.info(http_to_s(path, headers, data))
         request = Net::HTTP::Put.new(path, headers)
         request.body = Misty.to_json(data)
         http(request)

data/lib/misty/misty.rb

@@ -1,3 +1,5 @@
+require 'misty/services'
+
 module Misty
   HEADER_JSON = {
     "Content-Type" => "application/json",
@@ -26,36 +28,28 @@ module Misty
   # Default mode when SSL is used (uri.scheme == "https")
   SSL_VERIFY_MODE = true
 
-  Service = Struct.new(:name, :project, :versions) do
-    def to_s
-      "#{name}: #{project} => #{versions}"
-    end
-  end
-
-  SERVICES = []
-  SERVICES << Service.new(:alarming,            :aodh,         ["v2"])
-  SERVICES << Service.new(:baremetal,           :ironic,       ["v1"])
-  SERVICES << Service.new(:block_storage,       :cinder,       ["v3", "v1"])
-  SERVICES << Service.new(:clustering,          :senlin,       ["v1"])
-  SERVICES << Service.new(:compute,             :nova,         ["v2.1"])
-  SERVICES << Service.new(:container,           :magnum,       ["v1"])
-  SERVICES << Service.new(:data_processing,     :sahara,       ["v1.1"])
-  SERVICES << Service.new(:data_protection,     :karbor,       ["v1"])
-  SERVICES << Service.new(:database,            :trove,        ["v1.0"])
-  SERVICES << Service.new(:dns,                 :designate,    ["v2"])
-  SERVICES << Service.new(:identity,            :keystone,     ["v3", "v2.0"])
-  SERVICES << Service.new(:image,               :glance,       ["v2", "v1"])
-  SERVICES << Service.new(:messaging,           :zaqar,        ["v2"])
-  SERVICES << Service.new(:metering,            :ceilometer,   ["v2"])
-  SERVICES << Service.new(:network,             :neutron,      ["v2.0"])
-  SERVICES << Service.new(:object_storage,      :swift,        ["v1"])
-  SERVICES << Service.new(:orchestration,       :heat,         ["v1"])
-  SERVICES << Service.new(:search,              :searchlight,  ["v1"])
-  SERVICES << Service.new(:shared_file_systems, :manila,       ["v2"])
-  SERVICES.freeze
-
   def self.services
-    SERVICES
+    services = Misty::Services.new
+    services.add(:alarming,            :aodh,         ["v2"])
+    services.add(:baremetal,           :ironic,       ["v1"])
+    services.add(:block_storage,       :cinder,       ["v3", "v1"])
+    services.add(:clustering,          :senlin,       ["v1"])
+    services.add(:compute,             :nova,         ["v2.1"])
+    services.add(:container,           :magnum,       ["v1"])
+    services.add(:data_processing,     :sahara,       ["v1.1"])
+    services.add(:data_protection,     :karbor,       ["v1"])
+    services.add(:database,            :trove,        ["v1.0"])
+    services.add(:dns,                 :designate,    ["v2"])
+    services.add(:identity,            :keystone,     ["v3", "v2.0"])
+    services.add(:image,               :glance,       ["v2", "v1"])
+    services.add(:messaging,           :zaqar,        ["v2"])
+    services.add(:metering,            :ceilometer,   ["v2"])
+    services.add(:network,             :neutron,      ["v2.0"])
+    services.add(:object_storage,      :swift,        ["v1"])
+    services.add(:orchestration,       :heat,         ["v1"])
+    services.add(:search,              :searchlight,  ["v1"])
+    services.add(:shared_file_systems, :manila,       ["v2"])
+    services
   end
 
   def self.to_json(data)

data/lib/misty/openstack/microversion.rb

@@ -6,7 +6,7 @@ module Misty
 
       VERSION_STATES = %w{CURRENT LATEST SUPPORTED}
 
-      def initialize(cloud, options)
+      def initialize(auth, cloud, options)
         super
         @microversion = true
         @version = version_get(@options.version)

data/lib/misty/services.rb

@@ -0,0 +1,49 @@
+module Misty
+  class Services
+    class Service
+      attr_reader :name, :options, :project, :versions, :version
+
+      def initialize(name, project, versions)
+        @name = name
+        @project = project
+        @versions = versions
+        @options = {}
+      end
+
+      def options=(val)
+        @options = val
+      end
+
+      def version=(val)
+        if @versions.include?(val)
+          @version = val
+        else
+          # Use highest version
+          @version = versions.sort[-1]
+        end
+      end
+
+      def to_s
+        "#{name}: #{project} => #{versions}"
+      end
+    end
+
+    include Enumerable
+
+    attr_reader :services
+
+    def initialize
+      @services = []
+    end
+
+    def add(*args)
+      @services << Service.new(*args)
+    end
+
+    def each
+      @services.each do |service|
+        yield service
+      end
+    end
+  end
+end

data/lib/misty/version.rb

@@ -1,3 +1,3 @@
 module Misty
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/test/unit/auth_test.rb

@@ -2,11 +2,16 @@ require 'test_helper'
 require 'auth_helper'
 
 describe Misty::Auth do
-  let(:log) { Logger.new('/dev/null') }
+  let(:config) do
+    config = Misty::Cloud::Config.new
+    config.log = Logger.new('/dev/null')
+    config.ssl_verify_mode = false
+    config
+  end
 
   describe Misty::AuthV3 do
     describe "#new" do
-      it "authenticates using project scoped authorization" do
+      it "authenticates with password using project scoped authorization" do
         auth = {
           :url        => "http://localhost:5000",
           :user_id    => "user_id",
@@ -19,10 +24,10 @@ describe Misty::Auth do
             :headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}).
           to_return(:status => 200, :body => JSON.dump(auth_response_v3("identity", "keystone")), :headers => {"x-subject-token"=>"token_data"})
 
-        Misty::AuthV3.new(auth, URI.parse(""), false, log)
+        Misty::AuthV3.new(auth, config)
       end
 
-      it "authenticates using domain scoped authorization" do
+      it "authenticates with password using domain scoped authorization" do
         auth = {
           :url      => "http://localhost:5000",
           :user_id  => "user_id",
@@ -34,7 +39,36 @@ describe Misty::Auth do
             :headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}).
           to_return(:status => 200, :body => JSON.dump(auth_response_v3("identity", "keystone")), :headers => {"x-subject-token"=>"token_data"})
 
-        Misty::AuthV3.new(auth, URI.parse(""), false, log)
+        Misty::AuthV3.new(auth, config)
+      end
+
+      it "authenticates with token using project scoped authorization" do
+        auth = {
+          :url        => "http://localhost:5000",
+          :token      => "exampletoken",
+          :project_id => "project_id"
+        }
+
+        stub_request(:post, "http://localhost:5000/v3/auth/tokens").
+          with(:body => "{\"auth\":{\"identity\":{\"methods\":[\"token\"],\"token\":{\"id\":\"exampletoken\"}},\"scope\":{\"project\":{\"id\":\"project_id\"}}}}",
+            :headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}).
+          to_return(:status => 200, :body => JSON.dump(auth_response_v3("identity", "keystone")), :headers => {"x-subject-token"=>"token_data"})
+
+        Misty::AuthV3.new(auth, config)
+      end
+
+      it "authenticates with token using domain scoped authorization" do
+        auth = {
+          :url      => "http://localhost:5000",
+          :token    => "exampletoken",
+        }
+
+        stub_request(:post, "http://localhost:5000/v3/auth/tokens").
+          with(:body => "{\"auth\":{\"identity\":{\"methods\":[\"token\"],\"token\":{\"id\":\"exampletoken\"}},\"scope\":{\"domain\":{\"id\":\"default\"}}}}",
+            :headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}).
+          to_return(:status => 200, :body => JSON.dump(auth_response_v3("identity", "keystone")), :headers => {"x-subject-token"=>"token_data"})
+
+        Misty::AuthV3.new(auth, config)
       end
     end
 
@@ -53,15 +87,15 @@ describe Misty::Auth do
         to_return(:status => 200, :body => "{\"token\":{\"catalog\":[]}}", :headers => {"x-subject-token"=>"token_data"})
 
         proc do
-          Misty::AuthV3.new({}, URI.parse(""), false, log)
-        end.must_raise Misty::Auth::CredentialsError
+          Misty::AuthV3.new({}, config)
+        end.must_raise Misty::Auth::URLError
       end
 
       it "#get_token" do
         stub_request(:post, "http://localhost:5000/v3/auth/tokens").
         to_return(:status => 200, :body => "{\"token\":{\"catalog\":[\"catalog_data\"]}}", :headers => {"x-subject-token"=>"token_data"})
 
-        auth = Misty::AuthV3.new(authv3_creds, URI.parse(""), false, log)
+        auth = Misty::AuthV3.new(authv3_creds, config)
         auth.stub :expired?, false do
           auth.get_token.must_equal "token_data"
         end
@@ -71,7 +105,7 @@ describe Misty::Auth do
         stub_request(:post, "http://localhost:5000/v3/auth/tokens").
         to_return(:status => 200, :body => "{\"token\":{\"catalog\":[\"catalog_data\"]}}", :headers => {"x-subject-token"=>"token_data"})
 
-        auth = Misty::AuthV3.new(authv3_creds, URI.parse(""), false, log)
+        auth = Misty::AuthV3.new(authv3_creds, config)
         auth.catalog.must_equal ["catalog_data"]
       end
 
@@ -79,7 +113,7 @@ describe Misty::Auth do
         stub_request(:post, "http://localhost:5000/v3/auth/tokens").
         to_return(:status => 200, :body => JSON.dump(auth_response_v3("identity", "keystone")), :headers => {"x-subject-token"=>"token_data"})
 
-        auth = Misty::AuthV3.new(authv3_creds, URI.parse(""), false, log)
+        auth = Misty::AuthV3.new(authv3_creds, config)
         auth.get_endpoint(%w{identity}, "regionOne", "public").must_equal "http://localhost"
       end
     end
@@ -92,8 +126,8 @@ describe Misty::Auth do
           to_return(:status => 200, :body => "{\"access\":{\"token\":{\"id\":\"token_data\"}}}", :headers => {})
 
         proc do
-          Misty::AuthV2.new({}, URI.parse(""), false, log)
-        end.must_raise Misty::Auth::CredentialsError
+          Misty::AuthV2.new({}, config)
+        end.must_raise Misty::Auth::URLError
       end
     end
 
@@ -111,7 +145,7 @@ describe Misty::Auth do
         stub_request(:post, "http://localhost:5000/v2.0/tokens").
           to_return(:status => 200, :body => "{\"access\":{\"token\":{\"id\":\"token_data\"},\"serviceCatalog\":[\"catalog_data\"]}}", :headers => {})
 
-        auth = Misty::AuthV2.new(authv2_creds, URI.parse(""), false, log)
+        auth = Misty::AuthV2.new(authv2_creds, config)
         auth.stub :expired?, false do
           auth.get_token.must_equal "token_data"
         end
@@ -121,7 +155,7 @@ describe Misty::Auth do
         stub_request(:post, "http://localhost:5000/v2.0/tokens").
           to_return(:status => 200, :body => "{\"access\":{\"token\":{\"id\":\"token_data\"},\"serviceCatalog\":[\"catalog_data\"]}}", :headers => {})
 
-        auth = Misty::AuthV2.new(authv2_creds, URI.parse(""), false, log)
+        auth = Misty::AuthV2.new(authv2_creds, config)
         auth.catalog.must_equal ["catalog_data"]
       end
 
@@ -129,7 +163,7 @@ describe Misty::Auth do
         stub_request(:post, "http://localhost:5000/v2.0/tokens").
           to_return(:status => 200, :body => JSON.dump(auth_response_v2("identity", "keystone")), :headers => {"x-subject-token"=>"token_data"})
 
-        auth = Misty::AuthV2.new(authv2_creds, URI.parse(""), false, log)
+        auth = Misty::AuthV2.new(authv2_creds, config)
         auth.get_endpoint(%w{identity}, "regionOne", "public").must_equal "http://localhost"
       end
     end

data/test/unit/cloud_test.rb

@@ -27,57 +27,55 @@ describe Misty::Cloud do
 
     it "uses default version" do
       cloud = Misty::Cloud.new(:auth => auth)
-      cloud.services[:identity].must_equal ({:keystone => "v3"})
-    end
-
-    it "uses provided version" do
-      cloud = Misty::Cloud.new(:auth => auth, :identity => {:api_version => "v2.0"})
-      cloud.services[:identity].must_equal ({:keystone => "v2.0"})
+      cloud.identity.must_be_kind_of Misty::Openstack::Keystone::V3
     end
 
     it "uses default version when provided version is out of range" do
       cloud = Misty::Cloud.new(:auth => auth, :identity => {:api_version => "v1"})
-      cloud.services[:identity].must_equal ({:keystone => "v3"})
+      cloud.identity.must_be_kind_of Misty::Openstack::Keystone::V3
+    end
+
+    it "uses provided version" do
+      cloud = Misty::Cloud.new(:auth => auth, :identity => {:api_version => "v2.0"})
+      cloud.identity.must_be_kind_of Misty::Openstack::Keystone::V2_0
     end
   end
 
-  describe "All SERVICES" do
-    it "have a method defined" do
-      Misty::SERVICES.each do |service|
+  describe "Each service" do
+    it "has a method defined" do
+      Misty::services.each do |service|
         method =  Misty::Cloud.method_defined?(service.name)
         method.must_equal true
       end
     end
   end
 
-  describe "#setup" do
+  describe "#config" do
     it "sets up default values" do
       Misty::Auth.stub :factory, nil do
-        setup = Misty::Cloud.setup({})
-        setup.must_be_kind_of Misty::Cloud::Setup
-        setup.content_type.must_equal Misty::CONTENT_TYPE
-        setup.log.must_be_kind_of Logger
-        setup.interface.must_equal Misty::INTERFACE
-        setup.proxy.must_be_kind_of URI
-        setup.proxy.host.must_be_nil
-        setup.region_id.must_equal Misty::REGION_ID
-        setup.ssl_verify_mode.must_equal Misty::SSL_VERIFY_MODE
+        config = Misty::Cloud.set_configuration({})
+        config.must_be_kind_of Misty::Cloud::Config
+        config.content_type.must_equal Misty::CONTENT_TYPE
+        config.log.must_be_kind_of Logger
+        config.interface.must_equal Misty::INTERFACE
+        config.region_id.must_equal Misty::REGION_ID
+        config.ssl_verify_mode.must_equal Misty::SSL_VERIFY_MODE
       end
     end
   end
 
   describe "#new" do
     describe "fails" do
-      it "when no credentials" do
+      it "when no parameters" do
         proc do
           Misty::Cloud.new
-        end.must_raise Misty::Auth::CredentialsError
+        end.must_raise ArgumentError
       end
 
       it "with empty credentials" do
         proc do
           Misty::Cloud.new(:auth => {})
-        end.must_raise Misty::Auth::CredentialsError
+        end.must_raise Misty::Auth::URLError
       end
 
       it "with incomplete credentials" do

data/test/unit/http/client_test.rb

@@ -42,8 +42,7 @@ describe Misty::HTTP::Client do
   describe "#net_http" do
     it "returns a Net/http instance" do
       endpoint = URI.parse("http://localhost")
-      proxy = URI.parse("")
-      service.send(:net_http, endpoint, proxy, false, Logger.new("/dev/null")).must_be_instance_of Net::HTTP
+      service.send(:net_http, endpoint, false, Logger.new("/dev/null")).must_be_instance_of Net::HTTP
     end
   end
 

data/test/unit/http/method_builder_test.rb

@@ -122,12 +122,23 @@ describe Misty::HTTP::MethodBuilder do
       service.send(:query_param, "name=foobar").must_equal "?name=foobar"
     end
 
-    it "returns nil when passing an empty String" do
-      service.send(:query_param, "").must_be_nil
+    it "returns empty string when passing an empty String" do
+      service.send(:query_param, "").must_equal ""
     end
 
-    it "returns nil unless passing a String" do
-      service.send(:query_param, "name" => "foobar").must_be_nil
+    it "returns a query string when passing in a Hash" do
+      service.send(:query_param, {}).must_equal ''
+
+      service.send(:query_param, {:foo  => 'bar'}).must_equal '?foo=bar'
+      service.send(:query_param, {'foo' => 'bar'}).must_equal '?foo=bar'
+
+      service.send(:query_param, {:foo => ['bar', 'baz'], :value => 42, :flag => nil }).must_equal '?foo=bar&foo=baz&value=42&flag'
+
+      service.send(:query_param, {'===' => 'Ëncøding is hárd!'}).must_equal '?%3D%3D%3D=%C3%8Bnc%C3%B8ding+is+h%C3%A1rd%21'
+    end
+
+    it "returns nil unless passing a String or Hash" do
+      service.send(:query_param, 42).must_be_nil
     end
   end
 end

data/test/unit/misty_test.rb

@@ -1,15 +1,116 @@
 require 'test_helper'
 
+def validate(service)
+  service.must_be_kind_of Misty::Services::Service
+  service.name.must_be_kind_of Symbol
+  service.project.must_be_kind_of Symbol
+  service.versions.must_be_kind_of Array
+  service.versions.each do |version|
+    version.must_be_kind_of String
+  end
+end
+
 describe Misty do
-  describe "SERVICES" do
-    it "has expected structure" do
-      Misty::SERVICES.each do |service|
-        service.name.must_be_kind_of Symbol
-        service.project.must_be_kind_of Symbol
-        service.versions.must_be_kind_of Array
-        service.versions.each do |version|
-          version.must_be_kind_of String
-        end
+  describe "#set_services" do
+    it "has alarming service" do
+      service = Misty::services.find { |s| s.name == :alarming}
+      validate(service)
+    end
+
+    it "has baremetal service" do
+      service = Misty::services.find { |s| s.name == :baremetal}
+      validate(service)
+    end
+
+    it "has block_storage service" do
+      service = Misty::services.find { |s| s.name == :block_storage}
+      validate(service)
+    end
+
+    it "has clustering service" do
+      service = Misty::services.find { |s| s.name == :clustering}
+      validate(service)
+    end
+
+    it "has compute service" do
+      service = Misty::services.find { |s| s.name == :compute}
+      validate(service)
+    end
+
+    it "has container service" do
+      service = Misty::services.find { |s| s.name == :container}
+      validate(service)
+    end
+
+    it "has data_processing service" do
+      service = Misty::services.find { |s| s.name == :data_processing}
+      validate(service)
+    end
+
+    it "has data_protection service" do
+      service = Misty::services.find { |s| s.name == :data_protection}
+      validate(service)
+    end
+
+    it "has database service" do
+      service = Misty::services.find { |s| s.name == :database}
+      validate(service)
+    end
+
+    it "has dns service" do
+      service = Misty::services.find { |s| s.name == :dns}
+      validate(service)
+    end
+
+    it "has identity service" do
+      service = Misty::services.find { |s| s.name == :identity}
+      validate(service)
+    end
+
+    it "has image service" do
+      service = Misty::services.find { |s| s.name == :image}
+      validate(service)
+    end
+
+    it "has messaging service" do
+      service = Misty::services.find { |s| s.name == :messaging}
+      validate(service)
+    end
+
+    it "has metering service" do
+      service = Misty::services.find { |s| s.name == :metering}
+      validate(service)
+    end
+
+    it "has network service" do
+      service = Misty::services.find { |s| s.name == :network}
+      validate(service)
+    end
+
+    it "has object_storage service" do
+      service = Misty::services.find { |s| s.name == :object_storage}
+      validate(service)
+    end
+
+    it "has orchestration service" do
+      service = Misty::services.find { |s| s.name == :orchestration}
+      validate(service)
+    end
+
+    it "has search service" do
+      service = Misty::services.find { |s| s.name == :search}
+      validate(service)
+    end
+
+    it "has shared_file_systems service" do
+      service = Misty::services.find { |s| s.name == :shared_file_systems}
+      validate(service)
+    end
+
+    describe "#services" do
+      it "returns Services" do
+        services = Misty::services
+        services.must_be_kind_of Misty::Services
       end
     end
   end

data/test/unit/openstack/microversion_test.rb

@@ -31,12 +31,10 @@ describe Misty::HTTP::Microversion do
       "token_id"
     end
 
-    setup = Misty::Cloud::Setup.new
-    setup.auth = auth
+    setup = Misty::Cloud::Config.new
     setup.content_type = :ruby
     setup.log = Logger.new('/dev/null')
     setup.interface = Misty::INTERFACE
-    setup.proxy = URI.parse('')
     setup.region_id = Misty::REGION_ID
     setup.ssl_verify_mode = Misty::SSL_VERIFY_MODE
 
@@ -44,7 +42,7 @@ describe Misty::HTTP::Microversion do
       with(:headers => {'Accept'=>'application/json', 'Content-Type'=>'application/json'}).
       to_return(:status => 200, :body => JSON.dump(versions_data), :headers => {})
 
-    Misty::Openstack::Nova::V2_1.new(setup, {})
+    Misty::Openstack::Nova::V2_1.new(auth, setup, {})
   end
 
   describe "#version_get" do

data/test/unit/service_helper.rb

@@ -15,12 +15,10 @@ def service(content_type = :ruby)
     "token_id"
   end
 
-  setup = Misty::Cloud::Setup.new
-  setup.auth = auth
+  setup = Misty::Cloud::Config.new
   setup.content_type = content_type
   setup.log = Logger.new('/dev/null')
   setup.interface = Misty::INTERFACE
-  setup.proxy = URI.parse("")
   setup.region_id = Misty::REGION_ID
   setup.ssl_verify_mode = Misty::SSL_VERIFY_MODE
 
@@ -28,5 +26,5 @@ def service(content_type = :ruby)
     with(:headers => request_header).
     to_return(:status => 200, :body => "", :headers => {})
 
-  Misty::Openstack::Neutron::V2_0.new(setup, {})
+  Misty::Openstack::Neutron::V2_0.new(auth, setup, {})
 end

data/test/unit/services_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+describe "Services" do
+  describe "#add" do
+    it "Adds a service" do
+      services = Misty::Services.new
+      services.add(:name, :project, ["v1", "v2.0"])
+      services.services.size.must_equal 1
+      service = services.services[0]
+      service.must_be_kind_of Misty::Services::Service
+      service.name.must_equal :name
+      service.project.must_equal :project
+      service.versions.must_include "v1"
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: misty
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Gilles Dubreuil
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-18 00:00:00.000000000 Z
+date: 2017-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -186,6 +186,7 @@ files:
 - lib/misty/openstack/trove/v1_0.rb
 - lib/misty/openstack/zaqar/v2.rb
 - lib/misty/openstack/zaqar/zaqar_v2.rb
+- lib/misty/services.rb
 - lib/misty/version.rb
 - test/integration/compute_test.rb
 - test/integration/network_test.rb
@@ -208,6 +209,7 @@ files:
 - test/unit/openstack/APIs_test.rb
 - test/unit/openstack/microversion_test.rb
 - test/unit/service_helper.rb
+- test/unit/services_test.rb
 - test/unit/test_helper.rb
 homepage: https://github.com/flystack/misty
 licenses: