Expose cache keys creation. (#1265)

Added new class to create keys used to store partitions, bundles,
quadtrees etc. Now user can modify and rewrite data in the cache.
All *CacheRepository classes now use the API instead of internal
hidden scattered methods.

Integration testing done via adding new checks in existing tests. The
change doesn't add new functionality, but we must be sure clients
write data with same cache keys.

Resolves: OLPEDGE-2649
Signed-off-by: Kostiantyn Zvieriev <[email protected]>

Author: kzvieriev

olp-cpp-sdk-core/CMakeLists.txt

@@ -62,6 +62,7 @@ include(cmake/ios.cmake)
 set(OLP_SDK_CACHE_HEADERS
     ./include/olp/core/cache/CacheSettings.h
     ./include/olp/core/cache/DefaultCache.h
+    ./include/olp/core/cache/KeyGenerator.h
     ./include/olp/core/cache/KeyValueCache.h
 )
 
@@ -234,6 +235,7 @@ set(OLP_SDK_CACHE_SOURCES
     ./src/cache/DiskCacheSizeLimitEnv.h
     ./src/cache/DiskCacheSizeLimitWritableFile.cpp
     ./src/cache/DiskCacheSizeLimitWritableFile.h
+    ./src/cache/KeyGenerator.cpp
     ./src/cache/ProtectedKeyList.cpp
     ./src/cache/ProtectedKeyList.h
     ./src/cache/InMemoryCache.cpp

olp-cpp-sdk-core/include/olp/core/cache/KeyGenerator.h

@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2021 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 <string>
+
+#include <olp/core/CoreApi.h>
+#include <olp/core/client/HRN.h>
+#include <olp/core/geo/tiling/TileKey.h>
+#include <boost/optional.hpp>
+
+namespace olp {
+namespace cache {
+
+/**
+ * @brief Helper class to generate cache keys for different entities.
+ */
+class CORE_API KeyGenerator {
+ public:
+  /**
+   * @brief Generates cache key for service API.
+   *
+   * @param hrn The HRN of the catalog.
+   * @param service The service.
+   * @param version The version of the service.
+   *
+   * @return A key used to store the API in cache.
+   */
+  static std::string CreateApiKey(const std::string& hrn,
+                                  const std::string& service,
+                                  const std::string& version);
+
+  /**
+   * @brief Generates cache key for catalog data.
+   *
+   * @param hrn The HRN of the catalog.
+   *
+   * @return A key used to store the catalog data in cache.
+   */
+  static std::string CreateCatalogKey(const std::string& hrn);
+
+  /**
+   * @brief Generates cache key to store latest catalog version.
+   *
+   * @param hrn The HRN of the catalog.
+   *
+   * @return A key used to store the version in cache.
+   */
+  static std::string CreateLatestVersionKey(const std::string& hrn);
+
+  /**
+   * @brief Generates cache key for storing partition data.
+   *
+   * @param hrn The HRN of the catalog.
+   * @param layer_id The layer of the partition.
+   * @param partition_id The partition name.
+   * @param version The version of the catalog.
+   *
+   * @return A key used to store the patition data in cache.
+   */
+  static std::string CreatePartitionKey(
+      const std::string& hrn, const std::string& layer_id,
+      const std::string& partition_id, const boost::optional<int64_t>& version);
+
+  /**
+   * @brief Generates cache key for storing list of partitions.
+   *
+   * @param hrn The HRN of the catalog.
+   * @param layer_id The layer of the partition.
+   * @param version The version of the catalog.
+   *
+   * @return A key used to store the list of patitions in cache.
+   */
+  static std::string CreatePartitionsKey(
+      const std::string& hrn, const std::string& layer_id,
+      const boost::optional<int64_t>& version);
+
+  /**
+   * @brief Generates cache key for storing list of available layer versions.
+   *
+   * @param hrn The HRN of the catalog.
+   * @param version The version of the catalog.
+   *
+   * @return A key used to store the list layer versions in cache.
+   */
+  static std::string CreateLayerVersionsKey(const std::string& hrn,
+                                            const int64_t version);
+
+  /**
+   * @brief Generates cache key for storing quadtree metadata.
+   *
+   * @param hrn The HRN of the catalog.
+   * @param layer_id The layer of the quadtree.
+   * @param root The root tile of the quadtree.
+   * @param version The version of the catalog.
+   * @param depth The quadtree depth.
+   *
+   * @return A key used to store the quadtree in cache.
+   */
+  static std::string CreateQuadTreeKey(const std::string& hrn,
+                                       const std::string& layer_id,
+                                       olp::geo::TileKey root,
+                                       const boost::optional<int64_t>& version,
+                                       int32_t depth);
+
+  /**
+   * @brief Generates cache key for data handle entities.
+   *
+   * @param hrn The HRN of the catalog.
+   * @param layer_id The layer of the data handle.
+   * @param data_handle The data handle.
+   *
+   * @return A key used to store the data handle in cache.
+   */
+  static std::string CreateDataHandleKey(const std::string& hrn,
+                                         const std::string& layer_id,
+                                         const std::string& data_handle);
+};
+
+}  // namespace cache
+}  // namespace olp

olp-cpp-sdk-core/src/cache/KeyGenerator.cpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2021 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
+ */
+
+#include "olp/core/cache/KeyGenerator.h"
+
+namespace olp {
+namespace cache {
+std::string KeyGenerator::CreateApiKey(const std::string& hrn,
+                                       const std::string& service,
+                                       const std::string& version) {
+  return hrn + "::" + service + "::" + version + "::api";
+}
+
+std::string KeyGenerator::CreateCatalogKey(const std::string& hrn) {
+  return hrn + "::catalog";
+}
+
+std::string KeyGenerator::CreateLatestVersionKey(const std::string& hrn) {
+  return hrn + "::latestVersion";
+}
+
+std::string KeyGenerator::CreatePartitionKey(
+    const std::string& hrn, const std::string& layer_id,
+    const std::string& partition_id, const boost::optional<int64_t>& version) {
+  return hrn + "::" + layer_id + "::" + partition_id +
+         "::" + (version ? std::to_string(*version) + "::" : "") + "partition";
+}
+
+std::string KeyGenerator::CreatePartitionsKey(
+    const std::string& hrn, const std::string& layer_id,
+    const boost::optional<int64_t>& version) {
+  return hrn + "::" + layer_id +
+         "::" + (version ? std::to_string(*version) + "::" : "") + "partitions";
+}
+
+std::string KeyGenerator::CreateLayerVersionsKey(const std::string& hrn,
+                                                 const int64_t version) {
+  return hrn + "::" + std::to_string(version) + "::layerVersions";
+}
+
+std::string KeyGenerator::CreateQuadTreeKey(
+    const std::string& hrn, const std::string& layer_id, olp::geo::TileKey root,
+    const boost::optional<int64_t>& version, int32_t depth) {
+  return hrn + "::" + layer_id + "::" + root.ToHereTile() +
+         "::" + (version ? std::to_string(*version) + "::" : "") +
+         std::to_string(depth) + "::quadtree";
+}
+
+std::string KeyGenerator::CreateDataHandleKey(const std::string& hrn,
+                                              const std::string& layer_id,
+                                              const std::string& data_handle) {
+  return hrn + "::" + layer_id + "::" + data_handle + "::Data";
+}
+
+}  // namespace cache
+}  // namespace olp

olp-cpp-sdk-core/src/client/repository/ApiCacheRepository.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 HERE Europe B.V.
+ * Copyright (C) 2020-2021 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.
@@ -19,17 +19,13 @@
 
 #include "ApiCacheRepository.h"
 
+#include <olp/core/cache/KeyGenerator.h>
 #include <olp/core/cache/KeyValueCache.h>
 #include <olp/core/logging/Log.h>
 
 namespace {
 constexpr auto kLogTag = "ApiCacheRepository";
 constexpr time_t kLookupApiExpiryTime = 3600;
-
-std::string CreateKey(const std::string& hrn, const std::string& service,
-                      const std::string& serviceVersion) {
-  return hrn + "::" + service + "::" + serviceVersion + "::api";
-}
 }  // namespace
 
 namespace olp {
@@ -42,7 +38,7 @@ ApiCacheRepository::ApiCacheRepository(
 void ApiCacheRepository::Put(const std::string& service,
                              const std::string& version, const std::string& url,
                              boost::optional<time_t> expiry) {
-  auto key = CreateKey(hrn_, service, version);
+  const auto key = cache::KeyGenerator::CreateApiKey(hrn_, service, version);
   OLP_SDK_LOG_DEBUG_F(kLogTag, "Put -> '%s'", key.c_str());
 
   cache_->Put(key, url, [&]() { return url; },
@@ -51,7 +47,7 @@ void ApiCacheRepository::Put(const std::string& service,
 
 boost::optional<std::string> ApiCacheRepository::Get(
     const std::string& service, const std::string& version) {
-  auto key = CreateKey(hrn_, service, version);
+  const auto key = cache::KeyGenerator::CreateApiKey(hrn_, service, version);
   OLP_SDK_LOG_DEBUG_F(kLogTag, "Get -> '%s'", key.c_str());
 
   auto url = cache_->Get(key, [](const std::string& value) { return value; });

olp-cpp-sdk-core/tests/CMakeLists.txt

@@ -21,6 +21,7 @@ set(OLP_CPP_SDK_CORE_TESTS_SOURCES
     ./cache/Helpers.cpp
     ./cache/Helpers.h
     ./cache/InMemoryCacheTest.cpp
+    ./cache/KeyGeneratorTest.cpp
     ./cache/ProtectedKeyListTest.cpp
 
     ./client/ApiLookupClientImplTest.cpp