mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/wda/watchdog.py

@@ -0,0 +1,243 @@
+"""A watchdog for a wedged WebDriverAgent runner or relay, and the record of actions in flight.
+
+``DeviceManager.probe`` feeds it one result per probe (``GET /wda/locked``, bounded at 3 s). After
+FAILURES_TO_WEDGE failures in a row the phone is ``wedged``; once it has stayed wedged for WEDGED_RESTART_SECONDS the
+watchdog restarts the runner, subject to the rules below. They are the safety case, and tests/test_wda_watchdog.py
+has one test for each:
+
+1. **An action in flight is never re-sent, and never restarted under.** ``ActionTracker`` records every WDA action
+   (tap, swipe, key, button, element value, app activate) from just before it is sent until it answers or fails.
+   A restart waits while one is in flight (``admit_restart`` checks that, the unknown outcomes and the task, and blocks,
+   in one step). When one ends without an answer its outcome is *unknown*: it is
+   recorded, the transport never replays it (transport.HTTP), the effect ledger keeps blocking the same effect
+   (effect_ledger.py), and the run ends or goes on from a fresh look. The watchdog sends nothing.
+2. **While a restart runs, no new action leaves.** ``admit_restart``, ``run_started`` and ``begin`` share one lock: an
+action that starts
+   after the restart began is refused before it is sent ("nothing sent"), a known outcome.
+3. **A restart with a task running happens only between actions** (nothing in flight, no unknown outcome waiting to
+   be settled), never on a dead runner: a runner that is not running ends the run with a plain sentence instead
+   (``on_dead_runner``), because there is nothing to restart into a task safely.
+4. **Backoff, no storm.** The gap between restarts doubles for each restart in a row (MIN_RESTART_GAP, 2x, 4x...
+   up to MAX_RESTART_GAP), and resets after HEALTHY_SECONDS of passing probes.
+"""
+
+import threading
+import time
+
+from ..transport import NotSent
+from .timeouts import is_action
+
+FAILURES_TO_WEDGE = 3
+WEDGED_RESTART_SECONDS = 90.0
+MIN_RESTART_GAP = 180.0
+MAX_RESTART_GAP = 1800.0
+HEALTHY_SECONDS = 120.0
+
+DEAD_RUNNER = ("Mobster's helper on your iPhone stopped, so this task ended. No further action was taken. "
+               "Check that your iPhone is connected and unlocked, then run the task again.")
+
+
+class ActionBlocked(NotSent):
+    """An action refused before it was sent, because the runner is restarting. Nothing happened on the phone."""
+
+
+class ActionTracker:
+    UNKNOWN_KEPT = 20
+
+    def __init__(self, clock=time.time):
+        self.clock = clock
+        self.lock = threading.Lock()
+        self.flying = {}      # token -> (url, method, path, started, run_id)
+        self.unknown = {}     # url -> [(method, path, at, run_id)]
+        self.blocked = set()
+        self.runs = {}        # url -> run id of the task holding the phone
+        self.last_action = {}  # url -> when the last action was sent (wall clock)
+        self.next_token = 0
+
+    @staticmethod
+    def _key(url):
+        return (url or "").rstrip("/")
+
+    def run_started(self, url, run_id):
+        """A task takes the phone. Raises ActionBlocked while a restart runs: the start is refused, nothing sent."""
+        url = self._key(url)
+        with self.lock:
+            if url in self.blocked:
+                raise ActionBlocked("Mobster's helper is restarting; nothing sent")
+            self.runs[url] = run_id
+
+    def run_ended(self, url, run_id):
+        """The task is over: its journal holds what it left unknown, so the tracker forgets those outcomes."""
+        url = self._key(url)
+        with self.lock:
+            if self.runs.get(url) != run_id:
+                return  # a waiting or failed task cannot retire the actual holder's unknown outcome
+            self.runs.pop(url, None)
+            self.unknown.pop(url, None)
+
+    def has_run(self, url):
+        with self.lock:
+            return self._key(url) in self.runs
+
+    def begin(self, url, method, path):
+        """Record an action about to be sent; None for a read. Raises ActionBlocked while a restart runs."""
+        if not is_action(method, path):
+            return None
+        url = self._key(url)
+        with self.lock:
+            if url in self.blocked:
+                raise ActionBlocked("Mobster's helper is restarting; nothing sent")
+            self.next_token += 1
+            self.flying[self.next_token] = (url, method, path, self.clock(), self.runs.get(url))
+            self.last_action[url] = self.clock()
+            return self.next_token
+
+    def end(self, token, outcome="done"):
+        """outcome: "done" (answered), "not_sent" (refused before it left) or "unknown" (it left; no answer)."""
+        if token is None:
+            return
+        with self.lock:
+            entry = self.flying.pop(token, None)
+            if outcome == "unknown" and entry is not None:
+                url, method, path, _, run_id = entry
+                self.unknown.setdefault(url, []).append((method, path, self.clock(), run_id))
+                del self.unknown[url][:-self.UNKNOWN_KEPT]
+
+    def last_action_at(self, url):
+        with self.lock:
+            return self.last_action.get(self._key(url))
+
+    def in_flight(self, url):
+        url = self._key(url)
+        with self.lock:
+            return [(m, p) for u, m, p, *_ in self.flying.values() if u == url]
+
+    def unknown_outcomes(self, url):
+        with self.lock:
+            return [(m, p, at) for m, p, at, _ in self.unknown.get(self._key(url), ())]
+
+    def admit_restart(self, url):
+        """Decide and block in one step: None when new actions are now blocked, else why the restart may not go."""
+        url = self._key(url)
+        with self.lock:
+            if url in self.blocked:
+                return "restarting"
+            if any(u == url for u, *_ in self.flying.values()):
+                return "action_in_flight"
+            if url in self.runs and self.unknown.get(url):
+                return "unknown_outcome"
+            self.blocked.add(url)
+            return None
+
+    def unblock(self, url):
+        with self.lock:
+            self.blocked.discard(self._key(url))
+
+
+tracker = ActionTracker()
+
+
+def send(url, method, path, send_request):
+    """Run ``send_request()`` for a WDA request, recording it when it is an action. Never retries."""
+    token = tracker.begin(url, method, path)
+    try:
+        result = send_request()
+    except NotSent:
+        tracker.end(token, "not_sent")
+        raise
+    except Exception:
+        tracker.end(token, "unknown")
+        raise
+    tracker.end(token, "done")
+    return result
+
+
+class Watchdog:
+    def __init__(self, restart, *, url=lambda: None, busy=lambda: False, alive=lambda: True, on_dead_runner=None,
+                 actions=tracker, wall=time.time):
+        """``restart`` stops and starts the runner and relay; ``on_dead_runner(message)`` ends the running task."""
+        self.restart, self.url, self.busy, self.alive = restart, url, busy, alive
+        self.on_dead_runner, self.actions, self.wall = on_dead_runner, actions, wall
+        self.state, self.restarts, self.last_restart = "ok", 0, None
+        self.failures, self.wedged_since = 0, None
+        self.last_restart_at = None
+        self.streak = 0            # restarts in a row, for the backoff
+        self.healthy_since = None
+        self.deferred = None       # why the last restart did not happen: a short id
+
+    def probe_result(self, ok, now):
+        """One probe's result at monotonic time ``now``. Returns True when it restarted the runner."""
+        if ok:
+            self.failures, self.wedged_since, self.deferred = 0, None, None
+            if self.state != "restarting":
+                self.state = "ok"
+            if self.healthy_since is None:
+                self.healthy_since = now
+            elif now - self.healthy_since >= HEALTHY_SECONDS:
+                self.streak = 0
+            return False
+        self.healthy_since = None
+        self.failures += 1
+        if self.wedged_since is None:
+            self.wedged_since = now
+        if self.failures >= FAILURES_TO_WEDGE:
+            self.state = "wedged"
+        else:
+            return False
+        if now - self.wedged_since < WEDGED_RESTART_SECONDS:
+            return False
+        return self._try_restart(now)
+
+    def reset_failures(self):
+        """The runner is stopped on purpose or still starting: missed checks count for nothing."""
+        self.failures, self.wedged_since = 0, None
+        if self.state == "wedged":
+            self.state = "ok"
+
+    def gap(self):
+        return min(MAX_RESTART_GAP, MIN_RESTART_GAP * 2 ** max(0, self.streak - 1))
+
+    def admit(self, now):
+        """Every automatic restart asks here: None to go (actions blocked until ``done``), else why it must not."""
+        url = self.url()
+        if self.last_restart_at is not None and now - self.last_restart_at < self.gap():
+            return "backoff"
+        reason = self.actions.admit_restart(url)
+        if reason is not None:
+            return reason
+        self.state = "restarting"
+        self.last_restart_at = now
+        self.streak += 1
+        self.restarts += 1
+        self.last_restart = int(self.wall() * 1000)
+        self.failures, self.wedged_since = 0, None
+        return None
+
+    def done(self, ok=True):
+        self.actions.unblock(self.url())
+        self.state = "ok" if ok else "wedged"
+
+    def _try_restart(self, now):
+        url = self.url()
+        if not self.alive():
+            # Nothing to restart into: with a task running it ends the task with a plain sentence. Without one the
+            # supervisor's gated relaunch and autostart bring it back.
+            if (self.actions.has_run(url) or self.busy()) and callable(self.on_dead_runner):
+                self.deferred = "dead_runner_with_task"
+                self.on_dead_runner(DEAD_RUNNER)
+            return False
+        reason = self.admit(now)
+        if reason is not None:
+            self.deferred = reason
+            return False
+        self.deferred = None
+        try:
+            self.restart()
+        except Exception:  # noqa: BLE001 -- the next probes decide; backoff holds the next try
+            self.done(False)
+            return False
+        self.done(True)
+        return True
+
+    def snapshot(self):
+        return {"state": self.state, "restarts": self.restarts, "last_restart": self.last_restart}

