10939316335

Committed 19 Sep 2024 10:37AM UTC coverage: 31.864% (+0.02%) from 31.848%

Build # 10939316335

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9767 from ForumMagnum/master

[EA] Deploy fixed for typo, LW changes

Run Details

5077 of 41359 branches covered (12.28%)

Branch coverage included in aggregate %.

46 of 105 new or added lines in 24 files covered. (43.81%)

15 existing lines in 10 files now uncovered.

29442 of 66974 relevant lines covered (43.96%)

184.73 hits per line

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

82.08

/packages/lesswrong/server/utils/callbackHooks.ts

import { isServer } from '@/lib/executionEnvironment';
import { isPromise } from '@/lib/vulcan-lib/utils';
import { loggerConstructor } from '@/lib/utils/logging'

export interface CallbackPropertiesBase<N extends CollectionNameString> {
  // TODO: Many of these are empirically optional, but setting them to optional
  // causes a bajillion type errors, so we will not be fixing today
  currentUser: DbUser|null
  collection: CollectionBase<N>
  context: ResolverContext
  schema: SchemaType<N>
}

export class CallbackChainHook<IteratorType,ArgumentsType extends any[]> {
  name: string
  
  constructor(name: string) {
    this.name = name;
  }
  
  add = (fn: (doc: IteratorType, ...args: ArgumentsType) =>
    (Promise<IteratorType|Partial<IteratorType>> | IteratorType | undefined | void)
  ) => {
    addCallback(this.name, fn);
  }
  
  runCallbacks = async ({iterator, properties, ignoreExceptions}: {iterator: IteratorType, properties: ArgumentsType, ignoreExceptions?: boolean}): Promise<IteratorType> => {
    const start = Date.now();

    const result = await runCallbacks({
      name: this.name,
      iterator, properties, ignoreExceptions
    });

    const timeElapsed = Date.now() - start;
    // Need to use this from Globals to avoid import cycles
    // Temporarily disabled to investigate performance issues
    // Globals.captureEvent('callbacksCompleted', {
    //   callbackHookName: this.name,
    //   timeElapsed
    // }, true);

    return result;
  }
}

export class CallbackHook<ArgumentsType extends any[]> {
  name: string
  
  constructor(name: string) {
    this.name = name;
  }
  
  add = (fn: (...args: ArgumentsType) => void|Promise<void>) => {
    addCallback(this.name, fn);
  }
  
  runCallbacksAsync = async (properties: ArgumentsType): Promise<void> => {
    const start = Date.now();

    await runCallbacksAsync({
      name: this.name,
      properties
    });

    const timeElapsed = Date.now() - start;
    // Need to use this from Globals to avoid import cycles
    // Temporarily disabled to investigate performance issues 
    // Globals.captureEvent('callbacksCompleted', {
    //   callbackHookName: this.name,
    //   timeElapsed
    // }, true);
  }
}

/**
 * @summary Callback hooks provide an easy way to add extra steps to common operations.
 * @namespace Callbacks
 */
const Callbacks: Record<string,any> = {};

/**
 * @summary Add a callback function to a hook
 * @param {String} hook - The name of the hook
 * @param {Function} callback - The callback function
 */
const addCallback = function (hookName: string, callback: AnyBecauseTodo) {
  // if callback array doesn't exist yet, initialize it
  if (typeof Callbacks[hookName] === 'undefined') {
    Callbacks[hookName] = [];
  }

  Callbacks[hookName].push(callback);
  
  if (Callbacks[hookName].length > 20) {
    // eslint-disable-next-line no-console
    console.log(`Warning: Excessively many callbacks (${Callbacks[hookName].length}) on hook ${hookName}.`);
  }
  
  return callback;
};

/**
 * @summary Successively run all of a hook's callbacks on an item
 * @param {String} hook - First argument: the name of the hook, or an array
 * @param {Object} item - Second argument: the post, comment, modifier, etc. on which to run the callbacks
 * @param {Any} args - Other arguments will be passed to each successive iteration
 * @param {Array} callbacks - Optionally, pass an array of callback functions instead of passing a hook name
 * @param {Boolean} ignoreExceptions - Only available as a named argument, default true. If true, exceptions
 *   thrown from callbacks will be logged but otherwise ignored. If false, exceptions thrown from callbacks
 *   will be rethrown.
 * @returns {Object} Returns the item after it's been through all the callbacks for this hook
 */
