Merge lp:~nataliabidart/magicicada-server/embed-u1sync into lp:magicicada-server

[Natalia Bidart]

- Embed u1sync test dependency inside magicicada source code.

[Facundo Batista (facundo)]

Awesome!

review: Approve

=== modified file 'config-manager.txt'
--- config-manager.txt	2018-04-18 20:28:35 +0000
+++ config-manager.txt	2018-04-20 01:22:48 +0000
@@ -21,5 +21,4 @@
 #
 #   make clean-sourcedeps sourcedeps
 
-./.sourcecode/u1sync                      ~facundo/u1sync/opensourcing;revno=10
 ./.sourcecode/magicicada-client           ~chicharreros/magicicada-client/trunk;revno=1442

=== removed symlink 'lib/metrics'
=== target was u'../magicicada/metrics/'
=== removed symlink 'lib/u1sync'
=== target was u'../.sourcecode/u1sync/u1sync'
=== modified file 'lib/utilities/testlib.py'
--- lib/utilities/testlib.py	2018-04-05 21:08:25 +0000
+++ lib/utilities/testlib.py	2018-04-20 01:22:48 +0000
@@ -20,7 +20,6 @@
 
 from __future__ import unicode_literals
 
-import logging
 import os
 import re
 

=== modified file 'lib/utilities/utils.py'
--- lib/utilities/utils.py	2018-04-05 21:08:25 +0000
+++ lib/utilities/utils.py	2018-04-20 01:22:48 +0000
@@ -37,7 +37,7 @@
         with open(proc_stat, 'r') as f:
             if proc_name in f.read():
                 return True
-    except:
+    except Exception:
         # ignore all errors
         pass
     return False

=== modified file 'magicicada/filesync/services.py'
--- magicicada/filesync/services.py	2018-04-05 21:08:25 +0000
+++ magicicada/filesync/services.py	2018-04-20 01:22:48 +0000
@@ -34,12 +34,11 @@
 from functools import wraps
 from weakref import WeakValueDictionary
 
-import metrics
-
 from django.conf import settings
 from django.db import connection, models
 from django.utils.timezone import now
 
+from magicicada import metrics
 from magicicada.filesync import errors, utils
 from magicicada.filesync.dbmanager import (
     fsync_readonly,

=== modified file 'magicicada/metrics/tests/test_base.py'
--- magicicada/metrics/tests/test_base.py	2016-06-04 19:05:51 +0000
+++ magicicada/metrics/tests/test_base.py	2018-04-20 01:22:48 +0000
@@ -22,8 +22,7 @@
 import logging
 import unittest
 
-import metrics
-
+from magicicada import metrics
 from magicicada.testing.testcase import BaseTestCase
 
 

=== modified file 'magicicada/monitoring/reactor.py'
--- magicicada/monitoring/reactor.py	2018-04-05 21:08:25 +0000
+++ magicicada/monitoring/reactor.py	2018-04-20 01:22:48 +0000
@@ -28,8 +28,7 @@
 import traceback
 import Queue
 
-import metrics
-
+from magicicada import metrics
 from magicicada.settings import TRACE
 
 

=== modified file 'magicicada/monitoring/tests/test_reactor.py'
--- magicicada/monitoring/tests/test_reactor.py	2018-04-05 21:08:25 +0000
+++ magicicada/monitoring/tests/test_reactor.py	2018-04-20 01:22:48 +0000
@@ -26,8 +26,7 @@
 from twisted.trial.unittest import TestCase as TwistedTestCase
 from twisted.internet import reactor, defer
 
-import metrics
-
+from magicicada import metrics
 from magicicada.monitoring.reactor import ReactorInspector, logger
 from magicicada.settings import TRACE
 from magicicada.testing.testcase import BaseTestCase

=== modified file 'magicicada/server/integtests/test_sync.py'
--- magicicada/server/integtests/test_sync.py	2018-04-05 21:08:25 +0000
+++ magicicada/server/integtests/test_sync.py	2018-04-20 01:22:48 +0000
@@ -35,9 +35,6 @@
 from twisted.internet import reactor, defer
 from twisted.python.failure import Failure
 
-import u1sync.client
-
-from u1sync.main import do_diff, do_init, do_sync
 from ubuntuone.platform import tools
 from ubuntuone.storageprotocol import client as protocol_client
 from ubuntuone.storageprotocol import request
@@ -59,6 +56,9 @@
 )
 from magicicada.server.testing.caps_helpers import required_caps
 from magicicada.server.testing.testcase import logger
+from magicicada.u1sync import client as u1sync_client
+from magicicada.u1sync.main import do_diff, do_init, do_sync
+
 
 U1SYNC_QUIET = True
 NO_CONTENT_HASH = ""
@@ -225,7 +225,7 @@
 
     def _u1sync_client(self):
         """Create a u1sync client instance."""
-        client = u1sync.client.Client()
+        client = u1sync_client.Client()
         client.connect_ssl("localhost", self.ssl_port, True)
         client.set_capabilities()
         auth_info = self.access_tokens['jack']

=== modified file 'magicicada/server/server.py'
--- magicicada/server/server.py	2018-04-05 21:08:25 +0000
+++ magicicada/server/server.py	2018-04-20 01:22:48 +0000
@@ -40,8 +40,6 @@
 import twisted
 import twisted.web.error
 
-import metrics
-
 from twisted.application.service import MultiService, Service
 from twisted.application.internet import TCPServer
 from twisted.internet.defer import maybeDeferred, inlineCallbacks
@@ -51,7 +49,7 @@
 from ubuntuone.storageprotocol import protocol_pb2, request, sharersp
 from ubuntuone.supervisor import utils as supervisor_utils
 
-from magicicada import settings
+from magicicada import metrics, settings
 from magicicada.filesync import errors as dataerror
 from magicicada.filesync.notifier import notifier
 from magicicada.monitoring.reactor import ReactorInspector

=== modified file 'magicicada/server/ssl_proxy.py'
--- magicicada/server/ssl_proxy.py	2018-04-05 21:08:25 +0000
+++ magicicada/server/ssl_proxy.py	2018-04-20 01:22:48 +0000
@@ -31,9 +31,7 @@
 from twisted.protocols import portforward, basic
 from twisted.web import server, resource
 
-import metrics
-
-from magicicada import settings
+from magicicada import metrics, settings
 from magicicada.server.server import FILESYNC_STATUS_MSG, get_service_port
 from magicicada.server.ssl import disable_ssl_compression
 from ubuntuone.supervisor import utils as supervisor_utils

=== modified file 'magicicada/server/stats.py'
--- magicicada/server/stats.py	2018-04-05 21:08:25 +0000
+++ magicicada/server/stats.py	2018-04-20 01:22:48 +0000
@@ -27,8 +27,7 @@
 from twisted.internet import defer, reactor
 from twisted.web import server, resource
 
-import metrics
-
+from magicicada import metrics
 from magicicada.monitoring import dump
 
 logger = logging.getLogger(__name__)

=== modified file 'magicicada/server/tests/test_server.py'
--- magicicada/server/tests/test_server.py	2018-04-05 21:08:25 +0000
+++ magicicada/server/tests/test_server.py	2018-04-20 01:22:48 +0000
@@ -28,8 +28,6 @@
 import uuid
 import weakref
 
-import metrics
-
 from django.utils.timezone import now
 from mocker import expect, Mocker, MockerTestCase, ARGS, KWARGS, ANY
 from twisted.python.failure import Failure
@@ -38,7 +36,7 @@
 from twisted.trial.unittest import TestCase as TwistedTestCase
 from ubuntuone.storageprotocol import protocol_pb2, request
 
-from magicicada import settings
+from magicicada import metrics, settings
 from magicicada.filesync import errors as dataerror
 from magicicada.filesync.models import Share
 from magicicada.server import errors

=== modified file 'magicicada/server/tests/test_ssl_proxy.py'
--- magicicada/server/tests/test_ssl_proxy.py	2018-04-05 21:08:25 +0000
+++ magicicada/server/tests/test_ssl_proxy.py	2018-04-20 01:22:48 +0000
@@ -34,9 +34,7 @@
     StorageClientFactory, StorageClient)
 from ubuntuone.supervisor import utils as supervisor_utils
 
-import metrics
-
-from magicicada import settings
+from magicicada import metrics, settings
 from magicicada.server import ssl_proxy
 from magicicada.server.server import PREFERRED_CAP
 from magicicada.server.testing.testcase import TestWithDatabase

=== modified file 'magicicada/server/tests/test_stats.py'
--- magicicada/server/tests/test_stats.py	2018-04-05 21:08:25 +0000
+++ magicicada/server/tests/test_stats.py	2018-04-20 01:22:48 +0000
@@ -20,8 +20,7 @@
 
 from twisted.internet import defer
 
-import metrics
-
+from magicicada import metrics
 from magicicada.server.stats import StatsWorker
 from magicicada.server.testing.testcase import TestWithDatabase
 

