dashpay · shumkov · Oct 3, 2022 · Aug 30, 2022 · Sep 1, 2022 · Sep 13, 2022
@@ -243,6 +243,38 @@ To reset a node:
 $ dashmate reset
 ```
 
+### Reindex dashcore chain data
+
+The `reindex` command rebuilds the block chain index using the downloaded block data.
+
+It modifies the configuration, runs the core container in `reindex=1` mode, waits until it fully resynces, and returns it to the normal mode.
+
+The process is interactive (shows progress) and can be interrupted any time, but you cannot start your configuration until the resync is fully complete.
+
+The `reindex` command works for regular and local configurations.
+
+```
+Reindex Core
+
+USAGE
+  $ dashmate core reindex [-v] [--config <value>]
+
+FLAGS
+  -v, --verbose     use verbose mode for output
+  --config=<value>  configuration name to use
+
+DESCRIPTION
+  Reindex Core
+
+  Reindex Core data
+```
+
+With the hard reset mode enabled, the corresponding config will be reset as well. To proceed, running the node [setup](#setup-node) is required.
+
+To reset a node:
+```bash
+$ dashmate reset
+=======
 #### Hard reset
 
 ``dashmate reset --hard``

@@ -346,6 +346,11 @@ module.exports = {
   '0.23.0-alpha.1': (configFile) => {
     Object.entries(configFile.configs)
       .forEach(([, config]) => {
+        config.core.reindex = {
+          enable: false,
+          containerId: null,
+        };
+
         if (config.platform) {
           // Update images
           config.platform.dpns = systemConfigs.base.platform.dpns;

@@ -226,8 +226,23 @@ module.exports = {
           type: 'integer',
           enum: [0, 1],
         },
+        reindex: {
+          type: 'object',
+          properties: {
+            enable: {
+              type: 'boolean',
+            },
+            containerId: {
+              type: ['string', 'null'],
+              minLength: 1,
+            },
+            additionalProperties: false,
+          },
+          required: ['enable', 'containerId'],
+          additionalProperties: false,
+        },
       },
-      required: ['docker', 'p2p', 'rpc', 'spork', 'masternode', 'miner', 'devnetName', 'debug'],
+      required: ['docker', 'p2p', 'rpc', 'spork', 'masternode', 'miner', 'devnetName', 'debug', 'reindex'],
       additionalProperties: false,
     },
     platform: {

@@ -66,6 +66,10 @@ module.exports = {
       },
     },
     debug: 0,
+    reindex: {
+      enable: false,
+      containerId: null,
+    },
     devnetName: null,
   },
   platform: {

@@ -10,6 +10,8 @@ services:
     volumes:
       - core_data:/dash
       - ${DASHMATE_HOME_DIR:?err}/${CONFIG_NAME:?err}/core/dash.conf:/dash/.dashcore/dash.conf
+    command:
+      - dashd
     stop_grace_period: 30s
 
 volumes:

@@ -0,0 +1,64 @@
+const { Listr } = require('listr2');
+
+const { Flags } = require('@oclif/core');
+
+const ConfigBaseCommand = require('../../oclif/command/ConfigBaseCommand');
+
+const MuteOneLineError = require('../../oclif/errors/MuteOneLineError');
+
+class ReindexCommand extends ConfigBaseCommand {
+  /**
+   * @param {Object} args
+   * @param {Object} flags
+   * @param {isSystemConfig} isSystemConfig
+   * @param {Config} config
+   * @param {reindexNodeTask} reindexNodeTask
+   *
+   * @return {Promise<void>}
+   */
+  async runWithDependencies(
+    args,
+    {
+      verbose: isVerbose,
+    },
+    isSystemConfig,
+    config,
+    reindexNodeTask,
+  ) {
+    const tasks = new Listr([
+      {
+        title: `Reindex ${config.getName()} node`,
+        task: () => reindexNodeTask(config),
+      },
+    ],
+    {
+      renderer: isVerbose ? 'verbose' : 'default',
+      rendererOptions: {
+        showTimer: isVerbose,
+        clearOutput: false,
+        collapse: false,
+        showSubtasks: true,
+      },
+    });
+
+    try {
+      await tasks.run({
+        isVerbose,
+      });
+    } catch (e) {
+      throw new MuteOneLineError(e);
+    }
+  }
+}
+
+ReindexCommand.description = `Reindex Core
+
+Reindex Core data
+`;
+
+ReindexCommand.flags = {
+  ...ConfigBaseCommand.flags,
+  verbose: Flags.boolean({ char: 'v', description: 'use verbose mode for output', default: false }),
+};
+
+module.exports = ReindexCommand;
@@ -0,0 +1,77 @@
+const { Listr } = require('listr2');
+
+const { Flags } = require('@oclif/core');
+
+const MuteOneLineError = require('../../../oclif/errors/MuteOneLineError');
+const GroupBaseCommand = require('../../../oclif/command/GroupBaseCommand');
+
+class GroupReindexCommand extends GroupBaseCommand {
+  /**
+   * @param {Object} args
+   * @param {Object} flags
+   * @param {isSystemConfig} isSystemConfig
+   * @param {reindexNodeTask} reindexNodeTask
+   * @param {createRpcClient} createRpcClient
+   * @param {dockerCompose} dockerCompose
+   * @param {Config[]} configGroup
+   * @return {Promise<void>}
+   */
+  async runWithDependencies(
+    args,
+    {
+      verbose: isVerbose,
+    },
+    isSystemConfig,
+    reindexNodeTask,
+    createRpcClient,
+    dockerCompose,
+    configGroup,
+  ) {
+    const groupName = configGroup[0].get('group');
+
+    const tasks = new Listr({
+      title: `Reindex ${groupName} nodes`,
+      task: async () => (
+        new Listr([
+          {
+            title: 'Reindex core nodes',
+            task: () => (
+              new Listr(configGroup.map((config) => ({
+                task: () => reindexNodeTask(config),
+              })))
+            ),
+          },
+        ])
+      ),
+    },
+    {
+      renderer: isVerbose ? 'verbose' : 'default',
+      rendererOptions: {
+        showTimer: isVerbose,
+        clearOutput: false,
+        collapse: false,
+        showSubtasks: true,
+      },
+    });
+
+    try {
+      await tasks.run({
+        isVerbose,
+      });
+    } catch (e) {
+      throw new MuteOneLineError(e);
+    }
+  }
+}
+
+GroupReindexCommand.description = `Reindex group of Core services
+
+Reindex group Core data
+`;
+
+GroupReindexCommand.flags = {
+  ...GroupBaseCommand.flags,
+  verbose: Flags.boolean({ char: 'v', description: 'use verbose mode for output', default: false }),
+};
+
+module.exports = GroupReindexCommand;
@@ -76,9 +76,9 @@ class ConfigFileJsonRepository {
    * Save configs to file
    *
    * @param {ConfigFile} configFile
-   * @returns {Promise<void>}
+   * @returns {void}
    */
-  async write(configFile) {
+  write(configFile) {
     const configFileJSON = JSON.stringify(configFile.toObject(), undefined, 2);
 
     fs.writeFileSync(CONFIG_FILE_PATH, configFileJSON, 'utf8');

@@ -47,7 +47,7 @@ function startCoreFactory(
 
     if (options.wallet) {
       if (isMasternode) {
-        throw new Error('You cannot run masternode with wallet mode on')
+        throw new Error('You cannot run masternode with wallet mode on');
       }
 
       coreCommand.push('--disablewallet=0');

@@ -4,26 +4,29 @@ const wait = require('../util/wait');
  * Wait Core to be synced
  *
  * @typedef {waitForCoreSync}
- * @param {RpcClient} rpcClient
- * @param {function(progress: number)} [progressCallback]
+ * @param {CoreService} coreService
+ * @param {function(progress: {percent: number, blocks: number, headers: number})} progressCallback
  * @return {Promise<void>}
  */
-async function waitForCoreSync(rpcClient, progressCallback = () => {}) {
+async function waitForCoreSync(coreService, progressCallback = () => {}) {
   let isSynced = false;
   let isBlockchainSynced = false;
   let verificationProgress = 0.0;
+  let headers = 0;
+  let blocks = 0;
 
   do {
     ({
       result: { IsSynced: isSynced, IsBlockchainSynced: isBlockchainSynced },
-    } = await rpcClient.mnsync('status'));
+    } = await coreService.getRpcClient().mnsync('status'));
+
     ({
-      result: { verificationprogress: verificationProgress },
-    } = await rpcClient.getBlockchainInfo());
+      result: { verificationprogress: verificationProgress, headers, blocks },
+    } = await coreService.getRpcClient().getBlockchainInfo());
 
     if (!isSynced || !isBlockchainSynced) {
       await wait(10000);
-      progressCallback(verificationProgress);
+      progressCallback({ percent: verificationProgress, headers, blocks });
     }
   } while (!isSynced || !isBlockchainSynced);
 }

@@ -64,6 +64,7 @@ const waitForNodeToBeReadyTaskFactory = require('./listr/tasks/platform/waitForN
 const enableCoreQuorumsTaskFactory = require('./listr/tasks/setup/local/enableCoreQuorumsTaskFactory');
 const startGroupNodesTaskFactory = require('./listr/tasks/startGroupNodesTaskFactory');
 const buildServicesTaskFactory = require('./listr/tasks/buildServicesTaskFactory');
+const reindexNodeTaskFactory = require('./listr/tasks/reindexNodeTaskFactory');
 
 const generateHDPrivateKeys = require('./util/generateHDPrivateKeys');
 
@@ -175,6 +176,7 @@ async function createDIContainer() {
     outputStatusOverview: asFunction(outputStatusOverviewFactory),
     waitForNodeToBeReadyTask: asFunction(waitForNodeToBeReadyTaskFactory).singleton(),
     enableCoreQuorumsTask: asFunction(enableCoreQuorumsTaskFactory).singleton(),
+    reindexNodeTask: asFunction(reindexNodeTaskFactory).singleton(),
   });
 
   return container;

@@ -16,6 +16,7 @@ function ensureHomeDirFactory() {
   function ensureHomeDir() {
     if (fs.existsSync(HOME_DIR_PATH)) {
       try {
+        // eslint-disable-next-line no-bitwise
         fs.accessSync(HOME_DIR_PATH, fs.constants.R_OK | fs.constants.W_OK);
       } catch (e) {
         throw new HomeDirIsNotWritableError(HOME_DIR_PATH);

@@ -71,9 +71,10 @@ function registerMasternodeTaskFactory(
         task: async (ctx) => (
           new Observable(async (observer) => {
             await waitForCoreSync(
-              ctx.coreService.getRpcClient(),
+              ctx.coreService,
               (verificationProgress) => {
-                observer.next(`${(verificationProgress * 100).toFixed(2)}% complete`);
+                const { percent, headers, blocks } = verificationProgress;
+                observer.next(`${(percent * 100).toFixed(2)}% complete (${blocks} / ${headers})`);
               },
             );