@persistica/flux-mesh 0.0.1 → 0.0.4

package/src/orchestrators/facilitate-webrtc-connection.class.ts

@@ -1,23 +0,0 @@
-import {
-    GlobalWebRTCClient,
-    WebRTCClient,
-} from '../_classes/web-rtc-client-interface.class';
-
-export const facilitateWebRTCConnection = async (
-    initiator: WebRTCClient | GlobalWebRTCClient,
-    remoteClient: GlobalWebRTCClient
-) => {
-    //   console.log('Orchestrate ICS COnnection', initiator, remoteClient);
-
-    // initiator.
-    const offer = await initiator.createOffer();
-    console.log('Created offer:', !!offer);
-
-    const answer = await remoteClient.acceptOfferAndCreateAnswer(offer);
-    console.log('Got answer:', !!answer);
-
-    const acceptAnswer: boolean = await initiator.acceptAnswer(answer);
-    console.log('Answer was accepted by initiator:', acceptAnswer);
-
-    await remoteClient.answerWasAccepted(acceptAnswer);
-};

package/src/register/network-client-manager.class.ts

@@ -1,175 +0,0 @@
-import {
-    type RedisConnection,
-    getMeshRedisConnection,
-} from '../routing/redis/redis-connection.class';
-import type {
-    NetworkAgentRedisService,
-} from '@flux/mesh/store/redis/network-agent';
-import {
-    NetworkUsageRedisCacheService,
-} from '@flux/mesh/store/redis/network-usage';
-import type {
-    TAddress,
-    TClientId,
-    TAgentOwnUId,
-    TNetworkId_S,
-} from '@flux/shared/types';
-import type {
-    TFluxClientUID,
-} from '@flux/shared/utils';
-
-export class NetworkAgentManager {
-    public readonly networkAgentRedisService: NetworkAgentRedisService;
-    public readonly networkUsageRedisCacheService: NetworkUsageRedisCacheService;
-
-    private readonly redisConnection: RedisConnection = getMeshRedisConnection();
-    private readonly cache: Map<`${TNetworkId_S}.${TAgentOwnUId}`, TAddress> = new Map(); // ! cleanup
-    private readonly timers: Map<TClientId, ReturnType<typeof setInterval>> = new Map();
-
-    constructor(
-
-    ) {
-        this.networkAgentRedisService = this.redisConnection.networkAgentRedisService;
-        this.networkUsageRedisCacheService = new NetworkUsageRedisCacheService(this.redisConnection['cacheClient'].getClient());
-    }
-
-    /**
-     * Register an agent.
-     *
-     * @param { TNetworkId_S }              networkId
-     * @param { TClientId }                 id
-     * @param { Bun.SocketAddress | null }  ip
-     * @param { TAddress }                  address
-     * @param { TAgentOwnUId }              [uid]
-     * 
-     * @returns { void }
-     */
-    public registerAgent(
-        networkId: TNetworkId_S,
-        id: TClientId,
-        ip: Bun.SocketAddress | null,
-        address: TAddress,
-        throughput: {
-            bytes: number,
-            packets: number,
-        },
-        uid?: TAgentOwnUId,
-        machineUID?: TFluxClientUID,
-    ): Promise<void> {
-        this.timers.set(
-            id,
-            setInterval(async () => {
-                await this.networkAgentRedisService
-                    .registerAgentThroughput(
-                        networkId,
-                        id,
-                        throughput.bytes,
-                        throughput.packets,
-                    );
-
-                if ((throughput.bytes > 0) || (throughput.packets > 0)) {
-                    await this.networkUsageRedisCacheService
-                        .increaseNetworkUsage(
-                            networkId,
-                            throughput.bytes,
-                            throughput.packets,
-                        );
-                }
-
-                throughput.bytes = 0;
-                throughput.packets = 0;
-            }, 1_000),
-        );
-
-        return this.networkAgentRedisService
-            .registerAgent(
-                networkId,
-                id,
-                ip,
-                address,
-                uid,
-                machineUID,
-            );
-    }
-
-    /**
-     * Unregisters a network agent UID and associated data from the Redis hash.
-     *
-     * @param { TNetworkId_S }      networkId
-     * @param { TClientId }         clientId
-     * @param { TAgentOwnUId }     clientOwnUId
-     * 
-     * @returns { void }
-     */
-    public unregisterNetworkAgent(
-        networkId: TNetworkId_S,
-        clientId: TClientId,
-        clientOwnUId?: TAgentOwnUId,
-    ): void {
-        if (clientOwnUId) {
-            // Unregisters a network client UID and address in the Redis hash.
-            this.cache.delete(`${networkId}.${clientOwnUId}`);
-
-            this.networkAgentRedisService.unregisterNetworkAgent(
-                networkId,
-                clientId,
-                clientOwnUId,
-            );
-        }
-
-        // Cancel the timer
-        clearInterval(this.timers.get(clientId));
-    }
-
-    public async resolveNetworkClientAddressByUid(
-        networkId: TNetworkId_S,
-        clientOwnUId: TAgentOwnUId,
-        // retryWithDelay?: number,
-    ): Promise<TAddress> {
-        const cached: TAddress | undefined = this.cache.get(
-            `${networkId}.${clientOwnUId}`
-        );
-
-        if (cached) {
-            return cached;
-        }
-
-        const address: TAddress = await this.redisConnection
-            .networkAgentRedisService
-            .readNetworkClientAddressByUIDOrThrow(
-                networkId,
-                clientOwnUId
-            );
-
-        this.cache.set(`${networkId}.${clientOwnUId}`, address);
-
-        return address;
-    }
-
-    // public register(
-    //     networkId: TNetworkId_S,
-    //     socketId: TClientId,
-    // ): void {
-    //     this.redisConnection
-    //         .networkAuthoritySet
-    //         .registerNetworkAuthority(
-    //             networkId,
-    //             socketId,
-    //         );
-    // }
-
-    // public unregister(
-    //     networkId: TNetworkId_S,
-    //     socketId: TClientId,
-    // ): void {
-    //     this.cache.delete(networkId);
-
-    //     this.redisConnection
-    //         .networkAuthoritySet
-    //         .unregister(
-    //             networkId,
-    //             socketId,
-    //         );
-    // }
-
-}

