#include <RemoteProjectSnapshot.h>

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

Classes
struct	Tag

Public Member Functions
	RemoteProjectSnapshot (Tag, ProjectInfo projectInfo, SnapshotInfo snapshotInfo, std::string path, RemoteProjectSnapshotStateCallback callback, bool downloadDetached)

	~RemoteProjectSnapshot ()

	RemoteProjectSnapshot (const RemoteProjectSnapshot &)=delete

RemoteProjectSnapshot &	operator= (const RemoteProjectSnapshot &)=delete

	RemoteProjectSnapshot (RemoteProjectSnapshot &&)=delete

RemoteProjectSnapshot &	operator= (RemoteProjectSnapshot &&)=delete

void	Cancel ()

TransferStats	GetTransferStats () const

std::string_view	GetProjectId () const

Static Public Member Functions
static std::shared_ptr< RemoteProjectSnapshot >	Sync (ProjectInfo projectInfo, SnapshotInfo snapshotInfo, std::string path, RemoteProjectSnapshotStateCallback callback, bool downloadDetached)

Private Types
enum class	State { Downloading , Cancelled , Failed , Succeeded }

using	SuccessHandler = std::function< void(audacity::network_manager::ResponsePtr)>

using	Clock = std::chrono::steady_clock

using	TimePoint = Clock::time_point

Private Member Functions
std::string	AttachOriginalDB ()

void	SetupBlocksCopy (const std::string &dbName, std::unordered_set< std::string > blocks)

std::unordered_set< std::string >	CalculateKnownBlocks (const std::string &attachedDbName) const

void	DoCancel ()

void	DownloadBlob (std::string url, SuccessHandler onSuccess, int retries=3)

void	OnProjectBlobDownloaded (audacity::network_manager::ResponsePtr response)

void	OnBlockDownloaded (std::string blockHash, audacity::network_manager::ResponsePtr response)

void	OnFailure (ResponseResult result)

void	RemoveResponse (audacity::network_manager::IResponse *response)

void	MarkProjectInDB (bool successfulDownload)

void	ReportProgress ()

bool	InProgress () const

void	RequestsThread ()

void	SetState (State state)

void	CleanupOrphanBlocks ()

Private Attributes
const std::string	mSnapshotDBName

const ProjectInfo	mProjectInfo

const SnapshotInfo	mSnapshotInfo

const std::string	mPath

RemoteProjectSnapshotStateCallback	mCallback

std::vector< std::string >	mAttachedDBNames

std::atomic< State >	mState { State::Downloading }

TimePoint	mStartTime { Clock::now() }

TimePoint	mEndTime

std::thread	mRequestsThread

std::mutex	mRequestsMutex

std::condition_variable	mRequestsCV

std::vector< std::pair< std::string, SuccessHandler > >	mRequests

int	mRequestsInProgress { 0 }

size_t	mNextRequestIndex { 0 }

std::mutex	mResponsesMutex

std::vector< std::shared_ptr< audacity::network_manager::IResponse > >	mResponses

std::condition_variable	mResponsesEmptyCV

std::atomic< int64_t >	mDownloadedBlocks { 0 }

std::atomic< int64_t >	mCopiedBlocks { 0 }

std::atomic< int64_t >	mDownloadedBytes { 0 }

int64_t	mMissingBlocks { 0 }

std::optional< std::future< bool > >	mCopyBlocksFuture

std::atomic< bool >	mProjectDownloaded { false }

bool	mNothingToDo { false }

const bool	mDownloadDetached { false }

Detailed Description

Definition at line 51 of file RemoteProjectSnapshot.h.

Member Typedef Documentation

◆ Clock

using audacity::cloud::audiocom::sync::RemoteProjectSnapshot::Clock = std::chrono::steady_clock

private

Definition at line 133 of file RemoteProjectSnapshot.h.

◆ SuccessHandler

using audacity::cloud::audiocom::sync::RemoteProjectSnapshot::SuccessHandler = std::function<void(audacity::network_manager::ResponsePtr)>

private

Definition at line 88 of file RemoteProjectSnapshot.h.

◆ TimePoint

using audacity::cloud::audiocom::sync::RemoteProjectSnapshot::TimePoint = Clock::time_point

private

Definition at line 134 of file RemoteProjectSnapshot.h.

Member Enumeration Documentation

◆ State

enum class audacity::cloud::audiocom::sync::RemoteProjectSnapshot::State

strongprivate

Enumerator
Downloading
Cancelled
Failed
Succeeded

Definition at line 80 of file RemoteProjectSnapshot.h.

   {
      Downloading,
      Cancelled,
      Failed,
      Succeeded
   };

Constructor & Destructor Documentation

◆ RemoteProjectSnapshot() [1/3]

audacity::cloud::audiocom::sync::RemoteProjectSnapshot::RemoteProjectSnapshot	(	Tag	,
		ProjectInfo	projectInfo,
		SnapshotInfo	snapshotInfo,
		std::string	path,
		RemoteProjectSnapshotStateCallback	callback,
		bool	downloadDetached
	)

