10678000794

Committed 03 Sep 2024 06:53AM UTC coverage: 31.865% (-0.07%) from 31.93%

Build # 10678000794

Build Type

Pull #9335

github

Committed by

jimrandomh

Commit Message

Merge branch 'master' of https://github.com/ForumMagnum/LessWrong2 into refactor-callbacks

Pull Request Pull Request #9335: Uninvert control flow with callbacks

Run Details

5070 of 41246 branches covered (12.29%)

Branch coverage included in aggregate %.

132 of 209 new or added lines in 23 files covered. (63.16%)

10 existing lines in 7 files now uncovered.

29357 of 66794 relevant lines covered (43.95%)

184.8 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);
  
  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);
    
    markCallbackFinished(inProgressCallbackKey, hook);
    return result;
  } else { // else, just return the item unchanged
    markCallbackFinished(inProgressCallbackKey, hook);
    return item;
  }
};

/**
 * @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';	12,606✔
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,158✔
19	}
20
21	add = (fn: (doc: IteratorType, ...args: ArgumentsType) =>	9,158✔
22	(Promise<IteratorType\|Partial<IteratorType>> \| IteratorType \| undefined \| void)
23	) => {
24	addCallback(this.name, fn);	4,483✔
25	}
26
27	runCallbacks = async ({iterator, properties, ignoreExceptions}: {iterator: IteratorType, properties: ArgumentsType, ignoreExceptions?: boolean}): Promise<IteratorType> => {	9,158✔
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;	2,911✔
52	}
53
54	add = (fn: (...args: ArgumentsType) => void\|Promise<void>) => {	2,911✔
55	addCallback(this.name, fn);	2,897✔
56	}
57
58	runCallbacksAsync = async (properties: ArgumentsType): Promise<void> => {	2,911✔
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,380✔
90	Callbacks[hookName] = [];	2,737✔
91	}
92
93	Callbacks[hookName].push(callback);	7,380✔
94
95	if (Callbacks[hookName].length > 20) {	7,380!
96	// eslint-disable-next-line no-console
NEW 97	console.log(`Warning: Excessively many callbacks (${Callbacks[hookName].length}) on hook ${hookName}.`);	×
98	}
99
100	return callback;	7,380✔
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	if (typeof callbacks !== 'undefined' && !!callbacks.length) { // if the hook exists, and contains callbacks to run	3,426✔
138
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
156	console.log(error);	×
157	if (error.break \|\| (error.data && error.data.break) \|\| !ignoreExceptions) {	×
158	throw error;	×
159	}
160	// pass the unchanged accumulator to the next iteration of the loop
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
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
183	reject(error);	×
184	}
185	})
186	.catch(reject);
187	});
188	} else {
189	return runCallback(accumulator, callback);	2,135✔
190	}
191	}, item);
192
193	markCallbackFinished(inProgressCallbackKey, hook);	1,469✔
194	return result;	1,469✔
195	} else { // else, just return the item unchanged
196	markCallbackFinished(inProgressCallbackKey, hook);	1,957✔
197	return item;	1,957✔
198	}
199	};
200
201	/**
202	* @summary Successively run all of a hook's callbacks on an item, in async mode (only works on server)
203	* @param {String} hook - First argument: the name of the hook
204	* @param {Any} args - Other arguments will be passed to each successive iteration
205	*/
206	const runCallbacksAsync = function <N extends CollectionNameString> (options: {	21✔
207	name: string,
208	// A bit of a mess. If you stick to non-deprecated hooks, you'll get the typed version
209	properties: [CallbackPropertiesBase<N>]\|any[]
210	}) {
211	const logger = loggerConstructor(`callbacks-${options.properties[0]?.collection?.collectionName.toLowerCase()}`)	1,479!
212	const hook = options.name;	1,479✔
213	const args = options.properties;	1,479✔
214
215	const callbacks = Callbacks[hook];	1,479✔
216
217	if (isServer && typeof callbacks !== 'undefined' && !!callbacks.length) {	1,479✔
218	let pendingDeferredCallbackStart = markCallbackStarted(hook);	854✔
219
220	// use defer to avoid holding up client
221	setTimeout(function () {	854✔
222	// run all post submit server callbacks on post object successively
223	callbacks.forEach(function (this: any, callback: AnyBecauseTodo) {	854✔
224	logger(`\x1b[32m[${hook}]: [${callback.name \|\| 'noname callback'}]\x1b[0m`);	3,570✔
225
226	let pendingAsyncCallback = markCallbackStarted(hook);	3,570✔
227	try {	3,570✔
228	let callbackResult = callback.apply(this, args);	3,570✔
229	if (isPromise(callbackResult)) {	3,570✔
230	callbackResult	3,356✔
231	.then(
232	result => markCallbackFinished(pendingAsyncCallback, hook),	3,356✔
233	exception => {
234	markCallbackFinished(pendingAsyncCallback, hook)	×
235	// eslint-disable-next-line no-console
236	console.log(`Error running async callback [${callback.name}] on hook [${hook}]`);	×
237	// eslint-disable-next-line no-console
238	console.log(exception);	×
239	throw exception;	×
240	}
241	)
242	} else {
243	markCallbackFinished(pendingAsyncCallback, hook);	214✔
244	}
245	} finally {
246	markCallbackFinished(pendingAsyncCallback, hook);	3,570✔
247	}
248	});
249
250	markCallbackFinished(pendingDeferredCallbackStart, hook);	854✔
251	}, 0);
252
253	}
254	};
255
256	// Dictionary of all outstanding callbacks (key is an ID, value is `true`). If
257	// there are no outstanding callbacks, this should be an empty dictionary.
258	let pendingCallbackKeys: Partial<Record<string,true>> = {};	21✔
259
260	let pendingCallbackDescriptions: Record<string,number> = {};	21✔
261
262	// ID for a pending callback. Incremements with each call to
263	// `markCallbackStarted`.
264	let pendingCallbackKey = 0;	21✔
265
266	// Count of the number of outstanding callbacks. Used to check that this isn't
267	// leaking.
268	let numCallbacksPending = 0;	21✔
269
270	// When starting an async callback, assign it an ID, record the fact that it's
271	// running, and return the ID.
272	function markCallbackStarted(description: string): number
273	{
274	if (numCallbacksPending > 1000) {	7,850!
275	// eslint-disable-next-line no-console
276	console.log(`Warning: Excessively many background callbacks running (numCallbacksPending=${numCallbacksPending}) while trying to add callback ${description}`);	×
277	}
278	numCallbacksPending++;	7,850✔
279
280	if (pendingCallbackKey >= Number.MAX_SAFE_INTEGER)	7,850!
281	pendingCallbackKey = 0;	×
282	else
283	pendingCallbackKey++;	7,850✔
284	pendingCallbackKeys[pendingCallbackKey] = true;	7,850✔
285
286	if (description in pendingCallbackDescriptions) {	7,850✔
287	pendingCallbackDescriptions[description]++;	3,174✔
288	} else {
289	pendingCallbackDescriptions[description] = 1;	4,676✔
290	}
291
292	return pendingCallbackKey;	7,850✔
293	}
294
295	// Record the fact that an async callback with the given ID has finished.
296	function markCallbackFinished(id: number, description: string)
297	{
298	numCallbacksPending--;	11,420✔
299	delete pendingCallbackKeys[id];	11,420✔
300
301	if (!pendingCallbackDescriptions[description] \|\| pendingCallbackDescriptions[description]===1) {	11,420✔
302	delete pendingCallbackDescriptions[description];	8,246✔
303	} else {
304	pendingCallbackDescriptions[description]--;	3,174✔
305	}
306	}
307
308	// Return whether there is at least one async callback running.
309	export const callbacksArePending = (): boolean => {	21✔
310	for(let _ in pendingCallbackKeys) {	474✔
311	return true;	70✔
312	}
313	return false;	404✔
314	}
315
316	export function printInProgressCallbacks() {
317	const callbacksInProgress = Object.keys(pendingCallbackDescriptions);	×
318	// eslint-disable-next-line no-console
319	console.log(`Callbacks in progress: ${callbacksInProgress.map(c => pendingCallbackDescriptions[c]!==1 ? `${c}(${pendingCallbackDescriptions[c]})` : c).join(", ")}`);	×
320	}

ForumMagnum / ForumMagnum / 10678000794

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