Added VersionedLayerClient::PrefetchTiles method

Implemented the VersionedLayerClient::PrefetchTiles method in dataservice-read component, which is based on the CatalogClient::PrefetchTiles implementation.

Also, moved the integration and functional tests regarding the pre-fetch functionality from CatalogClientTest with following changes:
- added DataserviceReadVersionedLayerClientTest.cpp file to integration tests target;
- removed the PrefetchEmbedded integration test from tests in DataserviceReadVersionedLayerClientTest test suite (see OLPEDGE-906);
- re-enabled the PrefetchBusy test in both CatalogClientTest and DataserviceReadVersionedLayerClientTest.

Relates to: OLPEDGE-795

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

Author: Bohdan Kurylovych

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

@@ -28,6 +28,7 @@
 #include <olp/core/client/ApiResponse.h>
 #include <olp/core/client/OlpClientSettings.h>
 #include <olp/core/geo/tiling/TileKey.h>
+#include "olp/dataservice/read/PrefetchTileResult.h"
 #include "olp/dataservice/read/model/Catalog.h"
 #include "olp/dataservice/read/model/Data.h"
 #include "olp/dataservice/read/model/Partitions.h"
@@ -42,6 +43,8 @@ class HRN;
 namespace dataservice {
 namespace read {
 
+class PrefetchTilesRequest;
+
 namespace model {
 class Partition;
 }  // namespace model
@@ -79,52 +82,6 @@ using DataResult = model::Data;
 using DataResponse = client::ApiResponse<DataResult, client::ApiError>;
 using DataResponseCallback = std::function<void(DataResponse response)>;
 
-class PrefetchTilesRequest;
-class DATASERVICE_READ_API PrefetchTileNoError {
- public:
-  PrefetchTileNoError() = default;
-  PrefetchTileNoError(const PrefetchTileNoError& other) = default;
-  ~PrefetchTileNoError() = default;
-};
-
-class DATASERVICE_READ_API PrefetchTileResult
-    : public client::ApiResponse<PrefetchTileNoError, client::ApiError> {
- public:
-  PrefetchTileResult()
-      : client::ApiResponse<PrefetchTileNoError, client::ApiError>() {}
-
-  /**
-   * @brief PrefetchTileResult Constructor for a successfully executed request.
-   */
-  PrefetchTileResult(const geo::TileKey& tile,
-                     const PrefetchTileNoError& result)
-      : client::ApiResponse<PrefetchTileNoError, client::ApiError>(result),
-        tile_key_(tile) {}
-
-  /**
-   * @brief PrefetchTileResult Constructor if request unsuccessfully executed
-   */
-  PrefetchTileResult(const geo::TileKey& tile, const client::ApiError& error)
-      : client::ApiResponse<PrefetchTileNoError, client::ApiError>(error),
-        tile_key_(tile) {}
-
-  /**
-   * @brief PrefetchTileResult Copy constructor.
-   */
-  PrefetchTileResult(const PrefetchTileResult& r)
-      : client::ApiResponse<PrefetchTileNoError, client::ApiError>(r),
-        tile_key_(r.tile_key_) {}
-
-  /**
-   * @brief ApiResponse Constructor if request unsuccessfully executed
-   */
-  PrefetchTileResult(const client::ApiError& error)
-      : client::ApiResponse<PrefetchTileNoError, client::ApiError>(error) {}
-
- public:
-  geo::TileKey tile_key_;
-};
-
 /**
  * @brief The PrefetchTilesResponse class encapsulates the result of a prefetch
  * operation

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

@@ -0,0 +1,84 @@
+/*
+ * 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
+
+#include <olp/core/client/ApiError.h>
+#include <olp/core/client/ApiResponse.h>
+#include <olp/core/geo/tiling/TileKey.h>
+#include <olp/dataservice/read/DataServiceReadApi.h>
+
+namespace olp {
+namespace dataservice {
+namespace read {
+
+class DATASERVICE_READ_API PrefetchTileNoError {
+ public:
+  PrefetchTileNoError() = default;
+  PrefetchTileNoError(const PrefetchTileNoError& other) = default;
+  ~PrefetchTileNoError() = default;
+};
+
+/**
+ * @brif Class representing the result of pre-fetch operation.
+ * It will contain either a successful result represented as \c geo::TileKey
+ * object or will contain the failure error.
+ */
+class DATASERVICE_READ_API PrefetchTileResult
+    : public client::ApiResponse<PrefetchTileNoError, client::ApiError> {
+ public:
+  PrefetchTileResult()
+      : client::ApiResponse<PrefetchTileNoError, client::ApiError>() {}
+
+  /**
+   * @brief PrefetchTileResult Constructor for a successfully executed request.
+   */
+  PrefetchTileResult(const geo::TileKey& tile,
+                     const PrefetchTileNoError& result)
+      : client::ApiResponse<PrefetchTileNoError, client::ApiError>(result),
+        tile_key_(tile) {}
+
+  /**
+   * @brief PrefetchTileResult Constructor if request unsuccessfully executed
+   */
+  PrefetchTileResult(const geo::TileKey& tile, const client::ApiError& error)
+      : client::ApiResponse<PrefetchTileNoError, client::ApiError>(error),
+        tile_key_(tile) {}
+
+  /**
+   * @brief PrefetchTileResult Copy constructor.
+   */
+  PrefetchTileResult(const PrefetchTileResult& r)
+      : client::ApiResponse<PrefetchTileNoError, client::ApiError>(r),
+        tile_key_(r.tile_key_) {}
+
+  /**
+   * @brief ApiResponse Constructor if request unsuccessfully executed
+   */
+  PrefetchTileResult(const client::ApiError& error)
+      : client::ApiResponse<PrefetchTileNoError, client::ApiError>(error) {}
+
+ public:
+  /// The pre-fetched tile key.
+  geo::TileKey tile_key_;
+};
+
+}  // namespace read
+}  // namespace dataservice
+}  // namespace olp

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

