Implemented the PrefetchTiles with CancellableFuture in versioned client

- Implemented the PrefetchTiles method which returns CancellableFuture in the dataservice-read VersionedLayerClient class.
- aligned the API of PrefetchTiles methods with other methods;
- used the move semantics for the PrefetchTiles responses;

Relates to: OLPEDGE-958

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

Author: Bohdan Kurylovych

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

@@ -126,7 +126,28 @@ class DATASERVICE_READ_API VersionedLayerClient final {
    * @return A token that can be used to cancel this request.
    */
   client::CancellationToken PrefetchTiles(
-      PrefetchTilesRequest request, PrefetchTilesResponseCallback callback);
+      PrefetchTilesRequest request,
+      PrefetchTilesResponseCallback 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.
+   * @return CancellableFuture of type \c PrefetchTilesResponse, which when
+   * complete will contain the data or an error. Alternatively, the
+   * \c CancellableFuture can be used to cancel this request.
+   */
+  client::CancellableFuture<PrefetchTilesResponse> PrefetchTiles(
+      PrefetchTilesRequest request) const;
 
  private:
   std::unique_ptr<VersionedLayerClientImpl> impl_;

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

@@ -46,10 +46,16 @@ client::CancellationToken VersionedLayerClient::GetPartitions(
 }
 
 client::CancellationToken VersionedLayerClient::PrefetchTiles(
-    PrefetchTilesRequest request, PrefetchTilesResponseCallback callback) {
+    PrefetchTilesRequest request,
+    PrefetchTilesResponseCallback callback) const {
   return impl_->PrefetchTiles(std::move(request), std::move(callback));
 }
 
+client::CancellableFuture<VersionedLayerClient::PrefetchTilesResponse>
+VersionedLayerClient::PrefetchTiles(PrefetchTilesRequest request) const {
+  return impl_->PrefetchTiles(std::move(request));
+}
+
 }  // namespace read
 }  // namespace dataservice
 }  // namespace olp

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

@@ -148,13 +148,14 @@ client::CancellationToken VersionedLayerClientImpl::GetData(
 }
 
 client::CancellationToken VersionedLayerClientImpl::PrefetchTiles(
-    PrefetchTilesRequest request, PrefetchTilesResponseCallback callback) {
+    PrefetchTilesRequest request,
+    PrefetchTilesResponseCallback callback) const {
   const int64_t request_key = pending_requests_->GenerateRequestPlaceholder();
   auto pending_requests = pending_requests_;
-  auto request_callback = [=](const PrefetchTilesResponse& response) {
+  auto request_callback = [=](PrefetchTilesResponse response) {
     pending_requests->Remove(request_key);
     if (callback) {
-      callback(response);
+      callback(std::move(response));
     }
   };
 
@@ -164,6 +165,17 @@ client::CancellationToken VersionedLayerClientImpl::PrefetchTiles(
   return token;
 }
 
+client::CancellableFuture<PrefetchTilesResponse>
+VersionedLayerClientImpl::PrefetchTiles(PrefetchTilesRequest request) const {
+  auto promise = std::make_shared<std::promise<PrefetchTilesResponse>>();
+  auto cancel_token = PrefetchTiles(std::move(request),
+                                    [promise](PrefetchTilesResponse response) {
+                                      promise->set_value(std::move(response));
+                                    });
+  return client::CancellableFuture<PrefetchTilesResponse>(cancel_token,
+                                                          promise);
+}
+
 }  // namespace read
 }  // namespace dataservice
 }  // namespace olp

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

@@ -82,7 +82,11 @@ class VersionedLayerClientImpl {
       PartitionsRequest partitions_request, PartitionsCallback callback) const;
 
   virtual client::CancellationToken PrefetchTiles(
-      PrefetchTilesRequest request, PrefetchTilesResponseCallback callback);
+      PrefetchTilesRequest request,
+      PrefetchTilesResponseCallback callback) const;
+
+  virtual client::CancellableFuture<PrefetchTilesResponse> PrefetchTiles(
+      PrefetchTilesRequest request) const;
 
  protected:
   client::HRN catalog_;

