perf: Use stream around MediaProxy and FileServer

.node-version

@@ -1 +1 @@
-v18.12.1
+v18.13.0

packages/backend/src/core/DownloadService.ts

@@ -14,10 +14,16 @@ import { StatusError } from '@/misc/status-error.js';
 import { LoggerService } from '@/core/LoggerService.js';
 import type Logger from '@/logger.js';
 import { buildConnector } from 'undici';
+import type { Response } from 'undici';
 
 const pipeline = util.promisify(stream.pipeline);
 import { bindThis } from '@/decorators.js';
 
+export type NonNullBodyResponse = Response & {
+	body: ReadableStream;
+	clone: () => NonNullBodyResponse;
+};
+
 @Injectable()
 export class DownloadService {
 	private logger: Logger;
@@ -52,8 +58,8 @@ export class DownloadService {
 	}
 
 	@bindThis
-	public async downloadUrl(url: string, path: string): Promise<void> {
-		this.logger.info(`Downloading ${chalk.cyan(url)} to ${chalk.cyanBright(path)} ...`);
+	public async fetchUrl(url: string): Promise<NonNullBodyResponse> {
+		this.logger.info(`Downloading ${chalk.cyan(url)} ...`);
 
 		const timeout = 30 * 1000;
 		const operationTimeout = 60 * 1000;
@@ -65,8 +71,33 @@ export class DownloadService {
 			throw new StatusError('No body', 400, 'No body');
 		}
 
-		await pipeline(stream.Readable.fromWeb(response.body), fs.createWriteStream(path));
+		this.logger.succ(`Download finished: ${chalk.cyan(url)}`);
+
+		return response as NonNullBodyResponse;
+	}
+
+	@bindThis
+	public async pipeRequestToFile(_response: Response, path: string): Promise<void> {
+		const response = _response.clone();
+		if (response.body == null) {
+			throw new StatusError('No body', 400, 'No body');
+		}
+
+		try {
+			this.logger.info(`Saving File to ${chalk.cyanBright(path)} from downloading ...`);
+			await pipeline(stream.Readable.fromWeb(response.body), fs.createWriteStream(path));
+		} catch (e) {
+			if (e instanceof Got.HTTPError) {
+				throw new StatusError(`${e.response.statusCode} ${e.response.statusMessage}`, e.response.statusCode, e.response.statusMessage);
+			} else {
+				throw e;
+			}
+		}
+	}
 
+	@bindThis
+	public async downloadUrl(url: string, path: string): Promise<void> {
+		await this.pipeRequestToFile(await this.fetchUrl(url), path);
 		this.logger.succ(`Download finished: ${chalk.cyan(url)}`);
 	}
 

packages/backend/src/core/FileInfoService.ts

@@ -5,7 +5,7 @@ import * as stream from 'node:stream';
 import * as util from 'node:util';
 import { Inject, Injectable } from '@nestjs/common';
 import { FSWatcher } from 'chokidar';
-import { fileTypeFromFile } from 'file-type';
+import { fileTypeFromFile, fileTypeFromStream } from 'file-type';
 import FFmpeg from 'fluent-ffmpeg';
 import isSvg from 'is-svg';
 import probeImageSize from 'probe-image-size';
@@ -15,6 +15,8 @@ import { encode } from 'blurhash';
 import { createTempDir } from '@/misc/create-temp.js';
 import { AiService } from '@/core/AiService.js';
 import { bindThis } from '@/decorators.js';
+import { Response } from 'undici';
+import { StatusError } from '@/misc/status-error.js';
 
 const pipeline = util.promisify(stream.pipeline);
 
@@ -39,7 +41,7 @@ const TYPE_OCTET_STREAM = {
 	ext: null,
 };
 
-const TYPE_SVG = {
+export const TYPE_SVG = {
 	mime: 'image/svg+xml',
 	ext: 'svg',
 };
@@ -306,9 +308,9 @@ export class FileInfoService {
 	 */
 	@bindThis
 	public async detectType(path: string): Promise<{
-	mime: string;
-	ext: string | null;
-}> {
+		mime: string;
+		ext: string | null;
+	}> {
 	// Check 0 byte
 		const fileSize = await this.getFileSize(path);
 		if (fileSize === 0) {
@@ -338,6 +340,47 @@ export class FileInfoService {
 		return TYPE_OCTET_STREAM;
 	}
 
+	/**
+	 * Detect MIME Type and extension by stream and path for performance
+	 */
+	@bindThis
+	public async detectRequestType(_response: Response, path?: string, fileSavingPromise: Promise<any> = Promise.resolve()): Promise<{
+		mime: string;
+		ext: string | null;
+	}> {
+		const response = _response.clone();
+
+		if (!response.body) {
+			throw new StatusError('No Body', 400, 'No Body');
+		}
+
+		const type = await fileTypeFromStream(stream.Readable.fromWeb(response.body));
+
+		if (type) {
+			// XMLはSVGかもしれない
+			if (path && type.mime === 'application/xml') {
+				await fileSavingPromise;
+				if (await this.checkSvg(path)) {
+					return TYPE_SVG;
+				}	
+			}
+
+			return {
+				mime: type.mime,
+				ext: type.ext,
+			};
+		}
+
+		// 種類が不明でもSVGかもしれない
+		if (path) {
+			await fileSavingPromise;
+			if (await this.checkSvg(path)) return TYPE_SVG;
+		}
+
+		// 種類が不明なら application/octet-stream にする
+		return TYPE_OCTET_STREAM;
+	}
+
 	/**
 	 * Check the file is SVG or not
 	 */
@@ -346,7 +389,7 @@ export class FileInfoService {
 		try {
 			const size = await this.getFileSize(path);
 			if (size > 1 * 1024 * 1024) return false;
-			return isSvg(fs.readFileSync(path));
+			return isSvg(await fs.promises.readFile(path));
 		} catch {
 			return false;
 		}

packages/backend/src/core/ImageProcessingService.ts

@@ -2,13 +2,23 @@ import { Inject, Injectable } from '@nestjs/common';
 import sharp from 'sharp';
 import { DI } from '@/di-symbols.js';
 import type { Config } from '@/config.js';
+import { ReadableStream } from 'node:stream/web';
+import { Readable } from 'node:stream';
 
 export type IImage = {
 	data: Buffer;
 	ext: string | null;
 	type: string;
 };
 
+export type IImageStream = {
+	data: NodeJS.ReadableStream;
+	ext: string | null;
+	type: string;
+};
+
+export type IImageStreamable = IImage | IImageStream;
+
 export const webpDefault: sharp.WebpOptions = {
 	quality: 85,
 	alphaQuality: 95,
@@ -62,21 +72,40 @@ export class ImageProcessingService {
 	 * Convert to WebP
 	 *   with resize, remove metadata, resolve orientation, stop animation
 	 */
+	@bindThis
+	public convertSharpToWebpStream(sharp: sharp.Sharp, width: number, height: number, options: sharp.WebpOptions = webpDefault): sharp.Sharp {
+		return sharp
+			.resize(width, height, {
+				fit: 'inside',
+				withoutEnlargement: true,
+			})
+			.rotate()
+			.webp(options);
+	}
+
+	@bindThis
+	public convertSharpToWebpStreamObj(sharp: sharp.Sharp, width: number, height: number, options: sharp.WebpOptions = webpDefault): IImageStream {
+		return {
+			data: this.convertSharpToWebpStream(sharp, width, height, options),
+			ext: 'webp',
+			type: 'image/webp',
+		}
+	}
+
+	@bindThis
+	public convertToWebpFromWebReadable(readable: ReadableStream | null, width: number, height: number, options: sharp.WebpOptions = webpDefault): IImageStream {
+		if (readable == null) throw new Error('Input is null');
+		return this.convertSharpToWebpStreamObj(Readable.fromWeb(readable).pipe(sharp()), width, height, options);
+	}
+
 	@bindThis
 	public async convertToWebp(path: string, width: number, height: number, options: sharp.WebpOptions = webpDefault): Promise<IImage> {
 		return this.convertSharpToWebp(await sharp(path), width, height, options);
 	}
 
 	@bindThis
 	public async convertSharpToWebp(sharp: sharp.Sharp, width: number, height: number, options: sharp.WebpOptions = webpDefault): Promise<IImage> {
-		const data = await sharp
-			.resize(width, height, {
-				fit: 'inside',
-				withoutEnlargement: true,
-			})
-			.rotate()
-			.webp(options)
-			.toBuffer();
+		const data = await this.convertSharpToWebpStream(sharp, width, height, options).toBuffer();
 
 		return {
 			data,

packages/backend/src/logger.ts

@@ -68,6 +68,7 @@ export default class Logger {
 		if (envOption.withLogTime) log = chalk.gray(time) + ' ' + log;
 
 		console.log(important ? chalk.bold(log) : log);
+		if (level === 'error' && data) console.log(data);
 
 		if (store) {
 			if (this.syslogClient) {

packages/backend/src/server/FileServerService.ts

@@ -11,15 +11,16 @@ import { createTemp } from '@/misc/create-temp.js';
 import { FILE_TYPE_BROWSERSAFE } from '@/const.js';
 import { StatusError } from '@/misc/status-error.js';
 import type Logger from '@/logger.js';
-import { DownloadService } from '@/core/DownloadService.js';
-import { ImageProcessingService } from '@/core/ImageProcessingService.js';
+import { DownloadService, NonNullBodyResponse } from '@/core/DownloadService.js';
+import { ImageProcessingService, webpDefault } from '@/core/ImageProcessingService.js';
 import { VideoProcessingService } from '@/core/VideoProcessingService.js';
 import { InternalStorageService } from '@/core/InternalStorageService.js';
 import { contentDisposition } from '@/misc/content-disposition.js';
-import { FileInfoService } from '@/core/FileInfoService.js';
+import { FileInfoService, TYPE_SVG } from '@/core/FileInfoService.js';
 import { LoggerService } from '@/core/LoggerService.js';
 import { bindThis } from '@/decorators.js';
 import type { FastifyInstance, FastifyRequest, FastifyReply, FastifyPluginOptions } from 'fastify';
+import { Readable } from 'node:stream';
 
 const _filename = fileURLToPath(import.meta.url);
 const _dirname = dirname(_filename);
@@ -106,29 +107,43 @@ export class FileServerService {
 		if (!file.storedInternal) {
 			if (file.isLink && file.uri) {	// 期限切れリモートファイル
 				const [path, cleanup] = await createTemp();
-
 				try {
-					await this.downloadService.downloadUrl(file.uri, path);
+					const response = await this.downloadService.fetchUrl(file.uri);
+					const fileSaving = this.downloadService.pipeRequestToFile(response, path);
 
-					const { mime, ext } = await this.fileInfoService.detectType(path);
+					const { mime, ext } = await this.fileInfoService.detectRequestType(response, path, fileSaving);
 
 					const convertFile = async () => {
 						if (isThumbnail) {
 							if (['image/jpeg', 'image/webp', 'image/avif', 'image/png', 'image/svg+xml'].includes(mime)) {
-								return await this.imageProcessingService.convertToWebp(path, 498, 280);
+								return this.imageProcessingService.convertToWebpFromWebReadable(
+									response.body,
+									498,
+									280
+								);
 							} else if (mime.startsWith('video/')) {
+								await fileSaving;
 								return await this.videoProcessingService.generateVideoThumbnail(path);
 							}
 						}
 
 						if (isWebpublic) {
 							if (['image/svg+xml'].includes(mime)) {
-								return await this.imageProcessingService.convertToPng(path, 2048, 2048);
+								return {
+									data: this.imageProcessingService.convertToWebpFromWebReadable(
+											response.body,
+											2048,
+											2048,
+											{ ...webpDefault, lossless: true }
+										),
+									ext: 'webp',
+									type: 'image/webp',
+								};
 							}
 						}
 
 						return {
-							data: fs.readFileSync(path),
+							data: Readable.fromWeb(response.body),
 							ext,
 							type: mime,
 						};