Support sd_notify to signal readiness

At this point, it considers it 'ready' when the threads' init functions
have run. This should be enhanced with a facility to signal readiness
from the plugin, asynchronously.

Author: halfgaar

CMakeLists.shared

@@ -89,6 +89,7 @@ set(FLASHMQ_HEADERS
     ${RELPATH}persistencefunctions.h
     ${RELPATH}clientacceptqueue.h
     ${RELPATH}checkedsharedptr.h
+    ${RELPATH}sdnotify.h
 )
 
 set(FLASHMQ_IMPLS
@@ -156,4 +157,5 @@ set(FLASHMQ_IMPLS
     ${RELPATH}fmqssl.cpp
     ${RELPATH}persistencefunctions.cpp
     ${RELPATH}clientacceptqueue.cpp
+    ${RELPATH}sdnotify.cpp
     )

debian/flashmq.service

@@ -3,14 +3,15 @@ Description=FlashMQ MQTT server
 After=network.target
 
 [Service]
-Type=simple
+Type=notify
 User=root
 Group=root
 LimitNOFILE=infinity
 ExecStart=/usr/bin/flashmq --config-file /etc/flashmq/flashmq.conf
 ExecReload=/bin/kill -HUP $MAINPID
 Restart=on-failure
 RestartSec=5s
+TimeoutSec=300
 
 [Install]
 WantedBy=multi-user.target

mainapp.cpp

@@ -33,6 +33,7 @@ See LICENSE for license details.
 #include "globals.h"
 #include "fmqssl.h"
 #include "persistencefunctions.h"
+#include "sdnotify.h"
 
 MainApp::MainApp(const std::string &configFilePath)
 {
@@ -1363,6 +1364,8 @@ void MainApp::queueThreadInitDecrement()
 
             reloadTimers(nullptr);
             started = true;
+
+            notify_ready();
         }
         catch (std::exception &ex)
         {

sdnotify.cpp

@@ -0,0 +1,120 @@
+#include "sdnotify.h"
+
+/* SPDX-License-Identifier: MIT-0 */
+
+/* Implement the systemd notify protocol without external dependencies.
+ * Supports both readiness notification on startup and on reloading,
+ * according to the protocol defined at:
+ * https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html
+ * This protocol is guaranteed to be stable as per:
+ * https://systemd.io/PORTABILITY_AND_STABILITY/ */
+
+#define _GNU_SOURCE 1
+#include <errno.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <time.h>
+#include <unistd.h>
+
+#define _cleanup_(f) __attribute__((cleanup(f)))
+
+static void closep(int *fd) {
+  if (!fd || *fd < 0)
+    return;
+
+  close(*fd);
+  *fd = -1;
+}
+
+static int notify(const char *message) {
+  union sockaddr_union {
+    struct sockaddr sa;
+    struct sockaddr_un sun;
+  } socket_addr {};
+
+  socket_addr.sun.sun_family = AF_UNIX;
+  size_t path_length, message_length;
+  _cleanup_(closep) int fd = -1;
+  const char *socket_path;
+
+  /* Verify the argument first */
+  if (!message)
+    return -EINVAL;
+
+  message_length = strlen(message);
+  if (message_length == 0)
+    return -EINVAL;
+
+  /* If the variable is not set, the protocol is a noop */
+  socket_path = getenv("NOTIFY_SOCKET");
+  if (!socket_path)
+    return 0; /* Not set? Nothing to do */
+
+  /* Only AF_UNIX is supported, with path or abstract sockets */
+  if (socket_path[0] != '/' && socket_path[0] != '@')
+    return -EAFNOSUPPORT;
+
+  path_length = strlen(socket_path);
+  /* Ensure there is room for NUL byte */
+  if (path_length >= sizeof(socket_addr.sun.sun_path))
+    return -E2BIG;
+
+  memcpy(socket_addr.sun.sun_path, socket_path, path_length);
+
+  /* Support for abstract socket */
+  if (socket_addr.sun.sun_path[0] == '@')
+    socket_addr.sun.sun_path[0] = 0;
+
+  fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0);
+  if (fd < 0)
+    return -errno;
+
+  if (connect(fd, &socket_addr.sa, offsetof(struct sockaddr_un, sun_path) + path_length) != 0)
+    return -errno;
+
+  ssize_t written = write(fd, message, message_length);
+  if (written != (ssize_t) message_length)
+    return written < 0 ? -errno : -EPROTO;
+
+  return 1; /* Notified! */
+}
+
+int notify_ready(void) {
+  return notify("READY=1");
+}
+
+int notify_reloading(void) {
+  /* A buffer with length sufficient to format the maximum UINT64 value. */
+  char reload_message[sizeof("RELOADING=1\nMONOTONIC_USEC=18446744073709551615")];
+  struct timespec ts;
+  uint64_t now;
+
+  /* Notify systemd that we are reloading, including a CLOCK_MONOTONIC timestamp in usec
+   * so that the program is compatible with a Type=notify-reload service. */
+
+  if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0)
+    return -errno;
+
+  if (ts.tv_sec < 0 || ts.tv_nsec < 0 ||
+      (uint64_t) ts.tv_sec > (UINT64_MAX - (ts.tv_nsec / 1000ULL)) / 1000000ULL)
+    return -EINVAL;
+
+  now = (uint64_t) ts.tv_sec * 1000000ULL + (uint64_t) ts.tv_nsec / 1000ULL;
+
+  if (snprintf(reload_message, sizeof(reload_message), "RELOADING=1\nMONOTONIC_USEC=%" PRIu64, now) < 0)
+    return -EINVAL;
+
+  return notify(reload_message);
+}
+
+int notify_stopping(void) {
+  return notify("STOPPING=1");
+}
+
+

sdnotify.h

@@ -0,0 +1,9 @@
+#ifndef SDNOTIFY_H
+#define SDNOTIFY_H
+
+
+int notify_ready(void);
+int notify_reloading(void);
+int notify_stopping(void);
+
+#endif // SDNOTIFY_H