Add flexible periodic reboot feature

Author: diffstorm

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.3.0] - 2025-08-24
+
+### Added
+- Flexible periodic reboot feature. Supports daily time (`HH:MM`) and intervals in hours (`h`), days (`d`), weeks (`w`), and months (`m`).
+
 ## [1.2.0] - 2025-08-23
 
 ### Added

README.md

@@ -21,6 +21,7 @@ This application is particularly useful in environments where multiple processes
 - Provides file command interface to manually start, stop, or restart individual processes or the entire watchdog system or even a Linux reboot.
 - Generates statistics log files to track the status and history of each managed process.
 - Monitors CPU and memory usage of each process.
+- Supports periodic reboot of the host system.
 
 ## Requirements
 - If `heartbeat_interval > 0` : Processes managed by Process Watchdog must periodically send their heartbeat messages to prevent being restarted.
@@ -64,6 +65,13 @@ cmd = /usr/bin/python test_child.py 4 noheartbeat
 
 ### Fields
 - `udp_port` : The UDP port to expect heartbeats.
+- `periodic_reboot`: Optional. Specifies the periodic reboot schedule. The feature is disabled if the key is not found or the value is invalid. The supported formats are:
+    - Daily Specific Time: A specific time in `HH:MM` format (e.g., `04:00` for a reboot at 4:00 AM every day).
+    - Hourly Interval: An integer value followed by `h` (e.g., `6h` for every 6 hours).
+    - Daily Interval: An integer value followed by `d` (e.g., `5d` for every 5 days).
+    - Weekly Interval: An integer value followed by `w` (e.g., `2w` for every 2 weeks).
+    - Monthly Interval: An integer value followed by `m` (e.g., `3m` for every 3 months).
+    - Default to Days: If no unit is provided, the value is treated as days (e.g., `7` is equivalent to `7d`).
 - `[app:<AppName>]` : Each application to be monitored should have its own section prefixed with `app:`. `<AppName>` will be used as the name of the application.
 - `start_delay` : Delay in seconds before starting the application.
 - `heartbeat_delay` : Time in seconds to wait before expecting a heartbeat from the application.
@@ -302,6 +310,15 @@ Minimum first heartbeat time: 104 seconds
 Average heartbeat time: 102 seconds
 Maximum heartbeat time: 110 seconds
 Minimum heartbeat time: 102 seconds
