audacity::cloud::audiocom::sync::LocalProjectSnapshot Class Reference

#include <LocalProjectSnapshot.h>

Inheritance diagram for audacity::cloud::audiocom::sync::LocalProjectSnapshot:

Collaboration diagram for audacity::cloud::audiocom::sync::LocalProjectSnapshot:

Classes
struct	ProjectBlocksLock
struct	SnapshotData
struct	Tag

Public Types
using	Promise = std::promise< SnapshotData >
using	Future = std::future< SnapshotData >

Public Member Functions
	LocalProjectSnapshot (Tag, const ServiceConfig &config, const OAuthService &oauthService, ProjectCloudExtension &extension, std::string name, UploadMode mode)
	~LocalProjectSnapshot () override
bool	IsCompleted () const override
std::shared_ptr< AudacityProject >	GetProject ()
void	Start () override
void	SetUploadData (const ProjectUploadData &data) override
void	Cancel () override
void	Abort ()
Public Member Functions inherited from audacity::cloud::audiocom::sync::ProjectUploadOperation
virtual	~ProjectUploadOperation ()=default
virtual void	Start ()=0
virtual void	SetUploadData (const ProjectUploadData &data)=0
virtual bool	IsCompleted () const =0
Public Member Functions inherited from audacity::concurrency::ICancellable
virtual	~ICancellable ()=default
virtual void	Cancel ()=0

Static Public Member Functions
static Future	Create (const ServiceConfig &config, const OAuthService &oauthService, ProjectCloudExtension &extension, std::string name, UploadMode mode)

Private Member Functions
void	UploadFailed (CloudSyncError error)
void	DataUploadFailed (const ResponseResult &uploadResult)
void	DataUploadFailed (const MissingBlocksUploadProgress &uploadResult)
void	UpdateProjectSnapshot ()
void	OnSnapshotCreated (const CreateSnapshotResponse &response, bool newProject)
void	StorePendingSnapshot (const CreateSnapshotResponse &response, const ProjectUploadData &data)
void	MarkSnapshotSynced ()
void	DeleteSnapshot ()

Private Attributes
ProjectCloudExtension &	mProjectCloudExtension
std::weak_ptr< AudacityProject >	mWeakProject
std::promise< ProjectUploadData >	mProjectDataPromise
const ServiceConfig &	mServiceConfig
const OAuthService &	mOAuthService
std::string	mProjectName
std::unique_ptr< ProjectBlocksLock >	mProjectBlocksLock
std::shared_ptr< MissingBlocksUploader >	mMissingBlockUploader
std::mutex	mCreateSnapshotResponseMutex
std::optional< CreateSnapshotResponse >	mCreateSnapshotResponse
UploadMode	mUploadMode { UploadMode::Normal }
Promise	mCreateSnapshotPromise
concurrency::CancellationContextPtr	mCancellationContext
std::atomic< bool >	mCompleted { false }
std::atomic< bool >	mCancelled { false }
std::atomic< bool >	mProjectDataReady { false }

Detailed Description

Definition at line 47 of file LocalProjectSnapshot.h.

Member Typedef Documentation

Future

using audacity::cloud::audiocom::sync::LocalProjectSnapshot::Future = std::future<SnapshotData>

Definition at line 63 of file LocalProjectSnapshot.h.

Promise

using audacity::cloud::audiocom::sync::LocalProjectSnapshot::Promise = std::promise<SnapshotData>

Definition at line 62 of file LocalProjectSnapshot.h.

Constructor & Destructor Documentation

LocalProjectSnapshot()

audacity::cloud::audiocom::sync::LocalProjectSnapshot::LocalProjectSnapshot	(	Tag	,
		const ServiceConfig &	config,
		const OAuthService &	oauthService,
		ProjectCloudExtension &	extension,
		std::string	name,
		UploadMode	mode
	)

Definition at line 189 of file LocalProjectSnapshot.cpp.

    : mProjectCloudExtension { extension }
    , mWeakProject { extension.GetProject() }
    , mServiceConfig { config }
    , mOAuthService { oauthService }
    , mProjectName { std::move(name) }
    , mUploadMode { mode }
    , mCancellationContext { concurrency::CancellationContext::Create() }
{
}

