http.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/dll_import_export.hpp"
#include "azure/core/exception.hpp"
#include "azure/core/http/http_status_code.hpp"
#include "azure/core/http/raw_response.hpp"
#include "azure/core/internal/contract.hpp"
#include "azure/core/io/body_stream.hpp"
#include "azure/core/nullable.hpp"
#include "azure/core/url.hpp"
 
#include <algorithm>
#include <cstdint>
#include <functional>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <unordered_set>
#include <vector>
 
#if defined(_azure_TESTING_BUILD)
// Define the class used from tests to validate retry enabled
namespace Azure { namespace Core { namespace Test {
  class TestHttp_getters_Test;
  class TestHttp_query_parameter_Test;
  class TestHttp_RequestStartTry_Test;
  class TestURL_getters_Test;
  class TestURL_query_parameter_Test;
  class TransportAdapter_headWithStream_Test;
  class TransportAdapter_putWithStream_Test;
  class TransportAdapter_deleteRequestWithStream_Test;
  class TransportAdapter_patchWithStream_Test;
  class TransportAdapter_putWithStreamOnFail_Test;
  class TransportAdapter_SizePutFromFile_Test;
  class TransportAdapter_SizePutFromFileDefault_Test;
  class TransportAdapter_SizePutFromFileBiggerPage_Test;
}}} // namespace Azure::Core::Test
#endif
 
namespace Azure { namespace Core { namespace Http {
 
  /*********************  Exceptions  **********************/
  class TransportException final : public Azure::Core::RequestFailedException {
  public:
    explicit TransportException(std::string const& what) : Azure::Core::RequestFailedException(what)
    {
    }
  };
 
  struct HttpRange final
  {
    int64_t Offset = 0;
 
    Azure::Nullable<int64_t> Length;
  };
 
  class HttpMethod final {
  public:
    explicit HttpMethod(std::string value) : m_value(std::move(value)) {}
 
    bool operator==(const HttpMethod& other) const { return m_value == other.m_value; }
 
    bool operator!=(const HttpMethod& other) const { return !(*this == other); }
 
    const std::string& ToString() const { return m_value; }
 
    AZ_CORE_DLLEXPORT const static HttpMethod Get;
 
    AZ_CORE_DLLEXPORT const static HttpMethod Head;
 
    AZ_CORE_DLLEXPORT const static HttpMethod Post;
 
    AZ_CORE_DLLEXPORT const static HttpMethod Put;
 
    AZ_CORE_DLLEXPORT const static HttpMethod Delete;
 
    AZ_CORE_DLLEXPORT const static HttpMethod Patch;
 
    AZ_CORE_DLLEXPORT const static HttpMethod Options;
 
  private:
    std::string m_value;
  }; // extensible enum HttpMethod
 
  namespace Policies { namespace _internal {
    class RetryPolicy;
  }} // namespace Policies::_internal
 
  class Request final {
    friend class Azure::Core::Http::Policies::_internal::RetryPolicy;
#if defined(_azure_TESTING_BUILD)
    // make tests classes friends to validate set Retry
    friend class Azure::Core::Test::TestHttp_getters_Test;
    friend class Azure::Core::Test::TestHttp_query_parameter_Test;
    friend class Azure::Core::Test::TestHttp_RequestStartTry_Test;
    friend class Azure::Core::Test::TestURL_getters_Test;
    friend class Azure::Core::Test::TestURL_query_parameter_Test;
    // make tests classes friends to validate private Request ctor that takes both stream and bool
    friend class Azure::Core::Test::TransportAdapter_headWithStream_Test;
    friend class Azure::Core::Test::TransportAdapter_putWithStream_Test;
    friend class Azure::Core::Test::TransportAdapter_deleteRequestWithStream_Test;
    friend class Azure::Core::Test::TransportAdapter_patchWithStream_Test;
    friend class Azure::Core::Test::TransportAdapter_putWithStreamOnFail_Test;
    friend class Azure::Core::Test::TransportAdapter_SizePutFromFile_Test;
    friend class Azure::Core::Test::TransportAdapter_SizePutFromFileDefault_Test;
    friend class Azure::Core::Test::TransportAdapter_SizePutFromFileBiggerPage_Test;
#endif
 
