root
278 lines
13 KiB
TypeScript
278 lines
13 KiB
TypeScript
type RuntimeLaneDefaults = {
|
|
defaultNodeId?: string;
|
|
defaultGitopsRoot?: string;
|
|
defaultBranch?: string;
|
|
defaultGitopsBranch?: string;
|
|
defaultCatalogPath?: string;
|
|
defaultRuntimeEndpoint?: string;
|
|
defaultWebEndpoint?: string;
|
|
defaultV02RuntimeEndpoint?: string;
|
|
defaultSourceRepo?: string;
|
|
};
|
|
|
|
export type GitOpsRenderArgs = {
|
|
lane: string;
|
|
nodeId?: string;
|
|
outDir: string;
|
|
gitopsRoot?: string;
|
|
sourceBranch: string;
|
|
gitopsBranch: string;
|
|
catalogPath: string;
|
|
imageTagMode: string;
|
|
runtimeEndpoint: string;
|
|
webEndpoint: string;
|
|
sourceRepo: string;
|
|
[key: string]: unknown;
|
|
};
|
|
|
|
export type RuntimeLaneConfig = {
|
|
name?: string;
|
|
node?: string;
|
|
sourceBranch?: string;
|
|
gitopsBranch?: string;
|
|
gitReadUrl?: string;
|
|
gitWriteUrl?: string;
|
|
artifactCatalog?: string;
|
|
runtimePath?: string;
|
|
namespace?: string;
|
|
imageTagMode?: string;
|
|
endpoint?: string;
|
|
externalPostgres?: {
|
|
enabled?: boolean;
|
|
serviceName?: string;
|
|
endpointAddress?: string;
|
|
port?: number;
|
|
};
|
|
publicEndpoints?: {
|
|
frontend?: string;
|
|
api?: string;
|
|
[key: string]: string | undefined;
|
|
};
|
|
observability?: {
|
|
traceExplorerUrlTemplate?: string;
|
|
prometheusOperatorResources?: boolean;
|
|
};
|
|
sourceRepo?: string;
|
|
};
|
|
|
|
export type NodeConfig = {
|
|
gitopsRoot?: string;
|
|
sourceRepo?: string;
|
|
publicHost?: string;
|
|
};
|
|
|
|
export type RuntimeLaneMirrorSpec = {
|
|
lane: string;
|
|
sourceBranch: string;
|
|
gitopsBranch: string;
|
|
artifactCatalog: string;
|
|
runtimePath: string;
|
|
};
|
|
|
|
export type DeployConfig = {
|
|
nodes?: Record<string, NodeConfig | undefined>;
|
|
lanes?: Record<string, RuntimeLaneConfig | undefined>;
|
|
};
|
|
|
|
const defaultNodeId = "node";
|
|
const defaultGitopsRoot = "deploy/gitops/node";
|
|
const defaultPublicHost = "74.48.78.17";
|
|
|
|
export function isRuntimeLane(lane: unknown): lane is string {
|
|
const value = String(lane ?? "");
|
|
return !["node", "dev", "prod"].includes(value) && /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u.test(value);
|
|
}
|
|
|
|
export function isVersionRuntimeLane(lane: unknown): lane is string {
|
|
return /^v[0-9]{2,}$/u.test(String(lane ?? ""));
|
|
}
|
|
|
|
export function isNamedRuntimeLane(lane: unknown): lane is string {
|
|
return isRuntimeLane(lane) && !isVersionRuntimeLane(lane);
|
|
}
|
|
|
|
export function runtimeLaneMinor(lane: string): number {
|
|
invariant(isVersionRuntimeLane(lane), `version runtime lane must look like v02/v03, got ${lane}`);
|
|
return Number.parseInt(lane.slice(1), 10);
|
|
}
|
|
|
|
export function versionNameForRuntimeLane(lane: string): string {
|
|
return `v0.${runtimeLaneMinor(lane)}`;
|
|
}
|
|
|
|
export function namespaceNameForRuntimeLane(lane: string): string {
|
|
invariant(isVersionRuntimeLane(lane), `version runtime lane must look like v02/v03, got ${lane}`);
|
|
return `hwlab-${lane}`;
|
|
}
|
|
|
|
export function runtimePathForRuntimeLane(lane: string): string {
|
|
invariant(isVersionRuntimeLane(lane), `version runtime lane must look like v02/v03, got ${lane}`);
|
|
return `runtime-${lane}`;
|
|
}
|
|
|
|
export function nodeConfig(deploy: DeployConfig, nodeId: string): NodeConfig {
|
|
const config = deploy.nodes?.[nodeId];
|
|
return isObject(config) ? config : {};
|
|
}
|
|
|
|
export function nodeIdForRuntimeLane(deploy: DeployConfig, lane: string, defaults: RuntimeLaneDefaults = {}): string {
|
|
const laneConfig = runtimeLaneConfig(deploy, lane);
|
|
return laneConfig.node ?? defaults.defaultNodeId ?? defaultNodeId;
|
|
}
|
|
|
|
export function gitopsRootForNode(deploy: DeployConfig, nodeId: string, defaults: RuntimeLaneDefaults = {}): string {
|
|
const config = nodeConfig(deploy, nodeId);
|
|
return normalizeRepoPath(config.gitopsRoot ?? defaults.defaultGitopsRoot ?? defaultGitopsRoot);
|
|
}
|
|
|
|
export function runtimeGitopsPathForRuntimeLane(deploy: DeployConfig, lane: string, defaults: RuntimeLaneDefaults = {}): string {
|
|
const laneConfig = runtimeLaneConfig(deploy, lane);
|
|
const runtimePath = normalizeRepoPath(laneConfig.runtimePath ?? runtimePathForRuntimeLane(lane));
|
|
if (runtimePath.startsWith("deploy/")) return runtimePath;
|
|
return joinRepoPath(gitopsRootForNode(deploy, nodeIdForRuntimeLane(deploy, lane, defaults), defaults), runtimePath);
|
|
}
|
|
|
|
export function defaultPortForRuntimeLane(lane: string): number {
|
|
return 17666 + runtimeLaneMinor(lane) * 1000;
|
|
}
|
|
|
|
export function publicHostLabel(host = defaultPublicHost): string {
|
|
return host.replaceAll(".", "-");
|
|
}
|
|
|
|
export function defaultEndpointForRuntimeLane(lane: string, options: { host?: string; v02Endpoint?: string } = {}): string {
|
|
if (lane === "v02" && options.v02Endpoint) return options.v02Endpoint;
|
|
return `https://hwlab-${lane}.${publicHostLabel(options.host ?? defaultPublicHost)}.nip.io`;
|
|
}
|
|
|
|
export function runtimeLaneConfig(deploy: DeployConfig, lane: string): RuntimeLaneConfig {
|
|
invariant(isRuntimeLane(lane), `runtime lane must be a stable lowercase id, got ${lane}`);
|
|
const config = deploy.lanes?.[lane];
|
|
invariant(isObject(config), `deploy.lanes.${lane} is required`);
|
|
if (isNamedRuntimeLane(lane)) validateNamedRuntimeLaneConfig(config, lane);
|
|
return config;
|
|
}
|
|
|
|
export function applyRuntimeLaneDeployConfig(args: GitOpsRenderArgs, deploy: DeployConfig, defaults: RuntimeLaneDefaults = {}): GitOpsRenderArgs {
|
|
if (!isRuntimeLane(args.lane)) return args;
|
|
const result: GitOpsRenderArgs = { ...args };
|
|
const laneConfig = runtimeLaneConfig(deploy, args.lane);
|
|
const configuredNodeId = nodeIdForRuntimeLane(deploy, args.lane, defaults);
|
|
const rootNodeId = nodeIdFromGitopsRoot(result.gitopsRoot);
|
|
const requestedNodeId = result.nodeId && result.nodeId !== defaultNodeId ? result.nodeId : rootNodeId ?? configuredNodeId;
|
|
const nodeId = isNamedRuntimeLane(args.lane) ? configuredNodeId : requestedNodeId;
|
|
const node = nodeConfig(deploy, nodeId);
|
|
const versionName = isVersionRuntimeLane(args.lane) ? versionNameForRuntimeLane(args.lane) : null;
|
|
const defaultEndpointOptions: { host?: string; v02Endpoint?: string } = {};
|
|
if (node.publicHost) defaultEndpointOptions.host = node.publicHost;
|
|
if (defaults.defaultV02RuntimeEndpoint) defaultEndpointOptions.v02Endpoint = defaults.defaultV02RuntimeEndpoint;
|
|
const defaultEndpoint = versionName ? defaultEndpointForRuntimeLane(args.lane, defaultEndpointOptions) : null;
|
|
const configuredEndpoint = laneConfig.endpoint ?? defaultEndpoint;
|
|
const configuredWebEndpoint = laneConfig.publicEndpoints?.frontend ?? configuredEndpoint;
|
|
const configuredRuntimeEndpoint = laneConfig.publicEndpoints?.api ?? configuredEndpoint;
|
|
const defaultBranch = defaults.defaultBranch ?? "node";
|
|
const defaultGitopsBranch = defaults.defaultGitopsBranch ?? "node-gitops";
|
|
const defaultCatalogPath = defaults.defaultCatalogPath ?? "deploy/artifact-catalog.dev.json";
|
|
const defaultRuntimeEndpoint = defaults.defaultRuntimeEndpoint ?? "http://74.48.78.17:17667";
|
|
const defaultWebEndpoint = defaults.defaultWebEndpoint ?? "http://74.48.78.17:17666";
|
|
const defaultSourceRepo = defaults.defaultSourceRepo ?? "git@github.com:pikasTech/HWLAB.git";
|
|
const defaultCatalog = `deploy/artifact-catalog.${args.lane}.json`;
|
|
|
|
if (isNamedRuntimeLane(args.lane)) {
|
|
const configuredSourceRepo = laneConfig.sourceRepo ?? node.sourceRepo;
|
|
invariant(typeof node.gitopsRoot === "string" && node.gitopsRoot.trim().length > 0, `deploy.nodes.${nodeId}.gitopsRoot is required for named runtime lane ${args.lane}`);
|
|
requiredString(configuredSourceRepo, `deploy.lanes.${args.lane}.sourceRepo or deploy.nodes.${nodeId}.sourceRepo`);
|
|
result.nodeId = configuredNodeId;
|
|
result.gitopsRoot = normalizeRepoPath(node.gitopsRoot);
|
|
result.sourceBranch = requiredString(laneConfig.sourceBranch, `deploy.lanes.${args.lane}.sourceBranch`);
|
|
result.gitopsBranch = requiredString(laneConfig.gitopsBranch, `deploy.lanes.${args.lane}.gitopsBranch`);
|
|
result.catalogPath = normalizeRepoPath(requiredString(laneConfig.artifactCatalog, `deploy.lanes.${args.lane}.artifactCatalog`));
|
|
result.imageTagMode = requiredString(laneConfig.imageTagMode, `deploy.lanes.${args.lane}.imageTagMode`);
|
|
result.runtimeEndpoint = requiredString(laneConfig.publicEndpoints?.api, `deploy.lanes.${args.lane}.publicEndpoints.api`);
|
|
result.webEndpoint = requiredString(laneConfig.publicEndpoints?.frontend, `deploy.lanes.${args.lane}.publicEndpoints.frontend`);
|
|
result.sourceRepo = configuredSourceRepo as string;
|
|
result.gitReadUrl = requiredString(laneConfig.gitReadUrl, `deploy.lanes.${args.lane}.gitReadUrl`);
|
|
result.gitWriteUrl = requiredString(laneConfig.gitWriteUrl, `deploy.lanes.${args.lane}.gitWriteUrl`);
|
|
return result;
|
|
}
|
|
|
|
if (!result.nodeId || result.nodeId === defaultNodeId) result.nodeId = nodeId;
|
|
if (!result.gitopsRoot || result.gitopsRoot === (defaults.defaultGitopsRoot ?? defaultGitopsRoot)) result.gitopsRoot = gitopsRootForNode(deploy, nodeId, defaults);
|
|
if (result.sourceBranch === defaultBranch || result.sourceBranch === versionName) result.sourceBranch = laneConfig.sourceBranch ?? versionName ?? result.sourceBranch;
|
|
if (result.gitopsBranch === defaultGitopsBranch || result.gitopsBranch === `${versionName}-gitops`) result.gitopsBranch = laneConfig.gitopsBranch ?? (versionName ? `${versionName}-gitops` : result.gitopsBranch);
|
|
if (result.catalogPath === defaultCatalogPath || result.catalogPath === defaultCatalog) result.catalogPath = laneConfig.artifactCatalog ?? defaultCatalog;
|
|
if (result.imageTagMode === "full") result.imageTagMode = laneConfig.imageTagMode ?? result.imageTagMode;
|
|
if (result.runtimeEndpoint === defaultRuntimeEndpoint || result.runtimeEndpoint === defaultEndpoint) result.runtimeEndpoint = configuredRuntimeEndpoint ?? result.runtimeEndpoint;
|
|
if (result.webEndpoint === defaultWebEndpoint || result.webEndpoint === defaultEndpoint) result.webEndpoint = configuredWebEndpoint ?? result.webEndpoint;
|
|
if (result.sourceRepo === defaultSourceRepo) result.sourceRepo = laneConfig.sourceRepo ?? node.sourceRepo ?? result.sourceRepo;
|
|
return result;
|
|
}
|
|
|
|
function nodeIdFromGitopsRoot(gitopsRoot: unknown): string | undefined {
|
|
if (typeof gitopsRoot !== "string") return undefined;
|
|
const normalized = normalizeRepoPath(gitopsRoot);
|
|
const match = normalized.match(/(?:^|\/)deploy\/gitops\/node\/([^/]+)$/u);
|
|
return match?.[1] ? match[1].toUpperCase() : undefined;
|
|
}
|
|
|
|
export function runtimeLaneMirrorSpecs(deploy: DeployConfig, defaults: RuntimeLaneDefaults = {}): RuntimeLaneMirrorSpec[] {
|
|
return Object.entries(deploy.lanes ?? {})
|
|
.filter(([lane, config]) => isRuntimeLane(lane) && isObject(config))
|
|
.sort(([left], [right]) => left.localeCompare(right, "en"))
|
|
.map(([lane, config]) => {
|
|
const laneConfig = config as RuntimeLaneConfig;
|
|
const versionName = isVersionRuntimeLane(lane) ? versionNameForRuntimeLane(lane) : null;
|
|
return {
|
|
lane,
|
|
sourceBranch: laneConfig.sourceBranch ?? versionName ?? requiredString(laneConfig.sourceBranch, `deploy.lanes.${lane}.sourceBranch`),
|
|
gitopsBranch: laneConfig.gitopsBranch ?? (versionName ? `${versionName}-gitops` : requiredString(laneConfig.gitopsBranch, `deploy.lanes.${lane}.gitopsBranch`)),
|
|
artifactCatalog: laneConfig.artifactCatalog ?? `deploy/artifact-catalog.${lane}.json`,
|
|
runtimePath: runtimeGitopsPathForRuntimeLane(deploy, lane, defaults),
|
|
};
|
|
});
|
|
}
|
|
|
|
export function runtimeNamespaceForRuntimeLane(deploy: DeployConfig, lane: string): string {
|
|
const laneConfig = runtimeLaneConfig(deploy, lane);
|
|
return laneConfig.namespace ?? namespaceNameForRuntimeLane(lane);
|
|
}
|
|
|
|
export function runtimeRelativePathForRuntimeLane(deploy: DeployConfig, lane: string): string {
|
|
const laneConfig = runtimeLaneConfig(deploy, lane);
|
|
return normalizeRepoPath(laneConfig.runtimePath ?? runtimePathForRuntimeLane(lane));
|
|
}
|
|
|
|
function validateNamedRuntimeLaneConfig(config: RuntimeLaneConfig, lane: string): void {
|
|
const label = `deploy.lanes.${lane}`;
|
|
for (const key of ["name", "node", "sourceBranch", "gitopsBranch", "gitReadUrl", "gitWriteUrl", "artifactCatalog", "runtimePath", "namespace", "imageTagMode"] as const) {
|
|
requiredString(config[key], `${label}.${key}`);
|
|
}
|
|
invariant(config.imageTagMode === "short" || config.imageTagMode === "full", `${label}.imageTagMode must be short or full`);
|
|
invariant(isObject(config.publicEndpoints), `${label}.publicEndpoints is required`);
|
|
requiredString(config.publicEndpoints.frontend, `${label}.publicEndpoints.frontend`);
|
|
requiredString(config.publicEndpoints.api, `${label}.publicEndpoints.api`);
|
|
invariant(Array.isArray((config as Record<string, unknown>).envReuseServices) && ((config as Record<string, unknown>).envReuseServices as unknown[]).length > 0, `${label}.envReuseServices must not be empty`);
|
|
invariant(isObject((config as Record<string, unknown>).serviceDeclarations), `${label}.serviceDeclarations is required`);
|
|
}
|
|
|
|
function requiredString(value: unknown, label: string): string {
|
|
invariant(typeof value === "string" && value.trim().length > 0, `${label} must be a non-empty string`);
|
|
return value.trim();
|
|
}
|
|
|
|
function normalizeRepoPath(value: string): string {
|
|
return value.replaceAll("\\\\", "/").replace(/^\.\//u, "").replace(/\/+$/u, "");
|
|
}
|
|
|
|
function joinRepoPath(left: string, right: string): string {
|
|
return `${normalizeRepoPath(left)}/${normalizeRepoPath(right).replace(/^\/+/, "")}`;
|
|
}
|
|
|
|
function isObject(value: unknown): value is Record<string, unknown> {
|
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
}
|
|
|
|
function invariant(condition: unknown, message: string): asserts condition {
|
|
if (!condition) throw new Error(message);
|
|
}
|