Merge pull request #19 in ASAPO/asapo from Rename-hidra2-to-asapo to develop

* commit '0cd2bf30':
  rename

examples/worker/getnext_broker/CMakeLists_separate.in

@@ -31,4 +31,4 @@ link_directories(@CMAKE_INSTALL_PREFIX@/lib)
 
 add_executable(${TARGET_NAME} ${SOURCE_FILES})
 target_include_directories(${TARGET_NAME} PUBLIC @CMAKE_INSTALL_PREFIX@/include ${CURL_INCLUDE_DIRS})
-target_link_libraries(${TARGET_NAME} hidra2-worker ${CURL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries(${TARGET_NAME} asapo-worker ${CURL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})

examples/worker/getnext_broker/Makefile.in

@@ -3,7 +3,7 @@ PROGRAM=@TARGET_NAME@
 CXX=g++
 CXXFLAGS=-std=c++11
 LDFLAGS=-pthread  -static-libgcc -static-libstdc++
-LIBS=-L @CMAKE_INSTALL_PREFIX@/lib -lhidra2-worker -L ${LIBCURL_DIR}/lib -lcurl
+LIBS=-L @CMAKE_INSTALL_PREFIX@/lib -lasapo-worker -L ${LIBCURL_DIR}/lib -lcurl
 INCLUDE=-I @CMAKE_INSTALL_PREFIX@/include -I ${LIBCURL_DIR}/include
 RM=rm -f
 

examples/worker/getnext_broker/getnext_broker.cpp

@@ -7,10 +7,10 @@
 #include <iomanip>
 #include <numeric>
 
-#include "hidra2_worker.h"
+#include "asapo_worker.h"
 
 using std::chrono::high_resolution_clock;
-using hidra2::Error;
+using asapo::Error;
 
 void WaitThreads(std::vector<std::thread>* threads) {
     for (auto& thread : *threads) {
@@ -20,7 +20,7 @@ void WaitThreads(std::vector<std::thread>* threads) {
 
 int ProcessError(const Error& err) {
     if (err == nullptr) return 0;
-    if (err->GetErrorType() != hidra2::ErrorType::kEndOfFile) {
+    if (err->GetErrorType() != asapo::ErrorType::kEndOfFile) {
         std::cout << err->Explain() << std::endl;
         return 1;
     }
@@ -30,9 +30,9 @@ int ProcessError(const Error& err) {
 std::vector<std::thread> StartThreads(const std::string& server, const std::string& run_name, int nthreads,
                                       std::vector<int>* nfiles, std::vector<int>* errors) {
     auto exec_next = [server, run_name, nfiles, errors](int i) {
-        hidra2::FileInfo fi;
+        asapo::FileInfo fi;
         Error err;
-        auto broker = hidra2::DataBrokerFactory::CreateServerBroker(server, run_name, &err);
+        auto broker = asapo::DataBrokerFactory::CreateServerBroker(server, run_name, &err);
         broker->SetTimeout(1000);
         while ((err = broker->GetNext(&fi, nullptr)) == nullptr) {
             (*nfiles)[i] ++;
@@ -48,7 +48,7 @@ std::vector<std::thread> StartThreads(const std::string& server, const std::stri
 }
 
 int ReadAllData(const std::string& server, const std::string& run_name, int nthreads, uint64_t* duration_ms) {
-    hidra2::FileInfo fi;
+    asapo::FileInfo fi;
     high_resolution_clock::time_point t1 = high_resolution_clock::now();
 
     std::vector<int>nfiles(nthreads, 0);

examples/worker/process_folder/CMakeLists.txt

@@ -4,10 +4,10 @@ set(SOURCE_FILES process_folder.cpp)
 add_executable(${TARGET_NAME} ${SOURCE_FILES})
 
 #Add all necessary common libraries
-GET_PROPERTY(HIDRA2_COMMON_IO_LIBRARIES GLOBAL PROPERTY HIDRA2_COMMON_IO_LIBRARIES)
-target_link_libraries(${TARGET_NAME} ${HIDRA2_COMMON_IO_LIBRARIES})
+GET_PROPERTY(ASAPO_COMMON_IO_LIBRARIES GLOBAL PROPERTY ASAPO_COMMON_IO_LIBRARIES)
+target_link_libraries(${TARGET_NAME} ${ASAPO_COMMON_IO_LIBRARIES})
 
-target_link_libraries(${TARGET_NAME} hidra2-worker)
+target_link_libraries(${TARGET_NAME} asapo-worker)
 set_target_properties(${TARGET_NAME} PROPERTIES LINKER_LANGUAGE CXX)
 #use expression generator to get rid of VS adding Debug/Release folders
 set_target_properties(${TARGET_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY

examples/worker/process_folder/CMakeLists_separate.in

@@ -18,5 +18,5 @@ link_directories(@CMAKE_INSTALL_PREFIX@/lib)
 
 add_executable(${TARGET_NAME} ${SOURCE_FILES})
 target_include_directories(${TARGET_NAME} PUBLIC @CMAKE_INSTALL_PREFIX@/include)
-target_link_libraries(${TARGET_NAME} hidra2-worker ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries(${TARGET_NAME} asapo-worker ${CMAKE_THREAD_LIBS_INIT})
 

examples/worker/process_folder/Makefile.in

@@ -3,7 +3,7 @@ PROGRAM=worker_processfolder
 CXX=g++
 CXXFLAGS=-std=c++11
 LDFLAGS=-pthread  -static-libgcc -static-libstdc++
-LIBS=-L @CMAKE_INSTALL_PREFIX@/lib -lhidra2-worker
+LIBS=-L @CMAKE_INSTALL_PREFIX@/lib -lasapo-worker
 INCLUDE=@CMAKE_INSTALL_PREFIX@/include
 RM=rm -f
 

examples/worker/process_folder/process_folder.cpp

@@ -6,10 +6,10 @@
 #include <chrono>
 #include <iomanip>
 
-#include "hidra2_worker.h"
+#include "asapo_worker.h"
 
 using std::chrono::high_resolution_clock;
-using hidra2::Error;
+using asapo::Error;
 
 struct Statistics {
     std::chrono::milliseconds duration_scan;
@@ -26,9 +26,9 @@ std::string ProcessCommandArguments(int argc, char* argv[]) {
     return argv[1];
 }
 
-std::unique_ptr<hidra2::DataBroker> CreateBroker(const std::string& folder) {
+std::unique_ptr<asapo::DataBroker> CreateBroker(const std::string& folder) {
     Error err;
-    auto broker = hidra2::DataBrokerFactory::CreateFolderBroker(folder, &err);
+    auto broker = asapo::DataBrokerFactory::CreateFolderBroker(folder, &err);
     if (err != nullptr) {
         std::cout << "Cannot create broker" << std::endl;
         exit(EXIT_FAILURE);
@@ -37,7 +37,7 @@ std::unique_ptr<hidra2::DataBroker> CreateBroker(const std::string& folder) {
     return broker;
 }
 
-void ConnectToBrocker(std::unique_ptr<hidra2::DataBroker>* broker, Statistics* statistics) {
+void ConnectToBrocker(std::unique_ptr<asapo::DataBroker>* broker, Statistics* statistics) {
     high_resolution_clock::time_point t1 = high_resolution_clock::now();
     Error err = (*broker)->Connect();
     if (err != nullptr) {
@@ -48,10 +48,10 @@ void ConnectToBrocker(std::unique_ptr<hidra2::DataBroker>* broker, Statistics* s
     statistics->duration_scan = std::chrono::duration_cast<std::chrono::milliseconds>( t2 - t1 );
 }
 
-void ReadAllData(std::unique_ptr<hidra2::DataBroker>* broker, Statistics* statistics) {
+void ReadAllData(std::unique_ptr<asapo::DataBroker>* broker, Statistics* statistics) {
     Error err;
-    hidra2::FileInfo file_info;
-    hidra2::FileData file_data;
+    asapo::FileInfo file_info;
+    asapo::FileData file_data;
     high_resolution_clock::time_point t1 = high_resolution_clock::now();
 
     int nfiles = 0;
@@ -60,7 +60,7 @@ void ReadAllData(std::unique_ptr<hidra2::DataBroker>* broker, Statistics* statis
         nfiles++;
         size += file_info.size;
     }
-    if (err->GetErrorType() != hidra2::ErrorType::kEndOfFile) {
+    if (err->GetErrorType() != asapo::ErrorType::kEndOfFile) {
         std::cout << err->Explain() << std::endl;
         exit(EXIT_FAILURE);
     }

producer/api/CMakeLists.txt

@@ -11,7 +11,7 @@ set(SOURCE_FILES
 ################################
 add_library(${TARGET_NAME} STATIC ${SOURCE_FILES} $<TARGET_OBJECTS:system_io> $<TARGET_OBJECTS:logger>
         $<TARGET_OBJECTS:curl_http_client> )
-target_include_directories(${TARGET_NAME} PUBLIC include ${HIDRA2_CXX_COMMON_INCLUDE_DIR})
+target_include_directories(${TARGET_NAME} PUBLIC include ${ASAPO_CXX_COMMON_INCLUDE_DIR})
 target_link_libraries(${TARGET_NAME} ${CURL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
 
 ################################

producer/api/include/hidra2_producer.h → producer/api/include/asapo_producer.h

-#ifndef HIDRA2_HIDRA2_PRODUCER_H
-#define HIDRA2_HIDRA2_PRODUCER_H
+#ifndef ASAPO_ASAPO_PRODUCER_H
+#define ASAPO_ASAPO_PRODUCER_H
 
 #include "common/io_error.h"
 #include "producer/producer.h"
 
 
-#endif //HIDRA2_HIDRA2_PRODUCER_H
+#endif //ASAPO_ASAPO_PRODUCER_H

producer/api/include/producer/producer.h

-#ifndef HIDRA2_PRODUCER__PRODUCER_H
-#define HIDRA2_PRODUCER__PRODUCER_H
+#ifndef ASAPO_PRODUCER__PRODUCER_H
+#define ASAPO_PRODUCER__PRODUCER_H
 
 #include <memory>
 #include <string>
@@ -7,7 +7,7 @@
 #include "producer_error.h"
 #include "logger/logger.h"
 
-namespace hidra2 {
+namespace asapo {
 
 enum class ProducerStatus {
     kDisconnected,
@@ -57,4 +57,4 @@ class Producer {
 };
 }
 
-#endif //HIDRA2_PRODUCER__PRODUCER_H
+#endif //ASAPO_PRODUCER__PRODUCER_H

producer/api/include/producer/producer_error.h

-#ifndef HIDRA2_PRODUCER_ERROR_H
-#define HIDRA2_PRODUCER_ERROR_H
+#ifndef ASAPO_PRODUCER_ERROR_H
+#define ASAPO_PRODUCER_ERROR_H
 
 #include "common/error.h"
 
-namespace hidra2 {
+namespace asapo {
 
 enum class ProducerErrorType {
     kAlreadyConnected,
@@ -75,4 +75,4 @@ auto const kUnknownServerError = ProducerErrorTemplate {
 };
 }
 
-#endif //HIDRA2_PRODUCER_ERROR_H
+#endif //ASAPO_PRODUCER_ERROR_H

producer/api/src/producer.cpp

 #include "producer/producer.h"
 #include "producer_impl.h"
 
-std::unique_ptr<hidra2::Producer> hidra2::Producer::Create() {
-    return std::unique_ptr<hidra2::Producer>(new ProducerImpl());
+std::unique_ptr<asapo::Producer> asapo::Producer::Create() {
+    return std::unique_ptr<asapo::Producer>(new ProducerImpl());
 }

producer/api/src/producer_impl.cpp

@@ -4,7 +4,7 @@
 #include "producer_impl.h"
 #include "io/io_factory.h"
 
-namespace  hidra2 {
+namespace  asapo {
 
 const uint32_t ProducerImpl::kVersion = 1;
 const size_t ProducerImpl::kMaxChunkSize = size_t(1024) * size_t(1024) * size_t(1024) * size_t(2); //2GiByte

producer/api/src/producer_impl.h

-#ifndef HIDRA2_PRODUCER__PRODUCER_IMPL_H
-#define HIDRA2_PRODUCER__PRODUCER_IMPL_H
+#ifndef ASAPO_PRODUCER__PRODUCER_IMPL_H
+#define ASAPO_PRODUCER__PRODUCER_IMPL_H
 
 #include <string>
 #include <common/networking.h>
@@ -7,7 +7,7 @@
 #include "producer/producer.h"
 #include "logger/logger.h"
 
-namespace hidra2 {
+namespace asapo {
 class ProducerImpl : public Producer {
   private:
     static const uint32_t kVersion;
@@ -42,4 +42,4 @@ class ProducerImpl : public Producer {
 };
 }
 
-#endif //HIDRA2_PRODUCER__PRODUCER_IMPL_H
+#endif //ASAPO_PRODUCER__PRODUCER_IMPL_H

producer/api/unittests/test_producer.cpp

@@ -8,8 +8,8 @@ using ::testing::Ne;
 namespace {
 
 TEST(CreateProducer, PointerIsNotNullptr) {
-    std::unique_ptr<hidra2::Producer> producer = hidra2::Producer::Create();
-    ASSERT_THAT(dynamic_cast<hidra2::ProducerImpl*>(producer.get()), Ne(nullptr));
+    std::unique_ptr<asapo::Producer> producer = asapo::Producer::Create();
+    ASSERT_THAT(dynamic_cast<asapo::ProducerImpl*>(producer.get()), Ne(nullptr));
     ASSERT_THAT(producer.get(), Ne(nullptr));
 }
 

producer/api/unittests/test_producer_impl.cpp

@@ -22,14 +22,14 @@ using ::testing::InSequence;
 using ::testing::HasSubstr;
 
 TEST(get_version, VersionAboveZero) {
-    hidra2::ProducerImpl producer;
+    asapo::ProducerImpl producer;
     EXPECT_GE(producer.GetVersion(), 0);
 }
 
 
 TEST(Producer, Logger) {
-    hidra2::ProducerImpl producer;
-    ASSERT_THAT(dynamic_cast<hidra2::AbstractLogger*>(producer.log__.get()), Ne(nullptr));
+    asapo::ProducerImpl producer;
+    ASSERT_THAT(dynamic_cast<asapo::AbstractLogger*>(producer.log__.get()), Ne(nullptr));
 }
 
 /**
@@ -38,11 +38,11 @@ TEST(Producer, Logger) {
 
 class ProducerImpl : public testing::Test {
   public:
-    hidra2::ProducerImpl producer;
-    testing::NiceMock<hidra2::MockIO> mock_io;
-    testing::NiceMock<hidra2::MockLogger> mock_logger;
+    asapo::ProducerImpl producer;
+    testing::NiceMock<asapo::MockIO> mock_io;
+    testing::NiceMock<asapo::MockLogger> mock_logger;
 
-    hidra2::FileDescriptor expected_fd = 83942;
+    asapo::FileDescriptor expected_fd = 83942;
     uint64_t expected_file_id = 4224;
     std::string expected_address = "127.0.0.1:9090";
     uint64_t expected_request_id = 0;
@@ -50,15 +50,15 @@ class ProducerImpl : public testing::Test {
     void*    expected_file_pointer = (void*)0xC00FE;
 
     void SetUp() override {
-        producer.io__ = std::unique_ptr<hidra2::IO> {&mock_io};
-        producer.log__ = hidra2::Logger {&mock_logger};
+        producer.io__ = std::unique_ptr<asapo::IO> {&mock_io};
+        producer.log__ = asapo::Logger {&mock_logger};
     }
     void TearDown() override {
         producer.io__.release();
         producer.log__.release();
     }
 
-    void ConnectToReceiver_DONE(hidra2::FileDescriptor expected_fd = 1) {
+    void ConnectToReceiver_DONE(asapo::FileDescriptor expected_fd = 1) {
         EXPECT_CALL(mock_io, CreateAndConnectIPTCPSocket_t(expected_address, _))
         .Times(1)
         .WillOnce(
@@ -80,8 +80,8 @@ class ProducerImpl : public testing::Test {
 };
 
 TEST_F(ProducerImpl, get_status__disconnected) {
-    hidra2::ProducerStatus status = producer.GetStatus();
-    ASSERT_THAT(status, Eq(hidra2::ProducerStatus::kDisconnected));
+    asapo::ProducerStatus status = producer.GetStatus();
+    ASSERT_THAT(status, Eq(asapo::ProducerStatus::kDisconnected));
 }
 
 
@@ -90,7 +90,7 @@ TEST_F(ProducerImpl, ConnectToReceiver__CreateAndConnectIPTCPSocket_error) {
     .Times(1)
     .WillOnce(
         DoAll(
-            testing::SetArgPointee<1>(hidra2::IOErrorTemplates::kInvalidAddressFormat.Generate().release()),
+            testing::SetArgPointee<1>(asapo::IOErrorTemplates::kInvalidAddressFormat.Generate().release()),
             Return(-1)
         ));
 
@@ -99,8 +99,8 @@ TEST_F(ProducerImpl, ConnectToReceiver__CreateAndConnectIPTCPSocket_error) {
     auto error = producer.ConnectToReceiver(expected_address);
     auto status = producer.GetStatus();
 
-    ASSERT_THAT(error, Eq(hidra2::IOErrorTemplates::kInvalidAddressFormat));
-    ASSERT_THAT(status, Eq(hidra2::ProducerStatus::kDisconnected));
+    ASSERT_THAT(error, Eq(asapo::IOErrorTemplates::kInvalidAddressFormat));
+    ASSERT_THAT(status, Eq(asapo::ProducerStatus::kDisconnected));
 }
 
 TEST_F(ProducerImpl, ConnectToReceiver) {
@@ -119,7 +119,7 @@ TEST_F(ProducerImpl, ConnectToReceiver) {
     auto status = producer.GetStatus();
 
     ASSERT_THAT(error, Eq(nullptr));
-    ASSERT_THAT(status, Eq(hidra2::ProducerStatus::kConnected));
+    ASSERT_THAT(status, Eq(asapo::ProducerStatus::kConnected));
 }
 
 TEST_F(ProducerImpl, ConnectToReceiver__already_connected) {
@@ -129,7 +129,7 @@ TEST_F(ProducerImpl, ConnectToReceiver__already_connected) {
 
     auto error = producer.ConnectToReceiver(expected_address);
 
-    ASSERT_THAT(error, Eq(hidra2::ProducerErrorTemplates::kAlreadyConnected));
+    ASSERT_THAT(error, Eq(asapo::ProducerErrorTemplates::kAlreadyConnected));
 }
 
 /**
@@ -138,23 +138,23 @@ TEST_F(ProducerImpl, ConnectToReceiver__already_connected) {
 
 MATCHER_P3(M_CheckSendDataRequest, request_id, file_id, file_size,
            "Checks if a valid GenericNetworkRequestHeader was Send") {
-    return ((hidra2::GenericNetworkRequestHeader*)arg)->op_code == hidra2::kNetOpcodeSendData
-           && ((hidra2::GenericNetworkRequestHeader*)arg)->request_id == request_id
-           && ((hidra2::GenericNetworkRequestHeader*)arg)->data_id == file_id
-           && ((hidra2::GenericNetworkRequestHeader*)arg)->data_size == file_size;
+    return ((asapo::GenericNetworkRequestHeader*)arg)->op_code == asapo::kNetOpcodeSendData
+           && ((asapo::GenericNetworkRequestHeader*)arg)->request_id == request_id
+           && ((asapo::GenericNetworkRequestHeader*)arg)->data_id == file_id
+           && ((asapo::GenericNetworkRequestHeader*)arg)->data_size == file_size;
 }
 
 ACTION_P2(A_WriteSendDataResponse, error_code, request_id) {
-    ((hidra2::SendDataResponse*)arg1)->op_code = hidra2::kNetOpcodeSendData;
-    ((hidra2::SendDataResponse*)arg1)->error_code = error_code;
-    ((hidra2::SendDataResponse*)arg1)->request_id = request_id;
+    ((asapo::SendDataResponse*)arg1)->op_code = asapo::kNetOpcodeSendData;
+    ((asapo::SendDataResponse*)arg1)->error_code = error_code;
+    ((asapo::SendDataResponse*)arg1)->request_id = request_id;
 }
 
 TEST_F(ProducerImpl, Send__connection_not_ready) {
 
     auto error = producer.Send(expected_file_id, nullptr, 1);
 
-    ASSERT_THAT(error, Eq(hidra2::ProducerErrorTemplates::kConnectionNotReady));
+    ASSERT_THAT(error, Eq(asapo::ProducerErrorTemplates::kConnectionNotReady));
 }
 
 TEST_F(ProducerImpl, Send__file_too_large) {
@@ -164,7 +164,7 @@ TEST_F(ProducerImpl, Send__file_too_large) {
     auto error = producer.Send(expected_file_id, nullptr,
                                size_t(1024) * size_t(1024) * size_t(1024) * size_t(3));
 
-    ASSERT_THAT(error, Eq(hidra2::ProducerErrorTemplates::kFileTooLarge));
+    ASSERT_THAT(error, Eq(asapo::ProducerErrorTemplates::kFileTooLarge));
 }
 
 TEST_F(ProducerImpl, Send__sendDataRequest_error) {
@@ -174,17 +174,17 @@ TEST_F(ProducerImpl, Send__sendDataRequest_error) {
 
     EXPECT_CALL(mock_io, Send_t(expected_fd, M_CheckSendDataRequest(expected_request_id, expected_file_id,
                                 expected_file_size),
-                                sizeof(hidra2::GenericNetworkRequestHeader), _))
+                                sizeof(asapo::GenericNetworkRequestHeader), _))
     .Times(1)
     .WillOnce(
         DoAll(
-            testing::SetArgPointee<3>(hidra2::IOErrorTemplates::kBadFileNumber.Generate().release()),
+            testing::SetArgPointee<3>(asapo::IOErrorTemplates::kBadFileNumber.Generate().release()),
             Return(-1)
         ));
 
     auto error = producer.Send(expected_file_id, nullptr, expected_file_size);
 
-    ASSERT_THAT(error, Eq(hidra2::IOErrorTemplates::kBadFileNumber));
+    ASSERT_THAT(error, Eq(asapo::IOErrorTemplates::kBadFileNumber));
 }
 
 TEST_F(ProducerImpl, Send__sendData_error) {
@@ -197,7 +197,7 @@ TEST_F(ProducerImpl, Send__sendData_error) {
     .Times(1)
     .WillOnce(
         DoAll(
-            testing::SetArgPointee<3>(hidra2::IOErrorTemplates::kBadFileNumber.Generate().release()),
+            testing::SetArgPointee<3>(asapo::IOErrorTemplates::kBadFileNumber.Generate().release()),
             Return(-1)
         ));
 
@@ -205,7 +205,7 @@ TEST_F(ProducerImpl, Send__sendData_error) {
 
     auto error = producer.Send(expected_file_id, expected_file_pointer, expected_file_size);
 
-    ASSERT_THAT(error, Eq(hidra2::IOErrorTemplates::kBadFileNumber));
+    ASSERT_THAT(error, Eq(asapo::IOErrorTemplates::kBadFileNumber));
 }
 
 
@@ -215,11 +215,11 @@ TEST_F(ProducerImpl, Send__Receive_error) {
     ConnectToReceiver_DONE(expected_fd);
     Send_DONE(2);
 
-    EXPECT_CALL(mock_io, Receive_t(expected_fd, _, sizeof(hidra2::SendDataResponse), _))
+    EXPECT_CALL(mock_io, Receive_t(expected_fd, _, sizeof(asapo::SendDataResponse), _))
     .Times(1)
     .WillOnce(
         DoAll(
-            testing::SetArgPointee<3>(hidra2::IOErrorTemplates::kBadFileNumber.Generate().release()),
+            testing::SetArgPointee<3>(asapo::IOErrorTemplates::kBadFileNumber.Generate().release()),
             testing::Return(-1)
         ));
 
@@ -227,7 +227,7 @@ TEST_F(ProducerImpl, Send__Receive_error) {
 
     auto error = producer.Send(expected_file_id, expected_file_pointer, expected_file_size);
 
-    ASSERT_THAT(error, Eq(hidra2::IOErrorTemplates::kBadFileNumber));
+    ASSERT_THAT(error, Eq(asapo::IOErrorTemplates::kBadFileNumber));
 }
 
 TEST_F(ProducerImpl, Send__Receive_server_error) {
@@ -237,18 +237,18 @@ TEST_F(ProducerImpl, Send__Receive_server_error) {
     Send_DONE(2);
 
 
-    EXPECT_CALL(mock_io, Receive_t(_, _, sizeof(hidra2::SendDataResponse), _))
+    EXPECT_CALL(mock_io, Receive_t(_, _, sizeof(asapo::SendDataResponse), _))
     .Times(1)
     .WillOnce(
         DoAll(
             testing::SetArgPointee<3>(nullptr),
-            A_WriteSendDataResponse(hidra2::kNetErrorAllocateStorageFailed, expected_request_id),
+            A_WriteSendDataResponse(asapo::kNetErrorAllocateStorageFailed, expected_request_id),
             testing::ReturnArg<2>()
         ));
 
     auto error = producer.Send(expected_file_id, expected_file_pointer, expected_file_size);
 
-    ASSERT_THAT(error, Eq(hidra2::ProducerErrorTemplates::kUnknownServerError));
+    ASSERT_THAT(error, Eq(asapo::ProducerErrorTemplates::kUnknownServerError));
 }
 
 TEST_F(ProducerImpl, Send__Receive_server_error_id_already_in_use) {
@@ -258,18 +258,18 @@ TEST_F(ProducerImpl, Send__Receive_server_error_id_already_in_use) {
     Send_DONE(2);
 
 
-    EXPECT_CALL(mock_io, Receive_t(_, _, sizeof(hidra2::SendDataResponse), _))
+    EXPECT_CALL(mock_io, Receive_t(_, _, sizeof(asapo::SendDataResponse), _))
     .Times(1)
     .WillOnce(
         DoAll(
             testing::SetArgPointee<3>(nullptr),
-            A_WriteSendDataResponse(hidra2::kNetErrorFileIdAlreadyInUse, expected_request_id),
+            A_WriteSendDataResponse(asapo::kNetErrorFileIdAlreadyInUse, expected_request_id),
             testing::ReturnArg<2>()
         ));
 
     auto error = producer.Send(expected_file_id, expected_file_pointer, expected_file_size);
 
-    ASSERT_THAT(error, Eq(hidra2::ProducerErrorTemplates::kFileIdAlreadyInUse));
+    ASSERT_THAT(error, Eq(asapo::ProducerErrorTemplates::kFileIdAlreadyInUse));
 }
 
 TEST_F(ProducerImpl, Send) {
@@ -279,12 +279,12 @@ TEST_F(ProducerImpl, Send) {
     Send_DONE(2);
 
 
-    EXPECT_CALL(mock_io, Receive_t(_, _, sizeof(hidra2::SendDataResponse), _))
+    EXPECT_CALL(mock_io, Receive_t(_, _, sizeof(asapo::SendDataResponse), _))
     .Times(1)
     .WillOnce(
         DoAll(
             testing::SetArgPointee<3>(nullptr),
-            A_WriteSendDataResponse(hidra2::kNetErrorNoError, expected_request_id),
+            A_WriteSendDataResponse(asapo::kNetErrorNoError, expected_request_id),
             testing::ReturnArg<2>()
         ));
 
@@ -314,9 +314,9 @@ TEST_F(ProducerImpl, EnableRemoteLog) {
 
 TEST_F(ProducerImpl, SetLogLevel) {
 
-    EXPECT_CALL(mock_logger, SetLogLevel(hidra2::LogLevel::Warning));
+    EXPECT_CALL(mock_logger, SetLogLevel(asapo::LogLevel::Warning));
 
-    producer.SetLogLevel(hidra2::LogLevel::Warning);
+    producer.SetLogLevel(asapo::LogLevel::Warning);
 
 }
 

receiver/CMakeLists.txt

@@ -20,7 +20,7 @@ set(SOURCE_FILES
 add_library(${TARGET_NAME} STATIC ${SOURCE_FILES} $<TARGET_OBJECTS:system_io> $<TARGET_OBJECTS:curl_http_client>
          $<TARGET_OBJECTS:json_parser> $<TARGET_OBJECTS:logger>)
 set_target_properties(${TARGET_NAME} PROPERTIES LINKER_LANGUAGE CXX)
-target_include_directories(${TARGET_NAME} PUBLIC ${HIDRA2_CXX_COMMON_INCLUDE_DIR} ${CURL_INCLUDE_DIRS})
+target_include_directories(${TARGET_NAME} PUBLIC ${ASAPO_CXX_COMMON_INCLUDE_DIR} ${CURL_INCLUDE_DIRS})
 target_link_libraries(${TARGET_NAME} ${CURL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} database)
 
 

receiver/src/connection.cpp

@@ -6,7 +6,7 @@
 
 #include "receiver_logger.h"
 
-namespace hidra2 {
+namespace asapo {
 
 size_t Connection::kRequestHandlerMaxBufferSize;
 std::atomic<uint32_t> Connection::kNetworkProducerPeerImplGlobalCounter(0);

receiver/src/connection.h

-#ifndef HIDRA2_NetworkProducerPeerImpl_H
-#define HIDRA2_NetworkProducerPeerImpl_H
+#ifndef ASAPO_NetworkProducerPeerImpl_H
+#define ASAPO_NetworkProducerPeerImpl_H
 
 #include "connection.h"
 
@@ -17,7 +17,7 @@
 #include "statistics.h"
 #include "logger/logger.h"
 
-namespace hidra2 {
+namespace asapo {
 
 class Connection {
   public:
@@ -48,4 +48,4 @@ class Connection {
 }
 
 
-#endif //HIDRA2_NetworkProducerPeerImpl_H
+#endif //ASAPO_NetworkProducerPeerImpl_H

receiver/src/main.cpp

@@ -6,32 +6,32 @@
 
 #include "receiver_logger.h"
 
-hidra2::Error ReadConfigFile(int argc, char* argv[]) {
+asapo::Error ReadConfigFile(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " <config file>" << std::endl;
         exit(EXIT_FAILURE);
     }
-    hidra2::ReceiverConfigFactory factory;
+    asapo::ReceiverConfigFactory factory;
     return factory.SetConfigFromFile(argv[1]);
 }
 
 int main (int argc, char* argv[]) {
 
     auto err = ReadConfigFile(argc, argv);
-    const auto& logger = hidra2::GetDefaultReceiverLogger();
+    const auto& logger = asapo::GetDefaultReceiverLogger();
 
     if (err) {
         logger->Error("cannot read config file: " + err->Explain());
         return 1;
     }
 
-    auto config = hidra2::GetReceiverConfig();
+    auto config = asapo::GetReceiverConfig();
 
     logger->SetLogLevel(config->log_level);
 
     static const std::string address = "0.0.0.0:" + std::to_string(config->listen_port);
 
-    auto* receiver = new hidra2::Receiver();
+    auto* receiver = new asapo::Receiver();
 
     logger->Info("listening on " + address);
     receiver->Listen(address, &err);