=== added directory 'magicicada/u1sync'
=== added file 'magicicada/u1sync/__init__.py'
--- magicicada/u1sync/__init__.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/__init__.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,14 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""The guts of the u1sync tool."""

=== added file 'magicicada/u1sync/client.py'
--- magicicada/u1sync/client.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/client.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,736 @@
+# Copyright 2009-2015 Canonical
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Pretty API for protocol client."""
+
+from __future__ import with_statement
+
+import logging
+import os
+import sys
+import shutil
+import time
+import uuid
+import zlib
+
+from cStringIO import StringIO
+from logging.handlers import RotatingFileHandler
+from Queue import Queue
+from threading import Lock
+
+from dirspec.basedir import xdg_cache_home
+from twisted.internet import reactor, defer
+from twisted.internet.defer import inlineCallbacks, returnValue
+from ubuntuone.storageprotocol import request, volumes
+from ubuntuone.storageprotocol.content_hash import crc32
+from ubuntuone.storageprotocol.context import get_ssl_context
+from ubuntuone.storageprotocol.client import (
+    StorageClientFactory, StorageClient)
+from ubuntuone.storageprotocol.delta import DIRECTORY as delta_DIR
+from ubuntuone.storageprotocol.dircontent_pb2 import DIRECTORY, FILE
+
+from magicicada.u1sync.genericmerge import MergeNode
+from magicicada.u1sync.utils import should_sync
+
+
+CONSUMER_KEY = "ubuntuone"
+CONSUMER_SECRET = "hammertime"
+
+u1sync_log_dir = os.path.join(xdg_cache_home, 'u1sync', 'log')
+LOGFILENAME = os.path.join(u1sync_log_dir, 'u1sync.log')
+if not os.path.exists(u1sync_log_dir):
+    os.makedirs(u1sync_log_dir)
+u1_logger = logging.getLogger("u1sync.timing.log")
+handler = RotatingFileHandler(LOGFILENAME)
+u1_logger.addHandler(handler)
+
+
+def share_str(share_uuid):
+    """Converts a share UUID to a form the protocol likes."""
+    return str(share_uuid) if share_uuid is not None else request.ROOT
+
+
+def log_timing(func):
+    def wrapper(*arg, **kwargs):
+        start = time.time()
+        ent = func(*arg, **kwargs)
+        stop = time.time()
+        u1_logger.debug('for %s %0.5f ms elapsed',
+                        func.func_name, stop-start * 1000.0)
+        return ent
+    return wrapper
+
+
+class ForcedShutdown(Exception):
+    """Client shutdown forced."""
+
+
+class Waiter(object):
+    """Wait object for blocking waits."""
+
+    def __init__(self):
+        """Initializes the wait object."""
+        self.queue = Queue()
+
+    def wake(self, result):
+        """Wakes the waiter with a result."""
+        self.queue.put((result, None))
+
+    def wakeAndRaise(self, exc_info):
+        """Wakes the waiter, raising the given exception in it."""
+        self.queue.put((None, exc_info))
+
+    def wakeWithResult(self, func, *args, **kw):
+        """Wakes the waiter with the result of the given function."""
+        try:
+            result = func(*args, **kw)
+        except Exception:
+            self.wakeAndRaise(sys.exc_info())
+        else:
+            self.wake(result)
+
+    def wait(self):
+        """Waits for wakeup."""
+        (result, exc_info) = self.queue.get()
+        if exc_info:
+            try:
+                raise exc_info[0], exc_info[1], exc_info[2]
+            finally:
+                exc_info = None
+        else:
+            return result
+
+
+class SyncStorageClient(StorageClient):
+    """Simple client that calls a callback on connection."""
+
+    @log_timing
+    def connectionMade(self):
+        """Setup and call callback."""
+        StorageClient.connectionMade(self)
+        if self.factory.current_protocol not in (None, self):
+            self.factory.current_protocol.transport.loseConnection()
+        self.factory.current_protocol = self
+        self.factory.observer.connected()
+
+    @log_timing
+    def connectionLost(self, reason=None):
+        """Callback for established connection lost."""
+        StorageClient.connectionLost(self, reason)
+        if self.factory.current_protocol is self:
+            self.factory.current_protocol = None
+            self.factory.observer.disconnected(reason)
+
+
+class SyncClientFactory(StorageClientFactory):
+    """A cmd protocol factory."""
+
+    protocol = SyncStorageClient
+
+    @log_timing
+    def __init__(self, observer):
+        """Create the factory"""
+        self.observer = observer
+        self.current_protocol = None
+
+    @log_timing
+    def clientConnectionFailed(self, connector, reason):
+        """We failed at connecting."""
+        self.current_protocol = None
+        self.observer.connection_failed(reason)
+
+
+class UnsupportedOperationError(Exception):
+    """The operation is unsupported by the protocol version."""
+
+
+class ConnectionError(Exception):
+    """A connection error."""
+
+
+class AuthenticationError(Exception):
+    """An authentication error."""
+
+
+class NoSuchShareError(Exception):
+    """Error when there is no such share available."""
+
+
+class CapabilitiesError(Exception):
+    """A capabilities set/query related error."""
+
+
+class Client(object):
+    """U1 storage client facade."""
+    required_caps = frozenset([
+        "no-content", "account-info", "resumable-uploads",
+        "fix462230", "volumes", "generations",
+    ])
+
+    def __init__(self, realm=None, reactor=reactor):
+        """Create the instance.
+
+        'realm' is no longer used, but is left as param for API compatibility.
+
+        """
+        self.reactor = reactor
+        self.factory = SyncClientFactory(self)
+
+        self._status_lock = Lock()
+        self._status = "disconnected"
+        self._status_reason = None
+        self._status_waiting = []
+        self._active_waiters = set()
+
+        self.consumer_key = CONSUMER_KEY
+        self.consumer_secret = CONSUMER_SECRET
+
+    def force_shutdown(self):
+        """Forces the client to shut itself down."""
+        with self._status_lock:
+            self._status = "forced_shutdown"
+            self._reason = None
+            for waiter in self._active_waiters:
+                waiter.wakeAndRaise((ForcedShutdown("Forced shutdown"),
+                                     None, None))
+            self._active_waiters.clear()
+
+    def _get_waiter_locked(self):
+        """Gets a wait object for blocking waits.  Should be called with the
+        status lock held.
+        """
+        waiter = Waiter()
+        if self._status == "forced_shutdown":
+            raise ForcedShutdown("Forced shutdown")
+        self._active_waiters.add(waiter)
+        return waiter
+
+    def _get_waiter(self):
+        """Get a wait object for blocking waits.  Acquires the status lock."""
+        with self._status_lock:
+            return self._get_waiter_locked()
+
+    def _wait(self, waiter):
+        """Waits for the waiter."""
+        try:
+            return waiter.wait()
+        finally:
+            with self._status_lock:
+                if waiter in self._active_waiters:
+                    self._active_waiters.remove(waiter)
+
+    @log_timing
+    def _change_status(self, status, reason=None):
+        """Changes the client status.  Usually called from the reactor
+        thread.
+
+        """
+        with self._status_lock:
+            if self._status == "forced_shutdown":
+                return
+            self._status = status
+            self._status_reason = reason
+            waiting = self._status_waiting
+            self._status_waiting = []
+        for waiter in waiting:
+            waiter.wake((status, reason))
+
+    @log_timing
+    def _await_status_not(self, *ignore_statuses):
+        """Blocks until the client status changes, returning the new status.
+        Should never be called from the reactor thread.
+
+        """
+        with self._status_lock:
+            status = self._status
+            reason = self._status_reason
+            while status in ignore_statuses:
+                waiter = self._get_waiter_locked()
+                self._status_waiting.append(waiter)
+                self._status_lock.release()
+                try:
+                    status, reason = self._wait(waiter)
+                finally:
+                    self._status_lock.acquire()
+            if status == "forced_shutdown":
+                raise ForcedShutdown("Forced shutdown.")
+            return (status, reason)
+
+    def connection_failed(self, reason):
+        """Notification that connection failed."""
+        self._change_status("disconnected", reason)
+
+    def connected(self):
+        """Notification that connection succeeded."""
+        self._change_status("connected")
+
+    def disconnected(self, reason):
+        """Notification that we were disconnected."""
+        self._change_status("disconnected", reason)
+
+    def defer_from_thread(self, function, *args, **kwargs):
+        """Do twisted defer magic to get results and show exceptions."""
+        waiter = self._get_waiter()
+
+        @log_timing
+        def runner():
+            """inner."""
+            try:
+                d = function(*args, **kwargs)
+                if isinstance(d, defer.Deferred):
+                    d.addCallbacks(lambda r: waiter.wake((r, None, None)),
+                                   lambda f: waiter.wake((None, None, f)))
+                else:
+                    waiter.wake((d, None, None))
+            except Exception:
+                waiter.wake((None, sys.exc_info(), None))
+
+        self.reactor.callFromThread(runner)
+        result, exc_info, failure = self._wait(waiter)
+        if exc_info:
+            try:
+                raise exc_info[0], exc_info[1], exc_info[2]
+            finally:
+                exc_info = None
+        elif failure:
+            failure.raiseException()
+        else:
+            return result
+
+    @log_timing
+    def connect(self, host, port):
+        """Connect to host/port."""
+        def _connect():
+            """Deferred part."""
+            self.reactor.connectTCP(host, port, self.factory)
+        self._connect_inner(_connect)
+
+    @log_timing
+    def connect_ssl(self, host, port, no_verify):
+        """Connect to host/port using ssl."""
+        def _connect():
+            """deferred part."""
+            ctx = get_ssl_context(no_verify, host)
+            self.reactor.connectSSL(host, port, self.factory, ctx)
+        self._connect_inner(_connect)
+
+    @log_timing
+    def _connect_inner(self, _connect):
+        """Helper function for connecting."""
+        self._change_status("connecting")
+        self.reactor.callFromThread(_connect)
+        status, reason = self._await_status_not("connecting")
+        if status != "connected":
+            raise ConnectionError(reason.value)
+
+    @log_timing
+    def disconnect(self):
+        """Disconnect."""
+        if self.factory.current_protocol is not None:
+            self.reactor.callFromThread(
+                self.factory.current_protocol.transport.loseConnection)
+        self._await_status_not("connecting", "connected", "authenticated")
+
+    @log_timing
+    def simple_auth(self, username, password):
+        """Perform simple authorisation."""
+
+        @inlineCallbacks
+        def _wrapped_authenticate():
+            """Wrapped authenticate."""
+            try:
+                yield self.factory.current_protocol.simple_authenticate(
+                    username, password)
+            except Exception:
+                self.factory.current_protocol.transport.loseConnection()
+            else:
+                self._change_status("authenticated")
+
+        try:
+            self.defer_from_thread(_wrapped_authenticate)
+        except request.StorageProtocolError as e:
+            raise AuthenticationError(e)
+        status, reason = self._await_status_not("connected")
+        if status != "authenticated":
+            raise AuthenticationError(reason.value)
+
+    @log_timing
+    def set_capabilities(self):
+        """Set the capabilities with the server"""
+
+        client = self.factory.current_protocol
+
+        @log_timing
+        def set_caps_callback(req):
+            "Caps query succeeded"
+            if not req.accepted:
+                de = defer.fail("The server denied setting %s capabilities" %
+                                req.caps)
+                return de
+
+        @log_timing
+        def query_caps_callback(req):
+            "Caps query succeeded"
+            if req.accepted:
+                set_d = client.set_caps(self.required_caps)
+                set_d.addCallback(set_caps_callback)
+                return set_d
+            else:
+                # the server don't have the requested capabilities.
+                # return a failure for now, in the future we might want
+                # to reconnect to another server
+                de = defer.fail("The server don't have the requested"
+                                " capabilities: %s" % str(req.caps))
+                return de
+
+        @log_timing
+        def _wrapped_set_capabilities():
+            """Wrapped set_capabilities """
+            d = client.query_caps(self.required_caps)
+            d.addCallback(query_caps_callback)
+            return d
+
+        try:
+            self.defer_from_thread(_wrapped_set_capabilities)
+        except request.StorageProtocolError as e:
+            raise CapabilitiesError(e)
+
+    @log_timing
+    def get_root_info(self, volume_uuid):
+        """Returns the UUID of the applicable share root."""
+        if volume_uuid is None:
+            _get_root = self.factory.current_protocol.get_root
+            root = self.defer_from_thread(_get_root)
+            return (uuid.UUID(root), True)
+        else:
+            str_volume_uuid = str(volume_uuid)
+            volume = self._match_volume(
+                lambda v: str(v.volume_id) == str_volume_uuid)
+            if isinstance(volume, volumes.ShareVolume):
+                modify = volume.access_level == "Modify"
+            if isinstance(volume, volumes.UDFVolume):
+                modify = True
+            return (uuid.UUID(str(volume.node_id)), modify)
+
+    @log_timing
+    def resolve_path(self, share_uuid, root_uuid, path):
+        """Resolve path relative to the given root node."""
+
+        @inlineCallbacks
+        def _resolve_worker():
+            """Path resolution worker."""
+            node_uuid = root_uuid
+            local_path = path.strip('/')
+
+            while local_path != '':
+                local_path, name = os.path.split(local_path)
+                hashes = yield self._get_node_hashes(share_uuid)
+                content_hash = hashes.get(root_uuid, None)
+                if content_hash is None:
+                    raise KeyError("Content hash not available")
+                entries = yield self._get_dir_entries(share_uuid, root_uuid)
+                match_name = name.decode('utf-8')
+                match = None
+                for entry in entries:
+                    if match_name == entry.name:
+                        match = entry
+                        break
+
+                if match is None:
+                    raise KeyError("Path not found")
+
+                node_uuid = uuid.UUID(match.node)
+
+            returnValue(node_uuid)
+
+        return self.defer_from_thread(_resolve_worker)
+
+    @log_timing
+    def find_volume(self, volume_spec):
+        """Finds a share matching the given UUID.  Looks at both share UUIDs
+        and root node UUIDs."""
+
+        def match(s):
+            return (str(s.volume_id) == volume_spec or
+                    str(s.node_id) == volume_spec)
+
+        volume = self._match_volume(match)
+        return uuid.UUID(str(volume.volume_id))
+
+    @log_timing
+    def _match_volume(self, predicate):
+        """Finds a volume matching the given predicate."""
+        _list_shares = self.factory.current_protocol.list_volumes
+        r = self.defer_from_thread(_list_shares)
+        for volume in r.volumes:
+            if predicate(volume):
+                return volume
+        raise NoSuchShareError()
+
+    @log_timing
+    def build_tree(self, share_uuid, root_uuid):
+        """Builds and returns a tree representing the metadata for the given
+        subtree in the given share.
+
+        @param share_uuid: the share UUID or None for the user's volume
+        @param root_uuid: the root UUID of the subtree (must be a directory)
+        @return: a MergeNode tree
+
+        """
+        root = MergeNode(node_type=DIRECTORY, uuid=root_uuid)
+
+        @log_timing
+        @inlineCallbacks
+        def _get_root_content_hash():
+            """Obtain the content hash for the root node."""
+            result = yield self._get_node_hashes(share_uuid)
+            returnValue(result.get(root_uuid, None))
+
+        root.content_hash = self.defer_from_thread(_get_root_content_hash)
+        if root.content_hash is None:
+            raise ValueError("No content available for node %s" % root_uuid)
+
+        @log_timing
+        @inlineCallbacks
+        def _get_children(parent_uuid, parent_content_hash):
+            """Obtain a sequence of MergeNodes corresponding to a node's
+            immediate children.
+
+            """
+            entries = yield self._get_dir_entries(share_uuid, parent_uuid)
+            children = {}
+            for entry in entries:
+                if should_sync(entry.name):
+                    child = MergeNode(node_type=entry.node_type,
+                                      uuid=uuid.UUID(entry.node))
+                    children[entry.name] = child
+
+            content_hashes = yield self._get_node_hashes(share_uuid)
+            for child in children.itervalues():
+                child.content_hash = content_hashes.get(child.uuid, None)
+
+            returnValue(children)
+
+        need_children = [root]
+        while need_children:
+            node = need_children.pop()
+            if node.content_hash is not None:
+                children = self.defer_from_thread(_get_children, node.uuid,
+                                                  node.content_hash)
+                node.children = children
+                for child in children.itervalues():
+                    if child.node_type == DIRECTORY:
+                        need_children.append(child)
+
+        return root
+
+    @log_timing
+    @defer.inlineCallbacks
+    def _get_dir_entries(self, share_uuid, node_uuid):
+        """Get raw dir entries for the given directory."""
+        result = yield self.factory.current_protocol.get_delta(
+            share_str(share_uuid), from_scratch=True)
+        node_uuid = share_str(node_uuid)
+        children = []
+        for n in result.response:
+            if n.parent_id == node_uuid:
+                # adapt here some attrs so we don't need to change ALL the code
+                n.node_type = DIRECTORY if n.file_type == delta_DIR else FILE
+                n.node = n.node_id
+                children.append(n)
+        defer.returnValue(children)
+
+    @log_timing
+    def download_string(self, share_uuid, node_uuid, content_hash):
+        """Reads a file from the server into a string."""
+        output = StringIO()
+        self._download_inner(share_uuid=share_uuid, node_uuid=node_uuid,
+                             content_hash=content_hash, output=output)
+        return output.getValue()
+
+    @log_timing
+    def download_file(self, share_uuid, node_uuid, content_hash, filename):
+        """Downloads a file from the server."""
+        partial_filename = "%s.u1partial" % filename
+        output = open(partial_filename, "w")
+
+        @log_timing
+        def rename_file():
+            """Renames the temporary file to the final name."""
+            output.close()
+            os.rename(partial_filename, filename)
+
+        @log_timing
+        def delete_file():
+            """Deletes the temporary file."""
+            output.close()
+            os.remove(partial_filename)
+
+        self._download_inner(share_uuid=share_uuid, node_uuid=node_uuid,
+                             content_hash=content_hash, output=output,
+                             on_success=rename_file, on_failure=delete_file)
+
+    @log_timing
+    def _download_inner(self, share_uuid, node_uuid, content_hash, output,
+                        on_success=lambda: None, on_failure=lambda: None):
+        """Helper function for content downloads."""
+        dec = zlib.decompressobj()
+
+        @log_timing
+        def write_data(data):
+            """Helper which writes data to the output file."""
+            uncompressed_data = dec.decompress(data)
+            output.write(uncompressed_data)
+
+        @log_timing
+        def finish_download(value):
+            """Helper which finishes the download."""
+            uncompressed_data = dec.flush()
+            output.write(uncompressed_data)
+            on_success()
+            return value
+
+        @log_timing
+        def abort_download(value):
+            """Helper which aborts the download."""
+            on_failure()
+            return value
+
+        @log_timing
+        def _download():
+            """Async helper."""
+            _get_content = self.factory.current_protocol.get_content
+            d = _get_content(share_str(share_uuid), str(node_uuid),
+                             content_hash, callback=write_data)
+            d.addCallbacks(finish_download, abort_download)
+            return d
+
+        self.defer_from_thread(_download)
+
+    @log_timing
+    def create_directory(self, share_uuid, parent_uuid, name):
+        """Creates a directory on the server."""
+        r = self.defer_from_thread(self.factory.current_protocol.make_dir,
+                                   share_str(share_uuid), str(parent_uuid),
+                                   name)
+        return uuid.UUID(r.new_id)
+
+    @log_timing
+    def create_file(self, share_uuid, parent_uuid, name):
+        """Creates a file on the server."""
+        r = self.defer_from_thread(self.factory.current_protocol.make_file,
+                                   share_str(share_uuid), str(parent_uuid),
+                                   name)
+        return uuid.UUID(r.new_id)
+
+    @log_timing
+    def create_symlink(self, share_uuid, parent_uuid, name, target):
+        """Creates a symlink on the server."""
+        raise UnsupportedOperationError("Protocol does not support symlinks")
+
+    @log_timing
+    def upload_string(self, share_uuid, node_uuid, old_content_hash,
+                      content_hash, content):
+        """Uploads a string to the server as file content."""
+        crc = crc32(content, 0)
+        compressed_content = zlib.compress(content, 9)
+        compressed = StringIO(compressed_content)
+        self.defer_from_thread(self.factory.current_protocol.put_content,
+                               share_str(share_uuid), str(node_uuid),
+                               old_content_hash, content_hash,
+                               crc, len(content), len(compressed_content),
+                               compressed)
+
+    @log_timing
+    def upload_file(self, share_uuid, node_uuid, old_content_hash,
+                    content_hash, filename):
+        """Uploads a file to the server."""
+        parent_dir = os.path.split(filename)[0]
+        unique_filename = os.path.join(parent_dir, "." + str(uuid.uuid4()))
+
+        class StagingFile(object):
+            """An object which tracks data being compressed for staging."""
+            def __init__(self, stream):
+                """Initialize a compression object."""
+                self.crc32 = 0
+                self.enc = zlib.compressobj(9)
+                self.size = 0
+                self.compressed_size = 0
+                self.stream = stream
+
+            def write(self, bytes):
+                """Compress bytes, keeping track of length and crc32."""
+                self.size += len(bytes)
+                self.crc32 = crc32(bytes, self.crc32)
+                compressed_bytes = self.enc.compress(bytes)
+                self.compressed_size += len(compressed_bytes)
+                self.stream.write(compressed_bytes)
+
+            def finish(self):
+                """Finish staging compressed data."""
+                compressed_bytes = self.enc.flush()
+                self.compressed_size += len(compressed_bytes)
+                self.stream.write(compressed_bytes)
+
+        with open(unique_filename, "w+") as compressed:
+            os.remove(unique_filename)
+            with open(filename, "r") as original:
+                staging = StagingFile(compressed)
+                shutil.copyfileobj(original, staging)
+            staging.finish()
+            compressed.seek(0)
+            self.defer_from_thread(self.factory.current_protocol.put_content,
+                                   share_str(share_uuid), str(node_uuid),
+                                   old_content_hash, content_hash,
+                                   staging.crc32,
+                                   staging.size, staging.compressed_size,
+                                   compressed)
+
+    @log_timing
+    def move(self, share_uuid, parent_uuid, name, node_uuid):
+        """Moves a file on the server."""
+        self.defer_from_thread(self.factory.current_protocol.move,
+                               share_str(share_uuid), str(node_uuid),
+                               str(parent_uuid), name)
+
+    @log_timing
+    def unlink(self, share_uuid, node_uuid):
+        """Unlinks a file on the server."""
+        self.defer_from_thread(self.factory.current_protocol.unlink,
+                               share_str(share_uuid), str(node_uuid))
+
+    @log_timing
+    @defer.inlineCallbacks
+    def _get_node_hashes(self, share_uuid):
+        """Fetches hashes for the given nodes."""
+        result = yield self.factory.current_protocol.get_delta(
+            share_str(share_uuid), from_scratch=True)
+        hashes = {}
+        for fid in result.response:
+            node_uuid = uuid.UUID(fid.node_id)
+            hashes[node_uuid] = fid.content_hash
+        defer.returnValue(hashes)
+
+    @log_timing
+    def get_incoming_shares(self):
+        """Returns a list of incoming shares as (name, uuid, accepted)
+        tuples.
+
+        """
+        _list_shares = self.factory.current_protocol.list_shares
+        r = self.defer_from_thread(_list_shares)
+        return [(s.name, s.id, s.other_visible_name,
+                 s.accepted, s.access_level)
+                for s in r.shares if s.direction == "to_me"]

