Skip to content

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

8.8 KB
Raw Blame
import React, { createContext, useContext, useEffect, useMemo, useRef, useState, useCallback } from 'react';
import { useOverrides } from './useOverrides';

const ServiceHealthContext = createContext(null);

const ROLE_LABELS = {
  core_access: 'core',
  core_runtime: 'core',
  support: 'support',
  job_expected_exit: 'finished job',
  unknown: 'unknown',
};

const RULE_LABELS = {
  R1: 'container check',
  R2: 'you set this',
  R3: 'depended on',
  R4: 'only port',
  R5: 'loopback or UDP sibling',
  R6: 'finished job',
  R7: 'guessed from name',
  R8: 'unknown',
};

const COLOR_SEVERITY = { green: 0, gray: 1, yellow: 2, red: 3 };

function isCoreRole(role) {
  return role === 'core_runtime' || role === 'core_access';
}

function recomputeServiceColor(originalColor, components) {
  const list = Array.isArray(components) ? components : [];
  if (list.length === 0) return originalColor || 'gray';
  const cores = list.filter((c) => isCoreRole(c.effectiveRole || c.role));
  if (cores.length === 0) return originalColor || 'gray';
  const coreFailed = cores.some((c) => c.probe && c.probe.ok === false);
  if (coreFailed) return 'red';
  const supports = list.filter((c) => (c.effectiveRole || c.role) === 'support');
  const supportFailed = supports.some((c) => c.probe && c.probe.ok === false);
  if (supportFailed) return 'yellow';
  const allCoreOk = cores.every((c) => c.probe && c.probe.ok === true);
  return allCoreOk ? 'green' : (originalColor || 'gray');
}

function mergeColors(colors) {
  let worst = 'green';
  colors.forEach((c) => {
    if ((COLOR_SEVERITY[c] || 0) > (COLOR_SEVERITY[worst] || 0)) worst = c;
  });
  return worst;
}

function buildIndex(services) {
  const byProject = new Map();
  const byContainer = new Map();
  const byServiceName = new Map();
  (services || []).forEach((svc) => {
    const projectKey = svc.project || '__noproject__';
    if (!byProject.has(projectKey)) byProject.set(projectKey, []);
    byProject.get(projectKey).push(svc);
    if (svc.name) {
      if (!byServiceName.has(svc.name)) byServiceName.set(svc.name, []);
      byServiceName.get(svc.name).push(svc);
    }
    (svc.components || []).forEach((comp) => {
      if (comp.containerId) {
        byContainer.set(comp.containerId, { service: svc, component: comp });
        const short = comp.containerId.slice(0, 12);
        if (!byContainer.has(short)) byContainer.set(short, { service: svc, component: comp });
      }
    });
  });
  return { byProject, byContainer, byServiceName };
}

function findServiceMatches({ index, isDocker, composeProject, serviceName, containerId, containerIds }) {
  if (!isDocker) return [];
  const uniqIds = Array.from(new Set(
    (Array.isArray(containerIds) && containerIds.length ? containerIds : [containerId]).filter(Boolean)
  ));
  const matches = [];
  const seen = new Set();
  uniqIds.forEach((id) => {
    const hit = index.byContainer.get(id) || index.byContainer.get(id.slice(0, 12));
    if (hit && !seen.has(hit.service.serviceId)) {
      seen.add(hit.service.serviceId);
      matches.push(hit.service);
    }
  });
  if (matches.length === 0 && composeProject) return index.byProject.get(composeProject) || [];
  if (matches.length === 0 && serviceName) return index.byServiceName.get(serviceName) || [];
  return matches;
}

function applyOverridesToMatches(matches, getOverride) {
  const components = [];
  const overrideAdjustedColors = new Map();
  matches.forEach((svc) => {
    let serviceHasOverride = false;
    const svcComps = (svc.components || []).map((comp) => {
      const ovRole = comp.containerId ? getOverride(svc.serviceId, comp.containerId) : null;
      const overridden = !!ovRole;
      if (overridden) serviceHasOverride = true;
      return { ...comp, _serviceName: svc.name, _serviceId: svc.serviceId, effectiveRole: ovRole || comp.role, overridden };
    });
    svcComps.forEach((c) => components.push(c));
    if (serviceHasOverride) {
      overrideAdjustedColors.set(svc.serviceId, recomputeServiceColor(svc.color, svcComps));
    }
  });
  return { components, overrideAdjustedColors };
}

function isAmbientGray(svc, effectiveColor) {
  if (effectiveColor !== 'gray') return false;
  const comps = svc.components || [];
  if (comps.length === 0) return false;
  return comps.every((c) => {
    if (c.ruleId === 'R6') return true;
    if (c.ruleId === 'R8' && c.probe && c.probe.ok === true) return true;
    return false;
  });
}

