systemd-watchdog 0.9.1__py3-none-any.whl

systemd_watchdog-0.9.1.dist-info/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2020 Aaron D. Marasco
+Copyright (c) 2019 Stig Otnes Kolstad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

systemd_watchdog-0.9.1.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.3
+Name: systemd-watchdog
+Version: 0.9.1
+Summary: sd_notify and sd_watchdog_enabled functionality for writing Python daemons under systemd
+License: MIT
+Keywords: sd_notify,sd_watchdog_enabled,systemd,watchdog
+Author: AaronDMarasco
+Author-email: systemd-watchdog@marascos.net
+Requires-Python: >=3.9
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3 :: Only
+Project-URL: Homepage, http://github.com/AaronDMarasco/systemd-watchdog/
+Project-URL: Issues, http://github.com/AaronDMarasco/systemd-watchdog/issues
+Description-Content-Type: text/markdown
+
+# systemd_watchdog
+
+![](https://img.shields.io/pypi/l/systemd-watchdog)
+![](https://img.shields.io/pypi/v/systemd-watchdog.svg)
+![](https://img.shields.io/travis/com/aarondmarasco/systemd-watchdog)
+![](https://img.shields.io/badge/tested%20versions-3.5%7C3.6%7C3.7%7C3.8%7Cpypy3-success)
+![](https://img.shields.io/pypi/wheel/systemd-watchdog.svg)
+![](https://img.shields.io/pypi/pyversions/systemd-watchdog.svg)
+
+sd_notify(3) and sd_watchdog_enabled(3) client functionality implemented in Python 3 for writing Python daemons
+
+## Install
+```
+$ pip install systemd-watchdog
+```
+or
+```
+$ git clone ...
+$ make install
+```
+
+## Usage
+### `example.py`
+```python
+import systemd_watchdog
+import time
+
+wd = systemd_watchdog.watchdog()
+if not wd.is_enabled:
+    # Then it's probably not running is systemd with watchdog enabled
+    raise Exception("Watchdog not enabled")
+
+# Report a status message
+wd.status("Starting my service...")
+time.sleep(3)
+
+# Report that the program init is complete
+wd.ready()
+wd.status("Init is complete...")
+wd.notify()
+time.sleep(3)
+
+# Compute time between notifications
+timeout_half_sec = int(float(wd.timeout) / 2e6)  # Convert us->s and half that
+wd.status("Sleeping and then notify x 3")
+time.sleep(timeout_half_sec)
+wd.notify()
+time.sleep(timeout_half_sec)
+wd.notify()
+time.sleep(timeout_half_sec)
+wd.notify()
+wd.status("Spamming loop - should only see 2-3 notifications")
+t = float(0)
+while t <= 4*timeout_half_sec:
+    time.sleep(0.05)
+    wd.ping()
+    t += 0.05
+
+# Report an error to the service manager
+wd.notify_error("An irrecoverable error occured!")
+# The service manager will probably kill the program here
+time.sleep(3)
+```
+### Quick Example
+In one terminal:
+`socat unix-recv:/tmp/tempo.sock -`
+
+In another terminal:
+`NOTIFY_SOCKET=/tmp/tempo.sock WATCHDOG_USEC=5000000 python example.py`
+
+Expected output (in first terminal):
+```
+STATUS=Starting my service...
+READY=1
+STATUS=Init is complete...
+WATCHDOG=1
+STATUS=Sleeping and then notify x 3
+WATCHDOG=1
+WATCHDOG=1
+WATCHDOG=1
+STATUS=Spamming loop - should only see 2-3 notifications
+WATCHDOG=1
+WATCHDOG=1
+WATCHDOG=1
+STATUS=An irrecoverable error occured!
+WATCHDOG=trigger
+```
+
+## Public Interface
+### `systemd_watchdog.watchdog` - commonly used properties and methods
+#### `ping`
+The only method required for the simplest implementation; combines `notify_due` with `notify()` to _only_ send "alive" notifications at reasonable intervals.
+
+Returns boolean indicating if a message was sent or not.
+
+#### `beat`
+Alias for `ping()` if you prefer heartbeat terminology.
+
+#### `ready()`
+Report ready service state, _i.e._ completed init (only needed with `Type=notify`).
+
+#### `status(msg)`
+Send a service status message.
+
+### `systemd_watchdog.watchdog` - less-used properties and methods
+#### `is_enabled`
+Boolean property stating whether watchdog capability is enabled.
+
+#### `timeout`
+Property reporting the number of microseconds (int) before process will be killed.
+
+It is recommended that you call `notify()` once roughly half of this interval has passed (see `notify_due`).
+
+#### `timeout_td`
+Property that is the same as `timeout` but presented as `datetime.timedelta` for easier manipulation.
+
+#### `notify_due`
+Boolean property indicating more than half of the watchdog interval has passed since last update.
+
+#### `notify()`
+Report a healthy service state. Other calls, _e.g._ `status()` do *not* reset the watchdog.
+
+#### `notify_error(msg=None)`
+Report an error to the watchdog manager. This program will likely be killed upon receipt.
+
+If `msg` is provided, it will be reported as a status message prior to the error.
+
+
+## History
+Aaron D. Marasco May 2020
+ * Forked from the sd-notify project <https://github.com/stigok/sd-notify>
+ * Additional contributors can be found in GitHub repository history
+
+## License
+
+See `LICENSE` file
+

systemd_watchdog-0.9.1.dist-info/RECORD

@@ -0,0 +1,5 @@
+systemd_watchdog.py,sha256=856svx5UdOmq49Oi2CLIiiujC7XXx3pnPMhMR0Q3Pcg,3010
+systemd_watchdog-0.9.1.dist-info/LICENSE,sha256=kNXlp3uKgbeOGdvGLoWJnhuOEh6gbTZC3twX7P5uTmI,1111
+systemd_watchdog-0.9.1.dist-info/METADATA,sha256=xfsmkXQrkCT2JkbTJ0GqOaAkmR5KL1WYK9126-xrWAw,4531
+systemd_watchdog-0.9.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+systemd_watchdog-0.9.1.dist-info/RECORD,,

systemd_watchdog-0.9.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.3
+Root-Is-Purelib: true
+Tag: py3-none-any

systemd_watchdog.py

@@ -0,0 +1,84 @@
+"""
+sd_notify(3) and sd_watchdog_enabled(3) client functionality implemented in Python 3 for writing Python daemons
+
+See README.md and examples/daemon.py for usage
+"""
+from datetime import timedelta, datetime
+import os
+import socket
+
+class watchdog():
+    _default_timeout = timedelta(hours=24)  # Safe value to do math with; if disabled won't matter
+    def __init__(self, sock=None, addr=None):
+        self._address = addr or os.getenv("NOTIFY_SOCKET")
+        self._lastcall = datetime.fromordinal(1)
+        self._socket = sock or socket.socket(family=socket.AF_UNIX,
+                                             type=socket.SOCK_DGRAM)
+        self._timeout_td = self._default_timeout
+
+        # Note this fix is untested in a live system; https://unix.stackexchange.com/q/206386
+        if self._address and self._address[0] == '@':
+            self._address = '\0'+self._address[1:]
+
+        # Check for our timeout
+        if self._address:
+            wtime = os.getenv("WATCHDOG_USEC")
+            wpid = os.getenv("WATCHDOG_PID")
+            if wtime and wtime.isdigit():
+                if wpid is None or (wpid.isdigit() and (wpid == str(os.getpid()))):
+                    self._timeout_td = timedelta(microseconds=int(wtime))
+
+    def _send(self, msg):
+        """Send string as bytes on the notification socket"""
+        if self.is_enabled:
+            self._socket.sendto(msg.encode(), self._address)
+
+    @property
+    def is_enabled(self):
+        """Property indicating whether watchdog is enabled"""
+        return bool(self._address)
+
+    def notify(self):
+        """Send healthy notification to systemd"""
+        self._lastcall = datetime.now()
+        self._send("WATCHDOG=1\n")
+
+    @property
+    def notify_due(self):
+        return (datetime.now() - self._lastcall) >= (self._timeout_td / 2)
+
+    def notify_error(self, msg=None):
+        """
+        Report a watchdog error. This program will likely be killed by the service manager.
+
+        If msg is provided, it will be reported as a status message prior to the error.
+        """
+        if msg:
+            self.status(msg)
+        self._send("WATCHDOG=trigger\n")
+
+    def ping(self):
+        """Send healthy notification to systemd if prudent to"""
+        if self.notify_due:
+            self.notify()
+            return True
+        return False
+    beat = ping  # alias for ping if you prefer heartbeat terminology
+
+    def ready(self):
+        """Report ready service state, i.e. completed init"""
+        self._send("READY=1\n")
+
+    def status(self, msg):
+        """Send a free-form service status message"""
+        self._send("STATUS=%s\n" % (msg,))
+
+    @property
+    def timeout(self):
+        """Report the watchdog window in microseconds as int (cf. sd_watchdog_enabled(3) )"""
+        return int(self._timeout_td/timedelta(microseconds=1))
+
+    @property
+    def timeout_td(self):
+        """Report the watchdog window as datetime.timedelta (cf. sd_watchdog_enabled(3) )"""
+        return self._timeout_td