audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation Struct Reference

Inheritance diagram for audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation:

Collaboration diagram for audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation:

Public Types
using	Clock = std::chrono::steady_clock

Public Member Functions
	AudiocomUploadOperation (const ServiceConfig &serviceConfig, wxString fileName, wxString projectName, bool isPublic, UploadService::CompletedCallback completedCallback, UploadService::ProgressCallback progressCallback)
void	SetRequiredHeaders (audacity::network_manager::Request &request) const
void	FailPromise (UploadOperationCompleted::Result result, std::string errorMessage)
void	CompletePromise ()
void	InitiateUpload (std::string_view authToken)
void	HandleUploadPolicy (std::string uploadPolicyJSON)
void	HandleUploadProgress (uint64_t current, uint64_t total)
void	HandleS3UploadCompleted (std::shared_ptr< audacity::network_manager::IResponse > response)
bool	IsCompleted () override
	Returns true if the upload is finished. More...
void	Abort () override
	Abort the upload, if running. More...
void	DiscardResult () override
Public Member Functions inherited from audacity::cloud::audiocom::UploadOperation
virtual	~UploadOperation ()
virtual bool	IsCompleted ()=0
	Returns true if the upload is finished. More...
virtual void	Abort ()=0
	Abort the upload, if running. More...
virtual void	DiscardResult ()=0

Public Attributes
const ServiceConfig &	mServiceConfig
const wxString	mFileName
const wxString	mProjectName
const bool	mIsPublic
UploadService::CompletedCallback	mCompletedCallback
UploadService::ProgressCallback	mProgressCallback
std::string	mAuthToken
std::string	mSuccessUrl
std::string	mFailureUrl
std::string	mProgressUrl
std::string	mAudioID
std::string	mUploadToken
std::string	mUserName
std::string	mAudioSlug
Clock::time_point	mLastProgressReportTime
std::mutex	mStatusMutex
std::mutex	mCallbacksMutex
std::weak_ptr< audacity::network_manager::IResponse >	mActiveResponse
bool	mCompleted {}
bool	mAborted {}

Detailed Description

Definition at line 173 of file UploadService.cpp.

Member Typedef Documentation

Clock

using audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::Clock = std::chrono::steady_clock

Definition at line 213 of file UploadService.cpp.

Constructor & Destructor Documentation

AudiocomUploadOperation()

audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::AudiocomUploadOperation ( const ServiceConfig &  serviceConfig, wxString  fileName, wxString  projectName, bool  isPublic, UploadService::CompletedCallback  completedCallback, UploadService::ProgressCallback  progressCallback  )

inline

Definition at line 177 of file UploadService.cpp.

       : mServiceConfig(serviceConfig)
       , mFileName(std::move(fileName))
       , mProjectName(std::move(projectName))
       , mIsPublic(isPublic)
       , mCompletedCallback(std::move(completedCallback))
       , mProgressCallback(std::move(progressCallback))
   {
   }

Member Function Documentation

Abort()

void audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::Abort ( )

inlineoverridevirtual

Abort the upload, if running.

Implements audacity::cloud::audiocom::UploadOperation.

Definition at line 521 of file UploadService.cpp.

   {
      {
         std::lock_guard<std::mutex> lock(mStatusMutex);
 
         if (mCompleted)
            return;
 
         mCompleted = true;
         mAborted = true;
 
         if (auto activeResponse = mActiveResponse.lock())
            activeResponse->abort();
      }
 
      std::lock_guard<std::mutex> callbacksLock(mCallbacksMutex);
 
      if (mCompletedCallback)
         mCompletedCallback({ UploadOperationCompleted::Result::Aborted });
 
      mCompletedCallback = {};
      mProgressCallback = {};
  }

References audacity::cloud::audiocom::UploadOperationCompleted::Aborted.

CompletePromise()

void audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::CompletePromise ( )

inline

Definition at line 257 of file UploadService.cpp.

   {
      {
         std::lock_guard<std::mutex> lock(mStatusMutex);
         mCompleted = true;
      }
 
      std::lock_guard<std::mutex> callbacksLock(mCallbacksMutex);
 
      if (mCompletedCallback)
      {
         const auto uploadURL =
            mAuthToken.empty() ?
               mServiceConfig.GetFinishUploadPage(mAudioID, mUploadToken) :
               mServiceConfig.GetAudioURL(mUserName, mAudioSlug);
 
         mCompletedCallback(
            { UploadOperationCompleted::Result::Success,
              UploadSuccessfulPayload { mAudioID, mAudioSlug, mUploadToken, uploadURL } });
      }
 
      mProgressCallback = {};
      mCompletedCallback = {};
   }

References audacity::cloud::audiocom::ServiceConfig::GetAudioURL(), audacity::cloud::audiocom::ServiceConfig::GetFinishUploadPage(), and audacity::cloud::audiocom::UploadOperationCompleted::Success.

