diff --git a/services/backup/src/Reactors/client/blob/BlobPutClientReactor.h b/services/backup/src/Reactors/client/blob/BlobPutClientReactor.h
index 7fffbc886..7bc1b0237 100644
--- a/services/backup/src/Reactors/client/blob/BlobPutClientReactor.h
+++ b/services/backup/src/Reactors/client/blob/BlobPutClientReactor.h
@@ -1,54 +1,54 @@
 #pragma once
 
 #include "Constants.h"
 #include "GlobalConstants.h"
 
-#include "../_generated/blob.grpc.pb.h"
-#include "../_generated/blob.pb.h"
+#include "blob.grpc.pb.h"
+#include "blob.pb.h"
 
 #include "ClientBidiReactorBase.h"
 
 #include <folly/MPMCQueue.h>
 #include <grpcpp/grpcpp.h>
 
 #include <condition_variable>
 #include <memory>
 #include <string>
 
 namespace comm {
 namespace network {
 namespace reactor {
 
 class BlobPutClientReactor
     : public ClientBidiReactorBase<blob::PutRequest, blob::PutResponse> {
 
   enum class State {
     SEND_HOLDER = 0,
     SEND_HASH = 1,
     SEND_CHUNKS = 2,
   };
 
   State state = State::SEND_HOLDER;
   const std::string hash;
   const std::string holder;
   size_t currentDataSize = 0;
   const size_t chunkSize =
       GRPC_CHUNK_SIZE_LIMIT - GRPC_METADATA_SIZE_PER_MESSAGE;
   folly::MPMCQueue<std::string> dataChunks;
   std::condition_variable *terminationNotifier;
 
 public:
   BlobPutClientReactor(
       const std::string &holder,
       const std::string &hash,
       std::condition_variable *terminationNotifier);
   void scheduleSendingDataChunk(std::unique_ptr<std::string> dataChunk);
   std::unique_ptr<grpc::Status> prepareRequest(
       blob::PutRequest &request,
       std::shared_ptr<blob::PutResponse> previousResponse) override;
   void doneCallback() override;
 };
 
 } // namespace reactor
 } // namespace network
 } // namespace comm
diff --git a/services/backup/src/Reactors/server/AddAttachmentsUtility.h b/services/backup/src/Reactors/server/AddAttachmentsUtility.h
index 509ef252d..2530a4a1b 100644
--- a/services/backup/src/Reactors/server/AddAttachmentsUtility.h
+++ b/services/backup/src/Reactors/server/AddAttachmentsUtility.h
@@ -1,25 +1,25 @@
 #pragma once
 
 #include "LogItem.h"
 
-#include "../_generated/backup.grpc.pb.h"
-#include "../_generated/backup.pb.h"
+#include "backup.grpc.pb.h"
+#include "backup.pb.h"
 
 #include <grpcpp/grpcpp.h>
 #include <memory>
 
 namespace comm {
 namespace network {
 namespace reactor {
 
 class AddAttachmentsUtility {
   std::shared_ptr<database::LogItem>
   moveToS3(std::shared_ptr<database::LogItem> logItem);
 
 public:
   grpc::Status processRequest(const backup::AddAttachmentsRequest *request);
 };
 
 } // namespace reactor
 } // namespace network
 } // namespace comm
diff --git a/services/backup/src/Reactors/server/CreateNewBackupReactor.h b/services/backup/src/Reactors/server/CreateNewBackupReactor.h
index e3d312587..7a7e03736 100644
--- a/services/backup/src/Reactors/server/CreateNewBackupReactor.h
+++ b/services/backup/src/Reactors/server/CreateNewBackupReactor.h
@@ -1,56 +1,56 @@
 #pragma once
 
 #include "ServiceBlobClient.h"
 
-#include "../_generated/backup.grpc.pb.h"
-#include "../_generated/backup.pb.h"
+#include "backup.grpc.pb.h"
+#include "backup.pb.h"
 
 #include "ServerBidiReactorBase.h"
 
 #include <condition_variable>
 #include <memory>
 #include <mutex>
 #include <string>
 
 namespace comm {
 namespace network {
 namespace reactor {
 
 class CreateNewBackupReactor : public ServerBidiReactorBase<
                                    backup::CreateNewBackupRequest,
                                    backup::CreateNewBackupResponse> {
   enum class State {
     USER_ID = 1,
     DEVICE_ID = 2,
     KEY_ENTROPY = 3,
     DATA_HASH = 4,
     DATA_CHUNKS = 5,
   };
 
   State state = State::USER_ID;
   std::string userID;
   std::string deviceID;
   std::string keyEntropy;
   std::string dataHash;
   std::string holder;
   std::string backupID;
   std::shared_ptr<reactor::BlobPutClientReactor> putReactor;
 
   ServiceBlobClient blobClient;
   std::mutex reactorStateMutex;
 
   std::condition_variable blobPutDoneCV;
   std::mutex blobPutDoneCVMutex;
 
   std::string generateBackupID();
 
 public:
   std::unique_ptr<ServerBidiReactorStatus> handleRequest(
       backup::CreateNewBackupRequest request,
       backup::CreateNewBackupResponse *response) override;
   void terminateCallback() override;
 };
 
 } // namespace reactor
 } // namespace network
 } // namespace comm
