commit a6bc6ed645c2702d97f6222743c18aa06e02b0d0 · pyrox.dev/nixpkgs

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

···

       235
       235
        
         - `services.openssh.ciphers` to `services.openssh.settings.Ciphers`

     

       236
       236
        
         - `services.openssh.gatewayPorts` to `services.openssh.settings.GatewayPorts`

     

       237
       237
        
       

     

       238
       238
       +
       - `netbox` was updated to 3.4. NixOS' `services.netbox.package` still defaults to 3.3 if `stateVersion` is earlier than 23.05. Please review upstream's [breaking changes](https://github.com/netbox-community/netbox/releases/tag/v3.4.0), and upgrade NetBox by changing `services.netbox.package`. Database migrations will be run automatically.

     

       239
       239
       +
       

     

       240
       240
       +
       - `services.netbox` now support RFC42-style options, through `services.netbox.settings`.

     

       241
       241
       +
       

     

       238
       242
        
       - `services.mastodon` gained a tootctl wrapped named `mastodon-tootctl` similar to `nextcloud-occ` which can be executed from any user and switches to the configured mastodon user with sudo and sources the environment variables.

     

       239
       243
        
       

     

       240
       244
        
       - DocBook option documentation, which has been deprecated since 22.11, will now cause a warning when documentation is built. Out-of-tree modules should migrate to using CommonMark documentation as outlined in [](#sec-option-declarations) to silence this warning.

+124 -38

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

···

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
        
         cfg = config.services.netbox;

     

       7
       7
       +
         pythonFmt = pkgs.formats.pythonVars {};

     

       7
       8
        
         staticDir = cfg.dataDir + "/static";

     

       8
       8
       -
         configFile = pkgs.writeTextFile {

     

       9
       9
       -
           name = "configuration.py";

     

       10
       10
       -
           text = ''

     

       11
       11
       -
             STATIC_ROOT = '${staticDir}'

     

       12
       12
       -
             MEDIA_ROOT = '${cfg.dataDir}/media'

     

       13
       13
       -
             REPORTS_ROOT = '${cfg.dataDir}/reports'

     

       14
       14
       -
             SCRIPTS_ROOT = '${cfg.dataDir}/scripts'

     

       15
       9
        
       

     

       16
       16
       -
             ALLOWED_HOSTS = ['*']

     

       17
       17
       -
             DATABASE = {

     

       18
       18
       -
               'NAME': 'netbox',

     

       19
       19
       -
               'USER': 'netbox',

     

       20
       20
       -
               'HOST': '/run/postgresql',

     

       21
       21
       -
             }

     

       10
       10
       +
         settingsFile = pythonFmt.generate "netbox-settings.py" cfg.settings;

     

       11
       11
       +
         extraConfigFile = pkgs.writeTextFile {

     

       12
       12
       +
           name = "netbox-extraConfig.py";

     

       13
       13
       +
           text = cfg.extraConfig;

     

       14
       14
       +
         };

     

       15
       15
       +
         configFile = pkgs.concatText "configuration.py" [ settingsFile extraConfigFile ];

     

       22
       16
        
       

     

       23
       23
       -
             # Redis database settings. Redis is used for caching and for queuing background tasks such as webhook events. A separate

     

       24
       24
       -
             # configuration exists for each. Full connection details are required in both sections, and it is strongly recommended

     

       25
       25
       -
             # to use two separate database IDs.

     

       26
       26
       -
             REDIS = {

     

       27
       27
       -
                 'tasks': {

     

       28
       28
       -
                     'URL': 'unix://${config.services.redis.servers.netbox.unixSocket}?db=0',

     

       29
       29
       -
                     'SSL': False,

     

       30
       30
       -
                 },

     

       31
       31
       -
                 'caching': {

     

       32
       32
       -
                     'URL': 'unix://${config.services.redis.servers.netbox.unixSocket}?db=1',

     

       33
       33
       -
                     'SSL': False,

     

       34
       34
       -
                 }

     

       35
       35
       -
             }

     

       36
       36
       -
       

     

       37
       37
       -
             with open("${cfg.secretKeyFile}", "r") as file:

     

       38
       38
       -
                 SECRET_KEY = file.readline()

     

       39
       39
       -
       

     

       40
       40
       -
             ${optionalString cfg.enableLdap "REMOTE_AUTH_BACKEND = 'netbox.authentication.LDAPBackend'"}

     

       41
       41
       -
       

     

       42
       42
       -
             ${cfg.extraConfig}

     

       43
       43
       -
           '';

     

       44
       44
       -
         };

     

       45
       45
       -
         pkg = (pkgs.netbox.overrideAttrs (old: {

     

       17
       17
       +
         pkg = (cfg.package.overrideAttrs (old: {

     

       46
       18
        
           installPhase = old.installPhase + ''

     

       47
       19
        
             ln -s ${configFile} $out/opt/netbox/netbox/netbox/configuration.py

     

       48
       20
        
           '' + optionalString cfg.enableLdap ''

     
···

       70
       42
        
             '';

     

       71
       43
        
           };

     

       72
       44
        
       

     

       45
       45
       +
           settings = lib.mkOption {

     

       46
       46
       +
             description = lib.mdDoc ''

     

       47
       47
       +
               Configuration options to set in `configuration.py`.

     

       48
       48
       +
               See the [documentation](https://docs.netbox.dev/en/stable/configuration/) for more possible options.

     

       49
       49
       +
             '';

     

       50
       50
       +
       

     

       51
       51
       +
             default = { };

     

       52
       52
       +
       

     

       53
       53
       +
             type = lib.types.submodule {

     

       54
       54
       +
               freeformType = pythonFmt.type;

     

       55
       55
       +
       

     

       56
       56
       +
               options = {

     

       57
       57
       +
                 ALLOWED_HOSTS = lib.mkOption {

     

       58
       58
       +
                   type = with lib.types; listOf str;

     

       59
       59
       +
                   default = ["*"];

     

       60
       60
       +
                   description = lib.mdDoc ''

     

       61
       61
       +
                     A list of valid fully-qualified domain names (FQDNs) and/or IP

     

       62
       62
       +
                     addresses that can be used to reach the NetBox service.

     

       63
       63
       +
                   '';

     

       64
       64
       +
                 };

     

       65
       65
       +
               };

     

       66
       66
       +
             };

     

       67
       67
       +
           };

     

       68
       68
       +
       

     

       73
       69
        
           listenAddress = mkOption {

     

       74
       70
        
             type = types.str;

     

       75
       71
        
             default = "[::1]";

     

       76
       72
        
             description = lib.mdDoc ''

     

       77
       73
        
               Address the server will listen on.

     

       74
       74
       +
             '';

     

       75
       75
       +
           };

     

       76
       76
       +
       

     

       77
       77
       +
           package = mkOption {

     

       78
       78
       +
             type = types.package;

     

       79
       79
       +
             default = if versionAtLeast config.system.stateVersion "23.05" then pkgs.netbox else pkgs.netbox_3_3;

     

       80
       80
       +
             defaultText = literalExpression ''

     

       81
       81
       +
               if versionAtLeast config.system.stateVersion "23.05" then pkgs.netbox else pkgs.netbox_3_3;

     

       82
       82
       +
             '';

     

       83
       83
       +
             description = lib.mdDoc ''

     

       84
       84
       +
               NetBox package to use.

     

       78
       85
        
             '';

     

       79
       86
        
           };

     

       80
       87
        
       

     
···

       117
       124
        
             default = "";

     

       118
       125
        
             description = lib.mdDoc ''

     

       119
       126
        
               Additional lines of configuration appended to the `configuration.py`.

     

       120
       120
       -
               See the [documentation](https://netbox.readthedocs.io/en/stable/configuration/optional-settings/) for more possible options.

     

       127
       127
       +
               See the [documentation](https://docs.netbox.dev/en/stable/configuration/) for more possible options.

     

       121
       128
        
             '';

     

       122
       129
        
           };

     

       123
       130
        
       

     
···

       138
       145
        
               Path to the Configuration-File for LDAP-Authentication, will be loaded as `ldap_config.py`.

     

       139
       146
        
               See the [documentation](https://netbox.readthedocs.io/en/stable/installation/6-ldap/#configuration) for possible options.

     

       140
       147
        
             '';

     

       148
       148
       +
             example = ''

     

       149
       149
       +
               import ldap

     

       150
       150
       +
               from django_auth_ldap.config import LDAPSearch, PosixGroupType

     

       151
       151
       +
       

     

       152
       152
       +
               AUTH_LDAP_SERVER_URI = "ldaps://ldap.example.com/"

     

       153
       153
       +
       

     

       154
       154
       +
               AUTH_LDAP_USER_SEARCH = LDAPSearch(

     

       155
       155
       +
                   "ou=accounts,ou=posix,dc=example,dc=com",

     

       156
       156
       +
                   ldap.SCOPE_SUBTREE,

     

       157
       157
       +
                   "(uid=%(user)s)",

     

       158
       158
       +
               )

     

       159
       159
       +
       

     

       160
       160
       +
               AUTH_LDAP_GROUP_SEARCH = LDAPSearch(

     

       161
       161
       +
                   "ou=groups,ou=posix,dc=example,dc=com",

     

       162
       162
       +
                   ldap.SCOPE_SUBTREE,

     

       163
       163
       +
                   "(objectClass=posixGroup)",

     

       164
       164
       +
               )

     

       165
       165
       +
               AUTH_LDAP_GROUP_TYPE = PosixGroupType()

     

       166
       166
       +
       

     

       167
       167
       +
               # Mirror LDAP group assignments.

     

       168
       168
       +
               AUTH_LDAP_MIRROR_GROUPS = True

     

       169
       169
       +
       

     

       170
       170
       +
               # For more granular permissions, we can map LDAP groups to Django groups.

     

       171
       171
       +
               AUTH_LDAP_FIND_GROUP_PERMS = True

     

       172
       172
       +
             '';

     

       141
       173
        
           };

     

       142
       174
        
         };

     

       143
       175
        
       

     

       144
       176
        
         config = mkIf cfg.enable {

     

       145
       145
       -
           services.netbox.plugins = mkIf cfg.enableLdap (ps: [ ps.django-auth-ldap ]);

     

       177
       177
       +
           services.netbox = {

     

       178
       178
       +
             plugins = mkIf cfg.enableLdap (ps: [ ps.django-auth-ldap ]);

     

       179
       179
       +
             settings = {

     

       180
       180
       +
               STATIC_ROOT = staticDir;

     

       181
       181
       +
               MEDIA_ROOT = "${cfg.dataDir}/media";

     

       182
       182
       +
               REPORTS_ROOT = "${cfg.dataDir}/reports";

     

       183
       183
       +
               SCRIPTS_ROOT = "${cfg.dataDir}/scripts";

     

       184
       184
       +
       

     

       185
       185
       +
               DATABASE = {

     

       186
       186
       +
                 NAME = "netbox";

     

       187
       187
       +
                 USER = "netbox";

     

       188
       188
       +
                 HOST = "/run/postgresql";

     

       189
       189
       +
               };

     

       190
       190
       +
       

     

       191
       191
       +
               # Redis database settings. Redis is used for caching and for queuing

     

       192
       192
       +
               # background tasks such as webhook events. A separate configuration

     

       193
       193
       +
               # exists for each. Full connection details are required in both

     

       194
       194
       +
               # sections, and it is strongly recommended to use two separate database

     

       195
       195
       +
               # IDs.

     

       196
       196
       +
               REDIS = {

     

       197
       197
       +
                   tasks = {

     

       198
       198
       +
                       URL = "unix://${config.services.redis.servers.netbox.unixSocket}?db=0";

     

       199
       199
       +
                       SSL = false;

     

       200
       200
       +
                   };

     

       201
       201
       +
                   caching =  {

     

       202
       202
       +
                       URL = "unix://${config.services.redis.servers.netbox.unixSocket}?db=1";

     

       203
       203
       +
                       SSL = false;

     

       204
       204
       +
                   };

     

       205
       205
       +
               };

     

       206
       206
       +
       

     

       207
       207
       +
               REMOTE_AUTH_BACKEND = lib.mkIf cfg.enableLdap "netbox.authentication.LDAPBackend";

     

       208
       208
       +
       

     

       209
       209
       +
               LOGGING = lib.mkDefault {

     

       210
       210
       +
                 version = 1;

     

       211
       211
       +
       

     

       212
       212
       +
                 formatters.precise.format = "[%(levelname)s@%(name)s] %(message)s";

     

       213
       213
       +
       

     

       214
       214
       +
                 handlers.console = {

     

       215
       215
       +
                   class = "logging.StreamHandler";

     

       216
       216
       +
                   formatter = "precise";

     

       217
       217
       +
                 };

     

       218
       218
       +
       

     

       219
       219
       +
                 # log to console/systemd instead of file

     

       220
       220
       +
                 root = {

     

       221
       221
       +
                   level = "INFO";

     

       222
       222
       +
                   handlers = [ "console" ];

     

       223
       223
       +
                 };

     

       224
       224
       +
               };

     

       225
       225
       +
             };

     

       226
       226
       +
       

     

       227
       227
       +
             extraConfig = ''

     

       228
       228
       +
               with open("${cfg.secretKeyFile}", "r") as file:

     

       229
       229
       +
                   SECRET_KEY = file.readline()

     

       230
       230
       +
             '';

     

       231
       231
       +
           };

     

       146
       232
        
       

     

       147
       233
        
           services.redis.servers.netbox.enable = true;

     

       148
       234

+2 -1

nixos/tests/all-tests.nix

···

       460
       460
        
         netdata = handleTest ./netdata.nix {};

     

       461
       461
        
         networking.networkd = handleTest ./networking.nix { networkd = true; };

     

       462
       462
        
         networking.scripted = handleTest ./networking.nix { networkd = false; };

     

       463
       463
       -
         netbox = handleTest ./web-apps/netbox.nix {};

     

       463
       463
       +
         netbox = handleTest ./web-apps/netbox.nix { inherit (pkgs) netbox; };

     

       464
       464
       +
         netbox_3_3 = handleTest ./web-apps/netbox.nix { netbox = pkgs.netbox_3_3; };

     

       464
       465
        
         # TODO: put in networking.nix after the test becomes more complete

     

       465
       466
        
         networkingProxy = handleTest ./networking-proxy.nix {};

     

       466
       467
        
         nextcloud = handleTest ./nextcloud {};

+292 -5

nixos/tests/web-apps/netbox.nix

···

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

     

       1
       1
       +
       let

     

       2
       2
       +
         ldapDomain = "example.org";

     

       3
       3
       +
         ldapSuffix = "dc=example,dc=org";

     

       4
       4
       +
       

     

       5
       5
       +
         ldapRootUser = "admin";

     

       6
       6
       +
         ldapRootPassword = "foobar";

     

       7
       7
       +
       

     

       8
       8
       +
         testUser = "alice";

     

       9
       9
       +
         testPassword = "verySecure";

     

       10
       10
       +
         testGroup = "netbox-users";

     

       11
       11
       +
       in import ../make-test-python.nix ({ lib, pkgs, netbox, ... }: {

     

       2
       12
        
         name = "netbox";

     

       3
       13
        
       

     

       4
       14
        
         meta = with lib.maintainers; {

     

       5
       5
       -
           maintainers = [ n0emis ];

     

       15
       15
       +
           maintainers = [ minijackson n0emis ];

     

       6
       16
        
         };

     

       7
       17
        
       

     

       8
       8
       -
         nodes.machine = { ... }: {

     

       18
       18
       +
         nodes.machine = { config, ... }: {

     

       9
       19
        
           services.netbox = {

     

       10
       20
        
             enable = true;

     

       21
       21
       +
             package = netbox;

     

       11
       22
        
             secretKeyFile = pkgs.writeText "secret" ''

     

       12
       23
        
               abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789

     

       13
       24
        
             '';

     

       25
       25
       +
       

     

       26
       26
       +
             enableLdap = true;

     

       27
       27
       +
             ldapConfigPath = pkgs.writeText "ldap_config.py" ''

     

       28
       28
       +
               import ldap

     

       29
       29
       +
               from django_auth_ldap.config import LDAPSearch, PosixGroupType

     

       30
       30
       +
       

     

       31
       31
       +
               AUTH_LDAP_SERVER_URI = "ldap://localhost/"

     

       32
       32
       +
       

     

       33
       33
       +
               AUTH_LDAP_USER_SEARCH = LDAPSearch(

     

       34
       34
       +
                   "ou=accounts,ou=posix,${ldapSuffix}",

     

       35
       35
       +
                   ldap.SCOPE_SUBTREE,

     

       36
       36
       +
                   "(uid=%(user)s)",

     

       37
       37
       +
               )

     

       38
       38
       +
       

     

       39
       39
       +
               AUTH_LDAP_GROUP_SEARCH = LDAPSearch(

     

       40
       40
       +
                   "ou=groups,ou=posix,${ldapSuffix}",

     

       41
       41
       +
                   ldap.SCOPE_SUBTREE,

     

       42
       42
       +
                   "(objectClass=posixGroup)",

     

       43
       43
       +
               )

     

       44
       44
       +
               AUTH_LDAP_GROUP_TYPE = PosixGroupType()

     

       45
       45
       +
       

     

       46
       46
       +
               # Mirror LDAP group assignments.

     

       47
       47
       +
               AUTH_LDAP_MIRROR_GROUPS = True

     

       48
       48
       +
       

     

       49
       49
       +
               # For more granular permissions, we can map LDAP groups to Django groups.

     

       50
       50
       +
               AUTH_LDAP_FIND_GROUP_PERMS = True

     

       51
       51
       +
             '';

     

       14
       52
        
           };

     

       53
       53
       +
       

     

       54
       54
       +
           services.nginx = {

     

       55
       55
       +
             enable = true;

     

       56
       56
       +
       

     

       57
       57
       +
             recommendedProxySettings = true;

     

       58
       58
       +
       

     

       59
       59
       +
             virtualHosts.netbox = {

     

       60
       60
       +
               default = true;

     

       61
       61
       +
               locations."/".proxyPass = "http://localhost:${toString config.services.netbox.port}";

     

       62
       62
       +
               locations."/static/".alias = "/var/lib/netbox/static/";

     

       63
       63
       +
             };

     

       64
       64
       +
           };

     

       65
       65
       +
       

     

       66
       66
       +
           # Adapted from the sssd-ldap NixOS test

     

       67
       67
       +
           services.openldap = {

     

       68
       68
       +
             enable = true;

     

       69
       69
       +
             settings = {

     

       70
       70
       +
               children = {

     

       71
       71
       +
                 "cn=schema".includes = [

     

       72
       72
       +
                   "${pkgs.openldap}/etc/schema/core.ldif"

     

       73
       73
       +
                   "${pkgs.openldap}/etc/schema/cosine.ldif"

     

       74
       74
       +
                   "${pkgs.openldap}/etc/schema/inetorgperson.ldif"

     

       75
       75
       +
                   "${pkgs.openldap}/etc/schema/nis.ldif"

     

       76
       76
       +
                 ];

     

       77
       77
       +
                 "olcDatabase={1}mdb" = {

     

       78
       78
       +
                   attrs = {

     

       79
       79
       +
                     objectClass = [ "olcDatabaseConfig" "olcMdbConfig" ];

     

       80
       80
       +
                     olcDatabase = "{1}mdb";

     

       81
       81
       +
                     olcDbDirectory = "/var/lib/openldap/db";

     

       82
       82
       +
                     olcSuffix = ldapSuffix;

     

       83
       83
       +
                     olcRootDN = "cn=${ldapRootUser},${ldapSuffix}";

     

       84
       84
       +
                     olcRootPW = ldapRootPassword;

     

       85
       85
       +
                   };

     

       86
       86
       +
                 };

     

       87
       87
       +
               };

     

       88
       88
       +
             };

     

       89
       89
       +
             declarativeContents = {

     

       90
       90
       +
               ${ldapSuffix} = ''

     

       91
       91
       +
                 dn: ${ldapSuffix}

     

       92
       92
       +
                 objectClass: top

     

       93
       93
       +
                 objectClass: dcObject

     

       94
       94
       +
                 objectClass: organization

     

       95
       95
       +
                 o: ${ldapDomain}

     

       96
       96
       +
       

     

       97
       97
       +
                 dn: ou=posix,${ldapSuffix}

     

       98
       98
       +
                 objectClass: top

     

       99
       99
       +
                 objectClass: organizationalUnit

     

       100
       100
       +
       

     

       101
       101
       +
                 dn: ou=accounts,ou=posix,${ldapSuffix}

     

       102
       102
       +
                 objectClass: top

     

       103
       103
       +
                 objectClass: organizationalUnit

     

       104
       104
       +
       

     

       105
       105
       +
                 dn: uid=${testUser},ou=accounts,ou=posix,${ldapSuffix}

     

       106
       106
       +
                 objectClass: person

     

       107
       107
       +
                 objectClass: posixAccount

     

       108
       108
       +
                 userPassword: ${testPassword}

     

       109
       109
       +
                 homeDirectory: /home/${testUser}

     

       110
       110
       +
                 uidNumber: 1234

     

       111
       111
       +
                 gidNumber: 1234

     

       112
       112
       +
                 cn: ""

     

       113
       113
       +
                 sn: ""

     

       114
       114
       +
       

     

       115
       115
       +
                 dn: ou=groups,ou=posix,${ldapSuffix}

     

       116
       116
       +
                 objectClass: top

     

       117
       117
       +
                 objectClass: organizationalUnit

     

       118
       118
       +
       

     

       119
       119
       +
                 dn: cn=${testGroup},ou=groups,ou=posix,${ldapSuffix}

     

       120
       120
       +
                 objectClass: posixGroup

     

       121
       121
       +
                 gidNumber: 2345

     

       122
       122
       +
                 memberUid: ${testUser}

     

       123
       123
       +
               '';

     

       124
       124
       +
             };

     

       125
       125
       +
           };

     

       126
       126
       +
       

     

       127
       127
       +
           users.users.nginx.extraGroups = [ "netbox" ];

     

       128
       128
       +
       

     

       129
       129
       +
           networking.firewall.allowedTCPPorts = [ 80 ];

     

       15
       130
        
         };

     

       16
       131
        
       

     

       17
       17
       -
         testScript = ''

     

       18
       18
       -
           machine.start()

     

       132
       132
       +
         testScript = let

     

       133
       133
       +
           changePassword = pkgs.writeText "change-password.py" ''

     

       134
       134
       +
             from django.contrib.auth.models import User

     

       135
       135
       +
             u = User.objects.get(username='netbox')

     

       136
       136
       +
             u.set_password('netbox')

     

       137
       137
       +
             u.save()

     

       138
       138
       +
           '';

     

       139
       139
       +
         in ''

     

       140
       140
       +
           from typing import Any, Dict

     

       141
       141
       +
           import json

     

       142
       142
       +
       

     

       143
       143
       +
           start_all()

     

       19
       144
        
           machine.wait_for_unit("netbox.target")

     

       20
       145
        
           machine.wait_until_succeeds("journalctl --since -1m --unit netbox --grep Listening")

     

       21
       146
        
       

     
···

       26
       151
        
       

     

       27
       152
        
           with subtest("Staticfiles are generated"):

     

       28
       153
        
               machine.succeed("test -e /var/lib/netbox/static/netbox.js")

     

       154
       154
       +
       

     

       155
       155
       +
           with subtest("Superuser can be created"):

     

       156
       156
       +
               machine.succeed(

     

       157
       157
       +
                   "netbox-manage createsuperuser --noinput --username netbox --email netbox@example.com"

     

       158
       158
       +
               )

     

       159
       159
       +
               # Django doesn't have a "clean" way of inputting the password from the command line

     

       160
       160
       +
               machine.succeed("cat '${changePassword}' | netbox-manage shell")

     

       161
       161
       +
       

     

       162
       162
       +
           machine.wait_for_unit("network.target")

     

       163
       163
       +
       

     

       164
       164
       +
           with subtest("Home screen loads from nginx"):

     

       165
       165
       +
               machine.succeed(

     

       166
       166
       +
                   "curl -sSfL http://localhost | grep '<title>Home | NetBox</title>'"

     

       167
       167
       +
               )

     

       168
       168
       +
       

     

       169
       169
       +
           with subtest("Staticfiles can be fetched"):

     

       170
       170
       +
               machine.succeed("curl -sSfL http://localhost/static/netbox.js")

     

       171
       171
       +
               machine.succeed("curl -sSfL http://localhost/static/docs/")

     

       172
       172
       +
       

     

       173
       173
       +
           with subtest("Can interact with API"):

     

       174
       174
       +
               json.loads(

     

       175
       175
       +
                   machine.succeed("curl -sSfL -H 'Accept: application/json' 'http://localhost/api/'")

     

       176
       176
       +
               )

     

       177
       177
       +
       

     

       178
       178
       +
           def login(username: str, password: str):

     

       179
       179
       +
               encoded_data = json.dumps({"username": username, "password": password})

     

       180
       180
       +
               uri = "/users/tokens/provision/"

     

       181
       181
       +
               result = json.loads(

     

       182
       182
       +
                   machine.succeed(

     

       183
       183
       +
                       "curl -sSfL "

     

       184
       184
       +
                       "-X POST "

     

       185
       185
       +
                       "-H 'Accept: application/json' "

     

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

     

       187
       187
       +
                       f"'http://localhost/api{uri}' "

     

       188
       188
       +
                       f"--data '{encoded_data}'"

     

       189
       189
       +
                   )

     

       190
       190
       +
               )

     

       191
       191
       +
               return result["key"]

     

       192
       192
       +
       

     

       193
       193
       +
           with subtest("Can login"):

     

       194
       194
       +
               auth_token = login("netbox", "netbox")

     

       195
       195
       +
       

     

       196
       196
       +
           def get(uri: str):

     

       197
       197
       +
               return json.loads(

     

       198
       198
       +
                   machine.succeed(

     

       199
       199
       +
                       "curl -sSfL "

     

       200
       200
       +
                       "-H 'Accept: application/json' "

     

       201
       201
       +
                       f"-H 'Authorization: Token {auth_token}' "

     

       202
       202
       +
                       f"'http://localhost/api{uri}'"

     

       203
       203
       +
                   )

     

       204
       204
       +
               )

     

       205
       205
       +
       

     

       206
       206
       +
           def delete(uri: str):

     

       207
       207
       +
               return machine.succeed(

     

       208
       208
       +
                   "curl -sSfL "

     

       209
       209
       +
                   f"-X DELETE "

     

       210
       210
       +
                   "-H 'Accept: application/json' "

     

       211
       211
       +
                   f"-H 'Authorization: Token {auth_token}' "

     

       212
       212
       +
                   f"'http://localhost/api{uri}'"

     

       213
       213
       +
               )

     

       214
       214
       +
       

     

       215
       215
       +
       

     

       216
       216
       +
           def data_request(uri: str, method: str, data: Dict[str, Any]):

     

       217
       217
       +
               encoded_data = json.dumps(data)

     

       218
       218
       +
               return json.loads(

     

       219
       219
       +
                   machine.succeed(

     

       220
       220
       +
                       "curl -sSfL "

     

       221
       221
       +
                       f"-X {method} "

     

       222
       222
       +
                       "-H 'Accept: application/json' "

     

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

     

       224
       224
       +
                       f"-H 'Authorization: Token {auth_token}' "

     

       225
       225
       +
                       f"'http://localhost/api{uri}' "

     

       226
       226
       +
                       f"--data '{encoded_data}'"

     

       227
       227
       +
                   )

     

       228
       228
       +
               )

     

       229
       229
       +
       

     

       230
       230
       +
           def post(uri: str, data: Dict[str, Any]):

     

       231
       231
       +
             return data_request(uri, "POST", data)

     

       232
       232
       +
       

     

       233
       233
       +
           def patch(uri: str, data: Dict[str, Any]):

     

       234
       234
       +
             return data_request(uri, "PATCH", data)

     

       235
       235
       +
       

     

       236
       236
       +
           with subtest("Can create objects"):

     

       237
       237
       +
               result = post("/dcim/sites/", {"name": "Test site", "slug": "test-site"})

     

       238
       238
       +
               site_id = result["id"]

     

       239
       239
       +
       

     

       240
       240
       +
               # Example from:

     

       241
       241
       +
               # http://netbox.extra.cea.fr/static/docs/integrations/rest-api/#creating-a-new-object

     

       242
       242
       +
               post("/ipam/prefixes/", {"prefix": "192.0.2.0/24", "site": site_id})

     

       243
       243
       +
       

     

       244
       244
       +
               result = post(

     

       245
       245
       +
                   "/dcim/manufacturers/",

     

       246
       246
       +
                   {"name": "Test manufacturer", "slug": "test-manufacturer"}

     

       247
       247
       +
               )

     

       248
       248
       +
               manufacturer_id = result["id"]

     

       249
       249
       +
       

     

       250
       250
       +
               # Had an issue with device-types before NetBox 3.4.0

     

       251
       251
       +
               result = post(

     

       252
       252
       +
                   "/dcim/device-types/",

     

       253
       253
       +
                   {

     

       254
       254
       +
                       "model": "Test device type",

     

       255
       255
       +
                       "manufacturer": manufacturer_id,

     

       256
       256
       +
                       "slug": "test-device-type",

     

       257
       257
       +
                   },

     

       258
       258
       +
               )

     

       259
       259
       +
               device_type_id = result["id"]

     

       260
       260
       +
       

     

       261
       261
       +
           with subtest("Can list objects"):

     

       262
       262
       +
               result = get("/dcim/sites/")

     

       263
       263
       +
       

     

       264
       264
       +
               assert result["count"] == 1

     

       265
       265
       +
               assert result["results"][0]["id"] == site_id

     

       266
       266
       +
               assert result["results"][0]["name"] == "Test site"

     

       267
       267
       +
               assert result["results"][0]["description"] == ""

     

       268
       268
       +
       

     

       269
       269
       +
               result = get("/dcim/device-types/")

     

       270
       270
       +
               assert result["count"] == 1

     

       271
       271
       +
               assert result["results"][0]["id"] == device_type_id

     

       272
       272
       +
               assert result["results"][0]["model"] == "Test device type"

     

       273
       273
       +
       

     

       274
       274
       +
           with subtest("Can update objects"):

     

       275
       275
       +
               new_description = "Test site description"

     

       276
       276
       +
               patch(f"/dcim/sites/{site_id}/", {"description": new_description})

     

       277
       277
       +
               result = get(f"/dcim/sites/{site_id}/")

     

       278
       278
       +
               assert result["description"] == new_description

     

       279
       279
       +
       

     

       280
       280
       +
           with subtest("Can delete objects"):

     

       281
       281
       +
               # Delete a device-type since no object depends on it

     

       282
       282
       +
               delete(f"/dcim/device-types/{device_type_id}/")

     

       283
       283
       +
       

     

       284
       284
       +
               result = get("/dcim/device-types/")

     

       285
       285
       +
               assert result["count"] == 0

     

       286
       286
       +
       

     

       287
       287
       +
           with subtest("Can use the GraphQL API"):

     

       288
       288
       +
               encoded_data = json.dumps({

     

       289
       289
       +
                   "query": "query { prefix_list { prefix, site { id, description } } }",

     

       290
       290
       +
               })

     

       291
       291
       +
               result = json.loads(

     

       292
       292
       +
                   machine.succeed(

     

       293
       293
       +
                       "curl -sSfL "

     

       294
       294
       +
                       "-H 'Accept: application/json' "

     

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

     

       296
       296
       +
                       f"-H 'Authorization: Token {auth_token}' "

     

       297
       297
       +
                       "'http://localhost/graphql/' "

     

       298
       298
       +
                       f"--data '{encoded_data}'"

     

       299
       299
       +
                   )

     

       300
       300
       +
               )

     

       301
       301
       +
       

     

       302
       302
       +
               assert len(result["data"]["prefix_list"]) == 1

     

       303
       303
       +
               assert result["data"]["prefix_list"][0]["prefix"] == "192.0.2.0/24"

     

       304
       304
       +
               assert result["data"]["prefix_list"][0]["site"]["id"] == str(site_id)

     

       305
       305
       +
               assert result["data"]["prefix_list"][0]["site"]["description"] == new_description

     

       306
       306
       +
       

     

       307
       307
       +
           with subtest("Can login with LDAP"):

     

       308
       308
       +
               machine.wait_for_unit("openldap.service")

     

       309
       309
       +
               login("alice", "${testPassword}")

     

       310
       310
       +
       

     

       311
       311
       +
           with subtest("Can associate LDAP groups"):

     

       312
       312
       +
               result = get("/users/users/?username=${testUser}")

     

       313
       313
       +
       

     

       314
       314
       +
               assert result["count"] == 1

     

       315
       315
       +
               assert any(group["name"] == "${testGroup}" for group in result["results"][0]["groups"])

     

       29
       316
        
         '';

     

       30
       317
        
       })

+35

pkgs/pkgs-lib/formats.nix

···

       417
       417
        
             '';

     

       418
       418
        
           };

     

       419
       419
        
       

     

       420
       420
       +
         # Outputs a succession of Python variable assignments

     

       421
       421
       +
         # Useful for many Django-based services

     

       422
       422
       +
         pythonVars = {}: {

     

       423
       423
       +
           type = with lib.types; let

     

       424
       424
       +
             valueType = nullOr(oneOf [

     

       425
       425
       +
               bool

     

       426
       426
       +
               float

     

       427
       427
       +
               int

     

       428
       428
       +
               path

     

       429
       429
       +
               str

     

       430
       430
       +
               (attrsOf valueType)

     

       431
       431
       +
               (listOf valueType)

     

       432
       432
       +
             ]) // {

     

       433
       433
       +
               description = "Python value";

     

       434
       434
       +
             };

     

       435
       435
       +
           in attrsOf valueType;

     

       436
       436
       +
           generate = name: value: pkgs.callPackage ({ runCommand, python3, black }: runCommand name {

     

       437
       437
       +
             nativeBuildInputs = [ python3 black ];

     

       438
       438
       +
             value = builtins.toJSON value;

     

       439
       439
       +
             pythonGen = ''

     

       440
       440
       +
               import json

     

       441
       441
       +
               import os

     

       442
       442
       +
       

     

       443
       443
       +
               with open(os.environ["valuePath"], "r") as f:

     

       444
       444
       +
                   for key, value in json.load(f).items():

     

       445
       445
       +
                       print(f"{key} = {repr(value)}")

     

       446
       446
       +
             '';

     

       447
       447
       +
             passAsFile = [ "value" "pythonGen" ];

     

       448
       448
       +
           } ''

     

       449
       449
       +
             cat "$valuePath"

     

       450
       450
       +
             python3 "$pythonGenPath" > $out

     

       451
       451
       +
             black $out

     

       452
       452
       +
           '') {};

     

       453
       453
       +
         };

     

       454
       454
       +
       

     

       420
       455
        
       }

+8 -8

pkgs/servers/web-apps/netbox/config.patch

···

       1
       1
        
       diff --git a/netbox/netbox/settings.py b/netbox/netbox/settings.py

     

       2
       2
       -
       index d5a7bfaec..68754a8c5 100644

     

       2
       2
       +
       index 2de06dd10..00406af48 100644

     

       3
       3
        
       --- a/netbox/netbox/settings.py

     

       4
       4
        
       +++ b/netbox/netbox/settings.py

     

       5
       5
       -
       @@ -222,6 +222,7 @@ TASKS_REDIS_PASSWORD = TASKS_REDIS.get('PASSWORD', '')

     

       6
       6
       -
        TASKS_REDIS_DATABASE = TASKS_REDIS.get('DATABASE', 0)

     

       5
       5
       +
       @@ -236,6 +236,7 @@ TASKS_REDIS_DATABASE = TASKS_REDIS.get('DATABASE', 0)

     

       7
       6
        
        TASKS_REDIS_SSL = TASKS_REDIS.get('SSL', False)

     

       8
       7
        
        TASKS_REDIS_SKIP_TLS_VERIFY = TASKS_REDIS.get('INSECURE_SKIP_TLS_VERIFY', False)

     

       8
       8
       +
        TASKS_REDIS_CA_CERT_PATH = TASKS_REDIS.get('CA_CERT_PATH', False)

     

       9
       9
        
       +TASKS_REDIS_URL = TASKS_REDIS.get('URL')

     

       10
       10
        
        

     

       11
       11
        
        # Caching

     

       12
       12
        
        if 'caching' not in REDIS:

     

       13
       13
       -
       @@ -236,11 +237,12 @@ CACHING_REDIS_SENTINELS = REDIS['caching'].get('SENTINELS', [])

     

       14
       14
       -
        CACHING_REDIS_SENTINEL_SERVICE = REDIS['caching'].get('SENTINEL_SERVICE', 'default')

     

       13
       13
       +
       @@ -253,11 +254,12 @@ CACHING_REDIS_SENTINEL_SERVICE = REDIS['caching'].get('SENTINEL_SERVICE', 'defau

     

       15
       14
        
        CACHING_REDIS_PROTO = 'rediss' if REDIS['caching'].get('SSL', False) else 'redis'

     

       16
       15
        
        CACHING_REDIS_SKIP_TLS_VERIFY = REDIS['caching'].get('INSECURE_SKIP_TLS_VERIFY', False)

     

       16
       16
       +
        CACHING_REDIS_CA_CERT_PATH = REDIS['caching'].get('CA_CERT_PATH', False)

     

       17
       17
        
       +CACHING_REDIS_URL = REDIS['caching'].get('URL', f'{CACHING_REDIS_PROTO}://{CACHING_REDIS_HOST}:{CACHING_REDIS_PORT}/{CACHING_REDIS_DATABASE}')

     

       18
       18
        
        

     

       19
       19
        
        CACHES = {

     

       20
       20
        
            'default': {

     

       21
       21
        
                'BACKEND': 'django_redis.cache.RedisCache',

     

       22
       22
       -
       -        'LOCATION': f'{CACHING_REDIS_PROTO}://{CACHING_REDIS_HOST}:{CACHING_REDIS_PORT}/{CACHING_REDIS_DATABASE}',

     

       22
       22
       +
       -        'LOCATION': f'{CACHING_REDIS_PROTO}://{CACHING_REDIS_USERNAME_HOST}:{CACHING_REDIS_PORT}/{CACHING_REDIS_DATABASE}',

     

       23
       23
        
       +        'LOCATION': CACHING_REDIS_URL,

     

       24
       24
        
                'OPTIONS': {

     

       25
       25
        
                    'CLIENT_CLASS': 'django_redis.client.DefaultClient',

     

       26
       26
        
                    'PASSWORD': CACHING_REDIS_PASSWORD,

     

       27
       27
       -
       @@ -383,7 +385,7 @@ USE_X_FORWARDED_HOST = True

     

       27
       27
       +
       @@ -410,7 +412,7 @@ USE_X_FORWARDED_HOST = True

     

       28
       28
        
        X_FRAME_OPTIONS = 'SAMEORIGIN'

     

       29
       29
        
        

     

       30
       30
        
        # Static files (CSS, JavaScript, Images)

     
···

       33
       33
        
        STATIC_URL = f'/{BASE_PATH}static/'

     

       34
       34
        
        STATICFILES_DIRS = (

     

       35
       35
        
            os.path.join(BASE_DIR, 'project-static', 'dist'),

     

       36
       36
       -
       @@ -562,6 +564,14 @@ if TASKS_REDIS_USING_SENTINEL:

     

       36
       36
       +
       @@ -640,6 +642,14 @@ if TASKS_REDIS_USING_SENTINEL:

     

       37
       37
        
                    'socket_connect_timeout': TASKS_REDIS_SENTINEL_TIMEOUT

     

       38
       38
        
                },

     

       39
       39
        
            }

+50

pkgs/servers/web-apps/netbox/config_3_3.patch

···

       1
       1
       +
       diff --git a/netbox/netbox/settings.py b/netbox/netbox/settings.py

     

       2
       2
       +
       index d5a7bfaec..68754a8c5 100644

     

       3
       3
       +
       --- a/netbox/netbox/settings.py

     

       4
       4
       +
       +++ b/netbox/netbox/settings.py

     

       5
       5
       +
       @@ -222,6 +222,7 @@ TASKS_REDIS_PASSWORD = TASKS_REDIS.get('PASSWORD', '')

     

       6
       6
       +
        TASKS_REDIS_DATABASE = TASKS_REDIS.get('DATABASE', 0)

     

       7
       7
       +
        TASKS_REDIS_SSL = TASKS_REDIS.get('SSL', False)

     

       8
       8
       +
        TASKS_REDIS_SKIP_TLS_VERIFY = TASKS_REDIS.get('INSECURE_SKIP_TLS_VERIFY', False)

     

       9
       9
       +
       +TASKS_REDIS_URL = TASKS_REDIS.get('URL')

     

       10
       10
       +
        

     

       11
       11
       +
        # Caching

     

       12
       12
       +
        if 'caching' not in REDIS:

     

       13
       13
       +
       @@ -236,11 +237,12 @@ CACHING_REDIS_SENTINELS = REDIS['caching'].get('SENTINELS', [])

     

       14
       14
       +
        CACHING_REDIS_SENTINEL_SERVICE = REDIS['caching'].get('SENTINEL_SERVICE', 'default')

     

       15
       15
       +
        CACHING_REDIS_PROTO = 'rediss' if REDIS['caching'].get('SSL', False) else 'redis'

     

       16
       16
       +
        CACHING_REDIS_SKIP_TLS_VERIFY = REDIS['caching'].get('INSECURE_SKIP_TLS_VERIFY', False)

     

       17
       17
       +
       +CACHING_REDIS_URL = REDIS['caching'].get('URL', f'{CACHING_REDIS_PROTO}://{CACHING_REDIS_HOST}:{CACHING_REDIS_PORT}/{CACHING_REDIS_DATABASE}')

     

       18
       18
       +
        

     

       19
       19
       +
        CACHES = {

     

       20
       20
       +
            'default': {

     

       21
       21
       +
                'BACKEND': 'django_redis.cache.RedisCache',

     

       22
       22
       +
       -        'LOCATION': f'{CACHING_REDIS_PROTO}://{CACHING_REDIS_HOST}:{CACHING_REDIS_PORT}/{CACHING_REDIS_DATABASE}',

     

       23
       23
       +
       +        'LOCATION': CACHING_REDIS_URL,

     

       24
       24
       +
                'OPTIONS': {

     

       25
       25
       +
                    'CLIENT_CLASS': 'django_redis.client.DefaultClient',

     

       26
       26
       +
                    'PASSWORD': CACHING_REDIS_PASSWORD,

     

       27
       27
       +
       @@ -383,7 +385,7 @@ USE_X_FORWARDED_HOST = True

     

       28
       28
       +
        X_FRAME_OPTIONS = 'SAMEORIGIN'

     

       29
       29
       +
        

     

       30
       30
       +
        # Static files (CSS, JavaScript, Images)

     

       31
       31
       +
       -STATIC_ROOT = BASE_DIR + '/static'

     

       32
       32
       +
       +STATIC_ROOT = getattr(configuration, 'STATIC_ROOT', os.path.join(BASE_DIR, 'static')).rstrip('/')

     

       33
       33
       +
        STATIC_URL = f'/{BASE_PATH}static/'

     

       34
       34
       +
        STATICFILES_DIRS = (

     

       35
       35
       +
            os.path.join(BASE_DIR, 'project-static', 'dist'),

     

       36
       36
       +
       @@ -562,6 +564,14 @@ if TASKS_REDIS_USING_SENTINEL:

     

       37
       37
       +
                    'socket_connect_timeout': TASKS_REDIS_SENTINEL_TIMEOUT

     

       38
       38
       +
                },

     

       39
       39
       +
            }

     

       40
       40
       +
       +elif TASKS_REDIS_URL:

     

       41
       41
       +
       +    RQ_PARAMS = {

     

       42
       42
       +
       +        'URL': TASKS_REDIS_URL,

     

       43
       43
       +
       +        'PASSWORD': TASKS_REDIS_PASSWORD,

     

       44
       44
       +
       +        'SSL': TASKS_REDIS_SSL,

     

       45
       45
       +
       +        'SSL_CERT_REQS': None if TASKS_REDIS_SKIP_TLS_VERIFY else 'required',

     

       46
       46
       +
       +        'DEFAULT_TIMEOUT': RQ_DEFAULT_TIMEOUT,

     

       47
       47
       +
       +    }

     

       48
       48
       +
        else:

     

       49
       49
       +
            RQ_PARAMS = {

     

       50
       50
       +
                'HOST': TASKS_REDIS_HOST,

+23 -101

pkgs/servers/web-apps/netbox/default.nix

···

       1
       1
       -
       { lib

     

       2
       2
       -
       , pkgs

     

       3
       3
       -
       , fetchFromGitHub

     

       4
       4
       -
       , fetchpatch

     

       5
       5
       -
       , nixosTests

     

       6
       6
       -
       , python3

     

       7
       7
       -
       

     

       8
       8
       -
       , plugins ? ps: [] }:

     

       9
       9
       -
       

     

       1
       1
       +
       { lib, nixosTests, callPackage, fetchpatch }:

     

       10
       2
        
       let

     

       11
       11
       -
         py = python3 // {

     

       12
       12
       -
           pkgs = python3.pkgs.overrideScope (self: super: {

     

       13
       13
       -
             django = super.django_4;

     

       14
       14
       -
           });

     

       15
       15
       -
         };

     

       16
       16
       -
       

     

       17
       17
       -
         extraBuildInputs = plugins py.pkgs;

     

       3
       3
       +
         generic = import ./generic.nix;

     

       18
       4
        
       in

     

       19
       19
       -
       py.pkgs.buildPythonApplication rec {

     

       20
       20
       -
           pname = "netbox";

     

       21
       21
       -
           version = "3.3.9";

     

       22
       22
       -
       

     

       23
       23
       -
           format = "other";

     

       24
       24
       -
       

     

       25
       25
       -
           src = fetchFromGitHub {

     

       26
       26
       -
             owner = "netbox-community";

     

       27
       27
       -
             repo = pname;

     

       28
       28
       -
             rev = "refs/tags/v${version}";

     

       29
       29
       -
             sha256 = "sha256-KhnxD5pjlEIgISl4RMbhLCDwgUDfGFRi88ZcP1ndMhI=";

     

       30
       30
       -
           };

     

       31
       31
       -
       

     

       32
       32
       -
           patches = [

     

       5
       5
       +
       {

     

       6
       6
       +
         netbox_3_3 = callPackage generic {

     

       7
       7
       +
           version = "3.3.10";

     

       8
       8
       +
           hash = "sha256-MeOfTU5IxNDoUh7FyvwAQNRC/CE0R6p40WnlF+3RuxA=";

     

       9
       9
       +
           extraPatches = [

     

       33
       10
        
             # Allow setting the STATIC_ROOT from within the configuration and setting a custom redis URL

     

       34
       34
       -
             ./config.patch

     

       11
       11
       +
             ./config_3_3.patch

     

       35
       12
        
             ./graphql-3_2_0.patch

     

       36
       13
        
             # fix compatibility ith django 4.1

     

       37
       14
        
             (fetchpatch {

     
···

       40
       17
        
             })

     

       41
       18
        
           ];

     

       42
       19
        
       

     

       43
       43
       -
           propagatedBuildInputs = with py.pkgs; [

     

       44
       44
       -
             bleach

     

       45
       45
       -
             django_4

     

       46
       46
       -
             django-cors-headers

     

       47
       47
       -
             django-debug-toolbar

     

       48
       48
       -
             django-filter

     

       49
       49
       -
             django-graphiql-debug-toolbar

     

       50
       50
       -
             django-mptt

     

       51
       51
       -
             django-pglocks

     

       52
       52
       -
             django-prometheus

     

       53
       53
       -
             django-redis

     

       54
       54
       -
             django-rq

     

       55
       55
       -
             django-tables2

     

       56
       56
       -
             django-taggit

     

       57
       57
       -
             django-timezone-field

     

       58
       58
       -
             djangorestframework

     

       59
       59
       -
             drf-yasg

     

       60
       60
       -
             swagger-spec-validator # from drf-yasg[validation]

     

       61
       61
       -
             graphene-django

     

       62
       62
       -
             jinja2

     

       63
       63
       -
             markdown

     

       64
       64
       -
             markdown-include

     

       65
       65
       -
             netaddr

     

       66
       66
       -
             pillow

     

       67
       67
       -
             psycopg2

     

       68
       68
       -
             pyyaml

     

       69
       69
       -
             sentry-sdk

     

       70
       70
       -
             social-auth-core

     

       71
       71
       -
             social-auth-app-django

     

       72
       72
       -
             svgwrite

     

       73
       73
       -
             tablib

     

       74
       74
       -
             jsonschema

     

       75
       75
       -
           ] ++ extraBuildInputs;

     

       20
       20
       +
           tests.netbox = nixosTests.netbox_3_3;

     

       21
       21
       +
           maintainers = with lib.maintainers; [ n0emis raitobezarius ];

     

       22
       22
       +
           eol = true;

     

       23
       23
       +
         };

     

       76
       24
        
       

     

       77
       77
       -
           buildInputs = with py.pkgs; [

     

       78
       78
       -
             mkdocs-material

     

       79
       79
       -
             mkdocs-material-extensions

     

       80
       80
       -
             mkdocstrings

     

       81
       81
       -
             mkdocstrings-python

     

       25
       25
       +
         netbox = callPackage generic {

     

       26
       26
       +
           version = "3.4.7";

     

       27
       27
       +
           hash = "sha256-pWHGyzLc0tqfehWbCMF1l96L1pewb5FXBUkw9EqPtP8=";

     

       28
       28
       +
           extraPatches = [

     

       29
       29
       +
             # Allow setting the STATIC_ROOT from within the configuration and setting a custom redis URL

     

       30
       30
       +
             ./config.patch

     

       82
       31
        
           ];

     

       83
       83
       -
       

     

       84
       84
       -
           nativeBuildInputs = [

     

       85
       85
       -
             py.pkgs.mkdocs

     

       86
       86
       -
           ];

     

       87
       87
       -
       

     

       88
       88
       -
           postBuild = ''

     

       89
       89
       -
             PYTHONPATH=$PYTHONPATH:netbox/

     

       90
       90
       -
             python -m mkdocs build

     

       91
       91
       -
           '';

     

       92
       92
       -
       

     

       93
       93
       -
           installPhase = ''

     

       94
       94
       -
             mkdir -p $out/opt/netbox

     

       95
       95
       -
             cp -r . $out/opt/netbox

     

       96
       96
       -
             chmod +x $out/opt/netbox/netbox/manage.py

     

       97
       97
       -
             makeWrapper $out/opt/netbox/netbox/manage.py $out/bin/netbox \

     

       98
       98
       -
               --prefix PYTHONPATH : "$PYTHONPATH"

     

       99
       99
       -
           '';

     

       100
       100
       -
       

     

       101
       101
       -
           passthru = {

     

       102
       102
       -
             # PYTHONPATH of all dependencies used by the package

     

       103
       103
       -
             pythonPath = python3.pkgs.makePythonPath propagatedBuildInputs;

     

       104
       104
       -
       

     

       105
       105
       -
             tests = {

     

       106
       106
       -
               inherit (nixosTests) netbox;

     

       107
       107
       -
             };

     

       32
       32
       +
           tests = {

     

       33
       33
       +
             inherit (nixosTests) netbox;

     

       108
       34
        
           };

     

       109
       35
        
       

     

       110
       110
       -
           meta = with lib; {

     

       111
       111
       -
             homepage = "https://github.com/netbox-community/netbox";

     

       112
       112
       -
             description = "IP address management (IPAM) and data center infrastructure management (DCIM) tool";

     

       113
       113
       -
             license = licenses.asl20;

     

       114
       114
       -
             maintainers = with maintainers; [ n0emis raitobezarius ];

     

       115
       115
       -
           };

     

       116
       116
       -
         }

     

       36
       36
       +
           maintainers = with lib.maintainers; [ minijackson n0emis raitobezarius ];

     

       37
       37
       +
         };

     

       38
       38
       +
       }

+110

pkgs/servers/web-apps/netbox/generic.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , fetchFromGitHub

     

       3
       3
       +
       , python3

     

       4
       4
       +
       , version

     

       5
       5
       +
       , hash

     

       6
       6
       +
       , plugins ? ps: []

     

       7
       7
       +
       , extraPatches ? []

     

       8
       8
       +
       , tests ? {}

     

       9
       9
       +
       , maintainers ? []

     

       10
       10
       +
       , eol ? false

     

       11
       11
       +
       }:

     

       12
       12
       +
         let

     

       13
       13
       +
           py = python3 // {

     

       14
       14
       +
             pkgs = python3.pkgs.overrideScope (self: super: {

     

       15
       15
       +
               django = super.django_4;

     

       16
       16
       +
             });

     

       17
       17
       +
           };

     

       18
       18
       +
       

     

       19
       19
       +
           extraBuildInputs = plugins py.pkgs;

     

       20
       20
       +
         in

     

       21
       21
       +
         py.pkgs.buildPythonApplication rec {

     

       22
       22
       +
             pname = "netbox";

     

       23
       23
       +
             inherit version;

     

       24
       24
       +
       

     

       25
       25
       +
             format = "other";

     

       26
       26
       +
       

     

       27
       27
       +
             src = fetchFromGitHub {

     

       28
       28
       +
               owner = "netbox-community";

     

       29
       29
       +
               repo = pname;

     

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

     

       31
       31
       +
               inherit hash;

     

       32
       32
       +
             };

     

       33
       33
       +
       

     

       34
       34
       +
             patches = extraPatches;

     

       35
       35
       +
       

     

       36
       36
       +
             propagatedBuildInputs = with py.pkgs; [

     

       37
       37
       +
               bleach

     

       38
       38
       +
               django_4

     

       39
       39
       +
               django-cors-headers

     

       40
       40
       +
               django-debug-toolbar

     

       41
       41
       +
               django-filter

     

       42
       42
       +
               django-graphiql-debug-toolbar

     

       43
       43
       +
               django-mptt

     

       44
       44
       +
               django-pglocks

     

       45
       45
       +
               django-prometheus

     

       46
       46
       +
               django-redis

     

       47
       47
       +
               django-rq

     

       48
       48
       +
               django-tables2

     

       49
       49
       +
               django-taggit

     

       50
       50
       +
               django-timezone-field

     

       51
       51
       +
               djangorestframework

     

       52
       52
       +
               drf-yasg

     

       53
       53
       +
               swagger-spec-validator # from drf-yasg[validation]

     

       54
       54
       +
               graphene-django

     

       55
       55
       +
               jinja2

     

       56
       56
       +
               markdown

     

       57
       57
       +
               markdown-include

     

       58
       58
       +
               netaddr

     

       59
       59
       +
               pillow

     

       60
       60
       +
               psycopg2

     

       61
       61
       +
               pyyaml

     

       62
       62
       +
               sentry-sdk

     

       63
       63
       +
               social-auth-core

     

       64
       64
       +
               social-auth-app-django

     

       65
       65
       +
               svgwrite

     

       66
       66
       +
               tablib

     

       67
       67
       +
               jsonschema

     

       68
       68
       +
             ] ++ extraBuildInputs;

     

       69
       69
       +
       

     

       70
       70
       +
             buildInputs = with py.pkgs; [

     

       71
       71
       +
               mkdocs-material

     

       72
       72
       +
               mkdocs-material-extensions

     

       73
       73
       +
               mkdocstrings

     

       74
       74
       +
               mkdocstrings-python

     

       75
       75
       +
             ];

     

       76
       76
       +
       

     

       77
       77
       +
             nativeBuildInputs = [

     

       78
       78
       +
               py.pkgs.mkdocs

     

       79
       79
       +
             ];

     

       80
       80
       +
       

     

       81
       81
       +
             postBuild = ''

     

       82
       82
       +
               PYTHONPATH=$PYTHONPATH:netbox/

     

       83
       83
       +
               python -m mkdocs build

     

       84
       84
       +
             '';

     

       85
       85
       +
       

     

       86
       86
       +
             installPhase = ''

     

       87
       87
       +
               mkdir -p $out/opt/netbox

     

       88
       88
       +
               cp -r . $out/opt/netbox

     

       89
       89
       +
               chmod +x $out/opt/netbox/netbox/manage.py

     

       90
       90
       +
               makeWrapper $out/opt/netbox/netbox/manage.py $out/bin/netbox \

     

       91
       91
       +
                 --prefix PYTHONPATH : "$PYTHONPATH"

     

       92
       92
       +
             '';

     

       93
       93
       +
       

     

       94
       94
       +
             passthru = {

     

       95
       95
       +
               # PYTHONPATH of all dependencies used by the package

     

       96
       96
       +
               pythonPath = python3.pkgs.makePythonPath propagatedBuildInputs;

     

       97
       97
       +
               inherit tests;

     

       98
       98
       +
             };

     

       99
       99
       +
       

     

       100
       100
       +
             meta = {

     

       101
       101
       +
               homepage = "https://github.com/netbox-community/netbox";

     

       102
       102
       +
               description = "IP address management (IPAM) and data center infrastructure management (DCIM) tool";

     

       103
       103
       +
               license = lib.licenses.asl20;

     

       104
       104
       +
               knownVulnerabilities = (lib.optional eol "Netbox version ${version} is EOL; please upgrade by following the current release notes instructions.");

     

       105
       105
       +
               # Warning:

     

       106
       106
       +
               # Notice the missing `lib` in the inherit: it is using this function argument rather than a `with lib;` argument.

     

       107
       107
       +
               # If you replace this by `with lib;`, pay attention it does not inherit all maintainers in nixpkgs.

     

       108
       108
       +
               inherit maintainers;

     

       109
       109
       +
             };

     

       110
       110
       +
           }

+2 -1

pkgs/top-level/all-packages.nix

···

       10170
       10170
        
       

     

       10171
       10171
        
         netbootxyz-efi = callPackage ../tools/misc/netbootxyz-efi { };

     

       10172
       10172
        
       

     

       10173
       10173
       -
         netbox = callPackage ../servers/web-apps/netbox { };

     

       10173
       10173
       +
         inherit (callPackage ../servers/web-apps/netbox { })

     

       10174
       10174
       +
           netbox_3_3 netbox;

     

       10174
       10175
        
       

     

       10175
       10176
        
         netcat = libressl.nc;

     

       10176
       10177