10250823580

Committed 05 Aug 2024 02:34PM UTC coverage: 15.718% (+0.006%) from 15.712%

Build # 10250823580

Build Type

Pull #8666

github

Committed by

web-flow

Commit Message

Merge 6d00c9626 into 624f91366

Pull Request Pull Request #8666: Create blob storage port and adapters

Run Details

3533 of 21022 branches covered (16.81%)

Branch coverage included in aggregate %.

9 of 54 new or added lines in 11 files covered. (16.67%)

10 existing lines in 6 files now uncovered.

4694 of 31319 relevant lines covered (14.99%)

4.98 hits per line

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

13.55

/libs/core/src/ports/port.ts

import { delay } from '@hicommonwealth/shared';
import { config } from '../config';
import { logger, rollbar } from '../logging';
import { ExitCode } from './enums';
import { inMemoryBlobStorage } from './in-memory-blob-storage';
import { successfulInMemoryBroker } from './in-memory-brokers';
import {
  AdapterFactory,
  Analytics,
  BlobStorage,
  Broker,
  Cache,
  Disposable,
  Disposer,
  NotificationsProvider,
  NotificationsProviderSchedulesReturn,
  Stats,
} from './interfaces';

const log = logger(import.meta);

/**
 * Map of disposable adapter instances
 */
const adapters = new Map<string, Disposable>();

/**
 * Wraps creation of adapters around factory functions
 * @param factory adapter of T factory function
 * @returns adapter instance
 */
export function port<T extends Disposable>(factory: AdapterFactory<T>) {
  return function (adapter?: T) {
    if (!adapters.has(factory.name)) {
      const instance = factory(adapter);
      adapters.set(factory.name, instance);
      log.info(`[binding adapter] ${instance.name || factory.name}`);
      return instance;
    }
    return adapters.get(factory.name) as T;
  };
}

/**
 * Register of resource disposers on exit
 */
const disposers: Disposer[] = [];

/**
 * Internal disposer and process killer
 * @param code exit code, defaults to unit testing
 * @param forceExit Forces exit in production if set to true
 */
const disposeAndExit = async (
  code: ExitCode = 'UNIT_TEST',
  forceExit: boolean = false,
): Promise<void> => {
  // don't kill process when errors are caught in production
  if (code === 'ERROR' && config.NODE_ENV === 'production') {
    if (forceExit) await delay(1_000);
    else return;
  }

  // call disposers
  await Promise.all(disposers.map((disposer) => disposer()));
  await Promise.all(
    [...adapters].reverse().map(async ([key, adapter]) => {
      log.info(`[disposing adapter] ${adapter.name || key}`);
      await adapter.dispose();
    }),
  );
  adapters.clear();

  if (config.NODE_ENV !== 'test' && code !== 'UNIT_TEST') {
    rollbar.wait(() => {
      log.info('Rollbar logs flushed');
      // eslint-disable-next-line n/no-process-exit
      process.exit(code === 'ERROR' ? 1 : 0);
    });
  }
};

export const disposeAdapter = (name: string): void => {
  adapters.get(name)?.dispose();
  adapters.delete(name);
  adapters.clear();
};

/**
 * Registers resource disposers that get triggered on process exits
 * @param disposer the disposer function
 * @returns a function that triggers all registered disposers and terminates the process
 */
export const dispose = (disposer?: Disposer): typeof disposeAndExit => {
  disposer && disposers.push(disposer);
  return disposeAndExit;
};

/**
 * Handlers to dispose registered resources on exit or unhandled exceptions
 */
process.once('SIGINT', async (arg?: any) => {
  log.info(`SIGINT ${arg !== 'SIGINT' ? arg : ''}`);
  await disposeAndExit('EXIT');
});
process.once('SIGTERM', async (arg?: any) => {
  log.info(`SIGTERM ${arg !== 'SIGTERM' ? arg : ''}`);
  await disposeAndExit('EXIT');
});
process.once('uncaughtException', async (arg?: any) => {
  log.error('Uncaught Exception', arg);
  await disposeAndExit('ERROR');
});
process.once('unhandledRejection', async (arg?: any) => {
  log.error('Unhandled Rejection', arg);
  await disposeAndExit('ERROR');
});

/**
 * Stats port factory
 */
export const stats = port(function stats(stats?: Stats) {
  return (
    stats || {
      name: 'in-memory-stats',
      dispose: () => Promise.resolve(),
      histogram: () => {},
      set: () => {},
      increment: () => {},
      incrementBy: () => {},
      decrement: () => {},
      decrementBy: () => {},
      on: () => {},
      off: () => {},
      gauge: () => {},
      timing: () => {},
    }
  );
});

/**
 * Cache port factory
 */
