Merge lp:~facundo/ubuntuone-storage-protocol/simple_auth into lp:ubuntuone-storage-protocol

[Facundo Batista]

Use simple authentication against the server.

Use simple authentication against the server.

[Roberto Alsina (ralsina)]

review: Approve

Unmerged revisions

165. By Facundo Batista on 2015-05-18

Use simple authentication against the server.

=== modified file 'tests/test_client.py'
--- tests/test_client.py	2013-02-06 22:06:03 +0000
+++ tests/test_client.py	2015-05-18 17:24:40 +0000
@@ -1,9 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Author: Natalia B. Bidart <[e-mail]>
-# Author: Alejandro J. Cura <[e-mail]>
-#
-# Copyright (C) 2009-2012 Canonical Ltd.
+# Copyright (C) 2009-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License version 3,
@@ -34,15 +31,12 @@
 import StringIO
 import os
 import sys
-import time
 import unittest
 import uuid
 
-from urlparse import urlparse, parse_qsl
-
 from twisted.application import internet, service
 from twisted.internet import defer
-from twisted.internet.defer import Deferred, inlineCallbacks
+from twisted.internet.defer import Deferred
 from twisted.trial.unittest import TestCase as TwistedTestCase
 from twisted.web import server, resource
 
@@ -50,12 +44,10 @@
 from ubuntuone.storageprotocol.client import (
     StorageClient, CreateUDF, ListVolumes, DeleteVolume, GetDelta, Unlink,
     Authenticate, MakeFile, MakeDir, PutContent, Move, BytesMessageProducer,
-    TwistedTimestampChecker, tx_timestamp_checker,
 )
 
 from ubuntuone.storageprotocol import volumes
 from tests import test_delta_info
-from oauthlib.oauth1 import Client
 
 # let's not get picky about aatributes outside __init__ in tests
 # pylint: disable=W0201
@@ -797,46 +789,6 @@
         self.assertEqual(len(msg.auth_parameters), 1)
         self.assertEqual(len(msg.metadata), 0)
 
-    def test_oauth_authenticate_uses_server_timestamp(self):
-        """The oauth authentication uses the server timestamp."""
-        timestamps = []
-
-        original_sign = Client.sign
-
-        def fake_sign(self, *args, **kwargs):
-            """A fake Client.sign()."""
-            url, headers, body = original_sign(self, *args, **kwargs)
-            timestamps.extend(
-                value for name, value in parse_qsl(urlparse(url).query)
-                if name == 'oauth_timestamp')
-            return url, headers, body
-
-        fake_timestamp = '801'
-        timestamp_d = Deferred()
-        self.patch(tx_timestamp_checker, "get_faithful_time",
-                   lambda: timestamp_d)
-
-        self.patch(Client, 'sign', fake_sign)
-        protocol = FakedProtocol()
-        # For backward compatibility of the API, oauth_authenticate() takes a
-        # consumer object and a token object.  Both of those must have .key
-        # and .secret attributes.  In modern OAuth1 (i.e. RFC 5849)
-        # terminology, the consumer is really the OAuth client, and the token
-        # is really the OAuth resource owner.
-
-        class OAuthClient:
-            key = 'consumer_key'
-            secret = 'consumer_secret'
-
-        class OAuthResourceOwner:
-            key = 'token'
-            secret = 'token_secret'
-        protocol.oauth_authenticate(OAuthResourceOwner, OAuthClient)
-        self.assertEqual(len(timestamps), 0)
-        timestamp_d.callback(fake_timestamp)
-        self.assertEqual(len(timestamps), 1)
-        self.assertEqual(timestamps[0], fake_timestamp)
-
 
 class RootResource(resource.Resource):
     """A root resource that logs the number of calls."""
@@ -878,73 +830,6 @@
         self.service_collection.stopService()
 
 
