Return Postponed if protected cache failed to open (#1472)

This allows read-only protected cache location at start. Later when
there is a need to write to the protected cache it can be opened as
mutable and it is going to be an error if we have no write permission
at that time.

Relates-To: OLPEDGE-2858

Signed-off-by: Rustam Gamidov <ext-rustam.gamidov@here.com>

Author: rustam-gamidov-here

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

@@ -144,6 +144,7 @@ olp::cache::DefaultCache::StorageOpenResult ToStorageOpenResult(
       return StorageOpenResult::ProtectedCacheCorrupted;
     case olp::cache::OpenResult::Repaired:
     case olp::cache::OpenResult::Success:
+    case olp::cache::OpenResult::Postponed:
       return StorageOpenResult::Success;
   }
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2023 HERE Europe B.V.
+ * Copyright (C) 2019-2024 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.
@@ -241,6 +241,15 @@ OpenResult DiskCache::Open(const std::string& data_path,
 
   if (status.IsInvalidArgument() && is_read_only) {
     // Maybe folder with cache is an empty, so trying to create db and reopen it
+    if (!repair_if_broken) {
+      OLP_SDK_LOG_WARNING_F(kLogTag,
+                            "Open: failed, initialize attempt postponed, "
+                            "cache_path='%s', error='%s'",
+                            versioned_data_path.c_str(),
+                            status.ToString().c_str());
+      return OpenResult::Postponed;
+    }
+
     status = InitializeDB(settings, versioned_data_path);
     if (!status.ok()) {
       return OpenResult::Fail;

olp-cpp-sdk-core/src/cache/DiskCache.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2023 HERE Europe B.V.
+ * Copyright (C) 2019-2024 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.
@@ -63,7 +63,9 @@ enum class OpenResult {
   /// broken.
   Repaired,
   /// The store was successfully opened.
-  Success
+  Success,
+  /// The openning was postponed. Could be empty readonly location.
+  Postponed
 };
 
 struct StorageSettings {

olp-cpp-sdk-core/tests/cache/DefaultCacheImplTest.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 HERE Europe B.V.
+ * Copyright (C) 2020-2024 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.
@@ -33,6 +33,25 @@ namespace {
 namespace cache = olp::cache;
 using CacheType = cache::DefaultCache::CacheType;
 
+bool SetRights(const std::string& path, bool readonly) {
+#if !defined(_WIN32) || defined(__MINGW32__)
+  mode_t mode;
+  if (readonly) {
+    mode = S_IRUSR | S_IRGRP | S_IROTH;
+  } else {
+    mode = S_IRUSR | S_IWUSR | S_IXUSR;
+  }
+  mode = mode | S_IRGRP | S_IROTH;
+  return chmod(path.c_str(), mode) == 0;
+#else
+  DWORD attributes = GetFileAttributes(path.c_str());
+  attributes = readonly ? attributes | FILE_ATTRIBUTE_READONLY
+                        : attributes & ~FILE_ATTRIBUTE_READONLY;
+  BOOL result = SetFileAttributesA(path.c_str(), attributes);
+  return result != 0;
+#endif
+}
+
 class DefaultCacheImplTest : public ::testing::Test {
  public:
   void SetUp() override {
@@ -1332,4 +1351,65 @@ TEST_F(DefaultCacheImplTest, ProtectedCacheSize) {
 
   EXPECT_LT(std::fabs(diff_percentage), acceptable_diff_percentage);
 }
+
+struct OpenTestParameters {
+  olp::cache::DefaultCache::StorageOpenResult expected_result;
+  olp::cache::OpenOptions open_options;
+  boost::optional<std::string> disk_path_mutable;
+  boost::optional<std::string> disk_path_protected;
+};
+
+class DefaultCacheImplOpenTest
+    : public DefaultCacheImplTest,
+      public testing::WithParamInterface<OpenTestParameters> {};
+
+TEST_P(DefaultCacheImplOpenTest, ReadOnlyDir) {
+  const auto setup_dir = [&](const boost::optional<std::string>& cache_path) {
+    if (cache_path) {
+      if (olp::utils::Dir::Exists(*cache_path)) {
+        ASSERT_TRUE(olp::utils::Dir::Remove(*cache_path));
+      }
+      ASSERT_TRUE(olp::utils::Dir::Create(*cache_path));
+      ASSERT_TRUE(SetRights(*cache_path, true));
+    }
+  };
+
+  const auto reset_dir = [&](const boost::optional<std::string>& cache_path) {
+    if (cache_path) {
+      ASSERT_TRUE(olp::utils::Dir::Remove(*cache_path));
+    }
+  };
+
+  const OpenTestParameters test_params = GetParam();
+
+  ASSERT_NO_FATAL_FAILURE(setup_dir(test_params.disk_path_mutable));
+  ASSERT_NO_FATAL_FAILURE(setup_dir(test_params.disk_path_protected));
+
+  cache::CacheSettings settings;
+  settings.disk_path_mutable = test_params.disk_path_mutable;
+  settings.disk_path_protected = test_params.disk_path_protected;
+  settings.openOptions = test_params.open_options;
+  DefaultCacheImplHelper cache(settings);
+  EXPECT_EQ(test_params.expected_result, cache.Open());
+
+  ASSERT_NO_FATAL_FAILURE(reset_dir(test_params.disk_path_mutable));
+  ASSERT_NO_FATAL_FAILURE(reset_dir(test_params.disk_path_protected));
+}
+
+std::vector<OpenTestParameters> DefaultCacheImplOpenParams() {
+  const std::string cache_path =
+      olp::utils::Dir::TempDirectory() + "/unittest_readonly";
+  return {{olp::cache::DefaultCache::StorageOpenResult::Success,
+           olp::cache::OpenOptions::Default, boost::none, cache_path},
+          {olp::cache::DefaultCache::StorageOpenResult::Success,
+           olp::cache::OpenOptions::ReadOnly, boost::none, cache_path},
+          {olp::cache::DefaultCache::StorageOpenResult::OpenDiskPathFailure,
+           olp::cache::OpenOptions::Default, cache_path, boost::none},
+          {olp::cache::DefaultCache::StorageOpenResult::OpenDiskPathFailure,
+           olp::cache::OpenOptions::ReadOnly, cache_path, boost::none}};
+}
+
+INSTANTIATE_TEST_SUITE_P(, DefaultCacheImplOpenTest,
+                         testing::ValuesIn(DefaultCacheImplOpenParams()));
+
 }  // namespace