7400583236

Committed 03 Jan 2024 05:41PM UTC coverage: 84.511% (-0.03%) from 84.541%

Build # 7400583236

Build Type

Pull #4594

github

Committed by

web-flow

Commit Message

Merge b340adcfc into 709a823d2

Pull Request Pull Request #4594: fix: BotState cache hash skipped properties

Run Details

9983 of 13089 branches covered (0.0%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 2 files covered. (100.0%)

90 existing lines in 7 files now uncovered.

20408 of 22872 relevant lines covered (89.23%)

7184.03 hits per line

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

84.31

/libraries/botframework-streaming/src/namedPipe/namedPipeTransport.ts

/**
 * @module botframework-streaming
 */
/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */
import { INodeBuffer, INodeSocket, ITransportSender, ITransportReceiver } from '../interfaces';

/**
 * Named pipes based transport sender and receiver abstraction
 */
export class NamedPipeTransport implements ITransportSender, ITransportReceiver {
    static readonly PipePath: string = '\\\\.\\pipe\\';
    static readonly ServerIncomingPath: string = '.incoming';
    static readonly ServerOutgoingPath: string = '.outgoing';

    private readonly _queue: INodeBuffer[];
    private _active: INodeBuffer;
    private _activeOffset = 0;
    private _activeReceiveCount = 0;
    private _activeReceiveResolve: (resolve: INodeBuffer) => void;
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    private _activeReceiveReject: (reason?: any) => void;

    /**
     * Creates a new instance of the [NamedPipeTransport](xref:botframework-streaming.NamedPipeTransport) class.
     *
     * @param socket The socket object to build this connection on.
     */
    constructor(private socket: INodeSocket) {
        this._queue = [];
        if (socket) {
            this.socket.on('data', (data): void => {
                this.socketReceive(data);
            });
            this.socket.on('close', (): void => {
                this.socketClose();
            });
            this.socket.on('error', (err): void => {
                this.socketError(err);
            });
        }
    }

    /**
     * Writes to the pipe and sends.
     *
     * @param buffer The buffer full of data to send out across the socket.
     * @returns A number indicating the length of the sent data if the data was successfully sent, otherwise 0.
     */
    send(buffer: INodeBuffer): number {
        if (this.socket && !this.socket.connecting && this.socket.writable) {
            this.socket.write(buffer);

            return buffer.length;
        }

        return 0;
    }

    /**
     * Returns `true` if currently connected.
     *
     * @returns `true` if the the transport is connected and ready to send data, `false` otherwise.
     */
    get isConnected(): boolean {
        return !(!this.socket || this.socket.destroyed || this.socket.connecting);
    }

    /**
     * Closes the transport.
     */
    close(): void {
        if (this.socket) {
            this.socket.end('end');
            this.socket = null;
        }
    }

    /**
     * Receive from the transport into the buffer.
     *
     * @param count The maximum amount of bytes to write to the buffer.
     * @returns The buffer containing the data from the transport.
     */
    receive(count: number): Promise<INodeBuffer> {
        if (this._activeReceiveResolve) {
            throw new Error('Cannot call receive more than once before it has returned.');
        }

        this._activeReceiveCount = count;

        const promise = new Promise<INodeBuffer>((resolve, reject): void => {
            this._activeReceiveResolve = resolve;
            this._activeReceiveReject = reject;
        });

        this.trySignalData();

        return promise;
    }

    private socketReceive(data: INodeBuffer): void {
        if (this._queue && data && data.length > 0) {
            this._queue.push(data);
            this.trySignalData();
        }
    }

    private socketClose(): void {
        if (this._activeReceiveReject) {
            this._activeReceiveReject(new Error('Socket was closed.'));
        }

        this._active = null;
        this._activeOffset = 0;
        this._activeReceiveResolve = null;
        this._activeReceiveReject = null;
        this._activeReceiveCount = 0;
        this.socket = null;
    }

    private socketError(err: Error): void {
        if (this._activeReceiveReject) {
            this._activeReceiveReject(err);
        }
        this.socketClose();
    }

    private trySignalData(): void {
        if (this._activeReceiveResolve) {
            if (!this._active && this._queue.length > 0) {
                this._active = this._queue.shift();
                this._activeOffset = 0;
            }

            if (this._active) {
                if (this._activeOffset === 0 && this._active.length === this._activeReceiveCount) {
                    // can send the entire _active buffer
                    const buffer = this._active;
                    this._active = null;

                    this._activeReceiveResolve(buffer);
                } else {
                    // create a new buffer and copy some of the contents into it
                    const available = Math.min(this._activeReceiveCount, this._active.length - this._activeOffset);
                    const buffer = Buffer.alloc(available);
                    this._active.copy(buffer, 0, this._activeOffset, this._activeOffset + available);
                    this._activeOffset += available;

                    // if we used all of active, set it to undefined
                    if (this._activeOffset >= this._active.length) {
                        this._active = null;
                        this._activeOffset = 0;
                    }

                    this._activeReceiveResolve(buffer);
                }

                this._activeReceiveCount = 0;
                this._activeReceiveReject = null;
                this._activeReceiveResolve = null;
            }
        }
    }
}

1	/**
2	* @module botframework-streaming
3	*/
4	/**
5	* Copyright (c) Microsoft Corporation. All rights reserved.
6	* Licensed under the MIT License.
7	*/
8	import { INodeBuffer, INodeSocket, ITransportSender, ITransportReceiver } from '../interfaces';
9
10	/**
11	* Named pipes based transport sender and receiver abstraction
12	*/
13	export class NamedPipeTransport implements ITransportSender, ITransportReceiver {	2✔
14	static readonly PipePath: string = '\\\\.\\pipe\\';	2✔
15	static readonly ServerIncomingPath: string = '.incoming';	2✔
16	static readonly ServerOutgoingPath: string = '.outgoing';	2✔
17
18	private readonly _queue: INodeBuffer[];
19	private _active: INodeBuffer;
UNCOV 20	private _activeOffset = 0;	13✔
UNCOV 21	private _activeReceiveCount = 0;	13✔
22	private _activeReceiveResolve: (resolve: INodeBuffer) => void;
23	// eslint-disable-next-line @typescript-eslint/no-explicit-any
24	private _activeReceiveReject: (reason?: any) => void;
25
26	/**
27	* Creates a new instance of the [NamedPipeTransport](xref:botframework-streaming.NamedPipeTransport) class.
28	*
29	* @param socket The socket object to build this connection on.
30	*/
UNCOV 31	constructor(private socket: INodeSocket) {	13✔
UNCOV 32	this._queue = [];	13✔
UNCOV 33	if (socket) {	13!
UNCOV 34	this.socket.on('data', (data): void => {	13✔
35	this.socketReceive(data);	×
36	});
UNCOV 37	this.socket.on('close', (): void => {	13✔
UNCOV 38	this.socketClose();	2✔
39	});
UNCOV 40	this.socket.on('error', (err): void => {	13✔
UNCOV 41	this.socketError(err);	2✔
42	});
43	}
44	}
45
46	/**
47	* Writes to the pipe and sends.
48	*
49	* @param buffer The buffer full of data to send out across the socket.
50	* @returns A number indicating the length of the sent data if the data was successfully sent, otherwise 0.
51	*/
52	send(buffer: INodeBuffer): number {
UNCOV 53	if (this.socket && !this.socket.connecting && this.socket.writable) {	3✔
UNCOV 54	this.socket.write(buffer);	1✔
55
UNCOV 56	return buffer.length;	1✔
57	}
58
UNCOV 59	return 0;	2✔
60	}
61
62	/**
63	* Returns `true` if currently connected.
64	*
65	* @returns `true` if the the transport is connected and ready to send data, `false` otherwise.
66	*/
67	get isConnected(): boolean {
UNCOV 68	return !(!this.socket \|\| this.socket.destroyed \|\| this.socket.connecting);	8✔
69	}
70
71	/**
72	* Closes the transport.
73	*/
74	close(): void {
UNCOV 75	if (this.socket) {	11✔
UNCOV 76	this.socket.end('end');	10✔
UNCOV 77	this.socket = null;	10✔
78	}
79	}
80
81	/**
82	* Receive from the transport into the buffer.
83	*
84	* @param count The maximum amount of bytes to write to the buffer.
85	* @returns The buffer containing the data from the transport.
86	*/
87	receive(count: number): Promise<INodeBuffer> {
UNCOV 88	if (this._activeReceiveResolve) {	2!
89	throw new Error('Cannot call receive more than once before it has returned.');	×
90	}
91
UNCOV 92	this._activeReceiveCount = count;	2✔
93
UNCOV 94	const promise = new Promise<INodeBuffer>((resolve, reject): void => {	2✔
UNCOV 95	this._activeReceiveResolve = resolve;	2✔
UNCOV 96	this._activeReceiveReject = reject;	2✔
97	});
98
UNCOV 99	this.trySignalData();	2✔
100
UNCOV 101	return promise;	2✔
102	}
103
104	private socketReceive(data: INodeBuffer): void {
UNCOV 105	if (this._queue && data && data.length > 0) {	2!
UNCOV 106	this._queue.push(data);	2✔
UNCOV 107	this.trySignalData();	2✔
108	}
109	}
110
111	private socketClose(): void {
UNCOV 112	if (this._activeReceiveReject) {	6✔
UNCOV 113	this._activeReceiveReject(new Error('Socket was closed.'));	1✔
114	}
115
UNCOV 116	this._active = null;	6✔
UNCOV 117	this._activeOffset = 0;	6✔
UNCOV 118	this._activeReceiveResolve = null;	6✔
UNCOV 119	this._activeReceiveReject = null;	6✔
UNCOV 120	this._activeReceiveCount = 0;	6✔
UNCOV 121	this.socket = null;	6✔
122	}
123
124	private socketError(err: Error): void {
UNCOV 125	if (this._activeReceiveReject) {	3✔
UNCOV 126	this._activeReceiveReject(err);	1✔
127	}
UNCOV 128	this.socketClose();	3✔
129	}
130
131	private trySignalData(): void {
UNCOV 132	if (this._activeReceiveResolve) {	4✔
UNCOV 133	if (!this._active && this._queue.length > 0) {	3✔
UNCOV 134	this._active = this._queue.shift();	1✔
UNCOV 135	this._activeOffset = 0;	1✔
136	}
137
UNCOV 138	if (this._active) {	3✔
UNCOV 139	if (this._activeOffset === 0 && this._active.length === this._activeReceiveCount) {	1!
140	// can send the entire _active buffer
UNCOV 141	const buffer = this._active;	1✔
UNCOV 142	this._active = null;	1✔
143
UNCOV 144	this._activeReceiveResolve(buffer);	1✔
145	} else {
146	// create a new buffer and copy some of the contents into it
147	const available = Math.min(this._activeReceiveCount, this._active.length - this._activeOffset);	×
148	const buffer = Buffer.alloc(available);	×
149	this._active.copy(buffer, 0, this._activeOffset, this._activeOffset + available);	×
150	this._activeOffset += available;	×
151
152	// if we used all of active, set it to undefined
153	if (this._activeOffset >= this._active.length) {	×
154	this._active = null;	×
155	this._activeOffset = 0;	×
156	}
157
158	this._activeReceiveResolve(buffer);	×
159	}
160
UNCOV 161	this._activeReceiveCount = 0;	1✔
UNCOV 162	this._activeReceiveReject = null;	1✔
UNCOV 163	this._activeReceiveResolve = null;	1✔
164	}
165	}
166	}
167	}

microsoft / botbuilder-js / 7400583236

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