commit c05c2c2f5c109231d1dc6d70731fe862e2f41d74 · pyrox.dev/nixpkgs

maintainers/maintainer-list.nix

···

       6047
       6047
        
           github = "gigglesquid";

     

       6048
       6048
        
           githubId = 3685154;

     

       6049
       6049
        
           name = "Jack connors";

     

       6050
       6050
       +
           keys = [{

     

       6051
       6051
       +
             fingerprint = "21DF 8034 B212 EDFF 9F19  9C19 F65B 7583 7ABF D019";

     

       6052
       6052
       +
           }];

     

       6050
       6053
        
         };

     

       6051
       6054
        
         gila = {

     

       6052
       6055
        
           email = "jeffry.molanus@gmail.com";

+256 -257

nixos/modules/services/networking/syncthing.nix

···

       7
       7
        
         opt = options.services.syncthing;

     

       8
       8
        
         defaultUser = "syncthing";

     

       9
       9
        
         defaultGroup = defaultUser;

     

       10
       10
       +
         settingsFormat = pkgs.formats.json { };

     

       11
       11
       +
         cleanedConfig = converge (filterAttrsRecursive (_: v: v != null && v != {})) cfg.settings;

     

       10
       12
        
       

     

       11
       11
       -
         devices = mapAttrsToList (name: device: {

     

       13
       13
       +
         devices = mapAttrsToList (_: device: device // {

     

       12
       14
        
           deviceID = device.id;

     

       13
       13
       -
           inherit (device) name addresses introducer autoAcceptFolders;

     

       14
       14
       -
         }) cfg.devices;

     

       15
       15
       +
         }) cfg.settings.devices;

     

       15
       16
        
       

     

       16
       16
       -
         folders = mapAttrsToList ( _: folder: {

     

       17
       17
       -
           inherit (folder) path id label type;

     

       18
       18
       -
           devices = map (device: { deviceId = cfg.devices.${device}.id; }) folder.devices;

     

       19
       19
       -
           rescanIntervalS = folder.rescanInterval;

     

       20
       20
       -
           fsWatcherEnabled = folder.watch;

     

       21
       21
       -
           fsWatcherDelayS = folder.watchDelay;

     

       22
       22
       -
           ignorePerms = folder.ignorePerms;

     

       23
       23
       -
           ignoreDelete = folder.ignoreDelete;

     

       24
       24
       -
           versioning = folder.versioning;

     

       25
       25
       -
         }) (filterAttrs (

     

       26
       26
       -
           _: folder:

     

       17
       17
       +
         folders = mapAttrsToList (_: folder: folder //

     

       18
       18
       +
           throwIf (folder?rescanInterval || folder?watch || folder?watchDelay) ''

     

       19
       19
       +
             The options services.syncthing.settings.folders.<name>.{rescanInterval,watch,watchDelay}

     

       20
       20
       +
             were removed. Please use, respectively, {rescanIntervalS,fsWatcherEnabled,fsWatcherDelayS} instead.

     

       21
       21
       +
           '' {

     

       22
       22
       +
           devices = map (device:

     

       23
       23
       +
             if builtins.isString device then

     

       24
       24
       +
               { deviceId = cfg.settings.devices.${device}.id; }

     

       25
       25
       +
             else

     

       26
       26
       +
               device

     

       27
       27
       +
           ) folder.devices;

     

       28
       28
       +
         }) (filterAttrs (_: folder:

     

       27
       29
        
           folder.enable

     

       28
       28
       -
         ) cfg.folders);

     

       30
       30
       +
         ) cfg.settings.folders);

     

       29
       31
        
       

     

       30
       32
        
         updateConfig = pkgs.writers.writeDash "merge-syncthing-config" ''

     

       31
       33
        
           set -efu

     
···

       54
       56
        
           old_cfg=$(curl ${cfg.guiAddress}/rest/config)

     

       55
       57
        
       

     

       56
       58
        
           # generate the new config by merging with the NixOS config options

     

       57
       57
       -
           new_cfg=$(printf '%s\n' "$old_cfg" | ${pkgs.jq}/bin/jq -c '. * {

     

       58
       58
       -
               "devices": ('${escapeShellArg (builtins.toJSON devices)}'${optionalString (cfg.devices == {} || ! cfg.overrideDevices) " + .devices"}),

     

       59
       59
       -
               "folders": ('${escapeShellArg (builtins.toJSON folders)}'${optionalString (cfg.folders == {} || ! cfg.overrideFolders) " + .folders"})

     

       60
       60
       -
           } * '${escapeShellArg (builtins.toJSON cfg.extraOptions)})

     

       59
       59
       +
           new_cfg=$(printf '%s\n' "$old_cfg" | ${pkgs.jq}/bin/jq -c ${escapeShellArg ''. * ${builtins.toJSON cleanedConfig} * {

     

       60
       60
       +
               "devices": ('${escapeShellArg (builtins.toJSON devices)}'${optionalString (cfg.settings.devices == {} || ! cfg.overrideDevices) " + .devices"}),

     

       61
       61
       +
               "folders": ('${escapeShellArg (builtins.toJSON folders)}'${optionalString (cfg.settings.folders == {} || ! cfg.overrideFolders) " + .folders"})

     

       62
       62
       +
           }''})

     

       61
       63
        
       

     

       62
       64
        
           # send the new config

     

       63
       65
        
           curl -X PUT -d "$new_cfg" ${cfg.guiAddress}/rest/config

     
···

       99
       101
        
               default = true;

     

       100
       102
        
               description = mdDoc ''

     

       101
       103
        
                 Whether to delete the devices which are not configured via the

     

       102
       102
       -
                 [devices](#opt-services.syncthing.devices) option.

     

       104
       104
       +
                 [devices](#opt-services.syncthing.settings.devices) option.

     

       103
       105
        
                 If set to `false`, devices added via the web

     

       104
       106
        
                 interface will persist and will have to be deleted manually.

     

       105
       107
        
               '';

     

       106
       108
        
             };

     

       107
       109
        
       

     

       108
       108
       -
             devices = mkOption {

     

       109
       109
       -
               default = {};

     

       110
       110
       -
               description = mdDoc ''

     

       111
       111
       -
                 Peers/devices which Syncthing should communicate with.

     

       112
       112
       -
       

     

       113
       113
       -
                 Note that you can still add devices manually, but those changes

     

       114
       114
       -
                 will be reverted on restart if [overrideDevices](#opt-services.syncthing.overrideDevices)

     

       115
       115
       -
                 is enabled.

     

       116
       116
       -
               '';

     

       117
       117
       -
               example = {

     

       118
       118
       -
                 bigbox = {

     

       119
       119
       -
                   id = "7CFNTQM-IMTJBHJ-3UWRDIU-ZGQJFR6-VCXZ3NB-XUH3KZO-N52ITXR-LAIYUAU";

     

       120
       120
       -
                   addresses = [ "tcp://192.168.0.10:51820" ];

     

       121
       121
       -
                 };

     

       122
       122
       -
               };

     

       123
       123
       -
               type = types.attrsOf (types.submodule ({ name, ... }: {

     

       124
       124
       -
                 options = {

     

       125
       125
       -
       

     

       126
       126
       -
                   name = mkOption {

     

       127
       127
       -
                     type = types.str;

     

       128
       128
       -
                     default = name;

     

       129
       129
       -
                     description = lib.mdDoc ''

     

       130
       130
       -
                       The name of the device.

     

       131
       131
       -
                     '';

     

       132
       132
       -
                   };

     

       133
       133
       -
       

     

       134
       134
       -
                   addresses = mkOption {

     

       135
       135
       -
                     type = types.listOf types.str;

     

       136
       136
       -
                     default = [];

     

       137
       137
       -
                     description = lib.mdDoc ''

     

       138
       138
       -
                       The addresses used to connect to the device.

     

       139
       139
       -
                       If this is left empty, dynamic configuration is attempted.

     

       140
       140
       -
                     '';

     

       141
       141
       -
                   };

     

       142
       142
       -
       

     

       143
       143
       -
                   id = mkOption {

     

       144
       144
       -
                     type = types.str;

     

       145
       145
       -
                     description = mdDoc ''

     

       146
       146
       -
                       The device ID. See <https://docs.syncthing.net/dev/device-ids.html>.

     

       147
       147
       -
                     '';

     

       148
       148
       -
                   };

     

       149
       149
       -
       

     

       150
       150
       -
                   introducer = mkOption {

     

       151
       151
       -
                     type = types.bool;

     

       152
       152
       -
                     default = false;

     

       153
       153
       -
                     description = mdDoc ''

     

       154
       154
       -
                       Whether the device should act as an introducer and be allowed

     

       155
       155
       -
                       to add folders on this computer.

     

       156
       156
       -
                       See <https://docs.syncthing.net/users/introducer.html>.

     

       157
       157
       -
                     '';

     

       158
       158
       -
                   };

     

       159
       159
       -
       

     

       160
       160
       -
                   autoAcceptFolders = mkOption {

     

       161
       161
       -
                     type = types.bool;

     

       162
       162
       -
                     default = false;

     

       163
       163
       -
                     description = mdDoc ''

     

       164
       164
       -
                       Automatically create or share folders that this device advertises at the default path.

     

       165
       165
       -
                       See <https://docs.syncthing.net/users/config.html?highlight=autoaccept#config-file-format>.

     

       166
       166
       -
                     '';

     

       167
       167
       -
                   };

     

       168
       168
       -
       

     

       169
       169
       -
                 };

     

       170
       170
       -
               }));

     

       171
       171
       -
             };

     

       172
       172
       -
       

     

       173
       110
        
             overrideFolders = mkOption {

     

       174
       111
        
               type = types.bool;

     

       175
       112
        
               default = true;

     

       176
       113
        
               description = mdDoc ''

     

       177
       114
        
                 Whether to delete the folders which are not configured via the

     

       178
       178
       -
                 [folders](#opt-services.syncthing.folders) option.

     

       115
       115
       +
                 [folders](#opt-services.syncthing.settings.folders) option.

     

       179
       116
        
                 If set to `false`, folders added via the web

     

       180
       117
        
                 interface will persist and will have to be deleted manually.

     

       181
       118
        
               '';

     

       182
       119
        
             };

     

       183
       120
        
       

     

       184
       184
       -
             folders = mkOption {

     

       185
       185
       -
               default = {};

     

       186
       186
       -
               description = mdDoc ''

     

       187
       187
       -
                 Folders which should be shared by Syncthing.

     

       121
       121
       +
             settings = mkOption {

     

       122
       122
       +
               type = types.submodule {

     

       123
       123
       +
                 freeformType = settingsFormat.type;

     

       124
       124
       +
                 options = {

     

       125
       125
       +
                   # global options

     

       126
       126
       +
                   options = mkOption {

     

       127
       127
       +
                     default = {};

     

       128
       128
       +
                     description = mdDoc ''

     

       129
       129
       +
                       The options element contains all other global configuration options

     

       130
       130
       +
                     '';

     

       131
       131
       +
                     type = types.submodule ({ name, ... }: {

     

       132
       132
       +
                       freeformType = settingsFormat.type;

     

       133
       133
       +
                       options = {

     

       134
       134
       +
                         localAnnounceEnabled = mkOption {

     

       135
       135
       +
                           type = types.nullOr types.bool;

     

       136
       136
       +
                           default = null;

     

       137
       137
       +
                           description = lib.mdDoc ''

     

       138
       138
       +
                             Whether to send announcements to the local LAN, also use such announcements to find other devices.

     

       139
       139
       +
                           '';

     

       140
       140
       +
                         };

     

       188
       141
        
       

     

       189
       189
       -
                 Note that you can still add folders manually, but those changes

     

       190
       190
       -
                 will be reverted on restart if [overrideFolders](#opt-services.syncthing.overrideFolders)

     

       191
       191
       -
                 is enabled.

     

       192
       192
       -
               '';

     

       193
       193
       -
               example = literalExpression ''

     

       194
       194
       -
                 {

     

       195
       195
       -
                   "/home/user/sync" = {

     

       196
       196
       -
                     id = "syncme";

     

       197
       197
       -
                     devices = [ "bigbox" ];

     

       198
       198
       -
                   };

     

       199
       199
       -
                 }

     

       200
       200
       -
               '';

     

       201
       201
       -
               type = types.attrsOf (types.submodule ({ name, ... }: {

     

       202
       202
       -
                 options = {

     

       142
       142
       +
                         localAnnouncePort = mkOption {

     

       143
       143
       +
                           type = types.nullOr types.int;

     

       144
       144
       +
                           default = null;

     

       145
       145
       +
                           description = lib.mdDoc ''

     

       146
       146
       +
                             The port on which to listen and send IPv4 broadcast announcements to.

     

       147
       147
       +
                           '';

     

       148
       148
       +
                         };

     

       203
       149
        
       

     

       204
       204
       -
                   enable = mkOption {

     

       205
       205
       -
                     type = types.bool;

     

       206
       206
       -
                     default = true;

     

       207
       207
       -
                     description = lib.mdDoc ''

     

       208
       208
       -
                       Whether to share this folder.

     

       209
       209
       -
                       This option is useful when you want to define all folders

     

       210
       210
       -
                       in one place, but not every machine should share all folders.

     

       211
       211
       -
                     '';

     

       212
       212
       -
                   };

     

       150
       150
       +
                         relaysEnabled = mkOption {

     

       151
       151
       +
                           type = types.nullOr types.bool;

     

       152
       152
       +
                           default = null;

     

       153
       153
       +
                           description = lib.mdDoc ''

     

       154
       154
       +
                             When true, relays will be connected to and potentially used for device to device connections.

     

       155
       155
       +
                           '';

     

       156
       156
       +
                         };

     

       213
       157
        
       

     

       214
       214
       -
                   path = mkOption {

     

       215
       215
       -
                     # TODO for release 23.05: allow relative paths again and set

     

       216
       216
       -
                     # working directory to cfg.dataDir

     

       217
       217
       -
                     type = types.str // {

     

       218
       218
       -
                       check = x: types.str.check x && (substring 0 1 x == "/" || substring 0 2 x == "~/");

     

       219
       219
       -
                       description = types.str.description + " starting with / or ~/";

     

       220
       220
       -
                     };

     

       221
       221
       -
                     default = name;

     

       222
       222
       -
                     description = lib.mdDoc ''

     

       223
       223
       -
                       The path to the folder which should be shared.

     

       224
       224
       -
                       Only absolute paths (starting with `/`) and paths relative to

     

       225
       225
       -
                       the [user](#opt-services.syncthing.user)'s home directory

     

       226
       226
       -
                       (starting with `~/`) are allowed.

     

       227
       227
       -
                     '';

     

       228
       228
       -
                   };

     

       158
       158
       +
                         urAccepted = mkOption {

     

       159
       159
       +
                           type = types.nullOr types.int;

     

       160
       160
       +
                           default = null;

     

       161
       161
       +
                           description = lib.mdDoc ''

     

       162
       162
       +
                             Whether the user has accepted to submit anonymous usage data.

     

       163
       163
       +
                             The default, 0, mean the user has not made a choice, and Syncthing will ask at some point in the future.

     

       164
       164
       +
                             "-1" means no, a number above zero means that that version of usage reporting has been accepted.

     

       165
       165
       +
                           '';

     

       166
       166
       +
                         };

     

       229
       167
        
       

     

       230
       230
       -
                   id = mkOption {

     

       231
       231
       -
                     type = types.str;

     

       232
       232
       -
                     default = name;

     

       233
       233
       -
                     description = lib.mdDoc ''

     

       234
       234
       -
                       The ID of the folder. Must be the same on all devices.

     

       235
       235
       -
                     '';

     

       236
       236
       -
                   };

     

       168
       168
       +
                         limitBandwidthInLan = mkOption {

     

       169
       169
       +
                           type = types.nullOr types.bool;

     

       170
       170
       +
                           default = null;

     

       171
       171
       +
                           description = lib.mdDoc ''

     

       172
       172
       +
                             Whether to apply bandwidth limits to devices in the same broadcast domain as the local device.

     

       173
       173
       +
                           '';

     

       174
       174
       +
                         };

     

       237
       175
        
       

     

       238
       238
       -
                   label = mkOption {

     

       239
       239
       -
                     type = types.str;

     

       240
       240
       -
                     default = name;

     

       241
       241
       -
                     description = lib.mdDoc ''

     

       242
       242
       -
                       The label of the folder.

     

       243
       243
       -
                     '';

     

       176
       176
       +
                         maxFolderConcurrency = mkOption {

     

       177
       177
       +
                           type = types.nullOr types.int;

     

       178
       178
       +
                           default = null;

     

       179
       179
       +
                           description = lib.mdDoc ''

     

       180
       180
       +
                             This option controls how many folders may concurrently be in I/O-intensive operations such as syncing or scanning.

     

       181
       181
       +
                             The mechanism is described in detail in a [separate chapter](https://docs.syncthing.net/advanced/option-max-concurrency.html).

     

       182
       182
       +
                           '';

     

       183
       183
       +
                         };

     

       184
       184
       +
                       };

     

       185
       185
       +
                     });

     

       244
       186
        
                   };

     

       245
       187
        
       

     

       188
       188
       +
                   # device settings

     

       246
       189
        
                   devices = mkOption {

     

       247
       247
       -
                     type = types.listOf types.str;

     

       248
       248
       -
                     default = [];

     

       190
       190
       +
                     default = {};

     

       249
       191
        
                     description = mdDoc ''

     

       250
       250
       -
                       The devices this folder should be shared with. Each device must

     

       251
       251
       -
                       be defined in the [devices](#opt-services.syncthing.devices) option.

     

       192
       192
       +
                       Peers/devices which Syncthing should communicate with.

     

       193
       193
       +
       

     

       194
       194
       +
                       Note that you can still add devices manually, but those changes

     

       195
       195
       +
                       will be reverted on restart if [overrideDevices](#opt-services.syncthing.overrideDevices)

     

       196
       196
       +
                       is enabled.

     

       252
       197
        
                     '';

     

       198
       198
       +
                     example = {

     

       199
       199
       +
                       bigbox = {

     

       200
       200
       +
                         id = "7CFNTQM-IMTJBHJ-3UWRDIU-ZGQJFR6-VCXZ3NB-XUH3KZO-N52ITXR-LAIYUAU";

     

       201
       201
       +
                         addresses = [ "tcp://192.168.0.10:51820" ];

     

       202
       202
       +
                       };

     

       203
       203
       +
                     };

     

       204
       204
       +
                     type = types.attrsOf (types.submodule ({ name, ... }: {

     

       205
       205
       +
                       freeformType = settingsFormat.type;

     

       206
       206
       +
                       options = {

     

       207
       207
       +
       

     

       208
       208
       +
                         name = mkOption {

     

       209
       209
       +
                           type = types.str;

     

       210
       210
       +
                           default = name;

     

       211
       211
       +
                           description = lib.mdDoc ''

     

       212
       212
       +
                             The name of the device.

     

       213
       213
       +
                           '';

     

       214
       214
       +
                         };

     

       215
       215
       +
       

     

       216
       216
       +
                         id = mkOption {

     

       217
       217
       +
                           type = types.str;

     

       218
       218
       +
                           description = mdDoc ''

     

       219
       219
       +
                             The device ID. See <https://docs.syncthing.net/dev/device-ids.html>.

     

       220
       220
       +
                           '';

     

       221
       221
       +
                         };

     

       222
       222
       +
       

     

       223
       223
       +
                         autoAcceptFolders = mkOption {

     

       224
       224
       +
                           type = types.bool;

     

       225
       225
       +
                           default = false;

     

       226
       226
       +
                           description = mdDoc ''

     

       227
       227
       +
                             Automatically create or share folders that this device advertises at the default path.

     

       228
       228
       +
                             See <https://docs.syncthing.net/users/config.html?highlight=autoaccept#config-file-format>.

     

       229
       229
       +
                           '';

     

       230
       230
       +
                         };

     

       231
       231
       +
       

     

       232
       232
       +
                       };

     

       233
       233
       +
                     }));

     

       253
       234
        
                   };

     

       254
       235
        
       

     

       255
       255
       -
                   versioning = mkOption {

     

       256
       256
       -
                     default = null;

     

       236
       236
       +
                   # folder settings

     

       237
       237
       +
                   folders = mkOption {

     

       238
       238
       +
                     default = {};

     

       257
       239
        
                     description = mdDoc ''

     

       258
       258
       -
                       How to keep changed/deleted files with Syncthing.

     

       259
       259
       -
                       There are 4 different types of versioning with different parameters.

     

       260
       260
       -
                       See <https://docs.syncthing.net/users/versioning.html>.

     

       240
       240
       +
                       Folders which should be shared by Syncthing.

     

       241
       241
       +
       

     

       242
       242
       +
                       Note that you can still add folders manually, but those changes

     

       243
       243
       +
                       will be reverted on restart if [overrideFolders](#opt-services.syncthing.overrideFolders)

     

       244
       244
       +
                       is enabled.

     

       261
       245
        
                     '';

     

       262
       246
        
                     example = literalExpression ''

     

       263
       263
       -
                       [

     

       264
       264
       -
                         {

     

       265
       265
       -
                           versioning = {

     

       266
       266
       -
                             type = "simple";

     

       267
       267
       -
                             params.keep = "10";

     

       268
       268
       -
                           };

     

       269
       269
       -
                         }

     

       270
       270
       -
                         {

     

       271
       271
       -
                           versioning = {

     

       272
       272
       -
                             type = "trashcan";

     

       273
       273
       -
                             params.cleanoutDays = "1000";

     

       274
       274
       -
                           };

     

       275
       275
       -
                         }

     

       276
       276
       -
                         {

     

       277
       277
       -
                           versioning = {

     

       278
       278
       -
                             type = "staggered";

     

       279
       279
       -
                             fsPath = "/syncthing/backup";

     

       280
       280
       -
                             params = {

     

       281
       281
       -
                               cleanInterval = "3600";

     

       282
       282
       -
                               maxAge = "31536000";

     

       283
       283
       -
                             };

     

       284
       284
       -
                           };

     

       285
       285
       -
                         }

     

       286
       286
       -
                         {

     

       287
       287
       -
                           versioning = {

     

       288
       288
       -
                             type = "external";

     

       289
       289
       -
                             params.versionsPath = pkgs.writers.writeBash "backup" '''

     

       290
       290
       -
                               folderpath="$1"

     

       291
       291
       -
                               filepath="$2"

     

       292
       292
       -
                               rm -rf "$folderpath/$filepath"

     

       293
       293
       -
                             ''';

     

       294
       294
       -
                           };

     

       295
       295
       -
                         }

     

       296
       296
       -
                       ]

     

       247
       247
       +
                       {

     

       248
       248
       +
                         "/home/user/sync" = {

     

       249
       249
       +
                           id = "syncme";

     

       250
       250
       +
                           devices = [ "bigbox" ];

     

       251
       251
       +
                         };

     

       252
       252
       +
                       }

     

       297
       253
        
                     '';

     

       298
       298
       -
                     type = with types; nullOr (submodule {

     

       254
       254
       +
                     type = types.attrsOf (types.submodule ({ name, ... }: {

     

       255
       255
       +
                       freeformType = settingsFormat.type;

     

       299
       256
        
                       options = {

     

       300
       300
       -
                         type = mkOption {

     

       301
       301
       -
                           type = enum [ "external" "simple" "staggered" "trashcan" ];

     

       257
       257
       +
       

     

       258
       258
       +
                         enable = mkOption {

     

       259
       259
       +
                           type = types.bool;

     

       260
       260
       +
                           default = true;

     

       261
       261
       +
                           description = lib.mdDoc ''

     

       262
       262
       +
                             Whether to share this folder.

     

       263
       263
       +
                             This option is useful when you want to define all folders

     

       264
       264
       +
                             in one place, but not every machine should share all folders.

     

       265
       265
       +
                           '';

     

       266
       266
       +
                         };

     

       267
       267
       +
       

     

       268
       268
       +
                         path = mkOption {

     

       269
       269
       +
                           # TODO for release 23.05: allow relative paths again and set

     

       270
       270
       +
                           # working directory to cfg.dataDir

     

       271
       271
       +
                           type = types.str // {

     

       272
       272
       +
                             check = x: types.str.check x && (substring 0 1 x == "/" || substring 0 2 x == "~/");

     

       273
       273
       +
                             description = types.str.description + " starting with / or ~/";

     

       274
       274
       +
                           };

     

       275
       275
       +
                           default = name;

     

       276
       276
       +
                           description = lib.mdDoc ''

     

       277
       277
       +
                             The path to the folder which should be shared.

     

       278
       278
       +
                             Only absolute paths (starting with `/`) and paths relative to

     

       279
       279
       +
                             the [user](#opt-services.syncthing.user)'s home directory

     

       280
       280
       +
                             (starting with `~/`) are allowed.

     

       281
       281
       +
                           '';

     

       282
       282
       +
                         };

     

       283
       283
       +
       

     

       284
       284
       +
                         id = mkOption {

     

       285
       285
       +
                           type = types.str;

     

       286
       286
       +
                           default = name;

     

       287
       287
       +
                           description = lib.mdDoc ''

     

       288
       288
       +
                             The ID of the folder. Must be the same on all devices.

     

       289
       289
       +
                           '';

     

       290
       290
       +
                         };

     

       291
       291
       +
       

     

       292
       292
       +
                         label = mkOption {

     

       293
       293
       +
                           type = types.str;

     

       294
       294
       +
                           default = name;

     

       295
       295
       +
                           description = lib.mdDoc ''

     

       296
       296
       +
                             The label of the folder.

     

       297
       297
       +
                           '';

     

       298
       298
       +
                         };

     

       299
       299
       +
       

     

       300
       300
       +
                         devices = mkOption {

     

       301
       301
       +
                           type = types.listOf types.str;

     

       302
       302
       +
                           default = [];

     

       302
       303
        
                           description = mdDoc ''

     

       303
       303
       -
                             The type of versioning.

     

       304
       304
       -
                             See <https://docs.syncthing.net/users/versioning.html>.

     

       304
       304
       +
                             The devices this folder should be shared with. Each device must

     

       305
       305
       +
                             be defined in the [devices](#opt-services.syncthing.settings.devices) option.

     

       305
       306
        
                           '';

     

       306
       307
        
                         };

     

       307
       307
       -
                         fsPath = mkOption {

     

       308
       308
       -
                           default = "";

     

       309
       309
       -
                           type = either str path;

     

       308
       308
       +
       

     

       309
       309
       +
                         versioning = mkOption {

     

       310
       310
       +
                           default = null;

     

       310
       311
        
                           description = mdDoc ''

     

       311
       311
       -
                             Path to the versioning folder.

     

       312
       312
       +
                             How to keep changed/deleted files with Syncthing.

     

       313
       313
       +
                             There are 4 different types of versioning with different parameters.

     

       312
       314
        
                             See <https://docs.syncthing.net/users/versioning.html>.

     

       313
       315
        
                           '';

     

       316
       316
       +
                           example = literalExpression ''

     

       317
       317
       +
                             [

     

       318
       318
       +
                               {

     

       319
       319
       +
                                 versioning = {

     

       320
       320
       +
                                   type = "simple";

     

       321
       321
       +
                                   params.keep = "10";

     

       322
       322
       +
                                 };

     

       323
       323
       +
                               }

     

       324
       324
       +
                               {

     

       325
       325
       +
                                 versioning = {

     

       326
       326
       +
                                   type = "trashcan";

     

       327
       327
       +
                                   params.cleanoutDays = "1000";

     

       328
       328
       +
                                 };

     

       329
       329
       +
                               }

     

       330
       330
       +
                               {

     

       331
       331
       +
                                 versioning = {

     

       332
       332
       +
                                   type = "staggered";

     

       333
       333
       +
                                   fsPath = "/syncthing/backup";

     

       334
       334
       +
                                   params = {

     

       335
       335
       +
                                     cleanInterval = "3600";

     

       336
       336
       +
                                     maxAge = "31536000";

     

       337
       337
       +
                                   };

     

       338
       338
       +
                                 };

     

       339
       339
       +
                               }

     

       340
       340
       +
                               {

     

       341
       341
       +
                                 versioning = {

     

       342
       342
       +
                                   type = "external";

     

       343
       343
       +
                                   params.versionsPath = pkgs.writers.writeBash "backup" '''

     

       344
       344
       +
                                     folderpath="$1"

     

       345
       345
       +
                                     filepath="$2"

     

       346
       346
       +
                                     rm -rf "$folderpath/$filepath"

     

       347
       347
       +
                                   ''';

     

       348
       348
       +
                                 };

     

       349
       349
       +
                               }

     

       350
       350
       +
                             ]

     

       351
       351
       +
                           '';

     

       352
       352
       +
                           type = with types; nullOr (submodule {

     

       353
       353
       +
                             freeformType = settingsFormat.type;

     

       354
       354
       +
                             options = {

     

       355
       355
       +
                               type = mkOption {

     

       356
       356
       +
                                 type = enum [ "external" "simple" "staggered" "trashcan" ];

     

       357
       357
       +
                                 description = mdDoc ''

     

       358
       358
       +
                                   The type of versioning.

     

       359
       359
       +
                                   See <https://docs.syncthing.net/users/versioning.html>.

     

       360
       360
       +
                                 '';

     

       361
       361
       +
                               };

     

       362
       362
       +
                             };

     

       363
       363
       +
                           });

     

       314
       364
        
                         };

     

       315
       315
       -
                         params = mkOption {

     

       316
       316
       -
                           type = attrsOf (either str path);

     

       365
       365
       +
       

     

       366
       366
       +
                         copyOwnershipFromParent = mkOption {

     

       367
       367
       +
                           type = types.bool;

     

       368
       368
       +
                           default = false;

     

       317
       369
        
                           description = mdDoc ''

     

       318
       318
       -
                             The parameters for versioning. Structure depends on

     

       319
       319
       -
                             [versioning.type](#opt-services.syncthing.folders._name_.versioning.type).

     

       320
       320
       -
                             See <https://docs.syncthing.net/users/versioning.html>.

     

       370
       370
       +
                             On Unix systems, tries to copy file/folder ownership from the parent directory (the directory it’s located in).

     

       371
       371
       +
                             Requires running Syncthing as a privileged user, or granting it additional capabilities (e.g. CAP_CHOWN on Linux).

     

       321
       372
        
                           '';

     

       322
       373
        
                         };

     

       323
       374
        
                       };

     

       324
       324
       -
                     });

     

       325
       325
       -
                   };

     

       326
       326
       -
       

     

       327
       327
       -
                   rescanInterval = mkOption {

     

       328
       328
       -
                     type = types.int;

     

       329
       329
       -
                     default = 3600;

     

       330
       330
       -
                     description = lib.mdDoc ''

     

       331
       331
       -
                       How often the folder should be rescanned for changes.

     

       332
       332
       -
                     '';

     

       333
       333
       -
                   };

     

       334
       334
       -
       

     

       335
       335
       -
                   type = mkOption {

     

       336
       336
       -
                     type = types.enum [ "sendreceive" "sendonly" "receiveonly" "receiveencrypted" ];

     

       337
       337
       -
                     default = "sendreceive";

     

       338
       338
       -
                     description = lib.mdDoc ''

     

       339
       339
       -
                       Whether to only send changes for this folder, only receive them

     

       340
       340
       -
                       or both. `receiveencrypted` can be used for untrusted devices. See

     

       341
       341
       -
                       <https://docs.syncthing.net/users/untrusted.html> for reference.

     

       342
       342
       -
                     '';

     

       343
       343
       -
                   };

     

       344
       344
       -
       

     

       345
       345
       -
                   watch = mkOption {

     

       346
       346
       -
                     type = types.bool;

     

       347
       347
       -
                     default = true;

     

       348
       348
       -
                     description = lib.mdDoc ''

     

       349
       349
       -
                       Whether the folder should be watched for changes by inotify.

     

       350
       350
       -
                     '';

     

       351
       351
       -
                   };

     

       352
       352
       -
       

     

       353
       353
       -
                   watchDelay = mkOption {

     

       354
       354
       -
                     type = types.int;

     

       355
       355
       -
                     default = 10;

     

       356
       356
       -
                     description = lib.mdDoc ''

     

       357
       357
       -
                       The delay after an inotify event is triggered.

     

       358
       358
       -
                     '';

     

       359
       359
       -
                   };

     

       360
       360
       -
       

     

       361
       361
       -
                   ignorePerms = mkOption {

     

       362
       362
       -
                     type = types.bool;

     

       363
       363
       -
                     default = true;

     

       364
       364
       -
                     description = lib.mdDoc ''

     

       365
       365
       -
                       Whether to ignore permission changes.

     

       366
       366
       -
                     '';

     

       375
       375
       +
                     }));

     

       367
       376
        
                   };

     

       368
       377
        
       

     

       369
       369
       -
                   ignoreDelete = mkOption {

     

       370
       370
       -
                     type = types.bool;

     

       371
       371
       -
                     default = false;

     

       372
       372
       -
                     description = mdDoc ''

     

       373
       373
       -
                       Whether to skip deleting files that are deleted by peers.

     

       374
       374
       -
                       See <https://docs.syncthing.net/advanced/folder-ignoredelete.html>.

     

       375
       375
       -
                     '';

     

       376
       376
       -
                   };

     

       377
       378
        
                 };

     

       378
       378
       -
               }));

     

       379
       379
       -
             };

     

       380
       380
       -
       

     

       381
       381
       -
             extraOptions = mkOption {

     

       382
       382
       -
               type = types.addCheck (pkgs.formats.json {}).type isAttrs;

     

       379
       379
       +
               };

     

       383
       380
        
               default = {};

     

       384
       381
        
               description = mdDoc ''

     

       385
       382
        
                 Extra configuration options for Syncthing.

     
···

       530
       527
        
             This option was removed because Syncthing now has the inotify functionality included under the name "fswatcher".

     

       531
       528
        
             It can be enabled on a per-folder basis through the web interface.

     

       532
       529
        
           '')

     

       530
       530
       +
           (mkRenamedOptionModule [ "services" "syncthing" "extraOptions" ] [ "services" "syncthing" "settings" ])

     

       531
       531
       +
           (mkRenamedOptionModule [ "services" "syncthing" "folders" ] [ "services" "syncthing" "settings" "folders" ])

     

       532
       532
       +
           (mkRenamedOptionModule [ "services" "syncthing" "devices" ] [ "services" "syncthing" "settings" "devices" ])

     

       533
       533
       +
           (mkRenamedOptionModule [ "services" "syncthing" "options" ] [ "services" "syncthing" "settings" "options" ])

     

       533
       534
        
         ] ++ map (o:

     

       534
       535
        
           mkRenamedOptionModule [ "services" "syncthing" "declarative" o ] [ "services" "syncthing" o ]

     

       535
       536
        
         ) [ "cert" "key" "devices" "folders" "overrideDevices" "overrideFolders" "extraOptions"];

     
···

       615
       616
        
                 ];

     

       616
       617
        
               };

     

       617
       618
        
             };

     

       618
       618
       -
             syncthing-init = mkIf (

     

       619
       619
       -
               cfg.devices != {} || cfg.folders != {} || cfg.extraOptions != {}

     

       620
       620
       -
             ) {

     

       619
       619
       +
             syncthing-init = mkIf (cleanedConfig != {}) {

     

       621
       620
        
               description = "Syncthing configuration updater";

     

       622
       621
        
               requisite = [ "syncthing.service" ];

     

       623
       622
        
               after = [ "syncthing.service" ];

+1 -1

nixos/modules/services/networking/twingate.nix

···

       12
       12
        
         config = lib.mkIf cfg.enable {

     

       13
       13
        
           systemd.packages = [ cfg.package ];

     

       14
       14
        
           systemd.services.twingate = {

     

       15
       15
       -
             preStart = "cp -r -n ${cfg.package}/etc/twingate/. /etc/twingate/";

     

       15
       15
       +
             preStart = "cp -r --update=none ${cfg.package}/etc/twingate/. /etc/twingate/";

     

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

     

       17
       17
        
           };

     

       18
       18

nixos/tests/all-tests.nix

···

       728
       728
        
         switchTest = handleTest ./switch-test.nix {};

     

       729
       729
        
         sympa = handleTest ./sympa.nix {};

     

       730
       730
        
         syncthing = handleTest ./syncthing.nix {};

     

       731
       731
       +
         syncthing-no-settings = handleTest ./syncthing-no-settings.nix {};

     

       731
       732
        
         syncthing-init = handleTest ./syncthing-init.nix {};

     

       732
       733
        
         syncthing-relay = handleTest ./syncthing-relay.nix {};

     

       733
       734
        
         systemd = handleTest ./systemd.nix {};

+4 -4

nixos/tests/syncthing-init.nix

···

       10
       10
        
         nodes.machine = {

     

       11
       11
        
           services.syncthing = {

     

       12
       12
        
             enable = true;

     

       13
       13
       -
             devices.${testName} = {

     

       13
       13
       +
             settings.devices.testDevice = {

     

       14
       14
        
               id = testId;

     

       15
       15
        
             };

     

       16
       16
       -
             folders.testFolder = {

     

       16
       16
       +
             settings.folders.testFolder = {

     

       17
       17
        
               path = "/tmp/test";

     

       18
       18
       -
               devices = [ testName ];

     

       18
       18
       +
               devices = [ "testDevice" ];

     

       19
       19
        
             };

     

       20
       20
       -
             extraOptions.gui.user = "guiUser";

     

       20
       20
       +
             settings.gui.user = "guiUser";

     

       21
       21
        
           };

     

       22
       22
        
         };

     

       23
       23

+18

nixos/tests/syncthing-no-settings.nix

···

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

     

       2
       2
       +
         name = "syncthing";

     

       3
       3
       +
         meta.maintainers = with pkgs.lib.maintainers; [ chkno ];

     

       4
       4
       +
       

     

       5
       5
       +
         nodes = {

     

       6
       6
       +
           a = {

     

       7
       7
       +
             environment.systemPackages = with pkgs; [ curl libxml2 syncthing ];

     

       8
       8
       +
             services.syncthing = {

     

       9
       9
       +
               enable = true;

     

       10
       10
       +
             };

     

       11
       11
       +
           };

     

       12
       12
       +
         };

     

       13
       13
       +
         # Test that indeed a syncthing-init.service systemd service is not created.

     

       14
       14
       +
         #

     

       15
       15
       +
         testScript = /* python */ ''

     

       16
       16
       +
           a.succeed("systemctl list-unit-files | awk '$1 == \"syncthing-init.service\" {exit 1;}'")

     

       17
       17
       +
         '';

     

       18
       18
       +
       })

+15 -4

pkgs/applications/misc/tint2/default.nix

···

       1
       1
        
       { lib, stdenv

     

       2
       2
        
       , fetchFromGitLab

     

       3
       3
       +
       , fetchpatch

     

       3
       4
        
       , pkg-config

     

       4
       5
        
       , cmake

     

       5
       6
        
       , gettext

     
···

       24
       25
        
       

     

       25
       26
        
       stdenv.mkDerivation rec {

     

       26
       27
        
         pname = "tint2";

     

       27
       27
       -
         version = "17.0.2";

     

       28
       28
       +
         version = "17.1.3";

     

       28
       29
        
       

     

       29
       30
        
         src = fetchFromGitLab {

     

       30
       30
       -
           owner = "o9000";

     

       31
       31
       +
           owner = "nick87720z";

     

       31
       32
        
           repo = "tint2";

     

       32
       33
        
           rev = version;

     

       33
       33
       -
           sha256 = "sha256-SqpAjclwu3HN07LAZgvXGzjMK6G+nYLDdl90o1+9aog=";

     

       34
       34
       +
           hash = "sha256-9sEe/Gnj+FWLPbWBtfL1YlNNC12j7/KjQ40xdkaFJVQ=";

     

       34
       35
        
         };

     

       35
       36
        
       

     

       37
       37
       +
         patches = [

     

       38
       38
       +
           # Fix crashes with glib >= 2.76

     

       39
       39
       +
           # https://patchespromptly.com/glib2/

     

       40
       40
       +
           # https://gitlab.com/nick87720z/tint2/-/issues/4

     

       41
       41
       +
           (fetchpatch {

     

       42
       42
       +
             url = "https://gitlab.com/nick87720z/tint2/uploads/7de4501a4fa4fffa5ba8bb0fa3d19f78/glib.patch";

     

       43
       43
       +
             hash = "sha256-K547KYlRkVl1s2THi3ZCRuM447EFJwTqUEBjKQnV8Sc=";

     

       44
       44
       +
           })

     

       45
       45
       +
         ];

     

       46
       46
       +
       

     

       36
       47
        
         nativeBuildInputs = [

     

       37
       48
        
           pkg-config

     

       38
       49
        
           cmake

     
···

       72
       83
        
         '';

     

       73
       84
        
       

     

       74
       85
        
         meta = with lib; {

     

       75
       75
       -
           homepage = "https://gitlab.com/o9000/tint2";

     

       86
       86
       +
           homepage = "https://gitlab.com/nick87720z/tint2";

     

       76
       87
        
           description = "Simple panel/taskbar unintrusive and light (memory, cpu, aestetic)";

     

       77
       88
        
           license = licenses.gpl2Only;

     

       78
       89
        
           platforms = platforms.linux;

+2 -2

pkgs/applications/networking/browsers/brave/default.nix

···

       91
       91
        
       

     

       92
       92
        
       stdenv.mkDerivation rec {

     

       93
       93
        
         pname = "brave";

     

       94
       94
       -
         version = "1.52.130";

     

       94
       94
       +
         version = "1.56.9";

     

       95
       95
        
       

     

       96
       96
        
         src = fetchurl {

     

       97
       97
        
           url = "https://github.com/brave/brave-browser/releases/download/v${version}/brave-browser_${version}_amd64.deb";

     

       98
       98
       -
           sha256 = "sha256-TKCAv1gGdAU9KDcrrREPgFjZOPNwTAfLrCh33DAf41U=";

     

       98
       98
       +
           sha256 = "sha256-cw41xUewYB/M6xHZhhL9nX1J9vnNGA9TFJWI/Qwdu/k=";

     

       99
       99
        
         };

     

       100
       100
        
       

     

       101
       101
        
         dontConfigure = true;

+19 -15

pkgs/applications/networking/instant-messengers/teamspeak/client.nix

···

       1
       1
        
       { lib, stdenv, fetchurl, makeWrapper, makeDesktopItem, zlib, glib, libpng, freetype, openssl

     

       2
       2
        
       , xorg, fontconfig, qtbase, qtwebengine, qtwebchannel, qtsvg, qtwebsockets, xkeyboard_config

     

       3
       3
       -
       , alsa-lib, libpulseaudio ? null, libredirect, quazip, which, unzip, llvmPackages_10, writeShellScriptBin

     

       3
       3
       +
       , alsa-lib, libpulseaudio ? null, libredirect, quazip, which, unzip, perl, llvmPackages

     

       4
       4
        
       }:

     

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
        
       

     

       8
       8
       -
         arch = if stdenv.is64bit then "amd64" else "x86";

     

       8
       8
       +
         arch = "amd64";

     

       9
       9
        
       

     

       10
       10
       -
         libDir = if stdenv.is64bit then "lib64" else "lib";

     

       10
       10
       +
         libDir = "lib64";

     

       11
       11
        
       

     

       12
       12
        
         deps =

     

       13
       13
        
           [ zlib glib libpng freetype xorg.libSM xorg.libICE xorg.libXrender openssl

     

       14
       14
        
             xorg.libXrandr xorg.libXfixes xorg.libXcursor xorg.libXinerama

     

       15
       15
        
             xorg.libxcb fontconfig xorg.libXext xorg.libX11 alsa-lib qtbase qtwebengine qtwebchannel qtsvg

     

       16
       16
       -
             qtwebsockets libpulseaudio quazip llvmPackages_10.libcxx llvmPackages_10.libcxxabi # llvmPackages_11 and higher crash https://github.com/NixOS/nixpkgs/issues/161395

     

       16
       16
       +
             qtwebsockets libpulseaudio quazip llvmPackages.libcxx llvmPackages.libcxxabi

     

       17
       17
        
           ];

     

       18
       18
        
       

     

       19
       19
        
         desktopItem = makeDesktopItem {

     
···

       25
       25
        
           genericName = "TeamSpeak";

     

       26
       26
        
           categories = [ "Network" ];

     

       27
       27
        
         };

     

       28
       28
       -
       

     

       29
       29
       -
         fakeLess = writeShellScriptBin "less" "cat";

     

       30
       30
       -
       

     

       31
       28
        
       in

     

       32
       29
        
       

     

       33
       30
        
       stdenv.mkDerivation rec {

     

       34
       31
        
         pname = "teamspeak-client";

     

       35
       32
        
       

     

       36
       36
       -
         version = "3.5.6";

     

       33
       33
       +
         version = "3.6.0";

     

       37
       34
        
       

     

       38
       35
        
         src = fetchurl {

     

       39
       36
        
           url = "https://files.teamspeak-services.com/releases/client/${version}/TeamSpeak3-Client-linux_${arch}-${version}.run";

     

       40
       40
       -
           sha256 = if stdenv.is64bit

     

       41
       41
       -
                       then "sha256:0hjai1bd4mq3g2dlyi0zkn8s4zlgxd38skw77mb78nc4di5gvgpg"

     

       42
       42
       -
                       else "sha256:1y1c65nap91nv9xkvd96fagqbfl56p9n0rl6iac0i29bkysdmija";

     

       37
       37
       +
           hash = "sha256-ZbElnFoQmXdtCR9lb6eOz4dMzSwpfjC1DvG3VbDoSEA=";

     

       43
       38
        
         };

     

       44
       39
        
       

     

       45
       40
        
         # grab the plugin sdk for the desktop icon

     
···

       48
       43
        
           sha256 = "1bywmdj54glzd0kffvr27r84n4dsd0pskkbmh59mllbxvj0qwy7f";

     

       49
       44
        
         };

     

       50
       45
        
       

     

       51
       51
       -
         nativeBuildInputs = [ makeWrapper fakeLess which unzip ];

     

       46
       46
       +
         nativeBuildInputs = [

     

       47
       47
       +
           makeWrapper

     

       48
       48
       +
           which

     

       49
       49
       +
           unzip

     

       50
       50
       +
           perl # Installer script needs `shasum`

     

       51
       51
       +
         ];

     

       52
       52
        
       

     

       53
       53
       +
         # This just runs the installer script. If it gets stuck at something like

     

       54
       54
       +
         # ++ exec

     

       55
       55
       +
         # + PAGER_PATH=

     

       56
       56
       +
         # it's looking for a dependency and didn't find it. Check the script and make sure the dep is in nativeBuildInputs.

     

       53
       57
        
         unpackPhase =

     

       54
       58
        
           ''

     

       55
       55
       -
             echo -e '\ny' | sh -xe $src

     

       59
       59
       +
             echo -e '\ny' | PAGER=cat sh -xe $src

     

       56
       60
        
             cd TeamSpeak*

     

       57
       61
        
           '';

     

       58
       62
        
       

     
···

       110
       114
        
             url = "https://www.teamspeak.com/en/privacy-and-terms/";

     

       111
       115
        
             free = false;

     

       112
       116
        
           };

     

       113
       113
       -
           maintainers = with maintainers; [ lhvwb lukegb ];

     

       114
       114
       -
           platforms = [ "i686-linux" "x86_64-linux" ];

     

       117
       117
       +
           maintainers = with maintainers; [ lhvwb lukegb atemu ];

     

       118
       118
       +
           platforms = [ "x86_64-linux" ];

     

       115
       119
        
         };

     

       116
       120
        
       }

     

       117
       121

+14 -3

pkgs/applications/networking/seaweedfs/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , fetchFromGitHub

     

       3
       3
       +
       , fetchpatch

     

       3
       4
        
       , buildGoModule

     

       4
       5
        
       , testers

     

       5
       6
        
       , seaweedfs

     
···

       7
       8
        
       

     

       8
       9
        
       buildGoModule rec {

     

       9
       10
        
         pname = "seaweedfs";

     

       10
       10
       -
         version = "3.53";

     

       11
       11
       +
         version = "3.54";

     

       11
       12
        
       

     

       12
       13
        
         src = fetchFromGitHub {

     

       13
       14
        
           owner = "seaweedfs";

     

       14
       15
        
           repo = "seaweedfs";

     

       15
       16
        
           rev = version;

     

       16
       16
       -
           hash = "sha256-VfKzptMxT2ra1uVzbL52EWjEGHTxmnh5xZGiQpRivTU=";

     

       17
       17
       +
           hash = "sha256-2E2ANJIKWhUUxxSqk5+QROeoKnp1Akl5Bp+i8pPTkuQ=";

     

       17
       18
        
         };

     

       18
       19
        
       

     

       19
       19
       -
         vendorHash = "sha256-kL6huukrM4YeU7uvj7abXOEAvRhm1Nfp4JODW4BTy0A=";

     

       20
       20
       +
         patches = [

     

       21
       21
       +
           # Fix build on aarch64-darwin

     

       22
       22
       +
           # (remove again when v3.55 is released)

     

       23
       23
       +
           # https://github.com/seaweedfs/seaweedfs/pull/4679

     

       24
       24
       +
           (fetchpatch {

     

       25
       25
       +
             url = "https://github.com/seaweedfs/seaweedfs/commit/1bfc9581e0bc04f394187a0d39f319ad65df5aca.patch";

     

       26
       26
       +
             hash = "sha256-znQFtm8BYAjuvXa+vibawBb+uhnjOL9/o0sXNoXwLk8=";

     

       27
       27
       +
           })

     

       28
       28
       +
         ];

     

       29
       29
       +
       

     

       30
       30
       +
         vendorHash = "sha256-VK7BmApGq+X1oNjcwCSYHcEvVjL87t8fgJXLNQSfy3I=";

     

       20
       31
        
       

     

       21
       32
        
         subPackages = [ "weed" ];

     

       22
       33

+8 -2

pkgs/applications/video/qmplay2/default.nix

···

       4
       4
        
       , alsa-lib

     

       5
       5
        
       , cmake

     

       6
       6
        
       , ffmpeg

     

       7
       7
       +
       , fribidi

     

       7
       8
        
       , game-music-emu

     

       9
       9
       +
       , libXdmcp

     

       8
       10
        
       , libXv

     

       9
       11
        
       , libass

     

       10
       12
        
       , libcddb

     
···

       12
       14
        
       , libpulseaudio

     

       13
       15
        
       , libsidplayfp

     

       14
       16
        
       , libva

     

       17
       17
       +
       , libxcb

     

       15
       18
        
       , pkg-config

     

       16
       19
        
       , qtbase

     

       17
       20
        
       , qttools

     
···

       23
       26
        
       

     

       24
       27
        
       stdenv.mkDerivation (finalAttrs: {

     

       25
       28
        
         pname = "qmplay2";

     

       26
       26
       -
         version = "23.02.05";

     

       29
       29
       +
         version = "23.06.17";

     

       27
       30
        
       

     

       28
       31
        
         src = fetchFromGitHub {

     

       29
       32
        
           owner = "zaps166";

     

       30
       33
        
           repo = "QMPlay2";

     

       31
       34
        
           rev = finalAttrs.version;

     

       32
       32
       -
           sha256 = "sha256-ZDpUgD9qTvjopGFVrwTBSEmrXn+4aKq2zeqoTnXwmI8=";

     

       33
       35
        
           fetchSubmodules = true;

     

       36
       36
       +
           hash = "sha256-f4lIXB0eTyteCJdWFP0XnsnxGWc32CV+HlqpaCjmgOE=";

     

       34
       37
        
         };

     

       35
       38
        
       

     

       36
       39
        
         nativeBuildInputs = [

     
···

       42
       45
        
         buildInputs = [

     

       43
       46
        
           alsa-lib

     

       44
       47
        
           ffmpeg

     

       48
       48
       +
           fribidi

     

       45
       49
        
           game-music-emu

     

       50
       50
       +
           libXdmcp

     

       46
       51
        
           libXv

     

       47
       52
        
           libass

     

       48
       53
        
           libcddb

     
···

       50
       55
        
           libpulseaudio

     

       51
       56
        
           libsidplayfp

     

       52
       57
        
           libva

     

       58
       58
       +
           libxcb

     

       53
       59
        
           qtbase

     

       54
       60
        
           qttools

     

       55
       61
        
           taglib

+10 -4

pkgs/applications/window-managers/sway/osd.nix

···

       4
       4
        
       , pkg-config

     

       5
       5
        
       , wrapGAppsHook

     

       6
       6
        
       , gtk-layer-shell

     

       7
       7
       +
       , libevdev

     

       8
       8
       +
       , libinput

     

       7
       9
        
       , libpulseaudio

     

       10
       10
       +
       , udev

     

       8
       11
        
       }:

     

       9
       12
        
       

     

       10
       13
        
       rustPlatform.buildRustPackage {

     

       11
       14
        
         pname = "swayosd";

     

       12
       12
       -
         version = "unstable-2023-05-09";

     

       15
       15
       +
         version = "unstable-2023-07-18";

     

       13
       16
        
       

     

       14
       17
        
         src = fetchFromGitHub {

     

       15
       18
        
           owner = "ErikReider";

     

       16
       19
        
           repo = "SwayOSD";

     

       17
       17
       -
           rev = "5c2176ae6a01a18fdc2b0f5d5f593737b5765914";

     

       18
       18
       -
           hash = "sha256-rh42J6LWgNPOWYLaIwocU1JtQnA5P1jocN3ywVOfYoc=";

     

       20
       20
       +
           rev = "b14c83889c7860c174276d05dec6554169a681d9";

     

       21
       21
       +
           hash = "sha256-MJuTwEI599Y7q+0u0DMxRYaXsZfpksc2csgnK9Ghp/E=";

     

       19
       22
        
         };

     

       20
       23
        
       

     

       21
       21
       -
         cargoHash = "sha256-ZcgrUcRQTcEYhw2mpJDuYDz3I/u/2Q+O60ajXYRMeow=";

     

       24
       24
       +
         cargoHash = "sha256-pExpzQwuHREhgkj+eZ8drBVsh/B3WiQBBh906O6ymFw=";

     

       22
       25
        
       

     

       23
       26
        
         nativeBuildInputs = [

     

       24
       27
        
           wrapGAppsHook

     
···

       27
       30
        
       

     

       28
       31
        
         buildInputs = [

     

       29
       32
        
           gtk-layer-shell

     

       33
       33
       +
           libevdev

     

       34
       34
       +
           libinput

     

       30
       35
        
           libpulseaudio

     

       36
       36
       +
           udev

     

       31
       37
        
         ];

     

       32
       38
        
       

     

       33
       39
        
         meta = with lib; {

+41

pkgs/development/python-modules/google-cloud-artifact-registry/default.nix

···

       1
       1
       +
       { buildPythonPackage

     

       2
       2
       +
       , fetchPypi

     

       3
       3
       +
       , google-api-core

     

       4
       4
       +
       , grpc-google-iam-v1

     

       5
       5
       +
       , lib

     

       6
       6
       +
       , pytestCheckHook

     

       7
       7
       +
       , pythonOlder

     

       8
       8
       +
       }:

     

       9
       9
       +
       

     

       10
       10
       +
       buildPythonPackage rec {

     

       11
       11
       +
         pname = "google-cloud-artifact-registry";

     

       12
       12
       +
         version = "1.8.2";

     

       13
       13
       +
         format = "setuptools";

     

       14
       14
       +
       

     

       15
       15
       +
         disabled = pythonOlder "3.7";

     

       16
       16
       +
       

     

       17
       17
       +
         src = fetchPypi {

     

       18
       18
       +
           inherit pname version;

     

       19
       19
       +
           hash = "sha256-FuuxwOMV7IB1drn5hzX7p4BwJYQCUsgnZNVR+E6XKhM=";

     

       20
       20
       +
         };

     

       21
       21
       +
       

     

       22
       22
       +
         propagatedBuildInputs = [

     

       23
       23
       +
           google-api-core

     

       24
       24
       +
           grpc-google-iam-v1

     

       25
       25
       +
         ] ++ google-api-core.optional-dependencies.grpc;

     

       26
       26
       +
       

     

       27
       27
       +
         nativeCheckInputs = [ pytestCheckHook ];

     

       28
       28
       +
       

     

       29
       29
       +
         pythonImportsCheck = [

     

       30
       30
       +
           "google.cloud.artifactregistry"

     

       31
       31
       +
           "google.cloud.artifactregistry_v1"

     

       32
       32
       +
           "google.cloud.artifactregistry_v1beta2"

     

       33
       33
       +
         ];

     

       34
       34
       +
       

     

       35
       35
       +
         meta = with lib; {

     

       36
       36
       +
           description = "Google Cloud Artifact Registry API client library";

     

       37
       37
       +
           homepage = "https://github.com/googleapis/google-cloud-python";

     

       38
       38
       +
           license = licenses.asl20;

     

       39
       39
       +
           maintainers = with maintainers; [ samuela ];

     

       40
       40
       +
         };

     

       41
       41
       +
       }

+81

pkgs/development/python-modules/slack-bolt/default.nix

···

       1
       1
       +
       { buildPythonPackage

     

       2
       2
       +
       , chalice

     

       3
       3
       +
       , cherrypy

     

       4
       4
       +
       , django

     

       5
       5
       +
       , falcon

     

       6
       6
       +
       , fastapi

     

       7
       7
       +
       , fetchFromGitHub

     

       8
       8
       +
       , flask

     

       9
       9
       +
       , flask-sockets

     

       10
       10
       +
       , lib

     

       11
       11
       +
       , moto

     

       12
       12
       +
       , numpy

     

       13
       13
       +
       , pyramid

     

       14
       14
       +
       , pytest-asyncio

     

       15
       15
       +
       , pytestCheckHook

     

       16
       16
       +
       , sanic

     

       17
       17
       +
       , sanic-testing

     

       18
       18
       +
       , slack-sdk

     

       19
       19
       +
       , starlette

     

       20
       20
       +
       , tornado

     

       21
       21
       +
       }:

     

       22
       22
       +
       

     

       23
       23
       +
       buildPythonPackage rec {

     

       24
       24
       +
         pname = "slack-bolt";

     

       25
       25
       +
         version = "1.18.0";

     

       26
       26
       +
         format = "setuptools";

     

       27
       27
       +
       

     

       28
       28
       +
         src = fetchFromGitHub {

     

       29
       29
       +
           owner = "slackapi";

     

       30
       30
       +
           repo = "bolt-python";

     

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

     

       32
       32
       +
           hash = "sha256-s9djd/MDNnyNkjkeApY6Fb1mhI6iop8RghaSJdi4eAs=";

     

       33
       33
       +
         };

     

       34
       34
       +
       

     

       35
       35
       +
         propagatedBuildInputs = [ slack-sdk ];

     

       36
       36
       +
       

     

       37
       37
       +
         nativeCheckInputs = [

     

       38
       38
       +
           chalice

     

       39
       39
       +
           cherrypy

     

       40
       40
       +
           django

     

       41
       41
       +
           falcon

     

       42
       42
       +
           fastapi

     

       43
       43
       +
           flask

     

       44
       44
       +
           flask-sockets

     

       45
       45
       +
           moto

     

       46
       46
       +
           pyramid

     

       47
       47
       +
           pytest-asyncio

     

       48
       48
       +
           pytestCheckHook

     

       49
       49
       +
           sanic

     

       50
       50
       +
           sanic-testing

     

       51
       51
       +
           starlette

     

       52
       52
       +
           tornado

     

       53
       53
       +
         ];

     

       54
       54
       +
       

     

       55
       55
       +
         # Work around "Read-only file system: '/homeless-shelter'" errors

     

       56
       56
       +
         preCheck = ''

     

       57
       57
       +
           export HOME="$(mktemp -d)"

     

       58
       58
       +
         '';

     

       59
       59
       +
       

     

       60
       60
       +
         disabledTestPaths = [

     

       61
       61
       +
           # boddle is not packaged as of 2023-07-15

     

       62
       62
       +
           "tests/adapter_tests/bottle/"

     

       63
       63
       +
         ];

     

       64
       64
       +
       

     

       65
       65
       +
         disabledTests = [

     

       66
       66
       +
           # Require network access

     

       67
       67
       +
           "test_events"

     

       68
       68
       +
           "test_interactions"

     

       69
       69
       +
           "test_lazy_listener_calls"

     

       70
       70
       +
           "test_lazy_listeners"

     

       71
       71
       +
         ];

     

       72
       72
       +
       

     

       73
       73
       +
         pythonImportsCheck = [ "slack_bolt" ];

     

       74
       74
       +
       

     

       75
       75
       +
         meta = with lib; {

     

       76
       76
       +
           description = "A framework to build Slack apps using Python";

     

       77
       77
       +
           homepage = "https://github.com/slackapi/bolt-python";

     

       78
       78
       +
           license = licenses.mit;

     

       79
       79
       +
           maintainers = with maintainers; [ samuela ];

     

       80
       80
       +
         };

     

       81
       81
       +
       }

+3 -4

pkgs/development/python-modules/slack-sdk/default.nix

···

       5
       5
        
       , boto3

     

       6
       6
        
       , buildPythonPackage

     

       7
       7
        
       , codecov

     

       8
       8
       -
       , databases

     

       9
       8
        
       , fetchFromGitHub

     

       10
       9
        
       , flake8

     

       11
       10
        
       , flask-sockets

     
···

       21
       20
        
       

     

       22
       21
        
       buildPythonPackage rec {

     

       23
       22
        
         pname = "slack-sdk";

     

       24
       24
       -
         version = "3.20.2";

     

       23
       23
       +
         version = "3.21.3";

     

       25
       24
        
         format = "setuptools";

     

       26
       25
        
       

     

       27
       26
        
         disabled = pythonOlder "3.6";

     
···

       30
       29
        
           owner = "slackapi";

     

       31
       30
        
           repo = "python-slack-sdk";

     

       32
       31
        
           rev = "refs/tags/v${version}";

     

       33
       33
       -
           hash = "sha256-2MPXV+rVXZYMTZe11T8x8GKQmHZwUlkwarCkheVkERo=";

     

       32
       32
       +
           hash = "sha256-begpT/DaDqOi8HZE10FCuIIv18KSU/i5G/Z5DXKUT7Y=";

     

       34
       33
        
         };

     

       35
       34
        
       

     

       36
       35
        
         propagatedBuildInputs = [

     
···

       44
       43
        
       

     

       45
       44
        
         nativeCheckInputs = [

     

       46
       45
        
           codecov

     

       47
       47
       -
           databases

     

       48
       46
        
           flake8

     

       49
       47
        
           flask-sockets

     

       50
       48
        
           moto

     
···

       67
       65
        
           "test_start_raises_an_error_if_rtm_ws_url_is_not_returned"

     

       68
       66
        
           "test_org_installation"

     

       69
       67
        
           "test_interactions"

     

       68
       68
       +
           "test_issue_690_oauth_access"

     

       70
       69
        
         ];

     

       71
       70
        
       

     

       72
       71
        
         pythonImportsCheck = [

+6 -2

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

···

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchPypi

     

       4
       4
        
       , setuptools

     

       5
       5
       +
       , pythonOlder

     

       5
       6
        
       , numpy

     

       6
       7
        
       , lxml

     

       7
       8
        
       }:

     

       8
       9
        
       

     

       9
       10
        
       buildPythonPackage rec {

     

       10
       11
        
         pname = "trimesh";

     

       11
       11
       -
         version = "3.22.4";

     

       12
       12
       +
         version = "3.22.5";

     

       12
       13
        
         format = "pyproject";

     

       13
       14
        
       

     

       15
       15
       +
         disabled = pythonOlder "3.7";

     

       16
       16
       +
       

     

       14
       17
        
         src = fetchPypi {

     

       15
       18
        
           inherit pname version;

     

       16
       16
       -
           hash = "sha256-DFOtanrrc3Jufuu5ybbbc0xJX29CVp2tFOP93QFoJeM=";

     

       19
       19
       +
           hash = "sha256-Lk30HShbVSBeiclfxJUkd7W2HfvLsZiUdYqebLI7otw=";

     

       17
       20
        
         };

     

       18
       21
        
       

     

       19
       22
        
         nativeBuildInputs = [ setuptools ];

     
···

       33
       36
        
         meta = with lib; {

     

       34
       37
        
           description = "Python library for loading and using triangular meshes";

     

       35
       38
        
           homepage = "https://trimsh.org/";

     

       39
       39
       +
           changelog = "https://github.com/mikedh/trimesh/releases/tag/${version}";

     

       36
       40
        
           license = licenses.mit;

     

       37
       41
        
           maintainers = with maintainers; [ gebner ];

     

       38
       42
        
         };

+21 -13

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , stdenv

     

       3
       3
        
       , appdirs

     

       4
       4
       +
       , azure-containerregistry

     

       4
       5
        
       , azure-core

     

       6
       6
       +
       , azure-identity

     

       7
       7
       +
       , azure-storage-blob

     

       5
       8
        
       , bokeh

     

       6
       9
        
       , boto3

     

       7
       10
        
       , buildPythonPackage

     
···

       11
       14
        
       , flask

     

       12
       15
        
       , git

     

       13
       16
        
       , gitpython

     

       17
       17
       +
       , google-cloud-artifact-registry

     

       14
       18
        
       , google-cloud-compute

     

       15
       19
        
       , google-cloud-storage

     

       16
       20
        
       , hypothesis

     
···

       51
       55
        
       

     

       52
       56
        
       buildPythonPackage rec {

     

       53
       57
        
         pname = "wandb";

     

       54
       54
       -
         version = "0.15.3";

     

       58
       58
       +
         version = "0.15.5";

     

       55
       59
        
         format = "setuptools";

     

       56
       60
        
       

     

       57
       61
        
         disabled = pythonOlder "3.6";

     
···

       60
       64
        
           owner = pname;

     

       61
       65
        
           repo = pname;

     

       62
       66
        
           rev = "refs/tags/v${version}";

     

       63
       63
       -
           hash = "sha256-i1Lo6xbkCgRTJwRjk2bXkZ5a/JRUCzFzmEuPQlPvZf4=";

     

       67
       67
       +
           hash = "sha256-etS1NkkskA5Lg/38QIdzCVWgqZpjpT2LwaWF1k7WVXs=";

     

       64
       68
        
         };

     

       65
       69
        
       

     

       66
       70
        
         patches = [

     
···

       94
       98
        
         ];

     

       95
       99
        
       

     

       96
       100
        
         nativeCheckInputs = [

     

       101
       101
       +
           azure-containerregistry

     

       97
       102
        
           azure-core

     

       103
       103
       +
           azure-identity

     

       104
       104
       +
           azure-storage-blob

     

       98
       105
        
           bokeh

     

       99
       106
        
           boto3

     

       100
       107
        
           flask

     

       108
       108
       +
           google-cloud-artifact-registry

     

       101
       109
        
           google-cloud-compute

     

       102
       110
        
           google-cloud-storage

     

       103
       111
        
           hypothesis

     
···

       213
       221
        
           "tests/pytest_tests/system_tests/test_sweep/test_wandb_agent.py"

     

       214
       222
        
           "tests/pytest_tests/system_tests/test_sweep/test_wandb_sweep.py"

     

       215
       223
        
           "tests/pytest_tests/system_tests/test_system_metrics/test_open_metrics.py"

     

       216
       216
       -
           "tests/pytest_tests/system_tests/tests_launch/test_github_reference.py"

     

       217
       217
       -
           "tests/pytest_tests/system_tests/tests_launch/test_job.py"

     

       218
       218
       -
           "tests/pytest_tests/system_tests/tests_launch/test_launch_add.py"

     

       219
       219
       -
           "tests/pytest_tests/system_tests/tests_launch/test_launch_cli.py"

     

       220
       220
       -
           "tests/pytest_tests/system_tests/tests_launch/test_launch_kubernetes.py"

     

       221
       221
       -
           "tests/pytest_tests/system_tests/tests_launch/test_launch_local_container.py"

     

       222
       222
       -
           "tests/pytest_tests/system_tests/tests_launch/test_launch_run.py"

     

       223
       223
       -
           "tests/pytest_tests/system_tests/tests_launch/test_launch_sweep_cli.py"

     

       224
       224
       -
           "tests/pytest_tests/system_tests/tests_launch/test_launch_sweep.py"

     

       225
       225
       -
           "tests/pytest_tests/system_tests/tests_launch/test_launch.py"

     

       226
       226
       -
           "tests/pytest_tests/system_tests/tests_launch/test_wandb_reference.py"

     

       224
       224
       +
           "tests/pytest_tests/system_tests/test_launch/test_github_reference.py"

     

       225
       225
       +
           "tests/pytest_tests/system_tests/test_launch/test_job.py"

     

       226
       226
       +
           "tests/pytest_tests/system_tests/test_launch/test_launch_add.py"

     

       227
       227
       +
           "tests/pytest_tests/system_tests/test_launch/test_launch_cli.py"

     

       228
       228
       +
           "tests/pytest_tests/system_tests/test_launch/test_launch_kubernetes.py"

     

       229
       229
       +
           "tests/pytest_tests/system_tests/test_launch/test_launch_local_container.py"

     

       230
       230
       +
           "tests/pytest_tests/system_tests/test_launch/test_launch_run.py"

     

       231
       231
       +
           "tests/pytest_tests/system_tests/test_launch/test_launch_sweep_cli.py"

     

       232
       232
       +
           "tests/pytest_tests/system_tests/test_launch/test_launch_sweep.py"

     

       233
       233
       +
           "tests/pytest_tests/system_tests/test_launch/test_launch.py"

     

       234
       234
       +
           "tests/pytest_tests/system_tests/test_launch/test_wandb_reference.py"

     

       227
       235
        
       

     

       228
       236
        
           # Tries to access /homeless-shelter

     

       229
       237
        
           "tests/pytest_tests/unit_tests/test_tables.py"

+9 -4

pkgs/development/tools/capnproto-rust/default.nix

···

       6
       6
        
       

     

       7
       7
        
       rustPlatform.buildRustPackage rec {

     

       8
       8
        
         pname = "capnproto-rust";

     

       9
       9
       -
         version = "0.17.1";

     

       9
       9
       +
         version = "0.17.2";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchCrate {

     

       12
       12
        
           crateName = "capnpc";

     

       13
       13
        
           inherit version;

     

       14
       14
       -
           sha256 = "sha256-7RfJUYV3X9w0FALP3pbhmeIqrWLqlgr4oNvPnBc+RY8=";

     

       14
       14
       +
           hash = "sha256-WVjXVLVoTCAtA8a6+zaX4itAaPCWb2c0trtSsxBopO4=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
       -
         cargoHash = "sha256-wmoXdukXWagW61jbFBODnIjlBrV6Q+wgvuFG/TqkvVk=";

     

       17
       17
       +
         cargoHash = "sha256-h9YArxHnY14T8eQCS4JVItjaCjv+2dorcOVBir7r6SY=";

     

       18
       18
       +
       

     

       19
       19
       +
         postInstall = ''

     

       20
       20
       +
           mkdir -p $out/include/capnp

     

       21
       21
       +
           cp rust.capnp $out/include/capnp

     

       22
       22
       +
         '';

     

       18
       23
        
       

     

       19
       24
        
         nativeCheckInputs = [

     

       20
       25
        
           capnproto

     
···

       24
       29
        
           description = "Cap'n Proto codegen plugin for Rust";

     

       25
       30
        
           homepage = "https://github.com/capnproto/capnproto-rust";

     

       26
       31
        
           license = licenses.mit;

     

       27
       27
       -
           maintainers = with maintainers; [ mikroskeem ];

     

       32
       32
       +
           maintainers = with maintainers; [ mikroskeem solson ];

     

       28
       33
        
         };

     

       29
       34
        
       }

+6 -6

pkgs/development/tools/symfony-cli/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "symfony-cli";

     

       5
       5
       -
         version = "5.5.6";

     

       6
       6
       -
         vendorHash = "sha256-AfgDsd4W8wV0GeymD9SLeHtOeFP9qbFy+GTdMxQSkDA=";

     

       5
       5
       +
         version = "5.5.7";

     

       6
       6
       +
         vendorHash = "sha256-OXV/hTSHJvYfe2SiFamkedC01J/DOgd8I60yIpQToos=";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchFromGitHub {

     

       9
       9
        
           owner = "symfony-cli";

     

       10
       10
        
           repo = "symfony-cli";

     

       11
       11
        
           rev = "v${version}";

     

       12
       12
       -
           sha256 = "sha256-lE8RBjBXucL0DJjEnBLbHqOVE6g358rwmaEUqU6QhOw=";

     

       12
       12
       +
           hash = "sha256-LC6QQIVHllBRu8B6XfV8SuTB3O+FmqYr+LQnVmLj2nU=";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
        
         ldflags = [

     
···

       27
       27
        
           $GOPATH/bin/symfony-cli

     

       28
       28
        
         '';

     

       29
       29
        
       

     

       30
       30
       -
         meta = with lib; {

     

       30
       30
       +
         meta = {

     

       31
       31
        
           description = "Symfony CLI";

     

       32
       32
        
           homepage = "https://github.com/symfony-cli/symfony-cli";

     

       33
       33
       -
           license = licenses.agpl3Plus;

     

       34
       34
       -
           maintainers = with maintainers; [ drupol ];

     

       33
       33
       +
           license = lib.licenses.agpl3Plus;

     

       35
       34
        
           mainProgram = "symfony";

     

       35
       35
       +
           maintainers = with lib.maintainers; [ drupol ];

     

       36
       36
        
         };

     

       37
       37
        
       }

+37

pkgs/os-specific/linux/fanout/default.nix

···

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, kernel, kmod }:

     

       2
       2
       +
       

     

       3
       3
       +
       stdenv.mkDerivation rec {

     

       4
       4
       +
         pname = "fanout";

     

       5
       5
       +
         version = "unstable-2022-10-17-${kernel.version}";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchFromGitHub {

     

       8
       8
       +
           owner = "bob-linuxtoys";

     

       9
       9
       +
           repo = "fanout";

     

       10
       10
       +
           rev = "69b1cc69bf425d1a5f83b4e84d41272f1caa0144";

     

       11
       11
       +
           hash = "sha256-Q19c88KDFu0A6MejZgKYei9J2693EjRkKtR9hcRcHa0=";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         preBuild = ''

     

       15
       15
       +
           substituteInPlace Makefile --replace "modules_install" "INSTALL_MOD_PATH=$out modules_install"

     

       16
       16
       +
         '';

     

       17
       17
       +
       

     

       18
       18
       +
         patches = [

     

       19
       19
       +
           ./remove_auto_mknod.patch

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         hardeningDisable = [ "format" "pic" ];

     

       23
       23
       +
       

     

       24
       24
       +
         nativeBuildInputs = [ kmod ] ++ kernel.moduleBuildDependencies;

     

       25
       25
       +
       

     

       26
       26
       +
         makeFlags = kernel.makeFlags ++ [

     

       27
       27
       +
           "KERNELDIR=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build"

     

       28
       28
       +
         ];

     

       29
       29
       +
       

     

       30
       30
       +
         meta = with lib; {

     

       31
       31
       +
           description = "Kernel-based publish-subscribe system";

     

       32
       32
       +
           homepage = "https://github.com/bob-linuxtoys/fanout";

     

       33
       33
       +
           license = licenses.gpl2Only;

     

       34
       34
       +
           maintainers = with maintainers; [ therishidesai ];

     

       35
       35
       +
           platforms = platforms.linux;

     

       36
       36
       +
         };

     

       37
       37
       +
       }

+13

pkgs/os-specific/linux/fanout/remove_auto_mknod.patch

···

       1
       1
       +
       diff --git a/fanout.c b/fanout.c

     

       2
       2
       +
       index f5d2a55..87125f4 100644

     

       3
       3
       +
       --- a/fanout.c

     

       4
       4
       +
       +++ b/fanout.c

     

       5
       5
       +
       @@ -13,7 +13,7 @@

     

       6
       6
       +
        /* Comment out to forgo the creation of /dev entries

     

       7
       7
       +
         * The companion udev rules 'fanout.rules' sets the special file mode

     

       8
       8
       +
         */

     

       9
       9
       +
       -#define DEV_MKNOD

     

       10
       10
       +
       +// #define DEV_MKNOD

     

       11
       11
       +
        

     

       12
       12
       +
        #include <linux/kernel.h>

     

       13
       13
       +
        #include <linux/module.h>

+2 -1

pkgs/servers/mastodon/default.nix

···

       156
       156
        
       

     

       157
       157
        
         passthru = {

     

       158
       158
        
           tests.mastodon = nixosTests.mastodon;

     

       159
       159
       -
           updateScript = callPackage ./update.nix {};

     

       159
       159
       +
           # run with: nix-shell ./maintainers/scripts/update.nix --argstr package mastodon

     

       160
       160
       +
           updateScript = ./update.sh;

     

       160
       161
        
         };

     

       161
       162
        
       

     

       162
       163
        
         meta = with lib; {

-29

pkgs/servers/mastodon/update.nix

···

       1
       1
       -
       { runCommand

     

       2
       2
       -
       , lib

     

       3
       3
       -
       , makeWrapper

     

       4
       4
       -
       , yarn2nix

     

       5
       5
       -
       , bundix

     

       6
       6
       -
       , coreutils

     

       7
       7
       -
       , diffutils

     

       8
       8
       -
       , nix-prefetch-github

     

       9
       9
       -
       , gnused

     

       10
       10
       -
       , jq

     

       11
       11
       -
       }:

     

       12
       12
       -
       let

     

       13
       13
       -
         binPath = lib.makeBinPath [ yarn2nix bundix coreutils diffutils nix-prefetch-github gnused jq ];

     

       14
       14
       -
       in

     

       15
       15
       -
       runCommand "mastodon-update-script"

     

       16
       16
       -
       {

     

       17
       17
       -
         nativeBuildInputs = [ makeWrapper ];

     

       18
       18
       -
       

     

       19
       19
       -
         meta = {

     

       20
       20
       -
           maintainers = with lib.maintainers; [ happy-river ];

     

       21
       21
       -
           description = "Utility to generate Nix expressions for Mastodon's dependencies";

     

       22
       22
       -
           platforms = lib.platforms.unix;

     

       23
       23
       -
         };

     

       24
       24
       -
       } ''

     

       25
       25
       -
         mkdir -p $out/bin

     

       26
       26
       -
         cp ${./update.sh} $out/bin/update.sh

     

       27
       27
       -
         patchShebangs $out/bin/update.sh

     

       28
       28
       -
         wrapProgram $out/bin/update.sh --prefix PATH : ${binPath}

     

       29
       29
       -
       ''

+12 -11

pkgs/servers/mastodon/update.sh

···

       1
       1
       -
       #!/usr/bin/env bash

     

       1
       1
       +
       #!/usr/bin/env nix-shell

     

       2
       2
       +
       #! nix-shell -i bash -p yarn2nix bundix coreutils diffutils nix-prefetch-github gnused jq

     

       2
       3
        
       set -e

     

       3
       4
        
       

     

       4
       5
        
       OWNER=mastodon

     
···

       41
       42
        
           esac

     

       42
       43
        
       done

     

       43
       44
        
       

     

       44
       44
       -
       if [[ -z "$VERSION" || -n "$POSITIONAL" ]]; then

     

       45
       45
       -
           echo "Usage: update.sh [--owner OWNER] [--repo REPO] --ver VERSION [--rev REVISION] [--patches PATCHES]"

     

       46
       46
       -
           echo "OWNER and repo must be paths on github."

     

       47
       47
       -
           echo "If VERSION is not a revision acceptable to 'git checkout', you must provide one in REVISION."

     

       45
       45
       +
       if [[ -n "$POSITIONAL" ]]; then

     

       46
       46
       +
           echo "Usage: update.sh [--owner OWNER] [--repo REPO] [--ver VERSION] [--rev REVISION] [--patches PATCHES]"

     

       47
       47
       +
           echo "OWNER and REPO must be paths on github."

     

       48
       48
       +
           echo "If REVISION is not provided, the latest tag from github.com/mastodon/mastodon is fetched and VERSION is calculated from it."

     

       48
       49
        
           echo "If OWNER and REPO are not provided, it defaults they default to mastodon and mastodon."

     

       49
       50
        
           echo "PATCHES, if provided, should be one or more Nix expressions separated by spaces."

     

       50
       51
        
           exit 1

     

       51
       52
        
       fi

     

       52
       53
        
       

     

       53
       54
        
       if [[ -z "$REVISION" ]]; then

     

       54
       54
       -
           REVISION="$VERSION"

     

       55
       55
       +
           REVISION="$(curl ${GITHUB_TOKEN:+" -u \":$GITHUB_TOKEN\""} -s "https://api.github.com/repos/$OWNER/$REPO/releases" | jq -r  'map(select(.prerelease == false)) | .[0].tag_name')"

     

       56
       56
       +
           VERSION="$(echo "$REVISION" | cut -c2-)"

     

       55
       57
        
       fi

     

       56
       58
        
       

     

       57
       59
        
       rm -f gemset.nix version.nix source.nix

     

       58
       58
       -
       TARGET_DIR="$PWD"

     

       59
       59
       -
       

     

       60
       60
       +
       cd "$(dirname "${BASH_SOURCE[0]}")" || exit 1

     

       60
       61
        
       

     

       61
       62
        
       WORK_DIR=$(mktemp -d)

     

       62
       63
        
       

     
···

       85
       86
        
       # This file was generated by pkgs.mastodon.updateScript.

     

       86
       87
        
       { fetchFromGitHub, applyPatches }: let

     

       87
       88
        
         src = fetchFromGitHub {

     

       88
       88
       -
           owner = "mastodon";

     

       89
       89
       -
           repo = "mastodon";

     

       89
       89
       +
           owner = "$OWNER";

     

       90
       90
       +
           repo = "$REPO";

     

       90
       91
        
           rev = "$REVISION";

     

       91
       92
        
           hash = "$HASH";

     

       92
       93
        
         };

     
···

       99
       100
        
       

     

       100
       101
        
       echo "Creating gemset.nix"

     

       101
       102
        
       bundix --lockfile="$SOURCE_DIR/Gemfile.lock" --gemfile="$SOURCE_DIR/Gemfile"

     

       102
       102
       -
       echo "" >> "$TARGET_DIR/gemset.nix"  # Create trailing newline to please EditorConfig checks

     

       103
       103
       +
       echo "" >> gemset.nix  # Create trailing newline to please EditorConfig checks

+2 -2

pkgs/servers/nosql/apache-jena/binary.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "apache-jena";

     

       5
       5
       -
         version = "4.8.0";

     

       5
       5
       +
         version = "4.9.0";

     

       6
       6
        
         src = fetchurl {

     

       7
       7
        
           url = "mirror://apache/jena/binaries/apache-jena-${version}.tar.gz";

     

       8
       8
       -
           hash = "sha256-kAbhH0E2C1ToxDQgFUqWxvknCeFZbtqFhOmiSJ//ciU=";

     

       8
       8
       +
           hash = "sha256-kUsEdEKwYjyM5G8YKTt90fWzX21hiulRj3W5jK45Keg=";

     

       9
       9
        
         };

     

       10
       10
        
         nativeBuildInputs = [

     

       11
       11
        
           makeWrapper

+18 -4

pkgs/servers/nosql/apache-jena/fuseki-binary.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, java, makeWrapper }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , java

     

       5
       5
       +
       , coreutils

     

       6
       6
       +
       , which

     

       7
       7
       +
       , makeWrapper

     

       8
       8
       +
         # For the test

     

       9
       9
       +
       , pkgs

     

       10
       10
       +
       }:

     

       2
       11
        
       

     

       3
       12
        
       stdenv.mkDerivation rec {

     

       4
       13
        
         pname = "apache-jena-fuseki";

     

       5
       5
       -
         version = "4.8.0";

     

       14
       14
       +
         version = "4.9.0";

     

       6
       15
        
         src = fetchurl {

     

       7
       16
        
           url = "mirror://apache/jena/binaries/apache-jena-fuseki-${version}.tar.gz";

     

       8
       8
       -
           hash = "sha256-rJCY8vG1vfEGGA0gsIqNFXKl75O2Zp4zUIWSDfplpVE=";

     

       17
       17
       +
           hash = "sha256-t25Q0lb+ecR12cDD1p6eZnzLxW0kZpPOFGvo5YK7AlI=";

     

       9
       18
        
         };

     

       10
       19
        
         nativeBuildInputs = [

     

       11
       20
        
           makeWrapper

     
···

       16
       25
        
           ln -s "$out"/{fuseki-backup,fuseki-server,fuseki} "$out/bin"

     

       17
       26
        
           for i in "$out"/bin/*; do

     

       18
       27
        
             wrapProgram "$i" \

     

       19
       19
       -
               --prefix "PATH" : "${java}/bin/" \

     

       28
       28
       +
               --prefix "PATH" : "${java}/bin/:${coreutils}/bin:${which}/bin" \

     

       20
       29
        
               --set-default "FUSEKI_HOME" "$out" \

     

       21
       30
        
               ;

     

       22
       31
        
           done

     

       23
       32
        
         '';

     

       33
       33
       +
         passthru = {

     

       34
       34
       +
           tests = {

     

       35
       35
       +
             basic-test = pkgs.callPackage ./fuseki-test.nix { };

     

       36
       36
       +
           };

     

       37
       37
       +
         };

     

       24
       38
        
         meta = with lib; {

     

       25
       39
        
           description = "SPARQL server";

     

       26
       40
        
           license = licenses.asl20;

+18

pkgs/servers/nosql/apache-jena/fuseki-test.nix

···

       1
       1
       +
       { lib, runCommandNoCC, apache-jena-fuseki, curl }:

     

       2
       2
       +
       runCommandNoCC "fuseki-test-${apache-jena-fuseki.name}"

     

       3
       3
       +
       { nativeBuildInputs = [ curl apache-jena-fuseki ]; } ''

     

       4
       4
       +
         export FUSEKI_BASE="$PWD/fuseki-base"

     

       5
       5
       +
         mkdir -p "$FUSEKI_BASE/db"

     

       6
       6
       +
         FUSEKI_ARGS="--update --loc=$FUSEKI_BASE/db /dataset" fuseki start

     

       7
       7
       +
         fuseki status

     

       8
       8
       +
         for i in $(seq 120); do

     

       9
       9
       +
             if  curl http://127.0.0.1:3030/dataset/data; then

     

       10
       10
       +
                 break;

     

       11
       11
       +
             fi

     

       12
       12
       +
             sleep 1

     

       13
       13
       +
         done

     

       14
       14
       +
         curl -d 'update=insert+data+{+<test://subject>+<test://predicate>+<test://object>+}' http://127.0.0.1:3030/dataset/update > /dev/null

     

       15
       15
       +
         curl http://127.0.0.1:3030/dataset/data | grep -C999 'test://predicate'

     

       16
       16
       +
         curl -d 'query=select+?s+?p+?o+where+{+?s+?p+?o+.+}' http://127.0.0.1:3030/dataset/query | grep -C999 'test://predicate'

     

       17
       17
       +
         touch $out

     

       18
       18
       +
       ''

+1 -4

pkgs/stdenv/adapters.nix

···

       67
       67
        
                   "--disable-shared" # brrr...

     

       68
       68
        
                 ];

     

       69
       69
        
             }));

     

       70
       70
       -
           } // lib.optionalAttrs (stdenv0.hostPlatform.libc == "libc") {

     

       70
       70
       +
           } // lib.optionalAttrs (stdenv0.hostPlatform.libc == "glibc") {

     

       71
       71
        
             extraBuildInputs = (old.extraBuildInputs or []) ++ [

     

       72
       72
        
               pkgs.glibc.static

     

       73
       73
        
             ];

     
···

       121
       121
        
           # Apple does not provide a static version of libSystem or crt0.o

     

       122
       122
        
           # So we can’t build static binaries without extensive hacks.

     

       123
       123
        
           ++ lib.optional (!stdenv.hostPlatform.isDarwin) makeStaticBinaries

     

       124
       124
       -
       

     

       125
       125
       -
           # Glibc doesn’t come with static runtimes by default.

     

       126
       126
       -
           # ++ lib.optional (stdenv.hostPlatform.libc == "glibc") ((lib.flip overrideInStdenv) [ self.glibc.static ])

     

       127
       124
        
         );

     

       128
       125
        
       

     

       129
       126

+1 -1

pkgs/tools/security/metasploit/Gemfile

···

       1
       1
        
       # frozen_string_literal: true

     

       2
       2
        
       source "https://rubygems.org"

     

       3
       3
        
       

     

       4
       4
       -
       gem "metasploit-framework", git: "https://github.com/rapid7/metasploit-framework", ref: "refs/tags/6.3.25"

     

       4
       4
       +
       gem "metasploit-framework", git: "https://github.com/rapid7/metasploit-framework", ref: "refs/tags/6.3.26"

+9 -9

pkgs/tools/security/metasploit/Gemfile.lock

···

       1
       1
        
       GIT

     

       2
       2
        
         remote: https://github.com/rapid7/metasploit-framework

     

       3
       3
       -
         revision: ba44d1810c38a63f46b3c1fb9290de4a384b802d

     

       4
       4
       -
         ref: refs/tags/6.3.25

     

       3
       3
       +
         revision: dd1f90dd6fd267d8430d8e0299ebcfe6a85327cf

     

       4
       4
       +
         ref: refs/tags/6.3.26

     

       5
       5
        
         specs:

     

       6
       6
       -
           metasploit-framework (6.3.25)

     

       6
       6
       +
           metasploit-framework (6.3.26)

     

       7
       7
        
             actionpack (~> 7.0)

     

       8
       8
        
             activerecord (~> 7.0)

     

       9
       9
        
             activesupport (~> 7.0)

     
···

       131
       131
        
           arel-helpers (2.14.0)

     

       132
       132
        
             activerecord (>= 3.1.0, < 8)

     

       133
       133
        
           aws-eventstream (1.2.0)

     

       134
       134
       -
           aws-partitions (1.785.0)

     

       134
       134
       +
           aws-partitions (1.790.0)

     

       135
       135
        
           aws-sdk-core (3.178.0)

     

       136
       136
        
             aws-eventstream (~> 1, >= 1.0.2)

     

       137
       137
        
             aws-partitions (~> 1, >= 1.651.0)

     

       138
       138
        
             aws-sigv4 (~> 1.5)

     

       139
       139
        
             jmespath (~> 1, >= 1.6.1)

     

       140
       140
       -
           aws-sdk-ec2 (1.389.0)

     

       140
       140
       +
           aws-sdk-ec2 (1.392.0)

     

       141
       141
        
             aws-sdk-core (~> 3, >= 3.177.0)

     

       142
       142
        
             aws-sigv4 (~> 1.1)

     

       143
       143
       -
           aws-sdk-iam (1.85.0)

     

       143
       143
       +
           aws-sdk-iam (1.86.0)

     

       144
       144
        
             aws-sdk-core (~> 3, >= 3.177.0)

     

       145
       145
        
             aws-sigv4 (~> 1.1)

     

       146
       146
        
           aws-sdk-kms (1.71.0)

     

       147
       147
        
             aws-sdk-core (~> 3, >= 3.177.0)

     

       148
       148
        
             aws-sigv4 (~> 1.1)

     

       149
       149
       -
           aws-sdk-s3 (1.129.0)

     

       149
       149
       +
           aws-sdk-s3 (1.131.0)

     

       150
       150
        
             aws-sdk-core (~> 3, >= 3.177.0)

     

       151
       151
        
             aws-sdk-kms (~> 1)

     

       152
       152
        
             aws-sigv4 (~> 1.6)

     
···

       212
       212
        
           i18n (1.14.1)

     

       213
       213
        
             concurrent-ruby (~> 1.0)

     

       214
       214
        
           io-console (0.6.0)

     

       215
       215
       -
           irb (1.7.3)

     

       215
       215
       +
           irb (1.7.4)

     

       216
       216
        
             reline (>= 0.3.6)

     

       217
       217
        
           jmespath (1.6.2)

     

       218
       218
        
           jsobfu (0.4.2)

     
···

       258
       258
        
             webrick

     

       259
       259
        
           metasploit_payloads-mettle (1.0.20)

     

       260
       260
        
           method_source (1.0.0)

     

       261
       261
       -
           mini_portile2 (2.8.2)

     

       261
       261
       +
           mini_portile2 (2.8.4)

     

       262
       262
        
           minitest (5.18.1)

     

       263
       263
        
           mqtt (0.6.0)

     

       264
       264
        
           msgpack (1.6.1)

+2 -2

pkgs/tools/security/metasploit/default.nix

···

       15
       15
        
         };

     

       16
       16
        
       in stdenv.mkDerivation rec {

     

       17
       17
        
         pname = "metasploit-framework";

     

       18
       18
       -
         version = "6.3.25";

     

       18
       18
       +
         version = "6.3.26";

     

       19
       19
        
       

     

       20
       20
        
         src = fetchFromGitHub {

     

       21
       21
        
           owner = "rapid7";

     

       22
       22
        
           repo = "metasploit-framework";

     

       23
       23
        
           rev = version;

     

       24
       24
       -
           sha256 = "sha256-ezAlfG9ZDJ1QowwNUCpkHkjxV2qKITE/qftN2sWq6CE=";

     

       24
       24
       +
           sha256 = "sha256-GSf+GE4LeZxmhTskiwWjWf9rc6K4wg357MuK5cbLuMs=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         nativeBuildInputs = [ makeWrapper ];

+15 -15

pkgs/tools/security/metasploit/gemset.nix

···

       104
       104
        
           platforms = [];

     

       105
       105
        
           source = {

     

       106
       106
        
             remotes = ["https://rubygems.org"];

     

       107
       107
       -
             sha256 = "05m0c3h1z0jhaqiciil55fshrjvc725cf1lc0g933pf98vqflb0r";

     

       107
       107
       +
             sha256 = "1mjzb10zyx78hnnz6j4bjv3awpgajfi0nmavrhy9x1qsf7yc9bjd";

     

       108
       108
        
             type = "gem";

     

       109
       109
        
           };

     

       110
       110
       -
           version = "1.785.0";

     

       110
       110
       +
           version = "1.790.0";

     

       111
       111
        
         };

     

       112
       112
        
         aws-sdk-core = {

     

       113
       113
        
           groups = ["default"];

     
···

       124
       124
        
           platforms = [];

     

       125
       125
        
           source = {

     

       126
       126
        
             remotes = ["https://rubygems.org"];

     

       127
       127
       -
             sha256 = "19pfwc0884g9afjh18q76snr9ldnihksmagf36yiqchnvvk956lj";

     

       127
       127
       +
             sha256 = "15vb0gn23xig6alcxh487r0jl5cdxm45b6zihh3wscvfzwqq0n5n";

     

       128
       128
        
             type = "gem";

     

       129
       129
        
           };

     

       130
       130
       -
           version = "1.389.0";

     

       130
       130
       +
           version = "1.392.0";

     

       131
       131
        
         };

     

       132
       132
        
         aws-sdk-iam = {

     

       133
       133
        
           groups = ["default"];

     

       134
       134
        
           platforms = [];

     

       135
       135
        
           source = {

     

       136
       136
        
             remotes = ["https://rubygems.org"];

     

       137
       137
       -
             sha256 = "12hk0ylwjc6jq4qvw08v27ggh9pgfyi1j24jjb0lxb1p21m8ljpi";

     

       137
       137
       +
             sha256 = "02bp18pi29zncznkzkjzlg5j1cl99q41xvw0z5qx9q55mcwaj7i8";

     

       138
       138
        
             type = "gem";

     

       139
       139
        
           };

     

       140
       140
       -
           version = "1.85.0";

     

       140
       140
       +
           version = "1.86.0";

     

       141
       141
        
         };

     

       142
       142
        
         aws-sdk-kms = {

     

       143
       143
        
           groups = ["default"];

     
···

       154
       154
        
           platforms = [];

     

       155
       155
        
           source = {

     

       156
       156
        
             remotes = ["https://rubygems.org"];

     

       157
       157
       -
             sha256 = "06hgrc39ngs8nis2f85z5gg4ihskk9x3xv6vamc4wx927nsymf42";

     

       157
       157
       +
             sha256 = "1855m1v6lh9rji543nvk0fjn98ma0q2978zc4f5y76qsibl7fg6c";

     

       158
       158
        
             type = "gem";

     

       159
       159
        
           };

     

       160
       160
       -
           version = "1.129.0";

     

       160
       160
       +
           version = "1.131.0";

     

       161
       161
        
         };

     

       162
       162
        
         aws-sdk-ssm = {

     

       163
       163
        
           groups = ["default"];

     
···

       534
       534
        
           platforms = [];

     

       535
       535
        
           source = {

     

       536
       536
        
             remotes = ["https://rubygems.org"];

     

       537
       537
       -
             sha256 = "0dhwvflcssva4s7ad4sddr2zra8723l2hm1px2rg63ljnh0bgvr3";

     

       537
       537
       +
             sha256 = "158ca10kj3qqnql5g8f1g2arsnhgdl79mg74manpf8ldkwjjn3n8";

     

       538
       538
        
             type = "gem";

     

       539
       539
        
           };

     

       540
       540
       -
           version = "1.7.3";

     

       540
       540
       +
           version = "1.7.4";

     

       541
       541
        
         };

     

       542
       542
        
         jmespath = {

     

       543
       543
        
           groups = ["default"];

     
···

       634
       634
        
           platforms = [];

     

       635
       635
        
           source = {

     

       636
       636
        
             fetchSubmodules = false;

     

       637
       637
       -
             rev = "ba44d1810c38a63f46b3c1fb9290de4a384b802d";

     

       638
       638
       -
             sha256 = "08g8mb2xlkgvm4zk28cad9bz2j0ychm5038cld89s32rdxy2ac3v";

     

       637
       637
       +
             rev = "dd1f90dd6fd267d8430d8e0299ebcfe6a85327cf";

     

       638
       638
       +
             sha256 = "1jxqrg3fb2nbxkwhvhmql9rnpzsrlc2qn91vhmk9qy8b9qcgw9qr";

     

       639
       639
        
             type = "git";

     

       640
       640
        
             url = "https://github.com/rapid7/metasploit-framework";

     

       641
       641
        
           };

     

       642
       642
       -
           version = "6.3.25";

     

       642
       642
       +
           version = "6.3.26";

     

       643
       643
        
         };

     

       644
       644
        
         metasploit-model = {

     

       645
       645
        
           groups = ["default"];

     
···

       696
       696
        
           platforms = [];

     

       697
       697
        
           source = {

     

       698
       698
        
             remotes = ["https://rubygems.org"];

     

       699
       699
       -
             sha256 = "0z7f38iq37h376n9xbl4gajdrnwzq284c9v1py4imw3gri2d5cj6";

     

       699
       699
       +
             sha256 = "02mj8mpd6ck5gpcnsimx5brzggw5h5mmmpq2djdypfq16wcw82qq";

     

       700
       700
        
             type = "gem";

     

       701
       701
        
           };

     

       702
       702
       -
           version = "2.8.2";

     

       702
       702
       +
           version = "2.8.4";

     

       703
       703
        
         };

     

       704
       704
        
         minitest = {

     

       705
       705
        
           groups = ["default"];

pkgs/top-level/linux-kernels.nix

···

       349
       349
        
       

     

       350
       350
        
           evdi = callPackage ../os-specific/linux/evdi { };

     

       351
       351
        
       

     

       352
       352
       +
           fanout = callPackage ../os-specific/linux/fanout { };

     

       353
       353
       +
       

     

       352
       354
        
           fwts-efi-runtime = callPackage ../os-specific/linux/fwts/module.nix { };

     

       353
       355
        
       

     

       354
       356
        
           gcadapter-oc-kmod = callPackage ../os-specific/linux/gcadapter-oc-kmod { };

pkgs/top-level/python-packages.nix

···

       4281
       4281
        
       

     

       4282
       4282
        
         google-cloud-appengine-logging = callPackage ../development/python-modules/google-cloud-appengine-logging { };

     

       4283
       4283
        
       

     

       4284
       4284
       +
         google-cloud-artifact-registry = callPackage ../development/python-modules/google-cloud-artifact-registry { };

     

       4285
       4285
       +
       

     

       4284
       4286
        
         google-cloud-asset = callPackage ../development/python-modules/google-cloud-asset { };

     

       4285
       4287
        
       

     

       4286
       4288
        
         google-cloud-audit-log = callPackage ../development/python-modules/google-cloud-audit-log { };

     
···

       11588
       11590
        
         };

     

       11589
       11591
        
       

     

       11590
       11592
        
         skytemple-ssb-debugger = callPackage ../development/python-modules/skytemple-ssb-debugger { };

     

       11593
       11593
       +
       

     

       11594
       11594
       +
         slack-bolt = callPackage ../development/python-modules/slack-bolt { };

     

       11591
       11595
        
       

     

       11592
       11596
        
         slack-sdk = callPackage ../development/python-modules/slack-sdk { };

     

       11593
       11597