~LocalProjectSnapshot()

audacity::cloud::audiocom::sync::LocalProjectSnapshot::~LocalProjectSnapshot ( )

override

Definition at line 202 of file LocalProjectSnapshot.cpp.

{
}

Member Function Documentation

Abort()

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::Abort

(

)

Definition at line 273 of file LocalProjectSnapshot.cpp.

{
   mCancelled.store(true, std::memory_order_release);
 
   mCancellationContext->Cancel();
 
   if (!mProjectDataReady.load(std::memory_order_acquire))
      mProjectDataPromise.set_value({});
 
   UploadFailed({ CloudSyncError::Aborted });
 
   DeleteSnapshot();
}

References audacity::cloud::audiocom::sync::CloudSyncError::Aborted, DeleteSnapshot(), mCancellationContext, mCancelled, mProjectDataPromise, mProjectDataReady, and UploadFailed().

Here is the call graph for this function:

Cancel()

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::Cancel ( )

overridevirtual

Implements audacity::concurrency::ICancellable.

Definition at line 261 of file LocalProjectSnapshot.cpp.

{
   mCancelled.store(true, std::memory_order_release);
 
   mCancellationContext->Cancel();
 
   if (!mProjectDataReady.load(std::memory_order_acquire))
      mProjectDataPromise.set_value({});
 
   UploadFailed({ CloudSyncError::Cancelled });
}

References audacity::cloud::audiocom::sync::CloudSyncError::Cancelled, mCancellationContext, mCancelled, mProjectDataPromise, mProjectDataReady, and UploadFailed().

Here is the call graph for this function:

Create()

LocalProjectSnapshot::Future audacity::cloud::audiocom::sync::LocalProjectSnapshot::Create ( const ServiceConfig &  config, const OAuthService &  oauthService, ProjectCloudExtension &  extension, std::string  name, UploadMode  mode  )

static

Definition at line 206 of file LocalProjectSnapshot.cpp.

{
   auto project = extension.GetProject().lock();
 
   if (!project)
      return {};
 
   auto snapshot = std::make_shared<LocalProjectSnapshot>(
      Tag {}, config, oauthService, extension, std::move(name), mode);
 
   snapshot->mProjectCloudExtension.OnUploadOperationCreated(snapshot);
 
   snapshot->mProjectBlocksLock = std::make_unique<ProjectBlocksLock>(
      extension, *project,
      [weakSnapshot = std::weak_ptr(snapshot)]
      {
         auto snapshot = weakSnapshot.lock();
 
         if (snapshot == nullptr)
            return;
 
         auto project = snapshot->GetProject();
 
         if (project == nullptr)
            return;
 
         snapshot->mProjectCloudExtension.OnBlocksHashed(*snapshot);
      });
 
   return snapshot->mCreateSnapshotPromise.get_future();
}

References anonymous_namespace{CloudProjectFileIOExtensions.cpp}::extension, name, and project.

DataUploadFailed() [1/2]

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::DataUploadFailed ( const MissingBlocksUploadProgress &  uploadResult )

private

Definition at line 298 of file LocalProjectSnapshot.cpp.

{
   CloudSyncError::ErrorType errorType = CloudSyncError::DataUploadFailed;
 
   for (const auto& uploadError : uploadResult.UploadErrors)
   {
      if (
         uploadError.Code == SyncResultCode::Success ||
         uploadError.Code == SyncResultCode::Conflict)
         continue;
 
      const auto deducedError = DeduceError(uploadError.Code);
 
      if (
         errorType == CloudSyncError::DataUploadFailed &&
         deducedError == CloudSyncError::Network)
      {
         errorType = deducedError;
      }
      else if (
         deducedError == CloudSyncError::ProjectStorageLimitReached ||
         deducedError == CloudSyncError::Cancelled)
      {
         errorType = deducedError;
         break;
      }
   }
 
   UploadFailed({ errorType, {} });
}

References audacity::cloud::audiocom::sync::CloudSyncError::Cancelled, audacity::cloud::audiocom::Conflict, audacity::cloud::audiocom::sync::CloudSyncError::DataUploadFailed, audacity::cloud::audiocom::sync::DeduceError(), audacity::cloud::audiocom::sync::CloudSyncError::Network, audacity::cloud::audiocom::sync::CloudSyncError::ProjectStorageLimitReached, audacity::cloud::audiocom::Success, audacity::cloud::audiocom::sync::MissingBlocksUploadProgress::UploadErrors, and UploadFailed().

Here is the call graph for this function:

DataUploadFailed() [2/2]

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::DataUploadFailed ( const ResponseResult &  uploadResult )

private

Definition at line 293 of file LocalProjectSnapshot.cpp.

{
   UploadFailed({ DeduceError(uploadResult.Code), uploadResult.Content });
}

References audacity::cloud::audiocom::ResponseResult::Code, audacity::cloud::audiocom::ResponseResult::Content, audacity::cloud::audiocom::sync::DeduceError(), and UploadFailed().

Referenced by OnSnapshotCreated().

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteSnapshot()

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::DeleteSnapshot ( )

private

Definition at line 593 of file LocalProjectSnapshot.cpp.

{
   if (!mCreateSnapshotResponse)
      return;
 
   using namespace network_manager;
 
   Request request(mServiceConfig.GetDeleteSnapshotUrl(
      mCreateSnapshotResponse->Project.Id,
      mCreateSnapshotResponse->Snapshot.Id));
 
   SetCommonHeaders(request);
 
   auto response = NetworkManager::GetInstance().doDelete(request);
 
   response->setRequestFinishedCallback(
      [this, response, strongThis = shared_from_this()](auto)
      {
         CloudProjectsDatabase::Get().RemovePendingSnapshot(
            mCreateSnapshotResponse->Project.Id,
            mCreateSnapshotResponse->Snapshot.Id);
      });
}