diff --git a/services/backup/src/Reactors/server/RecoverBackupKeyReactor.h b/services/backup/src/Reactors/server/RecoverBackupKeyReactor.h
index 9dee9def2..c2fa38ac3 100644
--- a/services/backup/src/Reactors/server/RecoverBackupKeyReactor.h
+++ b/services/backup/src/Reactors/server/RecoverBackupKeyReactor.h
@@ -1,33 +1,33 @@
 #pragma once
 
 #include "ServerBidiReactorBase.h"
 
-#include "../_generated/backup.grpc.pb.h"
-#include "../_generated/backup.pb.h"
+#include "backup.grpc.pb.h"
+#include "backup.pb.h"
 
 #include <memory>
 #include <string>
 
 namespace comm {
 namespace network {
 namespace reactor {
 
 class RecoverBackupKeyReactor : public ServerBidiReactorBase<
                                     backup::RecoverBackupKeyRequest,
                                     backup::RecoverBackupKeyResponse> {
 public:
   std::unique_ptr<ServerBidiReactorStatus> handleRequest(
       backup::RecoverBackupKeyRequest request,
       backup::RecoverBackupKeyResponse *response);
 };
 
 std::unique_ptr<ServerBidiReactorStatus> RecoverBackupKeyReactor::handleRequest(
     backup::RecoverBackupKeyRequest request,
     backup::RecoverBackupKeyResponse *response) { // TODO handle request
   return std::make_unique<ServerBidiReactorStatus>(
       grpc::Status(grpc::StatusCode::UNIMPLEMENTED, "unimplemented"));
 }
 
 } // namespace reactor
 } // namespace network
 } // namespace comm
diff --git a/services/backup/src/Reactors/server/SendLogReactor.h b/services/backup/src/Reactors/server/SendLogReactor.h
index 615e7c431..886ba6b5d 100644
--- a/services/backup/src/Reactors/server/SendLogReactor.h
+++ b/services/backup/src/Reactors/server/SendLogReactor.h
@@ -1,65 +1,65 @@
 #pragma once
 
 #include "LogItem.h"
 #include "ServerReadReactorBase.h"
 #include "ServiceBlobClient.h"
 
-#include "../_generated/backup.grpc.pb.h"
-#include "../_generated/backup.pb.h"
+#include "backup.grpc.pb.h"
+#include "backup.pb.h"
 
 #include <memory>
 #include <string>
 
 namespace comm {
 namespace network {
 namespace reactor {
 
 class SendLogReactor : public ServerReadReactorBase<
                            backup::SendLogRequest,
                            backup::SendLogResponse> {
   enum class State {
     USER_ID = 1,
     BACKUP_ID = 2,
     LOG_HASH = 3,
     LOG_CHUNK = 4,
   };
 
   enum class PersistenceMethod {
     UNKNOWN = 0,
     DB = 1,
     BLOB = 2,
   };
 
   State state = State::USER_ID;
   PersistenceMethod persistenceMethod = PersistenceMethod::UNKNOWN;
   std::string userID;
   std::string logID;
   std::string backupID;
   std::string hash;
   std::string blobHolder;
   std::string value;
   std::mutex reactorStateMutex;
 
   std::condition_variable blobPutDoneCV;
   std::mutex blobPutDoneCVMutex;
 
   std::shared_ptr<reactor::BlobPutClientReactor> putReactor;
   ServiceBlobClient blobClient;
 
   void storeInDatabase();
   std::string generateLogID(const std::string &backupID);
   void initializePutReactor();
 
 public:
   using ServerReadReactorBase<backup::SendLogRequest, backup::SendLogResponse>::
       ServerReadReactorBase;
 
   std::unique_ptr<grpc::Status>
   readRequest(backup::SendLogRequest request) override;
   void doneCallback() override;
   void terminateCallback() override;
 };
 
 } // namespace reactor
 } // namespace network
 } // namespace comm