uvco::CurlRequestCore_ Class Reference

Used as awaiter by Curl::download. More...

Public Member Functions
	CurlRequestCore_ (const CurlRequestCore_ &)=delete
	CurlRequestCore_ (CurlRequestCore_ &&)=delete
CurlRequestCore_ &	operator= (const CurlRequestCore_ &)=delete
CurlRequestCore_ &	operator= (CurlRequestCore_ &&)=delete
	CurlRequestCore_ (std::weak_ptr< UvCurlContext_ > ctx)
	CurlRequestCore_ (std::weak_ptr< UvCurlContext_ > ctx, std::string url)
	Construct and initialize download.
	~CurlRequestCore_ ()
void	initCommon (std::string url)
void	initGet (std::string url)
void	initPost (std::string url, std::span< const std::pair< std::string, std::string > > fields)
std::string_view	url () const noexcept
	Get the URL of the request.
void	onDataAvailable (char *data, size_t size)
	Called when data is available. Resumes the downloader coroutine.
void	onError (uv_status status) noexcept
bool	await_ready () const noexcept
bool	await_suspend (std::coroutine_handle<> handle) noexcept
	Awaiter protocol: suspend the downloader coroutine.
std::optional< std::string >	await_resume ()
	Awaiter protocol: yield the next chunk or signal end of stream.
void	setUvStatus (uv_status status) noexcept
	Set socket error status.
void	setResponseCode (long status) noexcept
	Set HTTP response code.
void	setVerifyResult (long result) noexcept
	Set SSL verification result.
void	setCurlStatus (CURLcode status) noexcept
	Set Curl error code.
std::optional< uv_status >	uvStatus () const noexcept
	Get uv error status. 0 if success.
std::optional< long >	responseCode () const noexcept
	Get HTTP response code. 0 if not set.
std::optional< long >	verifyResult () const noexcept
	Get SSL verification result. 0 means success, > 0 means failure.
std::optional< CURLcode >	curlStatus () const noexcept
	Get Curl error code once the request has finished.

Static Private Member Functions
static size_t	onCurlDataAvailable (char *data, size_t size, size_t nmemb, void *userp)

Private Attributes
std::weak_ptr< UvCurlContext_ >	context_
CURL *	easyHandle_
std::string	url_
std::optional< std::string >	payload_
std::optional< std::coroutine_handle<> >	downloaderHandle_
std::vector< std::string >	chunks_
std::optional< uv_status >	uvStatus_
std::optional< CURLcode >	curlStatus_
std::optional< long >	responseCode_
std::optional< long >	verifyResult_

Friends
class	CurlRequest

Detailed Description

Used as awaiter by Curl::download.

Constructor & Destructor Documentation

CurlRequestCore_() [1/4]

uvco::CurlRequestCore_::CurlRequestCore_ ( const CurlRequestCore_ &  )

delete

CurlRequestCore_() [2/4]

uvco::CurlRequestCore_::CurlRequestCore_ ( CurlRequestCore_ &&  )

delete

CurlRequestCore_() [3/4]

uvco::CurlRequestCore_::CurlRequestCore_ ( std::weak_ptr< UvCurlContext_ >  ctx )

inlineexplicit

      : context_{std::move(ctx)}, easyHandle_{curl_easy_init()} {}

CurlRequestCore_() [4/4]

uvco::CurlRequestCore_::CurlRequestCore_ ( std::weak_ptr< UvCurlContext_ >  ctx, std::string  url  )

inline

Construct and initialize download.

      : context_{std::move(ctx)}, easyHandle_(curl_easy_init()) {
    initGet(std::move(url));
  }

~CurlRequestCore_()

uvco::CurlRequestCore_::~CurlRequestCore_ ( )

inline

                      {
    curl_easy_cleanup(easyHandle_);
    if (!context_.expired()) {
      context_.lock()->removeHandle(easyHandle_);
    }
    easyHandle_ = nullptr;
  }

Member Function Documentation

await_ready()

