RemoveFromCache API for VersionedLayerClient. (#719)

kzvieriev · web-flow · commit fc00797d978d · 2020-03-20T10:20:04.000+02:00
Added new RemoveFromCache method. It's now possible to clear all cache
data for specific partition.
Added integration test for the new functionality.

Resolves: OLPEDGE-1567

Signed-off-by: Kostiantyn Zvieriev &lt;ext-kostiantyn.zvieriev@here.com&gt;
diff --git a/olp-cpp-sdk-dataservice-read/include/olp/dataservice/read/VersionedLayerClient.h b/olp-cpp-sdk-dataservice-read/include/olp/dataservice/read/VersionedLayerClient.h
@@ -318,6 +318,15 @@ class DATASERVICE_READ_API VersionedLayerClient final {
   client::CancellableFuture<PrefetchTilesResponse> PrefetchTiles(
       PrefetchTilesRequest request);
 
+  /**
+   * @brief Removes the partition from the mutable disk cache.
+   *
+   * @param partition_id The partition ID that should be removed.
+   *
+   * @return True if partition data is removed successfully; false otherwise.
+   */
+  bool RemoveFromCache(const std::string& partition_id);
+
  private:
   std::unique_ptr<VersionedLayerClientImpl> impl_;
 };
diff --git a/olp-cpp-sdk-dataservice-read/src/VersionedLayerClient.cpp b/olp-cpp-sdk-dataservice-read/src/VersionedLayerClient.cpp
@@ -94,6 +94,10 @@ client::CancellableFuture<DataResponse> VersionedLayerClient::GetData(
   return impl_->GetData(std::move(request));
 }
 
+bool VersionedLayerClient::RemoveFromCache(const std::string& partition_id) {
+  return impl_->RemoveFromCache(partition_id);
+}
+
 }  // namespace read
 }  // namespace dataservice
 }  // namespace olp
diff --git a/olp-cpp-sdk-dataservice-read/src/VersionedLayerClientImpl.cpp b/olp-cpp-sdk-dataservice-read/src/VersionedLayerClientImpl.cpp
@@ -29,6 +29,7 @@
 #include <olp/dataservice/read/CatalogVersionRequest.h>
 #include "Common.h"
 #include "repositories/CatalogRepository.h"
+#include "repositories/DataCacheRepository.h"
 #include "repositories/DataRepository.h"
 #include "repositories/PartitionsRepository.h"
 #include "repositories/PrefetchTilesRepository.h"
@@ -452,6 +453,24 @@ client::CancellableFuture<DataResponse> VersionedLayerClientImpl::GetData(
                                                  std::move(promise));
 }
 
+bool VersionedLayerClientImpl::RemoveFromCache(
+    const std::string& partition_id) {
+  repository::PartitionsCacheRepository cache_repository(catalog_,
+                                                         settings_.cache);
+  boost::optional<model::Partition> partition;
+  if (!cache_repository.ClearPartitionMetadata(
+          catalog_version_.load(), partition_id, layer_id_, partition)) {
+    return false;
+  }
+
+  if (!partition) {
+    return true;
+  }
+
+  repository::DataCacheRepository data_repository(catalog_, settings_.cache);
+  return data_repository.Clear(layer_id_, partition.get().GetDataHandle());
+}
+
 PORTING_POP_WARNINGS()
 }  // namespace read
 }  // namespace dataservice
