Merge lp:~mandel/ubuntu-sso-client/use-unix-domain into lp:ubuntu-sso-client

[Manuel de la Peña]

Added support for domain sockets in the tcpactivation and the ipc on darwin which removed the need of using random ports (LP: #984665).

- Added support for domain sockets in the tcpactivation and the ipc on darwin which removed the need of using random ports (LP: #984665).

[Diego Sarmentero (diegosarmentero)]

The same as in my branch, it would be better if we have instead of:

from ubuntu_sso.main import windows
from ubuntu_sso.main import darwin
from ubuntu_sso.main import linux
source = X

something like:

from ubuntu_sso.main import darwin as source

review: Needs Fixing

[lp:~mandel/ubuntu-sso-client/use-unix-domain]

961. By Manuel de la Peña on 2012-05-01

Do smarter imports.

962. By Manuel de la Peña on 2012-05-01

Skip if on win32.

963. By Manuel de la Peña on 2012-05-01

Skip if on win32.

964. By Manuel de la Peña on 2012-05-03

Use the service runner to clean the tests on windows.

965. By Manuel de la Peña on 2012-05-03

Use run server to clean reactor on windows.

966. By Manuel de la Peña on 2012-05-03

Clean tests to work in all platforms.

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

[Alejandro J. Cura (alecu)]

I liked a lot this branch; I specially liked the refactoring of port -> service description a lot!

A few comments:
---
We need to check that the path returned by get_sso_domain_socket is only readable by the current user. Please consider opening a new bug for this.

"prot =" -> "port ="
---
I've only ran tests on Linux, and everything seems fine otherwise, so I'm ready to approve when the above small things are taken care of. Thanks for working on this!

review: Needs Fixing

[Manuel de la Peña (mandel)]

> I liked a lot this branch; I specially liked the refactoring of port ->
> service description a lot!
>
> A few comments:
> ---
> We need to check that the path returned by get_sso_domain_socket is only
> readable by the current user. Please consider opening a new bug for this.
>
> "prot =" -> "port ="
> ---
> I've only ran tests on Linux, and everything seems fine otherwise, so I'm
> ready to approve when the above small things are taken care of. Thanks for
> working on this!

Thx!! I have updated the branch and removed the spelling error. You can find the bug regarding security here: lp:#1000155.

I thin using peereid on the connecting client to get the uid of the user running the process will ensure that the correct client connects.

[lp:~mandel/ubuntu-sso-client/use-unix-domain]

967. By Manuel de la Peña on 2012-05-16

Spelling fail.

[Alejandro J. Cura (alecu)]

+1

review: Approve

=== modified file 'bin/ubuntu-sso-login'
--- bin/ubuntu-sso-login	2012-05-09 13:39:29 +0000
+++ bin/ubuntu-sso-login	2012-05-16 10:20:23 +0000
@@ -52,7 +52,7 @@
 import os
 import sys
 
-if sys.platform == 'win32':
+if sys.platform in ('win32', 'darwin'):
     from PyQt4 import QtGui
     # need to create the QApplication before installing the reactor
     if os.environ.get('TESTABILITY', False):

=== modified file 'bin/ubuntu-sso-login-qt'
--- bin/ubuntu-sso-login-qt	2012-04-09 17:38:24 +0000
+++ bin/ubuntu-sso-login-qt	2012-05-16 10:20:23 +0000
@@ -33,7 +33,9 @@
 # Access to a protected member, pylint: disable=W0212
 
 import sys
-if sys.platform == 'win32':
+if sys.platform in ('win32', 'darwin'):
+    from PyQt4 import QtGui
+    app = QtGui.QApplication(sys.argv)
     import qt4reactor
     qt4reactor.install()
 

=== modified file 'run-mac-tests'
--- run-mac-tests	2012-04-27 15:42:22 +0000
+++ run-mac-tests	2012-05-16 10:20:23 +0000
@@ -49,7 +49,7 @@
 
 echo "*** Running QT test suite for ""$MODULE"" ***"
 ./setup.py build
-python $u1trial --reactor=qt4 --gui -p "$GTK_TESTS_PATH" -i "test_gui.py, test_linux.py, test_qt.py, test_windows.py, test_glib.py, test_txsecrets.py, test_ipc.py, test_tcpactivation.py" "$MODULE"
+python $u1trial --reactor=qt4 --gui -p "$GTK_TESTS_PATH" -i "test_gui.py, test_linux.py, test_qt.py, test_windows.py, test_glib.py, test_txsecrets.py" "$MODULE"
 rm -rf _trial_temp
 rm -rf build
 

=== modified file 'ubuntu_sso/main/__init__.py'
--- ubuntu_sso/main/__init__.py	2012-05-09 17:37:55 +0000
+++ ubuntu_sso/main/__init__.py	2012-05-16 10:20:23 +0000
@@ -60,15 +60,16 @@
 # pylint: disable=C0103, W0703, W0621
 
 if sys.platform == 'win32':
-    from ubuntu_sso.main import windows
+    from ubuntu_sso.main import windows as source
     from ubuntu_sso.main.perspective_broker import (
+        finish_setup,
+        main as main_func,
         timeout_func,
         shutdown_func,
         start_setup,
-        main as main_func,
         )
 
-    source = windows
+    source.finish_setup = finish_setup
     source.timeout_func = timeout_func
     source.shutdown_func = shutdown_func
     source.start_setup = start_setup
@@ -76,22 +77,22 @@
 
     TIMEOUT_INTERVAL = 10000000000  # forever (hack)
 elif sys.platform == 'darwin':
-    from ubuntu_sso.main import darwin
+    from ubuntu_sso.main import darwin as source
     from ubuntu_sso.main.perspective_broker import (
+        finish_setup,
+        main as main_func,
         timeout_func,
         shutdown_func,
         start_setup,
-        main as main_func,
         )
 
-    source = darwin
+    source.finish_setup = finish_setup
     source.timeout_func = timeout_func
     source.shutdown_func = shutdown_func
     source.start_setup = start_setup
     source.main = main_func
 else:
-    from ubuntu_sso.main import linux
-    source = linux
+    from ubuntu_sso.main import linux as source
 
 UbuntuSSOClient = source.UbuntuSSOClient
 UbuntuSSOProxy = source.UbuntuSSOProxy

=== modified file 'ubuntu_sso/main/darwin.py'
--- ubuntu_sso/main/darwin.py	2012-04-23 12:22:03 +0000
+++ ubuntu_sso/main/darwin.py	2012-05-16 10:20:23 +0000
@@ -28,6 +28,7 @@
 import os
 import os.path
 
+from dirspec import basedir
 from twisted.internet import defer
 
 import ubuntu_sso
@@ -45,17 +46,26 @@
 
 
 logger = setup_logging("ubuntu_sso.main.darwin")
-U1_REG_PATH = r'Software\Ubuntu One'
 SSO_INSTALL_PATH = 'SSOInstallPath'
-SSO_BASE_PB_PORT = 50000
-SSO_RESERVED_PORTS = 3000
-SSO_PORT_ALLOCATION_STEP = 3  # contiguous ports for sso, u1client, and u1cp
-
-
-def get_sso_pb_port():
-    """Compute the port the SSO service should run on per-user."""
-    uid_modulo = os.getuid() % SSO_RESERVED_PORTS
-    return SSO_BASE_PB_PORT + uid_modulo * SSO_PORT_ALLOCATION_STEP
+
+
+def get_sso_domain_socket():
+    """Compute the domain socket for the sso ipc."""
+    path = os.path.join(basedir.xdg_cache_home, 'sso', 'ipc')
+    return path
+
+
+class DescriptionFactory(object):
+    """Factory that provides the server and client descriptions."""
+
+    client_description_pattern = 'unix:path=%s'
+    server_description_pattern = 'unix:%s'
+
+    def __init__(self):
+        """Create a new instance."""
+        self.domain = get_sso_domain_socket()
+        self.server = self.server_description_pattern % self.domain
+        self.client = self.client_description_pattern % self.domain
 
 
 class UbuntuSSOProxy(UbuntuSSOProxyBase):
@@ -64,9 +74,9 @@
     name = SSO_SERVICE_NAME
 
     @property
-    def port(self):
-        """Get the port on which the SSO pb is running."""
-        return get_sso_pb_port()
+    def description(self):
+        """Get the description on which the SSO pb is running."""
+        return DescriptionFactory()
 
     @property
     def cmdline(self):
@@ -77,7 +87,7 @@
         ubuntu_sso_pkg_dir = os.path.dirname(
             os.path.dirname(ubuntu_sso.__file__))
         ubuntu_sso_bin_dir = os.path.join(ubuntu_sso_pkg_dir, 'bin')
-        ubuntu_sso_bin = os.path.join(ubuntu_sso_bin_dir, self.name)
+        ubuntu_sso_bin = os.path.join(ubuntu_sso_bin_dir, 'ubuntu-sso-login')
         ubuntuone_client_bin_dir = os.path.join(ubuntu_sso_pkg_dir,
                                                 '../ubuntuone-client/bin')
         ubuntuone_client_bin = os.path.join(ubuntuone_client_bin_dir,
@@ -98,7 +108,7 @@
     }
 
     service_name = UbuntuSSOProxy.name
-    service_port = UbuntuSSOProxy.port
+    service_description = UbuntuSSOProxy.description
     service_cmdline = UbuntuSSOProxy.cmdline
 
 

=== modified file 'ubuntu_sso/main/tests/test_darwin.py'
--- ubuntu_sso/main/tests/test_darwin.py	2012-04-23 12:22:03 +0000
+++ ubuntu_sso/main/tests/test_darwin.py	2012-05-16 10:20:23 +0000
@@ -15,29 +15,47 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Darwin specific tests for the main module."""
 
+import os
+
+from dirspec import basedir
+from twisted.internet import defer
+
 from ubuntu_sso.main import darwin
 from ubuntu_sso.tests import TestCase
 
 # because we are using twisted we have java like names C0103
 # pylint: disable=C0103
 
-MOCK_SSO_DARWIN_UID = 1001
-
-
-class MockOsGetuid(object):
-    """Mocked os.getuid to support reliable uid for test"""
-
-    def getuid(self):
-        """Return the same uid for tests"""
-        return MOCK_SSO_DARWIN_UID
-
 
 class DarwinTestCase(TestCase):
     """Tests for module level misc functions"""
 
     def test_get_sso_pb_port(self):
         """Test the get_sso_pb_port function, by patching os.getuid"""
-        mock_os = MockOsGetuid()
-        self.patch(darwin, "os", mock_os)
-        expected_port = 53003
-        self.assertEqual(darwin.get_sso_pb_port(), expected_port)
+        expected = os.path.join(basedir.xdg_cache_home, 'sso', 'ipc')
+        self.assertEqual(darwin.get_sso_domain_socket(), expected)
+
+
+class DescriptionFactoryTestcase(TestCase):
+    """Test the factory."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the tests."""
+        yield super(DescriptionFactoryTestcase, self).setUp()
+        self.domain = '/path/to/domain'
+        self.patch(darwin, 'get_sso_domain_socket', lambda: self.domain)
+
+    def test_server_description(self):
+        """Test getting the description info."""
+        expected = darwin.DescriptionFactory.server_description_pattern % \
+                       self.domain
+        factory = darwin.DescriptionFactory()
+        self.assertEqual(expected, factory.server)
+
+    def test_client_description(self):
+        """Test getting the description info."""
+        expected = darwin.DescriptionFactory.client_description_pattern % \
+                       self.domain
+        factory = darwin.DescriptionFactory()
+        self.assertEqual(expected, factory.client)

=== modified file 'ubuntu_sso/main/tests/test_windows.py'
--- ubuntu_sso/main/tests/test_windows.py	2012-04-20 16:27:04 +0000
+++ ubuntu_sso/main/tests/test_windows.py	2012-05-16 10:20:23 +0000
@@ -31,6 +31,8 @@
 # pylint: disable=F0401
 from _winreg import REG_SZ
 
+from twisted.internet import defer
+
 from ubuntu_sso.main import windows
 from ubuntu_sso.main import perspective_broker
 from ubuntu_sso.tests import TestCase
@@ -114,3 +116,28 @@
         cmdline = windows.get_activation_cmdline(
             perspective_broker.SSO_SERVICE_NAME)
         self.assertEqual(sample_value, cmdline)
+
+
+class DescriptionFactoryTestcase(TestCase):
+    """Test the factory."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the tests."""
+        yield super(DescriptionFactoryTestcase, self).setUp()
+        self.port = 55555
+        self.patch(windows, 'get_sso_pb_port', lambda: self.port)
+
+    def test_server_description(self):
+        """Test getting the description info."""
+        expected = windows.DescriptionFactory.server_description_pattern % \
+                       self.port
+        factory = windows.DescriptionFactory()
+        self.assertEqual(expected, factory.server)
+
+    def test_client_description(self):
+        """Test getting the description info."""
+        expected = windows.DescriptionFactory.client_description_pattern % \
+                       self.port
+        factory = windows.DescriptionFactory()
+        self.assertEqual(expected, factory.client)

=== modified file 'ubuntu_sso/main/windows.py'
--- ubuntu_sso/main/windows.py	2012-04-23 12:22:03 +0000
+++ ubuntu_sso/main/windows.py	2012-05-16 10:20:23 +0000
@@ -89,15 +89,28 @@
     return value
 
 
+class DescriptionFactory(object):
+    """Factory that provides the server and client descriptions."""
+
+    client_description_pattern = 'tcp:host=127.0.0.1:port=%s'
+    server_description_pattern = 'tcp:%s:interface=127.0.0.1'
+
+    def __init__(self):
+        """Create a new instance."""
+        self.port = get_sso_pb_port()
+        self.server = self.server_description_pattern % self.port
+        self.client = self.client_description_pattern % self.port
+
+
 class UbuntuSSOProxy(UbuntuSSOProxyBase):
     """Object that exposes the diff referenceable objects."""
 
     name = SSO_SERVICE_NAME
 
     @property
-    def port(self):
-        """Get the port on which the SSO pb is running."""
-        return get_sso_pb_port()
+    def description(self):
+        """Get the description on which the SSO pb is running."""
+        return DescriptionFactory()
 
     @property
     def cmdline(self):
@@ -116,7 +129,7 @@
     }
 
     service_name = UbuntuSSOProxy.name
-    service_port = UbuntuSSOProxy.port
+    service_description = UbuntuSSOProxy.description
     service_cmdline = UbuntuSSOProxy.cmdline
 
 

=== modified file 'ubuntu_sso/utils/ipc.py'
--- ubuntu_sso/utils/ipc.py	2012-04-10 10:43:48 +0000
+++ ubuntu_sso/utils/ipc.py	2012-05-16 10:20:23 +0000
@@ -31,7 +31,7 @@
 from functools import wraps, partial
 from collections import defaultdict
 
-from twisted.internet import defer
+from twisted.internet import defer, endpoints
 from twisted.spread.pb import (
     DeadReferenceError,
     NoSuchMethod,
@@ -46,41 +46,44 @@
     ActivationClient,
     ActivationConfig,
     ActivationInstance,
-    LOCALHOST,
 )
 
 
 logger = setup_logging("ubuntu_sso.utils.ipc")
-
+LOCALHOST = '127.0.0.1'
 
 # pylint: disable=E1103
 
+
 @defer.inlineCallbacks
-def server_listen(server_factory, service_name, activation_cmdline, port,
-                  reactor=None):
+def server_listen(server_factory, service_name, activation_cmdline,
+                  description, reactor=None):
     """Connect the IPC server factory."""
-    config = ActivationConfig(service_name, activation_cmdline, port)
+    config = ActivationConfig(service_name, activation_cmdline, description)
     ai = ActivationInstance(config)
-    port = yield ai.get_port()
+    description = yield ai.get_server_description()
 
     if reactor is None:
         from twisted.internet import reactor
-    connector = reactor.listenTCP(port, server_factory, interface=LOCALHOST)
+    server = endpoints.serverFromString(reactor, description)
+    connector = yield server.listen(server_factory)
     defer.returnValue(connector)
 
 
 @defer.inlineCallbacks
-def client_connect(client_factory, service_name, activation_cmdline, port,
-                   reactor=None):
+def client_connect(client_factory, service_name, activation_cmdline,
+                   description, reactor=None):
     """Connect the IPC client factory."""
-    config = ActivationConfig(service_name, activation_cmdline, port)
+    config = ActivationConfig(service_name, activation_cmdline, description)
     ac = ActivationClient(config)
-    port = yield ac.get_active_port()
+    description = yield ac.get_active_client_description()
 
     if reactor is None:
         from twisted.internet import reactor
-    connector = reactor.connectTCP(LOCALHOST, port, client_factory)
-    defer.returnValue(connector)
+
+    client = endpoints.clientFromString(reactor, description)
+    port = yield client.connect(client_factory)
+    defer.returnValue(port)
 
 
 # pylint: enable=E1103
@@ -179,7 +182,7 @@
 class BaseService(object, Root):
     """Base PB service.
 
-    Inherit from this class and define name, port and cmdline.
+    Inherit from this class and define name, description and cmdline.
 
     If 'start' is called, 'shutdown' should be called when done.
 
@@ -188,7 +191,7 @@
     # a mapping of (service name, service class (an instance of RemoteService))
     services = {}
     name = None
-    port = None
+    description = None
     cmdline = None
 
     def __init__(self, *a, **kw):
@@ -207,12 +210,12 @@
 
     @defer.inlineCallbacks
     def start(self):
-        """Start listening in the proper port."""
+        """Start listening in the proper description."""
         self.factory = PBServerFactory(self)
         self.listener = yield server_listen(self.factory,
                                             self.name,
                                             self.cmdline,
-                                            self.port)
+                                            self.description)
 
     def shutdown(self):
         """Stop listening."""
@@ -312,9 +315,9 @@
 
 
 class BaseClient(object):
-    """Client that will connect to the service listening on service_port.
+    """Client that will connect to the service listening on the description.
 
-    Inherit from this class and define service_name, service_port and
+    Inherit from this class and define service_name, service_description and
     service_cmdline so they return the proper values.
 
     The service_cmdline must be redefined so it returns the command line to
@@ -327,7 +330,7 @@
     # a mapping of (client name, client class (an instance of RemoteClient))
     clients = {}
     service_name = None
-    service_port = None
+    service_description = None
     service_cmdline = None
 
     def __init__(self):
@@ -352,7 +355,7 @@
         self.client = yield client_connect(self.factory,
                                            self.service_name,
                                            self.service_cmdline,
-                                           self.service_port)
+                                           self.service_description)
         root = yield self.factory.getRootObject()
         yield self._request_remote_objects(root)
         yield self.register_to_signals()

=== modified file 'ubuntu_sso/utils/tcpactivation.py'
--- ubuntu_sso/utils/tcpactivation.py	2012-04-10 10:43:53 +0000
+++ ubuntu_sso/utils/tcpactivation.py	2012-05-16 10:20:23 +0000
@@ -30,7 +30,8 @@
 
 import subprocess
 
-from twisted.internet import defer, protocol, reactor
+from twisted.internet import defer, error, protocol, reactor
+from twisted.internet.endpoints import clientFromString
 
 LOCALHOST = "127.0.0.1"
 DELAY_BETWEEN_CHECKS = 0.1
@@ -67,6 +68,8 @@
 class PortDetectFactory(protocol.ClientFactory):
     """Will detect if something is listening in a given port."""
 
+    protocol = NullProtocol
+
     def __init__(self):
         """Initialize this instance."""
         self.d = defer.Deferred()
@@ -77,9 +80,10 @@
 
     def buildProtocol(self, addr):
         """Connected."""
+        p = protocol.ClientFactory.buildProtocol(self, addr)
         if not self.d.called:
             self.d.callback(True)
-        return NullProtocol()
+        return p
 
     def clientConnectionLost(self, connector, reason):
         """The connection was lost."""
@@ -95,11 +99,11 @@
 class ActivationConfig(object):
     """The configuration for tcp activation."""
 
-    def __init__(self, service_name, command_line, port):
+    def __init__(self, service_name, command_line, description):
         """Initialize this instance."""
         self.service_name = service_name
         self.command_line = command_line
-        self.port = port
+        self.description = description
 
 
 class ActivationDetector(object):
@@ -113,10 +117,12 @@
     def is_already_running(self):
         """Check if the instance is already running."""
         factory = PortDetectFactory()
-        # pylint: disable=E1101
-        connector = reactor.connectTCP(LOCALHOST, self.config.port, factory)
+        client = clientFromString(reactor, self.config.description.client)
+        try:
+            yield client.connect(factory)
+        except error.ConnectError:
+            defer.returnValue(False)
         result = yield factory.is_listening()
-        connector.disconnect()
         defer.returnValue(result)
 
 
@@ -144,20 +150,20 @@
         subprocess.Popen(self.config.command_line, close_fds=True)
 
     @defer.inlineCallbacks
-    def _do_get_active_port(self):
-        """Get the port for the running instance, starting it if needed."""
+    def _do_get_active_description(self):
+        """Get the details for the running instance, starting it if needed."""
         is_running = yield self.is_already_running()
         if not is_running:
             self._spawn_server()
             yield self._wait_server_active()
-        defer.returnValue(self.config.port)
+        defer.returnValue(self.config.description.client)
 
     @defer.inlineCallbacks
-    def get_active_port(self):
-        """Serialize the requests to _do_get_active_port."""
+    def get_active_client_description(self):
+        """Serialize the requests to _do_get_active_description."""
         yield self.lock.acquire()
         try:
-            result = yield self._do_get_active_port()
+            result = yield self._do_get_active_description()
             defer.returnValue(result)
         finally:
             self.lock.release()
@@ -167,9 +173,9 @@
     """A tcp activation server instance."""
 
     @defer.inlineCallbacks
-    def get_port(self):
+    def get_server_description(self):
         """Get the port to run this service or fail if already started."""
         is_running = yield self.is_already_running()
         if is_running:
             raise AlreadyStartedError()
-        defer.returnValue(self.config.port)
+        defer.returnValue(self.config.description.server)

=== modified file 'ubuntu_sso/utils/tests/test_ipc.py'
--- ubuntu_sso/utils/tests/test_ipc.py	2012-04-26 11:35:46 +0000
+++ ubuntu_sso/utils/tests/test_ipc.py	2012-05-16 10:20:23 +0000
@@ -38,7 +38,11 @@
     NoSuchMethod,
 )
 from ubuntuone.devtools.handlers import MementoHandler
-from ubuntuone.devtools.testcases.txsocketserver import TCPPbServerTestCase
+from ubuntuone.devtools.testcases import skipIfOS
+from ubuntuone.devtools.testcases.txsocketserver import (
+    TidyUnixServer,
+    TCPPbServerTestCase,
+)
 
 from ubuntu_sso.tests import TestCase
 from ubuntu_sso.utils import ipc
@@ -46,7 +50,8 @@
 
 TEST_SERVICE = 'foo-service'
 TEST_CMDLINE = 'foo.bin'
-TEST_PORT = 40404
+TEST_SERVER_DESCRIPTION = 'tcp:40404:interface=127.0.0.1'
+TEST_CLIENT_DESCRIPTION = 'tcp:host=127.0.0.1:port=40404'
 
 
 class RandomException(Exception):
@@ -60,15 +65,30 @@
         """Initialize this fake instance."""
         self.config = config
 
-    def get_active_port(self):
-        """Return the port where the pb server is running."""
-        return defer.succeed(self.config.port)
-
-
-class FakeActivationInstance(FakeActivationClient):
+    def get_active_client_description(self):
+        """Return the description where the pb server is running."""
+        return defer.succeed(self.config.description.client)
+
+
+class FakeActivationInstance(object):
     """A fake ActivationInstance."""
 
-    get_port = FakeActivationClient.get_active_port
+    def __init__(self, config):
+        """Initialize the fake instance."""
+        self.config = config
+
+    def get_server_description(self):
+        """Return the description where the pb server is running."""
+        return defer.succeed(self.config.description.server)
+
+
+class FakeDescriptionFactory(object):
+    """A fake description factory."""
+
+    def __init__(self, server_description, client_description):
+        """Create a new instace."""
+        self.server = server_description
+        self.client = client_description
 
 
 # Invalid name "callRemote", etc.
@@ -80,20 +100,33 @@
 
     def __init__(self):
         """Initialize this faker."""
-        self.connection_class = namedtuple("Connection", "host port factory")
+        self.connection_class = namedtuple("Connection",
+                                         "host port factory backlog")
         self.connections = []
 
-    def connectTCP(self, host, port, factory):
+    def connectTCP(self, host, port, factory, timeout=None, bindAddress=None):
         """Store the connected factory."""
-        connection = self.connection_class(host, port, factory)
+        connection = self.connection_class(host, port, factory, None)
         self.connections.append(connection)
 
-    def listenTCP(self, port, factory, interface):
+    def listenTCP(self, port, factory, interface=None, backlog=None):
         """Store the listenning factory."""
-        connection = self.connection_class(interface, port, factory)
+        connection = self.connection_class(interface, port, factory, backlog)
         self.connections.append(connection)
 
 
+class FakeTCP4ClientEndpoint(object):
+    """A fake tcp4 client."""
+
+    def __init__(self, protocol):
+        """Create a new instance."""
+        self.protocol = protocol
+
+    def connect(self, *args, **kwargs):
+        """Return the client."""
+        return defer.succeed(self.protocol)
+
+
 class FakeRemoteClient(object):
     """A fake RemoteClient."""
 
@@ -166,7 +199,7 @@
 
     services = {'dummy': DummyRemoteService}
     name = 'Dummy Service'
-    port = TEST_PORT
+    description = TEST_CLIENT_DESCRIPTION
     cmdline = 'yadda yo'
 
 
@@ -182,10 +215,19 @@
 
     clients = {'dummy': DummyRemoteClient}
     service_name = DummyService.name
-    service_port = DummyService.port
+    service_port = TEST_SERVER_DESCRIPTION
     service_cmdline = DummyService.cmdline
 
 
+class DummyDescription(object):
+    """Return the descriptions accordingly."""
+
+    def __init__(self, client, server):
+        """Create a new instance."""
+        self.client = client
+        self.server = server
+
+
 class BaseIPCTestCase(TCPPbServerTestCase, TestCase):
     """Set the ipc to a random port for this instance."""
 
@@ -219,7 +261,7 @@
 
             @defer.inlineCallbacks
             def server_listen(server_factory, service_name, activation_cmd,
-                              port, reactor=None):
+                              description, reactor=None):
                 """Connect to the local running service."""
                 yield self.listen_server(self.service)
                 defer.returnValue(self.listener)
@@ -228,7 +270,7 @@
 
             @defer.inlineCallbacks
             def client_connect(client_factory, service_name,
-                               activation_cmdline, port, reactor=None):
+                               activation_cmdline, description, reactor=None):
                 """Connect the local running client."""
                 yield self.connect_client()
                 self.client.factory = self.client_factory
@@ -322,12 +364,12 @@
 # pylint: enable=E1102
 
 
-class ListenConnectTestCase(BaseIPCTestCase):
+class TCPListenConnectTestCase(BaseIPCTestCase):
     """Test suite for the server_listen and client_connect methods."""
 
     @defer.inlineCallbacks
     def setUp(self):
-        yield super(ListenConnectTestCase, self).setUp()
+        yield super(TCPListenConnectTestCase, self).setUp()
         self.fake_reactor = FakeReactor()
 
     @defer.inlineCallbacks
@@ -335,35 +377,60 @@
         """Test the server_listen function."""
         self.patch(ipc, "ActivationInstance", FakeActivationInstance)
 
+        description_factory = FakeDescriptionFactory(TEST_SERVER_DESCRIPTION,
+                                                     TEST_CLIENT_DESCRIPTION)
+
         fake_factory = object()
         yield ipc.server_listen(fake_factory, TEST_SERVICE,
-                                TEST_CMDLINE, TEST_PORT,
+                                TEST_CMDLINE, description_factory,
                                 reactor=self.fake_reactor)
 
         self.assertEqual(len(self.fake_reactor.connections), 1)
         conn = self.fake_reactor.connections[0]
-        self.assertEqual(conn.port, TEST_PORT)
         self.assertEqual(conn.factory, fake_factory)
         self.assertEqual(conn.host, ipc.LOCALHOST)
 
     @defer.inlineCallbacks
     def test_client_connect(self):
         """Test the client_connect function."""
+        called = []
         self.patch(ipc, "ActivationClient", FakeActivationClient)
 
+        protocol = 'protocol'
+        client = FakeTCP4ClientEndpoint(protocol)
+
+        def client_from_string(reactor, description):
+            """Create a client from the given string."""
+            called.append(('clientFromString', reactor, description))
+            return client
+
+        self.patch(ipc.endpoints, 'clientFromString', client_from_string)
+
+        description_factory = FakeDescriptionFactory(TEST_SERVER_DESCRIPTION,
+                                                     TEST_CLIENT_DESCRIPTION)
+
         fake_factory = object()
-        yield ipc.client_connect(fake_factory, TEST_SERVICE,
-                                 TEST_CMDLINE, TEST_PORT,
-                                 reactor=self.fake_reactor)
-
-        self.assertEqual(len(self.fake_reactor.connections), 1)
-        conn = self.fake_reactor.connections[0]
-        self.assertEqual(conn.port, TEST_PORT)
-        self.assertEqual(conn.factory, fake_factory)
-        self.assertEqual(conn.host, ipc.LOCALHOST)
-
-
-class DummyClientTestCase(BaseIPCTestCase):
+        returned_protocol = yield ipc.client_connect(fake_factory,
+                                              TEST_SERVICE,
+                                              TEST_CMDLINE,
+                                              description_factory,
+                                              reactor=self.fake_reactor)
+
+        self.assertIn(('clientFromString', self.fake_reactor,
+                          description_factory.client), called)
+        self.assertEqual(protocol, returned_protocol)
+
+
+@skipIfOS('win32', 'Unix domain sockets not supported on windows.')
+class DomainListenConnectTestCase(TCPListenConnectTestCase):
+    """Test suite for the server_listen and client_connect methods."""
+
+    def get_server(self):
+        """Return the server to be used to run the tests."""
+        return TidyUnixServer()
+
+
+class TCPDummyClientTestCase(BaseIPCTestCase):
     """Test the status client class."""
 
     client_class = DummyClient
@@ -422,6 +489,15 @@
             self.assertEqual(0, actual)
 
 
+@skipIfOS('win32', 'Unix domain sockets not supported on windows.')
+class DomainDummyClientTestCase(TCPDummyClientTestCase):
+    """Test the status client class."""
+
+    def get_server(self):
+        """Return the server to be used to run the tests."""
+        return TidyUnixServer()
+
+
 class RemoteMetaTestCase(TestCase):
     """Tests for the RemoteMeta metaclass."""
 

=== modified file 'ubuntu_sso/utils/tests/test_tcpactivation.py'
--- ubuntu_sso/utils/tests/test_tcpactivation.py	2012-04-10 10:43:53 +0000
+++ ubuntu_sso/utils/tests/test_tcpactivation.py	2012-05-16 10:20:23 +0000
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 
-# Author: Alejandro J. Cura <[e-mail]>
 #
 # Copyright 2011-2012 Canonical Ltd.
 #
@@ -39,6 +38,14 @@
 from twisted.internet import defer, protocol, reactor, task
 from twisted.trial.unittest import TestCase
 
+# pylint: disable=W0611
+from ubuntuone.devtools.testcases import skipIfOS
+# pylint: enable=W0611
+from ubuntuone.devtools.testcases.txsocketserver import (
+    ServerTestCase,
+    TidyTCPServer,
+)
+
 from ubuntu_sso.utils import tcpactivation
 from ubuntu_sso.utils.tcpactivation import (
     ActivationClient,
@@ -53,7 +60,8 @@
 
 SAMPLE_SERVICE = "test_service_name"
 SAMPLE_CMDLINE = ["python", __file__, "-server"]
-SAMPLE_PORT = 55555
+SAMPLE_SERVER_DESCRIPTION = 'tcp:55555:interface=127.0.0.1'
+SAMPLE_CLIENT_DESCRIPTION = 'tcp:host=127.0.0.1:port=55555'
 
 
 class FakeServerProtocol(protocol.Protocol):
@@ -63,25 +71,12 @@
         """Echo the data received."""
         self.transport.write(data)
 
-    #pylint:disable=E1101
-    def connectionLost(self, *a):
-        self.factory.onConnectionLost.callback(self)
-    #pylint:enable=E1101
-
 
 class FakeServerFactory(protocol.Factory):
     """A factory for the test server."""
 
     protocol = FakeServerProtocol
 
-    #pylint:disable=W0201
-    def __init__(self, testcase=None):
-        """Create a new instance for the testcase."""
-        if testcase is not None:
-            self.onConnectionLost = defer.Deferred()
-            testcase.addCleanup(lambda: self.onConnectionLost)
-    #pylint:enable=W0201
-
 
 class FakeTransport(object):
     """A fake transport."""
@@ -93,6 +88,46 @@
         self.connectionLost = True
 
 
+class FakeDescriptionFactory(object):
+    """A fake description factory."""
+
+    def __init__(self, server_description, client_description):
+        """Create a new instace."""
+        self.server = server_description
+        self.client = client_description
+
+
+class FakeConnectedClient(object):
+    """Fake class use to patch connections."""
+
+    def __init__(self, testcase, inner):
+        """Create a new instance."""
+        self.testcase = testcase
+        self.inner = inner
+
+    @defer.inlineCallbacks
+    def connect(self, factory):
+        """Connect using the given factory."""
+        # we need to get the class of the factory and patch it
+        yield self.testcase.connect_client(PortDetectFactory)
+        self.inner.factory = self.testcase.client_factory
+        defer.returnValue(self.testcase.connector)
+
+
+class WrapperFactory(object):
+    """Wrapps a factory so that it can be replaced in a test."""
+
+    def __init__(self, factory):
+        self.factory = None
+
+    def __call__(self, *args, **kwargs):
+        return self
+
+    def is_listening(self):
+        """Return if the service is listening."""
+        return self.factory.is_listening()
+
+
 class AsyncSleepTestCase(TestCase):
     """Tests for the async_sleep function."""
 
@@ -146,7 +181,7 @@
     @defer.inlineCallbacks
     def test_is_listening(self):
         """Test that the deferred returns True when something is listening."""
-        addr = (tcpactivation.LOCALHOST, SAMPLE_PORT)
+        addr = (tcpactivation.LOCALHOST, SAMPLE_CLIENT_DESCRIPTION)
         self.factory.buildProtocol(addr)
         is_listening = yield self.factory.is_listening()
         self.assertTrue(is_listening)
@@ -176,7 +211,7 @@
     @defer.inlineCallbacks
     def test_connection_works_then_lost(self):
         """It's not an error if two events happen."""
-        addr = (tcpactivation.LOCALHOST, SAMPLE_PORT)
+        addr = (tcpactivation.LOCALHOST, SAMPLE_CLIENT_DESCRIPTION)
         self.factory.buildProtocol(addr)
         d = self.factory.is_listening()
         self.factory.clientConnectionLost(None, "test reason")
@@ -189,26 +224,39 @@
 
     def test_initialization(self):
         """Test the constructor."""
-        config = ActivationConfig(SAMPLE_SERVICE, SAMPLE_CMDLINE, SAMPLE_PORT)
+        config = ActivationConfig(SAMPLE_SERVICE, SAMPLE_CMDLINE,
+                                                   SAMPLE_CLIENT_DESCRIPTION)
         self.assertEqual(config.service_name, SAMPLE_SERVICE)
         self.assertEqual(config.command_line, SAMPLE_CMDLINE)
-        self.assertEqual(config.port, SAMPLE_PORT)
-
-
-class ActivationDetectorTestCase(TestCase):
+        self.assertEqual(config.description, SAMPLE_CLIENT_DESCRIPTION)
+
+
+class ActivationDetectorTestCase(ServerTestCase):
     """Tests for the ActivationDetector class."""
 
+    timeoue = 3
+
+    client_description = 'tcp:host=127.0.0.1:port=55555'
+    server_description = 'tcp:55555:interface=127.0.0.1'
+
     @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
         yield super(ActivationDetectorTestCase, self).setUp()
+        self.description_factory = FakeDescriptionFactory(
+                                                     self.server_description,
+                                                     self.client_description)
         self.config = ActivationConfig(SAMPLE_SERVICE, SAMPLE_CMDLINE,
-                                       SAMPLE_PORT)
+                                       self.description_factory)
+
+    def get_server(self):
+        """Return the server to be used to run the tests."""
+        return TidyTCPServer()
 
     def test_initialization(self):
         """Test the constructor."""
         self.config = ActivationConfig(SAMPLE_SERVICE, SAMPLE_CMDLINE,
-                                       SAMPLE_PORT)
+                                       self.description_factory)
         ai = ActivationDetector(self.config)
         self.assertEqual(ai.config, self.config)
 
