Skip to content

An open source, self-hosted, real-time port monitoring and discovery tool.

11.1 KB
Raw Blame
import { useState, useEffect, useRef } from "react";
import {
  Tooltip,
  TooltipContent,
  TooltipProvider,
  TooltipTrigger,
} from "@/components/ui/tooltip";
import { useServiceHealth } from "@/hooks/useServiceHealth";
import { WhyThisStatusPopover } from "./WhyThisStatusPopover";

const COLOR_CLASSES = {
  green: "bg-green-500",
  yellow: "bg-yellow-500",
  red: "bg-red-500",
  gray: "bg-gray-400",
};

function stopStatusEvent(event) {
  event.stopPropagation();
}

function deriveStatusesFromComponents(components, ports) {
  const out = {};
  if (!Array.isArray(components) || !Array.isArray(ports)) return out;
  const byContainer = new Map();
  components.forEach((c) => {
    if (c && c.containerId) byContainer.set(c.containerId, c);
  });
  const samePort = (a, b) => Number(a) === Number(b);
  const matchesEntry = (entry, port) => {
    if (!entry) return false;
    if (!samePort(entry.host_port, port.host_port)) return false;
    if (!entry.host_ip || !port.host_ip) return true;
    return entry.host_ip === port.host_ip;
  };
  ports.forEach((port) => {
    if (!port || port.host_ip == null || port.host_port == null) return;
    const key = `${port.host_ip}:${port.host_port}`;
    const comp = port.container_id ? byContainer.get(port.container_id) : null;
    if (!comp) return;
    const probe = comp.probe || {};
    const evidence = probe.evidence || {};
    const failures = Array.isArray(evidence.failures) ? evidence.failures : [];
    const suppressed = Array.isArray(evidence.suppressed) ? evidence.suppressed : [];
    const failure = failures.find((f) => matchesEntry(f, port));
    if (failure) {
      out[key] = { color: 'red', reason: failure.error || 'unreachable', isInternal: !!port.internal };
      return;
    }
    const supp = suppressed.find((s) => matchesEntry(s, port));
    if (supp) {
      out[key] = { color: 'gray', suppressed: true, suppressedReason: supp.reason || 'unknown', isInternal: !!port.internal };
      return;
    }
    out[key] = { color: probe.ok === true ? 'green' : 'red', isInternal: !!port.internal };
  });
  return out;
}

function shortStatusReason(reason, colorWord) {
  if (!reason) return colorWord;
  return reason;
}

