feat: allow to get drive's status from dashmate helper

packages/dashmate/Dockerfile

@@ -50,10 +50,11 @@ FROM node:16-alpine3.16
 
 ARG NODE_ENV=production
 ENV NODE_ENV ${NODE_ENV}
+ENV DASHMATE_HELPER=1
 
 RUN apk update && \
     apk --no-cache upgrade && \
-    apk add --no-cache docker-cli
+    apk add --no-cache docker-cli docker-cli-compose
 
 LABEL maintainer="Dash Developers <dev@dash.org>"
 LABEL description="Dashmate Helper Node.JS"

packages/dashmate/configs/migrations.js

@@ -418,4 +418,18 @@ module.exports = {
 
     return configFile;
   },
+  '0.24.0-dev.13': (configFile) => {
+    Object.entries(configFile.configs)
+      .forEach(([, config]) => {
+        if (config.platform) {
+          if (config.group === 'local') {
+            config.platform.drive.tenderdash.moniker = config.name;
+          } else {
+            config.platform.drive.tenderdash.moniker = null;
+          }
+        }
+      });
+
+    return configFile;
+  },
 };

packages/dashmate/configs/schema/configJsonSchema.js

@@ -491,14 +491,18 @@ module.exports = {
                 nodeKey: {
                   type: 'object',
                 },
+                moniker: {
+                  type: ['string', 'null'],
+                },
                 genesis: {
                   type: 'object',
                 },
                 nodeId: {
                   type: ['string', 'null'],
                 },
               },
-              required: ['docker', 'p2p', 'rpc', 'consensus', 'nodeKey', 'genesis', 'nodeId'],
+              required: ['docker', 'p2p', 'rpc', 'consensus',
+                'nodeKey', 'moniker', 'genesis', 'nodeId'],
               additionalProperties: false,
             },
           },

packages/dashmate/configs/system/base.js

@@ -165,6 +165,7 @@ module.exports = {
 
         },
         nodeId: null,
