Added sync version of LookupApiClient in dataservice-write

Implemented the sync version of ApiClientLookup::LookupApiClient in dataservice-write component in the same way it is done in dataservice-read component.
Also, covered this new function with unit tests.

Relates to: OLPEDGE-1103

Signed-off-by: Bohdan Kurylovych <[email protected]>
Signed-off-by: Diachenko Mykahilo <[email protected]>

Author: Bohdan Kurylovych

olp-cpp-sdk-dataservice-write/src/ApiClientLookup.cpp

@@ -20,8 +20,10 @@
 #include "ApiClientLookup.h"
 
 #include <olp/core/client/ApiError.h>
+#include <olp/core/client/Condition.h>
 #include <olp/core/client/HRN.h>
 #include <olp/core/client/OlpClient.h>
+#include <olp/core/cache/KeyValueCache.h>
 #include <olp/core/logging/Log.h>
 #include "generated/PlatformApi.h"
 #include "generated/ResourcesApi.h"
@@ -45,6 +47,13 @@ std::string GetDatastoreServerUrl(const std::string& partition) {
              ? "https://api-lookup." + server_url->second + "/lookup/v1"
              : "";
 }
+
+std::string CreateKeyForCache(const std::string& hrn,
+                              const std::string& service,
+                              const std::string& service_version) {
+  return hrn + "::" + service + "::" + service_version + "::api";
+}
+
 }  // namespace
 
 client::CancellationToken ApiClientLookup::LookupApi(
@@ -126,6 +135,110 @@ client::CancellationToken ApiClientLookup::LookupApiClient(
       });
 }
 
+ApiClientLookup::ApiClientResponse ApiClientLookup::LookupApiClient(
+    const client::HRN& catalog,
+    client::CancellationContext cancellation_context, std::string service,
+    std::string service_version, client::OlpClientSettings settings) {
+  auto cache_key =
+      CreateKeyForCache(catalog.ToCatalogHRNString(), service, service_version);
+  // first, try to find the corresponding Base URL from cache
+  auto cache = settings.cache;
+  if (cache) {
+    auto url =
+        cache->Get(cache_key, [](const std::string& value) { return value; });
+    if (!url.empty()) {
+      auto base_url = boost::any_cast<std::string>(url);
+      OLP_SDK_LOG_INFO_F(kLogTag, "LookupApiClient(%s, %s) -> from cache",
+                         service.c_str(), service_version.c_str());
+      client::OlpClient client;
+      client.SetSettings(settings);
+      client.SetBaseUrl(base_url);
+      return ApiClientResponse{client};
+    }
+  }
+
+  client::Condition condition;
+  // when the network operation took too much time we cancel it and exit
+  // execution, to make sure that network callback will not access dangling
+  // references we protect them with atomic bool flag.
+  auto flag = std::make_shared<std::atomic_bool>(true);
+
+  ApiClientResponse api_response;
+  auto api_callback = [&, flag](ApiClientResponse response) {
+    if (flag->exchange(false)) {
+      api_response = std::move(response);
+      condition.Notify();
+    }
+  };
+
+  cancellation_context.ExecuteOrCancelled(
+      [&, flag]() {
+        auto client_ptr = std::make_shared<olp::client::OlpClient>();
+        client_ptr->SetSettings(settings);
+
+        auto token = ApiClientLookup::LookupApiClient(
+            client_ptr, service, service_version, catalog, api_callback);
+        return client::CancellationToken([&, token, flag]() {
+          if (flag->exchange(false)) {
+            token.Cancel();
+            condition.Notify();
+          }
+        });
+      },
+      [&]() {
+        // if context was cancelled before the execution setup, unblock the
+        // upcoming wait routine.
+        condition.Notify();
+      });
+  if (!condition.Wait(std::chrono::seconds(settings.retry_settings.timeout))) {
+    cancellation_context.CancelOperation();
+    OLP_SDK_LOG_INFO_F(kLogTag, "LookupApi(%s/%s): %s - timeout",
+                       service.c_str(), service_version.c_str(),
+                       catalog.partition.c_str());
+    return client::ApiError(client::ErrorCode::RequestTimeout,
+                            "Network request timed out.");
+  }
+
+  flag->store(false);
+
+  if (cancellation_context.IsCancelled()) {
+    // We can't use api response here because it could potentially be
+    // uninitialized.
+    OLP_SDK_LOG_INFO_F(kLogTag, "LookupApi(%s/%s): %s - cancelled",
+                       service.c_str(), service_version.c_str(),
+                       catalog.partition.c_str());
+    return client::ApiError(client::ErrorCode::Cancelled,
+                            "Operation cancelled.");
+  }
+
+  if (!api_response.IsSuccessful()) {
+    return api_response.GetError();
+  }
+
+  auto client = api_response.GetResult();
+  if (client.GetBaseUrl().empty()) {
+    OLP_SDK_LOG_WARNING_F(kLogTag, "LookupApi(%s/%s): %s - empty base URL",
+                          service.c_str(), service_version.c_str(),
+                          catalog.partition.c_str());
+  }
+
+  if (cache) {
+    const auto& base_url = client.GetBaseUrl();
+
+    constexpr time_t kExpiryTimeInSecs = 3600;
+    if (cache->Put(cache_key, base_url, [base_url]() { return base_url; },
+                   kExpiryTimeInSecs)) {
+      OLP_SDK_LOG_TRACE_F(kLogTag, "Put '%s' to cache", cache_key.c_str());
+    } else {
+      OLP_SDK_LOG_WARNING_F(kLogTag, "Failed to put '%s' to cache",
+                            cache_key.c_str());
+    }
+  }
+
+  client.SetSettings(settings);
+  return ApiClientResponse{std::move(client)};
+}
+
 }  // namespace write
 }  // namespace dataservice
 }  // namespace olp

olp-cpp-sdk-dataservice-write/src/ApiClientLookup.h

@@ -51,6 +51,11 @@ class ApiClientLookup {
       std::shared_ptr<client::OlpClient> client, const std::string& service,
       const std::string& service_version, const client::HRN& hrn,
       const ApiClientCallback& callback);
+
+  static ApiClientResponse LookupApiClient(
+      const client::HRN& catalog,
+      client::CancellationContext cancellation_context, std::string service,
+      std::string service_version, client::OlpClientSettings settings);
 };
 
 }  // namespace write