commit 41c5662cbec9930b337a895c7cb010948d9766a9 · pyrox.dev/nixpkgs

+3 -3

doc/languages-frameworks/beam.section.md

···

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

     

       260
       260
        
           after = [

     

       261
       261
        
             "network.target"

     

       262
       262
       -
             "postgresql.service"

     

       262
       262
       +
             "postgresql.target"

     

       263
       263
        
           ];

     

       264
       264
        
           # note that if you are connecting to a postgres instance on a different host

     

       265
       265
       -
           # postgresql.service should not be included in the requires.

     

       265
       265
       +
           # postgresql.target should not be included in the requires.

     

       266
       266
        
           requires = [

     

       267
       267
        
             "network-online.target"

     

       268
       268
       -
             "postgresql.service"

     

       268
       268
       +
             "postgresql.target"

     

       269
       269
        
           ];

     

       270
       270
        
           description = "my app";

     

       271
       271
        
           environment = {

+5 -13

nixos/doc/manual/redirects.json

···

       1316
       1316
        
         "module-services-postgres-initializing-extra-permissions": [

     

       1317
       1317
        
           "index.html#module-services-postgres-initializing-extra-permissions"

     

       1318
       1318
        
         ],

     

       1319
       1319
       -
         "module-services-postgres-initializing-extra-permissions-superuser": [

     

       1320
       1320
       -
           "index.html#module-services-postgres-initializing-extra-permissions-superuser"

     

       1321
       1321
       -
         ],

     

       1322
       1319
        
         "module-services-postgres-initializing-extra-permissions-superuser-post-start": [

     

       1323
       1323
       -
           "index.html#module-services-postgres-initializing-extra-permissions-superuser-post-start"

     

       1324
       1324
       -
         ],

     

       1325
       1325
       -
         "module-services-postgres-initializing-extra-permissions-superuser-oneshot": [

     

       1326
       1326
       -
           "index.html#module-services-postgres-initializing-extra-permissions-superuser-oneshot"

     

       1327
       1327
       -
         ],

     

       1328
       1328
       -
         "module-services-postgres-initializing-extra-permissions-service-user": [

     

       1320
       1320
       +
           "index.html#module-services-postgres-initializing-extra-permissions-superuser-post-start",

     

       1321
       1321
       +
           "index.html#module-services-postgres-initializing-extra-permissions-superuser",

     

       1322
       1322
       +
           "index.html#module-services-postgres-initializing-extra-permissions-service-user-pre-start",

     

       1329
       1323
        
           "index.html#module-services-postgres-initializing-extra-permissions-service-user"

     

       1330
       1324
        
         ],

     

       1331
       1331
       -
         "module-services-postgres-initializing-extra-permissions-service-user-pre-start": [

     

       1332
       1332
       -
           "index.html#module-services-postgres-initializing-extra-permissions-service-user-pre-start"

     

       1333
       1333
       -
         ],

     

       1334
       1334
       -
         "module-services-postgres-initializing-extra-permissions-service-user-oneshot": [

     

       1325
       1325
       +
         "module-services-postgres-initializing-extra-permissions-superuser-oneshot": [

     

       1326
       1326
       +
           "index.html#module-services-postgres-initializing-extra-permissions-superuser-oneshot",

     

       1335
       1327
        
           "index.html#module-services-postgres-initializing-extra-permissions-service-user-oneshot"

     

       1336
       1328
        
         ],

     

       1337
       1329
        
         "module-services-postgres-authentication": [

+2

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

···

       64
       64
        
       

     

       65
       65
        
       - The `yeahwm` package and `services.xserver.windowManager.yeahwm` module were removed due to the package being broken and unmaintained upstream.

     

       66
       66
        
       

     

       67
       67
       +
       - The `services.postgresql` module now sets up a systemd unit `postgresql.target`. Depending on `postgresql.target` guarantees that initial/ensure scripts were executed.

     

       68
       68
       +
       

     

       67
       69
        
       - The `services.siproxd` module has been removed as `siproxd` is unmaintained and broken with libosip 5.x.

     

       68
       70
        
       

     

       69
       71
        
       - `services.dwm-status.extraConfig` was replaced by [RFC0042](https://github.com/NixOS/rfcs/blob/master/rfcs/0042-config-option.md)-compliant [](#opt-services.dwm-status.settings), which is used to generate the config file. `services.dwm-status.order` is now moved to [](#opt-services.dwm-status.settings.order), as it's a part of the config file.

+1 -1

nixos/modules/services/admin/pgadmin.nix

···

       182
       182
        
             requires = [ "network.target" ];

     

       183
       183
        
             # we're adding this optionally so just in case there's any race it'll be caught

     

       184
       184
        
             # in case postgres doesn't start, pgadmin will just start normally

     

       185
       185
       -
             wants = [ "postgresql.service" ];

     

       185
       185
       +
             wants = [ "postgresql.target" ];

     

       186
       186
        
       

     

       187
       187
        
             path = [

     

       188
       188
        
               config.services.postgresql.package

+1 -1

nixos/modules/services/backup/bacula.nix

···

       720
       720
        
           systemd.services.bacula-dir = mkIf dir_cfg.enable {

     

       721
       721
        
             after = [

     

       722
       722
        
               "network.target"

     

       723
       723
       -
               "postgresql.service"

     

       723
       723
       +
               "postgresql.target"

     

       724
       724
        
             ];

     

       725
       725
        
             description = "Bacula Director Daemon";

     

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

+1 -1

nixos/modules/services/backup/postgresql-backup.nix

···

       35
       35
        
       

     

       36
       36
        
             description = "Backup of ${db} database(s)";

     

       37
       37
        
       

     

       38
       38
       -
             requires = [ "postgresql.service" ];

     

       38
       38
       +
             requires = [ "postgresql.target" ];

     

       39
       39
        
       

     

       40
       40
        
             path = [

     

       41
       41
        
               pkgs.coreutils

+2 -2

nixos/modules/services/continuous-integration/hydra/default.nix

···

       334
       334
        
       

     

       335
       335
        
           systemd.services.hydra-init = {

     

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

     

       337
       337
       -
             requires = lib.optional haveLocalDB "postgresql.service";

     

       338
       338
       -
             after = lib.optional haveLocalDB "postgresql.service";

     

       337
       337
       +
             requires = lib.optional haveLocalDB "postgresql.target";

     

       338
       338
       +
             after = lib.optional haveLocalDB "postgresql.target";

     

       339
       339
        
             environment = env // {

     

       340
       340
        
               HYDRA_DBI = "${env.HYDRA_DBI};application_name=hydra-init";

     

       341
       341
        
             };

+2 -2

nixos/modules/services/databases/pgmanage.nix

···

       185
       185
        
         config = lib.mkIf cfg.enable {

     

       186
       186
        
           systemd.services.pgmanage = {

     

       187
       187
        
             description = "pgmanage - PostgreSQL Administration for the web";

     

       188
       188
       -
             wants = [ "postgresql.service" ];

     

       189
       189
       -
             after = [ "postgresql.service" ];

     

       188
       188
       +
             wants = [ "postgresql.target" ];

     

       189
       189
       +
             after = [ "postgresql.target" ];

     

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

     

       191
       191
        
             serviceConfig = {

     

       192
       192
        
               User = pgmanage;

+1 -1

nixos/modules/services/databases/postgres-websockets.nix

···

       156
       156
        
             wants = [ "network-online.target" ];

     

       157
       157
        
             after = [

     

       158
       158
        
               "network-online.target"

     

       159
       159
       -
               "postgresql.service"

     

       159
       159
       +
               "postgresql.target"

     

       160
       160
        
             ];

     

       161
       161
        
       

     

       162
       162
        
             environment =

+10 -59

nixos/modules/services/databases/postgresql.md

···

       89
       89
        
       

     

       90
       90
        
       **NOTE:** please make sure that any added migrations are idempotent (re-runnable).

     

       91
       91
        
       

     

       92
       92
       -
       #### as superuser {#module-services-postgres-initializing-extra-permissions-superuser}

     

       93
       93
       -
       

     

       94
       94
       -
       **Advantage:** compatible with postgres < 15, because it's run

     

       95
       95
       -
       as the database superuser `postgres`.

     

       92
       92
       +
       #### in database's setup `postStart` {#module-services-postgres-initializing-extra-permissions-superuser-post-start}

     

       96
       93
        
       

     

       97
       97
       -
       ##### in database `postStart` {#module-services-postgres-initializing-extra-permissions-superuser-post-start}

     

       98
       98
       -
       

     

       99
       99
       -
       **Disadvantage:** need to take care of ordering yourself. In this

     

       100
       100
       -
       example, `mkAfter` ensures that permissions are assigned after any

     

       101
       101
       -
       databases from `ensureDatabases` and `extraUser1` from `ensureUsers`

     

       102
       102
       -
       are already created.

     

       94
       94
       +
       `ensureUsers` is run in `postgresql-setup`, so this is where `postStart` must be added to:

     

       103
       95
        
       

     

       104
       96
        
       ```nix

     

       105
       97
        
         {

     

       106
       106
       -
           systemd.services.postgresql.postStart = lib.mkAfter ''

     

       107
       107
       -
             $PSQL service1 -c 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "extraUser1"'

     

       108
       108
       -
             $PSQL service1 -c 'GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO "extraUser1"'

     

       98
       98
       +
           systemd.services.postgresql-setup.postStart = ''

     

       99
       99
       +
             psql service1 -c 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "extraUser1"'

     

       100
       100
       +
             psql service1 -c 'GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO "extraUser1"'

     

       109
       101
        
             # ....

     

       110
       102
        
           '';

     

       111
       103
        
         }

     

       112
       104
        
       ```

     

       113
       105
        
       

     

       114
       114
       -
       ##### in intermediate oneshot service {#module-services-postgres-initializing-extra-permissions-superuser-oneshot}

     

       106
       106
       +
       #### in intermediate oneshot service {#module-services-postgres-initializing-extra-permissions-superuser-oneshot}

     

       115
       107
        
       

     

       116
       108
        
       ```nix

     

       117
       109
        
         {

     
···

       119
       111
        
             serviceConfig.Type = "oneshot";

     

       120
       112
        
             requiredBy = "service1.service";

     

       121
       113
        
             before = "service1.service";

     

       122
       122
       -
             after = "postgresql.service";

     

       114
       114
       +
             after = "postgresql.target";

     

       123
       115
        
             serviceConfig.User = "postgres";

     

       124
       124
       -
             environment.PSQL = "psql --port=${toString services.postgresql.settings.port}";

     

       116
       116
       +
             environment.PGPORT = toString services.postgresql.settings.port;

     

       125
       117
        
             path = [ postgresql ];

     

       126
       118
        
             script = ''

     

       127
       127
       -
               $PSQL service1 -c 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "extraUser1"'

     

       128
       128
       -
               $PSQL service1 -c 'GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO "extraUser1"'

     

       129
       129
       -
               # ....

     

       130
       130
       -
             '';

     

       131
       131
       -
           };

     

       132
       132
       -
         }

     

       133
       133
       -
       ```

     

       134
       134
       -
       

     

       135
       135
       -
       #### as service user {#module-services-postgres-initializing-extra-permissions-service-user}

     

       136
       136
       -
       

     

       137
       137
       -
       **Advantage:** re-uses systemd's dependency ordering;

     

       138
       138
       -
       

     

       139
       139
       -
       **Disadvantage:** relies on service user having grant permission. To be combined with `ensureDBOwnership`.

     

       140
       140
       -
       

     

       141
       141
       -
       ##### in service `preStart` {#module-services-postgres-initializing-extra-permissions-service-user-pre-start}

     

       142
       142
       -
       

     

       143
       143
       -
       ```nix

     

       144
       144
       -
         {

     

       145
       145
       -
           environment.PSQL = "psql --port=${toString services.postgresql.settings.port}";

     

       146
       146
       -
           path = [ postgresql ];

     

       147
       147
       -
           systemd.services."service1".preStart = ''

     

       148
       148
       -
             $PSQL -c 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "extraUser1"'

     

       149
       149
       -
             $PSQL -c 'GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO "extraUser1"'

     

       150
       150
       -
             # ....

     

       151
       151
       -
           '';

     

       152
       152
       -
         }

     

       153
       153
       -
       ```

     

       154
       154
       -
       

     

       155
       155
       -
       ##### in intermediate oneshot service {#module-services-postgres-initializing-extra-permissions-service-user-oneshot}

     

       156
       156
       -
       

     

       157
       157
       -
       ```nix

     

       158
       158
       -
         {

     

       159
       159
       -
           systemd.services."migrate-service1-db1" = {

     

       160
       160
       -
             serviceConfig.Type = "oneshot";

     

       161
       161
       -
             requiredBy = "service1.service";

     

       162
       162
       -
             before = "service1.service";

     

       163
       163
       -
             after = "postgresql.service";

     

       164
       164
       -
             serviceConfig.User = "service1";

     

       165
       165
       -
             environment.PSQL = "psql --port=${toString services.postgresql.settings.port}";

     

       166
       166
       -
             path = [ postgresql ];

     

       167
       167
       -
             script = ''

     

       168
       168
       -
               $PSQL -c 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "extraUser1"'

     

       169
       169
       -
               $PSQL -c 'GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO "extraUser1"'

     

       119
       119
       +
               psql service1 -c 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "extraUser1"'

     

       120
       120
       +
               psql service1 -c 'GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO "extraUser1"'

     

       170
       121
        
               # ....

     

       171
       122
        
             '';

     

       172
       123
        
           };

+70 -44

nixos/modules/services/databases/postgresql.nix

···

       751
       751
        
             cfg.checkConfig && pkgs.stdenv.hostPlatform == pkgs.stdenv.buildPlatform

     

       752
       752
        
           ) configFileCheck;

     

       753
       753
        
       

     

       754
       754
       +
           systemd.targets.postgresql = {

     

       755
       755
       +
             description = "PostgreSQL";

     

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

     

       757
       757
       +
             bindsTo = [

     

       758
       758
       +
               "postgresql.service"

     

       759
       759
       +
               "postgresql-setup.service"

     

       760
       760
       +
             ];

     

       761
       761
       +
           };

     

       762
       762
       +
       

     

       754
       763
        
           systemd.services.postgresql = {

     

       755
       764
        
             description = "PostgreSQL Server";

     

       756
       765
        
       

     

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

     

       758
       766
        
             after = [ "network.target" ];

     

       767
       767
       +
       

     

       768
       768
       +
             # To trigger the .target also on "systemctl start postgresql".

     

       769
       769
       +
             bindsTo = [ "postgresql.target" ];

     

       759
       770
        
       

     

       760
       771
        
             environment.PGDATA = cfg.dataDir;

     

       761
       772
        
       

     
···

       775
       786
        
       

     

       776
       787
        
               ln -sfn "${configFile}/postgresql.conf" "${cfg.dataDir}/postgresql.conf"

     

       777
       788
        
             '';

     

       778
       778
       -
       

     

       779
       779
       -
             # Wait for PostgreSQL to be ready to accept connections.

     

       780
       780
       -
             postStart =

     

       781
       781
       -
               ''

     

       782
       782
       -
                 PSQL="psql --port=${builtins.toString cfg.settings.port}"

     

       783
       783
       -
       

     

       784
       784
       -
                 while ! $PSQL -d postgres -c "" 2> /dev/null; do

     

       785
       785
       -
                     if ! kill -0 "$MAINPID"; then exit 1; fi

     

       786
       786
       -
                     sleep 0.1

     

       787
       787
       -
                 done

     

       788
       788
       -
       

     

       789
       789
       -
                 if test -e "${cfg.dataDir}/.first_startup"; then

     

       790
       790
       -
                   ${optionalString (cfg.initialScript != null) ''

     

       791
       791
       -
                     $PSQL -f "${cfg.initialScript}" -d postgres

     

       792
       792
       -
                   ''}

     

       793
       793
       -
                   rm -f "${cfg.dataDir}/.first_startup"

     

       794
       794
       -
                 fi

     

       795
       795
       -
               ''

     

       796
       796
       -
               + optionalString (cfg.ensureDatabases != [ ]) ''

     

       797
       797
       -
                 ${concatMapStrings (database: ''

     

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

     

       799
       799
       -
                 '') cfg.ensureDatabases}

     

       800
       800
       -
               ''

     

       801
       801
       -
               + ''

     

       802
       802
       -
                 ${concatMapStrings (

     

       803
       803
       -
                   user:

     

       804
       804
       -
                   let

     

       805
       805
       -
                     dbOwnershipStmt = optionalString user.ensureDBOwnership ''$PSQL -tAc 'ALTER DATABASE "${user.name}" OWNER TO "${user.name}";' '';

     

       806
       806
       -
       

     

       807
       807
       -
                     filteredClauses = filterAttrs (name: value: value != null) user.ensureClauses;

     

       808
       808
       -
       

     

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

     

       810
       810
       -
       

     

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

     

       812
       812
       -
                   in

     

       813
       813
       -
                   ''

     

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

     

       815
       815
       -
                     ${userClauses}

     

       816
       816
       -
       

     

       817
       817
       -
                     ${dbOwnershipStmt}

     

       818
       818
       -
                   ''

     

       819
       819
       -
                 ) cfg.ensureUsers}

     

       820
       820
       -
               '';

     

       821
       789
        
       

     

       822
       790
        
             serviceConfig = mkMerge [

     

       823
       791
        
               {

     
···

       890
       858
        
             ];

     

       891
       859
        
       

     

       892
       860
        
             unitConfig.RequiresMountsFor = "${cfg.dataDir}";

     

       861
       861
       +
           };

     

       862
       862
       +
       

     

       863
       863
       +
           systemd.services.postgresql-setup = {

     

       864
       864
       +
             description = "PostgreSQL Setup Scripts";

     

       865
       865
       +
       

     

       866
       866
       +
             requires = [ "postgresql.service" ];

     

       867
       867
       +
             after = [ "postgresql.service" ];

     

       868
       868
       +
       

     

       869
       869
       +
             serviceConfig = {

     

       870
       870
       +
               User = "postgres";

     

       871
       871
       +
               Group = "postgres";

     

       872
       872
       +
               Type = "oneshot";

     

       873
       873
       +
               RemainAfterExit = true;

     

       874
       874
       +
             };

     

       875
       875
       +
       

     

       876
       876
       +
             path = [ cfg.finalPackage ];

     

       877
       877
       +
             environment.PGPORT = builtins.toString cfg.settings.port;

     

       878
       878
       +
       

     

       879
       879
       +
             # Wait for PostgreSQL to be ready to accept connections.

     

       880
       880
       +
             script =

     

       881
       881
       +
               ''

     

       882
       882
       +
                 while ! psql -d postgres -c "" 2> /dev/null; do

     

       883
       883
       +
                     if ! systemctl is-active --quiet postgresql.service; then exit 1; fi

     

       884
       884
       +
                     sleep 0.1

     

       885
       885
       +
                 done

     

       886
       886
       +
       

     

       887
       887
       +
                 if test -e "${cfg.dataDir}/.first_startup"; then

     

       888
       888
       +
                   ${optionalString (cfg.initialScript != null) ''

     

       889
       889
       +
                     psql -f "${cfg.initialScript}" -d postgres

     

       890
       890
       +
                   ''}

     

       891
       891
       +
                   rm -f "${cfg.dataDir}/.first_startup"

     

       892
       892
       +
                 fi

     

       893
       893
       +
               ''

     

       894
       894
       +
               + optionalString (cfg.ensureDatabases != [ ]) ''

     

       895
       895
       +
                 ${concatMapStrings (database: ''

     

       896
       896
       +
                   psql -tAc "SELECT 1 FROM pg_database WHERE datname = '${database}'" | grep -q 1 || psql -tAc 'CREATE DATABASE "${database}"'

     

       897
       897
       +
                 '') cfg.ensureDatabases}

     

       898
       898
       +
               ''

     

       899
       899
       +
               + ''

     

       900
       900
       +
                 ${concatMapStrings (

     

       901
       901
       +
                   user:

     

       902
       902
       +
                   let

     

       903
       903
       +
                     dbOwnershipStmt = optionalString user.ensureDBOwnership ''psql -tAc 'ALTER DATABASE "${user.name}" OWNER TO "${user.name}";' '';

     

       904
       904
       +
       

     

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

     

       906
       906
       +
       

     

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

     

       908
       908
       +
       

     

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

     

       910
       910
       +
                   in

     

       911
       911
       +
                   ''

     

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

     

       913
       913
       +
                     ${userClauses}

     

       914
       914
       +
       

     

       915
       915
       +
                     ${dbOwnershipStmt}

     

       916
       916
       +
                   ''

     

       917
       917
       +
                 ) cfg.ensureUsers}

     

       918
       918
       +
               '';

     

       893
       919
        
           };

     

       894
       920
        
         };

     

       895
       921

+1 -1

nixos/modules/services/databases/postgrest.nix

···

       256
       256
        
             wants = [ "network-online.target" ];

     

       257
       257
        
             after = [

     

       258
       258
        
               "network-online.target"

     

       259
       259
       -
               "postgresql.service"

     

       259
       259
       +
               "postgresql.target"

     

       260
       260
        
             ];

     

       261
       261
        
       

     

       262
       262
        
             serviceConfig = {

+2 -2

nixos/modules/services/development/zammad.nix

···

       275
       275
        
                 "systemd-tmpfiles-setup.service"

     

       276
       276
        
               ]

     

       277
       277
        
               ++ lib.optionals (cfg.database.createLocally) [

     

       278
       278
       -
                 "postgresql.service"

     

       278
       278
       +
                 "postgresql.target"

     

       279
       279
        
               ]

     

       280
       280
        
               ++ lib.optionals cfg.redis.createLocally [

     

       281
       281
        
                 "redis-${cfg.redis.name}.service"

     

       282
       282
        
               ];

     

       283
       283
        
             requires = lib.optionals (cfg.database.createLocally) [

     

       284
       284
       -
               "postgresql.service"

     

       284
       284
       +
               "postgresql.target"

     

       285
       285
        
             ];

     

       286
       286
        
             description = "Zammad web";

     

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

+2 -2

nixos/modules/services/finance/libeufin/common.nix

···

       123
       123
        
                         echo "Bank initialisation complete"

     

       124
       124
        
                       fi

     

       125
       125
        
                     '';

     

       126
       126
       -
                   requires = lib.optionals cfg.createLocalDatabase [ "postgresql.service" ];

     

       127
       127
       -
                   after = [ "network.target" ] ++ lib.optionals cfg.createLocalDatabase [ "postgresql.service" ];

     

       126
       126
       +
                   requires = lib.optionals cfg.createLocalDatabase [ "postgresql.target" ];

     

       127
       127
       +
                   after = [ "network.target" ] ++ lib.optionals cfg.createLocalDatabase [ "postgresql.target" ];

     

       128
       128
        
                 };

     

       129
       129
        
             };

     

       130
       130

+2 -2

nixos/modules/services/finance/odoo.nix

···

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

     

       120
       120
        
               after = [

     

       121
       121
        
                 "network.target"

     

       122
       122
       -
                 "postgresql.service"

     

       122
       122
       +
                 "postgresql.target"

     

       123
       123
        
               ];

     

       124
       124
        
       

     

       125
       125
        
               # pg_dump

     

       126
       126
        
               path = [ config.services.postgresql.package ];

     

       127
       127
        
       

     

       128
       128
       -
               requires = [ "postgresql.service" ];

     

       128
       128
       +
               requires = [ "postgresql.target" ];

     

       129
       129
        
       

     

       130
       130
        
               serviceConfig = {

     

       131
       131
        
                 ExecStart = "${cfg.package}/bin/odoo";

+2 -2

nixos/modules/services/finance/taler/common.nix

···

       89
       89
        
                   Restart = "on-failure";

     

       90
       90
        
                   RestartSec = "5s";

     

       91
       91
        
                 };

     

       92
       92
       -
                 requires = [ "postgresql.service" ];

     

       93
       93
       -
                 after = [ "postgresql.service" ];

     

       92
       92
       +
                 requires = [ "postgresql.target" ];

     

       93
       93
       +
                 after = [ "postgresql.target" ];

     

       94
       94
        
               };

     

       95
       95
        
             }

     

       96
       96
        
           ];

+1 -1

nixos/modules/services/home-automation/home-assistant.nix

···

       623
       623
        
       

     

       624
       624
        
               # prevent races with database creation

     

       625
       625
        
               "mysql.service"

     

       626
       626
       -
               "postgresql.service"

     

       626
       626
       +
               "postgresql.target"

     

       627
       627
        
             ];

     

       628
       628
        
             reloadTriggers =

     

       629
       629
        
               optionals (cfg.config != null) [ configFile ]

+1 -1

nixos/modules/services/mail/dspam.nix

···

       107
       107
        
               systemd.services.dspam = {

     

       108
       108
        
                 description = "dspam spam filtering daemon";

     

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

     

       110
       110
       -
                 after = [ "postgresql.service" ];

     

       110
       110
       +
                 after = [ "postgresql.target" ];

     

       111
       111
        
                 restartTriggers = [ cfgfile ];

     

       112
       112
        
       

     

       113
       113
        
                 serviceConfig = {

+1 -1

nixos/modules/services/mail/listmonk.nix

···

       193
       193
        
       

     

       194
       194
        
           systemd.services.listmonk = {

     

       195
       195
        
             description = "Listmonk - newsletter and mailing list manager";

     

       196
       196
       -
             after = [ "network.target" ] ++ lib.optional cfg.database.createLocally "postgresql.service";

     

       196
       196
       +
             after = [ "network.target" ] ++ lib.optional cfg.database.createLocally "postgresql.target";

     

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

     

       198
       198
        
             serviceConfig = {

     

       199
       199
        
               Type = "exec";

+6 -6

nixos/modules/services/mail/mailman.nix

···

       575
       575
        
                 after =

     

       576
       576
        
                   [ "network.target" ]

     

       577
       577
        
                   ++ lib.optional cfg.enablePostfix "postfix-setup.service"

     

       578
       578
       -
                   ++ lib.optional withPostgresql "postgresql.service";

     

       578
       578
       +
                   ++ lib.optional withPostgresql "postgresql.target";

     

       579
       579
        
                 restartTriggers = [ mailmanCfgFile ];

     

       580
       580
       -
                 requires = lib.optional withPostgresql "postgresql.service";

     

       580
       580
       +
                 requires = lib.optional withPostgresql "postgresql.target";

     

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

     

       582
       582
        
                 serviceConfig = {

     

       583
       583
        
                   ExecStart = "${mailmanEnv}/bin/mailman start";

     
···

       609
       609
        
                   "hyperkitty.service"

     

       610
       610
        
                 ];

     

       611
       611
        
                 path = with pkgs; [ jq ];

     

       612
       612
       -
                 after = lib.optional withPostgresql "postgresql.service";

     

       613
       613
       -
                 requires = lib.optional withPostgresql "postgresql.service";

     

       612
       612
       +
                 after = lib.optional withPostgresql "postgresql.target";

     

       613
       613
       +
                 requires = lib.optional withPostgresql "postgresql.target";

     

       614
       614
        
                 serviceConfig.RemainAfterExit = true;

     

       615
       615
        
                 serviceConfig.Type = "oneshot";

     

       616
       616
        
                 script = ''

     
···

       709
       709
        
                 in

     

       710
       710
        
                 {

     

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

     

       712
       712
       -
                   after = lib.optional withPostgresql "postgresql.service";

     

       712
       712
       +
                   after = lib.optional withPostgresql "postgresql.target";

     

       713
       713
        
                   requires = [

     

       714
       714
        
                     "mailman-uwsgi.socket"

     

       715
       715
        
                     "mailman-web-setup.service"

     

       716
       716
       -
                   ] ++ lib.optional withPostgresql "postgresql.service";

     

       716
       716
       +
                   ] ++ lib.optional withPostgresql "postgresql.target";

     

       717
       717
        
                   restartTriggers = [ config.environment.etc."mailman3/settings.py".source ];

     

       718
       718
        
                   serviceConfig = {

     

       719
       719
        
                     # Since the mailman-web settings.py obstinately creates a logs

+2 -2

nixos/modules/services/mail/postfixadmin.nix

···

       148
       148
        
           # objects owners and extensions; for now we tack on what's needed

     

       149
       149
        
           # here.

     

       150
       150
        
           systemd.services.postfixadmin-postgres = lib.mkIf localDB {

     

       151
       151
       -
             after = [ "postgresql.service" ];

     

       152
       152
       -
             bindsTo = [ "postgresql.service" ];

     

       151
       151
       +
             after = [ "postgresql.target" ];

     

       152
       152
       +
             bindsTo = [ "postgresql.target" ];

     

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

     

       154
       154
        
             path = [

     

       155
       155
        
               pgsql.package

+2 -2

nixos/modules/services/mail/roundcube.nix

···

       273
       273
        
       

     

       274
       274
        
           systemd.services.roundcube-setup = lib.mkMerge [

     

       275
       275
        
             (lib.mkIf localDB {

     

       276
       276
       -
               requires = [ "postgresql.service" ];

     

       277
       277
       -
               after = [ "postgresql.service" ];

     

       276
       276
       +
               requires = [ "postgresql.target" ];

     

       277
       277
       +
               after = [ "postgresql.target" ];

     

       278
       278
        
             })

     

       279
       279
        
             {

     

       280
       280
        
               wants = [ "network-online.target" ];

+1 -1

nixos/modules/services/matrix/appservice-irc.nix

···

       196
       196
        
             description = "Matrix-IRC bridge";

     

       197
       197
        
             before = [ "matrix-synapse.service" ]; # So the registration can be used by Synapse

     

       198
       198
        
             after = lib.optionals (cfg.settings.database.engine == "postgres") [

     

       199
       199
       -
               "postgresql.service"

     

       199
       199
       +
               "postgresql.target"

     

       200
       200
        
             ];

     

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

     

       202
       202

+1 -1

nixos/modules/services/matrix/maubot.nix

···

       440
       440
        
       

     

       441
       441
        
           systemd.services.maubot = rec {

     

       442
       442
        
             description = "maubot - a plugin-based Matrix bot system written in Python";

     

       443
       443
       -
             after = [ "network.target" ] ++ wants ++ lib.optional hasLocalPostgresDB "postgresql.service";

     

       443
       443
       +
             after = [ "network.target" ] ++ wants ++ lib.optional hasLocalPostgresDB "postgresql.target";

     

       444
       444
        
             # all plugins get automatically disabled if maubot starts before synapse

     

       445
       445
        
             wants = lib.optional config.services.matrix-synapse.enable config.services.matrix-synapse.serviceUnit;

     

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

+1 -1

nixos/modules/services/matrix/synapse-auto-compressor.nix

···

       119
       119
        
           systemd.services.synapse-auto-compressor = {

     

       120
       120
        
             description = "synapse-auto-compressor";

     

       121
       121
        
             requires = lib.optionals synapseUsesLocalPostgresql [

     

       122
       122
       -
               "postgresql.service"

     

       122
       122
       +
               "postgresql.target"

     

       123
       123
        
             ];

     

       124
       124
        
             inherit (cfg) startAt;

     

       125
       125
        
             serviceConfig = {

+4 -4

nixos/modules/services/matrix/synapse.nix

···

       1439
       1439
        
           systemd.targets.matrix-synapse = lib.mkIf hasWorkers {

     

       1440
       1440
        
             description = "Synapse Matrix parent target";

     

       1441
       1441
        
             wants = [ "network-online.target" ];

     

       1442
       1442
       -
             after = [ "network-online.target" ] ++ optional hasLocalPostgresDB "postgresql.service";

     

       1442
       1442
       +
             after = [ "network-online.target" ] ++ optional hasLocalPostgresDB "postgresql.target";

     

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

     

       1444
       1444
        
           };

     

       1445
       1445
        
       

     
···

       1451
       1451
        
                     partOf = [ "matrix-synapse.target" ];

     

       1452
       1452
        
                     wantedBy = [ "matrix-synapse.target" ];

     

       1453
       1453
        
                     unitConfig.ReloadPropagatedFrom = "matrix-synapse.target";

     

       1454
       1454
       -
                     requires = optional hasLocalPostgresDB "postgresql.service";

     

       1454
       1454
       +
                     requires = optional hasLocalPostgresDB "postgresql.target";

     

       1455
       1455
        
                   }

     

       1456
       1456
        
                 else

     

       1457
       1457
        
                   {

     

       1458
       1458
        
                     wants = [ "network-online.target" ];

     

       1459
       1459
       -
                     after = [ "network-online.target" ] ++ optional hasLocalPostgresDB "postgresql.service";

     

       1460
       1460
       -
                     requires = optional hasLocalPostgresDB "postgresql.service";

     

       1459
       1459
       +
                     after = [ "network-online.target" ] ++ optional hasLocalPostgresDB "postgresql.target";

     

       1460
       1460
       +
                     requires = optional hasLocalPostgresDB "postgresql.target";

     

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

     

       1462
       1462
        
                   };

     

       1463
       1463
        
               baseServiceConfig = {

+3 -3

nixos/modules/services/misc/atuin.nix

···

       92
       92
        
       

     

       93
       93
        
           systemd.services.atuin = {

     

       94
       94
        
             description = "atuin server";

     

       95
       95
       -
             requires = lib.optionals cfg.database.createLocally [ "postgresql.service" ];

     

       95
       95
       +
             requires = lib.optionals cfg.database.createLocally [ "postgresql.target" ];

     

       96
       96
        
             after = [

     

       97
       97
        
               "network-online.target"

     

       98
       98
       -
             ] ++ lib.optionals cfg.database.createLocally [ "postgresql.service" ];

     

       98
       98
       +
             ] ++ lib.optionals cfg.database.createLocally [ "postgresql.target" ];

     

       99
       99
        
             wants = [

     

       100
       100
        
               "network-online.target"

     

       101
       101
       -
             ] ++ lib.optionals cfg.database.createLocally [ "postgresql.service" ];

     

       101
       101
       +
             ] ++ lib.optionals cfg.database.createLocally [ "postgresql.target" ];

     

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

     

       103
       103
        
       

     

       104
       104
        
             serviceConfig = {

+1 -1

nixos/modules/services/misc/disnix.nix

···

       77
       77
        
                 [ "dbus.service" ]

     

       78
       78
        
                 ++ lib.optional config.services.httpd.enable "httpd.service"

     

       79
       79
        
                 ++ lib.optional config.services.mysql.enable "mysql.service"

     

       80
       80
       -
                 ++ lib.optional config.services.postgresql.enable "postgresql.service"

     

       80
       80
       +
                 ++ lib.optional config.services.postgresql.enable "postgresql.target"

     

       81
       81
        
                 ++ lib.optional config.services.tomcat.enable "tomcat.service"

     

       82
       82
        
                 ++ lib.optional config.services.svnserve.enable "svnserve.service"

     

       83
       83
        
                 ++ lib.optional config.services.mongodb.enable "mongodb.service"

+2 -2

nixos/modules/services/misc/forgejo.nix

···

       663
       663
        
                 "network.target"

     

       664
       664
        
               ]

     

       665
       665
        
               ++ optionals usePostgresql [

     

       666
       666
       -
                 "postgresql.service"

     

       666
       666
       +
                 "postgresql.target"

     

       667
       667
        
               ]

     

       668
       668
        
               ++ optionals useMysql [

     

       669
       669
        
                 "mysql.service"

     
···

       673
       673
        
               ];

     

       674
       674
        
             requires =

     

       675
       675
        
               optionals (cfg.database.createDatabase && usePostgresql) [

     

       676
       676
       -
                 "postgresql.service"

     

       676
       676
       +
                 "postgresql.target"

     

       677
       677
        
               ]

     

       678
       678
        
               ++ optionals (cfg.database.createDatabase && useMysql) [

     

       679
       679
        
                 "mysql.service"

+1 -1

nixos/modules/services/misc/gammu-smsd.nix

···

       238
       238
        
       

     

       239
       239
        
             wants =

     

       240
       240
        
               with cfg.backend;

     

       241
       241
       -
               [ ] ++ lib.optionals (service == "sql" && sql.driver == "native_pgsql") [ "postgresql.service" ];

     

       241
       241
       +
               [ ] ++ lib.optionals (service == "sql" && sql.driver == "native_pgsql") [ "postgresql.target" ];

     

       242
       242
        
       

     

       243
       243
        
             preStart =

     

       244
       244
        
               with cfg.backend;

+2 -2

nixos/modules/services/misc/gitea.nix

···

       758
       758
        
             description = "gitea";

     

       759
       759
        
             after =

     

       760
       760
        
               [ "network.target" ]

     

       761
       761
       -
               ++ optional usePostgresql "postgresql.service"

     

       761
       761
       +
               ++ optional usePostgresql "postgresql.target"

     

       762
       762
        
               ++ optional useMysql "mysql.service";

     

       763
       763
        
             requires =

     

       764
       764
       -
               optional (cfg.database.createDatabase && usePostgresql) "postgresql.service"

     

       764
       764
       +
               optional (cfg.database.createDatabase && usePostgresql) "postgresql.target"

     

       765
       765
        
               ++ optional (cfg.database.createDatabase && useMysql) "mysql.service";

     

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

     

       767
       767
        
             path = [

+9 -9

nixos/modules/services/misc/gitlab.nix

···

       1295
       1295
        
               pgsql = config.services.postgresql;

     

       1296
       1296
        
             in

     

       1297
       1297
        
             mkIf databaseActuallyCreateLocally {

     

       1298
       1298
       -
               after = [ "postgresql.service" ];

     

       1299
       1299
       -
               bindsTo = [ "postgresql.service" ];

     

       1298
       1298
       +
               after = [ "postgresql.target" ];

     

       1299
       1299
       +
               bindsTo = [ "postgresql.target" ];

     

       1300
       1300
        
               wantedBy = [ "gitlab.target" ];

     

       1301
       1301
        
               partOf = [ "gitlab.target" ];

     

       1302
       1302
        
               path = [

     
···

       1561
       1561
        
           systemd.services.gitlab-db-config = {

     

       1562
       1562
        
             after = [

     

       1563
       1563
        
               "gitlab-config.service"

     

       1564
       1564
       -
               "gitlab-postgresql.service"

     

       1565
       1565
       -
               "postgresql.service"

     

       1564
       1564
       +
               "gitlab-postgresql.target"

     

       1565
       1565
       +
               "postgresql.target"

     

       1566
       1566
        
             ];

     

       1567
       1567
        
             wants =

     

       1568
       1568
       -
               optional (cfg.databaseHost == "") "postgresql.service"

     

       1569
       1569
       -
               ++ optional databaseActuallyCreateLocally "gitlab-postgresql.service";

     

       1568
       1568
       +
               optional (cfg.databaseHost == "") "postgresql.target"

     

       1569
       1569
       +
               ++ optional databaseActuallyCreateLocally "gitlab-postgresql.target";

     

       1570
       1570
        
             bindsTo = [ "gitlab-config.service" ];

     

       1571
       1571
        
             wantedBy = [ "gitlab.target" ];

     

       1572
       1572
        
             partOf = [ "gitlab.target" ];

     
···

       1596
       1596
        
             after = [

     

       1597
       1597
        
               "network.target"

     

       1598
       1598
        
               "redis-gitlab.service"

     

       1599
       1599
       -
               "postgresql.service"

     

       1599
       1599
       +
               "postgresql.target"

     

       1600
       1600
        
               "gitlab-config.service"

     

       1601
       1601
        
               "gitlab-db-config.service"

     

       1602
       1602
        
             ];

     
···

       1604
       1604
        
               "gitlab-config.service"

     

       1605
       1605
        
               "gitlab-db-config.service"

     

       1606
       1606
        
             ];

     

       1607
       1607
       -
             wants = [ "redis-gitlab.service" ] ++ optional (cfg.databaseHost == "") "postgresql.service";

     

       1607
       1607
       +
             wants = [ "redis-gitlab.service" ] ++ optional (cfg.databaseHost == "") "postgresql.target";

     

       1608
       1608
        
             wantedBy = [ "gitlab.target" ];

     

       1609
       1609
        
             partOf = [ "gitlab.target" ];

     

       1610
       1610
        
             environment =

     
···

       1847
       1847
        
               "gitlab-config.service"

     

       1848
       1848
        
               "gitlab-db-config.service"

     

       1849
       1849
        
             ];

     

       1850
       1850
       -
             wants = [ "redis-gitlab.service" ] ++ optional (cfg.databaseHost == "") "postgresql.service";

     

       1850
       1850
       +
             wants = [ "redis-gitlab.service" ] ++ optional (cfg.databaseHost == "") "postgresql.target";

     

       1851
       1851
        
             requiredBy = [ "gitlab.target" ];

     

       1852
       1852
        
             partOf = [ "gitlab.target" ];

     

       1853
       1853
        
             environment = gitlabEnv;

+8 -8

nixos/modules/services/misc/paperless.nix

···

       491
       491
        
                     fi

     

       492
       492
        
                   fi

     

       493
       493
        
                 '';

     

       494
       494
       -
                 requires = lib.optional cfg.database.createLocally "postgresql.service";

     

       494
       494
       +
                 requires = lib.optional cfg.database.createLocally "postgresql.target";

     

       495
       495
        
                 after =

     

       496
       496
        
                   lib.optional enableRedis "redis-paperless.service"

     

       497
       497
       -
                   ++ lib.optional cfg.database.createLocally "postgresql.service";

     

       497
       497
       +
                   ++ lib.optional cfg.database.createLocally "postgresql.target";

     

       498
       498
        
               };

     

       499
       499
        
       

     

       500
       500
        
               systemd.services.paperless-task-queue = {

     

       501
       501
        
                 description = "Paperless Celery Workers";

     

       502
       502
       -
                 requires = lib.optional cfg.database.createLocally "postgresql.service";

     

       502
       502
       +
                 requires = lib.optional cfg.database.createLocally "postgresql.target";

     

       503
       503
        
                 after = [

     

       504
       504
        
                   "paperless-scheduler.service"

     

       505
       505
       -
                 ] ++ lib.optional cfg.database.createLocally "postgresql.service";

     

       505
       505
       +
                 ] ++ lib.optional cfg.database.createLocally "postgresql.target";

     

       506
       506
        
                 serviceConfig = defaultServiceConfig // {

     

       507
       507
        
                   User = cfg.user;

     

       508
       508
        
                   ExecStart = "${cfg.package}/bin/celery --app paperless worker --loglevel INFO";

     
···

       520
       520
        
                 # Bind to `paperless-scheduler` so that the consumer never runs

     

       521
       521
        
                 # during migrations

     

       522
       522
        
                 bindsTo = [ "paperless-scheduler.service" ];

     

       523
       523
       -
                 requires = lib.optional cfg.database.createLocally "postgresql.service";

     

       523
       523
       +
                 requires = lib.optional cfg.database.createLocally "postgresql.target";

     

       524
       524
        
                 after = [

     

       525
       525
        
                   "paperless-scheduler.service"

     

       526
       526
       -
                 ] ++ lib.optional cfg.database.createLocally "postgresql.service";

     

       526
       526
       +
                 ] ++ lib.optional cfg.database.createLocally "postgresql.target";

     

       527
       527
        
                 serviceConfig = defaultServiceConfig // {

     

       528
       528
        
                   User = cfg.user;

     

       529
       529
        
                   ExecStart = "${cfg.package}/bin/paperless-ngx document_consumer";

     
···

       541
       541
        
                 # Bind to `paperless-scheduler` so that the web server never runs

     

       542
       542
        
                 # during migrations

     

       543
       543
        
                 bindsTo = [ "paperless-scheduler.service" ];

     

       544
       544
       -
                 requires = lib.optional cfg.database.createLocally "postgresql.service";

     

       544
       544
       +
                 requires = lib.optional cfg.database.createLocally "postgresql.target";

     

       545
       545
        
                 after = [

     

       546
       546
        
                   "paperless-scheduler.service"

     

       547
       547
       -
                 ] ++ lib.optional cfg.database.createLocally "postgresql.service";

     

       547
       547
       +
                 ] ++ lib.optional cfg.database.createLocally "postgresql.target";

     

       548
       548
        
                 # Setup PAPERLESS_SECRET_KEY.

     

       549
       549
        
                 # If this environment variable is left unset, paperless-ngx defaults

     

       550
       550
        
                 # to a well-known value, which is insecure.

+1 -1

nixos/modules/services/misc/redmine.nix

···

       374
       374
        
             after =

     

       375
       375
        
               [ "network.target" ]

     

       376
       376
        
               ++ lib.optional mysqlLocal "mysql.service"

     

       377
       377
       -
               ++ lib.optional pgsqlLocal "postgresql.service";

     

       377
       377
       +
               ++ lib.optional pgsqlLocal "postgresql.target";

     

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

     

       379
       379
        
             environment.RAILS_ENV = "production";

     

       380
       380
        
             environment.RAILS_CACHE = "${cfg.stateDir}/cache";

+5 -7

nixos/modules/services/misc/sourcehut/service.nix

···

       52
       52
        
             {

     

       53
       53
        
               after =

     

       54
       54
        
                 [ "network.target" ]

     

       55
       55
       -
                 ++ optional cfg.postgresql.enable "postgresql.service"

     

       55
       55
       +
                 ++ optional cfg.postgresql.enable "postgresql.target"

     

       56
       56
        
                 ++ optional cfg.redis.enable "redis-sourcehut-${srvsrht}.service";

     

       57
       57
        
               requires =

     

       58
       58
       -
                 optional cfg.postgresql.enable "postgresql.service"

     

       58
       58
       +
                 optional cfg.postgresql.enable "postgresql.target"

     

       59
       59
        
                 ++ optional cfg.redis.enable "redis-sourcehut-${srvsrht}.service";

     

       60
       60
        
               path = [ pkgs.gawk ];

     

       61
       61
        
               environment.HOME = runDir;

     
···

       482
       482
        
                   && lib.strings.versionAtLeast config.services.postgresql.package.version "15.0"

     

       483
       483
        
                 )

     

       484
       484
        
                 {

     

       485
       485
       -
                   postgresql.postStart = (

     

       486
       486
       -
                     lib.mkAfter ''

     

       487
       487
       -
                       $PSQL -tAc 'ALTER DATABASE "${srvCfg.postgresql.database}" OWNER TO "${srvCfg.user}";'

     

       488
       488
       -
                     ''

     

       489
       489
       -
                   );

     

       485
       485
       +
                   postgresql-setup.postStart = ''

     

       486
       486
       +
                     psql -tAc 'ALTER DATABASE "${srvCfg.postgresql.database}" OWNER TO "${srvCfg.user}";'

     

       487
       487
       +
                   '';

     

       490
       488
        
                 }

     

       491
       489
        
               )

     

       492
       490
        
             ];

+1 -1

nixos/modules/services/monitoring/grafana.nix

···

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

     

       2021
       2021
        
             after =

     

       2022
       2022
        
               [ "networking.target" ]

     

       2023
       2023
       -
               ++ lib.optional usePostgresql "postgresql.service"

     

       2023
       2023
       +
               ++ lib.optional usePostgresql "postgresql.target"

     

       2024
       2024
        
               ++ lib.optional useMysql "mysql.service";

     

       2025
       2025
        
             script = ''

     

       2026
       2026
        
               set -o errexit -o pipefail -o nounset -o errtrace

+1 -1

nixos/modules/services/monitoring/zabbix-proxy.nix

···

       337
       337
        
             description = "Zabbix Proxy";

     

       338
       338
        
       

     

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

     

       340
       340
       -
             after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.service";

     

       340
       340
       +
             after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.target";

     

       341
       341
        
       

     

       342
       342
        
             path = [ "/run/wrappers" ] ++ cfg.extraPackages;

     

       343
       343
        
             preStart =

+2 -2

nixos/modules/services/monitoring/zabbix-server.nix

···

       328
       328
        
             description = "Zabbix Server";

     

       329
       329
        
       

     

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

     

       331
       331
       -
             after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.service";

     

       331
       331
       +
             after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.target";

     

       332
       332
        
       

     

       333
       333
        
             path = [ "/run/wrappers" ] ++ cfg.extraPackages;

     

       334
       334
        
             preStart =

     
···

       374
       374
        
       

     

       375
       375
        
           systemd.services.httpd.after =

     

       376
       376
        
             optional (config.services.zabbixWeb.enable && mysqlLocal) "mysql.service"

     

       377
       377
       -
             ++ optional (config.services.zabbixWeb.enable && pgsqlLocal) "postgresql.service";

     

       377
       377
       +
             ++ optional (config.services.zabbixWeb.enable && pgsqlLocal) "postgresql.target";

     

       378
       378
        
       

     

       379
       379
        
         };

     

       380
       380

+2 -2

nixos/modules/services/networking/atticd.nix

···

       169
       169
        
       

     

       170
       170
        
           systemd.services.atticd = {

     

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

     

       172
       172
       -
             after = [ "network-online.target" ] ++ lib.optionals hasLocalPostgresDB [ "postgresql.service" ];

     

       173
       173
       -
             requires = lib.optionals hasLocalPostgresDB [ "postgresql.service" ];

     

       172
       172
       +
             after = [ "network-online.target" ] ++ lib.optionals hasLocalPostgresDB [ "postgresql.target" ];

     

       173
       173
       +
             requires = lib.optionals hasLocalPostgresDB [ "postgresql.target" ];

     

       174
       174
        
             wants = [ "network-online.target" ];

     

       175
       175
        
       

     

       176
       176
        
             serviceConfig = {

+2 -2

nixos/modules/services/networking/firezone/server.nix

···

       1105
       1105
        
             systemd.services.firezone-initialize = {

     

       1106
       1106
        
               description = "Backend initialization service for the Firezone zero-trust access platform";

     

       1107
       1107
        
       

     

       1108
       1108
       -
               after = mkIf cfg.enableLocalDB [ "postgresql.service" ];

     

       1109
       1109
       -
               requires = mkIf cfg.enableLocalDB [ "postgresql.service" ];

     

       1108
       1108
       +
               after = mkIf cfg.enableLocalDB [ "postgresql.target" ];

     

       1109
       1109
       +
               requires = mkIf cfg.enableLocalDB [ "postgresql.target" ];

     

       1110
       1110
        
               wantedBy = [ "firezone.target" ];

     

       1111
       1111
        
               partOf = [ "firezone.target" ];

     

       1112
       1112

+1 -1

nixos/modules/services/networking/pleroma.nix

···

       122
       122
        
                 wants = [ "network-online.target" ];

     

       123
       123
        
                 after = [

     

       124
       124
        
                   "network-online.target"

     

       125
       125
       -
                   "postgresql.service"

     

       125
       125
       +
                   "postgresql.target"

     

       126
       126
        
                 ];

     

       127
       127
        
                 wantedBy = [ "pleroma.service" ];

     

       128
       128
        
                 environment.RELEASE_COOKIE = "/var/lib/pleroma/.cookie";

+1 -1

nixos/modules/services/networking/powerdns.nix

···

       53
       53
        
             after = [

     

       54
       54
        
               "network.target"

     

       55
       55
        
               "mysql.service"

     

       56
       56
       -
               "postgresql.service"

     

       56
       56
       +
               "postgresql.target"

     

       57
       57
        
               "openldap.service"

     

       58
       58
        
             ];

     

       59
       59

+1 -1

nixos/modules/services/networking/quassel.nix

···

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

     

       121
       121
        
             after =

     

       122
       122
        
               [ "network.target" ]

     

       123
       123
       -
               ++ optional config.services.postgresql.enable "postgresql.service"

     

       123
       123
       +
               ++ optional config.services.postgresql.enable "postgresql.target"

     

       124
       124
        
               ++ optional config.services.mysql.enable "mysql.service";

     

       125
       125
        
       

     

       126
       126
        
             serviceConfig = {

+2 -2

nixos/modules/services/security/canaille.nix

···

       283
       283
        
           systemd.services.canaille-install = {

     

       284
       284
        
             # We want this on boot, not on socket activation

     

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

     

       286
       286
       -
             after = optional createLocalPostgresqlDb "postgresql.service";

     

       286
       286
       +
             after = optional createLocalPostgresqlDb "postgresql.target";

     

       287
       287
        
             serviceConfig = commonServiceConfig // {

     

       288
       288
        
               Type = "oneshot";

     

       289
       289
        
               ExecStart = "${getExe finalPackage} install";

     
···

       296
       296
        
             after = [

     

       297
       297
        
               "network.target"

     

       298
       298
        
               "canaille-install.service"

     

       299
       299
       -
             ] ++ optional createLocalPostgresqlDb "postgresql.service";

     

       299
       299
       +
             ] ++ optional createLocalPostgresqlDb "postgresql.target";

     

       300
       300
        
             requires = [

     

       301
       301
        
               "canaille-install.service"

     

       302
       302
        
               "canaille.socket"

+2 -2

nixos/modules/services/torrent/bitmagnet.nix

···

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

     

       128
       128
        
             after = [

     

       129
       129
        
               "network.target"

     

       130
       130
       -
             ] ++ optional cfg.useLocalPostgresDB "postgresql.service";

     

       131
       131
       -
             requires = optional cfg.useLocalPostgresDB "postgresql.service";

     

       130
       130
       +
             ] ++ optional cfg.useLocalPostgresDB "postgresql.target";

     

       131
       131
       +
             requires = optional cfg.useLocalPostgresDB "postgresql.target";

     

       132
       132
        
             serviceConfig = {

     

       133
       133
        
               Type = "simple";

     

       134
       134
        
               DynamicUser = true;

+2 -2

nixos/modules/services/web-apps/akkoma.nix

···

       1231
       1231
        
             requiredBy = [ "akkoma.service" ];

     

       1232
       1232
        
             after = [

     

       1233
       1233
        
               "akkoma-config.service"

     

       1234
       1234
       -
               "postgresql.service"

     

       1234
       1234
       +
               "postgresql.target"

     

       1235
       1235
        
             ];

     

       1236
       1236
        
             before = [ "akkoma.service" ];

     

       1237
       1237
        
       

     
···

       1269
       1269
        
                 "akkoma-config.target"

     

       1270
       1270
        
                 "network.target"

     

       1271
       1271
        
                 "network-online.target"

     

       1272
       1272
       -
                 "postgresql.service"

     

       1272
       1272
       +
                 "postgresql.target"

     

       1273
       1273
        
               ];

     

       1274
       1274
        
       

     

       1275
       1275
        
               confinement.packages = mkIf isConfined runtimeInputs;

+1 -1

nixos/modules/services/web-apps/crabfit.nix

···

       109
       109
        
               description = "The API for Crab Fit.";

     

       110
       110
        
       

     

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

     

       112
       112
       -
               after = [ "postgresql.service" ];

     

       112
       112
       +
               after = [ "postgresql.target" ];

     

       113
       113
        
       

     

       114
       114
        
               serviceConfig = {

     

       115
       115
        
                 # TODO: harden

+3 -3

nixos/modules/services/web-apps/davis.nix

···

       444
       444
        
               before = [ "phpfpm-davis.service" ];

     

       445
       445
        
               after =

     

       446
       446
        
                 lib.optional mysqlLocal "mysql.service"

     

       447
       447
       -
                 ++ lib.optional pgsqlLocal "postgresql.service"

     

       447
       447
       +
                 ++ lib.optional pgsqlLocal "postgresql.target"

     

       448
       448
        
                 ++ [ "davis-env-setup.service" ];

     

       449
       449
        
               requires =

     

       450
       450
        
                 lib.optional mysqlLocal "mysql.service"

     

       451
       451
       -
                 ++ lib.optional pgsqlLocal "postgresql.service"

     

       451
       451
       +
                 ++ lib.optional pgsqlLocal "postgresql.target"

     

       452
       452
        
                 ++ [ "davis-env-setup.service" ];

     

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

     

       454
       454
        
               serviceConfig = defaultServiceConfig // {

     
···

       483
       483
        
                 "davis-db-migrate.service"

     

       484
       484
        
               ]

     

       485
       485
        
               ++ lib.optional mysqlLocal "mysql.service"

     

       486
       486
       -
               ++ lib.optional pgsqlLocal "postgresql.service";

     

       486
       486
       +
               ++ lib.optional pgsqlLocal "postgresql.target";

     

       487
       487
        
             systemd.services.phpfpm-davis.serviceConfig.ReadWritePaths = [ cfg.dataDir ];

     

       488
       488
        
       

     

       489
       489
        
             services.nginx = lib.mkIf (cfg.nginx != null) {

+3 -3

nixos/modules/services/web-apps/dependency-track.nix

···

       535
       535
        
           };

     

       536
       536
        
       

     

       537
       537
        
           systemd.services.dependency-track-postgresql-init = lib.mkIf cfg.database.createLocally {

     

       538
       538
       -
             after = [ "postgresql.service" ];

     

       538
       538
       +
             after = [ "postgresql.target" ];

     

       539
       539
        
             before = [ "dependency-track.service" ];

     

       540
       540
       -
             bindsTo = [ "postgresql.service" ];

     

       540
       540
       +
             bindsTo = [ "postgresql.target" ];

     

       541
       541
        
             path = [ config.services.postgresql.package ];

     

       542
       542
        
             serviceConfig = {

     

       543
       543
        
               Type = "oneshot";

     
···

       572
       572
        
                 if cfg.database.createLocally then

     

       573
       573
        
                   [

     

       574
       574
        
                     "dependency-track-postgresql-init.service"

     

       575
       575
       -
                     "postgresql.service"

     

       575
       575
       +
                     "postgresql.target"

     

       576
       576
        
                   ]

     

       577
       577
        
                 else

     

       578
       578
        
                   [ ];

+1 -1

nixos/modules/services/web-apps/dex.nix

···

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

     

       101
       101
        
             after = [

     

       102
       102
        
               "networking.target"

     

       103
       103
       -
             ] ++ (optional (cfg.settings.storage.type == "postgres") "postgresql.service");

     

       103
       103
       +
             ] ++ (optional (cfg.settings.storage.type == "postgres") "postgresql.target");

     

       104
       104
        
             path = with pkgs; [ replace-secret ];

     

       105
       105
        
             restartTriggers = restartTriggers;

     

       106
       106
        
             serviceConfig =

+6 -6

nixos/modules/services/web-apps/discourse.nix

···

       705
       705
        
               pgsql = config.services.postgresql;

     

       706
       706
        
             in

     

       707
       707
        
             lib.mkIf databaseActuallyCreateLocally {

     

       708
       708
       -
               after = [ "postgresql.service" ];

     

       709
       709
       -
               bindsTo = [ "postgresql.service" ];

     

       708
       708
       +
               after = [ "postgresql.target" ];

     

       709
       709
       +
               bindsTo = [ "postgresql.target" ];

     

       710
       710
        
               wantedBy = [ "discourse.service" ];

     

       711
       711
        
               partOf = [ "discourse.service" ];

     

       712
       712
        
               path = [

     
···

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

     

       733
       733
        
             after = [

     

       734
       734
        
               "redis-discourse.service"

     

       735
       735
       -
               "postgresql.service"

     

       736
       736
       -
               "discourse-postgresql.service"

     

       735
       735
       +
               "postgresql.target"

     

       736
       736
       +
               "discourse-postgresql.target"

     

       737
       737
        
             ];

     

       738
       738
        
             bindsTo =

     

       739
       739
        
               [

     

       740
       740
        
                 "redis-discourse.service"

     

       741
       741
        
               ]

     

       742
       742
        
               ++ lib.optionals (cfg.database.host == null) [

     

       743
       743
       -
                 "postgresql.service"

     

       744
       744
       -
                 "discourse-postgresql.service"

     

       743
       743
       +
                 "postgresql.target"

     

       744
       744
       +
                 "discourse-postgresql.target"

     

       745
       745
        
               ];

     

       746
       746
        
             path = cfg.package.runtimeDeps ++ [

     

       747
       747
        
               postgresqlPackage

+2 -2

nixos/modules/services/web-apps/fider.nix

···

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

     

       88
       88
        
             after = [

     

       89
       89
        
               "network.target"

     

       90
       90
       -
             ] ++ lib.optionals (cfg.database.url == "local") [ "postgresql.service" ];

     

       91
       91
       -
             requires = lib.optionals (cfg.database.url == "local") [ "postgresql.service" ];

     

       90
       90
       +
             ] ++ lib.optionals (cfg.database.url == "local") [ "postgresql.target" ];

     

       91
       91
       +
             requires = lib.optionals (cfg.database.url == "local") [ "postgresql.target" ];

     

       92
       92
        
             environment =

     

       93
       93
        
               let

     

       94
       94
        
                 localPostgresqlUrl = "postgres:///fider?host=/run/postgresql";

+1 -1

nixos/modules/services/web-apps/filesender.nix

···

       227
       227
        
               "multi-user.target"

     

       228
       228
        
               "phpfpm-filesender.service"

     

       229
       229
        
             ];

     

       230
       230
       -
             after = [ "postgresql.service" ];

     

       230
       230
       +
             after = [ "postgresql.target" ];

     

       231
       231
        
       

     

       232
       232
        
             restartIfChanged = true;

     

       233
       233

+2 -2

nixos/modules/services/web-apps/firefly-iii.nix

···

       308
       308
        
       

     

       309
       309
        
           systemd.services.firefly-iii-setup = {

     

       310
       310
        
             after = [

     

       311
       311
       -
               "postgresql.service"

     

       311
       311
       +
               "postgresql.target"

     

       312
       312
        
               "mysql.service"

     

       313
       313
        
             ];

     

       314
       314
        
             requiredBy = [ "phpfpm-firefly-iii.service" ];

     
···

       325
       325
        
           systemd.services.firefly-iii-cron = {

     

       326
       326
        
             after = [

     

       327
       327
        
               "firefly-iii-setup.service"

     

       328
       328
       -
               "postgresql.service"

     

       328
       328
       +
               "postgresql.target"

     

       329
       329
        
               "mysql.service"

     

       330
       330
        
             ];

     

       331
       331
        
             wants = [ "firefly-iii-setup.service" ];

+3 -3

nixos/modules/services/web-apps/froide-govplan.nix

···

       163
       163
        
           systemd = {

     

       164
       164
        
             services = {

     

       165
       165
        
       

     

       166
       166
       -
               postgresql.serviceConfig.ExecStartPost =

     

       166
       166
       +
               postgresql-setup.serviceConfig.ExecStartPost =

     

       167
       167
        
                 let

     

       168
       168
       -
                   sqlFile = pkgs.writeText "immich-pgvectors-setup.sql" ''

     

       168
       168
       +
                   sqlFile = pkgs.writeText "froide-govplan-postgis-setup.sql" ''

     

       169
       169
        
                     CREATE EXTENSION IF NOT EXISTS postgis;

     

       170
       170
        
                   '';

     

       171
       171
        
                 in

     
···

       184
       184
        
                   Group = "govplan";

     

       185
       185
        
                 };

     

       186
       186
        
                 after = [

     

       187
       187
       -
                   "postgresql.service"

     

       187
       187
       +
                   "postgresql.target"

     

       188
       188
        
                   "network.target"

     

       189
       189
        
                   "systemd-tmpfiles-setup.service"

     

       190
       190
        
                 ];

+1 -1

nixos/modules/services/web-apps/gancio.nix

···

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

     

       212
       212
        
               after = [

     

       213
       213
        
                 "network.target"

     

       214
       214
       -
               ] ++ optional (cfg.settings.db.dialect == "postgres") "postgresql.service";

     

       214
       214
       +
               ] ++ optional (cfg.settings.db.dialect == "postgres") "postgresql.target";

     

       215
       215
        
       

     

       216
       216
        
               environment = {

     

       217
       217
        
                 NODE_ENV = "production";

+2 -2

nixos/modules/services/web-apps/glitchtip.nix

···

       171
       171
        
       

     

       172
       172
        
                 wants = [ "network-online.target" ];

     

       173
       173
        
                 requires =

     

       174
       174
       -
                   lib.optional cfg.database.createLocally "postgresql.service"

     

       174
       174
       +
                   lib.optional cfg.database.createLocally "postgresql.target"

     

       175
       175
        
                   ++ lib.optional cfg.redis.createLocally "redis-glitchtip.service";

     

       176
       176
        
                 after =

     

       177
       177
        
                   [ "network-online.target" ]

     

       178
       178
       -
                   ++ lib.optional cfg.database.createLocally "postgresql.service"

     

       178
       178
       +
                   ++ lib.optional cfg.database.createLocally "postgresql.target"

     

       179
       179
        
                   ++ lib.optional cfg.redis.createLocally "redis-glitchtip.service";

     

       180
       180
        
       

     

       181
       181
        
                 inherit environment;

+2 -2

nixos/modules/services/web-apps/gotosocial.nix

···

       144
       144
        
           systemd.services.gotosocial = {

     

       145
       145
        
             description = "ActivityPub social network server";

     

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

     

       147
       147
       -
             after = [ "network.target" ] ++ lib.optional cfg.setupPostgresqlDB "postgresql.service";

     

       148
       148
       -
             requires = lib.optional cfg.setupPostgresqlDB "postgresql.service";

     

       147
       147
       +
             after = [ "network.target" ] ++ lib.optional cfg.setupPostgresqlDB "postgresql.target";

     

       148
       148
       +
             requires = lib.optional cfg.setupPostgresqlDB "postgresql.target";

     

       149
       149
        
             restartTriggers = [ configFile ];

     

       150
       150
        
       

     

       151
       151
        
             serviceConfig = {

+2 -2

nixos/modules/services/web-apps/homebox.nix

···

       81
       81
        
             ];

     

       82
       82
        
           };

     

       83
       83
        
           systemd.services.homebox = {

     

       84
       84
       -
             requires = lib.optional cfg.database.createLocally "postgresql.service";

     

       85
       85
       -
             after = lib.optional cfg.database.createLocally "postgresql.service";

     

       84
       84
       +
             requires = lib.optional cfg.database.createLocally "postgresql.target";

     

       85
       85
       +
             after = lib.optional cfg.database.createLocally "postgresql.target";

     

       86
       86
        
             environment = cfg.settings;

     

       87
       87
        
             serviceConfig = {

     

       88
       88
        
               User = "homebox";

+1 -1

nixos/modules/services/web-apps/immich.nix

···

       254
       254
        
               search_path = "\"$user\", public, vectors";

     

       255
       255
        
             };

     

       256
       256
        
           };

     

       257
       257
       -
           systemd.services.postgresql.serviceConfig.ExecStartPost =

     

       257
       257
       +
           systemd.services.postgresql-setup.serviceConfig.ExecStartPost =

     

       258
       258
        
             let

     

       259
       259
        
               sqlFile = pkgs.writeText "immich-pgvectors-setup.sql" ''

     

       260
       260
        
                 CREATE EXTENSION IF NOT EXISTS unaccent;

+2 -2

nixos/modules/services/web-apps/invidious.nix

···

       19
       19
        
         commonInvidousServiceConfig = {

     

       20
       20
        
           description = "Invidious (An alternative YouTube front-end)";

     

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

     

       22
       22
       -
           after = [ "network-online.target" ] ++ lib.optional cfg.database.createLocally "postgresql.service";

     

       23
       23
       -
           requires = lib.optional cfg.database.createLocally "postgresql.service";

     

       22
       22
       +
           after = [ "network-online.target" ] ++ lib.optional cfg.database.createLocally "postgresql.target";

     

       23
       23
       +
           requires = lib.optional cfg.database.createLocally "postgresql.target";

     

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

     

       25
       25
        
       

     

       26
       26
        
           serviceConfig = {

+3 -3

nixos/modules/services/web-apps/keycloak.nix

···

       602
       602
        
               ];

     

       603
       603
        
       

     

       604
       604
        
             systemd.services.keycloakPostgreSQLInit = mkIf createLocalPostgreSQL {

     

       605
       605
       -
               after = [ "postgresql.service" ];

     

       605
       605
       +
               after = [ "postgresql.target" ];

     

       606
       606
        
               before = [ "keycloak.service" ];

     

       607
       607
       -
               bindsTo = [ "postgresql.service" ];

     

       607
       607
       +
               bindsTo = [ "postgresql.target" ];

     

       608
       608
        
               path = [ config.services.postgresql.package ];

     

       609
       609
        
               serviceConfig = {

     

       610
       610
        
                 Type = "oneshot";

     
···

       690
       690
        
                   if createLocalPostgreSQL then

     

       691
       691
        
                     [

     

       692
       692
        
                       "keycloakPostgreSQLInit.service"

     

       693
       693
       -
                       "postgresql.service"

     

       693
       693
       +
                       "postgresql.target"

     

       694
       694
        
                     ]

     

       695
       695
        
                   else if createLocalMySQL then

     

       696
       696
        
                     [

+4 -4

nixos/modules/services/web-apps/lasuite-docs.nix

···

       350
       350
        
             description = "Docs from SuiteNumérique";

     

       351
       351
        
             after =

     

       352
       352
        
               [ "network.target" ]

     

       353
       353
       -
               ++ (optional cfg.postgresql.createLocally "postgresql.service")

     

       353
       353
       +
               ++ (optional cfg.postgresql.createLocally "postgresql.target")

     

       354
       354
        
               ++ (optional cfg.redis.createLocally "redis-lasuite-docs.service");

     

       355
       355
        
             wants =

     

       356
       356
       -
               (optional cfg.postgresql.createLocally "postgresql.service")

     

       356
       356
       +
               (optional cfg.postgresql.createLocally "postgresql.target")

     

       357
       357
        
               ++ (optional cfg.redis.createLocally "redis-lasuite-docs.service");

     

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

     

       359
       359
        
       

     
···

       398
       398
        
             description = "Docs Celery broker from SuiteNumérique";

     

       399
       399
        
             after =

     

       400
       400
        
               [ "network.target" ]

     

       401
       401
       -
               ++ (optional cfg.postgresql.createLocally "postgresql.service")

     

       401
       401
       +
               ++ (optional cfg.postgresql.createLocally "postgresql.target")

     

       402
       402
        
               ++ (optional cfg.redis.createLocally "redis-lasuite-docs.service");

     

       403
       403
        
             wants =

     

       404
       404
       -
               (optional cfg.postgresql.createLocally "postgresql.service")

     

       404
       404
       +
               (optional cfg.postgresql.createLocally "postgresql.target")

     

       405
       405
        
               ++ (optional cfg.redis.createLocally "redis-lasuite-docs.service");

     

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

     

       407
       407

+2 -2

nixos/modules/services/web-apps/lemmy.nix

···

       325
       325
        
       

     

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

     

       327
       327
        
       

     

       328
       328
       -
                 after = [ "pict-rs.service" ] ++ lib.optionals cfg.database.createLocally [ "postgresql.service" ];

     

       328
       328
       +
                 after = [ "pict-rs.service" ] ++ lib.optionals cfg.database.createLocally [ "postgresql.target" ];

     

       329
       329
        
       

     

       330
       330
       -
                 requires = lib.optionals cfg.database.createLocally [ "postgresql.service" ];

     

       330
       330
       +
                 requires = lib.optionals cfg.database.createLocally [ "postgresql.target" ];

     

       331
       331
        
       

     

       332
       332
        
                 # substitute secrets and prevent others from reading the result

     

       333
       333
        
                 # if somehow $CREDENTIALS_DIRECTORY is not set we fail

+2 -2

nixos/modules/services/web-apps/limesurvey.nix

···

       413
       413
        
           systemd.services.limesurvey-init = {

     

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

     

       415
       415
        
             before = [ "phpfpm-limesurvey.service" ];

     

       416
       416
       -
             after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.service";

     

       416
       416
       +
             after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.target";

     

       417
       417
        
             environment.DBENGINE = "${cfg.database.dbEngine}";

     

       418
       418
        
             environment.LIMESURVEY_CONFIG = limesurveyConfig;

     

       419
       419
        
             script = ''

     
···

       444
       444
        
       

     

       445
       445
        
           systemd.services.httpd.after =

     

       446
       446
        
             optional mysqlLocal "mysql.service"

     

       447
       447
       -
             ++ optional pgsqlLocal "postgresql.service";

     

       447
       447
       +
             ++ optional pgsqlLocal "postgresql.target";

     

       448
       448
        
       

     

       449
       449
        
           users.users.${user} = {

     

       450
       450
        
             group = group;

+11 -11

nixos/modules/services/web-apps/mastodon.nix

···

       126
       126
        
           SystemCallArchitectures = "native";

     

       127
       127
        
         };

     

       128
       128
        
       

     

       129
       129
       -
         # Services that all Mastodon units After= and Requires= on

     

       130
       130
       -
         commonServices =

     

       129
       129
       +
         # Units that all Mastodon units After= and Requires= on

     

       130
       130
       +
         commonUnits =

     

       131
       131
        
           lib.optional redisActuallyCreateLocally "redis-mastodon.service"

     

       132
       132
       -
           ++ lib.optional databaseActuallyCreateLocally "postgresql.service"

     

       132
       132
       +
           ++ lib.optional databaseActuallyCreateLocally "postgresql.target"

     

       133
       133
        
           ++ lib.optional cfg.automaticMigrations "mastodon-init-db.service";

     

       134
       134
        
       

     

       135
       135
        
         envFile = pkgs.writeText "mastodon.env" (

     
···

       170
       170
        
               after = [

     

       171
       171
        
                 "network.target"

     

       172
       172
        
                 "mastodon-init-dirs.service"

     

       173
       173
       -
               ] ++ commonServices;

     

       174
       174
       -
               requires = [ "mastodon-init-dirs.service" ] ++ commonServices;

     

       173
       173
       +
               ] ++ commonUnits;

     

       174
       174
       +
               requires = [ "mastodon-init-dirs.service" ] ++ commonUnits;

     

       175
       175
        
               description = "Mastodon sidekiq${jobClassLabel}";

     

       176
       176
        
               wantedBy = [ "mastodon.target" ];

     

       177
       177
        
               environment = env // {

     
···

       209
       209
        
               after = [

     

       210
       210
        
                 "network.target"

     

       211
       211
        
                 "mastodon-init-dirs.service"

     

       212
       212
       -
               ] ++ commonServices;

     

       213
       213
       -
               requires = [ "mastodon-init-dirs.service" ] ++ commonServices;

     

       212
       212
       +
               ] ++ commonUnits;

     

       213
       213
       +
               requires = [ "mastodon-init-dirs.service" ] ++ commonUnits;

     

       214
       214
        
               wantedBy = [

     

       215
       215
        
                 "mastodon.target"

     

       216
       216
        
                 "mastodon-streaming.target"

     
···

       998
       998
        
                 after = [

     

       999
       999
        
                   "network.target"

     

       1000
       1000
        
                   "mastodon-init-dirs.service"

     

       1001
       1001
       -
                 ] ++ lib.optional databaseActuallyCreateLocally "postgresql.service";

     

       1001
       1001
       +
                 ] ++ lib.optional databaseActuallyCreateLocally "postgresql.target";

     

       1002
       1002
        
                 requires = [

     

       1003
       1003
        
                   "mastodon-init-dirs.service"

     

       1004
       1004
       -
                 ] ++ lib.optional databaseActuallyCreateLocally "postgresql.service";

     

       1004
       1004
       +
                 ] ++ lib.optional databaseActuallyCreateLocally "postgresql.target";

     

       1005
       1005
        
               };

     

       1006
       1006
        
       

     

       1007
       1007
        
               systemd.services.mastodon-web = {

     

       1008
       1008
        
                 after = [

     

       1009
       1009
        
                   "network.target"

     

       1010
       1010
        
                   "mastodon-init-dirs.service"

     

       1011
       1011
       -
                 ] ++ commonServices;

     

       1012
       1012
       -
                 requires = [ "mastodon-init-dirs.service" ] ++ commonServices;

     

       1011
       1011
       +
                 ] ++ commonUnits;

     

       1012
       1012
       +
                 requires = [ "mastodon-init-dirs.service" ] ++ commonUnits;

     

       1013
       1013
        
                 wantedBy = [ "mastodon.target" ];

     

       1014
       1014
        
                 description = "Mastodon web";

     

       1015
       1015
        
                 environment =

+2 -2

nixos/modules/services/web-apps/mattermost.nix

···

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

     

       841
       841
        
               after = mkMerge [

     

       842
       842
        
                 [ "network.target" ]

     

       843
       843
       -
                 (mkIf (cfg.database.driver == "postgres" && cfg.database.create) [ "postgresql.service" ])

     

       843
       843
       +
                 (mkIf (cfg.database.driver == "postgres" && cfg.database.create) [ "postgresql.target" ])

     

       844
       844
        
                 (mkIf (cfg.database.driver == "mysql" && cfg.database.create) [ "mysql.service" ])

     

       845
       845
        
               ];

     

       846
       846
        
               requires = after;

     
···

       946
       946
        
               ];

     

       947
       947
        
       

     

       948
       948
        
               unitConfig.JoinsNamespaceOf = mkMerge [

     

       949
       949
       -
                 (mkIf (cfg.database.driver == "postgres" && cfg.database.create) [ "postgresql.service" ])

     

       949
       949
       +
                 (mkIf (cfg.database.driver == "postgres" && cfg.database.create) [ "postgresql.target" ])

     

       950
       950
        
                 (mkIf (cfg.database.driver == "mysql" && cfg.database.create) [ "mysql.service" ])

     

       951
       951
        
               ];

     

       952
       952
        
             };

+2 -2

nixos/modules/services/web-apps/mealie.nix

···

       66
       66
        
           systemd.services.mealie = {

     

       67
       67
        
             description = "Mealie, a self hosted recipe manager and meal planner";

     

       68
       68
        
       

     

       69
       69
       -
             after = [ "network-online.target" ] ++ lib.optional cfg.database.createLocally "postgresql.service";

     

       70
       70
       -
             requires = lib.optional cfg.database.createLocally "postgresql.service";

     

       69
       69
       +
             after = [ "network-online.target" ] ++ lib.optional cfg.database.createLocally "postgresql.target";

     

       70
       70
       +
             requires = lib.optional cfg.database.createLocally "postgresql.target";

     

       71
       71
        
             wants = [ "network-online.target" ];

     

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

     

       73
       73

+2 -2

nixos/modules/services/web-apps/mediagoblin.nix

···

       339
       339
        
               mediagoblin-paster = lib.recursiveUpdate serviceDefaults {

     

       340
       340
        
                 after = [

     

       341
       341
        
                   "mediagoblin-celeryd.service"

     

       342
       342
       -
                   "postgresql.service"

     

       342
       342
       +
                   "postgresql.target"

     

       343
       343
        
                 ];

     

       344
       344
        
                 requires = [

     

       345
       345
        
                   "mediagoblin-celeryd.service"

     

       346
       346
       -
                   "postgresql.service"

     

       346
       346
       +
                   "postgresql.target"

     

       347
       347
        
                 ];

     

       348
       348
        
                 preStart = ''

     

       349
       349
        
                   cp --remove-destination ${pasteConfig} /var/lib/mediagoblin/paste.ini

+2 -2

nixos/modules/services/web-apps/mediawiki.nix

···

       707
       707
        
             before = [ "phpfpm-mediawiki.service" ];

     

       708
       708
        
             after =

     

       709
       709
        
               optional (cfg.database.type == "mysql" && cfg.database.createLocally) "mysql.service"

     

       710
       710
       -
               ++ optional (cfg.database.type == "postgres" && cfg.database.createLocally) "postgresql.service";

     

       710
       710
       +
               ++ optional (cfg.database.type == "postgres" && cfg.database.createLocally) "postgresql.target";

     

       711
       711
        
             script = ''

     

       712
       712
        
               if ! test -e "${stateDir}/secret.key"; then

     

       713
       713
        
                 tr -dc A-Za-z0-9 </dev/urandom 2>/dev/null | head -c 64 > ${stateDir}/secret.key

     
···

       754
       754
        
             ) "mysql.service"

     

       755
       755
        
             ++ optional (

     

       756
       756
        
               cfg.webserver == "apache" && cfg.database.createLocally && cfg.database.type == "postgres"

     

       757
       757
       -
             ) "postgresql.service";

     

       757
       757
       +
             ) "postgresql.target";

     

       758
       758
        
       

     

       759
       759
        
           users.users.${user} = {

     

       760
       760
        
             inherit group;

+3 -3

nixos/modules/services/web-apps/miniflux.nix

···

       107
       107
        
       

     

       108
       108
        
           systemd.services.miniflux-dbsetup = lib.mkIf cfg.createDatabaseLocally {

     

       109
       109
        
             description = "Miniflux database setup";

     

       110
       110
       -
             requires = [ "postgresql.service" ];

     

       110
       110
       +
             requires = [ "postgresql.target" ];

     

       111
       111
        
             after = [

     

       112
       112
        
               "network.target"

     

       113
       113
       -
               "postgresql.service"

     

       113
       113
       +
               "postgresql.target"

     

       114
       114
        
             ];

     

       115
       115
        
             serviceConfig = {

     

       116
       116
        
               Type = "oneshot";

     
···

       126
       126
        
             after =

     

       127
       127
        
               [ "network.target" ]

     

       128
       128
        
               ++ lib.optionals cfg.createDatabaseLocally [

     

       129
       129
       -
                 "postgresql.service"

     

       129
       129
       +
                 "postgresql.target"

     

       130
       130
        
                 "miniflux-dbsetup.service"

     

       131
       131
        
               ];

     

       132
       132

+1 -1

nixos/modules/services/web-apps/misskey.nix

···

       319
       319
        
           systemd.services.misskey = {

     

       320
       320
        
             after = [

     

       321
       321
        
               "network-online.target"

     

       322
       322
       -
               "postgresql.service"

     

       322
       322
       +
               "postgresql.target"

     

       323
       323
        
             ];

     

       324
       324
        
             wants = [ "network-online.target" ];

     

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

+1 -1

nixos/modules/services/web-apps/mobilizon.nix

···

       366
       366
        
           systemd.services.mobilizon-postgresql = mkIf isLocalPostgres {

     

       367
       367
        
             description = "Mobilizon PostgreSQL setup";

     

       368
       368
        
       

     

       369
       369
       -
             after = [ "postgresql.service" ];

     

       369
       369
       +
             after = [ "postgresql.target" ];

     

       370
       370
        
             before = [

     

       371
       371
        
               "mobilizon.service"

     

       372
       372
        
               "mobilizon-setup-secrets.service"

+2 -2

nixos/modules/services/web-apps/moodle.nix

···

       351
       351
        
           systemd.services.moodle-init = {

     

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

     

       353
       353
        
             before = [ "phpfpm-moodle.service" ];

     

       354
       354
       -
             after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.service";

     

       354
       354
       +
             after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.target";

     

       355
       355
        
             environment.MOODLE_CONFIG = moodleConfig;

     

       356
       356
        
             script = ''

     

       357
       357
        
               ${phpExt}/bin/php ${cfg.package}/share/moodle/admin/cli/check_database_schema.php && rc=$? || rc=$?

     
···

       394
       394
        
       

     

       395
       395
        
           systemd.services.httpd.after =

     

       396
       396
        
             optional mysqlLocal "mysql.service"

     

       397
       397
       -
             ++ optional pgsqlLocal "postgresql.service";

     

       397
       397
       +
             ++ optional pgsqlLocal "postgresql.target";

     

       398
       398
        
       

     

       399
       399
        
           users.users.${user} = {

     

       400
       400
        
             group = group;

+8 -8

nixos/modules/services/web-apps/movim.nix

···

       165
       165
        
         fpm = config.services.phpfpm.pools.${pool};

     

       166
       166
        
         phpExecutionUnit = "phpfpm-${pool}";

     

       167
       167
        
       

     

       168
       168
       -
         dbService =

     

       168
       168
       +
         dbUnit =

     

       169
       169
        
           {

     

       170
       170
       -
             "postgresql" = "postgresql.service";

     

       170
       170
       +
             "postgresql" = "postgresql.target";

     

       171
       171
        
             "mariadb" = "mysql.service";

     

       172
       172
        
           }

     

       173
       173
        
           .${cfg.database.type};

     
···

       843
       843
        
               requiredBy = [ "${phpExecutionUnit}.service" ];

     

       844
       844
        
               before = [ "${phpExecutionUnit}.service" ];

     

       845
       845
        
               wants = [ "local-fs.target" ];

     

       846
       846
       -
               requires = lib.optional cfg.database.createLocally dbService;

     

       847
       847
       -
               after = lib.optional cfg.database.createLocally dbService;

     

       846
       846
       +
               requires = lib.optional cfg.database.createLocally dbUnit;

     

       847
       847
       +
               after = lib.optional cfg.database.createLocally dbUnit;

     

       848
       848
        
       

     

       849
       849
        
               serviceConfig =

     

       850
       850
        
                 {

     
···

       899
       899
        
               requiredBy = [ "movim.service" ];

     

       900
       900
        
               before = [ "movim.service" ] ++ lib.optional (webServerService != null) webServerService;

     

       901
       901
        
               wants = [ "network.target" ];

     

       902
       902
       -
               requires = [ "movim-data-setup.service" ] ++ lib.optional cfg.database.createLocally dbService;

     

       903
       903
       -
               after = [ "movim-data-setup.service" ] ++ lib.optional cfg.database.createLocally dbService;

     

       902
       902
       +
               requires = [ "movim-data-setup.service" ] ++ lib.optional cfg.database.createLocally dbUnit;

     

       903
       903
       +
               after = [ "movim-data-setup.service" ] ++ lib.optional cfg.database.createLocally dbUnit;

     

       904
       904
        
             };

     

       905
       905
        
       

     

       906
       906
        
             services.movim = {

     
···

       915
       915
        
                   "movim-data-setup.service"

     

       916
       916
        
                   "${phpExecutionUnit}.service"

     

       917
       917
        
                 ]

     

       918
       918
       -
                 ++ lib.optional cfg.database.createLocally dbService

     

       918
       918
       +
                 ++ lib.optional cfg.database.createLocally dbUnit

     

       919
       919
        
                 ++ lib.optional (webServerService != null) webServerService;

     

       920
       920
        
               after =

     

       921
       921
        
                 [

     

       922
       922
        
                   "movim-data-setup.service"

     

       923
       923
        
                   "${phpExecutionUnit}.service"

     

       924
       924
        
                 ]

     

       925
       925
       -
                 ++ lib.optional cfg.database.createLocally dbService

     

       925
       925
       +
                 ++ lib.optional cfg.database.createLocally dbUnit

     

       926
       926
        
                 ++ lib.optional (webServerService != null) webServerService;

     

       927
       927
        
               environment = {

     

       928
       928
        
                 PUBLIC_URL = "//${cfg.domain}";

+2 -2

nixos/modules/services/web-apps/nextcloud.nix

···

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

     

       1168
       1168
        
                   wants = [ "nextcloud-update-db.service" ];

     

       1169
       1169
        
                   before = [ "phpfpm-nextcloud.service" ];

     

       1170
       1170
       -
                   after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.service";

     

       1171
       1171
       -
                   requires = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.service";

     

       1170
       1170
       +
                   after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.target";

     

       1171
       1171
       +
                   requires = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.target";

     

       1172
       1172
        
                   path = [ occ ];

     

       1173
       1173
        
                   restartTriggers = [ overrideConfig ];

     

       1174
       1174
        
                   script = ''

+2 -2

nixos/modules/services/web-apps/nipap.nix

···

       234
       234
        
                   after = [

     

       235
       235
        
                     "network.target"

     

       236
       236
        
                     "systemd-tmpfiles-setup.service"

     

       237
       237
       -
                   ] ++ lib.optional (cfg.settings.nipapd.db_host == "") "postgresql.service";

     

       238
       238
       -
                   requires = lib.optional (cfg.settings.nipapd.db_host == "") "postgresql.service";

     

       237
       237
       +
                   ] ++ lib.optional (cfg.settings.nipapd.db_host == "") "postgresql.target";

     

       238
       238
       +
                   requires = lib.optional (cfg.settings.nipapd.db_host == "") "postgresql.target";

     

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

     

       240
       240
        
                   preStart = lib.optionalString (cfg.settings.auth.default_backend == defaultAuthBackend) ''

     

       241
       241
        
                     # Create/upgrade local auth database

+4 -4

nixos/modules/services/web-apps/onlyoffice.nix

···

       235
       235
        
               after = [

     

       236
       236
        
                 "network.target"

     

       237
       237
        
                 "onlyoffice-docservice.service"

     

       238
       238
       -
                 "postgresql.service"

     

       238
       238
       +
                 "postgresql.target"

     

       239
       239
        
               ];

     

       240
       240
        
               requires = [

     

       241
       241
        
                 "network.target"

     

       242
       242
        
                 "onlyoffice-docservice.service"

     

       243
       243
       -
                 "postgresql.service"

     

       243
       243
       +
                 "postgresql.target"

     

       244
       244
        
               ];

     

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

     

       246
       246
        
               serviceConfig = {

     
···

       314
       314
        
                 description = "onlyoffice documentserver";

     

       315
       315
        
                 after = [

     

       316
       316
        
                   "network.target"

     

       317
       317
       -
                   "postgresql.service"

     

       317
       317
       +
                   "postgresql.target"

     

       318
       318
        
                 ];

     

       319
       319
       -
                 requires = [ "postgresql.service" ];

     

       319
       319
       +
                 requires = [ "postgresql.target" ];

     

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

     

       321
       321
        
                 serviceConfig = {

     

       322
       322
        
                   ExecStart = "${cfg.package.fhs}/bin/onlyoffice-wrapper DocService/docservice /run/onlyoffice/config";

+2 -2

nixos/modules/services/web-apps/outline.nix

···

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

     

       635
       635
        
               after =

     

       636
       636
        
                 [ "networking.target" ]

     

       637
       637
       -
                 ++ lib.optional (cfg.databaseUrl == "local") "postgresql.service"

     

       637
       637
       +
                 ++ lib.optional (cfg.databaseUrl == "local") "postgresql.target"

     

       638
       638
        
                 ++ lib.optional (cfg.redisUrl == "local") "redis-outline.service";

     

       639
       639
        
               requires =

     

       640
       640
       -
                 lib.optional (cfg.databaseUrl == "local") "postgresql.service"

     

       640
       640
       +
                 lib.optional (cfg.databaseUrl == "local") "postgresql.target"

     

       641
       641
        
                 ++ lib.optional (cfg.redisUrl == "local") "redis-outline.service";

     

       642
       642
        
               path = [

     

       643
       643
        
                 pkgs.openssl # Required by the preStart script

+3 -3

nixos/modules/services/web-apps/part-db.nix

···

       195
       195
        
             services = {

     

       196
       196
        
               part-db-migrate = {

     

       197
       197
        
                 before = [ "phpfpm-part-db.service" ];

     

       198
       198
       -
                 after = [ "postgresql.service" ];

     

       199
       199
       -
                 requires = [ "postgresql.service" ];

     

       198
       198
       +
                 after = [ "postgresql.target" ];

     

       199
       199
       +
                 requires = [ "postgresql.target" ];

     

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

     

       201
       201
        
                 serviceConfig = {

     

       202
       202
        
                   Type = "oneshot";

     
···

       216
       216
        
                 after = [ "part-db-migrate.service" ];

     

       217
       217
        
                 requires = [

     

       218
       218
        
                   "part-db-migrate.service"

     

       219
       219
       -
                   "postgresql.service"

     

       219
       219
       +
                   "postgresql.target"

     

       220
       220
        
                 ];

     

       221
       221
        
                 # ensure nginx can access the php-fpm socket

     

       222
       222
        
                 postStart = ''

+4 -4

nixos/modules/services/web-apps/peertube.nix

···

       439
       439
        
             description = "Initialization database for PeerTube daemon";

     

       440
       440
        
             after = [

     

       441
       441
        
               "network.target"

     

       442
       442
       -
               "postgresql.service"

     

       442
       442
       +
               "postgresql.target"

     

       443
       443
        
             ];

     

       444
       444
       -
             requires = [ "postgresql.service" ];

     

       444
       444
       +
             requires = [ "postgresql.target" ];

     

       445
       445
        
       

     

       446
       446
        
             script =

     

       447
       447
        
               let

     
···

       475
       475
        
               [ "network.target" ]

     

       476
       476
        
               ++ lib.optional cfg.redis.createLocally "redis-peertube.service"

     

       477
       477
        
               ++ lib.optionals cfg.database.createLocally [

     

       478
       478
       -
                 "postgresql.service"

     

       478
       478
       +
                 "postgresql.target"

     

       479
       479
        
                 "peertube-init-db.service"

     

       480
       480
        
               ];

     

       481
       481
        
             requires =

     

       482
       482
        
               lib.optional cfg.redis.createLocally "redis-peertube.service"

     

       483
       483
        
               ++ lib.optionals cfg.database.createLocally [

     

       484
       484
       -
                 "postgresql.service"

     

       484
       484
       +
                 "postgresql.target"

     

       485
       485
        
                 "peertube-init-db.service"

     

       486
       486
        
               ];

     

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

+6 -6

nixos/modules/services/web-apps/pixelfed.nix

···

       53
       53
        
             "mysql" = "/run/mysqld/mysqld.sock";

     

       54
       54
        
           }

     

       55
       55
        
           .${cfg.database.type};

     

       56
       56
       -
         dbService =

     

       56
       56
       +
         dbUnit =

     

       57
       57
        
           {

     

       58
       58
       -
             "pgsql" = "postgresql.service";

     

       58
       58
       +
             "pgsql" = "postgresql.target";

     

       59
       59
        
             "mysql" = "mysql.service";

     

       60
       60
        
           }

     

       61
       61
        
           .${cfg.database.type};

     
···

       355
       355
        
               "pixelfed-horizon.service"

     

       356
       356
        
               "pixelfed-data-setup.service"

     

       357
       357
        
             ]

     

       358
       358
       -
             ++ lib.optional cfg.database.createLocally dbService

     

       358
       358
       +
             ++ lib.optional cfg.database.createLocally dbUnit

     

       359
       359
        
             ++ lib.optional cfg.redis.createLocally redisService;

     

       360
       360
        
           # Ensure image optimizations programs are available.

     

       361
       361
        
           systemd.services.phpfpm-pixelfed.path = extraPrograms;

     
···

       368
       368
        
             ];

     

       369
       369
        
             requires =

     

       370
       370
        
               [ "pixelfed-data-setup.service" ]

     

       371
       371
       -
               ++ (lib.optional cfg.database.createLocally dbService)

     

       371
       371
       +
               ++ (lib.optional cfg.database.createLocally dbUnit)

     

       372
       372
        
               ++ (lib.optional cfg.redis.createLocally redisService);

     

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

     

       374
       374
        
             # Ensure image optimizations programs are available.

     
···

       412
       412
        
           systemd.services.pixelfed-data-setup = {

     

       413
       413
        
             description = "Pixelfed setup: migrations, environment file update, cache reload, data changes";

     

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

     

       415
       415
       -
             after = lib.optional cfg.database.createLocally dbService;

     

       416
       416
       -
             requires = lib.optional cfg.database.createLocally dbService;

     

       415
       415
       +
             after = lib.optional cfg.database.createLocally dbUnit;

     

       416
       416
       +
             requires = lib.optional cfg.database.createLocally dbUnit;

     

       417
       417
        
             path =

     

       418
       418
        
               with pkgs;

     

       419
       419
        
               [

+3 -3

nixos/modules/services/web-apps/plausible.nix

···

       196
       196
        
                 after =

     

       197
       197
        
                   optional cfg.database.clickhouse.setup "clickhouse.service"

     

       198
       198
        
                   ++ optionals cfg.database.postgres.setup [

     

       199
       199
       -
                     "postgresql.service"

     

       199
       199
       +
                     "postgresql.target"

     

       200
       200
        
                     "plausible-postgres.service"

     

       201
       201
        
                   ];

     

       202
       202
        
                 requires =

     

       203
       203
        
                   optional cfg.database.clickhouse.setup "clickhouse.service"

     

       204
       204
        
                   ++ optionals cfg.database.postgres.setup [

     

       205
       205
       -
                     "postgresql.service"

     

       205
       205
       +
                     "postgresql.target"

     

       206
       206
        
                     "plausible-postgres.service"

     

       207
       207
        
                   ];

     

       208
       208
        
       

     
···

       309
       309
        
             (mkIf cfg.database.postgres.setup {

     

       310
       310
        
               # `plausible' requires the `citext'-extension.

     

       311
       311
        
               plausible-postgres = {

     

       312
       312
       -
                 after = [ "postgresql.service" ];

     

       312
       312
       +
                 after = [ "postgresql.target" ];

     

       313
       313
        
                 partOf = [ "plausible.service" ];

     

       314
       314
        
                 serviceConfig = {

     

       315
       315
        
                   Type = "oneshot";

+2 -2

nixos/modules/services/web-apps/pretalx.nix

···

       434
       434
        
                     "redis-pretalx.service"

     

       435
       435
        
                   ]

     

       436
       436
        
                   ++ lib.optionals (cfg.settings.database.backend == "postgresql") [

     

       437
       437
       -
                     "postgresql.service"

     

       437
       437
       +
                     "postgresql.target"

     

       438
       438
        
                   ]

     

       439
       439
        
                   ++ lib.optionals (cfg.settings.database.backend == "mysql") [

     

       440
       440
        
                     "mysql.service"

     
···

       484
       484
        
                       "redis-pretalx.service"

     

       485
       485
        
                     ]

     

       486
       486
        
                     ++ lib.optionals (cfg.settings.database.backend == "postgresql") [

     

       487
       487
       -
                       "postgresql.service"

     

       487
       487
       +
                       "postgresql.target"

     

       488
       488
        
                     ]

     

       489
       489
        
                     ++ lib.optionals (cfg.settings.database.backend == "mysql") [

     

       490
       490
        
                       "mysql.service"

+2 -2

nixos/modules/services/web-apps/pretix.nix

···

       533
       533
        
                 after = [

     

       534
       534
        
                   "network.target"

     

       535
       535
        
                   "redis-pretix.service"

     

       536
       536
       -
                   "postgresql.service"

     

       536
       536
       +
                   "postgresql.target"

     

       537
       537
        
                 ];

     

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

     

       539
       539
        
                 preStart = ''

     
···

       574
       574
        
                 after = [

     

       575
       575
        
                   "network.target"

     

       576
       576
        
                   "redis-pretix.service"

     

       577
       577
       -
                   "postgresql.service"

     

       577
       577
       +
                   "postgresql.target"

     

       578
       578
        
                 ];

     

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

     

       580
       580
        
                 serviceConfig = {

+1 -1

nixos/modules/services/web-apps/reposilite.nix

···

       398
       398
        
             after =

     

       399
       399
        
               [ "network.target" ]

     

       400
       400
        
               ++ (lib.optional useMySQL "mysql.service")

     

       401
       401
       -
               ++ (lib.optional usePostgres "postgresql.service");

     

       401
       401
       +
               ++ (lib.optional usePostgres "postgresql.target");

     

       402
       402
        
       

     

       403
       403
        
             script =

     

       404
       404
        
               lib.optionalString (cfg.keyPasswordFile != null && cfg.settings.keyPassword == null) ''

+1 -1

nixos/modules/services/web-apps/shiori.nix

···

       62
       62
        
             description = "Shiori simple bookmarks manager";

     

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

     

       64
       64
        
             after = [

     

       65
       65
       -
               "postgresql.service"

     

       65
       65
       +
               "postgresql.target"

     

       66
       66
        
               "mysql.service"

     

       67
       67
        
             ];

     

       68
       68
        
             environment =

+2 -2

nixos/modules/services/web-apps/sogo.nix

···

       104
       104
        
           systemd.services.sogo = {

     

       105
       105
        
             description = "SOGo groupware";

     

       106
       106
        
             after = [

     

       107
       107
       -
               "postgresql.service"

     

       107
       107
       +
               "postgresql.target"

     

       108
       108
        
               "mysql.service"

     

       109
       109
        
               "memcached.service"

     

       110
       110
        
               "openldap.service"

     
···

       191
       191
        
             description = "SOGo email alarms";

     

       192
       192
        
       

     

       193
       193
        
             after = [

     

       194
       194
       -
               "postgresql.service"

     

       194
       194
       +
               "postgresql.target"

     

       195
       195
        
               "mysqld.service"

     

       196
       196
        
               "memcached.service"

     

       197
       197
        
               "openldap.service"

+2 -2

nixos/modules/services/web-apps/tt-rss.nix

···

       667
       667
        
               };

     

       668
       668
        
       

     

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

     

       670
       670
       -
               requires = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.service";

     

       670
       670
       +
               requires = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.target";

     

       671
       671
        
               after =

     

       672
       672
        
                 [ "network.target" ]

     

       673
       673
        
                 ++ optional mysqlLocal "mysql.service"

     

       674
       674
       -
                 ++ optional pgsqlLocal "postgresql.service";

     

       674
       674
       +
                 ++ optional pgsqlLocal "postgresql.target";

     

       675
       675
        
             };

     

       676
       676
        
           };

     

       677
       677

+1 -1

nixos/modules/services/web-apps/vikunja.nix

···

       117
       117
        
             description = "vikunja";

     

       118
       118
        
             after =

     

       119
       119
        
               [ "network.target" ]

     

       120
       120
       -
               ++ lib.optional usePostgresql "postgresql.service"

     

       120
       120
       +
               ++ lib.optional usePostgresql "postgresql.target"

     

       121
       121
        
               ++ lib.optional useMysql "mysql.service";

     

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

     

       123
       123
        
             path = [ cfg.package ];

+2 -2

nixos/modules/services/web-apps/wakapi.nix

···

       135
       135
        
             description = "Wakapi (self-hosted WakaTime-compatible backend)";

     

       136
       136
        
             wants = [

     

       137
       137
        
               "network-online.target"

     

       138
       138
       -
             ] ++ optional (cfg.database.dialect == "postgres") "postgresql.service";

     

       138
       138
       +
             ] ++ optional (cfg.database.dialect == "postgres") "postgresql.target";

     

       139
       139
        
             after = [

     

       140
       140
        
               "network-online.target"

     

       141
       141
       -
             ] ++ optional (cfg.database.dialect == "postgres") "postgresql.service";

     

       141
       141
       +
             ] ++ optional (cfg.database.dialect == "postgres") "postgresql.target";

     

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

     

       143
       143
        
       

     

       144
       144
        
             script = ''

+2 -2

nixos/modules/services/web-apps/weblate.nix

···

       251
       251
        
       

     

       252
       252
        
           systemd.services.weblate-postgresql-setup = {

     

       253
       253
        
             description = "Weblate PostgreSQL setup";

     

       254
       254
       -
             after = [ "postgresql.service" ];

     

       254
       254
       +
             after = [ "postgresql.target" ];

     

       255
       255
        
             serviceConfig = {

     

       256
       256
        
               Type = "oneshot";

     

       257
       257
        
               User = "postgres";

     
···

       290
       290
        
             after = [

     

       291
       291
        
               "network.target"

     

       292
       292
        
               "redis-weblate.service"

     

       293
       293
       -
               "postgresql.service"

     

       293
       293
       +
               "postgresql.target"

     

       294
       294
        
             ];

     

       295
       295
        
             # We want this to be active on boot, not just on socket activation

     

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

+30 -32

nixos/modules/services/web-apps/windmill.nix

···

       134
       134
        
               # coming from https://github.com/windmill-labs/windmill/blob/main/init-db-as-superuser.sql

     

       135
       135
        
               # modified to not grant privileges on all tables

     

       136
       136
        
               # create role windmill_user and windmill_admin only if they don't exist

     

       137
       137
       -
               postgresql.postStart = lib.mkIf cfg.database.createLocally (

     

       138
       138
       -
                 lib.mkAfter ''

     

       139
       139
       -
                         $PSQL -tA <<"EOF"

     

       140
       140
       -
                   DO $$

     

       141
       141
       -
                   BEGIN

     

       142
       142
       -
                       IF NOT EXISTS (

     

       143
       143
       -
                           SELECT FROM pg_catalog.pg_roles

     

       144
       144
       -
                           WHERE rolname = 'windmill_user'

     

       145
       145
       -
                       ) THEN

     

       146
       146
       -
                           CREATE ROLE windmill_user;

     

       147
       147
       -
                           GRANT ALL PRIVILEGES ON DATABASE ${cfg.database.name} TO windmill_user;

     

       148
       148
       -
                       ELSE

     

       149
       149
       -
                         RAISE NOTICE 'Role "windmill_user" already exists. Skipping.';

     

       150
       150
       -
                       END IF;

     

       151
       151
       -
                       IF NOT EXISTS (

     

       152
       152
       -
                           SELECT FROM pg_catalog.pg_roles

     

       153
       153
       -
                           WHERE rolname = 'windmill_admin'

     

       154
       154
       -
                       ) THEN

     

       155
       155
       -
                         CREATE ROLE windmill_admin WITH BYPASSRLS;

     

       156
       156
       -
                         GRANT windmill_user TO windmill_admin;

     

       157
       157
       -
                       ELSE

     

       158
       158
       -
                         RAISE NOTICE 'Role "windmill_admin" already exists. Skipping.';

     

       159
       159
       -
                       END IF;

     

       160
       160
       -
                       GRANT windmill_admin TO windmill;

     

       161
       161
       -
                   END

     

       162
       162
       -
                   $$;

     

       163
       163
       -
                   EOF

     

       164
       164
       -
                 ''

     

       165
       165
       -
               );

     

       137
       137
       +
               postgresql.postStart = lib.mkIf cfg.database.createLocally ''

     

       138
       138
       +
                 psql -tA <<"EOF"

     

       139
       139
       +
                 DO $$

     

       140
       140
       +
                 BEGIN

     

       141
       141
       +
                     IF NOT EXISTS (

     

       142
       142
       +
                         SELECT FROM pg_catalog.pg_roles

     

       143
       143
       +
                         WHERE rolname = 'windmill_user'

     

       144
       144
       +
                     ) THEN

     

       145
       145
       +
                         CREATE ROLE windmill_user;

     

       146
       146
       +
                         GRANT ALL PRIVILEGES ON DATABASE ${cfg.database.name} TO windmill_user;

     

       147
       147
       +
                     ELSE

     

       148
       148
       +
                       RAISE NOTICE 'Role "windmill_user" already exists. Skipping.';

     

       149
       149
       +
                     END IF;

     

       150
       150
       +
                     IF NOT EXISTS (

     

       151
       151
       +
                         SELECT FROM pg_catalog.pg_roles

     

       152
       152
       +
                         WHERE rolname = 'windmill_admin'

     

       153
       153
       +
                     ) THEN

     

       154
       154
       +
                       CREATE ROLE windmill_admin WITH BYPASSRLS;

     

       155
       155
       +
                       GRANT windmill_user TO windmill_admin;

     

       156
       156
       +
                     ELSE

     

       157
       157
       +
                       RAISE NOTICE 'Role "windmill_admin" already exists. Skipping.';

     

       158
       158
       +
                     END IF;

     

       159
       159
       +
                     GRANT windmill_admin TO windmill;

     

       160
       160
       +
                 END

     

       161
       161
       +
                 $$;

     

       162
       162
       +
                 EOF

     

       163
       163
       +
               '';

     

       166
       164
        
       

     

       167
       165
        
               windmill-server = {

     

       168
       166
        
                 description = "Windmill server";

     

       169
       169
       -
                 after = [ "network.target" ] ++ lib.optional cfg.database.createLocally "postgresql.service";

     

       167
       167
       +
                 after = [ "network.target" ] ++ lib.optional cfg.database.createLocally "postgresql.target";

     

       170
       168
        
                 wantedBy = [ "multi-user.target" ];

     

       171
       169
        
       

     

       172
       170
        
                 serviceConfig = serviceConfig // {

     
···

       183
       181
        
       

     

       184
       182
        
               windmill-worker = {

     

       185
       183
        
                 description = "Windmill worker";

     

       186
       186
       -
                 after = [ "network.target" ] ++ lib.optional cfg.database.createLocally "postgresql.service";

     

       184
       184
       +
                 after = [ "network.target" ] ++ lib.optional cfg.database.createLocally "postgresql.target";

     

       187
       185
        
                 wantedBy = [ "multi-user.target" ];

     

       188
       186
        
       

     

       189
       187
        
                 serviceConfig = serviceConfig // {

     
···

       201
       199
        
       

     

       202
       200
        
               windmill-worker-native = {

     

       203
       201
        
                 description = "Windmill worker native";

     

       204
       204
       -
                 after = [ "network.target" ] ++ lib.optional cfg.database.createLocally "postgresql.service";

     

       202
       202
       +
                 after = [ "network.target" ] ++ lib.optional cfg.database.createLocally "postgresql.target";

     

       205
       203
        
                 wantedBy = [ "multi-user.target" ];

     

       206
       204
        
       

     

       207
       205
        
                 serviceConfig = serviceConfig // {

+2 -2

nixos/modules/services/web-apps/zipline.nix

···

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

     

       94
       94
        
       

     

       95
       95
        
             wants = [ "network-online.target" ];

     

       96
       96
       -
             after = [ "network-online.target" ] ++ lib.optional cfg.database.createLocally "postgresql.service";

     

       97
       97
       -
             requires = lib.optional cfg.database.createLocally "postgresql.service";

     

       96
       96
       +
             after = [ "network-online.target" ] ++ lib.optional cfg.database.createLocally "postgresql.target";

     

       97
       97
       +
             requires = lib.optional cfg.database.createLocally "postgresql.target";

     

       98
       98
        
       

     

       99
       99
        
             environment = lib.mapAttrs (_: value: toString value) cfg.settings;

     

       100
       100

+1 -1

nixos/modules/services/web-servers/keter/default.nix

···

       182
       182
        
               after = [

     

       183
       183
        
                 "network.target"

     

       184
       184
        
                 "local-fs.target"

     

       185
       185
       -
                 "postgresql.service"

     

       185
       185
       +
                 "postgresql.target"

     

       186
       186
        
               ];

     

       187
       187
        
             };

     

       188
       188

+1 -1

nixos/tests/coder.nix

···

       14
       14
        
       

     

       15
       15
        
         testScript = ''

     

       16
       16
        
           machine.start()

     

       17
       17
       -
           machine.wait_for_unit("postgresql.service")

     

       17
       17
       +
           machine.wait_for_unit("postgresql.target")

     

       18
       18
        
           machine.wait_for_unit("coder.service")

     

       19
       19
        
           machine.wait_for_open_port(3000)

     

       20
       20

+1 -1

nixos/tests/davis.nix

···

       55
       55
        
         testScript = ''

     

       56
       56
        
           start_all()

     

       57
       57
        
       

     

       58
       58
       -
           machine1.wait_for_unit("postgresql.service")

     

       58
       58
       +
           machine1.wait_for_unit("postgresql.target")

     

       59
       59
        
           machine1.wait_for_unit("davis-env-setup.service")

     

       60
       60
        
           machine1.wait_for_unit("davis-db-migrate.service")

     

       61
       61
        
           machine1.wait_for_unit("phpfpm-davis.service")

+2 -2

nixos/tests/documize.nix

···

       18
       18
        
             };

     

       19
       19
        
       

     

       20
       20
        
             systemd.services.documize-server = {

     

       21
       21
       -
               after = [ "postgresql.service" ];

     

       22
       22
       -
               requires = [ "postgresql.service" ];

     

       21
       21
       +
               after = [ "postgresql.target" ];

     

       22
       22
       +
               requires = [ "postgresql.target" ];

     

       23
       23
        
             };

     

       24
       24
        
       

     

       25
       25
        
             services.postgresql = {

+2 -2

nixos/tests/ferretdb.nix

···

       29
       29
        
               };

     

       30
       30
        
       

     

       31
       31
        
               systemd.services.ferretdb.serviceConfig = {

     

       32
       32
       -
                 Requires = "postgresql.service";

     

       33
       33
       -
                 After = "postgresql.service";

     

       32
       32
       +
                 Requires = "postgresql.target";

     

       33
       33
       +
                 After = "postgresql.target";

     

       34
       34
        
               };

     

       35
       35
        
       

     

       36
       36
        
               services.postgresql = {

+1 -1

nixos/tests/firefly-iii.nix

···

       105
       105
        
           fireflySqlite.succeed("systemctl start firefly-iii-cron.service")

     

       106
       106
        
           fireflyPostgresql.wait_for_unit("phpfpm-firefly-iii.service")

     

       107
       107
        
           fireflyPostgresql.wait_for_unit("nginx.service")

     

       108
       108
       -
           fireflyPostgresql.wait_for_unit("postgresql.service")

     

       108
       108
       +
           fireflyPostgresql.wait_for_unit("postgresql.target")

     

       109
       109
        
           fireflyPostgresql.succeed("curl -fvvv -Ls http://localhost/ | grep 'Firefly III'")

     

       110
       110
        
           fireflyPostgresql.succeed("systemctl start firefly-iii-cron.service")

     

       111
       111
        
           fireflyMysql.wait_for_unit("phpfpm-firefly-iii.service")

+2 -2

nixos/tests/freshrss/pgsql.nix

···

       38
       38
        
               };

     

       39
       39
        
       

     

       40
       40
        
               systemd.services."freshrss-config" = {

     

       41
       41
       -
                 requires = [ "postgresql.service" ];

     

       42
       42
       -
                 after = [ "postgresql.service" ];

     

       41
       41
       +
                 requires = [ "postgresql.target" ];

     

       42
       42
       +
                 after = [ "postgresql.target" ];

     

       43
       43
        
               };

     

       44
       44
        
             };

     

       45
       45

+1 -1

nixos/tests/gancio.nix

···

       67
       67
        
         testScript = ''

     

       68
       68
        
           start_all()

     

       69
       69
        
       

     

       70
       70
       -
           server.wait_for_unit("postgresql")

     

       70
       70
       +
           server.wait_for_unit("postgresql.target")

     

       71
       71
        
           server.wait_for_unit("gancio")

     

       72
       72
        
           server.wait_for_unit("nginx")

     

       73
       73
        
           server.wait_for_file("/run/gancio/socket")

+1 -1

nixos/tests/gitlab.nix

···

       488
       488
        
             gitlab.systemctl("start gitlab-backup.service")

     

       489
       489
        
             gitlab.wait_for_unit("gitlab-backup.service")

     

       490
       490
        
             gitlab.wait_for_file("${nodes.gitlab.services.gitlab.statePath}/backup/dump_gitlab_backup.tar")

     

       491
       491
       -
             gitlab.systemctl("stop postgresql.service gitlab-config.service gitlab.target")

     

       491
       491
       +
             gitlab.systemctl("stop postgresql gitlab-config.service gitlab.target")

     

       492
       492
        
             gitlab.succeed(

     

       493
       493
        
                 "find ${nodes.gitlab.services.gitlab.statePath} -mindepth 1 -maxdepth 1 -not -name backup -execdir rm -r {} +"

     

       494
       494
        
             )

+2 -2

nixos/tests/grafana/basic.nix

···

       63
       63
        
                   }

     

       64
       64
        
                 ];

     

       65
       65
        
               };

     

       66
       66
       -
               systemd.services.grafana.after = [ "postgresql.service" ];

     

       66
       66
       +
               systemd.services.grafana.after = [ "postgresql.target" ];

     

       67
       67
        
             };

     

       68
       68
        
       

     

       69
       69
        
             mysql = {

     
···

       133
       133
        
       

     

       134
       134
        
             with subtest("Successful API query as admin user with postgresql db"):

     

       135
       135
        
                 postgresql.wait_for_unit("grafana.service")

     

       136
       136
       -
                 postgresql.wait_for_unit("postgresql.service")

     

       136
       136
       +
                 postgresql.wait_for_unit("postgresql.target")

     

       137
       137
        
                 postgresql.wait_for_open_port(3000)

     

       138
       138
        
                 postgresql.wait_for_open_port(5432)

     

       139
       139
        
                 postgresql.succeed(

+4 -4

nixos/tests/hedgedoc.nix

···

       13
       13
        
           hedgedocPostgresWithTCPSocket =

     

       14
       14
        
             { ... }:

     

       15
       15
        
             {

     

       16
       16
       -
               systemd.services.hedgedoc.after = [ "postgresql.service" ];

     

       16
       16
       +
               systemd.services.hedgedoc.after = [ "postgresql.target" ];

     

       17
       17
        
               services = {

     

       18
       18
        
                 hedgedoc = {

     

       19
       19
        
                   enable = true;

     
···

       47
       47
        
           hedgedocPostgresWithUNIXSocket =

     

       48
       48
        
             { ... }:

     

       49
       49
        
             {

     

       50
       50
       -
               systemd.services.hedgedoc.after = [ "postgresql.service" ];

     

       50
       50
       +
               systemd.services.hedgedoc.after = [ "postgresql.target" ];

     

       51
       51
        
               services = {

     

       52
       52
        
                 hedgedoc = {

     

       53
       53
        
                   enable = true;

     
···

       83
       83
        
               hedgedocSqlite.wait_until_succeeds("curl -sSf http://localhost:3000/new")

     

       84
       84
        
       

     

       85
       85
        
           with subtest("HedgeDoc postgres with TCP socket"):

     

       86
       86
       -
               hedgedocPostgresWithTCPSocket.wait_for_unit("postgresql.service")

     

       86
       86
       +
               hedgedocPostgresWithTCPSocket.wait_for_unit("postgresql.target")

     

       87
       87
        
               hedgedocPostgresWithTCPSocket.wait_for_unit("hedgedoc.service")

     

       88
       88
        
               hedgedocPostgresWithTCPSocket.wait_for_open_port(5432)

     

       89
       89
        
               hedgedocPostgresWithTCPSocket.wait_for_open_port(3000)

     

       90
       90
        
               hedgedocPostgresWithTCPSocket.wait_until_succeeds("curl -sSf http://localhost:3000/new")

     

       91
       91
        
       

     

       92
       92
        
           with subtest("HedgeDoc postgres with UNIX socket"):

     

       93
       93
       -
               hedgedocPostgresWithUNIXSocket.wait_for_unit("postgresql.service")

     

       93
       93
       +
               hedgedocPostgresWithUNIXSocket.wait_for_unit("postgresql.target")

     

       94
       94
        
               hedgedocPostgresWithUNIXSocket.wait_for_unit("hedgedoc.service")

     

       95
       95
        
               hedgedocPostgresWithUNIXSocket.wait_for_open_port(5432)

     

       96
       96
        
               hedgedocPostgresWithUNIXSocket.wait_for_open_port(3000)

+1 -1

nixos/tests/hydra/default.nix

···

       18
       18
        
           # let the system boot up

     

       19
       19
        
           machine.wait_for_unit("multi-user.target")

     

       20
       20
        
           # test whether the database is running

     

       21
       21
       -
           machine.wait_for_unit("postgresql.service")

     

       21
       21
       +
           machine.wait_for_unit("postgresql.target")

     

       22
       22
        
           # test whether the actual hydra daemons are running

     

       23
       23
        
           machine.wait_for_unit("hydra-init.service")

     

       24
       24
        
           machine.require_unit_state("hydra-queue-runner.service")

+1 -1

nixos/tests/invidious.nix

···

       144
       144
        
             curl_assert_status_code("http://invidious.example.com/search", 200)

     

       145
       145
        
             machine.succeed("journalctl -eu invidious.service | grep -o \"SigHelper: Using helper at 'tcp://127.0.0.1:2999'\"")

     

       146
       146
        
       

     

       147
       147
       -
             postgres_tcp.wait_for_unit("postgresql.service")

     

       147
       147
       +
             postgres_tcp.wait_for_unit("postgresql.target")

     

       148
       148
        
             activate_specialisation("postgres-tcp")

     

       149
       149
        
             machine.wait_for_open_port(port)

     

       150
       150
        
             curl_assert_status_code(f"{url}/search", 200)

+1 -1

nixos/tests/listmonk.nix

···

       41
       41
        
                return f'curl -u "{basic_auth}" -X {type} "http://localhost:9000/api/{url}" -H "Content-Type: application/json; charset=utf-8" --data-raw \'{json_data}\'''

     

       42
       42
        
       

     

       43
       43
        
             machine.wait_for_unit("mailhog.service")

     

       44
       44
       -
             machine.wait_for_unit("postgresql.service")

     

       44
       44
       +
             machine.wait_for_unit("postgresql.target")

     

       45
       45
        
             machine.wait_for_unit("listmonk.service")

     

       46
       46
        
             machine.wait_for_open_port(1025)

     

       47
       47
        
             machine.wait_for_open_port(8025)

+1 -1

nixos/tests/matrix/synapse.nix

···

       233
       233
        
           serverpostgres.wait_until_succeeds(

     

       234
       234
        
               "journalctl -u matrix-synapse.service | grep -q 'Connected to redis'"

     

       235
       235
        
           )

     

       236
       236
       -
           serverpostgres.require_unit_state("postgresql.service")

     

       236
       236
       +
           serverpostgres.require_unit_state("postgresql.target")

     

       237
       237
        
           serverpostgres.succeed("REQUESTS_CA_BUNDLE=${ca_pem} register_new_matrix_user -u ${testUser} -p ${testPassword} -a -k ${registrationSharedSecret} https://localhost:8448/")

     

       238
       238
        
           serverpostgres.succeed("obtain-token-and-register-email")

     

       239
       239
        
           serversqlite.wait_for_unit("matrix-synapse.service")

+2 -2

nixos/tests/miniflux.nix

···

       80
       80
        
                   host sameuser miniflux samenet scram-sha-256

     

       81
       81
        
                 '';

     

       82
       82
        
               };

     

       83
       83
       -
               systemd.services.postgresql.postStart = lib.mkAfter ''

     

       83
       83
       +
               systemd.services.postgresql-setup.postStart = lib.mkAfter ''

     

       84
       84
        
                 $PSQL -tAd miniflux -c 'CREATE EXTENSION hstore;'

     

       85
       85
        
               '';

     

       86
       86
        
               networking.firewall.allowedTCPPorts = [ config.services.postgresql.settings.port ];

     
···

       123
       123
        
           runTest(withoutSudo, ${toString defaultPort}, "${defaultUsername}:${defaultPassword}")

     

       124
       124
        
           runTest(customized, ${toString port}, "${username}:${password}")

     

       125
       125
        
       

     

       126
       126
       -
           postgresTcp.wait_for_unit("postgresql.service")

     

       126
       126
       +
           postgresTcp.wait_for_unit("postgresql.target")

     

       127
       127
        
           externalDb.start()

     

       128
       128
        
           runTest(externalDb, ${toString defaultPort}, "${defaultUsername}:${defaultPassword}")

     

       129
       129
        
         '';

+3 -3

nixos/tests/nextcloud/with-declarative-redis-and-secrets.nix

···

       65
       65
        
                 };

     

       66
       66
        
       

     

       67
       67
        
                 systemd.services.nextcloud-setup = {

     

       68
       68
       -
                   requires = [ "postgresql.service" ];

     

       69
       69
       -
                   after = [ "postgresql.service" ];

     

       68
       68
       +
                   requires = [ "postgresql.target" ];

     

       69
       69
       +
                   after = [ "postgresql.target" ];

     

       70
       70
        
                 };

     

       71
       71
        
       

     

       72
       72
        
                 services.postgresql = {

     

       73
       73
        
                   enable = true;

     

       74
       74
        
                 };

     

       75
       75
       -
                 systemd.services.postgresql.postStart = lib.mkAfter ''

     

       75
       75
       +
                 systemd.services.postgresql-setup.postStart = ''

     

       76
       76
        
                   password=$(cat ${config.services.nextcloud.config.dbpassFile})

     

       77
       77
        
                   ${config.services.postgresql.package}/bin/psql <<EOF

     

       78
       78
        
                     CREATE ROLE ${adminuser} WITH LOGIN PASSWORD '$password' CREATEDB;

+2 -2

nixos/tests/pgadmin4.nix

···

       55
       55
        
       

     

       56
       56
        
         testScript = ''

     

       57
       57
        
           with subtest("Check pgadmin module"):

     

       58
       58
       -
             machine.wait_for_unit("postgresql")

     

       58
       58
       +
             machine.wait_for_unit("postgresql.target")

     

       59
       59
        
             machine.wait_for_unit("pgadmin")

     

       60
       60
        
             machine.wait_until_succeeds("curl -sS localhost:5051")

     

       61
       61
        
             machine.wait_until_succeeds("curl -sS localhost:5051/login | grep \"<title>pgAdmin 4</title>\" > /dev/null")

     
···

       80
       80
        
             machine.succeed("wget -nv --level=1 --spider --recursive localhost:5050/browser")

     

       81
       81
        
       

     

       82
       82
        
           with subtest("Check pgadmin minimum password length"):

     

       83
       83
       -
             machine2.wait_for_unit("postgresql")

     

       83
       83
       +
             machine2.wait_for_unit("postgresql.target")

     

       84
       84
        
             machine2.wait_for_console_text("Password must be at least 12 characters long")

     

       85
       85
        
         '';

     

       86
       86
        
       }

+1 -1

nixos/tests/pgbackrest/sftp.nix

···

       89
       89
        
               primary.succeed("sudo -u postgres pgbackrest --stanza=default restore --delta")

     

       90
       90
        
       

     

       91
       91
        
               primary.systemctl("start postgresql")

     

       92
       92
       -
               primary.wait_for_unit("postgresql.service")

     

       92
       92
       +
               primary.wait_for_unit("postgresql.target")

     

       93
       93
        
               assert "hello world" in primary.succeed("sudo -u postgres psql -c 'TABLE t;'")

     

       94
       94
        
           '';

     

       95
       95
        
       }

+1 -1

nixos/tests/pgbouncer.nix

···

       10
       10
        
           one =

     

       11
       11
        
             { pkgs, ... }:

     

       12
       12
        
             {

     

       13
       13
       -
               systemd.services.postgresql = {

     

       13
       13
       +
               systemd.services.postgresql-setup = {

     

       14
       14
        
                 postStart = ''

     

       15
       15
        
                   ${pkgs.postgresql}/bin/psql -U postgres -c "ALTER ROLE testuser WITH LOGIN PASSWORD 'testpass'";

     

       16
       16
        
                   ${pkgs.postgresql}/bin/psql -U postgres -c "ALTER DATABASE testdb OWNER TO testuser;";

+1 -1

nixos/tests/pghero.nix

···

       53
       53
        
               assert http_code.split("\n")[-1].strip() == code, \

     

       54
       54
        
                 f"expected HTTP status code {code} but got {http_code}"

     

       55
       55
        
       

     

       56
       56
       -
           machine.wait_for_unit("postgresql.service")

     

       56
       56
       +
           machine.wait_for_unit("postgresql.target")

     

       57
       57
        
           machine.wait_for_unit("pghero.service")

     

       58
       58
        
       

     

       59
       59
        
           with subtest("requires HTTP Basic Auth credentials"):

+1 -1

nixos/tests/pgweb.nix

···

       19
       19
        
                 ExecStart = "${pkgs.pgweb}/bin/pgweb --url postgresql://postgres@localhost:5432/postgres";

     

       20
       20
        
               };

     

       21
       21
        
               path = [ pkgs.getent ];

     

       22
       22
       -
               after = [ "postgresql.service" ];

     

       22
       22
       +
               after = [ "postgresql.target" ];

     

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

     

       24
       24
        
             };

     

       25
       25
        
           };

+1 -1

nixos/tests/pleroma.nix

···

       266
       266
        
           testScript =

     

       267
       267
        
             { nodes, ... }:

     

       268
       268
        
             ''

     

       269
       269
       -
               pleroma.wait_for_unit("postgresql.service")

     

       269
       269
       +
               pleroma.wait_for_unit("postgresql.target")

     

       270
       270
        
               pleroma.wait_until_succeeds("ls /var/lib/pleroma")

     

       271
       271
        
               pleroma.succeed("provision-db")

     

       272
       272
        
               pleroma.wait_for_file("/var/lib/pleroma")

+1 -1

nixos/tests/postfixadmin.nix

···

       23
       23
        
       

     

       24
       24
        
         testScript = ''

     

       25
       25
        
           postfixadmin.start

     

       26
       26
       -
           postfixadmin.wait_for_unit("postgresql.service")

     

       26
       26
       +
           postfixadmin.wait_for_unit("postgresql.target")

     

       27
       27
        
           postfixadmin.wait_for_unit("phpfpm-postfixadmin.service")

     

       28
       28
        
           postfixadmin.wait_for_unit("nginx.service")

     

       29
       29
        
           postfixadmin.succeed(

+1 -1

nixos/tests/postgres-websockets.nix

···

       58
       58
        
             token = jwt.encode({ "mode": "rw" }, "reallyreallyreallyreallyverysafe")

     

       59
       59
        
       

     

       60
       60
        
             def test():

     

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

     

       61
       61
       +
                 machine.wait_for_unit("postgresql.target")

     

       62
       62
        
                 machine.wait_for_unit("postgres-websockets.service")

     

       63
       63
        
       

     

       64
       64
        
                 machine.succeed(f"echo 'hi there' | websocat --no-close 'ws://localhost:3000/test/{token}' > output &")

+1 -1

nixos/tests/postgresql/anonymizer.nix

···

       28
       28
        
             testScript = ''

     

       29
       29
        
               start_all()

     

       30
       30
        
               machine.wait_for_unit("multi-user.target")

     

       31
       31
       -
               machine.wait_for_unit("postgresql.service")

     

       31
       31
       +
               machine.wait_for_unit("postgresql.target")

     

       32
       32
        
       

     

       33
       33
        
               with subtest("Setup"):

     

       34
       34
        
                   machine.succeed("sudo -u postgres psql --command 'create database demo'")

+1 -1

nixos/tests/postgresql/pgjwt.nix

···

       40
       40
        
               in

     

       41
       41
        
               ''

     

       42
       42
        
                 start_all()

     

       43
       43
       -
                 master.wait_for_unit("postgresql")

     

       43
       43
       +
                 master.wait_for_unit("postgresql.target")

     

       44
       44
        
                 master.succeed(

     

       45
       45
        
                     "${pkgs.sudo}/bin/sudo -u ${sqlSU} ${pgProve}/bin/pg_prove -d postgres -v -f ${pgjwt.src}/test.sql"

     

       46
       46
        
                 )

+1 -1

nixos/tests/postgresql/postgresql-jit.nix

···

       29
       29
        
       

     

       30
       30
        
             testScript = ''

     

       31
       31
        
               machine.start()

     

       32
       32
       -
               machine.wait_for_unit("postgresql.service")

     

       32
       32
       +
               machine.wait_for_unit("postgresql.target")

     

       33
       33
        
       

     

       34
       34
        
               with subtest("JIT is enabled"):

     

       35
       35
        
                   machine.succeed("sudo -u postgres psql <<<'show jit;' | grep 'on'")

+2 -2

nixos/tests/postgresql/postgresql-wal-receiver.nix

···

       62
       62
        
       

     

       63
       63
        
             testScript = ''

     

       64
       64
        
               # make an initial base backup

     

       65
       65
       -
               machine.wait_for_unit("postgresql")

     

       65
       65
       +
               machine.wait_for_unit("postgresql.target")

     

       66
       66
        
               machine.wait_for_unit("postgresql-wal-receiver-main")

     

       67
       67
        
               # WAL receiver healthchecks PG every 5 seconds, so let's be sure they have connected each other

     

       68
       68
        
               # required only for 9.4

     
···

       99
       99
        
               machine.systemctl("start postgresql")

     

       100
       100
        
               machine.wait_for_file("${postgresqlDataDir}/recovery.done")

     

       101
       101
        
               machine.systemctl("restart postgresql")

     

       102
       102
       -
               machine.wait_for_unit("postgresql")

     

       102
       102
       +
               machine.wait_for_unit("postgresql.target")

     

       103
       103
        
       

     

       104
       104
        
               # check that our records have been restored

     

       105
       105
        
               machine.succeed(

+3 -3

nixos/tests/postgresql/postgresql.nix

···

       82
       82
        
       

     

       83
       83
        
       

     

       84
       84
        
                 machine.start()

     

       85
       85
       -
                 machine.wait_for_unit("postgresql")

     

       85
       85
       +
                 machine.wait_for_unit("postgresql.target")

     

       86
       86
        
       

     

       87
       87
        
                 with subtest("Postgresql is available just after unit start"):

     

       88
       88
        
                     machine.succeed(

     
···

       94
       94
        
                     import time

     

       95
       95
        
                     time.sleep(2)

     

       96
       96
        
                     machine.start()

     

       97
       97
       -
                     machine.wait_for_unit("postgresql")

     

       97
       97
       +
                     machine.wait_for_unit("postgresql.target")

     

       98
       98
        
       

     

       99
       99
        
                 machine.fail(check_count("SELECT * FROM sth;", 3))

     

       100
       100
        
                 machine.succeed(check_count("SELECT * FROM sth;", 5))

     
···

       219
       219
        
               ''

     

       220
       220
        
                 import json

     

       221
       221
        
                 machine.start()

     

       222
       222
       -
                 machine.wait_for_unit("postgresql")

     

       222
       222
       +
                 machine.wait_for_unit("postgresql.target")

     

       223
       223
        
       

     

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

     

       225
       225
        
                     clauses = json.loads(

+1 -1

nixos/tests/postgresql/wal2json.nix

···

       27
       27
        
             };

     

       28
       28
        
       

     

       29
       29
        
             testScript = ''

     

       30
       30
       -
               machine.wait_for_unit("postgresql")

     

       30
       30
       +
               machine.wait_for_unit("postgresql.target")

     

       31
       31
        
               machine.succeed(

     

       32
       32
        
                   "sudo -u postgres psql -qAt -f ${./wal2json/example2.sql} postgres > /tmp/example2.out"

     

       33
       33
        
               )

+1 -1

nixos/tests/postgrest.nix

···

       57
       57
        
           ''

     

       58
       58
        
             import jwt

     

       59
       59
        
       

     

       60
       60
       -
             machine.wait_for_unit("postgresql.service")

     

       60
       60
       +
             machine.wait_for_unit("postgresql.target")

     

       61
       61
        
       

     

       62
       62
        
             def wait_for_postgrest():

     

       63
       63
        
                 machine.wait_for_unit("postgrest.service")

+1 -1

nixos/tests/powerdns-admin.nix

···

       92
       92
        
                 '';

     

       93
       93
        
               };

     

       94
       94
        
               systemd.services.powerdns-admin = {

     

       95
       95
       -
                 after = [ "postgresql.service" ];

     

       95
       95
       +
                 after = [ "postgresql.target" ];

     

       96
       96
        
                 serviceConfig.BindPaths = "/run/postgresql";

     

       97
       97
        
               };

     

       98
       98

+6 -6

nixos/tests/prometheus-exporters.nix

···

       1121
       1121
        
               };

     

       1122
       1122
        
             };

     

       1123
       1123
        
             exporterTest = ''

     

       1124
       1124
       -
               wait_for_unit("postgresql.service")

     

       1124
       1124
       +
               wait_for_unit("postgresql.target")

     

       1125
       1125
        
               wait_for_unit("pgbouncer.service")

     

       1126
       1126
        
               wait_for_unit("prometheus-pgbouncer-exporter.service")

     

       1127
       1127
        
               wait_for_open_port(9127)

     
···

       1254
       1254
        
             exporterTest = ''

     

       1255
       1255
        
               wait_for_unit("prometheus-postgres-exporter.service")

     

       1256
       1256
        
               wait_for_open_port(9187)

     

       1257
       1257
       -
               wait_for_unit("postgresql.service")

     

       1257
       1257
       +
               wait_for_unit("postgresql.target")

     

       1258
       1258
        
               succeed(

     

       1259
       1259
        
                   "curl -sSf http://localhost:9187/metrics | grep 'pg_exporter_last_scrape_error 0'"

     

       1260
       1260
        
               )

     

       1261
       1261
        
               succeed("curl -sSf http://localhost:9187/metrics | grep 'pg_up 1'")

     

       1262
       1262
       -
               systemctl("stop postgresql.service")

     

       1262
       1262
       +
               systemctl("stop postgresql")

     

       1263
       1263
        
               succeed(

     

       1264
       1264
        
                   "curl -sSf http://localhost:9187/metrics | grep -v 'pg_exporter_last_scrape_error 0'"

     

       1265
       1265
        
               )

     

       1266
       1266
        
               succeed("curl -sSf http://localhost:9187/metrics | grep 'pg_up 0'")

     

       1267
       1267
       -
               systemctl("start postgresql.service")

     

       1268
       1268
       -
               wait_for_unit("postgresql.service")

     

       1267
       1267
       +
               systemctl("start postgresql")

     

       1268
       1268
       +
               wait_for_unit("postgresql.target")

     

       1269
       1269
        
               succeed(

     

       1270
       1270
        
                   "curl -sSf http://localhost:9187/metrics | grep 'pg_exporter_last_scrape_error 0'"

     

       1271
       1271
        
               )

     
···

       1609
       1609
        
                   GRANT SELECT ON points TO "prometheus-sql-exporter";

     

       1610
       1610
        
                 '';

     

       1611
       1611
        
               };

     

       1612
       1612
       -
               systemd.services.prometheus-sql-exporter.after = [ "postgresql.service" ];

     

       1612
       1612
       +
               systemd.services.prometheus-sql-exporter.after = [ "postgresql.target" ];

     

       1613
       1613
        
             };

     

       1614
       1614
        
             exporterTest = ''

     

       1615
       1615
        
               wait_for_unit("prometheus-sql-exporter.service")

+1 -1

nixos/tests/roundcube.nix

···

       30
       30
        
       

     

       31
       31
        
         testScript = ''

     

       32
       32
        
           roundcube.start

     

       33
       33
       -
           roundcube.wait_for_unit("postgresql.service")

     

       33
       33
       +
           roundcube.wait_for_unit("postgresql.target")

     

       34
       34
        
           roundcube.wait_for_unit("phpfpm-roundcube.service")

     

       35
       35
        
           roundcube.wait_for_unit("nginx.service")

     

       36
       36
        
           roundcube.succeed("curl -sSfL http://roundcube/ | grep 'Keep me logged in'")

+1 -1

nixos/tests/sftpgo.nix

···

       216
       216
        
               };

     

       217
       217
        
       

     

       218
       218
        
               systemd.services.sftpgo = {

     

       219
       219
       -
                 after = [ "postgresql.service" ];

     

       219
       219
       +
                 after = [ "postgresql.target" ];

     

       220
       220
        
                 environment = {

     

       221
       221
        
                   # Update existing users

     

       222
       222
        
                   SFTPGO_LOADDATA_MODE = "0";

+1 -1

nixos/tests/tandoor-recipes.nix

···

       29
       29
        
       

     

       30
       30
        
             systemd.services = {

     

       31
       31
        
               tandoor-recipes = {

     

       32
       32
       -
                 after = [ "postgresql.service" ];

     

       32
       32
       +
                 after = [ "postgresql.target" ];

     

       33
       33
        
               };

     

       34
       34
        
             };

     

       35
       35
        
           };

+1 -1

nixos/tests/vault-postgresql.nix

···

       25
       25
        
       

     

       26
       26
        
             systemd.services.vault = {

     

       27
       27
        
               after = [

     

       28
       28
       -
                 "postgresql.service"

     

       28
       28
       +
                 "postgresql.target"

     

       29
       29
        
               ];

     

       30
       30
        
               # Try for about 10 minutes rather than the default of 5 attempts.

     

       31
       31
        
               serviceConfig.RestartSec = 1;

+1 -1

nixos/tests/vaultwarden.nix

···

       138
       138
        
       

     

       139
       139
        
                           services.vaultwarden.config.databaseUrl = "postgresql:///vaultwarden?host=/run/postgresql";

     

       140
       140
        
       

     

       141
       141
       -
                           systemd.services.vaultwarden.after = [ "postgresql.service" ];

     

       141
       141
       +
                           systemd.services.vaultwarden.after = [ "postgresql.target" ];

     

       142
       142
        
                         };

     

       143
       143
        
       

     

       144
       144
        
                         sqlite = {

+1 -1

nixos/tests/web-apps/gotosocial.nix

···

       20
       20
        
       

     

       21
       21
        
         testScript = ''

     

       22
       22
        
           machine.wait_for_unit("gotosocial.service")

     

       23
       23
       -
           machine.wait_for_unit("postgresql.service")

     

       23
       23
       +
           machine.wait_for_unit("postgresql.target")

     

       24
       24
        
           machine.wait_for_open_port(8081)

     

       25
       25
        
           # Database migrations are running, wait until gotosocial no longer serves 503

     

       26
       26
        
           machine.wait_until_succeeds("curl -sS -f http://localhost:8081/readyz", timeout=300)

+1 -1

nixos/tests/web-apps/mastodon/remote-databases.nix

···

       207
       207
        
               nginx.wait_for_unit("nginx.service")

     

       208
       208
        
               nginx.wait_for_open_port(443)

     

       209
       209
        
               databases.wait_for_unit("redis-mastodon.service")

     

       210
       210
       -
               databases.wait_for_unit("postgresql.service")

     

       210
       210
       +
               databases.wait_for_unit("postgresql.target")

     

       211
       211
        
               databases.wait_for_open_port(31637)

     

       212
       212
        
               databases.wait_for_open_port(5432)

     

       213
       213
        
             '';

+1 -1

nixos/tests/web-apps/mastodon/standard.nix

···

       101
       101
        
               server.wait_for_unit("nginx.service")

     

       102
       102
        
               server.wait_for_open_port(443)

     

       103
       103
        
               server.wait_for_unit("redis-mastodon.service")

     

       104
       104
       -
               server.wait_for_unit("postgresql.service")

     

       104
       104
       +
               server.wait_for_unit("postgresql.target")

     

       105
       105
        
               server.wait_for_open_port(5432)

     

       106
       106
        
             '';

     

       107
       107
        
           };

+1 -1

nixos/tests/web-apps/peertube.nix

···

       142
       142
        
           testScript = ''

     

       143
       143
        
             start_all()

     

       144
       144
        
       

     

       145
       145
       -
             database.wait_for_unit("postgresql.service")

     

       145
       145
       +
             database.wait_for_unit("postgresql.target")

     

       146
       146
        
             database.wait_for_unit("redis-peertube.service")

     

       147
       147
        
       

     

       148
       148
        
             database.wait_for_open_port(5432)

+2 -2

nixos/tests/wiki-js.nix

···

       27
       27
        
               ];

     

       28
       28
        
             };

     

       29
       29
        
             systemd.services.wiki-js = {

     

       30
       30
       -
               requires = [ "postgresql.service" ];

     

       31
       31
       -
               after = [ "postgresql.service" ];

     

       30
       30
       +
               requires = [ "postgresql.target" ];

     

       31
       31
       +
               after = [ "postgresql.target" ];

     

       32
       32
        
             };

     

       33
       33
        
             environment.systemPackages = with pkgs; [ jq ];

     

       34
       34
        
           };

+1 -1

nixos/tests/zammad.nix

···

       21
       21
        
       

     

       22
       22
        
         testScript = ''

     

       23
       23
        
           start_all()

     

       24
       24
       -
           machine.wait_for_unit("postgresql.service")

     

       24
       24
       +
           machine.wait_for_unit("postgresql.target")

     

       25
       25
        
           machine.wait_for_unit("redis-zammad.service")

     

       26
       26
        
           machine.wait_for_unit("zammad-web.service")

     

       27
       27
        
           machine.wait_for_unit("zammad-websocket.service")