#12825

Committed 23 Jul 2024 12:31PM UTC coverage: 88.782% (+0.8%) from 87.936%

Build Type

push

Committed by

Commit Message

Merge 4c24a48e4 into 1755665fb

Run Details

6623 of 7923 branches covered (83.59%)

Branch coverage included in aggregate %.

1032 of 1161 new or added lines in 29 files covered. (88.89%)

24 existing lines in 5 files now uncovered.

9458 of 10190 relevant lines covered (92.82%)

1709.36 hits per line

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

98.57

/src/lsp/ActionQueue.ts

import type { CancellationToken } from 'vscode-languageserver-protocol';
import { CancellationTokenSource } from 'vscode-languageserver-protocol';
import { Deferred } from '../deferred';
import * as safeJsonStringify from 'safe-json-stringify';
import { EventEmitter } from 'eventemitter3';
import util from '../util';

export class ActionQueue {

    public constructor(
        options?: ActionQueueOptions
    ) {
        this.options = options ?? {} as any;
        this.options.maxActionDuration ??= 2_147_483_647;
    }

    public options: ActionQueueOptions;

    private queue: Array<{
        /**
         * An action to run
         */
        action: Action;
        /**
         * Data to be passed to the action
         */
        data: any;
        /**
         * A deferred to resolve when the action is complete.
         * @default Number.MAX_SAFE_INTEGER
         */
        deferred: Deferred<any>;
    }> = [];

    /**
     * Run an action. This will run after all previous actions have completed
     * @param action action to be run
     */
    public run<T = any>(action: Action<T>, data?: T) {
        const deferred = new Deferred();
        this.queue.push({
            action: action,
            data: data,
            deferred: deferred
        });
        void this.process();
        return deferred.promise;
    }

    private isRunning = false;

    /**
     * Process the next pending action. Safe to call even if another action is running, we will only run one action at a time
     */
    private async process() {
        if (this.isRunning) {
            return;
        }
        if (this.queue.length === 0) {
            this.emit('idle');
            return;
        }
        this.isRunning = true;

        //run the action and resolve the deferred if it succeeds
        const queueItem = this.queue.shift();
        const cancellationTokenSource = new CancellationTokenSource();

        //process the action next tick to allow the event loop to catch up
        let actionPromise = Promise.resolve().then(() => {
            return queueItem.action(queueItem.data, cancellationTokenSource.token);
        }).then((result) => {
            queueItem.deferred.resolve(result);
        });

        //register a timeout that will reject if the action takes too long
        let timeoutId: NodeJS.Timeout;
        const timeoutPromise = new Promise((resolve, reject) => {
            timeoutId = setTimeout(() => {
                cancellationTokenSource.cancel();
                reject(
                    new Error(`Action took longer than ${this.options.maxActionDuration}ms to complete. Data: ${this.stringifyJson(queueItem.data)}`)
                );
            }, this.options.maxActionDuration);
        });

        //wait for the action to finish or the timeout to trigger
        await Promise.race([timeoutPromise, actionPromise]).catch((error) => {
            //if we have an error, reject the deferred
            queueItem.deferred.tryReject(error);
        });

        clearTimeout(timeoutId);

        //small delay to allow the event loop to catch up
        await util.sleep(1);

        this.isRunning = false;

        //at this point, we've properly handled the action, so try and handle the next one
        await this.process();
    }

    private stringifyJson(data: any) {
        return safeJsonStringify(
            data,
            (_, value) => {
                return typeof value === 'bigint' ? value.toString() : value;
            }
        );
    }

    public get isIdle() {
        return this.queue.length === 0 && !this.isRunning;
    }

    /**
     * Get a promise that resolves when the queue is empty
     */
    public onIdle() {
        if (!this.isIdle) {
            return this.once('idle');
        }
        return Promise.resolve();
    }

    public once(eventname: 'idle'): Promise<void>;
    public once(eventName: string): Promise<void> {
        return new Promise<any>((resolve) => {
            const disconnect = this.on(eventName as Parameters<typeof this['on']>[0], (...args) => {
                disconnect();
                resolve(args);
            });
        });
    }

    public on(eventName: 'idle', handler: () => any);
    public on(eventName: string, handler: (payload: any) => any) {
        this.emitter.on(eventName, handler as any);
        return () => {
            this.emitter.removeListener(eventName, handler as any);
        };
    }

    private async emit(eventName: 'idle');
    private async emit(eventName: string, data?: any) {
        //emit these events on next tick, otherwise they will be processed immediately which could cause issues
        await util.sleep(0);
        this.emitter.emit(eventName, data);
    }
    private emitter = new EventEmitter();

    public dispose() {
        this.emitter.removeAllListeners();
    }
}

export type Action<T = any> = (data: T, cancellationToken?: CancellationToken) => any;

export interface ActionQueueOptions {
    /**
     * Max milliseconds an individual action may run before it's cancelled. This is the amount of time the action actually runs,
     * and does not count the time it waits in the queue
     */
    maxActionDuration: number;
}

