import * as Hetzner from "@distilled.cloud/hetzner";
import type { GetFloatingIpResponseFloatingIp } from "@distilled.cloud/hetzner/floating_ips";
import { isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Data from "effect/Data";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
import * as Stream from "effect/Stream";
import { waitForAction } from "./actions.ts";
import { alchemyStackSelector } from "./Labels.ts";
import type { Providers } from "./Providers.ts";
export class FloatingIpAssignmentError extends Data.TaggedError("FloatingIpAssignmentError")<{
message: string;
}> {}
/**
* A resource-valued prop: the resource itself, or an Effect that produces
* it (so `yield* FloatingIp(...)` and `FloatingIp(...)` both type-check).
*/
type Ref<T> = T | Effect.Effect<T, never, Providers>;
/**
* Floating IP identity this assignment binds. Accepts a
* `Hetzner.FloatingIp` resource or an `{ id }` stub.
*/
export type FloatingIpAssignmentIp = {
readonly id: number;
};
/**
* Server identity a Floating IP can be assigned to. Accepts a
* `Hetzner.Server` resource or a `{ serverId }` stub.
*/
export type FloatingIpAssignmentServer = {
readonly serverId: number;
};
export interface FloatingIpAssignmentProps {
/**
* Floating IP to assign. Accepts a `Hetzner.FloatingIp` or `{ id }`.
* Changing it updates the assignment in place (previous IP is
* unassigned).
*/
floatingIp: Ref<FloatingIpAssignmentIp>;
/**
* Server to assign the Floating IP to. Accepts a `Hetzner.Server` or
* `{ serverId }`. Changing it updates the assignment in place.
*/
server: Ref<FloatingIpAssignmentServer>;
}
export type FloatingIpAssignment = Resource<
"Hetzner.FloatingIpAssignment",
FloatingIpAssignmentProps,
{
/**
* Numeric Hetzner ID of the assigned Floating IP.
*/
floatingIpId: number;
/**
* Numeric Hetzner ID of the Server the Floating IP is assigned to.
*/
serverId: number;
},
never,
Providers
>;
/**
* Assigns a Hetzner Cloud {@link FloatingIp} to a Server. The assignment
* is existence-only: observe the Floating IP and ensure it is bound to
* the Server. Changing either reference updates in place (the previous
* IP is unassigned, then the new pair is assigned).
*
* A Floating IP can be assigned to at most one Server at a time. A Server
* may hold many Floating IPs. Destroying the assignment unassigns the IP
* but leaves both the Floating IP and the Server in place.
*
* @see https://docs.hetzner.cloud/reference/cloud#floating-ip-actions-assign-a-floating-ip-to-a-server
*
* ### Assigning a Floating IP
* **Example:** Assign an IPv4 to a Server
* ```typescript
* const server = yield* Hetzner.Server("web", {
* image: "ubuntu-24.04",
* serverType: "cx23",
* location: "nbg1",
* });
* const ip = yield* Hetzner.FloatingIp("public-ip", {
* type: "ipv4",
* homeLocation: "nbg1",
* });
* const assignment = yield* Hetzner.FloatingIpAssignment("public-ip-web", {
* floatingIp: ip,
* server,
* });
* ```
*
* **Example:** Assign with stub identities
* ```typescript
* const assignment = yield* Hetzner.FloatingIpAssignment("public-ip-web", {
* floatingIp: { id: 123 },
* server: { serverId: 42 },
* });
* ```
*
* @resource
* @product IP Address
*/
export const FloatingIpAssignment = Resource<FloatingIpAssignment>("Hetzner.FloatingIpAssignment");
type CloudFloatingIp = GetFloatingIpResponseFloatingIp;
const floatingIpIdOf = (value: unknown): number | undefined => {
if (value === null || typeof value !== "object") return undefined;
const rec = value as { id?: unknown; floatingIpId?: unknown };
if (typeof rec.id === "number") return rec.id;
if (typeof rec.floatingIpId === "number") return rec.floatingIpId;
return undefined;
};
const serverIdOf = (value: unknown): number | undefined => {
if (value === null || typeof value !== "object") return undefined;
const rec = value as { serverId?: unknown; id?: unknown };
if (typeof rec.serverId === "number") return rec.serverId;
if (typeof rec.id === "number") return rec.id;
return undefined;
};
const toAttrs = (ip: CloudFloatingIp): FloatingIpAssignment["Attributes"] | undefined => {
if (ip.server === null) return undefined;
return {
floatingIpId: ip.id,
serverId: ip.server,
};
};
const getById = (id: number) =>
Hetzner.floatingIps.getFloatingIp({ id }).pipe(
Effect.map(({ floating_ip }) => floating_ip),
Effect.catchTag("NotFound", () => Effect.undefined),
);
const refresh = (id: number) =>
Hetzner.floatingIps.getFloatingIp({ id }).pipe(
Effect.map(({ floating_ip }) => floating_ip),
Effect.retry({
while: (e) => e._tag === "NotFound",
times: 5,
schedule: Schedule.min([
Schedule.exponential(Duration.millis(200), 1.5),
Schedule.spaced(Duration.seconds(2)),
]),
}),
);
const observeAssignment = (floatingIpId: number, serverId: number) =>
Effect.gen(function* () {
const ip = yield* getById(floatingIpId);
if (ip === undefined) return undefined;
if (ip.server !== serverId) return undefined;
return ip;
});
const unassignIfNeeded = (ip: CloudFloatingIp) =>
Effect.gen(function* () {
if (ip.server === null) return ip;
const { action } = yield* Hetzner.floatingIpActions.unassignFloatingIp({
id: ip.id,
});
yield* waitForAction(action);
return yield* refresh(ip.id);
});
const assignTo = (ip: CloudFloatingIp, serverId: number) =>
Effect.gen(function* () {
if (ip.server === serverId) return ip;
const { action } = yield* Hetzner.floatingIpActions.assignFloatingIp({
id: ip.id,
server: serverId,
});
yield* waitForAction(action);
return yield* refresh(ip.id);
});
export const FloatingIpAssignmentProvider = () =>
Provider.succeed(FloatingIpAssignment, {
stables: ["floatingIpId", "serverId"],
nuke: { dependsOn: ["Hetzner.FloatingIp", "Hetzner.Server"] },
list: Effect.fn(function* () {
const items = yield* Hetzner.floatingIps.listFloatingIps
.items({ label_selector: alchemyStackSelector, per_page: 50 })
.pipe(
Stream.runCollect,
Effect.map((chunk) => Array.from(chunk)),
);
return items.flatMap((ip) => {
const attrs = toAttrs(ip);
return attrs === undefined ? [] : [attrs];
});
}),
diff: Effect.fn(function* ({ news }) {
if (!isResolved(news)) return undefined;
return undefined;
}),
read: Effect.fn(function* ({ output }) {
if (output === undefined) return undefined;
const found = yield* observeAssignment(output.floatingIpId, output.serverId);
return found === undefined ? undefined : toAttrs(found);
}),
reconcile: Effect.fn(function* ({ news, output }) {
const floatingIpId = floatingIpIdOf(news.floatingIp);
const serverId = serverIdOf(news.server);
if (floatingIpId === undefined || serverId === undefined) {
return yield* new FloatingIpAssignmentError({
message: "FloatingIpAssignment requires a resolved floatingIp and server",
});
}
// Observe — cloud assignment on the Floating IP is authoritative.
let current = yield* getById(floatingIpId);
if (current === undefined) {
current = yield* refresh(floatingIpId);
}
// Ensure — the pair exists. Release a previously owned IP first so
// an in-place retarget does not leave the old address assigned.
if (output !== undefined && output.floatingIpId !== floatingIpId) {
const previous = yield* getById(output.floatingIpId);
if (previous !== undefined && previous.server === output.serverId) {
yield* unassignIfNeeded(previous);
}
}
if (current.server !== serverId) {
current = yield* unassignIfNeeded(current);
current = yield* assignTo(current, serverId);
}
const attrs = toAttrs(current);
if (attrs === undefined) {
return yield* new FloatingIpAssignmentError({
message: "FloatingIpAssignment reconcile finished without an assignment",
});
}
return attrs;
}),
delete: Effect.fn(function* ({ output }) {
const current = yield* getById(output.floatingIpId);
if (current === undefined) return;
if (current.server !== output.serverId) return;
yield* unassignIfNeeded(current);
}),
});