Merge lp:~mhr3/dee/private-connections into lp:dee

[Michal Hruby]

This branch implements possibility to create private connections which can be used to synchronize the shared models.

[Mikkel Kamstrup Erlandsen (kamstrup)]

Can you file a bug on this and target it for the 1.0.0 milestone please

[Mikkel Kamstrup Erlandsen (kamstrup)]

Sorry - never mind. Why didn't I just do it myself once I had the thought? ;-) Bug #904299 filed.

[Mikkel Kamstrup Erlandsen (kamstrup)]

DeePeer and DeeServer does not seem to be included in the gtk-docs. Can you please add them under the Peer Discovery section?

Wrt to socket addresses.. Are you sure that abstract filenames are per-user? Otherwise we'd end up with collisions. And can you also make triple sure that users can not connect to each other? So on this line:

1115 + // FIXME: check same user_id?

The answer is "yes". This needs to be secure by default. If someone really wants to do some cross user talking, they're gonna have to go through the hazzle themselves I think.

Overall the code looks good, but I want to take it through a more thorough inspection before I approve this.

review: Needs Fixing

[Mikkel Kamstrup Erlandsen (kamstrup)]

(btw ran the extended tests suite and all tests pass - and distcheck still passes as well - so far so good :-))

[lp:~mhr3/dee/private-connections]

325. By Michal Hruby on 2011-12-14

Enable also the schemaless test

326. By Michal Hruby on 2011-12-14

Add test for multiple connections

327. By Michal Hruby on 2011-12-15

Merged lp:~kamstrup/dee/private-connections-tool

328. By Michal Hruby on 2011-12-15

Allow only same user to connect to the abstract socket

329. By Michal Hruby on 2011-12-15

Merge trunk

330. By Michal Hruby on 2011-12-15

Set schema on server model

331. By Michal Hruby on 2011-12-15

Regenerate doc types, add client/server to Peer discovery section

[Michal Hruby (mhr3)]

A reminder: DeeClient needs to watch the connection and emit connection-closed when that happens.

[lp:~mhr3/dee/private-connections]

332. By Michal Hruby on 2011-12-15

Make sure we emit peer-found & peer-lost signals on DeeServer and connection-closed on DeeClient

333. By Michal Hruby on 2011-12-15

Make sure we wait for the server to initialize when testing client connections

334. By Michal Hruby on 2011-12-16

Add dee_{client,server}_new_for_address and documentation

335. By Michal Hruby on 2011-12-16

A couple of docs fixes

336. By Michal Hruby on 2011-12-16

Fix warnings

337. By Michal Hruby on 2011-12-16

Few more docs fixes

[Michal Hruby (mhr3)]

Should be mostly ready to go...

[Mikkel Kamstrup Erlandsen (kamstrup)]

Awesome work dude! Code looks good and test tests are passing. Just three nitpicks and we can merge:

410 + * created using dee_server_new. The #DeePeer:swarm-leader property will be set

Can you add braces, dee_server_new(), so we gtk-doc to make the function a link.

1404 + trace_object ("User id doesn't match, rejecting connection");

This call needs a 'self' argument

.... aaand! please update the VAPI! (yes yes! I finally nailed you on that one! :-D)

review: Needs Fixing

[lp:~mhr3/dee/private-connections]

338. By Michal Hruby on 2011-12-19

Fix issues brought up during review

[Michal Hruby (mhr3)]

Done, done, done...

[Mikkel Kamstrup Erlandsen (kamstrup)]

Great work!

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2010-04-15 13:29:59 +0000
+++ .bzrignore	2011-12-19 08:59:26 +0000
@@ -12,7 +12,7 @@
 config.status
 config.sub
 configure
-dbusmodel.pc
+dee-1.0.pc
 depcomp
 install-sh
 libtool
@@ -29,72 +29,67 @@
 build/autotools/ltsugar.m4
 build/autotools/ltversion.m4
 build/autotools/lt~obsolete.m4
-dbusmodel/DbusModel-0.1.gir
-dbusmodel/DbusModel-0.1.typelib
-dbusmodel/Makefile
-dbusmodel/Makefile.in
-dbusmodel/libdbusmodel.la
-dbusmodel/libdbusmodel_la-dbus-model.lo
 doc/Makefile
 doc/Makefile.in
 doc/reference/Makefile
 doc/reference/Makefile.in
-doc/reference/libdbusmodel/Makefile
-doc/reference/libdbusmodel/Makefile.in
 examples/Makefile
 examples/Makefile.in
 examples/synced-lists
 tests/Makefile
 tests/Makefile.in
-tests/test-dbusmodel
-tests/test-dbusmodel-results.xml
-tests/test-dbusmodel-results.html
-doc/reference/libdbusmodel/html/
-doc/reference/libdbusmodel/html-build.stamp
-doc/reference/libdbusmodel/html.stamp
-doc/reference/libdbusmodel/libdbusmodel-decl-list.txt
-doc/reference/libdbusmodel/libdbusmodel-decl.txt
-doc/reference/libdbusmodel/libdbusmodel-decl.txt.bak
-doc/reference/libdbusmodel/libdbusmodel-overrides.txt
-doc/reference/libdbusmodel/libdbusmodel-sections.txt
-doc/reference/libdbusmodel/libdbusmodel-undeclared.txt
-doc/reference/libdbusmodel/libdbusmodel-undocumented.txt
-doc/reference/libdbusmodel/libdbusmodel-unused.txt
-doc/reference/libdbusmodel/libdbusmodel.args
-doc/reference/libdbusmodel/libdbusmodel.hierarchy
-doc/reference/libdbusmodel/libdbusmodel.interfaces
-doc/reference/libdbusmodel/libdbusmodel.prerequisites
-doc/reference/libdbusmodel/libdbusmodel.signals
-doc/reference/libdbusmodel/libdbusmodel.types
-doc/reference/libdbusmodel/scan-build.stamp
-doc/reference/libdbusmodel/sgml-build.stamp
-doc/reference/libdbusmodel/sgml.stamp
-doc/reference/libdbusmodel/tmpl/
-doc/reference/libdbusmodel/tmpl-build.stamp
-doc/reference/libdbusmodel/tmpl.stamp
-doc/reference/libdbusmodel/xml/
+dee/Dee-1.0.gir
+dee/Dee-1.0.typelib
+dee/com.canonical.Dee.Model-xml.h
+dee/com.canonical.Dee.Peer-xml.h
+dee/dee-marshal.c
+dee/dee-marshal.h
+dee/libdee-1.0.la
+doc/reference/dee-1.0/dee-1.0-decl-list.txt
+doc/reference/dee-1.0/dee-1.0-decl.txt
+doc/reference/dee-1.0/dee-1.0-overrides.txt
+doc/reference/dee-1.0/dee-1.0-sections.txt
+doc/reference/dee-1.0/dee-1.0-undeclared.txt
+doc/reference/dee-1.0/dee-1.0-undocumented.txt
+doc/reference/dee-1.0/dee-1.0-unused.txt
+doc/reference/dee-1.0/dee-1.0.args
+doc/reference/dee-1.0/dee-1.0.hierarchy
+doc/reference/dee-1.0/dee-1.0.interfaces
+doc/reference/dee-1.0/dee-1.0.prerequisites
+doc/reference/dee-1.0/dee-1.0.signals
+doc/reference/dee-1.0/html/
+doc/reference/dee-1.0/html-build.stamp
+doc/reference/dee-1.0/html.stamp
+doc/reference/dee-1.0/scan-build.stamp
+doc/reference/dee-1.0/setup-build.stamp
+doc/reference/dee-1.0/sgml-build.stamp
+doc/reference/dee-1.0/sgml.stamp
+doc/reference/dee-1.0/tmpl/
+doc/reference/dee-1.0/tmpl-build.stamp
+doc/reference/dee-1.0/tmpl.stamp
+doc/reference/dee-1.0/xml/
 .lo
 *.lo
 .lo
-dbusmodel/dbus-model-client.h
-dbusmodel/dbus-model-server.h
-doc/reference/libdbusmodel/libdbusmodel-decl
-doc/reference/libdbusmodel/libdbusmodel-decl-list.txt.bak
 examples/peers
-dbusmodel/dbus-model-marshal.list
 examples/master-model.c
 examples/slave-model.c
-dbusmodel/dbus-model-marshal.h
-dbusmodel/dbus-model-marshal.c
 examples/master-model
 examples/slave-model
 examples/test
 examples/master-model-vala
-dbusmodel-0.1.0.tar.gz
-dbusmodel/dbus-swarm-client.h
-dbusmodel/dbus-swarm-server.h
+tools/dee-tool
 tests/model-helper-add3rows
 tests/model-helper-change3rows
 tests/model-helper-clear3rows
 tests/model-helper-clone3rows
 tests/model-helper-insert1row
+tests/model-helper-clear3add5
+tests/model-helper-introspect
+tests/model-helper-remove3rows
+tests/model-helper-schemaless
+tests/peer-helper-1peer
+tests/server-helper-client
+tests/test-dee
+tests/test-benchmark
+tests/test-dee-results.xml

=== modified file 'dee/Makefile.am'
--- dee/Makefile.am	2011-12-15 12:28:43 +0000
+++ dee/Makefile.am	2011-12-19 08:59:26 +0000
@@ -38,6 +38,8 @@
   dee-model.h \
   dee-model-reader.h \
   dee-peer.h \
+  dee-server.h \
+  dee-client.h \
   dee-proxy-model.h \
   dee-resource-manager.h \
   dee-result-set.h \
@@ -77,6 +79,8 @@
   dee-marshal.c \
   dee-marshal.h \
   dee-peer.c \
+  dee-server.c \
+  dee-client.c \
   dee-proxy-model.c \
   dee-resource-manager.c \
   dee-result-set.c \
@@ -167,6 +171,7 @@
 	-I$(top_builddir) \
 	-DDEE_COMPILATION \
 	--include=GObject-2.0 \
+	--include=Gio-2.0 \
 	--include=GLib-2.0 \
 	--library=dee-1.0 \
 	--output $@ $(irscanner_sources)

