Merge lp:~thisfred/ubuntuone-couch/add-tests into lp:~thisfred/ubuntuone-couch/trunk

[Eric Casteleijn]

Fixed and refactored u1couch-query and added tests

Fixed and refactored u1couch-query and added tests

[lp:~thisfred/ubuntuone-couch/add-tests]

14. By Eric Casteleijn on 2011-02-17

unchanged: attach bug

[Alejandro J. Cura (alecu)]

Great to see this being tested and tidied up. Good work!
I've added bug #720917 so the request method returns only json or Exceptions, and thisfred agreed to work on that on a subsequent branch.

review: Approve

[Natalia Bidart (nataliabidart)]

Added bug #720928 to use u1 specific login service.

review: Approve

=== renamed file 'bin/ubuntuone-couchdb-query' => 'bin/u1couch-query' (properties changed: -x to +x)
--- bin/ubuntuone-couchdb-query	2011-02-14 20:21:08 +0000
+++ bin/u1couch-query	2011-02-17 19:10:44 +0000
@@ -1,204 +1,55 @@
 #!/usr/bin/python
+
+# Copyright 2011 Canonical Ltd.
+#
+# Ubuntu One Couch is free software: you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public License
+# version 3 as published by the Free Software Foundation.
+#
+# Ubuntu One Couch is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with desktopcouch. If not, see
+# <http://www.gnu.org/licenses/>.
+
 """ubuntuone-couchdb-query: Command line query tool for Ubuntu One CouchDBs"""
 
-# [e-mail], 2010-02-13
 
 from optparse import OptionParser
-from oauth import oauth
-import gnomekeyring, gobject, httplib2, simplejson, urlparse, cgi, urllib
-
-try:
-    from ubuntu_sso.main import SSOCredentials
-except ImportError:
-    SSOCredentials = None
 
 import socket
+from u1couch import query
+
 socket.setdefaulttimeout(5)
 
