README.md

@@ -30,17 +30,6 @@ nix build
 
 A statically compiled binary will be placed in the `result` directory.
 
-A full release, which cross-compiles binaries for all supported platforms, can
-be generated by doing:
-
-```
-nix build '.#release'
-```
-
-*NOTE* that cross-compiling will download a separate build environment for each
-target platform, which can take up quite a bit of disk space (>10GB).
-gigs).
-
 ## Configuration
 
 Domani is configured via a YAML file whose path is given on the command-line.

flake.nix

@@ -5,46 +5,39 @@
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-22.11";
   };
 
-  outputs = { self, nixpkgs, naersk, fenix }: let
+  outputs = { self, nixpkgs, naersk, fenix }:
-
+    let
-      newBuildTarget = {
-        nixPkgsSystem,
-        rustTarget ? nixPkgsSystem,
-        nativeBuildInputs ? pkgsCross: [],
-        rustFlags ? pkgsCross: [],
-      }: {
-        inherit nixPkgsSystem rustTarget nativeBuildInputs rustFlags;
-      };
-
       buildTargets = {
-        "x86_64-linux" = newBuildTarget {
+        "x86_64-linux" = {
-          nixPkgsSystem = "x86_64-unknown-linux-musl";
+          crossSystemConfig = "x86_64-unknown-linux-musl";
+          rustTarget = "x86_64-unknown-linux-musl";
         };
 
-        "i686-linux" = newBuildTarget {
+        "i686-linux" = {
-          nixPkgsSystem = "i686-unknown-linux-musl";
+          crossSystemConfig = "i686-unknown-linux-musl";
+          rustTarget = "i686-unknown-linux-musl";
         };
 
-        "aarch64-linux" = newBuildTarget {
+        "aarch64-linux" = {
-          nixPkgsSystem = "aarch64-unknown-linux-musl";
+          crossSystemConfig = "aarch64-unknown-linux-musl";
+          rustTarget = "aarch64-unknown-linux-musl";
         };
 
         # Old Raspberry Pi's
-        "armv6l-linux" = newBuildTarget {
+        "armv6l-linux" = {
-          nixPkgsSystem = "armv6l-unknown-linux-musleabihf";
+          crossSystemConfig = "armv6l-unknown-linux-musleabihf";
           rustTarget = "arm-unknown-linux-musleabihf";
         };
 
-        "x86_64-windows" = newBuildTarget {
+        "x86_64-windows" = {
-          nixPkgsSystem = "x86_64-w64-mingw32";
+          crossSystemConfig = "x86_64-w64-mingw32";
           rustTarget = "x86_64-pc-windows-gnu";
-          nativeBuildInputs = pkgsCross: [
+          makeBuildPackageAttrs = pkgsCross: {
-            pkgsCross.stdenv.cc
+            depsBuildBuild = [
-            pkgsCross.windows.pthreads
+              pkgsCross.stdenv.cc
-          ];
+              pkgsCross.windows.pthreads
-          rustFlags = pkgsCross: [
+            ];
-            "-C" "link-arg=-L${pkgsCross.windows.pthreads}/lib"
+          };
-          ];
         };
       };
 
@@ -68,29 +61,12 @@
       # "$system.cross-$system" for every system.
       #
       eachCrossSystem = supportedSystems: callback:
-        eachSystem supportedSystems (buildSystem: let
+        eachSystem supportedSystems (buildSystem: builtins.foldl'
-          pkgs = mkPkgs buildSystem null;
-          crosses = builtins.foldl'
             (inner: targetSystem: inner // {
               "cross-${targetSystem}" = callback buildSystem targetSystem;
             })
             { default = callback buildSystem buildSystem; }
-            supportedSystems;
+            supportedSystems
-        in
-          crosses // (rec {
-            default = callback buildSystem buildSystem;
-            release = let
-              bins = pkgs.symlinkJoin {
-                name = "${default.name}-all-bins";
-                paths = builtins.attrValues crosses;
-              };
-            in
-              pkgs.runCommand "${default.name}-release" {} ''
-                cp -rL "${bins}" "$out"
-                chmod +w "$out"/bin
-                (cd "$out"/bin && sha256sum * > sha256.txt)
-              '';
-          })
         );
 
       mkPkgs = buildSystem: targetSystem: import nixpkgs ({
@@ -101,105 +77,76 @@
         # build platform (and therefore it's not really cross-compiling). So we
         # only set up the cross-compiling config if the target platform is
         # different.
-        crossSystem.config = buildTargets.${targetSystem}.nixPkgsSystem;
+        crossSystem.config = buildTargets.${targetSystem}.crossSystemConfig;
       }));
 
-      mkToolchain = buildSystem: targetSystem: let
-        buildTarget = buildTargets.${targetSystem};
-        rustTarget = buildTarget.rustTarget;
-        fenixPkgs = fenix.packages.${buildSystem};
-
-        # TODO I'd prefer to use the toolchain file
-        # https://github.com/nix-community/fenix/issues/123
-        fenixToolchain = fenixTarget: (builtins.getAttr "toolchainOf" fenixTarget) {
-          channel = "nightly";
-          date = "2023-07-23";
-          sha256 = "sha256-LU4C/i+maIOqBZagUaXpFyWZyOVfQ3Ah5/JTz7v6CG4=";
-        };
-      in
-        fenixPkgs.combine [
-          (fenixToolchain fenixPkgs).rustc
-          (fenixToolchain fenixPkgs).rustfmt
-          (fenixToolchain fenixPkgs).cargo
-          (fenixToolchain fenixPkgs).clippy
-          (fenixToolchain (fenixPkgs.targets).${rustTarget}).rust-std
-        ];
-
-      buildEnv = buildSystem: targetSystem: let
-        pkgs = mkPkgs buildSystem null;
-        pkgsCross = mkPkgs buildSystem targetSystem;
-        buildTarget = buildTargets.${targetSystem};
-      in
-        rec {
-          nativeBuildInputs = (buildTarget.nativeBuildInputs pkgsCross) ++ [
-            (mkToolchain buildSystem targetSystem)
-
-            # Required for shell because of rust dependency build scripts which
-            # must run on the build system.
-            pkgs.stdenv.cc
-          ];
-
-          OPENSSL_STATIC = "1";
-          OPENSSL_LIB_DIR = "${pkgsCross.pkgsStatic.openssl.out}/lib";
-          OPENSSL_INCLUDE_DIR = "${pkgsCross.pkgsStatic.openssl.dev}/include";
-
-          # Required because ring crate is special. This also seems to have
-          # fixed some issues with the x86_64-windows cross-compile :shrug:
-          TARGET_CC = "${pkgsCross.stdenv.cc}/bin/${pkgsCross.stdenv.cc.targetPrefix}cc";
-
-          CARGO_BUILD_TARGET = buildTarget.rustTarget;
-          CARGO_BUILD_RUSTFLAGS = [
-            "-C" "target-feature=+crt-static"
-
-            # -latomic is required to build openssl-sys for armv6l-linux, but
-            # it doesn't seem to hurt any other builds.
-            "-C" "link-args=-static -latomic"
-
-            # https://github.com/rust-lang/cargo/issues/4133
-            "-C" "linker=${TARGET_CC}"
-          ] ++ (buildTarget.rustFlags pkgsCross);
-        };
-
     in {
-
       packages = eachCrossSystem
         (builtins.attrNames buildTargets)
         (buildSystem: targetSystem: let
           pkgs = mkPkgs buildSystem null;
-          toolchain = mkToolchain buildSystem targetSystem;
+          pkgsCross = mkPkgs buildSystem targetSystem;
+          rustTarget = buildTargets.${targetSystem}.rustTarget;
+
+          # TODO I'd prefer to use the toolchain file
+          # https://github.com/nix-community/fenix/issues/123
+          #toolchain = fenix.packages.${buildSystem}.fromToolchainFile {
+          #  file = ./rust-toolchain.toml;
+          #  sha256 = "sha256-LU4C/i+maIOqBZagUaXpFyWZyOVfQ3Ah5/JTz7v6CG4=";
+          #};
+
+          fenixPkgs = fenix.packages.${buildSystem};
+
+          mkToolchain = fenixPkgs: fenixPkgs.toolchainOf {
+            channel = "nightly";
+            date = "2023-07-23";
+            sha256 = "sha256-LU4C/i+maIOqBZagUaXpFyWZyOVfQ3Ah5/JTz7v6CG4=";
+          };
+
+          toolchain = fenixPkgs.combine [
+            (mkToolchain fenixPkgs).rustc
+            (mkToolchain fenixPkgs).cargo
+            (mkToolchain fenixPkgs.targets.${rustTarget}).rust-std
+          ];
+
+          buildPackageAttrs = if
+            builtins.hasAttr "makeBuildPackageAttrs" buildTargets.${targetSystem}
+          then
+            buildTargets.${targetSystem}.makeBuildPackageAttrs pkgsCross
+          else
+            {};
+
           naersk-lib = pkgs.callPackage naersk {
             cargo = toolchain;
             rustc = toolchain;
           };
+
         in
-          naersk-lib.buildPackage (rec {
+          naersk-lib.buildPackage (buildPackageAttrs // rec {
             src = ./.;
             strictDeps = true;
             doCheck = false;
-            release = true;
-            postInstall = ''
-              cd "$out"/bin
-              for f in "$(ls)"; do
-                if ext="$(echo "$f" | grep -oP '\.[a-z]+$')"; then
-                  base="$(echo "$f" | cut -d. -f1)"
-                  mv "$f" "$base-${targetSystem}$ext"
-                else
-                  mv "$f" "$f-${targetSystem}"
-                fi
-              done
-            '';
-          } // (buildEnv buildSystem targetSystem))
-        );
 
-      devShells = eachCrossSystem
+            OPENSSL_STATIC = "1";
-        (builtins.attrNames buildTargets)
+            OPENSSL_LIB_DIR = "${pkgsCross.pkgsStatic.openssl.out}/lib";
-        (buildSystem: targetSystem: let
+            OPENSSL_INCLUDE_DIR = "${pkgsCross.pkgsStatic.openssl.dev}/include";
-          pkgs = mkPkgs buildSystem null;
+
-          toolchain = mkToolchain buildSystem targetSystem;
+            # Required because ring crate is special. This also seems to have
-        in
+            # fixed some issues with the x86_64-windows cross-compile :shrug:
-          pkgs.mkShell ({
+            TARGET_CC = "${pkgsCross.stdenv.cc}/bin/${pkgsCross.stdenv.cc.targetPrefix}cc";
-            inputsFrom = []; # extra packages for dev
+
-          } // (buildEnv buildSystem targetSystem))
+            CARGO_BUILD_TARGET = rustTarget;
+            CARGO_BUILD_RUSTFLAGS = [
+              "-C" "target-feature=+crt-static"
+
+              # -latomic is required to build openssl-sys for armv6l-linux, but
+              # it doesn't seem to hurt any other builds.
+              "-C" "link-args=-static -latomic"
+
+              # https://github.com/rust-lang/cargo/issues/4133
+              "-C" "linker=${TARGET_CC}"
+            ];
+          })
         );
     };
 }