remove socks, update plugins add credential provider

backend/src/Routes/Main/Credential/Provider.ts

@@ -1,9 +1,16 @@
-import {CredentialProviderResponse} from 'flyingfish_schemas';
+import {CredentialProviderResponse, StatusCodes} from 'flyingfish_schemas';
+import {CredentialProviders} from '../../../inc/Provider/CredentialProvider/CredentialProviders.js';
 
 export class Provider {
 
     public static async getProviders(): Promise<CredentialProviderResponse> {
+        const cp = new CredentialProviders();
+        const providers = await cp.getProviders();
 
+        return {
+            statusCode: StatusCodes.OK,
+            list: providers
+        };
     }
 
 }

backend/src/Routes/Main/Ssl/Details.ts

@@ -26,7 +26,8 @@ export class Details {
             const domain = await DomainServiceDB.getInstance().findOne(http.domain_id);
 
             if (domain) {
-                const provider = await SslCertProviders.getProvider(http.cert_provider);
+                const sp = new SslCertProviders();
+                const provider = await sp.getProvider(http.cert_provider);
 
                 if (provider) {
                     // TODO Wildcard

backend/src/Routes/Main/Ssl/Providers.ts

@@ -10,9 +10,11 @@ export class Providers {
      * getProviders
      */
     public static async getProviders(): Promise<SslProvidersResponse> {
+        const sp = new SslCertProviders();
+
         return {
             statusCode: StatusCodes.OK,
-            list: await SslCertProviders.getProviders()
+            list: await sp.getProviders()
         };
     }
 

backend/src/inc/Credential/Credential.ts

@@ -1,7 +1,12 @@
-import {CredentialLocationServiceDB, CredentialServiceDB, Logger, NginxLocationServiceDB} from 'flyingfish_core';
+import {
+    CredentialLocationServiceDB,
+    CredentialServiceDB,
+    ICredentialAuthBasic,
+    Logger,
+    NginxLocationServiceDB
+} from 'flyingfish_core';
 import {CredentialSchemaBasic} from 'flyingfish_schemas';
 import {CredentialProvider} from './CredentialProvider.js';
-import {ICredentialAuthBasic} from './ICredential.js';
 
 /**
  * Credential

backend/src/inc/Credential/CredentialDatabase.ts

@@ -1,7 +1,6 @@
 import * as bcrypt from 'bcrypt';
-import {CredentialDB, CredentialUserServiceDB, Logger} from 'flyingfish_core';
-import {CredentialSchemaTypes} from 'flyingfish_schemas/dist/src/index.js';
-import {ICredential, ICredentialAuthBasic} from './ICredential.js';
+import {CredentialDB, CredentialUserServiceDB, Logger, ICredential, ICredentialAuthBasic} from 'flyingfish_core';
+import {CredentialSchemaTypes} from 'flyingfish_schemas';
 
 /**
  * CredentialDB

backend/src/inc/Credential/CredentialProvider.ts

@@ -1,6 +1,6 @@
-import {CredentialDB} from 'flyingfish_core';
+import {CredentialDB, ICredential} from 'flyingfish_core';
 import {CredentialDatabase} from './CredentialDatabase.js';
-import {ICredential} from './ICredential.js';
+
 
 /**
  * CredentialProvider

backend/src/inc/Provider/CredentialProvider/CredentialProviders.ts

@@ -1,17 +1,22 @@
-import {ICredentialProvider, ICredentialProviders} from 'flyingfish_core';
+import {
+    BaseProviders,
+    ICredentialProvider,
+    ICredentialProviders
+} from 'flyingfish_core';
 import {ProviderEntry} from 'flyingfish_schemas';
 
-export class CredentialProviders implements ICredentialProviders {
-
-    public async getCredentialProvider(
-        name: string,
-        sourceCredentialId: number
-    ): Promise<ICredentialProvider | null> {
-        return null;
-    }
+/**
+ * Credential providers
+ */
+export class CredentialProviders extends BaseProviders implements ICredentialProviders {
 
+    /**
+     * Return a provider by name
+     * @param {string} name
+     * @returns {ICredentialProvider | null}
+     */
     public async getProvider(name: string): Promise<ICredentialProvider | null> {
-        return null;
+        return  this._getProvider<ICredentialProvider>(name);
     }
 
     public getProviders(): Promise<ProviderEntry[]> {

backend/src/inc/Provider/SslCertProvider/SslCertProviders.ts

@@ -1,32 +1,24 @@
-import {ASslCertProviderOnLoadEvent, ISslCertProvider, ISslCertProviders, PluginManager} from 'flyingfish_core';
+import {
+    ASslCertProviderOnLoadEvent,
+    BaseProviders,
+    ISslCertProvider,
+    ISslCertProviders,
+    PluginManager
+} from 'flyingfish_core';
 import {ProviderEntry} from 'flyingfish_schemas';
 
 /**
  * Ssl Certificate provider.
  */
-export class SslCertProviders implements ISslCertProviders {
+export class SslCertProviders extends BaseProviders implements ISslCertProviders {
 
     /**
      * Get a provider object by provider name.
      * @param {string} name - Name of provider.
      * @returns {ISslCertProvider|null}
      */
     public async getProvider(name: string): Promise<ISslCertProvider | null> {
-        const events = PluginManager.getInstance().getAllEvents<ASslCertProviderOnLoadEvent>(
-            ASslCertProviderOnLoadEvent
-        );
-
-        for await (const event of events) {
-            const providers = await event.getProviders();
-
-            for (const provider of providers) {
-                if (provider.getName() === name) {
-                    return provider;
-                }
-            }
-        }
-
-        return null;
+        return this._getProvider<ISslCertProvider>(name);
     }
 
     /**

backend/src/inc/Service/NginxService.ts

@@ -18,7 +18,8 @@ import {
     NginxUpstreamDB,
     NginxUpstreamServiceDB,
     SshPortDB,
-    SshPortServiceDB
+    SshPortServiceDB,
+    SslCertBundel
 } from 'flyingfish_core';
 import {
     NginxHttpVariableContextType,
@@ -28,8 +29,7 @@ import {
     NginxListenVariableContextType,
     NginxLocationDestinationTypes,
     NginxStreamDestinationType,
-    NginxStreamSshR,
-    SslCertBundel
+    NginxStreamSshR
 } from 'flyingfish_schemas';
 import fs from 'fs/promises';
 import path from 'path';
@@ -599,7 +599,7 @@ export class NginxService {
                                     weight: 0,
                                     max_fails: 0,
                                     fail_timeout: 0,
-                                    unix_sock: unixSocket
+                                    //unix_sock: unixSocket
                                 });
                             } else {
                                 Logger.getLogger().silly(`Destination listen not found by domain: ${domainName}`, {
@@ -982,7 +982,8 @@ export class NginxService {
                 // ssl use ---------------------------------------------------------------------------------------------
 
                 if (ssl_enable) {
-                    const provider = await SslCertProviders.getProvider(httpSubCollect.http.cert_provider);
+                    const sslCertProviders = new SslCertProviders();
+                    const provider = await sslCertProviders.getProvider(httpSubCollect.http.cert_provider);
 
                     if (provider) {
                         let sslBundel: SslCertBundel | null = null;

core/src/inc/Credential/ICredential.ts

@@ -0,0 +1,20 @@
+import {CredentialSchemaTypes} from 'flyingfish_schemas';
+
+/**
+ * Interface of credential
+ */
+export interface ICredential {
+
+    /**
+     * Return the supported types
+     * @returns {CredentialSchemaTypes[]}
+     */
+    getSupports(): CredentialSchemaTypes[];
+
+    /**
+     * Return the credential name
+     * @returns {string}
+     */
+    getName(): string;
+
+}

core/src/inc/Credential/ICredentialAuthBasic.ts

@@ -0,0 +1,16 @@
+import {ICredential} from './ICredential.js';
+
+/**
+ * Interface of credential auth basic
+ */
+export interface ICredentialAuthBasic extends ICredential {
+
+    /**
+     * Check an auth by username and password
+     * @param {string} username
+     * @param {string} password
+     * @returns {boolean}
+     */
+    authBasic(username: string, password: string): Promise<boolean>;
+
+}

core/src/inc/PluginSystem/PluginDefinition.ts

@@ -9,7 +9,8 @@ export const SchemaPluginDefinition = Vts.object({
     version: Vts.string(),
     author: Vts.string(),
     url: Vts.string(),
-    main: Vts.string()
+    main: Vts.string(),
+    main_directory: Vts.optional(Vts.array(Vts.string()))
 });
 
 /**

core/src/inc/PluginSystem/PluginManager.ts

@@ -160,15 +160,32 @@ export class PluginManager {
      */
     public async load(plugin: PluginInformation): Promise<boolean> {
         try {
+            let importFile: string|null = null;
+
             const pluginMain = path.join(plugin.path, plugin.definition.main);
 
-            if (!await FileHelper.fileExist(pluginMain)) {
-                throw new Error(`plugin main not found: ${pluginMain}`);
+            if (await FileHelper.fileExist(pluginMain, true)) {
+                importFile = pluginMain;
+            }
+
+            if (plugin.definition.main_directory) {
+                for await (const dir of plugin.definition.main_directory) {
+                    const pluginSubMain = path.join(plugin.path, dir, plugin.definition.main);
+
+                    if (await FileHelper.fileExist(pluginSubMain, true)) {
+                        importFile = pluginSubMain;
+                        break;
+                    }
+                }
+            }
+
+            if (importFile === null) {
+                throw new Error(`plugin main not found: ${plugin.path}`);
             }
 
-            Logger.getLogger().silly(`PluginManager::load: file plugin: ${pluginMain} (${plugin.definition.name})`);
+            Logger.getLogger().silly(`PluginManager::load: file plugin: ${importFile} (${plugin.definition.name})`);
 
-            const oPlugin = await import(pluginMain);
+            const oPlugin = await import(importFile);
 
             console.log(oPlugin);
 

core/src/inc/Provider/AProviderOnLoadEvent.ts

@@ -0,0 +1,15 @@
+import {APluginEvent} from '../PluginSystem/APluginEvent.js';
+import {IProvider} from './IProvider.js';
+
+/**
+ * Provider on load event
+ */
+export abstract class AProviderOnLoadEvent<T extends IProvider> extends APluginEvent {
+
+    /**
+     * Return all supported Providers.
+     * @returns {T[]}
+     */
+    public abstract getProviders(): Promise<T[]>;
+
+}

core/src/inc/Provider/BaseProviders.ts

@@ -0,0 +1,29 @@
+import {PluginManager} from '../PluginSystem/PluginManager.js';
+import {AProviderOnLoadEvent} from './AProviderOnLoadEvent.js';
+import {IProvider} from './IProvider.js';
+
+export class BaseProviders {
+
+    /**
+     * Return a provider by name
+     * @param {string} name
+     * @protected
+     * @returns {T|null}
+     */
+    protected async _getProvider<T extends IProvider>(name: string): Promise<T | null> {
+        const events = PluginManager.getInstance().getAllEvents<AProviderOnLoadEvent<T>>(AProviderOnLoadEvent<T>);
+
+        for await (const event of events) {
+            const providers = await event.getProviders();
+
+            for (const provider of providers) {
+                if (provider.getName() === name) {
+                    return provider;
+                }
+            }
+        }
+
+        return null;
+    }
+
+}

core/src/inc/Provider/CredentialProvider/ACredentialProviderOnLoadEvent.ts

@@ -0,0 +1,7 @@
+import {AProviderOnLoadEvent} from '../AProviderOnLoadEvent.js';
+import {ICredentialProvider} from './ICredentialProvider.js';
+
+/**
+ * Abstract class for provider on load event
+ */
+export abstract class ACredentialProviderOnLoadEvent extends AProviderOnLoadEvent<ICredentialProvider> {}

core/src/inc/Provider/CredentialProvider/ICredentialProvider.ts

@@ -1,6 +1,14 @@
+import {ICredential} from '../../Credential/ICredential.js';
 import {IProvider} from '../IProvider.js';
 
 /**
  * Interface of a Credential provider
  */
-export type ICredentialProvider = IProvider;
+export interface ICredentialProvider extends IProvider {
+
+    /**
+     * Return the credential
+     */
+    getCredential(): ICredential;
+
+}

core/src/inc/Provider/CredentialProvider/ICredentialProviders.ts

@@ -4,14 +4,4 @@ import {ICredentialProvider} from './ICredentialProvider.js';
 /**
  * Interface of credential providers
  */
-export interface ICredentialProviders extends IProviders<ICredentialProvider> {
-
-    /**
-     * Return the credential provider by name
-     * @param {string} name
-     * @param {number} sourceCredentialId
-     * @returns {IProvider|null}
-     */
-    getCredentialProvider(name: string, sourceCredentialId: number): Promise<ICredentialProvider|null>;
-
-}
+export type ICredentialProviders = IProviders<ICredentialProvider>;