start receiver data server, introduce c++ templates for errors

common/cpp/include/common/error.h

@@ -155,5 +155,48 @@ auto const kEndOfFile = SimpleErrorTemplate {
 
 }
 
+template <typename ServiceErrorType, ErrorType MainErrorType>
+class ServiceError : public SimpleError {
+ private:
+  ServiceErrorType error_type_;
+ public:
+  ServiceError(const std::string& error, ServiceErrorType error_type) : SimpleError(error, MainErrorType) {
+      error_type_ = error_type;
+  }
+  ServiceErrorType GetServiceErrorType() const noexcept {
+      return error_type_;
+  }
+};
+
+template <typename ServiceErrorType, ErrorType MainErrorType>
+class ServiceErrorTemplate : public SimpleErrorTemplate {
+ protected:
+  ServiceErrorType error_type_;
+ public:
+  ServiceErrorTemplate(const std::string& error, ServiceErrorType error_type) : SimpleErrorTemplate(error,
+                                                                                                    MainErrorType) {
+      error_type_ = error_type;
+  }
+
+  inline ServiceErrorType GetServiceErrorType() const noexcept {
+      return error_type_;
+  }
+
+  inline Error Generate() const noexcept override {
+      auto err = new ServiceError<ServiceErrorType, MainErrorType>(error_, error_type_);
+      return Error(err);
+  }
+
+  inline Error Generate(const std::string& prefix) const noexcept {
+      auto err = new ServiceError<ServiceErrorType, MainErrorType>(prefix + " :" + error_, error_type_);
+      return Error(err);
+  }
+
+  inline bool operator==(const Error& rhs) const override {
+      return SimpleErrorTemplate::operator==(rhs)
+          && GetServiceErrorType() == ((ServiceError<ServiceErrorType, MainErrorType>*) rhs.get())->GetServiceErrorType();
+  }
+};
+
 }
 #endif //ASAPO_ERROR_H

deploy/nomad_jobs/fluentd.conf

@@ -48,6 +48,7 @@
   <store>
   @type file
   flush_interval 1s
+  append true
   buffer_type memory
   path /shared/asapo-logs
   </store>

receiver/CMakeLists.txt

@@ -12,7 +12,12 @@ set(SOURCE_FILES
         src/request_handler_authorize.cpp
         src/statistics_sender_fluentd.cpp
         src/requests_dispatcher.cpp
-)
+        src/receiver_data_server/receiver_data_server.cpp
+        src/receiver_data_server/net_server.cpp
+        src/receiver_data_server/tcp_server.cpp
+        src/receiver_data_server/request_pool.cpp
+        src/receiver_data_server/request.cpp
+        src/receiver_data_server/receiver_data_server_logger.cpp)
 
 
 ################################
