commit 7984a7dacb059ed70f44474b55f3ba91470c3aed · pyrox.dev/nixpkgs

maintainers/maintainer-list.nix

···

       15923
       15923
        
           github = "kuwii";

     

       15924
       15924
        
           githubId = 10705175;

     

       15925
       15925
        
         };

     

       15926
       15926
       +
         kkharji = {

     

       15927
       15927
       +
           name = "kkharji";

     

       15928
       15928
       +
           email = "kkharji@protonmail.com";

     

       15929
       15929
       +
           github = "kkharji";

     

       15930
       15930
       +
           githubId = 65782666;

     

       15931
       15931
       +
         };

     

       15926
       15932
        
         melias122 = {

     

       15927
       15933
        
           name = "Martin Elias";

     

       15928
       15934
        
           email = "martin+nixpkgs@elias.sx";

nixos/doc/manual/from_md/release-notes/rl-2305.section.xml

···

       46
       46
        
             </listitem>

     

       47
       47
        
             <listitem>

     

       48
       48
        
               <para>

     

       49
       49
       +
                 <link xlink:href="https://gitlab.com/kop316/mmsd">mmsd</link>,

     

       50
       50
       +
                 a lower level daemon that transmits and recieves MMSes.

     

       51
       51
       +
                 Available as

     

       52
       52
       +
                 <link linkend="opt-services.mmsd.enable">services.mmsd</link>.

     

       53
       53
       +
               </para>

     

       54
       54
       +
             </listitem>

     

       55
       55
       +
             <listitem>

     

       56
       56
       +
               <para>

     

       49
       57
        
                 <link xlink:href="https://v2raya.org">v2rayA</link>, a Linux

     

       50
       58
        
                 web GUI client of Project V which supports V2Ray, Xray, SS,

     

       51
       59
        
                 SSR, Trojan and Pingtunnel. Available as

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

···

       20
       20
        
       

     

       21
       21
        
       - [atuin](https://github.com/ellie/atuin), a sync server for shell history. Available as [services.atuin](#opt-services.atuin.enable).

     

       22
       22
        
       

     

       23
       23
       +
       - [mmsd](https://gitlab.com/kop316/mmsd), a lower level daemon that transmits and recieves MMSes. Available as [services.mmsd](#opt-services.mmsd.enable).

     

       24
       24
       +
       

     

       23
       25
        
       - [v2rayA](https://v2raya.org), a Linux web GUI client of Project V which supports V2Ray, Xray, SS, SSR, Trojan and Pingtunnel. Available as [services.v2raya](options.html#opt-services.v2raya.enable).

     

       24
       26
        
       

     

       25
       27
        
       ## Backward Incompatibilities {#sec-release-23.05-incompatibilities}

nixos/modules/module-list.nix

···

       873
       873
        
         ./services/networking/miniupnpd.nix

     

       874
       874
        
         ./services/networking/miredo.nix

     

       875
       875
        
         ./services/networking/mjpg-streamer.nix

     

       876
       876
       +
         ./services/networking/mmsd.nix

     

       877
       877
       +
         ./services/networking/mosquitto.nix

     

       876
       878
        
         ./services/networking/monero.nix

     

       877
       879
        
         ./services/networking/morty.nix

     

       878
       880
        
         ./services/networking/mosquitto.nix

+172 -6

nixos/modules/services/databases/postgresql.nix

···

       146
       146
        
                       Name of the user to ensure.

     

       147
       147
        
                     '';

     

       148
       148
        
                   };

     

       149
       149
       +
       

     

       149
       150
        
                   ensurePermissions = mkOption {

     

       150
       151
        
                     type = types.attrsOf types.str;

     

       151
       152
        
                     default = {};

     
···

       166
       167
        
                         "ALL TABLES IN SCHEMA public" = "ALL PRIVILEGES";

     

       167
       168
        
                       }

     

       168
       169
        
                     '';

     

       170
       170
       +
                   };

     

       171
       171
       +
       

     

       172
       172
       +
                   ensureClauses = mkOption {

     

       173
       173
       +
                     description = lib.mdDoc ''

     

       174
       174
       +
                       An attrset of clauses to grant to the user. Under the hood this uses the

     

       175
       175
       +
                       [ALTER USER syntax](https://www.postgresql.org/docs/current/sql-alteruser.html) for each attrName where

     

       176
       176
       +
                       the attrValue is true in the attrSet:

     

       177
       177
       +
                       `ALTER USER user.name WITH attrName`

     

       178
       178
       +
                     '';

     

       179
       179
       +
                     example = literalExpression ''

     

       180
       180
       +
                       {

     

       181
       181
       +
                         superuser = true;

     

       182
       182
       +
                         createrole = true;

     

       183
       183
       +
                         createdb = true;

     

       184
       184
       +
                       }

     

       185
       185
       +
                     '';

     

       186
       186
       +
                     default = {};

     

       187
       187
       +
                     defaultText = lib.literalMD ''

     

       188
       188
       +
                       The default, `null`, means that the user created will have the default permissions assigned by PostgreSQL. Subsequent server starts will not set or unset the clause, so imperative changes are preserved.

     

       189
       189
       +
                     '';

     

       190
       190
       +
                     type = types.submodule {

     

       191
       191
       +
                       options = let

     

       192
       192
       +
                         defaultText = lib.literalMD ''

     

       193
       193
       +
                           `null`: do not set. For newly created roles, use PostgreSQL's default. For existing roles, do not touch this clause.

     

       194
       194
       +
                         '';

     

       195
       195
       +
                       in {

     

       196
       196
       +
                         superuser = mkOption {

     

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

     

       198
       198
       +
                           description = lib.mdDoc ''

     

       199
       199
       +
                             Grants the user, created by the ensureUser attr, superuser permissions. From the postgres docs:

     

       200
       200
       +
       

     

       201
       201
       +
                             A database superuser bypasses all permission checks,

     

       202
       202
       +
                             except the right to log in. This is a dangerous privilege

     

       203
       203
       +
                             and should not be used carelessly; it is best to do most

     

       204
       204
       +
                             of your work as a role that is not a superuser. To create

     

       205
       205
       +
                             a new database superuser, use CREATE ROLE name SUPERUSER.

     

       206
       206
       +
                             You must do this as a role that is already a superuser.

     

       207
       207
       +
       

     

       208
       208
       +
                             More information on postgres roles can be found [here](https://www.postgresql.org/docs/current/role-attributes.html)

     

       209
       209
       +
                           '';

     

       210
       210
       +
                           default = null;

     

       211
       211
       +
                           inherit defaultText;

     

       212
       212
       +
                         };

     

       213
       213
       +
                         createrole = mkOption {

     

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

     

       215
       215
       +
                           description = lib.mdDoc ''

     

       216
       216
       +
                             Grants the user, created by the ensureUser attr, createrole permissions. From the postgres docs:

     

       217
       217
       +
       

     

       218
       218
       +
                             A role must be explicitly given permission to create more

     

       219
       219
       +
                             roles (except for superusers, since those bypass all

     

       220
       220
       +
                             permission checks). To create such a role, use CREATE

     

       221
       221
       +
                             ROLE name CREATEROLE. A role with CREATEROLE privilege

     

       222
       222
       +
                             can alter and drop other roles, too, as well as grant or

     

       223
       223
       +
                             revoke membership in them. However, to create, alter,

     

       224
       224
       +
                             drop, or change membership of a superuser role, superuser

     

       225
       225
       +
                             status is required; CREATEROLE is insufficient for that.

     

       226
       226
       +
       

     

       227
       227
       +
                             More information on postgres roles can be found [here](https://www.postgresql.org/docs/current/role-attributes.html)

     

       228
       228
       +
                           '';

     

       229
       229
       +
                           default = null;

     

       230
       230
       +
                           inherit defaultText;

     

       231
       231
       +
                         };

     

       232
       232
       +
                         createdb = mkOption {

     

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

     

       234
       234
       +
                           description = lib.mdDoc ''

     

       235
       235
       +
                             Grants the user, created by the ensureUser attr, createdb permissions. From the postgres docs:

     

       236
       236
       +
       

     

       237
       237
       +
                             A role must be explicitly given permission to create

     

       238
       238
       +
                             databases (except for superusers, since those bypass all

     

       239
       239
       +
                             permission checks). To create such a role, use CREATE

     

       240
       240
       +
                             ROLE name CREATEDB.

     

       241
       241
       +
       

     

       242
       242
       +
                             More information on postgres roles can be found [here](https://www.postgresql.org/docs/current/role-attributes.html)

     

       243
       243
       +
                           '';

     

       244
       244
       +
                           default = null;

     

       245
       245
       +
                           inherit defaultText;

     

       246
       246
       +
                         };

     

       247
       247
       +
                         "inherit" = mkOption {

     

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

     

       249
       249
       +
                           description = lib.mdDoc ''

     

       250
       250
       +
                             Grants the user created inherit permissions. From the postgres docs:

     

       251
       251
       +
       

     

       252
       252
       +
                             A role is given permission to inherit the privileges of

     

       253
       253
       +
                             roles it is a member of, by default. However, to create a

     

       254
       254
       +
                             role without the permission, use CREATE ROLE name

     

       255
       255
       +
                             NOINHERIT.

     

       256
       256
       +
       

     

       257
       257
       +
                             More information on postgres roles can be found [here](https://www.postgresql.org/docs/current/role-attributes.html)

     

       258
       258
       +
                           '';

     

       259
       259
       +
                           default = null;

     

       260
       260
       +
                           inherit defaultText;

     

       261
       261
       +
                         };

     

       262
       262
       +
                         login = mkOption {

     

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

     

       264
       264
       +
                           description = lib.mdDoc ''

     

       265
       265
       +
                             Grants the user, created by the ensureUser attr, login permissions. From the postgres docs:

     

       266
       266
       +
       

     

       267
       267
       +
                             Only roles that have the LOGIN attribute can be used as

     

       268
       268
       +
                             the initial role name for a database connection. A role

     

       269
       269
       +
                             with the LOGIN attribute can be considered the same as a

     

       270
       270
       +
                             “database user”. To create a role with login privilege,

     

       271
       271
       +
                             use either:

     

       272
       272
       +
       

     

       273
       273
       +
                             CREATE ROLE name LOGIN; CREATE USER name;

     

       274
       274
       +
       

     

       275
       275
       +
                             (CREATE USER is equivalent to CREATE ROLE except that

     

       276
       276
       +
                             CREATE USER includes LOGIN by default, while CREATE ROLE

     

       277
       277
       +
                             does not.)

     

       278
       278
       +
       

     

       279
       279
       +
                             More information on postgres roles can be found [here](https://www.postgresql.org/docs/current/role-attributes.html)

     

       280
       280
       +
                           '';

     

       281
       281
       +
                           default = null;

     

       282
       282
       +
                           inherit defaultText;

     

       283
       283
       +
                         };

     

       284
       284
       +
                         replication = mkOption {

     

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

     

       286
       286
       +
                           description = lib.mdDoc ''

     

       287
       287
       +
                             Grants the user, created by the ensureUser attr, replication permissions. From the postgres docs:

     

       288
       288
       +
       

     

       289
       289
       +
                             A role must explicitly be given permission to initiate

     

       290
       290
       +
                             streaming replication (except for superusers, since those

     

       291
       291
       +
                             bypass all permission checks). A role used for streaming

     

       292
       292
       +
                             replication must have LOGIN permission as well. To create

     

       293
       293
       +
                             such a role, use CREATE ROLE name REPLICATION LOGIN.

     

       294
       294
       +
       

     

       295
       295
       +
                             More information on postgres roles can be found [here](https://www.postgresql.org/docs/current/role-attributes.html)

     

       296
       296
       +
                           '';

     

       297
       297
       +
                           default = null;

     

       298
       298
       +
                           inherit defaultText;

     

       299
       299
       +
                         };

     

       300
       300
       +
                         bypassrls = mkOption {

     

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

     

       302
       302
       +
                           description = lib.mdDoc ''

     

       303
       303
       +
                             Grants the user, created by the ensureUser attr, replication permissions. From the postgres docs:

     

       304
       304
       +
       

     

       305
       305
       +
                             A role must be explicitly given permission to bypass

     

       306
       306
       +
                             every row-level security (RLS) policy (except for

     

       307
       307
       +
                             superusers, since those bypass all permission checks). To

     

       308
       308
       +
                             create such a role, use CREATE ROLE name BYPASSRLS as a

     

       309
       309
       +
                             superuser.

     

       310
       310
       +
       

     

       311
       311
       +
                             More information on postgres roles can be found [here](https://www.postgresql.org/docs/current/role-attributes.html)

     

       312
       312
       +
                           '';

     

       313
       313
       +
                           default = null;

     

       314
       314
       +
                           inherit defaultText;

     

       315
       315
       +
                         };

     

       316
       316
       +
                       };

     

       317
       317
       +
                     };

     

       169
       318
        
                   };

     

       170
       319
        
                 };

     

       171
       320
        
               });

     
···

       380
       529
        
                     $PSQL -tAc "SELECT 1 FROM pg_database WHERE datname = '${database}'" | grep -q 1 || $PSQL -tAc 'CREATE DATABASE "${database}"'

     

       381
       530
        
                   '') cfg.ensureDatabases}

     

       382
       531
        
                 '' + ''

     

       383
       383
       -
                   ${concatMapStrings (user: ''

     

       384
       384
       -
                     $PSQL -tAc "SELECT 1 FROM pg_roles WHERE rolname='${user.name}'" | grep -q 1 || $PSQL -tAc 'CREATE USER "${user.name}"'

     

       385
       385
       -
                     ${concatStringsSep "\n" (mapAttrsToList (database: permission: ''

     

       386
       386
       -
                       $PSQL -tAc 'GRANT ${permission} ON ${database} TO "${user.name}"'

     

       387
       387
       -
                     '') user.ensurePermissions)}

     

       388
       388
       -
                   '') cfg.ensureUsers}

     

       532
       532
       +
                   ${

     

       533
       533
       +
                     concatMapStrings

     

       534
       534
       +
                     (user:

     

       535
       535
       +
                       let

     

       536
       536
       +
                         userPermissions = concatStringsSep "\n"

     

       537
       537
       +
                           (mapAttrsToList

     

       538
       538
       +
                             (database: permission: ''$PSQL -tAc 'GRANT ${permission} ON ${database} TO "${user.name}"' '')

     

       539
       539
       +
                             user.ensurePermissions

     

       540
       540
       +
                           );

     

       541
       541
       +
       

     

       542
       542
       +
                         filteredClauses = filterAttrs (name: value: value != null) user.ensureClauses;

     

       543
       543
       +
       

     

       544
       544
       +
                         clauseSqlStatements = attrValues (mapAttrs (n: v: if v then n else "no${n}") filteredClauses);

     

       545
       545
       +
       

     

       546
       546
       +
                         userClauses = ''$PSQL -tAc 'ALTER ROLE "${user.name}" ${concatStringsSep " " clauseSqlStatements}' '';

     

       547
       547
       +
                       in ''

     

       548
       548
       +
                         $PSQL -tAc "SELECT 1 FROM pg_roles WHERE rolname='${user.name}'" | grep -q 1 || $PSQL -tAc 'CREATE USER "${user.name}"'

     

       549
       549
       +
                         ${userPermissions}

     

       550
       550
       +
                         ${userClauses}

     

       551
       551
       +
                       ''

     

       552
       552
       +
                     )

     

       553
       553
       +
                     cfg.ensureUsers

     

       554
       554
       +
                   }

     

       389
       555
        
                 '';

     

       390
       556
        
       

     

       391
       557
        
               serviceConfig = mkMerge [

+38

nixos/modules/services/networking/mmsd.nix

···

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

     

       2
       2
       +
       with lib;

     

       3
       3
       +
       let

     

       4
       4
       +
         cfg = config.services.mmsd;

     

       5
       5
       +
         dbusServiceFile = pkgs.writeTextDir "share/dbus-1/services/org.ofono.mms.service" ''

     

       6
       6
       +
           [D-BUS Service]

     

       7
       7
       +
           Name=org.ofono.mms

     

       8
       8
       +
           SystemdService=dbus-org.ofono.mms.service

     

       9
       9
       +
       

     

       10
       10
       +
           # Exec= is still required despite SystemdService= being used:

     

       11
       11
       +
           # https://github.com/freedesktop/dbus/blob/ef55a3db0d8f17848f8a579092fb05900cc076f5/test/data/systemd-activation/com.example.SystemdActivatable1.service

     

       12
       12
       +
           Exec=${pkgs.coreutils}/bin/false mmsd

     

       13
       13
       +
         '';

     

       14
       14
       +
       in

     

       15
       15
       +
       {

     

       16
       16
       +
         options.services.mmsd = {

     

       17
       17
       +
           enable = mkEnableOption (mdDoc "Multimedia Messaging Service Daemon");

     

       18
       18
       +
           extraArgs = mkOption {

     

       19
       19
       +
             type = with types; listOf str;

     

       20
       20
       +
             description = mdDoc "Extra arguments passed to `mmsd-tng`";

     

       21
       21
       +
             default = [];

     

       22
       22
       +
             example = ["--debug"];

     

       23
       23
       +
           };

     

       24
       24
       +
         };

     

       25
       25
       +
         config = mkIf cfg.enable {

     

       26
       26
       +
           services.dbus.packages = [ dbusServiceFile ];

     

       27
       27
       +
           systemd.user.services.mmsd = {

     

       28
       28
       +
             after = [ "ModemManager.service" ];

     

       29
       29
       +
             aliases = [ "dbus-org.ofono.mms.service" ];

     

       30
       30
       +
             serviceConfig = {

     

       31
       31
       +
               Type = "dbus";

     

       32
       32
       +
               ExecStart = "${pkgs.mmsd-tng}/bin/mmsdtng " + escapeShellArgs cfg.extraArgs;

     

       33
       33
       +
               BusName = "org.ofono.mms";

     

       34
       34
       +
               Restart = "on-failure";

     

       35
       35
       +
             };

     

       36
       36
       +
           };

     

       37
       37
       +
         };

     

       38
       38
       +
       }

+91 -2

nixos/tests/postgresql.nix

···

       130
       130
        
           '';

     

       131
       131
        
       

     

       132
       132
        
         };

     

       133
       133
       +
       

     

       134
       134
       +
         mk-ensure-clauses-test = postgresql-name: postgresql-package: makeTest {

     

       135
       135
       +
           name = postgresql-name;

     

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

     

       137
       137
       +
             maintainers = [ zagy ];

     

       138
       138
       +
           };

     

       139
       139
       +
       

     

       140
       140
       +
           machine = {...}:

     

       141
       141
       +
             {

     

       142
       142
       +
               services.postgresql = {

     

       143
       143
       +
                 enable = true;

     

       144
       144
       +
                 package = postgresql-package;

     

       145
       145
       +
                 ensureUsers = [

     

       146
       146
       +
                   {

     

       147
       147
       +
                     name = "all-clauses";

     

       148
       148
       +
                     ensureClauses = {

     

       149
       149
       +
                       superuser = true;

     

       150
       150
       +
                       createdb = true;

     

       151
       151
       +
                       createrole = true;

     

       152
       152
       +
                       "inherit" = true;

     

       153
       153
       +
                       login = true;

     

       154
       154
       +
                       replication = true;

     

       155
       155
       +
                       bypassrls = true;

     

       156
       156
       +
                     };

     

       157
       157
       +
                   }

     

       158
       158
       +
                   {

     

       159
       159
       +
                     name = "default-clauses";

     

       160
       160
       +
                   }

     

       161
       161
       +
                 ];

     

       162
       162
       +
               };

     

       163
       163
       +
             };

     

       164
       164
       +
       

     

       165
       165
       +
           testScript = let

     

       166
       166
       +
             getClausesQuery = user: pkgs.lib.concatStringsSep " "

     

       167
       167
       +
               [

     

       168
       168
       +
                 "SELECT row_to_json(row)"

     

       169
       169
       +
                 "FROM ("

     

       170
       170
       +
                 "SELECT"

     

       171
       171
       +
                   "rolsuper,"

     

       172
       172
       +
                   "rolinherit,"

     

       173
       173
       +
                   "rolcreaterole,"

     

       174
       174
       +
                   "rolcreatedb,"

     

       175
       175
       +
                   "rolcanlogin,"

     

       176
       176
       +
                   "rolreplication,"

     

       177
       177
       +
                   "rolbypassrls"

     

       178
       178
       +
                 "FROM pg_roles"

     

       179
       179
       +
                 "WHERE rolname = '${user}'"

     

       180
       180
       +
                 ") row;"

     

       181
       181
       +
               ];

     

       182
       182
       +
           in ''

     

       183
       183
       +
             import json

     

       184
       184
       +
             machine.start()

     

       185
       185
       +
             machine.wait_for_unit("postgresql")

     

       186
       186
       +
       

     

       187
       187
       +
             with subtest("All user permissions are set according to the ensureClauses attr"):

     

       188
       188
       +
                 clauses = json.loads(

     

       189
       189
       +
                   machine.succeed(

     

       190
       190
       +
                       "sudo -u postgres psql -tc \"${getClausesQuery "all-clauses"}\""

     

       191
       191
       +
                   )

     

       192
       192
       +
                 )

     

       193
       193
       +
                 print(clauses)

     

       194
       194
       +
                 assert clauses['rolsuper'], 'expected user with clauses to have superuser clause'

     

       195
       195
       +
                 assert clauses['rolinherit'], 'expected user with clauses to have inherit clause'

     

       196
       196
       +
                 assert clauses['rolcreaterole'], 'expected user with clauses to have create role clause'

     

       197
       197
       +
                 assert clauses['rolcreatedb'], 'expected user with clauses to have create db clause'

     

       198
       198
       +
                 assert clauses['rolcanlogin'], 'expected user with clauses to have login clause'

     

       199
       199
       +
                 assert clauses['rolreplication'], 'expected user with clauses to have replication clause'

     

       200
       200
       +
                 assert clauses['rolbypassrls'], 'expected user with clauses to have bypassrls clause'

     

       201
       201
       +
       

     

       202
       202
       +
             with subtest("All user permissions default when ensureClauses is not provided"):

     

       203
       203
       +
                 clauses = json.loads(

     

       204
       204
       +
                   machine.succeed(

     

       205
       205
       +
                       "sudo -u postgres psql -tc \"${getClausesQuery "default-clauses"}\""

     

       206
       206
       +
                   )

     

       207
       207
       +
                 )

     

       208
       208
       +
                 assert not clauses['rolsuper'], 'expected user with no clauses set to have default superuser clause'

     

       209
       209
       +
                 assert clauses['rolinherit'], 'expected user with no clauses set to have default inherit clause'

     

       210
       210
       +
                 assert not clauses['rolcreaterole'], 'expected user with no clauses set to have default create role clause'

     

       211
       211
       +
                 assert not clauses['rolcreatedb'], 'expected user with no clauses set to have default create db clause'

     

       212
       212
       +
                 assert clauses['rolcanlogin'], 'expected user with no clauses set to have default login clause'

     

       213
       213
       +
                 assert not clauses['rolreplication'], 'expected user with no clauses set to have default replication clause'

     

       214
       214
       +
                 assert not clauses['rolbypassrls'], 'expected user with no clauses set to have default bypassrls clause'

     

       215
       215
       +
       

     

       216
       216
       +
             machine.shutdown()

     

       217
       217
       +
           '';

     

       218
       218
       +
         };

     

       133
       219
        
       in

     

       134
       134
       -
         (mapAttrs' (name: package: { inherit name; value=make-postgresql-test name package false;}) postgresql-versions) // {

     

       220
       220
       +
         concatMapAttrs (name: package: {

     

       221
       221
       +
           ${name} = make-postgresql-test name package false;

     

       222
       222
       +
           ${name + "-clauses"} = mk-ensure-clauses-test name package;

     

       223
       223
       +
         }) postgresql-versions

     

       224
       224
       +
         // {

     

       135
       225
        
           postgresql_11-backup-all = make-postgresql-test "postgresql_11-backup-all" postgresql-versions.postgresql_11 true;

     

       136
       226
        
         }

     

       137
       137
       -

pkgs/applications/blockchains/erigon/default.nix

···

       29
       29
        
           "cmd/rlpdump"

     

       30
       30
        
         ];

     

       31
       31
        
       

     

       32
       32
       +
         passthru.updateScript = ./update.sh;

     

       33
       33
       +
       

     

       32
       34
        
         meta = with lib; {

     

       33
       35
        
           homepage = "https://github.com/ledgerwatch/erigon/";

     

       34
       36
        
           description = "Ethereum node implementation focused on scalability and modularity";

+2 -2

pkgs/applications/emulators/citra/update.sh

···

       27
       27
        
           OLD_NIGHTLY_VERSION="$(getLocalVersion "citra-nightly")"

     

       28
       28
        
           OLD_NIGHTLY_HASH="$(getLocalHash "citra-nightly")"

     

       29
       29
        
       

     

       30
       30
       -
           NEW_NIGHTLY_VERSION="$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} \

     

       30
       30
       +
           NEW_NIGHTLY_VERSION="$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} \

     

       31
       31
        
               "https://api.github.com/repos/citra-emu/citra-nightly/releases?per_page=1" | jq -r '.[0].name' | cut -d"-" -f2 | cut -d" " -f2)"

     

       32
       32
        
       

     

       33
       33
        
           if [[ "${OLD_NIGHTLY_VERSION}" = "${NEW_NIGHTLY_VERSION}" ]]; then

     
···

       52
       52
        
           OLD_CANARY_VERSION="$(getLocalVersion "citra-canary")"

     

       53
       53
        
           OLD_CANARY_HASH="$(getLocalHash "citra-canary")"

     

       54
       54
        
       

     

       55
       55
       -
           NEW_CANARY_VERSION="$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} \

     

       55
       55
       +
           NEW_CANARY_VERSION="$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} \

     

       56
       56
        
               "https://api.github.com/repos/citra-emu/citra-canary/releases?per_page=1" | jq -r '.[0].name' | cut -d"-" -f2 | cut -d" " -f1)"

     

       57
       57
        
       

     

       58
       58
        
           if [[ "${OLD_CANARY_VERSION}" = "${NEW_CANARY_VERSION}" ]]; then

+4 -4

pkgs/applications/emulators/yuzu/update.sh

···

       21
       21
        
           oldHash="$(nix eval --raw -f "./default.nix" "$attribute".src.drvAttrs.outputHash)"

     

       22
       22
        
       

     

       23
       23
        
           if [[ "$branch" = "mainline" ]]; then

     

       24
       24
       -
               newVersion="$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} "https://api.github.com/repos/yuzu-emu/yuzu-mainline/releases?per_page=1" \

     

       24
       24
       +
               newVersion="$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} "https://api.github.com/repos/yuzu-emu/yuzu-mainline/releases?per_page=1" \

     

       25
       25
        
                   | jq -r '.[0].name' | cut -d" " -f2)"

     

       26
       26
        
           elif [[ "$branch" = "early-access" ]]; then

     

       27
       27
       -
               newVersion="$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} "https://api.github.com/repos/pineappleEA/pineapple-src/releases?per_page=2" \

     

       27
       27
       +
               newVersion="$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} "https://api.github.com/repos/pineappleEA/pineapple-src/releases?per_page=2" \

     

       28
       28
        
                   | jq -r '.[].tag_name' | grep '^EA-[0-9]*' | head -n1 | cut -d"-" -f2 | cut -d" " -f1)"

     

       29
       29
        
           fi

     

       30
       30
        
       

     