+        moniker: null,
       },
     },
     dpns: {

packages/dashmate/src/commands/status/platform.js

@@ -43,51 +43,64 @@ class PlatformStatusCommand extends ConfigBaseCommand {
       throw new Error('Platform status is not available until core sync is complete!');
     }
 
-    const {
-      httpService,
-      httpPort,
-      httpPortState,
-      gRPCService,
-      gRPCPort,
-      gRPCPortState,
-      p2pService,
-      p2pPort,
-      p2pPortState,
-      rpcService,
-      tenderdash,
-    } = scope;
-
-    const plain = {
-      'HTTP service': httpService,
-      'HTTP port': `${httpPort} ${colors.portState(httpPortState)(httpPortState)}`,
-      'GRPC service': gRPCService,
-      'GRPC port': `${gRPCPort} ${colors.portState(gRPCPortState)(gRPCPortState)}`,
-      'P2P service': p2pService,
-      'P2P port': `${p2pPort} ${colors.portState(p2pPortState)(p2pPortState)}`,
-      'RPC service': rpcService,
-    };
-
-    if (tenderdash.version) {
+    if (flags.format === OUTPUT_FORMATS.PLAIN) {
       const {
-        dockerStatus,
-        serviceStatus,
-        version: tenderdashVersion,
-        lastBlockHeight: platformBlockHeight,
-        latestAppHash: platformLatestAppHash,
-        peers: platformPeers,
-        network: tenderdashNetwork,
-      } = tenderdash;
-
-      plain['Docker Status'] = dockerStatus;
-      plain['Service Status'] = colors.status(serviceStatus)(serviceStatus);
-      plain['Network'] = tenderdashNetwork;
-      plain['Tenderdash Version'] = tenderdashVersion;
-      plain['Block height'] = platformBlockHeight;
-      plain['Peer count'] = platformPeers;
-      plain['App hash'] = platformLatestAppHash;
+        httpService,
+        httpPort,
+        httpPortState,
+        gRPCService,
+        gRPCPort,
+        gRPCPortState,
+        p2pService,
+        p2pPort,
+        p2pPortState,
+        rpcService,
+        tenderdash,
+        drive,
+      } = scope;
+
+      const plain = {
+        'HTTP service': httpService,
+        'HTTP port': `${httpPort} ${colors.portState(httpPortState)(httpPortState)}`,
+        'GRPC service': gRPCService,
+        'GRPC port': `${gRPCPort} ${colors.portState(gRPCPortState)(gRPCPortState)}`,
+        'P2P service': p2pService,
+        'P2P port': `${p2pPort} ${colors.portState(p2pPortState)(p2pPortState)}`,
+        'RPC service': rpcService,
+      };
+
+      const { dockerStatus: tenderdashDockerStatus } = tenderdash;
+      const { serviceStatus: tenderdashServiceStatus } = tenderdash;
+
+      const { dockerStatus: driveDockerStatus } = drive;
+      const { serviceStatus: driveServiceStatus } = drive;
+
+      plain['Tenderdash Docker Status'] = colors.docker(tenderdashDockerStatus)(tenderdashDockerStatus);
+      plain['Tenderdash Service Status'] = colors.status(tenderdashServiceStatus)(tenderdashServiceStatus);
+
+      plain['Drive Docker Status'] = colors.docker(driveDockerStatus)(driveDockerStatus);
+      plain['Drive Service Status'] = colors.status(driveServiceStatus)(driveServiceStatus);
+
+      if (tenderdash.version) {
+        const {
+          version: tenderdashVersion,
+          lastBlockHeight: platformBlockHeight,
+          latestAppHash: platformLatestAppHash,
+          peers: platformPeers,
+          network: tenderdashNetwork,
+        } = tenderdash;
+
+        plain['Network'] = tenderdashNetwork;
+        plain['Tenderdash Version'] = tenderdashVersion;
+        plain['Block height'] = platformBlockHeight;
+        plain['Peer count'] = platformPeers;
+        plain['App hash'] = platformLatestAppHash;
+      }
+
+      return printObject(plain, flags.format);
     }
 
-    return printObject(plain, flags.format);
+    return printObject(scope, flags.format);
   }
 }
 

packages/dashmate/src/core/startCoreFactory.js

@@ -5,13 +5,15 @@ const CoreService = require('./CoreService');
  * @param {waitForCoreStart} waitForCoreStart
  * @param {waitForCoreSync} waitForCoreSync
  * @param {DockerCompose} dockerCompose
+ * @param {getConnectionHost} getConnectionHost
  * @return {startCore}
  */
 function startCoreFactory(
   createRpcClient,
   waitForCoreStart,
   waitForCoreSync,
   dockerCompose,
+  getConnectionHost,
 ) {
   /**
    * @typedef startCore
@@ -70,6 +72,7 @@ function startCoreFactory(
         port: config.get('core.rpc.port'),
         user: config.get('core.rpc.user'),
         pass: config.get('core.rpc.password'),
+        host: await getConnectionHost(config, 'core'),
       },
     );
 

packages/dashmate/src/createDIContainer.js

@@ -9,6 +9,7 @@ const {
 const Docker = require('dockerode');
 
 const ensureHomeDirFactory = require('./ensureHomeDirFactory');
+const getConnectionHostFactory = require('./getConnectionHostFactory');
 const ConfigFileJsonRepository = require('./config/configFile/ConfigFileJsonRepository');
 const createSystemConfigsFactory = require('./config/systemConfigs/createSystemConfigsFactory');
 const isSystemConfigFactory = require('./config/systemConfigs/isSystemConfigFactory');
@@ -106,6 +107,8 @@ async function createDIContainer() {
     createSystemConfigs: asFunction(createSystemConfigsFactory).singleton(),
     isSystemConfig: asFunction(isSystemConfigFactory).singleton(),
     migrateConfigFile: asValue(migrateConfigFile),
+    isHelper: asValue(process.env.DASHMATE_HELPER === '1'),
+    getConnectionHost: asClass(getConnectionHostFactory).singleton(),
     // `configFile` and `config` are registering on command init
   });
 

packages/dashmate/src/docker/DockerCompose.js

@@ -415,6 +415,22 @@ class DockerCompose {
       env,
     };
   }
+
+  /**
+   * Resolve container internal IP
+   *
+   * @param {Object} envs
+   * @param {string} serviceName
+   * @return {Promise<string>}
+   */
+  async getContainerIp(envs, serviceName) {
+    const containerInfo = await this.inspectService(envs, serviceName);
+
+    const [firstNetwork] = Object.keys(containerInfo.NetworkSettings.Networks);
+    const { IPAddress: containerIP } = containerInfo.NetworkSettings.Networks[firstNetwork];
+
+    return containerIP;
+  }
 }
 
 DockerCompose.DOCKER_COMPOSE_MIN_VERSION = '2.0.0';

