fastled 1.1.7__py2.py3-none-any.whl → 1.1.16__py2.py3-none-any.whl

fastled/compile_server.py

@@ -1,251 +1,156 @@
-import socket
-import subprocess
-import threading
-import time
-from pathlib import Path
-from typing import Optional
-
-import httpx
-
-from fastled.docker_manager import DockerManager
-from fastled.sketch import looks_like_fastled_repo
-
-_DEFAULT_CONTAINER_NAME = "fastled-wasm-compiler"
-
-SERVER_PORT = 9021
-
-
-def find_available_port(start_port: int = SERVER_PORT) -> int:
-    """Find an available port starting from the given port."""
-    port = start_port
-    end_port = start_port + 1000
-    while True:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            if s.connect_ex(("localhost", port)) != 0:
-                return port
-            port += 1
-            if port >= end_port:
-                raise RuntimeError("No available ports found")
-
-
-class CompileServer:
-    def __init__(
-        self,
-        container_name=_DEFAULT_CONTAINER_NAME,
-        interactive: bool = False,
-    ) -> None:
-
-        cwd = Path(".").resolve()
-        fastled_src_dir: Path | None = None
-        if looks_like_fastled_repo(cwd):
-            print(
-                "Looks like a FastLED repo, using it as the source directory and mapping it into the server."
-            )
-            fastled_src_dir = cwd / "src"
-
-        self.container_name = container_name
-        self.docker = DockerManager(container_name=container_name)
-        self.running = False
-        self.thread: Optional[threading.Thread] = None
-        self.running_process: subprocess.Popen | None = None
-        self.fastled_src_dir: Path | None = fastled_src_dir
-        self.interactive = interactive
-        self._port = self._start()
-
-    def port(self) -> int:
-        return self._port
-
-    def url(self) -> str:
-        return f"http://localhost:{self._port}"
-
-    def wait_for_startup(self, timeout: int = 100) -> bool:
-        """Wait for the server to start up."""
-        start_time = time.time()
-        while time.time() - start_time < timeout:
-            # ping the server to see if it's up
-            if not self._port:
-                return False
-            # use httpx to ping the server
-            # if successful, return True
-            try:
-                response = httpx.get(
-                    f"http://localhost:{self._port}", follow_redirects=True
-                )
-                if response.status_code < 400:
-                    return True
-            except KeyboardInterrupt:
-                raise
-            except Exception:
-                pass
-            time.sleep(0.1)
-            if not self.running:
-                return False
-        return False
-
-    def _start(self) -> int:
-        print("Compiling server starting")
-        self.running = True
-        # Ensure Docker is running
-        with self.docker.get_lock():
-            if not self.docker.is_running():
-                if not self.docker.start():
-                    print("Docker could not be started. Exiting.")
-                    raise RuntimeError("Docker could not be started. Exiting.")
-
-            # Clean up any existing container with the same name
-
-            try:
-                container_exists = (
-                    subprocess.run(
-                        ["docker", "inspect", self.container_name],
-                        capture_output=True,
-                        text=True,
-                    ).returncode
-                    == 0
-                )
-                if container_exists:
-                    print("Cleaning up existing container")
-                    subprocess.run(
-                        ["docker", "rm", "-f", self.container_name],
-                        check=False,
-                    )
-            except KeyboardInterrupt:
-                raise
-            except Exception as e:
-                print(f"Warning: Failed to remove existing container: {e}")
-
-            print("Ensuring Docker image exists at latest version")
-            if not self.docker.ensure_image_exists():
-                print("Failed to ensure Docker image exists.")
-                raise RuntimeError("Failed to ensure Docker image exists")
-
-        print("Docker image now validated")
-
-        # Remove the image to force a fresh download
-        # subprocess.run(["docker", "rmi", "fastled-wasm"], capture_output=True)
-        # print("All clean")
-
-        port = find_available_port()
-        print(f"Found an available port: {port}")
-        # server_command = ["python", "/js/run.py", "server", "--allow-shutdown"]
-        if self.interactive:
-            server_command = ["/bin/bash"]
-        else:
-            server_command = ["python", "/js/run.py", "server"]
-        print(f"Started Docker container with command: {server_command}")
-        ports = {port: 80}
-        volumes = None
-        if self.fastled_src_dir:
-            print(
-                f"Mounting FastLED source directory {self.fastled_src_dir} into container /host/fastled/src"
-            )
-            volumes = {
-                str(self.fastled_src_dir): {"bind": "/host/fastled/src", "mode": "ro"}
-            }
-            if not self.interactive:
-                # no auto-update because the source directory is mapped in.
-                # This should be automatic now.
-                server_command.append("--no-auto-update")  # stop git repo updates.
-        self.running_process = self.docker.run_container(
-            server_command, ports=ports, volumes=volumes
-        )
-        print("Compile server starting")
-        time.sleep(3)
-        if self.running_process.poll() is not None:
-            print("Server failed to start")
-            self.running = False
-            raise RuntimeError("Server failed to start")
-        self.thread = threading.Thread(target=self._server_loop, daemon=True)
-        self.thread.start()
-
-        return port
-
-    def proceess_running(self) -> bool:
-        if self.running_process is None:
-            return False
-        return self.running_process.poll() is None
-
-    def stop(self) -> None:
-        print(f"Stopping server on port {self._port}")
-        # attempt to send a shutdown signal to the server
-        try:
-            httpx.get(f"http://localhost:{self._port}/shutdown", timeout=2)
-        # except Exception:
-        except Exception as e:
-            print(f"Failed to send shutdown signal: {e}")
-            pass
-        try:
-            # Stop the Docker container
-            cp: subprocess.CompletedProcess
-            cp = subprocess.run(
-                ["docker", "stop", self.container_name],
-                capture_output=True,
-                text=True,
-                check=True,
-            )
-            if cp.returncode != 0:
-                print(f"Failed to stop Docker container: {cp.stderr}")
-
-            cp = subprocess.run(
-                ["docker", "rm", self.container_name],
-                capture_output=True,
-                text=True,
-                check=True,
-            )
-            if cp.returncode != 0:
-                print(f"Failed to remove Docker container: {cp.stderr}")
-
-            # Close the stdout pipe
-            if self.running_process and self.running_process.stdout:
-                self.running_process.stdout.close()
-
-                # Wait for the process to fully terminate with a timeout
-                self.running_process.wait(timeout=10)
-                if self.running_process.returncode is None:
-                    # kill
-                    self.running_process.kill()
-                if self.running_process.returncode is not None:
-                    print(
-                        f"Server stopped with return code {self.running_process.returncode}"
-                    )
-
-        except subprocess.TimeoutExpired:
-            # Force kill if it doesn't stop gracefully
-            if self.running_process:
-                self.running_process.kill()
-                self.running_process.wait()
-        except KeyboardInterrupt:
-            if self.running_process:
-                self.running_process.kill()
-                self.running_process.wait()
-        except Exception as e:
-            print(f"Error stopping Docker container: {e}")
-        finally:
-            self.running_process = None
-        # Signal the server thread to stop
-        self.running = False
-        if self.thread:
-            self.thread.join(timeout=10)  # Wait up to 10 seconds for thread to finish
-            if self.thread.is_alive():
-                print("Warning: Server thread did not terminate properly")
-
-        print("Compile server stopped")
-
-    def _server_loop(self) -> None:
-        try:
-            while self.running:
-                if self.running_process:
-                    # Read Docker container output
-                    # Check if Docker process is still running
-                    if self.running_process.poll() is not None:
-                        print("Docker server stopped unexpectedly")
-                        self.running = False
-                        break
-
-                time.sleep(0.1)  # Prevent busy waiting
-        except KeyboardInterrupt:
-            print("Server thread stopped by user.")
-        except Exception as e:
-            print(f"Error in server thread: {e}")
-        finally:
-            self.running = False
+import subprocess
+import time
+from pathlib import Path
+
+import httpx
+
+from fastled.docker_manager import DISK_CACHE, DockerManager, RunningContainer
+from fastled.sketch import looks_like_fastled_repo
+
+_IMAGE_NAME = "niteris/fastled-wasm"
+_DEFAULT_CONTAINER_NAME = "fastled-wasm-compiler"
+
+SERVER_PORT = 9021
+
+SERVER_OPTIONS = ["--allow-shutdown", "--no-auto-update"]
+
+
+class CompileServer:
+    def __init__(
+        self,
+        container_name=_DEFAULT_CONTAINER_NAME,
+        interactive: bool = False,
+    ) -> None:
+
+        cwd = Path(".").resolve()
+        fastled_src_dir: Path | None = None
+        if looks_like_fastled_repo(cwd):
+            print(
+                "Looks like a FastLED repo, using it as the source directory and mapping it into the server."
+            )
+            fastled_src_dir = cwd / "src"
+
+        self.container_name = container_name
+        self.docker = DockerManager()
+        self.fastled_src_dir: Path | None = fastled_src_dir
+        self.interactive = interactive
+        self.running_container: RunningContainer | None = None
+        self._port = self._start()
+        # fancy print
+        if not interactive:
+            msg = f"# FastLED Compile Server started at {self.url()} #"
+            print("\n" + "#" * len(msg))
+            print(msg)
+            print("#" * len(msg) + "\n")
+
+    @property
+    def running(self) -> bool:
+        if not self._port:
+            return False
+        if not DockerManager.is_docker_installed():
+            return False
+        if not DockerManager.is_running():
+            return False
+        return self.docker.is_container_running(self.container_name)
+
+    def using_fastled_src_dir_volume(self) -> bool:
+        return self.fastled_src_dir is not None
+
+    def port(self) -> int:
+        return self._port
+
+    def url(self) -> str:
+        return f"http://localhost:{self._port}"
+
+    def wait_for_startup(self, timeout: int = 100) -> bool:
+        """Wait for the server to start up."""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            # ping the server to see if it's up
+            if not self._port:
+                return False
+            # use httpx to ping the server
+            # if successful, return True
+            try:
+                response = httpx.get(
+                    f"http://localhost:{self._port}", follow_redirects=True
+                )
+                if response.status_code < 400:
+                    return True
+            except KeyboardInterrupt:
+                raise
+            except Exception:
+                pass
+            time.sleep(0.1)
+            if not self.docker.is_container_running(self.container_name):
+                return False
+        return False
+
+    def _start(self) -> int:
+        print("Compiling server starting")
+
+        # Ensure Docker is running
+        with self.docker.get_lock():
+            if not self.docker.is_running():
+                if not self.docker.start():
+                    print("Docker could not be started. Exiting.")
+                    raise RuntimeError("Docker could not be started. Exiting.")
+            from datetime import datetime, timezone
+
+            now = datetime.now(timezone.utc)
+            now_str = now.strftime("%Y-%m-%d %H %Z")
+            prev_date_str = DISK_CACHE.get("last-update")
+
+            upgrade = False
+            if prev_date_str != now_str:
+                print("New day, upgrading Docker image")
+                upgrade = True
+
+            self.docker.validate_or_download_image(
+                image_name=_IMAGE_NAME, tag="main", upgrade=upgrade
+            )
+            DISK_CACHE.put("last-update", now_str)
+
+        print("Docker image now validated")
+        port = SERVER_PORT
+        if self.interactive:
+            server_command = ["/bin/bash"]
+        else:
+            server_command = ["python", "/js/run.py", "server"] + SERVER_OPTIONS
+        server_cmd_str = subprocess.list2cmdline(server_command)
+        print(f"Started Docker container with command: {server_cmd_str}")
+        ports = {80: port}
+        volumes = None
+        if self.fastled_src_dir:
+            print(
+                f"Mounting FastLED source directory {self.fastled_src_dir} into container /host/fastled/src"
+            )
+            volumes = {
+                str(self.fastled_src_dir): {"bind": "/host/fastled/src", "mode": "ro"}
+            }
+
+        cmd_str = subprocess.list2cmdline(server_command)
+
+        self.docker.run_container(
+            image_name=_IMAGE_NAME,
+            tag="main",
+            container_name=self.container_name,
+            command=cmd_str,
+            ports=ports,
+            volumes=volumes,
+        )
+        self.running_container = self.docker.attach_and_run(self.container_name)
+        assert self.running_container is not None, "Container should be running"
+
+        print("Compile server starting")
+        return port
+
+    def proceess_running(self) -> bool:
+        return self.docker.is_container_running(self.container_name)
+
+    def stop(self) -> None:
+        # print(f"Stopping server on port {self._port}")
+        if self.running_container:
+            self.running_container.stop()
+        self.docker.suspend_container(self.container_name)
+        print("Compile server stopped")