8694638738

Committed 15 Apr 2024 07:03PM UTC coverage: 65.076% (-0.07%) from 65.141%

Build # 8694638738

Build Type

push

github

Committed by

bpatrik

Commit Message

fix default loading issue #888

Run Details

1554 of 2715 branches covered (57.24%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

5 existing lines in 1 file now uncovered.

4433 of 6485 relevant lines covered (68.36%)

13295.56 hits per line

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

26.17

/src/backend/model/extension/ExtensionManager.ts

import {ProjectPath} from '../../ProjectPath';
import {Config} from '../../../common/config/private/Config';
import * as fs from 'fs';
import * as path from 'path';
import {IObjectManager} from '../database/IObjectManager';
import {Logger} from '../../Logger';
import {IExtensionEvents, IExtensionObject} from './IExtension';
import {Server} from '../../server';
import {ExtensionEvent} from './ExtensionEvent';
import * as express from 'express';
import {SQLConnection} from '../database/SQLConnection';
import {ExtensionObject} from './ExtensionObject';
import {ExtensionDecoratorObject} from './ExtensionDecorator';
import * as util from 'util';
// eslint-disable-next-line @typescript-eslint/no-var-requires
const exec = util.promisify(require('child_process').exec);

const LOG_TAG = '[ExtensionManager]';

export class ExtensionManager implements IObjectManager {

  public static EXTENSION_API_PATH = Config.Server.apiPath + '/extension';

  events: IExtensionEvents;
  extObjects: { [key: string]: ExtensionObject<unknown> } = {};
  router: express.Router;

  constructor() {
    this.initEvents();
  }

  public async init() {
    this.extObjects = {};
    this.initEvents();
    if (!Config.Extensions.enabled) {
      return;
    }
    this.router = express.Router();
    Server.instance?.app.use(ExtensionManager.EXTENSION_API_PATH, this.router);
    this.loadExtensionsList();
    await this.initExtensions();
  }

  private initEvents() {
    this.events = {
      gallery: {
        MetadataLoader: {
          loadPhotoMetadata: new ExtensionEvent(),
          loadVideoMetadata: new ExtensionEvent()
        },
        CoverManager: {
          getCoverForDirectory: new ExtensionEvent(),
          getCoverForAlbum: new ExtensionEvent(),
          invalidateDirectoryCovers: new ExtensionEvent(),
        },
        DiskManager: {
          excludeDir: new ExtensionEvent(),
          scanDirectory: new ExtensionEvent()
        },
        ImageRenderer: {
          render: new ExtensionEvent()
        }
      }
    };
    ExtensionDecoratorObject.init(this.events);
  }

  public loadExtensionsList() {
    Logger.debug(LOG_TAG, 'Loading extension list from ' + ProjectPath.ExtensionFolder);
    if (!fs.existsSync(ProjectPath.ExtensionFolder)) {
      return;
    }


    const extList = fs
      .readdirSync(ProjectPath.ExtensionFolder)
      .filter((f): boolean =>
        fs.statSync(path.join(ProjectPath.ExtensionFolder, f)).isDirectory()
      );
    extList.sort();


    Logger.debug(LOG_TAG, 'Extensions found: ', JSON.stringify(Config.Extensions.extensions.map(ec => ec.path)));
  }

  private createUniqueExtensionObject(name: string, folder: string): IExtensionObject<unknown> {
    let id = name;
    if (this.extObjects[id]) {
      let i = 0;
      while (this.extObjects[`${name}_${++i}`]) { /* empty */
      }
      id = `${name}_${++i}`;
    }
    if (!this.extObjects[id]) {
      this.extObjects[id] = new ExtensionObject(id, name, folder, this.router, this.events);
    }
    return this.extObjects[id];
  }

  private async initExtensions() {

    for (let i = 0; i < Config.Extensions.extensions.length; ++i) {
      const extFolder = Config.Extensions.extensions[i].path;
      let extName = extFolder;

      if (Config.Extensions.extensions[i].enabled === false) {
        Logger.silly(LOG_TAG, `Skipping ${extFolder} initiation. Extension is disabled.`);
      }
      const extPath = path.join(ProjectPath.ExtensionFolder, extFolder);
      const serverExtPath = path.join(extPath, 'server.js');
      const packageJsonPath = path.join(extPath, 'package.json');
      if (!fs.existsSync(serverExtPath)) {
        Logger.silly(LOG_TAG, `Skipping ${extFolder} server initiation. server.js does not exists`);
        continue;
      }

      if (fs.existsSync(packageJsonPath)) {
        if (fs.existsSync(path.join(extPath, 'node_modules'))) {
          Logger.debug(LOG_TAG, `node_modules folder exists. Skipping "npm install".`);
        } else {
          Logger.silly(LOG_TAG, `Running: "npm install --prefer-offline --no-audit --progress=false --omit=dev" in ${extPath}`);
          await exec('npm install  --no-audit --progress=false --omit=dev', {
            cwd: extPath
          });
        }
        // eslint-disable-next-line @typescript-eslint/no-var-requires
        const pkg = require(packageJsonPath);
        if (pkg.name) {
          extName = pkg.name;
        }
      }

      // eslint-disable-next-line @typescript-eslint/no-var-requires
      const ext = require(serverExtPath);
      if (typeof ext?.init === 'function') {
        Logger.debug(LOG_TAG, 'Running init on extension: ' + extFolder);
        await ext?.init(this.createUniqueExtensionObject(extName, extFolder));
      }
    }
    if (Config.Extensions.cleanUpUnusedTables) {
      // Clean up tables after all Extension was initialized.
      await SQLConnection.removeUnusedTables();
    }
  }

  private async cleanUpExtensions() {
    for (const extObj of Object.values(this.extObjects)) {
      const serverExt = path.join(extObj.folder, 'server.js');
      // eslint-disable-next-line @typescript-eslint/no-var-requires
      const ext = require(serverExt);
      if (typeof ext?.cleanUp === 'function') {
        Logger.debug(LOG_TAG, 'Running Init on extension:' + extObj.extensionName);
        await ext?.cleanUp(extObj);
      }
      extObj.messengers.cleanUp();
    }
  }


  public async cleanUp() {
    if (!Config.Extensions.enabled) {
      return;
    }
    this.initEvents(); // reset events
    await this.cleanUpExtensions();
    Server.instance?.app.use(ExtensionManager.EXTENSION_API_PATH, this.router);
    this.extObjects = {};
  }
}

1	import {ProjectPath} from '../../ProjectPath';	1✔
2	import {Config} from '../../../common/config/private/Config';	1✔
3	import * as fs from 'fs';	1✔
4	import * as path from 'path';	1✔
5	import {IObjectManager} from '../database/IObjectManager';
6	import {Logger} from '../../Logger';	1✔
7	import {IExtensionEvents, IExtensionObject} from './IExtension';
8	import {Server} from '../../server';	1✔
9	import {ExtensionEvent} from './ExtensionEvent';	1✔
10	import * as express from 'express';	1✔
11	import {SQLConnection} from '../database/SQLConnection';	1✔
12	import {ExtensionObject} from './ExtensionObject';	1✔
13	import {ExtensionDecoratorObject} from './ExtensionDecorator';	1✔
14	import * as util from 'util';	1✔
15	// eslint-disable-next-line @typescript-eslint/no-var-requires
16	const exec = util.promisify(require('child_process').exec);	1✔
17
18	const LOG_TAG = '[ExtensionManager]';	1✔
19
20	export class ExtensionManager implements IObjectManager {	1✔
21
22	public static EXTENSION_API_PATH = Config.Server.apiPath + '/extension';	1✔
23
24	events: IExtensionEvents;
25	extObjects: { [key: string]: ExtensionObject<unknown> } = {};	93✔
26	router: express.Router;
27
28	constructor() {
29	this.initEvents();	93✔
30	}
31
32	public async init() {
33	this.extObjects = {};	93✔
34	this.initEvents();	93✔
35	if (!Config.Extensions.enabled) {	93!
36	return;	93✔
37	}
38	this.router = express.Router();	×
39	Server.instance?.app.use(ExtensionManager.EXTENSION_API_PATH, this.router);	×
40	this.loadExtensionsList();	×
41	await this.initExtensions();	×
42	}
43
44	private initEvents() {
45	this.events = {	186✔
46	gallery: {
47	MetadataLoader: {
48	loadPhotoMetadata: new ExtensionEvent(),
49	loadVideoMetadata: new ExtensionEvent()
50	},
51	CoverManager: {
52	getCoverForDirectory: new ExtensionEvent(),
53	getCoverForAlbum: new ExtensionEvent(),
54	invalidateDirectoryCovers: new ExtensionEvent(),
55	},
56	DiskManager: {
57	excludeDir: new ExtensionEvent(),
58	scanDirectory: new ExtensionEvent()
59	},
60	ImageRenderer: {
61	render: new ExtensionEvent()
62	}
63	}
64	};
65	ExtensionDecoratorObject.init(this.events);	186✔
66	}
67
68	public loadExtensionsList() {
69	Logger.debug(LOG_TAG, 'Loading extension list from ' + ProjectPath.ExtensionFolder);	×
70	if (!fs.existsSync(ProjectPath.ExtensionFolder)) {	×
71	return;	×
72	}
73
74
75	const extList = fs	×
76	.readdirSync(ProjectPath.ExtensionFolder)
77	.filter((f): boolean =>
78	fs.statSync(path.join(ProjectPath.ExtensionFolder, f)).isDirectory()	×
79	);
80	extList.sort();	×
81
82
83	Logger.debug(LOG_TAG, 'Extensions found: ', JSON.stringify(Config.Extensions.extensions.map(ec => ec.path)));	×
84	}
85
86	private createUniqueExtensionObject(name: string, folder: string): IExtensionObject<unknown> {
87	let id = name;	×
88	if (this.extObjects[id]) {	×
89	let i = 0;	×
90	while (this.extObjects[`${name}_${++i}`]) { /* empty */	×
91	}
92	id = `${name}_${++i}`;	×
93	}
94	if (!this.extObjects[id]) {	×
95	this.extObjects[id] = new ExtensionObject(id, name, folder, this.router, this.events);	×
96	}
97	return this.extObjects[id];	×
98	}
99
100	private async initExtensions() {
101
102	for (let i = 0; i < Config.Extensions.extensions.length; ++i) {	×
103	const extFolder = Config.Extensions.extensions[i].path;	×
104	let extName = extFolder;	×
105
106	if (Config.Extensions.extensions[i].enabled === false) {	×
107	Logger.silly(LOG_TAG, `Skipping ${extFolder} initiation. Extension is disabled.`);	×
108	}
109	const extPath = path.join(ProjectPath.ExtensionFolder, extFolder);	×
110	const serverExtPath = path.join(extPath, 'server.js');	×
111	const packageJsonPath = path.join(extPath, 'package.json');	×
112	if (!fs.existsSync(serverExtPath)) {	×
113	Logger.silly(LOG_TAG, `Skipping ${extFolder} server initiation. server.js does not exists`);	×
114	continue;	×
115	}
116
117	if (fs.existsSync(packageJsonPath)) {	×
118	if (fs.existsSync(path.join(extPath, 'node_modules'))) {	×
119	Logger.debug(LOG_TAG, `node_modules folder exists. Skipping "npm install".`);	×
120	} else {
121	Logger.silly(LOG_TAG, `Running: "npm install --prefer-offline --no-audit --progress=false --omit=dev" in ${extPath}`);	×
122	await exec('npm install --no-audit --progress=false --omit=dev', {	×
123	cwd: extPath
124	});
125	}
126	// eslint-disable-next-line @typescript-eslint/no-var-requires
127	const pkg = require(packageJsonPath);	×
128	if (pkg.name) {	×
129	extName = pkg.name;	×
130	}
131	}
132
133	// eslint-disable-next-line @typescript-eslint/no-var-requires
134	const ext = require(serverExtPath);	×
135	if (typeof ext?.init === 'function') {	×
136	Logger.debug(LOG_TAG, 'Running init on extension: ' + extFolder);	×
137	await ext?.init(this.createUniqueExtensionObject(extName, extFolder));	×
138	}
139	}
140	if (Config.Extensions.cleanUpUnusedTables) {	×
141	// Clean up tables after all Extension was initialized.
142	await SQLConnection.removeUnusedTables();	×
143	}
144	}
145
146	private async cleanUpExtensions() {
UNCOV 147	for (const extObj of Object.values(this.extObjects)) {	×
148	const serverExt = path.join(extObj.folder, 'server.js');	×
149	// eslint-disable-next-line @typescript-eslint/no-var-requires
150	const ext = require(serverExt);	×
151	if (typeof ext?.cleanUp === 'function') {	×
152	Logger.debug(LOG_TAG, 'Running Init on extension:' + extObj.extensionName);	×
153	await ext?.cleanUp(extObj);	×
154	}
155	extObj.messengers.cleanUp();	×
156	}
157	}
158
159
160	public async cleanUp() {
161	if (!Config.Extensions.enabled) {	93!
162	return;	93✔
163	}
UNCOV 164	this.initEvents(); // reset events	×
UNCOV 165	await this.cleanUpExtensions();	×
UNCOV 166	Server.instance?.app.use(ExtensionManager.EXTENSION_API_PATH, this.router);	×
UNCOV 167	this.extObjects = {};	×
168	}
169	}

bpatrik / pigallery2 / 8694638738

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