diff --git a/acceptance/01-authentication.go b/acceptance/01-authentication.go
new file mode 100644
index 0000000..643ad48
--- /dev/null
+++ b/acceptance/01-authentication.go
@@ -0,0 +1,32 @@
+package main
+
+import (
+	"os"
+	"fmt"
+	"github.com/rackspace/gophercloud"
+)
+
+func main() {
+	provider := os.Getenv("SDK_PROVIDER")
+	username := os.Getenv("SDK_USERNAME")
+	password := os.Getenv("SDK_PASSWORD")
+
+	if (provider == "") || (username == "") || (password == "") {
+		fmt.Fprintf(os.Stderr, "One or more of the following environment variables aren't set:\n")
+		fmt.Fprintf(os.Stderr, "  SDK_PROVIDER=\"%s\"\n", provider)
+		fmt.Fprintf(os.Stderr, "  SDK_USERNAME=\"%s\"\n", username)
+		fmt.Fprintf(os.Stderr, "  SDK_PASSWORD=\"%s\"\n", password)
+		os.Exit(1)
+	}
+
+	_, err := gophercloud.Authenticate(
+		provider,
+		gophercloud.AuthOptions{
+			Username: username,
+			Password: password,
+		},
+	)
+	if err != nil {
+		panic(err)
+	}
+}
diff --git a/api.go b/api.go
new file mode 100644
index 0000000..73b3a8c
--- /dev/null
+++ b/api.go
@@ -0,0 +1,43 @@
+package gophercloud
+
+// globalContext is the, well, "global context."
+// Most of this SDK is written in a manner to facilitate easier testing,
+// which doesn't require all the configuration a real-world application would require.
+// However, for real-world deployments, applications should be able to rely on a consistent configuration of providers, etc.
+var globalContext *Context
+
+// providers is the set of supported providers.
+var providers = map[string]Provider{
+	"rackspace-us": Provider{
+		AuthEndpoint: "https://identity.api.rackspacecloud.com/v2.0/tokens",
+	},
+	"rackspace-uk": Provider{
+		AuthEndpoint: "https://lon.identity.api.rackspacecloud.com/v2.0/tokens",
+	},
+}
+
+// Initialize the global context to sane configuration.
+// The Go runtime ensures this function is called before main(),
+// thus guaranteeing proper configuration before your application ever runs.
+func init() {
+	globalContext = TestContext()
+	for name, descriptor := range providers {
+		globalContext.RegisterProvider(name, descriptor)
+	}
+}
+
+// Authenticate() grants access to the OpenStack-compatible provider API.
+//
+// Providers are identified through a unique key string.
+// Specifying an unsupported provider will result in an ErrProvider error.
+//
+// The supplied AuthOptions instance allows the client to specify only those credentials
+// relevant for the authentication request.  At present, support exists for OpenStack
+// Identity V2 API only; support for V3 will become available as soon as documentation for it
+// becomes readily available.
+//
+// For Identity V2 API requirements, you must provide at least the Username and Password
+// options.  The TenantId field is optional, and defaults to "".
+func Authenticate(provider string, options AuthOptions) (*Access, error) {
+	return globalContext.Authenticate(provider, options)
+}
diff --git a/authenticate.go b/authenticate.go
new file mode 100644
index 0000000..836c21b
--- /dev/null
+++ b/authenticate.go
@@ -0,0 +1,131 @@
+package gophercloud
+
+import (
+	"github.com/racker/perigee"
+)
+
+// AuthOptions lets anyone calling Authenticate() supply the required access credentials.
+// At present, only Identity V2 API support exists; therefore, only Username, Password,
+// and optionally, TenantId are provided.  If future Identity API versions become available,
+// alternative fields unique to those versions may appear here.
+type AuthOptions struct {
+	// Username and Password are required if using Identity V2 API.
+	// Consult with your provider's control panel to discover your
+	// account's username and password.
+	Username, Password string
+
+	// The TenantId field is optional for the Identity V2 API.
+	TenantId string
+}
+
+// AuthContainer provides a JSON encoding wrapper for passing credentials to the Identity
+// service.  You will not work with this structure directly.
+type AuthContainer struct {
+	Auth Auth `json:"auth"`
+}
+
+// Auth provides a JSON encoding wrapper for passing credentials to the Identity
+// service.  You will not work with this structure directly.
+type Auth struct {
+	PasswordCredentials PasswordCredentials `json:"passwordCredentials"`
+	TenantId            string              `json:"tenantId,omitempty"`
+}
+
+// PasswordCredentials provides a JSON encoding wrapper for passing credentials to the Identity
+// service.  You will not work with this structure directly.
+type PasswordCredentials struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+// Access encapsulates the API token and its relevant fields, as well as the
+// services catalog that Identity API returns once authenticated.  You'll probably
+// rarely use this record directly, unless you intend on marshalling or unmarshalling
+// Identity API JSON records yourself.
+type Access struct {
+	Token          Token
+	ServiceCatalog []CatalogEntry
+	User           User
+}
+
+// Token encapsulates an authentication token and when it expires.  It also includes
+// tenant information if available.
+type Token struct {
+	Id, Expires string
+	Tenant      Tenant
+}
+
+// Tenant encapsulates tenant authentication information.  If, after authentication,
+// no tenant information is supplied, both Id and Name will be "".
+type Tenant struct {
+	Id, Name string
+}
+
+// User encapsulates the user credentials, and provides visibility in what
+// the user can do through its role assignments.
+type User struct {
+	Id, Name          string
+	XRaxDefaultRegion string `json:"RAX-AUTH:defaultRegion"`
+	Roles             []Role
+}
+
+// Role encapsulates a permission that a user can rely on.
+type Role struct {
+	Description, Id, Name string
+}
+
+// CatalogEntry encapsulates a service catalog record.
+type CatalogEntry struct {
+	Name, Type string
+	Endpoints  []EntryEndpoint
+}
+
+// EntryEndpoint encapsulates how to get to the API of some service.
+type EntryEndpoint struct {
+	Region, TenantId                    string
+	PublicURL, InternalURL              string
+	VersionId, VersionInfo, VersionList string
+}
+
+// Authenticate() grants access to the OpenStack-compatible provider API.
+//
+// Providers are identified through a unique key string.
+// See the RegisterProvider() method for more details.
+//
+// The supplied AuthOptions instance allows the client to specify only those credentials
+// relevant for the authentication request.  At present, support exists for OpenStack
+// Identity V2 API only; support for V3 will become available as soon as documentation for it
+// becomes readily available.
+//
+// For Identity V2 API requirements, you must provide at least the Username and Password
+// options.  The TenantId field is optional, and defaults to "".
+func (c *Context) Authenticate(provider string, options AuthOptions) (*Access, error) {
+	var access *Access
+
+	p, err := c.ProviderByName(provider)
+	if err != nil {
+		return nil, err
+	}
+	if (options.Username == "") || (options.Password == "") {
+		return nil, ErrCredentials
+	}
+
+	err = perigee.Post(p.AuthEndpoint, perigee.Options{
+		CustomClient: c.httpClient,
+		ReqBody: &AuthContainer{
+			Auth: Auth{
+				PasswordCredentials: PasswordCredentials{
+					Username: options.Username,
+					Password: options.Password,
+				},
+				TenantId: options.TenantId,
+			},
+		},
+		Results: &struct {
+			Access **Access `json:"access"`
+		}{
+			&access,
+		},
+	})
+	return access, err
+}
diff --git a/authenticate_test.go b/authenticate_test.go
new file mode 100644
index 0000000..f077dab
--- /dev/null
+++ b/authenticate_test.go
@@ -0,0 +1,299 @@
+package gophercloud
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+const SUCCESSFUL_RESPONSE = `{
+	"access": {
+		"serviceCatalog": [{
+			"endpoints": [{
+				"publicURL": "https://ord.servers.api.rackspacecloud.com/v2/12345",
+				"region": "ORD",
+				"tenantId": "12345",
+				"versionId": "2",
+				"versionInfo": "https://ord.servers.api.rackspacecloud.com/v2",
+				"versionList": "https://ord.servers.api.rackspacecloud.com/"
+			},{
+				"publicURL": "https://dfw.servers.api.rackspacecloud.com/v2/12345",
+				"region": "DFW",
+				"tenantId": "12345",
+				"versionId": "2",
+				"versionInfo": "https://dfw.servers.api.rackspacecloud.com/v2",
+				"versionList": "https://dfw.servers.api.rackspacecloud.com/"
+			}],
+			"name": "cloudServersOpenStack",
+			"type": "compute"
+		},{
+			"endpoints": [{
+				"publicURL": "https://ord.databases.api.rackspacecloud.com/v1.0/12345",
+				"region": "ORD",
+				"tenantId": "12345"
+			}],
+			"name": "cloudDatabases",
+			"type": "rax:database"
+		}],
+		"token": {
+			"expires": "2012-04-13T13:15:00.000-05:00",
+			"id": "aaaaa-bbbbb-ccccc-dddd"
+		},
+		"user": {
+			"RAX-AUTH:defaultRegion": "DFW",
+			"id": "161418",
+			"name": "demoauthor",
+			"roles": [{
+				"description": "User Admin Role.",
+				"id": "3",
+				"name": "identity:user-admin"
+			}]
+		}
+	}
+}
+`
+
+type testTransport struct {
+	called   int
+	response string
+}
+
+func (t *testTransport) RoundTrip(req *http.Request) (rsp *http.Response, err error) {
+	t.called++
+
+	headers := make(http.Header)
+	headers.Add("Content-Type", "application/xml; charset=UTF-8")
+
+	body := ioutil.NopCloser(strings.NewReader(t.response))
+
+	rsp = &http.Response{
+		Status:           "200 OK",
+		StatusCode:       200,
+		Proto:            "HTTP/1.1",
+		ProtoMajor:       1,
+		ProtoMinor:       1,
+		Header:           headers,
+		Body:             body,
+		ContentLength:    -1,
+		TransferEncoding: nil,
+		Close:            true,
+		Trailer:          nil,
+		Request:          req,
+	}
+	return
+}
+
+type tenantIdCheckTransport struct {
+	expectTenantId bool
+	tenantIdFound  bool
+}
+
+func (t *tenantIdCheckTransport) RoundTrip(req *http.Request) (rsp *http.Response, err error) {
+	var authContainer *AuthContainer
+
+	headers := make(http.Header)
+	headers.Add("Content-Type", "application/xml; charset=UTF-8")
+
+	body := ioutil.NopCloser(strings.NewReader("t.response"))
+
+	rsp = &http.Response{
+		Status:           "200 OK",
+		StatusCode:       200,
+		Proto:            "HTTP/1.1",
+		ProtoMajor:       1,
+		ProtoMinor:       1,
+		Header:           headers,
+		Body:             body,
+		ContentLength:    -1,
+		TransferEncoding: nil,
+		Close:            true,
+		Trailer:          nil,
+		Request:          req,
+	}
+
+	bytes, err := ioutil.ReadAll(req.Body)
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal(bytes, &authContainer)
+	if err != nil {
+		return nil, err
+	}
+	t.tenantIdFound = (authContainer.Auth.TenantId != "")
+
+	if t.tenantIdFound != t.expectTenantId {
+		rsp.Status = "500 Internal Server Error"
+		rsp.StatusCode = 500
+	}
+	return
+}
+
+func TestAuthProvider(t *testing.T) {
+	c := TestContext()
+	tt := &testTransport{}
+	c.UseCustomClient(&http.Client{
+		Transport: tt,
+	})
+
+	_, err := c.Authenticate("", AuthOptions{})
+	if err == nil {
+		t.Error("Expected error for empty provider string")
+		return
+	}
+	_, err = c.Authenticate("unknown-provider", AuthOptions{Username: "u", Password: "p"})
+	if err == nil {
+		t.Error("Expected error for unknown service provider")
+		return
+	}
+
+	err = c.RegisterProvider("provider", Provider{AuthEndpoint: "/"})
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	_, err = c.Authenticate("provider", AuthOptions{Username: "u", Password: "p"})
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if tt.called != 1 {
+		t.Error("Expected transport to be called once.")
+		return
+	}
+}
+
+func TestTenantIdEncoding(t *testing.T) {
+	c := TestContext()
+	tt := &tenantIdCheckTransport{}
+	c.UseCustomClient(&http.Client{
+		Transport: tt,
+	})
+	c.RegisterProvider("provider", Provider{AuthEndpoint: "/"})
+
+	tt.expectTenantId = false
+	_, err := c.Authenticate("provider", AuthOptions{
+		Username: "u",
+		Password: "p",
+	})
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if tt.tenantIdFound {
+		t.Error("Tenant ID should not have been encoded")
+		return
+	}
+
+	tt.expectTenantId = true
+	_, err = c.Authenticate("provider", AuthOptions{
+		Username: "u",
+		Password: "p",
+		TenantId: "t",
+	})
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if !tt.tenantIdFound {
+		t.Error("Tenant ID should have been encoded")
+		return
+	}
+}
+
+func TestUserNameAndPassword(t *testing.T) {
+	c := TestContext()
+	c.UseCustomClient(&http.Client{Transport: &testTransport{}})
+	c.RegisterProvider("provider", Provider{AuthEndpoint: "http://localhost/"})
+
+	credentials := []AuthOptions{
+		AuthOptions{},
+		AuthOptions{Username: "u"},
+		AuthOptions{Password: "p"},
+	}
+	for i, auth := range credentials {
+		_, err := c.Authenticate("provider", auth)
+		if err == nil {
+			t.Error("Expected error from missing credentials (%d)", i)
+			return
+		}
+	}
+
+	_, err := c.Authenticate("provider", AuthOptions{Username: "u", Password: "p"})
+	if err != nil {
+		t.Error(err)
+		return
+	}
+}
+
+func TestTokenAcquisition(t *testing.T) {
+	c := TestContext()
+	tt := &testTransport{}
+	tt.response = SUCCESSFUL_RESPONSE
+	c.UseCustomClient(&http.Client{Transport: tt})
+	c.RegisterProvider("provider", Provider{AuthEndpoint: "http://localhost"})
+
+	acc, err := c.Authenticate("provider", AuthOptions{Username: "u", Password: "p"})
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	tok := acc.Token
+	if (tok.Id == "") || (tok.Expires == "") {
+		t.Error("Expected a valid token for successful login; got %s, %s", tok.Id, tok.Expires)
+		return
+	}
+}
+
+func TestServiceCatalogAcquisition(t *testing.T) {
+	c := TestContext()
+	tt := &testTransport{}
+	tt.response = SUCCESSFUL_RESPONSE
+	c.UseCustomClient(&http.Client{Transport: tt})
+	c.RegisterProvider("provider", Provider{AuthEndpoint: "http://localhost"})
+
+	acc, err := c.Authenticate("provider", AuthOptions{Username: "u", Password: "p"})
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	svcs := acc.ServiceCatalog
+	if len(svcs) < 2 {
+		t.Error("Expected 2 service catalog entries; got %d", len(svcs))
+		return
+	}
+
+	types := map[string]bool{
+		"compute":      true,
+		"rax:database": true,
+	}
+	for _, entry := range svcs {
+		if !types[entry.Type] {
+			t.Error("Expected to find type %s.", entry.Type)
+			return
+		}
+	}
+}
+
+func TestUserAcquisition(t *testing.T) {
+	c := TestContext()
+	tt := &testTransport{}
+	tt.response = SUCCESSFUL_RESPONSE
+	c.UseCustomClient(&http.Client{Transport: tt})
+	c.RegisterProvider("provider", Provider{AuthEndpoint: "http://localhost"})
+
+	acc, err := c.Authenticate("provider", AuthOptions{Username: "u", Password: "p"})
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	u := acc.User
+	if u.Id != "161418" {
+		t.Error("Expected user ID of 16148; got", u.Id)
+		return
+	}
+}
diff --git a/context.go b/context.go
new file mode 100644
index 0000000..70d70a7
--- /dev/null
+++ b/context.go
@@ -0,0 +1,37 @@
+package gophercloud
+
+import (
+	"net/http"
+)
+
+// Context structures encapsulate Gophercloud-global state in a manner which
+// facilitates easier unit testing.  As a user of this SDK, you'll never
+// have to use this structure, except when contributing new code to the SDK.
+type Context struct {
+	// providerMap serves as a directory of supported providers.
+	providerMap map[string]Provider
+
+	// httpClient refers to the current HTTP client interface to use.
+	httpClient *http.Client
+}
+
+// TestContext yields a new Context instance, pre-initialized with a barren
+// state suitable for per-unit-test customization.  This configuration consists
+// of:
+//
+// * An empty provider map.
+//
+// * An HTTP client built by the net/http package (see http://godoc.org/net/http#Client).
+func TestContext() *Context {
+	return &Context{
+		providerMap: make(map[string]Provider),
+		httpClient:  &http.Client{},
+	}
+}
+
+// UseCustomClient configures the context to use a customized HTTP client
+// instance.  By default, TestContext() will return a Context which uses
+// the net/http package's default client instance.  
+func (c *Context) UseCustomClient(hc *http.Client) {
+	c.httpClient = hc
+}
diff --git a/errors.go b/errors.go
new file mode 100644
index 0000000..58a898c
--- /dev/null
+++ b/errors.go
@@ -0,0 +1,27 @@
+package gophercloud
+
+import (
+	"fmt"
+)
+
+// ErrNotImplemented should be used only while developing new SDK features.
+// No established function or method will ever produce this error.
+var ErrNotImplemented = fmt.Errorf("Not implemented")
+
+// ErrProvider errors occur when attempting to reference an unsupported
+// provider.  More often than not, this error happens due to a typo in
+// the name.
+var ErrProvider = fmt.Errorf("Missing or incorrect provider")
+
+// ErrCredentials errors happen when attempting to authenticate using a
+// set of credentials not recognized by the Authenticate() method.
+// For example, not providing a username or password when attempting to
+// authenticate against an Identity V2 API.
+var ErrCredentials = fmt.Errorf("Missing or incomplete credentials")
+
+// ErrConfiguration errors happen when attempting to add a new provider, and
+// the provider added lacks a correct or consistent configuration.
+// For example, all providers must expose at least an Identity V2 API
+// for authentication; if this endpoint isn't specified, you may receive
+// this error when attempting to register it against a context.
+var ErrConfiguration = fmt.Errorf("Missing or incomplete configuration")
diff --git a/package.go b/package.go
new file mode 100644
index 0000000..396e523
--- /dev/null
+++ b/package.go
@@ -0,0 +1,7 @@
+// Gophercloud provides a multi-vendor interface to OpenStack-compatible clouds which attempts to follow
+// established Go community coding standards and social norms.
+//
+// Unless you intend on contributing code to the SDK, you will almost certainly never have to use any
+// Context structures or any of its methods.  Contextual methods exist for easier unit testing only.
+// Stick with the global functions unless you know exactly what you're doing, and why.
+package gophercloud
diff --git a/provider.go b/provider.go
new file mode 100644
index 0000000..c741c4c
--- /dev/null
+++ b/provider.go
@@ -0,0 +1,32 @@
+package gophercloud
+
+// Provider structures exist for each tangible provider of OpenStack service.
+// For example, Rackspace, Hewlett-Packard, and NASA might have their own instance of this structure.
+//
+// At a minimum, a provider must expose an authentication endpoint.
+type Provider struct {
+	AuthEndpoint string
+}
+
+// RegisterProvider allows a unit test to register a mythical provider convenient for testing.
+// If the provider structure lacks adequate configuration, or the configuration given has some
+// detectable error, an ErrConfiguration error will result.
+func (c *Context) RegisterProvider(name string, p Provider) error {
+	if p.AuthEndpoint == "" {
+		return ErrConfiguration
+	}
+
+	c.providerMap[name] = p
+	return nil
+}
+
+// ProviderByName will locate a provider amongst those previously registered, if it exists.
+// If the named provider has not been registered, an ErrProvider error will result.
+func (c *Context) ProviderByName(name string) (p Provider, err error) {
+	for provider, descriptor := range c.providerMap {
+		if name == provider {
+			return descriptor, nil
+		}
+	}
+	return Provider{}, ErrProvider
+}
diff --git a/provider_test.go b/provider_test.go
new file mode 100644
index 0000000..2936526
--- /dev/null
+++ b/provider_test.go
@@ -0,0 +1,28 @@
+package gophercloud
+
+import (
+	"testing"
+)
+
+func TestProviderRegistry(t *testing.T) {
+	c := TestContext()
+
+	_, err := c.ProviderByName("aProvider")
+	if err == nil {
+		t.Error("Expected error when looking for a provider by non-existant name")
+		return
+	}
+
+	err = c.RegisterProvider("aProvider", Provider{})
+	if err != ErrConfiguration {
+		t.Error("Unexpected error/nil when registering a provider w/out an auth endpoint\n  %s", err)
+		return
+	}
+
+	_ = c.RegisterProvider("aProvider", Provider{AuthEndpoint: "http://localhost/auth"})
+	_, err = c.ProviderByName("aProvider")
+	if err != nil {
+		t.Error(err)
+		return
+	}
+}
diff --git a/scripts/test-all.sh b/scripts/test-all.sh
new file mode 100755
index 0000000..b78e606
--- /dev/null
+++ b/scripts/test-all.sh
@@ -0,0 +1,35 @@
+#!/bin/bash
+#
+# This script is responsible for executing all the acceptance tests found in
+# the acceptance/ directory.
+
+# Find where _this_ script is running from.
+SCRIPTS=$(dirname $0)
+SCRIPTS=$(cd $SCRIPTS; pwd)
+
+# Locate the acceptance test / examples directory.
+ACCEPTANCE=$(cd $SCRIPTS/../acceptance; pwd)
+
+# Go workspace path
+WS=$(cd $SCRIPTS/..; pwd)
+
+# In order to run Go code interactively, we need the GOPATH environment
+# to be set.
+if [ "x$GOPATH" == "x" ]; then
+  export GOPATH=$WS
+  echo "WARNING: You didn't have your GOPATH environment variable set."
+  echo "         I'm assuming $GOPATH as its value."
+fi
+
+# Run all acceptance tests sequentially.
+# If any test fails, we fail fast.
+for T in $(ls -1 $ACCEPTANCE/[0-9][0-9]*.go); do
+  if ! [ -x $T ]; then
+    echo "go run $T -quiet ..."
+    if ! go run $T -quiet ; then
+      echo "- FAILED.  Try re-running w/out the -quiet option to see output."
+      exit 1
+    fi
+  fi
+done
+