commit 02ba3238d2be056673a3a6bbaedc09db6e6448f5 · pyrox.dev/nixpkgs

+118 -8

nixos/modules/programs/atop.nix

···

       1
       1
        
       # Global configuration for atop.

     

       2
       2
        
       

     

       3
       3
       -
       { config, lib, ... }:

     

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

     

       4
       4
        
       

     

       5
       5
        
       with lib;

     

       6
       6
        
       

     
···

       12
       12
        
       

     

       13
       13
        
         options = {

     

       14
       14
        
       

     

       15
       15
       -
           programs.atop = {

     

       15
       15
       +
           programs.atop = rec {

     

       16
       16
       +
       

     

       17
       17
       +
             enable = mkEnableOption "Atop";

     

       18
       18
       +
       

     

       19
       19
       +
             package = mkOption {

     

       20
       20
       +
               type = types.package;

     

       21
       21
       +
               default = pkgs.atop;

     

       22
       22
       +
               description = ''

     

       23
       23
       +
                 Which package to use for Atop.

     

       24
       24
       +
               '';

     

       25
       25
       +
             };

     

       26
       26
       +
       

     

       27
       27
       +
             netatop = {

     

       28
       28
       +
               enable = mkOption {

     

       29
       29
       +
                 type = types.bool;

     

       30
       30
       +
                 default = false;

     

       31
       31
       +
                 description = ''

     

       32
       32
       +
                   Whether to install and enable the netatop kernel module.

     

       33
       33
       +
                   Note: this sets the kernel taint flag "O" for loading out-of-tree modules.

     

       34
       34
       +
                 '';

     

       35
       35
       +
               };

     

       36
       36
       +
               package = mkOption {

     

       37
       37
       +
                 type = types.package;

     

       38
       38
       +
                 default = config.boot.kernelPackages.netatop;

     

       39
       39
       +
                 description = ''

     

       40
       40
       +
                   Which package to use for netatop.

     

       41
       41
       +
                 '';

     

       42
       42
       +
               };

     

       43
       43
       +
             };

     

       44
       44
       +
       

     

       45
       45
       +
             atopgpu.enable = mkOption {

     

       46
       46
       +
               type = types.bool;

     

       47
       47
       +
               default = false;

     

       48
       48
       +
               description = ''

     

       49
       49
       +
                 Whether to install and enable the atopgpud daemon to get information about

     

       50
       50
       +
                 NVIDIA gpus.

     

       51
       51
       +
               '';

     

       52
       52
       +
             };

     

       53
       53
       +
       

     

       54
       54
       +
             setuidWrapper.enable = mkOption {

     

       55
       55
       +
               type = types.bool;

     

       56
       56
       +
               default = false;

     

       57
       57
       +
               description = ''

     

       58
       58
       +
                 Whether to install a setuid wrapper for Atop. This is required to use some of

     

       59
       59
       +
                 the features as non-root user (e.g.: ipc information, netatop, atopgpu).

     

       60
       60
       +
                 Atop tries to drop the root privileges shortly after starting.

     

       61
       61
       +
               '';

     

       62
       62
       +
             };

     

       16
       63
        
       

     

       64
       64
       +
             atopService.enable = mkOption {

     

       65
       65
       +
               type = types.bool;

     

       66
       66
       +
               default = true;

     

       67
       67
       +
               description = ''

     

       68
       68
       +
                 Whether to enable the atop service responsible for storing statistics for

     

       69
       69
       +
                 long-term analysis.

     

       70
       70
       +
               '';

     

       71
       71
       +
             };

     

       72
       72
       +
             atopRotateTimer.enable = mkOption {

     

       73
       73
       +
               type = types.bool;

     

       74
       74
       +
               default = true;

     

       75
       75
       +
               description = ''

     

       76
       76
       +
                 Whether to enable the atop-rotate timer, which restarts the atop service

     

       77
       77
       +
                 daily to make sure the data files are rotate.

     

       78
       78
       +
               '';

     

       79
       79
       +
             };

     

       80
       80
       +
             atopacctService.enable = mkOption {

     

       81
       81
       +
               type = types.bool;

     

       82
       82
       +
               default = true;

     

       83
       83
       +
               description = ''

     

       84
       84
       +
                 Whether to enable the atopacct service which manages process accounting.

     

       85
       85
       +
                 This allows Atop to gather data about processes that disappeared in between

     

       86
       86
       +
                 two refresh intervals.

     

       87
       87
       +
               '';

     

       88
       88
       +
             };

     

       17
       89
        
             settings = mkOption {

     

       18
       90
        
               type = types.attrs;

     

       19
       19
       -
               default = {};

     

       91
       91
       +
               default = { };

     

       20
       92
        
               example = {

     

       21
       93
        
                 flags = "a1f";

     

       22
       94
        
                 interval = 5;

     
···

       25
       97
        
                 Parameters to be written to <filename>/etc/atoprc</filename>.

     

       26
       98
        
               '';

     

       27
       99
        
             };

     

       28
       28
       -
       

     

       29
       100
        
           };

     

       30
       101
        
         };

     

       31
       102
        
       

     

       32
       32
       -
         config = mkIf (cfg.settings != {}) {

     

       33
       33
       -
           environment.etc.atoprc.text =

     

       34
       34
       -
             concatStrings (mapAttrsToList (n: v: "${n} ${toString v}\n") cfg.settings);

     

       35
       35
       -
         };

     

       103
       103
       +
         config = mkIf cfg.enable (

     

       104
       104
       +
           let

     

       105
       105
       +
             atop =

     

       106
       106
       +
               if cfg.atopgpu.enable then

     

       107
       107
       +
                 (cfg.package.override { withAtopgpu = true; })

     

       108
       108
       +
               else

     

       109
       109
       +
                 cfg.package;

     

       110
       110
       +
           in

     

       111
       111
       +
           {

     

       112
       112
       +
             environment.etc = mkIf (cfg.settings != { }) {

     

       113
       113
       +
               atoprc.text = concatStrings

     

       114
       114
       +
                 (mapAttrsToList

     

       115
       115
       +
                   (n: v: ''

     

       116
       116
       +
                     ${n} ${toString v}

     

       117
       117
       +
                   '')

     

       118
       118
       +
                   cfg.settings);

     

       119
       119
       +
             };

     

       120
       120
       +
             environment.systemPackages = [ atop (lib.mkIf cfg.netatop.enable cfg.netatop.package) ];

     

       121
       121
       +
             boot.extraModulePackages = [ (lib.mkIf cfg.netatop.enable cfg.netatop.package) ];

     

       122
       122
       +
             systemd =

     

       123
       123
       +
               let

     

       124
       124
       +
                 mkSystemd = type: cond: name: restartTriggers: {

     

       125
       125
       +
                   ${name} = lib.mkIf cond {

     

       126
       126
       +
                     inherit restartTriggers;

     

       127
       127
       +
                     wantedBy = [ (if type == "services" then "multi-user.target" else if type == "timers" then "timers.target" else null) ];

     

       128
       128
       +
                   };

     

       129
       129
       +
                 };

     

       130
       130
       +
                 mkService = mkSystemd "services";

     

       131
       131
       +
                 mkTimer = mkSystemd "timers";

     

       132
       132
       +
               in

     

       133
       133
       +
               {

     

       134
       134
       +
                 packages = [ atop (lib.mkIf cfg.netatop.enable cfg.netatop.package) ];

     

       135
       135
       +
                 services =

     

       136
       136
       +
                   mkService cfg.atopService.enable "atop" [ atop ]

     

       137
       137
       +
                   // mkService cfg.atopacctService.enable "atopacct" [ atop ]

     

       138
       138
       +
                   // mkService cfg.netatop.enable "netatop" [ cfg.netatop.package ]

     

       139
       139
       +
                   // mkService cfg.atopgpu.enable "atopgpu" [ atop ];

     

       140
       140
       +
                 timers = mkTimer cfg.atopRotateTimer.enable "atop-rotate" [ atop ];

     

       141
       141
       +
               };

     

       142
       142
       +
             security.wrappers =

     

       143
       143
       +
               lib.mkIf cfg.setuidWrapper.enable { atop = { source = "${atop}/bin/atop"; }; };

     

       144
       144
       +
           }

     

       145
       145
       +
         );

     

       36
       146
        
       }

nixos/tests/all-tests.nix

···

       29
       29
        
         ammonite = handleTest ./ammonite.nix {};

     

       30
       30
        
         apparmor = handleTest ./apparmor.nix {};

     

       31
       31
        
         atd = handleTest ./atd.nix {};

     

       32
       32
       +
         atop = handleTest ./atop.nix {};

     

       32
       33
        
         avahi = handleTest ./avahi.nix {};

     

       33
       34
        
         avahi-with-resolved = handleTest ./avahi.nix { networkd = true; };

     

       34
       35
        
         awscli = handleTest ./awscli.nix { };

+213

nixos/tests/atop.nix

···

       1
       1
       +
       { system ? builtins.currentSystem

     

       2
       2
       +
       , config ? { }

     

       3
       3
       +
       , pkgs ? import ../.. { inherit system config; }

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       with import ../lib/testing-python.nix { inherit system pkgs; };

     

       7
       7
       +
       with pkgs.lib;

     

       8
       8
       +
       

     

       9
       9
       +
       let assertions = rec {

     

       10
       10
       +
         path = program: path: ''

     

       11
       11
       +
           with subtest("The path of ${program} should be ${path}"):

     

       12
       12
       +
               p = machine.succeed("type -p \"${program}\" | head -c -1")

     

       13
       13
       +
               assert p == "${path}", f"${program} is {p}, expected ${path}"

     

       14
       14
       +
         '';

     

       15
       15
       +
         unit = name: state: ''

     

       16
       16
       +
           with subtest("Unit ${name} should be ${state}"):

     

       17
       17
       +
               machine.require_unit_state("${name}", "${state}")

     

       18
       18
       +
         '';

     

       19
       19
       +
         version = ''

     

       20
       20
       +
           import re

     

       21
       21
       +
       

     

       22
       22
       +
           with subtest("binary should report the correct version"):

     

       23
       23
       +
               pkgver = "${pkgs.atop.version}"

     

       24
       24
       +
               ver = re.sub(r'(?s)^Version: (\d\.\d\.\d).*', r'\1', machine.succeed("atop -V"))

     

       25
       25
       +
               assert ver == pkgver, f"Version is `{ver}`, expected `{pkgver}`"

     

       26
       26
       +
         '';

     

       27
       27
       +
         atoprc = contents:

     

       28
       28
       +
           if builtins.stringLength contents > 0 then ''

     

       29
       29
       +
             with subtest("/etc/atoprc should have the correct contents"):

     

       30
       30
       +
                 f = machine.succeed("cat /etc/atoprc")

     

       31
       31
       +
                 assert f == "${contents}", f"/etc/atoprc contents: '{f}', expected '${contents}'"

     

       32
       32
       +
           '' else ''

     

       33
       33
       +
             with subtest("/etc/atoprc should not be present"):

     

       34
       34
       +
                 machine.succeed("test ! -e /etc/atoprc")

     

       35
       35
       +
           '';

     

       36
       36
       +
         wrapper = present:

     

       37
       37
       +
           if present then path "atop" "/run/wrappers/bin/atop" + ''

     

       38
       38
       +
             with subtest("Wrapper should be setuid root"):

     

       39
       39
       +
                 stat = machine.succeed("stat --printf '%a %u' /run/wrappers/bin/atop")

     

       40
       40
       +
                 assert stat == "4511 0", f"Wrapper stat is {stat}, expected '4511 0'"

     

       41
       41
       +
           ''

     

       42
       42
       +
           else path "atop" "/run/current-system/sw/bin/atop";

     

       43
       43
       +
         atopService = present:

     

       44
       44
       +
           if present then

     

       45
       45
       +
             unit "atop.service" "active"

     

       46
       46
       +
             + ''

     

       47
       47
       +
               with subtest("atop.service should have written some data to /var/log/atop"):

     

       48
       48
       +
                   files = int(machine.succeed("ls -1 /var/log/atop | wc -l"))

     

       49
       49
       +
                   assert files > 0, "Expected at least 1 data file"

     

       50
       50
       +
             '' else unit "atop.service" "inactive";

     

       51
       51
       +
         atopRotateTimer = present:

     

       52
       52
       +
           unit "atop-rotate.timer" (if present then "active" else "inactive");

     

       53
       53
       +
         atopacctService = present:

     

       54
       54
       +
           if present then

     

       55
       55
       +
             unit "atopacct.service" "active"

     

       56
       56
       +
             + ''

     

       57
       57
       +
               with subtest("atopacct.service should enable process accounting"):

     

       58
       58
       +
                   machine.succeed("test -f /run/pacct_source")

     

       59
       59
       +
       

     

       60
       60
       +
               with subtest("atopacct.service should write data to /run/pacct_shadow.d"):

     

       61
       61
       +
                   files = int(machine.succeed("ls -1 /run/pacct_shadow.d | wc -l"))

     

       62
       62
       +
                   assert files >= 1, "Expected at least 1 pacct_shadow.d file"

     

       63
       63
       +
             '' else unit "atopacct.service" "inactive";

     

       64
       64
       +
         netatop = present:

     

       65
       65
       +
           if present then

     

       66
       66
       +
             unit "netatop.service" "active"

     

       67
       67
       +
             + ''

     

       68
       68
       +
               with subtest("The netatop kernel module should be loaded"):

     

       69
       69
       +
                   out = machine.succeed("modprobe -n -v netatop")

     

       70
       70
       +
                   assert out == "", f"Module should be loaded already, but modprobe would have done {out}."

     

       71
       71
       +
             '' else ''

     

       72
       72
       +
             with subtest("The netatop kernel module should be absent"):

     

       73
       73
       +
                 machine.fail("modprobe -n -v netatop")

     

       74
       74
       +
           '';

     

       75
       75
       +
         atopgpu = present:

     

       76
       76
       +
           if present then

     

       77
       77
       +
             (unit "atopgpu.service" "active") + (path "atopgpud" "/run/current-system/sw/bin/atopgpud")

     

       78
       78
       +
           else (unit "atopgpu.service" "inactive") + ''

     

       79
       79
       +
             with subtest("atopgpud should not be present"):

     

       80
       80
       +
                 machine.fail("type -p atopgpud")

     

       81
       81
       +
           '';

     

       82
       82
       +
       };

     

       83
       83
       +
       in

     

       84
       84
       +
       {

     

       85
       85
       +
         name = "atop";

     

       86
       86
       +
       

     

       87
       87
       +
         justThePackage = makeTest {

     

       88
       88
       +
           name = "atop-justThePackage";

     

       89
       89
       +
           machine = {

     

       90
       90
       +
             environment.systemPackages = [ pkgs.atop ];

     

       91
       91
       +
           };

     

       92
       92
       +
           testScript = with assertions; builtins.concatStringsSep "\n" [

     

       93
       93
       +
             version

     

       94
       94
       +
             (atoprc "")

     

       95
       95
       +
             (wrapper false)

     

       96
       96
       +
             (atopService false)

     

       97
       97
       +
             (atopRotateTimer false)

     

       98
       98
       +
             (atopacctService false)

     

       99
       99
       +
             (netatop false)

     

       100
       100
       +
             (atopgpu false)

     

       101
       101
       +
           ];

     

       102
       102
       +
         };

     

       103
       103
       +
         defaults = makeTest {

     

       104
       104
       +
           name = "atop-defaults";

     

       105
       105
       +
           machine = {

     

       106
       106
       +
             programs.atop = {

     

       107
       107
       +
               enable = true;

     

       108
       108
       +
             };

     

       109
       109
       +
           };

     

       110
       110
       +
           testScript = with assertions; builtins.concatStringsSep "\n" [

     

       111
       111
       +
             version

     

       112
       112
       +
             (atoprc "")

     

       113
       113
       +
             (wrapper false)

     

       114
       114
       +
             (atopService true)

     

       115
       115
       +
             (atopRotateTimer true)

     

       116
       116
       +
             (atopacctService true)

     

       117
       117
       +
             (netatop false)

     

       118
       118
       +
             (atopgpu false)

     

       119
       119
       +
           ];

     

       120
       120
       +
         };

     

       121
       121
       +
         minimal = makeTest {

     

       122
       122
       +
           name = "atop-minimal";

     

       123
       123
       +
           machine = {

     

       124
       124
       +
             programs.atop = {

     

       125
       125
       +
               enable = true;

     

       126
       126
       +
               atopService.enable = false;

     

       127
       127
       +
               atopRotateTimer.enable = false;

     

       128
       128
       +
               atopacctService.enable = false;

     

       129
       129
       +
             };

     

       130
       130
       +
           };

     

       131
       131
       +
           testScript = with assertions; builtins.concatStringsSep "\n" [

     

       132
       132
       +
             version

     

       133
       133
       +
             (atoprc "")

     

       134
       134
       +
             (wrapper false)

     

       135
       135
       +
             (atopService false)

     

       136
       136
       +
             (atopRotateTimer false)

     

       137
       137
       +
             (atopacctService false)

     

       138
       138
       +
             (netatop false)

     

       139
       139
       +
             (atopgpu false)

     

       140
       140
       +
           ];

     

       141
       141
       +
         };

     

       142
       142
       +
         netatop = makeTest {

     

       143
       143
       +
           name = "atop-netatop";

     

       144
       144
       +
           machine = {

     

       145
       145
       +
             programs.atop = {

     

       146
       146
       +
               enable = true;

     

       147
       147
       +
               netatop.enable = true;

     

       148
       148
       +
             };

     

       149
       149
       +
           };

     

       150
       150
       +
           testScript = with assertions; builtins.concatStringsSep "\n" [

     

       151
       151
       +
             version

     

       152
       152
       +
             (atoprc "")

     

       153
       153
       +
             (wrapper false)

     

       154
       154
       +
             (atopService true)

     

       155
       155
       +
             (atopRotateTimer true)

     

       156
       156
       +
             (atopacctService true)

     

       157
       157
       +
             (netatop true)

     

       158
       158
       +
             (atopgpu false)

     

       159
       159
       +
           ];

     

       160
       160
       +
         };

     

       161
       161
       +
         atopgpu = makeTest {

     

       162
       162
       +
           name = "atop-atopgpu";

     

       163
       163
       +
           machine = {

     

       164
       164
       +
             nixpkgs.config.allowUnfreePredicate = pkg: builtins.elem (getName pkg) [

     

       165
       165
       +
               "cudatoolkit"

     

       166
       166
       +
             ];

     

       167
       167
       +
       

     

       168
       168
       +
             programs.atop = {

     

       169
       169
       +
               enable = true;

     

       170
       170
       +
               atopgpu.enable = true;

     

       171
       171
       +
             };

     

       172
       172
       +
           };

     

       173
       173
       +
           testScript = with assertions; builtins.concatStringsSep "\n" [

     

       174
       174
       +
             version

     

       175
       175
       +
             (atoprc "")

     

       176
       176
       +
             (wrapper false)

     

       177
       177
       +
             (atopService true)

     

       178
       178
       +
             (atopRotateTimer true)

     

       179
       179
       +
             (atopacctService true)

     

       180
       180
       +
             (netatop false)

     

       181
       181
       +
             (atopgpu true)

     

       182
       182
       +
           ];

     

       183
       183
       +
         };

     

       184
       184
       +
         everything = makeTest {

     

       185
       185
       +
           name = "atop-everthing";

     

       186
       186
       +
           machine = {

     

       187
       187
       +
             nixpkgs.config.allowUnfreePredicate = pkg: builtins.elem (getName pkg) [

     

       188
       188
       +
               "cudatoolkit"

     

       189
       189
       +
             ];

     

       190
       190
       +
       

     

       191
       191
       +
             programs.atop = {

     

       192
       192
       +
               enable = true;

     

       193
       193
       +
               settings = {

     

       194
       194
       +
                 flags = "faf1";

     

       195
       195
       +
                 interval = 2;

     

       196
       196
       +
               };

     

       197
       197
       +
               setuidWrapper.enable = true;

     

       198
       198
       +
               netatop.enable = true;

     

       199
       199
       +
               atopgpu.enable = true;

     

       200
       200
       +
             };

     

       201
       201
       +
           };

     

       202
       202
       +
           testScript = with assertions; builtins.concatStringsSep "\n" [

     

       203
       203
       +
             version

     

       204
       204
       +
             (atoprc "flags faf1\\ninterval 2\\n")

     

       205
       205
       +
             (wrapper true)

     

       206
       206
       +
             (atopService true)

     

       207
       207
       +
             (atopRotateTimer true)

     

       208
       208
       +
             (atopacctService true)

     

       209
       209
       +
             (netatop true)

     

       210
       210
       +
             (atopgpu true)

     

       211
       211
       +
           ];

     

       212
       212
       +
         };

     

       213
       213
       +
       }

+10

pkgs/os-specific/linux/atop/atop.service.patch

···

       1
       1
       +
       --- a/atop.service

     

       2
       2
       +
       +++ b/atop.service

     

       3
       3
       +
       @@ -9,5 +9,6 @@

     

       4
       4
       +
        Environment=LOGPATH=/var/log/atop

     

       5
       5
       +
       -EnvironmentFile=/etc/default/atop

     

       6
       6
       +
       +EnvironmentFile=-/etc/default/atop

     

       7
       7
       +
        ExecStartPre=/bin/sh -c 'test -n "$LOGINTERVAL" -a "$LOGINTERVAL" -eq "$LOGINTERVAL"'

     

       8
       8
       +
        ExecStartPre=/bin/sh -c 'test -n "$LOGGENERATIONS" -a "$LOGGENERATIONS" -eq "$LOGGENERATIONS"'

     

       9
       9
       +
       +ExecStartPre=/bin/sh -c 'mkdir -p "${LOGPATH}"'

     

       10
       10
       +
        ExecStart=/bin/sh -c 'exec @out@/bin/atop ${LOGOPTS} -w "${LOGPATH}/atop_$(date +%%Y%%m%%d)" ${LOGINTERVAL}'

pkgs/os-specific/linux/atop/atopacct.service.patch

···

       1
       1
       +
       --- a/atopacct.service

     

       2
       2
       +
       +++ b/atopacct.service

     

       3
       3
       +
       @@ -9,3 +9,3 @@

     

       4
       4
       +
        Type=forking

     

       5
       5
       +
       -PIDFile=/var/run/atopacctd.pid

     

       6
       6
       +
       +PIDFile=/run/atopacctd.pid

     

       7
       7
       +
        ExecStart=@out@/bin/atopacctd

+47 -16

pkgs/os-specific/linux/atop/default.nix

···

       1
       1
       -
       {lib, stdenv, fetchurl, zlib, ncurses}:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , zlib

     

       5
       5
       +
       , ncurses

     

       6
       6
       +
       , findutils

     

       7
       7
       +
       , systemd

     

       8
       8
       +
       , python3

     

       9
       9
       +
       # makes the package unfree via pynvml

     

       10
       10
       +
       , withAtopgpu ? false

     

       11
       11
       +
       }:

     

       2
       12
        
       

     

       3
       13
        
       stdenv.mkDerivation rec {

     

       4
       14
        
         pname = "atop";

     
···

       9
       19
        
           sha256 = "nsLKOlcWkvfvqglfmaUQZDK8txzCLNbElZfvBIEFj3I=";

     

       10
       20
        
         };

     

       11
       21
        
       

     

       12
       12
       -
         buildInputs = [zlib ncurses];

     

       22
       22
       +
         nativeBuildInputs = lib.optionals withAtopgpu [ python3.pkgs.wrapPython ];

     

       23
       23
       +
         buildInputs = [ zlib ncurses ] ++ lib.optionals withAtopgpu [ python3 ];

     

       24
       24
       +
         pythonPath = lib.optionals withAtopgpu [ python3.pkgs.pynvml ];

     

       13
       25
        
       

     

       14
       26
        
         makeFlags = [

     

       15
       15
       -
           "SCRPATH=$out/etc/atop"

     

       16
       16
       -
           "LOGPATH=/var/log/atop"

     

       17
       17
       -
           "INIPATH=$out/etc/rc.d/init.d"

     

       18
       18
       -
           "SYSDPATH=$out/lib/systemd/system"

     

       19
       19
       -
           "CRNPATH=$out/etc/cron.d"

     

       20
       20
       -
           "DEFPATH=$out/etc/default"

     

       21
       21
       -
           "ROTPATH=$out/etc/logrotate.d"

     

       27
       27
       +
           "DESTDIR=$(out)"

     

       28
       28
       +
           "BINPATH=/bin"

     

       29
       29
       +
           "SBINPATH=/bin"

     

       30
       30
       +
           "MAN1PATH=/share/man/man1"

     

       31
       31
       +
           "MAN5PATH=/share/man/man5"

     

       32
       32
       +
           "MAN8PATH=/share/man/man8"

     

       33
       33
       +
           "SYSDPATH=/lib/systemd/system"

     

       34
       34
       +
           "PMPATHD=/lib/systemd/system-sleep"

     

       35
       35
       +
         ];

     

       36
       36
       +
       

     

       37
       37
       +
         patches = [

     

       38
       38
       +
           # Fix paths in atop.service, atop-rotate.service, atopgpu.service, atopacct.service,

     

       39
       39
       +
           # and atop-pm.sh

     

       40
       40
       +
           ./fix-paths.patch

     

       41
       41
       +
           # Don't fail on missing /etc/default/atop, make sure /var/log/atop exists pre-start

     

       42
       42
       +
           ./atop.service.patch

     

       43
       43
       +
           # Specify PIDFile in /run, not /var/run to silence systemd warning

     

       44
       44
       +
           ./atopacct.service.patch

     

       22
       45
        
         ];

     

       23
       46
        
       

     

       24
       47
        
         preConfigure = ''

     

       25
       25
       -
           sed -e "s@/usr/@$out/@g" -i $(find . -type f )

     

       26
       26
       -
           sed -e "/mkdir.*LOGPATH/s@mkdir@echo missing dir @" -i Makefile

     

       27
       27
       -
           sed -e "/touch.*LOGPATH/s@touch@echo should have created @" -i Makefile

     

       28
       28
       -
           sed -e 's/chown/true/g' -i Makefile

     

       29
       29
       -
           sed -e '/chkconfig/d' -i Makefile

     

       30
       30
       -
           sed -e 's/chmod 04711/chmod 0711/g' -i Makefile

     

       48
       48
       +
           for f in *.{sh,service}; do

     

       49
       49
       +
             findutils=${findutils} systemd=${systemd} substituteAllInPlace "$f"

     

       50
       50
       +
           done

     

       51
       51
       +
       

     

       52
       52
       +
           substituteInPlace Makefile --replace 'chown' 'true'

     

       53
       53
       +
           substituteInPlace Makefile --replace 'chmod 04711' 'chmod 0711'

     

       31
       54
        
         '';

     

       32
       55
        
       

     

       33
       56
        
         installTargets = [ "systemdinstall" ];

     

       34
       57
        
         preInstall = ''

     

       35
       35
       -
           mkdir -p "$out"/{bin,sbin}

     

       58
       58
       +
           mkdir -p $out/bin

     

       36
       59
        
         '';

     

       60
       60
       +
         postInstall = ''

     

       61
       61
       +
           # remove extra files we don't need

     

       62
       62
       +
           rm -r $out/{var,etc} $out/bin/atop{sar,}-${version}

     

       63
       63
       +
         '' + (if withAtopgpu then ''

     

       64
       64
       +
           wrapPythonPrograms

     

       65
       65
       +
         '' else ''

     

       66
       66
       +
           rm $out/lib/systemd/system/atopgpu.service $out/bin/atopgpud $out/share/man/man8/atopgpud.8

     

       67
       67
       +
         '');

     

       37
       68
        
       

     

       38
       69
        
         meta = with lib; {

     

       39
       70
        
           platforms = platforms.linux;

+48

pkgs/os-specific/linux/atop/fix-paths.patch

···

       1
       1
       +
       --- a/atop.service

     

       2
       2
       +
       +++ b/atop.service

     

       3
       3
       +
       @@ -12,4 +12,4 @@

     

       4
       4
       +
        ExecStartPre=/bin/sh -c 'test -n "$LOGGENERATIONS" -a "$LOGGENERATIONS" -eq "$LOGGENERATIONS"'

     

       5
       5
       +
       -ExecStart=/bin/sh -c 'exec /usr/bin/atop ${LOGOPTS} -w "${LOGPATH}/atop_$(date +%%Y%%m%%d)" ${LOGINTERVAL}'

     

       6
       6
       +
       -ExecStartPost=/usr/bin/find "${LOGPATH}" -name "atop_*" -mtime +${LOGGENERATIONS} -exec rm -v {} \;

     

       7
       7
       +
       +ExecStart=/bin/sh -c 'exec @out@/bin/atop ${LOGOPTS} -w "${LOGPATH}/atop_$(date +%%Y%%m%%d)" ${LOGINTERVAL}'

     

       8
       8
       +
       +ExecStartPost=@findutils@/bin/find "${LOGPATH}" -name "atop_*" -mtime +${LOGGENERATIONS} -exec rm -v {} \;

     

       9
       9
       +
        KillSignal=SIGUSR2

     

       10
       10
       +
       

     

       11
       11
       +
       --- a/atop-rotate.service

     

       12
       12
       +
       +++ b/atop-rotate.service

     

       13
       13
       +
       @@ -4,3 +4,3 @@

     

       14
       14
       +
        [Service]

     

       15
       15
       +
        Type=oneshot

     

       16
       16
       +
       -ExecStart=/usr/bin/systemctl try-restart atop.service

     

       17
       17
       +
       +ExecStart=@systemd@/bin/systemctl try-restart atop.service

     

       18
       18
       +
       

     

       19
       19
       +
       --- a/atopgpu.service

     

       20
       20
       +
       +++ b/atopgpu.service

     

       21
       21
       +
       @@ -6,5 +6,5 @@

     

       22
       22
       +
       

     

       23
       23
       +
        [Service]

     

       24
       24
       +
       -ExecStart=/usr/sbin/atopgpud

     

       25
       25
       +
       +ExecStart=@out@/bin/atopgpud

     

       26
       26
       +
        Type=oneshot

     

       27
       27
       +
        RemainAfterExit=yes

     

       28
       28
       +
       

     

       29
       29
       +
       --- a/atopacct.service

     

       30
       30
       +
       +++ b/atopacct.service

     

       31
       31
       +
       @@ -10,3 +10,3 @@

     

       32
       32
       +
        PIDFile=/var/run/atopacctd.pid

     

       33
       33
       +
       -ExecStart=/usr/sbin/atopacctd

     

       34
       34
       +
       +ExecStart=@out@/bin/atopacctd

     

       35
       35
       +
       

     

       36
       36
       +
       --- a/atop-pm.sh

     

       37
       37
       +
       +++ b/atop-pm.sh

     

       38
       38
       +
       @@ -2,8 +2,8 @@

     

       39
       39
       +
       

     

       40
       40
       +
        case "$1" in

     

       41
       41
       +
       -	pre)	/usr/bin/systemctl stop atop

     

       42
       42
       +
       +	pre)	@systemd@/bin/systemctl stop atop

     

       43
       43
       +
        		exit 0

     

       44
       44
       +
        		;;

     

       45
       45
       +
       -	post)	/usr/bin/systemctl start atop

     

       46
       46
       +
       +	post)	@systemd@/bin/systemctl start atop

     

       47
       47
       +
        		exit 0

     

       48
       48
       +
        		;;

+13 -5

pkgs/os-specific/linux/netatop/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, kernel, zlib }:

     

       1
       1
       +
       { lib, stdenv, fetchurl, kernel, kmod, zlib }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         version = "3.1";

     
···

       12
       12
        
           sha256 = "0qjw8glfdmngfvbn1w63q128vxdz2jlabw13y140ga9i5ibl6vvk";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
       -
         buildInputs = [ zlib ];

     

       15
       15
       +
         buildInputs = [ kmod zlib ];

     

       16
       16
        
       

     

       17
       17
        
         hardeningDisable = [ "pic" ];

     

       18
       18
        
       

     

       19
       19
       +
         patches = [

     

       20
       20
       +
           # fix paths in netatop.service

     

       21
       21
       +
           ./fix-paths.patch

     

       22
       22
       +
           # Specify PIDFile in /run, not /var/run to silence systemd warning

     

       23
       23
       +
           ./netatop.service.patch

     

       24
       24
       +
         ];

     

       19
       25
        
         preConfigure = ''

     

       20
       26
        
           patchShebangs mkversion

     

       21
       27
        
           sed -i -e 's,^KERNDIR.*,KERNDIR=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build,' \

     
···

       24
       30
        
               -e s,/usr,$out, \

     

       25
       31
        
               -e /init.d/d \

     

       26
       32
        
               -e /depmod/d \

     

       27
       27
       -
               -e /netatop.service/d \

     

       33
       33
       +
               -e s,/lib/systemd,$out/lib/systemd, \

     

       28
       34
        
               Makefile

     

       35
       35
       +
       

     

       36
       36
       +
           kmod=${kmod} substituteAllInPlace netatop.service

     

       29
       37
        
         '';

     

       30
       38
        
       

     

       31
       39
        
         preInstall = ''

     

       32
       32
       -
           mkdir -p $out/bin $out/sbin $out/share/man/man{4,8}

     

       40
       40
       +
           mkdir -p $out/lib/systemd/system $out/bin $out/sbin $out/share/man/man{4,8}

     

       33
       41
        
           mkdir -p $out/lib/modules/${kernel.modDirVersion}/extra

     

       34
       42
        
         '';

     

       35
       43
        
       

     