export function AggregatedHealthDot({
  ports,
  serverId,
  serverUrl,
  hostOverride,
  serviceName,
  isDocker,
}) {
  const [portStatuses, setPortStatuses] = useState({});
  const [checking, setChecking] = useState(true);
  const abortControllerRef = useRef(null);
  const sh = useServiceHealth();
  const isLocal = !serverId || serverId === "local";
  const composeProject = (ports || []).find((p) => p && p.compose_project)?.compose_project || null;
  const containerIds = Array.from(
    new Set((ports || []).map((p) => p && p.container_id).filter(Boolean))
  );
  const anyContainerId = containerIds[0] || null;
  const shLookup = sh.enabled && isLocal
    ? sh.lookupCard({ isDocker, composeProject, serviceName, containerId: anyContainerId, containerIds })
    : null;
  const shHasVerdict = !!(shLookup && shLookup.color);

  useEffect(() => {
    if (!ports || ports.length === 0) {
      setChecking(false);
      return;
    }
    if (shHasVerdict) {
      setChecking(false);
      return;
    }

    abortControllerRef.current = new AbortController();
    const signal = abortControllerRef.current.signal;
    setChecking(true);
    setPortStatuses({});

    const checkPort = async (port) => {
      let pingApiUrl = `/api/ping?host_ip=${encodeURIComponent(
        port.host_ip
      )}&host_port=${port.host_port}`;
      if (serverId) pingApiUrl += `&server_id=${encodeURIComponent(serverId)}`;

      if (port.internal) {
        pingApiUrl += `&internal=true`;
        if (port.container_id) {
          pingApiUrl += `&container_id=${encodeURIComponent(port.container_id)}`;
        }
      }

      if (port.owner) {
        pingApiUrl += `&owner=${encodeURIComponent(port.owner)}`;
      }

      if (port.source) {
        pingApiUrl += `&source=${encodeURIComponent(port.source)}`;
      }

      if (
        serverId &&
        serverId !== "local" &&
        serverUrl &&
        (port.host_ip === "0.0.0.0" || port.host_ip === "127.0.0.1")
      ) {
        pingApiUrl += `&target_server_url=${encodeURIComponent(serverUrl)}`;
      }

      try {
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), 8000);

        const res = await fetch(pingApiUrl, { signal: controller.signal });
        clearTimeout(timeoutId);

        if (signal.aborted) return null;

        if (res.ok) {
          const data = await res.json();
          return { 
            portKey: `${port.host_ip}:${port.host_port}`, 
            color: data.color || "gray",
            hasWebUI: data.hasWebUI !== false,
            isInternal: port.internal || false
          };
        }
        return { portKey: `${port.host_ip}:${port.host_port}`, color: "red", hasWebUI: true, isInternal: port.internal || false };
      } catch {
        if (signal.aborted) return null;
        return { portKey: `${port.host_ip}:${port.host_port}`, color: "red", hasWebUI: true, isInternal: port.internal || false };
      }
    };

    const checkAllPorts = async () => {
      const results = await Promise.all(ports.map(checkPort));
      if (signal.aborted) return;

      const statuses = {};
      results.forEach((result) => {
        if (result) {
          statuses[result.portKey] = { color: result.color, hasWebUI: result.hasWebUI, isInternal: result.isInternal };
        }
      });
      setPortStatuses(statuses);
      setChecking(false);
    };

    checkAllPorts();

    return () => {
      abortControllerRef.current?.abort();
    };
  }, [ports, serverId, serverUrl, shHasVerdict]);

  const getAggregatedState = () => {
    if (checking || Object.keys(portStatuses).length === 0) {
      return {
        color: "bg-blue-400 animate-pulse",
        title: "Checking…",
        hasNoWebUI: false,
      };
    }

    const statuses = Object.values(portStatuses);
    const externalStatuses = statuses.filter(s => !s.isInternal);
    const externalColors = externalStatuses.map(s => s.color);
    const hasRed = externalColors.includes("red");
    const hasYellow = externalColors.includes("yellow");
    const allGreen = externalColors.length > 0 && externalColors.every((c) => c === "green");
    const hasNoWebUI = statuses.some(s => !s.hasWebUI);

    if (hasRed) {
      const redCount = externalColors.filter((c) => c === "red").length;
      return {
        color: "bg-red-500",
        title: `${redCount} port${redCount !== 1 ? "s" : ""} unreachable`,
        hasNoWebUI: false,
      };
    }

    if (hasYellow) {
      const yellowCount = externalColors.filter((c) => c === "yellow").length;
      return {
        color: "bg-yellow-500",
        title: `${yellowCount} port${yellowCount !== 1 ? "s" : ""} with issues`,
        hasNoWebUI: false,
      };
    }

    if (allGreen) {
      return {
        color: "bg-green-500",
        title: `All ${externalColors.length} port${externalColors.length !== 1 ? "s" : ""} healthy`,
        hasNoWebUI,
      };
    }

    if (externalColors.length === 0 && statuses.length > 0) {
      return {
        color: "bg-gray-400",
        title: "Internal ports only",
        hasNoWebUI: false,
      };
    }

    return {
      color: "bg-gray-400",
      title: "Status unknown",
      hasNoWebUI: false,
    };
  };

  const state = getAggregatedState();

  const [explainerOpen, setExplainerOpen] = useState(false);

  if (isLocal && sh.loading) {
    return (
      <TooltipProvider>
        <Tooltip>
          <TooltipTrigger asChild>
            <div className="relative flex-shrink-0">
              <div className="w-2 h-2 rounded-full bg-blue-400 animate-pulse" />
            </div>
          </TooltipTrigger>
          <TooltipContent className="max-w-[230px]">
            <p className="font-medium text-xs">Checking…</p>
          </TooltipContent>
        </Tooltip>
      </TooltipProvider>
    );
  }

  if (shLookup && shLookup.color) {
    const colorClass = COLOR_CLASSES[shLookup.color] || COLOR_CLASSES.gray;
    const colorWord = {
      green: "All reachable",
      yellow: "Partially reachable",
      red: "Main service unreachable",
      gray: "Status unclear",
    }[shLookup.color] || "Service health";
    const title = shortStatusReason(shLookup.reason, colorWord);
    return (
      <>
        <TooltipProvider>
          <Tooltip>
            <TooltipTrigger asChild>
              <button
                type="button"
                onClick={(e) => { e.stopPropagation(); setExplainerOpen(true); }}
                onMouseDown={stopStatusEvent}
                onPointerDown={stopStatusEvent}
                onKeyDown={(e) => {
                  if (e.key === "Enter" || e.key === " ") {
                    e.preventDefault();
                    e.stopPropagation();
                    setExplainerOpen(true);
                  }
                }}
                className="relative flex flex-shrink-0 cursor-pointer items-center justify-center rounded-full focus:outline-none focus-visible:ring-2 focus-visible:ring-blue-500 focus-visible:ring-offset-2 dark:focus-visible:ring-offset-slate-900"
                aria-label={`Service status: ${title}. Open details.`}
              >
                <div className={`w-2 h-2 rounded-full ${colorClass}`} />
                <span aria-hidden="true" className="absolute -inset-2" />
              </button>
            </TooltipTrigger>
            <TooltipContent
              className="max-w-[230px]"
              onClick={stopStatusEvent}
              onMouseDown={stopStatusEvent}
              onPointerDown={stopStatusEvent}
            >
              <p className="font-medium text-xs leading-snug">{title}</p>
            </TooltipContent>
          </Tooltip>
        </TooltipProvider>
        <WhyThisStatusPopover
          open={explainerOpen}
          onOpenChange={setExplainerOpen}
          serviceName={serviceName || (shLookup.services[0] && shLookup.services[0].name) || "service"}
          color={shLookup.color}
          reason={shLookup.reason}
          components={shLookup.components}
          ports={ports}
          portStatuses={deriveStatusesFromComponents(shLookup.components, ports)}
          updatedAt={sh.updatedAt}
          onRefresh={sh.refresh}
          serverId={serverId}
          serverUrl={serverUrl}
          hostOverride={hostOverride}
        />
      </>
    );
  }

  return (
    <TooltipProvider>
      <Tooltip>
        <TooltipTrigger asChild>
          <div className="relative flex-shrink-0">
            <div className={`w-2 h-2 rounded-full ${state.color}`} />
            {state.hasNoWebUI && (
              <div className="absolute -top-0.5 -right-0.5 w-1 h-1 rounded-full bg-slate-400" />
            )}
          </div>
        </TooltipTrigger>
        <TooltipContent
          className="max-w-[230px]"
          onClick={stopStatusEvent}
          onMouseDown={stopStatusEvent}
          onPointerDown={stopStatusEvent}
        >
          <p className="font-medium text-xs">{state.title}</p>
          {state.hasNoWebUI && (
            <p className="text-xs text-slate-400">Some ports have no web UI</p>
          )}
        </TooltipContent>
      </Tooltip>
    </TooltipProvider>
  );
}