flightdeck 0.0.2 → 0.0.3

package/src/flightdeck.lib.ts

@@ -0,0 +1,343 @@
+import { execSync, spawn } from "node:child_process"
+import { existsSync, mkdirSync, renameSync, rmSync } from "node:fs"
+import type { Server } from "node:http"
+import { createServer } from "node:http"
+import { homedir } from "node:os"
+import { resolve } from "node:path"
+
+import { Future } from "atom.io/internal"
+import { fromEntries, toEntries } from "atom.io/json"
+import { ChildSocket } from "atom.io/realtime-server"
+
+export type FlightDeckOptions<S extends string = string> = {
+	secret: string
+	packageName: string
+	services: { [service in S]: { run: string[]; waitFor: boolean } }
+	downloadPackageToUpdatesCmd: string[]
+	flightdeckRootDir?: string | undefined
+}
+
+const PORT = process.env.PORT ?? 8080
+const ORIGIN = `http://localhost:${PORT}`
+export class FlightDeck<S extends string = string> {
+	protected safety = 0
+
+	protected webhookServer: Server
+	protected services: {
+		[service in S]: ChildSocket<
+			{ updatesReady: [] },
+			{ readyToUpdate: []; alive: [] }
+		> | null
+	}
+	protected serviceIdx: { readonly [service in S]: number }
+	public defaultServicesReadyToUpdate: { readonly [service in S]: boolean }
+	public servicesReadyToUpdate: { [service in S]: boolean }
+	public servicesShouldRestart: boolean
+
+	protected restartTimes: number[] = []
+
+	public servicesLive: Future<void>[]
+	public servicesDead: Future<void>[]
+	public live = new Future(() => {})
+	public dead = new Future(() => {})
+
+	public readonly currentServiceDir: string
+	public readonly updateServiceDir: string
+	public readonly backupServiceDir: string
+
+	public constructor(public readonly options: FlightDeckOptions<S>) {
+		const { secret, flightdeckRootDir = resolve(homedir(), `services`) } =
+			options
+
+		const servicesEntries = toEntries(options.services)
+		this.services = fromEntries(
+			servicesEntries.map(([serviceName]) => [serviceName, null]),
+		)
+		this.serviceIdx = fromEntries(
+			servicesEntries.map(([serviceName], idx) => [serviceName, idx]),
+		)
+		this.defaultServicesReadyToUpdate = fromEntries(
+			servicesEntries.map(([serviceName, { waitFor }]) => [
+				serviceName,
+				!waitFor,
+			]),
+		)
+		this.servicesReadyToUpdate = { ...this.defaultServicesReadyToUpdate }
+		this.servicesShouldRestart = true
+		this.servicesLive = servicesEntries.map(() => new Future(() => {}))
+		this.servicesDead = servicesEntries.map(() => new Future(() => {}))
+		this.live.use(Promise.all(this.servicesLive))
+		this.dead.use(Promise.all(this.servicesDead))
+
+		this.currentServiceDir = resolve(
+			flightdeckRootDir,
+			options.packageName,
+			`current`,
+		)
+		this.backupServiceDir = resolve(
+			flightdeckRootDir,
+			options.packageName,
+			`backup`,
+		)
+		this.updateServiceDir = resolve(
+			flightdeckRootDir,
+			options.packageName,
+			`update`,
+		)
+
+		createServer((req, res) => {
+			let data: Uint8Array[] = []
+			req
+				.on(`data`, (chunk) => {
+					data.push(chunk instanceof Buffer ? chunk : Buffer.from(chunk))
+				})
+				.on(`end`, () => {
+					console.log(req.headers)
+					const authHeader = req.headers.authorization
+					try {
+						if (typeof req.url === `undefined`) throw 400
+						if (authHeader !== `Bearer ${secret}`) throw 401
+						const url = new URL(req.url, ORIGIN)
+						console.log(req.method, url.pathname)
+						switch (req.method) {
+							case `POST`:
+								{
+									console.log(`received post, url is ${url.pathname}`)
+									switch (url.pathname) {
+										case `/`:
+											{
+												res.writeHead(200)
+												res.end()
+												this.fetchLatestRelease()
+												if (
+													toEntries(this.servicesReadyToUpdate).every(
+														([, isReady]) => isReady,
+													)
+												) {
+													console.log(`All services are ready to update!`)
+													this.stopAllServices()
+													return
+												}
+												for (const entry of toEntries(this.services)) {
+													const [serviceName, service] = entry
+													if (service) {
+														if (this.options.services[serviceName].waitFor) {
+															service.emit(`updatesReady`)
+														}
+													} else {
+														this.startService(serviceName)
+													}
+												}
+											}
+											break
+
+										default:
+											throw 404
+									}
+								}
+								break
+
+							default:
+								throw 405
+						}
+					} catch (thrown) {
+						console.error(thrown, req.url)
+						if (typeof thrown === `number`) {
+							res.writeHead(thrown)
+							res.end()
+						}
+					} finally {
+						data = []
+					}
+				})
+		}).listen(PORT, () => {
+			console.log(`Server started on port ${PORT}`)
+		})
+
+		this.startAllServices()
+	}
+
+	protected startAllServices(): void {
+		console.log(`Starting all services...`)
+		for (const [serviceName] of toEntries(this.services)) {
+			this.startService(serviceName)
+		}
+	}
+
+	protected startService(serviceName: S): void {
+		console.log(
+			`Starting service ${this.options.packageName}::${serviceName}, try ${this.safety}/2...`,
+		)
+		if (this.safety > 2) {
+			throw new Error(`Out of tries...`)
+		}
+		this.safety++
+		if (!existsSync(this.currentServiceDir)) {
+			console.log(
+				`Tried to start service but failed: Service ${this.options.packageName} is not yet installed.`,
+			)
+			this.fetchLatestRelease()
+			this.applyUpdate()
+			this.startService(serviceName)
+
+			return
+		}
+
+		const [executable, ...args] = this.options.services[serviceName].run
+		const program = executable.startsWith(`./`)
+			? resolve(this.currentServiceDir, executable)
+			: executable
+		const serviceProcess = spawn(program, args, {
+			cwd: this.currentServiceDir,
+			env: import.meta.env,
+		})
+		this.services[serviceName] = new ChildSocket(
+			serviceProcess,
+			`${this.options.packageName}::${serviceName}`,
+			console,
+		)
+		this.services[serviceName].onAny((...messages) => {
+			console.log(`${this.options.packageName}::${serviceName} 💬`, ...messages)
+		})
+		this.services[serviceName].on(`readyToUpdate`, () => {
+			console.log(
+				`Service ${this.options.packageName}::${serviceName} is ready to update.`,
+			)
+			this.servicesReadyToUpdate[serviceName] = true
+			if (
+				toEntries(this.servicesReadyToUpdate).every(([, isReady]) => isReady)
+			) {
+				console.log(`All services are ready to update!`)
+				this.stopAllServices()
+			}
+		})
+		this.services[serviceName].on(`alive`, () => {
+			this.servicesLive[this.serviceIdx[serviceName]].use(Promise.resolve())
+			this.servicesDead[this.serviceIdx[serviceName]] = new Future(() => {})
+			if (this.dead.done) {
+				this.dead = new Future(() => {})
+			}
+			this.dead.use(Promise.all(this.servicesDead))
+		})
+		this.services[serviceName].process.on(`close`, (exitCode) => {
+			console.log(
+				`${this.options.packageName}::${serviceName} exited with code ${exitCode}`,
+			)
+			this.services[serviceName] = null
+			if (!this.servicesShouldRestart) {
+				console.log(
+					`Service ${this.options.packageName}::${serviceName} will not be restarted.`,
+				)
+				return
+			}
+			const updatesAreReady = existsSync(this.updateServiceDir)
+			if (updatesAreReady) {
+				console.log(
+					`${this.options.packageName}::${serviceName} will be updated before startup...`,
+				)
+				this.restartTimes = []
+				this.applyUpdate()
+				this.startService(serviceName)
+			} else {
+				const now = Date.now()
+				const fiveMinutesAgo = now - 5 * 60 * 1000
+				this.restartTimes = this.restartTimes.filter(
+					(time) => time > fiveMinutesAgo,
+				)
+				this.restartTimes.push(now)
+
+				if (this.restartTimes.length < 5) {
+					console.log(
+						`Service ${this.options.packageName}::${serviceName} crashed. Restarting...`,
+					)
+					this.startService(serviceName)
+				} else {
+					console.log(
+						`Service ${this.options.packageName}::${serviceName} crashed too many times. Not restarting.`,
+					)
+				}
+			}
+		})
+		this.safety = 0
+	}
+
+	protected applyUpdate(): void {
+		console.log(
+			`Installing latest version of service ${this.options.packageName}...`,
+		)
+
+		if (existsSync(this.updateServiceDir)) {
+			const runningServices = toEntries(this.services).filter(
+				([, service]) => service,
+			)
+			if (runningServices.length > 0) {
+				console.log(
+					`Tried to apply update to ${this.options.packageName} but failed. The following services are currently running: [${runningServices.map(([serviceName]) => serviceName).join(`, `)}]`,
+				)
+				return
+			}
+
+			if (existsSync(this.currentServiceDir)) {
+				if (!existsSync(this.backupServiceDir)) {
+					mkdirSync(this.backupServiceDir, { recursive: true })
+				} else {
+					rmSync(this.backupServiceDir, { recursive: true })
+				}
+				renameSync(this.currentServiceDir, this.backupServiceDir)
+			}
+
+			renameSync(this.updateServiceDir, this.currentServiceDir)
+			this.restartTimes = []
+			this.servicesReadyToUpdate = { ...this.defaultServicesReadyToUpdate }
+		} else {
+			console.log(`Service ${this.options.packageName} is already up to date.`)
+		}
+	}
+
+	protected fetchLatestRelease(): void {
+		console.log(
+			`Downloading latest version of service ${this.options.packageName}...`,
+		)
+
+		try {
+			execSync(this.options.downloadPackageToUpdatesCmd.join(` `))
+		} catch (thrown) {
+			if (thrown instanceof Error) {
+				console.error(`Failed to fetch the latest release: ${thrown.message}`)
+			}
+			return
+		}
+	}
+
+	public stopAllServices(): void {
+		console.log(`Stopping all services...`)
+		for (const [serviceName] of toEntries(this.services)) {
+			this.stopService(serviceName)
+		}
+	}
+
+	public stopService(serviceName: S): void {
+		if (this.services[serviceName]) {
+			console.log(
+				`Stopping service ${this.options.packageName}::${serviceName}...`,
+			)
+			this.services[serviceName].process.kill()
+			this.services[serviceName] = null
+			this.servicesDead[this.serviceIdx[serviceName]].use(Promise.resolve())
+			this.servicesLive[this.serviceIdx[serviceName]] = new Future(() => {})
+			if (this.live.done) {
+				this.live = new Future(() => {})
+			}
+			this.live.use(Promise.all(this.servicesLive))
+		} else {
+			console.error(
+				`Failed to stop service ${this.options.packageName}::${serviceName}: Service is not running.`,
+			)
+		}
+	}
+
+	public shutdown(): void {
+		this.servicesShouldRestart = false
+		this.stopAllServices()
+	}
+}