@@ -222,11 +270,16 @@
     @defer.inlineCallbacks
     def test_is_already_running(self):
         """The is_already_running method returns True if already started."""
-        f = FakeServerFactory(self)
+        inner = WrapperFactory(None)
+
+        self.patch(tcpactivation, 'PortDetectFactory', inner)
+        client = FakeConnectedClient(self, inner)
+
+        self.patch(tcpactivation, 'clientFromString',
+                   lambda *args: client)
+
+        yield self.listen_server(FakeServerFactory)
         # pylint: disable=E1101
-        listener = reactor.listenTCP(SAMPLE_PORT, f,
-                                     interface=tcpactivation.LOCALHOST)
-        self.addCleanup(defer.maybeDeferred, listener.stopListening)
         ad = ActivationDetector(self.config)
         result = yield ad.is_already_running()
         self.assertTrue(result, "It should be already running.")
@@ -237,12 +290,18 @@
 
     timeout = 2
 
+    server_description = 'tcp:55555:interface=127.0.0.1'
+    client_description = 'tcp:host=127.0.0.1:port=55555'
+
     @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
         yield super(ActivationClientTestCase, self).setUp()
+        self.description_factory = FakeDescriptionFactory(
+                                                     self.server_description,
+                                                     self.client_description)
         self.config = ActivationConfig(SAMPLE_SERVICE, SAMPLE_CMDLINE,
-                                       SAMPLE_PORT)
+                                       self.description_factory)
 
     def test_initialization(self):
         """Test the constructor."""
