Merge lp:~raof/mir/xserver-spawner into lp:mir

[Chris Halse Rogers]

A first cut at the infrastructure required for seamless nesting of X11 clients.

In order to do this we need to be able to spawn an Xorg server, wait until it's
ready to accept connections, connect a Mir X11 client to act as a bridging WM,
and *then* offer the X11 socket to clients.

This branch accomplishes the first two requirements.

A first cut at the infrastructure required for seamless nesting of X11 clients.

In order to do this we need to be able to spawn an Xorg server, wait until it's
ready to accept connections, connect a Mir X11 client to act as a bridging WM,
and *then* offer the X11 socket to clients.

This branch accomplishes the first two requirements.

I'm proposing it now because it's a reasonable checkpoint and I need to go and work on something else.

[Daniel van Vugt (vanvugt)]

Please rethink class names ending in "er". That's almost always a bad decision, and an indication that a different cleaner design is possible...

http://www.benhallbenhall.com/2013/01/naming-objects-er-object-names/

review: Needs Fixing

Unmerged revisions

1349. By Chris Halse Rogers on 2014-01-28

clang-format: We always split constructor initialisers on new lines

1348. By Chris Halse Rogers on 2014-01-28

Disable X11ClientConnects acceptance test.

This needs a bit more fiddling - it all roughly works, but in the acceptance
test framework we don't have a real graphics card, so XMir currently fails.

Needs at least an xorg.conf specifying the dummy graphics driver

1347. By Chris Halse Rogers on 2014-01-28

Get the Xserver to connect to a Mir socket

1346. By Chris Halse Rogers on 2014-01-28

Update for process::Spawner API change

1345. By Chris Halse Rogers on 2014-01-28

Merged subprocess-wrapper into xserver-spawner.

1344. By Chris Halse Rogers on 2014-01-28

X::ServerSpawner::create_server must take a shared_ptr<process::Spawner>

create_server does things asynchronously, so it has to take shared ownership
of the process::Spawner it's using

1343. By Chris Halse Rogers on 2014-01-28

Rejigger X::ServerSpawner API.

spawn_server() now returns a future<ServerHandle> that will become a present ServerHandle once
the server is ready, rather than returning a ServerHandle now that has methods that will only
work in the future.

1342. By Chris Halse Rogers on 2014-01-24

Implement -displayfd handling for GlobalSocketListeningServerSpawner.

client_connection_string now returns a string that should be associated with an Xorg server that's ready to accept connections

1341. By Chris Halse Rogers on 2014-01-24

Merge process::Spawner work required to do Xserver startup properly

1340. By Chris Halse Rogers on 2014-01-22

More basic unittests for GlobalSocketListeningServerSpawner

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2014-01-28 06:34:09 +0000
@@ -0,0 +1,1 @@
+build
 
=== modified file '.clang-format'
--- .clang-format	2014-01-10 15:48:08 +0000
+++ .clang-format	2014-01-28 06:34:09 +0000
@@ -14,7 +14,7 @@
 BreakConstructorInitializersBeforeComma: false
 BinPackParameters: true
 ColumnLimit:     120
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
 DerivePointerBinding: true
 ExperimentalAutoDetectBinPacking: true
 IndentCaseLabels: false
 
=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-01-21 15:29:52 +0000
+++ include/server/mir/default_server_configuration.h	2014-01-28 06:34:09 +0000
@@ -113,6 +113,11 @@
 class Logger;
 }
 