···

       50
       50
        
       

     

       51
       51
        
       updateCompatibilityList() {

     

       52
       52
        
           local latestRevision oldUrl newUrl oldHash newHash oldDate newDate

     

       53
       53
       -
           latestRevision="$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} "https://api.github.com/repos/flathub/org.yuzu_emu.yuzu/commits/master" | jq -r '.sha')"

     

       53
       53
       +
           latestRevision="$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} "https://api.github.com/repos/flathub/org.yuzu_emu.yuzu/commits/master" | jq -r '.sha')"

     

       54
       54
        
       

     

       55
       55
        
           oldUrl="$(sed -n '/yuzu-compat-list/,/url/p' "$DEFAULT_NIX" | tail -n1 | cut -d'"' -f2)"

     

       56
       56
        
           newUrl="https://raw.githubusercontent.com/flathub/org.yuzu_emu.yuzu/${latestRevision}/compatibility_list.json"

     

       57
       57
        
       

     

       58
       58
        
           oldDate="$(sed -n '/last updated.*/p' "$DEFAULT_NIX" | rev | cut -d' ' -f1 | rev)"

     

       59
       59
       -
           newDate="$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} "https://api.github.com/repos/flathub/org.yuzu_emu.yuzu/commits/${latestRevision}" \

     

       59
       59
       +
           newDate="$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} "https://api.github.com/repos/flathub/org.yuzu_emu.yuzu/commits/${latestRevision}" \

     

       60
       60
        
               | jq -r '.commit.committer.date' | cut -d'T' -f1)"

     

       61
       61
        
       

     

       62
       62
        
           oldHash="$(sed -n '/yuzu-compat-list/,/sha256/p' "$DEFAULT_NIX" | tail -n1 | cut -d'"' -f2)"

+20 -13

pkgs/applications/misc/yambar/default.nix

···

       2
       2
        
       , stdenv

     

       3
       3
        
       , fetchFromGitea

     

       4
       4
        
       , alsa-lib

     

       5
       5
       +
       , bison

     

       5
       6
        
       , fcft

     

       7
       7
       +
       , flex

     

       6
       8
        
       , json_c

     

       7
       9
        
       , libmpdclient

     

       8
       10
        
       , libxcb

     

       9
       11
        
       , libyaml

     

       10
       12
        
       , meson

     

       11
       13
        
       , ninja

     

       14
       14
       +
       , pipewire

     

       12
       15
        
       , pixman

     

       13
       16
        
       , pkg-config

     

       17
       17
       +
       , pulseaudio

     

       14
       18
        
       , scdoc

     

       15
       19
        
       , tllist

     

       16
       20
        
       , udev

     
···

       26
       30
        
       }:

     

       27
       31
        
       

     

       28
       32
        
       let

     

       29
       29
       -
         # Courtesy of sternenseemann and FRidh

     

       30
       30
       -
         mesonFeatureFlag = feature: flag:

     

       31
       31
       -
           "-D${feature}=${if flag then "enabled" else "disabled"}";

     

       33
       33
       +
         inherit (lib) mesonEnable;

     

       32
       34
        
       in

     

       33
       33
       -
       stdenv.mkDerivation rec {

     

       35
       35
       +
       assert (x11Support || waylandSupport);

     

       36
       36
       +
       stdenv.mkDerivation (finalAttrs: {

     

       34
       37
        
         pname = "yambar";

     

       35
       35
       -
         version = "1.8.0";

     

       38
       38
       +
         version = "1.9.0";

     

       36
       39
        
       

     

       37
       40
        
         src = fetchFromGitea {

     

       38
       41
        
           domain = "codeberg.org";

     

       39
       42
        
           owner = "dnkl";

     

       40
       43
        
           repo = "yambar";

     

       41
       41
       -
           rev = version;

     

       42
       42
       -
           hash = "sha256-zXhIXT3JrVSllnYheDU2KK3NE2VYa+xuKufIXjdMFjU=";

     

       44
       44
       +
           rev = finalAttrs.version;

     

       45
       45
       +
           hash = "sha256-0bgRnZYLGWJ9PE62i04hPBcgzWyd30DK7AUuejSgta4=";

     

       43
       46
        
         };

     

       44
       47
        
       

     

       45
       48
        
         nativeBuildInputs = [

     

       46
       46
       -
           pkg-config

     

       49
       49
       +
           bison

     

       50
       50
       +
           flex

     

       47
       51
        
           meson

     

       48
       52
        
           ninja

     

       53
       53
       +
           pkg-config

     

       49
       54
        
           scdoc

     

       50
       55
        
           wayland-scanner

     

       51
       56
        
         ];

     
···

       56
       61
        
           json_c

     

       57
       62
        
           libmpdclient

     

       58
       63
        
           libyaml

     

       64
       64
       +
           pipewire

     

       59
       65
        
           pixman

     

       66
       66
       +
           pulseaudio

     

       60
       67
        
           tllist

     

       61
       68
        
           udev

     

       62
       69
        
         ] ++ lib.optionals (waylandSupport) [

     
···

       72
       79
        
         mesonBuildType = "release";

     

       73
       80
        
       

     

       74
       81
        
         mesonFlags = [

     

       75
       75
       -
           (mesonFeatureFlag "backend-x11" x11Support)

     

       76
       76
       -
           (mesonFeatureFlag "backend-wayland" waylandSupport)

     

       82
       82
       +
           (mesonEnable "backend-x11" x11Support)

     

       83
       83
       +
           (mesonEnable "backend-wayland" waylandSupport)

     

       77
       84
        
         ];

     

       78
       85
        
       

     

       79
       86
        
         meta = with lib; {

     

       80
       87
        
           homepage = "https://codeberg.org/dnkl/yambar";

     

       81
       81
       -
           changelog = "https://codeberg.org/dnkl/yambar/releases/tag/${version}";

     

       88
       88
       +
           changelog = "https://codeberg.org/dnkl/yambar/releases/tag/${finalAttrs.version}";

     

       82
       89
        
           description = "Modular status panel for X11 and Wayland";

     

       83
       90
        
           longDescription = ''

     

       84
       91
        
             yambar is a lightweight and configurable status panel (bar, for short) for

     
···

       107
       114
        
           '';

     

       108
       115
        
           license = licenses.mit;

     

       109
       116
        
           maintainers = with maintainers; [ AndersonTorres ];

     

       110
       110
       -
           platforms = with platforms; unix;

     

       117
       117
       +
           platforms = platforms.linux;

     

       111
       118
        
         };

     

       112
       112
       -
       }

     

       119
       119
       +
       })

+2 -2

pkgs/applications/networking/cluster/argo-rollouts/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "argo-rollouts";

     

       5
       5
       -
         version = "1.3.1";

     

       5
       5
       +
         version = "1.3.2";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "argoproj";

     

       9
       9
        
           repo = "argo-rollouts";

     

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

     

       11
       11
       -
           sha256 = "sha256-qgOhiJdaxauHIoPsMfcdxwrKiv8QD/tFksCbk13Zpiw=";

     

       11
       11
       +
           sha256 = "sha256-hsUpZrtgjP6FaVhw0ijDTlvfz9Ok+A4nyAwi2VNxvEg=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         vendorSha256 = "sha256-gm96rQdQJGsIcxVgEI7sI7BvEETU/+HsQ6PnDjFXb/0=";

+3 -3

pkgs/applications/networking/cluster/cmctl/update.sh

