fog-openstack 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8a6165984c1f19c2ae03e5673d3d223e1a5b196b
+  data.tar.gz: 95d5177e637bce30149f49cb0c5324c77ab3243b
+SHA512:
+  metadata.gz: 9151bde397b04c12c2fe65ef5c996d44addfd11b46655ec28313855aebc60c308a33428f4a5a0f64ca96f3ad2193e629a3af801831ff1651e242a10b4ec7ed07
+  data.tar.gz: 2564f645ef566d60c1940c854e7bb836babb895666c67c286a3d49d8ef282d4f04179aec19627f5df002b29395a44314739d2141957d760ea70e88a9807307a9

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+fog-openstack

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/.travis.yml

@@ -0,0 +1,30 @@
+language: ruby
+sudo: false
+script: bundle exec rake test
+matrix:
+  fast_finish: true
+  include:
+  - rvm: 1.8.7
+    gemfile: gemfiles/Gemfile-ruby-1.8.7
+  - rvm: 1.9.3
+    gemfile: Gemfile
+  - rvm: 2.0.0
+    gemfile: Gemfile
+  - rvm: 2.1.0
+    gemfile: Gemfile
+  - rvm: 2.1.1
+    gemfile: Gemfile
+  - rvm: 2.1.1
+    gemfile: gemfiles/Gemfile-edge
+  - rvm: 2.2.0
+    gemfile: Gemfile
+  - rvm: 2.2.0
+    gemfile: gemfiles/Gemfile-edge
+  - rvm: jruby-18mode
+    gemfile: gemfiles/Gemfile-ruby-1.8.7
+  - rvm: jruby-19mode
+    gemfile: Gemfile
+  - rvm: jruby-head
+    gemfile: Gemfile
+  allow_failures:
+  - rvm: jruby-head

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at matt.darby@rackspace.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/CONTRIBUTING.md