packages/dashmate/src/getConnectionHostFactory.js

@@ -0,0 +1,19 @@
+function getConnectionHostFactory(dockerCompose, isHelper) {
+  /**
+   * Get proper service endpoint url
+   * @param config
+   * @param serviceName
+   * @return {Promise<string>}
+   */
+  async function getConnectionHost(config, serviceName) {
+    if (isHelper) {
+      return dockerCompose.getContainerIp(config.toEnvs(), serviceName);
+    }
+
+    return '127.0.0.1';
+  }
+
+  return getConnectionHost;
+}
+
+module.exports = getConnectionHostFactory;

packages/dashmate/src/listr/tasks/reindexNodeTaskFactory.js

@@ -13,6 +13,7 @@ const CoreService = require('../../core/CoreService');
  * @param {writeServiceConfigs} writeServiceConfigs
  * @param {configFileRepository} configFileRepository
  * @param {configFile} configFile
+ * @param {getConnectionHost} getConnectionHost
  * @return {reindexNodeTask}
  */
 function reindexNodeTaskFactory(
@@ -26,6 +27,7 @@ function reindexNodeTaskFactory(
   writeServiceConfigs,
   configFileRepository,
   configFile,
+  getConnectionHost,
 ) {
   /**
    * @typedef {reindexNodeTask}
@@ -94,6 +96,7 @@ function reindexNodeTaskFactory(
                 port: config.get('core.rpc.port'),
                 user: config.get('core.rpc.user'),
                 pass: config.get('core.rpc.password'),
+                host: await getConnectionHost(config, 'core'),
               },
             ),
             docker.getContainer(containerId),

packages/dashmate/src/listr/tasks/setup/setupLocalPresetTaskFactory.js

@@ -184,6 +184,7 @@ function setupLocalPresetTaskFactory(
                   config.set('platform.dapi.envoy.grpc.port', 3010 + (i * 100));
                   config.set('platform.drive.tenderdash.p2p.port', 26656 + (i * 100));
                   config.set('platform.drive.tenderdash.rpc.port', 26657 + (i * 100));
+                  config.set('platform.drive.tenderdash.moniker', config.name);
 
                   // Setup logs
                   if (ctx.debugLogs) {

packages/dashmate/src/listr/tasks/setup/setupRegularPresetTaskFactory.js

@@ -146,11 +146,6 @@ function setupRegularPresetTaskFactory(
         },
         options: { persistentOutput: true },
       },
-      {
-        title: 'Initialize Tenderdash',
-        enabled: (ctx) => ctx.preset !== PRESET_MAINNET,
-        task: (ctx) => tenderdashInitTask(ctx.config),
-      },
       {
         title: 'Set default config',
         task: (ctx, task) => {
@@ -245,6 +240,11 @@ function setupRegularPresetTaskFactory(
           return saveCertificateTask(ctx.config);
         },
       },
+      {
+        title: 'Initialize Tenderdash',
+        enabled: (ctx) => ctx.preset !== PRESET_MAINNET,
+        task: (ctx) => tenderdashInitTask(ctx.config),
+      },
     ]);
   }
 

packages/dashmate/src/listr/tasks/startGroupNodesTaskFactory.js

@@ -13,6 +13,7 @@ const { NETWORK_LOCAL } = require('../../constants');
  * @param {startNodeTask} startNodeTask
  * @param {waitForNodeToBeReadyTask} waitForNodeToBeReadyTask
  * @param {buildServicesTask} buildServicesTask
+ * @param {getConnectionHost} getConnectionHost
  * @return {startGroupNodesTask}
  */
 function startGroupNodesTaskFactory(
@@ -24,6 +25,7 @@ function startGroupNodesTaskFactory(
   startNodeTask,
   waitForNodeToBeReadyTask,
   buildServicesTask,
+  getConnectionHost,
 ) {
   /**
    * @typedef {startGroupNodesTask}
@@ -68,6 +70,7 @@ function startGroupNodesTaskFactory(
                 port: config.get('core.rpc.port'),
                 user: config.get('core.rpc.user'),
                 pass: config.get('core.rpc.password'),
+                host: await getConnectionHost(config, 'core'),
               });
 
               await waitForCorePeersConnected(rpcClient);

packages/dashmate/src/listr/tasks/startNodeTaskFactory.js

@@ -13,6 +13,7 @@ const { NETWORK_LOCAL } = require('../../constants');
  * @param {waitForMasternodesSync} waitForMasternodesSync
  * @param {createRpcClient} createRpcClient
  * @param {buildServicesTask} buildServicesTask
+ * @param getConnectionHost {getConnectionHost}
  * @return {startNodeTask}
  */
 function startNodeTaskFactory(
@@ -21,6 +22,7 @@ function startNodeTaskFactory(
   waitForMasternodesSync,
   createRpcClient,
   buildServicesTask,
+  getConnectionHost,
 ) {
   /**
    * @typedef {startNodeTask}
@@ -106,6 +108,7 @@ function startNodeTaskFactory(
             port: config.get('core.rpc.port'),
             user: config.get('core.rpc.user'),
             pass: config.get('core.rpc.password'),
+            host: await getConnectionHost(config, 'core'),
           });
 
           return new Observable(async (observer) => {

packages/dashmate/src/listr/tasks/stopNodeTaskFactory.js

@@ -3,11 +3,13 @@ const { Listr } = require('listr2');
 /**
  * @param {DockerCompose} dockerCompose
  * @param {createRpcClient} createRpcClient
+ * @param {getConnectionHost} getConnectionHost
  * @return {stopNodeTask}
  */
 function stopNodeTaskFactory(
   dockerCompose,
   createRpcClient,
+  getConnectionHost,
 ) {
   /**
    * Stop node
@@ -36,6 +38,7 @@ function stopNodeTaskFactory(
             port: config.get('core.rpc.port'),
             user: config.get('core.rpc.user'),
             pass: config.get('core.rpc.password'),
+            host: await getConnectionHost(config, 'core'),
           });
 
           const { result: { mediantime } } = await rpcClient.getBlockchainInfo();

packages/dashmate/src/status/colors.js

@@ -1,6 +1,7 @@
 const chalk = require('chalk');
 const PortStateEnum = require('../enums/portState');
 const ServiceStatusEnum = require('../enums/serviceStatus');
+const DockerStatusEnum = require('../enums/dockerStatus');
 
 module.exports = {
 
@@ -14,6 +15,14 @@ module.exports = {
     }
     return chalk.red;
   },
+  docker: (status) => {
+    switch (status) {
+      case DockerStatusEnum.running:
+        return chalk.green;
+      default:
+        return chalk.red;
+    }
+  },
   status: (status) => {
     switch (status) {
       case ServiceStatusEnum.up: