commit dca7e827b31c80412b4c7008d5eca1065afa64f7 · pyrox.dev/nixpkgs

+1 -5

nixos/modules/services/databases/influxdb.nix

···

       93
       93
        
           };

     

       94
       94
        
         } cfg.extraConfig;

     

       95
       95
        
       

     

       96
       96
       -
         configFile = pkgs.runCommandLocal "config.toml" { } ''

     

       97
       97
       -
           ${pkgs.buildPackages.remarshal}/bin/remarshal -if json -of toml \

     

       98
       98
       -
             < ${pkgs.writeText "config.json" (builtins.toJSON configOptions)} \

     

       99
       99
       -
             > $out

     

       100
       100
       -
         '';

     

       96
       96
       +
         configFile = (pkgs.formats.toml {}).generate "config.toml" configOptions;

     

       101
       97
        
       in

     

       102
       98
        
       {

     

       103
       99

+4 -6

nixos/modules/services/development/athens.nix

···

       140
       140
        
           }

     

       141
       141
        
         );

     

       142
       142
        
       

     

       143
       143
       -
         configFile = pkgs.runCommandLocal "config.toml" { } ''

     

       144
       144
       -
           ${pkgs.buildPackages.jq}/bin/jq 'del(..|nulls)' \

     

       145
       145
       -
             < ${pkgs.writeText "config.json" (builtins.toJSON athensConfig)} | \

     

       146
       146
       -
           ${pkgs.buildPackages.remarshal}/bin/remarshal -if json -of toml \

     

       147
       147
       -
             > $out

     

       148
       148
       -
         '';

     

       143
       143
       +
         configFile = lib.pipe athensConfig [

     

       144
       144
       +
           (lib.filterAttrsRecursive (_k: v: v != null))

     

       145
       145
       +
           ((pkgs.formats.toml {}).generate "config.toml")

     

       146
       146
       +
         ];

     

       149
       147
        
       in

     

       150
       148
        
       {

     

       151
       149
        
         meta = {

+6 -4

nixos/modules/services/logging/promtail.nix

···

       2
       2
        
       let

     

       3
       3
        
         cfg = config.services.promtail;

     

       4
       4
        
       

     

       5
       5
       -
         prettyJSON = conf: pkgs.runCommandLocal "promtail-config.json" {} ''

     

       6
       6
       -
           echo '${builtins.toJSON conf}' | ${pkgs.buildPackages.jq}/bin/jq 'del(._module)' > $out

     

       7
       7
       -
         '';

     

       5
       5
       +
         format = pkgs.formats.json {};

     

       6
       6
       +
         prettyJSON = conf: with lib; pipe conf [

     

       7
       7
       +
           (flip removeAttrs [ "_module" ])

     

       8
       8
       +
           (format.generate "promtail-config.json")

     

       9
       9
       +
         ];

     

       8
       10
        
       

     

       9
       11
        
         allowSystemdJournal = cfg.configuration ? scrape_configs && lib.any (v: v ? journal) cfg.configuration.scrape_configs;

     

       10
       12
        
       

     
···

       20
       22
        
           enable = mkEnableOption "the Promtail ingresser";

     

       21
       23
        
       

     

       22
       24
        
           configuration = mkOption {

     

       23
       23
       -
             type = (pkgs.formats.json {}).type;

     

       25
       25
       +
             type = format.type;

     

       24
       26
        
             description = ''

     

       25
       27
        
               Specify the configuration for Promtail in Nix.

     

       26
       28
        
               This option will be ignored if `services.promtail.configFile` is defined.

+8 -12

nixos/modules/services/monitoring/thanos.nix

···

       28
       28
        
         cfg = config.services.thanos;

     

       29
       29
        
       

     

       30
       30
        
         nullOpt = type: description: mkOption {

     

       31
       31
       -
           type = types.nullOr type;

     

       31
       31
       +
           type = if type.check null then type else types.nullOr type;

     

       32
       32
        
           default = null;

     

       33
       33
        
           description = description;

     

       34
       34
        
         };

     
···

       85
       85
        
           };

     

       86
       86
        
         };

     

       87
       87
        
       

     

       88
       88
       -
         toYAML = name: attrs: pkgs.runCommand name {

     

       89
       89
       -
           preferLocalBuild = true;

     

       90
       90
       -
           json = builtins.toFile "${name}.json" (builtins.toJSON attrs);

     

       91
       91
       -
           nativeBuildInputs = [ pkgs.remarshal ];

     

       92
       92
       -
         } "json2yaml -i $json -o $out";

     

       88
       88
       +
         format = pkgs.formats.yaml {};

     

       93
       89
        
       

     

       94
       90
        
         thanos = cmd: "${cfg.package}/bin/thanos ${cmd}" +

     

       95
       91
        
           (let args = cfg.${cmd}.arguments;

     
···

       144
       140
        
               option = mkOption {

     

       145
       141
        
                 type = with types; nullOr str;

     

       146
       142
        
                 default = if cfg.tracing.config == null then null

     

       147
       147
       -
                           else toString (toYAML "tracing.yaml" cfg.tracing.config);

     

       143
       143
       +
                           else toString (format.generate "tracing.yaml" cfg.tracing.config);

     

       148
       144
        
                 defaultText = literalExpression ''

     

       149
       145
        
                   if config.services.thanos.<cmd>.tracing.config == null then null

     

       150
       150
       -
                   else toString (toYAML "tracing.yaml" config.services.thanos.<cmd>.tracing.config);

     

       146
       146
       +
                   else toString (format.generate "tracing.yaml" config.services.thanos.<cmd>.tracing.config);

     

       151
       147
        
                 '';

     

       152
       148
        
                 description = ''

     

       153
       149
        
                   Path to YAML file that contains tracing configuration.

     
···

       160
       156
        
             tracing.config =

     

       161
       157
        
               {

     

       162
       158
        
                 toArgs = _opt: _attrs: [];

     

       163
       163
       -
                 option = nullOpt types.attrs ''

     

       159
       159
       +
                 option = nullOpt format.type ''

     

       164
       160
        
                   Tracing configuration.

     

       165
       161
        
       

     

       166
       162
        
                   When not `null` the attribute set gets converted to

     
···

       209
       205
        
               option = mkOption {

     

       210
       206
        
                 type = with types; nullOr str;

     

       211
       207
        
                 default = if cfg.objstore.config == null then null

     

       212
       212
       -
                           else toString (toYAML "objstore.yaml" cfg.objstore.config);

     

       208
       208
       +
                           else toString (format.generate "objstore.yaml" cfg.objstore.config);

     

       213
       209
        
                 defaultText = literalExpression ''

     

       214
       210
        
                   if config.services.thanos.<cmd>.objstore.config == null then null

     

       215
       215
       -
                   else toString (toYAML "objstore.yaml" config.services.thanos.<cmd>.objstore.config);

     

       211
       211
       +
                   else toString (format.generate "objstore.yaml" config.services.thanos.<cmd>.objstore.config);

     

       216
       212
        
                 '';

     

       217
       213
        
                 description = ''

     

       218
       214
        
                   Path to YAML file that contains object store configuration.

     
···

       225
       221
        
             objstore.config =

     

       226
       222
        
               {

     

       227
       223
        
                 toArgs = _opt: _attrs: [];

     

       228
       228
       -
                 option = nullOpt types.attrs ''

     

       224
       224
       +
                 option = nullOpt format.type ''

     

       229
       225
        
                   Object store configuration.

     

       230
       226
        
       

     

       231
       227
        
                   When not `null` the attribute set gets converted to

+4 -21

nixos/modules/services/networking/ncdns.nix

···

       4
       4
        
         cfg  = cfgs.ncdns;

     

       5
       5
        
       

     

       6
       6
        
         dataDir  = "/var/lib/ncdns";

     

       7
       7
       -
         username = "ncdns";

     

       8
       7
        
       

     

       9
       9
       -
         valueType = with lib.types; oneOf [ int str bool path ]

     

       10
       10
       -
           // { description = "setting type (integer, string, bool or path)"; };

     

       11
       11
       -
       

     

       12
       12
       -
         configType = with lib.types; attrsOf (nullOr (either valueType configType))

     

       13
       13
       -
           // { description = ''

     

       14
       14
       -
                 ncdns.conf configuration type. The format consists of an

     

       15
       15
       -
                 attribute set of settings. Each setting can be either `null`,

     

       16
       16
       -
                 a value or an attribute set. The allowed values are integers,

     

       17
       17
       -
                 strings, booleans or paths.

     

       18
       18
       -
                '';

     

       19
       19
       -
              };

     

       20
       20
       -
       

     

       21
       21
       -
         configFile = pkgs.runCommand "ncdns.conf"

     

       22
       22
       -
           { json = builtins.toJSON cfg.settings;

     

       23
       23
       -
             passAsFile = [ "json" ];

     

       24
       24
       -
           }

     

       25
       25
       -
           "${pkgs.remarshal}/bin/json2toml < $jsonPath > $out";

     

       8
       8
       +
         format = pkgs.formats.toml {};

     

       26
       9
        
       

     

       27
       10
        
         defaultFiles = {

     

       28
       11
        
           public  = "${dataDir}/bit.key";

     
···

       35
       18
        
         needsKeygen = lib.all lib.id (lib.flip lib.mapAttrsToList cfg.dnssec.keys

     

       36
       19
        
           (n: v: v == lib.getAttr n defaultFiles));

     

       37
       20
        
       

     

       38
       38
       -
         mkDefaultAttrs = lib.mapAttrs (n: v: lib.mkDefault v);

     

       21
       21
       +
         mkDefaultAttrs = lib.mapAttrs (_n: v: lib.mkDefault v);

     

       39
       22
        
       

     

       40
       23
        
       in

     

       41
       24
        
       

     
···

       160
       143
        
             };

     

       161
       144
        
       

     

       162
       145
        
             settings = lib.mkOption {

     

       163
       163
       -
               type = configType;

     

       146
       146
       +
               type = format.type;

     

       164
       147
        
               default = { };

     

       165
       148
        
               example = lib.literalExpression ''

     

       166
       149
        
                 { # enable webserver

     
···

       257
       240
        
               User = "ncdns";

     

       258
       241
        
               StateDirectory = "ncdns";

     

       259
       242
        
               Restart = "on-failure";

     

       260
       260
       -
               ExecStart = "${pkgs.ncdns}/bin/ncdns -conf=${configFile}";

     

       243
       243
       +
               ExecStart = "${pkgs.ncdns}/bin/ncdns -conf=${format.generate "ncdns.conf" cfg.settings}";

     

       261
       244
        
             };

     

       262
       245
        
       

     

       263
       246
        
             preStart = lib.optionalString (cfg.dnssec.enable && needsKeygen) ''

+10 -40

nixos/modules/services/web-servers/traefik.nix

···

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
        
         cfg = config.services.traefik;

     

       7
       7
       -
         jsonValue = with types;

     

       8
       8
       -
           let

     

       9
       9
       -
             valueType = nullOr (oneOf [

     

       10
       10
       -
               bool

     

       11
       11
       -
               int

     

       12
       12
       -
               float

     

       13
       13
       -
               str

     

       14
       14
       -
               (lazyAttrsOf valueType)

     

       15
       15
       -
               (listOf valueType)

     

       16
       16
       -
             ]) // {

     

       17
       17
       -
               description = "JSON value";

     

       18
       18
       -
               emptyValue.value = { };

     

       19
       19
       -
             };

     

       20
       20
       -
           in valueType;

     

       7
       7
       +
       

     

       8
       8
       +
         format = pkgs.formats.toml {};

     

       9
       9
       +
       

     

       21
       10
        
         dynamicConfigFile = if cfg.dynamicConfigFile == null then

     

       22
       22
       -
           pkgs.runCommand "config.toml" {

     

       23
       23
       -
             buildInputs = [ pkgs.remarshal ];

     

       24
       24
       -
             preferLocalBuild = true;

     

       25
       25
       -
           } ''

     

       26
       26
       -
             remarshal -if json -of toml \

     

       27
       27
       -
               < ${

     

       28
       28
       -
                 pkgs.writeText "dynamic_config.json"

     

       29
       29
       -
                 (builtins.toJSON cfg.dynamicConfigOptions)

     

       30
       30
       -
               } \

     

       31
       31
       -
               > $out

     

       32
       32
       -
           ''

     

       11
       11
       +
           format.generate "config.toml" cfg.dynamicConfigOptions

     

       33
       12
        
         else

     

       34
       13
        
           cfg.dynamicConfigFile;

     

       14
       14
       +
       

     

       35
       15
        
         staticConfigFile = if cfg.staticConfigFile == null then

     

       36
       36
       -
           pkgs.runCommand "config.toml" {

     

       37
       37
       -
             buildInputs = [ pkgs.yj ];

     

       38
       38
       -
             preferLocalBuild = true;

     

       39
       39
       -
           } ''

     

       40
       40
       -
             yj -jt -i \

     

       41
       41
       -
               < ${

     

       42
       42
       -
                 pkgs.writeText "static_config.json" (builtins.toJSON

     

       43
       43
       -
                   (recursiveUpdate cfg.staticConfigOptions {

     

       44
       44
       -
                     providers.file.filename = "${dynamicConfigFile}";

     

       45
       45
       -
                   }))

     

       46
       46
       -
               } \

     

       47
       47
       -
               > $out

     

       48
       48
       -
           ''

     

       16
       16
       +
           format.generate "config.toml" (recursiveUpdate cfg.staticConfigOptions {

     

       17
       17
       +
             providers.file.filename = "${dynamicConfigFile}";

     

       18
       18
       +
           })

     

       49
       19
        
         else

     

       50
       20
        
           cfg.staticConfigFile;

     

       51
       21
        
       

     
···

       71
       41
        
             description = ''

     

       72
       42
        
               Static configuration for Traefik.

     

       73
       43
        
             '';

     

       74
       74
       -
             type = jsonValue;

     

       44
       44
       +
             type = format.type;

     

       75
       45
        
             default = { entryPoints.http.address = ":80"; };

     

       76
       46
        
             example = {

     

       77
       47
        
               entryPoints.web.address = ":8080";

     
···

       95
       65
        
             description = ''

     

       96
       66
        
               Dynamic configuration for Traefik.

     

       97
       67
        
             '';

     

       98
       98
       -
             type = jsonValue;

     

       68
       68
       +
             type = format.type;

     

       99
       69
        
             default = { };

     

       100
       70
        
             example = {

     

       101
       71
        
               http.routers.router1 = {