Merge lp:~alecu/ubuntuone-client/proxy-tunnel-fix into lp:ubuntuone-client

[Alejandro J. Cura]

QNetwork must use the proxy built; forward disconnections in the tunnel client.

QNetwork must use the proxy built; forward disconnections in the tunnel client.

[Eric Casteleijn (thisfred)]

Looking good

review: Approve

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

=== modified file 'tests/proxy/test_tunnel_client.py'
--- tests/proxy/test_tunnel_client.py	2012-03-10 00:39:26 +0000
+++ tests/proxy/test_tunnel_client.py	2012-03-14 17:56:29 +0000
@@ -104,6 +104,60 @@
         self.assertEqual(self.other_proto.content, expected)
 
 
+class FakeOtherFactory(object):
+    """A fake factory."""
+
+    def __init__(self):
+        """Initialize this fake."""
+        self.started_called = None
+        self.failed_called = None
+        self.lost_called = None
+
+    def startedConnecting(self, *args):
+        """Store the call."""
+        self.started_called = args
+
+    def clientConnectionFailed(self, *args):
+        """Store the call."""
+        self.failed_called = args
+
+    def clientConnectionLost(self, *args):
+        """Store the call."""
+        self.lost_called = args
+
+
+class TunnelClientFactoryTestCase(TestCase):
+    """Tests for the TunnelClientFactory."""
+
+    def test_forwards_started(self):
+        """The factory forwards the startedConnecting call."""
+        fake_other_factory = FakeOtherFactory()
+        tcf = tunnel_client.TunnelClientFactory(None, None, fake_other_factory)
+        fake_connector = object()
+        tcf.startedConnecting(fake_connector)
+        self.assertEqual(fake_other_factory.started_called, (fake_connector,))
+
+    def test_forwards_failed(self):
+        """The factory forwards the clientConnectionFailed call."""
+        fake_reason = object()
+        fake_other_factory = FakeOtherFactory()
+        tcf = tunnel_client.TunnelClientFactory(None, None, fake_other_factory)
+        fake_connector = object()
+        tcf.clientConnectionFailed(fake_connector, fake_reason)
+        self.assertEqual(fake_other_factory.failed_called,
+                         (fake_connector, fake_reason))
+
+    def test_forwards_lost(self):
+        """The factory forwards the clientConnectionLost call."""
+        fake_reason = object()
+        fake_other_factory = FakeOtherFactory()
+        tcf = tunnel_client.TunnelClientFactory(None, None, fake_other_factory)
+        fake_connector = object()
+        tcf.clientConnectionLost(fake_connector, fake_reason)
+        self.assertEqual(fake_other_factory.lost_called,
+                         (fake_connector, fake_reason))
+
+
 class TunnelClientTestCase(SquidTestCase):
     """Test the client for the tunnel."""
 

=== modified file 'tests/proxy/test_tunnel_server.py'
--- tests/proxy/test_tunnel_server.py	2012-03-09 22:36:14 +0000
+++ tests/proxy/test_tunnel_server.py	2012-03-14 17:56:29 +0000
@@ -42,8 +42,10 @@
 )
 
 FAKE_SETTINGS = {
-    "host": "myhost",
-    "port": "8888",
+    "http": {
+        "host": "myhost",
+        "port": 8888,
+    }
 }
 
 SAMPLE_HOST = "samplehost.com"
@@ -384,13 +386,21 @@
         return [self]
 
 
-class IsProxyEnabledTestCase(TestCase):
-    """Tests for the is_proxy_enabled function."""
+class CheckProxyEnabledTestCase(TestCase):
+    """Tests for the check_proxy_enabled function."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Initialize this testcase."""
+        yield super(CheckProxyEnabledTestCase, self).setUp()
+        self.app_proxy = []
 
     def _assert_proxy_state(self, platform, state, assertion):
         """Assert the proxy is in a given state."""
+        self.patch(tunnel_server.QNetworkProxy, "setApplicationProxy",
+                   lambda proxy: self.app_proxy.append(proxy))
         self.patch(tunnel_server.sys, "platform", platform)
-        ret = tunnel_server.is_proxy_enabled(SAMPLE_HOST, str(SAMPLE_PORT))
+        ret = tunnel_server.check_proxy_enabled(SAMPLE_HOST, str(SAMPLE_PORT))
         self.assertTrue(ret == state, assertion)
 
     def _assert_proxy_enabled(self, platform):
@@ -406,23 +416,27 @@
         self.patch(tunnel_server.gsettings, "get_proxy_settings",
                    lambda: FAKE_SETTINGS)
         self._assert_proxy_enabled("linux3")
+        self.assertEqual(len(self.app_proxy), 1)
 
     def test_platform_linux_disabled(self):
         """Tests for the linux platform with proxies disabled."""
         self.patch(tunnel_server.gsettings, "get_proxy_settings", lambda: {})
         self._assert_proxy_disabled("linux3")
+        self.assertEqual(len(self.app_proxy), 0)
 
     def test_platform_other_enabled(self):
         """Tests for any other platform with proxies enabled."""
         fake_netproxfact = FakeNetworkProxyFactoryClass(True)
         self.patch(tunnel_server, "QNetworkProxyFactory", fake_netproxfact)
         self._assert_proxy_enabled("windows 1.0")
