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

[Alejandro J. Cura]

- Tunnel storage protocol if proxy enabled in system settings (LP: #929208).

- Tunnel storage protocol if proxy enabled in system settings. (LP: #929208)

[lp:~alecu/ubuntuone-client/proxy-tunnel-useit]

1218. By Alejandro J. Cura on 2012-03-06

Merged proxy-tunnel-process into proxy-tunnel-useit.

1219. By Alejandro J. Cura on 2012-03-06

move the patching of TunnelRunner to the parent class

1220. By Alejandro J. Cura on 2012-03-07

Merged proxy-tunnel-process into proxy-tunnel-useit.

[Manuel de la Peña (mandel)]

I get the following when I try to run the tests:

== Python Lint Notices ==

./contrib/testing/testcase.py:
    278: undefined name 'reactor'

review: Needs Fixing

[lp:~alecu/ubuntuone-client/proxy-tunnel-useit]

1221. By Alejandro J. Cura on 2012-03-09

merged with parent branch

1222. By Alejandro J. Cura on 2012-03-09

Merged proxy-tunnel-process into proxy-tunnel-useit.

1223. By Alejandro J. Cura on 2012-03-09

Merged proxy-tunnel-process into proxy-tunnel-useit.

1224. By Alejandro J. Cura on 2012-03-09

fixed lint issue

[Manuel de la Peña (mandel)]

I see nothing wrong with the code!

review: Approve

[Natalia Bidart (nataliabidart)]

* Could you please change this assert:

        self.assertTrue(self.spawned, "The tunnel process is started.")

to something that reflects that self.spawned is not a boolean but a list? Perhaps using assertEqual against what should actually be in the list.

* This is in live code, TUNNEL_PORT = "Tunnel port", is it correct? does no look like a port to me :-/

* This import is not alphabetically ordered: from ubuntuone.proxy import tunnel_client. Also, if I understand correctly, that import can fail with an ImportError if the user does not have the -proxy-support debian/ubuntu package installed, since the whole ubuntuone.proxy namespace will be distributed in another binary package (as far as I know).

review: Needs Fixing

[Alejandro J. Cura (alecu)]

> * Could you please change this assert:
>
> self.assertTrue(self.spawned, "The tunnel process is started.")
>
> to something that reflects that self.spawned is not a boolean but a list?
> Perhaps using assertEqual against what should actually be in the list.

Good point, I'll fix it.

> * This is in live code, TUNNEL_PORT = "Tunnel port", is it correct? does no
> look like a port to me :-/

The string is correct.
But I agree that the name of the constant is misleading, so I'm renaming it to something better.

> * This import is not alphabetically ordered: from ubuntuone.proxy import
> tunnel_client. Also, if I understand correctly, that import can fail with an
> ImportError if the user does not have the -proxy-support debian/ubuntu package
> installed, since the whole ubuntuone.proxy namespace will be distributed in
> another binary package (as far as I know).

The tunnel_client.py module should not be part of the different binary package, only tunnel_server.py and bin/ubuntuone-proxy-tunnel depend on qtnet and should be in a different package. Also tunnel_client has code to deal with the case where bin/ubuntuone-proxy-tunnel is not installed or cannot be found, and in that case SD starts just like if no proxies were configured.

[lp:~alecu/ubuntuone-client/proxy-tunnel-useit]

1225. By Alejandro J. Cura on 2012-03-09

fixes requested on review

1226. By Alejandro J. Cura on 2012-03-10

The ubuntuone.proxy namespace can be provided by a different ubuntu package.

[Alejandro J. Cura (alecu)]

I've reworked the branch with the suggestions provided in the review.
It's now pushed and ready for re-review.

[Alejandro J. Cura (alecu)]

review: Abstain

[Natalia Bidart (nataliabidart)]

Second connection attempt is failing with:

Unhandled error in Deferred:
Unhandled Error
Traceback (most recent call last):
  File "/usr/lib/python2.7/dist-packages/twisted/internet/defer.py", line 362, in callback
    self._startRunCallbacks(result)
  File "/usr/lib/python2.7/dist-packages/twisted/internet/defer.py", line 458, in _startRunCallbacks
    self._runCallbacks()
  File "/usr/lib/python2.7/dist-packages/twisted/internet/defer.py", line 545, in _runCallbacks
    current.result = callback(current.result, *args, **kw)
  File "/usr/lib/python2.7/dist-packages/twisted/internet/defer.py", line 1181, in unwindGenerator
    return _inlineCallbacks(None, gen, Deferred())
--- <exception caught here> ---
  File "/usr/lib/python2.7/dist-packages/twisted/internet/defer.py", line 1039, in _inlineCallbacks
    result = g.send(result)
  File "/home/nessita/canonical/client/review_proxy-tunnel-useit/ubuntuone/syncdaemon/action_queue.py", line 832, in _make_connection
    self.connector = client.connectSSL(host, port, factory=self,
exceptions.AttributeError: 'NoneType' object has no attribute 'connectSSL'

Alecu and I already debugged it, so he will be working on a fix.

review: Needs Fixing

[lp:~alecu/ubuntuone-client/proxy-tunnel-useit]

1227. By Alejandro J. Cura on 2012-03-12

get_client() now returns independent deferreds that can be yielded at will

[Natalia Bidart (nataliabidart)]

Looks great!

review: Approve

=== modified file 'bin/ubuntuone-proxy-tunnel' (properties changed: -x to +x)
=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2012-02-09 21:57:00 +0000
+++ contrib/testing/testcase.py	2012-03-12 17:46:23 +0000
@@ -28,7 +28,7 @@
 from collections import defaultdict
 from functools import wraps
 
-from twisted.internet import defer
+from twisted.internet import defer, reactor
 from twisted.trial.unittest import TestCase as TwistedTestCase
 from ubuntuone.devtools.testcases import skipIfOS
 from zope.interface import implements
@@ -267,6 +267,17 @@
         return defer.succeed(True)
 
 
+class FakeTunnelRunner(object):
+    """A fake proxy.tunnel_client.TunnelRunner."""
+
+    def __init__(self, *args):
+        """Fake a proxy tunnel."""
+
+    def get_client(self):
+        """Always return the reactor."""
+        return defer.succeed(reactor)
+
+
 class BaseTwistedTestCase(TwistedTestCase):
     """Base TestCase with helper methods to handle temp dir.
 
@@ -276,6 +287,7 @@
         makedirs(path): support read-only shares
     """
     MAX_FILENAME = 32 # some platforms limit lengths of filenames
+    tunnel_runner_class = FakeTunnelRunner
 
     def mktemp(self, name='temp'):
         """ Customized mktemp that accepts an optional name argument. """
@@ -380,6 +392,8 @@
         # Patch the user home
         self.home_dir = self.mktemp('ubuntuonehacker')
         self.patch(platform, "xdg_home", self.home_dir)
+        self.patch(action_queue.tunnel_runner, "TunnelRunner",
+                   self.tunnel_runner_class)
 
 
 class FakeMainTestCase(BaseTwistedTestCase):
 
=== modified file 'tests/proxy/test_tunnel_client.py'
--- tests/proxy/test_tunnel_client.py	2012-03-09 14:36:34 +0000
+++ tests/proxy/test_tunnel_client.py	2012-03-12 17:46:23 +0000
@@ -84,7 +84,7 @@
 
     def test_sends_connect_request(self):
         """Sends the expected CONNECT request."""
-        expected = tunnel_client.METHOD_LINE.format(self.host, self.port)
+        expected = tunnel_client.METHOD_LINE % (self.host, self.port)
         written = self.tunnel_client_proto.transport.getvalue()
         first_line = written.split(CRLF)[0]
         self.assertEqual(first_line + CRLF, expected)
 
=== modified file 'tests/proxy/test_tunnel_server.py'
--- tests/proxy/test_tunnel_server.py	2012-03-09 15:46:50 +0000
+++ tests/proxy/test_tunnel_server.py	2012-03-12 17:46:23 +0000
@@ -34,11 +34,11 @@
 
 
 FAKE_SESSION_TEMPLATE = (
-    "CONNECT {0.netloc} HTTP/1.0" + CRLF +
+    "CONNECT %s HTTP/1.0" + CRLF +
     "Header1: value1" + CRLF +
     "Header2: value2" + CRLF +
     CRLF +
-    "GET {0.path} HTTP/1.0" + CRLF + CRLF
+    "GET %s HTTP/1.0" + CRLF + CRLF
 )
 
 FAKE_SETTINGS = {
@@ -140,7 +140,8 @@
     def test_complete_connection(self):
         """Test from the tunnel server down."""
         url = urlparse(self.dest_url)
-        client = FakeClientFactory(FAKE_SESSION_TEMPLATE.format(url))
+        fake_session = FAKE_SESSION_TEMPLATE % (url.netloc, url.path)
+        client = FakeClientFactory(fake_session)
         reactor.connectTCP("0.0.0.0", self.tunnel_server.port, client)
         response = yield client.response
         self.assertIn(SAMPLE_CONTENT, response)
@@ -230,7 +231,7 @@
     def test_successful_connect(self):
         """A successful connect thru the tunnel."""
         url = urlparse(self.dest_url)
-        data = FAKE_SESSION_TEMPLATE.format(url)
+        data = FAKE_SESSION_TEMPLATE % (url.netloc, url.path)
         self.proto.dataReceived(data)
         lines = self.transport.getvalue().split(CRLF)
         self.assertEqual(lines[-1], SAMPLE_CONTENT)
@@ -474,7 +475,8 @@
         """With proxies enabled print port to stdout and start the mainloop."""
         self.proxies_enabled = True
         tunnel_server.main(["example.com", "443"])
-        self.assertIn("Tunnel port:", self.fake_stdout.getvalue())
+        self.assertIn(tunnel_server.TUNNEL_PORT_LABEL + ":",
+                      self.fake_stdout.getvalue())
 
     def test_on_proxies_disabled_exit(self):
         """With proxies disabled, print a message and exit gracefully."""
 
=== modified file 'tests/syncdaemon/test_action_queue.py'
--- tests/syncdaemon/test_action_queue.py	2012-02-18 16:13:04 +0000
+++ tests/syncdaemon/test_action_queue.py	2012-03-12 17:46:23 +0000
@@ -186,6 +186,35 @@
         return FakeRequest()
 
 
+class FakeTunnelClient(object):
+    """A fake proxy.tunnel_client."""
+
+    def __init__(self):
+        """Fake this proxy tunnel."""
+        self.tcp_connected = False
+        self.ssl_connected = False
+
+    def connectTCP(self, *args, **kwargs):
+        """Save the connection thru TCP."""
+        self.tcp_connected = True
+
+    def connectSSL(self, *args, **kwargs):
+        """Save the connection thru SSL."""
+        self.ssl_connected = True
+
+
+class SavingConnectionTunnelRunner(object):
+    """A fake proxy.tunnel_client.TunnelRunner."""
+
+    def __init__(self, *args):
+        """Fake a proxy tunnel."""
+        self.client = FakeTunnelClient()
+
+    def get_client(self):
+        """Always return the reactor."""
+        return defer.succeed(self.client)
+
+
 class TestingProtocol(ActionQueue.protocol):
     """Protocol for testing."""
 
@@ -1295,6 +1324,28 @@
                                                 "host 1.2.3.4", "port 4321"))
 
 
+class TunnelRunnerTestCase(FactoryBaseTestCase):
+    """Tests for the tunnel runner."""
+
+    tunnel_runner_class = SavingConnectionTunnelRunner
+
+    @defer.inlineCallbacks
+    def test_make_connection_uses_tunnelrunner_non_ssl(self):
+        """Check that _make_connection uses TunnelRunner."""
+        self.action_queue.use_ssl = False
+        yield self.action_queue._make_connection(("127.0.0.1", 1234))
+        self.assertTrue(self.action_queue.tunnel_runner.client.tcp_connected,
+                        "connectTCP is called on the client.")
+
+    @defer.inlineCallbacks
+    def test_make_connection_uses_tunnelrunner_ssl(self):
+        """Check that _make_connection uses TunnelRunner."""
+        self.action_queue.use_ssl = True
+        yield self.action_queue._make_connection(("127.0.0.1", 1234))
+        self.assertTrue(self.action_queue.tunnel_runner.client.ssl_connected,
+                        "connectSSL is called on the client.")
+
+
 class ConnectedBaseTestCase(FactoryBaseTestCase):
     """Base test case generating a connected factory."""
 
 
=== added file 'tests/syncdaemon/test_tunnel_runner.py'
--- tests/syncdaemon/test_tunnel_runner.py	1970-01-01 00:00:00 +0000
+++ tests/syncdaemon/test_tunnel_runner.py	2012-03-12 17:46:23 +0000
@@ -0,0 +1,114 @@
+# -*- coding: utf8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Tests for the proxy tunnel runner."""
+
+from twisted.internet import defer, error, reactor, task
+from twisted.trial.unittest import TestCase
+
+from ubuntuone.proxy import tunnel_client
+from ubuntuone.syncdaemon import tunnel_runner
+
+FAKE_HOST = "fs-1.two.ubuntu.com"
+FAKE_PORT = 443
+
+
+class TunnelRunnerConstructorTestCase(TestCase):
+    """Test the tunnel runner constructor."""
+
+    timeout = 3
+
+    def raise_import_error(self, *args):
+        """Raise an import error."""
+        raise ImportError
+
+    @defer.inlineCallbacks
+    def test_proxy_support_not_installed(self):
+        """The proxy support binary package is not installed."""
+        self.patch(tunnel_runner.TunnelRunner, "start_process",
+                   self.raise_import_error)
+        tr = tunnel_runner.TunnelRunner(FAKE_HOST, FAKE_PORT)
+        client = yield tr.get_client()
+        self.assertEqual(client, reactor)
+
+
+class TunnelRunnerTestCase(TestCase):
+    """Tests for the TunnelRunner."""
+
+    timeout = 3
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Initialize this testcase."""
+        yield super(TunnelRunnerTestCase, self).setUp()
+        self.spawned = []
+        self.patch(tunnel_client.reactor, "spawnProcess",
+                   lambda *args, **kwargs: self.spawned.append((args, kwargs)))
+        self.process_protocol = None
+        self.process_protocol_class = tunnel_client.TunnelProcessProtocol
+        self.patch(tunnel_client, "TunnelProcessProtocol",
+                   self.storing_process_protocol_factory)
+        self.tr = tunnel_runner.TunnelRunner("fs-1.one.ubuntu.com", 443)
+
+    def storing_process_protocol_factory(self, *args, **kwargs):
+        """Store the process protocol just created."""
+        self.process_protocol = self.process_protocol_class(*args, **kwargs)
+        return self.process_protocol
+
+    def test_tunnel_process_is_started(self):
+        """The tunnel process is started."""
+        self.assertEqual(len(self.spawned), 1,
+                        "The tunnel process is started.")
+
+    @defer.inlineCallbacks
+    def test_tunnel_process_get_client_yielded_twice(self):
+        """The get_client method can be yielded twice."""
+        self.process_protocol.processExited(error.ProcessTerminated(1))
+        client = yield self.tr.get_client()
+        client = yield self.tr.get_client()
+        self.assertNotEqual(client, None)
+
+    @defer.inlineCallbacks
+    def test_tunnel_process_exits_with_error(self):
+        """The tunnel process exits with an error."""
+        self.process_protocol.processExited(error.ProcessTerminated(1))
+        client = yield self.tr.get_client()
+        self.assertEqual(client, reactor)
+
+    @defer.inlineCallbacks
+    def test_tunnel_process_exits_gracefully(self):
+        """The tunnel process exits gracefully."""
+        self.process_protocol.processExited(error.ProcessDone(0))
+        client = yield self.tr.get_client()
+        self.assertEqual(client, reactor)
+
+    @defer.inlineCallbacks
+    def test_tunnel_process_prints_random_garbage_and_timeouts(self):
+        """The tunnel process prints garbage and timeouts."""
+        clock = task.Clock()
+        self.patch(tunnel_client, "reactor", clock)
+        self.process_protocol.connectionMade()
+        self.process_protocol.outReceived("Random garbage")
+        clock.advance(self.process_protocol.timeout)
+        client = yield self.tr.get_client()
+        self.assertEqual(client, clock)
+
+    @defer.inlineCallbacks
+    def test_tunnel_process_prints_port_number(self):
+        """The tunnel process prints the port number."""
+        received = "%s: %d\n" % (tunnel_client.TUNNEL_PORT_LABEL, FAKE_PORT)
+        self.process_protocol.outReceived(received)
+        client = yield self.tr.get_client()
+        self.assertEqual(client.tunnel_port, FAKE_PORT)
 
=== modified file 'ubuntuone/proxy/common.py'
--- ubuntuone/proxy/common.py	2012-03-07 23:43:07 +0000
+++ ubuntuone/proxy/common.py	2012-03-12 17:46:23 +0000
@@ -18,6 +18,7 @@
 from twisted.protocols import basic
 
 CRLF = "\r\n"
+TUNNEL_PORT_LABEL = "Tunnel port"
 
 
 class BaseTunnelProtocol(basic.LineReceiver):
 
=== modified file 'ubuntuone/proxy/tunnel_client.py'
--- ubuntuone/proxy/tunnel_client.py	2012-03-09 14:36:34 +0000
+++ ubuntuone/proxy/tunnel_client.py	2012-03-12 17:46:23 +0000
@@ -15,11 +15,15 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Client for the tunnel protocol."""
 
-from twisted.internet import protocol
-
-from ubuntuone.proxy.common import BaseTunnelProtocol, CRLF
-
-METHOD_LINE = "CONNECT {0}:{1} HTTP/1.0" + CRLF
+import logging
+
+from twisted.internet import protocol, reactor
+
+from ubuntuone.proxy.common import BaseTunnelProtocol, CRLF, TUNNEL_PORT_LABEL
+
+METHOD_LINE = "CONNECT %s:%d HTTP/1.0" + CRLF
+LOCALHOST = "127.0.0.1"
+logger = logging.getLogger("ubuntuone.Proxy.TunnelClient")
 
 
 class TunnelClientProtocol(BaseTunnelProtocol):
@@ -27,8 +31,8 @@
 
     def connectionMade(self):
         """The connection to the tunnel was made so send request."""
-        method_line = METHOD_LINE.format(self.factory.tunnel_host,
-                                         self.factory.tunnel_port)
+        method_line = METHOD_LINE % (self.factory.tunnel_host,
+                                     self.factory.tunnel_port)
         headers = {
             "User-Agent": "Ubuntu One tunnel client"
         }
@@ -82,20 +86,69 @@
         """Initialize this client."""
         self.tunnel_host = tunnel_host
         self.tunnel_port = tunnel_port
-        # TODO: use tcp activation to start a tunnel process if not running
 
-    def connectTCP(self, host, port, other_factory, *args, **kwargs):
+    def connectTCP(self, host, port, factory, *args, **kwargs):
         """A connectTCP going thru the tunnel."""
-        factory = TunnelClientFactory(host, port, other_factory)
-        from twisted.internet import reactor
+        logger.info("Connecting (TCP) to %r:%r via tunnel at %r:%r",
+                    host, port, self.tunnel_host, self.tunnel_port)
+        tunnel_factory = TunnelClientFactory(host, port, factory)
         return reactor.connectTCP(self.tunnel_host, self.tunnel_port,
-                                  factory, *args, **kwargs)
+                                  tunnel_factory, *args, **kwargs)
 
-    def connectSSL(self, host, port, other_factory,
-                   context_factory, *args, **kwargs):
+    def connectSSL(self, host, port, factory,
+                   contextFactory, *args, **kwargs):
         """A connectSSL going thru the tunnel."""
-        factory = TunnelClientFactory(host, port, other_factory,
-                                      context_factory)
-        from twisted.internet import reactor
+        logger.info("Connecting (SSL) to %r:%r via tunnel at %r:%r",
+                    host, port, self.tunnel_host, self.tunnel_port)
+        tunnel_factory = TunnelClientFactory(host, port, factory,
+                                      contextFactory)
         return reactor.connectTCP(self.tunnel_host, self.tunnel_port,
-                                  factory, *args, **kwargs)
+                                  tunnel_factory, *args, **kwargs)
+
+
+class TunnelProcessProtocol(protocol.ProcessProtocol):
+    """The dialog thru stdout with the tunnel server."""
+
+    timeout = 5
+
+    def __init__(self, client_d):
+        """Initialize this protocol."""
+        self.client_d = client_d
+        self.timer = None
+
+    def connectionMade(self):
+        """The process has started, start a timer."""
+        logger.info("Tunnel process started.")
+        self.timer = reactor.callLater(self.timeout, self.process_timeouted)
+
+    def process_timeouted(self):
+        """The process took too long to reply."""
+        if not self.client_d.called:
+            logger.info("Timeout while waiting for tunnel process.")
+            self.client_d.callback(reactor)
+
+    def finish_timeout(self):
+        """Stop the timer from firing."""
+        if self.timer and self.timer.active():
+            self.timer.cancel()
+
+    def processExited(self, status):
+        """The tunnel process has exited with some error code."""
+        self.finish_timeout()
+        logger.info("Tunnel process exit status %r.", status)
+        if not self.client_d.called:
+            self.client_d.callback(reactor)
+
+    def outReceived(self, data):
+        """Receive the port number."""
+        if self.client_d.called:
+            return
+
+        for line in data.split("\n"):
+            if line.startswith(TUNNEL_PORT_LABEL):
+                _header, port = line.split(":", 1)
+                port = int(port.strip())
+                logger.info("Tunnel process listening on port %r.", port)
+                client = TunnelClient(LOCALHOST, port)
+                self.client_d.callback(client)
+                break
 
