fog 1.31.0 → 1.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ef4e602225c238bc7f2eb32eba5e3a62e72a85c
-  data.tar.gz: 9386d2f4f96563b804e0a82c59fc2d305a3df65b
+  metadata.gz: 7801c7c007b8ade9b3db8b3adbcccce77483a544
+  data.tar.gz: f4b0c047843cc79f845badafc9afeb2e9ba04167
 SHA512:
-  metadata.gz: 60fb274b89ab1917b6b5efac3cbac481e4856c11b4d6b7a9b9bfa0a1d67e0a7cfe155980065501a05a2eef6adfa88471b39e6812fce323947e952fa9ca571340
-  data.tar.gz: 8cecceddcc6ee4b41ac94a66d28c5b4148c63ca935b9a84b917034bb6e92c2d3e0b29c5c4f70433fee7129cf27ef91905ecd27a59300e3f8d044f5a881209977
+  metadata.gz: 444572699a31be8229aca465659aaabc11ddf16d81bfd103914561a82e11dc55f43ab57a2e254fd986eb53dbe4ef3b1f30dc9be25bc4ac09dded50eceb73dbc6
+  data.tar.gz: e74522ce110047b1f7bdeb6e4ae263ff5854fd4741d6af224dbded8046543196d26986cbb6e5d7b33717ed1ef848abb9bfac5932ca52f13f6490a2b6cc6909ad

data/CHANGELOG.md

@@ -1,3 +1,56 @@
+## 1.32.0 07/02/2015
+*Hash* 3339ba764f099c1fab8c989510c427ac65dabeca
+
+Statistic     | Value
+------------- | --------:
+Collaborators | 2
+Downloads     | 10420612
+Forks         | 1453
+Open Issues   | 83
+Watchers      | 3538
+
+**MVP!** Ladislav Smola
+
+#### [cloudstack]
+*   Use `isdefault` in `listNetworks` response. thanks Yamashita Yuu
+
+#### [misc]
+*   Various fixes & tweaks for OpenStack Identity V3 API & related tests. thanks Darren Hague
+*   Clamp fog-ecloud at 0.1.1 because 0.1.2 was causing a Travis build failure. thanks Darren Hague
+*   Reintroduce user_domain and project_domain     Refactor - move repetitive code from compute & network to core.     Tweak VCR config and Rakefile to make sure tests are run correctly. thanks Darren Hague
+*   Fix ruby 1.8.7 failure. thanks Darren Hague
+*   Add missing reference to openstack_project_name & simplify test code a little. thanks Darren Hague
+*   Adding OpenStack Host Aggregate support. thanks Ladislav Smola
+*   OpenStack Baremetal list methods unified interface. thanks Ladislav Smola
+*   We need to move all list methods to unified interface, where     only Hash is passed as a first argument. The hash can have     specific fields, that will be recognized and deleted. Rest     of the Hash goes directly to request :query. thanks Ladislav Smola
+*   OpenStack Keystone and Ironic change all to detailed list. thanks Ladislav Smola
+*   OpenStack Cinder, Swift and Tuskar list methods unified interface. thanks Ladislav Smola
+*   OpenStack Compute list methods unified interface. thanks Ladislav Smola
+*   OpenStack Glance and Heat list methods unified interface. thanks Ladislav Smola
+*   Minor bugs from list methods unification. thanks Ladislav Smola
+*   Missing network init uri. thanks Ladislav Smola
+*   OpenStack missing list unification of Network and Volume. thanks Ladislav Smola
+*   Openstack security groups list typo. thanks Ladislav Smola
+*   Don't remove nil keys in OpenStack#create_subnet. thanks Matt Darby
+*   Send :force flag in Snapshot payload. thanks Matt Darby
+*   OpenStack create_volume: add metadata option. thanks Maurice Schreiber
+*   OpenStack volume model: add metadata attribute. thanks Maurice Schreiber
+*   OpenStack port: add security groups to model and update request. thanks Maurice Schreiber
+*   include core in identity_v3 mock. thanks Maurice Schreiber
+*   correct mock format, when there is no input given. thanks Maurice Schreiber
+*   Bump fog-aws dependency. thanks Quentin de Metz
+*   add missing new method call to example. thanks Ryan King
+*   first bits of a spec for Fog::OpenStack::Volume. thanks Stefan Majewsky
+*   test the model create() method instead of the create_volume request. thanks Stefan Majewsky
+*   Fix typo in vm_clone. thanks alan
+*   bump fog-core dep. thanks geemus
+*   comment attribute in ovirt. thanks karmab
+*   support security-group by create port. thanks kazuhiko yamashita
+
+#### [openstack]
+*   Minor bugfixes & cleanups in identity_v3 test code. thanks Darren Hague
+
+
 ## 1.31.0 06/05/2015
 *Hash* 8c653412b40dd82f82187b9710ccb9177dab3d98
 

