mirror of
https://git.datalinker.icu/comfyanonymous/ComfyUI
synced 2026-11-20 21:57:05 +08:00
258 lines
9.5 KiB
Python
258 lines
9.5 KiB
Python
from ai_api import (queue_prompt,
|
|
get_history,
|
|
get_queue_state,
|
|
get_parsed_input_nodes,
|
|
parse_workflow_prompt,
|
|
parse_outputs,
|
|
save_binary_file)
|
|
import asyncio
|
|
import aiohttp
|
|
import logging
|
|
from aiohttp import web
|
|
import json, os
|
|
|
|
class BridgeServer():
|
|
|
|
def __init__(self, loop, server_address:list) -> None:
|
|
self.sockets_res = {}
|
|
self.sockets_req = {}
|
|
self.sid_server_map = {}
|
|
self.ws_connection_status = {}
|
|
self.loop = loop
|
|
self.server_address = server_address
|
|
|
|
async def send_socket_catch_exception(self, sid, message):
|
|
try:
|
|
await self.sockets_res[sid].send_json(message)
|
|
self.ws_connection_status[sid] = message.get("status", None)
|
|
except (aiohttp.ClientError, aiohttp.ClientPayloadError, ConnectionResetError) as err:
|
|
logging.warning(f"send error: {err} / {message}")
|
|
|
|
async def init_app(self):
|
|
app = web.Application()
|
|
app.add_routes([
|
|
web.post('/generate-based-workflow', self.generate_based_workflow),
|
|
web.get('/ws', self.websocket_connection),
|
|
web.get("/", self.main_page),
|
|
web.get("/history", self.get_history),
|
|
web.post("/upload/image", self.upload_image),
|
|
web.post("/workflow-info", self.workflow_info)
|
|
])
|
|
return app
|
|
|
|
async def track_progress(self, sid):
|
|
ws_req = self.sockets_req[sid]
|
|
finished_nodes = []
|
|
|
|
while True:
|
|
out = await ws_req.receive()
|
|
out = out.data
|
|
|
|
if isinstance(out, str):
|
|
message = json.loads(out)
|
|
if message['type'] == 'progress':
|
|
data = message['data']
|
|
current_step = data['value']
|
|
progress_message = {
|
|
'status': 'progress_update',
|
|
'details': f'In K-Sampler -> Step: {current_step} of {data["max"]}'
|
|
}
|
|
await self.send_socket_catch_exception(sid, progress_message)
|
|
|
|
if message['type'] == 'execution_cached':
|
|
data = message['data']
|
|
for itm in data['nodes']:
|
|
if itm not in finished_nodes:
|
|
finished_nodes.append(itm)
|
|
progress_message = {
|
|
'status': 'progress_update',
|
|
'details': f'Progress: {len(finished_nodes)} / {len(data['nodes'])} Tasks done'
|
|
}
|
|
await self.send_socket_catch_exception(sid, progress_message)
|
|
|
|
if message['type'] == 'executing':
|
|
data = message['data']
|
|
if data['node'] not in finished_nodes:
|
|
finished_nodes.append(data['node'])
|
|
progress_message = {
|
|
'status': 'progress_update',
|
|
'details': f'Progress: {len(finished_nodes)} / ) Tasks done'
|
|
}
|
|
await self.send_socket_catch_exception(sid, progress_message)
|
|
|
|
if data['node'] is None and data['prompt_id'] == sid:
|
|
completion_message = {
|
|
'status': 'closed',
|
|
'details': 'Execution is done'
|
|
}
|
|
await self.send_socket_catch_exception(sid, completion_message)
|
|
break # Execution is done
|
|
elif out == None:
|
|
completion_message = {
|
|
'status': 'closed',
|
|
'details': 'comfy ui out is None'
|
|
}
|
|
await self.send_socket_catch_exception(sid, completion_message)
|
|
break
|
|
else:
|
|
continue
|
|
return
|
|
|
|
|
|
async def websocket_connection(self, request):
|
|
sid = request.rel_url.query.get('clientId', '')
|
|
|
|
async with aiohttp.ClientSession() as session:
|
|
server_address = await self.get_not_busy_server_address()
|
|
self.sid_server_map[sid] = server_address
|
|
|
|
ws_res = web.WebSocketResponse()
|
|
ws_req = await session.ws_connect(f"ws://{server_address}/ws?clientId={sid}")
|
|
|
|
self.sockets_res[sid] = ws_res
|
|
self.sockets_req[sid] = ws_req
|
|
|
|
try:
|
|
await self.sockets_res[sid].prepare(request)
|
|
|
|
await self.send_socket_catch_exception(sid, {"status":"connected", "details":"web socket connected"})
|
|
self.ws_connection_status[sid] = "connected"
|
|
|
|
task = asyncio.create_task(self.track_progress(sid))
|
|
|
|
while True:
|
|
out = await ws_res.receive()
|
|
out = out.data
|
|
|
|
if isinstance(out, str):
|
|
message = json.loads(out)
|
|
if message['status'] == 'error':
|
|
break
|
|
if self.ws_connection_status[sid] == "closed":
|
|
break
|
|
|
|
await task
|
|
|
|
except aiohttp.ServerDisconnectedError as e:
|
|
await self.send_socket_catch_exception(sid, {"status":"error", "details":"server disconnected"})
|
|
|
|
except Exception as e:
|
|
await self.send_socket_catch_exception(sid, {"status":"error", "details":str(e)})
|
|
|
|
finally:
|
|
await self.send_socket_catch_exception(sid, {"status":"closed", "details":"connection will be closed"})
|
|
await self.sockets_req[sid].close()
|
|
await self.sockets_res[sid].close()
|
|
self.sockets_req.pop(sid, None)
|
|
self.sockets_res.pop(sid, None)
|
|
self.ws_connection_status.pop(sid, None)
|
|
|
|
async def get_not_busy_server_address(self):
|
|
queue_lenghs = []
|
|
for server_address in self.server_address:
|
|
try:
|
|
queue_state = get_queue_state(server_address)
|
|
except Exception as e:
|
|
print(f"{server_address} in error {e}")
|
|
|
|
queue_length = sum([len(cur) for cur in queue_state.values()])
|
|
queue_lenghs.append(queue_length)
|
|
|
|
target_server_address = self.server_address[queue_lenghs.index(min(queue_lenghs))]
|
|
|
|
return target_server_address
|
|
|
|
async def generate_based_workflow(self, request):
|
|
data = await request.json()
|
|
sid = request.rel_url.query.get('clientId', '')
|
|
|
|
workflow = data.pop("workflow", None)
|
|
kwargs = data
|
|
|
|
prompt = parse_workflow_prompt(workflow, **kwargs)
|
|
prompt = queue_prompt(prompt, sid, self.sid_server_map[sid])
|
|
|
|
return web.Response(status=200)
|
|
|
|
async def upload_image(self, request):
|
|
reader = await request.multipart()
|
|
|
|
fns={}
|
|
async for part in reader:
|
|
file_name = part.headers.get('Content-Disposition', '').split('filename=')[1].strip('"')
|
|
file_data = await part.read()
|
|
|
|
fn = save_binary_file(file_data, file_name)
|
|
fns[part.headers.get("ori_file_id", None)] = fn
|
|
|
|
return web.Response(
|
|
status=200,
|
|
body=json.dumps(fns),
|
|
headers={"Content-Type": "application/json"}
|
|
)
|
|
|
|
async def get_history(self, request):
|
|
sid = request.rel_url.query.get('clientId', '')
|
|
|
|
history = get_history(sid, self.sid_server_map[sid])
|
|
history = history.get(sid, None)
|
|
self.sid_server_map.pop(sid, None)
|
|
|
|
if history is not None:
|
|
output = history["outputs"],
|
|
if isinstance(output, tuple):
|
|
output = (output)
|
|
|
|
writer = aiohttp.MultipartWriter("form-data")
|
|
|
|
file_paths, mime_types, file_contents = parse_outputs(output[0])
|
|
for file_path, mime_type, file_content in zip(file_paths, mime_types, file_contents):
|
|
|
|
headers = {'Content-Type': mime_type, 'Content-Disposition': f'attachment; filename="{file_path.split("/")[-1]}"'}
|
|
writer.append(file_content, headers)
|
|
|
|
headers = {
|
|
'Content-Type': writer.content_type,
|
|
}
|
|
|
|
return web.Response(
|
|
status=200,
|
|
body=writer,
|
|
headers=headers
|
|
)
|
|
else:
|
|
return web.Response(
|
|
status=204,
|
|
text="No contents with that client id."
|
|
)
|
|
|
|
async def workflow_info(self, request):
|
|
data = await request.json()
|
|
|
|
workflow = data.pop("workflow", None)
|
|
node_info = get_parsed_input_nodes(workflow)
|
|
|
|
return web.Response(status=200, body=json.dumps(node_info), content_type="application/json")
|
|
|
|
async def main_page(self, request):
|
|
return web.Response(text="Hello, this is Favorfit Bridge Server!")
|
|
|
|
def main():
|
|
from dotenv import load_dotenv
|
|
load_dotenv()
|
|
|
|
servers_str = os.getenv('COMFYUI_SERVERS')
|
|
host = os.getenv("HOST")
|
|
port = os.getenv("PORT")
|
|
|
|
server_list = servers_str.split(',') if servers_str else []
|
|
|
|
loop = asyncio.get_event_loop()
|
|
server = BridgeServer(loop, server_list)
|
|
app = loop.run_until_complete(server.init_app())
|
|
web.run_app(app, host=host, port=int(port))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|