commit ebaa2268539a1d7fcf81773afb0bea671a6ec340 · pyrox.dev/nixpkgs

+9 -1

nixos/doc/manual/from_md/release-notes/rl-2205.section.xml

···

       19
       19
        
         </section>

     

       20
       20
        
         <section xml:id="sec-release-22.05-new-services">

     

       21
       21
        
           <title>New Services</title>

     

       22
       22
       -
           <itemizedlist spacing="compact">

     

       22
       22
       +
           <itemizedlist>

     

       23
       23
        
             <listitem>

     

       24
       24
        
               <para>

     

       25
       25
        
                 <link xlink:href="https://github.com/intel/linux-sgx#install-the-intelr-sgx-psw">aesmd</link>,

     

       26
       26
        
                 the Intel SGX Architectural Enclave Service Manager. Available

     

       27
       27
        
                 as

     

       28
       28
        
                 <link linkend="opt-services.aesmd.enable">services.aesmd</link>.

     

       29
       29
       +
               </para>

     

       30
       30
       +
             </listitem>

     

       31
       31
       +
             <listitem>

     

       32
       32
       +
               <para>

     

       33
       33
       +
                 <link xlink:href="https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-overview.html">filebeat</link>,

     

       34
       34
       +
                 a lightweight shipper for forwarding and centralizing log

     

       35
       35
       +
                 data. Available as

     

       36
       36
       +
                 <link linkend="opt-services.filebeat.enable">services.filebeat</link>.

     

       29
       37
        
               </para>

     

       30
       38
        
             </listitem>

     

       31
       39
        
           </itemizedlist>

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