1	import type { CancellationToken } from 'vscode-languageserver-protocol';
2	import { CancellationTokenSource } from 'vscode-languageserver-protocol';	1✔
3	import { Deferred } from '../deferred';	1✔
4	import * as safeJsonStringify from 'safe-json-stringify';	1✔
5	import { EventEmitter } from 'eventemitter3';	1✔
6	import util from '../util';	1✔
7
8	export class ActionQueue {	1✔
9
10	public constructor(
11	options?: ActionQueueOptions
12	) {
13	this.options = options ?? {} as any;	77✔
14	this.options.maxActionDuration ??= 2_147_483_647;	77✔
15	}
16
17	public options: ActionQueueOptions;
18
19	private queue: Array<{	77✔
20	/**
21	* An action to run
22	*/
23	action: Action;
24	/**
25	* Data to be passed to the action
26	*/
27	data: any;
28	/**
29	* A deferred to resolve when the action is complete.
30	* @default Number.MAX_SAFE_INTEGER
31	*/
32	deferred: Deferred<any>;
33	}> = [];
34
35	/**
36	* Run an action. This will run after all previous actions have completed
37	* @param action action to be run
38	*/
39	public run<T = any>(action: Action<T>, data?: T) {
40	const deferred = new Deferred();	68✔
41	this.queue.push({	68✔
42	action: action,
43	data: data,
44	deferred: deferred
45	});
46	void this.process();	68✔
47	return deferred.promise;	68✔
48	}
49
50	private isRunning = false;	77✔
51
52	/**
53	* Process the next pending action. Safe to call even if another action is running, we will only run one action at a time
54	*/
55	private async process() {
56	if (this.isRunning) {	136✔
57	return;	29✔
58	}
59	if (this.queue.length === 0) {	107✔
60	this.emit('idle');	39✔
61	return;	39✔
62	}
63	this.isRunning = true;	68✔
64
65	//run the action and resolve the deferred if it succeeds
66	const queueItem = this.queue.shift();	68✔
67	const cancellationTokenSource = new CancellationTokenSource();	68✔
68
69	//process the action next tick to allow the event loop to catch up
70	let actionPromise = Promise.resolve().then(() => {	68✔
71	return queueItem.action(queueItem.data, cancellationTokenSource.token);	68✔
72	}).then((result) => {
73	queueItem.deferred.resolve(result);	67✔
74	});
75
76	//register a timeout that will reject if the action takes too long
77	let timeoutId: NodeJS.Timeout;
78	const timeoutPromise = new Promise((resolve, reject) => {	68✔
79	timeoutId = setTimeout(() => {	68✔
80	cancellationTokenSource.cancel();	2✔
81	reject(	2✔
82	new Error(`Action took longer than ${this.options.maxActionDuration}ms to complete. Data: ${this.stringifyJson(queueItem.data)}`)
83	);
84	}, this.options.maxActionDuration);
85	});
86
87	//wait for the action to finish or the timeout to trigger
88	await Promise.race([timeoutPromise, actionPromise]).catch((error) => {	68✔
89	//if we have an error, reject the deferred
90	queueItem.deferred.tryReject(error);	3✔
91	});
92
93	clearTimeout(timeoutId);	68✔
94
95	//small delay to allow the event loop to catch up
96	await util.sleep(1);	68✔
97
98	this.isRunning = false;	68✔
99
100	//at this point, we've properly handled the action, so try and handle the next one
101	await this.process();	68✔
102	}
103
104	private stringifyJson(data: any) {
105	return safeJsonStringify(	2✔
106	data,
107	(_, value) => {
108	return typeof value === 'bigint' ? value.toString() : value;	2✔
109	}
110	);
111	}
112
113	public get isIdle() {
114	return this.queue.length === 0 && !this.isRunning;	91✔
115	}
116
117	/**
118	* Get a promise that resolves when the queue is empty
119	*/
120	public onIdle() {
121	if (!this.isIdle) {	11✔
122	return this.once('idle');	8✔
123	}
124	return Promise.resolve();	3✔
125	}
126
127	public once(eventname: 'idle'): Promise<void>;
128	public once(eventName: string): Promise<void> {
129	return new Promise<any>((resolve) => {	8✔
130	const disconnect = this.on(eventName as Parameters<typeof this['on']>[0], (...args) => {	8✔
131	disconnect();	8✔
132	resolve(args);	8✔
133	});
134	});
135	}
136
137	public on(eventName: 'idle', handler: () => any);
138	public on(eventName: string, handler: (payload: any) => any) {
139	this.emitter.on(eventName, handler as any);	8✔
140	return () => {	8✔
141	this.emitter.removeListener(eventName, handler as any);	8✔
142	};
143	}
144
145	private async emit(eventName: 'idle');
146	private async emit(eventName: string, data?: any) {
147	//emit these events on next tick, otherwise they will be processed immediately which could cause issues
148	await util.sleep(0);	39✔
149	this.emitter.emit(eventName, data);	39✔
150	}
151	private emitter = new EventEmitter();	77✔
152
153	public dispose() {
NEW 154	this.emitter.removeAllListeners();	×
155	}
156	}
157
158	export type Action<T = any> = (data: T, cancellationToken?: CancellationToken) => any;
159
160	export interface ActionQueueOptions {
161	/**
162	* Max milliseconds an individual action may run before it's cancelled. This is the amount of time the action actually runs,
163	* and does not count the time it waits in the queue
164	*/
165	maxActionDuration: number;
166	}

rokucommunity / brighterscript / #12825

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