+namespace X
+{
+class ServerSpawner;
+}
+
 class DefaultServerConfiguration : public virtual ServerConfiguration, DefaultConfigurationOptions
 {
 public:
@@ -232,6 +237,12 @@
 
     virtual std::shared_ptr<time::Clock> the_clock();
 
+    /** @name X11 server integration - customization
+     * configurable interfaces for integration with legacy X11 apps
+     * @{ */
+    virtual std::shared_ptr<X::ServerSpawner> the_xserver_spawner();
+    /** @} */
+
 protected:
     using DefaultConfigurationOptions::the_options;
     using DefaultConfigurationOptions::add_options;
 
=== added directory 'include/server/mir/process'
=== added file 'include/server/mir/process/handle.h'
--- include/server/mir/process/handle.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/process/handle.h	2014-01-28 06:34:09 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_PROCESS_HANDLE_H_
+#define MIR_PROCESS_HANDLE_H_
+
+#include <sys/types.h>
+
+namespace mir
+{
+namespace process
+{
+class Handle
+{
+public:
+    enum Status {
+       NotStarted,
+       Running,
+       Stopped
+    };
+
+    virtual ~Handle() = default;
+
+    virtual Status status() const = 0;
+    virtual pid_t pid() const = 0;
+};
+
+}
+}
+#endif // MIR_PROCESS_HANDLE_H_
 
=== added file 'include/server/mir/process/spawner.h'
--- include/server/mir/process/spawner.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/process/spawner.h	2014-01-28 06:34:09 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_PROCESS_SPAWNER_H_
+#define MIR_PROCESS_SPAWNER_H_
+
+#include <memory>
+#include <future>
+#include <initializer_list>
+
+namespace mir
+{
+namespace process
+{
+
+class Handle;
+
+class Spawner
+{
+public:
+    virtual ~Spawner() = default;
+    /**
+     * \brief Run a binary, respecting $PATH
+     * \note All open file descriptors other than stdin, stdout, and stderr are closed before
+     *       running the binary.
+     * \param [in] binary_name  The name of the binary to run, such as “Xorg”
+     * \return                  A future that will contain the handle to the spawned process.
+     *                          The future will be populated after the process has been exec()d,
+     *                          or the call to exec() has failed.
+     *                          If spawning the binary fails the future will contain a
+     *                          std::runtime_error.
+     */
+    virtual std::future<std::unique_ptr<Handle>> run_from_path(char const* binary_name) const = 0;
+    /**
+     * \brief Run a binary with arguments, respecting $PATH
+     * \note All open file descriptors other than stdin, stdout, and stderr are closed before
+     *       running the binary.
+     * \param [in] binary_name  The name of the binary to run, such as “Xorg”
+     * \param [in] args         The arguments to be passed to the binary. No processing is done on
+     *                          these strings; each one will appear verbatim as a separate char* in
+     *                          the binary's argv[].
+     * \return                  A future that will contain the handle to the spawned process.
+     *                          The future will be populated after the process has been exec()d,
+     *                          or the call to exec() has failed.
+     *                          If spawning the binary fails the future will contain a
+     *                          std::runtime_error.
+     */
+    virtual std::future<std::unique_ptr<Handle>> run_from_path(char const* binary_name, std::initializer_list<char const*> args) const = 0;
+    /**
+     * \brief Run a binary, respecting $PATH
+     * \note All open file descriptors other than stdin, stdout, stderr, and the fds listed in
+     *       fds are closed before running the binary.
+     * \param [in] binary_name  The name of the binary to run, such as “Xorg”
+     * \param [in] args         The arguments to be passed to the binary. No processing is done on
+     *                          these strings; each one will appear verbatim as a separate char* in
+     *                          the binary's argv[].
+     * \param [in] fds          The set of fds that will remain available to the child process.
+     * \return                  A future that will contain the handle to the spawned process.
+     *                          The future will be populated after the process has been exec()d,
+     *                          or the call to exec() has failed.
+     *                          If spawning the binary fails the future will contain a
+     *                          std::runtime_error.
+     */
+    virtual std::future<std::unique_ptr<Handle>> run_from_path(char const* binary_name, std::initializer_list<char const*> args, std::initializer_list<int> fds) const = 0;
+};
+}
+}
+#endif  // MIR_PROCESS_SPAWNER_H_
 
=== added directory 'include/server/mir/xserver'
=== added file 'include/server/mir/xserver/null_server_spawner.h'
--- include/server/mir/xserver/null_server_spawner.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/xserver/null_server_spawner.h	2014-01-28 06:34:09 +0000
@@ -0,0 +1,25 @@
+#ifndef MIR_X_NULL_SERVER_SPAWNER_H_
+#define MIR_X_NULL_SERVER_SPAWNER_H_
+
+#include <mir/xserver/xserver_launcher.h>
+
+namespace mir
+{
+namespace X
+{
+class NullServerContext : public ServerContext
+{
+public:
+    char const* client_connection_string() override;
+};
+
+class NullServerSpawner : public ServerSpawner
+{
+public:
+    std::future<std::unique_ptr<ServerContext>> create_server(std::shared_ptr<process::Spawner> const& spawner, std::shared_ptr<mir::frontend::Connector> const& connector) override;
+};
+
+}
+}
+
+#endif // MIR_X_NULL_SERVER_SPAWNER_H_
 
=== added file 'include/server/mir/xserver/xserver_launcher.h'
--- include/server/mir/xserver/xserver_launcher.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/xserver/xserver_launcher.h	2014-01-28 06:34:09 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_X_XSERVER_LAUNCHER_H_
+#define MIR_X_XSERVER_LAUNCHER_H_
+
+#include <future>
+#include <memory>
+
+#include "mir/process/spawner.h"
+#include "mir/frontend/connector.h"
+
+namespace mir
+{
+namespace X
+{
+
+class ServerContext
+{
+public:
+    virtual ~ServerContext() = default;
+
+    /**
+     * \brief Get the XLib connection string to connect to this server
+     *
+     * This string can be passed by the client to XOpenDisplay to connect
+     * to this server instance, or set in the DISPLAY environment variable
+     * to be used as the default display.
+     */
+    virtual char const* client_connection_string() = 0;
+};
+
+class ServerSpawner
+{
+public:
+    virtual ~ServerSpawner() = default;
+
+    virtual std::future<std::unique_ptr<ServerContext>> create_server(std::shared_ptr<mir::process::Spawner> const& spawner,
+                                                                      std::shared_ptr<mir::frontend::Connector> const& connector) = 0;
+};
+}
+}
+
+#endif // MIR_X_XSERVER_LAUNCHER_H_
 
=== renamed file 'include/test/mir_test/pipe.h' => 'include/shared/mir/pipe.h'
--- include/test/mir_test/pipe.h	2013-07-03 09:54:10 +0000
+++ include/shared/mir/pipe.h	2014-01-28 06:34:09 +0000
@@ -1,16 +1,16 @@
 /*
  * Copyright © 2013 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 free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
+ * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Alexandros Frantzis <[e-mail]>
@@ -21,18 +21,22 @@
 
 namespace mir
 {
-namespace test
+namespace pipe
 {
 
 class Pipe
 {
 public:
     Pipe();
+    Pipe(int flags);
     ~Pipe();
 
     int read_fd() const;
     int write_fd() const;
 
+    void close_read_fd();
+    void close_write_fd();
+
 private:
     Pipe(Pipe const&) = delete;
     Pipe& operator=(Pipe const&) = delete;
 
=== modified file 'src/server/CMakeLists.txt'
--- src/server/CMakeLists.txt	2014-01-22 08:32:55 +0000
+++ src/server/CMakeLists.txt	2014-01-28 06:34:09 +0000
@@ -12,6 +12,8 @@
 add_subdirectory(frontend/)
 add_subdirectory(shell/)
 add_subdirectory(time/)
+add_subdirectory(process/)
+add_subdirectory(xserver/)
 
 set(PREFIX "${CMAKE_INSTALL_PREFIX}")
 set(EXEC_PREFIX "${CMAKE_INSTALL_PREFIX}")
@@ -56,6 +58,9 @@
   mirlttng
   mirnestedgraphics
   miroffscreengraphics
+  mirsharedpipe
+  mirprocess
+  mirxserverintegration
 )
 
 list(APPEND MIRSERVER_LINKS
 
=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2014-01-13 06:12:33 +0000
+++ src/server/default_server_configuration.cpp	2014-01-28 06:34:09 +0000
@@ -42,6 +42,7 @@
 #include "mir/time/high_resolution_clock.h"
 #include "mir/geometry/rectangles.h"
 #include "mir/default_configuration.h"
+#include "mir/xserver/null_server_spawner.h"
 
 #include <map>
 
@@ -249,3 +250,8 @@
             return std::make_shared<mir::DefaultServerStatusListener>();
         });
 }
+
+std::shared_ptr<mir::X::ServerSpawner> mir::DefaultServerConfiguration::the_xserver_spawner()
+{
+    return std::make_shared<mir::X::NullServerSpawner>();
+}
 
=== added directory 'src/server/process'
=== added file 'src/server/process/CMakeLists.txt'
--- src/server/process/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/server/process/CMakeLists.txt	2014-01-28 06:34:09 +0000
@@ -0,0 +1,25 @@
+# Copyright © 2014 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 warranty of
+# MERCHANTABILITY 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/>.
+#
+# Authored by: Christopher James Halse Rogers <[e-mail]>
+
+set(
+  PROCESS_SOURCES
+  ${CMAKE_CURRENT_SOURCE_DIR}/fork_spawner.cpp
+)
+
+add_library(
+  mirprocess STATIC
+  ${PROCESS_SOURCES}
+)
 
=== added file 'src/server/process/fork_spawner.cpp'
--- src/server/process/fork_spawner.cpp	1970-01-01 00:00:00 +0000
+++ src/server/process/fork_spawner.cpp	2014-01-28 06:34:09 +0000
@@ -0,0 +1,165 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#include "fork_spawner.h"
+
+#include "mir/process/handle.h"
+#include "mir/pipe.h"
+#include "mir/raii.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <dirent.h>
+#include <vector>
+#include <thread>
+#include <string>
+#include <set>
+#include <boost/throw_exception.hpp>
+#include <boost/exception/errinfo_errno.hpp>
+
+namespace
+{
+class PidHandle : public mir::process::Handle
+{
+public:
+    PidHandle(pid_t pid) : child_pid(pid)
+    {
+    }
+
+    Status status() const override
+    {
+        return Status::Running;
+    }
+    pid_t pid() const override
+    {
+        return child_pid;
+    }
+
+private:
+    pid_t child_pid;
+};
+
+static std::vector<int> open_fds()
+{
+    std::vector<int> fds;
+
+    DIR* process_fds_dir;
+    auto const dir_raii = mir::raii::paired_calls([&process_fds_dir]
+                                                  { process_fds_dir = opendir("/proc/self/fd"); },
+                                                  [&process_fds_dir]
+                                                  {
+        if (process_fds_dir != nullptr)
+            closedir(process_fds_dir);
+    });
+
+    if (process_fds_dir == nullptr)
+        BOOST_THROW_EXCEPTION(boost::enable_error_info(std::runtime_error("Failed to open process fds directory"))
+                              << boost::errinfo_errno(errno));
+
+    struct dirent* entry;
+    errno = 0;
+    while ((entry = readdir(process_fds_dir)) != nullptr)
+    {
+        // We don't care about directory links
+        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+            continue;
+
+        int fd;
+        char* conversion_end;
+        fd = strtol(entry->d_name, &conversion_end, 10);
+
+        if (*conversion_end != '\0' || conversion_end == entry->d_name)
+            BOOST_THROW_EXCEPTION(std::runtime_error(std::string("Unexpected fd name: ") + entry->d_name));
+
+        if (fd != dirfd(process_fds_dir))
+            fds.push_back(fd);
+    }
+    if (errno != 0)
+        BOOST_THROW_EXCEPTION(boost::enable_error_info(std::runtime_error("Failed to read from process fds directory"))
+                              << boost::errinfo_errno(errno));
+
+    return fds;
+}
+
+static std::unique_ptr<mir::process::Handle> run(char const* binary_name,
+                                                 std::initializer_list<char const*> args,
+                                                 std::initializer_list<int> fds)
+{
+    mir::pipe::Pipe error_pipe(O_CLOEXEC);
+    pid_t child = fork();
+
+    if (child == 0)
+    {
+        std::set<int> precious_fds{fds};
+        // Don't close stdin, stdout, or stderr
+        precious_fds.insert({0, 1, 2});
+        // Don't close our cross-process pipe, we need it and know it's CLOEXEC
+        precious_fds.insert(error_pipe.write_fd());
+
+        error_pipe.close_read_fd();
+
+        for (auto fd : open_fds())
+        {
+            if (precious_fds.count(fd) == 0)
+                close(fd);
+        }
+
+        std::vector<char const*> argv;
+        argv.push_back(binary_name);
+        argv.insert(argv.end(), args);
+        argv.push_back(nullptr);
+
+        execvp(binary_name, const_cast<char* const*>(argv.data()));
+        // We can only get here by failing to exec
+        write(error_pipe.write_fd(), &errno, sizeof errno);
+    }
+
+    error_pipe.close_write_fd();
+    error_t error = 0;
+    if (read(error_pipe.read_fd(), &error, sizeof error) == -1)
+        BOOST_THROW_EXCEPTION(boost::enable_error_info(std::runtime_error("Failed to read from pipe"))
+                              << boost::errinfo_errno(errno));
+
+    if (error != 0)
+        BOOST_THROW_EXCEPTION(
+            boost::enable_error_info(std::runtime_error(std::string("Failed to execute process: ") + binary_name))
+            << boost::errinfo_errno(errno));
+
+    return std::unique_ptr<PidHandle>(new PidHandle(child));
+}
+}
+
+std::future<std::unique_ptr<mir::process::Handle>> mir::process::ForkSpawner::run_from_path(char const* binary_name)
+    const
+{
+    return std::async(
+        std::launch::async, run, binary_name, std::initializer_list<char const*>(), std::initializer_list<int>());
+}
+
+std::future<std::unique_ptr<mir::process::Handle>> mir::process::ForkSpawner::run_from_path(
+    char const* binary_name, std::initializer_list<char const*> args) const
+{
+    return std::async(std::launch::async, run, binary_name, args, std::initializer_list<int>());
+}
+
+std::future<std::unique_ptr<mir::process::Handle>> mir::process::ForkSpawner::run_from_path(
+    char const* binary_name, std::initializer_list<char const*> args, std::initializer_list<int> fds) const
+{
+    return std::async(std::launch::async, run, binary_name, args, fds);
+}
 
=== added file 'src/server/process/fork_spawner.h'
--- src/server/process/fork_spawner.h	1970-01-01 00:00:00 +0000
+++ src/server/process/fork_spawner.h	2014-01-28 06:34:09 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+
+#ifndef MIR_PROCESS_FORK_SPAWNER_H_
+#define MIR_PROCESS_FORK_SPAWNER_H_
+
+#include "mir/process/spawner.h"
+
+namespace mir
+{
+namespace process
+{
+
+/**
+ * \brief An implementation of mir::process::Spawner that forks new processes
+ */
+class ForkSpawner : public Spawner
+{
+public:
+    std::future<std::unique_ptr<Handle>> run_from_path(char const* binary_name) const override;
+    std::future<std::unique_ptr<Handle>> run_from_path(char const* binary_name, std::initializer_list<char const*> args) const override;
+    std::future<std::unique_ptr<Handle>> run_from_path(char const* binary_name, std::initializer_list<char const*> args, std::initializer_list<int> fds) const override;
+};
+
+}
+}
+
+#endif // MIR_PROCESS_FORK_SPAWNER_H_
 