const runCallbacks = function <N extends CollectionNameString> (this: any, options: {
  name: string,
  iterator?: any,
  // A bit of a mess. If you stick to non-deprecated hooks, you'll get the typed version
  properties: [CallbackPropertiesBase<N>]|any[],
  ignoreExceptions?: boolean,
}) {
  const logger = loggerConstructor(`callbacks-${options.properties[0]?.collection?.collectionName.toLowerCase()}`)
  const hook = options.name;
  const item = options.iterator;
  const args = options.properties;
  let ignoreExceptions: boolean;
  if ("ignoreExceptions" in options)
    ignoreExceptions = !!options.ignoreExceptions;
  else
    ignoreExceptions = true;
  const callbacks = Callbacks[hook];

  // flag used to detect the callback that initiated the async context
  let asyncContext = false;
  
  let inProgressCallbackKey = markCallbackStarted(hook);
  
  try {
    if (typeof callbacks !== 'undefined' && !!callbacks.length) { // if the hook exists, and contains callbacks to run
      const runCallback = (accumulator: AnyBecauseTodo, callback: AnyBecauseTodo) => {
        logger(`\x1b[32m[${hook}] [${callback.name || 'noname callback'}]\x1b[0m`);
        try {
          const result = callback.apply(this, [accumulator].concat(args));
  
          if (typeof result === 'undefined') {
            // if result of current iteration is undefined, don't pass it on
            // logger(`// Warning: Sync callback [${callback.name}] in hook [${hook}] didn't return a result!`)
            return accumulator;
          } else {
            return result;
          }
  
        } catch (error) {
          // eslint-disable-next-line no-console
          console.log(`\x1b[31m// error at callback [${callback.name}] in hook [${hook}]\x1b[0m`);
          // eslint-disable-next-line no-console
          console.log(error);
          if (error.break || (error.data && error.data.break) || !ignoreExceptions) {
            throw error;
          }
          // pass the unchanged accumulator to the next iteration of the loop
          return accumulator;
        }
      };
  
      const result = callbacks.reduce(function (accumulator: AnyBecauseTodo, callback: AnyBecauseTodo, index: AnyBecauseTodo) {
        if (isPromise(accumulator)) {
          if (!asyncContext) {
            logger(`\x1b[32m[${hook}] Started async context for [${callbacks[index-1] && callbacks[index-1].name}]\x1b[0m`);
            asyncContext = true;
          }
          return new Promise((resolve, reject) => {
            accumulator
              .then(result => {
                if (result === undefined) {
                  // eslint-disable-next-line no-console
                  console.error('Async before callbacks should not return undefined. Please return the document/data instead')
                }
                try {
                  // run this callback once we have the previous value
                  resolve(runCallback(result, callback));
                } catch (error) {
                  // error will be thrown only for breaking errors, so throw it up in the promise chain
                  reject(error);
                }
              })
              .catch(reject);
          });
        } else {
          return runCallback(accumulator, callback);
        }
      }, item);
      
      return result;
    } else { // else, just return the item unchanged
      return item;
    }
  } finally {
    markCallbackFinished(inProgressCallbackKey, hook);
  }
};

/**
 * @summary Successively run all of a hook's callbacks on an item, in async mode (only works on server)
 * @param {String} hook - First argument: the name of the hook
 * @param {Any} args - Other arguments will be passed to each successive iteration
 */
