RubyGems - fog - Versions diffs - 2.0.0.pre.0 → 2.0.0 - Mend

fog 2.0.0.pre.0 → 2.0.0

Files changed (2479) hide show

data/lib/fog/openstack/compute.rb DELETED

@@ -1,393 +0,0 @@
-require 'fog/openstack/core'
-module Fog
-  module Compute
-    class OpenStack < Fog::Service
-      requires :openstack_auth_url
-      recognizes :openstack_auth_token, :openstack_management_url,
-                 :persistent, :openstack_service_type, :openstack_service_name,
-                 :openstack_tenant, :openstack_tenant_id,
-                 :openstack_api_key, :openstack_username, :openstack_identity_endpoint,
-                 :current_user, :current_tenant, :openstack_region,
-                 :openstack_endpoint_type,
-                 :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       :availability_zone
-      collection  :availability_zones
-      model       :server
-      collection  :servers
-      model       :service
-      collection  :services
-      model       :image
-      collection  :images
-      model       :flavor
-      collection  :flavors
-      model       :metadatum
-      collection  :metadata
-      model       :address
-      collection  :addresses
-      model       :security_group
-      collection  :security_groups
-      model       :security_group_rule
-      collection  :security_group_rules
-      model       :key_pair
-      collection  :key_pairs
-      model       :tenant
-      collection  :tenants
-      model       :volume
-      collection  :volumes
-      model       :network
-      collection  :networks
-      model       :snapshot
-      collection  :snapshots
-      model       :host
-      collection  :hosts
-      ## REQUESTS
-      #
-      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
-      request :create_server
-      request :get_server_details
-      request :update_server
-      request :delete_server
-      # Server Actions
-      request :server_actions
-      request :server_action
-      request :reboot_server
-      request :rebuild_server
-      request :resize_server
-      request :confirm_resize_server
-      request :revert_resize_server
-      request :pause_server
-      request :unpause_server
-      request :suspend_server
-      request :resume_server
-      request :start_server
-      request :stop_server
-      request :rescue_server
-      request :change_server_password
-      request :add_fixed_ip
-      request :remove_fixed_ip
-      request :server_diagnostics
-      request :boot_from_snapshot
-      request :reset_server_state
-      request :add_security_group
-      request :remove_security_group
-      request :shelve_server
-      request :unshelve_server
-      request :shelve_offload_server
-      # Server Extenstions
-      request :get_console_output
-      request :get_vnc_console
-      request :live_migrate_server
-      request :migrate_server
-      # Service CRUD
-      request :list_services
-      request :enable_service
-      request :disable_service
-      request :disable_service_log_reason
-      request :delete_service
-      # Image CRUD
-      request :list_images
-      request :list_images_detail
-      request :create_image
-      request :get_image_details
-      request :delete_image
-      # Flavor CRUD
-      request :list_flavors
-      request :list_flavors_detail
-      request :get_flavor_details
-      request :create_flavor
-      request :delete_flavor
-      # Flavor Actions
-      request :get_flavor_metadata
-      request :create_flavor_metadata
-      # Flavor Access
-      request :add_flavor_access
-      request :remove_flavor_access
-      request :list_tenants_with_flavor_access
-      # Hypervisor
-      request :get_hypervisor_statistics
-      # Metadata
-      request :list_metadata
-      request :get_metadata
-      request :set_metadata
-      request :update_metadata
-      request :delete_metadata
-      # Metadatam
-      request :delete_meta
-      request :update_meta
-      # Address
-      request :list_addresses
-      request :list_address_pools
-      request :list_all_addresses
-      request :list_private_addresses
-      request :list_public_addresses
-      request :get_address
-      request :allocate_address
-      request :associate_address
-      request :release_address
-      request :disassociate_address
-      # Security Group
-      request :list_security_groups
-      request :get_security_group
-      request :create_security_group
-      request :create_security_group_rule
-      request :delete_security_group
-      request :delete_security_group_rule
-      request :get_security_group_rule
-      # Key Pair
-      request :list_key_pairs
-      request :create_key_pair
-      request :delete_key_pair
-      # Tenant
-      request :list_tenants
-      request :set_tenant
-      request :get_limits
-      # Volume
-      request :list_volumes
-      request :list_volumes_detail
-      request :create_volume
-      request :get_volume_details
-      request :delete_volume
-      request :attach_volume
-      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
-      # Usage
-      request :list_usages
-      request :get_usage
-      # Quota
-      request :get_quota
-      request :get_quota_defaults
-      request :update_quota
-      # Hosts
-      request :list_hosts
-      request :get_host_details
-      # Zones
-      request :list_zones
-      request :list_zones_detailed
-      class Mock
-        attr_reader :auth_token
-        attr_reader :auth_token_expiration
-        attr_reader :current_user
-        attr_reader :current_tenant
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {
-              :last_modified => {
-                :images  => {},
-                :servers => {},
-                :key_pairs => {},
-                :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",
-                  "name"=>"cirros-0.3.0-x86_64-blank",
-                  'progress'  => 100,
-                  'status'    => "ACTIVE",
-                  'updated'   => "",
-                  'minRam'    => 0,
-                  'minDisk'   => 0,
-                  'metadata'  => {},
-                  'links'     => [{"href"=>"http://nova1:8774/v1.1/admin/images/1", "rel"=>"self"}, {"href"=>"http://nova1:8774/admin/images/2", "rel"=>"bookmark"}]
-                }
-              },
-              :servers => {},
-              :key_pairs => {},
-              :security_groups => {
-                '0' => {
-                  "id"          => 0,
-                  "tenant_id"   => Fog::Mock.random_hex(8),
-                  "name"        => "default",
-                  "description" => "default",
-                  "rules"       => [
-                    { "id"              => 0,
-                      "parent_group_id" => 0,
-                      "from_port"       => 68,
-                      "to_port"         => 68,
-                      "ip_protocol"     => "udp",
-                      "ip_range"        => { "cidr" => "0.0.0.0/0" },
-                      "group"           => {}, },
-                  ],
-                },
-              },
-              :server_security_group_map => {},
-              :addresses => {},
-              :quota => {
-                'security_group_rules' => 20,
-                'security_groups' => 10,
-                'injected_file_content_bytes' => 10240,
-                'injected_file_path_bytes' => 256,
-                'injected_files' => 5,
-                'metadata_items' => 128,
-                'floating_ips'   => 10,
-                'instances'      => 10,
-                'key_pairs'      => 10,
-                'gigabytes'      => 5000,
-                'volumes'        => 10,
-                'cores'          => 20,
-                'ram'            => 51200
-              },
-              :volumes => {}
-            }
-          end
-        end
-        def self.reset
-          @data = nil
-        end
-        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'
-          @openstack_management_url = management_url.to_s
-          identity_public_endpoint = URI.parse(options[:openstack_auth_url])
-          identity_public_endpoint.port = 5000
-          @openstack_identity_public_endpoint = identity_public_endpoint.to_s
-        end
-        def data
-          self.class.data["#{@openstack_username}-#{@current_tenant}"]
-        end
-        def reset_data
-          self.class.data.delete("#{@openstack_username}-#{@current_tenant}")
-        end
-      end
-      class Real
-        include Fog::OpenStack::Core
-        def initialize(options={})
-          initialize_identity options
-          @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]
-          @connection_options       = options[:connection_options] || {}
-          authenticate
-          unless @path.match(/1\.1|v2/)
-            raise Fog::OpenStack::Errors::ServiceUnavailable.new(
-                    "OpenStack compute binding only supports version 2 (a.k.a. 1.1)")
-          end
-          @persistent = options[:persistent] || false
-          @connection = Fog::Core::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
-        end
-        def request(params)
-          begin
-            response = @connection.request(params.merge({
-              :headers  => {
-                'Content-Type' => 'application/json',
-                'Accept' => 'application/json',
-                'X-Auth-Token' => @auth_token
-              }.merge!(params[:headers] || {}),
-              :path     => "#{@path}/#{params[:path]}",
-              :query    => params[:query]
-            }))
-          rescue Excon::Errors::Unauthorized => error
-            if error.response.body != 'Bad username or password' # token expiration
-              @openstack_must_reauthenticate = true
-              authenticate
-              retry
-            else # Bad Credentials
-              raise error
-            end
-          rescue Excon::Errors::HTTPStatusError => error
-            raise case error
-              when Excon::Errors::NotFound
-                Fog::Compute::OpenStack::NotFound.slurp(error)
-              else
-                error
-              end
-          end
-          if !response.body.empty? and response.get_header('Content-Type') == 'application/json'
-            response.body = Fog::JSON.decode(response.body)
-          end
-          response
-        end
-        private
-      end
-    end
-  end
-end

