cat-shark
575 lines
24 KiB
TypeScript
575 lines
24 KiB
TypeScript
import {Files} from "../mapi/file/main";
|
|
import {Log} from "../mapi/log/main";
|
|
import {SendType, ServerApiType, ServerFunctionDataType, ServerInfo} from "../mapi/server/type";
|
|
import {AigcServerUtil} from "./util";
|
|
import path from "path";
|
|
import {getFFmpegExecutablePath, resourceExists} from "../lib/resource-path";
|
|
|
|
type LauncherResultType = {
|
|
result: {
|
|
[key: string]: any;
|
|
};
|
|
endTime: number | null;
|
|
};
|
|
|
|
const normalizeEasyServerFunctions = (functions: Record<string, any> = {}) => {
|
|
const normalized = {
|
|
...functions,
|
|
};
|
|
if (normalized.speechRecognition && !normalized.asr) {
|
|
normalized.asr = normalized.speechRecognition;
|
|
}
|
|
return normalized;
|
|
};
|
|
|
|
export const EasyServer = function (config: any) {
|
|
const me = this;
|
|
let controller: any = null;
|
|
let controllerWatching = {
|
|
id: null as string | null,
|
|
launcherResult: null as LauncherResultType | null,
|
|
resolve: null as ((value: any) => void) | null,
|
|
reject: null as ((reason?: any) => void) | null,
|
|
promiseResolved: false,
|
|
};
|
|
const resetControllerWatching = () => {
|
|
controllerWatching.id = null;
|
|
controllerWatching.launcherResult = null;
|
|
controllerWatching.resolve = null;
|
|
controllerWatching.reject = null;
|
|
controllerWatching.promiseResolved = false;
|
|
};
|
|
const settleControllerWatching = async (type: "resolve" | "reject", reason?: any, stopController = false) => {
|
|
if (controllerWatching.promiseResolved) {
|
|
return;
|
|
}
|
|
controllerWatching.promiseResolved = true;
|
|
const resolve = controllerWatching.resolve;
|
|
const reject = controllerWatching.reject;
|
|
if (stopController && controller) {
|
|
const runningController = controller;
|
|
controller = null;
|
|
try {
|
|
await runningController.stop();
|
|
} catch (e) {
|
|
Log.warn("easyServer.settle.stop.error", e);
|
|
}
|
|
}
|
|
if (type === "resolve") {
|
|
resolve?.(undefined);
|
|
} else {
|
|
reject?.(reason);
|
|
}
|
|
};
|
|
this.serverConfig = {
|
|
...(config || {}),
|
|
easyServer: {
|
|
...(config?.easyServer || {}),
|
|
functions: normalizeEasyServerFunctions(config?.easyServer?.functions || {}),
|
|
},
|
|
} as {
|
|
easyServer: {
|
|
entry: string;
|
|
entryArgs: string[];
|
|
envs: string[];
|
|
content: string;
|
|
functions: {
|
|
[key: string]: {
|
|
content?: string;
|
|
param?: any[];
|
|
};
|
|
};
|
|
};
|
|
};
|
|
this.isRunning = false;
|
|
this.ServerApi = null as ServerApiType | null;
|
|
this.ServerInfo = null as ServerInfo | null;
|
|
this.serverRuntime = {
|
|
startTime: 0,
|
|
};
|
|
this.send = function (type: SendType, data: any) {
|
|
this.ServerApi.event.sendChannel(this.ServerInfo.eventChannelName, {type, data});
|
|
};
|
|
this.init = async function () {
|
|
};
|
|
this.config = async function () {
|
|
return {
|
|
code: 0,
|
|
msg: "ok",
|
|
data: {
|
|
httpUrl: null,
|
|
content: this.serverConfig.easyServer.content || "",
|
|
functions: this.serverConfig.easyServer.functions || {},
|
|
},
|
|
};
|
|
};
|
|
this.start = async function () {
|
|
// console.log('start', this.ServerInfo)
|
|
this.serverRuntime.startTime = Date.now();
|
|
this.send("starting", this.ServerInfo);
|
|
};
|
|
this.ping = async function (): Promise<boolean> {
|
|
// console.log('ping', this.ServerInfo)
|
|
return this.serverRuntime.startTime > 0;
|
|
};
|
|
this.stop = async function () {
|
|
// console.log('stop', this.ServerInfo)
|
|
this.send("stopping", this.ServerInfo);
|
|
this.serverRuntime.startTime = 0;
|
|
if (controller) {
|
|
try {
|
|
await controller.stop();
|
|
} catch (e) {
|
|
Log.warn("easyServer.stop.error", e);
|
|
}
|
|
controller = null;
|
|
}
|
|
this.send("stopped", this.ServerInfo);
|
|
this.send("success", this.ServerInfo);
|
|
};
|
|
this.cancel = async function () {
|
|
if (controller) {
|
|
await controller.stop();
|
|
controller = null;
|
|
}
|
|
};
|
|
this._controllerRunIfNeeded = async function (
|
|
configJsonPath: string | null,
|
|
option: {
|
|
timeout: number;
|
|
}
|
|
) {
|
|
if (!controller) {
|
|
const _localPath = this.ServerInfo?.localPath || '';
|
|
Log.info("[EasyServer] ServerInfo.localPath", _localPath);
|
|
let command = [];
|
|
command.push(this.serverConfig.easyServer.entry);
|
|
if (this.serverConfig.easyServer.entryArgs) {
|
|
command = command.concat(this.serverConfig.easyServer.entryArgs);
|
|
}
|
|
for (let i = 0; i < command.length; i++) {
|
|
command[i] = command[i].replace("${CONFIG}", `"${configJsonPath}"`);
|
|
command[i] = command[i].replace("${ROOT}", _localPath);
|
|
}
|
|
Log.info("[EasyServer] command", JSON.stringify(command));
|
|
Log.info("[EasyServer] localPath", this.ServerInfo.localPath);
|
|
const envMap = {};
|
|
Log.info('EasyServer.config', JSON.stringify(this.serverConfig.easyServer));
|
|
if (this.serverConfig.easyServer.entry === "launcher") {
|
|
const systemEnv = await this.ServerApi.env();
|
|
// console.log('EasyServer.systemEnv', systemEnv)
|
|
for (const k in systemEnv) {
|
|
envMap[k] = systemEnv[k];
|
|
}
|
|
}
|
|
// 🔧 修复：添加 FFmpeg 目录到 PATH，让 Python 脚本能找到 ffmpeg
|
|
const pathDirs = [
|
|
`${this.ServerInfo.localPath}`,
|
|
`${this.ServerInfo.localPath}/binary`,
|
|
];
|
|
const ffmpegPath = getFFmpegExecutablePath();
|
|
if (resourceExists(ffmpegPath)) {
|
|
const ffmpegDir = path.dirname(ffmpegPath);
|
|
pathDirs.push(ffmpegDir);
|
|
Log.info(`[EasyServer] ✓ 已添加 FFmpeg 目录到 PATH: ${ffmpegDir}`);
|
|
}
|
|
envMap["PATH"] = this.ServerApi.getPathEnv(pathDirs);
|
|
envMap["PYTHONIOENCODING"] = "utf-8";
|
|
envMap["AIGCPANEL_SERVER_PLACEHOLDER_CONFIG"] = configJsonPath;
|
|
envMap["AIGCPANEL_SERVER_PLACEHOLDER_ROOT"] = this.ServerInfo.localPath;
|
|
if (this.serverConfig.easyServer.envs) {
|
|
for (const e of this.serverConfig.easyServer.envs) {
|
|
let pcs = e.split("=");
|
|
const key = pcs.shift();
|
|
envMap[key] = pcs.join("=");
|
|
}
|
|
}
|
|
for (const k in envMap) {
|
|
envMap[k] = envMap[k].replace("${CONFIG}", `"${configJsonPath}"`);
|
|
envMap[k] = envMap[k].replace("${ROOT}", this.ServerInfo.localPath);
|
|
}
|
|
const hasMoreQueue = async () => {
|
|
const queueRoot = this.ServerInfo.localPath + `/aigcpanel-queue/`;
|
|
await Files.mkdir(queueRoot);
|
|
const files = await Files.list(queueRoot);
|
|
const validQueueFiles = files.filter(f => f.name.match(/\.queue\.json$/));
|
|
if (validQueueFiles.length > 0) {
|
|
const configJson = await Files.temp("json");
|
|
await Files.copy(validQueueFiles[0].pathname, configJson);
|
|
await Files.deletes(validQueueFiles[0].pathname);
|
|
await this._controllerRunIfNeeded(configJson, option);
|
|
}
|
|
};
|
|
let timer = null;
|
|
if (option.timeout > 0) {
|
|
timer = setTimeout(async () => {
|
|
this.ServerApi.file.appendText(this.ServerInfo.logFile, "timeout", {isDataPath: true});
|
|
await settleControllerWatching("reject", new Error("timeout"), true);
|
|
}, option.timeout * 1000);
|
|
}
|
|
let buffer = "";
|
|
controller = await this.ServerApi.app.spawnShell(command, {
|
|
env: envMap,
|
|
cwd: this.ServerInfo.localPath,
|
|
stdout: _data => {
|
|
// console.log('easyServer.stdout', _data)
|
|
buffer += _data;
|
|
// check if has \n and process the buffer
|
|
let lines = buffer.split("\n");
|
|
buffer = lines.pop() || "";
|
|
this.ServerApi.file.appendText(this.ServerInfo.logFile, _data, {isDataPath: true});
|
|
|
|
// 鍙戦€佹棩蹇楀埌鍓嶇UI
|
|
if (controllerWatching.id) {
|
|
this.send("taskLog", {
|
|
id: controllerWatching.id,
|
|
type: "stdout",
|
|
data: _data,
|
|
timestamp: Date.now()
|
|
});
|
|
}
|
|
|
|
const result = this.ServerApi.extractResultFromLogs(controllerWatching.id, lines.join("\n") + "\n");
|
|
if (result) {
|
|
if (controllerWatching.launcherResult) {
|
|
controllerWatching.launcherResult.result = Object.assign(controllerWatching.launcherResult.result, result);
|
|
}
|
|
if (controllerWatching.id) {
|
|
this.send("taskResult", {id: controllerWatching.id, result});
|
|
}
|
|
}
|
|
if (controllerWatching.launcherResult) {
|
|
controllerWatching.launcherResult.result.error =
|
|
AigcServerUtil.errorDetect(_data) || controllerWatching.launcherResult.result.error;
|
|
// 馃敡 淇锛氬彧鏈夊湪End=true涓斿凡缁忔湁鏈夋晥缁撴灉(url/records/error)鏃舵墠resolve
|
|
if (controllerWatching.launcherResult.result && controllerWatching.launcherResult.result['End']) {
|
|
const hasValidResult =
|
|
controllerWatching.launcherResult.result.url ||
|
|
controllerWatching.launcherResult.result.records ||
|
|
controllerWatching.launcherResult.result.error;
|
|
if (hasValidResult) {
|
|
settleControllerWatching("resolve", undefined, true).then();
|
|
}
|
|
}
|
|
}
|
|
},
|
|
stderr: _data => {
|
|
// console.log('easyServer.stderr', _data)
|
|
this.ServerApi.file.appendText(this.ServerInfo.logFile, _data, {isDataPath: true});
|
|
|
|
// 鍙戦€佹棩蹇楀埌鍓嶇UI
|
|
if (controllerWatching.id) {
|
|
this.send("taskLog", {
|
|
id: controllerWatching.id,
|
|
type: "stderr",
|
|
data: _data,
|
|
timestamp: Date.now()
|
|
});
|
|
}
|
|
|
|
if (controllerWatching.launcherResult) {
|
|
controllerWatching.launcherResult.result.error =
|
|
AigcServerUtil.errorDetect(_data) || controllerWatching.launcherResult.result.error;
|
|
}
|
|
},
|
|
success: _data => {
|
|
// console.log('easyServer.success', _data)
|
|
clearTimeout(timer);
|
|
controller = null;
|
|
hasMoreQueue().then()
|
|
settleControllerWatching("resolve").then();
|
|
},
|
|
error: (_data, code) => {
|
|
// console.log('easyServer.error', {_data, controllerWatching})
|
|
this.ServerApi.file.appendText(this.ServerInfo.logFile, `exit code ${code}`, {isDataPath: true});
|
|
clearTimeout(timer);
|
|
controller = null;
|
|
hasMoreQueue().then()
|
|
settleControllerWatching("reject").then();
|
|
},
|
|
})
|
|
} else if (configJsonPath) {
|
|
const queueName = `${Date.now()}.queue.json`;
|
|
const queuePath = this.ServerInfo.localPath + `/aigcpanel-queue/${queueName}`;
|
|
await Files.copy(configJsonPath, queuePath);
|
|
this.ServerApi.file.appendText(
|
|
this.ServerInfo.logFile,
|
|
`Another task is running, queued at ${queueName}`,
|
|
{isDataPath: true}
|
|
);
|
|
}
|
|
};
|
|
this._callFunc = async function (
|
|
data: ServerFunctionDataType,
|
|
configCalculator: (data: ServerFunctionDataType) => Promise<any>,
|
|
resultDataCalculator: (data: ServerFunctionDataType, launcherResult: LauncherResultType) => Promise<any>,
|
|
option: {
|
|
timeout: number;
|
|
}
|
|
) {
|
|
option = Object.assign(
|
|
{
|
|
timeout: 24 * 3600,
|
|
},
|
|
option
|
|
);
|
|
const resultData = {
|
|
// success, retry
|
|
type: "success",
|
|
start: 0,
|
|
end: 0,
|
|
data: {},
|
|
};
|
|
if (this.isRunning) {
|
|
resultData.type = "retry";
|
|
return {
|
|
code: 0,
|
|
msg: "ok",
|
|
data: resultData,
|
|
};
|
|
}
|
|
this.isRunning = true;
|
|
resultData.start = Date.now();
|
|
let configJsonPath = null;
|
|
try {
|
|
this.send("taskRunning", {id: data.id});
|
|
const configData = await configCalculator(data);
|
|
configData.setting = this.ServerInfo.setting;
|
|
configJsonPath = await this.ServerApi.launcherPrepareConfigJson(configData);
|
|
// console.log('EasyServer.envMap', envMap)
|
|
const launcherResult: LauncherResultType = {
|
|
result: {},
|
|
endTime: null,
|
|
};
|
|
// console.log('easyServer.start', JSON.stringify({command, envMap, configData}))
|
|
await (async () => {
|
|
return new Promise((resolve, reject) => {
|
|
controllerWatching.id = data.id;
|
|
controllerWatching.launcherResult = launcherResult;
|
|
controllerWatching.resolve = resolve;
|
|
controllerWatching.reject = reject;
|
|
controllerWatching.promiseResolved = false;
|
|
me._controllerRunIfNeeded(configJsonPath, option);
|
|
});
|
|
})();
|
|
resultData.end = Date.now();
|
|
resultData.data = await resultDataCalculator(data, launcherResult);
|
|
// console.log('easyServer.end', launcherResult)
|
|
await Files.deletes(configJsonPath);
|
|
return {
|
|
code: 0,
|
|
msg: "ok",
|
|
data: resultData,
|
|
};
|
|
} catch (e) {
|
|
throw e;
|
|
} finally {
|
|
resetControllerWatching();
|
|
this.isRunning = false;
|
|
}
|
|
};
|
|
this.soundTts = async function (data: ServerFunctionDataType) {
|
|
// console.log('soundTts', {data, serverInfo: this.ServerInfo})
|
|
return this._callFunc(
|
|
data,
|
|
async (data: ServerFunctionDataType) => {
|
|
return {
|
|
id: data.id,
|
|
mode: "local",
|
|
modelConfig: {
|
|
type: "soundTts",
|
|
param: data.param,
|
|
text: data.text,
|
|
},
|
|
};
|
|
},
|
|
async (data: ServerFunctionDataType, launcherResult: LauncherResultType) => {
|
|
// 馃敡 淇锛氬拷鐣?{"End": true} 缁撴潫鏍囧織,鍙鏌ョ湡姝ｇ殑閿欒
|
|
if (!("url" in launcherResult.result)) {
|
|
// 濡傛灉鏄疎nd鏍囧織,鐩存帴杩斿洖鐜版湁缁撴灉(涓嶆姤閿?
|
|
if (launcherResult.result.End === true) {
|
|
return launcherResult.result;
|
|
}
|
|
if (launcherResult.result.error) {
|
|
throw launcherResult.result.error;
|
|
}
|
|
throw "鎵ц澶辫触锛岃鏌ョ湅妯″瀷鏃ュ織";
|
|
}
|
|
return {
|
|
url: launcherResult.result.url,
|
|
};
|
|
}
|
|
);
|
|
};
|
|
this.soundClone = async function (data: ServerFunctionDataType) {
|
|
// console.log('soundClone', {data, serverInfo: this.ServerInfo})
|
|
return this._callFunc(
|
|
data,
|
|
async (data: ServerFunctionDataType) => {
|
|
return {
|
|
id: data.id,
|
|
mode: "local",
|
|
modelConfig: {
|
|
type: "soundClone",
|
|
param: data.param,
|
|
text: data.text,
|
|
promptAudio: data.promptAudio,
|
|
promptText: data.promptText,
|
|
},
|
|
};
|
|
},
|
|
async (data: ServerFunctionDataType, launcherResult: LauncherResultType) => {
|
|
// 馃敡 淇锛氬拷鐣?{"End": true} 缁撴潫鏍囧織,鍙鏌ョ湡姝ｇ殑閿欒
|
|
if (!("url" in launcherResult.result)) {
|
|
// 濡傛灉鏄疎nd鏍囧織,鐩存帴杩斿洖鐜版湁缁撴灉(涓嶆姤閿?
|
|
if (launcherResult.result.End === true) {
|
|
return launcherResult.result;
|
|
}
|
|
if (launcherResult.result.error) {
|
|
throw launcherResult.result.error;
|
|
}
|
|
throw "鎵ц澶辫触锛岃鏌ョ湅妯″瀷鏃ュ織";
|
|
}
|
|
return {
|
|
url: launcherResult.result.url,
|
|
};
|
|
}
|
|
);
|
|
};
|
|
this.videoGen = async function (data: ServerFunctionDataType) {
|
|
// console.log('videoGen', JSON.stringify({data, serverInfo: this.ServerInfo}))
|
|
return this._callFunc(
|
|
data,
|
|
async (data: ServerFunctionDataType) => {
|
|
return {
|
|
id: data.id,
|
|
mode: "local",
|
|
modelConfig: {
|
|
type: "videoGen",
|
|
param: data.param,
|
|
video: data.video,
|
|
audio: data.audio,
|
|
},
|
|
};
|
|
},
|
|
async (data: ServerFunctionDataType, launcherResult: LauncherResultType) => {
|
|
// 馃敡 淇锛氬拷鐣?{"End": true} 缁撴潫鏍囧織,鍙鏌ョ湡姝ｇ殑閿欒
|
|
if (!("url" in launcherResult.result)) {
|
|
// 濡傛灉鏄疎nd鏍囧織,鐩存帴杩斿洖鐜版湁缁撴灉(涓嶆姤閿?
|
|
if (launcherResult.result.End === true) {
|
|
return launcherResult.result;
|
|
}
|
|
if (launcherResult.result.error) {
|
|
throw launcherResult.result.error;
|
|
}
|
|
throw "鎵ц澶辫触锛岃鏌ョ湅妯″瀷鏃ュ織";
|
|
}
|
|
return {
|
|
url: launcherResult.result.url,
|
|
};
|
|
}
|
|
);
|
|
};
|
|
this.asr = async function (data: ServerFunctionDataType) {
|
|
// console.log('videoGen', JSON.stringify({data, serverInfo: this.ServerInfo}))
|
|
return this._callFunc(
|
|
data,
|
|
async (data: ServerFunctionDataType) => {
|
|
return {
|
|
id: data.id,
|
|
mode: "local",
|
|
modelConfig: {
|
|
type: 'asr',
|
|
audio: data.audio,
|
|
param: data.param,
|
|
},
|
|
};
|
|
},
|
|
async (data: ServerFunctionDataType, launcherResult: LauncherResultType) => {
|
|
// 馃敡 淇锛氬拷鐣?{"End": true} 缁撴潫鏍囧織,鍙鏌ョ湡姝ｇ殑閿欒
|
|
if (!("records" in launcherResult.result)) {
|
|
// 濡傛灉鏄疎nd鏍囧織,鐩存帴杩斿洖鐜版湁缁撴灉(涓嶆姤閿?
|
|
if (launcherResult.result.End === true) {
|
|
return launcherResult.result;
|
|
}
|
|
if (launcherResult.result.error) {
|
|
throw launcherResult.result.error;
|
|
}
|
|
throw "鎵ц澶辫触锛岃鏌ョ湅妯″瀷鏃ュ織";
|
|
}
|
|
return {
|
|
records: launcherResult.result.records,
|
|
};
|
|
}
|
|
);
|
|
};
|
|
this.textToImage = async function (data: ServerFunctionDataType) {
|
|
// console.log('textToImage', {data, serverInfo: this.ServerInfo})
|
|
return this._callFunc(
|
|
data,
|
|
async (data: ServerFunctionDataType) => {
|
|
return {
|
|
id: data.id,
|
|
mode: "local",
|
|
modelConfig: {
|
|
type: "textToImage",
|
|
prompt: data.prompt,
|
|
param: data.param,
|
|
},
|
|
};
|
|
},
|
|
async (data: ServerFunctionDataType, launcherResult: LauncherResultType) => {
|
|
// 馃敡 淇锛氬拷鐣?{"End": true} 缁撴潫鏍囧織,鍙鏌ョ湡姝ｇ殑閿欒
|
|
if (!("url" in launcherResult.result)) {
|
|
// 濡傛灉鏄疎nd鏍囧織,鐩存帴杩斿洖鐜版湁缁撴灉(涓嶆姤閿?
|
|
if (launcherResult.result.End === true) {
|
|
return launcherResult.result;
|
|
}
|
|
if (launcherResult.result.error) {
|
|
throw launcherResult.result.error;
|
|
}
|
|
throw "鎵ц澶辫触锛岃鏌ョ湅妯″瀷鏃ュ織";
|
|
}
|
|
return {
|
|
url: launcherResult.result.url,
|
|
};
|
|
}
|
|
);
|
|
};
|
|
this.imageToImage = async function (data: ServerFunctionDataType) {
|
|
// console.log('imageToImage', {data, serverInfo: this.ServerInfo})
|
|
return this._callFunc(
|
|
data,
|
|
async (data: ServerFunctionDataType) => {
|
|
return {
|
|
id: data.id,
|
|
mode: "local",
|
|
modelConfig: {
|
|
type: "imageToImage",
|
|
image: data.image,
|
|
prompt: data.prompt,
|
|
param: data.param,
|
|
},
|
|
};
|
|
},
|
|
async (data: ServerFunctionDataType, launcherResult: LauncherResultType) => {
|
|
// 馃敡 淇锛氬拷鐣?{"End": true} 缁撴潫鏍囧織,鍙鏌ョ湡姝ｇ殑閿欒
|
|
if (!("url" in launcherResult.result)) {
|
|
// 濡傛灉鏄疎nd鏍囧織,鐩存帴杩斿洖鐜版湁缁撴灉(涓嶆姤閿?
|
|
if (launcherResult.result.End === true) {
|
|
return launcherResult.result;
|
|
}
|
|
if (launcherResult.result.error) {
|
|
throw launcherResult.result.error;
|
|
}
|
|
throw "鎵ц澶辫触锛岃鏌ョ湅妯″瀷鏃ュ織";
|
|
}
|
|
return {
|
|
url: launcherResult.result.url,
|
|
};
|
|
}
|
|
);
|
|
};
|
|
};
|
|
|