···

       
201
       
 
       


     

       
202
       
 
       
  ################################################################################

     

       
203
       
 
       


     

       
204
       
-
       
  types.system = mkOptionType {

     

       
205
       
 
       
    name = "system";

     

       
206
       
 
       
    description = "fully parsed representation of llvm- or nix-style platform tuple";

     

       
207
       
 
       
    merge = mergeOneOption;

     
···

       
215
       
 
       
  isSystem = isType "system";

     

       
216
       
 
       


     

       
217
       
 
       
  mkSystem = components:

     

       
218
       
-
       
    assert types.system.check components;

     

       
219
       
 
       
    setType "system" components;

     

       
220
       
 
       


     

       
221
       
 
       
  mkSkeletonFromList = l: {

     

···

       
201
       
 
       


     

       
202
       
 
       
  ################################################################################

     

       
203
       
 
       


     

       
204
       
+
       
  types.parsedPlatform = mkOptionType {

     

       
205
       
 
       
    name = "system";

     

       
206
       
 
       
    description = "fully parsed representation of llvm- or nix-style platform tuple";

     

       
207
       
 
       
    merge = mergeOneOption;

     
···

       
215
       
 
       
  isSystem = isType "system";

     

       
216
       
 
       


     

       
217
       
 
       
  mkSystem = components:

     

       
218
       
+
       
    assert types.parsedPlatform.check components;

     

       
219
       
 
       
    setType "system" components;

     

       
220
       
 
       


     

       
221
       
 
       
  mkSkeletonFromList = l: {

     

···

       
40
       
 
       
  test1 = {pkgs, config, ...}:

     

       
41
       
 
       
    {

     

       
42
       
 
       
      services.openssh.enable = true;

     

       
43
       
-
       
      nixpkgs.system = "i686-linux";

     

       
44
       
 
       
      deployment.targetHost = "test1.example.net";

     

       
45
       
 
       


     

       
46
       
 
       
      # Other NixOS options

     
···

       
51
       
 
       
      services.openssh.enable = true;

     

       
52
       
 
       
      services.httpd.enable = true;

     

       
53
       
 
       
      environment.systemPackages = [ pkgs.lynx ];

     

       
54
       
-
       
      nixpkgs.system = "x86_64-linux";

     

       
55
       
 
       
      deployment.targetHost = "test2.example.net";

     

       
56
       
 
       


     

       
57
       
 
       
      # Other NixOS options

     
···

       
66
       
 
       
The <varname>deployment.targetHost</varname> specifies the address

     

       
67
       
 
       
(domain name or IP address)

     

       
68
       
 
       
of the system which is used by <command>ssh</command> to perform

     

       
69
       
-
       
remote deployment operations. The <varname>nixpkgs.system</varname>

     

       
70
       
 
       
attribute can be used to specify an architecture for the target machine,

     

       
71
       
 
       
such as <varname>i686-linux</varname> which builds a 32-bit NixOS

     

       
72
       
 
       
configuration. Omitting this property will build the configuration

     

···

       
40
       
 
       
  test1 = {pkgs, config, ...}:

     

       
41
       
 
       
    {

     

       
42
       
 
       
      services.openssh.enable = true;

     

       
43
       
+
       
      nixpkgs.localSystem.system = "i686-linux";

     

       
44
       
 
       
      deployment.targetHost = "test1.example.net";

     

       
45
       
 
       


     

       
46
       
 
       
      # Other NixOS options

     
···

       
51
       
 
       
      services.openssh.enable = true;

     

       
52
       
 
       
      services.httpd.enable = true;

     

       
53
       
 
       
      environment.systemPackages = [ pkgs.lynx ];

     

       
54
       
+
       
      nixpkgs.localSystem.system = "x86_64-linux";

     

       
55
       
 
       
      deployment.targetHost = "test2.example.net";

     

       
56
       
 
       


     

       
57
       
 
       
      # Other NixOS options

     
···

       
66
       
 
       
The <varname>deployment.targetHost</varname> specifies the address

     

       
67
       
 
       
(domain name or IP address)

     

       
68
       
 
       
of the system which is used by <command>ssh</command> to perform

     

       
69
       
+
       
remote deployment operations. The <varname>nixpkgs.localSystem.system</varname>

     

       
70
       
 
       
attribute can be used to specify an architecture for the target machine,

     

       
71
       
 
       
such as <varname>i686-linux</varname> which builds a 32-bit NixOS

     

       
72
       
 
       
configuration. Omitting this property will build the configuration

     

···

       
26
       
 
       
, lib ? import ../../lib

     

       
27
       
 
       
}:

     

       
28
       
 
       


     

       
29
       
-
       
let extraArgs_ = extraArgs; pkgs_ = pkgs; system_ = system;

     

       
30
       
 
       
    extraModules = let e = builtins.getEnv "NIXOS_EXTRA_MODULE_PATH";

     

       
31
       
 
       
                   in if e == "" then [] else [(import (builtins.toPath e))];

     

       
32
       
 
       
in

     
···

       
36
       
 
       
    _file = ./eval-config.nix;

     

       
37
       
 
       
    key = _file;

     

       
38
       
 
       
    config = {

     

       
39
       
-
       
      nixpkgs.system = lib.mkDefault system_;

     

       
40
       
 
       
      _module.args.pkgs = lib.mkIf (pkgs_ != null) (lib.mkForce pkgs_);

     

       
41
       
 
       
    };

     

       
42
       
 
       
  };

     

···

       
26
       
 
       
, lib ? import ../../lib

     

       
27
       
 
       
}:

     

       
28
       
 
       


     

       
29
       
+
       
let extraArgs_ = extraArgs; pkgs_ = pkgs;

     

       
30
       
 
       
    extraModules = let e = builtins.getEnv "NIXOS_EXTRA_MODULE_PATH";

     

       
31
       
 
       
                   in if e == "" then [] else [(import (builtins.toPath e))];

     

       
32
       
 
       
in

     
···

       
36
       
 
       
    _file = ./eval-config.nix;

     

       
37
       
 
       
    key = _file;

     

       
38
       
 
       
    config = {

     

       
39
       
+
       
      nixpkgs.localSystem = lib.mkDefault { inherit system; };

     

       
40
       
 
       
      _module.args.pkgs = lib.mkIf (pkgs_ != null) (lib.mkForce pkgs_);

     

       
41
       
 
       
    };

     

       
42
       
 
       
  };

     

···

       
58
       
 
       
    pkgs = mkOption {

     

       
59
       
 
       
      defaultText = literalExample

     

       
60
       
 
       
        ''import "''${nixos}/.." {

     

       
61
       
-
       
            inherit (config.nixpkgs) config overlays system;

     

       
62
       
 
       
          }

     

       
63
       
 
       
        '';

     

       
64
       
-
       
      default = import ../../.. { inherit (cfg) config overlays system crossSystem; };

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
65
       
 
       
      type = pkgsType;

     

       
66
       
 
       
      example = literalExample ''import <nixpkgs> {}'';

     

       
67
       
 
       
      description = ''

     
···

       
73
       
 
       
        relative to the location of this NixOS module, because

     

       
74
       
 
       
        NixOS and Nixpkgs are distributed together for consistency,

     

       
75
       
 
       
        so the <code>nixos</code> in the default value is in fact a

     

       
76
       
-
       
        relative path. The <code>config</code>, <code>overlays</code>

     

       
77
       
-
       
        and <code>system</code> come from this option's siblings.

     

       
0
       
 
       

     

       
78
       
 
       


     

       
79
       
 
       
        This option can be used by applications like NixOps to increase

     

       
80
       
 
       
        the performance of evaluation, or to create packages that depend

     
···

       
130
       
 
       
      '';

     

       
131
       
 
       
    };

     

       
132
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
133
       
 
       
    crossSystem = mkOption {

     

       
134
       
-
       
      type = types.nullOr types.attrs;

     

       
135
       
 
       
      default = null;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
136
       
 
       
      description = ''

     

       
137
       
-
       
        The description of the system we're cross-compiling to, or null

     

       
138
       
-
       
        if this isn't a cross-compile. See the description of the

     

       
139
       
-
       
        crossSystem argument in the nixpkgs manual.

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
140
       
 
       


     

       
141
       
 
       
        Ignored when <code>nixpkgs.pkgs</code> is set.

     

       
142
       
 
       
      '';

     
···

       
146
       
 
       
      type = types.str;

     

       
147
       
 
       
      example = "i686-linux";

     

       
148
       
 
       
      description = ''

     

       
149
       
-
       
        Specifies the Nix platform type for which NixOS should be built.

     

       
150
       
-
       
        If unset, it defaults to the platform type of your host system.

     

       
151
       
-
       
        Specifying this option is useful when doing distributed

     

       
152
       
-
       
        multi-platform deployment, or when building virtual machines.

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
153
       
 
       


     

       
154
       
 
       
        Ignored when <code>nixpkgs.pkgs</code> is set.

     

       
155
       
 
       
      '';

     

···

       
58
       
 
       
    pkgs = mkOption {

     

       
59
       
 
       
      defaultText = literalExample

     

       
60
       
 
       
        ''import "''${nixos}/.." {

     

       
61
       
+
       
            inherit (config.nixpkgs) config overlays localSystem crossSystem;

     

       
62
       
 
       
          }

     

       
63
       
 
       
        '';

     

       
64
       
+
       
      default = import ../../.. {

     

       
65
       
+
       
        localSystem = { inherit (cfg) system; } // cfg.localSystem;

     

       
66
       
+
       
        inherit (cfg) config overlays crossSystem;

     

       
67
       
+
       
      };

     

       
68
       
 
       
      type = pkgsType;

     

       
69
       
 
       
      example = literalExample ''import <nixpkgs> {}'';

     

       
70
       
 
       
      description = ''

     
···

       
76
       
 
       
        relative to the location of this NixOS module, because

     

       
77
       
 
       
        NixOS and Nixpkgs are distributed together for consistency,

     

       
78
       
 
       
        so the <code>nixos</code> in the default value is in fact a

     

       
79
       
+
       
        relative path. The <code>config</code>, <code>overlays</code>,

     

       
80
       
+
       
        <code>localSystem</code>, and <code>crossSystem</code> come

     

       
81
       
+
       
        from this option's siblings.

     

       
82
       
 
       


     

       
83
       
 
       
        This option can be used by applications like NixOps to increase

     

       
84
       
 
       
        the performance of evaluation, or to create packages that depend

     
···

       
134
       
 
       
      '';

     

       
135
       
 
       
    };

     

       
136
       
 
       


     

       
137
       
+
       
    localSystem = mkOption {

     

       
138
       
+
       
      type = types.attrs; # TODO utilize lib.systems.parsedPlatform

     

       
139
       
+
       
      default = { system = builtins.currentSystem; };

     

       
140
       
+
       
      example = { system = "aarch64-linux"; config = "aarch64-unknown-linux-gnu"; };

     

       
141
       
+
       
      defaultText = literalExample

     

       
142
       
+
       
        ''(import "''${nixos}/../lib").lib.systems.examples.aarch64-multiplatform'';

     

       
143
       
+
       
      description = ''

     

       
144
       
+
       
        Specifies the platform on which NixOS should be built. When

     

       
145
       
+
       
        <code>nixpkgs.crossSystem</code> is unset, it also specifies

     

       
146
       
+
       
        the platform <emphasis>for</emphasis> which NixOS should be

     

       
147
       
+
       
        built.  If this option is unset, it defaults to the platform

     

       
148
       
+
       
        type of the machine where evaluation happens. Specifying this

     

       
149
       
+
       
        option is useful when doing distributed multi-platform

     

       
150
       
+
       
        deployment, or when building virtual machines. See its

     

       
151
       
+
       
        description in the Nixpkgs manual for more details.

     

       
152
       
+
       


     

       
153
       
+
       
        Ignored when <code>nixpkgs.pkgs</code> is set.

     

       
154
       
+
       
      '';

     

       
155
       
+
       
    };

     

       
156
       
+
       


     

       
157
       
 
       
    crossSystem = mkOption {

     

       
158
       
+
       
      type = types.nullOr types.attrs; # TODO utilize lib.systems.parsedPlatform

     

       
159
       
 
       
      default = null;

     

       
160
       
+
       
      example = { system = "aarch64-linux"; config = "aarch64-unknown-linux-gnu"; };

     

       
161
       
+
       
      defaultText = literalExample

     

       
162
       
+
       
        ''(import "''${nixos}/../lib").lib.systems.examples.aarch64-multiplatform'';

     

       
163
       
 
       
      description = ''

     

       
164
       
+
       
        Specifies the platform for which NixOS should be

     

       
165
       
+
       
        built. Specify this only if it is different from

     

       
166
       
+
       
        <code>nixpkgs.localSystem</code>, the platform

     

       
167
       
+
       
        <emphasis>on</emphasis> which NixOS should be built. In other

     

       
168
       
+
       
        words, specify this to cross-compile NixOS. Otherwise it

     

       
169
       
+
       
        should be set as null, the default. See its description in the

     

       
170
       
+
       
        Nixpkgs manual for more details.

     

       
171
       
 
       


     

       
172
       
 
       
        Ignored when <code>nixpkgs.pkgs</code> is set.

     

       
173
       
 
       
      '';

     
···

       
177
       
 
       
      type = types.str;

     

       
178
       
 
       
      example = "i686-linux";

     

       
179
       
 
       
      description = ''

     

       
180
       
+
       
        Specifies the Nix platform type on which NixOS should be built.

     

       
181
       
+
       
        It is better to specify <code>nixpkgs.localSystem</code> instead.

     

       
182
       
+
       
        <programlisting>

     

       
183
       
+
       
        {

     

       
184
       
+
       
          nixpkgs.system = ..;

     

       
185
       
+
       
        }

     

       
186
       
+
       
        </programlisting>

     

       
187
       
+
       
        is the same as

     

       
188
       
+
       
        <programlisting>

     

       
189
       
+
       
        {

     

       
190
       
+
       
          nixpkgs.localSystem.system = ..;

     

       
191
       
+
       
        }

     

       
192
       
+
       
        </programlisting>

     

       
193
       
+
       
        See <code>nixpkgs.localSystem</code> for more information.

     

       
194
       
 
       


     

       
195
       
 
       
        Ignored when <code>nixpkgs.pkgs</code> is set.

     

       
196
       
 
       
      '';

     

···

       
158
       
 
       


     

       
159
       
 
       
    services.dysnomia.properties = {

     

       
160
       
 
       
      hostname = config.networking.hostName;

     

       
161
       
-
       
      system = if config.nixpkgs.system == "" then builtins.currentSystem else config.nixpkgs.system;

     

       
162
       
 
       


     

       
163
       
 
       
      supportedTypes = (import "${pkgs.stdenv.mkDerivation {

     

       
164
       
 
       
        name = "supportedtypes";

     

···

       
158
       
 
       


     

       
159
       
 
       
    services.dysnomia.properties = {

     

       
160
       
 
       
      hostname = config.networking.hostName;

     

       
161
       
+
       
      inherit (config.nixpkgs.localSystem) system;

     

       
162
       
 
       


     

       
163
       
 
       
      supportedTypes = (import "${pkgs.stdenv.mkDerivation {

     

       
164
       
 
       
        name = "supportedtypes";

     

···

       
23
       
 
       
    options =

     

       
24
       
 
       
      let

     

       
25
       
 
       
        scrubbedEval = evalModules {

     

       
26
       
-
       
          modules = [ { nixpkgs.system = config.nixpkgs.system; } ] ++ baseModules;

     

       
27
       
 
       
          args = (config._module.args) // { modules = [ ]; };

     

       
28
       
 
       
          specialArgs = { pkgs = scrubDerivations "pkgs" pkgs; };

     

       
29
       
 
       
        };

     

···

       
23
       
 
       
    options =

     

       
24
       
 
       
      let

     

       
25
       
 
       
        scrubbedEval = evalModules {

     

       
26
       
+
       
          modules = [ { nixpkgs.localSystem = config.nixpkgs.localSystem; } ] ++ baseModules;

     

       
27
       
 
       
          args = (config._module.args) // { modules = [ ]; };

     

       
28
       
 
       
          specialArgs = { pkgs = scrubDerivations "pkgs" pkgs; };

     

       
29
       
 
       
        };

     

···

       
112
       
 
       


     

       
113
       
 
       
      # If the host is 64-bit and the container is 32-bit, add a

     

       
114
       
 
       
      # --personality flag.

     

       
115
       
-
       
      ${optionalString (config.nixpkgs.system == "x86_64-linux") ''

     

       
116
       
 
       
        if [ "$(< ''${SYSTEM_PATH:-/nix/var/nix/profiles/per-container/$INSTANCE/system}/system)" = i686-linux ]; then

     

       
117
       
 
       
          extraFlags+=" --personality=x86"

     

       
118
       
 
       
        fi

     
···

       
255
       
 
       
  };

     

       
256
       
 
       


     

       
257
       
 
       


     

       
258
       
-
       
  system = config.nixpkgs.system;

     

       
259
       
 
       


     

       
260
       
 
       
  bindMountOpts = { name, config, ... }: {

     

       
261
       
 
       


     

···

       
112
       
 
       


     

       
113
       
 
       
      # If the host is 64-bit and the container is 32-bit, add a

     

       
114
       
 
       
      # --personality flag.

     

       
115
       
+
       
      ${optionalString (config.nixpkgs.localSystem.system == "x86_64-linux") ''

     

       
116
       
 
       
        if [ "$(< ''${SYSTEM_PATH:-/nix/var/nix/profiles/per-container/$INSTANCE/system}/system)" = i686-linux ]; then

     

       
117
       
 
       
          extraFlags+=" --personality=x86"

     

       
118
       
 
       
        fi

     
···

       
255
       
 
       
  };

     

       
256
       
 
       


     

       
257
       
 
       


     

       
258
       
+
       
  system = config.nixpkgs.localSystem.system;

     

       
259
       
 
       


     

       
260
       
 
       
  bindMountOpts = { name, config, ... }: {

     

       
261
       
 
       


     

···

       
144
       
 
       
    license = either (listOf lib.types.attrs) (either lib.types.attrs str);

     

       
145
       
 
       
    maintainers = listOf (attrsOf str);

     

       
146
       
 
       
    priority = int;

     

       
147
       
-
       
    platforms = listOf (either str lib.systems.parsed.types.system);

     

       
148
       
 
       
    hydraPlatforms = listOf str;

     

       
149
       
 
       
    broken = bool;

     

       
150
       
 
       


     

···

       
144
       
 
       
    license = either (listOf lib.types.attrs) (either lib.types.attrs str);

     

       
145
       
 
       
    maintainers = listOf (attrsOf str);

     

       
146
       
 
       
    priority = int;

     

       
147
       
+
       
    platforms = listOf (either str lib.systems.parsedPlatform.types.system);

     

       
148
       
 
       
    hydraPlatforms = listOf str;

     

       
149
       
 
       
    broken = bool;

     

       
150