2026-06-09 12:34:15 -07:00
|
|
|
import { IStatusProvider } from "@/service/network/IStatusProvider.js";
|
2026-08-28 12:24:44 -07:00
|
|
|
import {
|
|
|
|
|
DockerContainerInfo,
|
|
|
|
|
DockerContainerState,
|
|
|
|
|
DockerContainerStates,
|
|
|
|
|
DockerContainerSummary,
|
|
|
|
|
DockerHealthStatus,
|
|
|
|
|
DockerHealthStatuses,
|
|
|
|
|
DockerStatusPayload,
|
|
|
|
|
MonitorStatusResponse,
|
|
|
|
|
} from "@/types/network.js";
|
2026-07-24 11:32:00 -07:00
|
|
|
import { Monitor, MonitorType } from "@/domain/monitors/monitor.type.js";
|
2026-03-05 18:19:03 +00:00
|
|
|
import { ILogger } from "@/utils/logger.js";
|
|
|
|
|
import { AppError } from "@/utils/AppError.js";
|
|
|
|
|
import Dockerode from "dockerode";
|
2026-07-24 11:09:53 -07:00
|
|
|
import { timeRequest } from "@/service/network/utils.js";
|
|
|
|
|
import { NETWORK_ERROR } from "@/types/network.js";
|
2026-03-05 18:19:03 +00:00
|
|
|
type DockerodeType = typeof Dockerode;
|
|
|
|
|
|
|
|
|
|
const SERVICE_NAME = "DockerProvider";
|
2026-08-28 12:24:44 -07:00
|
|
|
const STATS_CONCURRENCY = 5;
|
2026-03-05 18:19:03 +00:00
|
|
|
|
|
|
|
|
export interface DockerError extends Error {
|
|
|
|
|
statusCode?: number;
|
|
|
|
|
reason?: string;
|
|
|
|
|
json?: { message?: string };
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
export class DockerProvider implements IStatusProvider<DockerStatusPayload> {
|
|
|
|
|
readonly type = "docker";
|
2026-08-28 12:24:44 -07:00
|
|
|
|
2026-03-05 18:19:03 +00:00
|
|
|
constructor(
|
|
|
|
|
private logger: ILogger,
|
|
|
|
|
private DockerLib: DockerodeType
|
2026-08-28 12:24:44 -07:00
|
|
|
) {}
|
2026-03-05 18:19:03 +00:00
|
|
|
|
|
|
|
|
supports(type: MonitorType): boolean {
|
|
|
|
|
return type === "docker";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private isDockerError(error: unknown): error is DockerError {
|
|
|
|
|
return error instanceof Error && ("statusCode" in error || "reason" in error || "json" in error);
|
|
|
|
|
}
|
|
|
|
|
|
2026-08-28 12:24:44 -07:00
|
|
|
private toDockerOptions = (monitor: Monitor): Dockerode.DockerOptions => {
|
|
|
|
|
const url = monitor.url?.trim();
|
|
|
|
|
if (!url) throw new AppError({ message: "Docker host URL is required", status: 422, service: SERVICE_NAME, method: "toDockerOptions" });
|
|
|
|
|
if (url.startsWith("unix://")) {
|
|
|
|
|
const socketPath = url.slice("unix://".length);
|
2026-08-28 12:28:26 -07:00
|
|
|
if (!socketPath.startsWith("/"))
|
|
|
|
|
throw new AppError({ message: `Invalid Docker host URL: ${url}`, status: 422, service: SERVICE_NAME, method: "toDockerOptions" });
|
2026-08-28 12:24:44 -07:00
|
|
|
return { socketPath };
|
|
|
|
|
}
|
|
|
|
|
if (url.startsWith("/")) return { socketPath: url };
|
|
|
|
|
const match = url.match(/^ssh:\/\/(?:([^@\s]+)@)?([^\s/:@]+)(?::(\d{1,5}))?\/?$/);
|
2026-08-28 12:28:26 -07:00
|
|
|
if (!match) throw new AppError({ message: `Invalid Docker host URL: ${url}`, status: 422, service: SERVICE_NAME, method: "toDockerOptions" });
|
2026-08-28 12:24:44 -07:00
|
|
|
const [, username, host, port] = match;
|
|
|
|
|
if (!username)
|
|
|
|
|
throw new AppError({
|
|
|
|
|
message: "SSH Docker host URL requires a user: ssh://user@host",
|
|
|
|
|
status: 422,
|
|
|
|
|
service: SERVICE_NAME,
|
2026-08-28 12:28:26 -07:00
|
|
|
method: "toDockerOptions",
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
if (!monitor.sshPrivateKey)
|
|
|
|
|
throw new AppError({
|
|
|
|
|
message: "SSH Docker host requires a private key",
|
|
|
|
|
status: 422,
|
|
|
|
|
service: SERVICE_NAME,
|
|
|
|
|
method: "toDockerOptions",
|
2026-08-28 12:24:44 -07:00
|
|
|
});
|
|
|
|
|
return {
|
|
|
|
|
protocol: "ssh",
|
|
|
|
|
host,
|
|
|
|
|
port: port ? Number(port) : 22,
|
|
|
|
|
username,
|
|
|
|
|
sshOptions: { privateKey: monitor.sshPrivateKey },
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
private async mapWithConcurrency<T, R>(items: T[], limit: number, fn: (item: T) => Promise<R>): Promise<R[]> {
|
|
|
|
|
const results: R[] = [];
|
|
|
|
|
for (let i = 0; i < items.length; i += limit) {
|
|
|
|
|
results.push(...(await Promise.all(items.slice(i, i + limit).map(fn))));
|
|
|
|
|
}
|
|
|
|
|
return results;
|
|
|
|
|
}
|
2026-03-05 18:19:03 +00:00
|
|
|
|
2026-08-28 12:24:44 -07:00
|
|
|
private toContainerState(state: string): DockerContainerState {
|
|
|
|
|
return (DockerContainerStates as readonly string[]).includes(state) ? (state as DockerContainerState) : "created";
|
|
|
|
|
}
|
2026-03-05 18:19:03 +00:00
|
|
|
|
2026-08-28 12:24:44 -07:00
|
|
|
private toHealthStatus(status: string | undefined): DockerHealthStatus {
|
|
|
|
|
return status && (DockerHealthStatuses as readonly string[]).includes(status) ? (status as DockerHealthStatus) : "none";
|
|
|
|
|
}
|
2026-03-05 18:19:03 +00:00
|
|
|
|
2026-08-28 12:24:44 -07:00
|
|
|
private computeCpuPct(stats: Dockerode.ContainerStats): number {
|
|
|
|
|
const cpuDelta = stats.cpu_stats.cpu_usage.total_usage - stats.precpu_stats.cpu_usage.total_usage;
|
|
|
|
|
const systemDelta = stats.cpu_stats.system_cpu_usage - (stats.precpu_stats.system_cpu_usage ?? 0);
|
|
|
|
|
const onlineCpus = stats.cpu_stats.online_cpus ?? stats.cpu_stats.cpu_usage.percpu_usage?.length ?? 1;
|
|
|
|
|
if (!(systemDelta > 0) || cpuDelta < 0) return 0;
|
2026-08-31 12:02:40 -07:00
|
|
|
return (cpuDelta / systemDelta) * onlineCpus;
|
2026-08-28 12:24:44 -07:00
|
|
|
}
|
2026-03-05 18:19:03 +00:00
|
|
|
|
2026-08-28 12:24:44 -07:00
|
|
|
private computeMemory(stats: Dockerode.ContainerStats): Pick<DockerContainerInfo, "memoryUsedBytes" | "memoryLimitBytes" | "memoryPct"> {
|
|
|
|
|
const raw = stats.memory_stats.usage ?? 0;
|
|
|
|
|
const pageCache = stats.memory_stats.stats?.inactive_file ?? stats.memory_stats.stats?.cache ?? 0;
|
|
|
|
|
const memoryUsedBytes = Math.max(0, raw - pageCache);
|
|
|
|
|
const memoryLimitBytes = stats.memory_stats.limit ?? 0;
|
|
|
|
|
return {
|
|
|
|
|
memoryUsedBytes,
|
|
|
|
|
memoryLimitBytes,
|
2026-08-31 12:02:40 -07:00
|
|
|
memoryPct: memoryLimitBytes > 0 ? memoryUsedBytes / memoryLimitBytes : 0,
|
2026-08-28 12:24:44 -07:00
|
|
|
};
|
|
|
|
|
}
|
2026-03-05 18:19:03 +00:00
|
|
|
|
2026-08-28 12:24:44 -07:00
|
|
|
private async toContainerInfo(docker: Dockerode, summary: Dockerode.ContainerInfo): Promise<DockerContainerInfo> {
|
|
|
|
|
const info: DockerContainerInfo = {
|
|
|
|
|
id: summary.Id,
|
|
|
|
|
name: summary.Names?.[0]?.replace(/^\//, "") ?? summary.Id.slice(0, 12),
|
|
|
|
|
image: summary.Image,
|
|
|
|
|
state: this.toContainerState(summary.State),
|
|
|
|
|
status: summary.Status,
|
|
|
|
|
health: "none",
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const container = docker.getContainer(summary.Id);
|
|
|
|
|
const [inspectResult, statsResult] = await Promise.allSettled([
|
|
|
|
|
container.inspect(),
|
|
|
|
|
summary.State === "running" ? container.stats({ stream: false }) : Promise.resolve(null),
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
if (inspectResult.status === "fulfilled") {
|
|
|
|
|
info.restartCount = inspectResult.value.RestartCount;
|
|
|
|
|
info.startedAt = inspectResult.value.State?.StartedAt;
|
|
|
|
|
info.health = this.toHealthStatus(inspectResult.value.State?.Health?.Status);
|
|
|
|
|
} else {
|
|
|
|
|
this.logger.warn({
|
|
|
|
|
message: `Failed to inspect container ${info.name}`,
|
|
|
|
|
service: SERVICE_NAME,
|
|
|
|
|
method: "toContainerInfo",
|
|
|
|
|
details: { containerId: summary.Id },
|
|
|
|
|
});
|
|
|
|
|
}
|
2026-03-05 18:19:03 +00:00
|
|
|
|
2026-08-28 12:24:44 -07:00
|
|
|
if (statsResult.status === "fulfilled" && statsResult.value) {
|
|
|
|
|
info.cpuPct = this.computeCpuPct(statsResult.value);
|
|
|
|
|
Object.assign(info, this.computeMemory(statsResult.value));
|
|
|
|
|
}
|
2026-03-05 18:19:03 +00:00
|
|
|
|
2026-08-28 12:24:44 -07:00
|
|
|
return info;
|
|
|
|
|
}
|
2026-03-05 18:19:03 +00:00
|
|
|
|
2026-08-28 12:24:44 -07:00
|
|
|
handle = async (monitor: Monitor): Promise<MonitorStatusResponse<DockerStatusPayload>> => {
|
|
|
|
|
try {
|
|
|
|
|
const docker = new this.DockerLib(this.toDockerOptions(monitor));
|
|
|
|
|
// Host reachability is the monitor's status; ping latency is the responseTime
|
|
|
|
|
const { responseTime, error } = await timeRequest(() => docker.ping());
|
2026-03-05 18:19:03 +00:00
|
|
|
if (error) {
|
2026-08-28 12:24:44 -07:00
|
|
|
let message = "Docker host is unreachable";
|
2026-03-05 18:19:03 +00:00
|
|
|
let code = NETWORK_ERROR;
|
|
|
|
|
if (this.isDockerError(error)) {
|
|
|
|
|
code = error.statusCode ?? NETWORK_ERROR;
|
|
|
|
|
message = error.json?.message ?? error.reason ?? error.message;
|
|
|
|
|
} else if (error instanceof Error) {
|
|
|
|
|
message = error.message;
|
|
|
|
|
}
|
2026-04-10 12:33:08 -07:00
|
|
|
return {
|
|
|
|
|
monitorId: monitor.id,
|
|
|
|
|
teamId: monitor.teamId,
|
|
|
|
|
type: monitor.type,
|
|
|
|
|
status: false,
|
2026-08-28 12:24:44 -07:00
|
|
|
code,
|
|
|
|
|
message,
|
2026-04-10 12:33:08 -07:00
|
|
|
responseTime,
|
|
|
|
|
payload: null,
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2026-08-28 12:24:44 -07:00
|
|
|
const summaries = await docker.listContainers({ all: true });
|
|
|
|
|
const containers = await this.mapWithConcurrency(summaries, STATS_CONCURRENCY, (s) => this.toContainerInfo(docker, s));
|
|
|
|
|
const summary: DockerContainerSummary = {
|
|
|
|
|
total: containers.length,
|
|
|
|
|
running: containers.filter((c) => c.state === "running").length,
|
|
|
|
|
stopped: containers.filter((c) => c.state === "exited" || c.state === "dead").length,
|
|
|
|
|
unhealthy: containers.filter((c) => c.health === "unhealthy").length,
|
|
|
|
|
};
|
2026-03-05 18:19:03 +00:00
|
|
|
return {
|
|
|
|
|
monitorId: monitor.id,
|
|
|
|
|
teamId: monitor.teamId,
|
|
|
|
|
type: monitor.type,
|
2026-08-28 12:24:44 -07:00
|
|
|
status: true,
|
2026-03-05 18:19:03 +00:00
|
|
|
code: 200,
|
2026-08-28 12:24:44 -07:00
|
|
|
message: "Docker host is reachable",
|
2026-03-05 18:19:03 +00:00
|
|
|
responseTime,
|
2026-08-28 12:24:44 -07:00
|
|
|
payload: { containers, summary },
|
2026-03-05 18:19:03 +00:00
|
|
|
};
|
2026-08-28 12:24:44 -07:00
|
|
|
} catch (error: unknown) {
|
|
|
|
|
if (error instanceof AppError) throw error;
|
2026-03-05 18:19:03 +00:00
|
|
|
throw new AppError({
|
2026-08-28 12:24:44 -07:00
|
|
|
message: error instanceof Error ? error.message : "Error performing Docker request",
|
2026-03-05 18:19:03 +00:00
|
|
|
service: SERVICE_NAME,
|
|
|
|
|
method: "handle",
|
2026-08-28 12:24:44 -07:00
|
|
|
details: {
|
|
|
|
|
url: monitor.url,
|
|
|
|
|
},
|
2026-03-05 18:19:03 +00:00
|
|
|
});
|
|
|
|
|
}
|
2026-08-28 12:24:44 -07:00
|
|
|
};
|
2026-03-05 18:19:03 +00:00
|
|
|
}
|