public void InvokeProgress(MirrorEventArgs args)
{
if (FileProgress != null)
{
if (FileProgress(args))
{
_cancelRequested = true;
_engine.Cancel();
}
}
}
void OnStartingFile(object sender, MirrorEventArgs args)
{
if (ShouldSkip("Backup", args))
{
args.PendingAction = MirrorAction.Skip;
InvokeProgress(args);
return;
}
switch (args.Situation)
{
case MirrorSituation.FileIsSame:
_alreadyAccountedFor.Add(args.Path);
break;
case MirrorSituation.FileMissing:
_files++;
InvokeProgress(args);
_progress.WriteVerbose("[{0}] Will create on backup: {1}", _currentGroup.Name, args.GetDestinationPathForDisplay());
_alreadyAccountedFor.Add(args.Path);
break;
case MirrorSituation.SourceFileOlder:
case MirrorSituation.SourceFileNewer:
_files++;
InvokeProgress(args);
_progress.WriteVerbose("[{0}] Updating {1}", _currentGroup.Name, args.GetDestinationPathForDisplay());
break;
case MirrorSituation.DirectoryOnDestinationButNotSource:
case MirrorSituation.FileOnDestinationButNotSource:
if (!_currentGroup.NormallyPropogateDeletions &&
!args.Path.Contains(".hg")) //always propogate deletions inside the mercurial folder
{
args.PendingAction = MirrorAction.Skip;
_progress.WriteVerbose("[{0}] Because of group policy, will not propagate deletion of {1}", _currentGroup.Name, args.GetDestinationPathForDisplay());
}
else
{
args.PendingAction = MirrorAction.Delete;
_progress.WriteVerbose("[{0}] Deleting {1}", _currentGroup.Name, args.Path);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
//review: does this really mean success?
_errorCountSinceLastSuccess = 0;
}
private MirrorAction GetDirectoryActionFromClient(FileOrDirectory directory, MirrorSituation situation, MirrorAction action)
{
var args = new MirrorEventArgs(directory.Path, situation, action);
EventHandler <MirrorEventArgs> handler = StartingDirectory;
if (handler != null)
{
handler(this, args);
}
if (args.PendingAction == MirrorAction.Skip || args.PendingAction == MirrorAction.Delete)
{
_skippedOrRemovedDirectories.Add(directory.Path);
}
return(args.PendingAction);
}
private MirrorAction GetFileActionFromClient(string path, MirrorSituation situation, MirrorAction action)
{
//note... this is needed only because we don't currently have a
//hierarchical list of things to walk, such that we trim in a more
//effecient way
if (_skippedOrRemovedDirectories.Any(d => path.StartsWith(d)))
{
return(MirrorAction.Skip);
}
var args = new MirrorEventArgs(path, situation, action);
EventHandler <MirrorEventArgs> handler = StartingFile;
if (handler != null)
{
handler(this, args);
}
return(args.PendingAction);
}
/*
* private void OnDestinationPreviewChange(object provider, ApplyingChangeEventArgs args)
* {
* if(ShouldSkip("Preview", (FileSyncProvider)provider,args))
* {
* args.SkipChange = true;
* return;
* }
* if(args.CurrentFileData !=null)
* {
* _currentGroup.NetChangeInBytes -= args.CurrentFileData.Size;
* //below, we'll add back the new size, giving us the correct net change
* }
* string rootDirectoryPath = ((FileSyncProvider)provider).RootDirectoryPath;
* switch (args.ChangeType)
* {
* case ChangeType.Create:
* _progress.WriteVerbose("[{0}] Preview Create {1}", _currentGroup.Name, args.Path);
* _currentGroup.NewFileCount++;
* _currentGroup.NetChangeInBytes += args.NewFileData.Size;
* _alreadyAccountedFor.Add(args.NewFileData.RelativePath);
* break;
* case ChangeType.Update:
* _progress.WriteVerbose("[{0}] Preview Update {1}", _currentGroup.Name, args.Path);
* _currentGroup.UpdateFileCount++;
* _currentGroup.NetChangeInBytes += args.NewFileData.Size;
* _alreadyAccountedFor.Add(args.CurrentFileData.RelativePath);
* break;
* case ChangeType.Delete:
* if (!_currentGroup.NormallyPropogateDeletions)
* {
* args.SkipChange = true;
* _progress.WriteVerbose("[{0}] Because of group policy, would not propagate deletion of {1}", _currentGroup.Name, args.Path);
* }
* else
* {
* _progress.WriteVerbose("[{0}] Preview Delete {1}", _currentGroup.Name, args.Path);
* _currentGroup.DeleteFileCount++;
* }
* break;
* }
* InvokeProgress(args);
* }*/
private bool ShouldSkip(string mode, MirrorEventArgs args)
{
try
{
if (args.Situation == MirrorSituation.DirectoryMissing)
{
string reasonForSkiping;
if (_currentGroup.ShouldSkipSubDirectory(args.Path, out reasonForSkiping))
{
_progress.WriteVerbose("{0} [{1}] Skipping folder '{2}' because {3}", mode, _currentGroup.Name, args.Path, reasonForSkiping);
return(true);
}
//TODO: what about if it is not missing, but should be removed ?
return(false);
}
if (_alreadyAccountedFor.Contains(args.Path))
{
_progress.WriteVerbose(
"[{0}] Skipping '{1}' because it was already backed up by a previous group",
_currentGroup.Name, args.Path);
return(true);
}
string reasonForSkipping;
if (_currentGroup.ShouldSkipFile(args.Path, out reasonForSkipping))
{
_progress.WriteVerbose("[{0}] Skipping '{1}' because {2}", _currentGroup.Name, args.Path, reasonForSkipping);
return(true);
}
}
catch (Exception e)
{
_progress.WriteException(e);
}
return(false);
}
/// <summary>
/// returns true if we want to cancel
/// </summary>
/// <returns></returns>
public bool OnFileProgress(MirrorEventArgs args)
{
InvokeIfRequired(() =>
{
if (_controller.FilesCopiedThusFar >= syncProgressBar.Minimum &&
_controller.FilesCopiedThusFar <= syncProgressBar.Maximum)
{
syncProgressBar.Value = _controller.FilesCopiedThusFar;
}
var max = 40;
string display = "";
var parts = args.Path.Split(new char[] { Path.DirectorySeparatorChar });
//in case the neame itself is too long...
if (parts.Length == 0)
{
return;
}
if (parts[parts.Length - 1].Length > max)
{
var length = args.Path.Length;
var start = length > max ? length - max : 0;
length = length > max ? max : length;
display = args.Path.Substring(start, length);
}
else
{
for (int i = parts.Length - 1; i >= 0; i--)
{
var potential = parts[i] + "/" + display;
if (potential.Length > max)
{
break;
}
display = potential;
}
}
display = display.TrimEnd(new char [] { '/' });
switch (args.PendingAction)
{
case MirrorAction.Skip:
_status.Text = string.Format("Skipping {0}", display);
break;
case MirrorAction.Create:
if (args.Situation == MirrorSituation.DirectoryMissing)
{
break; // don't make it look like we're copying a directory which we may later delete (because it ends up empty), which is then confusing "Why does it keep copying that thing over and over?"
}
_status.Text = string.Format("Copying {0}", display);
break;
case MirrorAction.Delete:
_status.Text = string.Format("Processing {0}", display); //nb "deleting" would scare people
break;
case MirrorAction.DoNothing:
_status.Text = string.Format("Checking {0}", display); //another euphemism
break;
case MirrorAction.Update:
_status.Text = string.Format("Updating {0}", display);
break;
default:
break;
}
});
return(GetIsCancellationPending(args));
}
bool GetIsCancellationPending(MirrorEventArgs unused)
{
return(_preparationWorker.CancellationPending || (_backupWorker != null && _backupWorker.CancellationPending));
}
