feat: add support for differential zip updates on macOS

packages/builder-util-runtime/src/index.ts

@@ -40,6 +40,8 @@ export { BlockMap } from "./blockMapApi"
 export const CURRENT_APP_INSTALLER_FILE_NAME = "installer.exe"
 // nsis-web
 export const CURRENT_APP_PACKAGE_FILE_NAME = "package.7z"
+// mac zip
+export const CURRENT_MAC_APP_ZIP_FILE_NAME = "update.zip"
 
 export function asArray<T>(v: null | undefined | T | Array<T>): Array<T> {
   if (v == null) {

packages/electron-updater/src/AppUpdater.ts

@@ -9,6 +9,7 @@ import {
   DownloadOptions,
   CancellationError,
   ProgressInfo,
+  BlockMap,
 } from "builder-util-runtime"
 import { randomBytes } from "crypto"
 import { EventEmitter } from "events"
@@ -29,6 +30,10 @@ import { ProviderPlatform } from "./providers/Provider"
 import type { TypedEmitter } from "tiny-typed-emitter"
 import Session = Electron.Session
 import { AuthInfo } from "electron"
+import { gunzipSync } from "zlib"
+import { blockmapFiles } from "./util"
+import { DifferentialDownloaderOptions } from "./differentialDownloader/DifferentialDownloader"
+import { GenericDifferentialDownloader } from "./differentialDownloader/GenericDifferentialDownloader"
 
 export type AppUpdaterEvents = {
   error: (error: Error, message?: string) => void
@@ -697,6 +702,63 @@ export abstract class AppUpdater extends (EventEmitter as new () => TypedEmitter
     log.info(`New version ${version} has been downloaded to ${updateFile}`)
     return await done(true)
   }
+  protected async differentialDownloadInstaller(
+    fileInfo: ResolvedUpdateFileInfo,
+    downloadUpdateOptions: DownloadUpdateOptions,
+    installerPath: string,
+    provider: Provider<any>,
+    oldInstallerFileName: string
+  ): Promise<boolean> {
+    try {
+      if (this._testOnlyOptions != null && !this._testOnlyOptions.isUseDifferentialDownload) {
+        return true
+      }
+      const blockmapFileUrls = blockmapFiles(fileInfo.url, this.app.version, downloadUpdateOptions.updateInfoAndProvider.info.version)
+      this._logger.info(`Download block maps (old: "${blockmapFileUrls[0]}", new: ${blockmapFileUrls[1]})`)
+
+      const downloadBlockMap = async (url: URL): Promise<BlockMap> => {
+        const data = await this.httpExecutor.downloadToBuffer(url, {
+          headers: downloadUpdateOptions.requestHeaders,
+          cancellationToken: downloadUpdateOptions.cancellationToken,
+        })
+
+        if (data == null || data.length === 0) {
+          throw new Error(`Blockmap "${url.href}" is empty`)
+        }
+
+        try {
+          return JSON.parse(gunzipSync(data).toString())
+        } catch (e: any) {
+          throw new Error(`Cannot parse blockmap "${url.href}", error: ${e}`)
+        }
+      }
+
+      const downloadOptions: DifferentialDownloaderOptions = {
+        newUrl: fileInfo.url,
+        oldFile: path.join(this.downloadedUpdateHelper!.cacheDir, oldInstallerFileName),
+        logger: this._logger,
+        newFile: installerPath,
+        isUseMultipleRangeRequest: provider.isUseMultipleRangeRequest,
+        requestHeaders: downloadUpdateOptions.requestHeaders,
+        cancellationToken: downloadUpdateOptions.cancellationToken,
+      }
+
+      if (this.listenerCount(DOWNLOAD_PROGRESS) > 0) {
+        downloadOptions.onProgress = it => this.emit(DOWNLOAD_PROGRESS, it)
+      }
+
+      const blockMapDataList = await Promise.all(blockmapFileUrls.map(u => downloadBlockMap(u)))
+      await new GenericDifferentialDownloader(fileInfo.info, this.httpExecutor, downloadOptions).download(blockMapDataList[0], blockMapDataList[1])
+      return false
+    } catch (e: any) {
+      this._logger.error(`Cannot download differentially, fallback to full download: ${e.stack || e}`)
+      if (this._testOnlyOptions != null) {
+        // test mode
+        throw e
+      }
+      return true
+    }
+  }
 }
 
 export interface DownloadUpdateOptions {

packages/electron-updater/src/MacUpdater.ts

@@ -1,6 +1,6 @@
-import { AllPublishOptions, newError, safeStringifyJson } from "builder-util-runtime"
+import { AllPublishOptions, newError, safeStringifyJson, CURRENT_MAC_APP_ZIP_FILE_NAME } from "builder-util-runtime"
 import { stat } from "fs-extra"
-import { createReadStream } from "fs"
+import { createReadStream, copyFileSync } from "fs"
 import { createServer, IncomingMessage, Server, ServerResponse } from "http"
 import { AppAdapter } from "./AppAdapter"
 import { AppUpdater, DownloadUpdateOptions } from "./AppUpdater"
@@ -79,12 +79,17 @@ export class MacUpdater extends AppUpdater {
       throw newError(`ZIP file not provided: ${safeStringifyJson(files)}`, "ERR_UPDATER_ZIP_FILE_NOT_FOUND")
     }
 
+    const provider = downloadUpdateOptions.updateInfoAndProvider.provider
+
     return this.executeDownload({
       fileExtension: "zip",
       fileInfo: zipFileInfo,
       downloadUpdateOptions,
-      task: (destinationFile, downloadOptions) => {
-        return this.httpExecutor.download(zipFileInfo.url, destinationFile, downloadOptions)
+      task: async (destinationFile, downloadOptions) => {
+        if (await this.differentialDownloadInstaller(zipFileInfo, downloadUpdateOptions, destinationFile, provider, CURRENT_MAC_APP_ZIP_FILE_NAME)) {
+          await this.httpExecutor.download(zipFileInfo.url, destinationFile, downloadOptions)
+        }
+        copyFileSync(destinationFile, this.downloadedUpdateHelper!.cacheDir + "/update.zip")
       },
       done: event => this.updateDownloaded(zipFileInfo, event),
     })

packages/electron-updater/src/NsisUpdater.ts

@@ -1,18 +1,15 @@
-import { AllPublishOptions, newError, PackageFileInfo, BlockMap, CURRENT_APP_PACKAGE_FILE_NAME, CURRENT_APP_INSTALLER_FILE_NAME } from "builder-util-runtime"
+import { AllPublishOptions, newError, PackageFileInfo, CURRENT_APP_INSTALLER_FILE_NAME, CURRENT_APP_PACKAGE_FILE_NAME } from "builder-util-runtime"
 import * as path from "path"
 import { AppAdapter } from "./AppAdapter"
 import { DownloadUpdateOptions } from "./AppUpdater"
 import { BaseUpdater, InstallOptions } from "./BaseUpdater"
 import { DifferentialDownloaderOptions } from "./differentialDownloader/DifferentialDownloader"
 import { FileWithEmbeddedBlockMapDifferentialDownloader } from "./differentialDownloader/FileWithEmbeddedBlockMapDifferentialDownloader"
-import { GenericDifferentialDownloader } from "./differentialDownloader/GenericDifferentialDownloader"
-import { DOWNLOAD_PROGRESS, ResolvedUpdateFileInfo, verifyUpdateCodeSignature } from "./main"
-import { blockmapFiles } from "./util"
+import { DOWNLOAD_PROGRESS, verifyUpdateCodeSignature } from "./main"
 import { findFile, Provider } from "./providers/Provider"
 import { unlink } from "fs-extra"
 import { verifySignature } from "./windowsExecutableCodeSignatureVerifier"
 import { URL } from "url"
-import { gunzipSync } from "zlib"
 
 export class NsisUpdater extends BaseUpdater {
   /**
@@ -67,7 +64,7 @@ export class NsisUpdater extends BaseUpdater {
         if (
           isWebInstaller ||
           downloadUpdateOptions.disableDifferentialDownload ||
-          (await this.differentialDownloadInstaller(fileInfo, downloadUpdateOptions, destinationFile, provider))
+          (await this.differentialDownloadInstaller(fileInfo, downloadUpdateOptions, destinationFile, provider, CURRENT_APP_INSTALLER_FILE_NAME))
         ) {
           await this.httpExecutor.download(fileInfo.url, destinationFile, downloadOptions)
         }
@@ -176,63 +173,6 @@ export class NsisUpdater extends BaseUpdater {
     return true
   }
 
-  private async differentialDownloadInstaller(
-    fileInfo: ResolvedUpdateFileInfo,
-    downloadUpdateOptions: DownloadUpdateOptions,
-    installerPath: string,
-    provider: Provider<any>
-  ): Promise<boolean> {
-    try {
-      if (this._testOnlyOptions != null && !this._testOnlyOptions.isUseDifferentialDownload) {
-        return true
-      }
-      const blockmapFileUrls = blockmapFiles(fileInfo.url, this.app.version, downloadUpdateOptions.updateInfoAndProvider.info.version)
-      this._logger.info(`Download block maps (old: "${blockmapFileUrls[0]}", new: ${blockmapFileUrls[1]})`)
-
-      const downloadBlockMap = async (url: URL): Promise<BlockMap> => {
-        const data = await this.httpExecutor.downloadToBuffer(url, {
-          headers: downloadUpdateOptions.requestHeaders,
-          cancellationToken: downloadUpdateOptions.cancellationToken,
-        })
-
-        if (data == null || data.length === 0) {
-          throw new Error(`Blockmap "${url.href}" is empty`)
-        }
-
-        try {
-          return JSON.parse(gunzipSync(data).toString())
-        } catch (e: any) {
-          throw new Error(`Cannot parse blockmap "${url.href}", error: ${e}`)
-        }
-      }
-
-      const downloadOptions: DifferentialDownloaderOptions = {
-        newUrl: fileInfo.url,
-        oldFile: path.join(this.downloadedUpdateHelper!.cacheDir, CURRENT_APP_INSTALLER_FILE_NAME),
-        logger: this._logger,
-        newFile: installerPath,
-        isUseMultipleRangeRequest: provider.isUseMultipleRangeRequest,
-        requestHeaders: downloadUpdateOptions.requestHeaders,
-        cancellationToken: downloadUpdateOptions.cancellationToken,
-      }
-
-      if (this.listenerCount(DOWNLOAD_PROGRESS) > 0) {
-        downloadOptions.onProgress = it => this.emit(DOWNLOAD_PROGRESS, it)
-      }
-
-      const blockMapDataList = await Promise.all(blockmapFileUrls.map(u => downloadBlockMap(u)))
-      await new GenericDifferentialDownloader(fileInfo.info, this.httpExecutor, downloadOptions).download(blockMapDataList[0], blockMapDataList[1])
-      return false
-    } catch (e: any) {
-      this._logger.error(`Cannot download differentially, fallback to full download: ${e.stack || e}`)
-      if (this._testOnlyOptions != null) {
-        // test mode
-        throw e
-      }
-      return true
-    }
-  }
-
   private async differentialDownloadWebPackage(
     downloadUpdateOptions: DownloadUpdateOptions,
     packageInfo: PackageFileInfo,