@4players/odin-plugin-web 1.0.0-alpha.21 → 1.0.0-alpha.23

package/lib/plugin/medias/video-playback.d.ts

@@ -0,0 +1,13 @@
+import { Backend } from '@4players/odin-common';
+export declare class VideoPlayback implements Backend.VideoPlayback {
+    readonly uid: Backend.UID;
+    readonly customType?: string | undefined;
+    private _mediaStream?;
+    constructor(uid: Backend.UID, customType?: string | undefined);
+    /**
+     * Sets the MediaStream once.
+     */
+    setMediaStream(ms?: MediaStream): void;
+    get mediaStream(): MediaStream | undefined;
+    close(): void;
+}

package/lib/plugin/medias/video-playback.js

@@ -0,0 +1,20 @@
+export class VideoPlayback {
+    constructor(uid, customType) {
+        this.uid = uid;
+        this.customType = customType;
+    }
+    /**
+     * Sets the MediaStream once.
+     */
+    setMediaStream(ms) {
+        if (this._mediaStream)
+            return;
+        this._mediaStream = ms;
+    }
+    get mediaStream() {
+        return this._mediaStream;
+    }
+    close() {
+        throw new Error('Method not implemented.');
+    }
+}

package/lib/plugin/roomConnection.d.ts

@@ -0,0 +1,40 @@
+import { Backend, RoomCommands, Result, Infer } from '@4players/odin-common';
+import { ConnectionPool } from './connectionPool';
+import { MainConnection } from './mainConnection';
+import { Token } from './token';
+import Transport = Backend.Transport;
+export declare class RoomConnection implements RoomConnection {
+    readonly connectionPool: ConnectionPool;
+    readonly transport: Transport;
+    readonly onEvent: Backend.OnEvent;
+    readonly gateway: URL | undefined;
+    readonly roomId: string;
+    private _RoomConnection;
+    private _MainConnection;
+    private _OwnPeerId;
+    private readonly _Close;
+    private _Token;
+    private _UserData;
+    private _Position;
+    private _ConnectionFailures;
+    private _FailureLimit;
+    private _LastTokenRenew;
+    private readonly _Closed;
+    get token(): Token;
+    get userData(): Uint8Array;
+    get position(): [number, number, number];
+    get closed(): boolean;
+    get mainConnection(): MainConnection | undefined;
+    constructor(connectionPool: ConnectionPool, transport: Transport, onEvent: Backend.OnEvent, gateway: URL | undefined, token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]);
+    request(name: string, properties: unknown): Promise<Result<unknown> | 'closed'>;
+    typedRequest<Name extends Extract<keyof RoomCommands, string>>(name: Name, properties: Infer<RoomCommands[Name]['request']>): Promise<Result<Infer<RoomCommands[Name]['response']>> | 'closed'>;
+    close(): void;
+    get renewTokenIn(): number;
+    private _Main;
+    private _ConnectToServer;
+    private _ChangeStatus;
+    private _HandleConnection;
+    private _HandleEvent;
+    private _HandleRequests;
+    private _RenewToken;
+}

package/lib/plugin/roomConnection.js