=== added file 'magicicada/u1sync/constants.py'
--- magicicada/u1sync/constants.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/constants.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,26 @@
+# Copyright 2009 Canonical Ltd.
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Assorted constant definitions which don't fit anywhere else."""
+
+import re
+
+# the name of the directory u1sync uses to keep metadata about a mirror
+METADATA_DIR_NAME = u".ubuntuone-sync"
+
+# filenames to ignore
+SPECIAL_FILE_RE = re.compile(".*\\.("
+                             "(u1)?partial|part|"
+                             "(u1)?conflict(\\.[0-9]+)?)$")

=== added file 'magicicada/u1sync/genericmerge.py'
--- magicicada/u1sync/genericmerge.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/genericmerge.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,86 @@
+# Copyright 2009 Canonical Ltd.
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""A generic abstraction for merge operations on directory trees."""
+
+from itertools import chain
+
+from ubuntuone.storageprotocol.dircontent_pb2 import DIRECTORY
+
+
+class MergeNode(object):
+    """A filesystem node.  Should generally be treated as immutable."""
+    def __init__(self, node_type, content_hash=None, uuid=None, children=None,
+                 conflict_info=None):
+        """Initializes a node instance."""
+        self.node_type = node_type
+        self.children = children
+        self.uuid = uuid
+        self.content_hash = content_hash
+        self.conflict_info = conflict_info
+
+    def __eq__(self, other):
+        """Equality test."""
+        if type(other) is not type(self):
+            return False
+        return (self.node_type == other.node_type and
+                self.children == other.children and
+                self.uuid == other.uuid and
+                self.content_hash == other.content_hash and
+                self.conflict_info == other.conflict_info)
+
+    def __ne__(self, other):
+        """Non-equality test."""
+        return not self.__eq__(other)
+
+
+def show_tree(tree, indent="", name="/"):
+    """Prints a tree."""
+    if tree.node_type == DIRECTORY:
+        type_str = "DIR "
+    else:
+        type_str = "FILE"
+    print "%s%-36s %s %s  %s" % (indent, tree.uuid, type_str, name,
+                                 tree.content_hash)
+    if tree.node_type == DIRECTORY and tree.children is not None:
+        for name in sorted(tree.children.keys()):
+            subtree = tree.children[name]
+            show_tree(subtree, indent="  " + indent, name=name)
+
+
+def generic_merge(trees, pre_merge, post_merge, partial_parent, name):
+    """Generic tree merging function."""
+
+    partial_result = pre_merge(nodes=trees, name=name,
+                               partial_parent=partial_parent)
+
+    def tree_children(tree):
+        """Returns children if tree is not None"""
+        return tree.children if tree is not None else None
+
+    child_dicts = [tree_children(t) or {} for t in trees]
+    child_names = set(chain(*[cs.iterkeys() for cs in child_dicts]))
+    child_results = {}
+    for child_name in child_names:
+        subtrees = [cs.get(child_name, None) for cs in child_dicts]
+        child_result = generic_merge(trees=subtrees,
+                                     pre_merge=pre_merge,
+                                     post_merge=post_merge,
+                                     partial_parent=partial_result,
+                                     name=child_name)
+        child_results[child_name] = child_result
+
+    return post_merge(nodes=trees, partial_result=partial_result,
+                      child_results=child_results)

=== added file 'magicicada/u1sync/main.py'
--- magicicada/u1sync/main.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/main.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,443 @@
+# Copyright 2009 Canonical Ltd.
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""A prototype directory sync client."""
+
+from __future__ import with_statement
+
+import signal
+import os
+import sys
+import uuid
+
+from errno import EEXIST
+from optparse import OptionParser, SUPPRESS_HELP
+from Queue import Queue
+
+import gobject
+
+import ubuntuone.storageprotocol.dircontent_pb2 as dircontent_pb2
+from ubuntuone.storageprotocol.dircontent_pb2 import DIRECTORY, SYMLINK
+from twisted.internet import reactor
+
+from magicicada.u1sync import metadata
+from magicicada.u1sync.client import (
+    ConnectionError, AuthenticationError, NoSuchShareError,
+    ForcedShutdown, Client)
+from magicicada.u1sync.constants import METADATA_DIR_NAME
+from magicicada.u1sync.genericmerge import show_tree, generic_merge
+from magicicada.u1sync.merge import (
+    SyncMerge, ClobberServerMerge, ClobberLocalMerge, merge_trees)
+from magicicada.u1sync.scan import scan_directory
+from magicicada.u1sync.sync import download_tree, upload_tree
+from magicicada.u1sync.utils import safe_mkdir
+
+
+gobject.set_application_name('u1sync')
+
+DEFAULT_MERGE_ACTION = 'auto'
+MERGE_ACTIONS = {
+    # action: (merge_class, should_upload, should_download)
+    'sync': (SyncMerge, True, True),
+    'clobber-server': (ClobberServerMerge, True, False),
+    'clobber-local': (ClobberLocalMerge, False, True),
+    'upload': (SyncMerge, True, False),
+    'download': (SyncMerge, False, True),
+    'auto': None  # special case
+}
+NODE_TYPE_ENUM = dircontent_pb2._NODETYPE
+
+
+def node_type_str(node_type):
+    """Converts a numeric node type to a human-readable string."""
+    return NODE_TYPE_ENUM.values_by_number[node_type].name
+
+
+class ReadOnlyShareError(Exception):
+    """Share is read-only."""
+
+
+class DirectoryAlreadyInitializedError(Exception):
+    """The directory has already been initialized."""
+
+
+class DirectoryNotInitializedError(Exception):
+    """The directory has not been initialized."""
+
+
+class NoParentError(Exception):
+    """A node has no parent."""
+
+
+class TreesDiffer(Exception):
+    """Raised when diff tree differs."""
+    def __init__(self, quiet):
+        self.quiet = quiet
+
+
+def do_init(client, share_spec, directory, quiet, subtree_path,
+            metadata=metadata):
+    """Initializes a directory for syncing, and syncs it."""
+    info = metadata.Metadata()
+
+    if share_spec is not None:
+        info.share_uuid = client.find_volume(share_spec)
+    else:
+        info.share_uuid = None
+
+    if subtree_path is not None:
+        info.path = subtree_path
+    else:
+        info.path = "/"
+
+    if not quiet:
+        print "\nInitializing directory..."
+    safe_mkdir(directory)
+
+    metadata_dir = os.path.join(directory, METADATA_DIR_NAME)
+    try:
+        os.mkdir(metadata_dir)
+    except OSError as e:
+        if e.errno == EEXIST:
+            raise DirectoryAlreadyInitializedError(directory)
+        else:
+            raise
+
+    if not quiet:
+        print "\nWriting mirror metadata..."
+    metadata.write(metadata_dir, info)
+
+    if not quiet:
+        print "\nDone."
+
+
+def do_sync(client, directory, action, dry_run, quiet):
+    """Synchronizes a directory with the given share."""
+    absolute_path = os.path.abspath(directory)
+    while True:
+        metadata_dir = os.path.join(absolute_path, METADATA_DIR_NAME)
+        if os.path.exists(metadata_dir):
+            break
+        if absolute_path == "/":
+            raise DirectoryNotInitializedError(directory)
+        absolute_path = os.path.split(absolute_path)[0]
+
+    if not quiet:
+        print "\nReading mirror metadata..."
+    info = metadata.read(metadata_dir)
+
+    top_uuid, writable = client.get_root_info(info.share_uuid)
+
+    if info.root_uuid is None:
+        info.root_uuid = client.resolve_path(info.share_uuid, top_uuid,
+                                             info.path)
+
+    if action == 'auto':
+        if writable:
+            action = 'sync'
+        else:
+            action = 'download'
+    merge_type, should_upload, should_download = MERGE_ACTIONS[action]
+    if should_upload and not writable:
+        raise ReadOnlyShareError(info.share_uuid)
+
+    if not quiet:
+        print "\nScanning directory..."
+    local_tree = scan_directory(absolute_path, quiet=quiet)
+
+    if not quiet:
+        print "\nFetching metadata..."
+    remote_tree = client.build_tree(info.share_uuid, info.root_uuid)
+    if not quiet:
+        show_tree(remote_tree)
+
+    if not quiet:
+        print "\nMerging trees..."
+    merged_tree = merge_trees(old_local_tree=info.local_tree,
+                              local_tree=local_tree,
+                              old_remote_tree=info.remote_tree,
+                              remote_tree=remote_tree,
+                              merge_action=merge_type())
+    if not quiet:
+        show_tree(merged_tree)
+
+    if not quiet:
+        print "\nSyncing content..."
+    if should_download:
+        info.local_tree = download_tree(merged_tree=merged_tree,
+                                        local_tree=local_tree,
+                                        client=client,
+                                        share_uuid=info.share_uuid,
+                                        path=absolute_path, dry_run=dry_run,
+                                        quiet=quiet)
+    else:
+        info.local_tree = local_tree
+    if should_upload:
+        info.remote_tree = upload_tree(merged_tree=merged_tree,
+                                       remote_tree=remote_tree,
+                                       client=client,
+                                       share_uuid=info.share_uuid,
+                                       path=absolute_path, dry_run=dry_run,
+                                       quiet=quiet)
+    else:
+        info.remote_tree = remote_tree
+
+    if not dry_run:
+        if not quiet:
+            print "\nUpdating mirror metadata..."
+        metadata.write(metadata_dir, info)
+
+    if not quiet:
+        print "\nDone."
+
+
+def do_list_shares(client):
+    """Lists available (incoming) shares."""
+    shares = client.get_incoming_shares()
+    for (name, id, user, accepted, access) in shares:
+        if not accepted:
+            status = " [not accepted]"
+        else:
+            status = ""
+        name = name.encode("utf-8")
+        user = user.encode("utf-8")
+        print "%s  %s (from %s) [%s]%s" % (id, name, user, access, status)
+
+
+def do_diff(client, share_spec, directory, quiet, subtree_path,
+            ignore_symlinks=True):
+    """Diffs a local directory with the server."""
+    if share_spec is not None:
+        share_uuid = client.find_volume(share_spec)
+    else:
+        share_uuid = None
+    if subtree_path is None:
+        subtree_path = '/'
+
+    root_uuid, writable = client.get_root_info(share_uuid)
+    subtree_uuid = client.resolve_path(share_uuid, root_uuid, subtree_path)
+    local_tree = scan_directory(directory, quiet=True)
+    remote_tree = client.build_tree(share_uuid, subtree_uuid)
+
+    def pre_merge(nodes, name, partial_parent):
+        """Compares nodes and prints differences."""
+        (local_node, remote_node) = nodes
+        (parent_display_path, parent_differs) = partial_parent
+        display_path = os.path.join(parent_display_path, name.encode("UTF-8"))
+        differs = True
+        if local_node is None:
+            if not quiet:
+                print "%s missing from client" % display_path
+        elif remote_node is None:
+            if ignore_symlinks and local_node.node_type == SYMLINK:
+                differs = False
+            elif not quiet:
+                print "%s missing from server" % display_path
+        elif local_node.node_type != remote_node.node_type:
+            local_type = node_type_str(local_node.node_type)
+            remote_type = node_type_str(remote_node.node_type)
+            if not quiet:
+                print ("%s node types differ (client: %s, server: %s)" %
+                       (display_path, local_type, remote_type))
+        elif (local_node.node_type != DIRECTORY and
+                local_node.content_hash != remote_node.content_hash):
+            local_content = local_node.content_hash
+            remote_content = remote_node.content_hash
+            if not quiet:
+                print ("%s has different content (client: %s, server: %s)" %
+                       (display_path, local_content, remote_content))
+        else:
+            differs = False
+        return (display_path, differs)
+
+    def post_merge(nodes, partial_result, child_results):
+        """Aggregates 'differs' flags."""
+        (display_path, differs) = partial_result
+        return differs or any(child_results.itervalues())
+
+    differs = generic_merge(trees=[local_tree, remote_tree],
+                            pre_merge=pre_merge, post_merge=post_merge,
+                            partial_parent=("", False), name=u"")
+    if differs:
+        raise TreesDiffer(quiet=quiet)
+
+
+def do_main(argv):
+    """The main user-facing portion of the script."""
+    usage = (
+        "Usage: %prog [options] [DIRECTORY]\n"
+        "       %prog --list-shares [options]\n"
+        "       %prog --init [--share=SHARE_UUID] [options] DIRECTORY\n"
+        "       %prog --diff [--share=SHARE_UUID] [options] DIRECTORY")
+    parser = OptionParser(usage=usage)
+    parser.add_option("--port", dest="port", metavar="PORT",
+                      default=443,
+                      help="The port on which to connect to the server")
+    parser.add_option("--host", dest="host", metavar="HOST",
+                      default='fs-1.one.ubuntu.com',
+                      help="The server address")
+
+    action_list = ", ".join(sorted(MERGE_ACTIONS.keys()))
+    parser.add_option("--action", dest="action", metavar="ACTION",
+                      default=None,
+                      help="Select a sync action (%s; default is %s)" %
+                           (action_list, DEFAULT_MERGE_ACTION))
+    parser.add_option("--dry-run", action="store_true", dest="dry_run",
+                      default=False, help="Do a dry run without actually "
+                                          "making changes")
+    parser.add_option("--quiet", action="store_true", dest="quiet",
+                      default=False, help="Produces less output")
+    parser.add_option("--list-shares", action="store_const", dest="mode",
+                      const="list-shares", default="sync",
+                      help="List available shares")
+    parser.add_option("--init", action="store_const", dest="mode",
+                      const="init",
+                      help="Initialize a local directory for syncing")
+    parser.add_option("--no-ssl-verify", action="store_true",
+                      dest="no_ssl_verify",
+                      default=False, help=SUPPRESS_HELP)
+    parser.add_option("--diff", action="store_const", dest="mode",
+                      const="diff",
+                      help="Compare tree on server with local tree "
+                           "(does not require previous --init)")
+    parser.add_option("--share", dest="share", metavar="SHARE_UUID",
+                      default=None,
+                      help="Sync the directory with a share rather than the "
+                           "user's own volume")
+    parser.add_option("--subtree", dest="subtree", metavar="PATH",
+                      default=None,
+                      help="Mirror a subset of the share or volume")
+
+    (options, args) = parser.parse_args(args=list(argv[1:]))
+
+    if options.share is not None and options.mode not in ("init", "diff"):
+        parser.error("--share is only valid with --init or --diff")
+
+    directory = None
+    if options.mode in ("sync", "init" or "diff"):
+        if len(args) > 1:
+            parser.error("Too many arguments")
+        elif len(args) < 1:
+            if options.mode == "init" or options.mode == "diff":
+                parser.error("--%s requires a directory to "
+                             "be specified" % options.mode)
+            else:
+                directory = "."
+        else:
+            directory = args[0]
+    if options.mode in ("init", "list-shares", "diff"):
+        if options.action is not None:
+            parser.error("--%s does not take the --action parameter" %
+                         options.mode)
+        if options.dry_run:
+            parser.error("--%s does not take the --dry-run parameter" %
+                         options.mode)
+    if options.mode == "list-shares":
+        if len(args) != 0:
+            parser.error("--list-shares does not take a directory")
+    if options.mode not in ("init", "diff"):
+        if options.subtree is not None:
+            parser.error("--%s does not take the --subtree parameter" %
+                         options.mode)
+
+    if options.action is not None and options.action not in MERGE_ACTIONS:
+        parser.error("--action: Unknown action %s" % options.action)
+
+    if options.action is None:
+        options.action = DEFAULT_MERGE_ACTION
+
+    if options.share is not None:
+        try:
+            uuid.UUID(options.share)
+        except ValueError as e:
+            parser.error("Invalid --share argument: %s" % e)
+        share_spec = options.share
+    else:
+        share_spec = None
+
+    client = Client(reactor=reactor)
+
+    signal.signal(signal.SIGINT, lambda s, f: client.force_shutdown())
+    signal.signal(signal.SIGTERM, lambda s, f: client.force_shutdown())
+
+    def run_client():
+        """Run the blocking client."""
+        client.connect_ssl(
+            options.host, int(options.port), options.no_ssl_verify)
+
+        try:
+            client.set_capabilities()
+
+            if options.mode == "sync":
+                do_sync(client=client, directory=directory,
+                        action=options.action,
+                        dry_run=options.dry_run, quiet=options.quiet)
+            elif options.mode == "init":
+                do_init(client=client, share_spec=share_spec,
+                        directory=directory,
+                        quiet=options.quiet, subtree_path=options.subtree)
+            elif options.mode == "list-shares":
+                do_list_shares(client=client)
+            elif options.mode == "diff":
+                do_diff(client=client, share_spec=share_spec,
+                        directory=directory,
+                        quiet=options.quiet, subtree_path=options.subtree,
+                        ignore_symlinks=False)
+        finally:
+            client.disconnect()
+
+    def capture_exception(queue, func):
+        """Capture the exception from calling func."""
+        try:
+            func()
+        except Exception:
+            queue.put(sys.exc_info())
+        else:
+            queue.put(None)
+        finally:
+            reactor.callWhenRunning(reactor.stop)
+
+    queue = Queue()
+    reactor.callInThread(capture_exception, queue, run_client)
+    reactor.run(installSignalHandlers=False)
+    exc_info = queue.get(True, 0.1)
+    if exc_info:
+        raise exc_info[0], exc_info[1], exc_info[2]
+
+
+def main(*argv):
+    """Top-level main function."""
+    try:
+        do_main(argv=argv)
+    except AuthenticationError as e:
+        print "Authentication failed: %s" % e
+    except ConnectionError as e:
+        print "Connection failed: %s" % e
+    except DirectoryNotInitializedError:
+        print "Directory not initialized; use --init [DIRECTORY] to init it."
+    except DirectoryAlreadyInitializedError:
+        print "Directory already initialized."
+    except NoSuchShareError:
+        print "No matching share found."
+    except ReadOnlyShareError:
+        print "The selected action isn't possible on a read-only share."
+    except (ForcedShutdown, KeyboardInterrupt):
+        print "Interrupted!"
+    except TreesDiffer as e:
+        if not e.quiet:
+            print "Trees differ."
+    else:
+        return 0
+    return 1