Here is the call graph for this function:

DiscardResult()

void audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::DiscardResult ( )

inlineoverridevirtual

Abort the upload, if running, notify audio.com that the uploaded file is no longer needed otherwise

Implements audacity::cloud::audiocom::UploadOperation.

Definition at line 546 of file UploadService.cpp.

   {
      using namespace audacity::network_manager;
 
      Abort();
 
      auto url = mServiceConfig.GetAPIUrl("/audio");
      url += "/" + mAudioID + "?token=" + mUploadToken;
 
      Request request(url);
      auto response = NetworkManager::GetInstance().doDelete(request);
 
      response->setRequestFinishedCallback(
         [response](auto)
         {
            // Do nothing
         });
   }

References audacity::network_manager::NetworkManager::doDelete(), audacity::cloud::audiocom::ServiceConfig::GetAPIUrl(), and audacity::network_manager::NetworkManager::GetInstance().

Here is the call graph for this function:

FailPromise()

void audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::FailPromise ( UploadOperationCompleted::Result  result, std::string  errorMessage  )

inline

Definition at line 238 of file UploadService.cpp.

   {
      {
         std::lock_guard<std::mutex> lock(mStatusMutex);
         mCompleted = true;
      }
 
      std::lock_guard<std::mutex> callbacksLock(mCallbacksMutex);
 
      if (mCompletedCallback)
      {
         mCompletedCallback(
            UploadOperationCompleted { result, ParseUploadFailedMessage(errorMessage) });
      }
 
      mProgressCallback = {};
      mCompletedCallback = {};
   }

References audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::ParseUploadFailedMessage().

Here is the call graph for this function:

HandleS3UploadCompleted()

void audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::HandleS3UploadCompleted ( std::shared_ptr< audacity::network_manager::IResponse >  response )

inline

Definition at line 477 of file UploadService.cpp.

   {
      using namespace audacity::network_manager;
 
      const auto responseCode = response->getHTTPCode();
 
      const bool success =
         responseCode == 200 || responseCode == 201 || responseCode == 204;
 
      Request request(success ? mSuccessUrl : mFailureUrl);
      SetRequiredHeaders(request);
 
      std::lock_guard<std::mutex> lock(mStatusMutex);
 
      if (mAborted)
         return;
 
      auto finalResponse = success ? NetworkManager::GetInstance().doPost(request, nullptr, 0) :
                                NetworkManager::GetInstance().doDelete(request);
 
      mActiveResponse = finalResponse;
 
      finalResponse->setRequestFinishedCallback(
         [finalResponse, sharedThis = shared_from_this(), this, success](auto)
         {
            const auto httpCode = finalResponse->getHTTPCode();
            if (success && httpCode >= 200 && httpCode < 300)
            {
               CompletePromise();
               return;
            }
 
            FailPromise(
               UploadOperationCompleted::Result::UploadFailed,
               finalResponse->readAll<std::string>());
         });
   }

References audacity::network_manager::NetworkManager::doDelete(), audacity::network_manager::NetworkManager::doPost(), audacity::network_manager::NetworkManager::GetInstance(), and audacity::cloud::audiocom::UploadOperationCompleted::UploadFailed.

Here is the call graph for this function:

HandleUploadPolicy()

void audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::HandleUploadPolicy ( std::string  uploadPolicyJSON )

inline

