git.delta.rocks / jrsonnet / refs/commits / 4e7930a0a457

4949
50enum PackageAction {50enum PackageAction {
51	SdImage,51	SdImage,
52	InstallationCd,
52}53}
54impl PackageAction {
55	fn build_attr(&self) -> String {
56		match self {
57			PackageAction::SdImage => "sdImage".to_owned(),
58			PackageAction::InstallationCd => "installationCd".to_owned(),
59		}
60	}
61}
5362
54enum Action {63enum Action {
55	Upload(Option<UploadAction>),64	Upload { action: Option<UploadAction> },
56	Package(PackageAction),65	Package(PackageAction),
57}66}
67impl Action {
68	fn build_attr(&self) -> String {
69		match self {
70			Action::Upload { .. } => "toplevel".to_owned(),
71			Action::Package(p) => p.build_attr(),
72		}
73	}
74}
5875
59impl From<Subcommand> for Action {76impl From<Subcommand> for Action {
60	fn from(s: Subcommand) -> Self {77	fn from(s: Subcommand) -> Self {
61		match s {78		match s {
62			Subcommand::Upload => Self::Upload(None),79			Subcommand::Upload => Self::Upload { action: None },
63			Subcommand::Test => Self::Upload(Some(UploadAction::Test)),80			Subcommand::Test => Self::Upload {
81				action: Some(UploadAction::Test),
82			},
64			Subcommand::Boot => Self::Upload(Some(UploadAction::Boot)),83			Subcommand::Boot => Self::Upload {
84				action: Some(UploadAction::Boot),
85			},
65			Subcommand::Switch => Self::Upload(Some(UploadAction::Switch)),86			Subcommand::Switch => Self::Upload {
87				action: Some(UploadAction::Switch),
88			},
66			Subcommand::SdImage => Self::Package(PackageAction::SdImage),89			Subcommand::SdImage => Self::Package(PackageAction::SdImage),
90			Subcommand::InstallationCd => Self::Package(PackageAction::InstallationCd),
67		}91		}
68	}92	}
69}93}
79	/// Upload + test + boot103	/// Upload + test + boot
80	Switch,104	Switch,
81105
82	/// Build sd image106	/// Build SD .img image
83	SdImage,107	SdImage,
108	/// Build an installation cd ISO image
109	InstallationCd,
84}110}
85111
86impl BuildSystems {112impl BuildSystems {
87	async fn build_task(self, config: Config, host: String) -> Result<()> {113	async fn build_task(self, config: Config, host: String) -> Result<()> {
88		info!("building");114		info!("building");
115		let action = Action::from(self.subcommand.clone());
89		let built = {116		let built = {
90			let dir = tempfile::tempdir()?;117			let dir = tempfile::tempdir()?;
91			dir.path().to_owned()118			dir.path().to_owned()
110			.arg(&built)137			.arg(&built)
111			.arg(config.configuration_attr_name(&format!(138			.arg(
139				config.configuration_attr_name(&format!(
112				"configuredSystems.{}.config.system.build.toplevel",140					"buildSystems.{}.{host}",
113				host141					action.build_attr()
114			)));142				)),
143			);
115144
130		nix_build.run_nix().await?;159		nix_build.run_nix().await?;
131		let built = std::fs::canonicalize(built)?;160		let built = std::fs::canonicalize(built)?;
132
133		let action = Action::from(self.subcommand.clone());
134161
135		match action {162		match action {
136			Action::Upload(action) => {163			Action::Upload { action } => {
137				if !config.is_local(&host) {164				if !config.is_local(&host) {
138					info!("uploading system closure");165					info!("uploading system closure");
139					let mut tries = 0;166					let mut tries = 0;
195					.args(&["build", "--impure", "--no-link", "--out-link"])222					.args(&["build", "--impure", "--no-link", "--out-link"])
196					.arg(&out)223					.arg(&out)
197					.arg(config.configuration_attr_name(&format!(224					.arg(
198						"configuredSystems.{}.config.system.build.sdImage",225						config.configuration_attr_name(&format!("buildSystems.sdImage.{}", host,)),
199						host,
200					)));226					);
201				if let Some(builders) = &self.builders {227				if let Some(builders) = &self.builders {
211237
212				nix_build.inherit_stdio().run_nix().await?;238				nix_build.inherit_stdio().run_nix().await?;
213			}239			}
240			Action::Package(PackageAction::InstallationCd) => {
241				let mut out = current_dir()?;
242				out.push(format!("installation-cd-{}", host));
243
244				info!("building sd image to {:?}", out);
245				let mut nix_build = if self.privileged_build {
246					let mut out = Command::new("sudo");
247					out.arg("nix");
248					out
249				} else {
250					Command::new("nix")
251				};
252				nix_build
253					.args(&["build", "--impure", "--no-link", "--out-link"])
254					.arg(&out)
255					.arg(
256						config.configuration_attr_name(&format!(
257							"buildSystems.installationCd.{}",
258							host,
259						)),
260					);
261				if let Some(builders) = &self.builders {
262					nix_build.arg("--builders").arg(builders);
263				}
264				if let Some(jobs) = &self.jobs {
265					nix_build.arg("--max-jobs");
266					nix_build.arg(format!("{}", jobs));
267				}
268				if !self.fail_fast {
269					nix_build.arg("--keep-going");
270				}
271
272				nix_build.inherit_stdio().run_nix().await?;
273			}
214		};274		};
215		Ok(())275		Ok(())
216	}276	}

--- a/lib/default.nix
+++ b/lib/default.nix
@@ -20,21 +20,17 @@
           if failedAssertions != [ ]
           then throw "Failed assertions:\n${nixpkgs.lib.concatStringsSep "\n" (map (x: "- ${x}") failedAssertions)}"
           else nixpkgs.lib.showWarnings root.config.warnings root;
-      in
-      rec {
         configuredHosts = rootAssertWarn.config.hosts;
         configuredSecrets = rootAssertWarn.config.secrets;
-        configuredSystems = nixpkgs.lib.listToAttrs (
+        configuredSystems = configuredSystemsWithExtraModules [ ];
+        configuredSystemsWithExtraModules = extraModules: nixpkgs.lib.listToAttrs (
           map
             (
               name: {
                 inherit name;
                 value = nixpkgs.lib.nixosSystem {
                   system = configuredHosts.${name}.system;
-                  modules = configuredHosts.${name}.modules ++ (
-                    if configuredHosts.${name}.system == "aarch64-linux" then [ (nixpkgs + "/nixos/modules/installer/sd-card/sd-image-aarch64-installer.nix") ]
-                    else [ ]
-                  ) ++ [
+                  modules = configuredHosts.${name}.modules ++ extraModules ++ [
                     ({ ... }: {
                       nixpkgs.system = system;
                       nixpkgs.localSystem.system = system;
@@ -51,6 +47,22 @@
               }
             )
             (builtins.attrNames rootAssertWarn.config.hosts)
-        ); #nixpkgs.lib.nixosSystem {}
+        );
+      in
+      rec {
+        inherit configuredHosts configuredSecrets configuredSystems;
+        buildSystems = {
+          toplevel = builtins.mapAttrs (_name: value: value.config.system.build.toplevel) (configuredSystemsWithExtraModules [ ]);
+          sdImage = builtins.mapAttrs (_name: value: value.config.system.build.sdImage) (configuredSystemsWithExtraModules [
+            (nixpkgs + "/nixos/modules/installer/sd-card/sd-image-aarch64-installer.nix")
+          ]);
+          installationCd = builtins.mapAttrs (_name: value: value.config.system.build.isoImage) (configuredSystemsWithExtraModules [
+            (nixpkgs + "/nixos/modules/installer/cd-dvd/installation-cd-minimal.nix")
+            ({ lib, ... }: {
+              # Needed for https://github.com/NixOS/nixpkgs/issues/58959
+              boot.supportedFilesystems = lib.mkForce [ "btrfs" "reiserfs" "vfat" "f2fs" "xfs" "ntfs" "cifs" ];
+            })
+          ]);
+        };
       });
 }