package/src/klaxon.bin.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import { cli, required } from "comline"
+import { z } from "zod"
+
+import * as Klaxon from "./klaxon.lib"
+
+const changesetsPublishedPackagesSchema: z.ZodSchema<Klaxon.ScrambleOptions> =
+	z.object({
+		packageConfig: z.record(z.string(), z.object({ endpoint: z.string() })),
+		secretsConfig: z.record(z.string(), z.string()),
+		publishedPackages: z.array(
+			z.object({
+				name: z.string(),
+				version: z.string(),
+			}),
+		),
+	})
+
+const klaxon = cli({
+	cliName: `klaxon`,
+	routes: required({
+		scramble: null,
+	}),
+	routeOptions: {
+		scramble: {
+			options: {
+				packageConfig: {
+					description: `Maps the names of your packages to the endpoints that klaxon will POST to.`,
+					example: `--packageConfig="{\\"my-app\\":{\\"endpoint\\":\\"https://my-app.com\\"}}"`,
+					flag: `c`,
+					parse: JSON.parse,
+					required: true,
+				},
+				secretsConfig: {
+					description: `Maps the names of your packages to the secrets that klaxon will use to authenticate with their respective endpoints.`,
+					example: `--secretsConfig="{\\"my-app\\":\\"XXXX-XXXX-XXXX\\"}"`,
+					flag: `s`,
+					parse: JSON.parse,
+					required: true,
+				},
+				publishedPackages: {
+					description: `The output of the "Publish" step in Changesets.`,
+					example: `--publishedPackages="[{\\"name\\":\\"my-app\\",\\"version\\":\\"0.0.0\\"}]"`,
+					flag: `p`,
+					parse: JSON.parse,
+					required: true,
+				},
+			},
+			optionsSchema: changesetsPublishedPackagesSchema,
+		},
+	},
+})
+
+const { inputs } = klaxon(process.argv)
+await Klaxon.scramble(inputs.opts).then((scrambleResult) => {
+	console.log(scrambleResult)
+})

