not working dump

.dockerignore

@@ -0,0 +1,4 @@
+**/.parcel-cache
+**/dist
+**/node_modules
+**/target

.github/workflows/server.yml

@@ -7,6 +7,12 @@ on:
   pull_request:
     branches: ["main"]
 
+env:
+  # Use docker.io for Docker Hub if empty
+  REGISTRY: ghcr.io
+  # github.repository as <account>/<repo>
+  IMAGE_NAME: ${{ github.repository }}
+
 jobs:
   build-dhfs:
     runs-on: ubuntu-latest
@@ -14,21 +20,26 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-        with:
-          submodules: "recursive"
 
       - name: Install sudo for ACT
         run: apt-get update && apt-get install -y sudo
         if: env.ACT=='true'
 
-      - name: Install FUSE
-        run: sudo apt-get update && sudo apt-get install -y libfuse2 libfuse3-dev libfuse3-3 fuse3
+      - name: Install fuse and maven
+        run: sudo apt-get update && sudo apt-get install -y libfuse2
 
-      - name: User allow other for fuse
-        run: echo "user_allow_other" | sudo tee -a /etc/fuse.conf
+      - name: Download maven
+        run: |
+          cd "$HOME"
+          mkdir maven-bin
+          curl -s -L https://dlcdn.apache.org/maven/maven-3/3.9.9/binaries/apache-maven-3.9.9-bin.tar.gz | tar xvz --strip-components=1 -C maven-bin
+          echo "$HOME"/maven-bin/bin >> $GITHUB_PATH
 
-      - name: Dump fuse.conf
-        run: cat /etc/fuse.conf
+      - name: Maven info
+        run: |
+          echo $GITHUB_PATH
+          echo $PATH
+          mvn -v
 
       - name: Set up JDK 21
         uses: actions/setup-java@v4
@@ -37,21 +48,16 @@ jobs:
           distribution: "zulu"
           cache: maven
 
-      - name: Build LazyFS
-        run: cd thirdparty/lazyfs/ && ./build.sh
-
       - name: Test with Maven
-        run: cd dhfs-parent && mvn -T $(nproc) --batch-mode --update-snapshots package verify javadoc:aggregate
+        run: cd dhfs-parent && mvn -T $(nproc) --batch-mode --update-snapshots package verify
+
+      # - name: Build with Maven
+      #   run: cd dhfs-parent && mvn --batch-mode --update-snapshots package # -Dquarkus.log.category.\"com.usatiuk.dhfs\".min-level=DEBUG
 
       - uses: actions/upload-artifact@v4
         with:
           name: DHFS Server Package
-          path: dhfs-parent/dhfs-fuse/target/quarkus-app
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: DHFS Javadocs
-          path: dhfs-parent/target/reports/apidocs/
+          path: dhfs-parent/dhfs-app/target/quarkus-app
 
       - uses: actions/upload-artifact@v4
         if: ${{ always() }}
@@ -83,12 +89,211 @@ jobs:
           name: Webui
           path: webui/dist
 
+  build-native-libs:
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            cross: "linux/amd64"
+          - os: ubuntu-latest
+            cross: "linux/arm64"
+          - os: macos-latest
+
+    runs-on: ${{ matrix.os }}
+    env:
+      DO_LOCAL_BUILD: ${{ matrix.os == 'macos-latest' }}
+      DOCKER_PLATFORM: ${{ matrix.cross || 'NATIVE' }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set SANITIZED_DOCKER_PLATFORM
+        run: echo "SANITIZED_DOCKER_PLATFORM=$(echo $DOCKER_PLATFORM | tr / _ )" >> $GITHUB_ENV
+
+      - name: Set DOCKER_BUILDER_IMAGE
+        run: echo "DOCKER_BUILDER_IMAGE=dhfs_lib_builder-${{matrix.os}}-$SANITIZED_DOCKER_PLATFORM" >> $GITHUB_ENV
+
+      - name: Build config
+        run: |
+          echo DO_LOCAL_BUILD: $DO_LOCAL_BUILD
+          echo DOCKER_PLATFORM: $DOCKER_PLATFORM
+          echo SANITIZED_DOCKER_PLATFORM: $SANITIZED_DOCKER_PLATFORM
+          echo DOCKER_BUILDER_IMAGE: $DOCKER_BUILDER_IMAGE
+
+      - name: Set up JDK 21
+        if: ${{ env.DO_LOCAL_BUILD == 'TRUE' }}
+        uses: actions/setup-java@v4
+        with:
+          java-version: "21"
+          distribution: "zulu"
+          cache: maven
+
+      - name: Set up Docker Buildx
+        if: ${{ env.DO_LOCAL_BUILD != 'TRUE' }}
+        uses: docker/setup-buildx-action@v3
+
+      - name: Set up QEMU
+        if: ${{ env.DO_LOCAL_BUILD != 'TRUE' }}
+        uses: docker/setup-qemu-action@v3
+
+      - name: Build Docker builder image
+        if: ${{ env.DO_LOCAL_BUILD != 'TRUE' }}
+        uses: docker/build-push-action@v5
+        with:
+          context: ./libdhfs_support/builder
+          file: ./libdhfs_support/builder/Dockerfile
+          push: false
+          platforms: ${{ env.DOCKER_PLATFORM }}
+          tags: ${{ env.DOCKER_BUILDER_IMAGE }}
+          cache-from: type=gha,scope=build-${{ env.DOCKER_BUILDER_IMAGE }}
+          cache-to: type=gha,mode=max,scope=build-${{ env.DOCKER_BUILDER_IMAGE }}
+          load: true
+
+      - name: Build the library
+        run: |
+          CMAKE_ARGS="-DCMAKE_BUILD_TYPE=Release" libdhfs_support/builder/cross-build.sh both build "$(pwd)/result"
+
+      - name: Upload build
+        uses: actions/upload-artifact@v4
+        with:
+          name: NativeLib-${{ matrix.os }}-${{ env.SANITIZED_DOCKER_PLATFORM }}
+          path: result
+
+  merge-native-libs:
+    runs-on: ubuntu-latest
+    needs: [build-native-libs]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: downloaded-libs
+
+      - name: Merge all
+        run: rsync -av downloaded-libs/NativeLib*/* result/
+
+      - name: Check that libs exists
+        run: |
+          test -f "result/Linux-x86_64/libdhfs_support.so" || exit 1
+
+      - name: Upload
+        uses: actions/upload-artifact@v4
+        with:
+          name: NativeLibs
+          path: result
+
+  publish-docker:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+      # This is used to complete the identity challenge
+      # with sigstore/fulcio when running outside of PRs.
+      id-token: write
+
+    needs: [build-webui, merge-native-libs, build-dhfs]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Download server package
+        uses: actions/download-artifact@v4
+        with:
+          name: DHFS Server Package
+          path: dhfs-package-downloaded
+
+      - name: Download webui
+        uses: actions/download-artifact@v4
+        with:
+          name: Webui
+          path: webui-dist-downloaded
+
+      - name: Download native libs
+        uses: actions/download-artifact@v4
+        with:
+          name: NativeLibs
+          path: dhfs-native-downloaded
+
+      - name: Show all the files
+        run: find .
+
+      # Install the cosign tool except on PR
+      # https://github.com/sigstore/cosign-installer
+      - name: Install cosign
+        if: github.event_name != 'pull_request'
+        uses: sigstore/cosign-installer@v3.5.0
+        with:
+          cosign-release: "v2.2.4"
+
+      # Set up BuildKit Docker container builder to be able to build
+      # multi-platform images and export cache
+      # https://github.com/docker/setup-buildx-action
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      # Login against a Docker registry except on PR
+      # https://github.com/docker/login-action
+      - name: Log into registry ${{ env.REGISTRY }}
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # Extract metadata (tags, labels) for Docker
+      # https://github.com/docker/metadata-action
+      - name: Extract Docker metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+
+      # Build and push Docker image with Buildx (don't push on PR)
+      # https://github.com/docker/build-push-action
+      - name: Build and push Docker image
+        id: build-and-push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile.ci
+          push: ${{ github.event_name != 'pull_request' }}
+          platforms: linux/amd64,linux/arm64
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      # Sign the resulting Docker image digest except on PRs.
+      # This will only write to the public Rekor transparency log when the Docker
+      # repository is public to avoid leaking data.  If you would like to publish
+      # transparency data even for private images, pass --force to cosign below.
+      # https://github.com/sigstore/cosign
+      - name: Sign the published Docker image
+        if: ${{ github.event_name != 'pull_request' }}
+        env:
+          # https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions#using-an-intermediate-environment-variable
+          TAGS: ${{ steps.meta.outputs.tags }}
+          DIGEST: ${{ steps.build-and-push.outputs.digest }}
+        # This step uses the identity token to provision an ephemeral certificate
+        # against the sigstore community Fulcio instance.
+        run: echo "${TAGS}" | xargs -I {} cosign sign --yes {}@${DIGEST}
+
   publish-run-wrapper:
     runs-on: ubuntu-latest
     permissions:
       contents: read
+      packages: write
+      # This is used to complete the identity challenge
+      # with sigstore/fulcio when running outside of PRs.
+      id-token: write
 
-    needs: [build-webui, build-dhfs]
+    needs: [build-webui, merge-native-libs, build-dhfs]
 
     steps:
       - name: Checkout repository
@@ -104,6 +309,11 @@ jobs:
           name: Webui
           path: webui-dist-downloaded
 
+      - uses: actions/download-artifact@v4
+        with:
+          name: NativeLibs
+          path: dhfs-native-downloaded
+
       - name: Show all the files
         run: find .
 
@@ -111,18 +321,17 @@ jobs:
         run: mkdir -p run-wrapper-out/dhfs/data && mkdir -p run-wrapper-out/dhfs/fuse && mkdir -p run-wrapper-out/dhfs/app
 
       - name: Copy DHFS
-        run: cp -r ./dhfs-package-downloaded "run-wrapper-out/dhfs/app/Server"
+        run: cp -r ./dhfs-package-downloaded "run-wrapper-out/dhfs/app/DHFS Package"
 
       - name: Copy Webui
         run: cp -r ./webui-dist-downloaded "run-wrapper-out/dhfs/app/Webui"
 
+      - name: Copy Webui
+        run: cp -r ./dhfs-native-downloaded "run-wrapper-out/dhfs/app/NativeLibs"
+
       - name: Copy run wrapper
         run: cp -r ./run-wrapper/* "run-wrapper-out/dhfs/app/"
 
-      - name: Copy README
-        run: |
-          cp README.md "run-wrapper-out/dhfs/"
-
       - name: Add version to run wrapper
         run: echo $GITHUB_RUN_ID > "run-wrapper-out/dhfs/app/"version
 
@@ -134,36 +343,3 @@ jobs:
         with:
           name: Run wrapper
           path: ~/run-wrapper.tar.gz
-
-  publish-javadoc:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      pages: write
-      id-token: write
-
-    needs: [build-webui, build-dhfs]
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - uses: actions/download-artifact@v4
-        with:
-          name: DHFS Javadocs
-          path: dhfs-javadocs-downloaded
-
-      - name: Setup Pages
-        uses: actions/configure-pages@v5
-
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          path: "dhfs-javadocs-downloaded"
-
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "thirdparty/lazyfs/lazyfs"]
-	path = thirdparty/lazyfs/lazyfs
-	url = git@github.com:dsrhaslab/lazyfs.git

.vscode/ltex.dictionary.en-US.txt

@@ -1 +0,0 @@
-Syncthing

Dockerfile

@@ -0,0 +1,35 @@
+FROM node:20-bullseye as webui-build
+
+WORKDIR /usr/src/app/webui-build
+COPY ./webui/package*.json ./
+RUN npm i
+COPY ./webui/. .
+RUN npm run build
+
+FROM azul/zulu-openjdk:21 as server-build
+
+WORKDIR /usr/src/app/server-build
+COPY ./server/.mvn .mvn
+COPY ./server/mvnw ./server/pom.xml ./
+RUN ./mvnw quarkus:go-offline
+# The previous thing still doesn't download 100% everything
+RUN ./mvnw -Dmaven.test.skip=true -Dskip.unit=true package --fail-never
+COPY ./server/. .   
+RUN ./mvnw -Dmaven.test.skip=true -Dskip.unit=true clean package
+
+FROM azul/zulu-openjdk-alpine:21-jre-headless
+
+RUN apk update && apk add fuse && rm -rf /var/cache/apk/*
+
+WORKDIR /usr/src/app
+COPY --from=server-build /usr/src/app/server-build/target/quarkus-app/. .
+RUN mkdir -p webui
+COPY --from=webui-build /usr/src/app/webui-build/dist/. ./webui
+
+ENV dhfs_webui_root=/usr/src/app/webui
+
+COPY ./dockerentry.sh .
+
+RUN ["chmod", "+x", "./dockerentry.sh"]
+
+CMD [ "./dockerentry.sh" ]

Dockerfile.ci

@@ -0,0 +1,24 @@
+FROM azul/zulu-openjdk:21-jre-headless
+
+RUN apt update && apt install -y libfuse2 && apt-get clean
+
+WORKDIR /usr/src/app
+
+COPY ./dhfs-package-downloaded/lib .
+COPY ./dhfs-package-downloaded/*.jar .
+COPY ./dhfs-package-downloaded/app .
+COPY ./dhfs-package-downloaded/quarkus .
+
+WORKDIR /usr/src/app/native-libs
+COPY ./dhfs-native-downloaded/. .
+WORKDIR /usr/src/app/webui
+COPY ./webui-dist-downloaded/. .
+
+ENV dhfs_webui_root=/usr/src/app/webui
+
+WORKDIR /usr/src/app
+COPY ./dockerentry.sh .
+
+RUN ["chmod", "+x", "./dockerentry.sh"]
+
+CMD [ "./dockerentry.sh" ]

README.md

@@ -1,6 +1,4 @@
-# Distributed Home File System
-
-[Javadocs](https://usatiuk.github.io/dhfs/)
+# Distributed Home File System 🚧
 
 ## What is this?
 
@@ -13,78 +11,9 @@ Syncthing and allowing you to stream your files like Google Drive File Stream
 
 [Download latest build](https://nightly.link/usatiuk/dhfs/workflows/server/main/Run%20wrapper.zip)
 
-This is a simple set of scripts that allows you to run/stop
-the DHFS server in the background, and update it.
+This is a simple wrapper around the jar/web ui distribution that allows you to run/stop
+the DHFS server in the background, and update itself (hopefully!)
 
-Once unpacked, in the root folder (`dhfs`), there will be 3 folders:
+## How to use it and how it works?
 
-- `app` contains the application
-- `data` contains the filesystem data storage
-- `fuse` is the default filesystem mount point (not on Windows, the default mount drive letter is `Z`)
-
-Note that on Windows, the path to the root can not contain spaces.
-
-## How to use it?
-
-### General prerequisites
-
-Java should be available as `java` in `PATH`, or with a correctly set `JAVA_HOME` (ignored on Windows), and Java 21 is required.
-
-FUSE 2 userspace library also should be available:
-
-- On Ubuntu `libfuse2` package can be installed, or an analogous package for other distributions.
-
-- On Windows, [WinFsp](https://winfsp.dev/) should be installed.
-
-- On macOS, [macFUSE](https://macfuse.github.io/).
-
-### How to run it?
-
-In the run-wrapper `app` folder, 3 scripts are available.
-
-- `run` script starts the filesystem
-- `stop` script stops it
-- `update` script will update the filesystem to the newest available CI build
-
-On Windows, Powershell versions of the scripts should be used. For them to work, it might be required to allow execution of unsigned scripts using `set-executionpolicy unrestricted`.
-
-### Additional options
-
-Additional options for the filesystem can be specified in the `extra-opts` file in the same directory with the run scripts.
-
-One line in the `extra-opts` file corresponds to one option passed to the JVM when starting the filesystem.
-
-Some extra possible configuration options are:
-
-- `-Ddhfs.fuse.root=` specifies the root where filesystem should be mounted. By default, it is the `fuse` path under the `run-wrapper` root. For windows, it should be a disk root, by default `Z:\`.
-- `-Ddhfs.objects.last-seen.timeout=` specifies the period of time (in seconds) after which unavailable peers will be ignored for garbage collection and resynchronized after being reconnected. The default is 43200 (30 days), if set to `-1`, this feature is disabled.
-- `-Ddhfs.objects.autosync.download-all=` specifies whether all objects (files and their data) should be downloaded to this peer. `true` or `false`, the default is `false`.
-- `-Ddhfs.objects.peerdiscovery.port=` port to broadcast on and listen to for LAN peer discovery (default is `42262`)
-- `-Ddhfs.objects.peerdiscovery.broadcast=` whether to enable local peer discovery or not (default is `true`)
-- `-Dquarkus.http.port=` HTTP port to listen on (default is `8080`)
-- `-Dquarkus.http.ssl-port=` HTTPS port to listen on (default is `8443`)
-- `-Dquarkus.http.host=` IP address to listen on (default is `0.0.0.0`)
-- `-Ddhfs.peerdiscovery.static-peers=` allows to manually specify a peer's address in format of `peer id:http port:https port`, for example `-Ddhfs.peerdiscovery.static-peers=11000000-0000-0000-0000-000000000000:127.0.0.1:9010:9011`
-
-On Windows, the entire space for the filesystem should also be preallocated, the `-Ddhfs.objects.persistence.lmdb.size=` option controls the size (the value is in bytes), on Windows the default is 100 GB.
-
-In case of errors, the standard output is redirected to `quarkus.log` in the `app` folder, on Windows the error output is separate.
-
-### How to connect to other peers?
-
-Then, a web interface will be available at `losthost:8080` (or whatever the HTTP port is), that can be used to connect with other peers. Peers on local network should be available to be connected to automatically.
-
-## Other notes
-
-### Running tests
-
-To run LazyFS tests, LazyFS needs to be built: the git submodules need to be cloned and `./thirdparty/lazyfs/build.sh` script needs to be run. 
-
-LazyFS tests were only tested on Linux.
-
-
-### Notice
-
-This software was developed with the support of the Faculty of Information Technology, Czech Technical University in Prague, [fit.cvut.cz](https://fit.cvut.cz)
-
-<img src="./docs/logo-fit-en-cerna.svg" height="64">
+TODO 😁

dhfs-parent/.gitignore

@@ -41,5 +41,3 @@ nb-configuration.xml
 
 # Plugin directory
 /.quarkus/cli/plugins/
-
-.jqwik-database

dhfs-parent/.run/Main 2.run.xml

@@ -1,11 +1,11 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Main 2" type="QsApplicationConfigurationType" factoryName="QuarkusApplication">
-    <option name="MAIN_CLASS_NAME" value="com.usatiuk.dhfsfuse.Main" />
-    <module name="dhfs-fuse" />
-    <option name="VM_PARAMETERS" value="-XX:+UnlockDiagnosticVMOptions -XX:+UseParallelGC -XX:+DebugNonSafepoints --enable-preview --add-exports java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-exports java.base/jdk.internal.access=ALL-UNNAMED -ea -Xmx512M -Ddhfs.webui.root=$ProjectFileDir$/../webui/dist -Ddhfs.fuse.root=${HOME}/dhfs_test/2/fuse -Ddhfs.objects.persistence.root=${HOME}/dhfs_test/2/data -Ddhfs.objects.peerdiscovery.broadcast=false -Dquarkus.http.port=9020 -Dquarkus.http.ssl-port=9021 -Ddhfs.peerdiscovery.preset-uuid=22000000-0000-0000-0000-000000000000 -Ddhfs.peerdiscovery.static-peers=11000000-0000-0000-0000-000000000000:127.0.0.1:9010:9011" />
+    <option name="MAIN_CLASS_NAME" value="com.usatiuk.dhfs.app.Main" />
+    <module name="dhfs-app" />
+    <option name="VM_PARAMETERS" value="-XX:+UnlockDiagnosticVMOptions -XX:+DebugNonSafepoints --add-exports java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-exports java.base/jdk.internal.access=ALL-UNNAMED -ea -Dcom.usatiuk.dhfs.supportlib.native-path=$ProjectFileDir$/target/classes/native -Xmx2G -Ddhfs.webui.root=$ProjectFileDir$/../webui/dist -Ddhfs.fuse.root=${HOME}/dhfs_test/2/fuse -Ddhfs.objects.persistence.files.root=${HOME}/dhfs_test/2/data -Ddhfs.objects.persistence.stuff.root=${HOME}/dhfs_test/2/data/stuff -Ddhfs.objects.peerdiscovery.broadcast=false -Dquarkus.http.port=9020 -Dquarkus.http.ssl-port=9021 -Ddhfs.peerdiscovery.preset-uuid=22000000-0000-0000-0000-000000000000 -Ddhfs.peerdiscovery.static-peers=11000000-0000-0000-0000-000000000000:127.0.0.1:9010:9011" />
     <extension name="coverage">
       <pattern>
-        <option name="PATTERN" value="com.usatiuk.dhfs.remoteobj.*" />
+        <option name="PATTERN" value="com.usatiuk.dhfs.*" />
         <option name="ENABLED" value="true" />
       </pattern>
     </extension>

dhfs-parent/.run/Main.run.xml

@@ -1,11 +1,11 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Main" type="QsApplicationConfigurationType" factoryName="QuarkusApplication" nameIsGenerated="true">
-    <option name="MAIN_CLASS_NAME" value="com.usatiuk.dhfsfuse.Main" />
-    <module name="dhfs-fuse" />
-    <option name="VM_PARAMETERS" value="-XX:+UnlockDiagnosticVMOptions -XX:+UseZGC -XX:+ZGenerational --enable-preview -XX:+DebugNonSafepoints --add-exports java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-exports java.base/jdk.internal.access=ALL-UNNAMED -ea -Xmx1G -Ddhfs.webui.root=$ProjectFileDir$/../webui/dist -Ddhfs.fuse.root=${HOME}/dhfs_test/1/fuse -Ddhfs.objects.persistence.root=${HOME}/dhfs_test/1/data -Ddhfs.objects.peerdiscovery.broadcast=true -Dquarkus.http.port=9010 -Dquarkus.http.ssl-port=9011 -Ddhfs.peerdiscovery.preset-uuid=11000000-0000-0000-0000-000000000000 -Ddhfs.peerdiscovery.static-peers=22000000-0000-0000-0000-000000000000:127.0.0.1:9020:9021 -Dquarkus.http.host=0.0.0.0" />
+    <option name="MAIN_CLASS_NAME" value="com.usatiuk.dhfs.app.Main" />
+    <module name="dhfs-app" />
+    <option name="VM_PARAMETERS" value="-XX:+UnlockDiagnosticVMOptions -XX:+DebugNonSafepoints --add-exports java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-exports java.base/jdk.internal.access=ALL-UNNAMED -ea -Dcom.usatiuk.dhfs.supportlib.native-path=$ProjectFileDir$/target/classes/native -Xmx2G -Ddhfs.webui.root=$ProjectFileDir$/../webui/dist -Ddhfs.fuse.root=${HOME}/dhfs_test/1/fuse -Ddhfs.objects.persistence.files.root=${HOME}/dhfs_test/1/data -Ddhfs.objects.persistence.stuff.root=${HOME}/dhfs_test/1/data/stuff -Ddhfs.objects.peerdiscovery.broadcast=true -Dquarkus.http.port=9010 -Dquarkus.http.ssl-port=9011 -Ddhfs.peerdiscovery.preset-uuid=11000000-0000-0000-0000-000000000000 -Ddhfs.peerdiscovery.static-peers=22000000-0000-0000-0000-000000000000:127.0.0.1:9020:9021 -Dquarkus.http.host=0.0.0.0" />
     <extension name="coverage">
       <pattern>
-        <option name="PATTERN" value="com.usatiuk.dhfs.remoteobj.*" />
+        <option name="PATTERN" value="com.usatiuk.dhfs.*" />
         <option name="ENABLED" value="true" />
       </pattern>
     </extension>

dhfs-parent/dhfs-app/.dockerignore

@@ -0,0 +1,5 @@
+*
+!target/*-runner
+!target/*-runner.jar
+!target/lib/*
+!target/quarkus-app/*

dhfs-parent/dhfs-app/.gitignore

@@ -0,0 +1,43 @@
+#Maven
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+release.properties
+.flattened-pom.xml
+
+# Eclipse
+.project
+.classpath
+.settings/
+bin/
+
+# IntelliJ
+.idea
+*.ipr
+*.iml
+*.iws
+
+# NetBeans
+nb-configuration.xml
+
+# Visual Studio Code
+.vscode
+.factorypath
+
+# OSX
+.DS_Store
+
+# Vim
+*.swp
+*.swo
+
+# patch
+*.orig
+*.rej
+
+# Local environment
+.env
+
+# Plugin directory
+/.quarkus/cli/plugins/

dhfs-parent/dhfs-app/Dockerfile

@@ -0,0 +1,2 @@
+FROM azul/zulu-openjdk-debian:21-jre-latest
+RUN apt update && apt install -y libfuse2 curl

dhfs-parent/dhfs-app/docker-compose.yml

@@ -0,0 +1,43 @@
+version: "3.2"
+
+services:
+  dhfs1:
+    build: .
+    privileged: true
+    devices:
+      - /dev/fuse
+    volumes:
+      - $HOME/dhfs/dhfs1:/dhfs_root
+      - $HOME/dhfs/dhfs1_f:/dhfs_root/fuse:rshared
+      - ./target/quarkus-app:/app
+    command: "java --add-exports java.base/sun.nio.ch=ALL-UNNAMED
+     -Ddhfs.objects.persistence.files.root=/dhfs_root/p 
+     -Ddhfs.objects.root=/dhfs_root/d 
+     -Ddhfs.fuse.root=/dhfs_root/fuse -Dquarkus.http.host=0.0.0.0 
+     -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005
+     -jar /app/quarkus-run.jar"
+    ports:
+      - 8080:8080
+      - 8081:8443
+      - 5005:5005
+  dhfs2:
+    build: .
+    privileged: true
+    devices:
+      - /dev/fuse
+    volumes:
+      - $HOME/dhfs/dhfs2:/dhfs_root
+      - $HOME/dhfs/dhfs2_f:/dhfs_root/fuse:rshared
+      - ./target/quarkus-app:/app
+    command: "java --add-exports java.base/sun.nio.ch=ALL-UNNAMED
+     --add-exports java.base/jdk.internal.access=ALL-UNNAMED
+     --add-opens=java.base/java.nio=ALL-UNNAMED
+     -Ddhfs.objects.persistence.files.root=/dhfs_root/p 
+     -Ddhfs.objects.root=/dhfs_root/d 
+     -Ddhfs.fuse.root=/dhfs_root/fuse -Dquarkus.http.host=0.0.0.0
+     -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5010
+     -jar /app/quarkus-run.jar"
+    ports:
+      - 8090:8080
+      - 8091:8443
+      - 5010:5010

dhfs-parent/dhfs-app/pom.xml

@@ -0,0 +1,215 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.usatiuk.dhfs</groupId>
+    <artifactId>dhfs-app</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <parent>
+        <groupId>com.usatiuk.dhfs</groupId>
+        <artifactId>parent</artifactId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>testcontainers</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcprov-jdk18on</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcpkix-jdk18on</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-security</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>net.openhft</groupId>
+            <artifactId>zero-allocation-hashing</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-grpc</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-arc</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest-client</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest-client-jsonb</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest-jsonb</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-scheduler</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-junit5</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.github.SerCeMan</groupId>
+            <artifactId>jnr-fuse</artifactId>
+            <version>44ed40f8ce</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.jnr</groupId>
+            <artifactId>jnr-ffi</artifactId>
+            <version>2.2.16</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.jnr</groupId>
+            <artifactId>jnr-posix</artifactId>
+            <version>3.1.19</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.jnr</groupId>
+            <artifactId>jnr-constants</artifactId>
+            <version>0.10.4</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.jboss.slf4j</groupId>
+            <artifactId>slf4j-jboss-logmanager</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.pcollections</groupId>
+            <artifactId>pcollections</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>3.6.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk</groupId>
+            <artifactId>kleppmanntree</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>supportlib</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>objects</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>dhfs-fs</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>dhfs-fuse</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>sync-base</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>utils</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <forkCount>1C</forkCount>
+                    <reuseForks>false</reuseForks>
+                    <parallel>classes</parallel>
+                    <systemPropertyVariables>
+                        <junit.jupiter.execution.parallel.enabled>
+                            false
+                        </junit.jupiter.execution.parallel.enabled>
+                    </systemPropertyVariables>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-failsafe-plugin</artifactId>
+                <configuration>
+                    <systemPropertyVariables>
+                        <junit.jupiter.execution.parallel.enabled>
+                            true
+                        </junit.jupiter.execution.parallel.enabled>
+                        <junit.jupiter.execution.parallel.mode.default>
+                            concurrent
+                        </junit.jupiter.execution.parallel.mode.default>
+                        <junit.jupiter.execution.parallel.config.dynamic.factor>
+                            0.5
+                        </junit.jupiter.execution.parallel.config.dynamic.factor>
+                        <junit.platform.output.capture.stdout>true</junit.platform.output.capture.stdout>
+                        <junit.platform.output.capture.stderr>true</junit.platform.output.capture.stderr>
+                    </systemPropertyVariables>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>${quarkus.platform.group-id}</groupId>
+                <artifactId>quarkus-maven-plugin</artifactId>
+                <version>${quarkus.platform.version}</version>
+                <extensions>true</extensions>
+                <executions>
+                    <execution>
+                        <id>quarkus-plugin</id>
+                        <goals>
+                            <goal>build</goal>
+                            <goal>generate-code</goal>
+                            <goal>generate-code-tests</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

dhfs-parent/dhfs-app/src/main/docker/Dockerfile.jvm

@@ -0,0 +1,97 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in JVM mode
+#
+# Before building the container image run:
+#
+# ./mvnw package
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.jvm -t quarkus/server-jvm .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/server-jvm
+#
+# If you want to include the debug port into your docker image
+# you will have to expose the debug port (default 5005 being the default) like this :  EXPOSE 8080 5005.
+# Additionally you will have to set -e JAVA_DEBUG=true and -e JAVA_DEBUG_PORT=*:5005
+# when running the container
+#
+# Then run the container using :
+#
+# docker run -i --rm -p 8080:8080 quarkus/server-jvm
+#
+# This image uses the `run-java.sh` script to run the application.
+# This scripts computes the command line to execute your Java application, and
+# includes memory/GC tuning.
+# You can configure the behavior using the following environment properties:
+# - JAVA_OPTS: JVM options passed to the `java` command (example: "-verbose:class")
+# - JAVA_OPTS_APPEND: User specified Java options to be appended to generated options
+#   in JAVA_OPTS (example: "-Dsome.property=foo")
+# - JAVA_MAX_MEM_RATIO: Is used when no `-Xmx` option is given in JAVA_OPTS. This is
+#   used to calculate a default maximal heap memory based on a containers restriction.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xmx` is set to a ratio
+#   of the container available memory as set here. The default is `50` which means 50%
+#   of the available memory is used as an upper boundary. You can skip this mechanism by
+#   setting this value to `0` in which case no `-Xmx` option is added.
+# - JAVA_INITIAL_MEM_RATIO: Is used when no `-Xms` option is given in JAVA_OPTS. This
+#   is used to calculate a default initial heap memory based on the maximum heap memory.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xms` is set to a ratio
+#   of the `-Xmx` memory as set here. The default is `25` which means 25% of the `-Xmx`
+#   is used as the initial heap size. You can skip this mechanism by setting this value
+#   to `0` in which case no `-Xms` option is added (example: "25")
+# - JAVA_MAX_INITIAL_MEM: Is used when no `-Xms` option is given in JAVA_OPTS.
+#   This is used to calculate the maximum value of the initial heap memory. If used in
+#   a container without any memory constraints for the container then this option has
+#   no effect. If there is a memory constraint then `-Xms` is limited to the value set
+#   here. The default is 4096MB which means the calculated value of `-Xms` never will
+#   be greater than 4096MB. The value of this variable is expressed in MB (example: "4096")
+# - JAVA_DIAGNOSTICS: Set this to get some diagnostics information to standard output
+#   when things are happening. This option, if set to true, will set
+#  `-XX:+UnlockDiagnosticVMOptions`. Disabled by default (example: "true").
+# - JAVA_DEBUG: If set remote debugging will be switched on. Disabled by default (example:
+#    true").
+# - JAVA_DEBUG_PORT: Port used for remote debugging. Defaults to 5005 (example: "8787").
+# - CONTAINER_CORE_LIMIT: A calculated core limit as described in
+#   https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt. (example: "2")
+# - CONTAINER_MAX_MEMORY: Memory limit given to the container (example: "1024").
+# - GC_MIN_HEAP_FREE_RATIO: Minimum percentage of heap free after GC to avoid expansion.
+#   (example: "20")
+# - GC_MAX_HEAP_FREE_RATIO: Maximum percentage of heap free after GC to avoid shrinking.
+#   (example: "40")
+# - GC_TIME_RATIO: Specifies the ratio of the time spent outside the garbage collection.
+#   (example: "4")
+# - GC_ADAPTIVE_SIZE_POLICY_WEIGHT: The weighting given to the current GC time versus
+#   previous GC times. (example: "90")
+# - GC_METASPACE_SIZE: The initial metaspace size. (example: "20")
+# - GC_MAX_METASPACE_SIZE: The maximum metaspace size. (example: "100")
+# - GC_CONTAINER_OPTIONS: Specify Java GC to use. The value of this variable should
+#   contain the necessary JRE command-line options to specify the required GC, which
+#   will override the default of `-XX:+UseParallelGC` (example: -XX:+UseG1GC).
+# - HTTPS_PROXY: The location of the https proxy. (example: "myuser@127.0.0.1:8080")
+# - HTTP_PROXY: The location of the http proxy. (example: "myuser@127.0.0.1:8080")
+# - NO_PROXY: A comma separated lists of hosts, IP addresses or domains that can be
+#   accessed directly. (example: "foo.example.com,bar.example.com")
+#
+###
+FROM registry.access.redhat.com/ubi8/openjdk-21:1.18
+
+ENV LANGUAGE='en_US:en'
+
+
+# We make four distinct layers so if there are application changes the library layers can be re-used
+COPY --chown=185 target/quarkus-app/lib/ /deployments/lib/
+COPY --chown=185 target/quarkus-app/*.jar /deployments/
+COPY --chown=185 target/quarkus-app/app/ /deployments/app/
+COPY --chown=185 target/quarkus-app/quarkus/ /deployments/quarkus/
+
+EXPOSE 8080
+USER 185
+ENV JAVA_OPTS_APPEND="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
+ENV JAVA_APP_JAR="/deployments/quarkus-run.jar"
+
+ENTRYPOINT [ "/opt/jboss/container/java/run/run-java.sh" ]
+

dhfs-parent/dhfs-app/src/main/docker/Dockerfile.legacy-jar

@@ -0,0 +1,93 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in JVM mode
+#
+# Before building the container image run:
+#
+# ./mvnw package -Dquarkus.package.jar.type=legacy-jar
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.legacy-jar -t quarkus/server-legacy-jar .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/server-legacy-jar
+#
+# If you want to include the debug port into your docker image
+# you will have to expose the debug port (default 5005 being the default) like this :  EXPOSE 8080 5005.
+# Additionally you will have to set -e JAVA_DEBUG=true and -e JAVA_DEBUG_PORT=*:5005
+# when running the container
+#
+# Then run the container using :
+#
+# docker run -i --rm -p 8080:8080 quarkus/server-legacy-jar
+#
+# This image uses the `run-java.sh` script to run the application.
+# This scripts computes the command line to execute your Java application, and
+# includes memory/GC tuning.
+# You can configure the behavior using the following environment properties:
+# - JAVA_OPTS: JVM options passed to the `java` command (example: "-verbose:class")
+# - JAVA_OPTS_APPEND: User specified Java options to be appended to generated options
+#   in JAVA_OPTS (example: "-Dsome.property=foo")
+# - JAVA_MAX_MEM_RATIO: Is used when no `-Xmx` option is given in JAVA_OPTS. This is
+#   used to calculate a default maximal heap memory based on a containers restriction.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xmx` is set to a ratio
+#   of the container available memory as set here. The default is `50` which means 50%
+#   of the available memory is used as an upper boundary. You can skip this mechanism by
+#   setting this value to `0` in which case no `-Xmx` option is added.
+# - JAVA_INITIAL_MEM_RATIO: Is used when no `-Xms` option is given in JAVA_OPTS. This
+#   is used to calculate a default initial heap memory based on the maximum heap memory.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xms` is set to a ratio
+#   of the `-Xmx` memory as set here. The default is `25` which means 25% of the `-Xmx`
+#   is used as the initial heap size. You can skip this mechanism by setting this value
+#   to `0` in which case no `-Xms` option is added (example: "25")
+# - JAVA_MAX_INITIAL_MEM: Is used when no `-Xms` option is given in JAVA_OPTS.
+#   This is used to calculate the maximum value of the initial heap memory. If used in
+#   a container without any memory constraints for the container then this option has
+#   no effect. If there is a memory constraint then `-Xms` is limited to the value set
+#   here. The default is 4096MB which means the calculated value of `-Xms` never will
+#   be greater than 4096MB. The value of this variable is expressed in MB (example: "4096")
+# - JAVA_DIAGNOSTICS: Set this to get some diagnostics information to standard output
+#   when things are happening. This option, if set to true, will set
+#  `-XX:+UnlockDiagnosticVMOptions`. Disabled by default (example: "true").
+# - JAVA_DEBUG: If set remote debugging will be switched on. Disabled by default (example:
+#    true").
+# - JAVA_DEBUG_PORT: Port used for remote debugging. Defaults to 5005 (example: "8787").
+# - CONTAINER_CORE_LIMIT: A calculated core limit as described in
+#   https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt. (example: "2")
+# - CONTAINER_MAX_MEMORY: Memory limit given to the container (example: "1024").
+# - GC_MIN_HEAP_FREE_RATIO: Minimum percentage of heap free after GC to avoid expansion.
+#   (example: "20")
+# - GC_MAX_HEAP_FREE_RATIO: Maximum percentage of heap free after GC to avoid shrinking.
+#   (example: "40")
+# - GC_TIME_RATIO: Specifies the ratio of the time spent outside the garbage collection.
+#   (example: "4")
+# - GC_ADAPTIVE_SIZE_POLICY_WEIGHT: The weighting given to the current GC time versus
+#   previous GC times. (example: "90")
+# - GC_METASPACE_SIZE: The initial metaspace size. (example: "20")
+# - GC_MAX_METASPACE_SIZE: The maximum metaspace size. (example: "100")
+# - GC_CONTAINER_OPTIONS: Specify Java GC to use. The value of this variable should
+#   contain the necessary JRE command-line options to specify the required GC, which
+#   will override the default of `-XX:+UseParallelGC` (example: -XX:+UseG1GC).
+# - HTTPS_PROXY: The location of the https proxy. (example: "myuser@127.0.0.1:8080")
+# - HTTP_PROXY: The location of the http proxy. (example: "myuser@127.0.0.1:8080")
+# - NO_PROXY: A comma separated lists of hosts, IP addresses or domains that can be
+#   accessed directly. (example: "foo.example.com,bar.example.com")
+#
+###
+FROM registry.access.redhat.com/ubi8/openjdk-21:1.18
+
+ENV LANGUAGE='en_US:en'
+
+
+COPY target/lib/* /deployments/lib/
+COPY target/*-runner.jar /deployments/quarkus-run.jar
+
+EXPOSE 8080
+USER 185
+ENV JAVA_OPTS_APPEND="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
+ENV JAVA_APP_JAR="/deployments/quarkus-run.jar"
+
+ENTRYPOINT [ "/opt/jboss/container/java/run/run-java.sh" ]

dhfs-parent/dhfs-app/src/main/docker/Dockerfile.native

@@ -0,0 +1,27 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in native (no JVM) mode.
+#
+# Before building the container image run:
+#
+# ./mvnw package -Dnative
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.native -t quarkus/server .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/server
+#
+###
+FROM registry.access.redhat.com/ubi8/ubi-minimal:8.9
+WORKDIR /work/
+RUN chown 1001 /work \
+    && chmod "g+rwX" /work \
+    && chown 1001:root /work
+COPY --chown=1001:root target/*-runner /work/application
+
+EXPOSE 8080
+USER 1001
+
+ENTRYPOINT ["./application", "-Dquarkus.http.host=0.0.0.0"]

dhfs-parent/dhfs-app/src/main/docker/Dockerfile.native-micro

@@ -0,0 +1,30 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in native (no JVM) mode.
+# It uses a micro base image, tuned for Quarkus native executables.
+# It reduces the size of the resulting container image.
+# Check https://quarkus.io/guides/quarkus-runtime-base-image for further information about this image.
+#
+# Before building the container image run:
+#
+# ./mvnw package -Dnative
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.native-micro -t quarkus/server .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/server
+#
+###
+FROM quay.io/quarkus/quarkus-micro-image:2.0
+WORKDIR /work/
+RUN chown 1001 /work \
+    && chmod "g+rwX" /work \
+    && chown 1001:root /work
+COPY --chown=1001:root target/*-runner /work/application
+
+EXPOSE 8080
+USER 1001
+
+ENTRYPOINT ["./application", "-Dquarkus.http.host=0.0.0.0"]

dhfs-parent/dhfs-app/src/main/java/com/usatiuk/dhfs/app/Main.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfuse;
+package com.usatiuk.dhfs.app;
 
 import io.quarkus.runtime.Quarkus;
 import io.quarkus.runtime.QuarkusApplication;

dhfs-parent/dhfs-app/src/main/resources/application.properties

@@ -0,0 +1,34 @@
+quarkus.grpc.server.use-separate-server=false
+dhfs.objects.peerdiscovery.port=42069
+dhfs.objects.peerdiscovery.interval=4s
+dhfs.objects.peerdiscovery.broadcast=true
+dhfs.objects.sync.timeout=30
+dhfs.objects.sync.ping.timeout=5
+dhfs.objects.invalidation.threads=16
+dhfs.objects.invalidation.delay=1000
+dhfs.objects.reconnect_interval=5s
+dhfs.objects.write_log=false
+dhfs.objects.periodic-push-op-interval=5m
+dhfs.fuse.root=${HOME}/dhfs_default/fuse
+dhfs.objects.persistence.stuff.root=${HOME}/dhfs_default/data/stuff
+dhfs.fuse.debug=false
+dhfs.fuse.enabled=true
+dhfs.files.allow_recursive_delete=false
+dhfs.files.target_chunk_size=2097152
+dhfs.files.target_chunk_alignment=19
+dhfs.objects.deletion.delay=1000
+dhfs.objects.deletion.can-delete-retry-delay=10000
+dhfs.objects.ref_verification=true
+dhfs.files.use_hash_for_chunks=false
+dhfs.objects.autosync.threads=16
+dhfs.objects.autosync.download-all=false
+dhfs.objects.move-processor.threads=16
+dhfs.objects.ref-processor.threads=16
+dhfs.objects.opsender.batch-size=100
+dhfs.objects.lock_timeout_secs=2
+dhfs.local-discovery=true
+dhfs.peerdiscovery.timeout=10000
+quarkus.log.category."com.usatiuk".min-level=INFO
+quarkus.log.category."com.usatiuk".level=INFO
+quarkus.http.insecure-requests=enabled
+quarkus.http.ssl.client-auth=required

dhfs-parent/dhfs-app/src/test/java/com/usatiuk/dhfs/TempDataProfile.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfuse;
+package com.usatiuk.dhfs;
 
 import io.quarkus.test.junit.QuarkusTestProfile;
 
@@ -21,7 +21,7 @@ abstract public class TempDataProfile implements QuarkusTestProfile {
             throw new RuntimeException(e);
         }
         var ret = new HashMap<String, String>();
-        ret.put("dhfs.objects.persistence.root", tempDirWithPrefix.resolve("dhfs_root_test").toString());
+        ret.put("dhfs.objects.persistence.files.root", tempDirWithPrefix.resolve("dhfs_root_test").toString());
         ret.put("dhfs.fuse.root", tempDirWithPrefix.resolve("dhfs_fuse_root_test").toString());
         getConfigOverrides(ret);
         return ret;

dhfs-parent/dhfs-app/src/test/java/com/usatiuk/dhfs/TestDataCleaner.java

@@ -0,0 +1,44 @@
+package com.usatiuk.dhfs;
+
+import io.quarkus.logging.Log;
+import io.quarkus.runtime.ShutdownEvent;
+import io.quarkus.runtime.StartupEvent;
+import jakarta.annotation.Priority;
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.event.Observes;
+import org.eclipse.microprofile.config.inject.ConfigProperty;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Objects;
+
+@ApplicationScoped
+public class TestDataCleaner {
+    @ConfigProperty(name = "dhfs.objects.persistence.files.root")
+    String tempDirectory;
+
+    void init(@Observes @Priority(1) StartupEvent event) throws IOException {
+        try {
+            purgeDirectory(Path.of(tempDirectory).toFile());
+        } catch (Exception ignored) {
+            Log.warn("Couldn't cleanup test data on init");
+        }
+    }
+
+    void shutdown(@Observes @Priority(1000000000) ShutdownEvent event) throws IOException {
+        purgeDirectory(Path.of(tempDirectory).toFile());
+    }
+
+    public static void purgeDirectory(File dir) {
+        try {
+            for (File file : Objects.requireNonNull(dir.listFiles())) {
+                if (file.isDirectory())
+                    purgeDirectory(file);
+                file.delete();
+            }
+        } catch (Exception e) {
+            Log.error("Couldn't purge directory " + dir, e);
+        }
+    }
+}

dhfs-parent/dhfs-app/src/test/java/com/usatiuk/dhfs/integration/DhfsFuseIT.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfuse.integration;
+package com.usatiuk.dhfs.integration;
 
 import com.github.dockerjava.api.model.Device;
 import io.quarkus.logging.Log;
@@ -10,8 +10,10 @@ import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.output.Slf4jLogConsumer;
 import org.testcontainers.containers.output.WaitingConsumer;
+import org.testcontainers.containers.wait.strategy.Wait;
 
 import java.io.IOException;
+import java.time.Duration;
 import java.util.Objects;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
@@ -30,19 +32,17 @@ public class DhfsFuseIT {
     String c1uuid;
     String c2uuid;
 
-    Network network;
-
     @BeforeEach
     void setup(TestInfo testInfo) throws IOException, InterruptedException, TimeoutException {
-        network = Network.newNetwork();
+        Network network = Network.newNetwork();
         container1 = new GenericContainer<>(DhfsImage.getInstance())
                 .withPrivilegedMode(true)
                 .withCreateContainerCmdModifier(cmd -> Objects.requireNonNull(cmd.getHostConfig()).withDevices(Device.parse("/dev/fuse")))
-                .withNetwork(network);
+                .waitingFor(Wait.forLogMessage(".*Listening.*", 1).withStartupTimeout(Duration.ofSeconds(60))).withNetwork(network);
         container2 = new GenericContainer<>(DhfsImage.getInstance())
                 .withPrivilegedMode(true)
                 .withCreateContainerCmdModifier(cmd -> Objects.requireNonNull(cmd.getHostConfig()).withDevices(Device.parse("/dev/fuse")))
-                .withNetwork(network);
+                .waitingFor(Wait.forLogMessage(".*Listening.*", 1).withStartupTimeout(Duration.ofSeconds(60))).withNetwork(network);
 
         Stream.of(container1, container2).parallel().forEach(GenericContainer::start);
 
@@ -53,11 +53,8 @@ public class DhfsFuseIT {
         var loggingConsumer2 = new Slf4jLogConsumer(LoggerFactory.getLogger(DhfsFuseIT.class)).withPrefix("2-" + testInfo.getDisplayName());
         container2.followOutput(loggingConsumer2.andThen(waitingConsumer2));
 
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Listening"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Listening"), 60, TimeUnit.SECONDS);
-
-        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
-        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
+        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
+        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
 
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c1uuid));
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c2uuid));
@@ -68,39 +65,22 @@ public class DhfsFuseIT {
         var c1curl = container1.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c2uuid);
+                        "  --data '{\"uuid\":\"" + c2uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         var c2curl = container2.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c1uuid);
+                        "  --data '{\"uuid\":\"" + c1uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
     }
 
-    private void checkConsistency() {
-        await().atMost(45, TimeUnit.SECONDS).until(() -> {
-            Log.info("Listing consistency");
-            var cat1 = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/*/*");
-            var cat2 = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/*/*");
-            var ls1 = container1.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse/*/*");
-            var ls2 = container2.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse/*/*");
-            Log.info(ls1);
-            Log.info(cat1);
-            Log.info(ls2);
-            Log.info(cat2);
-
-            return ls1.equals(ls2) && cat1.equals(cat2);
-        });
-    }
-
     @AfterEach
     void stop() {
         Stream.of(container1, container2).parallel().forEach(GenericContainer::stop);
-        network.close();
     }
 
     @Test
@@ -129,15 +109,13 @@ public class DhfsFuseIT {
                 "tesempty\n".equals(container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf1").getStdout()));
 
         var client = DockerClientFactory.instance().client();
-        client.disconnectFromNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
-        client.disconnectFromNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
+        client.pauseContainerCmd(container2.getContainerId()).exec();
 
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
 
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "echo newfile > /dhfs_test/fuse/testf2").getExitCode());
 
-        client.connectToNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
-        client.connectToNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
+        client.unpauseContainerCmd(container2.getContainerId()).exec();
 
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
         await().atMost(45, TimeUnit.SECONDS).until(() ->
@@ -155,13 +133,13 @@ public class DhfsFuseIT {
                 "tesempty\n".equals(container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf1").getStdout()));
 
         var client = DockerClientFactory.instance().client();
-        client.disconnectFromNetworkCmd().withNetworkId(network.getId()).withContainerId(container2.getContainerId()).exec();
+        client.pauseContainerCmd(container2.getContainerId()).exec();
 
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
 
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "echo rewritten > /dhfs_test/fuse/testf1").getExitCode());
 
-        client.connectToNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
+        client.unpauseContainerCmd(container2.getContainerId()).exec();
 
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
 
@@ -171,6 +149,35 @@ public class DhfsFuseIT {
                 "rewritten\n".equals(container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf1").getStdout()));
     }
 
+    // TODO: How this fits with the tree?
+    @Test
+    @Disabled
+    void deleteDelayedTest() throws IOException, InterruptedException, TimeoutException {
+        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "echo tesempty > /dhfs_test/fuse/testf1").getExitCode());
+        await().atMost(45, TimeUnit.SECONDS).until(() -> "tesempty\n".equals(container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf1").getStdout()));
+        await().atMost(45, TimeUnit.SECONDS).until(() -> "tesempty\n".equals(container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf1").getStdout()));
+
+        var client = DockerClientFactory.instance().client();
+        client.pauseContainerCmd(container2.getContainerId()).exec();
+
+        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
+
+        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "rm /dhfs_test/fuse/testf1").getExitCode());
+        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Delaying deletion check"), 60, TimeUnit.SECONDS, 1);
+
+        client.unpauseContainerCmd(container2.getContainerId()).exec();
+
+        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
+
+        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse").getExitCode());
+
+        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Deleting from persistent"), 60, TimeUnit.SECONDS, 1);
+        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Deleting from persistent"), 60, TimeUnit.SECONDS, 3);
+
+        await().atMost(45, TimeUnit.SECONDS).until(() -> 1 == container2.execInContainer("/bin/sh", "-c", "test -f /dhfs_test/fuse/testf1").getExitCode());
+        await().atMost(45, TimeUnit.SECONDS).until(() -> 1 == container1.execInContainer("/bin/sh", "-c", "test -f /dhfs_test/fuse/testf1").getExitCode());
+    }
+
     @Test
     void deleteTest() throws IOException, InterruptedException, TimeoutException {
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "echo tesempty > /dhfs_test/fuse/testf1").getExitCode());
@@ -195,44 +202,6 @@ public class DhfsFuseIT {
                 1 == container1.execInContainer("/bin/sh", "-c", "test -f /dhfs_test/fuse/testf1").getExitCode());
     }
 
-    @Test
-    void deleteTestKickedOut() throws IOException, InterruptedException, TimeoutException {
-        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "echo tesempty > /dhfs_test/fuse/testf1").getExitCode());
-        await().atMost(45, TimeUnit.SECONDS).until(() ->
-                "tesempty\n".equals(container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf1").getStdout()));
-        await().atMost(45, TimeUnit.SECONDS).until(() ->
-                "tesempty\n".equals(container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf1").getStdout()));
-
-        var client = DockerClientFactory.instance().client();
-        client.disconnectFromNetworkCmd().withNetworkId(network.getId()).withContainerId(container2.getContainerId()).exec();
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("kicked"), 60, TimeUnit.SECONDS, 1);
-
-        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "echo tesempty2 > /dhfs_test/fuse/testf2").getExitCode());
-        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "echo tesempty3 > /dhfs_test/fuse/testf3").getExitCode());
-
-        Log.info("Deleting");
-        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "rm /dhfs_test/fuse/testf1").getExitCode());
-        Log.info("Deleted");
-
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Deleting from persistent"), 60, TimeUnit.SECONDS, 3);
-
-        client.connectToNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
-
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-
-        await().atMost(45, TimeUnit.SECONDS).until(() ->
-                1 == container1.execInContainer("/bin/sh", "-c", "test -f /dhfs_test/fuse/testf1").getExitCode());
-
-        await().atMost(45, TimeUnit.SECONDS).until(() ->
-                "tesempty2\n".equals(container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf2").getStdout()));
-        await().atMost(45, TimeUnit.SECONDS).until(() ->
-                "tesempty3\n".equals(container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf3").getStdout()));
-        await().atMost(45, TimeUnit.SECONDS).until(() ->
-                "tesempty2\n".equals(container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf2").getStdout()));
-        await().atMost(45, TimeUnit.SECONDS).until(() ->
-                "tesempty3\n".equals(container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf3").getStdout()));
-    }
-
     @Test
     void moveFileTest() throws IOException, InterruptedException, TimeoutException {
         Log.info("Creating");
@@ -276,8 +245,8 @@ public class DhfsFuseIT {
         var c2curl = container2.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request DELETE " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c1uuid);
+                        "  --data '{\"uuid\":\"" + c1uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "echo rewritten > /dhfs_test/fuse/testf1").getExitCode());
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "echo jioadsd > /dhfs_test/fuse/newfile1").getExitCode());
@@ -292,8 +261,8 @@ public class DhfsFuseIT {
         container2.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c1uuid);
+                        "  --data '{\"uuid\":\"" + c1uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
 
@@ -337,33 +306,6 @@ public class DhfsFuseIT {
         });
     }
 
-    @Test
-    void dirConflictTest2() throws IOException, InterruptedException, TimeoutException {
-        var client = DockerClientFactory.instance().client();
-        client.disconnectFromNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
-        client.disconnectFromNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
-
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 1);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 1);
-
-        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "mkdir /dhfs_test/fuse/a && echo fdsaio >> /dhfs_test/fuse/a/testf").getExitCode());
-        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "mkdir /dhfs_test/fuse/a && echo exgrg >> /dhfs_test/fuse/a/testf").getExitCode());
-
-        client.connectToNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
-        client.connectToNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
-
-        Log.warn("Waiting for connections");
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 1);
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 1);
-        Log.warn("Connected");
-
-        checkConsistency();
-
-        var ls1 = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/a*/*");
-        Assertions.assertTrue(ls1.getStdout().contains("fdsaio"));
-        Assertions.assertTrue(ls1.getStdout().contains("exgrg"));
-    }
-
     @Test
     void dirCycleTest() throws IOException, InterruptedException, TimeoutException {
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse").getExitCode());
@@ -378,12 +320,12 @@ public class DhfsFuseIT {
         });
 
         var client = DockerClientFactory.instance().client();
