GetPartitions for VersionedLayerClient

The method introduced. Currently it has the same implementation as
CatalogClient, but defines new interface.
Test for VersionedLayerClient moved to integration test subsystem.

Resolves: OLPEDGE-793

Signed-off-by: Sergii Vostrikov <[email protected]>

Author: sergii-vostrikov

olp-cpp-sdk-dataservice-read/include/olp/dataservice/read/VersionedLayerClient.h

@@ -28,7 +28,9 @@
 #include <olp/core/client/OlpClientSettings.h>
 #include <olp/dataservice/read/DataRequest.h>
 #include <olp/dataservice/read/DataServiceReadApi.h>
+#include <olp/dataservice/read/PartitionsRequest.h>
 #include <olp/dataservice/read/model/Data.h>
+#include <olp/dataservice/read/model/Partitions.h>
 
 namespace olp {
 namespace dataservice {
@@ -47,6 +49,10 @@ class DATASERVICE_READ_API VersionedLayerClient final {
   /// Callback alias
   using Callback = std::function<void(CallbackResponse response)>;
 
+  using PartitionsResult = model::Partitions;
+  using PartitionsResponse =
+      client::ApiResponse<PartitionsResult, client::ApiError>;
+  using PartitionsCallback = std::function<void(PartitionsResponse response)>;
   /**
    * @brief VersionedLayerClient constructor
    * @param catalog this versioned layer client uses during requests.
@@ -75,6 +81,18 @@ class DATASERVICE_READ_API VersionedLayerClient final {
   olp::client::CancellationToken GetData(DataRequest data_request,
                                          Callback callback);
 
+  /**
+   * @brief fetches a list partitions for given generic layer asynchronously.
+   * @param request contains the complete set of request parameters.
+   * \note \c PartitionsRequest's GetLayerId value will be ignored and the
+   * parameter from the constructor will be used instead.
+   * @param callback will be invoked once the list of partitions is available,
+   * or an error is encountered.
+   * @return A token that can be used to cancel this request
+   */
+  client::CancellationToken GetPartitions(PartitionsRequest partitions_request,
+                                          PartitionsCallback callback) const;
+
  private:
   std::unique_ptr<VersionedLayerClientImpl> impl_;
 };

olp-cpp-sdk-dataservice-read/src/VersionedLayerClient.cpp

@@ -40,6 +40,12 @@ olp::client::CancellationToken VersionedLayerClient::GetData(
   return impl_->GetData(std::move(data_request), std::move(callback));
 }
 
+client::CancellationToken VersionedLayerClient::GetPartitions(
+    PartitionsRequest partitions_request, PartitionsCallback callback) const {
+  return impl_->GetPartitions(std::move(partitions_request),
+                              std::move(callback));
+}
+
 }  // namespace read
 }  // namespace dataservice
 }  // namespace olp

olp-cpp-sdk-dataservice-read/src/VersionedLayerClientImpl.cpp

@@ -24,6 +24,7 @@
 #include <olp/core/context/Context.h>
 #include <olp/core/thread/TaskScheduler.h>
 #include "TaskContext.h"
+#include "repositories/ApiRepository.h"
 #include "repositories/CatalogRepository.h"
 #include "repositories/DataRepository.h"
 #include "repositories/ExecuteOrSchedule.inl"
@@ -38,21 +39,62 @@ VersionedLayerClientImpl::VersionedLayerClientImpl(
     olp::client::OlpClientSettings client_settings)
     : catalog_(std::move(catalog)),
       layer_id_(std::move(layer_id)),