@@ -0,0 +1,18 @@
+## Getting Involved
+
+New contributors are always welcome, when it doubt please ask questions. We strive to be an open and welcoming community. Please be nice to one another.
+
+### Coding
+
+* Pick a task:
+  * Offer feedback on open [pull requests](https://github.com/fog/fog-openstack/pulls).
+  * Review open [issues](https://github.com/fog/fog-openstack/issues) for things to help on.
+  * [Create an issue](https://github.com/fog/fog-openstack/issues/new) to start a discussion on additions or features.
+* Fork the project, add your changes and tests to cover them in a topic branch.
+* Commit your changes and rebase against `fog/fog-openstack` to ensure everything is up to date.
+* [Submit a pull request](https://github.com/fog/fog-openstack/compare/).
+
+### Non-Coding
+
+* Offer feedback on open [issues](https://github.com/fog/fog-openstack/issues).
+* Organize or volunteer at events.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fog-openstack.gemspec
+gemspec

data/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 [CONTRIBUTORS.md](https://github.com/fog/fog-rackspace/blob/master/CONTRIBUTORS.md)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# Fog::Openstack
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/fog/openstack`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fog-openstack'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fog-openstack
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/fog-openstack. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+task :default => :test
+
+mock = ENV['FOG_MOCK'] || 'true'
+task :test do
+  sh("export FOG_MOCK=#{mock} && bundle exec shindont")
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fog/openstack"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/fog-openstack.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fog/openstack/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fog-openstack"
+  spec.version       = Fog::Openstack::VERSION
+  spec.authors       = ["Matt Darby"]
+  spec.email         = ["matt.darby@rackspace.com"]
+
+  spec.summary       = %q{OpenStack fog provider gem}
+  spec.description   = %q{OpenStack fog provider gem.}
+  spec.homepage      = "https://github.com/fog/fog-openstack"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake',    '~> 10.0'
+  spec.add_development_dependency 'shindo',  '~> 0.3'
+  spec.add_development_dependency 'rubyzip', '~> 0.9.9'
+  spec.add_development_dependency "mime-types"
+  spec.add_development_dependency "mime-types-data"
+
+  spec.add_dependency 'fog-core',  '>= 1.35'
+  spec.add_dependency 'fog-json',  '>= 1.0'
+  spec.add_dependency 'fog-xml',   '>= 0.1'
+  spec.add_dependency 'ipaddress', '>= 0.8'
+end

data/lib/fog/openstack.rb

@@ -0,0 +1,508 @@
+require 'fog/openstack/version'
+require 'fog/core'
+require 'fog/json'
+
+require 'fog/openstack/core'
+require 'fog/openstack/common'
+require 'fog/openstack/errors'
+
+module Fog
+  module OpenStack
+    extend Fog::Provider
+
+    # `require` is necessary until they can be refactored into autoload
+    require 'fog/openstack/image_v1'
+    require 'fog/openstack/storage'
+    require 'fog/openstack/volume_v1'
+    require 'fog/openstack/volume_v2'
+    require 'fog/openstack/planning'
+
+    autoload :Compute, File.expand_path('../openstack/compute', __FILE__)
+    autoload :IdentityV2, File.expand_path('../openstack/identity_v2', __FILE__)
+    autoload :IdentityV3, File.expand_path('../openstack/identity_v3', __FILE__)
+    autoload :Image, File.expand_path('../openstack/image', __FILE__)
+    autoload :ImageV2, File.expand_path('../openstack/image_v2', __FILE__)
+    autoload :Metering, File.expand_path('../openstack/metering', __FILE__)
+    autoload :Network, File.expand_path('../openstack/network', __FILE__)
+    autoload :Orchestration, File.expand_path('../openstack/orchestration', __FILE__)
+    autoload :Volume, File.expand_path('../openstack/volume', __FILE__)
+    autoload :Baremetal, File.expand_path('../openstack/baremetal', __FILE__)
+
+    service(:compute ,      'Compute')
+    service(:image,         'Image')
+    service(:identity,      'Identity')
+    service(:network,       'Network')
+    service(:storage,       'Storage')
+    service(:volume,        'Volume')
+    service(:metering,      'Metering')
+    service(:orchestration, 'Orchestration')
+    service(:baremetal,     'Baremetal')
+    service(:planning,      'Planning')
+
+    @@token_cache = {}
+
+    def self.clear_token_cache
+      @@token_cache.clear
+    end
+
+    def self.authenticate(options, connection_options = {})
+      case options[:openstack_auth_uri].path
+      when /v1(\.\d+)?/
+        authenticate_v1(options, connection_options)
+      when /v2(\.\d+)?/
+        authenticate_v2(options, connection_options)
+      when /v3(\.\d+)?/
+        authenticate_v3(options, connection_options)
+      else
+        authenticate_v2(options, connection_options)
+      end
+    end
+
+    # legacy v1.0 style auth
+    def self.authenticate_v1(options, connection_options = {})
+      uri = options[:openstack_auth_uri]
+      connection = Fog::Core::Connection.new(uri.to_s, false, connection_options)
+      @openstack_api_key  = options[:openstack_api_key]
+      @openstack_username = options[:openstack_username]
+
+      response = connection.request({
+        :expects  => [200, 204],
+        :headers  => {
+          'X-Auth-Key'  => @openstack_api_key,
+          'X-Auth-User' => @openstack_username
+        },
+        :method   => 'GET',
+        :path     =>  (uri.path and not uri.path.empty?) ? uri.path : 'v1.0'
+      })
+
+      return {
+        :token => response.headers['X-Auth-Token'],
+        :server_management_url => response.headers['X-Server-Management-Url'] || response.headers['X-Storage-Url'],
+        :identity_public_endpoint => response.headers['X-Keystone']
+      }
+    end
+
+    # Keystone Style Auth
+    def self.authenticate_v2(options, connection_options = {})
+      uri                   = options[:openstack_auth_uri]
+      tenant_name           = options[:openstack_tenant]
+      service_type          = options[:openstack_service_type]
+      service_name          = options[:openstack_service_name]
+      identity_service_type = options[:openstack_identity_service_type]
+      endpoint_type         = (options[:openstack_endpoint_type] || 'publicURL').to_s
+      openstack_region      = options[:openstack_region]
+
+      body = retrieve_tokens_v2(options, connection_options)
+      service = get_service(body, service_type, service_name)
+
+      options[:unscoped_token] = body['access']['token']['id']
+
+      unless service
+        unless tenant_name
+          response = Fog::Core::Connection.new(
+            "#{uri.scheme}://#{uri.host}:#{uri.port}/v2.0/tenants", false, connection_options).request({
+            :expects => [200, 204],
+            :headers => {'Content-Type' => 'application/json',
+                         'Accept' => 'application/json',
+                         'X-Auth-Token' => body['access']['token']['id']},
+            :method  => 'GET'
+          })
+
+          body = Fog::JSON.decode(response.body)
+          if body['tenants'].empty?
+            raise Fog::Errors::NotFound.new('No Tenant Found')
+          else
+            options[:openstack_tenant] = body['tenants'].first['name']
+          end
+        end
+
+        body = retrieve_tokens_v2(options, connection_options)
+        service = get_service(body, service_type, service_name)
+
+      end
+
+      service['endpoints'] = service['endpoints'].select do |endpoint|
+        endpoint['region'] == openstack_region
+      end if openstack_region
+
+      if service['endpoints'].empty?
+        raise Fog::Errors::NotFound.new("No endpoints available for region '#{openstack_region}'")
+      end if openstack_region
+
+      unless service
+        available = body['access']['serviceCatalog'].map { |endpoint|
+          endpoint['type']
+        }.sort.join ', '
+
+        missing = service_type.join ', '
+
+        message = "Could not find service #{missing}.  Have #{available}"
+
+        raise Fog::Errors::NotFound, message
+      end
+
+      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
+
+      identity_service = get_service(body, identity_service_type) if identity_service_type
+      tenant = body['access']['token']['tenant']
+      user = body['access']['user']
+
+      management_url = service['endpoints'].find{|s| s[endpoint_type]}[endpoint_type]
+      identity_url   = identity_service['endpoints'].find{|s| s['publicURL']}['publicURL'] if identity_service
+
+      {
+        :user                     => user,
+        :tenant                   => tenant,
+        :identity_public_endpoint => identity_url,
+        :server_management_url    => management_url,
+        :token                    => body['access']['token']['id'],
+        :expires                  => body['access']['token']['expires'],
+        :current_user_id          => body['access']['user']['id'],
+        :unscoped_token           => options[:unscoped_token]
+      }
+    end
+
+    # Keystone Style Auth
+    def self.authenticate_v3(options, connection_options = {})
+      uri = options[:openstack_auth_uri]
+      project_name          = options[:openstack_project_name]
+      service_type          = options[:openstack_service_type]
+      service_name          = options[:openstack_service_name]
+      identity_service_type = options[:openstack_identity_service_type]
+      endpoint_type         = map_endpoint_type(options[:openstack_endpoint_type] || 'publicURL')
+      openstack_region      = options[:openstack_region]
+
+      token, body = retrieve_tokens_v3 options, connection_options
+
+      service = get_service_v3(body, service_type, service_name, openstack_region, options)
+
+      options[:unscoped_token] = token
+
+      unless service
+        unless project_name
+          request_body = {
+              :expects => [200],
+              :headers => {'Content-Type' => 'application/json',
+                           'Accept' => 'application/json',
+                           'X-Auth-Token' => token},
+              :method => 'GET'
+          }
+          user_id = body['token']['user']['id']
+          response = Fog::Core::Connection.new(
+              "#{uri.scheme}://#{uri.host}:#{uri.port}/v3/users/#{user_id}/projects", false, connection_options).request(request_body)
+
+          projects_body = Fog::JSON.decode(response.body)
+          if projects_body['projects'].empty?
+            options[:openstack_domain_id] = body['token']['user']['domain']['id']
+          else
+            options[:openstack_project_name] = projects_body['projects'].first['name']
+            options[:openstack_domain_id] = projects_body['projects'].first['domain_id']
+          end
+        end
+
+        token, body = retrieve_tokens_v3(options, connection_options)
+        service = get_service_v3(body, service_type, service_name, openstack_region, options)
+      end
+
+      unless service
+        available_services = body['token']['catalog'].map { |service|
+          service['type']
+        }.sort.join ', '
+
+        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|
+        endpoint['region'] == openstack_region && endpoint['interface'] == endpoint_type
+      end if openstack_region
+
+      if service['endpoints'].empty?
+        raise Fog::Errors::NotFound.new("No endpoints available for region '#{openstack_region}'")
+      end if openstack_region
+
+      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
+
+      identity_service = get_service_v3(body, identity_service_type, nil, nil, :openstack_endpoint_path_matches => /\/v3/) if identity_service_type
+
+      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
+
+      if body['token']['project']
+        tenant = body['token']['project']['name']
+      else
+        tenant = body['token']['user']['project']['name'] if body['token']['user']['project']
+      end
+
+      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|
+          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
+      elsif not body['token']['catalog'].nil?
+        body['token']['catalog'].find 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
+
+      end
+    end
+
+    def self.retrieve_tokens_v2(options, connection_options = {})
+      api_key     = options[:openstack_api_key].to_s
+      username    = options[:openstack_username].to_s
+      tenant_name = options[:openstack_tenant].to_s
+      auth_token  = options[:openstack_auth_token] || options[:unscoped_token]
+      uri         = options[:openstack_auth_uri]
+
+      identity_v2_connection = Fog::Core::Connection.new(uri.to_s, false, connection_options)
+      request_body = {:auth => Hash.new}
+
+      if auth_token
+        request_body[:auth][:token] = {
+          :id => auth_token
+        }
+      else
+        request_body[:auth][:passwordCredentials] = {
+          :username => username,
+          :password => api_key
+        }
+      end
+      request_body[:auth][:tenantName] = tenant_name if tenant_name
+
+      response = identity_v2_connection.request({
+        :expects  => [200, 204],
+        :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'
+      })
+
+      Fog::JSON.decode(response.body)
+    end
+
+    def self.retrieve_tokens_v3(options, connection_options = {})
+
+      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 => {}}
+
+      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][:identity] = {
+            :methods => %w{token},
+            :token => {
+                :id => auth_token
+            }
+        }
+      else
+        request_body[:auth][:identity] = {
+            :methods => %w{password},
+            :password => {
+                :user => {
+                    :password => api_key
+                }
+            }
+        }
+
+        if userid
+          request_body[:auth][:identity][:password][:user][:id] = userid
+        else
+          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?
+
+      path     = (uri.path and not uri.path.empty?) ? uri.path : 'v3'
+
+      response, expires = @@token_cache[{body: request_body, path: path}]
+
+      unless response && expires > Time.now
+        response = connection.request({   :expects => [201],
+                                          :headers => {'Content-Type' => 'application/json'},
+                                          :body    => Fog::JSON.encode(request_body),
+                                          :method  => 'POST',
+                                          :path    => path
+                                      })
+        @@token_cache[{body: request_body, path: path}] = response, Time.now + 30 # 30-second TTL, enough for most requests
+      end
+
+      [response.headers["X-Subject-Token"], Fog::JSON.decode(response.body)]
+    end
+
+    def self.get_service_v3(hash, service_type=[], service_name=nil, region=nil, options={})
+
+      # Find all services matching any of the types in service_type, filtered by service_name if it's non-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']
+
+      # Filter the found services by region (if specified) and whether the endpoint path matches the given regex (e.g. /\/v3/)
+      services.find do |s|
+        s['endpoints'].any? { |ep| endpoint_region?(ep, region) && endpoint_path_match?(ep, options[:openstack_endpoint_path_matches])}
+      end if services
+
+    end
+
+    def self.endpoint_region?(endpoint, region)
+      region.nil? || endpoint['region'] == region
+    end
+
+    def self.endpoint_path_match?(endpoint, match_regex)
+      match_regex.nil? || URI(endpoint['url']).path =~ match_regex
+    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'
+                                    })
+
+      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")
+        end
+        version = supported_version["id"] if supported_version
+      end
+      if version.nil?
+        raise Fog::OpenStack::Errors::ServiceUnavailable.new(
+                  "OpenStack service only supports API versions #{supported_versions.inspect}")
+      end
+
+      version
+    end
+
+    def self.get_supported_version_path(supported_versions, uri, auth_token, connection_options = {})
+      # Find a version in the path (e.g. the v1 in /xyz/v1/tenantid/abc) and get the path up until that version (e.g. /xyz))
+      path_components = uri.path.split '/'
+      version_component_index = path_components.index{|comp| comp.match(/v[0-9].?[0-9]?/) }
+      versionless_path = (path_components.take(version_component_index).join '/' if version_component_index) || ''
+      connection = Fog::Core::Connection.new("#{uri.scheme}://#{uri.host}:#{uri.port}#{versionless_path}", 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'
+                                    })
+
+      body = Fog::JSON.decode(response.body)
+      path = nil
+      unless body['versions'].empty?
+        supported_version = body['versions'].find do |x|
+          x["id"].match(supported_versions) &&
+              (x["status"] == "CURRENT" || x["status"] == "SUPPORTED")
+        end
+        path = URI.parse(supported_version['links'].first['href']).path if supported_version
+      end
+      if path.nil?
+        raise Fog::OpenStack::Errors::ServiceUnavailable.new(
+                  "OpenStack service only supports API versions #{supported_versions.inspect}")
+      end
+
+      path.chomp '/'
+    end
+
+    # CGI.escape, but without special treatment on spaces
+    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
+    end
+
+    def self.map_endpoint_type type
+      case type
+        when "publicURL"
+          "public"
+        when "internalURL"
+          "internal"
+        when "adminURL"
+          "admin"
+      end
+
+    end
+  end
+
+end