=== added directory 'src/server/xserver'
=== added file 'src/server/xserver/CMakeLists.txt'
--- src/server/xserver/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/server/xserver/CMakeLists.txt	2014-01-28 06:34:09 +0000
@@ -0,0 +1,12 @@
+set(
+  MIR_XSERVER_SRCS
+
+  global_socket_listening_server_spawner.cpp
+  null_server_spawner.cpp
+)
+
+ADD_LIBRARY(
+  mirxserverintegration STATIC
+
+  ${MIR_XSERVER_SRCS}
+)
 
=== added file 'src/server/xserver/global_socket_listening_server_spawner.cpp'
--- src/server/xserver/global_socket_listening_server_spawner.cpp	1970-01-01 00:00:00 +0000
+++ src/server/xserver/global_socket_listening_server_spawner.cpp	2014-01-28 06:34:09 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#include <unistd.h>
+#include <errno.h>
+
+#include <boost/throw_exception.hpp>
+#include <boost/exception/errinfo_errno.hpp>
+
+#include "global_socket_listening_server_spawner.h"
+#include "mir/process/handle.h"
+
+namespace mx = mir::X;
+
+mx::GlobalSocketListeningServerContext::GlobalSocketListeningServerContext(std::unique_ptr<mir::process::Handle> server_handle, std::string connection_string)
+    : server_handle(std::move(server_handle)),
+      connection_string(connection_string)
+{
+}
+
+char const* mx::GlobalSocketListeningServerContext::client_connection_string()
+{
+    return connection_string.c_str();
+}
+
+std::future<std::unique_ptr<mx::ServerContext>> mx::GlobalSocketListeningServerSpawner::create_server(std::shared_ptr<mir::process::Spawner> const& spawner, std::shared_ptr<mir::frontend::Connector> const& connector)
+{
+    return std::async(std::launch::async, [spawner, connector]()
+    {
+        mir::pipe::Pipe displayfd_pipe;
+        auto displayfd = std::to_string(displayfd_pipe.write_fd());
+        int mir_fd = connector->client_socket_fd();
+        auto mir_fd_arg = std::string("fd://") + std::to_string(mir_fd);
+
+        auto future_handle = spawner->run_from_path("Xorg",
+                                                    {"-displayfd", displayfd.c_str(),
+                                                     "-mir", "xserver",
+                                                     "-mirSocket", mir_fd_arg.c_str()},
+                                                    {displayfd_pipe.write_fd(), mir_fd});
+
+        char display_number[10];
+        errno = 0;
+        int bytes_read = read(displayfd_pipe.read_fd(), display_number, sizeof display_number);
+
+        while (bytes_read == -1 && errno == EINTR)
+            bytes_read = read(displayfd_pipe.read_fd(), display_number, sizeof display_number);;
+
+        if (errno != 0)
+            BOOST_THROW_EXCEPTION(boost::enable_error_info(std::runtime_error("Failed to receive display number from Xserver"))
+                                  << boost::errinfo_errno(errno));
+
+        display_number[bytes_read] = '\0';
+
+        return std::unique_ptr<mx::ServerContext>(new mx::GlobalSocketListeningServerContext(future_handle.get(), std::string(":") + display_number));
+    });
+}
 
