4 files changed, 330 insertions, 11 deletions

diff --git a/common/storage_lmdb.cpp b/common/storage_lmdb.cpp
index 18a5aa6..283205f 100644
--- a/common/storage_lmdb.cpp
+++ b/common/storage_lmdb.cpp
@@ -14,10 +14,12 @@
 class Storage::Private
 {
 public:
-    Private(const QString &p);
+    Private(const QString &s, const QString &name);
     ~Private();
 
-    QString path;
+    QString storageRoot;
+    QString name;
+
     MDB_dbi dbi;
     MDB_env *env;
     MDB_txn *transaction;
@@ -25,20 +27,21 @@ public:
     bool firstOpen;
 };
 
-Storage::Private::Private(const QString &p)
-    : path(p),
-      transaction(0),
+Storage::Private::Private(const QString &s, const QString &n)
+    : transaction(0),
       readTransaction(false),
-      firstOpen(true)
+      firstOpen(true),
+      storageRoot(s),
+      name(n)
 {
     QDir dir;
-    dir.mkdir(path);
+    dir.mkdir(storageRoot);
 
     //create file
     if (mdb_env_create(&env)) {
         // TODO: handle error
     } else {
-        int rc = mdb_env_open(env, path.toStdString().data(), 0, 0664);
+        int rc = mdb_env_open(env, storageRoot.toStdString().data(), 0, 0664);
 
         if (rc) {
             std::cerr << "mdb_env_open: " << rc << " " << mdb_strerror(rc) << std::endl;
@@ -63,7 +66,7 @@ Storage::Private::~Private()
 }
 
 Storage::Storage(const QString &storageRoot, const QString &name)
-    : d(new Private(storageRoot + '/' + name))
+    : d(new Private(storageRoot, name))
 {
 }
 
@@ -143,6 +146,11 @@ void Storage::abortTransaction()
     d->transaction = 0;
 }
 
+bool Storage::write(const char *key, size_t keySize, const char *value, size_t valueSize)
+{
+    write(std::string(key, keySize), std::string(value, valueSize));
+}
+
 bool Storage::write(const std::string &sKey, const std::string &sValue)
 {
     if (!d->env) {
@@ -241,7 +249,7 @@ bool Storage::read(const std::string &sKey, const std::function<void(void *ptr,
 
     if (rc) {
         std::cerr << "mdb_cursor_get: " << rc << " " << mdb_strerror(rc) << std::endl;
-        return false
+        return false;
     }
 
     /**
@@ -255,7 +263,7 @@ bool Storage::read(const std::string &sKey, const std::function<void(void *ptr,
 
 qint64 Storage::diskUsage() const
 {
-    QFileInfo info(d->path, "data.mdb");
+    QFileInfo info(d->storageRoot + "/data.mdb");
     return info.size();
 }
 
@@ -266,3 +274,9 @@ void Storage::removeFromDisk() const
     dir.remove("lock.mdb");
 }
 
+void Storage::removeFromDisk() const
+{
+    QDir dir(d->storageRoot);
+    dir.remove("data.mdb");
+    dir.remove("lock.mdb");
+}
diff --git a/store/kyotodatabase.cpp b/store/kyotodatabase.cpp
new file mode 100644
index 0000000..542667a
--- /dev/null
+++ b/store/kyotodatabase.cpp
@@ -0,0 +1,164 @@
+#include "database.h"
+
+#include <iostream>
+
+#include <QAtomicInt>
+#include <QDebug>
+#include <QDir>
+#include <QFileInfo>
+#include <QReadWriteLock>
+#include <QString>
+#include <QTime>
+
+#include <kchashdb.h>
+
+class Database::Private
+{
+public:
+    Private(const QString &storageRoot, const QString &name);
+    ~Private();
+
+    kyotocabinet::TreeDB db;
+    bool dbOpen;
+    bool inTransaction;
+};
+
+Database::Private::Private(const QString &storageRoot, const QString &name)
+    : inTransaction(false)
+{
+    QDir dir;
+    dir.mkdir(storageRoot);
+
+    //create file
+    dbOpen = db.open((storageRoot + "/" + name + ".kch").toStdString(), kyotocabinet::BasicDB::OWRITER | kyotocabinet::BasicDB::OCREATE);
+    if (!dbOpen) {
+        // TODO: handle error
+    }
+}
+
+Database::Private::~Private()
+{
+    if (dbOpen && inTransaction) {
+        db.end_transaction(false);
+    }
+}
+
+Database::Database(const QString &storageRoot, const QString &name)
+    : d(new Private(storageRoot, name))
+{
+}
+
+Database::~Database()
+{
+    delete d;
+}
+
+bool Database::isInTransaction() const
+{
+    return d->inTransaction;
+}
+
+bool Database::startTransaction(TransactionType type)
+{
+    if (!d->dbOpen) {
+        return false;
+    }
+
+    if (d->inTransaction) {
+        return true;
+    }
+
+    //TODO handle errors
+    d->inTransaction = d->db.begin_transaction();
+    return d->inTransaction;
+}
+
+bool Database::commitTransaction()
+{
+    if (!d->dbOpen) {
+        return false;
+    }
+
+    if (!d->inTransaction) {
+        return false;
+    }
+
+    bool success = d->db.end_transaction(true);
+    d->inTransaction = false;
+    return success;
+}
+
+void Database::abortTransaction()
+{
+    if (!d->dbOpen || !d->inTransaction) {
+        return;
+    }
+
+    d->db.end_transaction(false);
+    d->inTransaction = false;
+}
+
+bool Database::write(const char *key, size_t keySize, const char *value, size_t valueSize)
+{
+    if (!d->dbOpen) {
+        return false;
+    }
+
+    bool success = d->db.set(key, keySize, value, valueSize);
+    return success; 
+}
+
+bool Database::write(const std::string &sKey, const std::string &sValue)
+{
+    if (!d->dbOpen) {
+        return false;
+    }
+
+    bool success = d->db.set(sKey, sValue);
+    return success; 
+}
+
+void Database::read(const std::string &sKey, const std::function<void(const std::string &value)> &resultHandler)
+{
+    if (!d->dbOpen) {
+        return;
+    }
+
+    std::string value;
+    if (d->db.get(sKey, &value)) {
+        resultHandler(value);
+    }
+}
+
+void Database::read(const std::string &sKey, const std::function<void(void *ptr, int size)> &resultHandler)
+{
+    if (!d->dbOpen) {
+        return;
+    }
+
+    size_t valueSize;
+    char *valueBuffer = d->db.get(sKey.data(), sKey.size(), &valueSize);
+    resultHandler(valueBuffer, valueSize);
+    delete[] valueBuffer;
+}
+
+qint64 Database::diskUsage() const
+{
+    if (!d->dbOpen) {
+        return 0;
+    }
+
+    QFileInfo info(QString::fromStdString(d->db.path()));
+    return info.size();
+}
+
+void Database::removeFromDisk() const
+{
+    if (!d->dbOpen) {
+        return;
+    }
+
+   QFileInfo info(QString::fromStdString(d->db.path()));
+   QDir dir = info.dir();
+   dir.remove(info.fileName());
+}
diff --git a/store/kyotodatabase.h b/store/kyotodatabase.h
new file mode 100644
index 0000000..e752ff5
--- /dev/null
+++ b/store/kyotodatabase.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <string>
+#include <QString>
+
+class Database {
+public:
+    enum TransactionType { ReadOnly, ReadWrite };
+
+    Database(const QString &storageRoot, const QString &name);
+    ~Database();
+    bool isInTransaction() const;
+    bool startTransaction(TransactionType type = ReadWrite);
+    bool commitTransaction();
+    void abortTransaction();
+    bool write(const char *key, size_t keySize, const char *value, size_t valueSize);
+    bool write(const std::string &sKey, const std::string &sValue);
+    //Perhaps prefer iterators (assuming we need to be able to match multiple values
+    void read(const std::string &sKey, const std::function<void(const std::string &value)> &);
+    void read(const std::string &sKey, const std::function<void(void *ptr, int size)> &);
+
+    qint64 diskUsage() const;
+    void removeFromDisk() const;
+private:
+    class Private;
+    Private * const d;
+};
+
diff --git a/store/test/storagetest.cpp b/store/test/storagetest.cpp
new file mode 100644
index 0000000..dba4f6c
--- /dev/null
+++ b/store/test/storagetest.cpp
@@ -0,0 +1,113 @@
+#include <QtTest>
+
+#include <iostream>
+
+#include <QDebug>
+#include <QString>
+#include <QtConcurrent/QtConcurrentRun>
+
+#include "store/database.h"
+
+class StorageTest : public QObject
+{
+    Q_OBJECT
+private:
+    //This should point to a directory on disk and not a ramdisk (since we're measuring performance)
+    QString testDataPath;
+    QString dbName;
+    const char *keyPrefix = "key";
+
+    void populate(int count)
+    {
+        Database db(testDataPath, dbName);
+        for (int i = 0; i < count; i++) {
+            //This should perhaps become an implementation detail of the db?
+            if (i % 10000 == 0) {
+                if (i > 0) {
+                    db.commitTransaction();
+                }
+                db.startTransaction();
+            }
+            db.write(keyPrefix + std::to_string(i), keyPrefix + std::to_string(i));
+        }
+        db.commitTransaction();
+    }
+
+    bool verify(Database &db, int i)
+    {
+        bool error = false;
+        const auto reference = keyPrefix + std::to_string(i);
+        if(!db.read(keyPrefix + std::to_string(i), [&error, &reference](const std::string &value) {
+            if (value != reference) {
+                qDebug() << "Mismatch while reading";
+                error = true;
+            }
+        })) {
+            return false;
+        }
+        return !error;
+    }
+
+private Q_SLOTS:
+    void initTestCase()
+    {
+        testDataPath = "./testdb";
+        dbName = "test";
+    }
+
+    void cleanupTestCase()
+    {
+        Database db(testDataPath, dbName);
+        db.removeFromDisk();
+    }
+
+
+    void testRead()
+    {
+        const int count = 100;
+
+        populate(count);
+
+        //ensure we can read everything back correctly
+        {
+            Database db(testDataPath, dbName);
+            for (int i = 0; i < count; i++) {
+                QVERIFY(verify(db, i));
+            }
+        }
+
+        Database db(testDataPath, dbName);
+        db.removeFromDisk();
+    }
+
+    void testConcurrentRead()
+    {
+        const int count = 10000;
+
+        populate(count);
+
+        //Try to concurrently read
+        QList<QFuture<void> > futures;
+        const int concurrencyLevel = 4;
+        for (int num = 0; num < concurrencyLevel; num++) {
+            futures << QtConcurrent::run([this, count](){
+                Database db(testDataPath, dbName);
+                for (int i = 0; i < count; i++) {
+                    if (!verify(db, i)) {
+                        qWarning() << "invalid value";
+                        break;
+                    }
+                }
+            });
+        }
+        for(auto future : futures) {
+            future.waitForFinished();
+        }
+
+        Database db(testDataPath, dbName);
+        db.removeFromDisk();
+    }
+};
+
+QTEST_MAIN(StorageTest)
+#include "storagetest.moc"