=== added file 'dee/dee-client.c'
--- dee/dee-client.c	1970-01-01 00:00:00 +0000
+++ dee/dee-client.c	2011-12-19 08:59:26 +0000
@@ -0,0 +1,403 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License
+ * version 3.0 as published by the Free Software Foundation.
+ *
+ * This library 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 version 3.0 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michal Hruby <[e-mail]>
+ *
+ */
+/**
+ * SECTION:dee-client
+ * @short_description: Creates a client object you can use to connect
+ *                     to a #DeeServer.
+ * @include: dee.h
+ *
+ * #DeeClient is the endpoint for connecting to #DeeServer.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gio/gio.h>
+
+#include "dee-client.h"
+#include "dee-marshal.h"
+#include "trace-log.h"
+
+G_DEFINE_TYPE (DeeClient, dee_client, DEE_TYPE_PEER)
+
+#define GET_PRIVATE(o) \
+      (G_TYPE_INSTANCE_GET_PRIVATE ((o), DEE_TYPE_CLIENT, DeeClientPrivate))
+
+/**
+ * DeeClientPrivate:
+ *
+ * Ignore this structure.
+ **/
+struct _DeeClientPrivate
+{
+  GDBusConnection *connection;
+  GCancellable    *cancellable;
+  gchar           *bus_address;
+
+  guint            peer_found_timer_id;
+  gulong           closed_signal_handler_id;
+};
+
+/* Globals */
+enum
+{
+  PROP_0,
+  PROP_BUS_ADDRESS
+};
+
+enum
+{
+  LAST_SIGNAL
+};
+
+//static guint32 _server_signals[LAST_SIGNAL] = { 0 };
+
+/* Forwards */
+static gboolean     dee_client_is_swarm_leader     (DeePeer *peer);
+
+static const gchar* dee_client_get_swarm_leader    (DeePeer *peer);
+
+static GSList*      dee_client_get_connections     (DeePeer *peer);
+
+static void         connecting_finished            (GObject *object,
+                                                    GAsyncResult *res,
+                                                    gpointer user_data);
+
+static void         connection_closed              (GDBusConnection *connection,
+                                                    gboolean         remote_peer_vanished,
+                                                    GError          *error,
+                                                    DeeClient       *client);
+
+/* GObject methods */
+static void
+dee_client_get_property (GObject *object, guint property_id,
+                         GValue *value, GParamSpec *pspec)
+{
+  DeeClientPrivate *priv;
+
+  priv = DEE_CLIENT (object)->priv;
+
+  switch (property_id)
+    {
+      case PROP_BUS_ADDRESS:
+        g_value_set_string (value, priv->bus_address);
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+dee_client_set_property (GObject *object, guint property_id,
+                              const GValue *value, GParamSpec *pspec)
+{
+  DeeClientPrivate *priv;
+
+  priv = DEE_CLIENT (object)->priv;
+
+  switch (property_id)
+    {
+      case PROP_BUS_ADDRESS:
+        if (priv->bus_address) g_free (priv->bus_address);
+        priv->bus_address = g_value_dup_string (value);
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+dee_client_constructed (GObject *self)
+{
+  DeeClientPrivate *priv;
+  const gchar      *swarm_name;
+  GDBusConnectionFlags flags;
+
+  priv = DEE_CLIENT (self)->priv;
+
+  /* we should chain up the constructed method here, but peer does things we
+   * don't want to, so not chaining up... */
+
+  swarm_name = dee_peer_get_swarm_name (DEE_PEER (self));
+  if (swarm_name == NULL)
+    {
+      g_critical ("DeeClient created without a swarm name. You must specify "
+                  "a non-NULL swarm name");
+      return;
+    }
+
+  if (!priv->bus_address)
+    {
+      const gchar *username = g_get_user_name ();
+      priv->bus_address = g_strdup_printf ("unix:abstract=%s-%s",
+                                           username, swarm_name);
+    }
+
+  flags = G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT;
+  priv->cancellable = g_cancellable_new ();
+  g_dbus_connection_new_for_address (priv->bus_address,
+                                     flags,
+                                     NULL, // AuthObserver
+                                     priv->cancellable,
+                                     connecting_finished,
+                                     self);
+}
+
+static void
+dee_client_finalize (GObject *object)
+{
+  DeeClientPrivate *priv;
+
+  priv = DEE_CLIENT (object)->priv;
+
+  if (priv->cancellable)
+    {
+      g_cancellable_cancel (priv->cancellable);
+      g_object_unref (priv->cancellable);
+    }
+
+  if (priv->closed_signal_handler_id)
+    {
+      g_signal_handler_disconnect (priv->connection,
+                                   priv->closed_signal_handler_id);
+      priv->closed_signal_handler_id = 0;
+    }
+
+  if (priv->connection)
+    {
+      // FIXME: close the connection?
+      g_object_unref (priv->connection);
+    }
+
+  if (priv->peer_found_timer_id)
+    {
+      g_source_remove (priv->peer_found_timer_id);
+      priv->peer_found_timer_id = 0;
+    }
+
+  if (priv->bus_address)
+    {
+      g_free (priv->bus_address);
+    }
+
+  G_OBJECT_CLASS (dee_client_parent_class)->finalize (object);
+}
+
+static void
+dee_client_class_init (DeeClientClass *klass)
+{
+  GParamSpec   *pspec;
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  DeePeerClass *peer_class = DEE_PEER_CLASS (klass);
+
+  g_type_class_add_private (klass, sizeof (DeeClientPrivate));
+
+  object_class->constructed    = dee_client_constructed;
+  object_class->get_property   = dee_client_get_property;
+  object_class->set_property   = dee_client_set_property;
+  object_class->finalize       = dee_client_finalize;
+
+  peer_class->is_swarm_leader  = dee_client_is_swarm_leader;
+  peer_class->get_swarm_leader = dee_client_get_swarm_leader;
+  peer_class->get_connections  = dee_client_get_connections;
+
+  /**
+   * DeeClient::bus-address:
+   *
+   * D-Bus address the client will connect to. If you do not specify this 
+   * property DeeClient will try to use abstract unix domain socket where
+   * its name is a concatenation of user name running current process and
+   * the swarm name.
+   */
+  pspec = g_param_spec_string ("bus-address", "Bus address",
+                               "Bus address to use for the connection",
+                               NULL,
+                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY
+                               | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_BUS_ADDRESS, pspec);
+}
+
+static void
+dee_client_init (DeeClient *self)
+{
+  self->priv = GET_PRIVATE (self);
+}
+
+/**
+ * dee_client_new:
+ *
+ * @swarm_name: Name of swarm to join.
+ *
+ * Creates a new instance of #DeeClient and tries to connect to #DeeServer
+ * created using dee_server_new(). The #DeePeer:swarm-leader property will
+ * be set once the client connects.
+ *
+ * Return value: (transfer full): A newly constructed #DeeClient.
+ */
+DeeClient*
+dee_client_new (const gchar* swarm_name)
+{
+  g_return_val_if_fail (swarm_name != NULL, NULL);
+
+  return DEE_CLIENT (g_object_new (DEE_TYPE_CLIENT,
+                                   "swarm-name", swarm_name, NULL));
+}
+
+/**
+ * dee_client_new_for_address:
+ *
+ * @swarm_name: Name of swarm to join.
+ * @bus_address: D-Bus address to use when connecting to the server.
+ *
+ * Creates a new instance of #DeeClient and tries to connect to @bus_address.
+ * The #DeePeer:swarm-leader property will be set once the client connects.
+ *
+ * Return value: (transfer full): A newly constructed #DeeClient.
+ */
+DeeClient*
+dee_client_new_for_address (const gchar* swarm_name,
+                            const gchar* bus_address)
+{
+  g_return_val_if_fail (swarm_name != NULL, NULL);
+
+  return DEE_CLIENT (g_object_new (DEE_TYPE_CLIENT, 
+                                   "swarm-name", swarm_name,
+                                   "bus-address", bus_address, NULL));
+}
+
+/* Private Methods */
+
+static gboolean
+dee_client_is_swarm_leader (DeePeer *peer)
+{
+  return FALSE;
+}
+
+static const gchar*
+dee_client_get_swarm_leader (DeePeer *peer)
+{
+  DeeClientPrivate *priv;
+
+  priv = DEE_CLIENT (peer)->priv;
+  return priv->connection ? g_dbus_connection_get_guid (priv->connection) : NULL;
+}
+
+static GSList*
+dee_client_get_connections (DeePeer *peer)
+{
+  DeeClientPrivate *priv;
+  GSList *list = NULL;
+
+  priv = DEE_CLIENT (peer)->priv;
+
+  if (priv->connection)
+    {
+      list = g_slist_append (list, priv->connection);
+    }
+
+  return list;
+}
+
+static gboolean
+emit_peer_found (gpointer user_data)
+{
+  g_return_val_if_fail (DEE_IS_CLIENT (user_data), FALSE);
+
+  DeeClientPrivate *priv = DEE_CLIENT (user_data)->priv;
+
+  g_signal_emit_by_name (user_data, "peer-found",
+                         g_dbus_connection_get_guid (priv->connection));
+
+  priv->peer_found_timer_id = 0;
+
+  return FALSE;
+}
+
+static void
+connecting_finished (GObject *object, GAsyncResult *res, gpointer user_data)
+{
+  GDBusConnection  *connection;
+  DeeClient        *self;
+  DeeClientPrivate *priv;
+  GError           *error = NULL;
+
+  connection = g_dbus_connection_new_for_address_finish (res, &error);
+
+  if (error)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        {
+          g_warning ("Unable to connect to server: %s", error->message);
+          // swarm-leader will be set to NULL for unsuccessful connections
+          g_object_notify (G_OBJECT (user_data), "swarm-leader");
+        }
+      /* Don't touch the object in case we were cancelled, it's most likely
+       * unreffed by now */
+
+      g_error_free (error);
+      return;
+    }
+
+  self = DEE_CLIENT (user_data);
+  priv = self->priv;
+  priv->connection = connection;
+
+  g_object_unref (priv->cancellable);
+  priv->cancellable = NULL;
+
+  priv->closed_signal_handler_id = g_signal_connect (connection, "closed",
+      G_CALLBACK (connection_closed), self);
+
+  g_object_notify (G_OBJECT (user_data), "swarm-leader");
+
+  g_signal_emit_by_name (user_data, "connection-acquired", connection);
+
+  // FIXME: we might want to call some List method (same as DeePeer), so far
+  // we'll just simulate an async method (tests expect this anyway)
+  priv->peer_found_timer_id = g_idle_add_full (G_PRIORITY_DEFAULT,
+                                               emit_peer_found, user_data,
+                                               NULL);
+}
+
+static void
+connection_closed (GDBusConnection *connection, gboolean remote_peer_vanished,
+                   GError *error, DeeClient *client)
+{
+  DeeClientPrivate *priv;
+
+  g_return_if_fail (DEE_IS_CLIENT (client));
+
+  priv = client->priv;
+  priv->connection = NULL;
+
+  g_signal_handler_disconnect (connection, priv->closed_signal_handler_id);
+  priv->closed_signal_handler_id = 0;
+
+  /* Let's do reverse order of connecting_finished */
+  g_signal_emit_by_name (client, "peer-lost",
+                         g_dbus_connection_get_guid (priv->connection));
+  g_signal_emit_by_name (client, "connection-closed", connection);
+
+  g_object_notify (G_OBJECT (client), "swarm-leader");
+
+  g_object_unref (connection);
+}
+

=== added file 'dee/dee-client.h'
--- dee/dee-client.h	1970-01-01 00:00:00 +0000
+++ dee/dee-client.h	2011-12-19 08:59:26 +0000
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License
+ * version 3.0 as published by the Free Software Foundation.
+ *
+ * This library 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 version 3.0 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ */
+
+#if !defined (_DEE_H_INSIDE) && !defined (DEE_COMPILATION)
+#error "Only <dee.h> can be included directly."
+#endif
+
+#ifndef _HAVE_DEE_CLIENT_H
+#define _HAVE_DEE_CLIENT_H
+
+#include <glib.h>
+#include <glib-object.h>
+#include "dee-peer.h"
+
+G_BEGIN_DECLS
+
+#define DEE_TYPE_CLIENT dee_client_get_type()
+
+#define DEE_CLIENT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), DEE_TYPE_CLIENT, DeeClient))
+
+#define DEE_CLIENT_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), DEE_TYPE_CLIENT, DeeClientClass))
+
+#define DEE_IS_CLIENT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DEE_TYPE_CLIENT))
+
+#define DEE_IS_CLIENT_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), DEE_TYPE_CLIENT))
+
+#define DEE_CLIENT_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), DEE_TYPE_CLIENT, DeeClientClass))
+
+typedef struct _DeeClientPrivate DeeClientPrivate;
+
+typedef struct {
+  /*< private >*/
+  DeePeer parent;
+
+  DeeClientPrivate *priv;
+} DeeClient;
+
+typedef struct {
+  /*< private >*/
+  DeePeerClass parent_class;
+} DeeClientClass;
+
+/**
+ * dee_client_get_type:
+ *
+ * The GType of #DeeClient.
+ *
+ * Return value: the #GType of #DeeClient.
+ **/
+GType          dee_client_get_type         (void);
+
+DeeClient*     dee_client_new              (const gchar *swarm_name);
+
+DeeClient*     dee_client_new_for_address  (const gchar* swarm_name,
+                                            const gchar* bus_address);
+
+G_END_DECLS
+
+#endif /* _HAVE_DEE_CLIENT_H */
+

=== modified file 'dee/dee-filter-model.c'
--- dee/dee-filter-model.c	2011-12-14 14:44:58 +0000
+++ dee/dee-filter-model.c	2011-12-19 08:59:26 +0000
@@ -35,8 +35,8 @@
  * a "transfomation map" to the filtered data).
  *
  * The reuse of row iters also minimizes the amount of memory shuffling needed
- * to set up a filter model. The filtering functions, #DeeModelMapFunc and
- * #DeeModelMapNotify, has also been designed to minimize the amount of work
+ * to set up a filter model. The filtering functions, #DeeFilterMapFunc and
+ * #DeeFilterMapNotify, has also been designed to minimize the amount of work
  * done to create a filter model. So if the filter functions are written
  * optimally the resulting filter models should be cheap to construct.
  *
@@ -396,8 +396,8 @@
  * Includes @iter from the back end model in the filtered model, appending
  * it to the end of the filtered rows.
  *
- * This method is usually called when implementing #DeeModelMapFunc or
- * #DeeModelMapNotify methods.
+ * This method is usually called when implementing #DeeFilterMapFunc or
+ * #DeeFilterMapNotify methods.
  *
  * Return value: (transfer none): Always returns @iter
  */
@@ -436,8 +436,8 @@
  * Includes @iter from the back end model in the filtered model, prepending
  * it to the beginning of the filtered rows.
  *
- * This method is usually called when implementing #DeeModelMapFunc or
- * #DeeModelMapNotify methods.
+ * This method is usually called when implementing #DeeFilterMapFunc or
+ * #DeeFilterMapNotify methods.
  *
  * Return value: (transfer none): Always returns @iter
  */
@@ -476,8 +476,8 @@
  * Includes @iter from the back end model in the filtered model, inserting it at
  * @pos pushing other rows down.
  *
- * This method is usually called when implementing #DeeModelMapFunc or
- * #DeeModelMapNotify methods.
+ * This method is usually called when implementing #DeeFilterMapFunc or
+ * #DeeFilterMapNotify methods.
  *
  * Return value: (transfer none): Always returns @iter
  */
@@ -504,8 +504,8 @@
  * Includes @iter from the back end model in the filtered model, inserting it at
  * the position before @pos pushing other rows down.
  *
- * This method is usually called when implementing #DeeModelMapFunc or
- * #DeeModelMapNotify methods.
+ * This method is usually called when implementing #DeeFilterMapFunc or
+ * #DeeFilterMapNotify methods.
  *
  * Return value: (transfer none): Always returns @iter
  */
@@ -555,7 +555,7 @@
  * is already ordered this way. If that's not the case then this method has
  * undefined behaviour.
  *
- * This method is mainly intended as a helper for #DeeModelMapNotify functions
+ * This method is mainly intended as a helper for #DeeFilterMapNotify functions
  * of #DeeFilter implementations that creates filter models sorted in
  * accordance with the original models.
  *

=== modified file 'dee/dee-peer.c'
--- dee/dee-peer.c	2011-12-01 16:00:03 +0000
+++ dee/dee-peer.c	2011-12-19 08:59:26 +0000
@@ -129,9 +129,10 @@
 
 enum
 {
-  CONNECTED,
   PEER_FOUND,
   PEER_LOST,
+  CONNECTION_ACQUIRED,
+  CONNECTION_CLOSED,
 
   LAST_SIGNAL
 };
@@ -198,7 +199,13 @@
                                                      gboolean         incoming,
                                                      gpointer         user_data);
 
-/* GObject methods */
+static const gchar*  dee_peer_real_get_swarm_leader (DeePeer *self);
+
+static gboolean      dee_peer_real_is_swarm_leader  (DeePeer *self);
+
+static GSList*       dee_peer_real_get_connections  (DeePeer *self);
+
+  /* GObject methods */
 static void
 dee_peer_finalize (GObject *object)
 {
@@ -382,7 +389,7 @@
       g_value_set_string (value, DEE_PEER (object)->priv->swarm_name);
       break;
     case PROP_SWARM_LEADER:
-      g_value_set_string (value, DEE_PEER (object)->priv->swarm_leader);
+      g_value_set_string (value, dee_peer_get_swarm_leader (DEE_PEER (object)));
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, id, pspec);
@@ -401,6 +408,10 @@
   obj_class->get_property = dee_peer_get_property;
   obj_class->constructed  = dee_peer_constructed;
 
+  /* Virtual methods */
+  klass->get_swarm_leader = dee_peer_real_get_swarm_leader;
+  klass->is_swarm_leader  = dee_peer_real_is_swarm_leader;
+  klass->get_connections  = dee_peer_real_get_connections;
 
   /* Add Signals */
 
@@ -439,6 +450,42 @@
                   G_TYPE_NONE, 1,
                   G_TYPE_STRING);
   
+  /**
+   * DeePeer::new-connection:
+   * @self: the #DeePeer on which the signal is emitted
+   * @connection: the new #GDBusConnection
+   *
+   * Connect to this signal to be notified when peers connect via 
+   * new #GDBusConnection.
+   **/
+  _peer_signals[CONNECTION_ACQUIRED] =
+    g_signal_new ("connection-acquired",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (DeePeerClass, connection_acquired),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__OBJECT,
+                  G_TYPE_NONE, 1,
+                  G_TYPE_DBUS_CONNECTION);
+  
+  /**
+   * DeePeer::connection-closed:
+   * @self: the #DeePeer on which the signal is emitted
+   * @connection: the closed #GDBusConnection
+   *
+   * Connect to this signal to be notified when peers close
+   * their #GDBusConnection.
+   **/
+  _peer_signals[CONNECTION_CLOSED] =
+    g_signal_new ("connection-closed",
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (DeePeerClass, connection_closed),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__OBJECT,
+                  G_TYPE_NONE, 1,
+                  G_TYPE_DBUS_CONNECTION);
+
   /* Add properties */
   /**
    * DeePeer::swarm-name:
@@ -631,6 +678,31 @@
                           NULL); /* user_data */
 }
 
+static const gchar*
+dee_peer_real_get_swarm_leader (DeePeer *self)
+{
+  return self->priv->swarm_leader;
+}
+
+static gboolean
+dee_peer_real_is_swarm_leader (DeePeer *self)
+{
+  return self->priv->is_swarm_leader;
+}
+
+static GSList*
+dee_peer_real_get_connections (DeePeer *self)
+{
+  GSList *list = NULL;
+
+  if (self->priv->connection)
+    {
+      list = g_slist_append (list, self->priv->connection);
+    }
+
+  return list;
+}
+
 /* Public Methods */
 
 /**
@@ -653,37 +725,38 @@
 }
 
 /**
- * dee_peer_is_swarm_leader
+ * dee_peer_is_swarm_leader:
  * @self: a #DeePeer
  *
  * Return value: %TRUE if and only if this peer owns the swarm name on
  *               the session bus
  */