=== added file 'src/server/xserver/global_socket_listening_server_spawner.h'
--- src/server/xserver/global_socket_listening_server_spawner.h	1970-01-01 00:00:00 +0000
+++ src/server/xserver/global_socket_listening_server_spawner.h	2014-01-28 06:34:09 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#ifndef MIR_X_GLOBAL_SOCKET_LISTENING_SERVER_SPAWNER_H_
+#define MIR_X_GLOBAL_SOCKET_LISTENING_SERVER_SPAWNER_H_
+
+#include "mir/xserver/xserver_launcher.h"
+#include "mir/process/spawner.h"
+#include "mir/pipe.h"
+
+#include <memory>
+
+namespace mir
+{
+namespace X
+{
+class GlobalSocketListeningServerContext : public ServerContext
+{
+public:
+    GlobalSocketListeningServerContext(std::unique_ptr<mir::process::Handle> server_handle, std::string connection_string);
+    char const* client_connection_string() override;
+
+private:
+    std::unique_ptr<mir::process::Handle> server_handle;
+    std::string connection_string;
+};
+
+class GlobalSocketListeningServerSpawner : public ServerSpawner
+{
+public:
+    std::future<std::unique_ptr<ServerContext>> create_server(std::shared_ptr<mir::process::Spawner> const& spawner, std::shared_ptr<mir::frontend::Connector> const& connector) override;
+};
+
+}
+}
+
+#endif // MIR_X_GLOBAL_SOCKET_LISTENING_SERVER_SPAWNER_H_
 
=== added file 'src/server/xserver/null_server_spawner.cpp'
--- src/server/xserver/null_server_spawner.cpp	1970-01-01 00:00:00 +0000
+++ src/server/xserver/null_server_spawner.cpp	2014-01-28 06:34:09 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#include "mir/xserver/null_server_spawner.h"
+
+const char* mir::X::NullServerContext::client_connection_string()
+{
+    return "";
+}
+
+std::future<std::unique_ptr<mir::X::ServerContext>> mir::X::NullServerSpawner::create_server(
+    std::shared_ptr<mir::process::Spawner> const& unused, std::shared_ptr<mir::frontend::Connector> const& unuseder)
+{
+    static_cast<void>(unused);
+    static_cast<void>(unuseder);
+    std::promise<std::unique_ptr<mir::X::ServerContext>> boring_promise;
+    boring_promise.set_value(std::unique_ptr<mir::X::ServerContext>(new mir::X::NullServerContext));
+    return boring_promise.get_future();
+}
 
=== modified file 'src/shared/CMakeLists.txt'
--- src/shared/CMakeLists.txt	2014-01-13 06:12:33 +0000
+++ src/shared/CMakeLists.txt	2014-01-28 06:34:09 +0000
@@ -11,6 +11,7 @@
 add_subdirectory(logging)
 add_subdirectory(lttng)
 add_subdirectory(env)
