1840 lines
58 KiB
C++
1840 lines
58 KiB
C++
/**********************************************************************
|
|
|
|
Audacity: A Digital Audio Editor
|
|
Audacity(R) is copyright (c) 1999-2008 Audacity Team.
|
|
License: GPL v2. See License.txt.
|
|
|
|
DirManager.cpp
|
|
|
|
Dominic Mazzoni
|
|
Matt Brubeck
|
|
Michael Chinen
|
|
James Crook
|
|
Al Dimond
|
|
Brian Gunlogson
|
|
Josh Haberman
|
|
Vaughan Johnson
|
|
Leland Lucius
|
|
Monty
|
|
Markus Meyer
|
|
|
|
*******************************************************************//*!
|
|
|
|
\class DirManager
|
|
\brief Creates and manages BlockFile objects.
|
|
|
|
This class manages the files that a project uses to store most
|
|
of its data. It creates NEW BlockFile objects, which can
|
|
be used to store any type of data. BlockFiles support all of
|
|
the common file operations, but they also support reference
|
|
counting, so two different parts of a project can point to
|
|
the same block of data.
|
|
|
|
For example, a track might contain 10 blocks of data representing
|
|
its audio. If you copy the last 5 blocks and paste at the
|
|
end of the file, no NEW blocks need to be created - we just store
|
|
pointers to NEW ones. When part of a track is deleted, the
|
|
affected blocks decrement their reference counts, and when they
|
|
reach zero they are deleted. This same mechanism is also used
|
|
to implement Undo.
|
|
|
|
The DirManager, besides mapping filenames to absolute paths,
|
|
also hashes all of the block names used in a project, so that
|
|
when reading a project from disk, multiple copies of the
|
|
same block still get mapped to the same BlockFile object.
|
|
|
|
The blockfile/directory scheme is rather complicated with two different schemes.
|
|
The current scheme uses two levels of subdirectories - up to 256 'eXX' and up to
|
|
256 'dYY' directories within each of the 'eXX' dirs, where XX and YY are hex chars.
|
|
In each of the dXX directories there are up to 256 audio files (e.g. .au or .auf).
|
|
They have a filename scheme of 'eXXYYZZZZ', where XX and YY refers to the
|
|
subdirectories as above. The 'ZZZZ' component is generated randomly for some reason.
|
|
The XX and YY components are sequential.
|
|
DirManager fills up the current dYY subdir until 256 are created, and moves on to the next one.
|
|
|
|
So for example, the first blockfile created may be 'e00/d00/e0000a23b.au' and the next
|
|
'e00/d00/e000015e8.au', and the 257th may be 'e00/d01/e0001f02a.au'.
|
|
On close the blockfiles that are no longer referenced by the project (edited or deleted) are removed,
|
|
along with the consequent empty directories.
|
|
|
|
|
|
*//*******************************************************************/
|
|
|
|
|
|
#include "Audacity.h" // for __UNIX__
|
|
#include "DirManager.h"
|
|
|
|
#include <time.h> // to use time() for srand()
|
|
|
|
#include <wx/wxcrtvararg.h>
|
|
#include <wx/defs.h>
|
|
#include <wx/dir.h>
|
|
#include <wx/log.h>
|
|
#include <wx/filefn.h>
|
|
#include <wx/hash.h>
|
|
#include <wx/timer.h>
|
|
#include <wx/intl.h>
|
|
#include <wx/file.h>
|
|
#include <wx/filename.h>
|
|
#include <wx/object.h>
|
|
|
|
// chmod
|
|
#ifdef __UNIX__
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#endif
|
|
|
|
#include "BlockFile.h"
|
|
#include "FileNames.h"
|
|
#include "InconsistencyException.h"
|
|
#include "Prefs.h"
|
|
#include "Project.h"
|
|
#include "widgets/Warning.h"
|
|
#include "widgets/AudacityMessageBox.h"
|
|
#include "widgets/ProgressDialog.h"
|
|
|
|
#if defined(__WXMAC__)
|
|
#include <mach/mach.h>
|
|
#include <mach/vm_statistics.h>
|
|
#endif
|
|
|
|
|
|
wxMemorySize GetFreeMemory()
|
|
{
|
|
wxMemorySize avail;
|
|
|
|
#if defined(__WXMAC__)
|
|
mach_port_t port = mach_host_self();
|
|
mach_msg_type_number_t cnt = HOST_VM_INFO_COUNT;
|
|
vm_statistics_data_t stats;
|
|
vm_size_t pagesize = 0;
|
|
|
|
memset(&stats, 0, sizeof(stats));
|
|
|
|
host_page_size(port, &pagesize);
|
|
host_statistics(port, HOST_VM_INFO, (host_info_t) &stats, &cnt);
|
|
avail = stats.free_count * pagesize;
|
|
#else
|
|
avail = wxGetFreeMemory();
|
|
#endif
|
|
|
|
return avail;
|
|
}
|
|
|
|
//
|
|
// local helper functions for subdirectory traversal
|
|
//
|
|
|
|
// Behavior of RecursivelyEnumerate is tailored to our uses and not
|
|
// entirely straightforward. We use it only for recursing into
|
|
// Audacity projects, but beware that it may be applied to a directory
|
|
// that contains other things too, for example a temp directory.
|
|
// It recurses depth-first from the passed-
|
|
// in directory into its subdirs according to optional dirspec
|
|
// pattern, building a list of directories and (optionally) files
|
|
// in the listed order.
|
|
// The dirspec is not applied to subdirs of subdirs.
|
|
// The filespec is applied to all files in subdirectories.
|
|
// Files in the passed-in directory will not be
|
|
// enumerated. Also, the passed-in directory is the last entry added
|
|
// to the list.
|
|
// JKC: Using flag wxDIR_NO_FOLLOW to NOT follow symbolic links.
|
|
// Directories and files inside a project should never be symbolic
|
|
// links, so if we find one, do not follow it.
|
|
int DirManager::RecursivelyEnumerate(const FilePath &dirPath,
|
|
FilePaths& filePathArray, // output: all files in dirPath tree
|
|
wxString dirspec,
|
|
wxString filespec,
|
|
bool bFiles, bool bDirs,
|
|
int progress_count,
|
|
int progress_bias,
|
|
ProgressDialog* progress)
|
|
{
|
|
int count=0;
|
|
bool cont;
|
|
|
|
wxDir dir(dirPath);
|
|
if(dir.IsOpened()){
|
|
wxString name;
|
|
|
|
// Don't DELETE files from a selective top level, e.g. if handed "projects*" as the
|
|
// directory specifier.
|
|
if (bFiles && dirspec.empty() ){
|
|
cont= dir.GetFirst(&name, filespec, wxDIR_FILES | wxDIR_HIDDEN | wxDIR_NO_FOLLOW);
|
|
while ( cont ){
|
|
FilePath filepath = dirPath + wxFILE_SEP_PATH + name;
|
|
|
|
count++;
|
|
filePathArray.push_back(filepath);
|
|
|
|
cont = dir.GetNext(&name);
|
|
|
|
if (progress)
|
|
progress->Update(count + progress_bias,
|
|
progress_count);
|
|
}
|
|
}
|
|
|
|
cont= dir.GetFirst(&name, dirspec, wxDIR_DIRS | wxDIR_NO_FOLLOW);
|
|
while ( cont ){
|
|
FilePath subdirPath = dirPath + wxFILE_SEP_PATH + name;
|
|
count += RecursivelyEnumerate(
|
|
subdirPath, filePathArray, wxEmptyString,filespec,
|
|
bFiles, bDirs,
|
|
progress_count, count + progress_bias,
|
|
progress);
|
|
cont = dir.GetNext(&name);
|
|
}
|
|
}
|
|
|
|
if (bDirs) {
|
|
filePathArray.push_back(dirPath);
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
int DirManager::RecursivelyEnumerateWithProgress(const FilePath &dirPath,
|
|
FilePaths& filePathArray, // output: all files in dirPath tree
|
|
wxString dirspec,
|
|
wxString filespec,
|
|
bool bFiles, bool bDirs,
|
|
int progress_count,
|
|
const TranslatableString &message)
|
|
{
|
|
Optional<ProgressDialog> progress{};
|
|
|
|
if (!message.empty())
|
|
progress.emplace( XO("Progress"), message );
|
|
|
|
int count = RecursivelyEnumerate(
|
|
dirPath, filePathArray, dirspec,filespec,
|
|
bFiles, bDirs,
|
|
progress_count, 0,
|
|
progress ? &*progress : nullptr);
|
|
|
|
return count;
|
|
}
|
|
|
|
int DirManager::RecursivelyCountSubdirs( const FilePath &dirPath )
|
|
{
|
|
bool bContinue;
|
|
int nCount = 0;
|
|
wxDir dir(dirPath);
|
|
if (dir.IsOpened() && dir.HasSubDirs())
|
|
{
|
|
wxString name;
|
|
bContinue = dir.GetFirst(&name, wxEmptyString, wxDIR_DIRS);
|
|
while (bContinue)
|
|
{
|
|
nCount++;
|
|
FilePath subdirPath = dirPath + wxFILE_SEP_PATH + name;
|
|
nCount += RecursivelyCountSubdirs(subdirPath);
|
|
bContinue = dir.GetNext(&name);
|
|
}
|
|
}
|
|
return nCount;
|
|
}
|
|
|
|
int DirManager::RecursivelyRemoveEmptyDirs(const FilePath &dirPath,
|
|
int nDirCount,
|
|
ProgressDialog* pProgress)
|
|
{
|
|
bool bContinue;
|
|
wxDir dir(dirPath);
|
|
int nCount = 0;
|
|
if (dir.IsOpened())
|
|
{
|
|
if (dir.HasSubDirs())
|
|
{
|
|
wxString name;
|
|
bContinue = dir.GetFirst(&name, wxEmptyString, wxDIR_DIRS);
|
|
while (bContinue)
|
|
{
|
|
FilePath subdirPath = dirPath + wxFILE_SEP_PATH + name;
|
|
nCount += RecursivelyRemoveEmptyDirs(subdirPath, nDirCount, pProgress);
|
|
bContinue = dir.GetNext(&name);
|
|
}
|
|
}
|
|
// Have to recheck dir.HasSubDirs() again, in case they all were deleted in recursive calls.
|
|
if (!dir.HasSubDirs() && !dir.HasFiles() && (dirPath.Right(5) != wxT("_data")))
|
|
{
|
|
// No subdirs or files. It's empty so DELETE it.
|
|
// Vaughan, 2010-07-07:
|
|
// Note that, per http://src.chromium.org/svn/trunk/src/base/file_util_win.cc, among others,
|
|
// "Some versions of Windows return ERROR_FILE_NOT_FOUND (0x2) when deleting
|
|
// an empty directory..." Supposedly fixed in Vista and up.
|
|
// I discovered this on WinXP. I tried several other Windows SDK functions (e.g., _rmdir
|
|
// and RemoveDirectory), and they all give same results.
|
|
// I noticed dirs get deleted in RecursivelyRemove, maybe because it doesn't
|
|
// consider whether the path is a directory or a file and wxRemoveFile()'s it first.
|
|
// Tried it here on WinXP, but no joy. Leave the code in case it works on other Win systems.
|
|
#ifdef __WXMSW__
|
|
::wxRemoveFile(dirPath);
|
|
#endif
|
|
::wxRmdir(dirPath);
|
|
}
|
|
nCount++; // Count dirPath in progress.
|
|
if (pProgress)
|
|
pProgress->Update(nCount, nDirCount);
|
|
}
|
|
return nCount;
|
|
}
|
|
|
|
void DirManager::RecursivelyRemove(const FilePaths& filePathArray, int count, int bias,
|
|
int flags, const TranslatableString &message)
|
|
{
|
|
bool bFiles= (flags & kCleanFiles) != 0;
|
|
bool bDirs = (flags & kCleanDirs) != 0;
|
|
bool bDirsMustBeEmpty = (flags & kCleanDirsOnlyIfEmpty) != 0;
|
|
Optional<ProgressDialog> progress{};
|
|
|
|
|
|
if (!message.empty())
|
|
progress.emplace( XO("Progress"), message );
|
|
|
|
auto nn = filePathArray.size();
|
|
for ( size_t ii = 0; ii < nn; ++ii ) {
|
|
const auto &file = filePathArray[ ii ];
|
|
if (bFiles)
|
|
::wxRemoveFile(file);
|
|
if (bDirs) {
|
|
// continue will go to the next item, and skip
|
|
// attempting to delete the directory.
|
|
if( bDirsMustBeEmpty ){
|
|
wxDir dir( file );
|
|
if( !dir.IsOpened() )
|
|
continue;
|
|
if( dir.HasFiles() )
|
|
continue;
|
|
if( dir.HasSubDirs() )
|
|
continue;
|
|
}
|
|
|
|
#ifdef __WXMSW__
|
|
if (!bFiles)
|
|
::wxRemoveFile(file); // See note above about wxRmdir sometimes incorrectly failing on Windows.
|
|
#endif
|
|
|
|
if (! ::wxRmdir(file) ) {
|
|
wxDir dir(file);
|
|
if(dir.IsOpened()) {
|
|
wxLogMessage(file + wxString(" still contains:"));
|
|
wxString name;
|
|
auto cont = dir.GetFirst(&name);
|
|
while ( cont ) {
|
|
wxLogMessage(file + wxString(wxFILE_SEP_PATH) + name );
|
|
cont = dir.GetNext(&name);
|
|
}
|
|
}
|
|
else
|
|
wxLogMessage(wxString("Can't enumerate directory ") + file);
|
|
}
|
|
}
|
|
if (progress)
|
|
progress->Update((int) ii + bias, count);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// DirManager
|
|
//
|
|
|
|
// Static class variables
|
|
wxString DirManager::globaltemp;
|
|
int DirManager::numDirManagers = 0;
|
|
bool DirManager::dontDeleteTempFiles = false;
|
|
|
|
namespace {
|
|
|
|
// Global tracking of all outstanding DirManagers
|
|
std::vector< std::weak_ptr< DirManager > > sDirManagers;
|
|
|
|
}
|
|
|
|
std::shared_ptr<DirManager> DirManager::Create()
|
|
{
|
|
auto result = std::shared_ptr< DirManager >( safenew DirManager );
|
|
sDirManagers.push_back( result );
|
|
return result;
|
|
}
|
|
|
|
static const AudacityProject::AttachedObjects::RegisteredFactory key{
|
|
[](AudacityProject&) { return DirManager::Create(); }
|
|
};
|
|
|
|
DirManager &DirManager::Get( AudacityProject &project )
|
|
{
|
|
return project.AttachedObjects::Get< DirManager >( key );
|
|
}
|
|
|
|
const DirManager &DirManager::Get( const AudacityProject &project )
|
|
{
|
|
return Get( const_cast< AudacityProject & >( project ) );
|
|
}
|
|
|
|
DirManager &DirManager::Reset( AudacityProject &project )
|
|
{
|
|
auto dirManager = DirManager::Create();
|
|
project.AttachedObjects::Assign( key, dirManager );
|
|
return *dirManager;
|
|
}
|
|
|
|
void DirManager::Destroy( AudacityProject &project )
|
|
{
|
|
project.AttachedObjects::Assign( key, nullptr );
|
|
}
|
|
|
|
DirManager::DirManager()
|
|
{
|
|
wxLogDebug(wxT("DirManager: Created new instance."));
|
|
|
|
mLastBlockFileDestructionCount = BlockFile::gBlockFileDestructionCount;
|
|
|
|
// Seed the random number generator.
|
|
// this need not be strictly uniform or random, but it should give
|
|
// unclustered numbers
|
|
srand(time(NULL));
|
|
|
|
// Set up local temp subdir
|
|
// Previously, Audacity just named project temp directories "project0",
|
|
// "project1" and so on. But with the advent of recovery code, we need a
|
|
// unique name even after a crash. So we create a random project index
|
|
// and make sure it is not used already. This will not pose any performance
|
|
// penalties as long as the number of open Audacity projects is much
|
|
// lower than RAND_MAX.
|
|
do {
|
|
mytemp = globaltemp + wxFILE_SEP_PATH +
|
|
wxString::Format(wxT("project%d"), rand());
|
|
} while (wxDirExists(mytemp));
|
|
|
|
numDirManagers++;
|
|
|
|
projPath = wxT("");
|
|
projName = wxT("");
|
|
|
|
mMaxSamples = ~size_t(0);
|
|
|
|
// toplevel pool hash is fully populated to begin
|
|
{
|
|
// We can bypass the accessor function while initializing
|
|
auto &balanceInfo = mBalanceInfo;
|
|
auto &dirTopPool = balanceInfo.dirTopPool;
|
|
for(int i = 0; i < 256; ++i)
|
|
dirTopPool[i] = 0;
|
|
}
|
|
|
|
// Make sure there is plenty of space for temp files
|
|
wxLongLong freeSpace = 0;
|
|
if (wxGetDiskSpace(globaltemp, NULL, &freeSpace)) {
|
|
if (freeSpace < wxLongLong(wxLL(100 * 1048576))) {
|
|
ShowWarningDialog(NULL, wxT("DiskSpaceWarning"),
|
|
XO("There is very little free disk space left on this volume.\nPlease select another temporary directory in Preferences."));
|
|
}
|
|
}
|
|
}
|
|
|
|
DirManager::~DirManager()
|
|
{
|
|
auto start = sDirManagers.begin(), finish = sDirManagers.end(),
|
|
iter = std::remove_if( start, finish,
|
|
[=]( const std::weak_ptr<DirManager> &ptr ){
|
|
return ptr.expired() || ptr.lock().get() == this;
|
|
} );
|
|
sDirManagers.erase( iter, finish );
|
|
|
|
numDirManagers--;
|
|
if (numDirManagers == 0) {
|
|
CleanTempDir();
|
|
//::wxRmdir(temp);
|
|
} else if( projFull.empty() && !mytemp.empty()) {
|
|
CleanDir(mytemp, wxEmptyString, ".DS_Store", XO("Cleaning project temporary files"), kCleanTopDirToo | kCleanDirsOnlyIfEmpty );
|
|
}
|
|
}
|
|
|
|
|
|
// static
|
|
// This is quite a dangerous function. In the temp dir it will DELETE every directory
|
|
// recursively, that has 'project*' as the name - EVEN if it happens not to be an Audacity
|
|
// project but just something else called project.
|
|
void DirManager::CleanTempDir()
|
|
{
|
|
// with default flags (none) this does not clean the top directory, and may remove non-empty
|
|
// directories.
|
|
CleanDir(globaltemp, wxT("project*"), wxEmptyString, XO("Cleaning up temporary files"));
|
|
}
|
|
|
|
// static
|
|
void DirManager::CleanDir(
|
|
const FilePath &path,
|
|
const wxString &dirSpec,
|
|
const wxString &fileSpec,
|
|
const TranslatableString &msg,
|
|
int flags)
|
|
{
|
|
if (dontDeleteTempFiles)
|
|
return; // do nothing
|
|
|
|
FilePaths filePathArray, dirPathArray;
|
|
|
|
int countFiles =
|
|
RecursivelyEnumerate(path, filePathArray, dirSpec, fileSpec, true, false);
|
|
int countDirs =
|
|
RecursivelyEnumerate(path, dirPathArray, dirSpec, fileSpec, false, true);
|
|
|
|
// Subtract 1 because we don't want to DELETE the global temp directory,
|
|
// which this will find and list last.
|
|
if ((flags & kCleanTopDirToo)==0) {
|
|
// Remove the globaltemp itself from the array so that it is not deleted.
|
|
--countDirs;
|
|
dirPathArray.resize(countDirs);
|
|
}
|
|
|
|
auto count = countFiles + countDirs;
|
|
if (count == 0)
|
|
return;
|
|
|
|
RecursivelyRemove(filePathArray, count, 0, flags | kCleanFiles, msg);
|
|
RecursivelyRemove(dirPathArray, count, countFiles, flags | kCleanDirs, msg);
|
|
}
|
|
|
|
namespace {
|
|
struct PathRestorer {
|
|
PathRestorer(
|
|
bool &commitFlag, FilePath &path, FilePath &name, FilePath &full )
|
|
: committed( commitFlag )
|
|
|
|
, projPath( path )
|
|
, projName( name )
|
|
, projFull( full )
|
|
|
|
, oldPath( path )
|
|
, oldName( name )
|
|
, oldFull( full )
|
|
{}
|
|
|
|
~PathRestorer()
|
|
{
|
|
if (!committed)
|
|
projFull = oldFull, projName = oldName, projPath = oldPath;
|
|
}
|
|
|
|
bool &committed;
|
|
FilePath &projPath, &projName, &projFull;
|
|
const FilePath oldPath, oldName, oldFull;
|
|
};
|
|
|
|
struct DirCleaner {
|
|
DirCleaner( bool &commitFlag, const FilePath &path )
|
|
: committed( commitFlag )
|
|
, fullPath( path )
|
|
{}
|
|
~DirCleaner()
|
|
{
|
|
if (!committed)
|
|
DirManager::CleanDir(
|
|
fullPath,
|
|
wxEmptyString,
|
|
wxEmptyString,
|
|
XO("Cleaning up after failed save"),
|
|
kCleanTopDirToo);
|
|
}
|
|
|
|
bool &committed;
|
|
FilePath fullPath;
|
|
};
|
|
}
|
|
|
|
struct DirManager::ProjectSetter::Impl
|
|
{
|
|
Impl(
|
|
DirManager &dm,
|
|
FilePath& newProjPath, const FilePath& newProjName, const bool bCreate,
|
|
bool moving );
|
|
|
|
void Commit();
|
|
|
|
DirManager &dirManager;
|
|
bool committed{ false };
|
|
|
|
// RAII object
|
|
// Save old state of paths in case of failure
|
|
PathRestorer pathRestorer{
|
|
committed,
|
|
dirManager.projPath, dirManager.projName, dirManager.projFull };
|
|
|
|
// Another RAII object
|
|
// Be prepared to un-create directory on failure
|
|
Optional<DirCleaner> dirCleaner;
|
|
|
|
// State variables to carry over into Commit()
|
|
// Remember old path to be cleaned up in case of successful move
|
|
FilePath oldFull{ dirManager.projFull };
|
|
FilePaths newPaths;
|
|
size_t trueTotal{ 0 };
|
|
bool moving{ true };
|
|
|
|
// Make this true only after successful construction
|
|
bool ok{ false };
|
|
};
|
|
|
|
DirManager::ProjectSetter::ProjectSetter(
|
|
DirManager &dirManager,
|
|
FilePath& newProjPath, const FilePath& newProjName, const bool bCreate,
|
|
bool moving )
|
|
: mpImpl{
|
|
std::make_unique<Impl>( dirManager, newProjPath, newProjName, bCreate,
|
|
moving )
|
|
}
|
|
{
|
|
|
|
}
|
|
|
|
DirManager::ProjectSetter::~ProjectSetter()
|
|
{
|
|
}
|
|
|
|
bool DirManager::ProjectSetter::Ok()
|
|
{
|
|
return mpImpl->ok;
|
|
}
|
|
|
|
|
|
void DirManager::ProjectSetter::Commit()
|
|
{
|
|
mpImpl->Commit();
|
|
}
|
|
|
|
DirManager::ProjectSetter::Impl::Impl(
|
|
DirManager &dm,
|
|
FilePath& newProjPath, const FilePath& newProjName, const bool bCreate,
|
|
bool moving_ )
|
|
: dirManager{ dm }
|
|
, moving{ moving_ }
|
|
{
|
|
// Choose new paths
|
|
if (newProjPath.empty())
|
|
newProjPath = ::wxGetCwd();
|
|
|
|
dirManager.projPath = newProjPath;
|
|
dirManager.projName = newProjName;
|
|
if (newProjPath.Last() == wxFILE_SEP_PATH)
|
|
dirManager.projFull = newProjPath + newProjName;
|
|
else
|
|
dirManager.projFull = newProjPath + wxFILE_SEP_PATH + newProjName;
|
|
|
|
// Verify new paths, maybe creating a directory
|
|
if (bCreate) {
|
|
if (!wxDirExists(dirManager.projFull) &&
|
|
!wxMkdir(dirManager.projFull))
|
|
return;
|
|
|
|
#ifdef __UNIX__
|
|
chmod(OSFILENAME(dirManager.projFull), 0775);
|
|
#endif
|
|
|
|
#ifdef __WXMAC__
|
|
chmod(OSFILENAME(dirManager.projFull), 0775);
|
|
#endif
|
|
|
|
}
|
|
else if (!wxDirExists(dirManager.projFull))
|
|
return;
|
|
|
|
// Be prepared to un-create directory on failure
|
|
if (bCreate)
|
|
dirCleaner.emplace( committed, dirManager.projFull );
|
|
|
|
/* Hard-link or copy all files into this NEW directory.
|
|
|
|
If any files are "locked" then all get copied. (This happens when
|
|
we perform a Save As - the files which belonged to the last
|
|
saved version of the old project must not be removed because of operations
|
|
on the NEW project, otherwise the old project would not be safe.)
|
|
|
|
Copy also happens anyway when hard file links are not possible, as when
|
|
saving the project for the first time out of temporary storage and onto
|
|
some other storage device.
|
|
|
|
Renaming would also be cheap like hard-linking, but linking is better
|
|
because it builds up a new tree of files without destroying anything in
|
|
the old tree. That destruction can be left to a commit phase which
|
|
proceeds only when all the building of the new tree has succeeded.
|
|
*/
|
|
|
|
/* Bug2059: Don't deduce whether moving or copying just from the block
|
|
files, because an empty project, or one that was empty in its last saved
|
|
state, may have had no block files to lock.
|
|
Must treat as a copy if any is locked, but may also treat as copy if
|
|
the constructor argument tells us so.
|
|
With this change, the empty _data folder of the empty source project
|
|
will not be deleted in Commit().
|
|
*/
|
|
|
|
moving = moving && ! std::any_of(
|
|
dirManager.mBlockFileHash.begin(), dirManager.mBlockFileHash.end(),
|
|
[]( const BlockHash::value_type &pair ){
|
|
auto b = pair.second.lock();
|
|
return b && b->IsLocked();
|
|
}
|
|
);
|
|
|
|
trueTotal = 0;
|
|
|
|
{
|
|
/* i18n-hint: This title appears on a dialog that indicates the progress
|
|
in doing something.*/
|
|
ProgressDialog progress(XO("Progress"),
|
|
XO("Saving project data files"));
|
|
|
|
int total = dirManager.mBlockFileHash.size();
|
|
|
|
bool link = moving;
|
|
for (const auto &pair : dirManager.mBlockFileHash) {
|
|
if( progress.Update((int) newPaths.size(), total) != ProgressResult::Success )
|
|
return;
|
|
|
|
FilePath newPath;
|
|
if (auto b = pair.second.lock()) {
|
|
auto result =
|
|
dirManager.LinkOrCopyToNewProjectDirectory( &*b, link );
|
|
if (!result.first)
|
|
return;
|
|
newPath = result.second;
|
|
++trueTotal;
|
|
}
|
|
newPaths.push_back( newPath );
|
|
}
|
|
}
|
|
|
|
ok = true;
|
|
}
|
|
|
|
void DirManager::ProjectSetter::Impl::Commit()
|
|
{
|
|
wxASSERT( ok );
|
|
|
|
// We have built all of the new file tree.
|
|
// So cancel the destructor actions of the RAII objects.
|
|
committed = true;
|
|
|
|
auto size = newPaths.size();
|
|
wxASSERT( size == dirManager.mBlockFileHash.size() );
|
|
|
|
// Commit changes to filenames in the BlockFile objects, and removal
|
|
// of files at old paths, ONLY NOW! This must be nothrow.
|
|
|
|
// This copy-then-delete procedure is needed to make it safe to
|
|
// attempt save to another storage device, but fail.
|
|
|
|
// It has the consequence that saving a project from one part of
|
|
// the device to another will not succeed unless there is sufficient
|
|
// space to hold originals and copies at the same time. Perhaps the
|
|
// extra cautions are not needed in that case, and the old procedure
|
|
// of renaming first, and reversing the renamings in case of failure,
|
|
// could still work safely.
|
|
|
|
// But I don't know whether wxWidgets gives us a reliable means to
|
|
// distinguish that case.
|
|
|
|
// I will err on the side of safety and simplicity and follow the
|
|
// same procedure in all cases.
|
|
|
|
size_t ii = 0;
|
|
for (const auto &pair : dirManager.mBlockFileHash)
|
|
{
|
|
BlockFilePtr b = pair.second.lock();
|
|
|
|
if (b) {
|
|
if (moving || !b->IsLocked()) {
|
|
auto result = b->GetFileName();
|
|
auto oldPath = result.name.GetFullPath();
|
|
if (!oldPath.empty())
|
|
wxRemoveFile( oldPath );
|
|
}
|
|
|
|
if (ii < size)
|
|
b->SetFileName(
|
|
wxFileNameWrapper{ wxFileName{ newPaths[ii] } } );
|
|
}
|
|
|
|
++ii;
|
|
}
|
|
|
|
// Some subtlety; SetProject is used both to move a temp project
|
|
// into a permanent home as well as just set up path variables when
|
|
// loading a project; in this latter case, the movement code does
|
|
// nothing because SetProject is called before there are any
|
|
// blockfiles. Cleanup code trigger is the same
|
|
|
|
// Do the cleanup of the temporary directory only if not saving-as, which we
|
|
// detect by having done copies rather than moves.
|
|
if (moving && trueTotal > 0) {
|
|
// Clean up after ourselves; boldly remove all files and directories
|
|
// in the tree. (Unlike what the earlier version of this comment said.)
|
|
// Because this is a relocation of the project, not the case of closing
|
|
// a persistent project.
|
|
|
|
// You may think the loops above guarantee that all files we put in the
|
|
// folders have been moved away already, but:
|
|
// to fix bug1567 on Mac, we need to find the extraneous .DS_Store files
|
|
// that we didn't put there, but that Finder may insert into the folders,
|
|
// and mercilessly remove them, in addition to removing the directories.
|
|
|
|
auto cleanupLoc1 = oldFull.empty() ? dirManager.mytemp : oldFull;
|
|
CleanDir(
|
|
cleanupLoc1,
|
|
wxEmptyString, // EmptyString => ALL directories.
|
|
// If the next line were wxEmptyString, ALL files would be removed.
|
|
".DS_Store", // Other project files should already have been removed.
|
|
XO("Cleaning up cache directories"),
|
|
kCleanTopDirToo);
|
|
|
|
//This destroys the empty dirs of the OD block files, which are yet to come.
|
|
//Dont know if this will make the project dirty, but I doubt it. (mchinen)
|
|
// count += RecursivelyEnumerate(cleanupLoc2, dirlist, wxEmptyString, false, true);
|
|
}
|
|
}
|
|
|
|
bool DirManager::SetProject(
|
|
FilePath& newProjPath, const FilePath& newProjName, const bool bCreate)
|
|
{
|
|
ProjectSetter setter{ *this, newProjPath, newProjName, bCreate, true };
|
|
if (!setter.Ok())
|
|
return false;
|
|
setter.Commit();
|
|
return true;
|
|
}
|
|
|
|
FilePath DirManager::GetProjectDataDir()
|
|
{
|
|
return projFull;
|
|
}
|
|
|
|
FilePath DirManager::GetProjectName()
|
|
{
|
|
return projName;
|
|
}
|
|
|
|
wxLongLong DirManager::GetFreeDiskSpace()
|
|
{
|
|
wxLongLong freeSpace = -1;
|
|
wxFileName path;
|
|
|
|
path.SetPath(projPath.empty() ? mytemp : projPath);
|
|
|
|
// Use the parent directory if the project directory hasn't yet been created
|
|
if (!path.DirExists())
|
|
{
|
|
path.RemoveLastDir();
|
|
}
|
|
|
|
if (!wxGetDiskSpace(path.GetFullPath(), NULL, &freeSpace))
|
|
{
|
|
freeSpace = -1;
|
|
}
|
|
|
|
return freeSpace;
|
|
}
|
|
|
|
FilePath DirManager::GetDataFilesDir() const
|
|
{
|
|
return !projFull.empty()? projFull: mytemp;
|
|
}
|
|
|
|
void DirManager::SetLocalTempDir(const wxString &path)
|
|
{
|
|
mytemp = path;
|
|
}
|
|
|
|
wxFileNameWrapper DirManager::MakeBlockFilePath(const wxString &value) {
|
|
|
|
wxFileNameWrapper dir;
|
|
dir.AssignDir(GetDataFilesDir());
|
|
|
|
if(value.GetChar(0)==wxT('d')){
|
|
// this file is located in a subdirectory tree
|
|
int location=value.Find(wxT('b'));
|
|
wxString subdir=value.Mid(0,location);
|
|
dir.AppendDir(subdir);
|
|
|
|
if(!dir.DirExists())
|
|
dir.Mkdir();
|
|
}
|
|
|
|
if(value.GetChar(0)==wxT('e')){
|
|
// this file is located in a NEW style two-deep subdirectory tree
|
|
wxString topdir=value.Mid(0,3);
|
|
wxString middir=wxT("d");
|
|
middir.Append(value.Mid(3,2));
|
|
|
|
dir.AppendDir(topdir);
|
|
dir.AppendDir(middir);
|
|
|
|
if(!dir.DirExists() && !dir.Mkdir(0777,wxPATH_MKDIR_FULL))
|
|
{ // need braces to avoid compiler warning about ambiguous else, see the macro
|
|
wxLogSysError(wxT("mkdir in DirManager::MakeBlockFilePath failed."));
|
|
}
|
|
}
|
|
return dir;
|
|
}
|
|
|
|
bool DirManager::AssignFile(wxFileNameWrapper &fileName,
|
|
const wxString &value,
|
|
bool diskcheck)
|
|
{
|
|
wxFileNameWrapper dir{ MakeBlockFilePath(value) };
|
|
|
|
if(diskcheck){
|
|
// verify that there's no possible collision on disk. If there
|
|
// is, log the problem and return FALSE so that MakeBlockFileName
|
|
// can try again
|
|
|
|
wxDir checkit(dir.GetFullPath());
|
|
if(!checkit.IsOpened()) return FALSE;
|
|
|
|
// this code is only valid if 'value' has no extension; that
|
|
// means, effectively, AssignFile may be called with 'diskcheck'
|
|
// set to true only if called from MakeFileBlockName().
|
|
|
|
wxString filespec;
|
|
filespec.Printf(wxT("%s.*"),value);
|
|
if(checkit.HasFiles(filespec)){
|
|
// collision with on-disk state!
|
|
wxString collision;
|
|
checkit.GetFirst(&collision,filespec);
|
|
|
|
wxLogWarning(wxT("Audacity found an orphan block file: %s. \nPlease consider saving and reloading the project to perform a complete project check."),
|
|
collision);
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
fileName.Assign(dir.GetFullPath(),value);
|
|
return fileName.IsOk();
|
|
}
|
|
|
|
static inline unsigned int hexchar_to_int(unsigned int x)
|
|
{
|
|
if(x<48U)return 0;
|
|
if(x<58U)return x-48U;
|
|
if(x<65U)return 10U;
|
|
if(x<71U)return x-55U;
|
|
if(x<97U)return 10U;
|
|
if(x<103U)return x-87U;
|
|
return 15U;
|
|
}
|
|
|
|
int DirManager::BalanceMidAdd(int topnum, int midkey)
|
|
{
|
|
// enter the midlevel directory if it doesn't exist
|
|
|
|
auto &balanceInfo = GetBalanceInfo();
|
|
auto &dirMidPool = balanceInfo.dirMidPool;
|
|
auto &dirMidFull = balanceInfo.dirMidFull;
|
|
auto &dirTopPool = balanceInfo.dirTopPool;
|
|
auto &dirTopFull = balanceInfo.dirTopFull;
|
|
|
|
if(dirMidPool.find(midkey) == dirMidPool.end() &&
|
|
dirMidFull.find(midkey) == dirMidFull.end()){
|
|
dirMidPool[midkey]=0;
|
|
|
|
// increment toplevel directory fill
|
|
dirTopPool[topnum]++;
|
|
if(dirTopPool[topnum]>=256){
|
|
// this toplevel is now full; move it to the full hash
|
|
dirTopPool.erase(topnum);
|
|
dirTopFull[topnum]=256;
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void DirManager::BalanceFileAdd(int midkey)
|
|
{
|
|
auto &balanceInfo = GetBalanceInfo();
|
|
auto &dirMidPool = balanceInfo.dirMidPool;
|
|
auto &dirMidFull = balanceInfo.dirMidFull;
|
|
|
|
// increment the midlevel directory usage information
|
|
if(dirMidPool.find(midkey) != dirMidPool.end()){
|
|
dirMidPool[midkey]++;
|
|
if(dirMidPool[midkey]>=256){
|
|
// this middir is now full; move it to the full hash
|
|
dirMidPool.erase(midkey);
|
|
dirMidFull[midkey]=256;
|
|
}
|
|
}else{
|
|
// this case only triggers in absurdly large projects; we still
|
|
// need to track directory fill even if we're over 256/256/256
|
|
dirMidPool[midkey]++;
|
|
}
|
|
}
|
|
|
|
void DirManager::BalanceInfoAdd(const wxString &file)
|
|
{
|
|
const wxChar *s=file;
|
|
if(s[0]==wxT('e')){
|
|
// this is one of the modern two-deep managed files
|
|
// convert filename to keys
|
|
unsigned int topnum = (hexchar_to_int(s[1]) << 4) |
|
|
hexchar_to_int(s[2]);
|
|
unsigned int midnum = (hexchar_to_int(s[3]) << 4) |
|
|
hexchar_to_int(s[4]);
|
|
unsigned int midkey=topnum<<8|midnum;
|
|
|
|
BalanceMidAdd(topnum,midkey);
|
|
BalanceFileAdd(midkey);
|
|
}
|
|
}
|
|
|
|
auto DirManager::GetBalanceInfo() -> BalanceInfo &
|
|
{
|
|
// Before returning the map,
|
|
// see whether any block files have disappeared,
|
|
// and if so update
|
|
|
|
auto count = BlockFile::gBlockFileDestructionCount;
|
|
if ( mLastBlockFileDestructionCount != count ) {
|
|
auto it = mBlockFileHash.begin(), end = mBlockFileHash.end();
|
|
while (it != end)
|
|
{
|
|
BlockFilePtr ptr { it->second.lock() };
|
|
if (!ptr) {
|
|
auto name = it->first;
|
|
mBlockFileHash.erase( it++ );
|
|
BalanceInfoDel( name );
|
|
}
|
|
else
|
|
++it;
|
|
}
|
|
}
|
|
|
|
mLastBlockFileDestructionCount = count;
|
|
|
|
return mBalanceInfo;
|
|
}
|
|
|
|
// Note that this will try to clean up directories out from under even
|
|
// locked blockfiles; this is actually harmless as the rmdir will fail
|
|
// on non-empty directories.
|
|
void DirManager::BalanceInfoDel(const wxString &file)
|
|
{
|
|
// do not use GetBalanceInfo(),
|
|
// rather this function will be called from there.
|
|
auto &balanceInfo = mBalanceInfo;
|
|
auto &dirMidPool = balanceInfo.dirMidPool;
|
|
auto &dirMidFull = balanceInfo.dirMidFull;
|
|
auto &dirTopPool = balanceInfo.dirTopPool;
|
|
auto &dirTopFull = balanceInfo.dirTopFull;
|
|
|
|
const wxChar *s=file;
|
|
if(s[0]==wxT('e')){
|
|
// this is one of the modern two-deep managed files
|
|
|
|
unsigned int topnum = (hexchar_to_int(s[1]) << 4) |
|
|
hexchar_to_int(s[2]);
|
|
unsigned int midnum = (hexchar_to_int(s[3]) << 4) |
|
|
hexchar_to_int(s[4]);
|
|
unsigned int midkey=topnum<<8|midnum;
|
|
|
|
// look for midkey in the mid pool
|
|
if(dirMidFull.find(midkey) != dirMidFull.end()){
|
|
// in the full pool
|
|
|
|
if(--dirMidFull[midkey]<256){
|
|
// move out of full into available
|
|
dirMidPool[midkey]=dirMidFull[midkey];
|
|
dirMidFull.erase(midkey);
|
|
}
|
|
}else{
|
|
if(--dirMidPool[midkey]<1){
|
|
// erasing the key here is OK; we have provision to add it
|
|
// back if its needed (unlike the dirTopPool hash)
|
|
dirMidPool.erase(midkey);
|
|
|
|
// DELETE the actual directory
|
|
auto dir = !projFull.empty() ? projFull : mytemp;
|
|
dir += wxFILE_SEP_PATH;
|
|
dir += file.Mid(0,3);
|
|
dir += wxFILE_SEP_PATH;
|
|
dir += wxT("d");
|
|
dir += file.Mid(3,2);
|
|
wxFileName::Rmdir(dir);
|
|
|
|
// also need to remove from toplevel
|
|
if(dirTopFull.find(topnum) != dirTopFull.end()){
|
|
// in the full pool
|
|
if(--dirTopFull[topnum]<256){
|
|
// move out of full into available
|
|
dirTopPool[topnum]=dirTopFull[topnum];
|
|
dirTopFull.erase(topnum);
|
|
}
|
|
}else{
|
|
if(--dirTopPool[topnum]<1){
|
|
// do *not* erase the hash entry from dirTopPool
|
|
// *do* DELETE the actual directory
|
|
dir=(!projFull.empty()? projFull: mytemp);
|
|
dir += wxFILE_SEP_PATH;
|
|
dir += file.Mid(0,3);
|
|
wxFileName::Rmdir(dir);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// only determines appropriate filename and subdir balance; does not
|
|
// perform maintainence
|
|
wxFileNameWrapper DirManager::MakeBlockFileName()
|
|
{
|
|
auto &balanceInfo = GetBalanceInfo();
|
|
auto &dirMidPool = balanceInfo.dirMidPool;
|
|
auto &dirTopPool = balanceInfo.dirTopPool;
|
|
auto &dirTopFull = balanceInfo.dirTopFull;
|
|
|
|
wxFileNameWrapper ret;
|
|
wxString baseFileName;
|
|
|
|
unsigned int filenum,midnum,topnum,midkey;
|
|
|
|
while(1){
|
|
|
|
/* blockfiles are divided up into hierarchical directories.
|
|
Each toplevel directory is represented by "e" + two unique
|
|
hexadecimal digits, for a total possible number of 256
|
|
toplevels. Each toplevel contains up to 256 subdirs named
|
|
"d" + two hex digits. Each subdir contains 'a number' of
|
|
files. */
|
|
|
|
filenum=0;
|
|
midnum=0;
|
|
topnum=0;
|
|
|
|
// first action: if there is no available two-level directory in
|
|
// the available pool, try to make one
|
|
|
|
if(dirMidPool.empty()){
|
|
|
|
// is there a toplevel directory with space for a NEW subdir?
|
|
|
|
if(!dirTopPool.empty()){
|
|
|
|
// there's still a toplevel with room for a subdir
|
|
|
|
DirHash::iterator iter = dirTopPool.begin();
|
|
int newcount = 0;
|
|
topnum = iter->first;
|
|
|
|
|
|
// search for unused midlevels; linear search adequate
|
|
// add 32 NEW topnum/midnum dirs full of prospective filenames to midpool
|
|
for(midnum=0;midnum<256;midnum++){
|
|
midkey=(topnum<<8)+midnum;
|
|
if(BalanceMidAdd(topnum,midkey)){
|
|
newcount++;
|
|
if(newcount>=32)break;
|
|
}
|
|
}
|
|
|
|
if(dirMidPool.empty()){
|
|
// all the midlevels in this toplevel are in use yet the
|
|
// toplevel claims some are free; this implies multiple
|
|
// internal logic faults, but simply giving up and going
|
|
// into an infinite loop isn't acceptible. Just in case,
|
|
// for some reason, we get here, dynamite this toplevel so
|
|
// we don't just fail.
|
|
|
|
// this is 'wrong', but the best we can do given that
|
|
// something else is also wrong. It will contain the
|
|
// problem so we can keep going without worry.
|
|
dirTopPool.erase(topnum);
|
|
dirTopFull[topnum]=256;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if(dirMidPool.empty()){
|
|
// still empty, thus an absurdly large project; all dirs are
|
|
// full to 256/256/256; keep working, but fall back to 'big
|
|
// filenames' and randomized placement
|
|
|
|
filenum = rand();
|
|
midnum = (int)(256.*rand()/(RAND_MAX+1.));
|
|
topnum = (int)(256.*rand()/(RAND_MAX+1.));
|
|
midkey=(topnum<<8)+midnum;
|
|
|
|
|
|
}else{
|
|
|
|
DirHash::iterator iter = dirMidPool.begin();
|
|
midkey = iter->first;
|
|
|
|
// split the retrieved 16 bit directory key into two 8 bit numbers
|
|
topnum = midkey >> 8;
|
|
midnum = midkey & 0xff;
|
|
filenum = (int)(4096.*rand()/(RAND_MAX+1.));
|
|
|
|
}
|
|
|
|
baseFileName.Printf(wxT("e%02x%02x%03x"),topnum,midnum,filenum);
|
|
|
|
if (!ContainsBlockFile(baseFileName)) {
|
|
// not in the hash, good.
|
|
if (!this->AssignFile(ret, baseFileName, true))
|
|
{
|
|
// this indicates an on-disk collision, likely due to an
|
|
// orphan blockfile. We should try again, but first
|
|
// alert the balancing info there's a phantom file here;
|
|
// if the directory is nearly full of orphans we neither
|
|
// want performance to suffer nor potentially get into an
|
|
// infinite loop if all possible filenames are taken by
|
|
// orphans (unlikely but possible)
|
|
BalanceFileAdd(midkey);
|
|
|
|
}else break;
|
|
}
|
|
}
|
|
// FIXME: Might we get here without midkey having been set?
|
|
// Seemed like a possible problem in these changes in .aup directory hierarchy.
|
|
BalanceFileAdd(midkey);
|
|
return ret;
|
|
}
|
|
|
|
BlockFilePtr DirManager::NewBlockFile( const BlockFileFactory &factory )
|
|
{
|
|
wxFileNameWrapper filePath{ MakeBlockFileName() };
|
|
const wxString fileName{ filePath.GetName() };
|
|
auto newBlockFile = factory( std::move(filePath) );
|
|
mBlockFileHash[fileName] = newBlockFile;
|
|
auto &aliasName = newBlockFile->GetExternalFileName();
|
|
if ( aliasName.IsOk() )
|
|
//OD TODO: check to see if we need to remove this when done decoding.
|
|
//I don't immediately see a place where aliased files remove when a file is closed.
|
|
aliasList.push_back( aliasName.GetFullPath() );
|
|
return newBlockFile;
|
|
}
|
|
|
|
bool DirManager::ContainsBlockFile(const BlockFile *b) const
|
|
{
|
|
if (!b)
|
|
return false;
|
|
auto result = b->GetFileName();
|
|
BlockHash::const_iterator it = mBlockFileHash.find(result.name.GetName());
|
|
if (it == mBlockFileHash.end())
|
|
return false;
|
|
BlockFilePtr ptr = it->second.lock();
|
|
return ptr && (b == &*ptr);
|
|
}
|
|
|
|
bool DirManager::ContainsBlockFile(const wxString &filepath) const
|
|
{
|
|
// check what the hash returns in case the blockfile is from a different project
|
|
BlockHash::const_iterator it = mBlockFileHash.find(filepath);
|
|
return it != mBlockFileHash.end() &&
|
|
BlockFilePtr{ it->second.lock() };
|
|
}
|
|
|
|
// Adds one to the reference count of the block file,
|
|
// UNLESS it is "locked", then it makes a NEW copy of
|
|
// the BlockFile.
|
|
// This function returns non-NULL, or else throws
|
|
BlockFilePtr DirManager::CopyBlockFile(const BlockFilePtr &b)
|
|
{
|
|
if (!b)
|
|
THROW_INCONSISTENCY_EXCEPTION;
|
|
|
|
auto result = b->GetFileName();
|
|
const auto &fn = result.name;
|
|
|
|
if (!b->IsLocked()) {
|
|
//mchinen:July 13 2009 - not sure about this, but it needs to be added to the hash to be able to save if not locked.
|
|
//note that this shouldn't hurt mBlockFileHash's that already contain the filename, since it should just overwrite.
|
|
//but it's something to watch out for.
|
|
//
|
|
// LLL: Except for silent block files which have uninitialized filename.
|
|
if (fn.IsOk())
|
|
mBlockFileHash[fn.GetName()] = b;
|
|
return b;
|
|
}
|
|
|
|
// Copy the blockfile
|
|
BlockFilePtr b2;
|
|
if (!fn.IsOk())
|
|
// Block files with uninitialized filename (i.e. SilentBlockFile)
|
|
// just need an in-memory copy.
|
|
b2 = b->Copy(wxFileNameWrapper{});
|
|
else
|
|
{
|
|
wxFileNameWrapper newFile{ MakeBlockFileName() };
|
|
const wxString newName{newFile.GetName()};
|
|
const wxString newPath{ newFile.GetFullPath() };
|
|
|
|
// We assume that the NEW file should have the same extension
|
|
// as the existing file
|
|
newFile.SetExt(fn.GetExt());
|
|
|
|
//some block files such as ODPCMAliasBlockFIle don't always have
|
|
//a summary file, so we should check before we copy.
|
|
if(b->IsSummaryAvailable())
|
|
{
|
|
if( !FileNames::CopyFile(fn.GetFullPath(),
|
|
newFile.GetFullPath()) )
|
|
// Disk space exhaustion, maybe
|
|
throw FileException{
|
|
FileException::Cause::Write, newFile };
|
|
}
|
|
|
|
// Done with fn
|
|
result.mLocker.reset();
|
|
|
|
b2 = b->Copy(std::move(newFile));
|
|
|
|
mBlockFileHash[newName] = b2;
|
|
aliasList.push_back(newPath);
|
|
}
|
|
|
|
if (!b2)
|
|
THROW_INCONSISTENCY_EXCEPTION;
|
|
|
|
return b2;
|
|
}
|
|
|
|
namespace {
|
|
|
|
using Deserializers =
|
|
std::unordered_map< wxString, DirManager::BlockFileDeserializer >;
|
|
Deserializers &GetDeserializers()
|
|
{
|
|
static Deserializers sDeserializers;
|
|
return sDeserializers;
|
|
}
|
|
|
|
}
|
|
|
|
DirManager::RegisteredBlockFileDeserializer::RegisteredBlockFileDeserializer(
|
|
const wxString &tag, BlockFileDeserializer function )
|
|
{
|
|
GetDeserializers()[tag] = function;
|
|
}
|
|
|
|
bool DirManager::HandleXMLTag(const wxChar *tag, const wxChar **attrs)
|
|
{
|
|
if( !mLoadingTarget )
|
|
return false;
|
|
|
|
BlockFilePtr pBlockFile {};
|
|
|
|
BlockFilePtr &target = mLoadingTarget();
|
|
mLoadingTarget = nullptr;
|
|
|
|
auto &table = GetDeserializers();
|
|
auto iter = table.find( tag );
|
|
if ( iter == table.end() )
|
|
return false;
|
|
pBlockFile = iter->second( *this, attrs );
|
|
|
|
if (!pBlockFile)
|
|
// BuildFromXML failed, or we didn't find a valid blockfile tag.
|
|
return false;
|
|
|
|
if (!pBlockFile->GetFileName().name.IsOk()) {
|
|
// Silent blocks don't actually have a file associated, so
|
|
// we don't need to worry about the hash table at all
|
|
target = pBlockFile;
|
|
return true;
|
|
}
|
|
|
|
// Check the length here so we don't have to do it in each BuildFromXML method.
|
|
if ((mMaxSamples != ~size_t(0)) && // is initialized
|
|
(pBlockFile->GetLength() > mMaxSamples))
|
|
{
|
|
// See http://bugzilla.audacityteam.org/show_bug.cgi?id=451#c13.
|
|
// Lock pBlockFile so that the ~BlockFile() will not DELETE the file on disk.
|
|
pBlockFile->Lock();
|
|
return false;
|
|
}
|
|
else
|
|
target = pBlockFile;
|
|
|
|
//
|
|
// If the block we loaded is already in the hash table, then the
|
|
// object we just loaded is a duplicate, so we DELETE it and
|
|
// return a reference to the existing object instead.
|
|
//
|
|
|
|
wxString name = target->GetFileName().name.GetName();
|
|
auto &wRetrieved = mBlockFileHash[name];
|
|
BlockFilePtr retrieved = wRetrieved.lock();
|
|
if (retrieved) {
|
|
// Lock it in order to DELETE it safely, i.e. without having
|
|
// it DELETE the file, too...
|
|
target->Lock();
|
|
|
|
target = retrieved;
|
|
return true;
|
|
}
|
|
|
|
// This is a NEW object
|
|
wRetrieved = target;
|
|
// MakeBlockFileName wasn't used so we must add the directory
|
|
// balancing information
|
|
BalanceInfoAdd(name);
|
|
|
|
return true;
|
|
}
|
|
|
|
std::pair<bool, FilePath> DirManager::LinkOrCopyToNewProjectDirectory(
|
|
BlockFile *f, bool &link )
|
|
{
|
|
FilePath newPath;
|
|
auto result = f->GetFileName();
|
|
const auto &oldFileNameRef = result.name;
|
|
|
|
// Check that this BlockFile corresponds to a file on disk
|
|
//ANSWER-ME: Is this checking only for SilentBlockFiles, in which case
|
|
// (!oldFileName.IsOk()) is a more correct check?
|
|
if (oldFileNameRef.GetName().empty()) {
|
|
return { true, newPath };
|
|
}
|
|
|
|
wxFileNameWrapper newFileName;
|
|
if (!this->AssignFile(newFileName, oldFileNameRef.GetFullName(), false)
|
|
// Another sanity check against blockfiles getting reassigned an empty
|
|
// name, as apparently happened in
|
|
// http://forum.audacityteam.org/viewtopic.php?f=47&t=97787 :
|
|
|| newFileName.GetFullName().empty() )
|
|
return { false, {} };
|
|
|
|
newPath = newFileName.GetFullPath();
|
|
|
|
if (newFileName != oldFileNameRef) {
|
|
//check to see that summary exists before we copy.
|
|
bool summaryExisted = f->IsSummaryAvailable();
|
|
auto oldPath = oldFileNameRef.GetFullPath();
|
|
if (summaryExisted) {
|
|
bool success = false;
|
|
if (link)
|
|
success = FileNames::HardLinkFile( oldPath, newPath );
|
|
if (!success)
|
|
link = false,
|
|
success = FileNames::CopyFile( oldPath, newPath );
|
|
if (!success)
|
|
return { false, {} };
|
|
}
|
|
|
|
if (!summaryExisted && (f->IsSummaryAvailable() || f->IsSummaryBeingComputed())) {
|
|
// PRL: These steps apply only in case of "on-demand" files that have
|
|
// not completed their asynchronous loading yet -- a very unusual
|
|
// circumstance.
|
|
|
|
// We will need to remember the old file name, so copy it
|
|
wxFileName oldFileName{ oldFileNameRef };
|
|
|
|
// Now we can free any lock (and should, if as the comment below says, we need
|
|
// the other threads to progress)
|
|
result.mLocker.reset();
|
|
|
|
f->SetFileName(std::move(newFileName));
|
|
|
|
//there is a small chance that the summary has begun to be computed on a different thread with the
|
|
//original filename. we need to catch this case by waiting for it to finish and then copy.
|
|
|
|
//block to make sure OD files don't get written while we are changing file names.
|
|
//(It is important that OD files set this lock while computing their summary files.)
|
|
while(f->IsSummaryBeingComputed() && !f->IsSummaryAvailable())
|
|
::wxMilliSleep(50);
|
|
|
|
//check to make sure the oldfile exists.
|
|
//if it doesn't, we can assume it was written to the NEW name, which is fine.
|
|
if (oldFileName.FileExists())
|
|
{
|
|
bool ok = FileNames::CopyFile(oldPath, newPath);
|
|
if (!ok)
|
|
return { false, {} };
|
|
}
|
|
}
|
|
}
|
|
|
|
return { true, newPath };
|
|
}
|
|
|
|
bool DirManager::EnsureSafeFilename(const wxFileName &fName)
|
|
{
|
|
// Quick check: If it's not even in our alias list,
|
|
// then the file name is A-OK.
|
|
|
|
const wxString fullPath{fName.GetFullPath()};
|
|
if ( !make_iterator_range( aliasList ).contains( fullPath ) )
|
|
return true;
|
|
|
|
// Figure out what the NEW name for the existing file would be.
|
|
// Keep trying until we find a filename that doesn't exist.
|
|
|
|
wxFileNameWrapper renamedFileName{ fName };
|
|
int i = 0;
|
|
do {
|
|
i++;
|
|
/* i18n-hint: This is the pattern for filenames that are created
|
|
* when a file needs to be backed up to a different name. For
|
|
* example, mysong would become mysong-old1, mysong-old2, etc.
|
|
* 'old' is part of a filename used when a file is renamed.
|
|
* e.g. Try to go from "mysong.wav" to "mysong-old1.wav". */
|
|
renamedFileName.SetName(wxString::Format(_("%s-old%d"), fName.GetName(), i));
|
|
} while (renamedFileName.FileExists());
|
|
|
|
// Test creating a file by that name to make sure it will
|
|
// be possible to do the rename
|
|
|
|
const wxString renamedFullPath{ renamedFileName.GetFullPath() };
|
|
wxFile testFile(renamedFullPath, wxFile::write);
|
|
if (!testFile.IsOpened()) {
|
|
{ // need braces to avoid compiler warning about ambiguous else, see the macro
|
|
wxLogSysError(wxT("Unable to open/create test file."),
|
|
renamedFullPath);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Close the file prior to renaming.
|
|
testFile.Close();
|
|
|
|
if (!wxRemoveFile(renamedFullPath)) {
|
|
{ // need braces to avoid compiler warning about ambiguous else, see the macro
|
|
/* i18n-hint: %s is the name of a file.*/
|
|
wxLogSysError(wxT("Unable to remove '%s'."),
|
|
renamedFullPath);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
wxPrintf(_("Renamed file: %s\n"), renamedFullPath);
|
|
|
|
// Go through our block files and see if any indeed point to
|
|
// the file we're concerned about. If so, point the block file
|
|
// to the renamed file and when we're done, perform the rename.
|
|
|
|
bool needToRename = false;
|
|
wxBusyCursor busy;
|
|
BlockHash::iterator iter = mBlockFileHash.begin();
|
|
std::vector< BlockFile::ReadLock > readLocks;
|
|
while (iter != mBlockFileHash.end())
|
|
{
|
|
BlockFilePtr b = iter->second.lock();
|
|
if (b) {
|
|
if (fName.IsOk() && b->GetExternalFileName() == fName) {
|
|
needToRename = true;
|
|
|
|
//ODBlocks access the aliased file on another thread, so we need to pause them before this continues.
|
|
readLocks.push_back( b->LockForRead() );
|
|
}
|
|
}
|
|
++iter;
|
|
}
|
|
|
|
if (needToRename) {
|
|
if (!wxRenameFile(fullPath,
|
|
renamedFullPath))
|
|
{
|
|
// ACK!!! The renaming was unsuccessful!!!
|
|
// (This shouldn't happen, since we tried creating a
|
|
// file of this name and then deleted it just a
|
|
// second earlier.) But we'll handle this scenario
|
|
// just in case!!!
|
|
|
|
// Print error message and cancel the export
|
|
wxLogSysError(wxT("Unable to rename '%s' to '%s'."),
|
|
fullPath,
|
|
renamedFullPath);
|
|
|
|
// Destruction of readLocks puts things back where they were
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
//point the aliases to the NEW filename.
|
|
BlockHash::iterator iter2 = mBlockFileHash.begin();
|
|
while (iter2 != mBlockFileHash.end())
|
|
{
|
|
BlockFilePtr b = iter2->second.lock();
|
|
if (b) {
|
|
if (fName.IsOk() && b->GetExternalFileName() == fName) {
|
|
b->SetExternalFileName(wxFileNameWrapper{ renamedFileName });
|
|
wxPrintf(_("Changed block %s to new alias name\n"),
|
|
b->GetFileName().name.GetFullName());
|
|
|
|
}
|
|
}
|
|
++iter2;
|
|
}
|
|
|
|
}
|
|
|
|
aliasList.erase(
|
|
std::find( aliasList.begin(), aliasList.end(), fullPath ) );
|
|
aliasList.push_back(renamedFullPath);
|
|
}
|
|
|
|
// Success!!! Either we successfully renamed the file,
|
|
// or we didn't need to!
|
|
return true;
|
|
}
|
|
|
|
void DirManager::FindMissingAliasFiles(
|
|
BlockHash& missingAliasFilesAUFHash, // output: (.auf) AliasBlockFiles whose aliased files are missing
|
|
BlockHash& missingAliasFilesPathHash) // output: full paths of missing aliased files
|
|
{
|
|
BlockHash::iterator iter = mBlockFileHash.begin();
|
|
while (iter != mBlockFileHash.end())
|
|
{
|
|
wxString key = iter->first; // file name and extension
|
|
BlockFilePtr b = iter->second.lock();
|
|
if (b) {
|
|
if (b->IsAlias())
|
|
{
|
|
const wxFileName &aliasedFileName =
|
|
static_cast< AliasBlockFile* > ( &*b )->GetAliasedFileName();
|
|
wxString aliasedFileFullPath = aliasedFileName.GetFullPath();
|
|
// wxEmptyString can happen if user already chose to "replace... with silence".
|
|
if ((!aliasedFileFullPath.empty()) &&
|
|
!aliasedFileName.FileExists())
|
|
{
|
|
missingAliasFilesAUFHash[key] = b;
|
|
if (missingAliasFilesPathHash.find(aliasedFileFullPath) ==
|
|
missingAliasFilesPathHash.end()) // Add it only once.
|
|
// Not actually using the block here, just the path,
|
|
// so set the block to NULL to create the entry.
|
|
missingAliasFilesPathHash[aliasedFileFullPath] = {};
|
|
}
|
|
}
|
|
}
|
|
++iter;
|
|
}
|
|
|
|
iter = missingAliasFilesPathHash.begin();
|
|
while (iter != missingAliasFilesPathHash.end())
|
|
{
|
|
wxLogWarning(wxT("Missing aliased audio file: '%s'"), iter->first);
|
|
++iter;
|
|
}
|
|
}
|
|
|
|
void DirManager::FindMissingAUFs(
|
|
BlockHash& missingAUFHash) // output: missing (.auf) AliasBlockFiles
|
|
{
|
|
BlockHash::iterator iter = mBlockFileHash.begin();
|
|
while (iter != mBlockFileHash.end())
|
|
{
|
|
const wxString &key = iter->first;
|
|
BlockFilePtr b = iter->second.lock();
|
|
if (b) {
|
|
if (b->IsAlias() && b->IsSummaryAvailable())
|
|
{
|
|
/* don't look in hash; that might find files the user moved
|
|
that the Blockfile abstraction can't find itself */
|
|
wxFileNameWrapper fileName{ MakeBlockFilePath(key) };
|
|
fileName.SetName(key);
|
|
fileName.SetExt(wxT("auf"));
|
|
if (!fileName.FileExists())
|
|
{
|
|
missingAUFHash[key] = b;
|
|
wxLogWarning(wxT("Missing alias (.auf) block file: '%s'"),
|
|
fileName.GetFullPath());
|
|
}
|
|
}
|
|
}
|
|
++iter;
|
|
}
|
|
}
|
|
|
|
void DirManager::FindMissingAUs(
|
|
BlockHash& missingAUHash) // missing data (.au) blockfiles
|
|
{
|
|
BlockHash::iterator iter = mBlockFileHash.begin();
|
|
while (iter != mBlockFileHash.end())
|
|
{
|
|
const wxString &key = iter->first;
|
|
BlockFilePtr b = iter->second.lock();
|
|
// TODO key can be empty in doing a ProjectFSK
|
|
// In which case MakeFilePath will fail. Bail out?
|
|
if (b) {
|
|
if (!b->IsAlias())
|
|
{
|
|
wxFileNameWrapper fileName{ MakeBlockFilePath(key) };
|
|
fileName.SetName(key);
|
|
fileName.SetExt(wxT("au"));
|
|
const auto path = fileName.GetFullPath();
|
|
if (!fileName.FileExists() ||
|
|
wxFile{ path }.Length() == 0)
|
|
{
|
|
missingAUHash[key] = b;
|
|
wxLogWarning(wxT("Missing data block file: '%s'"), path);
|
|
}
|
|
}
|
|
}
|
|
++iter;
|
|
}
|
|
}
|
|
|
|
// Find .au and .auf files that are not in the project.
|
|
void DirManager::FindOrphanBlockFiles(
|
|
const FilePaths &filePathArray, // input: all files in project directory
|
|
FilePaths &orphanFilePathArray) // output: orphan files
|
|
{
|
|
std::vector< std::shared_ptr<DirManager> > otherDirManagers;
|
|
for ( auto &wPtr : sDirManagers ) {
|
|
auto sPtr = wPtr.lock();
|
|
if ( sPtr && sPtr.get() != this )
|
|
otherDirManagers.push_back( sPtr );
|
|
}
|
|
|
|
for (size_t i = 0; i < filePathArray.size(); i++)
|
|
{
|
|
const wxFileName &fullname = filePathArray[i];
|
|
wxString basename = fullname.GetName();
|
|
const wxString ext{fullname.GetExt()};
|
|
if ((mBlockFileHash.find(basename) == mBlockFileHash.end()) && // is orphan
|
|
// Consider only Audacity data files.
|
|
// Specifically, ignore <branding> JPG and <import> OGG ("Save Compressed Copy").
|
|
(ext.IsSameAs(wxT("au"), false) ||
|
|
ext.IsSameAs(wxT("auf"), false)))
|
|
{
|
|
// Ignore it if it exists in the clipboard (from a previously closed project)
|
|
if ( std::any_of( otherDirManagers.begin(), otherDirManagers.end(),
|
|
[&]( const std::shared_ptr< DirManager > &ptr ){
|
|
return ptr->ContainsBlockFile( basename );
|
|
}
|
|
) )
|
|
continue;
|
|
|
|
orphanFilePathArray.push_back(fullname.GetFullPath());
|
|
}
|
|
}
|
|
for ( const auto &orphan : orphanFilePathArray )
|
|
wxLogWarning(wxT("Orphan block file: '%s'"), orphan);
|
|
}
|
|
|
|
|
|
void DirManager::RemoveOrphanBlockfiles()
|
|
{
|
|
FilePaths filePathArray; // *all* files in the project directory/subdirectories
|
|
auto dirPath = (!projFull.empty() ? projFull : mytemp);
|
|
RecursivelyEnumerateWithProgress(
|
|
dirPath,
|
|
filePathArray, // output: all files in project directory tree
|
|
wxEmptyString, // All dirs
|
|
wxEmptyString, // All files
|
|
true, false,
|
|
mBlockFileHash.size(), // rough guess of how many BlockFiles will be found/processed, for progress
|
|
XO("Inspecting project file data"));
|
|
|
|
FilePaths orphanFilePathArray;
|
|
this->FindOrphanBlockFiles(
|
|
filePathArray, // input: all files in project directory tree
|
|
orphanFilePathArray); // output: orphan files
|
|
|
|
// Remove all orphan blockfiles.
|
|
for ( const auto &orphan : orphanFilePathArray )
|
|
wxRemoveFile(orphan);
|
|
}
|
|
|
|
void DirManager::FillBlockfilesCache()
|
|
{
|
|
#ifdef DEPRECATED_AUDIO_CACHE
|
|
// See http://bugzilla.audacityteam.org/show_bug.cgi?id=545.
|
|
bool cacheBlockFiles = false;
|
|
gPrefs->Read(wxT("/Directories/CacheBlockFiles"), &cacheBlockFiles);
|
|
|
|
if (!cacheBlockFiles)
|
|
return; // user opted not to cache block files
|
|
|
|
int lowMem = gPrefs->Read(wxT("/Directories/CacheLowMem"), 16l);
|
|
if (lowMem < 16) {
|
|
lowMem = 16;
|
|
}
|
|
lowMem <<= 20;
|
|
|
|
BlockHash::iterator iter;
|
|
int numNeed = 0;
|
|
|
|
iter = mBlockFileHash.begin();
|
|
while (iter != mBlockFileHash.end())
|
|
{
|
|
BlockFilePtr b = iter->second.lock();
|
|
if (b) {
|
|
if (b->GetNeedFillCache())
|
|
numNeed++;
|
|
}
|
|
++iter;
|
|
}
|
|
|
|
if (numNeed == 0)
|
|
return;
|
|
|
|
ProgressDialog progress(XO("Caching audio"),
|
|
XO("Caching audio into memory"));
|
|
|
|
iter = mBlockFileHash.begin();
|
|
int current = 0;
|
|
while (iter != mBlockFileHash.end())
|
|
{
|
|
BlockFilePtr b = iter->second.lock();
|
|
if (b) {
|
|
if (b->GetNeedFillCache() && (GetFreeMemory() > lowMem)) {
|
|
b->FillCache();
|
|
}
|
|
|
|
if (ProgressResult::Cancelled != progress.Update(current, numNeed))
|
|
break; // user cancelled progress dialog, stop caching
|
|
current++;
|
|
}
|
|
++iter;
|
|
}
|
|
#endif // DEPRECATED_AUDIO_CACHE
|
|
}
|
|
|
|
void DirManager::WriteCacheToDisk()
|
|
{
|
|
BlockHash::iterator iter;
|
|
int numNeed = 0;
|
|
|
|
iter = mBlockFileHash.begin();
|
|
while (iter != mBlockFileHash.end())
|
|
{
|
|
BlockFilePtr b = iter->second.lock();
|
|
if (b) {
|
|
if (b->GetNeedWriteCacheToDisk())
|
|
numNeed++;
|
|
}
|
|
++iter;
|
|
}
|
|
|
|
if (numNeed == 0)
|
|
return;
|
|
|
|
ProgressDialog progress(XO("Saving recorded audio"),
|
|
XO("Saving recorded audio to disk"));
|
|
|
|
iter = mBlockFileHash.begin();
|
|
int current = 0;
|
|
while (iter != mBlockFileHash.end())
|
|
{
|
|
BlockFilePtr b = iter->second.lock();
|
|
if (b) {
|
|
if (b->GetNeedWriteCacheToDisk())
|
|
{
|
|
b->WriteCacheToDisk();
|
|
progress.Update(current, numNeed);
|
|
}
|
|
current++;
|
|
}
|
|
++iter;
|
|
}
|
|
}
|
|
|