//---------------------------------------------------------------------------
void __fastcall TSynchronizeController::LogOperation(TSynchronizeOperation Operation,
const UnicodeString FileName)
{
TSynchronizeLogEntry Entry;
UnicodeString Message;
switch (Operation)
{
case soDelete:
Entry = slDelete;
Message = FMTLOAD(SYNCHRONIZE_DELETED, (FileName));
break;
default:
assert(false);
// fallthru
case soUpload:
Entry = slUpload;
Message = FMTLOAD(SYNCHRONIZE_UPLOADED, (FileName));
break;
}
SynchronizeLog(Entry, Message);
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeController::StartStop(TObject * Sender,
bool Start, const TSynchronizeParamType & Params, const TCopyParamType & CopyParam,
TSynchronizeOptions * Options,
TSynchronizeAbortEvent OnAbort, TSynchronizeThreadsEvent OnSynchronizeThreads,
TSynchronizeLog OnSynchronizeLog)
{
if (Start)
{
Configuration->Usage->Inc(L"KeepUpToDates");
try
{
assert(OnSynchronizeLog != NULL);
FSynchronizeLog = OnSynchronizeLog;
FOptions = Options;
if (FLAGSET(Params.Options, soSynchronize) &&
(FOnSynchronize != NULL))
{
FOnSynchronize(this, Params.LocalDirectory,
Params.RemoteDirectory, CopyParam,
Params, NULL, FOptions, true);
}
FCopyParam = CopyParam;
FSynchronizeParams = Params;
assert(OnAbort);
FSynchronizeAbort = OnAbort;
if (FLAGSET(FSynchronizeParams.Options, soRecurse))
{
SynchronizeLog(slScan,
FMTLOAD(SYNCHRONIZE_SCAN, (FSynchronizeParams.LocalDirectory)));
}
FSynchronizeMonitor = new TDiscMonitor(dynamic_cast<TComponent*>(Sender));
FSynchronizeMonitor->SubTree = false;
TMonitorFilters Filters;
Filters << moFilename << moLastWrite;
if (FLAGSET(FSynchronizeParams.Options, soRecurse))
{
Filters << moDirName;
}
FSynchronizeMonitor->Filters = Filters;
FSynchronizeMonitor->MaxDirectories = 0;
FSynchronizeMonitor->ChangeDelay = GUIConfiguration->KeepUpToDateChangeDelay;
FSynchronizeMonitor->OnTooManyDirectories = SynchronizeTooManyDirectories;
FSynchronizeMonitor->OnDirectoriesChange = SynchronizeDirectoriesChange;
FSynchronizeMonitor->OnFilter = SynchronizeFilter;
FSynchronizeMonitor->AddDirectory(FSynchronizeParams.LocalDirectory,
FLAGSET(FSynchronizeParams.Options, soRecurse));
FSynchronizeMonitor->OnChange = SynchronizeChange;
FSynchronizeMonitor->OnInvalid = SynchronizeInvalid;
FSynchronizeMonitor->OnSynchronize = OnSynchronizeThreads;
// get count before open to avoid thread issues
int Directories = FSynchronizeMonitor->Directories->Count;
FSynchronizeMonitor->Open();
SynchronizeLog(slStart, FMTLOAD(SYNCHRONIZE_START, (Directories)));
}
catch(...)
{
SAFE_DESTROY(FSynchronizeMonitor);
throw;
}
}
else
{
FOptions = NULL;
SAFE_DESTROY(FSynchronizeMonitor);
}
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeController::SynchronizeDirectoriesChange(
TObject * /*Sender*/, int Directories)
{
SynchronizeLog(slDirChange, FMTLOAD(SYNCHRONIZE_START, (Directories)));
}
//---------------------------------------------------------------------------
void __fastcall TSynchronizeController::SynchronizeChange(
TObject * /*Sender*/, const UnicodeString Directory, bool & SubdirsChanged)
{
try
{
UnicodeString RemoteDirectory;
UnicodeString RootLocalDirectory;
RootLocalDirectory = IncludeTrailingBackslash(FSynchronizeParams.LocalDirectory);
RemoteDirectory = UnixIncludeTrailingBackslash(FSynchronizeParams.RemoteDirectory);
UnicodeString LocalDirectory = IncludeTrailingBackslash(Directory);
assert(LocalDirectory.SubString(1, RootLocalDirectory.Length()) ==
RootLocalDirectory);
RemoteDirectory = RemoteDirectory +
ToUnixPath(LocalDirectory.SubString(RootLocalDirectory.Length() + 1,
LocalDirectory.Length() - RootLocalDirectory.Length()));
SynchronizeLog(slChange, FMTLOAD(SYNCHRONIZE_CHANGE,
(ExcludeTrailingBackslash(LocalDirectory))));
if (FOnSynchronize != NULL)
{
// this is completelly wrong as the options structure
// can contain non-root specific options in future
TSynchronizeOptions * Options =
((LocalDirectory == RootLocalDirectory) ? FOptions : NULL);
TSynchronizeChecklist * Checklist = NULL;
FOnSynchronize(this, LocalDirectory, RemoteDirectory, FCopyParam,
FSynchronizeParams, &Checklist, Options, false);
if (Checklist != NULL)
{
try
{
if (FLAGSET(FSynchronizeParams.Options, soRecurse))
{
SubdirsChanged = false;
assert(Checklist != NULL);
for (int Index = 0; Index < Checklist->Count; Index++)
{
const TSynchronizeChecklist::TItem * Item = Checklist->Item[Index];
// note that there may be action saDeleteRemote even if nothing has changed
// so this is sub-optimal
if (Item->IsDirectory)
{
if ((Item->Action == TSynchronizeChecklist::saUploadNew) ||
(Item->Action == TSynchronizeChecklist::saDeleteRemote))
{
SubdirsChanged = true;
break;
}
else
{
assert(false);
}
}
}
}
else
{
SubdirsChanged = false;
}
}
__finally
{
delete Checklist;
}
}
}
}
catch(Exception & E)
{
SynchronizeAbort(dynamic_cast<EFatal*>(&E) != NULL);
}
}
void TSynchronizeController::StartStop(TObject * /*Sender*/,
bool Start, const TSynchronizeParamType & Params, const TCopyParamType & CopyParam,
TSynchronizeOptions * Options,
TSynchronizeAbortEvent OnAbort, TSynchronizeThreadsEvent /*OnSynchronizeThreads*/,
TSynchronizeLogEvent OnSynchronizeLog)
{
if (Start)
{
// Configuration->GetUsage()->Inc(L"KeepUpToDates");
try
{
assert(OnSynchronizeLog != nullptr);
FSynchronizeLog = OnSynchronizeLog;
FOptions = Options;
if (FLAGSET(Params.Options, soSynchronize) &&
(FOnSynchronize != nullptr))
{
FOnSynchronize(this, Params.LocalDirectory,
Params.RemoteDirectory, CopyParam,
Params, nullptr, FOptions, /*Full=*/true);
}
FCopyParam = CopyParam;
FSynchronizeParams = Params;
assert(OnAbort);
FSynchronizeAbort = OnAbort;
if (FLAGSET(FSynchronizeParams.Options, soRecurse))
{
SynchronizeLog(slScan,
FMTLOAD(SYNCHRONIZE_SCAN, FSynchronizeParams.LocalDirectory.c_str()));
}
Error(SNotImplemented, 256);
/*
// FIXME
FSynchronizeMonitor = new TDiscMonitor(NB_STATIC_DOWNCAST(TComponent, Sender));
FSynchronizeMonitor->SubTree = false;
TMonitorFilters Filters;
Filters << moFilename << moLastWrite;
if (FLAGSET(FSynchronizeParams.Options, soRecurse))
{
Filters << moDirName;
}
FSynchronizeMonitor->Filters = Filters;
FSynchronizeMonitor->MaxDirectories = 0;
FSynchronizeMonitor->ChangeDelay = GetGUIConfiguration()->GetKeepUpToDateChangeDelay();
FSynchronizeMonitor->OnTooManyDirectories = SynchronizeTooManyDirectories;
FSynchronizeMonitor->OnDirectoriesChange = SynchronizeDirectoriesChange;
FSynchronizeMonitor->OnFilter = SynchronizeFilter;
FSynchronizeMonitor->AddDirectory(FSynchronizeParams.LocalDirectory,
FLAGSET(FSynchronizeParams.Options, soRecurse));
FSynchronizeMonitor->OnChange = SynchronizeChange;
FSynchronizeMonitor->OnInvalid = SynchronizeInvalid;
FSynchronizeMonitor->OnSynchronize = OnSynchronizeThreads;
// get count before open to avoid thread issues
int Directories = FSynchronizeMonitor->Directories->Count;
FSynchronizeMonitor->Open();
SynchronizeLog(slStart, FMTLOAD(SYNCHRONIZE_START, Directories));
*/
}
catch (...)
{
// FIXME SAFE_DESTROY(FSynchronizeMonitor);
Error(SNotImplemented, 257);
throw;
}
}
else
{
FOptions = nullptr;
// SAFE_DESTROY(FSynchronizeMonitor);
}
}
void TSynchronizeController::SynchronizeChange(
TObject * /*Sender*/, const UnicodeString & Directory, bool & SubdirsChanged)
{
try
{
UnicodeString RemoteDirectory;
UnicodeString RootLocalDirectory;
RootLocalDirectory = ::IncludeTrailingBackslash(FSynchronizeParams.LocalDirectory);
RemoteDirectory = core::UnixIncludeTrailingBackslash(FSynchronizeParams.RemoteDirectory);
UnicodeString LocalDirectory = ::IncludeTrailingBackslash(Directory);
assert(LocalDirectory.SubString(1, RootLocalDirectory.Length()) ==
RootLocalDirectory);
RemoteDirectory = RemoteDirectory +
core::ToUnixPath(LocalDirectory.SubString(RootLocalDirectory.Length() + 1,
LocalDirectory.Length() - RootLocalDirectory.Length()));
SynchronizeLog(slChange, FMTLOAD(SYNCHRONIZE_CHANGE,
::ExcludeTrailingBackslash(LocalDirectory).c_str()));
if (FOnSynchronize != nullptr)
{
// this is completely wrong as the options structure
// can contain non-root specific options in future
TSynchronizeOptions * Options =
((LocalDirectory == RootLocalDirectory) ? FOptions : nullptr);
TSynchronizeChecklist * Checklist = nullptr;
FOnSynchronize(this, LocalDirectory, RemoteDirectory, FCopyParam,
FSynchronizeParams, &Checklist, Options, false);
if (Checklist != nullptr)
{
std::unique_ptr<TSynchronizeChecklist> ChecklistPtr(Checklist);
(void)ChecklistPtr;
if (FLAGSET(FSynchronizeParams.Options, soRecurse))
{
SubdirsChanged = false;
assert(Checklist != nullptr);
for (intptr_t Index = 0; Index < Checklist->GetCount(); ++Index)
{
const TChecklistItem * Item = Checklist->GetItem(Index);
// note that there may be action saDeleteRemote even if nothing has changed
// so this is sub-optimal
if (Item->IsDirectory)
{
if ((Item->Action == saUploadNew) ||
(Item->Action == saDeleteRemote))
{
SubdirsChanged = true;
break;
}
else
{
assert(false);
}
}
}
}
else
{
SubdirsChanged = false;
}
}
}
}
catch (Exception & E)
{
SynchronizeAbort(NB_STATIC_DOWNCAST(EFatal, &E) != nullptr);
}
}