tests/functional/olp-cpp-sdk-dataservice-read/DataserviceReadVersionedLayerClientTest.cpp

@@ -199,7 +199,7 @@ TEST_F(DataserviceReadVersionedLayerClientTest, Prefetch) {
     auto token = client->PrefetchTiles(
         request,
         [&promise](VersionedLayerClient::PrefetchTilesResponse response) {
-          promise.set_value(response);
+          promise.set_value(std::move(response));
         });
 
     ASSERT_NE(future.wait_for(kWaitTimeout), std::future_status::timeout);
@@ -267,4 +267,41 @@ TEST_F(DataserviceReadVersionedLayerClientTest, Prefetch) {
   }
 }
 
+TEST_F(DataserviceReadVersionedLayerClientTest, PrefetchWithCancellableFuture) {
+  const auto catalog =
+      olp::client::HRN::FromString(CustomParameters::getArgument(
+          "dataservice_read_test_versioned_prefetch_catalog"));
+  const auto kLayerId = CustomParameters::getArgument(
+      "dataservice_read_test_versioned_prefetch_layer");
+  const auto kTileId = CustomParameters::getArgument(
+      "dataservice_read_test_versioned_prefetch_tile");
+
+  auto client = std::make_unique<olp::dataservice::read::VersionedLayerClient>(
+      catalog, kLayerId, *settings_);
+
+  std::vector<olp::geo::TileKey> tile_keys = {
+      olp::geo::TileKey::FromHereTile(kTileId)};
+
+  auto request = olp::dataservice::read::PrefetchTilesRequest()
+                     .WithTileKeys(tile_keys)
+                     .WithMinLevel(10)
+                     .WithMaxLevel(12);
+  auto cancel_future = client->PrefetchTiles(std::move(request));
+
+  auto raw_future = cancel_future.GetFuture();
+  ASSERT_NE(raw_future.wait_for(kWaitTimeout), std::future_status::timeout);
+  VersionedLayerClient::PrefetchTilesResponse response = raw_future.get();
+  EXPECT_SUCCESS(response);
+  ASSERT_FALSE(response.GetResult().empty());
+
+  const auto& result = response.GetResult();
+
+  for (auto tile_result : result) {
+    EXPECT_SUCCESS(*tile_result);
+    ASSERT_TRUE(tile_result->tile_key_.IsValid());
+  }
+
+  ASSERT_EQ(6u, result.size());
+}
+
 }  // namespace

tests/integration/olp-cpp-sdk-dataservice-read/VersionedLayerClientTest.cpp