@@ -250,37 +309,38 @@
         self.assertEqual(ac.config, self.config)
 
     @defer.inlineCallbacks
-    def test_do_get_active_port_running(self):
-        """Test the _do_get_active_port method when the server is running."""
+    def test_do_get_active_description_running(self):
+        """Test the _do_get_active_description method when is running."""
         ac = ActivationClient(self.config)
         self.patch(ac, "is_already_running", lambda: defer.succeed(True))
-        result = yield ac._do_get_active_port()
-        self.assertEqual(result, SAMPLE_PORT)
+        result = yield ac._do_get_active_description()
+        self.assertEqual(result, self.client_description)
 
     @defer.inlineCallbacks
-    def test_do_get_active_port_not_running(self):
-        """Test _do_get_active_port method when the server is not running."""
+    def test_do_get_active_description_not_running(self):
+        """Test _do_get_active_description method when is not running."""
         server_spawned = []
         ac = ActivationClient(self.config)
         self.patch(ac, "_spawn_server",
                                 lambda *args: server_spawned.append(args))
         self.patch(ac, "is_already_running", lambda: defer.succeed(False))
         self.patch(ac, "_wait_server_active", lambda: defer.succeed(None))
-        result = yield ac._do_get_active_port()
-        self.assertEqual(result, SAMPLE_PORT)
+        result = yield ac._do_get_active_description()
+        self.assertEqual(result, self.client_description)
         self.assertEqual(len(server_spawned), 1)
 
