Web UI: replace run install manifest form

striker-ui-api/src/lib/request_handlers/command/runManifest.ts

@@ -9,28 +9,38 @@ import {
   getHostData,
   getManifestData,
   job,
+  query,
   sub,
 } from '../../accessModule';
+import { ResponseError } from '../../ResponseError';
 import { sanitize } from '../../sanitize';
 import { perr } from '../../shell';
 
 export const runManifest: RequestHandler<
   { manifestUuid: string },
-  undefined,
+  undefined | ResponseErrorBody,
   RunManifestRequestBody
 > = async (request, response) => {
   const {
-    params: { manifestUuid },
+    params: { manifestUuid: rawManifestUuid },
     body: {
       debug = 2,
       description: rawDescription,
       hosts: rawHostList = {},
       password: rawPassword,
+      rerun: rawRerun,
+      reuseHosts: rawReuseHosts,
     } = {},
   } = request;
 
-  const description = sanitize(rawDescription, 'string');
-  const password = sanitize(rawPassword, 'string');
+  const manifestUuid = sanitize(rawManifestUuid, 'string', {
+    modifierType: 'sql',
+  });
+  const rerun = sanitize(rawRerun, 'boolean');
+  const reuseHosts = sanitize(rawReuseHosts, 'boolean');
+
+  let description = sanitize(rawDescription, 'string');
+  let password = sanitize(rawPassword, 'string');
 
   const hostList: ManifestExecutionHostList = {};
 
@@ -42,6 +52,48 @@ export const runManifest: RequestHandler<
     response.status(400).send();
   };
 
