@@ -40,6 +47,7 @@ import PageTransition from "~/components/ui/transitions/PageTransition.vue";
import { generateQuery } from "~/graphql/graphqlGen";
import getGraphqlClient from "~/graphql/getGraphqlClient";
import FileManagerContainer from "~/components/file-manager/FileManagerContainer.vue";
+import { useServerMigration } from "~/composables/useServerMigration";
definePageMeta({ middleware: "admin" });
@@ -57,6 +65,17 @@ const server = ref<{
};
} | null>(null);
+const { server: migratingServer, isMigrating } = useServerMigration(
+ serverId,
+ computed(() => useAuthStore().isAdmin),
+);
+
+const nodeId = computed(
+ () =>
+ migratingServer.value?.game_server_node_id ??
+ server.value?.game_server_node_id,
+);
+
onMounted(async () => {
// Check if user is administrator
const authStore = useAuthStore();
diff --git a/pages/file-popout/[scope]/[id].vue b/pages/file-popout/[scope]/[id].vue
index 97b4bf2c4..6791612f8 100644
--- a/pages/file-popout/[scope]/[id].vue
+++ b/pages/file-popout/[scope]/[id].vue
@@ -33,9 +33,16 @@
+
+ {{ $t("file_manager.server_moving") }}
+
label.value || id.value);
+const { server: migratingServer, isMigrating } = useServerMigration(
+ computed(() => (scope.value === "server" ? id.value : null)),
+ computed(() => useAuthStore().isAdmin),
+);
+
+const currentNodeId = computed(
+ () =>
+ (scope.value === "server" && migratingServer.value?.game_server_node_id) ||
+ nodeId.value,
+);
+
useHead({
title: computed(() =>
label.value ? `${label.value} — Files` : "Files",
diff --git a/tests/components/servers/ServerMove.spec.ts b/tests/components/servers/ServerMove.spec.ts
new file mode 100644
index 000000000..cf2806cc7
--- /dev/null
+++ b/tests/components/servers/ServerMove.spec.ts
@@ -0,0 +1,327 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { flushPromises } from "@vue/test-utils";
+import { mountSuspended } from "@nuxt/test-utils/runtime";
+import ServerMoveDialog from "~/components/servers/ServerMoveDialog.vue";
+import ServerMigrationPanel from "~/components/servers/ServerMigrationPanel.vue";
+import type {
+ MigratingServer,
+ ServerMigrationRow,
+ ServerMoveNode,
+} from "~/types/serverMigration";
+
+const { toast, moveNodes } = vi.hoisted(() => ({
+ toast: vi.fn(),
+ moveNodes: { value: [] as Array, loaded: true },
+}));
+
+vi.mock("@/components/ui/toast", async (importOriginal) => ({
+ ...(await importOriginal()),
+ toast,
+}));
+
+vi.mock("~/composables/useServerMigration", async () => {
+ const { ref } = await import("vue");
+ return {
+ useServerMoveNodes: () => ({
+ nodes: ref(moveNodes.value),
+ loaded: ref(moveNodes.loaded),
+ }),
+ };
+});
+
+const node = (overrides: Partial): ServerMoveNode => ({
+ id: "node-b",
+ label: "Node B",
+ status: "Online",
+ node_ip: "100.64.0.2",
+ enabled: true,
+ build_id: 100,
+ csgo_build_id: null,
+ update_status: null,
+ region: "EU",
+ e_region: { description: "Europe" },
+ disk_available_gb: 100,
+ available_dedicated_slot_count: 2,
+ pin_plugin_runtime: null,
+ ...overrides,
+});
+
+const server: MigratingServer = {
+ id: "server-1",
+ game: "cs2",
+ region: "EU",
+ plugin_runtime: "swiftlys2",
+ game_server_node_id: "node-a",
+ game_server_node: {
+ id: "node-a",
+ label: "Node A",
+ status: "Online",
+ node_ip: "100.64.0.1",
+ offline_at: null,
+ pin_plugin_runtime: null,
+ },
+ migrations: [],
+};
+
+let mutate: ReturnType;
+let unmount: (() => void) | null = null;
+
+afterEach(() => {
+ moveNodes.loaded = true;
+ unmount?.();
+ unmount = null;
+ vi.restoreAllMocks();
+ toast.mockReset();
+});
+
+async function mount(component: any, props: Record) {
+ const client = (useNuxtApp() as any).$apollo.defaultClient;
+ mutate = vi.fn().mockResolvedValue({ data: {} });
+ vi.spyOn(client, "mutate").mockImplementation(mutate);
+
+ const wrapper = await mountSuspended(component, {
+ props,
+ attachTo: document.body,
+ global: {
+ mixins: (useNuxtApp().vueApp as any)._context.mixins,
+ },
+ });
+ unmount = () => wrapper.unmount();
+ await flushPromises();
+ return wrapper;
+}
+
+const radios = () =>
+ Array.from(
+ document.body.querySelectorAll('[role="radio"]'),
+ );
+
+const buttonNamed = (name: string) =>
+ Array.from(document.body.querySelectorAll("button")).find(
+ (button) => button.textContent?.trim() === name,
+ );
+
+describe("ServerMoveDialog", () => {
+ it("greys out the nodes a server cannot move to and says why", async () => {
+ moveNodes.value = [
+ node({ id: "node-a", label: "Node A" }),
+ node({ id: "node-b", label: "Node B" }),
+ node({ id: "node-c", label: "Node C", available_dedicated_slot_count: 0 }),
+ ];
+
+ await mount(ServerMoveDialog, {
+ open: true,
+ server,
+ serverLabel: "Community",
+ sourceReachable: true,
+ });
+
+ const [first, ...rest] = radios();
+ expect(first.textContent).toContain("Node B");
+ expect(first.disabled).toBe(false);
+ expect(
+ rest.map((radio) => [radio.textContent?.trim(), radio.disabled]),
+ ).toEqual([
+ [expect.stringContaining("Current node"), true],
+ [expect.stringContaining("No free server slots"), true],
+ ]);
+ });
+
+ it("names why an unreachable node cannot take the server", async () => {
+ moveNodes.value = [
+ node({ id: "node-b", label: "Node B", node_ip: null }),
+ node({ id: "node-c", label: "Node C", status: "Offline" }),
+ ];
+
+ await mount(ServerMoveDialog, {
+ open: true,
+ server,
+ serverLabel: "Community",
+ sourceReachable: true,
+ });
+
+ expect(radios().map((radio) => radio.textContent?.trim())).toEqual([
+ expect.stringContaining("Unreachable"),
+ expect.stringContaining("Offline"),
+ ]);
+ });
+
+ it("says it is loading rather than that there are no nodes", async () => {
+ moveNodes.value = [];
+ moveNodes.loaded = false;
+
+ await mount(ServerMoveDialog, {
+ open: true,
+ server,
+ serverLabel: "Community",
+ sourceReachable: true,
+ });
+
+ expect(document.body.textContent).toContain("Loading...");
+ expect(document.body.textContent).not.toContain(
+ "There are no other game server nodes",
+ );
+ });
+
+ it("moves the server to the chosen node with its files", async () => {
+ moveNodes.value = [node({ id: "node-b" })];
+
+ const wrapper = await mount(ServerMoveDialog, {
+ open: true,
+ server,
+ serverLabel: "Community",
+ sourceReachable: true,
+ });
+
+ expect(buttonNamed("Move Server")!.disabled).toBe(true);
+
+ radios()[0].click();
+ await flushPromises();
+ buttonNamed("Move Server")!.click();
+ await flushPromises();
+
+ expect(mutate).toHaveBeenCalledTimes(1);
+ expect(mutate.mock.calls[0][0].variables).toEqual({
+ server_id: "server-1",
+ game_server_node_id: "node-b",
+ without_files: false,
+ });
+ expect(wrapper.emitted("update:open")).toEqual([[false]]);
+ });
+
+ it("only moves off an offline node once told to leave the files behind", async () => {
+ moveNodes.value = [node({ id: "node-b" })];
+
+ await mount(ServerMoveDialog, {
+ open: true,
+ server,
+ serverLabel: "Community",
+ sourceReachable: false,
+ });
+
+ radios()[0].click();
+ await flushPromises();
+ expect(buttonNamed("Move Server")!.disabled).toBe(true);
+
+ document.body.querySelector('[role="checkbox"]')!.click();
+ await flushPromises();
+ buttonNamed("Move Server")!.click();
+ await flushPromises();
+
+ expect(mutate.mock.calls[0][0].variables).toMatchObject({
+ without_files: true,
+ });
+ });
+
+ it("keeps the dialog open and reports why the api refused", async () => {
+ moveNodes.value = [node({ id: "node-b" })];
+
+ const wrapper = await mount(ServerMoveDialog, {
+ open: true,
+ server,
+ serverLabel: "Community",
+ sourceReachable: true,
+ });
+ mutate.mockRejectedValue({
+ graphQLErrors: [{ message: "Node B has no free server slots" }],
+ });
+
+ radios()[0].click();
+ await flushPromises();
+ buttonNamed("Move Server")!.click();
+ await flushPromises();
+
+ expect(wrapper.emitted("update:open")).toBeUndefined();
+ expect(toast).toHaveBeenCalledWith(
+ expect.objectContaining({
+ variant: "destructive",
+ description: "Node B has no free server slots",
+ }),
+ );
+ });
+});
+
+describe("ServerMigrationPanel", () => {
+ const migration = (
+ overrides: Partial,
+ ): ServerMigrationRow => ({
+ id: "migration-1",
+ status: "Transferring",
+ with_files: true,
+ bytes_total: 1000,
+ bytes_done: 500,
+ error: null,
+ warnings: [],
+ created_at: new Date().toISOString(),
+ started_at: new Date().toISOString(),
+ finished_at: null,
+ from_game_server_node: { id: "node-a", label: "Node A" },
+ to_game_server_node: { id: "node-b", label: "Node B" },
+ ...overrides,
+ });
+
+ it("shows how much has been copied and lets the move be canceled", async () => {
+ const wrapper = await mount(ServerMigrationPanel, {
+ serverId: "server-1",
+ migration: migration({}),
+ });
+
+ expect(wrapper.text()).toContain("Moving to Node B");
+ expect(wrapper.text()).toContain("(50%)");
+
+ buttonNamed("Cancel Move")!.click();
+ await flushPromises();
+
+ expect(mutate.mock.calls[0][0].variables).toEqual({
+ server_id: "server-1",
+ });
+ });
+
+ it("shows no copy progress for a server with no files", async () => {
+ const wrapper = await mount(ServerMigrationPanel, {
+ serverId: "server-1",
+ migration: migration({ bytes_total: "0", bytes_done: "0" }),
+ });
+
+ expect(wrapper.text()).not.toContain("0 B of 0 B");
+ });
+
+ it("reads the byte counts Hasura sends as strings", async () => {
+ const wrapper = await mount(ServerMigrationPanel, {
+ serverId: "server-1",
+ migration: migration({ bytes_total: "1000", bytes_done: "250" }),
+ });
+
+ expect(wrapper.text()).toContain("(25%)");
+ });
+
+ it("never claims the copy is done before the server has switched", async () => {
+ const wrapper = await mount(ServerMigrationPanel, {
+ serverId: "server-1",
+ migration: migration({ bytes_done: 1200 }),
+ });
+
+ expect(wrapper.text()).toContain("(99%)");
+ });
+
+ it("explains a failed move and that the server is back where it was", async () => {
+ const wrapper = await mount(ServerMigrationPanel, {
+ serverId: "server-1",
+ migration: migration({
+ status: "Failed",
+ error: "The transfer stalled",
+ finished_at: new Date().toISOString(),
+ }),
+ });
+
+ expect(wrapper.text()).toContain("Move to Node B failed");
+ expect(wrapper.text()).toContain("The transfer stalled");
+ expect(wrapper.text()).toContain("The server is back on Node A.");
+ expect(buttonNamed("Cancel Move")).toBeUndefined();
+
+ document.body
+ .querySelector('button[aria-label="Dismiss"]')!
+ .click();
+ expect(wrapper.emitted("dismiss")).toHaveLength(1);
+ });
+});
diff --git a/tests/types/serverMigration.spec.ts b/tests/types/serverMigration.spec.ts
new file mode 100644
index 000000000..ac2380549
--- /dev/null
+++ b/tests/types/serverMigration.spec.ts
@@ -0,0 +1,76 @@
+// @vitest-environment node
+import { describe, expect, it } from "vitest";
+import {
+ formatBytes,
+ isNodeUp,
+ moveTargetIneligibility,
+ type ServerMoveNode,
+} from "~/types/serverMigration";
+
+const node = (overrides: Partial = {}): ServerMoveNode => ({
+ id: "node-b",
+ label: "Node B",
+ status: "Online",
+ node_ip: "100.64.0.2",
+ enabled: true,
+ build_id: 100,
+ csgo_build_id: null,
+ update_status: null,
+ region: "EU",
+ disk_available_gb: 100,
+ available_dedicated_slot_count: 2,
+ pin_plugin_runtime: null,
+ ...overrides,
+});
+
+const cs2 = { game: "cs2", game_server_node_id: "node-a" };
+
+describe("moveTargetIneligibility", () => {
+ it.each([
+ ["the current node", node({ id: "node-a" }), cs2, "current"],
+ ["a disabled node", node({ enabled: false }), cs2, "disabled"],
+ ["an offline node", node({ status: "Offline" }), cs2, "offline"],
+ ["a node still being set up", node({ status: "Setup" }), cs2, "setup"],
+ [
+ "an online node without an address",
+ node({ node_ip: null }),
+ cs2,
+ "unreachable",
+ ],
+ ["a node updating CS2", node({ update_status: "Downloading" }), cs2, "updating"],
+ ["a node without CS2", node({ build_id: null }), cs2, "no_build"],
+ [
+ "a node without CS:GO for a CS:GO server",
+ node(),
+ { game: "csgo", game_server_node_id: "node-a" },
+ "no_build",
+ ],
+ ["a full node", node({ available_dedicated_slot_count: 0 }), cs2, "no_slot"],
+ ])("rules out %s", (_label, candidate, server, key) => {
+ expect(moveTargetIneligibility(candidate, server)?.key).toBe(key);
+ });
+
+ it("accepts a node that is not taking new matches", () => {
+ expect(
+ moveTargetIneligibility(node({ status: "NotAcceptingNewMatches" }), cs2),
+ ).toBeNull();
+ });
+});
+
+describe("isNodeUp", () => {
+ it("needs both a live status and an address", () => {
+ expect(isNodeUp(node())).toBe(true);
+ expect(isNodeUp(node({ node_ip: null }))).toBe(false);
+ expect(isNodeUp(node({ status: "Setup" }))).toBe(false);
+ expect(isNodeUp(null)).toBe(false);
+ });
+});
+
+describe("formatBytes", () => {
+ it("scales to the largest whole unit", () => {
+ expect(formatBytes(512)).toBe("512 B");
+ expect(formatBytes(1536)).toBe("1.5 KB");
+ expect(formatBytes(3 * 1024 ** 3)).toBe("3.0 GB");
+ expect(formatBytes(null)).toBe("0 B");
+ });
+});
diff --git a/types/serverMigration.ts b/types/serverMigration.ts
new file mode 100644
index 000000000..3195b30d6
--- /dev/null
+++ b/types/serverMigration.ts
@@ -0,0 +1,127 @@
+// Mirrors graphql/serverMigrationGraphql.ts and the api's
+// DedicatedServerMigrationService -- extend them together.
+
+export const ACTIVE_SERVER_MIGRATION_STATUSES = [
+ "Queued",
+ "Stopping",
+ "Transferring",
+ "Finalizing",
+];
+
+export const CANCELABLE_SERVER_MIGRATION_STATUSES = [
+ "Queued",
+ "Stopping",
+ "Transferring",
+];
+
+export type ServerMoveNode = {
+ id: string;
+ label: string | null;
+ status: string | null;
+ node_ip: string | null;
+ enabled: boolean | null;
+ build_id: number | null;
+ csgo_build_id: number | null;
+ update_status: string | null;
+ region: string | null;
+ e_region?: { description: string | null } | null;
+ disk_available_gb: number | null;
+ available_dedicated_slot_count: number | null;
+ pin_plugin_runtime: string | null;
+};
+
+export type ServerMigrationRow = {
+ id: string;
+ status: string;
+ with_files: boolean;
+ bytes_total: number | string | null;
+ bytes_done: number | string;
+ error: string | null;
+ warnings: Array | null;
+ created_at: string;
+ started_at: string | null;
+ finished_at: string | null;
+ from_game_server_node: { id: string; label: string | null } | null;
+ to_game_server_node: { id: string; label: string | null } | null;
+};
+
+export type MigratingServer = {
+ id: string;
+ game: string;
+ region: string | null;
+ plugin_runtime: string | null;
+ game_server_node_id: string | null;
+ game_server_node: {
+ id: string;
+ label: string | null;
+ status: string | null;
+ node_ip: string | null;
+ offline_at: string | null;
+ pin_plugin_runtime: string | null;
+ } | null;
+ migrations: Array;
+};
+
+export type ServerMoveIneligibility =
+ | { key: "current" }
+ | { key: "disabled" }
+ | { key: "offline" }
+ | { key: "setup" }
+ | { key: "unreachable" }
+ | { key: "updating" }
+ | { key: "no_build"; game: string }
+ | { key: "no_slot" };
+
+export function isNodeUp(
+ node: Pick | null | undefined,
+): boolean {
+ return (
+ !!node?.node_ip &&
+ (node.status === "Online" || node.status === "NotAcceptingNewMatches")
+ );
+}
+
+export function moveTargetIneligibility(
+ node: ServerMoveNode,
+ server: Pick,
+): ServerMoveIneligibility | null {
+ if (node.id === server.game_server_node_id) {
+ return { key: "current" };
+ }
+ if (!node.enabled) {
+ return { key: "disabled" };
+ }
+ if (!isNodeUp(node)) {
+ if (node.status === "Online" || node.status === "NotAcceptingNewMatches") {
+ return { key: "unreachable" };
+ }
+
+ return { key: node.status === "Setup" ? "setup" : "offline" };
+ }
+ if (node.update_status) {
+ return { key: "updating" };
+ }
+ if (server.game === "csgo" ? !node.csgo_build_id : !node.build_id) {
+ return { key: "no_build", game: server.game === "csgo" ? "CS:GO" : "CS2" };
+ }
+ if (!node.available_dedicated_slot_count) {
+ return { key: "no_slot" };
+ }
+ return null;
+}
+
+export function formatBytes(
+ bytes: number | string | null | undefined,
+): string {
+ const value = Number(bytes ?? 0);
+ const units = ["B", "KB", "MB", "GB", "TB"];
+ let size = value;
+ let unit = 0;
+
+ while (size >= 1024 && unit < units.length - 1) {
+ size /= 1024;
+ unit += 1;
+ }
+
+ return `${size.toFixed(unit === 0 ? 0 : 1)} ${units[unit]}`;
+}