=== added file 'magicicada/u1sync/merge.py'
--- magicicada/u1sync/merge.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/merge.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,181 @@
+# Copyright 2009 Canonical Ltd.
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Code for merging changes between modified trees."""
+
+from __future__ import with_statement
+
+import os
+import uuid
+
+from ubuntuone.storageprotocol.dircontent_pb2 import DIRECTORY
+
+from magicicada.u1sync.genericmerge import MergeNode, generic_merge
+
+
+class NodeTypeMismatchError(Exception):
+    """Node types don't match."""
+
+
+def merge_trees(old_local_tree, local_tree, old_remote_tree, remote_tree,
+                merge_action):
+    """Performs a tree merge using the given merge action."""
+
+    def pre_merge(nodes, name, partial_parent):
+        """Accumulates path and determines merged node type."""
+        old_local_node, local_node, old_remote_node, remote_node = nodes
+        (parent_path, parent_type) = partial_parent
+        path = os.path.join(parent_path, name.encode("utf-8"))
+        node_type = merge_action.get_node_type(old_local_node=old_local_node,
+                                               local_node=local_node,
+                                               old_remote_node=old_remote_node,
+                                               remote_node=remote_node,
+                                               path=path)
+        return (path, node_type)
+
+    def post_merge(nodes, partial_result, child_results):
+        """Drops deleted children and merges node."""
+        old_local_node, local_node, old_remote_node, remote_node = nodes
+        (path, node_type) = partial_result
+        if node_type == DIRECTORY:
+            merged_children = dict(
+                (name, child) for (name, child) in child_results.iteritems()
+                if child is not None)
+        else:
+            merged_children = None
+        return merge_action.merge_node(old_local_node=old_local_node,
+                                       local_node=local_node,
+                                       old_remote_node=old_remote_node,
+                                       remote_node=remote_node,
+                                       node_type=node_type,
+                                       merged_children=merged_children)
+
+    return generic_merge(trees=[old_local_tree, local_tree,
+                                old_remote_tree, remote_tree],
+                         pre_merge=pre_merge, post_merge=post_merge,
+                         name=u"", partial_parent=("", None))
+
+
+class SyncMerge(object):
+    """Performs a bidirectional sync merge."""
+
+    def get_node_type(self, old_local_node, local_node,
+                      old_remote_node, remote_node, path):
+        """Requires that all node types match."""
+        node_type = None
+        for node in (old_local_node, local_node, remote_node):
+            if node is not None:
+                if node_type is not None:
+                    if node.node_type != node_type:
+                        message = "Node types don't match for %s" % path
+                        raise NodeTypeMismatchError(message)
+                else:
+                    node_type = node.node_type
+        return node_type
+
+    def merge_node(self, old_local_node, local_node,
+                   old_remote_node, remote_node, node_type, merged_children):
+        """Performs bidirectional merge of node state."""
+
+        def node_content_hash(node):
+            """Returns node content hash if node is not None"""
+            return node.content_hash if node is not None else None
+
+        old_local_content_hash = node_content_hash(old_local_node)
+        local_content_hash = node_content_hash(local_node)
+        old_remote_content_hash = node_content_hash(old_remote_node)
+        remote_content_hash = node_content_hash(remote_node)
+
+        locally_deleted = old_local_node is not None and local_node is None
+        deleted_on_server = old_remote_node is not None and remote_node is None
+        # updated means modified or created
+        locally_updated = (not locally_deleted and
+                           old_local_content_hash != local_content_hash)
+        updated_on_server = (not deleted_on_server and
+                             old_remote_content_hash != remote_content_hash)
+
+        has_merged_children = (merged_children is not None and
+                               len(merged_children) > 0)
+
+        either_node_exists = local_node is not None or remote_node is not None
+        should_delete = (
+            (locally_deleted and not updated_on_server) or
+            (deleted_on_server and not locally_updated))
+
+        if (either_node_exists and not should_delete) or has_merged_children:
+            if (node_type != DIRECTORY and locally_updated and
+                    updated_on_server and
+                    local_content_hash != remote_content_hash):
+                # local_content_hash will become the merged content_hash;
+                # save remote_content_hash in conflict info
+                conflict_info = (str(uuid.uuid4()), remote_content_hash)
+            else:
+                conflict_info = None
+            node_uuid = remote_node.uuid if remote_node is not None else None
+            if locally_updated:
+                content_hash = local_content_hash or remote_content_hash
+            else:
+                content_hash = remote_content_hash or local_content_hash
+            return MergeNode(
+                node_type=node_type, uuid=node_uuid, children=merged_children,
+                content_hash=content_hash, conflict_info=conflict_info)
+        else:
+            return None
+
+
+class ClobberServerMerge(object):
+    """Clobber server to match local state."""
+
+    def get_node_type(self, old_local_node, local_node,
+                      old_remote_node, remote_node, path):
+        """Return local node type."""
+        if local_node is not None:
+            return local_node.node_type
+        else:
+            return None
+
+    def merge_node(self, old_local_node, local_node,
+                   old_remote_node, remote_node, node_type, merged_children):
+        """Copy local node and associate with remote uuid (if applicable)."""
+        if local_node is None:
+            return None
+        if remote_node is not None:
+            node_uuid = remote_node.uuid
+        else:
+            node_uuid = None
+        return MergeNode(
+            node_type=local_node.node_type, uuid=node_uuid,
+            content_hash=local_node.content_hash, children=merged_children)
+
+
+class ClobberLocalMerge(object):
+    """Clobber local state to match server."""
+
+    def get_node_type(self, old_local_node, local_node,
+                      old_remote_node, remote_node, path):
+        """Return remote node type."""
+        if remote_node is not None:
+            return remote_node.node_type
+        else:
+            return None
+
+    def merge_node(self, old_local_node, local_node,
+                   old_remote_node, remote_node, node_type, merged_children):
+        """Copy the remote node."""
+        if remote_node is None:
+            return None
+        return MergeNode(
+            node_type=node_type, uuid=remote_node.uuid,
+            content_hash=remote_node.content_hash, children=merged_children)