+add_subdirectory(pipe)
 
 set(
   MIR_COMMON_PLATFORM_LIBRARIES
 
=== added directory 'src/shared/pipe'
=== added file 'src/shared/pipe/CMakeLists.txt'
--- src/shared/pipe/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/shared/pipe/CMakeLists.txt	2014-01-28 06:34:09 +0000
@@ -0,0 +1,19 @@
+# Copyright © 2014 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authored by: Christopher James Halse Rogers <[e-mail]>
+
+add_library(mirsharedpipe STATIC
+  pipe.cpp
+)
 
=== renamed file 'tests/mir_test/pipe.cpp' => 'src/shared/pipe/pipe.cpp'
--- tests/mir_test/pipe.cpp	2013-07-02 15:44:55 +0000
+++ src/shared/pipe/pipe.cpp	2014-01-28 06:34:09 +0000
@@ -2,34 +2,40 @@
  * Copyright © 2013 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,
+ * under the terms of the GNU Lesser 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 warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * GNU Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
+ * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#include <mir_test/pipe.h>
+#include "mir/pipe.h"
 
 #include <boost/throw_exception.hpp>
 #include <boost/exception/errinfo_errno.hpp>
 
 #include <stdexcept>
 
+#include <fcntl.h>
 #include <unistd.h>
 
-namespace mt = mir::test;
-
-mt::Pipe::Pipe()
-{
-    if (pipe(pipefd))
+namespace mp = mir::pipe;
+
+mp::Pipe::Pipe()
+    : Pipe(0)
+{
+}
+
+mp::Pipe::Pipe(int flags)
+{
+    if (::pipe2(pipefd, flags))
     {
         BOOST_THROW_EXCEPTION(
             boost::enable_error_info(std::runtime_error("Failed to create pipe"))
@@ -37,18 +43,32 @@
     }
 }
 
-mt::Pipe::~Pipe()
+mp::Pipe::~Pipe()
+{
+    if (pipefd[0] != -1)
+        close(pipefd[0]);
+    if (pipefd[1] != -1)
+        close(pipefd[1]);
+}
+
+int mp::Pipe::read_fd() const
+{
+    return pipefd[0];
+}
+
+int mp::Pipe::write_fd() const
+{
+    return pipefd[1];
+}
+
+void mp::Pipe::close_read_fd()
 {
     close(pipefd[0]);
+    pipefd[0] = -1;
+}
+
+void mp::Pipe::close_write_fd()
+{
     close(pipefd[1]);
-}
-
-int mt::Pipe::read_fd() const
-{
-    return pipefd[0];
-}
-
-int mt::Pipe::write_fd() const
-{
-    return pipefd[1];
+    pipefd[1] = -1;
 }
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-01-23 08:06:05 +0000
+++ tests/CMakeLists.txt	2014-01-28 06:34:09 +0000
@@ -36,6 +36,7 @@
 
 if (MIR_BUILD_ACCEPTANCE_TESTS)
   add_subdirectory(acceptance-tests/)
+  pkg_check_modules(X11 REQUIRED x11)
 endif (MIR_BUILD_ACCEPTANCE_TESTS)
 
 if (MIR_BUILD_INTEGRATION_TESTS)
 
=== modified file 'tests/acceptance-tests/CMakeLists.txt'
--- tests/acceptance-tests/CMakeLists.txt	2014-01-24 11:15:31 +0000
+++ tests/acceptance-tests/CMakeLists.txt	2014-01-28 06:34:09 +0000
@@ -27,6 +27,8 @@
   test_server_disconnect.cpp
   test_client_library_drm.cpp
   test_protobuf.cpp
+  test_subprocess.cpp
+  test_xserver_spawner.cpp
   ${GENERATED_PROTOBUF_SRCS}
   ${GENERATED_PROTOBUF_HDRS}
 )
@@ -65,6 +67,7 @@
   ${GMOCK_LIBRARY}
   ${GMOCK_MAIN_LIBRARY}
   ${CMAKE_THREAD_LIBS_INIT} # Link in pthread.
+  ${X11_LDFLAGS}
 )
 
 CMAKE_DEPENDENT_OPTION(
 
=== modified file 'tests/acceptance-tests/test_display_configuration.cpp'
--- tests/acceptance-tests/test_display_configuration.cpp	2014-01-13 06:12:33 +0000
+++ tests/acceptance-tests/test_display_configuration.cpp	2014-01-28 06:34:09 +0000
@@ -20,6 +20,7 @@
 #include "mir/frontend/session_authorizer.h"
 #include "mir/graphics/event_handler_register.h"
 #include "src/server/scene/global_event_sender.h"
+#include "mir/pipe.h"
 
 #include "mir_test_framework/display_server_test_fixture.h"
 #include "mir_test_framework/cross_process_sync.h"
@@ -32,7 +33,6 @@
 #include "mir_test_doubles/stub_display_configuration.h"
 #include "mir_test_doubles/stub_buffer_allocator.h"
 #include "mir_test/fake_shared.h"
-#include "mir_test/pipe.h"
 #include "mir_test/cross_process_action.h"
 
 #include "mir_toolkit/mir_client_library.h"
@@ -49,6 +49,7 @@
 namespace mtf = mir_test_framework;
 namespace mtd = mir::test::doubles;
 namespace mt = mir::test;
+namespace mp = mir::pipe;
 
 namespace
 {
@@ -127,7 +128,7 @@
 private:
     std::shared_ptr<mg::DisplayConfiguration> config;
     mtd::NullDisplayBuffer display_buffer;
-    mt::Pipe p;
+    mp::Pipe p;
     std::atomic<bool> handler_called;
 };
 
 
=== added file 'tests/acceptance-tests/test_subprocess.cpp'
--- tests/acceptance-tests/test_subprocess.cpp	1970-01-01 00:00:00 +0000
+++ tests/acceptance-tests/test_subprocess.cpp	2014-01-28 06:34:09 +0000
@@ -0,0 +1,166 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#include "src/server/process/fork_spawner.h"
+#include "mir/process/spawner.h"
+#include "mir/process/handle.h"
+
+#include <fstream>
+#include <sstream>
+#include <unistd.h>
+#include <thread>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <errno.h>
+#include <string.h>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+TEST(ProcessTest, RunFromPathRunsCorrectBinary)
+{
+    mir::process::ForkSpawner spawner;
+
+    auto future_handle = spawner.run_from_path("true");
+    auto handle = future_handle.get();
+
+    std::stringstream stat_path;
+    stat_path << "/proc/" << handle->pid() << "/stat";
+
+    std::ifstream status{stat_path.str()};
+
+    char binary_name[PATH_MAX];
+
+    // Read up to the initial '('
+    while (status.good() && !status.eof() && (status.get() != '('))
+        ;
+
+    status.getline(binary_name, sizeof(binary_name), ')');
+
+    EXPECT_STREQ("true", binary_name);
+}
+
+TEST(ProcessTest, ChildHasExpectedFDs)
+{
+    mir::process::ForkSpawner spawner;
+
+    auto fd = open("/dev/null", O_RDONLY);
+    auto future_handle = spawner.run_from_path("sleep", {"1"});
+    auto handle = future_handle.get();
+
+    // TODO: Why is this racy?
+    std::this_thread::sleep_for(std::chrono::milliseconds{1});
+
+    std::stringstream fds_path;
+    fds_path << "/proc/" << handle->pid() << "/fd";
+
+    bool found_stdin = false, found_stdout = false, found_stderr = false;
+
+    DIR* process_fds_dir = opendir(fds_path.str().c_str());
+    ASSERT_NE(process_fds_dir, nullptr) << "Error opening " << fds_path.str() << ": " << strerror(errno) << " ("
+                                        << errno << ")" << std::endl;
+    struct dirent* entry;
+    while ((entry = readdir(process_fds_dir)) != nullptr)
+    {
+        // We don't care about directory links
+        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+            continue;
+
+        if (strcmp(entry->d_name, "0") == 0)
+        {
+            found_stdin = true;
+        }
+        else if (strcmp(entry->d_name, "1") == 0)
+        {
+            found_stdout = true;
+        }
+        else if (strcmp(entry->d_name, "2") == 0)
+        {
+            found_stderr = true;
+        }
+        else
+        {
+            ADD_FAILURE() << "Unexpected fd: " << entry->d_name << std::endl;
+        }
+    }
+    EXPECT_TRUE(found_stdin);
+    EXPECT_TRUE(found_stdout);
+    EXPECT_TRUE(found_stderr);
+    closedir(process_fds_dir);
+    close(fd);
+}
+
+TEST(ProcessTest, ChildReceivesExpectedCmdline)
+{
+    mir::process::ForkSpawner spawner;
+
+    auto future_handle = spawner.run_from_path("sleep", {"10"});
+    auto handle = future_handle.get();
+
+    std::stringstream cmdline_path;
+    cmdline_path << "/proc/" << handle->pid() << "/cmdline";
+
+    std::ifstream cmdline{cmdline_path.str()};
+
+    // We expect "sleep\010\0\0"
+    char buffer[5 + 1 + 2 + 1 + 1];
+    cmdline.read(buffer, sizeof(buffer));
+
+    EXPECT_STREQ("sleep", buffer);
+    EXPECT_STREQ("10", buffer + 6);
+}
+
+TEST(ProcessTest, SpawningNonExistentBinaryThrows)
+{
+    mir::process::ForkSpawner spawner;
+
+    auto future_handle = spawner.run_from_path("I'm a binary that almost certainly doesn't exist");
+
+    EXPECT_THROW(future_handle.get(), std::runtime_error);
+}
+
+TEST(ProcessTest, ChildRetainsSetFDs)
+{
+    mir::process::ForkSpawner spawner;
+
+    auto fd = open("/dev/null", 0);
+    auto future_handle = spawner.run_from_path("sleep", {"1"}, {fd});
+    auto handle = future_handle.get();
+
+    // TODO: Why is this racy?
+
+    std::stringstream fds_path;
+    fds_path << "/proc/" << handle->pid() << "/fd";
+
+    bool found_our_fd = false;
+
+    DIR* process_fds_dir = opendir(fds_path.str().c_str());
+    ASSERT_NE(process_fds_dir, nullptr) << "Error opening " << fds_path.str() << ": " << strerror(errno) << " ("
+                                        << errno << ")" << std::endl;
+    struct dirent* entry;
+    while ((entry = readdir(process_fds_dir)) != nullptr)
+    {
+        if (atoi(entry->d_name) == fd)
+            found_our_fd = true;
+    }
+    EXPECT_TRUE(found_our_fd);
+    closedir(process_fds_dir);
+    close(fd);
+}
 
=== added file 'tests/acceptance-tests/test_xserver_spawner.cpp'
--- tests/acceptance-tests/test_xserver_spawner.cpp	1970-01-01 00:00:00 +0000
+++ tests/acceptance-tests/test_xserver_spawner.cpp	2014-01-28 06:34:09 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#include "src/server/xserver/global_socket_listening_server_spawner.h"
+#include "mir_test_framework/testing_server_configuration.h"
+#include "mir_test_framework/in_process_server.h"
+#include "mir/xserver/xserver_launcher.h"
+#include "src/server/process/fork_spawner.h"
+
+#include <X11/Xlib.h>
+#include <stdlib.h>
+
+#include <gtest/gtest.h>
+
+namespace mtf = mir_test_framework;
+namespace mx = mir::X;
+
+namespace
+{
+struct XserverSpawningServer : public mtf::InProcessServer
+{
+public:
+    std::shared_ptr<mx::ServerSpawner> the_xserver_spawner()
+    {
+        return config.the_xserver_spawner();
+    }
+
+    mir::DefaultServerConfiguration& server_config() override
+    {
+        return config;
+    }
+
+    class SocketListeningXServerConfig : public mtf::StubbedServerConfiguration
+    {
+    public:
+        std::shared_ptr<mx::ServerSpawner> the_xserver_spawner() override
+        {
+            return std::make_shared<mx::GlobalSocketListeningServerSpawner> ();
+        }
+    } config;
+};
+}
+
+// This requires a bit more fiddling before it will work.
+// Particularly, it needs an xorg.conf that specifies dummy
+// devices, so the real devices don't fail to load.
+TEST_F(XserverSpawningServer, DISABLED_X11ClientConnects)
+{
+    // Ensure the surrounding environment doesn't mess with the test
+    unsetenv("DISPLAY");
+
+    auto xserver = the_xserver_spawner()->create_server(std::make_shared<mir::process::ForkSpawner>(), config.the_connector());
+    Display* disp = XOpenDisplay(xserver.get()->client_connection_string());
+
+    ASSERT_TRUE(disp != NULL);
+
+    XCloseDisplay(disp);
+}
 
=== modified file 'tests/integration-tests/test_display_server_main_loop_events.cpp'
--- tests/integration-tests/test_display_server_main_loop_events.cpp	2014-01-13 06:12:33 +0000
+++ tests/integration-tests/test_display_server_main_loop_events.cpp	2014-01-28 06:34:09 +0000
@@ -23,8 +23,8 @@
 #include "mir/main_loop.h"
 #include "mir/display_changer.h"
 #include "mir/server_status_listener.h"
+#include "mir/pipe.h"
 
-#include "mir_test/pipe.h"
 #include "mir_test_framework/testing_server_configuration.h"
 #include "mir_test_doubles/mock_input_manager.h"
 #include "mir_test_doubles/mock_compositor.h"
@@ -46,7 +46,7 @@
 namespace mc = mir::compositor;
 namespace mg = mir::graphics;
 namespace mf = mir::frontend;
-namespace mt = mir::test;
+namespace mp = mir::pipe;
 namespace mtd = mir::test::doubles;
 namespace mtf = mir_test_framework;
 
@@ -314,7 +314,7 @@
     std::shared_ptr<mtd::MockInputManager> mock_input_manager;
     std::shared_ptr<MockDisplayChanger> mock_display_changer;
 
-    mt::Pipe p;
+    mp::Pipe p;
     int const pause_signal;
     int const resume_signal;
 };
 
=== modified file 'tests/mir_test/CMakeLists.txt'
--- tests/mir_test/CMakeLists.txt	2013-08-28 03:41:48 +0000
+++ tests/mir_test/CMakeLists.txt	2014-01-28 06:34:09 +0000
@@ -1,7 +1,6 @@
 add_library(
   mir-test STATIC
 
-  pipe.cpp
   display_config_matchers.cpp
   cross_process_action.cpp
 )
 
=== modified file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	2014-01-23 08:21:21 +0000
+++ tests/unit-tests/CMakeLists.txt	2014-01-28 06:34:09 +0000
@@ -11,6 +11,7 @@
   test_asio_main_loop.cpp
   shared_library_test.cpp
   test_raii.cpp
+  test_fork_spawner.cpp
 )
 
 if (UMOCKDEV_REQUIRED)