-      settings_(std::move(client_settings)),
+      settings_(std::make_shared<olp::client::OlpClientSettings>(
+          std::move(client_settings))),
       pending_requests_(std::make_shared<PendingRequests>()) {
-  if (!settings_.cache) {
-    settings_.cache =
+  if (!settings_->cache) {
+    settings_->cache =
         olp::client::OlpClientSettingsFactory::CreateDefaultCache({});
   }
   // to avoid capturing task scheduler inside a task, we need a copy of settings
   // without the scheduler
-  task_scheduler_ = std::move(settings_.task_scheduler);
+  task_scheduler_ = std::move(settings_->task_scheduler);
+
+  auto api_repo = std::make_shared<repository::ApiRepository>(
+      catalog_, settings_, settings_->cache);
+
+  auto catalog_repo = std::make_shared<repository::CatalogRepository>(
+      catalog_, api_repo, settings_->cache);
+
+  partition_repo_ = std::make_shared<repository::PartitionsRepository>(
+      catalog_, api_repo, catalog_repo, settings_->cache);
 }
 
 VersionedLayerClientImpl::~VersionedLayerClientImpl() {
   pending_requests_->CancelPendingRequests();
 }
 
+client::CancellationToken VersionedLayerClientImpl::GetPartitions(
+    PartitionsRequest partitions_request, PartitionsCallback callback) const {
+  partitions_request.WithLayerId(layer_id_);
+  olp::client::CancellationToken token;
+  int64_t request_key = pending_requests_->GenerateRequestPlaceholder();
+  auto pending_requests = pending_requests_;
+  auto request_callback = [pending_requests, request_key,
+                           callback](PartitionsResponse response) {
+    if (pending_requests->Remove(request_key)) {
+      callback(response);
+    }
+  };
+  if (CacheWithUpdate == partitions_request.GetFetchOption()) {
+    token = partition_repo_->GetPartitions(
+        partitions_request.WithFetchOption(CacheOnly), request_callback);
+    auto onlineKey = pending_requests_->GenerateRequestPlaceholder();
+    pending_requests_->Insert(
+        partition_repo_->GetPartitions(
+            partitions_request.WithFetchOption(OnlineIfNotFound),
+            [pending_requests, onlineKey](PartitionsResponse) {
+              pending_requests->Remove(onlineKey);
+            }),
+        onlineKey);
+  } else {
+    token =
+        partition_repo_->GetPartitions(partitions_request, request_callback);
+  }
+  pending_requests_->Insert(token, request_key);
+  return token;
+}
+
 olp::client::CancellationToken VersionedLayerClientImpl::GetData(
     DataRequest data_request, Callback callback) const {
   auto fetch_option = data_request.GetFetchOption();
@@ -74,7 +116,7 @@ client::CancellationToken VersionedLayerClientImpl::AddGetDataTask(
     DataRequest request, Callback callback) const {
   auto catalog = catalog_;
   auto layer_id = layer_id_;
-  auto settings = settings_;
+  auto settings = *settings_;
   auto pending_requests = pending_requests_;
 
   auto data_task = [=](client::CancellationContext context) {

olp-cpp-sdk-dataservice-read/src/VersionedLayerClientImpl.h

@@ -29,15 +29,19 @@
 #include <olp/core/client/HRN.h>
 #include <olp/core/client/OlpClientSettings.h>
 #include <olp/dataservice/read/DataRequest.h>
+#include <olp/dataservice/read/PartitionsRequest.h>
 #include <olp/dataservice/read/model/Data.h>
+#include <olp/dataservice/read/model/Partitions.h>
 
 namespace olp {
 namespace thread {
 class TaskScheduler;
 }
-
 namespace dataservice {
 namespace read {
+namespace repository {
+class PartitionsRepository;
+}
 
 class VersionedLayerClientImpl {
  public:
@@ -48,6 +52,11 @@ class VersionedLayerClientImpl {
   /// Callback alias
   using Callback = std::function<void(CallbackResponse response)>;
 
+  using PartitionsResult = model::Partitions;
+  using PartitionsResponse =
+      client::ApiResponse<PartitionsResult, client::ApiError>;
+  using PartitionsCallback = std::function<void(PartitionsResponse response)>;
+
   VersionedLayerClientImpl(olp::client::HRN catalog, std::string layer_id,
                            olp::client::OlpClientSettings client_settings);
 
@@ -56,16 +65,20 @@ class VersionedLayerClientImpl {
   virtual olp::client::CancellationToken GetData(DataRequest data_request,
                                                  Callback callback) const;
 
+  virtual client::CancellationToken GetPartitions(
+      PartitionsRequest partitions_request, PartitionsCallback callback) const;
+
  private:
   olp::client::CancellationToken AddGetDataTask(DataRequest data_request,
                                                 Callback callback) const;
 
  protected:
   olp::client::HRN catalog_;
   std::string layer_id_;
-  olp::client::OlpClientSettings settings_;
+  std::shared_ptr<olp::client::OlpClientSettings> settings_;
   std::shared_ptr<thread::TaskScheduler> task_scheduler_;
   std::shared_ptr<PendingRequests> pending_requests_;
+  std::shared_ptr<repository::PartitionsRepository> partition_repo_;
 };
 
 }  // namespace read

olp-cpp-sdk-dataservice-read/tests/CMakeLists.txt

@@ -30,7 +30,6 @@ set(OLP_SDK_DATASERVICE_READ_TEST_SOURCES
     TaskContextTest.cpp
     VolatileLayerClientImplTest.cpp
     VolatileLayerClientTest.cpp
-    VersionedLayerClientTest.cpp
 )
 
 if (ANDROID OR IOS)