···

       7
       7
        
       CMCTL_PATH="$( cd -- "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )"

     

       8
       8
        
       

     

       9
       9
        
       OLD_VERSION="$(nix-instantiate --eval -E "with import $NIXPKGS_PATH {}; cmctl.version or (builtins.parseDrvName cmctl.name).version" | tr -d '"')"

     

       10
       10
       -
       LATEST_TAG="$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} "https://api.github.com/repos/cert-manager/cert-manager/releases" | jq '.[].tag_name' --raw-output | sed '/-/d' | sort --version-sort -r | head -n 1)"

     

       10
       10
       +
       LATEST_TAG="$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} "https://api.github.com/repos/cert-manager/cert-manager/releases" | jq '.[].tag_name' --raw-output | sed '/-/d' | sort --version-sort -r | head -n 1)"

     

       11
       11
        
       LATEST_VERSION="${LATEST_TAG:1}"

     

       12
       12
        
       

     

       13
       13
        
       if [ ! "$OLD_VERSION" = "$LATEST_VERSION" ]; then

     

       14
       14
        
           SHA256=$(nix-prefetch-url --quiet --unpack https://github.com/cert-manager/cert-manager/archive/refs/tags/${LATEST_TAG}.tar.gz)

     

       15
       15
       -
           TAG_SHA=$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""}  "https://api.github.com/repos/cert-manager/cert-manager/git/ref/tags/${LATEST_TAG}" | jq -r '.object.sha')

     

       16
       16
       -
           TAG_COMMIT_SHA=$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} "https://api.github.com/repos/cert-manager/cert-manager/git/tags/${TAG_SHA}" | jq '.object.sha' --raw-output)

     

       15
       15
       +
           TAG_SHA=$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"}  "https://api.github.com/repos/cert-manager/cert-manager/git/ref/tags/${LATEST_TAG}" | jq -r '.object.sha')

     

       16
       16
       +
           TAG_COMMIT_SHA=$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} "https://api.github.com/repos/cert-manager/cert-manager/git/tags/${TAG_SHA}" | jq '.object.sha' --raw-output)

     

       17
       17
        
       

     

       18
       18
        
           setKV () {

     

       19
       19
        
               sed -i "s|$1 = \".*\"|$1 = \"${2:-}\"|" "${CMCTL_PATH}/default.nix"

+2 -2

pkgs/applications/networking/cluster/crc/update.sh

···

       13
       13
        
       cd ${NIXPKGS_CRC_FOLDER}

     

       14
       14
        
       

     

       15
       15
        
       LATEST_TAG_RAWFILE=${WORKDIR}/latest_tag.json

     

       16
       16
       -
       curl --silent ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} \

     

       16
       16
       +
       curl --silent ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} \

     

       17
       17
        
           https://api.github.com/repos/code-ready/crc/releases >${LATEST_TAG_RAWFILE}

     

       18
       18
        
       

     

       19
       19
        
       LATEST_TAG_NAME=$(jq 'map(.tag_name)' ${LATEST_TAG_RAWFILE} |

     
···

       21
       21
        
       

     

       22
       22
        
       CRC_VERSION=$(echo ${LATEST_TAG_NAME} | sed 's/^v//')

     

       23
       23
        
       

     

       24
       24
       -
       CRC_COMMIT=$(curl --silent ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} \

     

       24
       24
       +
       CRC_COMMIT=$(curl --silent ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} \

     

       25
       25
        
           https://api.github.com/repos/code-ready/crc/tags |

     

       26
       26
        
           jq -r "map(select(.name == \"${LATEST_TAG_NAME}\")) | .[0] | .commit.sha")

     

       27
       27

+2 -2

pkgs/applications/networking/cluster/k3s/update.sh

···

       11
       11
        
       cd ${NIXPKGS_K3S_PATH}

     

       12
       12
        
       

     

       13
       13
        
       LATEST_TAG_RAWFILE=${WORKDIR}/latest_tag.json

     

       14
       14
       -
       curl --silent ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} \

     

       14
       14
       +
       curl --silent ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} \

     

       15
       15
        
           https://api.github.com/repos/k3s-io/k3s/releases > ${LATEST_TAG_RAWFILE}

     

       16
       16
        
       

     

       17
       17
        
       LATEST_TAG_NAME=$(jq 'map(.tag_name)' ${LATEST_TAG_RAWFILE} | \

     
···

       19
       19
        
       

     

       20
       20
        
       K3S_VERSION=$(echo ${LATEST_TAG_NAME} | sed 's/^v//')

     

       21
       21
        
       

     

       22
       22
       -
       K3S_COMMIT=$(curl --silent ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} \

     

       22
       22
       +
       K3S_COMMIT=$(curl --silent ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} \

     

       23
       23
        
           https://api.github.com/repos/k3s-io/k3s/tags \

     

       24
       24
        
           | jq -r "map(select(.name == \"${LATEST_TAG_NAME}\")) | .[0] | .commit.sha")

     

       25
       25

+2 -2

pkgs/applications/networking/cluster/kubergrunt/default.nix