-class TimestampCheckerTestCase(TwistedTestCase):
-    """Tests for the timestamp checker."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        yield super(TimestampCheckerTestCase, self).setUp()
-        self.ws = MockWebServer()
-        self.addCleanup(self.ws.stop)
-        self.patch(TwistedTimestampChecker, "SERVER_URL", self.ws.get_url())
-
-    @inlineCallbacks
-    def test_returned_value_is_int(self):
-        """The returned value is an integer."""
-        checker = TwistedTimestampChecker()
-        t = yield checker.get_faithful_time()
-        self.assertEqual(type(t), int)
-
-    @inlineCallbacks
-    def test_first_call_does_head(self):
-        """The first call gets the clock from our web."""
-        checker = TwistedTimestampChecker()
-        yield checker.get_faithful_time()
-        self.assertEqual(self.ws.root.count, 1)
-
-    @inlineCallbacks
-    def test_second_call_is_cached(self):
-        """For the second call, the time is cached."""
-        checker = TwistedTimestampChecker()
-        yield checker.get_faithful_time()
-        yield checker.get_faithful_time()
-        self.assertEqual(self.ws.root.count, 1)
-
-    @inlineCallbacks
-    def test_after_timeout_cache_expires(self):
-        """After some time, the cache expires."""
-        fake_timestamp = 1
-        self.patch(time, "time", lambda: fake_timestamp)
-        checker = TwistedTimestampChecker()
-        yield checker.get_faithful_time()
-        fake_timestamp += TwistedTimestampChecker.CHECKING_INTERVAL
-        yield checker.get_faithful_time()
-        self.assertEqual(self.ws.root.count, 2)
-
-    @inlineCallbacks
-    def test_server_error_means_skew_not_updated(self):
-        """When server can't be reached, the skew is not updated."""
-        fake_timestamp = 1
-        self.patch(time, "time", lambda: fake_timestamp)
-        checker = TwistedTimestampChecker()
-        failing_get_server_time = lambda: defer.fail(FakedError())
-        self.patch(checker, "get_server_time", failing_get_server_time)
-        yield checker.get_faithful_time()
-        self.assertEqual(checker.skew, 0)
-        self.assertEqual(checker.next_check,
-                    fake_timestamp + TwistedTimestampChecker.ERROR_INTERVAL)
-
-    @inlineCallbacks
-    def test_server_date_sends_nocache_headers(self):
-        """Getting the server date sends the no-cache headers."""
-        checker = TwistedTimestampChecker()
-        yield checker.get_server_date_header(self.ws.get_url())
-        assert len(self.ws.root.request_headers) == 1
-        headers = self.ws.root.request_headers[0]
-        result = headers.getRawHeaders("Cache-Control")
-        self.assertEqual(result, ["no-cache"])
-
-
 class TestGenerationInRequests(RequestTestCase):
     """Base class for testing that actions that change the volume will
     have a new_generation attribute set."""
@@ -992,8 +877,8 @@
 
     def build_request(self):
         """Creates the request object."""
-        return self.request_class(FakedProtocol(), None, None, None, None,
-                          None, None, None, None)
+        return self.request_class(
+            FakedProtocol(), None, None, None, None, None, None, None, None)
 
     def build_message(self):
         """Creates the ending message for the request."""
@@ -1040,8 +925,8 @@
     def test_bytesmessageproducer_maxpayloadsize(self):
         """The producer uses the payload size from the request."""
         # set up the PutContent
-        pc = self.request_class(FakedProtocol(), None, None, None, None,
-                        None, None, None, None)
+        pc = self.request_class(
+            FakedProtocol(), None, None, None, None, None, None, None, None)
         assert 12345 != pc.max_payload_size
         pc.max_payload_size = 12345
 

=== modified file 'tests/test_context.py'
--- tests/test_context.py	2014-04-14 22:21:04 +0000
+++ tests/test_context.py	2015-05-18 17:24:40 +0000
@@ -1,6 +1,6 @@
 # tests.test_context - test ssl context creation
 #