Definition at line 339 of file UploadService.cpp.

   {
      using namespace audacity::network_manager;
 
      rapidjson::Document document;
      document.Parse(uploadPolicyJSON.data(), uploadPolicyJSON.length());
 
      if (
         !document.HasMember("url") || !document.HasMember("success") ||
         !document.HasMember("fail") || !document.HasMember("progress"))
      {
         FailPromise(
            UploadOperationCompleted::Result::UnexpectedResponse,
            uploadPolicyJSON);
 
         return;
      }
 
      auto form = std::make_unique<MultipartData>();
 
      if (document.HasMember("fields"))
      {
         const auto& fields = document["fields"];
 
         for (auto it = fields.MemberBegin(); it != fields.MemberEnd(); ++it)
            form->Add(it->name.GetString(), it->value.GetString());
      }
 
      const auto fileField =
         document.HasMember("field") ? document["field"].GetString() : "file";
 
      const wxFileName name { mFileName };
 
      try
      {
         // We have checked for the file existence on the main thread
         // already. For safety sake check for any exception thrown by AddFile
         // anyway
         form->AddFile(fileField, DeduceMimeType(name.GetExt()), name);
      }
      catch (...)
      {
         // Just fail the promise in case if any exception was thrown
         // UploadService user is responsible to display an appropriate dialog
         FailPromise(UploadOperationCompleted::Result::FileNotFound, {});
         return;
      }
 
 
      const auto url = document["url"].GetString();
 
      mSuccessUrl = document["success"].GetString();
      mFailureUrl = document["fail"].GetString();
      mProgressUrl = document["progress"].GetString();
 
      if (document.HasMember("extra"))
      {
         const auto& extra = document["extra"];
 
         mAudioID = extra["audio"]["id"].GetString();
         mAudioSlug = extra["audio"]["slug"].GetString();
 
         if (extra.HasMember("token"))
            mUploadToken = extra["token"].GetString();
 
         mUserName = extra["audio"]["username"].GetString();
      }
 
      const auto encType = document.HasMember("enctype") ?
                              document["enctype"].GetString() :
                              "multipart/form-data";
 
      Request request(url);
 
      request.setHeader(common_headers::ContentType, encType);
      request.setHeader(
         common_headers::Accept, common_content_types::ApplicationJson);
 
      // We only lock late and for very short time
      std::lock_guard<std::mutex> lock(mStatusMutex);
 
      if (mAborted)
         return;
 
      auto response =
         NetworkManager::GetInstance().doPost(request, std::move(form));
 
      mActiveResponse = response;
 
      response->setRequestFinishedCallback(
         [response, sharedThis = shared_from_this(), this](auto)
         {
            HandleS3UploadCompleted(response);
         });
 
      response->setUploadProgressCallback(
         [response, sharedThis = shared_from_this(),
          this](auto current, auto total)
         { HandleUploadProgress(current, total); });
   }

References audacity::network_manager::common_headers::Accept, audacity::network_manager::common_content_types::ApplicationJson, audacity::network_manager::common_headers::ContentType, audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::DeduceMimeType(), audacity::network_manager::NetworkManager::doPost(), audacity::cloud::audiocom::UploadOperationCompleted::FileNotFound, audacity::network_manager::NetworkManager::GetInstance(), name, audacity::network_manager::Request::setHeader(), and audacity::cloud::audiocom::UploadOperationCompleted::UnexpectedResponse.

Here is the call graph for this function:

HandleUploadProgress()

void audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::HandleUploadProgress ( uint64_t  current, uint64_t  total  )

inline

Definition at line 440 of file UploadService.cpp.

   {
      {
         std::lock_guard<std::mutex> callbacksLock(mCallbacksMutex);
 
         if (mProgressCallback)
            mProgressCallback(current, total);
      }
 
      const auto now = Clock::now();
 
      if ((now - mLastProgressReportTime) > mServiceConfig.GetProgressCallbackTimeout())
      {
         mLastProgressReportTime = now;
 
         using namespace audacity::network_manager;
         Request request(mProgressUrl);
 
         request.setHeader(
            common_headers::ContentType, common_content_types::ApplicationJson);
         request.setHeader(
            common_headers::Accept, common_content_types::ApplicationJson);
 
         auto payload = GetProgressPayload(current, total);
 
         std::lock_guard<std::mutex> lock(mStatusMutex);
 
         if (mAborted)
            return;
 
         auto response = NetworkManager::GetInstance().doPatch(
            request, payload.data(), payload.size());
 
         response->setRequestFinishedCallback([response](auto) {});
      }
   }

References audacity::network_manager::common_headers::Accept, audacity::network_manager::common_content_types::ApplicationJson, audacity::network_manager::common_headers::ContentType, audacity::network_manager::NetworkManager::doPatch(), audacity::network_manager::NetworkManager::GetInstance(), audacity::cloud::audiocom::ServiceConfig::GetProgressCallbackTimeout(), audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::GetProgressPayload(), and audacity::network_manager::Request::setHeader().

Here is the call graph for this function:

InitiateUpload()

void audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::InitiateUpload ( std::string_view  authToken )

inline

Definition at line 282 of file UploadService.cpp.

   {
      using namespace audacity::network_manager;
 
      Request request(mServiceConfig.GetAPIUrl("/audio"));
 
      request.setHeader(
         common_headers::ContentType, common_content_types::ApplicationJson);
 
      request.setHeader(
         common_headers::Accept, common_content_types::ApplicationJson);
 
      mAuthToken = std::string(authToken);
      SetRequiredHeaders(request);
 
      const auto payload = GetUploadRequestPayload(mFileName, mProjectName, mIsPublic);
 
      std::lock_guard<std::mutex> lock(mStatusMutex);
 
      // User has already aborted? Do not send the request.
      if (mAborted)
         return;
 
      auto response = NetworkManager::GetInstance().doPost(
         request, payload.data(), payload.size());
 
      mActiveResponse = response;
 
      response->setRequestFinishedCallback(
         [response, sharedThis = shared_from_this(), this](auto) {
            auto responseCode = response->getHTTPCode();
 
            if (responseCode == 201)
            {
               HandleUploadPolicy(response->readAll<std::string>());
            }
            else if (responseCode == 401)
            {
               FailPromise(
                  UploadOperationCompleted::Result::Unauthorized,
                  response->readAll<std::string>());
            }
            else if (responseCode == 422)
            {
               FailPromise(
                  UploadOperationCompleted::Result::InvalidData,
                  response->readAll<std::string>());
            }
            else
            {
               FailPromise(
                  UploadOperationCompleted::Result::UnexpectedResponse,
                  response->readAll<std::string>());
            }
         });
   }