-        client.disconnectFromNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
-        client.disconnectFromNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
+        client.pauseContainerCmd(container1.getContainerId()).exec();
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "mv /dhfs_test/fuse/a /dhfs_test/fuse/b").getExitCode());
+        client.pauseContainerCmd(container2.getContainerId()).exec();
+        client.unpauseContainerCmd(container1.getContainerId()).exec();
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "mv /dhfs_test/fuse/b /dhfs_test/fuse/a").getExitCode());
-        client.connectToNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
-        client.connectToNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
+        client.unpauseContainerCmd(container2.getContainerId()).exec();
 
 
         await().atMost(45, TimeUnit.SECONDS).until(() -> {
@@ -417,14 +359,14 @@ public class DhfsFuseIT {
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse/").getExitCode());
         await().atMost(45, TimeUnit.SECONDS).until(() -> "tesempty\n".equals(container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf1").getStdout()));
 
-        client.disconnectFromNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
-        client.disconnectFromNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
-
+        client.pauseContainerCmd(container1.getContainerId()).exec();
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 1);
 
         Log.info("Removing");
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "rm /dhfs_test/fuse/testf1").getExitCode());
 
+        client.pauseContainerCmd(container2.getContainerId()).exec();
+        client.unpauseContainerCmd(container1.getContainerId()).exec();
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 1);
         Log.info("Moving");
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "mv /dhfs_test/fuse/testf1 /dhfs_test/fuse/testf2").getExitCode());
@@ -432,14 +374,12 @@ public class DhfsFuseIT {
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse/").getExitCode());
         Log.info("Reading");
         await().atMost(45, TimeUnit.SECONDS).until(() -> "tesempty\n".equals(container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf2").getStdout()));
-
-        client.connectToNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
-        client.connectToNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
+        client.unpauseContainerCmd(container2.getContainerId()).exec();
 
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 1);
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 1);
-
         // Either removed, or moved
+        // TODO: it always seems to be removed?
         Log.info("Reading both");
         await().atMost(45, TimeUnit.SECONDS).until(() -> {
             var ls1 = container1.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse/");

dhfs-parent/dhfs-app/src/test/java/com/usatiuk/dhfs/integration/DhfsFusex3IT.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfuse.integration;
+package com.usatiuk.dhfs.integration;
 
 import com.github.dockerjava.api.model.Device;
 import io.quarkus.logging.Log;
@@ -9,8 +9,10 @@ import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.Network;
 import org.testcontainers.containers.output.Slf4jLogConsumer;
 import org.testcontainers.containers.output.WaitingConsumer;
+import org.testcontainers.containers.wait.strategy.Wait;
 
 import java.io.IOException;
+import java.time.Duration;
 import java.util.List;
 import java.util.Objects;
 import java.util.UUID;
@@ -33,53 +35,51 @@ public class DhfsFusex3IT {
     String c2uuid;
     String c3uuid;
 
-    Network network;
+    // This calculation is somewhat racy, so keep it hardcoded for now
+    long emptyFileCount = 9;
 
     @BeforeEach
     void setup(TestInfo testInfo) throws IOException, InterruptedException, TimeoutException {
         // TODO: Dedup
-        network = Network.newNetwork();
+        Network network = Network.newNetwork();
 
         container1 = new GenericContainer<>(DhfsImage.getInstance())
                 .withPrivilegedMode(true)
                 .withCreateContainerCmdModifier(cmd -> Objects.requireNonNull(cmd.getHostConfig()).withDevices(Device.parse("/dev/fuse")))
-                .withNetwork(network);
+                .waitingFor(Wait.forLogMessage(".*Listening.*", 1).withStartupTimeout(Duration.ofSeconds(60))).withNetwork(network);
         container2 = new GenericContainer<>(DhfsImage.getInstance())
                 .withPrivilegedMode(true)
                 .withCreateContainerCmdModifier(cmd -> Objects.requireNonNull(cmd.getHostConfig()).withDevices(Device.parse("/dev/fuse")))
-                .withNetwork(network);
+                .waitingFor(Wait.forLogMessage(".*Listening.*", 1).withStartupTimeout(Duration.ofSeconds(60))).withNetwork(network);
         container3 = new GenericContainer<>(DhfsImage.getInstance())
                 .withPrivilegedMode(true)
                 .withCreateContainerCmdModifier(cmd -> Objects.requireNonNull(cmd.getHostConfig()).withDevices(Device.parse("/dev/fuse")))
-                .withNetwork(network);
+                .waitingFor(Wait.forLogMessage(".*Listening.*", 1).withStartupTimeout(Duration.ofSeconds(60))).withNetwork(network);
+
 
         Stream.of(container1, container2, container3).parallel().forEach(GenericContainer::start);
 
+        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
+        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
+        c3uuid = container3.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
+
+        Log.info(container1.getContainerId() + "=" + c1uuid);
+        Log.info(container2.getContainerId() + "=" + c2uuid);
+        Log.info(container3.getContainerId() + "=" + c3uuid);
+
         waitingConsumer1 = new WaitingConsumer();
         var loggingConsumer1 = new Slf4jLogConsumer(LoggerFactory.getLogger(DhfsFusex3IT.class))
-                .withPrefix(1 + "-" + testInfo.getDisplayName());
+                .withPrefix(c1uuid.substring(0, 4) + "-" + testInfo.getDisplayName());
         container1.followOutput(loggingConsumer1.andThen(waitingConsumer1));
         waitingConsumer2 = new WaitingConsumer();
         var loggingConsumer2 = new Slf4jLogConsumer(LoggerFactory.getLogger(DhfsFusex3IT.class))
-                .withPrefix(2 + "-" + testInfo.getDisplayName());
+                .withPrefix(c2uuid.substring(0, 4) + "-" + testInfo.getDisplayName());
         container2.followOutput(loggingConsumer2.andThen(waitingConsumer2));
         waitingConsumer3 = new WaitingConsumer();
         var loggingConsumer3 = new Slf4jLogConsumer(LoggerFactory.getLogger(DhfsFusex3IT.class))
-                .withPrefix(3 + "-" + testInfo.getDisplayName());
+                .withPrefix(c3uuid.substring(0, 4) + "-" + testInfo.getDisplayName());
         container3.followOutput(loggingConsumer3.andThen(waitingConsumer3));
 
-        waitingConsumer3.waitUntil(frame -> frame.getUtf8String().contains("Listening"), 60, TimeUnit.SECONDS);
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Listening"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Listening"), 60, TimeUnit.SECONDS);
-
-        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
-        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
-        c3uuid = container3.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
-
-        Log.info(container1.getContainerId() + "=" + c1uuid + " = 1");
-        Log.info(container2.getContainerId() + "=" + c2uuid + " = 2");
-        Log.info(container3.getContainerId() + "=" + c3uuid + " = 3");
-
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c1uuid));
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c2uuid));
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c3uuid));
@@ -91,36 +91,46 @@ public class DhfsFusex3IT {
         var c1curl = container1.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c2uuid);
+                        "  --data '{\"uuid\":\"" + c2uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         var c2curl1 = container2.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c1uuid);
+                        "  --data '{\"uuid\":\"" + c1uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         var c2curl3 = container2.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c3uuid);
+                        "  --data '{\"uuid\":\"" + c3uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         var c3curl = container3.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c2uuid);
+                        "  --data '{\"uuid\":\"" + c2uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         waitingConsumer3.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 2);
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 2);
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 2);
     }
 
+    private boolean checkEmpty() throws IOException, InterruptedException {
+        for (var container : List.of(container1, container2, container3)) {
+            var found = container.execInContainer("/bin/sh", "-c", "find /dhfs_test/data/objs -type f");
+            var foundWc = container.execInContainer("/bin/sh", "-c", "find /dhfs_test/data/objs -type f | wc -l");
+            Log.info("Remaining objects in " + container.getContainerId() + ": " + found.toString() + " " + foundWc.toString());
+            if (!(found.getExitCode() == 0 && foundWc.getExitCode() == 0 && Integer.parseInt(foundWc.getStdout().strip()) == emptyFileCount))
+                return false;
+        }
+        return true;
+    }
+
     @AfterEach
     void stop() {
         Stream.of(container1, container2, container3).parallel().forEach(GenericContainer::stop);
-        network.close();
     }
 
     @Test
