Skip to content

Modern Docker Management, Designed for Everyone

13.9 KB
Raw Blame
import { environmentStore } from '#lib/stores/environment.store.svelte.js';
import type { SearchPaginationSortRequest, Paginated } from '#lib/types/shared.js';
import type {
	SwarmServiceSummary,
	SwarmNodeSummary,
	SwarmTaskSummary,
	SwarmStackSummary,
	SwarmInfo,
	SwarmRuntimeStatus,
	SwarmNodeAgentDeployment,
	SwarmNodeAgentBindingRequest,
	SwarmNodeAgentReconcileResponse,
	SwarmServiceCreateRequest,
	SwarmServiceUpdateRequest,
	SwarmServiceCreateResponse,
	SwarmServiceUpdateResponse,
	SwarmServiceInspect,
	SwarmStackDeployRequest,
	SwarmStackDeployResponse,
	SwarmServiceScaleRequest,
	SwarmNodeUpdateRequest,
	SwarmStackInspect,
	SwarmStackRenderConfigRequest,
	SwarmStackRenderConfigResponse,
	SwarmStackSource,
	SwarmStackSourceUpdateRequest,
	SwarmInitRequest,
	SwarmInitResponse,
	SwarmJoinRequest,
	SwarmLeaveRequest,
	SwarmUnlockRequest,
	SwarmUnlockKeyResponse,
	SwarmJoinTokensResponse,
	SwarmRotateJoinTokensRequest,
	SwarmUpdateRequest,
	SwarmKvCreateRequest,
	SwarmKvKind,
	SwarmKvSummary,
	SwarmKvUpdateRequest,
	SwarmJoinCandidate,
	SwarmJoinEnvironmentsRequest,
	SwarmJoinEnvironmentsResponse
} from '#lib/types/swarm.js';
import { transformPaginationParams } from '#lib/utils/tables.js';

import BaseAPIService, { type APIRequestConfig } from './api-service';

export type SwarmServicesPaginatedResponse = Paginated<SwarmServiceSummary>;
export type SwarmNodesPaginatedResponse = Paginated<SwarmNodeSummary>;
export type SwarmTasksPaginatedResponse = Paginated<SwarmTaskSummary>;
export type SwarmStacksPaginatedResponse = Paginated<SwarmStackSummary>;

