Moved the auto-flush props from FlushSettings into AutoFlushSettings

Moved the auto-flush specific properties (auto_flush_num_events, auto_flush_interval, events_per_single_flush) from FlushSettings into AutoFlushSettings with following changes:
- the return type of `events_per_single_flush` changed to int;
- the AutoFlushSettings is now part of the private API.

Also, removed all the auto-flush functional and integration tests, because the auto-flush mechanism is no longer part of public API.

Relates to: OLPEDGE-826

Signed-off-by: Bohdan Kurylovych <[email protected]>

Author: Bohdan Kurylovych

olp-cpp-sdk-dataservice-write/include/olp/dataservice/write/FlushSettings.h

@@ -30,23 +30,6 @@ namespace dataservice {
 namespace write {
 
 struct DATASERVICE_WRITE_API FlushSettings {
-  /**
-   * How many requests can be cached before an auto flush event is triggered.
-   */
-  int auto_flush_num_events = 20;
-
-  /**
-   * The period (in seconds) between sequential auto flush events when using
-   * interval based auto-flush. Setting 0 indicates this feature is disabled.
-   */
-  int auto_flush_interval = 0;
-
-  /**
-    @brief The maximum number of partitions to be flushed each time.Set
-    boost::none to flush all partitions. Non-positive number will flush nothing.
-  */
-  boost::optional<int> events_per_single_flush = boost::none;
-
   /**
     @brief The maximum number of requests that can be stored
     boost::none to store all requests. Must be positive.

olp-cpp-sdk-dataservice-write/src/AutoFlushController.cpp

@@ -19,6 +19,7 @@
 
 #include "AutoFlushController.h"
 
+#include <olp/dataservice/write/StreamLayerClient.h>
 #include "BackgroundTaskCollection.h"
 #include "StreamLayerClientImpl.h"
 #include "TimeUtils.h"
@@ -59,10 +60,10 @@ class EnabledAutoFlushControllerImpl
           EnabledAutoFlushControllerImpl<ClientImpl, FlushResponse>> {
  public:
   EnabledAutoFlushControllerImpl(
-      std::shared_ptr<ClientImpl> client_impl, FlushSettings flush_settings,
+      std::shared_ptr<ClientImpl> client_impl, AutoFlushSettings flush_settings,
       std::shared_ptr<FlushEventListener<FlushResponse>> listener)
       : client_impl_(client_impl),
-        flush_settings_(flush_settings),
+        flush_settings_(std::move(flush_settings)),
         listener_(listener),
         background_task_col_(),
         cancel_mutex_(),
@@ -169,9 +170,7 @@ class EnabledAutoFlushControllerImpl
       auto id = self->background_task_col_.AddTask();
 
       const auto num_requests_to_flush =
-          self->flush_settings_.events_per_single_flush
-              ? *(self->flush_settings_.events_per_single_flush)
-              : 0;
+          self->flush_settings_.events_per_single_flush;
       model::FlushRequest request =
           model::FlushRequest().WithNumberOfRequestsToFlush(
               num_requests_to_flush);
@@ -224,15 +223,16 @@ class EnabledAutoFlushControllerImpl
 
  private:
   std::weak_ptr<ClientImpl> client_impl_;
-  FlushSettings flush_settings_;
+  AutoFlushSettings flush_settings_;
   std::shared_ptr<FlushEventListener<FlushResponse>> listener_;
   BackgroundTaskCollection<size_t> background_task_col_;
   std::mutex cancel_mutex_;
   std::map<size_t, olp::client::CancellationToken> cancel_token_map_;
   bool is_cancelled_{false};
 };
 
-AutoFlushController::AutoFlushController(const FlushSettings& flush_settings)
+AutoFlushController::AutoFlushController(
+    const AutoFlushSettings& flush_settings)
     : flush_settings_(flush_settings),
       impl_(std::make_shared<DisabledAutoFlushControllerImpl>()) {}
 

olp-cpp-sdk-dataservice-write/src/AutoFlushController.h

@@ -19,18 +19,19 @@
 
 #pragma once
 
+#include <future>
 #include <memory>
 
 #include <olp/dataservice/write/FlushEventListener.h>
-#include <olp/dataservice/write/StreamLayerClient.h>
+#include "AutoFlushSettings.h"
 
 namespace olp {
 namespace dataservice {
 namespace write {
 
 class AutoFlushController {
  public:
-  AutoFlushController(const FlushSettings& flush_settings);
+  AutoFlushController(const AutoFlushSettings& flush_settings);
 
   template <typename ClientImpl, typename FlushResponse>
   void Enable(std::shared_ptr<ClientImpl> client_impl,
@@ -56,7 +57,7 @@ class AutoFlushController {
   };
 
  private:
-  FlushSettings flush_settings_;
+  AutoFlushSettings flush_settings_;
   std::shared_ptr<AutoFlushControllerImpl> impl_;
 };
 

olp-cpp-sdk-dataservice-write/src/AutoFlushSettings.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2019 HERE Europe B.V.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * License-Filename: LICENSE
+ */
+
+#pragma once
+
+namespace olp {
+namespace dataservice {
+namespace write {
+
+struct AutoFlushSettings {
+  /**
+   * How many requests can be cached before an auto flush event is triggered.
+   */
+  int auto_flush_num_events = 20;
+
+  /**
+   * The period (in seconds) between sequential auto flush events when using
+   * interval based auto-flush. Setting 0 indicates this feature is disabled.
+   */
+  int auto_flush_interval = 0;
+
+  /**
+    @brief The maximum number of partitions to be flushed each time.Set
+    0 to flush all partitions. Non-positive number will flush nothing.
+  */
+  int events_per_single_flush = 0;
+};
+
+}  // namespace write
+}  // namespace dataservice
+}  // namespace olp

olp-cpp-sdk-dataservice-write/src/StreamLayerClientImpl.cpp

@@ -90,7 +90,7 @@ StreamLayerClientImpl::StreamLayerClientImpl(HRN catalog,
       cache_(settings_.cache),
       cache_mutex_(),
       flush_settings_(std::move(flush_settings)),
-      auto_flush_controller_(new AutoFlushController(flush_settings_)) {}
+      auto_flush_controller_(new AutoFlushController(AutoFlushSettings{})) {}
 
 CancellationToken StreamLayerClientImpl::InitApiClients(
     const std::shared_ptr<CancellationContext>& cancel_context,