embedded-lab-control 0.2.0__py3-none-any.whl

labctl/web/views.py

@@ -0,0 +1,496 @@
+"""
+Web views for lab controller dashboard.
+"""
+
+from flask import (
+    Blueprint,
+    Response,
+    current_app,
+    flash,
+    g,
+    redirect,
+    render_template,
+    stream_with_context,
+    url_for,
+)
+
+from labctl.actuators.runtime import power_cycle_with_bindings, power_on_with_bindings
+from labctl.core.models import AddressType, PlugType, PortType, Status
+from labctl.power import PowerController, PowerState
+from labctl.web import claims
+from labctl.web.api import (
+    begin_power_cycle,
+    end_power_cycle,
+    outlet_cycle_in_progress,
+)
+
+views_bp = Blueprint("views", __name__)
+
+
+@views_bp.route("/")
+def index():
+    """Dashboard home page."""
+    sbcs = g.manager.list_sbcs()
+
+    # Get power states for SBCs with plugs
+    power_states = {}
+    for sbc in sbcs:
+        if sbc.power_plug:
+            try:
+                controller = PowerController.from_plug(sbc.power_plug)
+                power_states[sbc.name] = controller.get_state()
+            except Exception:
+                power_states[sbc.name] = PowerState.UNKNOWN
+
+    # Index active claims by SBC name for dashboard badges
+    claims_by_sbc = {c.sbc_name: c for c in g.manager.list_active_claims()}
+
+    return render_template(
+        "dashboard.html",
+        sbcs=sbcs,
+        power_states=power_states,
+        claims_by_sbc=claims_by_sbc,
+        PowerState=PowerState,
+    )
+
+
+@views_bp.route("/sbc/<name>")
+def sbc_detail(name: str):
+    """SBC detail page."""
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    power_state = None
+    if sbc.power_plug:
+        try:
+            controller = PowerController.from_plug(sbc.power_plug)
+            power_state = controller.get_state()
+        except Exception:
+            power_state = PowerState.UNKNOWN
+
+    # Load active claim for this SBC
+    active_claim = g.manager.get_active_claim(sbc.name)
+
+    return render_template(
+        "sbc_detail.html",
+        sbc=sbc,
+        power_state=power_state,
+        active_claim=active_claim,
+        PowerState=PowerState,
+        Status=Status,
+        PortType=PortType,
+        AddressType=AddressType,
+        PlugType=PlugType,
+    )
+
+
+@views_bp.route("/sbc/<name>/power/<action>", methods=["POST"])
+def sbc_power_action(name: str, action: str):
+    """Handle power control actions."""
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    if not sbc.power_plug:
+        flash("No power plug assigned", "error")
+        return redirect(url_for("views.sbc_detail", name=name))
+
+    if action not in ("on", "off", "cycle"):
+        flash(f"Unknown action: {action}", "error")
+        return redirect(url_for("views.sbc_detail", name=name))
+
+    refusal = claims.check(name)
+    if refusal:
+        return claims.refusal_page(refusal, name)
+
+    # Same guards as REST: one cycle of an outlet at a time, rate-limited,
+    # and no on/off of an outlet while it is being cycled.
+    if action == "cycle":
+        busy = begin_power_cycle(sbc)
+        if busy:
+            flash(f"Error: {busy}", "error")
+            return redirect(url_for("views.sbc_detail", name=name))
+    elif outlet_cycle_in_progress(sbc):
+        flash(
+            f"Error: a power cycle of {name!r}'s power outlet is in progress; "
+            "retry when it has finished",
+            "error",
+        )
+        return redirect(url_for("views.sbc_detail", name=name))
+
+    success = False
+    try:
+        controller = PowerController.from_plug(sbc.power_plug)
+
+        if action == "on":
+            success = power_on_with_bindings(g.manager, sbc, controller)
+            msg = "Power ON" if success else "Failed to power on"
+        elif action == "off":
+            success = controller.power_off()
+            msg = "Power OFF" if success else "Failed to power off"
+        else:
+            success = power_cycle_with_bindings(g.manager, sbc, controller)
+            msg = "Power cycled" if success else "Failed to power cycle"
+
+        flash(msg, "success" if success else "error")
+    except Exception as e:
+        flash(f"Error: {e}", "error")
+    finally:
+        if action == "cycle":
+            end_power_cycle(sbc, success)
+
+    return redirect(url_for("views.sbc_detail", name=name))
+
+
+@views_bp.route("/sbc/<name>/console")
+def sbc_console(name: str):
+    """SBC console page with xterm.js terminal."""
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    # Find console port
+    port = sbc.console_port
+
+    return render_template(
+        "console.html",
+        sbc=sbc,
+        port=port,
+    )
+
+
+@views_bp.route("/sbc/<name>/history")
+def sbc_history(name: str):
+    """SBC status history page."""
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    # Get status history
+    history = g.manager.get_status_history(sbc_id=sbc.id, limit=100)
+
+    return render_template(
+        "status_history.html",
+        sbc=sbc,
+        history=history,
+        Status=Status,
+    )
+
+
+@views_bp.route("/sbc/<name>/edit", methods=["POST"])
+def sbc_edit(name: str):
+    """Handle SBC edit form."""
+    from flask import request
+
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    new_name = request.form.get("name", "").strip() or None
+    project = request.form.get("project", "").strip() or None
+    description = request.form.get("description", "").strip() or None
+    ssh_user = request.form.get("ssh_user", "").strip() or "root"
+    status = request.form.get("status", "").strip()
+
+    status_enum = Status(status) if status else None
+
+    refusal = claims.check(name, shared=False)
+    if refusal:
+        return claims.refusal_page(refusal, name)
+
+    # Only pass new_name if it actually changed
+    rename = new_name if new_name and new_name != name else None
+
+    g.manager.update_sbc(
+        sbc.id,
+        name=rename,
+        project=project,
+        description=description,
+        ssh_user=ssh_user,
+        status=status_enum,
+    )
+
+    display_name = rename or name
+    flash(f"Updated SBC '{display_name}'", "success")
+    return redirect(url_for("views.sbc_detail", name=display_name))
+
+
+@views_bp.route("/sbc/<name>/port/assign", methods=["POST"])
+def sbc_port_assign(name: str):
+    """Handle port assignment form."""
+    from flask import request
+
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    port_type = request.form.get("port_type", "").strip()
+    alias = request.form.get("alias", "").strip() or None
+    device = request.form.get("device", "").strip()
+    tcp_port = request.form.get("tcp_port", "").strip()
+    baud_rate = request.form.get("baud_rate", "115200").strip()
+
+    if not port_type or not device:
+        flash("Port type and device are required", "error")
+        return redirect(url_for("views.sbc_detail", name=name))
+
+    # The boards already wired to this console are checked too: otherwise
+    # a claimed board's console could be typed into through this one.
+    refusal = claims.check(
+        name,
+        shared=False,
+        sharers=dict(
+            serial_device_path=device,
+            tcp_port=claims.port_number(tcp_port),
+        ),
+    )
+    if refusal:
+        return claims.refusal_page(refusal, name)
+
+    try:
+        g.manager.assign_serial_port(
+            sbc_id=sbc.id,
+            port_type=PortType(port_type),
+            device_path=device,
+            tcp_port=int(tcp_port) if tcp_port else None,
+            baud_rate=int(baud_rate),
+            alias=alias,
+        )
+        flash(f"Assigned {port_type} port", "success")
+    except Exception as e:
+        flash(f"Error: {e}", "error")
+
+    return redirect(url_for("views.sbc_detail", name=name))
+
+
+@views_bp.route("/sbc/<name>/port/remove/<port_type>", methods=["POST"])
+def sbc_port_remove(name: str, port_type: str):
+    """Remove port assignment."""
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    refusal = claims.check(name, shared=False)
+    if refusal:
+        return claims.refusal_page(refusal, name)
+
+    if g.manager.remove_serial_port(sbc.id, PortType(port_type)):
+        flash(f"Removed {port_type} port", "success")
+    else:
+        flash(f"No {port_type} port to remove", "error")
+
+    return redirect(url_for("views.sbc_detail", name=name))
+
+
+@views_bp.route("/sbc/<name>/network/set", methods=["POST"])
+def sbc_network_set(name: str):
+    """Handle network address form."""
+    from flask import request
+
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    address_type = request.form.get("address_type", "").strip()
+    ip_address = request.form.get("ip_address", "").strip()
+    mac_address = request.form.get("mac_address", "").strip() or None
+    hostname = request.form.get("hostname", "").strip() or None
+
+    if not address_type or not ip_address:
+        flash("Address type and IP are required", "error")
+        return redirect(url_for("views.sbc_detail", name=name))
+
+    refusal = claims.check(name, shared=False)
+    if refusal:
+        return claims.refusal_page(refusal, name)
+
+    try:
+        g.manager.set_network_address(
+            sbc_id=sbc.id,
+            address_type=AddressType(address_type),
+            ip_address=ip_address,
+            mac_address=mac_address,
+            hostname=hostname,
+        )
+        flash(f"Set {address_type} address", "success")
+    except Exception as e:
+        flash(f"Error: {e}", "error")
+
+    return redirect(url_for("views.sbc_detail", name=name))
+
+
+@views_bp.route("/sbc/<name>/network/remove/<address_type>", methods=["POST"])
+def sbc_network_remove(name: str, address_type: str):
+    """Remove network address."""
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    refusal = claims.check(name, shared=False)
+    if refusal:
+        return claims.refusal_page(refusal, name)
+
+    if g.manager.remove_network_address(sbc.id, AddressType(address_type)):
+        flash(f"Removed {address_type} address", "success")
+    else:
+        flash(f"No {address_type} address to remove", "error")
+
+    return redirect(url_for("views.sbc_detail", name=name))
+
+
+@views_bp.route("/sbc/<name>/plug/assign", methods=["POST"])
+def sbc_plug_assign(name: str):
+    """Handle power plug assignment form."""
+    from flask import request
+
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    plug_type = request.form.get("plug_type", "").strip()
+    address = request.form.get("address", "").strip()
+    plug_index = request.form.get("plug_index", "1").strip()
+
+    if not plug_type or not address:
+        flash("Plug type and address are required", "error")
+        return redirect(url_for("views.sbc_detail", name=name))
+
+    # Outlets are numbered from 1; index 0 addresses every outlet on a
+    # Tasmota device at once.
+    if claims.port_number(plug_index) is None:
+        flash("Plug index must be a whole number from 1 to 65535", "error")
+        return redirect(url_for("views.sbc_detail", name=name))
+    try:
+        plug_type_enum = PlugType(plug_type)
+    except ValueError:
+        flash(f"Unknown plug type: {plug_type}", "error")
+        return redirect(url_for("views.sbc_detail", name=name))
+
+    # The boards already on this outlet are checked too: otherwise a
+    # claimed board could be powered through this one.
+    refusal = claims.check(
+        name,
+        shared=False,
+        sharers=dict(plug=(plug_type_enum.value, address, int(plug_index))),
+    )
+    if refusal:
+        return claims.refusal_page(refusal, name)
+
+    try:
+        g.manager.assign_power_plug(
+            sbc_id=sbc.id,
+            plug_type=plug_type_enum,
+            address=address,
+            plug_index=int(plug_index),
+        )
+        flash(f"Assigned {plug_type} plug", "success")
+    except Exception as e:
+        flash(f"Error: {e}", "error")
+
+    return redirect(url_for("views.sbc_detail", name=name))
+
+
+@views_bp.route("/sbc/<name>/plug/remove", methods=["POST"])
+def sbc_plug_remove(name: str):
+    """Remove power plug assignment."""
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    refusal = claims.check(name, shared=False)
+    if refusal:
+        return claims.refusal_page(refusal, name)
+
+    if g.manager.remove_power_plug(sbc.id):
+        flash("Removed power plug", "success")
+    else:
+        flash("No power plug to remove", "error")
+
+    return redirect(url_for("views.sbc_detail", name=name))
+
+
+@views_bp.route("/sbc/<name>/claim/force-release", methods=["POST"])
+def sbc_force_release(name: str):
+    """Force-release a claim from the web dashboard."""
+    from flask import request as flask_request
+
+    from labctl.core.models import ClaimNotFoundError
+
+    sbc = g.manager.get_sbc_by_name(name)
+    if not sbc:
+        flash(f"SBC '{name}' not found", "error")
+        return redirect(url_for("views.index"))
+
+    if not claims.web_actor().operator:
+        flash(
+            "Only operators may force-release a claim; your user has role 'agent'.",
+            "error",
+        )
+        return redirect(url_for("views.sbc_detail", name=name))
+
+    reason = flask_request.form.get("reason", "force-released via web dashboard")
+    try:
+        g.manager.force_release_claim(name, reason, released_by=claims.web_user_name())
+        flash(f"Force-released claim on '{name}'", "success")
+    except ClaimNotFoundError:
+        flash(f"No active claim on '{name}'", "error")
+
+    return redirect(url_for("views.sbc_detail", name=name))
+
+
+@views_bp.route("/settings")
+def settings():
+    """Settings page."""
+    from flask import current_app
+
+    config = current_app.config.get("LABCTL_CONFIG")
+
+    return render_template(
+        "settings.html",
+        config=config,
+    )
+
+
+@views_bp.route("/activity")
+def activity():
+    """Live activity-stream page."""
+    broadcaster = current_app.config.get("ACTIVITY_BROADCASTER")
+    initial = broadcaster.recent() if broadcaster else []
+    return render_template(
+        "activity.html",
+        initial_events=[e.to_dict() for e in initial],
+    )
+
+
+@views_bp.route("/activity/stream")
+def activity_stream():
+    """Server-Sent Events feed of live activity events.
+
+    Sends a one-shot hydration of the last N events, then live events
+    as they arrive. Keeps alive with a comment-only frame every 15s.
+    """
+    from labctl.web.activity_broadcaster import iter_sse_frames
+
+    broadcaster = current_app.config.get("ACTIVITY_BROADCASTER")
+    if broadcaster is None:
+        return Response("Activity broadcaster not initialized", status=503)
+
+    response = Response(
+        stream_with_context(iter_sse_frames(broadcaster)),
+        mimetype="text/event-stream",
+    )
+    response.headers["Cache-Control"] = "no-cache"
+    response.headers["X-Accel-Buffering"] = "no"  # disable nginx buffering
+    return response