class SwarmService extends BaseAPIService {
	async getServices(options?: SearchPaginationSortRequest): Promise<SwarmServicesPaginatedResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		const params = transformPaginationParams(options);
		const res = await this.api.get(`/environments/${envId}/swarm/services`, { params });
		return res.data;
	}

	async getService(serviceId: string): Promise<SwarmServiceInspect> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.get(`/environments/${envId}/swarm/services/${serviceId}`));
	}

	async createService(request: SwarmServiceCreateRequest): Promise<SwarmServiceCreateResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.post(`/environments/${envId}/swarm/services`, request));
	}

	async updateService(serviceId: string, request: SwarmServiceUpdateRequest): Promise<SwarmServiceUpdateResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.put(`/environments/${envId}/swarm/services/${serviceId}`, request));
	}

	async getServiceTasks(serviceId: string, options?: SearchPaginationSortRequest): Promise<SwarmTasksPaginatedResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		const params = transformPaginationParams(options);
		const res = await this.api.get(`/environments/${envId}/swarm/services/${serviceId}/tasks`, { params });
		return res.data;
	}

	async rollbackService(serviceId: string): Promise<SwarmServiceUpdateResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.post(`/environments/${envId}/swarm/services/${serviceId}/rollback`, {}));
	}

	async scaleService(serviceId: string, request: SwarmServiceScaleRequest): Promise<SwarmServiceUpdateResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.post(`/environments/${envId}/swarm/services/${serviceId}/scale`, request));
	}

	async removeService(serviceId: string): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.delete(`/environments/${envId}/swarm/services/${serviceId}`));
	}

	async getNodes(options?: SearchPaginationSortRequest): Promise<SwarmNodesPaginatedResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		const params = transformPaginationParams(options);
		const res = await this.api.get(`/environments/${envId}/swarm/nodes`, { params });
		return res.data;
	}

	async getNodeAgentDeployment(nodeId: string, rotate = false): Promise<SwarmNodeAgentDeployment> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.post(`/environments/${envId}/swarm/nodes/${nodeId}/agent/deployment`, { rotate }));
	}

	async reconcileNodeAgents(): Promise<SwarmNodeAgentReconcileResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.post(`/environments/${envId}/swarm/nodes/agents/reconcile`, {}));
	}

	async bindNodeAgent(nodeId: string, request: SwarmNodeAgentBindingRequest): Promise<SwarmNodeSummary> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.put(`/environments/${envId}/swarm/nodes/${nodeId}/agent/binding`, request));
	}

	async detachNodeAgent(nodeId: string): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.delete(`/environments/${envId}/swarm/nodes/${nodeId}/agent/binding`));
	}

	async removeNodeAgentDeployment(nodeId: string): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.delete(`/environments/${envId}/swarm/nodes/${nodeId}/agent/deployment`));
	}

	async updateNode(nodeId: string, request: SwarmNodeUpdateRequest): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.patch(`/environments/${envId}/swarm/nodes/${nodeId}`, request));
	}

	async removeNode(nodeId: string, force = false): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.delete(`/environments/${envId}/swarm/nodes/${nodeId}`, { params: { force } }));
	}

	async promoteNode(nodeId: string): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.post(`/environments/${envId}/swarm/nodes/${nodeId}/promote`, {}));
	}

	async demoteNode(nodeId: string): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.post(`/environments/${envId}/swarm/nodes/${nodeId}/demote`, {}));
	}

	async getNodeTasks(nodeId: string, options?: SearchPaginationSortRequest): Promise<SwarmTasksPaginatedResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		const params = transformPaginationParams(options);
		const res = await this.api.get(`/environments/${envId}/swarm/nodes/${nodeId}/tasks`, { params });
		return res.data;
	}

	async getTasks(options?: SearchPaginationSortRequest): Promise<SwarmTasksPaginatedResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		const params = transformPaginationParams(options);
		const res = await this.api.get(`/environments/${envId}/swarm/tasks`, { params });
		return res.data;
	}

	async getStacks(options?: SearchPaginationSortRequest): Promise<SwarmStacksPaginatedResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		const params = transformPaginationParams(options);
		const res = await this.api.get(`/environments/${envId}/swarm/stacks`, { params });
		return res.data;
	}

	async deployStack(request: SwarmStackDeployRequest): Promise<SwarmStackDeployResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.post(`/environments/${envId}/swarm/stacks`, request));
	}

	async getStack(name: string): Promise<SwarmStackInspect> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.get(`/environments/${envId}/swarm/stacks/${name}`));
	}

	async getStackSource(name: string): Promise<SwarmStackSource> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.get(`/environments/${envId}/swarm/stacks/${name}/source`));
	}

	async updateStackSource(name: string, request: SwarmStackSourceUpdateRequest): Promise<SwarmStackSource> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.put(`/environments/${envId}/swarm/stacks/${name}/source`, request));
	}

	async removeStack(name: string): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.delete(`/environments/${envId}/swarm/stacks/${name}`));
	}

	async getStackServices(name: string, options?: SearchPaginationSortRequest): Promise<SwarmServicesPaginatedResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		const params = transformPaginationParams(options);
		const res = await this.api.get(`/environments/${envId}/swarm/stacks/${name}/services`, { params });
		return res.data;
	}

	async getStackTasks(name: string, options?: SearchPaginationSortRequest): Promise<SwarmTasksPaginatedResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		const params = transformPaginationParams(options);
		const res = await this.api.get(`/environments/${envId}/swarm/stacks/${name}/tasks`, { params });
		return res.data;
	}

	async renderStackConfig(request: SwarmStackRenderConfigRequest): Promise<SwarmStackRenderConfigResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.post(`/environments/${envId}/swarm/stacks/config/render`, request));
	}

	async getSwarmInfo(): Promise<SwarmInfo> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.get(`/environments/${envId}/swarm/info`));
	}

	async getSwarmStatus(environmentId?: string, config?: APIRequestConfig): Promise<SwarmRuntimeStatus> {
		const envId = environmentId ?? (await environmentStore.getCurrentEnvironmentId());
		return this.handleResponse(this.api.get(`/environments/${envId}/swarm/status`, config));
	}

	async initSwarm(request: SwarmInitRequest): Promise<SwarmInitResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.post(`/environments/${envId}/swarm/init`, request));
	}

	async joinSwarm(request: SwarmJoinRequest): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.post(`/environments/${envId}/swarm/join`, request));
	}

	async getSwarmJoinCandidates(environmentId?: string, config?: APIRequestConfig): Promise<SwarmJoinCandidate[]> {
		const envId = environmentId ?? (await environmentStore.getCurrentEnvironmentId());
		return this.handleResponse(this.api.get(`/environments/${envId}/swarm/join-candidates`, config));
	}

	async joinEnvironments(request: SwarmJoinEnvironmentsRequest, environmentId?: string): Promise<SwarmJoinEnvironmentsResponse> {
		const envId = environmentId ?? (await environmentStore.getCurrentEnvironmentId());
		return this.handleResponse(this.api.post(`/environments/${envId}/swarm/join-environments`, request));
	}

	async leaveSwarm(request: SwarmLeaveRequest): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.post(`/environments/${envId}/swarm/leave`, request));
	}

	async unlockSwarm(request: SwarmUnlockRequest): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.post(`/environments/${envId}/swarm/unlock`, request));
	}

	async getSwarmUnlockKey(): Promise<SwarmUnlockKeyResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.get(`/environments/${envId}/swarm/unlock-key`));
	}

	async getSwarmJoinTokens(): Promise<SwarmJoinTokensResponse> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		return this.handleResponse(this.api.get(`/environments/${envId}/swarm/join-tokens`));
	}

	async rotateSwarmJoinTokens(request: SwarmRotateJoinTokensRequest = {}): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.post(`/environments/${envId}/swarm/join-tokens/rotate`, request));
	}

	async updateSwarmSpec(request: SwarmUpdateRequest): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.put(`/environments/${envId}/swarm/spec`, request));
	}

	async getKvItems(kind: SwarmKvKind, options?: SearchPaginationSortRequest): Promise<Paginated<SwarmKvSummary>> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		const res = await this.api.get(`/environments/${envId}/swarm/${kind}`, { params: transformPaginationParams(options) });
		return res.data;
	}

	async getKvItem(kind: SwarmKvKind, id: string, environmentId?: string): Promise<SwarmKvSummary> {
		const envId = environmentId ?? (await environmentStore.getCurrentEnvironmentId());
		return this.handleResponse(this.api.get(`/environments/${envId}/swarm/${kind}/${encodeURIComponent(id)}`));
	}

	async createKvItem(kind: SwarmKvKind, request: SwarmKvCreateRequest, environmentId?: string): Promise<SwarmKvSummary> {
		const envId = environmentId ?? (await environmentStore.getCurrentEnvironmentId());
		return this.handleResponse(this.api.post(`/environments/${envId}/swarm/${kind}`, request));
	}

	async updateKvItem(
		kind: SwarmKvKind,
		id: string,
		request: SwarmKvUpdateRequest,
		environmentId?: string
	): Promise<SwarmKvSummary> {
		const envId = environmentId ?? (await environmentStore.getCurrentEnvironmentId());
		return this.handleResponse(this.api.put(`/environments/${envId}/swarm/${kind}/${encodeURIComponent(id)}`, request));
	}

	async removeKvItem(kind: SwarmKvKind, id: string): Promise<void> {
		const envId = await environmentStore.getCurrentEnvironmentId();
		await this.handleResponse(this.api.delete(`/environments/${envId}/swarm/${kind}/${encodeURIComponent(id)}`));
	}
}

export const swarmService = new SwarmService();