-# Copyright 2012 Canonical Ltd.
+# Copyright 2012-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License version 3,
@@ -35,7 +35,12 @@
 from twisted.web import client, resource, server
 
 from ubuntuone.storageprotocol import context
-from ubuntu_sso.utils import get_cert_dir
+
+try:
+    from ubuntu_sso.utils import get_cert_dir
+except ImportError:
+    # old system, let's support Precise
+    get_cert_dir = lambda: '/etc/ssl/certs'
 
 
 class FakeCerts(object):

=== modified file 'ubuntuone/storageprotocol/client.py'
--- ubuntuone/storageprotocol/client.py	2013-02-25 15:21:30 +0000
+++ ubuntuone/storageprotocol/client.py	2015-05-18 17:24:40 +0000
@@ -6,7 +6,7 @@
 # Author: Facundo Batista <[e-mail]>
 # Author: Alejandro J. Cura <[e-mail]>
 #
-# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2009-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License version 3,
@@ -39,42 +39,22 @@
 
 from functools import partial
 from itertools import chain
-from urlparse import urlparse, parse_qsl
-from oauthlib.oauth1 import Client, SIGNATURE_PLAINTEXT, SIGNATURE_TYPE_QUERY
 
 from twisted.internet.protocol import ClientFactory
 from twisted.internet import reactor, defer
 from twisted.python import log
-from twisted.web import client
-from twisted.web.http_headers import Headers
 
 from ubuntuone.storageprotocol import (
     delta,
     protocol_pb2,
     request,
     sharersp,
-    utils,
     volumes,
 )
 
 log_debug = partial(log.msg, loglevel=logging.DEBUG)
 
 
-class TwistedTimestampChecker(utils.BaseTimestampChecker):
-    """A timestamp that's regularly checked with a server."""
-
-    @defer.inlineCallbacks
-    def get_server_date_header(self, server_url):
-        """Get the server date using twisted webclient."""
-        agent = client.Agent(reactor)
-        headers = Headers({'Cache-Control': ['no-cache']})
-        response = yield agent.request("HEAD", server_url, headers)
-        defer.returnValue(response.headers.getRawHeaders("Date")[0])
-
-
-tx_timestamp_checker = TwistedTimestampChecker()
-
-
 class StorageClient(request.RequestHandler):
     """A Basic Storage Protocol client."""
 
@@ -140,38 +120,15 @@
         p.start()
         return p.deferred
 
-    @defer.inlineCallbacks
-    def oauth_authenticate(self, consumer, token, metadata=None):
-        """Authenticate to a server using the OAuth provider.
-
-        @param consumer: the OAuth consumer (a.k.a. client in RFC 5849) to
-            authenticate with.
-        @type consumer: object having both a `.key` and `.secret` attribute.
-        @param token: a previously acquired OAuth access token (a.k.a.
-            resource owner in RFC 5849).
-        @type token: object having both a `.key` and `.secret` attribute.
-        @param metadata: key/values to send as metadata
-
-        Return a deferred that will get called with the request
-        object when completed.
-
-        """
-        timestamp = yield tx_timestamp_checker.get_faithful_time()
-        client = Client(consumer.key, consumer.secret,
-                        token.key, token.secret,
-                        signature_method=SIGNATURE_PLAINTEXT,
-                        signature_type=SIGNATURE_TYPE_QUERY,
-                        timestamp=timestamp)
-        url, headers, body = client.sign('http://server')
-        # Parse out the authentication parameters from the query string.
-        auth_parameters = dict(
-            (name, value) for name, value in
-            parse_qsl(urlparse(url).query)
-            if name.startswith('oauth_'))
+    def simple_authenticate(self, username, password, metadata=None):
+        """Authenticate to a server using the username and password."""
+        auth_parameters = {
+            'username': username,
+            'password': password,
+        }
         p = Authenticate(self, auth_parameters, metadata=metadata)
         p.start()