data/lib/fog/openstack/core.rb DELETED

@@ -1,594 +0,0 @@
-require 'fog/core'
-require 'fog/json'
-module Fog
-  module OpenStack
-    extend Fog::Provider
-    module Errors
-      class ServiceError < Fog::Errors::Error
-        attr_reader :response_data
-        def self.slurp(error)
-          if error.response.body.empty?
-            data = nil
-            message = nil
-          else
-            data = Fog::JSON.decode(error.response.body)
-            message = data['message']
-            if message.nil? and !data.values.first.nil?
-              message = data.values.first['message']
-            end
-          end
-          new_error = super(error, message)
-          new_error.instance_variable_set(:@response_data, data)
-          new_error
-        end
-      end
-      class ServiceUnavailable < ServiceError; end
-      class BadRequest < ServiceError
-        attr_reader :validation_errors
-        def self.slurp(error)
-          new_error = super(error)
-          unless new_error.response_data.nil? or new_error.response_data['badRequest'].nil?
-            new_error.instance_variable_set(:@validation_errors, new_error.response_data['badRequest']['validationErrors'])
-          end
-          new_error
-        end
-      end
-      class InterfaceNotImplemented < Fog::Errors::Error; end
-    end
-    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')
-    module Core
-      attr_accessor :auth_token
-      attr_reader :auth_token_expiration
-      attr_reader :current_user
-      attr_reader :current_user_id
-      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
-        # Create @openstack_* instance variables from all :openstack_* options
-        options.select{|x|x.to_s.start_with? 'openstack'}.each do |openstack_param, value|
-          instance_variable_set "@#{openstack_param}".to_sym, value
-        end
-        @auth_token        ||= options[:openstack_auth_token]
-        @openstack_identity_public_endpoint = options[:openstack_identity_endpoint]
-        @openstack_auth_uri    = URI.parse(options[:openstack_auth_url])
-        @openstack_must_reauthenticate  = false
-        @openstack_endpoint_type = options[:openstack_endpoint_type] || 'publicURL'
-        unless @auth_token
-          missing_credentials = Array.new
-          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_user_id = options[:current_user_id]
-        @current_tenant = options[:current_tenant]
-      end
-      def credentials
-        options =  {
-          :provider                    => 'openstack',
-          :openstack_auth_url          => @openstack_auth_uri.to_s,
-          :openstack_auth_token        => @auth_token,
-          :openstack_identity_endpoint => @openstack_identity_public_endpoint,
-          :current_user                => @current_user,
-          :current_user_id             => @current_user_id,
-          :current_tenant              => @current_tenant,
-          :unscoped_token              => @unscoped_token}
-        openstack_options.merge options
-      end
-      def reload
-        @connection.reset
-      end
-      private
-      def openstack_options
-        options={}
-        # Create a hash of (:openstack_*, value) of all the @openstack_* instance variables
-        self.instance_variables.select{|x|x.to_s.start_with? '@openstack'}.each do |openstack_param|
-          option_name = openstack_param.to_s[1..-1]
-          options[option_name.to_sym] = instance_variable_get openstack_param
-        end
-        options
-      end
-      def authenticate
-        if !@openstack_management_url || @openstack_must_reauthenticate
-          options = openstack_options
-          options[:openstack_auth_token] = @openstack_must_reauthenticate ? nil : @openstack_auth_token
-          credentials = Fog::OpenStack.authenticate(options, @connection_options)
-          @current_user = credentials[:user]
-          @current_user_id = credentials[:current_user_id]
-          @current_tenant = credentials[:tenant]
-          @openstack_must_reauthenticate = false
-          @auth_token = credentials[:token]
-          @openstack_management_url = credentials[:server_management_url]
-          @unscoped_token = credentials[:unscoped_token]
-        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
-        @path.sub!(/\/$/, '')
-        @port   = @openstack_management_uri.port
-        @scheme = @openstack_management_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(
-            @openstack_identity_public_endpoint || @openstack_management_url,
-            false, @connection_options)
-        end
-        true
-      end
-    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
-      if service['endpoints'].count > 1
-        regions = service["endpoints"].map{ |e| e['region'] }.uniq.join(',')
-        raise Fog::Errors::NotFound.new("Multiple regions available choose one of these '#{regions}'")
-      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[: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)
-      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, :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]
-      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 = 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?
-      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 : '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, 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[: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
-    # 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