const runCallbacksAsync = function <N extends CollectionNameString> (options: {
  name: string,
  // A bit of a mess. If you stick to non-deprecated hooks, you'll get the typed version
  properties: [CallbackPropertiesBase<N>]|any[]
}) {
  const logger = loggerConstructor(`callbacks-${options.properties[0]?.collection?.collectionName.toLowerCase()}`)
  const hook = options.name;
  const args = options.properties;

  const callbacks = Callbacks[hook];

  if (isServer && typeof callbacks !== 'undefined' && !!callbacks.length) {
    let pendingDeferredCallbackStart = markCallbackStarted(hook);

    // use defer to avoid holding up client
    setTimeout(function () {
      // run all post submit server callbacks on post object successively
      callbacks.forEach(function (this: any, callback: AnyBecauseTodo) {
        logger(`\x1b[32m[${hook}]: [${callback.name || 'noname callback'}]\x1b[0m`);
        
        let pendingAsyncCallback = markCallbackStarted(hook);
        try {
          let callbackResult = callback.apply(this, args);
          if (isPromise(callbackResult)) {
            callbackResult
              .then(
                result => markCallbackFinished(pendingAsyncCallback, hook),
                exception => {
                  markCallbackFinished(pendingAsyncCallback, hook)
                  // eslint-disable-next-line no-console
                  console.log(`Error running async callback [${callback.name}] on hook [${hook}]`);
                  // eslint-disable-next-line no-console
                  console.log(exception);
                  throw exception;
                }
              )
          } else {
            markCallbackFinished(pendingAsyncCallback, hook);
          }
        } finally {
          markCallbackFinished(pendingAsyncCallback, hook);
        }
      });
      
      markCallbackFinished(pendingDeferredCallbackStart, hook);
    }, 0);

  }
};

// Dictionary of all outstanding callbacks (key is an ID, value is `true`). If
// there are no outstanding callbacks, this should be an empty dictionary.
let pendingCallbackKeys: Partial<Record<string,true>> = {};

let pendingCallbackDescriptions: Record<string,number> = {};

// ID for a pending callback. Incremements with each call to
// `markCallbackStarted`.
let pendingCallbackKey = 0;

// Count of the number of outstanding callbacks. Used to check that this isn't
// leaking.
let numCallbacksPending = 0;

// When starting an async callback, assign it an ID, record the fact that it's
// running, and return the ID.
function markCallbackStarted(description: string): number
{
  if (numCallbacksPending > 1000) {
    // eslint-disable-next-line no-console
    console.log(`Warning: Excessively many background callbacks running (numCallbacksPending=${numCallbacksPending}) while trying to add callback ${description}`);
  }
  numCallbacksPending++;
  
  if (pendingCallbackKey >= Number.MAX_SAFE_INTEGER)
    pendingCallbackKey = 0;
  else
    pendingCallbackKey++;
  pendingCallbackKeys[pendingCallbackKey] = true;
  
  if (description in pendingCallbackDescriptions) {
    pendingCallbackDescriptions[description]++;
  } else {
    pendingCallbackDescriptions[description] = 1;
  }
  
  return pendingCallbackKey;
}

// Record the fact that an async callback with the given ID has finished.
function markCallbackFinished(id: number, description: string)
{
  numCallbacksPending--;
  delete pendingCallbackKeys[id];
  
  if (!pendingCallbackDescriptions[description] || pendingCallbackDescriptions[description]===1) {
    delete pendingCallbackDescriptions[description];
  } else {
    pendingCallbackDescriptions[description]--;
  }
}

// Return whether there is at least one async callback running.
export const callbacksArePending = (): boolean => {
  for(let _ in pendingCallbackKeys) {
    return true;
  }
  return false;
}

export function printInProgressCallbacks() {
  const callbacksInProgress = Object.keys(pendingCallbackDescriptions);
  // eslint-disable-next-line no-console
  console.log(`Callbacks in progress: ${callbacksInProgress.map(c => pendingCallbackDescriptions[c]!==1 ? `${c}(${pendingCallbackDescriptions[c]})` : c).join(", ")}`);
}

