headplane/app/integration/docker.ts

import { access, constants } from 'node:fs/promises';
import { setTimeout } from 'node:timers/promises';

import { Client } from 'undici';

import { HeadscaleError, pull } from '~/utils/headscale';
import log from '~/utils/log';

import { createIntegration } from './integration';

interface Context {
	client: Client | undefined;
	container: string | undefined;
	maxAttempts: number;
}

export default createIntegration<Context>({
	name: 'Docker',
	context: {
		client: undefined,
		container: undefined,
		maxAttempts: 10,
	},
	isAvailable: async (context) => {
		// Check for the HEADSCALE_CONTAINER environment variable first
		// to avoid unnecessary fetching of the Docker socket
		log.debug('INTG', 'Checking Docker integration availability');
		context.container = process.env.HEADSCALE_CONTAINER?.trim().toLowerCase();

		if (!context.container || context.container.length === 0) {
			log.error('INTG', 'Missing HEADSCALE_CONTAINER variable');
			return false;
		}

		log.info('INTG', 'Using container: %s', context.container);
		const path = process.env.DOCKER_SOCK ?? 'unix:///var/run/docker.sock';
		let url: URL | undefined;

		try {
			url = new URL(path);
		} catch {
			log.error('INTG', 'Invalid Docker socket path: %s', path);
			return false;
		}

		if (url.protocol !== 'tcp:' && url.protocol !== 'unix:') {
			log.error('INTG', 'Invalid Docker socket protocol: %s', url.protocol);
			return false;
		}

		// The API is available as an HTTP endpoint and this
		// will simplify the fetching logic in undici
		if (url.protocol === 'tcp:') {
			// Apparently setting url.protocol doesn't work anymore?
			const fetchU = url.href.replace(url.protocol, 'http:');

			try {
				log.info('INTG', 'Checking API: %s', fetchU);
				await fetch(new URL('/v1.30/version', fetchU).href);
			} catch (error) {
				log.debug('INTG', 'Failed to connect to Docker API', error);
				log.error('INTG', 'Failed to connect to Docker API');
				return false;
			}

			context.client = new Client(fetchU);
		}

		// Check if the socket is accessible
		if (url.protocol === 'unix:') {
			try {
				log.info('INTG', 'Checking socket: %s', url.pathname);
				await access(url.pathname, constants.R_OK);
			} catch (error) {
				log.debug('INTG', 'Failed to access Docker socket: %s', error);
				log.error('INTG', 'Failed to access Docker socket: %s', path);
				return false;
			}

			context.client = new Client('http://localhost', {
				socketPath: url.pathname,
			});
		}

		return context.client !== undefined;
	},

	onConfigChange: async (context) => {
		if (!context.client || !context.container) {
			return;
		}

		log.info('INTG', 'Restarting Headscale via Docker');

		let attempts = 0;
		while (attempts <= context.maxAttempts) {
			log.debug(
				'INTG',
				'Restarting container: %s (attempt %d)',
				context.container,
				attempts,
			);

			const response = await context.client.request({
				method: 'POST',
				path: `/v1.30/containers/${context.container}/restart`,
			});

			if (response.statusCode !== 204) {
				if (attempts < context.maxAttempts) {
					attempts++;
					await setTimeout(1000);
					continue;
				}

				const stringCode = response.statusCode.toString();
				const body = await response.body.text();
				throw new Error(`API request failed: ${stringCode} ${body}`);
			}

			break;
		}

		attempts = 0;
		while (attempts <= context.maxAttempts) {
			try {
				log.debug('INTG', 'Checking Headscale status (attempt %d)', attempts);
				await pull('v1', '');
				return;
			} catch (error) {
				if (error instanceof HeadscaleError && error.status === 401) {
					break;
				}

				if (error instanceof HeadscaleError && error.status === 404) {
					break;
				}

				if (attempts < context.maxAttempts) {
					attempts++;
					await setTimeout(1000);
					continue;
				}

				throw new Error(`Missed restart deadline for ${context.container}`);
			}
		}
	},
});