@@ -63,3 +68,7 @@ set(TEST_SOURCE_FILES
 #
 set(TEST_LIBRARIES "${TARGET_NAME};system_io")
 gtest(${TARGET_NAME} "${TEST_SOURCE_FILES}" "${TEST_LIBRARIES}" ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp)
+
+set(TEST_SOURCE_FILES_RDS
+        unittests/receiver_data_server/test_receiver_data_server.cpp)
+gtest(${TARGET_NAME}_RDS "${TEST_SOURCE_FILES_RDS}" "${TEST_LIBRARIES}")

receiver/src/receiver_data_server/common.h

+#ifndef ASAPO_COMMON_H
+#define ASAPO_COMMON_H
+
+#include <vector>
+
+#include "request.h"
+namespace asapo {
+
+using Requests = std::vector<asapo::Request>;
+
+}
+
+#endif //ASAPO_COMMON_H

receiver/src/receiver_data_server/net_server.cpp

+#include "net_server.h"
+
+namespace asapo {
+
+}
\ No newline at end of file

receiver/src/receiver_data_server/net_server.h

+#ifndef ASAPO_NET_SERVER_H
+#define ASAPO_NET_SERVER_H
+
+#include "common/error.h"
+
+#include "common.h"
+
+namespace asapo {
+
+class NetServer {
+  public:
+    virtual Requests GetNewRequests(Error* err) const noexcept = 0;
+    virtual ~NetServer() = default;
+};
+
+}
+
+#endif //ASAPO_NET_SERVER_H

receiver/src/receiver_data_server/receiver_data_server.cpp

+#include "receiver_data_server.h"
+#include "tcp_server.h"
+#include "receiver_data_server_logger.h"
+
+namespace asapo {
+
+ReceiverDataServer::ReceiverDataServer() : request_pool__{new RequestPool}, net__{new TcpServer()},
+log__{GetDefaultReceiverDataServerLogger()} {
+}
+
+void ReceiverDataServer::Run() {
+    while (true) {
+        Error err;
+        auto requests = net__->GetNewRequests(&err);
+        if (err) {
+            log__->Error(std::string("receiver data server stopped: ") + err->Explain());
+            return;
+        }
+        err = request_pool__->AddRequests(requests);
+        if (err) {
+            log__->Error(std::string("receiver data server stopped: ") + err->Explain());
+            return;
+        }
+    }
+}
+
+}
\ No newline at end of file

receiver/src/receiver_data_server/receiver_data_server.h

+#ifndef ASAPO_RECEIVER_DATA_SERVER_H
+#define ASAPO_RECEIVER_DATA_SERVER_H
+
+#include <memory>
+
+#include "net_server.h"
+#include "request_pool.h"
+#include "logger/logger.h"
+
+namespace asapo {
+
+class ReceiverDataServer {
+  public:
+    std::unique_ptr<RequestPool> request_pool__;
+    std::unique_ptr<NetServer> net__;
+    const AbstractLogger* log__;
+
+    ReceiverDataServer();
+    void Run();
+};
+
+}
+
+#endif //ASAPO_RECEIVER_DATA_SERVER_H

receiver/src/receiver_data_server/receiver_data_server_error.h

+#ifndef ASAPO_RECEIVER_ERROR_H
+#define ASAPO_RECEIVER_ERROR_H
+
+#include "common/error.h"
+
+namespace asapo {
+
+enum class ReceiverDataServerErrorType {
+    kMemoryPool,
+};
+
+using ReceiverDataServerErrorTemplate = ServiceErrorTemplate<ReceiverDataServerErrorType, ErrorType::kReceiverError>;
+
+namespace ReceiverErrorTemplates {
+auto const kMemoryPool = ReceiverDataServerErrorTemplate {
+    "memory error", ReceiverDataServerErrorType::kMemoryPool
+};
+
+};
+}
+
+#endif //ASAPO_RECEIVER_ERROR_H

receiver/src/receiver_data_server/receiver_data_server_logger.cpp

+#include "receiver_data_server_logger.h"
+
+namespace asapo {
+
+
+AbstractLogger* GetDefaultReceiverDataServerLogger() {
+    static Logger logger = asapo::CreateDefaultLoggerBin("receiver_dataserver");
+    return logger.get();
+}
+
+}

receiver/src/receiver_data_server/receiver_data_server_logger.h

+#ifndef ASAPO_RECEIVER_LOGGER_H
+#define ASAPO_RECEIVER_LOGGER_H
+
+#include "logger/logger.h"
+
+namespace asapo {
+
+
+AbstractLogger* GetDefaultReceiverDataServerLogger();
+
+}
+
+
+#endif //ASAPO_RECEIVER_LOGGER_H

receiver/src/receiver_data_server/request.cpp

+#include "request.h"
+
+namespace asapo {
+
+}
\ No newline at end of file

receiver/src/receiver_data_server/request.h

+#ifndef ASAPO_REQUEST_H
+#define ASAPO_REQUEST_H
+
+namespace asapo {
+
+class Request {
+
+};
+
+}
+
+#endif //ASAPO_REQUEST_H

receiver/src/receiver_data_server/request_pool.cpp

+#include "request_pool.h"
+
+namespace asapo {
+
+Error RequestPool::AddRequests(const Requests& requests) noexcept {
+    return nullptr;
+}
+
+}
\ No newline at end of file

receiver/src/receiver_data_server/request_pool.h

+#ifndef ASAPO_REQUEST_POOL_H
+#define ASAPO_REQUEST_POOL_H
+
+#include "preprocessor/definitions.h"
+#include "common/error.h"
+#include "common.h"
+
+namespace asapo {
+
+class RequestPool {
+  public:
+    VIRTUAL Error AddRequests(const Requests& requests) noexcept;
+};
+
+}
+
+#endif //ASAPO_REQUEST_POOL_H

receiver/src/receiver_data_server/tcp_server.cpp

+#include "tcp_server.h"
+
+namespace asapo {
+
+Requests TcpServer::GetNewRequests(Error* err) const noexcept {
+    return {};
+}
+}
\ No newline at end of file

receiver/src/receiver_data_server/tcp_server.h

+#ifndef ASAPO_TCP_SERVER_H
+#define ASAPO_TCP_SERVER_H
+
+#include "net_server.h"
+
+namespace asapo {
+
+class TcpServer : public NetServer {
+  public:
+    virtual Requests GetNewRequests(Error* err) const noexcept override ;
+};
+
+}
+
+#endif //ASAPO_TCP_SERVER_H

receiver/unittests/receiver_data_server/receiver_dataserver_mocking.h

+#ifndef ASAPO_MOCK_STATISTICS_H
+#define ASAPO_MOCK_STATISTICS_H
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "../../src/receiver_data_server/net_server.h"
+#include "../../src/receiver_data_server/request_pool.h"
+
+
+namespace asapo {
+
+class MockNetServer : public NetServer {
+  public:
+    Requests GetNewRequests(Error* err) const noexcept override {
+        ErrorInterface* error = nullptr;
+        auto reqs = GetNewRequests_t(&error);
+        err->reset(error);
+        return  reqs;
+    }
+
+    MOCK_CONST_METHOD1(GetNewRequests_t, Requests (ErrorInterface**
+                                                   error));
+};
+
+class MockPool : public RequestPool {
+  public:
+    Error AddRequests(const Requests& requests) noexcept override {
+        return Error(AddRequests_t(requests));
+
+    }
+
+    MOCK_METHOD1(AddRequests_t, ErrorInterface * (const Requests&));
+};
+
+
+
+}
+
+#endif //ASAPO_MOCK_STATISTICS_H

receiver/unittests/receiver_data_server/test_receiver_data_server.cpp

+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+
+#include "unittests/MockLogger.h"
+#include "../../src/receiver_data_server/receiver_data_server.h"
+#include "../../src/receiver_data_server/tcp_server.h"
+#include "../../src/receiver_data_server/common.h"
+
+#include "receiver_dataserver_mocking.h"
+
+#include "common/io_error.h"
+#include "../../src/receiver_data_server/receiver_data_server_error.h"
+
+
+using ::testing::Test;
+using ::testing::Gt;
+using ::testing::Ge;
+using ::testing::Le;
+using ::testing::Eq;
+using ::testing::Ne;
+using ::testing::Ref;
+using ::testing::Return;
+using ::testing::_;
+using ::testing::SetArgPointee;
+using ::testing::NiceMock;
+using ::testing::HasSubstr;
+
+
+using asapo::MockLogger;
+using asapo::ReceiverDataServer;
+using asapo::Error;
+
+
+namespace {
+
+TEST(ReceiverDataServer, Constructor) {
+    ReceiverDataServer data_server;
+    ASSERT_THAT(dynamic_cast<const asapo::TcpServer*>(data_server.net__.get()), Ne(nullptr));
+    ASSERT_THAT(dynamic_cast<asapo::RequestPool*>(data_server.request_pool__.get()), Ne(nullptr));
+    ASSERT_THAT(dynamic_cast<const asapo::AbstractLogger*>(data_server.log__), Ne(nullptr));
+
+}
+
+class ReceiverDataServerTests : public Test {
+  public:
+    ReceiverDataServer data_server;
+    asapo::MockNetServer mock_net;
+    asapo::MockPool mock_pool;
+    NiceMock<asapo::MockLogger> mock_logger;
+    void SetUp() override {
+        data_server.net__ = std::unique_ptr<asapo::NetServer> {&mock_net};
+        data_server.request_pool__ = std::unique_ptr<asapo::RequestPool> {&mock_pool};
+        data_server.log__ = &mock_logger;
+
+    }
+    void TearDown() override {
+        data_server.net__.release();
+        data_server.request_pool__.release();
+    }
+};
+
+
+TEST_F(ReceiverDataServerTests, ErrorGetNewRequests) {
+
+    /*    EXPECT_CALL(mock_net, ProcessRequest_t(_)).WillOnce(
+            Return(nullptr)
+        ).WillOnce(
+            Return(new asapo::IOError("Test Send Error", asapo::IOErrorType::kUnknownIOError))
+        );
+    */
+
+    EXPECT_CALL(mock_net, GetNewRequests_t(_)).WillOnce(
+        DoAll(SetArgPointee<0>(asapo::IOErrorTemplates::kUnknownIOError.Generate().release()),
+              Return(asapo::Requests{})
+             )
+    );
+
+    auto errtext = asapo::IOErrorTemplates::kUnknownIOError.Generate()->Explain();
+
+    EXPECT_CALL(mock_logger, Error(AllOf(HasSubstr("stopped"), HasSubstr(errtext))));
+
+
+    data_server.Run();
+
+}
+
+TEST_F(ReceiverDataServerTests, ErrorAddingRequests) {
+
+    EXPECT_CALL(mock_net, GetNewRequests_t(_)).WillOnce(
+        DoAll(SetArgPointee<0>(nullptr),
+              Return(asapo::Requests{})
+             )
+    );
+
+    EXPECT_CALL(mock_pool, AddRequests_t(_)).WillOnce(
+        Return(asapo::ReceiverErrorTemplates::kMemoryPool.Generate("cannot add request to pool").release())
+    );
+
+    auto errtext = asapo::ReceiverErrorTemplates::kMemoryPool.Generate("cannot add request to pool")->Explain();
+
+    EXPECT_CALL(mock_logger, Error(AllOf(HasSubstr("stopped"), HasSubstr(errtext))));
+
+    data_server.Run();
+}
+
+
+
+}