From c9747eeb7f6ad27fa118b5bdd8d8da32b7cef15e Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Tue, 29 Apr 2025 14:36:01 +0000 Subject: [PATCH 01/27] base image update --- omnitool/omnibox/Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/omnitool/omnibox/Dockerfile b/omnitool/omnibox/Dockerfile index b464714a..dc67536b 100644 --- a/omnitool/omnibox/Dockerfile +++ b/omnitool/omnibox/Dockerfile @@ -1,7 +1,7 @@ ARG VERSION_ARG="latest" FROM scratch AS build-amd64 -COPY --from=qemux/qemu-docker:6.08 / / +COPY --from=qemux/qemu:6.18 / / ARG DEBCONF_NOWARNINGS="yes" ARG DEBIAN_FRONTEND="noninteractive" From 05c417fdb385540c18896a512c138b84ed124753 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Tue, 29 Apr 2025 14:36:48 +0000 Subject: [PATCH 02/27] vanilla omniboxes --- .../scripts/omniboxes/OmniBoxes/Dockerfile | 48 +++++ .../scripts/omniboxes/OmniBoxes/cleanall | 10 ++ .../scripts/omniboxes/OmniBoxes/command.txt | 1 + .../scripts/omniboxes/OmniBoxes/compose.yml | 23 +++ .../scripts/omniboxes/OmniBoxes/manageall.py | 121 +++++++++++++ .../omniboxes/OmniBoxes/manageinstance.py | 164 ++++++++++++++++++ .../omniboxes/OmniBoxes/requirements.txt | 3 + 7 files changed, 370 insertions(+) create mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/Dockerfile create mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/cleanall create mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/command.txt create mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/compose.yml create mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageall.py create mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageinstance.py create mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/requirements.txt diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/Dockerfile b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/Dockerfile new file mode 100644 index 00000000..b464714a --- /dev/null +++ b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/Dockerfile @@ -0,0 +1,48 @@ +ARG VERSION_ARG="latest" +FROM scratch AS build-amd64 + +COPY --from=qemux/qemu-docker:6.08 / / + +ARG DEBCONF_NOWARNINGS="yes" +ARG DEBIAN_FRONTEND="noninteractive" +ARG DEBCONF_NONINTERACTIVE_SEEN="true" + +RUN set -eu && \ + apt-get update && \ + apt-get --no-install-recommends -y install \ + bc \ + jq \ + curl \ + 7zip \ + wsdd \ + samba \ + xz-utils \ + wimtools \ + dos2unix \ + cabextract \ + genisoimage \ + libxml2-utils \ + libarchive-tools && \ + apt-get clean && \ + rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* + +COPY --chmod=755 ./vm/buildcontainer /run/ +RUN dos2unix /run/* + +COPY --chmod=755 ./vm/win11def /run/assets +RUN dos2unix /run/assets/* + +ADD --chmod=755 https://raw.githubusercontent.com/christgau/wsdd/v0.8/src/wsdd.py /usr/sbin/wsdd +ADD --chmod=664 https://github.com/qemus/virtiso-whql/releases/download/v1.9.43-0/virtio-win-1.9.43.tar.xz /drivers.txz + +FROM dockurr/windows-arm:${VERSION_ARG} AS build-arm64 +FROM build-${TARGETARCH} + +ARG VERSION_ARG="0.00" +RUN echo "$VERSION_ARG" > /run/version + +EXPOSE 8006 3389 + +ENV VERSION="win11e" + +ENTRYPOINT ["/usr/bin/tini", "-s", "/run/entry.sh"] \ No newline at end of file diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/cleanall b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/cleanall new file mode 100644 index 00000000..b5c66144 --- /dev/null +++ b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/cleanall @@ -0,0 +1,10 @@ +from manageinstance import delete_instance +import os +import shutil + +# for every folder of the form omnibox- in this dir delete the docker container (leave folder) +for folder in os.listdir("."): + if folder.startswith("omnibox-"): + delete_instance(int(folder.split("-")[1])) + # uncomment below to also delete the folder + shutil.rmtree(folder) diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/command.txt b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/command.txt new file mode 100644 index 00000000..4d152f93 --- /dev/null +++ b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/command.txt @@ -0,0 +1 @@ +az storage blob upload-batch --account-name goldenimage --sas-token "sp=racw&st=2025-04-02T23:09:18Z&se=2025-04-03T07:09:18Z&spr=https&sv=2024-11-04&sr=c&sig=kCahg2xb32DgJjOGYiDAcX716m6df5AZBD2KV5sPeVs%3D" --destination goldenimages --source /home/thomasdh/OmniBoxes/common \ No newline at end of file diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/compose.yml b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/compose.yml new file mode 100644 index 00000000..101f6667 --- /dev/null +++ b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/compose.yml @@ -0,0 +1,23 @@ +services: + windows: + image: windows-local + container_name: omni-windows + privileged: true + environment: + RAM_SIZE: "8G" + CPU_CORES: "4" + DISK_SIZE: "11G" + devices: + - /dev/kvm + - /dev/net/tun + cap_add: + - NET_ADMIN + ports: + - 8006:8006 # Web Viewer access + - 5000:5000 # Computer control server + volumes: + - ./common/win11iso/custom.iso:/custom.iso + - ./common/win11setup/firstboot:/oem + - ./common/win11setup/setupscripts:/data + - ./omnibox-0:/storage + \ No newline at end of file diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageall.py b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageall.py new file mode 100644 index 00000000..4ebf8e86 --- /dev/null +++ b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageall.py @@ -0,0 +1,121 @@ +import os +from fastapi import FastAPI, HTTPException, Response +from fastapi.responses import JSONResponse, StreamingResponse +import requests +import uvicorn +import concurrent.futures +from typing import List, Dict, Any, Optional +from manageinstance import ( + reset_instance_with_callback, flask_url +) +import time +import uuid +from tqdm import tqdm +from contextlib import asynccontextmanager + +@asynccontextmanager +async def lifespan(app: FastAPI): + # Startup code goes here + yield + # Shutdown code goes here + if reset_executor: + reset_executor.shutdown(wait=True, cancel_futures=False) + +app = FastAPI(lifespan=lifespan) + +INSTANCES = 10 +available_instances = [] +in_use = {} # key = instance_uuid, value = instance_id + +RESET_WORKERS = 10 +reset_executor = concurrent.futures.ThreadPoolExecutor(max_workers=RESET_WORKERS) + +def instance_reset_callback(instance_id): + if instance_id not in available_instances: + available_instances.append(instance_id) + +for i in range(INSTANCES): + reset_executor.submit(reset_instance_with_callback, i, instance_reset_callback) + +# Wait for all instances to be initialized +with tqdm(total=INSTANCES, desc="Initializing instances") as pbar: + last_count = 0 + while len(available_instances) < INSTANCES: + current_count = len(available_instances) + if current_count > last_count: + pbar.update(current_count - last_count) + last_count = current_count + time.sleep(0.1) + pbar.update(INSTANCES - last_count) + +@app.get("/getinstance") +def get_instance(): + """Get an available instance from the pool""" + if not available_instances: + raise HTTPException(status_code=503, detail="No instances available") + + instance_id = available_instances.pop(0) + instance_uuid = str(uuid.uuid4()) + in_use[instance_uuid] = instance_id + return {"instance_uuid": instance_uuid} + +@app.post("/resetinstance/{instance_uuid}") +def reset_instance(instance_uuid: str): + """Reset an instance to its initial state and make it available again""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance_id = in_use[instance_uuid] + reset_executor.submit(reset_instance_with_callback, instance_id, instance_reset_callback) + + return {"status": "success", "message": f"UUID {instance_uuid} for instance {instance_id} has been queued for reset"} + +@app.post("/executeinstance/{instance_uuid}/execute") +async def execute_instance_command(instance_uuid: str, command_data: Dict[str, Any]): + """Forward execute command to the Flask server in the specified instance""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance_id = in_use[instance_uuid] + try: + response = requests.post(flask_url(instance_id), json=command_data, timeout=5) + return JSONResponse(content=response.json(), status_code=response.status_code) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with instance {instance_id}: {str(e)}") + +@app.get("/executeinstance/{instance_uuid}/screenshot") +async def get_instance_screenshot(instance_uuid: str): + """Forward screenshot request to the Flask server in the specified instance""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance_id = in_use[instance_uuid] + try: + response = requests.get(flask_url(instance_id) + "/screenshot", timeout=5) + + if response.status_code == 200: + return Response(content=response.content, media_type="image/png") + else: + return JSONResponse( + content={"status": "error", "message": f"Failed to get screenshot: {response.text}"}, + status_code=response.status_code + ) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance_id}: {str(e)}") + +@app.get("/executeinstance/{instance_uuid}/probe") +async def probe_instance(instance_uuid: str): + """Forward probe request to the Flask server in the specified instance""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance_id = in_use[instance_uuid] + try: + response = requests.get(flask_url(instance_id) + "/probe", timeout=1) + return JSONResponse(content=response.json(), status_code=response.status_code) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance_id}: {str(e)}") + +if __name__ == "__main__": + uvicorn.run(app, host="0.0.0.0", port=8000) + diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageinstance.py b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageinstance.py new file mode 100644 index 00000000..859f3205 --- /dev/null +++ b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageinstance.py @@ -0,0 +1,164 @@ +import os +import subprocess +import tempfile +import threading +import queue +import shutil +import time +import requests +import concurrent.futures + +# Base compose file template +compose_template = """ +networks: + omnibox-network: + name: omnibox-network-{instance} + +services: + windows: + image: windows-local + container_name: omni-windows-{instance} + networks: + - omnibox-network + privileged: true + environment: + RAM_SIZE: "2G" + CPU_CORES: "4" + DISK_SIZE: "11G" + devices: + - /dev/kvm + - /dev/net/tun + cap_add: + - NET_ADMIN + ports: + - {web_port}:8006 # Web Viewer access + - {control_port}:5000 # Computer control server + volumes: + - {omniboxes_path}/common/win11iso/custom.iso:/custom.iso + - {omniboxes_path}/common/win11setup/firstboot:/oem + - {omniboxes_path}/common/win11setup/setupscripts:/data + - {omniboxes_path}/omnibox-{instance}:/storage +""" +omniboxes_path = os.path.dirname(__file__) +def get_compose_path(instance_num): + with tempfile.NamedTemporaryFile(mode='w', suffix='.yml', delete=False) as temp_file: + compose_content = compose_template.format( + instance = instance_num, + web_port = 8006 + instance_num, + control_port = 5000 + instance_num, + omniboxes_path = omniboxes_path + ) + temp_file.write(compose_content) + return temp_file.name + +def create_instance(instance_num): + if not os.path.exists(f"omnibox-{instance_num}"): + os.makedirs(f"omnibox-{instance_num}") + subprocess.run(["cp", "-r", f"{omniboxes_path}/common/win11storage/.", f"{omniboxes_path}/omnibox-{instance_num}/"]) + + temp_file_path = get_compose_path(instance_num) + try: + subprocess.run( + ["docker", "compose", "-f", temp_file_path, "-p", f"omnibox-{instance_num}", "up", "-d"], + check=True, + stdout=subprocess.DEVNULL, # Suppress standard output + stderr=subprocess.DEVNULL # Suppress error output + ) + print(f"Instance {instance_num} launched successfully!") + except subprocess.CalledProcessError as e: + print(f"Error launching instance {instance_num}: {e}") + finally: + os.unlink(temp_file_path) # Clean up the temporary file + +def start_instance(instance_num): + temp_file_path = get_compose_path(instance_num) + try: + subprocess.run( + ["docker", "compose", "-f", temp_file_path, "-p", f"omnibox-{instance_num}", "start"], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL + ) + print(f"Instance {instance_num} started successfully!") + except subprocess.CalledProcessError as e: + print(f"Error starting instance {instance_num}: {e}") + finally: + os.unlink(temp_file_path) + +def stop_instance(instance_num): + temp_file_path = get_compose_path(instance_num) + try: + subprocess.run( + ["docker", "compose", "-f", temp_file_path, "-p", f"omnibox-{instance_num}", "stop"], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL + ) + print(f"Instance {instance_num} stopped successfully!") + except subprocess.CalledProcessError as e: + print(f"Error stopping instance {instance_num}: {e}") + finally: + os.unlink(temp_file_path) + +def delete_instance(instance_num): + temp_file_path = get_compose_path(instance_num) + try: + subprocess.run( + ["docker", "compose", "-f", temp_file_path, "-p", f"omnibox-{instance_num}", "down"], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL + ) + print(f"Instance {instance_num} deleted successfully!") + except subprocess.CalledProcessError as e: + print(f"Error deleting instance {instance_num}: {e}") + finally: + os.unlink(temp_file_path) + +def flask_url(instance_id: int): + return f"http://localhost:{5000 + instance_id}" + +def instance_ready(instance_id: int): + try: + response = requests.get(flask_url(instance_id) + "/probe", timeout=1) + return response.status_code == 200 + except requests.RequestException as e: + return False + +def reset_instance(instance_id): + delete_instance(instance_id) + if os.path.exists(f"omnibox-{instance_id}"): + subprocess.run(["sudo", "rm", "-rf", f"{omniboxes_path}/omnibox-{instance_id}"], check=True) + create_instance(instance_id) + +def reset_instance_soft(instance_id): + stop_instance(instance_id) + if os.path.exists(f"omnibox-{instance_id}"): + subprocess.run(["sudo", "rm", "-rf", f"{omniboxes_path}/omnibox-{instance_id}"], check=True) + start_instance(instance_id) + +def reset_instance_with_callback(instance_id, callback): + try: + reset_instance(instance_id) + while not instance_ready(instance_id): + time.sleep(1) + callback(instance_id) + except Exception as e: + print(f"Error in reset worker: {str(e)}") + +# got insufficient perf with this method +def reset_instance_soft_with_callback(instance_id, callback): + try: + reset_instance_soft(instance_id) + while not instance_ready(instance_id): + time.sleep(1) + callback(instance_id) + except Exception as e: + print(f"Error in reset worker: {str(e)}") + +# num_instances = 3 +# for i in range(num_instances): + # create_instance(i) + # stop_instance(i) + # start_instance(i) + # delete_instance(i) diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/requirements.txt b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/requirements.txt new file mode 100644 index 00000000..c4641cdf --- /dev/null +++ b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/requirements.txt @@ -0,0 +1,3 @@ +fastapi[standard] +requests +tqdm From 03036853e6febb494a0582813f693acaf395e76e Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Mon, 5 May 2025 18:41:08 +0000 Subject: [PATCH 03/27] host/instance --- .../scripts/omniboxes/OmniBoxes/host.py | 124 ++++++++++++ .../scripts/omniboxes/OmniBoxes/instance.py | 190 ++++++++++++++++++ 2 files changed, 314 insertions(+) create mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/host.py create mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/instance.py diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/host.py b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/host.py new file mode 100644 index 00000000..9fc5f646 --- /dev/null +++ b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/host.py @@ -0,0 +1,124 @@ +import os +from fastapi import FastAPI, HTTPException, Response +from fastapi.responses import JSONResponse, StreamingResponse +import requests +import uvicorn +import concurrent.futures +from typing import List, Dict, Any, Optional +from instance import Instance, reset_with_callback +import time +import uuid +from tqdm import tqdm +from contextlib import asynccontextmanager + +@asynccontextmanager +async def lifespan(app: FastAPI): + # Startup code goes here + yield + # Shutdown code goes here + if reset_executor: + reset_executor.shutdown(wait=True, cancel_futures=False) + +app = FastAPI(lifespan=lifespan) + +INSTANCES = 2 +available_instances = [] +in_use = {} # key = instance_uuid, value = instance_id + +RESET_WORKERS = 2 +reset_executor = concurrent.futures.ThreadPoolExecutor(max_workers=RESET_WORKERS) + +def instance_reset_callback(instance_id): + if instance_id not in available_instances: + available_instances.append(instance_id) + +for i in range(INSTANCES): + reset_executor.submit(reset_with_callback, Instance(instance_num=i), instance_reset_callback) + +# Wait for all instances to be initialized +with tqdm(total=INSTANCES, desc="Initializing instances") as pbar: + last_count = 0 + while len(available_instances) < INSTANCES: + current_count = len(available_instances) + if current_count > last_count: + pbar.update(current_count - last_count) + last_count = current_count + time.sleep(0.1) + pbar.update(INSTANCES - last_count) + +@app.post("/getinstance") +def get_instance(): + """Get an available instance from the pool""" + if not available_instances: + raise HTTPException(status_code=503, detail="No instances available") + + instance_id = available_instances.pop(0) + instance_uuid = str(uuid.uuid4()) + in_use[instance_uuid] = instance_id + return {"instance_uuid": instance_uuid} + +@app.post("/resetinstance/{instance_uuid}") +def reset_instance(instance_uuid: str): + """Reset an instance to its initial state and make it available again""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance_id = in_use[instance_uuid] + reset_executor.submit(reset_with_callback, Instance(instance_num = instance_id), instance_reset_callback) + + return {"status": "success", "message": f"UUID {instance_uuid} for instance {instance_id} has been queued for reset"} + +@app.post("/executeinstance/{instance_uuid}/execute") +async def execute_instance_command(instance_uuid: str, command_data: Dict[str, Any]): + """Forward execute command to the Flask server in the specified instance""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance_id = in_use[instance_uuid] + try: + response = requests.post(Instance(instance_num = instance_id).flask_url(), json=command_data, timeout=5) + return JSONResponse(content=response.json(), status_code=response.status_code) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with instance {instance_id}: {str(e)}") + +@app.get("/executeinstance/{instance_uuid}/screenshot") +async def get_instance_screenshot(instance_uuid: str): + """Forward screenshot request to the Flask server in the specified instance""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance_id = in_use[instance_uuid] + try: + response = requests.get(Instance(instance_num = instance_id).flask_url() + "/screenshot", timeout=5) + + if response.status_code == 200: + return Response(content=response.content, media_type="image/png") + else: + return JSONResponse( + content={"status": "error", "message": f"Failed to get screenshot: {response.text}"}, + status_code=response.status_code + ) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance_id}: {str(e)}") + +@app.get("/executeinstance/{instance_uuid}/probe") +async def probe_instance(instance_uuid: str): + """Forward probe request to the Flask server in the specified instance""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance_id = in_use[instance_uuid] + try: + response = requests.get(Instance(instance_num = instance_id).flask_url() + "/probe", timeout=1) + return JSONResponse(content=response.json(), status_code=response.status_code) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance_id}: {str(e)}") + +@app.get("/available") +def get_available_instances(): + """Get an available instance from the pool""" + return {'available': len(available_instances)} + +if __name__ == "__main__": + uvicorn.run(app, host="0.0.0.0", port=8000) + diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/instance.py b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/instance.py new file mode 100644 index 00000000..03244ff5 --- /dev/null +++ b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/instance.py @@ -0,0 +1,190 @@ +import os +import subprocess +import tempfile +import time +import requests +from pathlib import Path + + +class IInstance: + def create(self): + raise NotImplementedError("Subclasses should implement this!") + + def start(self): + raise NotImplementedError("Subclasses should implement this!") + + def stop(self): + raise NotImplementedError("Subclasses should implement this!") + + def delete(self): + raise NotImplementedError("Subclasses should implement this!") + + def flask_url(self): + raise NotImplementedError("Subclasses should implement this!") + + def is_ready(self): + raise NotImplementedError("Subclasses should implement this!") + + +def DummyInstance(IInstance): + def __init__(self, root_path = None, instance_num = 0): + self.root_path = root_path + self.instance_num = instance_num + + def create(self): + print("Dummy instance created") + + def start(self): + print("Dummy instance started") + + def stop(self): + print("Dummy instance stopped") + + def delete(self): + print("Dummy instance deleted") + + def flask_url(self): + return f"http://localhost:{5000 + self.instance_num}" + + def is_ready(self): + return True + + +_compose_template = """ +networks: + omnibox-network: + name: omnibox-network-{instance} + +services: + windows: + image: windows-local + container_name: omni-windows-{instance} + networks: + - omnibox-network + privileged: true + environment: + RAM_SIZE: "2G" + CPU_CORES: "4" + DISK_SIZE: "11G" + devices: + - /dev/kvm + - /dev/net/tun + cap_add: + - NET_ADMIN + ports: + - {web_port}:8006 # Web Viewer access + - {control_port}:5000 # Computer control server + volumes: + - {omniboxes_path}/common/win11iso/custom.iso:/custom.iso + - {omniboxes_path}/common/win11setup/firstboot:/oem + - {omniboxes_path}/common/win11setup/setupscripts:/data + - {omniboxes_path}/omnibox-{instance}:/storage +""" + +class Instance(IInstance): + def __init__(self, root_path = None, instance_num = 0): + self.root_path = Path(root_path or os.path.dirname(__file__)) + self.instance_num = instance_num + self.config_path = self.root_path / f'{instance_num}.yml' + with open(self.config_path, mode='w') as temp_file: + compose_content = _compose_template.format( + instance = self.instance_num, + web_port = 8006 + self.instance_num, + control_port = 5000 + self.instance_num, + omniboxes_path = self.root_path + ) + temp_file.write(compose_content) + + def create(self): + if not os.path.exists(f"omnibox-{self.instance_num}"): + os.makedirs(f"omnibox-{self.instance_num}") + subprocess.run(["cp", "-r", f"{str(self.root_path)}/common/win11storage/.", f"{self.root_path}/omnibox-{self.instance_num}/"]) + + try: + subprocess.run( + ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "up", "-d"], + check=True, + stdout=subprocess.DEVNULL, # Suppress standard output + stderr=subprocess.DEVNULL # Suppress error output + ) + print(f"Instance {self.instance_num} launched successfully!") + except subprocess.CalledProcessError as e: + print(f"Error launching instance {self.instance_num}: {e}") + + def start(self): + try: + subprocess.run( + ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "start"], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL + ) + print(f"Instance {self.instance_num} started successfully!") + except subprocess.CalledProcessError as e: + print(f"Error starting instance {self.instance_num}: {e}") + + def stop(self): + try: + subprocess.run( + ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "stop"], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL + ) + print(f"Instance {self.instance_num} stopped successfully!") + except subprocess.CalledProcessError as e: + print(f"Error stopping instance {self.instance_num}: {e}") + + def delete(self): + try: + subprocess.run( + ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "down"], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL + ) + print(f"Instance {self.instance_num} deleted successfully!") + except subprocess.CalledProcessError as e: + print(f"Error deleting instance {self.instance_num}: {e}") + + def flask_url(self): + return f"http://localhost:{5000 + self.instance_num}" + + def is_ready(self): + try: + response = requests.get(self.flask_url() + "/probe", timeout=1) + return response.status_code == 200 + except requests.RequestException as e: + return False + + def reset(self): + self.delete() + if os.path.exists(f"omnibox-{self.instance_num}"): + subprocess.run(["sudo", "rm", "-rf", f"{self.root_path}/omnibox-{self.instance_num}"], check=True) + self.create() + + def reset_soft(self): + self.stop() + if os.path.exists(f"omnibox-{self.instance_num}"): + subprocess.run(["sudo", "rm", "-rf", f"{self.root_path}/omnibox-{self.instance_num}"], check=True) + self.start() + +def reset_with_callback(instance, callback): + try: + instance.reset() + while not instance.is_ready(): + time.sleep(1) + callback(instance.instance_num) + except Exception as e: + print(f"Error in reset worker: {str(e)}") + +# got insufficient perf with this method +def reset_soft_with_callback(instance, callback): + try: + instance.reset_soft() + while not instance.is_ready(): + time.sleep(1) + callback(instance.instance_num) + except Exception as e: + print(f"Error in reset worker: {str(e)}") + From cdd9e0c331d342dd0ebc02e37b4ed99bb46c515c Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Mon, 5 May 2025 19:08:23 +0000 Subject: [PATCH 04/27] move to src --- omnitool/omnibox/{scripts/omniboxes/OmniBoxes => src}/host.py | 0 .../omnibox/{scripts/omniboxes/OmniBoxes => src}/instance.py | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) rename omnitool/omnibox/{scripts/omniboxes/OmniBoxes => src}/host.py (100%) rename omnitool/omnibox/{scripts/omniboxes/OmniBoxes => src}/instance.py (99%) diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/host.py b/omnitool/omnibox/src/host.py similarity index 100% rename from omnitool/omnibox/scripts/omniboxes/OmniBoxes/host.py rename to omnitool/omnibox/src/host.py diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/instance.py b/omnitool/omnibox/src/instance.py similarity index 99% rename from omnitool/omnibox/scripts/omniboxes/OmniBoxes/instance.py rename to omnitool/omnibox/src/instance.py index 03244ff5..77e14fc3 100644 --- a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/instance.py +++ b/omnitool/omnibox/src/instance.py @@ -26,7 +26,7 @@ def is_ready(self): raise NotImplementedError("Subclasses should implement this!") -def DummyInstance(IInstance): +def MockInstance(IInstance): def __init__(self, root_path = None, instance_num = 0): self.root_path = root_path self.instance_num = instance_num From 040acb8ee10582721d7ca6d33a4c03ea052f30c0 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Mon, 5 May 2025 19:17:50 +0000 Subject: [PATCH 05/27] omnitool client --- omnitool/omnibox/client/client.py | 134 +++++++++++++++++++++++++ omnitool/omnibox/client/notebook.ipynb | 36 +++++++ 2 files changed, 170 insertions(+) create mode 100644 omnitool/omnibox/client/client.py create mode 100644 omnitool/omnibox/client/notebook.ipynb diff --git a/omnitool/omnibox/client/client.py b/omnitool/omnibox/client/client.py new file mode 100644 index 00000000..2aa5928c --- /dev/null +++ b/omnitool/omnibox/client/client.py @@ -0,0 +1,134 @@ +import requests +from PIL import Image +import io +import ipywidgets +import json +import time + +def _pyscript(commands): + script = ";".join(commands) + return f'python -c "{script}"' + +def _moveTo(x, y): + return { + 'command': _pyscript([ + 'import pyautogui', + f'pyautogui.moveTo({x}, {y})' + ]) + } + +def _click(): + return { + 'command': _pyscript([ + 'import pyautogui', + f'pyautogui.click()' + ]) + } + +def _rightClick(): + return { + 'command': _pyscript([ + 'import pyautogui', + f'pyautogui.rightClick()' + ]) + } + +def _doubleClick(): + return { + 'command': _pyscript([ + 'import pyautogui', + f'pyautogui.doubleClick()' + ]) + } + +def _position(): + return { + 'command': _pyscript([ + 'import pyautogui', + 'import json', + 'p = pyautogui.position()', + "print(json.dumps({'x': p.x, 'y': p.y}))", + ]) + } + +def _screensize(): + return { + 'command': _pyscript([ + 'import pyautogui', + 'import json', + 'sz = pyautogui.size()', + "print(json.dumps({'width': sz.width, 'height': sz.height}))", + ]) + } + + +class Client: + def __init__(self, host = 'localhost', port = 5000): + self.host = host + self.port = port + self.output = None + + def screenshot(self): + data = requests.get(f'http://{self.host}:{self.port}/screenshot') + image_data = io.BytesIO(data.content) + return Image.open(image_data) + + def execute(self, command): + return requests.post(f'http://{self.host}:{self.port}/execute', json = command) + + def do_and_show(self, command, waitTime): + response = self.execute(command) + if response.status_code != 200: + raise Exception(f"Error: {response.status_code} - {response.text}") + time.sleep(waitTime) + self._display(response.json()['output']) + + def _display(self, data = None): + with self.output: + self.output.clear_output(wait = True) + display(self.screenshot()) + print(data) + + def position(self): + return json.loads(self.execute(_position()).json()['output']) + + def screensize(self): + return json.loads(self.execute(_screensize()).json()['output']) + + def ui(self): + self.output = ipywidgets.Output() + self._display() + + screensize = self.screensize() + position = self.position() + + waitTime = ipywidgets.FloatLogSlider(base=2, value = 1, min = -3, max = 5, step = 1, description = 'wait (s)') + + x = ipywidgets.IntSlider(min = 0, max = screensize['width'], value = position['x'], description = 'X') + y = ipywidgets.IntSlider(min = 0, max = screensize['height'], value = position['y'], description = 'Y') + + click = ipywidgets.Button(description = 'Click') + rightClick = ipywidgets.Button(description = 'Right Click') + doubleClick = ipywidgets.Button(description = 'Double Click') + + x.observe(lambda v: self.do_and_show(_moveTo(x.value, y.value), waitTime.value), names='value') + y.observe(lambda v: self.do_and_show(_moveTo(x.value, y.value), waitTime.value), names='value') + + click.on_click(lambda v: self.do_and_show(_click(), waitTime.value)) + rightClick.on_click(lambda v: self.do_and_show(_rightClick(), waitTime.value)) + doubleClick.on_click(lambda v: self.do_and_show(_doubleClick(), waitTime.value)) + + cmd = ipywidgets.Textarea(description = 'Commands', layout=ipywidgets.Layout(width='50%')) + shell = ipywidgets.Checkbox(description = 'Shell', value = False) + python = ipywidgets.Checkbox(description = 'Python', value = True) + submit = ipywidgets.Button(description = 'Submit') + submit.on_click(lambda v: self.do_and_show({ + 'command': _pyscript(cmd.value.split('\n')) if python.value else '&&'.join(cmd.value.split('\n')), + 'shell': shell.value + }, waitTime.value)) + display(ipywidgets.VBox([ + waitTime, + ipywidgets.HBox([x, y]), + ipywidgets.HBox([click, rightClick, doubleClick]), + ipywidgets.HBox([cmd, ipywidgets.VBox([shell, python]), submit]), + self.output])) diff --git a/omnitool/omnibox/client/notebook.ipynb b/omnitool/omnibox/client/notebook.ipynb new file mode 100644 index 00000000..bbdd7f4e --- /dev/null +++ b/omnitool/omnibox/client/notebook.ipynb @@ -0,0 +1,36 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "ae7b2936", + "metadata": {}, + "outputs": [], + "source": [ + "import client\n", + "client.Client(port = 5000).ui()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "explore", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 9d99d5f1ec1c6f46f9c64190a7f2558c8c540ae2 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Mon, 5 May 2025 19:21:17 +0000 Subject: [PATCH 06/27] requirements --- omnitool/omnibox/client/requirements.txt | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 omnitool/omnibox/client/requirements.txt diff --git a/omnitool/omnibox/client/requirements.txt b/omnitool/omnibox/client/requirements.txt new file mode 100644 index 00000000..dbfd4e08 --- /dev/null +++ b/omnitool/omnibox/client/requirements.txt @@ -0,0 +1,3 @@ +pillow +ipywidgets +requests \ No newline at end of file From 8de62e086d4e5356bc08f3983d71c8084a6022a4 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Tue, 6 May 2025 01:27:43 +0000 Subject: [PATCH 07/27] client minor update --- omnitool/omnibox/client/client.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/omnitool/omnibox/client/client.py b/omnitool/omnibox/client/client.py index 2aa5928c..d3ae6845 100644 --- a/omnitool/omnibox/client/client.py +++ b/omnitool/omnibox/client/client.py @@ -104,8 +104,8 @@ def ui(self): waitTime = ipywidgets.FloatLogSlider(base=2, value = 1, min = -3, max = 5, step = 1, description = 'wait (s)') - x = ipywidgets.IntSlider(min = 0, max = screensize['width'], value = position['x'], description = 'X') - y = ipywidgets.IntSlider(min = 0, max = screensize['height'], value = position['y'], description = 'Y') + x = ipywidgets.IntSlider(min = 0, max = screensize.get('width', 1), value = position.get('x', 0), description = 'X') + y = ipywidgets.IntSlider(min = 0, max = screensize.get('height', 1), value = position.get('y', 0), description = 'Y') click = ipywidgets.Button(description = 'Click') rightClick = ipywidgets.Button(description = 'Right Click') From 8e90ce019ff331d1fa5af5b63ce5a60ff2e1d92c Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Tue, 6 May 2025 01:28:28 +0000 Subject: [PATCH 08/27] mock_instance --- omnitool/omnibox/host/mock_instance.py | 107 +++++++++++++++++++++++++ 1 file changed, 107 insertions(+) create mode 100644 omnitool/omnibox/host/mock_instance.py diff --git a/omnitool/omnibox/host/mock_instance.py b/omnitool/omnibox/host/mock_instance.py new file mode 100644 index 00000000..06497a4f --- /dev/null +++ b/omnitool/omnibox/host/mock_instance.py @@ -0,0 +1,107 @@ +import logging +from flask import Flask, request, jsonify, send_file +from PIL import Image, ImageDraw, ImageFont +from io import BytesIO +from instance import IInstance +from threading import Thread + + +def create_app(log_file=None): + """Create and configure the Flask app""" + if log_file: + logging.basicConfig(filename=log_file, level=logging.DEBUG, filemode='w') + logger = logging.getLogger('werkzeug') + + app = Flask(__name__) + command_history = [] + + @app.route('/probe', methods=['GET']) + def probe_endpoint(): + return jsonify({"status": "Probe successful", "message": "Service is operational"}), 200 + + @app.route('/execute', methods=['POST']) + def execute_command(): + data = request.json + command = data.get('command', "") + command_history.append(str(command)) + return jsonify({ + 'status': 'success', + 'output': '{}', + 'error': '', + 'returncode': 0 + }) + + @app.route('/screenshot', methods=['GET']) + def screenshot(): + width, height = 800, 600 + image = Image.new('RGB', (width, height), color='white') + draw = ImageDraw.Draw(image) + + try: + font = ImageFont.truetype("DejaVuSans.ttf", 14) + except IOError: + font = ImageFont.load_default() + + draw.text((10, 10), "Mock Instance - Command History", fill="black", font=font) + draw.line([(10, 40), (width-10, 40)], fill="black", width=1) + + y_position = 50 + max_commands = min(len(command_history), 20) # Limit to last 20 commands + + if max_commands == 0: + draw.text((20, y_position), "No commands executed yet", fill="gray", font=font) + else: + for i, cmd in enumerate(command_history[-max_commands:]): + timestamp = f"{i+1}." + draw.text((20, y_position), timestamp, fill="blue", font=font) + draw.text((50, y_position), cmd, fill="black", font=font) + y_position += 25 + + # If we're running out of space + if y_position > height - 30: + remaining = len(command_history) - (i + 1) + if remaining > 0: + draw.text((20, y_position), f"... {remaining} more commands not shown", + fill="red", font=font) + break + + img_io = BytesIO() + image.save(img_io, 'PNG') + img_io.seek(0) + return send_file(img_io, mimetype='image/png') + + return app + + +class MockInstance(IInstance): + def __init__(self, root_path = None, instance_num = 0): + print(f'Creating mock instance: {instance_num}') + self.root_path = root_path + self.instance_num = instance_num + self.app = create_app() + p = Thread(target=self.app.run, args=('0.0.0.0',5000 + self.instance_num), daemon=True) + p.start() + + def create(self): + print("Dummy instance created") + + def start(self): + print("Dummy instance started") + + def stop(self): + print("Dummy instance stopped") + + def delete(self): + print("Dummy instance deleted") + + def flask_url(self): + return f"http://localhost:{5000 + self.instance_num}" + + def is_ready(self): + return True + + def reset(self): + print("Dummy instance reset") + + def reset_soft(self): + print("Dummy instance reset soft") From 999385970ccdcd3c6ac0b602f1fcf9a0f79d198d Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Tue, 6 May 2025 15:32:17 +0000 Subject: [PATCH 09/27] forgotten files --- omnitool/omnibox/host/host.py | 127 +++++++++++++++++++++ omnitool/omnibox/host/instance.py | 178 ++++++++++++++++++++++++++++++ 2 files changed, 305 insertions(+) create mode 100644 omnitool/omnibox/host/host.py create mode 100644 omnitool/omnibox/host/instance.py diff --git a/omnitool/omnibox/host/host.py b/omnitool/omnibox/host/host.py new file mode 100644 index 00000000..3f368b5c --- /dev/null +++ b/omnitool/omnibox/host/host.py @@ -0,0 +1,127 @@ +import os +from fastapi import FastAPI, HTTPException, Response +from fastapi.responses import JSONResponse, StreamingResponse +import requests +import uvicorn +import concurrent.futures +from typing import List, Dict, Any, Optional +from instance import Instance, reset_with_callback +from mock_instance import MockInstance as Instance +import time +import uuid +from tqdm import tqdm +from contextlib import asynccontextmanager + +@asynccontextmanager +async def lifespan(app: FastAPI): + # Startup code goes here + yield + # Shutdown code goes here + if reset_executor: + reset_executor.shutdown(wait=True, cancel_futures=False) + +app = FastAPI(lifespan=lifespan) + +INSTANCES = 2 +available_instances = {} # instance_num to instance +in_use = {} # key = instance_uuid, value = instance_id + +RESET_WORKERS = 2 +reset_executor = concurrent.futures.ThreadPoolExecutor(max_workers=RESET_WORKERS) + +def instance_reset_callback(instance): + available_instances[instance.instance_num] = instance + +for i in range(INSTANCES): + reset_executor.submit(reset_with_callback, Instance(instance_num=i), instance_reset_callback) + +# Wait for all instances to be initialized +with tqdm(total=INSTANCES, desc="Initializing instances") as pbar: + last_count = 0 + while len(available_instances) < INSTANCES: + current_count = len(available_instances) + if current_count > last_count: + pbar.update(current_count - last_count) + last_count = current_count + time.sleep(0.1) + pbar.update(INSTANCES - last_count) + +@app.post("/getinstance") +def get_instance(): + """Get an available instance from the pool""" + if not available_instances: + raise HTTPException(status_code=503, detail="No instances available") + + instance = available_instances.pop(list(available_instances.keys())[0]) + instance_uuid = str(uuid.uuid4()) + in_use[instance_uuid] = instance + return {"instance_uuid": instance_uuid} + +@app.post("/resetinstance/{instance_uuid}") +def reset_instance(instance_uuid: str): + """Reset an instance to its initial state and make it available again""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance = in_use[instance_uuid] + reset_executor.submit(reset_with_callback, instance, instance_reset_callback) + + return {"status": "success", "message": f"UUID {instance_uuid} for instance {instance.instance_num} has been queued for reset"} + +@app.post("/executeinstance/{instance_uuid}/execute") +async def execute_instance_command(instance_uuid: str, command_data: Dict[str, Any]): + """Forward execute command to the Flask server in the specified instance""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance = in_use[instance_uuid] + try: + response = requests.post(instance.flask_url() + "/execute", json=command_data, timeout=5) + return JSONResponse(content=response.json(), status_code=response.status_code) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with instance {instance.instance_num}: {str(e)}") + +@app.get("/executeinstance/{instance_uuid}/screenshot") +async def get_instance_screenshot(instance_uuid: str): + """Forward screenshot request to the Flask server in the specified instance""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance = in_use[instance_uuid] + try: + response = requests.get(instance.flask_url() + "/screenshot", timeout=5) + + if response.status_code == 200: + return Response(content=response.content, media_type="image/png") + else: + return JSONResponse( + content={"status": "error", "message": f"Failed to get screenshot: {response.text}"}, + status_code=response.status_code + ) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance.instance_num}: {str(e)}") + +@app.get("/executeinstance/{instance_uuid}/probe") +async def probe_instance(instance_uuid: str): + """Forward probe request to the Flask server in the specified instance""" + if instance_uuid not in in_use: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + + instance= in_use[instance_uuid] + try: + response = requests.get(instance.flask_url() + "/probe", timeout=1) + return JSONResponse(content=response.json(), status_code=response.status_code) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance.instance_num}: {str(e)}") + +@app.get("/instances/info") +def get_available_instances(): + """Get an available instance from the pool""" + return { + 'available': len(available_instances), + 'in_use': list(in_use.keys())} + + +if __name__ == "__main__": + uvicorn.run(app, host="0.0.0.0", port=8000) + diff --git a/omnitool/omnibox/host/instance.py b/omnitool/omnibox/host/instance.py new file mode 100644 index 00000000..f8897366 --- /dev/null +++ b/omnitool/omnibox/host/instance.py @@ -0,0 +1,178 @@ +import os +import subprocess +import tempfile +import time +import requests +from pathlib import Path + + +class IInstance: + def create(self): + raise NotImplementedError("Subclasses should implement this!") + + def start(self): + raise NotImplementedError("Subclasses should implement this!") + + def stop(self): + raise NotImplementedError("Subclasses should implement this!") + + def delete(self): + raise NotImplementedError("Subclasses should implement this!") + + def flask_url(self): + raise NotImplementedError("Subclasses should implement this!") + + def is_ready(self): + raise NotImplementedError("Subclasses should implement this!") + + def reset(self): + raise NotImplementedError("Subclasses should implement this!") + + def reset_soft(self): + self.stop() + if os.path.exists(f"omnibox-{self.instance_num}"): + subprocess.run(["sudo", "rm", "-rf", f"{self.root_path}/omnibox-{self.instance_num}"], check=True) + self.start() + + +_compose_template = """ +networks: + omnibox-network: + name: omnibox-network-{instance} + +services: + windows: + image: windows-local + container_name: omni-windows-{instance} + networks: + - omnibox-network + privileged: true + environment: + RAM_SIZE: "2G" + CPU_CORES: "4" + DISK_SIZE: "11G" + devices: + - /dev/kvm + - /dev/net/tun + cap_add: + - NET_ADMIN + ports: + - {web_port}:8006 # Web Viewer access + - {control_port}:5000 # Computer control server + volumes: + - {omniboxes_path}/common/win11iso/custom.iso:/custom.iso + - {omniboxes_path}/common/win11setup/firstboot:/oem + - {omniboxes_path}/common/win11setup/setupscripts:/data + - {omniboxes_path}/omnibox-{instance}:/storage +""" + + +class Instance(IInstance): + def __init__(self, root_path = None, instance_num = 0): + self.root_path = Path(root_path or os.path.dirname(__file__)) + self.instance_num = instance_num + self.config_path = self.root_path / f'{instance_num}.yml' + with open(self.config_path, mode='w') as temp_file: + compose_content = _compose_template.format( + instance = self.instance_num, + web_port = 8006 + self.instance_num, + control_port = 5000 + self.instance_num, + omniboxes_path = self.root_path + ) + temp_file.write(compose_content) + + def create(self): + if not os.path.exists(f"omnibox-{self.instance_num}"): + os.makedirs(f"omnibox-{self.instance_num}") + subprocess.run(["cp", "-r", f"{str(self.root_path)}/common/win11storage/.", f"{self.root_path}/omnibox-{self.instance_num}/"]) + + try: + subprocess.run( + ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "up", "-d"], + check=True, + stdout=subprocess.DEVNULL, # Suppress standard output + stderr=subprocess.DEVNULL # Suppress error output + ) + print(f"Instance {self.instance_num} launched successfully!") + except subprocess.CalledProcessError as e: + print(f"Error launching instance {self.instance_num}: {e}") + + def start(self): + try: + subprocess.run( + ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "start"], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL + ) + print(f"Instance {self.instance_num} started successfully!") + except subprocess.CalledProcessError as e: + print(f"Error starting instance {self.instance_num}: {e}") + + def stop(self): + try: + subprocess.run( + ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "stop"], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL + ) + print(f"Instance {self.instance_num} stopped successfully!") + except subprocess.CalledProcessError as e: + print(f"Error stopping instance {self.instance_num}: {e}") + + def delete(self): + try: + subprocess.run( + ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "down"], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL + ) + print(f"Instance {self.instance_num} deleted successfully!") + except subprocess.CalledProcessError as e: + print(f"Error deleting instance {self.instance_num}: {e}") + + def flask_url(self): + return f"http://localhost:{5000 + self.instance_num}" + + def is_ready(self): + try: + response = requests.get(self.flask_url() + "/probe", timeout=1) + return response.status_code == 200 + except requests.RequestException as e: + return False + + def reset(self): + self.delete() + if os.path.exists(f"omnibox-{self.instance_num}"): + subprocess.run(["sudo", "rm", "-rf", f"{self.root_path}/omnibox-{self.instance_num}"], check=True) + self.create() + + def reset_soft(self): + self.stop() + if os.path.exists(f"omnibox-{self.instance_num}"): + subprocess.run(["sudo", "rm", "-rf", f"{self.root_path}/omnibox-{self.instance_num}"], check=True) + self.start() + + +def reset_with_callback(instance, callback): + try: + instance.reset() + while not instance.is_ready(): + time.sleep(1) + callback(instance) + except Exception as e: + print(f"Error in reset worker: {str(e)}") + + +# got insufficient perf with this method +def reset_soft_with_callback(instance, callback): + try: + instance.reset_soft() + while not instance.is_ready(): + time.sleep(1) + callback(instance) + except Exception as e: + print(f"Error in reset worker: {str(e)}") + From 33df3887a3a9f05f8a29a3c1cfad320bd289530b Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Tue, 6 May 2025 15:32:26 +0000 Subject: [PATCH 10/27] host client --- omnitool/omnibox/client/client.py | 124 +++++++++++++++++++++++++++++- 1 file changed, 123 insertions(+), 1 deletion(-) diff --git a/omnitool/omnibox/client/client.py b/omnitool/omnibox/client/client.py index d3ae6845..7c57e5a6 100644 --- a/omnitool/omnibox/client/client.py +++ b/omnitool/omnibox/client/client.py @@ -62,7 +62,7 @@ def _screensize(): } -class Client: +class InstanceClient: def __init__(self, host = 'localhost', port = 5000): self.host = host self.port = port @@ -132,3 +132,125 @@ def ui(self): ipywidgets.HBox([click, rightClick, doubleClick]), ipywidgets.HBox([cmd, ipywidgets.VBox([shell, python]), submit]), self.output])) + + +class HostClient: + def __init__(self, host = 'localhost', port = 8000): + self.host = host + self.port = port + self.output = None + self.instance_id = None + + def get_instance(self): + data = requests.post(f'http://{self.host}:{self.port}/getinstance') + instance_id = data.json()['instance_uuid'] + return instance_id + + def get_instances_info(self): + data = requests.get(f'http://{self.host}:{self.port}/instances/info') + return data.json() + + def reset_instance(self, instance_id): + data = requests.post(f'http://{self.host}:{self.port}/resetinstance/{instance_id}') + if data.status_code != 200: + raise Exception(f"Error: {data.status_code} - {data.text}") + return data.json() + + def screenshot(self, instance_id): + data = requests.get(f'http://{self.host}:{self.port}/executeinstance/{instance_id}/screenshot') + image_data = io.BytesIO(data.content) + return Image.open(image_data) + + def execute(self, instance_id, command): + return requests.post(f'http://{self.host}:{self.port}/executeinstance/{instance_id}/execute', json = command) + + def do_and_show(self, instance_id, command, waitTime): + response = self.execute(instance_id, command) + if response.status_code != 200: + raise Exception(f"Error: {response.status_code} - {response.text}") + time.sleep(waitTime) + self._display(instance_id, response.json()['output']) + + def _display(self, instance_id, data = None): + with self.output: + self.output.clear_output(wait = True) + display(self.screenshot(instance_id)) + print(data) + + def position(self, instance_id): + return json.loads(self.execute(instance_id, _position()).json()['output']) + + def screensize(self, instance_id): + return json.loads(self.execute(instance_id, _screensize()).json()['output']) + + def ui(self): + self.output = ipywidgets.Output() + + get_button = ipywidgets.Button(description = 'Get Instance') + release_button = ipywidgets.Button(description = 'Release Instance') + instances = ipywidgets.RadioButtons(description = 'Instances', options = self.get_instances_info()['in_use'], layout=ipywidgets.Layout(width='50%')) + + def on_add_click(b): + self.get_instance() + info = self.get_instances_info() + instances.options = info['in_use'] + + def on_release_click(b): + self.reset_instance(instances.value) + info = self.get_instances_info() + instances.options = info['in_use'] + + get_button.on_click(on_add_click) + release_button.on_click(on_release_click) + + waitTime = ipywidgets.FloatLogSlider(base=2, value = 1, min = -3, max = 5, step = 1, description = 'wait (s)') + + screensize = {} + position = {} + if self.instance_id: + screensize = self.screensize(self.instance_id) + position = self.position(self.instance_id) + + x = ipywidgets.IntSlider(min = 0, max = screensize.get('width', 1), value = position.get('x', 0), description = 'X') + y = ipywidgets.IntSlider(min = 0, max = screensize.get('height', 1), value = position.get('y', 0), description = 'Y') + + click = ipywidgets.Button(description = 'Click') + rightClick = ipywidgets.Button(description = 'Right Click') + doubleClick = ipywidgets.Button(description = 'Double Click') + + x.observe(lambda v: self.do_and_show(self.instance_id, _moveTo(x.value, y.value), waitTime.value), names='value') + y.observe(lambda v: self.do_and_show(self.instance_id, _moveTo(x.value, y.value), waitTime.value), names='value') + + click.on_click(lambda v: self.do_and_show(self.instance_id, _click(), waitTime.value)) + rightClick.on_click(lambda v: self.do_and_show(self.instance_id, _rightClick(), waitTime.value)) + doubleClick.on_click(lambda v: self.do_and_show(self.instance_id, _doubleClick(), waitTime.value)) + + cmd = ipywidgets.Textarea(description = 'Commands', layout=ipywidgets.Layout(width='50%')) + shell = ipywidgets.Checkbox(description = 'Shell', value = False) + python = ipywidgets.Checkbox(description = 'Python', value = True) + submit = ipywidgets.Button(description = 'Submit') + submit.on_click(lambda v: self.do_and_show(self.instance_id, { + 'command': _pyscript(cmd.value.split('\n')) if python.value else '&&'.join(cmd.value.split('\n')), + 'shell': shell.value + }, waitTime.value)) + + def on_instance_change(_): + self.instance_id = instances.value + screensize = self.screensize(self.instance_id) + x.max = screensize.get('width', 1) + y.max = screensize.get('height', 1) + position = self.position(self.instance_id) + x.value = position.get('x', 0) + y.value = position.get('y', 0) + self._display(self.instance_id) + + instances.observe(on_instance_change, names='value') + + display(ipywidgets.VBox([ + ipywidgets.HBox([instances, ipywidgets.VBox([get_button, release_button])]), + waitTime, + ipywidgets.HBox([x, y]), + ipywidgets.HBox([click, rightClick, doubleClick]), + ipywidgets.HBox([cmd, ipywidgets.VBox([shell, python]), submit]), + self.output])) + From e37a0c5168f0da4d874b911f92065fce0ba3e6b9 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Tue, 6 May 2025 15:32:53 +0000 Subject: [PATCH 11/27] notebook update --- omnitool/omnibox/client/notebook.ipynb | 314 ++++++++++++++++++++++++- 1 file changed, 311 insertions(+), 3 deletions(-) diff --git a/omnitool/omnibox/client/notebook.ipynb b/omnitool/omnibox/client/notebook.ipynb index bbdd7f4e..44df00e6 100644 --- a/omnitool/omnibox/client/notebook.ipynb +++ b/omnitool/omnibox/client/notebook.ipynb @@ -1,15 +1,323 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "578457c0", + "metadata": {}, + "source": [ + "# Test instance" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "ae7b2936", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "905146bb7cb44a95b9a30410f499b2df", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(FloatLogSlider(value=1.0, base=2.0, description='wait (s)', max=5.0, min=-3.0, step=1.0), HBox(…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import client\n", - "client.Client(port = 5000).ui()" + "client.InstanceClient(port = 5001).ui()" + ] + }, + { + "cell_type": "markdown", + "id": "741598f1", + "metadata": {}, + "source": [ + "# Test host" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eca33f8c", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c5ac9102430f4a8d8861efcfa05aa0ff", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(RadioButtons(description='Instances', layout=Layout(width='50%'), options=('9740…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "ename": "KeyError", + "evalue": "'output'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mKeyError\u001b[39m Traceback (most recent call last)", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/ipywidgets/widgets/widget.py:773\u001b[39m, in \u001b[36mWidget._handle_msg\u001b[39m\u001b[34m(self, msg)\u001b[39m\n\u001b[32m 771\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[33m'\u001b[39m\u001b[33mbuffer_paths\u001b[39m\u001b[33m'\u001b[39m \u001b[38;5;129;01min\u001b[39;00m data:\n\u001b[32m 772\u001b[39m _put_buffers(state, data[\u001b[33m'\u001b[39m\u001b[33mbuffer_paths\u001b[39m\u001b[33m'\u001b[39m], msg[\u001b[33m'\u001b[39m\u001b[33mbuffers\u001b[39m\u001b[33m'\u001b[39m])\n\u001b[32m--> \u001b[39m\u001b[32m773\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mset_state\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 775\u001b[39m \u001b[38;5;66;03m# Handle a state request.\u001b[39;00m\n\u001b[32m 776\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m method == \u001b[33m'\u001b[39m\u001b[33mrequest_state\u001b[39m\u001b[33m'\u001b[39m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/ipywidgets/widgets/widget.py:650\u001b[39m, in \u001b[36mWidget.set_state\u001b[39m\u001b[34m(self, sync_data)\u001b[39m\n\u001b[32m 645\u001b[39m \u001b[38;5;28mself\u001b[39m._send(msg, buffers=echo_buffers)\n\u001b[32m 647\u001b[39m \u001b[38;5;66;03m# The order of these context managers is important. Properties must\u001b[39;00m\n\u001b[32m 648\u001b[39m \u001b[38;5;66;03m# be locked when the hold_trait_notification context manager is\u001b[39;00m\n\u001b[32m 649\u001b[39m \u001b[38;5;66;03m# released and notifications are fired.\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m650\u001b[39m \u001b[43m\u001b[49m\u001b[38;5;28;43;01mwith\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_lock_property\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43msync_data\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mhold_trait_notifications\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m 651\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43msync_data\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m 652\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m:\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/contextlib.py:144\u001b[39m, in \u001b[36m_GeneratorContextManager.__exit__\u001b[39m\u001b[34m(self, typ, value, traceback)\u001b[39m\n\u001b[32m 142\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m typ \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 143\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m144\u001b[39m \u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 145\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m:\n\u001b[32m 146\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1510\u001b[39m, in \u001b[36mHasTraits.hold_trait_notifications\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 1508\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m changes \u001b[38;5;129;01min\u001b[39;00m cache.values():\n\u001b[32m 1509\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m change \u001b[38;5;129;01min\u001b[39;00m changes:\n\u001b[32m-> \u001b[39m\u001b[32m1510\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mnotify_change\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchange\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/ipywidgets/widgets/widget.py:701\u001b[39m, in \u001b[36mWidget.notify_change\u001b[39m\u001b[34m(self, change)\u001b[39m\n\u001b[32m 698\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.keys \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m._should_send_property(name, \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, name)):\n\u001b[32m 699\u001b[39m \u001b[38;5;66;03m# Send new state to front-end\u001b[39;00m\n\u001b[32m 700\u001b[39m \u001b[38;5;28mself\u001b[39m.send_state(key=name)\n\u001b[32m--> \u001b[39m\u001b[32m701\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mnotify_change\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchange\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1525\u001b[39m, in \u001b[36mHasTraits.notify_change\u001b[39m\u001b[34m(self, change)\u001b[39m\n\u001b[32m 1523\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mnotify_change\u001b[39m(\u001b[38;5;28mself\u001b[39m, change: Bunch) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 1524\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Notify observers of a change event\"\"\"\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1525\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_notify_observers\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchange\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1568\u001b[39m, in \u001b[36mHasTraits._notify_observers\u001b[39m\u001b[34m(self, event)\u001b[39m\n\u001b[32m 1565\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(c, EventHandler) \u001b[38;5;129;01mand\u001b[39;00m c.name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 1566\u001b[39m c = \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, c.name)\n\u001b[32m-> \u001b[39m\u001b[32m1568\u001b[39m \u001b[43mc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mevent\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/ipywidgets/widgets/widget_selection.py:236\u001b[39m, in \u001b[36m_Selection._propagate_index\u001b[39m\u001b[34m(self, change)\u001b[39m\n\u001b[32m 234\u001b[39m \u001b[38;5;28mself\u001b[39m.label = label\n\u001b[32m 235\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.value \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m value:\n\u001b[32m--> \u001b[39m\u001b[32m236\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvalue\u001b[49m = value\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:716\u001b[39m, in \u001b[36mTraitType.__set__\u001b[39m\u001b[34m(self, obj, value)\u001b[39m\n\u001b[32m 714\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.read_only:\n\u001b[32m 715\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m TraitError(\u001b[33m'\u001b[39m\u001b[33mThe \u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m\"\u001b[39m\u001b[33m trait is read-only.\u001b[39m\u001b[33m'\u001b[39m % \u001b[38;5;28mself\u001b[39m.name)\n\u001b[32m--> \u001b[39m\u001b[32m716\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mset\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:706\u001b[39m, in \u001b[36mTraitType.set\u001b[39m\u001b[34m(self, obj, value)\u001b[39m\n\u001b[32m 702\u001b[39m silent = \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[32m 703\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m silent \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[32m 704\u001b[39m \u001b[38;5;66;03m# we explicitly compare silent to True just in case the equality\u001b[39;00m\n\u001b[32m 705\u001b[39m \u001b[38;5;66;03m# comparison above returns something other than True/False\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m706\u001b[39m \u001b[43mobj\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_notify_trait\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mold_value\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnew_value\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1513\u001b[39m, in \u001b[36mHasTraits._notify_trait\u001b[39m\u001b[34m(self, name, old_value, new_value)\u001b[39m\n\u001b[32m 1512\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_notify_trait\u001b[39m(\u001b[38;5;28mself\u001b[39m, name: \u001b[38;5;28mstr\u001b[39m, old_value: t.Any, new_value: t.Any) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1513\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mnotify_change\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1514\u001b[39m \u001b[43m \u001b[49m\u001b[43mBunch\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1515\u001b[39m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m=\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1516\u001b[39m \u001b[43m \u001b[49m\u001b[43mold\u001b[49m\u001b[43m=\u001b[49m\u001b[43mold_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1517\u001b[39m \u001b[43m \u001b[49m\u001b[43mnew\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnew_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1518\u001b[39m \u001b[43m \u001b[49m\u001b[43mowner\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 1519\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mtype\u001b[39;49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mchange\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 1520\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1521\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/ipywidgets/widgets/widget.py:701\u001b[39m, in \u001b[36mWidget.notify_change\u001b[39m\u001b[34m(self, change)\u001b[39m\n\u001b[32m 698\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.keys \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m._should_send_property(name, \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, name)):\n\u001b[32m 699\u001b[39m \u001b[38;5;66;03m# Send new state to front-end\u001b[39;00m\n\u001b[32m 700\u001b[39m \u001b[38;5;28mself\u001b[39m.send_state(key=name)\n\u001b[32m--> \u001b[39m\u001b[32m701\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mnotify_change\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchange\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1525\u001b[39m, in \u001b[36mHasTraits.notify_change\u001b[39m\u001b[34m(self, change)\u001b[39m\n\u001b[32m 1523\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mnotify_change\u001b[39m(\u001b[38;5;28mself\u001b[39m, change: Bunch) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 1524\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Notify observers of a change event\"\"\"\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1525\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_notify_observers\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchange\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1568\u001b[39m, in \u001b[36mHasTraits._notify_observers\u001b[39m\u001b[34m(self, event)\u001b[39m\n\u001b[32m 1565\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(c, EventHandler) \u001b[38;5;129;01mand\u001b[39;00m c.name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 1566\u001b[39m c = \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, c.name)\n\u001b[32m-> \u001b[39m\u001b[32m1568\u001b[39m \u001b[43mc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mevent\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/ataymano/OmniParser/omnitool/omnibox/client/client.py:239\u001b[39m, in \u001b[36mHostClient.ui..on_instance_change\u001b[39m\u001b[34m(_)\u001b[39m\n\u001b[32m 237\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mon_instance_change\u001b[39m(_):\n\u001b[32m 238\u001b[39m \u001b[38;5;28mself\u001b[39m.instance_id = instances.value\n\u001b[32m--> \u001b[39m\u001b[32m239\u001b[39m screensize = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mscreensize\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43minstance_id\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 240\u001b[39m x.max = screensize.get(\u001b[33m'\u001b[39m\u001b[33mwidth\u001b[39m\u001b[33m'\u001b[39m, \u001b[32m1\u001b[39m)\n\u001b[32m 241\u001b[39m y.max = screensize.get(\u001b[33m'\u001b[39m\u001b[33mheight\u001b[39m\u001b[33m'\u001b[39m, \u001b[32m1\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/ataymano/OmniParser/omnitool/omnibox/client/client.py:184\u001b[39m, in \u001b[36mHostClient.screensize\u001b[39m\u001b[34m(self, instance_id)\u001b[39m\n\u001b[32m 183\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mscreensize\u001b[39m(\u001b[38;5;28mself\u001b[39m, instance_id):\n\u001b[32m--> \u001b[39m\u001b[32m184\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m json.loads(\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\u001b[43minstance_id\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_screensize\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mjson\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43moutput\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m]\u001b[49m)\n", + "\u001b[31mKeyError\u001b[39m: 'output'" + ] + } + ], + "source": [ + "import client\n", + "c = client.HostClient(port = 8000)\n", + "c.ui()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7279ac3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6b8d2c38", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d3d776ca4d9f4192a5c05abffdc2b37b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "RadioButtons(options=('a', 'b'), value='a')" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "('a', 'b', 'c')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import ipywidgets\n", + "a = ipywidgets.RadioButtons(options=['a', 'b'])\n", + "display(a)\n", + "a.options = ['a', 'b', 'c']\n", + "a.options" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5b889bd4", + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "HostClient.screensize() missing 1 required positional argument: 'instance_id'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mc\u001b[49m\u001b[43m.\u001b[49m\u001b[43mui\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/ataymano/OmniParser/omnitool/omnibox/client/client.py:202\u001b[39m, in \u001b[36mHostClient.ui\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 199\u001b[39m get_button.on_click(on_add_click)\n\u001b[32m 200\u001b[39m release_button.on_click(on_release_click) \n\u001b[32m--> \u001b[39m\u001b[32m202\u001b[39m screensize = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mscreensize\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 203\u001b[39m position = \u001b[38;5;28mself\u001b[39m.position()\n\u001b[32m 206\u001b[39m waitTime = ipywidgets.FloatLogSlider(base=\u001b[32m2\u001b[39m, value = \u001b[32m1\u001b[39m, \u001b[38;5;28mmin\u001b[39m = -\u001b[32m3\u001b[39m, \u001b[38;5;28mmax\u001b[39m = \u001b[32m5\u001b[39m, step = \u001b[32m1\u001b[39m, description = \u001b[33m'\u001b[39m\u001b[33mwait (s)\u001b[39m\u001b[33m'\u001b[39m)\n", + "\u001b[31mTypeError\u001b[39m: HostClient.screensize() missing 1 required positional argument: 'instance_id'" + ] + } + ], + "source": [ + "c.ui()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c0b07ec6", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8661ac79cb7542b29593730b898b34f9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "RadioButtons(options=(), value=None)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import ipywidgets\n", + "\n", + "options = ipywidgets.RadioButtons(options=[])\n", + "display(options)\n", + "options.value" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5f9aa0f6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c.screenshot('dc8cacc7-d317-4dde-a8e4-b0a70b6c754b')" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "55666faf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1, 3}" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "set([1,2,3]) - {2}" ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1f2e8d3a", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0e034995b8f245b59476524287739e62", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "RadioButtons(description='bla', options=('a', 'b'), value='a')" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import ipywidgets\n", + "opts = ipywidgets.RadioButtons(options = ['a', 'b'], description='bla')\n", + "display(opts)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4fe6618b", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84d5057ca8d540c5a1a2666b9551f092", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Button(description='Click me!', style=ButtonStyle())" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5f51d260fe5642db9afc32558abe52ec", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "RadioButtons(description='bla', options=(), value=None)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import ipywidgets\n", + "\n", + "button = ipywidgets.Button(description=\"Click me!\")\n", + "opts = ipywidgets.RadioButtons(options = [], description='bla')\n", + "def on_button_click(b):\n", + " opts.options = list(opts.options) + [str(len(opts.options))]\n", + "button.on_click(on_button_click)\n", + "display(button, opts)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "124b7781", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From be00f11805a6db6ac2fff7c79a48980020bfb33f Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Tue, 6 May 2025 15:40:09 +0000 Subject: [PATCH 12/27] minor fixes --- omnitool/omnibox/client/client.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/omnitool/omnibox/client/client.py b/omnitool/omnibox/client/client.py index 7c57e5a6..0f87ea7d 100644 --- a/omnitool/omnibox/client/client.py +++ b/omnitool/omnibox/client/client.py @@ -189,7 +189,7 @@ def ui(self): get_button = ipywidgets.Button(description = 'Get Instance') release_button = ipywidgets.Button(description = 'Release Instance') instances = ipywidgets.RadioButtons(description = 'Instances', options = self.get_instances_info()['in_use'], layout=ipywidgets.Layout(width='50%')) - + self.instance_id = instances.value def on_add_click(b): self.get_instance() info = self.get_instances_info() @@ -210,6 +210,7 @@ def on_release_click(b): if self.instance_id: screensize = self.screensize(self.instance_id) position = self.position(self.instance_id) + self._display(self.instance_id) x = ipywidgets.IntSlider(min = 0, max = screensize.get('width', 1), value = position.get('x', 0), description = 'X') y = ipywidgets.IntSlider(min = 0, max = screensize.get('height', 1), value = position.get('y', 0), description = 'Y') From 0a9b20d23e2e506e1983a8d5931200c7626ea22e Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Tue, 6 May 2025 15:40:21 +0000 Subject: [PATCH 13/27] custom port --- omnitool/omnibox/host/host.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/omnitool/omnibox/host/host.py b/omnitool/omnibox/host/host.py index 3f368b5c..4d5f29a6 100644 --- a/omnitool/omnibox/host/host.py +++ b/omnitool/omnibox/host/host.py @@ -11,6 +11,7 @@ import uuid from tqdm import tqdm from contextlib import asynccontextmanager +import argparse @asynccontextmanager async def lifespan(app: FastAPI): @@ -123,5 +124,8 @@ def get_available_instances(): if __name__ == "__main__": - uvicorn.run(app, host="0.0.0.0", port=8000) + parser = argparse.ArgumentParser(description="OmniBox Host") + parser.add_argument("--port", type=int, default=8000, help="Port to run the server on") + args = parser.parse_args() + uvicorn.run(app, host="0.0.0.0", port=args.port) From 9d5b728b0f11afc142a0ee13a1a3eb86a19bfa71 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Wed, 7 May 2025 02:02:33 +0000 Subject: [PATCH 14/27] refactoring --- omnitool/omnibox/host/host.py | 131 ------------------ omnitool/omnibox/{host => node}/instance.py | 9 +- omnitool/omnibox/node/instance_client.py | 39 ++++++ omnitool/omnibox/node/instance_manager.py | 62 +++++++++ .../omnibox/{host => node}/mock_instance.py | 0 omnitool/omnibox/node/requirements.txt | 4 + omnitool/omnibox/node/server.py | 87 ++++++++++++ 7 files changed, 195 insertions(+), 137 deletions(-) delete mode 100644 omnitool/omnibox/host/host.py rename omnitool/omnibox/{host => node}/instance.py (96%) create mode 100644 omnitool/omnibox/node/instance_client.py create mode 100644 omnitool/omnibox/node/instance_manager.py rename omnitool/omnibox/{host => node}/mock_instance.py (100%) create mode 100644 omnitool/omnibox/node/requirements.txt create mode 100644 omnitool/omnibox/node/server.py diff --git a/omnitool/omnibox/host/host.py b/omnitool/omnibox/host/host.py deleted file mode 100644 index 4d5f29a6..00000000 --- a/omnitool/omnibox/host/host.py +++ /dev/null @@ -1,131 +0,0 @@ -import os -from fastapi import FastAPI, HTTPException, Response -from fastapi.responses import JSONResponse, StreamingResponse -import requests -import uvicorn -import concurrent.futures -from typing import List, Dict, Any, Optional -from instance import Instance, reset_with_callback -from mock_instance import MockInstance as Instance -import time -import uuid -from tqdm import tqdm -from contextlib import asynccontextmanager -import argparse - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup code goes here - yield - # Shutdown code goes here - if reset_executor: - reset_executor.shutdown(wait=True, cancel_futures=False) - -app = FastAPI(lifespan=lifespan) - -INSTANCES = 2 -available_instances = {} # instance_num to instance -in_use = {} # key = instance_uuid, value = instance_id - -RESET_WORKERS = 2 -reset_executor = concurrent.futures.ThreadPoolExecutor(max_workers=RESET_WORKERS) - -def instance_reset_callback(instance): - available_instances[instance.instance_num] = instance - -for i in range(INSTANCES): - reset_executor.submit(reset_with_callback, Instance(instance_num=i), instance_reset_callback) - -# Wait for all instances to be initialized -with tqdm(total=INSTANCES, desc="Initializing instances") as pbar: - last_count = 0 - while len(available_instances) < INSTANCES: - current_count = len(available_instances) - if current_count > last_count: - pbar.update(current_count - last_count) - last_count = current_count - time.sleep(0.1) - pbar.update(INSTANCES - last_count) - -@app.post("/getinstance") -def get_instance(): - """Get an available instance from the pool""" - if not available_instances: - raise HTTPException(status_code=503, detail="No instances available") - - instance = available_instances.pop(list(available_instances.keys())[0]) - instance_uuid = str(uuid.uuid4()) - in_use[instance_uuid] = instance - return {"instance_uuid": instance_uuid} - -@app.post("/resetinstance/{instance_uuid}") -def reset_instance(instance_uuid: str): - """Reset an instance to its initial state and make it available again""" - if instance_uuid not in in_use: - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") - - instance = in_use[instance_uuid] - reset_executor.submit(reset_with_callback, instance, instance_reset_callback) - - return {"status": "success", "message": f"UUID {instance_uuid} for instance {instance.instance_num} has been queued for reset"} - -@app.post("/executeinstance/{instance_uuid}/execute") -async def execute_instance_command(instance_uuid: str, command_data: Dict[str, Any]): - """Forward execute command to the Flask server in the specified instance""" - if instance_uuid not in in_use: - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") - - instance = in_use[instance_uuid] - try: - response = requests.post(instance.flask_url() + "/execute", json=command_data, timeout=5) - return JSONResponse(content=response.json(), status_code=response.status_code) - except requests.RequestException as e: - raise HTTPException(status_code=500, detail=f"Error communicating with instance {instance.instance_num}: {str(e)}") - -@app.get("/executeinstance/{instance_uuid}/screenshot") -async def get_instance_screenshot(instance_uuid: str): - """Forward screenshot request to the Flask server in the specified instance""" - if instance_uuid not in in_use: - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") - - instance = in_use[instance_uuid] - try: - response = requests.get(instance.flask_url() + "/screenshot", timeout=5) - - if response.status_code == 200: - return Response(content=response.content, media_type="image/png") - else: - return JSONResponse( - content={"status": "error", "message": f"Failed to get screenshot: {response.text}"}, - status_code=response.status_code - ) - except requests.RequestException as e: - raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance.instance_num}: {str(e)}") - -@app.get("/executeinstance/{instance_uuid}/probe") -async def probe_instance(instance_uuid: str): - """Forward probe request to the Flask server in the specified instance""" - if instance_uuid not in in_use: - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") - - instance= in_use[instance_uuid] - try: - response = requests.get(instance.flask_url() + "/probe", timeout=1) - return JSONResponse(content=response.json(), status_code=response.status_code) - except requests.RequestException as e: - raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance.instance_num}: {str(e)}") - -@app.get("/instances/info") -def get_available_instances(): - """Get an available instance from the pool""" - return { - 'available': len(available_instances), - 'in_use': list(in_use.keys())} - - -if __name__ == "__main__": - parser = argparse.ArgumentParser(description="OmniBox Host") - parser.add_argument("--port", type=int, default=8000, help="Port to run the server on") - args = parser.parse_args() - uvicorn.run(app, host="0.0.0.0", port=args.port) - diff --git a/omnitool/omnibox/host/instance.py b/omnitool/omnibox/node/instance.py similarity index 96% rename from omnitool/omnibox/host/instance.py rename to omnitool/omnibox/node/instance.py index f8897366..cbe4b9cb 100644 --- a/omnitool/omnibox/host/instance.py +++ b/omnitool/omnibox/node/instance.py @@ -1,9 +1,9 @@ import os import subprocess -import tempfile import time import requests from pathlib import Path +from typing import Dict, Any class IInstance: @@ -29,10 +29,7 @@ def reset(self): raise NotImplementedError("Subclasses should implement this!") def reset_soft(self): - self.stop() - if os.path.exists(f"omnibox-{self.instance_num}"): - subprocess.run(["sudo", "rm", "-rf", f"{self.root_path}/omnibox-{self.instance_num}"], check=True) - self.start() + raise NotImplementedError("Subclasses should implement this!") _compose_template = """ @@ -69,7 +66,7 @@ def reset_soft(self): class Instance(IInstance): def __init__(self, root_path = None, instance_num = 0): - self.root_path = Path(root_path or os.path.dirname(__file__)) + self.root_path = Path(root_path or os.path.dirname(__file__)).resolve() self.instance_num = instance_num self.config_path = self.root_path / f'{instance_num}.yml' with open(self.config_path, mode='w') as temp_file: diff --git a/omnitool/omnibox/node/instance_client.py b/omnitool/omnibox/node/instance_client.py new file mode 100644 index 00000000..a8e94c2d --- /dev/null +++ b/omnitool/omnibox/node/instance_client.py @@ -0,0 +1,39 @@ +from typing import Dict, Any +from fastapi.responses import JSONResponse +from fastapi import FastAPI, HTTPException, Response +import requests + +class InstanceClient: + def __init__(self, url): + self.url = url + + def execute(self, command_data: Dict[str, Any]): + """Forward execute command to the Flask server in the specified instance""" + try: + response = requests.post(f"{self.url}/execute", json=command_data, timeout=5) + return JSONResponse(content=response.json(), status_code=response.status_code) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with theinstance {self.url}: {str(e)}") + + def screenshot(self): + """Forward screenshot request to the Flask server in the specified instance""" + try: + response = requests.get(f"{self.url}/screenshot", timeout=5) + + if response.status_code == 200: + return Response(content=response.content, media_type="image/png") + else: + return JSONResponse( + content={"status": "error", "message": f"Failed to get screenshot: {response.text}"}, + status_code=response.status_code + ) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with the instance {self.url}: {str(e)}") + + def probe(self): + """Forward probe request to the Flask server in the specified instance""" + try: + response = requests.get(f"{self.url}/probe", timeout=1) + return JSONResponse(content=response.json(), status_code=response.status_code) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with the instance {self.url}: {str(e)}") diff --git a/omnitool/omnibox/node/instance_manager.py b/omnitool/omnibox/node/instance_manager.py new file mode 100644 index 00000000..f68297cd --- /dev/null +++ b/omnitool/omnibox/node/instance_manager.py @@ -0,0 +1,62 @@ +import concurrent +from instance import Instance, reset_with_callback +#from mock_instance import MockInstance as Instance +from tqdm import tqdm +import time +import uuid +from typing import Dict, Any +from pathlib import Path +import os + + +class InstanceManager: + def __init__(self, path = None, capacity: int = 2): + self.capacity = capacity + self.available_instances = {} # instance_num to instance + self.in_use = {} # key = instance_uuid, value = instance_id + + self.reset_workers = capacity + self.reset_executor = concurrent.futures.ThreadPoolExecutor(max_workers=self.reset_workers) + self.path = Path(path or os.path.dirname(__file__)).resolve() + + for i in range(self.capacity): + self.reset_executor.submit(reset_with_callback, Instance(self.path, instance_num=i), self.instance_reset_callback) + + # Wait for all instances to be initialized + with tqdm(total=self.capacity, desc="Initializing instances") as pbar: + last_count = 0 + while len(self.available_instances) < self.capacity: + current_count = len(self.available_instances) + if current_count > last_count: + pbar.update(current_count - last_count) + last_count = current_count + time.sleep(0.1) + pbar.update(self.capacity - last_count) + + def instance_reset_callback(self, instance): + self.available_instances[instance.instance_num] = instance + + def shutdown(self): + if self.reset_executor: + self.reset_executor.shutdown(wait=True, cancel_futures=False) + + def start(self): + if not self.available_instances: + return None + + instance = self.available_instances.pop(list(self.available_instances.keys())[0]) + instance_uuid = str(uuid.uuid4()) + self.in_use[instance_uuid] = instance + return instance_uuid + + def reset(self, instance_uuid: str): + if instance_uuid not in self.in_use: + return False + + instance = self.in_use[instance_uuid] + self.reset_executor.submit(reset_with_callback, instance, self.instance_reset_callback) + return True + + def get(self, uuid: str): + return self.in_use.get(uuid, None) + \ No newline at end of file diff --git a/omnitool/omnibox/host/mock_instance.py b/omnitool/omnibox/node/mock_instance.py similarity index 100% rename from omnitool/omnibox/host/mock_instance.py rename to omnitool/omnibox/node/mock_instance.py diff --git a/omnitool/omnibox/node/requirements.txt b/omnitool/omnibox/node/requirements.txt new file mode 100644 index 00000000..4f1aa032 --- /dev/null +++ b/omnitool/omnibox/node/requirements.txt @@ -0,0 +1,4 @@ +fastapi[standard] +requests +tqdm +flask diff --git a/omnitool/omnibox/node/server.py b/omnitool/omnibox/node/server.py new file mode 100644 index 00000000..843914a7 --- /dev/null +++ b/omnitool/omnibox/node/server.py @@ -0,0 +1,87 @@ +from fastapi import FastAPI, HTTPException +import requests +import uvicorn +from typing import Dict, Any +from contextlib import asynccontextmanager +import argparse +from instance_manager import InstanceManager +from instance_client import InstanceClient +from pathlib import Path + +parser = argparse.ArgumentParser(description="OmniBox Host") +parser.add_argument("--port", type=int, default=8000, help="Port to run the server on") +parser.add_argument('--path', type=str, default='/home/azureuser/ataymano/OmniParser/omnitool/omnibox/run1', help="Path to the instance directory. Expected to contain prepared common subfolder") +args = parser.parse_args() + +Path(args.path).mkdir(parents=True, exist_ok=True) +instance_manager = InstanceManager(args.path) + +@asynccontextmanager +async def lifespan(app: FastAPI): + # Startup code goes here + yield + instance_manager.shutdown() + + +app = FastAPI(lifespan=lifespan) + +@app.post("/getinstance") +def get_instance(): + """Get an available instance from the pool""" + instance_uuid = instance_manager.start() + if not instance_uuid: + raise HTTPException(status_code=503, detail="No instances available") + return {"instance_uuid": instance_uuid} + +@app.post("/resetinstance/{instance_uuid}") +def reset_instance(instance_uuid: str): + """Reset an instance to its initial state and make it available again""" + if instance_manager.reset(instance_uuid): + return {"status": "success", "message": f"UUID {instance_uuid} for instance has been queued for reset"} + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + +@app.post("/executeinstance/{instance_uuid}/execute") +async def execute_instance_command(instance_uuid: str, command_data: Dict[str, Any]): + """Forward execute command to the Flask server in the specified instance""" + instance= instance_manager.get(instance_uuid) + if not instance: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + try: + return InstanceClient(instance.flask_url()).execute(command_data) + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with instance {instance.instance_num}: {str(e)}") + +@app.get("/executeinstance/{instance_uuid}/screenshot") +async def get_instance_screenshot(instance_uuid: str): + """Forward screenshot request to the Flask server in the specified instance""" + instance = instance_manager.get(instance_uuid) + if not instance: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + try: + return InstanceClient(instance.flask_url()).screenshot() + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance.instance_num}: {str(e)}") + +@app.get("/executeinstance/{instance_uuid}/probe") +async def probe_instance(instance_uuid: str): + """Forward probe request to the Flask server in the specified instance""" + instance= instance_manager.get(instance_uuid) + if not instance: + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + try: + return InstanceClient(instance.flask_url()).probe() + except requests.RequestException as e: + raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance.instance_num}: {str(e)}") + +@app.get("/instances/info") +def get_available_instances(): + """Get an available instance from the pool""" + return { + 'available': len(instance_manager.available_instances), + 'capacity': instance_manager.capacity, + 'in_use': list(instance_manager.in_use.keys())} + + +if __name__ == "__main__": + uvicorn.run(app, host="0.0.0.0", port=args.port) + From f69e20bdba21134045a54793a7b54331be38fde2 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Wed, 7 May 2025 02:02:50 +0000 Subject: [PATCH 15/27] client update --- omnitool/omnibox/client/client.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/omnitool/omnibox/client/client.py b/omnitool/omnibox/client/client.py index 0f87ea7d..96fcef1c 100644 --- a/omnitool/omnibox/client/client.py +++ b/omnitool/omnibox/client/client.py @@ -134,7 +134,7 @@ def ui(self): self.output])) -class HostClient: +class NodeClient: def __init__(self, host = 'localhost', port = 8000): self.host = host self.port = port From 8db30346a11a32d9d21e5345bc9d9f2feaef7440 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Wed, 7 May 2025 02:05:05 +0000 Subject: [PATCH 16/27] forgotten changes --- omnitool/omnibox/src/host.py | 124 -------------------- omnitool/omnibox/src/instance.py | 190 ------------------------------- 2 files changed, 314 deletions(-) delete mode 100644 omnitool/omnibox/src/host.py delete mode 100644 omnitool/omnibox/src/instance.py diff --git a/omnitool/omnibox/src/host.py b/omnitool/omnibox/src/host.py deleted file mode 100644 index 9fc5f646..00000000 --- a/omnitool/omnibox/src/host.py +++ /dev/null @@ -1,124 +0,0 @@ -import os -from fastapi import FastAPI, HTTPException, Response -from fastapi.responses import JSONResponse, StreamingResponse -import requests -import uvicorn -import concurrent.futures -from typing import List, Dict, Any, Optional -from instance import Instance, reset_with_callback -import time -import uuid -from tqdm import tqdm -from contextlib import asynccontextmanager - -@asynccontextmanager -async def lifespan(app: FastAPI): - # Startup code goes here - yield - # Shutdown code goes here - if reset_executor: - reset_executor.shutdown(wait=True, cancel_futures=False) - -app = FastAPI(lifespan=lifespan) - -INSTANCES = 2 -available_instances = [] -in_use = {} # key = instance_uuid, value = instance_id - -RESET_WORKERS = 2 -reset_executor = concurrent.futures.ThreadPoolExecutor(max_workers=RESET_WORKERS) - -def instance_reset_callback(instance_id): - if instance_id not in available_instances: - available_instances.append(instance_id) - -for i in range(INSTANCES): - reset_executor.submit(reset_with_callback, Instance(instance_num=i), instance_reset_callback) - -# Wait for all instances to be initialized -with tqdm(total=INSTANCES, desc="Initializing instances") as pbar: - last_count = 0 - while len(available_instances) < INSTANCES: - current_count = len(available_instances) - if current_count > last_count: - pbar.update(current_count - last_count) - last_count = current_count - time.sleep(0.1) - pbar.update(INSTANCES - last_count) - -@app.post("/getinstance") -def get_instance(): - """Get an available instance from the pool""" - if not available_instances: - raise HTTPException(status_code=503, detail="No instances available") - - instance_id = available_instances.pop(0) - instance_uuid = str(uuid.uuid4()) - in_use[instance_uuid] = instance_id - return {"instance_uuid": instance_uuid} - -@app.post("/resetinstance/{instance_uuid}") -def reset_instance(instance_uuid: str): - """Reset an instance to its initial state and make it available again""" - if instance_uuid not in in_use: - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") - - instance_id = in_use[instance_uuid] - reset_executor.submit(reset_with_callback, Instance(instance_num = instance_id), instance_reset_callback) - - return {"status": "success", "message": f"UUID {instance_uuid} for instance {instance_id} has been queued for reset"} - -@app.post("/executeinstance/{instance_uuid}/execute") -async def execute_instance_command(instance_uuid: str, command_data: Dict[str, Any]): - """Forward execute command to the Flask server in the specified instance""" - if instance_uuid not in in_use: - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") - - instance_id = in_use[instance_uuid] - try: - response = requests.post(Instance(instance_num = instance_id).flask_url(), json=command_data, timeout=5) - return JSONResponse(content=response.json(), status_code=response.status_code) - except requests.RequestException as e: - raise HTTPException(status_code=500, detail=f"Error communicating with instance {instance_id}: {str(e)}") - -@app.get("/executeinstance/{instance_uuid}/screenshot") -async def get_instance_screenshot(instance_uuid: str): - """Forward screenshot request to the Flask server in the specified instance""" - if instance_uuid not in in_use: - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") - - instance_id = in_use[instance_uuid] - try: - response = requests.get(Instance(instance_num = instance_id).flask_url() + "/screenshot", timeout=5) - - if response.status_code == 200: - return Response(content=response.content, media_type="image/png") - else: - return JSONResponse( - content={"status": "error", "message": f"Failed to get screenshot: {response.text}"}, - status_code=response.status_code - ) - except requests.RequestException as e: - raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance_id}: {str(e)}") - -@app.get("/executeinstance/{instance_uuid}/probe") -async def probe_instance(instance_uuid: str): - """Forward probe request to the Flask server in the specified instance""" - if instance_uuid not in in_use: - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") - - instance_id = in_use[instance_uuid] - try: - response = requests.get(Instance(instance_num = instance_id).flask_url() + "/probe", timeout=1) - return JSONResponse(content=response.json(), status_code=response.status_code) - except requests.RequestException as e: - raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance_id}: {str(e)}") - -@app.get("/available") -def get_available_instances(): - """Get an available instance from the pool""" - return {'available': len(available_instances)} - -if __name__ == "__main__": - uvicorn.run(app, host="0.0.0.0", port=8000) - diff --git a/omnitool/omnibox/src/instance.py b/omnitool/omnibox/src/instance.py deleted file mode 100644 index 77e14fc3..00000000 --- a/omnitool/omnibox/src/instance.py +++ /dev/null @@ -1,190 +0,0 @@ -import os -import subprocess -import tempfile -import time -import requests -from pathlib import Path - - -class IInstance: - def create(self): - raise NotImplementedError("Subclasses should implement this!") - - def start(self): - raise NotImplementedError("Subclasses should implement this!") - - def stop(self): - raise NotImplementedError("Subclasses should implement this!") - - def delete(self): - raise NotImplementedError("Subclasses should implement this!") - - def flask_url(self): - raise NotImplementedError("Subclasses should implement this!") - - def is_ready(self): - raise NotImplementedError("Subclasses should implement this!") - - -def MockInstance(IInstance): - def __init__(self, root_path = None, instance_num = 0): - self.root_path = root_path - self.instance_num = instance_num - - def create(self): - print("Dummy instance created") - - def start(self): - print("Dummy instance started") - - def stop(self): - print("Dummy instance stopped") - - def delete(self): - print("Dummy instance deleted") - - def flask_url(self): - return f"http://localhost:{5000 + self.instance_num}" - - def is_ready(self): - return True - - -_compose_template = """ -networks: - omnibox-network: - name: omnibox-network-{instance} - -services: - windows: - image: windows-local - container_name: omni-windows-{instance} - networks: - - omnibox-network - privileged: true - environment: - RAM_SIZE: "2G" - CPU_CORES: "4" - DISK_SIZE: "11G" - devices: - - /dev/kvm - - /dev/net/tun - cap_add: - - NET_ADMIN - ports: - - {web_port}:8006 # Web Viewer access - - {control_port}:5000 # Computer control server - volumes: - - {omniboxes_path}/common/win11iso/custom.iso:/custom.iso - - {omniboxes_path}/common/win11setup/firstboot:/oem - - {omniboxes_path}/common/win11setup/setupscripts:/data - - {omniboxes_path}/omnibox-{instance}:/storage -""" - -class Instance(IInstance): - def __init__(self, root_path = None, instance_num = 0): - self.root_path = Path(root_path or os.path.dirname(__file__)) - self.instance_num = instance_num - self.config_path = self.root_path / f'{instance_num}.yml' - with open(self.config_path, mode='w') as temp_file: - compose_content = _compose_template.format( - instance = self.instance_num, - web_port = 8006 + self.instance_num, - control_port = 5000 + self.instance_num, - omniboxes_path = self.root_path - ) - temp_file.write(compose_content) - - def create(self): - if not os.path.exists(f"omnibox-{self.instance_num}"): - os.makedirs(f"omnibox-{self.instance_num}") - subprocess.run(["cp", "-r", f"{str(self.root_path)}/common/win11storage/.", f"{self.root_path}/omnibox-{self.instance_num}/"]) - - try: - subprocess.run( - ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "up", "-d"], - check=True, - stdout=subprocess.DEVNULL, # Suppress standard output - stderr=subprocess.DEVNULL # Suppress error output - ) - print(f"Instance {self.instance_num} launched successfully!") - except subprocess.CalledProcessError as e: - print(f"Error launching instance {self.instance_num}: {e}") - - def start(self): - try: - subprocess.run( - ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "start"], - check=True, - stdout=subprocess.DEVNULL, - stderr=subprocess.DEVNULL - ) - print(f"Instance {self.instance_num} started successfully!") - except subprocess.CalledProcessError as e: - print(f"Error starting instance {self.instance_num}: {e}") - - def stop(self): - try: - subprocess.run( - ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "stop"], - check=True, - stdout=subprocess.DEVNULL, - stderr=subprocess.DEVNULL - ) - print(f"Instance {self.instance_num} stopped successfully!") - except subprocess.CalledProcessError as e: - print(f"Error stopping instance {self.instance_num}: {e}") - - def delete(self): - try: - subprocess.run( - ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "down"], - check=True, - stdout=subprocess.DEVNULL, - stderr=subprocess.DEVNULL - ) - print(f"Instance {self.instance_num} deleted successfully!") - except subprocess.CalledProcessError as e: - print(f"Error deleting instance {self.instance_num}: {e}") - - def flask_url(self): - return f"http://localhost:{5000 + self.instance_num}" - - def is_ready(self): - try: - response = requests.get(self.flask_url() + "/probe", timeout=1) - return response.status_code == 200 - except requests.RequestException as e: - return False - - def reset(self): - self.delete() - if os.path.exists(f"omnibox-{self.instance_num}"): - subprocess.run(["sudo", "rm", "-rf", f"{self.root_path}/omnibox-{self.instance_num}"], check=True) - self.create() - - def reset_soft(self): - self.stop() - if os.path.exists(f"omnibox-{self.instance_num}"): - subprocess.run(["sudo", "rm", "-rf", f"{self.root_path}/omnibox-{self.instance_num}"], check=True) - self.start() - -def reset_with_callback(instance, callback): - try: - instance.reset() - while not instance.is_ready(): - time.sleep(1) - callback(instance.instance_num) - except Exception as e: - print(f"Error in reset worker: {str(e)}") - -# got insufficient perf with this method -def reset_soft_with_callback(instance, callback): - try: - instance.reset_soft() - while not instance.is_ready(): - time.sleep(1) - callback(instance.instance_num) - except Exception as e: - print(f"Error in reset worker: {str(e)}") - From e8a00c4ac8ba4cb09558fd3b37b815da1d8dde00 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Wed, 7 May 2025 02:43:41 +0000 Subject: [PATCH 17/27] api cleanup --- omnitool/omnibox/client/client.py | 8 ++++---- omnitool/omnibox/node/server.py | 10 +++++----- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/omnitool/omnibox/client/client.py b/omnitool/omnibox/client/client.py index 96fcef1c..e5b49eb6 100644 --- a/omnitool/omnibox/client/client.py +++ b/omnitool/omnibox/client/client.py @@ -142,7 +142,7 @@ def __init__(self, host = 'localhost', port = 8000): self.instance_id = None def get_instance(self): - data = requests.post(f'http://{self.host}:{self.port}/getinstance') + data = requests.post(f'http://{self.host}:{self.port}/instances/get') instance_id = data.json()['instance_uuid'] return instance_id @@ -151,18 +151,18 @@ def get_instances_info(self): return data.json() def reset_instance(self, instance_id): - data = requests.post(f'http://{self.host}:{self.port}/resetinstance/{instance_id}') + data = requests.post(f'http://{self.host}:{self.port}/instances/{instance_id}/reset') if data.status_code != 200: raise Exception(f"Error: {data.status_code} - {data.text}") return data.json() def screenshot(self, instance_id): - data = requests.get(f'http://{self.host}:{self.port}/executeinstance/{instance_id}/screenshot') + data = requests.get(f'http://{self.host}:{self.port}/instances/{instance_id}/screenshot') image_data = io.BytesIO(data.content) return Image.open(image_data) def execute(self, instance_id, command): - return requests.post(f'http://{self.host}:{self.port}/executeinstance/{instance_id}/execute', json = command) + return requests.post(f'http://{self.host}:{self.port}/instances/{instance_id}/execute', json = command) def do_and_show(self, instance_id, command, waitTime): response = self.execute(instance_id, command) diff --git a/omnitool/omnibox/node/server.py b/omnitool/omnibox/node/server.py index 843914a7..d39ed9e2 100644 --- a/omnitool/omnibox/node/server.py +++ b/omnitool/omnibox/node/server.py @@ -25,7 +25,7 @@ async def lifespan(app: FastAPI): app = FastAPI(lifespan=lifespan) -@app.post("/getinstance") +@app.post("/instances/get") def get_instance(): """Get an available instance from the pool""" instance_uuid = instance_manager.start() @@ -33,14 +33,14 @@ def get_instance(): raise HTTPException(status_code=503, detail="No instances available") return {"instance_uuid": instance_uuid} -@app.post("/resetinstance/{instance_uuid}") +@app.post("/instances/{instance_uuid}/reset") def reset_instance(instance_uuid: str): """Reset an instance to its initial state and make it available again""" if instance_manager.reset(instance_uuid): return {"status": "success", "message": f"UUID {instance_uuid} for instance has been queued for reset"} raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") -@app.post("/executeinstance/{instance_uuid}/execute") +@app.post("/instances/{instance_uuid}/execute") async def execute_instance_command(instance_uuid: str, command_data: Dict[str, Any]): """Forward execute command to the Flask server in the specified instance""" instance= instance_manager.get(instance_uuid) @@ -51,7 +51,7 @@ async def execute_instance_command(instance_uuid: str, command_data: Dict[str, A except requests.RequestException as e: raise HTTPException(status_code=500, detail=f"Error communicating with instance {instance.instance_num}: {str(e)}") -@app.get("/executeinstance/{instance_uuid}/screenshot") +@app.get("/instances/{instance_uuid}/screenshot") async def get_instance_screenshot(instance_uuid: str): """Forward screenshot request to the Flask server in the specified instance""" instance = instance_manager.get(instance_uuid) @@ -62,7 +62,7 @@ async def get_instance_screenshot(instance_uuid: str): except requests.RequestException as e: raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance.instance_num}: {str(e)}") -@app.get("/executeinstance/{instance_uuid}/probe") +@app.get("/instances/{instance_uuid}/probe") async def probe_instance(instance_uuid: str): """Forward probe request to the Flask server in the specified instance""" instance= instance_manager.get(instance_uuid) From 28a15223f2d79baa4636c0b7e7e4d3098191a490 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Wed, 7 May 2025 03:40:24 +0000 Subject: [PATCH 18/27] api surface cleanup --- omnitool/omnibox/client/client.py | 13 ++++++---- omnitool/omnibox/node/server.py | 42 +++++++++++++++---------------- 2 files changed, 29 insertions(+), 26 deletions(-) diff --git a/omnitool/omnibox/client/client.py b/omnitool/omnibox/client/client.py index e5b49eb6..2bbf6a4c 100644 --- a/omnitool/omnibox/client/client.py +++ b/omnitool/omnibox/client/client.py @@ -142,27 +142,30 @@ def __init__(self, host = 'localhost', port = 8000): self.instance_id = None def get_instance(self): - data = requests.post(f'http://{self.host}:{self.port}/instances/get') + data = requests.post(f'http://{self.host}:{self.port}/get') instance_id = data.json()['instance_uuid'] return instance_id def get_instances_info(self): - data = requests.get(f'http://{self.host}:{self.port}/instances/info') + data = requests.get(f'http://{self.host}:{self.port}/info') return data.json() def reset_instance(self, instance_id): - data = requests.post(f'http://{self.host}:{self.port}/instances/{instance_id}/reset') + data = requests.post(f'http://{self.host}:{self.port}/reset', params = {'instance_id': instance_id}) if data.status_code != 200: raise Exception(f"Error: {data.status_code} - {data.text}") return data.json() def screenshot(self, instance_id): - data = requests.get(f'http://{self.host}:{self.port}/instances/{instance_id}/screenshot') + data = requests.get(f'http://{self.host}:{self.port}/screenshot', params = {'instance_id': instance_id}) image_data = io.BytesIO(data.content) return Image.open(image_data) def execute(self, instance_id, command): - return requests.post(f'http://{self.host}:{self.port}/instances/{instance_id}/execute', json = command) + return requests.post( + f'http://{self.host}:{self.port}/execute', + params={'instance_id': instance_id}, + json = command) def do_and_show(self, instance_id, command, waitTime): response = self.execute(instance_id, command) diff --git a/omnitool/omnibox/node/server.py b/omnitool/omnibox/node/server.py index d39ed9e2..62ca37d8 100644 --- a/omnitool/omnibox/node/server.py +++ b/omnitool/omnibox/node/server.py @@ -25,7 +25,7 @@ async def lifespan(app: FastAPI): app = FastAPI(lifespan=lifespan) -@app.post("/instances/get") +@app.post("/get") def get_instance(): """Get an available instance from the pool""" instance_uuid = instance_manager.start() @@ -33,47 +33,47 @@ def get_instance(): raise HTTPException(status_code=503, detail="No instances available") return {"instance_uuid": instance_uuid} -@app.post("/instances/{instance_uuid}/reset") -def reset_instance(instance_uuid: str): +@app.post("/reset") +def reset_instance(instance_id: str): """Reset an instance to its initial state and make it available again""" - if instance_manager.reset(instance_uuid): - return {"status": "success", "message": f"UUID {instance_uuid} for instance has been queued for reset"} - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + if instance_manager.reset(instance_id): + return {"status": "success", "message": f"UUID {instance_id} for instance has been queued for reset"} + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_id}") -@app.post("/instances/{instance_uuid}/execute") -async def execute_instance_command(instance_uuid: str, command_data: Dict[str, Any]): +@app.post("/execute") +async def execute_instance_command(instance_id: str, command_data: Dict[str, Any]): """Forward execute command to the Flask server in the specified instance""" - instance= instance_manager.get(instance_uuid) + instance= instance_manager.get(instance_id) if not instance: - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_id}") try: return InstanceClient(instance.flask_url()).execute(command_data) except requests.RequestException as e: raise HTTPException(status_code=500, detail=f"Error communicating with instance {instance.instance_num}: {str(e)}") -@app.get("/instances/{instance_uuid}/screenshot") -async def get_instance_screenshot(instance_uuid: str): +@app.get("/screenshot") +async def get_instance_screenshot(instance_id: str): """Forward screenshot request to the Flask server in the specified instance""" - instance = instance_manager.get(instance_uuid) + instance = instance_manager.get(instance_id) if not instance: - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_id}") try: return InstanceClient(instance.flask_url()).screenshot() except requests.RequestException as e: - raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance.instance_num}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_id} for instance {instance.instance_num}: {str(e)}") -@app.get("/instances/{instance_uuid}/probe") -async def probe_instance(instance_uuid: str): +@app.get("/probe") +async def probe_instance(instance_id: str): """Forward probe request to the Flask server in the specified instance""" - instance= instance_manager.get(instance_uuid) + instance= instance_manager.get(instance_id) if not instance: - raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_uuid}") + raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_id}") try: return InstanceClient(instance.flask_url()).probe() except requests.RequestException as e: - raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_uuid} for instance {instance.instance_num}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_id} for instance {instance.instance_num}: {str(e)}") -@app.get("/instances/info") +@app.get("/info") def get_available_instances(): """Get an available instance from the pool""" return { From ca1bc7b171e97f259a7917a12ddeeebf5191ddbf Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Wed, 7 May 2025 14:34:06 +0000 Subject: [PATCH 19/27] fixes / logging --- omnitool/omnibox/client/client.py | 2 +- omnitool/omnibox/node/instance.py | 24 +++++++++++---------- omnitool/omnibox/node/instance_manager.py | 13 +++++++----- omnitool/omnibox/node/logging_utils.py | 8 +++++++ omnitool/omnibox/node/mock_instance.py | 16 ++++++++------ omnitool/omnibox/node/server.py | 26 +++++++++++------------ 6 files changed, 52 insertions(+), 37 deletions(-) create mode 100644 omnitool/omnibox/node/logging_utils.py diff --git a/omnitool/omnibox/client/client.py b/omnitool/omnibox/client/client.py index 2bbf6a4c..612c8135 100644 --- a/omnitool/omnibox/client/client.py +++ b/omnitool/omnibox/client/client.py @@ -143,7 +143,7 @@ def __init__(self, host = 'localhost', port = 8000): def get_instance(self): data = requests.post(f'http://{self.host}:{self.port}/get') - instance_id = data.json()['instance_uuid'] + instance_id = data.json()['instance_id'] return instance_id def get_instances_info(self): diff --git a/omnitool/omnibox/node/instance.py b/omnitool/omnibox/node/instance.py index cbe4b9cb..24ee224d 100644 --- a/omnitool/omnibox/node/instance.py +++ b/omnitool/omnibox/node/instance.py @@ -4,6 +4,7 @@ import requests from pathlib import Path from typing import Dict, Any +from logging_utils import default_logger class IInstance: @@ -65,10 +66,11 @@ def reset_soft(self): class Instance(IInstance): - def __init__(self, root_path = None, instance_num = 0): + def __init__(self, root_path = None, instance_num = 0, logger = None): self.root_path = Path(root_path or os.path.dirname(__file__)).resolve() self.instance_num = instance_num self.config_path = self.root_path / f'{instance_num}.yml' + self.logger = logger or default_logger() with open(self.config_path, mode='w') as temp_file: compose_content = _compose_template.format( instance = self.instance_num, @@ -90,9 +92,9 @@ def create(self): stdout=subprocess.DEVNULL, # Suppress standard output stderr=subprocess.DEVNULL # Suppress error output ) - print(f"Instance {self.instance_num} launched successfully!") + self.logger.info(f"Instance {self.instance_num} launched successfully!") except subprocess.CalledProcessError as e: - print(f"Error launching instance {self.instance_num}: {e}") + self.logger.error(f"Error launching instance {self.instance_num}: {e}") def start(self): try: @@ -102,9 +104,9 @@ def start(self): stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL ) - print(f"Instance {self.instance_num} started successfully!") + self.logger.info(f"Instance {self.instance_num} started successfully!") except subprocess.CalledProcessError as e: - print(f"Error starting instance {self.instance_num}: {e}") + self.logger.error(f"Error starting instance {self.instance_num}: {e}") def stop(self): try: @@ -114,9 +116,9 @@ def stop(self): stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL ) - print(f"Instance {self.instance_num} stopped successfully!") + self.logger.info(f"Instance {self.instance_num} stopped successfully!") except subprocess.CalledProcessError as e: - print(f"Error stopping instance {self.instance_num}: {e}") + self.logger.error(f"Error stopping instance {self.instance_num}: {e}") def delete(self): try: @@ -126,9 +128,9 @@ def delete(self): stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL ) - print(f"Instance {self.instance_num} deleted successfully!") + self.logger.info(f"Instance {self.instance_num} deleted successfully!") except subprocess.CalledProcessError as e: - print(f"Error deleting instance {self.instance_num}: {e}") + self.logger.error(f"Error deleting instance {self.instance_num}: {e}") def flask_url(self): return f"http://localhost:{5000 + self.instance_num}" @@ -160,7 +162,7 @@ def reset_with_callback(instance, callback): time.sleep(1) callback(instance) except Exception as e: - print(f"Error in reset worker: {str(e)}") + instance.logger.error(f"Error in reset worker: {str(e)}") # got insufficient perf with this method @@ -171,5 +173,5 @@ def reset_soft_with_callback(instance, callback): time.sleep(1) callback(instance) except Exception as e: - print(f"Error in reset worker: {str(e)}") + instance.logger.error(f"Error in reset worker: {str(e)}") diff --git a/omnitool/omnibox/node/instance_manager.py b/omnitool/omnibox/node/instance_manager.py index f68297cd..1828eff5 100644 --- a/omnitool/omnibox/node/instance_manager.py +++ b/omnitool/omnibox/node/instance_manager.py @@ -1,20 +1,20 @@ import concurrent from instance import Instance, reset_with_callback -#from mock_instance import MockInstance as Instance +from mock_instance import MockInstance as Instance from tqdm import tqdm import time import uuid from typing import Dict, Any from pathlib import Path import os - +from logging_utils import default_logger class InstanceManager: - def __init__(self, path = None, capacity: int = 2): + def __init__(self, path = None, capacity: int = 2, logger = None): self.capacity = capacity self.available_instances = {} # instance_num to instance self.in_use = {} # key = instance_uuid, value = instance_id - + self.logger = logger or default_logger() self.reset_workers = capacity self.reset_executor = concurrent.futures.ThreadPoolExecutor(max_workers=self.reset_workers) self.path = Path(path or os.path.dirname(__file__)).resolve() @@ -34,6 +34,7 @@ def __init__(self, path = None, capacity: int = 2): pbar.update(self.capacity - last_count) def instance_reset_callback(self, instance): + self.logger.info(f"Instance {instance.instance_num} is ready") self.available_instances[instance.instance_num] = instance def shutdown(self): @@ -50,10 +51,12 @@ def start(self): return instance_uuid def reset(self, instance_uuid: str): + self.logger.info(f"Resetting instance {instance_uuid}") if instance_uuid not in self.in_use: return False - instance = self.in_use[instance_uuid] + instance = self.in_use.pop(instance_uuid) + self.logger.info(f"Resetting instance {instance_uuid}: {instance.instance_num} ") self.reset_executor.submit(reset_with_callback, instance, self.instance_reset_callback) return True diff --git a/omnitool/omnibox/node/logging_utils.py b/omnitool/omnibox/node/logging_utils.py new file mode 100644 index 00000000..2008f488 --- /dev/null +++ b/omnitool/omnibox/node/logging_utils.py @@ -0,0 +1,8 @@ +import logging + +def default_logger(): + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", + ) + return logging.getLogger("omnibox-node") \ No newline at end of file diff --git a/omnitool/omnibox/node/mock_instance.py b/omnitool/omnibox/node/mock_instance.py index 06497a4f..798dfe18 100644 --- a/omnitool/omnibox/node/mock_instance.py +++ b/omnitool/omnibox/node/mock_instance.py @@ -4,6 +4,7 @@ from io import BytesIO from instance import IInstance from threading import Thread +from logging_utils import default_logger def create_app(log_file=None): @@ -74,25 +75,26 @@ def screenshot(): class MockInstance(IInstance): - def __init__(self, root_path = None, instance_num = 0): + def __init__(self, root_path = None, instance_num = 0, logger = None): print(f'Creating mock instance: {instance_num}') self.root_path = root_path self.instance_num = instance_num self.app = create_app() + self.logger = logger or default_logger() p = Thread(target=self.app.run, args=('0.0.0.0',5000 + self.instance_num), daemon=True) p.start() def create(self): - print("Dummy instance created") + self.logger.info("Dummy instance created") def start(self): - print("Dummy instance started") + self.logger.info("Dummy instance started") def stop(self): - print("Dummy instance stopped") + self.logger.info("Dummy instance stopped") def delete(self): - print("Dummy instance deleted") + self.logger.info("Dummy instance deleted") def flask_url(self): return f"http://localhost:{5000 + self.instance_num}" @@ -101,7 +103,7 @@ def is_ready(self): return True def reset(self): - print("Dummy instance reset") + self.logger.info("Dummy instance reset") def reset_soft(self): - print("Dummy instance reset soft") + self.logger.info("Dummy instance reset soft") diff --git a/omnitool/omnibox/node/server.py b/omnitool/omnibox/node/server.py index 62ca37d8..30a0f833 100644 --- a/omnitool/omnibox/node/server.py +++ b/omnitool/omnibox/node/server.py @@ -28,10 +28,10 @@ async def lifespan(app: FastAPI): @app.post("/get") def get_instance(): """Get an available instance from the pool""" - instance_uuid = instance_manager.start() - if not instance_uuid: + instance_id = instance_manager.start() + if not instance_id: raise HTTPException(status_code=503, detail="No instances available") - return {"instance_uuid": instance_uuid} + return {"instance_id": instance_id} @app.post("/reset") def reset_instance(instance_id: str): @@ -40,16 +40,16 @@ def reset_instance(instance_id: str): return {"status": "success", "message": f"UUID {instance_id} for instance has been queued for reset"} raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_id}") -@app.post("/execute") -async def execute_instance_command(instance_id: str, command_data: Dict[str, Any]): - """Forward execute command to the Flask server in the specified instance""" +@app.get("/probe") +async def probe_instance(instance_id: str): + """Forward probe request to the Flask server in the specified instance""" instance= instance_manager.get(instance_id) if not instance: raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_id}") try: - return InstanceClient(instance.flask_url()).execute(command_data) + return InstanceClient(instance.flask_url()).probe() except requests.RequestException as e: - raise HTTPException(status_code=500, detail=f"Error communicating with instance {instance.instance_num}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_id} for instance {instance.instance_num}: {str(e)}") @app.get("/screenshot") async def get_instance_screenshot(instance_id: str): @@ -62,16 +62,16 @@ async def get_instance_screenshot(instance_id: str): except requests.RequestException as e: raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_id} for instance {instance.instance_num}: {str(e)}") -@app.get("/probe") -async def probe_instance(instance_id: str): - """Forward probe request to the Flask server in the specified instance""" +@app.post("/execute") +async def execute_instance_command(instance_id: str, command_data: Dict[str, Any]): + """Forward execute command to the Flask server in the specified instance""" instance= instance_manager.get(instance_id) if not instance: raise HTTPException(status_code=400, detail=f"Invalid instance UUID: {instance_id}") try: - return InstanceClient(instance.flask_url()).probe() + return InstanceClient(instance.flask_url()).execute(command_data) except requests.RequestException as e: - raise HTTPException(status_code=500, detail=f"Error communicating with UUID {instance_id} for instance {instance.instance_num}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error communicating with instance {instance.instance_num}: {str(e)}") @app.get("/info") def get_available_instances(): From 3b169214706568f3a9e5125a601f185d57b80fb0 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Wed, 7 May 2025 14:34:26 +0000 Subject: [PATCH 20/27] master --- omnitool/omnibox/master/logging_utils.py | 8 ++ omnitool/omnibox/master/node_manager.py | 104 +++++++++++++++++ omnitool/omnibox/master/server.py | 139 +++++++++++++++++++++++ 3 files changed, 251 insertions(+) create mode 100644 omnitool/omnibox/master/logging_utils.py create mode 100644 omnitool/omnibox/master/node_manager.py create mode 100644 omnitool/omnibox/master/server.py diff --git a/omnitool/omnibox/master/logging_utils.py b/omnitool/omnibox/master/logging_utils.py new file mode 100644 index 00000000..ee77ff99 --- /dev/null +++ b/omnitool/omnibox/master/logging_utils.py @@ -0,0 +1,8 @@ +import logging + +def default_logger(): + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", + ) + return logging.getLogger("omnibox-master") \ No newline at end of file diff --git a/omnitool/omnibox/master/node_manager.py b/omnitool/omnibox/master/node_manager.py new file mode 100644 index 00000000..3d97d93f --- /dev/null +++ b/omnitool/omnibox/master/node_manager.py @@ -0,0 +1,104 @@ +import asyncio +import httpx +import uvicorn +import logging +from fastapi import FastAPI, HTTPException, status, Response +from pydantic import BaseModel, Field +from typing import Dict, List, Optional, Any +import logging_utils + + +class NodeRegistration(BaseModel): + url: str + + +class NodeStatus(BaseModel): + url: str + hash: str + healthy: bool + capacity: int + available: int + instances: List[str] + + @staticmethod + def failed(url): + return NodeStatus(url=url, hash=url_hash(url), healthy=False, capacity=0, available=0, instances=[]) + + +def url_hash(url: str) -> str: + return url + + +def _default_logger(): + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", + ) + return logging.getLogger("omnibox-master") + + +class NodeManager: + def __init__(self, logger = None, update_timeout: int = 60): + self._nodes = {} + self._node_info = {} + self.logger = logger or _default_logger() + self.update_timeout = update_timeout + + async def _get_status(self, node_url): + try: + async with httpx.AsyncClient(timeout=5.0) as client: + response = await client.get(f"{node_url}/info") + if response.status_code != 200: + return NodeStatus.failed(node_url) + data = response.json() + return NodeStatus( + url = node_url, + hash = url_hash(node_url), + healthy = True, + capacity = data.get("capacity", 0), + available = data.get("available", 0), + instances = data.get("in_use", []) + ) + except Exception as e: + self.logger.warning(f"Node {node_url} health check failed: {str(e)}") + return NodeStatus.failed(node_url) + + async def update_statuses(self): + for node_url in self._nodes.keys(): + self._node_info[node_url] = await self._get_status(node_url) + + async def update_statuses_worker(self): + while True: + await self.update_statuses() + await asyncio.sleep(self.update_timeout) + + async def register_node(self, node: NodeRegistration): + self._nodes[url_hash(node.url)] = node + self._node_info[url_hash(node.url)] = await self._get_status(node.url) + + async def unregister_node(self, node_url: str): + """Unregister a worker node from the master""" + node_hash = url_hash(node_url) + if node_hash not in self._nodes: + self.logger.warning(f"Node {node_url} not found for unregistration") + return False + + self._nodes.pop(node_hash, None) + self._node_info.pop(node_hash, None) + return True + + def get_best_node(self) -> Optional[str]: + result = None + available = 0 + for node in self._node_info.values(): + if node.healthy and node.available > available: + result = node + available = node.available + return result + + def get_node(self, hash: str) -> Optional[NodeStatus]: + return self._node_info.get(hash, None) + + def node_info(self): + return self._node_info + diff --git a/omnitool/omnibox/master/server.py b/omnitool/omnibox/master/server.py new file mode 100644 index 00000000..7f006db8 --- /dev/null +++ b/omnitool/omnibox/master/server.py @@ -0,0 +1,139 @@ +import asyncio +import httpx +import uvicorn +import logging +from fastapi import FastAPI, HTTPException, status, Response +from pydantic import BaseModel, Field +from typing import Dict, List, Optional, Any +from contextlib import asynccontextmanager +from fastapi.responses import JSONResponse +from node_manager import NodeManager, NodeRegistration +import requests +import argparse + +# Configure logging +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", +) +logger = logging.getLogger("omnibox-master") + +node_manager = NodeManager(logger = logger) + +@asynccontextmanager +async def lifespan(app: FastAPI): + await node_manager.register_node(NodeRegistration(url = "http://localhost:8000")) + task = asyncio.create_task(node_manager.update_statuses_worker()) + yield + # Shutdown code goes here + +app = FastAPI( + title="OmniBox Master Node", + description="Manages redirection of instance operations to worker nodes", + lifespan = lifespan) + +@app.post("/get") +def create_instance(): + node = node_manager.get_best_node() + if node is None: + raise HTTPException( + status_code=status.HTTP_503_SERVICE_UNAVAILABLE, + detail="No available nodes with capacity to create new instance" + ) + + data = requests.post(f'{node.url}/get') + instance_id = data.json()['instance_id'] + return { + 'instance_id': instance_id, + 'node': node.hash, + } + +@app.post("/reset") +async def reset(instance_id: str, node: str): + """Reset an existing instance by delegating to the worker node that hosts it""" + node_info = node_manager.get_node(node) + if node_info is None: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail=f"Node {node} is not found" + ) + return requests.post(f'{node_info.url}/reset', params={"instance_id": instance_id}) + +@app.get("/probe") +async def probe(instance_id: str, node: str): + """Reset an existing instance by delegating to the worker node that hosts it""" + node_info = node_manager.get_node(node) + if node_info is None: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail=f"Node {node} is not found" + ) + response = requests.get(f'{node_info.url}/probe', params={"instance_id": instance_id}) + return JSONResponse(content=response.json(), status_code=response.status_code) + +@app.get("/screenshot") +async def screenshot(instance_id: str, node: str): + """Make a screenshot of an existing instance by delegating to the worker node that hosts it""" + node_info = node_manager.get_node(node) + if node_info is None: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail=f"Node {node} is not found" + ) + response = requests.get(f'{node_info.url}/screenshot', params={"instance_id": instance_id}) + if response.status_code == 200: + return Response(content=response.content, media_type="image/png") + + return JSONResponse( + content={"status": "error", "message": f"Failed to get screenshot: {response.text}"}, + status_code=response.status_code + ) + +@app.post("/execute") +async def execute(command_data: Dict[str, Any]): + """Forward execute command to the Flask server in the specified instance""" + node = command_data.pop('node') + instance_id = command_data.pop('instance_id') + node_info = node_manager.get_node(node) + if node_info is None: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail=f"Node {node} is not found" + ) + response = requests.post(f'{node_info.url}/execute', + params={"instance_id": instance_id}, + json = command_data) + if response.status_code == 200: + return JSONResponse(content=response.json(), status_code=response.status_code) + + return JSONResponse( + content={"status": "error", "message": f"Failed to execute command: {response.text}"}, + status_code=response.status_code + ) + +@app.get("/info") +def get_info(): + node_info = node_manager.node_info() + return JSONResponse( + content={ + "nodes": [ + { + "url": node.url, + "hash": node.hash, + "healthy": node.healthy, + "capacity": node.capacity, + "available": node.available, + "instances": node.instances + } + for node in node_info.values() + ] + }, + status_code=status.HTTP_200_OK + ) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="OmniBox Host") + parser.add_argument("--port", type=int, default=7000, help="Port to run the server on") + args = parser.parse_args() + uvicorn.run(app, host="0.0.0.0", port=args.port) \ No newline at end of file From 39bf238bf7b2e92d67e165154014e9024b536bd4 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Wed, 7 May 2025 15:25:23 +0000 Subject: [PATCH 21/27] fix + master client --- omnitool/omnibox/client/client.py | 135 +++++++++++++ omnitool/omnibox/client/notebook.ipynb | 252 +++---------------------- omnitool/omnibox/master/server.py | 4 +- 3 files changed, 160 insertions(+), 231 deletions(-) diff --git a/omnitool/omnibox/client/client.py b/omnitool/omnibox/client/client.py index 612c8135..0491d7d9 100644 --- a/omnitool/omnibox/client/client.py +++ b/omnitool/omnibox/client/client.py @@ -257,4 +257,139 @@ def on_instance_change(_): ipywidgets.HBox([click, rightClick, doubleClick]), ipywidgets.HBox([cmd, ipywidgets.VBox([shell, python]), submit]), self.output])) + + +class MasterClient: + def __init__(self, host = 'localhost', port = 7000): + self.host = host + self.port = port + self.output = None + self.instance = None + + def probe(self, instance: dict): + return requests.get(f'http://{self.host}:{self.port}/probe', params=instance).json() + + def get_instance(self): + url = f'http://{self.host}:{self.port}/get' + response = requests.post(url) + if response.status_code != 200: + raise Exception(f"Error: {response.status_code} - {response.text}") + return response.json() + + def get_info(self): + url = f'http://{self.host}:{self.port}/info' + response = requests.get(url) + if response.status_code != 200: + raise Exception(f"Error: {response.status_code} - {response.text}") + return response.json() + + def get_options(self): + info = self.get_info()['nodes'] + print(type(info)) + return [json.dumps({'instance_id': instance, 'node': node['hash']}) for node in info for instance in node['instances']] + + def reset_instance(self, instance: dict): + data = requests.post(f'http://{self.host}:{self.port}/reset', params = instance) + if data.status_code != 200: + raise Exception(f"Error: {data.status_code} - {data.text}") + return data.json() + + def screenshot(self, instance: dict): + data = requests.get(f'http://{self.host}:{self.port}/screenshot', params = instance) + image_data = io.BytesIO(data.content) + return Image.open(image_data) + + def execute(self, instance: dict, command): + return requests.post(f'http://{self.host}:{self.port}/execute', json = dict(command, **instance)) + + def do_and_show(self, instance, command, waitTime): + response = self.execute(instance, command) + if response.status_code != 200: + raise Exception(f"Error: {response.status_code} - {response.text}") + time.sleep(waitTime) + self._display(instance, response.json()['output']) + + def _display(self, instance, data = None): + with self.output: + self.output.clear_output(wait = True) + display(self.screenshot(instance)) + print(data) + + def position(self, instance): + return json.loads(self.execute(instance, _position()).json()['output']) + + def screensize(self, instance): + return json.loads(self.execute(instance, _screensize()).json()['output']) + + def ui(self): + self.output = ipywidgets.Output() + + get_button = ipywidgets.Button(description = 'Get Instance') + release_button = ipywidgets.Button(description = 'Release Instance') + instances = ipywidgets.RadioButtons(description = 'Instances', options = self.get_options(), layout=ipywidgets.Layout(width='50%')) + self.instance = json.loads(instances.value) if instances.value else {} + def on_add_click(b): + new_instance = json.dumps(self.get_instance()) + instances.options = list(instances.options) + [new_instance] + + def on_release_click(b): + self.reset_instance(json.loads(instances.value)) + options = list(instances.options) + options.remove(instances.value) + instances.options = options + + get_button.on_click(on_add_click) + release_button.on_click(on_release_click) + + waitTime = ipywidgets.FloatLogSlider(base=2, value = 1, min = -3, max = 5, step = 1, description = 'wait (s)') + + screensize = {} + position = {} + if self.instance: + screensize = self.screensize(self.instance) + position = self.position(self.instance) + self._display(self.instance) + + x = ipywidgets.IntSlider(min = 0, max = screensize.get('width', 1), value = position.get('x', 0), description = 'X') + y = ipywidgets.IntSlider(min = 0, max = screensize.get('height', 1), value = position.get('y', 0), description = 'Y') + + click = ipywidgets.Button(description = 'Click') + rightClick = ipywidgets.Button(description = 'Right Click') + doubleClick = ipywidgets.Button(description = 'Double Click') + + x.observe(lambda v: self.do_and_show(self.instance, _moveTo(x.value, y.value), waitTime.value), names='value') + y.observe(lambda v: self.do_and_show(self.instance, _moveTo(x.value, y.value), waitTime.value), names='value') + + click.on_click(lambda v: self.do_and_show(self.instance, _click(), waitTime.value)) + rightClick.on_click(lambda v: self.do_and_show(self.instance, _rightClick(), waitTime.value)) + doubleClick.on_click(lambda v: self.do_and_show(self.instance, _doubleClick(), waitTime.value)) + + cmd = ipywidgets.Textarea(description = 'Commands', layout=ipywidgets.Layout(width='50%')) + shell = ipywidgets.Checkbox(description = 'Shell', value = False) + python = ipywidgets.Checkbox(description = 'Python', value = True) + submit = ipywidgets.Button(description = 'Submit') + submit.on_click(lambda v: self.do_and_show(self.instance, { + 'command': _pyscript(cmd.value.split('\n')) if python.value else '&&'.join(cmd.value.split('\n')), + 'shell': shell.value + }, waitTime.value)) + + def on_instance_change(_): + self.instance = json.loads(instances.value) + screensize = self.screensize(self.instance) + x.max = screensize.get('width', 1) + y.max = screensize.get('height', 1) + position = self.position(self.instance) + x.value = position.get('x', 0) + y.value = position.get('y', 0) + self._display(self.instance) + + instances.observe(on_instance_change, names='value') + + display(ipywidgets.VBox([ + ipywidgets.HBox([instances, ipywidgets.VBox([get_button, release_button])]), + waitTime, + ipywidgets.HBox([x, y]), + ipywidgets.HBox([click, rightClick, doubleClick]), + ipywidgets.HBox([cmd, ipywidgets.VBox([shell, python]), submit]), + self.output])) diff --git a/omnitool/omnibox/client/notebook.ipynb b/omnitool/omnibox/client/notebook.ipynb index 44df00e6..eb30ad84 100644 --- a/omnitool/omnibox/client/notebook.ipynb +++ b/omnitool/omnibox/client/notebook.ipynb @@ -10,14 +10,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "ae7b2936", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "905146bb7cb44a95b9a30410f499b2df", + "model_id": "af9a41f28b6245168be034d10a2303cd", "version_major": 2, "version_minor": 0 }, @@ -39,261 +39,66 @@ "id": "741598f1", "metadata": {}, "source": [ - "# Test host" + "# Test node" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "eca33f8c", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c5ac9102430f4a8d8861efcfa05aa0ff", + "model_id": "c7f1d7a7f3f74587a4ee5d0d648025cd", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(HBox(children=(RadioButtons(description='Instances', layout=Layout(width='50%'), options=('9740…" + "VBox(children=(HBox(children=(RadioButtons(description='Instances', layout=Layout(width='50%'), options=(), va…" ] }, "metadata": {}, "output_type": "display_data" - }, - { - "ename": "KeyError", - "evalue": "'output'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mKeyError\u001b[39m Traceback (most recent call last)", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/ipywidgets/widgets/widget.py:773\u001b[39m, in \u001b[36mWidget._handle_msg\u001b[39m\u001b[34m(self, msg)\u001b[39m\n\u001b[32m 771\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[33m'\u001b[39m\u001b[33mbuffer_paths\u001b[39m\u001b[33m'\u001b[39m \u001b[38;5;129;01min\u001b[39;00m data:\n\u001b[32m 772\u001b[39m _put_buffers(state, data[\u001b[33m'\u001b[39m\u001b[33mbuffer_paths\u001b[39m\u001b[33m'\u001b[39m], msg[\u001b[33m'\u001b[39m\u001b[33mbuffers\u001b[39m\u001b[33m'\u001b[39m])\n\u001b[32m--> \u001b[39m\u001b[32m773\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mset_state\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 775\u001b[39m \u001b[38;5;66;03m# Handle a state request.\u001b[39;00m\n\u001b[32m 776\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m method == \u001b[33m'\u001b[39m\u001b[33mrequest_state\u001b[39m\u001b[33m'\u001b[39m:\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/ipywidgets/widgets/widget.py:650\u001b[39m, in \u001b[36mWidget.set_state\u001b[39m\u001b[34m(self, sync_data)\u001b[39m\n\u001b[32m 645\u001b[39m \u001b[38;5;28mself\u001b[39m._send(msg, buffers=echo_buffers)\n\u001b[32m 647\u001b[39m \u001b[38;5;66;03m# The order of these context managers is important. Properties must\u001b[39;00m\n\u001b[32m 648\u001b[39m \u001b[38;5;66;03m# be locked when the hold_trait_notification context manager is\u001b[39;00m\n\u001b[32m 649\u001b[39m \u001b[38;5;66;03m# released and notifications are fired.\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m650\u001b[39m \u001b[43m\u001b[49m\u001b[38;5;28;43;01mwith\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_lock_property\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43msync_data\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mhold_trait_notifications\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m 651\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43msync_data\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m 652\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m:\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/contextlib.py:144\u001b[39m, in \u001b[36m_GeneratorContextManager.__exit__\u001b[39m\u001b[34m(self, typ, value, traceback)\u001b[39m\n\u001b[32m 142\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m typ \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 143\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m144\u001b[39m \u001b[38;5;28;43mnext\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mgen\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 145\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m:\n\u001b[32m 146\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1510\u001b[39m, in \u001b[36mHasTraits.hold_trait_notifications\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 1508\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m changes \u001b[38;5;129;01min\u001b[39;00m cache.values():\n\u001b[32m 1509\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m change \u001b[38;5;129;01min\u001b[39;00m changes:\n\u001b[32m-> \u001b[39m\u001b[32m1510\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mnotify_change\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchange\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/ipywidgets/widgets/widget.py:701\u001b[39m, in \u001b[36mWidget.notify_change\u001b[39m\u001b[34m(self, change)\u001b[39m\n\u001b[32m 698\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.keys \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m._should_send_property(name, \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, name)):\n\u001b[32m 699\u001b[39m \u001b[38;5;66;03m# Send new state to front-end\u001b[39;00m\n\u001b[32m 700\u001b[39m \u001b[38;5;28mself\u001b[39m.send_state(key=name)\n\u001b[32m--> \u001b[39m\u001b[32m701\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mnotify_change\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchange\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1525\u001b[39m, in \u001b[36mHasTraits.notify_change\u001b[39m\u001b[34m(self, change)\u001b[39m\n\u001b[32m 1523\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mnotify_change\u001b[39m(\u001b[38;5;28mself\u001b[39m, change: Bunch) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 1524\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Notify observers of a change event\"\"\"\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1525\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_notify_observers\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchange\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1568\u001b[39m, in \u001b[36mHasTraits._notify_observers\u001b[39m\u001b[34m(self, event)\u001b[39m\n\u001b[32m 1565\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(c, EventHandler) \u001b[38;5;129;01mand\u001b[39;00m c.name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 1566\u001b[39m c = \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, c.name)\n\u001b[32m-> \u001b[39m\u001b[32m1568\u001b[39m \u001b[43mc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mevent\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/ipywidgets/widgets/widget_selection.py:236\u001b[39m, in \u001b[36m_Selection._propagate_index\u001b[39m\u001b[34m(self, change)\u001b[39m\n\u001b[32m 234\u001b[39m \u001b[38;5;28mself\u001b[39m.label = label\n\u001b[32m 235\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.value \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m value:\n\u001b[32m--> \u001b[39m\u001b[32m236\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvalue\u001b[49m = value\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:716\u001b[39m, in \u001b[36mTraitType.__set__\u001b[39m\u001b[34m(self, obj, value)\u001b[39m\n\u001b[32m 714\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.read_only:\n\u001b[32m 715\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m TraitError(\u001b[33m'\u001b[39m\u001b[33mThe \u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m\"\u001b[39m\u001b[33m trait is read-only.\u001b[39m\u001b[33m'\u001b[39m % \u001b[38;5;28mself\u001b[39m.name)\n\u001b[32m--> \u001b[39m\u001b[32m716\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mset\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:706\u001b[39m, in \u001b[36mTraitType.set\u001b[39m\u001b[34m(self, obj, value)\u001b[39m\n\u001b[32m 702\u001b[39m silent = \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[32m 703\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m silent \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[32m 704\u001b[39m \u001b[38;5;66;03m# we explicitly compare silent to True just in case the equality\u001b[39;00m\n\u001b[32m 705\u001b[39m \u001b[38;5;66;03m# comparison above returns something other than True/False\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m706\u001b[39m \u001b[43mobj\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_notify_trait\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mold_value\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnew_value\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1513\u001b[39m, in \u001b[36mHasTraits._notify_trait\u001b[39m\u001b[34m(self, name, old_value, new_value)\u001b[39m\n\u001b[32m 1512\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_notify_trait\u001b[39m(\u001b[38;5;28mself\u001b[39m, name: \u001b[38;5;28mstr\u001b[39m, old_value: t.Any, new_value: t.Any) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1513\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mnotify_change\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1514\u001b[39m \u001b[43m \u001b[49m\u001b[43mBunch\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 1515\u001b[39m \u001b[43m \u001b[49m\u001b[43mname\u001b[49m\u001b[43m=\u001b[49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1516\u001b[39m \u001b[43m \u001b[49m\u001b[43mold\u001b[49m\u001b[43m=\u001b[49m\u001b[43mold_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1517\u001b[39m \u001b[43m \u001b[49m\u001b[43mnew\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnew_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 1518\u001b[39m \u001b[43m \u001b[49m\u001b[43mowner\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 1519\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mtype\u001b[39;49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mchange\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 1520\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1521\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/ipywidgets/widgets/widget.py:701\u001b[39m, in \u001b[36mWidget.notify_change\u001b[39m\u001b[34m(self, change)\u001b[39m\n\u001b[32m 698\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.keys \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m._should_send_property(name, \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, name)):\n\u001b[32m 699\u001b[39m \u001b[38;5;66;03m# Send new state to front-end\u001b[39;00m\n\u001b[32m 700\u001b[39m \u001b[38;5;28mself\u001b[39m.send_state(key=name)\n\u001b[32m--> \u001b[39m\u001b[32m701\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mnotify_change\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchange\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1525\u001b[39m, in \u001b[36mHasTraits.notify_change\u001b[39m\u001b[34m(self, change)\u001b[39m\n\u001b[32m 1523\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mnotify_change\u001b[39m(\u001b[38;5;28mself\u001b[39m, change: Bunch) -> \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 1524\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Notify observers of a change event\"\"\"\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1525\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_notify_observers\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchange\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/explore/lib/python3.12/site-packages/traitlets/traitlets.py:1568\u001b[39m, in \u001b[36mHasTraits._notify_observers\u001b[39m\u001b[34m(self, event)\u001b[39m\n\u001b[32m 1565\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(c, EventHandler) \u001b[38;5;129;01mand\u001b[39;00m c.name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 1566\u001b[39m c = \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, c.name)\n\u001b[32m-> \u001b[39m\u001b[32m1568\u001b[39m \u001b[43mc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mevent\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/ataymano/OmniParser/omnitool/omnibox/client/client.py:239\u001b[39m, in \u001b[36mHostClient.ui..on_instance_change\u001b[39m\u001b[34m(_)\u001b[39m\n\u001b[32m 237\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mon_instance_change\u001b[39m(_):\n\u001b[32m 238\u001b[39m \u001b[38;5;28mself\u001b[39m.instance_id = instances.value\n\u001b[32m--> \u001b[39m\u001b[32m239\u001b[39m screensize = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mscreensize\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43minstance_id\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 240\u001b[39m x.max = screensize.get(\u001b[33m'\u001b[39m\u001b[33mwidth\u001b[39m\u001b[33m'\u001b[39m, \u001b[32m1\u001b[39m)\n\u001b[32m 241\u001b[39m y.max = screensize.get(\u001b[33m'\u001b[39m\u001b[33mheight\u001b[39m\u001b[33m'\u001b[39m, \u001b[32m1\u001b[39m)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/ataymano/OmniParser/omnitool/omnibox/client/client.py:184\u001b[39m, in \u001b[36mHostClient.screensize\u001b[39m\u001b[34m(self, instance_id)\u001b[39m\n\u001b[32m 183\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mscreensize\u001b[39m(\u001b[38;5;28mself\u001b[39m, instance_id):\n\u001b[32m--> \u001b[39m\u001b[32m184\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m json.loads(\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\u001b[43minstance_id\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_screensize\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mjson\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43moutput\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m]\u001b[49m)\n", - "\u001b[31mKeyError\u001b[39m: 'output'" - ] } ], "source": [ "import client\n", - "c = client.HostClient(port = 8000)\n", - "c.ui()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f7279ac3", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "6b8d2c38", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d3d776ca4d9f4192a5c05abffdc2b37b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "RadioButtons(options=('a', 'b'), value='a')" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "('a', 'b', 'c')" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import ipywidgets\n", - "a = ipywidgets.RadioButtons(options=['a', 'b'])\n", - "display(a)\n", - "a.options = ['a', 'b', 'c']\n", - "a.options" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "5b889bd4", - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "HostClient.screensize() missing 1 required positional argument: 'instance_id'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mc\u001b[49m\u001b[43m.\u001b[49m\u001b[43mui\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/ataymano/OmniParser/omnitool/omnibox/client/client.py:202\u001b[39m, in \u001b[36mHostClient.ui\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 199\u001b[39m get_button.on_click(on_add_click)\n\u001b[32m 200\u001b[39m release_button.on_click(on_release_click) \n\u001b[32m--> \u001b[39m\u001b[32m202\u001b[39m screensize = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mscreensize\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 203\u001b[39m position = \u001b[38;5;28mself\u001b[39m.position()\n\u001b[32m 206\u001b[39m waitTime = ipywidgets.FloatLogSlider(base=\u001b[32m2\u001b[39m, value = \u001b[32m1\u001b[39m, \u001b[38;5;28mmin\u001b[39m = -\u001b[32m3\u001b[39m, \u001b[38;5;28mmax\u001b[39m = \u001b[32m5\u001b[39m, step = \u001b[32m1\u001b[39m, description = \u001b[33m'\u001b[39m\u001b[33mwait (s)\u001b[39m\u001b[33m'\u001b[39m)\n", - "\u001b[31mTypeError\u001b[39m: HostClient.screensize() missing 1 required positional argument: 'instance_id'" - ] - } - ], - "source": [ + "c = client.NodeClient(port = 8000)\n", "c.ui()" ] }, { - "cell_type": "code", - "execution_count": 7, - "id": "c0b07ec6", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8661ac79cb7542b29593730b898b34f9", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "RadioButtons(options=(), value=None)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import ipywidgets\n", - "\n", - "options = ipywidgets.RadioButtons(options=[])\n", - "display(options)\n", - "options.value" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "5f9aa0f6", + "cell_type": "markdown", + "id": "c2b1810b", "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "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", - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "c.screenshot('dc8cacc7-d317-4dde-a8e4-b0a70b6c754b')" + "# Test master node" ] }, { "cell_type": "code", "execution_count": 1, - "id": "55666faf", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{1, 3}" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "set([1,2,3]) - {2}" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "1f2e8d3a", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0e034995b8f245b59476524287739e62", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "RadioButtons(description='bla', options=('a', 'b'), value='a')" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import ipywidgets\n", - "opts = ipywidgets.RadioButtons(options = ['a', 'b'], description='bla')\n", - "display(opts)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "4fe6618b", + "id": "bf6188a0", "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "84d5057ca8d540c5a1a2666b9551f092", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Button(description='Click me!', style=ButtonStyle())" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5f51d260fe5642db9afc32558abe52ec", + "model_id": "4d55d4c417724189b0d0129f93f80a08", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "RadioButtons(description='bla', options=(), value=None)" + "VBox(children=(HBox(children=(RadioButtons(description='Instances', layout=Layout(width='50%'), options=('{\"in…" ] }, "metadata": {}, @@ -301,28 +106,15 @@ } ], "source": [ - "import ipywidgets\n", - "\n", - "button = ipywidgets.Button(description=\"Click me!\")\n", - "opts = ipywidgets.RadioButtons(options = [], description='bla')\n", - "def on_button_click(b):\n", - " opts.options = list(opts.options) + [str(len(opts.options))]\n", - "button.on_click(on_button_click)\n", - "display(button, opts)" + "import client\n", + "c = client.MasterClient(port = 7000)\n", + "c.ui()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "124b7781", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "explore", + "display_name": "omnibox", "language": "python", "name": "python3" }, diff --git a/omnitool/omnibox/master/server.py b/omnitool/omnibox/master/server.py index 7f006db8..3cd46a79 100644 --- a/omnitool/omnibox/master/server.py +++ b/omnitool/omnibox/master/server.py @@ -57,7 +57,9 @@ async def reset(instance_id: str, node: str): status_code=status.HTTP_400_BAD_REQUEST, detail=f"Node {node} is not found" ) - return requests.post(f'{node_info.url}/reset', params={"instance_id": instance_id}) + response = requests.post(f'{node_info.url}/reset', params={"instance_id": instance_id}) + return JSONResponse(content=response.json(), status_code=response.status_code) + @app.get("/probe") async def probe(instance_id: str, node: str): From d34b31188fb62ff1b6deb8f06986eed8e4e92546 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Wed, 7 May 2025 15:40:56 +0000 Subject: [PATCH 22/27] mock reset --- omnitool/omnibox/node/mock_instance.py | 121 +++++++++++++------------ 1 file changed, 61 insertions(+), 60 deletions(-) diff --git a/omnitool/omnibox/node/mock_instance.py b/omnitool/omnibox/node/mock_instance.py index 798dfe18..d3170102 100644 --- a/omnitool/omnibox/node/mock_instance.py +++ b/omnitool/omnibox/node/mock_instance.py @@ -7,71 +7,71 @@ from logging_utils import default_logger -def create_app(log_file=None): - """Create and configure the Flask app""" - if log_file: - logging.basicConfig(filename=log_file, level=logging.DEBUG, filemode='w') - logger = logging.getLogger('werkzeug') +class MockApp: + def __init__(self, log_file=None): + """Create and configure the Flask app""" + if log_file: + logging.basicConfig(filename=log_file, level=logging.DEBUG, filemode='w') + logger = logging.getLogger('werkzeug') - app = Flask(__name__) - command_history = [] + self.app = Flask(__name__) + self.command_history = [] - @app.route('/probe', methods=['GET']) - def probe_endpoint(): - return jsonify({"status": "Probe successful", "message": "Service is operational"}), 200 + @self.app.route('/probe', methods=['GET']) + def probe_endpoint(): + return jsonify({"status": "Probe successful", "message": "Service is operational"}), 200 - @app.route('/execute', methods=['POST']) - def execute_command(): - data = request.json - command = data.get('command', "") - command_history.append(str(command)) - return jsonify({ - 'status': 'success', - 'output': '{}', - 'error': '', - 'returncode': 0 - }) + @self.app.route('/execute', methods=['POST']) + def execute_command(): + data = request.json + command = data.get('command', "") + self.command_history.append(str(command)) + return jsonify({ + 'status': 'success', + 'output': '{}', + 'error': '', + 'returncode': 0 + }) - @app.route('/screenshot', methods=['GET']) - def screenshot(): - width, height = 800, 600 - image = Image.new('RGB', (width, height), color='white') - draw = ImageDraw.Draw(image) - - try: - font = ImageFont.truetype("DejaVuSans.ttf", 14) - except IOError: - font = ImageFont.load_default() + @self.app.route('/screenshot', methods=['GET']) + def screenshot(): + width, height = 800, 600 + image = Image.new('RGB', (width, height), color='white') + draw = ImageDraw.Draw(image) - draw.text((10, 10), "Mock Instance - Command History", fill="black", font=font) - draw.line([(10, 40), (width-10, 40)], fill="black", width=1) - - y_position = 50 - max_commands = min(len(command_history), 20) # Limit to last 20 commands - - if max_commands == 0: - draw.text((20, y_position), "No commands executed yet", fill="gray", font=font) - else: - for i, cmd in enumerate(command_history[-max_commands:]): - timestamp = f"{i+1}." - draw.text((20, y_position), timestamp, fill="blue", font=font) - draw.text((50, y_position), cmd, fill="black", font=font) - y_position += 25 + try: + font = ImageFont.truetype("DejaVuSans.ttf", 14) + except IOError: + font = ImageFont.load_default() - # If we're running out of space - if y_position > height - 30: - remaining = len(command_history) - (i + 1) - if remaining > 0: - draw.text((20, y_position), f"... {remaining} more commands not shown", - fill="red", font=font) - break + draw.text((10, 10), "Mock Instance - Command History", fill="black", font=font) + draw.line([(10, 40), (width-10, 40)], fill="black", width=1) + + y_position = 50 + max_commands = min(len(self.command_history), 20) # Limit to last 20 commands + + if max_commands == 0: + draw.text((20, y_position), "No commands executed yet", fill="gray", font=font) + else: + for i, cmd in enumerate(self.command_history[-max_commands:]): + timestamp = f"{i+1}." + draw.text((20, y_position), timestamp, fill="blue", font=font) + draw.text((50, y_position), cmd, fill="black", font=font) + y_position += 25 + + # If we're running out of space + if y_position > height - 30: + remaining = len(self.command_history) - (i + 1) + if remaining > 0: + draw.text((20, y_position), f"... {remaining} more commands not shown", + fill="red", font=font) + break + + img_io = BytesIO() + image.save(img_io, 'PNG') + img_io.seek(0) + return send_file(img_io, mimetype='image/png') - img_io = BytesIO() - image.save(img_io, 'PNG') - img_io.seek(0) - return send_file(img_io, mimetype='image/png') - - return app class MockInstance(IInstance): @@ -79,9 +79,9 @@ def __init__(self, root_path = None, instance_num = 0, logger = None): print(f'Creating mock instance: {instance_num}') self.root_path = root_path self.instance_num = instance_num - self.app = create_app() + self.app = MockApp() self.logger = logger or default_logger() - p = Thread(target=self.app.run, args=('0.0.0.0',5000 + self.instance_num), daemon=True) + p = Thread(target=self.app.app.run, args=('0.0.0.0',5000 + self.instance_num), daemon=True) p.start() def create(self): @@ -103,6 +103,7 @@ def is_ready(self): return True def reset(self): + self.app.command_history = [] self.logger.info("Dummy instance reset") def reset_soft(self): From 2dba2dc2bd6ac712282366c588254d76a26933c4 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Wed, 7 May 2025 15:46:23 +0000 Subject: [PATCH 23/27] instance_factory --- omnitool/omnibox/node/instance_manager.py | 6 +++--- omnitool/omnibox/node/server.py | 6 +++++- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/omnitool/omnibox/node/instance_manager.py b/omnitool/omnibox/node/instance_manager.py index 1828eff5..17fa3425 100644 --- a/omnitool/omnibox/node/instance_manager.py +++ b/omnitool/omnibox/node/instance_manager.py @@ -1,6 +1,5 @@ import concurrent from instance import Instance, reset_with_callback -from mock_instance import MockInstance as Instance from tqdm import tqdm import time import uuid @@ -10,8 +9,9 @@ from logging_utils import default_logger class InstanceManager: - def __init__(self, path = None, capacity: int = 2, logger = None): + def __init__(self, instance_factory = None, path = None, capacity: int = 2, logger = None): self.capacity = capacity + self.instance_factory = instance_factory or Instance self.available_instances = {} # instance_num to instance self.in_use = {} # key = instance_uuid, value = instance_id self.logger = logger or default_logger() @@ -20,7 +20,7 @@ def __init__(self, path = None, capacity: int = 2, logger = None): self.path = Path(path or os.path.dirname(__file__)).resolve() for i in range(self.capacity): - self.reset_executor.submit(reset_with_callback, Instance(self.path, instance_num=i), self.instance_reset_callback) + self.reset_executor.submit(reset_with_callback, self.instance_factory(self.path, instance_num=i), self.instance_reset_callback) # Wait for all instances to be initialized with tqdm(total=self.capacity, desc="Initializing instances") as pbar: diff --git a/omnitool/omnibox/node/server.py b/omnitool/omnibox/node/server.py index 30a0f833..9a445fa0 100644 --- a/omnitool/omnibox/node/server.py +++ b/omnitool/omnibox/node/server.py @@ -6,15 +6,19 @@ import argparse from instance_manager import InstanceManager from instance_client import InstanceClient +from instance import Instance +from mock_instance import MockInstance from pathlib import Path parser = argparse.ArgumentParser(description="OmniBox Host") parser.add_argument("--port", type=int, default=8000, help="Port to run the server on") parser.add_argument('--path', type=str, default='/home/azureuser/ataymano/OmniParser/omnitool/omnibox/run1', help="Path to the instance directory. Expected to contain prepared common subfolder") +parser.add_argument('--mock', action='store_true', help="Use mock instances") args = parser.parse_args() Path(args.path).mkdir(parents=True, exist_ok=True) -instance_manager = InstanceManager(args.path) +instance_factory = MockInstance if args.mock else Instance +instance_manager = InstanceManager(instance_factory = instance_factory, path = args.path) @asynccontextmanager async def lifespan(app: FastAPI): From 9c84ba95934c9ffde0bc93b848aef7420f738c48 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Wed, 7 May 2025 17:47:01 +0000 Subject: [PATCH 24/27] v0 --- .../scripts/omniboxes/OmniBoxes/Dockerfile | 48 ------------------- .../scripts/omniboxes/OmniBoxes/cleanall | 10 ---- .../scripts/omniboxes/OmniBoxes/command.txt | 1 - .../scripts/omniboxes/OmniBoxes/compose.yml | 23 --------- .../omniboxes/OmniBoxes/requirements.txt | 3 -- .../omniboxes/OmniBoxes => v0}/manageall.py | 0 .../OmniBoxes => v0}/manageinstance.py | 0 7 files changed, 85 deletions(-) delete mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/Dockerfile delete mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/cleanall delete mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/command.txt delete mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/compose.yml delete mode 100644 omnitool/omnibox/scripts/omniboxes/OmniBoxes/requirements.txt rename omnitool/omnibox/{scripts/omniboxes/OmniBoxes => v0}/manageall.py (100%) rename omnitool/omnibox/{scripts/omniboxes/OmniBoxes => v0}/manageinstance.py (100%) diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/Dockerfile b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/Dockerfile deleted file mode 100644 index b464714a..00000000 --- a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/Dockerfile +++ /dev/null @@ -1,48 +0,0 @@ -ARG VERSION_ARG="latest" -FROM scratch AS build-amd64 - -COPY --from=qemux/qemu-docker:6.08 / / - -ARG DEBCONF_NOWARNINGS="yes" -ARG DEBIAN_FRONTEND="noninteractive" -ARG DEBCONF_NONINTERACTIVE_SEEN="true" - -RUN set -eu && \ - apt-get update && \ - apt-get --no-install-recommends -y install \ - bc \ - jq \ - curl \ - 7zip \ - wsdd \ - samba \ - xz-utils \ - wimtools \ - dos2unix \ - cabextract \ - genisoimage \ - libxml2-utils \ - libarchive-tools && \ - apt-get clean && \ - rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* - -COPY --chmod=755 ./vm/buildcontainer /run/ -RUN dos2unix /run/* - -COPY --chmod=755 ./vm/win11def /run/assets -RUN dos2unix /run/assets/* - -ADD --chmod=755 https://raw.githubusercontent.com/christgau/wsdd/v0.8/src/wsdd.py /usr/sbin/wsdd -ADD --chmod=664 https://github.com/qemus/virtiso-whql/releases/download/v1.9.43-0/virtio-win-1.9.43.tar.xz /drivers.txz - -FROM dockurr/windows-arm:${VERSION_ARG} AS build-arm64 -FROM build-${TARGETARCH} - -ARG VERSION_ARG="0.00" -RUN echo "$VERSION_ARG" > /run/version - -EXPOSE 8006 3389 - -ENV VERSION="win11e" - -ENTRYPOINT ["/usr/bin/tini", "-s", "/run/entry.sh"] \ No newline at end of file diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/cleanall b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/cleanall deleted file mode 100644 index b5c66144..00000000 --- a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/cleanall +++ /dev/null @@ -1,10 +0,0 @@ -from manageinstance import delete_instance -import os -import shutil - -# for every folder of the form omnibox- in this dir delete the docker container (leave folder) -for folder in os.listdir("."): - if folder.startswith("omnibox-"): - delete_instance(int(folder.split("-")[1])) - # uncomment below to also delete the folder - shutil.rmtree(folder) diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/command.txt b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/command.txt deleted file mode 100644 index 4d152f93..00000000 --- a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/command.txt +++ /dev/null @@ -1 +0,0 @@ -az storage blob upload-batch --account-name goldenimage --sas-token "sp=racw&st=2025-04-02T23:09:18Z&se=2025-04-03T07:09:18Z&spr=https&sv=2024-11-04&sr=c&sig=kCahg2xb32DgJjOGYiDAcX716m6df5AZBD2KV5sPeVs%3D" --destination goldenimages --source /home/thomasdh/OmniBoxes/common \ No newline at end of file diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/compose.yml b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/compose.yml deleted file mode 100644 index 101f6667..00000000 --- a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/compose.yml +++ /dev/null @@ -1,23 +0,0 @@ -services: - windows: - image: windows-local - container_name: omni-windows - privileged: true - environment: - RAM_SIZE: "8G" - CPU_CORES: "4" - DISK_SIZE: "11G" - devices: - - /dev/kvm - - /dev/net/tun - cap_add: - - NET_ADMIN - ports: - - 8006:8006 # Web Viewer access - - 5000:5000 # Computer control server - volumes: - - ./common/win11iso/custom.iso:/custom.iso - - ./common/win11setup/firstboot:/oem - - ./common/win11setup/setupscripts:/data - - ./omnibox-0:/storage - \ No newline at end of file diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/requirements.txt b/omnitool/omnibox/scripts/omniboxes/OmniBoxes/requirements.txt deleted file mode 100644 index c4641cdf..00000000 --- a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -fastapi[standard] -requests -tqdm diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageall.py b/omnitool/omnibox/v0/manageall.py similarity index 100% rename from omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageall.py rename to omnitool/omnibox/v0/manageall.py diff --git a/omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageinstance.py b/omnitool/omnibox/v0/manageinstance.py similarity index 100% rename from omnitool/omnibox/scripts/omniboxes/OmniBoxes/manageinstance.py rename to omnitool/omnibox/v0/manageinstance.py From 0b4094142d92e0e6e911209ff125bb9b54eb6151 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Thu, 8 May 2025 14:07:18 +0000 Subject: [PATCH 25/27] omniboxes --- .../{omnibox => omniboxes}/client/client.py | 28 ++++++------ .../client/requirements.txt | 0 omnitool/omniboxes/master/__init__.py | 0 .../master/logging_utils.py | 0 .../master/node_manager.py | 2 +- .../{omnibox => omniboxes}/master/server.py | 22 ++++++---- omnitool/omniboxes/node/__init__.py | 0 .../{omnibox => omniboxes}/node/instance.py | 43 +++++++------------ .../node/instance_client.py | 0 .../node/instance_manager.py | 0 .../node/logging_utils.py | 0 .../node/mock_instance.py | 15 ++++--- .../node/requirements.txt | 0 .../{omnibox => omniboxes}/node/server.py | 2 +- .../{omnibox => omniboxes}/v0/manageall.py | 0 .../v0/manageinstance.py | 0 16 files changed, 55 insertions(+), 57 deletions(-) rename omnitool/{omnibox => omniboxes}/client/client.py (96%) rename omnitool/{omnibox => omniboxes}/client/requirements.txt (100%) create mode 100644 omnitool/omniboxes/master/__init__.py rename omnitool/{omnibox => omniboxes}/master/logging_utils.py (100%) rename omnitool/{omnibox => omniboxes}/master/node_manager.py (98%) rename omnitool/{omnibox => omniboxes}/master/server.py (87%) create mode 100644 omnitool/omniboxes/node/__init__.py rename omnitool/{omnibox => omniboxes}/node/instance.py (77%) rename omnitool/{omnibox => omniboxes}/node/instance_client.py (100%) rename omnitool/{omnibox => omniboxes}/node/instance_manager.py (100%) rename omnitool/{omnibox => omniboxes}/node/logging_utils.py (100%) rename omnitool/{omnibox => omniboxes}/node/mock_instance.py (86%) rename omnitool/{omnibox => omniboxes}/node/requirements.txt (100%) rename omnitool/{omnibox => omniboxes}/node/server.py (95%) rename omnitool/{omnibox => omniboxes}/v0/manageall.py (100%) rename omnitool/{omnibox => omniboxes}/v0/manageinstance.py (100%) diff --git a/omnitool/omnibox/client/client.py b/omnitool/omniboxes/client/client.py similarity index 96% rename from omnitool/omnibox/client/client.py rename to omnitool/omniboxes/client/client.py index 0491d7d9..8c42b4ff 100644 --- a/omnitool/omnibox/client/client.py +++ b/omnitool/omniboxes/client/client.py @@ -41,24 +41,26 @@ def _doubleClick(): ]) } -def _position(): +def _position(ignore_by_mock = True): return { 'command': _pyscript([ 'import pyautogui', 'import json', 'p = pyautogui.position()', "print(json.dumps({'x': p.x, 'y': p.y}))", - ]) + ]), + 'ignore_by_mock': ignore_by_mock } -def _screensize(): +def _screensize(ignore_by_mock = True): return { 'command': _pyscript([ 'import pyautogui', 'import json', 'sz = pyautogui.size()', "print(json.dumps({'width': sz.width, 'height': sz.height}))", - ]) + ]), + 'ignore_by_mock': ignore_by_mock } @@ -142,9 +144,8 @@ def __init__(self, host = 'localhost', port = 8000): self.instance_id = None def get_instance(self): - data = requests.post(f'http://{self.host}:{self.port}/get') - instance_id = data.json()['instance_id'] - return instance_id + data = requests.post(f'http://{self.host}:{self.port}/get').json() + return data.get('instance_id', None) def get_instances_info(self): data = requests.get(f'http://{self.host}:{self.port}/info') @@ -194,14 +195,17 @@ def ui(self): instances = ipywidgets.RadioButtons(description = 'Instances', options = self.get_instances_info()['in_use'], layout=ipywidgets.Layout(width='50%')) self.instance_id = instances.value def on_add_click(b): - self.get_instance() - info = self.get_instances_info() - instances.options = info['in_use'] + instance_id = self.get_instance() + if instance_id: + instances.options = list(instances.options) + [instance_id] + else: + print('No instance available') def on_release_click(b): self.reset_instance(instances.value) - info = self.get_instances_info() - instances.options = info['in_use'] + options = list(instances.options) + options.remove(instances.value) + instances.options = options get_button.on_click(on_add_click) release_button.on_click(on_release_click) diff --git a/omnitool/omnibox/client/requirements.txt b/omnitool/omniboxes/client/requirements.txt similarity index 100% rename from omnitool/omnibox/client/requirements.txt rename to omnitool/omniboxes/client/requirements.txt diff --git a/omnitool/omniboxes/master/__init__.py b/omnitool/omniboxes/master/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/omnitool/omnibox/master/logging_utils.py b/omnitool/omniboxes/master/logging_utils.py similarity index 100% rename from omnitool/omnibox/master/logging_utils.py rename to omnitool/omniboxes/master/logging_utils.py diff --git a/omnitool/omnibox/master/node_manager.py b/omnitool/omniboxes/master/node_manager.py similarity index 98% rename from omnitool/omnibox/master/node_manager.py rename to omnitool/omniboxes/master/node_manager.py index 3d97d93f..d4030320 100644 --- a/omnitool/omnibox/master/node_manager.py +++ b/omnitool/omniboxes/master/node_manager.py @@ -38,7 +38,7 @@ def _default_logger(): class NodeManager: - def __init__(self, logger = None, update_timeout: int = 60): + def __init__(self, logger = None, update_timeout: int = 10): self._nodes = {} self._node_info = {} self.logger = logger or _default_logger() diff --git a/omnitool/omnibox/master/server.py b/omnitool/omniboxes/master/server.py similarity index 87% rename from omnitool/omnibox/master/server.py rename to omnitool/omniboxes/master/server.py index 3cd46a79..aec69e07 100644 --- a/omnitool/omnibox/master/server.py +++ b/omnitool/omniboxes/master/server.py @@ -23,7 +23,8 @@ @asynccontextmanager async def lifespan(app: FastAPI): await node_manager.register_node(NodeRegistration(url = "http://localhost:8000")) - task = asyncio.create_task(node_manager.update_statuses_worker()) +# await node_manager.register_node(NodeRegistration(url = "http://localhost:8001")) + tasks = asyncio.create_task(node_manager.update_statuses_worker()) yield # Shutdown code goes here @@ -34,6 +35,7 @@ async def lifespan(app: FastAPI): @app.post("/get") def create_instance(): + """Get an available new instance from less occupied node""" node = node_manager.get_best_node() if node is None: raise HTTPException( @@ -41,12 +43,16 @@ def create_instance(): detail="No available nodes with capacity to create new instance" ) - data = requests.post(f'{node.url}/get') - instance_id = data.json()['instance_id'] - return { - 'instance_id': instance_id, - 'node': node.hash, - } + data = requests.post(f'{node.url}/get').json() + if 'instance_id' in data: + return { + 'instance_id': data['instance_id'], + 'node': node.hash, + } + raise HTTPException( + status_code=status.HTTP_503_SERVICE_UNAVAILABLE, + detail="No available nodes with capacity to create new instance" + ) @app.post("/reset") async def reset(instance_id: str, node: str): @@ -63,7 +69,7 @@ async def reset(instance_id: str, node: str): @app.get("/probe") async def probe(instance_id: str, node: str): - """Reset an existing instance by delegating to the worker node that hosts it""" + """Probe the instance by delegating to the worker node that hosts it""" node_info = node_manager.get_node(node) if node_info is None: raise HTTPException( diff --git a/omnitool/omniboxes/node/__init__.py b/omnitool/omniboxes/node/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/omnitool/omnibox/node/instance.py b/omnitool/omniboxes/node/instance.py similarity index 77% rename from omnitool/omnibox/node/instance.py rename to omnitool/omniboxes/node/instance.py index 24ee224d..c5692bab 100644 --- a/omnitool/omnibox/node/instance.py +++ b/omnitool/omniboxes/node/instance.py @@ -80,54 +80,41 @@ def __init__(self, root_path = None, instance_num = 0, logger = None): ) temp_file.write(compose_content) + def path(self): + return f"{self.root_path}/omnibox-{self.instance_num}/" + + def _execute(self, command): + self.logger.info(f'Running: {" ".join(command)}') + subprocess.run(command, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + def create(self): - if not os.path.exists(f"omnibox-{self.instance_num}"): + if not os.path.exists(self.path()): os.makedirs(f"omnibox-{self.instance_num}") - subprocess.run(["cp", "-r", f"{str(self.root_path)}/common/win11storage/.", f"{self.root_path}/omnibox-{self.instance_num}/"]) + subprocess.run(["cp", "-r", f"{str(self.root_path)}/common/win11storage/.", self.path()]) try: - subprocess.run( - ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "up", "-d"], - check=True, - stdout=subprocess.DEVNULL, # Suppress standard output - stderr=subprocess.DEVNULL # Suppress error output - ) + self._execute(["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "up", "-d"]) self.logger.info(f"Instance {self.instance_num} launched successfully!") except subprocess.CalledProcessError as e: self.logger.error(f"Error launching instance {self.instance_num}: {e}") def start(self): try: - subprocess.run( - ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "start"], - check=True, - stdout=subprocess.DEVNULL, - stderr=subprocess.DEVNULL - ) + self._execute(["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "start"]) self.logger.info(f"Instance {self.instance_num} started successfully!") except subprocess.CalledProcessError as e: self.logger.error(f"Error starting instance {self.instance_num}: {e}") def stop(self): try: - subprocess.run( - ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "stop"], - check=True, - stdout=subprocess.DEVNULL, - stderr=subprocess.DEVNULL - ) + self._execute(["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "stop"]) self.logger.info(f"Instance {self.instance_num} stopped successfully!") except subprocess.CalledProcessError as e: self.logger.error(f"Error stopping instance {self.instance_num}: {e}") def delete(self): try: - subprocess.run( - ["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "down"], - check=True, - stdout=subprocess.DEVNULL, - stderr=subprocess.DEVNULL - ) + self._execute(["docker", "compose", "-f", str(self.config_path), "-p", f"omnibox-{self.instance_num}", "down"]) self.logger.info(f"Instance {self.instance_num} deleted successfully!") except subprocess.CalledProcessError as e: self.logger.error(f"Error deleting instance {self.instance_num}: {e}") @@ -144,13 +131,13 @@ def is_ready(self): def reset(self): self.delete() - if os.path.exists(f"omnibox-{self.instance_num}"): + if os.path.exists(self.path()): subprocess.run(["sudo", "rm", "-rf", f"{self.root_path}/omnibox-{self.instance_num}"], check=True) self.create() def reset_soft(self): self.stop() - if os.path.exists(f"omnibox-{self.instance_num}"): + if os.path.exists(self.path()): subprocess.run(["sudo", "rm", "-rf", f"{self.root_path}/omnibox-{self.instance_num}"], check=True) self.start() diff --git a/omnitool/omnibox/node/instance_client.py b/omnitool/omniboxes/node/instance_client.py similarity index 100% rename from omnitool/omnibox/node/instance_client.py rename to omnitool/omniboxes/node/instance_client.py diff --git a/omnitool/omnibox/node/instance_manager.py b/omnitool/omniboxes/node/instance_manager.py similarity index 100% rename from omnitool/omnibox/node/instance_manager.py rename to omnitool/omniboxes/node/instance_manager.py diff --git a/omnitool/omnibox/node/logging_utils.py b/omnitool/omniboxes/node/logging_utils.py similarity index 100% rename from omnitool/omnibox/node/logging_utils.py rename to omnitool/omniboxes/node/logging_utils.py diff --git a/omnitool/omnibox/node/mock_instance.py b/omnitool/omniboxes/node/mock_instance.py similarity index 86% rename from omnitool/omnibox/node/mock_instance.py rename to omnitool/omniboxes/node/mock_instance.py index d3170102..d58c8829 100644 --- a/omnitool/omnibox/node/mock_instance.py +++ b/omnitool/omniboxes/node/mock_instance.py @@ -25,7 +25,8 @@ def probe_endpoint(): def execute_command(): data = request.json command = data.get('command', "") - self.command_history.append(str(command)) + if not data.get('ignore_by_mock', False): + self.command_history.append(str(command)) return jsonify({ 'status': 'success', 'output': '{}', @@ -85,16 +86,16 @@ def __init__(self, root_path = None, instance_num = 0, logger = None): p.start() def create(self): - self.logger.info("Dummy instance created") + self.logger.info(f"Creating dummy instance {self.instance_num}") def start(self): - self.logger.info("Dummy instance started") + self.logger.info(f"Starting dummy instance {self.instance_num}") def stop(self): - self.logger.info("Dummy instance stopped") + self.logger.info(f"Stopping dummy instance {self.instance_num}") def delete(self): - self.logger.info("Dummy instance deleted") + self.logger.info(f"Deleting dummy instance {self.instance_num}") def flask_url(self): return f"http://localhost:{5000 + self.instance_num}" @@ -104,7 +105,7 @@ def is_ready(self): def reset(self): self.app.command_history = [] - self.logger.info("Dummy instance reset") + self.logger.info(f"Resetting dummy instance {self.instance_num}") def reset_soft(self): - self.logger.info("Dummy instance reset soft") + self.logger.info(f"Soft resetting dummy instance {self.instance_num}") diff --git a/omnitool/omnibox/node/requirements.txt b/omnitool/omniboxes/node/requirements.txt similarity index 100% rename from omnitool/omnibox/node/requirements.txt rename to omnitool/omniboxes/node/requirements.txt diff --git a/omnitool/omnibox/node/server.py b/omnitool/omniboxes/node/server.py similarity index 95% rename from omnitool/omnibox/node/server.py rename to omnitool/omniboxes/node/server.py index 9a445fa0..5ba6612f 100644 --- a/omnitool/omnibox/node/server.py +++ b/omnitool/omniboxes/node/server.py @@ -12,7 +12,7 @@ parser = argparse.ArgumentParser(description="OmniBox Host") parser.add_argument("--port", type=int, default=8000, help="Port to run the server on") -parser.add_argument('--path', type=str, default='/home/azureuser/ataymano/OmniParser/omnitool/omnibox/run1', help="Path to the instance directory. Expected to contain prepared common subfolder") +parser.add_argument('--path', type=str, default='../run', help="Path to the instance directory. Expected to contain prepared common subfolder") parser.add_argument('--mock', action='store_true', help="Use mock instances") args = parser.parse_args() diff --git a/omnitool/omnibox/v0/manageall.py b/omnitool/omniboxes/v0/manageall.py similarity index 100% rename from omnitool/omnibox/v0/manageall.py rename to omnitool/omniboxes/v0/manageall.py diff --git a/omnitool/omnibox/v0/manageinstance.py b/omnitool/omniboxes/v0/manageinstance.py similarity index 100% rename from omnitool/omnibox/v0/manageinstance.py rename to omnitool/omniboxes/v0/manageinstance.py From 324626755adaa1c6800374c320f9de097b578f29 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Thu, 8 May 2025 14:22:00 +0000 Subject: [PATCH 26/27] notebook move --- omnitool/omnibox/client/notebook.ipynb | 136 ----------------------- omnitool/omniboxes/client/notebook.ipynb | 84 ++++++++++++++ 2 files changed, 84 insertions(+), 136 deletions(-) delete mode 100644 omnitool/omnibox/client/notebook.ipynb create mode 100644 omnitool/omniboxes/client/notebook.ipynb diff --git a/omnitool/omnibox/client/notebook.ipynb b/omnitool/omnibox/client/notebook.ipynb deleted file mode 100644 index eb30ad84..00000000 --- a/omnitool/omnibox/client/notebook.ipynb +++ /dev/null @@ -1,136 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "578457c0", - "metadata": {}, - "source": [ - "# Test instance" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "ae7b2936", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "af9a41f28b6245168be034d10a2303cd", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(FloatLogSlider(value=1.0, base=2.0, description='wait (s)', max=5.0, min=-3.0, step=1.0), HBox(…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import client\n", - "client.InstanceClient(port = 5001).ui()" - ] - }, - { - "cell_type": "markdown", - "id": "741598f1", - "metadata": {}, - "source": [ - "# Test node" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "eca33f8c", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c7f1d7a7f3f74587a4ee5d0d648025cd", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HBox(children=(RadioButtons(description='Instances', layout=Layout(width='50%'), options=(), va…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import client\n", - "c = client.NodeClient(port = 8000)\n", - "c.ui()" - ] - }, - { - "cell_type": "markdown", - "id": "c2b1810b", - "metadata": {}, - "source": [ - "# Test master node" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "bf6188a0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4d55d4c417724189b0d0129f93f80a08", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HBox(children=(RadioButtons(description='Instances', layout=Layout(width='50%'), options=('{\"in…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import client\n", - "c = client.MasterClient(port = 7000)\n", - "c.ui()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "omnibox", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/omnitool/omniboxes/client/notebook.ipynb b/omnitool/omniboxes/client/notebook.ipynb new file mode 100644 index 00000000..972a3832 --- /dev/null +++ b/omnitool/omniboxes/client/notebook.ipynb @@ -0,0 +1,84 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "578457c0", + "metadata": {}, + "source": [ + "# Test instance" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ae7b2936", + "metadata": {}, + "outputs": [], + "source": [ + "import client\n", + "client.InstanceClient(port = 5000).ui()" + ] + }, + { + "cell_type": "markdown", + "id": "741598f1", + "metadata": {}, + "source": [ + "# Test node" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eca33f8c", + "metadata": {}, + "outputs": [], + "source": [ + "import client\n", + "c = client.NodeClient(port = 8000)\n", + "c.ui()" + ] + }, + { + "cell_type": "markdown", + "id": "c2b1810b", + "metadata": {}, + "source": [ + "# Test master node" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf6188a0", + "metadata": {}, + "outputs": [], + "source": [ + "import client\n", + "c = client.MasterClient(port = 7000)\n", + "c.ui()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "omnibox", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 5d9da468f3553344f3dcab9551c98aed40ee8438 Mon Sep 17 00:00:00 2001 From: Alexey Taymano Date: Thu, 8 May 2025 14:35:56 +0000 Subject: [PATCH 27/27] base_port_control --- omnitool/omniboxes/node/instance_manager.py | 2 +- omnitool/omniboxes/node/mock_instance.py | 11 ++++++++--- omnitool/omniboxes/node/server.py | 4 +++- 3 files changed, 12 insertions(+), 5 deletions(-) diff --git a/omnitool/omniboxes/node/instance_manager.py b/omnitool/omniboxes/node/instance_manager.py index 17fa3425..33e08832 100644 --- a/omnitool/omniboxes/node/instance_manager.py +++ b/omnitool/omniboxes/node/instance_manager.py @@ -20,7 +20,7 @@ def __init__(self, instance_factory = None, path = None, capacity: int = 2, logg self.path = Path(path or os.path.dirname(__file__)).resolve() for i in range(self.capacity): - self.reset_executor.submit(reset_with_callback, self.instance_factory(self.path, instance_num=i), self.instance_reset_callback) + self.reset_executor.submit(reset_with_callback, self.instance_factory(self.path, instance_num=i, logger=self.logger), self.instance_reset_callback) # Wait for all instances to be initialized with tqdm(total=self.capacity, desc="Initializing instances") as pbar: diff --git a/omnitool/omniboxes/node/mock_instance.py b/omnitool/omniboxes/node/mock_instance.py index d58c8829..46c532ae 100644 --- a/omnitool/omniboxes/node/mock_instance.py +++ b/omnitool/omniboxes/node/mock_instance.py @@ -76,15 +76,20 @@ def screenshot(): class MockInstance(IInstance): - def __init__(self, root_path = None, instance_num = 0, logger = None): + def __init__(self, root_path = None, instance_num = 0, logger = None, base_control_port = 5000): print(f'Creating mock instance: {instance_num}') self.root_path = root_path self.instance_num = instance_num self.app = MockApp() self.logger = logger or default_logger() - p = Thread(target=self.app.app.run, args=('0.0.0.0',5000 + self.instance_num), daemon=True) + self.base_control_port = base_control_port + p = Thread(target=self.app.app.run, args=('0.0.0.0', self.control_port), daemon=True) p.start() + @property + def control_port(self): + return self.base_control_port + self.instance_num + def create(self): self.logger.info(f"Creating dummy instance {self.instance_num}") @@ -98,7 +103,7 @@ def delete(self): self.logger.info(f"Deleting dummy instance {self.instance_num}") def flask_url(self): - return f"http://localhost:{5000 + self.instance_num}" + return f"http://localhost:{self.control_port}" def is_ready(self): return True diff --git a/omnitool/omniboxes/node/server.py b/omnitool/omniboxes/node/server.py index 5ba6612f..c8bc2e09 100644 --- a/omnitool/omniboxes/node/server.py +++ b/omnitool/omniboxes/node/server.py @@ -13,11 +13,13 @@ parser = argparse.ArgumentParser(description="OmniBox Host") parser.add_argument("--port", type=int, default=8000, help="Port to run the server on") parser.add_argument('--path', type=str, default='../run', help="Path to the instance directory. Expected to contain prepared common subfolder") +parser.add_argument('--base_control_port', type=int, default=5000, help="Base control port offset for the instances (for testing with mock instances)") parser.add_argument('--mock', action='store_true', help="Use mock instances") args = parser.parse_args() Path(args.path).mkdir(parents=True, exist_ok=True) -instance_factory = MockInstance if args.mock else Instance +mock_instance_factory = lambda root_path, instance_num, logger: MockInstance(root_path, instance_num, logger, args.base_control_port) +instance_factory = mock_instance_factory if args.mock else Instance instance_manager = InstanceManager(instance_factory = instance_factory, path = args.path) @asynccontextmanager