bool uvco::CurlRequestCore_::await_ready ( ) const

inlinenoexcept

Awaiter protocol: ready if there are chunks to yield or the download is done.

                                                  {
    BOOST_ASSERT_MSG(!context_.expired(),
                     "Curl object must outlive any request");
    // Before checking response code, ensure that it's up-to-date.
    context_.lock()->checkCurlInfo();
    return !chunks_.empty() || responseCode_ > 0;
  }

await_resume()

std::optional< std::string > uvco::CurlRequestCore_::await_resume ( )

inline

Awaiter protocol: yield the next chunk or signal end of stream.

                                        {
    if (uvStatus_ && *uvStatus_ != 0) {
      return std::nullopt;
    }
    if (verifyResult_ && *verifyResult_ != 0) {
      // SSL verification to be checked by downloader.
      return std::nullopt;
    }
    if (responseCode_ && *responseCode_ != 200) {
      // HTTP Status to be checked by downloader.
      return std::nullopt;
    }
    if (!chunks_.empty()) {
      std::string thisResult = std::move(chunks_.front());
      chunks_.erase(chunks_.begin());
      return std::move(thisResult);
    }
 
    // Signal end of stream.
    return std::nullopt;
  }

await_suspend()

bool uvco::CurlRequestCore_::await_suspend ( std::coroutine_handle<>  handle )

inlinenoexcept

Awaiter protocol: suspend the downloader coroutine.

                                                            {
    BOOST_ASSERT(!downloaderHandle_);
    downloaderHandle_ = handle;
    return true;
  }

curlStatus()

std::optional< CURLcode > uvco::CurlRequestCore_::curlStatus ( ) const

inlinenoexcept

Get Curl error code once the request has finished.

                                                                  {
    return curlStatus_;
  }

initCommon()

void uvco::CurlRequestCore_::initCommon ( std::string  url )

inline

                                 {
    BOOST_ASSERT(easyHandle_ != nullptr);
    BOOST_ASSERT_MSG(url_.empty(), "cannot work with empty URL");
    BOOST_ASSERT_MSG(!context_.expired(),
                     "Curl object must outlive any request");
 
    url_ = std::move(url);
    // Configure easy handle and initiate download.
    curl_easy_setopt(easyHandle_, CURLOPT_URL, url_.data());
    curl_easy_setopt(easyHandle_, CURLOPT_WRITEFUNCTION, onCurlDataAvailable);
    // Set Write Data for use in onCurlDataAvailable.
    curl_easy_setopt(easyHandle_, CURLOPT_WRITEDATA, this);
    // Set private data for use in curlSocketFunction.
    curl_easy_setopt(easyHandle_, CURLOPT_PRIVATE, this);
    curl_easy_setopt(easyHandle_, CURLOPT_FOLLOWLOCATION, 1L);
  }

initGet()

void uvco::CurlRequestCore_::initGet ( std::string  url )

inline

                              {
    initCommon(std::move(url));
    context_.lock()->addHandle(easyHandle_);
  }

initPost()

void uvco::CurlRequestCore_::initPost ( std::string  url, std::span< const std::pair< std::string, std::string > >  fields  )

inline

                                                                     {
    initCommon(std::move(url));
    BOOST_ASSERT(!payload_);
 
    // Must keep payload alive until request is done.
    payload_ = formattedFields(easyHandle_, fields);
    curl_easy_setopt(easyHandle_, CURLOPT_POST, 1L);
    curl_easy_setopt(easyHandle_, CURLOPT_POSTFIELDS, payload_->c_str());
    context_.lock()->addHandle(easyHandle_);
  }

onCurlDataAvailable()

size_t uvco::CurlRequestCore_::onCurlDataAvailable ( char *  data, size_t  size, size_t  nmemb, void *  userp  )

staticprivate

                                                                        {
  auto *request = static_cast<CurlRequestCore_ *>(userp);
  request->onDataAvailable(data, size * nmemb);
  return nmemb;
}

onDataAvailable()

