Add automatic module updates. Closes filecoin-station/roadmap#53

lib/modules.js

@@ -1,7 +1,7 @@
 import os from 'node:os'
 import assert from 'node:assert'
 import { join } from 'node:path'
-import { mkdir, chmod } from 'node:fs/promises'
+import { mkdir, chmod, rmdir } from 'node:fs/promises'
 import { fetch } from 'undici'
 import { pipeline } from 'node:stream/promises'
 import gunzip from 'gunzip-maybe'
@@ -91,12 +91,48 @@ export const installBinaryModule = async ({
   console.log(`[${module}] ✓ ${outFile}`)
 }
 
-export async function downloadSourceFiles ({ module, repo, distTag }) {
+/** @typedef {{
+ *   tag_name: string
+ * }?} GitHubRelease */
+
+async function getLatestDistTag (repo) {
+  const res = await fetch(
+    `https://api.github.com/repos/${repo}/releases/latest`,
+    {
+      headers: {
+        ...(authorization ? { authorization } : {})
+      }
+    }
+  )
+  if (!res.ok) {
+    throw new Error(
+      `[${module}] Cannot fetch ${module} latest release: ${res.status}\n` +
+      await res.text()
+    )
+  }
+
+  const body = /** @type {GitHubRelease} */ (await res.json())
+  return body.tag_name
+}
+
+const lastModuleDistTag = new Map()
+
+export async function updateSourceFiles ({ module, repo }) {
   await mkdir(moduleBinaries, { recursive: true })
   const outDir = join(moduleBinaries, module)
 
-  console.log(`[${module}]  ⇣ downloading source files`)
+  if (lastModuleDistTag.has(module)) {
+    console.log(`[${module}]  ⇣ checking for updates`)
+  }
 
+  const distTag = await getLatestDistTag(repo)
+  const isUpdate = lastModuleDistTag.get(module) !== distTag
+  if (!isUpdate) {
+    console.log(`[${module}]  ✓ no update available`)
+    return isUpdate
+  }
+
+  console.log(`[${module}]  ⇣ downloading source files`)
   const url = `https://github.com/${repo}/archive/refs/tags/${distTag}.tar.gz`
   const res = await fetch(url, {
     headers: {
@@ -118,7 +154,16 @@ export async function downloadSourceFiles ({ module, repo, distTag }) {
     )
   }
 
-  // `{ strip: 1}` tells tar to remove the top-level directory (e.g. `mod-peer-checker-v1.0.0`)
-  await pipeline(res.body, gunzip(), tar.extract(outDir, { strip: 1 }))
+  try {
+    // `{ strip: 1}` tells tar to remove the top-level directory (e.g. `mod-peer-checker-v1.0.0`)
+    await pipeline(res.body, gunzip(), tar.extract(outDir, { strip: 1 }))
+  } catch (err) {
+    await rmdir(outDir, { recursive: true })
+    throw err
+  }
+
+  lastModuleDistTag.set(module, distTag)
   console.log(`[${module}]  ✓ ${outDir}`)
+
+  return isUpdate
 }

lib/zinnia.js

@@ -1,43 +1,38 @@
 import { execa } from 'execa'
 import Sentry from '@sentry/node'
-import { installBinaryModule, downloadSourceFiles, getBinaryModuleExecutable } from './modules.js'
+import { installBinaryModule, updateSourceFiles, getBinaryModuleExecutable } from './modules.js'
 import { moduleBinaries } from './paths.js'
 import os from 'node:os'
 import { once } from 'node:events'
 import { ethers } from 'ethers'
 import fs from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
+import pRetry from 'p-retry'
+import timers from 'node:timers/promises'
 
 const ZINNIA_DIST_TAG = 'v0.16.0'
 const ZINNIA_MODULES = [
   {
     module: 'spark',
-    repo: 'filecoin-station/spark',
-    distTag: 'v1.7.0'
+    repo: 'filecoin-station/spark'
   }
 ]
 const { TARGET_ARCH = os.arch() } = process.env
 
-export async function install () {
-  await Promise.all([
-    installBinaryModule({
-      module: 'zinnia',
-      repo: 'filecoin-station/zinnia',
-      distTag: ZINNIA_DIST_TAG,
-      executable: 'zinniad',
-      arch: TARGET_ARCH,
-      targets: [
-        { platform: 'darwin', arch: 'arm64', asset: 'zinniad-macos-arm64.zip' },
-        { platform: 'darwin', arch: 'x64', asset: 'zinniad-macos-x64.zip' },
-        { platform: 'linux', arch: 'arm64', asset: 'zinniad-linux-arm64.tar.gz' },
-        { platform: 'linux', arch: 'x64', asset: 'zinniad-linux-x64.tar.gz' },
-        { platform: 'win32', arch: 'x64', asset: 'zinniad-windows-x64.zip' }
-      ]
-    }),
-
-    ...Object.values(ZINNIA_MODULES).map(downloadSourceFiles)
-  ])
-}
+export const install = () => installBinaryModule({
+  module: 'zinnia',
+  repo: 'filecoin-station/zinnia',
+  distTag: ZINNIA_DIST_TAG,
+  executable: 'zinniad',
+  arch: TARGET_ARCH,
+  targets: [
+    { platform: 'darwin', arch: 'arm64', asset: 'zinniad-macos-arm64.zip' },
+    { platform: 'darwin', arch: 'x64', asset: 'zinniad-macos-x64.zip' },
+    { platform: 'linux', arch: 'arm64', asset: 'zinniad-linux-arm64.tar.gz' },
+    { platform: 'linux', arch: 'x64', asset: 'zinniad-linux-x64.tar.gz' },
+    { platform: 'win32', arch: 'x64', asset: 'zinniad-windows-x64.zip' }
+  ]
+})
 
 let lastCrashReportedAt = 0
 const maybeReportCrashToSentry = (/** @type {unknown} */ err) => {
@@ -49,13 +44,34 @@ const maybeReportCrashToSentry = (/** @type {unknown} */ err) => {
   Sentry.captureException(err)
 }
 
+const updateAllSourceFiles = async () => {
+  const modules = await Promise.allSettled(
+    Object
+      .values(ZINNIA_MODULES)
+      .map(({ module, repo }) =>
+        pRetry(
+          () => updateSourceFiles({ module, repo }),
+          {
+            retries: 1000,
+            onFailedAttempt: () =>
+              console.error(`Failed to download ${module} source. Retrying...`)
+          }
+        )
+      )
+  )
+  const hasUpdated = modules
+    .find(res => res.status === 'fulfilled' && res.value === true)
+  return hasUpdated
+}
+
 export async function run ({
   FIL_WALLET_ADDRESS,
   ethAddress,
   STATE_ROOT,
   CACHE_ROOT,
   onActivity,
-  onMetrics
+  onMetrics,
+  isUpdated = false
 }) {
   const fetchRequest = new ethers.FetchRequest(
     'https://api.node.glif.io/rpc/v1'
@@ -81,10 +97,25 @@ export async function run ({
   )
 
   const zinniadExe = getBinaryModuleExecutable({ module: 'zinnia', executable: 'zinniad' })
-  const modules = [
-    // all paths are relative to `moduleBinaries`
-    'spark/main.js'
-  ]
+  // all paths are relative to `moduleBinaries`
+  const modules = ZINNIA_MODULES.map(m => `${m.module}/main.js`)
+
+  if (!isUpdated) {
+    try {
+      onActivity({
+        type: 'info',
+        message: 'Downloading latest Zinnia module source files...'
+      })
+      await updateAllSourceFiles()
+    } catch (err) {
+      onActivity({
+        type: 'error',
+        message: 'Failed to download latest Zinnia module source files'
+      })
+      throw err
+    }
+  }
+
   const childProcess = execa(zinniadExe, modules, {
     cwd: moduleBinaries,
     env: {
@@ -116,11 +147,35 @@ export async function run ({
     onActivity({ type: 'info', message: msg })
   })
 
+  let shouldRestart
+
   await Promise.all([
+    (async () => {
+      while (true) {
+        await timers.setTimeout(10 * 60 * 1000) // 10 minutes
+        try {
+          shouldRestart = await updateAllSourceFiles()
+        } catch (err) {
+          onActivity({
+            type: 'error',
+            message: 'Failed to update Zinnia module source files'
+          })
+        }
+        if (shouldRestart) {
+          onActivity({
+            type: 'info',
+            message: 'Updated Zinnia module source files, restarting...'
+          })
+          childProcess.kill()
+          return
+        }
+      }
+    })(),
     (async () => {
       try {
         await childProcess
       } catch (err) {
+        if (shouldRestart) return
         const errorMsg = err instanceof Error ? err.message : '' + err
         const message = `Cannot start Zinnia: ${errorMsg}`
         onActivity({ type: 'error', message })
@@ -133,11 +188,24 @@ export async function run ({
       console.error(`Zinnia closed all stdio with code ${code ?? '<no code>'}`)
       childProcess.stderr.removeAllListeners()
       childProcess.stdout.removeAllListeners()
+      if (shouldRestart) return
       const err = new Error(`Zinnia exited ${exitReason ?? 'for unknown reason'}`)
       maybeReportCrashToSentry(err)
       throw err
     })()
   ])
+
+  if (shouldRestart) {
+    return run({
+      FIL_WALLET_ADDRESS,
+      ethAddress,
+      STATE_ROOT,
+      CACHE_ROOT,
+      onActivity,
+      onMetrics,
+      isUpdated: true
+    })
+  }
 }
 
 async function handleEvents ({