feat(electon-updater): autoUpdater download-progress event is not called on macOS

Close #1167

Author: develar

packages/electron-builder-http/src/httpExecutor.ts

@@ -188,10 +188,10 @@ export abstract class HttpExecutor<REQUEST> {
   }
 }
 
-class DigestTransform extends Transform {
+export class DigestTransform extends Transform {
   private readonly digester: Hash
 
-  constructor(private readonly expected: string, algorithm: string, private readonly encoding: "hex" | "base64" | "latin1") {
+  constructor(private readonly expected: string, private readonly algorithm: string, private readonly encoding: "hex" | "base64" | "latin1") {
     super()
 
     this.digester = createHash(algorithm)
@@ -204,7 +204,7 @@ class DigestTransform extends Transform {
 
   _flush(callback: Function): void {
     const hash = this.digester.digest(this.encoding)
-    callback(hash === this.expected ? null : new Error(`SHA2 checksum mismatch, expected ${this.expected}, got ${hash}`))
+    callback(hash === this.expected ? null : new Error(`${this.algorithm} checksum mismatch, expected ${this.expected}, got ${hash}`))
   }
 }
 
@@ -227,7 +227,7 @@ function checkSha2(sha2Header: string | null | undefined, sha2: string | null |
   return true
 }
 
-function safeGetHeader(response: any, headerKey: string) {
+export function safeGetHeader(response: any, headerKey: string) {
   const value = response.headers[headerKey]
   if (value == null) {
     return null

packages/electron-updater/src/AppUpdater.ts

@@ -71,6 +71,8 @@ export abstract class AppUpdater extends EventEmitter {
 
   private currentVersion: string
 
+  protected httpExecutor: ElectronHttpExecutor
+
   constructor(options: PublishConfiguration | null | undefined, app?: any) {
     super()
 
@@ -86,7 +88,8 @@ export abstract class AppUpdater extends EventEmitter {
     }
     else {
       this.app = require("electron").app
-      executorHolder.httpExecutor = new ElectronHttpExecutor((authInfo, callback) => this.emit("login", authInfo, callback))
+      this.httpExecutor = new ElectronHttpExecutor((authInfo, callback) => this.emit("login", authInfo, callback))
+      executorHolder.httpExecutor = this.httpExecutor
       this.untilAppReady = new BluebirdPromise(resolve => {
         if (this.app.isReady()) {
           if (this.logger != null) {

packages/electron-updater/src/GitHubProvider.ts

@@ -61,8 +61,9 @@ export class GitHubProvider extends BaseGitHubProvider<UpdateInfo> {
     let result: UpdateInfo
     const channelFile = getChannelFilename(getDefaultChannelName())
     const requestOptions = Object.assign({path: this.getBaseDownloadPath(version, channelFile), headers: this.requestHeaders || undefined}, this.baseUrl)
+    let rawData: string
     try {
-      result = safeLoad(await request<string>(requestOptions, cancellationToken))
+      rawData = await request<string>(requestOptions, cancellationToken)
     }
     catch (e) {
       if (!this.updater.allowPrerelease) {
@@ -73,6 +74,13 @@ export class GitHubProvider extends BaseGitHubProvider<UpdateInfo> {
       throw e
     }
 
+    try {
+      result = safeLoad(rawData)
+    }
+    catch (e) {
+      throw new Error(`Cannot parse update info from ${channelFile} in the latest release artifacts (${formatUrl(<any>requestOptions)}): ${e.stack || e.message}, rawData: ${rawData}`)
+    }
+
     Provider.validateUpdateInfo(result)
     if (isUseOldMacProvider()) {
       (<any>result).releaseJsonUrl = `${githubUrl(this.options)}/${requestOptions.path}`

packages/electron-updater/src/MacUpdater.ts

@@ -1,16 +1,17 @@
 import BluebirdPromise from "bluebird-lst"
+import { configureRequestOptions, DigestTransform, safeGetHeader } from "electron-builder-http"
 import { CancellationToken } from "electron-builder-http/out/CancellationToken"
+import { ProgressCallbackTransform } from "electron-builder-http/out/ProgressCallbackTransform"
 import { PublishConfiguration, VersionInfo } from "electron-builder-http/out/publishOptions"
-import { createServer, IncomingMessage, Server, ServerResponse } from "http"
+import { createServer, IncomingMessage, ServerResponse } from "http"
+import { parse as parseUrl } from "url"
 import { AppUpdater } from "./AppUpdater"
-import { FileInfo } from "./main"
+import { DOWNLOAD_PROGRESS, FileInfo } from "./main"
 import AutoUpdater = Electron.AutoUpdater
 
 export class MacUpdater extends AppUpdater {
   private readonly nativeUpdater: AutoUpdater = require("electron").autoUpdater
 
-  private server: Server | null
-
   constructor(options?: PublishConfiguration) {
     super(options)
 
@@ -28,43 +29,107 @@ export class MacUpdater extends AppUpdater {
     })
   }
 
-  protected onUpdateAvailable(versionInfo: VersionInfo, fileInfo: FileInfo) {
-    super.onUpdateAvailable(versionInfo, fileInfo)
+  protected doDownloadUpdate(versionInfo: VersionInfo, fileInfo: FileInfo, cancellationToken: CancellationToken) {
+    const server = createServer()
+    server.on("close", () => {
+      if (this.logger != null) {
+        this.logger.info(`Proxy server for native Squirrel.Mac is closed (was started to download ${fileInfo.url})`)
+      }
+    })
 
-    let server = this.server
-    if (server != null) {
-      return
+    function getServerUrl() {
+      const address = server.address()
+      return `http://${address.address}:${address.port}`
     }
 
-    server = createServer()
-    this.server = server
-    server.on("request", (request: IncomingMessage, response: ServerResponse) => {
-      if (request.url!.endsWith("/update.json")) {
-        response.writeHead(200, {"Content-Type": "application/json"})
-        response.end(`{ "url": "${this.getServerUrl()}/app.zip" }`)
+    return new BluebirdPromise((resolve, reject) => {
+      server.on("request", (request: IncomingMessage, response: ServerResponse) => {
+        const requestUrl = request.url!
+        if (requestUrl === "/") {
+          response.writeHead(200, {"Content-Type": "application/json"})
+          response.end(`{ "url": "${getServerUrl()}/app.zip" }`)
+        }
+        else if (requestUrl === "/app.zip") {
+          let errorOccurred = false
+          response.on("finish", () => {
+            if (!errorOccurred) {
+              resolve()
+            }
+          })
+          this.proxyUpdateFile(response, fileInfo, error => {
+            errorOccurred = true
+            try {
+              response.writeHead(500)
+              response.end()
+            }
+            finally {
+              reject(new Error(`Cannot download "${fileInfo.url}": ${error}`))
+            }
+          })
+        }
+        else {
+          response.writeHead(404)
+          response.end()
+        }
+      })
+      server.listen(0, "127.0.0.1", 16, () => {
+        this.nativeUpdater.setFeedURL(`${getServerUrl()}`, Object.assign({"Cache-Control": "no-cache"}, this.computeRequestHeaders(fileInfo)))
+        this.nativeUpdater.checkForUpdates()
+      })
+    })
+  }
+
+  private proxyUpdateFile(nativeResponse: ServerResponse, fileInfo: FileInfo, errorHandler: (error: Error) => void) {
+    nativeResponse.writeHead(200, {"Content-Type": "application/zip"})
+
+    const parsedUrl = parseUrl(fileInfo.url)
+    const downloadRequest = this.httpExecutor.doRequest(configureRequestOptions({
+      protocol: parsedUrl.protocol,
+      hostname: parsedUrl.hostname,
+      path: parsedUrl.path,
+      port: parsedUrl.port ? parseInt(parsedUrl.port, 10) : undefined,
+      headers: this.computeRequestHeaders(fileInfo) || undefined,
+    }), downloadResponse => {
+      if (downloadResponse.statusCode! >= 400) {
+        try {
+          nativeResponse.writeHead(404)
+          nativeResponse.end()
+        }
+        finally {
+          this.emit("error", new Error(`Cannot download "${fileInfo.url}", status ${downloadResponse.statusCode}: ${downloadResponse.statusMessage}`))
+        }
+        return
       }
-      else {
-        response.writeHead(404)
-        response.end()
 
+      const streams: Array<any> = []
+      if (this.listenerCount(DOWNLOAD_PROGRESS) > 0) {
+        const contentLength = safeGetHeader(downloadResponse, "content-length")
+        if (contentLength != null) {
+          streams.push(new ProgressCallbackTransform(parseInt(contentLength, 10), new CancellationToken(), it => this.emit(DOWNLOAD_PROGRESS, it)))
+        }
+      }
+
+      // for mac only sha512 is produced (sha256 is published for windows only to preserve backward compatibility)
+      const sha512 = fileInfo.sha512
+      if (sha512 != null) {
+        // "hex" to easy migrate to new base64 encoded hash (we already produces latest-mac.yml with hex encoded hash)
+        streams.push(new DigestTransform(sha512, "sha512", sha512.length === 128 && !sha512.includes("+") && !sha512.includes("Z") && !sha512.includes("=") ? "hex" : "base64"))
+      }
+
+      streams.push(nativeResponse)
+
+      let lastStream = downloadResponse
+      for (const stream of streams) {
+        stream.on("error", errorHandler)
+        lastStream = lastStream.pipe(stream)
       }
     })
-    server.listen(0, "127.0.0.1", 16, () => {
-      this.nativeUpdater.setFeedURL(`${this.getServerUrl()}`, Object.assign({"Cache-Control": "no-cache"}, this.computeRequestHeaders(fileInfo)))
-    })
-  }
 
-  protected doDownloadUpdate(versionInfo: VersionInfo, fileInfo: FileInfo, cancellationToken: CancellationToken) {
-    this.nativeUpdater.checkForUpdates()
-    return BluebirdPromise.resolve()
+    downloadRequest.on("error", errorHandler)
+    downloadRequest.end()
   }
 
   quitAndInstall(): void {
     this.nativeUpdater.quitAndInstall()
   }
-
-  private getServerUrl() {
-    const address = this.server!.address()
-    return `http://${address.address}:${address.port}`
-  }
 }

packages/electron-updater/src/electronHttpExecutor.ts

@@ -65,7 +65,7 @@ export class ElectronHttpExecutor extends HttpExecutor<Electron.ClientRequest> {
   }
 
 
-  protected doRequest(options: any, callback: (response: any) => void): any {
+  public doRequest(options: any, callback: (response: any) => void): any {
     const request = (<any>net).request(Object.assign({session: (<any>session).fromPartition(NET_SESSION_NAME)}, options), callback)
     this.addProxyLoginHandler(request)
     return request