diff --git a/olp-cpp-sdk-dataservice-read/src/VersionedLayerClientImpl.h b/olp-cpp-sdk-dataservice-read/src/VersionedLayerClientImpl.h
@@ -81,6 +81,8 @@ class VersionedLayerClientImpl {
   virtual client::CancellableFuture<PrefetchTilesResponse> PrefetchTiles(
       PrefetchTilesRequest request);
 
+  virtual bool RemoveFromCache(const std::string& partition_id);
+
  private:
   CatalogVersionResponse GetVersion(boost::optional<std::string> billing_tag,
                                     const FetchOptions& fetch_options,
diff --git a/olp-cpp-sdk-dataservice-read/src/repositories/DataCacheRepository.cpp b/olp-cpp-sdk-dataservice-read/src/repositories/DataCacheRepository.cpp
@@ -62,12 +62,12 @@ boost::optional<model::Data> DataCacheRepository::Get(
   return std::move(cachedData);
 }
 
-void DataCacheRepository::Clear(const std::string& layer_id,
+bool DataCacheRepository::Clear(const std::string& layer_id,
                                 const std::string& data_handle) {
   std::string hrn(hrn_.ToCatalogHRNString());
   auto key = CreateKey(hrn, layer_id, data_handle);
-  OLP_SDK_LOG_TRACE_F(kLogTag, "Clear '%s'", key.c_str());
-  cache_->RemoveKeysWithPrefix(key);
+  OLP_SDK_LOG_INFO_F(kLogTag, "Clear '%s'", key.c_str());
+  return cache_->RemoveKeysWithPrefix(key);
 }
 
 }  // namespace repository
diff --git a/olp-cpp-sdk-dataservice-read/src/repositories/DataCacheRepository.h b/olp-cpp-sdk-dataservice-read/src/repositories/DataCacheRepository.h
@@ -46,7 +46,7 @@ class DataCacheRepository final {
   boost::optional<model::Data> Get(const std::string& layer_id,
                                    const std::string& data_handle);
 
-  void Clear(const std::string& layer_id, const std::string& data_handle);
+  bool Clear(const std::string& layer_id, const std::string& data_handle);
 
  private:
   client::HRN hrn_;
diff --git a/olp-cpp-sdk-dataservice-read/src/repositories/PartitionsCacheRepository.cpp b/olp-cpp-sdk-dataservice-read/src/repositories/PartitionsCacheRepository.cpp
@@ -206,6 +206,25 @@ void PartitionsCacheRepository::ClearPartitions(
   }
 }
 
+bool PartitionsCacheRepository::ClearPartitionMetadata(
+    int64_t catalog_version, const std::string& partition_id,
+    const std::string& layer_id,
+    boost::optional<model::Partition>& out_partition) {
+  std::string hrn(hrn_.ToCatalogHRNString());
+  auto key = CreateKey(hrn, layer_id, partition_id, catalog_version);
+  OLP_SDK_LOG_INFO_F(kLogTag, "ClearPartitionMetadata '%s'", key.c_str());
+  auto cached_partition =
+      cache_->Get(key, [](const std::string& serialized_object) {
+        return parser::parse<model::Partition>(serialized_object);
+      });
+  if (cached_partition.empty()) {
+    return true;
+  }
+
+  out_partition = boost::any_cast<model::Partition>(cached_partition);
+  return cache_->RemoveKeysWithPrefix(key);
+}
+
 PORTING_POP_WARNINGS()
 }  // namespace repository
 }  // namespace read
diff --git a/olp-cpp-sdk-dataservice-read/src/repositories/PartitionsCacheRepository.h b/olp-cpp-sdk-dataservice-read/src/repositories/PartitionsCacheRepository.h
@@ -63,6 +63,11 @@ class PartitionsCacheRepository final {
                        const std::vector<std::string>& partitionIds,
                        const std::string& layer_id);
 
+  bool ClearPartitionMetadata(int64_t catalog_version,
+                              const std::string& partition_id,
+                              const std::string& layer_id,
+                              boost::optional<model::Partition>& out_partition);
+
  private:
   client::HRN hrn_;
   std::shared_ptr<cache::KeyValueCache> cache_;
diff --git a/olp-cpp-sdk-dataservice-read/tests/VersionedLayerClientTest.cpp b/olp-cpp-sdk-dataservice-read/tests/VersionedLayerClientTest.cpp
@@ -21,6 +21,9 @@
 #include <mocks/CacheMock.h>
 #include <mocks/NetworkMock.h>
 
+#include <olp/core/cache/CacheSettings.h>
+#include <olp/core/cache/KeyValueCache.h>
+#include <olp/core/client/OlpClientSettingsFactory.h>
 #include <olp/dataservice/read/VersionedLayerClient.h>
 
 namespace {
@@ -33,6 +36,7 @@ const std::string kCatalog =
 const std::string kLayerId = "testlayer";
 const auto kHrn = olp::client::HRN::FromString(kCatalog);
 const auto kPartitionId = "269";
+const auto kCatalogVersion = 108;
 const auto kTimeout = std::chrono::seconds(5);
 
 constexpr auto kBlobDataHandle = R"(4eed6ed1-0d32-43b9-ae79-043cb4256432)";
@@ -72,4 +76,66 @@ TEST(VersionedLayerClientTest, GetData) {
   }
 }
 
