4 files changed, 27 insertions, 27 deletions

diff --git a/common/clientapi.cpp b/common/clientapi.cpp
index 10115da..6f0b421 100644
--- a/common/clientapi.cpp
+++ b/common/clientapi.cpp
@@ -36,10 +36,7 @@ void Store::shutdown(const QString &identifier)
     Akonadi2::ResourceAccess resourceAccess(identifier);
     //FIXME this starts the resource, just to shut it down again if it's not running in the first place.
     resourceAccess.open();
-    resourceAccess.sendCommand(Akonadi2::Commands::ShutdownCommand).then<void>([](Async::Future<void> &f){
-        //TODO wait for disconnect
-        f.setFinished();
-    }).exec().waitForFinished();
+    resourceAccess.sendCommand(Akonadi2::Commands::ShutdownCommand).exec().waitForFinished();
 }
 
 } // namespace Akonadi2
diff --git a/common/clientapi.h b/common/clientapi.h
index aa3aab8..63305ab 100644
--- a/common/clientapi.h
+++ b/common/clientapi.h
@@ -425,13 +425,22 @@ public:
                 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);
-                //We copy the facade pointer to keep it alive
-                job = job.then(facade->load(query, addCallback));
+
+                // TODO The following is a necessary hack to keep the facade alive.
+                // Otherwise this would reduce to:
+                // job = job.then(facade->load(query, addCallback));
+                // We somehow have to guarantee that the facade remains valid for the duration of the job
+                job = job.then<void>([facade, query, addCallback](Async::Future<void> &future) {
+                    Async::Job<void> j = facade->load(query, addCallback);
+                    j.then<void>([&future, facade](Async::Future<void> &f) {
+                        future.setFinished();
+                        f.setFinished();
+                    }).exec();
+                });
             }
-            job.then<void>([/* eventloop,  */resultSet](Async::Future<void> &future) {
+            job.then<void>([resultSet]() {
                 qDebug() << "Query complete";
                 resultSet->complete();
-                future.setFinished();
             }).exec().waitForFinished(); //We use the eventloop provided by waitForFinished to keep the thread alive until all is done
         });
         return resultSet->emitter();
diff --git a/common/pipeline.cpp b/common/pipeline.cpp
index f321cf5..ed40699 100644
--- a/common/pipeline.cpp
+++ b/common/pipeline.cpp
@@ -30,6 +30,7 @@
 #include "createentity_generated.h"
 #include "entitybuffer.h"
 #include "async/src/async.h"
+#include "log.h"
 
 namespace Akonadi2
 {
@@ -95,7 +96,7 @@ void Pipeline::null()
 
 Async::Job<void> Pipeline::newEntity(void const *command, size_t size)
 {
-    qDebug() << "Pipeline: New Entity";
+    Log() << "Pipeline: New Entity";
 
     //TODO toRFC4122 would probably be more efficient, but results in non-printable keys.
     const auto key = QUuid::createUuid().toString().toUtf8();
@@ -136,7 +137,7 @@ Async::Job<void> Pipeline::newEntity(void const *command, size_t size)
 
     storage().write(key.data(), key.size(), fbb.GetBufferPointer(), fbb.GetSize());
     storage().setMaxRevision(newRevision);
-    qDebug() << "Pipeline: wrote entity: "<< newRevision;
+    Log() << "Pipeline: wrote entity: "<< newRevision;
 
     return Async::start<void>([this, key, entityType](Async::Future<void> &future) {
         PipelineState state(this, NewPipeline, key, d->newPipeline[entityType], [&future]() {
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index 22d7d97..7320e50 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -41,23 +41,14 @@ class QueuedCommand
 public:
     QueuedCommand(int commandId, const std::function<void(int, const QString &)> &callback)
         : commandId(commandId),
-          bufferSize(0),
-          buffer(0),
           callback(callback)
     {}
 
-    QueuedCommand(int commandId, flatbuffers::FlatBufferBuilder &fbb, const std::function<void(int, const QString &)> &callback)
+    QueuedCommand(int commandId, const QByteArray &b, const std::function<void(int, const QString &)> &callback)
         : commandId(commandId),
-          bufferSize(fbb.GetSize()),
-          buffer(new char[bufferSize]),
+          buffer(b),
           callback(callback)
     {
-        memcpy(buffer, fbb.GetBufferPointer(), bufferSize);
-    }
-
-    ~QueuedCommand()
-    {
-        delete[] buffer;
     }
 
 private:
@@ -66,8 +57,7 @@ private:
 
 public:
     const int commandId;
-    const uint bufferSize;
-    char *buffer;
+    QByteArray buffer;
     std::function<void(int, const QString &)> callback;
 };
 
@@ -159,7 +149,9 @@ Async::Job<void> ResourceAccess::sendCommand(int commandId)
 
 Async::Job<void>  ResourceAccess::sendCommand(int commandId, flatbuffers::FlatBufferBuilder &fbb)
 {
-    return Async::start<void>([commandId, &fbb, this](Async::Future<void> &f) {
+    //The flatbuffer is transient, but we want to store it until the job is executed
+    QByteArray buffer(reinterpret_cast<const char*>(fbb.GetBufferPointer()), fbb.GetSize());
+    return Async::start<void>([commandId, buffer, this](Async::Future<void> &f) {
         auto callback = [&f](int error, const QString &errorMessage) {
             if (error) {
                 f.setError(error, errorMessage);
@@ -169,12 +161,13 @@ Async::Job<void>  ResourceAccess::sendCommand(int commandId, flatbuffers::FlatBu
         };
 
         if (isReady()) {
+            //TODO: We probably always want to queue the command, so we can resend it in case something goes wrong
             d->messageId++;
             log(QString("Sending command %1 with messageId %2").arg(commandId).arg(d->messageId));
             registerCallback(d->messageId, callback);
-            Commands::write(d->socket, d->messageId, commandId, fbb);
+            Commands::write(d->socket, d->messageId, commandId, buffer.constData(), buffer.size());
         } else {
-            d->commandQueue << new QueuedCommand(commandId, fbb, callback);
+            d->commandQueue << new QueuedCommand(commandId, buffer, callback);
         }
     });
 }
@@ -237,7 +230,7 @@ void ResourceAccess::connected()
         if (command->callback) {
             registerCallback(d->messageId, command->callback);
         }
-        Commands::write(d->socket, d->messageId, command->commandId, command->buffer, command->bufferSize);
+        Commands::write(d->socket, d->messageId, command->commandId, command->buffer.constData(), command->buffer.size());
         delete command;
     }
     d->commandQueue.clear();