discstation 0.1.22 → 0.1.26

package/src/discstation.py

@@ -114,9 +114,87 @@ class VirtualSerial:
         pass
 
 
+class TcpSerial:
+    """serial.Serial look-alike over a TCP socket to the ESP32's Wi-Fi link
+    (firmware's WiFiServer on port 2323). Exposes the same tiny surface
+    station_loop and the flow functions use - write / readline / in_waiting /
+    read / close / setDTR - so nothing downstream knows it isn't a wire.
+    A dead link raises serial.SerialException from in_waiting/write, which is
+    what check_serial_alive() / main()'s reconnect loop already expect."""
+
+    def __init__(self, host, port=2323, connect_timeout=5):
+        if host.count(":") == 1 and not host.startswith("["):  # "ip:port"
+            host, _, p = host.rpartition(":")
+            if p.isdigit():
+                port = int(p)
+        self._sock = socket.create_connection((host, port), timeout=connect_timeout)
+        self._sock.settimeout(0.05)
+        self._buf = b""
+        self._lock = threading.Lock()
+        self._alive = True
+        self._reader = threading.Thread(target=self._pump, daemon=True)
+        self._reader.start()
+
+    def _pump(self):
+        while self._alive:
+            try:
+                chunk = self._sock.recv(4096)
+            except socket.timeout:
+                continue
+            except OSError:
+                break
+            if not chunk:
+                break
+            with self._lock:
+                self._buf += chunk
+        self._alive = False
+
+    @property
+    def in_waiting(self):
+        if not self._alive:
+            raise serial.SerialException("Wi-Fi remote link closed")
+        with self._lock:
+            return len(self._buf)
+
+    def read(self, n=1):
+        with self._lock:
+            data, self._buf = self._buf[:n], self._buf[n:]
+            return data
+
+    def readline(self):
+        with self._lock:
+            idx = self._buf.find(b"\n")
+            if idx < 0:
+                data, self._buf = self._buf, b""
+                return data
+            line, self._buf = self._buf[:idx + 1], self._buf[idx + 1:]
+            return line
+
+    def write(self, data):
+        if not self._alive:
+            raise serial.SerialException("Wi-Fi remote link closed")
+        try:
+            self._sock.sendall(data)
+            return len(data) if data else 0
+        except OSError as e:
+            self._alive = False
+            raise serial.SerialException(f"Wi-Fi remote write failed: {e}") from e
+
+    def close(self):
+        self._alive = False
+        try:
+            self._sock.close()
+        except OSError:
+            pass
+
+    def setDTR(self, value):
+        pass
+
+
 class _HardwareAttached(Exception):
-    """Raised out of station_loop when a real ESP32 appears while running on
-    a VirtualSerial, so main() can hand control over to it."""
+    """Raised out of station_loop when a real link (USB serial or the Wi-Fi
+    remote) appears while running on a VirtualSerial, so main() can hand
+    control over to it."""
 
 
 class _WebHandler(http.server.BaseHTTPRequestHandler):
@@ -825,7 +903,12 @@ _line_buf = b""
 def read_serial_line(ser, timeout=0.1):
     global _line_buf
     deadline = time.monotonic() + timeout
-    while time.monotonic() < deadline:
+    # Always make at least one non-blocking pass, even for timeout<=0 - the
+    # `remaining <= 0: break` at the bottom still ends it after that pass.
+    # (`while time.monotonic() < deadline` used to skip the body entirely for
+    # timeout=0, which is exactly how _check_cancel() calls this - so cancel
+    # detection during rips silently never read the port.)
+    while True:
         if _line_buf:
             _line_buf = _line_buf.lstrip(b'\r\n')
             if _line_buf:
@@ -870,6 +953,10 @@ def read_serial_line(ser, timeout=0.1):
     return None
 
 