export const cache = port(function cache(cache?: Cache) {
  return (
    cache || {
      name: 'in-memory-cache',
      dispose: () => Promise.resolve(),
      ready: () => Promise.resolve(true),
      isReady: () => true,
      getKey: () => Promise.resolve(''),
      setKey: () => Promise.resolve(false),
      getKeys: () => Promise.resolve(false),
      setKeys: () => Promise.resolve(false),
      getNamespaceKeys: () => Promise.resolve(false),
      deleteKey: () => Promise.resolve(0),
      deleteNamespaceKeys: () => Promise.resolve(0),
      flushAll: () => Promise.resolve(),
      incrementKey: () => Promise.resolve(0),
      decrementKey: () => Promise.resolve(0),
      getKeyTTL: () => Promise.resolve(0),
      setKeyTTL: () => Promise.resolve(false),
    }
  );
});

/**
 * Analytics port factory
 */
export const analytics = port(function analytics(analytics?: Analytics) {
  return (
    analytics || {
      name: 'in-memory-analytics',
      dispose: () => Promise.resolve(),
      track: () => {},
    }
  );
});

/**
 * Broker port factory
 */
export const broker = port(function broker(broker?: Broker) {
  return broker || successfulInMemoryBroker;
});

/**
 * External blob storage port factory
 */
export const blobStorage = port(function blobStorage(
  blobStorage?: BlobStorage,
) {
  return blobStorage || inMemoryBlobStorage;
});

/**
 * Notifications provider port factory
 */
export const notificationsProvider = port(function notificationsProvider(
  notificationsProvider?: NotificationsProvider,
) {
  return (
    notificationsProvider || {
      name: 'in-memory-notifications-provider',
      dispose: () => Promise.resolve(),
      triggerWorkflow: () => Promise.resolve(true),
      getMessages: () => Promise.resolve([]),
      getSchedules: () =>
        Promise.resolve([] as NotificationsProviderSchedulesReturn),
      createSchedules: () =>
        Promise.resolve([] as NotificationsProviderSchedulesReturn),
      deleteSchedules: ({ schedule_ids }) =>
        Promise.resolve(new Set(schedule_ids)),
      registerClientRegistrationToken: () => Promise.resolve(false),
      unregisterClientRegistrationToken: () => Promise.resolve(false),
    }
  );
});

