@serve.zone/interfaces 31.3.0 → 31.5.0

package/dist_ts/data/clusteringress.js

@@ -0,0 +1,302 @@
+import { isPlausibleUnicastIpv4 } from '../private/ipv4.js';
+import { isUtcCalendarDay } from '../private/utccalendarday.js';
+/**
+ * The cluster ingress contracts.
+ *
+ * A cluster's ingress terminates TLS for the hostnames its services publish and
+ * forwards to the host ports Pallet published for the workloads behind them.
+ * Cloudly computes the table — it is the only party that knows every service,
+ * every ready endpoint and every certificate — and the relay carries it to the
+ * ingress and the ingress's counters back.
+ *
+ * Names here carry no version suffix and no schema field: the protocol version
+ * is the installed `@serve.zone/interfaces` version.
+ */
+export const clusterIngressLimits = Object.freeze({
+    minimumIngressBearerLength: 16,
+    maximumIngressBearerLength: 4096,
+    maximumHostNameLength: 253,
+    maximumRoutes: 4096,
+    maximumPortRoutes: 1024,
+    maximumDestinationsPerRoute: 64,
+    maximumStatisticsPageSize: 1000,
+    maximumCursorLength: 512,
+    maximumIdentifierLength: 200,
+    maximumIngressCapabilities: 32,
+});
+const isRecord = (valueArg) => (Boolean(valueArg)
+    && typeof valueArg === 'object'
+    && !Array.isArray(valueArg)
+    && (Object.getPrototypeOf(valueArg) === Object.prototype
+        || Object.getPrototypeOf(valueArg) === null));
+const hasExactKeys = (valueArg, keysArg, optionalKeysArg = []) => {
+    const actualKeys = Object.keys(valueArg);
+    return keysArg.every((keyArg) => actualKeys.includes(keyArg))
+        && actualKeys.every((keyArg) => keysArg.includes(keyArg) || optionalKeysArg.includes(keyArg));
+};
+const isCounter = (valueArg) => (Number.isSafeInteger(valueArg) && valueArg >= 0);
+const isPort = (valueArg) => (Number.isSafeInteger(valueArg) && valueArg >= 1 && valueArg <= 65_535);
+const hostLabelPattern = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+// Built from the limit rather than beside it, so the two can never disagree.
+const identifierPattern = new RegExp(`^[A-Za-z0-9][A-Za-z0-9:._-]{0,${clusterIngressLimits.maximumIdentifierLength - 1}}$`);
+/**
+ * A hostname a certificate can be issued for and a browser can present.
+ *
+ * Lowercase labels only, because a certificate names the lowercase form and a
+ * table that carried both would serve one of them without a certificate.
+ */
+export const isClusterIngressHostName = (valueArg) => {
+    if (typeof valueArg !== 'string'
+        || valueArg.length === 0
+        || valueArg.length > clusterIngressLimits.maximumHostNameLength) {
+        return false;
+    }
+    const labels = valueArg.split('.');
+    return labels.length >= 2 && labels.every((labelArg) => hostLabelPattern.test(labelArg));
+};
+const validateDestinations = (valueArg, pathArg) => {
+    if (!Array.isArray(valueArg)
+        || valueArg.length === 0
+        || valueArg.length > clusterIngressLimits.maximumDestinationsPerRoute) {
+        return [`${pathArg} must list 1 to `
+                + `${clusterIngressLimits.maximumDestinationsPerRoute} destinations`];
+    }
+    const errors = [];
+    for (const [index, destination] of valueArg.entries()) {
+        const destinationPath = `${pathArg}[${index}]`;
+        if (!isRecord(destination) || !hasExactKeys(destination, ['address', 'port'])) {
+            errors.push(`${destinationPath} must use its exact schema`);
+            continue;
+        }
+        if (!isPlausibleUnicastIpv4(destination.address)) {
+            errors.push(`${destinationPath} address must be a unicast IPv4 literal`);
+        }
+        if (!isPort(destination.port)) {
+            errors.push(`${destinationPath} port must be an integer from 1 to 65535`);
+        }
+    }
+    return errors;
+};
+const validateCertificate = (valueArg, pathArg) => {
+    // Presence and shape only. The material itself is never described in a reason:
+    // a validation message travels into logs, and this one would carry a key.
+    if (!isRecord(valueArg) || !hasExactKeys(valueArg, ['publicKey', 'privateKey'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (typeof valueArg.publicKey !== 'string' || valueArg.publicKey.length === 0) {
+        errors.push(`${pathArg} publicKey must be a non-empty PEM string`);
+    }
+    if (typeof valueArg.privateKey !== 'string' || valueArg.privateKey.length === 0) {
+        errors.push(`${pathArg} privateKey must be a non-empty PEM string`);
+    }
+    return errors;
+};
+const validateAuthentication = (valueArg, pathArg) => {
+    if (!isRecord(valueArg) || !hasExactKeys(valueArg, ['type', 'user', 'pass'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    return valueArg.type === 'Basic'
+        && typeof valueArg.user === 'string' && valueArg.user.length > 0
+        && typeof valueArg.pass === 'string' && valueArg.pass.length > 0
+        ? []
+        : [`${pathArg} must be Basic authentication with a user and a pass`];
+};
+const validateHttpRoute = (valueArg, pathArg) => {
+    if (!isRecord(valueArg)
+        || !hasExactKeys(valueArg, ['hostName', 'destinations', 'certificate'], ['authentication'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (!isClusterIngressHostName(valueArg.hostName)) {
+        errors.push(`${pathArg} hostName must be a lowercase dotted hostname a certificate can name`);
+    }
+    errors.push(...validateDestinations(valueArg.destinations, `${pathArg} destinations`));
+    errors.push(...validateCertificate(valueArg.certificate, `${pathArg} certificate`));
+    if (valueArg.authentication !== undefined) {
+        errors.push(...validateAuthentication(valueArg.authentication, `${pathArg} authentication`));
+    }
+    return errors;
+};
+const validatePortRoute = (valueArg, pathArg) => {
+    if (!isRecord(valueArg)
+        || !hasExactKeys(valueArg, ['name', 'listenPort', 'transport', 'destinations'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (typeof valueArg.name !== 'string' || !identifierPattern.test(valueArg.name)) {
+        errors.push(`${pathArg} name must be a bounded identifier`);
+    }
+    if (!isPort(valueArg.listenPort)) {
+        errors.push(`${pathArg} listenPort must be an integer from 1 to 65535`);
+    }
+    if (valueArg.transport !== 'tcp' && valueArg.transport !== 'udp') {
+        errors.push(`${pathArg} transport must be tcp or udp`);
+    }
+    errors.push(...validateDestinations(valueArg.destinations, `${pathArg} destinations`));
+    return errors;
+};
+/**
+ * Validates one route table and names every reason it is refused.
+ *
+ * Shape only. Whether a hostname belongs to the cluster, whether a certificate
+ * matches it, and whether a destination is a node of this cluster are decisions
+ * for the party that computed the table; a table that passes here has claimed
+ * none of them. No reason ever quotes certificate material.
+ */
+export const validateClusterRouteTable = (valueArg, pathArg = 'cluster route table') => {
+    if (!isRecord(valueArg)
+        || !hasExactKeys(valueArg, ['revision', 'issuedAt', 'routes', 'portRoutes'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (!isCounter(valueArg.revision)) {
+        errors.push(`${pathArg} revision must be a non-negative safe integer`);
+    }
+    if (!Number.isSafeInteger(valueArg.issuedAt) || valueArg.issuedAt <= 0) {
+        errors.push(`${pathArg} issuedAt must be a positive epoch millisecond timestamp`);
+    }
+    if (!Array.isArray(valueArg.routes)
+        || valueArg.routes.length > clusterIngressLimits.maximumRoutes) {
+        errors.push(`${pathArg} routes must list at most ${clusterIngressLimits.maximumRoutes} routes`);
+    }
+    else {
+        const seenHostNames = new Set();
+        for (const [index, route] of valueArg.routes.entries()) {
+            errors.push(...validateHttpRoute(route, `${pathArg} routes[${index}]`));
+            const hostName = isRecord(route) ? route.hostName : undefined;
+            if (typeof hostName === 'string') {
+                if (seenHostNames.has(hostName)) {
+                    errors.push(`${pathArg} routes[${index}] repeats hostName ${hostName}`);
+                }
+                seenHostNames.add(hostName);
+            }
+        }
+    }
+    if (!Array.isArray(valueArg.portRoutes)
+        || valueArg.portRoutes.length > clusterIngressLimits.maximumPortRoutes) {
+        errors.push(`${pathArg} portRoutes must list at most `
+            + `${clusterIngressLimits.maximumPortRoutes} port routes`);
+    }
+    else {
+        const seenPorts = new Set();
+        for (const [index, portRoute] of valueArg.portRoutes.entries()) {
+            errors.push(...validatePortRoute(portRoute, `${pathArg} portRoutes[${index}]`));
+            if (!isRecord(portRoute)) {
+                continue;
+            }
+            const key = `${String(portRoute.transport)}:${String(portRoute.listenPort)}`;
+            if (seenPorts.has(key)) {
+                errors.push(`${pathArg} portRoutes[${index}] repeats ${key}`);
+            }
+            seenPorts.add(key);
+        }
+    }
+    return errors;
+};
+/** Validates one day bucket of ingress counters. */
+export const validateClusterTrafficStatistics = (valueArg, pathArg = 'cluster traffic statistics') => {
+    if (!isRecord(valueArg) || !hasExactKeys(valueArg, [
+        'serviceId', 'hostName', 'nodeId', 'dayUtc', 'requests', 'bytesIn', 'bytesOut',
+        'connections', 'backendErrors', 'updatedAt',
+    ])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    for (const key of ['serviceId', 'nodeId']) {
+        const value = valueArg[key];
+        if (typeof value !== 'string' || !identifierPattern.test(value)) {
+            errors.push(`${pathArg} ${key} must be a bounded identifier`);
+        }
+    }
+    if (!isClusterIngressHostName(valueArg.hostName)) {
+        errors.push(`${pathArg} hostName must be a lowercase dotted hostname`);
+    }
+    if (!isUtcCalendarDay(valueArg.dayUtc)) {
+        errors.push(`${pathArg} dayUtc must be a real YYYY-MM-DD UTC calendar day`);
+    }
+    for (const key of ['requests', 'bytesIn', 'bytesOut', 'connections']) {
+        if (!isCounter(valueArg[key])) {
+            errors.push(`${pathArg} ${key} must be a non-negative safe integer`);
+        }
+    }
+    const backendErrors = valueArg.backendErrors;
+    if (!isRecord(backendErrors)
+        || !hasExactKeys(backendErrors, ['connect', 'handshake', 'request'])
+        || !isCounter(backendErrors.connect)
+        || !isCounter(backendErrors.handshake)
+        || !isCounter(backendErrors.request)) {
+        errors.push(`${pathArg} backendErrors must count connect, handshake and request failures`);
+    }
+    if (!Number.isSafeInteger(valueArg.updatedAt) || valueArg.updatedAt <= 0) {
+        errors.push(`${pathArg} updatedAt must be a positive epoch millisecond timestamp`);
+    }
+    return errors;
+};
+/**
+ * Validates one page of ingress counters, as a reader receives it.
+ *
+ * The cursor is opaque to everyone but the ingress that issued it: bounded and
+ * printable here, meaningful only there.
+ */
+export const validateClusterTrafficStatisticsPage = (valueArg, pathArg = 'cluster traffic statistics page') => {
+    if (!isRecord(valueArg) || !hasExactKeys(valueArg, ['statistics'], ['nextCursor'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (!Array.isArray(valueArg.statistics)
+        || valueArg.statistics.length > clusterIngressLimits.maximumStatisticsPageSize) {
+        errors.push(`${pathArg} statistics must list at most `
+            + `${clusterIngressLimits.maximumStatisticsPageSize} entries`);
+    }
+    else {
+        for (const [index, item] of valueArg.statistics.entries()) {
+            errors.push(...validateClusterTrafficStatistics(item, `${pathArg} statistics[${index}]`));
+        }
+    }
+    if (valueArg.nextCursor !== undefined
+        && (typeof valueArg.nextCursor !== 'string'
+            || valueArg.nextCursor.length === 0
+            || valueArg.nextCursor.length > clusterIngressLimits.maximumCursorLength)) {
+        errors.push(`${pathArg} nextCursor must be 1 to `
+            + `${clusterIngressLimits.maximumCursorLength} characters when present`);
+    }
+    return errors;
+};
+/**
+ * Validates one cluster ingress registration and names every reason it is refused.
+ *
+ * Shape only, and deliberately so: whether the bearer is the one Cloudly minted
+ * for this cluster's ingress is Cloudly's to verify against its own records, and
+ * which cluster is speaking comes from the identity tag on the relay's session.
+ * A registration that passes here has proven nothing — and no reason it returns
+ * ever quotes the bearer, because a reason travels into logs.
+ */
+export const validateClusterIngressRegistration = (valueArg, pathArg = 'cluster ingress registration') => {
+    if (!isRecord(valueArg)
+        || !hasExactKeys(valueArg, ['bearer', 'version', 'nodeId'], ['capabilities'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (typeof valueArg.bearer !== 'string'
+        || valueArg.bearer.length < clusterIngressLimits.minimumIngressBearerLength
+        || valueArg.bearer.length > clusterIngressLimits.maximumIngressBearerLength) {
+        errors.push(`${pathArg} bearer must be ${clusterIngressLimits.minimumIngressBearerLength} to `
+            + `${clusterIngressLimits.maximumIngressBearerLength} characters`);
+    }
+    if (typeof valueArg.version !== 'string' || !identifierPattern.test(valueArg.version)) {
+        errors.push(`${pathArg} version must be a bounded identifier`);
+    }
+    if (typeof valueArg.nodeId !== 'string' || !identifierPattern.test(valueArg.nodeId)) {
+        errors.push(`${pathArg} nodeId must be a bounded identifier`);
+    }
+    if (valueArg.capabilities !== undefined
+        && (!Array.isArray(valueArg.capabilities)
+            || valueArg.capabilities.length > clusterIngressLimits.maximumIngressCapabilities
+            || !valueArg.capabilities.every((capabilityArg) => (typeof capabilityArg === 'string' && identifierPattern.test(capabilityArg))))) {
+        errors.push(`${pathArg} capabilities must be at most `
+            + `${clusterIngressLimits.maximumIngressCapabilities} bounded identifiers when present`);
+    }
+    return errors;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clusteringress.js","sourceRoot":"","sources":["../../ts/data/clusteringress.ts"],"names":[],"mappings":"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"}