pyobs-core 2.0.0.dev90__tar.gz → 2.0.0.dev92__tar.gz

{pyobs_core-2.0.0.dev90 → pyobs_core-2.0.0.dev92}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyobs-core
-Version: 2.0.0.dev90
+Version: 2.0.0.dev92
 Summary: robotic telescope software
 Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>
 License-Expression: MIT

{pyobs_core-2.0.0.dev90 → pyobs_core-2.0.0.dev92}/pyobs/application.py

@@ -260,7 +260,16 @@ class Application:
                 # stem-mismatch check below. Give it the config file's own stem instead.
                 cfg = {**cfg, "comm": {"class": f"{DummyComm.__module__}.{DummyComm.__name__}", "name": config_stem}}
             log.info("Creating module from class %s...", klass.__name__)
-            self._module = get_object(cfg, Module)
+            try:
+                self._module = get_object(cfg, Module)
+            except Exception:
+                # The module-creation failure (bad kwargs, broken __init__ chain, ...) is
+                # otherwise only visible as an uncaught traceback on stderr -- which is
+                # /dev/null for daemonized modules (--pid-file, as started by pyobsd /
+                # pyobs-web-admin), so it silently vanishes from all logs. Record it through
+                # the configured handlers (file/journald) before propagating.
+                log.exception("Could not create module %s from config %s.", klass.__name__, config)
+                raise
 
             # a config file whose stem doesn't match its own module's name silently splits
             # PYOBS_MODULE log tagging in two: logging that falls through both execute()

{pyobs_core-2.0.0.dev90 → pyobs_core-2.0.0.dev92}/pyobs/mixins/weatheraware.py

@@ -84,7 +84,7 @@ class WeatherAwareMixin:
                     if not self.__weatheraware_is_error_state:
                         log.error("Telescope is in error mode, cannot park.")
                 else:
-                    log.warning("Weather is bad, shutting down.")
+                    log.info("Weather is bad, shutting down.")
                     await msi.park()
 
             # save error state

{pyobs_core-2.0.0.dev90 → pyobs_core-2.0.0.dev92}/pyobs/modules/camera/basecamera.py

@@ -524,9 +524,42 @@ class BaseCamera(
         is_top = max(top, img_top)
         is_bottom = min(top + height, img_top + img_height)
 
-        # for simplicity we allow prescan/overscan only in one dimension
-        if (left < is_left or left + width > is_right) and (top < is_top or top + height > is_bottom):
-            log.warning("BIASSEC/TRIMSEC can only be calculated with a prescan/overscan on one axis only.")
+        # prescan/overscan exists only where the window extends beyond the visible frame
+        x_ovs = img_left < left or img_left + img_width > left + width
+        y_ovs = img_top < top or img_top + img_height > top + height
+
+        # window extends beyond the visible frame on both axes: the simple calculation
+        # below only supports prescan/overscan on one axis
+        if x_ovs and y_ovs:
+            log.warning(
+                "Cannot compute BIASSEC/TRIMSEC: window %dx%d at %d,%d has prescan/overscan on both axes "
+                "(only one axis is supported).",
+                img_width,
+                img_height,
+                img_left,
+                img_top,
+            )
+            return
+
+        # window lies fully inside the visible frame: there is no prescan/overscan at all
+        if (
+            not x_ovs
+            and not y_ovs
+            and (
+                img_left > left
+                or img_left + img_width < left + width
+                or img_top > top
+                or img_top + img_height < top + height
+            )
+        ):
+            log.info(
+                "No BIASSEC/TRIMSEC: window %dx%d at %d,%d lies fully inside the visible frame "
+                "(no prescan/overscan).",
+                img_width,
+                img_height,
+                img_left,
+                img_top,
+            )
             return
 
         # comments

{pyobs_core-2.0.0.dev90 → pyobs_core-2.0.0.dev92}/pyobs/modules/camera/basevideo.py

@@ -1,4 +1,6 @@
 import asyncio
+import hashlib
+import hmac
 import io
 import json
 import logging
@@ -33,12 +35,18 @@ INDEX_HTML = """
     <title>Title</title>
   </head>
   <body>
-    <img src="/video.mjpg" width="100%">
+    <img src="video.mjpg" width="100%">
   </body>
 </html>
 
 """
 
+# session cookie for browser login (see _check_auth); only used when a token is configured
+_COOKIE_NAME = "pyobs_video_session"
+_COOKIE_LIFETIME = 24 * 60 * 60  # 24 h, in seconds
+# delay on a wrong login password, to slow brute force (compare is constant-time either way)
+_LOGIN_FAILURE_SLEEP = 1.0
+
 
 async def calc_expose_timeout(webcam: IExposureTime, *args: Any, **kwargs: Any) -> float:
     """Calculates timeout for grabe_image()."""
@@ -71,7 +79,14 @@ class LastImage(NamedTuple):
 
 
 class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCMeta):