-const gboolean
-dee_peer_is_swarm_leader  (DeePeer *self)
+gboolean
+dee_peer_is_swarm_leader (DeePeer *self)
 {
   g_return_val_if_fail (DEE_PEER (self), FALSE);
 
-  return self->priv->is_swarm_leader;
+  DeePeerClass *klass = DEE_PEER_GET_CLASS (self);
+  return klass->is_swarm_leader (self);
 }
 
 /**
- * dee_peer_get_swarm_leader
+ * dee_peer_get_swarm_leader:
  * @self: a #DeePeer
  *
- * Gets the unique DBus address of the current swarm leader.
- *
- * This function can only be used after dee_peer_connect() has been called.
- *
- * Return value: Unique DBus address of the current swarm leader, possibly %NULL
- *    if the leader has not been detected yet
+ * In case this peer is connected to a message bus, gets the unique DBus
+ * address of the current swarm leader, otherwise returns id of the leader.
+ *
+ * Return value: Unique DBus address of the current swarm leader,
+ *    possibly %NULL if the leader has not been detected yet
  */
 const gchar*
 dee_peer_get_swarm_leader (DeePeer *self)
 {
   g_return_val_if_fail (DEE_PEER (self), NULL);
 
-  return self->priv->swarm_leader;
+  DeePeerClass *klass = DEE_PEER_GET_CLASS (self);
+  return klass->get_swarm_leader (self);
 }
 
 /**
@@ -703,6 +776,23 @@
   return self->priv->swarm_name;
 }
 
+/**
+ * dee_peer_get_connections:
+ *
+ * Gets list of #GDBusConnection instances used by this #DeePeer instance.
+ *
+ * Return value: (transfer container) (element-type Gio.DBusConnection): 
+ *               List of connections.
+ */
+GSList*
+dee_peer_get_connections (DeePeer *self)
+{
+  g_return_val_if_fail (DEE_PEER (self), NULL);
+
+  DeePeerClass *klass = DEE_PEER_GET_CLASS (self);
+  return klass->get_connections (self);
+}
+
 static void
 emit_peer_found (DeePeer     *self,
                  const gchar *name)
@@ -778,6 +868,8 @@
   priv->connection = g_object_ref (connection);
   priv->own_name = g_strdup (g_dbus_connection_get_unique_name (connection));
 