@@ -130,6 +140,25 @@ public class DhfsFusex3IT {
         await().atMost(45, TimeUnit.SECONDS).until(() -> "tesempty\n".equals(container3.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf1").getStdout()));
     }
 
+    // FIXME:
+    @Test
+    @Disabled
+    void largerFileDeleteTest() throws IOException, InterruptedException, TimeoutException {
+        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "cd /dhfs_test/fuse && dd if=/dev/urandom of=10MB.bin bs=1M count=10").getExitCode());
+        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "head -c 10 /dhfs_test/fuse/10MB.bin").getExitCode());
+        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container3.execInContainer("/bin/sh", "-c", "rm /dhfs_test/fuse/10MB.bin").getExitCode());
+        await().atMost(45, TimeUnit.SECONDS).until(() -> checkEmpty());
+    }
+
+    @Test
+    @Disabled
+    void largerFileDeleteTestNoDelays() throws IOException, InterruptedException, TimeoutException {
+        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "cd /dhfs_test/fuse && dd if=/dev/urandom of=10MB.bin bs=1M count=10").getExitCode());
+        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "head -c 10 /dhfs_test/fuse/10MB.bin").getExitCode());
+        await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container3.execInContainer("/bin/sh", "-c", "rm /dhfs_test/fuse/10MB.bin").getExitCode());
+        await().atMost(45, TimeUnit.SECONDS).until(() -> checkEmpty());
+    }
+
     @Test
     void gccHelloWorldTest() throws IOException, InterruptedException, TimeoutException {
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "echo '#include<stdio.h>\nint main(){printf(\"hello world\"); return 0;}' > /dhfs_test/fuse/hello.c").getExitCode());
@@ -161,8 +190,8 @@ public class DhfsFusex3IT {
         var c3curl = container3.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request DELETE " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c2uuid);
+                        "  --data '{\"uuid\":\"" + c2uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         Thread.sleep(10000);
 
@@ -175,22 +204,21 @@ public class DhfsFusex3IT {
     @Test
     void dirConflictTest() throws IOException, InterruptedException, TimeoutException {
         var client = DockerClientFactory.instance().client();
-
-        client.disconnectFromNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
-        client.disconnectFromNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
-        client.disconnectFromNetworkCmd().withContainerId(container3.getContainerId()).withNetworkId(network.getId()).exec();
-
+        client.pauseContainerCmd(container1.getContainerId()).exec();
+        client.pauseContainerCmd(container2.getContainerId()).exec();
+        // Pauses needed as otherwise docker buffers some incoming packets
         waitingConsumer3.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 2);
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container3.execInContainer("/bin/sh", "-c", "echo test3 >> /dhfs_test/fuse/testf").getExitCode());
+        client.pauseContainerCmd(container3.getContainerId()).exec();
+        client.unpauseContainerCmd(container2.getContainerId()).exec();
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 2);
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "echo test2 >> /dhfs_test/fuse/testf").getExitCode());
+        client.pauseContainerCmd(container2.getContainerId()).exec();
+        client.unpauseContainerCmd(container1.getContainerId()).exec();
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 2);
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "echo test1 >> /dhfs_test/fuse/testf").getExitCode());
-
-        client.connectToNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
-        client.connectToNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
-        client.connectToNetworkCmd().withContainerId(container3.getContainerId()).withNetworkId(network.getId()).exec();
-
+        client.unpauseContainerCmd(container2.getContainerId()).exec();
+        client.unpauseContainerCmd(container3.getContainerId()).exec();
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 2);
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 2);
         waitingConsumer3.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 2);
@@ -224,22 +252,21 @@ public class DhfsFusex3IT {
         await().atMost(45, TimeUnit.SECONDS).until(() -> "tesempty\n".equals(container3.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/testf").getStdout()));
 
         var client = DockerClientFactory.instance().client();
-        client.disconnectFromNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
-        client.disconnectFromNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
-        client.disconnectFromNetworkCmd().withContainerId(container3.getContainerId()).withNetworkId(network.getId()).exec();
-
+        client.pauseContainerCmd(container1.getContainerId()).exec();
+        client.pauseContainerCmd(container2.getContainerId()).exec();
+        // Pauses needed as otherwise docker buffers some incoming packets
         waitingConsumer3.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 2);
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 2);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 2);
-
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container3.execInContainer("/bin/sh", "-c", "echo test3 >> /dhfs_test/fuse/testf").getExitCode());
+        client.pauseContainerCmd(container3.getContainerId()).exec();
+        client.unpauseContainerCmd(container2.getContainerId()).exec();
+        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 2);
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container2.execInContainer("/bin/sh", "-c", "echo test2 >> /dhfs_test/fuse/testf").getExitCode());
+        client.pauseContainerCmd(container2.getContainerId()).exec();
+        client.unpauseContainerCmd(container1.getContainerId()).exec();
+        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS, 2);
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "echo test1 >> /dhfs_test/fuse/testf").getExitCode());
-
-        client.connectToNetworkCmd().withContainerId(container1.getContainerId()).withNetworkId(network.getId()).exec();
-        client.connectToNetworkCmd().withContainerId(container2.getContainerId()).withNetworkId(network.getId()).exec();
-        client.connectToNetworkCmd().withContainerId(container3.getContainerId()).withNetworkId(network.getId()).exec();
-
+        client.unpauseContainerCmd(container2.getContainerId()).exec();
+        client.unpauseContainerCmd(container3.getContainerId()).exec();
         Log.warn("Waiting for connections");
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 2);
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS, 2);

dhfs-parent/dhfs-app/src/test/java/com/usatiuk/dhfs/integration/DhfsImage.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfuse.integration;
+package com.usatiuk.dhfs.integration;
 
 import io.quarkus.logging.Log;
 import org.jetbrains.annotations.NotNull;
@@ -66,28 +66,25 @@ public class DhfsImage implements Future<String> {
                                 .run("apt update && apt install -y libfuse2 curl gcc")
                                 .copy("/app", "/app")
                                 .copy("/libs", "/libs")
-                                .cmd("java", "-ea", "-Xmx512M", "-XX:+UseParallelGC",
+                                .cmd("java", "-ea", "-Xmx128M",
                                         "--add-exports", "java.base/sun.nio.ch=ALL-UNNAMED",
                                         "--add-exports", "java.base/jdk.internal.access=ALL-UNNAMED",
                                         "--add-opens=java.base/java.nio=ALL-UNNAMED",
-                                        "--enable-preview",
                                         "-Ddhfs.objects.peerdiscovery.interval=1s",
                                         "-Ddhfs.objects.invalidation.delay=100",
                                         "-Ddhfs.objects.deletion.delay=0",
                                         "-Ddhfs.objects.deletion.can-delete-retry-delay=1000",
                                         "-Ddhfs.objects.ref_verification=true",
-                                        "-Ddhfs.objects.sync.timeout=30",
+                                        "-Ddhfs.objects.write_log=true",
+                                        "-Ddhfs.objects.sync.timeout=10",
                                         "-Ddhfs.objects.sync.ping.timeout=5",
                                         "-Ddhfs.objects.reconnect_interval=1s",
-                                        "-Ddhfs.objects.last-seen.timeout=30",
-                                        "-Ddhfs.objects.last-seen.update=10",
-                                        "-Ddhfs.sync.cert-check=false",
+                                        "-Dcom.usatiuk.dhfs.supportlib.native-path=/libs",
                                         "-Dquarkus.log.category.\"com.usatiuk\".level=TRACE",
                                         "-Dquarkus.log.category.\"com.usatiuk.dhfs\".level=TRACE",
-                                        "-Dquarkus.log.category.\"com.usatiuk.objects.transaction\".level=INFO",
                                         "-Ddhfs.objects.periodic-push-op-interval=5s",
                                         "-Ddhfs.fuse.root=/dhfs_test/fuse",
-                                        "-Ddhfs.objects.persistence.root=/dhfs_test/data",
+                                        "-Ddhfs.objects.persistence.files.root=/dhfs_test/data",
                                         "-Ddhfs.objects.persistence.stuff.root=/dhfs_test/data/stuff",
                                         "-jar", "/app/quarkus-run.jar")
                                 .run("mkdir /dhfs_test && chmod 777 /dhfs_test")

dhfs-parent/dhfs-app/src/test/java/com/usatiuk/dhfs/integration/KillIT.java

@@ -1,7 +1,7 @@
-package com.usatiuk.dhfsfuse.integration;
+package com.usatiuk.dhfs.integration;
 
 import com.github.dockerjava.api.model.Device;
-import com.usatiuk.dhfsfuse.TestDataCleaner;
+import com.usatiuk.dhfs.TestDataCleaner;
 import io.quarkus.logging.Log;
 import org.junit.jupiter.api.*;
 import org.slf4j.LoggerFactory;
@@ -18,7 +18,10 @@ import java.nio.file.Files;
 import java.time.Duration;
 import java.util.Objects;
 import java.util.UUID;
-import java.util.concurrent.*;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.stream.Stream;
 
 import static org.awaitility.Awaitility.await;
@@ -36,28 +39,22 @@ public class KillIT {
     File data1;
     File data2;
 
-    Network network;
-
-    ExecutorService executor;
-
     @BeforeEach
     void setup(TestInfo testInfo) throws IOException, InterruptedException, TimeoutException {
-        executor = Executors.newCachedThreadPool();
-
         data1 = Files.createTempDirectory("").toFile();
         data2 = Files.createTempDirectory("").toFile();
 
-        network = Network.newNetwork();
+        Network network = Network.newNetwork();
 
         container1 = new GenericContainer<>(DhfsImage.getInstance())
                 .withPrivilegedMode(true)
                 .withCreateContainerCmdModifier(cmd -> Objects.requireNonNull(cmd.getHostConfig()).withDevices(Device.parse("/dev/fuse")))
-                .withNetwork(network)
+                .waitingFor(Wait.forLogMessage(".*Listening.*", 1).withStartupTimeout(Duration.ofSeconds(60))).withNetwork(network)
                 .withFileSystemBind(data1.getAbsolutePath(), "/dhfs_test/data");
         container2 = new GenericContainer<>(DhfsImage.getInstance())
                 .withPrivilegedMode(true)
                 .withCreateContainerCmdModifier(cmd -> Objects.requireNonNull(cmd.getHostConfig()).withDevices(Device.parse("/dev/fuse")))
-                .withNetwork(network)
+                .waitingFor(Wait.forLogMessage(".*Listening.*", 1).withStartupTimeout(Duration.ofSeconds(60))).withNetwork(network)
                 .withFileSystemBind(data2.getAbsolutePath(), "/dhfs_test/data");
 
         Stream.of(container1, container2).parallel().forEach(GenericContainer::start);
@@ -69,11 +66,8 @@ public class KillIT {
         var loggingConsumer2 = new Slf4jLogConsumer(LoggerFactory.getLogger(KillIT.class)).withPrefix("2-" + testInfo.getDisplayName());
         container2.followOutput(loggingConsumer2.andThen(waitingConsumer2));
 
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Listening"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Listening"), 60, TimeUnit.SECONDS);
-
-        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
-        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
+        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
+        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
 
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c1uuid));
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c2uuid));
@@ -84,14 +78,14 @@ public class KillIT {
         var c1curl = container1.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c2uuid);