+Resource sample count: 190
+Current CPU usage: 0.50%
+Maximum CPU usage: 0.80%
+Minimum CPU usage: 0.00%
+Average CPU usage: 0.40%
+Current memory usage: 11.62 MB
+Maximum memory usage: 11.88 MB
+Minimum memory usage: 11.38 MB
+Average memory usage: 11.74 MB
 Magic: A50FAA55
 ```
 
@@ -353,10 +370,10 @@ Use the provided `run.sh` script to start the Process Watchdog application. This
 Or just `./run.sh &` which is recommended.
 
 ## TODO
+- Attaching to already running processes
 - Create easy-to-use heartbeat libraries
 - Enable commands over UDP
 - Enable remote syslog server reporting
-- Add periodic reboot feature
 - Add periodic server health reporting
 - Add IPC and TCP support
 - Add json support

config.ini

@@ -1,5 +1,6 @@
 [processWatchdog]
 udp_port = 12345
+periodic_reboot = OFF
 
 [app:Communicator]
 start_delay = 10

src/apps.h

@@ -59,13 +59,30 @@ typedef struct
     time_t last_heartbeat; /**< Time when the last heartbeat was received from the application. */
 } Application_t;
 
+typedef enum
+{
+    REBOOT_MODE_DISABLED,
+    REBOOT_MODE_DAILY_TIME,
+    REBOOT_MODE_INTERVAL
+} RebootMode_t;
+
 typedef struct
 {
     int app_count; /**< Total number of applications found in the ini file. */
     int udp_port; /**< UDP port number specified in the ini file. */
     char ini_file[MAX_APP_CMD_LENGTH]; /**< Path to the ini file. */
     time_t ini_last_modified_time; /**< Last modified time of the ini file. */
     time_t uptime; /**< System uptime in seconds. */
+    RebootMode_t periodic_reboot; /**< Periodic reboot mode. */
+    union
+    {
+        struct
+        {
+            int hour;
+            int min;
+        } daily_time;
+        long interval_minutes;
+    } reboot_params; /**< Periodic reboot parameters. */
 } AppState_t;
 
 // Function prototypes

src/config.c

@@ -28,6 +28,8 @@
 #include <errno.h>
 #include <limits.h>
 
+#define MAX_REBOOT_MINUTES 525600 // 1 year in minutes
+
 static time_t config_get_file_modified_time(const char *path)
 {
     struct stat attr;
@@ -100,6 +102,88 @@ static int config_ini_handler(void *user, const char *section, const char *name,
                 return 0;
             }
         }
+        else if(strcmp(name, "periodic_reboot") == 0)
+        {
+            state->periodic_reboot = REBOOT_MODE_DISABLED;
+            int hour, min;
+
+            if(sscanf(value, "%d:%d", &hour, &min) == 2)
+            {
+                if(hour >= 0 && hour <= 23 && min >= 0 && min <= 59)
+                {
+                    state->periodic_reboot = REBOOT_MODE_DAILY_TIME;
+                    state->reboot_params.daily_time.hour = hour;
+                    state->reboot_params.daily_time.min = min;
+                    LOGN("Periodic reboot set to daily at %02d:%02d", hour, min);
+                }
+            }
+            else
+            {
+                char unit = 'd';
+                long interval = 0;
+                char *endptr;
+                interval = strtol(value, &endptr, 10);
+
+                if(endptr != value)
+                {
+                    if(*endptr != '\0')
+                    {
+                        unit = *endptr;
+                    }
+
+                    long multiplier = 0;
+
+                    switch(unit)
+                    {
+                        case 'h':
+                        case 'H':
+                            multiplier = 60;
+                            break;
+
+                        case 'd':
+                        case 'D':
+                            multiplier = 24 * 60;
+                            break;
+
+                        case 'w':
+                        case 'W':
+                            multiplier = 7 * 24 * 60;
+                            break;
+
+                        case 'm':
+                        case 'M':
+                            multiplier = 30 * 24 * 60;
+                            break;
+
+                        default:
+                            break;
+                    }
+
+                    if(multiplier > 0 && interval > 0)
+                    {
+                        if(interval > LONG_MAX / multiplier)
+                        {
+                            LOGE("Reboot interval value is too large and would cause an overflow.");
+                        }
+                        else
+                        {
+                            long interval_minutes = interval * multiplier;
+
+                            if(interval_minutes <= MAX_REBOOT_MINUTES)
+                            {
+                                state->periodic_reboot = REBOOT_MODE_INTERVAL;
+                                state->reboot_params.interval_minutes = interval_minutes;
+                                LOGN("Periodic reboot set to an interval of %ld minutes.", interval_minutes);
+                            }
+                            else
+                            {
+                                LOGW("Reboot interval of %ld minutes is too long (max is %d minutes).", interval_minutes, MAX_REBOOT_MINUTES);
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
     else if(index != -1)      // This is an app section we are tracking
     {
@@ -172,6 +256,7 @@ int config_parse_file(const char *ini_path, Application_t *apps, int max_apps, A
     state->app_count = 0;
     state->uptime = get_uptime();
     state->udp_port = UDP_PORT;
+    state->periodic_reboot = REBOOT_MODE_DISABLED;
     LOGD("Reading ini file %s", ini_path);
     // Prepare user data for the handler
     void *user_data[2] = { apps, state };

src/main.c

@@ -136,7 +136,7 @@ extern char *optarg;
 extern int opterr, optind;
 
 #define APPNAME     basename(argv[0])
-#define VERSION     "1.2.0"
+#define VERSION     "1.3.0"
 #define OPTSTR      "i:v:t:h"
 #define USAGE_FMT   "%s -i <file.ini> [-v] [-h] [-t testname]\n"
 
@@ -214,6 +214,7 @@ void help(char *progname)
     fprintf(stderr, GREEN "\nINI File example config:\n" RESET
             "[processWatchdog]\n"
             "udp_port = 12345\n"
+            "periodic_reboot = OFF\n"
             "\n"
             "[app:Communicator]\n"
             "start_delay = 10\n"
@@ -291,6 +292,7 @@ int main(int argc, char *argv[])
     }
 
     LOGN("%s started v:%s", APPNAME, VERSION);
+    time_t start_time = time(NULL);
 
     // Read config
     if(read_ini_file())
@@ -320,6 +322,7 @@ int main(int argc, char *argv[])
     // Loop here until exit signal arrived
     while(main_alive)
     {
+        long uptime = time(NULL) - start_time;
         // Poll UDP messages
         length = sizeof(data) - 1;
 
@@ -347,13 +350,13 @@ int main(int argc, char *argv[])
             if(process_is_started(i))
             {
                 // Update resource usage stats (1 min)
-                if((get_uptime() % 60) == 0 && process_is_running(i))
+                if((uptime % 60) == 0 && process_is_running(i))
                 {
                     stats_update_resource_usage(i, get_app_pid(i));
                 }
 
                 // Update stats files periodically (15 mins)
-                if((get_uptime() % (15 * 60)) == 0)
+                if((uptime % (15 * 60)) == 0)
                 {
                     stats_write_to_file(i, get_app_name(i));
                     stats_print_to_file(i, get_app_name(i));
@@ -420,13 +423,53 @@ int main(int argc, char *argv[])
             return_code = EXIT_REBOOT;
         }
 
+        // Check for periodic reboot (1 min)
+        if(apps_get_state()->periodic_reboot != REBOOT_MODE_DISABLED && (uptime % 60 == 0))
+        {
+            switch(apps_get_state()->periodic_reboot)
+            {
+                case REBOOT_MODE_DAILY_TIME:
+                {
+                    time_t now = time(NULL);
+                    struct tm *tm_now = localtime(&now);
+
+                    if(tm_now->tm_hour == apps_get_state()->reboot_params.daily_time.hour && tm_now->tm_min == apps_get_state()->reboot_params.daily_time.min)
+                    {
+                        LOGN("Periodic reboot triggered (daily time)");
+                        main_alive = false;
+                        return_code = EXIT_REBOOT;
+                    }
+
+                    break;
+                }
+
+                case REBOOT_MODE_INTERVAL:
+                {
+                    long uptime_minutes = uptime / 60;
+
+                    if(uptime_minutes > 0 && uptime_minutes % apps_get_state()->reboot_params.interval_minutes == 0)
+                    {
+                        LOGN("Periodic reboot triggered (interval)");
+                        main_alive = false;
+                        return_code = EXIT_REBOOT;
+                    }
+
+                    break;
+                }
+
+                default:
+                    break;
+            }
+        }
+
 #if 0 // feature disabled
 
         // Check if ini updated and re-read
         if(is_ini_updated())
         {
             if(read_ini_file())
             {
+                // TODO: attaching to existing PIDs to prevent restarting the processes
                 exit(EXIT_RESTART);
             }
         }

test/server_test.cpp

@@ -1,10 +1,11 @@
 #include "gtest/gtest.h"
 
 extern "C" {
-    #include "server.h"
+#include "server.h"
 }
 
-TEST(ServerTest, UdpStart) {
+TEST(ServerTest, UdpStart)
+{
     int socket;
     int port = 12345;
     ASSERT_EQ(udp_start(&socket, port), 0);