commit 78745f4652acc9949d47838b4260b3d7d163da1c · pyrox.dev/nixpkgs

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

···

       85
       85
        
       

     

       86
       86
        
       - [RustDesk](https://rustdesk.com), a full-featured open source remote control alternative for self-hosting and security with minimal configuration. Alternative to TeamViewer.

     

       87
       87
        
       

     

       88
       88
       +
       - [Scrutiny](https://github.com/AnalogJ/scrutiny), a S.M.A.R.T monitoring tool for hard disks with a web frontend.

     

       89
       89
       +
       

     

       88
       90
        
       - [systemd-lock-handler](https://git.sr.ht/~whynothugo/systemd-lock-handler/), a bridge between logind D-Bus events and systemd targets. Available as [services.systemd-lock-handler.enable](#opt-services.systemd-lock-handler.enable).

     

       89
       91
        
       

     

       90
       92
        
       ## Backward Incompatibilities {#sec-release-24.05-incompatibilities}

nixos/modules/module-list.nix

···

       841
       841
        
         ./services/monitoring/riemann.nix

     

       842
       842
        
         ./services/monitoring/rustdesk-server.nix

     

       843
       843
        
         ./services/monitoring/scollector.nix

     

       844
       844
       +
         ./services/monitoring/scrutiny.nix

     

       844
       845
        
         ./services/monitoring/smartd.nix

     

       845
       846
        
         ./services/monitoring/snmpd.nix

     

       846
       847
        
         ./services/monitoring/statsd.nix

+221

nixos/modules/services/monitoring/scrutiny.nix

···

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

     

       2
       2
       +
       let

     

       3
       3
       +
         cfg = config.services.scrutiny;

     

       4
       4
       +
         # Define the settings format used for this program

     

       5
       5
       +
         settingsFormat = pkgs.formats.yaml { };

     

       6
       6
       +
       in

     

       7
       7
       +
       {

     

       8
       8
       +
         options = {

     

       9
       9
       +
           services.scrutiny = {

     

       10
       10
       +
             enable = lib.mkEnableOption "Enables the scrutiny web application.";

     

       11
       11
       +
       

     

       12
       12
       +
             package = lib.mkPackageOptionMD pkgs "scrutiny" { };

     

       13
       13
       +
       

     

       14
       14
       +
             openFirewall = lib.mkOption {

     

       15
       15
       +
               type = lib.types.bool;

     

       16
       16
       +
               default = false;

     

       17
       17
       +
               description = "Open the default ports in the firewall for Scrutiny.";

     

       18
       18
       +
             };

     

       19
       19
       +
       

     

       20
       20
       +
             influxdb.enable = lib.mkOption {

     

       21
       21
       +
               type = lib.types.bool;

     

       22
       22
       +
               default = true;

     

       23
       23
       +
               description = lib.mdDoc ''

     

       24
       24
       +
                 Enables InfluxDB on the host system using the `services.influxdb2` NixOS module

     

       25
       25
       +
                 with default options.

     

       26
       26
       +
       

     

       27
       27
       +
                 If you already have InfluxDB configured, or wish to connect to an external InfluxDB

     

       28
       28
       +
                 instance, disable this option.

     

       29
       29
       +
               '';

     

       30
       30
       +
             };

     

       31
       31
       +
       

     

       32
       32
       +
             settings = lib.mkOption {

     

       33
       33
       +
               description = lib.mdDoc ''

     

       34
       34
       +
                 Scrutiny settings to be rendered into the configuration file.

     

       35
       35
       +
       

     

       36
       36
       +
                 See https://github.com/AnalogJ/scrutiny/blob/master/example.scrutiny.yaml.

     

       37
       37
       +
               '';

     

       38
       38
       +
               default = { };

     

       39
       39
       +
               type = lib.types.submodule {

     

       40
       40
       +
                 freeformType = settingsFormat.type;

     

       41
       41
       +
       

     

       42
       42
       +
                 options.web.listen.port = lib.mkOption {

     

       43
       43
       +
                   type = lib.types.port;

     

       44
       44
       +
                   default = 8080;

     

       45
       45
       +
                   description = lib.mdDoc "Port for web application to listen on.";

     

       46
       46
       +
                 };

     

       47
       47
       +
       

     

       48
       48
       +
                 options.web.listen.host = lib.mkOption {

     

       49
       49
       +
                   type = lib.types.str;

     

       50
       50
       +
                   default = "0.0.0.0";

     

       51
       51
       +
                   description = lib.mdDoc "Interface address for web application to bind to.";

     

       52
       52
       +
                 };

     

       53
       53
       +
       

     

       54
       54
       +
                 options.web.listen.basepath = lib.mkOption {

     

       55
       55
       +
                   type = lib.types.str;

     

       56
       56
       +
                   default = "";

     

       57
       57
       +
                   example = "/scrutiny";

     

       58
       58
       +
                   description = lib.mdDoc ''

     

       59
       59
       +
                     If Scrutiny will be behind a path prefixed reverse proxy, you can override this

     

       60
       60
       +
                     value to serve Scrutiny on a subpath.

     

       61
       61
       +
                   '';

     

       62
       62
       +
                 };

     

       63
       63
       +
       

     

       64
       64
       +
                 options.log.level = lib.mkOption {

     

       65
       65
       +
                   type = lib.types.enum [ "INFO" "DEBUG" ];

     

       66
       66
       +
                   default = "INFO";

     

       67
       67
       +
                   description = lib.mdDoc "Log level for Scrutiny.";

     

       68
       68
       +
                 };

     

       69
       69
       +
       

     

       70
       70
       +
                 options.web.influxdb.scheme = lib.mkOption {

     

       71
       71
       +
                   type = lib.types.str;

     

       72
       72
       +
                   default = "http";

     

       73
       73
       +
                   description = lib.mdDoc "URL scheme to use when connecting to InfluxDB.";

     

       74
       74
       +
                 };

     

       75
       75
       +
       

     

       76
       76
       +
                 options.web.influxdb.host = lib.mkOption {

     

       77
       77
       +
                   type = lib.types.str;

     

       78
       78
       +
                   default = "0.0.0.0";

     

       79
       79
       +
                   description = lib.mdDoc "IP or hostname of the InfluxDB instance.";

     

       80
       80
       +
                 };

     

       81
       81
       +
       

     

       82
       82
       +
                 options.web.influxdb.port = lib.mkOption {

     

       83
       83
       +
                   type = lib.types.port;

     

       84
       84
       +
                   default = 8086;

     

       85
       85
       +
                   description = lib.mdDoc "The port of the InfluxDB instance.";

     

       86
       86
       +
                 };

     

       87
       87
       +
       

     

       88
       88
       +
                 options.web.influxdb.tls.insecure_skip_verify = lib.mkOption {

     

       89
       89
       +
                   type = lib.types.bool;

     

       90
       90
       +
                   default = false;

     

       91
       91
       +
                   description = lib.mdDoc "Skip TLS verification when connecting to InfluxDB.";

     

       92
       92
       +
                 };

     

       93
       93
       +
       

     

       94
       94
       +
                 options.web.influxdb.token = lib.mkOption {

     

       95
       95
       +
                   type = lib.types.nullOr lib.types.str;

     

       96
       96
       +
                   default = null;

     

       97
       97
       +
                   description = lib.mdDoc "Authentication token for connecting to InfluxDB.";

     

       98
       98
       +
                 };

     

       99
       99
       +
       

     

       100
       100
       +
                 options.web.influxdb.org = lib.mkOption {

     

       101
       101
       +
                   type = lib.types.nullOr lib.types.str;

     

       102
       102
       +
                   default = null;

     

       103
       103
       +
                   description = lib.mdDoc "InfluxDB organisation under which to store data.";

     

       104
       104
       +
                 };

     

       105
       105
       +
       

     

       106
       106
       +
                 options.web.influxdb.bucket = lib.mkOption {

     

       107
       107
       +
                   type = lib.types.nullOr lib.types.str;

     

       108
       108
       +
                   default = null;

     

       109
       109
       +
                   description = lib.mdDoc "InfluxDB bucket in which to store data.";

     

       110
       110
       +
                 };

     

       111
       111
       +
               };

     

       112
       112
       +
             };

     

       113
       113
       +
       

     

       114
       114
       +
             collector = {

     

       115
       115
       +
               enable = lib.mkEnableOption "Enables the scrutiny metrics collector.";

     

       116
       116
       +
       

     

       117
       117
       +
               package = lib.mkPackageOptionMD pkgs "scrutiny-collector" { };

     

       118
       118
       +
       

     

       119
       119
       +
               schedule = lib.mkOption {

     

       120
       120
       +
                 type = lib.types.str;

     

       121
       121
       +
                 default = "*:0/15";

     

       122
       122
       +
                 description = lib.mdDoc ''

     

       123
       123
       +
                   How often to run the collector in systemd calendar format.

     

       124
       124
       +
                 '';

     

       125
       125
       +
               };

     

       126
       126
       +
       

     

       127
       127
       +
               settings = lib.mkOption {

     

       128
       128
       +
                 description = lib.mdDoc ''

     

       129
       129
       +
                   Collector settings to be rendered into the collector configuration file.

     

       130
       130
       +
       

     

       131
       131
       +
                   See https://github.com/AnalogJ/scrutiny/blob/master/example.collector.yaml.

     

       132
       132
       +
                 '';

     

       133
       133
       +
                 default = { };

     

       134
       134
       +
                 type = lib.types.submodule {

     

       135
       135
       +
                   freeformType = settingsFormat.type;

     

       136
       136
       +
       

     

       137
       137
       +
                   options.host.id = lib.mkOption {

     

       138
       138
       +
                     type = lib.types.nullOr lib.types.str;

     

       139
       139
       +
                     default = null;

     

       140
       140
       +
                     description = lib.mdDoc "Host ID for identifying/labelling groups of disks";

     

       141
       141
       +
                   };

     

       142
       142
       +
       

     

       143
       143
       +
                   options.api.endpoint = lib.mkOption {

     

       144
       144
       +
                     type = lib.types.str;

     

       145
       145
       +
                     default = "http://localhost:8080";

     

       146
       146
       +
                     description = lib.mdDoc "Scrutiny app API endpoint for sending metrics to.";

     

       147
       147
       +
                   };

     

       148
       148
       +
       

     

       149
       149
       +
                   options.log.level = lib.mkOption {

     

       150
       150
       +
                     type = lib.types.enum [ "INFO" "DEBUG" ];

     

       151
       151
       +
                     default = "INFO";

     

       152
       152
       +
                     description = lib.mdDoc "Log level for Scrutiny collector.";

     

       153
       153
       +
                   };

     

       154
       154
       +
                 };

     

       155
       155
       +
               };

     

       156
       156
       +
             };

     

       157
       157
       +
           };

     

       158
       158
       +
         };

     

       159
       159
       +
       

     

       160
       160
       +
         config = lib.mkIf (cfg.enable || cfg.collector.enable) {

     

       161
       161
       +
           services.influxdb2.enable = cfg.influxdb.enable;

     

       162
       162
       +
       

     

       163
       163
       +
           networking.firewall = lib.mkIf cfg.openFirewall {

     

       164
       164
       +
             allowedTCPPorts = [ cfg.settings.web.listen.port ];

     

       165
       165
       +
           };

     

       166
       166
       +
       

     

       167
       167
       +
           services.smartd = lib.mkIf cfg.collector.enable {

     

       168
       168
       +
             enable = true;

     

       169
       169
       +
             extraOptions = [

     

       170
       170
       +
               "-A /var/log/smartd/"

     

       171
       171
       +
               "--interval=600"

     

       172
       172
       +
             ];

     

       173
       173
       +
           };

     

       174
       174
       +
       

     

       175
       175
       +
           systemd = {

     

       176
       176
       +
             services = {

     

       177
       177
       +
               scrutiny = lib.mkIf cfg.enable {

     

       178
       178
       +
                 description = "Hard Drive S.M.A.R.T Monitoring, Historical Trends & Real World Failure Thresholds";

     

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

     

       180
       180
       +
                 after = [ "network.target" ];

     

       181
       181
       +
                 environment = {

     

       182
       182
       +
                   SCRUTINY_VERSION = "1";

     

       183
       183
       +
                   SCRUTINY_WEB_DATABASE_LOCATION = "/var/lib/scrutiny/scrutiny.db";

     

       184
       184
       +
                   SCRUTINY_WEB_SRC_FRONTEND_PATH = "${cfg.package}/share/scrutiny";

     

       185
       185
       +
                 };

     

       186
       186
       +
                 serviceConfig = {

     

       187
       187
       +
                   DynamicUser = true;

     

       188
       188
       +
                   ExecStart = "${lib.getExe cfg.package} start --config ${settingsFormat.generate "scrutiny.yaml" cfg.settings}";

     

       189
       189
       +
                   Restart = "always";

     

       190
       190
       +
                   StateDirectory = "scrutiny";

     

       191
       191
       +
                   StateDirectoryMode = "0750";

     

       192
       192
       +
                 };

     

       193
       193
       +
               };

     

       194
       194
       +
       

     

       195
       195
       +
               scrutiny-collector = lib.mkIf cfg.collector.enable {

     

       196
       196
       +
                 description = "Scrutiny Collector Service";

     

       197
       197
       +
                 environment = {

     

       198
       198
       +
                   COLLECTOR_VERSION = "1";

     

       199
       199
       +
                   COLLECTOR_API_ENDPOINT = cfg.collector.settings.api.endpoint;

     

       200
       200
       +
                 };

     

       201
       201
       +
                 serviceConfig = {

     

       202
       202
       +
                   Type = "oneshot";

     

       203
       203
       +
                   ExecStart = "${lib.getExe cfg.collector.package} run --config ${settingsFormat.generate "scrutiny-collector.yaml" cfg.collector.settings}";

     

       204
       204
       +
                 };

     

       205
       205
       +
               };

     

       206
       206
       +
             };

     

       207
       207
       +
       

     

       208
       208
       +
             timers = lib.mkIf cfg.collector.enable {

     

       209
       209
       +
               scrutiny-collector = {

     

       210
       210
       +
                 timerConfig = {

     

       211
       211
       +
                   OnCalendar = cfg.collector.schedule;

     

       212
       212
       +
                   Persistent = true;

     

       213
       213
       +
                   Unit = "scrutiny-collector.service";

     

       214
       214
       +
                 };

     

       215
       215
       +
               };

     

       216
       216
       +
             };

     

       217
       217
       +
           };

     

       218
       218
       +
         };

     

       219
       219
       +
       

     

       220
       220
       +
         meta.maintainers = [ lib.maintainers.jnsgruk ];

     

       221
       221
       +
       }

nixos/tests/all-tests.nix

···

       772
       772
        
         sanoid = handleTest ./sanoid.nix {};

     

       773
       773
        
         scaphandre = handleTest ./scaphandre.nix {};

     

       774
       774
        
         schleuder = handleTest ./schleuder.nix {};

     

       775
       775
       +
         scrutiny = handleTest ./scrutiny.nix {};

     

       775
       776
        
         sddm = handleTest ./sddm.nix {};

     

       776
       777
        
         seafile = handleTest ./seafile.nix {};

     

       777
       778
        
         searx = handleTest ./searx.nix {};

+70

nixos/tests/scrutiny.nix

···

       1
       1
       +
       import ./make-test-python.nix ({ lib, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       {

     

       4
       4
       +
         name = "scrutiny";

     

       5
       5
       +
         meta.maintainers = with lib.maintainers; [ jnsgruk ];

     

       6
       6
       +
       

     

       7
       7
       +
         nodes = {

     

       8
       8
       +
           machine = { self, pkgs, lib, ... }: {

     

       9
       9
       +
             services = {

     

       10
       10
       +
               scrutiny.enable = true;

     

       11
       11
       +
               scrutiny.collector.enable = true;

     

       12
       12
       +
             };

     

       13
       13
       +
       

     

       14
       14
       +
             environment.systemPackages =

     

       15
       15
       +
               let

     

       16
       16
       +
                 seleniumScript = pkgs.writers.writePython3Bin "selenium-script"

     

       17
       17
       +
                   {

     

       18
       18
       +
                     libraries = with pkgs.python3Packages; [ selenium ];

     

       19
       19
       +
                   } ''

     

       20
       20
       +
                   from selenium import webdriver

     

       21
       21
       +
                   from selenium.webdriver.common.by import By

     

       22
       22
       +
                   from selenium.webdriver.firefox.options import Options

     

       23
       23
       +
                   from selenium.webdriver.support.ui import WebDriverWait

     

       24
       24
       +
                   from selenium.webdriver.support import expected_conditions as EC

     

       25
       25
       +
       

     

       26
       26
       +
                   options = Options()

     

       27
       27
       +
                   options.add_argument("--headless")

     

       28
       28
       +
                   service = webdriver.FirefoxService(executable_path="${lib.getExe pkgs.geckodriver}")  # noqa: E501

     

       29
       29
       +
       

     

       30
       30
       +
                   driver = webdriver.Firefox(options=options, service=service)

     

       31
       31
       +
                   driver.implicitly_wait(10)

     

       32
       32
       +
                   driver.get("http://localhost:8080/web/dashboard")

     

       33
       33
       +
       

     

       34
       34
       +
                   wait = WebDriverWait(driver, 10).until(

     

       35
       35
       +
                     EC.text_to_be_present_in_element(

     

       36
       36
       +
                       (By.TAG_NAME, "body"), "Drive health at a glance")

     

       37
       37
       +
                   )

     

       38
       38
       +
       

     

       39
       39
       +
                   body_text = driver.find_element(By.TAG_NAME, "body").text

     

       40
       40
       +
                   assert "Temperature history for each device" in body_text

     

       41
       41
       +
       

     

       42
       42
       +
                   driver.close()

     

       43
       43
       +
                 '';

     

       44
       44
       +
               in

     

       45
       45
       +
               with pkgs; [ curl firefox-unwrapped geckodriver seleniumScript ];

     

       46
       46
       +
           };

     

       47
       47
       +
         };

     

       48
       48
       +
         # This is the test code that will check if our service is running correctly:

     

       49
       49
       +
         testScript = ''

     

       50
       50
       +
           start_all()

     

       51
       51
       +
       

     

       52
       52
       +
           # Wait for InfluxDB to be available

     

       53
       53
       +
           machine.wait_for_unit("influxdb2")

     

       54
       54
       +
           machine.wait_for_open_port(8086)

     

       55
       55
       +
       

     

       56
       56
       +
           # Wait for Scrutiny to be available

     

       57
       57
       +
           machine.wait_for_unit("scrutiny")

     

       58
       58
       +
           machine.wait_for_open_port(8080)

     

       59
       59
       +
       

     

       60
       60
       +
           # Ensure the API responds as we expect

     

       61
       61
       +
           output = machine.succeed("curl localhost:8080/api/health")

     

       62
       62
       +
           assert output == '{"success":true}'

     

       63
       63
       +
       

     

       64
       64
       +
           # Start the collector service to send some metrics

     

       65
       65
       +
           collect = machine.succeed("systemctl start scrutiny-collector.service")

     

       66
       66
       +
       

     

       67
       67
       +
           # Ensure the application is actually rendered by the Javascript

     

       68
       68
       +
           machine.succeed("PYTHONUNBUFFERED=1 selenium-script")

     

       69
       69
       +
         '';

     

       70
       70
       +
       })

+53

pkgs/by-name/sc/scrutiny-collector/package.nix

···

       1
       1
       +
       { buildGoModule

     

       2
       2
       +
       , fetchFromGitHub

     

       3
       3
       +
       , makeWrapper

     

       4
       4
       +
       , smartmontools

     

       5
       5
       +
       , nixosTests

     

       6
       6
       +
       , lib

     

       7
       7
       +
       }:

     

       8
       8
       +
       let

     

       9
       9
       +
         version = "0.7.2";

     

       10
       10
       +
       in

     

       11
       11
       +
       buildGoModule rec {

     

       12
       12
       +
         inherit version;

     

       13
       13
       +
         pname = "scrutiny-collector";

     

       14
       14
       +
       

     

       15
       15
       +
         src = fetchFromGitHub {

     

       16
       16
       +
           owner = "AnalogJ";

     

       17
       17
       +
           repo = "scrutiny";

     

       18
       18
       +
           rev = "refs/tags/v${version}";

     

       19
       19
       +
           hash = "sha256-UYKi+WTsasUaE6irzMAHr66k7wXyec8FXc8AWjEk0qs=";

     

       20
       20
       +
         };

     

       21
       21
       +
       

     

       22
       22
       +
         subPackages = "collector/cmd/collector-metrics";

     

       23
       23
       +
       

     

       24
       24
       +
         vendorHash = "sha256-SiQw6pq0Fyy8Ia39S/Vgp9Mlfog2drtVn43g+GXiQuI=";

     

       25
       25
       +
       

     

       26
       26
       +
         buildInputs = [ makeWrapper ];

     

       27
       27
       +
       

     

       28
       28
       +
         CGO_ENABLED = 0;

     

       29
       29
       +
       

     

       30
       30
       +
         ldflags = [ "-extldflags=-static" ];

     

       31
       31
       +
       

     

       32
       32
       +
         tags = [ "static" ];

     

       33
       33
       +
       

     

       34
       34
       +
         installPhase = ''

     

       35
       35
       +
           runHook preInstall

     

       36
       36
       +
           mkdir -p $out/bin

     

       37
       37
       +
           cp $GOPATH/bin/collector-metrics $out/bin/scrutiny-collector-metrics

     

       38
       38
       +
           wrapProgram $out/bin/scrutiny-collector-metrics \

     

       39
       39
       +
             --prefix PATH : ${lib.makeBinPath [ smartmontools ]}

     

       40
       40
       +
           runHook postInstall

     

       41
       41
       +
         '';

     

       42
       42
       +
       

     

       43
       43
       +
         passthru.tests.scrutiny-collector = nixosTests.scrutiny;

     

       44
       44
       +
       

     

       45
       45
       +
         meta = {

     

       46
       46
       +
           description = "Hard disk metrics collector for Scrutiny.";

     

       47
       47
       +
           homepage = "https://github.com/AnalogJ/scrutiny";

     

       48
       48
       +
           license = lib.licenses.mit;

     

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

     

       50
       50
       +
           mainProgram = "scrutiny-collector-metrics";

     

       51
       51
       +
           platforms = lib.platforms.linux;

     

       52
       52
       +
         };

     

       53
       53
       +
       }

+68

pkgs/by-name/sc/scrutiny/package.nix

···

       1
       1
       +
       { buildNpmPackage

     

       2
       2
       +
       , buildGoModule

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , nixosTests

     

       5
       5
       +
       , lib

     

       6
       6
       +
       }:

     

       7
       7
       +
       let

     

       8
       8
       +
         pname = "scrutiny";

     

       9
       9
       +
         version = "0.7.2";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchFromGitHub {

     

       12
       12
       +
           owner = "AnalogJ";

     

       13
       13
       +
           repo = "scrutiny";

     

       14
       14
       +
           rev = "refs/tags/v${version}";

     

       15
       15
       +
           hash = "sha256-UYKi+WTsasUaE6irzMAHr66k7wXyec8FXc8AWjEk0qs=";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         frontend = buildNpmPackage {

     

       19
       19
       +
           inherit version;

     

       20
       20
       +
           pname = "${pname}-webapp";

     

       21
       21
       +
           src = "${src}/webapp/frontend";

     

       22
       22
       +
       

     

       23
       23
       +
           npmDepsHash = "sha256-M8P41LPg7oJ/C9abDuNM5Mn+OO0zK56CKi2BwLxv8oQ=";

     

       24
       24
       +
       

     

       25
       25
       +
           buildPhase = ''

     

       26
       26
       +
             runHook preBuild

     

       27
       27
       +
             mkdir dist

     

       28
       28
       +
             npm run build:prod --offline -- --output-path=dist

     

       29
       29
       +
             runHook postBuild

     

       30
       30
       +
           '';

     

       31
       31
       +
       

     

       32
       32
       +
           installPhase = ''

     

       33
       33
       +
             runHook preInstall

     

       34
       34
       +
             mkdir $out

     

       35
       35
       +
             cp -r dist/* $out

     

       36
       36
       +
             runHook postInstall

     

       37
       37
       +
           '';

     

       38
       38
       +
         };

     

       39
       39
       +
       in

     

       40
       40
       +
       buildGoModule rec {

     

       41
       41
       +
         inherit pname src version;

     

       42
       42
       +
       

     

       43
       43
       +
         subPackages = "webapp/backend/cmd/scrutiny";

     

       44
       44
       +
       

     

       45
       45
       +
         vendorHash = "sha256-SiQw6pq0Fyy8Ia39S/Vgp9Mlfog2drtVn43g+GXiQuI=";

     

       46
       46
       +
       

     

       47
       47
       +
         CGO_ENABLED = 0;

     

       48
       48
       +
       

     

       49
       49
       +
         ldflags = [ "-extldflags=-static" ];

     

       50
       50
       +
       

     

       51
       51
       +
         tags = [ "static" ];

     

       52
       52
       +
       

     

       53
       53
       +
         postInstall = ''

     

       54
       54
       +
           mkdir -p $out/share/scrutiny

     

       55
       55
       +
           cp -r ${frontend}/* $out/share/scrutiny

     

       56
       56
       +
         '';

     

       57
       57
       +
       

     

       58
       58
       +
         passthru.tests.scrutiny = nixosTests.scrutiny;

     

       59
       59
       +
       

     

       60
       60
       +
         meta = {

     

       61
       61
       +
           description = "Hard Drive S.M.A.R.T Monitoring, Historical Trends & Real World Failure Thresholds.";

     

       62
       62
       +
           homepage = "https://github.com/AnalogJ/scrutiny";

     

       63
       63
       +
           license = lib.licenses.mit;

     

       64
       64
       +
           maintainers = with lib.maintainers; [ jnsgruk ];

     

       65
       65
       +
           mainProgram = "scrutiny";

     

       66
       66
       +
           platforms = lib.platforms.linux;

     

       67
       67
       +
         };

     

       68
       68
       +
       }