diff --git a/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientBidiReactorBase.h b/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientBidiReactorBase.h
index e88d45129..af32ef2ab 100644
--- a/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientBidiReactorBase.h
+++ b/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientBidiReactorBase.h
@@ -1,108 +1,113 @@
 #include <grpcpp/grpcpp.h>
 
 namespace comm {
 namespace network {
 namespace reactor {
 
 template <class Request, class Response>
 class ClientBidiReactorBase
     : public grpc::ClientBidiReactor<Request, Response> {
   std::shared_ptr<Response> response = nullptr;
   bool done = false;
   bool initialized = 0;
 
 protected:
   Request request;
   grpc::Status status = grpc::Status::OK;
 
 public:
   grpc::ClientContext context;
 
   void nextWrite();
   void terminate(const grpc::Status &status);
   bool isDone();
   void OnWriteDone(bool ok) override;
   void OnReadDone(bool ok) override;
   void OnDone(const grpc::Status &status) override;
 
   virtual std::unique_ptr<grpc::Status> prepareRequest(
       Request &request,
       std::shared_ptr<Response> previousResponse) = 0;
   virtual void validate(){};
   virtual void doneCallback(){};
   virtual void terminateCallback(){};
 };
 
 template <class Request, class Response>
 void ClientBidiReactorBase<Request, Response>::nextWrite() {
   this->request = Request();
-  std::unique_ptr<grpc::Status> status =
-      this->prepareRequest(this->request, this->response);
-  if (status != nullptr) {
-    this->terminate(*status);
+  try {
+    std::unique_ptr<grpc::Status> status =
+        this->prepareRequest(this->request, this->response);
+    if (status != nullptr) {
+      this->terminate(*status);
+      return;
+    }
+  } catch (std::runtime_error &e) {
+    this->terminate(grpc::Status(grpc::StatusCode::INTERNAL, e.what()));
     return;
   }
   this->StartWrite(&this->request);
   if (!this->initialized) {
     this->StartCall();
     this->initialized = true;
   }
 }
 
 template <class Request, class Response>
 void ClientBidiReactorBase<Request, Response>::terminate(
     const grpc::Status &status) {
   if (this->status.ok()) {
     this->status = status;
   }
   if (!this->status.ok()) {
     std::cout << "error: " << this->status.error_message() << std::endl;
   }
   if (this->done) {
     return;
   }
   this->terminateCallback();
   try {
     this->validate();
   } catch (std::runtime_error &e) {
     this->status = grpc::Status(grpc::StatusCode::INTERNAL, e.what());
   }
   this->StartWritesDone();
   this->done = true;
 }
 
 template <class Request, class Response>
 bool ClientBidiReactorBase<Request, Response>::isDone() {
   return this->done;
 }
 
 template <class Request, class Response>
 void ClientBidiReactorBase<Request, Response>::OnWriteDone(bool ok) {
   if (this->response == nullptr) {
     this->response = std::make_shared<Response>();
   }
   this->StartRead(&(*this->response));
 }
 
 template <class Request, class Response>
 void ClientBidiReactorBase<Request, Response>::OnReadDone(bool ok) {
   if (!ok) {
     // Ending a connection on the other side results in the `ok` flag being set
     // to false. It makes it impossible to detect a failure based just on the
     // flag. We should manually check if the data we received is valid
     this->terminate(grpc::Status::OK);
     return;
   }
   this->nextWrite();
 }
 
 template <class Request, class Response>
 void ClientBidiReactorBase<Request, Response>::OnDone(
     const grpc::Status &status) {
   this->terminate(status);
   this->doneCallback();
 }
 
 } // namespace reactor
 } // namespace network
 } // namespace comm
diff --git a/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientReadReactorBase.h b/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientReadReactorBase.h
index c4e342b20..33433f28e 100644
--- a/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientReadReactorBase.h
+++ b/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientReadReactorBase.h
@@ -1,93 +1,97 @@
 #include <grpcpp/grpcpp.h>
 
 namespace comm {
 namespace network {
 namespace reactor {
 
 template <class Request, class Response>
 class ClientReadReactorBase : public grpc::ClientReadReactor<Response> {
   Response response;
   grpc::Status status = grpc::Status::OK;
   bool done = false;
   bool initialized = false;
 
   void terminate(const grpc::Status &status);
 
 public:
   Request request;
   grpc::ClientContext context;
 
   void start();
   void OnReadDone(bool ok) override;
   void OnDone(const grpc::Status &status) override;
   bool isDone();
 
   virtual std::unique_ptr<grpc::Status>
   readResponse(const Response &response) = 0;
   virtual void validate(){};
   virtual void doneCallback(){};
   virtual void terminateCallback(){};
 };
 
 template <class Request, class Response>
 void ClientReadReactorBase<Request, Response>::terminate(
     const grpc::Status &status) {
   if (this->status.ok()) {
     this->status = status;
   }
   if (!this->status.ok()) {
     std::cout << "error: " << this->status.error_message() << std::endl;
   }
   if (this->done) {
     return;
   }
   this->terminateCallback();
   try {
     this->validate();
   } catch (std::runtime_error &e) {
     this->status = grpc::Status(grpc::StatusCode::INTERNAL, e.what());
   }
   this->done = true;
 }
 
 template <class Request, class Response>
 void ClientReadReactorBase<Request, Response>::start() {
   this->StartRead(&this->response);
   if (!this->initialized) {
     this->StartCall();
     this->initialized = true;
   }
 }
 
 template <class Request, class Response>
 void ClientReadReactorBase<Request, Response>::OnReadDone(bool ok) {
   if (!ok) {
     // Ending a connection on the other side results in the `ok` flag being set
     // to false. It makes it impossible to detect a failure based just on the
     // flag. We should manually check if the data we received is valid
     this->terminate(grpc::Status::OK);
     return;
   }
-  std::unique_ptr<grpc::Status> status = this->readResponse(this->response);
-  if (status != nullptr) {
-    this->terminate(*status);
-    return;
+  try {
+    std::unique_ptr<grpc::Status> status = this->readResponse(this->response);
+    if (status != nullptr) {
+      this->terminate(*status);
+      return;
+    }
+  } catch (std::runtime_error &e) {
+    this->terminate(grpc::Status(grpc::StatusCode::INTERNAL, e.what()));
   }
   this->StartRead(&this->response);
 }
 
 template <class Request, class Response>
 void ClientReadReactorBase<Request, Response>::OnDone(
     const grpc::Status &status) {
   this->terminate(status);
   this->doneCallback();
 }
 
 template <class Request, class Response>
 bool ClientReadReactorBase<Request, Response>::isDone() {
   return this->done;
 }
 
 } // namespace reactor
 } // namespace network
 } // namespace comm
diff --git a/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientWriteReactorBase.h b/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientWriteReactorBase.h
index 89f7a8585..ef617982c 100644
--- a/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientWriteReactorBase.h
+++ b/services/backup/docker-server/contents/server/src/Reactors/client/base-reactors/ClientWriteReactorBase.h
@@ -1,90 +1,94 @@
 #include <grpcpp/grpcpp.h>
 
 namespace comm {
 namespace network {
 namespace reactor {
 
 template <class Request, class Response>
 class ClientWriteReactorBase : public grpc::ClientWriteReactor<Request> {
   grpc::Status status = grpc::Status::OK;
   bool done = false;
   bool initialized = 0;
   Request request;
 
 public:
   Response response;
   grpc::ClientContext context;
 
   void nextWrite();
   void OnWriteDone(bool ok) override;
   void terminate(const grpc::Status &status);
   bool isDone();
   void OnDone(const grpc::Status &status) override;
 
   virtual std::unique_ptr<grpc::Status> prepareRequest(Request &request) = 0;
   virtual void validate(){};
   virtual void doneCallback(){};
   virtual void terminateCallback(){};
 };
 
 template <class Request, class Response>
 void ClientWriteReactorBase<Request, Response>::nextWrite() {
   this->request = Request();
-  std::unique_ptr<grpc::Status> status = this->prepareRequest(this->request);
-  if (status != nullptr) {
-    this->terminate(*status);
-    return;
+  try {
+    std::unique_ptr<grpc::Status> status = this->prepareRequest(this->request);
+    if (status != nullptr) {
+      this->terminate(*status);
+      return;
+    }
+  } catch (std::runtime_error &e) {
+    this->terminate(grpc::Status(grpc::StatusCode::INTERNAL, e.what()));
   }
   this->StartWrite(&this->request);
   if (!this->initialized) {
     this->StartCall();
     this->initialized = true;
   }
 }
 
 template <class Request, class Response>
 void ClientWriteReactorBase<Request, Response>::OnWriteDone(bool ok) {
   if (!ok) {
     this->terminate(grpc::Status(grpc::StatusCode::UNKNOWN, "write error"));
     return;
   }
   this->nextWrite();
 }
 
 template <class Request, class Response>
 void ClientWriteReactorBase<Request, Response>::terminate(
     const grpc::Status &status) {
   if (this->status.ok()) {
     this->status = status;
   }
   if (!this->status.ok()) {
     std::cout << "error: " << this->status.error_message() << std::endl;
   }
   if (this->done) {
     return;
   }
   this->terminateCallback();
   try {
     this->validate();
   } catch (std::runtime_error &e) {
     this->status = grpc::Status(grpc::StatusCode::INTERNAL, e.what());
   }
   this->done = true;
   this->StartWritesDone();
 }
 
 template <class Request, class Response>
 bool ClientWriteReactorBase<Request, Response>::isDone() {
   return this->done;
 }
 
 template <class Request, class Response>
 void ClientWriteReactorBase<Request, Response>::OnDone(
     const grpc::Status &status) {
   this->terminate(status);
   this->doneCallback();
 }
 
 } // namespace reactor
 } // namespace network
 } // namespace comm