consolidated image resampling. fixed importing zipped workspace.

1 files changed, 37 insertions, 37 deletions

diff --git a/src/server/DashUploadUtils.ts b/src/server/DashUploadUtils.ts
index 5cf86b2ae..1e55a885a 100644
--- a/src/server/DashUploadUtils.ts
+++ b/src/server/DashUploadUtils.ts
@@ -7,7 +7,7 @@ import * as ffmpeg from 'fluent-ffmpeg';
 import * as formidable from 'formidable';
 import { File } from 'formidable';
 import * as fs from 'fs';
-import { createReadStream, createWriteStream, existsSync, readFileSync, rename, unlinkSync, writeFile } from 'fs'; // import { Jimp } from "@jimp/core";
+import { createReadStream, createWriteStream, existsSync, readFileSync, rename, unlinkSync, writeFile } from 'fs';
 import { Jimp } from 'jimp';
 import * as md5File from 'md5-file';
 import * as path from 'path';
@@ -25,32 +25,38 @@ import { resolvedServerUrl } from './server_Initialization';
 import { Worker, isMainThread, parentPort } from 'worker_threads';
 
 // Create an array to store worker threads
-const workerThreads: Worker[] = [];
+enum workertasks {
+    JIMP = 'jimp',
+}
+const JimpWorker: Worker | undefined = isMainThread ? new Worker(__filename) : undefined;
+export const workerResample = (imgSourcePath: string, outputPath: string, origSuffix: SizeSuffix, unlinkSource: boolean) => {
+    JimpWorker?.postMessage({ task: workertasks.JIMP, imgSourcePath, outputPath, origSuffix, unlinkSource });
+};
+
 if (isMainThread) {
-    // Main thread code
-    // Create worker threads -- just one right to do image resampling
-    workerThreads.push(new Worker(__filename));
+    // main thread code if needed ...
 } else {
     // Worker thread code - Listens for messages from the main thread
-    parentPort?.on('message', message => workerResampleImage(message.task));
-    async function workerResampleImage(task: string) {
-        const [sourcePath, outputFileName, outputDirectory, unlinkSource] = task.split('::');
-        const sizes = DashUploadUtils.imageResampleSizes(path.extname(sourcePath));
-        const imgBuffer = await fs.readFileSync(sourcePath);
-        const outputPath = (suffix: SizeSuffix) => {
-            const writtenFile = InjectSize(outputFileName, suffix);
-            return path.resolve(outputDirectory, writtenFile);
-        };
-        await Jimp.fromBuffer(imgBuffer)
-            .then(img => sizes.filter(({ width }) => width).map(({ width, suffix }) => img.resize({ w: width }).write(outputPath(suffix) as `${string}.${string}`)))
-            .catch(e => {
-                console.log('ERROR' + e);
-            });
-        if (unlinkSource === 'true') {
-            unlinkSync(sourcePath);
+    parentPort?.on('message', message => {
+        switch (message.task) {
+            case workertasks.JIMP:
+                return workerResampleImage(message);
+            default:
         }
-
-        // … operations to be performed to execute the task
+    });
+
+    async function workerResampleImage(message: { imgSourcePath: string; outputPath: string; origSuffix: string; unlinkSource: boolean }) {
+        const { imgSourcePath, outputPath, origSuffix, unlinkSource } = message;
+        const sizes = !origSuffix ? [{ width: 400, suffix: SizeSuffix.Medium }] : DashUploadUtils.imageResampleSizes(path.extname(imgSourcePath));
+        // prettier-ignore
+        Jimp.read(imgSourcePath)
+            .then(img => 
+                sizes.forEach(({ width, suffix }) =>
+                    img.resize({ w: width || img.bitmap.width })
+                       .write(InjectSize(outputPath, suffix) as `${string}.${string}`)
+                ))
+            .catch(e => console.log('Error Jimp:', e))
+            .finally(() => unlinkSource && unlinkSync(imgSourcePath));
     }
 }
 
@@ -332,28 +338,22 @@ export namespace DashUploadUtils {
      * @param outputDirectory the directory to output to, usually Directory.Images
      * @returns a map with suffixes as keys and resized filenames as values.
      */
-    export async function outputResizedImages(imgSourcePath: string, outputFileName: string, outputDirectory: string, unlinkSource: boolean) {
+    export async function outputResizedImages(imgSourcePath: string, outputFileName: string, unlinkSource: boolean) {
         const writtenFiles: { [suffix: string]: string } = {};
-
-        const outputPath = (suffix: SizeSuffix) => {
-            writtenFiles[suffix] = InjectSize(outputFileName, suffix);
-            return path.resolve(outputDirectory, writtenFiles[suffix]);
-        };
-
+        const outputPath = path.resolve(pathToDirectory(Directory.images), outputFileName);
         const sizes = imageResampleSizes(path.extname(outputFileName));
-        const imgBuffer = fs.readFileSync(imgSourcePath);
+
         const imgReadStream = new Duplex();
-        imgReadStream.push(imgBuffer);
+        imgReadStream.push(fs.readFileSync(imgSourcePath));
         imgReadStream.push(null);
         await Promise.all(
             sizes.map(({ suffix }) => 
                 new Promise<unknown>(res =>
-                    imgReadStream.pipe(createWriteStream(outputPath(suffix))).on('close', res)
+                    imgReadStream.pipe(createWriteStream(writtenFiles[suffix] = InjectSize(outputPath, suffix))).on('close', res)
                 )
         )); // prettier-ignore
 
-        // Send a message to worker thread to resample image
-        workerThreads[0].postMessage({ task: imgSourcePath + '::' + outputFileName + '::' + outputDirectory + '::' + unlinkSource });
+        workerResample(imgSourcePath, outputPath, SizeSuffix.Original, unlinkSource);
         return writtenFiles;
     }
 
@@ -402,7 +402,7 @@ export namespace DashUploadUtils {
         } else {
             const unlinkSrcWhenFinished = isLocal().test(source) && cleanUp;
             try {
-                writtenFiles = await outputResizedImages(metadata.source, resolved, pathToDirectory(Directory.images), unlinkSrcWhenFinished);
+                writtenFiles = await outputResizedImages(metadata.source, resolved, unlinkSrcWhenFinished);
             } catch (e) {
                 // input is a blob or other, try reading it to create a metadata source file.
                 const reqSource = request(metadata.source);
@@ -414,7 +414,7 @@ export namespace DashUploadUtils {
                         .on('close', () => res())
                         .on('error', () => rej());
                 });
-                writtenFiles = await outputResizedImages(readSource, resolved, pathToDirectory(Directory.images), unlinkSrcWhenFinished);
+                writtenFiles = await outputResizedImages(readSource, resolved, unlinkSrcWhenFinished);
                 fs.unlink(readSource, err => console.log("Couldn't unlink temporary image file:" + readSource, err));
             }
         }