@@ -20,6 +20,7 @@
 #pragma once
 
 #include <memory>
+#include <vector>
 
 #include <olp/core/client/ApiError.h>
 #include <olp/core/client/ApiResponse.h>
@@ -29,6 +30,8 @@
 #include <olp/dataservice/read/DataRequest.h>
 #include <olp/dataservice/read/DataServiceReadApi.h>
 #include <olp/dataservice/read/PartitionsRequest.h>
+#include <olp/dataservice/read/PrefetchTileResult.h>
+#include <olp/dataservice/read/PrefetchTilesRequest.h>
 #include <olp/dataservice/read/model/Data.h>
 #include <olp/dataservice/read/model/Partitions.h>
 
@@ -53,6 +56,16 @@ class DATASERVICE_READ_API VersionedLayerClient final {
   using PartitionsResponse =
       client::ApiResponse<PartitionsResult, client::ApiError>;
   using PartitionsCallback = std::function<void(PartitionsResponse response)>;
+
+  /// PrefetchTileResult alias
+  using PrefetchTilesResult = std::vector<std::shared_ptr<PrefetchTileResult>>;
+  /// Alias for the response to the \c PrefetchTileRequest
+  using PrefetchTilesResponse =
+      client::ApiResponse<PrefetchTilesResult, client::ApiError>;
+  /// Alias for the callback  to the results of PrefetchTilesResponse
+  using PrefetchTilesResponseCallback =
+      std::function<void(const PrefetchTilesResponse& response)>;
+
   /**
    * @brief VersionedLayerClient constructor
    * @param catalog this versioned layer client uses during requests.
@@ -93,6 +106,26 @@ class DATASERVICE_READ_API VersionedLayerClient final {
   client::CancellationToken GetPartitions(PartitionsRequest partitions_request,
                                           PartitionsCallback callback) const;
 
+  /**
+   * @brief Pre-fetches a set of tiles asychronously.
+   *
+   * This method recursively downloads all tilekeys from minLevel to maxLevel
+   * specified in the \c PrefetchTilesRequest's properties. This will help to
+   * reduce the network load by using the pre-fetched tiles' data from cache.
+   *
+   * \note - this does not guarantee that all tiles are available offline, as
+   * the cache might overflow and data might be evicted at any point.
+   *
+   * @param request contains the complete set of request parameters.
+   * \note The \c PrefetchTilesRequest's GetLayerId value will be ignored and
+   * the parameter from constructore will be used instead.
+   * @param callback will be invoked once the \c PrefetchTilesResult is
+   * available, or an error is encountered.
+   * @return A token that can be used to cancel this request.
+   */
+  olp::client::CancellationToken PrefetchTiles(
+      PrefetchTilesRequest request, PrefetchTilesResponseCallback callback);
+
  private:
   std::unique_ptr<VersionedLayerClientImpl> impl_;
 };

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

@@ -249,7 +249,7 @@ client::CancellationToken CatalogClientImpl::PrefetchTiles(
     callback(response);
   };
 
-  auto token = prefetch_provider_->PrefetchTiles(request, callback);
+  auto token = prefetch_provider_->PrefetchTiles(request, request_callback);
 
   pending_requests_->Insert(token, request_key);
   return token;

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

@@ -46,6 +46,11 @@ client::CancellationToken VersionedLayerClient::GetPartitions(
                               std::move(callback));
 }
 
+olp::client::CancellationToken VersionedLayerClient::PrefetchTiles(
+    PrefetchTilesRequest request, PrefetchTilesResponseCallback callback) {
+  return impl_->PrefetchTiles(std::move(request), std::move(callback));
+}
+
 }  // namespace read
 }  // namespace dataservice
 }  // namespace olp

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

