commit 58cbe00eb63f9e590965c2b05ef84b2b046e5eea · pyrox.dev/nixpkgs

nixos/doc/manual/release-notes/rl-2405.section.md

···

       152
       152
        
         The module now includes an optional config check, that is enabled by default, to make the change obvious before any deployment.

     

       153
       153
        
         More information about the configuration syntax change is available in the [upstream repository](https://github.com/prometheus/snmp_exporter/blob/b75fc6b839ee3f3ccbee68bee55f1ae99555084a/auth-split-migration.md).

     

       154
       154
        
       

     

       155
       155
       +
       - [watchdogd](https://troglobit.com/projects/watchdogd/), a system and process supervisor using watchdog timers. Available as [services.watchdogd](#opt-services.watchdogd.enable).

     

       156
       156
       +
       

     

       155
       157
        
       ## Other Notable Changes {#sec-release-24.05-notable-changes}

     

       156
       158
        
       

     

       157
       159
        
       <!-- To avoid merge conflicts, consider adding your item at an arbitrary place in the list instead. -->

nixos/modules/module-list.nix

···

       849
       849
        
         ./services/monitoring/vmagent.nix

     

       850
       850
        
         ./services/monitoring/vmalert.nix

     

       851
       851
        
         ./services/monitoring/vnstat.nix

     

       852
       852
       +
         ./services/monitoring/watchdogd.nix

     

       852
       853
        
         ./services/monitoring/zabbix-agent.nix

     

       853
       854
        
         ./services/monitoring/zabbix-proxy.nix

     

       854
       855
        
         ./services/monitoring/zabbix-server.nix

+131

nixos/modules/services/monitoring/watchdogd.nix

···

       1
       1
       +
       { config, lib, pkgs, ... }:

     

       2
       2
       +
       with lib;

     

       3
       3
       +
       let

     

       4
       4
       +
         cfg = config.services.watchdogd;

     

       5
       5
       +
       

     

       6
       6
       +
         mkPluginOpts = plugin: defWarn: defCrit: {

     

       7
       7
       +
           enabled = mkEnableOption "watchdogd plugin ${plugin}";

     

       8
       8
       +
           interval = mkOption {

     

       9
       9
       +
             type = types.ints.unsigned;

     

       10
       10
       +
             default = 300;

     

       11
       11
       +
             description = ''

     

       12
       12
       +
               Amount of seconds between every poll.

     

       13
       13
       +
             '';

     

       14
       14
       +
           };

     

       15
       15
       +
           logmark = mkOption {

     

       16
       16
       +
             type = types.bool;

     

       17
       17
       +
             default = false;

     

       18
       18
       +
             description = ''

     

       19
       19
       +
               Whether to log current stats every poll interval.

     

       20
       20
       +
             '';

     

       21
       21
       +
           };

     

       22
       22
       +
           warning = mkOption {

     

       23
       23
       +
             type = types.numbers.nonnegative;

     

       24
       24
       +
             default = defWarn;

     

       25
       25
       +
             description = ''

     

       26
       26
       +
               The high watermark level. Alert sent to log.

     

       27
       27
       +
             '';

     

       28
       28
       +
           };

     

       29
       29
       +
           critical = mkOption {

     

       30
       30
       +
             type = types.numbers.nonnegative;

     

       31
       31
       +
             default = defCrit;

     

       32
       32
       +
             description = ''

     

       33
       33
       +
               The critical watermark level. Alert sent to log, followed by reboot or script action.

     

       34
       34
       +
             '';

     

       35
       35
       +
           };

     

       36
       36
       +
         };

     

       37
       37
       +
       in {

     

       38
       38
       +
         options.services.watchdogd = {

     

       39
       39
       +
           enable = mkEnableOption "watchdogd, an advanced system & process supervisor";

     

       40
       40
       +
           package = mkPackageOption pkgs "watchdogd" { };

     

       41
       41
       +
       

     

       42
       42
       +
           settings = mkOption {

     

       43
       43
       +
             type = with types; submodule {

     

       44
       44
       +
               freeformType = let

     

       45
       45
       +
                 valueType = oneOf [

     

       46
       46
       +
                   bool

     

       47
       47
       +
                   int

     

       48
       48
       +
                   float

     

       49
       49
       +
                   str

     

       50
       50
       +
                 ];

     

       51
       51
       +
               in attrsOf (either valueType (attrsOf valueType));

     

       52
       52
       +
       

     

       53
       53
       +
               options = {

     

       54
       54
       +
                 timeout = mkOption {

     

       55
       55
       +
                   type = types.ints.unsigned;

     

       56
       56
       +
                   default = 15;

     

       57
       57
       +
                   description = ''

     

       58
       58
       +
                     The WDT timeout before reset.

     

       59
       59
       +
                   '';

     

       60
       60
       +
                 };

     

       61
       61
       +
                 interval = mkOption {

     

       62
       62
       +
                   type = types.ints.unsigned;

     

       63
       63
       +
                   default = 5;

     

       64
       64
       +
                   description = ''

     

       65
       65
       +
                     The kick interval, i.e. how often {manpage}`watchdogd(8)` should reset the WDT timer.

     

       66
       66
       +
                   '';

     

       67
       67
       +
                 };

     

       68
       68
       +
       

     

       69
       69
       +
                 safe-exit = mkOption {

     

       70
       70
       +
                   type = types.bool;

     

       71
       71
       +
                   default = true;

     

       72
       72
       +
                   description = ''

     

       73
       73
       +
                     With {var}`safeExit` enabled, the daemon will ask the driver to disable the WDT before exiting.

     

       74
       74
       +
                     However, some WDT drivers (or hardware) may not support this.

     

       75
       75
       +
                   '';

     

       76
       76
       +
                 };

     

       77
       77
       +
       

     

       78
       78
       +
                 filenr = mkPluginOpts "filenr" 0.9 1.0;

     

       79
       79
       +
       

     

       80
       80
       +
                 loadavg = mkPluginOpts "loadavg" 1.0 2.0;

     

       81
       81
       +
       

     

       82
       82
       +
                 meminfo = mkPluginOpts "meminfo" 0.9 0.95;

     

       83
       83
       +
               };

     

       84
       84
       +
             };

     

       85
       85
       +
             default = { };

     

       86
       86
       +
             description = ''

     

       87
       87
       +
               Configuration to put in {file}`watchdogd.conf`.

     

       88
       88
       +
               See {manpage}`watchdogd.conf(5)` for more details.

     

       89
       89
       +
             '';

     

       90
       90
       +
           };

     

       91
       91
       +
         };

     

       92
       92
       +
       

     

       93
       93
       +
         config = let

     

       94
       94
       +
           toConfig = attrs: concatStringsSep "\n" (mapAttrsToList toValue attrs);

     

       95
       95
       +
       

     

       96
       96
       +
           toValue = name: value:

     

       97
       97
       +
             if isAttrs value

     

       98
       98
       +
               then pipe value [

     

       99
       99
       +
                 (mapAttrsToList toValue)

     

       100
       100
       +
                 (map (s: "  ${s}"))

     

       101
       101
       +
                 (concatStringsSep "\n")

     

       102
       102
       +
                 (s: "${name} {\n${s}\n}")

     

       103
       103
       +
               ]

     

       104
       104
       +
             else if isBool value

     

       105
       105
       +
               then "${name} = ${boolToString value}"

     

       106
       106
       +
             else if any (f: f value) [isString isInt isFloat]

     

       107
       107
       +
               then "${name} = ${toString value}"

     

       108
       108
       +
             else throw ''

     

       109
       109
       +
               Found invalid type in `services.watchdogd.settings`: '${typeOf value}'

     

       110
       110
       +
             '';

     

       111
       111
       +
       

     

       112
       112
       +
           watchdogdConf = pkgs.writeText "watchdogd.conf" (toConfig cfg.settings);

     

       113
       113
       +
         in mkIf cfg.enable {

     

       114
       114
       +
           environment.systemPackages = [ cfg.package ];

     

       115
       115
       +
       

     

       116
       116
       +
           systemd.services.watchdogd = {

     

       117
       117
       +
             documentation = [

     

       118
       118
       +
               "man:watchdogd(8)"

     

       119
       119
       +
               "man:watchdogd.conf(5)"

     

       120
       120
       +
             ];

     

       121
       121
       +
             wantedBy = [ "multi-user.target" ];

     

       122
       122
       +
             description = "Advanced system & process supervisor";

     

       123
       123
       +
             serviceConfig = {

     

       124
       124
       +
               Type = "simple";

     

       125
       125
       +
               ExecStart = "${cfg.package}/bin/watchdogd -n -f ${watchdogdConf}";

     

       126
       126
       +
             };

     

       127
       127
       +
           };

     

       128
       128
       +
         };

     

       129
       129
       +
       

     

       130
       130
       +
         meta.maintainers = with maintainers; [ vifino ];

     

       131
       131
       +
       }