[Fix] Installation of HP games, statuses, filters, stuck download and more (#328)

* fix: unzip, disk write and throttle progress

* fix: progress on download screen

* chore: mac notarize var env

* feat: implement getExtraInfo for HP

* fix: hide non-working items from submenu

* feat: improve initial download and logging

* chore: remove unused warning

* feat: show extracting message on gamepage

* fix: default platform on install dialog

* fix: logging and button label

* fix: OS filters for HP games

* fix: downloaded bytes

* fix: platform name and install size on gamepage

* chore: log and mac build

* add unit tests, fix extractZip

* prettier

---------

Co-authored-by: BrettCleary <27568879+BrettCleary@users.noreply.github.com>

Author: flavioislima

package.json

@@ -161,6 +161,7 @@
     "@types/jsdom": "^20.0.0",
     "@types/qrcode": "^1.5.0",
     "@types/react-blockies": "^1.4.1",
+    "@types/unzipper": "^0.10.6",
     "@walletconnect/web3-provider": "^1.8.0",
     "axios": "^0.26.1",
     "bn.js": "^5.2.1",
@@ -205,6 +206,7 @@
     "systeminformation": "^5.15.0",
     "ts-prune": "^0.10.3",
     "tslib": "^2.4.0",
+    "unzipper": "^0.10.14",
     "web3": "^1.7.5"
   },
   "scripts": {

sign/notarize.js

@@ -3,7 +3,7 @@ const { notarize } = require('@electron/notarize')
 
 exports.default = async function notarizing(context) {
   const { electronPlatformName, appOutDir } = context
-  if (electronPlatformName !== 'darwin' || process.env.NOTARIZE === 'false') {
+  if (electronPlatformName !== 'darwin' || process.env.CSC_IDENTITY_AUTO_DISCOVERY === 'false') {
     console.log('Notarizing skipped')
     return
   }

src/backend/__mocks__/test.zip

@@ -3,6 +3,15 @@ import { app } from 'electron'
 import { logError } from '../logger/logger'
 import * as utils from '../utils'
 import { test_data } from './test_data/github-api-heroic-test-data.json'
+import path from 'path'
+import {
+  copyFileSync,
+  existsSync,
+  readFileSync,
+  rmSync,
+  rmdirSync,
+  renameSync
+} from 'graceful-fs'
 
 jest.mock('electron')
 jest.mock('../logger/logger')
@@ -131,4 +140,150 @@ describe('backend/utils.ts', () => {
       expect(releases).toMatchInlineSnapshot(`Array []`)
     })
   })
+
+  describe('calculateEta', () => {
+    const getBytesFromMB = (sizeInMB: number) => sizeInMB * 1024 * 1024
+    test('normal download seconds', () => {
+      const downloadedMB = 10
+      const totalSizeMB = 100
+      const downloadSpeedMB = 10
+      const etaString = utils.calculateEta(
+        getBytesFromMB(downloadedMB),
+        getBytesFromMB(downloadSpeedMB),
+        getBytesFromMB(totalSizeMB)
+      )
+      expect(etaString).toEqual('00:00:09')
+    })
+
+    test('downloaded > total size', () => {
+      const downloadedMB = 105
+      const totalSizeMB = 100
+      const downloadSpeedMB = 10
+      const etaString = utils.calculateEta(
+        getBytesFromMB(downloadedMB),
+        getBytesFromMB(downloadSpeedMB),
+        getBytesFromMB(totalSizeMB)
+      )
+      expect(etaString).toEqual('00:00:00')
+    })
+
+    test('with last progress time 4 seconds ago', () => {
+      const downloadedMB = 10
+      const totalSizeMB = 100
+      const downloadSpeedMB = 10
+      const lastProgressTime = Date.now().valueOf() - 1000 * 4
+      const etaString = utils.calculateEta(
+        getBytesFromMB(downloadedMB),
+        getBytesFromMB(downloadSpeedMB),
+        getBytesFromMB(totalSizeMB),
+        lastProgressTime
+      )
+      expect(etaString).toEqual('00:00:05')
+    })
+
+    test('normal download minutes', () => {
+      const downloadedMB = 100
+      const totalSizeMB = 1000
+      const downloadSpeedMB = 10
+      const etaString = utils.calculateEta(
+        getBytesFromMB(downloadedMB),
+        getBytesFromMB(downloadSpeedMB),
+        getBytesFromMB(totalSizeMB)
+      )
+      expect(etaString).toEqual('00:01:30')
+    })
+
+    test('normal download hours', () => {
+      const downloadedMB = 100
+      const totalSizeMB = 100000
+      const downloadSpeedMB = 10
+      const etaString = utils.calculateEta(
+        getBytesFromMB(downloadedMB),
+        getBytesFromMB(downloadSpeedMB),
+        getBytesFromMB(totalSizeMB)
+      )
+      expect(etaString).toEqual('02:46:30')
+    })
+  })
+
+  describe('bytesToSize', () => {
+    test('Bytes', () => {
+      expect(utils.bytesToSize(0)).toEqual('0 Bytes')
+      expect(utils.bytesToSize(10)).toEqual('10 Bytes')
+      expect(utils.bytesToSize(112)).toEqual('112 Bytes')
+    })
+
+    test('Kilobytes', () => {
+      expect(utils.bytesToSize(1024)).toEqual('1 KB')
+      expect(utils.bytesToSize(1025)).toEqual('1 KB')
+      expect(utils.bytesToSize(2059)).toEqual('2.01 KB')
+    })
+
+    test('Megabytes', () => {
+      expect(utils.bytesToSize(1024 * 1024)).toEqual('1 MB')
+      expect(utils.bytesToSize(1025 * 1024)).toEqual('1 MB')
+      expect(utils.bytesToSize(2059 * 1024)).toEqual('2.01 MB')
+    })
+
+    test('Gigabytes', () => {
+      expect(utils.bytesToSize(1024 * 1024 * 1029)).toEqual('1 GB')
+      expect(utils.bytesToSize(1025 * 1024 * 2056)).toEqual('2.01 GB')
+      expect(utils.bytesToSize(2059 * 1024 * 3045)).toEqual('5.98 GB')
+    })
+
+    test('Terabytes', () => {
+      expect(utils.bytesToSize(1024 * 1024 * 1029 * 44000)).toEqual('43.18 TB')
+      expect(utils.bytesToSize(1025 * 1024 * 2056 * 21010)).toEqual('41.24 TB')
+      expect(utils.bytesToSize(2059 * 1024 * 3045 * 4000)).toEqual('23.36 TB')
+    })
+  })
+
+  describe('extractZip', () => {
+    let testCopyZipPath: string
+    let destFilePath: string
+
+    beforeEach(() => {
+      const testZipPath = path.resolve('./src/backend/__mocks__/test.zip')
+      //copy zip because extract will delete it
+      testCopyZipPath = path.resolve('./src/backend/__mocks__/test2.zip')
+      copyFileSync(testZipPath, testCopyZipPath)
+      destFilePath = path.resolve('./src/backend/__mocks__/test')
+    })
+
+    afterEach(async () => {
+      const extractPromise = utils.extractZip(testCopyZipPath, destFilePath)
+      await extractPromise
+      expect(extractPromise).resolves
+
+      const testTxtFilePath = path.resolve(destFilePath, './test.txt')
+      console.log('checking dest file path ', testTxtFilePath)
+      expect(existsSync(testTxtFilePath)).toBe(true)
+
+      const testMessage = readFileSync(testTxtFilePath).toString()
+      console.log('unzipped file contents: ', testMessage)
+      expect(testMessage).toEqual('this is a test message')
+
+      //extract deletes the zip file used to extract async so we wait and then check
+      await utils.wait(100)
+      expect(existsSync(testCopyZipPath)).toBe(false)
+
+      //clean up test
+      rmSync(testTxtFilePath)
+      rmdirSync(destFilePath)
+      expect(existsSync(testTxtFilePath)).toBe(false)
+      expect(existsSync(destFilePath)).toBe(false)
+    })
+
+    test('extract a normal test zip', async () => {
+      console.log('extracting test.zip')
+    })
+
+    test('extract a test zip with non ascii characters', async () => {
+      const renamedZipFilePath = path.resolve(
+        './src/backend/__mocks__/谷���新道ひばりヶ�.zip'
+      )
+      renameSync(testCopyZipPath, renamedZipFilePath)
+      testCopyZipPath = renamedZipFilePath
+    })
+  })
 })