package/src/register/register-network-authority.class.ts

@@ -1,123 +0,0 @@
-import { splitAddressOrThrow, type TAddress, type TClientId, type TNetworkId_S } from '@flux/shared/types';
-import {
-    type RedisConnection,
-    getMeshRedisConnection,
-} from '../routing/redis/redis-connection.class';
-import type {
-    TFluxClientUID,
-} from '@flux/shared/utils';
-
-export class NetworkAuthorityManager {
-    private readonly redisConnection: RedisConnection = getMeshRedisConnection();
-    private readonly cache: Map<TNetworkId_S, Set<TAddress>> = new Map();
-
-    public async register(
-        networkId: TNetworkId_S,
-        socketId: TClientId,
-        machineUID?: TFluxClientUID,
-    ): Promise<void> {
-        await this.redisConnection.networkAuthoritySet
-            .registerNetworkAuthority(
-                networkId,
-                socketId,
-                machineUID,
-            );
-    }
-
-    public unregister(
-        networkId: TNetworkId_S,
-        networkAuthorityAddress: TAddress,
-    ): void {
-        const cached: Set<TAddress> | undefined = this.cache.get(networkId);
-        if (cached) {
-            cached.delete(networkAuthorityAddress);
-        }
-
-        const [_machineAddress, _processId, clientId] = splitAddressOrThrow(networkAuthorityAddress);
-
-        this.redisConnection.networkAuthoritySet.unregister(
-            networkId,
-            clientId,
-        );
-    }
-
-    /**
-     * Used for cleanup, in case of discovering an idle authority.
-     * 
-     * @param { TNetworkId_S }  networkId
-     * @param { TAddress }      networkAuthorityAddress
-     * 
-     * @returns { void }
-     */
-    public unregisterGlobal(
-        networkId: TNetworkId_S,
-        networkAuthorityAddress: TAddress,
-    ): void {
-        const cached: Set<TAddress> | undefined = this.cache.get(networkId);
-        if (cached) {
-            cached.delete(networkAuthorityAddress);
-        }
-
-        this.redisConnection.networkAuthoritySet
-            .unregisterGlobal(
-                networkId,
-                networkAuthorityAddress,
-            );
-    }
-
-    /**
-     * Resolves a random network authority address for a given network ID.
-     * 
-     * @param { TNetworkId_S }  networkId
-     * 
-     * @returns { Promise<TAddress> }
-     */
-    public async resolveNetworkAuthorityAddressOrThrow(
-        networkId: TNetworkId_S
-        // retryWithDelay?: number,
-    ): Promise<TAddress> {
-        const cached: Set<TAddress> | undefined = this.cache.get(networkId);
-
-        if (cached && (cached.size > 0)) {
-            const randomItem = [...cached][Math.floor(Math.random() * [...cached].length)];
-
-            if (randomItem) {
-                return randomItem;
-            }
-        }
-
-        const address: TAddress[] = await this.redisConnection
-            .networkAuthoritySet
-            .resolveNetworkAuthorityAddressesOrThrow(
-                networkId,
-            );
-
-        if (cached) {
-            for (const a of address) {
-                cached.add(a);
-            }
-        } else {
-            this.cache.set(networkId, new Set(address));
-        }
-
-        const cached_: Set<TAddress> = this.cache.get(networkId) as Set<TAddress>;
-        const randomItem = [...cached_][Math.floor(Math.random() * [...cached_].length)];
-
-        return randomItem;
-    }
-
-    /**
-     * Removes a client.
-     * 
-     * @param { TNetworkId_S }  networkId
-     * @param { TAddress }      networkAuthorityAddress
-     * 
-     * @returns { void }
-     */
-    public removeUnresponsiveClient(
-        networkId: TNetworkId_S,
-        networkAuthorityAddress: TAddress,
-    ): void {
-        this.unregisterGlobal(networkId, networkAuthorityAddress);
-    }
-}

