Add proper cancellation for the new token provider (#1269)

The inner class TokenEndpoint::Impl is extructed from TokenEndpoint.cpp
to separate files TokenEndpointImpl.h and TokenEndpointImpl.cpp.

TokenEndpointImpl is extended with mostly copy-pasted code from
AuthenticationClientImpl, which is supposed to be refactored in
the future to use TokenProvider, and not in the opposite direction,
as it is now. TokenEndpointImpl code is adapted in a way to give an
abilty to pass cancellation context from the new token profider to
OlpClient::CallApi().

A new test class TokenEndpointTest contains adapted tests
copy-pasted from AuthenticationClientTest.

Integration tests for cancellation and timeout are added.

Relates-To: OLPEDGE-2651

Signed-off-by: Mykola Malik <[email protected]>

Author: mykolamalik

olp-cpp-sdk-authentication/include/olp/authentication/AutoRefreshingToken.h

@@ -28,6 +28,7 @@
 #include "TokenRequest.h"
 #include "TokenResult.h"
 
+#include "olp/core/client/CancellationContext.h"
 #include "olp/core/client/CancellationToken.h"
 #include "olp/core/porting/warning_disable.h"
 
@@ -67,8 +68,6 @@ class AUTHENTICATION_API OLP_SDK_DEPRECATED("Will be removed by 10.2020.")
    * @note This method is blocked when a new token needs to be retrieved.
    * Therefore, the token should not be called from a time-sensitive thread (for
    * example, the UI thread).
-   * @throw std::future_error Thrown when a failure occurs.
-   * Contains the error code and message.
    *
    * @param cancellation_token The token used to cancel the operation.
    * @param minimum_validity (Optional) Sets the minimum validity period of
@@ -78,11 +77,32 @@ class AUTHENTICATION_API OLP_SDK_DEPRECATED("Will be removed by 10.2020.")
    * @return The `TokenResponse` instance if the old one is expired.
    * Otherwise, returns the cached `TokenResponse` instance.
    */
-
   TokenResponse GetToken(client::CancellationToken& cancellation_token,
                          const std::chrono::seconds& minimum_validity =
                              kDefaultMinimumValiditySeconds) const;
 
+  /**
+   * @brief Synchronously gets a token that is always fresh.
+   *
+   * If no token has been retrieved yet or the current token is expired or
+   * expires within five minutes, a new token is requested. Otherwise,
+   * the cached token is returned. This method is thread-safe.
+   * @note This method is blocked when a new token needs to be retrieved.
+   * Therefore, the token should not be called from a time-sensitive thread (for
+   * example, the UI thread).
+   *
+   * @param context Used to cancel the pending token request.
+   * @param minimum_validity (Optional) Sets the minimum validity period of
+   * the token in seconds. The default validity period is 5 minutes. If
+   * the period is set to 0, the token is refreshed immediately.
+   *
+   * @return The `TokenResponse` instance if the old one is expired.
+   * Otherwise, returns the cached `TokenResponse` instance.
+   */
+  TokenResponse GetToken(client::CancellationContext& context,
+                         const std::chrono::seconds& minimum_validity =
+                             kDefaultMinimumValiditySeconds) const;
+
   /**
    * @brief Synchronously gets a token that is always fresh.
    *
@@ -92,8 +112,6 @@ class AUTHENTICATION_API OLP_SDK_DEPRECATED("Will be removed by 10.2020.")
    * @note This method is blocked when a new token needs to be retrieved.
    * Therefore, it should not be called from a time-sensitive thread (for
    * example, the UI thread).
-   * @throw std::future_error Thrown when a failure occurs.
-   * Contains the error code and message.
    *
    * @param minimum_validity (Optional) Sets the minimum validity period of
    * the token in seconds. The default validity period is 5 minutes. If

olp-cpp-sdk-authentication/include/olp/authentication/SignInResult.h

@@ -134,6 +134,7 @@ class AUTHENTICATION_API SignInResult {
  private:
   friend class SignInUserResult;
   friend class AuthenticationClientImpl;
+  friend class TokenEndpointImpl;
 
   SignInResult(std::shared_ptr<SignInResultImpl> impl);
 

olp-cpp-sdk-authentication/include/olp/authentication/TokenEndpoint.h

@@ -30,12 +30,14 @@
 #include <olp/authentication/TokenResult.h>
 #include <olp/authentication/Types.h>
 #include <olp/core/client/ApiResponse.h>
+#include <olp/core/client/CancellationContext.h>
 #include <olp/core/client/CancellationToken.h>
 #include <olp/core/porting/warning_disable.h>
 
 namespace olp {
 namespace authentication {
 class AutoRefreshingToken;
+class TokenEndpointImpl;
 
 /**
  * @brief Corresponds to the token endpoint as specified in the OAuth2.0
@@ -89,6 +91,22 @@ class AUTHENTICATION_API OLP_SDK_DEPRECATED("Will be removed in 10.2020")
       client::CancellationToken& cancellation_token,
       const TokenRequest& token_request = TokenRequest()) const;
 
+  /**
+   * @brief Executes the POST request method to the token endpoint.
+   *
+   * The request gets the HERE Access token that is used to access the HERE
+   * platform Services. Returns the token that is used as the `Authorization:
+   * Bearer` token value.
+   *
+   * @param context Used to cancel the pending token request.
+   * @param token_request The `TokenRequest` instance.
+   *
+   * @return The `TokenResponse` instance.
+   */
+  TokenResponse RequestToken(
+      client::CancellationContext& context,
+      const TokenRequest& token_request = TokenRequest()) const;
+
   /**
    * Executes the POST request method to the token endpoint.
    *
@@ -127,8 +145,7 @@ class AUTHENTICATION_API OLP_SDK_DEPRECATED("Will be removed in 10.2020")
   explicit TokenEndpoint(Settings settings);
 
  private:
-  class Impl;
-  std::shared_ptr<Impl> impl_;
+  std::shared_ptr<TokenEndpointImpl> impl_;
 };
 
 }  // namespace authentication

olp-cpp-sdk-authentication/include/olp/authentication/TokenProvider.h

@@ -173,13 +173,11 @@ class TokenProvider {
     /// Gets the token response from `AutoRefreshingToken` or requests a new
     /// token if the token response expired or is not present.
     TokenResponse GetResponse(client::CancellationContext& context) const {
-      OLP_SDK_CORE_UNUSED(context);
-
       // Mutex is needed to prevent multiple authorization requests that can
       // happen when the token is not available, and multiple consumers
       // requested it.
       std::lock_guard<std::mutex> lock(request_mutex_);
-      return token_.GetToken(minimum_validity_);
+      return token_.GetToken(context, minimum_validity_);
     }
 
     /// Checks whether the available token response is valid.

olp-cpp-sdk-authentication/src/AutoRefreshingToken.cpp

@@ -59,7 +59,7 @@ struct AutoRefreshingToken::Impl {
 
   TokenResponse GetToken(client::CancellationToken& cancellation_token,
                          std::chrono::seconds minimum_validity) {
-    if (ForceRefresh(minimum_validity) || ShouldRefreshNow()) {
+    if (ShouldRefreshNow(minimum_validity)) {
       OLP_SDK_LOG_INFO_F(kLogTag, "Time to refresh token");
       TryRefreshCurrentToken(cancellation_token, minimum_validity);
     }
@@ -68,9 +68,20 @@ struct AutoRefreshingToken::Impl {
     return current_token_;
   }
 
+  TokenResponse GetToken(client::CancellationContext& context,
+                         std::chrono::seconds minimum_validity) {
+    if (ShouldRefreshNow(minimum_validity)) {
+      OLP_SDK_LOG_INFO_F(kLogTag, "Time to refresh token");
+      TryRefreshCurrentToken(context, minimum_validity);
+    }
+
+    // Return existing still valid token
+    return current_token_;
+  }
+
   client::CancellationToken GetToken(const GetTokenCallback& callback,
                                      std::chrono::seconds minimum_validity) {
-    if (ForceRefresh(minimum_validity) || ShouldRefreshNow()) {
+    if (ShouldRefreshNow(minimum_validity)) {
       OLP_SDK_LOG_INFO_F(kLogTag, "Time to refresh token");
       return TryRefreshCurrentToken(callback, minimum_validity);
     }
@@ -81,12 +92,9 @@ struct AutoRefreshingToken::Impl {
   }
 
  private:
-  bool ShouldRefreshNow() const {
-    return std::chrono::steady_clock::now() >= token_refresh_time_;
-  }
-
-  bool ForceRefresh(const std::chrono::seconds& minimum_validity) const {
-    return minimum_validity <= std::chrono::seconds(0);
+  bool ShouldRefreshNow(const std::chrono::seconds& minimum_validity) const {
+    return minimum_validity <= std::chrono::seconds(0) ||
+           std::chrono::steady_clock::now() >= token_refresh_time_;
   }
 
   void TryRefreshCurrentToken(client::CancellationToken& cancellation_token,
@@ -110,6 +118,26 @@ struct AutoRefreshingToken::Impl {
     token_refresh_time_ = ComputeRefreshTime(current_token_, minimum_validity);
   }
 
+  void TryRefreshCurrentToken(client::CancellationContext& context,
+                              const std::chrono::seconds& minimum_validity) {
+    std::lock_guard<std::mutex> guard(token_mutex_);
+    current_token_ = token_endpoint_.RequestToken(context, token_request_);
+
+    if (!current_token_) {
+      OLP_SDK_LOG_INFO_F(
+          kLogTag, "Token NOK, error_code=%d, http_status=%d, message='%s'",
+          static_cast<int>(current_token_.GetError().GetErrorCode()),
+          current_token_.GetError().GetHttpStatusCode(),
+          current_token_.GetError().GetMessage().c_str());
+    } else {
+      auto expiry_time = current_token_.GetResult().GetExpiryTime();
+      OLP_SDK_LOG_INFO_F(kLogTag, "Token OK, expires=%s",
+                         std::asctime(std::gmtime(&expiry_time)));
+    }
+
+    token_refresh_time_ = ComputeRefreshTime(current_token_, minimum_validity);
+  }
+
   client::CancellationToken TryRefreshCurrentToken(
       const GetTokenCallback& callback,
       const std::chrono::seconds& minimum_validity) {
@@ -162,6 +190,12 @@ TokenResponse AutoRefreshingToken::GetToken(
   return impl_->GetToken(cancellation_token, minimum_validity);
 }
 
+TokenResponse AutoRefreshingToken::GetToken(
+    client::CancellationContext& context,
+    const std::chrono::seconds& minimum_validity) const {
+  return impl_->GetToken(context, minimum_validity);
+}
+
 TokenResponse AutoRefreshingToken::GetToken(
     const std::chrono::seconds& minimum_validity) const {
   client::CancellationToken cancellation_token;

olp-cpp-sdk-authentication/src/TokenEndpoint.cpp

@@ -17,95 +17,24 @@
  * License-Filename: LICENSE
  */
 
-#include "olp/authentication/TokenEndpoint.h"
+#include <olp/authentication/TokenEndpoint.h>
 
 PORTING_PUSH_WARNINGS()
 PORTING_CLANG_GCC_DISABLE_WARNING("-Wdeprecated-declarations")
 
-#include "olp/authentication/AuthenticationClient.h"
-#include "olp/authentication/AuthenticationCredentials.h"
-#include "olp/authentication/AutoRefreshingToken.h"
-#include "olp/authentication/ErrorResponse.h"
-#include "olp/authentication/SignInResult.h"
-#include "olp/core/logging/Log.h"
+#include <olp/authentication/AuthenticationClient.h>
+#include <olp/authentication/AutoRefreshingToken.h>
+#include <olp/core/logging/Log.h>
+#include "TokenEndpointImpl.h"
 
 namespace olp {
 namespace authentication {
 
 namespace {
 static const std::string kOauth2TokenEndpoint = "/oauth2/token";
 static constexpr auto kLogTag = "TokenEndpoint";
-
-AuthenticationSettings ConvertSettings(Settings settings) {
-  AuthenticationSettings auth_settings;
-  auth_settings.network_proxy_settings = settings.network_proxy_settings;
-  // Ignore task scheduler. It can cause a dealock on the sign in when used from
-  // another task within `TaskScheduler` with 1 thread.
-  //auth_settings.task_scheduler = settings.task_scheduler;
-  auth_settings.network_request_handler = settings.network_request_handler;
-  auth_settings.token_endpoint_url = settings.token_endpoint_url;
-  auth_settings.use_system_time = settings.use_system_time;
-  auth_settings.retry_settings = settings.retry_settings;
-  return auth_settings;
-}
 }  // namespace
 
-class TokenEndpoint::Impl {
- public:
-  explicit Impl(Settings settings);
-
-  client::CancellationToken RequestToken(const TokenRequest& token_request,
-                                         const RequestTokenCallback& callback);
-
-  std::future<TokenResponse> RequestToken(
-      client::CancellationToken& cancel_token,
-      const TokenRequest& token_request);
-
- private:
-  AuthenticationClient auth_client_;
-  AuthenticationCredentials auth_credentials_;
-};
-
-TokenEndpoint::Impl::Impl(Settings settings)
-    : auth_client_(ConvertSettings(settings)),
-      auth_credentials_(std::move(settings.credentials)) {}
-
-client::CancellationToken TokenEndpoint::Impl::RequestToken(
-    const TokenRequest& token_request, const RequestTokenCallback& callback) {
-  AuthenticationClient::SignInProperties properties;
-  properties.expires_in = token_request.GetExpiresIn();
-  return auth_client_.SignInClient(
-      auth_credentials_, properties,
-      [callback](
-          const AuthenticationClient::SignInClientResponse& sign_in_response) {
-        if (!sign_in_response) {
-          callback(sign_in_response.GetError());
-          return;
-        }
-
-        const auto& sign_in_result = sign_in_response.GetResult();
-        if (sign_in_result.GetAccessToken().empty()) {
-          callback(client::ApiError{sign_in_result.GetStatus(),
-                                    sign_in_result.GetFullMessage()});
-          return;
-        }
-
-        callback(TokenResult{sign_in_result.GetAccessToken(),
-                             sign_in_result.GetExpiresIn(),
-                             http::HttpStatusCode::OK, ErrorResponse{}});
-      });
-}
-
-std::future<TokenResponse> TokenEndpoint::Impl::RequestToken(
-    client::CancellationToken& cancel_token,
-    const TokenRequest& token_request) {
-  auto promise = std::make_shared<std::promise<TokenResponse>>();
-  cancel_token = RequestToken(token_request, [promise](TokenResponse response) {
-    promise->set_value(std::move(response));
-  });
-  return promise->get_future();
-}
-
 TokenEndpoint::TokenEndpoint(Settings settings) {
   // The underlying auth library expects a base URL and appends /oauth2/token
   // endpoint to it. Therefore if /oauth2/token is found it is stripped from the
@@ -121,7 +50,7 @@ TokenEndpoint::TokenEndpoint(Settings settings) {
         "standard OAuth2 token endpoint URLs are supported.");
   }
 
-  impl_ = std::make_shared<TokenEndpoint::Impl>(std::move(settings));
+  impl_ = std::make_shared<TokenEndpointImpl>(std::move(settings));
 }
 
 client::CancellationToken TokenEndpoint::RequestToken(
@@ -136,6 +65,12 @@ std::future<TokenResponse> TokenEndpoint::RequestToken(
   return impl_->RequestToken(cancellation_token, token_request);
 }
 
+TokenResponse TokenEndpoint::RequestToken(
+    client::CancellationContext& context,
+    const TokenRequest& token_request) const {
+  return impl_->RequestToken(context, token_request);
+}
+
 std::future<TokenResponse> TokenEndpoint::RequestToken(
     const TokenRequest& token_request) const {
   client::CancellationToken cancellation_token;