src/backend/__tests__/utils.test.ts

@@ -105,7 +105,6 @@ import {
 import { handleProtocol } from './protocol'
 import {
   logChangedSetting,
-  logDebug,
   logError,
   logInfo,
   LogPrefix,
@@ -592,7 +591,6 @@ ipcMain.handle('checkDiskSpace', async (event, folder) => {
         message: `${getFileSize(free)} / ${getFileSize(diskSize)}`,
         validPath: !writeError
       }
-      logDebug(`${JSON.stringify(ret)}`, LogPrefix.Backend)
       res(ret)
     })
   })

src/backend/hyperplay-proxy-server

@@ -17,7 +17,9 @@ import {
   downloadFile,
   spawnAsync,
   killPattern,
-  shutdownWine
+  shutdownWine,
+  extractZip,
+  calculateEta
 } from 'backend/utils'
 import { notify } from 'backend/dialog/dialog'
 import path, { join } from 'path'
@@ -173,6 +175,10 @@ export async function importGame(
 const installDistributables = async (gamePath: string) => {
   const distFolder = path.join(gamePath, 'dist')
   if (!existsSync(distFolder)) {
+    logWarning(
+      `Tried to install distributables from ${distFolder} but folder does not exist!`,
+      LogPrefix.HyperPlay
+    )
     return
   }
 
@@ -215,9 +221,11 @@ async function downloadGame(
       downloadPath,
       createAbortController(appName),
       (downloadedBytes, downloadSpeed, diskWriteSpeed, progress) => {
-        // convert speed to Mb/s
-        downloadSpeed = Math.round(downloadSpeed / 1000000)
-        diskWriteSpeed = Math.round(diskWriteSpeed / 1000000)
+        const eta = calculateEta(
+          downloadedBytes,
+          downloadSpeed,
+          platformInfo.downloadSize
+        )
 
         window.webContents.send(`progressUpdate-${appName}`, {
           appName,
@@ -226,10 +234,11 @@ async function downloadGame(
           folder: destinationPath,
           progress: {
             percent: progress,
-            diskSpeed: diskWriteSpeed,
-            downSpeed: downloadSpeed,
-            bytes: downloadedBytes,
-            folder: destinationPath
+            diskSpeed: diskWriteSpeed / 1024 / 1024,
+            downSpeed: downloadSpeed / 1024 / 1024,
+            bytes: downloadedBytes / 1024 / 1024,
+            folder: destinationPath,
+            eta
           }
         })
       }
@@ -264,19 +273,19 @@ export async function install(
 
   logInfo(`Installing ${title} to ${dirpath}...`, LogPrefix.HyperPlay)
 
-  // download the zip file
-  try {
-    const appPlatform = handleArchAndPlatform(platformToInstall, releaseMeta)
-    const platformInfo = releaseMeta.platforms[appPlatform]
-    const zipName = encodeURI(platformInfo.name)
-    const tempfolder = path.join(configFolder, 'hyperplay', '.temp', appName)
+  const appPlatform = handleArchAndPlatform(platformToInstall, releaseMeta)
+  const platformInfo = releaseMeta.platforms[appPlatform]
+  const zipName = encodeURI(platformInfo.name)
+  const tempfolder = path.join(configFolder, 'hyperplay', '.temp', appName)
 
-    if (!existsSync(tempfolder)) {
-      mkdirSync(tempfolder, { recursive: true })
-    }
+  if (!existsSync(tempfolder)) {
+    mkdirSync(tempfolder, { recursive: true })
+  }
 
-    const zipFile = path.join(tempfolder, zipName)
+  const zipFile = path.join(tempfolder, zipName)
 
+  // download the zip file
+  try {
     // prevent naming conflicts where two developers release games with the same name
     const sanitizedDestinationFolderName =
       developer !== undefined
@@ -300,33 +309,10 @@ export async function install(
       })
 
       if (isWindows) {
-        await spawnAsync('powershell', [
-          'Expand-Archive',
-          '-LiteralPath',
-          `"${zipFile}"`,
-          '-DestinationPath',
-          `"${destinationPath}"`
-        ])
-
+        await extractZip(zipFile, destinationPath)
         await installDistributables(destinationPath)
       } else {
-        // extract the zip file and overwrite existing files
-        const { code, stderr } = await spawnAsync('unzip', [
-          '-o',
-          zipFile,
-          '-d',
-          destinationPath
-        ])
-        if (code !== 0) {
-          rmSync(zipFile)
-          clean(zipFile)
-          throw new Error(stderr)
-        }
-      }
-      rmSync(zipFile)
-
-      if (isWindows) {
-        await installDistributables(destinationPath)
+        await extractZip(zipFile, destinationPath)
       }
 
       if (isMac && executable.endsWith('.app')) {
@@ -377,6 +363,8 @@ export async function install(
     return { status: 'done' }
   } catch (error) {
     logInfo('Error while downloading and extracting game', LogPrefix.HyperPlay)
+    rmSync(zipFile)
+    clean(zipFile)
     return {
       status: 'error',
       error: `${error}`
@@ -474,17 +462,19 @@ export async function removeShortcuts(appName: string): Promise<void> {
 }
 
 export async function getExtraInfo(appName: string): Promise<ExtraInfo> {
-  logWarning(
-    `getExtraInfo not implemented on HyperPlay Game Manager. called for appName = ${appName}`
-  )
-  return {
-    about: {
-      description: '',
-      shortDescription: ''
-    },
-    reqs: [],
-    storeUrl: ''
+  const extraInfo = getGameInfo(appName).extra
+  if (!extraInfo) {
+    logWarning(`No extra info found for ${appName}`, LogPrefix.HyperPlay)
+    return {
+      about: {
+        description: '',
+        shortDescription: ''
+      },
+      reqs: [],
+      storeUrl: ''
+    }
   }
+  return extraInfo
 }
 
 export async function launch(
@@ -565,8 +555,5 @@ export async function syncSaves(
 }
 
 export async function forceUninstall(appName: string): Promise<void> {
-  logWarning(
-    `forceUninstall not implemented on HyperPlay Game Manager. Calling uninstall instead called for appName = ${appName}`
-  )
   await uninstall({ appName, shouldRemovePrefix: false })
 }

src/backend/main.ts

@@ -67,17 +67,14 @@ export function handleArchAndPlatform(
 
 export function handlePlatformReversed(platform: string) {
   switch (platform) {
-    case 'windows_arm64':
-      return 'Windows'
-    case 'linux_arm64':
-      return 'linux'
-    case 'darwin_arm64':
-      return 'Mac'
     case 'windows_amd64':
+    case 'windows_arm64':
       return 'Windows'
     case 'linux_amd64':
-      return 'linux'
+    case 'linux_arm64':
+      return 'Linux'
     case 'darwin_amd64':
+    case 'darwin_arm64':
       return 'Mac'
     case 'web':
       return 'Browser'