a bit more cleanup with metadata

server/src/main/java/com/usatiuk/dhfs/storage/objects/repository/distributed/DistributedObjectRepository.java

@@ -84,7 +84,7 @@ public class DistributedObjectRepository implements ObjectRepository {
 
         var info = infoOpt.get();
 
-        Optional<byte[]> read = info.runReadLocked(() -> {
+        Optional<byte[]> read = info.runReadLocked((data) -> {
             if (objectPersistentStore.existsObject(name))
                 return Optional.of(objectPersistentStore.readObject(name));
             return Optional.empty();
@@ -92,7 +92,7 @@ public class DistributedObjectRepository implements ObjectRepository {
         if (read.isPresent()) return read.get();
         // Race?
 
-        return info.runWriteLocked(() -> {
+        return info.runWriteLocked((data) -> {
             var obj = remoteObjectServiceClient.getObject(name);
             objectPersistentStore.writeObject(name, obj);
             return obj;
@@ -104,7 +104,7 @@ public class DistributedObjectRepository implements ObjectRepository {
     public void writeObject(String name, byte[] data, Boolean canIgnoreConflict) {
         var info = objectIndexService.getOrCreateMeta(name, canIgnoreConflict);
 
-        info.runWriteLocked(() -> {
+        info.runWriteLocked((metaData) -> {
             objectPersistentStore.writeObject(name, data);
             var prevMtime = info.getMtime();
             info.setMtime(System.currentTimeMillis());

server/src/main/java/com/usatiuk/dhfs/storage/objects/repository/distributed/ObjectMeta.java

@@ -1,61 +1,50 @@
 package com.usatiuk.dhfs.storage.objects.repository.distributed;
 
-import lombok.Getter;
-
 import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.Callable;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 
 public class ObjectMeta implements Serializable {
     public ObjectMeta(String name, Boolean assumeUnique) {
-        this._name = name;
+        _data = new ObjectMetaData(name, assumeUnique);
-        this._assumeUnique = assumeUnique;
     }
 
+    private final ObjectMetaData _data;
     private final ReadWriteLock _lock = new ReentrantReadWriteLock();
 
-    @Getter
-    final String _name;
-
-    long _mtime;
-
-    @Getter
-    final Boolean _assumeUnique;
-
-    //FIXME:
-    final List<String> _remoteCopies = new ArrayList<>();
-
     public void setMtime(long mtime) {
-        runWriteLocked(() -> {
+        runWriteLocked((data) -> {
-            _mtime = mtime;
+            data.setMtime(mtime);
             return null;
         });
     }
 
     public long getMtime() {
-        return runReadLocked(() -> _mtime);
+        return runReadLocked((data) -> data.getMtime());
     }
 
-    public <R> R runReadLocked(Callable<R> fn) {
+    public boolean getAssumeUnique() {
+        return runReadLocked((data) -> data.getAssumeUnique());
+    }
+
+    @FunctionalInterface
+    public interface ObjectMetaFn<R> {
+        R apply(ObjectMetaData indexData);
+    }
+
+    public <R> R runReadLocked(ObjectMetaFn<R> fn) {
         _lock.readLock().lock();
         try {
-            return fn.call();
+            return fn.apply(_data);
-        } catch (Exception e) {
-            throw new RuntimeException(e);
         } finally {
             _lock.readLock().unlock();
         }
     }
 
-    public <R> R runWriteLocked(Callable<R> fn) {
+    public <R> R runWriteLocked(ObjectMetaFn<R> fn) {
         _lock.writeLock().lock();
         try {
-            return fn.call();
+            return fn.apply(_data);
-        } catch (Exception e) {
-            throw new RuntimeException(e);
         } finally {
             _lock.writeLock().unlock();
         }

server/src/main/java/com/usatiuk/dhfs/storage/objects/repository/distributed/ObjectMetaData.java

@@ -0,0 +1,28 @@
+package com.usatiuk.dhfs.storage.objects.repository.distributed;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ObjectMetaData implements Serializable {
+    public ObjectMetaData(String name, Boolean assumeUnique) {
+        _name = name;
+        _assumeUnique = assumeUnique;
+    }
+
+    @Getter
+    final String _name;
+
+    @Getter
+    @Setter
+    long _mtime;
+
+    @Getter
+    final Boolean _assumeUnique;
+
+    @Getter
+    final List<String> _remoteCopies = new ArrayList<>();
+}

server/src/main/java/com/usatiuk/dhfs/storage/objects/repository/distributed/RemoteObjectServiceServer.java

@@ -33,7 +33,7 @@ public class RemoteObjectServiceServer implements DhfsObjectSyncGrpc {
         var metaOpt = objectIndexService.getMeta(request.getName());
         if (metaOpt.isEmpty()) throw new StatusRuntimeException(Status.NOT_FOUND);
         var meta = metaOpt.get();
-        Optional<Pair<Long, byte[]>> read = meta.runReadLocked(() -> {
+        Optional<Pair<Long, byte[]>> read = meta.runReadLocked((data) -> {
             if (objectPersistentStore.existsObject(request.getName()))
                 return Optional.of(Pair.of(meta.getMtime(), objectPersistentStore.readObject(request.getName())));
             return Optional.empty();

server/src/main/java/com/usatiuk/dhfs/storage/objects/repository/distributed/SyncHandler.java

@@ -5,7 +5,6 @@ import com.usatiuk.dhfs.objects.repository.distributed.IndexUpdateReply;
 import com.usatiuk.dhfs.storage.objects.jrepository.JObjectManager;
 import com.usatiuk.dhfs.storage.objects.repository.persistence.ObjectPersistentStore;
 import io.quarkus.logging.Log;
-import io.smallrye.mutiny.Uni;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
 import org.apache.commons.lang3.NotImplementedException;
@@ -22,32 +21,32 @@ public class SyncHandler {
     JObjectManager jObjectManager;
 
     public IndexUpdateReply handleRemoteUpdate(IndexUpdatePush request) {
-        var metaOpt = objectIndexService.getOrCreateMeta(request.getName(), request.getAssumeUnique());
+        var meta = objectIndexService.getOrCreateMeta(request.getName(), request.getAssumeUnique());
-        metaOpt.runWriteLocked(() -> {
+        meta.runWriteLocked((data) -> {
-            if (metaOpt.getMtime() == request.getMtime()) {
+            if (meta.getMtime() == request.getMtime()) {
-                metaOpt._remoteCopies.add(request.getSelfname());
+                data.getRemoteCopies().add(request.getSelfname());
                 return null;
             }
 
-            if (metaOpt.getMtime() != request.getPrevMtime()) {
+            if (meta.getMtime() != request.getPrevMtime()) {
-                if (!metaOpt.getAssumeUnique()
+                if (!meta.getAssumeUnique()
-                        || (metaOpt.getAssumeUnique() != request.getAssumeUnique())) {
+                        || (meta.getAssumeUnique() != request.getAssumeUnique())) {
                     Log.error("Conflict!");
                     throw new NotImplementedException();
                 }
             }
 
-            metaOpt.setMtime(request.getMtime());
+            meta.setMtime(request.getMtime());
 
-            metaOpt._remoteCopies.clear();
+            data.getRemoteCopies().clear();
-            metaOpt._remoteCopies.add(request.getSelfname());
+            data.getRemoteCopies().add(request.getSelfname());
 
             try {
                 objectPersistentStore.deleteObject(request.getName());
             } catch (Exception ignored) {
             }
 
-            jObjectManager.invalidateJObject(metaOpt.getName());
+            jObjectManager.invalidateJObject(data.getName());
 
             return null;
         });