=== added file 'magicicada/u1sync/metadata.py'
--- magicicada/u1sync/metadata.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/metadata.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,155 @@
+# Copyright 2009 Canonical Ltd.
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Routines for loading/storing u1sync mirror metadata."""
+
+from __future__ import with_statement
+
+import os
+import uuid
+
+from contextlib import contextmanager
+import cPickle as pickle
+from errno import ENOENT
+
+from ubuntuone.storageprotocol.dircontent_pb2 import DIRECTORY
+
+from magicicada.u1sync.merge import MergeNode
+from magicicada.u1sync.utils import safe_unlink
+
+
+class Metadata(object):
+    """Object representing mirror metadata."""
+
+    def __init__(self, local_tree=None, remote_tree=None, share_uuid=None,
+                 root_uuid=None, path=None):
+        """Populate fields."""
+        self.local_tree = local_tree
+        self.remote_tree = remote_tree
+        self.share_uuid = share_uuid
+        self.root_uuid = root_uuid
+        self.path = path
+
+
+def read(metadata_dir):
+    """Read metadata for a mirror rooted at directory."""
+    index_file = os.path.join(metadata_dir, "local-index")
+    share_uuid_file = os.path.join(metadata_dir, "share-uuid")
+    root_uuid_file = os.path.join(metadata_dir, "root-uuid")
+    path_file = os.path.join(metadata_dir, "path")
+
+    index = read_pickle_file(index_file, {})
+    share_uuid = read_uuid_file(share_uuid_file)
+    root_uuid = read_uuid_file(root_uuid_file)
+    path = read_string_file(path_file, '/')
+
+    local_tree = index.get("tree", None)
+    remote_tree = index.get("remote_tree", None)
+
+    if local_tree is None:
+        local_tree = MergeNode(node_type=DIRECTORY, children={})
+    if remote_tree is None:
+        remote_tree = MergeNode(node_type=DIRECTORY, children={})
+
+    return Metadata(local_tree=local_tree, remote_tree=remote_tree,
+                    share_uuid=share_uuid, root_uuid=root_uuid,
+                    path=path)
+
+
+def write(metadata_dir, info):
+    """Writes all metadata for the mirror rooted at directory."""
+    share_uuid_file = os.path.join(metadata_dir, "share-uuid")
+    root_uuid_file = os.path.join(metadata_dir, "root-uuid")
+    index_file = os.path.join(metadata_dir, "local-index")
+    path_file = os.path.join(metadata_dir, "path")
+    if info.share_uuid is not None:
+        write_uuid_file(share_uuid_file, info.share_uuid)
+    else:
+        safe_unlink(share_uuid_file)
+    if info.root_uuid is not None:
+        write_uuid_file(root_uuid_file, info.root_uuid)
+    else:
+        safe_unlink(root_uuid_file)
+    write_string_file(path_file, info.path)
+    write_pickle_file(index_file, {"tree": info.local_tree,
+                                   "remote_tree": info.remote_tree})
+
+
+def write_pickle_file(filename, value):
+    """Writes a pickled python object to a file."""
+    with atomic_update_file(filename) as stream:
+        pickle.dump(value, stream, 2)
+
+
+def write_string_file(filename, value):
+    """Writes a string to a file with an added line feed, or
+    deletes the file if value is None.
+    """
+    if value is not None:
+        with atomic_update_file(filename) as stream:
+            stream.write(value)
+            stream.write('\n')
+    else:
+        safe_unlink(filename)
+
+
+def write_uuid_file(filename, value):
+    """Writes a UUID to a file."""
+    write_string_file(filename, str(value))
+
+
+def read_pickle_file(filename, default_value=None):
+    """Reads a pickled python object from a file."""
+    try:
+        with open(filename, "rb") as stream:
+            return pickle.load(stream)
+    except IOError as e:
+        if e.errno != ENOENT:
+            raise
+        return default_value
+
+
+def read_string_file(filename, default_value=None):
+    """Reads a string from a file, discarding the final character."""
+    try:
+        with open(filename, "r") as stream:
+            return stream.read()[:-1]
+    except IOError as e:
+        if e.errno != ENOENT:
+            raise
+        return default_value
+
+
+def read_uuid_file(filename, default_value=None):
+    """Reads a UUID from a file."""
+    try:
+        with open(filename, "r") as stream:
+            return uuid.UUID(stream.read()[:-1])
+    except IOError as e:
+        if e.errno != ENOENT:
+            raise
+        return default_value
+
+
+@contextmanager
+def atomic_update_file(filename):
+    """Returns a context manager for atomically updating a file."""
+    temp_filename = "%s.%s" % (filename, uuid.uuid4())
+    try:
+        with open(temp_filename, "w") as stream:
+            yield stream
+        os.rename(temp_filename, filename)
+    finally:
+        safe_unlink(temp_filename)

=== added file 'magicicada/u1sync/scan.py'
--- magicicada/u1sync/scan.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/scan.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,84 @@
+# Copyright 2009 Canonical Ltd.
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Code for scanning local directory state."""
+
+from __future__ import with_statement
+
+import os
+import hashlib
+import shutil
+
+from errno import ENOTDIR, EINVAL
+
+from ubuntuone.storageprotocol.dircontent_pb2 import DIRECTORY, FILE, SYMLINK
+
+from magicicada.u1sync.genericmerge import MergeNode
+from magicicada.u1sync.utils import should_sync
+
+
+EMPTY_HASH = "sha1:%s" % hashlib.sha1().hexdigest()
+
+
+def scan_directory(path, display_path="", quiet=False):
+    """Scans a local directory and builds an in-memory tree from it."""
+    if display_path != "" and not quiet:
+        print display_path
+
+    link_target = None
+    child_names = None
+    try:
+        link_target = os.readlink(path)
+    except OSError as e:
+        if e.errno != EINVAL:
+            raise
+        try:
+            child_names = os.listdir(path)
+        except OSError as e:
+            if e.errno != ENOTDIR:
+                raise
+
+    if link_target is not None:
+        # symlink
+        sum = hashlib.sha1()
+        sum.update(link_target)
+        content_hash = "sha1:%s" % sum.hexdigest()
+        return MergeNode(node_type=SYMLINK, content_hash=content_hash)
+    elif child_names is not None:
+        # directory
+        child_names = [
+            n for n in child_names if should_sync(n.decode("utf-8"))]
+        child_paths = [(os.path.join(path, child_name),
+                        os.path.join(display_path, child_name))
+                       for child_name in child_names]
+        children = [scan_directory(child_path, child_display_path, quiet)
+                    for (child_path, child_display_path) in child_paths]
+        unicode_child_names = [n.decode("utf-8") for n in child_names]
+        children = dict(zip(unicode_child_names, children))
+        return MergeNode(node_type=DIRECTORY, children=children)
+    else:
+        # regular file
+        sum = hashlib.sha1()
+
+        class HashStream(object):
+            """Stream that computes hashes."""
+            def write(self, bytes):
+                """Accumulate bytes."""
+                sum.update(bytes)
+
+        with open(path, "r") as stream:
+            shutil.copyfileobj(stream, HashStream())
+        content_hash = "sha1:%s" % sum.hexdigest()
+        return MergeNode(node_type=FILE, content_hash=content_hash)