+TEST(VersionedLayerClientTest, RemoveFromCache) {
+  olp::client::OlpClientSettings settings;
+  std::shared_ptr<CacheMock> cache_mock = std::make_shared<CacheMock>();
+  settings.cache = cache_mock;
+
+  // successfull mock cache calls
+  auto found_cache_response = [](const std::string& key,
+                                 const olp::cache::Decoder& encoder) {
+    auto partition = model::Partition();
+    partition.SetPartition(kPartitionId);
+    partition.SetDataHandle(kBlobDataHandle);
+    return partition;
+  };
+  auto partition_cache_remove = [&](const std::string& prefix) {
+    std::string expected_prefix =
+        kHrn.ToCatalogHRNString() + "::" + kLayerId + "::" + kPartitionId +
+        "::" + std::to_string(kCatalogVersion) + "::partition";
+    EXPECT_EQ(prefix, expected_prefix);
+    return true;
+  };
+  auto data_cache_remove = [&](const std::string& prefix) {
+    std::string expected_prefix = kHrn.ToCatalogHRNString() + "::" + kLayerId +
+                                  "::" + kBlobDataHandle + "::Data";
+    EXPECT_EQ(prefix, expected_prefix);
+    return true;
+  };
+
+  VersionedLayerClient client(kHrn, kLayerId, kCatalogVersion, settings);
+  {
+    SCOPED_TRACE("Successfull remove partition from cache");
+
+    EXPECT_CALL(*cache_mock, Get(_, _)).WillOnce(found_cache_response);
+    EXPECT_CALL(*cache_mock, RemoveKeysWithPrefix(_))
+        .WillOnce(partition_cache_remove)
+        .WillOnce(data_cache_remove);
+    ASSERT_TRUE(client.RemoveFromCache(kPartitionId));
+  }
+  {
+    SCOPED_TRACE("Remove not existing partition from cache");
+    EXPECT_CALL(*cache_mock, Get(_, _))
+        .WillOnce([](const std::string&, const olp::cache::Decoder&) {
+          return boost::any();
+        });
+    ASSERT_TRUE(client.RemoveFromCache(kPartitionId));
+  }
+  {
+    SCOPED_TRACE("Partition cache failure");
+    EXPECT_CALL(*cache_mock, Get(_, _)).WillOnce(found_cache_response);
+    EXPECT_CALL(*cache_mock, RemoveKeysWithPrefix(_))
+        .WillOnce([](const std::string&) { return false; });
+    ASSERT_FALSE(client.RemoveFromCache(kPartitionId));
+  }
+  {
+    SCOPED_TRACE("Data cache failure");
+    EXPECT_CALL(*cache_mock, Get(_, _)).WillOnce(found_cache_response);
+    EXPECT_CALL(*cache_mock, RemoveKeysWithPrefix(_))
+        .WillOnce(partition_cache_remove)
+        .WillOnce([](const std::string&) { return false; });
+    ASSERT_FALSE(client.RemoveFromCache(kPartitionId));
+  }
+}
+
 }  // namespace
diff --git a/tests/integration/olp-cpp-sdk-dataservice-read/VersionedLayerClientTest.cpp b/tests/integration/olp-cpp-sdk-dataservice-read/VersionedLayerClientTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -62,12 +62,12 @@ boost::optional<model::Data> DataCacheRepository::Get(`
`62`	`62`	`return std::move(cachedData);`
`63`	`63`	`}`
`64`	`64`
`65`		`-void DataCacheRepository::Clear(const std::string& layer_id,`
	`65`	`+bool DataCacheRepository::Clear(const std::string& layer_id,`
`66`	`66`	`const std::string& data_handle) {`
`67`	`67`	`std::string hrn(hrn_.ToCatalogHRNString());`
`68`	`68`	`auto key = CreateKey(hrn, layer_id, data_handle);`
`69`		`- OLP_SDK_LOG_TRACE_F(kLogTag, "Clear '%s'", key.c_str());`
`70`		`- cache_->RemoveKeysWithPrefix(key);`
	`69`	`+ OLP_SDK_LOG_INFO_F(kLogTag, "Clear '%s'", key.c_str());`
	`70`	`+ return cache_->RemoveKeysWithPrefix(key);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`} // namespace repository`