Don't encode the resource type into the identifier

16 files changed, 57 insertions, 62 deletions

diff --git a/common/definitions.cpp b/common/definitions.cpp
index 101279e..26e23ed 100644
--- a/common/definitions.cpp
+++ b/common/definitions.cpp
@@ -36,13 +36,3 @@ QString Sink::temporaryFileLocation()
     dir.mkpath(path);
     return path;
 }
-
-QByteArray Sink::resourceName(const QByteArray &instanceIdentifier)
-{
-    auto split = instanceIdentifier.split('.');
-    if (split.size() <= 1) {
-        return instanceIdentifier;
-    }
-    split.removeLast();
-    return split.join('.');
-}
diff --git a/common/definitions.h b/common/definitions.h
index a90b15a..6a6796e 100644
--- a/common/definitions.h
+++ b/common/definitions.h
@@ -27,5 +27,4 @@
 namespace Sink {
 QString SINK_EXPORT storageLocation();
 QString SINK_EXPORT temporaryFileLocation();
-QByteArray SINK_EXPORT resourceName(const QByteArray &instanceIdentifier);
 }
diff --git a/common/facade.cpp b/common/facade.cpp
index 803f85c..cdd06f9 100644
--- a/common/facade.cpp
+++ b/common/facade.cpp
@@ -26,6 +26,7 @@
 #include "domainadaptor.h"
 #include "queryrunner.h"
 #include "bufferutils.h"
+#include "resourceconfig.h"
 
 using namespace Sink;
 