@@ -29,6 +30,7 @@
 add_subdirectory(android_input/)
 add_subdirectory(scene/)
 add_subdirectory(draw/)
+add_subdirectory(xserver/)
 
 add_executable(mir_unit_tests ${UNIT_TEST_SOURCES})
 uses_android_input(mir_unit_tests)
@@ -42,6 +44,7 @@
   mirdraw
   mirtestdraw
   mirlogging
+  mirxserverintegration
 
   mir-test
   mir-test-doubles
 
=== modified file 'tests/unit-tests/test_asio_main_loop.cpp'
--- tests/unit-tests/test_asio_main_loop.cpp	2014-01-13 06:12:33 +0000
+++ tests/unit-tests/test_asio_main_loop.cpp	2014-01-28 06:34:09 +0000
@@ -17,7 +17,7 @@
  */
 
 #include "mir/asio_main_loop.h"
-#include "mir_test/pipe.h"
+#include "mir/pipe.h"
 
 #include <gtest/gtest.h>
 
@@ -27,7 +27,7 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-namespace mt = mir::test;
+namespace mp = mir::pipe;
 
 TEST(AsioMainLoopTest, signal_handled)
 {
@@ -148,7 +148,7 @@
 
 TEST(AsioMainLoopTest, fd_data_handled)
 {
-    mt::Pipe p;
+    mp::Pipe p;
     char const data_to_write{'a'};
     int handled_fd{0};
     char data_read{0};
@@ -173,7 +173,7 @@
 
 TEST(AsioMainLoopTest, multiple_fds_with_single_handler_handled)
 {
-    std::vector<mt::Pipe> const pipes(2);
+    std::vector<mp::Pipe> const pipes(2);
     size_t const num_elems_to_send{10};
     std::vector<int> handled_fds;
     std::vector<size_t> elems_read;
@@ -223,7 +223,7 @@
 
 TEST(AsioMainLoopTest, multiple_fd_handlers_are_called)
 {
-    std::vector<mt::Pipe> const pipes(3);
+    std::vector<mp::Pipe> const pipes(3);
     std::vector<int> const elems_to_send{10,11,12};
     std::vector<int> handled_fds{0,0,0};
     std::vector<int> elems_read{0,0,0};
 
=== added file 'tests/unit-tests/test_fork_spawner.cpp'
--- tests/unit-tests/test_fork_spawner.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/test_fork_spawner.cpp	2014-01-28 06:34:09 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#include "src/server/process/fork_spawner.cpp"
+
+#include <set>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+using namespace testing;
+
+TEST(ForkSpawnerTest, OpenFDsListsCorrectFDs)
+{
+    // We start with stdin, stdout stderr
+    std::set<int> std_fds{0, 1, 2};
+    std::set<int> extra_fds;
+
+    extra_fds.insert(open("/dev/null", O_RDONLY));
+
+    // Ensure we have a hole in our fd numbering
+    int spacing_fd = open("/dev/null", O_RDONLY);
+
+    extra_fds.insert(open("/dev/null", O_RDONLY));
+    extra_fds.insert(open("/dev/null", O_RDONLY));
+
+    close(spacing_fd);
+
+    for (auto fd : open_fds())
+    {
+        if (std_fds.erase(fd) != 1)
+        {
+            if (extra_fds.erase(fd) != 1)
+            {
+                // We can't fail on unexpected fd as we don't control our test environment
+                // sufficiently - ctest leaves fds open.
+                close(fd);
+            }
+        }
+    }
+
+    EXPECT_THAT(std_fds, IsEmpty());
+    EXPECT_THAT(extra_fds, IsEmpty());
+
+    for (auto fd : extra_fds)
+    {
+        close(fd);
+    }
+}
 
=== added directory 'tests/unit-tests/xserver'
=== added file 'tests/unit-tests/xserver/CMakeLists.txt'
--- tests/unit-tests/xserver/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/xserver/CMakeLists.txt	2014-01-28 06:34:09 +0000
@@ -0,0 +1,8 @@
+list(APPEND UNIT_TEST_SOURCES
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_xserver_spawner.cpp
+)
+
+set(
+  UNIT_TEST_SOURCES
+  ${UNIT_TEST_SOURCES}
+  PARENT_SCOPE)
 
=== added file 'tests/unit-tests/xserver/test_xserver_spawner.cpp'
--- tests/unit-tests/xserver/test_xserver_spawner.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/xserver/test_xserver_spawner.cpp	2014-01-28 06:34:09 +0000
@@ -0,0 +1,206 @@
+/*
+ * Copyright © 2014 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 warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Authored by: Christopher James Halse Rogers <[e-mail]>
+ */
+
+#include <future>
+#include <vector>
+#include <thread>
+#include <condition_variable>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "mir/process/spawner.h"
+#include "mir/process/handle.h"
+
+#include "src/server/xserver/global_socket_listening_server_spawner.h"
+
+using namespace ::testing;
+
+namespace
+{
+struct MockConnector : public mir::frontend::Connector
+{
+    MOCK_METHOD0(start, void(void));
+    MOCK_METHOD0(stop, void(void));
+    MOCK_CONST_METHOD0(client_socket_fd, int(void));
+    MOCK_CONST_METHOD0(remove_endpoint, void(void));
+};
+
+struct MockProcessSpawner : public mir::process::Spawner
+{
+    MOCK_CONST_METHOD3(run, mir::process::Handle*(std::string, std::vector<char const*>, std::vector<int>));
+
+    std::future<std::unique_ptr<mir::process::Handle>> run_from_path(char const* binary) const override
+    {
+        std::promise<std::unique_ptr<mir::process::Handle>> dummy_promise;
+        dummy_promise.set_value(std::unique_ptr<mir::process::Handle>(
+            run(binary, std::initializer_list<char const*>(), std::initializer_list<int>())));
+        return dummy_promise.get_future();
+    }
+    std::future<std::unique_ptr<mir::process::Handle>> run_from_path(char const* binary,
+                                                                     std::initializer_list<char const*> args) const
+        override
+    {
+        std::promise<std::unique_ptr<mir::process::Handle>> dummy_promise;
+        dummy_promise.set_value(std::unique_ptr<mir::process::Handle>(run(binary, args, std::initializer_list<int>())));
+        return dummy_promise.get_future();
+    }
+
+    std::future<std::unique_ptr<mir::process::Handle>> run_from_path(char const* binary,
+                                                                     std::initializer_list<char const*> args,
+                                                                     std::initializer_list<int> fds) const override
+    {
+        std::promise<std::unique_ptr<mir::process::Handle>> dummy_promise;
+        dummy_promise.set_value(std::unique_ptr<mir::process::Handle>(run(binary, args, fds)));
+        return dummy_promise.get_future();
+    }
+};
+
+struct SocketListeningServerTest : public testing::Test
+{
+    SocketListeningServerTest()
+        : default_server_number("100"),
+          spawner(std::make_shared<NiceMock<MockProcessSpawner>>()),
+          connector(std::make_shared<NiceMock<MockConnector>>())
+    {
+        ON_CALL(*spawner, run(_, _, _))
+            .WillByDefault(DoAll(SaveArg<0>(&binary),
+                                 SaveArg<1>(&args),
+                                 SaveArg<2>(&fds),
+                                 InvokeWithoutArgs([this]()
+                                                   { write_server_string(default_server_number); }),
+                                 Return(nullptr)));
+        ON_CALL(*connector, client_socket_fd())
+            .WillByDefault(Return(22));
+    }
+
+    void write_server_string(std::string server_number)
+    {
+        auto location = std::find_if(args.begin(), args.end(), [](char const* a)
+                                     { return strcmp(a, "-displayfd") == 0; });
+        ASSERT_NE(location, args.end());
+        ASSERT_NE(++location, args.end());
+        int server_fd = atoi(*location);
+        write(server_fd, server_number.data(), server_number.length());
+        close(server_fd);
+    }
+
+    std::string default_server_number;
+    std::string binary;
+    std::vector<char const*> args;
+    std::vector<int> fds;
+    std::shared_ptr<NiceMock<MockProcessSpawner>> spawner;
+    std::shared_ptr<NiceMock<MockConnector>> connector;
+};
+}
+
+TEST_F(SocketListeningServerTest, CreateServerAlwaysValid)
+{
+    mir::X::GlobalSocketListeningServerSpawner factory;
+
+    auto server_context = factory.create_server(spawner, connector);
+    ASSERT_NE(server_context.get(), nullptr);
+}
+
+TEST_F(SocketListeningServerTest, SpawnsCorrectExecutable)
+{
+    mir::X::GlobalSocketListeningServerSpawner factory;
+
+    auto server_context = factory.create_server(spawner, connector);
+    server_context.get();
+
+    EXPECT_EQ(binary, "Xorg");
+}
+
+namespace
+{
+MATCHER_P(ContainsSubsequence, subsequence, "")
+{
+    auto location =
+        std::search(arg.begin(), arg.end(), subsequence.begin(), subsequence.end(), [](char const* a, std::string b)
+                    { return strcmp(a, b.c_str()) == 0; });
+    return location != arg.end();
+}
+}
+
+TEST_F(SocketListeningServerTest, SpawnsWithDisplayFDSet)
+{
+    mir::X::GlobalSocketListeningServerSpawner factory;
+
+    auto server_context = factory.create_server(spawner, connector);
+    server_context.get();
+
+    ASSERT_THAT(args, Not(IsEmpty()));
+    ASSERT_THAT(fds, Not(IsEmpty()));
+
+    Matcher<std::vector<char const*>> fd_matcher = Not(_);
+    for (auto fd : fds)
+    {
+        fd_matcher = AnyOf(fd_matcher, ContainsSubsequence(std::vector<std::string>{"-displayfd", std::to_string(fd)}));
+    }
+    EXPECT_THAT(args, fd_matcher);
+}
+
+TEST_F(SocketListeningServerTest, ReturnsCorrectDisplayString)
+{
+    mir::X::GlobalSocketListeningServerSpawner factory;
+
+    default_server_number = "20";
+    auto server_context = factory.create_server(spawner, connector);
+
+    EXPECT_STREQ(":20", server_context.get()->client_connection_string());
+}
+
+TEST_F(SocketListeningServerTest, HandlesSpawnerLifecycleCorrectly)
+{
+    mir::X::GlobalSocketListeningServerSpawner factory;
+
+    std::future<std::unique_ptr<mir::X::ServerContext>> server_context;
+
+    {
+        auto tmp_spawner = std::make_shared<MockProcessSpawner>();
+        ON_CALL(*tmp_spawner, run(_, _, _))
+            .WillByDefault(DoAll(SaveArg<0>(&binary),
+                                 SaveArg<1>(&args),
+                                 SaveArg<2>(&fds),
+                                 InvokeWithoutArgs([this]()
+                                                   { write_server_string(default_server_number); }),
+                                 Return(nullptr)));
+        EXPECT_CALL(*tmp_spawner, run(_, _, _));
+        server_context = factory.create_server(tmp_spawner, connector);
+    }
+
+    ASSERT_NE(server_context.get(), nullptr);
+}
+
+TEST_F(SocketListeningServerTest, PassesMirSocketCorrectly)
+{
+    mir::X::GlobalSocketListeningServerSpawner factory;
+
+    int const mir_fd{32};
+    std::string const mir_connect_str{std::string("fd://") + std::to_string(mir_fd)};
+    EXPECT_CALL(*connector, client_socket_fd())
+        .WillOnce(Return(mir_fd));
+
+    auto server_context = factory.create_server(spawner, connector);
+
+    server_context.get();
+
+    EXPECT_THAT(args, ContainsSubsequence(std::vector<std::string>{"-mirSocket", mir_connect_str}));
+    EXPECT_THAT(fds, Contains(Eq(mir_fd)));
+}