Definition at line 60 of file RemoteProjectSnapshot.cpp.

    : mSnapshotDBName { std::string("s_") + projectInfo.Id }
    , mProjectInfo { std::move(projectInfo) }
    , mSnapshotInfo { std::move(snapshotInfo) }
    , mPath { std::move(path) }
    , mCallback { std::move(callback) }
    , mDownloadDetached { downloadDetached }
{
   auto db = CloudProjectsDatabase::Get().GetConnection();
   // RemoteProjectSnapshot always receives a path to the database
   // that has AudacityProject schema installed, even if it's a detached
   // or was deleted from the disk before
   auto attachStmt = db->CreateStatement("ATTACH DATABASE ? AS ?");
   auto result     = attachStmt->Prepare(mPath, mSnapshotDBName).Run();
 
   if (!result.IsOk())
      return;
 
   mAttachedDBNames.push_back(mSnapshotDBName);
 
   auto blocksSource = mSnapshotDBName;
 
   if (mDownloadDetached)
   {
      if (auto name = AttachOriginalDB(); !name.empty())
         blocksSource = name;
   }
 
   // This would return and empty set when the project
   // is detached
   auto knownBlocks = CalculateKnownBlocks(blocksSource);
 
   if (mDownloadDetached)
   {
      // We can assume, that if the known blocks are present,
      // they come from the "original" database
      SetupBlocksCopy(blocksSource, knownBlocks);
   }
   else if (knownBlocks.size() == mSnapshotInfo.Blocks.size())
   {
      auto syncInfo =
         CloudProjectsDatabase::Get().GetProjectData(mProjectInfo.Id);
 
      if (
         syncInfo && syncInfo->SnapshotId == mSnapshotInfo.Id &&
         syncInfo->SyncStatus == DBProjectData::SyncStatusSynced)
      {
         mCallback({ {}, 0, 0, true });
         mNothingToDo = true;
         return;
      }
   }
 
   if (!mDownloadDetached)
      CleanupOrphanBlocks();
 
   MarkProjectInDB(false);
 
   mMissingBlocks = mDownloadDetached ?
                       mSnapshotInfo.Blocks.size() :
                       mSnapshotInfo.Blocks.size() - knownBlocks.size();
 
   mRequests.reserve(1 + mMissingBlocks);
 
   mRequests.push_back(std::make_pair(
      mSnapshotInfo.FileUrl,
      [this](auto response) { OnProjectBlobDownloaded(response); }));
 
   for (auto& block : mSnapshotInfo.Blocks)
   {
      if (knownBlocks.find(ToUpper(block.Hash)) != knownBlocks.end())
         continue;
 
      mRequests.push_back(std::make_pair(
         block.Url, [this, hash = ToUpper(block.Hash)](auto response)
         { OnBlockDownloaded(std::move(hash), response); }));
   }
 
   mRequestsThread =
      std::thread { &RemoteProjectSnapshot::RequestsThread, this };
}

Here is the call graph for this function:

◆ ~RemoteProjectSnapshot()

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

Definition at line 144 of file RemoteProjectSnapshot.cpp.

{
   DoCancel();
 
   if (mRequestsThread.joinable())
      mRequestsThread.join();
 
   if (mCopyBlocksFuture.has_value())
      mCopyBlocksFuture->wait();
 
   {
      auto lock = std::unique_lock { mResponsesMutex };
      mResponsesEmptyCV.wait(lock, [this] { return mResponses.empty(); });
   }
 
   auto db = CloudProjectsDatabase::Get().GetConnection();
 
   for (const auto& dbName : ListAttachedDatabases())
   {
      auto detachStmt = db->CreateStatement("DETACH DATABASE ?");
      detachStmt->Prepare(dbName).Run();
   }
}