  private:
    HttpMethod m_method;
    Url m_url;
    CaseInsensitiveMap m_headers;
    CaseInsensitiveMap m_retryHeaders;
 
    Azure::Core::IO::BodyStream* m_bodyStream;
 
    // flag to know where to insert header
    bool m_retryModeEnabled{false};
    bool m_shouldBufferResponse{true};
 
    // Expected to be called by a Retry policy to reset all headers set after this function was
    // previously called
    void StartTry();
 
  public:
    explicit Request(
        HttpMethod httpMethod,
        Url url,
        Azure::Core::IO::BodyStream* bodyStream,
        bool shouldBufferResponse)
        : m_method(std::move(httpMethod)), m_url(std::move(url)), m_bodyStream(bodyStream),
          m_retryModeEnabled(false), m_shouldBufferResponse(shouldBufferResponse)
    {
      AZURE_ASSERT_MSG(bodyStream, "The bodyStream pointer cannot be null.");
    }
 
    explicit Request(HttpMethod httpMethod, Url url, Azure::Core::IO::BodyStream* bodyStream)
        : Request(httpMethod, std::move(url), bodyStream, true)
    {
    }
 
    explicit Request(HttpMethod httpMethod, Url url, bool shouldBufferResponse);
 
    explicit Request(HttpMethod httpMethod, Url url);
 
    void SetHeader(std::string const& name, std::string const& value);
 
    Azure::Nullable<std::string> GetHeader(std::string const& name);
 
    void RemoveHeader(std::string const& name);
 
    // Methods used by transport layer (and logger) to send request
    HttpMethod const& GetMethod() const;
 
    CaseInsensitiveMap GetHeaders() const;
 
    Azure::Core::IO::BodyStream* GetBodyStream() { return this->m_bodyStream; }
 
    Azure::Core::IO::BodyStream const* GetBodyStream() const { return this->m_bodyStream; }
 
    bool ShouldBufferResponse() { return this->m_shouldBufferResponse; }
 
    Url& GetUrl() { return this->m_url; }
 
    Url const& GetUrl() const { return this->m_url; }
  };
 
  namespace _detail {
    struct RawResponseHelpers final
    {
      static void InsertHeaderWithValidation(
          CaseInsensitiveMap& headers,
          std::string const& headerName,
          std::string const& headerValue);
 
      static void inline SetHeader(
          Azure::Core::Http::RawResponse& response,
          uint8_t const* const first,
          uint8_t const* const last)
      {
        // get name and value from header
        auto start = first;
        auto end = std::find(start, last, ':');
 
        if (end == last)
        {
          throw std::invalid_argument("Invalid header. No delimiter ':' found.");
        }
 
        // Always toLower() headers
        auto const headerName
            = Azure::Core::_internal::StringExtensions::ToLower(std::string(start, end));
        start = end + 1; // start value
        while (start < last && (*start == ' ' || *start == '\t'))
        {
          ++start;
        }
 
        end = std::find(start, last, '\r');
        auto headerValue = std::string(start, end); // remove \r
 
        response.SetHeader(headerName, headerValue);
      }
    };
  } // namespace _detail
 
  namespace _internal {
 
    struct HttpShared final
    {
      AZ_CORE_DLLEXPORT static char const ContentType[];
      AZ_CORE_DLLEXPORT static char const ApplicationJson[];
      AZ_CORE_DLLEXPORT static char const Accept[];
      AZ_CORE_DLLEXPORT static char const MsRequestId[];
      AZ_CORE_DLLEXPORT static char const MsClientRequestId[];
 
      static inline std::string GetHeaderOrEmptyString(
          Azure::Core::CaseInsensitiveMap const& headers,
          std::string const& headerName)
      {
        auto header = headers.find(headerName);
        if (header != headers.end())
        {
          return header->second; // second is the header value.
        }
        return {}; // empty string
      }
 
      static std::string GenerateUserAgent(
          std::string const& componentName,
          std::string const& componentVersion,
          std::string const& applicationId,
          long cplusplusValue);
 
    private:
      HttpShared() = delete;
      ~HttpShared() = delete;
    };
  } // namespace _internal
 
}}} // namespace Azure::Core::Http