297 lines
9.6 KiB
TypeScript
297 lines
9.6 KiB
TypeScript
import { bucketName, minioClient } from '@/modules/minio.ts';
|
||
import { IncomingMessage, ServerResponse } from 'http';
|
||
import { filterKeys } from './http-proxy.ts';
|
||
import { getUserFromRequest } from '../utils.ts';
|
||
import { UserPermission, Permission } from '@kevisual/permission';
|
||
import { getLoginUser } from '@/modules/auth.ts';
|
||
import busboy from 'busboy';
|
||
import { getContentType } from '../get-content-type.ts';
|
||
import { OssBase } from '@kevisual/oss';
|
||
import { parseSearchValue } from '@kevisual/router/browser';
|
||
import { logger } from '@/modules/logger.ts';
|
||
|
||
type FileList = {
|
||
name: string;
|
||
prefix?: string;
|
||
size?: number;
|
||
etag?: string;
|
||
lastModified?: Date;
|
||
|
||
path?: string;
|
||
url?: string;
|
||
pathname?: string;
|
||
};
|
||
export const getFileList = async (list: any, opts?: { objectName: string; app: string; host?: string }) => {
|
||
const { app, host } = opts || {};
|
||
const objectName = opts?.objectName || '';
|
||
let newObjectName = objectName;
|
||
const [user] = objectName.split('/');
|
||
let replaceUser = user + '/';
|
||
if (app === 'resources') {
|
||
replaceUser = `${user}/resources/`;
|
||
newObjectName = objectName.replace(`${user}/`, replaceUser);
|
||
}
|
||
return list.map((item: FileList) => {
|
||
if (item.name) {
|
||
item.path = item.name?.replace?.(objectName, '');
|
||
item.pathname = '/' + item.name.replace(`${user}/`, replaceUser);
|
||
} else {
|
||
item.path = item.prefix?.replace?.(objectName, '');
|
||
item.pathname = '/' + item.prefix.replace(`${user}/`, replaceUser);
|
||
}
|
||
if (item.name && app === 'ai') {
|
||
const [_user, _app, _version, ...rest] = item.name.split('/');
|
||
item.pathname = item.pathname.replace(`/${_user}/${_app}/${_version}/`, `/${_user}/${_app}/`);
|
||
} else if (app === 'ai') {
|
||
const [_user, _app, _version, ...rest] = item.prefix?.split('/');
|
||
item.pathname = item.pathname.replace(`/${_user}/${_app}/${_version}/`, `/${_user}/${_app}/`);
|
||
}
|
||
item.url = new URL(item.pathname, `https://${host}`).toString();
|
||
return item;
|
||
});
|
||
};
|
||
// import { logger } from '@/module/logger.ts';
|
||
const getAiProxy = async (req: IncomingMessage, res: ServerResponse, opts: ProxyOptions) => {
|
||
const { createNotFoundPage } = opts;
|
||
const _u = new URL(req.url, 'http://localhost');
|
||
const oss = opts.oss;
|
||
const params = _u.searchParams;
|
||
const password = params.get('p');
|
||
const hash = params.get('hash');
|
||
let dir = !!params.get('dir');
|
||
const recursive = !!params.get('recursive');
|
||
const { objectName, app, owner, loginUser, isOwner } = await getObjectName(req);
|
||
if (!dir && _u.pathname.endsWith('/')) {
|
||
dir = true; // 如果是目录请求，强制设置为true
|
||
}
|
||
logger.debug(`proxy request: ${objectName}`, dir);
|
||
try {
|
||
if (dir) {
|
||
if (!isOwner) {
|
||
return createNotFoundPage('no dir permission');
|
||
}
|
||
const list = await oss.listObjects<true>(objectName, { recursive: recursive });
|
||
res.writeHead(200, { 'content-type': 'application/json' });
|
||
const host = req.headers['host'] || 'localhost';
|
||
res.end(
|
||
JSON.stringify({
|
||
code: 200,
|
||
data: await getFileList(list, {
|
||
objectName: objectName,
|
||
app: app,
|
||
host,
|
||
}),
|
||
}),
|
||
);
|
||
return true;
|
||
}
|
||
const stat = await oss.statObject(objectName);
|
||
if (!stat) {
|
||
createNotFoundPage('Invalid proxy url');
|
||
logger.debug('no stat', objectName, owner, req.url);
|
||
return true;
|
||
}
|
||
const permissionInstance = new UserPermission({ permission: stat.metaData as Permission, owner: owner });
|
||
const checkPermission = permissionInstance.checkPermissionSuccess({
|
||
username: loginUser?.tokenUser?.username || '',
|
||
password: password,
|
||
});
|
||
if (!checkPermission.success) {
|
||
logger.info('no permission', checkPermission, loginUser, owner);
|
||
return createNotFoundPage('no permission');
|
||
}
|
||
if (hash && stat.etag === hash) {
|
||
res.writeHead(304); // not modified
|
||
res.end('not modified');
|
||
return true;
|
||
}
|
||
const filterMetaData = filterKeys(stat.metaData, ['size', 'etag', 'last-modified']);
|
||
const contentLength = stat.size;
|
||
const etag = stat.etag;
|
||
const lastModified = stat.lastModified.toISOString();
|
||
|
||
const objectStream = await minioClient.getObject(bucketName, objectName);
|
||
const headers = {
|
||
'Content-Length': contentLength,
|
||
etag,
|
||
'last-modified': lastModified,
|
||
...filterMetaData,
|
||
};
|
||
|
||
res.writeHead(200, {
|
||
...headers,
|
||
});
|
||
objectStream.pipe(res, { end: true });
|
||
return true;
|
||
} catch (error) {
|
||
console.error(`Proxy request error: ${error.message}`);
|
||
createNotFoundPage('Invalid ai proxy url');
|
||
return false;
|
||
}
|
||
};
|
||
export const getMetadata = (pathname: string) => {
|
||
let meta: any = { 'app-source': 'user-app' };
|
||
const isHtml = pathname.endsWith('.html');
|
||
if (isHtml) {
|
||
meta = {
|
||
...meta,
|
||
'content-type': 'text/html; charset=utf-8',
|
||
'cache-control': 'no-cache',
|
||
};
|
||
} else {
|
||
meta = {
|
||
...meta,
|
||
'content-type': getContentType(pathname),
|
||
'cache-control': 'max-age=31536000, immutable',
|
||
};
|
||
}
|
||
return meta;
|
||
};
|
||
|
||
export const postProxy = async (req: IncomingMessage, res: ServerResponse, opts: ProxyOptions) => {
|
||
const _u = new URL(req.url, 'http://localhost');
|
||
|
||
const pathname = _u.pathname;
|
||
const oss = opts.oss;
|
||
const params = _u.searchParams;
|
||
const force = !!params.get('force');
|
||
const hash = params.get('hash');
|
||
const _fileSize: string = params.get('size');
|
||
let fileSize: number | undefined = undefined;
|
||
if (_fileSize) {
|
||
fileSize = parseInt(_fileSize, 10)
|
||
}
|
||
let meta = parseSearchValue(params.get('meta'), { decode: true });
|
||
if (!hash && !force) {
|
||
return opts?.createNotFoundPage?.('no hash');
|
||
}
|
||
const { objectName, isOwner } = await getObjectName(req);
|
||
if (!isOwner) {
|
||
return opts?.createNotFoundPage?.('no permission');
|
||
}
|
||
const end = (data: any, message?: string, code = 200) => {
|
||
res.writeHead(code, { 'Content-Type': 'application/json' });
|
||
res.end(JSON.stringify({ code: code, data: data, message: message || 'success' }));
|
||
};
|
||
let statMeta: any = {};
|
||
if (!force) {
|
||
const check = await oss.checkObjectHash(objectName, hash, meta);
|
||
statMeta = check?.metaData || {};
|
||
let isNewMeta = false;
|
||
if (check.success && JSON.stringify(meta) !== '{}' && !check.equalMeta) {
|
||
meta = { ...statMeta, ...getMetadata(pathname), ...meta };
|
||
isNewMeta = true;
|
||
await oss.replaceObject(objectName, { ...meta });
|
||
}
|
||
if (check.success) {
|
||
return end({ success: true, hash, meta, isNewMeta, equalMeta: check.equalMeta }, '文件已存在');
|
||
}
|
||
}
|
||
const bb = busboy({
|
||
headers: req.headers,
|
||
limits: {
|
||
fileSize: 100 * 1024 * 1024, // 100MB
|
||
files: 1,
|
||
},
|
||
});
|
||
let fileProcessed = false;
|
||
bb.on('file', async (name, file, info) => {
|
||
fileProcessed = true;
|
||
try {
|
||
await oss.putObject(
|
||
objectName,
|
||
file,
|
||
{
|
||
...statMeta,
|
||
...getMetadata(pathname),
|
||
...meta,
|
||
},
|
||
{ check: false, isStream: true, size: fileSize },
|
||
);
|
||
end({ success: true, name, info, isNew: true, hash, meta: meta?.metaData, statMeta }, '上传成功', 200);
|
||
|
||
} catch (error) {
|
||
end({ error: error }, '上传失败', 500);
|
||
}
|
||
});
|
||
|
||
bb.on('finish', () => {
|
||
// 只有当没有文件被处理时才执行end
|
||
if (!fileProcessed) {
|
||
end({ success: false }, '没有接收到文件', 400);
|
||
}
|
||
});
|
||
bb.on('error', (err) => {
|
||
console.error('Busboy 错误:', err);
|
||
end({ error: err }, '文件解析失败', 500);
|
||
});
|
||
|
||
req.pipe(bb);
|
||
};
|
||
export const getObjectName = async (req: IncomingMessage, opts?: { checkOwner?: boolean }) => {
|
||
const _u = new URL(req.url, 'http://localhost');
|
||
const pathname = decodeURIComponent(_u.pathname);
|
||
const params = _u.searchParams;
|
||
const { user, app } = getUserFromRequest(req);
|
||
const checkOwner = opts?.checkOwner ?? true;
|
||
let objectName = '';
|
||
let owner = '';
|
||
if (app === 'ai') {
|
||
const version = params.get('version') || '1.0.0'; // root/ai
|
||
objectName = pathname.replace(`/${user}/${app}/`, `${user}/${app}/${version}/`);
|
||
} else {
|
||
objectName = pathname.replace(`/${user}/${app}/`, `${user}/`); // root/resources
|
||
}
|
||
owner = user;
|
||
let isOwner = undefined;
|
||
let loginUser: Awaited<ReturnType<typeof getLoginUser>> = null;
|
||
if (checkOwner) {
|
||
loginUser = await getLoginUser(req);
|
||
logger.debug('getObjectName', loginUser, user, app);
|
||
isOwner = loginUser?.tokenUser?.username === owner;
|
||
}
|
||
return {
|
||
objectName,
|
||
loginUser,
|
||
owner,
|
||
isOwner,
|
||
app,
|
||
user,
|
||
};
|
||
};
|
||
export const deleteProxy = async (req: IncomingMessage, res: ServerResponse, opts: ProxyOptions) => {
|
||
const { objectName, isOwner } = await getObjectName(req);
|
||
let oss = opts.oss;
|
||
if (!isOwner) {
|
||
return opts?.createNotFoundPage?.('no permission');
|
||
}
|
||
try {
|
||
await oss.deleteObject(objectName);
|
||
res.writeHead(200, { 'Content-Type': 'application/json' });
|
||
res.end(JSON.stringify({ success: true, message: 'delete success', objectName }));
|
||
} catch (error) {
|
||
logger.error('deleteProxy error', error);
|
||
res.writeHead(500, { 'Content-Type': 'application/json' });
|
||
res.end(JSON.stringify({ success: false, error: error }));
|
||
}
|
||
};
|
||
|
||
type ProxyOptions = {
|
||
createNotFoundPage: (msg?: string) => any;
|
||
oss?: OssBase;
|
||
};
|
||
export const aiProxy = async (req: IncomingMessage, res: ServerResponse, opts: ProxyOptions) => {
|
||
const oss = new OssBase({ bucketName, client: minioClient });
|
||
if (!opts.oss) {
|
||
opts.oss = oss;
|
||
}
|
||
if (req.method === 'POST') {
|
||
return postProxy(req, res, opts);
|
||
}
|
||
if (req.method === 'DELETE') {
|
||
return deleteProxy(req, res, opts);
|
||
}
|
||
|
||
return getAiProxy(req, res, opts);
|
||
};
|