package/src/klaxon.lib.ts

@@ -0,0 +1,78 @@
+export type AlertOptions = {
+	secret: string
+	endpoint: string
+}
+
+export async function alert({
+	secret,
+	endpoint,
+}: AlertOptions): Promise<Response> {
+	const response = await fetch(endpoint, {
+		method: `POST`,
+		headers: {
+			"Content-Type": `application/json`,
+			Authorization: `Bearer ${secret}`,
+		},
+	})
+
+	return response
+}
+
+/**
+ * @see https://github.com/changesets/action/blob/main/src/run.ts
+ */
+export type ChangesetsPublishedPackage = {
+	name: string
+	version: string
+}
+
+/**
+ * @see https://github.com/changesets/action/blob/main/src/run.ts
+ */
+export type ChangesetsPublishResult =
+	| {
+			published: true
+			publishedPackages: ChangesetsPublishedPackage[]
+	  }
+	| { published: false }
+
+export type PackageConfig<K extends string> = {
+	[key in K]: { endpoint: string }
+}
+export type SecretsConfig<K extends string> = {
+	[key in K]: string
+}
+
+export type ScrambleOptions<K extends string = string> = {
+	packageConfig: PackageConfig<K>
+	secretsConfig: SecretsConfig<K>
+	publishedPackages: ChangesetsPublishedPackage[]
+}
+
+export type ScrambleResult<K extends string = string> = {
+	[key in K]: Response
+}
+
+export async function scramble<K extends string = string>({
+	packageConfig,
+	secretsConfig,
+	publishedPackages,
+}: ScrambleOptions<K>): Promise<ScrambleResult<K>> {
+	const alertResults: Promise<readonly [K, Response]>[] = []
+	for (const publishedPackage of publishedPackages) {
+		if (publishedPackage.name in packageConfig) {
+			const name = publishedPackage.name as K
+			const { endpoint } = packageConfig[name]
+			const secret = secretsConfig[name]
+			const alertResultPromise = alert({ secret, endpoint }).then(
+				(alertResult) => [name, alertResult] as const,
+			)
+			alertResults.push(alertResultPromise)
+		}
+	}
+	const alertResultsResolved = await Promise.all(alertResults)
+	const scrambleResult = Object.fromEntries(
+		alertResultsResolved,
+	) as ScrambleResult<K>
+	return scrambleResult
+}