=== added file 'magicicada/u1sync/sync.py'
--- magicicada/u1sync/sync.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/sync.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,377 @@
+# Copyright 2009 Canonical Ltd.
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Sync.
+
+After merging, these routines are used to synchronize state locally and on
+the server to correspond to the merged result.
+
+"""
+
+from __future__ import with_statement
+
+import os
+
+from ubuntuone.storageprotocol import request
+from ubuntuone.storageprotocol.dircontent_pb2 import DIRECTORY, SYMLINK
+
+from magicicada.u1sync.client import UnsupportedOperationError
+from magicicada.u1sync.genericmerge import MergeNode, generic_merge
+from magicicada.u1sync.utils import safe_mkdir
+
+
+EMPTY_HASH = ""
+UPLOAD_SYMBOL = u"\u25b2".encode("utf-8")
+DOWNLOAD_SYMBOL = u"\u25bc".encode("utf-8")
+CONFLICT_SYMBOL = "!"
+DELETE_SYMBOL = "X"
+
+
+def get_conflict_path(path, conflict_info):
+    """Return path for conflict file corresponding to path."""
+    dir, name = os.path.split(path)
+    unique_id = conflict_info[0]
+    return os.path.join(dir, "conflict-%s-%s" % (unique_id, name))
+
+
+def name_from_path(path):
+    """Return unicode name from last path component."""
+    return os.path.split(path)[1].decode("UTF-8")
+
+
+class NodeSyncError(Exception):
+    """Error syncing node."""
+
+
+class NodeCreateError(NodeSyncError):
+    """Error creating node."""
+
+
+class NodeUpdateError(NodeSyncError):
+    """Error updating node."""
+
+
+class NodeDeleteError(NodeSyncError):
+    """Error deleting node."""
+
+
+def sync_tree(merged_tree, original_tree, sync_mode, path, quiet):
+    """Performs actual synchronization."""
+
+    def pre_merge(nodes, name, partial_parent):
+        """Create nodes and write content as required."""
+        (merged_node, original_node) = nodes
+        (parent_path, parent_display_path, parent_uuid,
+         parent_synced) = partial_parent
+
+        utf8_name = name.encode("utf-8")
+        path = os.path.join(parent_path, utf8_name)
+        display_path = os.path.join(parent_display_path, utf8_name)
+        node_uuid = None
+
+        synced = False
+        if merged_node is not None:
+            if merged_node.node_type == DIRECTORY:
+                if original_node is not None:
+                    synced = True
+                    node_uuid = original_node.uuid
+                else:
+                    if not quiet:
+                        print "%s   %s" % (sync_mode.symbol, display_path)
+                    try:
+                        create_dir = sync_mode.create_directory
+                        node_uuid = create_dir(parent_uuid=parent_uuid,
+                                               path=path)
+                        synced = True
+                    except NodeCreateError as e:
+                        print e
+            elif merged_node.content_hash is None:
+                if not quiet:
+                    print "?   %s" % display_path
+            elif (original_node is None or
+                  original_node.content_hash != merged_node.content_hash or
+                  merged_node.conflict_info is not None):
+                conflict_info = merged_node.conflict_info
+                if conflict_info is not None:
+                    conflict_symbol = CONFLICT_SYMBOL
+                else:
+                    conflict_symbol = " "
+                if not quiet:
+                    print "%s %s %s" % (sync_mode.symbol, conflict_symbol,
+                                        display_path)
+                if original_node is not None:
+                    node_uuid = original_node.uuid or merged_node.uuid
+                    original_hash = original_node.content_hash or EMPTY_HASH
+                else:
+                    node_uuid = merged_node.uuid
+                    original_hash = EMPTY_HASH
+                try:
+                    sync_mode.write_file(
+                        node_uuid=node_uuid,
+                        content_hash=merged_node.content_hash,
+                        old_content_hash=original_hash, path=path,
+                        parent_uuid=parent_uuid, conflict_info=conflict_info,
+                        node_type=merged_node.node_type)
+                    synced = True
+                except NodeSyncError as e:
+                    print e
+            else:
+                synced = True
+
+        return (path, display_path, node_uuid, synced)
+
+    def post_merge(nodes, partial_result, child_results):
+        """Delete nodes."""
+        (merged_node, original_node) = nodes
+        (path, display_path, node_uuid, synced) = partial_result
+
+        if merged_node is None:
+            assert original_node is not None
+            if not quiet:
+                print "%s %s %s" % (sync_mode.symbol, DELETE_SYMBOL,
+                                    display_path)
+            try:
+                if original_node.node_type == DIRECTORY:
+                    sync_mode.delete_directory(node_uuid=original_node.uuid,
+                                               path=path)
+                else:
+                    # files or symlinks
+                    sync_mode.delete_file(node_uuid=original_node.uuid,
+                                          path=path)
+                synced = True
+            except NodeDeleteError as e:
+                print e
+
+        if synced:
+            model_node = merged_node
+        else:
+            model_node = original_node
+
+        if model_node is not None:
+            if model_node.node_type == DIRECTORY:
+                child_iter = child_results.iteritems()
+                merged_children = dict(
+                    (name, child) for (name, child) in child_iter
+                    if child is not None)
+            else:
+                # if there are children here it's because they failed to delete
+                merged_children = None
+            return MergeNode(node_type=model_node.node_type,
+                             uuid=model_node.uuid,
+                             children=merged_children,
+                             content_hash=model_node.content_hash)
+        else:
+            return None
+
+    return generic_merge(trees=[merged_tree, original_tree],
+                         pre_merge=pre_merge, post_merge=post_merge,
+                         partial_parent=(path, "", None, True), name=u"")
+
+
+def download_tree(merged_tree, local_tree, client, share_uuid, path, dry_run,
+                  quiet):
+    """Downloads a directory."""
+    if dry_run:
+        downloader = DryRun(symbol=DOWNLOAD_SYMBOL)
+    else:
+        downloader = Downloader(client=client, share_uuid=share_uuid)
+    return sync_tree(merged_tree=merged_tree, original_tree=local_tree,
+                     sync_mode=downloader, path=path, quiet=quiet)
+
+
+def upload_tree(merged_tree, remote_tree, client, share_uuid, path, dry_run,
+                quiet):
+    """Uploads a directory."""
+    if dry_run:
+        uploader = DryRun(symbol=UPLOAD_SYMBOL)
+    else:
+        uploader = Uploader(client=client, share_uuid=share_uuid)
+    return sync_tree(merged_tree=merged_tree, original_tree=remote_tree,
+                     sync_mode=uploader, path=path, quiet=quiet)
+
+
+class DryRun(object):
+    """A class which implements the sync interface but does nothing."""
+    def __init__(self, symbol):
+        """Initializes a DryRun instance."""
+        self.symbol = symbol
+
+    def create_directory(self, parent_uuid, path):
+        """Doesn't create a directory."""
+        return None
+
+    def write_file(self, node_uuid, old_content_hash, content_hash,
+                   parent_uuid, path, conflict_info, node_type):
+        """Doesn't write a file."""
+        return None
+
+    def delete_directory(self, node_uuid, path):
+        """Doesn't delete a directory."""
+
+    def delete_file(self, node_uuid, path):
+        """Doesn't delete a file."""
+
+
+class Downloader(object):
+    """A class which implements the download half of syncing."""
+    def __init__(self, client, share_uuid):
+        """Initializes a Downloader instance."""
+        self.client = client
+        self.share_uuid = share_uuid
+        self.symbol = DOWNLOAD_SYMBOL
+
+    def create_directory(self, parent_uuid, path):
+        """Creates a directory."""
+        try:
+            safe_mkdir(path)
+        except OSError as e:
+            raise NodeCreateError(
+                "Error creating local directory %s: %s" % (path, e))
+        return None
+
+    def write_file(self, node_uuid, old_content_hash, content_hash,
+                   parent_uuid, path, conflict_info, node_type):
+        """Creates a file and downloads new content for it."""
+        if conflict_info:
+            # download to conflict file rather than overwriting local changes
+            path = get_conflict_path(path, conflict_info)
+            content_hash = conflict_info[1]
+        try:
+            if node_type == SYMLINK:
+                self.client.download_string(
+                    share_uuid=self.share_uuid, node_uuid=node_uuid,
+                    content_hash=content_hash)
+            else:
+                self.client.download_file(
+                    share_uuid=self.share_uuid, node_uuid=node_uuid,
+                    content_hash=content_hash, filename=path)
+        except (request.StorageRequestError, UnsupportedOperationError) as e:
+            if os.path.exists(path):
+                raise NodeUpdateError(
+                    "Error downloading content for %s: %s" % (path, e))
+            else:
+                raise NodeCreateError(
+                    "Error locally creating %s: %s" % (path, e))
+
+    def delete_directory(self, node_uuid, path):
+        """Deletes a directory."""
+        try:
+            os.rmdir(path)
+        except OSError as e:
+            raise NodeDeleteError("Error locally deleting %s: %s" % (path, e))
+
+    def delete_file(self, node_uuid, path):
+        """Deletes a file."""
+        try:
+            os.remove(path)
+        except OSError as e:
+            raise NodeDeleteError("Error locally deleting %s: %s" % (path, e))
+
+
+class Uploader(object):
+    """A class which implements the upload half of syncing."""
+    def __init__(self, client, share_uuid):
+        """Initializes an uploader instance."""
+        self.client = client
+        self.share_uuid = share_uuid
+        self.symbol = UPLOAD_SYMBOL
+
+    def create_directory(self, parent_uuid, path):
+        """Creates a directory on the server."""
+        name = name_from_path(path)
+        try:
+            return self.client.create_directory(share_uuid=self.share_uuid,
+                                                parent_uuid=parent_uuid,
+                                                name=name)
+        except (request.StorageRequestError, UnsupportedOperationError) as e:
+            raise NodeCreateError("Error remotely creating %s: %s" % (path, e))
+
+    def write_file(self, node_uuid, old_content_hash, content_hash,
+                   parent_uuid, path, conflict_info, node_type):
+        """Creates a file on the server and uploads new content for it."""
+
+        if conflict_info:
+            # move conflicting file out of the way on the server
+            conflict_path = get_conflict_path(path, conflict_info)
+            conflict_name = name_from_path(conflict_path)
+            try:
+                self.client.move(share_uuid=self.share_uuid,
+                                 parent_uuid=parent_uuid,
+                                 name=conflict_name,
+                                 node_uuid=node_uuid)
+            except (request.StorageRequestError,
+                    UnsupportedOperationError) as e:
+                raise NodeUpdateError(
+                    "Error remotely renaming %s to %s: %s" %
+                    (path, conflict_path, e))
+            node_uuid = None
+            old_content_hash = EMPTY_HASH
+
+        if node_type == SYMLINK:
+            try:
+                target = os.readlink(path)
+            except OSError as e:
+                raise NodeCreateError(
+                    "Error retrieving link target for %s: %s" % (path, e))
+        else:
+            target = None
+
+        name = name_from_path(path)
+        if node_uuid is None:
+            try:
+                if node_type == SYMLINK:
+                    node_uuid = self.client.create_symlink(
+                        share_uuid=self.share_uuid, parent_uuid=parent_uuid,
+                        name=name, target=target)
+                    old_content_hash = content_hash
+                else:
+                    node_uuid = self.client.create_file(
+                        share_uuid=self.share_uuid, parent_uuid=parent_uuid,
+                        name=name)
+            except (request.StorageRequestError,
+                    UnsupportedOperationError) as e:
+                raise NodeCreateError(
+                    "Error remotely creating %s: %s" % (path, e))
+
+        if old_content_hash != content_hash:
+            try:
+                if node_type == SYMLINK:
+                    self.client.upload_string(
+                        share_uuid=self.share_uuid, node_uuid=node_uuid,
+                        content_hash=content_hash,
+                        old_content_hash=old_content_hash, content=target)
+                else:
+                    self.client.upload_file(
+                        share_uuid=self.share_uuid, node_uuid=node_uuid,
+                        content_hash=content_hash,
+                        old_content_hash=old_content_hash, filename=path)
+            except (request.StorageRequestError,
+                    UnsupportedOperationError) as e:
+                raise NodeUpdateError(
+                    "Error uploading content for %s: %s" % (path, e))
+
+    def delete_directory(self, node_uuid, path):
+        """Deletes a directory."""
+        try:
+            self.client.unlink(share_uuid=self.share_uuid, node_uuid=node_uuid)
+        except (request.StorageRequestError, UnsupportedOperationError) as e:
+            raise NodeDeleteError("Error remotely deleting %s: %s" % (path, e))
+
+    def delete_file(self, node_uuid, path):
+        """Deletes a file."""
+        try:
+            self.client.unlink(share_uuid=self.share_uuid, node_uuid=node_uuid)
+        except (request.StorageRequestError, UnsupportedOperationError) as e:
+            raise NodeDeleteError("Error remotely deleting %s: %s" % (path, e))

