Update README with release build instructions

A lot of improvements got imported into here based on my work on the
garage nix setup.

README.md

@@ -30,6 +30,17 @@ 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,39 +5,46 @@
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-22.11";
   };
 
-  outputs = { self, nixpkgs, naersk, fenix }:
+  outputs = { self, nixpkgs, naersk, fenix }: let
-    let
+
+      newBuildTarget = {
+        nixPkgsSystem,
+        rustTarget ? nixPkgsSystem,
+        nativeBuildInputs ? pkgsCross: [],
+        rustFlags ? pkgsCross: [],
+      }: {
+        inherit nixPkgsSystem rustTarget nativeBuildInputs rustFlags;
+      };
+
       buildTargets = {
-        "x86_64-linux" = {
+        "x86_64-linux" = newBuildTarget {
-          crossSystemConfig = "x86_64-unknown-linux-musl";
+          nixPkgsSystem = "x86_64-unknown-linux-musl";
-          rustTarget = "x86_64-unknown-linux-musl";
         };
 
-        "i686-linux" = {
+        "i686-linux" = newBuildTarget {
-          crossSystemConfig = "i686-unknown-linux-musl";
+          nixPkgsSystem = "i686-unknown-linux-musl";
-          rustTarget = "i686-unknown-linux-musl";
         };
 
-        "aarch64-linux" = {
+        "aarch64-linux" = newBuildTarget {
-          crossSystemConfig = "aarch64-unknown-linux-musl";
+          nixPkgsSystem = "aarch64-unknown-linux-musl";
-          rustTarget = "aarch64-unknown-linux-musl";
         };
 
         # Old Raspberry Pi's
-        "armv6l-linux" = {
+        "armv6l-linux" = newBuildTarget {
-          crossSystemConfig = "armv6l-unknown-linux-musleabihf";
+          nixPkgsSystem = "armv6l-unknown-linux-musleabihf";
           rustTarget = "arm-unknown-linux-musleabihf";
         };
 
-        "x86_64-windows" = {
+        "x86_64-windows" = newBuildTarget {
-          crossSystemConfig = "x86_64-w64-mingw32";
+          nixPkgsSystem = "x86_64-w64-mingw32";
           rustTarget = "x86_64-pc-windows-gnu";
-          makeBuildPackageAttrs = pkgsCross: {
+          nativeBuildInputs = pkgsCross: [
-            depsBuildBuild = [
             pkgsCross.stdenv.cc
             pkgsCross.windows.pthreads
           ];
-          };
+          rustFlags = pkgsCross: [
+            "-C" "link-arg=-L${pkgsCross.windows.pthreads}/lib"
+          ];
         };
       };
 
@@ -61,12 +68,29 @@
       # "$system.cross-$system" for every system.
       #
       eachCrossSystem = supportedSystems: callback:
-        eachSystem supportedSystems (buildSystem: builtins.foldl'
+        eachSystem supportedSystems (buildSystem: let
+          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 ({
@@ -77,55 +101,43 @@
         # 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}.crossSystemConfig;
+        crossSystem.config = buildTargets.${targetSystem}.nixPkgsSystem;
       }));
 
-    in {
+      mkToolchain = buildSystem: targetSystem: let
-      packages = eachCrossSystem
+        buildTarget = buildTargets.${targetSystem};
-        (builtins.attrNames buildTargets)
+        rustTarget = buildTarget.rustTarget;
-        (buildSystem: targetSystem: let
+        fenixPkgs = fenix.packages.${buildSystem};
-          pkgs = mkPkgs buildSystem null;
-          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 {
+        fenixToolchain = fenixTarget: (builtins.getAttr "toolchainOf" fenixTarget) {
-          #  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=";
         };
-
+      in
-          toolchain = fenixPkgs.combine [
+        fenixPkgs.combine [
-            (mkToolchain fenixPkgs).rustc
+          (fenixToolchain fenixPkgs).rustc
-            (mkToolchain fenixPkgs).cargo
+          (fenixToolchain fenixPkgs).rustfmt
-            (mkToolchain fenixPkgs.targets.${rustTarget}).rust-std
+          (fenixToolchain fenixPkgs).cargo
+          (fenixToolchain fenixPkgs).clippy
+          (fenixToolchain (fenixPkgs.targets).${rustTarget}).rust-std
         ];
 
-          buildPackageAttrs = if
+      buildEnv = buildSystem: targetSystem: let
-            builtins.hasAttr "makeBuildPackageAttrs" buildTargets.${targetSystem}
+        pkgs = mkPkgs buildSystem null;
-          then
+        pkgsCross = mkPkgs buildSystem targetSystem;
-            buildTargets.${targetSystem}.makeBuildPackageAttrs pkgsCross
+        buildTarget = buildTargets.${targetSystem};
-          else
-            {};
-
-          naersk-lib = pkgs.callPackage naersk {
-            cargo = toolchain;
-            rustc = toolchain;
-          };
-
       in
-          naersk-lib.buildPackage (buildPackageAttrs // rec {
+        rec {
-            src = ./.;
+          nativeBuildInputs = (buildTarget.nativeBuildInputs pkgsCross) ++ [
-            strictDeps = true;
+            (mkToolchain buildSystem targetSystem)
-            doCheck = false;
+
+            # 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";
@@ -135,7 +147,7 @@
           # 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 = rustTarget;
+          CARGO_BUILD_TARGET = buildTarget.rustTarget;
           CARGO_BUILD_RUSTFLAGS = [
             "-C" "target-feature=+crt-static"
 
@@ -145,8 +157,49 @@
 
             # 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;
+          naersk-lib = pkgs.callPackage naersk {
+            cargo = toolchain;
+            rustc = toolchain;
+          };
+        in
+          naersk-lib.buildPackage (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
+        (builtins.attrNames buildTargets)
+        (buildSystem: targetSystem: let
+          pkgs = mkPkgs buildSystem null;
+          toolchain = mkToolchain buildSystem targetSystem;
+        in
+          pkgs.mkShell ({
+            inputsFrom = []; # extra packages for dev
+          } // (buildEnv buildSystem targetSystem))
         );
     };
 }