    # File lib/fog/openstack.rb, line 74
        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::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']},
                :host    => uri.host,
                :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 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'].detect{|s| s[endpoint_type]}[endpoint_type]
          identity_url   = identity_service['endpoints'].detect{|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