commit 96190535e526bc1f7b8975d9f6f2f6493060203f · pyrox.dev/nixpkgs

+1 -1

nixos/doc/manual/development/releases.xml

···

       70
       70
        
           <listitem>

     

       71
       71
        
            <para>

     

       72
       72
        
             <link xlink:href="https://github.com/NixOS/nixpkgs/compare/bdf161ed8d21...6b63c4616790">

     

       73
       73
       -
             Bump the <literal>system.nixos.defaultChannel</literal> attribute in

     

       73
       73
       +
             Bump the <literal>system.defaultChannel</literal> attribute in

     

       74
       74
        
             <literal>nixos/modules/misc/version.nix</literal> </link>

     

       75
       75
        
            </para>

     

       76
       76
        
           </listitem>

+2 -2

nixos/doc/manual/release-notes/rl-1509.xml

···

       433
       433
        
            default. If you have existing systems with such host keys and want to

     

       434
       434
        
            continue to use them, please set

     

       435
       435
        
       <programlisting>

     

       436
       436
       -
       system.nixos.stateVersion = "14.12";

     

       436
       436
       +
       system.stateVersion = "14.12";

     

       437
       437
        
       </programlisting>

     

       438
       438
       -
            The new option <option>system.nixos.stateVersion</option> ensures that

     

       438
       438
       +
            The new option <option>system.stateVersion</option> ensures that

     

       439
       439
        
            certain configuration changes that could break existing systems (such as

     

       440
       440
        
            the <command>sshd</command> host key setting) will maintain compatibility

     

       441
       441
        
            with the specified NixOS release. NixOps sets the state version of

+1 -1

nixos/modules/installer/cd-dvd/installation-cd-base.nix

···

       32
       32
        
         # Allow the user to log in as root without a password.

     

       33
       33
        
         users.users.root.initialHashedPassword = "";

     

       34
       34
        
       

     

       35
       35
       -
         system.nixos.stateVersion = mkDefault "18.03";

     

       35
       35
       +
         system.stateVersion = mkDefault "18.03";

     

       36
       36
        
       }

+1 -1

nixos/modules/installer/tools/nixos-generate-config.pl

···

       628
       628
        
         # compatible, in order to avoid breaking some software such as database

     

       629
       629
        
         # servers. You should change this only after NixOS release notes say you

     

       630
       630
        
         # should.

     

       631
       631
       -
         system.nixos.stateVersion = "${\(qw(@release@))}"; # Did you read the comment?

     

       631
       631
       +
         system.stateVersion = "${\(qw(@release@))}"; # Did you read the comment?

     

       632
       632
        
       

     

       633
       633
        
       }

     

       634
       634
        
       EOF

+1 -1

nixos/modules/installer/virtualbox-demo.nix

···

       21
       21
        
         services.xserver.videoDrivers = mkOverride 40 [ "virtualbox" "vmware" "cirrus" "vesa" "modesetting" ];

     

       22
       22
        
       

     

       23
       23
        
         powerManagement.enable = false;

     

       24
       24
       -
         system.nixos.stateVersion = mkDefault "18.03";

     

       24
       24
       +
         system.stateVersion = mkDefault "18.03";

     

       25
       25
        
       }

+8 -8

nixos/modules/misc/version.nix

