backend performance improvement

backend/middlewares/thumbnail/ThumbnailGeneratorMWs.ts

@@ -12,13 +12,13 @@ import {PhotoDTO} from "../../../common/entities/PhotoDTO";
 import {Config} from "../../../common/config/private/Config";
 import {ThumbnailProcessingLib} from "../../../common/config/private/IPrivateConfig";
 import {ThumbnailTH} from "../../model/threading/ThreadPool";
-import {RendererFactory, RendererInput} from "../../model/threading/ThumbnailWoker";
+import {RendererInput} from "../../model/threading/ThumbnailWoker";
+import {ITaskQue, TaskQue} from "../../model/threading/TaskQue";
 
 
 export class ThumbnailGeneratorMWs {
   private static initDone = false;
-  private static ThumbnailFunction: (input: RendererInput) => Promise<void> = null;
+  private static taskQue: ITaskQue = null;
-  private static threadPool: ThumbnailTH = null;
 
   public static init() {
     if (this.initDone == true) {
@@ -33,11 +33,11 @@ export class ThumbnailGeneratorMWs {
       Config.Client.concurrentThumbnailGenerations = 1;
     }
 
-    this.ThumbnailFunction = RendererFactory.build(Config.Server.thumbnail.processingLibrary);
-
     if (Config.Server.enableThreading == true &&
       Config.Server.thumbnail.processingLibrary == ThumbnailProcessingLib.Jimp) {
-      this.threadPool = new ThumbnailTH(Config.Client.concurrentThumbnailGenerations);
+      this.taskQue = new ThumbnailTH(Config.Client.concurrentThumbnailGenerations);
+    } else {
+      this.taskQue = new TaskQue(Config.Client.concurrentThumbnailGenerations);
     }
 
     this.initDone = true;
@@ -157,13 +157,8 @@ export class ThumbnailGeneratorMWs {
       qualityPriority: Config.Server.thumbnail.qualityPriority
     };
     try {
-      if (this.threadPool !== null) {
+      await this.taskQue.execute(input);
-        await this.threadPool.execute(input);
       return next();
-      } else {
-        await ThumbnailGeneratorMWs.ThumbnailFunction(input);
-        return next();
-      }
     } catch (error) {
       return next(new ErrorDTO(ErrorCodes.THUMBNAIL_GENERATION_ERROR, "Error during generating thumbnail", error));
     }

backend/model/memory/UserManager.ts

@@ -65,7 +65,6 @@ export class UserManager implements IUserManager {
         users.splice(i, 1);
       }
     }
-    console.log(users);
     return users;
   }
 

backend/model/threading/DiskMangerWorker.ts

@@ -35,7 +35,7 @@ export class DiskMangerWorker {
       const absoluteDirectoryName = path.join(ProjectPath.ImageFolder, relativeDirectoryName);
 
       const stat = fs.statSync(path.join(ProjectPath.ImageFolder, relativeDirectoryName));
-      let directory = <DirectoryDTO>{
+      const directory = <DirectoryDTO>{
         name: directoryName,
         path: directoryParent,
         lastModified: Math.max(stat.ctime.getTime(), stat.mtime.getTime()),
@@ -51,8 +51,8 @@ export class DiskMangerWorker {
 
         try {
           for (let i = 0; i < list.length; i++) {
-            let file = list[i];
+            const file = list[i];
-            let fullFilePath = path.normalize(path.resolve(absoluteDirectoryName, file));
+            const fullFilePath = path.normalize(path.resolve(absoluteDirectoryName, file));
             if (photosOnly == false && fs.statSync(fullFilePath).isDirectory()) {
               const d = await DiskMangerWorker.scanDirectory(path.join(relativeDirectoryName, file),
                 Config.Server.folderPreviewSize, true

backend/model/threading/TaskQue.ts

@@ -0,0 +1,46 @@
+import {RendererInput, ThumbnailWoker} from "./ThumbnailWoker";
+import {Config} from "../../../common/config/private/Config";
+
+
+interface QueTask {
+  data: RendererInput;
+  promise: { resolve: Function, reject: Function };
+}
+
+
+export interface ITaskQue {
+  execute(input: any): Promise<any>;
+}
+
+export class TaskQue implements ITaskQue {
+
+  private tasks: QueTask[] = [];
+  private taskInProgress: number = 0;
+  private run = async () => {
+    if (this.tasks.length == 0 || this.taskInProgress >= this.size) {
+      return;
+    }
+    this.taskInProgress++;
+    const task = this.tasks.shift();
+    try {
+      task.promise.resolve(await ThumbnailWoker.render(task.data, Config.Server.thumbnail.processingLibrary));
+    } catch (err) {
+      task.promise.reject(err);
+    }
+    this.taskInProgress--;
+    process.nextTick(this.run);
+  };
+
+  constructor(private size: number) {
+  }
+
+  execute(input: RendererInput): Promise<void> {
+    return new Promise((resolve: Function, reject: Function) => {
+      this.tasks.push({
+        data: input,
+        promise: {resolve: resolve, reject: reject}
+      });
+      this.run();
+    });
+  }
+}

backend/model/threading/ThreadPool.ts

@@ -4,6 +4,7 @@ import {DiskManagerTask, ThumbnailTask, WorkerMessage, WorkerTask, WorkerTaskTyp
 import {DirectoryDTO} from "../../../common/entities/DirectoryDTO";
 import {RendererInput} from "./ThumbnailWoker";
 import {Config} from "../../../common/config/private/Config";
+import {ITaskQue} from "./TaskQue";
 
 
 interface PoolTask {
@@ -26,7 +27,6 @@ export class ThreadPool {
     Logger.silly("Creating thread pool with", size, "workers");
     for (let i = 0; i < size; i++) {
       this.startWorker();
-
     }
   }
 
@@ -83,14 +83,14 @@ export class ThreadPool {
       return;
     }
 
-    const poolTask = this.tasks.pop();
+    const poolTask = this.tasks.shift();
     worker.poolTask = poolTask;
     worker.worker.send(poolTask.task);
   };
 
 }
 
-export class DiskManagerTH extends ThreadPool {
+export class DiskManagerTH extends ThreadPool implements ITaskQue {
   execute(relativeDirectoryName: string): Promise<DirectoryDTO> {
     return super.executeTask(<DiskManagerTask>{
       type: WorkerTaskTypes.diskManager,
@@ -99,7 +99,7 @@ export class DiskManagerTH extends ThreadPool {
   }
 }
 
-export class ThumbnailTH extends ThreadPool {
+export class ThumbnailTH extends ThreadPool implements ITaskQue {
   execute(input: RendererInput): Promise<void> {
     return super.executeTask(<ThumbnailTask>{
       type: WorkerTaskTypes.thumbnail,

backend/model/threading/Worker.ts

@@ -2,6 +2,7 @@ import {DiskMangerWorker} from "./DiskMangerWorker";
 import {Logger} from "../../Logger";
 import {RendererInput, ThumbnailWoker} from "./ThumbnailWoker";
 import {ThumbnailProcessingLib} from "../../../common/config/private/IPrivateConfig";
+
 export class Worker {
 
 
@@ -13,6 +14,9 @@ export class Worker {
         switch (task.type) {
           case WorkerTaskTypes.diskManager:
             result = await DiskMangerWorker.scanDirectory((<DiskManagerTask>task).relativeDirectoryName);
+            if (global.gc) {
+              global.gc();
+            }
             break;
           case WorkerTaskTypes.thumbnail:
             result = await ThumbnailWoker.render((<ThumbnailTask>task).input, (<ThumbnailTask>task).renderer);

backend/server.ts

@@ -16,7 +16,8 @@ import {ThumbnailGeneratorMWs} from "./middlewares/thumbnail/ThumbnailGeneratorM
 import {DiskManager} from "./model/DiskManger";
 import {NotificationRouter} from "./routes/NotificationRouter";
 import {ConfigDiagnostics} from "./model/ConfigDiagnostics";
-import _session = require('cookie-session');
+
+const _session = require('cookie-session');
 
 const LOG_TAG = "[server]";
 

backend/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compileOnSave": true,
+  "compilerOptions": {
+    "module": "commonjs",
+    "skipLibCheck": true,
+    "sourceMap": false,
+    "declaration": false,
+    "moduleResolution": "node",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "es6",
+    "typeRoots": [
+      "../node_modules/@types"
+    ]
+  }
+}