-def get_prod_oauth_token():
-    """Get the token from the keyring"""
-    gobject.set_application_name("Ubuntu One Web API Tool")
-
-    consumer = oauth.OAuthConsumer("ubuntuone", "hammertime")
-    items = []
-    items = gnomekeyring.find_items_sync(
-        gnomekeyring.ITEM_GENERIC_SECRET,
-        {'ubuntuone-realm': "https://ubuntuone.com",
-         'oauth-consumer-key': consumer.key})
-    return oauth.OAuthToken.from_string(items[0].secret)
-
-def get_prod_oauth_token(explicit_token_store=None):
-    """Get the token from the keyring"""
-    gobject.set_application_name("Ubuntu One Web API Tool")
-    if (SSOCredentials is not None) and (explicit_token_store in ["sso", None]):
-        creds = SSOCredentials('Ubuntu One')
-        info = creds.find_credentials('Ubuntu One')
-        consumer = oauth.OAuthConsumer(info['consumer_key'],
-                                    info['consumer_secret'])
-        secret='oauth_token=%s&oauth_token_secret=%s' % (info['token'],
-                                                        info['token_secret'])
-    elif explicit_token_store in ["hammertime", None]:
-        consumer = oauth.OAuthConsumer("ubuntuone", "hammertime")
-        items = []
-        items = gnomekeyring.find_items_sync(
-            gnomekeyring.ITEM_GENERIC_SECRET,
-            {'ubuntuone-realm': "https://ubuntuone.com",
-            'oauth-consumer-key': consumer.key})
-        secret = items[0].secret
-    else:
-        raise Exception("Wasn't able to get a token")
-
-    return (oauth.OAuthToken.from_string(secret), consumer)
-
-def get_oauth_request_header(consumer, access_token, http_url, signature_method):
-    """Get an oauth request header given the token and the url"""
-    assert http_url.startswith("https")
-    oauth_request = oauth.OAuthRequest.from_consumer_and_token(
-        http_url=http_url,
-        http_method="GET",
-        oauth_consumer=consumer,
-        token=access_token)
-    oauth_request.sign_request(signature_method, consumer, access_token)
-    return oauth_request.to_header()
-
-def request(urlpath, sigmeth, http_method, request_body, show_tokens, 
-        server_override=None, explicit_token_store=None):
-    """Make a request to couchdb.one.ubuntu.com for the user's data.
-    
-       The user supplies a urlpath (for example, dbname). We need to actually
-       request https://couchdb.one.ubuntu.com/PREFIX/dbname, and sign it with
-       the user's OAuth token, which must be in the keyring.
-       
-       We find the prefix by querying https://one.ubuntu.com/api/account/
-       (see desktopcouch.replication_services.ubuntuone, which does this).
-    """
-    
-    # First check that there's a token in the keyring.
-    try:
-        (access_token, consumer) = get_prod_oauth_token(explicit_token_store)
-    except: # bare except, norty
-        raise Exception("Unable to retrieve your Ubuntu One access details "
-            "from the keyring. Try connecting your machine to Ubuntu One.")
-    
-    # Set the signature method. This should be HMAC unless you have a jolly
-    # good reason for it to not be.
-    if sigmeth == "PLAINTEXT":
-        signature_method = oauth.OAuthSignatureMethod_PLAINTEXT()
-    elif sigmeth == "HMAC_SHA1":
-        signature_method = oauth.OAuthSignatureMethod_HMAC_SHA1()
-    else:
-        signature_method = oauth.OAuthSignatureMethod_PLAINTEXT()
-    
-    if show_tokens:
-        print "Using OAuth data:"
-        print "consumer: %s : %s\ntoken: %s" % (
-            consumer.key, consumer.secret, access_token)
-    
-    # Look up the user's prefix
-    infourl = "https://one.ubuntu.com/api/account/"
-    oauth_header = get_oauth_request_header(consumer, access_token, infourl, signature_method)
-    client = httplib2.Http()
-    resp, content = client.request(infourl, "GET", headers=oauth_header)
-    if resp['status'] == "200":
-        try:
-            document = simplejson.loads(content)
-        except ValueError:
-            raise Exception("Got unexpected content:\n%s" % content)
-        if "couchdb_root" not in document:
-            raise ValueError("couchdb_root not found in %s" % (document,))
-        if "id" not in document:
-            raise ValueError("id not found in %s" % (document,))
-        COUCH_ROOT = document["couchdb_root"]
-        USERID = document["id"]
-    else:
-        raise ValueError("Error retrieving user data (%s)" % (resp['status'], 
-            url))
-
-    # COUCH_ROOT must have all internal slashes escaped
-    schema, netloc, path, params, query, fragment = urlparse.urlparse(COUCH_ROOT)
-    if server_override:
-        netloc = server_override
-    path = "/" + urllib.quote(path[1:], safe="") # don't escape the first /
-    COUCH_ROOT = urlparse.urlunparse((schema, netloc, path, params, query, fragment))
-    
-    # Now use COUCH_ROOT and the specified user urlpath to get data
-    if urlpath == "_all_dbs":
-        couch_url = "%s%s" % (COUCH_ROOT, urlpath)
-        couch_url = urlparse.urlunparse((schema, netloc, "_all_dbs", None, "user_id=%s" % USERID, None))
-    else:
-        couch_url = "%s%%2F%s" % (COUCH_ROOT, urlpath)
-    schema, netloc, path, params, query, fragment = urlparse.urlparse(couch_url)
-    querystr_as_dict = dict(cgi.parse_qsl(query))
-    oauth_request = oauth.OAuthRequest.from_consumer_and_token(
-        http_url=couch_url,
-        http_method=http_method,
-        oauth_consumer=consumer,
-        token=access_token,
-        parameters=querystr_as_dict)
-    oauth_request.sign_request(signature_method, consumer, access_token)
-    failed = 0
-    #print "Connecting to effective Couch URL", oauth_request.to_url()
-    #print "Connecting to actual Couch URL (with OAuth header)", couch_url
-    #print oauth_request.to_header(), querystr_as_dict
-    while 1:
-        try:
-            resp, content = client.request(couch_url, http_method, 
-                headers=oauth_request.to_header(), body=request_body)
-            break
-        except IOError:
-            failed += 1
-    if failed > 0:
-        if failed == 1:
-            s = ""
-        else:
-            s = "s"
-        print "(request failed %s time%s)" % (failed, s)
-    if resp['status'] == "200":
-        try:
-            return simplejson.loads(content)
-        except:
-            print "(data returned from CouchDB was invalid JSON)"
-            return content
-    elif resp['status'] == "400":
-        print "The server could not parse the oauth token:\n%s" % content
-    elif resp['status'] == "401":
-        print "Access Denied"
-        print "Content:"
-        return content
-    else:
-        return (
-            "There was a problem processing the request:\nstatus:%s, response:"
-            " %r" % (resp['status'], content))
-
 
 if __name__ == "__main__":
