@4players/odin-plugin-web 1.0.0-alpha.2 → 1.0.0-alpha.20

package/{backend/lib → lib/plugin}/roomConnection.d.ts

@@ -1,19 +1,23 @@
+import { Backend, RoomCommands, Result, Infer } from '@4players/odin-common';
 import { ConnectionPool } from './connectionPool';
 import { MainConnection } from './mainConnection';
 import { Token } from './token';
-import { Backend, RoomCommands, Result } from '@4players/odin-common';
-import * as z from 'zod';
-export declare class RoomConnection {
+import { Transport } from './index';
+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;
@@ -21,9 +25,9 @@ export declare class RoomConnection {
     get position(): [number, number, number];
     get closed(): boolean;
     get mainConnection(): MainConnection | undefined;
-    constructor(connectionPool: ConnectionPool, onEvent: Backend.OnEvent, gateway: URL | undefined, token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]);
+    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: z.infer<RoomCommands[Name]['request']>): Promise<Result<z.infer<RoomCommands[Name]['response']>> | '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;
@@ -34,4 +38,3 @@ export declare class RoomConnection {
     private _HandleRequests;
     private _RenewToken;
 }
-//# sourceMappingURL=roomConnection.d.ts.map

package/{backend/lib → lib/plugin}/roomConnection.js

@@ -7,11 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { RpcConnection } from './rpcConnection';
+import { Selector, failure, sleep, success, RoomCommandsRpc, RoomNotificationsRpc, } from '@4players/odin-common';
 import { Token } from './token';
-import { Selector, failure, sleep, success, RoomCommandsRpc, } from '@4players/odin-common';
-import * as z from 'zod';
-import { ConnectTimeout, MinTokenLifetime, MinTokenRefreshInterval, } from './config';
+import { ConnectTimeout, logger, MinTokenLifetime, MinTokenRefreshInterval, } from './config';
 export class RoomConnection {
     get token() {
         return this._Token;
@@ -28,12 +26,15 @@ export class RoomConnection {
     get mainConnection() {
         return this._MainConnection;
     }
-    constructor(connectionPool, onEvent, gateway, token, roomId, userData, position) {
+    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,
@@ -41,7 +42,7 @@ export class RoomConnection {
         this._Token = token;
         this._UserData = userData;
         this._Position = position;
-        this._Main().then(({ reason }) => console.debug(`room closed; ${reason}`));
+        this._Main().then(({ reason }) => logger.info(['Connection'], `RoomConnection: Main() resolved; ${reason}`));
     }
     request(name, properties) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -78,11 +79,12 @@ export class RoomConnection {
         return Math.max(earliest, latest);
     }
     _Main() {
-        var _a;
         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;
@@ -91,6 +93,7 @@ export class RoomConnection {
                 (_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}`);
@@ -122,32 +125,42 @@ export class RoomConnection {
     }
     _ConnectToServer() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this._Token.hasAudience('sfu') || this._Token.address === undefined) {
+            // 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 ${this._Token.address}`);
+            this._ChangeStatus('Joining', `connecting to ${token.claims.adr}`);
             // are we already connected to the server?
             if (this._MainConnection === undefined ||
                 this._MainConnection.closed ||
-                this._MainConnection.url !== this._Token.address) {
+                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._Token.address, this._Close.signal);
+                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(this._Token, this.roomId, this.userData, this.position),
+                    this._MainConnection.joinRoom(token, this.roomId, this.userData, this.position),
                 ]),
                 sleep(ConnectTimeout, 'timeout'),
                 this._Closed,
@@ -155,36 +168,37 @@ export class RoomConnection {
             if (result === 'closed')
                 return failure('room connection closed'); // room connection was closed
             if (result !== 'timeout') {
-                const [websocket] = result;
-                if (websocket === 'closed')
+                const [rpc] = result;
+                if (rpc === 'closed')
                     return success('continue'); // connection was lost, before joinRoom finished
-                if (websocket.type === 'Failure') {
+                if (rpc.type === 'Failure') {
                     // join was rejected by the server
-                    return failure(`unable to join room; ${websocket.reason}`);
+                    return failure(`unable to join room; ${rpc.reason}`);
                 }
                 // room connection is open, make it available
-                this._RoomConnection = new RpcConnection(websocket.value);
-                this._ChangeStatus('Joined', `joined room ${this.roomId} on ${websocket.value.url}`);
+                this._RoomConnection = rpc.value;
+                this._ChangeStatus('Joined', `joined ${this.roomId}`);
                 // TODO(sven): handle this
-                // await this._MainConnection.webRtcReady()
-                // process room events
-                yield this._HandleConnection(this._MainConnection, websocket.value);
+                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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const properties = {
-                status,
-                message,
-            };
-            this.onEvent('RoomStatusChanged', properties);
-        });
+        const properties = {
+            status,
+            message,
+        };
+        this.onEvent('RoomStatusChanged', properties);
     }
-    _HandleConnection(main, webSocket) {
+    _HandleConnection(main) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (this._RoomConnection === undefined)
                 return;
             const selector = new Selector([
@@ -199,10 +213,12 @@ export class RoomConnection {
                 switch (value) {
                     case undefined:
                     case 'closed':
-                        webSocket.close();
+                        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(main, webSocket);
+                        this._RenewToken();
                         break;
                     case 'tick':
                         break;
@@ -214,12 +230,23 @@ export class RoomConnection {
         });
     }
     _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':
-                // eslint-disable-next-line no-case-declarations
+            case 'SetPeerPosition': {
                 const setPeerPosition = RoomCommandsRpc.SetPeerPosition.request.safeParse(properties);
                 if (setPeerPosition.success) {
                     const value = setPeerPosition.data.position;
@@ -229,8 +256,8 @@ export class RoomConnection {
                     console.warn('unable to process SetPeerPosition command');
                 }
                 break;
-            case 'UpdatePeer':
-                // eslint-disable-next-line no-case-declarations
+            }
+            case 'UpdatePeer': {
                 const updatePeer = RoomCommandsRpc.UpdatePeer.request.safeParse(properties);
                 if (updatePeer.success) {
                     this._UserData = updatePeer.data.user_data;
@@ -239,27 +266,33 @@ export class RoomConnection {
                     console.warn('unable to process UpdatePeer command');
                 }
                 break;
+            }
         }
     }
-    _RenewToken(main, webSocket) {
+    _RenewToken() {
         return __awaiter(this, void 0, void 0, function* () {
             this._LastTokenRenew = performance.now();
             if (this.token.timeLeft > MinTokenLifetime)
                 return;
-            const response = yield main.getReconnectToken(webSocket);
+            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 {
-                console.warn(`${main.url} rejected reconnect token request; ${response.reason}`);
+                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":{}}',
@@ -270,24 +303,13 @@ function contactGateway(gateway, token, signal) {
                 },
                 signal,
             });
-            const schema = z.union([
-                z.object({
-                    result: z.object({
-                        token: z.string(),
-                    }),
-                }),
-                z.object({
-                    error: z.object({
-                        message: z.string(),
-                    }),
-                }),
-            ]);
-            const body = schema.parse(yield response.json());
+            // 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; ${body.error.message}`);
+                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');
             }
         }
@@ -296,4 +318,3 @@ function contactGateway(gateway, token, signal) {
         }
     });
 }
-//# sourceMappingURL=roomConnection.js.map

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>;