1 files changed, 64 insertions, 15 deletions

diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index 7be1259..6592699 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -30,19 +30,33 @@
 #include "common/modifyentity_generated.h"
 #include "common/deleteentity_generated.h"
 #include "common/revisionreplayed_generated.h"
+#include "common/inspection_generated.h"
 #include "common/entitybuffer.h"
+#include "common/bufferutils.h"
 #include "log.h"
 
 #include <QCoreApplication>
 #include <QDebug>
 #include <QDir>
 #include <QProcess>
+#include <QDataStream>
+#include <QBuffer>
 
 #undef Trace
 #define Trace() Akonadi2::Log::debugStream(Akonadi2::Log::DebugLevel::Trace, __LINE__, __FILE__, Q_FUNC_INFO, "ResourceAccess")
 #undef Log
 #define Log(IDENTIFIER) Akonadi2::Log::debugStream(Akonadi2::Log::DebugLevel::Log, __LINE__, __FILE__, Q_FUNC_INFO, "ResourceAccess("+IDENTIFIER+")")
 
+static void queuedInvoke(const std::function<void()> &f, QObject *context = 0)
+{
+    auto timer = QSharedPointer<QTimer>::create();
+    timer->setSingleShot(true);
+    QObject::connect(timer.data(), &QTimer::timeout, context, [f, timer]() {
+        f();
+    });
+    timer->start(0);
+}
+
 namespace Akonadi2
 {
 
@@ -284,8 +298,8 @@ KAsync::Job<void> ResourceAccess::synchronizeResource(bool sourceSync, bool loca
 {
     Trace() << "Sending synchronize command: " << sourceSync << localSync;
     flatbuffers::FlatBufferBuilder fbb;
-    auto command = Akonadi2::CreateSynchronize(fbb, sourceSync, localSync);
-    Akonadi2::FinishSynchronizeBuffer(fbb, command);
+    auto command = Akonadi2::Commands::CreateSynchronize(fbb, sourceSync, localSync);
+    Akonadi2::Commands::FinishSynchronizeBuffer(fbb, command);
     open();
     return sendCommand(Commands::SynchronizeCommand, fbb);
 }
@@ -338,6 +352,25 @@ KAsync::Job<void> ResourceAccess::sendRevisionReplayedCommand(qint64 revision)
     return sendCommand(Akonadi2::Commands::RevisionReplayedCommand, fbb);
 }
 
+KAsync::Job<void> ResourceAccess::sendInspectionCommand(const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expectedValue)
+{
+    flatbuffers::FlatBufferBuilder fbb;
+    auto id = fbb.CreateString(inspectionId.toStdString());
+    auto domain = fbb.CreateString(domainType.toStdString());
+    auto entity = fbb.CreateString(entityId.toStdString());
+    auto prop = fbb.CreateString(property.toStdString());
+
+    QByteArray array;
+    QDataStream s(&array, QIODevice::WriteOnly);
+    s << expectedValue;
+
+    auto expected = fbb.CreateString(array.toStdString());
+    auto location = Akonadi2::Commands::CreateInspection (fbb, id, 0, entity, domain, prop, expected);
+    Akonadi2::Commands::FinishInspectionBuffer(fbb, location);
+    open();
+    return sendCommand(Akonadi2::Commands::InspectionCommand, fbb);
+}
+
 void ResourceAccess::open()
 {
     if (d->socket && d->socket->isValid()) {
@@ -424,8 +457,8 @@ void ResourceAccess::connected()
     {
         flatbuffers::FlatBufferBuilder fbb;
         auto name = fbb.CreateString(QString("PID: %1 ResourceAccess: %2").arg(QCoreApplication::applicationPid()).arg(reinterpret_cast<qlonglong>(this)).toLatin1());
-        auto command = Akonadi2::CreateHandshake(fbb, name);
-        Akonadi2::FinishHandshakeBuffer(fbb, command);
+        auto command = Akonadi2::Commands::CreateHandshake(fbb, name);
+        Akonadi2::Commands::FinishHandshakeBuffer(fbb, command);
         Commands::write(d->socket.data(), ++d->messageId, Commands::HandshakeCommand, fbb);
     }
 
@@ -490,28 +523,49 @@ bool ResourceAccess::processMessageBuffer()
 
     switch (commandId) {
         case Commands::RevisionUpdateCommand: {
-            auto buffer = GetRevisionUpdate(d->partialMessageBuffer.constData() + headerSize);
+            auto buffer = Commands::GetRevisionUpdate(d->partialMessageBuffer.constData() + headerSize);
             log(QString("Revision updated to: %1").arg(buffer->revision()));
             emit revisionChanged(buffer->revision());
 
             break;
         }
-        case Commands::CommandCompletion: {
-            auto buffer = GetCommandCompletion(d->partialMessageBuffer.constData() + headerSize);
+        case Commands::CommandCompletionCommand: {
+            auto buffer = Commands::GetCommandCompletion(d->partialMessageBuffer.constData() + headerSize);
             log(QString("Command with messageId %1 completed %2").arg(buffer->id()).arg(buffer->success() ? "sucessfully" : "unsuccessfully"));
 
             d->completeCommands << buffer->id();
             //The callbacks can result in this object getting destroyed directly, so we need to ensure we finish our work first
-            QMetaObject::invokeMethod(this, "callCallbacks", Qt::QueuedConnection);
+            queuedInvoke([=]() {
+                d->callCallbacks();
+            }, this);
             break;
         }
         case Commands::NotificationCommand: {
-            auto buffer = GetNotification(d->partialMessageBuffer.constData() + headerSize);
+            auto buffer = Commands::GetNotification(d->partialMessageBuffer.constData() + headerSize);
             switch (buffer->type()) {
-                case Akonadi2::NotificationType::NotificationType_Shutdown:
+                case Akonadi2::Commands::NotificationType::NotificationType_Shutdown:
                     Log(d->resourceInstanceIdentifier) << "Received shutdown notification.";
                     close();
                     break;
+                case Akonadi2::Commands::NotificationType::NotificationType_Inspection: {
+                    Log(d->resourceInstanceIdentifier) << "Received inspection notification.";
+                    Notification n;
+                    if (buffer->identifier()) {
+                        //Don't use fromRawData, the buffer is gone once we invoke emit notification
+                        n.id = BufferUtils::extractBufferCopy(buffer->identifier());
+                    }
+                    if (buffer->message()) {
+                        //Don't use fromRawData, the buffer is gone once we invoke emit notification
+                        n.message = BufferUtils::extractBufferCopy(buffer->message());
+                    }
+                    n.type = buffer->type();
+                    n.code = buffer->code();
+                    //The callbacks can result in this object getting destroyed directly, so we need to ensure we finish our work first
+                    queuedInvoke([=]() {
+                        emit notification(n);
+                    }, this);
+                }
+                    break;
                 default:
                     Warning() << "Received unknown notification: " << buffer->type();
                     break;
@@ -526,11 +580,6 @@ bool ResourceAccess::processMessageBuffer()
     return d->partialMessageBuffer.size() >= headerSize;
 }
 
-void ResourceAccess::callCallbacks()
-{
-    d->callCallbacks();
-}
-
 void ResourceAccess::log(const QString &message)
 {
     Log(d->resourceInstanceIdentifier) << this << message;