-    def test_get_active_port_waits_classwide(self):
-        """Test the get_active_port method locks classwide."""
+    def test_get_active_description_waits_classwide(self):
+        """Test the get_active_description method locks classwide."""
         d = defer.Deferred()
         ac1 = ActivationClient(self.config)
         ac2 = ActivationClient(self.config)
-        self.patch(ac1, "_do_get_active_port", lambda: d)
-        self.patch(ac2, "_do_get_active_port", lambda: defer.succeed(None))
-        ac1.get_active_port()
-        d2 = ac2.get_active_port()
+        self.patch(ac1, "_do_get_active_description", lambda: d)
+        self.patch(ac2, "_do_get_active_description",
+                   lambda: defer.succeed(None))
+        ac1.get_active_client_description()
+        d2 = ac2.get_active_client_description()
         self.assertFalse(d2.called, "The second must wait for the first.")
-        d.callback(SAMPLE_PORT)
+        d.callback(self.client_description)
         self.assertTrue(d2.called, "The second can fire after the first.")
 
     def test_wait_server_active(self):
@@ -320,17 +380,27 @@
         self.assertEqual(len(popen_calls), 1)
 
 
-class ActivationInstanceTestCase(TestCase):
+class ActivationInstanceTestCase(ServerTestCase):
     """Tests for the ActivationServer class."""
 
     timeout = 2
 