+        self.assertEqual(len(self.app_proxy), 0)
 
     def test_platform_other_disabled(self):
         """Tests for any other platform with proxies disabled."""
         fake_netproxfact = FakeNetworkProxyFactoryClass(False)
         self.patch(tunnel_server, "QNetworkProxyFactory", fake_netproxfact)
         self._assert_proxy_disabled("windows 1.0")
+        self.assertEqual(len(self.app_proxy), 0)
 
 
 class FakeQCoreApp(object):
@@ -461,7 +475,7 @@
             self.called.append(args)
             return self.proxies_enabled
 
-        self.patch(tunnel_server, "is_proxy_enabled", fake_is_proxy_enabled)
+        self.patch(tunnel_server, "check_proxy_enabled", fake_is_proxy_enabled)
         self.fake_stdout = StringIO()
         self.patch(tunnel_server.sys, "stdout", self.fake_stdout)
         self.patch(tunnel_server, "QCoreApplication", FakeQCoreApp)

=== modified file 'ubuntuone/proxy/logger.py'
--- ubuntuone/proxy/logger.py	2012-02-23 23:58:33 +0000
+++ ubuntuone/proxy/logger.py	2012-03-14 17:56:29 +0000
@@ -20,7 +20,6 @@
 import os
 
 from ubuntuone.logger import (
-    _DEBUG_LOG_LEVEL,
     basic_formatter,
     CustomRotatingFileHandler,
 )
@@ -30,8 +29,8 @@
 
 LOGFILENAME = os.path.join(ubuntuone_log_dir, 'proxy.log')
 logger = logging.getLogger("ubuntuone.proxy")
-logger.setLevel(_DEBUG_LOG_LEVEL)
+logger.setLevel(logging.DEBUG)
 handler = CustomRotatingFileHandler(filename=LOGFILENAME)
 handler.setFormatter(basic_formatter)
-handler.setLevel(_DEBUG_LOG_LEVEL)
+handler.setLevel(logging.DEBUG)
 logger.addHandler(handler)

=== modified file 'ubuntuone/proxy/tunnel_client.py'
--- ubuntuone/proxy/tunnel_client.py	2012-03-10 00:39:26 +0000
+++ ubuntuone/proxy/tunnel_client.py	2012-03-14 17:56:29 +0000
@@ -78,6 +78,18 @@
         self.other_factory = other_factory
         self.context_factory = context_factory
 
+    def startedConnecting(self, connector):
+        """Forward this call to the other factory."""
+        self.other_factory.startedConnecting(connector)
+
+    def clientConnectionFailed(self, connector, reason):
+        """Forward this call to the other factory."""
+        self.other_factory.clientConnectionFailed(connector, reason)
+
+    def clientConnectionLost(self, connector, reason):
+        """Forward this call to the other factory."""
+        self.other_factory.clientConnectionLost(connector, reason)
+
 
 class TunnelClient(object):
     """A client for the proxy tunnel."""

=== modified file 'ubuntuone/proxy/tunnel_server.py'
--- ubuntuone/proxy/tunnel_server.py	2012-03-09 22:36:14 +0000
+++ ubuntuone/proxy/tunnel_server.py	2012-03-14 17:56:29 +0000
@@ -93,6 +93,7 @@
         """When connected, send all pending data."""
         self.connected_d.callback(None)
         for d in self.buffered_data:
+            logger.debug("writing remote: %d bytes", len(d))
             super(RemoteSocket, self).write(d)
         self.buffered_data = []
 
@@ -104,6 +105,7 @@
     def write(self, data):
         """Write data to the remote end, buffering if not connected."""
         if self.state() == QAbstractSocket.ConnectedState:
+            logger.debug("writing remote: %d bytes", len(data))
             super(RemoteSocket, self).write(data)
         else:
             self.buffered_data.append(data)
@@ -218,6 +220,7 @@
 
     def write(self, data):
         """Data available on the remote end. Bring it back."""
+        logger.debug("writing local: %d bytes", len(data))
         self.local_socket.write(data)
 
     def loseConnection(self):
@@ -227,6 +230,7 @@
 
     def local_disconnected(self):
         """The local end disconnected."""
+        logger.debug("The local socket got disconnected.")
         # TODO: handle this case in an upcoming branch
 
 
@@ -258,12 +262,18 @@
         return self.server.serverPort()
 
 
-def is_proxy_enabled(host, port):
+def check_proxy_enabled(host, port):
     """Check if the proxy is enabled."""
     port = int(port)
     if sys.platform.startswith("linux"):
         settings = gsettings.get_proxy_settings()
-        return len(settings) > 0
+        enabled = len(settings) > 0
+        if enabled:
+            proxy = build_proxy(settings["http"])
+            QNetworkProxy.setApplicationProxy(proxy)
+        else:
+            logger.info("Proxy is disabled.")
+        return enabled
     else:
         query = QNetworkProxyQuery(host, port)
         proxies = QNetworkProxyFactory.systemProxyForQuery(query)
@@ -272,7 +282,7 @@
 
 def main(argv):
     """The main function for the tunnel server."""
-    if not is_proxy_enabled(*argv[1:]):
+    if not check_proxy_enabled(*argv[1:]):
         sys.stdout.write("Proxy not enabled.")
         sys.stdout.flush()
     else: