commit ca5cb00a4cfc8505a637527b7ebc8f342a4c7eeb · pyrox.dev/nixpkgs

+29 -34

nixos/modules/services/networking/veilid.nix

···

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2
        
       with lib;

     

       3
        
       let

     

       4
        
         cfg = config.services.veilid;

     
···

       6
        
       

     

       7
        
         settingsFormat = pkgs.formats.yaml { };

     

       8
        
         configFile = settingsFormat.generate "veilid-server.conf" cfg.settings;

     

       9
       -
       in {

     

       0
        
       
     

       10
        
         config = mkIf cfg.enable {

     

       11
        
           networking.firewall = mkIf cfg.openFirewall {

     

       12
        
             allowedTCPPorts = [ 5150 ];

     
···

       21
        
             before = [ "network-online.target" ];

     

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

     

       23
        
             restartTriggers = [ configFile ];

     

       24
       -
             environment = { RUST_BACKTRACE = "1"; };

     

       0
        
       
     

       0
        
       
     

       25
        
             serviceConfig = {

     

       26
        
               ExecStart = "${pkgs.veilid}/bin/veilid-server -c ${configFile}";

     

       27
        
               ExecReload = "${pkgs.coreutils}/bin/kill -s HUP $MAINPID";

     
···

       63
        
           };

     

       64
        
           users.groups.veilid = { };

     

       65
        
       

     

       66
       -
           environment = { systemPackages = [ pkgs.veilid ]; };

     

       0
        
       
     

       0
        
       
     

       67
        
           services.veilid.settings = { };

     

       68
        
         };

     

       69
        
       

     
···

       87
        
                   ipc_enabled = mkOption {

     

       88
        
                     type = types.bool;

     

       89
        
                     default = true;

     

       90
       -
                     description =

     

       91
       -
                       "veilid-server will respond to Python and other JSON client requests.";

     

       92
        
                   };

     

       93
        
                   ipc_directory = mkOption {

     

       94
        
                     type = types.str;

     
···

       107
        
                       type = types.str;

     

       108
        
                       default = "info";

     

       109
        
                       example = "debug";

     

       110
       -
                       description =

     

       111
       -
                         "The minimum priority of system events to be logged.";

     

       112
        
                     };

     

       113
        
                   };

     

       114
        
                   terminal = {

     
···

       121
        
                       type = types.str;

     

       122
        
                       default = "info";

     

       123
        
                       example = "debug";

     

       124
       -
                       description =

     

       125
       -
                         "The minimum priority of terminal events to be logged.";

     

       126
        
                     };

     

       127
        
                   };

     

       128
        
                   api = {

     
···

       135
        
                       type = types.str;

     

       136
        
                       default = "info";

     

       137
        
                       example = "debug";

     

       138
       -
                       description =

     

       139
       -
                         "The minimum priority of api events to be logged.";

     

       140
        
                     };

     

       141
        
                   };

     

       142
        
                 };

     
