Extend the DataResponse with NetworkStatistics (#1353)

Enable the GetData API to return NetworkStatistics along with response

Relates-To: OAM-1718

Signed-off-by: Mykhailo Kuchma <[email protected]>

Author: mykhailo-kuchma

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

@@ -79,9 +79,9 @@ using PartitionsResponseCallback =
 /// The `Data` alias type.
 using DataResult = model::Data;
 /// The data response alias.
-using DataResponse = Response<DataResult>;
+using DataResponse = Response<DataResult, client::NetworkStatistics>;
 /// The callback type of the data response.
-using DataResponseCallback = Callback<DataResult>;
+using DataResponseCallback = Callback<DataResult, client::NetworkStatistics>;
 
 /// The aggregated data response alias.
 using AggregatedDataResponse =

olp-cpp-sdk-dataservice-read/src/repositories/DataRepository.cpp

@@ -64,13 +64,15 @@ DataResponse DataRepository::GetVersionedTile(
                                   storage_);
   auto response = repository.GetTile(request, version, context);
 
+  auto network_statistics = response.GetPayload();
+
   if (!response.IsSuccessful()) {
     OLP_SDK_LOG_WARNING_F(
         kLogTag,
         "GetVersionedDataTile partition request failed, hrn='%s', key='%s'",
         catalog_.ToCatalogHRNString().c_str(),
         request.CreateKey(layer_id).c_str());
-    return response.GetError();
+    return DataResponse(response.GetError(), network_statistics);
   }
 
   // Get the data using a data handle for requested tile
@@ -79,27 +81,39 @@ DataResponse DataRepository::GetVersionedTile(
                                 .WithDataHandle(partition.GetDataHandle())
                                 .WithFetchOption(request.GetFetchOption());
 
-  return GetBlobData(layer_id, kBlobService, data_request, std::move(context));
+  auto data_response =
+      GetBlobData(layer_id, kBlobService, data_request, std::move(context));
+  network_statistics += data_response.GetPayload();
+
+  if (data_response) {
+    return DataResponse(data_response.MoveResult(), network_statistics);
+  } else {
+    return DataResponse(data_response.GetError(), network_statistics);
+  }
 }
 
 BlobApi::DataResponse DataRepository::GetVersionedData(
     const std::string& layer_id, const DataRequest& request, int64_t version,
     client::CancellationContext context, const bool fail_on_cache_error) {
   if (request.GetDataHandle() && request.GetPartitionId()) {
-    return {{client::ErrorCode::PreconditionFailed,
-             "Both data handle and partition id specified"}};
+    return client::ApiError::PreconditionFailed(
+        "Both data handle and partition id specified");
   }
 
   auto blob_request = request;
+  client::NetworkStatistics network_statistics;
+
   if (!request.GetDataHandle()) {
     // get data handle for a partition to be queried
     PartitionsRepository repository(catalog_, layer_id, settings_,
                                     lookup_client_, storage_);
     auto partitions_response =
         repository.GetPartitionById(request, version, context);
 
+    network_statistics = partitions_response.GetPayload();
+
     if (!partitions_response.IsSuccessful()) {
-      return partitions_response.GetError();
+      return DataResponse(partitions_response.GetError(), network_statistics);
     }
 
     const auto& partitions = partitions_response.GetResult().GetPartitions();
@@ -112,16 +126,25 @@ BlobApi::DataResponse DataRepository::GetVersionedData(
           catalog_.ToCatalogHRNString().c_str(),
           request.CreateKey(layer_id, version).c_str());
 
-      return {{client::ErrorCode::NotFound, "Partition not found"}};
+      return DataResponse(client::ApiError::NotFound("Partition not found"),
+                          network_statistics);
     }
 
     blob_request.WithDataHandle(partitions.front().GetDataHandle());
   }
 
   // finally get the data using a data handle
-  return repository::DataRepository::GetBlobData(
+  auto data_response = repository::DataRepository::GetBlobData(
       layer_id, kBlobService, blob_request, std::move(context),
       fail_on_cache_error);
+
+  network_statistics += data_response.GetPayload();
+
+  if (data_response) {
+    return DataResponse(data_response.MoveResult(), network_statistics);
+  } else {
+    return DataResponse(data_response.GetError(), network_statistics);
+  }
 }
 
 BlobApi::DataResponse DataRepository::GetBlobData(
@@ -132,7 +155,7 @@ BlobApi::DataResponse DataRepository::GetBlobData(
   const auto& data_handle = request.GetDataHandle();
 
   if (!data_handle) {
-    return {{client::ErrorCode::PreconditionFailed, "Data handle is missing"}};
+    return client::ApiError::PreconditionFailed("Data handle is missing");
   }
 
   NamedMutex mutex(storage_, catalog_.ToString() + layer + *data_handle);
@@ -157,8 +180,8 @@ BlobApi::DataResponse DataRepository::GetBlobData(
       OLP_SDK_LOG_INFO_F(
           kLogTag, "GetBlobData not found in cache, hrn='%s', key='%s'",
           catalog_.ToCatalogHRNString().c_str(), data_handle->c_str());
-      return {{client::ErrorCode::NotFound,
-               "CacheOnly: resource not found in cache"}};
+      return client::ApiError::NotFound(
+          "CacheOnly: resource not found in cache");
     }
   }
 
@@ -231,8 +254,8 @@ BlobApi::DataResponse DataRepository::GetVolatileData(
     const std::string& layer_id, const DataRequest& request,
     client::CancellationContext context, const bool fail_on_cache_error) {
   if (request.GetDataHandle() && request.GetPartitionId()) {
-    return {{client::ErrorCode::PreconditionFailed,
-             "Both data handle and partition id specified"}};
+    return client::ApiError::PreconditionFailed(
+        "Both data handle and partition id specified");
   }
 
   auto blob_request = request;
@@ -255,7 +278,7 @@ BlobApi::DataResponse DataRepository::GetVolatileData(
           catalog_.ToCatalogHRNString().c_str(),
           request.CreateKey(layer_id, boost::none).c_str());
 
-      return {{client::ErrorCode::NotFound, "Partition not found"}};
+      return client::ApiError::NotFound("Partition not found");
     }
 
     blob_request.WithDataHandle(partitions.front().GetDataHandle());

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

@@ -284,10 +284,12 @@ TEST_F(DataserviceReadVersionedLayerClientTest, GetDataFromPartitionAsync) {
   EXPECT_CALL(*network_mock_, Send(_, _, _, _, _))
       .WillOnce(ReturnHttpResponse(GetResponse(http::HttpStatusCode::OK),
                                    HTTP_RESPONSE_LOOKUP))
-      .WillOnce(ReturnHttpResponse(GetResponse(http::HttpStatusCode::OK),
-                                   kHttpResponsePartition_269))
-      .WillOnce(ReturnHttpResponse(GetResponse(http::HttpStatusCode::OK),
-                                   kHttpResponseBlobData_269));
+      .WillOnce(
+          ReturnHttpResponse(GetResponse(http::HttpStatusCode::OK, 1024, 123),
+                             kHttpResponsePartition_269))
+      .WillOnce(
+          ReturnHttpResponse(GetResponse(http::HttpStatusCode::OK, 1024, 123),
+                             kHttpResponseBlobData_269));
 
   auto client = std::make_shared<read::VersionedLayerClient>(
       kCatalog, kTestLayer, kTestVersion, settings_);
@@ -306,6 +308,10 @@ TEST_F(DataserviceReadVersionedLayerClientTest, GetDataFromPartitionAsync) {
   ASSERT_NE(response.GetResult(), nullptr);
   ASSERT_NE(response.GetResult()->size(), 0u);
 
+  const auto& network_stats = response.GetPayload();
+  EXPECT_EQ(network_stats.GetBytesDownloaded(), 2048);
+  EXPECT_EQ(network_stats.GetBytesUploaded(), 246);
+
   const auto cache_key = olp::cache::KeyGenerator::CreatePartitionKey(
       GetTestCatalog(), kTestLayer, kTestPartition, kTestVersion);
   EXPECT_TRUE(settings_.cache->Contains(cache_key));
@@ -2862,13 +2868,14 @@ TEST_F(DataserviceReadVersionedLayerClientTest, GetTile) {
 
   EXPECT_CALL(*network_mock_,
               Send(IsGetRequest(kHttpQueryTreeIndex_23064), _, _, _, _))
-      .WillOnce(ReturnHttpResponse(GetResponse(http::HttpStatusCode::OK),
-                                   kHttpSubQuads_23064));
+      .WillOnce(
+          ReturnHttpResponse(GetResponse(http::HttpStatusCode::OK, 1024, 123),
+                             kHttpSubQuads_23064));
 
   EXPECT_CALL(*network_mock_,
               Send(IsGetRequest(kHttpResponseBlobData_5904591), _, _, _, _))
-      .WillOnce(ReturnHttpResponse(GetResponse(http::HttpStatusCode::OK),
-                                   "someData"));
+      .WillOnce(ReturnHttpResponse(
+          GetResponse(http::HttpStatusCode::OK, 1024, 123), "someData"));
 
   auto request =
       read::TileRequest().WithTileKey(geo::TileKey::FromHereTile("5904591"));
@@ -2880,6 +2887,10 @@ TEST_F(DataserviceReadVersionedLayerClientTest, GetTile) {
   std::string data_string(data_response.GetResult()->begin(),
                           data_response.GetResult()->end());
   ASSERT_EQ("someData", data_string);
+
+  const auto& network_stats = data_response.GetPayload();
+  EXPECT_EQ(network_stats.GetBytesDownloaded(), 2048);
+  EXPECT_EQ(network_stats.GetBytesUploaded(), 246);
 }
 
 TEST_F(DataserviceReadVersionedLayerClientTest, GetTileConcurrent) {
@@ -3463,7 +3474,7 @@ TEST_F(DataserviceReadVersionedLayerClientTest, GetAggregatedData) {
         *network_mock_,
         Send(IsGetRequest(URL_BLOB_AGGREGATE_DATA_23618364), _, _, _, _))
         .WillOnce(ReturnHttpResponse(
-            GetResponse(http::HttpStatusCode::OK, 10240000, 123), "some_data"));
+            GetResponse(http::HttpStatusCode::OK, 1024, 123), "some_data"));
 
     auto client = read::VersionedLayerClient(kCatalog, kTestLayer, kTestVersion,
                                              settings_);
@@ -3481,7 +3492,7 @@ TEST_F(DataserviceReadVersionedLayerClientTest, GetAggregatedData) {
     ASSERT_EQ(result.GetTile(), tile_key);
 
     const auto& network_stats = response.GetPayload();
-    EXPECT_EQ(network_stats.GetBytesDownloaded(), 10241024);
+    EXPECT_EQ(network_stats.GetBytesDownloaded(), 2048);
     EXPECT_EQ(network_stats.GetBytesUploaded(), 246);
 
     testing::Mock::VerifyAndClearExpectations(network_mock_.get());