+    server_description = 'tcp:55555:interface=127.0.0.1'
+    client_description = 'tcp:host=127.0.0.1:port=55555'
+
     @defer.inlineCallbacks
     def setUp(self):
         """Initialize this test instance."""
         yield super(ActivationInstanceTestCase, self).setUp()
+        self.description_factory = FakeDescriptionFactory(
+                                                     self.server_description,
+                                                     self.client_description)
         self.config = ActivationConfig(SAMPLE_SERVICE, SAMPLE_CMDLINE,
-                                       SAMPLE_PORT)
+                                       self.description_factory)
+
+    def get_server(self):
+        """Return the server to be used to run the tests."""
+        return TidyTCPServer()
 
     def test_initialization(self):
         """Test the constructor."""
@@ -338,42 +408,48 @@
         self.assertEqual(ai.config, self.config)
 
     @defer.inlineCallbacks
-    def test_get_port(self):
-        """Test the get_port method."""
+    def test_get_sever_description(self):
+        """Test the get_description method."""
         ai = ActivationInstance(self.config)
-        port = yield ai.get_port()
-        self.assertEqual(port, SAMPLE_PORT)
+        self.patch(ai, 'is_already_running', lambda: False)
+
+        description = yield ai.get_server_description()
+        self.assertEqual(description, self.server_description)
 
     #pylint:disable=W0201
     @defer.inlineCallbacks