@@ -1478,7 +1478,7 @@ TEST_F(DataserviceReadVersionedLayerClientTest, PrefetchTilesWithCache) {
     auto token = client->PrefetchTiles(
         request,
         [&promise](VersionedLayerClient::PrefetchTilesResponse response) {
-          promise.set_value(response);
+          promise.set_value(std::move(response));
         });
 
     ASSERT_NE(future.wait_for(kWaitTimeout), std::future_status::timeout);
@@ -1580,7 +1580,7 @@ TEST_F(DataserviceReadVersionedLayerClientTest, PrefetchTilesBusy) {
   auto token1 = client->PrefetchTiles(
       request1,
       [&promise1](VersionedLayerClient::PrefetchTilesResponse response) {
-        promise1.set_value(response);
+        promise1.set_value(std::move(response));
       });
 
   // Wait for QuadKey request
@@ -1602,7 +1602,7 @@ TEST_F(DataserviceReadVersionedLayerClientTest, PrefetchTilesBusy) {
   auto token2 = client->PrefetchTiles(
       request2,
       [&promise2](VersionedLayerClient::PrefetchTilesResponse response) {
-        promise2.set_value(response);
+        promise2.set_value(std::move(response));
       });
 
   // Unblock the QuadKey request
@@ -1668,7 +1668,7 @@ TEST_F(DataserviceReadVersionedLayerClientTest,
   auto token = client->PrefetchTiles(
       request,
       [&promise](VersionedLayerClient::PrefetchTilesResponse response) {
-        promise.set_value(response);
+        promise.set_value(std::move(response));
       });
 
   wait_for_cancel->get_future().get();
@@ -1735,4 +1735,82 @@ TEST_F(DataserviceReadVersionedLayerClientTest, PrefetchTilesCancelOnLookup) {
             olp::client::ErrorCode::Cancelled);
 }
 
+TEST_F(DataserviceReadVersionedLayerClientTest,
+       PrefetchTilesWithCancellableFuture) {
+  olp::client::HRN catalog(GetTestCatalog());
+  constexpr auto kLayerId = "hype-test-prefetch";
+
+  std::vector<olp::geo::TileKey> tile_keys = {
+      olp::geo::TileKey::FromHereTile("5904591")};
+
+  auto request = olp::dataservice::read::PrefetchTilesRequest()
+                     .WithTileKeys(tile_keys)
+                     .WithMinLevel(10)
+                     .WithMaxLevel(12);
+
+  auto client = std::make_unique<olp::dataservice::read::VersionedLayerClient>(
+      catalog, kLayerId, *settings_);
+  ASSERT_TRUE(client);
+
+  auto cancel_future = client->PrefetchTiles(request);
+  auto raw_future = cancel_future.GetFuture();
+
+  ASSERT_NE(raw_future.wait_for(kWaitTimeout), std::future_status::timeout);
+  VersionedLayerClient::PrefetchTilesResponse response = raw_future.get();
+  ASSERT_TRUE(response.IsSuccessful()) << response.GetError().GetMessage();
+  ASSERT_FALSE(response.GetResult().empty());
+
+  const auto& result = response.GetResult();
+  for (auto tile_result : result) {
+    ASSERT_TRUE(tile_result->IsSuccessful())
+        << tile_result->GetError().GetMessage();
+    ASSERT_TRUE(tile_result->tile_key_.IsValid());
+  }
+}
+
+TEST_F(DataserviceReadVersionedLayerClientTest,
+       CancelPrefetchTilesWithCancellableFuture) {
+  olp::client::HRN catalog(GetTestCatalog());
+  constexpr auto kLayerId = "hype-test-prefetch";
+
+  std::vector<olp::geo::TileKey> tile_keys = {
+      olp::geo::TileKey::FromHereTile("5904591")};
+
+  auto request = olp::dataservice::read::PrefetchTilesRequest()
+                     .WithTileKeys(tile_keys)
+                     .WithMinLevel(10)
+                     .WithMaxLevel(12);
+
+  auto client = std::make_unique<olp::dataservice::read::VersionedLayerClient>(
+      catalog, kLayerId, *settings_);
+  ASSERT_TRUE(client);
+
+  auto wait_for_cancel = std::make_shared<std::promise<void>>();
+  auto pause_for_cancel = std::make_shared<std::promise<void>>();
+
+  olp::http::RequestId request_id;
+  NetworkCallback send_mock;
+  CancelCallback cancel_mock;
+  std::tie(request_id, send_mock, cancel_mock) = GenerateNetworkMockActions(
+      wait_for_cancel, pause_for_cancel,
+      {olp::http::HttpStatusCode::OK, HTTP_RESPONSE_LOOKUP_QUERY});
+  EXPECT_CALL(*network_mock_, Send(_, _, _, _, _))
+      .WillOnce(testing::Invoke(std::move(send_mock)));
+
+  EXPECT_CALL(*network_mock_, Cancel(_))
+      .WillOnce(testing::Invoke(std::move(cancel_mock)));
+
+  auto cancel_future = client->PrefetchTiles(request);
+
+  wait_for_cancel->get_future().get();
+  cancel_future.GetCancellationToken().cancel();
+  pause_for_cancel->set_value();
+
+  auto raw_future = cancel_future.GetFuture();
+  ASSERT_NE(raw_future.wait_for(kWaitTimeout), std::future_status::timeout);
+  VersionedLayerClient::PrefetchTilesResponse response = raw_future.get();
+  ASSERT_FALSE(response.IsSuccessful());
+  ASSERT_TRUE(response.GetResult().empty());
+}
+
 }  // namespace