std::shared_ptr IXmlHttpRequest2HttpClient::MakeRequest()

in src/aws-cpp-sdk-core/source/http/windows/IXmlHttpRequest2HttpClient.cpp [341:434]
80 lines of code
9 McCabe index (conditional complexity)

        std::shared_ptr<HttpResponse> IXmlHttpRequest2HttpClient::MakeRequest(const std::shared_ptr<HttpRequest>& request,
                                        Aws::Utils::RateLimits::RateLimiterInterface* readLimiter,
                                        Aws::Utils::RateLimits::RateLimiterInterface* writeLimiter) const
        {
            auto uri = request->GetUri();
            auto fullUriString = uri.GetURIString();
            AWS_LOGSTREAM_DEBUG(CLASS_TAG, "Making " << HttpMethodMapper::GetNameForHttpMethod(request->GetMethod())
                        << " request to url: " << fullUriString);

            auto url = Aws::Utils::StringUtils::ToWString(fullUriString.c_str());
            auto methodStr = Aws::Utils::StringUtils::ToWString(HttpMethodMapper::GetNameForHttpMethod(request->GetMethod()));
            auto proxyUserNameStr = Aws::Utils::StringUtils::ToWString(m_proxyUserName.c_str());
            auto proxyPasswordStr = Aws::Utils::StringUtils::ToWString(m_proxyPassword.c_str());

            auto requestHandle = m_resourceManager.Acquire();

            auto response = Aws::MakeShared<Standard::StandardHttpResponse>(CLASS_TAG, request);
            ComPtr<IXmlHttpRequest2HttpClientCallbacks> callbacks = Make<IXmlHttpRequest2HttpClientCallbacks>(*response, m_followRedirects);

            HRESULT hrResult = requestHandle->Open(methodStr.c_str(), url.c_str(), callbacks.Get(), nullptr, nullptr, proxyUserNameStr.c_str(), proxyPasswordStr.c_str());
            FillClientSettings(requestHandle);

            if (FAILED(hrResult))
            {
                Aws::StringStream ss;
                ss << "Error opening http request with status code " << hrResult;
                AWS_LOGSTREAM_ERROR(CLASS_TAG, ss.str());
                AWS_LOGSTREAM_DEBUG(CLASS_TAG, "The http request is: " << uri.GetURIString());
                response->SetClientErrorType(Aws::Client::CoreErrors::NETWORK_CONNECTION);
                response->SetClientErrorMessage(ss.str());
                ReturnHandleToResourceManager();
                return response;
            }

            AWS_LOGSTREAM_TRACE(CLASS_TAG, "Setting http headers:");
            for (auto& header : request->GetHeaders())
            {
                AWS_LOGSTREAM_TRACE(CLASS_TAG, header.first << ": " << header.second);
                hrResult = requestHandle->SetRequestHeader(Aws::Utils::StringUtils::ToWString(header.first.c_str()).c_str(),
                                                                Aws::Utils::StringUtils::ToWString(header.second.c_str()).c_str());

                if (FAILED(hrResult))
                {
                    Aws::StringStream ss;
                    ss << "Error setting http header " << header.first << " With status code: " << hrResult;
                    AWS_LOGSTREAM_ERROR(CLASS_TAG, ss.str());
                    AWS_LOGSTREAM_DEBUG(CLASS_TAG, "Corresponding header's value is: " << header.second);
                    response->SetClientErrorType(Aws::Client::CoreErrors::NETWORK_CONNECTION);
                    response->SetClientErrorMessage(ss.str());
                    ReturnHandleToResourceManager();
                    return response;
                }
            }

            OverrideOptionsOnRequestHandle(requestHandle);

            if (writeLimiter)
            {
                writeLimiter->ApplyAndPayForCost(request->GetSize());
            }

            ComPtr<IOStreamSequentialStream> responseStream = Make<IOStreamSequentialStream>(response->GetResponseBody(), *this, *request,
                            requestHandle, response.get(), writeLimiter);

            requestHandle->SetCustomResponseStream(responseStream.Get());

            ComPtr<IOStreamSequentialStream> requestStream(nullptr);
            ULONGLONG streamLength(0);

            if (request->GetContentBody() && !request->GetContentLength().empty())
            {
                AWS_LOGSTREAM_TRACE(CLASS_TAG, "Content detected, setting request stream.");
                requestStream = Make<IOStreamSequentialStream>(*request->GetContentBody(), *this, *request, requestHandle, nullptr, readLimiter);
                streamLength = static_cast<ULONGLONG>(Aws::Utils::StringUtils::ConvertToInt64(request->GetContentLength().c_str()));
            }

            hrResult = requestHandle->Send(requestStream.Get(), streamLength);
            callbacks->WaitUntilFinished();
            if (FAILED(hrResult) || response->GetResponseCode() == Http::HttpResponseCode::REQUEST_NOT_MADE)
            {
                Aws::StringStream ss;
                ss << "Request finished with response code: " << static_cast<int>(response->GetResponseCode());
                AWS_LOGSTREAM_ERROR(CLASS_TAG, ss.str());
                response->SetClientErrorType(Aws::Client::CoreErrors::NETWORK_CONNECTION);
                response->SetClientErrorMessage(ss.str());
            }
            else
            {
                response->GetResponseBody().flush();
                AWS_LOGSTREAM_DEBUG(CLASS_TAG, "Request finished with response code: " << static_cast<int>(response->GetResponseCode()));
            }
            ReturnHandleToResourceManager();
            return response;
        }