References audacity::network_manager::common_headers::Accept, audacity::network_manager::common_content_types::ApplicationJson, audacity::network_manager::common_headers::ContentType, audacity::network_manager::NetworkManager::doPost(), audacity::cloud::audiocom::ServiceConfig::GetAPIUrl(), audacity::network_manager::NetworkManager::GetInstance(), audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::GetUploadRequestPayload(), audacity::cloud::audiocom::UploadOperationCompleted::InvalidData, audacity::network_manager::Request::setHeader(), audacity::cloud::audiocom::UploadOperationCompleted::Unauthorized, and audacity::cloud::audiocom::UploadOperationCompleted::UnexpectedResponse.

Here is the call graph for this function:

IsCompleted()

bool audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::IsCompleted ( )

inlineoverridevirtual

Returns true if the upload is finished.

Implements audacity::cloud::audiocom::UploadOperation.

Definition at line 515 of file UploadService.cpp.

   {
      std::lock_guard<std::mutex> lock(mStatusMutex);
      return mCompleted;
   }

SetRequiredHeaders()

void audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::SetRequiredHeaders ( audacity::network_manager::Request &  request ) const

inline

Definition at line 224 of file UploadService.cpp.

   {
      if (!mAuthToken.empty())
         request.setHeader(
            audacity::network_manager::common_headers::Authorization, std::string(mAuthToken));
 
      const auto language = mServiceConfig.GetAcceptLanguageValue();
 
      if (!language.empty())
         request.setHeader(
            audacity::network_manager::common_headers::AcceptLanguage,
            language);
   }

References audacity::network_manager::common_headers::AcceptLanguage, audacity::network_manager::common_headers::Authorization, audacity::cloud::audiocom::ServiceConfig::GetAcceptLanguageValue(), and audacity::network_manager::Request::setHeader().

Here is the call graph for this function:

Member Data Documentation

mAborted

bool audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mAborted {}

Definition at line 222 of file UploadService.cpp.

mActiveResponse

std::weak_ptr<audacity::network_manager::IResponse> audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mActiveResponse

Definition at line 220 of file UploadService.cpp.

mAudioID

std::string audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mAudioID

Definition at line 207 of file UploadService.cpp.

mAudioSlug

std::string audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mAudioSlug

Definition at line 211 of file UploadService.cpp.

mAuthToken

std::string audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mAuthToken

Definition at line 201 of file UploadService.cpp.

mCallbacksMutex

std::mutex audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mCallbacksMutex

mutable

Definition at line 218 of file UploadService.cpp.

mCompleted

bool audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mCompleted {}

Definition at line 221 of file UploadService.cpp.

mCompletedCallback

UploadService::CompletedCallback audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mCompletedCallback

Definition at line 198 of file UploadService.cpp.

mFailureUrl

std::string audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mFailureUrl

Definition at line 204 of file UploadService.cpp.

mFileName

const wxString audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mFileName

Definition at line 193 of file UploadService.cpp.

mIsPublic

const bool audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mIsPublic

Definition at line 196 of file UploadService.cpp.

mLastProgressReportTime

Clock::time_point audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mLastProgressReportTime

Definition at line 215 of file UploadService.cpp.

mProgressCallback

UploadService::ProgressCallback audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mProgressCallback

Definition at line 199 of file UploadService.cpp.

mProgressUrl

std::string audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mProgressUrl

Definition at line 205 of file UploadService.cpp.

mProjectName

const wxString audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mProjectName

Definition at line 194 of file UploadService.cpp.

mServiceConfig

const ServiceConfig& audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mServiceConfig

Definition at line 191 of file UploadService.cpp.

mStatusMutex

std::mutex audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mStatusMutex

mutable

Definition at line 217 of file UploadService.cpp.

mSuccessUrl

std::string audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mSuccessUrl

Definition at line 203 of file UploadService.cpp.

mUploadToken

std::string audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mUploadToken

Definition at line 208 of file UploadService.cpp.

mUserName

std::string audacity::cloud::audiocom::anonymous_namespace{UploadService.cpp}::AudiocomUploadOperation::mUserName

Definition at line 209 of file UploadService.cpp.

---

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

• UploadService.cpp