Mizah/mizzkey
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

wip?

Browse source
This commit is contained in:
tamaina 2023-01-01 17:18:57 +00:00
parent a4a614e180
commit 453ba25af2
5 changed files with 148 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
packages/backend/src/core/DownloadService.ts
View file

@ -32,8 +32,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 gotUrl(url: string): Got.Request {
this.logger.info(`Downloading ${chalk.cyan(url)} ...`);
const timeout = 30 * 1000;
const operationTimeout = 60 * 1000;
@ -82,9 +82,16 @@ export class DownloadService {
req.destroy();
}
});
return req;
}
@bindThis
public async pipeRequestToFile(req: Got.Request, path: string): Promise<void> {
const copied = req.pipe(new stream.PassThrough());
try {
await pipeline(req, fs.createWriteStream(path));
this.logger.info(`Saving File to ${chalk.cyanBright(path)} from downloading ...`);
await pipeline(copied, 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);
@ -92,7 +99,11 @@ export class DownloadService {
throw e;
}
}
}
@bindThis
public async downloadUrl(url: string, path: string): Promise<void> {
await this.pipeRequestToFile(this.gotUrl(url), path);
this.logger.succ(`Download finished: ${chalk.cyan(url)}`);
}

54
packages/backend/src/core/FileInfoService.ts
View file

