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

package/lib/plugin/roomConnection.js

@@ -1,320 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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>;

package/lib/plugin/rpcConnection.js

@@ -1,281 +0,0 @@
-/* eslint-disable no-dupe-class-members */
-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 { failure, success, msgpackEncode, msgpackDecode, MessagePackRpcSchema, } from '@4players/odin-common';
-import { getByteSize } from '../common/msgpack';
-export class RpcConnection {
-    get closed() {
-        return this._Close.signal.aborted;
-    }
-    get closeSignal() {
-        return this._Close.signal;
-    }
-    constructor(stream) {
-        this.stream = stream;
-        this._SendQueue = [];
-        this._RecvQueue = [];
-        this._EventQueue = [];
-        this._Requests = new Map();
-        this._Close = new AbortController();
-        this._NextId = 1;
-        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,
-        });
-    }
-    request(name, properties, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closed) {
-                return Promise.resolve('closed');
-            }
-            const id = this._NextId;
-            const timeoutId = timeout === undefined
-                ? undefined
-                : setTimeout(() => this._TimeoutRequest(id), timeout);
-            this._Send([0, id, name, properties]);
-            return new Promise((accept) => {
-                this._Requests.set(id, { accept, timeoutId });
-                this._NextId += 1;
-            });
-        });
-    }
-    notify(name, properties) {
-        if (!this.closed) {
-            this._Send([2, name, properties]);
-        }
-    }
-    recv() {
-        if (this.closed) {
-            return Promise.resolve('closed');
-        }
-        const event = this._EventQueue.shift();
-        if (event !== undefined) {
-            return Promise.resolve(event);
-        }
-        else {
-            return new Promise((accept) => this._RecvQueue.push(accept));
-        }
-    }
-    close() {
-        this._Close.abort();
-    }
-    _TimeoutRequest(requestId) {
-        const request = this._Requests.get(requestId);
-        if (request === undefined)
-            return;
-        this._Requests.delete(requestId);
-        clearTimeout(request.timeoutId);
-        request.accept('timeout');
-    }
-    _Send(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 of this._SendQueue) {
-            this._Send(data);
-        }
-        this._SendQueue.length = 0;
-    }
-    _OnRpcMessage(bytes) {
-        const rpc = parseRpc(bytes);
-        if (rpc.type !== 'Success') {
-            this.close();
-            return;
-        }
-        switch (rpc.value[0]) {
-            case 0:
-                this._Send([1, rpc.value[1], 'not supported', undefined]);
-                break;
-            case 1:
-                this._OnResponse(rpc.value[1], rpc.value[2], rpc.value[3]);
-                break;
-            case 2:
-                this._OnEvent(rpc.value[1], rpc.value[2]);
-                break;
-        }
-    }
-    _OnResponse(id, error, result) {
-        const request = this._Requests.get(id);
-        if (request === undefined)
-            return;
-        clearTimeout(request.timeoutId);
-        request.accept(error === null ? success(result) : failure(error));
-    }
-    _OnEvent(name, properties) {
-        const receiver = this._RecvQueue.shift();
-        if (receiver !== undefined) {
-            receiver({ name, properties });
-        }
-        else {
-            this._EventQueue.push({ name, properties });
-        }
-    }
-    _Cleanup() {
-        var _a;
-        for (const request of this._Requests.values()) {
-            clearTimeout(request.timeoutId);
-            request.accept('closed');
-        }
-        this._Requests.clear();
-        for (const accept of this._RecvQueue) {
-            accept('closed');
-        }
-        this._RecvQueue.length = 0;
-        this._SendQueue.length = 0;
-        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 {
-    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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            properties = this._Commands[name].request.parse(properties);
-            const response = yield (timeout !== undefined
-                ? this.rpcConnection.request(name, properties, timeout)
-                : this.rpcConnection.request(name, properties));
-            if (response === 'closed' ||
-                response === 'timeout' ||
-                response.type === 'Failure') {
-                return response;
-            }
-            const parsed = this._Commands[name].response.safeParse(response.value);
-            if (parsed.success) {
-                response.value = parsed.data;
-                return response;
-            }
-            else {
-                return failure(`response schema failed validation: ${parsed.error}`);
-            }
-        });
-    }
-    notify(name, properties) {
-        properties = this._Commands[name].request.parse(properties);
-        this.rpcConnection.notify(name, properties);
-    }
-    recv() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const event = yield this.rpcConnection.recv();
-            if (event === 'closed')
-                return event;
-            const parsed = parseRpcMessage(this._Events, event);
-            if (parsed !== undefined) {
-                return parsed;
-            }
-            if (!isKnownRpcMessage(this._Events, event.name)) {
-                console.warn(`dropping unknown event ${event.name}`);
-            }
-            else {
-                console.error(`schema validation for ${event.name} failed; closing connection`);
-                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;
-}

package/lib/plugin/token.d.ts

@@ -1,13 +0,0 @@
-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;
-}