@openshift-migration-advisor/shared-components 0.22.0-dd51551836b7 → 0.23.0-e2d66ca45d64

package/src/report/infrastructureSummaryModel.ts

@@ -0,0 +1,281 @@
+export type FeatureStatus = "enabled" | "disabled" | "unknown";
+
+export type HostCapability = "vmotionSupported" | "storageVmotionSupported";
+
+export type InventoryHost = {
+  vmotionSupported?: boolean;
+  storageVmotionSupported?: boolean;
+};
+
+export type InventoryDatastore = {
+  type?: string;
+};
+
+export type InventoryNetwork = {
+  name: string;
+  type?: string;
+  vlanId?: string;
+};
+
+export type InventoryInfra = {
+  totalHosts?: number;
+  totalDatacenters?: number;
+  hosts?: InventoryHost[];
+  clustersPerDatacenter?: number[];
+  networks?: InventoryNetwork[];
+  datastores?: InventoryDatastore[];
+};
+
+export type InventoryVms = {
+  total?: number;
+  diskTypes?: Record<string, unknown>;
+};
+
+export type InventoryCluster = {
+  infra?: InventoryInfra;
+  vms?: InventoryVms;
+  vcenter?: { id?: string };
+  clusterFeatures?: {
+    drsEnabled?: boolean;
+    haEnabled?: boolean;
+  };
+};
+
+export type InfrastructureSummaryModel = {
+  vmwareVersion: string;
+  datacenters: number | undefined;
+  vCenters: number | undefined;
+  esxiHosts: number | undefined;
+};
+
+export type NetworkLabel = {
+  name: string;
+  vlanId?: string;
+  displayName: string;
+};
+
+export type ClusterDetailRow = {
+  id: string;
+  name: string;
+  hosts: number;
+  vms: number;
+  vmotion: FeatureStatus;
+  drs: FeatureStatus;
+  vsan: FeatureStatus;
+};
+
+export type ClusterDetailsModel = {
+  hosts: number;
+  vms: number;
+  networksDetected: number;
+  vmotion: FeatureStatus;
+  drs: FeatureStatus;
+  ha: FeatureStatus;
+  vsan: FeatureStatus;
+  networks: NetworkLabel[];
+};
+
+const VSAN_TYPE_PATTERN = /vsan/i;
+
+export const formatVSphereVersion = (version?: string): string => {
+  if (!version?.trim()) {
+    return "—";
+  }
+
+  const withoutPrefix = version.trim().replace(/^vSphere\s+/i, "");
+  const parts = withoutPrefix.split(".");
+  while (parts.length > 3 && parts[parts.length - 1] === "0") {
+    parts.pop();
+  }
+
+  return `vSphere ${parts.join(".")}`;
+};
+
+export const booleanToFeatureStatus = (
+  value: boolean | undefined,
+): FeatureStatus => {
+  if (value === true) {
+    return "enabled";
+  }
+  if (value === false) {
+    return "disabled";
+  }
+  return "unknown";
+};
+
+export const hostCapabilityStatus = (
+  hosts: InventoryHost[] | undefined,
+  capability: HostCapability,
+): FeatureStatus => {
+  if (!hosts || hosts.length === 0) {
+    return "unknown";
+  }
+
+  const known = hosts
+    .map((host) => host[capability])
+    .filter((value): value is boolean => typeof value === "boolean");
+
+  if (known.length === 0) {
+    return "unknown";
+  }
+
+  return known.some(Boolean) ? "enabled" : "disabled";
+};
+
+export const vsanStatus = (
+  infra?: InventoryInfra,
+  vms?: InventoryVms,
+): FeatureStatus => {
+  const datastoreMatch = infra?.datastores?.some((datastore) =>
+    VSAN_TYPE_PATTERN.test(datastore.type ?? ""),
+  );
+  const diskTypeMatch = Object.keys(vms?.diskTypes ?? {}).some((type) =>
+    VSAN_TYPE_PATTERN.test(type),
+  );
+
+  if (datastoreMatch || diskTypeMatch) {
+    return "enabled";
+  }
+
+  if (infra?.datastores || vms?.diskTypes) {
+    return "disabled";
+  }
+
+  return "unknown";
+};
+
+const hostCount = (infra?: InventoryInfra): number | undefined => {
+  if (typeof infra?.totalHosts === "number") {
+    return infra.totalHosts;
+  }
+  if (infra?.hosts) {
+    return infra.hosts.length;
+  }
+  return undefined;
+};
+
+const datacenterCount = (infra?: InventoryInfra): number | undefined => {
+  if (typeof infra?.totalDatacenters === "number") {
+    return infra.totalDatacenters;
+  }
+  if (infra?.clustersPerDatacenter && infra.clustersPerDatacenter.length > 0) {
+    return infra.clustersPerDatacenter.length;
+  }
+  return undefined;
+};
+
+export const countVCenters = (
+  clusters?: Record<string, InventoryCluster>,
+  vcenterId?: string,
+): number | undefined => {
+  const ids = new Set<string>();
+  if (vcenterId) {
+    ids.add(vcenterId);
+  }
+  for (const cluster of Object.values(clusters ?? {})) {
+    if (cluster.vcenter?.id) {
+      ids.add(cluster.vcenter.id);
+    }
+  }
+  return ids.size > 0 ? ids.size : undefined;
+};
+
+const toNetworkLabel = (network: InventoryNetwork): NetworkLabel => {
+  const vlanId = network.vlanId?.trim();
+  return {
+    name: network.name,
+    vlanId: vlanId || undefined,
+    displayName: vlanId ? `${network.name} (VLAN ${vlanId})` : network.name,
+  };
+};
+
+export const visibleNetworks = (infra?: InventoryInfra): NetworkLabel[] =>
+  (infra?.networks ?? [])
+    .filter(
+      (network) => Boolean(network.name?.trim()) && network.type !== "dvswitch",
+    )
+    .map(toNetworkLabel);
+
+export const buildInfrastructureSummary = ({
+  infra,
+  vcenterVersion,
+  vcenterId,
+  clusters,
+}: {
+  infra?: InventoryInfra;
+  vcenterVersion?: string;
+  vcenterId?: string;
+  clusters?: Record<string, InventoryCluster>;
+}): InfrastructureSummaryModel => ({
+  vmwareVersion: formatVSphereVersion(vcenterVersion),
+  datacenters: datacenterCount(infra),
+  vCenters: countVCenters(clusters, vcenterId),
+  esxiHosts: hostCount(infra),
+});
+
+const clusterFeatureStatus = (
+  cluster: InventoryCluster,
+): Pick<ClusterDetailRow, "vmotion" | "drs" | "vsan"> & {
+  ha: FeatureStatus;
+} => ({
+  vmotion: hostCapabilityStatus(cluster.infra?.hosts, "vmotionSupported"),
+  drs: booleanToFeatureStatus(cluster.clusterFeatures?.drsEnabled),
+  ha: booleanToFeatureStatus(cluster.clusterFeatures?.haEnabled),
+  vsan: vsanStatus(cluster.infra, cluster.vms),
+});
+
+const compareClustersByVmCount = (
+  a: string,
+  b: string,
+  clusters: Record<string, InventoryCluster>,
+): number => {
+  const vmsA = clusters[a]?.vms?.total ?? 0;
+  const vmsB = clusters[b]?.vms?.total ?? 0;
+  return vmsB - vmsA || a.localeCompare(b);
+};
+
+export const buildClusterDetailRows = (
+  clusters?: Record<string, InventoryCluster>,
+): ClusterDetailRow[] => {
+  if (!clusters) {
+    return [];
+  }
+
+  return Object.keys(clusters)
+    .sort((a, b) => compareClustersByVmCount(a, b, clusters))
+    .map((id) => {
+      const cluster = clusters[id];
+      const features = clusterFeatureStatus(cluster);
+      return {
+        id,
+        name: id,
+        hosts: hostCount(cluster.infra) ?? 0,
+        vms: cluster.vms?.total ?? 0,
+        vmotion: features.vmotion,
+        drs: features.drs,
+        vsan: features.vsan,
+      };
+    });
+};
+
+export const buildClusterDetails = (
+  cluster?: InventoryCluster,
+): ClusterDetailsModel | undefined => {
+  if (!cluster) {
+    return undefined;
+  }
+
+  const networks = visibleNetworks(cluster.infra);
+  const features = clusterFeatureStatus(cluster);
+
+  return {
+    hosts: hostCount(cluster.infra) ?? 0,
+    vms: cluster.vms?.total ?? 0,
+    networksDetected: networks.length,
+    vmotion: features.vmotion,
+    drs: features.drs,
+    ha: features.ha,
+    vsan: features.vsan,
+    networks,
+  };
+};

