Can disconnect client anytime during the simulation. Can also disconnect the...

Can disconnect client anytime during the simulation. Can also disconnect the backup servers. Can add a backup server

build/includes/summa_actor/summa_client.hpp

@@ -30,6 +30,7 @@ struct summa_client_state {
     std::vector<std::tuple<caf::actor, std::string>> backup_servers_list;
 
     Batch current_batch;
+    bool saved_batch = false;
 
     Summa_Actor_Settings summa_actor_settings;
     File_Access_Actor_Settings file_access_actor_settings;

build/source/actors/summa_actor/summa_backup_server.cpp

@@ -116,6 +116,7 @@ behavior summa_backup_server(stateful_actor<summa_server_state>* self, const act
         // We have a new backup server that was added to the server
         [=](update_backup_server_list, std::vector<std::tuple<caf::actor, std::string>> backup_servers) {
             aout(self) << "Received the backup server list from the lead server\n";
+            aout(self) << "Backup Server List = " << backup_servers << std::endl;
             self->state.backup_servers_list = backup_servers;
         },
         

build/source/actors/summa_actor/summa_client.cpp

@@ -32,7 +32,7 @@ behavior summa_client_init(stateful_actor<summa_client_state>* self) {
 
  
 behavior summa_client(stateful_actor<summa_client_state>* self) {
-    
+
     self->state.running = true;
     self->send(self->state.current_server_actor, connect_to_server_v, self, self->state.hostname);
     return {
@@ -66,6 +66,10 @@ behavior summa_client(stateful_actor<summa_client_state>* self) {
                     if(actor_cast<actor>(server) == server_actor ) {
                         aout(self) << "Found Match\n";
                         self->state.current_server = server;
+                        if (self->state.saved_batch) {
+                            self->state.saved_batch = false;
+                            self->send(self->state.current_server_actor, done_batch_v, self, self->state.current_batch);
+                        }
                     }
                 }
                 self->state.servers.clear();
@@ -110,10 +114,10 @@ behavior summa_client(stateful_actor<summa_client_state>* self) {
             self->state.current_batch.updateWriteTime(write_time);
 
             if(self->state.current_server == nullptr) {
-                aout(self) << "Maybe We Should not Send this\n";
+                aout(self) << "Saving batch until we find a new lead server\n";
+                self->state.saved_batch = true;
             } else {
                 self->send(self->state.current_server_actor, done_batch_v, self, self->state.current_batch);
-
             }
         },
 

build/source/actors/summa_actor/summa_server.cpp

@@ -54,7 +54,8 @@ behavior summa_server(stateful_actor<summa_server_state>* self) {
             std::optional<Client> client = self->state.client_container.getClient(client_actor.address());
             if (client.has_value()) {
                 aout(self) << "Client is already connected\n";
-                aout(self) << "Checking if client has batch\n";
+                aout(self) << "Updating " << hostname << " with current backup servers\n";
+                self->send(client.value().getActor(), update_backup_server_list_v, self->state.backup_servers_list);
                 std::optional<Batch> batch = client.value().getBatch();
                 if (batch.has_value()) {
                     return;
@@ -94,7 +95,16 @@ behavior summa_server(stateful_actor<summa_server_state>* self) {
         [=](connect_as_backup, actor backup_server, std::string hostname) {
             aout(self) << "Received Connection Request From a backup server " << hostname <<  "\n";
             self->monitor(backup_server);
-            self->state.backup_servers_list.push_back(std::make_tuple(backup_server, hostname));
+            // Check if the backup server is already connected
+            auto backup_server_iterator = find(self->state.backup_servers_list.begin(), self->state.backup_servers_list.end(), std::make_tuple(backup_server, hostname));
+
+            if (backup_server_iterator != self->state.backup_servers_list.end()) {
+                aout(self) << "Backup Server is already connected\n";
+            } else {
+                aout(self) << "Adding Backup Server to list\n";
+                self->state.backup_servers_list.push_back(std::make_tuple(backup_server, hostname));
+            }
+            
             self->send(backup_server, connect_as_backup_v); // confirm connection with sender
             // Now we need to send the backup actor our current state
             self->send(backup_server, update_with_current_state_v, self->state.batch_container, self->state.client_container);