···

       146
        
                       type = types.listOf types.str;

     

       147
        
                       default = [ ];

     

       148
        
                       example = [ "APPM" ];

     

       149
       -
                       description =

     

       150
       -
                         "A list of capabilities to disable (for example, DHTV to say you cannot store DHT information).";

     

       151
        
                     };

     

       152
        
                   };

     

       153
        
                   protected_store = {

     

       154
        
                     allow_insecure_fallback = mkOption {

     

       155
        
                       type = types.bool;

     

       156
        
                       default = true;

     

       157
       -
                       description =

     

       158
       -
                         "If we can't use system-provided secure storage, should we proceed anyway?";

     

       159
        
                     };

     

       160
        
                     always_use_insecure_storage = mkOption {

     

       161
        
                       type = types.bool;

     

       162
        
                       default = true;

     

       163
       -
                       description =

     

       164
       -
                         "Should we bypass any attempt to use system-provided secure storage?";

     

       165
        
                     };

     

       166
        
                     directory = mkOption {

     

       167
        
                       type = types.str;

     

       168
        
                       default = "${dataDir}/protected_store";

     

       169
       -
                       description =

     

       170
       -
                         "The filesystem directory to store your protected store in.";

     

       171
        
                     };

     

       172
        
                   };

     

       173
        
                   table_store = {

     

       174
        
                     directory = mkOption {

     

       175
        
                       type = types.str;

     

       176
        
                       default = "${dataDir}/table_store";

     

       177
       -
                       description =

     

       178
       -
                         "The filesystem directory to store your table store within.";

     

       179
        
                     };

     

       180
        
                   };

     

       181
        
                   block_store = {

     

       182
        
                     directory = mkOption {

     

       183
        
                       type = types.nullOr types.str;

     

       184
        
                       default = "${dataDir}/block_store";

     

       185
       -
                       description =

     

       186
       -
                         "The filesystem directory to store blocks for the block store.";

     

       187
        
                     };

     

       188
        
                   };

     

       189
        
                   network = {

     
···

       191
        
                       bootstrap = mkOption {

     

       192
        
                         type = types.listOf types.str;

     

       193
        
                         default = [ "bootstrap.veilid.net" ];

     

       194
       -
                         description =

     

       195
       -
                           "Host name of existing well-known Veilid bootstrap servers for the network to connect to.";

     

       196
        
                       };

     

       197
        
                       node_id = lib.mkOption {

     

       198
        
                         type = lib.types.nullOr lib.types.str;

     

       199
        
                         default = null;

     

       200
       -
                         description =

     

       201
       -
                           "Base64-encoded public key for the node, used as the node's ID.";

     

       202
        
                       };

     

       203
        
                     };

     

       204
        
                     dht = {

     

       205
        
                       min_peer_count = mkOption {

     

       206
        
                         type = types.number;

     

       207
        
                         default = 20;

     

       208
       -
                         description =

     

       209
       -
                           "Minimum number of nodes to keep in the peer table.";

     

       210
        
                       };

     

       211
        
                     };

     

       212
        
                     upnp = mkOption {

     

       213
        
                       type = types.bool;

     

       214
        
                       default = true;

     

       215
       -
                       description =

     

       216
       -
                         "Should the app try to improve its incoming network connectivity using UPnP?";

     

       217
        
                     };

     

       218
        
                     detect_address_changes = mkOption {

     

       219
        
                       type = types.bool;

     

       220
        
                       default = true;

     

       221
       -
                       description =

     

       222
       -
                         "Should veilid-core detect and notify on network address changes?";

     

       223
        
                     };

     

       224
        
                   };

     

       225
        
                 };

···

       1
       +
       {

     

       2
       +
         config,

     

       3
       +
         pkgs,

     

       4
       +
         lib,

     

       5
       +
         ...

     

       6
       +
       }:

     

       7
        
       with lib;

     

       8
        
       let

     

       9
        
         cfg = config.services.veilid;

     
···

       11
        
       

     

       12
        
         settingsFormat = pkgs.formats.yaml { };

     

       13
        
         configFile = settingsFormat.generate "veilid-server.conf" cfg.settings;

     

       14
       +
       in

     

       15
       +
       {

     

       16
        
         config = mkIf cfg.enable {

     

       17
        
           networking.firewall = mkIf cfg.openFirewall {

     

       18
        
             allowedTCPPorts = [ 5150 ];

     
···

       27
        
             before = [ "network-online.target" ];

     

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

     

       29
        
             restartTriggers = [ configFile ];

     

       30
       +
             environment = {

     

       31
       +
               RUST_BACKTRACE = "1";

     

       32
       +
             };

     

       33
        
             serviceConfig = {

     

       34
        
               ExecStart = "${pkgs.veilid}/bin/veilid-server -c ${configFile}";

     

       35
        
               ExecReload = "${pkgs.coreutils}/bin/kill -s HUP $MAINPID";

     
···

       71
        
           };

     

       72
        
           users.groups.veilid = { };

     

       73
        
       

     

       74
       +
           environment = {

     

       75
       +
             systemPackages = [ pkgs.veilid ];

     

       76
       +
           };

     

       77
        
           services.veilid.settings = { };

     

       78
        
         };

     

       79
        
       

     
···

       97
        
                   ipc_enabled = mkOption {

     

       98
        
                     type = types.bool;

     

       99
        
                     default = true;

     

       100
       +
                     description = "veilid-server will respond to Python and other JSON client requests.";

     

       0
        
       
     

       101
        
                   };

     

       102
        
                   ipc_directory = mkOption {

     

       103
        
                     type = types.str;

     
···

       116
        
                       type = types.str;

     

       117
        
                       default = "info";

     

       118
        
                       example = "debug";

     

       119
       +
                       description = "The minimum priority of system events to be logged.";

     

       0
        
       
     

       120
        
                     };

     

       121
        
                   };

     

       122
        
                   terminal = {

     
···

       129
        
                       type = types.str;

     

       130
        
                       default = "info";

     

       131
        
                       example = "debug";

     

       132
       +
                       description = "The minimum priority of terminal events to be logged.";

     

       0
        
       
     

       133
        
                     };

     

       134
        
                   };

     

       135
        
                   api = {

     
···

       142
        
                       type = types.str;

     

       143
        
                       default = "info";

     

       144
        
                       example = "debug";

     

       145
       +
                       description = "The minimum priority of api events to be logged.";

     

       0
        
       
     

       146
        
                     };

     

       147
        
                   };

     

       148
        
                 };

     