-        result = yield p.deferred
-        defer.returnValue(result)
+        return p.deferred
 
     def handle_ROOT(self, message):
         """Handle incoming ROOT message.
@@ -1756,10 +1713,10 @@
     def checkReadBandwidth(self):
         """Check if we've passed bandwidth limits."""
         limit_check = self.valid_limit(self.readLimit) and \
-                self.readLimit is not None and \
-                self.readThisSecond >= self.readLimit
+            self.readLimit is not None and \
+            self.readThisSecond >= self.readLimit
         should_check = self.throttling_enabled and limit_check and \
-                self.unthrottleReadsID is None
+            self.unthrottleReadsID is None
         if should_check:
             self.throttleReads()
             throttle_time = self._get_throttle_time(self.readThisSecond,
@@ -1771,14 +1728,14 @@
     def checkWriteBandwidth(self):
         """Check if we've passed bandwidth limits."""
         limit_check = self.valid_limit(self.writeLimit) and \
-                self.writeLimit is not None and \
-                self.writtenThisSecond >= self.writeLimit
+            self.writeLimit is not None and \
+            self.writtenThisSecond >= self.writeLimit
         should_check = self.throttling_enabled and limit_check and \
-                self.unthrottleWritesID is None
+            self.unthrottleWritesID is None
         if should_check:
             self.throttleWrites()
             throttle_time = self._get_throttle_time(self.writtenThisSecond,
-                                                self.writeLimit)
+                                                    self.writeLimit)
             log_debug("pause writes for: %s", str(throttle_time))
             self.unthrottleWritesID = self.maybeCallLater(
                 'unthrottleWritesID', throttle_time, self.unthrottleWrites)
@@ -1787,8 +1744,8 @@
         """Reset the counter named with 'name' every 1 second."""
         # check the bandwidth limits
         self.readThisSecond = 0
-        self.resetReadThisSecondID = self.callLater(1,
-                                                   self._resetReadThisSecond)
+        self.resetReadThisSecondID = self.callLater(
+            1, self._resetReadThisSecond)
 
     def _resetWrittenThisSecond(self):
         """Reset the counter named with 'name' every 1 second."""

=== modified file 'ubuntuone/storageprotocol/context.py'
--- ubuntuone/storageprotocol/context.py	2014-04-14 22:21:04 +0000
+++ ubuntuone/storageprotocol/context.py	2015-05-18 17:24:40 +0000
@@ -1,6 +1,6 @@
 # ubuntuone.storageprotocol.context - ssl context creation
 #
-# Copyright 2009-2012 Canonical Ltd.
+# Copyright 2009-2015 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License version 3,
@@ -35,7 +35,11 @@
 from twisted.internet import error, ssl
 from twisted.python import log
 
-from ubuntu_sso.utils import get_cert_dir
+try:
+    from ubuntu_sso.utils import get_cert_dir
+except ImportError:
+    # old system, let's support Precise
+    get_cert_dir = lambda: '/etc/ssl/certs'
 
 
 class HostnameVerifyContextFactory(ssl.CertificateOptions):
@@ -52,7 +56,8 @@
             # No extra checks because U1 certs have the right commonName
             if self.expected_hostname != cert.get_subject().commonName:
                 log.err("Host name does not match certificate. "
-                        "Expected %s but got %s." % (self.expected_hostname,
+                        "Expected %s but got %s." % (
+                            self.expected_hostname,
                             cert.get_subject().commonName))
                 return False
         return preverifyOK
@@ -95,5 +100,6 @@
             raise error.CertificateError(
                 'No hostname specified. Unable to verify SSL certificate.')
         ctx = HostnameVerifyContextFactory(hostname, verify=True,
-                          caCerts=get_certificates(), method=SSL.SSLv23_METHOD)
+                                           caCerts=get_certificates(),
+                                           method=SSL.SSLv23_METHOD)
     return ctx