package/src/routing/addressing.utils.ts

@@ -1,34 +0,0 @@
-import * as os from 'node:os';
-import type {
-    TMachineAddress,
-    TProcessId,
-    TProcessAddress,
-} from '@flux/shared/types';
-
-export const readProcessId = (): TProcessId => {
-    return process.pid as TProcessId;
-};
-
-let machineAddress: TMachineAddress | undefined;
-export const readMachineAddress = (): TMachineAddress => {
-    if (machineAddress) {
-        return machineAddress;
-    }
-
-    machineAddress = Object.values(os.networkInterfaces())
-        .flat()
-        .find((i) => i && !i.internal && i.mac !== '00:00:00:00:00:00')
-        ?.mac.replaceAll(':', '')
-        .replace(/^0+/, '') as TMachineAddress;
-
-    return machineAddress;
-};
-
-/**
- * Returns the process address.
- *
- * @returns { TProcessAddress }
- */
-export const readProcessAddress = (): TProcessAddress => {
-    return `${readMachineAddress()}/${readProcessId()}`;
-};

package/src/routing/global-channel/global-channel-pubsub.class.ts

@@ -1,76 +0,0 @@
-/**
- * 1. Detects global events and publishes them to all clients subscribed to the websocket channel system.
- * 
- * 2.   Sends messages to all nodes in the cluster, and when reached, publishes locally 
- *      on the server channel to everyone subscribed.
- */
-
-import type { TProcessAddress } from '@flux/shared/types';
-import type { TConnectedClientSocket } from '../../main';
-import type { RedisConnection } from '../redis/redis-connection.class';
-
-export type TGlobalChannel = string & { __brand: 'global-channel'; };
-
-export class GlobalChannelPubsub {
-
-    constructor(
-        private readonly redisConnection: RedisConnection,
-        private readonly bunServer: Bun.Server,
-        private readonly processAddress: TProcessAddress,
-    ) {
-        this.subscribeWebsocketChannelEvent();
-    }
-
-    /**
-     * Subscribes to the websocket channel event and publishes it on the local process.
-     * 
-     * @returns { void }
-     */
-    private subscribeWebsocketChannelEvent(
-    ): void {
-        this.redisConnection
-            .subscribeWebsocketChannelEvent((
-                channel: TGlobalChannel,
-                skipProcessAddress: TProcessAddress,
-                message: string,
-            ): void => {
-                if (this.processAddress === skipProcessAddress) {
-                    return;
-                }
-
-                // Publish it on the local process
-                this.bunServer.publish(
-                    message,
-                    channel,
-                );
-            });
-    }
-
-    /**
-     * Publishes a message to the given channel.
-     * 
-     * @param { string }  channel
-     * @param { string }  message
-     * @param { TConnectedClientSocket }  [ws]
-     * 
-     * @returns { Promise<void> }
-     */
-    public async publish(
-        channel: string,
-        message: string,
-        ws?: TConnectedClientSocket,
-    ): Promise<void> {
-        // Publish locally on the process to everyone but the client (if a client is provided)
-        (ws ?? this.bunServer).publish(
-            channel,
-            message,
-        );
-
-        // Publish globally to clients connected to other processes
-        await this.redisConnection.publishWebsocketChannelEvent(
-            this.processAddress, // The event is already sent to the local process
-            channel as TGlobalChannel,
-            message,
-        );
-    }
-}