labctl/web/websocket.py

@@ -0,0 +1,208 @@
+"""
+WebSocket bridge for serial console in web interface.
+
+Bridges between browser WebSocket and serial proxy TCP connection.
+"""
+
+import asyncio
+import logging
+from typing import Optional
+
+from flask import g, request
+from flask_socketio import SocketIO, emit, join_room, leave_room
+
+logger = logging.getLogger(__name__)
+
+# SocketIO instance - initialized in init_socketio()
+socketio: Optional[SocketIO] = None
+
+# Active console connections: {sid: {sbc_name, reader_task, writer}}
+active_connections: dict = {}
+
+
+def init_socketio(app, **kwargs):
+    """Initialize SocketIO with Flask app."""
+    global socketio
+    socketio = SocketIO(app, **kwargs)
+    register_handlers(socketio)
+    return socketio
+
+
+def register_handlers(sio: SocketIO):
+    """Register SocketIO event handlers."""
+
+    @sio.on("connect", namespace="/console")
+    def handle_connect():
+        """Handle new WebSocket connection."""
+        logger.info(f"WebSocket client connected: {request.sid}")
+
+    @sio.on("disconnect", namespace="/console")
+    def handle_disconnect():
+        """Handle WebSocket disconnection."""
+        sid = request.sid
+        logger.info(f"WebSocket client disconnected: {sid}")
+
+        # Clean up any active console connection
+        if sid in active_connections:
+            conn = active_connections.pop(sid)
+            if "reader_task" in conn and conn["reader_task"]:
+                conn["reader_task"].cancel()
+            if "writer" in conn and conn["writer"]:
+                try:
+                    conn["writer"].close()
+                except Exception:
+                    pass
+
+    @sio.on("open_console", namespace="/console")
+    def handle_open_console(data):
+        """Open console connection to SBC.
+
+        Expected data: {"sbc_name": "sbc1"}
+        """
+        sid = request.sid
+        sbc_name = data.get("sbc_name")
+
+        if not sbc_name:
+            emit("error", {"message": "sbc_name required"})
+            return
+
+        # Get SBC info
+        manager = g.manager
+        sbc = manager.get_sbc_by_name(sbc_name)
+
+        if not sbc:
+            emit("error", {"message": f"SBC '{sbc_name}' not found"})
+            return
+
+        console_port = sbc.console_port
+        if not console_port or not console_port.tcp_port:
+            emit("error", {"message": "No console port configured"})
+            return
+
+        # Join room for this SBC
+        join_room(sbc_name)
+
+        # Store connection info
+        active_connections[sid] = {
+            "sbc_name": sbc_name,
+            "tcp_port": console_port.tcp_port,
+            "reader_task": None,
+            "writer": None,
+        }
+
+        emit(
+            "console_opened",
+            {
+                "sbc_name": sbc_name,
+                "message": f"Connected to {sbc_name} console",
+            },
+        )
+
+        # Start async reader in background
+        # Note: This is simplified - in production, use a proper async bridge
+        logger.info(f"Console opened for {sbc_name} by {sid}")
+
+    @sio.on("console_input", namespace="/console")
+    def handle_console_input(data):
+        """Handle input from browser to send to console.
+
+        Expected data: {"text": "ls -la\n"}
+        """
+        sid = request.sid
+
+        if sid not in active_connections:
+            emit("error", {"message": "Console not opened"})
+            return
+
+        conn = active_connections[sid]
+        text = data.get("text", "")
+
+        if not text:
+            return
+
+        # Send to console via proxy
+        # Note: Actual implementation would write to TCP socket
+        logger.debug(f"Console input from {sid}: {repr(text)}")
+
+        # Echo back for now (in production, this comes from the serial device)
+        emit("console_output", {"text": text}, room=conn["sbc_name"])
+
+    @sio.on("close_console", namespace="/console")
+    def handle_close_console():
+        """Close console connection."""
+        sid = request.sid
+
+        if sid in active_connections:
+            conn = active_connections.pop(sid)
+            leave_room(conn["sbc_name"])
+            emit("console_closed", {"message": "Console closed"})
+            logger.info(f"Console closed for {conn['sbc_name']} by {sid}")
+
+
+class ConsoleWebSocketBridge:
+    """
+    Bridge between WebSocket and TCP proxy.
+
+    This class handles the async bridging between Flask-SocketIO
+    and the asyncio-based serial proxy.
+    """
+
+    def __init__(self, sio: SocketIO, sid: str, sbc_name: str, proxy_port: int):
+        self.sio = sio
+        self.sid = sid
+        self.sbc_name = sbc_name
+        self.proxy_port = proxy_port
+        self._reader: Optional[asyncio.StreamReader] = None
+        self._writer: Optional[asyncio.StreamWriter] = None
+        self._running = False
+
+    async def connect(self) -> bool:
+        """Connect to proxy TCP port."""
+        try:
+            self._reader, self._writer = await asyncio.open_connection(
+                "localhost", self.proxy_port
+            )
+            self._running = True
+            return True
+        except Exception as e:
+            logger.error(f"Failed to connect to proxy: {e}")
+            return False
+
+    async def disconnect(self):
+        """Disconnect from proxy."""
+        self._running = False
+        if self._writer:
+            self._writer.close()
+            try:
+                await self._writer.wait_closed()
+            except Exception:
+                pass
+
+    async def send_to_console(self, data: str):
+        """Send data to console."""
+        if self._writer and self._running:
+            self._writer.write(data.encode())
+            await self._writer.drain()
+
+    async def read_loop(self):
+        """Read from console and emit to WebSocket."""
+        while self._running and self._reader:
+            try:
+                data = await asyncio.wait_for(self._reader.read(4096), timeout=1.0)
+                if not data:
+                    break
+
+                # Emit to WebSocket
+                self.sio.emit(
+                    "console_output",
+                    {"text": data.decode("utf-8", errors="replace")},
+                    namespace="/console",
+                    room=self.sbc_name,
+                )
+            except asyncio.TimeoutError:
+                continue
+            except Exception as e:
+                logger.error(f"Console read error: {e}")
+                break
+
+        self._running = False