···

       38
       46
        
           homepage = "https://www.atoptool.nl/downloadnetatop.php";

     

       39
       47
        
           license = lib.licenses.gpl2;

     

       40
       48
        
           platforms = lib.platforms.linux;

     

       41
       41
       -
           maintainers = with lib.maintainers; [viric];

     

       49
       49
       +
           maintainers = with lib.maintainers; [ viric ];

     

       42
       50
        
         };

     

       43
       51
        
       }

+11

pkgs/os-specific/linux/netatop/fix-paths.patch

···

       1
       1
       +
       --- a/netatop.service

     

       2
       2
       +
       +++ b/netatop.service

     

       3
       3
       +
       @@ -8,5 +8,5 @@

     

       4
       4
       +
        Type=oneshot

     

       5
       5
       +
       -ExecStartPre=/sbin/modprobe netatop

     

       6
       6
       +
       -ExecStart=/usr/sbin/netatopd

     

       7
       7
       +
       -ExecStopPost=/sbin/rmmod netatop

     

       8
       8
       +
       +ExecStartPre=@kmod@/bin/modprobe netatop

     

       9
       9
       +
       +ExecStart=@out@/bin/netatopd

     

       10
       10
       +
       +ExecStopPost=@kmod@/bin/rmmod netatop

     

       11
       11
       +
        PIDFile=/var/run/netatop.pid

pkgs/os-specific/linux/netatop/netatop.service.patch

···

       1
       1
       +
       --- a/netatop.service

     

       2
       2
       +
       +++ b/netatop.service

     

       3
       3
       +
       @@ -11,3 +11,3 @@

     

       4
       4
       +
        ExecStopPost=@kmod@/bin/rmmod netatop

     

       5
       5
       +
       -PIDFile=/var/run/netatop.pid

     

       6
       6
       +
       +PIDFile=/run/netatop.pid

     

       7
       7
       +
        RemainAfterExit=yes