···

       10
       10
        
       

     

       11
       11
        
       - [aesmd](https://github.com/intel/linux-sgx#install-the-intelr-sgx-psw), the Intel SGX Architectural Enclave Service Manager. Available as [services.aesmd](#opt-services.aesmd.enable).

     

       12
       12
        
       

     

       13
       13
       +
       - [filebeat](https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-overview.html), a lightweight shipper for forwarding and centralizing log data. Available as [services.filebeat](#opt-services.filebeat.enable).

     

       14
       14
       +
       

     

       13
       15
        
       ## Backward Incompatibilities {#sec-release-22.05-incompatibilities}

     

       14
       16
        
       

     

       15
       17
        
       - `pkgs.ghc` now refers to `pkgs.targetPackages.haskellPackages.ghc`.

nixos/modules/module-list.nix

···

       448
       448
        
         ./services/hardware/xow.nix

     

       449
       449
        
         ./services/logging/SystemdJournal2Gelf.nix

     

       450
       450
        
         ./services/logging/awstats.nix

     

       451
       451
       +
         ./services/logging/filebeat.nix

     

       451
       452
        
         ./services/logging/fluentd.nix

     

       452
       453
        
         ./services/logging/graylog.nix

     

       453
       454
        
         ./services/logging/heartbeat.nix

+253

nixos/modules/services/logging/filebeat.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         inherit (lib)

     

       5
       5
       +
           attrValues

     

       6
       6
       +
           literalExpression

     

       7
       7
       +
           mkEnableOption

     

       8
       8
       +
           mkIf

     

       9
       9
       +
           mkOption

     

       10
       10
       +
           types;

     

       11
       11
       +
       

     

       12
       12
       +
         cfg = config.services.filebeat;

     

       13
       13
       +
       

     

       14
       14
       +
         json = pkgs.formats.json {};

     

       15
       15
       +
       in

     

       16
       16
       +
       {

     

       17
       17
       +
         options = {

     

       18
       18
       +
       

     

       19
       19
       +
           services.filebeat = {

     

       20
       20
       +
       

     

       21
       21
       +
             enable = mkEnableOption "filebeat";

     

       22
       22
       +
       

     

       23
       23
       +
             package = mkOption {

     

       24
       24
       +
               type = types.package;

     

       25
       25
       +
               default = pkgs.filebeat;

     

       26
       26
       +
               defaultText = literalExpression "pkgs.filebeat";

     

       27
       27
       +
               example = literalExpression "pkgs.filebeat7";

     

       28
       28
       +
               description = ''

     

       29
       29
       +
                 The filebeat package to use.

     

       30
       30
       +
               '';

     

       31
       31
       +
             };

     

       32
       32
       +
       

     

       33
       33
       +
             inputs = mkOption {

     

       34
       34
       +
               description = ''

     

       35
       35
       +
                 Inputs specify how Filebeat locates and processes input data.

     

       36
       36
       +
       

     

       37
       37
       +
                 This is like <literal>services.filebeat.settings.filebeat.inputs</literal>,

     

       38
       38
       +
                 but structured as an attribute set. This has the benefit

     

       39
       39
       +
                 that multiple NixOS modules can contribute settings to a

     

       40
       40
       +
                 single filebeat input.

     

       41
       41
       +
       

     

       42
       42
       +
                 An input type can be specified multiple times by choosing a

     

       43
       43
       +
                 different <literal>&lt;name></literal> for each, but setting

     

       44
       44
       +
                 <xref linkend="opt-services.filebeat.inputs._name_.type"/>

     

       45
       45
       +
                 to the same value.

     

       46
       46
       +
       

     

       47
       47
       +
                 See <link xlink:href="https://www.elastic.co/guide/en/beats/filebeat/current/configuration-filebeat-options.html"/>.

     

       48
       48
       +
               '';

     

       49
       49
       +
               default = {};

     

       50
       50
       +
               type = types.attrsOf (types.submodule ({ name, ... }: {

     

       51
       51
       +
                 freeformType = json.type;

     

       52
       52
       +
                 options = {

     

       53
       53
       +
                   type = mkOption {

     

       54
       54
       +
                     type = types.str;

     

       55
       55
       +
                     default = name;

     

       56
       56
       +
                     description = ''

     

       57
       57
       +
                       The input type.

     

       58
       58
       +
       

     

       59
       59
       +
                       Look for the value after <literal>type:</literal> on

     

       60
       60
       +
                       the individual input pages linked from

     

       61
       61
       +
                       <link xlink:href="https://www.elastic.co/guide/en/beats/filebeat/current/configuration-filebeat-options.html"/>.

     

       62
       62
       +
                     '';

     

       63
       63
       +
                   };

     

       64
       64
       +
                 };

     

       65
       65
       +
               }));

     

       66
       66
       +
               example = literalExpression ''

     

       67
       67
       +
                 {

     

       68
       68
       +
                   journald.id = "everything";  # Only for filebeat7

     

       69
       69
       +
                   log = {

     

       70
       70
       +
                     enabled = true;

     

       71
       71
       +
                     paths = [

     

       72
       72
       +
                       "/var/log/*.log"

     

       73
       73
       +
                     ];

     

       74
       74
       +
                   };

     

       75
       75
       +
                 };

     

       76
       76
       +
               '';

     

       77
       77
       +
             };

     

       78
       78
       +
       

     

       79
       79
       +
             modules = mkOption {

     

       80
       80
       +
               description = ''

     

       81
       81
       +
                 Filebeat modules provide a quick way to get started

     

       82
       82
       +
                 processing common log formats. They contain default

     

       83
       83
       +
                 configurations, Elasticsearch ingest pipeline definitions,

     

       84
       84
       +
                 and Kibana dashboards to help you implement and deploy a log

     

       85
       85
       +
                 monitoring solution.

     

       86
       86
       +
       

     

       87
       87
       +
                 This is like <literal>services.filebeat.settings.filebeat.modules</literal>,

     

       88
       88
       +
                 but structured as an attribute set. This has the benefit

     

       89
       89
       +
                 that multiple NixOS modules can contribute settings to a

     

       90
       90
       +
                 single filebeat module.

     

       91
       91
       +
       

     

       92
       92
       +
                 A module can be specified multiple times by choosing a

     

       93
       93
       +
                 different <literal>&lt;name></literal> for each, but setting

     

       94
       94
       +
                 <xref linkend="opt-services.filebeat.modules._name_.module"/>

     

       95
       95
       +
                 to the same value.

     

       96
       96
       +
       

     

       97
       97
       +
                 See <link xlink:href="https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-modules.html"/>.

     

       98
       98
       +
               '';

     

       99
       99
       +
               default = {};

     

       100
       100
       +
               type = types.attrsOf (types.submodule ({ name, ... }: {

     

       101
       101
       +
                 freeformType = json.type;

     

       102
       102
       +
                 options = {

     

       103
       103
       +
                   module = mkOption {

     

       104
       104
       +
                     type = types.str;

     

       105
       105
       +
                     default = name;

     

       106
       106
       +
                     description = ''

     

       107
       107
       +
                       The name of the module.

     

       108
       108
       +
       

     

       109
       109
       +
                       Look for the value after <literal>module:</literal> on

     

       110
       110
       +
                       the individual input pages linked from

     

       111
       111
       +
                       <link xlink:href="https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-modules.html"/>.

     

       112
       112
       +
                     '';

     

       113
       113
       +
                   };

     

       114
       114
       +
                 };

     

       115
       115
       +
               }));

     

       116
       116
       +
               example = literalExpression ''

     

       117
       117
       +
                 {

     

       118
       118
       +
                   nginx = {

     

       119
       119
       +
                     access = {

     

       120
       120
       +
                       enabled = true;

     

       121
       121
       +
                       var.paths = [ "/path/to/log/nginx/access.log*" ];

     

       122
       122
       +
                     };

     

       123
       123
       +
                     error = {

     

       124
       124
       +
                       enabled = true;

     

       125
       125
       +
                       var.paths = [ "/path/to/log/nginx/error.log*" ];

     

       126
       126
       +
                     };

     

       127
       127
       +
                   };

     

       128
       128
       +
                 };

     

       129
       129
       +
               '';

     

       130
       130
       +
             };

     

       131
       131
       +
       

     

       132
       132
       +
             settings = mkOption {

     

       133
       133
       +
               type = types.submodule {

     

       134
       134
       +
                 freeformType = json.type;

     

       135
       135
       +
       

     

       136
       136
       +
                 options = {

     

       137
       137
       +
       

     

       138
       138
       +
                   output.elasticsearch.hosts = mkOption {

     

       139
       139
       +
                     type = with types; listOf str;

     

       140
       140
       +
                     default = [ "127.0.0.1:9200" ];

     

       141
       141
       +
                     example = [ "myEShost:9200" ];

     

       142
       142
       +
                     description = ''

     

       143
       143
       +
                       The list of Elasticsearch nodes to connect to.

     

       144
       144
       +
       

     

       145
       145
       +
                       The events are distributed to these nodes in round

     

       146
       146
       +
                       robin order. If one node becomes unreachable, the

     

       147
       147
       +
                       event is automatically sent to another node. Each

     

       148
       148
       +
                       Elasticsearch node can be defined as a URL or

     

       149
       149
       +
                       IP:PORT. For example:

     

       150
       150
       +
                       <literal>http://192.15.3.2</literal>,

     

       151
       151
       +
                       <literal>https://es.found.io:9230</literal> or

     

       152
       152
       +
                       <literal>192.24.3.2:9300</literal>. If no port is

     

       153
       153
       +
                       specified, <literal>9200</literal> is used.

     

       154
       154
       +
                     '';

     

       155
       155
       +
                   };

     

       156
       156
       +
       

     

       157
       157
       +
                   filebeat = {

     

       158
       158
       +
                     inputs = mkOption {

     

       159
       159
       +
                       type = types.listOf json.type;

     

       160
       160
       +
                       default = [];

     

       161
       161
       +
                       internal = true;

     

       162
       162
       +
                       description = ''

     

       163
       163
       +
                         Inputs specify how Filebeat locates and processes

     

       164
       164
       +
                         input data. Use <xref

     

       165
       165
       +
                         linkend="opt-services.filebeat.inputs"/> instead.

     

       166
       166
       +
       

     

       167
       167
       +
                         See <link xlink:href="https://www.elastic.co/guide/en/beats/filebeat/current/configuration-filebeat-options.html"/>.

     

       168
       168
       +
                       '';

     

       169
       169
       +
                     };

     

       170
       170
       +
                     modules = mkOption {

     

       171
       171
       +
                       type = types.listOf json.type;

     

       172
       172
       +
                       default = [];

     

       173
       173
       +
                       internal = true;

     

       174
       174
       +
                       description = ''

     

       175
       175
       +
                         Filebeat modules provide a quick way to get started

     

       176
       176
       +
                         processing common log formats. They contain default

     

       177
       177
       +
                         configurations, Elasticsearch ingest pipeline

     

       178
       178
       +
                         definitions, and Kibana dashboards to help you

     

       179
       179
       +
                         implement and deploy a log monitoring solution.

     

       180
       180
       +
       

     

       181
       181
       +
                         Use <xref linkend="opt-services.filebeat.modules"/> instead.

     

       182
       182
       +
       

     

       183
       183
       +
                         See <link xlink:href="https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-modules.html"/>.

     

       184
       184
       +
                       '';

     

       185
       185
       +
                     };

     

       186
       186
       +
                   };

     

       187
       187
       +
                 };

     

       188
       188
       +
               };

     

       189
       189
       +
               default = {};

     

       190
       190
       +
               example = literalExpression ''

     

       191
       191
       +
                 {

     

       192
       192
       +
                   settings = {

     

       193
       193
       +
                     output.elasticsearch = {

     

       194
       194
       +
                       hosts = [ "myEShost:9200" ];

     

       195
       195
       +
                       username = "filebeat_internal";

     

       196
       196
       +
                       password = { _secret = "/var/keys/elasticsearch_password"; };

     

       197
       197
       +
                     };

     

       198
       198
       +
                     logging.level = "info";

     

       199
       199
       +
                   };

     

       200
       200
       +
                 };

     

       201
       201
       +
               '';

     

       202
       202
       +
       

     

       203
       203
       +
               description = ''

     

       204
       204
       +
                 Configuration for filebeat. See

     

       205
       205
       +
                 <link xlink:href="https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-reference-yml.html"/>

     

       206
       206
       +
                 for supported values.

     

       207
       207
       +
       

     

       208
       208
       +
                 Options containing secret data should be set to an attribute

     

       209
       209
       +
                 set containing the attribute <literal>_secret</literal> - a

     

       210
       210
       +
                 string pointing to a file containing the value the option

     

       211
       211
       +
                 should be set to. See the example to get a better picture of

     

       212
       212
       +
                 this: in the resulting

     

       213
       213
       +
                 <filename>filebeat.yml</filename> file, the

     

       214
       214
       +
                 <literal>output.elasticsearch.password</literal>

     

       215
       215
       +
                 key will be set to the contents of the

     

       216
       216
       +
                 <filename>/var/keys/elasticsearch_password</filename> file.

     

       217
       217
       +
               '';

     

       218
       218
       +
             };

     

       219
       219
       +
           };

     

       220
       220
       +
         };

     

       221
       221
       +
       

     

       222
       222
       +
         config = mkIf cfg.enable {

     

       223
       223
       +
       

     

       224
       224
       +
           services.filebeat.settings.filebeat.inputs = attrValues cfg.inputs;

     

       225
       225
       +
           services.filebeat.settings.filebeat.modules = attrValues cfg.modules;

     

       226
       226
       +
       

     

       227
       227
       +
           systemd.services.filebeat = {

     

       228
       228
       +
             description = "Filebeat log shipper";

     

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

     

       230
       230
       +
             wants = [ "elasticsearch.service" ];

     

       231
       231
       +
             after = [ "elasticsearch.service" ];

     

       232
       232
       +
             serviceConfig = {

     

       233
       233
       +
               ExecStartPre = pkgs.writeShellScript "filebeat-exec-pre" ''

     

       234
       234
       +
                 set -euo pipefail

     

       235
       235
       +
       

     

       236
       236
       +
                 umask u=rwx,g=,o=

     

       237
       237
       +
       

     

       238
       238
       +
                 ${utils.genJqSecretsReplacementSnippet

     

       239
       239
       +
                     cfg.settings

     

       240
       240
       +
                     "/var/lib/filebeat/filebeat.yml"

     

       241
       241
       +
                  }

     

       242
       242
       +
               '';

     

       243
       243
       +
               ExecStart = ''

     

       244
       244
       +
                 ${cfg.package}/bin/filebeat -e \

     

       245
       245
       +
                   -c "/var/lib/filebeat/filebeat.yml" \

     

       246
       246
       +
                   --path.data "/var/lib/filebeat"

     

       247
       247
       +
               '';

     

       248
       248
       +
               Restart = "always";

     

       249
       249
       +
               StateDirectory = "filebeat";

     

       250
       250
       +
             };

     

       251
       251
       +
           };

     

       252
       252
       +
         };

     

       253
       253
       +
       }

+2 -1

nixos/modules/services/logging/journalbeat.nix

···

       28
       28
        
               type = types.package;

     

       29
       29
        
               default = pkgs.journalbeat;

     

       30
       30
        
               defaultText = literalExpression "pkgs.journalbeat";

     

       31
       31
       -
               example = literalExpression "pkgs.journalbeat7";

     

       32
       31
        
               description = ''

     

       33
       32
        
                 The journalbeat package to use

     

       34
       33
        
               '';

     
···

       89
       88
        
           systemd.services.journalbeat = {

     

       90
       89
        
             description = "Journalbeat log shipper";

     

       91
       90
        
             wantedBy = [ "multi-user.target" ];

     

       91
       91
       +
             wants = [ "elasticsearch.service" ];

     

       92
       92
       +
             after = [ "elasticsearch.service" ];

     

       92
       93
        
             preStart = ''

     

       93
       94
        
               mkdir -p ${cfg.stateDir}/data

     

       94
       95
        
               mkdir -p ${cfg.stateDir}/logs

+69 -21

nixos/tests/elk.nix

···

       40
       40
        
       

     

       41
       41
        
                   services = {

     

       42
       42
        
       

     

       43
       43
       -
                     journalbeat = let lt6 = builtins.compareVersions

     

       44
       44
       -
                                               elk.journalbeat.version "6" < 0; in {

     

       45
       45
       -
                       enable = true;

     

       43
       43
       +
                     journalbeat = {

     

       44
       44
       +
                       enable = elk ? journalbeat;

     

       46
       45
        
                       package = elk.journalbeat;

     

       47
       46
        
                       extraConfig = pkgs.lib.mkOptionDefault (''

     

       48
       47
        
                         logging:

     
···

       51
       50
        
                           metrics.enabled: false

     

       52
       51
        
                         output.elasticsearch:

     

       53
       52
        
                           hosts: [ "127.0.0.1:9200" ]

     

       54
       54
       -
                           ${pkgs.lib.optionalString lt6 "template.enabled: false"}

     

       55
       55
       -
                       '' + pkgs.lib.optionalString (!lt6) ''

     

       56
       53
        
                         journalbeat.inputs:

     

       57
       54
        
                         - paths: []

     

       58
       55
        
                           seek: cursor

     

       59
       56
        
                       '');

     

       57
       57
       +
                     };

     

       58
       58
       +
       

     

       59
       59
       +
                     filebeat = {

     

       60
       60
       +
                       enable = elk ? filebeat;

     

       61
       61
       +
                       package = elk.filebeat;

     

       62
       62
       +
                       inputs.journald.id = "everything";

     

       63
       63
       +
       

     

       64
       64
       +
                       inputs.log = {

     

       65
       65
       +
                         enabled = true;

     

       66
       66
       +
                         paths = [

     

       67
       67
       +
                           "/var/lib/filebeat/test"

     

       68
       68
       +
                         ];

     

       69
       69
       +
                       };

     

       70
       70
       +
       

     

       71
       71
       +
                       settings = {

     

       72
       72
       +
                         logging.level = "info";

     

       73
       73
       +
                       };

     

       60
       74
        
                     };

     

       61
       75
        
       

     

       62
       76
        
                     metricbeat = {

     
···

       142
       156
        
             };

     

       143
       157
        
       

     

       144
       158
        
           passthru.elkPackages = elk;

     

       145
       145
       -
           testScript = ''

     

       159
       159
       +
           testScript =

     

       160
       160
       +
             let

     

       161
       161
       +
               valueObject = lib.optionalString (lib.versionAtLeast elk.elasticsearch.version "7") ".value";

     

       162
       162
       +
             in ''

     

       146
       163
        
             import json

     

       147
       164
        
       

     

       148
       165
        
       

     

       149
       149
       -
             def total_hits(message):

     

       166
       166
       +
             def expect_hits(message):

     

       150
       167
        
                 dictionary = {"query": {"match": {"message": message}}}

     

       151
       168
        
                 return (

     

       152
       152
       -
                     "curl --silent --show-error '${esUrl}/_search' "

     

       169
       169
       +
                     "curl --silent --show-error --fail-with-body '${esUrl}/_search' "

     

       153
       170
        
                     + "-H 'Content-Type: application/json' "

     

       154
       171
        
                     + "-d '{}' ".format(json.dumps(dictionary))

     

       155
       155
       -
                     + "| jq .hits.total"

     

       172
       172
       +
                     + " | tee /dev/console"

     

       173
       173
       +
                     + " | jq -es 'if . == [] then null else .[] | .hits.total${valueObject} > 0 end'"

     

       174
       174
       +
                 )

     

       175
       175
       +
       

     

       176
       176
       +
       

     

       177
       177
       +
             def expect_no_hits(message):

     

       178
       178
       +
                 dictionary = {"query": {"match": {"message": message}}}

     

       179
       179
       +
                 return (

     

       180
       180
       +
                     "curl --silent --show-error --fail-with-body '${esUrl}/_search' "

     

       181
       181
       +
                     + "-H 'Content-Type: application/json' "

     

       182
       182
       +
                     + "-d '{}' ".format(json.dumps(dictionary))

     

       183
       183
       +
                     + " | tee /dev/console"

     

       184
       184
       +
                     + " | jq -es 'if . == [] then null else .[] | .hits.total${valueObject} == 0 end'"

     

       156
       185
        
                 )

     

       157
       186
        
       

     

       158
       187
        
       

     

       159
       188
        
             def has_metricbeat():

     

       160
       189
        
                 dictionary = {"query": {"match": {"event.dataset": {"query": "system.cpu"}}}}

     

       161
       190
        
                 return (

     

       162
       162
       -
                     "curl --silent --show-error '${esUrl}/_search' "

     

       191
       191
       +
                     "curl --silent --show-error --fail-with-body '${esUrl}/_search' "

     

       163
       192
        
                     + "-H 'Content-Type: application/json' "

     

       164
       193
        
                     + "-d '{}' ".format(json.dumps(dictionary))

     

       165
       165
       -
                     + "| jq '.hits.total > 0'"

     

       194
       194
       +
                     + " | tee /dev/console"

     

       195
       195
       +
                     + " | jq -es 'if . == [] then null else .[] | .hits.total${valueObject} > 0 end'"

     

       166
       196
        
                 )

     

       167
       197
        
       

     

       168
       198
        
       

     
···

       178
       208
        
             # TODO: extend this test with multiple elasticsearch nodes

     

       179
       209
        
             #       and see if the status turns "green".

     

       180
       210
        
             one.wait_until_succeeds(

     

       181
       181
       -
                 "curl --silent --show-error '${esUrl}/_cluster/health' | jq .status | grep -v red"

     

       211
       211
       +
                 "curl --silent --show-error --fail-with-body '${esUrl}/_cluster/health'"

     

       212
       212
       +
                 + " | jq -es 'if . == [] then null else .[] | .status != \"red\" end'"

     

       182
       213
        
             )

     

       183
       214
        
       

     

       184
       215
        
             with subtest("Perform some simple logstash tests"):

     
···

       189
       220
        
             with subtest("Kibana is healthy"):

     

       190
       221
        
                 one.wait_for_unit("kibana.service")

     

       191
       222
        
                 one.wait_until_succeeds(

     

       192
       192
       -
                     "curl --silent --show-error 'http://localhost:5601/api/status' | jq .status.overall.state | grep green"

     

       223
       223
       +
                     "curl --silent --show-error --fail-with-body 'http://localhost:5601/api/status'"

     

       224
       224
       +
                     + " | jq -es 'if . == [] then null else .[] | .status.overall.state == \"green\" end'"

     

       193
       225
        
                 )

     

       194
       226
        
       

     

       195
       227
        
             with subtest("Metricbeat is running"):

     

       196
       228
        
                 one.wait_for_unit("metricbeat.service")

     

       197
       229
        
       

     

       198
       230
        
             with subtest("Metricbeat metrics arrive in elasticsearch"):

     

       199
       199
       -
                 one.wait_until_succeeds(has_metricbeat() + " | tee /dev/console | grep 'true'")

     

       231
       231
       +
                 one.wait_until_succeeds(has_metricbeat())

     

       200
       232
        
       

     

       201
       233
        
             with subtest("Logstash messages arive in elasticsearch"):

     

       202
       202
       -
                 one.wait_until_succeeds(total_hits("flowers") + " | grep -v 0")

     

       203
       203
       -
                 one.wait_until_succeeds(total_hits("dragons") + " | grep 0")

     

       234
       234
       +
                 one.wait_until_succeeds(expect_hits("flowers"))

     

       235
       235
       +
                 one.wait_until_succeeds(expect_no_hits("dragons"))

     

       204
       236
        
       

     

       237
       237
       +
           '' + lib.optionalString (elk ? journalbeat) ''

     

       205
       238
        
             with subtest(

     

       206
       239
        
                 "A message logged to the journal is ingested by elasticsearch via journalbeat"

     

       207
       240
        
             ):

     

       208
       241
        
                 one.wait_for_unit("journalbeat.service")

     

       209
       242
        
                 one.execute("echo 'Supercalifragilisticexpialidocious' | systemd-cat")

     

       210
       243
        
                 one.wait_until_succeeds(

     

       211
       211
       -
                     total_hits("Supercalifragilisticexpialidocious") + " | grep -v 0"

     

       244
       244
       +
                     expect_hits("Supercalifragilisticexpialidocious")

     

       245
       245
       +
                 )

     

       246
       246
       +
           '' + lib.optionalString (elk ? filebeat) ''

     

       247
       247
       +
             with subtest(

     

       248
       248
       +
                 "A message logged to the journal is ingested by elasticsearch via filebeat"

     

       249
       249
       +
             ):

     

       250
       250
       +
                 one.wait_for_unit("filebeat.service")

     

       251
       251
       +
                 one.execute("echo 'Superdupercalifragilisticexpialidocious' | systemd-cat")

     

       252
       252
       +
                 one.wait_until_succeeds(

     

       253
       253
       +
                     expect_hits("Superdupercalifragilisticexpialidocious")

     

       212
       254
        
                 )

     

       213
       213
       -
       

     

       255
       255
       +
                 one.execute(

     

       256
       256
       +
                     "echo 'SuperdupercalifragilisticexpialidociousIndeed' >> /var/lib/filebeat/test"

     

       257
       257
       +
                 )

     

       258
       258
       +
                 one.wait_until_succeeds(

     

       259
       259
       +
                     expect_hits("SuperdupercalifragilisticexpialidociousIndeed")

     

       260
       260
       +
                 )

     

       261
       261
       +
           '' + ''

     

       214
       262
        
             with subtest("Elasticsearch-curator works"):

     

       215
       263
        
                 one.systemctl("stop logstash")

     

       216
       264
        
                 one.systemctl("start elasticsearch-curator")

     

       217
       265
        
                 one.wait_until_succeeds(

     

       218
       218
       -
                     '! curl --silent --show-error "${esUrl}/_cat/indices" | grep logstash | grep ^'

     

       266
       266
       +
                     '! curl --silent --show-error --fail-with-body "${esUrl}/_cat/indices" | grep logstash | grep ^'

     

       219
       267
        
                 )

     

       220
       268
        
           '';

     

       221
       269
        
         }) { inherit pkgs system; };

     
···

       235
       283
        
         #   elasticsearch = pkgs.elasticsearch7-oss;

     

       236
       284
        
         #   logstash      = pkgs.logstash7-oss;

     

       237
       285
        
         #   kibana        = pkgs.kibana7-oss;

     

       238
       238
       -
         #   journalbeat   = pkgs.journalbeat7;

     

       286
       286
       +
         #   filebeat      = pkgs.filebeat7;

     

       239
       287
        
         #   metricbeat    = pkgs.metricbeat7;

     

       240
       288
        
         # };

     

       241
       289
        
         unfree = lib.dontRecurseIntoAttrs {

     
···

       250
       298
        
             elasticsearch = pkgs.elasticsearch7;

     

       251
       299
        
             logstash      = pkgs.logstash7;

     

       252
       300
        
             kibana        = pkgs.kibana7;

     

       253
       253
       -
             journalbeat   = pkgs.journalbeat7;

     

       301
       301
       +
             filebeat      = pkgs.filebeat7;

     

       254
       302
        
             metricbeat    = pkgs.metricbeat7;

     

       255
       303
        
           };

     

       256
       304
        
         };

+19 -8

nixos/tests/parsedmarc/default.nix

···

       4
       4
        
       { pkgs, ... }@args:

     

       5
       5
        
       let

     

       6
       6
        
         inherit (import ../../lib/testing-python.nix args) makeTest;

     

       7
       7
       +
         inherit (pkgs) lib;

     

       7
       8
        
       

     

       8
       9
        
         dmarcTestReport = builtins.fetchurl {

     

       9
       10
        
           name = "dmarc-test-report";

     
···

       54
       55
        
         localMail = makeTest

     

       55
       56
        
           {

     

       56
       57
        
             name = "parsedmarc-local-mail";

     

       57
       57
       -
             meta = with pkgs.lib.maintainers; {

     

       58
       58
       +
             meta = with lib.maintainers; {

     

       58
       59
        
               maintainers = [ talyz ];

     

       59
       60
        
             };

     

       60
       61
        
       

     
···

       83
       84
        
                   };

     

       84
       85
        
                 };

     

       85
       86
        
       

     

       86
       86
       -
                 services.elasticsearch.package = pkgs.elasticsearch7-oss;

     

       87
       87
       +
                 services.elasticsearch.package = pkgs.elasticsearch-oss;

     

       87
       88
        
       

     

       88
       89
        
                 environment.systemPackages = [

     

       89
       90
        
                   (sendEmail "dmarc@localhost")

     
···

       94
       95
        
             testScript = { nodes }:

     

       95
       96
        
               let

     

       96
       97
        
                 esPort = toString nodes.parsedmarc.config.services.elasticsearch.port;

     

       98
       98
       +
                 valueObject = lib.optionalString (lib.versionAtLeast nodes.parsedmarc.config.services.elasticsearch.package.version "7") ".value";

     

       97
       99
        
               in ''

     

       98
       100
        
                 parsedmarc.start()

     

       99
       101
        
                 parsedmarc.wait_for_unit("postfix.service")

     
···

       104
       106
        
                 )

     

       105
       107
        
       

     

       106
       108
        
                 parsedmarc.fail(

     

       107
       107
       -
                     "curl -sS -f http://localhost:${esPort}/_search?q=report_id:2940 | jq -e 'if .hits.total.value > 0 then true else null end'"

     

       109
       109
       +
                     "curl -sS -f http://localhost:${esPort}/_search?q=report_id:2940"

     

       110
       110
       +
                     + " | tee /dev/console"

     

       111
       111
       +
                     + " | jq -es 'if . == [] then null else .[] | .hits.total${valueObject} > 0 end'"

     

       108
       112
        
                 )

     

       109
       113
        
                 parsedmarc.succeed("send-email")

     

       110
       114
        
                 parsedmarc.wait_until_succeeds(

     

       111
       111
       -
                     "curl -sS -f http://localhost:${esPort}/_search?q=report_id:2940 | jq -e 'if .hits.total.value > 0 then true else null end'"

     

       115
       115
       +
                     "curl -sS -f http://localhost:${esPort}/_search?q=report_id:2940"

     

       116
       116
       +
                     + " | tee /dev/console"

     

       117
       117
       +
                     + " | jq -es 'if . == [] then null else .[] | .hits.total${valueObject} > 0 end'"

     

       112
       118
        
                 )

     

       113
       119
        
               '';

     

       114
       120
        
           };

     
···

       121
       127
        
           in

     

       122
       128
        
             makeTest {

     

       123
       129
        
               name = "parsedmarc-external-mail";

     

       124
       124
       -
               meta = with pkgs.lib.maintainers; {

     

       130
       130
       +
               meta = with lib.maintainers; {

     

       125
       131
        
                 maintainers = [ talyz ];

     

       126
       132
        
               };

     

       127
       133
        
       

     
···

       153
       159
        
                       };

     

       154
       160
        
                     };

     

       155
       161
        
       

     

       156
       156
       -
                     services.elasticsearch.package = pkgs.elasticsearch7-oss;

     

       162
       162
       +
                     services.elasticsearch.package = pkgs.elasticsearch-oss;

     

       157
       163
        
       

     

       158
       164
        
                     environment.systemPackages = [

     

       159
       165
        
                       pkgs.jq

     
···

       201
       207
        
               testScript = { nodes }:

     

       202
       208
        
                 let

     

       203
       209
        
                   esPort = toString nodes.parsedmarc.config.services.elasticsearch.port;

     

       210
       210
       +
                   valueObject = lib.optionalString (lib.versionAtLeast nodes.parsedmarc.config.services.elasticsearch.package.version "7") ".value";

     

       204
       211
        
                 in ''

     

       205
       212
        
                   mail.start()

     

       206
       213
        
                   mail.wait_for_unit("postfix.service")

     
···

       213
       220
        
                   )

     

       214
       221
        
       

     

       215
       222
        
                   parsedmarc.fail(

     

       216
       216
       -
                       "curl -sS -f http://localhost:${esPort}/_search?q=report_id:2940 | jq -e 'if .hits.total.value > 0 then true else null end'"

     

       223
       223
       +
                       "curl -sS -f http://localhost:${esPort}/_search?q=report_id:2940"

     

       224
       224
       +
                       + " | tee /dev/console"

     

       225
       225
       +
                       + " | jq -es 'if . == [] then null else .[] | .hits.total${valueObject} > 0 end'"

     

       217
       226
        
                   )

     

       218
       227
        
                   mail.succeed("send-email")

     

       219
       228
        
                   parsedmarc.wait_until_succeeds(

     

       220
       220
       -
                       "curl -sS -f http://localhost:${esPort}/_search?q=report_id:2940 | jq -e 'if .hits.total.value > 0 then true else null end'"

     

       229
       229
       +
                       "curl -sS -f http://localhost:${esPort}/_search?q=report_id:2940"

     

       230
       230
       +
                       + " | tee /dev/console"

     

       231
       231
       +
                       + " | jq -es 'if . == [] then null else .[] | .hits.total${valueObject} > 0 end'"

     

       221
       232
        
                   )

     

       222
       233
        
                 '';

     

       223
       234
        
             };

+4 -4

pkgs/development/tools/misc/kibana/6.x.nix

···

       18
       18
        
         shas =

     

       19
       19
        
           if enableUnfree

     

       20
       20
        
           then {

     

       21
       21
       -
             x86_64-linux  = "1xwklhqxk5rmdrgy2simwvijzq29kyq5w2w3hy53xh2i1zlnyvq3";

     

       22
       22
       -
             x86_64-darwin = "1qpdn28mrpggd55khzqqld6r89l0hb870rigxcw2i8p2yx3jv106";

     

       21
       21
       +
             x86_64-linux  = "1a501lavxhckb3l93sbrbqyshicwkk6p89frry4x8p037xcfpy0x";

     

       22
       22
       +
             x86_64-darwin = "0zm45af30shhcg3mdhcma6rms1hyrx62rm5jzwnz9kxv4d30skbw";

     

       23
       23
        
           }

     

       24
       24
        
           else {

     

       25
       25
       -
             x86_64-linux  = "1wpnwal2rq5v2bsp5qil9j6dplif7ql5394sy4ia5ghp2fzifxmf";

     

       26
       26
       -
             x86_64-darwin = "12z8i0wbw10c097glbpdy350p0h3957433f51qfx2p0ghgkzkhzv";

     

       25
       25
       +
             x86_64-linux  = "0wfdipf21apyily7mvlqgyc7m5jpr96zgrryzwa854z3xb2vw8zg";

     

       26
       26
       +
             x86_64-darwin = "1nklfx4yz6hsxlljvnvwjy7pncv9mzngl84710xad5jlyras3sdj";

     

       27
       27
        
           };

     

       28
       28
        
       

     

       29
       29
        
       in stdenv.mkDerivation rec {

+5 -5

pkgs/development/tools/misc/kibana/7.x.nix

···

       4
       4
        
       , stdenv

     

       5
       5
        
       , makeWrapper

     

       6
       6
        
       , fetchurl

     

       7
       7
       -
       , nodejs-14_x

     

       7
       7
       +
       , nodejs-16_x

     

       8
       8
        
       , coreutils

     

       9
       9
        
       , which

     

       10
       10
        
       }:

     

       11
       11
        
       

     

       12
       12
        
       with lib;

     

       13
       13
        
       let

     

       14
       14
       -
         nodejs = nodejs-14_x;

     

       14
       14
       +
         nodejs = nodejs-16_x;

     

       15
       15
        
         inherit (builtins) elemAt;

     

       16
       16
        
         info = splitString "-" stdenv.hostPlatform.system;

     

       17
       17
        
         arch = elemAt info 0;

     

       18
       18
        
         plat = elemAt info 1;

     

       19
       19
        
         shas =

     

       20
       20
        
           {

     

       21
       21
       -
             x86_64-linux  = "19p9s4sir982bb1zcldrbphhwfs9i11p0q28vgc421iqg10kjlf1";

     

       22
       22
       -
             x86_64-darwin = "0qq557ngwwakifidyrccga4cadj9k9pzhjwy4msmbcgf5pb86qyc";

     

       23
       23
       -
             aarch64-linux = "183cp1h8d3n7xfcpcys4hf36palczxa409afyp62kzyzckngy0j8";

     

       21
       21
       +
             x86_64-linux  = "0jivwsrq31n0qfznrsjfsn65sg3wpbd990afn2wzjnj4drq7plz6";

     

       22
       22
       +
             x86_64-darwin = "02483aqzrccq1x6rwznmcazijdd46yxj9vnbihnvp2xyp3w9as45";

     

       23
       23
       +
             aarch64-linux = "0iw155gkkl1hshc80lfj95rssg039ig21wz1l3srmmf2x4f934s9";

     

       24
       24
        
           };

     

       25
       25
        
       

     

       26
       26
        
       in stdenv.mkDerivation rec {

+1 -1

pkgs/misc/logging/beats/6.x.nix

···

       8
       8
        
               owner = "elastic";

     

       9
       9
        
               repo = "beats";

     

       10
       10
        
               rev = "v${version}";

     

       11
       11
       -
               sha256 = "0jkiz5dfdi9zsji04ipcmcj7pml9294v455y7s2c22k24gyzbaw8";

     

       11
       11
       +
               sha256 = "1vnw9clsc10cfpjf6vxvc6m507b2q17sgsl079iwqbp4v0286il7";

     

       12
       12
        
             };

     

       13
       13
        
       

     

       14
       14
        
             goPackagePath = "github.com/elastic/beats";

+10 -14

pkgs/misc/logging/beats/7.x.nix

···

       8
       8
        
           owner = "elastic";

     

       9
       9
        
           repo = "beats";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "0gjyzprgj9nskvlkm2bf125b7qn3608llz4kh1fyzsvrw6zb7sm8";

     

       11
       11
       +
           sha256 = "sha256-9Jl5Xo1iKdOY9ZE5JXKSL4ee+NdsN3KCY2dDYuxlzPI=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         vendorSha256 = "04cwf96fh60ld3ndjzzssgirc9ssb53yq71j6ksx36m3y1x7fq9c";

     

       14
       14
       +
         vendorSha256 = "sha256-tyxyM7RsTHTVVxc9gagPsSvFRaWGTmobKzyv9RODXBk=";

     

       15
       15
        
       

     

       16
       16
        
         subPackages = [ package ];

     

       17
       17
        
       

     
···

       24
       24
        
       } // extraArgs);

     

       25
       25
        
       in

     

       26
       26
        
       rec {

     

       27
       27
       -
         filebeat7 = beat "filebeat" { meta.description = "Lightweight shipper for logfiles"; };

     

       27
       27
       +
         filebeat7 = beat "filebeat" {

     

       28
       28
       +
           meta.description = "Lightweight shipper for logfiles";

     

       29
       29
       +
           buildInputs = [ systemd ];

     

       30
       30
       +
           tags = [ "withjournald" ];

     

       31
       31
       +
           postFixup = ''

     

       32
       32
       +
             patchelf --set-rpath ${lib.makeLibraryPath [ (lib.getLib systemd) ]} "$out/bin/filebeat"

     

       33
       33
       +
           '';

     

       34
       34
       +
         };

     

       28
       35
        
         heartbeat7 = beat "heartbeat" { meta.description = "Lightweight shipper for uptime monitoring"; };

     

       29
       36
        
         metricbeat7 = beat "metricbeat" {

     

       30
       37
        
           meta.description = "Lightweight shipper for metrics";

     
···

       46
       53
        
             your application processes, parse on the fly protocols like HTTP, MySQL,

     

       47
       54
        
             PostgreSQL, Redis or Thrift and correlate the messages into transactions.

     

       48
       55
        
           '';

     

       49
       49
       -
         };

     

       50
       50
       -
         journalbeat7 = beat "journalbeat" {

     

       51
       51
       -
           meta.description = ''

     

       52
       52
       -
             Journalbeat is an open source data collector to read and forward

     

       53
       53
       -
             journal entries from Linuxes with systemd.

     

       54
       54
       -
           '';

     

       55
       55
       -
           buildInputs = [ systemd.dev ];

     

       56
       56
       -
           postFixup = let libPath = lib.makeLibraryPath [ (lib.getLib systemd) ]; in

     

       57
       57
       -
             ''

     

       58
       58
       -
               patchelf --set-rpath ${libPath} "$out/bin/journalbeat"

     

       59
       59
       -
             '';

     

       60
       56
        
         };

     

       61
       57
        
       }