+                        "  --data '{\"uuid\":\"" + c2uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         var c2curl = container2.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c1uuid);
+                        "  --data '{\"uuid\":\"" + c1uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
@@ -102,28 +96,11 @@ public class KillIT {
         Stream.of(container1, container2).parallel().forEach(GenericContainer::stop);
         TestDataCleaner.purgeDirectory(data1);
         TestDataCleaner.purgeDirectory(data2);
-        executor.close();
-        network.close();
-    }
-
-    private void checkConsistency() {
-        await().atMost(45, TimeUnit.SECONDS).until(() -> {
-            Log.info("Listing consistency");
-            var ls1 = container1.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse");
-            var cat1 = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/*");
-            var ls2 = container2.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse");
-            var cat2 = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/*");
-            Log.info(ls1);
-            Log.info(cat1);
-            Log.info(ls2);
-            Log.info(cat2);
-
-            return ls1.equals(ls2) && cat1.equals(cat2) && ls1.getExitCode() == 0 && ls2.getExitCode() == 0 && cat1.getExitCode() == 0 && cat2.getExitCode() == 0;
-        });
     }
 
     @Test
     void killTest(TestInfo testInfo) throws Exception {
+        var executor = Executors.newFixedThreadPool(2);
         var barrier = new CyclicBarrier(2);
         var ret1 = executor.submit(() -> {
             try {
@@ -147,11 +124,24 @@ public class KillIT {
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
 
-        checkConsistency();
+        await().atMost(45, TimeUnit.SECONDS).until(() -> {
+            Log.info("Listing consistency");
+            var ls1 = container1.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse");
+            var cat1 = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/*");
+            var ls2 = container2.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse");
+            var cat2 = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/*");
+            Log.info(ls1);
+            Log.info(cat1);
+            Log.info(ls2);
+            Log.info(cat2);
+
+            return ls1.equals(ls2) && cat1.equals(cat2);
+        });
     }
 
     @Test
     void killTestDirs(TestInfo testInfo) throws Exception {
+        var executor = Executors.newFixedThreadPool(2);
         var barrier = new CyclicBarrier(2);
         var ret1 = executor.submit(() -> {
             try {
@@ -175,64 +165,18 @@ public class KillIT {
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
 
-        checkConsistency();
-    }
+        await().atMost(45, TimeUnit.SECONDS).until(() -> {
+            Log.info("Listing consistency");
+            var ls1 = container1.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse");
+            var cat1 = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/*");
+            var ls2 = container2.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse");
+            var cat2 = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/*");
+            Log.info(ls1);
+            Log.info(cat1);
+            Log.info(ls2);
+            Log.info(cat2);
 
-    @Test
-    void killTest2(TestInfo testInfo) throws Exception {
-        var barrier = new CyclicBarrier(2);
-        var ret1 = executor.submit(() -> {
-            try {
-                Log.info("Writing to container 1");
-                barrier.await();
-                container1.execInContainer("/bin/sh", "-c", "counter=0; while  [ ! -f /tmp/stopprinting ]; do counter=`expr $counter + 1`; echo $counter >> /dhfs_test/fuse/test1; done");
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
+            return ls1.equals(ls2) && cat1.equals(cat2);
         });
-        barrier.await();
-        Thread.sleep(10000);
-        var client = DockerClientFactory.instance().client();
-        client.killContainerCmd(container2.getContainerId()).exec();
-        container2.stop();
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
-        container1.execInContainer("/bin/sh", "-c", "touch /tmp/stopprinting");
-        container2.start();
-        waitingConsumer2 = new WaitingConsumer();
-        var loggingConsumer2 = new Slf4jLogConsumer(LoggerFactory.getLogger(KillIT.class)).withPrefix("2-" + testInfo.getDisplayName());
-        container2.followOutput(loggingConsumer2.andThen(waitingConsumer2));
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-
-        checkConsistency();
-    }
-
-    @Test
-    void killTestDirs2(TestInfo testInfo) throws Exception {
-        var barrier = new CyclicBarrier(2);
-        var ret1 = executor.submit(() -> {
-            try {
-                Log.info("Writing to container 1");
-                barrier.await();
-                container1.execInContainer("/bin/sh", "-c", "counter=0; while [ ! -f /tmp/stopprinting ]; do counter=`expr $counter + 1`; echo $counter >> /dhfs_test/fuse/test$counter; done");
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-        });
-        barrier.await();
-        Thread.sleep(10000);
-        var client = DockerClientFactory.instance().client();
-        client.killContainerCmd(container2.getContainerId()).exec();
-        container2.stop();
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
-        container1.execInContainer("/bin/sh", "-c", "touch /tmp/stopprinting");
-        container2.start();
-        waitingConsumer2 = new WaitingConsumer();
-        var loggingConsumer2 = new Slf4jLogConsumer(LoggerFactory.getLogger(KillIT.class)).withPrefix("2-" + testInfo.getDisplayName());
-        container2.followOutput(loggingConsumer2.andThen(waitingConsumer2));
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-
-        checkConsistency();
     }
 }

dhfs-parent/dhfs-app/src/test/java/com/usatiuk/dhfs/integration/ResyncIT.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfuse.integration;
+package com.usatiuk.dhfs.integration;
 
 import com.github.dockerjava.api.model.Device;
 import org.junit.jupiter.api.*;
@@ -29,20 +29,18 @@ public class ResyncIT {
     String c1uuid;
     String c2uuid;
 
-    Network network;
-
     @BeforeEach
     void setup(TestInfo testInfo) throws IOException, InterruptedException, TimeoutException {
-        network = Network.newNetwork();
+        Network network = Network.newNetwork();
 
         container1 = new GenericContainer<>(DhfsImage.getInstance())
                 .withPrivilegedMode(true)
                 .withCreateContainerCmdModifier(cmd -> Objects.requireNonNull(cmd.getHostConfig()).withDevices(Device.parse("/dev/fuse")))
-                .withNetwork(network);
+                .waitingFor(Wait.forLogMessage(".*Listening.*", 1).withStartupTimeout(Duration.ofSeconds(60))).withNetwork(network);
         container2 = new GenericContainer<>(DhfsImage.getInstance())
                 .withPrivilegedMode(true)
                 .withCreateContainerCmdModifier(cmd -> Objects.requireNonNull(cmd.getHostConfig()).withDevices(Device.parse("/dev/fuse")))
-                .withNetwork(network);
+                .waitingFor(Wait.forLogMessage(".*Listening.*", 1).withStartupTimeout(Duration.ofSeconds(60))).withNetwork(network);
 
         Stream.of(container1, container2).parallel().forEach(GenericContainer::start);
 
@@ -52,22 +50,18 @@ public class ResyncIT {
         waitingConsumer2 = new WaitingConsumer();
         var loggingConsumer2 = new Slf4jLogConsumer(LoggerFactory.getLogger(DhfsFuseIT.class)).withPrefix("2-" + testInfo.getDisplayName());
         container2.followOutput(loggingConsumer2.andThen(waitingConsumer2));
-
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Listening"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Listening"), 60, TimeUnit.SECONDS);
     }
 
     @AfterEach
     void stop() {
         Stream.of(container1, container2).parallel().forEach(GenericContainer::stop);
-        network.close();
     }
 
     @Test
     void readWriteFileTest() throws IOException, InterruptedException, TimeoutException {
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "echo tesempty > /dhfs_test/fuse/testf1").getExitCode());
-        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
-        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
+        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
+        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
 
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c1uuid));
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c2uuid));
@@ -78,14 +72,14 @@ public class ResyncIT {
         var c1curl = container1.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c2uuid);
+                        "  --data '{\"uuid\":\"" + c2uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         var c2curl = container2.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c1uuid);
+                        "  --data '{\"uuid\":\"" + c1uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
@@ -106,8 +100,8 @@ public class ResyncIT {
         foundWc = container2.execInContainer("/bin/sh", "-c", "find /dhfs_test/fuse -type f | wc -l");
         Assertions.assertEquals(200, Integer.valueOf(foundWc.getStdout().strip()));
 
-        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
-        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
+        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
+        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
 
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c1uuid));
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c2uuid));
@@ -118,14 +112,14 @@ public class ResyncIT {
         var c1curl = container1.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c2uuid);
+                        "  --data '{\"uuid\":\"" + c2uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         var c2curl = container2.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c1uuid);
+                        "  --data '{\"uuid\":\"" + c1uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
@@ -146,8 +140,8 @@ public class ResyncIT {
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "mv /dhfs_test/fuse/testd1 /dhfs_test/fuse/testd2").getExitCode());
         await().atMost(45, TimeUnit.SECONDS).until(() -> 0 == container1.execInContainer("/bin/sh", "-c", "echo tesempty2 > /dhfs_test/fuse/testd2/testf2").getExitCode());
 
-        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
-        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
+        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
+        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/stuff/self_uuid").getStdout();
 
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c1uuid));
         Assertions.assertDoesNotThrow(() -> UUID.fromString(c2uuid));
@@ -158,14 +152,14 @@ public class ResyncIT {
         var c1curl = container1.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c2uuid);
+                        "  --data '{\"uuid\":\"" + c2uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         var c2curl = container2.execInContainer("/bin/sh", "-c",
                 "curl --header \"Content-Type: application/json\" " +
                         "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c1uuid);
+                        "  --data '{\"uuid\":\"" + c1uuid + "\"}' " +
+                        "  http://localhost:8080/peers-manage/known-peers");
 
         waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
         waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);

dhfs-parent/dhfs-app/src/test/resources/application.properties

@@ -0,0 +1,12 @@
+dhfs.objects.persistence.files.root=${HOME}/dhfs_data/dhfs_root_test
+dhfs.objects.root=${HOME}/dhfs_data/dhfs_root_d_test
+dhfs.fuse.root=${HOME}/dhfs_data/dhfs_fuse_root_test
+dhfs.objects.ref_verification=true
+dhfs.objects.deletion.delay=0
+quarkus.log.category."com.usatiuk.dhfs".level=TRACE
+quarkus.log.category."com.usatiuk.dhfs".min-level=TRACE
+quarkus.class-loading.parent-first-artifacts=com.usatiuk.dhfs:supportlib
+quarkus.http.test-port=0
+quarkus.http.test-ssl-port=0
+dhfs.local-discovery=false
+dhfs.objects.persistence.snapshot-extra-checks=true

dhfs-parent/dhfs-fs/docker-compose.yml

@@ -0,0 +1,43 @@
+version: "3.2"
+
+services:
+  dhfs1:
+    build: .
+    privileged: true
+    devices:
+      - /dev/fuse
+    volumes:
+      - $HOME/dhfs/dhfs1:/dhfs_root
+      - $HOME/dhfs/dhfs1_f:/dhfs_root/fuse:rshared
+      - ./target/quarkus-app:/app
+    command: "java --add-exports java.base/sun.nio.ch=ALL-UNNAMED
+     -Ddhfs.objects.persistence.files.root=/dhfs_root/p 
+     -Ddhfs.objects.root=/dhfs_root/d 
+     -Ddhfs.fuse.root=/dhfs_root/fuse -Dquarkus.http.host=0.0.0.0 
+     -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005
+     -jar /app/quarkus-run.jar"
+    ports:
+      - 8080:8080
+      - 8081:8443
+      - 5005:5005
+  dhfs2:
+    build: .
+    privileged: true
+    devices:
+      - /dev/fuse
+    volumes:
+      - $HOME/dhfs/dhfs2:/dhfs_root
+      - $HOME/dhfs/dhfs2_f:/dhfs_root/fuse:rshared
+      - ./target/quarkus-app:/app
+    command: "java --add-exports java.base/sun.nio.ch=ALL-UNNAMED
+     --add-exports java.base/jdk.internal.access=ALL-UNNAMED
+     --add-opens=java.base/java.nio=ALL-UNNAMED
+     -Ddhfs.objects.persistence.files.root=/dhfs_root/p 
+     -Ddhfs.objects.root=/dhfs_root/d 
+     -Ddhfs.fuse.root=/dhfs_root/fuse -Dquarkus.http.host=0.0.0.0
+     -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5010
+     -jar /app/quarkus-run.jar"
+    ports:
+      - 8090:8080
+      - 8091:8443
+      - 5010:5010

dhfs-parent/dhfs-fs/pom.xml

@@ -23,10 +23,22 @@
             <artifactId>awaitility</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcprov-jdk18on</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcpkix-jdk18on</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-security</artifactId>
         </dependency>
+        <dependency>
+            <groupId>net.openhft</groupId>
+            <artifactId>zero-allocation-hashing</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-grpc</artifactId>
@@ -35,6 +47,22 @@
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-arc</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest-client</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest-client-jsonb</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest-jsonb</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-scheduler</artifactId>
@@ -44,6 +72,26 @@
             <artifactId>quarkus-junit5</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.github.SerCeMan</groupId>
+            <artifactId>jnr-fuse</artifactId>
+            <version>44ed40f8ce</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.jnr</groupId>
+            <artifactId>jnr-ffi</artifactId>
+            <version>2.2.16</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.jnr</groupId>
+            <artifactId>jnr-posix</artifactId>
+            <version>3.1.19</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.jnr</groupId>
+            <artifactId>jnr-constants</artifactId>
+            <version>0.10.4</version>
+        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
@@ -57,6 +105,10 @@
             <artifactId>slf4j-jboss-logmanager</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-collections4</artifactId>
@@ -65,11 +117,36 @@
             <groupId>org.pcollections</groupId>
             <artifactId>pcollections</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>3.6.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk</groupId>
+            <artifactId>kleppmanntree</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>supportlib</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>objects</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
         <dependency>
             <groupId>com.usatiuk.dhfs</groupId>
             <artifactId>sync-base</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>utils</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
     </dependencies>
 
     <build>

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/objects/ChunkData.java

@@ -0,0 +1,13 @@
+package com.usatiuk.dhfs.files.objects;
+
+import com.google.protobuf.ByteString;
+import com.usatiuk.dhfs.JDataRemote;
+import com.usatiuk.objects.JObjectKey;
+import com.usatiuk.dhfs.repository.JDataRemoteDto;
+
+public record ChunkData(JObjectKey key, ByteString data) implements JDataRemote, JDataRemoteDto {
+    @Override
+    public int estimateSize() {
+        return data.size();
+    }
+}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/objects/ChunkDataProtoSerializer.java

@@ -0,0 +1,26 @@
+package com.usatiuk.dhfs.files.objects;
+
+import com.usatiuk.dhfs.ProtoSerializer;
+import com.usatiuk.objects.JObjectKey;
+import com.usatiuk.dhfs.persistence.ChunkDataP;
+import com.usatiuk.dhfs.persistence.JObjectKeyP;
+import jakarta.inject.Singleton;
+
+@Singleton
+public class ChunkDataProtoSerializer implements ProtoSerializer<ChunkDataP, ChunkData> {
+    @Override
+    public ChunkData deserialize(ChunkDataP message) {
+        return new ChunkData(
+                JObjectKey.of(message.getKey().getName()),
+                message.getData()
+        );
+    }
+
+    @Override
+    public ChunkDataP serialize(ChunkData object) {
+        return ChunkDataP.newBuilder()
+                .setKey(JObjectKeyP.newBuilder().setName(object.key().value()).build())
+                .setData(object.data())
+                .build();
+    }
+}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/objects/File.java

@@ -1,23 +1,14 @@
-package com.usatiuk.dhfsfs.objects;
+package com.usatiuk.dhfs.files.objects;
 
+import com.usatiuk.dhfs.JDataRemote;
+import com.usatiuk.objects.JObjectKey;
 import com.usatiuk.dhfs.jmap.JMapHolder;
 import com.usatiuk.dhfs.jmap.JMapLongKey;
-import com.usatiuk.dhfs.remoteobj.JDataRemote;
-import com.usatiuk.dhfs.remoteobj.JDataRemoteDto;
-import com.usatiuk.objects.JObjectKey;
+import com.usatiuk.dhfs.repository.JDataRemoteDto;
 
 import java.util.Collection;
 import java.util.Set;
 
-/**
- * File is a data structure that represents a file in the file system
- *
- * @param key     unique key
- * @param mode    file mode
- * @param cTime   inode modification time
- * @param mTime   modification time
- * @param symlink true if the file is a symlink, false otherwise
- */
 public record File(JObjectKey key, long mode, long cTime, long mTime,
                    boolean symlink
 ) implements JDataRemote, JMapHolder<JMapLongKey> {
@@ -37,14 +28,6 @@ public record File(JObjectKey key, long mode, long cTime, long mTime,
         return new File(key, mode, cTime, mTime, symlink);
     }
 
-    public File withCurrentMTime() {
-        return new File(key, mode, cTime, System.currentTimeMillis(), symlink);
-    }
-
-    public File withCurrentCTime() {
-        return new File(key, mode, System.currentTimeMillis(), mTime, symlink);
-    }
-
     @Override
     public Collection<JObjectKey> collectRefsTo() {
         return Set.of();

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/objects/FileDto.java

@@ -0,0 +1,15 @@
+package com.usatiuk.dhfs.files.objects;
+
+import com.usatiuk.dhfs.JDataRemote;
+import com.usatiuk.objects.JObjectKey;
+import com.usatiuk.dhfs.repository.JDataRemoteDto;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.List;
+
+public record FileDto(File file, List<Pair<Long, JObjectKey>> chunks) implements JDataRemoteDto {
+    @Override
+    public Class<? extends JDataRemote> objClass() {
+        return File.class;
+    }
+}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/objects/FileDtoMapper.java

@@ -1,13 +1,10 @@
-package com.usatiuk.dhfsfs.objects;
+package com.usatiuk.dhfs.files.objects;
 
 import com.usatiuk.dhfs.jmap.JMapHelper;
-import com.usatiuk.dhfs.syncmap.DtoMapper;
+import com.usatiuk.dhfs.repository.syncmap.DtoMapper;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
 
-/**
- * Maps a {@link File} object to a {@link FileDto} object and vice versa.
- */
 @ApplicationScoped
 public class FileDtoMapper implements DtoMapper<File, FileDto> {
     @Inject

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/objects/FileHelper.java

@@ -1,8 +1,8 @@
-package com.usatiuk.dhfsfs.objects;
+package com.usatiuk.dhfs.files.objects;
 
+import com.usatiuk.objects.JObjectKey;
 import com.usatiuk.dhfs.jmap.JMapHelper;
 import com.usatiuk.dhfs.jmap.JMapLongKey;
-import com.usatiuk.objects.JObjectKey;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
 import org.apache.commons.lang3.tuple.Pair;
@@ -10,20 +10,11 @@ import org.apache.commons.lang3.tuple.Pair;
 import java.util.ArrayList;
 import java.util.List;
 
-/**
- * Helper class for working with files.
- */
 @ApplicationScoped
 public class FileHelper {
     @Inject
     JMapHelper jMapHelper;
 
-    /**
-     * Get the chunks of a file.
-     * Transaction is expected to be already started.
-     * @param file the file to get chunks from
-     * @return a list of pairs of chunk offset and chunk key
-     */
     public List<Pair<Long, JObjectKey>> getChunks(File file) {
         ArrayList<Pair<Long, JObjectKey>> chunks = new ArrayList<>();
         try (var it = jMapHelper.getIterator(file)) {
@@ -35,13 +26,6 @@ public class FileHelper {
         return List.copyOf(chunks);
     }
 
-    /**
-     * Replace the chunks of a file.
-     * All previous chunks will be deleted.
-     * Transaction is expected to be already started.
-     * @param file the file to replace chunks in
-     * @param chunks the list of pairs of chunk offset and chunk key
-     */
     public void replaceChunks(File file, List<Pair<Long, JObjectKey>> chunks) {
         jMapHelper.deleteAll(file);
 

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/objects/FileProtoSerializer.java

@@ -0,0 +1,25 @@
+package com.usatiuk.dhfs.files.objects;
+
+import com.usatiuk.dhfs.ProtoSerializer;
+import com.usatiuk.dhfs.persistence.FileDtoP;
+import com.usatiuk.dhfs.utils.SerializationHelper;
+import jakarta.inject.Singleton;
+
+import java.io.IOException;
+
+@Singleton
+public class FileProtoSerializer implements ProtoSerializer<FileDtoP, FileDto> {
+    @Override
+    public FileDto deserialize(FileDtoP message) {
+        try (var is = message.getSerializedData().newInput()) {
+            return SerializationHelper.deserialize(is);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public FileDtoP serialize(FileDto object) {
+        return FileDtoP.newBuilder().setSerializedData(SerializationHelper.serialize(object)).build();
+    }
+}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/objects/FileSyncHandler.java

@@ -1,14 +1,20 @@
-package com.usatiuk.dhfsfs.objects;
+package com.usatiuk.dhfs.files.objects;
 
+import com.usatiuk.dhfs.PeerId;
+import com.usatiuk.dhfs.RemoteObjectDataWrapper;
+import com.usatiuk.dhfs.RemoteObjectMeta;
+import com.usatiuk.dhfs.RemoteTransaction;
+import com.usatiuk.dhfs.files.service.DhfsFileService;
 import com.usatiuk.dhfs.jkleppmanntree.JKleppmannTreeManager;
+import com.usatiuk.dhfs.jkleppmanntree.structs.JKleppmannTreeNodeMetaFile;
 import com.usatiuk.dhfs.jmap.JMapHelper;
-import com.usatiuk.dhfs.peersync.PeerId;
-import com.usatiuk.dhfs.peersync.PersistentPeerDataService;
-import com.usatiuk.dhfs.remoteobj.*;
-import com.usatiuk.dhfsfs.service.DhfsFileService;
-import com.usatiuk.kleppmanntree.AlreadyExistsException;
+import com.usatiuk.dhfs.repository.ObjSyncHandler;
+import com.usatiuk.dhfs.repository.PersistentPeerDataService;
+import com.usatiuk.dhfs.repository.SyncHelper;
 import com.usatiuk.objects.JObjectKey;
+import com.usatiuk.objects.transaction.LockingStrategy;
 import com.usatiuk.objects.transaction.Transaction;
+import com.usatiuk.kleppmanntree.AlreadyExistsException;
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
 import io.quarkus.logging.Log;
@@ -23,9 +29,6 @@ import javax.annotation.Nullable;
 import java.util.List;
 import java.util.Objects;
 
-/**
- * Handles synchronization of file objects.
- */
 @ApplicationScoped
 public class FileSyncHandler implements ObjSyncHandler<File, FileDto> {
     @Inject
@@ -44,18 +47,14 @@ public class FileSyncHandler implements ObjSyncHandler<File, FileDto> {
     @Inject
     DhfsFileService fileService;
 
-    private JKleppmannTreeManager.JKleppmannTree getTree() {
-        return jKleppmannTreeManager.getTree(JObjectKey.of("fs")).orElseThrow();
+    private JKleppmannTreeManager.JKleppmannTree getTreeW() {
+        return jKleppmannTreeManager.getTree(JObjectKey.of("fs"));
+    }
+
+    private JKleppmannTreeManager.JKleppmannTree getTreeR() {
+        return jKleppmannTreeManager.getTree(JObjectKey.of("fs"), LockingStrategy.OPTIMISTIC);
     }
 
-    /**
-     * Resolve conflict between two file versions, update the file in storage and create a conflict file.
-     *
-     * @param from              the peer that sent the update
-     * @param key               the key of the file
-     * @param receivedChangelog the changelog of the received file
-     * @param receivedData      the received file data
-     */
     private void resolveConflict(PeerId from, JObjectKey key, PMap<PeerId, Long> receivedChangelog,
                                  @Nullable FileDto receivedData) {
         var oursCurMeta = curTx.get(RemoteObjectMeta.class, key).orElse(null);
@@ -137,12 +136,12 @@ public class FileSyncHandler implements ObjSyncHandler<File, FileDto> {
 
             do {
                 try {
-                    getTree().move(parent.getRight(),
+                    getTreeW().move(parent.getRight(),
                             new JKleppmannTreeNodeMetaFile(
                                     parent.getLeft() + ".fconflict." + persistentPeerDataService.getSelfUuid() + "." + otherHostname.toString() + "." + i,
                                     newFile.key()
                             ),
-                            getTree().getNewNodeId()
+                            getTreeW().getNewNodeId()
                     );
                 } catch (AlreadyExistsException aex) {
                     i++;

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/service/DhfsFileService.java

@@ -0,0 +1,48 @@
+package com.usatiuk.dhfs.files.service;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.UnsafeByteOperations;
+import com.usatiuk.objects.JObjectKey;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.Optional;
+
+public interface DhfsFileService {
+    Optional<JObjectKey> open(String name);
+
+    Optional<JObjectKey> create(String name, long mode);
+
+    Pair<String, JObjectKey> inoToParent(JObjectKey ino);
+
+    void mkdir(String name, long mode);
+
+    Optional<GetattrRes> getattr(JObjectKey name);
+
+    Boolean chmod(JObjectKey name, long mode);
+
+    void unlink(String name);
+
+    Boolean rename(String from, String to);
+
+    Boolean setTimes(JObjectKey fileUuid, long atimeMs, long mtimeMs);
+
+    Iterable<String> readDir(String name);
+
+    long size(JObjectKey fileUuid);
+
+    Optional<ByteString> read(JObjectKey fileUuid, long offset, int length);
+
+    Long write(JObjectKey fileUuid, long offset, ByteString data);
+
+    default Long write(JObjectKey fileUuid, long offset, byte[] data) {
+        return write(fileUuid, offset, UnsafeByteOperations.unsafeWrap(data));
+    }
+
+    Boolean truncate(JObjectKey fileUuid, long length);
+
+    String readlink(JObjectKey uuid);
+
+    ByteString readlinkBS(JObjectKey uuid);
+
+    JObjectKey symlink(String oldpath, String newpath);
+}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/service/DhfsFileServiceImpl.java

@@ -1,28 +1,27 @@
-package com.usatiuk.dhfsfs.service;
+package com.usatiuk.dhfs.files.service;
 
 import com.google.protobuf.ByteString;
 import com.google.protobuf.UnsafeByteOperations;
+import com.usatiuk.dhfs.JDataRemote;
+import com.usatiuk.dhfs.RemoteObjectMeta;
+import com.usatiuk.dhfs.RemoteTransaction;
+import com.usatiuk.dhfs.files.objects.ChunkData;
+import com.usatiuk.dhfs.files.objects.File;
 import com.usatiuk.dhfs.jkleppmanntree.JKleppmannTreeManager;
 import com.usatiuk.dhfs.jkleppmanntree.structs.JKleppmannTreeNode;
-import com.usatiuk.dhfs.jkleppmanntree.structs.JKleppmannTreeNodeHolder;
 import com.usatiuk.dhfs.jkleppmanntree.structs.JKleppmannTreeNodeMeta;
+import com.usatiuk.dhfs.jkleppmanntree.structs.JKleppmannTreeNodeMetaDirectory;
+import com.usatiuk.dhfs.jkleppmanntree.structs.JKleppmannTreeNodeMetaFile;
 import com.usatiuk.dhfs.jmap.JMapEntry;
 import com.usatiuk.dhfs.jmap.JMapHelper;
 import com.usatiuk.dhfs.jmap.JMapLongKey;
-import com.usatiuk.dhfs.remoteobj.JDataRemote;
-import com.usatiuk.dhfs.remoteobj.RemoteObjectMeta;
-import com.usatiuk.dhfs.remoteobj.RemoteTransaction;
-import com.usatiuk.dhfsfs.objects.ChunkData;
-import com.usatiuk.dhfsfs.objects.File;
-import com.usatiuk.dhfsfs.objects.JKleppmannTreeNodeMetaDirectory;
-import com.usatiuk.dhfsfs.objects.JKleppmannTreeNodeMetaFile;
+import com.usatiuk.dhfs.utils.StatusRuntimeExceptionNoStacktrace;
 import com.usatiuk.objects.JData;
 import com.usatiuk.objects.JObjectKey;
 import com.usatiuk.objects.iterators.IteratorStart;
-import com.usatiuk.objects.stores.ObjectPersistentStore;
+import com.usatiuk.objects.transaction.LockingStrategy;
 import com.usatiuk.objects.transaction.Transaction;
 import com.usatiuk.objects.transaction.TransactionManager;
-import com.usatiuk.utils.StatusRuntimeExceptionNoStacktrace;
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
 import io.quarkus.logging.Log;
@@ -34,83 +33,85 @@ import jakarta.inject.Inject;
 import org.apache.commons.lang3.tuple.Pair;
 import org.eclipse.microprofile.config.inject.ConfigProperty;
 
-import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
 import java.util.*;
 import java.util.stream.StreamSupport;
 
-/**
- * Actual filesystem implementation.
- */
 @ApplicationScoped
-public class DhfsFileService {
-    @ConfigProperty(name = "dhfs.files.target_chunk_alignment", defaultValue = "17")
-    int targetChunkAlignment;
-    @ConfigProperty(name = "dhfs.files.max_chunk_size", defaultValue = "524288")
-    int maxChunkSize;
-    @ConfigProperty(name = "dhfs.files.allow_recursive_delete")
-    boolean allowRecursiveDelete;
-
-
+public class DhfsFileServiceImpl implements DhfsFileService {
     @Inject
     Transaction curTx;
     @Inject
     RemoteTransaction remoteTx;
     @Inject
     TransactionManager jObjectTxManager;
+
+    @ConfigProperty(name = "dhfs.files.target_chunk_alignment")
+    int targetChunkAlignment;
+
+    @ConfigProperty(name = "dhfs.files.target_chunk_size")
+    int targetChunkSize;
+
+    @ConfigProperty(name = "dhfs.files.use_hash_for_chunks")
+    boolean useHashForChunks;
+
+    @ConfigProperty(name = "dhfs.files.allow_recursive_delete")
+    boolean allowRecursiveDelete;
+
+    @ConfigProperty(name = "dhfs.objects.ref_verification")
+    boolean refVerification;
+
+    @ConfigProperty(name = "dhfs.objects.write_log")
+    boolean writeLogging;
+
     @Inject
     JKleppmannTreeManager jKleppmannTreeManager;
+
     @Inject
     JMapHelper jMapHelper;
-    @Inject
-    ObjectPersistentStore objectPersistentStore;
 
-    private JKleppmannTreeManager.JKleppmannTree getTree() {
-        return jKleppmannTreeManager.getTree(JObjectKey.of("fs"), () -> new JKleppmannTreeNodeMetaDirectory(""));
+    private JKleppmannTreeManager.JKleppmannTree getTreeW() {
+        return jKleppmannTreeManager.getTree(JObjectKey.of("fs"));
+    }
+
+    private JKleppmannTreeManager.JKleppmannTree getTreeR() {
+        return jKleppmannTreeManager.getTree(JObjectKey.of("fs"), LockingStrategy.OPTIMISTIC);
     }
 
-    /**
-     * Create a new chunk with the given data and a new unique ID.
-     *
-     * @param bytes the data to store in the chunk
-     * @return the created chunk
-     */
     private ChunkData createChunk(ByteString bytes) {
         var newChunk = new ChunkData(JObjectKey.of(UUID.randomUUID().toString()), bytes);
-        remoteTx.putDataNew(newChunk);
+        remoteTx.putData(newChunk);
         return newChunk;
     }
 
-    int targetChunkSize() {
-        return 1 << targetChunkAlignment;
-    }
-
     void init(@Observes @Priority(500) StartupEvent event) {
         Log.info("Initializing file service");
-        getTree();
+        getTreeW();
     }
 
-    private JKleppmannTreeNode getDirEntry(String name) {
-        var res = getTree().traverse(StreamSupport.stream(Path.of(name).spliterator(), false).map(p -> p.toString()).toList());
+    private JKleppmannTreeNode getDirEntryW(String name) {
+        var res = getTreeW().traverse(StreamSupport.stream(Path.of(name).spliterator(), false).map(p -> p.toString()).toList());
         if (res == null) throw new StatusRuntimeExceptionNoStacktrace(Status.NOT_FOUND);
-        var ret = curTx.get(JKleppmannTreeNodeHolder.class, res).map(JKleppmannTreeNodeHolder::node).orElseThrow(() -> new StatusRuntimeException(Status.NOT_FOUND.withDescription("Tree node exists but not found as jObject: " + name)));
+        var ret = curTx.get(JKleppmannTreeNode.class, res).orElseThrow(() -> new StatusRuntimeException(Status.NOT_FOUND.withDescription("Tree node exists but not found as jObject: " + name)));
+        return ret;
+    }
+
+    private JKleppmannTreeNode getDirEntryR(String name) {
+        var res = getTreeR().traverse(StreamSupport.stream(Path.of(name).spliterator(), false).map(p -> p.toString()).toList());
+        if (res == null) throw new StatusRuntimeExceptionNoStacktrace(Status.NOT_FOUND);
+        var ret = curTx.get(JKleppmannTreeNode.class, res).orElseThrow(() -> new StatusRuntimeException(Status.NOT_FOUND.withDescription("Tree node exists but not found as jObject: " + name)));
         return ret;
     }
 
     private Optional<JKleppmannTreeNode> getDirEntryOpt(String name) {
-        var res = getTree().traverse(StreamSupport.stream(Path.of(name).spliterator(), false).map(p -> p.toString()).toList());
+        var res = getTreeW().traverse(StreamSupport.stream(Path.of(name).spliterator(), false).map(p -> p.toString()).toList());
         if (res == null) return Optional.empty();
-        var ret = curTx.get(JKleppmannTreeNodeHolder.class, res).map(JKleppmannTreeNodeHolder::node);
+        var ret = curTx.get(JKleppmannTreeNode.class, res);
         return ret;
     }
 
-    /**
-     * Get the attributes of a file or directory.
-     *
-     * @param uuid the UUID of the file or directory
-     * @return the attributes of the file or directory
-     */
+    @Override
     public Optional<GetattrRes> getattr(JObjectKey uuid) {
         return jObjectTxManager.executeTx(() -> {
             var ref = curTx.get(JData.class, uuid).orElse(null);
@@ -123,7 +124,7 @@ public class DhfsFileService {
                 } else {
                     throw new StatusRuntimeException(Status.DATA_LOSS.withDescription("FsNode is not an FsNode: " + ref.key()));
                 }
-            } else if (ref instanceof JKleppmannTreeNodeHolder) {
+            } else if (ref instanceof JKleppmannTreeNode) {
                 ret = new GetattrRes(100, 100, 0700, GetattrType.DIRECTORY);
             } else {
                 throw new StatusRuntimeException(Status.DATA_LOSS.withDescription("FsNode is not an FsNode: " + ref.key()));
@@ -132,18 +133,13 @@ public class DhfsFileService {
         });
     }
 
-    /**
-     * Try to resolve a path to a file or directory.
-     *
-     * @param name the path to resolve
-     * @return the key of the file or directory, or an empty optional if it does not exist
-     */
+    @Override
     public Optional<JObjectKey> open(String name) {
         return jObjectTxManager.executeTx(() -> {
             try {
-                var ret = getDirEntry(name);
+                var ret = getDirEntryR(name);
                 return switch (ret.meta()) {
-                    case JKleppmannTreeNodeMetaFile f -> Optional.of(f.fileIno());
+                    case JKleppmannTreeNodeMetaFile f -> Optional.of(f.getFileIno());
                     case JKleppmannTreeNodeMetaDirectory f -> Optional.of(ret.key());
                     default -> Optional.empty();
                 };
@@ -161,17 +157,11 @@ public class DhfsFileService {
             throw new StatusRuntimeExceptionNoStacktrace(Status.INVALID_ARGUMENT.withDescription("Not a directory: " + entry.key()));
     }
 
-    /**
-     * Create a new file with the given name and mode.
-     *
-     * @param name the name of the file
-     * @param mode the mode of the file
-     * @return the key of the created file
-     */
+    @Override
     public Optional<JObjectKey> create(String name, long mode) {
         return jObjectTxManager.executeTx(() -> {
             Path path = Path.of(name);
-            var parent = getDirEntry(path.getParent().toString());
+            var parent = getDirEntryW(path.getParent().toString());
 
             ensureDir(parent);
 
@@ -183,7 +173,7 @@ public class DhfsFileService {
             remoteTx.putData(f);
 
             try {
-                getTree().move(parent.key(), new JKleppmannTreeNodeMetaFile(fname, f.key()), getTree().getNewNodeId());
+                getTreeW().move(parent.key(), new JKleppmannTreeNodeMetaFile(fname, f.key()), getTreeW().getNewNodeId());
             } catch (Exception e) {
 //                fobj.getMeta().removeRef(newNodeId);
                 throw e;
@@ -192,101 +182,71 @@ public class DhfsFileService {
         });
     }
 
-    /**
-     * Get the parent directory of a file or directory.
-     *
-     * @param ino the key of the file or directory
-     * @return the parent directory
-     */
+    //FIXME: Slow..
+    @Override
     public Pair<String, JObjectKey> inoToParent(JObjectKey ino) {
         return jObjectTxManager.executeTx(() -> {
-            // FIXME: Slow
-            return getTree().findParent(w -> {
+            return getTreeW().findParent(w -> {
                 if (w.meta() instanceof JKleppmannTreeNodeMetaFile f)
-                    return f.fileIno().equals(ino);
+                    return f.getFileIno().equals(ino);
                 return false;
             });
         });
     }
 
-    /**
-     * Create a new directory with the given name and mode.
-     *
-     * @param name the name of the directory
-     * @param mode the mode of the directory
-     */
+    @Override
     public void mkdir(String name, long mode) {
         jObjectTxManager.executeTx(() -> {
             Path path = Path.of(name);
-            var parent = getDirEntry(path.getParent().toString());
+            var parent = getDirEntryW(path.getParent().toString());
             ensureDir(parent);
 
             String dname = path.getFileName().toString();
 
             Log.debug("Creating directory " + name);
 
-            // TODO: No modes for directories yet
-            getTree().move(parent.key(), new JKleppmannTreeNodeMetaDirectory(dname), getTree().getNewNodeId());
+            getTreeW().move(parent.key(), new JKleppmannTreeNodeMetaDirectory(dname), getTreeW().getNewNodeId());
         });
     }
 
-    /**
-     * Unlink a file or directory.
-     *
-     * @param name the name of the file or directory
-     * @throws DirectoryNotEmptyException if the directory is not empty and recursive delete is not allowed
-     */
+    @Override
     public void unlink(String name) {
         jObjectTxManager.executeTx(() -> {
             var node = getDirEntryOpt(name).orElse(null);
-            if (node == null)
-                throw new StatusRuntimeException(Status.NOT_FOUND.withDescription("File not found when trying to unlink: " + name));
             if (node.meta() instanceof JKleppmannTreeNodeMetaDirectory f) {
                 if (!allowRecursiveDelete && !node.children().isEmpty())
                     throw new DirectoryNotEmptyException();
             }
-            getTree().trash(node.meta(), node.key());
+            getTreeW().trash(node.meta(), node.key());
         });
     }
 
-    /**
-     * Rename a file or directory.
-     *
-     * @param from the old name
-     * @param to   the new name
-     * @return true if the rename was successful, false otherwise
-     */
-    public boolean rename(String from, String to) {
+    @Override
+    public Boolean rename(String from, String to) {
         return jObjectTxManager.executeTx(() -> {
-            var node = getDirEntry(from);
+            var node = getDirEntryW(from);
             JKleppmannTreeNodeMeta meta = node.meta();
 
             var toPath = Path.of(to);
-            var toDentry = getDirEntry(toPath.getParent().toString());
+            var toDentry = getDirEntryW(toPath.getParent().toString());
             ensureDir(toDentry);
 
-            getTree().move(toDentry.key(), meta.withName(toPath.getFileName().toString()), node.key());
+            getTreeW().move(toDentry.key(), meta.withName(toPath.getFileName().toString()), node.key());
             return true;
         });
     }
 
-    /**
-     * Change the mode of a file or directory.
-     *
-     * @param uuid the ID of the file or directory
-     * @param mode the new mode
-     * @return true if the mode was changed successfully, false otherwise
-     */
-    public boolean chmod(JObjectKey uuid, long mode) {
+    @Override
+    public Boolean chmod(JObjectKey uuid, long mode) {
         return jObjectTxManager.executeTx(() -> {
             var dent = curTx.get(JData.class, uuid).orElseThrow(() -> new StatusRuntimeExceptionNoStacktrace(Status.NOT_FOUND));
 
-            if (dent instanceof JKleppmannTreeNodeHolder) {
+            if (dent instanceof JKleppmannTreeNode) {
                 return true;
             } else if (dent instanceof RemoteObjectMeta) {
                 var remote = remoteTx.getData(JDataRemote.class, uuid).orElse(null);
                 if (remote instanceof File f) {
-                    remoteTx.putData(f.withMode(mode).withCurrentCTime());
+                    remoteTx.putData(f.withMode(mode).withMTime(System.currentTimeMillis()));
                     return true;
                 } else {
                     throw new IllegalArgumentException(uuid + " is not a file");
@@ -297,15 +257,10 @@ public class DhfsFileService {
         });
     }
 
-    /**
-     * Read the contents of a directory.
-     *
-     * @param name the path of the directory
-     * @return an iterable of the names of the files in the directory
-     */
+    @Override
     public Iterable<String> readDir(String name) {
         return jObjectTxManager.executeTx(() -> {
-            var found = getDirEntry(name);
+            var found = getDirEntryW(name);
 
             if (!(found.meta() instanceof JKleppmannTreeNodeMetaDirectory md))
                 throw new StatusRuntimeException(Status.INVALID_ARGUMENT);
@@ -314,15 +269,8 @@ public class DhfsFileService {
         });
     }
 
-    /**
-     * Read the contents of a file.
-     *
-     * @param fileUuid the ID of the file
-     * @param offset   the offset to start reading from
-     * @param length   the number of bytes to read
-     * @return the contents of the file as a ByteString
-     */
-    public ByteString read(JObjectKey fileUuid, long offset, int length) {
+    @Override
+    public Optional<ByteString> read(JObjectKey fileUuid, long offset, int length) {
         return jObjectTxManager.executeTx(() -> {
             if (length < 0)
                 throw new StatusRuntimeException(Status.INVALID_ARGUMENT.withDescription("Length should be more than zero: " + length));
@@ -332,12 +280,12 @@ public class DhfsFileService {
             var file = remoteTx.getData(File.class, fileUuid).orElse(null);
             if (file == null) {
                 Log.error("File not found when trying to read: " + fileUuid);
-                throw new StatusRuntimeException(Status.NOT_FOUND.withDescription("File not found when trying to read: " + fileUuid));
+                return Optional.empty();
             }
 
             try (var it = jMapHelper.getIterator(file, IteratorStart.LE, JMapLongKey.of(offset))) {
                 if (!it.hasNext())
-                    return ByteString.empty();
+                    return Optional.of(ByteString.empty());
 
 //                if (it.peekNextKey().key() != offset) {
 //                    Log.warnv("Read over the end of file: {0} {1} {2}, next chunk: {3}", fileUuid, offset, length, it.peekNextKey());
@@ -375,20 +323,14 @@ public class DhfsFileService {
                     chunk = it.next();
                 }
 
-                return buf;
+                return Optional.of(buf);
             } catch (Exception e) {
                 Log.error("Error reading file: " + fileUuid, e);
-                throw new StatusRuntimeException(Status.INTERNAL.withDescription("Error reading file: " + fileUuid));
+                return Optional.empty();
             }
         });
     }
 
-    /**
-     * Get the size of a file.
-     *
-     * @param uuid the ID of the file
-     * @return the size of the file
-     */
     private ByteString readChunk(JObjectKey uuid) {
         var chunkRead = remoteTx.getData(ChunkData.class, uuid).orElse(null);
 
@@ -400,12 +342,6 @@ public class DhfsFileService {
         return chunkRead.data();
     }
 
-    /**
-     * Get the size of a chunk.
-     *
-     * @param uuid the ID of the chunk
-     * @return the size of the chunk
-     */
     private int getChunkSize(JObjectKey uuid) {
         return readChunk(uuid).size();
     }
@@ -414,25 +350,24 @@ public class DhfsFileService {
         return num & -(1L << n);
     }
 
-    /**
-     * Write data to a file.
-     *
-     * @param fileUuid the ID of the file
-     * @param offset   the offset to write to
-     * @param data     the data to write
-     * @return the number of bytes written
-     */
-    public long write(JObjectKey fileUuid, long offset, ByteString data) {
+    @Override
+    public Long write(JObjectKey fileUuid, long offset, ByteString data) {
         return jObjectTxManager.executeTx(() -> {
             if (offset < 0)
                 throw new StatusRuntimeException(Status.INVALID_ARGUMENT.withDescription("Offset should be more than zero: " + offset));
 
-            var file = remoteTx.getData(File.class, fileUuid).orElse(null);
+            var file = remoteTx.getData(File.class, fileUuid, LockingStrategy.WRITE).orElse(null);
             if (file == null) {
-                throw new StatusRuntimeException(Status.NOT_FOUND.withDescription("File not found when trying to write: " + fileUuid));
+                Log.error("File not found when trying to write: " + fileUuid);
+                return -1L;
             }
 
-            Map<Long, JObjectKey> removedChunks = new HashMap<>();
+            if (writeLogging) {
+                Log.info("Writing to file: " + file.key() + " size=" + size(fileUuid) + " "
+                        + offset + " " + data.size());
+            }
+
+            NavigableMap<Long, JObjectKey> removedChunks = new TreeMap<>();
 
             long realOffset = targetChunkAlignment >= 0 ? alignDown(offset, targetChunkAlignment) : offset;
             long writeEnd = offset + data.size();
@@ -470,12 +405,12 @@ public class DhfsFileService {
             }
 
 
-            Map<Long, JObjectKey> newChunks = new HashMap<>();
+            NavigableMap<Long, JObjectKey> newChunks = new TreeMap<>();
 
             if (existingEnd < offset) {
                 if (!pendingPrefix.isEmpty()) {
                     int diff = Math.toIntExact(offset - existingEnd);
-                    pendingPrefix = pendingPrefix.concat(UnsafeByteOperations.unsafeWrap(ByteBuffer.allocateDirect(diff)));
+                    pendingPrefix = pendingPrefix.concat(ByteString.copyFrom(new byte[diff]));
                 } else {
                     fillZeros(existingEnd, offset, newChunks);
                     start = offset;
@@ -487,16 +422,15 @@ public class DhfsFileService {
             int combinedSize = pendingWrites.size();
 
             {
+                int targetChunkSize = 1 << targetChunkAlignment;
                 int cur = 0;
                 while (cur < combinedSize) {
                     int end;
 
-                    if (combinedSize - cur < maxChunkSize)
-                        end = combinedSize;
-                    else if (targetChunkAlignment < 0)
+                    if (targetChunkAlignment < 0)
                         end = combinedSize;
                     else
-                        end = Math.min(cur + targetChunkSize(), combinedSize);
+                        end = Math.min(cur + targetChunkSize, combinedSize);
 
                     var thisChunk = pendingWrites.substring(cur, end);
 
@@ -509,29 +443,23 @@ public class DhfsFileService {
             }
 
             for (var e : removedChunks.entrySet()) {
-//                Log.tracev("Removing chunk {0}-{1}", e.getKey(), e.getValue());
+                Log.tracev("Removing chunk {0}-{1}", e.getKey(), e.getValue());
                 jMapHelper.delete(file, JMapLongKey.of(e.getKey()));
             }
 
             for (var e : newChunks.entrySet()) {
-//                Log.tracev("Adding chunk {0}-{1}", e.getKey(), e.getValue());
+                Log.tracev("Adding chunk {0}-{1}", e.getKey(), e.getValue());
                 jMapHelper.put(file, JMapLongKey.of(e.getKey()), e.getValue());
             }
 
-            remoteTx.putData(file.withCurrentMTime());
+            remoteTx.putData(file);
 
             return (long) data.size();
         });
     }
 
-    /**
-     * Truncate a file to the given length.
-     *
-     * @param fileUuid the ID of the file
-     * @param length   the new length of the file
-     * @return true if the truncate was successful, false otherwise
-     */
-    public boolean truncate(JObjectKey fileUuid, long length) {
+    @Override
+    public Boolean truncate(JObjectKey fileUuid, long length) {
         return jObjectTxManager.executeTx(() -> {
             if (length < 0)
                 throw new StatusRuntimeException(Status.INVALID_ARGUMENT.withDescription("Length should be more than zero: " + length));
@@ -606,28 +534,21 @@ public class DhfsFileService {
 //            file = file.withChunks(file.chunks().minusAll(removedChunks.keySet()).plusAll(newChunks)).withMTime(System.currentTimeMillis());
 
             for (var e : removedChunks.entrySet()) {
-//                Log.tracev("Removing chunk {0}-{1}", e.getKey(), e.getValue());
+                Log.tracev("Removing chunk {0}-{1}", e.getKey(), e.getValue());
                 jMapHelper.delete(file, JMapLongKey.of(e.getKey()));
             }
 
             for (var e : newChunks.entrySet()) {
-//                Log.tracev("Adding chunk {0}-{1}", e.getKey(), e.getValue());
+                Log.tracev("Adding chunk {0}-{1}", e.getKey(), e.getValue());
                 jMapHelper.put(file, JMapLongKey.of(e.getKey()), e.getValue());
             }
 
-            remoteTx.putData(file.withCurrentMTime());
+            remoteTx.putData(file);
             return true;
         });
     }
 
-    /**
-     * Fill the given range with zeroes.
-     *
-     * @param fillStart the start of the range
-     * @param length    the end of the range
-     * @param newChunks the map to store the new chunks in
-     */
-    private void fillZeros(long fillStart, long length, Map<Long, JObjectKey> newChunks) {
+    private void fillZeros(long fillStart, long length, NavigableMap<Long, JObjectKey> newChunks) {
         long combinedSize = (length - fillStart);
 
         long start = fillStart;
@@ -640,18 +561,18 @@ public class DhfsFileService {
             while (cur < combinedSize) {
                 long end;
 
-                if (targetChunkSize() <= 0)
+                if (targetChunkSize <= 0)
                     end = combinedSize;
                 else {
-                    if ((combinedSize - cur) > (targetChunkSize() * 1.5)) {
-                        end = cur + targetChunkSize();
+                    if ((combinedSize - cur) > (targetChunkSize * 1.5)) {
+                        end = cur + targetChunkSize;
                     } else {
                         end = combinedSize;
                     }
                 }
 
                 if (!zeroCache.containsKey(end - cur))
-                    zeroCache.put(end - cur, createChunk(UnsafeByteOperations.unsafeWrap(ByteBuffer.allocateDirect(Math.toIntExact(end - cur)))));
+                    zeroCache.put(end - cur, createChunk(UnsafeByteOperations.unsafeWrap(new byte[Math.toIntExact(end - cur)])));
 
                 ChunkData newChunkData = zeroCache.get(end - cur);
                 newChunks.put(start, newChunkData.key());
@@ -662,42 +583,26 @@ public class DhfsFileService {
         }
     }
 
-    /**
-     * Read the contents of a symlink.
-     *
-     * @param uuid the ID of the symlink
-     * @return the contents of the symlink as a string
-     */
+    @Override
     public String readlink(JObjectKey uuid) {
         return jObjectTxManager.executeTx(() -> {
             return readlinkBS(uuid).toStringUtf8();
         });
     }
 
-    /**
-     * Read the contents of a symlink as a ByteString.
-     *
-     * @param uuid the ID of the symlink
-     * @return the contents of the symlink as a ByteString
-     */
+    @Override
     public ByteString readlinkBS(JObjectKey uuid) {
         return jObjectTxManager.executeTx(() -> {
             var fileOpt = remoteTx.getData(File.class, uuid).orElseThrow(() -> new StatusRuntimeException(Status.NOT_FOUND.withDescription("File not found when trying to readlink: " + uuid)));
-            return read(uuid, 0, Math.toIntExact(size(uuid)));
+            return read(uuid, 0, Math.toIntExact(size(uuid))).get();
         });
     }
 
-    /**
-     * Create a symlink.
-     *
-     * @param oldpath the target of the symlink
-     * @param newpath the path of the symlink
-     * @return the key of the created symlink
-     */
+    @Override
     public JObjectKey symlink(String oldpath, String newpath) {
         return jObjectTxManager.executeTx(() -> {
             Path path = Path.of(newpath);
-            var parent = getDirEntry(path.getParent().toString());
+            var parent = getDirEntryW(path.getParent().toString());
 
             ensureDir(parent);
 
@@ -711,29 +616,23 @@ public class DhfsFileService {
             jMapHelper.put(f, JMapLongKey.of(0), newChunkData.key());
 
             remoteTx.putData(f);
-            getTree().move(parent.key(), new JKleppmannTreeNodeMetaFile(fname, f.key()), getTree().getNewNodeId());
+            getTreeW().move(parent.key(), new JKleppmannTreeNodeMetaFile(fname, f.key()), getTreeW().getNewNodeId());
             return f.key();
         });
     }
 
-    /**
-     * Set the access and modification times of a file.
-     *
-     * @param fileUuid the ID of the file
-     * @param mtimeMs  the modification time in milliseconds
-     * @return true if the times were set successfully, false otherwise
-     */
-    public boolean setTimes(JObjectKey fileUuid, long mtimeMs) {
+    @Override
+    public Boolean setTimes(JObjectKey fileUuid, long atimeMs, long mtimeMs) {
         return jObjectTxManager.executeTx(() -> {
             var dent = curTx.get(JData.class, fileUuid).orElseThrow(() -> new StatusRuntimeExceptionNoStacktrace(Status.NOT_FOUND));
 
             // FIXME:
-            if (dent instanceof JKleppmannTreeNodeHolder) {
+            if (dent instanceof JKleppmannTreeNode) {
                 return true;
             } else if (dent instanceof RemoteObjectMeta) {
                 var remote = remoteTx.getData(JDataRemote.class, fileUuid).orElse(null);
                 if (remote instanceof File f) {
-                    remoteTx.putData(f.withCTime(System.currentTimeMillis()).withMTime(mtimeMs));
+                    remoteTx.putData(f.withCTime(atimeMs).withMTime(mtimeMs));
                     return true;
                 } else {
                     throw new IllegalArgumentException(fileUuid + " is not a file");
@@ -744,12 +643,7 @@ public class DhfsFileService {
         });
     }
 
-    /**
-     * Get the size of a file.
-     *
-     * @param fileUuid the ID of the file
-     * @return the size of the file
-     */
+    @Override
     public long size(JObjectKey fileUuid) {
         return jObjectTxManager.executeTx(() -> {
             long realSize = 0;
@@ -768,34 +662,4 @@ public class DhfsFileService {
             return realSize;
         });
     }
-
-    /**
-     * Write data to a file.
-     *
-     * @param fileUuid the ID of the file
-     * @param offset   the offset to write to
-     * @param data     the data to write
-     * @return the number of bytes written
-     */
-    public long write(JObjectKey fileUuid, long offset, byte[] data) {
-        return write(fileUuid, offset, UnsafeByteOperations.unsafeWrap(data));
-    }
-
-    /**
-     * Get the free space on the filesystem.
-     *
-     * @return the free space in bytes
-     */
-    public long getFreeSpace() {
-        return objectPersistentStore.getFreeSpace();
-    }
-
-    /**
-     * Get the total space on the filesystem.
-     *
-     * @return the total space in bytes
-     */
-    public long getTotalSpace() {
-        return objectPersistentStore.getTotalSpace();
-    }
 }

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/service/DirectoryNotEmptyException.java

@@ -0,0 +1,8 @@
+package com.usatiuk.dhfs.files.service;
+
+public class DirectoryNotEmptyException extends RuntimeException {
+    @Override
+    public synchronized Throwable fillInStackTrace() {
+        return this;
+    }
+}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/service/GetattrRes.java

@@ -0,0 +1,4 @@
+package com.usatiuk.dhfs.files.service;
+
+public record GetattrRes(long mtime, long ctime, long mode, GetattrType type) {
+}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfs/files/service/GetattrType.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfs.service;
+package com.usatiuk.dhfs.files.service;
 
 public enum GetattrType {
     FILE,

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfsfs/objects/ChunkData.java

@@ -1,18 +0,0 @@
-package com.usatiuk.dhfsfs.objects;
-
-import com.google.protobuf.ByteString;
-import com.usatiuk.dhfs.remoteobj.JDataRemote;
-import com.usatiuk.dhfs.remoteobj.JDataRemoteDto;
-import com.usatiuk.objects.JObjectKey;
-
-/**
- * ChunkData is a data structure that represents an immutable binary blob
- * @param key unique key
- * @param data binary data
- */
-public record ChunkData(JObjectKey key, ByteString data) implements JDataRemote, JDataRemoteDto {
-    @Override
-    public int estimateSize() {
-        return data.size();
-    }
-}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfsfs/objects/FileDto.java

@@ -1,20 +0,0 @@
-package com.usatiuk.dhfsfs.objects;
-
-import com.usatiuk.dhfs.remoteobj.JDataRemote;
-import com.usatiuk.dhfs.remoteobj.JDataRemoteDto;
-import com.usatiuk.objects.JObjectKey;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.List;
-
-/**
- * FileDto is a data transfer object that contains a file and its chunks.
- * @param file the file
- * @param chunks the list of chunks, each represented as a pair of a long and a JObjectKey
- */
-public record FileDto(File file, List<Pair<Long, JObjectKey>> chunks) implements JDataRemoteDto {
-    @Override
-    public Class<? extends JDataRemote> objClass() {
-        return File.class;
-    }
-}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfsfs/objects/JKleppmannTreeNodeMetaDirectory.java

@@ -1,22 +0,0 @@
-package com.usatiuk.dhfsfs.objects;
-
-import com.usatiuk.dhfs.jkleppmanntree.structs.JKleppmannTreeNodeMeta;
-import com.usatiuk.objects.JObjectKey;
-
-import java.util.Collection;
-import java.util.List;
-
-/**
- * JKleppmannTreeNodeMetaDirectory is a record that represents a directory in the JKleppmann tree.
- * @param name the name of the directory
- */
-public record JKleppmannTreeNodeMetaDirectory(String name) implements JKleppmannTreeNodeMeta {
-    public JKleppmannTreeNodeMeta withName(String name) {
-        return new JKleppmannTreeNodeMetaDirectory(name);
-    }
-
-    @Override
-    public Collection<JObjectKey> collectRefsTo() {
-        return List.of();
-    }
-}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfsfs/objects/JKleppmannTreeNodeMetaFile.java

@@ -1,24 +0,0 @@
-package com.usatiuk.dhfsfs.objects;
-
-import com.usatiuk.dhfs.jkleppmanntree.structs.JKleppmannTreeNodeMeta;
-import com.usatiuk.objects.JObjectKey;
-
-import java.util.Collection;
-import java.util.List;
-
-/**
- * JKleppmannTreeNodeMetaFile is a record that represents a file in the JKleppmann tree.
- * @param name the name of the file
- * @param fileIno a reference to the `File` object
- */
-public record JKleppmannTreeNodeMetaFile(String name, JObjectKey fileIno) implements JKleppmannTreeNodeMeta {
-    @Override
-    public JKleppmannTreeNodeMeta withName(String name) {
-        return new JKleppmannTreeNodeMetaFile(name, fileIno);
-    }
-
-    @Override
-    public Collection<JObjectKey> collectRefsTo() {
-        return List.of(fileIno);
-    }
-}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfsfs/service/DirectoryNotEmptyException.java

@@ -1,13 +0,0 @@
-package com.usatiuk.dhfsfs.service;
-
-/**
- * DirectoryNotEmptyException is thrown when a directory is not empty.
- * This exception is used to indicate that a directory cannot be deleted
- * because it contains files or subdirectories.
- */
-public class DirectoryNotEmptyException extends RuntimeException {
-    @Override
-    public synchronized Throwable fillInStackTrace() {
-        return this;
-    }
-}

dhfs-parent/dhfs-fs/src/main/java/com/usatiuk/dhfsfs/service/GetattrRes.java

@@ -1,11 +0,0 @@
-package com.usatiuk.dhfsfs.service;
-
-/**
- * GetattrRes is a record that represents the result of a getattr operation.
- * @param mtime File modification time
- * @param ctime File creation time
- * @param mode File mode
- * @param type File type
- */
- public record GetattrRes(long mtime, long ctime, long mode, GetattrType type) {
-}

dhfs-parent/dhfs-fs/src/main/resources/application.properties

@@ -1,5 +1,7 @@
 quarkus.grpc.server.use-separate-server=false
+dhfs.objects.peerdiscovery.port=42069
 dhfs.objects.peerdiscovery.interval=4s
+dhfs.objects.peerdiscovery.broadcast=true
 dhfs.objects.sync.timeout=30
 dhfs.objects.sync.ping.timeout=5
 dhfs.objects.invalidation.threads=16
@@ -12,6 +14,8 @@ dhfs.objects.persistence.stuff.root=${HOME}/dhfs_default/data/stuff
 dhfs.fuse.debug=false
 dhfs.fuse.enabled=true
 dhfs.files.allow_recursive_delete=false
+dhfs.files.target_chunk_size=2097152
+dhfs.files.target_chunk_alignment=19
 dhfs.objects.deletion.delay=1000
 dhfs.objects.deletion.can-delete-retry-delay=10000
 dhfs.objects.ref_verification=true

dhfs-parent/dhfs-fs/src/test/java/com/usatiuk/dhfs/TempDataProfile.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfs;
+package com.usatiuk.dhfs;
 
 import io.quarkus.test.junit.QuarkusTestProfile;
 
@@ -21,7 +21,7 @@ abstract public class TempDataProfile implements QuarkusTestProfile {
             throw new RuntimeException(e);
         }
         var ret = new HashMap<String, String>();
-        ret.put("dhfs.objects.persistence.root", tempDirWithPrefix.resolve("dhfs_root_test").toString());
+        ret.put("dhfs.objects.persistence.files.root", tempDirWithPrefix.resolve("dhfs_root_test").toString());
         ret.put("dhfs.fuse.root", tempDirWithPrefix.resolve("dhfs_fuse_root_test").toString());
         getConfigOverrides(ret);
         return ret;

dhfs-parent/dhfs-fs/src/test/java/com/usatiuk/dhfs/TestDataCleaner.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfs;
+package com.usatiuk.dhfs;
 
 import io.quarkus.logging.Log;
 import io.quarkus.runtime.ShutdownEvent;
@@ -15,7 +15,7 @@ import java.util.Objects;
 
 @ApplicationScoped
 public class TestDataCleaner {
-    @ConfigProperty(name = "dhfs.objects.persistence.root")
+    @ConfigProperty(name = "dhfs.objects.persistence.files.root")
     String tempDirectory;
 
     void init(@Observes @Priority(1) StartupEvent event) throws IOException {
@@ -30,7 +30,7 @@ public class TestDataCleaner {
         purgeDirectory(Path.of(tempDirectory).toFile());
     }
 
-    public void purgeDirectory(File dir) {
+    void purgeDirectory(File dir) {
         for (File file : Objects.requireNonNull(dir.listFiles())) {
             if (file.isDirectory())
                 purgeDirectory(file);

dhfs-parent/dhfs-fs/src/test/java/com/usatiuk/dhfs/benchmarks/Benchmarker.java

@@ -0,0 +1,83 @@
+package com.usatiuk.dhfs.benchmarks;
+
+import io.quarkus.logging.Log;
+import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
+
+import java.util.Arrays;
+import java.util.function.Supplier;
+
+public class Benchmarker {
+    static <T> long[] runLatency(Supplier<T> fn, int iterations) {
+        var out = new long[iterations];
+
+        int hash = 1;
+
+        for (int i = 0; i < iterations; i++) {
+            long startNanos = System.nanoTime();
+            var cur = fn.get();
+            long stopNanos = System.nanoTime();
+            out[i] = stopNanos - startNanos;
+            hash = hash * 31 + cur.hashCode();
+        }
+
+        System.out.println("\nHash: " + hash);
+
+        return out;
+    }
+
+    static <T> long[] runThroughput(Supplier<T> fn, int iterations, long iterationTime) {
+        var out = new long[iterations];
+
+        int hash = 1;
+
+        for (int i = 0; i < iterations; i++) {
+            long startMillis = System.currentTimeMillis();
+            long count = 0;
+            // FIXME: That's probably janky
+            while (System.currentTimeMillis() - startMillis < iterationTime) {
+                var res = fn.get();
+                count++;
+                hash = hash * 31 + res.hashCode();
+            }
+            System.out.println("Ran iteration " + i + "/" + iterations + " count=" + count);
+            out[i] = count;
+        }
+
+        System.out.println("\nHash: " + hash);
+
+        return out;
+    }
+
+    static void printStats(double[] data, String unit) {
+        DescriptiveStatistics stats = new DescriptiveStatistics();
+        for (var r : data) {
+            stats.addValue(r);
+        }
+        Log.info("\n" + stats +
+                "\n 50%: " + stats.getPercentile(50) + " " + unit +
+                "\n 90%: " + stats.getPercentile(90) + " " + unit +
+                "\n 95%: " + stats.getPercentile(95) + " " + unit +
+                "\n 99%: " + stats.getPercentile(99) + " " + unit +
+                "\n 99.9%: " + stats.getPercentile(99.9) + " " + unit +
+                "\n 99.99%: " + stats.getPercentile(99.99) + " " + unit
+        );
+
+    }
+
+    static <T> void runAndPrintMixSimple(String name, Supplier<T> fn, int latencyIterations, int thrptIterations, int thrptIterationTime, int warmupIterations, int warmupIterationTime) {
+        System.out.println("\n=========\n" + "Running " + name + "\n=========\n");
+        System.out.println("==Warmup==");
+        runThroughput(fn, warmupIterations, warmupIterationTime);
+        System.out.println("==Warmup done==");
+        System.out.println("==Throughput==");
+        var thrpt = runThroughput(fn, thrptIterations, thrptIterationTime);
+        printStats(Arrays.stream(thrpt).mapToDouble(o -> (double) o / 1000).toArray(), "ops/s");
+        System.out.println("==Throughput done==");
+        System.out.println("==Latency==");
+        var lat = runLatency(fn, latencyIterations);
+        printStats(Arrays.stream(lat).mapToDouble(o -> (double) o).toArray(), "ns/op");
+        System.out.println("==Latency done==");
+        System.out.println("\n=========\n" + name + " done" + "\n=========\n");
+    }
+
+}

dhfs-parent/dhfs-fs/src/test/java/com/usatiuk/dhfs/benchmarks/DhfsFileBenchmarkTest.java

@@ -0,0 +1,53 @@
+package com.usatiuk.dhfs.benchmarks;
+
+import com.google.protobuf.UnsafeByteOperations;
+import com.usatiuk.dhfs.TempDataProfile;
+import com.usatiuk.dhfs.files.service.DhfsFileService;
+import com.usatiuk.objects.JObjectKey;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.junit.TestProfile;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import java.nio.ByteBuffer;
+import java.util.Map;
+
+class Profiles {
+    public static class DhfsFuseTestProfile extends TempDataProfile {
+        @Override
+        protected void getConfigOverrides(Map<String, String> ret) {
+            ret.put("quarkus.log.category.\"com.usatiuk.dhfs\".level", "INFO");
+            ret.put("dhfs.fuse.enabled", "false");
+            ret.put("dhfs.objects.ref_verification", "false");
+        }
+    }
+}
+
+@QuarkusTest
+@TestProfile(Profiles.DhfsFuseTestProfile.class)
+public class DhfsFileBenchmarkTest {
+    @Inject
+    DhfsFileService dhfsFileService;
+
+    @Test
+    @Disabled
+    void openRootTest() {
+        Benchmarker.runAndPrintMixSimple("dhfsFileService.open(\"\")",
+                () -> {
+                    return dhfsFileService.open("");
+                }, 1_000_000, 5, 1000, 5, 1000);
+    }
+
+    @Test
+    @Disabled
+    void writeMbTest() {
+        JObjectKey file = dhfsFileService.create("/writeMbTest", 0777).get();
+        var bb = ByteBuffer.allocateDirect(1024 * 1024);
+        Benchmarker.runAndPrintMixSimple("dhfsFileService.write(\"\")",
+                () -> {
+                    var thing = UnsafeByteOperations.unsafeWrap(bb);
+                    return dhfsFileService.write(file, dhfsFileService.size(file), thing);
+                }, 1_000, 10, 100, 1, 100);
+    }
+}

dhfs-parent/dhfs-fs/src/test/java/com/usatiuk/dhfs/files/DhfsFileServiceSimpleTest.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfs;
+package com.usatiuk.dhfs.files;
 
 import io.quarkus.test.junit.QuarkusTest;
 import io.quarkus.test.junit.TestProfile;

dhfs-parent/dhfs-fs/src/test/java/com/usatiuk/dhfs/files/DhfsFileServiceSimpleTestImpl.java

@@ -1,8 +1,9 @@
-package com.usatiuk.dhfsfs;
+package com.usatiuk.dhfs.files;
 
-import com.usatiuk.dhfs.remoteobj.RemoteTransaction;
-import com.usatiuk.dhfsfs.objects.File;
-import com.usatiuk.dhfsfs.service.DhfsFileService;
+import com.usatiuk.dhfs.RemoteTransaction;
+import com.usatiuk.dhfs.TempDataProfile;
+import com.usatiuk.dhfs.files.objects.File;
+import com.usatiuk.dhfs.files.service.DhfsFileService;
 import com.usatiuk.kleppmanntree.AlreadyExistsException;
 import com.usatiuk.objects.transaction.Transaction;
 import com.usatiuk.objects.transaction.TransactionManager;
@@ -89,7 +90,7 @@ public abstract class DhfsFileServiceSimpleTestImpl {
 //            for (int start = 0; start < all.length(); start++) {
 //                for (int end = start; end <= all.length(); end++) {
 //                    var read = fileService.read(fuuid.toString(), start, end - start);
-//                    Assertions.assertArrayEquals(all.substring(start, end).getBytes(), read.toByteArray());
+//                    Assertions.assertArrayEquals(all.substring(start, end).getBytes(), read.get().toByteArray());
 //                }
 //            }
 //        }
@@ -110,21 +111,17 @@ public abstract class DhfsFileServiceSimpleTestImpl {
 
         var uuid = ret.get();
 
-        var curMtime = fileService.getattr(uuid).get().mtime();
         fileService.write(uuid, 0, new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).toByteArray());
-        Assertions.assertArrayEquals(new byte[]{2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 2, 8).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).get().toByteArray());
+        Assertions.assertArrayEquals(new byte[]{2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 2, 8).get().toByteArray());
         fileService.write(uuid, 4, new byte[]{10, 11, 12});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 10, 11, 12, 7, 8, 9}, fileService.read(uuid, 0, 10).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 10, 11, 12, 7, 8, 9}, fileService.read(uuid, 0, 10).get().toByteArray());
         fileService.write(uuid, 10, new byte[]{13, 14});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 10, 11, 12, 7, 8, 9, 13, 14}, fileService.read(uuid, 0, 12).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 10, 11, 12, 7, 8, 9, 13, 14}, fileService.read(uuid, 0, 12).get().toByteArray());
         fileService.write(uuid, 6, new byte[]{15, 16});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 10, 11, 15, 16, 8, 9, 13, 14}, fileService.read(uuid, 0, 12).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 10, 11, 15, 16, 8, 9, 13, 14}, fileService.read(uuid, 0, 12).get().toByteArray());
         fileService.write(uuid, 3, new byte[]{17, 18});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 17, 18, 11, 15, 16, 8, 9, 13, 14}, fileService.read(uuid, 0, 12).toByteArray());
-
-        var newMtime = fileService.getattr(uuid).get().mtime();
-        Assertions.assertTrue(newMtime > curMtime);
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 17, 18, 11, 15, 16, 8, 9, 13, 14}, fileService.read(uuid, 0, 12).get().toByteArray());
 
         fileService.unlink("/writeTest");
         Assertions.assertFalse(fileService.open("/writeTest").isPresent());
@@ -138,7 +135,7 @@ public abstract class DhfsFileServiceSimpleTestImpl {
         var uuid = ret.get();
 
         fileService.write(uuid, 0, new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).get().toByteArray());
 
         fileService.unlink("/removeTest");
         Assertions.assertFalse(fileService.open("/removeTest").isPresent());
@@ -152,12 +149,12 @@ public abstract class DhfsFileServiceSimpleTestImpl {
         var uuid = ret.get();
 
         fileService.write(uuid, 0, new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).get().toByteArray());
 
         fileService.truncate(uuid, 20);
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, fileService.read(uuid, 0, 20).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, fileService.read(uuid, 0, 20).get().toByteArray());
         fileService.write(uuid, 5, new byte[]{10, 11, 12, 13, 14, 15, 16, 17});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 15, 16, 17, 0, 0, 0, 0, 0, 0, 0}, fileService.read(uuid, 0, 20).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 15, 16, 17, 0, 0, 0, 0, 0, 0, 0}, fileService.read(uuid, 0, 20).get().toByteArray());
     }
 
     @RepeatedTest(100)
@@ -169,12 +166,12 @@ public abstract class DhfsFileServiceSimpleTestImpl {
             var uuid = ret.get();
 
             fileService.write(uuid, 0, new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-            Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).toByteArray());
+            Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).get().toByteArray());
 
             fileService.truncate(uuid, 20);
-            Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, fileService.read(uuid, 0, 20).toByteArray());
+            Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, fileService.read(uuid, 0, 20).get().toByteArray());
             fileService.write(uuid, 10, new byte[]{11, 12, 13, 14, 15, 16, 17, 18, 19, 20});
-            Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}, fileService.read(uuid, 0, 20).toByteArray());
+            Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}, fileService.read(uuid, 0, 20).get().toByteArray());
         } finally {
             fileService.unlink("/truncateTest2");
         }
@@ -188,10 +185,10 @@ public abstract class DhfsFileServiceSimpleTestImpl {
         var uuid = ret.get();
 
         fileService.write(uuid, 0, new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).get().toByteArray());
 
         fileService.truncate(uuid, 7);
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6,}, fileService.read(uuid, 0, 20).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6,}, fileService.read(uuid, 0, 20).get().toByteArray());
     }
 
     @Test
@@ -201,14 +198,14 @@ public abstract class DhfsFileServiceSimpleTestImpl {
         var uuid = ret.get();
 
         fileService.write(uuid, 0, new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).get().toByteArray());
 
         Assertions.assertTrue(fileService.rename("/moveTest", "/movedTest"));
         Assertions.assertFalse(fileService.open("/moveTest").isPresent());
         Assertions.assertTrue(fileService.open("/movedTest").isPresent());
 
         Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
-                fileService.read(fileService.open("/movedTest").get(), 0, 10).toByteArray());
+                fileService.read(fileService.open("/movedTest").get(), 0, 10).get().toByteArray());
     }
 
     @Test
@@ -221,9 +218,9 @@ public abstract class DhfsFileServiceSimpleTestImpl {
         var uuid2 = ret2.get();
 
         fileService.write(uuid, 0, new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).get().toByteArray());
         fileService.write(uuid2, 0, new byte[]{11, 12, 13, 14, 15, 16, 17, 18, 19, 29});
-        Assertions.assertArrayEquals(new byte[]{11, 12, 13, 14, 15, 16, 17, 18, 19, 29}, fileService.read(uuid2, 0, 10).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{11, 12, 13, 14, 15, 16, 17, 18, 19, 29}, fileService.read(uuid2, 0, 10).get().toByteArray());
 
 
         jObjectTxManager.run(() -> {
@@ -237,7 +234,7 @@ public abstract class DhfsFileServiceSimpleTestImpl {
         Assertions.assertTrue(fileService.open("/moveOverTest2").isPresent());
 
         Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
-                fileService.read(fileService.open("/moveOverTest2").get(), 0, 10).toByteArray());
+                fileService.read(fileService.open("/moveOverTest2").get(), 0, 10).get().toByteArray());
 
 //        await().atMost(5, TimeUnit.SECONDS).until(() -> {
 //                jObjectTxManager.run(() -> {
@@ -255,8 +252,8 @@ public abstract class DhfsFileServiceSimpleTestImpl {
         var uuid = ret.get();
 
         fileService.write(uuid, 0, new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).toByteArray());
-        Assertions.assertArrayEquals(new byte[]{}, fileService.read(uuid, 20, 10).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).get().toByteArray());
+        Assertions.assertArrayEquals(new byte[]{}, fileService.read(uuid, 20, 10).get().toByteArray());
     }
 
     @Test
@@ -266,13 +263,13 @@ public abstract class DhfsFileServiceSimpleTestImpl {
         var uuid = ret.get();
 
         fileService.write(uuid, 0, new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).get().toByteArray());
         fileService.write(uuid, 20, new byte[]{10, 11, 12, 13, 14, 15, 16, 17, 18, 19});
         Assertions.assertArrayEquals(new byte[]{
                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
-        }, fileService.read(uuid, 0, 30).toByteArray());
+        }, fileService.read(uuid, 0, 30).get().toByteArray());
     }
 
     @Test
@@ -282,7 +279,7 @@ public abstract class DhfsFileServiceSimpleTestImpl {
         var uuid = ret.get();
 
         fileService.write(uuid, 0, new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
-        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).toByteArray());
+        Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, fileService.read(uuid, 0, 10).get().toByteArray());
 
 //        var oldfile = jObjectManager.get(uuid).orElseThrow(IllegalStateException::new);
 //        var chunk = oldfile.runReadLocked(JObjectManager.ResolutionStrategy.LOCAL_ONLY, (m, d) -> d.extractRefs()).stream().toList().get(0);
@@ -297,6 +294,6 @@ public abstract class DhfsFileServiceSimpleTestImpl {
         Assertions.assertTrue(fileService.open("/movedTest2").isPresent());
 
         Assertions.assertArrayEquals(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
-                fileService.read(fileService.open("/movedTest2").get(), 0, 10).toByteArray());
+                fileService.read(fileService.open("/movedTest2").get(), 0, 10).get().toByteArray());
     }
 }

dhfs-parent/dhfs-fs/src/test/java/com/usatiuk/dhfs/files/DhfsFileServiceSimpleTestNoChunkingTest.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfs;
+package com.usatiuk.dhfs.files;
 
 import io.quarkus.test.junit.QuarkusTest;
 import io.quarkus.test.junit.TestProfile;

dhfs-parent/dhfs-fs/src/test/java/com/usatiuk/dhfs/files/DhfsFileServiceSimpleTestSmallChunkingTest.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfs;
+package com.usatiuk.dhfs.files;
 
 import io.quarkus.test.junit.QuarkusTest;
 import io.quarkus.test.junit.TestProfile;

dhfs-parent/dhfs-fs/src/test/resources/application.properties

@@ -1,9 +1,11 @@
-dhfs.objects.persistence.root=${HOME}/dhfs_data/dhfs_root_test
+dhfs.objects.persistence.files.root=${HOME}/dhfs_data/dhfs_root_test
+dhfs.objects.root=${HOME}/dhfs_data/dhfs_root_d_test
 dhfs.fuse.root=${HOME}/dhfs_data/dhfs_fuse_root_test
 dhfs.objects.ref_verification=true
 dhfs.objects.deletion.delay=0
 quarkus.log.category."com.usatiuk.dhfs".level=TRACE
 quarkus.log.category."com.usatiuk.dhfs".min-level=TRACE
+quarkus.class-loading.parent-first-artifacts=com.usatiuk.dhfs:supportlib
 quarkus.http.test-port=0
 quarkus.http.test-ssl-port=0
 dhfs.local-discovery=false

dhfs-parent/dhfs-fuse/docker-compose.yml

@@ -11,7 +11,8 @@ services:
       - $HOME/dhfs/dhfs1_f:/dhfs_root/fuse:rshared
       - ./target/quarkus-app:/app
     command: "java --add-exports java.base/sun.nio.ch=ALL-UNNAMED
-     -Ddhfs.objects.persistence.root=/dhfs_root/p 
+     -Ddhfs.objects.persistence.files.root=/dhfs_root/p 
+     -Ddhfs.objects.root=/dhfs_root/d 
      -Ddhfs.fuse.root=/dhfs_root/fuse -Dquarkus.http.host=0.0.0.0 
      -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005
      -jar /app/quarkus-run.jar"
@@ -31,7 +32,8 @@ services:
     command: "java --add-exports java.base/sun.nio.ch=ALL-UNNAMED
      --add-exports java.base/jdk.internal.access=ALL-UNNAMED
      --add-opens=java.base/java.nio=ALL-UNNAMED
-     -Ddhfs.objects.persistence.root=/dhfs_root/p 
+     -Ddhfs.objects.persistence.files.root=/dhfs_root/p 
+     -Ddhfs.objects.root=/dhfs_root/d 
      -Ddhfs.fuse.root=/dhfs_root/fuse -Dquarkus.http.host=0.0.0.0
      -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5010
      -jar /app/quarkus-run.jar"

dhfs-parent/dhfs-fuse/pom.xml

@@ -23,10 +23,22 @@
             <artifactId>awaitility</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcprov-jdk18on</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcpkix-jdk18on</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-security</artifactId>
         </dependency>
+        <dependency>
+            <groupId>net.openhft</groupId>
+            <artifactId>zero-allocation-hashing</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-grpc</artifactId>
@@ -35,6 +47,14 @@
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-arc</artifactId>
         </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.quarkus</groupId>
+            <artifactId>quarkus-rest-client</artifactId>
+        </dependency>
         <dependency>
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-rest-client-jsonb</artifactId>
@@ -53,9 +73,24 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>com.github.serceman</groupId>
+            <groupId>com.github.SerCeMan</groupId>
             <artifactId>jnr-fuse</artifactId>
-            <version>0.5.8</version>
+            <version>44ed40f8ce</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.jnr</groupId>
+            <artifactId>jnr-ffi</artifactId>
+            <version>2.2.16</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.jnr</groupId>
+            <artifactId>jnr-posix</artifactId>
+            <version>3.1.19</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.jnr</groupId>
+            <artifactId>jnr-constants</artifactId>
+            <version>0.10.4</version>
         </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
@@ -70,6 +105,10 @@
             <artifactId>slf4j-jboss-logmanager</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-collections4</artifactId>
@@ -78,11 +117,36 @@
             <groupId>org.pcollections</groupId>
             <artifactId>pcollections</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>3.6.1</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk</groupId>
+            <artifactId>kleppmanntree</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>supportlib</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>objects</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
         <dependency>
             <groupId>com.usatiuk.dhfs</groupId>
             <artifactId>dhfs-fs</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>sync-base</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
         <dependency>
             <groupId>com.usatiuk.dhfs</groupId>
             <artifactId>utils</artifactId>
@@ -110,13 +174,16 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-failsafe-plugin</artifactId>
                 <configuration>
-                    <forkCount>1C</forkCount>
-                    <reuseForks>false</reuseForks>
-                    <parallel>classes</parallel>
                     <systemPropertyVariables>
                         <junit.jupiter.execution.parallel.enabled>
-                            false
+                            true
                         </junit.jupiter.execution.parallel.enabled>
+                        <junit.jupiter.execution.parallel.mode.default>
+                            concurrent
+                        </junit.jupiter.execution.parallel.mode.default>
+                        <junit.jupiter.execution.parallel.config.dynamic.factor>
+                            0.5
+                        </junit.jupiter.execution.parallel.config.dynamic.factor>
                         <junit.platform.output.capture.stdout>true</junit.platform.output.capture.stdout>
                         <junit.platform.output.capture.stderr>true</junit.platform.output.capture.stderr>
                     </systemPropertyVariables>

dhfs-parent/dhfs-fuse/src/main/java/com/usatiuk/dhfs/fuse/DhfsFuse.java

@@ -1,15 +1,13 @@
-package com.usatiuk.dhfsfuse;
+package com.usatiuk.dhfs.fuse;
 
 import com.google.protobuf.UnsafeByteOperations;
-import com.kenai.jffi.MemoryIO;
 import com.sun.security.auth.module.UnixSystem;
-import com.usatiuk.dhfsfs.service.DhfsFileService;
-import com.usatiuk.dhfsfs.service.DirectoryNotEmptyException;
-import com.usatiuk.dhfsfs.service.GetattrRes;
+import com.usatiuk.dhfs.files.service.DhfsFileService;
+import com.usatiuk.dhfs.files.service.DirectoryNotEmptyException;
+import com.usatiuk.dhfs.files.service.GetattrRes;
+import com.usatiuk.dhfs.supportlib.UninitializedByteBuffer;
 import com.usatiuk.kleppmanntree.AlreadyExistsException;
 import com.usatiuk.objects.JObjectKey;
-import com.usatiuk.utils.UninitializedByteBuffer;
-import com.usatiuk.utils.UnsafeAccessor;
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
 import io.quarkus.logging.Log;
@@ -20,17 +18,16 @@ import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.enterprise.event.Observes;
 import jakarta.inject.Inject;
 import jnr.ffi.Pointer;
-import jnr.ffi.Runtime;
-import jnr.ffi.Struct;
-import jnr.ffi.types.off_t;
 import org.apache.commons.lang3.SystemUtils;
 import org.eclipse.microprofile.config.inject.ConfigProperty;
 import ru.serce.jnrfuse.ErrorCodes;
 import ru.serce.jnrfuse.FuseFillDir;
 import ru.serce.jnrfuse.FuseStubFS;
-import ru.serce.jnrfuse.struct.*;
+import ru.serce.jnrfuse.struct.FileStat;
+import ru.serce.jnrfuse.struct.FuseFileInfo;
+import ru.serce.jnrfuse.struct.Statvfs;
+import ru.serce.jnrfuse.struct.Timespec;
 
-import java.nio.ByteBuffer;
 import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.Optional;
@@ -39,30 +36,26 @@ import java.util.concurrent.atomic.AtomicLong;
 
 import static jnr.posix.FileStat.*;
 
-/**
- * FUSE file system implementation.
- */
 @ApplicationScoped
 public class DhfsFuse extends FuseStubFS {
     private static final int blksize = 1048576;
     private static final int iosize = 1048576;
-    private final ConcurrentHashMap<Long, JObjectKey> _openHandles = new ConcurrentHashMap<>();
-    private final AtomicLong _fh = new AtomicLong(1);
     @ConfigProperty(name = "dhfs.fuse.root")
     String root;
     @ConfigProperty(name = "dhfs.fuse.enabled")
     boolean enabled;
     @ConfigProperty(name = "dhfs.fuse.debug")
     Boolean debug;
+    @ConfigProperty(name = "dhfs.files.target_chunk_size")
+    int targetChunkSize;
+    @Inject
+    JnrPtrByteOutputAccessors jnrPtrByteOutputAccessors;
     @Inject
     DhfsFileService fileService;
 
-    /**
-     * Allocate a handle for the given key.
-     *
-     * @param key the key to allocate a handle for
-     * @return the allocated handle, not 0
-     */
+    private final ConcurrentHashMap<Long, JObjectKey> _openHandles = new ConcurrentHashMap<>();
+    private final AtomicLong _fh = new AtomicLong(1);
+
     private long allocateHandle(JObjectKey key) {
         while (true) {
             var newFh = _fh.getAndIncrement();
@@ -73,61 +66,47 @@ public class DhfsFuse extends FuseStubFS {
         }
     }
 
-    /**
-     * Get the key from the handle.
-     *
-     * @param handle the handle to get the key from
-     * @return the key, or null if not found
-     */
     private JObjectKey getFromHandle(long handle) {
-        if (handle == 0)
-            throw new IllegalStateException("Handle is 0");
+        assert handle != 0;
         return _openHandles.get(handle);
     }
 
     void init(@Observes @Priority(100000) StartupEvent event) {
         if (!enabled) return;
+        Paths.get(root).toFile().mkdirs();
+
+        if (!Paths.get(root).toFile().isDirectory())
+            throw new IllegalStateException("Could not create directory " + root);
 
         Log.info("Mounting with root " + root);
+
+        var uid = new UnixSystem().getUid();
+        var gid = new UnixSystem().getGid();
+
         var opts = new ArrayList<String>();
 
-        if (SystemUtils.IS_OS_WINDOWS) {
+        // Assuming macFuse
+        if (SystemUtils.IS_OS_MAC) {
             opts.add("-o");
-            opts.add("auto_cache");
-            opts.add("-o");
-            opts.add("uid=-1");
-            opts.add("-o");
-            opts.add("gid=-1");
-        } else {
-            Paths.get(root).toFile().mkdirs();
-
-            if (!Paths.get(root).toFile().isDirectory())
-                throw new IllegalStateException("Could not create directory " + root);
-
-            var uid = new UnixSystem().getUid();
-            var gid = new UnixSystem().getGid();
-
-            // Assuming macFuse
-            if (SystemUtils.IS_OS_MAC) {
-                opts.add("-o");
-                opts.add("iosize=" + iosize);
-            } else if (SystemUtils.IS_OS_LINUX) {
+            opts.add("iosize=" + iosize);
+        } else if (SystemUtils.IS_OS_LINUX) {
+            // FIXME: There's something else missing: the writes still seem to be 32k max
 //            opts.add("-o");
 //            opts.add("large_read");
-                opts.add("-o");
-                opts.add("big_writes");
-                opts.add("-o");
-                opts.add("max_read=" + iosize);
-                opts.add("-o");
-                opts.add("max_write=" + iosize);
-            }
             opts.add("-o");
-            opts.add("auto_cache");
+            opts.add("big_writes");
             opts.add("-o");
-            opts.add("uid=" + uid);
+            opts.add("max_read=" + iosize);
             opts.add("-o");
-            opts.add("gid=" + gid);
+            opts.add("max_write=" + iosize);
         }
+        opts.add("-o");
+        opts.add("auto_cache");
+        opts.add("-o");
+        opts.add("uid=" + uid);
+        opts.add("-o");
+        opts.add("gid=" + gid);
+
         mount(Paths.get(root), false, debug, opts.toArray(String[]::new));
     }
 
@@ -143,12 +122,13 @@ public class DhfsFuse extends FuseStubFS {
         try {
             stbuf.f_frsize.set(blksize);
             stbuf.f_bsize.set(blksize);
-            stbuf.f_blocks.set(fileService.getTotalSpace() / blksize); // total data blocks in file system
-            stbuf.f_bfree.set(fileService.getFreeSpace() / blksize);  // free blocks in fs
-            stbuf.f_bavail.set(fileService.getFreeSpace() / blksize); // avail blocks in fs
-            stbuf.f_files.set(1000); // TODO: Calculate real file counts?
-            stbuf.f_ffree.set(Integer.MAX_VALUE - 1000);
-            stbuf.f_favail.set(Integer.MAX_VALUE - 1000);
+            // FIXME:
+            stbuf.f_blocks.set(1024 * 1024 * 1024 / blksize); // total data blocks in file system
+            stbuf.f_bfree.set(1024 * 1024 * 1024 / blksize);  // free blocks in fs
+            stbuf.f_bavail.set(1024 * 1024 * 1024 / blksize); // avail blocks in fs
+            stbuf.f_files.set(1000); //FIXME:
+            stbuf.f_ffree.set(Integer.MAX_VALUE - 2000); //FIXME:
+            stbuf.f_favail.set(Integer.MAX_VALUE - 2000); //FIXME:
             stbuf.f_namemax.set(2048);
             return super.statfs(path, stbuf);
         } catch (Throwable e) {
@@ -184,13 +164,13 @@ public class DhfsFuse extends FuseStubFS {
                 }
             }
 
+            // FIXME: Race?
             stat.st_ctim.tv_sec.set(found.get().ctime() / 1000);
             stat.st_ctim.tv_nsec.set((found.get().ctime() % 1000) * 1000);
             stat.st_mtim.tv_sec.set(found.get().mtime() / 1000);
             stat.st_mtim.tv_nsec.set((found.get().mtime() % 1000) * 1000);
-            var atime = Math.max(found.get().ctime(), found.get().mtime());
-            stat.st_atim.tv_sec.set(atime / 1000);
-            stat.st_atim.tv_nsec.set((atime % 1000) * 1000000L);
+            stat.st_atim.tv_sec.set(found.get().mtime() / 1000);
+            stat.st_atim.tv_nsec.set((found.get().mtime() % 1000) * 1000);
             stat.st_blksize.set(blksize);
         } catch (Throwable e) {
             Log.error("When getattr " + path, e);
@@ -206,7 +186,8 @@ public class DhfsFuse extends FuseStubFS {
             if (fileOpt.isEmpty()) return -ErrorCodes.ENOENT();
             var file = fileOpt.get();
             var res = fileService.setTimes(file,
-                    timespec[1].tv_sec.get() * 1000L + timespec[1].tv_nsec.longValue() / 1000000L);
+                    timespec[0].tv_sec.get() * 1000,
+                    timespec[1].tv_sec.get() * 1000);
             if (!res) return -ErrorCodes.EINVAL();
             else return 0;
         } catch (Throwable e) {
@@ -243,8 +224,8 @@ public class DhfsFuse extends FuseStubFS {
             var fileKey = getFromHandle(fi.fh.get());
             var read = fileService.read(fileKey, offset, (int) size);
             if (read.isEmpty()) return 0;
-            UnsafeByteOperations.unsafeWriteTo(read, new JnrPtrByteOutput(buf, size));
-            return read.size();
+            UnsafeByteOperations.unsafeWriteTo(read.get(), new JnrPtrByteOutput(jnrPtrByteOutputAccessors, buf, size));
+            return read.get().size();
         } catch (Throwable e) {
             Log.error("When reading " + path, e);
             return -ErrorCodes.EIO();
@@ -253,22 +234,24 @@ public class DhfsFuse extends FuseStubFS {
 
     @Override
     public int write(String path, Pointer buf, long size, long offset, FuseFileInfo fi) {
-        var buffer = UninitializedByteBuffer.allocate((int) size);
-        UnsafeAccessor.UNSAFE.copyMemory(
-                buf.address(),
-                UnsafeAccessor.NIO.getBufferAddress(buffer),
-                size
-        );
-        return write(path, buffer, offset, fi);
-    }
-
-    public int write(String path, ByteBuffer buffer, long offset, FuseFileInfo fi) {
         if (offset < 0) return -ErrorCodes.EINVAL();
         try {
             var fileKey = getFromHandle(fi.fh.get());
+            var buffer = UninitializedByteBuffer.allocateUninitialized((int) size);
+
+            if (buffer.isDirect()) {
+                jnrPtrByteOutputAccessors.getUnsafe().copyMemory(
+                        buf.address(),
+                        jnrPtrByteOutputAccessors.getNioAccess().getBufferAddress(buffer),
+                        size
+                );
+            } else {
+                buf.get(0, buffer.array(), 0, (int) size);
+            }
+
             var written = fileService.write(fileKey, offset, UnsafeByteOperations.unsafeWrap(buffer));
-            return Math.toIntExact(written);
-        } catch (Exception e) {
+            return written.intValue();
+        } catch (Throwable e) {
             Log.error("When writing " + path, e);
             return -ErrorCodes.EIO();
         }
@@ -404,7 +387,7 @@ public class DhfsFuse extends FuseStubFS {
             var file = fileOpt.get();
             var read = fileService.readlinkBS(fileOpt.get());
             if (read.isEmpty()) return 0;
-            UnsafeByteOperations.unsafeWriteTo(read, new JnrPtrByteOutput(buf, size));
+            UnsafeByteOperations.unsafeWriteTo(read, new JnrPtrByteOutput(jnrPtrByteOutputAccessors, buf, size));
             buf.putByte(Math.min(size - 1, read.size()), (byte) 0);
             return 0;
         } catch (Throwable e) {
@@ -436,29 +419,4 @@ public class DhfsFuse extends FuseStubFS {
             return -ErrorCodes.EIO();
         }
     }
-
-    @Override
-    public int write_buf(String path, FuseBufvec buf, @off_t long off, FuseFileInfo fi) {
-        int size = (int) libFuse.fuse_buf_size(buf);
-        FuseBufvec tmpVec = new FuseBufvec(Runtime.getSystemRuntime());
-        long tmpVecAddr = MemoryIO.getInstance().allocateMemory(Struct.size(tmpVec), false);
-        try {
-            tmpVec.useMemory(Pointer.wrap(Runtime.getSystemRuntime(), tmpVecAddr));
-            FuseBufvec.init(tmpVec, size);
-            var bb = UninitializedByteBuffer.allocate(size);
-            var mem = UninitializedByteBuffer.getAddress(bb);
-            tmpVec.buf.mem.set(mem);
-            tmpVec.buf.size.set(size);
-            int res = (int) libFuse.fuse_buf_copy(tmpVec, buf, 0);
-            if (res != size) {
-                Log.errorv("fuse_buf_copy failed: {0} != {1}", res, size);
-                return -ErrorCodes.ENOMEM();
-            }
-            return write(path, bb, off, fi);
-        } finally {
-            if (tmpVecAddr != 0) {
-                MemoryIO.getInstance().freeMemory(tmpVecAddr);
-            }
-        }
-    }
 }

dhfs-parent/dhfs-fuse/src/main/java/com/usatiuk/dhfs/fuse/JnrPtrByteOutput.java

@@ -1,24 +1,22 @@
-package com.usatiuk.dhfsfuse;
+package com.usatiuk.dhfs.fuse;
 
 import com.google.protobuf.ByteOutput;
-import com.usatiuk.utils.UnsafeAccessor;
 import jnr.ffi.Pointer;
 
 import java.nio.ByteBuffer;
 import java.nio.MappedByteBuffer;
 
-/**
- * JnrPtrByteOutput is a ByteOutput implementation that writes to a `jnr.ffi.Pointer`.
- */
 public class JnrPtrByteOutput extends ByteOutput {
     private final Pointer _backing;
     private final long _size;
+    private final JnrPtrByteOutputAccessors _accessors;
     private long _pos;
 
-    public JnrPtrByteOutput(Pointer backing, long size) {
+    public JnrPtrByteOutput(JnrPtrByteOutputAccessors accessors, Pointer backing, long size) {
         _backing = backing;
         _size = size;
         _pos = 0;
+        _accessors = accessors;
     }
 
     @Override
@@ -49,9 +47,9 @@ public class JnrPtrByteOutput extends ByteOutput {
             if (value instanceof MappedByteBuffer mb) {
                 mb.load();
             }
-            long addr = UnsafeAccessor.NIO.getBufferAddress(value) + value.position();
+            long addr = _accessors.getNioAccess().getBufferAddress(value) + value.position();
             var out = _backing.address() + _pos;
-            UnsafeAccessor.UNSAFE.copyMemory(addr, out, rem);
+            _accessors.getUnsafe().copyMemory(addr, out, rem);
         } else {
             _backing.put(_pos, value.array(), value.arrayOffset() + value.position(), rem);
         }

dhfs-parent/dhfs-fuse/src/main/java/com/usatiuk/dhfs/fuse/JnrPtrByteOutputAccessors.java

@@ -0,0 +1,29 @@
+package com.usatiuk.dhfs.fuse;
+
+import jakarta.inject.Singleton;
+import jdk.internal.access.JavaNioAccess;
+import jdk.internal.access.SharedSecrets;
+import sun.misc.Unsafe;
+
+import java.lang.reflect.Field;
+
+@Singleton
+class JnrPtrByteOutputAccessors {
+    JavaNioAccess _nioAccess;
+    Unsafe _unsafe;
+
+    JnrPtrByteOutputAccessors() throws NoSuchFieldException, IllegalAccessException {
+        _nioAccess = SharedSecrets.getJavaNioAccess();
+        Field f = Unsafe.class.getDeclaredField("theUnsafe");
+        f.setAccessible(true);
+        _unsafe = (Unsafe) f.get(null);
+    }
+
+    public JavaNioAccess getNioAccess() {
+        return _nioAccess;
+    }
+
+    public Unsafe getUnsafe() {
+        return _unsafe;
+    }
+}

dhfs-parent/dhfs-fuse/src/main/resources/application.properties

@@ -1,21 +1,31 @@
 quarkus.grpc.server.use-separate-server=false
+dhfs.objects.peerdiscovery.port=42069
 dhfs.objects.peerdiscovery.interval=4s
+dhfs.objects.peerdiscovery.broadcast=true
 dhfs.objects.sync.timeout=30
 dhfs.objects.sync.ping.timeout=5
 dhfs.objects.invalidation.threads=16
 dhfs.objects.invalidation.delay=1000
+dhfs.objects.reconnect_interval=5s
+dhfs.objects.write_log=false
+dhfs.objects.periodic-push-op-interval=5m
 dhfs.fuse.root=${HOME}/dhfs_default/fuse
 dhfs.objects.persistence.stuff.root=${HOME}/dhfs_default/data/stuff
 dhfs.fuse.debug=false
 dhfs.fuse.enabled=true
 dhfs.files.allow_recursive_delete=false
+dhfs.files.target_chunk_size=2097152
+dhfs.files.target_chunk_alignment=19
 dhfs.objects.deletion.delay=1000
 dhfs.objects.deletion.can-delete-retry-delay=10000
 dhfs.objects.ref_verification=true
-dhfs.objects.autosync.threads=8
+dhfs.files.use_hash_for_chunks=false
+dhfs.objects.autosync.threads=16
 dhfs.objects.autosync.download-all=false
-dhfs.objects.move-processor.threads=8
-dhfs.objects.ref-processor.threads=8
+dhfs.objects.move-processor.threads=16
+dhfs.objects.ref-processor.threads=16
+dhfs.objects.opsender.batch-size=100
+dhfs.objects.lock_timeout_secs=2
 dhfs.local-discovery=true
 dhfs.peerdiscovery.timeout=10000
 quarkus.log.category."com.usatiuk".min-level=TRACE

dhfs-parent/dhfs-fuse/src/test/java/com/usatiuk/dhfs/TempDataProfile.java

@@ -0,0 +1,29 @@
+package com.usatiuk.dhfs;
+
+import io.quarkus.test.junit.QuarkusTestProfile;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.Map;
+
+abstract public class TempDataProfile implements QuarkusTestProfile {
+    protected void getConfigOverrides(Map<String, String> toPut) {
+    }
+
+    @Override
+    final public Map<String, String> getConfigOverrides() {
+        Path tempDirWithPrefix;
+        try {
+            tempDirWithPrefix = Files.createTempDirectory("dhfs-test");
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        var ret = new HashMap<String, String>();
+        ret.put("dhfs.objects.persistence.files.root", tempDirWithPrefix.resolve("dhfs_root_test").toString());
+        ret.put("dhfs.fuse.root", tempDirWithPrefix.resolve("dhfs_fuse_root_test").toString());
+        getConfigOverrides(ret);
+        return ret;
+    }
+}

dhfs-parent/dhfs-fuse/src/test/java/com/usatiuk/dhfs/TestDataCleaner.java

@@ -1,4 +1,4 @@
-package com.usatiuk.dhfsfuse;
+package com.usatiuk.dhfs;
 
 import io.quarkus.logging.Log;
 import io.quarkus.runtime.ShutdownEvent;
@@ -15,7 +15,7 @@ import java.util.Objects;
 
 @ApplicationScoped
 public class TestDataCleaner {
-    @ConfigProperty(name = "dhfs.objects.persistence.root")
+    @ConfigProperty(name = "dhfs.objects.persistence.files.root")
     String tempDirectory;
 
     void init(@Observes @Priority(1) StartupEvent event) throws IOException {
@@ -30,7 +30,7 @@ public class TestDataCleaner {
         purgeDirectory(Path.of(tempDirectory).toFile());
     }
 
-    public static void purgeDirectory(File dir) {
+    void purgeDirectory(File dir) {
         for (File file : Objects.requireNonNull(dir.listFiles())) {
             if (file.isDirectory())
                 purgeDirectory(file);

dhfs-parent/dhfs-fuse/src/test/java/com/usatiuk/dhfs/fuse/DhfsFuseTest.java

@@ -1,5 +1,6 @@
-package com.usatiuk.dhfsfuse;
+package com.usatiuk.dhfs.fuse;
 
+import com.usatiuk.dhfs.TempDataProfile;
 import io.quarkus.test.junit.QuarkusTest;
 import io.quarkus.test.junit.TestProfile;
 import org.eclipse.microprofile.config.inject.ConfigProperty;

dhfs-parent/dhfs-fuse/src/test/java/com/usatiuk/dhfsfuse/integration/LazyFs.java

@@ -1,215 +0,0 @@
-package com.usatiuk.dhfsfuse.integration;
-
-import io.quarkus.logging.Log;
-
-import java.io.*;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ThreadLocalRandom;
-import java.util.concurrent.TimeUnit;
-
-public class LazyFs {
-    private static final String lazyFsPath;
-
-    static {
-        lazyFsPath = System.getProperty("lazyFsPath");
-        System.out.println("LazyFs Path: " + lazyFsPath);
-    }
-
-    private final String mountRoot;
-    private final String dataRoot;
-    private final String name;
-    private final File configFile;
-    private final File fifoFile;
-    private Thread errPiper;
-    private Thread outPiper;
-    private CountDownLatch startLatch;
-    private Process fs;
-    public LazyFs(String name, String mountRoot, String dataRoot) {
-        this.name = name;
-        this.mountRoot = mountRoot;
-        this.dataRoot = dataRoot;
-
-        try {
-            configFile = File.createTempFile("lazyfs", ".conf");
-            configFile.deleteOnExit();
-
-            fifoFile = new File("/tmp/" + ThreadLocalRandom.current().nextLong() + ".faultsfifo");
-            fifoFile.deleteOnExit();
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-
-        Runtime.getRuntime().addShutdownHook(new Thread(this::stop));
-    }
-
-    private String fifoPath() {
-        return fifoFile.getAbsolutePath();
-    }
-
-    public void start(String extraOpts) {
-        var lfsPath = Path.of(lazyFsPath).resolve("build").resolve("lazyfs");
-        if (!lfsPath.toFile().isFile())
-            throw new IllegalStateException("LazyFs binary does not exist: " + lfsPath.toAbsolutePath());
-        if (!lfsPath.toFile().canExecute())
-            throw new IllegalStateException("LazyFs binary is not executable: " + lfsPath.toAbsolutePath());
-
-        try (var rwFile = new RandomAccessFile(configFile, "rw");
-             var channel = rwFile.getChannel()) {
-            channel.truncate(0);
-            var config = "[faults]\n" +
-                    "fifo_path=\"" + fifoPath() + "\"\n" +
-                    "[cache]\n" +
-                    "apply_eviction=false\n" +
-                    "[cache.simple]\n" +
-                    "custom_size=\"1gb\"\n" +
-                    "blocks_per_page=1\n" +
-                    "[filesystem]\n" +
-                    "log_all_operations=false\n" +
-                    "logfile=\"\"\n" + extraOpts;
-            rwFile.write(config.getBytes());
-            Log.info("LazyFs config: \n" + config);
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-
-        var argList = new ArrayList<String>();
-
-        argList.add(lfsPath.toString());
-        argList.add(Path.of(mountRoot).toString());
-        argList.add("--config-path");
-        argList.add(configFile.getAbsolutePath());
-        argList.add("-o");
-        argList.add("allow_other");
-        argList.add("-o");
-        argList.add("modules=subdir");
-        argList.add("-o");
-        argList.add("subdir=" + Path.of(dataRoot).toAbsolutePath().toString());
-        try {
-            Log.info("Starting LazyFs " + argList);
-            fs = Runtime.getRuntime().exec(argList.toArray(String[]::new));
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-
-        startLatch = new CountDownLatch(1);
-
-        outPiper = new Thread(() -> {
-            try {
-                try (BufferedReader input = new BufferedReader(new InputStreamReader(fs.getInputStream()))) {
-                    String line;
-
-                    while ((line = input.readLine()) != null) {
-                        if (line.contains("running LazyFS"))
-                            startLatch.countDown();
-                        System.out.println(line);
-                    }
-                }
-            } catch (Exception e) {
-                Log.info("Exception in LazyFs piper", e);
-            }
-            Log.info("LazyFs out piper finished");
-        });
-        outPiper.start();
-        errPiper = new Thread(() -> {
-            try {
-                try (BufferedReader input = new BufferedReader(new InputStreamReader(fs.getErrorStream()))) {
-                    String line;
-
-                    while ((line = input.readLine()) != null) {
-                        System.out.println(line);
-                    }
-                }
-            } catch (Exception e) {
-                Log.info("Exception in LazyFs piper", e);
-            }
-            Log.info("LazyFs err piper finished");
-        });
-        errPiper.start();
-
-        try {
-            if (!startLatch.await(30, TimeUnit.SECONDS))
-                throw new RuntimeException("StartLatch timed out");
-        } catch (InterruptedException e) {
-            throw new RuntimeException(e);
-        }
-        Log.info("LazyFs started");
-    }
-
-    public void start() {
-        start("");
-    }
-
-    private String mdbPath() {
-        return Path.of(dataRoot).resolve("objects").resolve("data.mdb").toAbsolutePath().toString();
-    }
-
-    public void startTornOp() {
-        start("\n" +
-                "[[injection]]\n" +
-                "type=\"torn-seq\"\n" +
-                "op=\"write\"\n" +
-                "file=\"" + mdbPath() + "\"\n" +
-                "persist=[1,4]\n" +
-                "occurrence=3");
-    }
-
-    public void startTornSeq() {
-        start("[[injection]]\n" +
-                "type=\"torn-op\"\n" +
-                "file=\"" + mdbPath() + "\"\n" +
-                "occurrence=3\n" +
-                "parts=3 #or parts_bytes=[4096,3600,1260]\n" +
-                "persist=[1,3]");
-    }
-
-    public void crash() {
-        try {
-            var cmd = "echo \"lazyfs::crash::timing=after::op=write::from_rgx=*\" > " + fifoPath();
-            Log.info("Running command: " + cmd);
-            Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", cmd}).waitFor();
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    public void stop() {
-        try {
-            synchronized (this) {
-                Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", "fusermount3 -u " + mountRoot}).waitFor();
-            }
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-//    Doesn't actually work?
-//
-//    public void crashop() {
-//        try {
-//            var cmd = "echo \"lazyfs::torn-op::file=" + Path.of(lazyFsDataPath).toAbsolutePath().toString() + "/objects/data.mdb::persist=1,3::parts=3::occurrence=5\" > /tmp/faults.fifo";
-//            System.out.println("Running command: " + cmd);
-//            Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", cmd});
-//            Thread.sleep(1000);
-//            Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", "fusermount3 -u " + dataRoot});
-//            Thread.sleep(1000);
-//        } catch (Exception e) {
-//            throw new RuntimeException(e);
-//        }
-//    }
-//
-//    public void crashseq() {
-//        try {
-//            var cmd = "echo \"lazyfs::torn-seq::op=write::file=" + Path.of(lazyFsDataPath).toAbsolutePath().toString() + "/objects/data.mdb::persist=1,4::occurrence=2\" > /tmp/faults.fifo";
-//            System.out.println("Running command: " + cmd);
-//            Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", cmd});
-//            Thread.sleep(1000);
-//            Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", "fusermount3 -u " + dataRoot});
-//            Thread.sleep(1000);
-//        } catch (Exception e) {
-//            throw new RuntimeException(e);
-//        }
-//    }
-}
-

dhfs-parent/dhfs-fuse/src/test/java/com/usatiuk/dhfsfuse/integration/LazyFsIT.java

@@ -1,491 +0,0 @@
-package com.usatiuk.dhfsfuse.integration;
-
-import com.github.dockerjava.api.model.Device;
-import com.usatiuk.dhfsfuse.TestDataCleaner;
-import io.quarkus.logging.Log;
-import org.junit.jupiter.api.*;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.EnumSource;
-import org.slf4j.LoggerFactory;
-import org.testcontainers.DockerClientFactory;
-import org.testcontainers.containers.GenericContainer;
-import org.testcontainers.containers.Network;
-import org.testcontainers.containers.output.Slf4jLogConsumer;
-import org.testcontainers.containers.output.WaitingConsumer;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.util.Objects;
-import java.util.UUID;
-import java.util.concurrent.*;
-import java.util.stream.Stream;
-
-import static org.awaitility.Awaitility.await;
-
-@Disabled
-public class LazyFsIT {
-    GenericContainer<?> container1;
-    GenericContainer<?> container2;
-
-    WaitingConsumer waitingConsumer1;
-    WaitingConsumer waitingConsumer2;
-
-    String c1uuid;
-    String c2uuid;
-
-    File data1;
-    File data2;
-    File data1Lazy;
-    File data2Lazy;
-
-    LazyFs lazyFs1;
-    LazyFs lazyFs2;
-
-    ExecutorService executor;
-    Network network;
-
-    @BeforeEach
-    void setup(TestInfo testInfo) throws IOException, InterruptedException, TimeoutException {
-        executor = Executors.newCachedThreadPool();
-        data1 = Files.createTempDirectory("dhfsdata").toFile();
-        data2 = Files.createTempDirectory("dhfsdata").toFile();
-        data1Lazy = Files.createTempDirectory("lazyfsroot").toFile();
-        data2Lazy = Files.createTempDirectory("lazyfsroot").toFile();
-
-        network = Network.newNetwork();
-
-        lazyFs1 = new LazyFs(testInfo.getDisplayName(), data1.toString(), data1Lazy.toString());
-        lazyFs1.start();
-        lazyFs2 = new LazyFs(testInfo.getDisplayName(), data2.toString(), data2Lazy.toString());
-        lazyFs2.start();
-
-        container1 = new GenericContainer<>(DhfsImage.getInstance())
-                .withPrivilegedMode(true)
-                .withCreateContainerCmdModifier(cmd -> Objects.requireNonNull(cmd.getHostConfig()).withDevices(Device.parse("/dev/fuse")))
-                .withNetwork(network)
-                .withFileSystemBind(data1.getAbsolutePath(), "/dhfs_test/data");
-        container2 = new GenericContainer<>(DhfsImage.getInstance())
-                .withPrivilegedMode(true)
-                .withCreateContainerCmdModifier(cmd -> Objects.requireNonNull(cmd.getHostConfig()).withDevices(Device.parse("/dev/fuse")))
-                .withNetwork(network)
-                .withFileSystemBind(data2.getAbsolutePath(), "/dhfs_test/data");
-
-        Stream.of(container1, container2).parallel().forEach(GenericContainer::start);
-
-        waitingConsumer1 = new WaitingConsumer();
-        var loggingConsumer1 = new Slf4jLogConsumer(LoggerFactory.getLogger(LazyFsIT.class)).withPrefix("1-" + testInfo.getDisplayName());
-        container1.followOutput(loggingConsumer1.andThen(waitingConsumer1));
-        waitingConsumer2 = new WaitingConsumer();
-        var loggingConsumer2 = new Slf4jLogConsumer(LoggerFactory.getLogger(LazyFsIT.class)).withPrefix("2-" + testInfo.getDisplayName());
-        container2.followOutput(loggingConsumer2.andThen(waitingConsumer2));
-
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Listening"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Listening"), 60, TimeUnit.SECONDS);
-
-        c1uuid = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
-        c2uuid = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/data/self_uuid").getStdout();
-
-        Assertions.assertDoesNotThrow(() -> UUID.fromString(c1uuid));
-        Assertions.assertDoesNotThrow(() -> UUID.fromString(c2uuid));
-
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("New address"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("New address"), 60, TimeUnit.SECONDS);
-
-        var c1curl = container1.execInContainer("/bin/sh", "-c",
-                "curl --header \"Content-Type: application/json\" " +
-                        "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c2uuid);
-
-        var c2curl = container2.execInContainer("/bin/sh", "-c",
-                "curl --header \"Content-Type: application/json\" " +
-                        "  --request PUT " +
-                        "  --data '{}' " +
-                        "  http://localhost:8080/peers-manage/known-peers/" + c1uuid);
-
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-    }
-
-    @AfterEach
-    void stop() {
-        lazyFs1.stop();
-        lazyFs2.stop();
-
-        Stream.of(container1, container2).parallel().forEach(GenericContainer::stop);
-        TestDataCleaner.purgeDirectory(data1);
-        TestDataCleaner.purgeDirectory(data1Lazy);
-        TestDataCleaner.purgeDirectory(data2);
-        TestDataCleaner.purgeDirectory(data2Lazy);
-
-        executor.close();
-        network.close();
-    }
-
-    private void checkConsistency(String testName) {
-        await().atMost(120, TimeUnit.SECONDS).until(() -> {
-            var ls1 = container1.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse");
-            var cat1 = container1.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/*");
-            var ls2 = container2.execInContainer("/bin/sh", "-c", "ls /dhfs_test/fuse");
-            var cat2 = container2.execInContainer("/bin/sh", "-c", "cat /dhfs_test/fuse/*");
-            Log.info("Listing consistency " + testName + "\n"
-                    + ls1 + "\n"
-                    + cat1 + "\n"
-                    + ls2 + "\n"
-                    + cat2 + "\n");
-
-            return ls1.equals(ls2) && cat1.equals(cat2) && ls1.getExitCode() == 0 && ls2.getExitCode() == 0 && cat1.getExitCode() == 0 && cat2.getExitCode() == 0;
-        });
-    }
-
-    @ParameterizedTest
-    @EnumSource(CrashType.class)
-    void killTest(CrashType crashType, TestInfo testInfo) throws Exception {
-        var barrier = new CountDownLatch(1);
-        executor.submit(() -> {
-            try {
-                Log.info("Writing to container 1");
-                barrier.countDown();
-                container1.execInContainer("/bin/sh", "-c", "counter=0; while true; do counter=`expr $counter + 1`; echo $counter >> /dhfs_test/fuse/test1; done");
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-        });
-        barrier.await();
-        Thread.sleep(3000);
-        Log.info("Killing");
-        lazyFs1.crash();
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("org.lmdbjava.LmdbNativeException"), 60, TimeUnit.SECONDS);
-        var client = DockerClientFactory.instance().client();
-        client.killContainerCmd(container1.getContainerId()).exec();
-        container1.stop();
-        lazyFs1.stop();
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
-        Log.info("Restart");
-        switch (crashType) {
-            case CRASH -> lazyFs1.start();
-            case TORN_OP -> lazyFs1.startTornOp();
-            case TORN_SEQ -> lazyFs1.startTornSeq();
-        }
-        container1.start();
-
-        waitingConsumer1 = new WaitingConsumer();
-        var loggingConsumer1 = new Slf4jLogConsumer(LoggerFactory.getLogger(LazyFsIT.class)).withPrefix("1-" + testInfo.getDisplayName());
-        container1.followOutput(loggingConsumer1.andThen(waitingConsumer1));
-        try {
-            waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-            waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-        } catch (TimeoutException e) {
-            Log.info("Failed to connect: " + testInfo.getDisplayName());
-            // Sometimes it doesn't get mounted properly for some reason
-            Assumptions.assumeTrue(false);
-        }
-
-        executor.submit(() -> {
-            try {
-                Log.info("Writing to container 1");
-                barrier.countDown();
-                container1.execInContainer("/bin/sh", "-c", "counter=0; while true; do counter=`expr $counter + 1`; echo $counter >> /dhfs_test/fuse/test2; done");
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-        });
-        Log.info("Killing");
-        if (crashType.equals(CrashType.CRASH)) {
-            Thread.sleep(3000);
-            lazyFs1.crash();
-        }
-        try {
-            waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("org.lmdbjava.LmdbNativeException"), 60, TimeUnit.SECONDS);
-        } catch (TimeoutException e) {
-            // Sometimes crash doesn't work
-            Log.info("Failed to crash: " + testInfo.getDisplayName());
-            if (crashType.equals(CrashType.CRASH))
-                throw e;
-            Assumptions.assumeTrue(false);
-        }
-        client.killContainerCmd(container1.getContainerId()).exec();
-        container1.stop();
-        lazyFs1.stop();
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
-        Log.info("Restart");
-        lazyFs1.start();
-        container1.start();
-
-        waitingConsumer1 = new WaitingConsumer();
-        loggingConsumer1 = new Slf4jLogConsumer(LoggerFactory.getLogger(LazyFsIT.class)).withPrefix("1-" + testInfo.getDisplayName());
-        container1.followOutput(loggingConsumer1.andThen(waitingConsumer1));
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-
-        checkConsistency(testInfo.getDisplayName());
-    }
-
-    @ParameterizedTest
-    @EnumSource(CrashType.class)
-    void killTestDirs(CrashType crashType, TestInfo testInfo) throws Exception {
-        var barrier = new CountDownLatch(1);
-        executor.submit(() -> {
-            try {
-                Log.info("Writing to container 1");
-                barrier.countDown();
-                container1.execInContainer("/bin/sh", "-c", "counter=0; while true; do counter=`expr $counter + 1`; echo $counter >> /dhfs_test/fuse/test$counter; done");
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-        });
-        barrier.await();
-        Thread.sleep(3000);
-        Log.info("Killing");
-        lazyFs1.crash();
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("org.lmdbjava.LmdbNativeException"), 60, TimeUnit.SECONDS);
-        var client = DockerClientFactory.instance().client();
-        client.killContainerCmd(container1.getContainerId()).exec();
-        container1.stop();
-        lazyFs1.stop();
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
-        Log.info("Restart");
-        switch (crashType) {
-            case CRASH -> lazyFs1.start();
-            case TORN_OP -> lazyFs1.startTornOp();
-            case TORN_SEQ -> lazyFs1.startTornSeq();
-        }
-        container1.start();
-
-        waitingConsumer1 = new WaitingConsumer();
-        var loggingConsumer1 = new Slf4jLogConsumer(LoggerFactory.getLogger(LazyFsIT.class)).withPrefix("1-" + testInfo.getDisplayName());
-        container1.followOutput(loggingConsumer1.andThen(waitingConsumer1));
-        try {
-            waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-            waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-        } catch (TimeoutException e) {
-            Log.info("Failed to connect: " + testInfo.getDisplayName());
-            // Sometimes it doesn't get mounted properly for some reason
-
-            Assumptions.assumeTrue(false);
-        }
-
-        executor.submit(() -> {
-            try {
-                Log.info("Writing to container 1");
-                barrier.countDown();
-                container1.execInContainer("/bin/sh", "-c", "counter=0; while true; do counter=`expr $counter + 1`; echo $counter >> /dhfs_test/fuse/2test$counter; done");
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-        });
-        Log.info("Killing");
-        if (crashType.equals(CrashType.CRASH)) {
-            Thread.sleep(3000);
-            lazyFs1.crash();
-        }
-        try {
-            waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("org.lmdbjava.LmdbNativeException"), 60, TimeUnit.SECONDS);
-        } catch (TimeoutException e) {
-            // Sometimes crash doesn't work
-            Log.info("Failed to crash: " + testInfo.getDisplayName());
-            if (crashType.equals(CrashType.CRASH))
-                throw e;
-            Assumptions.assumeTrue(false);
-        }
-        client.killContainerCmd(container1.getContainerId()).exec();
-        container1.stop();
-        lazyFs1.stop();
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
-        Log.info("Restart");
-        lazyFs1.start();
-        container1.start();
-
-        waitingConsumer1 = new WaitingConsumer();
-        loggingConsumer1 = new Slf4jLogConsumer(LoggerFactory.getLogger(LazyFsIT.class)).withPrefix("1-" + testInfo.getDisplayName());
-        container1.followOutput(loggingConsumer1.andThen(waitingConsumer1));
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-
-        checkConsistency(testInfo.getDisplayName());
-    }
-
-    @ParameterizedTest
-    @EnumSource(CrashType.class)
-    void killTest2(CrashType crashType, TestInfo testInfo) throws Exception {
-        var barrier = new CountDownLatch(1);
-        executor.submit(() -> {
-            try {
-                Log.info("Writing to container 1");
-                barrier.countDown();
-                container1.execInContainer("/bin/sh", "-c", "counter=0; while  [ ! -f /tmp/stopprinting1 ]; do counter=`expr $counter + 1`; echo $counter >> /dhfs_test/fuse/test1; done");
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-        });
-        barrier.await();
-        Thread.sleep(3000);
-        Log.info("Killing");
-        lazyFs2.crash();
-        container1.execInContainer("/bin/sh", "-c", "touch /tmp/stopprinting1");
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("org.lmdbjava.LmdbNativeException"), 60, TimeUnit.SECONDS);
-        var client = DockerClientFactory.instance().client();
-        client.killContainerCmd(container2.getContainerId()).exec();
-        container2.stop();
-        lazyFs2.stop();
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
-        Log.info("Restart");
-        switch (crashType) {
-            case CRASH -> lazyFs2.start();
-            case TORN_OP -> lazyFs2.startTornOp();
-            case TORN_SEQ -> lazyFs2.startTornSeq();
-        }
-        container2.start();
-
-        waitingConsumer2 = new WaitingConsumer();
-        var loggingConsumer2 = new Slf4jLogConsumer(LoggerFactory.getLogger(LazyFsIT.class)).withPrefix("2-" + testInfo.getDisplayName());
-        container2.followOutput(loggingConsumer2.andThen(waitingConsumer2));
-        try {
-            waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-            waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-        } catch (TimeoutException e) {
-            Log.info("Failed to connect: " + testInfo.getDisplayName());
-            // Sometimes it doesn't get mounted properly for some reason
-
-            Assumptions.assumeTrue(false);
-        }
-        var barrier2 = new CountDownLatch(1);
-        executor.submit(() -> {
-            try {
-                Log.info("Writing to container 1");
-                barrier2.countDown();
-                container1.execInContainer("/bin/sh", "-c", "counter=0; while  [ ! -f /tmp/stopprinting2 ]; do counter=`expr $counter + 1`; echo $counter >> /dhfs_test/fuse/test2; done");
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-        });
-        barrier2.await();
-        Log.info("Killing");
-        Thread.sleep(3000);
-        if (crashType.equals(CrashType.CRASH)) {
-            lazyFs2.crash();
-        }
-        container1.execInContainer("/bin/sh", "-c", "touch /tmp/stopprinting2");
-        try {
-            waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("org.lmdbjava.LmdbNativeException"), 60, TimeUnit.SECONDS);
-        } catch (TimeoutException e) {
-            // Sometimes crash doesn't work
-            Log.info("Failed to crash: " + testInfo.getDisplayName());
-            if (crashType.equals(CrashType.CRASH))
-                throw e;
-            Assumptions.assumeTrue(false);
-        }
-        client.killContainerCmd(container2.getContainerId()).exec();
-        container2.stop();
-        lazyFs2.stop();
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
-        Log.info("Restart");
-        lazyFs2.start();
-        container2.start();
-
-        waitingConsumer2 = new WaitingConsumer();
-        loggingConsumer2 = new Slf4jLogConsumer(LoggerFactory.getLogger(LazyFsIT.class)).withPrefix("2-" + testInfo.getDisplayName());
-        container2.followOutput(loggingConsumer2.andThen(waitingConsumer2));
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-
-        checkConsistency(testInfo.getDisplayName());
-    }
-
-    @ParameterizedTest
-    @EnumSource(CrashType.class)
-    void killTestDirs2(CrashType crashType, TestInfo testInfo) throws Exception {
-        var barrier = new CountDownLatch(1);
-        executor.submit(() -> {
-            try {
-                Log.info("Writing to container 1");
-                barrier.countDown();
-                container1.execInContainer("/bin/sh", "-c", "counter=0; while  [ ! -f /tmp/stopprinting1 ]; do counter=`expr $counter + 1`; echo $counter >> /dhfs_test/fuse/test$counter; done");
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-        });
-        barrier.await();
-        Thread.sleep(3000);
-        Log.info("Killing");
-        lazyFs2.crash();
-        container1.execInContainer("/bin/sh", "-c", "touch /tmp/stopprinting1");
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("org.lmdbjava.LmdbNativeException"), 60, TimeUnit.SECONDS);
-        var client = DockerClientFactory.instance().client();
-        client.killContainerCmd(container2.getContainerId()).exec();
-        container2.stop();
-        lazyFs2.stop();
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
-        Log.info("Restart");
-        switch (crashType) {
-            case CRASH -> lazyFs2.start();
-            case TORN_OP -> lazyFs2.startTornOp();
-            case TORN_SEQ -> lazyFs2.startTornSeq();
-        }
-        container2.start();
-
-        waitingConsumer2 = new WaitingConsumer();
-        var loggingConsumer2 = new Slf4jLogConsumer(LoggerFactory.getLogger(LazyFsIT.class)).withPrefix("2-" + testInfo.getDisplayName());
-        container2.followOutput(loggingConsumer2.andThen(waitingConsumer2));
-        try {
-            waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-            waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-        } catch (TimeoutException e) {
-            Log.info("Failed to connect: " + testInfo.getDisplayName());
-            // Sometimes it doesn't get mounted properly for some reason
-            Assumptions.assumeTrue(false);
-        }
-
-        var barrier2 = new CountDownLatch(1);
-        executor.submit(() -> {
-            try {
-                Log.info("Writing to container 1");
-                barrier2.countDown();
-                container1.execInContainer("/bin/sh", "-c", "counter=0; while  [ ! -f /tmp/stopprinting2 ]; do counter=`expr $counter + 1`; echo $counter >> /dhfs_test/fuse/2test$counter; done");
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-        });
-        barrier2.await();
-        Thread.sleep(3000);
-        Log.info("Killing");
-        if (crashType.equals(CrashType.CRASH)) {
-            lazyFs2.crash();
-        }
-        container1.execInContainer("/bin/sh", "-c", "touch /tmp/stopprinting2");
-        try {
-            waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("org.lmdbjava.LmdbNativeException"), 60, TimeUnit.SECONDS);
-        } catch (TimeoutException e) {
-            // Sometimes crash doesn't work
-            Log.info("Failed to crash: " + testInfo.getDisplayName());
-            if (crashType.equals(CrashType.CRASH))
-                throw e;
-            Assumptions.assumeTrue(false);
-        }
-        client.killContainerCmd(container2.getContainerId()).exec();
-        container2.stop();
-        lazyFs2.stop();
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Lost connection to"), 60, TimeUnit.SECONDS);
-        Log.info("Restart");
-        lazyFs2.start();
-        container2.start();
-
-        waitingConsumer2 = new WaitingConsumer();
-        loggingConsumer2 = new Slf4jLogConsumer(LoggerFactory.getLogger(LazyFsIT.class)).withPrefix("2-" + testInfo.getDisplayName());
-        container2.followOutput(loggingConsumer2.andThen(waitingConsumer2));
-        waitingConsumer2.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-        waitingConsumer1.waitUntil(frame -> frame.getUtf8String().contains("Connected"), 60, TimeUnit.SECONDS);
-
-        checkConsistency(testInfo.getDisplayName());
-    }
-
-
-    private static enum CrashType {
-        CRASH,
-        TORN_OP,
-        TORN_SEQ
-    }
-
-
-}

dhfs-parent/dhfs-fuse/src/test/resources/application.properties

@@ -1,9 +1,11 @@
-dhfs.objects.persistence.root=${HOME}/dhfs_data/dhfs_root_test
+dhfs.objects.persistence.files.root=${HOME}/dhfs_data/dhfs_root_test
+dhfs.objects.root=${HOME}/dhfs_data/dhfs_root_d_test
 dhfs.fuse.root=${HOME}/dhfs_data/dhfs_fuse_root_test
 dhfs.objects.ref_verification=true
 dhfs.objects.deletion.delay=0
 quarkus.log.category."com.usatiuk.dhfs".level=TRACE
 quarkus.log.category."com.usatiuk.dhfs".min-level=TRACE
+quarkus.class-loading.parent-first-artifacts=com.usatiuk.dhfs:supportlib
 quarkus.http.test-port=0
 quarkus.http.test-ssl-port=0
 dhfs.local-discovery=false

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/AlreadyExistsException.java

@@ -1,8 +1,5 @@
 package com.usatiuk.kleppmanntree;
 
-/**
- * Exception thrown when an attempt is made to create a new tree node as a child with a name that already exists.
- */
 public class AlreadyExistsException extends RuntimeException {
     public AlreadyExistsException(String message) {
         super(message);

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/AtomicClock.java

@@ -0,0 +1,32 @@
+package com.usatiuk.kleppmanntree;
+
+import java.io.Serializable;
+
+public class AtomicClock implements Clock<Long>, Serializable {
+    private long _max = 0;
+
+    public AtomicClock(long counter) {
+        _max = counter;
+    }
+
+    @Override
+    public Long getTimestamp() {
+        return ++_max;
+    }
+
+    public void setTimestamp(Long timestamp) {
+        _max = timestamp;
+    }
+
+    @Override
+    public Long peekTimestamp() {
+        return _max;
+    }
+
+    @Override
+    public Long updateTimestamp(Long receivedTimestamp) {
+        var old = _max;
+        _max = Math.max(_max, receivedTimestamp) + 1;
+        return old;
+    }
+}

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/Clock.java

@@ -1,26 +1,9 @@
 package com.usatiuk.kleppmanntree;
 
-/**
- * Clock interface
- */
 public interface Clock<TimestampT extends Comparable<TimestampT>> {
-    /**
-     * Increment and get the current timestamp.
-     * @return the incremented timestamp
-     */
     TimestampT getTimestamp();
 
-    /**
-     * Get the current timestamp without incrementing it.
-     * @return the current timestamp
-     */
     TimestampT peekTimestamp();
 
-    /**
-     * Update the timestamp with an externally received timestamp.
-     * Will set the currently stored timestamp to <code>max(receivedTimestamp, currentTimestamp) + 1</code>
-     * @param receivedTimestamp the received timestamp
-     * @return the previous timestamp
-     */
     TimestampT updateTimestamp(TimestampT receivedTimestamp);
 }

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/CombinedTimestamp.java

@@ -3,13 +3,6 @@ package com.usatiuk.kleppmanntree;
 import java.io.Serializable;
 import java.util.Comparator;
 
-/**
- * CombinedTimestamp is a record that represents a timestamp and a node ID, ordered first by timestamp and then by node ID.
- * @param timestamp the timestamp
- * @param nodeId the node ID. If null, then only the timestamp is used for ordering.
- * @param <TimestampT> the type of the timestamp
- * @param <PeerIdT> the type of the node ID
- */
 public record CombinedTimestamp<TimestampT extends Comparable<TimestampT>, PeerIdT extends Comparable<PeerIdT>>
         (TimestampT timestamp,
          PeerIdT nodeId) implements Comparable<CombinedTimestamp<TimestampT, PeerIdT>>, Serializable {

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/KleppmannTree.java

@@ -1,5 +1,7 @@
 package com.usatiuk.kleppmanntree;
 
+import jakarta.annotation.Nonnull;
+import jakarta.annotation.Nullable;
 import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.*;
@@ -8,14 +10,6 @@ import java.util.function.Function;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
-/**
- * An implementation of a tree as described in <a href="https://martin.kleppmann.com/papers/move-op.pdf">A highly-available move operation for replicated trees</a>
- *
- * @param <TimestampT> Type of the timestamp
- * @param <PeerIdT>    Type of the peer ID
- * @param <MetaT>      Type of the node metadata
- * @param <NodeIdT>    Type of the node ID
- */
 public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT extends Comparable<PeerIdT>, MetaT extends NodeMeta, NodeIdT> {
     private static final Logger LOGGER = Logger.getLogger(KleppmannTree.class.getName());
 
@@ -23,15 +17,8 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
     private final PeerInterface<PeerIdT> _peers;
     private final Clock<TimestampT> _clock;
     private final OpRecorder<TimestampT, PeerIdT, MetaT, NodeIdT> _opRecorder;
+    private HashMap<NodeIdT, TreeNode<TimestampT, PeerIdT, MetaT, NodeIdT>> _undoCtx = null;
 
-    /**
-     * Constructor with all the dependencies
-     *
-     * @param storage    Storage interface
-     * @param peers      Peer interface
-     * @param clock      Clock interface
-     * @param opRecorder Operation recorder interface
-     */
     public KleppmannTree(StorageInterface<TimestampT, PeerIdT, MetaT, NodeIdT> storage,
                          PeerInterface<PeerIdT> peers,
                          Clock<TimestampT> clock,
@@ -42,13 +29,6 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         _opRecorder = opRecorder;
     }
 
-    /**
-     * Traverse the tree from the given node ID using the given list of names
-     *
-     * @param fromId The starting node ID
-     * @param names  The list of names to traverse
-     * @return The resulting node ID or null if not found
-     */
     private NodeIdT traverseImpl(NodeIdT fromId, List<String> names) {
         if (names.isEmpty()) return fromId;
 
@@ -62,21 +42,14 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         return traverseImpl(childId, names.subList(1, names.size()));
     }
 
-    /**
-     * Traverse the tree from its root node using the given list of names
-     *
-     * @param names The list of names to traverse
-     * @return The resulting node ID or null if not found
-     */
+    public NodeIdT traverse(NodeIdT fromId, List<String> names) {
+        return traverseImpl(fromId, names.subList(1, names.size()));
+    }
+
     public NodeIdT traverse(List<String> names) {
         return traverseImpl(_storage.getRootId(), names);
     }
 
-    /**
-     * Undo the effect of a log effect
-     *
-     * @param effect The log effect to undo
-     */
     private void undoEffect(LogEffect<TimestampT, PeerIdT, MetaT, NodeIdT> effect) {
         if (effect.oldInfo() != null) {
             var node = _storage.getById(effect.childId());
@@ -116,14 +89,10 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
                     node.withParent(null)
                             .withLastEffectiveOp(null)
             );
+            _undoCtx.put(node.key(), node);
         }
     }
 
-    /**
-     * Undo the effects of a log record
-     *
-     * @param op The log record to undo
-     */
     private void undoOp(LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT> op) {
         LOGGER.finer(() -> "Will undo op: " + op);
         if (op.effects() != null)
@@ -131,32 +100,16 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
                 undoEffect(e);
     }
 
-    /**
-     * Redo the operation in a log record
-     *
-     * @param entry The log record to redo
-     */
     private void redoOp(Map.Entry<CombinedTimestamp<TimestampT, PeerIdT>, LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT>> entry) {
         var newEffects = doOp(entry.getValue().op(), false);
         _storage.getLog().replace(entry.getKey(), newEffects);
     }
 
-    /**
-     * Perform the operation and put it in the log
-     *
-     * @param op                   The operation to perform
-     * @param failCreatingIfExists Whether to fail if there is a name conflict,
-     *                             otherwise replace the existing node
-     * @throws AlreadyExistsException If the node already exists and failCreatingIfExists is true
-     */
     private void doAndPut(OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> op, boolean failCreatingIfExists) {
         var res = doOp(op, failCreatingIfExists);
         _storage.getLog().put(res.op().timestamp(), res);
     }
 
-    /**
-     * Try to trim the log to the causality threshold
-     */
     private void tryTrimLog() {
         var log = _storage.getLog();
         var timeLog = _storage.getPeerTimestampLog();
@@ -212,52 +165,22 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         }
     }
 
-    /**
-     * Move a node to a new parent with new metadata
-     *
-     * @param newParent The new parent node ID
-     * @param newMeta   The new metadata
-     * @param child     The child node ID
-     * @throws AlreadyExistsException If the node already exists and failCreatingIfExists is true
-     */
     public <LocalMetaT extends MetaT> void move(NodeIdT newParent, LocalMetaT newMeta, NodeIdT child) {
         move(newParent, newMeta, child, true);
     }
 
-    /**
-     * Move a node to a new parent with new metadata
-     *
-     * @param newParent            The new parent node ID
-     * @param newMeta              The new metadata
-     * @param child                The child node ID
-     * @param failCreatingIfExists Whether to fail if there is a name conflict,
-     *                             otherwise replace the existing node
-     * @throws AlreadyExistsException If the node already exists and failCreatingIfExists is true
-     */
     public void move(NodeIdT newParent, MetaT newMeta, NodeIdT child, boolean failCreatingIfExists) {
         var createdMove = createMove(newParent, newMeta, child);
         applyOp(_peers.getSelfId(), createdMove, failCreatingIfExists);
         _opRecorder.recordOp(createdMove);
     }
 
-    /**
-     * Apply an external operation from a remote peer
-     *
-     * @param from The peer ID
-     * @param op   The operation to apply
-     */
     public void applyExternalOp(PeerIdT from, OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> op) {
         _clock.updateTimestamp(op.timestamp().timestamp());
         applyOp(from, op, false);
     }
 
-    /**
-     * Update the causality threshold timestamp for a peer
-     *
-     * @param from         The peer ID
-     * @param newTimestamp The timestamp received from it
-     * @return True if the timestamp was updated, false otherwise
-     */
+    // Returns true if the timestamp is newer than what's seen, false otherwise
     private boolean updateTimestampImpl(PeerIdT from, TimestampT newTimestamp) {
         TimestampT oldRef = _storage.getPeerTimestampLog().getForPeer(from);
         if (oldRef != null && oldRef.compareTo(newTimestamp) >= 0) { // FIXME?
@@ -268,12 +191,6 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         return true;
     }
 
-    /**
-     * Update the causality threshold timestamp for a peer
-     *
-     * @param from      The peer ID
-     * @param timestamp The timestamp received from it
-     */
     public void updateExternalTimestamp(PeerIdT from, TimestampT timestamp) {
         var gotExt = _storage.getPeerTimestampLog().getForPeer(from);
         var gotSelf = _storage.getPeerTimestampLog().getForPeer(_peers.getSelfId());
@@ -284,15 +201,6 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         tryTrimLog();
     }
 
-    /**
-     * Apply an operation from a peer
-     *
-     * @param from                 The peer ID
-     * @param op                   The operation to apply
-     * @param failCreatingIfExists Whether to fail if there is a name conflict,
-     *                             otherwise replace the existing node
-     * @throws AlreadyExistsException If the node already exists and failCreatingIfExists is true
-     */
     private void applyOp(PeerIdT from, OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> op, boolean failCreatingIfExists) {
         if (!updateTimestampImpl(op.timestamp().nodeId(), op.timestamp().timestamp())) return;
 
@@ -309,52 +217,45 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         }
         assert cmp != 0;
         if (cmp < 0) {
-            if (log.containsKey(op.timestamp())) return;
-            var toUndo = log.newestSlice(op.timestamp(), false);
-            for (var entry : toUndo.reversed()) {
-                undoOp(entry.getValue());
+            try {
+                if (log.containsKey(op.timestamp())) return;
+                var toUndo = log.newestSlice(op.timestamp(), false);
+                _undoCtx = new HashMap<>();
+                for (var entry : toUndo.reversed()) {
+                    undoOp(entry.getValue());
+                }
+                try {
+                    doAndPut(op, failCreatingIfExists);
+                } finally {
+                    for (var entry : toUndo) {
+                        redoOp(entry);
+                    }
+
+                    if (!_undoCtx.isEmpty()) {
+                        for (var e : _undoCtx.entrySet()) {
+                            LOGGER.log(Level.FINE, "Dropping node " + e.getKey());
+                            _storage.removeNode(e.getKey());
+                        }
+                    }
+                    _undoCtx = null;
+                }
+            } finally {
+                tryTrimLog();
             }
-            doAndPut(op, failCreatingIfExists);
-            for (var entry : toUndo) {
-                redoOp(entry);
-            }
-            tryTrimLog();
         } else {
             doAndPut(op, failCreatingIfExists);
             tryTrimLog();
         }
     }
 
-    /**
-     * Get a new timestamp, incrementing the one in storage
-     *
-     * @return A new timestamp
-     */
     private CombinedTimestamp<TimestampT, PeerIdT> getTimestamp() {
         return new CombinedTimestamp<>(_clock.getTimestamp(), _peers.getSelfId());
     }
 
-    /**
-     * Create a new move operation
-     *
-     * @param newParent The new parent node ID
-     * @param newMeta   The new metadata
-     * @param node      The child node ID
-     * @return A new move operation
-     */
     private <LocalMetaT extends MetaT> OpMove<TimestampT, PeerIdT, LocalMetaT, NodeIdT> createMove(NodeIdT newParent, LocalMetaT newMeta, NodeIdT node) {
         return new OpMove<>(getTimestamp(), newParent, newMeta, node);
     }
 
-    /**
-     * Perform the operation and return the log record
-     *
-     * @param op                   The operation to perform
-     * @param failCreatingIfExists Whether to fail if there is a name conflict,
-     *                             otherwise replace the existing node
-     * @return The log record
-     * @throws AlreadyExistsException If the node already exists and failCreatingIfExists is true
-     */
     private LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT> doOp(OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> op, boolean failCreatingIfExists) {
         LOGGER.finer(() -> "Doing op: " + op);
         LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT> computed;
@@ -363,7 +264,8 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         } catch (AlreadyExistsException aex) {
             throw aex;
         } catch (Exception e) {
-            throw new RuntimeException("Error computing effects for op " + op.toString(), e);
+            LOGGER.log(Level.SEVERE, "Error computing effects for op" + op.toString(), e);
+            computed = new LogRecord<>(op, null);
         }
 
         if (computed.effects() != null)
@@ -371,24 +273,28 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         return computed;
     }
 
-    /**
-     * Get a new node from storage
-     *
-     * @param key    The node ID
-     * @param parent The parent node ID
-     * @param meta   The metadata
-     * @return A new tree node
-     */
     private TreeNode<TimestampT, PeerIdT, MetaT, NodeIdT> getNewNode(NodeIdT key, NodeIdT parent, MetaT meta) {
+        if (_undoCtx != null) {
+            var node = _undoCtx.get(key);
+            if (node != null) {
+                try {
+                    if (!node.children().isEmpty()) {
+                        LOGGER.log(Level.WARNING, "Not empty children for undone node " + key);
+                    }
+                    node = node.withParent(parent).withMeta(meta);
+                } catch (Exception e) {
+                    LOGGER.log(Level.SEVERE, "Error while fixing up node " + key, e);
+                    node = null;
+                }
+            }
+            if (node != null) {
+                _undoCtx.remove(key);
+                return node;
+            }
+        }
         return _storage.createNewNode(key, parent, meta);
     }
 
-    /**
-     * Apply the effects of a log record
-     *
-     * @param sourceOp The source operation
-     * @param effects  The list of log effects
-     */
     private void applyEffects(OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> sourceOp, List<LogEffect<TimestampT, PeerIdT, MetaT, NodeIdT>> effects) {
         for (var effect : effects) {
             LOGGER.finer(() -> "Applying effect: " + effect + " from op " + sourceOp);
@@ -429,15 +335,6 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         }
     }
 
-    /**
-     * Compute the effects of a move operation
-     *
-     * @param op                   The operation to process
-     * @param failCreatingIfExists Whether to fail if there is a name conflict,
-     *                             otherwise replace the existing node
-     * @return The log record with the computed effects
-     * @throws AlreadyExistsException If the node already exists and failCreatingIfExists is true
-     */
     private LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT> computeEffects(OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> op, boolean failCreatingIfExists) {
         var node = _storage.getById(op.childId());
 
@@ -475,6 +372,10 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
                 var conflictNode = _storage.getById(conflictNodeId);
                 MetaT conflictNodeMeta = conflictNode.meta();
 
+                if (Objects.equals(conflictNodeMeta, op.newMeta())) {
+                    return new LogRecord<>(op, null);
+                }
+
                 LOGGER.finer(() -> "Node creation conflict: " + conflictNode);
 
                 String newConflictNodeName = op.newName() + ".conflict." + conflictNode.key();
@@ -499,14 +400,18 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         if (oldMeta != null
                 && op.newMeta() != null
                 && !oldMeta.getClass().equals(op.newMeta().getClass())) {
-            throw new RuntimeException("Class mismatch for meta for node " + node.key());
+            LOGGER.log(Level.SEVERE, "Class mismatch for meta for node " + node.key());
+            return new LogRecord<>(op, null);
         }
-
         var replaceNodeId = newParent.children().get(op.newName());
         if (replaceNodeId != null) {
             var replaceNode = _storage.getById(replaceNodeId);
             var replaceNodeMeta = replaceNode.meta();
 
+            if (Objects.equals(replaceNodeMeta, op.newMeta())) {
+                return new LogRecord<>(op, null);
+            }
+
             LOGGER.finer(() -> "Node replacement: " + replaceNode);
 
             return new LogRecord<>(op, List.of(
@@ -521,13 +426,6 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         ));
     }
 
-    /**
-     * Check if a node is an ancestor of another node
-     *
-     * @param child  The child node ID
-     * @param parent The parent node ID
-     * @return True if the child is an ancestor of the parent, false otherwise
-     */
     private boolean isAncestor(NodeIdT child, NodeIdT parent) {
         var node = _storage.getById(parent);
         NodeIdT curParent;
@@ -538,11 +436,6 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         return false;
     }
 
-    /**
-     * Walk the tree and apply the given consumer to each node
-     *
-     * @param consumer The consumer to apply to each node
-     */
     public void walkTree(Consumer<TreeNode<TimestampT, PeerIdT, MetaT, NodeIdT>> consumer) {
         ArrayDeque<NodeIdT> queue = new ArrayDeque<>();
         queue.push(_storage.getRootId());
@@ -556,12 +449,6 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         }
     }
 
-    /**
-     * Find the parent of a node that matches the given predicate
-     *
-     * @param kidPredicate The predicate to match the child node
-     * @return A pair containing the name of the child and the ID of the parent, or null if not found
-     */
     public Pair<String, NodeIdT> findParent(Function<TreeNode<TimestampT, PeerIdT, MetaT, NodeIdT>, Boolean> kidPredicate) {
         ArrayDeque<NodeIdT> queue = new ArrayDeque<>();
         queue.push(_storage.getRootId());
@@ -582,13 +469,6 @@ public class KleppmannTree<TimestampT extends Comparable<TimestampT>, PeerIdT ex
         return null;
     }
 
-    /**
-     * Record the bootstrap operations for a given peer
-     * Will visit all nodes of the tree and add their effective operations to both the queue to be sent to the peer,
-     * and to the global operation log.
-     *
-     * @param host The peer ID
-     */
     public void recordBoostrapFor(PeerIdT host) {
         TreeMap<CombinedTimestamp<TimestampT, PeerIdT>, OpMove<TimestampT, PeerIdT, MetaT, NodeIdT>> result = new TreeMap<>();
 

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/LogEffect.java

@@ -2,18 +2,6 @@ package com.usatiuk.kleppmanntree;
 
 import java.io.Serializable;
 
-/**
- * LogEffect is a record that represents the effect of a log entry on a tree node.
- * @param oldInfo the old information about the node, before it was moved. Null if the node did not exist before
- * @param effectiveOp the operation that had caused this effect to be applied
- * @param newParentId the ID of the new parent node
- * @param newMeta the new metadata of the node
- * @param childId the ID of the child node
- * @param <TimestampT> the type of the timestamp
- * @param <PeerIdT> the type of the peer ID
- * @param <MetaT> the type of the node metadata
- * @param <NodeIdT> the type of the node ID
- */
 public record LogEffect<TimestampT extends Comparable<TimestampT>, PeerIdT extends Comparable<PeerIdT>, MetaT extends NodeMeta, NodeIdT>(
         LogEffectOld<TimestampT, PeerIdT, MetaT, NodeIdT> oldInfo,
         OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> effectiveOp,
@@ -22,14 +10,14 @@ public record LogEffect<TimestampT extends Comparable<TimestampT>, PeerIdT exten
         NodeIdT childId) implements Serializable {
     public String oldName() {
         if (oldInfo.oldMeta() != null) {
-            return oldInfo.oldMeta().name();
+            return oldInfo.oldMeta().getName();
         }
         return childId.toString();
     }
 
     public String newName() {
         if (newMeta != null) {
-            return newMeta.name();
+            return newMeta.getName();
         }
         return childId.toString();
     }

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/LogEffectOld.java

@@ -2,16 +2,6 @@ package com.usatiuk.kleppmanntree;
 
 import java.io.Serializable;
 
-/**
- * Represents the old information about a node before it was moved.
- * @param oldEffectiveMove the old effective move that had caused this effect to be applied
- * @param oldParent the ID of the old parent node
- * @param oldMeta the old metadata of the node
- * @param <TimestampT> the type of the timestamp
- * @param <PeerIdT> the type of the peer ID
- * @param <MetaT> the type of the node metadata
- * @param <NodeIdT> the type of the node ID
- */
 public record LogEffectOld<TimestampT extends Comparable<TimestampT>, PeerIdT extends Comparable<PeerIdT>, MetaT extends NodeMeta, NodeIdT>
         (OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> oldEffectiveMove,
          NodeIdT oldParent,

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/LogInterface.java

@@ -4,82 +4,29 @@ import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.List;
 
-/**
- * LogInterface is an interface that allows accessing the log of operations
- * @param <TimestampT> the type of the timestamp
- * @param <PeerIdT> the type of the peer ID
- * @param <MetaT> the type of the node metadata
- * @param <NodeIdT> the type of the node ID
- */
 public interface LogInterface<
         TimestampT extends Comparable<TimestampT>,
         PeerIdT extends Comparable<PeerIdT>,
         MetaT extends NodeMeta,
         NodeIdT> {
-    /**
-     * Peek the oldest log entry.
-     * @return the oldest log entry
-     */
     Pair<CombinedTimestamp<TimestampT, PeerIdT>, LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT>> peekOldest();
 
-    /**
-     * Take the oldest log entry.
-     * @return the oldest log entry
-     */
     Pair<CombinedTimestamp<TimestampT, PeerIdT>, LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT>> takeOldest();
 
-    /**
-     * Peek the newest log entry.
-     * @return the newest log entry
-     */
     Pair<CombinedTimestamp<TimestampT, PeerIdT>, LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT>> peekNewest();
 
-    /**
-     * Return all log entries that are newer than the given timestamp.
-     * @param since the timestamp to compare with
-     * @param inclusive if true, include the log entry with the given timestamp
-     * @return a list of log entries that are newer than the given timestamp
-     */
     List<Pair<CombinedTimestamp<TimestampT, PeerIdT>, LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT>>>
     newestSlice(CombinedTimestamp<TimestampT, PeerIdT> since, boolean inclusive);
 
-    /**
-     * Return all the log entries
-     * @return a list of all log entries
-     */
     List<Pair<CombinedTimestamp<TimestampT, PeerIdT>, LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT>>> getAll();
 
-    /**
-     * Checks if the log is empty.
-     * @return true if the log is empty, false otherwise
-     */
     boolean isEmpty();
 
-    /**
-     * Checks if the log contains the given timestamp.
-     * @param timestamp the timestamp to check
-     * @return true if the log contains the given timestamp, false otherwise
-     */
     boolean containsKey(CombinedTimestamp<TimestampT, PeerIdT> timestamp);
 
-    /**
-     * Get the size of the log.
-     * @return the size of the log (number of entries)
-     */
     long size();
 
-    /**
-     * Add a log entry to the log.
-     * @param timestamp the timestamp of the log entry
-     * @param record the log entry
-     * @throws IllegalStateException if the log entry already exists
-     */
     void put(CombinedTimestamp<TimestampT, PeerIdT> timestamp, LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT> record);
 
-    /**
-     * Replace a log entry in the log.
-     * @param timestamp the timestamp of the log entry
-     * @param record the log entry
-     */
     void replace(CombinedTimestamp<TimestampT, PeerIdT> timestamp, LogRecord<TimestampT, PeerIdT, MetaT, NodeIdT> record);
 }

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/LogRecord.java

@@ -3,15 +3,6 @@ package com.usatiuk.kleppmanntree;
 import java.io.Serializable;
 import java.util.List;
 
-/**
- * Represents a log record in the Kleppmann tree.
- * @param op the operation that is stored in this log record
- * @param effects the effects of the operation (resulting moves)
- * @param <TimestampT> the type of the timestamp
- * @param <PeerIdT> the type of the peer ID
- * @param <MetaT> the type of the node metadata
- * @param <NodeIdT> the type of the node ID
- */
 public record LogRecord<TimestampT extends Comparable<TimestampT>, PeerIdT extends Comparable<PeerIdT>, MetaT extends NodeMeta, NodeIdT>
         (OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> op,
          List<LogEffect<TimestampT, PeerIdT, MetaT, NodeIdT>> effects) implements Serializable {

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/NodeMeta.java

@@ -2,24 +2,8 @@ package com.usatiuk.kleppmanntree;
 
 import java.io.Serializable;
 
-/**
- * Represents metadata associated with a node in the Kleppmann tree.
- * This interface is used to define the metadata that can be associated with nodes in the tree.
- * Implementations of this interface should provide a name for the node and a method to create a copy of it with a new name.
- */
 public interface NodeMeta extends Serializable {
-    /**
-     * Returns the name of the node.
-     *
-     * @return the name of the node
-     */
-    String name();
+    String getName();
 
-    /**
-     * Creates a copy of the metadata with a new name.
-     *
-     * @param name the new name for the metadata
-     * @return a new instance of NodeMeta with the specified name
-     */
     NodeMeta withName(String name);
 }

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/OpMove.java

@@ -2,30 +2,12 @@ package com.usatiuk.kleppmanntree;
 
 import java.io.Serializable;
 
-/**
- * Operation that moves a child node to a new parent node.
- *
- * @param timestamp    the timestamp of the operation
- * @param newParentId  the ID of the new parent node
- * @param newMeta      the new metadata of the node, can be null
- * @param childId      the ID of the child node (the node that is being moved)
- * @param <TimestampT> the type of the timestamp
- * @param <PeerIdT>    the type of the peer ID
- * @param <MetaT>      the type of the node metadata
- * @param <NodeIdT>    the type of the node ID
- */
 public record OpMove<TimestampT extends Comparable<TimestampT>, PeerIdT extends Comparable<PeerIdT>, MetaT extends NodeMeta, NodeIdT>
         (CombinedTimestamp<TimestampT, PeerIdT> timestamp, NodeIdT newParentId, MetaT newMeta,
          NodeIdT childId) implements Serializable {
-    /**
-     * Returns the new name of the node: name extracted from the new metadata if available,
-     * otherwise the child ID converted to string.
-     *
-     * @return the new name of the node
-     */
     public String newName() {
         if (newMeta != null)
-            return newMeta.name();
+            return newMeta.getName();
         return childId.toString();
     }
 }

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/OpRecorder.java

@@ -1,26 +1,7 @@
 package com.usatiuk.kleppmanntree;
 
-/**
- * Interface to provide recording operations to be sent to peers asynchronously.
- * @param <TimestampT> the type of the timestamp
- * @param <PeerIdT> the type of the peer ID
- * @param <MetaT> the type of the node metadata
- * @param <NodeIdT> the type of the node ID
- */
 public interface OpRecorder<TimestampT extends Comparable<TimestampT>, PeerIdT extends Comparable<PeerIdT>, MetaT extends NodeMeta, NodeIdT> {
-    /**
-     * Records an operation to be sent to peers asynchronously.
-     * The operation will be sent to all known peers in the system.
-     *
-     * @param op the operation to be recorded
-     */
     void recordOp(OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> op);
 
-    /**
-     * Records an operation to be sent to a specific peer asynchronously.
-     *
-     * @param peer the ID of the peer to send the operation to
-     * @param op   the operation to be recorded
-     */
     void recordOpForPeer(PeerIdT peer, OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> op);
 }

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/PeerInterface.java

@@ -2,22 +2,8 @@ package com.usatiuk.kleppmanntree;
 
 import java.util.Collection;
 
-/**
- * Interface providing access to a list of known peers.
- * @param <PeerIdT> the type of the peer ID
- */
 public interface PeerInterface<PeerIdT extends Comparable<PeerIdT>> {
-    /**
-     * Returns the ID of the current peer.
-     *
-     * @return the ID of the current peer
-     */
     PeerIdT getSelfId();
 
-    /**
-     * Returns a collection of all known peers.
-     *
-     * @return a collection of all known peers
-     */
     Collection<PeerIdT> getAllPeers();
 }

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/PeerTimestampLogInterface.java

@@ -1,26 +1,11 @@
 package com.usatiuk.kleppmanntree;
 
-/**
- * Interface providing a map of newest received timestamps for each peer. (causality thresholds)
- * If a peer has some timestamp recorded in this map,
- * it means that all messages coming from this peer will have a newer timestamp.
- * @param <TimestampT>
- * @param <PeerIdT>
- */
 public interface PeerTimestampLogInterface<
         TimestampT extends Comparable<TimestampT>,
         PeerIdT extends Comparable<PeerIdT>> {
 
-    /**
-     * Get the timestamp for a specific peer.
-     * @param peerId the ID of the peer
-     * @return the timestamp for the peer
-     */
     TimestampT getForPeer(PeerIdT peerId);
 
-    /**
-     * Get the timestamp for the current peer.
-     */
     void putForPeer(PeerIdT peerId, TimestampT timestamp);
 
 }

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/StorageInterface.java

@@ -1,89 +1,28 @@
 package com.usatiuk.kleppmanntree;
 
-/**
- * Storage interface for the Kleppmann tree.
- *
- * @param <TimestampT> the type of the timestamp
- * @param <PeerIdT>    the type of the peer ID
- * @param <MetaT>      the type of the node metadata
- * @param <NodeIdT>    the type of the node ID
- */
 public interface StorageInterface<
         TimestampT extends Comparable<TimestampT>,
         PeerIdT extends Comparable<PeerIdT>,
         MetaT extends NodeMeta,
         NodeIdT> {
-    /**
-     * Get the root node ID.
-     *
-     * @return the root node IDx
-     */
     NodeIdT getRootId();
 
-    /**
-     * Get the trash node ID.
-     *
-     * @return the trash node ID
-     */
     NodeIdT getTrashId();
 
-    /**
-     * Get the lost and found node ID.
-     *
-     * @return the lost and found node ID
-     */
     NodeIdT getLostFoundId();
 
-    /**
-     * Get the new node ID.
-     *
-     * @return the new node ID
-     */
     NodeIdT getNewNodeId();
 
-    /**
-     * Get the node by its ID.
-     *
-     * @param id the ID of the node
-     * @return the node with the specified ID, or null if not found
-     */
     TreeNode<TimestampT, PeerIdT, MetaT, NodeIdT> getById(NodeIdT id);
 
-    /**
-     * Create a new node with the specified key, parent, and metadata.
-     *
-     * @param key    the ID of the new node
-     * @param parent the ID of the parent node
-     * @param meta   the metadata of the new node
-     * @return the new node
-     */
+    // Creates a node, returned wrapper is RW-locked
     TreeNode<TimestampT, PeerIdT, MetaT, NodeIdT> createNewNode(NodeIdT key, NodeIdT parent, MetaT meta);
 
-    /**
-     * Put a node into the storage.
-     *
-     * @param node the node to put into the storage
-     */
     void putNode(TreeNode<TimestampT, PeerIdT, MetaT, NodeIdT> node);
 
-    /**
-     * Remove a node from the storage.
-     *
-     * @param id the ID of the node to remove
-     */
     void removeNode(NodeIdT id);
 
-    /**
-     * Get the log interface.
-     *
-     * @return the log interface
-     */
     LogInterface<TimestampT, PeerIdT, MetaT, NodeIdT> getLog();
 
-    /**
-     * Get the peer timestamp log interface.
-     *
-     * @return the peer timestamp log interface
-     */
     PeerTimestampLogInterface<TimestampT, PeerIdT> getPeerTimestampLog();
 }

dhfs-parent/kleppmanntree/src/main/java/com/usatiuk/kleppmanntree/TreeNode.java

@@ -5,92 +5,29 @@ import org.pcollections.PMap;
 
 import java.io.Serializable;
 
-/**
- * Represents a node in the Kleppmann tree.
- *
- * @param <TimestampT> the type of the timestamp
- * @param <PeerIdT>    the type of the peer ID
- * @param <MetaT>      the type of the node metadata
- * @param <NodeIdT>    the type of the node ID
- */
 public interface TreeNode<TimestampT extends Comparable<TimestampT>, PeerIdT extends Comparable<PeerIdT>, MetaT extends NodeMeta, NodeIdT> extends Serializable {
-    /**
-     * Get the ID of the node.
-     *
-     * @return the ID of the node
-     */
     NodeIdT key();
 
-    /**
-     * Get the ID of the parent node.
-     *
-     * @return the ID of the parent node
-     */
     NodeIdT parent();
 
-    /**
-     * Get the last effective operation that moved this node.
-     *
-     * @return the last effective operation
-     */
     OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> lastEffectiveOp();
 
-    /**
-     * Get the metadata stored in this node.
-     *
-     * @return the metadata of the node
-     */
     @Nullable
     MetaT meta();
 
-    /**
-     * Get the name of the node.
-     * If the node has metadata, the name is extracted from it, otherwise the key is converted to string.
-     *
-     * @return the name of the node
-     */
     default String name() {
         var meta = meta();
-        if (meta != null) return meta.name();
+        if (meta != null) return meta.getName();
         return key().toString();
     }
 
-    /**
-     * Get the children of this node.
-     *
-     * @return a map of child IDs to their respective nodes
-     */
     PMap<String, NodeIdT> children();
 
-    /**
-     * Make a copy of this node with a new parent.
-     *
-     * @param parent the ID of the new parent node
-     * @return a new TreeNode instance with the updated parent
-     */
     TreeNode<TimestampT, PeerIdT, MetaT, NodeIdT> withParent(NodeIdT parent);
 
-    /**
-     * Make a copy of this node with a new last effective operation.
-     *
-     * @param lastEffectiveOp the new last effective operation
-     * @return a new TreeNode instance with the updated last effective operation
-     */
     TreeNode<TimestampT, PeerIdT, MetaT, NodeIdT> withLastEffectiveOp(OpMove<TimestampT, PeerIdT, MetaT, NodeIdT> lastEffectiveOp);
 
-    /**
-     * Make a copy of this node with new metadata.
-     *
-     * @param meta the new metadata
-     * @return a new TreeNode instance with the updated metadata
-     */
     TreeNode<TimestampT, PeerIdT, MetaT, NodeIdT> withMeta(MetaT meta);
 
-    /**
-     * Make a copy of this node with new children.
-     *
-     * @param children the new children
-     * @return a new TreeNode instance with the updated children
-     */
     TreeNode<TimestampT, PeerIdT, MetaT, NodeIdT> withChildren(PMap<String, NodeIdT> children);
 }

dhfs-parent/kleppmanntree/src/test/java/com/usatiuk/kleppmanntree/TestNodeMeta.java

@@ -8,7 +8,7 @@ public abstract class TestNodeMeta implements NodeMeta {
     }
 
     @Override
-    public String name() {
+    public String getName() {
         return _name;
     }
 

dhfs-parent/objects/pom.xml

@@ -18,11 +18,6 @@
     </properties>
 
     <dependencies>
-        <dependency>
-            <groupId>net.jqwik</groupId>
-            <artifactId>jqwik</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-junit5</artifactId>
@@ -36,6 +31,10 @@
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-grpc</artifactId>
         </dependency>
+        <dependency>
+            <groupId>net.openhft</groupId>
+            <artifactId>zero-allocation-hashing</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
@@ -55,6 +54,11 @@
             <artifactId>utils</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
+        <dependency>
+            <groupId>com.usatiuk.dhfs</groupId>
+            <artifactId>supportlib</artifactId>
+            <version>1.0-SNAPSHOT</version>
+        </dependency>
         <dependency>
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-junit5-mockito</artifactId>

dhfs-parent/objects/src/main/java/com/usatiuk/objects/JData.java

@@ -2,20 +2,9 @@ package com.usatiuk.objects;
 
 import java.io.Serializable;
 
-/**
- * JData is a marker interface for all objects that can be stored in the object store.
- */
 public interface JData extends Serializable {
-    /**
-     * Returns the key of the object.
-     * @return the key of the object
-     */
     JObjectKey key();
 
-    /**
-     * Returns the estimated size of the object in bytes.
-     * @return the estimated size of the object in bytes
-     */
     default int estimateSize() {
         return 100;
     }

dhfs-parent/objects/src/main/java/com/usatiuk/objects/JDataVersionedWrapper.java

@@ -1,35 +1,9 @@
 package com.usatiuk.objects;
 
-import com.usatiuk.objects.iterators.Data;
-
-/**
- * JDataVersionedWrapper is a wrapper for JData that contains its version number
- * (the id of the transaction that had changed it last)
- */
-public sealed interface JDataVersionedWrapper extends Data<JDataVersionedWrapper> permits JDataVersionedWrapperLazy, JDataVersionedWrapperImpl {
-    @Override
-    default JDataVersionedWrapper value() {
-        return this;
-    }
-
-    /**
-     * Returns the wrapped object.
-     *
-     * @return the wrapped object
-     */
+public interface JDataVersionedWrapper {
     JData data();
 
-    /**
-     * Returns the version number of the object.
-     *
-     * @return the version number of the object
-     */
     long version();
 
-    /**
-     * Returns the estimated size of the object in bytes.
-     *
-     * @return the estimated size of the object in bytes
-     */
     int estimateSize();
 }

dhfs-parent/objects/src/main/java/com/usatiuk/objects/JDataVersionedWrapperImpl.java

@@ -4,9 +4,6 @@ import jakarta.annotation.Nonnull;
 
 import java.io.Serializable;
 
-/**
- * Simple wrapper for an already-existing JData object with a version.
- */
 public record JDataVersionedWrapperImpl(@Nonnull JData data,
                                         long version) implements Serializable, JDataVersionedWrapper {
     @Override

dhfs-parent/objects/src/main/java/com/usatiuk/objects/JDataVersionedWrapperLazy.java

@@ -2,47 +2,18 @@ package com.usatiuk.objects;
 
 import java.util.function.Supplier;
 
-/**
- * Lazy JDataVersionedWrapper implementation.
- * The object is deserialized only when data() is called for the first time.
- * Also allows to set a callback to be called when the data is loaded (e.g. to cache it).
- */
-public final class JDataVersionedWrapperLazy implements JDataVersionedWrapper {
+public class JDataVersionedWrapperLazy implements JDataVersionedWrapper {
     private final long _version;
     private final int _estimatedSize;
-    private JData _data;
     private Supplier<JData> _producer;
+    private JData _data;
 
-    /**
-     * Creates a new JDataVersionedWrapperLazy object.
-     *
-     * @param version       the version number of the object
-     * @param estimatedSize the estimated size of the object in bytes
-     * @param producer      a supplier that produces the wrapped object
-     */
     public JDataVersionedWrapperLazy(long version, int estimatedSize, Supplier<JData> producer) {
         _version = version;
         _estimatedSize = estimatedSize;
         _producer = producer;
     }
 
-    /**
-     * Set a callback to be called when the data is loaded.
-     *
-     * @param cacheCallback the callback to be called
-     */
-    public void setCacheCallback(Runnable cacheCallback) {
-        if (_data != null) {
-            throw new IllegalStateException("Cache callback can be set only before data is loaded");
-        }
-        var oldProducer = _producer;
-        _producer = () -> {
-            var ret = oldProducer.get();
-            cacheCallback.run();
-            return ret;
-        };
-    }
-
     public JData data() {
         if (_data != null)
             return _data;

dhfs-parent/objects/src/main/java/com/usatiuk/objects/JDataVersionedWrapperSerializer.java

@@ -2,26 +2,17 @@ package com.usatiuk.objects;
 
 
 import com.google.protobuf.ByteString;
+import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
 
 import java.nio.ByteBuffer;
 
-/**
- * Serializer for JDataVersionedWrapper objects.
- * The objects are stored in a simple format: first is 8-byte long, then the serialized object.
- */
-@Singleton
-public class JDataVersionedWrapperSerializer {
+@ApplicationScoped
+public class JDataVersionedWrapperSerializer implements ObjectSerializer<JDataVersionedWrapper> {
     @Inject
     ObjectSerializer<JData> dataSerializer;
 
-    /**
-     * Serializes a JDataVersionedWrapper object to a ByteString.
-     *
-     * @param obj the object to serialize
-     * @return the serialized object as a ByteString
-     */
+    @Override
     public ByteString serialize(JDataVersionedWrapper obj) {
         ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
         buffer.putLong(obj.version());
@@ -29,17 +20,10 @@ public class JDataVersionedWrapperSerializer {
         return ByteString.copyFrom(buffer).concat(dataSerializer.serialize(obj.data()));
     }
 
-    /**
-     * Deserializes a JDataVersionedWrapper object from a ByteBuffer.
-     * Returns a lazy wrapper (JDataVersionedWrapperLazy).
-     *
-     * @param data the ByteBuffer containing the serialized object
-     * @return the deserialized object
-     */
-    public JDataVersionedWrapper deserialize(ByteBuffer data) {
-        var version = data.getLong();
-        return new JDataVersionedWrapperLazy(version, data.remaining(),
-                () -> dataSerializer.deserialize(data)
-        );
+    @Override
+    public JDataVersionedWrapper deserialize(ByteString data) {
+        var version = data.substring(0, Long.BYTES).asReadOnlyByteBuffer().getLong();
+        var rawData = data.substring(Long.BYTES);
+        return new JDataVersionedWrapperLazy(version, rawData.size(), () -> dataSerializer.deserialize(rawData));
     }
 }

dhfs-parent/objects/src/main/java/com/usatiuk/objects/JObjectKey.java

@@ -1,76 +1,46 @@
 package com.usatiuk.objects;
 
+import com.google.protobuf.ByteString;
+import com.usatiuk.dhfs.supportlib.UninitializedByteBuffer;
+
 import java.io.Serializable;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.util.UUID;
 
-/**
- * JObjectKey is an interface for object keys to be used in the object store.
- */
 public sealed interface JObjectKey extends Serializable, Comparable<JObjectKey> permits JObjectKeyImpl, JObjectKeyMax, JObjectKeyMin {
     JObjectKeyMin MIN = new JObjectKeyMin();
     JObjectKeyMax MAX = new JObjectKeyMax();
 
-    /**
-     * Creates a new JObjectKey from a string value.
-     *
-     * @param value the string value of the key
-     * @return a new JObjectKey
-     */
     static JObjectKey of(String value) {
-        return new JObjectKeyImpl(value);
+        var heapBb = StandardCharsets.UTF_8.encode(value);
+        if (heapBb.isDirect()) return new JObjectKeyImpl(heapBb);
+        return fromByteBuffer(heapBb);
+    }
+
+    static JObjectKey of(ByteString value) {
+        var heapBb = value.asReadOnlyByteBuffer();
+        if (heapBb.isDirect()) return new JObjectKeyImpl(heapBb);
+        return fromByteBuffer(heapBb);
     }
 
-    /**
-     * Creates a new JObjectKey with a random UUID.
-     *
-     * @return a new JObjectKey with a random UUID
-     */
     static JObjectKey random() {
-        return new JObjectKeyImpl(UUID.randomUUID().toString());
+        return JObjectKey.of(UUID.randomUUID().toString());
     }
 
-    /**
-     * Returns a JObjectKey that compares less than all other keys.
-     * Calling value on this key will result in an exception.
-     *
-     * @return a JObjectKey that compares less than all other keys
-     */
     static JObjectKey first() {
         return MIN;
     }
 
-    /**
-     * Returns a JObjectKey that compares greater than all other keys.
-     * Calling value on this key will result in an exception.
-     *
-     * @return a JObjectKey that compares greater than all other keys
-     */
     static JObjectKey last() {
         return MAX;
     }
 
-    /**
-     * Creates a new JObjectKey from a byte array.
-     *
-     * @param bytes the byte array representing the key
-     * @return a new JObjectKey
-     */
-    static JObjectKey fromBytes(byte[] bytes) {
-        return new JObjectKeyImpl(new String(bytes, StandardCharsets.ISO_8859_1));
-    }
-
-    /**
-     * Creates a new JObjectKey from a ByteBuffer.
-     *
-     * @param buff the ByteBuffer representing the key
-     * @return a new JObjectKey
-     */
     static JObjectKey fromByteBuffer(ByteBuffer buff) {
-        byte[] bytes = new byte[buff.remaining()];
-        buff.get(bytes);
-        return new JObjectKeyImpl(bytes);
+        var directBb = UninitializedByteBuffer.allocateUninitialized(buff.remaining());
+        directBb.put(buff);
+        directBb.flip();
+        return new JObjectKeyImpl(directBb);
     }
 
     @Override
@@ -79,17 +49,7 @@ public sealed interface JObjectKey extends Serializable, Comparable<JObjectKey>
     @Override
     String toString();
 
-    /**
-     * Returns the byte buffer representation of the key.
-     *
-     * @return the byte buffer representation of the key
-     */
     ByteBuffer toByteBuffer();
 
-    /**
-     * Returns the string value of the key.
-     *
-     * @return the string value of the key
-     */
-    String value();
+    ByteString value();
 }

dhfs-parent/objects/src/main/java/com/usatiuk/objects/JObjectKeyImpl.java

@@ -1,34 +1,71 @@
 package com.usatiuk.objects;
 
-import com.usatiuk.utils.UninitializedByteBuffer;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.UnsafeByteOperations;
+import com.usatiuk.dhfs.supportlib.UninitializedByteBuffer;
 
-import java.io.Serial;
+import java.io.*;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
+import java.util.Base64;
 import java.util.Objects;
 
-/**
- * A "real" implementation of JObjectKey, containing an underlying string, and a cached lazily created byte buffer.
- */
-public final class JObjectKeyImpl implements JObjectKey {
-    @Serial
-    private static final long serialVersionUID = 0L;
-    private final String value;
-    private transient ByteBuffer _bb = null;
+public record JObjectKeyImpl(SerializableByteBufferWrapper rawValue) implements JObjectKey {
+    private static class SerializableByteBufferWrapper implements Serializable {
+        @Serial
+        private static final long serialVersionUID = 1L;
+        private ByteBuffer byteBuffer;
 
-    public JObjectKeyImpl(String value) {
-        this.value = value;
+        public SerializableByteBufferWrapper(ByteBuffer byteBuffer) {
+            this.byteBuffer = byteBuffer;
+        }
+
+        public ByteBuffer getByteBuffer() {
+            return byteBuffer;
+        }
+
+        @Serial
+        private void writeObject(ObjectOutputStream out) throws IOException {
+            var readOnlyBuffer = byteBuffer.asReadOnlyBuffer();
+            var barr = new byte[readOnlyBuffer.remaining()];
+            readOnlyBuffer.get(barr);
+            out.writeInt(barr.length);
+            out.write(barr);
+        }
+
+        @Serial
+        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+            int length = in.readInt();
+            ByteBuffer byteBuffer = UninitializedByteBuffer.allocateUninitialized(length);
+            var bytes = new byte[length];
+            in.readFully(bytes);
+            byteBuffer.put(bytes);
+            byteBuffer.flip();
+            this.byteBuffer = byteBuffer;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == null || getClass() != o.getClass()) return false;
+            SerializableByteBufferWrapper that = (SerializableByteBufferWrapper) o;
+            return Objects.equals(byteBuffer, that.byteBuffer);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hashCode(byteBuffer);
+        }
     }
 
-    public JObjectKeyImpl(byte[] bytes) {
-        this.value = new String(bytes, StandardCharsets.ISO_8859_1);
+    JObjectKeyImpl(ByteBuffer byteBuffer) {
+        this(new SerializableByteBufferWrapper(byteBuffer));
     }
 
     @Override
     public int compareTo(JObjectKey o) {
         switch (o) {
             case JObjectKeyImpl jObjectKeyImpl -> {
-                return value.compareTo(jObjectKeyImpl.value());
+                return rawValue.getByteBuffer().compareTo(jObjectKeyImpl.rawValue().getByteBuffer());
             }
             case JObjectKeyMax jObjectKeyMax -> {
                 return -1;
@@ -41,40 +78,18 @@ public final class JObjectKeyImpl implements JObjectKey {
 
     @Override
     public String toString() {
-        return value;
+        var encoded = Base64.getEncoder().encode(toByteBuffer());
+        return StandardCharsets.US_ASCII.decode(encoded).toString();
+    }
+
+    @Override
+    public ByteString value() {
+        return UnsafeByteOperations.unsafeWrap(toByteBuffer());
     }
 
     @Override
     public ByteBuffer toByteBuffer() {
-        if (_bb != null) return _bb;
-
-        synchronized (this) {
-            if (_bb != null) return _bb;
-            var bytes = value.getBytes(StandardCharsets.ISO_8859_1);
-            var directBb = UninitializedByteBuffer.allocate(bytes.length);
-            directBb.put(bytes);
-            directBb.flip();
-            _bb = directBb;
-            return directBb;
-        }
-    }
-
-    @Override
-    public String value() {
-        return value;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == this) return true;
-        if (obj == null || obj.getClass() != this.getClass()) return false;
-        var that = (JObjectKeyImpl) obj;
-        return Objects.equals(this.value, that.value);
-    }
-
-    @Override
-    public int hashCode() {
-        return value.hashCode();
+        return rawValue.getByteBuffer().asReadOnlyBuffer();
     }
 
 }

dhfs-parent/objects/src/main/java/com/usatiuk/objects/JObjectKeyMax.java

@@ -1,10 +1,9 @@
 package com.usatiuk.objects;
 
+import com.google.protobuf.ByteString;
+
 import java.nio.ByteBuffer;
 
-/**
- * JObjectKey implementation that compares greater than all other keys.
- */
 public record JObjectKeyMax() implements JObjectKey {
     @Override
     public int compareTo(JObjectKey o) {
@@ -27,7 +26,7 @@ public record JObjectKeyMax() implements JObjectKey {
     }
 
     @Override
-    public String value() {
+    public ByteString value() {
         throw new UnsupportedOperationException();
     }
 }

dhfs-parent/objects/src/main/java/com/usatiuk/objects/JObjectKeyMin.java

@@ -1,10 +1,9 @@
 package com.usatiuk.objects;
 
+import com.google.protobuf.ByteString;
+
 import java.nio.ByteBuffer;
 
-/**
- * JObjectKey implementation that compares less than all other keys.
- */
 public record JObjectKeyMin() implements JObjectKey {
     @Override
     public int compareTo(JObjectKey o) {
@@ -27,7 +26,7 @@ public record JObjectKeyMin() implements JObjectKey {
     }
 
     @Override
-    public String value() {
+    public ByteString value() {
         throw new UnsupportedOperationException();
     }
 }