···

       12
       12
        
       

     

       13
       13
        
       {

     

       14
       14
        
       

     

       15
       15
       -
         options.system.nixos = {

     

       15
       15
       +
         options.system = {

     

       16
       16
        
       

     

       17
       17
       -
           version = mkOption {

     

       17
       17
       +
           nixos.version = mkOption {

     

       18
       18
        
             internal = true;

     

       19
       19
        
             type = types.str;

     

       20
       20
        
             description = "The full NixOS version (e.g. <literal>16.03.1160.f2d4ee1</literal>).";

     

       21
       21
        
           };

     

       22
       22
        
       

     

       23
       23
       -
           release = mkOption {

     

       23
       23
       +
           nixos.release = mkOption {

     

       24
       24
        
             readOnly = true;

     

       25
       25
        
             type = types.str;

     

       26
       26
        
             default = trivial.release;

     

       27
       27
        
             description = "The NixOS release (e.g. <literal>16.03</literal>).";

     

       28
       28
        
           };

     

       29
       29
        
       

     

       30
       30
       -
           versionSuffix = mkOption {

     

       30
       30
       +
           nixos.versionSuffix = mkOption {

     

       31
       31
        
             internal = true;

     

       32
       32
        
             type = types.str;

     

       33
       33
        
             default = trivial.versionSuffix;

     

       34
       34
        
             description = "The NixOS version suffix (e.g. <literal>1160.f2d4ee1</literal>).";

     

       35
       35
        
           };

     

       36
       36
        
       

     

       37
       37
       -
           revision = mkOption {

     

       37
       37
       +
           nixos.revision = mkOption {

     

       38
       38
        
             internal = true;

     

       39
       39
        
             type = types.str;

     

       40
       40
        
             default = if pathIsDirectory gitRepo then commitIdFromGitRepo gitRepo

     
···

       43
       43
        
             description = "The Git revision from which this NixOS configuration was built.";

     

       44
       44
        
           };

     

       45
       45
        
       

     

       46
       46
       -
           codeName = mkOption {

     

       46
       46
       +
           nixos.codeName = mkOption {

     

       47
       47
        
             readOnly = true;

     

       48
       48
        
             type = types.str;

     

       49
       49
        
             description = "The NixOS release code name (e.g. <literal>Emu</literal>).";

     
···

       76
       76
        
       

     

       77
       77
        
         config = {

     

       78
       78
        
       

     

       79
       79
       -
           warnings = lib.optional (options.system.nixos.stateVersion.highestPrio > 1000)

     

       80
       80
       -
             "You don't have `system.nixos.stateVersion` explicitly set. Expect things to break.";

     

       79
       79
       +
           warnings = lib.optional (options.system.stateVersion.highestPrio > 1000)

     

       80
       80
       +
             "You don't have `system.stateVersion` explicitly set. Expect things to break.";

     

       81
       81
        
       

     

       82
       82
        
           system.nixos = {

     

       83
       83
        
             # These defaults are set here rather than up there so that

+1 -1

nixos/modules/programs/shell.nix

···

       34
       34
        
       

     

       35
       35
        
                 # Subscribe the root user to the NixOS channel by default.

     

       36
       36
        
                 if [ "$USER" = root -a ! -e "$HOME/.nix-channels" ]; then

     

       37
       37
       -
                     echo "${config.system.nixos.defaultChannel} nixos" > "$HOME/.nix-channels"

     

       37
       37
       +
                     echo "${config.system.defaultChannel} nixos" > "$HOME/.nix-channels"

     

       38
       38
        
                 fi

     

       39
       39
        
       

     

       40
       40
        
                 # Create the per-user garbage collector roots directory.

-2

nixos/modules/rename.nix

···

       222
       222
        
           (mkRenamedOptionModule [ "system" "nixosVersionSuffix" ] [ "system" "nixos" "versionSuffix" ])

     

       223
       223
        
           (mkRenamedOptionModule [ "system" "nixosRevision" ] [ "system" "nixos" "revision" ])

     

       224
       224
        
           (mkRenamedOptionModule [ "system" "nixosLabel" ] [ "system" "nixos" "label" ])

     

       225
       225
       -
           (mkRenamedOptionModule [ "system" "stateVersion" ] [ "system" "nixos" "stateVersion" ])

     

       226
       226
       -
           (mkRenamedOptionModule [ "system" "defaultChannel" ] [ "system" "nixos" "defaultChannel" ])

     

       227
       225
        
       

     

       228
       226
        
           # Users

     

       229
       227
        
           (mkAliasOptionModule [ "users" "extraUsers" ] [ "users" "users" ])

+1 -1

nixos/modules/services/databases/mysql.nix

···

       218
       218
        
         config = mkIf config.services.mysql.enable {

     

       219
       219
        
       

     

       220
       220
        
           services.mysql.dataDir =

     

       221
       221
       -
             mkDefault (if versionAtLeast config.system.nixos.stateVersion "17.09" then "/var/lib/mysql"

     

       221
       221
       +
             mkDefault (if versionAtLeast config.system.stateVersion "17.09" then "/var/lib/mysql"

     

       222
       222
        
                        else "/var/mysql");

     

       223
       223
        
       

     

       224
       224
        
           users.users.mysql = {

+5 -5

nixos/modules/services/databases/postgresql.nix

···

       146
       146
        
             };

     

       147
       147
        
             superUser = mkOption {

     

       148
       148
        
               type = types.str;

     

       149
       149
       -
               default= if versionAtLeast config.system.nixos.stateVersion "17.09" then "postgres" else "root";

     

       149
       149
       +
               default= if versionAtLeast config.system.stateVersion "17.09" then "postgres" else "root";

     

       150
       150
        
               internal = true;

     

       151
       151
        
               description = ''

     

       152
       152
        
                 NixOS traditionally used 'root' as superuser, most other distros use 'postgres'.

     
···

       165
       165
        
       

     

       166
       166
        
           services.postgresql.package =

     

       167
       167
        
             # Note: when changing the default, make it conditional on

     

       168
       168
       -
             # ‘system.nixos.stateVersion’ to maintain compatibility with existing

     

       168
       168
       +
             # ‘system.stateVersion’ to maintain compatibility with existing

     

       169
       169
        
             # systems!

     

       170
       170
       -
             mkDefault (if versionAtLeast config.system.nixos.stateVersion "17.09" then pkgs.postgresql96

     

       171
       171
       -
                   else if versionAtLeast config.system.nixos.stateVersion "16.03" then pkgs.postgresql95

     

       170
       170
       +
             mkDefault (if versionAtLeast config.system.stateVersion "17.09" then pkgs.postgresql96

     

       171
       171
       +
                   else if versionAtLeast config.system.stateVersion "16.03" then pkgs.postgresql95

     

       172
       172
        
                   else pkgs.postgresql94);

     

       173
       173
        
       

     

       174
       174
        
           services.postgresql.dataDir =

     

       175
       175
       -
             mkDefault (if versionAtLeast config.system.nixos.stateVersion "17.09" then "/var/lib/postgresql/${config.services.postgresql.package.psqlSchema}"

     

       175
       175
       +
             mkDefault (if versionAtLeast config.system.stateVersion "17.09" then "/var/lib/postgresql/${config.services.postgresql.package.psqlSchema}"

     

       176
       176
        
                        else "/var/db/postgresql");

     

       177
       177
        
       

     

       178
       178
        
           services.postgresql.authentication = mkAfter

+1 -1

nixos/modules/services/misc/matrix-synapse.nix

···

       342
       342
        
             };

     

       343
       343
        
             database_type = mkOption {

     

       344
       344
        
               type = types.enum [ "sqlite3" "psycopg2" ];

     

       345
       345
       -
               default = if versionAtLeast config.system.nixos.stateVersion "18.03"

     

       345
       345
       +
               default = if versionAtLeast config.system.stateVersion "18.03"

     

       346
       346
        
                 then "psycopg2"

     

       347
       347
        
                 else "sqlite3";

     

       348
       348
        
               description = ''

+1 -1

nixos/modules/services/network-filesystems/ipfs.nix

···

       14
       14
        
           (optionalString (cfg.defaultMode == "norouting") "--routing=none")

     

       15
       15
        
         ] ++ cfg.extraFlags);

     

       16
       16
        
       

     

       17
       17
       -
         defaultDataDir = if versionAtLeast config.system.nixos.stateVersion "17.09" then

     

       17
       17
       +
         defaultDataDir = if versionAtLeast config.system.stateVersion "17.09" then

     

       18
       18
        
           "/var/lib/ipfs" else

     

       19
       19
        
           "/var/lib/ipfs/.ipfs";

     

       20
       20

+2 -2

nixos/modules/services/networking/radicale.nix

···

       9
       9
        
         confFile = pkgs.writeText "radicale.conf" cfg.config;

     

       10
       10
        
       

     

       11
       11
        
         # This enables us to default to version 2 while still not breaking configurations of people with version 1

     

       12
       12
       -
         defaultPackage = if versionAtLeast config.system.nixos.stateVersion "17.09" then {

     

       12
       12
       +
         defaultPackage = if versionAtLeast config.system.stateVersion "17.09" then {

     

       13
       13
        
           pkg = pkgs.radicale2;

     

       14
       14
        
           text = "pkgs.radicale2";

     

       15
       15
        
         } else {

     
···

       35
       35
        
             defaultText = defaultPackage.text;

     

       36
       36
        
             description = ''

     

       37
       37
        
               Radicale package to use. This defaults to version 1.x if

     

       38
       38
       -
               <literal>system.nixos.stateVersion &lt; 17.09</literal> and version 2.x

     

       38
       38
       +
               <literal>system.stateVersion &lt; 17.09</literal> and version 2.x

     

       39
       39
        
               otherwise.

     

       40
       40
        
             '';

     

       41
       41
        
           };

+1 -1

nixos/modules/services/web-servers/caddy.nix

···

       66
       66
        
             description = "Caddy web server";

     

       67
       67
        
             after = [ "network-online.target" ];

     

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

     

       69
       69
       -
             environment = mkIf (versionAtLeast config.system.nixos.stateVersion "17.09")

     

       69
       69
       +
             environment = mkIf (versionAtLeast config.system.stateVersion "17.09")

     

       70
       70
        
               { CADDYPATH = cfg.dataDir; };

     

       71
       71
        
             serviceConfig = {

     

       72
       72
        
               ExecStart = ''

+1 -1

nixos/modules/testing/test-instrumentation.nix

···

       127
       127
        
           services.xserver.displayManager.job.logToJournal = true;

     

       128
       128
        
       

     

       129
       129
        
           # set default stateVersion to avoid warnings during eval

     

       130
       130
       -
           system.nixos.stateVersion = mkDefault "18.03";

     

       130
       130
       +
           system.stateVersion = mkDefault "18.03";

     

       131
       131
        
         };

     

       132
       132
        
       

     

       133
       133
        
       }

+1 -1

nixos/modules/virtualisation/amazon-options.nix

···

       3
       3
        
         options = {

     

       4
       4
        
           ec2 = {

     

       5
       5
        
             hvm = lib.mkOption {

     

       6
       6
       -
               default = lib.versionAtLeast config.system.nixos.stateVersion "17.03";

     

       6
       6
       +
               default = lib.versionAtLeast config.system.stateVersion "17.03";

     

       7
       7
        
               internal = true;

     

       8
       8
        
               description = ''

     

       9
       9
        
                 Whether the EC2 instance is a HVM instance.

+1 -1

nixos/modules/virtualisation/containers.nix

···

       607
       607
        
                         { services.postgresql.enable = true;

     

       608
       608
        
                           services.postgresql.package = pkgs.postgresql96;

     

       609
       609
        
       

     

       610
       610
       -
                           system.nixos.stateVersion = "17.03";

     

       610
       610
       +
                           system.stateVersion = "17.03";

     

       611
       611
        
                         };

     

       612
       612
        
                     };

     

       613
       613
        
                 }

+1 -1

nixos/release.nix

···

       198
       198
        
               modules = singleton ({ ... }:

     

       199
       199
        
                 { fileSystems."/".device  = mkDefault "/dev/sda1";

     

       200
       200
        
                   boot.loader.grub.device = mkDefault "/dev/sda";

     

       201
       201
       -
                   system.nixos.stateVersion = mkDefault "18.03";

     

       201
       201
       +
                   system.stateVersion = mkDefault "18.03";

     

       202
       202
        
                 });

     

       203
       203
        
             }).config.system.build.toplevel;

     

       204
       204
        
             preferLocalBuild = true;

+1 -1

nixos/tests/containers-imperative.nix

···

       18
       18
        
                 inherit (config.nixpkgs.localSystem) system;

     

       19
       19
        
                 modules = lib.singleton {

     

       20
       20
        
                   containers.foo.config = {

     

       21
       21
       -
                     system.nixos.stateVersion = "18.03";

     

       21
       21
       +
                     system.stateVersion = "18.03";

     

       22
       22
        
                   };

     

       23
       23
        
                 };

     

       24
       24
        
               };

+1 -1

nixos/tests/containers-ipv4.nix

···

       21
       21
        
                     services.httpd.adminAddr = "foo@example.org";

     

       22
       22
        
                     networking.firewall.allowedTCPPorts = [ 80 ];

     

       23
       23
        
                     networking.firewall.allowPing = true;

     

       24
       24
       -
                     system.nixos.stateVersion = "18.03";

     

       24
       24
       +
                     system.stateVersion = "18.03";

     

       25
       25
        
                   };

     

       26
       26
        
               };

     

       27
       27

+2 -2

nixos/tests/radicale.nix

···

       43
       43
        
                   });

     

       44
       44
        
                 })

     

       45
       45
        
               ];

     

       46
       46
       -
               system.nixos.stateVersion = "17.03";

     

       46
       46
       +
               system.stateVersion = "17.03";

     

       47
       47
        
             };

     

       48
       48
        
             radicale1_export = lib.recursiveUpdate radicale1 {

     

       49
       49
        
               services.radicale.extraArgs = [

     
···

       54
       54
        
               services.radicale.extraArgs = [ "--verify-storage" ];

     

       55
       55
        
             };

     

       56
       56
        
             radicale2 = lib.recursiveUpdate (common args) {

     

       57
       57
       -
               system.nixos.stateVersion = "17.09";

     

       57
       57
       +
               system.stateVersion = "17.09";

     

       58
       58
        
             };

     

       59
       59
        
           };

     

       60
       60