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

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

@@ -8,55 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import * as msgpack from '@msgpack/msgpack';
-import { failure, success, isKnownRpcMessage, parseRpc, parseRpcMessage, abortableSleep, } from '@4players/odin-common';
-import { ConnectInterval } from './config';
-export function connect(url, signal) {
-    return __awaiter(this, void 0, void 0, function* () {
-        console.debug(`connecting to ${url}`);
-        const start = performance.now();
-        let connection = failure('no connection was attempted');
-        for (let failures = 0; failures < ConnectInterval.length && signal.aborted === false; failures++) {
-            const nextReconnectAt = start + whenToConnect(failures);
-            if ((yield abortableSleep(nextReconnectAt - performance.now(), signal)) ===
-                'aborted') {
-                return failure('aborted');
-            }
-            connection = yield connectOnce(url, signal);
-            if (connection.type === 'Success') {
-                return connection;
-            }
-        }
-        return connection;
-    });
-}
-export function connectOnce(url, signal) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let webSocket;
-        try {
-            webSocket = new WebSocket(url);
-        }
-        catch (reason) {
-            return failure(`unable to create websocket; ${reason}`);
-        }
-        const abort = new AbortController();
-        const onOpen = new Promise((accept) => webSocket.addEventListener('open', () => accept(success(webSocket)), {
-            signal: abort.signal,
-        }));
-        const onClose = new Promise((accept) => webSocket.addEventListener('close', (event) => accept(failure(event.reason)), { signal: abort.signal }));
-        const onAbort = new Promise((accept) => signal.addEventListener('abort', () => accept(failure('aborted')), {
-            signal: abort.signal,
-        }));
-        const result = yield Promise.race([onOpen, onClose, onAbort]);
-        abort.abort();
-        return result;
-    });
-}
-function whenToConnect(failures) {
-    const past_connects = ConnectInterval.slice(0, failures).reduce((a, b) => a + b, 0);
-    const interval = ConnectInterval[failures] * Math.random();
-    return past_connects + interval;
-}
+import { failure, success, msgpackEncode, msgpackDecode, MessagePackRpcSchema, } from '@4players/odin-common';
+import { getByteSize } from '../common/msgpack';
 export class RpcConnection {
     get closed() {
         return this._Close.signal.aborted;
@@ -64,17 +17,26 @@ export class RpcConnection {
     get closeSignal() {
         return this._Close.signal;
     }
-    constructor(webSocket) {
-        this.webSocket = webSocket;
+    constructor(stream) {
+        this.stream = stream;
         this._SendQueue = [];
         this._RecvQueue = [];
+        this._EventQueue = [];
         this._Requests = new Map();
         this._Close = new AbortController();
         this._NextId = 1;
-        this.webSocket.addEventListener('open', this._OnWebSocketOpen.bind(this));
-        this.webSocket.addEventListener('close', this.close.bind(this));
-        this.webSocket.addEventListener('message', this._OnWebSocketMessage.bind(this));
-        this.webSocket.binaryType = 'arraybuffer';
+        if (stream instanceof WebSocket) {
+            stream.addEventListener('open', this._OnWebSocketOpen.bind(this));
+            stream.addEventListener('close', this.close.bind(this));
+            stream.addEventListener('message', (event) => this._OnRpcMessage(event.data));
+            stream.binaryType = 'arraybuffer';
+        }
+        else {
+            readRpcFromStream(stream.readable.getReader(), this._OnRpcMessage.bind(this))
+                .catch(console.error)
+                .finally(this.close.bind(this));
+            this._Writer = stream.writable.getWriter();
+        }
         this._Close.signal.addEventListener('abort', this._Cleanup.bind(this), {
             once: true,
         });
@@ -96,16 +58,20 @@ export class RpcConnection {
         });
     }
     notify(name, properties) {
-        if (this.closed === false) {
+        if (!this.closed) {
             this._Send([2, name, properties]);
         }
     }
     recv() {
-        if (this.closed === false) {
-            return new Promise((accept) => this._RecvQueue.push(accept));
+        if (this.closed) {
+            return Promise.resolve('closed');
+        }
+        const event = this._EventQueue.shift();
+        if (event !== undefined) {
+            return Promise.resolve(event);
         }
         else {
-            return Promise.resolve('closed');
+            return new Promise((accept) => this._RecvQueue.push(accept));
         }
     }
     close() {
@@ -120,18 +86,26 @@ export class RpcConnection {
         request.accept('timeout');
     }
     _Send(message) {
-        this.webSocket.send(msgpack.encode(message));
+        const encoded = message instanceof Uint8Array
+            ? message
+            : new Uint8Array(msgpackEncode(message));
+        if (this.stream instanceof WebSocket) {
+            this.stream.send(encoded);
+        }
+        else {
+            this._Writer.write(encoded);
+        }
     }
     _OnWebSocketOpen(ev) {
-        for (const data in this._SendQueue) {
-            this.webSocket.send(data);
+        for (const data of this._SendQueue) {
+            this._Send(data);
         }
         this._SendQueue.length = 0;
     }
-    _OnWebSocketMessage(ev) {
-        const rpc = parseRpc(ev.data);
+    _OnRpcMessage(bytes) {
+        const rpc = parseRpc(bytes);
         if (rpc.type !== 'Success') {
-            this.webSocket.close();
+            this.close();
             return;
         }
         switch (rpc.value[0]) {
@@ -154,14 +128,16 @@ export class RpcConnection {
         request.accept(error === null ? success(result) : failure(error));
     }
     _OnEvent(name, properties) {
-        console.log('event', name, properties);
         const receiver = this._RecvQueue.shift();
         if (receiver !== undefined) {
             receiver({ name, properties });
         }
+        else {
+            this._EventQueue.push({ name, properties });
+        }
     }
     _Cleanup() {
-        console.log(`cleanup ${this.webSocket.url}`);
+        var _a;
         for (const request of this._Requests.values()) {
             clearTimeout(request.timeoutId);
             request.accept('closed');
@@ -172,24 +148,34 @@ export class RpcConnection {
         }
         this._RecvQueue.length = 0;
         this._SendQueue.length = 0;
-        this.webSocket.close();
+        if (this.stream instanceof WebSocket) {
+            this.stream.close();
+        }
+        else {
+            (_a = this._Writer) === null || _a === void 0 ? void 0 : _a.close().catch(() => {
+                /* drop silently */
+            });
+        }
     }
 }
-export class TypedRpcConnection extends RpcConnection {
-    constructor(webSocket, _Commands, _Events) {
-        super(webSocket);
+export class TypedRpcConnection {
+    get closed() {
+        return this.rpcConnection.closed;
+    }
+    get closeSignal() {
+        return this.rpcConnection.closeSignal;
+    }
+    constructor(rpcConnection, _Commands, _Events) {
+        this.rpcConnection = rpcConnection;
         this._Commands = _Commands;
         this._Events = _Events;
     }
     request(name, properties, timeout) {
-        const _super = Object.create(null, {
-            request: { get: () => super.request }
-        });
         return __awaiter(this, void 0, void 0, function* () {
             properties = this._Commands[name].request.parse(properties);
             const response = yield (timeout !== undefined
-                ? _super.request.call(this, name, properties, timeout)
-                : _super.request.call(this, name, properties));
+                ? this.rpcConnection.request(name, properties, timeout)
+                : this.rpcConnection.request(name, properties));
             if (response === 'closed' ||
                 response === 'timeout' ||
                 response.type === 'Failure') {
@@ -207,14 +193,11 @@ export class TypedRpcConnection extends RpcConnection {
     }
     notify(name, properties) {
         properties = this._Commands[name].request.parse(properties);
-        super.notify(name, properties);
+        this.rpcConnection.notify(name, properties);
     }
     recv() {
-        const _super = Object.create(null, {
-            recv: { get: () => super.recv }
-        });
         return __awaiter(this, void 0, void 0, function* () {
-            const event = yield _super.recv.call(this);
+            const event = yield this.rpcConnection.recv();
             if (event === 'closed')
                 return event;
             const parsed = parseRpcMessage(this._Events, event);
@@ -226,10 +209,73 @@ export class TypedRpcConnection extends RpcConnection {
             }
             else {
                 console.error(`schema validation for ${event.name} failed; closing connection`);
-                this.close();
+                this.rpcConnection.close();
             }
             return 'closed';
         });
     }
+    close() {
+        this.rpcConnection.close();
+    }
+}
+export function parseRpc(buffer) {
+    try {
+        return success(MessagePackRpcSchema.parse(msgpackDecode(buffer)));
+    }
+    catch (error) {
+        return failure(String(error));
+    }
+}
+export function parseRpcMessage(events, rpc) {
+    if (!isKnownRpcMessage(events, rpc.name))
+        return undefined;
+    const parsed = events[rpc.name].safeParse(rpc.properties);
+    if (!parsed.success) {
+        return undefined;
+    }
+    return {
+        name: rpc.name,
+        properties: parsed.data,
+    };
+}
+export function isKnownRpcMessage(events, name) {
+    return name in events;
+}
+function readRpcFromStream(reader, onRpc) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let buffer = new Uint8Array();
+        for (;;) {
+            let read;
+            try {
+                read = yield reader.read();
+            }
+            catch (error) {
+                break;
+            }
+            if (read.done)
+                break;
+            buffer = mergeBuffer(buffer, read.value);
+            let offset = 0;
+            for (let size;; offset += size) {
+                size = getByteSize(buffer, offset);
+                if (!size || offset + buffer.length < size)
+                    break;
+                onRpc(buffer.subarray(offset, offset + size));
+            }
+            buffer = buffer.subarray(offset);
+        }
+        if (buffer.length > 0) {
+            console.warn('unprocessed bytes left in rpc stream', buffer);
+        }
+    });
+}
+function mergeBuffer(a, b) {
+    if (a.length === 0)
+        return b;
+    if (b.length === 0)
+        return a;
+    const merged = new Uint8Array(a.length + b.length);
+    merged.set(a, 0);
+    merged.set(b, a.length);
+    return merged;
 }
-//# sourceMappingURL=rpcConnection.js.map

package/lib/plugin/token.d.ts

@@ -0,0 +1,13 @@
+import { TokenAudienceSchema, TokenClaims, Result, Infer } from '@4players/odin-common';
+export declare class Token {
+    readonly text: string;
+    readonly claims: TokenClaims;
+    static parse(token: string): Result<Token>;
+    private readonly _Upstream;
+    protected constructor(text: string, claims: TokenClaims);
+    get timeLeft(): number;
+    get upstream(): Token | undefined;
+    get defaultRoomId(): string | undefined;
+    hasAudience(audience: Infer<typeof TokenAudienceSchema>): boolean;
+    toString(): string;
+}

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

@@ -24,13 +24,13 @@ export class Token {
     constructor(text, claims) {
         this.text = text;
         this.claims = claims;
-        const address = claims.adr;
-        if (address !== undefined) {
-            try {
-                this._Address = new URL(`wss://${address}`);
+        if (claims.ups !== undefined) {
+            const upstream = Token.parse(claims.ups);
+            if (upstream.type === 'Success') {
+                this._Upstream = upstream.value;
             }
-            catch (error) {
-                console.error(`address in token(${address}) can not be parsed; ${error}`);
+            else {
+                console.error(`upstream in token can not be parsed; ${upstream.reason}`);
             }
         }
     }
@@ -39,8 +39,8 @@ export class Token {
             return Infinity;
         return this.claims.exp * 1000 - Date.now();
     }
-    get address() {
-        return this._Address;
+    get upstream() {
+        return this._Upstream;
     }
     get defaultRoomId() {
         if (Array.isArray(this.claims.rid)) {
@@ -64,4 +64,3 @@ export class Token {
         return this.text;
     }
 }
-//# sourceMappingURL=token.js.map

package/lib/plugin/webrtc/mainConnection.d.ts

@@ -0,0 +1,53 @@
+import { MainCommands, MainNotifications, Result } from '@4players/odin-common';
+import { type MainConnection, type DatagramHandler, ConnectionStatus } from '../mainConnection';
+import { Token } from '../token';
+import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
+import { Transport } from '../index';
+export declare class WebRtcMainConnection implements MainConnection {
+    readonly id: number;
+    readonly address: string;
+    readonly url: URL;
+    readonly onDatagram: DatagramHandler;
+    readonly connection: TypedRpcConnection<MainCommands, MainNotifications>;
+    readonly webRtc: RTCPeerConnection;
+    static create(id: number, address: string, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
+    private readonly _AudioChannel;
+    private readonly _PeerIdMap;
+    private _PeriodicHealthCheck;
+    private _WebRtcIceTimeout;
+    private _WebRtcTimeout;
+    private _ClosePromise;
+    private _LocalVideos;
+    private _RemoteVideos;
+    private _Negotiation;
+    private _ResolveOffer?;
+    private _awaitingRemoteTracks;
+    get transport(): Transport;
+    get closePromise(): Promise<"closed">;
+    get closeSignal(): AbortSignal;
+    get closed(): boolean;
+    get status(): ConnectionStatus;
+    waitForConnected(): Promise<void>;
+    private constructor();
+    close(): void;
+    joinRoom(token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]): Promise<Result<RpcConnection> | 'closed'>;
+    getReconnectToken(peerId: number): Promise<Result<Token>>;
+    sendDatagram(datagram: Uint8Array): void;
+    healthCheck(): Promise<boolean>;
+    private _Request;
+    private _readWebRtcUpdate;
+    private _SendOffer;
+    private _OnWebRtcStatusChanged;
+    private _OnWebRtcUpdate;
+    private _UpdateRemoteSdp;
+    private _AddIceCandidate;
+    private _OnIceCandidate;
+    private ensureTransceivers;
+    startLocalVideo(mediaId: number, track: MediaStreamTrack): Promise<void>;
+    stopLocalVideo(mediaId: number): void;
+    startRemoteVideo(mediaId: number): Promise<MediaStreamTrack>;
+    stopRemoteVideo(mediaId: number): void;
+    private onTrack;
+    requestNegotiation(waitForAnswer: boolean): void;
+    private _CleanUp;
+}