Remove dead code

Remove old dead code that is not used:
* ApiRepository async methods
* DataRepository async methods
* PartitionsRepository async methods
* PrefetchTilesRepository async methods
* PendingRequests old methods that were using keys and tokens
* MultiRequestContext

Clients now do not use separated task schedulers.

Resolves: OLPEDGE-1145

Signed-off-by: Mykhailo Kuchma <[email protected]>

Author: mykhailo-kuchma

olp-cpp-sdk-core/include/olp/core/client/PendingRequests.h

@@ -36,69 +36,37 @@ namespace client {
  */
 class PendingRequests final {
  public:
-  PendingRequests();
-  ~PendingRequests();
-
   /**
    * @brief Cancels all pending tasks
    * @note This call does not wait for the tasks to finalize, use
    * CancelAllAndWait() to also wait for the tasks to finalize..
    * @return True on success
    */
   bool CancelAll();
-  
+
   /**
    * @brief Cancels all pending tasks and waits for all beeing finalized.
    * @return True on success
    */
   bool CancelAllAndWait();
 
-  /**
-   * @brief Generates a placehoder for request cancellation token and returns a
-   * key associated with it.
-   * @return Returns a key associated with a placeholder.
-   */
-  int64_t GenerateRequestPlaceholder();
-
-  /**
-   * @brief Inserts request cancellation token into the placeholder associated
-   * with a key.
-   * @param token Cancellation token.
-   * @param key Key associated with a placeholder.
-   * @return True on success, false when the placeholder is missing.
-   */
-  bool Insert(const client::CancellationToken& token, int64_t key);
-
   /**
    * @brief Inserts task context into the requests container.
    * @param task_context Task context.
    */
-  void Insert(client::TaskContext task_context);
-
-  /**
-   * @brief Removes a pending request and placholder.
-   * @param key Internal request key to remove
-   * @return True on success
-   */
-  bool Remove(int64_t key);
+  void Insert(TaskContext task_context);
 
   /**
    * @brief Removes a task context.
    * @param task_context Task context.
    */
-  void Remove(client::TaskContext task_context);
+  void Remove(TaskContext task_context);
 
  private:
-  int64_t key_ = 0;
-  using RequestMap = std::unordered_map<int64_t, client::CancellationToken>;
-  using ContextMap =
-      std::unordered_set<client::TaskContext, client::TaskContextHash>;
-  RequestMap requests_map_;
+  using ContextMap = std::unordered_set<TaskContext, TaskContextHash>;
   ContextMap task_contexts_;
-
-  std::mutex requests_lock_;
+  std::mutex task_contexts_lock_;
 };
 
 }  // namespace client
 }  // namespace olp
-

olp-cpp-sdk-core/src/client/PendingRequests.cpp

@@ -28,23 +28,13 @@ namespace {
 constexpr auto kLogTag = "PendingRequests";
 }
 
-PendingRequests::PendingRequests(){};
-
-PendingRequests::~PendingRequests(){};
-
 bool PendingRequests::CancelAll() {
-  RequestMap requests_map;
   ContextMap contexts;
   {
-    std::lock_guard<std::mutex> lk(requests_lock_);
-    requests_map = requests_map_;
+    std::lock_guard<std::mutex> lock(task_contexts_lock_);
     contexts = task_contexts_;
   }
 
-  for (auto& pair : requests_map) {
-    pair.second.Cancel();
-  }
-
   for (auto context : contexts) {
     context.CancelToken().Cancel();
   }
@@ -57,7 +47,7 @@ bool PendingRequests::CancelAllAndWait() {
 
   ContextMap contexts;
   {
-    std::lock_guard<std::mutex> lk(requests_lock_);
+    std::lock_guard<std::mutex> lock(task_contexts_lock_);
     contexts = std::move(task_contexts_);
   }
 
@@ -70,40 +60,13 @@ bool PendingRequests::CancelAllAndWait() {
   return true;
 }
 
-int64_t PendingRequests::GenerateRequestPlaceholder() {
-  std::lock_guard<std::mutex> lk(requests_lock_);
-  key_++;
-  requests_map_[key_] = client::CancellationToken();
-  return key_;
-}
-
-bool PendingRequests::Insert(const client::CancellationToken& request,
-                             int64_t key) {
-  std::lock_guard<std::mutex> lk(requests_lock_);
-  if (requests_map_.find(key) == requests_map_.end()) {
-    return false;
-  }
-  requests_map_[key] = request;
-  return true;
-}
-
-void PendingRequests::Insert(client::TaskContext task_context) {
-  std::lock_guard<std::mutex> lk(requests_lock_);
+void PendingRequests::Insert(TaskContext task_context) {
+  std::lock_guard<std::mutex> lock(task_contexts_lock_);
   task_contexts_.insert(task_context);
 }
 
-bool PendingRequests::Remove(int64_t key) {
-  std::lock_guard<std::mutex> lk(requests_lock_);
-  auto request = requests_map_.find(key);
-  if (request != requests_map_.end()) {
-    requests_map_.erase(request);
-    return true;
-  }
-  return false;
-}
-
-void PendingRequests::Remove(client::TaskContext task_context) {
-  std::lock_guard<std::mutex> lk(requests_lock_);
+void PendingRequests::Remove(TaskContext task_context) {
+  std::lock_guard<std::mutex> lock(task_contexts_lock_);
   task_contexts_.erase(task_context);
 }
 

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

@@ -22,7 +22,6 @@ set(OLP_CPP_SDK_CORE_TESTS_SOURCES
     ./client/CancellationContextTest.cpp
     ./client/ConditionTest.cpp
     ./client/TaskContextTest.cpp
-    ./client/PendingRequestsTest.cpp
 
     ./geo/coordinates/GeoCoordinates3dTest.cpp
     ./geo/coordinates/GeoCoordinatesTest.cpp

olp-cpp-sdk-core/tests/client/PendingRequestsTest.cpp

@@ -50,85 +50,6 @@ std::string GetDatastoreServerUrl(const std::string& partition) {
 }
 }  // namespace
 
-client::CancellationToken ApiClientLookup::LookupApi(
-    std::shared_ptr<client::OlpClient> client, const std::string& service,
-    const std::string& service_version, const client::HRN& hrn,
-    const ApisCallback& callback) {
-  OLP_SDK_LOG_TRACE_F(kLogTag, "LookupApi(%s/%s): %s", service.c_str(),
-                      service_version.c_str(), hrn.partition.c_str());
-
-  // compare the hrn
-  auto base_url = GetDatastoreServerUrl(hrn.partition);
-  if (base_url.empty()) {
-    OLP_SDK_LOG_INFO_F(kLogTag, "LookupApi(%s/%s): %s Lookup URL not found",
-                       service.c_str(), service_version.c_str(),
-                       hrn.partition.c_str());
-    callback(
-        client::ApiError(client::ErrorCode::NotFound, "Invalid or broken HRN"));
-    return client::CancellationToken();
-  }
-
-  client->SetBaseUrl(base_url);
-
-  if (service == "config") {
-    OLP_SDK_LOG_INFO_F(kLogTag, "LookupApi(%s/%s): %s - config service",
-                       service.c_str(), service_version.c_str(),
-                       hrn.partition.c_str());
-
-    // scan apis at platform apis
-    return PlatformApi::GetApis(
-        client, service, service_version,
-        [callback](PlatformApi::ApisResponse response) { callback(response); });
-  }
-
-  OLP_SDK_LOG_INFO_F(kLogTag, "LookupApi(%s/%s): %s - resource service",
-                     service.c_str(), service_version.c_str(),
-                     hrn.partition.c_str());
-
-  // scan apis at resource endpoint
-  return ResourcesApi::GetApis(
-      client, hrn.ToCatalogHRNString(), service, service_version,
-      [callback](PlatformApi::ApisResponse response) { callback(response); });
-}
-
-client::CancellationToken ApiClientLookup::LookupApiClient(
-    std::shared_ptr<client::OlpClient> client, const std::string& service,
-    const std::string& service_version, const client::HRN& hrn,
-    const ApiClientCallback& callback) {
-  OLP_SDK_LOG_TRACE_F(kLogTag, "LookupApiClient(%s/%s): %s", service.c_str(),
-                      service_version.c_str(), hrn.partition.c_str());
-
-  return ApiClientLookup::LookupApi(
-      client, service, service_version, hrn, [=](ApisResponse response) {
-        if (!response.IsSuccessful()) {
-          OLP_SDK_LOG_INFO_F(
-              kLogTag, "LookupApiClient(%s/%s): %s - unsuccessful: %s",
-              service.c_str(), service_version.c_str(), hrn.partition.c_str(),
-              response.GetError().GetMessage().c_str());
-
-          callback(response.GetError());
-        } else if (response.GetResult().size() < 1) {
-          OLP_SDK_LOG_INFO_F(
-              kLogTag, "LookupApiClient(%s/%s): %s - service not available",
-              service.c_str(), service_version.c_str(), hrn.partition.c_str());
-
-          // TODO use defined ErrorCode
-          callback(
-              client::ApiError(client::ErrorCode::ServiceUnavailable,
-                               "Service/Version not available for given HRN"));
-        } else {
-          const auto& base_url = response.GetResult().at(0).GetBaseUrl();
-          OLP_SDK_LOG_INFO_F(kLogTag,
-                             "LookupApiClient(%s/%s): %s - OK, base_url=%s",
-                             service.c_str(), service_version.c_str(),
-                             hrn.partition.c_str(), base_url.c_str());
-
-          client->SetBaseUrl(base_url);
-          callback(*client);
-        }
-      });
-}
-
 ApiClientLookup::ApiClientResponse ApiClientLookup::LookupApi(
     const client::HRN& catalog,
     client::CancellationContext cancellation_context, std::string service,

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

@@ -37,23 +37,10 @@ namespace read {
  */
 class ApiClientLookup {
  public:
-  using ApisResponse = client::ApiResponse<model::Apis, client::ApiError>;
-  using ApisCallback = std::function<void(ApisResponse)>;
-
-  static client::CancellationToken LookupApi(
-      std::shared_ptr<client::OlpClient> client, const std::string& service,
-      const std::string& service_version, const client::HRN& hrn,
-      const ApisCallback& callback);
-
   using ApiClientResponse =
       client::ApiResponse<client::OlpClient, client::ApiError>;
   using ApiClientCallback = std::function<void(ApiClientResponse)>;
 
-  static client::CancellationToken LookupApiClient(
-      std::shared_ptr<client::OlpClient> client, const std::string& service,
-      const std::string& service_version, const client::HRN& hrn,
-      const ApiClientCallback& callback);
-
   static ApiClientResponse LookupApi(
       const client::HRN& catalog,
       client::CancellationContext cancellation_context, std::string service,

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

@@ -25,7 +25,6 @@
 #include <olp/core/logging/Log.h>
 
 #include "Common.h"
-#include "repositories/ApiRepository.h"
 #include "repositories/CatalogRepository.h"
 #include "repositories/ExecuteOrSchedule.inl"