+2 -2

pkgs/servers/search/elasticsearch/6.x.nix

···

       19
       19
        
           url = "https://artifacts.elastic.co/downloads/elasticsearch/${pname}-${version}.tar.gz";

     

       20
       20
        
           sha256 =

     

       21
       21
        
             if enableUnfree

     

       22
       22
       -
             then "09dy3iyzk460vra6na6vk7d3mzpbv4cl0pl7kjmybxy947j7hh42"

     

       23
       23
       -
             else "0s04xz3j4psyhawvy503sp2nl5s0gswmpd9wfvwnavgcrr23wk39";

     

       22
       22
       +
             then "1hkcgqsrnnx3zjpgar4424mxfaxrx0zbrp7n7n0dlbhphshwnkmd"

     

       23
       23
       +
             else "1pglg60aigy31xmpfchnxcc04nd18zwc3av4m0kyp00yk5mnlyqm";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         patches = [ ./es-home-6.x.patch ];

+3 -3

pkgs/servers/search/elasticsearch/7.x.nix

···

       18
       18
        
         plat = elemAt info 1;

     

       19
       19
        
         shas =

     

       20
       20
        
           {

     

       21
       21
       -
             x86_64-linux  = "1ld7656b37l67vi4pyv0il865b168niqnbd4hzbvdnwrm35prp10";

     

       22
       22
       -
             x86_64-darwin = "11b180y11xw5q01l7aw6lyn15lp9ks8xmakjg1j7gp3z6c90hpn3";

     

       23
       23
       -
             aarch64-linux = "0s4ph79x17f90jk31wjwk259dk9dmhnmnkxdcn77m191wvf6m3wy";

     

       21
       21
       +
             x86_64-linux  = "1s16l95wc589cr69pfbgmkn9rkvxn6sd6jlbiqpm6p6iyxiaxd6c";

     

       22
       22
       +
             x86_64-darwin = "05h7pvq4pb816wgcymnfklp3w6sv54x6138v2infw5219dnk8pfs";

     

       23
       23
       +
             aarch64-linux = "0q4xnjzhlx1b2lkikca88qh9glfxaifsm419k2bxxlrfrx31zlkq";

     

       24
       24
        
           };

     

       25
       25
        
       in

     

       26
       26
        
       stdenv.mkDerivation rec {

+22 -22

pkgs/servers/search/elasticsearch/plugins.nix

···

       38
       38
        
           src = fetchurl {

     

       39
       39
        
             url = "https://artifacts.elastic.co/downloads/elasticsearch-plugins/${pluginName}/${pluginName}-${version}.zip";

     

       40
       40
        
             sha256 =

     

       41
       41
       -
               if version == "7.11.1" then "0mi6fmnjbqypa4n1w34dvlmyq793pz4wf1r5srcs7i84kkiddysy"

     

       42
       42
       -
               else if version == "6.8.3" then "0vbaqyj0lfy3ijl1c9h92b0nh605h5mjs57bk2zhycdvbw5sx2lv"

     

       41
       41
       +
               if version == "7.16.1" then "1sz858m9963xqr5kzjlwnq7k0a146rn60v6xijyfbp8y3brg618p"

     

       42
       42
       +
               else if version == "6.8.21" then "06b1pavyggzfp4wwdql0q9nm3r7i9px9cagp4yh4nhxhnk4w5fiq"

     

       43
       43
        
               else throw "unsupported version ${version} for plugin ${pluginName}";

     

       44
       44
        
           };

     

       45
       45
        
           meta = with lib; {

     
···

       55
       55
        
           src = fetchurl {

     

       56
       56
        
             url = "https://github.com/vhyza/elasticsearch-${pluginName}/releases/download/v${version}/elasticsearch-${pluginName}-${version}-plugin.zip";

     

       57
       57
        
             sha256 =

     

       58
       58
       -
               if version == "7.11.1" then "0r2k2ndgqiqh27lch8dbay1m09f00h5kjcan87chcvyf623l40a3"

     

       59
       59
       -
               else if version == "6.8.3" then "12bshvp01pp2lgwd0cn9l58axg8gdimsh4g9wfllxi1bdpv4cy53"

     

       58
       58
       +
               if version == "7.16.1" then "0yjy9yhw77lmalivxnmv2rq8fk93ddxszkk73lgmpffladx2ikir"

     

       59
       59
       +
               else if version == "6.8.21" then "0m80cn7vkcvk95v4pdmi6vk5ww7p01k0hj2iqb9g870vs6x2qjzv"

     

       60
       60
        
               else throw "unsupported version ${version} for plugin ${pluginName}";

     

       61
       61
        
           };

     

       62
       62
        
           meta = with lib; {

     
···

       72
       72
        
           src = fetchurl {

     

       73
       73
        
             url = "https://artifacts.elastic.co/downloads/elasticsearch-plugins/${pluginName}/${pluginName}-${version}.zip";

     

       74
       74
        
             sha256 =

     

       75
       75
       -
               if version == "7.11.1" then "10ln81zyf04qi9wv10mck8iz0xwfvwp4ni0hl1gkgvh44lf1n855"

     

       76
       76
       -
               else if version == "6.8.3" then "0ggdhf7w50bxsffmcznrjy14b578fps0f8arg3v54qvj94v9jc37"

     

       75
       75
       +
               if version == "7.16.1" then "1w5ndgffqzj5ijglmykifrk1jsgh7qwn8m7sbpiv0r7n3aayhz1x"

     

       76
       76
       +
               else if version == "6.8.21" then "07w8s4a5gvr9lzjzf629y8rx3kvs6zd1vl07ksw1paghp42yb354"

     

       77
       77
        
               else throw "unsupported version ${version} for plugin ${pluginName}";

     

       78
       78
        
           };

     

       79
       79
        
           meta = with lib; {

     
···

       89
       89
        
           src = fetchurl {

     

       90
       90
        
             url = "https://artifacts.elastic.co/downloads/elasticsearch-plugins/${pluginName}/${pluginName}-${version}.zip";

     

       91
       91
        
             sha256 =

     

       92
       92
       -
               if version == "7.11.1" then "09grfvqjmm2rznc48z84awh54afh81qa16amfqw3amsb8dr6czm6"

     

       93
       93
       -
               else if version == "6.8.3" then "0pmffz761dqjpvmkl7i7xsyw1iyyspqpddxp89rjsznfc9pak5im"

     

       92
       92
       +
               if version == "7.16.1" then "16mv7b9nl96bcygabvjqidxp2sjk340va19mrmliblpq3mxa2sii"

     

       93
       93
       +
               else if version == "6.8.21" then "1kdpbrasxwr3dn21zjrklp1s389rwa51fairygdwl8px9liwwfa5"

     

       94
       94
        
               else throw "unsupported version ${version} for plugin ${pluginName}";

     

       95
       95
        
           };

     

       96
       96
        
           meta = with lib; {

     
···

       106
       106
        
           src = fetchurl {

     

       107
       107
        
             url = "https://artifacts.elastic.co/downloads/elasticsearch-plugins/${pluginName}/${pluginName}-${version}.zip";

     

       108
       108
        
             sha256 =

     

       109
       109
       -
               if version == "7.11.1" then "0imkf3w2fmspb78vkf9k6kqx1crm4f82qgnbk1qa7gbsa2j47hbs"

     

       110
       110
       -
               else if version == "6.8.3" then "0kfr4i2rcwinjn31xrc2piicasjanaqcgnbif9xc7lnak2nnzmll"

     

       109
       109
       +
               if version == "7.16.1" then "0bf8f8cybsp6s2ai3j04yay9kbhsafpgxivxjvzn2iy9qgc84ls4"

     

       110
       110
       +
               else if version == "6.8.21" then "0v31yyhjcdlqnjw1f9kihh7z3c6d31whc57hqqd1dn579n4s9rlz"

     

       111
       111
        
               else throw "unsupported version ${version} for plugin ${pluginName}";

     

       112
       112
        
           };

     

       113
       113
        
           meta = with lib; {

     
···

       123
       123
        
           src = fetchurl {

     

       124
       124
        
             url = "https://artifacts.elastic.co/downloads/elasticsearch-plugins/${pluginName}/${pluginName}-${esVersion}.zip";

     

       125
       125
        
             sha256 =

     

       126
       126
       -
               if version == "7.11.1" then "0ahyb1plgwvq22id2kcx9g076ybb3kvybwakgcvsdjjdyi4cwgjs"

     

       127
       127
       -
               else if version == "6.8.3" then "1mm6hj2m1db68n81rzsvlw6nisflr5ikzk5zv9nmk0z641n5vh1x"

     

       126
       126
       +
               if version == "7.16.1" then "0sfa0ql3hh8jmha230dyhr51bvsvwmazyycf36ngpmxsysm8ccml"

     

       127
       127
       +
               else if version == "6.8.21" then "0sfh1az30q4f34zxig2fz8wn9gk53fmmxyg5pbi1svn9761p5awq"

     

       128
       128
        
               else throw "unsupported version ${version} for plugin ${pluginName}";

     

       129
       129
        
           };

     

       130
       130
        
           meta = with lib; {

     
···

       140
       140
        
           src = fetchurl {

     

       141
       141
        
             url = "https://artifacts.elastic.co/downloads/elasticsearch-plugins/${pluginName}/${pluginName}-${esVersion}.zip";

     

       142
       142
        
             sha256 =

     

       143
       143
       -
               if version == "7.11.1" then "0i98b905k1zwm3y9pfhr40v2fm5qdsp3icygibhxf7drffygk4l7"

     

       144
       144
       -
               else if version == "6.8.3" then "1s2klpvnhpkrk53p64zbga3b66czi7h1a13f58kfn2cn0zfavnbk"

     

       143
       143
       +
               if version == "7.16.1" then "1b95hjr4qhiavm7r7k19bwk5c64r00f1g5s0ydnb6gzym9hdb5s1"

     

       144
       144
       +
               else if version == "6.8.21" then "00lwj00rfdk6850gk1n86chiz2w6afpqn7jn588jdbwv41qh5mrv"

     

       145
       145
        
               else throw "unsupported version ${version} for plugin ${pluginName}";

     

       146
       146
        
           };

     

       147
       147
        
           meta = with lib; {

     
···

       157
       157
        
           pluginName = "search-guard";

     

       158
       158
        
           version =

     

       159
       159
        
             # https://docs.search-guard.com/latest/search-guard-versions

     

       160
       160
       -
             if esVersion == "7.11.1" then "${esVersion}-50.0.0"

     

       161
       161
       -
             else if esVersion == "6.8.3" then "${esVersion}-25.5"

     

       160
       160
       +
             if esVersion == "7.16.1" then "${esVersion}-52.5.0"

     

       161
       161
       +
             else if esVersion == "6.8.21" then "${esVersion}-25.6"

     

       162
       162
        
             else throw "unsupported version ${esVersion} for plugin ${pluginName}";

     

       163
       163
        
           src =

     

       164
       164
       -
             if esVersion == "7.11.1" then

     

       164
       164
       +
             if esVersion == "7.16.1" then

     

       165
       165
        
               fetchurl {

     

       166
       166
        
                 url = "https://maven.search-guard.com/search-guard-suite-release/com/floragunn/search-guard-suite-plugin/${version}/search-guard-suite-plugin-${version}.zip";

     

       167
       167
       -
                 sha256 = "1lippygiy0xcxxlakylhvj3bj2i681k6jcfjsprkfk7hlaqsqxkm";

     

       167
       167
       +
                 sha256 = "1m3nj35qyrkkh3mhmn66nippavima8h8qpaxddalhjsvf70lhnjb";

     

       168
       168
        
               }

     

       169
       169
       -
             else if esVersion == "6.8.3" then

     

       169
       169
       +
             else if esVersion == "6.8.21" then

     

       170
       170
        
               fetchurl {

     

       171
       171
       -
                 url = "mirror://maven/com/floragunn/${pluginName}-${majorVersion}/${version}/${pluginName}-${majorVersion}-${version}.zip";

     

       172
       172
       -
                 sha256 = "0a7ys9qinc0fjyka03cx9rv0pm7wnvslk234zv5vrphkrj52s1cb";

     

       171
       171
       +
                 url = "https://maven.search-guard.com/search-guard-release/com/floragunn/search-guard-6/${version}/search-guard-6-${version}.zip";

     

       172
       172
       +
                 sha256 = "19nj513wigwd0mzq747zax4fzvv5vi24f7j0636rydd9iv9cyhg2";

     

       173
       173
        
               }

     

       174
       174
        
             else throw "unsupported version ${version} for plugin ${pluginName}";

     

       175
       175
        
           meta = with lib; {

     

       176
       176
        
             homepage = "https://search-guard.com";

     

       177
       177
       -
             description = "Elasticsearch plugin that offers encryption, authentication, and authorisation. ";

     

       177
       177
       +
             description = "Elasticsearch plugin that offers encryption, authentication, and authorisation.";

     

       178
       178
        
             license = licenses.asl20;

     

       179
       179
        
           };

     

       180
       180
        
         };

+2 -2

pkgs/tools/misc/logstash/6.x.nix

···

       17
       17
        
           url = "https://artifacts.elastic.co/downloads/logstash/${pname}-${version}.tar.gz";

     

       18
       18
        
           sha256 =

     

       19
       19
        
             if enableUnfree

     

       20
       20
       -
             then "00pwi7clgdflzzg15bh3y30gzikvvy7p5fl88fww7xhhy47q8053"

     

       21
       21
       -
             else "0spxgqsyh72n0l0xh6rljp0lbqz46xmr02sqz25ybycr4qkxdhgk";

     

       20
       20
       +
             then "0hij1byw5b3xmk3vshr9p7gxwbjrywr7ylps05ydc2dmnz8q2a79"

     

       21
       21
       +
             else "1fa236pvhj7spys54nqi3k64rwzf6zi6gaccmqg4p4sh92jzsybv";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         dontBuild         = true;

+6 -6

pkgs/tools/misc/logstash/7.x.nix

···

       17
       17
        
         shas =

     

       18
       18
        
           if enableUnfree

     

       19
       19
        
           then {

     

       20
       20
       -
             x86_64-linux  = "0yjaki7gjffrz86hvqgn1gzhd9dc9llcj50g2x1sgpyn88zk0z0p";

     

       21
       21
       -
             x86_64-darwin = "0dqm66c89w1nvmbwqzphlqmf7avrycgv1nwd5b0k1z168fj0c3zm";

     

       22
       22
       -
             aarch64-linux = "11hjhyb48mjagmvqyxb780n57kr619h6p4adl2vs1zm97g9gslx8";

     

       20
       20
       +
             x86_64-linux  = "1vm53alq9q1qy2jcsjg9z339xrkac5r9qqpdafp53ny4zsv1n7vj";

     

       21
       21
       +
             x86_64-darwin = "0hhjyl04h3gd66rdk22272rj419br4v2i59lyrmaj6hmnsqbv968";

     

       22
       22
       +
             aarch64-linux = "0yjaki7gjffrz86hvqgn1gzhd9dc9llcj50g2x1sgpyn88zk0z0p";

     

       23
       23
        
           }

     

       24
       24
        
           else {

     

       25
       25
       -
             x86_64-linux  = "14b1649avjcalcsi0ffkgznq6d93qdk6m3j0i73mwfqka5d3dvy3";

     

       26
       26
       -
             x86_64-darwin = "0ypgdfklr5rxvsnc3czh231pa1z2h70366j1c6q5g64b3xnxpphs";

     

       27
       27
       -
             aarch64-linux = "01ainayr8fwwfix7dmxfhhmb23ji65dn4lbjwnj2w0pl0ym9h9w2";

     

       25
       25
       +
             x86_64-linux  = "1f3659vcgczm7v03q3fvsmp1ndp6wm3i7r2b2vbl4xq7hf9v7azk";

     

       26
       26
       +
             x86_64-darwin = "10zw9qc0lc0x9in0nkxc1aiazhyd69l8sya2ni46ivyyjwf0sqsn";

     

       27
       27
       +
             aarch64-linux = "1czhgmky2zf3mqykn5ww4257yfhd36mi4x6dq569ymly83pivf8v";

     

       28
       28
        
           };

     

       29
       29
        
         this = stdenv.mkDerivation rec {

     

       30
       30
        
           version = elk7Version;

pkgs/top-level/aliases.nix

···

       384
       384
        
         jbuilder = dune_1; # added 2018-09-09

     

       385
       385
        
         jikes = throw "jikes was deprecated on 2019-10-07: abandoned by upstream";

     

       386
       386
        
         joseki = apache-jena-fuseki; # added 2016-02-28

     

       387
       387
       +
         journalbeat7 = throw "journalbeat has been removed upstream. Use filebeat with the journald input instead.";

     

       387
       388
        
         jvmci8 = throw "graalvm8 and its tools were deprecated in favor of graalvm8-ce"; # added 2021-10-15

     

       388
       389
        
         json_glib = json-glib; # added 2018-02-25

     

       389
       390
        
         kafkacat = kcat; # added 2021-10-07

+3 -4

pkgs/top-level/all-packages.nix

···

       2140
       2140
        
           filebeat7

     

       2141
       2141
        
           heartbeat7

     

       2142
       2142
        
           metricbeat7

     

       2143
       2143
       -
           packetbeat7

     

       2144
       2144
       -
           journalbeat7;

     

       2143
       2143
       +
           packetbeat7;

     

       2145
       2144
        
       

     

       2146
       2145
        
         filebeat = filebeat6;

     

       2147
       2146
        
         heartbeat = heartbeat6;

     
···

       5000
       4999
        
       

     

       5001
       5000
        
         # The latest version used by elasticsearch, logstash, kibana and the the beats from elastic.

     

       5002
       5001
        
         # When updating make sure to update all plugins or they will break!

     

       5003
       5003
       -
         elk6Version = "6.8.3";

     

       5004
       5004
       -
         elk7Version = "7.11.1";

     

       5002
       5002
       +
         elk6Version = "6.8.21";

     

       5003
       5003
       +
         elk7Version = "7.16.1";

     

       5005
       5004
        
       

     

       5006
       5005
        
         elasticsearch6 = callPackage ../servers/search/elasticsearch/6.x.nix {

     

       5007
       5006
        
           util-linux = util-linuxMinimal;