References audacity::network_manager::NetworkManager::doDelete(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::Get(), audacity::cloud::audiocom::ServiceConfig::GetDeleteSnapshotUrl(), audacity::network_manager::NetworkManager::GetInstance(), mCreateSnapshotResponse, mServiceConfig, audacity::cloud::audiocom::sync::CloudProjectsDatabase::RemovePendingSnapshot(), and audacity::cloud::audiocom::SetCommonHeaders().

Referenced by Abort().

Here is the call graph for this function:

Here is the caller graph for this function:

GetProject()

std::shared_ptr< AudacityProject > audacity::cloud::audiocom::sync::LocalProjectSnapshot::GetProject

(

)

Definition at line 245 of file LocalProjectSnapshot.cpp.

{
   return mWeakProject.lock();
}

References mWeakProject.

IsCompleted()

bool audacity::cloud::audiocom::sync::LocalProjectSnapshot::IsCompleted ( ) const

overridevirtual

Implements audacity::cloud::audiocom::sync::ProjectUploadOperation.

Definition at line 240 of file LocalProjectSnapshot.cpp.

{
   return mCompleted.load(std::memory_order_acquire);
}

References mCompleted.

MarkSnapshotSynced()

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::MarkSnapshotSynced ( )

private

Definition at line 558 of file LocalProjectSnapshot.cpp.

{
   using namespace network_manager;
   Request request(mServiceConfig.GetSnapshotSyncUrl(
      mCreateSnapshotResponse->Project.Id,
      mCreateSnapshotResponse->Snapshot.Id));
 
   SetCommonHeaders(request);
 
   auto response = NetworkManager::GetInstance().doPost(request, nullptr, 0);
 
   response->setRequestFinishedCallback(
      [this, response, weakThis = weak_from_this()](auto)
      {
         auto strongThis = weakThis.lock();
         if (!strongThis)
            return;
 
         CloudProjectsDatabase::Get().RemovePendingSnapshot(
            mCreateSnapshotResponse->Project.Id,
            mCreateSnapshotResponse->Snapshot.Id);
 
         if (response->getError() != NetworkError::NoError)
         {
            UploadFailed(DeduceUploadError(*response));
            return;
         }
 
         mCompleted.store(true, std::memory_order_release);
         mProjectCloudExtension.OnSyncCompleted(this, {});
      });
 
   mCancellationContext->OnCancelled(response);
}

References audacity::cloud::audiocom::sync::DeduceUploadError(), audacity::network_manager::NetworkManager::doPost(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::Get(), audacity::network_manager::NetworkManager::GetInstance(), audacity::cloud::audiocom::ServiceConfig::GetSnapshotSyncUrl(), mCancellationContext, mCompleted, mCreateSnapshotResponse, mProjectCloudExtension, mServiceConfig, audacity::cloud::audiocom::sync::ProjectCloudExtension::OnSyncCompleted(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::RemovePendingSnapshot(), audacity::cloud::audiocom::SetCommonHeaders(), and UploadFailed().

Referenced by OnSnapshotCreated().

Here is the call graph for this function:

Here is the caller graph for this function:

OnSnapshotCreated()

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::OnSnapshotCreated ( const CreateSnapshotResponse &  response, bool  newProject  )

private

Definition at line 427 of file LocalProjectSnapshot.cpp.

{
   auto project = mWeakProject.lock();
 
   if (project == nullptr)
   {
      UploadFailed(MakeClientFailure(
         XO("Project was closed before snapshot was created")));
      return;
   }
 
   if (newProject)
      mProjectBlocksLock->UpdateProjectHashesInCache();
 
   mProjectBlocksLock->FillMissingBlocks(response.SyncState.MissingBlocks);
 
   mProjectCloudExtension.OnSnapshotCreated(*this, response);
 
   {
      auto lock = std::lock_guard { mCreateSnapshotResponseMutex };
      mCreateSnapshotResponse = response;
   }
 
   mCreateSnapshotPromise.set_value({ response, shared_from_this() });
 
   auto projectData = mProjectDataPromise.get_future().get();
 
   if (mCancelled.load(std::memory_order_acquire))
      return;
 
   StorePendingSnapshot(response, projectData);
 
   DataUploader::Get().Upload(
      mCancellationContext, mServiceConfig, response.SyncState.FileUrls,
      projectData.ProjectSnapshot,
      [this, weakThis = weak_from_this()](ResponseResult result)
      {
         auto strongThis = weakThis.lock();
         if (!strongThis)
            return;
 
         auto& db = CloudProjectsDatabase::Get();
 
         const auto projectId  = mCreateSnapshotResponse->Project.Id;
         const auto snapshotId = mCreateSnapshotResponse->Snapshot.Id;
 
         if (result.Code != SyncResultCode::Success)
         {
            db.RemovePendingSnapshot(projectId, snapshotId);
            db.RemovePendingProjectBlob(projectId, snapshotId);
            db.RemovePendingProjectBlocks(projectId, snapshotId);
 
            DataUploadFailed(result);
            return;
         }
 
         mProjectCloudExtension.OnProjectDataUploaded(*this);
         db.RemovePendingProjectBlob(projectId, snapshotId);
 
         if (mProjectBlocksLock->MissingBlocks.empty())
         {
            MarkSnapshotSynced();
            return;
         }
 
         mMissingBlockUploader = MissingBlocksUploader::Create(
            mCancellationContext, mServiceConfig,
            mProjectBlocksLock->MissingBlocks,
            [this, weakThis = weak_from_this()](
               auto result, auto block, auto uploadResult)
            {
               auto strongThis = weakThis.lock();
               if (!strongThis)
                  return;
 
               if (!IsUploadRecoverable(uploadResult.Code))
                  CloudProjectsDatabase::Get().RemovePendingProjectBlock(
                     mCreateSnapshotResponse->Project.Id, block.Id);
 
               mProjectCloudExtension.OnBlockUploaded(
                  *this, block.Hash,
                  uploadResult.Code == SyncResultCode::Success);
 
               const auto completed =
                  result.UploadedBlocks == result.TotalBlocks ||
                  result.FailedBlocks != 0;
               const bool succeeded = completed && result.FailedBlocks == 0;
 
               if (!completed)
                  return;
 
               if (succeeded)
                  MarkSnapshotSynced();
               else
                  DataUploadFailed(result);
            });
      });
}

References audacity::cloud::audiocom::ResponseResult::Code, audacity::cloud::audiocom::sync::MissingBlocksUploader::Create(), DataUploadFailed(), audacity::cloud::audiocom::sync::ProjectSyncState::FileUrls, audacity::cloud::audiocom::sync::CloudProjectsDatabase::Get(), audacity::cloud::audiocom::sync::DataUploader::Get(), audacity::cloud::audiocom::IsUploadRecoverable(), audacity::cloud::audiocom::sync::MakeClientFailure(), MarkSnapshotSynced(), mCancellationContext, mCancelled, mCreateSnapshotPromise, mCreateSnapshotResponse, mCreateSnapshotResponseMutex, audacity::cloud::audiocom::sync::ProjectSyncState::MissingBlocks, mMissingBlockUploader, mProjectBlocksLock, mProjectCloudExtension, mProjectDataPromise, mServiceConfig, mWeakProject, audacity::cloud::audiocom::sync::ProjectCloudExtension::OnBlockUploaded(), audacity::cloud::audiocom::sync::ProjectCloudExtension::OnProjectDataUploaded(), audacity::cloud::audiocom::sync::ProjectCloudExtension::OnSnapshotCreated(), project, audacity::cloud::audiocom::sync::CloudProjectsDatabase::RemovePendingProjectBlock(), StorePendingSnapshot(), audacity::cloud::audiocom::Success, audacity::cloud::audiocom::sync::CreateSnapshotResponse::SyncState, audacity::cloud::audiocom::sync::DataUploader::Upload(), UploadFailed(), and XO().

Referenced by UpdateProjectSnapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

SetUploadData()

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::SetUploadData ( const ProjectUploadData &  data )

overridevirtual

Implements audacity::cloud::audiocom::sync::ProjectUploadOperation.

Definition at line 255 of file LocalProjectSnapshot.cpp.

{
   mProjectDataReady.store(true);
   mProjectDataPromise.set_value(data);
}

References mProjectDataPromise, and mProjectDataReady.

Start()

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::Start ( )

overridevirtual

Implements audacity::cloud::audiocom::sync::ProjectUploadOperation.

Definition at line 250 of file LocalProjectSnapshot.cpp.

{
   UpdateProjectSnapshot();
}

References UpdateProjectSnapshot().

Here is the call graph for this function:

StorePendingSnapshot()

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::StorePendingSnapshot ( const CreateSnapshotResponse &  response, const ProjectUploadData &  data  )

private

Definition at line 527 of file LocalProjectSnapshot.cpp.

{
   CloudProjectsDatabase::Get().AddPendingSnapshot(
      { response.Project.Id, response.Snapshot.Id,
        mServiceConfig.GetSnapshotSyncUrl(
           response.Project.Id, response.Snapshot.Id) });
 
   CloudProjectsDatabase::Get().AddPendingProjectBlob(
      { response.Project.Id, response.Snapshot.Id,
        response.SyncState.FileUrls.UploadUrl,
        response.SyncState.FileUrls.SuccessUrl,
        response.SyncState.FileUrls.FailUrl, projectData.ProjectSnapshot });
 
   if (mProjectBlocksLock->MissingBlocks.empty())
      return;
 
   std::vector<PendingProjectBlockData> pendingBlocks;
   pendingBlocks.reserve(mProjectBlocksLock->MissingBlocks.size());
 
   for (const auto& block : mProjectBlocksLock->MissingBlocks)
   {
      pendingBlocks.push_back(PendingProjectBlockData {
         response.Project.Id, response.Snapshot.Id, block.BlockUrls.UploadUrl,
         block.BlockUrls.SuccessUrl, block.BlockUrls.FailUrl, block.Block.Id,
         static_cast<int>(block.Block.Format), block.Block.Hash });
   }
 
   CloudProjectsDatabase::Get().AddPendingProjectBlocks(pendingBlocks);
}

References audacity::cloud::audiocom::sync::CloudProjectsDatabase::AddPendingProjectBlob(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::AddPendingProjectBlocks(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::AddPendingSnapshot(), audacity::cloud::audiocom::sync::UploadUrls::FailUrl, audacity::cloud::audiocom::sync::ProjectSyncState::FileUrls, audacity::cloud::audiocom::sync::CloudProjectsDatabase::Get(), audacity::cloud::audiocom::ServiceConfig::GetSnapshotSyncUrl(), audacity::cloud::audiocom::sync::SnapshotInfo::Id, audacity::cloud::audiocom::sync::ProjectInfo::Id, mProjectBlocksLock, mServiceConfig, audacity::cloud::audiocom::sync::CreateSnapshotResponse::Project, audacity::cloud::audiocom::sync::ProjectUploadData::ProjectSnapshot, audacity::cloud::audiocom::sync::CreateSnapshotResponse::Snapshot, audacity::cloud::audiocom::sync::UploadUrls::SuccessUrl, audacity::cloud::audiocom::sync::CreateSnapshotResponse::SyncState, and audacity::cloud::audiocom::sync::UploadUrls::UploadUrl.

Referenced by OnSnapshotCreated().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateProjectSnapshot()

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::UpdateProjectSnapshot ( )

private

Definition at line 330 of file LocalProjectSnapshot.cpp.

{
   auto project = mWeakProject.lock();
 
   if (project == nullptr)
   {
      UploadFailed(MakeClientFailure(
         XO("Project was closed before snapshot was created")));
      return;
   }
 
   const bool isCloudProject = mProjectCloudExtension.IsCloudProject();
   const bool createNew =
      mUploadMode == UploadMode::CreateNew || !isCloudProject;
 
   ProjectForm projectForm;
 
   if (createNew)
      projectForm.Name = mProjectName;
   else
      projectForm.HeadSnapshotId = mProjectCloudExtension.GetSnapshotId();
 
   // For empty projects, mProjectBlocksLock will be nullptr at this point
   if (mProjectBlocksLock != nullptr)
   {
      projectForm.Hashes.reserve(mProjectBlocksLock->Blocks.size());
      std::transform(
         mProjectBlocksLock->Blocks.begin(), mProjectBlocksLock->Blocks.end(),
         std::back_inserter(projectForm.Hashes),
         [](const auto& block) { return block.Hash; });
   }
 
   using namespace audacity::network_manager;
 
   const auto url = createNew ? mServiceConfig.GetCreateProjectUrl() :
                                mServiceConfig.GetCreateSnapshotUrl(
                                   mProjectCloudExtension.GetCloudProjectId());
 
   projectForm.Force = !createNew && mUploadMode == UploadMode::ForceOverwrite;
 
   auto request = Request(url);
 
   request.setHeader(
      common_headers::ContentType, common_content_types::ApplicationJson);
   request.setHeader(
      common_headers::Accept, common_content_types::ApplicationJson);
   // request.setHeader(common_headers::ContentEncoding, "gzip");
 
   const auto language = mServiceConfig.GetAcceptLanguageValue();
 
   if (!language.empty())
      request.setHeader(
         audacity::network_manager::common_headers::AcceptLanguage, language);
 
   request.setHeader(
      common_headers::Authorization, mOAuthService.GetAccessToken());
 
   auto serializedForm = Serialize(projectForm);
 
   auto response = NetworkManager::GetInstance().doPost(
      request, serializedForm.data(), serializedForm.size());
 
   response->setRequestFinishedCallback(
      [this, response, createNew, weakThis = weak_from_this()](auto)
      {
         auto strongThis = weakThis.lock();
         if (!strongThis)
            return;
 
         const auto error = response->getError();
 
         if (error != NetworkError::NoError)
         {
            UploadFailed(DeduceUploadError(*response));
 
            mCreateSnapshotPromise.set_value({});
            return;
         }
 
         const auto body = response->readAll<std::string>();
         auto result     = DeserializeCreateSnapshotResponse(body);
 
         if (!result)
         {
            UploadFailed(MakeClientFailure(
               XO("Invalid Response: %s").Format(body).Translation()));
 
            mCreateSnapshotPromise.set_value({});
            return;
         }
 
         OnSnapshotCreated(*result, createNew);
      });
 
   mCancellationContext->OnCancelled(response);
}

References audacity::network_manager::common_headers::Accept, audacity::network_manager::common_headers::AcceptLanguage, audacity::network_manager::common_content_types::ApplicationJson, audacity::network_manager::common_headers::Authorization, audacity::network_manager::common_headers::ContentType, audacity::cloud::audiocom::sync::CreateNew, audacity::cloud::audiocom::sync::DeduceUploadError(), audacity::cloud::audiocom::sync::DeserializeCreateSnapshotResponse(), audacity::network_manager::NetworkManager::doPost(), audacity::cloud::audiocom::sync::ProjectForm::Force, audacity::cloud::audiocom::sync::ForceOverwrite, audacity::cloud::audiocom::ServiceConfig::GetAcceptLanguageValue(), audacity::cloud::audiocom::OAuthService::GetAccessToken(), audacity::cloud::audiocom::sync::ProjectCloudExtension::GetCloudProjectId(), audacity::cloud::audiocom::ServiceConfig::GetCreateProjectUrl(), audacity::cloud::audiocom::ServiceConfig::GetCreateSnapshotUrl(), audacity::network_manager::NetworkManager::GetInstance(), audacity::cloud::audiocom::sync::ProjectCloudExtension::GetSnapshotId(), audacity::cloud::audiocom::sync::ProjectForm::Hashes, audacity::cloud::audiocom::sync::ProjectForm::HeadSnapshotId, audacity::cloud::audiocom::sync::ProjectCloudExtension::IsCloudProject(), audacity::cloud::audiocom::sync::MakeClientFailure(), mCancellationContext, mCreateSnapshotPromise, mOAuthService, mProjectBlocksLock, mProjectCloudExtension, mProjectName, mServiceConfig, mUploadMode, mWeakProject, audacity::cloud::audiocom::sync::ProjectForm::Name, OnSnapshotCreated(), project, audacity::cloud::audiocom::sync::Serialize(), UploadFailed(), and XO().

Referenced by Start().

Here is the call graph for this function:

Here is the caller graph for this function:

UploadFailed()

void audacity::cloud::audiocom::sync::LocalProjectSnapshot::UploadFailed ( CloudSyncError  error )

private

Definition at line 287 of file LocalProjectSnapshot.cpp.

{
   if (!mCompleted.exchange(true, std::memory_order_release))
      mProjectCloudExtension.OnSyncCompleted(this, std::make_optional(error));
}

References mCompleted, mProjectCloudExtension, and audacity::cloud::audiocom::sync::ProjectCloudExtension::OnSyncCompleted().

Referenced by Abort(), Cancel(), DataUploadFailed(), MarkSnapshotSynced(), OnSnapshotCreated(), and UpdateProjectSnapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mCancellationContext

concurrency::CancellationContextPtr audacity::cloud::audiocom::sync::LocalProjectSnapshot::mCancellationContext

private

Definition at line 121 of file LocalProjectSnapshot.h.

Referenced by Abort(), Cancel(), MarkSnapshotSynced(), OnSnapshotCreated(), and UpdateProjectSnapshot().

mCancelled

std::atomic<bool> audacity::cloud::audiocom::sync::LocalProjectSnapshot::mCancelled { false }

private

Definition at line 124 of file LocalProjectSnapshot.h.

Referenced by Abort(), Cancel(), and OnSnapshotCreated().

mCompleted

std::atomic<bool> audacity::cloud::audiocom::sync::LocalProjectSnapshot::mCompleted { false }

private

Definition at line 123 of file LocalProjectSnapshot.h.

Referenced by IsCompleted(), MarkSnapshotSynced(), and UploadFailed().

mCreateSnapshotPromise

Promise audacity::cloud::audiocom::sync::LocalProjectSnapshot::mCreateSnapshotPromise

private

Definition at line 119 of file LocalProjectSnapshot.h.

Referenced by OnSnapshotCreated(), and UpdateProjectSnapshot().

mCreateSnapshotResponse

std::optional<CreateSnapshotResponse> audacity::cloud::audiocom::sync::LocalProjectSnapshot::mCreateSnapshotResponse

private

Definition at line 115 of file LocalProjectSnapshot.h.

Referenced by DeleteSnapshot(), MarkSnapshotSynced(), and OnSnapshotCreated().

mCreateSnapshotResponseMutex

std::mutex audacity::cloud::audiocom::sync::LocalProjectSnapshot::mCreateSnapshotResponseMutex

private

Definition at line 114 of file LocalProjectSnapshot.h.

Referenced by OnSnapshotCreated().

mMissingBlockUploader

std::shared_ptr<MissingBlocksUploader> audacity::cloud::audiocom::sync::LocalProjectSnapshot::mMissingBlockUploader

private

Definition at line 112 of file LocalProjectSnapshot.h.

Referenced by OnSnapshotCreated().

mOAuthService

const OAuthService& audacity::cloud::audiocom::sync::LocalProjectSnapshot::mOAuthService

private

Definition at line 105 of file LocalProjectSnapshot.h.

Referenced by UpdateProjectSnapshot().

mProjectBlocksLock

std::unique_ptr<ProjectBlocksLock> audacity::cloud::audiocom::sync::LocalProjectSnapshot::mProjectBlocksLock

private

Definition at line 110 of file LocalProjectSnapshot.h.

Referenced by OnSnapshotCreated(), StorePendingSnapshot(), and UpdateProjectSnapshot().

mProjectCloudExtension

ProjectCloudExtension& audacity::cloud::audiocom::sync::LocalProjectSnapshot::mProjectCloudExtension

private

Definition at line 99 of file LocalProjectSnapshot.h.

Referenced by MarkSnapshotSynced(), OnSnapshotCreated(), UpdateProjectSnapshot(), and UploadFailed().

mProjectDataPromise

std::promise<ProjectUploadData> audacity::cloud::audiocom::sync::LocalProjectSnapshot::mProjectDataPromise

private

Definition at line 102 of file LocalProjectSnapshot.h.

Referenced by Abort(), Cancel(), OnSnapshotCreated(), and SetUploadData().

mProjectDataReady

std::atomic<bool> audacity::cloud::audiocom::sync::LocalProjectSnapshot::mProjectDataReady { false }

private

Definition at line 125 of file LocalProjectSnapshot.h.

Referenced by Abort(), Cancel(), and SetUploadData().

mProjectName

std::string audacity::cloud::audiocom::sync::LocalProjectSnapshot::mProjectName

private

Definition at line 107 of file LocalProjectSnapshot.h.

Referenced by UpdateProjectSnapshot().

mServiceConfig

const ServiceConfig& audacity::cloud::audiocom::sync::LocalProjectSnapshot::mServiceConfig

private

Definition at line 104 of file LocalProjectSnapshot.h.

Referenced by DeleteSnapshot(), MarkSnapshotSynced(), OnSnapshotCreated(), StorePendingSnapshot(), and UpdateProjectSnapshot().

mUploadMode

UploadMode audacity::cloud::audiocom::sync::LocalProjectSnapshot::mUploadMode { UploadMode::Normal }

private

Definition at line 117 of file LocalProjectSnapshot.h.

Referenced by UpdateProjectSnapshot().

mWeakProject

std::weak_ptr<AudacityProject> audacity::cloud::audiocom::sync::LocalProjectSnapshot::mWeakProject

private

Definition at line 100 of file LocalProjectSnapshot.h.

Referenced by GetProject(), OnSnapshotCreated(), and UpdateProjectSnapshot().

---

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

• LocalProjectSnapshot.h
• LocalProjectSnapshot.cpp