9 files changed, 903 insertions, 1 deletions

diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index d200635..fab7708 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -13,12 +13,16 @@ endif (STORAGE_unqlite)
 set(command_SRCS
     commands.cpp
     console.cpp
+    resourceaccess.cpp
     storage_common.cpp
+    threadboundary.cpp
     ${storage_SRCS})
 
 add_library(${PROJECT_NAME} SHARED ${command_SRCS})
 generate_export_header(${PROJECT_NAME} BASE_NAME Akonadi2Common EXPORT_FILE_NAME akonadi2common_export.h)
 SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE CXX)
-qt5_use_modules(${PROJECT_NAME} Widgets)
+qt5_use_modules(${PROJECT_NAME} Widgets Network)
 target_link_libraries(${PROJECT_NAME} ${storage_LIBS})
 install(TARGETS ${PROJECT_NAME} DESTINATION lib)
+
+add_subdirectory(test)
diff --git a/common/clientapi.cpp b/common/clientapi.cpp
new file mode 100644
index 0000000..88797cc
--- /dev/null
+++ b/common/clientapi.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2014 Aaron Seigo <aseigo@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "clientapi.h"
+
+Resource::Resource()
+    : d(0)
+{
+
+}
+
+Resource::~Resource()
+{
+    //delete d;
+}
+
+ResourceFactory::ResourceFactory(QObject *parent)
+    : QObject(parent),
+      d(0)
+{
+
+}
+
+ResourceFactory::~ResourceFactory()
+{
+    //delete d;
+}
+
diff --git a/common/clientapi.h b/common/clientapi.h
new file mode 100644
index 0000000..3531462
--- /dev/null
+++ b/common/clientapi.h
@@ -0,0 +1,465 @@
+/*
+ * Copyright (C) 2014 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QString>
+#include <QSet>
+#include <QSharedPointer>
+#include <QStandardPaths>
+#include <QTimer>
+#include <QDebug>
+#include <QEventLoop>
+#include <QtConcurrent/QtConcurrentRun>
+#include <functional>
+#include "threadboundary.h"
+
+namespace async {
+    //This should abstract if we execute from eventloop or in thread.
+    //It supposed to allow the caller to finish the current method before executing the runner.
+    void run(const std::function<void()> &runner) {
+        QtConcurrent::run(runner);
+
+        // //FIXME we should be using a Job instead of a timer
+        // auto timer = new QTimer;
+        // timer->setSingleShot(true);
+        // QObject::connect(timer, &QTimer::timeout, runner);
+        // QObject::connect(timer, &QTimer::timeout, timer, &QObject::deleteLater);
+        // timer->start(0);
+    };
+
+    /**
+    * Query result set
+    */
+
+    template<class T>
+    class ResultEmitter;
+
+    /*
+    * The promise side for the result emitter
+    */
+    template<class T>
+    class ResultProvider {
+    public:
+        //Called from worker thread
+        void add(const T &value)
+        {
+            //We use the eventloop to call the addHandler directly from the main eventloop.
+            //That way the result emitter implementation doesn't have to care about threadsafety at all.
+            //The alternative would be to make all handlers of the emitter threadsafe.
+            auto emitter = mResultEmitter;
+            mResultEmitter->mThreadBoundary.callInMainThread([emitter, value]() {
+                if (emitter) {
+                    emitter->addHandler(value);
+                }
+            });
+        }
+
+        //Called from worker thread
+        void complete()
+        {
+            auto emitter = mResultEmitter;
+            mResultEmitter->mThreadBoundary.callInMainThread([emitter]() {
+                if (emitter) {
+                    emitter->completeHandler();
+                }
+            });
+        }
+
+        QSharedPointer<ResultEmitter<T> > emitter()
+        {
+            mResultEmitter = QSharedPointer<ResultEmitter<T> >(new ResultEmitter<T>());
+            return mResultEmitter;
+        }
+
+    private:
+        QSharedPointer<ResultEmitter<T> > mResultEmitter;
+    };
+
+    /*
+    * The future side for the client.
+    *
+    * It does not directly hold the state.
+    *
+    * The advantage of this is that we can specialize it to:
+    * * do inline transformations to the data
+    * * directly store the state in a suitable datastructure: QList, QSet, std::list, QVector, ...
+    * * build async interfaces with signals
+    * * build sync interfaces that block when accessing the value
+    *
+    * TODO: This should probably be merged with daniels futurebase used in Async
+    */
+    template<class DomainType>
+    class ResultEmitter {
+    public:
+        void onAdded(const std::function<void(const DomainType&)> &handler)
+        {
+            addHandler = handler;
+        }
+        // void onRemoved(const std::function<void(const T&)> &handler);
+        void onComplete(const std::function<void(void)> &handler)
+        {
+            completeHandler = handler;
+        }
+
+    private:
+        friend class ResultProvider<DomainType>;
+        std::function<void(const DomainType&)> addHandler;
+        // std::function<void(const T&)> removeHandler;
+        std::function<void(void)> completeHandler;
+        ThreadBoundary mThreadBoundary;
+    };
+
+
+    /*
+     * A result set specialization that provides a syncronous list
+     */
+    template<class T>
+    class SyncListResult : public QList<T> {
+    public:
+        SyncListResult(const QSharedPointer<ResultEmitter<T> > &emitter)
+            :QList<T>(),
+            mComplete(false),
+            mEmitter(emitter)
+        {
+            emitter->onAdded([this](const T &value) {
+                this->append(value);
+            });
+            emitter->onComplete([this]() {
+                mComplete = true;
+                auto loop = mWaitLoop.toStrongRef();
+                if (loop) {
+                    loop->quit();
+                }
+            });
+        }
+
+        void exec()
+        {
+            auto loop = QSharedPointer<QEventLoop>::create();
+            mWaitLoop = loop;
+            loop->exec(QEventLoop::ExcludeUserInputEvents);
+        }
+
+    private:
+        bool mComplete;
+        QWeakPointer<QEventLoop> mWaitLoop;
+        QSharedPointer<ResultEmitter<T> > mEmitter;
+    };
+}
+
+namespace Akonadi2 {
+
+/**
+ * Standardized Domain Types
+ *
+ * The don't adhere to any standard and can be freely extended
+ * Their sole purpose is providing a standardized interface to access data.
+ * 
+ * This is necessary to decouple resource-backends from application domain containers (otherwise each resource would have to provide a faceade for each application domain container).
+ *
+ * These types will be frequently modified (for every new feature that should be exposed to the any client)
+ */
+namespace Domain {
+
+class AkonadiDomainType {
+public:
+    AkonadiDomainType(const QString &resourceName, const QString &identifier, qint64 revision)
+        : mResourceName(resourceName),
+        mIdentifier(identifier),
+        mRevision(revision)
+    {
+    }
+
+    virtual QVariant getProperty(const QString &key){ return QVariant(); }
+
+private:
+    /*
+     * Each domain object needs to store the resource, identifier, revision triple so we can link back to the storage location.
+     */
+    QString mResourceName;
+    QString mIdentifier;
+    qint64 mRevision;
+};
+
+class Event : public AkonadiDomainType {
+public:
+    typedef QSharedPointer<Event> Ptr;
+    Event(const QString &resource, const QString &identifier, qint64 revision):AkonadiDomainType(resource, identifier, revision){};
+
+};
+
+class Todo : public AkonadiDomainType {
+public:
+    typedef QSharedPointer<Todo> Ptr;
+};
+
+class Calendar : public AkonadiDomainType {
+public:
+    typedef QSharedPointer<Calendar> Ptr;
+};
+
+class Mail : public AkonadiDomainType {
+};
+
+class Folder : public AkonadiDomainType {
+};
+
+/**
+ * All types need to be registered here an MUST return a different name.
+ * 
+ * Do not store these types to disk, they may change over time.
+ */
+
+template<class DomainType>
+QString getTypeName();
+
+template<>
+QString getTypeName<Event>()
+{
+    return "event";
+}
+
+template<>
+QString getTypeName<Todo>()
+{
+    return "todo";
+}
+
+}
+
+using namespace async;
+
+/**
+ * A query that matches a set of objects
+ * 
+ * The query will have to be updated regularly similary to the domain objects.
+ * It probably also makes sense to have a domain specific part of the query,
+ * such as what properties we're interested in (necessary information for on-demand
+ * loading of data).
+ *
+ * The query defines:
+ * * what resources to search
+ * * filters on various properties (parent collection, startDate range, ....)
+ * * properties we need (for on-demand querying)
+ */
+class Query
+{
+public:
+    //Could also be a propertyFilter
+    QStringList resources;
+    //Could also be a propertyFilter
+    QStringList ids;
+    //Filters to apply
+    QHash<QString, QVariant> propertyFilter;
+    //Properties to retrieve
+    QSet<QString> requestedProperties;
+};
+
+
+/**
+ * Interface for the store facade.
+ * 
+ * All methods are synchronous.
+ * Facades are stateful (they hold connections to resources and database).
+ * 
+ * TODO: would it make sense to split the write, read and notification parts? (we could potentially save some connections)
+ */
+template<class DomainType>
+class StoreFacade {
+public:
+    virtual ~StoreFacade(){};
+    virtual void create(const DomainType &domainObject) = 0;
+    virtual void modify(const DomainType &domainObject) = 0;
+    virtual void remove(const DomainType &domainObject) = 0;
+    virtual void load(const Query &query, const std::function<void(const typename DomainType::Ptr &)> &resultCallback) = 0;
+};
+
+
+/**
+ * Facade factory that returns a store facade implementation, by loading a plugin and providing the relevant implementation.
+ * 
+ * If we were to provide default implementations for certain capabilities. Here would be the place to do so.
+ * 
+ * TODO: pluginmechansims for resources to provide their implementations.
+ * * We may want a way to recycle facades to avoid recreating socket connections all the time?
+ */
+
+class FacadeFactory {
+public:
+    //FIXME: proper singleton implementation
+    static FacadeFactory &instance()
+    {
+        static FacadeFactory factory;
+        return factory;
+    }
+
+    static QString key(const QString &resource, const QString &type)
+    {
+        return resource + type;
+    }
+
+    template<class DomainType, class Facade>
+    void registerFacade(const QString &resource)
+    {
+        const QString typeName = Domain::getTypeName<DomainType>();
+        mFacadeRegistry.insert(key(resource, typeName), [](){ return new Facade; });
+    }
+
+    /*
+     * Allows the registrar to register a specific instance.
+     *
+     * Primarily for testing.
+     * The facade factory takes ovnership of the poniter and typically deletes the instance via shared pointer.
+     * Supplied factory functions should therefore always return a new pointer (i.e. via clone())
+     *
+     * FIXME the factory function should really be returning QSharedPointer<void>, which doesn't work (std::shared_pointer<void> would though). That way i.e. a test could keep the object alive until it's done.
+     */
+    template<class DomainType, class Facade>
+    void registerFacade(const QString &resource, const std::function<void*(void)> &customFactoryFunction)
+    {
+        const QString typeName = Domain::getTypeName<DomainType>();
+        mFacadeRegistry.insert(key(resource, typeName), customFactoryFunction);
+    }
+
+    template<class DomainType>
+    QSharedPointer<StoreFacade<DomainType> > getFacade(const QString &resource)
+    {
+        const QString typeName = Domain::getTypeName<DomainType>();
+        auto factoryFunction = mFacadeRegistry.value(key(resource, typeName));
+        if (factoryFunction) {
+            return QSharedPointer<StoreFacade<DomainType> >(static_cast<StoreFacade<DomainType>* >(factoryFunction()));
+        }
+        qWarning() << "Failed to find facade for resource: " << resource << " and type: " << typeName;
+        return QSharedPointer<StoreFacade<DomainType> >();
+    }
+
+private:
+    QHash<QString, std::function<void*(void)> > mFacadeRegistry;
+};
+
+/**
+ * Store interface used in the client API.
+ *
+ * TODO: For testing we need to be able to inject dummy StoreFacades. Should we work with a store instance, or a singleton factory?
+ */
+class Store {
+public:
+    static QString storageLocation()
+    {
+        return QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/akonadi2";
+    }
+
+    /**
+     * Asynchronusly load a dataset
+     */
+    template <class DomainType>
+    static QSharedPointer<ResultEmitter<typename DomainType::Ptr> > load(Query query)
+    {
+        QSharedPointer<ResultProvider<typename DomainType::Ptr> > resultSet(new ResultProvider<typename DomainType::Ptr>);
+
+        //Execute the search in a thread.
+        //We must guarantee that the emitter is returned before the first result is emitted.
+        //The result provider must be threadsafe.
+        async::run([resultSet, query](){
+            // Query all resources and aggregate results
+            // query tells us in which resources we're interested
+            // TODO: queries to individual resources could be parallelized
+            for(const QString &resource : query.resources) {
+                auto facade = FacadeFactory::instance().getFacade<DomainType>(resource);
+                //We have to bind an instance to the function callback. Since we use a shared pointer this keeps the result provider instance (and thus also the emitter) alive.
+                std::function<void(const typename DomainType::Ptr &)> addCallback = std::bind(&ResultProvider<typename DomainType::Ptr>::add, resultSet, std::placeholders::_1);
+                facade->load(query, addCallback);
+            }
+            resultSet->complete();
+        });
+        return resultSet->emitter();
+    }
+
+    /**
+     * Asynchronusly load a dataset with tree structure information
+     */
+    // template <class DomainType>
+    // static TreeSet<DomainType> loadTree(Query)
+    // {
+
+    // }
+
+    /**
+     * Create a new entity.
+     */
+    template <class DomainType>
+    static void create(const DomainType &domainObject, const QString &resourceIdentifier) {
+        //Potentially move to separate thread as well
+        auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
+        facade.create(domainObject);
+    }
+
+    /**
+     * Modify an entity.
+     * 
+     * This includes moving etc. since these are also simple settings on a property.
+     */
+    template <class DomainType>
+    static void modify(const DomainType &domainObject, const QString &resourceIdentifier) {
+        //Potentially move to separate thread as well
+        auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
+        facade.modify(domainObject);
+    }
+
+    /**
+     * Remove an entity.
+     */
+    template <class DomainType>
+    static void remove(const DomainType &domainObject, const QString &resourceIdentifier) {
+        //Potentially move to separate thread as well
+        auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
+        facade.remove(domainObject);
+    }
+};
+
+class Resource
+{
+public:
+    Resource();
+    virtual ~Resource();
+
+private:
+    class Private;
+    Private * const d;
+};
+
+class ResourceFactory : public QObject
+{
+public:
+    ResourceFactory(QObject *parent);
+    virtual ~ResourceFactory();
+
+    virtual Resource *createResource() = 0;
+    virtual void registerFacade(FacadeFactory &factory) = 0;
+
+private:
+    class Private;
+    Private * const d;
+};
+}
+
+Q_DECLARE_INTERFACE(Akonadi2::ResourceFactory, "org.kde.akonadi2.resourcefactory")
+
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
new file mode 100644
index 0000000..2b58545
--- /dev/null
+++ b/common/resourceaccess.cpp
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2014 Aaron Seigo <aseigo@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "resourceaccess.h"
+
+#include "common/console.h"
+#include "common/commands.h"
+#include "common/handshake_generated.h"
+#include "common/revisionupdate_generated.h"
+
+#include <QDebug>
+#include <QProcess>
+
+namespace Akonadi2
+{
+
+ResourceAccess::ResourceAccess(const QString &resourceName, QObject *parent)
+    : QObject(parent),
+      m_resourceName(resourceName),
+      m_socket(new QLocalSocket(this)),
+      m_tryOpenTimer(new QTimer(this)),
+      m_startingProcess(false)
+{
+    m_tryOpenTimer->setInterval(50);
+    m_tryOpenTimer->setSingleShot(true);
+    connect(m_tryOpenTimer, &QTimer::timeout,
+           this, &ResourceAccess::open);
+
+    log("Starting access");
+    connect(m_socket, &QLocalSocket::connected,
+            this, &ResourceAccess::connected);
+    connect(m_socket, &QLocalSocket::disconnected,
+            this, &ResourceAccess::disconnected);
+    connect(m_socket, SIGNAL(error(QLocalSocket::LocalSocketError)),
+            this, SLOT(connectionError(QLocalSocket::LocalSocketError)));
+    connect(m_socket, &QIODevice::readyRead,
+            this, &ResourceAccess::readResourceMessage);
+
+}
+
+ResourceAccess::~ResourceAccess()
+{
+
+}
+
+QString ResourceAccess::resourceName() const
+{
+    return m_resourceName;
+}
+
+bool ResourceAccess::isReady() const
+{
+    return m_socket->isValid();
+}
+
+void ResourceAccess::open()
+{
+    if (m_socket->isValid()) {
+        log("Socket valid, so aborting the open");
+        return;
+    }
+
+    m_socket->setServerName(m_resourceName);
+    log(QString("Opening %1").arg(m_socket->serverName()));
+    //FIXME: race between starting the exec and opening the socket?
+    m_socket->open();
+}
+
+void ResourceAccess::close()
+{
+    log(QString("Closing %1").arg(m_socket->fullServerName()));
+    m_socket->close();
+}
+
+void ResourceAccess::connected()
+{
+    m_startingProcess = false;
+    log(QString("Connected: ").arg(m_socket->fullServerName()));
+
+    {
+        auto name = m_fbb.CreateString(QString::number((long long)this).toLatin1());
+        auto command = Akonadi2::CreateHandshake(m_fbb, name);
+        Akonadi2::FinishHandshakeBuffer(m_fbb, command);
+        Commands::write(m_socket, Commands::HandshakeCommand, m_fbb);
+        m_fbb.Clear();
+    }
+
+    emit ready(true);
+}
+
+void ResourceAccess::disconnected()
+{
+    m_socket->close();
+    log(QString("Disconnected from %1").arg(m_socket->fullServerName()));
+    emit ready(false);
+    open();
+}
+
+void ResourceAccess::connectionError(QLocalSocket::LocalSocketError error)
+{
+    log(QString("Connection error: %2").arg(error));
+    if (m_startingProcess) {
+        if (!m_tryOpenTimer->isActive()) {
+            m_tryOpenTimer->start();
+        }
+        return;
+    }
+
+    m_startingProcess = true;
+    log(QString("Attempting to start resource ") + m_resourceName);
+    QStringList args;
+    args << m_resourceName;
+    if (QProcess::startDetached("akonadi2_synchronizer", args)) {
+        m_socket->open();
+    }
+}
+
+void ResourceAccess::readResourceMessage()
+{
+    if (!m_socket->isValid()) {
+        return;
+    }
+
+    m_partialMessageBuffer += m_socket->readAll();
+
+    // should be scheduled rather than processed all at once
+    while (processMessageBuffer()) {}
+}
+
+bool ResourceAccess::processMessageBuffer()
+{
+    static const int headerSize = (sizeof(int) * 2);
+    if (m_partialMessageBuffer.size() < headerSize) {
+        return false;
+    }
+
+    const int commandId = *(int*)m_partialMessageBuffer.constData();
+    const int size = *(int*)(m_partialMessageBuffer.constData() + sizeof(int));
+
+    if (size > m_partialMessageBuffer.size() - headerSize) {
+        return false;
+    }
+
+    switch (commandId) {
+        case Commands::RevisionUpdateCommand: {
+            auto buffer = Akonadi2::GetRevisionUpdate(m_partialMessageBuffer.constData() + headerSize);
+            log(QString("Revision updated to: %1").arg(buffer->revision()));
+            emit revisionChanged(buffer->revision());
+            break;
+        }
+        default:
+            break;
+    }
+
+    m_partialMessageBuffer.remove(0, headerSize + size);
+    return m_partialMessageBuffer.size() >= headerSize;
+}
+
+void ResourceAccess::log(const QString &message)
+{
+    Console::main()->log(m_resourceName + ": " + message);
+}
+
+}
diff --git a/common/resourceaccess.h b/common/resourceaccess.h
new file mode 100644
index 0000000..f381af1
--- /dev/null
+++ b/common/resourceaccess.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2014 Aaron Seigo <aseigo@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QLocalSocket>
+#include <QObject>
+#include <QTimer>
+
+#include <flatbuffers/flatbuffers.h>
+
+namespace Akonadi2
+{
+
+class ResourceAccess : public QObject
+{
+    Q_OBJECT
+
+public:
+    ResourceAccess(const QString &resourceName, QObject *parent = 0);
+    ~ResourceAccess();
+
+    QString resourceName() const;
+    bool isReady() const;
+
+public Q_SLOTS:
+    void open();
+    void close();
+
+Q_SIGNALS:
+    void ready(bool isReady);
+    void revisionChanged(unsigned long long revision);
+
+private Q_SLOTS:
+    void connected();
+    void disconnected();
+    void connectionError(QLocalSocket::LocalSocketError error);
+    void readResourceMessage();
+    bool processMessageBuffer();
+
+private:
+    void log(const QString &message);
+    QString m_resourceName;
+    QLocalSocket *m_socket;
+    QTimer *m_tryOpenTimer;
+    bool m_startingProcess;
+    QByteArray m_partialMessageBuffer;
+    flatbuffers::FlatBufferBuilder m_fbb;
+};
+
+}
diff --git a/common/test/CMakeLists.txt b/common/test/CMakeLists.txt
new file mode 100644
index 0000000..98d4ecc
--- /dev/null
+++ b/common/test/CMakeLists.txt
@@ -0,0 +1,15 @@
+set(CMAKE_AUTOMOC ON)
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+macro(auto_tests)
+    foreach(_testname ${ARGN})
+        add_executable(${_testname} ${_testname}.cpp ${store_SRCS})
+        qt5_use_modules(${_testname} Core Test)
+        target_link_libraries(${_testname} akonadi2common)
+        add_test(NAME ${_testname} COMMAND ${_testname})
+    endforeach(_testname)
+endmacro(auto_tests)
+
+auto_tests (
+    clientapitest
+)
diff --git a/common/test/clientapitest.cpp b/common/test/clientapitest.cpp
new file mode 100644
index 0000000..2d1c238
--- /dev/null
+++ b/common/test/clientapitest.cpp
@@ -0,0 +1,48 @@
+#include <QtTest>
+#include <QDebug>
+#include <functional>
+
+#include "../clientapi.h"
+
+class DummyResourceFacade : public Akonadi2::StoreFacade<Akonadi2::Domain::Event>
+{
+public:
+    ~DummyResourceFacade(){};
+    virtual void create(const Akonadi2::Domain::Event &domainObject){};
+    virtual void modify(const Akonadi2::Domain::Event &domainObject){};
+    virtual void remove(const Akonadi2::Domain::Event &domainObject){};
+    virtual void load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback)
+    {
+        qDebug() << "load called";
+        for(const auto &result : results) {
+            resultCallback(result);
+        }
+    }
+
+    QList<Akonadi2::Domain::Event::Ptr> results;
+};
+
+class ClientAPITest : public QObject
+{
+    Q_OBJECT
+private Q_SLOTS:
+
+    void testLoad()
+    {
+        DummyResourceFacade facade;
+        facade.results << QSharedPointer<Akonadi2::Domain::Event>::create("resource", "id", 0);
+
+        Akonadi2::FacadeFactory::instance().registerFacade<Akonadi2::Domain::Event, DummyResourceFacade>("dummyresource", [facade](){ return new DummyResourceFacade(facade); });
+
+        Akonadi2::Query query;
+        query.resources << "dummyresource";
+
+        async::SyncListResult<Akonadi2::Domain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::Domain::Event>(query));
+        result.exec();
+        QCOMPARE(result.size(), 1);
+    }
+
+};
+
+QTEST_MAIN(ClientAPITest)
+#include "clientapitest.moc"
diff --git a/common/threadboundary.cpp b/common/threadboundary.cpp
new file mode 100644
index 0000000..47ec508
--- /dev/null
+++ b/common/threadboundary.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2014 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "threadboundary.h"
+
+Q_DECLARE_METATYPE(std::function<void()>);
+
+namespace async {
+ThreadBoundary::ThreadBoundary(): QObject() { qRegisterMetaType<std::function<void()> >("std::function<void()>"); }
+ThreadBoundary:: ~ThreadBoundary() {}
+}
+
diff --git a/common/threadboundary.h b/common/threadboundary.h
new file mode 100644
index 0000000..9881afa
--- /dev/null
+++ b/common/threadboundary.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2014 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <QObject>
+#include <functional>
+
+namespace async {
+    /*
+     * A helper class to invoke a method in a different thread using the event loop.
+     * The ThreadBoundary object must live in the thread where the function should be called.
+     */
+    class ThreadBoundary : public QObject {
+        Q_OBJECT
+    public:
+        ThreadBoundary();
+        virtual ~ThreadBoundary();
+
+        //Call in worker thread
+        void callInMainThread(std::function<void()> f) {
+            QMetaObject::invokeMethod(this, "addValueInMainThread", Qt::QueuedConnection, QGenericReturnArgument(), Q_ARG(std::function<void()>, f));
+        }
+    public slots:
+        //Get's called in main thread by it's eventloop
+        void addValueInMainThread(std::function<void()> f) {
+            f();
+        }
+    };
+}