1	import { isServer } from '@/lib/executionEnvironment';	13,034✔
2	import { isPromise } from '@/lib/vulcan-lib/utils';	21✔
3	import { loggerConstructor } from '@/lib/utils/logging'	21✔
4
5	export interface CallbackPropertiesBase<N extends CollectionNameString> {
6	// TODO: Many of these are empirically optional, but setting them to optional
7	// causes a bajillion type errors, so we will not be fixing today
8	currentUser: DbUser\|null
9	collection: CollectionBase<N>
10	context: ResolverContext
11	schema: SchemaType<N>
12	}
13
14	export class CallbackChainHook<IteratorType,ArgumentsType extends any[]> {
15	name: string
16
17	constructor(name: string) {
18	this.name = name;	9,481✔
19	}
20
21	add = (fn: (doc: IteratorType, ...args: ArgumentsType) =>	9,481✔
22	(Promise<IteratorType\|Partial<IteratorType>> \| IteratorType \| undefined \| void)
23	) => {
24	addCallback(this.name, fn);	4,568✔
25	}
26
27	runCallbacks = async ({iterator, properties, ignoreExceptions}: {iterator: IteratorType, properties: ArgumentsType, ignoreExceptions?: boolean}): Promise<IteratorType> => {	9,481✔
28	const start = Date.now();	3,426✔
29
30	const result = await runCallbacks({	3,426✔
31	name: this.name,
32	iterator, properties, ignoreExceptions
33	});
34
35	const timeElapsed = Date.now() - start;	3,424✔
36	// Need to use this from Globals to avoid import cycles
37	// Temporarily disabled to investigate performance issues
38	// Globals.captureEvent('callbacksCompleted', {
39	// callbackHookName: this.name,
40	// timeElapsed
41	// }, true);
42
43	return result;	3,424✔
44	}
45	}
46
47	export class CallbackHook<ArgumentsType extends any[]> {
48	name: string
49
50	constructor(name: string) {
51	this.name = name;	3,013✔
52	}
53
54	add = (fn: (...args: ArgumentsType) => void\|Promise<void>) => {	3,013✔
55	addCallback(this.name, fn);	2,931✔
56	}
57
58	runCallbacksAsync = async (properties: ArgumentsType): Promise<void> => {	3,013✔
59	const start = Date.now();	1,479✔
60
61	await runCallbacksAsync({	1,479✔
62	name: this.name,
63	properties
64	});
65
66	const timeElapsed = Date.now() - start;	1,479✔
67	// Need to use this from Globals to avoid import cycles
68	// Temporarily disabled to investigate performance issues
69	// Globals.captureEvent('callbacksCompleted', {
70	// callbackHookName: this.name,
71	// timeElapsed
72	// }, true);
73	}
74	}
75
76	/**
77	* @summary Callback hooks provide an easy way to add extra steps to common operations.
78	* @namespace Callbacks
79	*/
80	const Callbacks: Record<string,any> = {};	21✔
81
82	/**
83	* @summary Add a callback function to a hook
84	* @param {String} hook - The name of the hook
85	* @param {Function} callback - The callback function
86	*/
87	const addCallback = function (hookName: string, callback: AnyBecauseTodo) {	21✔
88	// if callback array doesn't exist yet, initialize it
89	if (typeof Callbacks[hookName] === 'undefined') {	7,499✔
90	Callbacks[hookName] = [];	2,839✔
91	}
92
93	Callbacks[hookName].push(callback);	7,499✔
94
95	if (Callbacks[hookName].length > 20) {	7,499!
96	// eslint-disable-next-line no-console
97	console.log(`Warning: Excessively many callbacks (${Callbacks[hookName].length}) on hook ${hookName}.`);	×
98	}
99
100	return callback;	7,499✔
101	};
102
103	/**
104	* @summary Successively run all of a hook's callbacks on an item
105	* @param {String} hook - First argument: the name of the hook, or an array
106	* @param {Object} item - Second argument: the post, comment, modifier, etc. on which to run the callbacks
107	* @param {Any} args - Other arguments will be passed to each successive iteration
108	* @param {Array} callbacks - Optionally, pass an array of callback functions instead of passing a hook name
109	* @param {Boolean} ignoreExceptions - Only available as a named argument, default true. If true, exceptions
110	* thrown from callbacks will be logged but otherwise ignored. If false, exceptions thrown from callbacks
111	* will be rethrown.
112	* @returns {Object} Returns the item after it's been through all the callbacks for this hook
113	*/
114	const runCallbacks = function <N extends CollectionNameString> (this: any, options: {	21✔
115	name: string,
116	iterator?: any,
117	// A bit of a mess. If you stick to non-deprecated hooks, you'll get the typed version
118	properties: [CallbackPropertiesBase<N>]\|any[],
119	ignoreExceptions?: boolean,
120	}) {
121	const logger = loggerConstructor(`callbacks-${options.properties[0]?.collection?.collectionName.toLowerCase()}`)	3,426✔
122	const hook = options.name;	3,426✔
123	const item = options.iterator;	3,426✔
124	const args = options.properties;	3,426✔
125	let ignoreExceptions: boolean;
126	if ("ignoreExceptions" in options)	3,426!
127	ignoreExceptions = !!options.ignoreExceptions;	3,426✔
128	else
129	ignoreExceptions = true;	×
130	const callbacks = Callbacks[hook];	3,426✔
131
132	// flag used to detect the callback that initiated the async context
133	let asyncContext = false;	3,426✔
134
135	let inProgressCallbackKey = markCallbackStarted(hook);	3,426✔
136
137	try {	3,426✔
138	if (typeof callbacks !== 'undefined' && !!callbacks.length) { // if the hook exists, and contains callbacks to run	3,426✔
139	const runCallback = (accumulator: AnyBecauseTodo, callback: AnyBecauseTodo) => {	1,469✔
140	logger(`\x1b[32m[${hook}] [${callback.name \|\| 'noname callback'}]\x1b[0m`);	7,686✔
141	try {	7,686✔
142	const result = callback.apply(this, [accumulator].concat(args));	7,686✔
143
144	if (typeof result === 'undefined') {	7,686✔
145	// if result of current iteration is undefined, don't pass it on
146	// logger(`// Warning: Sync callback [${callback.name}] in hook [${hook}] didn't return a result!`)
147	return accumulator;	518✔
148	} else {
149	return result;	7,168✔
150	}
151
152	} catch (error) {
153	// eslint-disable-next-line no-console
NEW 154	console.log(`\x1b[31m// error at callback [${callback.name}] in hook [${hook}]\x1b[0m`);	×
155	// eslint-disable-next-line no-console
NEW 156	console.log(error);	×
NEW 157	if (error.break \|\| (error.data && error.data.break) \|\| !ignoreExceptions) {	×
NEW 158	throw error;	×
159	}
160	// pass the unchanged accumulator to the next iteration of the loop
UNCOV 161	return accumulator;	×
162	}
163	};
164
165	const result = callbacks.reduce(function (accumulator: AnyBecauseTodo, callback: AnyBecauseTodo, index: AnyBecauseTodo) {	1,469✔
166	if (isPromise(accumulator)) {	7,686✔
167	if (!asyncContext) {	5,551✔
168	logger(`\x1b[32m[${hook}] Started async context for [${callbacks[index-1] && callbacks[index-1].name}]\x1b[0m`);	1,263✔
169	asyncContext = true;	1,263✔
170	}
171	return new Promise((resolve, reject) => {	5,551✔
172	accumulator	5,551✔
173	.then(result => {
174	if (result === undefined) {	5,551!
175	// eslint-disable-next-line no-console
NEW 176	console.error('Async before callbacks should not return undefined. Please return the document/data instead')	×
177	}
178	try {	5,551✔
179	// run this callback once we have the previous value
180	resolve(runCallback(result, callback));	5,551✔
181	} catch (error) {
182	// error will be thrown only for breaking errors, so throw it up in the promise chain
NEW 183	reject(error);	×
184	}
185	})
186	.catch(reject);
187	});
188	} else {
189	return runCallback(accumulator, callback);	2,135✔
190	}
191	}, item);
192
193	return result;	1,469✔
194	} else { // else, just return the item unchanged
195	return item;	1,957✔
196	}
197	} finally {
198	markCallbackFinished(inProgressCallbackKey, hook);	3,426✔
199	}
200	};
201
202	/**
203	* @summary Successively run all of a hook's callbacks on an item, in async mode (only works on server)
204	* @param {String} hook - First argument: the name of the hook
205	* @param {Any} args - Other arguments will be passed to each successive iteration
206	*/
207	const runCallbacksAsync = function <N extends CollectionNameString> (options: {	21✔
208	name: string,
209	// A bit of a mess. If you stick to non-deprecated hooks, you'll get the typed version
210	properties: [CallbackPropertiesBase<N>]\|any[]
211	}) {
212	const logger = loggerConstructor(`callbacks-${options.properties[0]?.collection?.collectionName.toLowerCase()}`)	1,479!
213	const hook = options.name;	1,479✔
214	const args = options.properties;	1,479✔
215
216	const callbacks = Callbacks[hook];	1,479✔
217
218	if (isServer && typeof callbacks !== 'undefined' && !!callbacks.length) {	1,479✔
219	let pendingDeferredCallbackStart = markCallbackStarted(hook);	854✔
220
221	// use defer to avoid holding up client
222	setTimeout(function () {	854✔
223	// run all post submit server callbacks on post object successively
224	callbacks.forEach(function (this: any, callback: AnyBecauseTodo) {	854✔
225	logger(`\x1b[32m[${hook}]: [${callback.name \|\| 'noname callback'}]\x1b[0m`);	3,570✔
226
227	let pendingAsyncCallback = markCallbackStarted(hook);	3,570✔
228	try {	3,570✔
229	let callbackResult = callback.apply(this, args);	3,570✔
230	if (isPromise(callbackResult)) {	3,570✔
231	callbackResult	3,356✔
232	.then(
233	result => markCallbackFinished(pendingAsyncCallback, hook),	3,356✔
234	exception => {
235	markCallbackFinished(pendingAsyncCallback, hook)	×
236	// eslint-disable-next-line no-console
237	console.log(`Error running async callback [${callback.name}] on hook [${hook}]`);	×
238	// eslint-disable-next-line no-console
239	console.log(exception);	×
240	throw exception;	×
241	}
242	)
243	} else {
244	markCallbackFinished(pendingAsyncCallback, hook);	214✔
245	}
246	} finally {
247	markCallbackFinished(pendingAsyncCallback, hook);	3,570✔
248	}
249	});
250
251	markCallbackFinished(pendingDeferredCallbackStart, hook);	854✔
252	}, 0);
253
254	}
255	};
256
257	// Dictionary of all outstanding callbacks (key is an ID, value is `true`). If
258	// there are no outstanding callbacks, this should be an empty dictionary.
259	let pendingCallbackKeys: Partial<Record<string,true>> = {};	21✔
260
261	let pendingCallbackDescriptions: Record<string,number> = {};	21✔
262
263	// ID for a pending callback. Incremements with each call to
264	// `markCallbackStarted`.
265	let pendingCallbackKey = 0;	21✔
266
267	// Count of the number of outstanding callbacks. Used to check that this isn't
268	// leaking.
269	let numCallbacksPending = 0;	21✔
270
271	// When starting an async callback, assign it an ID, record the fact that it's
272	// running, and return the ID.
273	function markCallbackStarted(description: string): number
274	{
275	if (numCallbacksPending > 1000) {	7,850!
276	// eslint-disable-next-line no-console
277	console.log(`Warning: Excessively many background callbacks running (numCallbacksPending=${numCallbacksPending}) while trying to add callback ${description}`);	×
278	}
279	numCallbacksPending++;	7,850✔
280
281	if (pendingCallbackKey >= Number.MAX_SAFE_INTEGER)	7,850!
282	pendingCallbackKey = 0;	×
283	else
284	pendingCallbackKey++;	7,850✔
285	pendingCallbackKeys[pendingCallbackKey] = true;	7,850✔
286
287	if (description in pendingCallbackDescriptions) {	7,850✔
288	pendingCallbackDescriptions[description]++;	3,219✔
289	} else {
290	pendingCallbackDescriptions[description] = 1;	4,631✔
291	}
292
293	return pendingCallbackKey;	7,850✔
294	}
295
296	// Record the fact that an async callback with the given ID has finished.
297	function markCallbackFinished(id: number, description: string)
298	{
299	numCallbacksPending--;	11,420✔
300	delete pendingCallbackKeys[id];	11,420✔
301
302	if (!pendingCallbackDescriptions[description] \|\| pendingCallbackDescriptions[description]===1) {	11,420✔
303	delete pendingCallbackDescriptions[description];	8,201✔
304	} else {
305	pendingCallbackDescriptions[description]--;	3,219✔
306	}
307	}
308
309	// Return whether there is at least one async callback running.
310	export const callbacksArePending = (): boolean => {	21✔
311	for(let _ in pendingCallbackKeys) {	477✔
312	return true;	66✔
313	}
314	return false;	411✔
315	}
316
317	export function printInProgressCallbacks() {
318	const callbacksInProgress = Object.keys(pendingCallbackDescriptions);	×
319	// eslint-disable-next-line no-console
320	console.log(`Callbacks in progress: ${callbacksInProgress.map(c => pendingCallbackDescriptions[c]!==1 ? `${c}(${pendingCallbackDescriptions[c]})` : c).join(", ")}`);	×
321	}

ForumMagnum / ForumMagnum / 10939316335

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