commit bbabfca453cdf16844f3140766f6d678abbc853f · pyrox.dev/nixpkgs

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

···

       93
       93
        
       

     

       94
       94
        
       - [Clevis](https://github.com/latchset/clevis), a pluggable framework for automated decryption, used to unlock encrypted devices in initrd. Available as [boot.initrd.clevis.enable](#opt-boot.initrd.clevis.enable).

     

       95
       95
        
       

     

       96
       96
       +
       - [armagetronad](https://wiki.armagetronad.org), a mid-2000s 3D lightcycle game widely played at iD Tech Camps. You can define multiple servers using `services.armagetronad.<server>.enable`.

     

       97
       97
       +
       

     

       96
       98
        
       - [TuxClocker](https://github.com/Lurkki14/tuxclocker), a hardware control and monitoring program. Available as [programs.tuxclocker](#opt-programs.tuxclocker.enable).

     

       97
       99
        
       

     

       98
       100
        
       - [ALVR](https://github.com/alvr-org/alvr), a VR desktop streamer. Available as [programs.alvr](#opt-programs.alvr.enable)

nixos/modules/module-list.nix

···

       512
       512
        
         ./services/editors/infinoted.nix

     

       513
       513
        
         ./services/finance/odoo.nix

     

       514
       514
        
         ./services/games/archisteamfarm.nix

     

       515
       515
       +
         ./services/games/armagetronad.nix

     

       515
       516
        
         ./services/games/crossfire-server.nix

     

       516
       517
        
         ./services/games/deliantra-server.nix

     

       517
       518
        
         ./services/games/factorio.nix

+268

nixos/modules/services/games/armagetronad.nix

···

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

     

       2
       2
       +
       let

     

       3
       3
       +
         inherit (lib) mkEnableOption mkIf mkOption mkMerge literalExpression;

     

       4
       4
       +
         inherit (lib) mapAttrsToList filterAttrs unique recursiveUpdate types;

     

       5
       5
       +
       

     

       6
       6
       +
         mkValueStringArmagetron = with lib; v:

     

       7
       7
       +
           if isInt v then toString v

     

       8
       8
       +
           else if isFloat v then toString v

     

       9
       9
       +
           else if isString v then v

     

       10
       10
       +
           else if true == v then "1"

     

       11
       11
       +
           else if false == v then "0"

     

       12
       12
       +
           else if null == v then ""

     

       13
       13
       +
           else throw "unsupported type: ${builtins.typeOf v}: ${(lib.generators.toPretty {} v)}";

     

       14
       14
       +
       

     

       15
       15
       +
         settingsFormat = pkgs.formats.keyValue {

     

       16
       16
       +
           mkKeyValue = lib.generators.mkKeyValueDefault

     

       17
       17
       +
             {

     

       18
       18
       +
               mkValueString = mkValueStringArmagetron;

     

       19
       19
       +
             } " ";

     

       20
       20
       +
           listsAsDuplicateKeys = true;

     

       21
       21
       +
         };

     

       22
       22
       +
       

     

       23
       23
       +
         cfg = config.services.armagetronad;

     

       24
       24
       +
         enabledServers = lib.filterAttrs (n: v: v.enable) cfg.servers;

     

       25
       25
       +
         nameToId = serverName: "armagetronad-${serverName}";

     

       26
       26
       +
         getStateDirectory = serverName: "armagetronad/${serverName}";

     

       27
       27
       +
         getServerRoot = serverName: "/var/lib/${getStateDirectory serverName}";

     

       28
       28
       +
       in

     

       29
       29
       +
       {

     

       30
       30
       +
         options = {

     

       31
       31
       +
           services.armagetronad = {

     

       32
       32
       +
             servers = mkOption {

     

       33
       33
       +
               description = lib.mdDoc "Armagetron server definitions.";

     

       34
       34
       +
               default = { };

     

       35
       35
       +
               type = types.attrsOf (types.submodule {

     

       36
       36
       +
                 options = {

     

       37
       37
       +
                   enable = mkEnableOption (lib.mdDoc "armagetronad");

     

       38
       38
       +
       

     

       39
       39
       +
                   package = lib.mkPackageOptionMD pkgs "armagetronad-dedicated" {

     

       40
       40
       +
                     example = ''

     

       41
       41
       +
                       pkgs.armagetronad."0.2.9-sty+ct+ap".dedicated

     

       42
       42
       +
                     '';

     

       43
       43
       +
                     extraDescription = ''

     

       44
       44
       +
                       Ensure that you use a derivation which contains the path `bin/armagetronad-dedicated`.

     

       45
       45
       +
                     '';

     

       46
       46
       +
                   };

     

       47
       47
       +
       

     

       48
       48
       +
                   host = mkOption {

     

       49
       49
       +
                     type = types.str;

     

       50
       50
       +
                     default = "0.0.0.0";

     

       51
       51
       +
                     description = lib.mdDoc "Host to listen on. Used for SERVER_IP.";

     

       52
       52
       +
                   };

     

       53
       53
       +
       

     

       54
       54
       +
                   port = mkOption {

     

       55
       55
       +
                     type = types.port;

     

       56
       56
       +
                     default = 4534;

     

       57
       57
       +
                     description = lib.mdDoc "Port to listen on. Used for SERVER_PORT.";

     

       58
       58
       +
                   };

     

       59
       59
       +
       

     

       60
       60
       +
                   dns = mkOption {

     

       61
       61
       +
                     type = types.nullOr types.str;

     

       62
       62
       +
                     default = null;

     

       63
       63
       +
                     description = lib.mdDoc "DNS address to use for this server. Optional.";

     

       64
       64
       +
                   };

     

       65
       65
       +
       

     

       66
       66
       +
                   openFirewall = mkOption {

     

       67
       67
       +
                     type = types.bool;

     

       68
       68
       +
                     default = true;

     

       69
       69
       +
                     description = lib.mdDoc "Set to true to open the configured UDP port for Armagetron Advanced.";

     

       70
       70
       +
                   };

     

       71
       71
       +
       

     

       72
       72
       +
                   name = mkOption {

     

       73
       73
       +
                     type = types.str;

     

       74
       74
       +
                     description = "The name of this server.";

     

       75
       75
       +
                   };

     

       76
       76
       +
       

     

       77
       77
       +
                   settings = mkOption {

     

       78
       78
       +
                     type = settingsFormat.type;

     

       79
       79
       +
                     default = { };

     

       80
       80
       +
                     description = lib.mdDoc ''

     

       81
       81
       +
                       Armagetron Advanced server rules configuration. Refer to:

     

       82
       82
       +
                       <https://wiki.armagetronad.org/index.php?title=Console_Commands>

     

       83
       83
       +
                       or `armagetronad-dedicated --doc` for a list.

     

       84
       84
       +
       

     

       85
       85
       +
                       This attrset is used to populate `settings_custom.cfg`; see:

     

       86
       86
       +
                       <https://wiki.armagetronad.org/index.php/Configuration_Files>

     

       87
       87
       +
                     '';

     

       88
       88
       +
                     example = literalExpression ''

     

       89
       89
       +
                       {

     

       90
       90
       +
                         CYCLE_RUBBER = 40;

     

       91
       91
       +
                       }

     

       92
       92
       +
                     '';

     

       93
       93
       +
                   };

     

       94
       94
       +
       

     

       95
       95
       +
                   roundSettings = mkOption {

     

       96
       96
       +
                     type = settingsFormat.type;

     

       97
       97
       +
                     default = { };

     

       98
       98
       +
                     description = lib.mdDoc ''

     

       99
       99
       +
                       Armagetron Advanced server per-round configuration. Refer to:

     

       100
       100
       +
                       <https://wiki.armagetronad.org/index.php?title=Console_Commands>

     

       101
       101
       +
                       or `armagetronad-dedicated --doc` for a list.

     

       102
       102
       +
       

     

       103
       103
       +
                       This attrset is used to populate `everytime.cfg`; see:

     

       104
       104
       +
                       <https://wiki.armagetronad.org/index.php/Configuration_Files>

     

       105
       105
       +
                     '';

     

       106
       106
       +
                     example = literalExpression ''

     

       107
       107
       +
                       {

     

       108
       108
       +
                         SAY = [

     

       109
       109
       +
                           "Hosted on NixOS"

     

       110
       110
       +
                           "https://nixos.org"

     

       111
       111
       +
                           "iD Tech High Rubber rul3z!! Happy New Year 2008!!1"

     

       112
       112
       +
                         ];

     

       113
       113
       +
                       }

     

       114
       114
       +
                     '';

     

       115
       115
       +
                   };

     

       116
       116
       +
                 };

     

       117
       117
       +
               });

     

       118
       118
       +
             };

     

       119
       119
       +
           };

     

       120
       120
       +
         };

     

       121
       121
       +
       

     

       122
       122
       +
         config = mkIf (enabledServers != { }) {

     

       123
       123
       +
           systemd.tmpfiles.settings = mkMerge (mapAttrsToList

     

       124
       124
       +
             (serverName: serverCfg:

     

       125
       125
       +
               let

     

       126
       126
       +
                 serverId = nameToId serverName;

     

       127
       127
       +
                 serverRoot = getServerRoot serverName;

     

       128
       128
       +
                 serverInfo = (

     

       129
       129
       +
                   {

     

       130
       130
       +
                     SERVER_IP = serverCfg.host;

     

       131
       131
       +
                     SERVER_PORT = serverCfg.port;

     

       132
       132
       +
                     SERVER_NAME = serverCfg.name;

     

       133
       133
       +
                   } // (lib.optionalAttrs (serverCfg.dns != null) { SERVER_DNS = serverCfg.dns; })

     

       134
       134
       +
                 );

     

       135
       135
       +
                 customSettings = serverCfg.settings;

     

       136
       136
       +
                 everytimeSettings = serverCfg.roundSettings;

     

       137
       137
       +
       

     

       138
       138
       +
                 serverInfoCfg = settingsFormat.generate "server_info.${serverName}.cfg" serverInfo;

     

       139
       139
       +
                 customSettingsCfg = settingsFormat.generate "settings_custom.${serverName}.cfg" customSettings;

     

       140
       140
       +
                 everytimeSettingsCfg = settingsFormat.generate "everytime.${serverName}.cfg" everytimeSettings;

     

       141
       141
       +
               in

     

       142
       142
       +
               {

     

       143
       143
       +
                 "10-armagetronad-${serverId}" = {

     

       144
       144
       +
                   "${serverRoot}/data" = {

     

       145
       145
       +
                     d = {

     

       146
       146
       +
                       group = serverId;

     

       147
       147
       +
                       user = serverId;

     

       148
       148
       +
                       mode = "0750";

     

       149
       149
       +
                     };

     

       150
       150
       +
                   };

     

       151
       151
       +
                   "${serverRoot}/settings" = {

     

       152
       152
       +
                     d = {

     

       153
       153
       +
                       group = serverId;

     

       154
       154
       +
                       user = serverId;

     

       155
       155
       +
                       mode = "0750";

     

       156
       156
       +
                     };

     

       157
       157
       +
                   };

     

       158
       158
       +
                   "${serverRoot}/var" = {

     

       159
       159
       +
                     d = {

     

       160
       160
       +
                       group = serverId;

     

       161
       161
       +
                       user = serverId;

     

       162
       162
       +
                       mode = "0750";

     

       163
       163
       +
                     };

     

       164
       164
       +
                   };

     

       165
       165
       +
                   "${serverRoot}/resource" = {

     

       166
       166
       +
                     d = {

     

       167
       167
       +
                       group = serverId;

     

       168
       168
       +
                       user = serverId;

     

       169
       169
       +
                       mode = "0750";

     

       170
       170
       +
                     };

     

       171
       171
       +
                   };

     

       172
       172
       +
                   "${serverRoot}/input" = {

     

       173
       173
       +
                     "f+" = {

     

       174
       174
       +
                       group = serverId;

     

       175
       175
       +
                       user = serverId;

     

       176
       176
       +
                       mode = "0640";

     

       177
       177
       +
                     };

     

       178
       178
       +
                   };

     

       179
       179
       +
                   "${serverRoot}/settings/server_info.cfg" = {

     

       180
       180
       +
                     "L+" = {

     

       181
       181
       +
                       argument = "${serverInfoCfg}";

     

       182
       182
       +
                     };

     

       183
       183
       +
                   };

     

       184
       184
       +
                   "${serverRoot}/settings/settings_custom.cfg" = {

     

       185
       185
       +
                     "L+" = {

     

       186
       186
       +
                       argument = "${customSettingsCfg}";

     

       187
       187
       +
                     };

     

       188
       188
       +
                   };

     

       189
       189
       +
                   "${serverRoot}/settings/everytime.cfg" = {

     

       190
       190
       +
                     "L+" = {

     

       191
       191
       +
                       argument = "${everytimeSettingsCfg}";

     

       192
       192
       +
                     };

     

       193
       193
       +
                   };

     

       194
       194
       +
                 };

     

       195
       195
       +
               }

     

       196
       196
       +
             )

     

       197
       197
       +
             enabledServers

     

       198
       198
       +
           );

     

       199
       199
       +
       

     

       200
       200
       +
           systemd.services = mkMerge (mapAttrsToList

     

       201
       201
       +
             (serverName: serverCfg:

     

       202
       202
       +
               let

     

       203
       203
       +
                 serverId = nameToId serverName;

     

       204
       204
       +
               in

     

       205
       205
       +
               {

     

       206
       206
       +
                 "armagetronad-${serverName}" = {

     

       207
       207
       +
                   description = "Armagetron Advanced Dedicated Server for ${serverName}";

     

       208
       208
       +
                   wants = [ "basic.target" ];

     

       209
       209
       +
                   after = [ "basic.target" "network.target" "multi-user.target" ];

     

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

     

       211
       211
       +
                   serviceConfig =

     

       212
       212
       +
                     let

     

       213
       213
       +
                       serverRoot = getServerRoot serverName;

     

       214
       214
       +
                     in

     

       215
       215
       +
                     {

     

       216
       216
       +
                       Type = "simple";

     

       217
       217
       +
                       StateDirectory = getStateDirectory serverName;

     

       218
       218
       +
                       ExecStart = "${lib.getExe serverCfg.package} --daemon --input ${serverRoot}/input --userdatadir ${serverRoot}/data --userconfigdir ${serverRoot}/settings --vardir ${serverRoot}/var --autoresourcedir ${serverRoot}/resource";

     

       219
       219
       +
                       Restart = "on-failure";

     

       220
       220
       +
                       CapabilityBoundingSet = "";

     

       221
       221
       +
                       LockPersonality = true;

     

       222
       222
       +
                       NoNewPrivileges = true;

     

       223
       223
       +
                       PrivateDevices = true;

     

       224
       224
       +
                       PrivateTmp = true;

     

       225
       225
       +
                       PrivateUsers = true;

     

       226
       226
       +
                       ProtectClock = true;

     

       227
       227
       +
                       ProtectControlGroups = true;

     

       228
       228
       +
                       ProtectHome = true;

     

       229
       229
       +
                       ProtectHostname = true;

     

       230
       230
       +
                       ProtectKernelLogs = true;

     

       231
       231
       +
                       ProtectKernelModules = true;

     

       232
       232
       +
                       ProtectKernelTunables = true;

     

       233
       233
       +
                       ProtectProc = "invisible";

     

       234
       234
       +
                       ProtectSystem = "strict";

     

       235
       235
       +
                       RestrictNamespaces = true;

     

       236
       236
       +
                       RestrictSUIDSGID = true;

     

       237
       237
       +
                       User = serverId;

     

       238
       238
       +
                       Group = serverId;

     

       239
       239
       +
                     };

     

       240
       240
       +
                 };

     

       241
       241
       +
               })

     

       242
       242
       +
             enabledServers

     

       243
       243
       +
           );

     

       244
       244
       +
       

     

       245
       245
       +
           networking.firewall.allowedUDPPorts =

     

       246
       246
       +
             unique (mapAttrsToList (serverName: serverCfg: serverCfg.port) (filterAttrs (serverName: serverCfg: serverCfg.openFirewall) enabledServers));

     

       247
       247
       +
       

     

       248
       248
       +
           users.users = mkMerge (mapAttrsToList

     

       249
       249
       +
             (serverName: serverCfg:

     

       250
       250
       +
               {

     

       251
       251
       +
                 ${nameToId serverName} = {

     

       252
       252
       +
                   group = nameToId serverName;

     

       253
       253
       +
                   description = "Armagetron Advanced dedicated user for server ${serverName}";

     

       254
       254
       +
                   isSystemUser = true;

     

       255
       255
       +
                 };

     

       256
       256
       +
               })

     

       257
       257
       +
             enabledServers

     

       258
       258
       +
           );

     

       259
       259
       +
       

     

       260
       260
       +
           users.groups = mkMerge (mapAttrsToList

     

       261
       261
       +
             (serverName: serverCfg:

     

       262
       262
       +
               {

     

       263
       263
       +
                 ${nameToId serverName} = { };

     

       264
       264
       +
               })

     

       265
       265
       +
             enabledServers

     

       266
       266
       +
           );

     

       267
       267
       +
         };

     

       268
       268
       +
       }

nixos/tests/all-tests.nix

···

       128
       128
        
         appliance-repart-image = runTest ./appliance-repart-image.nix;

     

       129
       129
        
         apparmor = handleTest ./apparmor.nix {};

     

       130
       130
        
         archi = handleTest ./archi.nix {};

     

       131
       131
       +
         armagetronad = handleTest ./armagetronad.nix {};

     

       131
       132
        
         atd = handleTest ./atd.nix {};

     

       132
       133
        
         atop = handleTest ./atop.nix {};

     

       133
       134
        
         atuin = handleTest ./atuin.nix {};

+272

nixos/tests/armagetronad.nix

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         user = "alice";

     

       5
       5
       +
       

     

       6
       6
       +
         client =

     

       7
       7
       +
           { pkgs, ... }:

     

       8
       8
       +
       

     

       9
       9
       +
           { imports = [ ./common/user-account.nix ./common/x11.nix ];

     

       10
       10
       +
             hardware.opengl.driSupport = true;

     

       11
       11
       +
             virtualisation.memorySize = 256;

     

       12
       12
       +
             environment = {

     

       13
       13
       +
               systemPackages = [ pkgs.armagetronad ];

     

       14
       14
       +
               variables.XAUTHORITY = "/home/${user}/.Xauthority";

     

       15
       15
       +
             };

     

       16
       16
       +
             test-support.displayManager.auto.user = user;

     

       17
       17
       +
           };

     

       18
       18
       +
       

     

       19
       19
       +
       in {

     

       20
       20
       +
         name = "armagetronad";

     

       21
       21
       +
         meta = with pkgs.lib.maintainers; {

     

       22
       22
       +
           maintainers = [ numinit ];

     

       23
       23
       +
         };

     

       24
       24
       +
       

     

       25
       25
       +
         enableOCR = true;

     

       26
       26
       +
       

     

       27
       27
       +
         nodes =

     

       28
       28
       +
           {

     

       29
       29
       +
             server = {

     

       30
       30
       +
               services.armagetronad.servers = {

     

       31
       31
       +
                 high-rubber = {

     

       32
       32
       +
                   enable = true;

     

       33
       33
       +
                   name = "Smoke Test High Rubber Server";

     

       34
       34
       +
                   port = 4534;

     

       35
       35
       +
                   settings = {

     

       36
       36
       +
                     SERVER_OPTIONS = "High Rubber server made to run smoke tests.";

     

       37
       37
       +
                     CYCLE_RUBBER = 40;

     

       38
       38
       +
                     SIZE_FACTOR = 0.5;

     

       39
       39
       +
                   };

     

       40
       40
       +
                   roundSettings = {

     

       41
       41
       +
                     SAY = [

     

       42
       42
       +
                       "NixOS Smoke Test Server"

     

       43
       43
       +
                       "https://nixos.org"

     

       44
       44
       +
                     ];

     

       45
       45
       +
                   };

     

       46
       46
       +
                 };

     

       47
       47
       +
                 sty = {

     

       48
       48
       +
                   enable = true;

     

       49
       49
       +
                   name = "Smoke Test sty+ct+ap Server";

     

       50
       50
       +
                   package = pkgs.armagetronad."0.2.9-sty+ct+ap".dedicated;

     

       51
       51
       +
                   port = 4535;

     

       52
       52
       +
                   settings = {

     

       53
       53
       +
                     SERVER_OPTIONS = "sty+ct+ap server made to run smoke tests.";

     

       54
       54
       +
                     CYCLE_RUBBER = 20;

     

       55
       55
       +
                     SIZE_FACTOR = 0.5;

     

       56
       56
       +
                   };

     

       57
       57
       +
                   roundSettings = {

     

       58
       58
       +
                     SAY = [

     

       59
       59
       +
                       "NixOS Smoke Test sty+ct+ap Server"

     

       60
       60
       +
                       "https://nixos.org"

     

       61
       61
       +
                     ];

     

       62
       62
       +
                   };

     

       63
       63
       +
                 };

     

       64
       64
       +
                 trunk = {

     

       65
       65
       +
                   enable = true;

     

       66
       66
       +
                   name = "Smoke Test trunk Server";

     

       67
       67
       +
                   package = pkgs.armagetronad."0.4".dedicated;

     

       68
       68
       +
                   port = 4536;

     

       69
       69
       +
                   settings = {

     

       70
       70
       +
                     SERVER_OPTIONS = "0.4 server made to run smoke tests.";

     

       71
       71
       +
                     CYCLE_RUBBER = 20;

     

       72
       72
       +
                     SIZE_FACTOR = 0.5;

     

       73
       73
       +
                   };

     

       74
       74
       +
                   roundSettings = {

     

       75
       75
       +
                     SAY = [

     

       76
       76
       +
                       "NixOS Smoke Test 0.4 Server"

     

       77
       77
       +
                       "https://nixos.org"

     

       78
       78
       +
                     ];

     

       79
       79
       +
                   };

     

       80
       80
       +
                 };

     

       81
       81
       +
               };

     

       82
       82
       +
             };

     

       83
       83
       +
       

     

       84
       84
       +
             client1 = client;

     

       85
       85
       +
             client2 = client;

     

       86
       86
       +
           };

     

       87
       87
       +
       

     

       88
       88
       +
         testScript = let

     

       89
       89
       +
           xdo = name: text: let

     

       90
       90
       +
             xdoScript = pkgs.writeText "${name}.xdo" text;

     

       91
       91
       +
           in "${pkgs.xdotool}/bin/xdotool ${xdoScript}";

     

       92
       92
       +
         in

     

       93
       93
       +
           ''

     

       94
       94
       +
             import shlex

     

       95
       95
       +
             import threading

     

       96
       96
       +
             from collections import namedtuple

     

       97
       97
       +
       

     

       98
       98
       +
             class Client(namedtuple('Client', ('node', 'name'))):

     

       99
       99
       +
               def send(self, *keys):

     

       100
       100
       +
                 for key in keys:

     

       101
       101
       +
                   self.node.send_key(key)

     

       102
       102
       +
       

     

       103
       103
       +
               def send_on(self, text, *keys):

     

       104
       104
       +
                 self.node.wait_for_text(text)

     

       105
       105
       +
                 self.send(*keys)

     

       106
       106
       +
       

     

       107
       107
       +
             Server = namedtuple('Server', ('node', 'name', 'address', 'port', 'welcome', 'attacker', 'victim', 'coredump_delay'))

     

       108
       108
       +
       

     

       109
       109
       +
             # Clients and their in-game names

     

       110
       110
       +
             clients = (

     

       111
       111
       +
               Client(client1, 'Arduino'),

     

       112
       112
       +
               Client(client2, 'SmOoThIcE')

     

       113
       113
       +
             )

     

       114
       114
       +
       

     

       115
       115
       +
             # Server configs.

     

       116
       116
       +
             servers = (

     

       117
       117
       +
               Server(server, 'high-rubber', 'server', 4534, 'NixOS Smoke Test Server', 'SmOoThIcE', 'Arduino', 8),

     

       118
       118
       +
               Server(server, 'sty', 'server', 4535, 'NixOS Smoke Test sty+ct+ap Server', 'Arduino', 'SmOoThIcE', 8),

     

       119
       119
       +
               Server(server, 'trunk', 'server', 4536, 'NixOS Smoke Test 0.4 Server', 'Arduino', 'SmOoThIcE', 8)

     

       120
       120
       +
             )

     

       121
       121
       +
       

     

       122
       122
       +
             """

     

       123
       123
       +
             Runs a command as the client user.

     

       124
       124
       +
             """

     

       125
       125
       +
             def run(cmd):

     

       126
       126
       +
               return "su - ${user} -c " + shlex.quote(cmd)

     

       127
       127
       +
       

     

       128
       128
       +
             screenshot_idx = 1

     

       129
       129
       +
       

     

       130
       130
       +
             """

     

       131
       131
       +
             Takes screenshots on all clients.

     

       132
       132
       +
             """

     

       133
       133
       +
             def take_screenshots(screenshot_idx):

     

       134
       134
       +
               for client in clients:

     

       135
       135
       +
                 client.node.screenshot(f"screen_{client.name}_{screenshot_idx}")

     

       136
       136
       +
               return screenshot_idx + 1

     

       137
       137
       +
       

     

       138
       138
       +
             # Wait for the servers to come up.

     

       139
       139
       +
             start_all()

     

       140
       140
       +
             for srv in servers:

     

       141
       141
       +
               srv.node.wait_for_unit(f"armagetronad-{srv.name}")

     

       142
       142
       +
               srv.node.wait_until_succeeds(f"ss --numeric --udp --listening | grep -q {srv.port}")

     

       143
       143
       +
       

     

       144
       144
       +
             # Make sure console commands work through the named pipe we created.

     

       145
       145
       +
             for srv in servers:

     

       146
       146
       +
               srv.node.succeed(

     

       147
       147
       +
                 f"echo 'say Testing!' >> /var/lib/armagetronad/{srv.name}/input"

     

       148
       148
       +
               )

     

       149
       149
       +
               srv.node.succeed(

     

       150
       150
       +
                 f"echo 'say Testing again!' >> /var/lib/armagetronad/{srv.name}/input"

     

       151
       151
       +
               )

     

       152
       152
       +
               srv.node.wait_until_succeeds(

     

       153
       153
       +
                 f"journalctl -u armagetronad-{srv.name} -e | grep -q 'Admin: Testing!'"

     

       154
       154
       +
               )

     

       155
       155
       +
               srv.node.wait_until_succeeds(

     

       156
       156
       +
                 f"journalctl -u armagetronad-{srv.name} -e | grep -q 'Admin: Testing again!'"

     

       157
       157
       +
               )

     

       158
       158
       +
       

     

       159
       159
       +
             """

     

       160
       160
       +
             Sets up a client, waiting for the given barrier on completion.

     

       161
       161
       +
             """

     

       162
       162
       +
             def client_setup(client, servers, barrier):

     

       163
       163
       +
               client.node.wait_for_x()

     

       164
       164
       +
       

     

       165
       165
       +
               # Configure Armagetron.

     

       166
       166
       +
               client.node.succeed(

     

       167
       167
       +
                 run("mkdir -p ~/.armagetronad/var"),

     

       168
       168
       +
                 run(f"echo 'PLAYER_1 {client.name}' >> ~/.armagetronad/var/autoexec.cfg")

     

       169
       169
       +
               )

     

       170
       170
       +
               for idx, srv in enumerate(servers):

     

       171
       171
       +
                 client.node.succeed(

     

       172
       172
       +
                   run(f"echo 'BOOKMARK_{idx+1}_ADDRESS {srv.address}' >> ~/.armagetronad/var/autoexec.cfg"),

     

       173
       173
       +
                   run(f"echo 'BOOKMARK_{idx+1}_NAME {srv.name}' >> ~/.armagetronad/var/autoexec.cfg"),

     

       174
       174
       +
                   run(f"echo 'BOOKMARK_{idx+1}_PORT {srv.port}' >> ~/.armagetronad/var/autoexec.cfg")

     

       175
       175
       +
                 )

     

       176
       176
       +
       

     

       177
       177
       +
               # Start Armagetron.

     

       178
       178
       +
               client.node.succeed(run("ulimit -c unlimited; armagetronad >&2 & disown"))

     

       179
       179
       +
               client.node.wait_until_succeeds(

     

       180
       180
       +
                 run(

     

       181
       181
       +
                   "${xdo "create_new_win-select_main_window" ''

     

       182
       182
       +
                     search --onlyvisible --name "Armagetron Advanced"

     

       183
       183
       +
                     windowfocus --sync

     

       184
       184
       +
                     windowactivate --sync

     

       185
       185
       +
                   ''}"

     

       186
       186
       +
                 )

     

       187
       187
       +
               )

     

       188
       188
       +
       

     

       189
       189
       +
               # Get through the tutorial.

     

       190
       190
       +
               client.send_on('Language Settings', 'ret')

     

       191
       191
       +
               client.send_on('First Setup', 'ret')

     

       192
       192
       +
               client.send_on('Welcome to Armagetron Advanced', 'ret')

     

       193
       193
       +
               client.send_on('round 1', 'esc')

     

       194
       194
       +
               client.send_on('Menu', 'up', 'up', 'ret')

     

       195
       195
       +
               client.send_on('We hope you', 'ret')

     

       196
       196
       +
               client.send_on('Armagetron Advanced', 'ret')

     

       197
       197
       +
               client.send_on('Play Game', 'ret')

     

       198
       198
       +
       

     

       199
       199
       +
               # Online > LAN > Network Setup > Mates > Server Bookmarks

     

       200
       200
       +
               client.send_on('Multiplayer', 'down', 'down', 'down', 'down', 'ret')

     

       201
       201
       +
       

     

       202
       202
       +
               barrier.wait()

     

       203
       203
       +
       

     

       204
       204
       +
             # Get to the Server Bookmarks screen on both clients. This takes a while so do it asynchronously.

     

       205
       205
       +
             barrier = threading.Barrier(3, timeout=120)

     

       206
       206
       +
             for client in clients:

     

       207
       207
       +
               threading.Thread(target=client_setup, args=(client, servers, barrier)).start()

     

       208
       208
       +
             barrier.wait()

     

       209
       209
       +
       

     

       210
       210
       +
             # Main testing loop. Iterates through each server bookmark and connects to them in sequence.

     

       211
       211
       +
             # Assumes that the game is currently on the Server Bookmarks screen.

     

       212
       212
       +
             for srv in servers:

     

       213
       213
       +
               screenshot_idx = take_screenshots(screenshot_idx)

     

       214
       214
       +
       

     

       215
       215
       +
               # Connect both clients at once, one second apart.

     

       216
       216
       +
               for client in clients:

     

       217
       217
       +
                 client.send('ret')

     

       218
       218
       +
                 client.node.sleep(1)

     

       219
       219
       +
       

     

       220
       220
       +
               # Wait for clients to connect

     

       221
       221
       +
               for client in clients:

     

       222
       222
       +
                 srv.node.wait_until_succeeds(

     

       223
       223
       +
                   f"journalctl -u armagetronad-{srv.name} -e | grep -q '{client.name}.*entered the game'"

     

       224
       224
       +
                 )

     

       225
       225
       +
       

     

       226
       226
       +
               # Wait for the match to start

     

       227
       227
       +
               srv.node.wait_until_succeeds(

     

       228
       228
       +
                 f"journalctl -u armagetronad-{srv.name} -e | grep -q 'Admin: {srv.welcome}'"

     

       229
       229
       +
               )

     

       230
       230
       +
               srv.node.wait_until_succeeds(

     

       231
       231
       +
                 f"journalctl -u armagetronad-{srv.name} -e | grep -q 'Admin: https://nixos.org'"

     

       232
       232
       +
               )

     

       233
       233
       +
               srv.node.wait_until_succeeds(

     

       234
       234
       +
                 f"journalctl -u armagetronad-{srv.name} -e | grep -q 'Go (round 1 of 10)'"

     

       235
       235
       +
               )

     

       236
       236
       +
       

     

       237
       237
       +
               # Wait a bit

     

       238
       238
       +
               srv.node.sleep(srv.coredump_delay)

     

       239
       239
       +
       

     

       240
       240
       +
               # Turn the attacker player's lightcycle left

     

       241
       241
       +
               attacker = next(client for client in clients if client.name == srv.attacker)

     

       242
       242
       +
               victim = next(client for client in clients if client.name == srv.victim)

     

       243
       243
       +
               attacker.send('left')

     

       244
       244
       +
               screenshot_idx = take_screenshots(screenshot_idx)

     

       245
       245
       +
       

     

       246
       246
       +
               # Wait for coredump.

     

       247
       247
       +
               srv.node.wait_until_succeeds(

     

       248
       248
       +
                 f"journalctl -u armagetronad-{srv.name} -e | grep -q '{attacker.name} core dumped {victim.name}'"

     

       249
       249
       +
               )

     

       250
       250
       +
               screenshot_idx = take_screenshots(screenshot_idx)

     

       251
       251
       +
       

     

       252
       252
       +
               # Disconnect both clients from the server

     

       253
       253
       +
               for client in clients:

     

       254
       254
       +
                 client.send('esc')

     

       255
       255
       +
                 client.send_on('Menu', 'up', 'up', 'ret')

     

       256
       256
       +
                 srv.node.wait_until_succeeds(

     

       257
       257
       +
                   f"journalctl -u armagetronad-{srv.name} -e | grep -q '{client.name}.*left the game'"

     

       258
       258
       +
                 )

     

       259
       259
       +
       

     

       260
       260
       +
               # Next server.

     

       261
       261
       +
               for client in clients:

     

       262
       262
       +
                 client.send_on('Server Bookmarks', 'down')

     

       263
       263
       +
       

     

       264
       264
       +
             # Stop the servers

     

       265
       265
       +
             for srv in servers:

     

       266
       266
       +
               srv.node.succeed(

     

       267
       267
       +
                 f"systemctl stop armagetronad-{srv.name}"

     

       268
       268
       +
               )

     

       269
       269
       +
               srv.node.wait_until_fails(f"ss --numeric --udp --listening | grep -q {srv.port}")

     

       270
       270
       +
           '';

     

       271
       271
       +
       

     

       272
       272
       +
       })