@@ -38,7 +39,7 @@ GenericFacade<DomainType>::GenericFacade(
     : Sink::StoreFacade<DomainType>(), mResourceAccess(resourceAccess), mDomainTypeAdaptorFactory(adaptorFactory), mResourceInstanceIdentifier(resourceIdentifier)
 {
     if (!mResourceAccess) {
-        mResourceAccess = ResourceAccessFactory::instance().getAccess(resourceIdentifier);
+        mResourceAccess = ResourceAccessFactory::instance().getAccess(resourceIdentifier, ResourceConfig::getResourceType(resourceIdentifier));
     }
 }
 
diff --git a/common/listener.cpp b/common/listener.cpp
index 145267a..828a917 100644
--- a/common/listener.cpp
+++ b/common/listener.cpp
@@ -42,10 +42,10 @@
 #undef DEBUG_AREA
 #define DEBUG_AREA "resource.communication"
 
-Listener::Listener(const QByteArray &resourceInstanceIdentifier, QObject *parent)
+Listener::Listener(const QByteArray &resourceInstanceIdentifier, const QByteArray &resourceType, QObject *parent)
     : QObject(parent),
       m_server(new QLocalServer(this)),
-      m_resourceName(Sink::resourceName(resourceInstanceIdentifier)),
+      m_resourceName(resourceType),
       m_resourceInstanceIdentifier(resourceInstanceIdentifier),
       m_resource(0),
       m_clientBufferProcessesTimer(new QTimer(this)),
diff --git a/common/listener.h b/common/listener.h
index aca7c50..cd1a7f6 100644
--- a/common/listener.h
+++ b/common/listener.h
@@ -56,7 +56,7 @@ class SINK_EXPORT Listener : public QObject
     Q_OBJECT
 
 public:
-    Listener(const QByteArray &resourceName, QObject *parent = 0);
+    Listener(const QByteArray &resourceName, const QByteArray &resourceType, QObject *parent = 0);
     ~Listener();
 
 signals:
diff --git a/common/notifier.cpp b/common/notifier.cpp
index 25d0b85..94ac84e 100644
--- a/common/notifier.cpp
+++ b/common/notifier.cpp
@@ -48,9 +48,9 @@ Notifier::Notifier(const QSharedPointer<ResourceAccess> &resourceAccess) : d(new
     d->resourceAccess << resourceAccess;
 }
 
-Notifier::Notifier(const QByteArray &instanceIdentifier) : d(new Sink::Notifier::Private)
+Notifier::Notifier(const QByteArray &instanceIdentifier, const QByteArray &resourceType) : d(new Sink::Notifier::Private)
 {
-    auto resourceAccess = Sink::ResourceAccess::Ptr::create(instanceIdentifier);
+    auto resourceAccess = Sink::ResourceAccess::Ptr::create(instanceIdentifier, resourceType);
     resourceAccess->open();
     QObject::connect(resourceAccess.data(), &ResourceAccess::notification, d->context.data(), [this](const Notification &notification) {
         for (const auto &handler : d->handler) {
diff --git a/common/notifier.h b/common/notifier.h
index 9e75dde..3d61e95 100644
--- a/common/notifier.h
+++ b/common/notifier.h
@@ -36,7 +36,7 @@ class SINK_EXPORT Notifier
 {
 public:
     Notifier(const QSharedPointer<ResourceAccess> &resourceAccess);
-    Notifier(const QByteArray &resourceInstanceIdentifier);
+    Notifier(const QByteArray &resourceInstanceIdentifier, const QByteArray &resourceType);
     void registerHandler(std::function<void(const Notification &)>);
 
 private:
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index c8c8189..33820af 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -199,7 +199,7 @@ KAsync::Job<void> ResourceAccess::Private::initializeSocket()
                     TracePrivate() << "Failed to connect, starting resource";
                     // We failed to connect, so let's start the resource
                     QStringList args;
-                    args << resourceInstanceIdentifier;
+                    args << resourceInstanceIdentifier << resourceName;
                     qint64 pid = 0;
                     if (QProcess::startDetached("sink_synchronizer", args, QDir::homePath(), &pid)) {
                         TracePrivate() << "Started resource " << pid;
@@ -218,15 +218,8 @@ KAsync::Job<void> ResourceAccess::Private::initializeSocket()
     });
 }
 
-static QByteArray getResourceName(const QByteArray &instanceIdentifier)
-{
-    auto split = instanceIdentifier.split('.');
-    split.removeLast();
-    return split.join('.');
-}
-
-ResourceAccess::ResourceAccess(const QByteArray &resourceInstanceIdentifier)
-    : ResourceAccessInterface(), d(new Private(getResourceName(resourceInstanceIdentifier), resourceInstanceIdentifier, this))
+ResourceAccess::ResourceAccess(const QByteArray &resourceInstanceIdentifier, const QByteArray &resourceType)
+    : ResourceAccessInterface(), d(new Private(resourceType, resourceInstanceIdentifier, this))
 {
     Log() << "Starting access";
 }
@@ -593,7 +586,7 @@ ResourceAccessFactory &ResourceAccessFactory::instance()
     return *instance;
 }
 
-Sink::ResourceAccess::Ptr ResourceAccessFactory::getAccess(const QByteArray &instanceIdentifier)
+Sink::ResourceAccess::Ptr ResourceAccessFactory::getAccess(const QByteArray &instanceIdentifier, const QByteArray resourceType)
 {
     if (!mCache.contains(instanceIdentifier)) {
         // Reuse the pointer if something else kept the resourceaccess alive
@@ -605,7 +598,7 @@ Sink::ResourceAccess::Ptr ResourceAccessFactory::getAccess(const QByteArray &ins
         }
         if (!mCache.contains(instanceIdentifier)) {
             // Create a new instance if necessary
-            auto sharedPointer = Sink::ResourceAccess::Ptr::create(instanceIdentifier);
+            auto sharedPointer = Sink::ResourceAccess::Ptr::create(instanceIdentifier, resourceType);
             QObject::connect(sharedPointer.data(), &Sink::ResourceAccess::ready, sharedPointer.data(), [this, instanceIdentifier](bool ready) {
                 if (!ready) {
                     mCache.remove(instanceIdentifier);
diff --git a/common/resourceaccess.h b/common/resourceaccess.h
index bd9af65..60f29e9 100644
--- a/common/resourceaccess.h
+++ b/common/resourceaccess.h
@@ -88,7 +88,7 @@ class SINK_EXPORT ResourceAccess : public ResourceAccessInterface
 public:
     typedef QSharedPointer<ResourceAccess> Ptr;
 
-    ResourceAccess(const QByteArray &resourceName);
+    ResourceAccess(const QByteArray &resourceInstanceIdentifier, const QByteArray &resourceType);
     ~ResourceAccess();
 
     QByteArray resourceName() const;
@@ -141,7 +141,7 @@ class ResourceAccessFactory
 {
 public:
     static ResourceAccessFactory &instance();
-    Sink::ResourceAccess::Ptr getAccess(const QByteArray &instanceIdentifier);
+    Sink::ResourceAccess::Ptr getAccess(const QByteArray &instanceIdentifier, const QByteArray resourceType);
 
     QHash<QByteArray, QWeakPointer<Sink::ResourceAccess>> mWeakCache;
     QHash<QByteArray, Sink::ResourceAccess::Ptr> mCache;
diff --git a/common/resourceconfig.cpp b/common/resourceconfig.cpp
index cfde4e9..a4e5fc5 100644
--- a/common/resourceconfig.cpp
+++ b/common/resourceconfig.cpp
@@ -71,6 +71,11 @@ QMap<QByteArray, QByteArray> ResourceConfig::getResources()
     return resources;
 }
 
+QByteArray ResourceConfig::getResourceType(const QByteArray &identifier)
+{
+    return getResources().value(identifier);
+}
+
 void ResourceConfig::clear()
 {
     auto settings = getConfig("resources");
diff --git a/common/resourceconfig.h b/common/resourceconfig.h
index 2108caa..fb74249 100644
--- a/common/resourceconfig.h
+++ b/common/resourceconfig.h
@@ -29,6 +29,7 @@ class SINK_EXPORT ResourceConfig
 {
 public:
     static QMap<QByteArray, QByteArray> getResources();
+    static QByteArray getResourceType(const QByteArray &identifier);
     static QByteArray newIdentifier(const QByteArray &type);
     static void addResource(const QByteArray &identifier, const QByteArray &type);
     static void removeResource(const QByteArray &identifier);
diff --git a/common/resourcecontrol.cpp b/common/resourcecontrol.cpp
index d8b0972..ac6ddba 100644
--- a/common/resourcecontrol.cpp
+++ b/common/resourcecontrol.cpp
@@ -25,6 +25,7 @@
 #include <functional>
 
 #include "resourceaccess.h"
+#include "resourceconfig.h"
 #include "commands.h"
 #include "log.h"
 #include "notifier.h"
@@ -44,7 +45,7 @@ KAsync::Job<void> ResourceControl::shutdown(const QByteArray &identifier)
             [identifier, time](QSharedPointer<QLocalSocket> socket, KAsync::Future<void> &future) {
                 // We can't currently reuse the socket
                 socket->close();
-                auto resourceAccess = ResourceAccessFactory::instance().getAccess(identifier);
+                auto resourceAccess = ResourceAccessFactory::instance().getAccess(identifier, ResourceConfig::getResourceType(identifier));
                 resourceAccess->open();
                 resourceAccess->sendCommand(Sink::Commands::ShutdownCommand)
                     .then<void>([&future, resourceAccess, time]() {
@@ -64,7 +65,7 @@ KAsync::Job<void> ResourceControl::start(const QByteArray &identifier)
     Trace() << "start " << identifier;
     auto time = QSharedPointer<QTime>::create();
     time->start();
-    auto resourceAccess = ResourceAccessFactory::instance().getAccess(identifier);
+    auto resourceAccess = ResourceAccessFactory::instance().getAccess(identifier, ResourceConfig::getResourceType(identifier));
     resourceAccess->open();
     return resourceAccess->sendCommand(Sink::Commands::PingCommand).then<void>([resourceAccess, time]() { Trace() << "Start complete." << Log::TraceTime(time->elapsed()); });
 }
@@ -75,7 +76,7 @@ KAsync::Job<void> ResourceControl::flushMessageQueue(const QByteArrayList &resou
     return KAsync::iterate(resourceIdentifier)
         .template each<void, QByteArray>([](const QByteArray &resource, KAsync::Future<void> &future) {
             Trace() << "Flushing message queue " << resource;
-            auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource);
+            auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource, ResourceConfig::getResourceType(resource));
             resourceAccess->open();
             resourceAccess->synchronizeResource(false, true).then<void>([&future, resourceAccess]() { future.setFinished(); }).exec();
         });
@@ -94,7 +95,7 @@ KAsync::Job<void> ResourceControl::inspect(const Inspection &inspectionCommand)
     auto time = QSharedPointer<QTime>::create();
     time->start();
     Trace() << "Sending inspection " << resource;
-    auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource);
+    auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource, ResourceConfig::getResourceType(resource));
     resourceAccess->open();
     auto notifier = QSharedPointer<Sink::Notifier>::create(resourceAccess);
     auto id = QUuid::createUuid().toByteArray();
diff --git a/common/store.cpp b/common/store.cpp
index 0321583..b89e08c 100644
--- a/common/store.cpp
+++ b/common/store.cpp
@@ -51,23 +51,27 @@ QString Store::getTemporaryFilePath()
     return Sink::temporaryFileLocation() + "/" + QUuid::createUuid().toString();
 }
 
-static QList<QByteArray> getResources(const QList<QByteArray> &resourceFilter, const QByteArray &type = QByteArray())
+/*
+ * Returns a map of resource instance identifiers and resource type
+ */
+static QMap<QByteArray, QByteArray> getResources(const QList<QByteArray> &resourceFilter, const QByteArray &type = QByteArray())
 {
+    QMap<QByteArray, QByteArray> resources;
     // Return the global resource (signified by an empty name) for types that don't belong to a specific resource
     if (type == "sinkresource" || type == "sinkaccount" || type == "identity") {
-        return QList<QByteArray>() << "";
+        resources.insert("", "");
+        return resources;
     }
-    QList<QByteArray> resources;
     const auto configuredResources = ResourceConfig::getResources();
     if (resourceFilter.isEmpty()) {
         for (const auto &res : configuredResources.keys()) {
             // TODO filter by entity type
-            resources << res;
+            resources.insert(res, configuredResources.value(res));
         }
     } else {
         for (const auto &res : resourceFilter) {
             if (configuredResources.contains(res)) {
-                resources << res;
+                resources.insert(res, configuredResources.value(res));
             } else {
                 qWarning() << "Resource is not existing: " << res;
             }
@@ -99,16 +103,17 @@ QSharedPointer<QAbstractItemModel> Store::loadModel(Query query)
     auto resources = getResources(query.resources, ApplicationDomain::getTypeName<DomainType>());
     auto aggregatingEmitter = AggregatingResultEmitter<typename DomainType::Ptr>::Ptr::create();
     model->setEmitter(aggregatingEmitter);
-    KAsync::iterate(resources)
-        .template each<void, QByteArray>([query, aggregatingEmitter](const QByteArray &resource, KAsync::Future<void> &future) {
-            auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceName(resource), resource);
+    KAsync::iterate(resources.keys())
+        .template each<void, QByteArray>([query, aggregatingEmitter, resources](const QByteArray &resourceInstanceIdentifier, KAsync::Future<void> &future) {
+            const auto resourceType = resources.value(resourceInstanceIdentifier);
+            auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceType, resourceInstanceIdentifier);
             if (facade) {
-                Trace() << "Trying to fetch from resource " << resource;
+                Trace() << "Trying to fetch from resource " << resourceInstanceIdentifier;
                 auto result = facade->load(query);
                 aggregatingEmitter->addEmitter(result.second);
                 result.first.template then<void>([&future]() { future.setFinished(); }).exec();
             } else {
-                Trace() << "Couldn' find a facade for " << resource;
+                Trace() << "Couldn' find a facade for " << resourceInstanceIdentifier;
                 // Ignore the error and carry on
                 future.setFinished();
             }
@@ -129,8 +134,7 @@ static std::shared_ptr<StoreFacade<DomainType>> getFacade(const QByteArray &reso
             return facade;
         }
     }
-    const auto resourceType = resourceName(resourceInstanceIdentifier);
-    if (auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceType, resourceInstanceIdentifier)) {
+    if (auto facade = FacadeFactory::instance().getFacade<DomainType>(ResourceConfig::getResourceType(resourceInstanceIdentifier), resourceInstanceIdentifier)) {
         return facade;
     }
     return std::make_shared<NullFacade<DomainType>>();
@@ -168,7 +172,7 @@ KAsync::Job<void> Store::removeDataFromDisk(const QByteArray &identifier)
     Trace() << "Remove data from disk " << identifier;
     auto time = QSharedPointer<QTime>::create();
     time->start();
-    auto resourceAccess = ResourceAccessFactory::instance().getAccess(identifier);
+    auto resourceAccess = ResourceAccessFactory::instance().getAccess(identifier, ResourceConfig::getResourceType(identifier));
     resourceAccess->open();
     return resourceAccess->sendCommand(Sink::Commands::RemoveFromDiskCommand)
         .then<void>([resourceAccess, time]() { Trace() << "Remove from disk complete." << Log::TraceTime(time->elapsed()); });
@@ -177,11 +181,11 @@ KAsync::Job<void> Store::removeDataFromDisk(const QByteArray &identifier)
 KAsync::Job<void> Store::synchronize(const Sink::Query &query)
 {
     Trace() << "synchronize" << query.resources;
-    auto resources = getResources(query.resources);
+    auto resources = getResources(query.resources).keys();
     return KAsync::iterate(resources)
         .template each<void, QByteArray>([query](const QByteArray &resource, KAsync::Future<void> &future) {
             Trace() << "Synchronizing " << resource;
-            auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource);
+            auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource, ResourceConfig::getResourceType(resource));
             resourceAccess->open();
             resourceAccess->synchronizeResource(true, false).then<void>([&future, resourceAccess]() { future.setFinished(); }).exec();
         });
diff --git a/synchronizer/main.cpp b/synchronizer/main.cpp
index 02cf365..179fbf5 100644
--- a/synchronizer/main.cpp
+++ b/synchronizer/main.cpp
@@ -65,12 +65,13 @@ int main(int argc, char *argv[])
     signal(SIGSEGV, crashHandler);
     QCoreApplication app(argc, argv);
 
-    if (argc < 2) {
+    if (argc < 3) {
         Warning() << "Not enough args passed, no resource loaded.";
         return app.exec();
     }
 
     const QByteArray instanceIdentifier = argv[1];
+    const QByteArray resourceType = argv[2];
     app.setApplicationName(instanceIdentifier);
 
     QLockFile lockfile(instanceIdentifier + ".lock");
@@ -80,7 +81,7 @@ int main(int argc, char *argv[])
         return -1;
     }
 
-    Listener *listener = new Listener(instanceIdentifier, &app);
+    Listener *listener = new Listener(instanceIdentifier, resourceType, &app);
 
     QObject::connect(&app, &QCoreApplication::aboutToQuit, listener, &Listener::closeAllConnections);
     QObject::connect(listener, &Listener::noClients, &app, &QCoreApplication::quit);
diff --git a/tests/dummyresourcebenchmark.cpp b/tests/dummyresourcebenchmark.cpp
index 124abc1..1e71fc2 100644
--- a/tests/dummyresourcebenchmark.cpp
+++ b/tests/dummyresourcebenchmark.cpp
@@ -86,7 +86,7 @@ private slots:
         QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
         event.setProperty("summary", "summaryValue");
 
-        auto notifier = QSharedPointer<Sink::Notifier>::create("org.kde.dummy.instance1");
+        auto notifier = QSharedPointer<Sink::Notifier>::create("org.kde.dummy.instance1", "org.kde.dummy");
         bool gotNotification = false;
         int duration = 0;
         notifier->registerHandler([&gotNotification, &duration, &time](const Sink::Notification &notification) {
diff --git a/tests/resourcecommunicationtest.cpp b/tests/resourcecommunicationtest.cpp
index 2daf372..2874457 100644
--- a/tests/resourcecommunicationtest.cpp
+++ b/tests/resourcecommunicationtest.cpp
@@ -15,8 +15,8 @@ private slots:
     void testConnect()
     {
         const QByteArray resourceIdentifier("test");
-        Listener listener(resourceIdentifier);
-        Sink::ResourceAccess resourceAccess(resourceIdentifier);
+        Listener listener(resourceIdentifier, "");
+        Sink::ResourceAccess resourceAccess(resourceIdentifier, "");
 
         QSignalSpy spy(&resourceAccess, &Sink::ResourceAccess::ready);
         resourceAccess.open();
@@ -26,8 +26,8 @@ private slots:
     void testHandshake()
     {
         const QByteArray resourceIdentifier("test");
-        Listener listener(resourceIdentifier);
-        Sink::ResourceAccess resourceAccess(resourceIdentifier);
+        Listener listener(resourceIdentifier, "");
+        Sink::ResourceAccess resourceAccess(resourceIdentifier, "");
         resourceAccess.open();
 
         flatbuffers::FlatBufferBuilder fbb;
@@ -42,8 +42,8 @@ private slots:
     void testCommandLoop()
     {
         const QByteArray resourceIdentifier("test");
-        Listener listener(resourceIdentifier);
-        Sink::ResourceAccess resourceAccess(resourceIdentifier);
+        Listener listener(resourceIdentifier, "");
+        Sink::ResourceAccess resourceAccess(resourceIdentifier, "");
         resourceAccess.open();
 
         const int count = 500;
@@ -67,8 +67,8 @@ private slots:
     {
         qDebug();
         const QByteArray resourceIdentifier("test");
-        Listener listener(resourceIdentifier);
-        Sink::ResourceAccess resourceAccess(resourceIdentifier);
+        Listener listener(resourceIdentifier, "");
+        Sink::ResourceAccess resourceAccess(resourceIdentifier, "");
         resourceAccess.open();
 
         const int count = 10;