github/azure-sdk-for-cpp
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Core/response t (#316)

Browse Source 
* rename http response to RawResponse

* Adding Response T
This commit is contained in:
Victor Vazquez 2020-07-17 14:43:17 -07:00 committed by GitHub
parent 0f37994e44
commit 6122529bac
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 222 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sdk/core/azure-core/CMakeLists.txt
View File

@ -23,7 +23,7 @@ add_library (
src/http/curl/curl.cpp
src/http/policy.cpp
src/http/request.cpp
src/http/response.cpp
src/http/raw_response.cpp
src/http/retry_policy.cpp
src/http/url.cpp
src/http/winhttp/win_http_transport.cpp

2
sdk/core/azure-core/inc/credentials/policy/policies.hpp
View File

@ -60,7 +60,7 @@ namespace Azure { namespace Core { namespace Credentials { namespace Policy {
return new BearerTokenAuthenticationPolicy(m_credential, m_scopes);
}
std::unique_ptr<Http::Response> Send(
std::unique_ptr<Http::RawResponse> Send(
Context& context,
Http::Request& request,
Http::NextHttpPolicy policy) const override;

62
sdk/core/azure-core/inc/http/curl/curl.hpp
View File

@ -20,7 +20,7 @@ namespace Azure { namespace Core { namespace Http {
/**
* @brief Statefull component that controls sending an HTTP Request with libcurl thru the wire and
* parsing and building an HTTP Response.
* parsing and building an HTTP RawResponse.
* This session supports the classic libcurl easy interface to send and receive bytes from network
* using callbacks.
* This session also supports working with the custom HTTP protocol option from libcurl to
@ -34,7 +34,7 @@ namespace Azure { namespace Core { namespace Http {
private:
/**
* @brief Enum used by ResponseBufferParser to control the parsing internal state while building
* the HTTP Response
* the HTTP RawResponse
*
*/
enum class ResponseParserState
@ -45,14 +45,14 @@ namespace Azure { namespace Core { namespace Http {
};
/**
* @brief stateful component used to read and parse a buffer to construct a valid HTTP Response.
* @brief stateful component used to read and parse a buffer to construct a valid HTTP RawResponse.
*
* It uses an internal string as buffers to accumulate a response token (version, code, header,
* etc) until the next delimiter is found. Then it uses this string to keep building the HTTP
* Response.
* RawResponse.
*
* @remark Only status line and headers are parsed and built. Body is ignored by this component.
* A libcurl session will use this component to build and return the HTTP Response with a body
* A libcurl session will use this component to build and return the HTTP RawResponse with a body
* stream to the pipeline.
*/
class ResponseBufferParser {
@ -63,15 +63,15 @@ namespace Azure { namespace Core { namespace Http {
*/
ResponseParserState state;
/**
* @brief Unique prt to a response. Parser will create an Initial-valid HTTP Response and then
* @brief Unique prt to a response. Parser will create an Initial-valid HTTP RawResponse and then
* it will append headers to it. This response is moved to a different owner once parsing is
* completed.
*
*/
std::unique_ptr<Response> m_response;
std::unique_ptr<RawResponse> m_response;
/**
* @brief Indicates if parser has found the end of the headers and there is nothing left for
* the HTTP Response.
* the HTTP RawResponse.
*
*/
bool m_parseCompleted;
@ -81,10 +81,10 @@ namespace Azure { namespace Core { namespace Http {
/**
* @brief This buffer is used when the parsed buffer doesn't contain a completed token. The
* content from the buffer will be appended to this buffer. Once that a delimiter is found,
* the token for the HTTP Response is taken from this internal sting if it contains data.
* the token for the HTTP RawResponse is taken from this internal sting if it contains data.
*
* @remark This buffer allows a libcurl session to use any size of buffer to read from a
* socket while constructing an initial valid HTTP Response. No matter if the response from
* socket while constructing an initial valid HTTP RawResponse. No matter if the response from
* wire contains hundreds of headers, we can use only one fixed size buffer to parse it all.
*
*/
@ -96,7 +96,7 @@ namespace Azure { namespace Core { namespace Http {
* line delimiter.
*
* @remark When the end of status line delimiter is found, this method will create the HTTP
* Response. The HTTP Response is constructed by default with body type as Stream.
* RawResponse. The HTTP RawResponse is constructed by default with body type as Stream.
*
* @param buffer Points to a memory address with all or some part of a HTTP status line.
* @param bufferSize Indicates the size of the buffer.
@ -106,7 +106,7 @@ namespace Azure { namespace Core { namespace Http {
/**
* @brief This method is invoked by the Parsing process if the internal state is set to
* headers. Function will keep adding headers to the HTTP Response created before while
* headers. Function will keep adding headers to the HTTP RawResponse created before while
* parsing an status line.
*
* @param buffer Points to a memory address with all or some part of a HTTP header.
@ -118,7 +118,7 @@ namespace Azure { namespace Core { namespace Http {
public:
/**
* @brief Construct a new Response Buffer Parser object.
* @brief Construct a new RawResponse Buffer Parser object.
* Set the initial state and parsing completion.
*
*/
@ -132,22 +132,22 @@ namespace Azure { namespace Core { namespace Http {
// Parse contents of buffer to construct HttpResponse. Returns the index of the last parsed
// possition. Return bufferSize when all buffer was used to parse
/**
* @brief Parses the content of a buffer to constuct a valid HTTP Response. This method is
* @brief Parses the content of a buffer to constuct a valid HTTP RawResponse. This method is
* expected to be called over and over until it returns 0, indicating there is nothing more to
* parse to build the HTTP Response.
* parse to build the HTTP RawResponse.
*
* @param buffer points to a memory area that contains, all or some part of an HTTP response.
* @param bufferSize Indicates the size of the buffer.
* @return Returns the index of the last parsed position. Returning a 0 means nothing was
* parsed and it is likely that the HTTP Response is completed. Returning the same value as
* parsed and it is likely that the HTTP RawResponse is completed. Returning the same value as
* the buffer size means all buffer was parsed and the HTTP might be completed or not.
* Returning a value smaller than the buffer size will likely indicate that the HTTP Response
* Returning a value smaller than the buffer size will likely indicate that the HTTP RawResponse
* is completed and that the rest of the buffer contains part of the response body.
*/
int64_t Parse(uint8_t const* const buffer, int64_t const bufferSize);
/**
* @brief Indicates when the parser has completed parsing and building the HTTP Response.
* @brief Indicates when the parser has completed parsing and building the HTTP RawResponse.
*
* @return true if parsing is completed. Otherwise false.
*/
@ -156,10 +156,10 @@ namespace Azure { namespace Core { namespace Http {
/**
* @brief Moves the internal response to a different owner.
*
* @return Will move the response only if parsing is completed and if the HTTP Response was
* @return Will move the response only if parsing is completed and if the HTTP RawResponse was
* not moved before.
*/
std::unique_ptr<Response> GetResponse()
std::unique_ptr<RawResponse> GetResponse()
{
if (this->m_parseCompleted && this->m_response != nullptr)
{
@ -182,11 +182,11 @@ namespace Azure { namespace Core { namespace Http {
curl_socket_t m_curlSocket;
/**
* @brief unique ptr for the HTTP Response. The session is responsable for creating the response
* @brief unique ptr for the HTTP RawResponse. The session is responsable for creating the response
* once that an HTTP status line is received.
*
*/
std::unique_ptr<Response> m_response;
std::unique_ptr<RawResponse> m_response;
/**
* @brief The HTTP Request for to be used by the session.
@ -229,7 +229,7 @@ namespace Azure { namespace Core { namespace Http {
/**
* @brief This is a copy of the value of an HTTP response header `content-length`. The value is
* received as string and parsed to size_t. This field avoid parsing the string header everytime
* from HTTP Response.
* from HTTP RawResponse.
*
* @remark This value is also used to avoid trying to read more data from network than what we
* are expecting to.
@ -248,7 +248,7 @@ namespace Azure { namespace Core { namespace Http {
/**
* @brief Internal buffer from a session used to read bytes from a socket. This buffer is only
* used while constructing an HTTP Response without adding a body to it. Customers would
* used while constructing an HTTP RawResponse without adding a body to it. Customers would
* provide their own buffer to copy from socket when reading the HTTP body using streams.
*
*/
@ -336,7 +336,7 @@ namespace Azure { namespace Core { namespace Http {
/**
* @brief This function is used after sending an HTTP request to the server to read the HTTP
* Response from wire until the end of headers only.
* RawResponse from wire until the end of headers only.
*
* @return CURL_OK when an HTTP response is created.
*/
@ -389,12 +389,12 @@ namespace Azure { namespace Core { namespace Http {
CURLcode Perform(Context& context);
/**
* @brief Moved the ownership of the HTTP Response out of the session.
* @brief Moved the ownership of the HTTP RawResponse out of the session.
*
* @return the unique ptr to the HTTP Response or null if the HTTP Response is not yet created
* @return the unique ptr to the HTTP RawResponse or null if the HTTP RawResponse is not yet created
* or was moved before.
*/
std::unique_ptr<Azure::Core::Http::Response> GetResponse();
std::unique_ptr<Azure::Core::Http::RawResponse> GetResponse();
int64_t Length() const override { return this->m_contentLength; }
@ -410,13 +410,13 @@ namespace Azure { namespace Core { namespace Http {
class CurlTransport : public HttpTransport {
public:
/**
* @brief Implements interface to send an HTTP Request and produce an HTTP Response
* @brief Implements interface to send an HTTP Request and produce an HTTP RawResponse
*
* @param context TBD
* @param request an HTTP Request to be send.
* @return unique ptr to an HTTP Response.
* @return unique ptr to an HTTP RawResponse.
*/
std::unique_ptr<Response> Send(Context& context, Request& request) override;
std::unique_ptr<RawResponse> Send(Context& context, Request& request) override;
};
}}} // namespace Azure::Core::Http

16
sdk/core/azure-core/inc/http/http.hpp
View File

@ -9,9 +9,9 @@
#include <internal/contract.hpp>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
#include <stdexcept>
namespace Azure { namespace Core { namespace Http {
@ -234,14 +234,14 @@ namespace Azure { namespace Core { namespace Http {
std::string GetQueryString() const;
public:
Request(HttpMethod httpMethod, std::string const& url, BodyStream* bodyStream)
explicit Request(HttpMethod httpMethod, std::string const& url, BodyStream* bodyStream)
: m_method(std::move(httpMethod)), m_url(url), m_bodyStream(bodyStream),
m_retryModeEnabled(false)
{
}
// Typically used for GET with no request body.
Request(HttpMethod httpMethod, std::string const& url)
explicit Request(HttpMethod httpMethod, std::string const& url)
: Request(httpMethod, url, NullBodyStream::GetNullBodyStream())
{
}
@ -262,7 +262,7 @@ namespace Azure { namespace Core { namespace Http {
};
/*
* Response exceptions
* RawResponse exceptions
*/
struct CouldNotResolveHostException : public std::runtime_error
{
@ -275,7 +275,7 @@ namespace Azure { namespace Core { namespace Http {
explicit TransportException(std::string const& msg) : std::runtime_error(msg) {}
};
class Response {
class RawResponse {
private:
int32_t m_majorVersion;
@ -286,7 +286,7 @@ namespace Azure { namespace Core { namespace Http {
std::unique_ptr<BodyStream> m_bodyStream;
Response(
explicit RawResponse(
int32_t majorVersion,
int32_t minorVersion,
HttpStatusCode statusCode,
@ -298,12 +298,12 @@ namespace Azure { namespace Core { namespace Http {
}
public:
Response(
explicit RawResponse(
int32_t majorVersion,
int32_t minorVersion,
HttpStatusCode statusCode,
std::string const& reasonPhrase)
: Response(majorVersion, minorVersion, statusCode, reasonPhrase, nullptr)
: RawResponse(majorVersion, minorVersion, statusCode, reasonPhrase, nullptr)
{
}

2
sdk/core/azure-core/inc/http/pipeline.hpp
View File

@ -47,7 +47,7 @@ namespace Azure { namespace Core { namespace Http {
* @param request The request to be processed
* @return unique_ptr<Response>
*/
std::unique_ptr<Response> Send(Context& ctx, Request& request) const
std::unique_ptr<RawResponse> Send(Context& ctx, Request& request) const
{
return m_policies[0]->Send(ctx, request, NextHttpPolicy(0, &m_policies));
}

10
sdk/core/azure-core/inc/http/policy.hpp
View File

@ -20,7 +20,7 @@ namespace Azure { namespace Core { namespace Http {
// 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<Response> Send(
virtual std::unique_ptr<RawResponse> Send(
Context& context,
Request& request,
NextHttpPolicy policy) const = 0;
@ -46,7 +46,7 @@ namespace Azure { namespace Core { namespace Http {
{
}
std::unique_ptr<Response> Send(Context& ctx, Request& req);
std::unique_ptr<RawResponse> Send(Context& ctx, Request& req);
};
class TransportPolicy : public HttpPolicy {
@ -61,7 +61,7 @@ namespace Azure { namespace Core { namespace Http {
HttpPolicy* Clone() const override { return new TransportPolicy(m_transport); }
std::unique_ptr<Response> Send(Context& ctx, Request& request, NextHttpPolicy nextHttpPolicy)
std::unique_ptr<RawResponse> Send(Context& ctx, Request& request, NextHttpPolicy nextHttpPolicy)
const override
{
AZURE_UNREFERENCED_PARAMETER(nextHttpPolicy);
@ -98,7 +98,7 @@ namespace Azure { namespace Core { namespace Http {
HttpPolicy* Clone() const override { return new RetryPolicy(m_retryOptions); }
std::unique_ptr<Response> Send(Context& ctx, Request& request, NextHttpPolicy nextHttpPolicy)
std::unique_ptr<RawResponse> Send(Context& ctx, Request& request, NextHttpPolicy nextHttpPolicy)
const override;
};
@ -109,7 +109,7 @@ namespace Azure { namespace Core { namespace Http {
HttpPolicy* Clone() const override { return new RequestIdPolicy(); }
std::unique_ptr<Response> Send(Context& ctx, Request& request, NextHttpPolicy nextHttpPolicy)
std::unique_ptr<RawResponse> Send(Context& ctx, Request& request, NextHttpPolicy nextHttpPolicy)
const override
{
// Do real work here

2
sdk/core/azure-core/inc/http/transport.hpp
View File

@ -15,7 +15,7 @@ namespace Azure { namespace Core { namespace Http {
// At the top of the pipeline we might want to turn certain responses into exceptions
//TODO - Should this be const
virtual std::unique_ptr<Response> Send(Context& context, Request& request) = 0;
virtual std::unique_ptr<RawResponse> Send(Context& context, Request& request) = 0;
virtual ~HttpTransport() {}
protected:

2
sdk/core/azure-core/inc/http/winhttp/win_http_client.hpp
View File

@ -20,7 +20,7 @@ namespace Azure { namespace Core { namespace Http {
WinHttpTansport();
~WinHttpTansport();
virtual std::unique_ptr<Response> Send(Context& context, Request& request) ;
virtual std::unique_ptr<RawResponse> Send(Context& context, Request& request) ;
};
}}} // namespace Azure::Core::Http

33
sdk/core/azure-core/inc/response.hpp Normal file
View File

@ -0,0 +1,33 @@
// Copyright (c) Microsoft Corporation. All rights reserved.
// SPDX-License-Identifier: MIT
#pragma once
#include <http/http.hpp>
namespace Azure { namespace Core {
template <class T> class Response {
T m_value;
std::unique_ptr<Http::RawResponse> m_rawResponse;
public:
// Require a raw response to create a Response T
explicit Response(T initialValue, std::unique_ptr<Http::RawResponse>&& rawResponse)
: m_value(std::move(initialValue)), m_rawResponse(std::move(rawResponse))
{
}
// Do not give up raw response ownership.
Http::RawResponse& GetRawResponse() { return *this->m_rawResponse; }
T& operator=(const Response& other) = delete;
const T* operator->() const { return &this->m_value; };
T* operator->() { return &this->m_value; };
T& operator*() { return this->m_value; };
const T& operator*() const { return this->m_value; };
T ExtractValue() { return std::move(this->m_value); }
};
}} // namespace Azure::Core

2
sdk/core/azure-core/src/credentials/credentials.cpp
View File

@ -85,7 +85,7 @@ AccessToken ClientSecretCredential::GetToken(
Http::HttpPipeline httpPipeline(policies);
std::shared_ptr<Http::Response> response = httpPipeline.Send(context, request);
std::shared_ptr<Http::RawResponse> response = httpPipeline.Send(context, request);
if (!response)
{

2
sdk/core/azure-core/src/credentials/policy/policies.cpp
View File

@ -5,7 +5,7 @@
using namespace Azure::Core::Credentials::Policy;
std::unique_ptr<Azure::Core::Http::Response> BearerTokenAuthenticationPolicy::Send(
std::unique_ptr<Azure::Core::Http::RawResponse> BearerTokenAuthenticationPolicy::Send(
Context& context,
Http::Request& request,
Http::NextHttpPolicy policy) const

10
sdk/core/azure-core/src/http/curl/curl.cpp
View File

@ -8,7 +8,7 @@
using namespace Azure::Core::Http;
std::unique_ptr<Response> CurlTransport::Send(Context& context, Request& request)
std::unique_ptr<RawResponse> CurlTransport::Send(Context& context, Request& request)
{
// Create CurlSession to perform request
auto session = std::make_unique<CurlSession>(request);
@ -125,7 +125,7 @@ CURLcode CurlSession::Perform(Context& context)
}
// Creates an HTTP Response with specific bodyType
static std::unique_ptr<Response> CreateHTTPResponse(
static std::unique_ptr<RawResponse> CreateHTTPResponse(
uint8_t const* const begin,
uint8_t const* const last)
{
@ -149,12 +149,12 @@ static std::unique_ptr<Response> CreateHTTPResponse(
// allocate the instance of response to heap with shared ptr
// So this memory gets delegated outside Curl Transport as a shared ptr so memory will be
// eventually released
return std::make_unique<Response>(
return std::make_unique<RawResponse>(
(uint16_t)majorVersion, (uint16_t)minorVersion, HttpStatusCode(statusCode), reasonPhrase);
}
// Creates an HTTP Response with specific bodyType
static std::unique_ptr<Response> CreateHTTPResponse(std::string const& header)
static std::unique_ptr<RawResponse> CreateHTTPResponse(std::string const& header)
{
return CreateHTTPResponse(
reinterpret_cast<const uint8_t*>(header.data()),
@ -538,7 +538,7 @@ int64_t CurlSession::ReadSocketToBuffer(uint8_t* buffer, int64_t bufferSize)
return readBytes;
}
std::unique_ptr<Azure::Core::Http::Response> CurlSession::GetResponse()
std::unique_ptr<Azure::Core::Http::RawResponse> CurlSession::GetResponse()
{
return std::move(this->m_response);
}

2
sdk/core/azure-core/src/http/policy.cpp
View File

@ -6,7 +6,7 @@
using namespace Azure::Core::Http;
std::unique_ptr<Response> NextHttpPolicy::Send(Context& ctx, Request& req)
std::unique_ptr<RawResponse> NextHttpPolicy::Send(Context& ctx, Request& req)
{
if (m_policies == nullptr)
throw;

14
sdk/core/azure-core/src/http/response.cpp → sdk/core/azure-core/src/http/raw_response.cpp
View File

@ -12,13 +12,13 @@
using namespace Azure::Core::Http;
HttpStatusCode Response::GetStatusCode() const { return m_statusCode; }
HttpStatusCode RawResponse::GetStatusCode() const { return m_statusCode; }
std::string const& Response::GetReasonPhrase() { return m_reasonPhrase; }
std::string const& RawResponse::GetReasonPhrase() { return m_reasonPhrase; }
std::map<std::string, std::string> const& Response::GetHeaders() const { return this->m_headers; }
std::map<std::string, std::string> const& RawResponse::GetHeaders() const { return this->m_headers; }
void Response::AddHeader(uint8_t const* const begin, uint8_t const* const last)
void RawResponse::AddHeader(uint8_t const* const begin, uint8_t const* const last)
{
// get name and value from header
auto start = begin;
@ -43,20 +43,20 @@ void Response::AddHeader(uint8_t const* const begin, uint8_t const* const last)
AddHeader(headerName, headerValue);
}
void Response::AddHeader(std::string const& header)
void RawResponse::AddHeader(std::string const& header)
{
return AddHeader(
reinterpret_cast<uint8_t const*>(header.data()),
reinterpret_cast<uint8_t const*>(header.data() + header.size()));
}
void Response::AddHeader(std::string const& name, std::string const& value)
void RawResponse::AddHeader(std::string const& name, std::string const& value)
{
this->m_headers.insert(std::pair<std::string, std::string>(name, value));
}
void Response::SetBodyStream(std::unique_ptr<BodyStream> stream)
void RawResponse::SetBodyStream(std::unique_ptr<BodyStream> stream)
{
this->m_bodyStream = std::move(stream);
}

6
sdk/core/azure-core/src/http/retry_policy.cpp
View File

@ -14,7 +14,7 @@ namespace {
typedef decltype(RetryOptions::RetryDelay) Delay;
typedef decltype(RetryOptions::MaxRetries) RetryNumber;
bool GetResponseHeaderBasedDelay(Response const& response, Delay& retryAfter)
bool GetResponseHeaderBasedDelay(RawResponse const& response, Delay& retryAfter)
{
// Try to find retry-after headers. There are several of them possible.
auto const& responseHeaders = response.GetHeaders();
@ -93,7 +93,7 @@ bool ShouldRetryOnTransportFailure(
}
bool ShouldRetryOnResponse(
Response const& response,
RawResponse const& response,
RetryOptions const& retryOptions,
RetryNumber attempt,
Delay& retryAfter)
@ -121,7 +121,7 @@ bool ShouldRetryOnResponse(
}
} // namespace
std::unique_ptr<Response> RetryPolicy::Send(
std::unique_ptr<RawResponse> RetryPolicy::Send(
Context& ctx,
Request& request,
NextHttpPolicy nextHttpPolicy) const

2
sdk/core/azure-core/src/http/winhttp/win_http_transport.cpp
View File

@ -17,7 +17,7 @@ WinHttpTansport::WinHttpTansport() :
WinHttpTansport::~WinHttpTansport() {}
std::unique_ptr<Response> WinHttpTansport::Send(Context& context, Request& request)
std::unique_ptr<RawResponse> WinHttpTansport::Send(Context& context, Request& request)
{
AZURE_UNREFERENCED_PARAMETER(context);
AZURE_UNREFERENCED_PARAMETER(request);

4
sdk/core/azure-core/test/e2e/azure_core_with_curl_bodyBuffer.cpp
View File

@ -35,7 +35,7 @@ void doPutRequest(Context context, HttpPipeline& pipeline);
void doHeadRequest(Context context, HttpPipeline& pipeline);
void doDeleteRequest(Context context, HttpPipeline& pipeline);
void doPatchRequest(Context context, HttpPipeline& pipeline);
void printRespose(std::unique_ptr<Http::Response> response);
void printRespose(std::unique_ptr<Http::RawResponse> response);
void doFileRequest(Context context, HttpPipeline& pipeline);
int main()
@ -174,7 +174,7 @@ void doPutRequest(Context context, HttpPipeline& pipeline)
printRespose(std::move(pipeline.Send(context, request)));
}
void printRespose(std::unique_ptr<Http::Response> response)
void printRespose(std::unique_ptr<Http::RawResponse> response)
{
if (response == nullptr)
{

6
sdk/core/azure-core/test/e2e/azure_core_with_curl_bodyStream.cpp
View File

@ -32,7 +32,7 @@ void doGetRequest(Context context, HttpPipeline& pipeline);
void doNoPathGetRequest(Context context, HttpPipeline& pipeline);
void doPutRequest(Context context, HttpPipeline& pipeline);
void doPutStreamRequest(Context context, HttpPipeline& pipeline);
void printStream(Azure::Core::Context& context, std::unique_ptr<Http::Response> response);
void printStream(Azure::Core::Context& context, std::unique_ptr<Http::RawResponse> response);
int main()
{
@ -53,7 +53,7 @@ int main()
auto httpPipeline = Http::HttpPipeline(policies);
std::unique_ptr<Http::Response> response;
std::unique_ptr<Http::RawResponse> response;
auto context = Context();
doGetRequest(context, httpPipeline);
@ -162,7 +162,7 @@ void doPutStreamRequest(Context context, HttpPipeline& pipeline)
printStream(context, std::move(pipeline.Send(context, request)));
}
void printStream(Context& context, std::unique_ptr<Http::Response> response)
void printStream(Context& context, std::unique_ptr<Http::RawResponse> response)
{
if (response == nullptr)
{

28
sdk/core/azure-core/test/ut/transport_adapter.cpp
View File

@ -2,6 +2,7 @@
// SPDX-License-Identifier: MIT
#include "transport_adapter.hpp"
#include <response.hpp>
#include <string>
namespace Azure { namespace Core { namespace Test {
@ -52,7 +53,7 @@ namespace Azure { namespace Core { namespace Test {
auto expectedResponseBodySize = std::stoull(response->GetHeaders().at("content-length"));
CheckBodyStreamLength(*body, expectedResponseBodySize);
// Add a header and send again. Response should return that header in the body
// Add a header and send again. RawResponse should return that header in the body
request.AddHeader("123", "456");
response = pipeline.Send(context, request);
EXPECT_TRUE(response->GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok);
@ -163,4 +164,29 @@ namespace Azure { namespace Core { namespace Test {
CheckBodyStreamLength(*body, expectedResponseBodySize, expectedChunkResponse);
}
TEST_F(TransportAdapter, createResponseT)
{
std::string host("http://httpbin.org/get");
std::string expectedType("This is the Response Type");
auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, host);
auto response = pipeline.Send(context, request);
Azure::Core::Response<std::string> responseT(expectedType, std::move(response));
auto& r = responseT.GetRawResponse();
EXPECT_TRUE(r.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok);
auto body = r.GetBodyStream();
auto expectedResponseBodySize = std::stoull(r.GetHeaders().at("content-length"));
CheckBodyStreamLength(*body, expectedResponseBodySize);
// Direct access
EXPECT_STREQ((*responseT).data(), expectedType.data());
EXPECT_STREQ(responseT->data(), expectedType.data());
// extracting T out of response
EXPECT_STREQ(responseT.ExtractValue().data(), expectedType.data());
// Test that calling getValue again will return empty
EXPECT_STREQ(responseT.ExtractValue().data(), std::string("").data());
}
}}} // namespace Azure::Core::Test

132
sdk/storage/inc/blobs/internal/protocol/blob_rest_client.hpp
View File

@ -1147,10 +1147,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static ListContainersSegment ListBlobContainersParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
ListContainersSegment response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -1239,10 +1239,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static UserDelegationKey GetUserDelegationKeyParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
UserDelegationKey response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -1765,10 +1765,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobContainerInfo CreateParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobContainerInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -1842,10 +1842,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static DeleteContainerResponse DeleteParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
DeleteContainerResponse response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -1922,10 +1922,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobContainerProperties GetPropertiesParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobContainerProperties response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -2036,10 +2036,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static SetContainerMetadataResponse SetMetadataParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
SetContainerMetadataResponse response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -2120,10 +2120,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobsFlatSegment ListBlobsFlatParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobsFlatSegment response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -2223,10 +2223,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobsHierarchySegment ListBlobsByHierarchyParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobsHierarchySegment response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -2959,10 +2959,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobDownloadResponse DownloadParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobDownloadResponse response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -3155,10 +3155,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static DeleteBlobResponse DeleteParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
DeleteBlobResponse response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -3216,10 +3216,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static UndeleteBlobResponse UndeleteParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
UndeleteBlobResponse response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -3300,10 +3300,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobProperties GetPropertiesParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobProperties response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -3567,10 +3567,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static SetBlobHttpHeadersResponse SetHttpHeadersParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
SetBlobHttpHeadersResponse response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -3691,10 +3691,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static SetBlobMetadataResponse SetMetadataParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
SetBlobMetadataResponse response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -3763,10 +3763,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static SetAccessTierResponse SetAccessTierParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
SetAccessTierResponse response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -3904,10 +3904,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobCopyInfo StartCopyFromUriParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobCopyInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -3978,10 +3978,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static AbortCopyBlobResponse AbortCopyFromUriParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
AbortCopyBlobResponse response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -4094,10 +4094,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobSnapshotInfo CreateSnapshotParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobSnapshotInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -4271,10 +4271,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobContentInfo UploadParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobContentInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -4390,10 +4390,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlockInfo StageBlockParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlockInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -4547,10 +4547,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlockInfo StageBlockFromUriParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlockInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -4729,10 +4729,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobContentInfo CommitBlockListParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobContentInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -4815,10 +4815,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobBlockListInfo GetBlockListParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobBlockListInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -5141,10 +5141,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobContentInfo CreateParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobContentInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -5303,10 +5303,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static PageInfo UploadPagesParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
PageInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -5476,10 +5476,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static PageInfo UploadPagesFromUriParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
PageInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -5630,10 +5630,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static PageInfo ClearPagesParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
PageInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -5770,10 +5770,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static PageBlobInfo ResizeParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
PageBlobInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -5885,10 +5885,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static PageRangesInfoInternal GetPageRangesParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
PageRangesInfoInternal response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -5988,10 +5988,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobCopyInfo CopyIncrementalParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobCopyInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -6304,10 +6304,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobContentInfo CreateParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobContentInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -6451,10 +6451,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobAppendInfo AppendBlockParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobAppendInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(
@ -6621,10 +6621,10 @@ namespace Azure { namespace Storage { namespace Blobs {
static BlobAppendInfo AppendBlockFromUriParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::Response> pHttpResponse)
std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
{
unused(context);
Azure::Core::Http::Response& httpResponse = *pHttpResponse;
Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
BlobAppendInfo response;
auto http_status_code
= static_cast<std::underlying_type<Azure::Core::Http::HttpStatusCode>::type>(

2
sdk/storage/inc/common/common_headers_request_policy.hpp
View File

@ -14,7 +14,7 @@ namespace Azure { namespace Storage {
HttpPolicy* Clone() const override { return new CommonHeadersRequestPolicy(*this); }
std::unique_ptr<Core::Http::Response> Send(
std::unique_ptr<Core::Http::RawResponse> Send(
Core::Context& ctx,
Core::Http::Request& request,
Core::Http::NextHttpPolicy nextHttpPolicy) const override;

2
sdk/storage/inc/common/shared_key_policy.hpp
View File

@ -19,7 +19,7 @@ namespace Azure { namespace Storage {
HttpPolicy* Clone() const override { return new SharedKeyPolicy(m_credential); }
std::unique_ptr<Core::Http::Response> Send(
std::unique_ptr<Core::Http::RawResponse> Send(
Core::Context& ctx,
Core::Http::Request& request,
Core::Http::NextHttpPolicy nextHttpPolicy) const override

4
sdk/storage/inc/common/storage_error.hpp
View File

@ -21,9 +21,9 @@ namespace Azure { namespace Storage {
std::string RequestId;
std::string ErrorCode;
std::string Message;
std::unique_ptr<Azure::Core::Http::Response> RawResponse;
std::unique_ptr<Azure::Core::Http::RawResponse> RawResponse;
static StorageError CreateFromResponse(
/* const */ std::unique_ptr<Azure::Core::Http::Response> response);
/* const */ std::unique_ptr<Azure::Core::Http::RawResponse> response);
};
}} // namespace Azure::Storage

2
sdk/storage/inc/common/token_credential_policy.hpp
View File

@ -19,7 +19,7 @@ namespace Azure { namespace Storage {
HttpPolicy* Clone() const override { return new TokenCredentialPolicy(m_credential); }
std::unique_ptr<Core::Http::Response> Send(
std::unique_ptr<Core::Http::RawResponse> Send(
Core::Context& ctx,
Core::Http::Request& request,
Core::Http::NextHttpPolicy nextHttpPolicy) const override

32
sdk/storage/inc/datalake/protocol/datalake_rest_client.hpp
View File

@ -914,7 +914,7 @@ namespace Azure { namespace Storage { namespace DataLake {
private:
static ServiceListFileSystemsResponse ListFileSystemsParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -1245,7 +1245,7 @@ namespace Azure { namespace Storage { namespace DataLake {
private:
static FileSystemCreateResponse CreateParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
@ -1267,7 +1267,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static FileSystemSetPropertiesResponse SetPropertiesParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -1288,7 +1288,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static FileSystemGetPropertiesResponse GetPropertiesParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -1311,7 +1311,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static FileSystemDeleteResponse DeleteParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Accepted)
@ -1330,7 +1330,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static FileSystemListPathsResponse ListPathsParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -2700,7 +2700,7 @@ namespace Azure { namespace Storage { namespace DataLake {
private:
static PathCreateResponse CreateParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
@ -2739,7 +2739,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static PathUpdateResponse UpdateParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -2831,7 +2831,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static PathLeaseResponse LeaseParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -2884,7 +2884,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static PathReadResponse ReadParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -3033,7 +3033,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static PathGetPropertiesResponse GetPropertiesParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -3130,7 +3130,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static PathDeleteResponse DeleteParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -3154,7 +3154,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static PathSetAccessControlResponse SetAccessControlParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -3180,7 +3180,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static PathSetAccessControlRecursiveResponse SetAccessControlRecursiveParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -3217,7 +3217,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static PathFlushDataResponse FlushDataParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
@ -3249,7 +3249,7 @@ namespace Azure { namespace Storage { namespace DataLake {
}
static PathAppendDataResponse AppendDataParseResponse(
std::unique_ptr<Azure::Core::Http::Response> responsePtr)
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Accepted)

2
sdk/storage/src/common/common_headers_request_policy.cpp
View File

@ -7,7 +7,7 @@
namespace Azure { namespace Storage {
std::unique_ptr<Core::Http::Response> CommonHeadersRequestPolicy::Send(
std::unique_ptr<Core::Http::RawResponse> CommonHeadersRequestPolicy::Send(
Core::Context& ctx,
Core::Http::Request& request,
Core::Http::NextHttpPolicy nextHttpPolicy) const

2
sdk/storage/src/common/storage_error.cpp
View File

@ -10,7 +10,7 @@
namespace Azure { namespace Storage {
StorageError StorageError::CreateFromResponse(
std::unique_ptr<Azure::Core::Http::Response> response)
std::unique_ptr<Azure::Core::Http::RawResponse> response)
{
auto bodyStream = response->GetBodyStream();
std::vector<uint8_t> bodyBuffer;