package/src/routing/incomming-message-router.class.ts

@@ -1,47 +0,0 @@
-/**
- * Route messages to the correct destination.
- */
-import type { TClientId } from '@flux/shared/types';
-import {
-    type RedisConnection,
-    getMeshRedisConnection,
-} from './redis/redis-connection.class';
-
-export class IncommingMessageRouter {
-    private readonly redisConnection: RedisConnection = getMeshRedisConnection();
-
-    constructor(
-        private readonly onLocal: (
-            clientId: TClientId,
-            onMessage: (message: string) => void
-        ) => void
-    ) { }
-
-    /**
-     *
-     * @param address
-     * @param message
-     *
-     * @returns { void }
-     */
-    //     public subscribe(
-    //         clientId: TClientId,
-    //         onMessage: (
-    //             message: string,
-    //         ) => void,
-    //     ): void {
-    // console.log("subscreibing client", clientId);
-    //         // Listen to local
-    //         this.onLocal(
-    //             clientId,
-    //             onMessage,
-    //         );
-
-    //         // Listen to remote
-    //         this.redisConnection
-    //             .subscribe(
-    //                 clientId,
-    //                 onMessage,
-    //             );
-    //     }
-}

package/src/routing/outgoing-message-router.class.ts

@@ -1,72 +0,0 @@
-/**
- * Route messages to the correct destination.
- */
-import {
-    type TAddress,
-    type TClientId,
-    type TMachineAddress,
-    type TProcessId,
-    splitAddressOrThrow,
-} from '@flux/shared/types';
-import { readMachineAddress, readProcessId } from './addressing.utils';
-import {
-    type RedisConnection,
-    getMeshRedisConnection,
-} from './redis/redis-connection.class';
-import { PicoLogger } from '@utils/pico-logger';
-
-export class OutgoingMessageRouter {
-    private readonly processId: TProcessId = readProcessId();
-    private readonly machineAddress: TMachineAddress = readMachineAddress();
-
-    private readonly redisConnection: RedisConnection = getMeshRedisConnection();
-
-    constructor(
-        private readonly passToLocalClientOrThrowUnknownClient: (
-            clientId: TClientId,
-            message: string,
-        ) => void,
-    ) {
-        console.log(
-            `Created MessageRouter on machine address: ${this.machineAddress}, process id: ${this.processId}`
-        );
-    }
-
-    /**
-     *
-     * @param address
-     * @param message
-     *
-     * @returns
-     */
-    public message(
-        address: TAddress,
-        message: string,
-    ): void {
-        const [machineAddress, processId, clientId] = splitAddressOrThrow(address);
-
-        // * Not on the same machine
-        if (machineAddress !== this.machineAddress) {
-            PicoLogger.log('🛣️ Routing message to machine', 'routing');
-
-            this.redisConnection.directPublish(address, message);
-
-            return;
-        }
-
-        // * On the same machine, but not on the same process
-        if (processId !== this.processId) {
-            PicoLogger.log(`🛣️  Routing message from process ID '${this.processId}' to process ID: '${processId}'`, 'routing');
-
-            // ! Route through Redis for now, but change to direct process connection
-            this.redisConnection.directPublish(address, message);
-
-            return;
-        }
-
-        // * On the same machine and process
-        PicoLogger.log('🛣️ Routing message to local client', 'routing');
-
-        this.passToLocalClientOrThrowUnknownClient(clientId, message);
-    }
-}

package/src/routing/process-message-router.class.ts