=== modified file 'ubuntuone/proxy/tunnel_server.py'
--- ubuntuone/proxy/tunnel_server.py	2012-03-09 15:35:27 +0000
+++ ubuntuone/proxy/tunnel_server.py	2012-03-12 17:46:23 +0000
@@ -45,7 +45,7 @@
 from zope.interface import implements
 
 from ubuntu_sso.utils.webclient import gsettings
-from ubuntuone.proxy.common import BaseTunnelProtocol, CRLF
+from ubuntuone.proxy.common import BaseTunnelProtocol, CRLF, TUNNEL_PORT_LABEL
 from ubuntuone.proxy.logger import logger
 
 DEFAULT_CODE = 500
@@ -194,7 +194,6 @@
 
     def response_data_received(self, data):
         """Return data coming from the other side."""
-        logger.debug("writing data to the transport: %r", data)
         self.write_transport(data)
 
 
@@ -279,6 +278,6 @@
     else:
         app = QCoreApplication(argv)
         tunnel_server = TunnelServer()
-        sys.stdout.write("Tunnel port: {}\n".format(tunnel_server.port))
+        sys.stdout.write("%s: %d\n" % (TUNNEL_PORT_LABEL, tunnel_server.port))
         sys.stdout.flush()
         app.exec_()
 
