more work

producer/folder_monitor_producer/CMakeLists.txt

@@ -3,7 +3,8 @@ set(SOURCE_FILES
         src/event_detector.cpp
         src/foldermon_config.cpp
         src/foldermon_logger.cpp
-        )
+        src/event_detector_factory.cpp
+        src/inotify_event_detector.cpp)
 
 
 ################################
@@ -41,7 +42,7 @@ set_property(TARGET ${TARGET_NAME} PROPERTY ENABLE_EXPORTS true)
 set(TEST_SOURCE_FILES
         unittests/test_foldermon_config.cpp
         unittests/mock_foldermon_config.cpp
-#        unittests/test_event_detector_factory.cpp
+        unittests/test_event_detector_factory.cpp
    )
 
 set(TEST_LIBRARIES "${TARGET_NAME}")

producer/folder_monitor_producer/src/event_detector.h

 #ifndef ASAPO_EVENT_DETECTOR_H
 #define ASAPO_EVENT_DETECTOR_H
 
-namespace asapo {
+#include <memory>
+#include "producer/common.h"
 
-class EventDetector {
+namespace asapo {
 
+class AbstractEventDetector {
+  public:
+    virtual Error GetNextEvent(EventHeader* event_header) = 0;
 };
 
+using EventDetector = std::unique_ptr<AbstractEventDetector>;
 
 }
 

producer/folder_monitor_producer/src/event_detector_factory.cpp

+#include "event_detector_factory.h"
+
+#include "foldermon_config.h"
+#include "inotify_event_detector.h"
+
+namespace asapo {
+
+EventDetector EventDetectorFactory::CreateEventDetector() {
+    auto config = GetFolderMonConfig();
+    return EventDetector{new InotifyEventDetector(config)};
+}
+
+}
\ No newline at end of file

producer/folder_monitor_producer/src/event_detector_factory.h

+#ifndef ASAPO_EVENT_DETECTOR_FACTORY_H
+#define ASAPO_EVENT_DETECTOR_FACTORY_H
+
+#include "event_detector.h"
+#include "common/error.h"
+
+namespace asapo {
+
+class EventDetectorFactory {
+  public:
+    EventDetector CreateEventDetector();
+};
+
+}
+
+#endif //ASAPO_EVENT_DETECTOR_FACTORY_H

producer/folder_monitor_producer/src/foldermon_main.cpp

@@ -7,7 +7,8 @@
 #include "asapo_producer.h"
 #include "foldermon_config.h"
 #include "foldermon_config_factory.h"
-
+#include "event_detector_factory.h"
+#include "foldermon_logger.h"
 
 using asapo::Producer;
 using asapo::FolderMonConfigFactory;
@@ -29,7 +30,7 @@ std::unique_ptr<Producer> CreateProducer() {
 
     Error err;
     auto producer = Producer::Create(config->asapo_endpoint, config->nthreads,
-                                            config->mode, config->beamtime_id, &err);
+                                     config->mode, config->beamtime_id, &err);
     if(err) {
         std::cerr << "cannot create producer: " << err << std::endl;
         exit(EXIT_FAILURE);
@@ -40,6 +41,15 @@ std::unique_ptr<Producer> CreateProducer() {
 }
 
 
+void ProcessAfterSend(asapo::GenericRequestHeader header, asapo::Error err) {
+    if (err) {
+        const auto& logger = asapo::GetDefaultFolderMonLogger();
+        logger->Error("data was not successfully send: " + err->Explain());
+        return;
+    }
+}
+
+
 int main (int argc, char* argv[]) {
     auto err = ReadConfigFile(argc, argv);
     if (err) {
@@ -47,7 +57,31 @@ int main (int argc, char* argv[]) {
         return EXIT_FAILURE;
     }
 
+    const auto& logger = asapo::GetDefaultFolderMonLogger();
+    logger->SetLogLevel(GetFolderMonConfig()->log_level);
+
+
     auto producer = CreateProducer();
+    asapo::EventDetectorFactory factory;
+    auto event_detector = factory.CreateEventDetector();
+
+    int i = 0;
+    while (true && i < 1000) {
+        asapo::EventHeader event_header;
+        event_header.file_id = i++;
+        event_header.file_size = 0;
+        event_header.file_name = std::to_string(i);
+        auto err = event_detector->GetNextEvent(&event_header);
+        if (err) {
+            logger->Error("cannot retrieve next event: " + err->Explain());
+            continue;
+        }
+        producer->Send(event_header, nullptr, ProcessAfterSend);
+    }
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+
+
 
     return EXIT_SUCCESS;
 }

producer/folder_monitor_producer/src/inotify_event_detector.cpp

+#include "inotify_event_detector.h"
+
+namespace asapo {
+
+Error InotifyEventDetector::GetNextEvent(EventHeader* event_header) {
+    return nullptr;
+}
+InotifyEventDetector::InotifyEventDetector(const FolderMonConfig* config) : config_{config} {
+}
+
+}
\ No newline at end of file

producer/folder_monitor_producer/src/inotify_event_detector.h

+#ifndef ASAPO_INOTOFY_EVENT_DETECTOR_H
+#define ASAPO_INOTOFY_EVENT_DETECTOR_H
+
+#include "event_detector.h"
+#include "foldermon_config.h"
+
+namespace asapo {
+
+class InotifyEventDetector : public AbstractEventDetector {
+  public:
+    Error GetNextEvent(EventHeader* event_header) override;
+    InotifyEventDetector(const FolderMonConfig* config);
+  private:
+    const FolderMonConfig* config_;
+};
+
+}
+
+#endif //ASAPO_INOTOFY_EVENT_DETECTOR_H

producer/folder_monitor_producer/unittests/test_event_detector_factory.cpp

@@ -3,6 +3,8 @@
 
 #include "foldermon_mocking.h"
 #include "mock_foldermon_config.h"
+#include "../src/event_detector_factory.h"
+#include "../src/inotify_event_detector.h"
 
 using ::testing::Test;
 using ::testing::_;
@@ -12,41 +14,27 @@ using ::testing::Ne;
 using ::asapo::Error;
 
 
-//using asapo::EventDetectorFactory;
+using asapo::EventDetectorFactory;
 using asapo::FolderMonConfig;
 
 namespace {
 
 
 class FactoryTests : public Test {
- public:
-  //EventDetectorFactory factory;
-  Error err{nullptr};
-  FolderMonConfig config;
-  std::string asapo_endpoint{"endpoint"};
-  void SetUp() override {
-      config.asapo_endpoint = asapo_endpoint;
-      asapo::SetFolderMonConfig(config);
-  }
-  void TearDown() override {
-  }
+  public:
+    EventDetectorFactory factory;
+    Error err{nullptr};
+    FolderMonConfig config;
+    void SetUp() override {
+        asapo::SetFolderMonConfig(config);
+    }
+    void TearDown() override {
+    }
 };
 
-TEST_F(FactoryTests, ErrorOnWrongCode) {
-//    ASSERT_THAT(err, Ne(nullptr));
+TEST_F(FactoryTests, CreateDetector) {
+    auto event_detector = factory.CreateEventDetector();
+    ASSERT_THAT(dynamic_cast<asapo::InotifyEventDetector*>(event_detector.get()), Ne(nullptr));
 }
 
-
-
-TEST_F(FactoryTests, DoNotAddDiskWriterIfNotWanted) {
-//    config.write_to_disk = false;
-//    SetReceiverConfig(config);
-
-//      ASSERT_THAT(err, Eq(nullptr));
-//    ASSERT_THAT(request->GetListHandlers().size(), Eq(2));
-//    ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerAuthorize*>(request->GetListHandlers()[0]), Ne(nullptr));
-//    ASSERT_THAT(dynamic_cast<const asapo::RequestHandlerDbWrite*>(request->GetListHandlers().back()), Ne(nullptr));
-}
-
-
 }