@@ -1,85 +0,0 @@
-/**
- * Route messages to the correct process if necessary.
- */
-import {
-    type TCallbackFunction,
-    type TMachineAddress,
-    type TProcessId,
-    type TProcessAddress,
-    splitProcessAddress,
-} from '@flux/shared/types';
-import {
-    type RedisConnection,
-    getMeshRedisConnection,
-} from './redis/redis-connection.class';
-import {
-    readMachineAddress,
-    readProcessAddress,
-    readProcessId,
-} from './addressing.utils';
-import { PicoLogger } from '@utils/pico-logger';
-
-export class ProcessMessageRouter {
-    private readonly machineAddress: TMachineAddress = readMachineAddress();
-    private readonly processAddress: TProcessAddress = readProcessAddress();
-    private readonly processId: TProcessId = readProcessId();
-    private readonly redisConnection: RedisConnection = getMeshRedisConnection();
-    private readonly localCallbacks: Set<TCallbackFunction> = new Set();
-
-    /**
-     * Sends a message to a process.
-     *
-     * @param { TProcessAddress }   address
-     * @param { string }            message
-     *
-     * @returns
-     */
-    public message(
-        address: TProcessAddress,
-        message: string,
-    ): void {
-        const [machineAddress, processId] = splitProcessAddress(address);
-
-        // * Not on the same machine
-        if (machineAddress !== this.machineAddress) {
-            PicoLogger.log('🛣️ Routing message to machine', 'routing');
-
-            this.redisConnection.directPublish(address, message);
-
-            return;
-        }
-
-        // * Not on the same process
-        if (processId !== this.processId) {
-            PicoLogger.log('🛣️ Routing message to process (todo; direct process)', 'routing');
-            // ! Route through Redis for now, but change to direct process connection
-            this.redisConnection.directPublish(address, message);
-
-            return;
-        }
-
-        // * This must be to local process
-        PicoLogger.log('🛣️ Routing message to local', 'routing');
-        for (const localCallback of this.localCallbacks) {
-            localCallback(message);
-        }
-    }
-
-    /**
-     * Subscribe to mesaages for local process.
-     *
-     * @param message
-     *
-     * @returns { void }
-     */
-    public subscribe(
-        onMessage: TCallbackFunction,
-    ): void {
-        console.log('🗒️ Subscribing process', this.processAddress);
-
-        this.localCallbacks.add(onMessage);
-
-        //  Listen to remote
-        this.redisConnection.subscribe(this.processAddress, onMessage);
-    }
-}

package/src/routing/redis/hash/network-agent.redis.sorted-set.ts

@@ -1,60 +0,0 @@
-import type { RedisClient } from 'bun';
-import type {
-    TAddress,
-    TClientId,
-    TMachineAddress,
-    TNetworkId_S,
-    TProcessId,
-} from '@flux/shared/types';
-import { readMachineAddress, readProcessId } from '../../addressing.utils';
-
-export class NetworkAgentRedisSortedSet {
-    private readonly processId: TProcessId = readProcessId();
-    private readonly machineAddress: TMachineAddress = readMachineAddress();
-
-    constructor(
-        private readonly client: RedisClient,
-    ) { }
-
-    /**
-     * Registers a network agent in the sorted set.
-     * 
-     * @param { TNetworkId_S } networkId
-     * @param { TClientId } socketId
-     * 
-     * @returns { Promise<void> }
-     */
-    public async registerAgent(
-        networkId: TNetworkId_S,
-        socketId: TClientId,
-    ): Promise<void> {
-        const address: TAddress = `${this.machineAddress}/${this.processId}/${socketId}`;
-
-        await this.client.send('ZADD', [
-            `networks/${networkId}/agents`, // Key
-            `${Date.now()}`, // Score
-            address, // Member
-        ]);
-    }
-
-    /**
-     * Unregisters a network agent from the sorted set.
-     * 
-     * @param { TNetworkId_S } networkId
-     * @param { TClientId } socketId
-     * 
-     * @returns { Promise<number> }
-     */
-    public async unregisterAgent(
-        networkId: TNetworkId_S,
-        socketId: TClientId
-    ): Promise<number> {
-        const address: TAddress = `${this.machineAddress}/${this.processId}/${socketId}`;
-
-        return await this.client.send('ZREM', [
-            `networks/${networkId}/agents`,
-            address, // Member
-        ]);
-    }
-
-}