Rename from reddwarf to trove.0.1.3

Implements Blueprint reddwarf-trove-rename

Change-Id: Ib2d694c7466887ca297bea4250eca17cdc06b7bf

37 files changed, 0 insertions, 6325 deletions

diff --git a/reddwarfclient/__init__.py b/reddwarfclient/__init__.py
deleted file mode 100644
index 0383828..0000000
--- a/reddwarfclient/__init__.py
+++ /dev/null
@@ -1,31 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-
-from reddwarfclient.accounts import Accounts
-from reddwarfclient.databases import Databases
-from reddwarfclient.flavors import Flavors
-from reddwarfclient.instances import Instances
-from reddwarfclient.hosts import Hosts
-from reddwarfclient.management import Management
-from reddwarfclient.management import RootHistory
-from reddwarfclient.root import Root
-from reddwarfclient.storage import StorageInfo
-from reddwarfclient.users import Users
-from reddwarfclient.versions import Versions
-from reddwarfclient.diagnostics import DiagnosticsInterrogator
-from reddwarfclient.diagnostics import HwInfoInterrogator
-from reddwarfclient.client import Dbaas
-from reddwarfclient.client import ReddwarfHTTPClient
diff --git a/reddwarfclient/accounts.py b/reddwarfclient/accounts.py
deleted file mode 100644
index 43e9135..0000000
--- a/reddwarfclient/accounts.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-from reddwarfclient.common import check_for_exceptions
-
-
-class Account(base.Resource):
-    """
-    Account is an opaque instance used to hold account information.
-    """
-    def __repr__(self):
-        return "<Account: %s>" % self.name
-
-
-class Accounts(base.ManagerWithFind):
-    """
-    Manage :class:`Account` information.
-    """
-
-    resource_class = Account
-
-    def _list(self, url, response_key):
-        resp, body = self.api.client.get(url)
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-        return self.resource_class(self, body[response_key])
-
-    def index(self):
-        """Get a list of all accounts with non-deleted instances"""
-
-        url = "/mgmt/accounts"
-        resp, body = self.api.client.get(url)
-        check_for_exceptions(resp, body)
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-        return base.Resource(self, body)
-
-    def show(self, account):
-        """
-        Get details of one account.
-
-        :rtype: :class:`Account`.
-        """
-
-        acct_name = self._get_account_name(account)
-        return self._list("/mgmt/accounts/%s" % acct_name, 'account')
-
-    @staticmethod
-    def _get_account_name(account):
-        try:
-            if account.name:
-                return account.name
-        except AttributeError:
-            return account
diff --git a/reddwarfclient/auth.py b/reddwarfclient/auth.py
deleted file mode 100644
index 4494447..0000000
--- a/reddwarfclient/auth.py
+++ /dev/null
@@ -1,269 +0,0 @@
-#    Copyright 2012 OpenStack LLC
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import exceptions
-
-
-def get_authenticator_cls(cls_or_name):
-    """Factory method to retrieve Authenticator class."""
-    if isinstance(cls_or_name, type):
-        return cls_or_name
-    elif isinstance(cls_or_name, basestring):
-        if cls_or_name == "keystone":
-            return KeyStoneV2Authenticator
-        elif cls_or_name == "rax":
-            return RaxAuthenticator
-        elif cls_or_name == "auth1.1":
-            return Auth1_1
-        elif cls_or_name == "fake":
-            return FakeAuth
-
-    raise ValueError("Could not determine authenticator class from the given "
-                     "value %r." % cls_or_name)
-
-
-class Authenticator(object):
-    """
-    Helper class to perform Keystone or other miscellaneous authentication.
-
-    The "authenticate" method returns a ServiceCatalog, which can be used
-    to obtain a token.
-
-    """
-
-    URL_REQUIRED = True
-
-    def __init__(self, client, type, url, username, password, tenant,
-                 region=None, service_type=None, service_name=None,
-                 service_url=None):
-        self.client = client
-        self.type = type
-        self.url = url
-        self.username = username
-        self.password = password
-        self.tenant = tenant
-        self.region = region
-        self.service_type = service_type
-        self.service_name = service_name
-        self.service_url = service_url
-
-    def _authenticate(self, url, body, root_key='access'):
-        """Authenticate and extract the service catalog."""
-        # Make sure we follow redirects when trying to reach Keystone
-        tmp_follow_all_redirects = self.client.follow_all_redirects
-        self.client.follow_all_redirects = True
-
-        try:
-            resp, body = self.client._time_request(url, "POST", body=body)
-        finally:
-            self.client.follow_all_redirects = tmp_follow_all_redirects
-
-        if resp.status == 200:  # content must always present
-            try:
-                return ServiceCatalog(body, region=self.region,
-                                      service_type=self.service_type,
-                                      service_name=self.service_name,
-                                      service_url=self.service_url,
-                                      root_key=root_key)
-            except exceptions.AmbiguousEndpoints:
-                print "Found more than one valid endpoint. Use a more "\
-                      "restrictive filter"
-                raise
-            except KeyError:
-                raise exceptions.AuthorizationFailure()
-            except exceptions.EndpointNotFound:
-                print "Could not find any suitable endpoint. Correct region?"
-                raise
-
-        elif resp.status == 305:
-            return resp['location']
-        else:
-            raise exceptions.from_response(resp, body)
-
-    def authenticate(self):
-        raise NotImplementedError("Missing authenticate method.")
-
-
-class KeyStoneV2Authenticator(Authenticator):
-
-    def authenticate(self):
-        if self.url is None:
-            raise exceptions.AuthUrlNotGiven()
-        return self._v2_auth(self.url)
-
-    def _v2_auth(self, url):
-        """Authenticate against a v2.0 auth service."""
-        body = {"auth": {
-                    "passwordCredentials": {
-                            "username": self.username,
-                            "password": self.password}
-                    }
-               }
-
-        if self.tenant:
-            body['auth']['tenantName'] = self.tenant
-
-        return self._authenticate(url, body)
-
-
-class Auth1_1(Authenticator):
-
-    def authenticate(self):
-        """Authenticate against a v2.0 auth service."""
-        if self.url is None:
-            raise exceptions.AuthUrlNotGiven()
-        auth_url = self.url
-        body = {"credentials": {"username": self.username,
-                                "key": self.password}}
-        return self._authenticate(auth_url, body, root_key='auth')
-
-        try:
-            print(resp_body)
-            self.auth_token = resp_body['auth']['token']['id']
-        except KeyError:
-            raise nova_exceptions.AuthorizationFailure()
-
-        catalog = resp_body['auth']['serviceCatalog']
-        if 'cloudDatabases' not in catalog:
-            raise nova_exceptions.EndpointNotFound()
-        endpoints = catalog['cloudDatabases']
-        for endpoint in endpoints:
-            if self.region_name is None or \
-                endpoint['region'] == self.region_name:
-                self.management_url = endpoint['publicURL']
-                return
-        raise nova_exceptions.EndpointNotFound()
-
-
-class RaxAuthenticator(Authenticator):
-
-    def authenticate(self):
-        if self.url is None:
-            raise exceptions.AuthUrlNotGiven()
-        return self._rax_auth(self.url)
-
-    def _rax_auth(self, url):
-        """Authenticate against the Rackspace auth service."""
-        body = {'auth': {
-                    'RAX-KSKEY:apiKeyCredentials': {
-                            'username': self.username,
-                            'apiKey': self.password,
-                            'tenantName': self.tenant}
-                    }
-               }
-
-        return self._authenticate(self.url, body)
-
-
-class FakeAuth(Authenticator):
-    """Useful for faking auth."""
-
-    def authenticate(self):
-        class FakeCatalog(object):
-            def __init__(self, auth):
-                self.auth = auth
-
-            def get_public_url(self):
-                return "%s/%s" % ('http://localhost:8779/v1.0',
-                                  self.auth.tenant)
-
-            def get_token(self):
-                return self.auth.tenant
-
-        return FakeCatalog(self)
-
-
-class ServiceCatalog(object):
-    """Represents a Keystone Service Catalog which describes a service.
-
-    This class has methods to obtain a valid token as well as a public service
-    url and a management url.
-
-    """
-
-    def __init__(self, resource_dict, region=None, service_type=None,
-                 service_name=None, service_url=None, root_key='access'):
-        self.catalog = resource_dict
-        self.region = region
-        self.service_type = service_type
-        self.service_name = service_name
-        self.service_url = service_url
-        self.management_url = None
-        self.public_url = None
-        self.root_key = root_key
-        self._load()
-
-    def _load(self):
-        if not self.service_url:
-            self.public_url = self._url_for(attr='region',
-                                            filter_value=self.region,
-                                            endpoint_type="publicURL")
-            self.management_url = self._url_for(attr='region',
-                                                filter_value=self.region,
-                                                endpoint_type="adminURL")
-        else:
-            self.public_url = self.service_url
-            self.management_url = self.service_url
-
-    def get_token(self):
-        return self.catalog[self.root_key]['token']['id']
-
-    def get_management_url(self):
-        return self.management_url
-
-    def get_public_url(self):
-        return self.public_url
-
-    def _url_for(self, attr=None, filter_value=None,
-                 endpoint_type='publicURL'):
-        """
-        Fetch the public URL from the Reddwarf service for a particular
-        endpoint attribute. If none given, return the first.
-        """
-        matching_endpoints = []
-        if 'endpoints' in self.catalog:
-            # We have a bastardized service catalog. Treat it special. :/
-            for endpoint in self.catalog['endpoints']:
-                if not filter_value or endpoint[attr] == filter_value:
-                    matching_endpoints.append(endpoint)
-            if not matching_endpoints:
-                raise exceptions.EndpointNotFound()
-
-        # We don't always get a service catalog back ...
-        if not 'serviceCatalog' in self.catalog[self.root_key]:
-            raise exceptions.EndpointNotFound()
-
-        # Full catalog ...
-        catalog = self.catalog[self.root_key]['serviceCatalog']
-
-        for service in catalog:
-            if service.get("type") != self.service_type:
-                continue
-
-            if (self.service_name and self.service_type == 'database' and
-                service.get('name') != self.service_name):
-                continue
-
-            endpoints = service['endpoints']
-            for endpoint in endpoints:
-                if not filter_value or endpoint.get(attr) == filter_value:
-                    endpoint["serviceName"] = service.get("name")
-                    matching_endpoints.append(endpoint)
-
-        if not matching_endpoints:
-            raise exceptions.EndpointNotFound()
-        elif len(matching_endpoints) > 1:
-            raise exceptions.AmbiguousEndpoints(endpoints=matching_endpoints)
-        else:
-            return matching_endpoints[0].get(endpoint_type, None)
diff --git a/reddwarfclient/backups.py b/reddwarfclient/backups.py
deleted file mode 100644
index c78b840..0000000
--- a/reddwarfclient/backups.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-import exceptions
-
-
-class Backup(base.Resource):
-    """
-    Backup is a resource used to hold backup information.
-    """
-    def __repr__(self):
-        return "<Backup: %s>" % self.name
-
-
-class Backups(base.ManagerWithFind):
-    """
-    Manage :class:`Backups` information.
-    """
-
-    resource_class = Backup
-
-    def get(self, backup):
-        """
-        Get a specific backup.
-
-        :rtype: :class:`Backups`
-        """
-        return self._get("/backups/%s" % base.getid(backup),
-                         "backup")
-
-    def list(self, limit=None, marker=None):
-        """
-        Get a list of all backups.
-
-        :rtype: list of :class:`Backups`.
-        """
-        return self._list("/backups", "backups", limit, marker)
-
-    def create(self, name, instance, description=None):
-        """
-        Create a new backup from the given instance.
-        """
-        body = {"backup": {
-            "name": name,
-            "instance": instance,
-            "description": description,
-        }}
-        return self._create("/backups", body, "backup")
-
-    def delete(self, backup_id):
-        """
-        Delete the specified backup.
-
-        :param backup_id: The backup id to delete
-        """
-        resp, body = self.api.client.delete("/backups/%s" % backup_id)
-        if resp.status in (422, 500):
-            raise exceptions.from_response(resp, body)
diff --git a/reddwarfclient/base.py b/reddwarfclient/base.py
deleted file mode 100644
index 6660ff4..0000000
--- a/reddwarfclient/base.py
+++ /dev/null
@@ -1,293 +0,0 @@
-# Copyright 2010 Jacob Kaplan-Moss
-
-# Copyright 2012 OpenStack LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-Base utilities to build API operation managers and objects on top of.
-"""
-
-import contextlib
-import hashlib
-import os
-from reddwarfclient import exceptions
-from reddwarfclient import utils
-
-
-# Python 2.4 compat
-try:
-    all
-except NameError:
-    def all(iterable):
-        return True not in (not x for x in iterable)
-
-
-def getid(obj):
-    """
-    Abstracts the common pattern of allowing both an object or an object's ID
-    as a parameter when dealing with relationships.
-    """
-    try:
-        return obj.id
-    except AttributeError:
-        return obj
-
-
-class Manager(utils.HookableMixin):
-    """
-    Managers interact with a particular type of API (servers, flavors, images,
-    etc.) and provide CRUD operations for them.
-    """
-    resource_class = None
-
-    def __init__(self, api):
-        self.api = api
-
-    def _list(self, url, response_key, obj_class=None, body=None):
-        resp = None
-        if body:
-            resp, body = self.api.client.post(url, body=body)
-        else:
-            resp, body = self.api.client.get(url)
-
-        if obj_class is None:
-            obj_class = self.resource_class
-
-        data = body[response_key]
-        # NOTE(ja): keystone returns values as list as {'values': [ ... ]}
-        #           unlike other services which just return the list...
-        if isinstance(data, dict):
-            try:
-                data = data['values']
-            except KeyError:
-                pass
-
-        with self.completion_cache('human_id', obj_class, mode="w"):
-            with self.completion_cache('uuid', obj_class, mode="w"):
-                return [obj_class(self, res, loaded=True)
-                        for res in data if res]
-
-    @contextlib.contextmanager
-    def completion_cache(self, cache_type, obj_class, mode):
-        """
-        The completion cache store items that can be used for bash
-        autocompletion, like UUIDs or human-friendly IDs.
-
-        A resource listing will clear and repopulate the cache.
-
-        A resource create will append to the cache.
-
-        Delete is not handled because listings are assumed to be performed
-        often enough to keep the cache reasonably up-to-date.
-        """
-        base_dir = utils.env('REDDWARFCLIENT_ID_CACHE_DIR',
-                             default="~/.reddwarfclient")
-
-        # NOTE(sirp): Keep separate UUID caches for each username + endpoint
-        # pair
-        username = utils.env('OS_USERNAME', 'USERNAME')
-        url = utils.env('OS_URL', 'SERVICE_URL')
-        uniqifier = hashlib.md5(username + url).hexdigest()
-
-        cache_dir = os.path.expanduser(os.path.join(base_dir, uniqifier))
-
-        try:
-            os.makedirs(cache_dir, 0755)
-        except OSError:
-            # NOTE(kiall): This is typicaly either permission denied while
-            #              attempting to create the directory, or the directory
-            #              already exists. Either way, don't fail.
-            pass
-
-        resource = obj_class.__name__.lower()
-        filename = "%s-%s-cache" % (resource, cache_type.replace('_', '-'))
-        path = os.path.join(cache_dir, filename)
-
-        cache_attr = "_%s_cache" % cache_type
-
-        try:
-            setattr(self, cache_attr, open(path, mode))
-        except IOError:
-            # NOTE(kiall): This is typicaly a permission denied while
-            #              attempting to write the cache file.
-            pass
-
-        try:
-            yield
-        finally:
-            cache = getattr(self, cache_attr, None)
-            if cache:
-                cache.close()
-                delattr(self, cache_attr)
-
-    def write_to_completion_cache(self, cache_type, val):
-        cache = getattr(self, "_%s_cache" % cache_type, None)
-        if cache:
-            cache.write("%s\n" % val)
-
-    def _get(self, url, response_key=None):
-        resp, body = self.api.client.get(url)
-        if response_key:
-            return self.resource_class(self, body[response_key], loaded=True)
-        else:
-            return self.resource_class(self, body, loaded=True)
-
-    def _create(self, url, body, response_key, return_raw=False, **kwargs):
-        self.run_hooks('modify_body_for_create', body, **kwargs)
-        resp, body = self.api.client.post(url, body=body)
-        if return_raw:
-            return body[response_key]
-
-        with self.completion_cache('human_id', self.resource_class, mode="a"):
-            with self.completion_cache('uuid', self.resource_class, mode="a"):
-                return self.resource_class(self, body[response_key])
-
-    def _delete(self, url):
-        resp, body = self.api.client.delete(url)
-
-    def _update(self, url, body, **kwargs):
-        self.run_hooks('modify_body_for_update', body, **kwargs)
-        resp, body = self.api.client.put(url, body=body)
-        return body
-
-
-class ManagerWithFind(Manager):
-    """
-    Like a `Manager`, but with additional `find()`/`findall()` methods.
-    """
-    def find(self, **kwargs):
-        """
-        Find a single item with attributes matching ``**kwargs``.
-
-        This isn't very efficient: it loads the entire list then filters on
-        the Python side.
-        """
-        matches = self.findall(**kwargs)
-        num_matches = len(matches)
-        if num_matches == 0:
-            msg = "No %s matching %s." % (self.resource_class.__name__, kwargs)
-            raise exceptions.NotFound(404, msg)
-        elif num_matches > 1:
-            raise exceptions.NoUniqueMatch
-        else:
-            return matches[0]
-
-    def findall(self, **kwargs):
-        """
-        Find all items with attributes matching ``**kwargs``.
-
-        This isn't very efficient: it loads the entire list then filters on
-        the Python side.
-        """
-        found = []
-        searches = kwargs.items()
-
-        for obj in self.list():
-            try:
-                if all(getattr(obj, attr) == value
-                    for (attr, value) in searches):
-                    found.append(obj)
-            except AttributeError:
-                continue
-
-        return found
-
-    def list(self):
-        raise NotImplementedError
-
-
-class Resource(object):
-    """
-    A resource represents a particular instance of an object (server, flavor,
-    etc). This is pretty much just a bag for attributes.
-
-    :param manager: Manager object
-    :param info: dictionary representing resource attributes
-    :param loaded: prevent lazy-loading if set to True
-    """
-    HUMAN_ID = False
-
-    def __init__(self, manager, info, loaded=False):
-        self.manager = manager
-        self._info = info
-        self._add_details(info)
-        self._loaded = loaded
-
-        # NOTE(sirp): ensure `id` is already present because if it isn't we'll
-        # enter an infinite loop of __getattr__ -> get -> __init__ ->
-        # __getattr__ -> ...
-        if 'id' in self.__dict__ and len(str(self.id)) == 36:
-            self.manager.write_to_completion_cache('uuid', self.id)
-
-        human_id = self.human_id
-        if human_id:
-            self.manager.write_to_completion_cache('human_id', human_id)
-
-    @property
-    def human_id(self):
-        """Subclasses may override this provide a pretty ID which can be used
-        for bash completion.
-        """
-        if 'name' in self.__dict__ and self.HUMAN_ID:
-            return utils.slugify(self.name)
-        return None
-
-    def _add_details(self, info):
-        for (k, v) in info.iteritems():
-            try:
-                setattr(self, k, v)
-            except AttributeError:
-                # In this case we already defined the attribute on the class
-                pass
-
-    def __getattr__(self, k):
-        if k not in self.__dict__:
-            #NOTE(bcwaldon): disallow lazy-loading if already loaded once
-            if not self.is_loaded():
-                self.get()
-                return self.__getattr__(k)
-
-            raise AttributeError(k)
-        else:
-            return self.__dict__[k]
-
-    def __repr__(self):
-        reprkeys = sorted(k for k in self.__dict__.keys() if k[0] != '_' and
-                                                             k != 'manager')
-        info = ", ".join("%s=%s" % (k, getattr(self, k)) for k in reprkeys)
-        return "<%s %s>" % (self.__class__.__name__, info)
-
-    def get(self):
-        # set_loaded() first ... so if we have to bail, we know we tried.
-        self.set_loaded(True)
-        if not hasattr(self.manager, 'get'):
-            return
-
-        new = self.manager.get(self.id)
-        if new:
-            self._add_details(new._info)
-
-    def __eq__(self, other):
-        if not isinstance(other, self.__class__):
-            return False
-        if hasattr(self, 'id') and hasattr(other, 'id'):
-            return self.id == other.id
-        return self._info == other._info
-
-    def is_loaded(self):
-        return self._loaded
-
-    def set_loaded(self, val):
-        self._loaded = val
diff --git a/reddwarfclient/cli.py b/reddwarfclient/cli.py
deleted file mode 100644
index f83de6d..0000000
--- a/reddwarfclient/cli.py
+++ /dev/null
@@ -1,385 +0,0 @@
-#!/usr/bin/env python
-
-#    Copyright 2011 OpenStack LLC
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-Reddwarf Command line tool
-"""
-
-#TODO(tim.simpson): optparse is deprecated. Replace with argparse.
-import optparse
-import os
-import sys
-
-
-# If ../reddwarf/__init__.py exists, add ../ to Python search path, so that
-# it will override what happens to be installed in /usr/(local/)lib/python...
-possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
-                                   os.pardir,
-                                   os.pardir))
-if os.path.exists(os.path.join(possible_topdir, 'reddwarfclient',
-                               '__init__.py')):
-    sys.path.insert(0, possible_topdir)
-
-
-from reddwarfclient import common
-
-
-class InstanceCommands(common.AuthedCommandsBase):
-    """Commands to perform various instances operations and actions"""
-
-    params = [
-              'flavor',
-              'id',
-              'limit',
-              'marker',
-              'name',
-              'size',
-              'backup'
-    ]
-
-    def create(self):
-        """Create a new instance"""
-        self._require('name', 'flavor')
-        volume = None
-        if self.size is not None:
-            volume = {"size": self.size}
-        restorePoint = None
-        if self.backup is not None:
-            restorePoint = {"backupRef": self.backup}
-        self._pretty_print(self.dbaas.instances.create, self.name,
-                           self.flavor, volume, restorePoint=restorePoint)
-
-    def delete(self):
-        """Delete the specified instance"""
-        self._require('id')
-        print self.dbaas.instances.delete(self.id)
-
-    def get(self):
-        """Get details for the specified instance"""
-        self._require('id')
-        self._pretty_print(self.dbaas.instances.get, self.id)
-
-    def backups(self):
-        """Get a list of backups for the specified instance"""
-        self._require('id')
-        self._pretty_list(self.dbaas.instances.backups, self.id)
-
-    def list(self):
-        """List all instances for account"""
-        # limit and marker are not required.
-        limit = self.limit or None
-        if limit:
-            limit = int(limit, 10)
-        self._pretty_paged(self.dbaas.instances.list)
-
-    def resize_volume(self):
-        """Resize an instance volume"""
-        self._require('id', 'size')
-        self._pretty_print(self.dbaas.instances.resize_volume, self.id,
-                          self.size)
-
-    def resize_instance(self):
-        """Resize an instance flavor"""
-        self._require('id', 'flavor')
-        self._pretty_print(self.dbaas.instances.resize_instance, self.id,
-                          self.flavor)
-
-    def restart(self):
-        """Restart the database"""
-        self._require('id')
-        self._pretty_print(self.dbaas.instances.restart, self.id)
-
-    def reset_password(self):
-        """Reset the root user Password"""
-        self._require('id')
-        self._pretty_print(self.dbaas.instances.reset_password, self.id)
-
-
-class FlavorsCommands(common.AuthedCommandsBase):
-    """Commands for listing Flavors"""
-
-    params = []
-
-    def list(self):
-        """List the available flavors"""
-        self._pretty_list(self.dbaas.flavors.list)
-
-
-class DatabaseCommands(common.AuthedCommandsBase):
-    """Database CRUD operations on an instance"""
-
-    params = [
-              'name',
-              'id',
-              'limit',
-              'marker',
-             ]
-
-    def create(self):
-        """Create a database"""
-        self._require('id', 'name')
-        databases = [{'name': self.name}]
-        print self.dbaas.databases.create(self.id, databases)
-
-    def delete(self):
-        """Delete a database"""
-        self._require('id', 'name')
-        print self.dbaas.databases.delete(self.id, self.name)
-
-    def list(self):
-        """List the databases"""
-        self._require('id')
-        self._pretty_paged(self.dbaas.databases.list, self.id)
-
-
-class UserCommands(common.AuthedCommandsBase):
-    """User CRUD operations on an instance"""
-    params = [
-              'id',
-              'database',
-              'databases',
-              'hostname',
-              'name',
-              'password',
-             ]
-
-    def create(self):
-        """Create a user in instance, with access to one or more databases"""
-        self._require('id', 'name', 'password', 'databases')
-        self._make_list('databases')
-        databases = [{'name': dbname} for dbname in self.databases]
-        users = [{'name': self.name, 'host': self.hostname,
-                  'password': self.password, 'databases': databases}]
-        self.dbaas.users.create(self.id, users)
-
-    def delete(self):
-        """Delete the specified user"""
-        self._require('id', 'name')
-        self.dbaas.users.delete(self.id, self.name, self.hostname)
-
-    def get(self):
-        """Get a single user."""
-        self._require('id', 'name')
-        self._pretty_print(self.dbaas.users.get, self.id,
-                           self.name, self.hostname)
-
-    def list(self):
-        """List all the users for an instance"""
-        self._require('id')
-        self._pretty_paged(self.dbaas.users.list, self.id)
-
-    def access(self):
-        """Show all databases the user has access to."""
-        self._require('id', 'name')
-        self._pretty_list(self.dbaas.users.list_access, self.id,
-                          self.name, self.hostname)
-
-    def grant(self):
-        """Allow an existing user permissions to access one or more
-        databases."""
-        self._require('id', 'name', 'databases')
-        self._make_list('databases')
-        self.dbaas.users.grant(self.id, self.name, self.databases,
-                               self.hostname)
-
-    def revoke(self):
-        """Revoke from an existing user access permissions to a database."""
-        self._require('id', 'name', 'database')
-        self.dbaas.users.revoke(self.id, self.name, self.database,
-                                self.hostname)
-
-    def change_password(self):
-        """Change the password of a single user."""
-        self._require('id', 'name', 'password')
-        users = [{'name': self.name,
-                  'host': self.hostname,
-                  'password': self.password}]
-        self.dbaas.users.change_passwords(self.id, users)
-
-
-class RootCommands(common.AuthedCommandsBase):
-    """Root user related operations on an instance"""
-
-    params = [
-              'id',
-             ]
-
-    def create(self):
-        """Enable the instance's root user."""
-        self._require('id')
-        try:
-            user, password = self.dbaas.root.create(self.id)
-            print "User:\t\t%s\nPassword:\t%s" % (user, password)
-        except:
-            print sys.exc_info()[1]
-
-    def enabled(self):
-        """Check the instance for root access"""
-        self._require('id')
-        self._pretty_print(self.dbaas.root.is_root_enabled, self.id)
-
-
-class VersionCommands(common.AuthedCommandsBase):
-    """List available versions"""
-
-    params = [
-              'url',
-             ]
-
-    def list(self):
-        """List all the supported versions"""
-        self._require('url')
-        self._pretty_list(self.dbaas.versions.index, self.url)
-
-
-class LimitsCommands(common.AuthedCommandsBase):
-    """Show the rate limits and absolute limits"""
-
-    def list(self):
-        """List the rate limits and absolute limits"""
-        self._pretty_list(self.dbaas.limits.list)
-
-
-class BackupsCommands(common.AuthedCommandsBase):
-    """Command to manage and show backups"""
-    params = ['name', 'instance', 'description']
-
-    def get(self):
-        """Get details for the specified backup"""
-        self._require('id')
-        self._pretty_print(self.dbaas.backups.get, self.id)
-
-    def list(self):
-        """List backups"""
-        self._pretty_list(self.dbaas.backups.list)
-
-    def create(self):
-        """Create a new backup"""
-        self._require('name', 'instance')
-        self._pretty_print(self.dbaas.backups.create, self.name,
-                           self.instance, self.description)
-
-    def delete(self):
-        """Delete a backup"""
-        self._require('id')
-        self._pretty_print(self.dbaas.backups.delete, self.id)
-
-
-class SecurityGroupCommands(common.AuthedCommandsBase):
-    """Commands to list and show Security Groups For an Instance and """
-    """create and delete security group rules for them. """
-    params = ['id',
-              'secgroup_id',
-              'protocol',
-              'from_port',
-              'to_port',
-              'cidr'
-              ]
-
-    def get(self):
-        """Get a security group associated with an instance."""
-        self._require('id')
-        self._pretty_print(self.dbaas.security_groups.get, self.id)
-
-    def list(self):
-        """List all the Security Groups and the rules"""
-        self._pretty_paged(self.dbaas.security_groups.list)
-
-    def add_rule(self):
-        """Add a security group rule"""
-        self._require('secgroup_id', 'protocol',
-                      'from_port', 'to_port', 'cidr')
-        self.dbaas.security_group_rules.create(self.secgroup_id, self.protocol,
-                                               self.from_port, self.to_port,
-                                               self.cidr)
-
-    def delete_rule(self):
-        """Delete a security group rule"""
-        self._require('id')
-        self.dbaas.security_group_rules.delete(self.id)
-
-
-COMMANDS = {'auth': common.Auth,
-            'instance': InstanceCommands,
-            'flavor': FlavorsCommands,
-            'database': DatabaseCommands,
-            'limit': LimitsCommands,
-            'backup': BackupsCommands,
-            'user': UserCommands,
-            'root': RootCommands,
-            'version': VersionCommands,
-            'secgroup': SecurityGroupCommands,
-            }
-
-
-def main():
-    # Parse arguments
-    load_file = True
-    for index, arg in enumerate(sys.argv):
-        if (arg == "auth" and len(sys.argv) > (index + 1)
-            and sys.argv[index + 1] == "login"):
-            load_file = False
-
-    oparser = common.CliOptions.create_optparser(load_file)
-    for k, v in COMMANDS.items():
-        v._prepare_parser(oparser)
-    (options, args) = oparser.parse_args()
-
-    if not args:
-        common.print_commands(COMMANDS)
-
-    if options.verbose:
-        os.environ['RDC_PP'] = "True"
-        os.environ['REDDWARFCLIENT_DEBUG'] = "True"
-
-    # Pop the command and check if it's in the known commands
-    cmd = args.pop(0)
-    if cmd in COMMANDS:
-        fn = COMMANDS.get(cmd)
-        command_object = None
-        try:
-            command_object = fn(oparser)
-        except Exception as ex:
-            if options.debug:
-                raise
-            print(ex)
-
-        # Get a list of supported actions for the command
-        actions = common.methods_of(command_object)
-
-        if len(args) < 1:
-            common.print_actions(cmd, actions)
-
-        # Check for a valid action and perform that action
-        action = args.pop(0)
-        if action in actions:
-            if not options.debug:
-                try:
-                    getattr(command_object, action)()
-                except Exception as ex:
-                    if options.debug:
-                        raise
-                    print ex
-            else:
-                getattr(command_object, action)()
-        else:
-            common.print_actions(cmd, actions)
-    else:
-        common.print_commands(COMMANDS)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/reddwarfclient/client.py b/reddwarfclient/client.py
deleted file mode 100644
index f602afb..0000000
--- a/reddwarfclient/client.py
+++ /dev/null
@@ -1,370 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import httplib2
-import logging
-import os
-import time
-import urlparse
-import sys
-
-try:
-    import json
-except ImportError:
-    import simplejson as json
-
-# Python 2.5 compat fix
-if not hasattr(urlparse, 'parse_qsl'):
-    import cgi
-    urlparse.parse_qsl = cgi.parse_qsl
-
-from reddwarfclient import auth
-from reddwarfclient import exceptions
-
-
-_logger = logging.getLogger(__name__)
-RDC_PP = os.environ.get("RDC_PP", "False") == "True"
-
-
-expected_errors = (400, 401, 403, 404, 408, 409, 413, 422, 500, 501)
-
-
-def log_to_streamhandler(stream=None):
-    stream = stream or sys.stderr
-    ch = logging.StreamHandler(stream)
-    _logger.setLevel(logging.DEBUG)
-    _logger.addHandler(ch)
-
-
-if 'REDDWARFCLIENT_DEBUG' in os.environ and os.environ['REDDWARFCLIENT_DEBUG']:
-    log_to_streamhandler()
-
-
-class ReddwarfHTTPClient(httplib2.Http):
-
-    USER_AGENT = 'python-reddwarfclient'
-
-    def __init__(self, user, password, tenant, auth_url, service_name,
-                 service_url=None,
-                 auth_strategy=None, insecure=False,
-                 timeout=None, proxy_tenant_id=None,
-                 proxy_token=None, region_name=None,
-                 endpoint_type='publicURL', service_type=None,
-                 timings=False):
-
-        super(ReddwarfHTTPClient, self).__init__(timeout=timeout)
-
-        self.username = user
-        self.password = password
-        self.tenant = tenant
-        if auth_url:
-            self.auth_url = auth_url.rstrip('/')
-        else:
-            self.auth_url = None
-        self.region_name = region_name
-        self.endpoint_type = endpoint_type
-        self.service_url = service_url
-        self.service_type = service_type
-        self.service_name = service_name
-        self.timings = timings
-
-        self.times = []  # [("item", starttime, endtime), ...]
-
-        self.auth_token = None
-        self.proxy_token = proxy_token
-        self.proxy_tenant_id = proxy_tenant_id
-
-        # httplib2 overrides
-        self.force_exception_to_status_code = True
-        self.disable_ssl_certificate_validation = insecure
-
-        auth_cls = auth.get_authenticator_cls(auth_strategy)
-
-        self.authenticator = auth_cls(self, auth_strategy,
-                                      self.auth_url, self.username,
-                                      self.password, self.tenant,
-                                      region=region_name,
-                                      service_type=service_type,
-                                      service_name=service_name,
-                                      service_url=service_url)
-
-    def get_timings(self):
-        return self.times
-
-    def http_log(self, args, kwargs, resp, body):
-        if not RDC_PP:
-            self.simple_log(args, kwargs, resp, body)
-        else:
-            self.pretty_log(args, kwargs, resp, body)
-
-    def simple_log(self, args, kwargs, resp, body):
-        if not _logger.isEnabledFor(logging.DEBUG):
-            return
-
-        string_parts = ['curl -i']
-        for element in args:
-            if element in ('GET', 'POST'):
-                string_parts.append(' -X %s' % element)
-            else:
-                string_parts.append(' %s' % element)
-
-        for element in kwargs['headers']:
-            header = ' -H "%s: %s"' % (element, kwargs['headers'][element])
-            string_parts.append(header)
-
-        _logger.debug("REQ: %s\n" % "".join(string_parts))
-        if 'body' in kwargs:
-            _logger.debug("REQ BODY: %s\n" % (kwargs['body']))
-        _logger.debug("RESP:%s %s\n", resp, body)
-
-    def pretty_log(self, args, kwargs, resp, body):
-        from reddwarfclient import common
-        if not _logger.isEnabledFor(logging.DEBUG):
-            return
-
-        string_parts = ['curl -i']
-        for element in args:
-            if element in ('GET', 'POST'):
-                string_parts.append(' -X %s' % element)
-            else:
-                string_parts.append(' %s' % element)
-
-        for element in kwargs['headers']:
-            header = ' -H "%s: %s"' % (element, kwargs['headers'][element])
-            string_parts.append(header)
-
-        curl_cmd = "".join(string_parts)
-        _logger.debug("REQUEST:")
-        if 'body' in kwargs:
-            _logger.debug("%s -d '%s'" % (curl_cmd, kwargs['body']))
-            try:
-                req_body = json.dumps(json.loads(kwargs['body']),
-                                      sort_keys=True, indent=4)
-            except:
-                req_body = kwargs['body']
-            _logger.debug("BODY: %s\n" % (req_body))
-        else:
-            _logger.debug(curl_cmd)
-
-        try:
-            resp_body = json.dumps(json.loads(body), sort_keys=True, indent=4)
-        except:
-            resp_body = body
-        _logger.debug("RESPONSE HEADERS: %s" % resp)
-        _logger.debug("RESPONSE BODY   : %s" % resp_body)
-
-    def request(self, *args, **kwargs):
-        kwargs.setdefault('headers', kwargs.get('headers', {}))
-        kwargs['headers']['User-Agent'] = self.USER_AGENT
-        self.morph_request(kwargs)
-
-        resp, body = super(ReddwarfHTTPClient, self).request(*args, **kwargs)
-
-        # Save this in case anyone wants it.
-        self.last_response = (resp, body)
-        self.http_log(args, kwargs, resp, body)
-
-        if body:
-            try:
-                body = self.morph_response_body(body)
-            except exceptions.ResponseFormatError:
-                # Acceptable only if the response status is an error code.
-                # Otherwise its the API or client misbehaving.
-                self.raise_error_from_status(resp, None)
-                raise  # Not accepted!
-        else:
-            body = None
-
-        if resp.status in expected_errors:
-            raise exceptions.from_response(resp, body)
-
-        return resp, body
-
-    def raise_error_from_status(self, resp, body):
-        if resp.status in expected_errors:
-            raise exceptions.from_response(resp, body)
-
-    def morph_request(self, kwargs):
-        kwargs['headers']['Accept'] = 'application/json'
-        kwargs['headers']['Content-Type'] = 'application/json'
-        if 'body' in kwargs:
-            kwargs['body'] = json.dumps(kwargs['body'])
-
-    def morph_response_body(self, body_string):
-        try:
-            return json.loads(body_string)
-        except ValueError:
-            raise exceptions.ResponseFormatError()
-
-    def _time_request(self, url, method, **kwargs):
-        start_time = time.time()
-        resp, body = self.request(url, method, **kwargs)
-        self.times.append(("%s %s" % (method, url),
-                           start_time, time.time()))
-        return resp, body
-
-    def _cs_request(self, url, method, **kwargs):
-        def request():
-            kwargs.setdefault('headers', {})['X-Auth-Token'] = self.auth_token
-            if self.tenant:
-                kwargs['headers']['X-Auth-Project-Id'] = self.tenant
-
-            resp, body = self._time_request(self.service_url + url, method,
-                                            **kwargs)
-            return resp, body
-
-        if not self.auth_token or not self.service_url:
-            self.authenticate()
-
-        # Perform the request once. If we get a 401 back then it
-        # might be because the auth token expired, so try to
-        # re-authenticate and try again. If it still fails, bail.
-        try:
-            return request()
-        except exceptions.Unauthorized, ex:
-            self.authenticate()
-            return request()
-
-    def get(self, url, **kwargs):
-        return self._cs_request(url, 'GET', **kwargs)
-
-    def post(self, url, **kwargs):
-        return self._cs_request(url, 'POST', **kwargs)
-
-    def put(self, url, **kwargs):
-        return self._cs_request(url, 'PUT', **kwargs)
-
-    def delete(self, url, **kwargs):
-        return self._cs_request(url, 'DELETE', **kwargs)
-
-    def authenticate(self):
-        """Auths the client and gets a token. May optionally set a service url.
-
-        The client will get auth errors until the authentication step
-        occurs. Additionally, if a service_url was not explicitly given in
-        the clients __init__ method, one will be obtained from the auth
-        service.
-
-        """
-        catalog = self.authenticator.authenticate()
-        if self.service_url:
-            possible_service_url = None
-        else:
-            if self.endpoint_type == "publicURL":
-                possible_service_url = catalog.get_public_url()
-            elif self.endpoint_type == "adminURL":
-                possible_service_url = catalog.get_management_url()
-        self.authenticate_with_token(catalog.get_token(), possible_service_url)
-
-    def authenticate_with_token(self, token, service_url=None):
-        self.auth_token = token
-        if not self.service_url:
-            if not service_url:
-                raise exceptions.ServiceUrlNotGiven()
-            else:
-                self.service_url = service_url
-
-
-class Dbaas(object):
-    """
-    Top-level object to access the Rackspace Database as a Service API.
-
-    Create an instance with your creds::
-
-        >>> red = Dbaas(USERNAME, API_KEY, TENANT, AUTH_URL, SERVICE_NAME,
-                        SERVICE_URL)
-
-    Then call methods on its managers::
-
-        >>> red.instances.list()
-        ...
-        >>> red.flavors.list()
-        ...
-
-    &c.
-    """
-
-    def __init__(self, username, api_key, tenant=None, auth_url=None,
-                 service_type='database', service_name='reddwarf',
-                 service_url=None, insecure=False, auth_strategy='keystone',
-                 region_name=None, client_cls=ReddwarfHTTPClient):
-        from reddwarfclient.versions import Versions
-        from reddwarfclient.databases import Databases
-        from reddwarfclient.flavors import Flavors
-        from reddwarfclient.instances import Instances
-        from reddwarfclient.limits import Limits
-        from reddwarfclient.users import Users
-        from reddwarfclient.root import Root
-        from reddwarfclient.hosts import Hosts
-        from reddwarfclient.quota import Quotas
-        from reddwarfclient.backups import Backups
-        from reddwarfclient.security_groups import SecurityGroups
-        from reddwarfclient.security_groups import SecurityGroupRules
-        from reddwarfclient.storage import StorageInfo
-        from reddwarfclient.management import Management
-        from reddwarfclient.accounts import Accounts
-        from reddwarfclient.diagnostics import DiagnosticsInterrogator
-        from reddwarfclient.diagnostics import HwInfoInterrogator
-
-        self.client = client_cls(username, api_key, tenant, auth_url,
-                                 service_type=service_type,
-                                 service_name=service_name,
-                                 service_url=service_url,
-                                 insecure=insecure,
-                                 auth_strategy=auth_strategy,
-                                 region_name=region_name)
-        self.versions = Versions(self)
-        self.databases = Databases(self)
-        self.flavors = Flavors(self)
-        self.instances = Instances(self)
-        self.limits = Limits(self)
-        self.users = Users(self)
-        self.root = Root(self)
-        self.hosts = Hosts(self)
-        self.quota = Quotas(self)
-        self.backups = Backups(self)
-        self.security_groups = SecurityGroups(self)
-        self.security_group_rules = SecurityGroupRules(self)
-        self.storage = StorageInfo(self)
-        self.management = Management(self)
-        self.accounts = Accounts(self)
-        self.diagnostics = DiagnosticsInterrogator(self)
-        self.hwinfo = HwInfoInterrogator(self)
-
-        class Mgmt(object):
-            def __init__(self, dbaas):
-                self.instances = dbaas.management
-                self.hosts = dbaas.hosts
-                self.accounts = dbaas.accounts
-                self.storage = dbaas.storage
-
-        self.mgmt = Mgmt(self)
-
-    def set_management_url(self, url):
-        self.client.management_url = url
-
-    def get_timings(self):
-        return self.client.get_timings()
-
-    def authenticate(self):
-        """
-        Authenticate against the server.
-
-        This is called to perform an authentication to retrieve a token.
-
-        Returns on success; raises :exc:`exceptions.Unauthorized` if the
-        credentials are wrong.
-        """
-        self.client.authenticate()
diff --git a/reddwarfclient/common.py b/reddwarfclient/common.py
deleted file mode 100644
index 9c66c49..0000000
--- a/reddwarfclient/common.py
+++ /dev/null
@@ -1,406 +0,0 @@
-#    Copyright 2011 OpenStack LLC
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import copy
-import json
-import optparse
-import os
-import pickle
-import sys
-
-from reddwarfclient import client
-from reddwarfclient.xml import ReddwarfXmlClient
-from reddwarfclient import exceptions
-
-from urllib import quote
-
-
-def methods_of(obj):
-    """Get all callable methods of an object that don't start with underscore
-    returns a list of tuples of the form (method_name, method)"""
-    result = {}
-    for i in dir(obj):
-        if callable(getattr(obj, i)) and not i.startswith('_'):
-            result[i] = getattr(obj, i)
-    return result
-
-
-def check_for_exceptions(resp, body):
-    if resp.status in (400, 422, 500):
-            raise exceptions.from_response(resp, body)
-
-
-def print_actions(cmd, actions):
-    """Print help for the command with list of options and description"""
-    print ("Available actions for '%s' cmd:") % cmd
-    for k, v in actions.iteritems():
-        print "\t%-20s%s" % (k, v.__doc__)
-    sys.exit(2)
-
-
-def print_commands(commands):
-    """Print the list of available commands and description"""
-
-    print "Available commands"
-    for k, v in commands.iteritems():
-        print "\t%-20s%s" % (k, v.__doc__)
-    sys.exit(2)
-
-
-def limit_url(url, limit=None, marker=None):
-    if not limit and not marker:
-        return url
-    query = []
-    if marker:
-        query.append("marker=%s" % marker)
-    if limit:
-        query.append("limit=%s" % limit)
-    query = '?' + '&'.join(query)
-    return url + query
-
-
-def quote_user_host(user, host):
-    quoted = ''
-    if host:
-        quoted = quote("%s@%s" % (user, host))
-    else:
-        quoted = quote("%s" % user)
-    return quoted.replace('.', '%2e')
-
-
-class CliOptions(object):
-    """A token object containing the user, apikey and token which
-       is pickleable."""
-
-    APITOKEN = os.path.expanduser("~/.apitoken")
-
-    DEFAULT_VALUES = {
-        'username': None,
-        'apikey': None,
-        'tenant_id': None,
-        'auth_url': None,
-        'auth_type': 'keystone',
-        'service_type': 'database',
-        'service_name': 'reddwarf',
-        'region': 'RegionOne',
-        'service_url': None,
-        'insecure': False,
-        'verbose': False,
-        'debug': False,
-        'token': None,
-        'xml': None,
-    }
-
-    def __init__(self, **kwargs):
-        for key, value in self.DEFAULT_VALUES.items():
-            setattr(self, key, value)
-
-    @classmethod
-    def default(cls):
-        kwargs = copy.deepcopy(cls.DEFAULT_VALUES)
-        return cls(**kwargs)
-
-    @classmethod
-    def load_from_file(cls):
-        try:
-            with open(cls.APITOKEN, 'rb') as token:
-                return pickle.load(token)
-        except IOError:
-            pass  # File probably not found.
-        except:
-            print("ERROR: Token file found at %s was corrupt." % cls.APITOKEN)
-        return cls.default()
-
-    @classmethod
-    def save_from_instance_fields(cls, instance):
-        apitoken = cls.default()
-        for key, default_value in cls.DEFAULT_VALUES.items():
-            final_value = getattr(instance, key, default_value)
-            setattr(apitoken, key, final_value)
-        with open(cls.APITOKEN, 'wb') as token:
-            pickle.dump(apitoken, token, protocol=2)
-
-    @classmethod
-    def create_optparser(cls, load_file):
-        oparser = optparse.OptionParser(
-            usage="%prog [options] <cmd> <action> <args>",
-            version='1.0', conflict_handler='resolve')
-        if load_file:
-            file = cls.load_from_file()
-        else:
-            file = cls.default()
-
-        def add_option(*args, **kwargs):
-            if len(args) == 1:
-                name = args[0]
-            else:
-                name = args[1]
-            kwargs['default'] = getattr(file, name, cls.DEFAULT_VALUES[name])
-            oparser.add_option("--%s" % name, **kwargs)
-
-        add_option("verbose", action="store_true",
-                   help="Show equivalent curl statement along "
-            "with actual HTTP communication.")
-        add_option("debug", action="store_true",
-                   help="Show the stack trace on errors.")
-        add_option("auth_url", help="Auth API endpoint URL with port and "
-            "version. Default: http://localhost:5000/v2.0")
-        add_option("username", help="Login username")
-        add_option("apikey", help="Api key")
-        add_option("tenant_id",
-                   help="Tenant Id associated with the account")
-        add_option("auth_type",
-            help="Auth type to support different auth environments, \
-                                Supported values are 'keystone', 'rax'.")
-        add_option("service_type",
-            help="Service type is a name associated for the catalog")
-        add_option("service_name",
-            help="Service name as provided in the service catalog")
-        add_option("service_url",
-            help="Service endpoint to use if the catalog doesn't have one.")
-        add_option("region", help="Region the service is located in")
-        add_option("insecure", action="store_true",
-                   help="Run in insecure mode for https endpoints.")
-        add_option("token", help="Token from a prior login.")
-        add_option("xml", action="store_true", help="Changes format to XML.")
-
-        oparser.add_option("--secure", action="store_false", dest="insecure",
-                   help="Run in insecure mode for https endpoints.")
-        oparser.add_option("--json", action="store_false", dest="xml",
-                   help="Changes format to JSON.")
-        oparser.add_option("--terse", action="store_false", dest="verbose",
-                   help="Toggles verbose mode off.")
-        oparser.add_option("--hide-debug", action="store_false", dest="debug",
-                   help="Toggles debug mode off.")
-        return oparser
-
-
-class ArgumentRequired(Exception):
-    def __init__(self, param):
-        self.param = param
-
-    def __str__(self):
-        return 'Argument "--%s" required.' % self.param
-
-
-class CommandsBase(object):
-    params = []
-
-    def __init__(self, parser):
-        self._parse_options(parser)
-
-    def _get_client(self):
-        """Creates the all important client object."""
-        try:
-            if self.xml:
-                client_cls = ReddwarfXmlClient
-            else:
-                client_cls = client.ReddwarfHTTPClient
-            if self.verbose:
-                client.log_to_streamhandler(sys.stdout)
-                client.RDC_PP = True
-            return client.Dbaas(self.username, self.apikey, self.tenant_id,
-                          auth_url=self.auth_url,
-                          auth_strategy=self.auth_type,
-                          service_type=self.service_type,
-                          service_name=self.service_name,
-                          region_name=self.region,
-                          service_url=self.service_url,
-                          insecure=self.insecure,
-                          client_cls=client_cls)
-        except:
-            if self.debug:
-                raise
-            print sys.exc_info()[1]
-
-    def _safe_exec(self, func, *args, **kwargs):
-        if not self.debug:
-            try:
-                return func(*args, **kwargs)
-            except:
-                print(sys.exc_info()[1])
-                return None
-        else:
-            return func(*args, **kwargs)
-
-    @classmethod
-    def _prepare_parser(cls, parser):
-        for param in cls.params:
-            parser.add_option("--%s" % param)
-
-    def _parse_options(self, parser):
-        opts, args = parser.parse_args()
-        for param in opts.__dict__:
-            value = getattr(opts, param)
-            setattr(self, param, value)
-
-    def _require(self, *params):
-        for param in params:
-            if not hasattr(self, param):
-                raise ArgumentRequired(param)
-            if not getattr(self, param):
-                raise ArgumentRequired(param)
-
-    def _make_list(self, *params):
-        # Convert the listed params to lists.
-        for param in params:
-            raw = getattr(self, param)
-            if isinstance(raw, list):
-                return
-            raw = [item.strip() for item in raw.split(',')]
-            setattr(self, param, raw)
-
-    def _pretty_print(self, func, *args, **kwargs):
-        if self.verbose:
-            self._safe_exec(func, *args, **kwargs)
-            return  # Skip this, since the verbose stuff will show up anyway.
-
-        def wrapped_func():
-            result = func(*args, **kwargs)
-            if result:
-                print(json.dumps(result._info, sort_keys=True, indent=4))
-            else:
-                print("OK")
-        self._safe_exec(wrapped_func)
-
-    def _dumps(self, item):
-        return json.dumps(item, sort_keys=True, indent=4)
-
-    def _pretty_list(self, func, *args, **kwargs):
-        result = self._safe_exec(func, *args, **kwargs)
-        if self.verbose:
-            return
-        if result and len(result) > 0:
-            for item in result:
-                print(self._dumps(item._info))
-        else:
-            print("OK")
-
-    def _pretty_paged(self, func, *args, **kwargs):
-        try:
-            limit = self.limit
-            if limit:
-                limit = int(limit, 10)
-            result = func(*args, limit=limit, marker=self.marker, **kwargs)
-            if self.verbose:
-                return  # Verbose already shows the output, so skip this.
-            if result and len(result) > 0:
-                for item in result:
-                    print self._dumps(item._info)
-                if result.links:
-                    print("Links:")
-                    for link in result.links:
-                        print self._dumps((link))
-            else:
-                print("OK")
-        except:
-            if self.debug:
-                raise
-            print sys.exc_info()[1]
-
-
-class Auth(CommandsBase):
-    """Authenticate with your username and api key"""
-    params = [
-              'apikey',
-              'auth_strategy',
-              'auth_type',
-              'auth_url',
-              'options',
-              'region',
-              'service_name',
-              'service_type',
-              'service_url',
-              'tenant_id',
-              'username',
-             ]
-
-    def __init__(self, parser):
-        super(Auth, self).__init__(parser)
-        self.dbaas = None
-
-    def login(self):
-        """Login to retrieve an auth token to use for other api calls"""
-        self._require('username', 'apikey', 'tenant_id', 'auth_url')
-        try:
-            self.dbaas = self._get_client()
-            self.dbaas.authenticate()
-            self.token = self.dbaas.client.auth_token
-            self.service_url = self.dbaas.client.service_url
-            CliOptions.save_from_instance_fields(self)
-            print("Token aquired! Saving to %s..." % CliOptions.APITOKEN)
-            print("    service_url = %s" % self.service_url)
-            print("    token       = %s" % self.token)
-        except:
-            if self.debug:
-                raise
-            print sys.exc_info()[1]
-
-
-class AuthedCommandsBase(CommandsBase):
-    """Commands that work only with an authicated client."""
-
-    def __init__(self, parser):
-        """Makes sure a token is available somehow and logs in."""
-        super(AuthedCommandsBase, self).__init__(parser)
-        try:
-            self._require('token')
-        except ArgumentRequired:
-            if self.debug:
-                raise
-            print('No token argument supplied. Use the "auth login" command '
-                  'to log in and get a token.\n')
-            sys.exit(1)
-        try:
-            self._require('service_url')
-        except ArgumentRequired:
-            if self.debug:
-                raise
-            print('No service_url given.\n')
-            sys.exit(1)
-        self.dbaas = self._get_client()
-        # Actually set the token to avoid a re-auth.
-        self.dbaas.client.auth_token = self.token
-        self.dbaas.client.authenticate_with_token(self.token, self.service_url)
-
-
-class Paginated(object):
-    """ Pretends to be a list if you iterate over it, but also keeps a
-        next property you can use to get the next page of data. """
-
-    def __init__(self, items=[], next_marker=None, links=[]):
-        self.items = items
-        self.next = next_marker
-        self.links = links
-
-    def __len__(self):
-        return len(self.items)
-
-    def __iter__(self):
-        return self.items.__iter__()
-
-    def __getitem__(self, key):
-        return self.items[key]
-
-    def __setitem__(self, key, value):
-        self.items[key] = value
-
-    def __delitem__(self, key):
-        del self.items[key]
-
-    def __reversed__(self):
-        return reversed(self.items)
-
-    def __contains__(self, needle):
-        return needle in self.items
diff --git a/reddwarfclient/databases.py b/reddwarfclient/databases.py
deleted file mode 100644
index d7f31e1..0000000
--- a/reddwarfclient/databases.py
+++ /dev/null
@@ -1,79 +0,0 @@
-from reddwarfclient import base
-from reddwarfclient.common import check_for_exceptions
-from reddwarfclient.common import limit_url
-from reddwarfclient.common import Paginated
-import exceptions
-import urlparse
-
-
-class Database(base.Resource):
-    """
-    According to Wikipedia, "A database is a system intended to organize,
-    store, and retrieve
-    large amounts of data easily."
-    """
-    def __repr__(self):
-        return "<Database: %s>" % self.name
-
-
-class Databases(base.ManagerWithFind):
-    """
-    Manage :class:`Databases` resources.
-    """
-    resource_class = Database
-
-    def create(self, instance_id, databases):
-        """
-        Create new databases within the specified instance
-        """
-        body = {"databases": databases}
-        url = "/instances/%s/databases" % instance_id
-        resp, body = self.api.client.post(url, body=body)
-        check_for_exceptions(resp, body)
-
-    def delete(self, instance_id, dbname):
-        """Delete an existing database in the specified instance"""
-        url = "/instances/%s/databases/%s" % (instance_id, dbname)
-        resp, body = self.api.client.delete(url)
-        check_for_exceptions(resp, body)
-
-    def _list(self, url, response_key, limit=None, marker=None):
-        resp, body = self.api.client.get(limit_url(url, limit, marker))
-        check_for_exceptions(resp, body)
-        if not body:
-            raise Exception("Call to " + url +
-                            " did not return a body.")
-        links = body.get('links', [])
-        next_links = [link['href'] for link in links if link['rel'] == 'next']
-        next_marker = None
-        for link in next_links:
-            # Extract the marker from the url.
-            parsed_url = urlparse.urlparse(link)
-            query_dict = dict(urlparse.parse_qsl(parsed_url.query))
-            next_marker = query_dict.get('marker', None)
-        databases = body[response_key]
-        databases = [self.resource_class(self, res) for res in databases]
-        return Paginated(databases, next_marker=next_marker, links=links)
-
-    def list(self, instance, limit=None, marker=None):
-        """
-        Get a list of all Databases from the instance.
-
-        :rtype: list of :class:`Database`.
-        """
-        return self._list("/instances/%s/databases" % base.getid(instance),
-                          "databases", limit, marker)
-
-#    def get(self, instance, database):
-#        """
-#        Get a specific instances.
-#
-#        :param flavor: The ID of the :class:`Database` to get.
-#        :rtype: :class:`Database`
-#        """
-#        assert isinstance(instance, Instance)
-#        assert isinstance(database, (Database, int))
-#        instance_id = base.getid(instance)
-#        db_id = base.getid(database)
-#        url = "/instances/%s/databases/%s" % (instance_id, db_id)
-#        return self._get(url, "database")
diff --git a/reddwarfclient/diagnostics.py b/reddwarfclient/diagnostics.py
deleted file mode 100644
index 06da06c..0000000
--- a/reddwarfclient/diagnostics.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-import exceptions
-
-
-class Diagnostics(base.Resource):
-    """
-    Account is an opaque instance used to hold account information.
-    """
-    def __repr__(self):
-        return "<Diagnostics: %s>" % self.version
-
-
-class DiagnosticsInterrogator(base.ManagerWithFind):
-    """
-    Manager class for Interrogator resource
-    """
-    resource_class = Diagnostics
-
-    def get(self, instance):
-        """
-        Get the diagnostics of the guest on the instance.
-        """
-        return self._get("/mgmt/instances/%s/diagnostics" %
-                         base.getid(instance), "diagnostics")
-
-
-class HwInfo(base.Resource):
-
-    def __repr__(self):
-        return "<HwInfo: %s>" % self.version
-
-
-class HwInfoInterrogator(base.ManagerWithFind):
-    """
-    Manager class for HwInfo
-    """
-    resource_class = HwInfo
-
-    def get(self, instance):
-        """
-        Get the hardware information of the instance.
-        """
-        return self._get("/mgmt/instances/%s/hwinfo" % base.getid(instance))
diff --git a/reddwarfclient/exceptions.py b/reddwarfclient/exceptions.py
deleted file mode 100644
index 88c3f7e..0000000
--- a/reddwarfclient/exceptions.py
+++ /dev/null
@@ -1,179 +0,0 @@
-#    Copyright 2011 OpenStack LLC
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-
-class UnsupportedVersion(Exception):
-    """Indicates that the user is trying to use an unsupported
-    version of the API"""
-    pass
-
-
-class CommandError(Exception):
-    pass
-
-
-class AuthorizationFailure(Exception):
-    pass
-
-
-class NoUniqueMatch(Exception):
-    pass
-
-
-class NoTokenLookupException(Exception):
-    """This form of authentication does not support looking up
-       endpoints from an existing token."""
-    pass
-
-
-class EndpointNotFound(Exception):
-    """Could not find Service or Region in Service Catalog."""
-    pass
-
-
-class AuthUrlNotGiven(EndpointNotFound):
-    """The auth url was not given."""
-    pass
-
-
-class ServiceUrlNotGiven(EndpointNotFound):
-    """The service url was not given."""
-    pass
-
-
-class ResponseFormatError(Exception):
-    """Could not parse the response format."""
-    pass
-
-
-class AmbiguousEndpoints(Exception):
-    """Found more than one matching endpoint in Service Catalog."""
-    def __init__(self, endpoints=None):
-        self.endpoints = endpoints
-
-    def __str__(self):
-        return "AmbiguousEndpoints: %s" % repr(self.endpoints)
-
-
-class ClientException(Exception):
-    """
-    The base exception class for all exceptions this library raises.
-    """
-    def __init__(self, code, message=None, details=None, request_id=None):
-        self.code = code
-        self.message = message or self.__class__.message
-        self.details = details
-        self.request_id = request_id
-
-    def __str__(self):
-        formatted_string = "%s (HTTP %s)" % (self.message, self.code)
-        if self.request_id:
-            formatted_string += " (Request-ID: %s)" % self.request_id
-
-        return formatted_string
-
-
-class BadRequest(ClientException):
-    """
-    HTTP 400 - Bad request: you sent some malformed data.
-    """
-    http_status = 400
-    message = "Bad request"
-
-
-class Unauthorized(ClientException):
-    """
-    HTTP 401 - Unauthorized: bad credentials.
-    """
-    http_status = 401
-    message = "Unauthorized"
-
-
-class Forbidden(ClientException):
-    """
-    HTTP 403 - Forbidden: your credentials don't give you access to this
-    resource.
-    """
-    http_status = 403
-    message = "Forbidden"
-
-
-class NotFound(ClientException):
-    """
-    HTTP 404 - Not found
-    """
-    http_status = 404
-    message = "Not found"
-
-
-class OverLimit(ClientException):
-    """
-    HTTP 413 - Over limit: you're over the API limits for this time period.
-    """
-    http_status = 413
-    message = "Over limit"
-
-
-# NotImplemented is a python keyword.
-class HTTPNotImplemented(ClientException):
-    """
-    HTTP 501 - Not Implemented: the server does not support this operation.
-    """
-    http_status = 501
-    message = "Not Implemented"
-
-
-class UnprocessableEntity(ClientException):
-    """
-    HTTP 422 - Unprocessable Entity: The request cannot be processed.
-    """
-    http_status = 422
-    message = "Unprocessable Entity"
-
-
-# In Python 2.4 Exception is old-style and thus doesn't have a __subclasses__()
-# so we can do this:
-#     _code_map = dict((c.http_status, c)
-#                      for c in ClientException.__subclasses__())
-#
-# Instead, we have to hardcode it:
-_code_map = dict((c.http_status, c) for c in [BadRequest, Unauthorized,
-                                              Forbidden, NotFound, OverLimit,
-                                              HTTPNotImplemented,
-                                              UnprocessableEntity])
-
-
-def from_response(response, body):
-    """
-    Return an instance of an ClientException or subclass
-    based on an httplib2 response.
-
-    Usage::
-
-        resp, body = http.request(...)
-        if resp.status != 200:
-            raise exception_from_response(resp, body)
-    """
-    cls = _code_map.get(response.status, ClientException)
-    if body:
-        message = "n/a"
-        details = "n/a"
-        if hasattr(body, 'keys'):
-            error = body[body.keys()[0]]
-            message = error.get('message', None)
-            details = error.get('details', None)
-        return cls(code=response.status, message=message, details=details)
-    else:
-        request_id = response.get('x-compute-request-id')
-        return cls(code=response.status, request_id=request_id)
diff --git a/reddwarfclient/flavors.py b/reddwarfclient/flavors.py
deleted file mode 100644
index ba01a5f..0000000
--- a/reddwarfclient/flavors.py
+++ /dev/null
@@ -1,62 +0,0 @@
-# Copyright (c) 2012 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-
-from reddwarfclient import base
-
-import exceptions
-
-from reddwarfclient.common import check_for_exceptions
-
-
-class Flavor(base.Resource):
-    """
-    A Flavor is an Instance type, specifying among other things, RAM size.
-    """
-    def __repr__(self):
-        return "<Flavor: %s>" % self.name
-
-
-class Flavors(base.ManagerWithFind):
-    """
-    Manage :class:`Flavor` resources.
-    """
-    resource_class = Flavor
-
-    def __repr__(self):
-        return "<Flavors Manager at %s>" % id(self)
-
-    def _list(self, url, response_key):
-        resp, body = self.api.client.get(url)
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-        return [self.resource_class(self, res) for res in body[response_key]]
-
-    def list(self):
-        """
-        Get a list of all flavors.
-
-        :rtype: list of :class:`Flavor`.
-        """
-        return self._list("/flavors", "flavors")
-
-    def get(self, flavor):
-        """
-        Get a specific flavor.
-
-        :rtype: :class:`Flavor`
-        """
-        return self._get("/flavors/%s" % base.getid(flavor),
-                        "flavor")
diff --git a/reddwarfclient/hosts.py b/reddwarfclient/hosts.py
deleted file mode 100644
index fb03d37..0000000
--- a/reddwarfclient/hosts.py
+++ /dev/null
@@ -1,78 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-
-from reddwarfclient.common import check_for_exceptions
-
-
-class Host(base.Resource):
-    """
-    A Hosts is an opaque instance used to store Host instances.
-    """
-    def __repr__(self):
-        return "<Host: %s>" % self.name
-
-
-class Hosts(base.ManagerWithFind):
-    """
-    Manage :class:`Host` resources.
-    """
-    resource_class = Host
-
-    def _list(self, url, response_key):
-        resp, body = self.api.client.get(url)
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-        return [self.resource_class(self, res) for res in body[response_key]]
-
-    def _action(self, host_id, body):
-        """
-        Perform a host "action" -- update
-        """
-        url = "/mgmt/hosts/%s/instances/action" % host_id
-        resp, body = self.api.client.post(url, body=body)
-        check_for_exceptions(resp, body)
-
-    def update_all(self, host_id):
-        """
-        Update all instances on a host.
-        """
-        body = {'update': ''}
-        self._action(host_id, body)
-
-    def index(self):
-        """
-        Get a list of all hosts.
-
-        :rtype: list of :class:`Hosts`.
-        """
-        return self._list("/mgmt/hosts", "hosts")
-
-    def get(self, host):
-        """
-        Get a specific host.
-
-        :rtype: :class:`host`
-        """
-        return self._get("/mgmt/hosts/%s" % self._get_host_name(host), "host")
-
-    @staticmethod
-    def _get_host_name(host):
-        try:
-            if host.name:
-                return host.name
-        except AttributeError:
-            return host
diff --git a/reddwarfclient/instances.py b/reddwarfclient/instances.py
deleted file mode 100644
index 66b091c..0000000
--- a/reddwarfclient/instances.py
+++ /dev/null
@@ -1,185 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-
-import exceptions
-import urlparse
-
-from reddwarfclient.common import check_for_exceptions
-from reddwarfclient.common import limit_url
-from reddwarfclient.common import Paginated
-
-
-REBOOT_SOFT, REBOOT_HARD = 'SOFT', 'HARD'
-
-
-class Instance(base.Resource):
-    """
-    An Instance is an opaque instance used to store Database instances.
-    """
-    def __repr__(self):
-        return "<Instance: %s>" % self.name
-
-    def list_databases(self):
-        return self.manager.databases.list(self)
-
-    def delete(self):
-        """
-        Delete the instance.
-        """
-        self.manager.delete(self)
-
-    def restart(self):
-        """
-        Restart the database instance
-        """
-        self.manager.restart(self.id)
-
-
-class Instances(base.ManagerWithFind):
-    """
-    Manage :class:`Instance` resources.
-    """
-    resource_class = Instance
-
-    def create(self, name, flavor_id, volume=None, databases=None, users=None,
-               restorePoint=None):
-        """
-        Create (boot) a new instance.
-        """
-        body = {"instance": {
-            "name": name,
-            "flavorRef": flavor_id
-        }}
-        if volume:
-            body["instance"]["volume"] = volume
-        if databases:
-            body["instance"]["databases"] = databases
-        if users:
-            body["instance"]["users"] = users
-        if restorePoint:
-            body["instance"]["restorePoint"] = restorePoint
-
-        return self._create("/instances", body, "instance")
-
-    def _list(self, url, response_key, limit=None, marker=None):
-        resp, body = self.api.client.get(limit_url(url, limit, marker))
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-        links = body.get('links', [])
-        next_links = [link['href'] for link in links if link['rel'] == 'next']
-        next_marker = None
-        for link in next_links:
-            # Extract the marker from the url.
-            parsed_url = urlparse.urlparse(link)
-            query_dict = dict(urlparse.parse_qsl(parsed_url.query))
-            next_marker = query_dict.get('marker', None)
-        instances = body[response_key]
-        instances = [self.resource_class(self, res) for res in instances]
-        return Paginated(instances, next_marker=next_marker, links=links)
-
-    def list(self, limit=None, marker=None):
-        """
-        Get a list of all instances.
-
-        :rtype: list of :class:`Instance`.
-        """
-        return self._list("/instances", "instances", limit, marker)
-
-    def get(self, instance):
-        """
-        Get a specific instances.
-
-        :rtype: :class:`Instance`
-        """
-        return self._get("/instances/%s" % base.getid(instance),
-                         "instance")
-
-    def backups(self, instance):
-        """
-        Get the list of backups for a specific instance.
-
-        :rtype: list of :class:`Backups`.
-        """
-        return self._list("/instances/%s/backups" % base.getid(instance),
-                          "backups")
-
-    def delete(self, instance):
-        """
-        Delete the specified instance.
-
-        :param instance_id: The instance id to delete
-        """
-        resp, body = self.api.client.delete("/instances/%s" %
-                                            base.getid(instance))
-        if resp.status in (422, 500):
-            raise exceptions.from_response(resp, body)
-
-    def _action(self, instance_id, body):
-        """
-        Perform a server "action" -- reboot/rebuild/resize/etc.
-        """
-        url = "/instances/%s/action" % instance_id
-        resp, body = self.api.client.post(url, body=body)
-        check_for_exceptions(resp, body)
-        if body:
-            return self.resource_class(self, body, loaded=True)
-        return body
-
-    def resize_volume(self, instance_id, volume_size):
-        """
-        Resize the volume on an existing instances
-        """
-        body = {"resize": {"volume": {"size": volume_size}}}
-        self._action(instance_id, body)
-
-    def resize_instance(self, instance_id, flavor_id):
-        """
-        Resize the volume on an existing instances
-        """
-        body = {"resize": {"flavorRef": flavor_id}}
-        self._action(instance_id, body)
-
-    def restart(self, instance_id):
-        """
-        Restart the database instance.
-
-        :param instance_id: The :class:`Instance` (or its ID) to share onto.
-        """
-        body = {'restart': {}}
-        self._action(instance_id, body)
-
-    def reset_password(self, instance_id):
-        """
-        Resets the database instance root password.
-
-        :param instance_id: The :class:`Instance` (or its ID) to share onto.
-        """
-        body = {'reset-password': {}}
-        return self._action(instance_id, body)
-
-Instances.resize_flavor = Instances.resize_instance
-
-
-class InstanceStatus(object):
-
-    ACTIVE = "ACTIVE"
-    BLOCKED = "BLOCKED"
-    BUILD = "BUILD"
-    FAILED = "FAILED"
-    REBOOT = "REBOOT"
-    RESIZE = "RESIZE"
-    SHUTDOWN = "SHUTDOWN"
diff --git a/reddwarfclient/limits.py b/reddwarfclient/limits.py
deleted file mode 100644
index f2b8703..0000000
--- a/reddwarfclient/limits.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright (c) 2013 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-import exceptions
-
-
-class Limit(base.Resource):
-
-    def __repr__(self):
-        return "<Limit: %s>" % self.verb
-
-
-class Limits(base.ManagerWithFind):
-    """
-    Manages :class `Limit` resources
-    """
-    resource_class = Limit
-
-    def __repr__(self):
-        return "<Limit Manager at %s>" % id(self)
-
-    def _list(self, url, response_key):
-        resp, body = self.api.client.get(url)
-
-        if resp is None or resp.status != 200:
-            raise exceptions.from_response(resp, body)
-
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-
-        return [self.resource_class(self, res) for res in body[response_key]]
-
-    def list(self):
-        """
-        Retrieve the limits
-        """
-        return self._list("/limits", "limits")
diff --git a/reddwarfclient/management.py b/reddwarfclient/management.py
deleted file mode 100644
index 931c0d5..0000000
--- a/reddwarfclient/management.py
+++ /dev/null
@@ -1,136 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-import urlparse
-
-from reddwarfclient.common import check_for_exceptions
-from reddwarfclient.common import limit_url
-from reddwarfclient.common import Paginated
-from reddwarfclient.instances import Instance
-
-
-class RootHistory(base.Resource):
-    def __repr__(self):
-        return ("<Root History: Instance %s enabled at %s by %s>"
-                % (self.id, self.created, self.user))
-
-
-class Management(base.ManagerWithFind):
-    """
-    Manage :class:`Instances` resources.
-    """
-    resource_class = Instance
-
-    def _list(self, url, response_key, limit=None, marker=None):
-        resp, body = self.api.client.get(limit_url(url, limit, marker))
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-        links = body.get('links', [])
-        next_links = [link['href'] for link in links if link['rel'] == 'next']
-        next_marker = None
-        for link in next_links:
-            # Extract the marker from the url.
-            parsed_url = urlparse.urlparse(link)
-            query_dict = dict(urlparse.parse_qsl(parsed_url.query))
-            next_marker = query_dict.get('marker', None)
-        instances = body[response_key]
-        instances = [self.resource_class(self, res) for res in instances]
-        return Paginated(instances, next_marker=next_marker, links=links)
-
-    def show(self, instance):
-        """
-        Get details of one instance.
-
-        :rtype: :class:`Instance`.
-        """
-
-        return self._get("/mgmt/instances/%s" % base.getid(instance),
-                         'instance')
-
-    def index(self, deleted=None, limit=None, marker=None):
-        """
-        Show an overview of all local instances.
-        Optionally, filter by deleted status.
-
-        :rtype: list of :class:`Instance`.
-        """
-        form = ''
-        if deleted is not None:
-            if deleted:
-                form = "?deleted=true"
-            else:
-                form = "?deleted=false"
-
-        url = "/mgmt/instances%s" % form
-        return self._list(url, "instances", limit, marker)
-
-    def root_enabled_history(self, instance):
-        """
-        Get root access history of one instance.
-
-        """
-        url = "/mgmt/instances/%s/root" % base.getid(instance)
-        resp, body = self.api.client.get(url)
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-        return RootHistory(self, body['root_history'])
-
-    def _action(self, instance_id, body):
-        """
-        Perform a server "action" -- reboot/rebuild/resize/etc.
-        """
-        url = "/mgmt/instances/%s/action" % instance_id
-        resp, body = self.api.client.post(url, body=body)
-        check_for_exceptions(resp, body)
-
-    def stop(self, instance_id):
-        body = {'stop': {}}
-        self._action(instance_id, body)
-
-    def reboot(self, instance_id):
-        """
-        Reboot the underlying OS.
-
-        :param instance_id: The :class:`Instance` (or its ID) to share onto.
-        """
-        body = {'reboot': {}}
-        self._action(instance_id, body)
-
-    def migrate(self, instance_id, host=None):
-        """
-        Migrate the instance.
-
-        :param instance_id: The :class:`Instance` (or its ID) to share onto.
-        """
-        if host:
-            body = {'migrate': {'host': host}}
-        else:
-            body = {'migrate': {}}
-        self._action(instance_id, body)
-
-    def update(self, instance_id):
-        """
-        Update the guest agent via apt-get.
-        """
-        body = {'update': {}}
-        self._action(instance_id, body)
-
-    def reset_task_status(self, instance_id):
-        """
-        Set the task status to NONE.
-        """
-        body = {'reset-task-status': {}}
-        self._action(instance_id, body)
diff --git a/reddwarfclient/mcli.py b/reddwarfclient/mcli.py
deleted file mode 100644
index 62371cc..0000000
--- a/reddwarfclient/mcli.py
+++ /dev/null
@@ -1,246 +0,0 @@
-#!/usr/bin/env python
-
-#    Copyright 2011 OpenStack LLC
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-Reddwarf Management Command line tool
-"""
-
-import json
-import optparse
-import os
-import sys
-
-
-# If ../reddwarf/__init__.py exists, add ../ to Python search path, so that
-# it will override what happens to be installed in /usr/(local/)lib/python...
-possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
-                                   os.pardir,
-                                   os.pardir))
-if os.path.exists(os.path.join(possible_topdir, 'reddwarfclient',
-                               '__init__.py')):
-    sys.path.insert(0, possible_topdir)
-
-
-from reddwarfclient import common
-
-
-oparser = None
-
-
-def _pretty_print(info):
-    print json.dumps(info, sort_keys=True, indent=4)
-
-
-class HostCommands(common.AuthedCommandsBase):
-    """Commands to list info on hosts"""
-
-    params = [
-              'name',
-             ]
-
-    def update_all(self):
-        """Update all instances on a host"""
-        self._require('name')
-        self.dbaas.hosts.update_all(self.name)
-
-    def get(self):
-        """List details for the specified host"""
-        self._require('name')
-        self._pretty_print(self.dbaas.hosts.get, self.name)
-
-    def list(self):
-        """List all compute hosts"""
-        self._pretty_list(self.dbaas.hosts.index)
-
-
-class QuotaCommands(common.AuthedCommandsBase):
-    """List and update quota limits for a tenant."""
-
-    params = ['id',
-              'instances',
-              'volumes',
-              'backups']
-
-    def list(self):
-        """List all quotas for a tenant"""
-        self._require('id')
-        self._pretty_print(self.dbaas.quota.show, self.id)
-
-    def update(self):
-        """Update quota limits for a tenant"""
-        self._require('id')
-        self._pretty_print(self.dbaas.quota.update, self.id,
-                           dict((param, getattr(self, param))
-                                for param in self.params if param != 'id'))
-
-
-class RootCommands(common.AuthedCommandsBase):
-    """List details about the root info for an instance."""
-
-    params = [
-              'id',
-             ]
-
-    def history(self):
-        """List root history for the instance."""
-        self._require('id')
-        self._pretty_print(self.dbaas.management.root_enabled_history, self.id)
-
-
-class AccountCommands(common.AuthedCommandsBase):
-    """Commands to list account info"""
-
-    params = [
-              'id',
-             ]
-
-    def list(self):
-        """List all accounts with non-deleted instances"""
-        self._pretty_print(self.dbaas.accounts.index)
-
-    def get(self):
-        """List details for the account provided"""
-        self._require('id')
-        self._pretty_print(self.dbaas.accounts.show, self.id)
-
-
-class InstanceCommands(common.AuthedCommandsBase):
-    """List details about an instance."""
-
-    params = [
-              'deleted',
-              'id',
-              'limit',
-              'marker',
-              'host',
-             ]
-
-    def get(self):
-        """List details for the instance."""
-        self._require('id')
-        self._pretty_print(self.dbaas.management.show, self.id)
-
-    def list(self):
-        """List all instances for account"""
-        deleted = None
-        if self.deleted is not None:
-            if self.deleted.lower() in ['true']:
-                deleted = True
-            elif self.deleted.lower() in ['false']:
-                deleted = False
-        self._pretty_paged(self.dbaas.management.index, deleted=deleted)
-
-    def hwinfo(self):
-        """Show hardware information details about an instance."""
-        self._require('id')
-        self._pretty_print(self.dbaas.hwinfo.get, self.id)
-
-    def diagnostic(self):
-        """List diagnostic details about an instance."""
-        self._require('id')
-        self._pretty_print(self.dbaas.diagnostics.get, self.id)
-
-    def stop(self):
-        """Stop MySQL on the given instance."""
-        self._require('id')
-        self._pretty_print(self.dbaas.management.stop, self.id)
-
-    def reboot(self):
-        """Reboot the instance."""
-        self._require('id')
-        self._pretty_print(self.dbaas.management.reboot, self.id)
-
-    def migrate(self):
-        """Migrate the instance."""
-        self._require('id')
-        self._pretty_print(self.dbaas.management.migrate, self.id, self.host)
-
-    def reset_task_status(self):
-        """Set the instance's task status to NONE."""
-        self._require('id')
-        self._pretty_print(self.dbaas.management.reset_task_status, self.id)
-
-
-class StorageCommands(common.AuthedCommandsBase):
-    """Commands to list devices info"""
-
-    params = []
-
-    def list(self):
-        """List details for the storage device"""
-        self._pretty_list(self.dbaas.storage.index)
-
-
-def config_options(oparser):
-    oparser.add_option("-u", "--url", default="http://localhost:5000/v1.1",
-                       help="Auth API endpoint URL with port and version. \
-                            Default: http://localhost:5000/v1.1")
-
-
-COMMANDS = {'account': AccountCommands,
-            'host': HostCommands,
-            'instance': InstanceCommands,
-            'root': RootCommands,
-            'storage': StorageCommands,
-            'quota': QuotaCommands,
-            }
-
-
-def main():
-    # Parse arguments
-    oparser = common.CliOptions.create_optparser(True)
-    for k, v in COMMANDS.items():
-        v._prepare_parser(oparser)
-    (options, args) = oparser.parse_args()
-
-    if not args:
-        common.print_commands(COMMANDS)
-
-    # Pop the command and check if it's in the known commands
-    cmd = args.pop(0)
-    if cmd in COMMANDS:
-        fn = COMMANDS.get(cmd)
-        command_object = None
-        try:
-            command_object = fn(oparser)
-        except Exception as ex:
-            if options.debug:
-                raise
-            print(ex)
-
-        # Get a list of supported actions for the command
-        actions = common.methods_of(command_object)
-
-        if len(args) < 1:
-            common.print_actions(cmd, actions)
-
-        # Check for a valid action and perform that action
-        action = args.pop(0)
-        if action in actions:
-            try:
-                getattr(command_object, action)()
-            except Exception as ex:
-                if options.debug:
-                    raise
-                print ex
-        else:
-            common.print_actions(cmd, actions)
-    else:
-        common.print_commands(COMMANDS)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/reddwarfclient/quota.py b/reddwarfclient/quota.py
deleted file mode 100644
index e5a8f74..0000000
--- a/reddwarfclient/quota.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-from reddwarfclient.common import check_for_exceptions
-
-
-class Quotas(base.ManagerWithFind):
-    """
-    Manage :class:`Quota` information.
-    """
-
-    resource_class = base.Resource
-
-    def show(self, tenant_id):
-        """Get a list of all quotas for a tenant id"""
-
-        url = "/mgmt/quotas/%s" % tenant_id
-        resp, body = self.api.client.get(url)
-        check_for_exceptions(resp, body)
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-        if 'quotas' not in body:
-            raise Exception("Missing key value 'quotas' in response body.")
-        return body['quotas']
-
-    def update(self, id, quotas):
-        """
-        Set limits for quotas
-        """
-        url = "/mgmt/quotas/%s" % id
-        body = {"quotas": quotas}
-        resp, body = self.api.client.put(url, body=body)
-        check_for_exceptions(resp, body)
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-        if 'quotas' not in body:
-            raise Exception("Missing key value 'quotas' in response body.")
-        return body['quotas']
diff --git a/reddwarfclient/root.py b/reddwarfclient/root.py
deleted file mode 100644
index 33b0da7..0000000
--- a/reddwarfclient/root.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-
-from reddwarfclient import users
-from reddwarfclient.common import check_for_exceptions
-import exceptions
-
-
-class Root(base.ManagerWithFind):
-    """
-    Manager class for Root resource
-    """
-    resource_class = users.User
-    url = "/instances/%s/root"
-
-    def create(self, instance_id):
-        """
-        Enable the root user and return the root password for the
-        sepcified db instance
-        """
-        resp, body = self.api.client.post(self.url % instance_id)
-        check_for_exceptions(resp, body)
-        return body['user']['name'], body['user']['password']
-
-    def is_root_enabled(self, instance_id):
-        """ Return True if root is enabled for the instance;
-        False otherwise"""
-        resp, body = self.api.client.get(self.url % instance_id)
-        check_for_exceptions(resp, body)
-        return body['rootEnabled']
diff --git a/reddwarfclient/security_groups.py b/reddwarfclient/security_groups.py
deleted file mode 100644
index d26cc86..0000000
--- a/reddwarfclient/security_groups.py
+++ /dev/null
@@ -1,120 +0,0 @@
-# Copyright 2013 Hewlett-Packard Development Company, L.P.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-#
-
-from reddwarfclient import base
-
-import exceptions
-import urlparse
-
-from reddwarfclient.common import limit_url
-from reddwarfclient.common import Paginated
-
-
-class SecurityGroup(base.Resource):
-    """
-    Security Group is a resource used to hold security group information.
-    """
-    def __repr__(self):
-        return "<SecurityGroup: %s>" % self.name
-
-
-class SecurityGroups(base.ManagerWithFind):
-    """
-    Manage :class:`SecurityGroup` resources.
-    """
-    resource_class = SecurityGroup
-
-    def _list(self, url, response_key, limit=None, marker=None):
-        resp, body = self.api.client.get(limit_url(url, limit, marker))
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-        links = body.get('links', [])
-        next_links = [link['href'] for link in links if link['rel'] == 'next']
-        next_marker = None
-        for link in next_links:
-            # Extract the marker from the url.
-            parsed_url = urlparse.urlparse(link)
-            query_dict = dict(urlparse.parse_qsl(parsed_url.query))
-            next_marker = query_dict.get('marker', None)
-        instances = body[response_key]
-        instances = [self.resource_class(self, res) for res in instances]
-        return Paginated(instances, next_marker=next_marker, links=links)
-
-    def list(self, limit=None, marker=None):
-        """
-        Get a list of all security groups.
-
-        :rtype: list of :class:`SecurityGroup`.
-        """
-        return self._list("/security-groups", "security_groups", limit,
-                          marker)
-
-    def get(self, security_group):
-        """
-        Get a specific security group.
-
-        :rtype: :class:`SecurityGroup`
-        """
-        return self._get("/security-groups/%s" % base.getid(security_group),
-                         "security_group")
-
-
-class SecurityGroupRule(base.Resource):
-    """
-    Security Group Rule is a resource used to hold security group
-    rule related information.
-    """
-    def __repr__(self):
-        return \
-            "<SecurityGroupRule: ( \
-    Security Group id: %d, \
-    Protocol: %s, \
-    From_Port: %d, \
-    To_Port: %d, \
-    CIDR: %s )>" % (self.group_id, self.protocol, self.from_port,
-                    self.to_port, self.cidr)
-
-
-class SecurityGroupRules(base.ManagerWithFind):
-    """
-    Manage :class:`SecurityGroupRules` resources.
-    """
-    resource_class = SecurityGroupRule
-
-    def create(self, group_id, protocol, from_port, to_port, cidr):
-        """
-        Create a new security group rule.
-        """
-        body = {"security_group_rule": {
-            "group_id": group_id,
-            "protocol": protocol,
-            "from_port": from_port,
-            "to_port": to_port,
-            "cidr": cidr
-        }}
-        return self._create("/security-group-rules", body,
-                            "security_group_rule")
-
-    def delete(self, security_group_rule):
-        """
-        Delete the specified security group rule.
-
-        :param security_group_rule: The security group rule to delete
-        """
-        resp, body = self.api.client.delete("/security-group-rules/%s" %
-                                            base.getid(security_group_rule))
-        if resp.status in (422, 500):
-            raise exceptions.from_response(resp, body)
diff --git a/reddwarfclient/storage.py b/reddwarfclient/storage.py
deleted file mode 100644
index 653096e..0000000
--- a/reddwarfclient/storage.py
+++ /dev/null
@@ -1,45 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-
-
-class Device(base.Resource):
-    """
-    Storage is an opaque instance used to hold storage information.
-    """
-    def __repr__(self):
-        return "<Device: %s>" % self.name
-
-
-class StorageInfo(base.ManagerWithFind):
-    """
-    Manage :class:`Storage` resources.
-    """
-    resource_class = Device
-
-    def _list(self, url, response_key):
-        resp, body = self.api.client.get(url)
-        if not body:
-            raise Exception("Call to " + url + " did not return a body.")
-        return [self.resource_class(self, res) for res in body[response_key]]
-
-    def index(self):
-        """
-        Get a list of all storages.
-
-        :rtype: list of :class:`Storages`.
-        """
-        return self._list("/mgmt/storage", "devices")
diff --git a/reddwarfclient/tests/test_accounts.py b/reddwarfclient/tests/test_accounts.py
deleted file mode 100644
index ec76f13..0000000
--- a/reddwarfclient/tests/test_accounts.py
+++ /dev/null
@@ -1,84 +0,0 @@
-from testtools import TestCase
-from mock import Mock
-
-from reddwarfclient import accounts
-from reddwarfclient import base
-
-"""
-Unit tests for accounts.py
-"""
-
-
-class AccountTest(TestCase):
-
-    def setUp(self):
-        super(AccountTest, self).setUp()
-        self.orig__init = accounts.Account.__init__
-        accounts.Account.__init__ = Mock(return_value=None)
-        self.account = accounts.Account()
-
-    def tearDown(self):
-        super(AccountTest, self).tearDown()
-        accounts.Account.__init__ = self.orig__init
-
-    def test___repr__(self):
-        self.account.name = "account-1"
-        self.assertEqual('<Account: account-1>', self.account.__repr__())
-
-
-class AccountsTest(TestCase):
-
-    def setUp(self):
-        super(AccountsTest, self).setUp()
-        self.orig__init = accounts.Accounts.__init__
-        accounts.Accounts.__init__ = Mock(return_value=None)
-        self.accounts = accounts.Accounts()
-        self.accounts.api = Mock()
-        self.accounts.api.client = Mock()
-
-    def tearDown(self):
-        super(AccountsTest, self).tearDown()
-        accounts.Accounts.__init__ = self.orig__init
-
-    def test__list(self):
-        def side_effect_func(self, val):
-            return val
-
-        self.accounts.resource_class = Mock(side_effect=side_effect_func)
-        key_ = 'key'
-        body_ = {key_: "test-value"}
-        self.accounts.api.client.get = Mock(return_value=('resp', body_))
-        self.assertEqual("test-value", self.accounts._list('url', key_))
-
-        self.accounts.api.client.get = Mock(return_value=('resp', None))
-        self.assertRaises(Exception, self.accounts._list, 'url', None)
-
-    def test_index(self):
-        resp = Mock()
-        resp.status = 400
-        body = {"Accounts": {}}
-        self.accounts.api.client.get = Mock(return_value=(resp, body))
-        self.assertRaises(Exception, self.accounts.index)
-        resp.status = 200
-        self.assertTrue(isinstance(self.accounts.index(), base.Resource))
-        self.accounts.api.client.get = Mock(return_value=(resp, None))
-        self.assertRaises(Exception, self.accounts.index)
-
-    def test_show(self):
-        def side_effect_func(acct_name, acct):
-            return acct_name, acct
-
-        account_ = Mock()
-        account_.name = "test-account"
-        self.accounts._list = Mock(side_effect=side_effect_func)
-        self.assertEqual(('/mgmt/accounts/test-account', 'account'),
-                         self.accounts.show(account_))
-
-    def test__get_account_name(self):
-        account_ = 'account with no name'
-        self.assertEqual(account_,
-                         accounts.Accounts._get_account_name(account_))
-        account_ = Mock()
-        account_.name = "account-name"
-        self.assertEqual("account-name",
-                         accounts.Accounts._get_account_name(account_))
diff --git a/reddwarfclient/tests/test_auth.py b/reddwarfclient/tests/test_auth.py
deleted file mode 100644
index f1c4b59..0000000
--- a/reddwarfclient/tests/test_auth.py
+++ /dev/null
@@ -1,414 +0,0 @@
-import contextlib
-
-from testtools import TestCase
-from reddwarfclient import auth
-from mock import Mock
-
-from reddwarfclient import exceptions
-
-"""
-Unit tests for the classes and functions in auth.py.
-"""
-
-
-def check_url_none(test_case, auth_class):
-    # url is None, it must throw exception
-    authObj = auth_class(url=None, type=auth_class, client=None,
-                         username=None, password=None, tenant=None)
-    try:
-        authObj.authenticate()
-        test_case.fail("AuthUrlNotGiven exception expected")
-    except exceptions.AuthUrlNotGiven:
-        pass
-
-
-class AuthenticatorTest(TestCase):
-
-    def setUp(self):
-        super(AuthenticatorTest, self).setUp()
-        self.orig_load = auth.ServiceCatalog._load
-        self.orig__init = auth.ServiceCatalog.__init__
-
-    def tearDown(self):
-        super(AuthenticatorTest, self).tearDown()
-        auth.ServiceCatalog._load = self.orig_load
-        auth.ServiceCatalog.__init__ = self.orig__init
-
-    def test_get_authenticator_cls(self):
-        class_list = (auth.KeyStoneV2Authenticator,
-                      auth.RaxAuthenticator,
-                      auth.Auth1_1,
-                      auth.FakeAuth)
-
-        for c in class_list:
-            self.assertEqual(c, auth.get_authenticator_cls(c))
-
-        class_names = {"keystone": auth.KeyStoneV2Authenticator,
-                       "rax": auth.RaxAuthenticator,
-                       "auth1.1": auth.Auth1_1,
-                       "fake": auth.FakeAuth}
-
-        for cn in class_names.keys():
-            self.assertEqual(class_names[cn], auth.get_authenticator_cls(cn))
-
-        cls_or_name = "_unknown_"
-        self.assertRaises(ValueError, auth.get_authenticator_cls, cls_or_name)
-
-    def test__authenticate(self):
-        authObj = auth.Authenticator(Mock(), auth.KeyStoneV2Authenticator,
-                                     Mock(), Mock(), Mock(), Mock())
-        # test response code 200
-        resp = Mock()
-        resp.status = 200
-        body = "test_body"
-
-        auth.ServiceCatalog._load = Mock(return_value=1)
-        authObj.client._time_request = Mock(return_value=(resp, body))
-
-        sc = authObj._authenticate(Mock(), Mock())
-        self.assertEqual(body, sc.catalog)
-
-        # test AmbiguousEndpoints exception
-        auth.ServiceCatalog.__init__ = \
-            Mock(side_effect=exceptions.AmbiguousEndpoints)
-        self.assertRaises(exceptions.AmbiguousEndpoints,
-                          authObj._authenticate, Mock(), Mock())
-
-        # test handling KeyError and raising AuthorizationFailure exception
-        auth.ServiceCatalog.__init__ = Mock(side_effect=KeyError)
-        self.assertRaises(exceptions.AuthorizationFailure,
-                          authObj._authenticate, Mock(), Mock())
-
-        # test EndpointNotFound exception
-        mock = Mock(side_effect=exceptions.EndpointNotFound)
-        auth.ServiceCatalog.__init__ = mock
-        self.assertRaises(exceptions.EndpointNotFound,
-                          authObj._authenticate, Mock(), Mock())
-        mock.side_effect = None
-
-        # test response code 305
-        resp.__getitem__ = Mock(return_value='loc')
-        resp.status = 305
-        body = "test_body"
-        authObj.client._time_request = Mock(return_value=(resp, body))
-
-        l = authObj._authenticate(Mock(), Mock())
-        self.assertEqual('loc', l)
-
-        # test any response code other than 200 and 305
-        resp.status = 404
-        exceptions.from_response = Mock(side_effect=ValueError)
-        self.assertRaises(ValueError, authObj._authenticate, Mock(), Mock())
-
-    def test_authenticate(self):
-        authObj = auth.Authenticator(Mock(), auth.KeyStoneV2Authenticator,
-                                     Mock(), Mock(), Mock(), Mock())
-        self.assertRaises(NotImplementedError, authObj.authenticate)
-
-
-class KeyStoneV2AuthenticatorTest(TestCase):
-
-    def test_authenticate(self):
-        # url is None
-        check_url_none(self, auth.KeyStoneV2Authenticator)
-
-        # url is not None, so it must not throw exception
-        url = "test_url"
-        cls_type = auth.KeyStoneV2Authenticator
-        authObj = auth.KeyStoneV2Authenticator(url=url, type=cls_type,
-                                               client=None, username=None,
-                                               password=None, tenant=None)
-
-        def side_effect_func(url):
-            return url
-
-        mock = Mock()
-        mock.side_effect = side_effect_func
-        authObj._v2_auth = mock
-        r = authObj.authenticate()
-        self.assertEqual(url, r)
-
-    def test__v2_auth(self):
-        username = "reddwarf_user"
-        password = "reddwarf_password"
-        tenant = "tenant"
-        cls_type = auth.KeyStoneV2Authenticator
-        authObj = auth.KeyStoneV2Authenticator(url=None, type=cls_type,
-                                               client=None,
-                                               username=username,
-                                               password=password,
-                                               tenant=tenant)
-
-        def side_effect_func(url, body):
-            return body
-        mock = Mock()
-        mock.side_effect = side_effect_func
-        authObj._authenticate = mock
-        body = authObj._v2_auth(Mock())
-        self.assertEqual(username,
-                         body['auth']['passwordCredentials']['username'])
-        self.assertEqual(password,
-                         body['auth']['passwordCredentials']['password'])
-        self.assertEqual(tenant, body['auth']['tenantName'])
-
-
-class Auth1_1Test(TestCase):
-
-    def test_authenticate(self):
-        # handle when url is None
-        check_url_none(self, auth.Auth1_1)
-
-        # url is not none
-        username = "reddwarf_user"
-        password = "reddwarf_password"
-        url = "test_url"
-        authObj = auth.Auth1_1(url=url,
-                               type=auth.Auth1_1,
-                               client=None, username=username,
-                               password=password, tenant=None)
-
-        def side_effect_func(auth_url, body, root_key):
-            return auth_url, body, root_key
-
-        mock = Mock()
-        mock.side_effect = side_effect_func
-        authObj._authenticate = mock
-        auth_url, body, root_key = authObj.authenticate()
-
-        self.assertEqual(username, body['credentials']['username'])
-        self.assertEqual(password, body['credentials']['key'])
-        self.assertEqual(auth_url, url)
-        self.assertEqual('auth', root_key)
-
-
-class RaxAuthenticatorTest(TestCase):
-
-    def test_authenticate(self):
-        # url is None
-        check_url_none(self, auth.RaxAuthenticator)
-
-        # url is not None, so it must not throw exception
-        url = "test_url"
-        authObj = auth.RaxAuthenticator(url=url,
-                                        type=auth.RaxAuthenticator,
-                                        client=None, username=None,
-                                        password=None, tenant=None)
-
-        def side_effect_func(url):
-            return url
-
-        mock = Mock()
-        mock.side_effect = side_effect_func
-        authObj._rax_auth = mock
-        r = authObj.authenticate()
-        self.assertEqual(url, r)
-
-    def test__rax_auth(self):
-        username = "reddwarf_user"
-        password = "reddwarf_password"
-        tenant = "tenant"
-        authObj = auth.RaxAuthenticator(url=None,
-                                        type=auth.RaxAuthenticator,
-                                        client=None, username=username,
-                                        password=password, tenant=tenant)
-
-        def side_effect_func(url, body):
-            return body
-
-        mock = Mock()
-        mock.side_effect = side_effect_func
-        authObj._authenticate = mock
-        body = authObj._rax_auth(Mock())
-
-        v = body['auth']['RAX-KSKEY:apiKeyCredentials']['username']
-        self.assertEqual(username, v)
-
-        v = body['auth']['RAX-KSKEY:apiKeyCredentials']['apiKey']
-        self.assertEqual(password, v)
-
-        v = body['auth']['RAX-KSKEY:apiKeyCredentials']['tenantName']
-        self.assertEqual(tenant, v)
-
-
-class FakeAuthTest(TestCase):
-
-    def test_authenticate(self):
-        tenant = "tenant"
-        authObj = auth.FakeAuth(url=None,
-                                type=auth.FakeAuth,
-                                client=None, username=None,
-                                password=None, tenant=tenant)
-
-        fc = authObj.authenticate()
-        public_url = "%s/%s" % ('http://localhost:8779/v1.0', tenant)
-        self.assertEqual(public_url, fc.get_public_url())
-        self.assertEqual(tenant, fc.get_token())
-
-
-class ServiceCatalogTest(TestCase):
-
-    def setUp(self):
-        super(ServiceCatalogTest, self).setUp()
-        self.orig_url_for = auth.ServiceCatalog._url_for
-        self.orig__init__ = auth.ServiceCatalog.__init__
-        auth.ServiceCatalog.__init__ = Mock(return_value=None)
-        self.test_url = "http://localhost:1234/test"
-
-    def tearDown(self):
-        super(ServiceCatalogTest, self).tearDown()
-        auth.ServiceCatalog._url_for = self.orig_url_for
-        auth.ServiceCatalog.__init__ = self.orig__init__
-
-    def test__load(self):
-        url = "random_url"
-        auth.ServiceCatalog._url_for = Mock(return_value=url)
-
-        # when service_url is None
-        scObj = auth.ServiceCatalog()
-        scObj.region = None
-        scObj.service_url = None
-        scObj._load()
-        self.assertEqual(url, scObj.public_url)
-        self.assertEqual(url, scObj.management_url)
-
-        # service url is not None
-        service_url = "service_url"
-        scObj = auth.ServiceCatalog()
-        scObj.region = None
-        scObj.service_url = service_url
-        scObj._load()
-        self.assertEqual(service_url, scObj.public_url)
-        self.assertEqual(service_url, scObj.management_url)
-
-    def test_get_token(self):
-        test_id = "test_id"
-        scObj = auth.ServiceCatalog()
-        scObj.root_key = "root_key"
-        scObj.catalog = dict()
-        scObj.catalog[scObj.root_key] = dict()
-        scObj.catalog[scObj.root_key]['token'] = dict()
-        scObj.catalog[scObj.root_key]['token']['id'] = test_id
-        self.assertEqual(test_id, scObj.get_token())
-
-    def test_get_management_url(self):
-        test_mng_url = "test_management_url"
-        scObj = auth.ServiceCatalog()
-        scObj.management_url = test_mng_url
-        self.assertEqual(test_mng_url, scObj.get_management_url())
-
-    def test_get_public_url(self):
-        test_public_url = "test_public_url"
-        scObj = auth.ServiceCatalog()
-        scObj.public_url = test_public_url
-        self.assertEqual(test_public_url, scObj.get_public_url())
-
-    def test__url_for(self):
-        scObj = auth.ServiceCatalog()
-
-        # case for no endpoint found
-        self.case_no_endpoint_match(scObj)
-
-        # case for empty service catalog
-        self.case_endpoing_with_empty_catalog(scObj)
-
-        # more than one matching endpoints
-        self.case_ambiguous_endpoint(scObj)
-
-        # happy case
-        self.case_unique_endpoint(scObj)
-
-        # testing if-statements in for-loop to iterate services in catalog
-        self.case_iterating_services_in_catalog(scObj)
-
-    def case_no_endpoint_match(self, scObj):
-        # empty endpoint list
-        scObj.catalog = dict()
-        scObj.catalog['endpoints'] = list()
-        self.assertRaises(exceptions.EndpointNotFound, scObj._url_for)
-
-        def side_effect_func_ep(attr):
-            return "test_attr_value"
-
-        # simulating dict
-        endpoint = Mock()
-        mock = Mock()
-        mock.side_effect = side_effect_func_ep
-        endpoint.__getitem__ = mock
-        scObj.catalog['endpoints'].append(endpoint)
-
-        # not-empty list but not matching endpoint
-        filter_value = "not_matching_value"
-        self.assertRaises(exceptions.EndpointNotFound, scObj._url_for,
-                          attr="test_attr", filter_value=filter_value)
-
-        filter_value = "test_attr_value"  # so that we have an endpoint match
-        scObj.root_key = "access"
-        scObj.catalog[scObj.root_key] = dict()
-        self.assertRaises(exceptions.EndpointNotFound, scObj._url_for,
-                          attr="test_attr", filter_value=filter_value)
-
-    def case_endpoing_with_empty_catalog(self, scObj):
-        # first, test with empty catalog, this should pass since
-        # there is already enpoint added
-        scObj.catalog[scObj.root_key]['serviceCatalog'] = list()
-
-        endpoint = scObj.catalog['endpoints'][0]
-        endpoint.get = Mock(return_value=self.test_url)
-        r_url = scObj._url_for(attr="test_attr",
-                               filter_value="test_attr_value")
-        self.assertEqual(self.test_url, r_url)
-
-    def case_ambiguous_endpoint(self, scObj):
-        scObj.service_type = "reddwarf"
-        scObj.service_name = "test_service_name"
-
-        def side_effect_func_service(key):
-            if key == "type":
-                return "reddwarf"
-            elif key == "name":
-                return "test_service_name"
-            return None
-
-        mock1 = Mock()
-        mock1.side_effect = side_effect_func_service
-        service1 = Mock()
-        service1.get = mock1
-
-        endpoint2 = {"test_attr": "test_attr_value"}
-        service1.__getitem__ = Mock(return_value=[endpoint2])
-        scObj.catalog[scObj.root_key]['serviceCatalog'] = [service1]
-        self.assertRaises(exceptions.AmbiguousEndpoints, scObj._url_for,
-                          attr="test_attr", filter_value="test_attr_value")
-
-    def case_unique_endpoint(self, scObj):
-        # changing the endpoint2 attribute to pass the filter
-        service1 = scObj.catalog[scObj.root_key]['serviceCatalog'][0]
-        endpoint2 = service1[0][0]
-        endpoint2["test_attr"] = "new value not matching filter"
-        r_url = scObj._url_for(attr="test_attr",
-                               filter_value="test_attr_value")
-        self.assertEqual(self.test_url, r_url)
-
-    def case_iterating_services_in_catalog(self, scObj):
-        service1 = scObj.catalog[scObj.root_key]['serviceCatalog'][0]
-
-        scObj.catalog = dict()
-        scObj.root_key = "access"
-        scObj.catalog[scObj.root_key] = dict()
-        scObj.service_type = "no_match"
-
-        scObj.catalog[scObj.root_key]['serviceCatalog'] = [service1]
-        self.assertRaises(exceptions.EndpointNotFound, scObj._url_for)
-
-        scObj.service_type = "database"
-        scObj.service_name = "no_match"
-        self.assertRaises(exceptions.EndpointNotFound, scObj._url_for)
-
-        # no endpoints and no 'serviceCatalog' in catalog => raise exception
-        scObj = auth.ServiceCatalog()
-        scObj.catalog = dict()
-        scObj.root_key = "access"
-        scObj.catalog[scObj.root_key] = dict()
-        scObj.catalog[scObj.root_key]['serviceCatalog'] = []
-        self.assertRaises(exceptions.EndpointNotFound, scObj._url_for,
-                          attr="test_attr", filter_value="test_attr_value")
diff --git a/reddwarfclient/tests/test_base.py b/reddwarfclient/tests/test_base.py
deleted file mode 100644
index 5cbd590..0000000
--- a/reddwarfclient/tests/test_base.py
+++ /dev/null
@@ -1,447 +0,0 @@
-import contextlib
-import os
-
-from testtools import TestCase
-from mock import Mock
-
-from reddwarfclient import base
-from reddwarfclient import exceptions
-from reddwarfclient import utils
-
-"""
-Unit tests for base.py
-"""
-
-
-def obj_class(self, res, loaded=True):
-    return res
-
-
-class BaseTest(TestCase):
-
-    def test_getid(self):
-        obj = "test"
-        r = base.getid(obj)
-        self.assertEqual(obj, r)
-
-        test_id = "test_id"
-        obj = Mock()
-        obj.id = test_id
-        r = base.getid(obj)
-        self.assertEqual(test_id, r)
-
-
-class ManagerTest(TestCase):
-
-    def setUp(self):
-        super(ManagerTest, self).setUp()
-        self.orig__init = base.Manager.__init__
-        base.Manager.__init__ = Mock(return_value=None)
-        self.orig_os_makedirs = os.makedirs
-
-    def tearDown(self):
-        super(ManagerTest, self).tearDown()
-        base.Manager.__init__ = self.orig__init
-        os.makedirs = self.orig_os_makedirs
-
-    def test___init__(self):
-        api = Mock()
-        base.Manager.__init__ = self.orig__init
-        manager = base.Manager(api)
-        self.assertEqual(api, manager.api)
-
-    def test_completion_cache(self):
-        manager = base.Manager()
-
-        # handling exceptions
-        mode = "w"
-        cache_type = "unittest"
-        obj_class = Mock
-        with manager.completion_cache(cache_type, obj_class, mode):
-            pass
-
-        os.makedirs = Mock(side_effect=OSError)
-        with manager.completion_cache(cache_type, obj_class, mode):
-            pass
-
-    def test_write_to_completion_cache(self):
-        manager = base.Manager()
-
-        # no cache object, nothing should happen
-        manager.write_to_completion_cache("non-exist", "val")
-
-        def side_effect_func(val):
-            return val
-
-        manager._mock_cache = Mock()
-        manager._mock_cache.write = Mock(return_value=None)
-        manager.write_to_completion_cache("mock", "val")
-        self.assertEqual(1, manager._mock_cache.write.call_count)
-
-    def _get_mock(self):
-        manager = base.Manager()
-        manager.api = Mock()
-        manager.api.client = Mock()
-
-        def side_effect_func(self, body, loaded=True):
-            return body
-
-        manager.resource_class = Mock(side_effect=side_effect_func)
-        return manager
-
-    def test__get_with_response_key_none(self):
-        manager = self._get_mock()
-        url_ = "test-url"
-        body_ = "test-body"
-        resp_ = "test-resp"
-        manager.api.client.get = Mock(return_value=(resp_, body_))
-        r = manager._get(url=url_, response_key=None)
-        self.assertEqual(body_, r)
-
-    def test__get_with_response_key(self):
-        manager = self._get_mock()
-        response_key = "response_key"
-        body_ = {response_key: "test-resp-key-body"}
-        url_ = "test_url_get"
-        manager.api.client.get = Mock(return_value=(url_, body_))
-        r = manager._get(url=url_, response_key=response_key)
-        self.assertEqual(body_[response_key], r)
-
-    def test__create(self):
-        manager = base.Manager()
-        manager.api = Mock()
-        manager.api.client = Mock()
-
-        response_key = "response_key"
-        data_ = "test-data"
-        body_ = {response_key: data_}
-        url_ = "test_url_post"
-        manager.api.client.post = Mock(return_value=(url_, body_))
-
-        return_raw = True
-        r = manager._create(url_, body_, response_key, return_raw)
-        self.assertEqual(data_, r)
-
-        return_raw = False
-
-        @contextlib.contextmanager
-        def completion_cache_mock(*arg, **kwargs):
-            yield
-
-        mock = Mock()
-        mock.side_effect = completion_cache_mock
-        manager.completion_cache = mock
-
-        manager.resource_class = Mock(return_value="test-class")
-        r = manager._create(url_, body_, response_key, return_raw)
-        self.assertEqual("test-class", r)
-
-    def get_mock_mng_api_client(self):
-        manager = base.Manager()
-        manager.api = Mock()
-        manager.api.client = Mock()
-        return manager
-
-    def test__delete(self):
-        resp_ = "test-resp"
-        body_ = "test-body"
-
-        manager = self.get_mock_mng_api_client()
-        manager.api.client.delete = Mock(return_value=(resp_, body_))
-        # _delete just calls api.client.delete, and does nothing
-        # the correctness should be tested in api class
-        manager._delete("test-url")
-        pass
-
-    def test__update(self):
-        resp_ = "test-resp"
-        body_ = "test-body"
-
-        manager = self.get_mock_mng_api_client()
-        manager.api.client.put = Mock(return_value=(resp_, body_))
-        body = manager._update("test-url", body_)
-        self.assertEqual(body_, body)
-
-
-class ManagerListTest(ManagerTest):
-
-    def setUp(self):
-        super(ManagerListTest, self).setUp()
-
-        @contextlib.contextmanager
-        def completion_cache_mock(*arg, **kwargs):
-            yield
-
-        self.manager = base.Manager()
-        self.manager.api = Mock()
-        self.manager.api.client = Mock()
-
-        self.response_key = "response_key"
-        self.data_p = ["p1", "p2"]
-        self.body_p = {self.response_key: self.data_p}
-        self.url_p = "test_url_post"
-        self.manager.api.client.post = Mock(return_value=(self.url_p,
-                                                          self.body_p))
-
-        self.data_g = ["g1", "g2", "g3"]
-        self.body_g = {self.response_key: self.data_g}
-        self.url_g = "test_url_get"
-        self.manager.api.client.get = Mock(return_value=(self.url_g,
-                                                         self.body_g))
-
-        mock = Mock()
-        mock.side_effect = completion_cache_mock
-        self.manager.completion_cache = mock
-
-    def tearDown(self):
-        super(ManagerListTest, self).tearDown()
-
-    def obj_class(self, res, loaded=True):
-        return res
-
-    def test_list_with_body_none(self):
-        body = None
-        l = self.manager._list("url", self.response_key, obj_class, body)
-        self.assertEqual(len(self.data_g), len(l))
-        for i in range(0, len(l)):
-            self.assertEqual(self.data_g[i], l[i])
-
-    def test_list_body_not_none(self):
-        body = "something"
-        l = self.manager._list("url", self.response_key, obj_class, body)
-        self.assertEqual(len(self.data_p), len(l))
-        for i in range(0, len(l)):
-            self.assertEqual(self.data_p[i], l[i])
-
-    def test_list_key_mapping(self):
-        data_ = {"values": ["p1", "p2"]}
-        body_ = {self.response_key: data_}
-        url_ = "test_url_post"
-        self.manager.api.client.post = Mock(return_value=(url_, body_))
-        l = self.manager._list("url", self.response_key,
-                               obj_class, "something")
-        data = data_["values"]
-        self.assertEqual(len(data), len(l))
-        for i in range(0, len(l)):
-            self.assertEqual(data[i], l[i])
-
-    def test_list_without_key_mapping(self):
-        data_ = {"v1": "1", "v2": "2"}
-        body_ = {self.response_key: data_}
-        url_ = "test_url_post"
-        self.manager.api.client.post = Mock(return_value=(url_, body_))
-        l = self.manager._list("url", self.response_key,
-                               obj_class, "something")
-        self.assertEqual(len(data_), len(l))
-
-
-class ManagerWithFind(TestCase):
-
-    def setUp(self):
-        super(ManagerWithFind, self).setUp()
-        self.orig__init = base.ManagerWithFind.__init__
-        base.ManagerWithFind.__init__ = Mock(return_value=None)
-        self.manager = base.ManagerWithFind()
-
-    def tearDown(self):
-        super(ManagerWithFind, self).tearDown()
-        base.ManagerWithFind.__init__ = self.orig__init
-
-    def test_find(self):
-        obj1 = Mock()
-        obj1.attr1 = "v1"
-        obj1.attr2 = "v2"
-        obj1.attr3 = "v3"
-
-        obj2 = Mock()
-        obj2.attr1 = "v1"
-        obj2.attr2 = "v2"
-
-        self.manager.list = Mock(return_value=[obj1, obj2])
-        self.manager.resource_class = Mock
-
-        # exactly one match case
-        found = self.manager.find(attr1="v1", attr2="v2", attr3="v3")
-        self.assertEqual(obj1, found)
-
-        # no match case
-        self.assertRaises(exceptions.NotFound, self.manager.find,
-                          attr1="v2", attr2="v2", attr3="v3")
-
-        # multiple matches case
-        obj2.attr3 = "v3"
-        self.assertRaises(exceptions.NoUniqueMatch, self.manager.find,
-                          attr1="v1", attr2="v2", attr3="v3")
-
-    def test_findall(self):
-        obj1 = Mock()
-        obj1.attr1 = "v1"
-        obj1.attr2 = "v2"
-        obj1.attr3 = "v3"
-
-        obj2 = Mock()
-        obj2.attr1 = "v1"
-        obj2.attr2 = "v2"
-
-        self.manager.list = Mock(return_value=[obj1, obj2])
-
-        found = self.manager.findall(attr1="v1", attr2="v2", attr3="v3")
-        self.assertEqual(1, len(found))
-        self.assertEqual(obj1, found[0])
-
-        found = self.manager.findall(attr1="v2", attr2="v2", attr3="v3")
-        self.assertEqual(0, len(found))
-
-        found = self.manager.findall(attr7="v1", attr2="v2")
-        self.assertEqual(0, len(found))
-
-    def test_list(self):
-        # this method is not yet implemented, exception expected
-        self.assertRaises(NotImplementedError, self.manager.list)
-
-
-class ResourceTest(TestCase):
-
-    def setUp(self):
-        super(ResourceTest, self).setUp()
-        self.orig___init__ = base.Resource.__init__
-
-    def tearDown(self):
-        super(ResourceTest, self).tearDown()
-        base.Resource.__init__ = self.orig___init__
-
-    def test___init__(self):
-        manager = Mock()
-        manager.write_to_completion_cache = Mock(return_value=None)
-
-        info_ = {}
-        robj = base.Resource(manager, info_)
-        self.assertEqual(0, manager.write_to_completion_cache.call_count)
-
-        info_ = {"id": "id-with-less-than-36-char"}
-        robj = base.Resource(manager, info_)
-        self.assertEqual(info_["id"], robj.id)
-        self.assertEqual(0, manager.write_to_completion_cache.call_count)
-
-        id_ = "id-with-36-char-"
-        for i in range(36 - len(id_)):
-            id_ = id_ + "-"
-        info_ = {"id": id_}
-        robj = base.Resource(manager, info_)
-        self.assertEqual(info_["id"], robj.id)
-        self.assertEqual(1, manager.write_to_completion_cache.call_count)
-
-        info_["name"] = "test-human-id"
-        # Resource.HUMAN_ID is False
-        robj = base.Resource(manager, info_)
-        self.assertEqual(info_["id"], robj.id)
-        self.assertEqual(None, robj.human_id)
-        self.assertEqual(2, manager.write_to_completion_cache.call_count)
-
-        # base.Resource.HUMAN_ID = True
-        info_["HUMAN_ID"] = True
-        robj = base.Resource(manager, info_)
-        self.assertEqual(info_["id"], robj.id)
-        self.assertEqual(info_["name"], robj.human_id)
-        self.assertEqual(4, manager.write_to_completion_cache.call_count)
-
-    def test_human_id(self):
-        manager = Mock()
-        manager.write_to_completion_cache = Mock(return_value=None)
-
-        info_ = {"name": "test-human-id"}
-        robj = base.Resource(manager, info_)
-        self.assertEqual(None, robj.human_id)
-
-        info_["HUMAN_ID"] = True
-        robj = base.Resource(manager, info_)
-        self.assertEqual(info_["name"], robj.human_id)
-        robj.name = "new-human-id"
-        self.assertEqual("new-human-id", robj.human_id)
-
-    def get_mock_resource_obj(self):
-        base.Resource.__init__ = Mock(return_value=None)
-        robj = base.Resource()
-        return robj
-
-    def test__add_details(self):
-        robj = self.get_mock_resource_obj()
-        info_ = {"name": "test-human-id", "test_attr": 5}
-        robj._add_details(info_)
-        self.assertEqual(info_["name"], robj.name)
-        self.assertEqual(info_["test_attr"], robj.test_attr)
-
-    def test___getattr__(self):
-        robj = self.get_mock_resource_obj()
-        info_ = {"name": "test-human-id", "test_attr": 5}
-        robj._add_details(info_)
-        self.assertEqual(info_["test_attr"], robj.__getattr__("test_attr"))
-
-        # TODO: looks like causing infinite recursive calls
-        #robj.__getattr__("test_non_exist_attr")
-
-    def test___repr__(self):
-        robj = self.get_mock_resource_obj()
-        info_ = {"name": "test-human-id", "test_attr": 5}
-        robj._add_details(info_)
-
-        expected = "<Resource name=test-human-id, test_attr=5>"
-        self.assertEqual(expected, robj.__repr__())
-
-    def test_get(self):
-        robj = self.get_mock_resource_obj()
-        manager = Mock()
-        manager.get = None
-
-        robj.manager = object()
-        robj.get()
-
-        manager = Mock()
-        robj.manager = Mock()
-
-        robj.id = "id"
-        new = Mock()
-        new._info = {"name": "test-human-id", "test_attr": 5}
-        robj.manager.get = Mock(return_value=new)
-        robj.get()
-        self.assertEqual("test-human-id", robj.name)
-        self.assertEqual(5, robj.test_attr)
-
-    def tes___eq__(self):
-        robj = self.get_mock_resource_obj()
-        other = base.Resource()
-
-        info_ = {"name": "test-human-id", "test_attr": 5}
-        robj._info = info_
-        other._info = {}
-        self.assertNotTrue(robj.__eq__(other))
-
-        robj._info = info_
-        self.assertTrue(robj.__eq__(other))
-
-        robj.id = "rid"
-        other.id = "oid"
-        self.assertNotTrue(robj.__eq__(other))
-
-        other.id = "rid"
-        self.assertTrue(robj.__eq__(other))
-
-        # not instance of the same class
-        other = Mock()
-        self.assertNotTrue(robj.__eq__(other))
-
-    def test_is_loaded(self):
-        robj = self.get_mock_resource_obj()
-        robj._loaded = True
-        self.assertTrue(robj.is_loaded())
-
-        robj._loaded = False
-        self.assertFalse(robj.is_loaded())
-
-    def test_set_loaded(self):
-        robj = self.get_mock_resource_obj()
-        robj.set_loaded(True)
-        self.assertTrue(robj._loaded)
-
-        robj.set_loaded(False)
-        self.assertFalse(robj._loaded)
diff --git a/reddwarfclient/tests/test_client.py b/reddwarfclient/tests/test_client.py
deleted file mode 100644
index d52331f..0000000
--- a/reddwarfclient/tests/test_client.py
+++ /dev/null
@@ -1,322 +0,0 @@
-import contextlib
-import os
-import logging
-import httplib2
-import time
-
-from testtools import TestCase
-from mock import Mock
-
-from reddwarfclient import client
-from reddwarfclient import exceptions
-from reddwarfclient import utils
-
-"""
-Unit tests for client.py
-"""
-
-
-class ClientTest(TestCase):
-
-    def test_log_to_streamhandler(self):
-        client.log_to_streamhandler()
-        self.assertTrue(client._logger.level == logging.DEBUG)
-
-
-class ReddwarfHTTPClientTest(TestCase):
-
-    def setUp(self):
-        super(ReddwarfHTTPClientTest, self).setUp()
-        self.orig__init = client.ReddwarfHTTPClient.__init__
-        client.ReddwarfHTTPClient.__init__ = Mock(return_value=None)
-        self.hc = client.ReddwarfHTTPClient()
-        self.hc.auth_token = "test-auth-token"
-        self.hc.service_url = "test-service-url/"
-        self.hc.tenant = "test-tenant"
-
-        self.__debug_lines = list()
-
-        self.orig_client__logger = client._logger
-        client._logger = Mock()
-
-        self.orig_time = time.time
-        self.orig_htttp_request = httplib2.Http.request
-
-    def tearDown(self):
-        super(ReddwarfHTTPClientTest, self).tearDown()
-        client.ReddwarfHTTPClient.__init__ = self.orig__init
-        client._logger = self.orig_client__logger
-        time.time = self.orig_time
-        httplib2.Http.request = self.orig_htttp_request
-
-    def side_effect_func_for_moc_debug(self, s, *args):
-        self.__debug_lines.append(s)
-
-    def test___init__(self):
-        client.ReddwarfHTTPClient.__init__ = self.orig__init
-
-        user = "test-user"
-        password = "test-password"
-        tenant = "test-tenant"
-        auth_url = "http://test-auth-url/"
-        service_name = None
-
-        # when there is no auth_strategy provided
-        self.assertRaises(ValueError, client.ReddwarfHTTPClient, user,
-                          password, tenant, auth_url, service_name)
-
-        hc = client.ReddwarfHTTPClient(user, password, tenant, auth_url,
-                                       service_name, auth_strategy="fake")
-        self.assertEqual("http://test-auth-url", hc.auth_url)
-
-        #  auth_url is none
-        hc = client.ReddwarfHTTPClient(user, password, tenant, None,
-                                       service_name, auth_strategy="fake")
-        self.assertEqual(None, hc.auth_url)
-
-    def test_get_timings(self):
-        self.hc.times = ["item1", "item2"]
-        self.assertEqual(2, len(self.hc.get_timings()))
-        self.assertEqual("item1", self.hc.get_timings()[0])
-        self.assertEqual("item2", self.hc.get_timings()[1])
-
-    def test_http_log(self):
-        self.hc.simple_log = Mock(return_value=None)
-        self.hc.pretty_log = Mock(return_value=None)
-
-        client.RDC_PP = False
-        self.hc.http_log(None, None, None, None)
-        self.assertEqual(1, self.hc.simple_log.call_count)
-
-        client.RDC_PP = True
-        self.hc.http_log(None, None, None, None)
-        self.assertEqual(1, self.hc.pretty_log.call_count)
-
-    def test_simple_log(self):
-        client._logger.isEnabledFor = Mock(return_value=False)
-        self.hc.simple_log(None, None, None, None)
-        self.assertEqual(0, len(self.__debug_lines))
-
-        client._logger.isEnabledFor = Mock(return_value=True)
-        se = self.side_effect_func_for_moc_debug
-        client._logger.debug = Mock(side_effect=se)
-        self.hc.simple_log(['item1', 'GET', 'item3', 'POST', 'item5'],
-                           {'headers': {'e1': 'e1-v', 'e2': 'e2-v'},
-                            'body': 'body'}, None, None)
-        self.assertEqual(3, len(self.__debug_lines))
-        self.assertTrue(self.__debug_lines[0].startswith('REQ: curl -i'))
-        self.assertTrue(self.__debug_lines[1].startswith('REQ BODY:'))
-        self.assertTrue(self.__debug_lines[2].startswith('RESP:'))
-
-    def test_pretty_log(self):
-        client._logger.isEnabledFor = Mock(return_value=False)
-        self.hc.pretty_log(None, None, None, None)
-        self.assertEqual(0, len(self.__debug_lines))
-
-        client._logger.isEnabledFor = Mock(return_value=True)
-        se = self.side_effect_func_for_moc_debug
-        client._logger.debug = Mock(side_effect=se)
-        self.hc.pretty_log(['item1', 'GET', 'item3', 'POST', 'item5'],
-                           {'headers': {'e1': 'e1-v', 'e2': 'e2-v'},
-                            'body': 'body'}, None, None)
-        self.assertEqual(5, len(self.__debug_lines))
-        self.assertTrue(self.__debug_lines[0].startswith('REQUEST:'))
-        self.assertTrue(self.__debug_lines[1].startswith('curl -i'))
-        self.assertTrue(self.__debug_lines[2].startswith('BODY:'))
-        self.assertTrue(self.__debug_lines[3].startswith('RESPONSE HEADERS:'))
-        self.assertTrue(self.__debug_lines[4].startswith('RESPONSE BODY'))
-
-        # no body case
-        self.__debug_lines = list()
-        self.hc.pretty_log(['item1', 'GET', 'item3', 'POST', 'item5'],
-                           {'headers': {'e1': 'e1-v', 'e2': 'e2-v'}},
-                           None, None)
-        self.assertEqual(4, len(self.__debug_lines))
-        self.assertTrue(self.__debug_lines[0].startswith('REQUEST:'))
-        self.assertTrue(self.__debug_lines[1].startswith('curl -i'))
-        self.assertTrue(self.__debug_lines[2].startswith('RESPONSE HEADERS:'))
-        self.assertTrue(self.__debug_lines[3].startswith('RESPONSE BODY'))
-
-    def test_request(self):
-        self.hc.USER_AGENT = "user-agent"
-        resp = Mock()
-        body = Mock()
-        resp.status = 200
-        httplib2.Http.request = Mock(return_value=(resp, body))
-        self.hc.morph_response_body = Mock(return_value=body)
-        r, b = self.hc.request()
-        self.assertEqual(resp, r)
-        self.assertEqual(body, b)
-        self.assertEqual((resp, body), self.hc.last_response)
-
-        httplib2.Http.request = Mock(return_value=(resp, None))
-        r, b = self.hc.request()
-        self.assertEqual(resp, r)
-        self.assertEqual(None, b)
-
-        status_list = [400, 401, 403, 404, 408, 409, 413, 500, 501]
-        for status in status_list:
-            resp.status = status
-            self.assertRaises(ValueError, self.hc.request)
-
-        exception = exceptions.ResponseFormatError
-        self.hc.morph_response_body = Mock(side_effect=exception)
-        self.assertRaises(Exception, self.hc.request)
-
-    def test_raise_error_from_status(self):
-        resp = Mock()
-        resp.status = 200
-        self.hc.raise_error_from_status(resp, Mock())
-
-        status_list = [400, 401, 403, 404, 408, 409, 413, 500, 501]
-        for status in status_list:
-            resp.status = status
-            self.assertRaises(ValueError,
-                              self.hc.raise_error_from_status, resp, Mock())
-
-    def test_morph_request(self):
-        kwargs = dict()
-        kwargs['headers'] = dict()
-        kwargs['body'] = ['body', {'item1': 'value1'}]
-        self.hc.morph_request(kwargs)
-        expected = {'body': '["body", {"item1": "value1"}]',
-                    'headers': {'Content-Type': 'application/json',
-                                'Accept': 'application/json'}}
-        self.assertEqual(expected, kwargs)
-
-    def test_morph_response_body(self):
-        body_string = '["body", {"item1": "value1"}]'
-        expected = ['body', {'item1': 'value1'}]
-        self.assertEqual(expected, self.hc.morph_response_body(body_string))
-        body_string = '["body", {"item1": }]'
-        self.assertRaises(exceptions.ResponseFormatError,
-                          self.hc.morph_response_body, body_string)
-
-    def test__time_request(self):
-        self.__time = 0
-
-        def side_effect_func():
-            self.__time = self.__time + 1
-            return self.__time
-
-        time.time = Mock(side_effect=side_effect_func)
-        self.hc.request = Mock(return_value=("mock-response", "mock-body"))
-        self.hc.times = list()
-        resp, body = self.hc._time_request("test-url", "Get")
-        self.assertEqual(("mock-response", "mock-body"), (resp, body))
-        self.assertEqual([('Get test-url', 1, 2)], self.hc.times)
-
-    def mock_time_request_func(self):
-        def side_effect_func(url, method, **kwargs):
-            return url, method
-        self.hc._time_request = Mock(side_effect=side_effect_func)
-
-    def test__cs_request(self):
-        self.mock_time_request_func()
-        resp, body = self.hc._cs_request("test-url", "GET")
-        self.assertEqual(('test-service-url/test-url', 'GET'), (resp, body))
-
-        self.hc.authenticate = Mock(side_effect=ValueError)
-        self.hc.auth_token = None
-        self.hc.service_url = None
-        self.assertRaises(ValueError, self.hc._cs_request, "test-url", "GET")
-
-        self.hc.authenticate = Mock(return_value=None)
-        self.hc.service_url = "test-service-url/"
-
-        def side_effect_func_time_req(url, method, **kwargs):
-            raise exceptions.Unauthorized(None)
-
-        self.hc._time_request = Mock(side_effect=side_effect_func_time_req)
-        self.assertRaises(exceptions.Unauthorized,
-                          self.hc._cs_request, "test-url", "GET")
-
-    def test_get(self):
-        self.mock_time_request_func()
-        resp, body = self.hc.get("test-url")
-        self.assertEqual(("test-service-url/test-url", "GET"), (resp, body))
-
-    def test_post(self):
-        self.mock_time_request_func()
-        resp, body = self.hc.post("test-url")
-        self.assertEqual(("test-service-url/test-url", "POST"), (resp, body))
-
-    def test_put(self):
-        self.mock_time_request_func()
-        resp, body = self.hc.put("test-url")
-        self.assertEqual(("test-service-url/test-url", "PUT"), (resp, body))
-
-    def test_delete(self):
-        self.mock_time_request_func()
-        resp, body = self.hc.delete("test-url")
-        self.assertEqual(("test-service-url/test-url", "DELETE"), (resp, body))
-
-    def test_authenticate(self):
-        self.hc.authenticator = Mock()
-        catalog = Mock()
-        catalog.get_public_url = Mock(return_value="public-url")
-        catalog.get_management_url = Mock(return_value="mng-url")
-        catalog.get_token = Mock(return_value="test-token")
-
-        self.__auth_calls = []
-
-        def side_effect_func(token, url):
-            self.__auth_calls = [token, url]
-
-        self.hc.authenticate_with_token = Mock(side_effect=side_effect_func)
-        self.hc.authenticator.authenticate = Mock(return_value=catalog)
-        self.hc.endpoint_type = "publicURL"
-        self.hc.authenticate()
-        self.assertEqual(["test-token", None],
-                         self.__auth_calls)
-
-        self.__auth_calls = []
-        self.hc.service_url = None
-        self.hc.authenticate()
-        self.assertEqual(["test-token", "public-url"], self.__auth_calls)
-
-        self.__auth_calls = []
-        self.hc.endpoint_type = "adminURL"
-        self.hc.authenticate()
-        self.assertEqual(["test-token", "mng-url"], self.__auth_calls)
-
-    def test_authenticate_with_token(self):
-        self.hc.service_url = None
-        self.assertRaises(exceptions.ServiceUrlNotGiven,
-                          self.hc.authenticate_with_token, "token", None)
-        self.hc.authenticate_with_token("token", "test-url")
-        self.assertEqual("test-url", self.hc.service_url)
-        self.assertEqual("token", self.hc.auth_token)
-
-
-class DbaasTest(TestCase):
-
-    def setUp(self):
-        super(DbaasTest, self).setUp()
-        self.orig__init = client.ReddwarfHTTPClient.__init__
-        client.ReddwarfHTTPClient.__init__ = Mock(return_value=None)
-        self.dbaas = client.Dbaas("user", "api-key")
-
-    def tearDown(self):
-        super(DbaasTest, self).tearDown()
-        client.ReddwarfHTTPClient.__init__ = self.orig__init
-
-    def test___init__(self):
-        client.ReddwarfHTTPClient.__init__ = Mock(return_value=None)
-        self.assertNotEqual(None, self.dbaas.mgmt)
-
-    def test_set_management_url(self):
-        self.dbaas.set_management_url("test-management-url")
-        self.assertEqual("test-management-url",
-                         self.dbaas.client.management_url)
-
-    def test_get_timings(self):
-        __timings = {'start': 1, 'end': 2}
-        self.dbaas.client.get_timings = Mock(return_value=__timings)
-        self.assertEqual(__timings, self.dbaas.get_timings())
-
-    def test_authenticate(self):
-        mock_auth = Mock(return_value=None)
-        self.dbaas.client.authenticate = mock_auth
-        self.dbaas.authenticate()
-        self.assertEqual(1, mock_auth.call_count)
diff --git a/reddwarfclient/tests/test_common.py b/reddwarfclient/tests/test_common.py
deleted file mode 100644
index b038a05..0000000
--- a/reddwarfclient/tests/test_common.py
+++ /dev/null
@@ -1,395 +0,0 @@
-import sys
-import optparse
-import json
-import collections
-
-from testtools import TestCase
-from mock import Mock
-
-from reddwarfclient import common
-from reddwarfclient import client
-
-"""
- unit tests for common.py
-"""
-
-
-class CommonTest(TestCase):
-
-    def setUp(self):
-        super(CommonTest, self).setUp()
-        self.orig_sys_exit = sys.exit
-        sys.exit = Mock(return_value=None)
-
-    def tearDown(self):
-        super(CommonTest, self).tearDown()
-        sys.exit = self.orig_sys_exit
-
-    def test_methods_of(self):
-        class DummyClass:
-            def dummyMethod(self):
-                print("just for test")
-
-        obj = DummyClass()
-        result = common.methods_of(obj)
-        self.assertEqual(1, len(result))
-        method = result['dummyMethod']
-        self.assertIsNotNone(method)
-
-    def test_check_for_exceptions(self):
-        status = [400, 422, 500]
-        for s in status:
-            resp = Mock()
-            resp.status = s
-            self.assertRaises(ValueError,
-                              common.check_for_exceptions, resp, "body")
-
-        # a no-exception case
-        resp = Mock()
-        resp.status = 200
-        common.check_for_exceptions(resp, "body")
-
-    def test_print_actions(self):
-        cmd = "test-cmd"
-        actions = {"test": "test action", "help": "help action"}
-        common.print_actions(cmd, actions)
-        pass
-
-    def test_print_commands(self):
-        commands = {"cmd-1": "cmd 1", "cmd-2": "cmd 2"}
-        common.print_commands(commands)
-        pass
-
-    def test_limit_url(self):
-        url_ = "test-url"
-        limit_ = None
-        marker_ = None
-        self.assertEqual(url_, common.limit_url(url_))
-
-        limit_ = "test-limit"
-        marker_ = "test-marker"
-        expected = "test-url?marker=test-marker&limit=test-limit"
-        self.assertEqual(expected,
-                         common.limit_url(url_, limit=limit_, marker=marker_))
-
-
-class CliOptionsTest(TestCase):
-
-    def check_default_options(self, co):
-        self.assertEqual(None, co.username)
-        self.assertEqual(None, co.apikey)
-        self.assertEqual(None, co.tenant_id)
-        self.assertEqual(None, co.auth_url)
-        self.assertEqual('keystone', co.auth_type)
-        self.assertEqual('database', co.service_type)
-        self.assertEqual('reddwarf', co.service_name)
-        self.assertEqual('RegionOne', co.region)
-        self.assertEqual(None, co.service_url)
-        self.assertFalse(co.insecure)
-        self.assertFalse(co.verbose)
-        self.assertFalse(co.debug)
-        self.assertEqual(None, co.token)
-        self.assertEqual(None, co.xml)
-
-    def check_option(self, oparser, option_name):
-        option = oparser.get_option("--%s" % option_name)
-        self.assertNotEqual(None, option)
-        if option_name in common.CliOptions.DEFAULT_VALUES:
-            self.assertEqual(common.CliOptions.DEFAULT_VALUES[option_name],
-                             option.default)
-
-    def test___init__(self):
-        co = common.CliOptions()
-        self.check_default_options(co)
-
-    def test_deafult(self):
-        co = common.CliOptions.default()
-        self.check_default_options(co)
-
-    def test_load_from_file(self):
-        co = common.CliOptions.load_from_file()
-        self.check_default_options(co)
-
-    def test_create_optparser(self):
-        option_names = ["verbose", "debug", "auth_url", "username", "apikey",
-                        "tenant_id", "auth_type", "service_type",
-                        "service_name", "service_type", "service_name",
-                        "service_url", "region", "insecure", "token",
-                        "xml", "secure", "json", "terse", "hide-debug"]
-
-        oparser = common.CliOptions.create_optparser(True)
-        for option_name in option_names:
-            self.check_option(oparser, option_name)
-
-        oparser = common.CliOptions.create_optparser(False)
-        for option_name in option_names:
-            self.check_option(oparser, option_name)
-
-
-class ArgumentRequiredTest(TestCase):
-
-    def setUp(self):
-        super(ArgumentRequiredTest, self).setUp()
-        self.param = "test-param"
-        self.arg_req = common.ArgumentRequired(self.param)
-
-    def test___init__(self):
-        self.assertEqual(self.param, self.arg_req.param)
-
-    def test___str__(self):
-        expected = 'Argument "--%s" required.' % self.param
-        self.assertEqual(expected, self.arg_req.__str__())
-
-
-class CommandsBaseTest(TestCase):
-
-    def setUp(self):
-        super(CommandsBaseTest, self).setUp()
-        self.orig_sys_exit = sys.exit
-        sys.exit = Mock(return_value=None)
-        parser = common.CliOptions().create_optparser(False)
-        self.cmd_base = common.CommandsBase(parser)
-
-    def tearDown(self):
-        super(CommandsBaseTest, self).tearDown()
-        sys.exit = self.orig_sys_exit
-
-    def test___init__(self):
-        self.assertNotEqual(None, self.cmd_base)
-
-    def test__get_client(self):
-        client.log_to_streamhandler = Mock(return_value=None)
-        expected = Mock()
-        client.Dbaas = Mock(return_value=expected)
-
-        self.cmd_base.xml = Mock()
-        self.cmd_base.verbose = False
-        r = self.cmd_base._get_client()
-        self.assertEqual(expected, r)
-
-        self.cmd_base.xml = None
-        self.cmd_base.verbose = True
-        r = self.cmd_base._get_client()
-        self.assertEqual(expected, r)
-
-        # test debug true
-        self.cmd_base.debug = True
-        client.Dbaas = Mock(side_effect=ValueError)
-        self.assertRaises(ValueError, self.cmd_base._get_client)
-
-    def test__safe_exec(self):
-        func = Mock(return_value="test")
-        self.cmd_base.debug = True
-        r = self.cmd_base._safe_exec(func)
-        self.assertEqual("test", r)
-
-        self.cmd_base.debug = False
-        r = self.cmd_base._safe_exec(func)
-        self.assertEqual("test", r)
-
-        func = Mock(side_effect=ValueError)  # an arbitrary exception
-        r = self.cmd_base._safe_exec(func)
-        self.assertEqual(None, r)
-
-    def test__prepare_parser(self):
-        parser = optparse.OptionParser()
-        common.CommandsBase.params = ["test_1", "test_2"]
-        self.cmd_base._prepare_parser(parser)
-        option = parser.get_option("--%s" % "test_1")
-        self.assertNotEqual(None, option)
-        option = parser.get_option("--%s" % "test_2")
-        self.assertNotEqual(None, option)
-
-    def test__parse_options(self):
-        parser = optparse.OptionParser()
-        parser.add_option("--%s" % "test_1", default="test_1v")
-        parser.add_option("--%s" % "test_2", default="test_2v")
-        self.cmd_base._parse_options(parser)
-        self.assertEqual("test_1v", self.cmd_base.test_1)
-        self.assertEqual("test_2v", self.cmd_base.test_2)
-
-    def test__require(self):
-        self.assertRaises(common.ArgumentRequired,
-                          self.cmd_base._require, "attr_1")
-        self.cmd_base.attr_1 = None
-        self.assertRaises(common.ArgumentRequired,
-                          self.cmd_base._require, "attr_1")
-        self.cmd_base.attr_1 = "attr_v1"
-        self.cmd_base._require("attr_1")
-
-    def test__make_list(self):
-        self.assertRaises(AttributeError, self.cmd_base._make_list, "attr1")
-        self.cmd_base.attr1 = "v1,v2"
-        self.cmd_base._make_list("attr1")
-        self.assertEqual(["v1", "v2"], self.cmd_base.attr1)
-        self.cmd_base.attr1 = ["v3"]
-        self.cmd_base._make_list("attr1")
-        self.assertEqual(["v3"], self.cmd_base.attr1)
-
-    def test__pretty_print(self):
-        func = Mock(return_value=None)
-        self.cmd_base.verbose = True
-        self.assertEqual(None, self.cmd_base._pretty_print(func))
-        self.cmd_base.verbose = False
-        self.assertEqual(None, self.cmd_base._pretty_print(func))
-
-    def test__dumps(self):
-        json.dumps = Mock(return_value="test-dump")
-        self.assertEqual("test-dump", self.cmd_base._dumps("item"))
-
-    def test__pretty_list(self):
-        func = Mock(return_value=None)
-        self.cmd_base.verbose = True
-        self.assertEqual(None, self.cmd_base._pretty_list(func))
-        self.cmd_base.verbose = False
-        self.assertEqual(None, self.cmd_base._pretty_list(func))
-        item = Mock(return_value="test")
-        item._info = "info"
-        func = Mock(return_value=[item])
-        self.assertEqual(None, self.cmd_base._pretty_list(func))
-
-    def test__pretty_paged(self):
-        self.cmd_base.limit = "5"
-        func = Mock(return_value=None)
-        self.cmd_base.verbose = True
-        self.assertEqual(None, self.cmd_base._pretty_paged(func))
-
-        self.cmd_base.verbose = False
-
-        class MockIterable(collections.Iterable):
-            links = ["item"]
-            count = 1
-
-            def __iter__(self):
-                return ["item1"]
-
-            def __len__(self):
-                return count
-
-        ret = MockIterable()
-        func = Mock(return_value=ret)
-        self.assertEqual(None, self.cmd_base._pretty_paged(func))
-
-        ret.count = 0
-        self.assertEqual(None, self.cmd_base._pretty_paged(func))
-
-        func = Mock(side_effect=ValueError)
-        self.assertEqual(None, self.cmd_base._pretty_paged(func))
-        self.cmd_base.debug = True
-        self.cmd_base.marker = Mock()
-        self.assertRaises(ValueError, self.cmd_base._pretty_paged, func)
-
-
-class AuthTest(TestCase):
-
-    def setUp(self):
-        super(AuthTest, self).setUp()
-        self.orig_sys_exit = sys.exit
-        sys.exit = Mock(return_value=None)
-        self.parser = common.CliOptions().create_optparser(False)
-        self.auth = common.Auth(self.parser)
-
-    def tearDown(self):
-        super(AuthTest, self).tearDown()
-        sys.exit = self.orig_sys_exit
-
-    def test___init__(self):
-        self.assertEqual(None, self.auth.dbaas)
-        self.assertEqual(None, self.auth.apikey)
-
-    def test_login(self):
-        self.auth.username = "username"
-        self.auth.apikey = "apikey"
-        self.auth.tenant_id = "tenant_id"
-        self.auth.auth_url = "auth_url"
-        dbaas = Mock()
-        dbaas.authenticate = Mock(return_value=None)
-        dbaas.client = Mock()
-        dbaas.client.auth_token = Mock()
-        dbaas.client.service_url = Mock()
-        self.auth._get_client = Mock(return_value=dbaas)
-        self.auth.login()
-
-        self.auth.debug = True
-        self.auth._get_client = Mock(side_effect=ValueError)
-        self.assertRaises(ValueError, self.auth.login)
-
-        self.auth.debug = False
-        self.auth.login()
-
-
-class AuthedCommandsBaseTest(TestCase):
-
-    def setUp(self):
-        super(AuthedCommandsBaseTest, self).setUp()
-        self.orig_sys_exit = sys.exit
-        sys.exit = Mock(return_value=None)
-
-    def tearDown(self):
-        super(AuthedCommandsBaseTest, self).tearDown()
-        sys.exit = self.orig_sys_exit
-
-    def test___init__(self):
-        parser = common.CliOptions().create_optparser(False)
-        common.AuthedCommandsBase.debug = True
-        dbaas = Mock()
-        dbaas.authenticate = Mock(return_value=None)
-        dbaas.client = Mock()
-        dbaas.client.auth_token = Mock()
-        dbaas.client.service_url = Mock()
-        dbaas.client.authenticate_with_token = Mock()
-        common.AuthedCommandsBase._get_client = Mock(return_value=dbaas)
-        authed_cmd = common.AuthedCommandsBase(parser)
-
-
-class PaginatedTest(TestCase):
-
-    def setUp(self):
-        super(PaginatedTest, self).setUp()
-        self.items_ = ["item1", "item2"]
-        self.next_marker_ = "next-marker"
-        self.links_ = ["link1", "link2"]
-        self.pgn = common.Paginated(self.items_, self.next_marker_,
-                                    self.links_)
-
-    def tearDown(self):
-        super(PaginatedTest, self).tearDown()
-
-    def test___init__(self):
-        self.assertEqual(self.items_, self.pgn.items)
-        self.assertEqual(self.next_marker_, self.pgn.next)
-        self.assertEqual(self.links_, self.pgn.links)
-
-    def test___len__(self):
-        self.assertEqual(len(self.items_), self.pgn.__len__())
-
-    def test___iter__(self):
-        itr_expected = self.items_.__iter__()
-        itr = self.pgn.__iter__()
-        self.assertEqual(itr_expected.next(), itr.next())
-        self.assertEqual(itr_expected.next(), itr.next())
-        self.assertRaises(StopIteration, itr_expected.next)
-        self.assertRaises(StopIteration, itr.next)
-
-    def test___getitem__(self):
-        self.assertEqual(self.items_[0], self.pgn.__getitem__(0))
-
-    def test___setitem__(self):
-        self.pgn.__setitem__(0, "new-item")
-        self.assertEqual("new-item", self.pgn.items[0])
-
-    def test___delitem(self):
-        del self.pgn[0]
-        self.assertEqual(1, self.pgn.__len__())
-
-    def test___reversed__(self):
-        itr = self.pgn.__reversed__()
-        expected = ["item2", "item1"]
-        self.assertEqual("item2", itr.next())
-        self.assertEqual("item1", itr.next())
-        self.assertRaises(StopIteration, itr.next)
-
-    def test___contains__(self):
-        self.assertTrue(self.pgn.__contains__("item1"))
-        self.assertTrue(self.pgn.__contains__("item2"))
-        self.assertFalse(self.pgn.__contains__("item3"))
diff --git a/reddwarfclient/tests/test_instances.py b/reddwarfclient/tests/test_instances.py
deleted file mode 100644
index 2131d26..0000000
--- a/reddwarfclient/tests/test_instances.py
+++ /dev/null
@@ -1,176 +0,0 @@
-from testtools import TestCase
-from mock import Mock
-
-from reddwarfclient import instances
-from reddwarfclient import base
-
-"""
-Unit tests for instances.py
-"""
-
-
-class InstanceTest(TestCase):
-
-    def setUp(self):
-        super(InstanceTest, self).setUp()
-        self.orig__init = instances.Instance.__init__
-        instances.Instance.__init__ = Mock(return_value=None)
-        self.instance = instances.Instance()
-        self.instance.manager = Mock()
-
-    def tearDown(self):
-        super(InstanceTest, self).tearDown()
-        instances.Instance.__init__ = self.orig__init
-
-    def test___repr__(self):
-        self.instance.name = "instance-1"
-        self.assertEqual('<Instance: instance-1>', self.instance.__repr__())
-
-    def test_list_databases(self):
-        db_list = ['database1', 'database2']
-        self.instance.manager.databases = Mock()
-        self.instance.manager.databases.list = Mock(return_value=db_list)
-        self.assertEqual(db_list, self.instance.list_databases())
-
-    def test_delete(self):
-        db_delete_mock = Mock(return_value=None)
-        self.instance.manager.delete = db_delete_mock
-        self.instance.delete()
-        self.assertEqual(1, db_delete_mock.call_count)
-
-    def test_restart(self):
-        db_restart_mock = Mock(return_value=None)
-        self.instance.manager.restart = db_restart_mock
-        self.instance.id = 1
-        self.instance.restart()
-        self.assertEqual(1, db_restart_mock.call_count)
-
-
-class InstancesTest(TestCase):
-
-    def setUp(self):
-        super(InstancesTest, self).setUp()
-        self.orig__init = instances.Instances.__init__
-        instances.Instances.__init__ = Mock(return_value=None)
-        self.instances = instances.Instances()
-        self.instances.api = Mock()
-        self.instances.api.client = Mock()
-        self.instances.resource_class = Mock(return_value="instance-1")
-
-        self.orig_base_getid = base.getid
-        base.getid = Mock(return_value="instance1")
-
-    def tearDown(self):
-        super(InstancesTest, self).tearDown()
-        instances.Instances.__init__ = self.orig__init
-        base.getid = self.orig_base_getid
-
-    def test_create(self):
-        def side_effect_func(path, body, inst):
-            return path, body, inst
-
-        self.instances._create = Mock(side_effect=side_effect_func)
-        p, b, i = self.instances.create("test-name", 103, "test-volume",
-                                        ['db1', 'db2'], ['u1', 'u2'])
-        self.assertEqual("/instances", p)
-        self.assertEqual("instance", i)
-        self.assertEqual(['db1', 'db2'], b["instance"]["databases"])
-        self.assertEqual(['u1', 'u2'], b["instance"]["users"])
-        self.assertEqual("test-name", b["instance"]["name"])
-        self.assertEqual("test-volume", b["instance"]["volume"])
-        self.assertEqual(103, b["instance"]["flavorRef"])
-
-    def test__list(self):
-        self.instances.api.client.get = Mock(return_value=('resp', None))
-        self.assertRaises(Exception, self.instances._list, "url", None)
-
-        body = Mock()
-        body.get = Mock(return_value=[{'href': 'http://test.net/test_file',
-                                       'rel': 'next'}])
-        body.__getitem__ = Mock(return_value='instance1')
-        #self.instances.resource_class = Mock(return_value="instance-1")
-        self.instances.api.client.get = Mock(return_value=('resp', body))
-        _expected = [{'href': 'http://test.net/test_file', 'rel': 'next'}]
-        self.assertEqual(_expected, self.instances._list("url", None).links)
-
-    def test_list(self):
-        def side_effect_func(path, inst, limit, marker):
-            return path, inst, limit, marker
-
-        self.instances._list = Mock(side_effect=side_effect_func)
-        limit_ = "test-limit"
-        marker_ = "test-marker"
-        expected = ("/instances", "instances", limit_, marker_)
-        self.assertEqual(expected, self.instances.list(limit_, marker_))
-
-    def test_get(self):
-        def side_effect_func(path, inst):
-            return path, inst
-
-        self.instances._get = Mock(side_effect=side_effect_func)
-        self.assertEqual(('/instances/instance1', 'instance'),
-                         self.instances.get(1))
-
-    def test_delete(self):
-        resp = Mock()
-        resp.status = 200
-        body = None
-        self.instances.api.client.delete = Mock(return_value=(resp, body))
-        self.instances.delete('instance1')
-        resp.status = 500
-        self.assertRaises(ValueError, self.instances.delete, 'instance1')
-
-    def test__action(self):
-        body = Mock()
-        resp = Mock()
-        resp.status = 200
-        self.instances.api.client.post = Mock(return_value=(resp, body))
-        self.assertEqual('instance-1', self.instances._action(1, body))
-
-        self.instances.api.client.post = Mock(return_value=(resp, None))
-        self.assertEqual(None, self.instances._action(1, body))
-
-    def _set_action_mock(self):
-        def side_effect_func(instance_id, body):
-            self._instance_id = instance_id
-            self._body = body
-
-        self._instance_id = None
-        self._body = None
-        self.instances._action = Mock(side_effect=side_effect_func)
-
-    def test_resize_volume(self):
-        self._set_action_mock()
-        self.instances.resize_volume(152, 512)
-        self.assertEqual(152, self._instance_id)
-        self.assertEqual({"resize": {"volume": {"size": 512}}}, self._body)
-
-    def test_resize_instance(self):
-        self._set_action_mock()
-        self.instances.resize_instance(4725, 103)
-        self.assertEqual(4725, self._instance_id)
-        self.assertEqual({"resize": {"flavorRef": 103}}, self._body)
-
-    def test_restart(self):
-        self._set_action_mock()
-        self.instances.restart(253)
-        self.assertEqual(253, self._instance_id)
-        self.assertEqual({'restart': {}}, self._body)
-
-    def test_reset_password(self):
-        self._set_action_mock()
-        self.instances.reset_password(634)
-        self.assertEqual(634, self._instance_id)
-        self.assertEqual({'reset-password': {}}, self._body)
-
-
-class InstanceStatusTest(TestCase):
-
-    def test_constants(self):
-        self.assertEqual("ACTIVE", instances.InstanceStatus.ACTIVE)
-        self.assertEqual("BLOCKED", instances.InstanceStatus.BLOCKED)
-        self.assertEqual("BUILD", instances.InstanceStatus.BUILD)
-        self.assertEqual("FAILED", instances.InstanceStatus.FAILED)
-        self.assertEqual("REBOOT", instances.InstanceStatus.REBOOT)
-        self.assertEqual("RESIZE", instances.InstanceStatus.RESIZE)
-        self.assertEqual("SHUTDOWN", instances.InstanceStatus.SHUTDOWN)
diff --git a/reddwarfclient/tests/test_limits.py b/reddwarfclient/tests/test_limits.py
deleted file mode 100644
index fda182c..0000000
--- a/reddwarfclient/tests/test_limits.py
+++ /dev/null
@@ -1,79 +0,0 @@
-from testtools import TestCase
-from mock import Mock
-from reddwarfclient import limits
-
-
-class LimitsTest(TestCase):
-    """
-    This class tests the calling code for the Limits API
-    """
-
-    def setUp(self):
-        super(LimitsTest, self).setUp()
-        self.limits = limits.Limits(Mock())
-        self.limits.api.client = Mock()
-
-    def tearDown(self):
-        super(LimitsTest, self).tearDown()
-
-    def test_list(self):
-        resp = Mock()
-        resp.status = 200
-        body = {"limits":
-                [
-                    {'maxTotalInstances': 55,
-                     'verb': 'ABSOLUTE',
-                     'maxTotalVolumes': 100},
-                    {'regex': '.*',
-                     'nextAvailable': '2011-07-21T18:17:06Z',
-                     'uri': '*',
-                     'value': 10,
-                     'verb': 'POST',
-                     'remaining': 2, 'unit': 'MINUTE'},
-                    {'regex': '.*',
-                     'nextAvailable': '2011-07-21T18:17:06Z',
-                     'uri': '*',
-                     'value': 10,
-                     'verb': 'PUT',
-                     'remaining': 2,
-                     'unit': 'MINUTE'},
-                    {'regex': '.*',
-                     'nextAvailable': '2011-07-21T18:17:06Z',
-                     'uri': '*',
-                     'value': 10,
-                     'verb': 'DELETE',
-                     'remaining': 2,
-                     'unit': 'MINUTE'},
-                    {'regex': '.*',
-                     'nextAvailable': '2011-07-21T18:17:06Z',
-                     'uri': '*',
-                     'value': 10,
-                     'verb': 'GET',
-                     'remaining': 2, 'unit': 'MINUTE'}]}
-        response = (resp, body)
-
-        mock_get = Mock(return_value=response)
-        self.limits.api.client.get = mock_get
-        self.assertIsNotNone(self.limits.list())
-        mock_get.assert_called_once_with("/limits")
-
-    def test_list_errors(self):
-        status_list = [400, 401, 403, 404, 408, 409, 413, 500, 501]
-        for status_code in status_list:
-            self._check_error_response(status_code)
-
-    def _check_error_response(self, status_code):
-        RESPONSE_KEY = "limits"
-
-        resp = Mock()
-        resp.status = status_code
-        body = {RESPONSE_KEY: {
-            'absolute': {},
-            'rate': [
-            {'limit': []
-             }]}}
-        response = (resp, body)
-
-        mock_get = Mock(return_value=response)
-        self.limits.api.client.get = mock_get
-        self.assertRaises(Exception, self.limits.list)
diff --git a/reddwarfclient/tests/test_management.py b/reddwarfclient/tests/test_management.py
deleted file mode 100644
index 810961a..0000000
--- a/reddwarfclient/tests/test_management.py
+++ /dev/null
@@ -1,144 +0,0 @@
-from testtools import TestCase
-from mock import Mock
-
-from reddwarfclient import management
-from reddwarfclient import base
-
-"""
-Unit tests for management.py
-"""
-
-
-class RootHistoryTest(TestCase):
-
-    def setUp(self):
-        super(RootHistoryTest, self).setUp()
-        self.orig__init = management.RootHistory.__init__
-        management.RootHistory.__init__ = Mock(return_value=None)
-
-    def tearDown(self):
-        super(RootHistoryTest, self).tearDown()
-        management.RootHistory.__init__ = self.orig__init
-
-    def test___repr__(self):
-        root_history = management.RootHistory()
-        root_history.id = "1"
-        root_history.created = "ct"
-        root_history.user = "tu"
-        self.assertEqual('<Root History: Instance 1 enabled at ct by tu>',
-                         root_history.__repr__())
-
-
-class ManagementTest(TestCase):
-
-    def setUp(self):
-        super(ManagementTest, self).setUp()
-        self.orig__init = management.Management.__init__
-        management.Management.__init__ = Mock(return_value=None)
-        self.management = management.Management()
-        self.management.api = Mock()
-        self.management.api.client = Mock()
-
-        self.orig_hist__init = management.RootHistory.__init__
-        self.orig_base_getid = base.getid
-        base.getid = Mock(return_value="instance1")
-
-    def tearDown(self):
-        super(ManagementTest, self).tearDown()
-        management.Management.__init__ = self.orig__init
-        management.RootHistory.__init__ = self.orig_hist__init
-        base.getid = self.orig_base_getid
-
-    def test__list(self):
-        self.management.api.client.get = Mock(return_value=('resp', None))
-        self.assertRaises(Exception, self.management._list, "url", None)
-
-        body = Mock()
-        body.get = Mock(return_value=[{'href': 'http://test.net/test_file',
-                                       'rel': 'next'}])
-        body.__getitem__ = Mock(return_value='instance1')
-        self.management.resource_class = Mock(return_value="instance-1")
-        self.management.api.client.get = Mock(return_value=('resp', body))
-        _expected = [{'href': 'http://test.net/test_file', 'rel': 'next'}]
-        self.assertEqual(_expected, self.management._list("url", None).links)
-
-    def test_show(self):
-        def side_effect_func(path, instance):
-            return path, instance
-        self.management._get = Mock(side_effect=side_effect_func)
-        p, i = self.management.show(1)
-        self.assertEqual(('/mgmt/instances/instance1', 'instance'), (p, i))
-
-    def test_index(self):
-        def side_effect_func(url, name, limit, marker):
-            return url
-
-        self.management._list = Mock(side_effect=side_effect_func)
-        self.assertEqual('/mgmt/instances?deleted=true',
-                         self.management.index(deleted=True))
-        self.assertEqual('/mgmt/instances?deleted=false',
-                         self.management.index(deleted=False))
-
-    def test_root_enabled_history(self):
-        self.management.api.client.get = Mock(return_value=('resp', None))
-        self.assertRaises(Exception,
-                          self.management.root_enabled_history, "instance")
-        body = {'root_history': 'rh'}
-        self.management.api.client.get = Mock(return_value=('resp', body))
-        management.RootHistory.__init__ = Mock(return_value=None)
-        rh = self.management.root_enabled_history("instance")
-        self.assertTrue(isinstance(rh, management.RootHistory))
-
-    def test__action(self):
-        resp = Mock()
-        self.management.api.client.post = Mock(return_value=(resp, 'body'))
-        resp.status = 200
-        self.management._action(1, 'body')
-        self.assertEqual(1, self.management.api.client.post.call_count)
-        resp.status = 400
-        self.assertRaises(ValueError, self.management._action, 1, 'body')
-        self.assertEqual(2, self.management.api.client.post.call_count)
-
-    def _mock_action(self):
-        self.body_ = ""
-
-        def side_effect_func(instance_id, body):
-            self.body_ = body
-        self.management._action = Mock(side_effect=side_effect_func)
-
-    def test_stop(self):
-        self._mock_action()
-        self.management.stop(1)
-        self.assertEqual(1, self.management._action.call_count)
-        self.assertEqual({'stop': {}}, self.body_)
-
-    def test_reboot(self):
-        self._mock_action()
-        self.management.reboot(1)
-        self.assertEqual(1, self.management._action.call_count)
-        self.assertEqual({'reboot': {}}, self.body_)
-
-    def test_migrate(self):
-        self._mock_action()
-        self.management.migrate(1)
-        self.assertEqual(1, self.management._action.call_count)
-        self.assertEqual({'migrate': {}}, self.body_)
-
-    def test_migrate_to_host(self):
-        hostname = 'hostname2'
-        self._mock_action()
-        self.management.migrate(1, host=hostname)
-        self.assertEqual(1, self.management._action.call_count)
-        self.assertEqual({'migrate': {'host': hostname}}, self.body_)
-
-    def test_update(self):
-        self._mock_action()
-        self.management.update(1)
-        self.assertEqual(1, self.management._action.call_count)
-        self.assertEqual({'update': {}}, self.body_)
-
-    def test_reset_task_status(self):
-        self._mock_action()
-        self.management.reset_task_status(1)
-        self.assertEqual(1, self.management._action.call_count)
-        self.assertEqual({'reset-task-status': {}}, self.body_)
diff --git a/reddwarfclient/tests/test_secgroups.py b/reddwarfclient/tests/test_secgroups.py
deleted file mode 100644
index 25b4de8..0000000
--- a/reddwarfclient/tests/test_secgroups.py
+++ /dev/null
@@ -1,102 +0,0 @@
-from testtools import TestCase
-from mock import Mock
-
-from reddwarfclient import security_groups
-from reddwarfclient import base
-
-"""
-Unit tests for security_groups.py
-"""
-
-
-class SecGroupTest(TestCase):
-
-    def setUp(self):
-        super(SecGroupTest, self).setUp()
-        self.orig__init = security_groups.SecurityGroup.__init__
-        security_groups.SecurityGroup.__init__ = Mock(return_value=None)
-        self.security_group = security_groups.SecurityGroup()
-        self.security_groups = security_groups.SecurityGroups(1)
-
-    def tearDown(self):
-        super(SecGroupTest, self).tearDown()
-        security_groups.SecurityGroup.__init__ = self.orig__init
-
-    def test___repr__(self):
-        self.security_group.name = "security_group-1"
-        self.assertEqual('<SecurityGroup: security_group-1>',
-                         self.security_group.__repr__())
-
-    def test_list(self):
-        sec_group_list = ['secgroup1', 'secgroup2']
-        self.security_groups.list = Mock(return_value=sec_group_list)
-        self.assertEqual(sec_group_list, self.security_groups.list())
-
-    def test_get(self):
-        def side_effect_func(path, inst):
-            return path, inst
-
-        self.security_groups._get = Mock(side_effect=side_effect_func)
-        self.security_group.id = 1
-        self.assertEqual(('/security-groups/1', 'security_group'),
-                         self.security_groups.get(self.security_group))
-
-
-class SecGroupRuleTest(TestCase):
-
-    def setUp(self):
-        super(SecGroupRuleTest, self).setUp()
-        self.orig__init = security_groups.SecurityGroupRule.__init__
-        security_groups.SecurityGroupRule.__init__ = Mock(return_value=None)
-        security_groups.SecurityGroupRules.__init__ = Mock(return_value=None)
-        self.security_group_rule = security_groups.SecurityGroupRule()
-        self.security_group_rules = security_groups.SecurityGroupRules()
-
-    def tearDown(self):
-        super(SecGroupRuleTest, self).tearDown()
-        security_groups.SecurityGroupRule.__init__ = self.orig__init
-
-    def test___repr__(self):
-        self.security_group_rule.group_id = 1
-        self.security_group_rule.protocol = "tcp"
-        self.security_group_rule.from_port = 80
-        self.security_group_rule.to_port = 80
-        self.security_group_rule.cidr = "0.0.0.0//0"
-        representation = \
-            "<SecurityGroupRule: ( \
-    Security Group id: %d, \
-    Protocol: %s, \
-    From_Port: %d, \
-    To_Port: %d, \
-    CIDR: %s )>" % (1, "tcp", 80, 80, "0.0.0.0//0")
-
-        self.assertEqual(representation,
-                         self.security_group_rule.__repr__())
-
-    def test_create(self):
-        def side_effect_func(path, body, inst):
-            return path, body, inst
-
-        self.security_group_rules._create = Mock(side_effect=side_effect_func)
-        p, b, i = self.security_group_rules.create(1, "tcp",
-                                                   80, 80, "0.0.0.0//0")
-        self.assertEqual("/security-group-rules", p)
-        self.assertEqual("security_group_rule", i)
-        self.assertEqual(1, b["security_group_rule"]["group_id"])
-        self.assertEqual("tcp", b["security_group_rule"]["protocol"])
-        self.assertEqual(80, b["security_group_rule"]["from_port"])
-        self.assertEqual(80, b["security_group_rule"]["to_port"])
-        self.assertEqual("0.0.0.0//0", b["security_group_rule"]["cidr"])
-
-    def test_delete(self):
-        resp = Mock()
-        resp.status = 200
-        body = None
-        self.security_group_rules.api = Mock()
-        self.security_group_rules.api.client = Mock()
-        self.security_group_rules.api.client.delete = \
-            Mock(return_value=(resp, body))
-        self.security_group_rules.delete(self.id)
-        resp.status = 500
-        self.assertRaises(ValueError, self.security_group_rules.delete,
-                          self.id)
diff --git a/reddwarfclient/tests/test_users.py b/reddwarfclient/tests/test_users.py
deleted file mode 100644
index 80be05f..0000000
--- a/reddwarfclient/tests/test_users.py
+++ /dev/null
@@ -1,126 +0,0 @@
-from testtools import TestCase
-from mock import Mock
-
-from reddwarfclient import users
-from reddwarfclient import base
-
-"""
-Unit tests for users.py
-"""
-
-
-class UserTest(TestCase):
-
-    def setUp(self):
-        super(UserTest, self).setUp()
-        self.orig__init = users.User.__init__
-        users.User.__init__ = Mock(return_value=None)
-        self.user = users.User()
-
-    def tearDown(self):
-        super(UserTest, self).tearDown()
-        users.User.__init__ = self.orig__init
-
-    def test___repr__(self):
-        self.user.name = "user-1"
-        self.assertEqual('<User: user-1>', self.user.__repr__())
-
-
-class UsersTest(TestCase):
-
-    def setUp(self):
-        super(UsersTest, self).setUp()
-        self.orig__init = users.Users.__init__
-        users.Users.__init__ = Mock(return_value=None)
-        self.users = users.Users()
-        self.users.api = Mock()
-        self.users.api.client = Mock()
-
-        self.orig_base_getid = base.getid
-        base.getid = Mock(return_value="instance1")
-
-    def tearDown(self):
-        super(UsersTest, self).tearDown()
-        users.Users.__init__ = self.orig__init
-        base.getid = self.orig_base_getid
-
-    def _get_mock_method(self):
-        self._resp = Mock()
-        self._body = None
-        self._url = None
-
-        def side_effect_func(url, body=None):
-            self._body = body
-            self._url = url
-            return (self._resp, body)
-
-        return Mock(side_effect=side_effect_func)
-
-    def _build_fake_user(self, name, hostname=None, password=None,
-                         databases=None):
-        return {'name': name,
-                'password': password if password else 'password',
-                'host': hostname,
-                'databases': databases if databases else [],
-               }
-
-    def test_create(self):
-        self.users.api.client.post = self._get_mock_method()
-        self._resp.status = 200
-        user = self._build_fake_user('user1')
-
-        self.users.create(23, [user])
-        self.assertEqual('/instances/23/users', self._url)
-        self.assertEqual({"users": [user]}, self._body)
-
-        # Even if host isn't supplied originally,
-        # the default is supplied.
-        del user['host']
-        self.users.create(23, [user])
-        self.assertEqual('/instances/23/users', self._url)
-        user['host'] = '%'
-        self.assertEqual({"users": [user]}, self._body)
-
-        # If host is supplied, of course it's put into the body.
-        user['host'] = '127.0.0.1'
-        self.users.create(23, [user])
-        self.assertEqual({"users": [user]}, self._body)
-
-        # Make sure that response of 400 is recognized as an error.
-        user['host'] = '%'
-        self._resp.status = 400
-        self.assertRaises(Exception, self.users.create, 12, [user])
-
-    def test_delete(self):
-        self.users.api.client.delete = self._get_mock_method()
-        self._resp.status = 200
-        self.users.delete(27, 'user1')
-        self.assertEqual('/instances/27/users/user1', self._url)
-        self._resp.status = 400
-        self.assertRaises(Exception, self.users.delete, 34, 'user1')
-
-    def test__list(self):
-        def side_effect_func(self, val):
-            return val
-
-        key = 'key'
-        body = Mock()
-        body.get = Mock(return_value=[{'href': 'http://test.net/test_file',
-                                       'rel': 'next'}])
-        body.__getitem__ = Mock(return_value=["test-value"])
-
-        resp = Mock()
-        resp.status = 200
-        self.users.resource_class = Mock(side_effect=side_effect_func)
-        self.users.api.client.get = Mock(return_value=(resp, body))
-        self.assertEqual(["test-value"], self.users._list('url', key).items)
-
-        self.users.api.client.get = Mock(return_value=(resp, None))
-        self.assertRaises(Exception, self.users._list, 'url', None)
-
-    def test_list(self):
-        def side_effect_func(path, user, limit, marker):
-            return path
-
-        self.users._list = Mock(side_effect=side_effect_func)
-        self.assertEqual('/instances/instance1/users', self.users.list(1))
diff --git a/reddwarfclient/tests/test_utils.py b/reddwarfclient/tests/test_utils.py
deleted file mode 100644
index c3a000d..0000000
--- a/reddwarfclient/tests/test_utils.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import os
-from testtools import TestCase
-from reddwarfclient import utils
-from reddwarfclient import versions
-
-
-class UtilsTest(TestCase):
-
-    def test_add_hookable_mixin(self):
-        def func():
-            pass
-
-        hook_type = "hook_type"
-        mixin = utils.HookableMixin()
-        mixin.add_hook(hook_type, func)
-        self.assertTrue(hook_type in mixin._hooks_map)
-        self.assertTrue(func in mixin._hooks_map[hook_type])
-
-    def test_run_hookable_mixin(self):
-        def func():
-            pass
-
-        hook_type = "hook_type"
-        mixin = utils.HookableMixin()
-        mixin.add_hook(hook_type, func)
-        mixin.run_hooks(hook_type)
-
-    def test_environment(self):
-        self.assertEqual('', utils.env())
-        self.assertEqual('passing', utils.env(default='passing'))
-
-        os.environ['test_abc'] = 'passing'
-        self.assertEqual('passing', utils.env('test_abc'))
-        self.assertEqual('', utils.env('test_abcd'))
-
-    def test_slugify(self):
-        import unicodedata
-
-        self.assertEqual('not_unicode', utils.slugify('not_unicode'))
-        self.assertEqual('unicode', utils.slugify(unicode('unicode')))
-        self.assertEqual('slugify-test', utils.slugify('SLUGIFY% test!'))
diff --git a/reddwarfclient/tests/test_xml.py b/reddwarfclient/tests/test_xml.py
deleted file mode 100644
index cda382b..0000000
--- a/reddwarfclient/tests/test_xml.py
+++ /dev/null
@@ -1,241 +0,0 @@
-from testtools import TestCase
-from lxml import etree
-from reddwarfclient import xml
-
-
-class XmlTest(TestCase):
-
-    ELEMENT = '''
-        <instances>
-            <instance>
-                <flavor>
-                    <links>
-                    </links>
-                    <value value="5"/>
-                </flavor>
-            </instance>
-        </instances>
-    '''
-    ROOT = etree.fromstring(ELEMENT)
-
-    JSON = {'instances':
-            {'instances': ['1', '2', '3']}, 'dummy': {'dict': True}}
-
-    def test_element_ancestors_match_list(self):
-        # Test normal operation:
-        self.assertTrue(xml.element_ancestors_match_list(self.ROOT[0][0],
-                                                         ['instance',
-                                                          'instances']))
-
-        # Test itr_elem is None:
-        self.assertTrue(xml.element_ancestors_match_list(self.ROOT,
-                                                         ['instances']))
-
-        # Test that the first parent element does not match the first list
-        # element:
-        self.assertFalse(xml.element_ancestors_match_list(self.ROOT[0][0],
-                                                          ['instances',
-                                                           'instance']))
-
-    def test_populate_element_from_dict(self):
-        # Test populate_element_from_dict with a None in the data
-        ele = '''
-        <instance>
-            <volume>
-                <value size="5"/>
-            </volume>
-        </instance>
-            '''
-        rt = etree.fromstring(ele)
-
-        self.assertEqual(None, xml.populate_element_from_dict(rt,
-            {'size': None}))
-
-    def test_element_must_be_list(self):
-        # Test for when name isn't in the dictionary
-        self.assertFalse(xml.element_must_be_list(self.ROOT, "not_in_list"))
-
-        # Test when name is in the dictionary but list is empty
-        self.assertTrue(xml.element_must_be_list(self.ROOT, "accounts"))
-
-        # Test when name is in the dictionary but list is not empty
-        self.assertTrue(xml.element_must_be_list(self.ROOT[0][0][0], "links"))
-
-    def test_element_to_json(self):
-        # Test when element must be list:
-        self.assertEqual([{'flavor': {'links': [], 'value': {'value': '5'}}}],
-                         xml.element_to_json("accounts", self.ROOT))
-
-        # Test when element must not be list:
-        exp = {'instance': {'flavor': {'links': [], 'value': {'value': '5'}}}}
-        self.assertEqual(exp, xml.element_to_json("not_in_list", self.ROOT))
-
-    def test_root_element_to_json(self):
-        # Test when element must be list:
-        exp = ([{'flavor': {'links': [], 'value': {'value': '5'}}}], None)
-        self.assertEqual(exp, xml.root_element_to_json("accounts", self.ROOT))
-
-        # Test when element must not be list:
-        exp = {'instance': {'flavor': {'links': [], 'value': {'value': '5'}}}}
-        self.assertEqual((exp, None),
-                         xml.root_element_to_json("not_in_list", self.ROOT))
-
-        # Test rootEnabled True:
-        t_element = etree.fromstring('''<rootEnabled> True </rootEnabled>''')
-        self.assertEqual((True, None),
-                         xml.root_element_to_json("rootEnabled", t_element))
-
-        # Test rootEnabled False:
-        f_element = etree.fromstring('''<rootEnabled> False </rootEnabled>''')
-        self.assertEqual((False, None),
-                         xml.root_element_to_json("rootEnabled", f_element))
-
-    def test_element_to_list(self):
-        # Test w/ no child elements
-        self.assertEqual([], xml.element_to_list(self.ROOT[0][0][0]))
-
-        # Test w/ no child elements and check_for_links = True
-        self.assertEqual(([], None),
-                         xml.element_to_list(self.ROOT[0][0][0],
-                                             check_for_links=True))
-
-        # Test w/ child elements
-        self.assertEqual([{}, {'value': '5'}],
-                         xml.element_to_list(self.ROOT[0][0]))
-
-        # Test w/ child elements and check_for_links = True
-        self.assertEqual(([{'value': '5'}], []),
-                         xml.element_to_list(self.ROOT[0][0],
-                                             check_for_links=True))
-
-    def test_element_to_dict(self):
-        # Test when there is not a None
-        exp = {'instance': {'flavor': {'links': [], 'value': {'value': '5'}}}}
-        self.assertEqual(exp, xml.element_to_dict(self.ROOT))
-
-        # Test when there is a None
-        element = '''
-                <server>
-                    None
-                </server>
-            '''
-        rt = etree.fromstring(element)
-        self.assertEqual(None, xml.element_to_dict(rt))
-
-    def test_standarize_json(self):
-        xml.standardize_json_lists(self.JSON)
-        self.assertEqual({'instances': ['1', '2', '3'],
-                          'dummy': {'dict': True}}, self.JSON)
-
-    def test_normalize_tag(self):
-        ELEMENT_NS = '''
-            <instances xmlns="http://www.w3.org/1999/xhtml">
-                <instance>
-                    <flavor>
-                        <links>
-                        </links>
-                        <value value="5"/>
-                    </flavor>
-                </instance>
-            </instances>
-        '''
-        ROOT_NS = etree.fromstring(ELEMENT_NS)
-
-        # Test normalizing without namespace info
-        self.assertEqual('instances', xml.normalize_tag(self.ROOT))
-
-        # Test normalizing with namespace info
-        self.assertEqual('instances', xml.normalize_tag(ROOT_NS))
-
-    def test_create_root_xml_element(self):
-        # Test creating when name is not in REQUEST_AS_LIST
-        element = xml.create_root_xml_element("root", {"root": "value"})
-        exp = '<root xmlns="http://docs.openstack.org/database/api/v1.0" ' \
-            'root="value"/>'
-        self.assertEqual(exp, etree.tostring(element))
-
-        # Test creating when name is in REQUEST_AS_LIST
-        element = xml.create_root_xml_element("users", [])
-        exp = '<users xmlns="http://docs.openstack.org/database/api/v1.0"/>'
-        self.assertEqual(exp, etree.tostring(element))
-
-    def test_creating_subelements(self):
-        # Test creating a subelement as a dictionary
-        element = xml.create_root_xml_element("root", {"root": 5})
-        xml.create_subelement(element, "subelement", {"subelement": "value"})
-        exp = '<root xmlns="http://docs.openstack.org/database/api/v1.0" ' \
-            'root="5"><subelement subelement="value"/></root>'
-        self.assertEqual(exp, etree.tostring(element))
-
-        # Test creating a subelement as a list
-        element = xml.create_root_xml_element("root",
-                                              {"root": {"value": "nested"}})
-        xml.create_subelement(element, "subelement", [{"subelement": "value"}])
-        exp = '<root xmlns="http://docs.openstack.org/database/api/v1.0">' \
-            '<root value="nested"/><subelement><subelement subelement=' \
-            '"value"/></subelement></root>'
-        self.assertEqual(exp, etree.tostring(element))
-
-        # Test creating a subelement as a string (should raise TypeError)
-        element = xml.create_root_xml_element("root", {"root": "value"})
-        try:
-            xml.create_subelement(element, "subelement", ["value"])
-            self.fail("TypeError exception expected")
-        except TypeError:
-            pass
-
-    def test_modify_response_types(self):
-        TYPE_MAP = {
-            "Int": int,
-            "Bool": bool
-            }
-        #Is a string True
-        self.assertEqual(True, xml.modify_response_types('True', TYPE_MAP))
-
-        #Is a string False
-        self.assertEqual(False, xml.modify_response_types('False', TYPE_MAP))
-
-        #Is a dict
-        test_dict = {"Int": "5"}
-        test_dict = xml.modify_response_types(test_dict, TYPE_MAP)
-        self.assertEqual(int, test_dict["Int"].__class__)
-
-        #Is a list
-        test_list = {"a_list": [{"Int": "5"}, {"Str": "A"}]}
-        test_list = xml.modify_response_types(test_list["a_list"], TYPE_MAP)
-        self.assertEqual([{'Int': 5}, {'Str': 'A'}], test_list)
-
-    def test_reddwarfxmlclient(self):
-        from reddwarfclient import exceptions
-
-        client = xml.ReddwarfXmlClient("user", "password", "tenant",
-                                       "auth_url", "service_name",
-                                       auth_strategy="fake")
-        request = {'headers': {}}
-
-        # Test morph_request, no body
-        client.morph_request(request)
-        self.assertEqual('application/xml', request['headers']['Accept'])
-        self.assertEqual('application/xml', request['headers']['Content-Type'])
-
-        # Test morph_request, with body
-        request['body'] = {'root': {'test': 'test'}}
-        client.morph_request(request)
-        body = '<root xmlns="http://docs.openstack.org/database/api/v1.0" ' \
-            'test="test"/>\n'
-        exp = {'body': body,
-               'headers': {'Content-Type': 'application/xml',
-                           'Accept': 'application/xml'}}
-        self.assertEqual(exp, request)
-
-        # Test morph_response_body
-        request = "<users><links><user href='value'/></links></users>"
-        result = client.morph_response_body(request)
-        self.assertEqual({'users': [], 'links': [{'href': 'value'}]}, result)
-
-        # Test morph_response_body with improper input
-        try:
-            client.morph_response_body("value")
-            self.fail("ResponseFormatError exception expected")
-        except exceptions.ResponseFormatError:
-            pass
diff --git a/reddwarfclient/users.py b/reddwarfclient/users.py
deleted file mode 100644
index 344252c..0000000
--- a/reddwarfclient/users.py
+++ /dev/null
@@ -1,127 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-from reddwarfclient import databases
-from reddwarfclient.common import check_for_exceptions
-from reddwarfclient.common import limit_url
-from reddwarfclient.common import Paginated
-from reddwarfclient.common import quote_user_host
-import exceptions
-import urlparse
-
-
-class User(base.Resource):
-    """
-    A database user
-    """
-    def __repr__(self):
-        return "<User: %s>" % self.name
-
-
-class Users(base.ManagerWithFind):
-    """
-    Manage :class:`Users` resources.
-    """
-    resource_class = User
-
-    def create(self, instance_id, users):
-        """
-        Create users with permissions to the specified databases
-        """
-        body = {"users": users}
-        url = "/instances/%s/users" % instance_id
-        resp, body = self.api.client.post(url, body=body)
-        check_for_exceptions(resp, body)
-
-    def delete(self, instance_id, username, hostname=None):
-        """Delete an existing user in the specified instance"""
-        user = quote_user_host(username, hostname)
-        url = "/instances/%s/users/%s" % (instance_id, user)
-        resp, body = self.api.client.delete(url)
-        check_for_exceptions(resp, body)
-
-    def _list(self, url, response_key, limit=None, marker=None):
-        resp, body = self.api.client.get(limit_url(url, limit, marker))
-        check_for_exceptions(resp, body)
-        if not body:
-            raise Exception("Call to " + url +
-                            " did not return a body.")
-        links = body.get('links', [])
-        next_links = [link['href'] for link in links if link['rel'] == 'next']
-        next_marker = None
-        for link in next_links:
-            # Extract the marker from the url.
-            parsed_url = urlparse.urlparse(link)
-            query_dict = dict(urlparse.parse_qsl(parsed_url.query))
-            next_marker = query_dict.get('marker', None)
-        users = [self.resource_class(self, res) for res in body[response_key]]
-        return Paginated(users, next_marker=next_marker, links=links)
-
-    def list(self, instance, limit=None, marker=None):
-        """
-        Get a list of all Users from the instance's Database.
-
-        :rtype: list of :class:`User`.
-        """
-        return self._list("/instances/%s/users" % base.getid(instance),
-                          "users", limit, marker)
-
-    def get(self, instance_id, username, hostname=None):
-        """
-        Get a single User from the instance's Database.
-
-        :rtype: :class:`User`.
-        """
-        user = quote_user_host(username, hostname)
-        url = "/instances/%s/users/%s" % (instance_id, user)
-        return self._get(url, "user")
-
-    def list_access(self, instance, username, hostname=None):
-        """Show all databases the given user has access to. """
-        instance_id = base.getid(instance)
-        user = quote_user_host(username, hostname)
-        url = "/instances/%(instance_id)s/users/%(user)s/databases"
-        resp, body = self.api.client.get(url % locals())
-        check_for_exceptions(resp, body)
-        if not body:
-            raise Exception("Call to %s did not return to a body" % url)
-        return [databases.Database(self, db) for db in body['databases']]
-
-    def grant(self, instance, username, databases, hostname=None):
-        """Allow an existing user permissions to access a database."""
-        instance_id = base.getid(instance)
-        user = quote_user_host(username, hostname)
-        url = "/instances/%(instance_id)s/users/%(user)s/databases"
-        dbs = {'databases': [{'name': db} for db in databases]}
-        resp, body = self.api.client.put(url % locals(), body=dbs)
-        check_for_exceptions(resp, body)
-
-    def revoke(self, instance, username, database, hostname=None):
-        """Revoke from an existing user access permissions to a database."""
-        instance_id = base.getid(instance)
-        user = quote_user_host(username, hostname)
-        url = ("/instances/%(instance_id)s/users/%(user)s/"
-               "databases/%(database)s")
-        resp, body = self.api.client.delete(url % locals())
-        check_for_exceptions(resp, body)
-
-    def change_passwords(self, instance, users):
-        """Change the password for one or more users."""
-        instance_id = base.getid(instance)
-        user_dict = {"users": users}
-        url = "/instances/%s/users" % instance_id
-        resp, body = self.api.client.put(url, body=user_dict)
-        check_for_exceptions(resp, body)
diff --git a/reddwarfclient/utils.py b/reddwarfclient/utils.py
deleted file mode 100644
index 3deb806..0000000
--- a/reddwarfclient/utils.py
+++ /dev/null
@@ -1,68 +0,0 @@
-#    Copyright 2012 OpenStack LLC
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import os
-import re
-import sys
-
-
-class HookableMixin(object):
-    """Mixin so classes can register and run hooks."""
-    _hooks_map = {}
-
-    @classmethod
-    def add_hook(cls, hook_type, hook_func):
-        if hook_type not in cls._hooks_map:
-            cls._hooks_map[hook_type] = []
-
-        cls._hooks_map[hook_type].append(hook_func)
-
-    @classmethod
-    def run_hooks(cls, hook_type, *args, **kwargs):
-        hook_funcs = cls._hooks_map.get(hook_type) or []
-        for hook_func in hook_funcs:
-            hook_func(*args, **kwargs)
-
-
-def env(*vars, **kwargs):
-    """
-    returns the first environment variable set
-    if none are non-empty, defaults to '' or keyword arg default
-    """
-    for v in vars:
-        value = os.environ.get(v, None)
-        if value:
-            return value
-    return kwargs.get('default', '')
-
-
-_slugify_strip_re = re.compile(r'[^\w\s-]')
-_slugify_hyphenate_re = re.compile(r'[-\s]+')
-
-
-# http://code.activestate.com/recipes/
-#   577257-slugify-make-a-string-usable-in-a-url-or-filename/
-def slugify(value):
-    """
-    Normalizes string, converts to lowercase, removes non-alpha characters,
-    and converts spaces to hyphens.
-
-    From Django's "django/template/defaultfilters.py".
-    """
-    import unicodedata
-    if not isinstance(value, unicode):
-        value = unicode(value)
-    value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore')
-    value = unicode(_slugify_strip_re.sub('', value).strip().lower())
-    return _slugify_hyphenate_re.sub('-', value)
diff --git a/reddwarfclient/versions.py b/reddwarfclient/versions.py
deleted file mode 100644
index f7b52c4..0000000
--- a/reddwarfclient/versions.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# Copyright (c) 2011 OpenStack, LLC.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from reddwarfclient import base
-
-
-class Version(base.Resource):
-    """
-    Version is an opaque instance used to hold version information.
-    """
-    def __repr__(self):
-        return "<Version: %s>" % self.id
-
-
-class Versions(base.ManagerWithFind):
-    """
-    Manage :class:`Versions` information.
-    """
-
-    resource_class = Version
-
-    def index(self, url):
-        """
-        Get a list of all versions.
-
-        :rtype: list of :class:`Versions`.
-        """
-        resp, body = self.api.client.request(url, "GET")
-        return [self.resource_class(self, res) for res in body['versions']]
diff --git a/reddwarfclient/xml.py b/reddwarfclient/xml.py
deleted file mode 100644
index fe94f19..0000000
--- a/reddwarfclient/xml.py
+++ /dev/null
@@ -1,293 +0,0 @@
-from lxml import etree
-import json
-from numbers import Number
-
-from reddwarfclient import exceptions
-from reddwarfclient.client import ReddwarfHTTPClient
-
-XML_NS = {None: "http://docs.openstack.org/database/api/v1.0"}
-
-# If XML element is listed here then this searches through the ancestors.
-LISTIFY = {
-    "accounts": [[]],
-    "databases": [[]],
-    "flavors": [[]],
-    "instances": [[]],
-    "links": [[]],
-    "hosts": [[]],
-    "devices": [[]],
-    "users": [[]],
-    "versions": [[]],
-    "attachments": [[]],
-    "limits": [[]],
-    "security_groups": [[]],
-    "backups": [[]]
-}
-
-
-class IntDict(object):
-    pass
-
-
-TYPE_MAP = {
-    "instance": {
-        "volume": {
-            "used": float,
-            "size": int,
-        },
-        "deleted": bool,
-        "server": {
-            "local_id": int,
-            "deleted": bool,
-        },
-    },
-    "instances": {
-        "deleted": bool,
-    },
-    "deleted": bool,
-    "flavor": {
-        "ram": int,
-    },
-    "diagnostics": {
-        "vmHwm": int,
-        "vmPeak": int,
-        "vmSize": int,
-        "threads": int,
-        "vmRss": int,
-        "fdSize": int,
-    },
-    "security_group_rule": {
-        "from_port": int,
-        "to_port": int,
-    },
-    "quotas": IntDict,
-}
-TYPE_MAP["flavors"] = TYPE_MAP["flavor"]
-
-REQUEST_AS_LIST = set(['databases', 'users'])
-
-
-def element_ancestors_match_list(element, list):
-    """
-    For element root at <foo><blah><root></blah></foo> matches against
-    list ["blah", "foo"].
-    """
-    itr_elem = element.getparent()
-    for name in list:
-        if itr_elem is None:
-            break
-        if name != normalize_tag(itr_elem):
-            return False
-        itr_elem = itr_elem.getparent()
-    return True
-
-
-def element_must_be_list(parent_element, name):
-    """Determines if an element to be created should be a dict or list."""
-    if name in LISTIFY:
-        list_of_lists = LISTIFY[name]
-        for tag_list in list_of_lists:
-            if element_ancestors_match_list(parent_element, tag_list):
-                return True
-    return False
-
-
-def element_to_json(name, element):
-    if element_must_be_list(element, name):
-        return element_to_list(element)
-    else:
-        return element_to_dict(element)
-
-
-def root_element_to_json(name, element):
-    """Returns a tuple of the root JSON value, plus the links if found."""
-    if name == "rootEnabled":  # Why oh why were we inconsistent here? :'(
-        if element.text.strip() == "False":
-            return False, None
-        elif element.text.strip() == "True":
-            return True, None
-    if element_must_be_list(element, name):
-        return element_to_list(element, True)
-    else:
-        return element_to_dict(element), None
-
-
-def element_to_list(element, check_for_links=False):
-    """
-    For element "foo" in <foos><foo/><foo/></foos>
-    Returns [{}, {}]
-    """
-    links = None
-    result = []
-    for child_element in element:
-        # The "links" element gets jammed into the root element.
-        if check_for_links and normalize_tag(child_element) == "links":
-            links = element_to_list(child_element)
-        else:
-            result.append(element_to_dict(child_element))
-    if check_for_links:
-        return result, links
-    else:
-        return result
-
-
-def element_to_dict(element):
-    result = {}
-    for name, value in element.items():
-        result[name] = value
-    for child_element in element:
-        name = normalize_tag(child_element)
-        result[name] = element_to_json(name, child_element)
-    if len(result) == 0 and element.text:
-        string_value = element.text.strip()
-        if len(string_value):
-            if string_value == 'None':
-                return None
-            return string_value
-    return result
-
-
-def standardize_json_lists(json_dict):
-    """
-    In XML, we might see something like {'instances':{'instances':[...]}},
-    which we must change to just {'instances':[...]} to be compatable with
-    the true JSON format.
-
-    If any items are dictionaries with only one item which is a list,
-    simply remove the dictionary and insert its list directly.
-    """
-    found_items = []
-    for key, value in json_dict.items():
-        value = json_dict[key]
-        if isinstance(value, dict):
-            if len(value) == 1 and isinstance(value.values()[0], list):
-                found_items.append(key)
-            else:
-                standardize_json_lists(value)
-    for key in found_items:
-        json_dict[key] = json_dict[key].values()[0]
-
-
-def normalize_tag(elem):
-    """Given an element, returns the tag minus the XMLNS junk.
-
-    IOW, .tag may sometimes return the XML namespace at the start of the
-    string. This gets rids of that.
-    """
-    try:
-        prefix = "{" + elem.nsmap[None] + "}"
-        if elem.tag.startswith(prefix):
-            return elem.tag[len(prefix):]
-    except KeyError:
-        pass
-    return elem.tag
-
-
-def create_root_xml_element(name, value):
-    """Create the first element using a name and a dictionary."""
-    element = etree.Element(name, nsmap=XML_NS)
-    if name in REQUEST_AS_LIST:
-        add_subelements_from_list(element, name, value)
-    else:
-        populate_element_from_dict(element, value)
-    return element
-
-
-def create_subelement(parent_element, name, value):
-    """Attaches a new element onto the parent element."""
-    if isinstance(value, dict):
-        create_subelement_from_dict(parent_element, name, value)
-    elif isinstance(value, list):
-        create_subelement_from_list(parent_element, name, value)
-    else:
-        raise TypeError("Can't handle type %s." % type(value))
-
-
-def create_subelement_from_dict(parent_element, name, dict):
-    element = etree.SubElement(parent_element, name)
-    populate_element_from_dict(element, dict)
-
-
-def create_subelement_from_list(parent_element, name, list):
-    element = etree.SubElement(parent_element, name)
-    add_subelements_from_list(element, name, list)
-
-
-def add_subelements_from_list(element, name, list):
-    if name.endswith("s"):
-        item_name = name[:len(name) - 1]
-    else:
-        item_name = name
-    for item in list:
-        create_subelement(element, item_name, item)
-
-
-def populate_element_from_dict(element, dict):
-    for key, value in dict.items():
-        if isinstance(value, basestring):
-            element.set(key, value)
-        elif isinstance(value, Number):
-            element.set(key, str(value))
-        elif isinstance(value, None.__class__):
-            element.set(key, '')
-        else:
-            create_subelement(element, key, value)
-
-
-def modify_response_types(value, type_translator):
-    """
-    This will convert some string in response dictionary to ints or bool
-    so that our respose is compatiable with code expecting JSON style responses
-    """
-    if isinstance(value, str):
-        if value == 'True':
-            return True
-        elif value == 'False':
-            return False
-        else:
-            return type_translator(value)
-    elif isinstance(value, dict):
-        for k, v in value.iteritems():
-            if type_translator is not IntDict:
-                if v.__class__ is dict and v.__len__() == 0:
-                    value[k] = None
-                elif k in type_translator:
-                    value[k] = modify_response_types(value[k],
-                                                     type_translator[k])
-            else:
-                value[k] = int(value[k])
-        return value
-    elif isinstance(value, list):
-        return [modify_response_types(element, type_translator)
-                for element in value]
-
-
-class ReddwarfXmlClient(ReddwarfHTTPClient):
-
-    @classmethod
-    def morph_request(self, kwargs):
-        kwargs['headers']['Accept'] = 'application/xml'
-        kwargs['headers']['Content-Type'] = 'application/xml'
-        if 'body' in kwargs:
-            body = kwargs['body']
-            root_name = body.keys()[0]
-            xml = create_root_xml_element(root_name, body[root_name])
-            xml_string = etree.tostring(xml, pretty_print=True)
-            kwargs['body'] = xml_string
-
-    @classmethod
-    def morph_response_body(self, body_string):
-        # The root XML element always becomes a dictionary with a single
-        # field, which has the same key as the elements name.
-        result = {}
-        try:
-            root_element = etree.XML(body_string)
-        except etree.XMLSyntaxError:
-            raise exceptions.ResponseFormatError()
-        root_name = normalize_tag(root_element)
-        root_value, links = root_element_to_json(root_name, root_element)
-        result = {root_name: root_value}
-        if links:
-            result['links'] = links
-        modify_response_types(result, TYPE_MAP)
-        return result