@@ -0,0 +1,320 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Selector, failure, sleep, success, RoomCommandsRpc, RoomNotificationsRpc, } from '@4players/odin-common';
+import { Token } from './token';
+import { ConnectTimeout, logger, MinTokenLifetime, MinTokenRefreshInterval, } from './config';
+export class RoomConnection {
+    get token() {
+        return this._Token;
+    }
+    get userData() {
+        return this._UserData;
+    }
+    get position() {
+        return this._Position;
+    }
+    get closed() {
+        return this._Close.signal.aborted;
+    }
+    get mainConnection() {
+        return this._MainConnection;
+    }
+    constructor(connectionPool, transport, onEvent, gateway, token, roomId, userData, position) {
+        this.connectionPool = connectionPool;
+        this.transport = transport;
+        this.onEvent = onEvent;
+        this.gateway = gateway;
+        this.roomId = roomId;
+        this._Close = new AbortController();
+        this._ConnectionFailures = 0;
+        this._FailureLimit = 5;
+        this._LastTokenRenew = performance.now();
+        this._Closed = new Promise((accept) => this._Close.signal.addEventListener('abort', () => accept('closed'), {
+            once: true,
+        }));
+        this._Token = token;
+        this._UserData = userData;
+        this._Position = position;
+        this._Main().then(({ reason }) => logger.info(['Connection'], `RoomConnection: Main() resolved; ${reason}`));
+    }
+    request(name, properties) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._RoomConnection === undefined) {
+                return failure('currently not connected');
+            }
+            const response = yield this._RoomConnection.request(name, properties);
+            if (response !== 'closed' && response.type === 'Success') {
+                this._HandleRequests(name, properties, response.value);
+            }
+            return response;
+        });
+    }
+    typedRequest(name, properties) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schema = RoomCommandsRpc[name];
+            const response = yield this.request(name, properties);
+            if (response === 'closed' || response.type === 'Failure')
+                return response;
+            const parsed = schema.response.safeParse(response.value);
+            if (parsed.success)
+                return success(parsed.data);
+            else {
+                return failure(`received invalid response from ${name}; ${parsed.error}`);
+            }
+        });
+    }
+    close() {
+        this._Close.abort();
+    }
+    get renewTokenIn() {
+        const earliest = this._LastTokenRenew - performance.now() + MinTokenRefreshInterval;
+        const latest = this._Token.timeLeft - MinTokenLifetime;
+        return Math.max(earliest, latest);
+    }
+    _Main() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let closeReason = 'unable to establish connection';
+            /// as long as we are asked to continue
+            while (this._Close.signal.aborted === false) {
+                logger.debug(['Connection', 'RoomConnection._Main() loop']);
+                const result = yield this._ConnectToServer();
+                if (result.type === 'Failure') {
+                    closeReason = result.reason;
+                    break;
+                }
+                (_a = this._RoomConnection) === null || _a === void 0 ? void 0 : _a.close();
+                this._RoomConnection = undefined;
+                this._MainConnection = undefined;
+                this._OwnPeerId = undefined;
+                // can the token be used to request a better token from a gateway?
+                if (this.gateway !== undefined && this._Token.hasAudience('gateway')) {
+                    this._ChangeStatus('Joining', `requesting new token from ${this.gateway}`);
+                    const newToken = yield contactGateway(this.gateway, this._Token, this._Close.signal);
+                    if (newToken.type === 'Success') {
+                        if (newToken.value !== 'rejected') {
+                            // we got a better token, lets retry.
+                            this._Token = newToken.value;
+                            continue;
+                        }
+                        else {
+                            closeReason = 'invalid or expired token';
+                            break;
+                        }
+                    }
+                }
+                // we failed to get a connection, should we try again?
+                if (this._Token.timeLeft <= 0) {
+                    closeReason = 'unable to use expired token';
+                    break;
+                }
+                // slow retries down
+                yield sleep(1000);
+            }
+            this._ChangeStatus('Closed', this._Close.signal.aborted ? 'user requested' : closeReason);
+            this.close();
+            return failure(closeReason);
+        });
+    }
+    _ConnectToServer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // for now strip upstream wrappers in the token, because it not supported in web
+            let token = this._Token;
+            while (token.upstream !== undefined) {
+                token = token.upstream;
+            }
+            if (!token.hasAudience('sfu') || token.claims.adr === undefined) {
+                return success('continue');
+            }
+            this._ChangeStatus('Joining', `connecting to ${token.claims.adr}`);
+            // are we already connected to the server?
+            if (this._MainConnection === undefined ||
+                this._MainConnection.closed ||
+                this._MainConnection.address !== token.claims.adr) {
+                // no? release the not fitting connection
+                if (this._MainConnection) {
+                    this.connectionPool.releaseConnection(this._MainConnection);
+                }
+                // connect to the right server
+                const mainConnection = yield this.connectionPool.acquireConnection(this.transport, token.claims.adr, this._Close.signal);
+                if (mainConnection === 'closed')
+                    return failure('connection pool closed'); // connection pool is closed
+                if (mainConnection.type === 'Failure') {
+                    if (this._ConnectionFailures < this._FailureLimit) {
+                        this._ConnectionFailures++;
+                        return failure(`Connection failed; ${mainConnection.reason}`);
+                    }
+                    this._ChangeStatus('Joining', `connection failed; ${mainConnection.reason}`);
+                    return success('continue');
+                }
+                this._MainConnection = mainConnection.value;
+                this._OwnPeerId = undefined;
+            }
+            // join room
+            const result = yield Promise.race([
+                Promise.all([
+                    this._MainConnection.joinRoom(token, this.roomId, this.userData, this.position),
+                ]),
+                sleep(ConnectTimeout, 'timeout'),
+                this._Closed,
+            ]);
+            if (result === 'closed')
+                return failure('room connection closed'); // room connection was closed
+            if (result !== 'timeout') {
+                const [rpc] = result;
+                if (rpc === 'closed')
+                    return success('continue'); // connection was lost, before joinRoom finished
+                if (rpc.type === 'Failure') {
+                    // join was rejected by the server
+                    return failure(`unable to join room; ${rpc.reason}`);
+                }
+                // room connection is open, make it available
+                this._RoomConnection = rpc.value;
+                this._ChangeStatus('Joined', `joined ${this.roomId}`);
+                // TODO(sven): handle this
+                this._MainConnection
+                    .waitForConnected()
+                    .catch((error) => console.error('main connection failed to connect', error));
+                // Handle the open connection until it gets closed
+                yield this._HandleConnection(this._MainConnection);
+            }
+            // try to reconnect
+            return success('continue');
+        });
+    }
+    _ChangeStatus(status, message) {
+        const properties = {
+            status,
+            message,
+        };
+        this.onEvent('RoomStatusChanged', properties);
+    }
+    _HandleConnection(main) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this._RoomConnection === undefined)
+                return;
+            const selector = new Selector([
+                () => sleep(this.renewTokenIn, 'renewToken'),
+                () => sleep(500, 'tick'),
+                () => __awaiter(this, void 0, void 0, function* () { var _a; return yield ((_a = this._RoomConnection) === null || _a === void 0 ? void 0 : _a.recv()); }),
+                () => this._Closed,
+                () => main.closePromise,
+            ]);
+            while (true) {
+                const value = yield selector.next();
+                switch (value) {
+                    case undefined:
+                    case 'closed':
+                        logger.debug(['Connection'], 'RoomConnection._HandleConnection: closed');
+                        (_a = this._RoomConnection) === null || _a === void 0 ? void 0 : _a.close();
+                        this.connectionPool.releaseConnection(main);
+                        return;
+                    case 'renewToken':
+                        this._RenewToken();
+                        break;
+                    case 'tick':
+                        break;
+                    default:
+                        this._HandleEvent(value);
+                        break;
+                }
+            }
+        });
+    }
+    _HandleEvent(event) {
+        if (event.name === 'RoomUpdated') {
+            const roomUpdated = RoomNotificationsRpc.RoomUpdated.safeParse(event.properties);
+            if (!roomUpdated.success)
+                return;
+            for (const update of roomUpdated.data.updates) {
+                switch (update.kind) {
+                    case 'Joined':
+                        this._OwnPeerId = update.own_peer_id;
+                        break;
+                }
+            }
+        }
+        this.onEvent(event.name, event.properties);
+    }
+    _HandleRequests(name, properties, response) {
+        switch (name) {
+            case 'SetPeerPosition': {
+                const setPeerPosition = RoomCommandsRpc.SetPeerPosition.request.safeParse(properties);
+                if (setPeerPosition.success) {
+                    const value = setPeerPosition.data.position;
+                    this._Position = value.length === 2 ? [value[0], value[1], 0] : value;
+                }
+                else {
+                    console.warn('unable to process SetPeerPosition command');
+                }
+                break;
+            }
+            case 'UpdatePeer': {
+                const updatePeer = RoomCommandsRpc.UpdatePeer.request.safeParse(properties);
+                if (updatePeer.success) {
+                    this._UserData = updatePeer.data.user_data;
+                }
+                else {
+                    console.warn('unable to process UpdatePeer command');
+                }
+                break;
+            }
+        }
+    }
+    _RenewToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._LastTokenRenew = performance.now();
+            if (this.token.timeLeft > MinTokenLifetime)
+                return;
+            if (this._MainConnection === undefined || this._OwnPeerId === undefined) {
+                return failure('connection is not established');
+            }
+            const response = yield this._MainConnection.getReconnectToken(this._OwnPeerId);
+            if (response.type === 'Success') {
+                if (response.value.timeLeft > this._Token.timeLeft) {
+                    this._Token = response.value;
+                }
+                return success();
+            }
+            else {
+                return failure(`${this._MainConnection.address} rejected reconnect token request; ${response.reason}`);
+            }
+        });
+    }
+}
+function contactGateway(gateway, token, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            const response = yield fetch(gateway, {
+                body: '{"jsonrpc":"2.0","id":1,"method":"Connect","params":{}}',
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: `Bearer ${token}`,
+                },
+                signal,
+            });
+            // TODO: re-add validation once schemas are available in common
+            const body = yield response.json();
+            if ('result' in body) {
+                return Token.parse(body.result.token);
+            }
+            else {
+                console.error(`gateway rejected token; ${(_b = (_a = body.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'malformed response'}`);
+                return success('rejected');
+            }
+        }
+        catch (error) {
+            return failure(String(error));
+        }
+    });
+}