-    def test_get_port_fails_if_service_already_started(self):
-        """The get_port method fails if service already started."""
-        ai1 = ActivationInstance(self.config)
-        port1 = yield ai1.get_port()
-        f = FakeServerFactory(self)
-        # pylint: disable=E1101
-        listener = reactor.listenTCP(port1, f,
-                                     interface=tcpactivation.LOCALHOST)
-        self.addCleanup(listener.stopListening)
-        ai2 = ActivationInstance(self.config)
-        yield self.assertFailure(ai2.get_port(), AlreadyStartedError)
+    def test_get_description_fails_if_service_already_started(self):
+        """The get_description method fails if service already started."""
+        inner = WrapperFactory(None)
+
+        self.patch(tcpactivation, 'PortDetectFactory', inner)
+        client = FakeConnectedClient(self, inner)
+
+        self.patch(tcpactivation, 'clientFromString',
+                   lambda *args: client)
+
+        yield self.listen_server(FakeServerFactory)
+
+        ai = ActivationInstance(self.config)
+        yield self.assertFailure(ai.get_server_description(),
+                                 AlreadyStartedError)
     #pylint:enable=W0201
 
 
 def server_test(config):
     """An IRL test of the server."""
 
-    def got_port(port_number):
-        """The port number was found."""
-        print "got server port:", port_number
+    def got_description(description):
+        """The description was found."""
+        print "got server description:", description
 
         # start listening
         f = FakeServerFactory()
         # pylint: disable=E1101