mobile_agent/wireless/__init__.py

@@ -0,0 +1,15 @@
+"""Track `wireless`: Wi-Fi after one cable pairing, through Apple's encrypted CoreDevice tunnel (SPEC §3.7)."""
+
+import os
+
+# What an unset MOBSTER_WIFI_TRANSPORT means. This is the one line to flip, and only after `mobster wifi probe`
+# passes on a phone with its cable out (read_screen, launch_app, install_app and unlock_status over Wi-Fi too).
+DEFAULT_ON = False
+GATE = "MOBSTER_WIFI_TRANSPORT"
+ON_WORDS = ("1", "true", "yes", "on")
+OFF_WORDS = ("0", "false", "no", "off")
+
+
+def transport_on(env=None):
+    value = str((os.environ if env is None else env).get(GATE, "")).strip().lower()
+    return True if value in ON_WORDS else False if value in OFF_WORDS else DEFAULT_ON

mobile_agent/wireless/api.py

@@ -0,0 +1,354 @@
+"""Wi-Fi's HTTP routes (seam S3) and the monitor service (SPEC §3.7, API)."""
+
+import os
+import threading
+import time
+from urllib.parse import unquote
+
+from .. import api_routes
+from ..api_routes import Response, Route
+from . import GATE, result, store, switch, transport, transport_on, words
+from .monitor import Monitor, task_on
+
+# id(runtime) -> (runtime, Monitor): only for runtimes that manage USB phones, made when Wi-Fi for iPhones is on.
+_monitors = {}
+_monitors_lock = threading.Lock()
+# GET /api/wireless/network's last answer: (monotonic time, result). One check at a time; reused for NETWORK_FRESH s.
+NETWORK_FRESH = 15.0
+_network = {"at": None, "result": None}
+_network_lock = threading.Lock()
+# The Wi-Fi checks Add a device starts (POST /api/wireless/probe): UDID -> the running or last one. A check still
+# running after PROBE_SECONDS reads as timed out, and its late end changes nothing.
+PROBE_SECONDS = 180.0
+_probes = {}
+_probes_lock = threading.Lock()
+
+
+def _managed(runtime):
+    return getattr(runtime, "manager", None) is not None and getattr(runtime, "fleet", None) is not None
+
+
+# -- the service ----------------------------------------------------------------------------------------------------
+
+def start_service(runtime):
+    if _managed(runtime) and transport_on():
+        monitor_for(runtime, create=True).start()
+
+
+def close_service(runtime):
+    with _monitors_lock:
+        entry = _monitors.pop(id(runtime), None)
+    if entry is not None and entry[0] is runtime:
+        entry[1].stop()
+
+
+def monitor_for(runtime, create=False):
+    """The runtime's monitor; with ``create``, made when missing (a runtime that manages USB phones only)."""
+    with _monitors_lock:
+        entry = _monitors.get(id(runtime))
+        if entry is not None and entry[0] is runtime:
+            return entry[1]
+        if not create or not _managed(runtime):
+            return None
+        monitor = Monitor(runtime)
+        _monitors[id(runtime)] = (runtime, monitor)
+        return monitor
+
+
+# -- what a phone's Wi-Fi looks like ------------------------------------------------------------------------------
+
+def _phones(runtime):
+    return runtime.fleet.usb_managers() if _managed(runtime) else []
+
+
+def _name(phone, manager):
+    name = None
+    try:
+        name = manager.settings().get("device_name") if phone.primary else None
+    except Exception:
+        name = None
+    return phone.name or (name if isinstance(name, str) and name else None)
+
+
+def row(runtime, phone, udid, manager):
+    """One phone's Wi-Fi, as GET /api/wireless lists it."""
+    data_dir = runtime.fleet.data_dir
+    settings = store.get(data_dir, udid)
+    link = transport.link(udid) if transport_on() else None
+    name = _name(phone, manager)
+    running = manager.runner is not None and manager.runner.running
+    now = (link.transport if link is not None else
+           getattr(manager, "transport", None) if running else None)
+    problem = link.problem if link is not None and settings["enabled"] else None
+    return {"id": udid, "udid": udid, "name": name, "primary": bool(getattr(phone, "primary", False)),
+            "enabled": settings["enabled"], "transport": now,
+            "tunnel": link.tunnel if link is not None else "unknown",
+            "reachable": bool(link is not None and link.reachable),
+            "lastSeenAt": link.last_seen_at if link is not None else None,
+            "probe": _probe_view(udid, result.get(data_dir, udid)),
+            "lastCheck": _check_view(udid),
+            "problem": words.problem(problem, name) if problem in words.PROBLEMS else None}
+
+
+def _probe_view(udid, kept):
+    """The kept probe, or while a check runs: ``{state: "running", step, at}`` (the step it is on)."""
+    check = _current(udid)
+    if check is not None and check["state"] == "running":
+        return {"state": "running", "at": kept["at"], "reason": kept["reason"], "step": check["step"]}
+    return kept
+
+
+def _check_view(udid):
+    """The check Add a device started on this phone and how it ended, or None."""
+    check = _current(udid)
+    return None if check is None else {key: check[key] for key in ("state", "step", "startedAt", "reason", "next")}
+
+
+def _current(udid, clock=time.monotonic):
+    with _probes_lock:
+        check = _probes.get(str(udid).upper())
+        if check is not None and check["state"] == "running" and clock() - check["began"] >= PROBE_SECONDS:
+            check.update(state="timeout", reason=None, next=words.problem("probe_timeout", check["name"]))
+        return check
+
+
+# The step that failed -> what to tell the person (words.PROBLEMS).
+STEP_PROBLEMS = {"coredevice": "not_seen", "tunnel": "tunnel_down", "wda": "runner", "lan": "not_seen"}
+
+
+def _next_step(probe, name):
+    """The problem the check found, with its one fix: from the step that failed (else warned), else None."""
+    usb = next((item for item in probe.steps if item["key"] == "usb"), None)
+    if usb is not None and usb["detail"].startswith("plugged in"):
+        return words.problem("plugged_in", name)
+    for state in ("fail", "warn"):
+        step = next((item for item in probe.steps if item["state"] == state), None)
+        if step is not None:
+            code = STEP_PROBLEMS.get(step["key"])
+            return words.problem(code, name) if code else None
+    return None
+
+
+def network_view(result):
+    """``{state, problem}`` for a network.peer_check result (problem: null or {code, message, fix}); None for None."""
+    if not isinstance(result, dict):
+        return None
+    code = words.NETWORK_PROBLEMS.get(result.get("state"))
+    return {"state": result.get("state") or "unknown", "problem": words.problem(code) if code else None}
+
+
+def overview(runtime):
+    monitor = monitor_for(runtime) if transport_on() else None
+    with _network_lock:
+        checked = _network["result"]
+    data_dir = getattr(getattr(runtime, "fleet", None), "data_dir", None)
+    return {"wifiTransport": transport_on(),
+            "probe": result.latest(data_dir) if data_dir else dict(result.NOT_RUN),
+            "network": network_view(monitor.network if monitor is not None and monitor.network else checked),
+            "devices": [row(runtime, phone, udid, manager) for phone, udid, manager in _phones(runtime)]}
+
+
+def _find(runtime, ident):
+    """(phone, UDID, manager) for a USB phone set up here, or raises a Response-shaped APIError."""
+    from ..api_errors import APIError
+    from ..devices import AmbiguousDevice
+    if not _managed(runtime):
+        raise APIError("This Mobster doesn't manage USB iPhones.", 409, "not_managed")
+    fleet = runtime.fleet
+    try:
+        phone = fleet.lookup(unquote(ident))
+    except AmbiguousDevice as error:
+        raise APIError(str(error), 400, "device_ambiguous") from None
+    except LookupError as error:
+        raise APIError(str(error), 404, "device_not_found") from None
+    for candidate, udid, manager in fleet.usb_managers():
+        if candidate is phone or (phone.udid and phone.udid.upper() == udid.upper()):
+            return candidate, udid, manager
+    problem = words.problem("not_set_up", phone.name)
+    raise APIError(problem["message"], 409, "not_set_up", fix=problem["fix"])
+
+
+def _refuse(code, name, status=409, **details):
+    problem = words.problem(code, name)
+    return Response.error(problem["message"], status, code, fix=problem["fix"], **details)
+
+
+# -- handlers -------------------------------------------------------------------------------------------------------
+
+def get_wireless(request):
+    return Response.json(overview(request.runtime))
+
+
+def check_network(request, *, check=None, clock=time.monotonic):
+    from . import network
+    with _network_lock:
+        now = clock()
+        if _network["at"] is None or now - _network["at"] >= NETWORK_FRESH or _network["result"] is None:
+            try:
+                _network["result"] = (check or network.peer_check)()
+            except Exception:  # noqa: BLE001 -- a check that fails says nothing
+                _network["result"] = {"state": "unknown", "interface": None, "peers": 0}
+            _network["at"] = now
+        result = _network["result"]
+    return Response.json({"network": network_view(result)})
+
+
+def set_transport(request):
+    body = request.body if isinstance(request.body, dict) else {}
+    if set(body) != {"wifiTransport"} or type(body["wifiTransport"]) is not bool:
+        raise ValueError("Send {\"wifiTransport\": true} or false")
+    on = body["wifiTransport"]
+    runtime = request.runtime
+    setup = getattr(runtime, "setup", None)
+    env_file = getattr(setup, "env_file", None) or getattr(runtime.config, "env_file", None)
+    if env_file:
+        from ..env_secrets import update_env_file
+        update_env_file(env_file, {GATE: "1" if on else "0"})
+    os.environ[GATE] = "1" if on else "0"
+    monitor = monitor_for(runtime, create=on)
+    if monitor is not None:
+        if on:
+            monitor.start()
+            monitor.kick()
+        else:
+            monitor.stop()
+            monitor.retire()
+    return Response.json(overview(runtime))
+
+
+def set_device_wifi(request):
+    body = request.body if isinstance(request.body, dict) else {}
+    if set(body) != {"enabled"} or type(body["enabled"]) is not bool:
+        raise ValueError("Send {\"enabled\": true} or false")
+    runtime = request.runtime
+    phone, udid, manager = _find(runtime, request.params["device"])
+    name = _name(phone, manager)
+    data_dir = runtime.fleet.data_dir
+    listing = next((item for item in _listing(manager) if item.get("udid", "").upper() == udid.upper()), None)
+    following = None
+    if not body["enabled"]:
+        link = transport.link(udid)
+        running_on_wifi = ((link is not None and link.transport == "wifi")
+                           or getattr(manager, "transport", None) == "wifi")
+        if running_on_wifi and task_on(runtime, phone, udid):
+            return _refuse("busy", name)
+    try:
+        if body["enabled"]:
+            if switch.turn_on(data_dir, udid, listing) == "xcode":
+                following = words.problem("needs_xcode", name)
+        elif left_on := switch.turn_off(data_dir, udid, listing):
+            following = words.problem(left_on, name)   # off in Mobster; the phone's own switch is still on
+    except switch.SwitchRefused as error:
+        return _refuse(error.code, name)
+    except RuntimeError:
+        return Response.error("Devices are off in this Mobster (MOBSTER_NO_DEVICES).", 503, "devices_off")
+    monitor = monitor_for(runtime)
+    if monitor is not None:
+        monitor.kick(udid)
+    answer = {"device": row(runtime, phone, udid, manager)}
+    if following is not None:
+        answer["next"] = following
+    return Response.json(answer)
+
+
+def _listing(manager):
+    try:
+        return manager.devices()
+    except Exception:
+        return []
+
+
+def reconnect(request):
+    body = request.body if isinstance(request.body, dict) else {}
+    if set(body) != {"device"} or not isinstance(body["device"], str):
+        raise ValueError("Send {\"device\": \"<id, UDID or name>\"}")
+    runtime = request.runtime
+    phone, udid, manager = _find(runtime, body["device"])
+    if not transport_on():
+        return _refuse("off", _name(phone, manager))
+    monitor = monitor_for(runtime)
+    if monitor is not None:
+        monitor.kick(udid)
+    return Response.json({"device": udid, "accepted": True}, 202)
+
+
+def _run_probe(runtime, check, probe, manager_udid):
+    from ..mac_tools import usb_attached
+    try:
+        probe.run(usb_attached)
+    except Exception as error:  # noqa: BLE001 -- the check ends with its words, never a trace
+        probe.step("probe", "fail", "Wi-Fi check", f"stopped: {type(error).__name__}")
+    finally:
+        try:
+            probe.stop_launched()
+        except Exception:  # noqa: BLE001
+            pass
+    with _probes_lock:
+        if check["state"] != "running":
+            return  # it timed out: a late end changes nothing
+        usb = next((item for item in probe.steps if item["key"] == "usb"), None)
+        if usb is not None and usb["detail"].startswith("plugged in"):
+            state = "plugged_in"
+        else:
+            state = "passed" if probe.ok else "failed"
+            result.record(runtime.fleet.data_dir, manager_udid, probe.public())
+        check.update(state=state, reason=None if probe.ok else result.reason_of(probe.steps),
+                     next=None if probe.ok else _next_step(probe, check["name"]))
+
+
+def probe_wifi(request):
+    """Check one phone's Wi-Fi in the background, the way ``mobster wifi probe`` does (wireless/probe.py)."""
+    body = request.body if isinstance(request.body, dict) else {}
+    if set(body) - {"device", "start"} or not isinstance(body.get("device", ""), str) \
+            or type(body.get("start", False)) is not bool:
+        raise ValueError("Send {\"device\": \"<id, UDID or name>\"} (optional) and {\"start\": true} (optional)")
+    runtime = request.runtime
+    from .. import native_helpers
+    if not native_helpers.devices_allowed():
+        return Response.error("Devices are off in this Mobster (MOBSTER_NO_DEVICES).", 503, "devices_off")
+    if body.get("device"):
+        phone, udid, manager = _find(runtime, body["device"])
+    else:
+        phones = _phones(runtime)
+        if len(phones) != 1:
+            from ..api_errors import APIError
+            raise APIError("Name the iPhone to check." if phones else "Mobster sees no iPhone set up here.",
+                           400 if phones else 409, "device_ambiguous" if phones else "no_device")
+        phone, udid, manager = phones[0]
+    name = _name(phone, manager)
+    if task_on(runtime, phone, udid):
+        return _refuse("busy", name)
+    from .. import devices
+    from .probe import Probe
+    key = udid.upper()
+    with _probes_lock:
+        others = list(_probes)
+    if any(check["state"] == "running" for check in map(_current, others) if check):
+        return _refuse("probe_running", name)
+    check = {"state": "running", "step": None, "startedAt": int(time.time() * 1000), "began": time.monotonic(),
+             "reason": None, "next": None, "name": name or "your iPhone", "udid": udid}
+    probe = Probe(
+        udid=udid, name=name or "your iPhone", slot_port=devices.port_of(getattr(phone, "wda_url", None)),
+        data_dir=runtime.fleet.data_dir, start=bool(body.get("start")), manager=manager,
+        out=lambda step: check.update(step=step["title"]))
+    with _probes_lock:
+        _probes[key] = check
+    threading.Thread(target=_run_probe, args=(runtime, check, probe, udid), name="mobster-wifi-probe",
+                     daemon=True).start()
+    return Response.json({"device": udid, "accepted": True, "check": _check_view(udid)}, 202)
+
+
+# Every route needs the API token, like every other, and none grants anything an approval guards.
+ROUTES = (
+    Route("wireless", "GET", "/api/wireless", get_wireless, body="none"),
+    Route("wireless", "GET", "/api/wireless/network", check_network, body="none"),
+    Route("wireless", "POST", "/api/wireless", set_transport, max_bytes=1024),
+    Route("wireless", "POST", "/api/devices/{device}/wifi", set_device_wifi, max_bytes=1024),
+    Route("wireless", "POST", "/api/wireless/reconnect", reconnect, max_bytes=1024),
+    Route("wireless", "POST", "/api/wireless/probe", probe_wifi, max_bytes=1024),
+)
+
+
+def register_routes():
+    for route in ROUTES:
+        api_routes.register(route)