=== added directory 'magicicada/u1sync/tests'
=== added file 'magicicada/u1sync/tests/__init__.py'
--- magicicada/u1sync/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/tests/__init__.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,1 @@
+"""Tests for u1sync."""

=== added file 'magicicada/u1sync/tests/test_client.py'
--- magicicada/u1sync/tests/test_client.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/tests/test_client.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,63 @@
+# Copyright 2010 Canonical Ltd.
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Test the client code."""
+
+from mocker import Mocker
+from twisted.trial.unittest import TestCase
+
+from magicicada.u1sync import client
+
+
+class SyncStorageClientTest(TestCase):
+    """Test the SyncStorageClient."""
+
+    def test_conn_made_call_parent(self):
+        """The connectionMade method should call the parent."""
+        # set up everything
+        called = []
+        self.patch(client.StorageClient, 'connectionMade',
+                   lambda s: called.append(True))
+        c = client.SyncStorageClient()
+        mocker = Mocker()
+        obj = mocker.mock()
+        obj.current_protocol
+        mocker.result(None)
+        obj.current_protocol = c
+        obj.observer.connected()
+        c.factory = obj
+
+        # call and test
+        with mocker:
+            c.connectionMade()
+        self.assertTrue(called)
+
+    def test_conn_lost_call_parent(self):
+        """The connectionLost method should call the parent."""
+        # set up everything
+        called = []
+        self.patch(client.StorageClient, 'connectionLost',
+                   lambda s, r: called.append(True))
+        c = client.SyncStorageClient()
+        mocker = Mocker()
+        obj = mocker.mock()
+        obj.current_protocol
+        mocker.result(None)
+        c.factory = obj
+
+        # call and test
+        with mocker:
+            c.connectionLost()
+        self.assertTrue(called)

=== added file 'magicicada/u1sync/tests/test_init.py'
--- magicicada/u1sync/tests/test_init.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/tests/test_init.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,22 @@
+# Copyright 2009 Canonical Ltd.
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for u1sync mirror init"""
+
+from unittest import TestCase
+
+
+class InitTestCase(TestCase):
+    """Tests for u1sync --init"""

