metastar/meta-fuse
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

replace file discovery by udp discovery
Build and Push Docker Image / build (push) Failing after 13s
Details

Browse Source
This commit is contained in:
Worph
2026-09-14 11:25:03 +02:00
parent 2c485d5616
commit daf464261d
5 changed files with 72 additions and 402 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/meta-fuse-core/src/api/APIServer.ts
+20 -29
View File
@@ -91,9 +91,9 @@ export class APIServer {
this.app.post('/api/fuse/rules/validate', this.handleValidateRule.bind(this));
this.app.get('/api/fuse/rules/variables', this.handleGetVariables.bind(this));
// Service discovery — proxies to meta-core's /api/services, resolving the
// current leader's URL via LeaderClient (no hardcoded hostname).
this.app.get('/api/services', this.handleServices.bind(this));
// meta-discovery v1: neighbours heard over UDP, from this service's own
// map — no meta-core needed, so the nav renders even when the core is down.
this.app.get('/api/neighbors', this.handleNeighbors.bind(this));
// WebDAV access tokens (per-device basic-auth passwords for /webdav).
this.app.get('/api/webdav-tokens', this.handleListTokens.bind(this));
@@ -134,36 +134,27 @@ export class APIServer {
}
/**
* Proxy handler that forwards /api/services to meta-core's canonical
* registry endpoint using LeaderClient for discovery.
* meta-discovery v1 neighbours, served from this service's own UDP map.
* `services` is an alias kept while older dashboard builds are around.
*/
private async handleServices(_req: FastifyRequest, reply: FastifyReply): Promise<void> {
try {
const leaderClient = this.kvManager?.getLeaderClient();
if (!leaderClient) {
reply.status(503).send({ error: 'KVManager not initialized' });
return;
}
const apiUrl = await leaderClient.getApiUrl();
if (!apiUrl) {
reply.status(503).send({ error: 'Leader not available yet' });
return;
}
const response = await fetch(`${apiUrl}/api/services`, {
signal: AbortSignal.timeout(5000),
});
if (!response.ok) {
reply.status(response.status).send({
error: `Upstream ${apiUrl} returned ${response.status}`,
});
return;
}
reply.send(await response.json());
} catch (err: any) {
reply.status(502).send({ error: err?.message ?? String(err) });
private async handleNeighbors(_request: FastifyRequest, reply: FastifyReply): Promise<void> {
const leaderClient = this.kvManager?.getLeaderClient();
if (!leaderClient) {
void reply.send({ current: 'meta-fuse', enabled: false, count: 0, neighbors: [] });
return;
}
const neighbors = leaderClient.getNeighbors();
void reply.send({
current: 'meta-fuse',
enabled: true,
count: neighbors.length,
neighbors,
services: neighbors,
self: leaderClient.self(),
});
}
/**
* Start the server
*/
packages/meta-fuse-core/src/kv/IKVClient.ts
+1 -1
View File
@@ -58,7 +58,7 @@ export interface IKVClient {
}
/**
* Leader lock file content format (kv-leader.info)
* meta-core's identity and URL set (from its UDP announce, or /urls)
* Written by meta-core leader, read by other services
*/
export interface LeaderLockInfo {
packages/meta-fuse-core/src/kv/KVManager.ts
+7 -6
View File
@@ -2,7 +2,7 @@
* KV Manager for meta-fuse (FOLLOWER-only)
*
* Simplified KV manager that:
* 1. Discovers the leader via LeaderClient (reads kv-leader.info)
* 1. Locates meta-core via LeaderClient (UDP announce, meta-discovery v1)
* 2. Creates Redis client connection
* 3. Handles reconnection on leader failure
*
@@ -81,7 +81,12 @@ export class KVManager {
// No separate service registration step any more: the LeaderClient's
// discovery node announces this service on the same UDP group it
// listens on, so being discoverable and discovering are one thing.
const apiUrl = this.config.baseUrl || `http://${hostname()}:${this.config.apiPort}`;
// Browser-facing URL for the nav menu, in the order the spec requires:
// PUBLIC_URL (reachable when there is no Caddy perimeter in front — a
// debug-direct port) -> BASE_URL (the Caddy URL) -> container host.
// Announcing a Caddy URL on a stack with no Caddy running is what puts
// dead links in every neighbour's menu.
const apiUrl = process.env.PUBLIC_URL || this.config.baseUrl || `http://${hostname()}:${this.config.apiPort}`;
// If direct Redis URL provided, skip leader discovery
if (this.config.redisUrl) {
@@ -342,10 +347,6 @@ export class KVManager {
/**
* Get service registration instance
*/
/** @deprecated File-based registration is gone; always null. */
getServiceRegistration(): null {
return null;
}
/**
* Get configured paths
packages/meta-fuse-core/src/kv/ServiceRegistration.ts
-211
View File
@@ -1,211 +0,0 @@
/**
* Service Registration using shared filesystem
*
* Each service registers itself in /meta-core/services/{service-name}-{hostname}.json
* with its base URL, status, and heartbeat timestamp.
*
* Service discovery is centralized in meta-core - this class only handles registration.
* For service discovery, use the /api/services endpoint (proxied to meta-core via nginx).
*
* Each service must call start() to register itself and begin heartbeat updates.
* meta-core runs a cleanup process that removes services with stale heartbeats.
*/
import { promises as fs } from 'fs';
import { hostname } from 'os';
import { Logger } from 'tslog';
import type { ServiceInfo } from './IKVClient.js';
const logger = new Logger({ name: 'ServiceRegistration' });
interface ServiceRegistrationConfig {
/** Path to META_CORE_VOLUME (e.g., /meta-core) */
metaCorePath: string;
/** Service name */
serviceName: string;
/** Base URL for the service */
apiUrl: string;
/** Heartbeat interval in ms (default: 30000) */
heartbeatInterval?: number;
/** Stale threshold in ms (default: 60000) */
staleThreshold?: number;
}
export class ServiceRegistration {
private config: ServiceRegistrationConfig;
private servicesDir: string;
private serviceFilePath: string;
private heartbeatTimer: NodeJS.Timeout | null = null;
private isShuttingDown = false;
private isStarted = false;
private currentHostname: string;
constructor(config: ServiceRegistrationConfig) {
this.config = {
heartbeatInterval: 30000,
staleThreshold: 60000,
...config
};
this.currentHostname = hostname();
this.servicesDir = `${this.config.metaCorePath}/services`;
// Use hostname-based file naming
this.serviceFilePath = `${this.servicesDir}/${this.config.serviceName}-${this.currentHostname}.json`;
}
/**
* Ensure services directory exists
*/
private async ensureServicesDir(): Promise<void> {
await fs.mkdir(this.servicesDir, { recursive: true });
}
/**
* Build service info for this service
*/
private buildServiceInfo(status: ServiceInfo['status']): ServiceInfo {
return {
name: this.config.serviceName,
hostname: this.currentHostname,
baseUrl: this.config.apiUrl,
status,
lastHeartbeat: new Date().toISOString()
};
}
/**
* Register this service by writing service info to the shared filesystem.
* meta-core's cleanup process monitors these files and removes stale entries.
*/
async register(): Promise<void> {
await this.ensureServicesDir();
const info = this.buildServiceInfo('running');
await fs.writeFile(this.serviceFilePath, JSON.stringify(info, null, 2));
logger.info(`Registered ${this.config.serviceName}-${this.currentHostname}`);
}
/**
* Update service status
*/
async updateStatus(status: ServiceInfo['status']): Promise<void> {
try {
const content = await fs.readFile(this.serviceFilePath, 'utf-8');
const info = JSON.parse(content) as ServiceInfo;
info.status = status;
info.lastHeartbeat = new Date().toISOString();
await fs.writeFile(this.serviceFilePath, JSON.stringify(info, null, 2));
} catch (error) {
logger.error('Failed to update status:', error);
}
}
/**
* Send heartbeat (update lastHeartbeat timestamp)
*/
async heartbeat(): Promise<void> {
try {
const content = await fs.readFile(this.serviceFilePath, 'utf-8');
const info = JSON.parse(content) as ServiceInfo;
info.lastHeartbeat = new Date().toISOString();
await fs.writeFile(this.serviceFilePath, JSON.stringify(info, null, 2));
} catch (error: any) {
// If file was deleted, re-register
if (error.code === 'ENOENT') {
await this.register();
} else {
logger.error('Heartbeat failed:', error);
}
}
}
/**
* Start heartbeat loop
*/
startHeartbeat(): void {
this.heartbeatTimer = setInterval(async () => {
if (this.isShuttingDown) return;
await this.heartbeat();
}, this.config.heartbeatInterval);
}
/**
* Stop heartbeat loop
*/
stopHeartbeat(): void {
if (this.heartbeatTimer) {
clearInterval(this.heartbeatTimer);
this.heartbeatTimer = null;
}
}
/**
* Unregister this service (on shutdown)
*/
async unregister(): Promise<void> {
this.isShuttingDown = true;
this.stopHeartbeat();
try {
// Remove the service file
await fs.unlink(this.serviceFilePath);
logger.info(`Unregistered ${this.config.serviceName}-${this.currentHostname}`);
} catch (error: any) {
if (error.code !== 'ENOENT') {
logger.error('Failed to unregister:', error);
}
}
}
// ========================================================================
// Lifecycle
// ========================================================================
/**
* Full startup sequence: register service and start heartbeat loop.
*/
async start(): Promise<void> {
if (this.isStarted) return;
await this.register();
this.startHeartbeat();
this.isStarted = true;
logger.info(`Started ${this.config.serviceName} at ${this.config.apiUrl}`);
}
/**
* Full shutdown sequence
*/
async stop(): Promise<void> {
if (!this.isStarted) return;
await this.unregister();
this.isStarted = false;
}
// ========================================================================
// Getters
// ========================================================================
getServiceFilePath(): string {
return this.serviceFilePath;
}
getServicesDir(): string {
return this.servicesDir;
}
getIsStarted(): boolean {
return this.isStarted;
}
}