-        reactor.listenTCP(port_number, f)
+        reactor.listenTCP(description, f)
 
-        # try to get the port again
-        get_port()
+        # try to get the description again
+        get_description()
 
     def already_started(failure):
         """This instance was already started."""
@@ -381,15 +457,15 @@
         # pylint: disable=E1101
         reactor.callLater(3, reactor.stop)
 
-    def get_port():
-        """Try to get the port number."""
-        get_port_d = ai.get_port()
-        get_port_d.addCallback(got_port)
-        get_port_d.addErrback(already_started)
+    def get_description():
+        """Try to get the description number."""
+        get_description_d = ai.get_server_description()
+        get_description_d.addCallback(got_description)
+        get_description_d.addErrback(already_started)
 
     print "starting the server."
     ai = ActivationInstance(config)
-    get_port()
+    get_description()
     # pylint: disable=E1101
     reactor.run()
 
@@ -398,14 +474,14 @@
     """An IRL test of the client."""
     print "starting the client."
     ac = ActivationClient(config)
-    d = ac.get_active_port()
+    d = ac.get_active_client_description()
 
-    def got_port(port_number):
-        """The port number was found."""
-        print "client got server port:", port_number
+    def got_description(description):
+        """The description was found."""
+        print "client got server description:", description
         reactor.stop()
 
-    d.addCallback(got_port)
+    d.addCallback(got_description)
     # pylint: disable=E1101
     reactor.run()
 
@@ -413,7 +489,9 @@
 def irl_test():
     """Do an IRL test of the client and the server."""
     import sys
-    config = ActivationConfig(SAMPLE_SERVICE, SAMPLE_CMDLINE, SAMPLE_PORT)
+    description_f = FakeDescriptionFactory(SAMPLE_SERVER_DESCRIPTION,
+                                           SAMPLE_CLIENT_DESCRIPTION)
+    config = ActivationConfig(SAMPLE_SERVICE, SAMPLE_CMDLINE, description_f)
     if "-server" in sys.argv[1:]:
         server_test(config)
     else: