8669077916

Committed 12 Apr 2024 11:21PM UTC coverage: 65.142% (-0.01%) from 65.152%

Build # 8669077916

Build Type

push

github

Committed by

bpatrik

Commit Message

Improving extension loading. It mostly solves #847 and #784

Run Details

1549 of 2705 branches covered (57.26%)

Branch coverage included in aggregate %.

3 of 9 new or added lines in 2 files covered. (33.33%)

1 existing line in 1 file now uncovered.

4433 of 6478 relevant lines covered (68.43%)

13312.8 hits per line

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

42.47

/src/backend/model/extension/ExtensionConfigTemplateLoader.ts

import {PrivateConfigClass} from '../../../common/config/private/PrivateConfigClass';
import * as fs from 'fs';
import * as path from 'path';
import {ServerExtensionsEntryConfig} from '../../../common/config/private/subconfigs/ServerExtensionsConfig';
import * as child_process from 'child_process';

const execSync = child_process.execSync;

const LOG_TAG = '[ExtensionConfigTemplateLoader]';

/**
 * This class decouples the extension management and the config.
 * It helps to solve the "chicken and the egg" which should load first:
 *  Config or the extension as they have a circular dependency
 */
export class ExtensionConfigTemplateLoader {

  private static instance: ExtensionConfigTemplateLoader;
  private extensionsFolder: string;

  private loaded = false;
  private extensionList: string[] = [];
  private extensionTemplates: { folder: string, template?: { new(): unknown } }[] = [];

  public static get Instance() {
    if (!this.instance) {
      this.instance = new ExtensionConfigTemplateLoader();
    }

    return this.instance;
  }


  init(extensionsFolder: string) {
    this.extensionsFolder = extensionsFolder;
  }

  public loadExtensionTemplates(config: PrivateConfigClass) {
    if (!this.extensionsFolder) {
      throw new Error('Unknown extensions folder.');
    }
    // already loaded
    if (!this.loaded) {

      this.extensionTemplates = [];
      if (fs.existsSync(this.extensionsFolder)) {
        this.extensionList = (fs
          .readdirSync(this.extensionsFolder))
          .filter((f): boolean =>
            fs.statSync(path.join(this.extensionsFolder, f)).isDirectory()
          );
        this.extensionList.sort();

        for (let i = 0; i < this.extensionList.length; ++i) {
          const extFolder = this.extensionList[i];
          const extPath = path.join(this.extensionsFolder, extFolder);
          const configExtPath = path.join(extPath, 'config.js');
          const serverExtPath = path.join(extPath, 'server.js');

          // if server.js is missing, it's not a valid extension
          if (!fs.existsSync(serverExtPath)) {
            continue;
          }


          if (fs.existsSync(configExtPath)) {
            // eslint-disable-next-line @typescript-eslint/no-var-requires
            const extCfg = require(configExtPath);
            if (typeof extCfg?.initConfig === 'function') {
              extCfg?.initConfig({
                setConfigTemplate: (template: { new(): unknown }): void => {
                  this.extensionTemplates.push({folder: extFolder, template: template});
                }
              });
            }
          } else {
            //also create basic config extensions that do not have any
            this.extensionTemplates.push({folder: extFolder});
          }
        }
      }
      this.loaded = true;
    }

    this.setTemplatesToConfig(config);
  }


  private setTemplatesToConfig(config: PrivateConfigClass) {
    if (!this.extensionTemplates) {
      return;
    }

    const ePaths = this.extensionTemplates.map(et => et.folder);
    // delete not existing extensions
    config.Extensions.extensions = config.Extensions.extensions
      .filter(ec => ePaths.indexOf(ec.path) !== -1);


    for (let i = 0; i < this.extensionTemplates.length; ++i) {
      const ext = this.extensionTemplates[i];

      let c = (config.Extensions.extensions || [])
        .find(e => e.path === ext.folder);

      // set the new structure with the new def values
      if (!c) {
        c = new ServerExtensionsEntryConfig(ext.folder);
        if (ext.template) {
          c.configs = new ext.template();
        }
        // TODO: this does not hold if the order of the extensions mixes up.
        // TODO: experiment with a map instead of an array
        config.Extensions.extensions.push(c);
      }

    }
  }
}

1	import {PrivateConfigClass} from '../../../common/config/private/PrivateConfigClass';
2	import * as fs from 'fs';	1✔
3	import * as path from 'path';	1✔
4	import {ServerExtensionsEntryConfig} from '../../../common/config/private/subconfigs/ServerExtensionsConfig';	1✔
5	import * as child_process from 'child_process';	1✔
6
7	const execSync = child_process.execSync;	1✔
8
9	const LOG_TAG = '[ExtensionConfigTemplateLoader]';	1✔
10
11	/**
12	* This class decouples the extension management and the config.
13	* It helps to solve the "chicken and the egg" which should load first:
14	* Config or the extension as they have a circular dependency
15	*/
16	export class ExtensionConfigTemplateLoader {	1✔
17
18	private static instance: ExtensionConfigTemplateLoader;
19	private extensionsFolder: string;
20
21	private loaded = false;	1✔
22	private extensionList: string[] = [];	1✔
23	private extensionTemplates: { folder: string, template?: { new(): unknown } }[] = [];	1✔
24
25	public static get Instance() {
26	if (!this.instance) {	12✔
27	this.instance = new ExtensionConfigTemplateLoader();	1✔
28	}
29
30	return this.instance;	12✔
31	}
32
33
34	init(extensionsFolder: string) {
35	this.extensionsFolder = extensionsFolder;	1✔
36	}
37
38	public loadExtensionTemplates(config: PrivateConfigClass) {
39	if (!this.extensionsFolder) {	11!
40	throw new Error('Unknown extensions folder.');	×
41	}
42	// already loaded
43	if (!this.loaded) {	11✔
44
45	this.extensionTemplates = [];	1✔
46	if (fs.existsSync(this.extensionsFolder)) {	1!
47	this.extensionList = (fs	×
48	.readdirSync(this.extensionsFolder))
49	.filter((f): boolean =>
50	fs.statSync(path.join(this.extensionsFolder, f)).isDirectory()	×
51	);
52	this.extensionList.sort();	×
53
54	for (let i = 0; i < this.extensionList.length; ++i) {	×
55	const extFolder = this.extensionList[i];	×
56	const extPath = path.join(this.extensionsFolder, extFolder);	×
NEW 57	const configExtPath = path.join(extPath, 'config.js');	×
58	const serverExtPath = path.join(extPath, 'server.js');	×
59
60	// if server.js is missing, it's not a valid extension
61	if (!fs.existsSync(serverExtPath)) {	×
62	continue;	×
63	}
64
65
NEW 66	if (fs.existsSync(configExtPath)) {	×
67	// eslint-disable-next-line @typescript-eslint/no-var-requires
NEW 68	const extCfg = require(configExtPath);	×
NEW 69	if (typeof extCfg?.initConfig === 'function') {	×
NEW 70	extCfg?.initConfig({	×
71	setConfigTemplate: (template: { new(): unknown }): void => {
NEW 72	this.extensionTemplates.push({folder: extFolder, template: template});	×
73	}
74	});
75	}
76	} else {
77	//also create basic config extensions that do not have any
78	this.extensionTemplates.push({folder: extFolder});	×
79	}
80	}
81	}
82	this.loaded = true;	1✔
83	}
84
85	this.setTemplatesToConfig(config);	11✔
86	}
87
88
89	private setTemplatesToConfig(config: PrivateConfigClass) {
90	if (!this.extensionTemplates) {	11!
91	return;	×
92	}
93
94	const ePaths = this.extensionTemplates.map(et => et.folder);	11✔
95	// delete not existing extensions
96	config.Extensions.extensions = config.Extensions.extensions	11✔
97	.filter(ec => ePaths.indexOf(ec.path) !== -1);	×
98
99
100	for (let i = 0; i < this.extensionTemplates.length; ++i) {	11✔
101	const ext = this.extensionTemplates[i];	×
102
103	let c = (config.Extensions.extensions \|\| [])	×
104	.find(e => e.path === ext.folder);	×
105
106	// set the new structure with the new def values
107	if (!c) {	×
108	c = new ServerExtensionsEntryConfig(ext.folder);	×
109	if (ext.template) {	×
110	c.configs = new ext.template();	×
111	}
112	// TODO: this does not hold if the order of the extensions mixes up.
113	// TODO: experiment with a map instead of an array
UNCOV 114	config.Extensions.extensions.push(c);	×
115	}
116
117	}
118	}
119	}

bpatrik / pigallery2 / 8669077916

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