+  if (rerun) {
+    const sql = `
+      SELECT
+        a.anvil_description,
+        a.anvil_password
+      FROM anvils AS a
+      JOIN manifests AS b
+        ON a.anvil_name = b.manifest_name
+      WHERE b.manifest_uuid = '${manifestUuid}';`;
+
+    let rows: string[][];
+
+    try {
+      rows = await query<string[][]>(sql);
+    } catch (error) {
+      const rserror = new ResponseError(
+        '49e0e02',
+        `Failed to get existing record with manifest [${manifestUuid}]; CAUSE: ${error}`,
+      );
+
+      perr(rserror.toString());
+
+      return response.status(500).send(rserror.body);
+    }
+
+    if (!rows.length) {
+      const rserror = new ResponseError(
+        '2d42e16',
+        `No record found on rerun manifest [${manifestUuid}]`,
+      );
+
+      perr(rserror.toString());
+
+      return response.status(404).send(rserror.body);
+    }
+
+    // Assign existing values before value assertions.
+    ({
+      0: [description, password],
+    } = rows);
+  }
+
   try {
     assert(
       REP_PEACEFUL_STRING.test(description),
@@ -55,25 +107,25 @@ export const runManifest: RequestHandler<
 
     const uniqueList: Record<string, boolean | undefined> = {};
     const isHostListUnique = !Object.values(rawHostList).some(
-      ({ hostNumber, hostType, hostUuid }) => {
-        const hostId = `${hostType}${hostNumber}`;
+      ({ number, type, uuid }) => {
+        const id = `${type}${number}`;
         assert(
-          /^node[12]$/.test(hostId),
-          `Host ID must be "node" followed by 1 or 2; got [${hostId}]`,
+          /^node[12]$/.test(id),
+          `Host ID must be "node" followed by 1 or 2; got [${id}]`,
         );
 
         assert(
-          REP_UUID.test(hostUuid),
-          `Host UUID assigned to ${hostId} must be a UUIDv4; got [${hostUuid}]`,
+          REP_UUID.test(uuid),
+          `Host UUID assigned to ${id} must be a UUIDv4; got [${uuid}]`,
         );
 
-        const isIdDuplicate = Boolean(uniqueList[hostId]);
-        const isUuidDuplicate = Boolean(uniqueList[hostUuid]);
+        const isIdDuplicate = Boolean(uniqueList[id]);
+        const isUuidDuplicate = Boolean(uniqueList[uuid]);
 
-        uniqueList[hostId] = true;
-        uniqueList[hostUuid] = true;
+        uniqueList[id] = true;
+        uniqueList[uuid] = true;
 
-        hostList[hostId] = { hostNumber, hostType, hostUuid, hostId };
+        hostList[id] = { id, number, type, uuid };
 
         return isIdDuplicate || isUuidDuplicate;
       },
@@ -118,14 +170,14 @@ export const runManifest: RequestHandler<
 
   try {
     anParams = Object.values(hostList).reduce<Record<string, string>>(
-      (previous, { hostId = '', hostUuid }) => {
+      (previous, { id: hostId = '', uuid: hostUuid }) => {
         const hostName = mapToHostNameData[hostUuid];
         const { anvil_name: anName } = hostUuidMapToData[hostUuid];
 
-        if (anName) {
+        if (anName && !reuseHosts) {
           assert(
             anName !== manifestName,
-            `Host [${hostName}] cannot be used for [${manifestName}] because it belongs to [${anName}]`,
+            `Cannot use [${hostName}] for [${manifestName}] because it belongs to [${anName}]; set reuseHost:true to allow this`,
           );
         }
 

striker-ui-api/src/lib/request_handlers/host/getHost.ts

@@ -28,17 +28,38 @@ export const getHost = buildGetRequestHandler((request, buildQueryOptions) => {
       a.host_name,
       a.host_status,
       a.host_type,
-      a.host_uuid
+      a.host_uuid,
+      b.anvil_uuid,
+      b.anvil_name
     FROM hosts AS a
+    LEFT JOIN anvils AS b
+      ON a.host_uuid IN (
+        b.anvil_node1_host_uuid,
+        b.anvil_node2_host_uuid,
+        b.anvil_dr1_host_uuid
+      )
     ${condition}
     ORDER BY a.host_name ASC;`;
 
   let afterQueryReturn: QueryResultModifierFunction | undefined =
     buildQueryResultReducer<{ [hostUUID: string]: HostOverview }>(
-      (previous, [hostName, hostStatus, hostType, hostUUID]) => {
+      (previous, row) => {
+        const [hostName, hostStatus, hostType, hostUUID, anvilUuid, anvilName] =
+          row;
+
         const key = toLocal(hostUUID, localHostUUID);
 
+        let anvil: HostOverview['anvil'];
+
+        if (anvilUuid) {
+          anvil = {
+            name: anvilName,
+            uuid: anvilUuid,
+          };
+        }
+
         previous[key] = {
+          anvil,
           hostName,
           hostStatus,
           hostType,

striker-ui-api/src/lib/request_handlers/manifest/getManifestDetail.ts

@@ -1,8 +1,10 @@
 import { RequestHandler } from 'express';
 
-import { getManifestData } from '../../accessModule';
+import { getManifestData, query } from '../../accessModule';
 import { getEntityParts } from '../../disassembleEntityId';
+import { ResponseError } from '../../ResponseError';
 import { perr, pout, poutvar } from '../../shell';
+import { sanitize } from '../../sanitize';
 
 const handleSortEntries = <T extends [string, unknown]>(
   [aId]: T,
@@ -69,9 +71,13 @@ const handleSortNetworks = <T extends [string, unknown]>(
 
 export const getManifestDetail: RequestHandler = async (request, response) => {
   const {
-    params: { manifestUUID: manifestUuid },
+    params: { manifestUUID: rawManifestUuid },
   } = request;
 
+  const manifestUuid = sanitize(rawManifestUuid, 'string', {
+    modifierType: 'sql',
+  });
+
   let rawManifestListData: AnvilDataManifestListHash | undefined;
 
   try {
@@ -109,7 +115,49 @@ export const getManifestDetail: RequestHandler = async (request, response) => {
     },
   } = rawManifestListData;
 
+  const sql = `
+    SELECT
+      anvil_uuid,
+      anvil_description,
+      anvil_node1_host_uuid,
+      anvil_node2_host_uuid
+    FROM anvils
+    WHERE anvil_name = '${name}';`;
+
+  let rows: string[][];
+
+  try {
+    rows = await query<string[][]>(sql);
+  } catch (error) {
+    const rserror = new ResponseError(
+      '26bd07d',
+      `Failed to find existing record with manifest name [${name}]; CAUSE: ${error}`,
+    );
+
+    perr(rserror.toString());
+
+    return response.status(500).send(rserror.body);
+  }
+
+  let anvil: ManifestDetail['anvil'];
+
+  if (rows.length > 0) {
+    const {
+      0: [uuid, description, subnode1Uuid, subnode2Uuid],
+    } = rows;
+
+    anvil = {
+      description,
+      hosts: {
+        1: { uuid: subnode1Uuid },
+        2: { uuid: subnode2Uuid },
+      },
+      uuid,
+    };
+  }
+
   const manifestData: ManifestDetail = {
+    anvil,
     domain,
     hostConfig: {
       hosts: Object.entries(machine)

striker-ui-api/src/lib/request_handlers/server/getServer.ts

@@ -12,7 +12,7 @@ export const getServer = buildGetRequestHandler(
 
     const condAnvilUUIDs = join(sanitize(anvilUUIDs, 'string[]'), {
       beforeReturn: (toReturn) =>
-        toReturn ? `AND ser.server_anvil_uuid IN (${toReturn})` : '',
+        toReturn ? `AND a.server_anvil_uuid IN (${toReturn})` : '',
       elementWrapper: "'",
       separator: ', ',
     });
@@ -51,16 +51,17 @@ export const getServer = buildGetRequestHandler(
 
     return `
       SELECT
-        ser.server_uuid,
-        ser.server_name,
-        ser.server_state,
-        ser.server_host_uuid,
-        anv.anvil_uuid,
-        anv.anvil_name
-      FROM servers AS ser
-      JOIN anvils AS anv
-        ON ser.server_anvil_uuid = anv.anvil_uuid
-      WHERE ser.server_state != '${DELETED}'
-        ${condAnvilUUIDs};`;
+        a.server_uuid,
+        a.server_name,
+        a.server_state,
+        a.server_host_uuid,
+        b.anvil_uuid,
+        b.anvil_name
+      FROM servers AS a
+      JOIN anvils AS b
+        ON a.server_anvil_uuid = b.anvil_uuid
+      WHERE a.server_state != '${DELETED}'
+        ${condAnvilUUIDs}
+      ORDER BY a.server_name;`;
   },
 );

striker-ui-api/src/types/ApiHost.d.ts

@@ -49,6 +49,10 @@ type HostIpmi = {
 };
 
 type HostOverview = {
+  anvil?: {
+    name: string;
+    uuid: string;
+  };
   hostName: string;
   hostStatus: string;
   hostType: string;

striker-ui-api/src/types/ApiManifest.d.ts

@@ -58,6 +58,11 @@ type ManifestDetailHostList = {
 };
 
 type ManifestDetail = {
+  anvil?: {
+    description: string;
+    hosts: Record<string, { uuid: string }>;
+    uuid: string;
+  };
   domain: string;
   hostConfig: {
     hosts: ManifestDetailHostList;
@@ -74,15 +79,13 @@ type ManifestDetail = {
 };
 
 type ManifestExecutionHost = {
-  hostId?: string;
-  hostNumber: number;
-  hostType: string;
-  hostUuid: string;
+  id?: string;
+  number: number;
+  type: string;
+  uuid: string;
 };
 
-type ManifestExecutionHostList = {
-  [hostId: string]: ManifestExecutionHost;
-};
+type ManifestExecutionHostList = Record<string, ManifestExecutionHost>;
 
 type ManifestTemplate = {
   domain: string;
@@ -109,4 +112,6 @@ type RunManifestRequestBody = {
   description: string;
   hosts: ManifestExecutionHostList;
   password: string;
+  rerun?: boolean;
+  reuseHosts?: boolean;
 };