=== modified file 'ubuntuone/syncdaemon/action_queue.py'
--- ubuntuone/syncdaemon/action_queue.py	2012-02-09 21:57:00 +0000
+++ ubuntuone/syncdaemon/action_queue.py	2012-03-12 17:46:23 +0000
@@ -57,6 +57,7 @@
 from ubuntuone.syncdaemon.logger import mklog, TRACE
 from ubuntuone.syncdaemon.volume_manager import ACCESS_LEVEL_RW
 from ubuntuone.syncdaemon import config, offload_queue
+from ubuntuone.syncdaemon import tunnel_runner
 
 logger = logging.getLogger("ubuntuone.SyncDaemon.ActionQueue")
 
@@ -699,6 +700,7 @@
         self.zip_queue = ZipQueue()
         self.conditions_locker = ConditionsLocker()
         self.disk_queue = offload_queue.OffloadQueue()
+        self.tunnel_runner = tunnel_runner.TunnelRunner(self.host, self.port)
 
         self.estimated_free_space = {}
         event_queue.subscribe(self)
@@ -816,16 +818,18 @@
         else:
             return defer.succeed((self.host, self.port))
 
+    @defer.inlineCallbacks
     def _make_connection(self, result):
         """Do the real connect call."""
         host, port = result
         ssl_context = get_ssl_context(self.disable_ssl_verify)