void uvco::CurlRequestCore_::onDataAvailable ( char *  data, size_t  size  )

inline

Called when data is available. Resumes the downloader coroutine.

                                                {
    BOOST_ASSERT(data != nullptr);
    chunks_.emplace_back(data, size);
    if (downloaderHandle_) {
      auto handle = downloaderHandle_.value();
      downloaderHandle_.reset();
      Loop::enqueue(handle);
    }
  }

onError()

void uvco::CurlRequestCore_::onError ( uv_status  status )

inlinenoexcept

Called when an error occurs, but also upon completion (then status == 0).

Resumes the downloader coroutine.

                                          {
    if (downloaderHandle_) {
      auto handle = downloaderHandle_.value();
      setUvStatus(status);
      downloaderHandle_.reset();
      Loop::enqueue(handle);
    }
  }

operator=() [1/2]

CurlRequestCore_ & uvco::CurlRequestCore_::operator= ( const CurlRequestCore_ &  )

delete

operator=() [2/2]

CurlRequestCore_ & uvco::CurlRequestCore_::operator= ( CurlRequestCore_ &&  )

delete

responseCode()

std::optional< long > uvco::CurlRequestCore_::responseCode ( ) const

inlinenoexcept

Get HTTP response code. 0 if not set.

                                                                {
    return responseCode_;
  }

setCurlStatus()

void uvco::CurlRequestCore_::setCurlStatus ( CURLcode  status )

inlinenoexcept

Set Curl error code.

                                               {
    if (!curlStatus_) {
      curlStatus_ = status;
    }
  }

setResponseCode()

void uvco::CurlRequestCore_::setResponseCode ( long  status )

inlinenoexcept

Set HTTP response code.

                                             {
    if (!responseCode_) {
      responseCode_ = status;
    }
  }

setUvStatus()

void uvco::CurlRequestCore_::setUvStatus ( uv_status  status )

inlinenoexcept

Set socket error status.

                                              {
    if (!uvStatus_) {
      uvStatus_ = status;
    }
  }

setVerifyResult()

void uvco::CurlRequestCore_::setVerifyResult ( long  result )

inlinenoexcept

Set SSL verification result.

                                             {
    if (!verifyResult_) {
      verifyResult_ = result;
    }
  }

url()

std::string_view uvco::CurlRequestCore_::url ( ) const

inlinenoexcept

Get the URL of the request.

{ return url_; }

uvStatus()

std::optional< uv_status > uvco::CurlRequestCore_::uvStatus ( ) const

inlinenoexcept

Get uv error status. 0 if success.

                                                                 {
    return uvStatus_;
  }

verifyResult()

std::optional< long > uvco::CurlRequestCore_::verifyResult ( ) const

inlinenoexcept

Get SSL verification result. 0 means success, > 0 means failure.

                                                                {
    return verifyResult_;
  }

Friends And Related Symbol Documentation

CurlRequest

friend class CurlRequest

friend

Member Data Documentation

chunks_

std::vector<std::string> uvco::CurlRequestCore_::chunks_

private

context_

std::weak_ptr<UvCurlContext_> uvco::CurlRequestCore_::context_

private

curlStatus_

std::optional<CURLcode> uvco::CurlRequestCore_::curlStatus_

private

downloaderHandle_

std::optional<std::coroutine_handle<> > uvco::CurlRequestCore_::downloaderHandle_

private

easyHandle_

CURL* uvco::CurlRequestCore_::easyHandle_

private

payload_

std::optional<std::string> uvco::CurlRequestCore_::payload_

private

responseCode_

std::optional<long> uvco::CurlRequestCore_::responseCode_

private

url_

std::string uvco::CurlRequestCore_::url_

private

uvStatus_

std::optional<uv_status> uvco::CurlRequestCore_::uvStatus_

private

verifyResult_

std::optional<long> uvco::CurlRequestCore_::verifyResult_

private

---

The documentation for this class was generated from the following file:

• uvco/integrations/curl/curl.cc