@@ -23,12 +23,14 @@
 #include <olp/core/client/OlpClientSettingsFactory.h>
 #include <olp/core/context/Context.h>
 #include <olp/core/thread/TaskScheduler.h>
+#include "PrefetchTilesProvider.h"
 #include "TaskContext.h"
 #include "repositories/ApiRepository.h"
 #include "repositories/CatalogRepository.h"
 #include "repositories/DataRepository.h"
 #include "repositories/ExecuteOrSchedule.inl"
 #include "repositories/PartitionsRepository.h"
+#include "repositories/PrefetchTilesRepository.h"
 
 namespace olp {
 namespace dataservice {
@@ -58,6 +60,16 @@ VersionedLayerClientImpl::VersionedLayerClientImpl(
 
   partition_repo_ = std::make_shared<repository::PartitionsRepository>(
       catalog_, api_repo, catalog_repo, settings_->cache);
+
+  auto data_repo = std::make_shared<repository::DataRepository>(
+      catalog_, api_repo, catalog_repo, partition_repo_, settings_->cache);
+
+  auto prefetch_repo = std::make_shared<repository::PrefetchTilesRepository>(
+      catalog_, api_repo, partition_repo_->GetPartitionsCacheRepository(),
+      settings_);
+
+  prefetch_provider_ = std::make_shared<PrefetchTilesProvider>(
+      catalog_, api_repo, catalog_repo, data_repo, prefetch_repo, settings_);
 }
 
 VersionedLayerClientImpl::~VersionedLayerClientImpl() {
@@ -136,6 +148,23 @@ client::CancellationToken VersionedLayerClientImpl::AddGetDataTask(
   return context.CancelToken();
 }
 
+olp::client::CancellationToken VersionedLayerClientImpl::PrefetchTiles(
+    PrefetchTilesRequest request, PrefetchTilesResponseCallback callback) {
+  const int64_t request_key = pending_requests_->GenerateRequestPlaceholder();
+  auto pending_requests = pending_requests_;
+  auto request_callback = [=](const PrefetchTilesResponse& response) {
+    pending_requests->Remove(request_key);
+    if (callback) {
+      callback(response);
+    }
+  };
+
+  request.WithLayerId(layer_id_);
+  auto token = prefetch_provider_->PrefetchTiles(request, request_callback);
+  pending_requests->Insert(token, request_key);
+  return token;
+}
+
 }  // namespace read
 }  // namespace dataservice
 }  // namespace olp

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

@@ -30,6 +30,8 @@
 #include <olp/core/client/OlpClientSettings.h>
 #include <olp/dataservice/read/DataRequest.h>
 #include <olp/dataservice/read/PartitionsRequest.h>
+#include <olp/dataservice/read/PrefetchTileResult.h>
+#include <olp/dataservice/read/PrefetchTilesRequest.h>
 #include <olp/dataservice/read/model/Data.h>
 #include <olp/dataservice/read/model/Partitions.h>
 
@@ -43,6 +45,8 @@ namespace repository {
 class PartitionsRepository;
 }
 
+class PrefetchTilesProvider;
+
 class VersionedLayerClientImpl {
  public:
   /// DataResult alias
@@ -57,6 +61,15 @@ class VersionedLayerClientImpl {
       client::ApiResponse<PartitionsResult, client::ApiError>;
   using PartitionsCallback = std::function<void(PartitionsResponse response)>;
 
+  /// PrefetchTileResult alias
+  using PrefetchTilesResult = std::vector<std::shared_ptr<PrefetchTileResult>>;
+  /// Alias for the response to the \c PrefetchTileRequest
+  using PrefetchTilesResponse =
+      client::ApiResponse<PrefetchTilesResult, client::ApiError>;
+  /// Alias for the callback  to the results of PrefetchTilesResponse
+  using PrefetchTilesResponseCallback =
+      std::function<void(const PrefetchTilesResponse& response)>;
+
   VersionedLayerClientImpl(olp::client::HRN catalog, std::string layer_id,
                            olp::client::OlpClientSettings client_settings);
 
@@ -68,6 +81,9 @@ class VersionedLayerClientImpl {
   virtual client::CancellationToken GetPartitions(
       PartitionsRequest partitions_request, PartitionsCallback callback) const;
 
+  virtual olp::client::CancellationToken PrefetchTiles(
+      PrefetchTilesRequest request, PrefetchTilesResponseCallback callback);
+
  private:
   olp::client::CancellationToken AddGetDataTask(DataRequest data_request,
                                                 Callback callback) const;
@@ -79,6 +95,7 @@ class VersionedLayerClientImpl {
   std::shared_ptr<thread::TaskScheduler> task_scheduler_;
   std::shared_ptr<PendingRequests> pending_requests_;
   std::shared_ptr<repository::PartitionsRepository> partition_repo_;
+  std::shared_ptr<PrefetchTilesProvider> prefetch_provider_;
 };
 
 }  // namespace read