Add Protect/Release partition (#1199)

Add posibility to protect/release
partition by its id, which includes
metadata and data handle for partition.

Resolves: OAM-1024

Signed-off-by: Liubov Didkivska <[email protected]>

Author: Liubov Didkivska

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

@@ -409,8 +409,8 @@ class DATASERVICE_READ_API VersionedLayerClient final {
    *
    * @param partition_id The partition ID that should be removed.
    *
-   * @note Before calling the API, specify a layer version. You can set it using
-   * the constructor or after the first online request.
+   * @note Before calling the API, specify a catalog version. You can set it
+   * using the constructor or after the first online request.
    *
    * @return True if partition data is removed successfully; false otherwise.
    */
@@ -421,8 +421,8 @@ class DATASERVICE_READ_API VersionedLayerClient final {
    *
    * @param tile The tile key that should be removed.
    *
-   * @note Before calling the API, specify a layer version. You can set it using
-   * the constructor or after the first online request.
+   * @note Before calling the API, specify a catalog version. You can set it
+   * using the constructor or after the first online request.
    *
    * @return True if tile data is removed successfully; false otherwise.
    */
@@ -433,8 +433,8 @@ class DATASERVICE_READ_API VersionedLayerClient final {
    *
    * @param partition_id The partition ID.
    *
-   * @note Before calling the API, specify a layer version. You can set it using
-   * the constructor or after the first online request.
+   * @note Before calling the API, specify a catalog version. You can set it
+   * using the constructor or after the first online request.
    *
    * @return True if the partition data is cached; false otherwise.
    */
@@ -447,8 +447,8 @@ class DATASERVICE_READ_API VersionedLayerClient final {
    * @param aggregated The aggregated flag, used to specify whether the tile is
    * aggregated or not.
    *
-   * @note Before calling the API, specify a layer version. You can set it using
-   * the constructor or after the first online request.
+   * @note Before calling the API, specify a catalog version. You can set it
+   * using the constructor or after the first online request.
    *
    * @return True if the tile data is cached; false otherwise.
    */
@@ -463,22 +463,45 @@ class DATASERVICE_READ_API VersionedLayerClient final {
    * not expire. The quadtree stays protected if at least one tile key is
    * protected.
    *
+   * @note Before calling the API, specify a catalog version. You can set it
+   * using the constructor or after the first online request.
+   *
    * @note You can only protect tiles which data handles are present in the
    * cache at the time of the call.
    *
    * @note Please do not call `Protect` while the `Release` call for the same
    * catalog and layer is in progress.
    *
-   * @note Before calling the API, specify a layer version. You can set it using
-   * the constructor or after the first online request.
-   *
    * @param tiles The list of tile keys to be protected.
    *
    * @return True if some keys were successfully added to the protected list;
    * false otherwise.
    */
   bool Protect(const TileKeys& tiles);
 
+  /**
+   * @brief Protect partition from eviction.
+   *
+   * Protecting partition means that its data and metadata keys are added to the
+   * protected list and stored in the cache. These keys are removed from the LRU
+   * cache, so they could not be evicted. Also, they do not expire.
+   *
+   * @note Before calling the API, specify a catalog version. You can set it
+   * using the constructor or after the first online request.
+   *
+   * @note You can only protect partitions which data handles are present in the
+   * cache at the time of the call.
+   *
+   * @note Please do not call `Protect` while the `Release` call for the same
+   * catalog and layer is in progress.
+   *
+   * @param partition_id Partition id to be protected.
+   *
+   * @return True if partition keys were successfully added to the protected
+   * list; false otherwise.
+   */
+  bool Protect(const std::string& partition_id);
+
   /**
    * @brief Removes a list of tiles from protection.
    *
@@ -487,19 +510,40 @@ class DATASERVICE_READ_API VersionedLayerClient final {
    * Expiration value is restored, and keys can expire. The quadtree can be
    * removed from the protected list if all tile keys are no longer protected.
    *
+   * @note Before calling the API, specify a catalog version. You can set it
+   * using the constructor or after the first online request.
+   *
    * @note Please make sure that `Protect` will not be called for the same
    * catalog and layer while the `Release` call is in progress.
    *
-   * @note Before calling the API, specify a layer version. You can set it using
-   * the constructor or after the first online request.
-   *
    * @param tiles The list of tile keys to be removed from protection.
    *
    * @return True if some keys were successfully removed from the protected
    * list; false otherwise.
    */
   bool Release(const TileKeys& tiles);
 
+  /**
+   * @brief Removes partition from protection.
+   *
+   * Releasing partition id removes data handle and metadata keys from the
+   * protected list. The keys are added to the LRU cache, so they could be
+   * evicted. Expiration value is restored, and related to partition keys can
+   * expire.
+   *
+   * @note Before calling the API, specify a catalog version. You can set it
+   * using the constructor or after the first online request.
+   *
+   * @note Please make sure that `Protect` will not be called for the same
+   * catalog and layer while the `Release` call is in progress.
+   *
+   * @param partition_id Partition id to be removed from protection.
+   *
+   * @return True if keys related to partition were successfully removed from
+   * the protected list; false otherwise.
+   */
+  bool Release(const std::string& partition_id);
+
  private:
   std::unique_ptr<VersionedLayerClientImpl> impl_;
 };

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

@@ -141,6 +141,14 @@ bool VersionedLayerClient::Release(const TileKeys& tiles) {
   return impl_->Release(tiles);
 }
 
+bool VersionedLayerClient::Protect(const std::string& partition_id) {
+  return impl_->Protect(partition_id);
+}
+
+bool VersionedLayerClient::Release(const std::string& partition_id) {
+  return impl_->Release(partition_id);
+}
+
 }  // namespace read
 }  // namespace dataservice
 }  // namespace olp

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

@@ -791,6 +791,42 @@ bool VersionedLayerClientImpl::Release(const TileKeys& tiles) {
   return settings_.cache->Release(keys_to_release);
 }
 
+bool VersionedLayerClientImpl::Protect(const std::string& partition_id) {
+  if (!settings_.cache) {
+    return {};
+  }
+
+  auto version = catalog_version_.load();
+  if (version == kInvalidVersion) {
+    OLP_SDK_LOG_WARNING(kLogTag,
+                        "Method Protect failed, version is not initialized");
+    return {};
+  }
+
+  repository::PartitionsCacheRepository repository(catalog_, layer_id_,
+                                                   settings_.cache);
+
+  return repository.Protect(partition_id, version);
+}
+
+bool VersionedLayerClientImpl::Release(const std::string& partition_id) {
+  if (!settings_.cache) {
+    return {};
+  }
+
+  auto version = catalog_version_.load();
+  if (version == kInvalidVersion) {
+    OLP_SDK_LOG_WARNING(kLogTag,
+                        "Method Release failed, version is not initialized");
+    return {};
+  }
+
+  repository::PartitionsCacheRepository repository(catalog_, layer_id_,
+                                                   settings_.cache);
+
+  return repository.Release(partition_id, version);
+}
+
 }  // namespace read
 }  // namespace dataservice
 }  // namespace olp

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

