Move hi-level connection code to qredisclient

Author: uglide

3rdparty/qredisclient

@@ -1,6 +1,5 @@
 #include "treeoperations.h"
 #include <qredisclient/redisclient.h>
-#include <qredisclient/utils/compat.h>
 #include "app/widgets/consoletabs.h"
 #include "app/models/connectionconf.h"
 #include "console/consoletab.h"
@@ -14,98 +13,47 @@ TreeOperations::TreeOperations(QSharedPointer<RedisClient::Connection> connectio
 {
 }
 
-void TreeOperations::getDatabases(std::function<void (ConnectionsTree::Operations::DatabaseList)> callback)
+void TreeOperations::getDatabases(std::function<void (RedisClient::DatabaseList)> callback)
 {
-    using namespace RedisClient;
-
-    //  Get keys count
-    Response result;
-    try {
-        result = m_connection->commandSync("info");
-    } catch (const RedisClient::Connection::Exception& e) {
-        throw ConnectionsTree::Operations::Exception("Connection error:\n\n" + QString(e.what()));
+    if (!m_connection->isConnected()) {
+        try {
+            m_connection->connect(true);
+        } catch (const RedisClient::Connection::Exception& e) {
+            throw ConnectionsTree::Operations::Exception("Connection error: " + QString(e.what()));
+        }
     }
 
-    DatabaseList availableDatabeses;
-    QSet<int> loadedDatabeses;
+    RedisClient::DatabaseList availableDatabeses = m_connection->getKeyspaceInfo();
 
-    if (result.isErrorMessage()) {
-        return callback(availableDatabeses);
-    }
+    //detect all databases
+    RedisClient::Response scanningResp;
+    int dbIndex = (availableDatabeses.size() == 0)? 0 : availableDatabeses.lastKey() + 1;
 
-    // Parse keyspace info
-    QString keyspaceInfo = result.getValue().toString();
-    QRegularExpression getDbAndKeysCount("^db(\\d+):keys=(\\d+)");
-    getDbAndKeysCount.setPatternOptions(QRegularExpression::MultilineOption);
-    QRegularExpressionMatchIterator iter = getDbAndKeysCount.globalMatch(keyspaceInfo);
-    while (iter.hasNext()) {
-        QRegularExpressionMatch match = iter.next();
-        int dbIndex = match.captured(1).toInt();
-        availableDatabeses.push_back({dbIndex, match.captured(2).toInt()});
-        loadedDatabeses.insert(dbIndex);
-    }
+    while (true) {
+        try {
+            scanningResp = m_connection->commandSync("select", QString::number(dbIndex));
+        } catch (const RedisClient::Connection::Exception& e) {
+            throw ConnectionsTree::Operations::Exception("Connection error: " + QString(e.what()));
+        }
 
-    int dbCount = (loadedDatabeses.isEmpty())? 0 : *std::max_element(loadedDatabeses.begin(),
-                                                                     loadedDatabeses.end());
-    //detect more db if needed
-    if (dbCount == 0) {
-        Response scanningResp;
-        do {
-            try {
-                scanningResp = m_connection->commandSync("select", QString::number(dbCount));
-            } catch (const RedisClient::Connection::Exception& e) {
-                throw ConnectionsTree::Operations::Exception("Connection error: " + QString(e.what()));
-            }
-        } while (scanningResp.isOkMessage() && ++dbCount);
-    }
+        if (!scanningResp.isOkMessage())
+            break;
 
-    // build db list
-    for (int dbIndex = 0; dbIndex < dbCount; ++dbIndex)
-    {
-        if (loadedDatabeses.contains(dbIndex))
-            continue;
-        availableDatabeses.push_back({dbIndex, 0});
+        availableDatabeses.insert(dbIndex, 0);
+        ++dbIndex;
     }
 
-    std::sort(availableDatabeses.begin(), availableDatabeses.end(),
-              [](QPair<int, int> l, QPair<int, int> r) {
-        return l.first < r.first;
-    });
-
     return callback(availableDatabeses);
 }
 
-void TreeOperations::getDatabaseKeys(uint dbIndex, std::function<void (const RawKeysList &, const QString &)> callback)
+void TreeOperations::getDatabaseKeys(uint dbIndex, std::function<void (const RedisClient::Connection::RawKeysList &, const QString &)> callback)
 {
     QString keyPattern = static_cast<ConnectionConfig>(m_connection->getConfig()).keysPattern();
 
-    if (m_connection->getServerVersion() >= 2.8) {
-        QList<QByteArray> rawCmd {
-            "scan", "0", "MATCH", keyPattern.toUtf8(), "COUNT", "10000"
-        };
-        QSharedPointer<RedisClient::ScanCommand> keyCmd(new RedisClient::ScanCommand(rawCmd, dbIndex));
-
-        try {
-            m_connection->retrieveCollection(keyCmd, [this, callback](QVariant r, QString err)
-            {                
-                if (!err.isEmpty())
-                    callback(RawKeysList(), QString("Cannot load keys: %1").arg(err));
-
-                callback(convertQVariantList(r.toList()), QString());
-            });
-        } catch (const RedisClient::Connection::Exception& error) {            
-            callback(RawKeysList(), QString("Cannot load keys: %1").arg(error.what()));
-        }
-    } else {
-        try {
-            m_connection->command({"KEYS", keyPattern.toUtf8()}, this,
-                                  [this, callback](RedisClient::Response r, QString)
-            {
-                callback(convertQVariantList(r.getValue().toList()), QString());
-            }, dbIndex);
-        } catch (const RedisClient::Connection::Exception& error) {
-            callback(RawKeysList(), QString("Cannot load keys: %1").arg(error.what()));
-        }
+    try {
+        m_connection->getDatabaseKeys(callback, keyPattern, dbIndex);
+    } catch (const RedisClient::Connection::Exception& error) {
+        callback(RedisClient::Connection::RawKeysList(), QString("Cannot load keys: %1").arg(error.what()));
     }
 }
 

src/app/models/treeoperations.cpp

@@ -16,9 +16,9 @@ class TreeOperations : public QObject, public ConnectionsTree::Operations
     TreeOperations(QSharedPointer<RedisClient::Connection> connection,
                    ConsoleTabs& tabs);
 
-    void getDatabases(std::function<void(DatabaseList)>) override;
+    void getDatabases(std::function<void(RedisClient::DatabaseList)>) override;
 
-    void getDatabaseKeys(uint dbIndex, std::function<void(const RawKeysList&, const QString&)>) override;
+    void getDatabaseKeys(uint dbIndex, std::function<void(const RedisClient::Connection::RawKeysList&, const QString&)>) override;
 
     void disconnect() override;
 

src/app/models/treeoperations.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <qredisclient/connection.h>
 #include "treeitem.h"
 #include "connections-tree/operations.h"
 #include <QtConcurrent>
@@ -49,14 +50,14 @@ protected slots:
     void reload();
     void filterKeys(const QRegExp& filter);
     void resetFilter();
-    void renderRawKeys(const Operations::RawKeysList& rawKeys);
+    void renderRawKeys(const RedisClient::Connection::RawKeysList& rawKeys);
 
 private:
     class KeysTreeRenderer
     {
     public:
         static QSharedPointer<DatabaseKeys> renderKeys(QSharedPointer<Operations> operations,
-                                                       Operations::RawKeysList keys,
+                                                       RedisClient::Connection::RawKeysList keys,
                                                        QRegExp filter,
                                                        QString namespaceSeparator,
                                                        QSharedPointer<DatabaseItem>);
@@ -79,7 +80,7 @@ protected slots:
     QSharedPointer<DatabaseKeys> m_keys;
     QFutureWatcher<QSharedPointer<DatabaseKeys>> m_keysLoadingWatcher;
     QWeakPointer<TreeItem> m_parent;
-    Operations::RawKeysList m_rawKeys;
+    RedisClient::Connection::RawKeysList m_rawKeys;
     QRegExp m_filter;
     ParentView* m_parentView;
 };

src/modules/connections-tree/items/databaseitem.h

@@ -166,17 +166,17 @@ void ServerItem::load()
     m_locked = true;
     emit updateIcon();
 
-    std::function<void(Operations::DatabaseList)> callback = [this](Operations::DatabaseList databases) {
+    std::function<void(RedisClient::DatabaseList)> callback = [this](RedisClient::DatabaseList databases) {
 
         if (databases.size() == 0)
         {
             m_locked = false;
             return;
         }
 
-        Operations::DatabaseList::const_iterator db = databases.constBegin();
+        RedisClient::DatabaseList::const_iterator db = databases.constBegin();
         while (db != databases.constEnd()) {
-            QSharedPointer<TreeItem> database((new DatabaseItem(db->first, db->second, m_operations, m_self)));
+            QSharedPointer<TreeItem> database((new DatabaseItem(db.key(), db.value(), m_operations, m_self)));
 
             QObject::connect(dynamic_cast<QObject*>(database.data()), SIGNAL(keysLoaded(unsigned int)),
                              this, SIGNAL(keysLoadedInDatabase(unsigned int)));

src/modules/connections-tree/items/serveritem.cpp

@@ -1,6 +1,6 @@
 #pragma once
 #include <QString>
-#include <QHash>
+#include <QMap>
 #include <QSharedPointer>
 #include <QStringList>
 #include <functional>
@@ -22,16 +22,14 @@ namespace ConnectionsTree {
         /**
          * List of databases with keys counters
          * @emit databesesLoaded
-         **/
-        typedef QVector<QPair<int, int>> DatabaseList;
-        virtual void getDatabases(std::function<void(DatabaseList)>) = 0;
+         **/        
+        virtual void getDatabases(std::function<void(QMap<int, int>)>) = 0;
 
         /**
          * @brief getDatabaseKeys
          * @param dbIndex
-         */
-        typedef QList<QByteArray> RawKeysList;
-        virtual void getDatabaseKeys(uint dbIndex, std::function<void(const RawKeysList&, const QString&)>) = 0;
+         */        
+        virtual void getDatabaseKeys(uint dbIndex, std::function<void(const QList<QByteArray>&, const QString&)>) = 0;
 
         /**
          * Cancel all operations & close connection