package/src/report/powerStates.ts

@@ -0,0 +1,169 @@
+import type { MigrationDonutChartDatum } from "../charts/MigrationDonutChart.js";
+
+export type PowerStateChartModel = {
+  slices: MigrationDonutChartDatum[];
+  legend: Record<string, string>;
+  total: number;
+};
+
+const HOST_POWER_CATEGORIES = [
+  "Powered on",
+  "Powered off",
+  "Standby",
+  "Not responding",
+  "Maintenance",
+] as const;
+
+type HostPowerCategory = (typeof HOST_POWER_CATEGORIES)[number];
+
+const HOST_POWER_KEY_ALIASES: Record<string, HostPowerCategory> = {
+  poweredon: "Powered on",
+  powered_on: "Powered on",
+  green: "Powered on",
+  poweredoff: "Powered off",
+  powered_off: "Powered off",
+  standby: "Standby",
+  stand_by: "Standby",
+  notresponding: "Not responding",
+  not_responding: "Not responding",
+  gray: "Not responding",
+  grey: "Not responding",
+  red: "Not responding",
+  maintenance: "Maintenance",
+  inmaintenance: "Maintenance",
+  inmaintenancemode: "Maintenance",
+};
+
+export const HOST_POWER_COLORS: Record<string, string> = {
+  "Powered on": "#0066cc",
+  "Powered off": "#dca614",
+  Standby: "#f0ab00",
+  "Not responding": "#c9190b",
+  Maintenance: "#002f5d",
+};
+
+const VM_POWER_CATEGORIES = ["Powered off", "Powered on", "Suspended"] as const;
+
+type VmPowerCategory = (typeof VM_POWER_CATEGORIES)[number];
+
+const VM_POWER_KEY_ALIASES: Record<string, VmPowerCategory> = {
+  poweredoff: "Powered off",
+  powered_off: "Powered off",
+  poweredon: "Powered on",
+  powered_on: "Powered on",
+  suspended: "Suspended",
+};
+
+export const VM_POWER_COLORS: Record<string, string> = {
+  "Powered off": "#0066cc",
+  "Powered on": "#dca614",
+  Suspended: "#5e40be",
+};
+
+const OTHER_COLOR = "#6a6e73";
+
+const normalizeKey = (key: string): string =>
+  key
+    .trim()
+    .toLowerCase()
+    .replace(/[\s-]+/g, "");
+
+const formatUnknownLabel = (key: string): string => {
+  const spaced = key
+    .replace(/[_-]+/g, " ")
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .trim();
+  if (!spaced) {
+    return "Unknown";
+  }
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+};
+
+const toSlice = (
+  name: string,
+  count: number,
+  unit: string,
+): MigrationDonutChartDatum => ({
+  name,
+  count,
+  legendCategory: name,
+  countDisplay: `${count} ${count === 1 ? unit.replace(/s$/, "") : unit}`,
+});
+
+const sumCounts = (counts: Record<string, number>): number =>
+  Object.values(counts).reduce((total, count) => total + (count || 0), 0);
+
+export const buildHostPowerStateChart = (
+  hostPowerStates?: Record<string, number>,
+): PowerStateChartModel => {
+  const counts: Record<string, number> = Object.fromEntries(
+    HOST_POWER_CATEGORIES.map((category) => [category, 0]),
+  );
+
+  for (const [key, count] of Object.entries(hostPowerStates ?? {})) {
+    const mapped = HOST_POWER_KEY_ALIASES[normalizeKey(key)];
+    const label = mapped ?? formatUnknownLabel(key);
+    counts[label] = (counts[label] ?? 0) + (count || 0);
+  }
+
+  const orderedLabels = [
+    ...HOST_POWER_CATEGORIES,
+    ...Object.keys(counts).filter(
+      (label) => !HOST_POWER_CATEGORIES.includes(label as HostPowerCategory),
+    ),
+  ];
+
+  const slices = orderedLabels.map((label) =>
+    toSlice(label, counts[label] ?? 0, "hosts"),
+  );
+
+  const legend: Record<string, string> = {};
+  for (const label of orderedLabels) {
+    legend[label] = HOST_POWER_COLORS[label] ?? OTHER_COLOR;
+  }
+
+  return {
+    slices,
+    legend,
+    total: sumCounts(counts),
+  };
+};
+
+export const buildVmPowerStateChart = (
+  powerStates?: Record<string, number>,
+): PowerStateChartModel => {
+  const counts: Record<string, number> = {
+    "Powered off": 0,
+    "Powered on": 0,
+  };
+
+  for (const [key, count] of Object.entries(powerStates ?? {})) {
+    const mapped = VM_POWER_KEY_ALIASES[normalizeKey(key)];
+    const label = mapped ?? formatUnknownLabel(key);
+    counts[label] = (counts[label] ?? 0) + (count || 0);
+  }
+
+  const orderedLabels = [
+    ...VM_POWER_CATEGORIES.filter(
+      (category) => category !== "Suspended" || (counts[category] ?? 0) > 0,
+    ),
+    ...Object.keys(counts).filter(
+      (label) => !VM_POWER_CATEGORIES.includes(label as VmPowerCategory),
+    ),
+  ];
+
+  const slices = orderedLabels.map((label) =>
+    toSlice(label, counts[label] ?? 0, "VMs"),
+  );
+
+  const legend: Record<string, string> = {};
+  for (const label of orderedLabels) {
+    legend[label] = VM_POWER_COLORS[label] ?? OTHER_COLOR;
+  }
+
+  return {
+    slices,
+    legend,
+    total: sumCounts(counts),
+  };
+};