-    parser = OptionParser(usage="prog [options] urlpath")
-    parser.add_option("--oauth-signature-method", dest="sigmeth",
+    PARSER = OptionParser(usage="prog [options] urlpath")
+    PARSER.add_option("--oauth-signature-method", dest="sigmeth",
                       default="HMAC_SHA1",
                       help="OAuth signature method to use (PLAINTEXT or "
                       "HMAC_SHA1)")
-    parser.add_option("--http-method", dest="http_method",
+    PARSER.add_option("--http-method", dest="http_method",
                       default="GET",
                       help="HTTP method to use")
-    parser.add_option("--body", dest="body",
+    PARSER.add_option("--body", dest="body",
                       default=None,
                       help="HTTP request body")
-    parser.add_option("--show-tokens", dest="show_tokens",
+    PARSER.add_option("--show-tokens", dest="show_tokens",
                       default=False,
                       help="Show the OAuth tokens we're using")
-    parser.add_option("--server-override", dest="server_override",
+    PARSER.add_option("--server-override", dest="server_override",
                       default=None,
                       help="Use a different server")
-    parser.add_option("--explicit-token-store", dest="explicit_token_store",
-                      default=None,
-                      help="Explicitly choose a token store (sso or hammertime)")
 
-    (options, args) = parser.parse_args()
-    if len(args) != 1:
-        parser.error("You must specify a urlpath (e.g., a dbname)")
-    print request(
-        urlpath=args[0], sigmeth=options.sigmeth,
-        http_method=options.http_method, request_body=options.body,
-        show_tokens=options.show_tokens, 
-        server_override=options.server_override,
-        explicit_token_store=options.explicit_token_store)
+    (OPTIONS, ARGS) = PARSER.parse_args()
+    if len(ARGS) != 1:
+        PARSER.error("You must specify a urlpath (e.g., a dbname)")
+    print query.request(
+        urlpath=ARGS[0], sig_meth=OPTIONS.sigmeth,
+        http_method=OPTIONS.http_method, request_body=OPTIONS.body,
+        show_tokens=OPTIONS.show_tokens,
+        server_override=OPTIONS.server_override)
 
=== renamed file 'bin/ubuntuone-sign-uri' => 'bin/ubuntuone-sign-uri.py' (properties changed: -x to +x)
=== added directory 'tests'
=== added file 'tests/__init__.py'
=== added file 'tests/test_u1couchquery.py'
--- tests/test_u1couchquery.py	1970-01-01 00:00:00 +0000
+++ tests/test_u1couchquery.py	2011-02-17 19:10:44 +0000
@@ -0,0 +1,164 @@
+# Copyright 2011 Canonical Ltd.
+#
+# Ubuntu One Couch is free software: you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public License
+# version 3 as published by the Free Software Foundation.
+#
+# Ubuntu One Couch is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with desktopcouch. If not, see
+# <http://www.gnu.org/licenses/>.
+
+"""Tests for u1couch.query."""
+
+from twisted.trial.unittest import TestCase
+from mocker import Mocker, ANY
+
+import ubuntu_sso
+import json
+from oauth import oauth
+from u1couch import query
+
+CONSUMER_KEY = u'this_consumer_key'
+CONSUMER_SECRET = u'sssssh!'
+TOKEN_KEY = u'tokentokentoken'
+TOKEN_SECRET = u'ssssssshhhhhh!'
+
+CONSUMER = oauth.OAuthConsumer(CONSUMER_KEY, CONSUMER_SECRET)
+TOKEN = oauth.OAuthToken(TOKEN_KEY, TOKEN_SECRET)
+
+URL = 'https://example.com'
+
+
+class QueryTestCase(TestCase):
+    """Test case for u1couch.query."""
+
+    def setUp(self):
+        self.mocker = Mocker()
+
+    def tearDown(self):
+        self.mocker.restore()
+        self.mocker.verify()
+
+    def test_get_oauth_request_header(self):
+        """Test get_oauth_request_header returns correct headers."""
+        fake_headers = {'Authorization':
+             'OAuth realm="", oauth_nonce="39941541", '
+             'oauth_timestamp="1297958903", '
+             'oauth_consumer_key="this_consumer_key", '
+             'oauth_signature_method="HMAC-SHA1", oauth_version="1.0", '
+             'oauth_token="tokentokentoken", '
+             'oauth_signature="TNIfersCweWluuuJW%2FT%2FbW9IHD0%3D"'}
+        mock_oauth = self.mocker.replace("oauth.oauth")
+        mock_oauth.OAuthRequest                # pylint: disable=W0104
+        MockOAuthRequest = self.mocker.mock()  # pylint: disable=C0103
+        self.mocker.result(MockOAuthRequest)
+        MockOAuthRequest.from_consumer_and_token(
+            http_url=URL, http_method='GET', oauth_consumer=CONSUMER,
+            token=TOKEN)
+        oauth_request = self.mocker.mock()
+        self.mocker.result(oauth_request)
+        oauth_request.sign_request(query.HMAC_SHA1, CONSUMER, TOKEN)
+        oauth_request.to_header()
+        self.mocker.result(fake_headers)
+        self.mocker.replay()
+        headers = query.get_oauth_request_header(CONSUMER, TOKEN, URL)
+        self.assertEquals(fake_headers, headers)
+
+    def test_get_oauth_request_header_http(self):
+        """Test get_oauth_request_header fails on http urls."""
+        self.assertRaises(
+            AssertionError, query.get_oauth_request_header, CONSUMER, TOKEN,
+            'http://example.com')
+
+    def test_get_oauth_data(self):
+        """Test get_oauth_data returns proper oauth data."""
+        self.patch(query, "undbusify", lambda x: x)
+        dbus = self.mocker.replace("dbus")
+        self.mocker.replace("dbus.mainloop.glib.DBusGMainLoop")
+        bus = dbus.SessionBus()
+        bus.get_object(
+            ubuntu_sso.DBUS_BUS_NAME, ubuntu_sso.DBUS_CRED_PATH,
+            follow_name_owner_changes=True)
+        mock_proxy = self.mocker.mock()
+        self.mocker.result(mock_proxy)
+        mock_proxy.find_credentials(query.APP_NAME)
+        self.mocker.result({
+            u'token': TOKEN_KEY,
+            u'token_secret': TOKEN_SECRET,
+            u'consumer_secret': CONSUMER_SECRET,
+            u'consumer_key': CONSUMER_KEY})
+        self.mocker.replay()
+        oauth_data = query.get_oauth_data()
+        self.assertEquals(CONSUMER_KEY, oauth_data['consumer_key'])
+        self.assertEquals(CONSUMER_SECRET, oauth_data['consumer_secret'])
+        self.assertEquals(TOKEN_KEY, oauth_data['token'])
+        self.assertEquals(TOKEN_SECRET, oauth_data['token_secret'])
+
+    def test_get_prod_oauth_token(self):
+        """Test get_prod_oauth_token returns token and consumer."""
+        info = {
+            u'token': TOKEN_KEY,
+            u'token_secret': TOKEN_SECRET,
+            u'consumer_secret': CONSUMER_SECRET,
+            u'consumer_key': CONSUMER_KEY}
+        token, consumer = query.get_prod_oauth_token(info)
+        self.assertEquals(TOKEN_KEY, token.key)
+        self.assertEquals(TOKEN_SECRET, token.secret)
+        self.assertEquals(CONSUMER_KEY, consumer.key)
+        self.assertEquals(CONSUMER_SECRET, consumer.secret)
+
+    def test_get_user_info(self):
+        """Test get_user_info parses json correctly."""
+        mock_header = self.mocker.mock()
+        Http = self.mocker.replace("httplib2.Http")  # pylint: disable=C0103
+        http = Http()
+        http.request(URL, "GET", headers=mock_header)
+        self.mocker.result((
+            {'status': '200'},
+            '{"couchdb_root": "https://couchdb.one.ubuntu.com/u/abc/def/1337",'
+            ' "id": 1337}'))
+        self.mocker.replay()
+        user_id, root = query.get_user_info(URL, mock_header)
+        self.assertEquals(1337, user_id)
+        self.assertEquals(
+            "https://couchdb.one.ubuntu.com/u/abc/def/1337", root)
+
+    def test_request(self):
+        """Test a full request."""
+        fake_result = {
+            'committed_update_seq': 654,
+            'compact_running': False,
+            'db_name': 'u/abc/def/1337/contacts',
+            'disk_format_version': 5,
+            'disk_size': 929892,
+            'doc_count': 626,
+            'doc_del_count': 1,
+            'instance_start_time': '1297965776474824',
+            'purge_seq': 0,
+            'update_seq': 654}
+        fake_json = json.dumps(fake_result)
+        get_oauth_data = self.mocker.replace('u1couch.query.get_oauth_data')
+        get_oauth_data()
+        self.mocker.result({
+            u'token': TOKEN_KEY,
+            u'token_secret': TOKEN_SECRET,
+            u'consumer_secret': CONSUMER_SECRET,
+            u'consumer_key': CONSUMER_KEY})
+        get_user_info = self.mocker.replace('u1couch.query.get_user_info')
+        get_user_info('https://one.ubuntu.com/api/account/', ANY)
+        self.mocker.result((
+            1337, "https://couchdb.one.ubuntu.com/u/abc/def/1337"))
+        Http = self.mocker.replace("httplib2.Http")  # pylint: disable=C0103
+        http = Http()
+        http.request(
+            'https://couchdb.one.ubuntu.com/u%2Fabc%2Fdef%2F1337%2Fcontacts',
+            'GET', headers=ANY, body=None)
+        self.mocker.result(({'status': '200'}, fake_json))
+        self.mocker.replay()
+        result = query.request('contacts')
+        self.assertEquals(fake_result, result)
 
=== added directory 'u1couch'
=== added file 'u1couch/__init__.py'
=== added file 'u1couch/query.py'
--- u1couch/query.py	1970-01-01 00:00:00 +0000
+++ u1couch/query.py	2011-02-17 19:10:44 +0000
@@ -0,0 +1,195 @@
+# Copyright 2011 Canonical Ltd.
+#
+# Ubuntu One Couch is free software: you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public License
+# version 3 as published by the Free Software Foundation.
+#
+# Ubuntu One Couch is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with desktopcouch. If not, see
+# <http://www.gnu.org/licenses/>.
+
+"""Small library for talking to Ubuntu One CouchDBs."""
+
+import cgi
+import dbus
+from dbus.mainloop.glib import DBusGMainLoop
+import logging
+import httplib2
+import json
+import urllib
+import urlparse
+from time import sleep
+from oauth import oauth
+
+import ubuntu_sso
+
+APP_NAME = "Ubuntu One"
+HMAC_SHA1 = oauth.OAuthSignatureMethod_HMAC_SHA1()
+
+
+def undbusify(value):
+    """Convert dbus types back to native types."""
+    for singleton in (None, True, False):
+        if value == singleton:
+            return singleton
+    for val_type in (long, int, float, complex,
+                     unicode, str,
+                     list, tuple, dict, set):
+        if isinstance(value, val_type):
+            return val_type(value)
+    raise TypeError(value)
+
+
+def get_oauth_data():
+    """Information needed to replicate to a server."""
+
+    DBusGMainLoop(set_as_default=True)
+
+    bus = dbus.SessionBus()
+    proxy = bus.get_object(
+        ubuntu_sso.DBUS_BUS_NAME, ubuntu_sso.DBUS_CRED_PATH,
+        follow_name_owner_changes=True)
+    logging.info(
+        'get_oauth_data: asking for credentials to Ubuntu SSO. App name: %s',
+        APP_NAME)
+    oauth_data = dict(
+        (undbusify(k), undbusify(v)) for k, v in
+        proxy.find_credentials(APP_NAME).iteritems())
+    logging.info(
+        'Got credentials from Ubuntu SSO. Non emtpy credentials? %s',
+        len(oauth_data) > 0)
+    return oauth_data
+
+
+def get_prod_oauth_token(info):
+    """Get the token from the keyring."""
+    consumer = oauth.OAuthConsumer(
+        info['consumer_key'], info['consumer_secret'])
+    secret = 'oauth_token=%s&oauth_token_secret=%s' % (
+        info['token'], info['token_secret'])
+
+    return (oauth.OAuthToken.from_string(secret), consumer)
+
+
+def get_oauth_request_header(consumer, access_token, http_url,
+                             signature_method=HMAC_SHA1):
+    """Get an oauth request header given the token and the url."""
+    assert http_url.startswith("https")
+    oauth_request = oauth.OAuthRequest.from_consumer_and_token(
+        http_url=http_url,
+        http_method="GET",
+        oauth_consumer=consumer,
+        token=access_token)
+    oauth_request.sign_request(signature_method, consumer, access_token)
+    return oauth_request.to_header()
+
+
+def get_user_info(info_url, oauth_header):
+    """Look up the user's user id and prefix."""
+    http = httplib2.Http()
+    resp, content = http.request(info_url, "GET", headers=oauth_header)
+    if resp['status'] not in ("200", "201"):
+        raise ValueError(
+            "Error retrieving user data (%s, %s)" % resp['status'])
+    try:
+        document = json.loads(content)
+    except ValueError:
+        raise Exception("Got unexpected content:\n%s" % content)
+    if "couchdb_root" not in document:
+        raise ValueError("couchdb_root not found in %s" % (document,))
+    if "id" not in document:
+        raise ValueError("id not found in %s" % (document,))
+    return document["id"], document["couchdb_root"]
+
+
+def request(urlpath, sig_meth='HMAC_SHA1', http_method='GET',
+            request_body=None, show_tokens=False, server_override=None,
+            access_token=None, consumer=None):
+    """Make a request to couchdb.one.ubuntu.com for the user's data.
+
+    The user supplies a urlpath (for example, dbname). We need to actually
+    request https://couchdb.one.ubuntu.com/PREFIX/dbname, and sign it with
+    the user's OAuth token.
+
+    We find the prefix by querying https://one.ubuntu.com/api/account/
+    (see desktopcouch.replication_services.ubuntuone, which does this).
+
+    """
+    if access_token is None:
+        info = get_oauth_data()
+        (access_token, consumer) = get_prod_oauth_token(info)
+    # Set the signature method. This should be HMAC unless you have a jolly
+    # good reason for it to not be.
+    if sig_meth == "PLAINTEXT":
+        signature_method = oauth.OAuthSignatureMethod_PLAINTEXT()
+    else:
+        signature_method = oauth.OAuthSignatureMethod_HMAC_SHA1()
+    if show_tokens:
+        print "Using OAuth data:"
+        print "consumer: %s : %s\ntoken: %s" % (
+            consumer.key, consumer.secret, access_token)
+
+    info_url = "https://one.ubuntu.com/api/account/"
+    oauth_header = get_oauth_request_header(
+        consumer, access_token, info_url, signature_method)
+
+    userid, couch_root = get_user_info(info_url, oauth_header)
+    schema, netloc, path, params, query, fragment = urlparse.urlparse(
+        couch_root)
+    if server_override:
+        netloc = server_override
+    # Don't escape the first /
+    path = "/" + urllib.quote(path[1:], safe="")
+    couch_root = urlparse.urlunparse((
+        schema, netloc, path, params, query, fragment))
+
+    # Now use COUCH_ROOT and the specified user urlpath to get data
+    if urlpath == "_all_dbs":
+        couch_url = "%s%s" % (couch_root, urlpath)
+        couch_url = urlparse.urlunparse((
+            schema, netloc, "_all_dbs", None, "user_id=%s" % userid, None))
+    else:
+        couch_url = "%s%%2F%s" % (couch_root, urlpath)
+    schema, netloc, path, params, query, fragment = urlparse.urlparse(
+        couch_url)
+    querystr_as_dict = dict(cgi.parse_qsl(query))
+    oauth_request = oauth.OAuthRequest.from_consumer_and_token(
+        http_url=couch_url,
+        http_method=http_method,
+        oauth_consumer=consumer,
+        token=access_token,
+        parameters=querystr_as_dict)
+    oauth_request.sign_request(signature_method, consumer, access_token)
+    failed = 0
+    while True:
+        try:
+            http = httplib2.Http()
+            print couch_url, http_method
+            resp, content = http.request(couch_url, http_method,
+                headers=oauth_request.to_header(), body=request_body)
+            break
+        except IOError:
+            sleep(2 ** failed)  # 1, 2, 4, 8, 16
+            failed += 1
+            if failed > 5:
+                break
+    if failed:
+        print "(request failed %s time%s)" % (
+            failed, "s" if failed > 1 else "")
+    if resp['status'] in ("200", "201"):
+        return json.loads(content)
+    elif resp['status'] == "400":
+        print "The server could not parse the oauth token:\n%s" % content
+    elif resp['status'] == "401":
+        print "Access Denied"
+        print "Content:"
+        return content
+    else:
+        return (
+            "There was a problem processing the request:\nstatus:%s, response:"
+            " %r" % (resp['status'], content))