Merge branch 'master' of https://cs.idc.ac.il/rhodecode/meerkat/meerkat-java

.gitignore

@@ -13,4 +13,6 @@ out
 *.prefs
 *.project
 *.classpath
-bulletin-board-server/local-instances/meerkat.db
+*.db
+*.sql
+.arcconfig

bulletin-board-client/build.gradle

@@ -69,7 +69,7 @@ dependencies {
 
 test {
     exclude '**/*IntegrationTest*'
-    outputs.upToDateWhen { false }
+//    outputs.upToDateWhen { false }
 }
 
 task integrationTest(type: Test) {

bulletin-board-client/src/main/java/meerkat/bulletinboard/BatchDataContainer.java

@@ -1,7 +1,7 @@
 package meerkat.bulletinboard;
 
-import com.google.protobuf.ByteString;
-import meerkat.protobuf.BulletinBoardAPI.BatchData;
+import meerkat.protobuf.BulletinBoardAPI.BatchChunk;
+import meerkat.bulletinboard.AsyncBulletinBoardClient.BatchIdentifier;
 
 import java.util.List;
 
@@ -11,15 +11,13 @@ import java.util.List;
  */
 public class BatchDataContainer {
 
-    public final byte[] signerId;
-    public final int batchId;
-    public final List<BatchData> batchDataList;
+    public final MultiServerBatchIdentifier batchId;
+    public final List<BatchChunk> batchChunkList;
     public final int startPosition;
 
-    public BatchDataContainer(byte[] signerId, int batchId, List<BatchData> batchDataList, int startPosition) {
-        this.signerId = signerId;
+    public BatchDataContainer(MultiServerBatchIdentifier batchId, List<BatchChunk> batchChunkList, int startPosition) {
         this.batchId = batchId;
-        this.batchDataList = batchDataList;
+        this.batchChunkList = batchChunkList;
         this.startPosition = startPosition;
     }
 }

bulletin-board-client/src/main/java/meerkat/bulletinboard/CachedBulletinBoardClient.java

@@ -1,168 +1,490 @@
 package meerkat.bulletinboard;
 
 import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.ListeningScheduledExecutorService;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.protobuf.ByteString;
+import com.google.protobuf.Timestamp;
 import meerkat.comm.CommunicationException;
-import meerkat.protobuf.BulletinBoardAPI;
 import meerkat.protobuf.BulletinBoardAPI.*;
+import meerkat.protobuf.Crypto.Signature;
 import meerkat.protobuf.Voting.*;
 
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
-import java.util.concurrent.Executors;
 
 /**
  * Created by Arbel Deutsch Peled on 03-Mar-16.
  * This is a full-fledged implementation of a Bulletin Board Client
  * It provides asynchronous access to several remote servers, as well as a local cache
- * Read/write operations are performed on the local server
+ * Read operations are performed on the local server
+ * Batch reads are performed on the local server and, if they fail, also on the remote servers
+ * Write operations are performed on the local server
+ * A Synchronizer is employed in order to keep the remote server up to date
  * After any read is carried out, a subscription is made for the specific query to make sure the local DB will be updated
  * The database also employs a synchronizer which makes sure local data is sent to the remote servers
  */
-public class CachedBulletinBoardClient implements SubscriptionAsyncBulletinBoardClient {
+public class CachedBulletinBoardClient implements SubscriptionBulletinBoardClient {
 
-    private final BulletinBoardClient localClient;
-    private AsyncBulletinBoardClient remoteClient;
-    private BulletinBoardSubscriber subscriber;
+    private final AsyncBulletinBoardClient localClient;
+    private final AsyncBulletinBoardClient remoteClient;
+    private final AsyncBulletinBoardClient queueClient;
+    private final BulletinBoardSubscriber subscriber;
+    private final BulletinBoardSynchronizer synchronizer;
 
-    private final int threadPoolSize;
-    private final long failDelayInMilliseconds;
-    private final long subscriptionIntervalInMilliseconds;
+    private Thread syncThread;
 
-    public CachedBulletinBoardClient(BulletinBoardClient localClient,
-                                     int threadPoolSize,
-                                     long failDelayInMilliseconds,
-                                     long subscriptionIntervalInMilliseconds)
-            throws IllegalAccessException, InstantiationException {
+    private final static int DEFAULT_WAIT_CAP = 3000;
+    private final static int DEFAULT_SLEEP_INTERVAL = 3000;
+
+    private class SubscriptionStoreCallback implements FutureCallback<List<BulletinBoardMessage>>  {
+
+        private final FutureCallback<List<BulletinBoardMessage>> callback;
+
+        public SubscriptionStoreCallback(){
+            callback = null;
+        }
+
+        public SubscriptionStoreCallback(FutureCallback<List<BulletinBoardMessage>> callback){
+            this.callback = callback;
+        }
+
+        @Override
+        public void onSuccess(List<BulletinBoardMessage> result) {
+            for (BulletinBoardMessage msg : result) {
+                try {
+
+                    if (msg.getMsg().getDataTypeCase() == UnsignedBulletinBoardMessage.DataTypeCase.MSGID) {
+
+                        // This is a batch message: need to upload batch data as well as the message itself
+                        BulletinBoardMessage completeMessage = localClient.readBatchData(msg);
+
+                        localClient.postMessage(completeMessage);
+
+                    } else {
+
+                        // This is a regular message: post it
+                        localClient.postMessage(msg);
+
+                    }
+
+                } catch (CommunicationException ignored) {
+                    // TODO: log
+                }
+            }
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            if (callback != null) {
+                callback.onFailure(t);  // This is some hard error that cannot be dealt with
+            }
+        }
+
+    }
+
+    /**
+     * Creates a Cached Client
+     * Assumes all parameters are initialized
+     * @param localClient is a Client for the local instance
+     * @param remoteClient is a Client for the remote instance(s); Should have endless retries for post operations
+     * @param subscriber is a subscription service to the remote instance(s)
+     * @param queueClient is a client for a local deletable server to be used as a queue for not-yet-uploaded messages
+     */
+    public CachedBulletinBoardClient(AsyncBulletinBoardClient localClient,
+                                     AsyncBulletinBoardClient remoteClient,
+                                     BulletinBoardSubscriber subscriber,
+                                     DeletableSubscriptionBulletinBoardClient queueClient,
+                                     int sleepInterval,
+                                     int waitCap) {
 
         this.localClient = localClient;
-        this.threadPoolSize = threadPoolSize;
-        this.failDelayInMilliseconds = failDelayInMilliseconds;
-        this.subscriptionIntervalInMilliseconds = subscriptionIntervalInMilliseconds;
+        this.remoteClient = remoteClient;
+        this.subscriber = subscriber;
+        this.queueClient = queueClient;
 
-        remoteClient = new ThreadedBulletinBoardClient();
+        this.synchronizer = new SimpleBulletinBoardSynchronizer(sleepInterval,waitCap);
+        synchronizer.init(queueClient, remoteClient);
+        syncThread = new Thread(synchronizer);
+        syncThread.start();
+    }
+
+    /**
+     * Creates a Cached Client
+     * Used default values foe the time caps
+     * */
+    public CachedBulletinBoardClient(AsyncBulletinBoardClient localClient,
+                                     AsyncBulletinBoardClient remoteClient,
+                                     BulletinBoardSubscriber subscriber,
+                                     DeletableSubscriptionBulletinBoardClient queue) {
+
+        this(localClient, remoteClient, subscriber, queue, DEFAULT_SLEEP_INTERVAL, DEFAULT_WAIT_CAP);
+    }
+
+    @Override
+    public MessageID postMessage(final BulletinBoardMessage msg, final FutureCallback<Boolean> callback) {
+
+        return localClient.postMessage(msg, new FutureCallback<Boolean>() {
+            @Override
+            public void onSuccess(Boolean result) {
+                remoteClient.postMessage(msg, callback);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                if (callback != null)
+                    callback.onFailure(t);
+            }
+        });
 
     }
 
     @Override
-    public MessageID postMessage(BulletinBoardMessage msg, FutureCallback<Boolean> callback) {
-        return null;
+    public MessageID postAsBatch(final BulletinBoardMessage msg, final int chunkSize, final FutureCallback<Boolean> callback) {
+
+        return localClient.postAsBatch(msg, chunkSize, new FutureCallback<Boolean>() {
+            @Override
+            public void onSuccess(Boolean result) {
+                remoteClient.postAsBatch(msg, chunkSize, callback);
             }
 
             @Override
-    public MessageID postBatch(CompleteBatch completeBatch, FutureCallback<Boolean> callback) {
-        return null;
+            public void onFailure(Throwable t) {
+                if (callback != null)
+                    callback.onFailure(t);
             }
-
-    @Override
-    public void beginBatch(BeginBatchMessage beginBatchMessage, FutureCallback<Boolean> callback) {
+        });
 
     }
 
     @Override
-    public void postBatchData(byte[] signerId, int batchId, List<BatchData> batchDataList, int startPosition, FutureCallback<Boolean> callback) {
+    public void beginBatch(final Iterable<String> tags, final FutureCallback<BatchIdentifier> callback) {
+
+        localClient.beginBatch(tags, new FutureCallback<BatchIdentifier>() {
+
+            private BatchIdentifier localIdentifier;
+
+            @Override
+            public void onSuccess(BatchIdentifier result) {
+
+                localIdentifier = result;
+
+                remoteClient.beginBatch(tags, new FutureCallback<BatchIdentifier>() {
+                    @Override
+                    public void onSuccess(BatchIdentifier result) {
+                        if (callback != null)
+                            callback.onSuccess(new CachedClientBatchIdentifier(localIdentifier, result));
+                    }
+
+                    @Override
+                    public void onFailure(Throwable t) {
+                        if (callback != null)
+                            callback.onFailure(t);
+                    }
+                });
 
             }
 
             @Override
-    public void postBatchData(byte[] signerId, int batchId, List<BatchData> batchDataList, FutureCallback<Boolean> callback) {
+            public void onFailure(Throwable t) {
+                if (callback != null)
+                    callback.onFailure(t);
+            }
+        });
 
     }
 
     @Override
-    public void postBatchData(ByteString signerId, int batchId, List<BatchData> batchDataList, int startPosition, FutureCallback<Boolean> callback) {
+    public void postBatchData(final BatchIdentifier batchIdentifier, final List<BatchChunk> batchChunkList,
+                              final int startPosition, final FutureCallback<Boolean> callback) throws IllegalArgumentException{
+
+        if (!(batchIdentifier instanceof CachedClientBatchIdentifier)){
+            throw new IllegalArgumentException("Error: batch identifier supplied was not created by this class.");
+        }
+
+        final CachedClientBatchIdentifier identifier = (CachedClientBatchIdentifier) batchIdentifier;
+
+        localClient.postBatchData(identifier.getLocalIdentifier(), batchChunkList, startPosition, new FutureCallback<Boolean>() {
+            @Override
+            public void onSuccess(Boolean result) {
+                remoteClient.postBatchData(identifier.getRemoteIdentifier(), batchChunkList, startPosition, callback);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                if (callback != null)
+                    callback.onFailure(t);
+            }
+        });
 
     }
 
     @Override
-    public void postBatchData(ByteString signerId, int batchId, List<BatchData> batchDataList, FutureCallback<Boolean> callback) {
+    public void postBatchData(final BatchIdentifier batchIdentifier, final List<BatchChunk> batchChunkList, final FutureCallback<Boolean> callback)
+            throws IllegalArgumentException{
+
+        if (!(batchIdentifier instanceof CachedClientBatchIdentifier)){
+            throw new IllegalArgumentException("Error: batch identifier supplied was not created by this class.");
+        }
+
+        final CachedClientBatchIdentifier identifier = (CachedClientBatchIdentifier) batchIdentifier;
+
+        localClient.postBatchData(identifier.getLocalIdentifier(), batchChunkList, new FutureCallback<Boolean>() {
+            @Override
+            public void onSuccess(Boolean result) {
+                remoteClient.postBatchData(identifier.getRemoteIdentifier(), batchChunkList, callback);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                if (callback != null)
+                    callback.onFailure(t);
+            }
+        });
 
     }
 
     @Override
-    public void closeBatch(CloseBatchMessage closeBatchMessage, FutureCallback<Boolean> callback) {
+    public void closeBatch(final BatchIdentifier batchIdentifier, final Timestamp timestamp, final Iterable<Signature> signatures,
+                           final FutureCallback<Boolean> callback) {
+
+        if (!(batchIdentifier instanceof CachedClientBatchIdentifier)){
+            throw new IllegalArgumentException("Error: batch identifier supplied was not created by this class.");
+        }
+
+        final CachedClientBatchIdentifier identifier = (CachedClientBatchIdentifier) batchIdentifier;
+
+        localClient.closeBatch(identifier.getLocalIdentifier(), timestamp, signatures, new FutureCallback<Boolean>() {
+            @Override
+            public void onSuccess(Boolean result) {
+
+                remoteClient.closeBatch(identifier.getRemoteIdentifier(), timestamp, signatures, callback);
+
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                if (callback != null)
+                    callback.onFailure(t);
+            }
+        });
 
     }
 
     @Override
     public void getRedundancy(MessageID id, FutureCallback<Float> callback) {
 
-    }
-
-    @Override
-    public void readMessages(MessageFilterList filterList, FutureCallback<List<BulletinBoardMessage>> callback) {
+        remoteClient.getRedundancy(id, callback);
 
     }
 
     @Override
-    public void readBatch(BatchSpecificationMessage batchSpecificationMessage, FutureCallback<CompleteBatch> callback) {
+    public void readMessages(MessageFilterList filterList, final FutureCallback<List<BulletinBoardMessage>> callback) {
+
+        localClient.readMessages(filterList, callback);
+
+        subscriber.subscribe(filterList, new SubscriptionStoreCallback(callback));
+
+    }
+
+    @Override
+    public void readMessage(final MessageID msgID, final FutureCallback<BulletinBoardMessage> callback) {
+
+        localClient.readMessage(msgID, new FutureCallback<BulletinBoardMessage>() {
+
+            @Override
+            public void onSuccess(BulletinBoardMessage result) {
+                if (callback != null)
+                    callback.onSuccess(result);     // Read from local client was successful
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+
+                // Read from local unsuccessful: try to read from remote
+
+                remoteClient.readMessage(msgID, new FutureCallback<BulletinBoardMessage>() {
+
+                    @Override
+                    public void onSuccess(BulletinBoardMessage result) {
+
+                        // Read from remote was successful: store in local and return result
+
+                        localClient.postMessage(result, null);
+
+                        if (callback != null)
+                            callback.onSuccess(result);
+
+                    }
+
+                    @Override
+                    public void onFailure(Throwable t) {
+
+                        // Read from remote was unsuccessful: report error
+                        if (callback != null)
+                            callback.onFailure(t);
+
+                    }
+
+                });
+
+            }
+
+        });
+
+    }
+
+    @Override
+    public void readBatchData(final BulletinBoardMessage stub, final FutureCallback<BulletinBoardMessage> callback) throws IllegalArgumentException {
+
+        localClient.readBatchData(stub, new FutureCallback<BulletinBoardMessage>() {
+
+            @Override
+            public void onSuccess(BulletinBoardMessage result) {
+                if (callback != null)
+                    callback.onSuccess(result);     // Read from local client was successful
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+
+                // Read from local unsuccessful: try to read from remote
+
+                remoteClient.readBatchData(stub, new FutureCallback<BulletinBoardMessage>() {
+
+                    @Override
+                    public void onSuccess(BulletinBoardMessage result) {
+
+                        // Read from remote was successful: store in local and return result
+
+                        localClient.postMessage(result, null);
+
+                        if (callback != null)
+                            callback.onSuccess(result);
+
+                    }
+
+                    @Override
+                    public void onFailure(Throwable t) {
+
+                        // Read from remote was unsuccessful: report error
+                        if (callback != null)
+                            callback.onFailure(t);
+
+                    }
+
+                });
+
+            }
+
+        });
 
     }
 
     @Override
     public void querySync(SyncQuery syncQuery, FutureCallback<SyncQueryResponse> callback) {
 
+        localClient.querySync(syncQuery, callback);
+
     }
 
     @Override
-    public void init(BulletinBoardClientParams clientParams) {
-
-        remoteClient.init(clientParams);
-
-        ListeningScheduledExecutorService executorService = MoreExecutors.listeningDecorator(Executors.newScheduledThreadPool(threadPoolSize));
-
-        List<SubscriptionAsyncBulletinBoardClient> subscriberClients = new ArrayList<>(clientParams.getBulletinBoardAddressCount());
-
-        for (String address : clientParams.getBulletinBoardAddressList()){
-
-            SubscriptionAsyncBulletinBoardClient newClient =
-                    new SingleServerBulletinBoardClient(executorService, failDelayInMilliseconds, subscriptionIntervalInMilliseconds);
-
-            newClient.init(clientParams.toBuilder().clearBulletinBoardAddress().addBulletinBoardAddress(address).build());
-
-            subscriberClients.add(newClient);
-
-        }
-
-        subscriber = new ThreadedBulletinBoardSubscriber(subscriberClients, localClient);
-
-    }
+    /**
+     * This is a stub method
+     * All resources are assumed to be initialized
+     */
+    public void init(BulletinBoardClientParams clientParams) {}
 
     @Override
     public MessageID postMessage(BulletinBoardMessage msg) throws CommunicationException {
-        return null;
+        return localClient.postMessage(msg);
     }
 
     @Override
-    public float getRedundancy(MessageID id) {
-        return 0;
+    public MessageID postAsBatch(BulletinBoardMessage msg, int chunkSize) throws CommunicationException {
+        MessageID result = localClient.postAsBatch(msg, chunkSize);
+        remoteClient.postAsBatch(msg, chunkSize);
+        return  result;
     }
 
     @Override
-    public List<BulletinBoardMessage> readMessages(MessageFilterList filterList) {
-        return null;
+    public float getRedundancy(MessageID id) throws CommunicationException {
+        return remoteClient.getRedundancy(id);
     }
 
     @Override
-    public SyncQuery generateSyncQuery(GenerateSyncQueryParams GenerateSyncQueryParams) throws CommunicationException {
-        return null;
+    public List<BulletinBoardMessage> readMessages(MessageFilterList filterList) throws CommunicationException {
+        subscriber.subscribe(filterList, new SubscriptionStoreCallback());
+        return localClient.readMessages(filterList);
+    }
+
+    @Override
+    public BulletinBoardMessage readMessage(MessageID msgID) throws CommunicationException {
+
+        BulletinBoardMessage result = null;
+        try {
+            result = localClient.readMessage(msgID);
+        } catch (CommunicationException e) {
+            //TODO: log
+        }
+
+        if (result == null){
+            result = remoteClient.readMessage(msgID);
+
+            if (result != null){
+                localClient.postMessage(result);
+            }
+
+        }
+
+        return result;
+
+    }
+
+    @Override
+    public BulletinBoardMessage readBatchData(BulletinBoardMessage stub) throws CommunicationException, IllegalArgumentException {
+
+        BulletinBoardMessage result = null;
+        try {
+            result = localClient.readBatchData(stub);
+        } catch (CommunicationException e) {
+            //TODO: log
+        }
+
+        if (result == null){
+            result = remoteClient.readBatchData(stub);
+
+            if (result != null){
+                localClient.postMessage(result);
+            }
+
+        }
+
+        return result;
+
+    }
+
+    @Override
+    public SyncQuery generateSyncQuery(GenerateSyncQueryParams generateSyncQueryParams) throws CommunicationException {
+        return localClient.generateSyncQuery(generateSyncQueryParams);
     }
 
     @Override
     public void close() {
-
+        localClient.close();
+        remoteClient.close();
+        synchronizer.stop();
+        try {
+            syncThread.join();
+        } catch (InterruptedException e) {
+            //TODO: log interruption
+        }
     }
 
     @Override
     public void subscribe(MessageFilterList filterList, FutureCallback<List<BulletinBoardMessage>> callback) {
-
+        subscriber.subscribe(filterList, new SubscriptionStoreCallback(callback));
     }
 
     @Override
     public void subscribe(MessageFilterList filterList, long startEntry, FutureCallback<List<BulletinBoardMessage>> callback) {
-
+        subscriber.subscribe(filterList, startEntry, new SubscriptionStoreCallback(callback));
     }
+
 }

bulletin-board-client/src/main/java/meerkat/bulletinboard/CachedClientBatchIdentifier.java

@@ -0,0 +1,29 @@
+package meerkat.bulletinboard;
+
+import meerkat.bulletinboard.AsyncBulletinBoardClient.BatchIdentifier;
+
+import java.util.Arrays;
+
+/**
+ * Created by Arbel Deutsch Peled on 17-Jun-16.
+ */
+public final class CachedClientBatchIdentifier implements BatchIdentifier {
+
+    // Per-server identifiers
+    private final BatchIdentifier localIdentifier;
+    private final BatchIdentifier remoteIdentifier;
+
+    public CachedClientBatchIdentifier(BatchIdentifier localIdentifier, BatchIdentifier remoteIdentifier) {
+        this.localIdentifier = localIdentifier;
+        this.remoteIdentifier = remoteIdentifier;
+    }
+
+    public BatchIdentifier getLocalIdentifier() {
+        return localIdentifier;
+    }
+
+    public BatchIdentifier getRemoteIdentifier() {
+        return remoteIdentifier;
+    }
+
+}

bulletin-board-client/src/main/java/meerkat/bulletinboard/LocalBulletinBoardClient.java

@@ -1,20 +1,21 @@
 package meerkat.bulletinboard;
 
 import com.google.common.util.concurrent.*;
-import com.google.protobuf.ByteString;
+import com.google.protobuf.Int64Value;
+import com.google.protobuf.Timestamp;
 import meerkat.comm.CommunicationException;
 import meerkat.comm.MessageInputStream;
 import meerkat.comm.MessageInputStream.MessageInputStreamFactory;
 import meerkat.comm.MessageOutputStream;
 import meerkat.crypto.concrete.SHA256Digest;
 import meerkat.protobuf.BulletinBoardAPI.*;
+import meerkat.protobuf.Crypto.Signature;
 import meerkat.protobuf.Voting.*;
 import meerkat.util.BulletinBoardUtils;
 
 import javax.ws.rs.NotFoundException;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
-import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.Callable;
 import java.util.concurrent.Executors;
@@ -22,28 +23,27 @@ import java.util.concurrent.TimeUnit;
 
 /**
  * Created by Arbel Deutsch Peled on 15-Mar-16.
- * This client is to be used mainly for testing.
- * It wraps a BulletinBoardServer in an asynchronous client.
+ * This client wraps a BulletinBoardServer in an asynchronous client.
+ * It is meant to be used as a local cache handler and for testing purposes.
  * This means the access to the server is direct (via method calls) instead of through a TCP connection.
  * The client implements both synchronous and asynchronous method calls, but calls to the server itself are performed synchronously.
  */
-public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardClient{
+public class LocalBulletinBoardClient implements DeletableSubscriptionBulletinBoardClient {
 
-    private final BulletinBoardServer server;
+    private final DeletableBulletinBoardServer server;
     private final ListeningScheduledExecutorService executorService;
-    private final BatchDigest digest;
-    private final int subsrciptionDelay;
+    private final BulletinBoardDigest digest;
+    private final long subsrciptionDelay;
 
     /**
      * Initializes an instance of the client
      * @param server an initialized Bulletin Board Server instance which will perform the actual processing of the requests
      * @param threadNum is the number of concurrent threads to allocate for the client
-     * @param subscriptionDelay is the required delay between subscription calls in milliseconds
      */
-    public LocalBulletinBoardClient(BulletinBoardServer server, int threadNum, int subscriptionDelay) {
+    public LocalBulletinBoardClient(DeletableBulletinBoardServer server, int threadNum, int subscriptionDelay) {
         this.server = server;
         this.executorService = MoreExecutors.listeningDecorator(Executors.newScheduledThreadPool(threadNum));
-        this.digest = new GenericBatchDigest(new SHA256Digest());
+        this.digest = new GenericBulletinBoardDigest(new SHA256Digest());
         this.subsrciptionDelay = subscriptionDelay;
     }
 
@@ -57,7 +57,7 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
 
 
         @Override
-        public Boolean call() throws Exception {
+        public Boolean call() throws CommunicationException {
             return server.postMessage(msg).getValue();
         }
 
@@ -75,51 +75,57 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
 
     private class CompleteBatchPoster implements Callable<Boolean> {
 
-        private final CompleteBatch completeBatch;
+        private final BulletinBoardMessage msg;
+        private final int chunkSize;
 
-        public CompleteBatchPoster(CompleteBatch completeBatch) {
-            this.completeBatch = completeBatch;
+        public CompleteBatchPoster(BulletinBoardMessage msg, int chunkSize) {
+            this.msg = msg;
+            this.chunkSize = chunkSize;
         }
 
 
         @Override
-        public Boolean call() throws Exception {
+        public Boolean call() throws CommunicationException {
 
-            if (!server.beginBatch(completeBatch.getBeginBatchMessage()).getValue())
-                return false;
-
-            int i=0;
-            for (BatchData data : completeBatch.getBatchDataList()){
-
-                BatchMessage message = BatchMessage.newBuilder()
-                        .setSignerId(completeBatch.getSignature().getSignerId())
-                        .setBatchId(completeBatch.getBeginBatchMessage().getBatchId())
-                        .setSerialNum(i)
-                        .setData(data)
+            BeginBatchMessage beginBatchMessage = BeginBatchMessage.newBuilder()
+                    .addAllTag(msg.getMsg().getTagList())
                     .build();
 
-                if (!server.postBatchMessage(message).getValue())
-                    return false;
+            Int64Value batchId = server.beginBatch(beginBatchMessage);
+
+            BatchMessage.Builder builder = BatchMessage.newBuilder()
+                    .setBatchId(batchId.getValue());
+
+            List<BatchChunk> batchChunkList = BulletinBoardUtils.breakToBatch(msg, chunkSize);
+
+            int i=0;
+            for (BatchChunk chunk : batchChunkList){
+
+                server.postBatchMessage(builder.setSerialNum(i).setData(chunk).build());
 
                 i++;
+
             }
 
-            return server.closeBatchMessage(completeBatch.getCloseBatchMessage()).getValue();
+            CloseBatchMessage closeBatchMessage = BulletinBoardUtils.generateCloseBatchMessage(batchId, batchChunkList.size(), msg);
+
+            return server.closeBatch(closeBatchMessage).getValue();
         }
 
     }
 
     @Override
-    public MessageID postBatch(CompleteBatch completeBatch, FutureCallback<Boolean> callback) {
+    public MessageID postAsBatch(BulletinBoardMessage msg, int chunkSize, FutureCallback<Boolean> callback) {
 
-        Futures.addCallback(executorService.schedule(new CompleteBatchPoster(completeBatch), subsrciptionDelay, TimeUnit.MILLISECONDS), callback);
+        Futures.addCallback(executorService.submit(new CompleteBatchPoster(msg, chunkSize)), callback);
 
-        digest.update(completeBatch);
+        digest.reset();
+        digest.update(msg);
         return digest.digestAsMessageID();
 
     }
 
-    private class BatchBeginner implements Callable<Boolean> {
+    private class BatchBeginner implements Callable<SingleServerBatchIdentifier> {
 
         private final BeginBatchMessage msg;
 
@@ -129,28 +135,31 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
 
 
         @Override
-        public Boolean call() throws Exception {
-            return server.beginBatch(msg).getValue();
+        public SingleServerBatchIdentifier call() throws Exception {
+            return new SingleServerBatchIdentifier(server.beginBatch(msg));
         }
 
     }
 
     @Override
-    public void beginBatch(BeginBatchMessage beginBatchMessage, FutureCallback<Boolean> callback) {
+    public void beginBatch(Iterable<String> tags, FutureCallback<BatchIdentifier> callback) {
+
+        BeginBatchMessage beginBatchMessage = BeginBatchMessage.newBuilder()
+                .addAllTag(tags)
+                .build();
+
         Futures.addCallback(executorService.submit(new BatchBeginner(beginBatchMessage)), callback);
     }
 
     private class BatchDataPoster implements Callable<Boolean> {
 
-        private final ByteString signerId;
-        private final int batchId;
-        private final List<BatchData> batchDataList;
+        private final SingleServerBatchIdentifier batchId;
+        private final List<BatchChunk> batchChunkList;
         private final int startPosition;
 
-        public BatchDataPoster(ByteString signerId, int batchId, List<BatchData> batchDataList, int startPosition) {
-            this.signerId = signerId;
+        public BatchDataPoster(SingleServerBatchIdentifier batchId, List<BatchChunk> batchChunkList, int startPosition) {
             this.batchId = batchId;
-            this.batchDataList = batchDataList;
+            this.batchChunkList = batchChunkList;
             this.startPosition = startPosition;
         }
 
@@ -159,11 +168,10 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
         public Boolean call() throws Exception {
 
             BatchMessage.Builder msgBuilder = BatchMessage.newBuilder()
-                    .setSignerId(signerId)
-                    .setBatchId(batchId);
+                    .setBatchId(batchId.getBatchId().getValue());
 
             int i = startPosition;
-            for (BatchData data : batchDataList){
+            for (BatchChunk data : batchChunkList){
 
                 msgBuilder.setSerialNum(i)
                         .setData(data);
@@ -175,6 +183,8 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
 
             }
 
+            batchId.setLength(i);
+
             return true;
 
         }
@@ -182,24 +192,28 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
     }
 
     @Override
-    public void postBatchData(byte[] signerId, int batchId, List<BatchData> batchDataList, int startPosition, FutureCallback<Boolean> callback) {
-        postBatchData(ByteString.copyFrom(signerId), batchId, batchDataList, startPosition, callback);
+    public void postBatchData(BatchIdentifier batchId, List<BatchChunk> batchChunkList, int startPosition, FutureCallback<Boolean> callback)
+        throws IllegalArgumentException{
+
+        // Cast identifier to usable form
+
+        if (!(batchId instanceof SingleServerBatchIdentifier)){
+            throw new IllegalArgumentException("Error: batch identifier supplied was not created by this class.");
+        }
+
+        SingleServerBatchIdentifier identifier = (SingleServerBatchIdentifier) batchId;
+
+        // Add worker
+
+        Futures.addCallback(executorService.submit(new BatchDataPoster(identifier, batchChunkList, startPosition)), callback);
+
     }
 
     @Override
-    public void postBatchData(byte[] signerId, int batchId, List<BatchData> batchDataList, FutureCallback<Boolean> callback) {
-        postBatchData(signerId, batchId, batchDataList, 0, callback);
+    public void postBatchData(BatchIdentifier batchId, List<BatchChunk> batchChunkList, FutureCallback<Boolean> callback) throws IllegalArgumentException{
+        postBatchData(batchId, batchChunkList, 0, callback);
     }
 
-    @Override
-    public void postBatchData(ByteString signerId, int batchId, List<BatchData> batchDataList, int startPosition, FutureCallback<Boolean> callback) {
-        Futures.addCallback(executorService.submit(new BatchDataPoster(signerId, batchId, batchDataList, startPosition)), callback);
-    }
-
-    @Override
-    public void postBatchData(ByteString signerId, int batchId, List<BatchData> batchDataList, FutureCallback<Boolean> callback) {
-        postBatchData(signerId, batchId, batchDataList, 0, callback);
-    }
 
     private class BatchCloser implements Callable<Boolean> {
 
@@ -212,14 +226,33 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
 
         @Override
         public Boolean call() throws Exception {
-            return server.closeBatchMessage(msg).getValue();
+            return server.closeBatch(msg).getValue();
         }
 
     }
 
     @Override
-    public void closeBatch(CloseBatchMessage closeBatchMessage, FutureCallback<Boolean> callback) {
+    public void closeBatch(BatchIdentifier batchId, Timestamp timestamp, Iterable<Signature> signatures, FutureCallback<Boolean> callback) {
+
+        // Cast identifier to usable form
+
+        if (!(batchId instanceof SingleServerBatchIdentifier)){
+            throw new IllegalArgumentException("Error: batch identifier supplied was not created by this class.");
+        }
+
+        SingleServerBatchIdentifier identifier = (SingleServerBatchIdentifier) batchId;
+
+        // Add worker
+
+        CloseBatchMessage closeBatchMessage = CloseBatchMessage.newBuilder()
+                .setBatchId(identifier.getBatchId().getValue())
+                .setBatchLength(identifier.getLength())
+                .setTimestamp(timestamp)
+                .addAllSig(signatures)
+                .build();
+
         Futures.addCallback(executorService.submit(new BatchCloser(closeBatchMessage)), callback);
+
     }
 
     private class RedundancyGetter implements Callable<Float> {
@@ -310,6 +343,7 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
         public void onSuccess(List<BulletinBoardMessage> result) {
 
             // Report new messages to user
+            if (callback != null)
                 callback.onSuccess(result);
 
             MessageFilterList.Builder filterBuilder = filterList.toBuilder();
@@ -331,7 +365,7 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
             filterList = filterBuilder.build();
 
             // Reschedule job
-            Futures.addCallback(executorService.submit(new MessageReader(filterList)), this);
+            Futures.addCallback(executorService.schedule(new MessageReader(filterList), subsrciptionDelay, TimeUnit.MILLISECONDS), this);
 
         }
 
@@ -339,6 +373,7 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
         public void onFailure(Throwable t) {
 
             // Notify caller about failure and terminate subscription
+            if (callback != null)
                 callback.onFailure(t);
 
         }
@@ -364,83 +399,122 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
         subscribe(filterList, 0, callback);
     }
 
-    private class CompleteBatchReader implements Callable<CompleteBatch> {
+    private class BatchDataReader implements Callable<List<BatchChunk>> {
 
-        private final BatchSpecificationMessage batchSpecificationMessage;
+        private final MessageID msgID;
 
-        public CompleteBatchReader(BatchSpecificationMessage batchSpecificationMessage) {
-            this.batchSpecificationMessage = batchSpecificationMessage;
+        public BatchDataReader(MessageID msgID) {
+            this.msgID = msgID;
+        }
+
+        @Override
+        public List<BatchChunk> call() throws Exception {
+
+            BatchQuery batchQuery = BatchQuery.newBuilder()
+                    .setMsgID(msgID)
+                    .setStartPosition(0)
+                    .build();
+
+            ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
+            MessageOutputStream<BatchChunk> batchOutputStream = new MessageOutputStream<>(byteOutputStream);
+            server.readBatch(batchQuery,batchOutputStream);
+
+            MessageInputStream<BatchChunk> inputStream =
+                    MessageInputStreamFactory.createMessageInputStream(
+                            new ByteArrayInputStream(byteOutputStream.toByteArray()),
+                            BatchChunk.class);
+
+            return inputStream.asList();
+
+        }
+    }
+
+    private class CompleteBatchReader implements Callable<BulletinBoardMessage> {
+
+        private final MessageID msgID;
+
+        public CompleteBatchReader(MessageID msgID) {
+            this.msgID = msgID;
         }
 
 
         @Override
-        public CompleteBatch call() throws Exception {
+        public BulletinBoardMessage call() throws Exception {
 
-            final String[] TAGS_TO_REMOVE = {BulletinBoardConstants.BATCH_TAG, BulletinBoardConstants.BATCH_ID_TAG_PREFIX};
-
-            CompleteBatch completeBatch = new CompleteBatch(BeginBatchMessage.newBuilder()
-                    .setSignerId(batchSpecificationMessage.getSignerId())
-                    .setBatchId(batchSpecificationMessage.getBatchId())
-                    .build());
-
-            ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
-            MessageOutputStream<BatchData> batchOutputStream = new MessageOutputStream<>(byteOutputStream);
-            server.readBatch(batchSpecificationMessage,batchOutputStream);
-
-            MessageInputStream<BatchData> batchInputStream =
-                    MessageInputStreamFactory.createMessageInputStream(
-                            new ByteArrayInputStream(byteOutputStream.toByteArray()),
-                            BatchData.class);
-
-            completeBatch.appendBatchData(batchInputStream.asList());
+            // Read message (mat be a stub)
 
             MessageFilterList filterList = MessageFilterList.newBuilder()
                     .addFilter(MessageFilter.newBuilder()
-                            .setType(FilterType.TAG)
-                            .setTag(BulletinBoardConstants.BATCH_TAG)
-                            .build())
-                    .addFilter(MessageFilter.newBuilder()
-                            .setType(FilterType.TAG)
-                            .setTag(BulletinBoardConstants.BATCH_ID_TAG_PREFIX + completeBatch.getBeginBatchMessage().getBatchId())
-                            .build())
-                    .addFilter(MessageFilter.newBuilder()
-                            .setType(FilterType.SIGNER_ID)
-                            .setId(completeBatch.getBeginBatchMessage().getSignerId())
+                            .setType(FilterType.MSG_ID)
+                            .setId(msgID.getID())
                             .build())
                     .build();
 
-            byteOutputStream = new ByteArrayOutputStream();
-            MessageOutputStream<BulletinBoardMessage> messageOutputStream = new MessageOutputStream<>(byteOutputStream);
-            server.readMessages(filterList,messageOutputStream);
+            MessageReader messageReader = new MessageReader(filterList);
+            List<BulletinBoardMessage> bulletinBoardMessages = messageReader.call();
 
-            MessageInputStream<BulletinBoardMessage> messageInputStream =
-                    MessageInputStreamFactory.createMessageInputStream(
-                            new ByteArrayInputStream(byteOutputStream.toByteArray()),
-                            BulletinBoardMessage.class);
+            if (bulletinBoardMessages.size() <= 0) {
+                throw new NotFoundException("Message does not exist");
+            }
 
-            if (!messageInputStream.isAvailable())
-                throw new NotFoundException("Batch does not exist");
+            BulletinBoardMessage msg = bulletinBoardMessages.get(0);
 
-            BulletinBoardMessage message = messageInputStream.readMessage();
+            if (msg.getMsg().getDataTypeCase() == UnsignedBulletinBoardMessage.DataTypeCase.MSGID) {
 
-            completeBatch.setBeginBatchMessage(BeginBatchMessage.newBuilder()
-                    .addAllTag(BulletinBoardUtils.removePrefixTags(message, Arrays.asList(TAGS_TO_REMOVE)))
-                    .setSignerId(message.getSig(0).getSignerId())
-                    .setBatchId(Integer.parseInt(BulletinBoardUtils.findTagWithPrefix(message, BulletinBoardConstants.BATCH_ID_TAG_PREFIX)))
-                    .build());
+                // Read data
 
-            completeBatch.setSignature(message.getSig(0));
-            completeBatch.setTimestamp(message.getMsg().getTimestamp());
+                BatchDataReader batchDataReader = new BatchDataReader(msgID);
+                List<BatchChunk> batchChunkList = batchDataReader.call();
 
-            return completeBatch;
+                // Combine and return
+
+                return BulletinBoardUtils.gatherBatch(msg, batchChunkList);
+
+            } else {
+                return msg;
+            }
+
+        }
+
+    }
+
+    private class BatchDataCombiner implements Callable<BulletinBoardMessage> {
+
+        private final BulletinBoardMessage stub;
+
+        public BatchDataCombiner(BulletinBoardMessage stub) {
+            this.stub = stub;
+        }
+
+        @Override
+        public BulletinBoardMessage call() throws Exception {
+
+            MessageID msgID = MessageID.newBuilder().setID(stub.getMsg().getMsgId()).build();
+
+            BatchDataReader batchDataReader = new BatchDataReader(msgID);
+
+            List<BatchChunk> batchChunkList = batchDataReader.call();
+
+            return BulletinBoardUtils.gatherBatch(stub, batchChunkList);
 
         }
 
     }
 
     @Override
-    public void readBatch(BatchSpecificationMessage batchSpecificationMessage, FutureCallback<CompleteBatch> callback) {
-        Futures.addCallback(executorService.submit(new CompleteBatchReader(batchSpecificationMessage)), callback);
+    public void readMessage(MessageID msgID, FutureCallback<BulletinBoardMessage> callback) {
+        Futures.addCallback(executorService.submit(new CompleteBatchReader(msgID)), callback);
+    }
+
+    @Override
+    public void readBatchData(BulletinBoardMessage stub, FutureCallback<BulletinBoardMessage> callback) throws IllegalArgumentException {
+
+        if (stub.getMsg().getDataTypeCase() != UnsignedBulletinBoardMessage.DataTypeCase.MSGID){
+            throw new IllegalArgumentException("Message is not a stub and does not contain the required message ID");
+        }
+
+        Futures.addCallback(executorService.submit(new BatchDataCombiner(stub)),callback);
+
     }
 
     private class SyncQueryHandler implements Callable<SyncQueryResponse> {
@@ -474,18 +548,27 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
     @Override
     public MessageID postMessage(BulletinBoardMessage msg) throws CommunicationException {
 
-        try {
-
             MessagePoster poster = new MessagePoster(msg);
             poster.call();
 
-            digest.update(msg);
+            digest.update(msg.getMsg());
             return digest.digestAsMessageID();
 
-        } catch (Exception e) {
-            return null;
     }
 
+    @Override
+    public MessageID postAsBatch(BulletinBoardMessage msg, int chunkSize) throws CommunicationException {
+
+        CompleteBatchPoster poster = new CompleteBatchPoster(msg, chunkSize);
+        Boolean result = poster.call();
+
+        if (!result)
+            throw new CommunicationException("Batch post failed");
+
+        digest.reset();
+        digest.update(msg);
+        return digest.digestAsMessageID();
+
     }
 
     @Override
@@ -503,7 +586,7 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
     }
 
     @Override
-    public List<BulletinBoardMessage> readMessages(MessageFilterList filterList) {
+    public List<BulletinBoardMessage> readMessages(MessageFilterList filterList) throws CommunicationException{
 
         try {
 
@@ -511,14 +594,89 @@ public class LocalBulletinBoardClient implements SubscriptionAsyncBulletinBoardC
             return reader.call();
 
         } catch (Exception e){
-            return null;
+            throw new CommunicationException("Error reading from server");
         }
 
     }
 
     @Override
-    public SyncQuery generateSyncQuery(GenerateSyncQueryParams GenerateSyncQueryParams) throws CommunicationException {
-        return server.generateSyncQuery(GenerateSyncQueryParams);
+    public BulletinBoardMessage readMessage(MessageID msgID) throws CommunicationException {
+
+        MessageFilterList filterList = MessageFilterList.newBuilder()
+                .addFilter(MessageFilter.newBuilder()
+                        .setType(FilterType.MSG_ID)
+                        .setId(msgID.getID())
+                        .build())
+                .build();
+
+        CompleteBatchReader completeBatchReader = new CompleteBatchReader(msgID);
+
+        try {
+            return completeBatchReader.call();
+        } catch (Exception e) {
+            throw new CommunicationException(e.getMessage() + " " + e.getMessage());
+        }
+
+    }
+
+    @Override
+    public BulletinBoardMessage readBatchData(BulletinBoardMessage stub) throws CommunicationException, IllegalArgumentException {
+
+        if (stub.getMsg().getDataTypeCase() != UnsignedBulletinBoardMessage.DataTypeCase.MSGID){
+            throw new IllegalArgumentException("Message is not a stub and does not contain the required message ID");
+        }
+
+        BatchDataCombiner combiner = new BatchDataCombiner(stub);
+
+        try {
+            return combiner.call();
+        } catch (Exception e) {
+            throw new CommunicationException(e.getCause() + " " + e.getMessage());
+        }
+
+    }
+
+    @Override
+    public SyncQuery generateSyncQuery(GenerateSyncQueryParams generateSyncQueryParams) throws CommunicationException {
+        return server.generateSyncQuery(generateSyncQueryParams);
+    }
+
+    @Override
+    public void deleteMessage(MessageID msgID, FutureCallback<Boolean> callback) {
+
+        try {
+            Boolean deleted = server.deleteMessage(msgID).getValue();
+            if (callback != null)
+                callback.onSuccess(deleted);
+        } catch (CommunicationException e) {
+            if (callback != null)
+                callback.onFailure(e);
+        }
+
+    }
+
+    @Override
+    public void deleteMessage(long entryNum, FutureCallback<Boolean> callback) {
+
+        try {
+            Boolean deleted = server.deleteMessage(entryNum).getValue();
+            if (callback != null)
+                callback.onSuccess(deleted);
+        } catch (CommunicationException e) {
+            if (callback != null)
+                callback.onFailure(e);
+        }
+
+    }
+
+    @Override
+    public boolean deleteMessage(MessageID msgID) throws CommunicationException {
+        return server.deleteMessage(msgID).getValue();
+    }
+
+    @Override
+    public boolean deleteMessage(long entryNum) throws CommunicationException {
+        return server.deleteMessage(entryNum).getValue();
     }
 
     @Override

bulletin-board-client/src/main/java/meerkat/bulletinboard/MultiServerBatchIdentifier.java

@@ -0,0 +1,27 @@
+package meerkat.bulletinboard;
+
+import meerkat.bulletinboard.AsyncBulletinBoardClient.BatchIdentifier;
+
+import java.util.Arrays;
+
+/**
+ * Created by Arbel Deutsch Peled on 17-Jun-16.
+ */
+public final class MultiServerBatchIdentifier implements AsyncBulletinBoardClient.BatchIdentifier {
+
+    // Per-server identifiers
+    private final Iterable<BatchIdentifier> identifiers;
+
+    public MultiServerBatchIdentifier(Iterable<BatchIdentifier> identifiers) {
+        this.identifiers = identifiers;
+    }
+
+    public MultiServerBatchIdentifier(BatchIdentifier[] identifiers) {
+        this.identifiers = Arrays.asList(identifiers);
+    }
+
+    public Iterable<BatchIdentifier> getIdentifiers() {
+        return identifiers;
+    }
+
+}

bulletin-board-client/src/main/java/meerkat/bulletinboard/MultiServerWorker.java

@@ -18,7 +18,7 @@ import java.util.concurrent.atomic.AtomicInteger;
  */
 public abstract class MultiServerWorker<IN, OUT> extends BulletinClientWorker<IN> implements Runnable, FutureCallback<OUT>{
 
-    private final List<SingleServerBulletinBoardClient> clients;
+    protected final List<SingleServerBulletinBoardClient> clients;
 
     protected AtomicInteger minServers; // The minimal number of servers the job must be successful on for the job to be completed
 
@@ -74,6 +74,7 @@ public abstract class MultiServerWorker<IN, OUT> extends BulletinClientWorker<IN
      */
     protected void succeed(OUT result){
         if (returnedResult.compareAndSet(false, true)) {
+            if (futureCallback != null)
                 futureCallback.onSuccess(result);
         }
     }
@@ -85,18 +86,11 @@ public abstract class MultiServerWorker<IN, OUT> extends BulletinClientWorker<IN
      */
     protected void fail(Throwable t){
         if (returnedResult.compareAndSet(false, true)) {
+            if (futureCallback != null)
                 futureCallback.onFailure(t);
         }
     }
 
-    /**
-     * Used by implementations to get a Single Server Client iterator
-     * @return the requested iterator
-     */
-    protected Iterator<SingleServerBulletinBoardClient> getClientIterator() {
-        return clients.iterator();
-    }
-
     protected int getClientNumber() {
         return clients.size();
     }

bulletin-board-client/src/main/java/meerkat/bulletinboard/SimpleBulletinBoardClient.java

@@ -2,13 +2,15 @@ package meerkat.bulletinboard;
 
 import com.google.protobuf.BoolValue;
 import com.google.protobuf.ByteString;
+import com.google.protobuf.Int64Value;
+import meerkat.bulletinboard.workers.singleserver.*;
 import meerkat.comm.CommunicationException;
-import meerkat.crypto.Digest;
 import meerkat.crypto.concrete.SHA256Digest;
+import meerkat.protobuf.BulletinBoardAPI;
 import meerkat.protobuf.BulletinBoardAPI.*;
-import meerkat.protobuf.Comm.*;
 import meerkat.protobuf.Voting.*;
 import meerkat.rest.*;
+import meerkat.util.BulletinBoardUtils;
 
 import java.util.List;
 
@@ -30,7 +32,7 @@ public class SimpleBulletinBoardClient implements BulletinBoardClient{
 
     protected Client client;
 
-    protected Digest digest;
+    protected BulletinBoardDigest digest;
 
     /**
      * Stores database locations and initializes the web Client
@@ -45,7 +47,8 @@ public class SimpleBulletinBoardClient implements BulletinBoardClient{
         client.register(ProtobufMessageBodyReader.class);
         client.register(ProtobufMessageBodyWriter.class);
 
-        digest = new SHA256Digest();
+        // Wrap the Digest into a BatchDigest
+        digest = new GenericBulletinBoardDigest(new SHA256Digest());
 
     }
 
@@ -60,19 +63,16 @@ public class SimpleBulletinBoardClient implements BulletinBoardClient{
     public MessageID postMessage(BulletinBoardMessage msg) throws CommunicationException {
 
         WebTarget webTarget;
-        Response response;
+        Response response = null;
 
         // Post message to all databases
         try {
             for (String db : meerkatDBs) {
-                webTarget = client.target(db).path(BULLETIN_BOARD_SERVER_PATH).path(POST_MESSAGE_PATH);
-                response = webTarget.request(Constants.MEDIATYPE_PROTOBUF).post(Entity.entity(msg, Constants.MEDIATYPE_PROTOBUF));
 
-                // Only consider valid responses
-                if (response.getStatusInfo() == Response.Status.OK
-                        || response.getStatusInfo() == Response.Status.CREATED) {
-                    response.readEntity(BoolValue.class).getValue();
-                }
+                SingleServerPostMessageWorker worker = new SingleServerPostMessageWorker(db, msg, 0);
+
+                worker.call();
+
             }
         } catch (Exception e) { // Occurs only when server replies with valid status but invalid data
             throw new CommunicationException("Error accessing database: " + e.getMessage());
@@ -130,35 +130,172 @@ public class SimpleBulletinBoardClient implements BulletinBoardClient{
      * @return the list of Bulletin Board messages that are returned from a server
      */
     @Override
-    public List<BulletinBoardMessage> readMessages(MessageFilterList filterList) {
-
-        WebTarget webTarget;
-        Response response;
-        BulletinBoardMessageList messageList;
+    public List<BulletinBoardMessage> readMessages(MessageFilterList filterList) throws CommunicationException{
 
         // Replace null filter list with blank one.
         if (filterList == null){
-            filterList = MessageFilterList.newBuilder().build();
+            filterList = MessageFilterList.getDefaultInstance();
         }
 
+        String exceptionString = "";
+
         for (String db : meerkatDBs) {
 
             try {
-                webTarget = client.target(db).path(BULLETIN_BOARD_SERVER_PATH).path(READ_MESSAGES_PATH);
 
-                response = webTarget.request(Constants.MEDIATYPE_PROTOBUF).post(Entity.entity(filterList, Constants.MEDIATYPE_PROTOBUF));
+                SingleServerReadMessagesWorker worker = new SingleServerReadMessagesWorker(db, filterList, 0);
 
-                messageList = response.readEntity(BulletinBoardMessageList.class);
+                List<BulletinBoardMessage> result = worker.call();
 
-                if (messageList != null){
-                    return messageList.getMessageList();
+                return result;
+
+            } catch (Exception e) {
+                //TODO: log
+                exceptionString += e.getMessage() + "\n";
+            }
         }
 
-            } catch (Exception e) {}
+        throw new CommunicationException("Could not find message in any DB. Errors follow:\n" + exceptionString);
 
     }
 
-        return null;
+    @Override
+    public MessageID postAsBatch(BulletinBoardMessage msg, int chunkSize) throws CommunicationException {
+
+        List<BatchChunk> chunkList = BulletinBoardUtils.breakToBatch(msg, chunkSize);
+
+        BeginBatchMessage beginBatchMessage = BulletinBoardUtils.generateBeginBatchMessage(msg);
+
+        boolean posted = false;
+
+        // Post message to all databases
+
+        for (String db : meerkatDBs) {
+
+            try {
+
+                int pos = 0;
+
+                SingleServerBeginBatchWorker beginBatchWorker = new SingleServerBeginBatchWorker(db, beginBatchMessage, 0);
+
+                Int64Value batchId = beginBatchWorker.call();
+
+                BatchMessage.Builder builder = BatchMessage.newBuilder().setBatchId(batchId.getValue());
+
+                for (BatchChunk batchChunk : chunkList) {
+
+                    SingleServerPostBatchWorker postBatchWorker =
+                            new SingleServerPostBatchWorker(
+                                    db,
+                                    builder.setData(batchChunk).setSerialNum(pos).build(),
+                                    0);
+
+                    postBatchWorker.call();
+
+                    pos++;
+
+                }
+
+                CloseBatchMessage closeBatchMessage = BulletinBoardUtils.generateCloseBatchMessage(batchId, chunkList.size(), msg);
+
+                SingleServerCloseBatchWorker closeBatchWorker = new SingleServerCloseBatchWorker(db, closeBatchMessage, 0);
+
+                closeBatchWorker.call();
+
+                posted = true;
+
+            } catch(Exception ignored) {}
+
+        }
+
+        if (!posted){
+            throw new CommunicationException("Could not post to any server");
+        }
+
+        digest.reset();
+        digest.update(msg);
+        return digest.digestAsMessageID();
+
+    }
+
+    @Override
+    public BulletinBoardMessage readMessage(MessageID msgID) throws CommunicationException {
+
+        MessageFilterList filterList = MessageFilterList.newBuilder()
+                .addFilter(MessageFilter.newBuilder()
+                        .setType(FilterType.MSG_ID)
+                        .setId(msgID.getID())
+                        .build())
+                .build();
+
+        BatchQuery batchQuery = BatchQuery.newBuilder()
+                .setMsgID(msgID)
+                .setStartPosition(0)
+                .build();
+
+        String exceptionString = "";
+
+        for (String db : meerkatDBs) {
+
+            try {
+                SingleServerReadMessagesWorker messagesWorker = new SingleServerReadMessagesWorker(db, filterList, 0);
+
+                List<BulletinBoardMessage> messages = messagesWorker.call();
+
+                if (messages == null || messages.size() < 1)
+                    continue;
+
+                BulletinBoardMessage stub = messages.get(0);
+
+                SingleServerReadBatchWorker batchWorker = new SingleServerReadBatchWorker(db, batchQuery, 0);
+
+                List<BatchChunk> batchChunkList = batchWorker.call();
+
+                return BulletinBoardUtils.gatherBatch(stub, batchChunkList);
+
+            } catch (Exception e) {
+                //TODO: log
+                exceptionString += e.getMessage() + "\n";
+            }
+        }
+
+        throw new CommunicationException("Could not find message in any DB. Errors follow:\n" + exceptionString);
+
+    }
+
+    @Override
+    public BulletinBoardMessage readBatchData(BulletinBoardMessage stub) throws CommunicationException, IllegalArgumentException {
+
+        if (stub.getMsg().getDataTypeCase() != UnsignedBulletinBoardMessage.DataTypeCase.MSGID){
+            throw new IllegalArgumentException("Message is not a stub and does not contain the required message ID");
+        }
+
+        BatchQuery batchQuery = BatchQuery.newBuilder()
+                .setMsgID(MessageID.newBuilder()
+                        .setID(stub.getMsg().getMsgId())
+                        .build())
+                .setStartPosition(0)
+                .build();
+
+        String exceptionString = "";
+
+        for (String db : meerkatDBs) {
+
+            try {
+
+                SingleServerReadBatchWorker batchWorker = new SingleServerReadBatchWorker(db, batchQuery, 0);
+
+                List<BatchChunk> batchChunkList = batchWorker.call();
+
+                return BulletinBoardUtils.gatherBatch(stub, batchChunkList);
+
+            } catch (Exception e) {
+                //TODO: log
+                exceptionString += e.getMessage() + "\n";
+            }
+        }
+
+        throw new CommunicationException("Could not find message in any DB. Errors follow:\n" + exceptionString);
 
     }
 

bulletin-board-client/src/main/java/meerkat/bulletinboard/SimpleBulletinBoardSynchronizer.java

@@ -0,0 +1,241 @@
+package meerkat.bulletinboard;
+
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.protobuf.ByteString;
+import meerkat.comm.CommunicationException;
+import meerkat.protobuf.BulletinBoardAPI.*;
+import meerkat.util.BulletinBoardUtils;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Created by Arbel on 13/04/2016.
+ * Simple, straightforward implementation of the {@link BulletinBoardSynchronizer} interface
+ */
+public class SimpleBulletinBoardSynchronizer implements BulletinBoardSynchronizer {
+
+    private DeletableSubscriptionBulletinBoardClient localClient;
+    private AsyncBulletinBoardClient remoteClient;
+
+    private AtomicBoolean running;
+    private volatile SyncStatus syncStatus;
+
+    private List<FutureCallback<Integer>> messageCountCallbacks;
+    private List<FutureCallback<SyncStatus>> syncStatusCallbacks;
+
+    private static final MessageFilterList EMPTY_FILTER = MessageFilterList.getDefaultInstance();
+    private static final int DEFAULT_SLEEP_INTERVAL = 10000; // 10 Seconds
+    private static final int DEFAULT_WAIT_CAP = 300000; // 5 minutes wait before deciding that the sync has failed fatally
+
+    private final int SLEEP_INTERVAL;
+    private final int WAIT_CAP;
+
+    private Semaphore semaphore;
+
+    private class SyncCallback implements FutureCallback<List<BulletinBoardMessage>> {
+
+        @Override
+        public void onSuccess(List<BulletinBoardMessage> result) {
+
+            // Notify Message Count callbacks if needed
+
+            if (syncStatus != SyncStatus.SYNCHRONIZED || result.size() > 0) {
+
+                for (FutureCallback<Integer> callback : messageCountCallbacks){
+                    callback.onSuccess(result.size());
+                }
+
+            }
+
+            // Handle upload and status change
+
+            SyncStatus newStatus = SyncStatus.PENDING;
+
+            if (result.size() == 0) {
+                newStatus = SyncStatus.SYNCHRONIZED;
+                semaphore.release();
+            }
+
+            else{   // Upload messages
+
+                for (BulletinBoardMessage message : result){
+
+                    try {
+
+                        if (message.getMsg().getDataTypeCase() == UnsignedBulletinBoardMessage.DataTypeCase.MSGID) {
+
+                            // This is a batch message: need to upload batch data as well as the message itself
+
+                            BulletinBoardMessage completeMsg = localClient.readBatchData(message);
+
+                            remoteClient.postMessage(completeMsg);
+
+                            localClient.deleteMessage(completeMsg.getEntryNum());
+
+
+                        } else {
+
+                            // This is a regular message: post it
+                            remoteClient.postMessage(message);
+
+                            localClient.deleteMessage(message.getEntryNum());
+
+                        }
+
+                    } catch (CommunicationException e) {
+                        // This is an error with the local server
+                        // TODO: log
+                        updateSyncStatus(SyncStatus.SERVER_ERROR);
+                    }
+
+                }
+
+            }
+
+            updateSyncStatus(newStatus);
+
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+
+            updateSyncStatus(SyncStatus.SERVER_ERROR);
+
+        }
+
+    }
+
+    public SimpleBulletinBoardSynchronizer(int sleepInterval, int waitCap) {
+        this.syncStatus = SyncStatus.STOPPED;
+        this.SLEEP_INTERVAL = sleepInterval;
+        this.WAIT_CAP = waitCap;
+        this.running = new AtomicBoolean(false);
+    }
+
+    public SimpleBulletinBoardSynchronizer() {
+        this(DEFAULT_SLEEP_INTERVAL, DEFAULT_WAIT_CAP);
+    }
+
+    private synchronized void updateSyncStatus(SyncStatus newStatus) {
+
+        if (!running.get()) {
+
+            newStatus = SyncStatus.STOPPED;
+
+        }
+
+        if (newStatus != syncStatus){
+
+            syncStatus = newStatus;
+
+            for (FutureCallback<SyncStatus> callback : syncStatusCallbacks){
+                if (callback != null)
+                    callback.onSuccess(syncStatus);
+            }
+
+        }
+
+    }
+
+    @Override
+    public void init(DeletableSubscriptionBulletinBoardClient localClient, AsyncBulletinBoardClient remoteClient) {
+
+        updateSyncStatus(SyncStatus.STOPPED);
+
+        this.localClient = localClient;
+        this.remoteClient = remoteClient;
+
+        messageCountCallbacks = new LinkedList<>();
+        syncStatusCallbacks = new LinkedList<>();
+
+        semaphore = new Semaphore(0);
+
+    }
+
+    @Override
+    public SyncStatus getSyncStatus() {
+        return syncStatus;
+    }
+
+    @Override
+    public void subscribeToSyncStatus(FutureCallback<SyncStatus> callback) {
+        syncStatusCallbacks.add(callback);
+    }
+
+    @Override
+    public List<BulletinBoardMessage> getRemainingMessages()  throws CommunicationException{
+        return localClient.readMessages(EMPTY_FILTER);
+    }
+
+    @Override
+    public void getRemainingMessages(FutureCallback<List<BulletinBoardMessage>> callback) {
+        localClient.readMessages(EMPTY_FILTER, callback);
+    }
+
+    @Override
+    public long getRemainingMessagesCount() throws CommunicationException {
+        return localClient.readMessages(EMPTY_FILTER).size();
+    }
+
+    @Override
+    public void subscribeToRemainingMessagesCount(FutureCallback<Integer> callback) {
+        messageCountCallbacks.add(callback);
+    }
+
+    @Override
+    public void run() {
+
+        if (running.compareAndSet(false,true)){
+
+            updateSyncStatus(SyncStatus.PENDING);
+            SyncCallback callback = new SyncCallback();
+
+            while (syncStatus != SyncStatus.STOPPED) {
+
+                do {
+
+                    localClient.readMessages(EMPTY_FILTER, callback);
+
+                    try {
+
+                        semaphore.tryAcquire(WAIT_CAP, TimeUnit.MILLISECONDS);
+                        //TODO: log hard error. Too much time trying to upload data.
+
+                    } catch (InterruptedException ignored) {
+                        // We expect an interruption when the upload will complete
+                    }
+
+                } while (syncStatus == SyncStatus.PENDING);
+
+                // Database is synced. Wait for new data.
+
+                try {
+                    semaphore.tryAcquire(SLEEP_INTERVAL, TimeUnit.MILLISECONDS);
+                } catch (InterruptedException e) {
+                    //TODO: log (probably nudged)
+                }
+
+            }
+
+        }
+
+    }
+
+    @Override
+    public void nudge() {
+        semaphore.release();
+    }
+
+    @Override
+    public void stop() {
+
+        running.set(false);
+        updateSyncStatus(SyncStatus.STOPPED);
+
+    }
+
+}

bulletin-board-client/src/main/java/meerkat/bulletinboard/SingleServerBatchIdentifier.java

@@ -0,0 +1,42 @@
+package meerkat.bulletinboard;
+
+import com.google.protobuf.Int64Value;
+
+/**
+ * Created by Arbel Deutsch Peled on 16-Jun-16.
+ * Single-server implementation of the BatchIdentifier interface
+ */
+final class SingleServerBatchIdentifier implements AsyncBulletinBoardClient.BatchIdentifier {
+
+    private final Int64Value batchId;
+
+    private int length;
+
+    public SingleServerBatchIdentifier(Int64Value batchId) {
+        this.batchId = batchId;
+        length = 0;
+    }
+
+    public SingleServerBatchIdentifier(long batchId) {
+        this(Int64Value.newBuilder().setValue(batchId).build());
+    }
+
+    public Int64Value getBatchId() {
+        return batchId;
+    }
+
+    /**
+     * Overrides the existing length with the new one only if the new length is longer
+     * @param newLength
+     */
+    public void setLength(int newLength) {
+        if (newLength > length) {
+            length = newLength;
+        }
+    }
+
+    public int getLength() {
+        return length;
+    }
+
+}

bulletin-board-client/src/main/java/meerkat/bulletinboard/SingleServerBulletinBoardClient.java

@@ -4,16 +4,19 @@ import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListeningScheduledExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
-import com.google.protobuf.ByteString;
+import com.google.protobuf.Int64Value;
+import com.google.protobuf.Timestamp;
 import meerkat.bulletinboard.workers.singleserver.*;
 import meerkat.comm.CommunicationException;
+import meerkat.crypto.concrete.SHA256Digest;
 import meerkat.protobuf.BulletinBoardAPI.*;
+import meerkat.protobuf.Crypto;
 import meerkat.protobuf.Voting.BulletinBoardClientParams;
 import meerkat.util.BulletinBoardUtils;
 
-import java.util.Arrays;
+import javax.ws.rs.client.Client;
+import java.lang.Iterable;
 import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
@@ -28,19 +31,23 @@ import java.util.concurrent.atomic.AtomicInteger;
  * If the list of servers contains more than one server: the server actually used is the first one
  * The class further implements a delayed access to the server after a communication error occurs
  */
-public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient implements SubscriptionAsyncBulletinBoardClient {
+public class SingleServerBulletinBoardClient implements SubscriptionBulletinBoardClient {
+
+    protected Client client;
+
+    protected BulletinBoardDigest digest;
+
+    private String dbAddress;
 
     private final int MAX_RETRIES = 11;
 
-    private ListeningScheduledExecutorService executorService;
-
-    protected BatchDigest batchDigest;
+    private final ListeningScheduledExecutorService executorService;
 
     private long lastServerErrorTime;
 
-    private final long failDelayInMilliseconds;
+    private final long FAIL_DELAY_IN_MILLISECONDS;
 
-    private final long subscriptionIntervalInMilliseconds;
+    private final long SUBSCRIPTION_INTERVAL_IN_MILLISECONDS;
 
     /**
      * Notify the client that a job has failed
@@ -53,6 +60,43 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
 
     }
 
+    private class SynchronousRetry<OUT> {
+
+        private final SingleServerWorker<?,OUT> worker;
+
+        private String thrown;
+
+        public SynchronousRetry(SingleServerWorker<?,OUT> worker) {
+            this.worker = worker;
+            this.thrown = "Could not contact server. Errors follow:\n";
+        }
+
+        OUT run() throws CommunicationException {
+
+            do {
+
+                try {
+                    return worker.call();
+                } catch (Exception e) {
+                    thrown += e.getCause() + " " + e.getMessage() + "\n";
+                }
+
+                try {
+                    Thread.sleep(FAIL_DELAY_IN_MILLISECONDS);
+                } catch (InterruptedException e) {
+                    //TODO: log
+                }
+
+                worker.decMaxRetry();
+
+            } while (worker.isRetry());
+
+            throw new CommunicationException(thrown);
+
+        }
+
+    }
+
     /**
      * This method adds a worker to the scheduled queue of the threadpool
      * If the server is in an accessible state: the job is submitted for immediate handling
@@ -64,7 +108,7 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
 
         long timeSinceLastServerError = System.currentTimeMillis() - lastServerErrorTime;
 
-        if (timeSinceLastServerError >= failDelayInMilliseconds) {
+        if (timeSinceLastServerError >= FAIL_DELAY_IN_MILLISECONDS) {
 
             // Schedule for immediate processing
             Futures.addCallback(executorService.submit(worker), callback);
@@ -74,7 +118,7 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
             // Schedule for processing immediately following delay expiry
             Futures.addCallback(executorService.schedule(
                     worker,
-                    failDelayInMilliseconds - timeSinceLastServerError,
+                    FAIL_DELAY_IN_MILLISECONDS - timeSinceLastServerError,
                     TimeUnit.MILLISECONDS),
                     callback);
 
@@ -97,6 +141,7 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
 
         @Override
         public void onSuccess(T result) {
+            if (futureCallback != null)
                 futureCallback.onSuccess(result);
         }
 
@@ -115,6 +160,7 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
                 scheduleWorker(worker, this);
             } else {
                 // No more retries: notify caller about failure
+                if (futureCallback != null)
                     futureCallback.onFailure(t);
             }
 
@@ -127,14 +173,14 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
      * It reports success back to the user only if all of the batch-data were successfully posted
      * If any batch-data fails to post: this callback reports failure
      */
-    class PostBatchDataListCallback implements FutureCallback<Boolean> {
+    class PostBatchChunkListCallback implements FutureCallback<Boolean> {
 
         private final FutureCallback<Boolean> callback;
 
         private AtomicInteger batchDataRemaining;
         private AtomicBoolean aggregatedResult;
 
-        public PostBatchDataListCallback(int batchDataLength, FutureCallback<Boolean> callback) {
+        public PostBatchChunkListCallback(int batchDataLength, FutureCallback<Boolean> callback) {
 
             this.callback = callback;
             this.batchDataRemaining = new AtomicInteger(batchDataLength);
@@ -150,6 +196,7 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
             }
 
             if (batchDataRemaining.decrementAndGet() == 0){
+                if (callback != null)
                     callback.onSuccess(this.aggregatedResult.get());
             }
         }
@@ -158,110 +205,80 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
         public void onFailure(Throwable t) {
 
             // Notify caller about failure
+            if (callback != null)
                 callback.onFailure(t);
 
         }
     }
 
+    private class ReadBatchCallback implements FutureCallback<List<BatchChunk>> {
+
+        private final BulletinBoardMessage stub;
+        private final FutureCallback<BulletinBoardMessage> callback;
+
+        public ReadBatchCallback(BulletinBoardMessage stub, FutureCallback<BulletinBoardMessage> callback) {
+            this.stub = stub;
+            this.callback = callback;
+        }
+
+        @Override
+        public void onSuccess(List<BatchChunk> result) {
+            callback.onSuccess(BulletinBoardUtils.gatherBatch(stub, result));
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            callback.onFailure(t);
+        }
+
+    }
+
     /**
-     * This callback ties together the different parts of a CompleteBatch as they arrive from the server
-     * It assembles a CompleteBatch from the parts and sends it to the user if all parts arrived
-     * If any part fails to arrive: it invokes the onFailure method
+     * This callback receives a message which may be a stub
+     * If the message is not a stub: it returns it as is to a callback function
+     * If it is a stub: it schedules a read of the batch data which will return a complete message to the callback function
      */
-    class CompleteBatchReadCallback {
+    class CompleteMessageReadCallback implements FutureCallback<List<BulletinBoardMessage>>{
 
-        private final FutureCallback<CompleteBatch> callback;
+        private final FutureCallback<BulletinBoardMessage> callback;
 
-        private List<BatchData> batchDataList;
-        private BulletinBoardMessage batchMessage;
-
-        private AtomicInteger remainingQueries;
-        private AtomicBoolean failed;
-
-        public CompleteBatchReadCallback(FutureCallback<CompleteBatch> callback) {
+        public CompleteMessageReadCallback(FutureCallback<BulletinBoardMessage> callback) {
 
             this.callback = callback;
 
-            remainingQueries = new AtomicInteger(2);
-            failed = new AtomicBoolean(false);
-
         }
 
-        protected void combineAndReturn() {
-
-            final String[] prefixes = {
-                    BulletinBoardConstants.BATCH_ID_TAG_PREFIX,
-                    BulletinBoardConstants.BATCH_TAG};
-
-            if (remainingQueries.decrementAndGet() == 0){
-
-                String batchIdStr = BulletinBoardUtils.findTagWithPrefix(batchMessage, BulletinBoardConstants.BATCH_ID_TAG_PREFIX);
-
-                if (batchIdStr == null){
-                    callback.onFailure(new CommunicationException("Server returned invalid message with no Batch ID tag"));
-                }
-
-                BeginBatchMessage beginBatchMessage =
-                        BeginBatchMessage.newBuilder()
-                                .setSignerId(batchMessage.getSig(0).getSignerId())
-                                .setBatchId(Integer.parseInt(batchIdStr))
-                                .addAllTag(BulletinBoardUtils.removePrefixTags(batchMessage, Arrays.asList(prefixes)))
-                                .build();
-                callback.onSuccess(new CompleteBatch(beginBatchMessage, batchDataList, batchMessage.getSig(0)));
-            }
-
-        }
-
-        protected void fail(Throwable t) {
-            if (failed.compareAndSet(false, true)) {
-                callback.onFailure(t);
-            }
-        }
-
-        /**
-         * @return a FutureCallback for the Batch Data List that ties to this object
-         */
-        public FutureCallback<List<BatchData>> asBatchDataListFutureCallback() {
-            return new FutureCallback<List<BatchData>>() {
-
-                @Override
-                public void onSuccess(List<BatchData> result) {
-                    batchDataList = result;
-
-                    combineAndReturn();
-                }
-
-                @Override
-                public void onFailure(Throwable t) {
-                    fail(t);
-                }
-
-            };
-        }
-
-        /**
-         * @return a FutureCallback for the Bulletin Board Message that ties to this object
-         */
-        public FutureCallback<List<BulletinBoardMessage>> asBulletinBoardMessageListFutureCallback() {
-            return new FutureCallback<List<BulletinBoardMessage>>() {
-
         @Override
         public void onSuccess(List<BulletinBoardMessage> result) {
-                    if (result.size() < 1){
-                        onFailure(new IllegalArgumentException("Server returned empty message list"));
-                        return;
+            if (result.size() <= 0) {
+                onFailure(new CommunicationException("Could not find required message on the server."));
+            } else {
+
+                BulletinBoardMessage msg = result.get(0);
+
+                if (msg.getMsg().getDataTypeCase() != UnsignedBulletinBoardMessage.DataTypeCase.MSGID) {
+                    callback.onSuccess(msg);
+                } else {
+
+                    // Create job with MAX retries for retrieval of the Batch Data List
+
+                    BatchQuery batchQuery = BatchQuery.newBuilder()
+                            .setMsgID(MessageID.newBuilder()
+                                    .setID(msg.getMsg().getMsgId())
+                                    .build())
+                            .build();
+
+                    SingleServerReadBatchWorker batchWorker = new SingleServerReadBatchWorker(dbAddress, batchQuery, MAX_RETRIES);
+
+                    scheduleWorker(batchWorker, new ReadBatchCallback(msg, callback));
+
+                }
             }
-
-                    batchMessage = result.get(0);
-
-                    combineAndReturn();
         }
 
         @Override
         public void onFailure(Throwable t) {
-                    fail(t);
-                }
-            };
+            callback.onFailure(t);
         }
 
     }
@@ -289,8 +306,13 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
         public void onSuccess(List<BulletinBoardMessage> result) {
 
             // Report new messages to user
+            if (callback != null)
                 callback.onSuccess(result);
 
+            // Update filter if needed
+
+            if (result.size() > 0) {
+
                 // Remove last filter from list (MIN_ENTRY one)
                 filterBuilder.removeFilter(filterBuilder.getFilterCount() - 1);
 
@@ -300,11 +322,15 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
                         .setEntry(result.get(result.size() - 1).getEntryNum() + 1)
                         .build());
 
-            // Create new worker with updated task
-            worker = new SingleServerReadMessagesWorker(worker.serverAddress, filterBuilder.build(), 1);
+            }
 
-            // Schedule the worker
-            scheduleWorker(worker, this);
+            // Create new worker with updated task
+            worker = new SingleServerReadMessagesWorker(worker.serverAddress, filterBuilder.build(), MAX_RETRIES);
+
+            RetryCallback<List<BulletinBoardMessage>> retryCallback = new RetryCallback<>(worker, this);
+
+            // Schedule the worker to run after the given interval has elapsed
+            Futures.addCallback(executorService.schedule(worker, SUBSCRIPTION_INTERVAL_IN_MILLISECONDS, TimeUnit.MILLISECONDS), retryCallback);
 
         }
 
@@ -315,6 +341,7 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
             fail();
 
             // Notify caller about failure and terminate subscription
+            if (callback != null)
                 callback.onFailure(t);
         }
     }
@@ -325,8 +352,8 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
 
         this.executorService = executorService;
 
-        this.failDelayInMilliseconds = failDelayInMilliseconds;
-        this.subscriptionIntervalInMilliseconds = subscriptionIntervalInMilliseconds;
+        this.FAIL_DELAY_IN_MILLISECONDS = failDelayInMilliseconds;
+        this.SUBSCRIPTION_INTERVAL_IN_MILLISECONDS = subscriptionIntervalInMilliseconds;
 
         // Set server error time to a time sufficiently in the past to make new jobs go through
         lastServerErrorTime = System.currentTimeMillis() - failDelayInMilliseconds;
@@ -348,79 +375,289 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
     @Override
     public void init(BulletinBoardClientParams clientParams) {
 
-        // Perform usual setup
-        super.init(clientParams);
-
-        // Wrap the Digest into a BatchDigest
-        batchDigest = new GenericBatchDigest(digest);
+        this.digest = new GenericBulletinBoardDigest(new SHA256Digest());
 
         // Remove all but first DB address
-        String dbAddress = meerkatDBs.get(0);
-        meerkatDBs = new LinkedList<>();
-        meerkatDBs.add(dbAddress);
+        this.dbAddress = clientParams.getBulletinBoardAddress(0);
 
     }
 
+    // Synchronous methods
+
+    @Override
+    public MessageID postMessage(BulletinBoardMessage msg) throws CommunicationException {
+
+        SingleServerPostMessageWorker worker = new SingleServerPostMessageWorker(dbAddress, msg, MAX_RETRIES);
+
+        SynchronousRetry<Boolean> retry = new SynchronousRetry<>(worker);
+
+        retry.run();
+
+        digest.reset();
+        digest.update(msg);
+
+        return digest.digestAsMessageID();
+
+    }
+
+    @Override
+    public float getRedundancy(MessageID id) throws CommunicationException {
+
+        SingleServerGetRedundancyWorker worker = new SingleServerGetRedundancyWorker(dbAddress, id, MAX_RETRIES);
+
+        SynchronousRetry<Float> retry = new SynchronousRetry<>(worker);
+
+        return retry.run();
+
+    }
+
+    @Override
+    public List<BulletinBoardMessage> readMessages(MessageFilterList filterList) throws CommunicationException {
+
+        SingleServerReadMessagesWorker worker = new SingleServerReadMessagesWorker(dbAddress, filterList, MAX_RETRIES);
+
+        SynchronousRetry<List<BulletinBoardMessage>> retry = new SynchronousRetry<>(worker);
+
+        return retry.run();
+
+    }
+
+    @Override
+    public MessageID postAsBatch(BulletinBoardMessage msg, int chunkSize) throws CommunicationException {
+
+        // Begin the batch and obtain identifier
+
+        BeginBatchMessage beginBatchMessage = BeginBatchMessage.newBuilder()
+                .addAllTag(msg.getMsg().getTagList())
+                .build();
+
+        SingleServerBeginBatchWorker beginBatchWorker = new SingleServerBeginBatchWorker(dbAddress, beginBatchMessage, MAX_RETRIES);
+
+        SynchronousRetry<Int64Value> beginRetry = new SynchronousRetry<>(beginBatchWorker);
+
+        Int64Value identifier = beginRetry.run();
+
+        // Post data chunks
+
+        List<BatchChunk> batchChunkList = BulletinBoardUtils.breakToBatch(msg, chunkSize);
+
+        BatchMessage.Builder builder = BatchMessage.newBuilder().setBatchId(identifier.getValue());
+
+        int position = 0;
+
+        for (BatchChunk data : batchChunkList) {
+
+            builder.setSerialNum(position).setData(data);
+
+            SingleServerPostBatchWorker dataWorker = new SingleServerPostBatchWorker(dbAddress, builder.build(), MAX_RETRIES);
+
+            SynchronousRetry<Boolean> dataRetry = new SynchronousRetry<>(dataWorker);
+
+            dataRetry.run();
+
+            // Increment position in batch
+            position++;
+
+        }
+
+        // Close batch
+
+        CloseBatchMessage closeBatchMessage = CloseBatchMessage.newBuilder()
+                .setBatchId(identifier.getValue())
+                .addAllSig(msg.getSigList())
+                .setTimestamp(msg.getMsg().getTimestamp())
+                .setBatchLength(position)
+                .build();
+
+        SingleServerCloseBatchWorker closeBatchWorker = new SingleServerCloseBatchWorker(dbAddress, closeBatchMessage, MAX_RETRIES);
+
+        SynchronousRetry<Boolean> retry = new SynchronousRetry<>(closeBatchWorker);
+
+        retry.run();
+
+        // Calculate ID and return
+
+        digest.reset();
+        digest.update(msg);
+
+        return digest.digestAsMessageID();
+
+    }
+
+    @Override
+    public BulletinBoardMessage readMessage(MessageID msgID) throws CommunicationException {
+
+        // Retrieve message (which may be a stub)
+
+        MessageFilterList filterList = MessageFilterList.newBuilder()
+                .addFilter(MessageFilter.newBuilder()
+                        .setType(FilterType.MSG_ID)
+                        .setId(msgID.getID())
+                        .build())
+                .build();
+
+        SingleServerReadMessagesWorker stubWorker = new SingleServerReadMessagesWorker(dbAddress, filterList, MAX_RETRIES);
+
+        SynchronousRetry<List<BulletinBoardMessage>> retry = new SynchronousRetry<>(stubWorker);
+
+        List<BulletinBoardMessage> messages = retry.run();
+
+        if (messages.size() <= 0) {
+            throw new CommunicationException("Could not find message in database.");
+        }
+
+        BulletinBoardMessage msg = messages.get(0);
+
+        if (msg.getMsg().getDataTypeCase() != UnsignedBulletinBoardMessage.DataTypeCase.MSGID) {
+
+            // We retrieved a complete message. Return it.
+            return msg;
+
+        } else {
+
+            // We retrieved a stub. Retrieve data.
+            return readBatchData(msg);
+
+        }
+
+    }
+
+    @Override
+    public BulletinBoardMessage readBatchData(BulletinBoardMessage stub) throws CommunicationException, IllegalArgumentException {
+
+        BatchQuery batchQuery = BatchQuery.newBuilder()
+                .setMsgID(MessageID.newBuilder()
+                        .setID(stub.getMsg().getMsgId())
+                        .build())
+                .setStartPosition(0)
+                .build();
+
+        SingleServerReadBatchWorker readBatchWorker = new SingleServerReadBatchWorker(dbAddress, batchQuery, MAX_RETRIES);
+
+        SynchronousRetry<List<BatchChunk>> batchRetry = new SynchronousRetry<>(readBatchWorker);
+
+        List<BatchChunk> batchChunkList = batchRetry.run();
+
+        return BulletinBoardUtils.gatherBatch(stub, batchChunkList);
+
+    }
+
+    @Override
+    public SyncQuery generateSyncQuery(GenerateSyncQueryParams generateSyncQueryParams) throws CommunicationException {
+
+        SingleServerGenerateSyncQueryWorker worker =
+                new SingleServerGenerateSyncQueryWorker(dbAddress, generateSyncQueryParams, MAX_RETRIES);
+
+        SynchronousRetry<SyncQuery> retry = new SynchronousRetry<>(worker);
+
+        return retry.run();
+
+    }
+
+    // Asynchronous methods
+
     @Override
     public MessageID postMessage(BulletinBoardMessage msg, FutureCallback<Boolean> callback) {
 
         // Create worker with redundancy 1 and MAX_RETRIES retries
-        SingleServerPostMessageWorker worker = new SingleServerPostMessageWorker(meerkatDBs.get(0), msg, MAX_RETRIES);
+        SingleServerPostMessageWorker worker = new SingleServerPostMessageWorker(dbAddress, msg, MAX_RETRIES);
 
         // Submit worker and create callback
         scheduleWorker(worker, new RetryCallback<>(worker, callback));
 
         // Calculate the correct message ID and return it
-        batchDigest.reset();
-        batchDigest.update(msg.getMsg());
-        return batchDigest.digestAsMessageID();
+        digest.reset();
+        digest.update(msg.getMsg());
+        return digest.digestAsMessageID();
 
     }
 
     private class PostBatchDataCallback implements FutureCallback<Boolean> {
 
-        private final CompleteBatch completeBatch;
+        private final BulletinBoardMessage msg;
+        private final BatchIdentifier identifier;
         private final FutureCallback<Boolean> callback;
 
-        public PostBatchDataCallback(CompleteBatch completeBatch, FutureCallback<Boolean> callback) {
-            this.completeBatch = completeBatch;
+        public PostBatchDataCallback(BulletinBoardMessage msg, BatchIdentifier identifier, FutureCallback<Boolean> callback) {
+            this.msg = msg;
+            this.identifier = identifier;
             this.callback = callback;
         }
 
         @Override
-        public void onSuccess(Boolean msg) {
+        public void onSuccess(Boolean result) {
             closeBatch(
-                    completeBatch.getCloseBatchMessage(),
+                    identifier,
+                    msg.getMsg().getTimestamp(),
+                    msg.getSigList(),
                     callback
             );
         }
 
         @Override
         public void onFailure(Throwable t) {
+            if (callback != null)
                 callback.onFailure(t);
         }
 
     }
 
-    private class BeginBatchCallback implements FutureCallback<Boolean> {
+    private class ContinueBatchCallback implements FutureCallback<BatchIdentifier> {
 
-        private final CompleteBatch completeBatch;
+        private final BulletinBoardMessage msg;
+        private final int chunkSize;
         private final FutureCallback<Boolean> callback;
 
-        public BeginBatchCallback(CompleteBatch completeBatch, FutureCallback<Boolean> callback) {
-            this.completeBatch = completeBatch;
+        public ContinueBatchCallback(BulletinBoardMessage msg, int chunkSize, FutureCallback<Boolean> callback) {
+            this.msg = msg;
+            this.chunkSize = chunkSize;
             this.callback = callback;
         }
 
         @Override
-        public void onSuccess(Boolean msg) {
+        public void onSuccess(BatchIdentifier identifier) {
+
+            List<BatchChunk> batchChunkList = BulletinBoardUtils.breakToBatch(msg, chunkSize);
 
             postBatchData(
-                    completeBatch.getBeginBatchMessage().getSignerId(),
-                    completeBatch.getBeginBatchMessage().getBatchId(),
-                    completeBatch.getBatchDataList(),
+                    identifier,
+                    batchChunkList,
                     0,
-                    new PostBatchDataCallback(completeBatch,callback));
+                    new PostBatchDataCallback(msg, identifier, callback));
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            if (callback != null)
+                callback.onFailure(t);
+        }
+    }
+
+    @Override
+    public MessageID postAsBatch(BulletinBoardMessage msg, int chunkSize, FutureCallback<Boolean> callback) {
+
+        beginBatch(
+                msg.getMsg().getTagList(),
+                new ContinueBatchCallback(msg, chunkSize, callback)
+        );
+
+        digest.update(msg);
+
+        return digest.digestAsMessageID();
+
+    }
+
+    private class BeginBatchCallback implements FutureCallback<Int64Value> {
+
+        private final FutureCallback<BatchIdentifier> callback;
+
+        public BeginBatchCallback(FutureCallback<BatchIdentifier> callback) {
+            this.callback = callback;
+        }
+
+        @Override
+        public void onSuccess(Int64Value result) {
+            callback.onSuccess(new SingleServerBatchIdentifier(result));
         }
 
         @Override
@@ -430,51 +667,53 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
     }
 
     @Override
-    public MessageID postBatch(CompleteBatch completeBatch, FutureCallback<Boolean> callback) {
+    public void beginBatch(Iterable<String> tags, FutureCallback<BatchIdentifier> callback) {
 
-        beginBatch(
-                completeBatch.getBeginBatchMessage(),
-                new BeginBatchCallback(completeBatch, callback)
-        );
-
-        batchDigest.update(completeBatch);
-
-        return batchDigest.digestAsMessageID();
-
-    }
-
-    @Override
-    public void beginBatch(BeginBatchMessage beginBatchMessage, FutureCallback<Boolean> callback) {
+        BeginBatchMessage beginBatchMessage = BeginBatchMessage.newBuilder()
+                .addAllTag(tags)
+                .build();
 
         // Create worker with redundancy 1 and MAX_RETRIES retries
         SingleServerBeginBatchWorker worker =
-                new SingleServerBeginBatchWorker(meerkatDBs.get(0), beginBatchMessage, MAX_RETRIES);
+                new SingleServerBeginBatchWorker(dbAddress, beginBatchMessage, MAX_RETRIES);
 
         // Submit worker and create callback
-        scheduleWorker(worker, new RetryCallback<>(worker, callback));
+        scheduleWorker(worker, new RetryCallback<>(worker, new BeginBatchCallback(callback)));
 
     }
 
-    @Override
-    public void postBatchData(ByteString signerId, int batchId, List<BatchData> batchDataList,
-                          int startPosition, FutureCallback<Boolean> callback) {
 
-        BatchMessage.Builder builder = BatchMessage.newBuilder()
-                .setSignerId(signerId)
-                .setBatchId(batchId);
+    @Override
+    public void postBatchData(BatchIdentifier batchIdentifier, List<BatchChunk> batchChunkList,
+                          int startPosition, FutureCallback<Boolean> callback) throws IllegalArgumentException{
+
+        // Cast identifier to usable form
+
+        if (!(batchIdentifier instanceof SingleServerBatchIdentifier)){
+            throw new IllegalArgumentException("Error: batch identifier supplied was not created by this class.");
+        }
+
+        SingleServerBatchIdentifier identifier = (SingleServerBatchIdentifier) batchIdentifier;
+
+        // Update batch size
+
+        identifier.setLength(startPosition + batchChunkList.size());
 
         // Create a unified callback to aggregate successful posts
 
-        PostBatchDataListCallback listCallback = new PostBatchDataListCallback(batchDataList.size(), callback);
+        PostBatchChunkListCallback listCallback = new PostBatchChunkListCallback(batchChunkList.size(), callback);
 
         // Iterate through data list
 
-        for (BatchData data : batchDataList) {
+        BatchMessage.Builder builder = BatchMessage.newBuilder()
+                .setBatchId(identifier.getBatchId().getValue());
+
+        for (BatchChunk data : batchChunkList) {
             builder.setSerialNum(startPosition).setData(data);
 
             // Create worker with redundancy 1 and MAX_RETRIES retries
             SingleServerPostBatchWorker worker =
-                    new SingleServerPostBatchWorker(meerkatDBs.get(0), builder.build(), MAX_RETRIES);
+                    new SingleServerPostBatchWorker(dbAddress, builder.build(), MAX_RETRIES);
 
             // Create worker with redundancy 1 and MAX_RETRIES retries
             scheduleWorker(worker, new RetryCallback<>(worker, listCallback));
@@ -486,33 +725,33 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
     }
 
     @Override
-    public void postBatchData(ByteString signerId, int batchId, List<BatchData> batchDataList, FutureCallback<Boolean> callback) {
+    public void postBatchData(BatchIdentifier batchIdentifier, List<BatchChunk> batchChunkList, FutureCallback<Boolean> callback)
+        throws IllegalArgumentException {
 
-        postBatchData(signerId, batchId, batchDataList, 0, callback);
+        postBatchData(batchIdentifier, batchChunkList, 0, callback);
 
     }
 
     @Override
-    public void postBatchData(byte[] signerId, int batchId, List<BatchData> batchDataList,
-                              int startPosition, FutureCallback<Boolean> callback) {
-
-        postBatchData(ByteString.copyFrom(signerId), batchId, batchDataList, startPosition, callback);
+    public void closeBatch(BatchIdentifier batchIdentifier, Timestamp timestamp, Iterable<Crypto.Signature> signatures, FutureCallback<Boolean> callback)
+            throws IllegalArgumentException {
 
+        if (!(batchIdentifier instanceof SingleServerBatchIdentifier)){
+            throw new IllegalArgumentException("Error: batch identifier supplied was not created by this class.");
         }
 
-    @Override
-    public void postBatchData(byte[] signerId, int batchId, List<BatchData> batchDataList, FutureCallback<Boolean> callback) {
+        SingleServerBatchIdentifier identifier = (SingleServerBatchIdentifier) batchIdentifier;
 
-        postBatchData(signerId, batchId, batchDataList, 0, callback);
-
-    }
-
-    @Override
-    public void closeBatch(CloseBatchMessage closeBatchMessage, FutureCallback<Boolean> callback) {
+        CloseBatchMessage closeBatchMessage = CloseBatchMessage.newBuilder()
+                .setBatchId(identifier.getBatchId().getValue())
+                .setBatchLength(identifier.getLength())
+                .setTimestamp(timestamp)
+                .addAllSig(signatures)
+                .build();
 
         // Create worker with redundancy 1 and MAX_RETRIES retries
         SingleServerCloseBatchWorker worker =
-                new SingleServerCloseBatchWorker(meerkatDBs.get(0), closeBatchMessage, MAX_RETRIES);
+                new SingleServerCloseBatchWorker(dbAddress, closeBatchMessage, MAX_RETRIES);
 
         // Submit worker and create callback
         scheduleWorker(worker, new RetryCallback<>(worker, callback));
@@ -523,7 +762,7 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
     public void getRedundancy(MessageID id, FutureCallback<Float> callback) {
 
         // Create worker with no retries
-        SingleServerGetRedundancyWorker worker = new SingleServerGetRedundancyWorker(meerkatDBs.get(0), id, 1);
+        SingleServerGetRedundancyWorker worker = new SingleServerGetRedundancyWorker(dbAddress, id, 1);
 
         // Submit job and create callback
         scheduleWorker(worker, new RetryCallback<>(worker, callback));
@@ -534,7 +773,7 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
     public void readMessages(MessageFilterList filterList, FutureCallback<List<BulletinBoardMessage>> callback) {
 
         // Create job with no retries
-        SingleServerReadMessagesWorker worker = new SingleServerReadMessagesWorker(meerkatDBs.get(0), filterList, 1);
+        SingleServerReadMessagesWorker worker = new SingleServerReadMessagesWorker(dbAddress, filterList, 1);
 
         // Submit job and create callback
         scheduleWorker(worker, new RetryCallback<>(worker, callback));
@@ -542,43 +781,55 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
     }
 
     @Override
-    public void readBatch(BatchSpecificationMessage batchSpecificationMessage, FutureCallback<CompleteBatch> callback) {
+    public void readMessage(MessageID msgID, FutureCallback<BulletinBoardMessage> callback) {
 
-        // Create job with no retries for retrieval of the Bulletin Board Message that defines the batch
+        // Create job with MAX retries for retrieval of the Bulletin Board Message (which may be a stub)
 
         MessageFilterList filterList = MessageFilterList.newBuilder()
                 .addFilter(MessageFilter.newBuilder()
-                        .setType(FilterType.TAG)
-                        .setTag(BulletinBoardConstants.BATCH_TAG)
-                        .build())
-                .addFilter(MessageFilter.newBuilder()
-                        .setType(FilterType.TAG)
-                        .setTag(BulletinBoardConstants.BATCH_ID_TAG_PREFIX + batchSpecificationMessage.getBatchId())
-                        .build())
-                .addFilter(MessageFilter.newBuilder()
-                        .setType(FilterType.SIGNER_ID)
-                        .setId(batchSpecificationMessage.getSignerId())
+                        .setType(FilterType.MSG_ID)
+                        .setId(msgID.getID())
                         .build())
                 .build();
 
-        SingleServerReadMessagesWorker messageWorker = new SingleServerReadMessagesWorker(meerkatDBs.get(0), filterList, 1);
+        BatchQuery batchQuery = BatchQuery.newBuilder()
+                .setMsgID(msgID)
+                .setStartPosition(0)
+                .build();
 
-        // Create job with no retries for retrieval of the Batch Data List
-        SingleServerReadBatchWorker batchWorker = new SingleServerReadBatchWorker(meerkatDBs.get(0), batchSpecificationMessage, 1);
-
-        // Create callback that will combine the two worker products
-        CompleteBatchReadCallback completeBatchReadCallback = new CompleteBatchReadCallback(callback);
+        SingleServerReadMessagesWorker messageWorker = new SingleServerReadMessagesWorker(dbAddress, filterList, MAX_RETRIES);
 
         // Submit jobs with wrapped callbacks
-        scheduleWorker(messageWorker, new RetryCallback<>(messageWorker, completeBatchReadCallback.asBulletinBoardMessageListFutureCallback()));
-        scheduleWorker(batchWorker, new RetryCallback<>(batchWorker, completeBatchReadCallback.asBatchDataListFutureCallback()));
+        scheduleWorker(messageWorker, new RetryCallback<>(messageWorker, new CompleteMessageReadCallback(callback)));
+
+    }
+
+    @Override
+    public void readBatchData(BulletinBoardMessage stub, FutureCallback<BulletinBoardMessage> callback) throws IllegalArgumentException{
+
+        if (stub.getMsg().getDataTypeCase() != UnsignedBulletinBoardMessage.DataTypeCase.MSGID) {
+            throw new IllegalArgumentException("Message is not a stub and does not contain the required message ID");
+        }
+
+        // Create job with MAX retries for retrieval of the Batch Data List
+
+        BatchQuery batchQuery = BatchQuery.newBuilder()
+                .setMsgID(MessageID.newBuilder()
+                        .setID(stub.getMsg().getMsgId())
+                        .build())
+                .setStartPosition(0)
+                .build();
+
+        SingleServerReadBatchWorker batchWorker = new SingleServerReadBatchWorker(dbAddress, batchQuery, MAX_RETRIES);
+
+        scheduleWorker(batchWorker, new RetryCallback<>(batchWorker, new ReadBatchCallback(stub, callback)));
 
     }
 
     @Override
     public void querySync(SyncQuery syncQuery, FutureCallback<SyncQueryResponse> callback) {
 
-        SingleServerQuerySyncWorker worker = new SingleServerQuerySyncWorker(meerkatDBs.get(0), syncQuery, MAX_RETRIES);
+        SingleServerQuerySyncWorker worker = new SingleServerQuerySyncWorker(dbAddress, syncQuery, MAX_RETRIES);
 
         scheduleWorker(worker, new RetryCallback<>(worker, callback));
 
@@ -604,7 +855,7 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
                 .build());
 
         // Create job with no retries
-        SingleServerReadMessagesWorker worker = new SingleServerReadMessagesWorker(meerkatDBs.get(0), filterListBuilder.build(), MAX_RETRIES);
+        SingleServerReadMessagesWorker worker = new SingleServerReadMessagesWorker(dbAddress, filterListBuilder.build(), MAX_RETRIES);
 
         // Submit job and create callback that retries on failure and handles repeated subscription
         scheduleWorker(worker, new RetryCallback<>(worker, new SubscriptionCallback(worker, callback)));
@@ -618,8 +869,6 @@ public class SingleServerBulletinBoardClient extends SimpleBulletinBoardClient i
     @Override
     public void close() {
 
-        super.close();
-
         executorService.shutdown();
 
     }

bulletin-board-client/src/main/java/meerkat/bulletinboard/ThreadedBulletinBoardClient.java

@@ -1,12 +1,11 @@
 package meerkat.bulletinboard;
 
 import com.google.common.util.concurrent.FutureCallback;
-import com.google.protobuf.ByteString;
 
+import com.google.protobuf.Timestamp;
 import meerkat.bulletinboard.workers.multiserver.*;
-import meerkat.comm.CommunicationException;
-import meerkat.protobuf.BulletinBoardAPI;
 import meerkat.protobuf.BulletinBoardAPI.*;
+import meerkat.protobuf.Crypto.Signature;
 import meerkat.protobuf.Voting.*;
 
 import java.util.ArrayList;
@@ -31,18 +30,33 @@ public class ThreadedBulletinBoardClient extends SimpleBulletinBoardClient imple
     // Per-server clients
     private List<SingleServerBulletinBoardClient> clients;
 
-    private BatchDigest batchDigest;
+    private BulletinBoardDigest batchDigest;
 
     private final static int POST_MESSAGE_RETRY_NUM = 3;
     private final static int READ_MESSAGES_RETRY_NUM = 1;
     private final static int GET_REDUNDANCY_RETRY_NUM = 1;
 
-    private static final int SERVER_THREADPOOL_SIZE = 5;
-    private static final long FAIL_DELAY = 5000;
-    private static final long SUBSCRIPTION_INTERVAL = 10000;
+    private final int SERVER_THREADPOOL_SIZE;
+    private final long FAIL_DELAY;
+    private final long SUBSCRIPTION_INTERVAL;
+
+    private static final int DEFAULT_SERVER_THREADPOOL_SIZE = 5;
+    private static final long DEFAULT_FAIL_DELAY = 5000;
+    private static final long DEFAULT_SUBSCRIPTION_INTERVAL = 10000;
 
     private int minAbsoluteRedundancy;
 
+
+    public ThreadedBulletinBoardClient(int serverThreadpoolSize, long failDelay, long subscriptionInterval) {
+        SERVER_THREADPOOL_SIZE = serverThreadpoolSize;
+        FAIL_DELAY = failDelay;
+        SUBSCRIPTION_INTERVAL = subscriptionInterval;
+    }
+
+    public ThreadedBulletinBoardClient() {
+        this(DEFAULT_SERVER_THREADPOOL_SIZE, DEFAULT_FAIL_DELAY, DEFAULT_SUBSCRIPTION_INTERVAL);
+    }
+
     /**
      * Stores database locations and initializes the web Client
      * Stores the required minimum redundancy.
@@ -54,7 +68,7 @@ public class ThreadedBulletinBoardClient extends SimpleBulletinBoardClient imple
 
         super.init(clientParams);
 
-        batchDigest = new GenericBatchDigest(digest);
+        batchDigest = new GenericBulletinBoardDigest(digest);
 
         minAbsoluteRedundancy = (int) (clientParams.getMinRedundancy() * (float) clientParams.getBulletinBoardAddressCount());
 
@@ -100,28 +114,28 @@ public class ThreadedBulletinBoardClient extends SimpleBulletinBoardClient imple
     }
 
     @Override
-    public MessageID postBatch(CompleteBatch completeBatch, FutureCallback<Boolean> callback) {
+    public MessageID postAsBatch(BulletinBoardMessage msg, int chunkSize, FutureCallback<Boolean> callback) {
 
         // Create job
         MultiServerPostBatchWorker worker =
-                new MultiServerPostBatchWorker(clients, minAbsoluteRedundancy, completeBatch, POST_MESSAGE_RETRY_NUM, callback);
+                new MultiServerPostBatchWorker(clients, minAbsoluteRedundancy, msg, chunkSize, POST_MESSAGE_RETRY_NUM, callback);
 
         // Submit job
         executorService.submit(worker);
 
         // Calculate the correct message ID and return it
         batchDigest.reset();
-        batchDigest.update(completeBatch);
+        batchDigest.update(msg);
         return batchDigest.digestAsMessageID();
 
     }
 
     @Override
-    public void beginBatch(BeginBatchMessage beginBatchMessage, FutureCallback<Boolean> callback) {
+    public void beginBatch(Iterable<String> tags, FutureCallback<BatchIdentifier> callback) {
 
         // Create job
         MultiServerBeginBatchWorker worker =
-                new MultiServerBeginBatchWorker(clients, minAbsoluteRedundancy, beginBatchMessage, POST_MESSAGE_RETRY_NUM, callback);
+                new MultiServerBeginBatchWorker(clients, minAbsoluteRedundancy, tags, POST_MESSAGE_RETRY_NUM, callback);
 
         // Submit job
         executorService.submit(worker);
@@ -129,10 +143,18 @@ public class ThreadedBulletinBoardClient extends SimpleBulletinBoardClient imple
     }
 
     @Override
-    public void postBatchData(byte[] signerId, int batchId, List<BatchData> batchDataList,
-                              int startPosition, FutureCallback<Boolean> callback) {
+    public void postBatchData(BatchIdentifier batchIdentifier, List<BatchChunk> batchChunkList,
+                              int startPosition, FutureCallback<Boolean> callback) throws IllegalArgumentException {
 
-        BatchDataContainer batchDataContainer = new BatchDataContainer(signerId, batchId, batchDataList, startPosition);
+        // Cast identifier to usable form
+
+        if (!(batchIdentifier instanceof MultiServerBatchIdentifier)){
+            throw new IllegalArgumentException("Error: batch identifier supplied was not created by this class.");
+        }
+
+        MultiServerBatchIdentifier identifier = (MultiServerBatchIdentifier) batchIdentifier;
+
+        BatchDataContainer batchDataContainer = new BatchDataContainer(identifier, batchChunkList, startPosition);
 
         // Create job
         MultiServerPostBatchDataWorker worker =
@@ -144,33 +166,26 @@ public class ThreadedBulletinBoardClient extends SimpleBulletinBoardClient imple
     }
 
     @Override
-    public void postBatchData(byte[] signerId, int batchId, List<BatchData> batchDataList, FutureCallback<Boolean> callback) {
+    public void postBatchData(BatchIdentifier batchIdentifier, List<BatchChunk> batchChunkList, FutureCallback<Boolean> callback)
+            throws IllegalArgumentException {
 
-        postBatchData(signerId, batchId, batchDataList, 0, callback);
+        postBatchData(batchIdentifier, batchChunkList, 0, callback);
 
     }
 
     @Override
-    public void postBatchData(ByteString signerId, int batchId, List<BatchData> batchDataList,
-                              int startPosition, FutureCallback<Boolean> callback) {
-
-        postBatchData(signerId.toByteArray(), batchId, batchDataList, startPosition, callback);
+    public void closeBatch(BatchIdentifier payload, Timestamp timestamp, Iterable<Signature> signatures, FutureCallback<Boolean> callback)
+        throws IllegalArgumentException{
 
+        if (!(payload instanceof MultiServerBatchIdentifier)) {
+            throw new IllegalArgumentException("Error: batch identifier supplied was not created by this class.");
         }
 
-    @Override
-    public void postBatchData(ByteString signerId, int batchId, List<BatchData> batchDataList, FutureCallback<Boolean> callback) {
-
-        postBatchData(signerId, batchId, batchDataList, 0, callback);
-
-    }
-
-    @Override
-    public void closeBatch(CloseBatchMessage closeBatchMessage, FutureCallback<Boolean> callback) {
+        MultiServerBatchIdentifier identifier = (MultiServerBatchIdentifier) payload;
 
         // Create job
         MultiServerCloseBatchWorker worker =
-                new MultiServerCloseBatchWorker(clients, minAbsoluteRedundancy, closeBatchMessage, POST_MESSAGE_RETRY_NUM, callback);
+                new MultiServerCloseBatchWorker(clients, minAbsoluteRedundancy, identifier, timestamp, signatures, POST_MESSAGE_RETRY_NUM, callback);
 
         // Submit job
         executorService.submit(worker);
@@ -213,11 +228,27 @@ public class ThreadedBulletinBoardClient extends SimpleBulletinBoardClient imple
     }
 
     @Override
-    public void readBatch(BatchSpecificationMessage batchSpecificationMessage, FutureCallback<CompleteBatch> callback) {
+    public void readMessage(MessageID msgID, FutureCallback<BulletinBoardMessage> callback) {
+
+        //Create job
+        MultiServerReadMessageWorker worker =
+                new MultiServerReadMessageWorker(clients, minAbsoluteRedundancy, msgID, READ_MESSAGES_RETRY_NUM, callback);
+
+        // Submit job
+        executorService.submit(worker);
+
+    }
+
+    @Override
+    public void readBatchData(BulletinBoardMessage stub, FutureCallback<BulletinBoardMessage> callback) throws IllegalArgumentException {
+
+        if (stub.getMsg().getDataTypeCase() != UnsignedBulletinBoardMessage.DataTypeCase.MSGID) {
+            throw new IllegalArgumentException("Message is not a stub and does not contain the required message ID");
+        }
 
         // Create job
-        MultiServerReadBatchWorker worker =
-                new MultiServerReadBatchWorker(clients, minAbsoluteRedundancy, batchSpecificationMessage, READ_MESSAGES_RETRY_NUM, callback);
+        MultiServerReadBatchDataWorker worker =
+                new MultiServerReadBatchDataWorker(clients, minAbsoluteRedundancy, stub, READ_MESSAGES_RETRY_NUM, callback);
 
         // Submit job
         executorService.submit(worker);

bulletin-board-client/src/main/java/meerkat/bulletinboard/ThreadedBulletinBoardSubscriber.java

@@ -8,7 +8,6 @@ import meerkat.util.BulletinBoardUtils;
 
 import static meerkat.protobuf.BulletinBoardAPI.FilterType.*;
 
-import java.sql.Time;
 import java.util.*;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -19,20 +18,22 @@ import java.util.concurrent.atomic.AtomicBoolean;
  */
 public class ThreadedBulletinBoardSubscriber implements BulletinBoardSubscriber {
 
-    protected final Collection<SubscriptionAsyncBulletinBoardClient> clients;
+    protected final Collection<SubscriptionBulletinBoardClient> clients;
     protected final BulletinBoardClient localClient;
 
-    protected Iterator<SubscriptionAsyncBulletinBoardClient> clientIterator;
-    protected SubscriptionAsyncBulletinBoardClient currentClient;
+    protected Iterator<SubscriptionBulletinBoardClient> clientIterator;
+    protected SubscriptionBulletinBoardClient currentClient;
 
     private long lastServerSwitchTime;
 
     private AtomicBoolean isSyncInProgress;
     private Semaphore rescheduleSemaphore;
 
+    private AtomicBoolean stopped;
+
     private static final Float[] BREAKPOINTS = {0.5f, 0.75f, 0.9f, 0.95f, 0.99f, 0.999f};
 
-    public ThreadedBulletinBoardSubscriber(Collection<SubscriptionAsyncBulletinBoardClient> clients, BulletinBoardClient localClient) {
+    public ThreadedBulletinBoardSubscriber(Collection<SubscriptionBulletinBoardClient> clients, BulletinBoardClient localClient) {
 
         this.clients = clients;
         this.localClient = localClient;
@@ -45,6 +46,8 @@ public class ThreadedBulletinBoardSubscriber implements BulletinBoardSubscriber
         isSyncInProgress = new AtomicBoolean(false);
         rescheduleSemaphore = new Semaphore(1);
 
+        stopped = new AtomicBoolean(false);
+
     }
 
     /**
@@ -132,6 +135,7 @@ public class ThreadedBulletinBoardSubscriber implements BulletinBoardSubscriber
 
                 //TODO: log
 
+                if (callback != null)
                     callback.onFailure(e); // Hard error: Cannot guarantee subscription safety
 
             }
@@ -218,6 +222,7 @@ public class ThreadedBulletinBoardSubscriber implements BulletinBoardSubscriber
         public void onSuccess(List<BulletinBoardMessage> result) {
 
             // Propagate result to caller
+            if (callback != null)
                 callback.onSuccess(result);
 
             // Renew subscription
@@ -245,11 +250,11 @@ public class ThreadedBulletinBoardSubscriber implements BulletinBoardSubscriber
             super(filterList, callback);
         }
 
-
         @Override
         public void onSuccess(List<BulletinBoardMessage> result) {
 
             // Propagate result to caller
+            if (callback != null)
                 callback.onSuccess(result);
 
         }
@@ -268,5 +273,4 @@ public class ThreadedBulletinBoardSubscriber implements BulletinBoardSubscriber
         subscribe(filterList, 0, callback);
     }
 
-
 }

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/multiserver/MultiServerBeginBatchWorker.java

@@ -1,28 +1,96 @@
 package meerkat.bulletinboard.workers.multiserver;
 
 import com.google.common.util.concurrent.FutureCallback;
+import meerkat.bulletinboard.MultiServerBatchIdentifier;
+import meerkat.bulletinboard.MultiServerWorker;
 import meerkat.bulletinboard.SingleServerBulletinBoardClient;
-import meerkat.protobuf.BulletinBoardAPI.BeginBatchMessage;
+import meerkat.bulletinboard.AsyncBulletinBoardClient.BatchIdentifier;
+import meerkat.comm.CommunicationException;
 
 import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * Created by Arbel Deutsch Peled on 27-Dec-15.
  */
-public class MultiServerBeginBatchWorker extends MultiServerGenericPostWorker<BeginBatchMessage> {
+public class MultiServerBeginBatchWorker extends MultiServerWorker<Iterable<String>, BatchIdentifier> {
+
+    private BatchIdentifier[] identifiers;
+    private AtomicInteger remainingServers;
 
     public MultiServerBeginBatchWorker(List<SingleServerBulletinBoardClient> clients,
-                                       int minServers, BeginBatchMessage payload, int maxRetry,
-                                       FutureCallback<Boolean> futureCallback) {
+                                       int minServers, Iterable<String> payload, int maxRetry,
+                                       FutureCallback<BatchIdentifier> futureCallback) {
 
         super(clients, minServers, payload, maxRetry, futureCallback);
 
+        identifiers = new BatchIdentifier[clients.size()];
+
+        for (int i = 0 ; i < identifiers.length ; i++) {
+            identifiers[i] = null;
+        }
+
+        remainingServers = new AtomicInteger(clients.size());
+
+    }
+
+    private class BeginBatchCallback implements FutureCallback<BatchIdentifier> {
+
+        private final int clientNum;
+
+        public BeginBatchCallback(int clientNum) {
+            this.clientNum = clientNum;
+        }
+
+        private void finishPost() {
+
+            if (remainingServers.decrementAndGet() <= 0){
+
+                if (minServers.decrementAndGet() <= 0) {
+                    MultiServerBeginBatchWorker.this.onSuccess(new MultiServerBatchIdentifier(identifiers));
+                } else {
+                    MultiServerBeginBatchWorker.this.onFailure(new CommunicationException("Could not open batch in enough servers"));
+                }
+            }
+
         }
 
         @Override
-    protected void doPost(SingleServerBulletinBoardClient client, BeginBatchMessage payload) {
-        client.beginBatch(payload, this);
+        public void onSuccess(BatchIdentifier result) {
+
+            identifiers[clientNum] = result;
+            finishPost();
+
         }
 
+        @Override
+        public void onFailure(Throwable t) {
+            finishPost();
+        }
+    }
 
+    @Override
+    public void onSuccess(BatchIdentifier result) {
+        succeed(result);
+    }
+
+    @Override
+    public void onFailure(Throwable t) {
+        fail(t);
+    }
+
+    @Override
+    public void run() {
+
+        int clientNum = 0;
+
+        for (SingleServerBulletinBoardClient client : clients){
+
+            client.beginBatch(payload, new BeginBatchCallback(clientNum));
+
+            clientNum++;
+
+        }
+
+    }
 }

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/multiserver/MultiServerCloseBatchWorker.java

@@ -1,27 +1,83 @@
 package meerkat.bulletinboard.workers.multiserver;
 
 import com.google.common.util.concurrent.FutureCallback;
+import com.google.protobuf.Timestamp;
+import meerkat.bulletinboard.AsyncBulletinBoardClient.BatchIdentifier;
+import meerkat.bulletinboard.BatchDataContainer;
+import meerkat.bulletinboard.MultiServerBatchIdentifier;
+import meerkat.bulletinboard.MultiServerWorker;
 import meerkat.bulletinboard.SingleServerBulletinBoardClient;
-import meerkat.protobuf.BulletinBoardAPI.CloseBatchMessage;
+import meerkat.crypto.DigitalSignature;
+import meerkat.protobuf.Crypto;
+import meerkat.protobuf.Crypto.Signature;
 
+import java.util.Iterator;
 import java.util.List;
 
 /**
  * Created by Arbel Deutsch Peled on 27-Dec-15.
  */
-public class MultiServerCloseBatchWorker extends MultiServerGenericPostWorker<CloseBatchMessage> {
+public class MultiServerCloseBatchWorker extends MultiServerWorker<MultiServerBatchIdentifier, Boolean> {
+
+    private final Timestamp timestamp;
+    private final Iterable<Crypto.Signature> signatures;
 
     public MultiServerCloseBatchWorker(List<SingleServerBulletinBoardClient> clients,
-                                       int minServers, CloseBatchMessage payload, int maxRetry,
-                                       FutureCallback<Boolean> futureCallback) {
+                                       int minServers, MultiServerBatchIdentifier payload, Timestamp timestamp, Iterable<Crypto.Signature> signatures,
+                                       int maxRetry, FutureCallback<Boolean> futureCallback) {
 
         super(clients, minServers, payload, maxRetry, futureCallback);
 
+        this.timestamp = timestamp;
+        this.signatures = signatures;
+
     }
 
     @Override
-    protected void doPost(SingleServerBulletinBoardClient client, CloseBatchMessage payload) {
-        client.closeBatch(payload, this);
+    public void run() {
+
+        Iterator<BatchIdentifier> identifierIterator = payload.getIdentifiers().iterator();
+
+        // Iterate through client
+
+        for (SingleServerBulletinBoardClient client : clients) {
+
+            if (identifierIterator.hasNext()) {
+
+                // Fetch the batch identifier supplied by the specific client (may be null if batch open failed on client
+
+                BatchIdentifier identifier = identifierIterator.next();
+
+                if (identifier != null) {
+
+                    // Post the data with the matching identifier to the client
+                    client.closeBatch(identifier, timestamp, signatures, this);
+
+                } else {
+
+                    // Count servers with no batch identifier as failed
+                    maxFailedServers.decrementAndGet();
+
+                }
+
+            }
+
+        }
+
+    }
+
+    @Override
+    public void onSuccess(Boolean result) {
+        if (minServers.decrementAndGet() <= 0){
+            succeed(result);
+        }
+    }
+
+    @Override
+    public void onFailure(Throwable t) {
+        if (maxFailedServers.decrementAndGet() <= 0){
+            fail(t);
+        }
     }
 
 

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/multiserver/MultiServerGenericPostWorker.java

@@ -35,14 +35,9 @@ public abstract class MultiServerGenericPostWorker<T> extends MultiServerWorker<
     public void run() {
 
         // Iterate through servers
-
-        Iterator<SingleServerBulletinBoardClient> clientIterator = getClientIterator();
-
-        while (clientIterator.hasNext()) {
+        for (SingleServerBulletinBoardClient client : clients) {
 
             // Send request to Server
-            SingleServerBulletinBoardClient client = clientIterator.next();
-
             doPost(client, payload);
 
         }

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/multiserver/MultiServerGenericReadWorker.java

@@ -14,7 +14,9 @@ import java.util.List;
  */
 public abstract class MultiServerGenericReadWorker<IN, OUT> extends MultiServerWorker<IN, OUT>{
 
-    private final Iterator<SingleServerBulletinBoardClient> clientIterator;
+    private Iterator<SingleServerBulletinBoardClient> clientIterator;
+
+    private String errorString;
 
     public MultiServerGenericReadWorker(List<SingleServerBulletinBoardClient> clients,
                                         int minServers, IN payload, int maxRetry,
@@ -22,7 +24,8 @@ public abstract class MultiServerGenericReadWorker<IN, OUT> extends MultiServerW
 
         super(clients, true, minServers, payload, maxRetry, futureCallback); // Shuffle clients on creation to balance load
 
-        clientIterator = getClientIterator();
+        clientIterator = clients.iterator();
+        errorString = "";
 
     }
 
@@ -46,7 +49,7 @@ public abstract class MultiServerGenericReadWorker<IN, OUT> extends MultiServerW
             doRead(payload, client);
 
         } else {
-            fail(new CommunicationException("Could not contact any server"));
+            fail(new CommunicationException("Could not contact any server. Errors follow:\n" + errorString));
         }
 
     }
@@ -58,6 +61,8 @@ public abstract class MultiServerGenericReadWorker<IN, OUT> extends MultiServerW
 
     @Override
     public void onFailure(Throwable t) {
+        //TODO: log
+        errorString += t.getCause() + " " + t.getMessage() + "\n";
         run(); // Retry with next server
     }
 

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/multiserver/MultiServerGetRedundancyWorker.java

@@ -36,13 +36,8 @@ public class MultiServerGetRedundancyWorker extends MultiServerWorker<MessageID,
      */
     public void run(){
 
-        Iterator<SingleServerBulletinBoardClient> clientIterator = getClientIterator();
-
         // Iterate through clients
-
-        while (clientIterator.hasNext()) {
-
-            SingleServerBulletinBoardClient client = clientIterator.next();
+        for (SingleServerBulletinBoardClient client : clients) {
 
             // Send request to client
             client.getRedundancy(payload,this);

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/multiserver/MultiServerPostBatchDataWorker.java

@@ -1,15 +1,18 @@
 package meerkat.bulletinboard.workers.multiserver;
 
 import com.google.common.util.concurrent.FutureCallback;
+import meerkat.bulletinboard.AsyncBulletinBoardClient.BatchIdentifier;
+import meerkat.bulletinboard.MultiServerWorker;
 import meerkat.bulletinboard.SingleServerBulletinBoardClient;
 import meerkat.bulletinboard.BatchDataContainer;
 
+import java.util.Iterator;
 import java.util.List;
 
 /**
  * Created by Arbel Deutsch Peled on 27-Dec-15.
  */
-public class MultiServerPostBatchDataWorker extends MultiServerGenericPostWorker<BatchDataContainer> {
+public class MultiServerPostBatchDataWorker extends MultiServerWorker<BatchDataContainer, Boolean> {
 
     public MultiServerPostBatchDataWorker(List<SingleServerBulletinBoardClient> clients,
                                           int minServers, BatchDataContainer payload, int maxRetry,
@@ -20,9 +23,50 @@ public class MultiServerPostBatchDataWorker extends MultiServerGenericPostWorker
     }
 
     @Override
-    protected void doPost(SingleServerBulletinBoardClient client, BatchDataContainer payload) {
-        client.postBatchData(payload.signerId, payload.batchId, payload.batchDataList, payload.startPosition, this);
+    public void run() {
+
+        Iterator<BatchIdentifier> identifierIterator = payload.batchId.getIdentifiers().iterator();
+
+        // Iterate through client
+
+        for (SingleServerBulletinBoardClient client : clients) {
+
+            if (identifierIterator.hasNext()) {
+
+                // Fetch the batch identifier supplied by the specific client (may be null if batch open failed on client
+
+                BatchIdentifier identifier = identifierIterator.next();
+
+                if (identifier != null) {
+
+                    // Post the data with the matching identifier to the client
+                    client.postBatchData(identifier, payload.batchChunkList, payload.startPosition, this);
+
+                } else {
+
+                    // Count servers with no batch identifier as failed
+                    maxFailedServers.decrementAndGet();
+
                 }
 
+            }
+
+        }
+
+    }
+
+    @Override
+    public void onSuccess(Boolean result) {
+        if (minServers.decrementAndGet() <= 0){
+            succeed(result);
+        }
+    }
+
+    @Override
+    public void onFailure(Throwable t) {
+        if (maxFailedServers.decrementAndGet() <= 0){
+            fail(t);
+        }
+    }
 
 }

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/multiserver/MultiServerPostBatchWorker.java

@@ -1,27 +1,33 @@
 package meerkat.bulletinboard.workers.multiserver;
 
 import com.google.common.util.concurrent.FutureCallback;
-import meerkat.bulletinboard.CompleteBatch;
 import meerkat.bulletinboard.SingleServerBulletinBoardClient;
+import meerkat.protobuf.BulletinBoardAPI.BulletinBoardMessage;
 
 import java.util.List;
 
 /**
  * Created by Arbel Deutsch Peled on 27-Dec-15.
  */
-public class MultiServerPostBatchWorker extends MultiServerGenericPostWorker<CompleteBatch> {
+public class MultiServerPostBatchWorker extends MultiServerGenericPostWorker<BulletinBoardMessage> {
+
+    private final int chunkSize;
 
     public MultiServerPostBatchWorker(List<SingleServerBulletinBoardClient> clients,
-                                      int minServers, CompleteBatch payload, int maxRetry,
+                                      int minServers, BulletinBoardMessage payload, int chunkSize, int maxRetry,
                                       FutureCallback<Boolean> futureCallback) {
 
         super(clients, minServers, payload, maxRetry, futureCallback);
 
+        this.chunkSize = chunkSize;
+
     }
 
     @Override
-    protected void doPost(SingleServerBulletinBoardClient client, CompleteBatch payload) {
-        client.postBatch(payload, this);
+    protected void doPost(SingleServerBulletinBoardClient client, BulletinBoardMessage payload) {
+
+        client.postAsBatch(payload, chunkSize, this);
+
     }
 
 

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/multiserver/MultiServerReadBatchDataWorker.java

@@ -0,0 +1,29 @@
+package meerkat.bulletinboard.workers.multiserver;
+
+import com.google.common.util.concurrent.FutureCallback;
+import meerkat.bulletinboard.SingleServerBulletinBoardClient;
+import meerkat.protobuf.BulletinBoardAPI.*;
+
+import java.util.List;
+
+
+/**
+ * Created by Arbel Deutsch Peled on 27-Dec-15.
+ */
+public class MultiServerReadBatchDataWorker extends MultiServerGenericReadWorker<BulletinBoardMessage, BulletinBoardMessage> {
+
+    public MultiServerReadBatchDataWorker(List<SingleServerBulletinBoardClient> clients,
+                                          int minServers, BulletinBoardMessage payload, int maxRetry,
+                                          FutureCallback<BulletinBoardMessage> futureCallback) {
+
+        super(clients, minServers, payload, maxRetry, futureCallback);
+
+    }
+
+    @Override
+    protected void doRead(BulletinBoardMessage payload, SingleServerBulletinBoardClient client) {
+        client.readBatchData(payload, this);
+    }
+
+
+}

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/multiserver/MultiServerReadBatchWorker.java

@@ -1,30 +0,0 @@
-package meerkat.bulletinboard.workers.multiserver;
-
-import com.google.common.util.concurrent.FutureCallback;
-import meerkat.bulletinboard.CompleteBatch;
-import meerkat.bulletinboard.SingleServerBulletinBoardClient;
-import meerkat.protobuf.BulletinBoardAPI.BatchSpecificationMessage;
-
-import java.util.List;
-
-
-/**
- * Created by Arbel Deutsch Peled on 27-Dec-15.
- */
-public class MultiServerReadBatchWorker extends MultiServerGenericReadWorker<BatchSpecificationMessage, CompleteBatch> {
-
-    public MultiServerReadBatchWorker(List<SingleServerBulletinBoardClient> clients,
-                                      int minServers, BatchSpecificationMessage payload, int maxRetry,
-                                      FutureCallback<CompleteBatch> futureCallback) {
-
-        super(clients, minServers, payload, maxRetry, futureCallback);
-
-    }
-
-    @Override
-    protected void doRead(BatchSpecificationMessage payload, SingleServerBulletinBoardClient client) {
-        client.readBatch(payload, this);
-    }
-
-
-}

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/multiserver/MultiServerReadMessageWorker.java

@@ -0,0 +1,30 @@
+package meerkat.bulletinboard.workers.multiserver;
+
+import com.google.common.util.concurrent.FutureCallback;
+import meerkat.bulletinboard.SingleServerBulletinBoardClient;
+import meerkat.protobuf.BulletinBoardAPI.BulletinBoardMessage;
+import meerkat.protobuf.BulletinBoardAPI.MessageID;
+
+import java.util.List;
+
+
+/**
+ * Created by Arbel Deutsch Peled on 27-Dec-15.
+ */
+public class MultiServerReadMessageWorker extends MultiServerGenericReadWorker<MessageID, BulletinBoardMessage> {
+
+    public MultiServerReadMessageWorker(List<SingleServerBulletinBoardClient> clients,
+                                        int minServers, MessageID payload, int maxRetry,
+                                        FutureCallback<BulletinBoardMessage> futureCallback) {
+
+        super(clients, minServers, payload, maxRetry, futureCallback);
+
+    }
+
+    @Override
+    protected void doRead(MessageID payload, SingleServerBulletinBoardClient client) {
+        client.readMessage(payload, this);
+    }
+
+
+}

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/singleserver/SingleServerBeginBatchWorker.java

@@ -1,17 +1,53 @@
 package meerkat.bulletinboard.workers.singleserver;
 
+import com.google.protobuf.Int64Value;
+import meerkat.bulletinboard.SingleServerWorker;
+import meerkat.comm.CommunicationException;
 import meerkat.protobuf.BulletinBoardAPI.BeginBatchMessage;
+import meerkat.rest.Constants;
+
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Response;
 
 import static meerkat.bulletinboard.BulletinBoardConstants.BEGIN_BATCH_PATH;
+import static meerkat.bulletinboard.BulletinBoardConstants.BULLETIN_BOARD_SERVER_PATH;
 
 /**
  * Created by Arbel Deutsch Peled on 27-Dec-15.
  * Tries to contact server once and perform a post operation
  */
-public class SingleServerBeginBatchWorker extends SingleServerGenericPostWorker<BeginBatchMessage> {
+public class SingleServerBeginBatchWorker extends SingleServerWorker<BeginBatchMessage,Int64Value> {
 
     public SingleServerBeginBatchWorker(String serverAddress, BeginBatchMessage payload, int maxRetry) {
-        super(serverAddress, BEGIN_BATCH_PATH, payload, maxRetry);
+        super(serverAddress, payload, maxRetry);
     }
 
+    @Override
+    public Int64Value call() throws Exception {
+        Client client = clientLocal.get();
+
+        WebTarget webTarget = client.target(serverAddress).path(BULLETIN_BOARD_SERVER_PATH).path(BEGIN_BATCH_PATH);
+        Response response = webTarget.request(Constants.MEDIATYPE_PROTOBUF).post(
+                Entity.entity(payload, Constants.MEDIATYPE_PROTOBUF));
+
+        try {
+
+            Int64Value result =  response.readEntity(Int64Value.class);
+            return result;
+
+        } catch (ProcessingException | IllegalStateException e) {
+
+            // Post to this server failed
+            throw new CommunicationException("Could not contact the server. Original error: " + e.getMessage());
+
+        } catch (Exception e) {
+            throw new CommunicationException("Could not contact the server. Original error: " + e.getMessage());
+        }
+        finally {
+            response.close();
+        }
+    }
 }

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/singleserver/SingleServerGenerateSyncQueryWorker.java

@@ -0,0 +1,55 @@
+package meerkat.bulletinboard.workers.singleserver;
+
+import com.google.protobuf.Int64Value;
+import meerkat.bulletinboard.SingleServerWorker;
+import meerkat.comm.CommunicationException;
+import meerkat.protobuf.BulletinBoardAPI.SyncQuery;
+import meerkat.protobuf.BulletinBoardAPI.GenerateSyncQueryParams;
+import meerkat.rest.Constants;
+
+import javax.ws.rs.ProcessingException;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Response;
+
+import static meerkat.bulletinboard.BulletinBoardConstants.BULLETIN_BOARD_SERVER_PATH;
+import static meerkat.bulletinboard.BulletinBoardConstants.GENERATE_SYNC_QUERY_PATH;
+
+/**
+ * Created by Arbel Deutsch Peled on 27-Dec-15.
+ * Tries to contact server once and perform a Sync Query Generation operation
+ */
+public class SingleServerGenerateSyncQueryWorker extends SingleServerWorker<GenerateSyncQueryParams,SyncQuery> {
+
+    public SingleServerGenerateSyncQueryWorker(String serverAddress, GenerateSyncQueryParams payload, int maxRetry) {
+        super(serverAddress, payload, maxRetry);
+    }
+
+    @Override
+    public SyncQuery call() throws Exception {
+
+        Client client = clientLocal.get();
+
+        WebTarget webTarget = client.target(serverAddress).path(BULLETIN_BOARD_SERVER_PATH).path(GENERATE_SYNC_QUERY_PATH);
+
+        Response response = webTarget.request(Constants.MEDIATYPE_PROTOBUF).post(Entity.entity(payload, Constants.MEDIATYPE_PROTOBUF));
+
+        try {
+
+            SyncQuery result = response.readEntity(SyncQuery.class);
+            return result;
+
+        } catch (ProcessingException | IllegalStateException e) {
+
+            // Post to this server failed
+            throw new CommunicationException("Could not contact the server. Original error: " + e.getMessage());
+
+        } catch (Exception e) {
+            throw new CommunicationException("Could not contact the server. Original error: " + e.getMessage());
+        }
+        finally {
+            response.close();
+        }
+    }
+}

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/singleserver/SingleServerGetRedundancyWorker.java

@@ -6,7 +6,6 @@ import meerkat.comm.MessageInputStream;
 import meerkat.protobuf.BulletinBoardAPI.*;
 import meerkat.rest.Constants;
 
-import javax.ws.rs.ProcessingException;
 import javax.ws.rs.client.Client;
 import javax.ws.rs.client.Entity;
 import javax.ws.rs.client.WebTarget;
@@ -14,7 +13,6 @@ import javax.ws.rs.core.Response;
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.lang.reflect.InvocationTargetException;
 
 import static meerkat.bulletinboard.BulletinBoardConstants.BULLETIN_BOARD_SERVER_PATH;
 import static meerkat.bulletinboard.BulletinBoardConstants.READ_MESSAGES_PATH;

bulletin-board-client/src/main/java/meerkat/bulletinboard/workers/singleserver/SingleServerReadBatchWorker.java

@@ -1,35 +1,28 @@
 package meerkat.bulletinboard.workers.singleserver;
 
-import meerkat.bulletinboard.CompleteBatch;
 import meerkat.bulletinboard.SingleServerWorker;
 import meerkat.comm.CommunicationException;
 import meerkat.comm.MessageInputStream;
 import meerkat.protobuf.BulletinBoardAPI.*;
 import meerkat.rest.Constants;
 
-import javax.ws.rs.ProcessingException;
 import javax.ws.rs.client.Client;
 import javax.ws.rs.client.Entity;
 import javax.ws.rs.client.WebTarget;
-import javax.ws.rs.core.GenericType;
-import javax.ws.rs.core.Response;
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 
 import static meerkat.bulletinboard.BulletinBoardConstants.BULLETIN_BOARD_SERVER_PATH;
-import static meerkat.bulletinboard.BulletinBoardConstants.READ_MESSAGES_PATH;
 import static meerkat.bulletinboard.BulletinBoardConstants.READ_BATCH_PATH;
 
-import static meerkat.bulletinboard.BulletinBoardConstants.BATCH_ID_TAG_PREFIX;
-
 /**
  * Created by Arbel Deutsch Peled on 27-Dec-15.
  */
-public class SingleServerReadBatchWorker extends SingleServerWorker<BatchSpecificationMessage, List<BatchData>> {
+public class SingleServerReadBatchWorker extends SingleServerWorker<BatchQuery, List<BatchChunk>> {
 
-    public SingleServerReadBatchWorker(String serverAddress, BatchSpecificationMessage payload, int maxRetry) {
+    public SingleServerReadBatchWorker(String serverAddress, BatchQuery payload, int maxRetry) {
         super(serverAddress, payload, maxRetry);
     }
 
@@ -39,7 +32,7 @@ public class SingleServerReadBatchWorker extends SingleServerWorker<BatchSpecifi
      * @return the complete batch as read from the server
      * @throws CommunicationException if the server's response is invalid
      */
-    public List<BatchData> call() throws CommunicationException{
+    public List<BatchChunk> call() throws CommunicationException{
 
         Client client = clientLocal.get();
 
@@ -50,11 +43,11 @@ public class SingleServerReadBatchWorker extends SingleServerWorker<BatchSpecifi
         webTarget = client.target(serverAddress).path(BULLETIN_BOARD_SERVER_PATH).path(READ_BATCH_PATH);
         InputStream in = webTarget.request(Constants.MEDIATYPE_PROTOBUF).post(Entity.entity(payload, Constants.MEDIATYPE_PROTOBUF), InputStream.class);
 
-        MessageInputStream<BatchData> inputStream = null;
+        MessageInputStream<BatchChunk> inputStream = null;
 
         try {
 
-            inputStream = MessageInputStream.MessageInputStreamFactory.createMessageInputStream(in, BatchData.class);
+            inputStream = MessageInputStream.MessageInputStreamFactory.createMessageInputStream(in, BatchChunk.class);
 
             return inputStream.asList();
 

bulletin-board-client/src/test/java/meerkat/bulletinboard/BulletinBoardSynchronizerTest.java

@@ -0,0 +1,318 @@
+package meerkat.bulletinboard;
+
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.protobuf.*;
+import com.google.protobuf.Timestamp;
+
+import static meerkat.bulletinboard.BulletinBoardSynchronizer.SyncStatus;
+
+import meerkat.bulletinboard.sqlserver.BulletinBoardSQLServer;
+import meerkat.bulletinboard.sqlserver.H2QueryProvider;
+
+import meerkat.comm.CommunicationException;
+import meerkat.crypto.concrete.ECDSASignature;
+import meerkat.protobuf.BulletinBoardAPI.*;
+import meerkat.util.BulletinBoardMessageComparator;
+import meerkat.util.BulletinBoardMessageGenerator;
+import org.junit.*;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.*;
+import java.security.cert.CertificateException;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.fail;
+
+/**
+ * Created by Arbel on 6/1/2016.
+ */
+public class BulletinBoardSynchronizerTest {
+
+    private static final String REMOTE_SERVER_ADDRESS = "remoteDB";
+    private static final String LOCAL_SERVER_ADDRESS = "localDB";
+    private static int testCount;
+
+    private static final int THREAD_NUM = 3;
+    private static final int SUBSCRIPTION_INTERVAL = 1000;
+
+    private static final int SYNC_SLEEP_INTERVAL = 500;
+    private static final int SYNC_WAIT_CAP = 1000;
+
+    private DeletableSubscriptionBulletinBoardClient localClient;
+    private AsyncBulletinBoardClient remoteClient;
+
+    private BulletinBoardSynchronizer synchronizer;
+
+    private static BulletinBoardMessageGenerator messageGenerator;
+    private static BulletinBoardMessageComparator messageComparator;
+
+    private static String KEYFILE_EXAMPLE = "/certs/enduser-certs/user1-key-with-password-secret.p12";
+    private static String KEYFILE_PASSWORD1 = "secret";
+    private static String CERT1_PEM_EXAMPLE = "/certs/enduser-certs/user1.crt";
+
+    private static BulletinBoardSignature[] signers;
+    private static ByteString[] signerIDs;
+
+    private Semaphore semaphore;
+    private List<Throwable> thrown;
+
+    @BeforeClass
+    public static void build() {
+
+        messageGenerator = new BulletinBoardMessageGenerator(new Random(0));
+        messageComparator = new BulletinBoardMessageComparator();
+
+        signers = new BulletinBoardSignature[1];
+        signerIDs = new ByteString[1];
+
+        signers[0] = new GenericBulletinBoardSignature(new ECDSASignature());
+        signerIDs[0] = signers[0].getSignerID();
+
+        InputStream keyStream = BulletinBoardSynchronizerTest.class.getResourceAsStream(KEYFILE_EXAMPLE);
+        char[] password = KEYFILE_PASSWORD1.toCharArray();
+
+        try {
+
+            KeyStore.Builder keyStoreBuilder = signers[0].getPKCS12KeyStoreBuilder(keyStream, password);
+
+            signers[0].loadSigningCertificate(keyStoreBuilder);
+
+            signers[0].loadVerificationCertificates(BulletinBoardSynchronizerTest.class.getResourceAsStream(CERT1_PEM_EXAMPLE));
+
+        } catch (IOException e) {
+            System.err.println("Failed reading from signature file " + e.getMessage());
+            fail("Failed reading from signature file " + e.getMessage());
+        } catch (CertificateException e) {
+            System.err.println("Failed reading certificate " + e.getMessage());
+            fail("Failed reading certificate " + e.getMessage());
+        } catch (KeyStoreException e) {
+            System.err.println("Failed reading keystore " + e.getMessage());
+            fail("Failed reading keystore " + e.getMessage());
+        } catch (NoSuchAlgorithmException e) {
+            System.err.println("Couldn't find signing algorithm " + e.getMessage());
+            fail("Couldn't find signing algorithm " + e.getMessage());
+        } catch (UnrecoverableKeyException e) {
+            System.err.println("Couldn't find signing key " + e.getMessage());
+            fail("Couldn't find signing key " + e.getMessage());
+        }
+
+        signerIDs[0] = signers[0].getSignerID();
+
+        testCount = 0;
+
+    }
+
+    @Before
+    public void init() throws CommunicationException {
+
+        DeletableBulletinBoardServer remoteServer = new BulletinBoardSQLServer(new H2QueryProvider(REMOTE_SERVER_ADDRESS + testCount));
+        remoteServer.init();
+
+        remoteClient = new LocalBulletinBoardClient(
+                remoteServer,
+                THREAD_NUM,
+                SUBSCRIPTION_INTERVAL);
+
+        DeletableBulletinBoardServer localServer = new BulletinBoardSQLServer(new H2QueryProvider(LOCAL_SERVER_ADDRESS + testCount));
+        localServer.init();
+
+        localClient = new LocalBulletinBoardClient(
+                localServer,
+                THREAD_NUM,
+                SUBSCRIPTION_INTERVAL);
+
+        synchronizer = new SimpleBulletinBoardSynchronizer(SYNC_SLEEP_INTERVAL, SYNC_WAIT_CAP);
+        synchronizer.init(localClient, remoteClient);
+
+        semaphore = new Semaphore(0);
+        thrown = new LinkedList<>();
+
+        testCount++;
+
+    }
+
+    private class SyncStatusCallback implements FutureCallback<SyncStatus> {
+
+        private final SyncStatus statusToWaitFor;
+        private AtomicBoolean stillWaiting;
+
+        public SyncStatusCallback(SyncStatus statusToWaitFor) {
+            this.statusToWaitFor = statusToWaitFor;
+            stillWaiting = new AtomicBoolean(true);
+        }
+
+        @Override
+        public void onSuccess(SyncStatus result) {
+
+            if (result == statusToWaitFor && stillWaiting.compareAndSet(true, false)){
+                semaphore.release();
+            }
+
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            thrown.add(t);
+            if (stillWaiting.compareAndSet(true,false)) {
+                semaphore.release();
+            }
+        }
+    }
+
+    private class MessageCountCallback implements FutureCallback<Integer> {
+
+        private int[] expectedCounts;
+        private int currentIteration;
+
+        public MessageCountCallback(int[] expectedCounts) {
+            this.expectedCounts = expectedCounts;
+            this.currentIteration = 0;
+        }
+
+        @Override
+        public void onSuccess(Integer result) {
+
+            if (currentIteration < expectedCounts.length){
+                if (result != expectedCounts[currentIteration]){
+                    onFailure(new AssertionError("Wrong message count. Expected " + expectedCounts[currentIteration] + " but received " + result));
+                    currentIteration = expectedCounts.length;
+                    return;
+                }
+            }
+
+            currentIteration++;
+
+            if (currentIteration == expectedCounts.length)
+                semaphore.release();
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            thrown.add(t);
+            semaphore.release();
+        }
+    }
+
+    @Test
+    public void testSync() throws SignatureException, CommunicationException, InterruptedException {
+
+        Timestamp timestamp = Timestamp.newBuilder()
+                .setSeconds(15252162)
+                .setNanos(85914)
+                .build();
+
+        BulletinBoardMessage msg = messageGenerator.generateRandomMessage(signers, timestamp, 10, 10);
+
+        MessageID msgID = localClient.postMessage(msg);
+
+        timestamp = Timestamp.newBuilder()
+                .setSeconds(51511653)
+                .setNanos(3625)
+                .build();
+
+        BulletinBoardMessage batchMessage = messageGenerator.generateRandomMessage(signers,timestamp,  100, 10);
+
+        MessageID batchMsgID = localClient.postAsBatch(batchMessage, 10);
+
+        BulletinBoardMessage test = localClient.readMessage(batchMsgID);
+
+        BulletinBoardMessage stub = localClient.readMessages(MessageFilterList.newBuilder()
+                .addFilter(MessageFilter.newBuilder()
+                        .setType(FilterType.MSG_ID)
+                        .setId(batchMsgID.getID())
+                        .build())
+                .build()).get(0);
+
+        BulletinBoardMessage test2 = localClient.readBatchData(stub);
+
+        synchronizer.subscribeToSyncStatus(new SyncStatusCallback(SyncStatus.SYNCHRONIZED));
+
+        int[] expectedCounts = {2,0};
+        synchronizer.subscribeToRemainingMessagesCount(new MessageCountCallback(expectedCounts));
+
+        Thread syncThread = new Thread(synchronizer);
+        syncThread.start();
+
+        if (!semaphore.tryAcquire(2, 4000, TimeUnit.MILLISECONDS)) {
+            thrown.add(new TimeoutException("Timeout occurred while waiting for synchronizer to sync."));
+        }
+
+        synchronizer.stop();
+        syncThread.join();
+
+        if (thrown.size() > 0) {
+            for (Throwable t : thrown)
+                System.err.println(t.getMessage());
+            assertThat("Exception thrown by Synchronizer: " + thrown.get(0).getMessage(), false);
+        }
+
+        List<BulletinBoardMessage> msgList = remoteClient.readMessages(MessageFilterList.newBuilder()
+                .addFilter(MessageFilter.newBuilder()
+                        .setType(FilterType.MSG_ID)
+                        .setId(msgID.getID())
+                        .build())
+                .build());
+
+        assertThat("Wrong number of messages returned.", msgList.size() == 1);
+        assertThat("Returned message is not equal to original one", messageComparator.compare(msgList.get(0),msg) == 0);
+
+        BulletinBoardMessage returnedBatchMsg = remoteClient.readMessage(batchMsgID);
+
+        assertThat("Returned batch does not equal original one.", messageComparator.compare(returnedBatchMsg, batchMessage) == 0);
+
+    }
+
+    @Test
+    public void testServerError() throws SignatureException, CommunicationException, InterruptedException {
+
+        Timestamp timestamp = Timestamp.newBuilder()
+                .setSeconds(945736256)
+                .setNanos(276788)
+                .build();
+
+        BulletinBoardMessage msg = messageGenerator.generateRandomMessage(signers, timestamp, 10, 10);
+
+        remoteClient.close();
+
+        synchronizer.subscribeToSyncStatus(new SyncStatusCallback(SyncStatus.SERVER_ERROR));
+
+        localClient.postMessage(msg);
+
+        Thread thread = new Thread(synchronizer);
+
+        thread.start();
+
+        if (!semaphore.tryAcquire(4000, TimeUnit.MILLISECONDS)) {
+            thrown.add(new TimeoutException("Timeout occurred while waiting for synchronizer to sync."));
+        }
+
+        synchronizer.stop();
+        thread.join();
+
+    }
+
+    @After
+    public void close() {
+
+        if (thrown.size() > 0) {
+            for (Throwable t : thrown) {
+                System.err.println(t.getMessage());
+            }
+            assertThat("Exception thrown by Synchronizer: " + thrown.get(0).getMessage(), false);
+        }
+
+        synchronizer.stop();
+        localClient.close();
+        remoteClient.close();
+
+    }
+
+}

bulletin-board-client/src/test/java/meerkat/bulletinboard/CachedBulletinBoardClientTest.java

@@ -0,0 +1,111 @@
+package meerkat.bulletinboard;
+
+import meerkat.bulletinboard.sqlserver.BulletinBoardSQLServer;
+import meerkat.bulletinboard.sqlserver.H2QueryProvider;
+import meerkat.comm.CommunicationException;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.security.SignatureException;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Created by Arbel on 6/27/2016.
+ */
+public class CachedBulletinBoardClientTest {
+
+    private static final int THREAD_NUM = 3;
+
+    private static final String LOCAL_DB_NAME = "localDB";
+    private static final String REMOTE_DB_NAME = "remoteDB";
+    private static final String QUEUE_DB_NAME = "queueDB";
+
+    private static final int SUBSRCIPTION_DELAY = 500;
+    private static final int SYNC_DELAY = 500;
+
+    // Testers
+    private CachedBulletinBoardClient cachedClient;
+    private GenericBulletinBoardClientTester clientTest;
+    private GenericSubscriptionClientTester subscriptionTester;
+
+    public CachedBulletinBoardClientTest() throws CommunicationException {
+
+        DeletableBulletinBoardServer localServer = new BulletinBoardSQLServer(new H2QueryProvider(LOCAL_DB_NAME));
+        localServer.init();
+        LocalBulletinBoardClient localClient = new LocalBulletinBoardClient(localServer, THREAD_NUM, SUBSRCIPTION_DELAY);
+
+        DeletableBulletinBoardServer remoteServer = new BulletinBoardSQLServer(new H2QueryProvider(REMOTE_DB_NAME));
+        remoteServer.init();
+        LocalBulletinBoardClient remoteClient = new LocalBulletinBoardClient(remoteServer, THREAD_NUM, SUBSRCIPTION_DELAY);
+
+        DeletableBulletinBoardServer queueServer = new BulletinBoardSQLServer(new H2QueryProvider(QUEUE_DB_NAME));
+        queueServer.init();
+        LocalBulletinBoardClient queueClient = new LocalBulletinBoardClient(queueServer, THREAD_NUM, SUBSRCIPTION_DELAY);
+
+        List<SubscriptionBulletinBoardClient> clientList = new LinkedList<>();
+        clientList.add(remoteClient);
+
+        BulletinBoardSubscriber subscriber = new ThreadedBulletinBoardSubscriber(clientList, localClient);
+
+        cachedClient = new CachedBulletinBoardClient(localClient, remoteClient, subscriber, queueClient, SYNC_DELAY, SYNC_DELAY);
+        subscriptionTester = new GenericSubscriptionClientTester(cachedClient);
+        clientTest = new GenericBulletinBoardClientTester(cachedClient, 87351);
+
+    }
+
+    // Test methods
+
+    /**
+     * Takes care of initializing the client and the test resources
+     */
+    @Before
+    public void init(){
+
+        clientTest.init();
+
+    }
+
+    /**
+     * Closes the client and makes sure the test fails when an exception occurred in a separate thread
+     */
+
+    @After
+    public void close() {
+
+        cachedClient.close();
+        clientTest.close();
+
+    }
+
+    @Test
+    public void testPost() {
+
+        clientTest.testPost();
+
+    }
+
+    @Test
+    public void testBatchPost() throws CommunicationException, SignatureException, InterruptedException {
+
+        clientTest.testBatchPost();
+    }
+
+    @Test
+    public void testCompleteBatchPost() throws CommunicationException, SignatureException, InterruptedException {
+
+        clientTest.testCompleteBatchPost();
+
+    }
+
+    @Test
+    public void testSubscription() throws SignatureException, CommunicationException {
+
+//        subscriptionTester.init();
+//        subscriptionTester.subscriptionTest();
+//        subscriptionTester.close();
+
+    }
+
+}

bulletin-board-client/src/test/java/meerkat/bulletinboard/GenericBulletinBoardClientTester.java

@@ -5,10 +5,13 @@ import com.google.protobuf.ByteString;
 import com.google.protobuf.Timestamp;
 import meerkat.comm.CommunicationException;
 import meerkat.crypto.concrete.ECDSASignature;
+import meerkat.crypto.concrete.SHA256Digest;
 import meerkat.protobuf.BulletinBoardAPI.*;
 import meerkat.protobuf.Crypto;
 import meerkat.util.BulletinBoardMessageComparator;
 import meerkat.util.BulletinBoardMessageGenerator;
+import meerkat.util.BulletinBoardUtils;
+import meerkat.bulletinboard.AsyncBulletinBoardClient.BatchIdentifier;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -28,7 +31,7 @@ public class GenericBulletinBoardClientTester {
 
     // Signature resources
 
-    private GenericBatchDigitalSignature signers[];
+    private BulletinBoardSignature signers[];
     private ByteString[] signerIDs;
 
     private static String KEYFILE_EXAMPLE = "/certs/enduser-certs/user1-key-with-password-secret.p12";
@@ -45,28 +48,29 @@ public class GenericBulletinBoardClientTester {
     private AsyncBulletinBoardClient bulletinBoardClient;
 
     private PostCallback postCallback;
-    private PostCallback failPostCallback = new PostCallback(true,false);
 
     private RedundancyCallback redundancyCallback;
     private ReadCallback readCallback;
-    private ReadBatchCallback readBatchCallback;
 
     // Sync and misc
 
     private Semaphore jobSemaphore;
     private Vector<Throwable> thrown;
     private Random random;
+    private BulletinBoardMessageGenerator generator;
+
+    private BulletinBoardDigest digest;
 
     // Constructor
 
-    public GenericBulletinBoardClientTester(AsyncBulletinBoardClient bulletinBoardClient){
+    public GenericBulletinBoardClientTester(AsyncBulletinBoardClient bulletinBoardClient, int seed){
 
         this.bulletinBoardClient = bulletinBoardClient;
 
-        signers = new GenericBatchDigitalSignature[2];
+        signers = new GenericBulletinBoardSignature[2];
         signerIDs = new ByteString[signers.length];
-        signers[0] = new GenericBatchDigitalSignature(new ECDSASignature());
-        signers[1] = new GenericBatchDigitalSignature(new ECDSASignature());
+        signers[0] = new GenericBulletinBoardSignature(new ECDSASignature());
+        signers[1] = new GenericBulletinBoardSignature(new ECDSASignature());
 
         InputStream keyStream = getClass().getResourceAsStream(KEYFILE_EXAMPLE);
         char[] password = KEYFILE_PASSWORD1.toCharArray();
@@ -108,6 +112,10 @@ public class GenericBulletinBoardClientTester {
             fail("Couldn't find signing key " + e.getMessage());
         }
 
+        this.random = new Random(seed);
+        this.generator = new BulletinBoardMessageGenerator(random);
+        this.digest = new GenericBulletinBoardDigest(new SHA256Digest());
+
     }
 
     // Callback definitions
@@ -138,16 +146,21 @@ public class GenericBulletinBoardClientTester {
 
         @Override
         public void onSuccess(Boolean msg) {
+
             System.err.println("Post operation completed");
-            jobSemaphore.release();
-            //TODO: Change Assert mechanism to exception one
+
             if (isAssert) {
-                if (assertValue) {
-                    assertThat("Post operation failed", msg, is(Boolean.TRUE));
+                if (assertValue && !msg) {
+                    genericHandleFailure(new AssertionError("Post operation failed"));
+                } else if (!assertValue && msg){
+                    genericHandleFailure(new AssertionError("Post operation succeeded unexpectedly"));
                 } else {
-                    assertThat("Post operation succeeded unexpectedly", msg, is(Boolean.FALSE));
+                    jobSemaphore.release();
                 }
+            } else {
+                jobSemaphore.release();
             }
+
         }
 
         @Override
@@ -210,21 +223,24 @@ public class GenericBulletinBoardClientTester {
         }
     }
 
-    private class ReadBatchCallback implements FutureCallback<CompleteBatch> {
+    private class ReadBatchCallback implements FutureCallback<BulletinBoardMessage>{
 
-        private CompleteBatch expectedBatch;
+        private BulletinBoardMessage expectedMsg;
 
-        public ReadBatchCallback(CompleteBatch expectedBatch) {
-            this.expectedBatch = expectedBatch;
+        public ReadBatchCallback(BulletinBoardMessage expectedMsg) {
+            this.expectedMsg = expectedMsg;
         }
 
         @Override
-        public void onSuccess(CompleteBatch batch) {
+        public void onSuccess(BulletinBoardMessage msg) {
 
-            System.err.println(batch);
+            BulletinBoardMessageComparator msgComparator = new BulletinBoardMessageComparator();
+
+            if (msgComparator.compare(msg, expectedMsg) != 0) {
+                genericHandleFailure(new AssertionError("Batch read returned different message.\nExpected:" + expectedMsg + "\nRecieved:" + msg + "\n"));
+            } else {
                 jobSemaphore.release();
-
-            assertThat("Batch returned is incorrect", batch, is(equalTo(expectedBatch)));
+            }
 
         }
 
@@ -234,59 +250,6 @@ public class GenericBulletinBoardClientTester {
         }
     }
 
-    // Randomness generators
-
-    private byte randomByte(){
-        return (byte) random.nextInt();
-    }
-
-    private byte[] randomByteArray(int length) {
-
-        byte[] randomBytes = new byte[length];
-
-        for (int i = 0; i < length ; i++){
-            randomBytes[i] = randomByte();
-        }
-
-        return randomBytes;
-
-    }
-
-    private CompleteBatch createRandomBatch(int signer, int batchId, int length) throws SignatureException {
-
-        CompleteBatch completeBatch = new CompleteBatch();
-
-        // Create data
-
-        completeBatch.setBeginBatchMessage(BeginBatchMessage.newBuilder()
-                .setSignerId(signerIDs[signer])
-                .setBatchId(batchId)
-                .addTag("Test")
-                .build());
-
-        for (int i = 0 ; i < length ; i++){
-
-            BatchData batchData = BatchData.newBuilder()
-                    .setData(ByteString.copyFrom(randomByteArray(i)))
-                    .build();
-
-            completeBatch.appendBatchData(batchData);
-
-        }
-
-        completeBatch.setTimestamp(Timestamp.newBuilder()
-                .setSeconds(Math.abs(90))
-                .setNanos(50)
-                .build());
-
-        signers[signer].updateContent(completeBatch);
-
-        completeBatch.setSignature(signers[signer].sign());
-
-        return completeBatch;
-
-    }
-
     // Test methods
 
     /**
@@ -311,7 +274,13 @@ public class GenericBulletinBoardClientTester {
     public void close() {
 
         if (thrown.size() > 0) {
+
+            for (Throwable t : thrown){
+                System.err.println(t.getMessage());
+            }
+
             assert false;
+
         }
 
     }
@@ -319,7 +288,7 @@ public class GenericBulletinBoardClientTester {
     /**
      * Tests the standard post, redundancy and read methods
      */
-    public void postTest() {
+    public void testPost() {
 
         byte[] b1 = {(byte) 1, (byte) 2, (byte) 3, (byte) 4};
         byte[] b2 = {(byte) 11, (byte) 12, (byte) 13, (byte) 14};
@@ -395,59 +364,69 @@ public class GenericBulletinBoardClientTester {
 
     /**
      * Tests posting a batch by parts
-     * Also tests not being able to post to a closed batch
      * @throws CommunicationException, SignatureException, InterruptedException
      */
     public void testBatchPost() throws CommunicationException, SignatureException, InterruptedException {
 
-        final int SIGNER = 1;
-        final int BATCH_ID = 100;
         final int BATCH_LENGTH = 100;
+        final int CHUNK_SIZE = 10;
+        final int TAG_NUM = 10;
 
-        CompleteBatch completeBatch = createRandomBatch(SIGNER, BATCH_ID, BATCH_LENGTH);
+        final Timestamp timestamp = Timestamp.newBuilder()
+                .setSeconds(141515)
+                .setNanos(859018)
+                .build();
+
+        final BulletinBoardMessage msg = generator.generateRandomMessage(signers, timestamp, BATCH_LENGTH, TAG_NUM);
 
         // Begin batch
 
-        bulletinBoardClient.beginBatch(completeBatch.getBeginBatchMessage(), postCallback);
+        bulletinBoardClient.beginBatch(msg.getMsg().getTagList(), new FutureCallback<BatchIdentifier>() {
+
+            @Override
+            public void onSuccess(final BatchIdentifier identifier) {
+
+                bulletinBoardClient.postBatchData(identifier, BulletinBoardUtils.breakToBatch(msg, CHUNK_SIZE), new FutureCallback<Boolean>() {
+
+                    @Override
+                    public void onSuccess(Boolean result) {
+
+                        bulletinBoardClient.closeBatch(identifier, msg.getMsg().getTimestamp(), msg.getSigList(), new FutureCallback<Boolean>() {
+                            @Override
+                            public void onSuccess(Boolean result) {
+                                jobSemaphore.release();
+                            }
+
+                            @Override
+                            public void onFailure(Throwable t) {
+                                genericHandleFailure(t);
+                            }
+                        });
+
+                    }
+
+                    @Override
+                    public void onFailure(Throwable t) {
+                        genericHandleFailure(t);
+                    }
+
+                });
+
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                genericHandleFailure(t);
+            }
+
+        });
 
         jobSemaphore.acquire();
 
-        // Post data
+        digest.reset();
+        digest.update(msg);
 
-        bulletinBoardClient.postBatchData(signerIDs[SIGNER], BATCH_ID, completeBatch.getBatchDataList(), postCallback);
-
-        jobSemaphore.acquire();
-
-        // Close batch
-
-        CloseBatchMessage closeBatchMessage = completeBatch.getCloseBatchMessage();
-
-        bulletinBoardClient.closeBatch(closeBatchMessage, postCallback);
-
-        jobSemaphore.acquire();
-
-        // Attempt to open batch again
-
-        bulletinBoardClient.beginBatch(completeBatch.getBeginBatchMessage(), failPostCallback);
-
-        // Attempt to add batch data
-
-        bulletinBoardClient.postBatchData(signerIDs[SIGNER], BATCH_ID, completeBatch.getBatchDataList(), failPostCallback);
-
-        jobSemaphore.acquire(2);
-
-        // Read batch data
-
-        BatchSpecificationMessage batchSpecificationMessage =
-                BatchSpecificationMessage.newBuilder()
-                        .setSignerId(signerIDs[SIGNER])
-                        .setBatchId(BATCH_ID)
-                        .setStartPosition(0)
-                        .build();
-
-        readBatchCallback = new ReadBatchCallback(completeBatch);
-
-        bulletinBoardClient.readBatch(batchSpecificationMessage, readBatchCallback);
+        bulletinBoardClient.readMessage(digest.digestAsMessageID(), new ReadBatchCallback(msg));
 
         jobSemaphore.acquire();
 
@@ -455,62 +434,61 @@ public class GenericBulletinBoardClientTester {
 
     /**
      * Posts a complete batch message
-     * Checks reading of the message
+     * Checks reading of the message in two parts
      * @throws CommunicationException, SignatureException, InterruptedException
      */
     public void testCompleteBatchPost() throws CommunicationException, SignatureException, InterruptedException {
 
-        final int SIGNER = 0;
-        final int BATCH_ID = 101;
-        final int BATCH_LENGTH = 50;
+        final int BATCH_LENGTH = 100;
+        final int CHUNK_SIZE = 99;
+        final int TAG_NUM = 8;
+
+        final Timestamp timestamp = Timestamp.newBuilder()
+                .setSeconds(7776151)
+                .setNanos(252616)
+                .build();
+
+        final BulletinBoardMessage msg = generator.generateRandomMessage(signers, timestamp, BATCH_LENGTH, TAG_NUM);
 
         // Post batch
 
-        CompleteBatch completeBatch = createRandomBatch(SIGNER, BATCH_ID, BATCH_LENGTH);
-
-        bulletinBoardClient.postBatch(completeBatch,postCallback);
+        MessageID msgID = bulletinBoardClient.postAsBatch(msg, CHUNK_SIZE, postCallback);
 
         jobSemaphore.acquire();
 
         // Read batch
 
-        BatchSpecificationMessage batchSpecificationMessage =
-                BatchSpecificationMessage.newBuilder()
-                        .setSignerId(signerIDs[SIGNER])
-                        .setBatchId(BATCH_ID)
-                        .setStartPosition(0)
-                        .build();
-
-        readBatchCallback = new ReadBatchCallback(completeBatch);
-
-        bulletinBoardClient.readBatch(batchSpecificationMessage, readBatchCallback);
-
-        jobSemaphore.acquire();
-
-    }
-
-    /**
-     * Tests that an unopened batch cannot be closed
-     * @throws CommunicationException, InterruptedException
-     */
-    public void testInvalidBatchClose() throws CommunicationException, InterruptedException {
-
-        final int NON_EXISTENT_BATCH_ID = 999;
-
-        CloseBatchMessage closeBatchMessage =
-                CloseBatchMessage.newBuilder()
-                        .setBatchId(NON_EXISTENT_BATCH_ID)
-                        .setBatchLength(1)
-                        .setSig(Crypto.Signature.getDefaultInstance())
-                        .setTimestamp(Timestamp.newBuilder()
-                                .setSeconds(9)
-                                .setNanos(12)
+        MessageFilterList filterList = MessageFilterList.newBuilder()
+                .addFilter(MessageFilter.newBuilder()
+                        .setType(FilterType.MSG_ID)
+                        .setId(msgID.getID())
                         .build())
                 .build();
 
-        // Try to stop the (unopened) batch;
+        bulletinBoardClient.readMessages(filterList, new FutureCallback<List<BulletinBoardMessage>>() {
 
-        bulletinBoardClient.closeBatch(closeBatchMessage, failPostCallback);
+            @Override
+            public void onSuccess(List<BulletinBoardMessage> msgList) {
+
+                if (msgList.size() != 1) {
+
+                    genericHandleFailure(new AssertionError("Wrong number of stubs returned. Expected: 1; Found: " + msgList.size()));
+
+                } else {
+
+                    BulletinBoardMessage retrievedMsg = msgList.get(0);
+                    bulletinBoardClient.readBatchData(retrievedMsg, new ReadBatchCallback(msg));
+
+                }
+
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                genericHandleFailure(t);
+            }
+
+        });
 
         jobSemaphore.acquire();
 

bulletin-board-client/src/test/java/meerkat/bulletinboard/GenericSubscriptionClientTester.java

@@ -16,9 +16,6 @@ import java.security.cert.CertificateException;
 import java.util.*;
 import java.util.concurrent.Semaphore;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.junit.Assert.assertThat;
 import static org.junit.Assert.fail;
 
 /**
@@ -26,7 +23,7 @@ import static org.junit.Assert.fail;
  */
 public class GenericSubscriptionClientTester {
 
-    private GenericBatchDigitalSignature signers[];
+    private BulletinBoardSignature signers[];
     private ByteString[] signerIDs;
 
     private static String KEYFILE_EXAMPLE = "/certs/enduser-certs/user1-key-with-password-secret.p12";
@@ -38,7 +35,7 @@ public class GenericSubscriptionClientTester {
     private static String CERT1_PEM_EXAMPLE = "/certs/enduser-certs/user1.crt";
     private static String CERT3_PEM_EXAMPLE = "/certs/enduser-certs/user3.crt";
 
-    private SubscriptionAsyncBulletinBoardClient bulletinBoardClient;
+    private SubscriptionBulletinBoardClient bulletinBoardClient;
 
     private Random random;
     private BulletinBoardMessageGenerator generator;
@@ -46,14 +43,14 @@ public class GenericSubscriptionClientTester {
     private Semaphore jobSemaphore;
     private Vector<Throwable> thrown;
 
-    public GenericSubscriptionClientTester(SubscriptionAsyncBulletinBoardClient bulletinBoardClient){
+    public GenericSubscriptionClientTester(SubscriptionBulletinBoardClient bulletinBoardClient){
 
         this.bulletinBoardClient = bulletinBoardClient;
 
-        signers = new GenericBatchDigitalSignature[2];
+        signers = new BulletinBoardSignature[2];
         signerIDs = new ByteString[signers.length];
-        signers[0] = new GenericBatchDigitalSignature(new ECDSASignature());
-        signers[1] = new GenericBatchDigitalSignature(new ECDSASignature());
+        signers[0] = new GenericBulletinBoardSignature(new ECDSASignature());
+        signers[1] = new GenericBulletinBoardSignature(new ECDSASignature());
 
         InputStream keyStream = getClass().getResourceAsStream(KEYFILE_EXAMPLE);
         char[] password = KEYFILE_PASSWORD1.toCharArray();
@@ -181,15 +178,13 @@ public class GenericSubscriptionClientTester {
         public void onFailure(Throwable t) {
             System.err.println(t.getCause() + " " + t.getMessage());
             thrown.add(t);
-            jobSemaphore.release(expectedMessages.size());
+            jobSemaphore.release();
             stage = expectedMessages.size();
         }
     }
 
     public void subscriptionTest() throws SignatureException, CommunicationException {
 
-        final int FIRST_POST_ID = 201;
-        final int SECOND_POST_ID = 202;
         final String COMMON_TAG = "SUBSCRIPTION_TEST";
         
         List<String> tags = new LinkedList<>();
@@ -207,9 +202,9 @@ public class GenericSubscriptionClientTester {
                 .build();
 
         List<List<BulletinBoardMessage>> expectedMessages = new ArrayList<>(3);
-        expectedMessages.add(new LinkedList<BulletinBoardMessage>());
-        expectedMessages.add(new LinkedList<BulletinBoardMessage>());
-        expectedMessages.add(new LinkedList<BulletinBoardMessage>());
+        expectedMessages.add(new LinkedList<>());
+        expectedMessages.add(new LinkedList<>());
+        expectedMessages.add(new LinkedList<>());
         expectedMessages.get(0).add(msg1);
         expectedMessages.get(2).add(msg3);
 

bulletin-board-client/src/test/java/meerkat/bulletinboard/LocalBulletinBoardClientTest.java

@@ -7,12 +7,6 @@ import org.junit.Before;
 import org.junit.Test;
 
 import java.security.SignatureException;
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.List;
-
-import static org.junit.Assert.fail;
 
 /**
  * Created by Arbel Deutsch Peled on 05-Dec-15.
@@ -30,30 +24,14 @@ public class LocalBulletinBoardClientTest {
 
     public LocalBulletinBoardClientTest() throws CommunicationException {
 
-        H2QueryProvider queryProvider = new H2QueryProvider(DB_NAME) ;
+        H2QueryProvider queryProvider = new H2QueryProvider(DB_NAME);
 
-        try {
-
-            Connection conn = queryProvider.getDataSource().getConnection();
-            Statement stmt = conn.createStatement();
-
-            List<String> deletionQueries = queryProvider.getSchemaDeletionCommands();
-
-            for (String deletionQuery : deletionQueries) {
-                stmt.execute(deletionQuery);
-            }
-
-        } catch (SQLException e) {
-            System.err.println(e.getMessage());
-            throw new CommunicationException(e.getCause() + " " + e.getMessage());
-        }
-
-        BulletinBoardServer server = new BulletinBoardSQLServer(queryProvider);
-        server.init(DB_NAME);
+        DeletableBulletinBoardServer server = new BulletinBoardSQLServer(queryProvider);
+        server.init();
 
         LocalBulletinBoardClient client = new LocalBulletinBoardClient(server, THREAD_NUM, SUBSRCIPTION_DELAY);
         subscriptionTester = new GenericSubscriptionClientTester(client);
-        clientTest = new GenericBulletinBoardClientTester(client);
+        clientTest = new GenericBulletinBoardClientTester(client, 98354);
 
     }
 
@@ -81,9 +59,9 @@ public class LocalBulletinBoardClientTest {
     }
 
     @Test
-    public void postTest() {
+    public void testPost() {
 
-        clientTest.postTest();
+        clientTest.testPost();
 
     }
 
@@ -100,15 +78,9 @@ public class LocalBulletinBoardClientTest {
 
     }
 
-    @Test
-    public void testInvalidBatchClose() throws CommunicationException, InterruptedException {
-
-        clientTest.testInvalidBatchClose();
-
-    }
-
     @Test
     public void testSubscription() throws SignatureException, CommunicationException {
+
         subscriptionTester.init();
         subscriptionTester.subscriptionTest();
         subscriptionTester.close();

bulletin-board-client/src/test/java/meerkat/bulletinboard/SingleServerBulletinBoardClientIntegrationTest.java

@@ -0,0 +1,104 @@
+package meerkat.bulletinboard;
+
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import meerkat.comm.CommunicationException;
+import meerkat.protobuf.Voting.BulletinBoardClientParams;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.security.SignatureException;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.Executors;
+
+/**
+ * Created by Arbel Deutsch Peled on 05-Dec-15.
+ */
+public class SingleServerBulletinBoardClientIntegrationTest {
+
+    // Server data
+
+    private static final String PROP_GETTY_URL = "gretty.httpBaseURI";
+    private static final String DEFAULT_BASE_URL = "http://localhost:8081";
+    private static final String BASE_URL =  System.getProperty(PROP_GETTY_URL, DEFAULT_BASE_URL);
+
+    private static final int THREAD_NUM = 3;
+    private static final long FAIL_DELAY = 3000;
+    private static final long SUBSCRIPTION_INTERVAL = 500;
+
+    // Testers
+    private GenericBulletinBoardClientTester clientTest;
+    private GenericSubscriptionClientTester subscriptionTester;
+
+    public SingleServerBulletinBoardClientIntegrationTest(){
+
+        SingleServerBulletinBoardClient client = new SingleServerBulletinBoardClient(THREAD_NUM, FAIL_DELAY, SUBSCRIPTION_INTERVAL);
+
+        List<String> testDB = new LinkedList<>();
+        testDB.add(BASE_URL);
+
+        client.init(BulletinBoardClientParams.newBuilder()
+                .addAllBulletinBoardAddress(testDB)
+                .setMinRedundancy((float) 1.0)
+                .build());
+
+        clientTest = new GenericBulletinBoardClientTester(client, 981541);
+        subscriptionTester = new GenericSubscriptionClientTester(client);
+
+    }
+
+    // Test methods
+
+    /**
+     * Takes care of initializing the client and the test resources
+     */
+    @Before
+    public void init(){
+
+        clientTest.init();
+
+    }
+
+    /**
+     * Closes the client and makes sure the test fails when an exception occurred in a separate thread
+     */
+
+    @After
+    public void close() {
+
+        clientTest.close();
+
+    }
+
+    @Test
+    public void testPost() {
+
+        clientTest.testPost();
+
+    }
+
+    @Test
+    public void testBatchPost() throws CommunicationException, SignatureException, InterruptedException {
+
+        clientTest.testBatchPost();
+    }
+
+    @Test
+    public void testCompleteBatchPost() throws CommunicationException, SignatureException, InterruptedException {
+
+        clientTest.testCompleteBatchPost();
+
+    }
+
+    @Test
+    public void testSubscription() throws SignatureException, CommunicationException {
+
+        subscriptionTester.init();
+        subscriptionTester.subscriptionTest();
+        subscriptionTester.close();
+
+    }
+
+}

bulletin-board-client/src/test/java/meerkat/bulletinboard/ThreadedBulletinBoardClientIntegrationTest.java

@@ -28,7 +28,7 @@ public class ThreadedBulletinBoardClientIntegrationTest {
 
     public ThreadedBulletinBoardClientIntegrationTest(){
 
-        ThreadedBulletinBoardClient client = new ThreadedBulletinBoardClient();
+        ThreadedBulletinBoardClient client = new ThreadedBulletinBoardClient(3,0,500);
 
         List<String> testDB = new LinkedList<>();
         testDB.add(BASE_URL);
@@ -38,7 +38,7 @@ public class ThreadedBulletinBoardClientIntegrationTest {
                 .setMinRedundancy((float) 1.0)
                 .build());
 
-        clientTest = new GenericBulletinBoardClientTester(client);
+        clientTest = new GenericBulletinBoardClientTester(client, 52351);
 
     }
 
@@ -66,9 +66,9 @@ public class ThreadedBulletinBoardClientIntegrationTest {
     }
 
     @Test
-    public void postTest() {
+    public void testPost() {
 
-        clientTest.postTest();
+        clientTest.testPost();
 
     }
 
@@ -76,6 +76,7 @@ public class ThreadedBulletinBoardClientIntegrationTest {
     public void testBatchPost() throws CommunicationException, SignatureException, InterruptedException {
 
         clientTest.testBatchPost();
+
     }
 
     @Test
@@ -85,11 +86,4 @@ public class ThreadedBulletinBoardClientIntegrationTest {
 
     }
 
-    @Test
-    public void testInvalidBatchClose() throws CommunicationException, InterruptedException {
-
-        clientTest.testInvalidBatchClose();
-
-    }
-
 }

bulletin-board-server/build.gradle

@@ -259,4 +259,3 @@ publishing {
     }
 }
 
-

bulletin-board-server/src/main/java/meerkat/bulletinboard/sqlserver/BulletinBoardSQLServer.java

@@ -1,5 +1,7 @@
 package meerkat.bulletinboard.sqlserver;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.sql.*;
 import java.util.*;
 
@@ -8,16 +10,16 @@ import com.google.protobuf.*;
 import com.google.protobuf.Timestamp;
 import meerkat.bulletinboard.*;
 import meerkat.bulletinboard.sqlserver.mappers.*;
-import static meerkat.bulletinboard.BulletinBoardConstants.*;
 
 import meerkat.comm.CommunicationException;
 
+import meerkat.comm.MessageInputStream;
 import meerkat.comm.MessageOutputStream;
-import meerkat.crypto.concrete.ECDSASignature;
+import meerkat.crypto.DigitalSignature;
 import meerkat.crypto.concrete.SHA256Digest;
 
 import meerkat.protobuf.BulletinBoardAPI.*;
-import meerkat.protobuf.Comm.*;
+import meerkat.protobuf.Comm;
 import meerkat.protobuf.Crypto.Signature;
 import meerkat.protobuf.Crypto.SignatureVerificationKey;
 
@@ -38,7 +40,7 @@ import org.springframework.jdbc.support.KeyHolder;
 /**
  * This is a generic SQL implementation of the BulletinBoardServer API.
  */
-public class BulletinBoardSQLServer implements BulletinBoardServer{
+public class BulletinBoardSQLServer implements DeletableBulletinBoardServer{
 
 	/**
 	 * This interface provides the required implementation-specific data to enable an access to an actual SQL server.
@@ -67,6 +69,16 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 					new int[] {Types.BLOB, Types.TIMESTAMP, Types.BLOB}
 			),
 
+			DELETE_MSG_BY_ENTRY(
+					new String[] {"EntryNum"},
+					new int[] {Types.INTEGER}
+			),
+
+			DELETE_MSG_BY_ID(
+					new String[] {"MsgId"},
+					new int[] {Types.BLOB}
+			),
+
 			INSERT_NEW_TAG(
 					new String[] {"Tag"},
 					new int[] {Types.VARCHAR}
@@ -107,39 +119,44 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 					new int[] {}
 			),
 
-			GET_BATCH_MESSAGE_ENTRY(
-					new String[] {"SignerId", "BatchId"},
-					new int[] {Types.BLOB, Types.INTEGER}
-			),
-
 			CHECK_BATCH_LENGTH(
-					new String[] {"SignerId", "BatchId"},
+					new String[] {"BatchId"},
 					new int[] {Types.BLOB, Types.INTEGER}
 			),
 
-			GET_BATCH_MESSAGE_DATA(
-					new String[] {"SignerId", "BatchId", "StartPosition"},
-					new int[] {Types.BLOB, Types.INTEGER, Types.INTEGER}
+			CHECK_BATCH_OPEN(
+					new String[] {"BatchId"},
+					new int[] {Types.BLOB, Types.INTEGER}
+			),
+
+			GET_BATCH_MESSAGE_DATA_BY_MSG_ID(
+					new String[] {"MsgId", "StartPosition"},
+					new int[] {Types.BLOB, Types.INTEGER}
+			),
+
+			GET_BATCH_MESSAGE_DATA_BY_BATCH_ID(
+					new String[] {"BatchId", "StartPosition"},
+					new int[] {Types.INTEGER, Types.INTEGER}
 			),
 
 			INSERT_BATCH_DATA(
-					new String[] {"SignerId", "BatchId", "SerialNum", "Data"},
-					new int[] {Types.BLOB, Types.INTEGER, Types.INTEGER, Types.BLOB}
+					new String[] {"BatchId", "SerialNum", "Data"},
+					new int[] {Types.INTEGER, Types.INTEGER, Types.BLOB}
 			),
 
-			CONNECT_BATCH_TAG(
-					new String[] {"SignerId", "BatchId", "Tag"},
-					new int[] {Types.BLOB, Types.INTEGER, Types.VARCHAR}
+			STORE_BATCH_TAGS(
+					new String[] {"Tags"},
+					new int[] {Types.BLOB}
 			),
 
 			GET_BATCH_TAGS(
-					new String[] {"SignerId", "BatchId"},
+					new String[] {"BatchId"},
 					new int[] {Types.BLOB, Types.INTEGER}
 			),
 
-			REMOVE_BATCH_TAGS(
-					new String[] {"SignerId", "BatchId"},
-					new int[] {Types.BLOB, Types.INTEGER}
+			ADD_ENTRY_NUM_TO_BATCH(
+					new String[] {"BatchId", "EntryNum"},
+					new int[] {Types.BLOB, Types.INTEGER, Types.INTEGER}
 			);
 
 			private String[] paramNames;
@@ -317,8 +334,8 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 
 	protected NamedParameterJdbcTemplate jdbcTemplate;
 	
-	protected BatchDigest digest;
-	protected BatchDigitalSignature signer;
+	protected BulletinBoardDigest digest;
+	protected DigitalSignature signer;
 	
 	protected List<SignatureVerificationKey> trusteeSignatureVerificationArray;
 	protected int minTrusteeSignatures;
@@ -351,11 +368,10 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 	 * This method initializes the signatures, connects to the DB and creates the schema (if required).
 	 */
 	@Override
-	public void init(String meerkatDB) throws CommunicationException {
+	public void init() throws CommunicationException {
 		// TODO write signature reading part.
 		
-		digest = new GenericBatchDigest(new SHA256Digest());
-		signer = new GenericBatchDigitalSignature(new ECDSASignature());
+		digest = new GenericBulletinBoardDigest(new SHA256Digest());
 
 		jdbcTemplate = new NamedParameterJdbcTemplate(sqlQueryProvider.getDataSource());
 
@@ -415,14 +431,17 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 	/**
 	 * This method posts a messages to the server
 	 * @param msg is the message to post
-	 * @param checkSignature decides whether ot not the method should check the signature before it posts the message
-	 * @return TRUE if the post is successful and FALSE otherwise
+	 * @param precalculatedMsgID is an optional precalculated message ID
+	 *              It is used when the message is the stub of a batch message
+	 *              In this case the validity of the signature is not checked either
+	 * @return -1 if the message is not verified
+	 * 			The entry number of the message if the message is posted
 	 * @throws CommunicationException
      */
-	public BoolValue postMessage(BulletinBoardMessage msg, boolean checkSignature) throws CommunicationException{
+	private long postMessage(BulletinBoardMessage msg, byte[] precalculatedMsgID) throws CommunicationException{
 
-		if (checkSignature && !verifyMessage(msg)) {
-			return boolToBoolValue(false);
+		if (precalculatedMsgID != null && !verifyMessage(msg)) {
+			return -1;
 		}
 
 		String sql;
@@ -437,12 +456,16 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 		List<Signature> signatureList;
 		Signature[] signatures;
 
-		// Calculate message ID (depending only on the the unsigned message)
 
+		if (precalculatedMsgID != null){
+			msgID = precalculatedMsgID;
+		} else{
+			// Calculate message ID (depending only on the the unsigned message)
 			digest.reset();
 			digest.update(msg.getMsg());
 
 			msgID = digest.digest();
+		}
 
 		// Add message to table if needed and store entry number of message.
 
@@ -520,13 +543,64 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 
 		jdbcTemplate.batchUpdate(sql,namedParameterArray);
 
-		return boolToBoolValue(true);
+		return entryNum;
 
 	}
 
+	private void checkConnection() throws CommunicationException {
+		if (jdbcTemplate == null) {
+			throw new CommunicationException("DB connection not initialized");
+		}
+	}
+
 	@Override
 	public BoolValue postMessage(BulletinBoardMessage msg) throws CommunicationException {
-		return postMessage(msg, true);	// Perform a post and check the signature for authenticity
+
+		checkConnection();
+
+		// Perform a post, calculate the message ID and check the signature for authenticity
+		if (postMessage(msg, null) != -1){
+			return BoolValue.newBuilder().setValue(true).build();	// Message was posted
+		}
+
+		return BoolValue.newBuilder().setValue(false).build();	// Message was not posted
+
+	}
+
+	@Override
+	public BoolValue deleteMessage(MessageID msgID) throws CommunicationException {
+
+		checkConnection();
+
+		String sql = sqlQueryProvider.getSQLString(QueryType.DELETE_MSG_BY_ID);
+		Map namedParameters = new HashMap();
+
+		namedParameters.put(QueryType.DELETE_MSG_BY_ID.getParamName(0),msgID);
+
+		int affectedRows = jdbcTemplate.update(sql, namedParameters);
+
+		//TODO: Log
+
+		return BoolValue.newBuilder().setValue(affectedRows > 0).build();
+
+	}
+
+	@Override
+	public BoolValue deleteMessage(long entryNum) throws CommunicationException {
+
+		checkConnection();
+
+		String sql = sqlQueryProvider.getSQLString(QueryType.DELETE_MSG_BY_ENTRY);
+		Map namedParameters = new HashMap();
+
+		namedParameters.put(QueryType.DELETE_MSG_BY_ENTRY.getParamName(0),entryNum);
+
+		int affectedRows = jdbcTemplate.update(sql, namedParameters);
+
+		//TODO: Log
+
+		return BoolValue.newBuilder().setValue(affectedRows > 0).build();
+
 	}
 
 
@@ -611,10 +685,38 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 
 	}
 
+	/**
+	 * Private implementation of the message reader for returning result as a list
+	 * @param filterList is a filter list that defines which messages the client is interested in
+	 * @return the requested list of messages
+	 */
+	private List<BulletinBoardMessage> readMessages(MessageFilterList filterList) throws CommunicationException {
+
+		try {
+
+			ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+
+			readMessages(filterList, new MessageOutputStream<BulletinBoardMessage>(outputStream));
+
+			MessageInputStream<BulletinBoardMessage> inputStream =
+					MessageInputStream.MessageInputStreamFactory.createMessageInputStream(new ByteArrayInputStream(
+									outputStream.toByteArray()),
+							BulletinBoardMessage.class);
+
+			return inputStream.asList();
+
+		} catch (Exception e) {
+			throw new CommunicationException(e.getCause() + " " + e.getMessage());
+		}
+
+	}
+
 
 	@Override
 	public void readMessages(MessageFilterList filterList, MessageOutputStream<BulletinBoardMessage> out) throws CommunicationException {
 
+		checkConnection();
+
 		BulletinBoardMessageList.Builder resultListBuilder = BulletinBoardMessageList.newBuilder();
 
 		// SQL length is roughly 50 characters per filter + 50 for the query itself
@@ -635,39 +737,12 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 
 	}
 
+	@Override
+	public Int32Value getMessageCount(MessageFilterList filterList) throws CommunicationException {
 
-	/**
-	 * This method returns a string representation of the tag associated with a batch ID
-	 * @param batchId is the given batch ID
-	 * @return the String representation of the tag
-     */
-	private String batchIdToTag(int batchId) {
-		return BATCH_ID_TAG_PREFIX + Integer.toString(batchId);
-	}
+		checkConnection();
 
-
-	/**
-	 * This method checks if a specified batch exists and is already closed
-	 * @param signerId is the ID of the publisher of the batch
-	 * @param batchId is the unique (per signer) batch ID
-     * @return TRUE if the batch is closed and FALSE if it is still open or doesn't exist at all
-     */
-	private boolean isBatchClosed(ByteString signerId, int batchId) throws CommunicationException {
-
-		MessageFilterList filterList = MessageFilterList.newBuilder()
-				.addFilter(MessageFilter.newBuilder()
-						.setType(FilterType.SIGNER_ID)
-						.setId(signerId)
-						.build())
-				.addFilter(MessageFilter.newBuilder()
-						.setType(FilterType.TAG)
-						.setTag(BATCH_TAG)
-						.build())
-				.addFilter(MessageFilter.newBuilder()
-						.setType(FilterType.TAG)
-						.setTag(batchIdToTag(batchId))
-						.build())
-				.build();
+		BulletinBoardMessageList.Builder resultListBuilder = BulletinBoardMessageList.newBuilder();
 
 		// SQL length is roughly 50 characters per filter + 50 for the query itself
 		StringBuilder sqlBuilder = new StringBuilder(50 * (filterList.getFilterCount() + 1));
@@ -684,44 +759,73 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 		// Run query and stream the output using a MessageCallbackHandler
 
 		List<Long> count = jdbcTemplate.query(sqlBuilder.toString(), sqlAndParameters.parameters, new LongMapper());
-
-		return (count.size() > 0) && (count.get(0) > 0);
+		return Int32Value.newBuilder().setValue(count.get(0).intValue()).build();
 
 	}
 
 
+	/**
+	 * This method checks if a specified batch exists and is already closed
+	 * @param msgID is the unique ID of the batch message
+     * @return TRUE if the batch is closed and FALSE if it is still open or doesn't exist at all
+     */
+	private boolean isBatchClosed(MessageID msgID) throws CommunicationException {
+
+		MessageFilterList filterList = MessageFilterList.newBuilder()
+				.addFilter(MessageFilter.newBuilder()
+						.setType(FilterType.MSG_ID)
+						.setId(msgID.getID())
+						.build())
+				.build();
+
+
+		List<BulletinBoardMessage> messages = readMessages(filterList);
+
+		if (messages.size() <= 0){
+			return false;
+		}
+
+		return (messages.get(0).getMsg().getDataTypeCase() == UnsignedBulletinBoardMessage.DataTypeCase.MSGID);
+
+	}
+
+	/**
+	 * This method checks if a specified batch exists and is still open
+	 * @param batchId is the temporary batch ID
+	 * @return TRUE if the batch is closed and FALSE if it is still open or doesn't exist at all
+	 */
+	private boolean isBatchOpen(long batchId) throws CommunicationException {
+
+		String sql = sqlQueryProvider.getSQLString(QueryType.CHECK_BATCH_OPEN);
+		MapSqlParameterSource namedParameters = new MapSqlParameterSource();
+
+		namedParameters.addValue(QueryType.CHECK_BATCH_OPEN.getParamName(0),batchId);
+
+		List<Long> result = jdbcTemplate.query(sql, namedParameters, new LongMapper());
+
+		return (result.size() > 0 && result.get(0) > 0);
+
+	}
+
 	@Override
-	public BoolValue beginBatch(BeginBatchMessage message) throws CommunicationException {
+	public Int64Value beginBatch(BeginBatchMessage message) throws CommunicationException {
 
-		// Check if batch is closed
-		if (isBatchClosed(message.getSignerId(), message.getBatchId())) {
-			return BoolValue.newBuilder().setValue(false).build();
-		}
+		checkConnection();
 
-		// Add new tags to table
-		ProtocolStringList tagList = message.getTagList();
-		String[] tags = new String[tagList.size()];
-		tags = tagList.toArray(tags);
-		try {
-			insertNewTags(tags);
-		} catch (SQLException e) {
-			throw new CommunicationException(e.getMessage());
-		}
+		// Store tags
+		String sql = sqlQueryProvider.getSQLString(QueryType.STORE_BATCH_TAGS);
+		MapSqlParameterSource namedParameters = new MapSqlParameterSource();
 
-		// Connect tags
-		String sql = sqlQueryProvider.getSQLString(QueryType.CONNECT_BATCH_TAG);
-		MapSqlParameterSource namedParameters[] = new MapSqlParameterSource[tags.length];
+		namedParameters.addValue(QueryType.STORE_BATCH_TAGS.getParamName(0),message.toByteArray());
 
-		for (int i=0 ; i < tags.length ; i++) {
-			namedParameters[i] = new MapSqlParameterSource();
-			namedParameters[i].addValue(QueryType.CONNECT_BATCH_TAG.getParamName(0),message.getSignerId().toByteArray());
-			namedParameters[i].addValue(QueryType.CONNECT_BATCH_TAG.getParamName(1),message.getBatchId());
-			namedParameters[i].addValue(QueryType.CONNECT_BATCH_TAG.getParamName(2),tags[i]);
-		}
+		jdbcTemplate.update(sql,namedParameters);
 
-		jdbcTemplate.batchUpdate(sql,namedParameters);
+		KeyHolder keyHolder = new GeneratedKeyHolder();
+		jdbcTemplate.update(sql, namedParameters, keyHolder);
 
-		return BoolValue.newBuilder().setValue(true).build();
+		long entryNum = keyHolder.getKey().longValue();
+
+		return Int64Value.newBuilder().setValue(entryNum).build();
 
 	}
 
@@ -729,8 +833,10 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 	@Override
 	public BoolValue postBatchMessage(BatchMessage batchMessage) throws CommunicationException{
 
-		// Check if batch is closed
-		if (isBatchClosed(batchMessage.getSignerId(), batchMessage.getBatchId())) {
+		checkConnection();
+
+		// Make sure batch is open
+		if (!isBatchOpen(batchMessage.getBatchId())) {
 			return BoolValue.newBuilder().setValue(false).build();
 		}
 
@@ -738,10 +844,9 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 		String sql = sqlQueryProvider.getSQLString(QueryType.INSERT_BATCH_DATA);
 		MapSqlParameterSource namedParameters = new MapSqlParameterSource();
 
-		namedParameters.addValue(QueryType.INSERT_BATCH_DATA.getParamName(0),batchMessage.getSignerId().toByteArray());
-		namedParameters.addValue(QueryType.INSERT_BATCH_DATA.getParamName(1),batchMessage.getBatchId());
-		namedParameters.addValue(QueryType.INSERT_BATCH_DATA.getParamName(2),batchMessage.getSerialNum());
-		namedParameters.addValue(QueryType.INSERT_BATCH_DATA.getParamName(3),batchMessage.getData().toByteArray());
+		namedParameters.addValue(QueryType.INSERT_BATCH_DATA.getParamName(0),batchMessage.getBatchId());
+		namedParameters.addValue(QueryType.INSERT_BATCH_DATA.getParamName(1),batchMessage.getSerialNum());
+		namedParameters.addValue(QueryType.INSERT_BATCH_DATA.getParamName(2),batchMessage.getData().toByteArray());
 
 		jdbcTemplate.update(sql, namedParameters);
 
@@ -751,12 +856,9 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 
 
 	@Override
-	public BoolValue closeBatchMessage(CloseBatchMessage message) throws CommunicationException {
+	public BoolValue closeBatch(CloseBatchMessage message) throws CommunicationException {
 
-		ByteString signerId = message.getSig().getSignerId();
-		int batchId = message.getBatchId();
-
-		KeyHolder keyHolder = new GeneratedKeyHolder();
+		checkConnection();
 
 		// Check batch size
 
@@ -764,8 +866,7 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 		MapSqlParameterSource namedParameters = new MapSqlParameterSource();
 
 
-		namedParameters.addValue(QueryType.CHECK_BATCH_LENGTH.getParamName(0),signerId.toByteArray());
-		namedParameters.addValue(QueryType.CHECK_BATCH_LENGTH.getParamName(1),batchId);
+		namedParameters.addValue(QueryType.CHECK_BATCH_LENGTH.getParamName(0),message.getBatchId());
 
 		List<Long> lengthResult = jdbcTemplate.query(sql, namedParameters, new LongMapper());
 
@@ -773,106 +874,87 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 			return BoolValue.newBuilder().setValue(false).build();
 		}
 
-		// Get Tags and add them to CompleteBatch
+		// Get Tags and add them to BulletinBoardMessage
 
 		sql = sqlQueryProvider.getSQLString(QueryType.GET_BATCH_TAGS);
 		namedParameters = new MapSqlParameterSource();
 
-		namedParameters.addValue(QueryType.GET_BATCH_TAGS.getParamName(0),signerId.toByteArray());
-		namedParameters.addValue(QueryType.GET_BATCH_TAGS.getParamName(1),batchId);
+		namedParameters.addValue(QueryType.GET_BATCH_TAGS.getParamName(0),message.getBatchId());
 
-		List<String> tags = jdbcTemplate.query(sql, namedParameters, new StringMapper());
+		List<BeginBatchMessage> beginBatchMessages = jdbcTemplate.query(sql, namedParameters, new BeginBatchMessageMapper());
 
-		CompleteBatch completeBatch = new CompleteBatch(
-				BeginBatchMessage.newBuilder()
-						.setSignerId(signerId)
-						.setBatchId(batchId)
-						.addAllTag(tags)
-						.build()
-		);
+		if (beginBatchMessages == null || beginBatchMessages.size() <= 0 || beginBatchMessages.get(0) == null) {
+			return BoolValue.newBuilder().setValue(false).build();
+		}
 
-		// Add timestamp to CompleteBatch
-		completeBatch.setTimestamp(message.getTimestamp());
+		UnsignedBulletinBoardMessage unsignedMessage = UnsignedBulletinBoardMessage.newBuilder()
+				.addAllTag(beginBatchMessages.get(0).getTagList())
+				.setTimestamp(message.getTimestamp())
+				.build();
 
-		// Add actual batch data to CompleteBatch
+		// Digest the data
 
-		sql = sqlQueryProvider.getSQLString(QueryType.GET_BATCH_MESSAGE_DATA);
+		digest.reset();
+		digest.update(unsignedMessage);
+
+		sql = sqlQueryProvider.getSQLString(QueryType.GET_BATCH_MESSAGE_DATA_BY_BATCH_ID);
 		namedParameters = new MapSqlParameterSource();
 
-		namedParameters.addValue(QueryType.GET_BATCH_MESSAGE_DATA.getParamName(0),signerId.toByteArray());
-		namedParameters.addValue(QueryType.GET_BATCH_MESSAGE_DATA.getParamName(1),batchId);
-		namedParameters.addValue(QueryType.GET_BATCH_MESSAGE_DATA.getParamName(2),0); // Read from the beginning
+		namedParameters.addValue(QueryType.GET_BATCH_MESSAGE_DATA_BY_BATCH_ID.getParamName(0),message.getBatchId());
+		namedParameters.addValue(QueryType.GET_BATCH_MESSAGE_DATA_BY_BATCH_ID.getParamName(1),0); // Read from the beginning
+		jdbcTemplate.query(sql, namedParameters, new BatchDataDigestHandler(digest));
 
-		completeBatch.appendBatchData(jdbcTemplate.query(sql, namedParameters, new BatchDataMapper()));
+		byte[] msgID = digest.digest();
 
-		// Verify signature
-
-		completeBatch.setSignature(message.getSig());
-
-//		try {
-//			TODO: Actual verification
-//			//signer.verify(completeBatch);
-//		} catch (CertificateException | InvalidKeyException | SignatureException e) {
-//			return BoolValue.newBuilder().setValue(false).build();
-//		}
-
-		// Batch verified: finalize it
-
-		// Calculate message ID
-		digest.reset();
-		digest.update(completeBatch);
-		MessageID msgID = MessageID.newBuilder().setID(ByteString.copyFrom(digest.digest())).build();
+		//TODO: Signature verification
 
 		// Create Bulletin Board message
 		BulletinBoardMessage bulletinBoardMessage = BulletinBoardMessage.newBuilder()
-				.addSig(message.getSig())
 				.setMsg(UnsignedBulletinBoardMessage.newBuilder()
-					.addAllTag(tags)
-					.addTag(BATCH_TAG)
-					.addTag(batchIdToTag(batchId))
-					.setData(message.getSig().getSignerId())
-					.setTimestamp(message.getTimestamp())
-					.build())
+						.mergeFrom(unsignedMessage)
+						.setMsgId(ByteString.copyFrom(msgID)))
+				.addAllSig(message.getSigList())
 				.build();
 
-		// Post message without checking signature validity
-		postMessage(bulletinBoardMessage, false);
+		// Post message with pre-calculated ID and without checking signature validity
+		long entryNum = postMessage(bulletinBoardMessage, msgID);
 
-		// Remove tags from temporary table
-		sql = sqlQueryProvider.getSQLString(QueryType.REMOVE_BATCH_TAGS);
+		// Add entry num to tag data table
+		sql = sqlQueryProvider.getSQLString(QueryType.ADD_ENTRY_NUM_TO_BATCH);
 		namedParameters = new MapSqlParameterSource();
 
-		namedParameters.addValue(QueryType.REMOVE_BATCH_TAGS.getParamName(0), signerId.toByteArray());
-		namedParameters.addValue(QueryType.REMOVE_BATCH_TAGS.getParamName(1), batchId);
+		namedParameters.addValue(QueryType.ADD_ENTRY_NUM_TO_BATCH.getParamName(0), message.getBatchId());
+		namedParameters.addValue(QueryType.ADD_ENTRY_NUM_TO_BATCH.getParamName(1), entryNum);
 
 		jdbcTemplate.update(sql, namedParameters);
 
 		// Return TRUE
 
 		return BoolValue.newBuilder().setValue(true).build();
+
 	}
 
 
 	@Override
-	public void readBatch(BatchSpecificationMessage message, MessageOutputStream<BatchData> out) throws CommunicationException, IllegalArgumentException{
+	public void readBatch(BatchQuery batchQuery, MessageOutputStream<BatchChunk> out) throws CommunicationException, IllegalArgumentException{
+
+		checkConnection();
 
 		// Check that batch is closed
-		if (!isBatchClosed(message.getSignerId(), message.getBatchId())) {
+		if (!isBatchClosed(batchQuery.getMsgID())) {
 			throw new IllegalArgumentException("No such batch");
 		}
 
-		String sql = sqlQueryProvider.getSQLString(QueryType.GET_BATCH_MESSAGE_DATA);
+		String sql = sqlQueryProvider.getSQLString(QueryType.GET_BATCH_MESSAGE_DATA_BY_MSG_ID);
 		MapSqlParameterSource namedParameters = new MapSqlParameterSource();
 
-		namedParameters.addValue(QueryType.GET_BATCH_MESSAGE_DATA.getParamName(0),message.getSignerId().toByteArray());
-		namedParameters.addValue(QueryType.GET_BATCH_MESSAGE_DATA.getParamName(1),message.getBatchId());
-		namedParameters.addValue(QueryType.GET_BATCH_MESSAGE_DATA.getParamName(2),message.getStartPosition());
+		namedParameters.addValue(QueryType.GET_BATCH_MESSAGE_DATA_BY_MSG_ID.getParamName(0),batchQuery.getMsgID().getID().toByteArray());
+		namedParameters.addValue(QueryType.GET_BATCH_MESSAGE_DATA_BY_MSG_ID.getParamName(1),batchQuery.getStartPosition());
 
 		jdbcTemplate.query(sql, namedParameters, new BatchDataCallbackHandler(out));
 
 	}
 
-
 	/**
 	 * Finds the entry number of the last entry in the database
 	 * @return the entry number, or -1 if no entries are found
@@ -892,7 +974,9 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 	}
 
 	@Override
-	public SyncQuery generateSyncQuery(GenerateSyncQueryParams generateSyncQueryParams) {
+	public SyncQuery generateSyncQuery(GenerateSyncQueryParams generateSyncQueryParams) throws CommunicationException{
+
+		checkConnection();
 
 		if (generateSyncQueryParams == null
 				|| !generateSyncQueryParams.hasFilterList()
@@ -935,7 +1019,7 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 
 				checksumChanged = true;
 
-				checksum.update(message.getMsg().getData());
+				checksum.update(message.getMsg().getMsgId());
 
 				lastTimestamp = message.getMsg().getTimestamp();
 				message = messageIterator.next();
@@ -971,6 +1055,8 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 	@Override
 	public SyncQueryResponse querySync(SyncQuery syncQuery) throws CommunicationException {
 
+		checkConnection();
+
 		if (syncQuery == null){
 			return SyncQueryResponse.newBuilder()
 					.setLastEntryNum(-1)
@@ -1013,7 +1099,7 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 
 			// Advance checksum
 
-			ByteString messageID = message.getMsg().getData();	// The data field contains the message ID
+			ByteString messageID = message.getMsg().getMsgId();	// The data field contains the message ID
 
 			checksum.update(messageID);
 
@@ -1039,6 +1125,8 @@ public class BulletinBoardSQLServer implements BulletinBoardServer{
 
 
 	@Override
-	public void close() {}
+	public void close() {
+		jdbcTemplate = null;
+	}
 
 }

bulletin-board-server/src/main/java/meerkat/bulletinboard/sqlserver/H2QueryProvider.java

@@ -2,11 +2,7 @@ package meerkat.bulletinboard.sqlserver;
 
 import meerkat.protobuf.BulletinBoardAPI.FilterType;
 import org.apache.commons.dbcp2.BasicDataSource;
-import org.h2.jdbcx.JdbcDataSource;
-import javax.naming.Context;
-import javax.naming.InitialContext;
 
-import javax.naming.NamingException;
 import javax.sql.DataSource;
 import java.text.MessageFormat;
 import java.util.LinkedList;
@@ -30,19 +26,28 @@ public class H2QueryProvider implements BulletinBoardSQLServer.SQLQueryProvider
 
         switch(queryType) {
             case ADD_SIGNATURE:
-                return "INSERT INTO SignatureTable (EntryNum, SignerId, Signature)"
-                        + " SELECT DISTINCT :EntryNum AS Entry, :SignerId AS Id, :Signature AS Sig FROM UtilityTable AS Temp"
+                return MessageFormat.format(
+                        "INSERT INTO SignatureTable (EntryNum, SignerId, Signature)"
+                            + " SELECT DISTINCT :{0} AS Entry, :{1} AS Id, :{2} AS Sig FROM UtilityTable AS Temp"
                             + " WHERE NOT EXISTS"
-                        + " (SELECT 1 FROM SignatureTable AS SubTable WHERE SubTable.SignerId = :SignerId AND SubTable.EntryNum = :EntryNum)";
+                            + " (SELECT 1 FROM SignatureTable AS SubTable WHERE SubTable.EntryNum = :{0} AND SubTable.SignerId = :{1})",
+                        QueryType.ADD_SIGNATURE.getParamName(0),
+                        QueryType.ADD_SIGNATURE.getParamName(1),
+                        QueryType.ADD_SIGNATURE.getParamName(2));
 
             case CONNECT_TAG:
-                return "INSERT INTO MsgTagTable (TagId, EntryNum)"
-                        + " SELECT DISTINCT TagTable.TagId, :EntryNum AS NewEntry FROM TagTable WHERE Tag = :Tag"
+                return MessageFormat.format(
+                        "INSERT INTO MsgTagTable (TagId, EntryNum)"
+                            + " SELECT DISTINCT TagTable.TagId, :{0} AS NewEntry FROM TagTable WHERE Tag = :{1}"
                             + " AND NOT EXISTS (SELECT 1 FROM MsgTagTable AS SubTable WHERE SubTable.TagId = TagTable.TagId"
-                            + " AND SubTable.EntryNum = :EntryNum)";
+                            + " AND SubTable.EntryNum = :{0})",
+                        QueryType.CONNECT_TAG.getParamName(0),
+                        QueryType.CONNECT_TAG.getParamName(1));
 
             case FIND_MSG_ID:
-                return "SELECT EntryNum From MsgTable WHERE MsgId = :MsgId";
+                return MessageFormat.format(
+                        "SELECT EntryNum From MsgTable WHERE MsgId = :{0}",
+                        QueryType.FIND_MSG_ID.getParamName(0));
 
             case FIND_TAG_ID:
                 return MessageFormat.format(
@@ -59,74 +64,85 @@ public class H2QueryProvider implements BulletinBoardSQLServer.SQLQueryProvider
                 return "SELECT MsgTable.EntryNum, MsgTable.MsgId, MsgTable.ExactTime FROM MsgTable";
 
             case GET_SIGNATURES:
-                return "SELECT Signature FROM SignatureTable WHERE EntryNum = :EntryNum";
+                return MessageFormat.format(
+                        "SELECT Signature FROM SignatureTable WHERE EntryNum = :{0}",
+                        QueryType.GET_SIGNATURES.getParamName(0));
 
             case INSERT_MSG:
-                return "INSERT INTO MsgTable (MsgId, Msg, ExactTime) VALUES(:MsgId,:Msg,:TimeStamp)";
+                return MessageFormat.format(
+                        "INSERT INTO MsgTable (MsgId, ExactTime, Msg) VALUES(:{0}, :{1}, :{2})",
+                        QueryType.INSERT_MSG.getParamName(0),
+                        QueryType.INSERT_MSG.getParamName(1),
+                        QueryType.INSERT_MSG.getParamName(2));
+
+            case DELETE_MSG_BY_ENTRY:
+                return MessageFormat.format(
+                        "DELETE FROM MsgTable WHERE EntryNum = :{0}",
+                        QueryType.DELETE_MSG_BY_ENTRY.getParamName(0));
+
+            case DELETE_MSG_BY_ID:
+                return MessageFormat.format(
+                        "DELETE FROM MsgTable WHERE MsgId = :{0}",
+                        QueryType.DELETE_MSG_BY_ID.getParamName(0));
 
             case INSERT_NEW_TAG:
-                return "INSERT INTO TagTable(Tag) SELECT DISTINCT :Tag AS NewTag FROM UtilityTable WHERE"
-                        + " NOT EXISTS (SELECT 1 FROM TagTable AS SubTable WHERE SubTable.Tag = :Tag)";
+                return MessageFormat.format(
+                        "INSERT INTO TagTable(Tag) SELECT DISTINCT :Tag AS NewTag FROM UtilityTable WHERE"
+                            + " NOT EXISTS (SELECT 1 FROM TagTable AS SubTable WHERE SubTable.Tag = :{0})",
+                        QueryType.INSERT_NEW_TAG.getParamName(0));
 
             case GET_LAST_MESSAGE_ENTRY:
                 return "SELECT MAX(MsgTable.EntryNum) FROM MsgTable";
 
-            case GET_BATCH_MESSAGE_ENTRY:
-                return MessageFormat.format(
-                        "SELECT MsgTable.EntryNum, MsgTable.Msg FROM MsgTable"
-                                + " INNER JOIN SignatureTable ON MsgTable.EntryNum = SignatureTable.EntryNum"
-                                + " INNER JOIN MsgTagTable ON MsgTable.EntryNum = MsgTagTable.EntryNum"
-                                + " INNER JOIN TagTable ON MsgTagTable.TagId = TagTable.TagId"
-                                + " WHERE SignatureTable.SignerId = :{0}"
-                                + " AND TagTable.Tag = :{1}",
-                        QueryType.GET_BATCH_MESSAGE_ENTRY.getParamName(0),
-                        QueryType.GET_BATCH_MESSAGE_ENTRY.getParamName(1));
-
-            case GET_BATCH_MESSAGE_DATA:
+            case GET_BATCH_MESSAGE_DATA_BY_MSG_ID:
                 return MessageFormat.format(
                         "SELECT Data FROM BatchTable"
-                                + " WHERE SignerId = :{0} AND BatchId = :{1} AND SerialNum >= :{2}"
-                                + " ORDER BY SerialNum ASC",
-                        QueryType.GET_BATCH_MESSAGE_DATA.getParamName(0),
-                        QueryType.GET_BATCH_MESSAGE_DATA.getParamName(1),
-                        QueryType.GET_BATCH_MESSAGE_DATA.getParamName(2));
+                                + " INNER JOIN MsgTable ON MsgTable.EntryNum = BatchTable.EntryNum"
+                                + " WHERE MsgTable.MsgId = :{0} AND BatchTable.SerialNum >= :{1}"
+                                + " ORDER BY BatchTable.SerialNum ASC",
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_MSG_ID.getParamName(0),
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_MSG_ID.getParamName(1));
+
+            case GET_BATCH_MESSAGE_DATA_BY_BATCH_ID:
+                return MessageFormat.format(
+                        "SELECT Data FROM BatchTable"
+                                + " WHERE BatchId = :{0} AND SerialNum >= :{1}"
+                                + " ORDER BY BatchTable.SerialNum ASC",
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_BATCH_ID.getParamName(0),
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_BATCH_ID.getParamName(1));
 
             case INSERT_BATCH_DATA:
                 return MessageFormat.format(
-                        "INSERT INTO BatchTable (SignerId, BatchId, SerialNum, Data)"
-                                + " VALUES (:{0}, :{1}, :{2}, :{3})",
+                        "INSERT INTO BatchTable (BatchId, SerialNum, Data) VALUES (:{0}, :{1}, :{2})",
                         QueryType.INSERT_BATCH_DATA.getParamName(0),
                         QueryType.INSERT_BATCH_DATA.getParamName(1),
-                        QueryType.INSERT_BATCH_DATA.getParamName(2),
-                        QueryType.INSERT_BATCH_DATA.getParamName(3));
+                        QueryType.INSERT_BATCH_DATA.getParamName(2));
 
             case CHECK_BATCH_LENGTH:
                 return MessageFormat.format(
-                        "SELECT COUNT(Data) AS BatchLength FROM BatchTable"
-                                + " WHERE SignerId = :{0} AND BatchId = :{1}",
-                        QueryType.CHECK_BATCH_LENGTH.getParamName(0),
-                        QueryType.CHECK_BATCH_LENGTH.getParamName(1));
+                        "SELECT COUNT(Data) AS BatchLength FROM BatchTable WHERE BatchId = :{0}",
+                        QueryType.CHECK_BATCH_LENGTH.getParamName(0));
 
-            case CONNECT_BATCH_TAG:
+            case CHECK_BATCH_OPEN:
                 return MessageFormat.format(
-                        "INSERT INTO BatchTagTable (SignerId, BatchId, TagId) SELECT :{0}, :{1}, TagId FROM TagTable"
-                                + " WHERE Tag = :{2}",
-                        QueryType.CONNECT_BATCH_TAG.getParamName(0),
-                        QueryType.CONNECT_BATCH_TAG.getParamName(1),
-                        QueryType.CONNECT_BATCH_TAG.getParamName(2));
+                        "SELECT COUNT(BatchId) AS batchCount FROM BatchTagTable WHERE  BatchId = :{0}",
+                        QueryType.CHECK_BATCH_OPEN.getParamName(0));
+
+            case STORE_BATCH_TAGS:
+                return MessageFormat.format(
+                        "INSERT INTO BatchTagTable (Tags) VALUES (:{0})",
+                        QueryType.STORE_BATCH_TAGS.getParamName(0));
 
             case GET_BATCH_TAGS:
                 return MessageFormat.format(
-                        "SELECT Tag FROM TagTable INNER JOIN BatchTagTable ON TagTable.TagId = BatchTagTable.TagId"
-                                + " WHERE SignerId = :{0} AND BatchId = :{1} ORDER BY Tag ASC",
-                        QueryType.GET_BATCH_TAGS.getParamName(0),
-                        QueryType.GET_BATCH_TAGS.getParamName(1));
+                        "SELECT Tags FROM BatchTagTable WHERE BatchId = :{0}",
+                        QueryType.GET_BATCH_TAGS.getParamName(0));
 
-            case REMOVE_BATCH_TAGS:
+            case ADD_ENTRY_NUM_TO_BATCH:
                 return MessageFormat.format(
-                        "DELETE FROM BatchTagTable WHERE SignerId = :{0} AND BatchId = :{1}",
-                        QueryType.REMOVE_BATCH_TAGS.getParamName(0),
-                        QueryType.REMOVE_BATCH_TAGS.getParamName(1));
+                        "UPDATE BatchTable SET EntryNum = :{1} WHERE BatchId = :{0}",
+                        QueryType.ADD_ENTRY_NUM_TO_BATCH.getParamName(0),
+                        QueryType.ADD_ENTRY_NUM_TO_BATCH.getParamName(1));
 
             default:
                 throw new IllegalArgumentException("Cannot serve a query of type " + queryType);
@@ -204,7 +220,7 @@ public class H2QueryProvider implements BulletinBoardSQLServer.SQLQueryProvider
         BasicDataSource dataSource = new BasicDataSource();
 
         dataSource.setDriverClassName("org.h2.Driver");
-        dataSource.setUrl("jdbc:h2:~/" + dbName);
+        dataSource.setUrl("jdbc:h2:mem:" + dbName);
 
         return dataSource;
 
@@ -215,28 +231,30 @@ public class H2QueryProvider implements BulletinBoardSQLServer.SQLQueryProvider
     public List<String> getSchemaCreationCommands() {
         List<String> list = new LinkedList<String>();
 
-        list.add("CREATE TABLE IF NOT EXISTS MsgTable (EntryNum INT NOT NULL AUTO_INCREMENT PRIMARY KEY, MsgId TINYBLOB UNIQUE, ExactTime TIMESTAMP, Msg BLOB)");
+        list.add("CREATE TABLE IF NOT EXISTS MsgTable (EntryNum INT NOT NULL AUTO_INCREMENT PRIMARY KEY,"
+                + " MsgId TINYBLOB UNIQUE, ExactTime TIMESTAMP, Msg BLOB)");
 
         list.add("CREATE TABLE IF NOT EXISTS TagTable (TagId INT NOT NULL AUTO_INCREMENT PRIMARY KEY, Tag VARCHAR(50) UNIQUE)");
 
         list.add("CREATE TABLE IF NOT EXISTS MsgTagTable (EntryNum INT, TagId INT,"
-                + " FOREIGN KEY (EntryNum) REFERENCES MsgTable(EntryNum),"
-                + " FOREIGN KEY (TagId) REFERENCES TagTable(TagId),"
+                + " FOREIGN KEY (EntryNum) REFERENCES MsgTable(EntryNum) ON DELETE CASCADE,"
+                + " FOREIGN KEY (TagId) REFERENCES TagTable(TagId) ON DELETE CASCADE,"
                 + " UNIQUE (EntryNum, TagID))");
 
         list.add("CREATE TABLE IF NOT EXISTS SignatureTable (EntryNum INT, SignerId TINYBLOB, Signature TINYBLOB UNIQUE,"
-                + " FOREIGN KEY (EntryNum) REFERENCES MsgTable(EntryNum))");
+                + " FOREIGN KEY (EntryNum) REFERENCES MsgTable(EntryNum) ON DELETE CASCADE)");
 
         list.add("CREATE INDEX IF NOT EXISTS SignerIndex ON SignatureTable(SignerId)");
-        list.add("CREATE UNIQUE INDEX IF NOT EXISTS SignerIndex ON SignatureTable(SignerId, EntryNum)");
+        list.add("CREATE UNIQUE INDEX IF NOT EXISTS SignatureIndex ON SignatureTable(SignerId, EntryNum)");
 
-        list.add("CREATE TABLE IF NOT EXISTS BatchTable (SignerId TINYBLOB, BatchId INT, SerialNum INT, Data BLOB,"
-                + " UNIQUE(SignerId, BatchId, SerialNum))");
+        list.add("CREATE TABLE IF NOT EXISTS BatchTagTable (BatchId INT AUTO_INCREMENT PRIMARY KEY, Tags BLOB)");
+
+        list.add("CREATE TABLE IF NOT EXISTS BatchTable (BatchId INT, EntryNum INT, SerialNum INT, Data BLOB,"
+                + " UNIQUE(BatchId, SerialNum),"
+                + " FOREIGN KEY (BatchId) REFERENCES BatchTagTable(BatchId) ON DELETE CASCADE)");
+        list.add("CREATE INDEX IF NOT EXISTS BatchDataIndex ON BatchTable(EntryNum, SerialNum)");
 
-        list.add("CREATE TABLE IF NOT EXISTS BatchTagTable (SignerId TINYBLOB, BatchId INT, TagId INT,"
-                + " FOREIGN KEY (TagId) REFERENCES TagTable(TagId))");
 
-        list.add("CREATE INDEX IF NOT EXISTS BatchIndex ON BatchTagTable(SignerId, BatchId)");
 
         // This is used to create a simple table with one entry.
         // It is used for implementing a workaround for the missing INSERT IGNORE syntax
@@ -251,13 +269,20 @@ public class H2QueryProvider implements BulletinBoardSQLServer.SQLQueryProvider
         List<String> list = new LinkedList<String>();
 
         list.add("DROP TABLE IF EXISTS UtilityTable");
-        list.add("DROP INDEX IF EXISTS BatchIndex");
-        list.add("DROP TABLE IF EXISTS BatchTagTable");
+
+        list.add("DROP INDEX IF EXISTS BatchDataIndex");
         list.add("DROP TABLE IF EXISTS BatchTable");
-        list.add("DROP INDEX IF EXISTS SignerIdIndex");
+
+        list.add("DROP INDEX IF EXISTS BatchTagIndex");
+        list.add("DROP TABLE IF EXISTS BatchTagTable");
+
         list.add("DROP TABLE IF EXISTS MsgTagTable");
+
+        list.add("DROP INDEX IF EXISTS SignerIdIndex");
         list.add("DROP TABLE IF EXISTS SignatureTable");
+
         list.add("DROP TABLE IF EXISTS TagTable");
+
         list.add("DROP TABLE IF EXISTS MsgTable");
 
         return list;

bulletin-board-server/src/main/java/meerkat/bulletinboard/sqlserver/MySQLQueryProvider.java

@@ -1,7 +1,5 @@
 package meerkat.bulletinboard.sqlserver;
 
-import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
-import meerkat.bulletinboard.BulletinBoardConstants;
 import meerkat.bulletinboard.sqlserver.BulletinBoardSQLServer.SQLQueryProvider;
 import meerkat.protobuf.BulletinBoardAPI.FilterType;
 import org.apache.commons.dbcp2.BasicDataSource;
@@ -81,6 +79,16 @@ public class MySQLQueryProvider implements SQLQueryProvider {
                         QueryType.INSERT_MSG.getParamName(1),
                         QueryType.INSERT_MSG.getParamName(2));
 
+            case DELETE_MSG_BY_ENTRY:
+                return MessageFormat.format(
+                        "DELETE IGNORE FROM MsgTable WHERE EntryNum = :{0}",
+                        QueryType.DELETE_MSG_BY_ENTRY.getParamName(0));
+
+            case DELETE_MSG_BY_ID:
+                return MessageFormat.format(
+                        "DELETE IGNORE FROM MsgTable WHERE MsgId = :{0}",
+                        QueryType.DELETE_MSG_BY_ID.getParamName(0));
+
             case INSERT_NEW_TAG:
                 return MessageFormat.format(
                         "INSERT IGNORE INTO TagTable(Tag) VALUES (:{0})",
@@ -89,62 +97,55 @@ public class MySQLQueryProvider implements SQLQueryProvider {
             case GET_LAST_MESSAGE_ENTRY:
                 return "SELECT MAX(MsgTable.EntryNum) FROM MsgTable";
 
-            case GET_BATCH_MESSAGE_ENTRY:
-                return MessageFormat.format(
-                        "SELECT MsgTable.EntryNum, MsgTable.Msg FROM MsgTable"
-                        + " INNER JOIN SignatureTable ON MsgTable.EntryNum = SignatureTable.EntryNum"
-                        + " INNER JOIN MsgTagTable ON MsgTable.EntryNum = MsgTagTable.EntryNum"
-                        + " INNER JOIN TagTable ON MsgTagTable.TagId = TagTable.TagId"
-                        + " WHERE SignatureTable.SignerId = :{0}"
-                        + " AND TagTable.Tag = :{1}",
-                        QueryType.GET_BATCH_MESSAGE_ENTRY.getParamName(0),
-                        QueryType.GET_BATCH_MESSAGE_ENTRY.getParamName(1));
-
-            case GET_BATCH_MESSAGE_DATA:
+            case GET_BATCH_MESSAGE_DATA_BY_MSG_ID:
                 return MessageFormat.format(
                         "SELECT Data FROM BatchTable"
-                        + " WHERE SignerId = :{0} AND BatchId = :{1} AND SerialNum >= :{2}"
-                        + " ORDER BY SerialNum ASC",
-                        QueryType.GET_BATCH_MESSAGE_DATA.getParamName(0),
-                        QueryType.GET_BATCH_MESSAGE_DATA.getParamName(1),
-                        QueryType.GET_BATCH_MESSAGE_DATA.getParamName(2));
+                                + " INNER JOIN MsgTable ON MsgTable.EntryNum = BatchTable.EntryNum"
+                                + " WHERE MsgTable.MsgId = :{0} AND BatchTable.SerialNum >= :{1}"
+                                + " ORDER BY BatchTable.SerialNum ASC",
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_MSG_ID.getParamName(0),
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_MSG_ID.getParamName(1));
+
+            case GET_BATCH_MESSAGE_DATA_BY_BATCH_ID:
+                return MessageFormat.format(
+                        "SELECT Data FROM BatchTable"
+                                + " WHERE BatchId = :{0} AND SerialNum >= :{1}"
+                                + " ORDER BY BatchTable.SerialNum ASC",
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_BATCH_ID.getParamName(0),
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_BATCH_ID.getParamName(1));
 
             case INSERT_BATCH_DATA:
                 return MessageFormat.format(
-                        "INSERT INTO BatchTable (SignerId, BatchId, SerialNum, Data)"
-                        + " VALUES (:{0}, :{1}, :{2}, :{3})",
+                        "INSERT INTO BatchTable (BatchId, SerialNum, Data) VALUES (:{0}, :{1}, :{2})",
                         QueryType.INSERT_BATCH_DATA.getParamName(0),
                         QueryType.INSERT_BATCH_DATA.getParamName(1),
-                        QueryType.INSERT_BATCH_DATA.getParamName(2),
-                        QueryType.INSERT_BATCH_DATA.getParamName(3));
+                        QueryType.INSERT_BATCH_DATA.getParamName(2));
 
             case CHECK_BATCH_LENGTH:
                 return MessageFormat.format(
-                        "SELECT COUNT(Data) AS BatchLength FROM BatchTable"
-                        + " WHERE SignerId = :{0} AND BatchId = :{1}",
-                        QueryType.CHECK_BATCH_LENGTH.getParamName(0),
-                        QueryType.CHECK_BATCH_LENGTH.getParamName(1));
+                        "SELECT COUNT(Data) AS BatchLength FROM BatchTable WHERE BatchId = :{0}",
+                        QueryType.CHECK_BATCH_LENGTH.getParamName(0));
 
-            case CONNECT_BATCH_TAG:
+            case CHECK_BATCH_OPEN:
                 return MessageFormat.format(
-                        "INSERT INTO BatchTagTable (SignerId, BatchId, TagId) SELECT :{0}, :{1}, TagId FROM TagTable"
-                        + " WHERE Tag = :{2}",
-                        QueryType.CONNECT_BATCH_TAG.getParamName(0),
-                        QueryType.CONNECT_BATCH_TAG.getParamName(1),
-                        QueryType.CONNECT_BATCH_TAG.getParamName(2));
+                        "SELECT COUNT(BatchId) AS batchCount FROM BatchTagTable WHERE  BatchId = :{0}",
+                        QueryType.CHECK_BATCH_OPEN.getParamName(0));
+
+            case STORE_BATCH_TAGS:
+                return MessageFormat.format(
+                        "INSERT INTO BatchTagTable (Tags) VALUES (:{0})",
+                        QueryType.STORE_BATCH_TAGS.getParamName(0));
 
             case GET_BATCH_TAGS:
                 return MessageFormat.format(
-                        "SELECT Tag FROM TagTable INNER JOIN BatchTagTable ON TagTable.TagId = BatchTagTable.TagId"
-                        + " WHERE SignerId = :{0} AND BatchId = :{1} ORDER BY Tag ASC",
-                        QueryType.GET_BATCH_TAGS.getParamName(0),
-                        QueryType.GET_BATCH_TAGS.getParamName(1));
+                        "SELECT Tags FROM BatchTagTable WHERE BatchId = :{0}",
+                        QueryType.GET_BATCH_TAGS.getParamName(0));
 
-            case REMOVE_BATCH_TAGS:
+            case ADD_ENTRY_NUM_TO_BATCH:
                 return MessageFormat.format(
-                        "DELETE FROM BatchTagTable WHERE SignerId = :{0} AND BatchId = :{1}",
-                        QueryType.REMOVE_BATCH_TAGS.getParamName(0),
-                        QueryType.REMOVE_BATCH_TAGS.getParamName(1));
+                        "UPDATE BatchTable SET EntryNum = :{1} WHERE BatchId = :{0}",
+                        QueryType.ADD_ENTRY_NUM_TO_BATCH.getParamName(0),
+                        QueryType.ADD_ENTRY_NUM_TO_BATCH.getParamName(1));
 
            default:
                throw new IllegalArgumentException("Cannot serve a query of type " + queryType);
@@ -240,19 +241,21 @@ public class MySQLQueryProvider implements SQLQueryProvider {
         list.add("CREATE TABLE IF NOT EXISTS TagTable (TagId INT NOT NULL AUTO_INCREMENT PRIMARY KEY, Tag VARCHAR(50), UNIQUE(Tag))");
 
         list.add("CREATE TABLE IF NOT EXISTS MsgTagTable (EntryNum INT, TagId INT,"
-                + " CONSTRAINT FOREIGN KEY (EntryNum) REFERENCES MsgTable(EntryNum),"
-                + " CONSTRAINT FOREIGN KEY (TagId) REFERENCES TagTable(TagId),"
+                + " CONSTRAINT FOREIGN KEY (EntryNum) REFERENCES MsgTable(EntryNum) ON DELETE CASCADE,"
+                + " CONSTRAINT FOREIGN KEY (TagId) REFERENCES TagTable(TagId) ON DELETE CASCADE,"
                 + " CONSTRAINT UNIQUE (EntryNum, TagID))");
 
         list.add("CREATE TABLE IF NOT EXISTS SignatureTable (EntryNum INT, SignerId TINYBLOB, Signature TINYBLOB,"
                 + " INDEX(SignerId(32)), CONSTRAINT Unique_Signature UNIQUE(SignerId(32), EntryNum),"
-                + " CONSTRAINT FOREIGN KEY (EntryNum) REFERENCES MsgTable(EntryNum))");
+                + " CONSTRAINT FOREIGN KEY (EntryNum) REFERENCES MsgTable(EntryNum) ON DELETE CASCADE)");
+
+        list.add("CREATE TABLE IF NOT EXISTS BatchTagTable (BatchId INT AUTO_INCREMENT PRIMARY KEY, Tags BLOB)");
+
+        list.add("CREATE TABLE IF NOT EXISTS BatchTable (BatchId INT, EntryNum INT, SerialNum INT, Data BLOB,"
+                + " CONSTRAINT UNIQUE(BatchId, SerialNum),"
+                + " CONSTRAINT FOREIGN KEY (BatchId) REFERENCES BatchTagTable(BatchId) ON DELETE CASCADE)");
 
-        list.add("CREATE TABLE IF NOT EXISTS BatchTable (SignerId TINYBLOB, BatchId INT, SerialNum INT, Data BLOB,"
-                + " CONSTRAINT Unique_Batch UNIQUE(SignerId(32), BatchId, SerialNum))");
 
-        list.add("CREATE TABLE IF NOT EXISTS BatchTagTable (SignerId TINYBLOB, BatchId INT, TagId INT,"
-                + " INDEX(SignerId(32), BatchId), CONSTRAINT FOREIGN KEY (TagId) REFERENCES TagTable(TagId))");
 
         return list;
     }
@@ -261,8 +264,8 @@ public class MySQLQueryProvider implements SQLQueryProvider {
     public List<String> getSchemaDeletionCommands() {
         List<String> list = new LinkedList<String>();
 
-        list.add("DROP TABLE IF EXISTS BatchTagTable");
         list.add("DROP TABLE IF EXISTS BatchTable");
+        list.add("DROP TABLE IF EXISTS BatchTagTable");
         list.add("DROP TABLE IF EXISTS MsgTagTable");
         list.add("DROP TABLE IF EXISTS SignatureTable");
         list.add("DROP TABLE IF EXISTS TagTable");

bulletin-board-server/src/main/java/meerkat/bulletinboard/sqlserver/SQLiteQueryProvider.java

@@ -1,6 +1,7 @@
 package meerkat.bulletinboard.sqlserver;
 
 import meerkat.protobuf.BulletinBoardAPI.*;
+import org.apache.commons.dbcp2.BasicDataSource;
 import org.sqlite.SQLiteDataSource;
 
 import javax.sql.DataSource;
@@ -60,62 +61,55 @@ public class SQLiteQueryProvider implements BulletinBoardSQLServer.SQLQueryProvi
             case GET_LAST_MESSAGE_ENTRY:
                 return "SELECT MAX(MsgTable.EntryNum) FROM MsgTable";
 
-            case GET_BATCH_MESSAGE_ENTRY:
-                return MessageFormat.format(
-                        "SELECT MsgTable.EntryNum, MsgTable.Msg FROM MsgTable"
-                                + " INNER JOIN SignatureTable ON MsgTable.EntryNum = SignatureTable.EntryNum"
-                                + " INNER JOIN MsgTagTable ON MsgTable.EntryNum = MsgTagTable.EntryNum"
-                                + " INNER JOIN TagTable ON MsgTagTable.TagId = TagTable.TagId"
-                                + " WHERE SignatureTable.SignerId = :{0}"
-                                + " AND TagTable.Tag = :{1}",
-                        QueryType.GET_BATCH_MESSAGE_ENTRY.getParamName(0),
-                        QueryType.GET_BATCH_MESSAGE_ENTRY.getParamName(1));
-
-            case GET_BATCH_MESSAGE_DATA:
+            case GET_BATCH_MESSAGE_DATA_BY_MSG_ID:
                 return MessageFormat.format(
                         "SELECT Data FROM BatchTable"
-                                + " WHERE SignerId = :{0} AND BatchId = :{1} AND SerialNum >= :{2}"
-                                + " ORDER BY SerialNum ASC",
-                        QueryType.GET_BATCH_MESSAGE_DATA.getParamName(0),
-                        QueryType.GET_BATCH_MESSAGE_DATA.getParamName(1),
-                        QueryType.GET_BATCH_MESSAGE_DATA.getParamName(2));
+                                + " INNER JOIN MsgTable ON MsgTable.EntryNum = BatchTable.EntryNum"
+                                + " WHERE MsgTable.MsgId = :{0} AND BatchTable.SerialNum >= :{1}"
+                                + " ORDER BY BatchTable.SerialNum ASC",
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_MSG_ID.getParamName(0),
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_MSG_ID.getParamName(1));
+
+            case GET_BATCH_MESSAGE_DATA_BY_BATCH_ID:
+                return MessageFormat.format(
+                        "SELECT Data FROM BatchTable"
+                                + " WHERE BatchId = :{0} AND SerialNum >= :{1}"
+                                + " ORDER BY BatchTable.SerialNum ASC",
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_BATCH_ID.getParamName(0),
+                        QueryType.GET_BATCH_MESSAGE_DATA_BY_BATCH_ID.getParamName(1));
 
             case INSERT_BATCH_DATA:
                 return MessageFormat.format(
-                        "INSERT INTO BatchTable (SignerId, BatchId, SerialNum, Data)"
-                                + " VALUES (:{0}, :{1}, :{2}, :{3})",
+                        "INSERT INTO BatchTable (BatchId, SerialNum, Data) VALUES (:{0}, :{1}, :{2})",
                         QueryType.INSERT_BATCH_DATA.getParamName(0),
                         QueryType.INSERT_BATCH_DATA.getParamName(1),
-                        QueryType.INSERT_BATCH_DATA.getParamName(2),
-                        QueryType.INSERT_BATCH_DATA.getParamName(3));
+                        QueryType.INSERT_BATCH_DATA.getParamName(2));
 
             case CHECK_BATCH_LENGTH:
                 return MessageFormat.format(
-                        "SELECT COUNT(Data) AS BatchLength FROM BatchTable"
-                                + " WHERE SignerId = :{0} AND BatchId = :{1}",
-                        QueryType.CHECK_BATCH_LENGTH.getParamName(0),
-                        QueryType.CHECK_BATCH_LENGTH.getParamName(1));
+                        "SELECT COUNT(Data) AS BatchLength FROM BatchTable WHERE BatchId = :{0}",
+                        QueryType.CHECK_BATCH_LENGTH.getParamName(0));
 
-            case CONNECT_BATCH_TAG:
+            case CHECK_BATCH_OPEN:
                 return MessageFormat.format(
-                        "INSERT INTO BatchTagTable (SignerId, BatchId, TagId) SELECT :{0}, :{1}, TagId FROM TagTable"
-                                + " WHERE Tag = :{2}",
-                        QueryType.CONNECT_BATCH_TAG.getParamName(0),
-                        QueryType.CONNECT_BATCH_TAG.getParamName(1),
-                        QueryType.CONNECT_BATCH_TAG.getParamName(2));
+                        "SELECT COUNT(BatchId) AS batchCount FROM BatchTagTable WHERE  BatchId = :{0}",
+                        QueryType.CHECK_BATCH_OPEN.getParamName(0));
+
+            case STORE_BATCH_TAGS:
+                return MessageFormat.format(
+                        "INSERT INTO BatchTagTable (Tags) VALUES (:{0})",
+                        QueryType.STORE_BATCH_TAGS.getParamName(0));
 
             case GET_BATCH_TAGS:
                 return MessageFormat.format(
-                        "SELECT Tag FROM TagTable INNER JOIN BatchTagTable ON TagTable.TagId = BatchTagTable.TagId"
-                                + " WHERE SignerId = :{0} AND BatchId = :{1} ORDER BY Tag ASC",
-                        QueryType.GET_BATCH_TAGS.getParamName(0),
-                        QueryType.GET_BATCH_TAGS.getParamName(1));
+                        "SELECT Tags FROM BatchTagTable WHERE BatchId = :{0}",
+                        QueryType.GET_BATCH_TAGS.getParamName(0));
 
-            case REMOVE_BATCH_TAGS:
+            case ADD_ENTRY_NUM_TO_BATCH:
                 return MessageFormat.format(
-                        "DELETE FROM BatchTagTable WHERE SignerId = :{0} AND BatchId = :{1}",
-                        QueryType.REMOVE_BATCH_TAGS.getParamName(0),
-                        QueryType.REMOVE_BATCH_TAGS.getParamName(1));
+                        "UPDATE BatchTable SET EntryNum = :{1} WHERE BatchId = :{0}",
+                        QueryType.ADD_ENTRY_NUM_TO_BATCH.getParamName(0),
+                        QueryType.ADD_ENTRY_NUM_TO_BATCH.getParamName(1));
 
            default:
                throw new IllegalArgumentException("Cannot serve a query of type " + queryType);
@@ -191,7 +185,8 @@ public class SQLiteQueryProvider implements BulletinBoardSQLServer.SQLQueryProvi
     @Override
     public DataSource getDataSource() {
 
-        SQLiteDataSource dataSource = new SQLiteDataSource();
+        BasicDataSource dataSource = new BasicDataSource();
+        dataSource.setDriverClassName("org.sqlite.JDBC");
         dataSource.setUrl("jdbc:sqlite:" + dbName);
 
         return dataSource;
@@ -205,14 +200,23 @@ public class SQLiteQueryProvider implements BulletinBoardSQLServer.SQLQueryProvi
         list.add("CREATE TABLE IF NOT EXISTS MsgTable (EntryNum INTEGER PRIMARY KEY, MsgId BLOB UNIQUE, Msg BLOB)");
 
         list.add("CREATE TABLE IF NOT EXISTS TagTable (TagId INTEGER PRIMARY KEY, Tag varchar(50) UNIQUE)");
-        list.add("CREATE TABLE IF NOT EXISTS MsgTagTable (EntryNum BLOB, TagId INTEGER, FOREIGN KEY (EntryNum)"
-                + " REFERENCES MsgTable(EntryNum), FOREIGN KEY (TagId) REFERENCES TagTable(TagId), UNIQUE (EntryNum, TagID))");
+        list.add("CREATE TABLE IF NOT EXISTS MsgTagTable (EntryNum BLOB, TagId INTEGER,"
+                + " FOREIGN KEY (EntryNum) REFERENCES MsgTable(EntryNum) ON DELETE CASCADE,"
+                + " FOREIGN KEY (TagId) REFERENCES TagTable(TagId) ON DELETE CASCADE,"
+                + " UNIQUE (EntryNum, TagID))");
 
         list.add("CREATE TABLE IF NOT EXISTS SignatureTable (EntryNum INTEGER, SignerId BLOB, Signature BLOB,"
-                + " FOREIGN KEY (EntryNum) REFERENCES MsgTable(EntryNum), UNIQUE(SignerId, EntryNum))");
+                + " FOREIGN KEY (EntryNum) REFERENCES MsgTable(EntryNum) ON DELETE CASCADE,"
+                + " UNIQUE(SignerId, EntryNum))");
 
         list.add("CREATE INDEX IF NOT EXISTS SignerIndex ON SignatureTable(SignerId)");
 
+        list.add("CREATE TABLE IF NOT EXISTS BatchTagTable (BatchId INTEGER PRIMARY KEY, Tags BLOB)");
+
+        list.add("CREATE TABLE IF NOT EXISTS BatchTable (BatchId INTEGER, EntryNum INTEGER, SerialNum INTEGER, Data BLOB,"
+                + " UNIQUE(BatchId, SerialNum),"
+                + " FOREIGN KEY (BatchId) REFERENCES BatchTagTable(BatchId) ON DELETE CASCADE)");
+
         return list;
     }
 

bulletin-board-server/src/main/java/meerkat/bulletinboard/sqlserver/mappers/BatchDataCallbackHandler.java

@@ -1,10 +1,8 @@
 package meerkat.bulletinboard.sqlserver.mappers;
 
-import com.google.protobuf.InvalidProtocolBufferException;
 import meerkat.comm.MessageOutputStream;
-import meerkat.protobuf.BulletinBoardAPI.BatchData;
+import meerkat.protobuf.BulletinBoardAPI.BatchChunk;
 import org.springframework.jdbc.core.RowCallbackHandler;
-import org.springframework.jdbc.core.RowMapper;
 
 import java.io.IOException;
 import java.sql.ResultSet;
@@ -15,16 +13,16 @@ import java.sql.SQLException;
  */
 public class BatchDataCallbackHandler implements RowCallbackHandler {
 
-    private final MessageOutputStream<BatchData> out;
+    private final MessageOutputStream<BatchChunk> out;
 
-    public BatchDataCallbackHandler(MessageOutputStream<BatchData> out) {
+    public BatchDataCallbackHandler(MessageOutputStream<BatchChunk> out) {
         this.out = out;
     }
 
     @Override
     public void processRow(ResultSet rs) throws SQLException {
         try {
-            out.writeMessage(BatchData.parseFrom(rs.getBytes(1)));
+            out.writeMessage(BatchChunk.parseFrom(rs.getBytes(1)));
         } catch (IOException e) {
             //TODO: Log
         }

bulletin-board-server/src/main/java/meerkat/bulletinboard/sqlserver/mappers/BatchDataDigestHandler.java

@@ -0,0 +1,31 @@
+package meerkat.bulletinboard.sqlserver.mappers;
+
+import meerkat.bulletinboard.BulletinBoardDigest;
+import meerkat.protobuf.BulletinBoardAPI.BatchChunk;
+import org.springframework.jdbc.core.RowCallbackHandler;
+
+import java.io.IOException;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * Created by Arbel Deutsch Peled on 19-Dec-15.
+ */
+public class BatchDataDigestHandler implements RowCallbackHandler {
+
+    private final BulletinBoardDigest digest;
+
+    public BatchDataDigestHandler(BulletinBoardDigest digest) {
+        this.digest = digest;
+    }
+
+    @Override
+    public void processRow(ResultSet rs) throws SQLException {
+        try {
+            BatchChunk batchChunk = BatchChunk.parseFrom(rs.getBytes(1));
+            digest.update(batchChunk.getData().toByteArray());
+        } catch (IOException e) {
+            //TODO: Log
+        }
+    }
+}

bulletin-board-server/src/main/java/meerkat/bulletinboard/sqlserver/mappers/BatchDataMapper.java

@@ -1,26 +0,0 @@
-package meerkat.bulletinboard.sqlserver.mappers;
-
-import com.google.protobuf.ByteString;
-import com.google.protobuf.InvalidProtocolBufferException;
-import meerkat.protobuf.BulletinBoardAPI.BatchData;
-import org.springframework.jdbc.core.RowMapper;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-
-/**
- * Created by Arbel Deutsch Peled on 19-Dec-15.
- */
-public class BatchDataMapper implements RowMapper<BatchData> {
-
-    @Override
-    public BatchData mapRow(ResultSet rs, int rowNum) throws SQLException {
-
-        try {
-            return BatchData.parseFrom(rs.getBytes(1));
-        } catch (InvalidProtocolBufferException e) {
-            return BatchData.getDefaultInstance();
-        }
-
-    }
-}

bulletin-board-server/src/main/java/meerkat/bulletinboard/sqlserver/mappers/BeginBatchMessageMapper.java

@@ -0,0 +1,24 @@
+package meerkat.bulletinboard.sqlserver.mappers;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import meerkat.protobuf.BulletinBoardAPI.BeginBatchMessage;
+import org.springframework.jdbc.core.RowMapper;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * Created by Arbel Deutsch Peled on 20-Dec-15.
+ */
+public class BeginBatchMessageMapper implements RowMapper<BeginBatchMessage> {
+
+    @Override
+    public BeginBatchMessage mapRow(ResultSet rs, int rowNum) throws SQLException {
+        try {
+            return BeginBatchMessage.newBuilder().mergeFrom(rs.getBytes(1)).build();
+        } catch (InvalidProtocolBufferException e) {
+            return null;
+        }
+    }
+
+}

bulletin-board-server/src/main/java/meerkat/bulletinboard/sqlserver/mappers/MessageStubMapper.java

@@ -21,7 +21,7 @@ public class MessageStubMapper implements RowMapper<BulletinBoardMessage> {
         return BulletinBoardMessage.newBuilder()
                 .setEntryNum(rs.getLong(1))
                 .setMsg(UnsignedBulletinBoardMessage.newBuilder()
-                        .setData(ByteString.copyFrom(rs.getBytes(2)))
+                        .setMsgId(ByteString.copyFrom(rs.getBytes(2)))
                         .setTimestamp(BulletinBoardUtils.toTimestampProto(rs.getTimestamp(3)))
                         .build())
                 .build();

bulletin-board-server/src/main/java/meerkat/bulletinboard/webapp/BulletinBoardWebApp.java

@@ -9,6 +9,8 @@ import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.StreamingOutput;
 
 import com.google.protobuf.BoolValue;
+import com.google.protobuf.Int32Value;
+import com.google.protobuf.Int64Value;
 import meerkat.bulletinboard.BulletinBoardServer;
 import meerkat.bulletinboard.sqlserver.BulletinBoardSQLServer;
 import meerkat.bulletinboard.sqlserver.H2QueryProvider;
@@ -17,13 +19,11 @@ import meerkat.bulletinboard.sqlserver.SQLiteQueryProvider;
 import meerkat.comm.CommunicationException;
 import meerkat.comm.MessageOutputStream;
 import meerkat.protobuf.BulletinBoardAPI.*;
-import meerkat.protobuf.Comm.*;
 import static meerkat.bulletinboard.BulletinBoardConstants.*;
 import static meerkat.rest.Constants.*;
 
 import java.io.IOException;
 import java.io.OutputStream;
-import java.util.Collection;
 
 /**
  * An implementation of the BulletinBoardServer which functions as a WebApp
@@ -44,14 +44,6 @@ public class BulletinBoardWebApp implements BulletinBoardServer, ServletContextL
 		bulletinBoard = (BulletinBoardServer) servletContext.getAttribute(BULLETIN_BOARD_ATTRIBUTE_NAME);
 	}
 	
-	/**
-	 * This is the BulletinBoard init method.
-	 */
-	@Override
-	public void init(String meerkatDB) throws CommunicationException {
-		bulletinBoard.init(meerkatDB);
-	}
-	
 	@Override
 	public void contextInitialized(ServletContextEvent servletContextEvent) {
 		ServletContext servletContext = servletContextEvent.getServletContext();
@@ -77,7 +69,7 @@ public class BulletinBoardWebApp implements BulletinBoardServer, ServletContextL
 		}
 
 		try {
-			init(dbName);
+			bulletinBoard.init();
 			servletContext.setAttribute(BULLETIN_BOARD_ATTRIBUTE_NAME, bulletinBoard);
 		} catch (CommunicationException e) {
 			System.err.println(e.getMessage());
@@ -100,6 +92,16 @@ public class BulletinBoardWebApp implements BulletinBoardServer, ServletContextL
 		bulletinBoard.readMessages(filterList, out);
 	}
 
+	@Path(COUNT_MESSAGES_PATH)
+	@POST
+	@Consumes(MEDIATYPE_PROTOBUF)
+	@Produces(MEDIATYPE_PROTOBUF)
+	@Override
+	public Int32Value getMessageCount(MessageFilterList filterList) throws CommunicationException {
+		init();
+		return bulletinBoard.getMessageCount(filterList);
+	}
+
 
 	@Path(READ_MESSAGES_PATH)
 	@POST
@@ -133,7 +135,7 @@ public class BulletinBoardWebApp implements BulletinBoardServer, ServletContextL
 	@Consumes(MEDIATYPE_PROTOBUF)
 	@Produces(MEDIATYPE_PROTOBUF)
 	@Override
-	public BoolValue beginBatch(BeginBatchMessage message) {
+	public Int64Value beginBatch(BeginBatchMessage message) {
 		try {
 			init();
 			return bulletinBoard.beginBatch(message);
@@ -163,10 +165,10 @@ public class BulletinBoardWebApp implements BulletinBoardServer, ServletContextL
 	@Consumes(MEDIATYPE_PROTOBUF)
 	@Produces(MEDIATYPE_PROTOBUF)
 	@Override
-	public BoolValue closeBatchMessage(CloseBatchMessage message) {
+	public BoolValue closeBatch(CloseBatchMessage message) {
 		try {
 			init();
-			return bulletinBoard.closeBatchMessage(message);
+			return bulletinBoard.closeBatch(message);
 		} catch (CommunicationException e) {
 			System.err.println(e.getMessage());
 			return null;
@@ -175,10 +177,10 @@ public class BulletinBoardWebApp implements BulletinBoardServer, ServletContextL
 
 
 	@Override
-	public void readBatch(BatchSpecificationMessage message, MessageOutputStream<BatchData> out) {
+	public void readBatch(BatchQuery batchQuery, MessageOutputStream<BatchChunk> out) throws CommunicationException, IllegalArgumentException {
 		try {
 			init();
-			bulletinBoard.readBatch(message, out);
+			bulletinBoard.readBatch(batchQuery, out);
 		} catch (CommunicationException | IllegalArgumentException e) {
 			System.err.println(e.getMessage());
 		}
@@ -205,17 +207,17 @@ public class BulletinBoardWebApp implements BulletinBoardServer, ServletContextL
 	/**
 	 * Wrapper for the readBatch method which streams the output into the response
 	 */
-	public StreamingOutput readBatch(final BatchSpecificationMessage message) {
+	public StreamingOutput readBatch(final BatchQuery batchQuery) {
 
 		return new StreamingOutput() {
 
 			@Override
 			public void write(OutputStream output) throws IOException, WebApplicationException {
-				MessageOutputStream<BatchData> out = new MessageOutputStream<>(output);
+				MessageOutputStream<BatchChunk> out = new MessageOutputStream<>(output);
 
 				try {
 					init();
-					bulletinBoard.readBatch(message, out);
+					bulletinBoard.readBatch(batchQuery, out);
 				} catch (CommunicationException e) {
 					//TODO: Log
 					out.writeMessage(null);

bulletin-board-server/src/main/proto/meerkat/bulletin_board_server.proto

@@ -1,9 +0,0 @@
-syntax = "proto3";
-
-package meerkat;
-
-option java_package = "meerkat.protobuf";
-
-message Boolean {
-    bool value = 1;
-}

bulletin-board-server/src/test/java/meerkat/bulletinboard/GenericBulletinBoardServerTest.java

@@ -20,17 +20,18 @@ import java.util.*;
 import com.google.protobuf.BoolValue;
 import com.google.protobuf.ByteString;
 
+import com.google.protobuf.Int64Value;
 import com.google.protobuf.Timestamp;
 import meerkat.comm.CommunicationException;
 import meerkat.comm.MessageInputStream;
 import meerkat.comm.MessageOutputStream;
 import meerkat.comm.MessageInputStream.MessageInputStreamFactory;
-import meerkat.crypto.Digest;
 import meerkat.crypto.concrete.ECDSASignature;
 import meerkat.crypto.concrete.SHA256Digest;
 import meerkat.protobuf.BulletinBoardAPI.*;
-import meerkat.protobuf.Comm.*;
+import meerkat.util.BulletinBoardMessageComparator;
 import meerkat.util.BulletinBoardMessageGenerator;
+import meerkat.util.BulletinBoardUtils;
 
 import static org.junit.Assert.*;
 import static org.hamcrest.CoreMatchers.*;
@@ -39,7 +40,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
 public class GenericBulletinBoardServerTest {
 
 	protected BulletinBoardServer bulletinBoardServer;
-	private GenericBatchDigitalSignature[] signers;
+	private GenericBulletinBoardSignature[] signers;
 	private ByteString[] signerIDs;
 	
 	private Random random;
@@ -59,24 +60,18 @@ public class GenericBulletinBoardServerTest {
 	private String[] tags;
 	private byte[][] data;
 
-	private List<CompleteBatch> completeBatches;
+	private List<BulletinBoardMessage> batches;
 
 	private final ThreadMXBean threadBean = ManagementFactory.getThreadMXBean(); // Used to time the tests
 
 	private BulletinBoardMessageGenerator bulletinBoardMessageGenerator;
 
-	private Digest digest;
+	private BulletinBoardDigest digest;
+
+	private BulletinBoardMessageComparator comparator;
 
 	/**
 	 * @param bulletinBoardServer is an initialized server.
-	 * @throws InstantiationException
-	 * @throws IllegalAccessException
-	 * @throws CertificateException
-	 * @throws KeyStoreException
-	 * @throws NoSuchAlgorithmException
-	 * @throws IOException
-	 * @throws UnrecoverableKeyException
-	 * @throws CommunicationException
 	 */
 	public void init(BulletinBoardServer bulletinBoardServer) {
 
@@ -85,10 +80,10 @@ public class GenericBulletinBoardServerTest {
 
 		this.bulletinBoardServer = bulletinBoardServer;
 		
-		signers = new GenericBatchDigitalSignature[2];
+		signers = new GenericBulletinBoardSignature[2];
 		signerIDs = new ByteString[signers.length];
-        signers[0] = new GenericBatchDigitalSignature(new ECDSASignature());
-        signers[1] = new GenericBatchDigitalSignature(new ECDSASignature());
+        signers[0] = new GenericBulletinBoardSignature(new ECDSASignature());
+        signers[1] = new GenericBulletinBoardSignature(new ECDSASignature());
 		
 		InputStream keyStream = getClass().getResourceAsStream(KEYFILE_EXAMPLE);
         char[] password = KEYFILE_PASSWORD1.toCharArray();
@@ -134,7 +129,9 @@ public class GenericBulletinBoardServerTest {
         random = new Random(0);
 		bulletinBoardMessageGenerator = new BulletinBoardMessageGenerator(random);
 
-		digest = new SHA256Digest();
+		digest = new GenericBulletinBoardDigest(new SHA256Digest());
+
+		comparator = new BulletinBoardMessageComparator();
 
 		long end = threadBean.getCurrentThreadCpuTime();
 		System.err.println("Finished initializing GenericBulletinBoardServerTest");
@@ -142,7 +139,7 @@ public class GenericBulletinBoardServerTest {
 
 		// Initialize Batch variables
 
-		completeBatches = new ArrayList<CompleteBatch>(10);
+		batches = new ArrayList<>(10);
 
 	}
 	
@@ -446,73 +443,48 @@ public class GenericBulletinBoardServerTest {
 
 	}
 
-	/**
-	 * Tests that posting a message before opening a batch does not work
-	 * @throws CommunicationException
-     */
-	public void testBatchPostAfterClose() throws CommunicationException, SignatureException {
 
-		final int BATCH_ID = 100;
+	private void postAsBatch(BulletinBoardMessage message, int chunkSize, boolean close) throws CommunicationException {
+
+		List<BatchChunk> batchChunks = BulletinBoardUtils.breakToBatch(message, chunkSize);
+		BeginBatchMessage beginBatchMessage = BulletinBoardUtils.generateBeginBatchMessage(message);
 
-		CompleteBatch completeBatch = new CompleteBatch(Timestamp.newBuilder()
-				.setSeconds(978325)
-				.setNanos(8097234)
-				.build());
 		BoolValue result;
 
-		// Create data
-
-		completeBatch.setBeginBatchMessage(BeginBatchMessage.newBuilder()
-				.setSignerId(signerIDs[1])
-				.setBatchId(BATCH_ID)
-				.addTag("Test")
-				.build());
-
-		BatchData batchData = BatchData.newBuilder()
-				.setData(ByteString.copyFrom((new byte[] {1,2,3,4})))
-				.build();
-
-		completeBatch.appendBatchData(batchData);
-
-		signers[1].updateContent(completeBatch);
-
-		completeBatch.setSignature(signers[1].sign());
-
 		// Begin batch
 
-		result = bulletinBoardServer.beginBatch(completeBatch.getBeginBatchMessage());
+		Int64Value batchId = bulletinBoardServer.beginBatch(beginBatchMessage);
 
-		assertThat("Was not able to open batch", result.getValue(), is(true));
+		assertThat("Was not able to open batch", batchId.getValue() != -1);
 
 		// Post data
 
-		BatchMessage batchMessage = BatchMessage.newBuilder()
-				.setSignerId(signerIDs[1])
-				.setBatchId(BATCH_ID)
-				.setData(batchData)
+		BatchMessage batchMessage = BatchMessage.getDefaultInstance();
+
+		for (int i = 0 ; i < batchChunks.size() ; i++){
+
+			batchMessage = BatchMessage.newBuilder()
+					.setBatchId(batchId.getValue())
+					.setSerialNum(i)
+					.setData(batchChunks.get(i))
 					.build();
 
 			result = bulletinBoardServer.postBatchMessage(batchMessage);
 
 			assertThat("Was not able to post batch message", result.getValue(), is(true));
 
-		// Close batch
+		}
 
-		result = bulletinBoardServer.closeBatchMessage(completeBatch.getCloseBatchMessage());
+		// Close batch
+		if (close) {
+
+			CloseBatchMessage closeBatchMessage = BulletinBoardUtils.generateCloseBatchMessage(batchId, batchChunks.size(), message);
+
+			result = bulletinBoardServer.closeBatch(closeBatchMessage);
 
 			assertThat("Was not able to close batch", result.getValue(), is(true));
 
-		// Attempt to open batch again
-
-		result = bulletinBoardServer.beginBatch(completeBatch.getBeginBatchMessage());
-
-		assertThat("Was able to open a closed batch", result.getValue(), is(false));
-
-		// Attempt to add batch data
-
-		result = bulletinBoardServer.postBatchMessage(batchMessage);
-
-		assertThat("Was able to change a closed batch", result.getValue(), is(false));
+		}
 
 	}
 
@@ -522,110 +494,79 @@ public class GenericBulletinBoardServerTest {
 	 */
 	public void testPostBatch() throws CommunicationException, SignatureException {
 
-		CompleteBatch completeBatch = new CompleteBatch(Timestamp.newBuilder()
-				.setSeconds(12345)
-				.setNanos(1111)
-				.build());
-		int currentBatch = completeBatches.size();
+		// Create data
+		final int BATCH_ID = 200;
+		final int DATA_SIZE = 10000;
+		final int CHUNK_SIZE = 100;
+		final int TAG_NUMBER = 10;
 
-		BoolValue result;
+		Timestamp timestamp = Timestamp.newBuilder()
+				.setSeconds(5235000)
+				.setNanos(32541)
+				.build();
 
-		// Define batch data
+		BulletinBoardMessage batch = bulletinBoardMessageGenerator.generateRandomMessage(signers, timestamp, DATA_SIZE, TAG_NUMBER);
 
-		String[] tempBatchTags = new String[]{randomString(),randomString(),randomString()};
-		byte[][] tempBatchData = new byte[Math.abs(randomByte())][];
+		// Post batch
 
-		for (int i = 0 ; i < tempBatchData.length ; i++) {
-
-			tempBatchData[i] = new byte[Math.abs(randomByte())];
-
-			for (int j = 0; j < tempBatchData[i].length; j++) {
-				tempBatchData[i][j] = randomByte();
-			}
-
-		}
-
-		// Begin batch
-
-		completeBatch.setBeginBatchMessage(BeginBatchMessage.newBuilder()
-				.setSignerId(signerIDs[0])
-				.setBatchId(currentBatch)
-				.addAllTag(Arrays.asList(tempBatchTags))
-				.build());
-
-		result = bulletinBoardServer.beginBatch(completeBatch.getBeginBatchMessage());
-
-		assertThat("Could not begin batch " + currentBatch, result.getValue(), is(true));
-
-		// Add batch data and randomize data posting order
-
-		List<Integer> dataOrder = new ArrayList<Integer>(tempBatchData.length);
-		for (int i = 0 ; i < tempBatchData.length ; i++) {
-			dataOrder.add(i);
-			completeBatch.appendBatchData(BatchData.newBuilder()
-					.setData(ByteString.copyFrom(tempBatchData[i]))
-					.build());
-		}
-		Collections.shuffle(dataOrder);
-
-		// Post data
-
-		for (int i = 0 ; i < tempBatchData.length ; i++) {
-
-			int dataIndex = dataOrder.get(i);
-
-			result = bulletinBoardServer.postBatchMessage(BatchMessage.newBuilder()
-					.setSignerId(signerIDs[0])
-					.setBatchId(currentBatch)
-					.setSerialNum(dataIndex)
-					.setData(completeBatch.getBatchDataList().get(dataIndex))
-					.build());
-
-			assertThat("Could not post batch data for batch ID " + currentBatch + " serial number " + dataIndex,
-					result.getValue(), is(true));
-
-		}
-
-		// Close batch
-
-		signers[0].updateContent(completeBatch);
-		completeBatch.setSignature(signers[0].sign());
-
-		result = bulletinBoardServer.closeBatchMessage(completeBatch.getCloseBatchMessage());
-
-		assertThat("Could not close batch " + currentBatch,	result.getValue(), is(true));
+		postAsBatch(batch, CHUNK_SIZE, true);
 
 		// Update locally stored batches
-		completeBatches.add(completeBatch);
+		batches.add(batch);
 
 	}
 
 	public void testReadBatch() throws CommunicationException {
 
-		for (CompleteBatch completeBatch : completeBatches) {
+		for (BulletinBoardMessage message : batches) {
 
 			try {
 
 				ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
 
-				BatchSpecificationMessage batchSpecificationMessage =
-						BatchSpecificationMessage.newBuilder()
-								.setSignerId(completeBatch.getBeginBatchMessage().getSignerId())
-								.setBatchId(completeBatch.getBeginBatchMessage().getBatchId())
+				digest.update(message);
+
+				MessageID msgId = digest.digestAsMessageID();
+
+				MessageFilterList messageFilterList = MessageFilterList.newBuilder()
+						.addFilter(MessageFilter.newBuilder()
+								.setType(FilterType.MSG_ID)
+								.setId(msgId.getID())
+								.build())
+						.build();
+
+				bulletinBoardServer.readMessages(messageFilterList, new MessageOutputStream<BulletinBoardMessage>(outputStream));
+
+				MessageInputStream<BulletinBoardMessage> messageInputStream =
+						MessageInputStreamFactory.createMessageInputStream(new ByteArrayInputStream(
+										outputStream.toByteArray()),
+								BulletinBoardMessage.class);
+
+				List<BulletinBoardMessage> messageList = messageInputStream.asList();
+
+				assertThat("No stub found for message ID " + msgId.getID().toStringUtf8(), messageList.size() == 1);
+
+				BulletinBoardMessage stub = messageList.get(0);
+
+				BatchQuery batchQuery =
+						BatchQuery.newBuilder()
+								.setMsgID(msgId)
 								.setStartPosition(0)
 								.build();
 
-				bulletinBoardServer.readBatch(batchSpecificationMessage, new MessageOutputStream<BatchData>(outputStream));
+				bulletinBoardServer.readBatch(batchQuery, new MessageOutputStream<BatchChunk>(outputStream));
 
-				MessageInputStream<BatchData> inputStream =
+				MessageInputStream<BatchChunk> batchInputStream =
 						MessageInputStreamFactory.createMessageInputStream(new ByteArrayInputStream(
 								outputStream.toByteArray()),
-								BatchData.class);
+								BatchChunk.class);
 
-				List<BatchData> batchDataList = inputStream.asList();
+				List<BatchChunk> batchChunkList = batchInputStream.asList();
 
-				assertThat("Non-matching batch data for batch " + completeBatch.getBeginBatchMessage().getBatchId(),
-						completeBatch.getBatchDataList().equals(batchDataList), is(true));
+				BulletinBoardMessage retrievedMessage = BulletinBoardUtils.gatherBatch(stub, batchChunkList);
+
+				assertThat("Non-matching batch data for batch " + msgId.getID().toStringUtf8(),
+						comparator.compare(message, retrievedMessage) == 0);
 
 			} catch (IOException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
 				assertThat("Error reading batch data list from input stream", false);

bulletin-board-server/src/test/java/meerkat/bulletinboard/H2BulletinBoardServerTest.java

@@ -7,7 +7,6 @@ import meerkat.comm.CommunicationException;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
-import org.junit.runner.Result;
 
 import java.lang.management.ManagementFactory;
 import java.lang.management.ThreadMXBean;
@@ -55,7 +54,7 @@ public class H2BulletinBoardServerTest {
 
         BulletinBoardServer bulletinBoardServer = new BulletinBoardSQLServer(queryProvider);
         try {
-            bulletinBoardServer.init("");
+            bulletinBoardServer.init();
 
         } catch (CommunicationException e) {
             System.err.println(e.getMessage());
@@ -107,16 +106,6 @@ public class H2BulletinBoardServerTest {
         System.err.println("Time of operation: " + (end - start));
     }
 
-    @Test
-    public void testBatchPostAfterClose() {
-        try{
-            serverTest.testBatchPostAfterClose();
-        } catch (Exception e) {
-            System.err.println(e.getMessage());
-            fail(e.getMessage());
-        }
-    }
-
     @Test
     public void testBatch() {
 

bulletin-board-server/src/test/java/meerkat/bulletinboard/MySQLBulletinBoardServerTest.java

@@ -8,13 +8,9 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
-import java.io.IOException;
 import java.lang.management.ManagementFactory;
 import java.lang.management.ThreadMXBean;
-import java.lang.reflect.InvocationTargetException;
-import java.security.SignatureException;
 import java.sql.Connection;
-import java.sql.DriverManager;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.List;
@@ -62,7 +58,7 @@ public class MySQLBulletinBoardServerTest {
 
         BulletinBoardServer bulletinBoardServer = new BulletinBoardSQLServer(queryProvider);
         try {
-            bulletinBoardServer.init("");
+            bulletinBoardServer.init();
 
         } catch (CommunicationException e) {
             System.err.println(e.getMessage());
@@ -114,16 +110,6 @@ public class MySQLBulletinBoardServerTest {
         System.err.println("Time of operation: " + (end - start));
     }
 
-    @Test
-    public void testBatchPostAfterClose() {
-        try{
-            serverTest.testBatchPostAfterClose();
-        } catch (Exception e) {
-            System.err.println(e.getMessage());
-            fail(e.getMessage());
-        }
-    }
-
     @Test
     public void testBatch() {
 

bulletin-board-server/src/test/java/meerkat/bulletinboard/SQLiteBulletinBoardServerTest.java

@@ -39,7 +39,7 @@ public class SQLiteBulletinBoardServerTest{
 
         BulletinBoardServer bulletinBoardServer = new BulletinBoardSQLServer(new SQLiteQueryProvider(testFilename));
         try {
-            bulletinBoardServer.init("");
+            bulletinBoardServer.init();
 
         } catch (CommunicationException e) {
             System.err.println(e.getMessage());
@@ -60,7 +60,7 @@ public class SQLiteBulletinBoardServerTest{
         System.err.println("Time of operation: " + (end - start));
     }
 
-    @Test
+//    @Test
     public void bulkTest() {
         System.err.println("Starting bulkTest of SQLiteBulletinBoardServerTest");
         long start = threadBean.getCurrentThreadCpuTime();
@@ -91,6 +91,29 @@ public class SQLiteBulletinBoardServerTest{
         System.err.println("Time of operation: " + (end - start));
     }
 
+//    @Test
+    public void testBatch() {
+
+        final int BATCH_NUM = 20;
+
+        try{
+            for (int i = 0 ; i < BATCH_NUM ; i++) {
+                serverTest.testPostBatch();
+            }
+        } catch (Exception e) {
+            System.err.println(e.getMessage());
+            fail(e.getMessage());
+        }
+
+        try{
+            serverTest.testReadBatch();
+        } catch (Exception e) {
+            System.err.println(e.getMessage());
+            fail(e.getMessage());
+        }
+
+    }
+
     @After
     public void close() {
         System.err.println("Starting to close SQLiteBulletinBoardServerTest");

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,7 @@
-#Fri Jan 29 21:00:29 IST 2016
+#Tue Aug 05 03:26:05 IDT 2014
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.9-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.9-all.zip
+distributionSha256Sum=4647967f8de78d6d6d8093cdac50f368f8c2b8038f41a5afe1c3bce4c69219a9

gradlew

@@ -42,6 +42,11 @@ case "`uname`" in
     ;;
 esac
 
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -56,9 +61,9 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
+cd "`dirname \"$PRG\"`/" >&-
 APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
+cd "$SAVED" >&-
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
@@ -109,7 +114,6 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`

meerkat-common/src/main/java/meerkat/bulletinboard/AsyncBulletinBoardClient.java

@@ -1,8 +1,9 @@
 package meerkat.bulletinboard;
 
 import com.google.common.util.concurrent.FutureCallback;
-import com.google.protobuf.ByteString;
+import com.google.protobuf.Timestamp;
 import meerkat.protobuf.BulletinBoardAPI.*;
+import meerkat.protobuf.Crypto.Signature;
 
 import java.util.List;
 
@@ -13,6 +14,7 @@ public interface AsyncBulletinBoardClient extends BulletinBoardClient {
 
     /**
      * Post a message to the bulletin board in an asynchronous manner
+     * The message may be broken up by the client into a batch message, depending on implementation
      * @param msg is the message to be posted
      * @param callback is a class containing methods to handle the result of the operation
      * @return a unique message ID for the message, that can be later used to retrieve the batch
@@ -20,56 +22,58 @@ public interface AsyncBulletinBoardClient extends BulletinBoardClient {
     public MessageID postMessage(BulletinBoardMessage msg, FutureCallback<Boolean> callback);
 
     /**
-     * Perform an end-to-end post of a signed batch message
-     * @param completeBatch contains all the data of the batch including the meta-data and the signature
+     * Perform an end-to-end post of a message in batch form
+     * @param completeBatch contains all the data of the batch
+     * @param chunkSize is the maximum size of each chunk of the message in bytes
      * @param callback is a class containing methods to handle the result of the operation
      * @return a unique identifier for the batch message
      */
-    public MessageID postBatch(CompleteBatch completeBatch, FutureCallback<Boolean> callback);
+    public MessageID postAsBatch(BulletinBoardMessage completeBatch, int chunkSize, FutureCallback<Boolean> callback);
+
+    /**
+     * An interface for returning an opaque identifier for a batch message
+     * This identifier is used to uniquely identify the batch until it is completely posted and signed
+     * After the batch is fully posted: it is identified by its digest (like any message)
+     * This can be implementation-specific (and not necessarily interchangeable between different implementations)
+     */
+    public interface BatchIdentifier {}
 
     /**
      * This message informs the server about the existence of a new batch message and supplies it with the tags associated with it
-     * @param beginBatchMessage contains the data required to begin the batch
+     * @param tags contains the tags used in the batch
      * @param callback is a callback function class for handling results of the operation
+     *                 it receives a BatchIdentifier for use in subsequent batch post operations
      */
-    public void beginBatch(BeginBatchMessage beginBatchMessage, FutureCallback<Boolean> callback);
+    public void beginBatch(Iterable<String> tags, FutureCallback<BatchIdentifier> callback);
 
     /**
      * This method posts batch data into an (assumed to be open) batch
      * It does not close the batch
-     * @param signerId is the canonical form for the ID of the sender of this batch
-     * @param batchId is a unique (per signer) ID for this batch
-     * @param batchDataList is the (canonically ordered) list of data comprising the portion of the batch to be posted
+     * @param batchIdentifier is the temporary batch identifier
+     * @param batchChunkList is the (canonically ordered) list of data comprising the portion of the batch to be posted
      * @param startPosition is the location (in the batch) of the first entry in batchDataList
  *                      (optionally used to continue interrupted post operations)
  *                      The first position in the batch is position 0
      * @param callback is a callback function class for handling results of the operation
+     * @throws IllegalArgumentException if the batch identifier given was of an illegal format
      */
-    public void postBatchData(byte[] signerId, int batchId, List<BatchData> batchDataList,
-                              int startPosition, FutureCallback<Boolean> callback);
+    public void postBatchData(BatchIdentifier batchIdentifier, List<BatchChunk> batchChunkList,
+                              int startPosition, FutureCallback<Boolean> callback) throws IllegalArgumentException;
 
     /**
      * Overloading of the postBatchData method which starts at the first position in the batch
      */
-    public void postBatchData(byte[] signerId, int batchId, List<BatchData> batchDataList, FutureCallback<Boolean> callback);
-
-    /**
-     * Overloading of the postBatchData method which uses ByteString
-     */
-    public void postBatchData(ByteString signerId, int batchId, List<BatchData> batchDataList,
-                              int startPosition, FutureCallback<Boolean> callback);
-
-    /**
-     * Overloading of the postBatchData method which uses ByteString and starts at the first position in the batch
-     */
-    public void postBatchData(ByteString signerId, int batchId, List<BatchData> batchDataList, FutureCallback<Boolean> callback);
+    public void postBatchData(BatchIdentifier batchIdentifier, List<BatchChunk> batchChunkList, FutureCallback<Boolean> callback)
+            throws IllegalArgumentException;
 
     /**
      * Attempts to close a batch message
-     * @param closeBatchMessage contains the data required to close the batch
+     * @param batchIdentifier is the temporary batch identifier
      * @param callback is a callback function class for handling results of the operation
+     * @throws IllegalArgumentException if the batch identifier given was of an illegal format
      */
-    public void closeBatch(CloseBatchMessage closeBatchMessage, FutureCallback<Boolean> callback);
+    public void closeBatch(BatchIdentifier batchIdentifier, Timestamp timestamp, Iterable<Signature> signatures, FutureCallback<Boolean> callback)
+            throws IllegalArgumentException;
 
     /**
      * Check how "safe" a given message is in an asynchronous manner
@@ -83,18 +87,29 @@ public interface AsyncBulletinBoardClient extends BulletinBoardClient {
      * Read all messages posted matching the given filter in an asynchronous manner
      * Note that if messages haven't been "fully posted", this might return a different
      * set of messages in different calls. However, messages that are fully posted
-     * are guaranteed to be included.
-     * @param filterList return only messages that match the filters (null means no filtering).
+     * are guaranteed to be included
+     * Also: batch messages are returned as stubs.
+     * @param filterList return only messages that match the filters (null means no filtering)
      * @param callback is a callback function class for handling results of the operation
      */
     public void readMessages(MessageFilterList filterList, FutureCallback<List<BulletinBoardMessage>> callback);
 
     /**
-     * Read a given batch message from the bulletin board
-     * @param batchSpecificationMessage contains the data required to specify a single batch instance
+     * Read a given message from the bulletin board
+     * If the message is a batch: returns a complete message containing the batch data as well as the metadata
+     * @param msgID is the ID of the message to be read
      * @param callback is a callback class for handling the result of the operation
      */
-    public void readBatch(BatchSpecificationMessage batchSpecificationMessage, FutureCallback<CompleteBatch> callback);
+    public void readMessage(MessageID msgID, FutureCallback<BulletinBoardMessage> callback);
+
+    /**
+     * Read batch data for a specific stub message
+     * @param stub is a batch message stub
+     * @param callback is a callback class for handling the result of the operation
+     * @return a new BulletinBoardMessage containing both metadata from the stub and actual data from the server
+     * @throws IllegalArgumentException if the received message is not a stub
+     */
+    public void readBatchData(BulletinBoardMessage stub, FutureCallback<BulletinBoardMessage> callback) throws IllegalArgumentException;
 
 
     /**

meerkat-common/src/main/java/meerkat/bulletinboard/BatchDigest.java

@@ -1,20 +0,0 @@
-package meerkat.bulletinboard;
-
-import meerkat.crypto.Digest;
-import meerkat.protobuf.BulletinBoardAPI.*;
-
-import java.util.List;
-
-/**
- * Created by Arbel Deutsch Peled on 18-Dec-15.
- * Extends the Digest interface with a method for digesting Batch messages
- */
-public interface BatchDigest extends Digest {
-
-    /**
-     * Update the digest with the batch message data (ignore the signature)
-     * @param completeBatch is the batch message that needs to be digested
-     */
-    public void update(CompleteBatch completeBatch);
-
-}

meerkat-common/src/main/java/meerkat/bulletinboard/BatchDigitalSignature.java

@@ -1,34 +0,0 @@
-package meerkat.bulletinboard;
-
-import meerkat.crypto.DigitalSignature;
-import meerkat.protobuf.BulletinBoardAPI.BeginBatchMessage;
-import meerkat.protobuf.BulletinBoardAPI.BatchData;
-import meerkat.protobuf.Crypto.Signature;
-
-import java.security.InvalidKeyException;
-import java.security.SignatureException;
-import java.security.cert.CertificateException;
-import java.util.List;
-
-/**
- * Created by Arbel Deutsch Peled on 20-Dec-15.
- * Extends the DigitalSignature interface with methods for signing and authenticating Batch messages
- */
-public interface BatchDigitalSignature extends DigitalSignature {
-
-    /**
-     * Appends the batch data to the signed content (ignoring the signature)
-     * @param completeBatch contains all the data about the batch
-     * @throws SignatureException
-     */
-    public void updateContent(CompleteBatch completeBatch) throws SignatureException;
-
-    /**
-     * Performs a complete verification process on the given batch message
-     * @param completeBatch contains the batch data as well as the signature
-     * @return TRUE if the batch is verified and FALSE otherwise
-     * @throws SignatureException | SignatureException | InvalidKeyException when underlying methods do so
-     */
-    public boolean verify(CompleteBatch completeBatch) throws SignatureException, CertificateException, InvalidKeyException;
-
-}

meerkat-common/src/main/java/meerkat/bulletinboard/BulletinBoardClient.java

@@ -5,7 +5,6 @@ import meerkat.protobuf.Voting.*;
 
 import static meerkat.protobuf.BulletinBoardAPI.*;
 
-import java.util.Collection;
 import java.util.List;
 
 /**
@@ -21,6 +20,7 @@ public interface BulletinBoardClient {
 
     /**
      * Post a message to the bulletin board in a synchronous manner
+     * The message may be broken up by the client into a batch message depending on implementation
      * @param msg is the message to be posted
      * @return a unique message ID for the message, that can be later used to retrieve the batch
      * @throws CommunicationException
@@ -31,28 +31,57 @@ public interface BulletinBoardClient {
      * Check how "safe" a given message is in a synchronous manner
      * @param id is the unique message identifier for retrieval
      * @return a normalized "redundancy score" from 0 (local only) to 1 (fully published)
+     * @throws CommunicationException
      */
-    float getRedundancy(MessageID id);
+    float getRedundancy(MessageID id) throws CommunicationException;
 
     /**
      * Read all messages posted matching the given filter in a synchronous manner
      * Note that if messages haven't been "fully posted", this might return a different
      * set of messages in different calls. However, messages that are fully posted
      * are guaranteed to be included.
+     * Also: batch messages are returned as stubs.
      * @param filterList return only messages that match the filters (null means no filtering)
      * @return the list of messages
      */
-    List<BulletinBoardMessage> readMessages(MessageFilterList filterList);
+    List<BulletinBoardMessage> readMessages(MessageFilterList filterList) throws CommunicationException;
+
+    /**
+     * Breaks up a bulletin board message into chunks and posts it as a batch message
+     * @param msg is the message to post
+     * @param chunkSize is the maximal chunk size in bytes
+     * @return the unique message ID
+     * @throws CommunicationException if operation is unsuccessful
+     */
+    MessageID postAsBatch(BulletinBoardMessage msg, int chunkSize) throws CommunicationException;
+
+    /**
+     * Read a given message from the bulletin board
+     * If the message is a batch: returns a complete message containing the batch data as well as the metadata
+     * @param msgID is the ID of the message to be read
+     * @return the complete message
+     * @throws CommunicationException if operation is unsuccessful
+     */
+    BulletinBoardMessage readMessage(MessageID msgID) throws CommunicationException;
+
+    /**
+     * Read batch data for a specific stub message
+     * @param stub is a batch message stub
+     * @return a new BulletinBoardMessage containing both metadata from the stub and actual data from the server
+     * @throws CommunicationException if operation is unsuccessful
+     * @throws IllegalArgumentException if the received message is not a stub
+     */
+    BulletinBoardMessage readBatchData(BulletinBoardMessage stub) throws CommunicationException, IllegalArgumentException;
 
     /**
      * Create a SyncQuery to test against that corresponds with the current server state for a specific filter list
      * Should only be called on instances for which the actual server contacted is known (i.e. there is only one server)
-     * @param GenerateSyncQueryParams defines the required information needed to generate the query
+     * @param generateSyncQueryParams defines the required information needed to generate the query
      *                    These are represented as fractions of the total number of relevant messages
      * @return The generated SyncQuery
      * @throws CommunicationException when no DB can be contacted
      */
-    SyncQuery generateSyncQuery(GenerateSyncQueryParams GenerateSyncQueryParams) throws CommunicationException;
+    SyncQuery generateSyncQuery(GenerateSyncQueryParams generateSyncQueryParams) throws CommunicationException;
 
     /**
      * Closes all connections, if any.

meerkat-common/src/main/java/meerkat/bulletinboard/BulletinBoardConstants.java

@@ -10,6 +10,7 @@ public interface BulletinBoardConstants {
     public static final String BULLETIN_BOARD_SERVER_PATH = "/bbserver";
     public static final String GENERATE_SYNC_QUERY_PATH = "/generatesyncquery";
     public static final String READ_MESSAGES_PATH = "/readmessages";
+    public static final String COUNT_MESSAGES_PATH = "/countmessages";
     public static final String READ_BATCH_PATH = "/readbatch";
     public static final String POST_MESSAGE_PATH = "/postmessage";
     public static final String BEGIN_BATCH_PATH = "/beginbatch";
@@ -17,9 +18,4 @@ public interface BulletinBoardConstants {
     public static final String CLOSE_BATCH_PATH = "/closebatch";
     public static final String SYNC_QUERY_PATH = "/syncquery";
 
-    // Other Constants
-
-    public static final String BATCH_TAG = "@BATCH";
-    public static final String BATCH_ID_TAG_PREFIX = "BATCHID#";
-
 }

meerkat-common/src/main/java/meerkat/bulletinboard/BulletinBoardDigest.java

@@ -0,0 +1,30 @@
+package meerkat.bulletinboard;
+
+import meerkat.crypto.Digest;
+import meerkat.protobuf.BulletinBoardAPI.*;
+
+import java.util.List;
+
+/**
+ * Created by Arbel Deutsch Peled on 18-Dec-15.
+ * Extends the Digest interface with methods for digesting Bulletin Board messages
+ */
+public interface BulletinBoardDigest extends Digest {
+
+    /**
+     * Update the digest with the message data (ignore the signature)
+     * The digest only uses the part the signatures are computed on for this operation
+     * If the message is a stub: this should be called before digesting the raw data
+     * @param msg is the message that needs to be digested
+     */
+    public void update(BulletinBoardMessage msg);
+
+    /**
+     * Update the digest with the message data (ignore the signature)
+     * The digest only uses the part the signatures are computed on for this operation
+     * If the message is a stub: this should be called before digesting the raw data
+     * @param msg is the message that needs to be digested
+     */
+    public void update(UnsignedBulletinBoardMessage msg);
+
+}

meerkat-common/src/main/java/meerkat/bulletinboard/BulletinBoardMessageDeleter.java

@@ -0,0 +1,49 @@
+package meerkat.bulletinboard;
+
+import com.google.common.util.concurrent.FutureCallback;
+import meerkat.comm.CommunicationException;
+import meerkat.protobuf.BulletinBoardAPI.*;
+
+/**
+ * Created by Arbel Deutsch Peled on 13-Apr-16.
+ * This interface is meant to extend a BulletinBoardClient interface/class
+ * It provides it with the ability to delete messages from the Server
+ * This assumes the Server implements the  {@link DeletableBulletinBoardServer}
+ */
+public interface BulletinBoardMessageDeleter {
+
+    /**
+     * Deletes a message from a Bulletin Board Server in a possibly asynchronous manner
+     * Logs this action
+     * @param msgID is the ID of the message to delete
+     * @param callback handles the result of the operation
+     */
+    public void deleteMessage(MessageID msgID, FutureCallback<Boolean> callback);
+
+    /**
+     * Deletes a message from the Bulletin Board in a possibly asynchronous manner
+     * Logs this action
+     * @param entryNum is the serial entry number of the message to delete
+     * @param callback handles the result of the operation
+     */
+    public void deleteMessage(long entryNum, FutureCallback<Boolean> callback);
+
+    /**
+     * Deletes a message from a Bulletin Board Server in a synchronous manner
+     * Logs this action
+     * @param msgID is the ID of the message to delete
+     * @return TRUE if the message was deleted and FALSE if it did not exist on the server
+     * @throws CommunicationException when an error occurs
+     */
+    public boolean deleteMessage(MessageID msgID) throws CommunicationException;
+
+    /**
+     * Deletes a message from the Bulletin Board in a synchronous manner
+     * Logs this action
+     * @param entryNum is the serial entry number of the message to delete
+     * @return TRUE if the message was deleted and FALSE if it did not exist on the server
+     * @throws CommunicationException when an error occurs
+     */
+    public boolean deleteMessage(long entryNum) throws CommunicationException;
+
+}

meerkat-common/src/main/java/meerkat/bulletinboard/BulletinBoardServer.java

@@ -1,12 +1,12 @@
 package meerkat.bulletinboard;
 
 import com.google.protobuf.BoolValue;
+import com.google.protobuf.Int32Value;
+import com.google.protobuf.Int64Value;
 import meerkat.comm.CommunicationException;
 import meerkat.comm.MessageOutputStream;
 import meerkat.protobuf.BulletinBoardAPI.*;
 
-import java.util.Collection;
-
 
 /**
  * Created by Arbel on 07/11/15.
@@ -22,7 +22,7 @@ public interface BulletinBoardServer{
 	 * It also establishes the connection to the DB
 	 * @throws CommunicationException on DB connection error
 	 */
-	public void init(String meerkatDB) throws CommunicationException;
+	public void init() throws CommunicationException;
 	
 	/**
      * Post a message to bulletin board.
@@ -33,7 +33,7 @@ public interface BulletinBoardServer{
 	public BoolValue postMessage(BulletinBoardMessage msg) throws CommunicationException;
 
 	 /**
-	  * Read all messages posted matching the given filter
+	  * Read all posted messages matching the given filters
 	  * @param filterList return only messages that match the filters (empty list or null means no filtering)
 	  * @param out is an output stream into which the matching messages are written
 	  * @throws CommunicationException on DB connection error
@@ -41,17 +41,23 @@ public interface BulletinBoardServer{
 	public void readMessages(MessageFilterList filterList, MessageOutputStream<BulletinBoardMessage> out) throws CommunicationException;
 
 	/**
-	 * Informs server about a new batch message
-	 * @param message contains the required data about the new batch
-	 * @return TRUE if the batch request is accepted amd FALSE otherwise
-	 * 		Specifically, if such a batch already exists and is not yet closed: the value returned will be TRUE
-	 * 		However, if such a batch exists and is already closed: the value returned will be FALSE
+	 * Return the number of posted messages matching the given filters
+	 * @param filterList count only messages that match the filters (empty list or null means no filtering)
+	 * @return an IntMsg containing the number of messages that match the filter
 	 * @throws CommunicationException on DB connection error
 	 */
-	public BoolValue beginBatch(BeginBatchMessage message) throws CommunicationException;
+	public Int32Value getMessageCount(MessageFilterList filterList) throws CommunicationException;
 
 	/**
-	 * Posts a (part of a) batch message to the bulletin board
+	 * Informs server about a new batch message
+	 * @param message contains the required data about the new batch
+	 * @return a unique batch identifier for the new batch ; -1 if batch creation was unsuccessful
+	 * @throws CommunicationException on DB connection error
+     */
+	public Int64Value beginBatch(BeginBatchMessage message) throws CommunicationException;
+
+	/**
+	 * Posts a chunk of a batch message to the bulletin board
 	 * Note that the existence and contents of a batch message are not available for reading before the batch is finalized
 	 * @param batchMessage contains the (partial) data this message carries as well as meta-data required in order to place the data
 	 *                     in the correct position inside the correct batch
@@ -63,22 +69,22 @@ public interface BulletinBoardServer{
 	public BoolValue postBatchMessage(BatchMessage batchMessage) throws CommunicationException;
 
 	/**
-	 * Attempts to stop and finalize a batch message
-	 * @param message contains the data necessary to stop the batch; in particular: the signature for the batch
+	 * Attempts to close and finalize a batch message
+	 * @param message contains the data necessary to close the batch; in particular: the signature for the batch
 	 * @return TRUE if the batch was successfully closed, FALSE otherwise
 	 * 		Specifically, if the signature is invalid or if some of the batch parts have not yet been submitted: the value returned will be FALSE
 	 * @throws CommunicationException on DB connection error
      */
-	public BoolValue closeBatchMessage(CloseBatchMessage message) throws CommunicationException;
+	public BoolValue closeBatch(CloseBatchMessage message) throws CommunicationException;
 
 	/**
 	 * Reads a batch message from the server (starting with the supplied position)
-	 * @param message specifies the signer ID and the batch ID to read as well as an (optional) start position
+	 * @param batchQuery specifies which batch and what parts of it to retrieve
 	 * @param out is a stream of the ordered batch messages starting from the specified start position (if given) or from the beginning (if omitted)
 	 * @throws CommunicationException on DB connection error
-	 * @throws IllegalArgumentException if message does not specify a batch
+	 * @throws IllegalArgumentException if message ID does not specify a batch
      */
-	public void readBatch(BatchSpecificationMessage message, MessageOutputStream<BatchData> out) throws CommunicationException, IllegalArgumentException;
+	public void readBatch(BatchQuery batchQuery, MessageOutputStream<BatchChunk> out) throws CommunicationException, IllegalArgumentException;
 
 	/**
 	 * Create a SyncQuery to test against that corresponds with the current server state for a specific filter list
@@ -86,7 +92,7 @@ public interface BulletinBoardServer{
 	 * @return The generated SyncQuery
 	 * @throws CommunicationException on DB connection error
 	 */
-	SyncQuery generateSyncQuery(GenerateSyncQueryParams generateSyncQueryParams) throws CommunicationException;
+	public SyncQuery generateSyncQuery(GenerateSyncQueryParams generateSyncQueryParams) throws CommunicationException;
 
 	/**
 	 * Queries the database for sync status with respect to a given sync query

meerkat-common/src/main/java/meerkat/bulletinboard/BulletinBoardSignature.java

@@ -0,0 +1,31 @@
+package meerkat.bulletinboard;
+
+import meerkat.crypto.DigitalSignature;
+import meerkat.protobuf.BulletinBoardAPI.BulletinBoardMessage;
+import meerkat.protobuf.BulletinBoardAPI.UnsignedBulletinBoardMessage;
+import meerkat.protobuf.Crypto;
+
+import java.security.SignatureException;
+
+/**
+ * Created by Arbel Deutsch Peled on 18-Dec-15.
+ * Extends the DigitalSignature interface with methods for signing Bulletin Board messages
+ */
+public interface BulletinBoardSignature extends DigitalSignature {
+
+    /**
+     * Add msg to the content stream to be verified / signed
+     * The digest only uses the part the signatures are computed on for this operation
+     * If the message is a stub: this should be called before updating with the raw data
+     * @param msg is the message that needs to be digested
+     */
+    public void updateContent(BulletinBoardMessage msg) throws SignatureException;
+
+    /**
+     * Add msg to the content stream to be verified / signed
+     * If the message is a stub: this should be called before updating with the raw data
+     * @param msg is the message that needs to be digested
+     */
+    public void updateContent(UnsignedBulletinBoardMessage msg) throws SignatureException;
+
+}

meerkat-common/src/main/java/meerkat/bulletinboard/BulletinBoardSynchronizer.java

@@ -1,22 +1,84 @@
 package meerkat.bulletinboard;
 
+import meerkat.comm.CommunicationException;
+import meerkat.protobuf.BulletinBoardAPI.*;
+
+import com.google.common.util.concurrent.FutureCallback;
+
+import java.util.List;
+
 /**
  * Created by Arbel Deutsch Peled on 08-Mar-16.
  * This interface defines the behaviour of a bulletin board synchronizer
  * This is used to make sure that data in a specific instance of a bulletin board server is duplicated to a sufficient percentage of the other servers
  */
-public interface BulletinBoardSynchronizer extends Runnable{
+public interface BulletinBoardSynchronizer extends Runnable {
+
+    public enum SyncStatus{
+        SYNCHRONIZED,   // No more messages to upload
+        PENDING,        // Synchronizer is querying for data to upload and uploading it as needed
+        SERVER_ERROR,   // Synchronizer encountered an error while uploading, but will retry
+        STOPPED         // Stopped/Not started by user
+    }
 
     /**
-     *
-     * @param localClient is a client for the local DB instance
-     * @param remoteClient is a client for the remote DBs
-     * @param minRedundancy
+     * Initializes the synchronizer with the required data to function properly
+     * @param localClient is a client for the temporary local storage server which contains only data to be uploaded
+     * @param remoteClient is a client for the remote servers into which the data needs to be uploaded
      */
-    public void init(BulletinBoardClient localClient, AsyncBulletinBoardClient remoteClient, float minRedundancy);
+    public void init(DeletableSubscriptionBulletinBoardClient localClient, AsyncBulletinBoardClient remoteClient);
 
+    /**
+     * Returns the current server synchronization status
+     * @return the current synchronization status
+     */
+    public SyncStatus getSyncStatus();
+
+    /**
+     * Creates a subscription to sync status changes
+     * @param callback is the handler for any status changes
+     */
+    public void subscribeToSyncStatus(FutureCallback<SyncStatus> callback);
+
+    /**
+     * Returns the messages which have not yet been synchronized
+     * @return the list of messages remaining to be synchronized
+     */
+    public List<BulletinBoardMessage> getRemainingMessages() throws CommunicationException;
+
+    /**
+     * Asynchronously returns the messages which have not yet been synchronized
+     * @param callback is the handler for the list of messages
+     */
+    public void getRemainingMessages(FutureCallback<List<BulletinBoardMessage>> callback);
+
+    /**
+     * Returns the current number of unsynchronized messages
+     * @return the current synchronization status
+     */
+    public long getRemainingMessagesCount() throws CommunicationException;
+
+    /**
+     * Creates a subscription to changes in the number of unsynchronized messages
+     * @param callback is the handler for any status changes
+     */
+    public void subscribeToRemainingMessagesCount(FutureCallback<Integer> callback);
+
+    /**
+     * Starts the synchronization
+     */
     @Override
     public void run();
 
+    /**
+     * Lets the Synchronizer know that there is new data to be uploaded
+     * This is used to reduce the latency between local data-writes and uploads to the remote servers
+     */
+    public void nudge();
+
+    /**
+     * Stops the synchronization
+     */
+    public void stop();
 
 }

meerkat-common/src/main/java/meerkat/bulletinboard/CompleteBatch.java

@@ -1,150 +0,0 @@
-package meerkat.bulletinboard;
-
-import com.google.protobuf.Timestamp;
-import meerkat.protobuf.BulletinBoardAPI.*;
-import meerkat.protobuf.Crypto.*;
-import meerkat.util.BulletinBoardMessageComparator;
-
-import java.util.LinkedList;
-import java.util.List;
-
-/**
- * Created by Arbel Deutsch Peled on 14-Dec-15.
- *
- * A data structure for holding a complete batch message along with its signature
- */
-public class CompleteBatch {
-
-    private BeginBatchMessage beginBatchMessage;
-    private List<BatchData> batchDataList;
-    private Signature signature;
-    private Timestamp timestamp;
-
-    public CompleteBatch() {
-        batchDataList = new LinkedList<BatchData>();
-    }
-
-    public CompleteBatch(BeginBatchMessage newBeginBatchMessage) {
-        this();
-        beginBatchMessage = newBeginBatchMessage;
-    }
-
-    public CompleteBatch(BeginBatchMessage newBeginBatchMessage, List<BatchData> newDataList) {
-        this(newBeginBatchMessage);
-        appendBatchData(newDataList);
-    }
-
-    public CompleteBatch(BeginBatchMessage newBeginBatchMessage, List<BatchData> newDataList, Signature newSignature) {
-        this(newBeginBatchMessage, newDataList);
-        signature = newSignature;
-    }
-
-    public CompleteBatch(BeginBatchMessage newBeginBatchMessage, List<BatchData> newDataList, Signature newSignature, Timestamp timestamp) {
-        this(newBeginBatchMessage, newDataList, newSignature);
-        this.timestamp = timestamp;
-    }
-
-    public CompleteBatch(Timestamp timestamp) {
-        this();
-        this.timestamp = timestamp;
-    }
-
-    public BeginBatchMessage getBeginBatchMessage() {
-        return beginBatchMessage;
-    }
-
-    public List<BatchData> getBatchDataList() {
-        return batchDataList;
-    }
-
-    public Signature getSignature() {
-        return signature;
-    }
-
-    public Timestamp getTimestamp() {
-        return timestamp;
-    }
-
-    public CloseBatchMessage getCloseBatchMessage() {
-        return CloseBatchMessage.newBuilder()
-                .setBatchId(getBeginBatchMessage().getBatchId())
-                .setBatchLength(getBatchDataList().size())
-                .setSig(getSignature())
-                .setTimestamp(getTimestamp())
-                .build();
-    }
-
-    public void setBeginBatchMessage(BeginBatchMessage beginBatchMessage) {
-        this.beginBatchMessage = beginBatchMessage;
-    }
-
-    public void appendBatchData(BatchData newBatchData) {
-        batchDataList.add(newBatchData);
-    }
-
-    public void appendBatchData(List<BatchData> newBatchDataList) {
-        batchDataList.addAll(newBatchDataList);
-    }
-
-    public void setSignature(Signature newSignature) {
-        signature = newSignature;
-    }
-
-    public void setTimestamp(Timestamp timestamp) {
-        this.timestamp = timestamp;
-    }
-
-    @Override
-    public boolean equals(Object other) {
-
-        if (!(other instanceof CompleteBatch)) {
-            return false;
-        }
-
-        CompleteBatch otherBatch = (CompleteBatch) other;
-
-        boolean result = true;
-
-        if (beginBatchMessage == null) {
-            if (otherBatch.getBeginBatchMessage() != null)
-                return false;
-        } else {
-            result = result && beginBatchMessage.equals(otherBatch.getBeginBatchMessage());
-        }
-
-        if (batchDataList == null) {
-            if (otherBatch.getBatchDataList() != null)
-                return false;
-        } else {
-            result = result && batchDataList.equals(otherBatch.getBatchDataList());
-        }
-
-        if (signature == null) {
-            if (otherBatch.getSignature() != null)
-                return false;
-        } else {
-            result = result && signature.equals(otherBatch.getSignature());
-        }
-
-        if (timestamp == null) {
-            if (otherBatch.getTimestamp() != null)
-                return false;
-        } else {
-            result = result && timestamp.equals(otherBatch.getTimestamp());
-        }
-
-        return result;
-
-    }
-
-    @Override
-    public String toString() {
-
-        if (beginBatchMessage == null || beginBatchMessage.getSignerId() == null)
-            return "Unspecified batch " + super.toString();
-
-        return "Batch " + beginBatchMessage.getSignerId().toString() + ":" + beginBatchMessage.getBatchId();
-
-    }
-
-}

meerkat-common/src/main/java/meerkat/bulletinboard/DeletableBulletinBoardServer.java

@@ -0,0 +1,32 @@
+package meerkat.bulletinboard;
+
+import com.google.protobuf.BoolValue;
+import meerkat.comm.CommunicationException;
+import meerkat.protobuf.BulletinBoardAPI.*;
+
+/**
+ * Created by Arbel Deutsch Peled on 13-Apr-16.
+ */
+public interface DeletableBulletinBoardServer extends BulletinBoardServer {
+
+    /**
+     * Deletes a message from the Bulletin Board
+     * If the message is a batch: the batch data is deleted as well
+     * Logs this action
+     * @param msgID is the ID of the message to delete
+     * @return a BoolMsg containing the value TRUE if a message was deleted, FALSE if the message does not exist
+     * @throws CommunicationException in case of an error
+     */
+    public BoolValue deleteMessage(MessageID msgID) throws CommunicationException;
+
+    /**
+     * Deletes a message from the Bulletin Board
+     * If the message is a batch: the batch data is deleted as well
+     * Logs this action
+     * @param entryNum is the serial entry number of the message to delete
+     * @return a BoolMsg containing the value TRUE if a message was deleted, FALSE if the message does not exist
+     * @throws CommunicationException in case of an error
+     */
+    public BoolValue deleteMessage(long entryNum) throws CommunicationException;
+
+}

meerkat-common/src/main/java/meerkat/bulletinboard/DeletableSubscriptionBulletinBoardClient.java

@@ -0,0 +1,7 @@
+package meerkat.bulletinboard;
+
+/**
+ * Created by Arbel Deutsch Peled on 13-Apr-16.
+ */
+public interface DeletableSubscriptionBulletinBoardClient extends SubscriptionBulletinBoardClient, BulletinBoardMessageDeleter {
+}

meerkat-common/src/main/java/meerkat/bulletinboard/GenericBatchDigest.java

@@ -1,61 +0,0 @@
-package meerkat.bulletinboard;
-
-import com.google.protobuf.Message;
-import meerkat.crypto.Digest;
-import meerkat.protobuf.BulletinBoardAPI.MessageID;
-import meerkat.protobuf.BulletinBoardAPI.BatchData;
-
-import java.util.List;
-
-
-/**
- * Created by Arbel Deutsch Peled on 19-Dec-15.
- * Wrapper class for digesting Batches in a standardized way
- */
-public class GenericBatchDigest implements BatchDigest{
-
-    private Digest digest;
-
-    public GenericBatchDigest(Digest digest) {
-        this.digest = digest;
-    }
-
-    @Override
-    public void update(CompleteBatch completeBatch) {
-
-        update(completeBatch.getBeginBatchMessage());
-
-        for (BatchData batchData : completeBatch.getBatchDataList()) {
-            update(batchData);
-        }
-
-        update(completeBatch.getTimestamp());
-
-    }
-
-    @Override
-    public byte[] digest() {
-        return digest.digest();
-    }
-
-    @Override
-    public MessageID digestAsMessageID() {
-        return digest.digestAsMessageID();
-    }
-
-    @Override
-    public void update(Message msg) {
-        digest.update(msg);
-    }
-
-    @Override
-    public void reset() {
-        digest.reset();
-    }
-
-    @Override
-    public GenericBatchDigest clone() throws CloneNotSupportedException{
-        return new GenericBatchDigest(digest.clone());
-    }
-
-}

meerkat-common/src/main/java/meerkat/bulletinboard/GenericBatchDigitalSignature.java

@@ -1,104 +0,0 @@
-package meerkat.bulletinboard;
-
-import com.google.protobuf.ByteString;
-import com.google.protobuf.Message;
-import meerkat.crypto.DigitalSignature;
-import meerkat.protobuf.BulletinBoardAPI.BatchData;
-import meerkat.protobuf.Crypto;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.security.InvalidKeyException;
-import java.security.KeyStore;
-import java.security.KeyStoreException;
-import java.security.SignatureException;
-import java.security.NoSuchAlgorithmException;
-import java.security.UnrecoverableKeyException;
-import java.security.cert.CertificateException;
-
-/**
- * Created by Arbel Deutsch Peled on 20-Dec-15.
- * Wrapper class for signing and verifying Batch signatures in a standardized way
- */
-public class GenericBatchDigitalSignature implements BatchDigitalSignature{
-
-    private DigitalSignature digitalSignature;
-
-    public GenericBatchDigitalSignature(DigitalSignature digitalSignature) {
-        this.digitalSignature = digitalSignature;
-    }
-
-    @Override
-    public void updateContent(CompleteBatch completeBatch) throws SignatureException {
-
-        digitalSignature.updateContent(completeBatch.getBeginBatchMessage());
-
-        for (BatchData batchData : completeBatch.getBatchDataList()) {
-            digitalSignature.updateContent(batchData);
-        }
-
-        digitalSignature.updateContent(completeBatch.getTimestamp());
-
-    }
-
-    @Override
-    public boolean verify(CompleteBatch completeBatch) throws SignatureException, CertificateException, InvalidKeyException {
-
-        digitalSignature.initVerify(completeBatch.getSignature());
-        updateContent(completeBatch);
-        return digitalSignature.verify();
-
-    }
-
-    @Override
-    public void loadVerificationCertificates(InputStream certStream) throws CertificateException {
-        digitalSignature.loadVerificationCertificates(certStream);
-    }
-
-    @Override
-    public void clearVerificationCertificates() {
-        digitalSignature.clearVerificationCertificates();
-    }
-
-    @Override
-    public void updateContent(Message msg) throws SignatureException {
-        digitalSignature.updateContent(msg);
-    }
-
-    @Override
-    public Crypto.Signature sign() throws SignatureException {
-        return digitalSignature.sign();
-    }
-
-    @Override
-    public void initVerify(Crypto.Signature sig) throws CertificateException, InvalidKeyException {
-        digitalSignature.initVerify(sig);
-    }
-
-    @Override
-    public boolean verify() {
-        return digitalSignature.verify();
-    }
-
-    @Override
-    public KeyStore.Builder getPKCS12KeyStoreBuilder(InputStream keyStream, char[] password)
-            throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException {
-        return digitalSignature.getPKCS12KeyStoreBuilder(keyStream, password);
-    }
-
-    @Override
-    public void loadSigningCertificate(KeyStore.Builder keyStoreBuilder) throws IOException, CertificateException, UnrecoverableKeyException {
-        digitalSignature.loadSigningCertificate(keyStoreBuilder);
-    }
-
-    @Override
-    public ByteString getSignerID() {
-        return digitalSignature.getSignerID();
-    }
-
-    @Override
-    public void clearSigningKey() {
-        digitalSignature.clearSigningKey();
-    }
-
-}

meerkat-common/src/main/java/meerkat/bulletinboard/GenericBulletinBoardDigest.java

@@ -0,0 +1,74 @@
+package meerkat.bulletinboard;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.BytesValue;
+import com.google.protobuf.Message;
+import meerkat.crypto.Digest;
+import meerkat.protobuf.BulletinBoardAPI;
+import meerkat.protobuf.BulletinBoardAPI.*;
+import meerkat.protobuf.BulletinBoardAPI.MessageID;
+
+
+/**
+ * Created by Arbel Deutsch Peled on 19-Dec-15.
+ * Wrapper class for digesting Batches in a standardized way
+ */
+public class GenericBulletinBoardDigest implements BulletinBoardDigest {
+
+    private Digest digest;
+
+    public GenericBulletinBoardDigest(Digest digest) {
+        this.digest = digest;
+    }
+
+    @Override
+    public byte[] digest() {
+        return digest.digest();
+    }
+
+    @Override
+    public MessageID digestAsMessageID() {
+        return digest.digestAsMessageID();
+    }
+
+    @Override
+    public void update(Message msg) {
+        digest.update(msg);
+    }
+
+    @Override
+    public void update(byte[] data) {
+        digest.update(data);
+    }
+
+    @Override
+    public void reset() {
+        digest.reset();
+    }
+
+    @Override
+    public GenericBulletinBoardDigest clone() throws CloneNotSupportedException{
+        return new GenericBulletinBoardDigest(digest.clone());
+    }
+
+    @Override
+    public void update(BulletinBoardMessage msg) {
+        update(msg.getMsg());
+    }
+
+    @Override
+    public void update(UnsignedBulletinBoardMessage msg) {
+
+        for (ByteString tag : msg.getTagList().asByteStringList()){
+            update(tag.toByteArray());
+        }
+
+        update(msg.getTimestamp());
+
+        if (msg.getDataTypeCase() == UnsignedBulletinBoardMessage.DataTypeCase.DATA){
+            update(msg.getData().toByteArray());
+        }
+
+    }
+
+}

meerkat-common/src/main/java/meerkat/bulletinboard/GenericBulletinBoardSignature.java

@@ -0,0 +1,106 @@
+package meerkat.bulletinboard;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Message;
+import meerkat.crypto.Digest;
+import meerkat.crypto.DigitalSignature;
+import meerkat.protobuf.BulletinBoardAPI;
+import meerkat.protobuf.BulletinBoardAPI.BulletinBoardMessage;
+import meerkat.protobuf.BulletinBoardAPI.MessageID;
+import meerkat.protobuf.BulletinBoardAPI.UnsignedBulletinBoardMessage;
+import meerkat.protobuf.Crypto;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.*;
+import java.security.cert.CertificateException;
+
+
+/**
+ * Created by Arbel Deutsch Peled on 19-Dec-15.
+ * Wrapper class for digesting Batches in a standardized way
+ */
+public class GenericBulletinBoardSignature implements BulletinBoardSignature {
+
+    private DigitalSignature signer;
+
+    public GenericBulletinBoardSignature(DigitalSignature signer) {
+        this.signer = signer;
+    }
+
+    @Override
+    public void updateContent(BulletinBoardMessage msg) throws SignatureException{
+        signer.updateContent(msg.getMsg());
+    }
+
+    @Override
+    public void updateContent(UnsignedBulletinBoardMessage msg) throws SignatureException{
+
+        for (ByteString tag : msg.getTagList().asByteStringList()){
+            updateContent(tag.toByteArray());
+        }
+
+        updateContent(msg.getTimestamp());
+
+        if (msg.getDataTypeCase() == UnsignedBulletinBoardMessage.DataTypeCase.DATA){
+            updateContent(msg.getData().toByteArray());
+        }
+
+    }
+
+    @Override
+    public void loadVerificationCertificates(InputStream certStream) throws CertificateException {
+        signer.loadVerificationCertificates(certStream);
+    }
+
+    @Override
+    public void clearVerificationCertificates() {
+        signer.clearVerificationCertificates();
+    }
+
+    @Override
+    public void updateContent(byte[] data) throws SignatureException {
+        signer.updateContent(data);
+    }
+
+    @Override
+    public void updateContent(Message msg) throws SignatureException {
+        signer.updateContent(msg);
+    }
+
+    @Override
+    public Crypto.Signature sign() throws SignatureException {
+        return signer.sign();
+    }
+
+    @Override
+    public void initVerify(Crypto.Signature sig) throws CertificateException, InvalidKeyException {
+        signer.initVerify(sig);
+    }
+
+    @Override
+    public boolean verify() {
+        return signer.verify();
+    }
+
+    @Override
+    public KeyStore.Builder getPKCS12KeyStoreBuilder(InputStream keyStream, char[] password) throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException {
+        return signer.getPKCS12KeyStoreBuilder(keyStream, password);
+    }
+
+    @Override
+    public void loadSigningCertificate(KeyStore.Builder keyStoreBuilder) throws IOException, CertificateException, UnrecoverableKeyException {
+        signer.loadSigningCertificate(keyStoreBuilder);
+    }
+
+    @Override
+    public ByteString getSignerID() {
+        return signer.getSignerID();
+    }
+
+    @Override
+    public void clearSigningKey() {
+        signer.clearSigningKey();
+    }
+
+}

meerkat-common/src/main/java/meerkat/bulletinboard/SubscriptionAsyncBulletinBoardClient.java

@@ -1,7 +0,0 @@
-package meerkat.bulletinboard;
-
-/**
- * Created by Arbel Deutsch Peled on 03-Mar-16.
- */
-public interface SubscriptionAsyncBulletinBoardClient extends AsyncBulletinBoardClient, BulletinBoardSubscriber {
-}

meerkat-common/src/main/java/meerkat/bulletinboard/SubscriptionBulletinBoardClient.java

@@ -0,0 +1,7 @@
+package meerkat.bulletinboard;
+
+/**
+ * Created by Arbel Deutsch Peled on 03-Mar-16.
+ */
+public interface SubscriptionBulletinBoardClient extends AsyncBulletinBoardClient, BulletinBoardSubscriber {
+}

meerkat-common/src/main/java/meerkat/crypto/Digest.java

@@ -22,6 +22,12 @@ public interface Digest {
      */
     public MessageID digestAsMessageID();
 
+    /**
+     * Updates the digest using the given raw data
+     * @param data contains the raw data
+     */
+    public void update (byte[] data);
+
     /**
      * Updates the digest using the specified message (in serialized wire form)
      *

meerkat-common/src/main/java/meerkat/crypto/DigitalSignature.java

@@ -39,6 +39,13 @@ public interface DigitalSignature {
      */
     public void clearVerificationCertificates();
 
+    /**
+     * Add raw data to the content stream to be verified / signed.
+     *
+     * @param data
+     * @throws SignatureException
+     */
+    public void updateContent(byte[] data) throws SignatureException;
 
     /**
      * Add msg to the content stream to be verified / signed. Each message is (automatically)

meerkat-common/src/main/java/meerkat/crypto/concrete/ECDSASignature.java

@@ -140,6 +140,11 @@ public class ECDSASignature implements DigitalSignature {
         signer.update(msg.toByteString().asReadOnlyByteBuffer());
     }
 
+    @Override
+    public void updateContent(byte[] data) throws SignatureException {
+        signer.update(data);
+    }
+
     public void updateContent(InputStream in) throws IOException, SignatureException {
         ByteString inStr = ByteString.readFrom(in);
         signer.update(inStr.asReadOnlyByteBuffer());

meerkat-common/src/main/java/meerkat/crypto/concrete/SHA256Digest.java

@@ -80,6 +80,7 @@ public class SHA256Digest implements Digest {
         hash.update(msg.asReadOnlyByteBuffer());
     }
 
+    @Override
     final public void update(byte[] msg) {
         hash.update(msg);
     }

meerkat-common/src/main/java/meerkat/util/BulletinBoardMessageComparator.java

@@ -5,6 +5,7 @@ import meerkat.protobuf.BulletinBoardAPI.*;
 import meerkat.protobuf.Crypto.*;
 
 import java.util.Comparator;
+import java.util.Iterator;
 import java.util.List;
 
 /**
@@ -24,22 +25,55 @@ public class BulletinBoardMessageComparator implements Comparator<BulletinBoardM
     @Override
     public int compare(BulletinBoardMessage msg1, BulletinBoardMessage msg2) {
 
-        List<Signature> msg1Sigs = msg1.getSigList();
-        List<Signature> msg2Sigs = msg2.getSigList();
 
-        // Compare unsigned message
-        if (!msg1.getMsg().equals(msg2.getMsg())){
+
+        // Compare Timestamps
+
+        if (!msg1.getMsg().getTimestamp().equals(msg2.getMsg().getTimestamp())){
             return -1;
         }
 
-        // Compare signatures
+        // Compare tags (enforce order)
 
-        if (msg1Sigs.size() != msg2Sigs.size()){
+        List<String> tags1 = msg1.getMsg().getTagList();
+        Iterator<String> tags2 = msg2.getMsg().getTagList().iterator();
+
+        for (String tag : tags1){
+            if (!tags2.hasNext()) {
+                return -1;
+            }
+            if (!tags2.next().equals(tag)){
+                return -1;
+            }
+        }
+
+        // Compare data
+
+        if (msg1.getMsg().getDataTypeCase() != msg2.getMsg().getDataTypeCase()){
             return -1;
         }
 
-        for (Signature sig : msg1Sigs){
-            if (!msg2Sigs.contains(sig)) {
+        if (msg1.getMsg().getDataTypeCase() == UnsignedBulletinBoardMessage.DataTypeCase.DATA){
+            if (!msg1.getMsg().getData().equals(msg2.getMsg().getData())){
+                return -1;
+            }
+        } else if (msg1.getMsg().getDataTypeCase() == UnsignedBulletinBoardMessage.DataTypeCase.MSGID){
+            if (!msg1.getMsg().getMsgId().equals(msg2.getMsg().getMsgId())){
+                return -1;
+            }
+        }
+
+        // Compare signatures (do not enforce order)
+
+        List<Signature> sigs1 = msg1.getSigList();
+        List<Signature> sigs2 = msg2.getSigList();
+
+        if (sigs1.size() != sigs2.size()){
+            return -1;
+        }
+
+        for (Signature sig : sigs1){
+            if (!sigs2.contains(sig)) {
                 return -1;
             }
         }

meerkat-common/src/main/java/meerkat/util/BulletinBoardMessageGenerator.java

@@ -7,7 +7,6 @@ import com.google.protobuf.Timestamp;
 
 import java.math.BigInteger;
 import java.security.SignatureException;
-import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Random;
@@ -28,10 +27,33 @@ public class BulletinBoardMessageGenerator {
         return (byte) random.nextInt();
     }
 
+    private byte[] randomBytes(int length) {
+
+        byte[] result = new byte[length];
+
+        for (int i = 0; i < length; i++) {
+            result[i] = randomByte();
+        }
+
+        return result;
+    }
+
     private String randomString(){
         return new BigInteger(130, random).toString(32);
     }
 
+    private List<String> randomStrings(int length) {
+
+        List<String> result = new LinkedList<>();
+
+        for (int i = 0; i < length; i++) {
+            result.add(randomString());
+        }
+
+        return result;
+
+    }
+
     /**
      * Generates a complete instance of a BulletinBoardMessage
      * @param signers contains the (possibly multiple) credentials required to sign the message
@@ -46,23 +68,16 @@ public class BulletinBoardMessageGenerator {
 
         // Generate random data.
 
-        byte[] data = new byte[dataSize];
-        String[] newTags = new String[tagNumber];
 
-        for (int i = 0; i < dataSize; i++) {
-            data[i] = randomByte();
-        }
 
-        for (int i = 0; i < tagNumber; i++) {
-            newTags[i] = randomString();
-        }
+
 
         UnsignedBulletinBoardMessage unsignedMessage =
                 UnsignedBulletinBoardMessage.newBuilder()
-                        .setData(ByteString.copyFrom(data))
+                        .setData(ByteString.copyFrom(randomBytes(dataSize)))
                         .setTimestamp(timestamp)
                         .addAllTag(tags)
-                        .addAllTag(Arrays.asList(newTags))
+                        .addAllTag(randomStrings(tagNumber))
                         .build();
 
         BulletinBoardMessage.Builder messageBuilder =
@@ -102,7 +117,6 @@ public class BulletinBoardMessageGenerator {
      * @param tagNumber is the number of tags to generate
      * @return a random, signed Bulletin Board Message containing random data, tags and timestamp
      */
-
     public BulletinBoardMessage generateRandomMessage(DigitalSignature[] signers, int dataSize, int tagNumber)
             throws SignatureException {
 

meerkat-common/src/main/java/meerkat/util/BulletinBoardUtils.java

@@ -1,7 +1,10 @@
 package meerkat.util;
 
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Int64Value;
 import meerkat.protobuf.BulletinBoardAPI.*;
 
+import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -104,4 +107,129 @@ public class BulletinBoardUtils {
         return new java.sql.Timestamp(protoTimestamp.getSeconds() * 1000 + protoTimestamp.getNanos() / 1000000);
     }
 
+    /**
+     * Breaks up a bulletin board message into chunks
+     * @param msg is the complete message
+     * @return a list of BatchChunks that contains the raw message data
+     */
+    public static List<BatchChunk> breakToBatch(BulletinBoardMessage msg, int chunkSize) {
+
+        byte[] data = msg.getMsg().getData().toByteArray();
+
+        int chunkNum = data.length / chunkSize;
+        if (data.length % chunkSize != 0)
+            chunkNum++;
+
+        List<BatchChunk> chunkList = new ArrayList<>(chunkNum);
+
+        int location = 0;
+
+        for (int i=0 ; i < chunkNum ; i++) {
+
+            int chunkLength;
+
+            if (i == chunkNum - 1){
+                chunkLength = data.length % chunkSize;
+                if (chunkLength == 0){
+                    chunkLength = chunkSize;
+                }
+            } else{
+                chunkLength = chunkSize;
+            }
+
+            chunkList.add(BatchChunk.newBuilder()
+                    .setData(ByteString.copyFrom(data, location, chunkLength))
+                    .build());
+
+            location += chunkLength;
+
+        }
+
+        return chunkList;
+
+    }
+
+    /**
+     * Removes concrete data from the message and turns it into a stub
+     * Note that the stub does not contain the message ID
+     * Therefore, it cannot be used to retrieve the message from a server
+     * @param msg is the original message
+     * @return the message stub
+     */
+    public static BulletinBoardMessage makeStub(BulletinBoardMessage msg) {
+
+        return BulletinBoardMessage.newBuilder()
+                .mergeFrom(msg)
+                .setMsg(UnsignedBulletinBoardMessage.newBuilder()
+                        .mergeFrom(msg.getMsg())
+                        .clearDataType()
+                        .clearData()
+                        .build())
+                .build();
+
+    }
+
+    /**
+     * Merges a batch chunk list back into a message stub to create a complete Bulletin Board message
+     * @param msgStub is a message stub
+     * @param chunkList contains the (ordered) data of the batch message
+     * @return a complete message containing both data and metadata
+     */
+    public static BulletinBoardMessage gatherBatch(BulletinBoardMessage msgStub, List<BatchChunk> chunkList) {
+
+        List<ByteString> dataList = new LinkedList<>();
+
+        for (BatchChunk chunk : chunkList){
+            dataList.add(chunk.getData());
+        }
+
+        return BulletinBoardMessage.newBuilder()
+                .mergeFrom(msgStub)
+                .setMsg(UnsignedBulletinBoardMessage.newBuilder()
+                        .mergeFrom(msgStub.getMsg())
+                        .setData(ByteString.copyFrom(dataList))
+                        .build())
+                .build();
+
+    }
+
+    /**
+     * Gerenates a BeginBatchMessage Protobuf which is used to begin uploading a message as a batch
+     * @param msg is the Bulletin Board message to be uploaded, which can be a stub or a complete message
+     * @return the required BeginBatchMessage
+     */
+    public static BeginBatchMessage generateBeginBatchMessage(BulletinBoardMessage msg) {
+
+        if (msg.getSigCount() <= 0){
+            throw new IllegalArgumentException("No signatures found");
+        }
+
+        return BeginBatchMessage.newBuilder()
+                .addAllTag(msg.getMsg().getTagList())
+                .build();
+
+    }
+
+    /**
+     * Gerenates a CloseBatchMessage Protobuf which is used to finalize a batch message
+     * @param batchId is the temporary identifier for the message
+     * @param batchLength is the number of chunks in the batch
+     * @param msg is the Bulletin Board message that was uploaded (and can also be a stub of said message)
+     * @throws IllegalArgumentException if the message contains no signatures
+     */
+    public static CloseBatchMessage generateCloseBatchMessage(Int64Value batchId, int batchLength, BulletinBoardMessage msg) {
+
+        if (msg.getSigCount() <= 0){
+            throw new IllegalArgumentException("No signatures found");
+        }
+
+        return CloseBatchMessage.newBuilder()
+                .setTimestamp(msg.getMsg().getTimestamp())
+                .setBatchLength(batchLength)
+                .setBatchId(batchId.getValue())
+                .addAllSig(msg.getSigList())
+                .build();
+
+    }
+
 }

meerkat-common/src/main/proto/meerkat/BulletinBoardAPI.proto

@@ -20,8 +20,18 @@ message UnsignedBulletinBoardMessage {
     // Timestamp of the message (as defined by client)
     google.protobuf.Timestamp timestamp = 2;
 
+    // The payload of the message
+    oneof dataType{
+
+        // A unique message identifier
+        bytes msgId = 3;
+
         // The actual content of the message
-    bytes data = 3;
+        bytes data = 4;
+
+    }
+
+
 }
 
 message BulletinBoardMessage {
@@ -82,42 +92,32 @@ message MessageFilterList {
 
 // This message is used to start a batch transfer to the Bulletin Board Server
 message BeginBatchMessage {
-    bytes signerId = 1;             // Unique signer identifier
-    int32 batchId = 2;              // Unique identifier for the batch (unique per signer)
-    repeated string tag = 3;        // Tags for the batch message
+    repeated string tag = 1;        // Tags for the batch message
 }
 
 // This message is used to finalize and sign a batch transfer to the Bulletin Board Server
 message CloseBatchMessage {
-    int32 batchId = 1;                          // Unique identifier for the batch (unique per signer)
+    int64 batchId = 1;                          // Unique temporary identifier for the batch
     int32 batchLength = 2;                      // Number of messages in the batch
     google.protobuf.Timestamp timestamp = 3;    // Timestamp of the batch (as defined by client)
-    meerkat.Signature sig = 4;                  // Signature on the (ordered) batch messages
+    repeated meerkat.Signature sig = 4;         // Signatures on the (ordered) batch messages
 }
 
-// Container for single batch message data
-message BatchData {
+// Container for single chunk of abatch message
+message BatchChunk {
     bytes data = 1;
 }
 
-// List of BatchData; Only used for testing
-message BatchDataList {
-    repeated BatchData data = 1;
+// List of BatchChunk; Only used for testing
+message BatchChunkList {
+    repeated BatchChunk data = 1;
 }
 
 // These messages comprise a batch message
 message BatchMessage {
-    bytes signerId = 1;             // Unique signer identifier
-    int32 batchId = 2;              // Unique identifier for the batch (unique per signer)
-    int32 serialNum = 3;            // Location of the message in the batch: starting from 0
-    BatchData data = 4;             // Actual data
-}
-
-// This message defines which batch to read and from which location to start reading
-message BatchSpecificationMessage {
-    bytes signerId = 1;             // Unique signer identifier
-    int32 batchId = 2;              // Unique identifier for the batch (unique per signer)
-    int32 startPosition = 3;        // Position in batch to start reading from
+    int64 batchId = 1;              // Unique temporary identifier for the batch
+    int32 serialNum = 2;            // Location of the message in the batch: starting from 0
+    BatchChunk data = 3;            // Actual data
 }
 
 // This message is used to define a single query to the server to ascertain whether or not the server is synched with the client
@@ -161,3 +161,14 @@ message SyncQueryResponse {
     google.protobuf.Timestamp lastTimeOfSync = 2;
 
 }
+
+// This message defines a query for retrieval of batch data
+message BatchQuery {
+
+    // The unique message ID if the batch
+    MessageID msgID = 1;
+
+    // The first chunk to retrieve (0 is the first chunk)
+    int32 startPosition = 2;
+
+}

meerkat-common/src/test/java/meerkat/bulletinboard/BulletinBoardDigestTest.java

@@ -0,0 +1,112 @@
+package meerkat.bulletinboard;
+
+import com.google.protobuf.ByteString;
+import meerkat.crypto.concrete.ECDSASignature;
+import meerkat.crypto.concrete.SHA256Digest;
+import meerkat.protobuf.BulletinBoardAPI.*;
+import meerkat.util.BulletinBoardMessageGenerator;
+import meerkat.util.BulletinBoardUtils;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.*;
+import java.security.cert.CertificateException;
+import java.util.List;
+import java.util.Random;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.fail;
+
+/**
+ * Created by Arbel Deutsch Peled on 16-Jun-16.
+ */
+public class BulletinBoardDigestTest {
+
+    private static String KEYFILE_EXAMPLE = "/certs/enduser-certs/user1-key-with-password-secret.p12";
+    private static String KEYFILE_EXAMPLE3 = "/certs/enduser-certs/user3-key-with-password-shh.p12";
+
+    private static String KEYFILE_PASSWORD1 = "secret";
+    private static String KEYFILE_PASSWORD3 = "shh";
+
+    private GenericBulletinBoardSignature[] signers;
+    private ByteString[] signerIDs;
+
+    @Before
+    public void init() {
+
+        signers = new GenericBulletinBoardSignature[2];
+        signerIDs = new ByteString[signers.length];
+        signers[0] = new GenericBulletinBoardSignature(new ECDSASignature());
+        signers[1] = new GenericBulletinBoardSignature(new ECDSASignature());
+
+        InputStream keyStream = getClass().getResourceAsStream(KEYFILE_EXAMPLE);
+        char[] password = KEYFILE_PASSWORD1.toCharArray();
+
+        KeyStore.Builder keyStoreBuilder = null;
+        try {
+            keyStoreBuilder = signers[0].getPKCS12KeyStoreBuilder(keyStream, password);
+
+            signers[0].loadSigningCertificate(keyStoreBuilder);
+
+            keyStream = getClass().getResourceAsStream(KEYFILE_EXAMPLE3);
+            password = KEYFILE_PASSWORD3.toCharArray();
+
+            keyStoreBuilder = signers[1].getPKCS12KeyStoreBuilder(keyStream, password);
+            signers[1].loadSigningCertificate(keyStoreBuilder);
+
+            for (int i = 0 ; i < signers.length ; i++) {
+                signerIDs[i] = signers[i].getSignerID();
+            }
+
+        } catch (IOException e) {
+            System.err.println("Failed reading from signature file " + e.getMessage());
+            fail("Failed reading from signature file " + e.getMessage());
+        } catch (CertificateException e) {
+            System.err.println("Failed reading certificate " + e.getMessage());
+            fail("Failed reading certificate " + e.getMessage());
+        } catch (KeyStoreException e) {
+            System.err.println("Failed reading keystore " + e.getMessage());
+            fail("Failed reading keystore " + e.getMessage());
+        } catch (NoSuchAlgorithmException e) {
+            System.err.println("Couldn't find signing algorithm " + e.getMessage());
+            fail("Couldn't find signing algorithm " + e.getMessage());
+        } catch (UnrecoverableKeyException e) {
+            System.err.println("Couldn't find signing key " + e.getMessage());
+            fail("Couldn't find signing key " + e.getMessage());
+        }
+
+    }
+
+    @Test
+    public void testBatchDigest() throws SignatureException {
+
+        final int MESSAGE_SIZE = 100;
+        final int CHUNK_SIZE = 10;
+        final int TAG_NUM = 10;
+
+        BulletinBoardMessageGenerator generator = new BulletinBoardMessageGenerator(new Random(0));
+
+        BulletinBoardMessage completeMessage = generator.generateRandomMessage(signers, MESSAGE_SIZE, TAG_NUM);
+
+        BulletinBoardMessage stub = BulletinBoardUtils.makeStub(completeMessage);
+        List<BatchChunk> batchChunks = BulletinBoardUtils.breakToBatch(completeMessage, CHUNK_SIZE);
+
+        BulletinBoardDigest digest = new GenericBulletinBoardDigest(new SHA256Digest());
+
+        digest.update(completeMessage);
+        MessageID id1 = digest.digestAsMessageID();
+
+        digest.update(stub);
+        for (BatchChunk batchChunk : batchChunks){
+            digest.update(batchChunk.getData().toByteArray());
+        }
+
+        MessageID id2 = digest.digestAsMessageID();
+
+        assertThat("Digests not equal!", id1.getID().equals(id2.getID()));
+
+    }
+
+}

voting-booth/build.gradle

@@ -1,4 +1,3 @@
-
 plugins {
   id "us.kirchmeier.capsule" version "1.0.1"
   id 'com.google.protobuf' version '0.7.0'
@@ -188,4 +187,3 @@ publishing {
         }
     }
 }
-