data/Rakefile

@@ -54,7 +54,7 @@ end
 
 GEM_NAME = "#{name}"
 task :default => :test
-task :travis  => ['test', 'test:travis']
+task :travis  => ['test', 'test:travis', 'test:openstack_idv3']
 
 Rake::TestTask.new do |t|
   t.pattern = File.join("spec", "**", "*_spec.rb")
@@ -63,7 +63,10 @@ end
 
 namespace :test do
   mock = ENV['FOG_MOCK'] || 'true'
-  task :travis do
+  task :openstack_idv3 do
+    sh("export FOG_MOCK=false && bundle exec rspec spec/fog/openstack/identity_v3_spec.rb")
+  end
+  task :travis => [:openstack_idv3] do
       sh("export FOG_MOCK=#{mock} && bundle exec shindont")
   end
   task :vsphere do
@@ -78,9 +81,6 @@ namespace :test do
   task :openstack do
       sh("export FOG_MOCK=#{mock} && bundle exec shindont tests/openstack")
   end
-  task :openstack_idv3 do
-    sh("export FOG_MOCK=#{mock} && bundle exec rspec spec/fog/openstack/identity_v3_spec.rb")
-  end
   task :cloudstack do
       sh("export FOG_MOCK=#{mock} && bundle exec shindont tests/cloudstack")
   end

data/fog.gemspec

@@ -11,8 +11,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = "fog"
-  s.version           = "1.31.0"
-  s.date              = "2015-06-04"
+  s.version           = "1.32.0"
+  s.date              = "2015-07-02"
   s.rubyforge_project = "fog"
 
   ## Make sure your summary is short. The description may be as long
@@ -44,7 +44,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.extra_rdoc_files = %w[README.md]
 
-  s.add_dependency("fog-core", "~> 1.30")
+  s.add_dependency("fog-core", "~> 1.32")
   s.add_dependency("fog-json")
   s.add_dependency("fog-xml", "~> 0.1.1")
 
@@ -53,9 +53,9 @@ Gem::Specification.new do |s|
 
   # Modular providers (please keep sorted)
   s.add_dependency("fog-atmos")
-  s.add_dependency("fog-aws", "~> 0.0")
+  s.add_dependency("fog-aws", ">= 0.6.0")
   s.add_dependency("fog-brightbox", "~> 0.4")
-  s.add_dependency("fog-ecloud")
+  s.add_dependency("fog-ecloud", "= 0.1.1")
   s.add_dependency("fog-google", ">= 0.0.2")
   s.add_dependency("fog-local")
   s.add_dependency("fog-powerdns", ">= 0.1.1")
@@ -85,6 +85,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency("thor")
   s.add_development_dependency("yard")
   s.add_development_dependency("rspec-core")
+  s.add_development_dependency("rspec-expectations")
   s.add_development_dependency("vcr")
   s.add_development_dependency("webmock")
 

data/lib/fog/cloudstack/models/compute/network.rb

@@ -38,6 +38,7 @@ module Fog
         attribute :canuse_for_deploy,       :aliases => 'canusefordeploy'
         attribute :is_persistent,           :aliases => 'ispersistent', :type => :boolean
         attribute :display_network,         :aliases => 'displaynetwork'
+        attribute :is_default,              :aliases => 'isdefault', :type => :boolean
 
         # restart network - will return a job
         def restart(options={})

data/lib/fog/openstack/compute.rb

@@ -10,12 +10,15 @@ module Fog
                  :openstack_api_key, :openstack_username, :openstack_identity_endpoint,
                  :current_user, :current_tenant, :openstack_region,
                  :openstack_endpoint_type,
-                 :openstack_project_name,
-                 :openstack_project_domain, :openstack_user_domain
+                 :openstack_project_name, :openstack_project_id,
+                 :openstack_project_domain, :openstack_user_domain, :openstack_domain_name,
+                 :openstack_project_domain_id, :openstack_user_domain_id, :openstack_domain_id
 
       ## MODELS
       #
       model_path 'fog/openstack/models/compute'
+      model       :aggregate
+      collection  :aggregates
       model       :server
       collection  :servers
       model       :service
@@ -49,6 +52,17 @@ module Fog
       #
       request_path 'fog/openstack/requests/compute'
 