References audacity::sqlite::Connection::CreateStatement(), DoCancel(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::Get(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::GetConnection(), audacity::cloud::audiocom::sync::anonymous_namespace{RemoteProjectSnapshot.cpp}::ListAttachedDatabases(), mCopyBlocksFuture, mRequestsThread, mResponses, mResponsesEmptyCV, and mResponsesMutex.

Here is the call graph for this function:

◆ RemoteProjectSnapshot() [2/3]

audacity::cloud::audiocom::sync::RemoteProjectSnapshot::RemoteProjectSnapshot ( const RemoteProjectSnapshot & )

delete

◆ RemoteProjectSnapshot() [3/3]

audacity::cloud::audiocom::sync::RemoteProjectSnapshot::RemoteProjectSnapshot ( RemoteProjectSnapshot && )

delete

Member Function Documentation

◆ AttachOriginalDB()

std::string audacity::cloud::audiocom::sync::RemoteProjectSnapshot::AttachOriginalDB ( )

private

Definition at line 226 of file RemoteProjectSnapshot.cpp.

{
   const std::string dbName = "o_" + mProjectInfo.Id;
 
   const auto projectData =
      CloudProjectsDatabase::Get().GetProjectData(mProjectInfo.Id);
 
   if (!projectData)
      return {};
 
   auto db = CloudProjectsDatabase::Get().GetConnection();
   // RemoteProjectSnapshot always receives a path to the database
   // that has AudacityProject schema installed, even if it's a detached
   // or was deleted from the disk before
   auto attachStmt = db->CreateStatement("ATTACH DATABASE ? AS ?");
   auto result     = attachStmt->Prepare(projectData->LocalPath, dbName).Run();
 
   if (!result.IsOk())
      return {};
 
   mAttachedDBNames.push_back(dbName);
 
   return dbName;
}

References audacity::sqlite::Connection::CreateStatement(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::Get(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::GetConnection(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::GetProjectData(), audacity::cloud::audiocom::sync::ProjectInfo::Id, mAttachedDBNames, and mProjectInfo.

Referenced by RemoteProjectSnapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalculateKnownBlocks()

std::unordered_set< std::string > audacity::cloud::audiocom::sync::RemoteProjectSnapshot::CalculateKnownBlocks ( const std::string & attachedDbName ) const

private

Definition at line 315 of file RemoteProjectSnapshot.cpp.

{
   std::unordered_set<std::string> remoteBlocks;
 
   for (const auto& block : mSnapshotInfo.Blocks)
      remoteBlocks.insert(ToUpper(block.Hash));
 
   auto db = CloudProjectsDatabase::Get().GetConnection();
 
   auto fn = db->CreateScalarFunction(
      "inRemoteBlocks", [&remoteBlocks](const std::string& hash)
      { return remoteBlocks.find(hash) != remoteBlocks.end(); });
 
   auto statement = db->CreateStatement(
      "SELECT hash FROM block_hashes WHERE project_id = ? AND inRemoteBlocks(hash) AND block_id IN (SELECT blockid FROM " +
      attachedDbName + ".sampleblocks)");
 
   if (!statement)
      return {};
 
   auto result = statement->Prepare(mProjectInfo.Id).Run();
 
   std::unordered_set<std::string> knownBlocks;
 
   for (auto row : result)
   {
      std::string hash;
 
      if (!row.Get(0, hash))
         continue;
 
      knownBlocks.insert(hash);
   }
 
   return knownBlocks;
}

References audacity::cloud::audiocom::sync::SnapshotInfo::Blocks, fn, audacity::cloud::audiocom::sync::CloudProjectsDatabase::Get(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::GetConnection(), audacity::cloud::audiocom::sync::ProjectInfo::Id, mProjectInfo, mSnapshotInfo, and ToUpper().

Referenced by RemoteProjectSnapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Cancel()

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

Definition at line 196 of file RemoteProjectSnapshot.cpp.

{
   DoCancel();
 
   mCallback({ { SyncResultCode::Cancelled, {} },
               mDownloadedBlocks.load() + mCopiedBlocks.load(),
               mMissingBlocks,
               mProjectDownloaded.load() });
}

References audacity::cloud::audiocom::Cancelled, DoCancel(), mCallback, mCopiedBlocks, mDownloadedBlocks, mMissingBlocks, and mProjectDownloaded.

Here is the call graph for this function:

◆ CleanupOrphanBlocks()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::CleanupOrphanBlocks ( )

private

Definition at line 764 of file RemoteProjectSnapshot.cpp.

{
   auto db = CloudProjectsDatabase::Get().GetConnection();
 
   auto transaction = db->BeginTransaction("d_" + mProjectInfo.Id);
 
   std::unordered_set<std::string> snaphotBlockHashes;
 
   for (const auto& block : mSnapshotInfo.Blocks)
      snaphotBlockHashes.insert(ToUpper(block.Hash));
 
   auto inSnaphotFunction = db->CreateScalarFunction(
      "inSnapshot", [&snaphotBlockHashes](const std::string& hash)
      { return snaphotBlockHashes.find(hash) != snaphotBlockHashes.end(); });
 
   // Delete blocks not in the snapshot
   auto deleteBlocksStatement = db->CreateStatement(
      "DELETE FROM " + mSnapshotDBName +
      ".sampleblocks WHERE blockid NOT IN (SELECT block_id FROM block_hashes WHERE project_id = ? AND inSnapshot(hash))");
 
   if (!deleteBlocksStatement)
      return;
 
   auto result = deleteBlocksStatement->Prepare(mProjectInfo.Id).Run();
 
   if (!result.IsOk())
      return;
 
   auto deleteHashesStatement = db->CreateStatement(
      "DELETE FROM block_hashes WHERE project_id = ? AND NOT inSnapshot(hash)");
 
   if (!deleteHashesStatement)
      return;
 
   result = deleteHashesStatement->Prepare(mProjectInfo.Id).Run();
 
   if (!result.IsOk())
      return;
 
   transaction.Commit();
}

References BasicUI::Get(), and ToUpper().

Referenced by RemoteProjectSnapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoCancel()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::DoCancel ( )

private

Definition at line 353 of file RemoteProjectSnapshot.cpp.

{
   if (mState.load(std::memory_order_acquire) != State::Downloading)
      return;
 
   SetState(State::Cancelled);
 
   mRequestsCV.notify_one();
 
   {
      auto responsesLock = std::lock_guard { mResponsesMutex };
      for (auto& response : mResponses)
         response->abort();
   }
}

References Cancelled, Downloading, mRequestsCV, mResponses, mResponsesMutex, mState, and SetState().

Referenced by Cancel(), and ~RemoteProjectSnapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DownloadBlob()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::DownloadBlob	(	std::string	url,
		SuccessHandler	onSuccess,
		int	retries = `3`
	)

private

Definition at line 369 of file RemoteProjectSnapshot.cpp.

{
   using namespace audacity::network_manager;
 
   auto request = Request(url);
 
   auto response = NetworkManager::GetInstance().doGet(request);
 
   {
      auto responsesLock = std::lock_guard { mResponsesMutex };
      mResponses.push_back(response);
   }
 
   response->setRequestFinishedCallback(
      [this, onSuccess = std::move(onSuccess), retries, response](auto)
      {
         mDownloadedBytes.fetch_add(
            response->getBytesAvailable(), std::memory_order_acq_rel);
 
         RemoveResponse(response.get());
 
         auto responseResult = GetResponseResult(*response, false);
 
         if (responseResult.Code == SyncResultCode::Cancelled)
            return;
 
         if (
            responseResult.Code != SyncResultCode::Success &&
            responseResult.Code != SyncResultCode::ConnectionFailed)
         {
            OnFailure(std::move(responseResult));
            return;
         }
 
         if (responseResult.Code == SyncResultCode::ConnectionFailed)
         {
            if (retries <= 0)
            {
               OnFailure(std::move(responseResult));
               return;
            }
 
            DownloadBlob(
               response->getRequest().getURL(), std::move(onSuccess),
               retries - 1);
 
            return;
         }
 
         onSuccess(response);
      });
}

References audacity::cloud::audiocom::Cancelled, audacity::cloud::audiocom::ConnectionFailed, audacity::network_manager::NetworkManager::doGet(), DownloadBlob(), audacity::network_manager::NetworkManager::GetInstance(), audacity::cloud::audiocom::GetResponseResult(), mDownloadedBytes, mResponses, mResponsesMutex, RemoveResponse(), and audacity::cloud::audiocom::Success.

Referenced by DownloadBlob().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetProjectId()

std::string_view audacity::cloud::audiocom::sync::RemoteProjectSnapshot::GetProjectId ( ) const

Definition at line 221 of file RemoteProjectSnapshot.cpp.

{
   return mProjectInfo.Id;
}

References audacity::cloud::audiocom::sync::ProjectInfo::Id, and mProjectInfo.

◆ GetTransferStats()

TransferStats audacity::cloud::audiocom::sync::RemoteProjectSnapshot::GetTransferStats ( ) const

Definition at line 206 of file RemoteProjectSnapshot.cpp.

{
   const auto duration =
      mState.load(std::memory_order_acquire) == State::Downloading ?
         Clock::now() - mStartTime :
         mEndTime - mStartTime;
 
   return TransferStats {}
      .SetBlocksTransferred(mDownloadedBlocks.load())
      .SetBytesTransferred(mDownloadedBytes.load())
      .SetProjectFilesTransferred(mProjectDownloaded.load() ? 1 : 0)
      .SetTransferDuration(
         std::chrono::duration_cast<TransferStats::Duration>(duration));
}

References Downloading, mDownloadedBlocks, mDownloadedBytes, mEndTime, mProjectDownloaded, mStartTime, mState, audacity::cloud::audiocom::TransferStats::SetBlocksTransferred(), audacity::cloud::audiocom::TransferStats::SetBytesTransferred(), audacity::cloud::audiocom::TransferStats::SetProjectFilesTransferred(), and audacity::cloud::audiocom::TransferStats::SetTransferDuration().

Here is the call graph for this function:

◆ InProgress()

bool audacity::cloud::audiocom::sync::RemoteProjectSnapshot::InProgress ( ) const

private

Definition at line 713 of file RemoteProjectSnapshot.cpp.

{
   return mState.load(std::memory_order_acquire) == State::Downloading;
}

References mState.

Referenced by SetupBlocksCopy().

Here is the caller graph for this function:

◆ MarkProjectInDB()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::MarkProjectInDB ( bool successfulDownload )

private

Definition at line 657 of file RemoteProjectSnapshot.cpp.

{
   if (mDownloadDetached)
      return;
 
   auto& db         = CloudProjectsDatabase::Get();
   auto currentData = db.GetProjectData(mProjectInfo.Id);
 
   auto data = currentData ? *currentData : DBProjectData {};
 
   data.ProjectId  = mProjectInfo.Id;
   data.SnapshotId = mSnapshotInfo.Id;
   data.SyncStatus = successfulDownload ? DBProjectData::SyncStatusSynced :
                                          DBProjectData::SyncStatusDownloading;
   data.LastRead   = wxDateTime::Now().GetTicks();
   data.LocalPath  = mPath;
 
   if (data.SavesCount == 0)
      data.SavesCount = 1;
 
   // For the downloaded projects - we don't need to show the dialog
   data.FirstSyncDialogShown = true;
 
   db.UpdateProjectData(data);
 
   if (successfulDownload)
      db.SetProjectUserSlug(mProjectInfo.Id, mProjectInfo.Username);
}

References BasicUI::Get(), and audacity::cloud::audiocom::sync::DBProjectData::ProjectId.

Referenced by RemoteProjectSnapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OnBlockDownloaded()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::OnBlockDownloaded	(	std::string	blockHash,
		audacity::network_manager::ResponsePtr	response
	)

private

Definition at line 536 of file RemoteProjectSnapshot.cpp.

{
   const auto compressedData = ReadResponseData(*response);
 
   const auto blockData =
      DecompressBlock(compressedData.data(), compressedData.size());
 
   if (!blockData)
   {
      OnFailure(
         { SyncResultCode::InternalClientError,
           audacity::ToUTF8(XO("Failed to decompress the Cloud project block")
                               .Translation()) });
      return;
   }
 
   auto db          = CloudProjectsDatabase::Get().GetConnection();
   auto transaction = db->BeginTransaction("b_" + blockHash);
 
   auto hashesStatement = db->CreateStatement(
      "INSERT INTO block_hashes (project_id, block_id, hash) VALUES (?1, ?2, ?3) "
      "ON CONFLICT(project_id, block_id) DO UPDATE SET hash = ?3");
 
   auto result =
      hashesStatement->Prepare(mProjectInfo.Id, blockData->BlockId, blockHash)
         .Run();
 
   if (!result.IsOk())
   {
      OnFailure(
         { SyncResultCode::InternalClientError,
           audacity::ToUTF8(
              result.GetErrors().front().GetErrorString().Translation()) });
      return;
   }
 
   auto blockStatement = db->CreateStatement(
      "INSERT INTO " + mSnapshotDBName +
      ".sampleblocks (blockid, sampleformat, summin, summax, sumrms, summary256, summary64k, samples) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8) "
      "ON CONFLICT(blockid) DO UPDATE SET sampleformat = ?2, summin = ?3, summax = ?4, sumrms = ?5, summary256 = ?6, summary64k = ?7, samples = ?8");
 
   if (!blockStatement)
   {
      OnFailure(
         { SyncResultCode::InternalClientError,
           audacity::ToUTF8(
              blockStatement.GetError().GetErrorString().Translation()) });
      return;
   }
 
   auto& preparedStatement = blockStatement->Prepare();
 
   preparedStatement.Bind(1, blockData->BlockId);
   preparedStatement.Bind(2, static_cast<int64_t>(blockData->Format));
   preparedStatement.Bind(3, blockData->BlockMinMaxRMS.Min);
   preparedStatement.Bind(4, blockData->BlockMinMaxRMS.Max);
   preparedStatement.Bind(5, blockData->BlockMinMaxRMS.RMS);
   preparedStatement.Bind(
      6, blockData->Summary256.data(),
      blockData->Summary256.size() * sizeof(MinMaxRMS), false);
   preparedStatement.Bind(
      7, blockData->Summary64k.data(),
      blockData->Summary64k.size() * sizeof(MinMaxRMS), false);
   preparedStatement.Bind(
      8, blockData->Data.data(), blockData->Data.size(), false);
 
   result = preparedStatement.Run();
 
   if (!result.IsOk())
   {
      OnFailure(
         { SyncResultCode::InternalClientError,
           audacity::ToUTF8(
              result.GetErrors().front().GetErrorString().Translation()) });
      return;
   }
 
   if (auto error = transaction.Commit(); error.IsError())
   {
      OnFailure({ SyncResultCode::InternalClientError,
                  audacity::ToUTF8(error.GetErrorString().Translation()) });
      return;
   }
 
   mDownloadedBlocks.fetch_add(1, std::memory_order_acq_rel);
 
   ReportProgress();
}

References audacity::cloud::audiocom::sync::DecompressBlock(), BasicUI::Get(), audacity::cloud::audiocom::InternalClientError, audacity::cloud::audiocom::sync::anonymous_namespace{RemoteProjectSnapshot.cpp}::ReadResponseData(), audacity::ToUTF8(), and XO().

Here is the call graph for this function:

◆ OnFailure()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::OnFailure ( ResponseResult result )

private

Definition at line 626 of file RemoteProjectSnapshot.cpp.

{
   SetState(State::Failed);
   mCallback({ result,
               mDownloadedBlocks.load(std::memory_order_acquire) +
                  mCopiedBlocks.load(std::memory_order_acquire),
               mMissingBlocks,
               mProjectDownloaded.load(std::memory_order_acquire) });
}

Referenced by SetupBlocksCopy().

Here is the caller graph for this function:

◆ OnProjectBlobDownloaded()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::OnProjectBlobDownloaded ( audacity::network_manager::ResponsePtr response )

private

Definition at line 441 of file RemoteProjectSnapshot.cpp.

{
   const std::vector<uint8_t> data = ReadResponseData(*response);
   uint64_t dictSize               = 0;
 
   if (data.size() < sizeof(uint64_t))
   {
      OnFailure({ SyncResultCode::UnexpectedResponse, {} });
      return;
   }
 
   std::memcpy(&dictSize, data.data(), sizeof(uint64_t));
 
   if (!IsLittleEndian())
      dictSize = SwapIntBytes(dictSize);
 
   if (data.size() < sizeof(uint64_t) + dictSize)
   {
      OnFailure({ SyncResultCode::UnexpectedResponse, {} });
      return;
   }
 
   auto db          = CloudProjectsDatabase::Get().GetConnection();
   auto transaction = db->BeginTransaction("p_" + mProjectInfo.Id);
 
   auto updateProjectStatement = db->CreateStatement(
      "INSERT INTO " + mSnapshotDBName +
      ".project (id, dict, doc) VALUES (1, ?1, ?2) "
      "ON CONFLICT(id) DO UPDATE SET dict = ?1, doc = ?2");
 
   if (!updateProjectStatement)
   {
      OnFailure({ SyncResultCode::InternalClientError,
                  audacity::ToUTF8(updateProjectStatement.GetError()
                                      .GetErrorString()
                                      .Translation()) });
      return;
   }
 
   auto& preparedUpdateProjectStatement = updateProjectStatement->Prepare();
 
   preparedUpdateProjectStatement.Bind(
      1, data.data() + sizeof(uint64_t), dictSize, false);
 
   preparedUpdateProjectStatement.Bind(
      2, data.data() + sizeof(uint64_t) + dictSize,
      data.size() - sizeof(uint64_t) - dictSize, false);
 
   auto result = preparedUpdateProjectStatement.Run();
 
   if (!result.IsOk())
   {
      OnFailure(
         { SyncResultCode::InternalClientError,
           audacity::ToUTF8(
              result.GetErrors().front().GetErrorString().Translation()) });
 
      return;
   }
 
   auto deleteAutosaveStatement = db->CreateStatement(
      "DELETE FROM " + mSnapshotDBName + ".autosave WHERE id = 1");
 
   if (!deleteAutosaveStatement)
   {
      OnFailure({ SyncResultCode::InternalClientError,
                  audacity::ToUTF8(deleteAutosaveStatement.GetError()
                                      .GetErrorString()
                                      .Translation()) });
      return;
   }
 
   result = deleteAutosaveStatement->Prepare().Run();
 
   if (!result.IsOk())
   {
      OnFailure(
         { SyncResultCode::InternalClientError,
           audacity::ToUTF8(
              result.GetErrors().front().GetErrorString().Translation()) });
      return;
   }
 
   if (auto error = transaction.Commit(); error.IsError())
   {
      OnFailure({ SyncResultCode::InternalClientError,
                  audacity::ToUTF8(error.GetErrorString().Translation()) });
      return;
   }
 
   mProjectDownloaded.store(true, std::memory_order_release);
   ReportProgress();
}

References BasicUI::Get(), audacity::cloud::audiocom::InternalClientError, IsLittleEndian(), audacity::cloud::audiocom::sync::anonymous_namespace{RemoteProjectSnapshot.cpp}::ReadResponseData(), SwapIntBytes(), audacity::ToUTF8(), and audacity::cloud::audiocom::UnexpectedResponse.

Here is the call graph for this function:

◆ operator=() [1/2]

RemoteProjectSnapshot & audacity::cloud::audiocom::sync::RemoteProjectSnapshot::operator= ( const RemoteProjectSnapshot & )

delete

◆ operator=() [2/2]

RemoteProjectSnapshot & audacity::cloud::audiocom::sync::RemoteProjectSnapshot::operator= ( RemoteProjectSnapshot && )

delete

◆ RemoveResponse()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::RemoveResponse ( audacity::network_manager::IResponse * response )

private

Definition at line 636 of file RemoteProjectSnapshot.cpp.

{
   {
      auto lock = std::lock_guard { mResponsesMutex };
      mResponses.erase(
         std::remove_if(
            mResponses.begin(), mResponses.end(),
            [response](auto& r) { return r.get() == response; }),
         mResponses.end());
 
      if (mResponses.empty())
         mResponsesEmptyCV.notify_all();
   }
   {
      auto lock = std::lock_guard { mRequestsMutex };
      mRequestsInProgress--;
      mRequestsCV.notify_one();
   }
}

Referenced by DownloadBlob().

Here is the caller graph for this function:

◆ ReportProgress()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::ReportProgress ( )

private

Definition at line 686 of file RemoteProjectSnapshot.cpp.

{
   if (mState.load(std::memory_order_acquire) != State::Downloading)
      return;
 
   const auto projectDownloaded =
      mProjectDownloaded.load(std::memory_order_acquire);
   const auto blocksDownloaded =
      mDownloadedBlocks.load(std::memory_order_acquire);
 
   const auto blockCopied = mCopiedBlocks.load(std::memory_order_acquire);
 
   const auto processedBlocks = blocksDownloaded + blockCopied;
 
   const auto completed =
      processedBlocks == mMissingBlocks && projectDownloaded;
 
   if (completed)
   {
      CleanupOrphanBlocks();
      SetState(State::Succeeded);
      MarkProjectInDB(true);
   }
 
   mCallback({ {}, processedBlocks, mMissingBlocks, projectDownloaded });
}

References mState.

Referenced by SetupBlocksCopy().

Here is the caller graph for this function:

◆ RequestsThread()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::RequestsThread ( )

private

Definition at line 718 of file RemoteProjectSnapshot.cpp.

{
   constexpr auto MAX_CONCURRENT_REQUESTS = 6;
 
   while (InProgress())
   {
      std::pair<std::string, SuccessHandler> request;
 
      {
         auto lock = std::unique_lock { mRequestsMutex };
 
         if (mRequestsInProgress >= MAX_CONCURRENT_REQUESTS)
         {
            mRequestsCV.wait(
               lock,
               [this, MAX_CONCURRENT_REQUESTS] {
                  return mRequestsInProgress < MAX_CONCURRENT_REQUESTS ||
                         !InProgress();
               });
         }
 
         if (!InProgress())
            return;
 
         if (mNextRequestIndex >= mRequests.size())
            return;
 
         request = mRequests[mNextRequestIndex++];
         mRequestsInProgress++;
      }
 
      DownloadBlob(std::move(request.first), std::move(request.second), 3);
 
      // TODO: Random sleep to avoid overloading the server
      std::this_thread::sleep_for(std::chrono::milliseconds(50));
   }
}

Referenced by RemoteProjectSnapshot().

Here is the caller graph for this function:

◆ SetState()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::SetState ( State state )

private

Definition at line 756 of file RemoteProjectSnapshot.cpp.

{
   if (state != State::Downloading)
      mEndTime = Clock::now();
 
   mState.exchange(state);
}

References mState.

Referenced by DoCancel().

Here is the caller graph for this function:

◆ SetupBlocksCopy()

void audacity::cloud::audiocom::sync::RemoteProjectSnapshot::SetupBlocksCopy	(	const std::string &	dbName,
		std::unordered_set< std::string >	blocks
	)

private

Definition at line 251 of file RemoteProjectSnapshot.cpp.

{
   // Still, better be safe than sorry
   if (dbName == mSnapshotDBName)
      return;
 
   if (blocks.empty())
      return;
 
   mCopyBlocksFuture = std::async(
      std::launch::async,
      [this, dbName = dbName, blocks = std::move(blocks)]()
      {
         const auto queryString =
            "INSERT INTO " + mSnapshotDBName +
            ".sampleblocks "
            "SELECT * FROM " +
            dbName +
            ".sampleblocks WHERE blockid IN (SELECT block_id FROM block_hashes WHERE hash = ?)";
 
         // Only lock DB for one block a time so the download thread can
         // continue to work
         for (const auto& block : blocks)
         {
            if (!InProgress())
               return false;
 
            auto db = CloudProjectsDatabase::Get().GetConnection();
 
            auto copyBlocksStatement = db->CreateStatement(queryString);
 
            if (!copyBlocksStatement)
            {
               OnFailure({ SyncResultCode::InternalClientError,
                           audacity::ToUTF8(copyBlocksStatement.GetError()
                                               .GetErrorString()
                                               .Translation()) });
 
               return false;
            }
 
            auto result = copyBlocksStatement->Prepare(block).Run();
 
            if (!result.IsOk())
            {
               OnFailure({ SyncResultCode::InternalClientError,
                           audacity::ToUTF8(result.GetErrors()
                                               .front()
                                               .GetErrorString()
                                               .Translation()) });
               return false;
            }
 
            const auto rowsUpdated = result.GetModifiedRowsCount();
            mCopiedBlocks.fetch_add(rowsUpdated, std::memory_order_acq_rel);
 
            ReportProgress();
         }
 
         return true;
      });
}

References audacity::sqlite::Connection::CreateStatement(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::Get(), audacity::cloud::audiocom::sync::CloudProjectsDatabase::GetConnection(), InProgress(), audacity::cloud::audiocom::InternalClientError, mCopiedBlocks, mCopyBlocksFuture, mSnapshotDBName, OnFailure(), ReportProgress(), and audacity::ToUTF8().

Referenced by RemoteProjectSnapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Sync()

std::shared_ptr< RemoteProjectSnapshot > audacity::cloud::audiocom::sync::RemoteProjectSnapshot::Sync	(	ProjectInfo	projectInfo,
		SnapshotInfo	snapshotInfo,
		std::string	path,
		RemoteProjectSnapshotStateCallback	callback,
		bool	downloadDetached
	)

static

Definition at line 168 of file RemoteProjectSnapshot.cpp.

{
   auto snapshot = std::make_shared<RemoteProjectSnapshot>(
      Tag {}, std::move(projectInfo), std::move(snapshotInfo), std::move(path),
      std::move(callback), downloadDetached);
 
   if (snapshot->mAttachedDBNames.empty())
   {
      snapshot->mCallback(
         { { SyncResultCode::InternalClientError,
             audacity::ToUTF8(
                XO("Failed to attach to the Cloud project database")
                   .Translation()) },
           0,
           0,
           false });
 
      return {};
   }
 
   if (snapshot->mNothingToDo)
      return {};
 
   return snapshot;
}

References audacity::cloud::audiocom::InternalClientError, audacity::ToUTF8(), and XO().

Here is the call graph for this function:

Member Data Documentation

◆ mAttachedDBNames

std::vector<std::string> audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mAttachedDBNames

private

Definition at line 129 of file RemoteProjectSnapshot.h.

Referenced by AttachOriginalDB(), and RemoteProjectSnapshot().

◆ mCallback

RemoteProjectSnapshotStateCallback audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mCallback

private

Definition at line 127 of file RemoteProjectSnapshot.h.

Referenced by Cancel(), and RemoteProjectSnapshot().

◆ mCopiedBlocks

std::atomic<int64_t> audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mCopiedBlocks { 0 }

private

Definition at line 154 of file RemoteProjectSnapshot.h.

Referenced by Cancel(), and SetupBlocksCopy().

◆ mCopyBlocksFuture

std::optional<std::future<bool> > audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mCopyBlocksFuture

private

Definition at line 159 of file RemoteProjectSnapshot.h.

Referenced by SetupBlocksCopy(), and ~RemoteProjectSnapshot().

◆ mDownloadDetached

const bool audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mDownloadDetached { false }

private

Definition at line 164 of file RemoteProjectSnapshot.h.

Referenced by RemoteProjectSnapshot().

◆ mDownloadedBlocks

std::atomic<int64_t> audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mDownloadedBlocks { 0 }

private

Definition at line 153 of file RemoteProjectSnapshot.h.

Referenced by Cancel(), and GetTransferStats().

◆ mDownloadedBytes

std::atomic<int64_t> audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mDownloadedBytes { 0 }

private

Definition at line 155 of file RemoteProjectSnapshot.h.

Referenced by DownloadBlob(), and GetTransferStats().

◆ mEndTime

TimePoint audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mEndTime

private

Definition at line 137 of file RemoteProjectSnapshot.h.

Referenced by GetTransferStats().

◆ mMissingBlocks

int64_t audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mMissingBlocks { 0 }

private

Definition at line 157 of file RemoteProjectSnapshot.h.

Referenced by Cancel(), and RemoteProjectSnapshot().

◆ mNextRequestIndex

size_t audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mNextRequestIndex { 0 }

private

Definition at line 146 of file RemoteProjectSnapshot.h.

◆ mNothingToDo

bool audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mNothingToDo { false }

private

Definition at line 163 of file RemoteProjectSnapshot.h.

Referenced by RemoteProjectSnapshot().

◆ mPath

const std::string audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mPath

private

Definition at line 126 of file RemoteProjectSnapshot.h.

Referenced by RemoteProjectSnapshot().

◆ mProjectDownloaded

std::atomic<bool> audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mProjectDownloaded { false }

private

Definition at line 161 of file RemoteProjectSnapshot.h.

Referenced by Cancel(), and GetTransferStats().

◆ mProjectInfo

const ProjectInfo audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mProjectInfo

private

Definition at line 124 of file RemoteProjectSnapshot.h.

Referenced by AttachOriginalDB(), CalculateKnownBlocks(), GetProjectId(), and RemoteProjectSnapshot().

◆ mRequests

std::vector<std::pair<std::string, SuccessHandler> > audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mRequests

private

Definition at line 143 of file RemoteProjectSnapshot.h.

Referenced by RemoteProjectSnapshot().

◆ mRequestsCV

std::condition_variable audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mRequestsCV

private

Definition at line 141 of file RemoteProjectSnapshot.h.

Referenced by DoCancel().

◆ mRequestsInProgress

int audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mRequestsInProgress { 0 }

private

Definition at line 145 of file RemoteProjectSnapshot.h.

◆ mRequestsMutex

std::mutex audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mRequestsMutex

private

Definition at line 140 of file RemoteProjectSnapshot.h.

◆ mRequestsThread

std::thread audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mRequestsThread

private

Definition at line 139 of file RemoteProjectSnapshot.h.

Referenced by RemoteProjectSnapshot(), and ~RemoteProjectSnapshot().

◆ mResponses

std::vector<std::shared_ptr<audacity::network_manager::IResponse> > audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mResponses

private

Definition at line 150 of file RemoteProjectSnapshot.h.

Referenced by DoCancel(), DownloadBlob(), and ~RemoteProjectSnapshot().

◆ mResponsesEmptyCV

std::condition_variable audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mResponsesEmptyCV

private

Definition at line 151 of file RemoteProjectSnapshot.h.

Referenced by ~RemoteProjectSnapshot().

◆ mResponsesMutex

std::mutex audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mResponsesMutex

private

Definition at line 148 of file RemoteProjectSnapshot.h.

Referenced by DoCancel(), DownloadBlob(), and ~RemoteProjectSnapshot().

◆ mSnapshotDBName

const std::string audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mSnapshotDBName

private

Definition at line 123 of file RemoteProjectSnapshot.h.

Referenced by RemoteProjectSnapshot(), and SetupBlocksCopy().

◆ mSnapshotInfo

const SnapshotInfo audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mSnapshotInfo

private

Definition at line 125 of file RemoteProjectSnapshot.h.

Referenced by CalculateKnownBlocks(), and RemoteProjectSnapshot().

◆ mStartTime

TimePoint audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mStartTime { Clock::now() }

private

Definition at line 136 of file RemoteProjectSnapshot.h.

Referenced by GetTransferStats().

◆ mState

std::atomic<State> audacity::cloud::audiocom::sync::RemoteProjectSnapshot::mState { State::Downloading }

private

Definition at line 131 of file RemoteProjectSnapshot.h.

Referenced by DoCancel(), and GetTransferStats().

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

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Clock

◆ SuccessHandler

◆ TimePoint

Member Enumeration Documentation

◆ State

Constructor & Destructor Documentation

◆ RemoteProjectSnapshot() [1/3]

◆ ~RemoteProjectSnapshot()

◆ RemoteProjectSnapshot() [2/3]

◆ RemoteProjectSnapshot() [3/3]

Member Function Documentation

◆ AttachOriginalDB()

◆ CalculateKnownBlocks()

◆ Cancel()

◆ CleanupOrphanBlocks()

◆ DoCancel()

◆ DownloadBlob()

◆ GetProjectId()

◆ GetTransferStats()

◆ InProgress()

◆ MarkProjectInDB()

◆ OnBlockDownloaded()

◆ OnFailure()

◆ OnProjectBlobDownloaded()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ RemoveResponse()

◆ ReportProgress()

◆ RequestsThread()

◆ SetState()

◆ SetupBlocksCopy()

◆ Sync()

Member Data Documentation

◆ mAttachedDBNames

◆ mCallback

◆ mCopiedBlocks

◆ mCopyBlocksFuture

◆ mDownloadDetached

◆ mDownloadedBlocks

◆ mDownloadedBytes

◆ mEndTime

◆ mMissingBlocks

◆ mNextRequestIndex

◆ mNothingToDo

◆ mPath

◆ mProjectDownloaded

◆ mProjectInfo

◆ mRequests

◆ mRequestsCV

◆ mRequestsInProgress

◆ mRequestsMutex

◆ mRequestsThread

◆ mResponses

◆ mResponsesEmptyCV

◆ mResponsesMutex

◆ mSnapshotDBName

◆ mSnapshotInfo

◆ mStartTime

◆ mState