commit 3a63b54b2c51f3b1c961b6165cd973d9aa4ca760 · pyrox.dev/nixpkgs

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

···

       42
       42
        
       

     

       43
       43
        
       - [Szurubooru](https://github.com/rr-/szurubooru), an image board engine inspired by services such as Danbooru, dedicated for small and medium communities. Available as [services.szurubooru](#opt-services.szurubooru.enable).

     

       44
       44
        
       

     

       45
       45
       +
       - The [Neat IP Address Planner](https://spritelink.github.io/NIPAP/) (NIPAP) can now be enabled through [services.nipap.enable](#opt-services.nipap.enable).

     

       46
       46
       +
       

     

       45
       47
        
       - [nix-store-veritysetup](https://github.com/nikstur/nix-store-veritysetup-generator), a systemd generator to unlock the Nix Store as a dm-verity protected block device. Available as [boot.initrd.nix-store-veritysetup](options.html#opt-boot.initrd.nix-store-veritysetup.enable).

     

       46
       48
        
       

     

       47
       49
        
       - [SuiteNumérique Docs](https://github.com/suitenumerique/docs), a collaborative note taking, wiki and documentation web platform and alternative to Notion or Outline. Available as [services.lasuite-docs](#opt-services.lasuite-docs.enable).

nixos/modules/module-list.nix

···

       1618
       1618
        
         ./services/web-apps/nextjs-ollama-llm-ui.nix

     

       1619
       1619
        
         ./services/web-apps/nexus.nix

     

       1620
       1620
        
         ./services/web-apps/nifi.nix

     

       1621
       1621
       +
         ./services/web-apps/nipap.nix

     

       1621
       1622
        
         ./services/web-apps/node-red.nix

     

       1622
       1623
        
         ./services/web-apps/nostr-rs-relay.nix

     

       1623
       1624
        
         ./services/web-apps/ocis.nix

+331

nixos/modules/services/web-apps/nipap.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         config,

     

       3
       3
       +
         lib,

     

       4
       4
       +
         pkgs,

     

       5
       5
       +
         ...

     

       6
       6
       +
       }:

     

       7
       7
       +
       

     

       8
       8
       +
       let

     

       9
       9
       +
         cfg = config.services.nipap;

     

       10
       10
       +
         iniFmt = pkgs.formats.ini { };

     

       11
       11
       +
       

     

       12
       12
       +
         configFile = iniFmt.generate "nipap.conf" cfg.settings;

     

       13
       13
       +
       

     

       14
       14
       +
         defaultUser = "nipap";

     

       15
       15
       +
         defaultAuthBackend = "local";

     

       16
       16
       +
         dataDir = "/var/lib/nipap";

     

       17
       17
       +
       

     

       18
       18
       +
         defaultServiceConfig = {

     

       19
       19
       +
           WorkingDirectory = dataDir;

     

       20
       20
       +
           User = cfg.user;

     

       21
       21
       +
           Group = config.users.users."${cfg.user}".group;

     

       22
       22
       +
           Restart = "on-failure";

     

       23
       23
       +
           RestartSec = 30;

     

       24
       24
       +
         };

     

       25
       25
       +
       

     

       26
       26
       +
         escapedHost = host: if lib.hasInfix ":" host then "[${host}]" else host;

     

       27
       27
       +
       in

     

       28
       28
       +
       {

     

       29
       29
       +
         options.services.nipap = {

     

       30
       30
       +
           enable = lib.mkEnableOption "global Neat IP Address Planner (NIPAP) configuration";

     

       31
       31
       +
       

     

       32
       32
       +
           user = lib.mkOption {

     

       33
       33
       +
             type = lib.types.str;

     

       34
       34
       +
             description = "User to use for running NIPAP services.";

     

       35
       35
       +
             default = defaultUser;

     

       36
       36
       +
           };

     

       37
       37
       +
       

     

       38
       38
       +
           settings = lib.mkOption {

     

       39
       39
       +
             description = ''

     

       40
       40
       +
               Configuration options to set in /etc/nipap/nipap.conf.

     

       41
       41
       +
             '';

     

       42
       42
       +
       

     

       43
       43
       +
             default = { };

     

       44
       44
       +
       

     

       45
       45
       +
             type = lib.types.submodule {

     

       46
       46
       +
               freeformType = iniFmt.type;

     

       47
       47
       +
       

     

       48
       48
       +
               options = {

     

       49
       49
       +
                 nipapd = {

     

       50
       50
       +
                   listen = lib.mkOption {

     

       51
       51
       +
                     type = lib.types.str;

     

       52
       52
       +
                     default = "::1";

     

       53
       53
       +
                     description = "IP address to bind nipapd to.";

     

       54
       54
       +
                   };

     

       55
       55
       +
                   port = lib.mkOption {

     

       56
       56
       +
                     type = lib.types.port;

     

       57
       57
       +
                     default = 1337;

     

       58
       58
       +
                     description = "Port to bind nipapd to.";

     

       59
       59
       +
                   };

     

       60
       60
       +
       

     

       61
       61
       +
                   foreground = lib.mkOption {

     

       62
       62
       +
                     type = lib.types.bool;

     

       63
       63
       +
                     default = true;

     

       64
       64
       +
                     description = "Remain in foreground rather than forking to background.";

     

       65
       65
       +
                   };

     

       66
       66
       +
                   debug = lib.mkOption {

     

       67
       67
       +
                     type = lib.types.bool;

     

       68
       68
       +
                     default = false;

     

       69
       69
       +
                     description = "Enable debug logging.";

     

       70
       70
       +
                   };

     

       71
       71
       +
       

     

       72
       72
       +
                   db_host = lib.mkOption {

     

       73
       73
       +
                     type = lib.types.str;

     

       74
       74
       +
                     default = "";

     

       75
       75
       +
                     description = "PostgreSQL host to connect to. Empty means use UNIX socket.";

     

       76
       76
       +
                   };

     

       77
       77
       +
                   db_name = lib.mkOption {

     

       78
       78
       +
                     type = lib.types.str;

     

       79
       79
       +
                     default = cfg.user;

     

       80
       80
       +
                     defaultText = defaultUser;

     

       81
       81
       +
                     description = "Name of database to use on PostgreSQL server.";

     

       82
       82
       +
                   };

     

       83
       83
       +
                 };

     

       84
       84
       +
       

     

       85
       85
       +
                 auth = {

     

       86
       86
       +
                   default_backend = lib.mkOption {

     

       87
       87
       +
                     type = lib.types.str;

     

       88
       88
       +
                     default = defaultAuthBackend;

     

       89
       89
       +
                     description = "Name of auth backend to use by default.";

     

       90
       90
       +
                   };

     

       91
       91
       +
                   auth_cache_timeout = lib.mkOption {

     

       92
       92
       +
                     type = lib.types.int;

     

       93
       93
       +
                     default = 3600;

     

       94
       94
       +
                     description = "Seconds to store cached auth entries for.";

     

       95
       95
       +
                   };

     

       96
       96
       +
                 };

     

       97
       97
       +
               };

     

       98
       98
       +
             };

     

       99
       99
       +
           };

     

       100
       100
       +
       

     

       101
       101
       +
           authBackendSettings = lib.mkOption {

     

       102
       102
       +
             description = ''

     

       103
       103
       +
               auth.backends options to set in /etc/nipap/nipap.conf.

     

       104
       104
       +
             '';

     

       105
       105
       +
       

     

       106
       106
       +
             default = {

     

       107
       107
       +
               "${defaultAuthBackend}" = {

     

       108
       108
       +
                 type = "SqliteAuth";

     

       109
       109
       +
                 db_path = "${dataDir}/local_auth.db";

     

       110
       110
       +
               };

     

       111
       111
       +
             };

     

       112
       112
       +
       

     

       113
       113
       +
             type = lib.types.submodule {

     

       114
       114
       +
               freeformType = iniFmt.type;

     

       115
       115
       +
             };

     

       116
       116
       +
           };

     

       117
       117
       +
       

     

       118
       118
       +
           nipapd = {

     

       119
       119
       +
             enable = lib.mkEnableOption "nipapd server";

     

       120
       120
       +
             package = lib.mkPackageOption pkgs "nipap" { };

     

       121
       121
       +
       

     

       122
       122
       +
             database.createLocally = lib.mkOption {

     

       123
       123
       +
               type = lib.types.bool;

     

       124
       124
       +
               default = true;

     

       125
       125
       +
               description = "Create a nipap database automatically.";

     

       126
       126
       +
             };

     

       127
       127
       +
           };

     

       128
       128
       +
       

     

       129
       129
       +
           nipap-www = {

     

       130
       130
       +
             enable = lib.mkEnableOption "nipap-www server";

     

       131
       131
       +
             package = lib.mkPackageOption pkgs "nipap-www" { };

     

       132
       132
       +
       

     

       133
       133
       +
             xmlrpcURIFile = lib.mkOption {

     

       134
       134
       +
               type = lib.types.nullOr lib.types.path;

     

       135
       135
       +
               default = null;

     

       136
       136
       +
               description = "Path to file containing XMLRPC URI for use by web UI - this is a secret, since it contains auth credentials. If null, it will be initialized assuming that the auth database is local.";

     

       137
       137
       +
             };

     

       138
       138
       +
       

     

       139
       139
       +
             workers = lib.mkOption {

     

       140
       140
       +
               type = lib.types.int;

     

       141
       141
       +
               default = 4;

     

       142
       142
       +
               description = "Number of worker processes for Gunicorn to fork.";

     

       143
       143
       +
             };

     

       144
       144
       +
             umask = lib.mkOption {

     

       145
       145
       +
               type = lib.types.str;

     

       146
       146
       +
               default = "0";

     

       147
       147
       +
               description = "umask for files written by Gunicorn, including UNIX socket.";

     

       148
       148
       +
             };

     

       149
       149
       +
       

     

       150
       150
       +
             unixSocket = lib.mkOption {

     

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

     

       152
       152
       +
               default = null;

     

       153
       153
       +
               description = "Path to UNIX socket to bind to.";

     

       154
       154
       +
               example = "/run/nipap/nipap-www.sock";

     

       155
       155
       +
             };

     

       156
       156
       +
             host = lib.mkOption {

     

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

     

       158
       158
       +
               default = "::";

     

       159
       159
       +
               description = "Host to bind to.";

     

       160
       160
       +
             };

     

       161
       161
       +
             port = lib.mkOption {

     

       162
       162
       +
               type = lib.types.nullOr lib.types.port;

     

       163
       163
       +
               default = 21337;

     

       164
       164
       +
               description = "Port to bind to.";

     

       165
       165
       +
             };

     

       166
       166
       +
           };

     

       167
       167
       +
         };

     

       168
       168
       +
       

     

       169
       169
       +
         config = lib.mkIf cfg.enable (

     

       170
       170
       +
           lib.mkMerge [

     

       171
       171
       +
             {

     

       172
       172
       +
               systemd.tmpfiles.rules = [

     

       173
       173
       +
                 "d '${dataDir}' - ${cfg.user} ${config.users.users."${cfg.user}".group} - -"

     

       174
       174
       +
               ];

     

       175
       175
       +
       

     

       176
       176
       +
               environment.etc."nipap/nipap.conf" = {

     

       177
       177
       +
                 source = configFile;

     

       178
       178
       +
               };

     

       179
       179
       +
       

     

       180
       180
       +
               services.nipap.settings = lib.attrsets.mapAttrs' (name: value: {

     

       181
       181
       +
                 name = "auth.backends.${name}";

     

       182
       182
       +
                 inherit value;

     

       183
       183
       +
               }) cfg.authBackendSettings;

     

       184
       184
       +
       

     

       185
       185
       +
               services.nipap.nipapd.enable = lib.mkDefault true;

     

       186
       186
       +
               services.nipap.nipap-www.enable = lib.mkDefault true;

     

       187
       187
       +
       

     

       188
       188
       +
               environment.systemPackages = [

     

       189
       189
       +
                 cfg.nipapd.package

     

       190
       190
       +
               ];

     

       191
       191
       +
             }

     

       192
       192
       +
             (lib.mkIf (cfg.user == defaultUser) {

     

       193
       193
       +
               users.users."${defaultUser}" = {

     

       194
       194
       +
                 isSystemUser = true;

     

       195
       195
       +
                 group = defaultUser;

     

       196
       196
       +
                 home = dataDir;

     

       197
       197
       +
               };

     

       198
       198
       +
               users.groups."${defaultUser}" = { };

     

       199
       199
       +
             })

     

       200
       200
       +
             (lib.mkIf (cfg.nipapd.enable && cfg.nipapd.database.createLocally) {

     

       201
       201
       +
               services.postgresql = {

     

       202
       202
       +
                 enable = true;

     

       203
       203
       +
                 extensions = ps: with ps; [ ip4r ];

     

       204
       204
       +
                 ensureUsers = [

     

       205
       205
       +
                   {

     

       206
       206
       +
                     name = cfg.user;

     

       207
       207
       +
                   }

     

       208
       208
       +
                 ];

     

       209
       209
       +
                 ensureDatabases = [ cfg.settings.nipapd.db_name ];

     

       210
       210
       +
               };

     

       211
       211
       +
       

     

       212
       212
       +
               systemd.services.postgresql.serviceConfig.ExecStartPost =

     

       213
       213
       +
                 let

     

       214
       214
       +
                   sqlFile = pkgs.writeText "nipapd-setup.sql" ''

     

       215
       215
       +
                     CREATE EXTENSION IF NOT EXISTS ip4r;

     

       216
       216
       +
       

     

       217
       217
       +
                     ALTER SCHEMA public OWNER TO "${cfg.user}";

     

       218
       218
       +
                     ALTER DATABASE "${cfg.settings.nipapd.db_name}" OWNER TO "${cfg.user}";

     

       219
       219
       +
                   '';

     

       220
       220
       +
                 in

     

       221
       221
       +
                 [

     

       222
       222
       +
                   ''

     

       223
       223
       +
                     ${lib.getExe' config.services.postgresql.finalPackage "psql"} -d "${cfg.settings.nipapd.db_name}" -f "${sqlFile}"

     

       224
       224
       +
                   ''

     

       225
       225
       +
                 ];

     

       226
       226
       +
             })

     

       227
       227
       +
             (lib.mkIf cfg.nipapd.enable {

     

       228
       228
       +
               systemd.services.nipapd =

     

       229
       229
       +
                 let

     

       230
       230
       +
                   pkg = cfg.nipapd.package;

     

       231
       231
       +
                 in

     

       232
       232
       +
                 {

     

       233
       233
       +
                   description = "Neat IP Address Planner";

     

       234
       234
       +
                   after = [

     

       235
       235
       +
                     "network.target"

     

       236
       236
       +
                     "systemd-tmpfiles-setup.service"

     

       237
       237
       +
                   ] ++ lib.optional (cfg.settings.nipapd.db_host == "") "postgresql.service";

     

       238
       238
       +
                   requires = lib.optional (cfg.settings.nipapd.db_host == "") "postgresql.service";

     

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

     

       240
       240
       +
                   preStart = lib.optionalString (cfg.settings.auth.default_backend == defaultAuthBackend) ''

     

       241
       241
       +
                     # Create/upgrade local auth database

     

       242
       242
       +
                     umask 077

     

       243
       243
       +
                     ${pkg}/bin/nipap-passwd create-database >/dev/null 2>&1

     

       244
       244
       +
                     ${pkg}/bin/nipap-passwd upgrade-database >/dev/null 2>&1

     

       245
       245
       +
                   '';

     

       246
       246
       +
                   serviceConfig = defaultServiceConfig // {

     

       247
       247
       +
                     KillSignal = "SIGINT";

     

       248
       248
       +
                     ExecStart = ''

     

       249
       249
       +
                       ${pkg}/bin/nipapd \

     

       250
       250
       +
                         --auto-install-db \

     

       251
       251
       +
                         --auto-upgrade-db \

     

       252
       252
       +
                         --foreground \

     

       253
       253
       +
                         --no-pid-file

     

       254
       254
       +
                     '';

     

       255
       255
       +
                   };

     

       256
       256
       +
                 };

     

       257
       257
       +
             })

     

       258
       258
       +
             (lib.mkIf cfg.nipap-www.enable {

     

       259
       259
       +
               assertions = [

     

       260
       260
       +
                 {

     

       261
       261
       +
                   assertion =

     

       262
       262
       +
                     cfg.nipap-www.xmlrpcURIFile == null -> cfg.settings.auth.default_backend == defaultAuthBackend;

     

       263
       263
       +
                   message = "If no XMLRPC URI secret file is specified, then the default auth backend must be in use to automatically generate credentials.";

     

       264
       264
       +
                 }

     

       265
       265
       +
               ];

     

       266
       266
       +
       

     

       267
       267
       +
               # Ensure that _something_ exists in the [www] group.

     

       268
       268
       +
               services.nipap.settings.www = lib.mkDefault { };

     

       269
       269
       +
       

     

       270
       270
       +
               systemd.services.nipap-www =

     

       271
       271
       +
                 let

     

       272
       272
       +
                   pkg = cfg.nipap-www.package;

     

       273
       273
       +
                 in

     

       274
       274
       +
                 {

     

       275
       275
       +
                   description = "Neat IP Address Planner web server";

     

       276
       276
       +
                   after = [

     

       277
       277
       +
                     "network.target"

     

       278
       278
       +
                     "systemd-tmpfiles-setup.service"

     

       279
       279
       +
                   ] ++ lib.optional cfg.nipapd.enable "nipapd.service";

     

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

     

       281
       281
       +
                   environment = {

     

       282
       282
       +
                     PYTHONPATH = pkg.pythonPath;

     

       283
       283
       +
                   };

     

       284
       284
       +
                   serviceConfig = defaultServiceConfig;

     

       285
       285
       +
                   script =

     

       286
       286
       +
                     let

     

       287
       287
       +
                       bind =

     

       288
       288
       +
                         if cfg.nipap-www.unixSocket != null then

     

       289
       289
       +
                           "unix:${cfg.nipap-www.unixSocket}"

     

       290
       290
       +
                         else

     

       291
       291
       +
                           "${escapedHost cfg.nipap-www.host}:${toString cfg.nipap-www.port}";

     

       292
       292
       +
                       generateXMLRPC = cfg.nipap-www.xmlrpcURIFile == null;

     

       293
       293
       +
                       xmlrpcURIFile = if generateXMLRPC then "${dataDir}/www_xmlrpc_uri" else cfg.nipap-www.xmlrpcURIFile;

     

       294
       294
       +
                     in

     

       295
       295
       +
                     ''

     

       296
       296
       +
                       test -f "${dataDir}/www_secret" || {

     

       297
       297
       +
                         umask 0077

     

       298
       298
       +
                         ${pkg.python}/bin/python -c "import secrets; print(secrets.token_hex())" > "${dataDir}/www_secret"

     

       299
       299
       +
                       }

     

       300
       300
       +
                       export FLASK_SECRET_KEY="$(cat "${dataDir}/www_secret")"

     

       301
       301
       +
       

     

       302
       302
       +
                       # Ensure that we have an XMLRPC URI.

     

       303
       303
       +
                       ${

     

       304
       304
       +
                         if generateXMLRPC then

     

       305
       305
       +
                           ''

     

       306
       306
       +
                             test -f "${dataDir}/www_xmlrpc_uri" || {

     

       307
       307
       +
                               umask 0077

     

       308
       308
       +
                               www_password="$(${pkg.python}/bin/python -c "import secrets; print(secrets.token_hex())")"

     

       309
       309
       +
                               ${cfg.nipapd.package}/bin/nipap-passwd add --username nipap-www --password "''${www_password}" --name "User account for the web UI" --trusted

     

       310
       310
       +
       

     

       311
       311
       +
                               echo "http://nipap-www@${defaultAuthBackend}:''${www_password}@${escapedHost cfg.settings.nipapd.listen}:${toString cfg.settings.nipapd.port}" > "${xmlrpcURIFile}"

     

       312
       312
       +
                             }

     

       313
       313
       +
                           ''

     

       314
       314
       +
                         else

     

       315
       315
       +
                           ""

     

       316
       316
       +
                       }

     

       317
       317
       +
                       export FLASK_XMLRPC_URI="$(cat "${xmlrpcURIFile}")"

     

       318
       318
       +
       

     

       319
       319
       +
                       exec "${pkg.gunicorn}/bin/gunicorn" \

     

       320
       320
       +
                         --preload --workers ${toString cfg.nipap-www.workers} \

     

       321
       321
       +
                         --pythonpath "${pkg}/${pkg.python.sitePackages}" \

     

       322
       322
       +
                         --bind ${bind} --umask ${cfg.nipap-www.umask} \

     

       323
       323
       +
                         "nipapwww:create_app()"

     

       324
       324
       +
                     '';

     

       325
       325
       +
                 };

     

       326
       326
       +
             })

     

       327
       327
       +
           ]

     

       328
       328
       +
         );

     

       329
       329
       +
       

     

       330
       330
       +
         meta.maintainers = with lib.maintainers; [ lukegb ];

     

       331
       331
       +
       }

nixos/tests/all-tests.nix

···

       946
       946
        
         nginx-unix-socket = runTest ./nginx-unix-socket.nix;

     

       947
       947
        
         nginx-variants = import ./nginx-variants.nix { inherit pkgs runTest; };

     

       948
       948
        
         nifi = runTestOn [ "x86_64-linux" ] ./web-apps/nifi.nix;

     

       949
       949
       +
         nipap = runTest ./web-apps/nipap.nix;

     

       949
       950
        
         nitter = runTest ./nitter.nix;

     

       950
       951
        
         nix-config = runTest ./nix-config.nix;

     

       951
       952
        
         nix-ld = runTest ./nix-ld.nix;

+69

nixos/tests/web-apps/nipap.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         nipapRc = pkgs.writeText "nipaprc" ''

     

       5
       5
       +
           [global]

     

       6
       6
       +
           hostname = [::1]

     

       7
       7
       +
           port = 1337

     

       8
       8
       +
           username = nixostest

     

       9
       9
       +
           password = nIx0st3st

     

       10
       10
       +
           default_vrf_rt = -

     

       11
       11
       +
           default_list_vrf_rt = all

     

       12
       12
       +
         '';

     

       13
       13
       +
       in

     

       14
       14
       +
       {

     

       15
       15
       +
         name = "lukegb";

     

       16
       16
       +
         meta.maintainers = [ lib.maintainers.lukegb ];

     

       17
       17
       +
       

     

       18
       18
       +
         nodes.main =

     

       19
       19
       +
           { ... }:

     

       20
       20
       +
           {

     

       21
       21
       +
             services.nipap = {

     

       22
       22
       +
               enable = true;

     

       23
       23
       +
             };

     

       24
       24
       +
       

     

       25
       25
       +
             environment.systemPackages = [

     

       26
       26
       +
               pkgs.nipap-cli

     

       27
       27
       +
             ];

     

       28
       28
       +
           };

     

       29
       29
       +
       

     

       30
       30
       +
         testScript = ''

     

       31
       31
       +
           main.wait_for_unit("nipapd.service")

     

       32
       32
       +
           main.wait_for_unit("nipap-www.service")

     

       33
       33
       +
       

     

       34
       34
       +
           # Make sure the web UI is up.

     

       35
       35
       +
           main.wait_for_open_port(21337)

     

       36
       36
       +
           main.succeed("curl -fvvv -Ls http://localhost:21337/ | grep 'NIPAP'")

     

       37
       37
       +
       

     

       38
       38
       +
           # Check that none of the files we created in /var/lib/nipap are readable.

     

       39
       39
       +
           out = main.succeed("ls -l /var/lib/nipap")

     

       40
       40
       +
           bad_perms = False

     

       41
       41
       +
           for ln in out.split("\n"):

     

       42
       42
       +
               ln = ln.strip()

     

       43
       43
       +
               if not ln or ln.startswith('total '):

     

       44
       44
       +
                   continue

     

       45
       45
       +
               if not ln.startswith('-rw------- '):

     

       46
       46
       +
                   print(f"Bad file permissions: {ln}")

     

       47
       47
       +
                   bad_perms = True

     

       48
       48
       +
           if bad_perms:

     

       49
       49
       +
               t.fail("One or more files were overly permissive.")

     

       50
       50
       +
       

     

       51
       51
       +
           # Check we created a web-frontend user.

     

       52
       52
       +
           main.succeed("nipap-passwd list | grep nipap-www")

     

       53
       53
       +
       

     

       54
       54
       +
           # Create a test user

     

       55
       55
       +
           main.succeed("nipap-passwd add -u nixostest -p nIx0st3st -n 'NixOS Test User'")

     

       56
       56
       +
       

     

       57
       57
       +
           # Try to log in with it on the web frontend

     

       58
       58
       +
           main.succeed("curl -fvvv -Ls -b \"\" -d username=nixostest -d password=nIx0st3st http://localhost:21337/auth/login | grep 'PrefixListController'")

     

       59
       59
       +
       

     

       60
       60
       +
           # Try to log in with it using the CLI

     

       61
       61
       +
           main.copy_from_host("${nipapRc}", "/root/.nipaprc")

     

       62
       62
       +
           main.succeed("chmod u=rw,go= /root/.nipaprc")

     

       63
       63
       +
           main.succeed("nipap address add prefix 192.0.2.0/24 type assignment description RFC1166")

     

       64
       64
       +
           main.succeed("nipap address add prefix 192.0.2.1/32 type host description 'test host'")

     

       65
       65
       +
           main.succeed("nipap address add prefix 2001:db8::/32 type reservation description RFC3849")

     

       66
       66
       +
           main.succeed("nipap address add prefix 2001:db8:f00f::/48 type assignment description 'eye pee vee six'")

     

       67
       67
       +
           main.succeed("nipap address add prefix 2001:db8:f00f:face:dead:beef:cafe:feed/128 type host description 'test host 2'")

     

       68
       68
       +
         '';

     

       69
       69
       +
       }

+56

pkgs/by-name/ni/nipap-cli/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         python312Packages,

     

       4
       4
       +
         nixosTests,

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       let

     

       8
       8
       +
         python3Packages = python312Packages;

     

       9
       9
       +
       in

     

       10
       10
       +
       python3Packages.buildPythonApplication rec {

     

       11
       11
       +
         pname = "nipap-cli";

     

       12
       12
       +
         inherit (python3Packages.nipap) version src;

     

       13
       13
       +
         pyproject = true;

     

       14
       14
       +
       

     

       15
       15
       +
         sourceRoot = "${src.name}/nipap-cli";

     

       16
       16
       +
       

     

       17
       17
       +
         postPatch = ''

     

       18
       18
       +
           substituteInPlace pyproject.toml \

     

       19
       19
       +
             --replace-fail 'docutils==0.20.1' 'docutils'

     

       20
       20
       +
         '';

     

       21
       21
       +
       

     

       22
       22
       +
         build-system = with python3Packages; [

     

       23
       23
       +
           setuptools

     

       24
       24
       +
           docutils

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         dependencies = with python3Packages; [

     

       28
       28
       +
           ipy

     

       29
       29
       +
           pynipap

     

       30
       30
       +
         ];

     

       31
       31
       +
       

     

       32
       32
       +
         checkInputs = with python3Packages; [

     

       33
       33
       +
           pythonImportsCheckHook

     

       34
       34
       +
         ];

     

       35
       35
       +
         pythonImportsCheck = [

     

       36
       36
       +
           "nipap_cli.nipap_cli"

     

       37
       37
       +
         ];

     

       38
       38
       +
       

     

       39
       39
       +
         passthru.tests.nixos = nixosTests.nipap;

     

       40
       40
       +
       

     

       41
       41
       +
         meta = {

     

       42
       42
       +
           description = "Neat IP Address Planner CLI";

     

       43
       43
       +
           longDescription = ''

     

       44
       44
       +
             NIPAP is the best open source IPAM in the known universe,

     

       45
       45
       +
             challenging classical IP address management (IPAM) systems in many areas.

     

       46
       46
       +
           '';

     

       47
       47
       +
           homepage = "https://github.com/SpriteLink/NIPAP";

     

       48
       48
       +
           changelog = "https://github.com/SpriteLink/NIPAP/releases/tag/v${version}";

     

       49
       49
       +
           license = lib.licenses.mit;

     

       50
       50
       +
           maintainers = with lib.maintainers; [

     

       51
       51
       +
             lukegb

     

       52
       52
       +
           ];

     

       53
       53
       +
           platforms = lib.platforms.all;

     

       54
       54
       +
           mainProgram = "nipap";

     

       55
       55
       +
         };

     

       56
       56
       +
       }

+53

pkgs/by-name/ni/nipap-www/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         python3Packages,

     

       4
       4
       +
         nixosTests,

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       python3Packages.buildPythonApplication rec {

     

       8
       8
       +
         pname = "nipap-www";

     

       9
       9
       +
         inherit (python3Packages.nipap) version src;

     

       10
       10
       +
         pyproject = true;

     

       11
       11
       +
       

     

       12
       12
       +
         sourceRoot = "${src.name}/nipap-www";

     

       13
       13
       +
       

     

       14
       14
       +
         postPatch = ''

     

       15
       15
       +
           # Load Flask config additionally from FLASK_ environment variables.

     

       16
       16
       +
           # This makes providing secrets easier.

     

       17
       17
       +
           sed -i nipapwww/__init__.py \

     

       18
       18
       +
             -e '/^\s*app =/a\    app.config.from_prefixed_env()'

     

       19
       19
       +
         '';

     

       20
       20
       +
       

     

       21
       21
       +
         pythonRelaxDeps = true; # deps are tightly specified

     

       22
       22
       +
       

     

       23
       23
       +
         build-system = with python3Packages; [

     

       24
       24
       +
           setuptools

     

       25
       25
       +
         ];

     

       26
       26
       +
       

     

       27
       27
       +
         dependencies = with python3Packages; [

     

       28
       28
       +
           flask

     

       29
       29
       +
           nipap

     

       30
       30
       +
           pynipap

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         passthru = {

     

       34
       34
       +
           inherit (python3Packages) gunicorn python;

     

       35
       35
       +
           pythonPath = python3Packages.makePythonPath dependencies;

     

       36
       36
       +
           tests.nixos = nixosTests.nipap;

     

       37
       37
       +
         };

     

       38
       38
       +
       

     

       39
       39
       +
         meta = {

     

       40
       40
       +
           description = "Neat IP Address Planner CLI, web UI";

     

       41
       41
       +
           longDescription = ''

     

       42
       42
       +
             NIPAP is the best open source IPAM in the known universe,

     

       43
       43
       +
             challenging classical IP address management (IPAM) systems in many areas.

     

       44
       44
       +
           '';

     

       45
       45
       +
           homepage = "https://github.com/SpriteLink/NIPAP";

     

       46
       46
       +
           changelog = "https://github.com/SpriteLink/NIPAP/releases/tag/v${version}";

     

       47
       47
       +
           license = lib.licenses.mit;

     

       48
       48
       +
           maintainers = with lib.maintainers; [

     

       49
       49
       +
             lukegb

     

       50
       50
       +
           ];

     

       51
       51
       +
           platforms = lib.platforms.all;

     

       52
       52
       +
         };

     

       53
       53
       +
       }

pkgs/by-name/ni/nipap/package.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         python3Packages,

     

       3
       3
       +
       }:

     

       4
       4
       +
       

     

       5
       5
       +
       python3Packages.toPythonApplication python3Packages.nipap

+50

pkgs/development/python-modules/flask-xml-rpc-re/default.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         buildPythonPackage,

     

       4
       4
       +
         fetchFromGitHub,

     

       5
       5
       +
         setuptools,

     

       6
       6
       +
         flask,

     

       7
       7
       +
         nose2,

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildPythonPackage rec {

     

       11
       11
       +
         pname = "flask-xml-rpc-re";

     

       12
       12
       +
         version = "0.2.0";

     

       13
       13
       +
       

     

       14
       14
       +
         src = fetchFromGitHub {

     

       15
       15
       +
           owner = "Croydon";

     

       16
       16
       +
           repo = "flask-xml-rpc-reloaded";

     

       17
       17
       +
           tag = version;

     

       18
       18
       +
           hash = "sha256-S+9Ur22ExgVjKMOKG19cBz2aCVdEyOoS7uoz17CDzd8=";

     

       19
       19
       +
         };

     

       20
       20
       +
       

     

       21
       21
       +
         build-system = [

     

       22
       22
       +
           setuptools

     

       23
       23
       +
         ];

     

       24
       24
       +
       

     

       25
       25
       +
         dependencies = [

     

       26
       26
       +
           flask

     

       27
       27
       +
         ];

     

       28
       28
       +
       

     

       29
       29
       +
         nativeCheckInputs = [

     

       30
       30
       +
           nose2

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         installCheckPhase = ''

     

       34
       34
       +
           runHook preInstallCheck

     

       35
       35
       +
           nose2 -v

     

       36
       36
       +
           runHook postInstallCheck

     

       37
       37
       +
         '';

     

       38
       38
       +
       

     

       39
       39
       +
         pythonImportsCheck = [ "flask_xmlrpcre" ];

     

       40
       40
       +
       

     

       41
       41
       +
         meta = {

     

       42
       42
       +
           description = "Let your Flask apps provide XML-RPC APIs";

     

       43
       43
       +
           license = lib.licenses.mit;

     

       44
       44
       +
           maintainers = with lib.maintainers; [

     

       45
       45
       +
             lukegb

     

       46
       46
       +
           ];

     

       47
       47
       +
           homepage = "https://github.com/Croydon/flask-xml-rpc-reloaded";

     

       48
       48
       +
           changelog = "https://github.com/Croydon/flask-xml-rpc-reloaded/releases/tag/${version}";

     

       49
       49
       +
         };

     

       50
       50
       +
       }

+100

pkgs/development/python-modules/nipap/default.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         buildPythonPackage,

     

       4
       4
       +
         fetchFromGitHub,

     

       5
       5
       +
       

     

       6
       6
       +
         # build deps

     

       7
       7
       +
         setuptools,

     

       8
       8
       +
         docutils,

     

       9
       9
       +
       

     

       10
       10
       +
         # dependencies

     

       11
       11
       +
         zipp,

     

       12
       12
       +
         importlib-metadata,

     

       13
       13
       +
         flask,

     

       14
       14
       +
         flask-compress,

     

       15
       15
       +
         flask-xml-rpc-re,

     

       16
       16
       +
         flask-restx,

     

       17
       17
       +
         requests,

     

       18
       18
       +
         ipy,

     

       19
       19
       +
         # indirect deps omitted: jinja2/markupsafe/werkzeug,

     

       20
       20
       +
         parsedatetime,

     

       21
       21
       +
         psutil,

     

       22
       22
       +
         psycopg2,

     

       23
       23
       +
         pyparsing,

     

       24
       24
       +
         python-dateutil,

     

       25
       25
       +
         pytz,

     

       26
       26
       +
         pyjwt,

     

       27
       27
       +
         tornado,

     

       28
       28
       +
       

     

       29
       29
       +
         # optional deps

     

       30
       30
       +
         ## ldap

     

       31
       31
       +
         python-ldap,

     

       32
       32
       +
       }:

     

       33
       33
       +
       

     

       34
       34
       +
       buildPythonPackage rec {

     

       35
       35
       +
         pname = "nipap";

     

       36
       36
       +
         version = "0.32.7";

     

       37
       37
       +
         pyproject = true;

     

       38
       38
       +
       

     

       39
       39
       +
         src = fetchFromGitHub {

     

       40
       40
       +
           owner = "SpriteLink";

     

       41
       41
       +
           repo = "NIPAP";

     

       42
       42
       +
           tag = "v${version}";

     

       43
       43
       +
           hash = "sha256-FnCHW/yEhWtx+2fU+G6vxz50lWC7WL3cYKYOQzmH8zs=";

     

       44
       44
       +
         };

     

       45
       45
       +
       

     

       46
       46
       +
         sourceRoot = "${src.name}/nipap";

     

       47
       47
       +
       

     

       48
       48
       +
         pythonRelaxDeps = true; # deps are tightly specified by upstream

     

       49
       49
       +
       

     

       50
       50
       +
         postPatch = ''

     

       51
       51
       +
           substituteInPlace pyproject.toml \

     

       52
       52
       +
             --replace-fail 'docutils==0.20.1' 'docutils'

     

       53
       53
       +
         '';

     

       54
       54
       +
       

     

       55
       55
       +
         build-system = [

     

       56
       56
       +
           setuptools

     

       57
       57
       +
           docutils

     

       58
       58
       +
         ];

     

       59
       59
       +
       

     

       60
       60
       +
         dependencies = [

     

       61
       61
       +
           zipp

     

       62
       62
       +
           importlib-metadata

     

       63
       63
       +
           flask

     

       64
       64
       +
           flask-compress

     

       65
       65
       +
           flask-xml-rpc-re

     

       66
       66
       +
           flask-restx

     

       67
       67
       +
           requests

     

       68
       68
       +
           ipy

     

       69
       69
       +
           # indirect deps omitted: jinja2/markupsafe/werkzeug

     

       70
       70
       +
           parsedatetime

     

       71
       71
       +
           psutil

     

       72
       72
       +
           psycopg2

     

       73
       73
       +
           pyparsing

     

       74
       74
       +
           python-dateutil

     

       75
       75
       +
           pytz

     

       76
       76
       +
           pyjwt

     

       77
       77
       +
           tornado

     

       78
       78
       +
         ];

     

       79
       79
       +
       

     

       80
       80
       +
         optional-dependencies = {

     

       81
       81
       +
           ldap = [ python-ldap ];

     

       82
       82
       +
         };

     

       83
       83
       +
       

     

       84
       84
       +
         doCheck = false; # tests require nose, /etc/nipap/nipap.conf and a running nipapd

     

       85
       85
       +
       

     

       86
       86
       +
         meta = {

     

       87
       87
       +
           description = "Neat IP Address Planner";

     

       88
       88
       +
           longDescription = ''

     

       89
       89
       +
             NIPAP is the best open source IPAM in the known universe,

     

       90
       90
       +
             challenging classical IP address management (IPAM) systems in many areas.

     

       91
       91
       +
           '';

     

       92
       92
       +
           homepage = "https://github.com/SpriteLink/NIPAP";

     

       93
       93
       +
           changelog = "https://github.com/SpriteLink/NIPAP/releases/tag/v${version}";

     

       94
       94
       +
           license = lib.licenses.mit;

     

       95
       95
       +
           maintainers = with lib.maintainers; [

     

       96
       96
       +
             lukegb

     

       97
       97
       +
           ];

     

       98
       98
       +
           platforms = lib.platforms.all;

     

       99
       99
       +
         };

     

       100
       100
       +
       }

+38

pkgs/development/python-modules/pynipap/default.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         lib,

     

       3
       3
       +
         buildPythonPackage,

     

       4
       4
       +
         nipap,

     

       5
       5
       +
       

     

       6
       6
       +
         # build deps

     

       7
       7
       +
         setuptools,

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildPythonPackage rec {

     

       11
       11
       +
         pname = "pynipap";

     

       12
       12
       +
         pyproject = true;

     

       13
       13
       +
       

     

       14
       14
       +
         inherit (nipap) version src;

     

       15
       15
       +
       

     

       16
       16
       +
         sourceRoot = "${src.name}/pynipap";

     

       17
       17
       +
       

     

       18
       18
       +
         build-system = [

     

       19
       19
       +
           setuptools

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         doCheck = false; # tests require nose, /etc/nipap/nipap.conf and a running nipapd

     

       23
       23
       +
       

     

       24
       24
       +
         meta = {

     

       25
       25
       +
           description = "Python client library for Neat IP Address Planner";

     

       26
       26
       +
           longDescription = ''

     

       27
       27
       +
             NIPAP is the best open source IPAM in the known universe,

     

       28
       28
       +
             challenging classical IP address management (IPAM) systems in many areas.

     

       29
       29
       +
           '';

     

       30
       30
       +
           homepage = "https://github.com/SpriteLink/NIPAP";

     

       31
       31
       +
           changelog = "https://github.com/SpriteLink/NIPAP/releases/tag/v${version}";

     

       32
       32
       +
           license = lib.licenses.mit;

     

       33
       33
       +
           maintainers = with lib.maintainers; [

     

       34
       34
       +
             lukegb

     

       35
       35
       +
           ];

     

       36
       36
       +
           platforms = lib.platforms.all;

     

       37
       37
       +
         };

     

       38
       38
       +
       }

+34

pkgs/servers/sql/postgresql/ext/ip4r.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         fetchFromGitHub,

     

       3
       3
       +
         lib,

     

       4
       4
       +
         postgresql,

     

       5
       5
       +
         postgresqlBuildExtension,

     

       6
       6
       +
         postgresqlTestExtension,

     

       7
       7
       +
       }:

     

       8
       8
       +
       

     

       9
       9
       +
       postgresqlBuildExtension (finalAttrs: {

     

       10
       10
       +
         pname = "ip4r";

     

       11
       11
       +
         version = "2.4.2";

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchFromGitHub {

     

       14
       14
       +
           owner = "RhodiumToad";

     

       15
       15
       +
           repo = "ip4r";

     

       16
       16
       +
           tag = "${finalAttrs.version}";

     

       17
       17
       +
           hash = "sha256-3chAD4f4A6VlXVSI0kfC/ANcnFy4vBp4FZpT6QRAueQ=";

     

       18
       18
       +
         };

     

       19
       19
       +
       

     

       20
       20
       +
         passthru.tests = {

     

       21
       21
       +
           extension = postgresqlTestExtension {

     

       22
       22
       +
             inherit (finalAttrs) finalPackage;

     

       23
       23
       +
             sql = "CREATE EXTENSION ip4r;";

     

       24
       24
       +
           };

     

       25
       25
       +
         };

     

       26
       26
       +
       

     

       27
       27
       +
         meta = {

     

       28
       28
       +
           description = "IPv4/v6 and IPv4/v6 range index type for PostgreSQL";

     

       29
       29
       +
           homepage = "https://github.com/RhodiumToad/ip4r";

     

       30
       30
       +
           license = lib.licenses.postgresql;

     

       31
       31
       +
           maintainers = with lib.maintainers; [ lukegb ];

     

       32
       32
       +
           inherit (postgresql.meta) platforms;

     

       33
       33
       +
         };

     

       34
       34
       +
       })

pkgs/top-level/python-packages.nix

···

       5234
       5234
        
       

     

       5235
       5235
        
         flask-wtf = callPackage ../development/python-modules/flask-wtf { };

     

       5236
       5236
        
       

     

       5237
       5237
       +
         flask-xml-rpc-re = callPackage ../development/python-modules/flask-xml-rpc-re { };

     

       5238
       5238
       +
       

     

       5237
       5239
        
         flatbencode = callPackage ../development/python-modules/flatbencode { };

     

       5238
       5240
        
       

     

       5239
       5241
        
         flatbuffers = callPackage ../development/python-modules/flatbuffers { inherit (pkgs) flatbuffers; };

     
···

       10208
       10210
        
       

     

       10209
       10211
        
         ninja = callPackage ../development/python-modules/ninja { inherit (pkgs) ninja; };

     

       10210
       10212
        
       

     

       10213
       10213
       +
         nipap = callPackage ../development/python-modules/nipap { };

     

       10214
       10214
       +
       

     

       10211
       10215
        
         nipreps-versions = callPackage ../development/python-modules/nipreps-versions { };

     

       10212
       10216
        
       

     

       10213
       10217
        
         nipy = callPackage ../development/python-modules/nipy { };

     
···

       13144
       13148
        
         pyngrok = callPackage ../development/python-modules/pyngrok { };

     

       13145
       13149
        
       

     

       13146
       13150
        
         pynina = callPackage ../development/python-modules/pynina { };

     

       13151
       13151
       +
       

     

       13152
       13152
       +
         pynipap = callPackage ../development/python-modules/pynipap { };

     

       13147
       13153
        
       

     

       13148
       13154
        
         pynisher = callPackage ../development/python-modules/pynisher { };

     

       13149
       13155