package/lib/plugin/rpcConnection.d.ts

@@ -0,0 +1,57 @@
+import { Result, Accept, MessagePackRpc, Notifications, Infer, Commands } from '@4players/odin-common';
+export interface RpcMessage {
+    name: string;
+    properties: unknown;
+}
+export interface RpcRequest {
+    accept: Accept<Result<unknown> | 'closed' | 'timeout'>;
+    timeoutId: ReturnType<typeof setTimeout> | undefined;
+}
+export declare class RpcConnection {
+    private readonly stream;
+    private readonly _SendQueue;
+    private readonly _RecvQueue;
+    private readonly _EventQueue;
+    private readonly _Requests;
+    private readonly _Close;
+    private readonly _Writer;
+    private _NextId;
+    get closed(): boolean;
+    get closeSignal(): AbortSignal;
+    constructor(stream: WebSocket | WebTransportBidirectionalStream);
+    request(name: string, properties: unknown): Promise<Result<unknown> | 'closed'>;
+    request(name: string, properties: unknown, timeout: number): Promise<Result<unknown> | 'closed' | 'timeout'>;
+    notify(name: string, properties: unknown): void;
+    recv(): Promise<RpcMessage | 'closed'>;
+    close(): void;
+    private _TimeoutRequest;
+    private _Send;
+    private _OnWebSocketOpen;
+    private _OnRpcMessage;
+    private _OnResponse;
+    private _OnEvent;
+    private _Cleanup;
+}
+export interface TypedRpcMessage<Name extends string, Properties> extends RpcMessage {
+    name: Name;
+    properties: Properties;
+}
+export type RealizedEvents<E extends Notifications> = {
+    [Name in Extract<keyof E, string>]: TypedRpcMessage<Name, Infer<E[Name]>>;
+}[Extract<keyof E, string>];
+export declare class TypedRpcConnection<C extends Commands, E extends Notifications> {
+    readonly rpcConnection: RpcConnection;
+    private readonly _Commands;
+    private readonly _Events;
+    get closed(): boolean;
+    get closeSignal(): AbortSignal;
+    constructor(rpcConnection: RpcConnection, _Commands: C, _Events: E);
+    request<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>): Promise<Result<Infer<C[Name]['response']>> | 'closed'>;
+    request<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>, timeout: number): Promise<Result<Infer<C[Name]['response']>> | 'closed' | 'timeout'>;
+    notify<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>): void;
+    recv(): Promise<RealizedEvents<E> | 'closed'>;
+    close(): void;
+}
+export declare function parseRpc(buffer: ArrayBuffer): Result<MessagePackRpc>;
+export declare function parseRpcMessage<E extends Notifications>(events: E, rpc: RpcMessage): RealizedEvents<E> | undefined;
+export declare function isKnownRpcMessage<E extends Notifications>(events: E, name: string): name is Extract<keyof E, string>;