+# Let the burn pipeline's check_cancel() share this buffered reader.
+discstation_burn.line_reader = read_serial_line
+
+
 def check_serial_alive(ser=None):
     """Raise serial.SerialException if the ESP32 link looks dead, so main()'s
     reconnect loop can re-scan for the (possibly renumbered) serial port.
@@ -2526,6 +2613,15 @@ def _check_cancel(ser):
         return False
 
 
+def _raise_if_cancelled(ser):
+    """Poll for a CANCEL press between blocking phases that have no
+    subprocess loop of their own (metadata lookups, scans, cover-art
+    downloads). Doesn't interrupt a call in progress, but catches the press
+    the moment the phase returns."""
+    if _check_cancel(ser):
+        raise CancelError
+
+
 def iter_process_events(proc, idle_seconds=1.0, ser=None):
     lines = Queue()
     finished = object()
@@ -3221,7 +3317,13 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
         except Exception:
             pass
 
-    proc = subprocess.Popen(run_as_desktop_user(cmd), env=env)
+    # Discard mpv's own output. Its terminal status line ("A: 00:04 / 00:15
+    # ...") prints several times a second; left inheriting our stdout it
+    # floods journald until the pipe backs up and our own print()/status
+    # writes block, wedging the whole play loop. We drive mpv over the IPC
+    # socket, so none of that output is wanted.
+    proc = subprocess.Popen(run_as_desktop_user(cmd), env=env,
+                            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
     try:
         if not wait_for_socket(MPV_SOCKET, proc):
@@ -3275,7 +3377,10 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
                     mpv_command(["set_property", "speed", 1.0])
                     send(ser, "PLAY_STATUS:PAUSED" if paused else "PLAY_STATUS:PLAYING")
 
-                elif line == "PLAY_STOP":
+                elif line in ("PLAY_STOP", "EJECT"):
+                    # EJECT during playback = stop first; the web remote has no
+                    # separate stop button, and without this the command is
+                    # silently dropped here and playback never ends.
                     send(ser, "STATUS:Stopping play")
                     discstation_burn.stop_process(proc)
                     break
@@ -3760,7 +3865,10 @@ def rip_flow(ser, artist_hint=None, album_hint=None):
         time.sleep(3)
         return
 
+    _raise_if_cancelled(ser)
+    send(ser, "STATUS:Scanning disc...")
     scan = handbrake_scan(device)
+    _raise_if_cancelled(ser)
     if scan:
         main = scan["main_feature"]
         mins = next((t["duration_s"] // 60 for t in scan["titles"] if t["index"] == main), 0)
@@ -3863,6 +3971,7 @@ def rip_video_disc(ser, device, kind):
             raise RuntimeError("No video files found")
 
         for index, src in enumerate(files, start=1):
+            _raise_if_cancelled(ser)
             send(ser, f"PROGRESS:File {index}/{len(files)}")
             dest = out_dir / f"{index:02d} - {safe_path_name(src.stem)}.mpg"
             print(f"Ripping {src.name} -> {dest.name}")
@@ -3923,6 +4032,7 @@ def _rip_audio_cd_macos(ser, device, chapters, metadata, cover_path, out_dir):
     if len(wav_files) < len(chapters):
         raise RuntimeError(f"Only ripped {len(wav_files)}/{len(chapters)} tracks")
     for index, wav in enumerate(wav_files[:len(chapters)], start=1):
+        _raise_if_cancelled(ser)
         chapter = chapters[index - 1]
         if metadata and index <= len(metadata["tracks"]):
             track_meta = metadata["tracks"][index - 1]
@@ -3958,8 +4068,10 @@ def rip_audio_cd(ser, device, artist_hint=None, album_hint=None):
     metadata = None
     cover_path = None
 
+    _raise_if_cancelled(ser)
     send(ser, "STATUS:Looking up CD...")
     metadata = audio_metadata_lookup(device, len(chapters), artist_hint, album_hint)
+    _raise_if_cancelled(ser)
 
     if metadata:
         album_folder = safe_path_name(f"{metadata['album_artist']} - {metadata['album']}")
@@ -3978,6 +4090,7 @@ def rip_audio_cd(ser, device, artist_hint=None, album_hint=None):
             out_dir,
             metadata.get("release_group_id"),
         )
+        _raise_if_cancelled(ser)
 
     send(ser, "STATUS:Ripping audio CD")
     if metadata:
@@ -4222,14 +4335,15 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
             last_ping = now
             safe_send(ser, "PING")
             if isinstance(ser, VirtualSerial):
-                # Safe point (no flow active) to check whether a real ESP32
-                # has appeared - hand off to it instead of the web remote.
+                # Safe point (no flow active) to check whether a real link -
+                # USB serial or the Wi-Fi remote - has appeared, and hand off
+                # to it instead of the web remote.
                 try:
-                    port = discstation_host.serial_port()
+                    link = discstation_host.serial_port() or discstation_host.remote_host()
                 except Exception:
-                    port = None
-                if port:
-                    raise _HardwareAttached(port)
+                    link = None
+                if link:
+                    raise _HardwareAttached(link)
             else:
                 check_serial_alive(ser)
 
@@ -4348,6 +4462,11 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
 
         except KeyboardInterrupt:
             raise
+        except CancelError:
+            safe_send(ser, "CANCELLED:Cancelled")
+            _last_burn_result = "Cancelled"
+            print(f"{mode} cancelled by user")
+            time.sleep(2)
         except Exception as e:
             safe_send(ser, f"ERROR:{str(e)[:50]}")
             _last_burn_result = f"ERROR: {e}"
@@ -4433,6 +4552,9 @@ def main():
         while True:
             try:
                 _line_buf = b""
+                ser = None
+
+                # 1. USB serial wins whenever it's present (no mDNS scan then).
                 port = discstation_host.serial_port()
                 if port:
                     print(f"Using ESP32 serial port: {port}")
@@ -4444,10 +4566,23 @@ def main():
                     time.sleep(2)
                     discstation_burn.reset_serial_state()
                     _appliance_mode = "hardware"
-                else:
-                    # No ESP32 found - run fully useful off the on-screen web
-                    # remote instead of retrying forever (station_loop already
-                    # publishes status via status_sink regardless of ser).
+
+                # 2. Else look for a Wi-Fi remote (DISC_REMOTE_HOST, default auto/mDNS).
+                if ser is None:
+                    remote = discstation_host.remote_host()
+                    if remote:
+                        try:
+                            print(f"Connecting to Wi-Fi remote at {remote}:2323 ...")
+                            ser = TcpSerial(remote)
+                            discstation_burn.reset_serial_state()
+                            _appliance_mode = "hardware"
+                            print(f"Wi-Fi remote link up ({remote}).")
+                        except OSError as e:
+                            print(f"Wi-Fi remote {remote} unreachable ({e}); using web remote.")
+                            ser = None
+
+                # 3. Else the on-screen web/app remote is the control surface.
+                if ser is None:
                     print("No ESP32 found - running in software-only mode (web remote).")
                     ser = VirtualSerial()
                     _appliance_mode = "software"

package/src/discstation_burn.py

@@ -192,6 +192,9 @@ BAUD   = 115200
 
 def check_cancel(ser):
     try:
+        if line_reader is not None:
+            line = line_reader(ser, 0)
+            return bool(line) and line in ("CANCEL", "PLAY_STOP")
         if ser and ser.in_waiting:
             line = ser.readline().decode(errors="ignore").strip()
             note_serial_activity()
@@ -517,6 +520,12 @@ def detect_disc_type(device):
 # pipeline emits also updates the web/SSE status in real time.
 status_sink = None
 
+# discstation.py sets this to its buffered read_serial_line so check_cancel
+# reads the same way station_loop does (partial lines get buffered and
+# reassembled). A bare ser.readline() here can slice a "CANCEL\n" in half
+# on a mid-transmission read and then never match it.
+line_reader = None
+
 
 def send(ser, msg):
     global _serial_write_failed

package/src/discstation_host.py

@@ -8,9 +8,11 @@ import os
 import platform
 import re
 import shutil
+import socket
 import subprocess
 import sys
 import threading
+import time
 from pathlib import Path
 
 from serial.tools import list_ports
@@ -67,6 +69,77 @@ def serial_port():
     return _stable_serial_path(sorted(preferred)[0])
 
 
+_REMOTE_MDNS_TYPE = "_discstation._tcp.local."
+_REMOTE_DEFAULT_HOST = "discstation.local"
+_remote_cache = {"at": 0.0, "value": None}
+
+
+def remote_host():
+    """Address of the Wi-Fi appliance remote, or None.
+
+    `DISC_REMOTE_HOST` unset / `auto` (default) -> mDNS browse for the
+        firmware's `_discstation._tcp` advert, falling back to resolving
+        `discstation.local` via the OS resolver. Result cached ~60s so the
+        reconnect loop / hot-swap poll don't hammer mDNS.
+    `DISC_REMOTE_HOST=<ip|host>`  -> that address, verbatim, instantly.
+    `DISC_REMOTE_HOST=off` / `none` / `0`  -> None (never look; USB / web only).
+
+    Only consulted by main() when no USB serial is present. Best-effort -
+    main() tries to connect and falls back on failure."""
+    setting = (os.environ.get("DISC_REMOTE_HOST") or "").strip().lower()
+    if setting in ("off", "none", "no", "false", "0", "disabled"):
+        return None
+    if setting and setting != "auto":
+        return (os.environ.get("DISC_REMOTE_HOST") or "").strip()
+
+    if time.time() - _remote_cache["at"] < 60:
+        return _remote_cache["value"]
+
+    value = _discover_remote()
+    _remote_cache["at"] = time.time()
+    _remote_cache["value"] = value
+    return value
+
+
+def _discover_remote():
+    try:
+        from zeroconf import Zeroconf, ServiceBrowser
+    except ImportError:
+        Zeroconf = None
+    if Zeroconf is not None:
+        found = {}
+
+        class _Listener:
+            def add_service(self, zc, type_, name):
+                info = zc.get_service_info(type_, name, timeout=1500)
+                if info:
+                    for addr in info.parsed_addresses():
+                        if "." in addr:  # IPv4
+                            found["addr"] = addr
+                            return
+
+            update_service = add_service
+
+            def remove_service(self, *a):
+                pass
+
+        zc = Zeroconf()
+        try:
+            ServiceBrowser(zc, _REMOTE_MDNS_TYPE, _Listener())
+            deadline = time.time() + 2.5
+            while time.time() < deadline and "addr" not in found:
+                time.sleep(0.1)
+        finally:
+            zc.close()
+        if found.get("addr"):
+            return found["addr"]
+
+    try:
+        return socket.gethostbyname(_REMOTE_DEFAULT_HOST)
+    except OSError:
+        return None
+
+
 def _stable_serial_path(device):
     """Map a volatile /dev/ttyUSBN to its stable /dev/serial/by-id/ symlink so a
     USB re-enumeration (ttyUSB1 -> ttyUSB0) doesn't strand the reconnect loop."""