@@ -109,6 +109,10 @@ class VersionedLayerClientImpl {
 
   virtual bool Release(const TileKeys& tiles);
 
+  virtual bool Protect(const std::string& partition_id);
+
+  virtual bool Release(const std::string& partition_id);
+
  private:
   CatalogVersionResponse GetVersion(boost::optional<std::string> billing_tag,
                                     const FetchOptions& fetch_options,

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

@@ -50,6 +50,7 @@ std::string CreateKey(const std::string& hrn, const std::string& layer_id,
   return hrn + "::" + layer_id + "::" + partitionId +
          "::" + (version ? std::to_string(*version) + "::" : "") + "partition";
 }
+
 std::string CreateKey(const std::string& hrn, const std::string& layer_id,
                       const boost::optional<int64_t>& version) {
   return hrn + "::" + layer_id +
@@ -59,6 +60,11 @@ std::string CreateKey(const std::string& hrn, const int64_t catalogVersion) {
   return hrn + "::" + std::to_string(catalogVersion) + "::layerVersions";
 }
 
+std::string CreateKey(const std::string& hrn, const std::string& layer_id,
+                      const std::string& datahandle) {
+  return hrn + "::" + layer_id + "::" + datahandle + "::Data";
+}
+
 time_t ConvertTime(std::chrono::seconds time) {
   return time == kChronoSecondsMax ? kTimetMax : time.count();
 }
@@ -327,6 +333,40 @@ bool PartitionsCacheRepository::ContainsTree(
   return cache_->Contains(CreateQuadKey(key, depth, version));
 }
 
+cache::KeyValueCache::KeyListType
+PartitionsCacheRepository::CreatePartitionKeys(
+    const std::string& partition_id, const boost::optional<int64_t>& version) {
+  std::string handle;
+
+  if (GetPartitionHandle(partition_id, version, handle)) {
+    return cache::KeyValueCache::KeyListType{
+        CreateKey(catalog_, layer_id_, partition_id, version),
+        CreateKey(catalog_, layer_id_, handle)};
+  }
+
+  return {};
+}
+
+bool PartitionsCacheRepository::Protect(
+    const std::string& partition_id, const boost::optional<int64_t>& version) {
+  const auto keys = CreatePartitionKeys(partition_id, version);
+  if (keys.empty()) {
+    return false;
+  }
+
+  return cache_->Protect(keys);
+}
+
+bool PartitionsCacheRepository::Release(
+    const std::string& partition_id, const boost::optional<int64_t>& version) {
+  const auto keys = CreatePartitionKeys(partition_id, version);
+  if (keys.empty()) {
+    return false;
+  }
+
+  return cache_->Release(keys);
+}
+
 }  // namespace repository
 }  // namespace read
 }  // namespace dataservice

olp-cpp-sdk-dataservice-read/src/repositories/PartitionsCacheRepository.h

@@ -92,7 +92,16 @@ class PartitionsCacheRepository final {
   bool ContainsTree(geo::TileKey key, int32_t depth,
                     const boost::optional<int64_t>& version) const;
 
+  bool Protect(const std::string& partition_id,
+               const boost::optional<int64_t>& version);
+
+  bool Release(const std::string& partition_id,
+               const boost::optional<int64_t>& version);
+
  private:
+  cache::KeyValueCache::KeyListType CreatePartitionKeys(
+      const std::string& partition_id, const boost::optional<int64_t>& version);
+
   const std::string catalog_;
   const std::string layer_id_;
   std::shared_ptr<cache::KeyValueCache> cache_;