=== added file 'magicicada/u1sync/tests/test_merge.py'
--- magicicada/u1sync/tests/test_merge.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/tests/test_merge.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,109 @@
+# Copyright 2009 Canonical Ltd.
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for tree merging."""
+
+import uuid
+import os
+
+from unittest import TestCase
+
+from ubuntuone.storageprotocol.dircontent_pb2 import FILE, DIRECTORY
+
+from magicicada.u1sync.genericmerge import MergeNode, generic_merge
+from magicicada.u1sync.merge import (
+    merge_trees, ClobberLocalMerge, ClobberServerMerge, SyncMerge)
+
+
+def accumulate_path(nodes, name, partial_parent):
+    """pre-merge which accumulates a path"""
+    return os.path.join(partial_parent, name)
+
+
+def capture_merge(nodes, partial_result, child_results):
+    """post-merge which accumulates merge results."""
+    return (nodes, partial_result, child_results)
+
+
+class MergeTest(TestCase):
+    """Tests for generic tree merges."""
+
+    def test_generic_merge(self):
+        """Tests that generic merge behaves as expected."""
+        tree_a = MergeNode(DIRECTORY, children={
+            'foo': MergeNode(FILE, uuid=uuid.uuid4()),
+            'bar': MergeNode(FILE, uuid=uuid.uuid4()),
+        }, uuid=uuid.uuid4())
+        tree_b = MergeNode(DIRECTORY, children={
+            'bar': MergeNode(FILE, uuid=uuid.uuid4()),
+            'baz': MergeNode(FILE, uuid=uuid.uuid4()),
+        }, uuid=uuid.uuid4())
+        result = generic_merge(trees=[tree_a, tree_b],
+                               pre_merge=accumulate_path,
+                               post_merge=capture_merge,
+                               partial_parent="", name="ex")
+        expected_result = ([tree_a, tree_b], "ex", {
+            'foo': ([tree_a.children['foo'], None], "ex/foo", {}),
+            'bar': ([tree_a.children['bar'], tree_b.children['bar']],
+                    "ex/bar", {}),
+            'baz': ([None, tree_b.children['baz']], "ex/baz", {}),
+        })
+        self.assertEqual(expected_result, result)
+
+    def test_clobber(self):
+        """Tests clobbering merges."""
+        server_tree = MergeNode(DIRECTORY, children={
+            'foo': MergeNode(FILE, content_hash="dummy:abc"),
+            'bar': MergeNode(FILE, content_hash="dummy:xyz"),
+            'baz': MergeNode(FILE, content_hash="dummy:aaa"),
+        })
+        local_tree = MergeNode(DIRECTORY, children={
+            'foo': MergeNode(FILE, content_hash="dummy:cde"),
+            'bar': MergeNode(FILE, content_hash="dummy:zyx"),
+            'hoge': MergeNode(FILE, content_hash="dummy:bbb"),
+        })
+        result_tree = merge_trees(local_tree, local_tree,
+                                  server_tree, server_tree,
+                                  ClobberServerMerge())
+        self.assertEqual(local_tree, result_tree)
+        result_tree = merge_trees(local_tree, local_tree,
+                                  server_tree, server_tree,
+                                  ClobberLocalMerge())
+        self.assertEqual(server_tree, result_tree)
+
+    def test_sync(self):
+        """Test sync merges."""
+        server_tree = MergeNode(DIRECTORY, children={
+            'bar': MergeNode(FILE, content_hash="dummy:xyz"),
+            'baz': MergeNode(FILE, content_hash="dummy:aaa"),
+            'foo': MergeNode(FILE, content_hash="dummy:abc"),
+        })
+        old_server_tree = MergeNode(DIRECTORY, children={})
+        local_tree = MergeNode(DIRECTORY, children={
+            'bar': MergeNode(FILE, content_hash="dummy:xyz"),
+            'foo': MergeNode(FILE, content_hash="dummy:abc"),
+            'hoge': MergeNode(FILE, content_hash="dummy:bbb"),
+        })
+        old_local_tree = MergeNode(DIRECTORY, children={})
+        expected_tree = MergeNode(DIRECTORY, children={
+            'bar': MergeNode(FILE, content_hash="dummy:xyz"),
+            'baz': MergeNode(FILE, content_hash="dummy:aaa"),
+            'foo': MergeNode(FILE, content_hash="dummy:abc"),
+            'hoge': MergeNode(FILE, content_hash="dummy:bbb"),
+        })
+        result_tree = merge_trees(old_local_tree, local_tree,
+                                  old_server_tree, server_tree,
+                                  SyncMerge())
+        self.assertEqual(result_tree, expected_tree)

=== added file 'magicicada/u1sync/utils.py'
--- magicicada/u1sync/utils.py	1970-01-01 00:00:00 +0000
+++ magicicada/u1sync/utils.py	2018-04-20 01:22:48 +0000
@@ -0,0 +1,50 @@
+# Copyright 2009 Canonical Ltd.
+# Copyright 2015-2018 Chicharreros (https://launchpad.net/~chicharreros)
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Miscellaneous utility functions."""
+
+import os
+
+from errno import EEXIST, ENOENT
+
+from magicicada.u1sync.constants import METADATA_DIR_NAME, SPECIAL_FILE_RE
+
+
+def should_sync(filename):
+    """Returns True if the filename should be synced.
+
+    @param filename: a unicode filename
+
+    """
+    return (filename != METADATA_DIR_NAME and
+            not SPECIAL_FILE_RE.match(filename))
+
+
+def safe_mkdir(path):
+    """Creates a directory if it does not already exist."""
+    try:
+        os.mkdir(path)
+    except OSError, e:
+        if e.errno != EEXIST:
+            raise
+
+
+def safe_unlink(path):
+    """Unlinks a file if it exists."""
+    try:
+        os.remove(path)
+    except OSError, e:
+        if e.errno != ENOENT:
+            raise