@ -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,7 @@ import { encode } from 'blurhash';
import { createTempDir } from '@/misc/create-temp.js';
import { AiService } from '@/core/AiService.js';
import { bindThis } from '@/decorators.js';
import type { Request } from 'got';
const pipeline = util.promisify(stream.pipeline);
@ -39,7 +40,7 @@ const TYPE_OCTET_STREAM = {
ext: null,
};
const TYPE_SVG = {
export const TYPE_SVG = {
mime: 'image/svg+xml',
ext: 'svg',
};
@ -306,9 +307,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) {
@ -332,21 +333,54 @@ export class FileInfoService {
// 種類が不明でもSVGかもしれない
if (await this.checkSvg(path)) {
return TYPE_SVG;
}
}
// それでも種類が不明なら application/octet-stream にする
return TYPE_OCTET_STREAM;
}
/**
* Detect MIME Type and extension by stream for performance (this cannot detect SVG)
*/
@bindThis
public async detectRequestType(request: Request): Promise<{
mime: string;
ext: string | null;
}> {
// Check 0 byte
if ((request.response?.complete || request.closed) && !request.response?.rawBody?.length) {
return TYPE_OCTET_STREAM;
}
const copied = request.pipe(new stream.PassThrough());
const type = await fileTypeFromStream(copied);
if (type) {
return {
mime: type.mime,
ext: type.ext,
};
}
// 種類が不明なら application/octet-stream にする
return TYPE_OCTET_STREAM;
}
/**
* Check the file is SVG or not
*/
@bindThis
public async checkSvg(path: string) {
public async checkSvg(target: string | Buffer) {
try {
const size = await this.getFileSize(path);
if (size > 1 * 1024 * 1024) return false;
return isSvg(fs.readFileSync(path));
if (typeof target === 'string') {
const size = await this.getFileSize(target);
if (size > 1 * 1024 * 1024) return false;
return isSvg(await fs.promises.readFile(target));
} else {
if (target.length > 1 * 1024 * 1024) return false;
return isSvg(target);
}
} catch {
return false;
}

37
packages/backend/src/core/ImageProcessingService.ts
View file

@ -9,6 +9,14 @@ export type IImage = {
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,6 +70,26 @@ 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 async convertToWebp(path: string, width: number, height: number, options: sharp.WebpOptions = webpDefault): Promise<IImage> {
return this.convertSharpToWebp(await sharp(path), width, height, options);
@ -69,14 +97,7 @@ export class ImageProcessingService {
@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,

32
packages/backend/src/server/FileServerService.ts
View file

@ -12,14 +12,17 @@ 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 { 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 { PassThrough } from 'node:stream';
import sharp from 'sharp';
import { Request } from 'got';
const _filename = fileURLToPath(import.meta.url);
const _dirname = dirname(_filename);
@ -106,29 +109,43 @@ export class FileServerService {
if (!file.storedInternal) {
if (file.isLink && file.uri) { // 期限切れリモートファイル
const [path, cleanup] = await createTemp();
const got = this.downloadService.gotUrl(file.uri);;
try {
await this.downloadService.downloadUrl(file.uri, path);
const fileSaving = this.downloadService.pipeRequestToFile(got, path);
const streamCopy = got.pipe(new PassThrough());
const { mime, ext } = await this.fileInfoService.detectType(path);
let { mime, ext } = await this.fileInfoService.detectRequestType(got);
if (mime === 'application/octet-stream' || mime === 'application/xml') {
await fileSaving;
if (await this.fileInfoService.checkSvg(path)) {
mime = TYPE_SVG.mime;
ext = TYPE_SVG.ext;
}
}
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.convertSharpToWebpStreamObj(streamCopy.pipe(sharp()), 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.convertSharpToWebpStream(streamCopy.pipe(sharp()), 2048, 2048, { ...webpDefault, lossless: true }),
ext: 'webp',
type: 'image/webp',
};
}
}
return {
data: fs.readFileSync(path),
data: streamCopy,
ext,
type: mime,
};
@ -141,6 +158,7 @@ export class FileServerService {
} catch (err) {
this.logger.error(`${err}`);
if (!got.closed) got.destroy();
if (err instanceof StatusError && err.isClientError) {
reply.code(err.statusCode);
reply.header('Cache-Control', 'max-age=86400');

51
packages/backend/src/server/MediaProxyServerService.ts
View file

@ -9,15 +9,17 @@ import type { Config } from '@/config.js';
import { isMimeImage } from '@/misc/is-mime-image.js';
import { createTemp } from '@/misc/create-temp.js';
import { DownloadService } from '@/core/DownloadService.js';
import { ImageProcessingService, webpDefault } from '@/core/ImageProcessingService.js';
import { IImageStreamable, ImageProcessingService, webpDefault } from '@/core/ImageProcessingService.js';
import type { IImage } from '@/core/ImageProcessingService.js';
import { FILE_TYPE_BROWSERSAFE } from '@/const.js';
import { StatusError } from '@/misc/status-error.js';
import type Logger from '@/logger.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, FastifyPluginOptions, FastifyReply, FastifyRequest } from 'fastify';
import { PassThrough, pipeline } from 'node:stream';
import { Request } from 'got';
const _filename = fileURLToPath(import.meta.url);
const _dirname = dirname(_filename);
@ -73,22 +75,33 @@ export class MediaProxyServerService {
// Create temp file
const [path, cleanup] = await createTemp();
const got = this.downloadService.gotUrl(url);
try {
await this.downloadService.downloadUrl(url, path);
const { mime, ext } = await this.fileInfoService.detectType(path);
const fileSaving = this.downloadService.pipeRequestToFile(got, path);
const streamCopy = got.pipe(new PassThrough());
let { mime, ext } = await this.fileInfoService.detectRequestType(got);
if (mime === 'application/octet-stream' || mime === 'application/xml') {
await fileSaving;
if (await this.fileInfoService.checkSvg(path)) {
mime = TYPE_SVG.mime;
ext = TYPE_SVG.ext;
}
}
const isConvertibleImage = isMimeImage(mime, 'sharp-convertible-image');
let image: IImage;
let image: IImageStreamable;
if ('emoji' in request.query && isConvertibleImage) {
const data = await sharp(path, { animated: !('static' in request.query) })
.resize({
height: 128,
withoutEnlargement: true,
})
.webp(webpDefault)
.toBuffer();
const data = pipeline(
streamCopy,
sharp({ animated: !('static' in request.query) })
.resize({
height: 128,
withoutEnlargement: true,
})
.webp(webpDefault),
);
image = {
data,
@ -96,15 +109,17 @@ export class MediaProxyServerService {
type: 'image/webp',
};
} else if ('static' in request.query && isConvertibleImage) {
image = await this.imageProcessingService.convertToWebp(path, 498, 280);
image = this.imageProcessingService.convertSharpToWebpStreamObj(streamCopy.pipe(sharp()), 498, 280);
} else if ('preview' in request.query && isConvertibleImage) {
image = await this.imageProcessingService.convertToWebp(path, 200, 200);
image = this.imageProcessingService.convertSharpToWebpStreamObj(streamCopy.pipe(sharp()), 200, 200);
} else if ('badge' in request.query) {
if (!isConvertibleImage) {
// 画像でないなら404でお茶を濁す
throw new StatusError('Unexpected mime', 404);
}
await fileSaving;
const mask = sharp(path)
.resize(96, 96, {
fit: 'inside',
@ -135,12 +150,12 @@ export class MediaProxyServerService {
type: 'image/png',
};
} else if (mime === 'image/svg+xml') {
image = await this.imageProcessingService.convertToWebp(path, 2048, 2048, webpDefault);
image = this.imageProcessingService.convertSharpToWebpStreamObj(streamCopy.pipe(sharp()), 2048, 2048);
} else if (!mime.startsWith('image/') || !FILE_TYPE_BROWSERSAFE.includes(mime)) {
throw new StatusError('Rejected type', 403, 'Rejected type');
} else {
image = {
data: fs.readFileSync(path),
data: streamCopy,
ext,
type: mime,
};
@ -152,6 +167,8 @@ export class MediaProxyServerService {
} catch (err) {
this.logger.error(`${err}`);
if (!got.closed) got.destroy();
if ('fallback' in request.query) {
return reply.sendFile('/dummy.png', assets);
}