Initial copy of reddwarfclient from reddwarf project.

Author: Tim Simpson

reddwarfclient/__init__.py

@@ -0,0 +1,132 @@
+# 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 time
+import urlparse
+
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+
+from novaclient.client import HTTPClient
+from novaclient.v1_1.client import Client
+
+
+# To write this test from an end user perspective, we have to create a client
+# similar to the CloudServers one.
+# For now we will work on it here.
+
+
+class ReddwarfHTTPClient(HTTPClient):
+    """
+    Class for overriding the HTTP authenticate call and making it specific to
+    reddwarf
+    """
+
+    def __init__(self, user, apikey, tenant, auth_url, service_name,
+                 service_url=None, timeout=None):
+        super(ReddwarfHTTPClient, self).__init__(user, apikey, tenant,
+                                                 auth_url, timeout=timeout)
+        self.tenant = tenant
+        self.service = service_name
+        self.management_url = service_url
+
+    def authenticate(self):
+        scheme, netloc, path, query, frag = urlparse.urlsplit(self.auth_url)
+        path_parts = path.split('/')
+        for part in path_parts:
+            if len(part) > 0 and part[0] == 'v':
+                self.version = part
+                break
+
+        # Auth against Keystone version 2.0
+        if self.version == "v2.0":
+            req_body = {'passwordCredentials': {'username': self.user,
+                                                'password': self.apikey,
+                                                'tenantId': self.tenant}}
+            self._get_token("/v2.0/tokens", req_body)
+        # Auth against Keystone version 1.1
+        elif self.version == "v1.1":
+            req_body = {'credentials': {'username': self.user,
+                                        'key': self.apikey}}
+            self._get_token("/v1.1/auth", req_body)
+        else:
+            raise NotImplementedError("Version %s is not supported"
+                                      % self.version)
+
+    def _get_token(self, path, req_body):
+        """Set the management url and auth token"""
+        token_url = urlparse.urljoin(self.auth_url, path)
+        resp, body = self.request(token_url, "POST", body=req_body)
+        try:
+            if not self.management_url:
+                self.management_url = body['auth']['serviceCatalog'] \
+                                      [self.service][0]['publicURL']
+            self.auth_token = body['auth']['token']['id']
+        except KeyError:
+            raise NotImplementedError("Service: %s is not available"
+                                      % self.service)
+
+
+class Dbaas(Client):
+    """
+    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, apikey, tenant=None, auth_url=None,
+                 service_name='reddwarf', service_url=None):
+        super(Dbaas, self).__init__(self, username, apikey, tenant, auth_url)
+        self.client = ReddwarfHTTPClient(username, apikey, tenant, auth_url,
+                                         service_name, service_url)
+        self.versions = Versions(self)
+        self.databases = Databases(self)
+        self.instances = Instances(self)
+        self.users = Users(self)
+        self.root = Root(self)
+        self.hosts = Hosts(self)
+        self.storage = StorageInfo(self)
+        self.management = Management(self)
+        self.accounts = Accounts(self)
+        self.configs = Configs(self)
+        self.diagnostics = Interrogator(self)
+
+
+from reddwarfclient.accounts import Accounts
+from reddwarfclient.config import  Configs
+from reddwarfclient.databases import Databases
+from reddwarfclient.instances import Instances
+from reddwarfclient.hosts import Hosts
+from reddwarfclient.management import Management
+from reddwarfclient.root import Root
+from reddwarfclient.storage import StorageInfo
+from reddwarfclient.users import Users
+from reddwarfclient.versions import Versions
+from reddwarfclient.diagnostics import Interrogator

reddwarfclient/accounts.py

@@ -0,0 +1,55 @@
+# 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 novaclient import base
+
+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 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
+

reddwarfclient/base.py

@@ -0,0 +1,15 @@
+
+def isid(obj):
+    """
+    Returns true if the given object can be converted to an ID, false otherwise.
+    """
+    if hasattr(obj, "id"):
+        return True
+    else:
+        try:
+            int(obj)
+        except ValueError:
+            return False
+        else:
+            return True
+

reddwarfclient/common.py

@@ -0,0 +1,113 @@
+#    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 os
+import pickle
+import sys
+
+
+from reddwarfclient import Dbaas
+import exceptions
+
+
+APITOKEN = os.path.expanduser("~/.apitoken")
+
+
+def get_client():
+    """Load an existing apitoken if available"""
+    try:
+        with open(APITOKEN, 'rb') as token:
+            apitoken = pickle.load(token)
+            dbaas = Dbaas(apitoken._user, apitoken._apikey, apitoken._tenant,
+                          apitoken._auth_url, apitoken._service_name,
+                          apitoken._service_url)
+            dbaas.client.auth_token = apitoken._token
+            return dbaas
+    except IOError:
+        print "ERROR: You need to login first and get an auth token\n"
+        sys.exit(1)
+    except:
+        print "ERROR: There was an error using your existing auth token, " \
+              "please login again.\n"
+        sys.exit(1)
+
+
+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)
+
+
+class APIToken(object):
+    """A token object containing the user, apikey and token which
+       is pickleable."""
+
+    def __init__(self, user, apikey, tenant, token, auth_url, service_name,
+                 service_url):
+        self._user = user
+        self._apikey = apikey
+        self._tenant = tenant
+        self._token = token
+        self._auth_url = auth_url
+        self._service_name = service_name
+        self._service_url = service_url
+
+
+class Auth(object):
+    """Authenticate with your username and api key"""
+
+    def __init__(self):
+        pass
+
+    def login(self, user, apikey, tenant="dbaas", auth_url="http://localhost:5000/v1.1",
+              service_name="reddwarf", service_url=None):
+        """Login to retrieve an auth token to use for other api calls"""
+        try:
+            dbaas = Dbaas(user, apikey, tenant, auth_url=auth_url,
+                          service_name=service_name, service_url=service_url)
+            dbaas.authenticate()
+            apitoken = APIToken(user, apikey, tenant, dbaas.client.auth_token,
+                                auth_url, service_name, service_url)
+
+            with open(APITOKEN, 'wb') as token:
+                pickle.dump(apitoken, token, protocol=2)
+            print apitoken._token
+        except:
+            print sys.exc_info()[1]

reddwarfclient/config.py

@@ -0,0 +1,73 @@
+# 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 novaclient import base
+
+
+class Config(base.Resource):
+    """
+    A configuration entry
+    """
+    def __repr__(self):
+        return "<Config: %s>" % self.key
+
+
+class Configs(base.ManagerWithFind):
+    """
+    Manage :class:`Configs` resources.
+    """
+    resource_class = Config
+
+    def create(self, configs):
+        """
+        Create the configuration entries
+        """
+        body = {"configs": configs}
+        url = "/mgmt/configs"
+        resp, body = self.api.client.post(url, body=body)
+
+    def delete(self, config):
+        """
+        Delete an existing configuration
+        """
+        url = "/mgmt/configs/%s"% config
+        self._delete(url)
+
+    def list(self):
+        """
+        Get a list of all configuration entries
+        """
+        resp, body = self.api.client.get("/mgmt/configs")
+        if not body:
+            raise Exception("Call to /mgmt/configs did not return a body.")
+        return [self.resource_class(self, res) for res in body['configs']]
+
+    def get(self, config):
+        """
+        Get the specified configuration entry
+        """
+        url = "/mgmt/configs/%s" % config
+        resp, body = self.api.client.get(url)
+        if not body:
+            raise Exception("Call to %s did not return a body." % url)
+        return self.resource_class(self, body['config'])
+
+    def update(self, config):
+        """
+        Update the configuration entries
+        """
+        body = {"config": config}
+        url = "/mgmt/configs/%s" % config['key']
+        resp, body = self.api.client.put(url, body=body)