policy.hpp

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// SPDX-License-Identifier: MIT
 
#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/input_sanitizer.hpp"
#include "azure/core/tracing/tracing.hpp"
#include "azure/core/uuid.hpp"
 
#include <atomic>
#include <chrono>
#include <cstddef>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
extern std::shared_ptr<Azure::Core::Http::HttpTransport> AzureSdkGetCustomHttpTransport();
 
namespace Azure { namespace Core { namespace Http { namespace Policies {
 
  namespace _detail {
    std::shared_ptr<HttpTransport> GetTransportAdapter();
    AZ_CORE_DLLEXPORT extern Azure::Core::CaseInsensitiveSet const g_defaultAllowedHttpHeaders;
  } // namespace _detail
 
  struct TelemetryOptions final
  {
    std::string ApplicationId;
 
    std::shared_ptr<Azure::Core::Tracing::TracerProvider> TracingProvider{
        Context::ApplicationContext.GetTracerProvider()};
  };
 
  struct RetryOptions final
  {
    int32_t MaxRetries = 3;
 
    std::chrono::milliseconds RetryDelay = std::chrono::seconds(4);
 
    std::chrono::milliseconds MaxRetryDelay = std::chrono::minutes(2);
 
    std::set<HttpStatusCode> StatusCodes{
        HttpStatusCode::RequestTimeout,
        HttpStatusCode::InternalServerError,
        HttpStatusCode::BadGateway,
        HttpStatusCode::ServiceUnavailable,
        HttpStatusCode::GatewayTimeout,
    };
  };
 
  struct LogOptions final
  {
    std::set<std::string> AllowedHttpQueryParameters;
 
    Azure::Core::CaseInsensitiveSet AllowedHttpHeaders = _detail::g_defaultAllowedHttpHeaders;
  };
 
  struct TransportOptions final
  {
    std::shared_ptr<HttpTransport> Transport = _detail::GetTransportAdapter();
  };
 
  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 options = TransportOptions())
          : m_options(std::move(options))
      {
      }
 
      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 RetryPolicy
#if !defined(TESTING_BUILD)
        final
#endif
        : public HttpPolicy {
    private:
      RetryOptions m_retryOptions;
 
    public:
      explicit RetryPolicy(RetryOptions options) : m_retryOptions(std::move(options)) {}
 
      std::unique_ptr<HttpPolicy> Clone() const override
      {
        return std::make_unique<RetryPolicy>(*this);
      }
 
      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 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
      {
        auto uuid = Uuid::CreateUuid().ToString();
 
        request.SetHeader(RequestIdHeader, uuid);
        return nextPolicy.Send(request, context);
      }
    };
 
    class RequestActivityPolicy final : public HttpPolicy {
    private:
      Azure::Core::_internal::InputSanitizer m_inputSanitizer;
 
    public:
      //      explicit RequestActivityPolicy() = default;
      explicit RequestActivityPolicy(Azure::Core::_internal::InputSanitizer const& inputSanitizer)
          : m_inputSanitizer(inputSanitizer)
      {
      }
 
      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;
 
      static std::string BuildTelemetryId(
          std::string const& componentName,
          std::string const& componentVersion,
          std::string const& applicationId);
 
    public:
      explicit TelemetryPolicy(
          std::string const& componentName,
          std::string const& componentVersion,
          TelemetryOptions options = TelemetryOptions())
          : m_telemetryId(BuildTelemetryId(componentName, componentVersion, options.ApplicationId))
      {
      }
 
      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 final : public HttpPolicy {
    private:
      std::shared_ptr<Credentials::TokenCredential const> const m_credential;
      Credentials::TokenRequestContext m_tokenRequestContext;
 
      mutable Credentials::AccessToken m_accessToken;
      mutable std::mutex m_accessTokenMutex;
 
      BearerTokenAuthenticationPolicy(BearerTokenAuthenticationPolicy const&) = delete;
      void operator=(BearerTokenAuthenticationPolicy const&) = delete;
 
    public:
      explicit BearerTokenAuthenticationPolicy(
          std::shared_ptr<Credentials::TokenCredential const> credential,
          Credentials::TokenRequestContext tokenRequestContext)
          : m_credential(std::move(credential)),
            m_tokenRequestContext(std::move(tokenRequestContext))
      {
      }
 
      std::unique_ptr<HttpPolicy> Clone() const override
      {
        return std::make_unique<BearerTokenAuthenticationPolicy>(
            m_credential, m_tokenRequestContext);
      }
 
      std::unique_ptr<RawResponse> Send(
          Request& request,
          NextHttpPolicy nextPolicy,
          Context const& context) const override;
    };
 
    class LogPolicy final : public HttpPolicy {
      LogOptions m_options;
      Azure::Core::_internal::InputSanitizer m_inputSanitizer;
 
    public:
      explicit LogPolicy(LogOptions options)
          : m_options(std::move(options)),
            m_inputSanitizer(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