nix: Package zerofs in nix, add nixos module, and nixos tests

.gitignore

@@ -4,3 +4,4 @@ target
 bench/bench_workspace
 zerofs.toml
 TODO.md
+result*

README.md

@@ -127,6 +127,39 @@ cargo install zerofs
 docker pull ghcr.io/barre/zerofs:latest
 ```
 
+#### Via Nix
+```nix
+# flake.nix
+{
+  inputs.zerofs.url = "github:Barre/ZeroFS";
+
+  outputs = { nixpkgs, zerofs, ... }: {
+    nixosConfigurations.myhost = nixpkgs.lib.nixosSystem {
+      modules = [
+        { nixpkgs.overlays = [ zerofs.overlays.default ]; }
+        zerofs.nixosModules.default
+        {
+          services.zerofs = {
+            enable = true;
+            settings = {
+              cache.dir = "/var/cache/zerofs";
+              cache.disk_size_gb = 10.0;
+              storage.url = "s3://my-bucket/zerofs-data";
+              storage.encryption_password = "\${ZEROFS_PASSWORD}";
+              servers.nfs.addresses = [ "127.0.0.1:2049" ];
+              aws = {
+                access_key_id = "\${AWS_ACCESS_KEY_ID}";
+                secret_access_key = "\${AWS_SECRET_ACCESS_KEY}";
+              };
+            };
+          };
+        }
+      ];
+    };
+  };
+}
+```
+
 ### Getting Started
 
 ```bash

documentation/src/app/quickstart/page.mdx

@@ -48,6 +48,23 @@ docker pull ghcr.io/barre/zerofs:latest
     encryption-password: ${{ secrets.ZEROFS_PASSWORD }}
 ```
 
+```nix {{ title: 'NixOS Module' }}
+# flake.nix
+{
+  inputs.zerofs.url = "github:Barre/ZeroFS";
+
+  outputs = { nixpkgs, zerofs, ... }: {
+    nixosConfigurations.myhost = nixpkgs.lib.nixosSystem {
+      modules = [
+        { nixpkgs.overlays = [ zerofs.overlays.default ]; }
+        zerofs.nixosModules.default
+        { services.zerofs.enable = true; /* ... */ }
+      ];
+    };
+  };
+}
+```
+
 </CodeGroup>
 
 ## Configuration
@@ -139,6 +156,24 @@ allow_http = "true"    # For HTTP endpoints
 addresses = ["127.0.0.1:2049"]
 ```
 
+```nix {{ title: 'NixOS' }}
+services.zerofs = {
+  enable = true;
+  settings = {
+    cache.dir = "/var/cache/zerofs";
+    cache.disk_size_gb = 10.0;
+    cache.memory_size_gb = 2.0;
+    storage.url = "s3://my-bucket/zerofs-data";
+    storage.encryption_password = "\${ZEROFS_PASSWORD}";
+    servers.nfs.addresses = [ "127.0.0.1:2049" ];
+    aws = {
+      access_key_id = "\${AWS_ACCESS_KEY_ID}";
+      secret_access_key = "\${AWS_SECRET_ACCESS_KEY}";
+    };
+  };
+};
+```
+
 </CodeGroup>
 
 <div className="not-prose">

flake.nix

@@ -0,0 +1,33 @@
+{
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
+
+    flake-parts = {
+      url = "github:hercules-ci/flake-parts";
+      inputs.nixpkgs-lib.follows = "nixpkgs";
+    };
+
+    crane.url = "github:ipetkov/crane";
+  };
+
+  outputs = inputs @ { self, flake-parts, ... }: let
+    inherit (inputs.nixpkgs) lib;
+
+    modules = builtins.foldl' (acc: f: f acc) ./nix/flake [
+      builtins.readDir
+      (lib.filterAttrs (name: type:
+        type == "regular" && lib.hasSuffix ".nix" name
+      ))
+      (lib.mapAttrsToList (name: _:
+        lib.path.append ./nix/flake name
+      ))
+    ];
+
+  in flake-parts.lib.mkFlake { inherit inputs; } {
+    imports = modules;
+    systems = [
+      "x86_64-linux"
+      "aarch64-linux"
+    ];
+  };
+}

nix/flake/nixos-modules.nix

@@ -0,0 +1,7 @@
+{ inputs, ... }:
+{
+  flake.nixosModules = {
+    zerofs = import ../nixos/zerofs.nix;
+    default = inputs.self.nixosModules.zerofs;
+  };
+}

nix/flake/overlays.nix

@@ -0,0 +1,12 @@
+{ inputs, ... }:
+{
+  flake.overlays = {
+    zerofs = final: prev: {
+      zerofs = final.callPackage "${inputs.self}/nix/package.nix" {
+        craneLib = inputs.crane.mkLib final;
+      };
+    };
+
+    default = inputs.self.overlays.zerofs;
+  };
+}

nix/flake/packages.nix

@@ -0,0 +1,13 @@
+{ inputs, ... }:
+{
+  perSystem = { pkgs, ... }:
+    let
+      craneLib = inputs.crane.mkLib pkgs;
+      zerofs = pkgs.callPackage "${inputs.self}/nix/package.nix" { inherit craneLib; };
+    in {
+      packages = {
+        inherit zerofs;
+        default = zerofs;
+      };
+    };
+}

nix/flake/tests.nix