1	import { delay } from '@hicommonwealth/shared';
2	import { config } from '../config';
3	import { logger, rollbar } from '../logging';
4	import { ExitCode } from './enums';
5	import { inMemoryBlobStorage } from './in-memory-blob-storage';
6	import { successfulInMemoryBroker } from './in-memory-brokers';
7	import {
8	AdapterFactory,
9	Analytics,
10	BlobStorage,
11	Broker,
12	Cache,
13	Disposable,
14	Disposer,
15	NotificationsProvider,
16	NotificationsProviderSchedulesReturn,
17	Stats,
18	} from './interfaces';
19
20	const log = logger(import.meta);	1✔
21
22	/**
23	* Map of disposable adapter instances
24	*/
25	const adapters = new Map<string, Disposable>();	1✔
26
27	/**
28	* Wraps creation of adapters around factory functions
29	* @param factory adapter of T factory function
30	* @returns adapter instance
31	*/
32	export function port<T extends Disposable>(factory: AdapterFactory<T>) {
33	return function (adapter?: T) {	6✔
34	if (!adapters.has(factory.name)) {	×
35	const instance = factory(adapter);	×
36	adapters.set(factory.name, instance);	×
37	log.info(`[binding adapter] ${instance.name \|\| factory.name}`);	×
38	return instance;	×
39	}
40	return adapters.get(factory.name) as T;	×
41	};
42	}
43
44	/**
45	* Register of resource disposers on exit
46	*/
47	const disposers: Disposer[] = [];	1✔
48
49	/**
50	* Internal disposer and process killer
51	* @param code exit code, defaults to unit testing
52	* @param forceExit Forces exit in production if set to true
53	*/
54	const disposeAndExit = async (	1✔
55	code: ExitCode = 'UNIT_TEST',	×
56	forceExit: boolean = false,	×
57	): Promise<void> => {
58	// don't kill process when errors are caught in production
59	if (code === 'ERROR' && config.NODE_ENV === 'production') {	×
60	if (forceExit) await delay(1_000);	×
61	else return;	×
62	}
63
64	// call disposers
65	await Promise.all(disposers.map((disposer) => disposer()));	×
66	await Promise.all(	×
67	[...adapters].reverse().map(async ([key, adapter]) => {
68	log.info(`[disposing adapter] ${adapter.name \|\| key}`);	×
69	await adapter.dispose();	×
70	}),
71	);
72	adapters.clear();	×
73
74	if (config.NODE_ENV !== 'test' && code !== 'UNIT_TEST') {	×
75	rollbar.wait(() => {	×
76	log.info('Rollbar logs flushed');	×
77	// eslint-disable-next-line n/no-process-exit
78	process.exit(code === 'ERROR' ? 1 : 0);	×
79	});
80	}
81	};
82
83	export const disposeAdapter = (name: string): void => {	1✔
84	adapters.get(name)?.dispose();	×
85	adapters.delete(name);	×
86	adapters.clear();	×
87	};
88
89	/**
90	* Registers resource disposers that get triggered on process exits
91	* @param disposer the disposer function
92	* @returns a function that triggers all registered disposers and terminates the process
93	*/
94	export const dispose = (disposer?: Disposer): typeof disposeAndExit => {	1✔
95	disposer && disposers.push(disposer);	×
96	return disposeAndExit;	×
97	};
98
99	/**
100	* Handlers to dispose registered resources on exit or unhandled exceptions
101	*/
102	process.once('SIGINT', async (arg?: any) => {	1✔
103	log.info(`SIGINT ${arg !== 'SIGINT' ? arg : ''}`);	×
104	await disposeAndExit('EXIT');	×
105	});
106	process.once('SIGTERM', async (arg?: any) => {	1✔
107	log.info(`SIGTERM ${arg !== 'SIGTERM' ? arg : ''}`);	×
108	await disposeAndExit('EXIT');	×
109	});
110	process.once('uncaughtException', async (arg?: any) => {	1✔
111	log.error('Uncaught Exception', arg);	×
112	await disposeAndExit('ERROR');	×
113	});
114	process.once('unhandledRejection', async (arg?: any) => {	1✔
115	log.error('Unhandled Rejection', arg);	×
116	await disposeAndExit('ERROR');	×
117	});
118
119	/**
120	* Stats port factory
121	*/
122	export const stats = port(function stats(stats?: Stats) {	1✔
123	return (	1✔
124	stats \|\| {	×
125	name: 'in-memory-stats',
126	dispose: () => Promise.resolve(),	×
127	histogram: () => {},
128	set: () => {},
129	increment: () => {},
130	incrementBy: () => {},
131	decrement: () => {},
132	decrementBy: () => {},
133	on: () => {},
134	off: () => {},
135	gauge: () => {},
136	timing: () => {},
137	}
138	);
139	});
140
141	/**
142	* Cache port factory
143	*/
144	export const cache = port(function cache(cache?: Cache) {	1✔
145	return (	1✔
146	cache \|\| {	×
147	name: 'in-memory-cache',
148	dispose: () => Promise.resolve(),	×
149	ready: () => Promise.resolve(true),	×
150	isReady: () => true,	×
151	getKey: () => Promise.resolve(''),	×
152	setKey: () => Promise.resolve(false),	×
153	getKeys: () => Promise.resolve(false),	×
154	setKeys: () => Promise.resolve(false),	×
155	getNamespaceKeys: () => Promise.resolve(false),	×
156	deleteKey: () => Promise.resolve(0),	×
157	deleteNamespaceKeys: () => Promise.resolve(0),	×
158	flushAll: () => Promise.resolve(),	×
159	incrementKey: () => Promise.resolve(0),	×
160	decrementKey: () => Promise.resolve(0),	×
161	getKeyTTL: () => Promise.resolve(0),	×
162	setKeyTTL: () => Promise.resolve(false),	×
163	}
164	);
165	});
166
167	/**
168	* Analytics port factory
169	*/
170	export const analytics = port(function analytics(analytics?: Analytics) {	1✔
171	return (	1✔
172	analytics \|\| {	×
173	name: 'in-memory-analytics',
174	dispose: () => Promise.resolve(),	×
175	track: () => {},
176	}
177	);
178	});
179
180	/**
181	* Broker port factory
182	*/
183	export const broker = port(function broker(broker?: Broker) {	1✔
184	return broker \|\| successfulInMemoryBroker;	×
185	});
186
187	/**
188	* External blob storage port factory
189	*/
190	export const blobStorage = port(function blobStorage(	1✔
191	blobStorage?: BlobStorage,
192	) {
NEW 193	return blobStorage \|\| inMemoryBlobStorage;	×
194	});
195
196	/**
197	* Notifications provider port factory
198	*/
199	export const notificationsProvider = port(function notificationsProvider(	1✔
200	notificationsProvider?: NotificationsProvider,
201	) {
202	return (	1✔
203	notificationsProvider \|\| {	×
204	name: 'in-memory-notifications-provider',
205	dispose: () => Promise.resolve(),	×
206	triggerWorkflow: () => Promise.resolve(true),	×
207	getMessages: () => Promise.resolve([]),	×
208	getSchedules: () =>
209	Promise.resolve([] as NotificationsProviderSchedulesReturn),	×
210	createSchedules: () =>
211	Promise.resolve([] as NotificationsProviderSchedulesReturn),	×
212	deleteSchedules: ({ schedule_ids }) =>
213	Promise.resolve(new Set(schedule_ids)),	×
214	registerClientRegistrationToken: () => Promise.resolve(false),	×
215	unregisterClientRegistrationToken: () => Promise.resolve(false),	×
216	}
217	);
218	});

hicommonwealth / commonwealth / 10250823580

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