mirror of
https://github.com/blakeblackshear/frigate.git
synced 2026-10-23 07:02:48 +03:00
Josh HawkinsandGitHub
3d3f6a0678
* reject push endpoints that crash the vapid audience parse The validator accepted hostnames like "." so https://./x passed, and check_registrations then raised ValueError slicing the endpoint, killing the dispatcher's IPC thread. The validator now rejects empty hostname labels and lives in webpush.py, the audience comes from urlparse, and _build_web_pushers skips stored rows whose endpoint fails validation. * keep the ipc thread alive when a handler raises An exception from any dispatcher handler escaped InterProcessCommunicator.read, which only caught ZMQError. The REP thread died owing a reply, so every InterProcessRequestor blocked forever. read now logs the error and replies with an empty response, and Dispatcher.publish and publish_local catch per communicator so one failing communicator can't take down the rest. * stop push sends from reaching internal addresses pywebpush posts through requests with redirects enabled, so an endpoint could answer 307 to http://127.0.0.1:5000/api/restart and the sender would follow it into the internal admin port on every alert. Pushers now use a session that never follows redirects, and each send first resolves the endpoint host and skips it unless every address is global. * keep the previous region grid when the refresh request fails The IPC reader now replies [] when a handler raises, and process_frames assigned that reply to region_grid unconditionally. The next region lookup then indexed into an empty list and killed the camera's detect process. An empty reply now keeps the current grid until the next daily refresh. * drop the send-time public address check Refusing non-global resolved addresses broke Tailscale (100.64.0.0/10), split-horizon DNS and HTTPS_PROXY-only setups, and added little once redirects are no longer followed and TLS verification stays on. * only skip stored push rows that break the vapid audience Running the full registration validator over stored rows dropped self-hosted endpoints registered before 0.18 with a non-443 port or a bare / path. _build_web_pushers now skips only non-dict rows, rows with no endpoint, unparsable endpoints and hosts with empty labels, and the warning names the host so the row can be found. Registration still uses the full validator.
102 lines
3.4 KiB
Python
102 lines
3.4 KiB
Python
"""Facilitates communication between processes."""
|
|
|
|
import logging
|
|
import multiprocessing as mp
|
|
import threading
|
|
from collections.abc import Callable
|
|
from multiprocessing.synchronize import Event as MpEvent
|
|
from typing import Any
|
|
|
|
import zmq
|
|
|
|
from frigate.comms.base_communicator import Communicator
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
SOCKET_REP_REQ = "ipc:///tmp/cache/comms"
|
|
|
|
|
|
class InterProcessCommunicator(Communicator):
|
|
def __init__(self) -> None:
|
|
# bound eagerly so subprocesses starting before start_communicators()
|
|
# can still connect; their requests queue in zmq until the reader runs
|
|
self.context = zmq.Context()
|
|
self.socket = self.context.socket(zmq.REP)
|
|
self.socket.bind(SOCKET_REP_REQ)
|
|
self.stop_event: MpEvent = mp.Event()
|
|
self.reader_thread: threading.Thread | None = None
|
|
|
|
def publish(self, topic: str, payload: Any, retain: bool = False) -> None:
|
|
"""There is no communication back to the processes."""
|
|
pass
|
|
|
|
def subscribe(self, receiver: Callable) -> None:
|
|
self._dispatcher = receiver
|
|
|
|
def start(self) -> None:
|
|
self.reader_thread = threading.Thread(target=self.read)
|
|
self.reader_thread.start()
|
|
|
|
def read(self) -> None:
|
|
while not self.stop_event.is_set():
|
|
while True: # load all messages that are queued
|
|
has_message, _, _ = zmq.select([self.socket], [], [], 1)
|
|
|
|
if not has_message:
|
|
break
|
|
|
|
try:
|
|
raw = self.socket.recv_json(flags=zmq.NOBLOCK)
|
|
|
|
if isinstance(raw, list):
|
|
(topic, value) = raw
|
|
|
|
# REP owes a reply, so a handler error must not end the thread
|
|
try:
|
|
response = self._dispatcher(topic, value)
|
|
except Exception:
|
|
logger.exception("Error handling IPC topic %s", topic)
|
|
response = None
|
|
else:
|
|
logging.warning(
|
|
f"Received unexpected data type in ZMQ recv_json: {type(raw)}"
|
|
)
|
|
response = None
|
|
|
|
if response is not None:
|
|
self.socket.send_json(response)
|
|
else:
|
|
self.socket.send_json([])
|
|
except zmq.ZMQError:
|
|
break
|
|
|
|
def stop(self) -> None:
|
|
self.stop_event.set()
|
|
if self.reader_thread is not None:
|
|
self.reader_thread.join()
|
|
self.socket.close(linger=0)
|
|
self.context.destroy(linger=0)
|
|
|
|
|
|
class InterProcessRequestor:
|
|
"""Simplifies sending data to InterProcessCommunicator and getting a reply."""
|
|
|
|
def __init__(self) -> None:
|
|
self.context = zmq.Context()
|
|
self.socket = self.context.socket(zmq.REQ)
|
|
self.socket.connect(SOCKET_REP_REQ)
|
|
self.lock = threading.Lock()
|
|
|
|
def send_data(self, topic: str, data: Any) -> Any:
|
|
"""Sends data and then waits for reply."""
|
|
with self.lock:
|
|
try:
|
|
self.socket.send_json((topic, data))
|
|
return self.socket.recv_json()
|
|
except zmq.ZMQError:
|
|
return ""
|
|
|
|
def stop(self) -> None:
|
|
self.socket.close(linger=0)
|
|
self.context.destroy(linger=0)
|