package/src/lib.ts

@@ -1 +1,4 @@
-export * from "./flightdeck"
+export * from "./flightdeck.lib"
+import * as Klaxon from "./klaxon.lib"
+
+export { Klaxon }

package/dist/bin.js

@@ -1,102 +0,0 @@
-#!/usr/bin/env node
-
-// src/bin.ts
-import * as path from "node:path";
-import {cli, optional, parseArrayOption} from "comline";
-import {FlightDeck} from "flightdeck";
-import {z} from "zod";
-var FLIGHTDECK_MANUAL = {
-  optionsSchema: z.object({
-    secret: z.string(),
-    repo: z.string(),
-    app: z.string(),
-    runCmd: z.array(z.string()),
-    serviceDir: z.string(),
-    updateCmd: z.array(z.string())
-  }),
-  options: {
-    secret: {
-      flag: `s`,
-      required: true,
-      description: `Secret used to authenticate with the service.`,
-      example: `--secret=\"secret\"`
-    },
-    repo: {
-      flag: `r`,
-      required: true,
-      description: `Name of the repository.`,
-      example: `--repo=\"sample/repo\"`
-    },
-    app: {
-      flag: `a`,
-      required: true,
-      description: `Name of the application.`,
-      example: `--app=\"my-app\"`
-    },
-    runCmd: {
-      flag: `r`,
-      required: true,
-      description: `Command to run the application.`,
-      example: `--runCmd=\"./app\"`,
-      parse: parseArrayOption
-    },
-    serviceDir: {
-      flag: `d`,
-      required: true,
-      description: `Directory where the service is stored.`,
-      example: `--serviceDir=\"./services/sample/repo/my-app/current\"`
-    },
-    updateCmd: {
-      flag: `u`,
-      required: true,
-      description: `Command to update the service.`,
-      example: `--updateCmd=\"./app\"`,
-      parse: parseArrayOption
-    }
-  }
-};
-var SCHEMA_MANUAL = {
-  optionsSchema: z.object({
-    outdir: z.string().optional()
-  }),
-  options: {
-    outdir: {
-      flag: `o`,
-      required: false,
-      description: `Directory to write the schema to.`,
-      example: `--outdir=./dist`
-    }
-  }
-};
-var parse = cli({
-  cliName: `flightdeck`,
-  routes: optional({ schema: null, $configPath: null }),
-  routeOptions: {
-    "": FLIGHTDECK_MANUAL,
-    $configPath: FLIGHTDECK_MANUAL,
-    schema: SCHEMA_MANUAL
-  },
-  discoverConfigPath: (args) => {
-    if (args[0] === `schema`) {
-      return;
-    }
-    const configPath = args[0] ?? path.join(process.cwd(), `flightdeck.config.json`);
-    return configPath;
-  }
-}, console);
-var { inputs, writeJsonSchema } = parse(process.argv);
-switch (inputs.case) {
-  case `schema`:
-    {
-      const { outdir } = inputs.opts;
-      writeJsonSchema(outdir ?? `.`);
-    }
-    break;
-  default: {
-    const flightDeck = new FlightDeck(inputs.opts);
-    process.on(`close`, async () => {
-      flightDeck.stopService();
-      await flightDeck.dead;
-    });
-  }
-}