-    """Base class for all webcam modules."""
+    """Base class for all webcam modules.
+
+    The built-in HTTP server serves the MJPEG live view, the raw frame stream and cached FITS
+    images. Set the ``token`` parameter to protect all of them: machine clients send
+    ``Authorization: Bearer <token>`` (as :class:`pyobs.vfs.HttpFile` does), browsers log in once
+    at ``/login`` and get an HMAC-signed session cookie that rides the same-origin ``<img>``
+    requests. Without a token (the default), no auth is enforced.
+    """
 
     __module__ = "pyobs.modules.camera"
 
@@ -90,6 +105,7 @@ class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCM
         flip: bool = False,
         sleep_time: int = 60,
         fits_header_timeout: float = 15.0,
+        token: str | None = None,
         **kwargs: Any,
     ):
         """Creates a new BaseWebcam.
@@ -112,6 +128,8 @@ class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCM
             flip: Whether to flip around Y axis.
             sleep_time: Time in s with inactivity after which the camera should go to sleep.
             fits_header_timeout: Maximum seconds to wait for a peer's FITS headers before skipping them.
+            token: Shared secret required in the "Authorization: Bearer <token>" header (or a
+                login-page cookie) for stream and data access. If None (default), no auth is enforced.
         """
         super().__init__(
             fits_namespaces=fits_namespaces,
@@ -153,12 +171,23 @@ class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCM
         self._cache = DataCache(cache_size)
 
         # define web server
+        self._token = token
+        # serializes /login attempts so _LOGIN_FAILURE_SLEEP actually caps the guess rate;
+        # without it, concurrent connections each sleep independently and the rate scales
+        # with concurrency instead of being capped
+        self._login_lock = asyncio.Lock()
         self._app = web.Application()
         routes = [web.get("/ping", self.ping_handler), web.get("/{filename}", self.image_handler)]
         if self._video_path is not None:
             routes += [web.get("/", self.web_handler), web.get("/video.mjpg", self.video_handler)]
         if self._raw_path is not None:
             routes.append(web.get("/video.raw", self.raw_handler))
+        if self._token is not None:
+            routes += [
+                web.get("/login", self.login_handler),
+                web.post("/login", self.login_post_handler),
+                web.get("/logout", self.logout_handler),
+            ]
         self._app.add_routes(routes)
         self._runner = web.AppRunner(self._app)
         self._site: web.TCPSite | None = None
@@ -196,6 +225,165 @@ class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCM
         """Whether the server is started."""
         return self._is_listening
 
+    def _sign(self, expiry: int) -> str:
+        """HMAC-SHA256 of ``expiry``, keyed with the configured token, as a hex digest.
+
+        Shared by _make_session_value (signs) and _check_cookie (verifies), so the two can't
+        drift apart on hash algo/encoding.
+
+        Args:
+            expiry: Session expiry timestamp being signed.
+
+        Returns:
+            Hex-encoded HMAC signature.
+        """
+        token = self._token
+        if token is None:
+            raise ValueError("Cannot sign a session without a configured token.")
+        return hmac.new(token.encode(), str(expiry).encode(), hashlib.sha256).hexdigest()
+
+    def _make_session_value(self) -> str:
+        """Build the value for the login session cookie.
+
+        Stateless and HMAC-signed -- the cookie does not contain the token itself:
+
+        ``value = "{expiry_ts}.{hex}"`` where ``hex = HMAC-SHA256(key=token, msg=str(expiry_ts))``
+
+        Returns:
+            Cookie value.
+        """
+        expiry = int(time.time()) + _COOKIE_LIFETIME
+        return f"{expiry}.{self._sign(expiry)}"
+
+    def _check_bearer(self, request: web.Request) -> bool:
+        """Whether the request carries the token as "Authorization: Bearer <token>".
+
+        Only called (via _check_auth) once a token is configured.
+
+        Args:
+            request: Request to check.
+
+        Returns:
+            True if the header matches the configured token.
+        """
+        prefix = "Bearer "
+        header = request.headers.get("Authorization", "")
+        if not header.startswith(prefix):
+            return False
+        return hmac.compare_digest(header[len(prefix) :], self._token or "")
+
+    def _check_cookie(self, request: web.Request) -> bool:
+        """Whether the request carries a valid, unexpired session cookie.
+
+        Only called (via _check_auth) once a token is configured.
+
+        Args:
+            request: Request to check.
+
+        Returns:
+            True if the cookie's HMAC signature verifies and it has not expired.
+        """
+        value = request.cookies.get(_COOKIE_NAME)
+        if value is None:
+            return False
+        try:
+            expiry_str, signature = value.rsplit(".", 1)
+            expiry = int(expiry_str)
+        except ValueError:
+            return False
+        if expiry < time.time():
+            return False
+        return hmac.compare_digest(signature, self._sign(expiry))
+
+    def _check_auth(self, request: web.Request) -> None:
+        """Raises HTTPUnauthorized if a token is configured and the request doesn't carry it.
+
+        Accepts either a valid "Authorization: Bearer <token>" header or a valid session cookie.
+        No-op when no token is configured. Same contract as HttpFileCache._check_auth: the
+        exception type is identical regardless of which handler called it.
+
+        Args:
+            request: Request to check.
+        """
+        if self._token is None:
+            return
+        if not (self._check_bearer(request) or self._check_cookie(request)):
+            raise web.HTTPUnauthorized()
+
+    async def login_handler(self, request: web.Request) -> web.Response:
+        """Handles GET access to /login and returns the login form.
+
+        Served unauthenticated: this is the bootstrap a browser needs, since it cannot attach an
+        "Authorization" header to an <img> request. Only registered when a token is configured.
+
+        Args:
+            request: Request to respond to.
+
+        Returns:
+            Response containing the login form.
+        """
+        html = """<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <title>Login</title>
+  </head>
+  <body>
+    <form method="post" action="/login">
+      <label>Password: <input type="password" name="token" autofocus></label>
+      <button type="submit">Login</button>
+    </form>
+  </body>
+</html>
+"""
+        return web.Response(text=html, content_type="text/html")
+
+    async def login_post_handler(self, request: web.Request) -> web.Response:
+        """Handles POST access to /login, verifying the password and issuing the session cookie.
+
+        Args:
+            request: Request to respond to.
+
+        Returns:
+            303 redirect to / on success, 401 on wrong password.
+        """
+        token = self._token
+        if token is None:
+            # login routes are only registered when a token is configured -- defensive
+            raise web.HTTPUnauthorized()
+        data = await request.post()
+        password = str(data.get("token", ""))
+        async with self._login_lock:
+            # serialized: caps the guess rate at 1/_LOGIN_FAILURE_SLEEP regardless of how many
+            # connections attempt concurrently
+            if not hmac.compare_digest(password, token):
+                # the compare above is constant-time; this sleep additionally slows brute force
+                await asyncio.sleep(_LOGIN_FAILURE_SLEEP)
+                raise web.HTTPUnauthorized()
+        response = web.HTTPSeeOther("/")
+        response.set_cookie(
+            _COOKIE_NAME,
+            self._make_session_value(),
+            max_age=_COOKIE_LIFETIME,
+            path="/",
+            httponly=True,
+            samesite="Lax",
+        )
+        return response
+
+    async def logout_handler(self, request: web.Request) -> web.Response:
+        """Handles GET access to /logout and clears the session cookie.
+
+        Args:
+            request: Request to respond to.
+
+        Returns:
+            303 redirect to /login.
+        """
+        response = web.HTTPSeeOther("/login")
+        response.del_cookie(_COOKIE_NAME, path="/")
+        return response
+
     async def web_handler(self, request: web.Request) -> web.Response:
         """Handles access to / and returns HTML page.
 
@@ -205,6 +393,11 @@ class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCM
         Returns:
             Response containing web page.
         """
+        # a browser landing on / should be taken to the login form, not shown a bare 401
+        try:
+            self._check_auth(request)
+        except web.HTTPUnauthorized:
+            raise web.HTTPSeeOther("/login")
         return web.Response(text=INDEX_HTML, content_type="text/html")
 
     async def ping_handler(self, request: web.Request) -> web.Response:
@@ -227,6 +420,7 @@ class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCM
         Returns:
             Response containing video stream.
         """
+        self._check_auth(request)
 
         # create response
         response = web.StreamResponse()
@@ -273,6 +467,8 @@ class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCM
         Returns:
             Response containing raw frame stream.
         """
+        # auth first: an unauthenticated request must not wake the camera
+        self._check_auth(request)
 
         # activate camera
         await self.activate_camera()
@@ -368,6 +564,7 @@ class BaseVideo(Module, ImageFitsHeaderMixin, IVideo, IImageType, metaclass=ABCM
         Returns:
             Response containing image.
         """
+        self._check_auth(request)
 
         # get filename
         filename = request.match_info["filename"]

{pyobs_core-2.0.0.dev90 → pyobs_core-2.0.0.dev92}/pyobs/modules/image/imagewatcher.py

@@ -29,6 +29,12 @@ class ImageWatcher(Module):
 
     Watches a path for new files and stores them in all given destinations. Only if all operations were successful,
     the file is deleted.
+
+    New files are not processed immediately, but only after a wait time (``wait_time``) has passed since they were
+    detected. This is mainly to make sure the file is fully written before it is read: while the inotify watcher
+    only reports files after they have been closed for writing (``CLOSE_WRITE``), the polling watcher and the
+    initial scan in ``open()`` can see a file while its write is still in progress. The same wait time is also
+    used to delay re-processing of files whose destination copy failed (see ``_worker``).
     """
 
     __module__ = "pyobs.modules.image"
@@ -50,7 +56,9 @@ class ImageWatcher(Module):
             destinations: Filename patterns for destinations.
             poll: If True, watchpath is polled instead of watched by inotify.
             poll_interval: Interval for polling in seconds, if poll is True.
-            wait_time: Time in seconds between adding file to list and processing it.
+            wait_time: Time in seconds between adding a file to the list and processing it. Gives a file that is
+                still being written time to finish (relevant for poll mode and the initial scan) and spaces out
+                re-queued files after failed destination copies.
         """
         Module.__init__(self, **kwargs)
 

{pyobs_core-2.0.0.dev90 → pyobs_core-2.0.0.dev92}/pyobs/robotic/utils/skyflats/flatfielder.py

@@ -489,7 +489,7 @@ class FlatFielder(Object):
 
             # log and return
             if frac > self._allowed_offset_frac:
-                log.warning("Deviation from target count (%.1f%%) is larger than allowed, retrying last image...", frac)
+                log.info("Deviation from target count (%.1f%%) is larger than allowed, retrying last image...", frac)
                 return False
             else:
                 log.info("Calculated new exposure time to be %.2fs.", self._exptime)

{pyobs_core-2.0.0.dev90 → pyobs_core-2.0.0.dev92}/pyobs/vfs/httpfile.py

@@ -78,6 +78,14 @@ class HttpFile(BufferedFile):
             raise ValueError("No download URL given.")
         return urljoin(self._download_path, self.filename)
 
+    @property
+    def headers(self) -> dict[str, str]:
+        """Headers sent with GET/POST requests, e.g. "Authorization: Bearer <token>".
+
+        Returns a copy; mutating it does not affect this instance's headers.
+        """
+        return dict(self._headers)
+
     async def _download(self) -> None:
         """For read access, download the file into a local buffer.
 

{pyobs_core-2.0.0.dev90 → pyobs_core-2.0.0.dev92}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyobs-core"
-version = "2.0.0.dev90"
+version = "2.0.0.dev92"
 description = "robotic telescope software"
 authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }]
 requires-python = ">=3.11"