+      # Aggregate CRUD
+      request :list_aggregates
+      request :create_aggregate
+      request :update_aggregate
+      request :get_aggregate
+      request :update_aggregate
+      request :update_aggregate_metadata
+      request :add_aggregate_host
+      request :remove_aggregate_host
+      request :delete_aggregate
+      
       # Server CRUD
       request :list_servers
       request :list_servers_detail
@@ -164,6 +178,7 @@ module Fog
 
       # Volume
       request :list_volumes
+      request :list_volumes_detail
       request :create_volume
       request :get_volume_details
       request :delete_volume
@@ -171,8 +186,10 @@ module Fog
       request :detach_volume
       request :get_server_volumes
 
+      # Snapshot
       request :create_volume_snapshot
       request :list_snapshots
+      request :list_snapshots_detail
       request :get_snapshot_details
       request :delete_snapshot
 
@@ -208,6 +225,15 @@ module Fog
                 :security_groups => {},
                 :addresses => {}
               },
+              :aggregates => [{
+                "availability_zone" => "nova",
+                "created_at" => "2012-11-16T06:22:23.032493",
+                "deleted" => false,
+                "deleted_at" => nil,
+                "id" => 1,
+                "name" => "name",
+                "updated_at" => nil
+              }],
               :images  => {
                 "0e09fbd6-43c5-448a-83e9-0d3d05f9747e" => {
                   "id"=>"0e09fbd6-43c5-448a-83e9-0d3d05f9747e",
@@ -266,18 +292,14 @@ module Fog
           @data = nil
         end
 
-        def initialize(options={})
-          @openstack_username = options[:openstack_username]
-          @openstack_user_domain = options[:openstack_user_domain] || options[:openstack_domain]
-          @openstack_project_domain  = options[:openstack_project_domain]  || options[:openstack_domain] || 'Default'
-          @openstack_auth_uri = URI.parse(options[:openstack_auth_url])
-
-          @current_tenant = options[:openstack_tenant]
-          @current_tenant_id = options[:openstack_tenant_id]
+        include Fog::OpenStack::Core
 
+        def initialize(options={})
           @auth_token = Fog::Mock.random_base64(64)
           @auth_token_expiration = (Time.now.utc + 86400).iso8601
 
+          initialize_identity options
+
           management_url = URI.parse(options[:openstack_auth_url])
           management_url.port = 8774
           management_url.path = '/v1.1/1'
@@ -296,77 +318,28 @@ module Fog
           self.class.data.delete("#{@openstack_username}-#{@current_tenant}")
         end
 
-        def credentials
-          { :provider                 => 'openstack',
-            :openstack_auth_url       => @openstack_auth_uri.to_s,
-            :openstack_auth_token     => @auth_token,
-            :openstack_management_url => @openstack_management_url,
-            :openstack_identity_endpoint => @openstack_identity_public_endpoint }
-        end
       end
 
       class Real
-        attr_reader :auth_token
-        attr_reader :auth_token_expiration
-        attr_reader :current_user
-        attr_reader :current_tenant
-        attr_reader :current_tenant_id
-        attr_reader :openstack_user_domain
-        attr_reader :openstack_project_domain
+
+        include Fog::OpenStack::Core
 
         def initialize(options={})
-          @openstack_auth_token = options[:openstack_auth_token]
-          @auth_token        = options[:openstack_auth_token]
-          @openstack_identity_public_endpoint = options[:openstack_identity_endpoint]
-
-          unless @auth_token
-            missing_credentials = Array.new
-            @openstack_api_key     = options[:openstack_api_key]
-            @openstack_username    = options[:openstack_username]
-            @openstack_user_domain = options[:openstack_user_domain] || options[:openstack_domain]
-            @openstack_project_domain  = options[:openstack_project_domain]  || options[:openstack_domain] || 'Default'
-
-            missing_credentials << :openstack_api_key  unless @openstack_api_key
-            missing_credentials << :openstack_username unless @openstack_username
-            raise ArgumentError, "Missing required arguments: #{missing_credentials.join(', ')}" unless missing_credentials.empty?
-          end
+          initialize_identity options
 
-          @openstack_tenant      = options[:openstack_tenant]
-          @openstack_tenant_id   = options[:openstack_tenant_id]
-          @openstack_user_domain = options[:openstack_user_domain] || options[:openstack_domain]
-          @openstack_project_domain  = options[:openstack_project_domain]  || options[:openstack_domain] || 'Default'
-          @openstack_auth_uri    = URI.parse(options[:openstack_auth_url])
-          @openstack_management_url       = options[:openstack_management_url]
-          @openstack_must_reauthenticate  = false
+          @openstack_identity_service_type = options[:openstack_identity_service_type] || 'identity'
           @openstack_service_type  = options[:openstack_service_type] || ['nova', 'compute']
           @openstack_service_name  = options[:openstack_service_name]
-          @openstack_identity_service_type = options[:openstack_identity_service_type] || 'identity'
-          @openstack_endpoint_type = options[:openstack_endpoint_type] || 'publicURL'
-          @openstack_region        = options[:openstack_region]
 
           @connection_options = options[:connection_options] || {}
 
-          @current_user = options[:current_user]
-          @current_tenant = options[:current_tenant]
-
-          authenticate
+          authenticate_compute
 
           @persistent = options[:persistent] || false
           @connection = Fog::Core::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
         end
 
-        def credentials
-          { :provider                 => 'openstack',
-            :openstack_user_domain    => @openstack_user_domain,
-            :openstack_project_domain     => @openstack_project_domain,
-            :openstack_auth_url       => @openstack_auth_uri.to_s,
-            :openstack_auth_token     => @auth_token,
-            :openstack_management_url => @openstack_management_url,
-            :openstack_identity_endpoint => @openstack_identity_public_endpoint,
-            :openstack_region         => @openstack_region,
-            :current_user             => @current_user,
-            :current_tenant           => @current_tenant }
-        end
+
 
         def reload
           @connection.reset
@@ -386,7 +359,7 @@ module Fog
           rescue Excon::Errors::Unauthorized => error
             if error.response.body != 'Bad username or password' # token expiration
               @openstack_must_reauthenticate = true
-              authenticate
+              authenticate_compute
               retry
             else # Bad Credentials
               raise error
@@ -409,35 +382,8 @@ module Fog
 
         private
 
-        def authenticate
-          if !@openstack_management_url || @openstack_must_reauthenticate
-            options = {
-              :openstack_api_key      => @openstack_api_key,
-              :openstack_username     => @openstack_username,
-              :openstack_user_domain  => @openstack_user_domain,
-              :openstack_project_domain   => @openstack_project_domain,
-              :openstack_auth_token   => @openstack_must_reauthenticate ? nil : @auth_token,
-              :openstack_auth_uri     => @openstack_auth_uri,
-              :openstack_region       => @openstack_region,
-              :openstack_tenant       => @openstack_tenant,
-              :openstack_tenant_id    => @openstack_tenant_id,
-              :openstack_service_type => @openstack_service_type,
-              :openstack_service_name => @openstack_service_name,
-              :openstack_identity_service_type => @openstack_identity_service_type,
-              :openstack_endpoint_type => @openstack_endpoint_type
-            }
-
-            credentials = Fog::OpenStack.authenticate(options, @connection_options)
-
-            @current_user = credentials[:user]
-            @current_tenant = credentials[:tenant]
-
-            @openstack_must_reauthenticate = false
-            @auth_token               = credentials[:token]
-            @auth_token_expiration    = credentials[:expires]
-            @openstack_management_url = credentials[:server_management_url]
-            @openstack_identity_public_endpoint  = credentials[:identity_public_endpoint]
-          end
+        def authenticate_compute
+          authenticate
 
           uri = URI.parse(@openstack_management_url)
           @host   = uri.host
@@ -449,9 +395,6 @@ module Fog
                     "OpenStack compute binding only supports version 2 (a.k.a. 1.1)")
           end
 
-          @port   = uri.port
-          @scheme = uri.scheme
-
           # Not all implementations have identity service in the catalog
           if @openstack_identity_public_endpoint || @openstack_management_url
             @identity_connection = Fog::Core::Connection.new(

data/lib/fog/openstack/core.rb

@@ -53,6 +53,127 @@ module Fog
     service(:baremetal,     'Baremetal')
     service(:planning,      'Planning')
 
+    module Core
+      attr_reader :auth_token
+      attr_reader :auth_token_expiration
+      attr_reader :current_user
+      attr_reader :current_tenant
+      attr_reader :openstack_domain_name
+      attr_reader :openstack_user_domain
+      attr_reader :openstack_project_domain
+      attr_reader :openstack_domain_id
+      attr_reader :openstack_user_domain_id
+      attr_reader :openstack_project_domain_id
+
+      def initialize_identity options
+        @openstack_auth_token = options[:openstack_auth_token]
+        @auth_token        ||= options[:openstack_auth_token]
+        @openstack_identity_public_endpoint = options[:openstack_identity_endpoint]
+
+        @openstack_username = options[:openstack_username]
+        @openstack_userid = options[:openstack_userid]
+
+        @openstack_domain_name = options[:openstack_domain_name]
+        @openstack_user_domain = options[:openstack_user_domain]
+        @openstack_project_domain  = options[:openstack_project_domain]
+        @openstack_domain_id = options[:openstack_domain_id]
+        @openstack_user_domain_id = options[:openstack_user_domain_id]
+        @openstack_project_domain_id  = options[:openstack_project_domain_id]
+
+        @openstack_project_name = options[:openstack_project_name]
+        @openstack_tenant      = options[:openstack_tenant]
+        @openstack_tenant_id   = options[:openstack_tenant_id]
+
+        @openstack_auth_uri    = URI.parse(options[:openstack_auth_url])
+
+        @openstack_management_url       = options[:openstack_management_url]
+
+        @openstack_must_reauthenticate  = false
+
+        @openstack_endpoint_type = options[:openstack_endpoint_type] || 'publicURL'
+        @openstack_region        = options[:openstack_region]
+
+        unless @auth_token
+          missing_credentials = Array.new
+          @openstack_api_key = options[:openstack_api_key]
+          @openstack_username = options[:openstack_username]
+          @openstack_userid = options[:openstack_userid]
+
+          missing_credentials << :openstack_api_key unless @openstack_api_key
+          unless @openstack_username || @openstack_userid
+            missing_credentials << 'openstack_username or openstack_userid'
+          end
+          raise ArgumentError, "Missing required arguments: #{missing_credentials.join(', ')}" unless missing_credentials.empty?
+        end
+
+        @current_user = options[:current_user]
+        @current_tenant = options[:current_tenant]
+
+      end
+
+      def credentials
+        { :provider                 => 'openstack',
+          :openstack_domain_name    => @openstack_domain_name,
+          :openstack_user_domain    => @openstack_user_domain,
+          :openstack_project_domain => @openstack_project_domain,
+          :openstack_domain_id      => @openstack_domain_id,
+          :openstack_user_domain_id => @openstack_user_domain_id,
+          :openstack_project_domain_id => @openstack_project_domain_id,
+          :openstack_auth_url       => @openstack_auth_uri.to_s,
+          :openstack_auth_token     => @auth_token,
+          :openstack_management_url => @openstack_management_url,
+          :openstack_identity_endpoint => @openstack_identity_public_endpoint,
+          :openstack_region         => @openstack_region,
+          :current_user             => @current_user,
+          :current_tenant           => @current_tenant }
+      end
+
+      private
+      def authenticate
+        if !@openstack_management_url || @openstack_must_reauthenticate
+          options = {
+              :openstack_tenant        => @openstack_tenant,
+              :openstack_tenant_id     => @openstack_tenant_id,
+              :openstack_api_key       => @openstack_api_key,
+              :openstack_username      => @openstack_username,
+              :openstack_userid        => @openstack_userid,
+              :openstack_user_domain   => @openstack_user_domain,
+              :openstack_project_domain => @openstack_project_domain,
+              :openstack_user_domain_id => @openstack_user_domain_id,
+              :openstack_project_domain_id => @openstack_project_domain_id,
+              :openstack_domain_name   => @openstack_domain_name,
+              :openstack_project_name  => @openstack_project_name,
+              :openstack_domain_id     => @openstack_domain_id,
+              :openstack_project_id    => @openstack_project_id,
+              :openstack_auth_uri      => @openstack_auth_uri,
+              :openstack_auth_token    => @openstack_must_reauthenticate ? nil : @openstack_auth_token,
+              :openstack_service_type  => @openstack_service_type,
+              :openstack_service_name  => @openstack_service_name,
+              :openstack_endpoint_type => @openstack_endpoint_type,
+              :openstack_region        => @openstack_region
+          }
+
+          credentials = Fog::OpenStack.authenticate(options, @connection_options)
+
+          @current_user = credentials[:user]
+          @current_tenant = credentials[:tenant]
+
+          @openstack_must_reauthenticate = false
+          @auth_token = credentials[:token]
+          @openstack_management_url = credentials[:server_management_url]
+        else
+          @auth_token = @openstack_auth_token
+        end
+        @openstack_management_uri = URI.parse(@openstack_management_url)
+
+        @host   = @openstack_management_uri.host
+        @path   = @openstack_management_uri.path
+        @port   = @openstack_management_uri.port
+        @scheme = @openstack_management_uri.scheme
+        true
+      end
+    end
+
     def self.authenticate(options, connection_options = {})
       case options[:openstack_auth_uri].path
       when /v1(\.\d+)?/
@@ -175,8 +296,7 @@ module Fog
 
     # Keystone Style Auth
     def self.authenticate_v3(options, connection_options = {})
-      uri                   = options[:openstack_auth_uri]
-      tenant_name           = options[:openstack_tenant]
+      uri = options[:openstack_auth_uri]
       project_name          = options[:openstack_project_name]
       service_type          = options[:openstack_service_type]
       service_name          = options[:openstack_service_name]
@@ -184,11 +304,11 @@ module Fog
       endpoint_type         = map_endpoint_type(options[:openstack_endpoint_type] || 'publicURL')
       openstack_region      = options[:openstack_region]
 
-      body, token_headers = retrieve_tokens_v3(options, connection_options)
+      token, body = retrieve_tokens_v3 options, connection_options
 
-      service = get_service(body, service_type, service_name)
+      service = get_service_v3(body, service_type, service_name, openstack_region)
 
-      options[:unscoped_token] = token_headers['X-Subject-Token']
+      options[:unscoped_token] = token
 
       unless service
         unless project_name
@@ -196,8 +316,8 @@ module Fog
               :expects => [200],
               :headers => {'Content-Type' => 'application/json',
                            'Accept' => 'application/json',
-                           'X-Auth-Token' => token_headers['X-Subject-Token']},
-              :method  => 'GET'
+                           'X-Auth-Token' => token},
+              :method => 'GET'
           }
           user_id = body['token']['user']['id']
           response = Fog::Core::Connection.new(
@@ -205,34 +325,34 @@ module Fog
 
           projects_body = Fog::JSON.decode(response.body)
           if projects_body['projects'].empty?
-            raise Fog::Errors::NotFound.new('No Project Found')
+            options[:openstack_domain_id] = body['token']['user']['domain']['id']
           else
             options[:openstack_project_name] = projects_body['projects'].first['name']
-            options[:openstack_domain_name] = body['token']['user']['domain']['name']
+            options[:openstack_domain_id] = projects_body['projects'].first['domain_id']
           end
         end
 
-        tenant_name = options[:openstack_project_name]
+        token, body = retrieve_tokens_v3(options, connection_options)
+        service = get_service_v3(body, service_type, service_name, openstack_region)
+      end
 
-        unless tenant_name
-          response = Fog::Core::Connection.new(
-            "#{uri.scheme}://#{uri.host}:#{uri.port}/v3/projects", false, connection_options).request({
-            :expects => [200, 204],
-            :headers => {'Content-Type' => 'application/json',
-                         'Accept' => 'application/json',
-                         'X-Auth-Token' => token_headers['X-Subject-Token']},
-            :method  => 'GET'
-          })
-          body = Fog::JSON.decode(response.body)
-          if body['projects'].empty?
-            raise Fog::Errors::NotFound.new('No Tenant Found')
-          else
-            options[:openstack_tenant] = body['projects'].first['name']
-          end
+      unless service
+        available_services = body['token']['catalog'].map { |service|
+          service['type']
+        }.sort.join ', '
 
-        end
-        body, token_headers = retrieve_tokens_v3(options, connection_options)
-        service = get_service(body, service_type, service_name)
+        available_regions = body['token']['catalog'].map { |service|
+          service['endpoints'].map { |endpoint|
+            endpoint['region']
+          }.uniq
+        }.uniq.sort.join ', '
+
+        missing = service_type.join ', '
+
+        message = "Could not find service #{missing}#{(' in region '+openstack_region) if openstack_region}."+
+            " Have #{available_services}#{(' in regions '+available_regions) if openstack_region}"
+
+        raise Fog::Errors::NotFound, message
       end
 
       service['endpoints'] = service['endpoints'].select do |endpoint|
@@ -243,48 +363,34 @@ module Fog
         raise Fog::Errors::NotFound.new("No endpoints available for region '#{openstack_region}'")
       end if openstack_region
 
-      unless service
-        available = body['token']['catalog'].map { |endpoint|
-          endpoint['type']
-        }.sort.join ', '
-
-        missing = service_type.join ', '
-
-        message = "Could not find service #{missing}.  Have #{available}"
-
-        raise Fog::Errors::NotFound, message
+      regions = service["endpoints"].map { |e| e['region'] }.uniq
+      if regions.count > 1
+        raise Fog::Errors::NotFound.new("Multiple regions available choose one of these '#{regions.join(',')}'")
       end
 
-      admin = false
-      body['token']['roles'].each do |r|
-        admin = true if r["name"] == "admin"
-      end
+      identity_service = get_service_v3(body, identity_service_type) if identity_service_type
 
-      regions = service["endpoints"].map{ |e| e['region'] }.uniq
-      if regions.count > 1 and not admin
-        raise Fog::Errors::NotFound.new("Multiple regions available choose one of these '#{regions.join(',')}'")
-      end
+      management_url = service['endpoints'].find { |e| e['interface']==endpoint_type }['url']
+      identity_url = identity_service['endpoints'].find { |e| e['interface']=='public' }['url'] if identity_service
 
-      identity_service = get_service(body, identity_service_type) if identity_service_type
-      tenant = body['token']['project']['name'] if body['token']['project']
-      tenant = body['token']['user']['project']['name'] unless body['token']['project']
-      user = body['token']['user']['name']
+      if body['token']['project']
+        tenant = body['token']['project']['name']
+      else
+        tenant = body['token']['user']['project']['name'] if body['token']['user']['project']
+      end
 
-      management_url = service['endpoints'].find{|s| s["interface"][endpoint_type]}["url"]
-      identity_url   = identity_service['endpoints'].find{|s| s["interface"]["public"]}["url"] if identity_service
-      {
-        :user                     => user,
-        :tenant                   => tenant,
-        :identity_public_endpoint => identity_url,
-        :server_management_url    => management_url,
-        :token                    => token_headers['X-Subject-Token'],
-        :expires                  => body['token']['expires_at'],
-        :current_user_id          => body['token']['user']['id'],
-        :unscoped_token           => options[:unscoped_token]
+      return {
+          :user                     => body['token']['user']['name'],
+          :tenant                   => tenant,
+          :identity_public_endpoint => identity_url,
+          :server_management_url    => management_url,
+          :token                    => token,
+          :expires                  => body['token']['expires_at'],
+          :current_user_id          => body['token']['user']['id'],
+          :unscoped_token           => options[:unscoped_token]
       }
     end
 
-
     def self.get_service(body, service_type=[], service_name=nil)
       if not body['access'].nil?
         body['access']['serviceCatalog'].find do |s|
@@ -340,87 +446,120 @@ module Fog
     end
 
     def self.retrieve_tokens_v3(options, connection_options = {})
-      api_key     = options[:openstack_api_key].to_s
-      username    = options[:openstack_username].to_s
-      if options[:openstack_tenant_id]
-        tenant_id   = options[:openstack_tenant_id].to_s
-      else
-        tenant_name = options[:openstack_tenant].to_s
-      end
-      auth_token  = options[:openstack_auth_token] || options[:unscoped_token]
-      uri         = options[:openstack_auth_uri]
-      userdomain  = options[:openstack_user_domain] || options[:openstack_domain] || 'Default'
-      project_domain  = options[:openstack_project_domain]  || options[:openstack_domain] || 'Default'
+
+      api_key      = options[:openstack_api_key].to_s
+      username     = options[:openstack_username].to_s
+      userid       = options[:openstack_userid]
+      domain_id    = options[:openstack_domain_id]
+      domain_name  = options[:openstack_domain_name]
+      project_domain = options[:openstack_project_domain]
+      project_domain_id = options[:openstack_project_domain_id]
+      user_domain  = options[:openstack_user_domain]
+      user_domain_id  = options[:openstack_user_domain_id]
+      project_name = options[:openstack_project_name]
+      project_id   = options[:openstack_project_id]
+      auth_token   = options[:openstack_auth_token] || options[:unscoped_token]
+      uri          = options[:openstack_auth_uri]
 
       connection = Fog::Core::Connection.new(uri.to_s, false, connection_options)
-      request_body = {:auth => Hash.new}
+      request_body = {:auth => {}}
+
+      scope = {}
+
+      if project_name || project_id
+        scope[:project] = if project_id.nil? then
+                            if project_domain || project_domain_id
+                              {:name => project_name, :domain => project_domain_id.nil? ? {:name => project_domain} : {:id => project_domain_id}}
+                            else
+                              {:name => project_name, :domain => domain_id.nil? ? {:name => domain_name} : {:id => domain_id}}
+                            end
+                          else
+                            {:id => project_id}
+                          end
+      elsif domain_name || domain_id
+        scope[:domain] = domain_id.nil? ? {:name => domain_name} : {:id => domain_id}
+      else
+        # unscoped token
+      end
 
       if auth_token
-        request_body[:auth][:token] = {
-          :id => auth_token
+        request_body[:auth][:identity] = {
+            :methods => %w{token},
+            :token => {
+                :id => auth_token
+            }
         }
       else
         request_body[:auth][:identity] = {
-          :methods => ["password"],
-          :password => {
-            :user => {
-              :name => username,
-              :password => api_key
+            :methods => %w{password},
+            :password => {
+                :user => {
+                    :password => api_key
+                }
             }
-          }
         }
-        unless tenant_id.nil?
-          request_body[:auth][:scope] = {
-            :project => {
-              :id => tenant_id
-            }
-          }
+
+        if userid
+          request_body[:auth][:identity][:password][:user][:id] = userid
         else
-          request_body[:auth][:scope] = {
-            :project => {
-              :name => tenant_name
-            }
-          }
-        end
-        unless userdomain.to_s.empty?
-          request_body[:auth][:identity][:password][:user][:domain] = {
-                  :name => userdomain
-          }
-        end
-        unless project_domain.to_s.empty?
-          request_body[:auth][:scope][:project][:domain] = {
-                :name => project_domain
-          }
+          if user_domain || user_domain_id
+            request_body[:auth][:identity][:password][:user].merge! :domain => user_domain_id.nil? ? {:name => user_domain} : {:id => user_domain_id}
+          elsif domain_name || domain_id
+            request_body[:auth][:identity][:password][:user].merge! :domain => domain_id.nil? ? {:name => domain_name} : {:id => domain_id}
+          end
+          request_body[:auth][:identity][:password][:user][:name] = username
         end
+
       end
+      request_body[:auth][:scope] = scope unless scope.empty?
+
+      puts "request_body: #{request_body}" if user_domain=='Default2'
 
       response = connection.request({
-        :expects  => [201],
-        :headers  => {'Content-Type' => 'application/json'},
-        :body     => Fog::JSON.encode(request_body),
-        :method   => 'POST',
-        :path     => (uri.path and not uri.path.empty?) ? uri.path : 'v3'
-      })
+                                        :expects => [201],
+                                        :headers => {'Content-Type' => 'application/json'},
+                                        :body => Fog::JSON.encode(request_body),
+                                        :method => 'POST',
+                                        :path => (uri.path and not uri.path.empty?) ? uri.path : 'v2.0'
+                                    })
+
+      puts "response.body: #{response.body}" if user_domain=='Default2'
+
+      [response.headers["X-Subject-Token"], Fog::JSON.decode(response.body)]
+    end
+
+    def self.get_service_v3(hash, service_type=[], service_name=nil, region=nil)
+
+      services = hash['token']['catalog'].find_all do |s|
+        if service_name.nil? or service_name.empty?
+          service_type.include?(s['type'])
+        else
+          service_type.include?(s['type']) and s['name'] == service_name
+        end
+      end if hash['token']['catalog']
+
+      services.find do |s|
+        region.nil? or s['endpoints'].any? { |ep| ep['region'] == region }
+      end if services
 
-      return Fog::JSON.decode(response.body), response.headers
     end
 
     def self.get_supported_version(supported_versions, uri, auth_token, connection_options = {})
       connection = Fog::Core::Connection.new("#{uri.scheme}://#{uri.host}:#{uri.port}", false, connection_options)
       response = connection.request({
-        :expects => [200, 204, 300],
-        :headers => {'Content-Type' => 'application/json',
-                     'Accept' => 'application/json',
-                     'X-Auth-Token' => auth_token},
-        :method  => 'GET'
-      })
+                                        :expects => [200, 204, 300],
+                                        :headers => {'Content-Type' => 'application/json',
+                                                     'Accept' => 'application/json',
+                                                     'X-Auth-Token' => auth_token},
+                                        :method => 'GET'
+                                    })
 
       body = Fog::JSON.decode(response.body)
       version = nil
       unless body['versions'].empty?
         supported_version = body['versions'].find do |x|
           x["id"].match(supported_versions) &&
-          (x["status"] == "CURRENT" || x["status"] == "SUPPORTED")
+              (x["status"] == "CURRENT" || x["status"] == "SUPPORTED")
         end
         version = supported_version["id"] if supported_version
       end
@@ -433,7 +572,7 @@ module Fog
     end
 
     # CGI.escape, but without special treatment on spaces
-    def self.escape(str,extra_exclude_chars = '')
+    def self.escape(str, extra_exclude_chars = '')
       str.gsub(/([^a-zA-Z0-9_.-#{extra_exclude_chars}]+)/) do
         '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
       end