14082303413

Committed 26 Mar 2025 11:36AM UTC coverage: 84.47% (-0.05%) from 84.524%

Build # 14082303413

Build Type

push

github

Committed by

web-flow

Commit Message

Update elliptic, esbuild, and serialize-javascript (#4862)

Run Details

8260 of 10940 branches covered (75.5%)

Branch coverage included in aggregate %.

20572 of 23193 relevant lines covered (88.7%)

4032.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.22

/libraries/botframework-streaming/src/webSocket/webSocketServer.ts

/**
 * @module botframework-streaming
 */
/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */
import { ProtocolAdapter } from '../protocolAdapter';
import { RequestHandler } from '../requestHandler';
import { StreamingRequest } from '../streamingRequest';
import { RequestManager } from '../payloads';
import { PayloadReceiver, PayloadSender, TransportDisconnectedEvent } from '../payloadTransport';
import { WebSocketTransport } from './webSocketTransport';
import { ISocket, IStreamingTransportServer, IReceiveResponse } from '../interfaces';

/**
 * Web socket based server to be used as streaming transport.
 */
export class WebSocketServer implements IStreamingTransportServer {
    private readonly _url: string;
    private readonly _requestHandler: RequestHandler;
    private readonly _sender: PayloadSender;
    private readonly _receiver: PayloadReceiver;
    private readonly _requestManager: RequestManager;
    private readonly _protocolAdapter: ProtocolAdapter;
    private readonly _webSocketTransport: WebSocketTransport;
    private _closedSignal;
    private _socket: ISocket;

    /**
     * Creates a new instance of the [WebSocketServer](xref:botframework-streaming.WebSocketServer) class.
     *
     * @param socket The underlying web socket.
     * @param requestHandler Optional [RequestHandler](xref:botframework-streaming.RequestHandler) to process incoming messages received by this server.
     */
    constructor(socket: ISocket, requestHandler?: RequestHandler) {
        if (!socket) {
            throw new TypeError('WebSocketServer: Missing socket parameter');
        }

        this._socket = socket;
        this._webSocketTransport = new WebSocketTransport(socket);
        this._requestHandler = requestHandler;

        this._requestManager = new RequestManager();

        this._sender = new PayloadSender();
        this._sender.disconnected = this.onConnectionDisconnected.bind(this);
        this._receiver = new PayloadReceiver();
        this._receiver.disconnected = this.onConnectionDisconnected.bind(this);

        this._protocolAdapter = new ProtocolAdapter(
            this._requestHandler,
            this._requestManager,
            this._sender,
            this._receiver,
        );

        this._closedSignal = (x: string): string => {
            return x;
        };
    }

    /**
     * Examines the stored [ISocket](xref:botframework-streaming.ISocket) and returns `true` if the socket connection is open.
     *
     * @returns `true` if the underlying websocket is ready and availble to send messages, otherwise `false`.
     */
    get isConnected(): boolean {
        return this._socket.isConnected;
    }

    /**
     * Used to establish the connection used by this server and begin listening for incoming messages.
     *
     * @returns A promise to handle the server listen operation. This task will not resolve as long as the server is running.
     */
    async start(): Promise<string> {
        this._sender.connect(this._webSocketTransport);
        this._receiver.connect(this._webSocketTransport);

        return this._closedSignal;
    }

    /**
     * Task used to send data over this server connection.
     *
     * @param request The streaming request to send.
     * @returns A promise that will produce an instance of receive response on completion of the send operation.
     */
    async send(request: StreamingRequest): Promise<IReceiveResponse> {
        return this._protocolAdapter.sendRequest(request);
    }

    /**
     * Stop this server.
     */
    disconnect(): void {
        this._sender.disconnect(new TransportDisconnectedEvent('Disconnect was called.'));
        this._receiver.disconnect(new TransportDisconnectedEvent('Disconnect was called.'));
    }

    /**
     * @param sender The PayloadReceiver or PayloadSender that triggered or received a disconnect.
     * @param e TransportDisconnectedEvent
     */
    private onConnectionDisconnected(sender: PayloadReceiver | PayloadSender, e?: TransportDisconnectedEvent): void {
        if (this._closedSignal) {
            this._closedSignal('close');
            this._closedSignal = null;
        }

        if (sender === this._sender) {
            this._receiver.disconnect(e);
        }

        if (sender === this._receiver) {
            this._sender.disconnect(e);
        }
    }
}

1	/**
2	* @module botframework-streaming
3	*/
4	/**
5	* Copyright (c) Microsoft Corporation. All rights reserved.
6	* Licensed under the MIT License.
7	*/
8	import { ProtocolAdapter } from '../protocolAdapter';	1✔
9	import { RequestHandler } from '../requestHandler';
10	import { StreamingRequest } from '../streamingRequest';
11	import { RequestManager } from '../payloads';	1✔
12	import { PayloadReceiver, PayloadSender, TransportDisconnectedEvent } from '../payloadTransport';	1✔
13	import { WebSocketTransport } from './webSocketTransport';	1✔
14	import { ISocket, IStreamingTransportServer, IReceiveResponse } from '../interfaces';
15
16	/**
17	* Web socket based server to be used as streaming transport.
18	*/
19	export class WebSocketServer implements IStreamingTransportServer {	1✔
20	private readonly _url: string;
21	private readonly _requestHandler: RequestHandler;
22	private readonly _sender: PayloadSender;
23	private readonly _receiver: PayloadReceiver;
24	private readonly _requestManager: RequestManager;
25	private readonly _protocolAdapter: ProtocolAdapter;
26	private readonly _webSocketTransport: WebSocketTransport;
27	private _closedSignal;
28	private _socket: ISocket;
29
30	/**
31	* Creates a new instance of the [WebSocketServer](xref:botframework-streaming.WebSocketServer) class.
32	*
33	* @param socket The underlying web socket.
34	* @param requestHandler Optional [RequestHandler](xref:botframework-streaming.RequestHandler) to process incoming messages received by this server.
35	*/
36	constructor(socket: ISocket, requestHandler?: RequestHandler) {
37	if (!socket) {	19✔
38	throw new TypeError('WebSocketServer: Missing socket parameter');	1✔
39	}
40
41	this._socket = socket;	18✔
42	this._webSocketTransport = new WebSocketTransport(socket);	18✔
43	this._requestHandler = requestHandler;	18✔
44
45	this._requestManager = new RequestManager();	18✔
46
47	this._sender = new PayloadSender();	18✔
48	this._sender.disconnected = this.onConnectionDisconnected.bind(this);	18✔
49	this._receiver = new PayloadReceiver();	18✔
50	this._receiver.disconnected = this.onConnectionDisconnected.bind(this);	18✔
51
52	this._protocolAdapter = new ProtocolAdapter(	18✔
53	this._requestHandler,
54	this._requestManager,
55	this._sender,
56	this._receiver,
57	);
58
59	this._closedSignal = (x: string): string => {	18✔
60	return x;	18✔
61	};
62	}
63
64	/**
65	* Examines the stored [ISocket](xref:botframework-streaming.ISocket) and returns `true` if the socket connection is open.
66	*
67	* @returns `true` if the underlying websocket is ready and availble to send messages, otherwise `false`.
68	*/
69	get isConnected(): boolean {
70	return this._socket.isConnected;	×
71	}
72
73	/**
74	* Used to establish the connection used by this server and begin listening for incoming messages.
75	*
76	* @returns A promise to handle the server listen operation. This task will not resolve as long as the server is running.
77	*/
78	async start(): Promise<string> {
79	this._sender.connect(this._webSocketTransport);	18✔
80	this._receiver.connect(this._webSocketTransport);	18✔
81
82	return this._closedSignal;	18✔
83	}
84
85	/**
86	* Task used to send data over this server connection.
87	*
88	* @param request The streaming request to send.
89	* @returns A promise that will produce an instance of receive response on completion of the send operation.
90	*/
91	async send(request: StreamingRequest): Promise<IReceiveResponse> {
92	return this._protocolAdapter.sendRequest(request);	2✔
93	}
94
95	/**
96	* Stop this server.
97	*/
98	disconnect(): void {
99	this._sender.disconnect(new TransportDisconnectedEvent('Disconnect was called.'));	5✔
100	this._receiver.disconnect(new TransportDisconnectedEvent('Disconnect was called.'));	5✔
101	}
102
103	/**
104	* @param sender The PayloadReceiver or PayloadSender that triggered or received a disconnect.
105	* @param e TransportDisconnectedEvent
106	*/
107	private onConnectionDisconnected(sender: PayloadReceiver \| PayloadSender, e?: TransportDisconnectedEvent): void {
108	if (this._closedSignal) {	84,108✔
109	this._closedSignal('close');	18✔
110	this._closedSignal = null;	18✔
111	}
112
113	if (sender === this._sender) {	84,108✔
114	this._receiver.disconnect(e);	42,048✔
115	}
116
117	if (sender === this._receiver) {	84,081✔
118	this._sender.disconnect(e);	42,060✔
119	}
120	}
121	}

microsoft / botbuilder-js / 14082303413

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous