policy.hpp

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/core/case_insensitive_containers.hpp"
#include "azure/core/context.hpp"
#include "azure/core/credentials/credentials.hpp"
#include "azure/core/dll_import_export.hpp"
#include "azure/core/http/http.hpp"
#include "azure/core/http/transport.hpp"
#include "azure/core/internal/http/http_sanitizer.hpp"
#include "azure/core/uuid.hpp"
 
#include <atomic>
#include <chrono>
#include <cstddef>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <shared_mutex>
#include <string>
#include <utility>
#include <vector>
 
extern std::shared_ptr<Azure::Core::Http::HttpTransport> AzureSdkGetCustomHttpTransport();
 
namespace Azure { namespace Core { namespace Http { namespace Policies {
 
  struct TransportOptions;
  namespace _detail {
    std::shared_ptr<HttpTransport> GetTransportAdapter(TransportOptions const& transportOptions);
 
    AZ_CORE_DLLEXPORT extern std::set<std::string> const g_defaultAllowedHttpQueryParameters;
    AZ_CORE_DLLEXPORT extern CaseInsensitiveSet const g_defaultAllowedHttpHeaders;
  } // namespace _detail
 
  namespace _internal {
    class TelemetryPolicy;
  }
 
  struct TelemetryOptions final
  {
    std::string ApplicationId;
 
    std::shared_ptr<Azure::Core::Tracing::TracerProvider> TracingProvider;
 
  private:
    // The friend declaration is needed so that TelemetryPolicy could access CppStandardVersion,
    // and it is not a struct's public field like the ones above to be set non-programmatically.
    // When building the SDK, tests, or samples, the value of __cplusplus is ultimately controlled
    // by the cmake files in this repo (i.e. C++14), therefore we set distinct values of 0, -1, etc
    // when it is the case.
    friend class _internal::TelemetryPolicy;
    long CppStandardVersion =
#if defined(_azure_BUILDING_SDK)
        -2L
#elif defined(_azure_BUILDING_TESTS)
        -1L
#elif defined(_azure_BUILDING_SAMPLES)
        0L
#else
    // https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
#if defined(_MSVC_LANG) && __cplusplus == 199711L
        _MSVC_LANG
#else
        __cplusplus
#endif
#endif
        ;
  };
 
  struct RetryOptions final
  {
    int32_t MaxRetries = 3;
 
    std::chrono::milliseconds RetryDelay = std::chrono::milliseconds(800);
 
    std::chrono::milliseconds MaxRetryDelay = std::chrono::seconds(60);
 
    std::set<HttpStatusCode> StatusCodes{
        HttpStatusCode::RequestTimeout,
        HttpStatusCode::InternalServerError,
        HttpStatusCode::BadGateway,
        HttpStatusCode::ServiceUnavailable,
        HttpStatusCode::GatewayTimeout,
    };
  };
 
  struct LogOptions final
  {
    std::set<std::string> AllowedHttpQueryParameters = _detail::g_defaultAllowedHttpQueryParameters;
 
    CaseInsensitiveSet AllowedHttpHeaders = _detail::g_defaultAllowedHttpHeaders;
  };
 
  struct TransportOptions final
  {
    Azure::Nullable<std::string> HttpProxy{};
 
    Azure::Nullable<std::string> ProxyUserName{};
 
    Azure::Nullable<std::string> ProxyPassword{};
 
    bool EnableCertificateRevocationListCheck{false};
 
    bool DisableTlsCertificateValidation{false};
 
    std::string ExpectedTlsRootCertificate{};
 
    std::shared_ptr<HttpTransport> Transport;
  };
 
  class NextHttpPolicy;
 
  class HttpPolicy {
  public:
    // If we get a response that goes up the stack
    // Any errors in the pipeline throws an exception
    // At the top of the pipeline we might want to turn certain responses into exceptions
 
    virtual std::unique_ptr<RawResponse> Send(
        Request& request,
        NextHttpPolicy nextPolicy,
        Context const& context) const = 0;
 
    virtual ~HttpPolicy() {}
 
    virtual std::unique_ptr<HttpPolicy> Clone() const = 0;
 
  protected:
    HttpPolicy() = default;
 
    HttpPolicy(const HttpPolicy& other) = default;
 
    HttpPolicy& operator=(const HttpPolicy& other) = default;
 
    HttpPolicy(HttpPolicy&& other) = default;
  };
 
  class NextHttpPolicy final {
    const size_t m_index;
    const std::vector<std::unique_ptr<HttpPolicy>>& m_policies;
 
  public:
    explicit NextHttpPolicy(size_t index, const std::vector<std::unique_ptr<HttpPolicy>>& policies)
        : m_index(index), m_policies(policies)
    {
    }
 
    std::unique_ptr<RawResponse> Send(Request& request, Context const& context);
  };
 
  namespace _internal {
 
    class TransportPolicy final : public HttpPolicy {
    private:
      TransportOptions m_options;
 
    public:
      explicit TransportPolicy(TransportOptions const& options = TransportOptions());
 
      std::unique_ptr<HttpPolicy> Clone() const override
      {
        return std::make_unique<TransportPolicy>(*this);
      }
 
      std::unique_ptr<RawResponse> Send(
          Request& request,
          NextHttpPolicy nextPolicy,
          Context const& context) const override;
    };
 
    class RetryPolicyBase : public HttpPolicy {
    private:
      RetryOptions m_retryOptions;
 
    public:
      explicit RetryPolicyBase(RetryOptions options) : m_retryOptions(std::move(options)) {}
 
      std::unique_ptr<RawResponse> Send(
          Request& request,
          NextHttpPolicy nextPolicy,
          Context const& context) const final;
 
      static int32_t GetRetryCount(Context const& context);
 
    protected:
      virtual bool ShouldRetryOnTransportFailure(
          RetryOptions const& retryOptions,
          int32_t attempt,
          std::chrono::milliseconds& retryAfter,
          double jitterFactor = -1) const;
 
      virtual bool ShouldRetryOnResponse(
          RawResponse const& response,
          RetryOptions const& retryOptions,
          int32_t attempt,
          std::chrono::milliseconds& retryAfter,
          double jitterFactor = -1) const;
    };
 
    class RetryPolicy final : public RetryPolicyBase {
    public:
      explicit RetryPolicy(RetryOptions options) : RetryPolicyBase(std::move(options)) {}
 
      std::unique_ptr<HttpPolicy> Clone() const override
      {
        return std::make_unique<RetryPolicy>(*this);
      }
    };
 
    class RequestIdPolicy final : public HttpPolicy {
    private:
      constexpr static const char* RequestIdHeader = "x-ms-client-request-id";
 
    public:
      explicit RequestIdPolicy() {}
 
      std::unique_ptr<HttpPolicy> Clone() const override
      {
        return std::make_unique<RequestIdPolicy>(*this);
      }
 
      std::unique_ptr<RawResponse> Send(
          Request& request,
          NextHttpPolicy nextPolicy,
          Context const& context) const override
      {
        if (!request.GetHeader(RequestIdHeader).HasValue())
        {
          auto const uuid = Uuid::CreateUuid().ToString();
          request.SetHeader(RequestIdHeader, uuid);
        }
 
        return nextPolicy.Send(request, context);
      }
    };
 
    class RequestActivityPolicy final : public HttpPolicy {
    private:
      Azure::Core::Http::_internal::HttpSanitizer m_httpSanitizer;
 
    public:
      //      explicit RequestActivityPolicy() = default;
      explicit RequestActivityPolicy(
          Azure::Core::Http::_internal::HttpSanitizer const& httpSanitizer)
          : m_httpSanitizer(httpSanitizer)
      {
      }
 
      std::unique_ptr<HttpPolicy> Clone() const override
      {
        return std::make_unique<RequestActivityPolicy>(*this);
      }
 
      std::unique_ptr<RawResponse> Send(
          Request& request,
          NextHttpPolicy nextPolicy,
          Context const& context) const override;
    };
 
    class TelemetryPolicy final : public HttpPolicy {
    private:
      std::string const m_telemetryId;
 
    public:
      explicit TelemetryPolicy(
          std::string const& packageName,
          std::string const& packageVersion,
          TelemetryOptions options = TelemetryOptions())
          : m_telemetryId(Azure::Core::Http::_internal::HttpShared::GenerateUserAgent(
              packageName,
              packageVersion,
              options.ApplicationId,
              options.CppStandardVersion))
      {
      }
 
      std::unique_ptr<HttpPolicy> Clone() const override
      {
        return std::make_unique<TelemetryPolicy>(*this);
      }
 
      std::unique_ptr<RawResponse> Send(
          Request& request,
          NextHttpPolicy nextPolicy,
          Context const& context) const override;
    };
 
    class BearerTokenAuthenticationPolicy : public HttpPolicy {
    private:
      std::shared_ptr<const Credentials::TokenCredential> m_credential;
      Credentials::TokenRequestContext m_tokenRequestContext;
 
      mutable Credentials::AccessToken m_accessToken;
      mutable std::shared_timed_mutex m_accessTokenMutex;
      mutable Credentials::TokenRequestContext m_accessTokenContext;
      mutable std::atomic<bool> m_invalidateToken = {false};
 
    public:
      explicit BearerTokenAuthenticationPolicy(
          std::shared_ptr<const Credentials::TokenCredential> credential,
          Credentials::TokenRequestContext tokenRequestContext)
          : m_credential(std::move(credential)),
            m_tokenRequestContext(std::move(tokenRequestContext))
      {
      }
 
      std::unique_ptr<HttpPolicy> Clone() const override
      {
        // Can't use std::make_shared here because copy constructor is not public.
        return std::unique_ptr<HttpPolicy>(new BearerTokenAuthenticationPolicy(*this));
      }
 
      std::unique_ptr<RawResponse> Send(
          Request& request,
          NextHttpPolicy nextPolicy,
          Context const& context) const override;
 
    protected:
      BearerTokenAuthenticationPolicy(BearerTokenAuthenticationPolicy const& other)
          : BearerTokenAuthenticationPolicy(other.m_credential, other.m_tokenRequestContext)
      {
        std::shared_lock<std::shared_timed_mutex> readLock(other.m_accessTokenMutex);
        m_accessToken = other.m_accessToken;
        m_accessTokenContext = other.m_accessTokenContext;
        m_invalidateToken.store(other.m_invalidateToken.load());
      }
 
      void operator=(BearerTokenAuthenticationPolicy const&) = delete;
 
      virtual std::unique_ptr<RawResponse> AuthorizeAndSendRequest(
          Request& request,
          NextHttpPolicy& nextPolicy,
          Context const& context) const;
 
      virtual bool AuthorizeRequestOnChallenge(
          std::string const& challenge,
          Request& request,
          Context const& context) const;
 
      void AuthenticateAndAuthorizeRequest(
          Request& request,
          Credentials::TokenRequestContext const& tokenRequestContext,
          Context const& context) const;
    };
 
    class LogPolicy final : public HttpPolicy {
      LogOptions m_options;
      Azure::Core::Http::_internal::HttpSanitizer m_httpSanitizer;
 
    public:
      explicit LogPolicy(LogOptions options)
          : m_options(std::move(options)),
            m_httpSanitizer(m_options.AllowedHttpQueryParameters, m_options.AllowedHttpHeaders)
      {
      }
 
      std::unique_ptr<HttpPolicy> Clone() const override
      {
        return std::make_unique<LogPolicy>(*this);
      }
 
      std::unique_ptr<RawResponse> Send(
          Request& request,
          NextHttpPolicy nextPolicy,
          Context const& context) const override;
    };
  } // namespace _internal
}}}} // namespace Azure::Core::Http::Policies