From f0544a5bbdf476ec875e2aca3f259bb244310c2f Mon Sep 17 00:00:00 2001 From: eureka-cpu Date: Thu, 18 Jul 2024 20:23:10 -0700 Subject: [PATCH] Create nixosModules, templates, and toolchains attributes --- flake.nix | 95 ++++++-- .../configuration.nix | 0 .../nix-darwin => nix-darwin}/flake.nix | 0 .../modules/deployments}/README.md | 0 .../modules/deployments}/debug-vm.nix | 0 .../digital-ocean/configuration.nix | 0 .../digital-ocean/digital-ocean-image.nix | 0 .../modules/deployments}/lasr_node/common.nix | 0 .../deployments}/lasr_node/lasr-overlay.nix | 0 .../lasr_node/nightly/nightly-options.nix | 0 templates/rust-package.nix | 161 ++++++++++++++ templates/rust-workspace-hakari.nix | 206 ++++++++++++++++++ templates/rust-workspace.nix | 185 ++++++++++++++++ toolchains/rust-toolchain.nix | 6 +- 14 files changed, 635 insertions(+), 18 deletions(-) rename {deployments/nix-darwin => nix-darwin}/configuration.nix (100%) rename {deployments/nix-darwin => nix-darwin}/flake.nix (100%) rename {deployments => nixos/modules/deployments}/README.md (100%) rename {deployments => nixos/modules/deployments}/debug-vm.nix (100%) rename {deployments => nixos/modules/deployments}/digital-ocean/configuration.nix (100%) rename {deployments => nixos/modules/deployments}/digital-ocean/digital-ocean-image.nix (100%) rename {deployments => nixos/modules/deployments}/lasr_node/common.nix (100%) rename {deployments => nixos/modules/deployments}/lasr_node/lasr-overlay.nix (100%) rename {deployments => nixos/modules/deployments}/lasr_node/nightly/nightly-options.nix (100%) create mode 100644 templates/rust-package.nix create mode 100644 templates/rust-workspace-hakari.nix create mode 100644 templates/rust-workspace.nix diff --git a/flake.nix b/flake.nix index d8a509c..997ea42 100644 --- a/flake.nix +++ b/flake.nix @@ -19,12 +19,6 @@ flake-utils.url = "github:numtide/flake-utils"; - # TODO: enable checks - # advisory-db = { - # url = "github:rustsec/advisory-db"; - # flake = false; - # }; - versatus = { url = "github:versatus/versatus"; flake = false; @@ -44,7 +38,22 @@ inherit (pkgs) lib; # Language toolchains - rustToolchain = pkgs.callPackage ./toolchains/rust-toolchain.nix { inherit fenix versatus; }; + # + # Given the path to a `rust-toolchain.toml`, produces the derivation + # for that toolchain for linux and darwin systems. + # Useful for rust projects that declare a `rust-toolchain.toml`. + mkRustToolchainFromTOML = toml_path: hash: + import ./toolchains/rust-toolchain.nix { + inherit + lib + pkgs + fenix + system + toml_path + hash; + }; + rustToolchain = mkRustToolchainFromTOML (versatus + "/rust-toolchain.toml") + "sha256-SXRtAuO4IqNOQq+nLbrsDFbVk+3aVA8NNpSZsKlVH/8="; haskellToolchain = pkgs.callPackage ./toolchains/haskell-toolchain.nix pkgs; # Overrides the default crane rust-toolchain with fenix. @@ -156,9 +165,9 @@ lasrGuestVM = nixpkgs.lib.nixosSystem { system = null; modules = [ - ./deployments/lasr_node/common.nix - ./deployments/lasr_node/nightly/nightly-options.nix - ./deployments/debug-vm.nix + ./nixos/modules/deployments/lasr_node/common.nix + ./nixos/modules/deployments/lasr_node/nightly/nightly-options.nix + self.nixosModules.deployments.debugVm ({ # macOS specific stuff virtualisation.host.pkgs = hostPkgs; @@ -285,6 +294,15 @@ # default = versaNodeBin; # }; + # Handles building project specific toolchains. + toolchains = { + # Given the path to a `rust-toolchain.toml`, produces the derivation + # for that toolchain for linux and darwin systems. + # Useful for rust projects that declare a `rust-toolchain.toml`. + inherit mkRustToolchainFromTOML; + }; + + devShells = rec { default = nix-dev; # Developer environments for Versatus repos @@ -328,12 +346,13 @@ }; }) // { overlays = { - lasr_overlay = import ./deployments/lasr_node/lasr-overlay.nix; + lasr_overlay = import ./nixos/modules/deployments/lasr_node/lasr-overlay.nix; rust = final: prev: { # This contains a lot of policy decisions which rust toolchain is used craneLib = (self.inputs.crane.mkLib prev).overrideToolchain final.rustToolchain.fenix-pkgs; rustToolchain = prev.callPackage ./toolchains/rust-toolchain.nix { - inherit (self.inputs) fenix versatus; + inherit (self.inputs) fenix; toml_path = (self.inputs.versatus + "/rust-toolchain.toml"); + hash = "sha256-SXRtAuO4IqNOQq+nLbrsDFbVk+3aVA8NNpSZsKlVH/8="; }; # This wouldn't be necessary if the lasr overlay was defined in the lasr repo @@ -341,6 +360,52 @@ }; }; + nixosModules = { + deployments = { + debugVm = ./nixos/modules/deployments/debug-vm.nix; + digitalOcean = { + digitalOceanImage = ./nixos/modules/deployments/digital-ocean/digital-ocean-image.nix; + configuration = ./nixos/modules/deployments/digital-ocean/configuration.nix; + }; + }; + }; + + templates = { + rust-package = { + path = ./templates/rust-package.nix; + description = '' + Initializes a nix flake that includes the boilerplate code for building + and developing Versatus' rust-based single-package projects. A workspace + template is also available: `rust-workspace`. + + `nix flake init -t github:versatus/versatus.nix#rust-package` + ''; + }; + rust-workspace = { + path = ./templates/rust-workspace.nix; + description = '' + Initializes a nix flake that includes the boilerplate code for building + and developing Versatus' rust-based workspace projects. A single-package + template is available: `rust-package`, as well as a workspace template + with extra workspace testing tools: `rust-workspace-hakari`. + + `nix flake init -t github:versatus/versatus.nix#rust-workspace` + ''; + }; + rust-workspace-hakari = { + path = ./templates/rust-workspace-hakari.nix; + description = '' + Initializes a nix flake that includes the boilerplate code for building + and developing Versatus' rust-based workspace projects. A single-package + template is also available: `rust-package`. This template includes the + cargo-hakari workspace tooling, a version of this template without hakari + is also available: `rust-workspace`. + + `nix flake init -t github:versatus/versatus.nix#rust-workspace-hakari` + ''; + }; + }; + nixosConfigurations.lasr_nightly = let system = flake-utils.lib.system.x86_64-linux; @@ -348,9 +413,9 @@ nixpkgs.lib.nixosSystem { inherit system; modules = [ - ./deployments/lasr_node/common.nix - ./deployments/lasr_node/nightly/nightly-options.nix - ./deployments/digital-ocean/digital-ocean-image.nix + ./nixos/modules/deployments/lasr_node/common.nix + ./nixos/modules/deployments/lasr_node/nightly/nightly-options.nix + self.nixosModules.deployments.digitalOcean.digitalOceanImage ({ nixpkgs.overlays = [ self.overlays.rust diff --git a/deployments/nix-darwin/configuration.nix b/nix-darwin/configuration.nix similarity index 100% rename from deployments/nix-darwin/configuration.nix rename to nix-darwin/configuration.nix diff --git a/deployments/nix-darwin/flake.nix b/nix-darwin/flake.nix similarity index 100% rename from deployments/nix-darwin/flake.nix rename to nix-darwin/flake.nix diff --git a/deployments/README.md b/nixos/modules/deployments/README.md similarity index 100% rename from deployments/README.md rename to nixos/modules/deployments/README.md diff --git a/deployments/debug-vm.nix b/nixos/modules/deployments/debug-vm.nix similarity index 100% rename from deployments/debug-vm.nix rename to nixos/modules/deployments/debug-vm.nix diff --git a/deployments/digital-ocean/configuration.nix b/nixos/modules/deployments/digital-ocean/configuration.nix similarity index 100% rename from deployments/digital-ocean/configuration.nix rename to nixos/modules/deployments/digital-ocean/configuration.nix diff --git a/deployments/digital-ocean/digital-ocean-image.nix b/nixos/modules/deployments/digital-ocean/digital-ocean-image.nix similarity index 100% rename from deployments/digital-ocean/digital-ocean-image.nix rename to nixos/modules/deployments/digital-ocean/digital-ocean-image.nix diff --git a/deployments/lasr_node/common.nix b/nixos/modules/deployments/lasr_node/common.nix similarity index 100% rename from deployments/lasr_node/common.nix rename to nixos/modules/deployments/lasr_node/common.nix diff --git a/deployments/lasr_node/lasr-overlay.nix b/nixos/modules/deployments/lasr_node/lasr-overlay.nix similarity index 100% rename from deployments/lasr_node/lasr-overlay.nix rename to nixos/modules/deployments/lasr_node/lasr-overlay.nix diff --git a/deployments/lasr_node/nightly/nightly-options.nix b/nixos/modules/deployments/lasr_node/nightly/nightly-options.nix similarity index 100% rename from deployments/lasr_node/nightly/nightly-options.nix rename to nixos/modules/deployments/lasr_node/nightly/nightly-options.nix diff --git a/templates/rust-package.nix b/templates/rust-package.nix new file mode 100644 index 0000000..7f94f7d --- /dev/null +++ b/templates/rust-package.nix @@ -0,0 +1,161 @@ +{ + description = "Versatus rust-based project template."; + + inputs = { + nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable"; + + crane = { + url = "github:ipetkov/crane"; + inputs.nixpkgs.follows = "nixpkgs"; + }; + + fenix = { + url = "github:nix-community/fenix"; + inputs.nixpkgs.follows = "nixpkgs"; + inputs.rust-analyzer-src.follows = ""; + }; + + flake-utils.url = "github:numtide/flake-utils"; + + advisory-db = { + url = "github:rustsec/advisory-db"; + flake = false; + }; + + versatus-nix = { + url = "github:versatus/versatus.nix"; + inputs.nixpkgs.follows = "nixpkgs"; + inputs.fenix.follows = "fenix"; + inputs.flake-utils.follows = "flake-utils"; + }; + }; + + outputs = { self, nixpkgs, crane, fenix, flake-utils, advisory-db, versatus-nix, ... }: + flake-utils.lib.eachDefaultSystem (system: + let + pkgs = nixpkgs.legacyPackages.${system}; + inherit (pkgs) lib; + + toolchains = versatus-nix.toolchains.${system}; + rustToolchain = toolchains.mkRustToolchainFromTOML + ./rust-toolchain.toml + lib.fakeSha256; # Run `nix flake check` and replace with the expected hash. + + # Overrides the default crane rust-toolchain with fenix. + craneLib = (crane.mkLib pkgs).overrideToolchain rustToolchain.fenix-pkgs; + src = craneLib.cleanCargoSource ./.; + + # Common arguments can be set here to avoid repeating them later + commonArgs = { + inherit src; + strictDeps = true; + + # Inputs that must be available at the time of the build + nativeBuildInputs = [ + # pkgs.pkg-config # necessary for linking OpenSSL + # pkgs.clang + ]; + + buildInputs = [ + # Add additional build inputs here + # pkgs.openssl.dev + ] ++ [ + # You probably want this. + rustToolchain.darwin-pkgs + ] ++ lib.optionals pkgs.stdenv.isDarwin [ + # Additional darwin specific inputs can be set here + ]; + + # Additional environment variables can be set directly + # LIBCLANG_PATH = "${pkgs.libclang.lib}/lib"; + # MY_CUSTOM_VAR = "some value"; + }; + + # Build *just* the cargo dependencies, so we can reuse + # all of that work (e.g. via cachix) when running in CI + cargoArtifacts = craneLib.buildDepsOnly commonArgs; + + # Build the actual crate itself, reusing the dependency + # artifacts from above. + my-crate = craneLib.buildPackage (commonArgs // { + inherit cargoArtifacts; + doCheck = false; # Use cargo-nexttest below. + # Extra command line arguments to pass to cargo. + # cargoExtraArgs = "--locked --bin your_binary_name"; + }); + in + { + checks = { + # Build the crate as part of `nix flake check` for convenience + inherit my-crate; + + # Run clippy (and deny all warnings) on the crate source, + # again, reusing the dependency artifacts from above. + # + # Note that this is done as a separate derivation so that + # we can block the CI if there are issues here, but not + # prevent downstream consumers from building our crate by itself. + my-crate-clippy = craneLib.cargoClippy (commonArgs // { + inherit cargoArtifacts; + cargoClippyExtraArgs = "--all-targets -- --deny warnings"; + }); + + my-crate-doc = craneLib.cargoDoc (commonArgs // { + inherit cargoArtifacts; + }); + + # Check formatting + my-crate-fmt = craneLib.cargoFmt { + inherit src; + }; + + # Audit dependencies + my-crate-audit = craneLib.cargoAudit { + inherit src advisory-db; + }; + + # Audit licenses + my-crate-deny = craneLib.cargoDeny { + inherit src; + }; + + # Run tests with cargo-nextest + # Consider setting `doCheck = false` on `my-crate` if you do not want + # the tests to run twice + my-crate-nextest = craneLib.cargoNextest (commonArgs // { + inherit cargoArtifacts; + partitions = 1; + partitionType = "count"; + }); + }; + + packages = { + default = my-crate; + } // lib.optionalAttrs (!pkgs.stdenv.isDarwin) { + my-crate-llvm-coverage = craneLib.cargoLlvmCov (commonArgs // { + inherit cargoArtifacts; + }); + }; + + apps.default = flake-utils.lib.mkApp { + drv = my-crate; + }; + + devShells.default = craneLib.devShell { + # Inherit inputs from checks. + checks = self.checks.${system}; + + # Additional dev-shell environment variables can be set directly + # MY_CUSTOM_DEVELOPMENT_VAR = "something else"; + + # Extra inputs can be added here; cargo and rustc are provided by default. + packages = with pkgs; [ + # ripgrep + nil # nix lsp + nixpkgs-fmt # nix formatter + ]; + }; + + formatter = pkgs.nixpkgs-fmt; + }); +} diff --git a/templates/rust-workspace-hakari.nix b/templates/rust-workspace-hakari.nix new file mode 100644 index 0000000..e8df697 --- /dev/null +++ b/templates/rust-workspace-hakari.nix @@ -0,0 +1,206 @@ +{ + description = "Versatus rust-based project template."; + + inputs = { + nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable"; + + crane = { + url = "github:ipetkov/crane"; + inputs.nixpkgs.follows = "nixpkgs"; + }; + + fenix = { + url = "github:nix-community/fenix"; + inputs.nixpkgs.follows = "nixpkgs"; + inputs.rust-analyzer-src.follows = ""; + }; + + flake-utils.url = "github:numtide/flake-utils"; + + advisory-db = { + url = "github:rustsec/advisory-db"; + flake = false; + }; + + versatus-nix = { + url = "github:versatus/versatus.nix"; + inputs.nixpkgs.follows = "nixpkgs"; + inputs.fenix.follows = "fenix"; + inputs.flake-utils.follows = "flake-utils"; + }; + }; + + outputs = { self, nixpkgs, crane, fenix, flake-utils, advisory-db, versatus-nix, ... }: + flake-utils.lib.eachDefaultSystem (system: + let + pkgs = nixpkgs.legacyPackages.${system}; + inherit (pkgs) lib; + + toolchains = versatus-nix.toolchains.${system}; + + rustToolchain = toolchains.mkRustToolchainFromTOML + ./rust-toolchain.toml + lib.fakeSha256; + # Overrides the default crane rust-toolchain with fenix. + craneLib = (crane.mkLib pkgs).overrideToolchain rustToolchain.fenix-pkgs; + src = craneLib.cleanCargoSource ./.; + + # Common arguments can be set here to avoid repeating them later + commonArgs = { + inherit src; + strictDeps = true; + + # Inputs that must be available at the time of the build + nativeBuildInputs = [ + # pkgs.pkg-config # necessary for linking OpenSSL + # pkgs.clang + ]; + + buildInputs = [ + # Add additional build inputs here + # pkgs.openssl.dev + ] ++ [ + # You probably want this. + rustToolchain.darwin-pkgs + ] ++ lib.optionals pkgs.stdenv.isDarwin [ + # Additional darwin specific inputs can be set here + ]; + + # Additional environment variables can be set directly + # LIBCLANG_PATH = "${pkgs.libclang.lib}/lib"; + # MY_CUSTOM_VAR = "some value"; + }; + + # Build *just* the cargo dependencies, so we can reuse + # all of that work (e.g. via cachix) when running in CI + cargoArtifacts = craneLib.buildDepsOnly commonArgs; + individualCrateArgs = commonArgs // { + inherit cargoArtifacts; + inherit (craneLib.crateNameFromCargoToml { inherit src; }) version; + doCheck = false; # Use cargo-nexttest below. + }; + + fileSetForCrate = crate: lib.fileset.toSource { + root = ./.; + fileset = lib.fileset.unions [ + ./Cargo.toml + ./Cargo.lock + ./my-common + ./my-workspace-hack + crate + ]; + }; + + # Build the top-level crates of the workspace as individual derivations. + # This allows consumers to only depend on (and build) only what they need. + # Though it is possible to build the entire workspace as a single derivation, + # so this is left up to you on how to organize things + my-cli = craneLib.buildPackage (individualCrateArgs // { + pname = "my-cli"; + cargoExtraArgs = "-p my-cli"; # specify the package to build + src = fileSetForCrate ./my-cli; + }); + my-server = craneLib.buildPackage (individualCrateArgs // { + pname = "my-server"; + cargoExtraArgs = "-p my-server"; # specify the package to build + src = fileSetForCrate ./my-server; + }); + in + { + checks = { + # Build the crate as part of `nix flake check` for convenience + inherit my-cli my-server; + + # Run clippy (and deny all warnings) on the workspace source, + # again, reusing the dependency artifacts from above. + # + # Note that this is done as a separate derivation so that + # we can block the CI if there are issues here, but not + # prevent downstream consumers from building our crate by itself. + my-workspace-clippy = craneLib.cargoClippy (commonArgs // { + inherit cargoArtifacts; + cargoClippyExtraArgs = "--all-targets -- --deny warnings"; + }); + + my-workspace-doc = craneLib.cargoDoc (commonArgs // { + inherit cargoArtifacts; + }); + + # Check formatting + my-workspace-fmt = craneLib.cargoFmt { + inherit src; + }; + + # Audit dependencies + my-workspace-audit = craneLib.cargoAudit { + inherit src advisory-db; + }; + + # Audit licenses + my-workspace-deny = craneLib.cargoDeny { + inherit src; + }; + + # Run tests with cargo-nextest + # Consider setting `doCheck = false` on other crate derivations + # if you do not want the tests to run twice + my-workspace-nextest = craneLib.cargoNextest (commonArgs // { + inherit cargoArtifacts; + partitions = 1; + partitionType = "count"; + }); + + # Ensure that cargo-hakari is up to date + my-workspace-hakari = craneLib.mkCargoDerivation { + inherit src; + pname = "my-workspace-hakari"; + cargoArtifacts = null; + doInstallCargoArtifacts = false; + + buildPhaseCargoCommand = '' + cargo hakari generate --diff # workspace-hack Cargo.toml is up-to-date + cargo hakari manage-deps --dry-run # all workspace crates depend on workspace-hack + cargo hakari verify + ''; + + nativeBuildInputs = [ + pkgs.cargo-hakari + ]; + }; + }; + + packages = { + inherit my-cli my-server; + } // lib.optionalAttrs (!pkgs.stdenv.isDarwin) { + my-workspace-llvm-coverage = craneLib.cargoLlvmCov (commonArgs // { + inherit cargoArtifacts; + }); + }; + + apps = { + my-cli = flake-utils.lib.mkApp { + drv = my-cli; + }; + my-server = flake-utils.lib.mkApp { + drv = my-server; + }; + }; + + devShells.default = craneLib.devShell { + # Inherit inputs from checks. + checks = self.checks.${system}; + + # Additional dev-shell environment variables can be set directly + # MY_CUSTOM_DEVELOPMENT_VAR = "something else"; + + # Extra inputs can be added here; cargo and rustc are provided by default. + packages = with pkgs; [ + cargo-hakari + nil # nix lsp + nixpkgs-fmt # nix formatter + ]; + }; + + formatter = pkgs.nixpkgs-fmt; + }); +} diff --git a/templates/rust-workspace.nix b/templates/rust-workspace.nix new file mode 100644 index 0000000..8c6b111 --- /dev/null +++ b/templates/rust-workspace.nix @@ -0,0 +1,185 @@ +{ + description = "Versatus rust-based project template."; + + inputs = { + nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable"; + + crane = { + url = "github:ipetkov/crane"; + inputs.nixpkgs.follows = "nixpkgs"; + }; + + fenix = { + url = "github:nix-community/fenix"; + inputs.nixpkgs.follows = "nixpkgs"; + inputs.rust-analyzer-src.follows = ""; + }; + + flake-utils.url = "github:numtide/flake-utils"; + + advisory-db = { + url = "github:rustsec/advisory-db"; + flake = false; + }; + + versatus-nix = { + url = "github:versatus/versatus.nix"; + inputs.nixpkgs.follows = "nixpkgs"; + inputs.fenix.follows = "fenix"; + inputs.flake-utils.follows = "flake-utils"; + }; + }; + + outputs = { self, nixpkgs, crane, fenix, flake-utils, advisory-db, versatus-nix, ... }: + flake-utils.lib.eachDefaultSystem (system: + let + pkgs = nixpkgs.legacyPackages.${system}; + inherit (pkgs) lib; + + toolchains = versatus-nix.toolchains.${system}; + + rustToolchain = toolchains.mkRustToolchainFromTOML + ./rust-toolchain.toml + lib.fakeSha256; + # Overrides the default crane rust-toolchain with fenix. + craneLib = (crane.mkLib pkgs).overrideToolchain rustToolchain.fenix-pkgs; + src = craneLib.cleanCargoSource ./.; + + # Common arguments can be set here to avoid repeating them later + commonArgs = { + inherit src; + strictDeps = true; + + # Inputs that must be available at the time of the build + nativeBuildInputs = [ + # pkgs.pkg-config # necessary for linking OpenSSL + # pkgs.clang + ]; + + buildInputs = [ + # Add additional build inputs here + # pkgs.openssl.dev + ] ++ [ + # You probably want this. + rustToolchain.darwin-pkgs + ] ++ lib.optionals pkgs.stdenv.isDarwin [ + # Additional darwin specific inputs can be set here + ]; + + # Additional environment variables can be set directly + # LIBCLANG_PATH = "${pkgs.libclang.lib}/lib"; + # MY_CUSTOM_VAR = "some value"; + }; + + # Build *just* the cargo dependencies, so we can reuse + # all of that work (e.g. via cachix) when running in CI + cargoArtifacts = craneLib.buildDepsOnly commonArgs; + individualCrateArgs = commonArgs // { + inherit cargoArtifacts; + inherit (craneLib.crateNameFromCargoToml { inherit src; }) version; + doCheck = false; # Use cargo-nexttest below. + }; + + fileSetForCrate = crate: lib.fileset.toSource { + root = ./.; + fileset = lib.fileset.unions [ + ./Cargo.toml + ./Cargo.lock + crate + ]; + }; + + # Build the top-level crates of the workspace as individual derivations. + # This allows consumers to only depend on (and build) only what they need. + # Though it is possible to build the entire workspace as a single derivation, + # so this is left up to you on how to organize things + my-cli = craneLib.buildPackage (individualCrateArgs // { + pname = "my-cli"; + cargoExtraArgs = "-p my-cli"; # specify the package to build + src = fileSetForCrate ./my-cli; + }); + my-server = craneLib.buildPackage (individualCrateArgs // { + pname = "my-server"; + cargoExtraArgs = "-p my-server"; # specify the package to build + src = fileSetForCrate ./my-server; + }); + in + { + checks = { + # Build the crate as part of `nix flake check` for convenience + inherit my-cli my-server; + + # Run clippy (and deny all warnings) on the workspace source, + # again, reusing the dependency artifacts from above. + # + # Note that this is done as a separate derivation so that + # we can block the CI if there are issues here, but not + # prevent downstream consumers from building our crate by itself. + my-workspace-clippy = craneLib.cargoClippy (commonArgs // { + inherit cargoArtifacts; + cargoClippyExtraArgs = "--all-targets -- --deny warnings"; + }); + + my-workspace-doc = craneLib.cargoDoc (commonArgs // { + inherit cargoArtifacts; + }); + + # Check formatting + my-workspace-fmt = craneLib.cargoFmt { + inherit src; + }; + + # Audit dependencies + my-workspace-audit = craneLib.cargoAudit { + inherit src advisory-db; + }; + + # Audit licenses + my-workspace-deny = craneLib.cargoDeny { + inherit src; + }; + + # Run tests with cargo-nextest + # Consider setting `doCheck = false` on other crate derivations + # if you do not want the tests to run twice + my-workspace-nextest = craneLib.cargoNextest (commonArgs // { + inherit cargoArtifacts; + partitions = 1; + partitionType = "count"; + }); + }; + + packages = { + inherit my-cli my-server; + } // lib.optionalAttrs (!pkgs.stdenv.isDarwin) { + my-workspace-llvm-coverage = craneLib.cargoLlvmCov (commonArgs // { + inherit cargoArtifacts; + }); + }; + + apps = { + my-cli = flake-utils.lib.mkApp { + drv = my-cli; + }; + my-server = flake-utils.lib.mkApp { + drv = my-server; + }; + }; + + devShells.default = craneLib.devShell { + # Inherit inputs from checks. + checks = self.checks.${system}; + + # Additional dev-shell environment variables can be set directly + # MY_CUSTOM_DEVELOPMENT_VAR = "something else"; + + # Extra inputs can be added here; cargo and rustc are provided by default. + packages = with pkgs; [ + nil # nix lsp + nixpkgs-fmt # nix formatter + ]; + }; + + formatter = pkgs.nixpkgs-fmt; + }); +} diff --git a/toolchains/rust-toolchain.nix b/toolchains/rust-toolchain.nix index dba6fb0..8b90948 100644 --- a/toolchains/rust-toolchain.nix +++ b/toolchains/rust-toolchain.nix @@ -1,8 +1,8 @@ -{ lib, pkgs, fenix, system, versatus }: +{ lib, pkgs, fenix, system, toml_path, hash }: let fenix-pkgs = (fenix.packages.${system}.fromToolchainFile { - file = versatus + "/rust-toolchain.toml"; - sha256 = "sha256-SXRtAuO4IqNOQq+nLbrsDFbVk+3aVA8NNpSZsKlVH/8="; + file = toml_path; + sha256 = hash; }); darwin-pkgs = (with pkgs; lib.optionals stdenv.isDarwin [ # Additional darwin specific inputs