···

       2
       2
        
       

     

       3
       3
        
       buildGoModule rec {

     

       4
       4
        
         pname = "kubergrunt";

     

       5
       5
       -
         version = "0.9.3";

     

       5
       5
       +
         version = "0.10.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "gruntwork-io";

     

       9
       9
        
           repo = "kubergrunt";

     

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

     

       11
       11
       -
           sha256 = "sha256-nbpRdAkctLiG/hP6vhfEimplAzzj70d5nnaFcJ1NykY=";

     

       11
       11
       +
           sha256 = "sha256-HJZrE0fHlyOTQF9EqdrtQNmaHlrMA2RwNg4P7B2lYI0=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         vendorSha256 = "sha256-9hWX6INN5HWXyeFQRjkqr+BsGv56lInVYacvT6Imahw=";

+3 -3

pkgs/applications/virtualization/pods/default.nix

···

       17
       17
        
       

     

       18
       18
        
       stdenv.mkDerivation rec {

     

       19
       19
        
         pname = "pods";

     

       20
       20
       -
         version = "1.0.0-beta.9";

     

       20
       20
       +
         version = "1.0.0-rc.2";

     

       21
       21
        
       

     

       22
       22
        
         src = fetchFromGitHub {

     

       23
       23
        
           owner = "marhkb";

     

       24
       24
        
           repo = pname;

     

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

     

       26
       26
       -
           sha256 = "sha256-cW6n00EPe7eFuqT2Vk27Ax0fxjz9kWSlYuS2oIj0mXY=";

     

       26
       26
       +
           sha256 = "sha256-fyhp0Qumku2EO+5+AaWBLp6xG9mpfNuxhr/PoLca1a4=";

     

       27
       27
        
         };

     

       28
       28
        
       

     

       29
       29
        
         cargoDeps = rustPlatform.fetchCargoTarball {

     

       30
       30
        
           inherit src;

     

       31
       31
        
           name = "${pname}-${version}";

     

       32
       32
       -
           sha256 = "sha256-y0njqlzAx1M7iC8bZrKlKACSiYnSRaHOrcAxs3bFF30=";

     

       32
       32
       +
           sha256 = "sha256-v6ZGDd1mAxb55JIijJHlthrTta2PwZMRa8MqVnJMyzQ=";

     

       33
       33
        
         };

     

       34
       34
        
       

     

       35
       35
        
         nativeBuildInputs = [

+1 -1

pkgs/development/interpreters/clojure/babashka.nix

···

       30
       30
        
           set -euo pipefail

     

       31
       31
        
       

     

       32
       32
        
           readonly latest_version="$(curl \

     

       33
       33
       -
             ''${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} \

     

       33
       33
       +
             ''${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} \

     

       34
       34
        
             -s "https://api.github.com/repos/babashka/babashka/releases/latest" \

     

       35
       35
        
             | jq -r '.tag_name')"

     

       36
       36

+1 -1

pkgs/development/interpreters/clojure/default.nix

···

       64
       64
        
       

     

       65
       65
        
           # `jq -r '.[0].name'` results in `v0.0`

     

       66
       66
        
           readonly latest_version="$(curl \

     

       67
       67
       -
             ''${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} \

     

       67
       67
       +
             ''${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} \

     

       68
       68
        
             -s "https://api.github.com/repos/clojure/brew-install/tags" \

     

       69
       69
        
             | jq -r '.[1].name')"

     

       70
       70

+30

pkgs/development/libraries/git2-cpp/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , cmake

     

       5
       5
       +
       }:

     

       6
       6
       +
       

     

       7
       7
       +
       stdenv.mkDerivation (finalAttrs: {

     

       8
       8
       +
         pname = "git2-cpp";

     

       9
       9
       +
         version = "0.1.1";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchFromGitHub {

     

       12
       12
       +
           owner = "ken-matsui";

     

       13
       13
       +
           repo = "git2-cpp";

     

       14
       14
       +
           rev = finalAttrs.version;

     

       15
       15
       +
           hash = "sha256-2jKSQW6dUCIKtl33paSTuZdYAaYdFnILx/Gxv/ghFiI=";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         nativeBuildInputs = [

     

       19
       19
       +
           cmake

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         meta = with lib; {

     

       23
       23
       +
           homepage = "https://github.com/ken-matsui/git2-cpp";

     

       24
       24
       +
           description = "libgit2 bindings for C++";

     

       25
       25
       +
           license = licenses.mit;

     

       26
       26
       +
           maintainers = with maintainers; [ ken-matsui ];

     

       27
       27
       +
           platforms = platforms.unix;

     

       28
       28
       +
         };

     

       29
       29
       +
       })

     

       30
       30
       +
       # TODO [ ken-matsui ]: tests

+2 -2

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

···

       8
       8
        
       

     

       9
       9
        
       buildPythonPackage rec {

     

       10
       10
        
         pname = "dnfile";

     

       11
       11
       -
         version = "0.12.0";

     

       11
       11
       +
         version = "0.13.0";

     

       12
       12
        
         format = "setuptools";

     

       13
       13
        
       

     

       14
       14
        
         disabled = pythonOlder "3.7";

     
···

       17
       17
        
           owner = "malwarefrank";

     

       18
       18
        
           repo = pname;

     

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

     

       20
       20
       -
           hash = "sha256-r3DupEyMEXOFeSDo9k0LmGM/TGMbbpVW7zCoUA4oG8Y=";

     

       20
       20
       +
           hash = "sha256-TH30gEoxXkaDac6hJsGQFWzwDeqzdZ19HK8i/3Dlh8k=";

     

       21
       21
        
           fetchSubmodules = true;

     

       22
       22
        
         };

     

       23
       23

+3 -7

pkgs/development/python-modules/dockerfile-parse/default.nix

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchPypi

     

       4
       4
       -
       , six

     

       5
       4
        
       , pytestCheckHook

     

       6
       5
        
       , pythonOlder

     

       7
       6
        
       }:

     

       8
       7
        
       

     

       9
       8
        
       buildPythonPackage rec {

     

       10
       9
        
         pname = "dockerfile-parse";

     

       11
       11
       -
         version = "1.2.0";

     

       10
       10
       +
         version = "2.0.0";

     

       12
       11
        
         format = "setuptools";

     

       13
       12
        
       

     

       14
       13
        
         disabled = pythonOlder "3.7";

     

       15
       14
        
       

     

       16
       15
        
         src = fetchPypi {

     

       17
       16
        
           inherit pname version;

     

       18
       18
       -
           hash = "sha256-B+Ze7DE5eOh32oGYVYcLOuR/P6yUpAqWW57eEEhNrMU=";

     

       17
       17
       +
           hash = "sha256-If59UQZC8rYamZ1Fw9l0X5UOEf5rokl1Vbj2N4K3jkU=";

     

       19
       18
        
         };

     

       20
       19
        
       

     

       21
       21
       -
         propagatedBuildInputs = [

     

       22
       22
       -
           six

     

       23
       23
       -
         ];

     

       24
       24
       -
       

     

       25
       20
        
         checkInputs = [

     

       26
       21
        
           pytestCheckHook

     

       27
       22
        
         ];

     
···

       38
       33
        
         meta = with lib; {

     

       39
       34
        
           description = "Library for parsing Dockerfile files";

     

       40
       35
        
           homepage = "https://github.com/DBuildService/dockerfile-parse";

     

       36
       36
       +
           changelog = "https://github.com/containerbuildsystem/dockerfile-parse/releases/tag/${version}";

     

       41
       37
        
           license = licenses.bsd3;

     

       42
       38
        
           maintainers = with maintainers; [ leenaars ];

     

       43
       39
        
         };

+2 -2

pkgs/development/python-modules/faraday-plugins/default.nix

···

       17
       17
        
       

     

       18
       18
        
       buildPythonPackage rec {

     

       19
       19
        
         pname = "faraday-plugins";

     

       20
       20
       -
         version = "1.8.1";

     

       20
       20
       +
         version = "1.9.0";

     

       21
       21
        
         format = "setuptools";

     

       22
       22
        
       

     

       23
       23
        
         disabled = pythonOlder "3.7";

     
···

       26
       26
        
           owner = "infobyte";

     

       27
       27
        
           repo = "faraday_plugins";

     

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

     

       29
       29
       -
           hash = "sha256-UnOIYYmOeBX22jQ4MkDxQKtSlxv+H/KOC83BZ39JA1E=";

     

       29
       29
       +
           hash = "sha256-ZWPImBqBpiz3y4OpDZLCfL3Oe/J+qP1Hduas3p0unCg=";

     

       30
       30
        
         };

     

       31
       31
        
       

     

       32
       32
        
         postPatch = ''

+2 -2

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

···

       9
       9
        
       

     

       10
       10
        
       buildPythonPackage rec {

     

       11
       11
        
         pname = "identify";

     

       12
       12
       -
         version = "2.5.9";

     

       12
       12
       +
         version = "2.5.10";

     

       13
       13
        
         format = "setuptools";

     

       14
       14
        
       

     

       15
       15
        
         disabled = pythonOlder "3.7";

     
···

       18
       18
        
           owner = "pre-commit";

     

       19
       19
        
           repo = pname;

     

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

     

       21
       21
       -
           sha256 = "sha256-5ISxzOTTlA1EcBO5N6YtBEah0SRehGeVIONj30zOKk0=";

     

       21
       21
       +
           sha256 = "sha256-4/p2m2A+0RDxQZHAJFSqk4x49bMWQo4R3aDOu3jI6FQ=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         checkInputs = [

+4 -3

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

···

       8
       8
        
       

     

       9
       9
        
       buildPythonPackage rec {

     

       10
       10
        
         pname = "jaconv";

     

       11
       11
       -
         version = "0.3";

     

       11
       11
       +
         version = "0.3.1";

     

       12
       12
        
         format = "setuptools";

     

       13
       13
        
       

     

       14
       14
       -
         disabled = pythonOlder "3.6";

     

       14
       14
       +
         disabled = pythonOlder "3.7";

     

       15
       15
        
       

     

       16
       16
        
         src = fetchFromGitHub {

     

       17
       17
        
           owner = "ikegami-yukino";

     

       18
       18
        
           repo = pname;

     

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

     

       20
       20
       -
           sha256 = "rityHi1JWWlV7+sAxNrlbcmfHmORZWrMZqXTRlsclhQ=";

     

       20
       20
       +
           hash = "sha256-uzGHvklFHVoNloZauczgITeHQIgYQAfI9cjLWgG/vyI=";

     

       21
       21
        
         };

     

       22
       22
        
       

     

       23
       23
        
         checkInputs = [

     
···

       32
       32
        
         meta = with lib; {

     

       33
       33
        
           description = "Python Japanese character interconverter for Hiragana, Katakana, Hankaku and Zenkaku";

     

       34
       34
        
           homepage = "https://github.com/ikegami-yukino/jaconv";

     

       35
       35
       +
           changelog = "https://github.com/ikegami-yukino/jaconv/blob/v${version}/CHANGES.rst";

     

       35
       36
        
           license = licenses.mit;

     

       36
       37
        
           maintainers = with maintainers; [ fab ];

     

       37
       38
        
         };

+2 -2

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

···

       20
       20
        
       

     

       21
       21
        
       buildPythonPackage rec {

     

       22
       22
        
         pname = "pytenable";

     

       23
       23
       -
         version = "1.4.10";

     

       23
       23
       +
         version = "1.4.11";

     

       24
       24
        
         format = "setuptools";

     

       25
       25
        
       

     

       26
       26
        
         disabled = pythonOlder "3.7";

     
···

       29
       29
        
           owner = "tenable";

     

       30
       30
        
           repo = "pyTenable";

     

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

     

       32
       32
       -
           hash = "sha256-BNPfoKXDLUckj/yg1Gz806CS5CyjWvc/Hy/NwnuWfo0=";

     

       32
       32
       +
           hash = "sha256-GSEMjgG8Q+gzHQWRbXr/qiGP6U6ydPxu0JsD56mRNWU=";

     

       33
       33
        
         };

     

       34
       34
        
       

     

       35
       35
        
         propagatedBuildInputs = [

+2 -2

pkgs/development/tools/coder/default.nix

···

       5
       5
        
       }:

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "coder";

     

       8
       8
       -
         version = "0.13.2";

     

       8
       8
       +
         version = "0.13.3";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = pname;

     

       12
       12
        
           repo = pname;

     

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

     

       14
       14
       -
           hash = "sha256-iuNTp+28tOggK3fgsa7yHmqXKz/zW/o47e5UKNppNWs=";

     

       14
       14
       +
           hash = "sha256-26RvDJ890MclDB4rtYQ7CcB3NQRXC7sI2cXd689Eq6E=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         # integration tests require network access

+45

pkgs/development/tools/package-project-cmake/default.nix

···

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenvNoCC

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       stdenvNoCC.mkDerivation (finalAttrs: {

     

       7
       7
       +
         pname = "package-project-cmake";

     

       8
       8
       +
         version = "1.10.0";

     

       9
       9
       +
       

     

       10
       10
       +
         src = fetchFromGitHub {

     

       11
       11
       +
           owner = "TheLartians";

     

       12
       12
       +
           repo = "PackageProject.cmake";

     

       13
       13
       +
           rev = "v${finalAttrs.version}";

     

       14
       14
       +
           hash = "sha256-tDjWknwqN8NLx6GX16WOn0JUDAyaGU9HA7fTsHNLx9s=";

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         dontConfigure = true;

     

       18
       18
       +
         dontBuild = true;

     

       19
       19
       +
       

     

       20
       20
       +
         installPhase = ''

     

       21
       21
       +
           runHook preInstall

     

       22
       22
       +
       

     

       23
       23
       +
           mkdir -p $out/share/{,doc/}package-project-cmake

     

       24
       24
       +
           install -Dm644 CMakeLists.txt $out/share/package-project-cmake/

     

       25
       25
       +
           install -Dm644 README.md $out/share/doc/package-project-cmake/

     

       26
       26
       +
       

     

       27
       27
       +
           runHook postInstall

     

       28
       28
       +
         '';

     

       29
       29
       +
       

     

       30
       30
       +
         meta = with lib; {

     

       31
       31
       +
           homepage = "https://github.com/TheLartians/PackageProject.cmake";

     

       32
       32
       +
           description = "A CMake script for packaging C/C++ projects";

     

       33
       33
       +
           longDescription = ''

     

       34
       34
       +
             Help other developers use your project. A CMake script for packaging

     

       35
       35
       +
             C/C++ projects for simple project installation while employing

     

       36
       36
       +
             best-practices for maximum compatibility. Creating installable

     

       37
       37
       +
             CMake scripts always requires a large amount of boilerplate code

     

       38
       38
       +
             to get things working. This small script should simplify the CMake

     

       39
       39
       +
             packaging process into a single, easy-to-use command.

     

       40
       40
       +
           '';

     

       41
       41
       +
           license = licenses.mit;

     

       42
       42
       +
           maintainers = with maintainers; [ ken-matsui ];

     

       43
       43
       +
           platforms = platforms.all;

     

       44
       44
       +
         };

     

       45
       45
       +
       })

+5 -7

pkgs/development/tools/ruff/default.nix

···

       2
       2
        
       , rustPlatform

     

       3
       3
        
       , fetchFromGitHub

     

       4
       4
        
       , stdenv

     

       5
       5
       -
       , CoreServices

     

       6
       6
       -
       , Security

     

       5
       5
       +
       , darwin

     

       7
       6
        
       }:

     

       8
       7
        
       

     

       9
       8
        
       rustPlatform.buildRustPackage rec {

     

       10
       9
        
         pname = "ruff";

     

       11
       11
       -
         version = "0.0.183";

     

       10
       10
       +
         version = "0.0.185";

     

       12
       11
        
       

     

       13
       12
        
         src = fetchFromGitHub {

     

       14
       13
        
           owner = "charliermarsh";

     

       15
       14
        
           repo = pname;

     

       16
       15
        
           rev = "v${version}";

     

       17
       17
       -
           sha256 = "sha256-xZSPRSqtf62BSfNw3eJEvsxqGBpy/v5DKWz6mipjsAY=";

     

       16
       16
       +
           sha256 = "sha256-L2NaBvSFy+x8mLxy7r0EQUKT4FE5JHaDkVjGiJ7HzTw=";

     

       18
       17
        
         };

     

       19
       18
        
       

     

       20
       20
       -
         cargoSha256 = "sha256-s7IQtfcRvcLgvzep0Ya6i7+OfFlQwFNG67SQe5D0/Ec=";

     

       19
       19
       +
         cargoSha256 = "sha256-/L9xgSG9ydGbjth6tBkqnuIAu7UqP+0IAX8izW1ZAkg=";

     

       21
       20
        
       

     

       22
       21
        
         buildInputs = lib.optionals stdenv.isDarwin [

     

       23
       23
       -
           CoreServices

     

       24
       24
       -
           Security

     

       22
       22
       +
           darwin.apple_sdk.frameworks.CoreServices

     

       25
       23
        
         ];

     

       26
       24
        
       

     

       27
       25
        
         meta = with lib; {

+20

pkgs/development/tools/rust/cargo-chef/default.nix

···

       1
       1
       +
       { lib, rustPlatform, fetchCrate }:

     

       2
       2
       +
       

     

       3
       3
       +
       rustPlatform.buildRustPackage rec {

     

       4
       4
       +
         pname = "cargo-chef";

     

       5
       5
       +
         version = "0.1.50";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchCrate {

     

       8
       8
       +
           inherit pname version;

     

       9
       9
       +
           sha256 = "sha256-d467uk4UCtAKcpFYODxIhRrYoIOHzxhoaJVMA9ErRAw=";

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         cargoSha256 = "sha256-5xj4/uxuMhlqY1ncrMU1IFWdVB4ZjHVXg0ZbRXDvIak=";

     

       13
       13
       +
       

     

       14
       14
       +
         meta = with lib; {

     

       15
       15
       +
           description = "A cargo-subcommand to speed up Rust Docker builds using Docker layer caching";

     

       16
       16
       +
           homepage = "https://github.com/LukeMathWalker/cargo-chef";

     

       17
       17
       +
           license = licenses.mit;

     

       18
       18
       +
           maintainers = with maintainers; [ kkharji ];

     

       19
       19
       +
         };

     

       20
       20
       +
       }

+7 -2

pkgs/games/BeatSaberModManager/default.nix

···

       7
       7
        
         buildDotnetModule,

     

       8
       8
        
         fetchFromGitHub,

     

       9
       9
        
       

     

       10
       10
       +
         dotnetCorePackages,

     

       11
       11
       +
       

     

       10
       12
        
         libX11,

     

       11
       13
        
         libICE,

     

       12
       14
        
         libSM,

     
···

       15
       17
        
       

     

       16
       18
        
       buildDotnetModule rec {

     

       17
       19
        
         pname = "BeatSaberModManager";

     

       18
       18
       -
         version = "0.0.2";

     

       20
       20
       +
         version = "0.0.4";

     

       19
       21
        
       

     

       20
       22
        
         src = fetchFromGitHub {

     

       21
       23
        
           owner = "affederaffe";

     

       22
       24
        
           repo = pname;

     

       23
       25
        
           rev = "v${version}";

     

       24
       24
       -
           sha256 = "sha256-6+9pWr8jJzs430Ai2ddh/2DK3C2bQA1e1+BNDrKhyzY=";

     

       26
       26
       +
           sha256 = "sha256-XeyOWg4Wa4hiorLPnbnBrLSjnxheAGGMPTqBleulDGw=";

     

       25
       27
        
           fetchSubmodules = true; # It vendors BSIPA-Linux

     

       26
       28
        
         };

     

       27
       29
        
       

     
···

       35
       37
        
             runtimeIdentifier = dotnet-sdk.passthru.systemToDotnetRid targetPlatform.system;

     

       36
       38
        
           })

     

       37
       39
        
         ];

     

       40
       40
       +
       

     

       41
       41
       +
         dotnet-sdk = dotnetCorePackages.sdk_7_0;

     

       42
       42
       +
         dotnet-runtime = dotnetCorePackages.runtime_7_0;

     

       38
       43
        
       

     

       39
       44
        
         nugetDeps = ./deps.nix;

     

       40
       45

+80 -32

pkgs/games/BeatSaberModManager/deps.nix

···

       2
       2
        
       # Please dont edit it manually, your changes might get overwritten!

     

       3
       3
        
       

     

       4
       4
        
       { fetchNuGet }: [

     

       5
       5
       -
         (fetchNuGet { pname = "Avalonia"; version = "0.10.16"; sha256 = "1197xyswinazahjd8mhfsrjszhcv4mdj48c56bmdlcsf6zbpravz"; })

     

       5
       5
       +
         (fetchNuGet { pname = "Avalonia"; version = "11.0.0-preview4"; sha256 = "0s2ijp8fbny04c62gy8acg4n769hzj1pl9jml35bqrzk4m29jxs2"; })

     

       6
       6
        
         (fetchNuGet { pname = "Avalonia.Angle.Windows.Natives"; version = "2.1.0.2020091801"; sha256 = "04jm83cz7vkhhr6n2c9hya2k8i2462xbf6np4bidk55as0jdq43a"; })

     

       7
       7
       -
         (fetchNuGet { pname = "Avalonia.Controls.DataGrid"; version = "0.10.16"; sha256 = "1xlg7r9r77fc9bcjw3rnnknncny7mcnkin6nwhg0sig4ab6givd2"; })

     

       8
       8
       -
         (fetchNuGet { pname = "Avalonia.Desktop"; version = "0.10.16"; sha256 = "09fg9j411kq0012wvix1bxiybif3pm1if624mwg4ng7w2z97dfl3"; })

     

       9
       9
       -
         (fetchNuGet { pname = "Avalonia.FreeDesktop"; version = "0.10.16"; sha256 = "1rxcbsbszgyb77gxp4zvg9k1cxw40vbm1z04dn5dqp4bfam9gnnh"; })

     

       10
       10
       -
         (fetchNuGet { pname = "Avalonia.Markup.Xaml.Loader"; version = "0.10.16"; sha256 = "10p93y3zr8aq8malahdllknk28afr0p2n7fz1c7hbhbkdpfjz01a"; })

     

       11
       11
       -
         (fetchNuGet { pname = "Avalonia.Native"; version = "0.10.16"; sha256 = "1m6cgql12rkzxxzvyxd1d0f5z2k4myby6d90li5p3nhblswx6jpk"; })

     

       12
       12
       -
         (fetchNuGet { pname = "Avalonia.ReactiveUI"; version = "0.10.16"; sha256 = "1cp1i07v1pkbff2qm046r1g517lw14q3vrli6f2k0i6aw7naay80"; })

     

       13
       13
       -
         (fetchNuGet { pname = "Avalonia.Remote.Protocol"; version = "0.10.16"; sha256 = "00iv96n2q2qg34zgqzcaja39396fbk8fj373d7zld46c64kf8g4h"; })

     

       14
       14
       -
         (fetchNuGet { pname = "Avalonia.Skia"; version = "0.10.16"; sha256 = "1rla042nc9mc36qnpipszrf0sffwi5d83cr9dmihpa015bby42pz"; })

     

       15
       15
       -
         (fetchNuGet { pname = "Avalonia.Win32"; version = "0.10.16"; sha256 = "171jv4hdi2r0wgmrjv8ajnjmwrf9j2d0g4ffyhhmmjnaclckgzgv"; })

     

       16
       16
       -
         (fetchNuGet { pname = "Avalonia.X11"; version = "0.10.16"; sha256 = "0yr8vkn59phlgcjkhzyygn2i3ghzhvd64sy84qyxxxyfm376cyxr"; })

     

       17
       17
       -
         (fetchNuGet { pname = "DryIoc.dll"; version = "5.1.0"; sha256 = "0vim3xmaajnvhwz01028lizjl2j0y2r2cbiwz0ga7n903pncrahw"; })

     

       18
       18
       -
         (fetchNuGet { pname = "DynamicData"; version = "7.9.4"; sha256 = "0mfmlsdd48dpwiphqhq8gsix2528mc6anp7rakd6vyzmig60f520"; })

     

       19
       19
       -
         (fetchNuGet { pname = "HarfBuzzSharp"; version = "2.8.2-preview.178"; sha256 = "1p5nwzl7jpypsd6df7hgcf47r977anjlyv21wacmalsj6lvdgnvn"; })

     

       20
       20
       -
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Linux"; version = "2.8.2-preview.178"; sha256 = "1402ylkxbgcnagcarqlfvg4gppy2pqs3bmin4n5mphva1g7bqb2p"; })

     

       21
       21
       -
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.macOS"; version = "2.8.2-preview.178"; sha256 = "0p8miaclnbfpacc1jaqxwfg0yfx9byagi4j4k91d9621vd19i8b2"; })

     

       22
       22
       -
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.WebAssembly"; version = "2.8.2-preview.178"; sha256 = "1n9jay9sji04xly6n8bzz4591fgy8i65p21a8mv5ip9lsyj1c320"; })

     

       23
       23
       -
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Win32"; version = "2.8.2-preview.178"; sha256 = "1r5syii96wv8q558cvsqw3lr10cdw6677lyiy82p6i3if51v3mr7"; })

     

       7
       7
       +
         (fetchNuGet { pname = "Avalonia.Controls.ColorPicker"; version = "11.0.0-preview4"; sha256 = "0dbbigfg5qqqgi16fglsqphg63ihl3hhpfw9f85ypvb5dfjimnq0"; })

     

       8
       8
       +
         (fetchNuGet { pname = "Avalonia.Controls.DataGrid"; version = "11.0.0-preview4"; sha256 = "10c1w7slmlkn1sjyk2y8awzlkd9rr35zpvwnvsv0i235zbqc3a07"; })

     

       9
       9
       +
         (fetchNuGet { pname = "Avalonia.Desktop"; version = "11.0.0-preview4"; sha256 = "1ccnfi429hah9qsl6qimkhlz6j29zjjpm77di14wnlr8x3nh19z0"; })

     

       10
       10
       +
         (fetchNuGet { pname = "Avalonia.Diagnostics"; version = "11.0.0-preview4"; sha256 = "1x8d46p9wxwrfhn4xcgx64x5y9dw08a7v54w8ms9ba58zr01bm74"; })

     

       11
       11
       +
         (fetchNuGet { pname = "Avalonia.FreeDesktop"; version = "11.0.0-preview4"; sha256 = "1ivrh736xxn3j1b64ni0wy7ydp22sbl2yv5kdircxknhb7bhpigd"; })

     

       12
       12
       +
         (fetchNuGet { pname = "Avalonia.Markup.Xaml.Loader"; version = "11.0.0-preview4"; sha256 = "16p0va19f83ccq493vxa8rvdgy71jsgijymb078bagk5nsm2alzs"; })

     

       13
       13
       +
         (fetchNuGet { pname = "Avalonia.Native"; version = "11.0.0-preview4"; sha256 = "0ia7zx7chgchh4piqp400cdpj14jndh313yh2z9nspqxq30xll46"; })

     

       14
       14
       +
         (fetchNuGet { pname = "Avalonia.ReactiveUI"; version = "11.0.0-preview4"; sha256 = "0qrv6ff3lgsqa57q5nrsmfzfp3w2x6d536xi3hq18616zjv7k1x4"; })

     

       15
       15
       +
         (fetchNuGet { pname = "Avalonia.Remote.Protocol"; version = "11.0.0-preview4"; sha256 = "1g8j7ll3q9k7v0j54j42dy1mkzkgs9rlyia0gjg3b7z5ilk0rbiz"; })

     

       16
       16
       +
         (fetchNuGet { pname = "Avalonia.Skia"; version = "11.0.0-preview4"; sha256 = "011flxwy9rnjlvwb1nvn9qlj0nfsr3f4gmvlzkg7abhwh7hzv3vi"; })

     

       17
       17
       +
         (fetchNuGet { pname = "Avalonia.Themes.Fluent"; version = "11.0.0-preview4"; sha256 = "07lkj6z4fy41i6fbnrzkb22z63czspcnfp5lz25qkvys37vkmhdm"; })

     

       18
       18
       +
         (fetchNuGet { pname = "Avalonia.Themes.Simple"; version = "11.0.0-preview4"; sha256 = "02cn71h91fxvw9knni2dxlhpf9ihdkq3r0mylvr8z7r493saiqkm"; })

     

       19
       19
       +
         (fetchNuGet { pname = "Avalonia.Win32"; version = "11.0.0-preview4"; sha256 = "1fqj7jv22ki9pim55hav8qfr01vhjkzdp5rdi1p22xxmgrxws5ws"; })

     

       20
       20
       +
         (fetchNuGet { pname = "Avalonia.X11"; version = "11.0.0-preview4"; sha256 = "0lmw94qp4y05xzxx6flzgsv4cw6mckcn8ig6mm8hdqpqqsiihc1n"; })

     

       21
       21
       +
         (fetchNuGet { pname = "DynamicData"; version = "7.9.5"; sha256 = "1m9qx8g6na5ka6kd9vhg8gjmxrnkzb6v5cl5yqp1kdjsw4rcwy6x"; })

     

       22
       22
       +
         (fetchNuGet { pname = "HarfBuzzSharp"; version = "2.8.2.1-preview.108"; sha256 = "0xs4px4fy5b6glc77rqswzpi5ddhxvbar1md6q9wla7hckabnq0z"; })

     

       23
       23
       +
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Linux"; version = "2.8.2.1-preview.108"; sha256 = "16wvgvyra2g1b38rxxgkk85wbz89hspixs54zfcm4racgmj1mrj4"; })

     

       24
       24
       +
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.macOS"; version = "2.8.2.1-preview.108"; sha256 = "16v7lrwwif2f5zfkx08n6y6w3m56mh4hy757biv0w9yffaf200js"; })

     

       25
       25
       +
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.WebAssembly"; version = "2.8.2.1-preview.108"; sha256 = "15kqb353snwpavz3jja63mq8xjqsrw1f902scm8wxmsqrm5q6x55"; })

     

       26
       26
       +
         (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Win32"; version = "2.8.2.1-preview.108"; sha256 = "0n6ymn9jqms3mk5hg0ar4y9jmh96myl6q0jimn7ahb1a8viq55k1"; })

     

       24
       27
        
         (fetchNuGet { pname = "JetBrains.Annotations"; version = "10.3.0"; sha256 = "1grdx28ga9fp4hwwpwv354rizm8anfq4lp045q4ss41gvhggr3z8"; })

     

       28
       28
       +
         (fetchNuGet { pname = "MicroCom.Runtime"; version = "0.11.0"; sha256 = "0p9c3m0zk59x9dcqw077hzd2yk60myisbacvm36mnwpcjwzjkp2m"; })

     

       29
       29
       +
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Ref"; version = "6.0.11"; sha256 = "15n8x52njzxs2cwzzswi0kawm673jkvf2yga87jaf7hr729bfmcr"; })

     

       30
       30
       +
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "6.0.11"; sha256 = "1pw25rnw5nm51wjdjbrhzhz9v0c8gjjqn2na2bam3c5xawvnqkqf"; })

     

       31
       31
       +
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "6.0.11"; sha256 = "0vd5da34frm7avrc9d16d39s2k5sgzd260j5pkjsianhpjby5rbn"; })

     

       32
       32
       +
         (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "3.0.0"; sha256 = "0bbl0jpqywqmzz2gagld1p2gvdfldjfjmm25hil9wj2nq1zc4di8"; })

     

       33
       33
       +
         (fetchNuGet { pname = "Microsoft.CodeAnalysis.Common"; version = "3.8.0"; sha256 = "12n7rvr39bzkf2maw7zplw8rwpxpxss4ich3bb2pw770rx4nyvyw"; })

     

       34
       34
       +
         (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp"; version = "3.8.0"; sha256 = "1kmry65csvfn72zzc16vj1nfbfwam28wcmlrk3m5rzb8ydbzgylb"; })

     

       35
       35
       +
         (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp.Scripting"; version = "3.8.0"; sha256 = "0w0yx0lpg54iw5jazqk46h48gx43ij32gwac8iywdj6kxfxm03vw"; })

     

       36
       36
       +
         (fetchNuGet { pname = "Microsoft.CodeAnalysis.Scripting.Common"; version = "3.8.0"; sha256 = "0hjgxcsj5zy27lqk0986m59n5dbplx2vjjla2lsvg4bwg8qa7bpk"; })

     

       37
       37
       +
         (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.3.0"; sha256 = "0gw297dgkh0al1zxvgvncqs0j15lsna9l1wpqas4rflmys440xvb"; })

     

       25
       38
        
         (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.5.0"; sha256 = "01i28nvzccxbqmiz217fxs6hnjwmd5fafs37rd49a6qp53y6623l"; })

     

       39
       39
       +
         (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "6.0.11"; sha256 = "0k8nl3hnr8h0ljw185dyhavrz2f7x6wavyadyf7f1v289jzasj72"; })

     

       40
       40
       +
         (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "6.0.11"; sha256 = "0bnq4dj7s5mspi7f8ihpp2y4bncb229ihrcmxvifsbb15mlhh8g4"; })

     

       41
       41
       +
         (fetchNuGet { pname = "Microsoft.NETCore.App.Ref"; version = "6.0.11"; sha256 = "1j64ppdvh5s3pqr6sm3sq9bmk3fzj7l4j3bx023zn3dyllibpv68"; })

     

       42
       42
       +
         (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "6.0.11"; sha256 = "03kvh4l5j8i8263wz7fmznzf5rs1grgazrhi3ayhynvhdal04mdk"; })

     

       43
       43
       +
         (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "6.0.11"; sha256 = "1f60dyl8pnj067i7bvmsbazcvrjkgrz9943vjj0ym49cfyq98cnw"; })

     

       26
       44
        
         (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.0.1"; sha256 = "01al6cfxp68dscl15z7rxfw9zvhm64dncsw09a1vmdkacsa2v6lr"; })

     

       27
       45
        
         (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.0"; sha256 = "08vh1r12g6ykjygq5d3vq09zylgb84l63k49jc4v8faw9g93iqqm"; })

     

       28
       28
       -
         (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "2.0.0"; sha256 = "1fk2fk2639i7nzy58m9dvpdnzql4vb8yl8vr19r2fp8lmj9w2jr0"; })

     

       46
       46
       +
         (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "2.1.2"; sha256 = "1507hnpr9my3z4w1r6xk5n0s1j3y6a2c2cnynj76za7cphxi1141"; })

     

       29
       47
        
         (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.0.1"; sha256 = "0ppdkwy6s9p7x9jix3v4402wb171cdiibq7js7i13nxpdky7074p"; })

     

       30
       48
        
         (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; sha256 = "193xwf33fbm0ni3idxzbr5fdq3i2dlfgihsac9jj7whj0gd902nh"; })

     

       31
       31
       -
         (fetchNuGet { pname = "Microsoft.Win32.SystemEvents"; version = "4.5.0"; sha256 = "0fnkv3ky12227zqg4zshx4kw2mvysq2ppxjibfw02cc3iprv4njq"; })

     

       32
       32
       -
         (fetchNuGet { pname = "ReactiveUI"; version = "18.2.9"; sha256 = "156747759npb2dgsnd2y1bq2vnmmssizsz78kf80mr8pd60wlbj4"; })

     

       49
       49
       +
         (fetchNuGet { pname = "Microsoft.Win32.SystemEvents"; version = "6.0.0"; sha256 = "0c6pcj088g1yd1vs529q3ybgsd2vjlk5y1ic6dkmbhvrp5jibl9p"; })

     

       50
       50
       +
         (fetchNuGet { pname = "ReactiveUI"; version = "18.3.1"; sha256 = "1lxkc8yk9glj0w9n5vry2dnwwvh8152ad2c5bivk8aciq64zidyn"; })

     

       51
       51
       +
         (fetchNuGet { pname = "runtime.any.System.Collections"; version = "4.0.11"; sha256 = "1x44bm1cgv28zmrp095wf9mn8a6a0ivnzp9v14dcbhx06igxzgg0"; })

     

       52
       52
       +
         (fetchNuGet { pname = "runtime.any.System.Globalization"; version = "4.0.11"; sha256 = "0240rp66pi5bw1xklmh421hj7arwcdmjmgfkiq1cbc6nrm8ah286"; })

     

       33
       53
        
         (fetchNuGet { pname = "runtime.any.System.IO"; version = "4.1.0"; sha256 = "0kasfkjiml2kk8prnyn1990nhsahnjggvqwszqjdsfwfl43vpcb5"; })

     

       34
       54
        
         (fetchNuGet { pname = "runtime.any.System.Reflection"; version = "4.1.0"; sha256 = "06kcs059d5czyakx75rvlwa2mr86156w18fs7chd03f7084l7mq6"; })

     

       55
       55
       +
         (fetchNuGet { pname = "runtime.any.System.Reflection.Extensions"; version = "4.0.1"; sha256 = "05k34ijz9g9csh0vbbv3g3lrxl163izwcfncmbcl7k073h32rzkr"; })

     

       35
       56
        
         (fetchNuGet { pname = "runtime.any.System.Reflection.Primitives"; version = "4.0.1"; sha256 = "1zxrpvixr5fqzkxpnin6g6gjq6xajy1snghz99ds2dwbhm276rhz"; })

     

       57
       57
       +
         (fetchNuGet { pname = "runtime.any.System.Resources.ResourceManager"; version = "4.0.1"; sha256 = "1jmgs7hynb2rff48623wnyb37558bbh1q28k9c249j5r5sgsr5kr"; })

     

       36
       58
        
         (fetchNuGet { pname = "runtime.any.System.Runtime"; version = "4.1.0"; sha256 = "0mjr2bi7wvnkphfjqgkyf8vfyvy15a829jz6mivl6jmksh2bx40m"; })

     

       59
       59
       +
         (fetchNuGet { pname = "runtime.any.System.Runtime.Handles"; version = "4.0.1"; sha256 = "1kswgqhy34qvc49i981fk711s7knd6z13bp0rin8ms6axkh98nas"; })

     

       60
       60
       +
         (fetchNuGet { pname = "runtime.any.System.Runtime.InteropServices"; version = "4.1.0"; sha256 = "0gm8if0hcmp1qys1wmx4970k2x62pqvldgljsyzbjhiy5644vl8z"; })

     

       37
       61
        
         (fetchNuGet { pname = "runtime.any.System.Text.Encoding"; version = "4.0.11"; sha256 = "0m4vgmzi1ky8xlj0r7xcyazxln3j9dlialnk6d2gmgrfnzf8f9m7"; })

     

       38
       62
        
         (fetchNuGet { pname = "runtime.any.System.Threading.Tasks"; version = "4.0.11"; sha256 = "1qzdp09qs8br5qxzlm1lgbjn4n57fk8vr1lzrmli2ysdg6x1xzvk"; })

     

       39
       63
        
         (fetchNuGet { pname = "runtime.native.System"; version = "4.0.0"; sha256 = "1ppk69xk59ggacj9n7g6fyxvzmk1g5p4fkijm0d7xqfkig98qrkf"; })

     

       64
       64
       +
         (fetchNuGet { pname = "runtime.native.System.Security.Cryptography"; version = "4.0.0"; sha256 = "0k57aa2c3b10wl3hfqbgrl7xq7g8hh3a3ir44b31dn5p61iiw3z9"; })

     

       65
       65
       +
         (fetchNuGet { pname = "runtime.unix.System.Diagnostics.Debug"; version = "4.0.11"; sha256 = "05ndbai4vpqrry0ghbfgqc8xblmplwjgndxmdn1zklqimczwjg2d"; })

     

       40
       66
        
         (fetchNuGet { pname = "runtime.unix.System.Private.Uri"; version = "4.0.1"; sha256 = "0ic5dgc45jkhcr1g9xmmzjm7ffiw4cymm0fprczlx4fnww4783nm"; })

     

       67
       67
       +
         (fetchNuGet { pname = "runtime.unix.System.Runtime.Extensions"; version = "4.1.0"; sha256 = "0x1cwd7cvifzmn5x1wafvj75zdxlk3mxy860igh3x1wx0s8167y4"; })

     

       41
       68
        
         (fetchNuGet { pname = "Serilog"; version = "2.10.0"; sha256 = "08bih205i632ywryn3zxkhb15dwgyaxbhmm1z3b5nmby9fb25k7v"; })

     

       42
       42
       -
         (fetchNuGet { pname = "Serilog.Sinks.File"; version = "5.0.0"; sha256 = "097rngmgcrdfy7jy8j7dq3xaq2qky8ijwg0ws6bfv5lx0f3vvb0q"; })

     

       43
       43
       -
         (fetchNuGet { pname = "SkiaSharp"; version = "2.88.1-preview.1"; sha256 = "1i1px67hcr9kygmbfq4b9nqzlwm7v2gapsp4isg9i19ax5g8dlhm"; })

     

       44
       44
       -
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.Linux"; version = "2.88.1-preview.1"; sha256 = "1r9qr3civk0ws1z7hg322qyr8yjm10853zfgs03szr2lvdqiy7d1"; })

     

       45
       45
       -
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.macOS"; version = "2.88.1-preview.1"; sha256 = "1w55nrwpl42psn6klia5a9aw2j1n25hpw2fdhchypm9f0v2iz24h"; })

     

       46
       46
       -
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.WebAssembly"; version = "2.88.1-preview.1"; sha256 = "0mwj2yl4gn40lry03yqkj7sbi1drmm672dv88481sgah4c21lzrq"; })

     

       47
       47
       -
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.Win32"; version = "2.88.1-preview.1"; sha256 = "1k50abd147pif9z9lkckbbk91ga1vv6k4skjz2n7wpll6fn0fvlv"; })

     

       48
       48
       -
         (fetchNuGet { pname = "Splat"; version = "14.3.4"; sha256 = "1j5riry4hc6gmw6zkwqq4fsw4rcddnb8kwyhnb321qp60z8v8pv4"; })

     

       69
       69
       +
         (fetchNuGet { pname = "Serilog.Sinks.File"; version = "5.0.1-dev-00947"; sha256 = "153vi3xjy65ixfr8nfs59n0bmgj0jxfyydmhjs8h3apr9f29lbh4"; })

     

       70
       70
       +
         (fetchNuGet { pname = "SkiaSharp"; version = "2.88.1"; sha256 = "0jpn0x1rfj3dzjfg972icml5swvzvr368nip269qq0a2z4xy0lhx"; })

     

       71
       71
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.Linux"; version = "2.88.1"; sha256 = "19f8f0m3d6xds2dggazafdk4i3injaxpx7ahg73nq8zj03qbg7fp"; })

     

       72
       72
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.macOS"; version = "2.88.1"; sha256 = "1img6chwxprz6bqjyi43walgb3xccnzgfxs29xwcvkkmc8w6pvdp"; })

     

       73
       73
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.WebAssembly"; version = "2.88.1"; sha256 = "0bvpwfdji8wb5f16hfzc62k265p21r172dqpibdx1gjd6w6phxrs"; })

     

       74
       74
       +
         (fetchNuGet { pname = "SkiaSharp.NativeAssets.Win32"; version = "2.88.1"; sha256 = "1x0ds2nnbqn44kfrfbvj055nihhmzlqm5fhdka3mgbj821fpy629"; })

     

       75
       75
       +
         (fetchNuGet { pname = "Splat"; version = "14.4.1"; sha256 = "03ycyjn2ii44npi015p4rk344xnjgdzz02cf63cmhx2ab8hv6p4b"; })

     

       76
       76
       +
         (fetchNuGet { pname = "StrongInject"; version = "1.4.5-ci-20220524-023137"; sha256 = "1ksiv5rs22j193sxwjvdc4vhblikka9z8hhs705f4mi1r4q0x1ha"; })

     

       77
       77
       +
         (fetchNuGet { pname = "System.Collections"; version = "4.3.0"; sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9"; })

     

       78
       78
       +
         (fetchNuGet { pname = "System.Collections.Immutable"; version = "5.0.0"; sha256 = "1kvcllagxz2q92g81zkz81djkn2lid25ayjfgjalncyc68i15p0r"; })

     

       49
       79
        
         (fetchNuGet { pname = "System.ComponentModel.Annotations"; version = "4.5.0"; sha256 = "1jj6f6g87k0iwsgmg3xmnn67a14mq88np0l1ys5zkxhkvbc8976p"; })

     

       50
       50
       -
         (fetchNuGet { pname = "System.Drawing.Common"; version = "4.5.0"; sha256 = "0knqa0zsm91nfr34br8gx5kjqq4v81zdhqkacvs2hzc8nqk0ddhc"; })

     

       80
       80
       +
         (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.3.0"; sha256 = "00yjlf19wjydyr6cfviaph3vsjzg3d5nvnya26i2fvfg53sknh3y"; })

     

       81
       81
       +
         (fetchNuGet { pname = "System.Drawing.Common"; version = "6.0.0"; sha256 = "02n8rzm58dac2np8b3xw8ychbvylja4nh6938l5k2fhyn40imlgz"; })

     

       82
       82
       +
         (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.3.0"; sha256 = "1d951hrvrpndk7insiag80qxjbf2y0y39y8h5hnq9612ws661glk"; })

     

       83
       83
       +
         (fetchNuGet { pname = "System.Globalization"; version = "4.3.0"; sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki"; })

     

       51
       84
        
         (fetchNuGet { pname = "System.IO"; version = "4.3.0"; sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f"; })

     

       85
       85
       +
         (fetchNuGet { pname = "System.Linq"; version = "4.3.0"; sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7"; })

     

       86
       86
       +
         (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.3.0"; sha256 = "0ky2nrcvh70rqq88m9a5yqabsl4fyd17bpr63iy2mbivjs2nyypv"; })

     

       52
       87
        
         (fetchNuGet { pname = "System.Memory"; version = "4.5.3"; sha256 = "0naqahm3wljxb5a911d37mwjqjdxv9l0b49p5dmfyijvni2ppy8a"; })

     

       88
       88
       +
         (fetchNuGet { pname = "System.Memory"; version = "4.5.4"; sha256 = "14gbbs22mcxwggn0fcfs1b062521azb9fbb7c113x0mq6dzq9h6y"; })

     

       53
       89
        
         (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.5.0"; sha256 = "1kzrj37yzawf1b19jq0253rcs8hsq1l2q8g69d7ipnhzb0h97m59"; })

     

       90
       90
       +
         (fetchNuGet { pname = "System.ObjectModel"; version = "4.3.0"; sha256 = "191p63zy5rpqx7dnrb3h7prvgixmk168fhvvkkvhlazncf8r3nc2"; })

     

       54
       91
        
         (fetchNuGet { pname = "System.Private.Uri"; version = "4.0.1"; sha256 = "0k57qhawjysm4cpbfpc49kl4av7lji310kjcamkl23bwgij5ld9j"; })

     

       55
       92
        
         (fetchNuGet { pname = "System.Reactive"; version = "5.0.0"; sha256 = "1lafmpnadhiwxyd543kraxa3jfdpm6ipblxrjlibym9b1ykpr5ik"; })

     

       56
       93
        
         (fetchNuGet { pname = "System.Reflection"; version = "4.3.0"; sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m"; })

     

       57
       94
        
         (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.3.0"; sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74"; })

     

       58
       95
        
         (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.7.0"; sha256 = "121l1z2ypwg02yz84dy6gr82phpys0njk7yask3sihgy214w43qp"; })

     

       59
       96
        
         (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.3.0"; sha256 = "0w1n67glpv8241vnpz1kl14sy7zlnw414aqwj4hcx5nd86f6994q"; })

     

       97
       97
       +
         (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.3.0"; sha256 = "0ql7lcakycrvzgi9kxz1b3lljd990az1x6c4jsiwcacrvimpib5c"; })

     

       98
       98
       +
         (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.3.0"; sha256 = "02bly8bdc98gs22lqsfx9xicblszr2yan7v2mmw3g7hy6miq5hwq"; })

     

       99
       99
       +
         (fetchNuGet { pname = "System.Reflection.Metadata"; version = "5.0.0"; sha256 = "17qsl5nanlqk9iz0l5wijdn6ka632fs1m1fvx18dfgswm258r3ss"; })

     

       60
       100
        
         (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.3.0"; sha256 = "04xqa33bld78yv5r93a8n76shvc8wwcdgr1qvvjh959g3rc31276"; })

     

       101
       101
       +
         (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.3.0"; sha256 = "0y2ssg08d817p0vdag98vn238gyrrynjdj4181hdg780sif3ykp1"; })

     

       102
       102
       +
         (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.3.0"; sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49"; })

     

       61
       103
        
         (fetchNuGet { pname = "System.Runtime"; version = "4.1.0"; sha256 = "02hdkgk13rvsd6r9yafbwzss8kr55wnj8d5c7xjnp8gqrwc8sn0m"; })

     

       62
       104
        
         (fetchNuGet { pname = "System.Runtime"; version = "4.3.0"; sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7"; })

     

       63
       105
        
         (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.6.0"; sha256 = "0xmzi2gpbmgyfr75p24rqqsba3cmrqgmcv45lsqp5amgrdwd0f0m"; })

     

       106
       106
       +
         (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.7.1"; sha256 = "119br3pd85lq8zcgh4f60jzmv1g976q1kdgi3hvqdlhfbw6siz2j"; })

     

       107
       107
       +
         (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.3.0"; sha256 = "1ykp3dnhwvm48nap8q23893hagf665k0kn3cbgsqpwzbijdcgc60"; })

     

       108
       108
       +
         (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.3.0"; sha256 = "0sw2gfj2xr7sw9qjn0j3l9yw07x73lcs97p8xfc9w1x9h5g5m7i8"; })

     

       109
       109
       +
         (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.3.0"; sha256 = "00hywrn4g7hva1b2qri2s6rabzwgxnbpw9zfxmz28z09cpwwgh7j"; })

     

       64
       110
        
         (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "4.7.0"; sha256 = "1a56ls5a9sr3ya0nr086sdpa9qv0abv31dd6fp27maqa9zclqq5d"; })

     

       65
       111
        
         (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr"; })

     

       112
       112
       +
         (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "4.5.1"; sha256 = "1z21qyfs6sg76rp68qdx0c9iy57naan89pg7p6i3qpj8kyzn921w"; })

     

       113
       113
       +
         (fetchNuGet { pname = "System.Threading"; version = "4.3.0"; sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34"; })

     

       66
       114
        
         (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.3.0"; sha256 = "134z3v9abw3a6jsw17xl3f6hqjpak5l682k2vz39spj4kmydg6k7"; })

     

       67
       115
        
         (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.5.4"; sha256 = "0y6ncasgfcgnjrhynaf0lwpkpkmv4a07sswwkwbwb5h7riisj153"; })

     

       68
       116
        
         (fetchNuGet { pname = "System.ValueTuple"; version = "4.5.0"; sha256 = "00k8ja51d0f9wrq4vv5z2jhq8hy31kac2rg0rv06prylcybzl8cy"; })

     

       69
       69
       -
         (fetchNuGet { pname = "ThisAssembly.AssemblyInfo"; version = "1.0.9"; sha256 = "0rvav885cq7ia5kzwp7d37c2azsg47988z2fn6ksi1q6y294crxm"; })

     

       70
       70
       -
         (fetchNuGet { pname = "ThisAssembly.Prerequisites"; version = "1.0.9"; sha256 = "1igi76li4c1iif71141jhn7x5w0ng1vmqj5ijjhdxz289n6wjf2g"; })

     

       117
       117
       +
         (fetchNuGet { pname = "ThisAssembly.AssemblyInfo"; version = "1.0.10"; sha256 = "1hvq0c9d6zmn1q6lyvz4hcaiypf1d65akhx70mv2plysbgvrcm95"; })

     

       118
       118
       +
         (fetchNuGet { pname = "ThisAssembly.Prerequisites"; version = "1.0.10"; sha256 = "112grp0xxkzfkhyxb1hbh4qs2d9qrkasv42himdkqjk0i0fg1ag0"; })

     

       71
       119
        
         (fetchNuGet { pname = "Tmds.DBus"; version = "0.9.0"; sha256 = "0vvx6sg8lxm23g5jvm5wh2gfs95mv85vd52lkq7d1b89bdczczf3"; })

     

       72
       72
       -
         (fetchNuGet { pname = "XamlNameReferenceGenerator"; version = "1.3.4"; sha256 = "0w1bz5sr6y5fhgx1f54xyl8rx7y3kyf1fhacnd6akq8970zjdkdi"; })

     

       120
       120
       +
         (fetchNuGet { pname = "XamlNameReferenceGenerator"; version = "1.5.1"; sha256 = "11sld5a9z2rdglkykvylghka7y37ny18naywpgpxp485m9bc63wc"; })

     

       73
       121
        
       ]

+8 -11

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

···

       6
       6
        
       

     

       7
       7
        
       rustPlatform.buildRustPackage rec {

     

       8
       8
        
         pname = "catfs";

     

       9
       9
       -
         version = "unstable-2020-03-21";

     

       9
       9
       +
         version = "0.9.0";

     

       10
       10
        
       

     

       11
       11
        
         src = fetchFromGitHub {

     

       12
       12
        
           owner = "kahing";

     

       13
       13
        
           repo = pname;

     

       14
       14
       -
           rev = "daa2b85798fa8ca38306242d51cbc39ed122e271";

     

       15
       15
       -
           sha256 = "0zca0c4n2p9s5kn8c9f9lyxdf3df88a63nmhprpgflj86bh8wgf5";

     

       14
       14
       +
           rev = "v${version}";

     

       15
       15
       +
           hash = "sha256-OvmtU2jpewP5EqPwEFAf67t8UCI1WuzUO2QQj4cH1Ak=";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         cargoSha256 = "1agcwq409s40kyij487wjrp8mj7942r9l2nqwks4xqlfb0bvaimf";

     

       18
       18
       +
         patches = [

     

       19
       19
       +
           # monitor https://github.com/kahing/catfs/issues/71

     

       20
       20
       +
           ./fix-for-rust-1.65.diff

     

       21
       21
       +
         ];

     

       19
       22
        
       

     

       20
       20
       -
         cargoPatches = [

     

       21
       21
       -
           # update cargo lock

     

       22
       22
       -
           (fetchpatch {

     

       23
       23
       -
             url = "https://github.com/kahing/catfs/commit/f838c1cf862cec3f1d862492e5be82b6dbe16ac5.patch";

     

       24
       24
       -
             sha256 = "1r1p0vbr3j9xyj9r1ahipg4acii3m4ni4m9mp3avbi1rfgzhblhw";

     

       25
       25
       -
           })

     

       26
       26
       -
         ];

     

       23
       23
       +
         cargoHash = "sha256-xF1J2Pr4qtNFcd2kec4tnbdYxoLK+jRnzp8p+cmNOcI=";

     

       27
       24
        
       

     

       28
       25
        
         nativeBuildInputs = [ pkg-config ];

     

       29
       26

+13

pkgs/os-specific/linux/catfs/fix-for-rust-1.65.diff

···

       1
       1
       +
       diff --git a/src/catfs/file.rs b/src/catfs/file.rs

     

       2
       2
       +
       index 6e781eb..92fdd80 100644

     

       3
       3
       +
       --- a/src/catfs/file.rs

     

       4
       4
       +
       +++ b/src/catfs/file.rs

     

       5
       5
       +
       @@ -569,7 +569,7 @@ impl Handle {

     

       6
       6
       +
                path: &dyn AsRef<Path>,

     

       7
       7
       +
                create: bool,

     

       8
       8
       +
            ) -> error::Result<()> {

     

       9
       9
       +
       -        let _ = self.page_in_res.0.lock().unwrap();

     

       10
       10
       +
       +        drop(self.page_in_res.0.lock().unwrap());

     

       11
       11
       +
        

     

       12
       12
       +
                let mut buf = [0u8; 0];

     

       13
       13
       +
                let mut flags = rlibc::O_RDWR;

+2 -2

pkgs/os-specific/linux/kernel/zen-kernels.nix

···

       12
       12
        
         # ./update-zen.py lqx

     

       13
       13
        
         lqxVariant = {

     

       14
       14
        
           version = "6.0.13"; #lqx

     

       15
       15
       -
           suffix = "lqx2"; #lqx

     

       16
       16
       -
           sha256 = "0xxxlv6rk620s947qj6xxxbjc8asynmx4ilbp66ahi92inxqiw29"; #lqx

     

       15
       15
       +
           suffix = "lqx3"; #lqx

     

       16
       16
       +
           sha256 = "0dc295d9dfm3j2nmvkzy21ky1k6jp7c7miqjhqgfjny9yk1b41k4"; #lqx

     

       17
       17
        
           isLqx = true;

     

       18
       18
        
         };

     

       19
       19
        
         zenKernelsFor = { version, suffix, sha256, isLqx }: buildLinux (args // {

+39 -2

pkgs/servers/http/apache-modules/mod_tile/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, fetchpatch, autoreconfHook, apacheHttpd, apr, cairo, iniparser, mapnik }:

     

       1
       1
       +
       { lib

     

       2
       2
       +
       , stdenv

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , fetchpatch

     

       5
       5
       +
       , autoreconfHook

     

       6
       6
       +
       , apacheHttpd

     

       7
       7
       +
       , apr

     

       8
       8
       +
       , cairo

     

       9
       9
       +
       , iniparser

     

       10
       10
       +
       , mapnik

     

       11
       11
       +
       , boost

     

       12
       12
       +
       , icu

     

       13
       13
       +
       , harfbuzz

     

       14
       14
       +
       , libjpeg

     

       15
       15
       +
       , libtiff

     

       16
       16
       +
       , libwebp

     

       17
       17
       +
       , proj

     

       18
       18
       +
       , sqlite

     

       19
       19
       +
       }:

     

       2
       20
        
       

     

       3
       21
        
       stdenv.mkDerivation rec {

     

       4
       22
        
         pname = "mod_tile";

     
···

       21
       39
        
           })

     

       22
       40
        
         ];

     

       23
       41
        
       

     

       42
       42
       +
         # test is broken and I couldn't figure out a better way to disable it.

     

       43
       43
       +
         postPatch = ''

     

       44
       44
       +
           echo "int main(){return 0;}" > src/gen_tile_test.cpp

     

       45
       45
       +
         '';

     

       46
       46
       +
       

     

       24
       47
        
         nativeBuildInputs = [ autoreconfHook ];

     

       25
       25
       -
         buildInputs = [ apacheHttpd apr cairo iniparser mapnik ];

     

       48
       48
       +
         buildInputs = [

     

       49
       49
       +
           apacheHttpd

     

       50
       50
       +
           apr

     

       51
       51
       +
           cairo

     

       52
       52
       +
           iniparser

     

       53
       53
       +
           mapnik

     

       54
       54
       +
           boost

     

       55
       55
       +
           icu

     

       56
       56
       +
           harfbuzz

     

       57
       57
       +
           libjpeg

     

       58
       58
       +
           libtiff

     

       59
       59
       +
           libwebp

     

       60
       60
       +
           proj

     

       61
       61
       +
           sqlite

     

       62
       62
       +
         ];

     

       26
       63
        
       

     

       27
       64
        
         configureFlags = [

     

       28
       65
        
           "--with-apxs=${apacheHttpd.dev}/bin/apxs"

+10 -4

pkgs/servers/monitoring/mimir/default.nix

···

       1
       1
        
       { lib, buildGoModule, fetchFromGitHub, nixosTests }:

     

       2
       2
       +
       let

     

       3
       3
       +
         pinData = lib.importJSON ./pin.json;

     

       4
       4
       +
       in

     

       2
       5
        
       buildGoModule rec {

     

       3
       6
        
         pname = "mimir";

     

       4
       4
       -
         version = "2.4.0";

     

       7
       7
       +
         version = pinData.version;

     

       5
       8
        
       

     

       6
       9
        
         src = fetchFromGitHub {

     

       7
       10
        
           rev = "${pname}-${version}";

     

       8
       11
        
           owner = "grafana";

     

       9
       12
        
           repo = pname;

     

       10
       10
       -
           sha256 = "sha256-OpQxVp4Q2+r3Tqrqw3SrBsJDU5KJqChxsuYneT0PvYQ=";

     

       13
       13
       +
           sha256 = pinData.sha256;

     

       11
       14
        
         };

     

       12
       15
        
       

     

       13
       16
        
         vendorSha256 = null;

     
···

       17
       20
        
           "cmd/mimirtool"

     

       18
       21
        
         ];

     

       19
       22
        
       

     

       20
       20
       -
         passthru.tests = {

     

       21
       21
       -
           inherit (nixosTests) mimir;

     

       23
       23
       +
         passthru = {

     

       24
       24
       +
           updateScript = ./update.sh;

     

       25
       25
       +
           tests = {

     

       26
       26
       +
             inherit (nixosTests) mimir;

     

       27
       27
       +
           };

     

       22
       28
        
         };

     

       23
       29
        
       

     

       24
       30
        
         ldflags = let t = "github.com/grafana/mimir/pkg/util/version";

pkgs/servers/monitoring/mimir/pin.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "version": "mimir-2.5.0",

     

       3
       3
       +
         "sha256": "sha256-lyF7ugnNEJug1Vx24ISrtENk6RoIt7H1zaCPYUZbBmM="

     

       4
       4
       +
       }

+25

pkgs/servers/monitoring/mimir/update.sh

···

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

     

       2
       2
       +
       #! nix-shell -i oil -p jq sd nix-prefetch-github ripgrep

     

       3
       3
       +
       

     

       4
       4
       +
       # TODO set to `verbose` or `extdebug` once implemented in oil

     

       5
       5
       +
       shopt --set xtrace

     

       6
       6
       +
       # we need failures inside of command subs to get the correct vendorSha256

     

       7
       7
       +
       shopt --unset inherit_errexit

     

       8
       8
       +
       

     

       9
       9
       +
       const directory = $(dirname $0 | xargs realpath)

     

       10
       10
       +
       const owner = "grafana"

     

       11
       11
       +
       const repo = "mimir"

     

       12
       12
       +
       const latest_rev = $(curl -q https://api.github.com/repos/${owner}/${repo}/releases/latest | \

     

       13
       13
       +
         jq -r '.tag_name')

     

       14
       14
       +
       const latest_version = $(echo $latest_rev | sd 'v' '')

     

       15
       15
       +
       const current_version = $(jq -r '.version' $directory/pin.json)

     

       16
       16
       +
       if ("$latest_version" === "$current_version") {

     

       17
       17
       +
         echo "$repo is already up-to-date"

     

       18
       18
       +
         return 0

     

       19
       19
       +
       } else {

     

       20
       20
       +
         const tarball_meta = $(nix-prefetch-github $owner $repo --rev "$latest_rev")

     

       21
       21
       +
         const tarball_hash = "sha256-$(echo $tarball_meta | jq -r '.sha256')"

     

       22
       22
       +
       

     

       23
       23
       +
         jq ".version = \"$latest_version\" | \

     

       24
       24
       +
             .\"sha256\" = \"$tarball_hash\"" $directory/pin.json | sponge $directory/pin.json

     

       25
       25
       +
       }

+1 -1

pkgs/servers/monitoring/uptime-kuma/update.sh

···

       3
       3
        
       

     

       4
       4
        
       set -euo pipefail

     

       5
       5
        
       

     

       6
       6
       -
       latestVersion="$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} "https://api.github.com/repos/louislam/uptime-kuma/releases?per_page=1" | jq -r ".[0].tag_name" | sed 's/^v//')"

     

       6
       6
       +
       latestVersion="$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} "https://api.github.com/repos/louislam/uptime-kuma/releases?per_page=1" | jq -r ".[0].tag_name" | sed 's/^v//')"

     

       7
       7
        
       currentVersion=$(nix-instantiate --eval -E "with import ./. {}; uptime-kuma.version or (lib.getVersion uptime-kuma)" | tr -d '"')

     

       8
       8
        
       

     

       9
       9
        
       if [[ "$currentVersion" == "$latestVersion" ]]; then

+2 -2

pkgs/servers/mqtt/nanomq/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation (finalAttrs: {

     

       4
       4
        
         pname = "nanomq";

     

       5
       5
       -
         version = "0.14.5";

     

       5
       5
       +
         version = "0.14.8";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "emqx";

     

       9
       9
        
           repo = "nanomq";

     

       10
       10
        
           rev = finalAttrs.version;

     

       11
       11
       -
           hash = "sha256-VbVeePacHrE79qV74rGv70G4Hj6O8nK4XCZ3xKbxuQU=";

     

       11
       11
       +
           hash = "sha256-rWLsH01XHtN/UlyOiMFI2UECuxodCkCVR/L72HIfNtY=";

     

       12
       12
        
           fetchSubmodules = true;

     

       13
       13
        
         };

     

       14
       14

+1 -1

pkgs/tools/misc/depotdownloader/update.sh

···

       5
       5
        
       

     

       6
       6
        
       depsFile="$(realpath "$(dirname "${BASH_SOURCE[0]}")/deps.nix")"

     

       7
       7
        
       currentVersion="$(nix eval --raw -f . depotdownloader.version)"

     

       8
       8
       -
       latestVersion="$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} "https://api.github.com/repos/SteamRE/DepotDownloader/releases?per_page=1" \

     

       8
       8
       +
       latestVersion="$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} "https://api.github.com/repos/SteamRE/DepotDownloader/releases?per_page=1" \

     

       9
       9
        
           | jq -r '.[].name' | cut -d' ' -f2)"

     

       10
       10
        
       

     

       11
       11
        
       if [[ "$currentVersion" = "$latestVersion" ]]; then

+3 -3

pkgs/tools/misc/star-history/default.nix

···

       9
       9
        
       

     

       10
       10
        
       rustPlatform.buildRustPackage rec {

     

       11
       11
        
         pname = "star-history";

     

       12
       12
       -
         version = "1.0.5";

     

       12
       12
       +
         version = "1.0.6";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchCrate {

     

       15
       15
        
           inherit pname version;

     

       16
       16
       -
           sha256 = "sha256-fmuCmyqw7wubMafkhqL1MltW6jZefgXdnudxdeBRSV4=";

     

       16
       16
       +
           sha256 = "sha256-NPlfgnLji261w/QedCkZ+IgfJMiG2aGjVfqJYpBPm6I=";

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         cargoSha256 = "sha256-+wHOBjBQyMuooDey4Py8xmgW3NNI8t8rCwA8A7D6L84=";

     

       19
       19
       +
         cargoSha256 = "sha256-NBegNCNjhI0XuvxeqiI1RD7nIM9MabhXxZBnSEZrsD4=";

     

       20
       20
        
       

     

       21
       21
        
         nativeBuildInputs = [ pkg-config ];

     

       22
       22

+4 -1

pkgs/tools/misc/vector/default.nix

···

       103
       103
        
           ''}

     

       104
       104
        
         '';

     

       105
       105
        
       

     

       106
       106
       -
         passthru = { inherit features; };

     

       106
       106
       +
         passthru = {

     

       107
       107
       +
           inherit features;

     

       108
       108
       +
           updateScript = ./update.sh;

     

       109
       109
       +
         };

     

       107
       110
        
       

     

       108
       111
        
         meta = with lib; {

     

       109
       112
        
           description = "A high-performance logs, metrics, and events router";

+53

pkgs/tools/networking/mmsd-tng/default.nix

···

       1
       1
       +
       { lib, stdenv

     

       2
       2
       +
       , fetchFromGitLab

     

       3
       3
       +
       , c-ares

     

       4
       4
       +
       , dbus

     

       5
       5
       +
       , glib

     

       6
       6
       +
       , libphonenumber

     

       7
       7
       +
       , libsoup

     

       8
       8
       +
       , meson

     

       9
       9
       +
       , mobile-broadband-provider-info

     

       10
       10
       +
       , modemmanager

     

       11
       11
       +
       , ninja

     

       12
       12
       +
       , pkg-config

     

       13
       13
       +
       , protobuf

     

       14
       14
       +
       }:

     

       15
       15
       +
       

     

       16
       16
       +
       stdenv.mkDerivation rec {

     

       17
       17
       +
         pname = "mmsd-tng";

     

       18
       18
       +
         version = "1.12.1";

     

       19
       19
       +
       

     

       20
       20
       +
         src = fetchFromGitLab {

     

       21
       21
       +
           owner = "kop316";

     

       22
       22
       +
           repo = "mmsd";

     

       23
       23
       +
           rev = version;

     

       24
       24
       +
           sha256 = "sha256-fhbiTJWmQwJpuMaVX2qWyWwJ/2Y/Vczo//+0T0b6jhA=";

     

       25
       25
       +
         };

     

       26
       26
       +
       

     

       27
       27
       +
         nativeBuildInputs = [

     

       28
       28
       +
           meson

     

       29
       29
       +
           ninja

     

       30
       30
       +
           pkg-config

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         buildInputs = [

     

       34
       34
       +
           c-ares

     

       35
       35
       +
           dbus

     

       36
       36
       +
           glib

     

       37
       37
       +
           libphonenumber

     

       38
       38
       +
           libsoup

     

       39
       39
       +
           mobile-broadband-provider-info

     

       40
       40
       +
           modemmanager

     

       41
       41
       +
           protobuf

     

       42
       42
       +
         ];

     

       43
       43
       +
       

     

       44
       44
       +
         doCheck = true;

     

       45
       45
       +
       

     

       46
       46
       +
         meta = with lib; {

     

       47
       47
       +
           description = "Multimedia Messaging Service Daemon - The Next Generation";

     

       48
       48
       +
           homepage = "https://gitlab.com/kop316/mmsd";

     

       49
       49
       +
           license = licenses.gpl2Plus;

     

       50
       50
       +
           maintainers = with maintainers; [ julm ];

     

       51
       51
       +
           platforms = platforms.linux;

     

       52
       52
       +
         };

     

       53
       53
       +
       }

+2 -2

pkgs/tools/networking/netbird/default.nix

···

       14
       14
        
       in

     

       15
       15
        
       buildGoModule rec {

     

       16
       16
        
         pname = "netbird";

     

       17
       17
       -
         version = "0.11.5";

     

       17
       17
       +
         version = "0.11.6";

     

       18
       18
        
       

     

       19
       19
        
         src = fetchFromGitHub {

     

       20
       20
        
           owner = "netbirdio";

     

       21
       21
        
           repo = pname;

     

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

     

       23
       23
       -
           sha256 = "sha256-MW0RAhBgragzRR+St6jy5GmiNdD+WDsmM/q7AIlO72w=";

     

       23
       23
       +
           sha256 = "sha256-q86GVCRppBU9qiCch0sjTnSsjl17xU5l3o72cBF3zZo=";

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         vendorSha256 = "sha256-TfHBvcG3e+yjifPVo0ZgcvLvD16fni4m71nCr4cCBD4=";

+3 -3

pkgs/tools/package-management/nix-template/default.nix

···

       9
       9
        
       

     

       10
       10
        
       rustPlatform.buildRustPackage rec {

     

       11
       11
        
         pname = "nix-template";

     

       12
       12
       -
         version = "0.4.0";

     

       12
       12
       +
         version = "0.4.1";

     

       13
       13
        
       

     

       14
       14
        
         src = fetchFromGitHub {

     

       15
       15
        
           name = "${pname}-${version}-src";

     

       16
       16
        
           owner = "jonringer";

     

       17
       17
        
           repo = pname;

     

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

     

       19
       19
       -
           sha256 = "sha256-5Xxv9TH5rGA4VU/64YarrBIOrROWjFu3RYRcoNo70UA=";

     

       19
       19
       +
           sha256 = "sha256-42u5FmTIKHpfQ2zZQXIrFkAN2/XvU0wWnCRrQkQzcNI=";

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
       -
         cargoSha256 = "sha256-GvIE46NXNWg1kSEbffvOCwVDr0YmVMo8C8+52RDEwco=";

     

       22
       22
       +
         cargoSha256 = "sha256-f8Th6SbV66Uukqh1Cb5uQVa844qw1PmBB9W7EMXMU4E=";

     

       23
       23
        
       

     

       24
       24
        
         nativeBuildInputs = [

     

       25
       25
        
           installShellFiles

+4 -3

pkgs/tools/security/ldapnomnom/default.nix

···

       5
       5
        
       

     

       6
       6
        
       buildGoModule rec {

     

       7
       7
        
         pname = "ldapnomnom";

     

       8
       8
       -
         version = "1.0.7";

     

       8
       8
       +
         version = "1.1.0";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "lkarlslund";

     

       12
       12
        
           repo = pname;

     

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

     

       14
       14
       -
           hash = "sha256-eGCg6s3bg7ixXmdwFsugRMLvL/nTE2p53otkfc8OgQU=";

     

       14
       14
       +
           hash = "sha256-o29vcPKRX8TWRCpa20DVsh/4K7d3IbaLS3B+jJGBEmo=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
       -
         vendorSha256 = "sha256-3ucnLD+qhBSWY2wLtBcsOcuEf1woqHP17qQg7LlERA8=";

     

       17
       17
       +
         vendorHash = "sha256-3ucnLD+qhBSWY2wLtBcsOcuEf1woqHP17qQg7LlERA8=";

     

       18
       18
        
       

     

       19
       19
        
         meta = with lib; {

     

       20
       20
        
           description = "Tool to anonymously bruteforce usernames from Domain controllers";

     

       21
       21
        
           homepage = "https://github.com/lkarlslund/ldapnomnom";

     

       22
       22
       +
           changelog = "https://github.com/lkarlslund/ldapnomnom/releases/tag/v${version}";

     

       22
       23
        
           license = licenses.mit;

     

       23
       24
        
           maintainers = with maintainers; [ fab ];

     

       24
       25
        
         };

+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.2.30"

     

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

+21 -22

pkgs/tools/security/metasploit/Gemfile.lock

···

       1
       1
        
       GIT

     

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

     

       3
       3
       -
         revision: 21ca4473d2486d30618f99eaee7f3067e136c608

     

       4
       4
       -
         ref: refs/tags/6.2.30

     

       3
       3
       +
         revision: 2654f6f02a0ce6150e623804b9fab9576fe008f6

     

       4
       4
       +
         ref: refs/tags/6.2.31

     

       5
       5
        
         specs:

     

       6
       6
       -
           metasploit-framework (6.2.30)

     

       6
       6
       +
           metasploit-framework (6.2.31)

     

       7
       7
        
             actionpack (~> 6.0)

     

       8
       8
        
             activerecord (~> 6.0)

     

       9
       9
        
             activesupport (~> 6.0)

     
···

       13
       13
        
             bcrypt

     

       14
       14
        
             bcrypt_pbkdf

     

       15
       15
        
             bson

     

       16
       16
       -
             concurrent-ruby (= 1.0.5)

     

       17
       16
        
             dnsruby

     

       18
       17
        
             ed25519

     

       19
       18
        
             em-http-request

     
···

       32
       31
        
             metasploit-concern

     

       33
       32
        
             metasploit-credential

     

       34
       33
        
             metasploit-model

     

       35
       35
       -
             metasploit-payloads (= 2.0.101)

     

       34
       34
       +
             metasploit-payloads (= 2.0.105)

     

       36
       35
        
             metasploit_data_models

     

       37
       36
        
             metasploit_payloads-mettle (= 1.0.20)

     

       38
       37
        
             mqtt

     
···

       129
       128
        
           arel-helpers (2.14.0)

     

       130
       129
        
             activerecord (>= 3.1.0, < 8)

     

       131
       130
        
           aws-eventstream (1.2.0)

     

       132
       132
       -
           aws-partitions (1.674.0)

     

       131
       131
       +
           aws-partitions (1.679.0)

     

       133
       132
        
           aws-sdk-core (3.168.4)

     

       134
       133
        
             aws-eventstream (~> 1, >= 1.0.2)

     

       135
       134
        
             aws-partitions (~> 1, >= 1.651.0)

     

       136
       135
        
             aws-sigv4 (~> 1.5)

     

       137
       136
        
             jmespath (~> 1, >= 1.6.1)

     

       138
       138
       -
           aws-sdk-ec2 (1.354.0)

     

       137
       137
       +
           aws-sdk-ec2 (1.355.0)

     

       139
       138
        
             aws-sdk-core (~> 3, >= 3.165.0)

     

       140
       139
        
             aws-sigv4 (~> 1.1)

     

       141
       140
        
           aws-sdk-iam (1.73.0)

     
···

       155
       154
        
           bindata (2.4.14)

     

       156
       155
        
           bson (4.15.0)

     

       157
       156
        
           builder (3.2.4)

     

       158
       158
       -
           concurrent-ruby (1.0.5)

     

       157
       157
       +
           concurrent-ruby (1.1.10)

     

       159
       158
        
           cookiejar (0.3.3)

     

       160
       159
        
           crass (1.0.6)

     

       161
       160
        
           daemons (1.4.1)

     
···

       176
       175
        
           eventmachine (1.2.7)

     

       177
       176
        
           faker (3.0.0)

     

       178
       177
        
             i18n (>= 1.8.11, < 2)

     

       179
       179
       -
           faraday (2.7.1)

     

       178
       178
       +
           faraday (2.7.2)

     

       180
       179
        
             faraday-net_http (>= 2.0, < 3.1)

     

       181
       180
        
             ruby2_keywords (>= 0.0.4)

     

       182
       181
        
           faraday-net_http (3.0.2)

     
···

       203
       202
        
           httpclient (2.8.3)

     

       204
       203
        
           i18n (1.12.0)

     

       205
       204
        
             concurrent-ruby (~> 1.0)

     

       206
       206
       -
           io-console (0.5.11)

     

       207
       207
       -
           irb (1.6.0)

     

       205
       205
       +
           io-console (0.6.0)

     

       206
       206
       +
           irb (1.6.1)

     

       208
       207
        
             reline (>= 0.3.0)

     

       209
       208
        
           jmespath (1.6.2)

     

       210
       209
        
           jsobfu (0.4.2)

     
···

       214
       213
        
           logging (2.3.1)

     

       215
       214
        
             little-plugger (~> 1.1)

     

       216
       215
        
             multi_json (~> 1.14)

     

       217
       217
       -
           loofah (2.19.0)

     

       216
       216
       +
           loofah (2.19.1)

     

       218
       217
        
             crass (~> 1.0.2)

     

       219
       218
        
             nokogiri (>= 1.5.9)

     

       220
       219
        
           metasm (1.0.5)

     
···

       222
       221
        
             activemodel (~> 6.0)

     

       223
       222
        
             activesupport (~> 6.0)

     

       224
       223
        
             railties (~> 6.0)

     

       225
       225
       -
           metasploit-credential (6.0.0)

     

       224
       224
       +
           metasploit-credential (6.0.1)

     

       226
       225
        
             metasploit-concern

     

       227
       226
        
             metasploit-model

     

       228
       227
        
             metasploit_data_models (>= 5.0.0)

     
···

       236
       235
        
             activemodel (~> 6.0)

     

       237
       236
        
             activesupport (~> 6.0)

     

       238
       237
        
             railties (~> 6.0)

     

       239
       239
       -
           metasploit-payloads (2.0.101)

     

       238
       238
       +
           metasploit-payloads (2.0.105)

     

       240
       239
        
           metasploit_data_models (5.0.6)

     

       241
       240
        
             activerecord (~> 6.0)

     

       242
       241
        
             activesupport (~> 6.0)

     
···

       292
       291
        
             nio4r (~> 2.0)

     

       293
       292
        
           racc (1.6.1)

     

       294
       293
        
           rack (2.2.4)

     

       295
       295
       -
           rack-protection (3.0.4)

     

       294
       294
       +
           rack-protection (3.0.5)

     

       296
       295
        
             rack

     

       297
       296
        
           rack-test (2.0.2)

     

       298
       297
        
             rack (>= 1.3)

     

       299
       298
        
           rails-dom-testing (2.0.3)

     

       300
       299
        
             activesupport (>= 4.2.0)

     

       301
       300
        
             nokogiri (>= 1.6)

     

       302
       302
       -
           rails-html-sanitizer (1.4.3)

     

       303
       303
       -
             loofah (~> 2.3)

     

       301
       301
       +
           rails-html-sanitizer (1.4.4)

     

       302
       302
       +
             loofah (~> 2.19, >= 2.19.1)

     

       304
       303
        
           railties (6.1.7)

     

       305
       304
        
             actionpack (= 6.1.7)

     

       306
       305
        
             activesupport (= 6.1.7)

     
···

       312
       311
        
           recog (3.0.3)

     

       313
       312
        
             nokogiri

     

       314
       313
        
           redcarpet (3.5.1)

     

       315
       315
       -
           reline (0.3.1)

     

       314
       314
       +
           reline (0.3.2)

     

       316
       315
        
             io-console (~> 0.5)

     

       317
       316
        
           rex-arch (0.1.14)

     

       318
       317
        
             rex-text

     
···

       359
       358
        
             rex-socket

     

       360
       359
        
             rex-text

     

       361
       360
        
           rex-struct2 (0.1.3)

     

       362
       362
       -
           rex-text (0.2.46)

     

       361
       361
       +
           rex-text (0.2.47)

     

       363
       362
        
           rex-zip (0.1.4)

     

       364
       363
        
             rex-text

     

       365
       364
        
           rexml (3.2.5)

     
···

       380
       379
        
             faraday (>= 0.17.3, < 3)

     

       381
       380
        
           simpleidn (0.2.1)

     

       382
       381
        
             unf (~> 0.1.4)

     

       383
       383
       -
           sinatra (3.0.4)

     

       382
       382
       +
           sinatra (3.0.5)

     

       384
       383
        
             mustermann (~> 3.0)

     

       385
       384
        
             rack (~> 2.2, >= 2.2.4)

     

       386
       386
       -
             rack-protection (= 3.0.4)

     

       385
       385
       +
             rack-protection (= 3.0.5)

     

       387
       386
        
             tilt (~> 2.0)

     

       388
       387
        
           sqlite3 (1.5.4)

     

       389
       388
        
             mini_portile2 (~> 2.8.0)

     
···

       436
       435
        
         metasploit-framework!

     

       437
       436
        
       

     

       438
       437
        
       BUNDLED WITH

     

       439
       439
       -
          2.3.25

     

       438
       438
       +
          2.3.26

+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.2.30";

     

       18
       18
       +
         version = "6.2.31";

     

       19
       19
        
       

     

       20
       20
        
         src = fetchFromGitHub {

     

       21
       21
        
           owner = "rapid7";

     

       22
       22
        
           repo = "metasploit-framework";

     

       23
       23
        
           rev = version;

     

       24
       24
       -
           sha256 = "sha256-2AEZJoGSWEBCCFabHjqzJyI3zx0PC8da2D3eRlfMKwY=";

     

       24
       24
       +
           sha256 = "sha256-oifgAc1umrEOULuJzK9EboBdXIXSici8ndlhRbbHUaw=";

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         nativeBuildInputs = [ makeWrapper ];

+31 -31

pkgs/tools/security/metasploit/gemset.nix

···

       104
       104
        
           platforms = [];

     

       105
       105
        
           source = {

     

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

     

       107
       107
       -
             sha256 = "0a4inr58vqzqb6g4j09pch55xyhj4kbbl4drsk1apfwhakc70vpr";

     

       107
       107
       +
             sha256 = "0ijs16zjif7zkwi4wd1qffi7c5b1v5b6hnw76h8kh6vgiwj9hmmz";

     

       108
       108
        
             type = "gem";

     

       109
       109
        
           };

     

       110
       110
       -
           version = "1.674.0";

     

       110
       110
       +
           version = "1.679.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 = "1fj3na0i1d50iw6cih2g3k3h9h2hq0n62czppxr0qsw65mwr5h8b";

     

       127
       127
       +
             sha256 = "1x0fg5gp7qcvfhngplb9438jv074llfb9d52jclnik8ibrrmgx8w";

     

       128
       128
        
             type = "gem";

     

       129
       129
        
           };

     

       130
       130
       -
           version = "1.354.0";

     

       130
       130
       +
           version = "1.355.0";

     

       131
       131
        
         };

     

       132
       132
        
         aws-sdk-iam = {

     

       133
       133
        
           groups = ["default"];

     
···

       224
       224
        
           platforms = [];

     

       225
       225
        
           source = {

     

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

     

       227
       227
       -
             sha256 = "183lszf5gx84kcpb779v6a2y0mx9sssy8dgppng1z9a505nj1qcf";

     

       227
       227
       +
             sha256 = "0s4fpn3mqiizpmpy2a24k4v365pv75y50292r8ajrv4i1p5b2k14";

     

       228
       228
        
             type = "gem";

     

       229
       229
        
           };

     

       230
       230
       -
           version = "1.0.5";

     

       230
       230
       +
           version = "1.1.10";

     

       231
       231
        
         };

     

       232
       232
        
         cookiejar = {

     

       233
       233
        
           groups = ["default"];

     
···

       344
       344
        
           platforms = [];

     

       345
       345
        
           source = {

     

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

     

       347
       347
       -
             sha256 = "1wyz9ab0mzi84gpf81fs19vrixglmmxi25k6n1mn9h141qmsp590";

     

       347
       347
       +
             sha256 = "17lacy6n0hsayafvgxgzmngfq2x62b2arbn32bj2yyzmgxwyxhqn";

     

       348
       348
        
             type = "gem";

     

       349
       349
        
           };

     

       350
       350
       -
           version = "2.7.1";

     

       350
       350
       +
           version = "2.7.2";

     

       351
       351
        
         };

     

       352
       352
        
         faraday-net_http = {

     

       353
       353
        
           groups = ["default"];

     
···

       494
       494
        
           platforms = [];

     

       495
       495
        
           source = {

     

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

     

       497
       497
       -
             sha256 = "0r9kxrf9jccrr329pa3s37rf16vy426cbqmfwxkav1fidwvih93y";

     

       497
       497
       +
             sha256 = "0dikardh14c72gd9ypwh8dim41wvqmzfzf35mincaj5yals9m7ff";

     

       498
       498
        
             type = "gem";

     

       499
       499
        
           };

     

       500
       500
       -
           version = "0.5.11";

     

       500
       500
       +
           version = "0.6.0";

     

       501
       501
        
         };

     

       502
       502
        
         irb = {

     

       503
       503
        
           groups = ["default"];

     

       504
       504
        
           platforms = [];

     

       505
       505
        
           source = {

     

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

     

       507
       507
       -
             sha256 = "078jfdkjg8kl82hy3awq0r9vww4allw4zpncm8hl6ccjswppr4jk";

     

       507
       507
       +
             sha256 = "09mbpnmfh5lwg6kcjlbyv9163pn50lfxphbra9rsws8cp04m1qj3";

     

       508
       508
        
             type = "gem";

     

       509
       509
        
           };

     

       510
       510
       -
           version = "1.6.0";

     

       510
       510
       +
           version = "1.6.1";

     

       511
       511
        
         };

     

       512
       512
        
         jmespath = {

     

       513
       513
        
           groups = ["default"];

     
···

       564
       564
        
           platforms = [];

     

       565
       565
        
           source = {

     

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

     

       567
       567
       -
             sha256 = "1fpyk1965py77al7iadkn5dibwgvybknkr7r8bii2dj73wvr29rh";

     

       567
       567
       +
             sha256 = "08qhzck271anrx9y6qa6mh8hwwdzsgwld8q0000rcd7yvvpnjr3c";

     

       568
       568
        
             type = "gem";

     

       569
       569
        
           };

     

       570
       570
       -
           version = "2.19.0";

     

       570
       570
       +
           version = "2.19.1";

     

       571
       571
        
         };

     

       572
       572
        
         metasm = {

     

       573
       573
        
           groups = ["default"];

     
···

       594
       594
        
           platforms = [];

     

       595
       595
        
           source = {

     

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

     

       597
       597
       -
             sha256 = "045aap4wrslclbvm2rczdxlgivyx9ricdbg2z9xk5xamf6cxfrx1";

     

       597
       597
       +
             sha256 = "061zkhiq7gpp0kjk1alaz0r266makzj3ahjzq6j9qxm4z9xiis4d";

     

       598
       598
        
             type = "gem";

     

       599
       599
        
           };

     

       600
       600
       -
           version = "6.0.0";

     

       600
       600
       +
           version = "6.0.1";

     

       601
       601
        
         };

     

       602
       602
        
         metasploit-framework = {

     

       603
       603
        
           groups = ["default"];

     

       604
       604
        
           platforms = [];

     

       605
       605
        
           source = {

     

       606
       606
        
             fetchSubmodules = false;

     

       607
       607
       -
             rev = "21ca4473d2486d30618f99eaee7f3067e136c608";

     

       608
       608
       -
             sha256 = "01ibribldpixv1dcf2qg3p7kf8i7ncx1x6sn11140n4jh4k1j0fq";

     

       607
       607
       +
             rev = "2654f6f02a0ce6150e623804b9fab9576fe008f6";

     

       608
       608
       +
             sha256 = "1b2iqyv4aqfrknyci2fjhmf5v03f8jpwr2dva07b36kfrl0y09x2";

     

       609
       609
        
             type = "git";

     

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

     

       611
       611
        
           };

     

       612
       612
       -
           version = "6.2.30";

     

       612
       612
       +
           version = "6.2.31";

     

       613
       613
        
         };

     

       614
       614
        
         metasploit-model = {

     

       615
       615
        
           groups = ["default"];

     
···

       626
       626
        
           platforms = [];

     

       627
       627
        
           source = {

     

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

     

       629
       629
       -
             sha256 = "0m9w4yy5iwpbbjycpxyhfql2b4dnm4wgcn039aw43igjgfdrkmkz";

     

       629
       629
       +
             sha256 = "1zp4njsk9ybrhjr7pb06nmnm3shmxc69ra2hxvz0bwhq4syr1xsl";

     

       630
       630
        
             type = "gem";

     

       631
       631
        
           };

     

       632
       632
       -
           version = "2.0.101";

     

       632
       632
       +
           version = "2.0.105";

     

       633
       633
        
         };

     

       634
       634
        
         metasploit_data_models = {

     

       635
       635
        
           groups = ["default"];

     
···

       957
       957
        
           platforms = [];

     

       958
       958
        
           source = {

     

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

     

       960
       960
       -
             sha256 = "1kljmw1lhzqjcwnwadr5m2khii0h2lsah447zb9vgirrv5jszg9h";

     

       960
       960
       +
             sha256 = "1a12m1mv8dc0g90fs1myvis8vsgr427k1arg1q4a9qlfw6fqyhis";

     

       961
       961
        
             type = "gem";

     

       962
       962
        
           };

     

       963
       963
       -
           version = "3.0.4";

     

       963
       963
       +
           version = "3.0.5";

     

       964
       964
        
         };

     

       965
       965
        
         rack-test = {

     

       966
       966
        
           groups = ["default"];

     
···

       987
       987
        
           platforms = [];

     

       988
       988
        
           source = {

     

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

     

       990
       990
       -
             sha256 = "1mj0b7ay10a2fgwj70kjw7mlyrp7a5la8lx8zmwhy40bkansdfrf";

     

       990
       990
       +
             sha256 = "1mcb75qvldfz6zsr4inrfx7dmb0ngxy507awx28khqmnla3hqpc9";

     

       991
       991
        
             type = "gem";

     

       992
       992
        
           };

     

       993
       993
       -
           version = "1.4.3";

     

       993
       993
       +
           version = "1.4.4";

     

       994
       994
        
         };

     

       995
       995
        
         railties = {

     

       996
       996
        
           groups = ["default"];

     
···

       1047
       1047
        
           platforms = [];

     

       1048
       1048
        
           source = {

     

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

     

       1050
       1050
       -
             sha256 = "1izlsziflj70kgwfy2d72jfr7bhrzamnhbq8gxjn8xdz0wvdj0di";

     

       1050
       1050
       +
             sha256 = "1vpsmij5mknpiqy4b835rzl87slshm5dkr08hm8wypfya3v4m6cp";

     

       1051
       1051
        
             type = "gem";

     

       1052
       1052
        
           };

     

       1053
       1053
       -
           version = "0.3.1";

     

       1053
       1053
       +
           version = "0.3.2";

     

       1054
       1054
        
         };

     

       1055
       1055
        
         rex-arch = {

     

       1056
       1056
        
           groups = ["default"];

     
···

       1217
       1217
        
           platforms = [];

     

       1218
       1218
        
           source = {

     

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

     

       1220
       1220
       -
             sha256 = "0arm3yakxs541qbm52rxjjd9b3p70sqim7syd83m3vqh366gr67d";

     

       1220
       1220
       +
             sha256 = "06xihmiw7fqbjpxi1zh6hb8whbq45saxllvlk00mjp2l3dn0p7hb";

     

       1221
       1221
        
             type = "gem";

     

       1222
       1222
        
           };

     

       1223
       1223
       -
           version = "0.2.46";

     

       1223
       1223
       +
           version = "0.2.47";

     

       1224
       1224
        
         };

     

       1225
       1225
        
         rex-zip = {

     

       1226
       1226
        
           groups = ["default"];

     
···

       1337
       1337
        
           platforms = [];

     

       1338
       1338
        
           source = {

     

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

     

       1340
       1340
       -
             sha256 = "1lgvrna3wvm21y350hrasdb4w8119cn1fd0prrrj76ws5w0pdzvc";

     

       1340
       1340
       +
             sha256 = "1ryfja9yd3fq8n1p5yi3qnd0pjk7bkycmxxmbb1bj0axlr1pdv20";

     

       1341
       1341
        
             type = "gem";

     

       1342
       1342
        
           };

     

       1343
       1343
       -
           version = "3.0.4";

     

       1343
       1343
       +
           version = "3.0.5";

     

       1344
       1344
        
         };

     

       1345
       1345
        
         sqlite3 = {

     

       1346
       1346
        
           dependencies = ["mini_portile2"];

+2 -2

pkgs/tools/system/logrotate/default.nix

···

       5
       5
        
       

     

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
        
         pname = "logrotate";

     

       8
       8
       -
         version = "3.20.1";

     

       8
       8
       +
         version = "3.21.0";

     

       9
       9
        
       

     

       10
       10
        
         src = fetchFromGitHub {

     

       11
       11
        
           owner = "logrotate";

     

       12
       12
        
           repo = "logrotate";

     

       13
       13
        
           rev = version;

     

       14
       14
       -
           sha256 = "sha256-IegYAV7Mrw9GKMQOE5Bk0J/2ljfHzPlIipyYm3LrUcU=";

     

       14
       14
       +
           sha256 = "sha256-w86y6bz/nvH/0mIbn2XrSs5KdOM/xadnlZMQZp4LdGQ=";

     

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         # Logrotate wants to access the 'mail' program; to be done.

+3 -3

pkgs/tools/text/mdbook-katex/default.nix

···

       2
       2
        
       

     

       3
       3
        
       rustPlatform.buildRustPackage rec {

     

       4
       4
        
         pname = "mdbook-katex";

     

       5
       5
       -
         version = "0.2.17";

     

       5
       5
       +
         version = "0.2.21";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchCrate {

     

       8
       8
        
           inherit pname version;

     

       9
       9
       -
           sha256 = "sha256-rJzZVZn8CJOIcSVLCLv6tWox0MRdxNBMUKo1fij1ogc=";

     

       9
       9
       +
           hash = "sha256-cJRO/HHxujSL5YTM4e+HMRsItlEe1OYn8rSqnwcqbgU=";

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
       -
         cargoHash = "sha256-aSFXTeP5wDshdrrJ+eJCTmLuTlxCuM+5irUr0iW4tAY=";

     

       12
       12
       +
         cargoHash = "sha256-FPoSye+wD/MPR5fCrQ212W4iYoJLWOFXgeStcg0GEHw=";

     

       13
       13
        
       

     

       14
       14
        
         OPENSSL_DIR = "${lib.getDev openssl}";

     

       15
       15
        
         OPENSSL_LIB_DIR = "${lib.getLib openssl}/lib";

+1 -1

pkgs/tools/virtualization/linode-cli/update.sh

···

       9
       9
        
       

     

       10
       10
        
       SPEC_SHA256=$(nix-prefetch-url --quiet https://raw.githubusercontent.com/linode/linode-api-docs/v${SPEC_VERSION}/openapi.yaml)

     

       11
       11
        
       

     

       12
       12
       -
       VERSION=$(curl -s ${GITHUB_TOKEN:+"-u \":$GITHUB_TOKEN\""} \

     

       12
       12
       +
       VERSION=$(curl -s ${GITHUB_TOKEN:+-u ":$GITHUB_TOKEN"} \

     

       13
       13
        
           -H "Accept: application/vnd.github.v3+json" \

     

       14
       14
        
           "https://api.github.com/repos/linode/linode-cli/tags" \

     

       15
       15
        
           | jq 'map(.name)' \

+8 -3

pkgs/top-level/all-packages.nix

···

       15331
       15331
        
         cargo-cache = callPackage ../development/tools/rust/cargo-cache {

     

       15332
       15332
        
           inherit (darwin.apple_sdk.frameworks) Security;

     

       15333
       15333
        
         };

     

       15334
       15334
       +
         cargo-chef = callPackage ../development/tools/rust/cargo-chef { };

     

       15334
       15335
        
         cargo-crev = callPackage ../development/tools/rust/cargo-crev {

     

       15335
       15336
        
           inherit (darwin.apple_sdk.frameworks) Security SystemConfiguration CoreFoundation;

     

       15336
       15337
        
         };

     
···

       17303
       17304
        
       

     

       17304
       17305
        
         gi-docgen = callPackage ../development/tools/documentation/gi-docgen { };

     

       17305
       17306
        
       

     

       17307
       17307
       +
         git2-cpp = callPackage ../development/libraries/git2-cpp { };

     

       17308
       17308
       +
       

     

       17306
       17309
        
         github-release = callPackage ../development/tools/github/github-release { };

     

       17307
       17310
        
       

     

       17308
       17311
        
         global = callPackage ../development/tools/misc/global { };

     
···

       17739
       17742
        
         oprofile = callPackage ../development/tools/profiling/oprofile {

     

       17740
       17743
        
           libiberty_static = libiberty.override { staticBuild = true; };

     

       17741
       17744
        
         };

     

       17745
       17745
       +
       

     

       17746
       17746
       +
         package-project-cmake = callPackage ../development/tools/package-project-cmake { };

     

       17742
       17747
        
       

     

       17743
       17748
        
         pactorio = callPackage ../development/tools/pactorio {

     

       17744
       17749
        
           inherit (darwin.apple_sdk.frameworks) Security;

     
···

       30579
       30584
        
       

     

       30580
       30585
        
         mmsd = callPackage ../tools/networking/mmsd { };

     

       30581
       30586
        
       

     

       30587
       30587
       +
         mmsd-tng = callPackage ../tools/networking/mmsd-tng { };

     

       30588
       30588
       +
       

     

       30582
       30589
        
         mmtc = callPackage ../applications/audio/mmtc { };

     

       30583
       30590
        
       

     

       30584
       30591
        
         mnamer = callPackage ../applications/misc/mnamer { };

     
···

       37180
       37187
        
       

     

       37181
       37188
        
         rucksack = callPackage ../development/tools/rucksack { };

     

       37182
       37189
        
       

     

       37183
       37183
       -
         ruff = callPackage ../development/tools/ruff {

     

       37184
       37184
       -
           inherit (darwin.apple_sdk.frameworks) CoreServices Security;

     

       37185
       37185
       -
         };

     

       37190
       37190
       +
         ruff = callPackage ../development/tools/ruff { };

     

       37186
       37191
        
       

     

       37187
       37192
        
         sam-ba = callPackage ../tools/misc/sam-ba { };

     

       37188
       37193