···

       152
        
                       type = types.listOf types.str;

     

       153
        
                       default = [ ];

     

       154
        
                       example = [ "APPM" ];

     

       155
       +
                       description = "A list of capabilities to disable (for example, DHTV to say you cannot store DHT information).";

     

       0
        
       
     

       156
        
                     };

     

       157
        
                   };

     

       158
        
                   protected_store = {

     

       159
        
                     allow_insecure_fallback = mkOption {

     

       160
        
                       type = types.bool;

     

       161
        
                       default = true;

     

       162
       +
                       description = "If we can't use system-provided secure storage, should we proceed anyway?";

     

       0
        
       
     

       163
        
                     };

     

       164
        
                     always_use_insecure_storage = mkOption {

     

       165
        
                       type = types.bool;

     

       166
        
                       default = true;

     

       167
       +
                       description = "Should we bypass any attempt to use system-provided secure storage?";

     

       0
        
       
     

       168
        
                     };

     

       169
        
                     directory = mkOption {

     

       170
        
                       type = types.str;

     

       171
        
                       default = "${dataDir}/protected_store";

     

       172
       +
                       description = "The filesystem directory to store your protected store in.";

     

       0
        
       
     

       173
        
                     };

     

       174
        
                   };

     

       175
        
                   table_store = {

     

       176
        
                     directory = mkOption {

     

       177
        
                       type = types.str;

     

       178
        
                       default = "${dataDir}/table_store";

     

       179
       +
                       description = "The filesystem directory to store your table store within.";

     

       0
        
       
     

       180
        
                     };

     

       181
        
                   };

     

       182
        
                   block_store = {

     

       183
        
                     directory = mkOption {

     

       184
        
                       type = types.nullOr types.str;

     

       185
        
                       default = "${dataDir}/block_store";

     

       186
       +
                       description = "The filesystem directory to store blocks for the block store.";

     

       0
        
       
     

       187
        
                     };

     

       188
        
                   };

     

       189
        
                   network = {

     
···

       191
        
                       bootstrap = mkOption {

     

       192
        
                         type = types.listOf types.str;

     

       193
        
                         default = [ "bootstrap.veilid.net" ];

     

       194
       +
                         description = "Host name of existing well-known Veilid bootstrap servers for the network to connect to.";

     

       0
        
       
     

       195
        
                       };

     

       196
        
                       node_id = lib.mkOption {

     

       197
        
                         type = lib.types.nullOr lib.types.str;

     

       198
        
                         default = null;

     

       199
       +
                         description = "Base64-encoded public key for the node, used as the node's ID.";

     

       0
        
       
     

       200
        
                       };

     

       201
        
                     };

     

       202
        
                     dht = {

     

       203
        
                       min_peer_count = mkOption {

     

       204
        
                         type = types.number;

     

       205
        
                         default = 20;

     

       206
       +
                         description = "Minimum number of nodes to keep in the peer table.";

     

       0
        
       
     

       207
        
                       };

     

       208
        
                     };

     

       209
        
                     upnp = mkOption {

     

       210
        
                       type = types.bool;

     

       211
        
                       default = true;

     

       212
       +
                       description = "Should the app try to improve its incoming network connectivity using UPnP?";

     

       0
        
       
     

       213
        
                     };

     

       214
        
                     detect_address_changes = mkOption {

     

       215
        
                       type = types.bool;

     

       216
        
                       default = true;

     

       217
       +
                       description = "Should veilid-core detect and notify on network address changes?";

     

       0
        
       
     

       218
        
                     };

     

       219
        
                   };

     

       220
        
                 };