+        client = yield self.tunnel_runner.get_client()
         if self.use_ssl:
-            self.connector = reactor.connectSSL(host, port, factory=self,
+            self.connector = client.connectSSL(host, port, factory=self,
                                             contextFactory=ssl_context,
                                             timeout=self.connection_timeout)
         else:
-            self.connector = reactor.connectTCP(host, port, self,
+            self.connector = client.connectTCP(host, port, self,
                                             timeout=self.connection_timeout)
 
     def connect(self):
 
=== added file 'ubuntuone/syncdaemon/tunnel_runner.py'
--- ubuntuone/syncdaemon/tunnel_runner.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/syncdaemon/tunnel_runner.py	2012-03-12 17:46:23 +0000
@@ -0,0 +1,70 @@
+# -*- coding: utf8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""Run the tunnel process and start a client, with a reactor as a fallback."""
+
+import logging
+
+from os import path
+
+from twisted.internet import defer, reactor
+
+
+TUNNEL_EXECUTABLE = "ubuntuone-proxy-tunnel"
+logger = logging.getLogger("ubuntuone.SyncDaemon.TunnelRunner")
+
+
+class TunnelRunner(object):
+    """Run a tunnel process."""
+
+    def __init__(self, host, port):
+        """Start this runner instance."""
+        self.client_d = defer.Deferred()
+        try:
+            self.start_process(host, port)
+        except ImportError:
+            logger.info("Proxy support not installed.")
+            self.client_d.callback(reactor)
+
+    def start_process(self, host, port):
+        """Start the tunnel process."""
+        from ubuntuone.proxy.tunnel_client import TunnelProcessProtocol
+        protocol = TunnelProcessProtocol(self.client_d)
+        process_path = self.get_process_path()
+        args = [TUNNEL_EXECUTABLE, host, str(port)]
+        reactor.spawnProcess(protocol, process_path, env=None, args=args)
+
+    def get_process_path(self):
+        """Get the path to the tunnel process."""
+        filename = path.join(path.dirname(__file__), "..", "..", "bin",
+                             TUNNEL_EXECUTABLE)
+        if path.isfile(filename):
+            return filename
+
+        from ubuntuone.clientdefs import LIBEXECDIR
+        return path.join(LIBEXECDIR, TUNNEL_EXECUTABLE)
+
+    def get_client(self):
+        """A deferred with the reactor or a tunnel client."""
+
+        def client_selected(result, d):
+            """The tunnel_client or the reactor were selected."""
+            d.callback(result)
+            # make sure the result is available for next callback
+            return result
+
+        d = defer.Deferred()
+        self.client_d.addCallback(client_selected, d)
+        return d