function describeMatches(matches, color, effectiveServiceColor) {
  if (matches.length === 1) return matches[0].reason || null;
  if (color === 'green') {
    const greens = matches.filter((s) => effectiveServiceColor(s) === 'green');
    const ambient = matches.length - greens.length;
    const names = greens.slice(0, 3).map((s) => s.name || s.serviceId).join(', ');
    const extraGreen = greens.length > 3 ? ` (+${greens.length - 3} more)` : '';
    return ambient > 0
      ? `${greens.length} main service${greens.length === 1 ? '' : 's'} reachable (${names}${extraGreen}); ${ambient} helper checked`
      : `${greens.length} main service${greens.length === 1 ? '' : 's'} reachable: ${names}${extraGreen}`;
  }
  const worst = matches.filter((s) => effectiveServiceColor(s) === color);
  const names = worst.slice(0, 3).map((s) => s.name || s.serviceId).join(', ');
  const extra = worst.length > 3 ? ` (+${worst.length - 3} more)` : '';
  const firstError = worst.flatMap((s) => s.components || [])
    .map((c) => (c && c.probe && c.probe.error) || c.reason).find(Boolean) || null;
  return `${color} via ${names}${extra}${firstError ? `: ${firstError}` : ''}`;
}

function buildLookupCard(state, index, getOverride) {
  return (args) => {
    if (!state.enabled) return null;
    const matches = findServiceMatches({ index, ...args });
    if (!matches.length) return null;
    const { components, overrideAdjustedColors } = applyOverridesToMatches(matches, getOverride);
    const effectiveServiceColor = (svc) =>
      overrideAdjustedColors.has(svc.serviceId) ? overrideAdjustedColors.get(svc.serviceId) : svc.color;
    const effective = matches.filter((m) => !isAmbientGray(m, effectiveServiceColor(m)));
    const colorSource = effective.length > 0 ? effective : matches;
    const color = mergeColors(colorSource.map(effectiveServiceColor).filter(Boolean));
    const reason = describeMatches(matches, color, effectiveServiceColor);
    return { color, reason, services: matches, components };
  };
}

export function ServiceHealthProvider({ children, refreshMs = 15000 }) {
  const [state, setState] = useState({ enabled: false, services: [], updatedAt: null, loading: true });
  const disabledRef = useRef(false);

  const fetchOnce = useCallback(async () => {
    try {
      const res = await fetch('/api/services', { credentials: 'include' });
      if (res.status === 404) {
        disabledRef.current = true;
        setState({ enabled: false, services: [], updatedAt: null, loading: false });
        return;
      }
      if (!res.ok) {
        setState((prev) => ({ ...prev, loading: false }));
        return;
      }
      const data = await res.json();
      setState({
        enabled: true,
        services: Array.isArray(data.services) ? data.services : [],
        updatedAt: Date.now(),
        loading: false,
      });
    } catch {
      setState((prev) => ({ ...prev, loading: false }));
    }
  }, []);

  useEffect(() => {
    fetchOnce();
  }, [fetchOnce]);

  useEffect(() => {
    if (disabledRef.current) return;
    const id = setInterval(fetchOnce, refreshMs);
    return () => clearInterval(id);
  }, [fetchOnce, refreshMs]);

  const index = useMemo(() => buildIndex(state.services), [state.services]);
  const { getOverride } = useOverrides();

  const value = useMemo(() => {
    const lookupCard = buildLookupCard(state, index, getOverride);

    const lookupPort = ({ container_id: containerId }) => {
      if (!state.enabled || !containerId) return null;
      const hit = index.byContainer.get(containerId) || index.byContainer.get(containerId.slice(0, 12));
      if (!hit) return null;
      return {
        component: hit.component,
        service: hit.service,
      };
    };

    return {
      enabled: state.enabled,
      loading: state.loading,
      updatedAt: state.updatedAt,
      services: state.services,
      refresh: fetchOnce,
      lookupCard,
      lookupPort,
    };
  }, [state, index, fetchOnce, getOverride]);

  return React.createElement(ServiceHealthContext.Provider, { value }, children);
}

export function useServiceHealth() {
  const ctx = useContext(ServiceHealthContext);
  if (!ctx) {
    return {
      enabled: false,
      loading: false,
      updatedAt: null,
      services: [],
      refresh: () => {},
      lookupCard: () => null,
      lookupPort: () => null,
    };
  }
  return ctx;
}

export function roleLabel(role) {
  return ROLE_LABELS[role] || role || 'unknown';
}

export function ruleLabel(ruleId) {
  return RULE_LABELS[ruleId] || ruleId || '';
}

export { ROLE_LABELS, RULE_LABELS };