Bulk Operations Update (RedisInsight#4561)

* Bulk Operations Update

Implements RedisInsight#3822
Fix RedisInsight#3918
Fix RedisInsight#4226
Fix RedisInsight#1924

Author: uglide

3rdparty/qredisclient

@@ -36,9 +36,10 @@ class Events : public QObject, public QEnableSharedFromThis<Events> {
                                                    QRegExp::Wildcard));
 
   // Dialogs
-  void requestBulkOperation(QSharedPointer<RedisClient::Connection> connection,
-                            int dbIndex, BulkOperations::Manager::Operation op,
-                            QRegExp keyPattern, std::function<void()> callback);
+  void requestBulkOperation(
+      QSharedPointer<RedisClient::Connection> connection, int dbIndex,
+      BulkOperations::Manager::Operation op, QRegExp keyPattern,
+      BulkOperations::AbstractOperation::OperationCallback callback);
 
   void newKeyDialog(QSharedPointer<RedisClient::Connection> connection,
                     std::function<void()> callback, int dbIndex,

src/app/events.h

@@ -90,20 +90,20 @@ void KeyFactory::createNewKeyRequest(
   emit newKeyDialog(NewKeyRequest(connection, dbIndex, callback, keyPrefix));
 }
 
-void KeyFactory::submitNewKeyRequest(NewKeyRequest r, QJSValue jsCallback) {
+void KeyFactory::submitNewKeyRequest(NewKeyRequest r) {
   QSharedPointer<ValueEditor::Model> result = createModel(
       r.keyType(), r.connection(), r.keyName().toUtf8(), r.dbIndex(), -1);
 
   if (!result) return;
 
-  result->addRow(r.value(), [r, &jsCallback](const QString& err) {
+  result->addRow(r.value(), [this, r, result](const QString& err) {
     if (err.size() > 0) {
-      if (jsCallback.isCallable()) jsCallback.call(QJSValueList{err});
+      emit error(err);
       return;
     }
 
-    if (jsCallback.isCallable()) jsCallback.call(QJSValueList{});
     r.callback();
+    emit keyAdded();
   });
 }
 

src/app/models/key-models/keyfactory.cpp

@@ -12,18 +12,20 @@ class KeyFactory : public QObject, public ValueEditor::AbstractKeyFactory {
   void loadKey(
       QSharedPointer<RedisClient::Connection> connection,
       QByteArray keyFullPath, int dbIndex,
-      std::function<void(QSharedPointer<ValueEditor::Model>, const QString &)>
+      std::function<void(QSharedPointer<ValueEditor::Model>, const QString&)>
           callback) override;
 
  public slots:
   void createNewKeyRequest(QSharedPointer<RedisClient::Connection> connection,
                            std::function<void()> callback, int dbIndex,
                            QString keyPrefix);
 
-  void submitNewKeyRequest(NewKeyRequest r, QJSValue jsCallback);
+  void submitNewKeyRequest(NewKeyRequest r);
 
  signals:
   void newKeyDialog(NewKeyRequest r);
+  void keyAdded();
+  void error(const QString& err);
 
  private:
   QSharedPointer<ValueEditor::Model> createModel(

src/app/models/key-models/keyfactory.h

@@ -10,6 +10,7 @@
 #include <algorithm>
 
 #include "app/events.h"
+#include "connections-tree/items/databaseitem.h"
 #include "connections-tree/items/namespaceitem.h"
 #include "connections-tree/keysrendering.h"
 
@@ -91,6 +92,20 @@ void TreeOperations::connect(QSharedPointer<RedisClient::Connection> c) {
   }
 }
 
+void TreeOperations::requestBulkOperation(
+    ConnectionsTree::AbstractNamespaceItem& ns,
+    BulkOperations::Manager::Operation op,
+    BulkOperations::AbstractOperation::OperationCallback callback) {
+  QString pattern =
+      QString("%1%2*")
+          .arg(QString::fromUtf8(ns.getFullPath()))
+          .arg(ns.getFullPath().size() > 0 ? conf().namespaceSeparator() : "");
+  QRegExp filter(pattern, Qt::CaseSensitive, QRegExp::Wildcard);
+
+  emit m_events->requestBulkOperation(m_connection, ns.getDbIndex(), op, filter,
+                                      callback);
+}
+
 QFuture<void> TreeOperations::getDatabases(
     std::function<void(RedisClient::DatabaseList)> callback) {
   return QtConcurrent::run(this, &TreeOperations::loadDatabases, callback);
@@ -215,20 +230,31 @@ void TreeOperations::deleteDbKey(ConnectionsTree::KeyItem& key,
       });
 }
 
+void TreeOperations::deleteDbKeys(ConnectionsTree::DatabaseItem& db) {
+  requestBulkOperation(db, BulkOperations::Manager::Operation::DELETE_KEYS,
+                       [this, &db](QRegExp filter, int, const QStringList&) {
+                         db.reload();
+                         emit m_events->closeDbKeys(m_connection,
+                                                    db.getDbIndex(), filter);
+                       });
+}
+
 void TreeOperations::deleteDbNamespace(ConnectionsTree::NamespaceItem& ns) {
-  QString pattern = QString("%1%2*")
-                        .arg(QString::fromUtf8(ns.getFullPath()))
-                        .arg(conf().namespaceSeparator());
-  QRegExp filter(pattern, Qt::CaseSensitive, QRegExp::Wildcard);
+  requestBulkOperation(ns, BulkOperations::Manager::Operation::DELETE_KEYS,
+                       [this, &ns](QRegExp filter, int, const QStringList&) {
+                         emit m_events->closeDbKeys(m_connection,
+                                                    ns.getDbIndex(), filter);
+                       });
+}
 
-  int dbIndex = ns.getDbIndex();
+void TreeOperations::setTTL(ConnectionsTree::AbstractNamespaceItem& ns) {
+  requestBulkOperation(ns, BulkOperations::Manager::Operation::TTL,
+                       [](QRegExp, int, const QStringList&) {});
+}
 
-  emit m_events->requestBulkOperation(
-      m_connection, dbIndex, BulkOperations::Manager::Operation::DELETE_KEYS,
-      filter, [this, dbIndex, filter, &ns]() {
-        ns.setRemoved();
-        emit m_events->closeDbKeys(m_connection, dbIndex, filter);
-      });
+void TreeOperations::copyKeys(ConnectionsTree::AbstractNamespaceItem& ns) {
+  requestBulkOperation(ns, BulkOperations::Manager::Operation::COPY_KEYS,
+                       [](QRegExp, int, const QStringList&) {});
 }
 
 void TreeOperations::flushDb(int dbIndex,
@@ -243,17 +269,7 @@ void TreeOperations::flushDb(int dbIndex,
 }
 
 QFuture<bool> TreeOperations::connectionSupportsMemoryOperations() {
-  auto d = QSharedPointer<AsyncFuture::Deferred<bool>>(
-      new AsyncFuture::Deferred<bool>());
-
-  m_connection->cmd(
-      {"MEMORY", "HELP"}, this, -1,
-      [d](RedisClient::Response r) {
-        d->complete(!r.isDisabledCommandErrorMessage());
-      },
-      [d](const QString&) { d->complete(false); });
-
-  return d->future();
+  return m_connection->isCommandSupported({"MEMORY", "HELP"});
 }
 
 QFuture<qlonglong> TreeOperations::getUsedMemory(const QByteArray& key,

src/app/models/treeoperations.cpp

@@ -51,8 +51,14 @@ class TreeOperations : public QObject,
   void deleteDbKey(ConnectionsTree::KeyItem& key,
                    std::function<void(const QString&)> callback) override;
 
+  virtual void deleteDbKeys(ConnectionsTree::DatabaseItem& db) override;
+
   void deleteDbNamespace(ConnectionsTree::NamespaceItem& ns) override;
 
+  virtual void setTTL(ConnectionsTree::AbstractNamespaceItem& ns) override;
+
+  virtual void copyKeys(ConnectionsTree::AbstractNamespaceItem& ns) override;
+
   virtual void flushDb(int dbIndex,
                        std::function<void(const QString&)> callback) override;
 
@@ -74,6 +80,11 @@ class TreeOperations : public QObject,
 
   void connect(QSharedPointer<RedisClient::Connection> c);
 
+  void requestBulkOperation(
+      ConnectionsTree::AbstractNamespaceItem& ns,
+      BulkOperations::Manager::Operation op,
+      BulkOperations::AbstractOperation::OperationCallback callback);
+
  private:
   QSharedPointer<RedisClient::Connection> m_connection;
   QSharedPointer<Events> m_events;