@@ -0,0 +1,33 @@
+{ inputs, lib, ... }:
+{
+  perSystem =
+    { pkgs, system, ... }:
+    let
+      mkTest =
+        name:
+        lib.nixos.evalTest {
+          imports = [ (../nixos/tests + "/${name}.nix") ];
+          hostPkgs = pkgs;
+          defaults = {
+            imports = [ inputs.self.nixosModules.default ];
+            services.zerofs.package = lib.mkDefault inputs.self.packages.${system}.default;
+          };
+        };
+
+      tests = {
+        nfs = mkTest "nfs";
+        "9p-tcp" = mkTest "9p-tcp";
+        "9p-uds" = mkTest "9p-uds";
+        "nbd-zfs" = mkTest "nbd-zfs";
+      };
+    in
+    {
+      apps = lib.mapAttrs' (
+        name: test:
+        lib.nameValuePair "test-${name}" {
+          type = "app";
+          program = "${test.config.result.driver}/bin/nixos-test-driver";
+        }
+      ) tests;
+    };
+}

nix/nixos/tests/9p-tcp.nix

@@ -0,0 +1,65 @@
+{ pkgs, ... }:
+{
+  name = "9p-tcp";
+
+  nodes.machine = { pkgs, ... }: {
+    services.minio = {
+      enable = true;
+      rootCredentialsFile = pkgs.writeText "minio-credentials" ''
+        MINIO_ROOT_USER=minioadmin
+        MINIO_ROOT_PASSWORD=minioadmin
+      '';
+    };
+
+    services.zerofs = {
+      enable = true;
+      settings = {
+        cache = {
+          dir = "/var/cache/zerofs";
+          disk_size_gb = 1.0;
+        };
+        storage = {
+          url = "s3://zerofs-test/data";
+          encryption_password = "test-password";
+        };
+        servers.ninep.addresses = [ "127.0.0.1:5564" ];
+        aws = {
+          access_key_id = "minioadmin";
+          secret_access_key = "minioadmin";
+          endpoint = "http://127.0.0.1:9000";
+          region = "us-east-1";
+          allow_http = "true";
+        };
+      };
+    };
+  };
+
+  testScript = ''
+    machine.wait_for_unit("minio.service")
+    machine.wait_for_open_port(9000)
+
+    machine.succeed(
+      "${pkgs.minio-client}/bin/mc alias set local http://127.0.0.1:9000 minioadmin minioadmin",
+      "${pkgs.minio-client}/bin/mc mb local/zerofs-test",
+    )
+
+    machine.wait_for_unit("zerofs.service")
+    machine.wait_for_open_port(5564)
+
+    # Mount zerofs via 9P over TCP
+    machine.succeed("mkdir -p /mnt/zerofs")
+    machine.succeed("mount -t 9p -o trans=tcp,port=5564,version=9p2000.L,cache=mmap 127.0.0.1 /mnt/zerofs")
+
+    # Test basic file operations
+    machine.succeed("echo 'Hello from ZeroFS 9P!' > /mnt/zerofs/test.txt")
+    output = machine.succeed("cat /mnt/zerofs/test.txt")
+    assert "Hello from ZeroFS 9P!" in output, f"Unexpected content: {output}"
+
+    machine.succeed("ls -la /mnt/zerofs/")
+
+    machine.succeed("rm /mnt/zerofs/test.txt")
+    machine.succeed("test ! -f /mnt/zerofs/test.txt")
+
+    machine.succeed("umount /mnt/zerofs")
+  '';
+}

nix/nixos/tests/9p-uds.nix

@@ -0,0 +1,67 @@
+{ pkgs, ... }:
+{
+  name = "9p-uds";
+
+  nodes.machine = { pkgs, ... }: {
+    services.minio = {
+      enable = true;
+      rootCredentialsFile = pkgs.writeText "minio-credentials" ''
+        MINIO_ROOT_USER=minioadmin
+        MINIO_ROOT_PASSWORD=minioadmin
+      '';
+    };
+
+    services.zerofs = {
+      enable = true;
+      settings = {
+        cache = {
+          dir = "/var/cache/zerofs";
+          disk_size_gb = 1.0;
+        };
+        storage = {
+          url = "s3://zerofs-test/data";
+          encryption_password = "test-password";
+        };
+        servers.ninep.unix_socket = "/run/zerofs/zerofs.9p.sock";
+        aws = {
+          access_key_id = "minioadmin";
+          secret_access_key = "minioadmin";
+          endpoint = "http://127.0.0.1:9000";
+          region = "us-east-1";
+          allow_http = "true";
+        };
+      };
+    };
+  };
+
+  testScript = ''
+    machine.wait_for_unit("minio.service")
+    machine.wait_for_open_port(9000)
+
+    machine.succeed(
+      "${pkgs.minio-client}/bin/mc alias set local http://127.0.0.1:9000 minioadmin minioadmin",
+      "${pkgs.minio-client}/bin/mc mb local/zerofs-test",
+    )
+
+    machine.wait_for_unit("zerofs.service")
+
+    # Wait for Unix socket to be created
+    machine.wait_for_file("/run/zerofs/zerofs.9p.sock")
+
+    # Mount zerofs via 9P over Unix domain socket
+    machine.succeed("mkdir -p /mnt/zerofs")
+    machine.succeed("mount -t 9p -o trans=unix,version=9p2000.L,cache=mmap,access=user /run/zerofs/zerofs.9p.sock /mnt/zerofs")
+
+    # Test basic file operations
+    machine.succeed("echo 'Hello from ZeroFS 9P UDS!' > /mnt/zerofs/test.txt")
+    output = machine.succeed("cat /mnt/zerofs/test.txt")
+    assert "Hello from ZeroFS 9P UDS!" in output, f"Unexpected content: {output}"
+
+    machine.succeed("ls -la /mnt/zerofs/")
+
+    machine.succeed("rm /mnt/zerofs/test.txt")
+    machine.succeed("test ! -f /mnt/zerofs/test.txt")
+
+    machine.succeed("umount /mnt/zerofs")
+  '';
+}