commit ec17e680af316502515337f7f4222c80ec783fe8 · pyrox.dev/nixpkgs

+1 -1

maintainers/team-list.nix

···

       818
       818
        
             megheaiulian

     

       819
       819
        
             mkg20001

     

       820
       820
        
           ];

     

       821
       821
       -
           scope = "All things linuxcontainers. LXC, Incus, LXD and related packages.";

     

       821
       821
       +
           scope = "All things linuxcontainers. Incus, LXC, and related packages.";

     

       822
       822
        
           shortName = "lxc";

     

       823
       823
        
         };

     

       824
       824

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

···

       134
       134
        
       

     

       135
       135
        
       - The `services.polipo` module has been removed as `polipo` is unmaintained and archived upstream.

     

       136
       136
        
       

     

       137
       137
       +
       - `virtualisation.lxd` has been removed due to lack of Nixpkgs maintenance. Users can migrate to `virtualisation.incus`, a fork of LXD, as a replacement. See [Incus migration documentation](https://linuxcontainers.org/incus/docs/main/howto/server_migrate_lxd/) for migration information.

     

       138
       138
       +
       

     

       137
       139
        
       - The non-LTS Forgejo package (`forgejo`) has been updated to 12.0.0. This release contains breaking changes, see the [release blog post](https://forgejo.org/2025-07-release-v12-0/)

     

       138
       140
        
         for all the details and how to ensure smooth upgrades.

     

       139
       141

-1

nixos/modules/misc/ids.nix

···

       584
       584
        
             #shout = 206; #unused

     

       585
       585
        
             #gateone = 207; #removed 2025-08-21

     

       586
       586
        
             namecoin = 208;

     

       587
       587
       -
             #lxd = 210; # unused

     

       588
       587
        
             #kibana = 211;

     

       589
       588
        
             xtreemfs = 212;

     

       590
       589
        
             calibre-server = 213;

-2

nixos/modules/module-list.nix

···

       1921
       1921
        
         ./virtualisation/libvirtd.nix

     

       1922
       1922
        
         ./virtualisation/lxc.nix

     

       1923
       1923
        
         ./virtualisation/lxcfs.nix

     

       1924
       1924
       -
         ./virtualisation/lxd-agent.nix

     

       1925
       1925
       -
         ./virtualisation/lxd.nix

     

       1926
       1924
        
         ./virtualisation/multipass.nix

     

       1927
       1925
        
         ./virtualisation/nixos-containers.nix

     

       1928
       1926
        
         ./virtualisation/oci-containers.nix

+1 -1

nixos/modules/virtualisation/lxc-image-metadata.nix

···

       77
       77
        
         options = {

     

       78
       78
        
           virtualisation.lxc = {

     

       79
       79
        
             templates = lib.mkOption {

     

       80
       80
       -
               description = "Templates for LXD";

     

       80
       80
       +
               description = "Templates for LXC images";

     

       81
       81
        
               type = lib.types.attrsOf (lib.types.submodule templateSubmodule);

     

       82
       82
        
               default = { };

     

       83
       83
        
               example = lib.literalExpression ''

-110

nixos/modules/virtualisation/lxd-agent.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.virtualisation.lxd.agent;

     

       10
       10
       -
       

     

       11
       11
       -
         # the lxd agent is provided by the lxd daemon through a virtiofs or 9p mount

     

       12
       12
       -
         # this is a port of the distrobuilder lxd-agent generator

     

       13
       13
       -
         # https://github.com/lxc/distrobuilder/blob/f77300bf7d7d5707b08eaf8a434d647d1ba81b5d/generators/lxd-agent.go#L18-L55

     

       14
       14
       -
         preStartScript = ''

     

       15
       15
       -
           PREFIX="/run/lxd_agent"

     

       16
       16
       -
       

     

       17
       17
       -
           mount_virtiofs() {

     

       18
       18
       -
               mount -t virtiofs config "$PREFIX/.mnt" >/dev/null 2>&1

     

       19
       19
       -
           }

     

       20
       20
       -
       

     

       21
       21
       -
           mount_9p() {

     

       22
       22
       -
               modprobe 9pnet_virtio >/dev/null 2>&1 || true

     

       23
       23
       -
               mount -t 9p config "$PREFIX/.mnt" -o access=0,trans=virtio,size=1048576 >/dev/null 2>&1

     

       24
       24
       -
           }

     

       25
       25
       -
       

     

       26
       26
       -
           fail() {

     

       27
       27
       -
               umount -l "$PREFIX" >/dev/null 2>&1 || true

     

       28
       28
       -
               rmdir "$PREFIX" >/dev/null 2>&1 || true

     

       29
       29
       -
               echo "$1"

     

       30
       30
       -
               exit 1

     

       31
       31
       -
           }

     

       32
       32
       -
       

     

       33
       33
       -
           # Setup the mount target.

     

       34
       34
       -
           umount -l "$PREFIX" >/dev/null 2>&1 || true

     

       35
       35
       -
           mkdir -p "$PREFIX"

     

       36
       36
       -
           mount -t tmpfs tmpfs "$PREFIX" -o mode=0700,size=50M

     

       37
       37
       -
           mkdir -p "$PREFIX/.mnt"

     

       38
       38
       -
       

     

       39
       39
       -
           # Try virtiofs first.

     

       40
       40
       -
           mount_virtiofs || mount_9p || fail "Couldn't mount virtiofs or 9p, failing."

     

       41
       41
       -
       

     

       42
       42
       -
           # Copy the data.

     

       43
       43
       -
           cp -Ra "$PREFIX/.mnt/"* "$PREFIX"

     

       44
       44
       -
       

     

       45
       45
       -
           # Unmount the temporary mount.

     

       46
       46
       -
           umount "$PREFIX/.mnt"

     

       47
       47
       -
           rmdir "$PREFIX/.mnt"

     

       48
       48
       -
       

     

       49
       49
       -
           # Fix up permissions.

     

       50
       50
       -
           chown -R root:root "$PREFIX"

     

       51
       51
       -
         '';

     

       52
       52
       -
       in

     

       53
       53
       -
       {

     

       54
       54
       -
         options = {

     

       55
       55
       -
           virtualisation.lxd.agent.enable = lib.mkEnableOption "LXD agent";

     

       56
       56
       -
         };

     

       57
       57
       -
       

     

       58
       58
       -
         config = lib.mkIf cfg.enable {

     

       59
       59
       -
           # https://github.com/lxc/distrobuilder/blob/f77300bf7d7d5707b08eaf8a434d647d1ba81b5d/generators/lxd-agent.go#L108-L125

     

       60
       60
       -
           systemd.services.lxd-agent = {

     

       61
       61
       -
             enable = true;

     

       62
       62
       -
             wantedBy = [ "multi-user.target" ];

     

       63
       63
       -
             before = [

     

       64
       64
       -
               "shutdown.target"

     

       65
       65
       -
             ]

     

       66
       66
       -
             ++ lib.optionals config.services.cloud-init.enable [

     

       67
       67
       -
               "cloud-init.target"

     

       68
       68
       -
               "cloud-init.service"

     

       69
       69
       -
               "cloud-init-local.service"

     

       70
       70
       -
             ];

     

       71
       71
       -
             conflicts = [ "shutdown.target" ];

     

       72
       72
       -
             path = [

     

       73
       73
       -
               pkgs.kmod

     

       74
       74
       -
               pkgs.util-linux

     

       75
       75
       -
       

     

       76
       76
       -
               # allow `incus exec` to find system binaries

     

       77
       77
       -
               "/run/current-system/sw"

     

       78
       78
       -
             ];

     

       79
       79
       -
       

     

       80
       80
       -
             preStart = preStartScript;

     

       81
       81
       -
       

     

       82
       82
       -
             # avoid killing nixos-rebuild switch when executed through lxc exec

     

       83
       83
       -
             restartIfChanged = false;

     

       84
       84
       -
             stopIfChanged = false;

     

       85
       85
       -
       

     

       86
       86
       -
             unitConfig = {

     

       87
       87
       -
               Description = "LXD - agent";

     

       88
       88
       -
               Documentation = "https://documentation.ubuntu.com/lxd/en/latest";

     

       89
       89
       -
               ConditionPathExists = "/dev/virtio-ports/org.linuxcontainers.lxd";

     

       90
       90
       -
               DefaultDependencies = "no";

     

       91
       91
       -
               StartLimitInterval = "60";

     

       92
       92
       -
               StartLimitBurst = "10";

     

       93
       93
       -
             };

     

       94
       94
       -
       

     

       95
       95
       -
             serviceConfig = {

     

       96
       96
       -
               Type = "notify";

     

       97
       97
       -
               WorkingDirectory = "-/run/lxd_agent";

     

       98
       98
       -
               ExecStart = "/run/lxd_agent/lxd-agent";

     

       99
       99
       -
               Restart = "on-failure";

     

       100
       100
       -
               RestartSec = "5s";

     

       101
       101
       -
             };

     

       102
       102
       -
           };

     

       103
       103
       -
       

     

       104
       104
       -
           systemd.paths.lxd-agent = {

     

       105
       105
       -
             enable = true;

     

       106
       106
       -
             wantedBy = [ "multi-user.target" ];

     

       107
       107
       -
             pathConfig.PathExists = "/dev/virtio-ports/org.linuxcontainers.lxd";

     

       108
       108
       -
           };

     

       109
       109
       -
         };

     

       110
       110
       -
       }

-283

nixos/modules/virtualisation/lxd.nix

···

       1
       1
       -
       # Systemd services for lxd.

     

       2
       2
       -
       

     

       3
       3
       -
       {

     

       4
       4
       -
         config,

     

       5
       5
       -
         lib,

     

       6
       6
       -
         pkgs,

     

       7
       7
       -
         ...

     

       8
       8
       -
       }:

     

       9
       9
       -
       

     

       10
       10
       -
       let

     

       11
       11
       -
         cfg = config.virtualisation.lxd;

     

       12
       12
       -
         preseedFormat = pkgs.formats.yaml { };

     

       13
       13
       -
       in

     

       14
       14
       -
       {

     

       15
       15
       -
         imports = [

     

       16
       16
       -
           (lib.mkRemovedOptionModule [

     

       17
       17
       -
             "virtualisation"

     

       18
       18
       -
             "lxd"

     

       19
       19
       -
             "zfsPackage"

     

       20
       20
       -
           ] "Override zfs in an overlay instead to override it globally")

     

       21
       21
       -
         ];

     

       22
       22
       -
       

     

       23
       23
       -
         options = {

     

       24
       24
       -
           virtualisation.lxd = {

     

       25
       25
       -
             enable = lib.mkOption {

     

       26
       26
       -
               type = lib.types.bool;

     

       27
       27
       -
               default = false;

     

       28
       28
       -
               description = ''

     

       29
       29
       -
                 This option enables lxd, a daemon that manages

     

       30
       30
       -
                 containers. Users in the "lxd" group can interact with

     

       31
       31
       -
                 the daemon (e.g. to start or stop containers) using the

     

       32
       32
       -
                 {command}`lxc` command line tool, among others.

     

       33
       33
       -
       

     

       34
       34
       -
                 Most of the time, you'll also want to start lxcfs, so

     

       35
       35
       -
                 that containers can "see" the limits:

     

       36
       36
       -
                 ```

     

       37
       37
       -
                 virtualisation.lxc.lxcfs.enable = true;

     

       38
       38
       -
                 ```

     

       39
       39
       -
               '';

     

       40
       40
       -
             };

     

       41
       41
       -
       

     

       42
       42
       -
             package = lib.mkPackageOption pkgs "lxd-lts" { };

     

       43
       43
       -
       

     

       44
       44
       -
             lxcPackage = lib.mkOption {

     

       45
       45
       -
               type = lib.types.package;

     

       46
       46
       -
               default = config.virtualisation.lxc.package;

     

       47
       47
       -
               defaultText = lib.literalExpression "config.virtualisation.lxc.package";

     

       48
       48
       -
               description = "The lxc package to use.";

     

       49
       49
       -
             };

     

       50
       50
       -
       

     

       51
       51
       -
             zfsSupport = lib.mkOption {

     

       52
       52
       -
               type = lib.types.bool;

     

       53
       53
       -
               default = config.boot.zfs.enabled;

     

       54
       54
       -
               defaultText = lib.literalExpression "config.boot.zfs.enabled";

     

       55
       55
       -
               description = ''

     

       56
       56
       -
                 Enables lxd to use zfs as a storage for containers.

     

       57
       57
       -
       

     

       58
       58
       -
                 This option is enabled by default if a zfs pool is configured

     

       59
       59
       -
                 with nixos.

     

       60
       60
       -
               '';

     

       61
       61
       -
             };

     

       62
       62
       -
       

     

       63
       63
       -
             recommendedSysctlSettings = lib.mkOption {

     

       64
       64
       -
               type = lib.types.bool;

     

       65
       65
       -
               default = false;

     

       66
       66
       -
               description = ''

     

       67
       67
       -
                 Enables various settings to avoid common pitfalls when

     

       68
       68
       -
                 running containers requiring many file operations.

     

       69
       69
       -
                 Fixes errors like "Too many open files" or

     

       70
       70
       -
                 "neighbour: ndisc_cache: neighbor table overflow!".

     

       71
       71
       -
                 See <https://lxd.readthedocs.io/en/latest/production-setup/>

     

       72
       72
       -
                 for details.

     

       73
       73
       -
               '';

     

       74
       74
       -
             };

     

       75
       75
       -
       

     

       76
       76
       -
             preseed = lib.mkOption {

     

       77
       77
       -
               type = lib.types.nullOr (

     

       78
       78
       -
                 lib.types.submodule {

     

       79
       79
       -
                   freeformType = preseedFormat.type;

     

       80
       80
       -
                 }

     

       81
       81
       -
               );

     

       82
       82
       -
       

     

       83
       83
       -
               default = null;

     

       84
       84
       -
       

     

       85
       85
       -
               description = ''

     

       86
       86
       -
                 Configuration for LXD preseed, see

     

       87
       87
       -
                 <https://documentation.ubuntu.com/lxd/en/latest/howto/initialize/#initialize-preseed>

     

       88
       88
       -
                 for supported values.

     

       89
       89
       -
       

     

       90
       90
       -
                 Changes to this will be re-applied to LXD which will overwrite existing entities or create missing ones,

     

       91
       91
       -
                 but entities will *not* be removed by preseed.

     

       92
       92
       -
               '';

     

       93
       93
       -
       

     

       94
       94
       -
               example = lib.literalExpression ''

     

       95
       95
       -
                 {

     

       96
       96
       -
                   networks = [

     

       97
       97
       -
                     {

     

       98
       98
       -
                       name = "lxdbr0";

     

       99
       99
       -
                       type = "bridge";

     

       100
       100
       -
                       config = {

     

       101
       101
       -
                         "ipv4.address" = "10.0.100.1/24";

     

       102
       102
       -
                         "ipv4.nat" = "true";

     

       103
       103
       -
                       };

     

       104
       104
       -
                     }

     

       105
       105
       -
                   ];

     

       106
       106
       -
                   profiles = [

     

       107
       107
       -
                     {

     

       108
       108
       -
                       name = "default";

     

       109
       109
       -
                       devices = {

     

       110
       110
       -
                         eth0 = {

     

       111
       111
       -
                           name = "eth0";

     

       112
       112
       -
                           network = "lxdbr0";

     

       113
       113
       -
                           type = "nic";

     

       114
       114
       -
                         };

     

       115
       115
       -
                         root = {

     

       116
       116
       -
                           path = "/";

     

       117
       117
       -
                           pool = "default";

     

       118
       118
       -
                           size = "35GiB";

     

       119
       119
       -
                           type = "disk";

     

       120
       120
       -
                         };

     

       121
       121
       -
                       };

     

       122
       122
       -
                     }

     

       123
       123
       -
                   ];

     

       124
       124
       -
                   storage_pools = [

     

       125
       125
       -
                     {

     

       126
       126
       -
                       name = "default";

     

       127
       127
       -
                       driver = "dir";

     

       128
       128
       -
                       config = {

     

       129
       129
       -
                         source = "/var/lib/lxd/storage-pools/default";

     

       130
       130
       -
                       };

     

       131
       131
       -
                     }

     

       132
       132
       -
                   ];

     

       133
       133
       -
                 }

     

       134
       134
       -
               '';

     

       135
       135
       -
             };

     

       136
       136
       -
       

     

       137
       137
       -
             startTimeout = lib.mkOption {

     

       138
       138
       -
               type = lib.types.int;

     

       139
       139
       -
               default = 600;

     

       140
       140
       -
               apply = toString;

     

       141
       141
       -
               description = ''

     

       142
       142
       -
                 Time to wait (in seconds) for LXD to become ready to process requests.

     

       143
       143
       -
                 If LXD does not reply within the configured time, lxd.service will be

     

       144
       144
       -
                 considered failed and systemd will attempt to restart it.

     

       145
       145
       -
               '';

     

       146
       146
       -
             };

     

       147
       147
       -
       

     

       148
       148
       -
             ui = {

     

       149
       149
       -
               enable = lib.mkEnableOption "(experimental) LXD UI";

     

       150
       150
       -
       

     

       151
       151
       -
               package = lib.mkPackageOption pkgs [ "lxd-ui" ] { };

     

       152
       152
       -
             };

     

       153
       153
       -
           };

     

       154
       154
       -
         };

     

       155
       155
       -
       

     

       156
       156
       -
         ###### implementation

     

       157
       157
       -
         config = lib.mkIf cfg.enable {

     

       158
       158
       -
           environment.systemPackages = [ cfg.package ];

     

       159
       159
       -
       

     

       160
       160
       -
           # Note: the following options are also declared in virtualisation.lxc, but

     

       161
       161
       -
           # the latter can't be simply enabled to reuse the formers, because it

     

       162
       162
       -
           # does a bunch of unrelated things.

     

       163
       163
       -
           systemd.tmpfiles.rules = [ "d /var/lib/lxc/rootfs 0755 root root -" ];

     

       164
       164
       -
       

     

       165
       165
       -
           security.apparmor = {

     

       166
       166
       -
             packages = [ cfg.lxcPackage ];

     

       167
       167
       -
             policies = {

     

       168
       168
       -
               "bin.lxc-start".profile = ''

     

       169
       169
       -
                 include ${cfg.lxcPackage}/etc/apparmor.d/usr.bin.lxc-start

     

       170
       170
       -
               '';

     

       171
       171
       -
               "lxc-containers".profile = ''

     

       172
       172
       -
                 include ${cfg.lxcPackage}/etc/apparmor.d/lxc-containers

     

       173
       173
       -
               '';

     

       174
       174
       -
             };

     

       175
       175
       -
           };

     

       176
       176
       -
       

     

       177
       177
       -
           systemd.sockets.lxd = {

     

       178
       178
       -
             description = "LXD UNIX socket";

     

       179
       179
       -
             wantedBy = [ "sockets.target" ];

     

       180
       180
       -
       

     

       181
       181
       -
             socketConfig = {

     

       182
       182
       -
               ListenStream = "/var/lib/lxd/unix.socket";

     

       183
       183
       -
               SocketMode = "0660";

     

       184
       184
       -
               SocketGroup = "lxd";

     

       185
       185
       -
               Service = "lxd.service";

     

       186
       186
       -
             };

     

       187
       187
       -
           };

     

       188
       188
       -
       

     

       189
       189
       -
           systemd.services.lxd = {

     

       190
       190
       -
             description = "LXD Container Management Daemon";

     

       191
       191
       -
       

     

       192
       192
       -
             wantedBy = [ "multi-user.target" ];

     

       193
       193
       -
             after = [

     

       194
       194
       -
               "network-online.target"

     

       195
       195
       -
               (lib.mkIf config.virtualisation.lxc.lxcfs.enable "lxcfs.service")

     

       196
       196
       -
             ];

     

       197
       197
       -
             requires = [

     

       198
       198
       -
               "network-online.target"

     

       199
       199
       -
               "lxd.socket"

     

       200
       200
       -
               (lib.mkIf config.virtualisation.lxc.lxcfs.enable "lxcfs.service")

     

       201
       201
       -
             ];

     

       202
       202
       -
             documentation = [ "man:lxd(1)" ];

     

       203
       203
       -
       

     

       204
       204
       -
             path = [ pkgs.util-linux ] ++ lib.optional cfg.zfsSupport config.boot.zfs.package;

     

       205
       205
       -
       

     

       206
       206
       -
             environment = lib.mkIf (cfg.ui.enable) {

     

       207
       207
       -
               "LXD_UI" = cfg.ui.package;

     

       208
       208
       -
             };

     

       209
       209
       -
       

     

       210
       210
       -
             serviceConfig = {

     

       211
       211
       -
               ExecStart = "@${cfg.package}/bin/lxd lxd --group lxd";

     

       212
       212
       -
               ExecStartPost = "${cfg.package}/bin/lxd waitready --timeout=${cfg.startTimeout}";

     

       213
       213
       -
               ExecStop = "${cfg.package}/bin/lxd shutdown";

     

       214
       214
       -
       

     

       215
       215
       -
               KillMode = "process"; # when stopping, leave the containers alone

     

       216
       216
       -
               LimitMEMLOCK = "infinity";

     

       217
       217
       -
               LimitNOFILE = "1048576";

     

       218
       218
       -
               LimitNPROC = "infinity";

     

       219
       219
       -
               TasksMax = "infinity";

     

       220
       220
       -
               Delegate = true; # LXD needs to manage cgroups in its subtree

     

       221
       221
       -
       

     

       222
       222
       -
               # By default, `lxd` loads configuration files from hard-coded

     

       223
       223
       -
               # `/usr/share/lxc/config` - since this is a no-go for us, we have to

     

       224
       224
       -
               # explicitly tell it where the actual configuration files are

     

       225
       225
       -
               Environment = lib.mkIf (config.virtualisation.lxc.lxcfs.enable) "LXD_LXC_TEMPLATE_CONFIG=${pkgs.lxcfs}/share/lxc/config";

     

       226
       226
       -
             };

     

       227
       227
       -
       

     

       228
       228
       -
             unitConfig.ConditionPathExists = "!/var/lib/incus/.migrated-from-lxd";

     

       229
       229
       -
           };

     

       230
       230
       -
       

     

       231
       231
       -
           systemd.services.lxd-preseed = lib.mkIf (cfg.preseed != null) {

     

       232
       232
       -
             description = "LXD initialization with preseed file";

     

       233
       233
       -
             wantedBy = [ "multi-user.target" ];

     

       234
       234
       -
             requires = [ "lxd.service" ];

     

       235
       235
       -
             after = [ "lxd.service" ];

     

       236
       236
       -
       

     

       237
       237
       -
             script = ''

     

       238
       238
       -
               ${pkgs.coreutils}/bin/cat ${preseedFormat.generate "lxd-preseed.yaml" cfg.preseed} | ${cfg.package}/bin/lxd init --preseed

     

       239
       239
       -
             '';

     

       240
       240
       -
       

     

       241
       241
       -
             serviceConfig = {

     

       242
       242
       -
               Type = "oneshot";

     

       243
       243
       -
             };

     

       244
       244
       -
           };

     

       245
       245
       -
       

     

       246
       246
       -
           users.groups.lxd = { };

     

       247
       247
       -
       

     

       248
       248
       -
           users.users.root = {

     

       249
       249
       -
             subUidRanges = [

     

       250
       250
       -
               {

     

       251
       251
       -
                 startUid = 1000000;

     

       252
       252
       -
                 count = 65536;

     

       253
       253
       -
               }

     

       254
       254
       -
             ];

     

       255
       255
       -
             subGidRanges = [

     

       256
       256
       -
               {

     

       257
       257
       -
                 startGid = 1000000;

     

       258
       258
       -
                 count = 65536;

     

       259
       259
       -
               }

     

       260
       260
       -
             ];

     

       261
       261
       -
           };

     

       262
       262
       -
       

     

       263
       263
       -
           boot.kernel.sysctl = lib.mkIf cfg.recommendedSysctlSettings {

     

       264
       264
       -
             "fs.inotify.max_queued_events" = 1048576;

     

       265
       265
       -
             "fs.inotify.max_user_instances" = 1048576;

     

       266
       266
       -
             "fs.inotify.max_user_watches" = 1048576;

     

       267
       267
       -
             "vm.max_map_count" = 262144; # TODO: Default vm.max_map_count has been increased system-wide

     

       268
       268
       -
             "kernel.dmesg_restrict" = 1;

     

       269
       269
       -
             "net.ipv4.neigh.default.gc_thresh3" = 8192;

     

       270
       270
       -
             "net.ipv6.neigh.default.gc_thresh3" = 8192;

     

       271
       271
       -
             "kernel.keys.maxkeys" = 2000;

     

       272
       272
       -
           };

     

       273
       273
       -
       

     

       274
       274
       -
           boot.kernelModules = [

     

       275
       275
       -
             "veth"

     

       276
       276
       -
             "xt_comment"

     

       277
       277
       -
             "xt_CHECKSUM"

     

       278
       278
       -
             "xt_MASQUERADE"

     

       279
       279
       -
             "vhost_vsock"

     

       280
       280
       -
           ]

     

       281
       281
       -
           ++ lib.optionals (!config.networking.nftables.enable) [ "iptable_mangle" ];

     

       282
       282
       -
         };

     

       283
       283
       -
       }

-1

nixos/tests/all-tests.nix

···

       855
       855
        
         luks = runTest ./luks.nix;

     

       856
       856
        
         lvm2 = handleTest ./lvm2 { };

     

       857
       857
        
         lxc = handleTest ./lxc { };

     

       858
       858
       -
         lxd = pkgs.recurseIntoAttrs (handleTest ./lxd { inherit handleTestOn; });

     

       859
       858
        
         lxd-image-server = runTest ./lxd-image-server.nix;

     

       860
       859
        
         lxqt = runTest ./lxqt.nix;

     

       861
       860
        
         ly = runTest ./ly.nix;

-4

nixos/tests/incus/default.nix

···

       24
       24
        
           storageLvm = true;

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
       -
         lxd-to-incus = import ./lxd-to-incus.nix {

     

       28
       28
       -
           inherit lts pkgs system;

     

       29
       29
       -
         };

     

       30
       30
       -
       

     

       31
       27
        
         openvswitch = incusTest {

     

       32
       28
        
           inherit lts pkgs system;

     

       33
       29
        
           networkOvs = true;

-119

nixos/tests/incus/lxd-to-incus.nix

···

       1
       1
       -
       import ../make-test-python.nix (

     

       2
       2
       -
       

     

       3
       3
       -
         {

     

       4
       4
       -
           pkgs,

     

       5
       5
       -
           lib,

     

       6
       6
       -
           lts ? true,

     

       7
       7
       -
           ...

     

       8
       8
       -
         }:

     

       9
       9
       -
       

     

       10
       10
       -
         let

     

       11
       11
       -
           releases = import ../../release.nix { configuration.documentation.enable = lib.mkForce false; };

     

       12
       12
       -
       

     

       13
       13
       -
           container-image-metadata = releases.lxdContainerMeta.${pkgs.stdenv.hostPlatform.system};

     

       14
       14
       -
           container-image-rootfs = releases.lxdContainerImage.${pkgs.stdenv.hostPlatform.system};

     

       15
       15
       -
         in

     

       16
       16
       -
         {

     

       17
       17
       -
           name = "lxd-to-incus";

     

       18
       18
       -
       

     

       19
       19
       -
           meta = {

     

       20
       20
       -
             maintainers = lib.teams.lxc.members;

     

       21
       21
       -
           };

     

       22
       22
       -
       

     

       23
       23
       -
           nodes.machine =

     

       24
       24
       -
             { ... }:

     

       25
       25
       -
             {

     

       26
       26
       -
               virtualisation = {

     

       27
       27
       -
                 diskSize = 6144;

     

       28
       28
       -
                 cores = 2;

     

       29
       29
       -
                 memorySize = 2048;

     

       30
       30
       -
       

     

       31
       31
       -
                 lxd.enable = true;

     

       32
       32
       -
                 lxd.preseed = {

     

       33
       33
       -
                   networks = [

     

       34
       34
       -
                     {

     

       35
       35
       -
                       name = "nixostestbr0";

     

       36
       36
       -
                       type = "bridge";

     

       37
       37
       -
                       config = {

     

       38
       38
       -
                         "ipv4.address" = "10.0.100.1/24";

     

       39
       39
       -
                         "ipv4.nat" = "true";

     

       40
       40
       -
                       };

     

       41
       41
       -
                     }

     

       42
       42
       -
                   ];

     

       43
       43
       -
                   profiles = [

     

       44
       44
       -
                     {

     

       45
       45
       -
                       name = "default";

     

       46
       46
       -
                       devices = {

     

       47
       47
       -
                         eth0 = {

     

       48
       48
       -
                           name = "eth0";

     

       49
       49
       -
                           network = "nixostestbr0";

     

       50
       50
       -
                           type = "nic";

     

       51
       51
       -
                         };

     

       52
       52
       -
                         root = {

     

       53
       53
       -
                           path = "/";

     

       54
       54
       -
                           pool = "nixostest_pool";

     

       55
       55
       -
                           size = "35GiB";

     

       56
       56
       -
                           type = "disk";

     

       57
       57
       -
                         };

     

       58
       58
       -
                       };

     

       59
       59
       -
                     }

     

       60
       60
       -
                     {

     

       61
       61
       -
                       name = "nixos_notdefault";

     

       62
       62
       -
                       devices = { };

     

       63
       63
       -
                     }

     

       64
       64
       -
                   ];

     

       65
       65
       -
                   storage_pools = [

     

       66
       66
       -
                     {

     

       67
       67
       -
                       name = "nixostest_pool";

     

       68
       68
       -
                       driver = "dir";

     

       69
       69
       -
                     }

     

       70
       70
       -
                   ];

     

       71
       71
       -
                 };

     

       72
       72
       -
       

     

       73
       73
       -
                 incus = {

     

       74
       74
       -
                   enable = true;

     

       75
       75
       -
                   package = if lts then pkgs.incus-lts else pkgs.incus;

     

       76
       76
       -
                 };

     

       77
       77
       -
               };

     

       78
       78
       -
               networking.nftables.enable = true;

     

       79
       79
       -
             };

     

       80
       80
       -
       

     

       81
       81
       -
           testScript = ''

     

       82
       82
       -
             def lxd_wait_for_preseed(_) -> bool:

     

       83
       83
       -
               _, output = machine.systemctl("is-active lxd-preseed.service")

     

       84
       84
       -
               return ("inactive" in output)

     

       85
       85
       -
       

     

       86
       86
       -
             def lxd_instance_is_up(_) -> bool:

     

       87
       87
       -
                 status, _ = machine.execute("lxc exec container --disable-stdin --force-interactive /run/current-system/sw/bin/systemctl -- is-system-running")

     

       88
       88
       -
                 return status == 0

     

       89
       89
       -
       

     

       90
       90
       -
             def incus_instance_is_up(_) -> bool:

     

       91
       91
       -
                 status, _ = machine.execute("incus exec container --disable-stdin --force-interactive /run/current-system/sw/bin/systemctl -- is-system-running")

     

       92
       92
       -
                 return status == 0

     

       93
       93
       -
       

     

       94
       94
       -
             with machine.nested("initialize lxd and resources"):

     

       95
       95
       -
               machine.wait_for_unit("sockets.target")

     

       96
       96
       -
               machine.wait_for_unit("lxd.service")

     

       97
       97
       -
               retry(lxd_wait_for_preseed)

     

       98
       98
       -
       

     

       99
       99
       -
               machine.succeed("lxc image import ${container-image-metadata}/*/*.tar.xz ${container-image-rootfs}/*/*.tar.xz --alias nixos")

     

       100
       100
       -
               machine.succeed("lxc launch nixos container")

     

       101
       101
       -
               retry(lxd_instance_is_up)

     

       102
       102
       -
       

     

       103
       103
       -
             machine.wait_for_unit("incus.service")

     

       104
       104
       -
       

     

       105
       105
       -
             with machine.nested("run migration"):

     

       106
       106
       -
                 machine.succeed("${pkgs.incus}/bin/lxd-to-incus --yes")

     

       107
       107
       -
       

     

       108
       108
       -
             with machine.nested("verify resources migrated to incus"):

     

       109
       109
       -
                 machine.succeed("incus config show container")

     

       110
       110
       -
                 retry(incus_instance_is_up)

     

       111
       111
       -
                 machine.succeed("incus exec container -- true")

     

       112
       112
       -
                 machine.succeed("incus profile show default | grep nixostestbr0")

     

       113
       113
       -
                 machine.succeed("incus profile show default | grep nixostest_pool")

     

       114
       114
       -
                 machine.succeed("incus profile show nixos_notdefault")

     

       115
       115
       -
                 machine.succeed("incus storage show nixostest_pool")

     

       116
       116
       -
                 machine.succeed("incus network show nixostestbr0")

     

       117
       117
       -
           '';

     

       118
       118
       -
         }

     

       119
       119
       -
       )

+2 -2

nixos/tests/lxc/default.nix

···

       9
       9
        
             };

     

       10
       10
        
           };

     

       11
       11
        
       

     

       12
       12
       -
           lxc-image-metadata = releases.lxdContainerMeta.${pkgs.stdenv.hostPlatform.system};

     

       13
       13
       -
           lxc-image-rootfs = releases.lxdContainerImage.${pkgs.stdenv.hostPlatform.system};

     

       12
       12
       +
           lxc-image-metadata = releases.incusContainerMeta.${pkgs.stdenv.hostPlatform.system};

     

       13
       13
       +
           lxc-image-rootfs = releases.incusContainerImage.${pkgs.stdenv.hostPlatform.system};

     

       14
       14
        
       

     

       15
       15
        
         in

     

       16
       16
        
         {

-133

nixos/tests/lxd/container.nix

···

       1
       1
       -
       import ../make-test-python.nix (

     

       2
       2
       -
         { pkgs, lib, ... }:

     

       3
       3
       -
       

     

       4
       4
       -
         let

     

       5
       5
       -
           releases = import ../../release.nix {

     

       6
       6
       -
             configuration = {

     

       7
       7
       -
               # Building documentation makes the test unnecessarily take a longer time:

     

       8
       8
       -
               documentation.enable = lib.mkForce false;

     

       9
       9
       -
       

     

       10
       10
       -
               # Our tests require `grep` & friends:

     

       11
       11
       -
               environment.systemPackages = with pkgs; [ busybox ];

     

       12
       12
       -
             };

     

       13
       13
       -
           };

     

       14
       14
       -
       

     

       15
       15
       -
           lxd-image-metadata = releases.lxdContainerMeta.${pkgs.stdenv.hostPlatform.system};

     

       16
       16
       -
           lxd-image-rootfs = releases.lxdContainerImage.${pkgs.stdenv.hostPlatform.system};

     

       17
       17
       -
           lxd-image-rootfs-squashfs = releases.lxdContainerImageSquashfs.${pkgs.stdenv.hostPlatform.system};

     

       18
       18
       -
       

     

       19
       19
       -
         in

     

       20
       20
       -
         {

     

       21
       21
       -
           name = "lxd-container";

     

       22
       22
       -
       

     

       23
       23
       -
           nodes.machine =

     

       24
       24
       -
             { lib, ... }:

     

       25
       25
       -
             {

     

       26
       26
       -
               virtualisation = {

     

       27
       27
       -
                 diskSize = 6144;

     

       28
       28
       -
       

     

       29
       29
       -
                 # Since we're testing `limits.cpu`, we've gotta have a known number of

     

       30
       30
       -
                 # cores to lean on

     

       31
       31
       -
                 cores = 2;

     

       32
       32
       -
       

     

       33
       33
       -
                 # Ditto, for `limits.memory`

     

       34
       34
       -
                 memorySize = 512;

     

       35
       35
       -
       

     

       36
       36
       -
                 lxc.lxcfs.enable = true;

     

       37
       37
       -
                 lxd.enable = true;

     

       38
       38
       -
               };

     

       39
       39
       -
             };

     

       40
       40
       -
       

     

       41
       41
       -
           testScript = ''

     

       42
       42
       -
             def instance_is_up(_) -> bool:

     

       43
       43
       -
               status, _ = machine.execute("lxc exec container --disable-stdin --force-interactive /run/current-system/sw/bin/true")

     

       44
       44
       -
               return status == 0

     

       45
       45
       -
       

     

       46
       46
       -
             machine.wait_for_unit("sockets.target")

     

       47
       47
       -
             machine.wait_for_unit("lxd.service")

     

       48
       48
       -
             machine.wait_for_file("/var/lib/lxd/unix.socket")

     

       49
       49
       -
       

     

       50
       50
       -
             # Wait for lxd to settle

     

       51
       51
       -
             machine.succeed("lxd waitready")

     

       52
       52
       -
       

     

       53
       53
       -
             # no preseed should mean no service

     

       54
       54
       -
             machine.fail("systemctl status lxd-preseed.service")

     

       55
       55
       -
       

     

       56
       56
       -
             machine.succeed("lxd init --minimal")

     

       57
       57
       -
       

     

       58
       58
       -
             machine.succeed(

     

       59
       59
       -
                 "lxc image import ${lxd-image-metadata}/*/*.tar.xz ${lxd-image-rootfs}/*/*.tar.xz --alias nixos"

     

       60
       60
       -
             )

     

       61
       61
       -
       

     

       62
       62
       -
             with subtest("Container can be managed"):

     

       63
       63
       -
                 machine.succeed("lxc launch nixos container")

     

       64
       64
       -
                 with machine.nested("Waiting for instance to start and be usable"):

     

       65
       65
       -
                   retry(instance_is_up)

     

       66
       66
       -
                 machine.succeed("echo true | lxc exec container /run/current-system/sw/bin/bash -")

     

       67
       67
       -
                 machine.succeed("lxc delete -f container")

     

       68
       68
       -
       

     

       69
       69
       -
             with subtest("Squashfs image is functional"):

     

       70
       70
       -
                 machine.succeed(

     

       71
       71
       -
                     "lxc image import ${lxd-image-metadata}/*/*.tar.xz ${lxd-image-rootfs-squashfs}/nixos-lxc-image-${pkgs.stdenv.hostPlatform.system}.squashfs --alias nixos-squashfs"

     

       72
       72
       -
                 )

     

       73
       73
       -
                 machine.succeed("lxc launch nixos-squashfs container")

     

       74
       74
       -
                 with machine.nested("Waiting for instance to start and be usable"):

     

       75
       75
       -
                   retry(instance_is_up)

     

       76
       76
       -
                 machine.succeed("echo true | lxc exec container /run/current-system/sw/bin/bash -")

     

       77
       77
       -
                 machine.succeed("lxc delete -f container")

     

       78
       78
       -
       

     

       79
       79
       -
             with subtest("Container is mounted with lxcfs inside"):

     

       80
       80
       -
                 machine.succeed("lxc launch nixos container")

     

       81
       81
       -
                 with machine.nested("Waiting for instance to start and be usable"):

     

       82
       82
       -
                     retry(instance_is_up)

     

       83
       83
       -
       

     

       84
       84
       -
                 ## ---------- ##

     

       85
       85
       -
                 ## limits.cpu ##

     

       86
       86
       -
       

     

       87
       87
       -
                 machine.succeed("lxc config set container limits.cpu 1")

     

       88
       88
       -
                 machine.succeed("lxc restart container")

     

       89
       89
       -
                 with machine.nested("Waiting for instance to start and be usable"):

     

       90
       90
       -
                     retry(instance_is_up)

     

       91
       91
       -
       

     

       92
       92
       -
                 assert (

     

       93
       93
       -
                     "1"

     

       94
       94
       -
                     == machine.succeed("lxc exec container grep -- -c ^processor /proc/cpuinfo").strip()

     

       95
       95
       -
                 )

     

       96
       96
       -
       

     

       97
       97
       -
                 machine.succeed("lxc config set container limits.cpu 2")

     

       98
       98
       -
                 machine.succeed("lxc restart container")

     

       99
       99
       -
                 with machine.nested("Waiting for instance to start and be usable"):

     

       100
       100
       -
                     retry(instance_is_up)

     

       101
       101
       -
       

     

       102
       102
       -
                 assert (

     

       103
       103
       -
                     "2"

     

       104
       104
       -
                     == machine.succeed("lxc exec container grep -- -c ^processor /proc/cpuinfo").strip()

     

       105
       105
       -
                 )

     

       106
       106
       -
       

     

       107
       107
       -
                 ## ------------- ##

     

       108
       108
       -
                 ## limits.memory ##

     

       109
       109
       -
       

     

       110
       110
       -
                 machine.succeed("lxc config set container limits.memory 64MB")

     

       111
       111
       -
                 machine.succeed("lxc restart container")

     

       112
       112
       -
                 with machine.nested("Waiting for instance to start and be usable"):

     

       113
       113
       -
                     retry(instance_is_up)

     

       114
       114
       -
       

     

       115
       115
       -
                 assert (

     

       116
       116
       -
                     "MemTotal:          62500 kB"

     

       117
       117
       -
                     == machine.succeed("lxc exec container grep -- MemTotal /proc/meminfo").strip()

     

       118
       118
       -
                 )

     

       119
       119
       -
       

     

       120
       120
       -
                 machine.succeed("lxc config set container limits.memory 128MB")

     

       121
       121
       -
                 machine.succeed("lxc restart container")

     

       122
       122
       -
                 with machine.nested("Waiting for instance to start and be usable"):

     

       123
       123
       -
                     retry(instance_is_up)

     

       124
       124
       -
       

     

       125
       125
       -
                 assert (

     

       126
       126
       -
                     "MemTotal:         125000 kB"

     

       127
       127
       -
                     == machine.succeed("lxc exec container grep -- MemTotal /proc/meminfo").strip()

     

       128
       128
       -
                 )

     

       129
       129
       -
       

     

       130
       130
       -
                 machine.succeed("lxc delete -f container")

     

       131
       131
       -
           '';

     

       132
       132
       -
         }

     

       133
       133
       -
       )

-13

nixos/tests/lxd/default.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         system ? builtins.currentSystem,

     

       3
       3
       -
         config ? { },

     

       4
       4
       -
         pkgs ? import ../../.. { inherit system config; },

     

       5
       5
       -
         handleTestOn,

     

       6
       6
       -
       }:

     

       7
       7
       -
       {

     

       8
       8
       -
         container = import ./container.nix { inherit system pkgs; };

     

       9
       9
       -
         nftables = import ./nftables.nix { inherit system pkgs; };

     

       10
       10
       -
         preseed = import ./preseed.nix { inherit system pkgs; };

     

       11
       11
       -
         ui = import ./ui.nix { inherit system pkgs; };

     

       12
       12
       -
         virtual-machine = handleTestOn [ "x86_64-linux" ] ./virtual-machine.nix { inherit system pkgs; };

     

       13
       13
       -
       }

-51

nixos/tests/lxd/nftables.nix

···

       1
       1
       -
       # This test makes sure that lxd stops implicitly depending on iptables when

     

       2
       2
       -
       # user enabled nftables.

     

       3
       3
       -
       #

     

       4
       4
       -
       # It has been extracted from `lxd.nix` for clarity, and because switching from

     

       5
       5
       -
       # iptables to nftables requires a full reboot, which is a bit hard inside NixOS

     

       6
       6
       -
       # tests.

     

       7
       7
       -
       

     

       8
       8
       -
       import ../make-test-python.nix (

     

       9
       9
       -
         { pkgs, lib, ... }:

     

       10
       10
       -
         {

     

       11
       11
       -
           name = "lxd-nftables";

     

       12
       12
       -
       

     

       13
       13
       -
           nodes.machine =

     

       14
       14
       -
             { lib, ... }:

     

       15
       15
       -
             {

     

       16
       16
       -
               virtualisation = {

     

       17
       17
       -
                 lxd.enable = true;

     

       18
       18
       -
               };

     

       19
       19
       -
       

     

       20
       20
       -
               networking = {

     

       21
       21
       -
                 firewall.enable = false;

     

       22
       22
       -
                 nftables.enable = true;

     

       23
       23
       -
                 nftables.tables."filter".family = "inet";

     

       24
       24
       -
                 nftables.tables."filter".content = ''

     

       25
       25
       -
                   chain incoming {

     

       26
       26
       -
                     type filter hook input priority 0;

     

       27
       27
       -
                     policy accept;

     

       28
       28
       -
                   }

     

       29
       29
       -
       

     

       30
       30
       -
                   chain forward {

     

       31
       31
       -
                     type filter hook forward priority 0;

     

       32
       32
       -
                     policy accept;

     

       33
       33
       -
                   }

     

       34
       34
       -
       

     

       35
       35
       -
                   chain output {

     

       36
       36
       -
                     type filter hook output priority 0;

     

       37
       37
       -
                     policy accept;

     

       38
       38
       -
                   }

     

       39
       39
       -
                 '';

     

       40
       40
       -
               };

     

       41
       41
       -
             };

     

       42
       42
       -
       

     

       43
       43
       -
           testScript = ''

     

       44
       44
       -
             machine.wait_for_unit("network.target")

     

       45
       45
       -
       

     

       46
       46
       -
             with subtest("When nftables are enabled, lxd doesn't depend on iptables anymore"):

     

       47
       47
       -
                 machine.succeed("lsmod | grep nf_tables")

     

       48
       48
       -
                 machine.fail("lsmod | grep ip_tables")

     

       49
       49
       -
           '';

     

       50
       50
       -
         }

     

       51
       51
       -
       )

-71

nixos/tests/lxd/preseed.nix

···

       1
       1
       -
       import ../make-test-python.nix (

     

       2
       2
       -
         { pkgs, lib, ... }:

     

       3
       3
       -
       

     

       4
       4
       -
         {

     

       5
       5
       -
           name = "lxd-preseed";

     

       6
       6
       -
       

     

       7
       7
       -
           nodes.machine =

     

       8
       8
       -
             { lib, ... }:

     

       9
       9
       -
             {

     

       10
       10
       -
               virtualisation = {

     

       11
       11
       -
                 diskSize = 4096;

     

       12
       12
       -
       

     

       13
       13
       -
                 lxc.lxcfs.enable = true;

     

       14
       14
       -
                 lxd.enable = true;

     

       15
       15
       -
       

     

       16
       16
       -
                 lxd.preseed = {

     

       17
       17
       -
                   networks = [

     

       18
       18
       -
                     {

     

       19
       19
       -
                       name = "nixostestbr0";

     

       20
       20
       -
                       type = "bridge";

     

       21
       21
       -
                       config = {

     

       22
       22
       -
                         "ipv4.address" = "10.0.100.1/24";

     

       23
       23
       -
                         "ipv4.nat" = "true";

     

       24
       24
       -
                       };

     

       25
       25
       -
                     }

     

       26
       26
       -
                   ];

     

       27
       27
       -
                   profiles = [

     

       28
       28
       -
                     {

     

       29
       29
       -
                       name = "nixostest_default";

     

       30
       30
       -
                       devices = {

     

       31
       31
       -
                         eth0 = {

     

       32
       32
       -
                           name = "eth0";

     

       33
       33
       -
                           network = "nixostestbr0";

     

       34
       34
       -
                           type = "nic";

     

       35
       35
       -
                         };

     

       36
       36
       -
                         root = {

     

       37
       37
       -
                           path = "/";

     

       38
       38
       -
                           pool = "default";

     

       39
       39
       -
                           size = "35GiB";

     

       40
       40
       -
                           type = "disk";

     

       41
       41
       -
                         };

     

       42
       42
       -
                       };

     

       43
       43
       -
                     }

     

       44
       44
       -
                   ];

     

       45
       45
       -
                   storage_pools = [

     

       46
       46
       -
                     {

     

       47
       47
       -
                       name = "nixostest_pool";

     

       48
       48
       -
                       driver = "dir";

     

       49
       49
       -
                     }

     

       50
       50
       -
                   ];

     

       51
       51
       -
                 };

     

       52
       52
       -
               };

     

       53
       53
       -
             };

     

       54
       54
       -
       

     

       55
       55
       -
           testScript = ''

     

       56
       56
       -
             def wait_for_preseed(_) -> bool:

     

       57
       57
       -
               _, output = machine.systemctl("is-active lxd-preseed.service")

     

       58
       58
       -
               return ("inactive" in output)

     

       59
       59
       -
       

     

       60
       60
       -
             machine.wait_for_unit("sockets.target")

     

       61
       61
       -
             machine.wait_for_unit("lxd.service")

     

       62
       62
       -
             with machine.nested("Waiting for preseed to complete"):

     

       63
       63
       -
               retry(wait_for_preseed)

     

       64
       64
       -
       

     

       65
       65
       -
             with subtest("Verify preseed resources created"):

     

       66
       66
       -
               machine.succeed("lxc profile show nixostest_default")

     

       67
       67
       -
               machine.succeed("lxc network info nixostestbr0")

     

       68
       68
       -
               machine.succeed("lxc storage show nixostest_pool")

     

       69
       69
       -
           '';

     

       70
       70
       -
         }

     

       71
       71
       -
       )

-74

nixos/tests/lxd/ui.nix

···

       1
       1
       -
       import ../make-test-python.nix (

     

       2
       2
       -
         { pkgs, ... }:

     

       3
       3
       -
         {

     

       4
       4
       -
           name = "lxd-ui";

     

       5
       5
       -
       

     

       6
       6
       -
           nodes.machine =

     

       7
       7
       -
             { lib, ... }:

     

       8
       8
       -
             {

     

       9
       9
       -
               virtualisation = {

     

       10
       10
       -
                 lxd.enable = true;

     

       11
       11
       -
                 lxd.ui.enable = true;

     

       12
       12
       -
               };

     

       13
       13
       -
       

     

       14
       14
       -
               environment.systemPackages =

     

       15
       15
       -
                 let

     

       16
       16
       -
                   seleniumScript =

     

       17
       17
       -
                     pkgs.writers.writePython3Bin "selenium-script"

     

       18
       18
       -
                       {

     

       19
       19
       -
                         libraries = with pkgs.python3Packages; [ selenium ];

     

       20
       20
       -
                       }

     

       21
       21
       -
                       ''

     

       22
       22
       -
                         from selenium import webdriver

     

       23
       23
       -
                         from selenium.webdriver.common.by import By

     

       24
       24
       -
                         from selenium.webdriver.firefox.options import Options

     

       25
       25
       -
                         from selenium.webdriver.support.ui import WebDriverWait

     

       26
       26
       -
       

     

       27
       27
       -
                         options = Options()

     

       28
       28
       -
                         options.add_argument("--headless")

     

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

     

       30
       30
       -
       

     

       31
       31
       -
                         driver = webdriver.Firefox(options=options, service=service)

     

       32
       32
       -
                         driver.implicitly_wait(10)

     

       33
       33
       -
                         driver.get("https://localhost:8443/ui")

     

       34
       34
       -
       

     

       35
       35
       -
                         wait = WebDriverWait(driver, 60)

     

       36
       36
       -
       

     

       37
       37
       -
                         assert len(driver.find_elements(By.CLASS_NAME, "l-application")) > 0

     

       38
       38
       -
                         assert len(driver.find_elements(By.CLASS_NAME, "l-navigation__drawer")) > 0

     

       39
       39
       -
       

     

       40
       40
       -
                         driver.close()

     

       41
       41
       -
                       '';

     

       42
       42
       -
                 in

     

       43
       43
       -
                 with pkgs;

     

       44
       44
       -
                 [

     

       45
       45
       -
                   curl

     

       46
       46
       -
                   firefox-unwrapped

     

       47
       47
       -
                   geckodriver

     

       48
       48
       -
                   seleniumScript

     

       49
       49
       -
                 ];

     

       50
       50
       -
             };

     

       51
       51
       -
       

     

       52
       52
       -
           testScript = ''

     

       53
       53
       -
             machine.wait_for_unit("sockets.target")

     

       54
       54
       -
             machine.wait_for_unit("lxd.service")

     

       55
       55
       -
             machine.wait_for_file("/var/lib/lxd/unix.socket")

     

       56
       56
       -
       

     

       57
       57
       -
             # Wait for lxd to settle

     

       58
       58
       -
             machine.succeed("lxd waitready")

     

       59
       59
       -
       

     

       60
       60
       -
             # Configure LXC listen address

     

       61
       61
       -
             machine.succeed("lxc config set core.https_address :8443")

     

       62
       62
       -
             machine.succeed("systemctl restart lxd")

     

       63
       63
       -
       

     

       64
       64
       -
             # Check that the LXD_UI environment variable is populated in the systemd unit

     

       65
       65
       -
             machine.succeed("cat /etc/systemd/system/lxd.service | grep 'LXD_UI'")

     

       66
       66
       -
       

     

       67
       67
       -
             # Ensure the endpoint returns an HTML page with 'LXD UI' in the title

     

       68
       68
       -
             machine.succeed("curl -kLs https://localhost:8443/ui | grep '<title>LXD UI</title>'")

     

       69
       69
       -
       

     

       70
       70
       -
             # Ensure the application is actually rendered by the Javascript

     

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

     

       72
       72
       -
           '';

     

       73
       73
       -
         }

     

       74
       74
       -
       )

-65

nixos/tests/lxd/virtual-machine.nix

···

       1
       1
       -
       import ../make-test-python.nix (

     

       2
       2
       -
         { pkgs, lib, ... }:

     

       3
       3
       -
       

     

       4
       4
       -
         let

     

       5
       5
       -
           releases = import ../../release.nix {

     

       6
       6
       -
             configuration = {

     

       7
       7
       -
               # Building documentation makes the test unnecessarily take a longer time:

     

       8
       8
       -
               documentation.enable = lib.mkForce false;

     

       9
       9
       -
       

     

       10
       10
       -
               # Our tests require `grep` & friends:

     

       11
       11
       -
               environment.systemPackages = with pkgs; [ busybox ];

     

       12
       12
       -
             };

     

       13
       13
       -
           };

     

       14
       14
       -
       

     

       15
       15
       -
           lxd-image-metadata = releases.lxdVirtualMachineImageMeta.${pkgs.stdenv.hostPlatform.system};

     

       16
       16
       -
           lxd-image-disk = releases.lxdVirtualMachineImage.${pkgs.stdenv.hostPlatform.system};

     

       17
       17
       -
       

     

       18
       18
       -
           instance-name = "instance1";

     

       19
       19
       -
         in

     

       20
       20
       -
         {

     

       21
       21
       -
           name = "lxd-virtual-machine";

     

       22
       22
       -
       

     

       23
       23
       -
           nodes.machine =

     

       24
       24
       -
             { lib, ... }:

     

       25
       25
       -
             {

     

       26
       26
       -
               virtualisation = {

     

       27
       27
       -
                 diskSize = 4096;

     

       28
       28
       -
       

     

       29
       29
       -
                 cores = 2;

     

       30
       30
       -
       

     

       31
       31
       -
                 # Ensure we have enough memory for the nested virtual machine

     

       32
       32
       -
                 memorySize = 1024;

     

       33
       33
       -
       

     

       34
       34
       -
                 lxc.lxcfs.enable = true;

     

       35
       35
       -
                 lxd.enable = true;

     

       36
       36
       -
               };

     

       37
       37
       -
             };

     

       38
       38
       -
       

     

       39
       39
       -
           testScript = ''

     

       40
       40
       -
             def instance_is_up(_) -> bool:

     

       41
       41
       -
               status, _ = machine.execute("lxc exec ${instance-name} --disable-stdin --force-interactive /run/current-system/sw/bin/true")

     

       42
       42
       -
               return status == 0

     

       43
       43
       -
       

     

       44
       44
       -
             machine.wait_for_unit("sockets.target")

     

       45
       45
       -
             machine.wait_for_unit("lxd.service")

     

       46
       46
       -
             machine.wait_for_file("/var/lib/lxd/unix.socket")

     

       47
       47
       -
       

     

       48
       48
       -
             # Wait for lxd to settle

     

       49
       49
       -
             machine.succeed("lxd waitready")

     

       50
       50
       -
       

     

       51
       51
       -
             machine.succeed("lxd init --minimal")

     

       52
       52
       -
       

     

       53
       53
       -
             with subtest("virtual-machine image can be imported"):

     

       54
       54
       -
                 machine.succeed("lxc image import ${lxd-image-metadata}/*/*.tar.xz ${lxd-image-disk}/nixos.qcow2 --alias nixos")

     

       55
       55
       -
       

     

       56
       56
       -
             with subtest("virtual-machine can be launched and become available"):

     

       57
       57
       -
                 machine.succeed("lxc launch nixos ${instance-name} --vm --config limits.memory=512MB --config security.secureboot=false")

     

       58
       58
       -
                 with machine.nested("Waiting for instance to start and be usable"):

     

       59
       59
       -
                   retry(instance_is_up)

     

       60
       60
       -
       

     

       61
       61
       -
             with subtest("lxd-agent is started"):

     

       62
       62
       -
                 machine.succeed("lxc exec ${instance-name} systemctl is-active lxd-agent")

     

       63
       63
       -
           '';

     

       64
       64
       -
         }

     

       65
       65
       -
       )

-148

pkgs/by-name/lx/lxd-lts/package.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         lib,

     

       3
       3
       -
         lxd-unwrapped-lts,

     

       4
       4
       -
         linkFarm,

     

       5
       5
       -
         makeWrapper,

     

       6
       6
       -
         stdenv,

     

       7
       7
       -
         symlinkJoin,

     

       8
       8
       -
         writeShellScriptBin,

     

       9
       9
       -
         acl,

     

       10
       10
       -
         apparmor-parser,

     

       11
       11
       -
         apparmor-profiles,

     

       12
       12
       -
         attr,

     

       13
       13
       -
         bash,

     

       14
       14
       -
         btrfs-progs,

     

       15
       15
       -
         cdrkit,

     

       16
       16
       -
         criu,

     

       17
       17
       -
         dnsmasq,

     

       18
       18
       -
         e2fsprogs,

     

       19
       19
       -
         getent,

     

       20
       20
       -
         gnutar,

     

       21
       21
       -
         gptfdisk,

     

       22
       22
       -
         gzip,

     

       23
       23
       -
         iproute2,

     

       24
       24
       -
         iptables,

     

       25
       25
       -
         kmod,

     

       26
       26
       -
         lvm2,

     

       27
       27
       -
         minio,

     

       28
       28
       -
         nftables,

     

       29
       29
       -
         OVMF,

     

       30
       30
       -
         qemu_kvm,

     

       31
       31
       -
         qemu-utils,

     

       32
       32
       -
         rsync,

     

       33
       33
       -
         spice-gtk,

     

       34
       34
       -
         squashfsTools,

     

       35
       35
       -
         thin-provisioning-tools,

     

       36
       36
       -
         util-linux,

     

       37
       37
       -
         virtiofsd,

     

       38
       38
       -
         xz,

     

       39
       39
       -
       }:

     

       40
       40
       -
       let

     

       41
       41
       -
         binPath = lib.makeBinPath [

     

       42
       42
       -
           acl

     

       43
       43
       -
           attr

     

       44
       44
       -
           bash

     

       45
       45
       -
           btrfs-progs

     

       46
       46
       -
           cdrkit

     

       47
       47
       -
           criu

     

       48
       48
       -
           dnsmasq

     

       49
       49
       -
           e2fsprogs

     

       50
       50
       -
           getent

     

       51
       51
       -
           gnutar

     

       52
       52
       -
           gptfdisk

     

       53
       53
       -
           gzip

     

       54
       54
       -
           iproute2

     

       55
       55
       -
           iptables

     

       56
       56
       -
           kmod

     

       57
       57
       -
           lvm2

     

       58
       58
       -
           minio

     

       59
       59
       -
           nftables

     

       60
       60
       -
           qemu_kvm

     

       61
       61
       -
           qemu-utils

     

       62
       62
       -
           rsync

     

       63
       63
       -
           squashfsTools

     

       64
       64
       -
           thin-provisioning-tools

     

       65
       65
       -
           util-linux

     

       66
       66
       -
           virtiofsd

     

       67
       67
       -
           xz

     

       68
       68
       -
       

     

       69
       69
       -
           (writeShellScriptBin "apparmor_parser" ''

     

       70
       70
       -
             exec '${apparmor-parser}/bin/apparmor_parser' -I '${apparmor-profiles}/etc/apparmor.d' "$@"

     

       71
       71
       -
           '')

     

       72
       72
       -
         ];

     

       73
       73
       -
       

     

       74
       74
       -
         clientBinPath = [ spice-gtk ];

     

       75
       75
       -
       

     

       76
       76
       -
         ovmf-2mb = OVMF.override {

     

       77
       77
       -
           secureBoot = true;

     

       78
       78
       -
           fdSize2MB = true;

     

       79
       79
       -
         };

     

       80
       80
       -
       

     

       81
       81
       -
         ovmf-4mb = OVMF.override {

     

       82
       82
       -
           secureBoot = true;

     

       83
       83
       -
           fdSize4MB = true;

     

       84
       84
       -
         };

     

       85
       85
       -
       

     

       86
       86
       -
         ovmf-prefix = if stdenv.hostPlatform.isAarch64 then "AAVMF" else "OVMF";

     

       87
       87
       -
       

     

       88
       88
       -
         # mimic ovmf from https://github.com/canonical/lxd-pkg-snap/blob/3abebe1dfeb20f9b7729556960c7e9fe6ad5e17c/snapcraft.yaml#L378

     

       89
       89
       -
         # also found in /snap/lxd/current/share/qemu/ on a snap install

     

       90
       90
       -
         ovmf = linkFarm "lxd-ovmf" [

     

       91
       91
       -
           {

     

       92
       92
       -
             name = "OVMF_CODE.2MB.fd";

     

       93
       93
       -
             path = "${ovmf-2mb.fd}/FV/${ovmf-prefix}_CODE.fd";

     

       94
       94
       -
           }

     

       95
       95
       -
           {

     

       96
       96
       -
             name = "OVMF_CODE.4MB.fd";

     

       97
       97
       -
             path = "${ovmf-4mb.fd}/FV/${ovmf-prefix}_CODE.fd";

     

       98
       98
       -
           }

     

       99
       99
       -
           {

     

       100
       100
       -
             name = "OVMF_CODE.fd";

     

       101
       101
       -
             path = "${ovmf-2mb.fd}/FV/${ovmf-prefix}_CODE.fd";

     

       102
       102
       -
           }

     

       103
       103
       -
       

     

       104
       104
       -
           {

     

       105
       105
       -
             name = "OVMF_VARS.2MB.fd";

     

       106
       106
       -
             path = "${ovmf-2mb.fd}/FV/${ovmf-prefix}_VARS.fd";

     

       107
       107
       -
           }

     

       108
       108
       -
           {

     

       109
       109
       -
             name = "OVMF_VARS.2MB.ms.fd";

     

       110
       110
       -
             path = "${ovmf-2mb.fd}/FV/${ovmf-prefix}_VARS.fd";

     

       111
       111
       -
           }

     

       112
       112
       -
           {

     

       113
       113
       -
             name = "OVMF_VARS.4MB.fd";

     

       114
       114
       -
             path = "${ovmf-4mb.fd}/FV/${ovmf-prefix}_VARS.fd";

     

       115
       115
       -
           }

     

       116
       116
       -
           {

     

       117
       117
       -
             name = "OVMF_VARS.4MB.ms.fd";

     

       118
       118
       -
             path = "${ovmf-4mb.fd}/FV/${ovmf-prefix}_VARS.fd";

     

       119
       119
       -
           }

     

       120
       120
       -
           {

     

       121
       121
       -
             name = "OVMF_VARS.fd";

     

       122
       122
       -
             path = "${ovmf-2mb.fd}/FV/${ovmf-prefix}_VARS.fd";

     

       123
       123
       -
           }

     

       124
       124
       -
           {

     

       125
       125
       -
             name = "OVMF_VARS.ms.fd";

     

       126
       126
       -
             path = "${ovmf-2mb.fd}/FV/${ovmf-prefix}_VARS.fd";

     

       127
       127
       -
           }

     

       128
       128
       -
         ];

     

       129
       129
       -
       in

     

       130
       130
       -
       symlinkJoin {

     

       131
       131
       -
         name = "lxd-${lxd-unwrapped-lts.version}";

     

       132
       132
       -
       

     

       133
       133
       -
         paths = [ lxd-unwrapped-lts ];

     

       134
       134
       -
       

     

       135
       135
       -
         nativeBuildInputs = [ makeWrapper ];

     

       136
       136
       -
       

     

       137
       137
       -
         postBuild = ''

     

       138
       138
       -
           wrapProgram $out/bin/lxd --prefix PATH : ${lib.escapeShellArg binPath}:${qemu_kvm}/libexec:$out/bin --set LXD_OVMF_PATH ${ovmf}

     

       139
       139
       -
       

     

       140
       140
       -
           wrapProgram $out/bin/lxc --prefix PATH : ${lib.makeBinPath clientBinPath}

     

       141
       141
       -
         '';

     

       142
       142
       -
       

     

       143
       143
       -
         passthru = {

     

       144
       144
       -
           inherit (lxd-unwrapped-lts) tests;

     

       145
       145
       -
         };

     

       146
       146
       -
       

     

       147
       147
       -
         inherit (lxd-unwrapped-lts) meta pname version;

     

       148
       148
       -
       }

-74

pkgs/by-name/lx/lxd-ui/package.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         lib,

     

       3
       3
       -
         stdenv,

     

       4
       4
       -
         fetchFromGitHub,

     

       5
       5
       -
         fetchYarnDeps,

     

       6
       6
       -
         nodejs,

     

       7
       7
       -
         fixup-yarn-lock,

     

       8
       8
       -
         yarn,

     

       9
       9
       -
         nixosTests,

     

       10
       10
       -
         nix-update-script,

     

       11
       11
       -
       }:

     

       12
       12
       -
       

     

       13
       13
       -
       stdenv.mkDerivation rec {

     

       14
       14
       -
         pname = "lxd-ui";

     

       15
       15
       -
         version = "0.16";

     

       16
       16
       -
       

     

       17
       17
       -
         src = fetchFromGitHub {

     

       18
       18
       -
           owner = "canonical";

     

       19
       19
       -
           repo = "lxd-ui";

     

       20
       20
       -
           tag = version;

     

       21
       21
       -
           hash = "sha256-JVozXgAu0rTjO9aNzKMzzoGYL09lRzNI5qcjDfRaMnE=";

     

       22
       22
       -
         };

     

       23
       23
       -
       

     

       24
       24
       -
         offlineCache = fetchYarnDeps {

     

       25
       25
       -
           yarnLock = "${src}/yarn.lock";

     

       26
       26
       -
           hash = "sha256-Z/C0QgqxBWob6KIWuU8PACkTKuAhTrJzod9WNXTO8Zs=";

     

       27
       27
       -
         };

     

       28
       28
       -
       

     

       29
       29
       -
         nativeBuildInputs = [

     

       30
       30
       -
           nodejs

     

       31
       31
       -
           fixup-yarn-lock

     

       32
       32
       -
           yarn

     

       33
       33
       -
         ];

     

       34
       34
       -
       

     

       35
       35
       -
         configurePhase = ''

     

       36
       36
       -
           runHook preConfigure

     

       37
       37
       -
       

     

       38
       38
       -
           export HOME=$(mktemp -d)

     

       39
       39
       -
           yarn config --offline set yarn-offline-mirror "$offlineCache"

     

       40
       40
       -
           fixup-yarn-lock yarn.lock

     

       41
       41
       -
           yarn --offline --frozen-lockfile --ignore-platform --ignore-scripts --no-progress --non-interactive install

     

       42
       42
       -
           patchShebangs node_modules

     

       43
       43
       -
       

     

       44
       44
       -
           runHook postConfigure

     

       45
       45
       -
         '';

     

       46
       46
       -
       

     

       47
       47
       -
         buildPhase = ''

     

       48
       48
       -
           runHook preBuild

     

       49
       49
       -
       

     

       50
       50
       -
           yarn --offline build

     

       51
       51
       -
       

     

       52
       52
       -
           runHook postBuild

     

       53
       53
       -
         '';

     

       54
       54
       -
       

     

       55
       55
       -
         installPhase = ''

     

       56
       56
       -
           runHook preInstall

     

       57
       57
       -
       

     

       58
       58
       -
           cp -r build/ui/ $out

     

       59
       59
       -
       

     

       60
       60
       -
           runHook postInstall

     

       61
       61
       -
         '';

     

       62
       62
       -
       

     

       63
       63
       -
         passthru.tests.default = nixosTests.lxd.ui;

     

       64
       64
       -
         passthru.updateScript = nix-update-script { };

     

       65
       65
       -
       

     

       66
       66
       -
         meta = {

     

       67
       67
       -
           description = "Web user interface for LXD";

     

       68
       68
       -
           homepage = "https://github.com/canonical/lxd-ui";

     

       69
       69
       -
           changelog = "https://github.com/canonical/lxd-ui/releases/tag/${version}";

     

       70
       70
       -
           license = lib.licenses.gpl3;

     

       71
       71
       -
           maintainers = [ ];

     

       72
       72
       -
           platforms = lib.platforms.linux;

     

       73
       73
       -
         };

     

       74
       74
       -
       }

-114

pkgs/by-name/lx/lxd-unwrapped-lts/package.nix

···

       1
       1
       -
       {

     

       2
       2
       -
         lib,

     

       3
       3
       -
         hwdata,

     

       4
       4
       -
         pkg-config,

     

       5
       5
       -
         lxc,

     

       6
       6
       -
         buildGoModule,

     

       7
       7
       -
         fetchFromGitHub,

     

       8
       8
       -
         acl,

     

       9
       9
       -
         libcap,

     

       10
       10
       -
         dqlite,

     

       11
       11
       -
         raft-canonical,

     

       12
       12
       -
         sqlite,

     

       13
       13
       -
         udev,

     

       14
       14
       -
         installShellFiles,

     

       15
       15
       -
         nixosTests,

     

       16
       16
       -
         nix-update-script,

     

       17
       17
       -
       }:

     

       18
       18
       -
       

     

       19
       19
       -
       buildGoModule rec {

     

       20
       20
       -
         pname = "lxd-unwrapped-lts";

     

       21
       21
       -
         # major/minor are used in updateScript to pin to LTS

     

       22
       22
       -
         version = "5.21.2";

     

       23
       23
       -
       

     

       24
       24
       -
         src = fetchFromGitHub {

     

       25
       25
       -
           owner = "canonical";

     

       26
       26
       -
           repo = "lxd";

     

       27
       27
       -
           tag = "lxd-${version}";

     

       28
       28
       -
           hash = "sha256-3C5pLvO7oABWFhFiWtBr5ohFFWm20Gg36WBfVVJgKdc=";

     

       29
       29
       -
         };

     

       30
       30
       -
       

     

       31
       31
       -
         vendorHash = "sha256-W7+Z2o5cw3u0DbTZA+a3pRXt9zRggUUjFTUTtQ7B22A=";

     

       32
       32
       -
       

     

       33
       33
       -
         postPatch = ''

     

       34
       34
       -
           substituteInPlace shared/usbid/load.go \

     

       35
       35
       -
             --replace "/usr/share/misc/usb.ids" "${hwdata}/share/hwdata/usb.ids"

     

       36
       36
       -
         '';

     

       37
       37
       -
       

     

       38
       38
       -
         excludedPackages = [

     

       39
       39
       -
           "test"

     

       40
       40
       -
           "lxd/db/generate"

     

       41
       41
       -
           "lxd-agent"

     

       42
       42
       -
           "lxd-migrate"

     

       43
       43
       -
         ];

     

       44
       44
       -
       

     

       45
       45
       -
         nativeBuildInputs = [

     

       46
       46
       -
           installShellFiles

     

       47
       47
       -
           pkg-config

     

       48
       48
       -
         ];

     

       49
       49
       -
         buildInputs = [

     

       50
       50
       -
           lxc

     

       51
       51
       -
           acl

     

       52
       52
       -
           libcap

     

       53
       53
       -
           dqlite.dev

     

       54
       54
       -
           raft-canonical.dev

     

       55
       55
       -
           sqlite

     

       56
       56
       -
           udev.dev

     

       57
       57
       -
         ];

     

       58
       58
       -
       

     

       59
       59
       -
         ldflags = [

     

       60
       60
       -
           "-s"

     

       61
       61
       -
           "-w"

     

       62
       62
       -
         ];

     

       63
       63
       -
         tags = [ "libsqlite3" ];

     

       64
       64
       -
       

     

       65
       65
       -
         preBuild = ''

     

       66
       66
       -
           # required for go-dqlite. See: https://github.com/canonical/lxd/pull/8939

     

       67
       67
       -
           export CGO_LDFLAGS_ALLOW="(-Wl,-wrap,pthread_create)|(-Wl,-z,now)"

     

       68
       68
       -
         '';

     

       69
       69
       -
       

     

       70
       70
       -
         # build static binaries: https://github.com/canonical/lxd/blob/6fd175c45e65cd475d198db69d6528e489733e19/Makefile#L43-L51

     

       71
       71
       -
         postBuild = ''

     

       72
       72
       -
           make lxd-agent lxd-migrate

     

       73
       73
       -
         '';

     

       74
       74
       -
       

     

       75
       75
       -
         checkFlags =

     

       76
       76
       -
           let

     

       77
       77
       -
             skippedTests = [

     

       78
       78
       -
               "TestValidateConfig"

     

       79
       79
       -
               "TestConvertNetworkConfig"

     

       80
       80
       -
               "TestConvertStorageConfig"

     

       81
       81
       -
               "TestSnapshotCommon"

     

       82
       82
       -
               "TestContainerTestSuite"

     

       83
       83
       -
             ];

     

       84
       84
       -
           in

     

       85
       85
       -
           [ "-skip=^${builtins.concatStringsSep "$|^" skippedTests}$" ];

     

       86
       86
       -
       

     

       87
       87
       -
         postInstall = ''

     

       88
       88
       -
           installShellCompletion --bash --name lxd ./scripts/bash/lxd-client

     

       89
       89
       -
         '';

     

       90
       90
       -
       

     

       91
       91
       -
         passthru = {

     

       92
       92
       -
           tests.lxd = nixosTests.lxd;

     

       93
       93
       -
           tests.lxd-to-incus = nixosTests.incus.lxd-to-incus;

     

       94
       94
       -
       

     

       95
       95
       -
           updateScript = nix-update-script {

     

       96
       96
       -
             extraArgs = [

     

       97
       97
       -
               "--version-regex"

     

       98
       98
       -
               "lxd-(5.21.*)"

     

       99
       99
       -
             ];

     

       100
       100
       -
           };

     

       101
       101
       -
         };

     

       102
       102
       -
       

     

       103
       103
       -
         meta = {

     

       104
       104
       -
           description = "Daemon based on liblxc offering a REST API to manage containers";

     

       105
       105
       -
           homepage = "https://ubuntu.com/lxd";

     

       106
       106
       -
           changelog = "https://github.com/canonical/lxd/releases/tag/lxd-${version}";

     

       107
       107
       -
           license = with lib.licenses; [

     

       108
       108
       -
             asl20

     

       109
       109
       -
             agpl3Plus

     

       110
       110
       -
           ];

     

       111
       111
       -
           maintainers = with lib.maintainers; [ ];

     

       112
       112
       -
           platforms = lib.platforms.linux;

     

       113
       113
       -
         };

     

       114
       114
       -
       }

+25 -2

pkgs/top-level/aliases.nix

···

       1509
       1509
        
         luci-go = throw "luci-go has been removed since it was unused and failing to build for 5 months"; # Added 2025-08-27

     

       1510
       1510
        
         lumail = throw "'lumail' has been removed since its upstream is unavailable"; # Added 2025-05-07

     

       1511
       1511
        
         lv_img_conv = throw "'lv_img_conv' has been removed from nixpkgs as it is broken"; # Added 2024-06-18

     

       1512
       1512
       -
         lxd = lib.warnOnInstantiate "lxd has been renamed to lxd-lts" lxd-lts; # Added 2024-04-01

     

       1512
       1512
       +
         lxd = throw ''

     

       1513
       1513
       +
           LXD has been removed from NixOS due to lack of Nixpkgs maintenance.

     

       1514
       1514
       +
           Consider migrating or switching to Incus, or remove from your configuration.

     

       1515
       1515
       +
           https://linuxcontainers.org/incus/docs/main/howto/server_migrate_lxd/

     

       1516
       1516
       +
         ''; # Added 2025-09-05

     

       1517
       1517
       +
         lxd-lts = throw ''

     

       1518
       1518
       +
           LXD has been removed from NixOS due to lack of Nixpkgs maintenance.

     

       1519
       1519
       +
           Consider migrating or switching to Incus, or remove from your configuration.

     

       1520
       1520
       +
           https://linuxcontainers.org/incus/docs/main/howto/server_migrate_lxd/

     

       1521
       1521
       +
         ''; # Added 2025-09-05

     

       1522
       1522
       +
         lxd-ui = throw ''

     

       1523
       1523
       +
           LXD has been removed from NixOS due to lack of Nixpkgs maintenance.

     

       1524
       1524
       +
           Consider migrating or switching to Incus, or remove from your configuration.

     

       1525
       1525
       +
           https://linuxcontainers.org/incus/docs/main/howto/server_migrate_lxd/

     

       1526
       1526
       +
         ''; # Added 2025-09-05

     

       1527
       1527
       +
         lxd-unwrapped = throw ''

     

       1528
       1528
       +
           LXD has been removed from NixOS due to lack of Nixpkgs maintenance.

     

       1529
       1529
       +
           Consider migrating or switching to Incus, or remove from your configuration.

     

       1530
       1530
       +
           https://linuxcontainers.org/incus/docs/main/howto/server_migrate_lxd/

     

       1531
       1531
       +
         ''; # Added 2025-09-05

     

       1532
       1532
       +
         lxd-unwrapped-lts = throw ''

     

       1533
       1533
       +
           LXD has been removed from NixOS due to lack of Nixpkgs maintenance.

     

       1534
       1534
       +
           Consider migrating or switching to Incus, or remove from your configuration.

     

       1535
       1535
       +
           https://linuxcontainers.org/incus/docs/main/howto/server_migrate_lxd/

     

       1536
       1536
       +
         ''; # Added 2025-09-05

     

       1513
       1537
        
       

     

       1514
       1538
        
         lxde = {

     

       1515
       1539
        
           gtk2-x11 = throw "'lxde.gtk2-x11' has been removed. Use 'gtk2-x11' directly.";

     
···

       1529
       1553
        
           lxtask = throw "'lxtask' has been moved to top-level. Use 'lxtask' directly"; # added 2025-08-31

     

       1530
       1554
        
         };

     

       1531
       1555
        
       

     

       1532
       1532
       -
         lxd-unwrapped = lib.warnOnInstantiate "lxd-unwrapped has been renamed to lxd-unwrapped-lts" lxd-unwrapped-lts; # Added 2024-04-01

     

       1533
       1556
        
         lxdvdrip = throw "'lxdvdrip' has been removed due to lack of upstream maintenance."; # Added 2025-06-09

     

       1534
       1557
        
         lzma = throw "'lzma' has been renamed to/replaced by 'xz'"; # Converted to throw 2024-10-17

     

       1535
       1558
        
         lzwolf = throw "'lzwolf' has been removed because it's no longer maintained upstream. Consider using 'ecwolf'"; # Added 2025-03-02