+  g_signal_emit (self, _peer_signals[CONNECTION_ACQUIRED], 0, priv->connection);
+
   priv->filter_id = g_dbus_connection_add_filter (priv->connection,
                                                   gdbus_message_filter,
                                                   self, /* self */

=== modified file 'dee/dee-peer.h'
--- dee/dee-peer.h	2011-12-14 10:59:40 +0000
+++ dee/dee-peer.h	2011-12-19 08:59:26 +0000
@@ -26,6 +26,7 @@
 
 #include <glib.h>
 #include <glib-object.h>
+#include <gio/gio.h>
 
 G_BEGIN_DECLS
 
@@ -74,11 +75,15 @@
   /*< public >*/
 
   /*< signals >*/
-  void (*connected)  (DeePeer *peer, const gchar *peer_name);
-  void (*peer_found) (DeePeer *peer, const gchar *name);
-  void (*peer_lost)  (DeePeer *peer, const gchar *name);
+  void (*peer_found)          (DeePeer *peer, const gchar *name);
+  void (*peer_lost)           (DeePeer *peer, const gchar *name);
+  void (*connection_acquired) (DeePeer *peer, GDBusConnection *connection);
+  void (*connection_closed)   (DeePeer *peer, GDBusConnection *connection);
 
   /*< vtable >*/
+  const gchar* (*get_swarm_leader)  (DeePeer *peer);
+  gboolean     (*is_swarm_leader)   (DeePeer *peer);
+  GSList*      (*get_connections)   (DeePeer *peer);
 
   /*< private >*/
   void (*_dee_peer_1) (void);
@@ -98,11 +103,13 @@
 
 DeePeer*          dee_peer_new              (const gchar* swarm_name);
 
-const gboolean    dee_peer_is_swarm_leader  (DeePeer    *self);
+gboolean          dee_peer_is_swarm_leader  (DeePeer    *self);
 
 const gchar*      dee_peer_get_swarm_leader (DeePeer    *self);
 
-const gchar *     dee_peer_get_swarm_name   (DeePeer    *self);
+const gchar*      dee_peer_get_swarm_name   (DeePeer    *self);
+
+GSList*           dee_peer_get_connections  (DeePeer    *self);
 
 G_END_DECLS
 

=== modified file 'dee/dee-sequence-model.c'
--- dee/dee-sequence-model.c	2011-12-09 14:14:11 +0000
+++ dee/dee-sequence-model.c	2011-12-19 08:59:26 +0000
@@ -25,7 +25,7 @@
  *
  * #DeeSequenceModel is an implementation of the #DeeModel<!-- --> interface
  * backed by a #GSequence. It extends #DeeSerializableModel so that you may use
- * it as back end model for a #DeeShareedModel.
+ * it as back end model for a #DeeSharedModel.
  *
  * The implementation is backed by a #GSequence giving a good tradeoff between
  * random access time versus random- insertion and deletion times.

=== added file 'dee/dee-server.c'
--- dee/dee-server.c	1970-01-01 00:00:00 +0000
+++ dee/dee-server.c	2011-12-19 08:59:26 +0000
@@ -0,0 +1,492 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License
+ * version 3.0 as published by the Free Software Foundation.
+ *
+ * This library 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 version 3.0 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Michal Hruby <[e-mail]>
+ *
+ */
+/**
+ * SECTION:dee-server
+ * @short_description: Creates a server object you can connect to.
+ * @include: dee.h
+ *
+ * #DeeServer allows you to create private connections (connections which 
+ * are not routed via dbus-daemon). Note that, unlike #DeePeer, #DeeServer
+ * will always be swarm leader, and clients connected to it cannot overtake
+ * swarm leadership once the server connection is closed.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gio/gio.h>
+
+#include "dee-server.h"
+#include "dee-marshal.h"
+#include "trace-log.h"
+
+G_DEFINE_TYPE (DeeServer, dee_server, DEE_TYPE_PEER)
+
+#define GET_PRIVATE(o) \
+      (G_TYPE_INSTANCE_GET_PRIVATE ((o), DEE_TYPE_SERVER, DeeServerPrivate))
+
+/**
+ * DeeServerPrivate:
+ *
+ * Ignore this structure.
+ **/
+struct _DeeServerPrivate
+{
+  GCredentials *our_creds;
+  GDBusServer  *server;
+  gchar        *bus_address;
+  gboolean      same_user_only;
+  guint         initialize_server_timer_id;
+
+  GSList       *active_connections;
+  guint         connection_id;
+  GHashTable   *connection_id_map;
+};
+
+/* Globals */
+enum
+{
+  PROP_0,
+  PROP_BUS_ADDRESS,
+  PROP_SAME_USER_ONLY
+};
+
+enum
+{
+  LAST_SIGNAL
+};
+
+//static guint32 _server_signals[LAST_SIGNAL] = { 0 };
+
+/* Forwards */
+static gboolean on_new_connection               (GDBusServer *server,
+                                                 GDBusConnection *connection,
+                                                 gpointer user_data);
+
+static void     on_connection_closed            (GDBusConnection *connection,
+                                                 gboolean remote_peer_vanished,
+                                                 GError *error,
+                                                 gpointer user_data);
+
+static gboolean dee_server_is_swarm_leader      (DeePeer *peer);
+
+static const gchar* dee_server_get_swarm_leader (DeePeer *peer);
+
+static GSList*  dee_server_get_connections      (DeePeer *peer);
+
+/* GObject methods */
+static void
+dee_server_get_property (GObject *object, guint property_id,
+                         GValue *value, GParamSpec *pspec)
+{
+  DeeServerPrivate *priv = DEE_SERVER (object)->priv;
+
+  switch (property_id)
+    {
+      case PROP_BUS_ADDRESS:
+        g_value_set_string (value, priv->bus_address);
+        break;
+      case PROP_SAME_USER_ONLY:
+        g_value_set_boolean (value, priv->same_user_only);
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+dee_server_set_property (GObject *object, guint property_id,
+                         const GValue *value, GParamSpec *pspec)
+{
+  DeeServerPrivate *priv = DEE_SERVER (object)->priv;
+
+  switch (property_id)
+    {
+      case PROP_BUS_ADDRESS:
+        if (priv->bus_address) g_free (priv->bus_address);
+        priv->bus_address = g_value_dup_string (value);
+        break;
+      case PROP_SAME_USER_ONLY:
+        priv->same_user_only = g_value_get_boolean (value);
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static gboolean
+initialize_server (DeeServer *self)
+{
+  DeeServerPrivate *priv;
+  gchar            *guid;
+  GDBusServerFlags  server_flags;
+  GError           *error = NULL;
+
+  priv = self->priv;
+
+  priv->initialize_server_timer_id = 0;
+
+  guid = g_dbus_generate_guid ();
+  server_flags = G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
+
+  priv->server = g_dbus_server_new_sync (priv->bus_address,
+                                         server_flags,
+                                         guid,
+                                         NULL,
+                                         NULL,
+                                         &error);
+
+  if (error)
+    {
+      g_critical ("Unable to set up DBusServer: %s", error->message);
+
+      g_error_free (error);
+      g_free (guid);
+
+      g_object_notify (G_OBJECT (self), "swarm-leader");
+      return FALSE;
+    }
+
+  g_signal_connect (priv->server, "new-connection",
+                    G_CALLBACK (on_new_connection), self);
+
+  g_dbus_server_start (priv->server);
+
+  g_object_notify (G_OBJECT (self), "swarm-leader");
+
+  g_free (guid);
+
+  return FALSE;
+}
+
+static void
+dee_server_constructed (GObject *self)
+{
+  DeeServerPrivate *priv;
+  const gchar      *swarm_name;
+
+  priv = DEE_SERVER (self)->priv;
+
+  /* we should chain up the constructed method here, but peer does things we
+   * don't want to, so not chaining up... */
+
+  swarm_name = dee_peer_get_swarm_name (DEE_PEER (self));
+  if (swarm_name == NULL)
+    {
+      g_critical ("DeeServer created without a swarm name. You must specify "
+                  "a non-NULL swarm name");
+      return;
+    }
+
+  priv->our_creds = g_credentials_new ();
+
+  if (!priv->bus_address)
+  {
+    const gchar *username = g_get_user_name ();
+    priv->bus_address = g_strdup_printf ("unix:abstract=%s-%s",
+                                         username, swarm_name);
+  }
+
+  /* Ideally we'd call the async variant of g_dbus_server_new (which doesn't
+   * exist atm) */
+  priv->initialize_server_timer_id = g_idle_add_full (G_PRIORITY_DEFAULT,
+      (GSourceFunc)initialize_server, self, NULL);
+}
+
+static void
+close_connection (gpointer data, gpointer user_data)
+{
+  GDBusConnection *connection = G_DBUS_CONNECTION (data);
+
+  g_signal_handlers_disconnect_by_func (connection, on_connection_closed,
+                                        user_data);
+
+  // FIXME: should we use the sync variant? and flush first?
+  g_dbus_connection_close (connection, NULL, NULL, NULL);
+}
+
+static void
+dee_server_finalize (GObject *object)
+{
+  DeeServerPrivate *priv;
+
+  priv = DEE_SERVER (object)->priv;
+
+  if (priv->initialize_server_timer_id)
+    {
+      g_source_remove (priv->initialize_server_timer_id);
+      priv->initialize_server_timer_id = 0;
+    }
+  
+  if (priv->active_connections)
+    {
+      g_slist_foreach (priv->active_connections, close_connection, object);
+      g_slist_free_full (priv->active_connections, g_object_unref);
+      priv->active_connections = NULL;
+    }
+
+  if (priv->server)
+    {
+      /* this should be done automatically on unref, but it doesn't seem so */
+      g_dbus_server_stop (priv->server);
+
+      g_object_unref (priv->server);
+    }
+
+  if (priv->connection_id_map)
+    {
+      g_hash_table_unref (priv->connection_id_map);
+      priv->connection_id_map = NULL;
+    }
+
+  if (priv->bus_address)
+    {
+      g_free (priv->bus_address);
+    }
+
+  if (priv->our_creds)
+    {
+      g_object_unref (priv->our_creds);
+      priv->our_creds = NULL;
+    }
+
+  G_OBJECT_CLASS (dee_server_parent_class)->finalize (object);
+}
+
+static void
+dee_server_class_init (DeeServerClass *klass)
+{
+  GParamSpec   *pspec;
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  DeePeerClass *peer_class = DEE_PEER_CLASS (klass);
+
+  g_type_class_add_private (klass, sizeof (DeeServerPrivate));
+
+  object_class->constructed = dee_server_constructed;
+  object_class->get_property = dee_server_get_property;
+  object_class->set_property = dee_server_set_property;
+  object_class->finalize = dee_server_finalize;
+
+  peer_class->is_swarm_leader  = dee_server_is_swarm_leader;
+  peer_class->get_swarm_leader = dee_server_get_swarm_leader;
+  peer_class->get_connections  = dee_server_get_connections;
+
+  /**
+   * DeeServer::bus-address:
+   *
+   * D-Bus address the server is bound to. If you do not specify this property
+   * DeeServer will try to use abstract unix domain socket where its name is
+   * a concatenation of user name running current process and the swarm name.
+   * You can use dee_server_get_client_address to get address string
+   * that can be used by clients to connect to.
+   */
+  pspec = g_param_spec_string ("bus-address", "Bus address",
+                               "Bus address to use for the connection",
+                               NULL,
+                               G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY
+                               | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_BUS_ADDRESS, pspec);
+
+  /**
+   * DeeServer::same-user-only:
+   *
+   * A boolean specifying whether the server should only accept connections
+   * from same user as the current process owner.
+   */
+  pspec = g_param_spec_boolean ("same-user-only", "Same user only",
+                                "Accept connections from current user only",
+                                TRUE,
+                                G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY
+                                | G_PARAM_STATIC_STRINGS);
+  g_object_class_install_property (object_class, PROP_SAME_USER_ONLY, pspec);
+}
+
+static void
+dee_server_init (DeeServer *self)
+{
+  self->priv = GET_PRIVATE (self);
+
+  self->priv->connection_id_map = g_hash_table_new_full (g_direct_hash,
+                                                         g_direct_equal,
+                                                         NULL,
+                                                         g_free);
+}
+
+/**
+ * dee_server_new:
+ *
+ * @swarm_name: Name of swarm to join.
+ *
+ * Creates a new instance of #DeeServer and tries to bind 
+ * to #DeeServer:bus-address. The #DeePeer:swarm-leader property will be set
+ * when the binding succeeds.
+ *
+ * Return value: (transfer full): A newly constructed #DeeServer.
+ */
+DeeServer*
+dee_server_new (const gchar* swarm_name)
+{
+  g_return_val_if_fail (swarm_name != NULL, NULL);
+
+  return DEE_SERVER (g_object_new (DEE_TYPE_SERVER,
+                                   "swarm-name", swarm_name, NULL));
+}
+
+/**
+ * dee_server_new_for_address:
+ *
+ * @swarm_name: Name of swarm to join.
+ * @bus_address: D-Bus address to use for the connection.
+ *
+ * Creates a new instance of #DeeServer and tries to bind to @bus_address.
+ * The #DeePeer:swarm-leader property will be set when the binding succeeds.
+ *
+ * Return value: (transfer full): A newly constructed #DeeServer.
+ */
+DeeServer*
+dee_server_new_for_address (const gchar* swarm_name, const gchar* bus_address)
+{
+  g_return_val_if_fail (swarm_name != NULL, NULL);
+
+  return DEE_SERVER (g_object_new (DEE_TYPE_SERVER,
+                                   "swarm-name", swarm_name,
+                                   "bus-address", bus_address, NULL));
+}
+
+/**
+ * dee_server_get_client_address:
+ *
+ * @self: A #DeeServer.
+ *
+ * Gets a D-Bus address string that can be used by clients to connect to server.
+ *
+ * Return value: A D-Bus address string. Do not free.
+ */
+const gchar*
+dee_server_get_client_address (DeeServer *server)
+{
+  DeeServerPrivate *priv;
+  g_return_val_if_fail (DEE_IS_SERVER (server), NULL);
+
+  priv = server->priv;
+
+  return priv->server != NULL ? 
+    g_dbus_server_get_client_address (priv->server) : NULL;
+}
+
+/* Private Methods */
+static gboolean
+on_new_connection (GDBusServer *server,
+                   GDBusConnection *connection,
+                   gpointer user_data)
+{
+  gchar *connection_name;
+  GCredentials *creds;
+  DeeServer *self = DEE_SERVER (user_data);
+  DeeServerPrivate *priv = self->priv;
+
+  trace_object (self, "New connection: [%p]", connection);
+
+  creds = g_dbus_connection_get_peer_credentials (connection);
+  if (!g_credentials_is_same_user (creds, priv->our_creds, NULL)
+      && priv->same_user_only)
+    {
+      trace_object (self, "User id doesn't match, rejecting connection");
+      return FALSE;
+    }
+
+  priv->active_connections = g_slist_prepend (priv->active_connections,
+                                              g_object_ref (connection));
+
+  g_signal_connect (connection, "closed",
+                    G_CALLBACK (on_connection_closed), self);
+
+  /* time to register dbus objects on this connection */
+  g_signal_emit_by_name (self, "connection-acquired", connection);
+
+  connection_name = g_strdup_printf ("%s:%u",
+                                     g_dbus_server_get_guid (priv->server),
+                                     ++priv->connection_id);
+  /* hash table assumes ownership of connection_name */
+  g_hash_table_insert (priv->connection_id_map, connection, connection_name);
+
+  g_signal_emit_by_name (self, "peer-found", connection_name);
+
+  return TRUE;
+}
+
+static void
+on_connection_closed (GDBusConnection *connection,
+                      gboolean remote_peer_vanished,
+                      GError *error,
+                      gpointer user_data)
+{
+  GSList           *element;
+  DeeServer        *self = DEE_SERVER (user_data);
+  DeeServerPrivate *priv = self->priv;
+
+  trace_object (self, "Connection [%p] was closed", connection);
+
+  element = g_slist_find (priv->active_connections, connection);
+  if (element == NULL)
+    {
+      g_warning ("Connection closed for element which isn't "
+                 "in active_connections");
+      return;
+    }
+
+  priv->active_connections = g_slist_delete_link (priv->active_connections,
+                                                  element);
+
+  /* reverse order of signals than in new-connection handler */
+  g_signal_emit_by_name (self, "peer-lost",
+                         g_hash_table_lookup (priv->connection_id_map,
+                                              connection));
+  g_hash_table_remove (priv->connection_id_map, connection);
+
+  g_signal_emit_by_name (self, "connection-closed", connection);
+
+  g_object_unref (connection);
+}
+
+static gboolean
+dee_server_is_swarm_leader (DeePeer *peer)
+{
+  DeeServerPrivate *priv = DEE_SERVER (peer)->priv;
+  return priv->server != NULL;
+}
+
+static const gchar*
+dee_server_get_swarm_leader (DeePeer *peer)
+{
+  DeeServerPrivate *priv = DEE_SERVER (peer)->priv;
+
+  return priv->server ? g_dbus_server_get_guid (priv->server) : NULL;
+}
+
+static GSList*
+dee_server_get_connections (DeePeer *peer)
+{
+  DeeServerPrivate *priv = DEE_SERVER (peer)->priv;
+
+  return g_slist_copy (priv->active_connections);
+}
+

=== added file 'dee/dee-server.h'
--- dee/dee-server.h	1970-01-01 00:00:00 +0000
+++ dee/dee-server.h	2011-12-19 08:59:26 +0000
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2011 Canonical, Ltd.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License
+ * version 3.0 as published by the Free Software Foundation.
+ *
+ * This library 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 version 3.0 for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Michal Hruby <[e-mail]>
+ */
+
+#if !defined (_DEE_H_INSIDE) && !defined (DEE_COMPILATION)
+#error "Only <dee.h> can be included directly."
+#endif
+
+#ifndef _HAVE_DEE_SERVER_H
+#define _HAVE_DEE_SERVER_H
+
+#include <glib.h>
+#include <glib-object.h>
+#include "dee-peer.h"
+
+G_BEGIN_DECLS
+
+#define DEE_TYPE_SERVER dee_server_get_type()
+
+#define DEE_SERVER(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), DEE_TYPE_SERVER, DeeServer))
+
+#define DEE_SERVER_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), DEE_TYPE_SERVER, DeeServerClass))
+
+#define DEE_IS_SERVER(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DEE_TYPE_SERVER))
+
+#define DEE_IS_SERVER_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), DEE_TYPE_SERVER))
+
+#define DEE_SERVER_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), DEE_TYPE_SERVER, DeeServerClass))
+
+typedef struct _DeeServerPrivate DeeServerPrivate;
+
+typedef struct {
+  /*< private >*/
+  DeePeer parent;
+
+  DeeServerPrivate *priv;
+} DeeServer;
+
+typedef struct {
+  /*< private >*/
+  DeePeerClass parent_class;
+} DeeServerClass;
+
+/**
+ * dee_server_get_type:
+ *
+ * The GType of #DeeServer
+ *
+ * Return value: the #GType of #DeeServer
+ **/
+GType          dee_server_get_type            (void);
+
+DeeServer*     dee_server_new                 (const gchar *swarm_name);
+
+DeeServer*     dee_server_new_for_address     (const gchar* swarm_name,
+                                               const gchar* bus_address);
+
+const gchar*   dee_server_get_client_address  (DeeServer *server);
+
+G_END_DECLS
+
+#endif /* _HAVE_DEE_SERVER_H */
+

=== modified file 'dee/dee-shared-model.c'
--- dee/dee-shared-model.c	2011-11-22 15:27:36 +0000
+++ dee/dee-shared-model.c	2011-12-19 08:59:26 +0000
@@ -17,6 +17,7 @@
  * Authored by:
  *               Mikkel Kamstrup Erlandsen <[e-mail]>
  *               Neil Jagdish Patel <[e-mail]>
+ *               Michal Hruby <[e-mail]>
  */
 
 /**
@@ -80,19 +81,21 @@
  **/
 struct _DeeSharedModelPrivate
 {
-  DeePeer         *swarm;
-  GDBusConnection *connection;
-  gchar           *model_path;
+  DeePeer    *swarm;
+  GSList     *connections;
+  gchar      *model_path;
   
   /* Buffer of DeeSharedModelRevisions that we keep in order to batch
    * our DBus signals. The invariant is that all buffered revisions
    * are of the same type */
   GSList     *revision_queue;
   guint       revision_queue_timeout_id;
-  guint       dbus_signal_handler;
-  guint       model_registration_id;
+  guint       acquisition_timer_id;
   gulong      swarm_leader_handler;
-  
+  gulong      connection_acquired_handler;
+  gulong      connection_closed_handler;
+  GArray     *connection_infos;
+
   gboolean    synchronized;
   gboolean    found_first_peer;
   gboolean    suppress_remote_signals;
@@ -108,6 +111,12 @@
   DeeModel   *model;
 } DeeSharedModelRevision;
 
+typedef struct
+{
+  GDBusConnection *connection;
+  guint            signal_subscription_id;
+  guint            registration_id;
+} DeeConnectionInfo;
 /* Globals */
 static GQuark           dee_shared_model_error_quark       = 0;
 
@@ -138,9 +147,13 @@
 //static guint32 _signals[LAST_SIGNAL] = { 0 };
 
 /* Forwards */
-static void     on_bus_connection_acquired             (GObject      *source_object,
-                                                        GAsyncResult *res,
-                                                        gpointer      user_data);
+static void     on_connection_acquired                 (DeeSharedModel  *self,
+                                                        GDBusConnection *connection,
+                                                        DeePeer         *peer);
+
+static void     on_connection_closed                   (DeeSharedModel  *self,
+                                                        GDBusConnection *connection,
+                                                        DeePeer         *peer);
 
 static void     commit_transaction                     (DeeSharedModel *self,
                                                         const gchar    *sender_name,
@@ -192,7 +205,8 @@
 static void        reset_model                   (DeeModel       *self);
 
 static void        invalidate_peer               (DeeSharedModel  *self,
-                                                  const gchar     *sender_name);
+                                                  const gchar     *sender_name,
+                                                  GDBusConnection *except);
 
 static gboolean    on_invalidate                 (DeeSharedModel  *self);
 
@@ -263,7 +277,9 @@
   DeeSharedModelRevision *rev;
   GError                 *error;
   GSList                 *iter;
+  GSList                 *connection_iter;
   GVariant               *schema;
+  GVariant               *transaction_variant;
   GVariantBuilder         aav, au, ay, transaction;
   guint64                 seqnum_begin = 0, seqnum_end = 0;
   guint                   n_cols, i;
@@ -278,7 +294,7 @@
    *    we'll assume the programmer knows this
    * 2) We are resetting the model - no problem
    */
-  if (priv->connection == NULL)
+  if (priv->connections == NULL)
     {
       trace_object (self, "Flushing revision queue, without a connection. "
                           "This will blow up unless you are the leader model");
@@ -368,21 +384,27 @@
   g_variant_builder_add_value (&transaction,
                                g_variant_new ("(tt)", seqnum_begin, seqnum_end));
 
-  /* Throw a Commit signal on the bus */
-  error = NULL;
-  g_dbus_connection_emit_signal(priv->connection,
-                                NULL,
-                                priv->model_path,
-                                "com.canonical.Dee.Model",
-                                "Commit",
-                                g_variant_builder_end (&transaction),
-                                &error);
+  transaction_variant = g_variant_builder_end (&transaction);
 
-  if (error != NULL)
+  /* Throw a Commit signal */
+  for (connection_iter = priv->connections; connection_iter != NULL; 
+       connection_iter = connection_iter->next)
     {
-      g_critical ("Failed to emit DBus signal "
-                  "com.canonical.Dee.Model.Commit: %s", error->message);
-      g_error_free (error);
+      error = NULL;
+      g_dbus_connection_emit_signal((GDBusConnection*) connection_iter->data,
+                                    NULL,
+                                    priv->model_path,
+                                    "com.canonical.Dee.Model",
+                                    "Commit",
+                                    transaction_variant,
+                                    &error);
+
+      if (error != NULL)
+        {
+          g_critical ("Failed to emit DBus signal "
+                      "com.canonical.Dee.Model.Commit: %s", error->message);
+          g_error_free (error);
+        }
     }
 
   trace_object (self, "Flushed %"G_GUINT64_FORMAT" revisions. "
@@ -429,6 +451,7 @@
 static void
 dee_shared_model_finalize (GObject *object)
 {
+  guint i;
   DeeSharedModelPrivate *priv = DEE_SHARED_MODEL (object)->priv;
 
   /* Flush any pending revisions */
@@ -437,18 +460,40 @@
       flush_revision_queue (DEE_MODEL(object));
       priv->revision_queue = NULL;
     }
-  
-  if (priv->model_registration_id != 0 && priv->connection != NULL)
-    {
-      g_dbus_connection_unregister_object (priv->connection,
-                                           priv->model_registration_id);
-      priv->model_registration_id = 0;
-    }
-  if (priv->dbus_signal_handler != 0 && priv->connection != NULL)
-    {
-      g_dbus_connection_signal_unsubscribe(priv->connection,
-                                           priv->dbus_signal_handler);
-      priv->dbus_signal_handler = 0;
+
+  if (priv->acquisition_timer_id != 0)
+    {
+      g_source_remove (priv->acquisition_timer_id);
+      priv->acquisition_timer_id = 0;
+    }
+
+  if (priv->connection_acquired_handler)
+    {
+      g_signal_handler_disconnect (priv->swarm,
+                                   priv->connection_acquired_handler);
+      priv->connection_acquired_handler = 0;
+    }
+
+  if (priv->connection_closed_handler)
+    {
+      g_signal_handler_disconnect (priv->swarm, priv->connection_closed_handler);
+      priv->connection_closed_handler = 0;
+    }
+
+  if (priv->connection_infos != NULL)
+    {
+      for (i = 0; i < priv->connection_infos->len; i++)
+        {
+          DeeConnectionInfo *info;
+          info = &g_array_index (priv->connection_infos, DeeConnectionInfo, i);
+          g_dbus_connection_unregister_object (info->connection,
+                                               info->registration_id);
+          g_dbus_connection_signal_unsubscribe (info->connection,
+                                                info->signal_subscription_id);
+        }
+
+      g_array_unref (priv->connection_infos);
+      priv->connection_infos = NULL;
     }
   if (priv->swarm_leader_handler != 0)
     {
@@ -459,10 +504,10 @@
       {
         g_free (priv->model_path);
       }
-  if (priv->connection)
+  if (priv->connections)
     {
-      g_object_unref (priv->connection);
-      priv->connection = NULL;
+      g_slist_free (priv->connections);
+      priv->connections = NULL;
     }
   if (priv->swarm)
     {
@@ -515,23 +560,49 @@
       g_value_set_object (value, priv->swarm);
       break;
     case PROP_SYNCHRONIZED:
-          g_value_set_boolean (value, priv->synchronized);
-          break;
+      g_value_set_boolean (value, priv->synchronized);
+      break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, id, pspec);
       break;
   }
 }
 
+static gboolean
+iterate_connections (DeeSharedModel *self)
+{
+  DeeSharedModelPrivate *priv;
+  GSList                *iter;
+
+  g_return_val_if_fail (DEE_IS_SHARED_MODEL (self), FALSE);
+  priv = self->priv;
+
+  priv->connections = dee_peer_get_connections (priv->swarm);
+
+  for (iter = priv->connections; iter != NULL; iter = iter->next)
+    {
+      on_connection_acquired (self, (GDBusConnection*) iter->data, priv->swarm);
+    }
+
+  priv->acquisition_timer_id = 0;
+
+  return FALSE;
+}
+
 static void
-dee_shared_model_constructed (GObject *self)
+dee_shared_model_constructed (GObject *object)
 {
-  DeeSharedModel        *_self;
+  DeeSharedModel        *self;
   DeeSharedModelPrivate *priv;
   gchar                 *dummy;
 
-  _self = DEE_SHARED_MODEL (self);
-  priv = _self->priv;
+  /* GObjectClass has NULL 'constructed' member, but we add this check for
+   * future robustness if we ever move to another base class */
+  if (G_OBJECT_CLASS (dee_shared_model_parent_class)->constructed != NULL)
+    G_OBJECT_CLASS (dee_shared_model_parent_class)->constructed (object);
+
+  self = DEE_SHARED_MODEL (object);
+  priv = self->priv;
 
   if (priv->swarm == NULL)
     {
@@ -546,21 +617,24 @@
                                     NULL);
   g_free (dummy);
 
-  priv->swarm_leader_handler = g_signal_connect_swapped(priv->swarm,
-                                                        "notify::swarm-leader",
-                                                        G_CALLBACK (on_leader_changed),
-                                                        self);
-
-  /* Connect asynchronously to the bus */
-  g_bus_get (G_BUS_TYPE_SESSION,
-             NULL,
-             on_bus_connection_acquired,
-             g_object_ref (self)); // ref to stay alive during async call
-
-  /* GObjectClass has NULL 'constructed' member, but we add this check for
-   * future robustness if we ever move to another base class */
-  if (G_OBJECT_CLASS (dee_shared_model_parent_class)->constructed != NULL)
-    G_OBJECT_CLASS (dee_shared_model_parent_class)->constructed (self);
+  priv->swarm_leader_handler =
+    g_signal_connect_swapped (priv->swarm, "notify::swarm-leader",
+                              G_CALLBACK (on_leader_changed), self);
+
+  priv->connection_acquired_handler =
+    g_signal_connect_swapped (priv->swarm, "connection-acquired",
+                              G_CALLBACK (on_connection_acquired), self);
+
+  priv->connection_closed_handler =
+    g_signal_connect_swapped (priv->swarm, "connection-closed",
+                              G_CALLBACK (on_connection_closed), self);
+
+  /* we don't want to invoke on_connection_acquired from here, it would mean
+   * emitting important signal when inside g_object_new */
+  /* using G_PRIORITY_DEFAULT will ensure that this will be dispatched before
+   * we'll have a chance to acquire new connections... FIXME: right? */
+  priv->acquisition_timer_id = g_idle_add_full (G_PRIORITY_DEFAULT,
+      (GSourceFunc) iterate_connections, self, NULL);
 }
 
 static void
@@ -612,14 +686,11 @@
 
   priv = self->priv = DEE_SHARED_MODEL_GET_PRIVATE (self);
 
-  priv->synchronized = FALSE;
   priv->swarm = NULL;
   priv->model_path = NULL;
 
   priv->revision_queue = NULL;
   priv->revision_queue_timeout_id = 0;
-  priv->dbus_signal_handler = 0;
-  priv->model_registration_id = 0;
   priv->swarm_leader_handler = 0;
 
   priv->synchronized = FALSE;
@@ -629,7 +700,8 @@
   if (!dee_shared_model_error_quark)
     dee_shared_model_error_quark = g_quark_from_string ("dbus-model-error");
 
-  priv->connection = NULL;
+  priv->connections = NULL;
+  priv->connection_infos = g_array_new (FALSE, TRUE, sizeof (DeeConnectionInfo));
   
   /* Connect to our own signals so we can queue up revisions to be emitted
    * on the bus */
@@ -689,51 +761,38 @@
 };
 
 static void
-on_bus_connection_acquired (GObject      *source_object,
-                            GAsyncResult *res,
-                            gpointer      user_data)
+on_connection_acquired (DeeSharedModel *self,
+                        GDBusConnection *connection,
+                        DeePeer *peer)
 {
-  DeeSharedModel        *self;
   DeeSharedModelPrivate *priv;
-  GError                *error;
+  DeeConnectionInfo      connection_info;
   GDBusNodeInfo         *model_introspection_data;
+  guint                  dbus_signal_handler;
+  guint                  model_registration_id;
 
   /* Keep the parsed introspection data of the Model interface around */
   static GDBusInterfaceInfo *model_interface_info = NULL;
 
-  g_return_if_fail (DEE_IS_SHARED_MODEL (user_data));
+  g_return_if_fail (DEE_IS_SHARED_MODEL (self));
 
-  self = DEE_SHARED_MODEL (user_data);
   priv = self->priv;
 
-  if (priv->connection)
-    {
-      g_critical ("Internal error in DeeSharedModel. "
-                  "DBus connection acquired twice.");
-
-      /* We don't know whether or not to g_object_unref(self) at this point
-       * since the internal state is messed up. We don't do the unref to try
-       * and avoid double freeing self */
-
-      return;
-    }
-
-  error = NULL;
-  priv->connection = g_bus_get_finish (res, &error);
-
-  if (error != NULL)
-    {
-      g_critical ("DeeSharedModel@%p failed to connect to session bus: %s",
-                  self, error->message);
-      g_error_free (error);
-      g_object_unref (self); // held during async call
-      return;
-    }
+  if (connection == NULL)
+    {
+      g_warning ("Internal error in DeeSharedModel. %s called with NULL "
+                 "connection", __func__);
+      return;
+    }
+
+  /* Update our list of connections */
+  if (priv->connections) g_slist_free (priv->connections);
+  priv->connections = dee_peer_get_connections (priv->swarm);
 
   /* Listen for changes from the peers in the same swarm.
    * We do this by matching arg0 with the swarm name */
-  priv->dbus_signal_handler = g_dbus_connection_signal_subscribe (
-                                         priv->connection,
+  dbus_signal_handler = g_dbus_connection_signal_subscribe (
+                                         connection,
                                          NULL,                // sender
                                          "com.canonical.Dee.Model", // iface
                                          NULL,                // member
@@ -758,8 +817,8 @@
     }
 
   /* Export the model on the bus */
-  priv->model_registration_id =
-      g_dbus_connection_register_object (priv->connection,
+  model_registration_id =
+      g_dbus_connection_register_object (connection,
                                          priv->model_path, /* object path */
                                          model_interface_info,
                                          &model_interface_vtable,
@@ -767,12 +826,17 @@
                                          NULL,  /* user_data_free_func */
                                          NULL); /* GError** */
 
+  connection_info.connection = connection;
+  connection_info.signal_subscription_id = dbus_signal_handler;
+  connection_info.registration_id = model_registration_id;
+  g_array_append_val (priv->connection_infos, connection_info);
+
   /* If we are swarm leaders and we have column type info we are ready by now.
    * Otherwise we will be ready when we receive the model clone from the leader
    */
   if (dee_peer_is_swarm_leader (priv->swarm))
     {
-      if (dee_model_get_n_columns (DEE_MODEL (self)) > 0)
+      if (dee_model_get_n_columns (DEE_MODEL (self)) > 0 && !priv->synchronized)
         {
           priv->synchronized = TRUE;
           g_object_notify (G_OBJECT (self), "synchronized");
@@ -789,8 +853,40 @@
     {
       // FIXME: There's no known leader
     }
-
-  g_object_unref (self); // held self-ref during async call
+}
+
+static void
+on_connection_closed (DeeSharedModel  *self,
+                      GDBusConnection *connection,
+                      DeePeer         *peer)
+{
+  DeeSharedModelPrivate *priv;
+  guint i;
+
+  g_return_if_fail (DEE_IS_SHARED_MODEL (self));
+
+  priv = self->priv;
+
+  /* Update our list of connections */
+  if (priv->connections) g_slist_free (priv->connections);
+  priv->connections = dee_peer_get_connections (priv->swarm);
+
+  /* Disconnect signals etc */
+  for (i = 0; i < priv->connection_infos->len; i++)
+    {
+      DeeConnectionInfo *info;
+      info = &g_array_index (priv->connection_infos, DeeConnectionInfo, i);
+      if (info->connection == connection)
+        {
+          g_dbus_connection_unregister_object (info->connection,
+                                               info->registration_id);
+          g_dbus_connection_signal_unsubscribe (info->connection,
+                                                info->signal_subscription_id);
+          /* remove the item */
+          g_array_remove_index (priv->connection_infos, i);
+          break;
+        }
+    }
 }
 
 /* Callback for clone_leader() */
@@ -811,7 +907,7 @@
   priv = self->priv;
 
   error = NULL;
-  transaction = g_dbus_connection_call_finish (G_DBUS_CONNECTION(source_object),
+  transaction = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
                                                res, &error);
 
   if (error != NULL)
@@ -859,10 +955,10 @@
 clone_leader (DeeSharedModel *self)
 {
   DeeSharedModelPrivate *priv;
+  GSList                *iter;
 
   g_return_if_fail (DEE_IS_SHARED_MODEL (self));
   g_return_if_fail (dee_peer_get_swarm_leader (self->priv->swarm) != NULL);
-  g_return_if_fail (self->priv->connection != NULL);
   g_return_if_fail (self->priv->revision_queue == NULL);
   g_return_if_fail (dee_model_get_n_rows (DEE_MODEL (self)) == 0);
 
@@ -871,18 +967,23 @@
   trace_object (self, "Cloning leader '%s'",
                 dee_shared_model_get_swarm_name (self));
 
-  g_dbus_connection_call(priv->connection,
-                         dee_shared_model_get_swarm_name (self), // name
-                         priv->model_path,                       // obj path
-                         "com.canonical.Dee.Model",              // iface
-                         "Clone",                                // member
-                         NULL,                                   // args
-                         G_VARIANT_TYPE ("(sasaavauay(tt))"),    // ret type
-                         G_DBUS_CALL_FLAGS_NONE,
-                         -1,                                     // timeout
-                         NULL,                                   // cancel
-                         on_clone_received,                      // cb
-                         g_object_ref (self));                   // userdata
+  /* This shouldn't really happen when we have multiple connections, but let's
+   * have it here for consistency */
+  for (iter = priv->connections; iter != NULL; iter = iter->next)
+    {
+      g_dbus_connection_call((GDBusConnection*) iter->data,
+                             dee_shared_model_get_swarm_name (self), // name
+                             priv->model_path,                       // obj path
+                             "com.canonical.Dee.Model",              // iface
+                             "Clone",                                // member
+                             NULL,                                   // args
+                             G_VARIANT_TYPE ("(sasaavauay(tt))"),    // ret type
+                             G_DBUS_CALL_FLAGS_NONE,
+                             -1,                                     // timeout
+                             NULL,                                   // cancel
+                             on_clone_received,                      // cb
+                             g_object_ref (self));                   // userdata
+    }
 }
 
 static void
@@ -894,20 +995,33 @@
                          GVariant        *parameters,
                          gpointer         user_data)
 {
+  DeeSharedModel *model;
+  const gchar    *unique_name;
+
   g_return_if_fail (DEE_IS_SHARED_MODEL (user_data));
 
+  unique_name = g_dbus_connection_get_unique_name (connection);
+
+  trace_object (user_data, "%s: sender: %s, our unique_name: %s",
+      __func__, sender_name, unique_name);
+
   /* Ignore signals from our selves. We may get those because of the way
    * we set up the match rules */
-  if (g_strcmp0 (sender_name,
+  if (unique_name != NULL && g_strcmp0 (sender_name,
                  g_dbus_connection_get_unique_name (connection)) == 0)
     return;
 
-
   if (g_strcmp0 (signal_name, "Commit") == 0)
     {
-      commit_transaction (DEE_SHARED_MODEL (user_data),
-                          sender_name,
-                          parameters);
+      model = DEE_SHARED_MODEL (user_data);
+      commit_transaction (model, sender_name, parameters);
+
+      if (g_slist_length (model->priv->connections) > 1)
+      {
+        /* this is a server and a client (non-leader) just committed a change
+         * to the model, let's invalidate all other clients */
+        invalidate_peer (model, sender_name, connection);
+      }
     }
   else
     g_warning ("Unexpected signal %s.%s from %s",
@@ -959,7 +1073,6 @@
   gint                   i, j;
 
   g_return_if_fail (DEE_IS_SHARED_MODEL (self));
-  g_return_if_fail (sender_name != NULL);
   g_return_if_fail (transaction != NULL);
 
   g_variant_ref_sink (transaction);
@@ -1036,7 +1149,7 @@
       if (dee_shared_model_is_leader (self))
         {
           g_warning ("Invalidating %s", sender_name);
-          invalidate_peer (self, sender_name);
+          invalidate_peer (self, sender_name, NULL);
         }
 
       g_variant_unref (transaction);
@@ -1245,12 +1358,13 @@
 /* Call DBus method com.canonical.Dee.Model.Invalidate() on @sender_name */
 static void
 invalidate_peer (DeeSharedModel  *self,
-                 const gchar     *sender_name)
+                 const gchar     *sender_name,
+                 GDBusConnection *except)
 {
   DeeSharedModelPrivate *priv;
+  GSList                *iter;
 
   g_return_if_fail (DEE_IS_SHARED_MODEL (self));
-  g_return_if_fail (sender_name != NULL);
 
   if (!dee_shared_model_is_leader (self))
     {
@@ -1261,18 +1375,23 @@
 
   priv = self->priv;
 
-  g_dbus_connection_call (priv->connection,
-                          sender_name,
-                          priv->model_path,
-                          "com.canonical.Dee.Model",
-                          "Invalidate",
-                          NULL,                      /* params */
-                          NULL,                      /* reply type */
-                          G_DBUS_CALL_FLAGS_NONE,
-                          -1,                        /* timeout */
-                          NULL,                      /* cancel */
-                          NULL,                      /* cb */
-                          NULL);                     /* user data */
+  // invalidate peers on all connections
+  for (iter = priv->connections; iter != NULL; iter = iter->next)
+    {
+      if (iter->data == except) continue;
+      g_dbus_connection_call ((GDBusConnection*) iter->data,
+                              sender_name,
+                              priv->model_path,
+                              "com.canonical.Dee.Model",
+                              "Invalidate",
+                              NULL,                      /* params */
+                              NULL,                      /* reply type */
+                              G_DBUS_CALL_FLAGS_NONE,
+                              -1,                        /* timeout */
+                              NULL,                      /* cancel */
+                              NULL,                      /* cb */
+                              NULL);                     /* user data */
+    }
 }
 
 /* Public Methods */
@@ -1309,6 +1428,44 @@
 }
 
 /**
+ * dee_shared_model_new_for_peer:
+ * @peer: (transfer full): A #DeePeer instance.
+ *
+ * Create a new empty shared model without any column schema associated.
+ * The column schema will be set in one of two ways: firstly you may set it
+ * manually with dee_model_set_schema() or secondly it will be set once
+ * the first rows are exchanged with a peer model.
+ * 
+ * A #DeeSharedModel with a schema manually set has to be created before
+ * creating more #DeeSharedModel with the same @name.
+ *
+ * A shared model created with this constructor will store row data in a
+ * suitably picked memory backed model.
+ *
+ * Return value: (transfer full) (type DeeSharedModel): a new #DeeSharedModel
+ */
+DeeModel*
+dee_shared_model_new_for_peer (DeePeer *peer)
+{
+  DeeModel *self;
+  DeeModel *back_end;
+
+  g_return_val_if_fail (peer != NULL, NULL);
+
+  back_end = (DeeModel*) dee_sequence_model_new ();
+
+  self = g_object_new (DEE_TYPE_SHARED_MODEL,
+                       "back-end", back_end,
+                       "peer", peer,
+                       NULL);
+
+  g_object_unref (back_end);
+  g_object_unref (peer);
+
+  return self;
+}
+
+/**
  * dee_shared_model_new_with_back_end:
  * @name: (transfer none): A well known name to publish this model under.
  *        Models sharing this name will synchronize with each other
@@ -1318,8 +1475,8 @@
  *
  * Create a new shared model storing all data in @back_end.
  *
- * In order to start synchronizing the new model with peer models you must call
- * dee_shared_model_connect() on it.
+ * The model will start synchronizing with peer models as soon as possible and
+ * the #DeeSharedModel:synchronized property will be set once finished.
  *
  * Return value: (transfer full) (type DeeSharedModel): a new #DeeSharedModel
  */
@@ -1460,6 +1617,7 @@
 {
   DeeSharedModelPrivate *priv;
   GError                *error;
+  GSList                *iter;
   guint                  n_revisions;
 
   g_return_val_if_fail (DEE_IS_SHARED_MODEL (self), 0);
@@ -1467,14 +1625,18 @@
   priv = self->priv;
   n_revisions = flush_revision_queue (DEE_MODEL (self));
 
-  error = NULL;
-  g_dbus_connection_flush_sync (priv->connection, NULL, &error);
-  if (error)
+  for (iter = priv->connections; iter != NULL; iter = iter->next)
     {
-      g_critical ("Error when flushing %u revisions of %s@%p: %s",
-                  n_revisions, G_OBJECT_TYPE_NAME (self), self, error->message);
-      g_error_free (error);
-      return 0;
+      error = NULL;
+      g_dbus_connection_flush_sync ((GDBusConnection*) iter->data, NULL, &error);
+      if (error)
+        {
+          g_critical ("Error when flushing %u revisions of %s@%p: %s",
+                      n_revisions, G_OBJECT_TYPE_NAME (self), self,
+                      error->message);
+          g_error_free (error);
+          return 0;
+        }
     }
 
   return n_revisions;

=== modified file 'dee/dee-shared-model.h'
--- dee/dee-shared-model.h	2011-03-06 09:42:20 +0000
+++ dee/dee-shared-model.h	2011-12-19 08:59:26 +0000
@@ -104,6 +104,8 @@
 
 DeeModel*             dee_shared_model_new             (const gchar *name);
 
+DeeModel*             dee_shared_model_new_for_peer    (DeePeer *peer);
+
 DeeModel*             dee_shared_model_new_with_back_end (const gchar *name,
                                                           DeeModel *back_end);
 

=== modified file 'dee/dee.h'
--- dee/dee.h	2011-12-15 12:28:43 +0000
+++ dee/dee.h	2011-12-19 08:59:26 +0000
@@ -30,6 +30,8 @@
 #define _DEE_H_INSIDE
 
 #include <dee-peer.h>
+#include <dee-server.h>
+#include <dee-client.h>
 #include <dee-model.h>
 #include <dee-model-reader.h>
 #include <dee-serializable-model.h>

=== modified file 'doc/reference/dee-1.0/dee-1.0-docs.sgml'
--- doc/reference/dee-1.0/dee-1.0-docs.sgml	2011-12-14 14:44:58 +0000
+++ doc/reference/dee-1.0/dee-1.0-docs.sgml	2011-12-19 08:59:26 +0000
@@ -12,6 +12,8 @@
   <chapter>
     <title>Peer Discovery</title>
       <xi:include href="xml/dee-peer.xml"/>
+      <xi:include href="xml/dee-server.xml"/>
+      <xi:include href="xml/dee-client.xml"/>
   </chapter>
 
   <chapter>

=== modified file 'doc/reference/dee-1.0/dee-1.0.types'
--- doc/reference/dee-1.0/dee-1.0.types	2011-11-02 14:05:47 +0000
+++ doc/reference/dee-1.0/dee-1.0.types	2011-12-19 08:59:26 +0000
@@ -1,18 +1,21 @@
+dee_analyzer_get_type
+dee_client_get_type
+dee_file_resource_manager_get_type
+dee_filter_model_get_type
+dee_glist_result_set_get_type
+dee_hash_index_get_type
+dee_index_get_type
+dee_model_get_type
 dee_peer_get_type
-dee_model_get_type
-dee_serializable_model_get_type
 dee_proxy_model_get_type
+dee_resource_manager_get_type
+dee_result_set_get_type
 dee_sequence_model_get_type
+dee_serializable_get_type
+dee_serializable_model_get_type
+dee_server_get_type
 dee_shared_model_get_type
 dee_term_list_get_type
-dee_result_set_get_type
-dee_analyzer_get_type
 dee_text_analyzer_get_type
-dee_index_get_type
-dee_hash_index_get_type
+dee_transaction_get_type
 dee_tree_index_get_type
-dee_filter_model_get_type
-dee_serializable_get_type
-dee_resource_manager_get_type
-dee_file_resource_manager_get_type
-

=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2011-12-13 13:49:08 +0000
+++ tests/Makefile.am	2011-12-19 08:59:26 +0000
@@ -48,6 +48,8 @@
 if HAVE_GTX
 test_dee_SOURCES += test-model-interactions.c
 test_dee_SOURCES += test-peer-interactions.c
+test_dee_SOURCES += test-client-server.c
+
 AM_CPPFLAGS += $(GTX_CFLAGS)
 test_dee_LDADD += $(GTX_LIBS)
 
@@ -67,9 +69,13 @@
   peer-helper-1peer.c \
   $(NULL)
 
+server_helpers = \
+  server-helper-client.c
+
 noinst_PROGRAMS += \
   $(model_helpers:.c=) \
   $(peer_helpers:.c=) \
+  $(server_helpers:.c=) \
   $(NULL)
 
 model_helper_clone3rows_SOURCES = model-helper-clone3rows.c
@@ -102,6 +108,9 @@
 peer_helper_1peer_SOURCES = peer-helper-1peer.c
 peer_helper_1peer_LDADD = $(test_dee_LDADD)
 
+server_helper_client_SOURCES = server-helper-client.c
+server_helper_client_LDADD = $(test_dee_LDADD)
+
 endif # HAVE_GTX
 
 #

=== modified file 'tests/model-helper-add3rows.c'
--- tests/model-helper-add3rows.c	2011-11-30 10:19:23 +0000
+++ tests/model-helper-add3rows.c	2011-12-19 08:59:26 +0000
@@ -43,7 +43,11 @@
   g_type_init (); 
   g_thread_init (NULL);
 
-  model = dee_shared_model_new (argv[1]);
+  if (argc == 2)
+    model = dee_shared_model_new (argv[1]);
+  else
+    model = dee_shared_model_new_for_peer ((DeePeer*) dee_client_new (argv[1]));
+
 
   /* Wait until we find the leader */
   if (gtx_wait_for_signal (G_OBJECT (model), 1000, "notify::synchronized", NULL))

=== modified file 'tests/model-helper-change3rows.c'
--- tests/model-helper-change3rows.c	2011-11-30 10:19:23 +0000
+++ tests/model-helper-change3rows.c	2011-12-19 08:59:26 +0000
@@ -42,7 +42,11 @@
   
   g_type_init (); 
 
-  model = dee_shared_model_new (argv[1]);
+  if (argc == 2)
+    model = dee_shared_model_new (argv[1]);
+  else
+    model = dee_shared_model_new_for_peer ((DeePeer*) dee_client_new (argv[1]));
+
   
   if (gtx_wait_for_signal (G_OBJECT (model), 1000, "notify::synchronized", NULL))
     g_error ("Helper model timed out waiting for 'ready' signal");

=== modified file 'tests/model-helper-clear3add5.c'
--- tests/model-helper-clear3add5.c	2011-11-30 10:19:23 +0000
+++ tests/model-helper-clear3add5.c	2011-12-19 08:59:26 +0000
@@ -42,7 +42,11 @@
   g_type_init (); 
   g_thread_init (NULL);
 
-  model = dee_shared_model_new (argv[1]);
+  if (argc == 2)
+    model = dee_shared_model_new (argv[1]);
+  else
+    model = dee_shared_model_new_for_peer ((DeePeer*) dee_client_new (argv[1]));
+
   
   if (gtx_wait_for_signal (G_OBJECT (model), 100000, "notify::synchronized", NULL))
     g_error ("Helper model timed out waiting for 'ready' signal");

=== modified file 'tests/model-helper-clear3rows.c'
--- tests/model-helper-clear3rows.c	2011-11-30 10:19:23 +0000
+++ tests/model-helper-clear3rows.c	2011-12-19 08:59:26 +0000
@@ -42,7 +42,11 @@
   g_type_init (); 
   g_thread_init (NULL);
 
-  model = dee_shared_model_new (argv[1]);
+  if (argc == 2)
+    model = dee_shared_model_new (argv[1]);
+  else
+    model = dee_shared_model_new_for_peer ((DeePeer*) dee_client_new (argv[1]));
+
   
   if (gtx_wait_for_signal (G_OBJECT (model), 100000, "notify::synchronized", NULL))
     g_error ("Helper model timed out waiting for 'ready' signal");

=== modified file 'tests/model-helper-clone3rows.c'
--- tests/model-helper-clone3rows.c	2011-11-30 10:19:23 +0000
+++ tests/model-helper-clone3rows.c	2011-12-19 08:59:26 +0000
@@ -35,7 +35,12 @@
   g_type_init (); 
   g_thread_init (NULL);
 
-  model = dee_shared_model_new (argv[1]);
+  g_set_prgname ("model-helper");
+
+  if (argc == 2)
+    model = dee_shared_model_new (argv[1]);
+  else
+    model = dee_shared_model_new_for_peer ((DeePeer*) dee_client_new (argv[1]));
   
   if (gtx_wait_for_signal (G_OBJECT (model), 100000, "notify::synchronized", NULL))
     g_error ("Helper model timed out waiting for 'ready' signal");

=== modified file 'tests/model-helper-insert1row.c'
--- tests/model-helper-insert1row.c	2011-11-30 10:19:23 +0000
+++ tests/model-helper-insert1row.c	2011-12-19 08:59:26 +0000
@@ -43,7 +43,11 @@
   g_type_init (); 
   g_thread_init (NULL);
 
-  model = dee_shared_model_new (argv[1]);
+  if (argc == 2)
+    model = dee_shared_model_new (argv[1]);
+  else
+    model = dee_shared_model_new_for_peer ((DeePeer*) dee_client_new (argv[1]));
+
 
   /* Wait until we find the leader */
   if (gtx_wait_for_signal (G_OBJECT (model), 1000, "notify::synchronized", NULL))

=== modified file 'tests/model-helper-remove3rows.c'
--- tests/model-helper-remove3rows.c	2011-11-30 10:19:23 +0000
+++ tests/model-helper-remove3rows.c	2011-12-19 08:59:26 +0000
@@ -53,7 +53,11 @@
   
   g_type_init (); 
 
-  model = dee_shared_model_new (argv[1]);
+  if (argc == 2)
+    model = dee_shared_model_new (argv[1]);
+  else
+    model = dee_shared_model_new_for_peer ((DeePeer*) dee_client_new (argv[1]));
+
 
   if (gtx_wait_for_signal (G_OBJECT (model), 1000, "notify::synchronized", NULL))
     g_error ("Helper model timed out waiting for 'ready' signal");

=== modified file 'tests/model-helper-schemaless.c'
--- tests/model-helper-schemaless.c	2011-11-30 10:19:23 +0000
+++ tests/model-helper-schemaless.c	2011-12-19 08:59:26 +0000
@@ -35,7 +35,10 @@
   g_type_init (); 
   g_thread_init (NULL);
 
-  model = dee_shared_model_new (argv[1]);
+  if (argc == 2)
+    model = dee_shared_model_new (argv[1]);
+  else
+    model = dee_shared_model_new_for_peer ((DeePeer*) dee_client_new (argv[1]));
   
   /* Important: In this test it's the *slave* that sets the schema,
    *            the leader is schemaless at this point in time, and will

=== added file 'tests/server-helper-client.c'
--- tests/server-helper-client.c	1970-01-01 00:00:00 +0000
+++ tests/server-helper-client.c	2011-12-19 08:59:26 +0000
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2011 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
+ *              Michal Hruby <[e-mail]>
+ *
+ */
+
+#include "config.h"
+#include <glib.h>
+#include <glib-object.h>
+#include <stdlib.h>
+
+#include <gtx.h>
+#include <dee.h>
+
+static void
+on_peer_found (DeePeer *peer, gchar *name, gint *n_peers)
+{
+  (*n_peers)++;
+}
+
+static void
+on_peer_lost (DeePeer *peer, gchar *name, gint *n_peers)
+{
+  (*n_peers)++;
+}
+
+static int
+peer_function (gchar *argv[])
+{
+  DeePeer      *peer;
+  gint          n_peers = 0;
+
+  peer = (DeePeer*) dee_client_new (argv[1]);
+  
+  g_signal_connect (peer, "peer-found", G_CALLBACK (on_peer_found), &n_peers);
+  g_signal_connect (peer, "peer-lost", G_CALLBACK (on_peer_lost), &n_peers);
+
+  if (gtx_wait_for_signal (G_OBJECT (peer), 10000, "notify::swarm-leader", NULL))
+    g_error ("Peer helper timed out waiting for swarm leader");
+
+  /* The main process should be swarm leaders. Not us */
+  g_assert_cmpint (0, ==, dee_peer_is_swarm_leader (peer));
+
+  /* At this point we shouldn't have emitted 'peer-found' yet */
+  g_assert_cmpint (0, ==, n_peers);
+
+  if (gtx_wait_for_signal (G_OBJECT (peer), 10000, "peer-found", NULL))
+      g_error ("Peer helper timed out waiting for 'peer-found' signal");
+
+  g_assert_cmpint (1, ==, n_peers);
+
+  gtx_assert_last_unref (peer);
+  
+  return 0;
+}
+
+static gint finished_children = 0;
+static void
+child_exited (GPid pid, gint status, gpointer user_data)
+{
+  finished_children++;
+}
+
+gint
+main (gint argc, gchar *argv[])
+{
+  int num_clients, i;
+  
+  g_type_init ();
+  g_thread_init (NULL);
+
+  if (argc < 3) g_error ("Invalid invocation");
+
+  num_clients = i = atoi (argv[2]);
+  while (i-- > 0)
+    {
+      GPid pid = (GPid) fork ();
+      if (pid != 0) g_child_watch_add (pid, child_exited, NULL);
+      else 
+      {
+        return peer_function (argv);
+      }
+    }
+
+  for (i = 0; i < 10; i++)
+  {
+    gtx_yield_main_loop (200);
+    if (finished_children == num_clients) break;
+  }
+
+  g_assert_cmpint (num_clients, ==, finished_children);
+
+  return 0;
+}

=== added file 'tests/test-client-server.c'
--- tests/test-client-server.c	1970-01-01 00:00:00 +0000
+++ tests/test-client-server.c	2011-12-19 08:59:26 +0000
@@ -0,0 +1,644 @@
+/*
+ * Copyright (C) 2011 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 Michal Hruby <[e-mail]>
+ *
+ */
+
+#include <glib.h>
+#include <glib-object.h>
+#include <dee.h>
+#include <gtx.h>
+
+#define TIMEOUT 100
+#define PEER_NAME "com.canonical.Dee.Peer.Tests.Interactions"
+#define MODEL_NAME "com.canonical.Dee.Peer.Tests.Interactions"
+
+/* A command line that launches the appropriate *-helper-* executable,
+ * giving $name as first argument */
+#define SERVER_HELPER(helper,name,count) \
+  (gchar *[]) { "./server-helper-"#helper, name, #count, NULL }
+
+#define MODEL_HELPER(helper,name) \
+  (gchar *[]) { "./model-helper-"#helper, name, "DeeClient", NULL }
+
+typedef struct
+{
+  DeeServer *server;
+
+} ServerFixture;
+
+typedef struct
+{
+  DeeModel *model;
+} Fixture;
+
+static void server_setup         (ServerFixture *fix, gconstpointer data);
+static void server_teardown      (ServerFixture *fix, gconstpointer data);
+static void model_setup          (Fixture *fix, gconstpointer data);
+static void model_teardown       (Fixture *fix, gconstpointer data);
+static void model_setup_null     (Fixture *fix, gconstpointer data);
+static void model_teardown_null  (Fixture *fix, gconstpointer data);
+
+static void test_allocation           (ServerFixture *fix, gconstpointer data);
+static void test_become_leader        (ServerFixture *fix, gconstpointer data);
+static void test_valid_client_address (ServerFixture *fix, gconstpointer data);
+static void test_one_client           (ServerFixture *fix, gconstpointer data);
+static void test_multiple_clients     (ServerFixture *fix, gconstpointer data);
+
+static void test_ready          (Fixture *fix, gconstpointer data);
+static void test_clone          (Fixture *fix, gconstpointer data);
+static void test_row_added      (Fixture *fix, gconstpointer data);
+static void test_row_changed    (Fixture *fix, gconstpointer data);
+static void test_row_removed    (Fixture *fix, gconstpointer data);
+static void test_model_clear    (Fixture *fix, gconstpointer data);
+static void test_clear_add      (Fixture *fix, gconstpointer data);
+static void test_clear_then_add (Fixture *fix, gconstpointer data);
+static void test_row_inserted   (Fixture *fix, gconstpointer data);
+static void test_schemaless_leader (Fixture *fix, gconstpointer data);
+
+static void test_client_commit  (Fixture *fix, gconstpointer data);
+
+void
+test_client_server_interactions_create_suite (void)
+{
+#define DOMAIN "/ClientServer/Interactions"
+
+  g_test_add (DOMAIN"/Allocation", ServerFixture, 0,
+              server_setup, test_allocation, server_teardown);
+  g_test_add (DOMAIN"/BecomeLeader", ServerFixture, 0,
+              server_setup, test_become_leader, server_teardown);
+  g_test_add (DOMAIN"/ValidClientAddress", ServerFixture, 0,
+              server_setup, test_valid_client_address, server_teardown);
+  g_test_add (DOMAIN"/OneClient", ServerFixture, 0,
+              server_setup, test_one_client, server_teardown);
+  g_test_add (DOMAIN"/MultipleClients", ServerFixture, 0,
+              server_setup, test_multiple_clients, server_teardown);
+
+#undef DOMAIN
+#define DOMAIN "/ClientServer/Model/Interactions"
+
+  g_test_add (DOMAIN"/Ready", Fixture, 0,
+              model_setup, test_ready, model_teardown);
+  g_test_add (DOMAIN"/Clone", Fixture, 0,
+              model_setup, test_clone, model_teardown);
+  g_test_add (DOMAIN"/RowAdded", Fixture, 0,
+              model_setup, test_row_added, model_teardown);
+  g_test_add (DOMAIN"/RowChanged", Fixture, 0,
+              model_setup, test_row_changed, model_teardown);
+  g_test_add (DOMAIN"/RowRemoved", Fixture, 0,
+              model_setup, test_row_removed, model_teardown);
+  g_test_add (DOMAIN"/Clear", Fixture, 0,
+              model_setup, test_model_clear, model_teardown);
+  g_test_add (DOMAIN"/ClearAndAdd", Fixture, 0,
+              model_setup, test_clear_add, model_teardown);
+  g_test_add (DOMAIN"/ClearThenAdd", Fixture, 0,
+              model_setup, test_clear_then_add, model_teardown);
+  g_test_add (DOMAIN"/RowInserted", Fixture, 0,
+              model_setup, test_row_inserted, model_teardown);
+  g_test_add (DOMAIN"/SchemalessLeader", Fixture, 0,
+              model_setup_null, test_schemaless_leader, model_teardown_null);
+  g_test_add (DOMAIN"/ClientCommit", Fixture, 0,
+              model_setup, test_client_commit, model_teardown);
+}
+
+static void
+server_setup (ServerFixture *fix, gconstpointer data)
+{
+  fix->server = dee_server_new (PEER_NAME);
+
+  g_assert_cmpint (0, ==, dee_peer_is_swarm_leader (DEE_PEER (fix->server)));
+
+  g_assert (DEE_IS_SERVER (fix->server));
+}
+
+static void
+server_teardown (ServerFixture *fix, gconstpointer data)
+{
+  gtx_assert_last_unref (fix->server);
+
+  /* Spin the mainloop a bit to check if we have any post-test
+   * async effect crashing us */
+  gtx_yield_main_loop (200);
+}
+
+static void
+model_setup (Fixture *fix, gconstpointer data)
+{
+  DeeServer *server = dee_server_new (MODEL_NAME);
+
+  fix->model = (DeeModel*) dee_shared_model_new_for_peer (DEE_PEER (server));
+  dee_model_set_schema (fix->model, "i", "s", NULL);
+
+  g_assert (DEE_IS_MODEL (fix->model));
+}
+
+static void
+model_teardown (Fixture *fix, gconstpointer data)
+{
+  gtx_assert_last_unref (fix->model);
+
+  /* Spin the mainloop so the socket service gets into usable state again */
+  gtx_yield_main_loop (200);
+}
+
+static void
+model_setup_null (Fixture *fix, gconstpointer data)
+{
+}
+
+static void
+model_teardown_null (Fixture *fix, gconstpointer data)
+{
+}
+
+/******************** The actual test cases ********************/
+
+static void
+test_allocation (ServerFixture *fix, gconstpointer data)
+{
+  /* Do nothing, this test basically just asserts that
+   * the fix->server is cleaned up after immediate construction */
+}
+
+static void
+test_become_leader (ServerFixture *fix, gconstpointer data)
+{
+  gtx_wait_for_signal (G_OBJECT (fix->server), TIMEOUT,
+                       "notify::swarm-leader", NULL);
+
+  /* Assert that we have become swarm leaders.
+   * No other peers should be running */
+  g_assert_cmpint (0, !=, dee_peer_is_swarm_leader (DEE_PEER (fix->server)));
+}
+
+static void
+test_valid_client_address (ServerFixture *fix, gconstpointer data)
+{
+  gtx_wait_for_signal (G_OBJECT (fix->server), TIMEOUT,
+                       "notify::swarm-leader", NULL);
+
+  g_assert (dee_server_get_client_address (fix->server) != NULL);
+}
+
+static void
+on_connection_acquired (DeeServer *server, GDBusConnection *connection, 
+                        GSList **list)
+{
+  /* Yes, I _know_ that append() is slow, but this is a test! */
+  *list = g_slist_append (*list, connection);
+}
+
+static void
+test_one_client (ServerFixture *fix, gconstpointer data)
+{
+  GSList *list = NULL;
+
+  g_signal_connect (fix->server, "connection-acquired",
+                    G_CALLBACK (on_connection_acquired), &list);
+
+  gtx_wait_for_signal (G_OBJECT (fix->server), TIMEOUT,
+                       "notify::swarm-leader", NULL);
+
+  /* We are leaders - launch the helper */
+  if (gtx_wait_for_command (TESTDIR,
+                            SERVER_HELPER (client, PEER_NAME, 1),
+                            2000))
+    g_critical ("Peer helper timed out");
+
+  gtx_assert_last_command_status (0);
+
+  g_assert_cmpuint (g_slist_length (list), ==, 1);
+
+  g_slist_free (list);
+}
+
+static void
+test_multiple_clients (ServerFixture *fix, gconstpointer data)
+{
+  GSList *list = NULL;
+
+  g_signal_connect (fix->server, "connection-acquired",
+                    G_CALLBACK (on_connection_acquired), &list);
+
+  gtx_wait_for_signal (G_OBJECT (fix->server), TIMEOUT,
+                       "notify::swarm-leader", NULL);
+
+  /* We are leaders - launch the helper */
+  if (gtx_wait_for_command (TESTDIR,
+                            SERVER_HELPER (client, PEER_NAME, 4),
+                            2000))
+    g_critical ("Peer helper timed out");
+
+  gtx_assert_last_command_status (0);
+
+  g_assert_cmpuint (g_slist_length (list), ==, 4);
+
+  g_slist_free (list);
+}
+
+static void
+test_ready (Fixture *fix, gconstpointer data)
+{
+  GParamSpec *pspec;
+  gboolean    synchronized;
+
+  /* Test the GObject property reports FALSE */
+  g_object_get (fix->model, "synchronized", &synchronized, NULL);
+  g_assert_cmpint (0, == , synchronized);
+
+  /* Check that convenience getter now reports FALSE */
+  g_assert_cmpint (0, ==, dee_shared_model_is_synchronized (DEE_SHARED_MODEL (fix->model)));
+
+  if (gtx_wait_for_signal (G_OBJECT (fix->model), TIMEOUT, "notify::synchronized", &pspec))
+    g_critical ("Model never synchronized");
+  else
+    g_param_spec_unref (pspec);
+
+  /* Test the GObject property reports TRUE */
+  g_object_get (fix->model, "synchronized", &synchronized, NULL);
+  g_assert_cmpint (0, != , synchronized);
+
+  /* Check that convenience getter now reports TRUE */
+  g_assert_cmpint (0, !=, dee_shared_model_is_synchronized (DEE_SHARED_MODEL (fix->model)));
+
+  if (!gtx_wait_for_signal (G_OBJECT (fix->model), TIMEOUT, "notify::synchronized", &pspec))
+    {
+      g_critical ("Model changed synchronization state twice");
+      g_param_spec_unref (pspec);
+    }
+}
+
+static gboolean
+_add3rows (DeeModel *model)
+{
+  g_return_val_if_fail (DEE_IS_MODEL (model), FALSE);
+
+  dee_model_append (model, 0, "zero");
+  dee_model_append (model, 1, "one");
+  dee_model_append (model, 2, "two");
+  return FALSE;
+}
+
+static gboolean
+_add5rows (DeeModel *model)
+{
+  g_return_val_if_fail (DEE_IS_MODEL (model), FALSE);
+
+  dee_model_append (model, 0, "zero");
+  dee_model_append (model, 1, "one");
+  dee_model_append (model, 2, "two");
+  dee_model_append (model, 3, "three");
+  dee_model_append (model, 4, "four");
+  return FALSE;
+}
+
+static gboolean
+_change3rows (DeeModel *model)
+{
+  DeeModelIter *iter;
+
+  g_return_val_if_fail (DEE_IS_MODEL (model), FALSE);
+
+  iter = dee_model_get_iter_at_row (model, 0);
+  dee_model_set_value (model, iter, 1, g_variant_new_string ("changed_zero"));
+
+  iter = dee_model_get_iter_at_row (model, 1);
+  dee_model_set_value (model, iter, 1, g_variant_new_string ("changed_one"));
+
+  iter = dee_model_get_iter_at_row (model, 2);
+  dee_model_set_value (model, iter, 1, g_variant_new_string ("changed_two"));
+  
+  return FALSE;
+}
+
+/* Assumes a model with 5 rows. Removes rows 0, 4, and 2
+ * in that order. Accounting for rows shifts this becomes
+ * 0, 3, and 1. Leaving the original rows 1 and 3 now in
+ * positions 0 and 1 */
+static gboolean
+_remove3rows (DeeModel *model)
+{
+  DeeModelIter *iter0, *iter4, *iter2;
+  DeeModelIter *orig_iter1, *orig_iter3;
+
+  g_return_val_if_fail (DEE_IS_MODEL (model), FALSE);
+  g_return_val_if_fail (dee_model_get_n_rows (model) == 5, FALSE);
+
+  iter0 = dee_model_get_iter_at_row (model, 0);
+  iter4 = dee_model_get_iter_at_row (model, 4);
+  iter2 = dee_model_get_iter_at_row (model, 2);
+
+  orig_iter1 = dee_model_get_iter_at_row (model, 1);
+  orig_iter3 = dee_model_get_iter_at_row (model, 3);
+
+  dee_model_remove (model, iter0);
+  dee_model_remove (model, iter4);
+  dee_model_remove (model, iter2);
+
+  g_assert_cmpint (dee_model_get_n_rows (model), ==, 2);
+  g_assert (dee_model_get_iter_at_row (model, 0) == orig_iter1);
+  g_assert (dee_model_get_iter_at_row (model, 1) == orig_iter3);
+
+  return FALSE;
+}
+
+static gboolean
+_insert1row (DeeModel *model)
+{
+  g_return_val_if_fail (DEE_IS_MODEL (model), FALSE);
+
+  dee_model_insert (model, 1, 27, "twentyseven");
+  return FALSE;
+}
+
+static gboolean
+_clear_model (DeeModel *model)
+{
+  g_return_val_if_fail (DEE_IS_MODEL (model), FALSE);
+
+  dee_model_clear (model);
+  
+  return FALSE;
+}
+
+static gboolean
+_clear_and_add5rows (DeeModel *model)
+{
+  g_return_val_if_fail (DEE_IS_MODEL (model), FALSE);
+
+  _clear_model (model);
+  _add5rows (model);
+
+  return FALSE;
+}
+
+static void
+test_clone (Fixture *fix, gconstpointer data)
+{ 
+  if (gtx_wait_for_signal (G_OBJECT (fix->model), TIMEOUT, "notify::synchronized", NULL))
+    g_critical ("Model never synchronized");
+
+  _add3rows (fix->model);
+
+  if (gtx_wait_for_command (TESTDIR,
+                            MODEL_HELPER (clone3rows, MODEL_NAME),
+                            1000))
+    g_critical ("Model helper timed out");
+
+  gtx_assert_last_command_status (0);
+
+  /* We test that we can do this two times */
+  /*if (gtx_wait_for_command (TESTDIR, MODEL_HELPER (3rows, MODEL_NAME), 1000))
+    g_critical ("Model helper timed out");
+
+  gtx_assert_last_command_status (0);*/
+}
+
+static void
+test_row_added (Fixture *fix, gconstpointer data)
+{ 
+  if (gtx_wait_for_signal (G_OBJECT (fix->model), TIMEOUT, "notify::synchronized", NULL))
+    g_critical ("Model never emitted 'ready' signal");
+
+  g_timeout_add (500, (GSourceFunc)_add3rows, fix->model);
+
+  if (gtx_wait_for_command (TESTDIR,
+                            MODEL_HELPER (add3rows, MODEL_NAME),
+                            2000))
+    g_critical ("Model helper timed out");
+
+  gtx_assert_last_command_status (0);
+}
+
+static void
+test_row_changed (Fixture *fix, gconstpointer data)
+{ 
+  if (gtx_wait_for_signal (G_OBJECT (fix->model), TIMEOUT, "notify::synchronized", NULL))
+    g_critical ("Model never emitted 'ready' signal");
+
+  _add3rows (fix->model);
+  g_timeout_add (500, (GSourceFunc)_change3rows, fix->model);
+
+  //const gchar *cmd[] = {"dbus-monitor", NULL};
+  //const gchar *cmd[] = {"sleep", "1",NULL};
+  if (gtx_wait_for_command (TESTDIR,
+                            MODEL_HELPER (change3rows, MODEL_NAME),
+                            2000))
+    g_critical ("Model helper timed out");
+  
+  gtx_assert_last_command_status (0);  
+}
+
+static void
+test_row_removed (Fixture *fix, gconstpointer data)
+{
+  if (gtx_wait_for_signal (G_OBJECT (fix->model), TIMEOUT, "notify::synchronized", NULL))
+    g_critical ("Model never emitted 'ready' signal");
+
+  _add5rows (fix->model);
+  g_timeout_add (500, (GSourceFunc)_remove3rows, fix->model);
+
+  if (gtx_wait_for_command (TESTDIR,
+                            MODEL_HELPER (remove3rows, MODEL_NAME),
+                            2000))
+    g_critical ("Model helper timed out");
+
+  gtx_assert_last_command_status (0);
+}
+
+static void
+test_model_clear (Fixture *fix, gconstpointer data)
+{ 
+  if (gtx_wait_for_signal (G_OBJECT (fix->model), TIMEOUT, "notify::synchronized", NULL))
+    g_critical ("Model never emitted 'ready' signal");
+
+  _add3rows (fix->model);
+  g_timeout_add (500, (GSourceFunc)_clear_model, fix->model);
+  
+  if (gtx_wait_for_command (TESTDIR,
+                            MODEL_HELPER (clear3rows, MODEL_NAME),
+                            2000))
+    g_critical ("Model helper timed out");
+  
+  gtx_assert_last_command_status (0);  
+}
+
+static void
+test_clear_add (Fixture *fix, gconstpointer data)
+{
+  if (gtx_wait_for_signal (G_OBJECT (fix->model), TIMEOUT, "notify::synchronized", NULL))
+    g_critical ("Model never emitted 'ready' signal");
+
+  g_timeout_add (500, (GSourceFunc)_add3rows, fix->model);
+  if (gtx_wait_for_command (TESTDIR,
+                            MODEL_HELPER (add3rows, MODEL_NAME),
+                            2000))
+    g_critical ("Model helper timed out");
+  
+  gtx_assert_last_command_status (0);
+
+  g_timeout_add (500, (GSourceFunc)_clear_and_add5rows, fix->model);
+  if (gtx_wait_for_command (TESTDIR,
+                            MODEL_HELPER (clear3add5, MODEL_NAME),
+                            2000))
+    g_critical ("Model helper timed out");
+  
+  gtx_assert_last_command_status (0);
+}
+
+static void
+test_clear_then_add (Fixture *fix, gconstpointer data)
+{ 
+  if (gtx_wait_for_signal (G_OBJECT (fix->model), TIMEOUT, "notify::synchronized", NULL))
+    g_critical ("Model never emitted 'ready' signal");
+
+  _clear_model (fix->model);
+  g_timeout_add (500, (GSourceFunc)_add3rows, fix->model);
+  
+  if (gtx_wait_for_command (TESTDIR,
+                            MODEL_HELPER (add3rows, MODEL_NAME),
+                            2000))
+    g_critical ("Model helper timed out");
+  
+  gtx_assert_last_command_status (0);
+  
+  g_timeout_add (500, (GSourceFunc)_clear_model, fix->model);
+  if (gtx_wait_for_command (TESTDIR,
+                            MODEL_HELPER (clear3rows, MODEL_NAME),
+                            2000))
+    g_critical ("Model helper timed out");
+  
+  gtx_assert_last_command_status (0);
+}
+
+static void
+test_row_inserted (Fixture *fix, gconstpointer data)
+{ 
+  if (gtx_wait_for_signal (G_OBJECT (fix->model), TIMEOUT, "notify::synchronized", NULL))
+    g_critical ("Model never emitted 'ready' signal");
+
+  _add3rows (fix->model);
+  g_timeout_add (500, (GSourceFunc)_insert1row, fix->model);
+  
+  if (gtx_wait_for_command (TESTDIR,
+                            MODEL_HELPER (insert1row, MODEL_NAME),
+                            2000))
+    g_critical ("Model helper timed out");
+
+  gtx_assert_last_command_status (0);
+}
+
+static void
+_ready (DeeModel *model, GParamSpec *pspec, GSList **rows_so_far)
+{
+  /* We must not have any rows when 'ready' is emitted */
+  g_assert (*rows_so_far == NULL);
+}
+
+static void
+_collect_row (DeeModel *model, DeeModelIter *iter, GSList **rows_so_far)
+{
+  /* Yes, I _know_ that append() is slow, but this is a test! */
+  *rows_so_far = g_slist_append (*rows_so_far, iter);
+}
+
+/* This case must run without a Fixture  */
+static void
+test_schemaless_leader (Fixture *fix, gconstpointer data)
+{
+  DeeModel     *model;
+  DeeModelIter *iter;
+  GSList        *rows_added;
+  
+  g_assert (fix->model == NULL);
+
+  /* Set up a clean model *without* a schema. We will pick up the schema
+   * with the first transaction from the slave. Or at least, that's what we
+   * want to assert ;-) */
+  model = dee_shared_model_new_for_peer (DEE_PEER (dee_server_new (MODEL_NAME)));
+  // no set_schema() on purpose!
+
+  /* Listen for changes */
+  rows_added = NULL;
+  g_signal_connect (model, "row-added", G_CALLBACK (_collect_row), &rows_added);
+  g_signal_connect (model, "notify::synchronized", G_CALLBACK (_ready), &rows_added);
+  
+  /* Remote process defines column types and adds two rows */
+  if (gtx_wait_for_command (TESTDIR,
+                            MODEL_HELPER (schemaless, MODEL_NAME),
+                            2000))
+    g_critical ("Model helper timed out");
+
+  /* Check that we got the right schema from the peer */
+  g_assert_cmpint (dee_model_get_n_columns (model), ==, 2);
+  g_assert_cmpstr (dee_model_get_column_schema (model, 0), ==, "i");
+  g_assert_cmpstr (dee_model_get_column_schema (model, 1), ==, "s");
+
+  /* Check that we got what we expected */
+  g_assert_cmpint (g_slist_length (rows_added), == , 2);
+  g_assert_cmpint (dee_model_get_n_rows (model), ==, 2);
+  g_assert_cmpint (dee_model_get_n_columns (model), ==, 2);
+
+  iter = (DeeModelIter*) g_slist_nth (rows_added, 0)->data;
+  g_assert_cmpint (dee_model_get_position (model, iter), == , 0);
+  g_assert_cmpint (dee_model_get_int32 (model, iter, 0), == , 27);
+  g_assert_cmpstr (dee_model_get_string (model, iter, 1), == , "skunkworks");
+
+  iter = (DeeModelIter*) g_slist_nth (rows_added, 1)->data;
+  g_assert_cmpint (dee_model_get_position (model, iter), == , 1);
+  g_assert_cmpint (dee_model_get_int32 (model, iter, 0), == , 68);
+  g_assert_cmpstr (dee_model_get_string (model, iter, 1), == , "wumbo");
+
+  gtx_assert_last_unref (model);
+  g_slist_free (rows_added);
+
+  /* Spin the mainloop so the socket service gets into usable state again */
+  gtx_yield_main_loop (200);
+}
+
+static void
+test_client_commit (Fixture *fix, gconstpointer data)
+{
+  gtx_wait_for_signal (G_OBJECT (fix->model), TIMEOUT,
+                       "notify::synchronized", NULL);
+
+  DeeModel *client_model1 = dee_shared_model_new_for_peer (
+      DEE_PEER (dee_client_new (MODEL_NAME)));
+  DeeModel *client_model2 = dee_shared_model_new_for_peer (
+      DEE_PEER (dee_client_new (MODEL_NAME)));
+
+  gtx_wait_for_signal (G_OBJECT (client_model1), TIMEOUT,
+                       "notify::synchronized", NULL);
+
+  g_assert (dee_shared_model_is_synchronized (DEE_SHARED_MODEL (client_model1)));
+
+  if (!dee_shared_model_is_synchronized (DEE_SHARED_MODEL (client_model2)))
+  {
+    gtx_wait_for_signal (G_OBJECT (client_model2), TIMEOUT, 
+                         "notify::synchronized", NULL);
+  }
+
+  dee_model_append (client_model1, 38, "client_change");
+
+  gtx_yield_main_loop (500);
+
+  g_assert_cmpuint (dee_model_get_n_rows (fix->model), >, 0);
+  g_assert_cmpuint (dee_model_get_n_rows (client_model1), >, 0);
+  g_assert_cmpuint (dee_model_get_n_rows (client_model2), >, 0);
+
+  g_object_unref (client_model1);
+  g_object_unref (client_model2);
+}

=== modified file 'tests/test-dee.c'
--- tests/test-dee.c	2011-12-06 20:52:49 +0000
+++ tests/test-dee.c	2011-12-19 08:59:26 +0000
@@ -40,6 +40,7 @@
 #ifdef HAVE_GTX
 void test_model_interactions_create_suite(void);
 void test_peer_interactions_create_suite(void);
+void test_client_server_interactions_create_suite(void);
 #endif  /* HAVE_GTX */
 
 gint
@@ -69,6 +70,7 @@
 #ifdef HAVE_GTX
   test_model_interactions_create_suite();
   test_peer_interactions_create_suite();
+  test_client_server_interactions_create_suite();
 #else
   g_message ("Interactions' test suite disabled. GTX not found. You can download GTX from https://launchpad.net/gtx");
 #endif  /* HAVE_GTX */

=== modified file 'tests/test-filter-model.c'
--- tests/test-filter-model.c	2011-12-14 14:44:58 +0000
+++ tests/test-filter-model.c	2011-12-19 08:59:26 +0000
@@ -120,16 +120,18 @@
     }
 }
 
-static void
+static gboolean
 discard_all_model_notify (DeeModel       *orig_model,
                           DeeModelIter   *orig_iter,
                           DeeFilterModel *mapped_model,
                           gpointer        user_data)
 {
   /* Do nothing */
+
+  return FALSE;
 }
 
-static void
+static gboolean
 append_all_model_notify (DeeModel       *orig_model,
                          DeeModelIter   *orig_iter,
                          DeeFilterModel *mapped_model,
@@ -138,6 +140,8 @@
   /* Always say "Thank you, I am delighted",
    * and append the new row to @mapped_model */
   dee_filter_model_append_iter (mapped_model, orig_iter);
+
+  return TRUE;
 }
 
 static void

=== modified file 'tools/dee-tool.c'
--- tools/dee-tool.c	2011-11-24 21:56:23 +0000
+++ tools/dee-tool.c	2011-12-19 08:59:26 +0000
@@ -22,9 +22,12 @@
 #include <glib/gprintf.h>
 #include <dee.h>
 
-static gchar *resource_name = NULL;
-static gchar *model_name = NULL;
-static gchar *peer_name = NULL;
+static gchar    *resource_name = NULL;
+static gchar    *model_name = NULL;
+static gchar    *peer_name = NULL;
+static gboolean  linger;
+static gboolean  private;
+static gboolean  server;
 
 static GOptionEntry option_entries[] = {
     { "resource", 'r', 0, G_OPTION_ARG_STRING, &resource_name,
@@ -33,6 +36,12 @@
       "Dump a model given by name" },
     { "peer", 'p', 0, G_OPTION_ARG_STRING, &peer_name,
       "List peers and leader of a swarm" },
+    { "linger", '\0', 0, G_OPTION_ARG_NONE, &linger,
+      "Don't exit, but keep the process running the mainloop" },
+    { "private", '\0', 0, G_OPTION_ARG_NONE, &private,
+      "Use a private (aka peer-2-peer) DBus connection" },
+    { "server", '\0', 0, G_OPTION_ARG_NONE, &server,
+      "Set up a private DBus server. Implies --private and --linger" },
     { NULL }
 };
 
@@ -81,7 +90,20 @@
   GVariant       *v;
   gchar          *dump;
 
-  m = DEE_SHARED_MODEL (dee_shared_model_new (name));
+  if (server)
+    {
+      m = DEE_SHARED_MODEL (dee_shared_model_new_for_peer (
+                                             DEE_PEER (dee_server_new (name))));
+      dee_model_set_schema (m, "s", "i", NULL);
+    }
+  else if (private)
+    {
+      m = DEE_SHARED_MODEL (dee_shared_model_new_for_peer (
+                                             DEE_PEER (dee_client_new (name))));
+    }
+  else
+    m = DEE_SHARED_MODEL (dee_shared_model_new (name));
+    
   ctx = g_main_context_default ();
 
   while (!dee_shared_model_is_synchronized (m))
@@ -94,6 +116,14 @@
 
   g_printf ("%s\n", dump);
 
+  if (linger)
+    {
+      while (TRUE)
+        {
+          g_main_context_iteration (ctx, TRUE);
+        }
+    }
+
   g_free (dump);
   g_variant_unref (v);
   g_object_unref (m);
@@ -124,8 +154,14 @@
 {
   DeePeer        *p;
   GMainContext   *ctx;
-
-  p = dee_peer_new (name);
+  
+  if (server)
+    p = DEE_PEER (dee_server_new (name));
+  else if (private)
+    p = DEE_PEER (dee_client_new (name));
+  else
+    p = dee_peer_new (name);
+  
   ctx = g_main_context_default ();
 
   g_signal_connect (p, "peer-found", G_CALLBACK (_peer_found_cb), NULL);
@@ -139,7 +175,11 @@
 
   g_printf ("LEADER %s\n", dee_peer_get_swarm_leader (p));
 
-  g_timeout_add_seconds (1, _timeout_cb, NULL);
+  /* If we're serving a private conn stick around indefinitely,
+   * otherwise quit after 1s */
+  if (!linger)
+    g_timeout_add_seconds (1, _timeout_cb, NULL);
+  
   while (!timed_out)
     {
       g_main_context_iteration (ctx, TRUE);
@@ -164,6 +204,12 @@
       g_error_free (error);
       return 1;
     }
+  
+  if (server)
+    {
+      private = TRUE;
+      linger = TRUE;
+    }
 
   if (resource_name)
     {

=== modified file 'vapi/dee-1.0.vapi'
--- vapi/dee-1.0.vapi	2011-12-15 12:28:43 +0000
+++ vapi/dee-1.0.vapi	2011-12-19 08:59:26 +0000
@@ -13,6 +13,15 @@
 		public virtual string collate_key (string data);
 		public virtual void tokenize (string data, Dee.TermList terms_out);
 	}
+	[CCode (cheader_filename = "dee.h", type_id = "dee_client_get_type ()")]
+	public class Client : Dee.Peer {
+		[CCode (has_construct_function = false)]
+		public Client (string swarm_name);
+		[CCode (has_construct_function = false)]
+		public Client.for_address (string swarm_name, string bus_address);
+		[NoAccessorMethod]
+		public string bus_address { owned get; construct; }
+	}
 	[CCode (cheader_filename = "dee.h", type_id = "dee_file_resource_manager_get_type ()")]
 	public class FileResourceManager : GLib.Object, Dee.ResourceManager {
 		[CCode (has_construct_function = false, type = "DeeResourceManager*")]
@@ -69,14 +78,15 @@
 	public class Peer : GLib.Object {
 		[CCode (has_construct_function = false)]
 		public Peer (string swarm_name);
-		[NoWrapper]
-		public virtual void connected (string peer_name);
-		public unowned string get_swarm_leader ();
+		public virtual GLib.SList<weak GLib.DBusConnection> get_connections ();
+		public virtual unowned string get_swarm_leader ();
 		public unowned string get_swarm_name ();
-		public bool is_swarm_leader ();
+		public virtual bool is_swarm_leader ();
 		public string swarm_leader { get; }
 		[NoAccessorMethod]
 		public string swarm_name { owned get; set construct; }
+		public virtual signal void connection_acquired (GLib.DBusConnection connection);
+		public virtual signal void connection_closed (GLib.DBusConnection connection);
 		public virtual signal void peer_found (string name);
 		public virtual signal void peer_lost (string name);
 	}
@@ -102,11 +112,25 @@
 		public virtual uint64 inc_seqnum ();
 		public virtual void set_seqnum (uint64 seqnum);
 	}
+	[CCode (cheader_filename = "dee.h", type_id = "dee_server_get_type ()")]
+	public class Server : Dee.Peer {
+		[CCode (has_construct_function = false)]
+		public Server (string swarm_name);
+		[CCode (has_construct_function = false)]
+		public Server.for_address (string swarm_name, string bus_address);
+		public unowned string get_client_address ();
+		[NoAccessorMethod]
+		public string bus_address { owned get; construct; }
+		[NoAccessorMethod]
+		public bool same_user_only { get; construct; }
+	}
 	[CCode (cheader_filename = "dee.h", type_id = "dee_shared_model_get_type ()")]
 	public class SharedModel : Dee.ProxyModel, Dee.Model, Dee.Serializable {
 		[CCode (has_construct_function = false, type = "DeeModel*")]
 		public SharedModel (string name);
 		public uint flush_revision_queue ();
+		[CCode (has_construct_function = false, type = "DeeModel*")]
+		public SharedModel.for_peer (owned Dee.Peer peer);
 		public unowned Dee.Peer get_peer ();
 		public unowned string get_swarm_name ();
 		public bool is_leader ();