Merge pull request #2763 from input-output-hk/update-master-with-release-4.5.2-without-rts-flags

Update master with release 4.5.2 without rts flags

Author: danielmain

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 4.5.2
+
+### Fixes
+
+- Fixed Cardano Node starting/stopping issues
+
 ## 4.5.1
 
 ### Fixes

package.json

@@ -1,7 +1,7 @@
 {
   "name": "daedalus",
   "productName": "Daedalus",
-  "version": "4.5.1",
+  "version": "4.5.2",
   "description": "Cryptocurrency Wallet",
   "main": "./dist/main/index.js",
   "scripts": {
@@ -111,7 +111,7 @@
     "eslint-config-airbnb": "18.2.0",
     "eslint-config-prettier": "6.12.0",
     "eslint-formatter-pretty": "4.0.0",
-    "eslint-import-resolver-webpack": "^0.13.1",
+    "eslint-import-resolver-webpack": "0.13.1",
     "eslint-plugin-flowtype": "5.2.0",
     "eslint-plugin-import": "2.23.3",
     "eslint-plugin-jsx-a11y": "6.3.1",
@@ -182,7 +182,7 @@
     "cardano-js": "0.4.7",
     "cardano-launcher": "0.20210215.0",
     "cbor": "5.0.2",
-    "check-disk-space": "2.1.0",
+    "check-disk-space": "3.0.1",
     "chroma-js": "2.1.0",
     "classnames": "2.2.6",
     "csv-stringify": "5.5.1",

source/common/ipc/api.js

@@ -111,7 +111,7 @@ export type ToggleUiPartRendererResponse = void;
  * Channel for checking the disk space available
  */
 export const GET_DISK_SPACE_STATUS_CHANNEL = 'GetDiskSpaceStatusChannel';
-export type GetDiskSpaceStatusRendererRequest = number | any;
+export type GetDiskSpaceStatusRendererRequest = void;
 export type GetDiskSpaceStatusMainResponse = CheckDiskSpaceResponse;
 
 /**

source/common/types/no-disk-space.types.js

@@ -1,9 +1,13 @@
 // @flow
+
 export type CheckDiskSpaceResponse = {
   isNotEnoughDiskSpace: boolean,
   diskSpaceRequired: string,
   diskSpaceMissing: string,
   diskSpaceRecommended: string,
   diskSpaceAvailable: string,
   hadNotEnoughSpaceLeft: boolean,
+  diskSpaceAvailableRaw: number,
+  diskTotalSpaceRaw: number,
+  isError: boolean,
 };

source/main/config.js

@@ -159,10 +159,12 @@ export const NODE_UPDATE_TIMEOUT = isTest ? 10000 : 5 * 60 * 1000; // 5 minutes
 
 export const DISK_SPACE_REQUIRED = 2 * 1073741274; // 2 GB | unit: bytes
 export const DISK_SPACE_REQUIRED_MARGIN_PERCENTAGE = 10; // 10% of the available disk space
+export const DISK_SPACE_CHECK_DONT_BOTHER_ME_INTERVAL = Number.MAX_SAFE_INTEGER; // Maximum interval
 export const DISK_SPACE_CHECK_LONG_INTERVAL = 10 * 60 * 1000; // 10 minutes | unit: milliseconds
 export const DISK_SPACE_CHECK_MEDIUM_INTERVAL = 60 * 1000; // 1 minute | unit: milliseconds
 export const DISK_SPACE_CHECK_SHORT_INTERVAL = isTest ? 2000 : 10 * 1000; // 10 seconds | unit: milliseconds
 export const DISK_SPACE_RECOMMENDED_PERCENTAGE = 15; // 15% of the total disk space
+export const DISK_SPACE_CHECK_TIMEOUT = 9 * 1000; // Timeout for checking disks pace
 
 export const BLOCK_REPLAY_PROGRESS_CHECK_INTERVAL = 1 * 1000; // 1 seconds | unit: milliseconds
 

source/main/index.js

@@ -118,8 +118,9 @@ const onAppReady = async () => {
   const platformVersion = os.release();
   const ram = JSON.stringify(os.totalmem(), null, 2);
   const startTime = new Date().toISOString();
-  // first checks for japanese locale, otherwise returns english
+  // first checks for Japanese locale, otherwise returns english
   const systemLocale = detectSystemLocale();
+  const userLocale = getLocale(network);
 
   const systemInfo = logSystemInfo({
     cardanoNodeVersion,
@@ -149,27 +150,29 @@ const onAppReady = async () => {
     cwd: process.cwd(),
   });
 
+  logger.info('System and user locale', { systemLocale, userLocale });
+
   ensureXDGDataIsSet();
   await installChromeExtensions(isDev);
 
-  // Detect locale
-  const locale = getLocale(network);
+  logger.info('Setting up Main Window...');
   mainWindow = createMainWindow(
-    locale,
+    userLocale,
     restoreSavedWindowBounds(screen, requestElectronStore)
   );
   saveWindowBoundsOnSizeAndPositionChange(mainWindow, requestElectronStore);
 
+  logger.info('Setting up Cardano Node...');
   cardanoNode = setupCardanoNode(launcherConfig, mainWindow);
 
-  buildAppMenus(mainWindow, cardanoNode, locale, {
+  buildAppMenus(mainWindow, cardanoNode, userLocale, {
     isNavigationEnabled: false,
   });
 
   enableApplicationMenuNavigationChannel.onReceive(
     () =>
       new Promise((resolve) => {
-        buildAppMenus(mainWindow, cardanoNode, locale, {
+        buildAppMenus(mainWindow, cardanoNode, userLocale, {
           isNavigationEnabled: true,
         });
         resolve();
@@ -179,10 +182,10 @@ const onAppReady = async () => {
   rebuildApplicationMenu.onReceive(
     (data) =>
       new Promise((resolve) => {
-        buildAppMenus(mainWindow, cardanoNode, locale, {
+        buildAppMenus(mainWindow, cardanoNode, userLocale, {
           isNavigationEnabled: data.isNavigationEnabled,
         });
-        mainWindow.updateTitle(locale);
+        mainWindow.updateTitle(userLocale);
         resolve();
       })
   );

source/main/utils/handleDiskSpace.js

@@ -5,18 +5,69 @@ import prettysize from 'prettysize';
 import { getDiskSpaceStatusChannel } from '../ipc/get-disk-space-status';
 import { logger } from './logging';
 import {
-  DISK_SPACE_REQUIRED,
-  DISK_SPACE_REQUIRED_MARGIN_PERCENTAGE,
+  DISK_SPACE_CHECK_DONT_BOTHER_ME_INTERVAL,
   DISK_SPACE_CHECK_LONG_INTERVAL,
   DISK_SPACE_CHECK_MEDIUM_INTERVAL,
   DISK_SPACE_CHECK_SHORT_INTERVAL,
   DISK_SPACE_RECOMMENDED_PERCENTAGE,
+  DISK_SPACE_REQUIRED,
+  DISK_SPACE_CHECK_TIMEOUT,
+  DISK_SPACE_REQUIRED_MARGIN_PERCENTAGE,
   stateDirectoryPath,
 } from '../config';
 import { CardanoNodeStates } from '../../common/types/cardano-node.types';
 import { CardanoNode } from '../cardano/CardanoNode';
 import type { CheckDiskSpaceResponse } from '../../common/types/no-disk-space.types';
 
+const getDiskCheckReport = async (
+  path: string,
+  timeout: number = DISK_SPACE_CHECK_TIMEOUT
+): Promise<CheckDiskSpaceResponse> => {
+  const initialReport: CheckDiskSpaceResponse = {
+    isNotEnoughDiskSpace: false,
+    diskSpaceRequired: '',
+    diskSpaceMissing: '',
+    diskSpaceRecommended: '',
+    diskSpaceAvailable: '',
+    hadNotEnoughSpaceLeft: false,
+    diskSpaceAvailableRaw: 0,
+    diskTotalSpaceRaw: 0,
+    isError: false,
+  };
+
+  return Promise.race([
+    // Disk space check promise
+    new Promise((resolve) => {
+      checkDiskSpace(path)
+        .then(({ free, size }) => {
+          logger.info('[DISK-SPACE-DEBUG] Disk space check completed', {
+            free,
+            size,
+          });
+          resolve({
+            ...initialReport,
+            diskSpaceAvailableRaw: free,
+            diskSpaceAvailable: prettysize(free),
+            diskTotalSpace: size,
+          });
+        })
+        .catch((error) => {
+          logger.error(
+            '[DISK-SPACE-DEBUG] Error getting diskCheckReport',
+            error
+          );
+          resolve({ ...initialReport, isError: true });
+        });
+    }),
+    // Timeout promise
+    new Promise((resolve) => {
+      setTimeout(() => {
+        resolve({ ...initialReport, isError: true });
+      }, timeout);
+    }),
+  ]);
+};
+
 export const handleDiskSpace = (
   mainWindow: BrowserWindow,
   cardanoNode: CardanoNode
@@ -30,30 +81,34 @@ export const handleDiskSpace = (
     forceDiskSpaceRequired?: number
   ): Promise<CheckDiskSpaceResponse> => {
     const diskSpaceRequired = forceDiskSpaceRequired || DISK_SPACE_REQUIRED;
-    try {
-      const {
-        free: diskSpaceAvailable,
-        size: diskTotalSpace,
-      } = await checkDiskSpace(stateDirectoryPath);
+
+    const response = await getDiskCheckReport(stateDirectoryPath);
+
+    if (response.isError) {
+      logger.info(
+        '[DISK-SPACE-DEBUG] We could not check disk space, but we will try to start cardano-node anyway'
+      );
+      resetInterval(DISK_SPACE_CHECK_DONT_BOTHER_ME_INTERVAL);
+    } else {
       const diskSpaceMissing = Math.max(
-        diskSpaceRequired - diskSpaceAvailable,
+        diskSpaceRequired - response.diskSpaceAvailableRaw,
         0
       );
       const diskSpaceRecommended =
-        (diskTotalSpace * DISK_SPACE_RECOMMENDED_PERCENTAGE) / 100;
+        (response.diskTotalSpaceRaw * DISK_SPACE_RECOMMENDED_PERCENTAGE) / 100;
       const diskSpaceRequiredMargin =
         diskSpaceRequired -
         (diskSpaceRequired * DISK_SPACE_REQUIRED_MARGIN_PERCENTAGE) / 100;
 
-      if (diskSpaceAvailable <= diskSpaceRequiredMargin) {
+      if (response.diskSpaceAvailableRaw <= diskSpaceRequiredMargin) {
         if (!isNotEnoughDiskSpace) {
           // State change: transitioning from enough to not-enough disk space
           setDiskSpaceIntervalChecking(DISK_SPACE_CHECK_SHORT_INTERVAL);
           isNotEnoughDiskSpace = true;
         }
-      } else if (diskSpaceAvailable >= diskSpaceRequired) {
+      } else if (response.diskSpaceAvailableRaw >= diskSpaceRequired) {
         const newDiskSpaceCheckIntervalLength =
-          diskSpaceAvailable >= diskSpaceRequired * 2
+          response.diskSpaceAvailableRaw >= diskSpaceRequired * 2
             ? DISK_SPACE_CHECK_LONG_INTERVAL
             : DISK_SPACE_CHECK_MEDIUM_INTERVAL;
         if (isNotEnoughDiskSpace) {
@@ -70,32 +125,29 @@ export const handleDiskSpace = (
           setDiskSpaceIntervalChecking(newDiskSpaceCheckIntervalLength);
         }
       }
+      response.isNotEnoughDiskSpace = isNotEnoughDiskSpace;
+      response.diskSpaceRequired = prettysize(diskSpaceRequired);
+      response.diskSpaceMissing = prettysize(diskSpaceMissing);
+      response.diskSpaceRecommended = prettysize(diskSpaceRecommended);
+      response.hadNotEnoughSpaceLeft = hadNotEnoughSpaceLeft;
+    }
 
-      const response = {
-        isNotEnoughDiskSpace,
-        diskSpaceRequired: prettysize(diskSpaceRequired),
-        diskSpaceMissing: prettysize(diskSpaceMissing),
-        diskSpaceRecommended: prettysize(diskSpaceRecommended),
-        diskSpaceAvailable: prettysize(diskSpaceAvailable),
-        hadNotEnoughSpaceLeft,
-      };
-
-      const NO_SPACE_AND_CARDANO_NODE_CAN_BE_STOPPED =
-        isNotEnoughDiskSpace &&
-        cardanoNode.state !== CardanoNodeStates.STOPPING &&
-        cardanoNode.state !== CardanoNodeStates.STOPPED;
-
-      const CARDANO_NODE_CAN_BE_STARTED_FOR_THE_FIRST_TIME =
-        !isNotEnoughDiskSpace &&
-        cardanoNode.state === CardanoNodeStates.STOPPED &&
-        cardanoNode._startupTries === 0;
-
-      const CARDANO_NODE_CAN_BE_STARTED_AFTER_FREEING_SPACE =
-        !isNotEnoughDiskSpace &&
-        cardanoNode.state !== CardanoNodeStates.STOPPED &&
-        cardanoNode.state !== CardanoNodeStates.STOPPING &&
-        hadNotEnoughSpaceLeft;
+    const NO_SPACE_AND_CARDANO_NODE_CAN_BE_STOPPED =
+      isNotEnoughDiskSpace &&
+      cardanoNode.state !== CardanoNodeStates.STOPPING &&
+      cardanoNode.state !== CardanoNodeStates.STOPPED;
 
+    const CARDANO_NODE_CAN_BE_STARTED_FOR_THE_FIRST_TIME =
+      !isNotEnoughDiskSpace &&
+      cardanoNode.state === CardanoNodeStates.STOPPED &&
+      cardanoNode._startupTries === 0;
+
+    const CARDANO_NODE_CAN_BE_STARTED_AFTER_FREEING_SPACE =
+      !isNotEnoughDiskSpace &&
+      cardanoNode.state !== CardanoNodeStates.STOPPED &&
+      cardanoNode.state !== CardanoNodeStates.STOPPING &&
+      hadNotEnoughSpaceLeft;
+    try {
       switch (true) {
         case NO_SPACE_AND_CARDANO_NODE_CAN_BE_STOPPED:
           try {
@@ -125,25 +177,20 @@ export const handleDiskSpace = (
           break;
         default:
       }
-      await getDiskSpaceStatusChannel.send(response, mainWindow.webContents);
-      return response;
     } catch (error) {
-      // Remove diskSpaceCheckInterval if set
-      if (diskSpaceCheckInterval) {
-        clearInterval(diskSpaceCheckInterval);
-        // Reset to default check interval
-        diskSpaceCheckIntervalLength = DISK_SPACE_CHECK_LONG_INTERVAL;
-      }
-      const response = {
-        isNotEnoughDiskSpace: false,
-        diskSpaceRequired: '',
-        diskSpaceMissing: '',
-        diskSpaceRecommended: '',
-        diskSpaceAvailable: '',
-        hadNotEnoughSpaceLeft: false,
-      };
-      await getDiskSpaceStatusChannel.send(response, mainWindow.webContents);
-      return response;
+      logger.error('[DISK-SPACE-DEBUG] Unknown error', error);
+      resetInterval(DISK_SPACE_CHECK_MEDIUM_INTERVAL);
+    }
+    await getDiskSpaceStatusChannel.send(response, mainWindow.webContents);
+    return response;
+  };
+
+  const resetInterval = (interval: number) => {
+    // Remove diskSpaceCheckInterval if set
+    if (diskSpaceCheckInterval) {
+      clearInterval(diskSpaceCheckInterval);
+      // Reset to default check interval
+      diskSpaceCheckIntervalLength = interval;
     }
   };
 
@@ -153,17 +200,19 @@ export const handleDiskSpace = (
     clearInterval(diskSpaceCheckInterval);
     diskSpaceCheckInterval = setInterval(async () => {
       const response = await handleCheckDiskSpace(hadNotEnoughSpaceLeft);
-      hadNotEnoughSpaceLeft = response.hadNotEnoughSpaceLeft;
+      hadNotEnoughSpaceLeft = response?.hadNotEnoughSpaceLeft;
     }, interval);
     diskSpaceCheckIntervalLength = interval;
   };
 
   // Start default interval
   setDiskSpaceIntervalChecking(diskSpaceCheckIntervalLength);
 
-  getDiskSpaceStatusChannel.onReceive((diskSpaceRequired) =>
-    handleCheckDiskSpace(hadNotEnoughSpaceLeft, diskSpaceRequired)
-  );
+  getDiskSpaceStatusChannel.onReceive(async () => {
+    const diskReport = await getDiskCheckReport(stateDirectoryPath);
+    await getDiskSpaceStatusChannel.send(diskReport, mainWindow.webContents);
+    return diskReport;
+  });
 
   return handleCheckDiskSpace;
 };