static void Main(string[] args)
{
string fileSourcePath = @"C:\Users\davamix\Downloads\pruebas\source";
string fileTargetPath = @"C:\Users\davamix\Downloads\pruebas\target";
//try
//{
FileSyncOptions options = FileSyncOptions.ExplicitDetectChanges | FileSyncOptions.RecycleDeletedFiles | FileSyncOptions.RecyclePreviousFileOnUpdates | FileSyncOptions.RecycleConflictLoserFiles;
FileSyncScopeFilter filter = new FileSyncScopeFilter();
filter.FileNameExcludes.Add("*.info");
DetectChangesOnFileSystemReplica(fileSourcePath, filter, options);
DetectChangesOnFileSystemReplica(fileTargetPath, filter, options);
SyncFileSystemReplicaOneWay(fileSourcePath, fileTargetPath, null, options);
SyncFileSystemReplicaOneWay(fileTargetPath, fileSourcePath, null, options);
//}
//catch (Exception e)
//{
// Console.WriteLine("Exception for FileSync provider\n-> {0}", e.Message);
//}
Console.WriteLine("FIN");
Console.Read();
}
public bool Sync(string sDir, string tDir, FileSyncScopeFilter filter, FileSyncOptions options)
{
try
{
_fileEngine.CheckTargetDirExists(tDir);
var SourceProvider = _fileEngine.CreateProvider(sDir, filter, options);
var DestinationProvider = _fileEngine.CreateProvider(tDir, filter, options);
_fileEngine.DetectChanges(SourceProvider);
SourceProvider = _fileEngine.CreateProvider(sDir, filter, options);
SourceProvider = _fileEngine.SetPreviewModeFlag(SourceProvider, true);
DestinationProvider = _fileEngine.SetPreviewModeFlag(DestinationProvider, true);
DestinationProvider = _fileEngine.AttachApplyingChangeEventHandler(DestinationProvider);
DestinationProvider = _fileEngine.AttachAppliedChangeEventHandler(DestinationProvider);
DestinationProvider = _fileEngine.AttachSkippedChangeEventHandler(DestinationProvider);
var agent = _fileEngine.CreateSyncOrchestrator(SourceProvider, DestinationProvider);
agent = _fileEngine.SetSyncDirection(agent);
_fileEngine.Synchronize(agent);
return true;
}
catch (Exception e)
{
// log teh error mon
return false;
}
}
/// <summary>
/// Starts the synchronization job
/// </summary>
/// <returns>Returns a boolean to indicate if the synchronization was successful</returns>
private bool InternalStartSync()
{
try
{
// Configure sync options
FileSyncOptions options = FileSyncOptions.ExplicitDetectChanges |
FileSyncOptions.RecycleConflictLoserFiles |
FileSyncOptions.RecycleDeletedFiles |
FileSyncOptions.RecyclePreviousFileOnUpdates;
// Configure sync filters
FileSyncScopeFilter filter = new FileSyncScopeFilter();
// Update metadata of the folders before sync to
// check for any changes or modifications
DetectChangesonFileSystemReplica(leftPath, filter, options);
DetectChangesonFileSystemReplica(rightPath, filter, options);
// Start the 2-way sync
SyncFileSystemReplicasOneWay(leftPath, rightPath, null, options, false);
SyncFileSystemReplicasOneWay(rightPath, leftPath, null, options, false);
return(true);
}
catch (Exception e)
{
return(false);
}
}
public static void SyncFileSystemReplicasOneWay(
string sourceReplicaRootPath, string destinationReplicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
sourceProvider = new FileSyncProvider(
sourceReplicaRootPath, filter, options);
destinationProvider = new FileSyncProvider(
destinationReplicaRootPath, filter, options);
destinationProvider.AppliedChange +=
new EventHandler<AppliedChangeEventArgs>(OnAppliedChange);
destinationProvider.SkippedChange +=
new EventHandler<SkippedChangeEventArgs>(OnSkippedChange);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destinationProvider;
agent.Direction = SyncDirectionOrder.Upload; // Sync source to destination
Console.WriteLine("Synchronizing changes to replica: " +
destinationProvider.RootDirectoryPath);
agent.Synchronize();
}
finally
{
// Release resources
if (sourceProvider != null) sourceProvider.Dispose();
if (destinationProvider != null) destinationProvider.Dispose();
}
}
private void SyncFileOperate(string sourceRootPath, string destRootPath, string tempDir, string trashDir)
{
FileSyncScopeFilter filter = new FileSyncScopeFilter();
filter.FileNameExcludes.Add("*.metadata");
FileSyncOptions options = FileSyncOptions.None;
//DetectChanges
DetectChangesOnFileSystemReplica(sourceRootPath, filter, options, sourceRootPath, "filesync.metadata", tempDir, trashDir);
DetectChangesOnFileSystemReplica(destRootPath, filter, options, destRootPath, "filesync.metadata", tempDir, trashDir);
try
{
ThreadInteropUtils.OpeMainFormControl(() =>
{
this.richTextBox1.Text += "Start synchronizing..." + Environment.NewLine;
}, this);
//SyncChanges Both Ways
SyncOperationStatistics syncOperationStatistics = null;
SyncFileUtils.SyncFileSystemReplicasOneWay(sourceRootPath, destRootPath, filter, options, sourceRootPath, "filesync.metadata", destRootPath, "filesync.metadata", tempDir, trashDir, ref syncOperationStatistics);
//ThreadInteropUtils.OpeMainFormControl(() =>
//{
// this.richTextBox1.Text += "Synchronizing file upload changes... " + syncOperationStatistics.UploadChangesApplied.ToString() + Environment.NewLine;
//}, this);
}
catch (Exception e)
{
throw e;
}
}
public void SyncFileSystemReplicasOneWay(
SyncId sourceReplicaId,
SyncId destinationReplicaId,
string sourceReplicaRootPath,
string destinationReplicaRootPath,
FileSyncScopeFilter filter,
FileSyncOptions options)
{
using (var sourceProvider = createFileSyncProvider(
sourceReplicaId.GetGuidId(),
sourceReplicaRootPath,
filter,
options))
using (var destinationProvider = createFileSyncProvider(
destinationReplicaId.GetGuidId(),
destinationReplicaRootPath,
filter,
options))
{
destinationProvider.AppliedChange += destinationProvider_AppliedChange;
destinationProvider.SkippedChange += destinationProvider_SkippedChange;
sourceProvider.DetectChanges();
destinationProvider.DetectChanges();
synchronizeProviders(destinationProvider, sourceProvider);
}
}
/// <summary>
/// InternalExecute
/// </summary>
protected override void InternalExecute()
{
if (!this.TargetingLocalMachine())
{
return;
}
// Check that the Source exists
if (!Directory.Exists(this.Source.GetMetadata("FullPath")))
{
this.Log.LogError(string.Format(CultureInfo.CurrentCulture, "Source Folder does not exist: {0}", this.Source.GetMetadata("FullPath")));
return;
}
// Set the sync options
if (this.SyncOptions != null)
{
FileSyncOptions fso = this.SyncOptions.Aggregate(new FileSyncOptions(), (current, opt) => current | (FileSyncOptions)Enum.Parse(typeof(FileSyncOptions), opt.ItemSpec));
this.syncOptions = fso;
this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "SyncOptions set: {0}", this.syncOptions));
}
switch (this.TaskAction)
{
case "SyncFolders":
this.SyncFolders();
break;
default:
this.Log.LogError(string.Format(CultureInfo.CurrentCulture, "Invalid TaskAction passed: {0}", this.TaskAction));
return;
}
}
private static void Main(string[] args)
{
const string replica1RootPath = "_R0";
const string replica2RootPath = "_R1";
if (Directory.Exists(replica1RootPath))
{
Directory.Delete(replica1RootPath, true);
}
Directory.CreateDirectory(replica1RootPath);
if (Directory.Exists(replica2RootPath))
{
Directory.Delete(replica2RootPath, true);
}
Directory.CreateDirectory(replica2RootPath);
try
{
// Set options for the synchronization operation
const FileSyncOptions options =
FileSyncOptions.ExplicitDetectChanges |
FileSyncOptions.RecycleDeletedFiles |
FileSyncOptions.RecyclePreviousFileOnUpdates |
FileSyncOptions.RecycleConflictLoserFiles;
var filter = new FileSyncScopeFilter();
//filter.FileNameExcludes.Add("*.lnk"); // Exclude all *.lnk files
Guid replica1Guid = Guid.Parse("181517DE-B950-4e62-9582-56F01884288D");
Guid replica2Guid = Guid.Parse("86C9D79E-679D-4d33-A051-AA4EEFF17E55");
using (var provider0 = new FileSyncProvider(replica1Guid, replica1RootPath, filter, options))
{
using (var provider1 = new FileSyncProvider(replica2Guid, replica2RootPath, filter, options))
//using (var provider1 = new TestProvider(replica2Guid, Path.Combine(replica2RootPath, "_replica.sdf")))
{
var agent = CreateAgent(
provider0,
provider1
);
while (true)
{
provider0.DetectChanges();
provider1.DetectChanges();
agent.Synchronize();
Thread.Sleep(25);
}
}
}
}
catch (Exception e)
{
Console.WriteLine("\nException from File Synchronization Provider:\n" + e);
}
}
/// <summary>
/// Does Sync operation to store change events into a list of FileData objects
/// </summary>
private int InternalPreviewSync()
{
try
{
fileData = new List <FileData>();
// Configure sync options
FileSyncOptions options = FileSyncOptions.ExplicitDetectChanges |
FileSyncOptions.RecycleConflictLoserFiles |
FileSyncOptions.RecycleDeletedFiles |
FileSyncOptions.RecyclePreviousFileOnUpdates;
// Configure sync filters
FileSyncScopeFilter filter = new FileSyncScopeFilter();
filter.SubdirectoryExcludes.Add(TRACKBACK_FOLDER_NAME);
filter.FileNameExcludes.Add(METADATA_FILE_NAME);
// Add filters for file types
for (int i = 0; i < excludeData.ExcludeFileTypeList.Count; i++)
{
filter.FileNameExcludes.Add("*" + excludeData.ExcludeFileTypeList[i]);
}
// Add filters for file names
for (int i = 0; i < excludeData.ExcludeFileNameList.Count; i++)
{
filter.FileNameExcludes.Add(excludeData.ExcludeFileNameList[i]);
}
// Add filters for folders
for (int i = 0; i < excludeData.ExcludeFolderList.Count; i++)
{
filter.SubdirectoryExcludes.Add(excludeData.ExcludeFolderList[i]);
}
// Update metadata of the folders before sync to
// check for any changes or modifications
DetectChangesonFileSystemReplica(leftPath, filter, options);
DetectChangesonFileSystemReplica(rightPath, filter, options);
// Start the 2-way sync
SyncFileSystemReplicasOneWay(leftPath, rightPath, null, options);
SyncFileSystemReplicasOneWay(rightPath, leftPath, null, options);
return(0);
}
catch (SyncException)
{
return(1);
}
catch (DirectoryNotFoundException)
{
return(2);
}
catch (Exception)
{
return(3);
}
}
public FileSyncInfo(string syncAction, string replicaRootPath, string[] filters, FileSyncOptions syncOptions, string serverSyncClass = null)
: base(syncAction)
{
ServerSyncClass = string.IsNullOrEmpty(serverSyncClass) ? FileSyncInfo.FILESYNC_CLASS : serverSyncClass;
ReplicaRootPath = replicaRootPath;
Filters = filters;
SyncOptions = syncOptions;
}
public void Configure(string syncAction, string replicaRootPath, string[] filters, FileSyncOptions syncOptions)
{
ReplicaRootPath = replicaRootPath;
SetScopeFilter(filters);
SyncOptions = syncOptions;
DetectChanges();
}
/// <summary>
/// Run method, executed by a dedicated Task to analyze file system changes and start syncing operations
/// </summary>
private void Run()
{
// Set options for the synchronization operation
FileSyncOptions options = FileSyncOptions.ExplicitDetectChanges |
FileSyncOptions.RecycleDeletedFiles |
FileSyncOptions.RecyclePreviousFileOnUpdates;
FileSyncScopeFilter filter = new FileSyncScopeFilter();
if (AppSettings.Default.ExcludedFiles.Trim().Length > 0)
{
var excludedTypes = AppSettings.Default.ExcludedFiles.Split(',');
foreach (var exType in excludedTypes)
{
if (exType != null && exType.Trim().Length > 0)
{
filter.FileNameExcludes.Add(exType);
}
}
}
else
{
Logger.Log("No file filter specified", LogInfo.Info, VerbosityInfoLevel.V2);
}
if (AppSettings.Default.ExcludedFolders.Trim().Length > 0)
{
var excludedFolders = AppSettings.Default.ExcludedFolders.Split(',');
foreach (var exFolder in excludedFolders)
{
if (exFolder != null && exFolder.Trim().Length > 0)
{
filter.SubdirectoryExcludes.Add(exFolder);
}
}
}
else
{
Logger.Log("No folder filter specified", LogInfo.Info, VerbosityInfoLevel.V2);
}
while (running)
{
try
{
DetectChangesOnFileSystemReplica(AppSettings.Default.Path1, filter, options);
DetectChangesOnFileSystemReplica(AppSettings.Default.Path2, filter, options);
SyncFileSystemReplicasOneWay(AppSettings.Default.Path1, AppSettings.Default.Path2, filter, options);
SyncFileSystemReplicasOneWay(AppSettings.Default.Path2, AppSettings.Default.Path1, filter, options);
}
catch (Exception e)
{
Logger.Log("Error on sync provider execution:\n {0}", LogInfo.Error, VerbosityInfoLevel.V1, e.ToString());
}
Thread.Sleep(AppSettings.Default.CheckIntervalSec * 1000);
}
}
public void DetectChangesOnFileSystemReplica(
SyncId replicaId,
string replicaRootPath,
FileSyncScopeFilter filter,
FileSyncOptions options)
{
using (var provider = createFileSyncProvider(replicaId.GetGuidId(), replicaRootPath, filter, options))
provider.DetectChanges();
}
public static void SyncFileSystemReplicasOneWay(
string sourceReplicaRootPath, string destinationReplicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
// Instantiate source and destination providers, with a null filter (the filter
// was specified in DetectChangesOnFileSystemReplica()), and options for both.
sourceProvider = new FileSyncProvider(
sourceReplicaRootPath, filter, options);
destinationProvider = new FileSyncProvider(
destinationReplicaRootPath, filter, options);
// Register event handlers so that we can write information
// to the console.
//destinationProvider.AppliedChange +=
// new EventHandler<AppliedChangeEventArgs>(OnAppliedChange);
//destinationProvider.SkippedChange +=
// new EventHandler<SkippedChangeEventArgs>(OnSkippedChange);
// Use SyncCallbacks for conflicting items.
//SyncCallbacks destinationCallbacks = destinationProvider.DestinationCallbacks;
//destinationCallbacks.ItemConflicting += new EventHandler<ItemConflictingEventArgs>(OnItemConflicting);
//destinationCallbacks.ItemConstraint += new EventHandler<ItemConstraintEventArgs>(OnItemConstraint);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destinationProvider;
agent.Direction = SyncDirectionOrder.Upload; // Upload changes from the source to the destination.
Console.WriteLine("Synchronizing changes to replica: " +
destinationProvider.RootDirectoryPath);
agent.Synchronize();
}
finally
{
// Release resources.
if (sourceProvider != null)
{
sourceProvider.Dispose();
}
if (destinationProvider != null)
{
destinationProvider.Dispose();
}
}
}
public override TaskStatus Run()
{
this.Info("Synchronising folders...");
bool success = true;
try
{
string idFileName = "filesync.id";
Guid replica1Id = GetReplicaId(Path.Combine(this.SrcFolder, idFileName));
Guid replica2Id = GetReplicaId(Path.Combine(this.destFolder, idFileName));
// Set options for the sync operation
FileSyncOptions options = FileSyncOptions.ExplicitDetectChanges |
FileSyncOptions.RecycleDeletedFiles | FileSyncOptions.RecyclePreviousFileOnUpdates | FileSyncOptions.RecycleConflictLoserFiles;
FileSyncScopeFilter filter = new FileSyncScopeFilter();
filter.FileNameExcludes.Add(idFileName); // Exclude the id file
// Explicitly detect changes on both replicas upfront, to avoid two change
// detection passes for the two-way sync
DetectChangesOnFileSystemReplica(replica1Id, this.SrcFolder, filter, options);
DetectChangesOnFileSystemReplica(replica2Id, this.destFolder, filter, options);
// Sync source to destination
SyncFileSystemReplicasOneWay(replica1Id, replica2Id, this.SrcFolder, this.destFolder, filter, options);
success &= true;
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception e)
{
Logger.ErrorFormat("Error from File Sync Provider: {0}\n", e.Message);
success &= false;
}
Status status = Status.Success;
if (!success)
{
status = Status.Error;
}
this.Info("Task finished.");
return(new TaskStatus(status, false));
}
private void button2_Click_1(object sender, EventArgs e)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
FileSyncScopeFilter filter = new FileSyncScopeFilter();
filter.FileNameExcludes.Add("*.metadata");
FileSyncOptions options = FileSyncOptions.None;
sourceProvider = new FileSyncProvider(sourceRootPath, filter, options);
destinationProvider = new FileSyncProvider(destRootPath, filter, options);
//destinationProvider.AppliedChange += new EventHandler<AppliedChangeEventArgs>(OnAppliedChange);
//destinationProvider.SkippedChange += new EventHandler<SkippedChangeEventArgs>(OnSkippedChange);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destinationProvider;
//agent.Direction = SyncDirectionOrder.Upload; // Sync source to destination
agent.Direction = SyncDirectionOrder.DownloadAndUpload; // Sync source to destination
Console.WriteLine("Synchronizing changes to replica: " + destinationProvider.RootDirectoryPath);
System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start();
agent.Synchronize();
stopwatch.Stop();
this.richTextBox1.Text = "Sync framework test total time：" + stopwatch.ElapsedMilliseconds + "ms";
}
catch (Exception exc)
{
throw exc;
}
finally
{
// Release resources
if (sourceProvider != null)
{
sourceProvider.Dispose();
}
if (destinationProvider != null)
{
destinationProvider.Dispose();
}
}
}
public static void WatchFileSystem(string sourceDirectory, string targetDirectory)
{
if (string.IsNullOrEmpty(sourceDirectory) || string.IsNullOrEmpty(targetDirectory) ||
!Directory.Exists(sourceDirectory) || !Directory.Exists(targetDirectory))
{
return;
}
try
{
// Set options for the synchronization operation
FileSyncOptions options = FileSyncOptions.ExplicitDetectChanges |
FileSyncOptions.RecycleDeletedFiles |
FileSyncOptions.RecyclePreviousFileOnUpdates |
FileSyncOptions.RecycleConflictLoserFiles;
FileSyncScopeFilter filter = new FileSyncScopeFilter();
//filter.FileNameExcludes.Add("*.lnk"); // Exclude all *.lnk files
filter.FileNameIncludes.Add("*.mp4");
filter.FileNameIncludes.Add("*.mkv");
filter.FileNameIncludes.Add("*.avi");
filter.FileNameIncludes.Add("*.divx");
filter.FileNameIncludes.Add("*.png");
filter.FileNameIncludes.Add("*.jpg");
filter.FileNameIncludes.Add("*.gif");
filter.FileNameIncludes.Add("*.zip");
filter.FileNameIncludes.Add("*.rar");
filter.FileNameIncludes.Add("*.mp3");
// Explicitly detect changes on both replicas upfront, to avoid two change
// detection passes for the two-way synchronization
//DetectChangesOnFileSystemReplica(
// sourceDirectory, filter, null);
//DetectChangesOnFileSystemReplica(
// targetDirectory, filter, options);
// Synchronization in both directions
SyncFileSystemReplicasOneWay(sourceDirectory, targetDirectory, filter, options);
//SyncFileSystemReplicasOneWay(sourceDirectory, targetDirectory, null, options);
}
catch (Exception e)
{
Logging.Log("\nException from File Synchronization Provider:\n" + e.ToString());
}
}
/// <summary>
/// Does actual presync preparations
/// </summary>
/// <returns></returns>
private bool InternalPreSync()
{
try
{
// Reset all counters before every synchronization
countChanges = 0;
countDoneChanges = 0;
freeDiskSpaceForLeft = 0;
freeDiskSpaceForRight = 0;
diskSpaceNeededForLeft = 0;
diskSpaceNeededForRight = 0;
isCheckForLeftDone = false;
// Configure sync options
FileSyncOptions options = FileSyncOptions.ExplicitDetectChanges |
FileSyncOptions.RecycleConflictLoserFiles |
FileSyncOptions.RecycleDeletedFiles |
FileSyncOptions.RecyclePreviousFileOnUpdates;
// Configure sync filters
FileSyncScopeFilter filter = new FileSyncScopeFilter();
// Update metadata of the folders before sync to
// check for any changes or modifications
DetectChangesonFileSystemReplica(leftPath, filter, options);
DetectChangesonFileSystemReplica(rightPath, filter, options);
// Start the 2-way sync
if (!SyncFileSystemReplicasOneWay(leftPath, rightPath, null, options, true))
{
return(false);
}
if (!SyncFileSystemReplicasOneWay(rightPath, leftPath, null, options, true))
{
return(false);
}
return(true);
}
catch (Exception e)
{
return(false);
}
}
public static void DetectChangesOnFileSystemReplica(
string replicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider provider = null;
try
{
provider = new FileSyncProvider(replicaRootPath, filter, options);
provider.DetectChanges();
}
finally
{
// Release resources
if (provider != null)
provider.Dispose();
}
}
/// <summary>
/// Synchronize two folders (source and destination). The sync operation is ONE WAY only (From source to destination)
/// </summary>
/// <param name="sourceReplicaRootPath">source syncing path</param>
/// <param name="destinationReplicaRootPath">destination syncing path</param>
/// <param name="filter">syncing filter</param>
/// <param name="options">syncing options</param>
private void SyncFileSystemReplicasOneWay(
string sourceReplicaRootPath, string destinationReplicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
sourceProvider = new FileSyncProvider(
sourceReplicaRootPath, filter, options);
destinationProvider = new FileSyncProvider(
destinationReplicaRootPath, filter, options);
destinationProvider.AppliedChange += new EventHandler <AppliedChangeEventArgs>(OnAppliedChange);
destinationProvider.SkippedChange += new EventHandler <SkippedChangeEventArgs>(OnSkippedChange);
destinationProvider.ApplyingChange += DestinationProvider_ApplyingChange;
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destinationProvider;
agent.Direction = SyncDirectionOrder.Upload; // Sync source to destination
var ret = agent.Synchronize();
if (ret.UploadChangesTotal != 0)
{
Logger.Log("Synchronizing '{0}', tot changes={1} ({2} done/{3} errors)", LogInfo.Info, VerbosityInfoLevel.V3, destinationProvider.RootDirectoryPath, ret.UploadChangesTotal, ret.UploadChangesApplied, ret.UploadChangesFailed);
}
}
finally
{
// Release resources
if (sourceProvider != null)
{
sourceProvider.Dispose();
}
if (destinationProvider != null)
{
destinationProvider.Dispose();
}
}
}
/// <summary>
/// Start the synchronization in one direction
/// </summary>
/// <param name="sourcePath">This parameter holds the source folder path</param>
/// <param name="destPath">This parameter holds the destination folder path</param>
/// <param name="filter">This parameter is the filter which will be used during synchronization</param>
/// <param name="options">This parameter holds the synchronization options</param>
private void SyncFileSystemReplicasOneWay(string sourcePath, string destPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destProvider = null;
try
{
sourceProvider = new FileSyncProvider(sourcePath, filter, options);
destProvider = new FileSyncProvider(destPath, filter, options);
sourceProvider.PreviewMode = true;
destProvider.PreviewMode = true;
destProvider.Configuration.ConflictResolutionPolicy = ConflictResolutionPolicy.ApplicationDefined;
SyncCallbacks destinationCallBacks = destProvider.DestinationCallbacks;
destinationCallBacks.ItemConflicting += new EventHandler <ItemConflictingEventArgs>(OnItemConflicting);
destinationCallBacks.ItemConstraint += new EventHandler <ItemConstraintEventArgs>(OnItemConstraint);
destProvider.ApplyingChange += new EventHandler <ApplyingChangeEventArgs>(OnApplyingChange);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destProvider;
agent.Direction = SyncDirectionOrder.Upload;
agent.Synchronize();
}
finally
{
if (sourceProvider != null)
{
sourceProvider.Dispose();
}
if (destProvider != null)
{
destProvider.Dispose();
}
}
}
/// <summary>
/// Detect the changes done to the folder
/// <para>Updates the metadata</para>
/// </summary>
/// <param name="replicaRootPath">This parameter is the folder path to be checked</param>
/// <param name="filter">This parameter is the filter which will be used during synchronization</param>
/// <param name="options">This parameter holds the synchronization options</param>
private static void DetectChangesonFileSystemReplica(
string replicaRootPath, FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider provider = null;
try
{
provider = new FileSyncProvider(replicaRootPath, filter, options);
provider.DetectChanges();
}
finally
{
// Release resources or memory
if (provider != null)
{
provider.Dispose();
}
}
}
public void SyncFileSystemReplicasOneWay(
string sourceReplicaRootPath, string destinationReplicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
sourceProvider = new FileSyncProvider(
sourceReplicaRootPath, filter, options);
destinationProvider = new FileSyncProvider(
destinationReplicaRootPath, filter, options);
destinationProvider.AppliedChange +=
new EventHandler <AppliedChangeEventArgs>(OnAppliedChange);
destinationProvider.SkippedChange +=
new EventHandler <SkippedChangeEventArgs>(OnSkippedChange);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destinationProvider;
agent.Direction = SyncDirectionOrder.DownloadAndUpload; // Sync source to destination
//Console.WriteLine("Synchronizing changes to replica: " +
// destinationProvider.RootDirectoryPath);
logException.LogExceptionToDisk("Synchronizing changes to replica: " + destinationProvider.RootDirectoryPath);
agent.Synchronize();
}
finally
{
// Release resources
if (sourceProvider != null)
{
sourceProvider.Dispose();
}
if (destinationProvider != null)
{
destinationProvider.Dispose();
}
}
}
public void DetectChangesOnFileSystemReplica(
Guid replicaId, string replicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider provider = null;
try
{
provider = new FileSyncProvider(replicaId, replicaRootPath, filter, options);
provider.DetectChanges();
}
finally
{
// Release resources
if (provider != null)
{
provider.Dispose();
}
}
}
public void SyncFileSystemReplicasOneWay(
Guid sourceReplicaId, Guid destinationReplicaId,
string sourceReplicaRootPath, string destinationReplicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
sourceProvider = new FileSyncProvider(
sourceReplicaId, sourceReplicaRootPath, filter, options);
destinationProvider = new FileSyncProvider(
destinationReplicaId, destinationReplicaRootPath, filter, options);
destinationProvider.AppliedChange += OnAppliedChange;
destinationProvider.SkippedChange += OnSkippedChange;
var agent = new SyncOrchestrator
{
LocalProvider = sourceProvider,
RemoteProvider = destinationProvider,
Direction = SyncDirectionOrder.Upload
};
InfoFormat("Synchronizing changes to replica: {0}", destinationProvider.RootDirectoryPath);
agent.Synchronize();
}
finally
{
// Release resources
if (sourceProvider != null)
{
sourceProvider.Dispose();
}
if (destinationProvider != null)
{
destinationProvider.Dispose();
}
}
}
public static void DetectChangesOnFileSystemReplica(
SyncId syncid, string replicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options,
DirectoryInfo syncDir,
string metadataName)
{
FileSyncProvider provider = null;
try
{
provider = new FileSyncProvider(
syncid.GetGuidId(), replicaRootPath, filter, options, syncDir.FullName, metadataName, syncDir.FullName, null);
provider.DetectChanges();
}
finally
{
// Release resources
if (provider != null)
provider.Dispose();
}
}
public static void Main(string[] args)
{
if (args.Length < 2 ||
string.IsNullOrEmpty(args[0]) || string.IsNullOrEmpty(args[1]) ||
!Directory.Exists(args[0]) || !Directory.Exists(args[1]))
{
Console.WriteLine(
"Usage: FileSyncSample [valid directory path 1] [valid directory path 2]");
return;
}
string replica1RootPath = args[0];
string replica2RootPath = args[1];
try
{
// Set options for the sync operation
FileSyncOptions options = FileSyncOptions.ExplicitDetectChanges |
FileSyncOptions.RecycleDeletedFiles | FileSyncOptions.RecyclePreviousFileOnUpdates | FileSyncOptions.RecycleConflictLoserFiles;
FileSyncScopeFilter filter = new FileSyncScopeFilter();
filter.FileNameExcludes.Add("*.lnk"); // Exclude all *.lnk files
// Explicitly detect changes on both replicas upfront, to avoid two change
// detection passes for the two-way sync
DetectChangesOnFileSystemReplica(
replica1RootPath, filter, options);
DetectChangesOnFileSystemReplica(
replica2RootPath, filter, options);
// Sync in both directions
SyncFileSystemReplicasOneWay(replica1RootPath, replica2RootPath, null, options);
SyncFileSystemReplicasOneWay(replica2RootPath, replica1RootPath, null, options);
}
catch (Exception e)
{
Console.WriteLine("\nException from File Sync Provider:\n" + e.ToString());
}
}
public bool SyncNotes()
{
logException.LogExceptionToDisk("Inside Sync Notes...");
string localPath = ConfigurationManager.AppSettings["localPath"]; //@"C:\Users\rpoondla\Documents\Visual Studio 2015\Projects\OneNoteApplication\OneNoteApplication\bin\Debug"; //args[0];
string remotePath = ConfigurationManager.AppSettings["RemotePath"]; //@"\\10.213.154.154\f\Ravali"; //args[1];
logException.LogExceptionToDisk("localPath: " + localPath + "RemotePath: " + remotePath);
try
{
// Set options for the synchronization operation
FileSyncOptions options = FileSyncOptions.ExplicitDetectChanges |
FileSyncOptions.RecycleDeletedFiles |
FileSyncOptions.RecyclePreviousFileOnUpdates |
FileSyncOptions.RecycleConflictLoserFiles;
FileSyncScopeFilter filter = new FileSyncScopeFilter();
filter.FileNameIncludes.Add("*.txt"); //FileNameExcludes.Add("*.lnk"); // Exclude all *.lnk files
// Explicitly detect changes on both replicas upfront, to avoid two change
// detection passes for the two-way synchronization
DetectChangesOnFileSystemReplica(
localPath, filter, options);
DetectChangesOnFileSystemReplica(
remotePath, filter, options);
// Synchronization in both directions
SyncFileSystemReplicasOneWay(localPath, remotePath, null, options);
SyncFileSystemReplicasOneWay(remotePath, localPath, null, options);
}
catch (Exception e)
{
logException.LogExceptionToDisk("\nException from File Synchronization Provider:\n" + e.ToString());
return(false);
}
return(true);
}
private bool SyncFolders()
{
var success = true;
try
{
const string idFileName = "filesync.id";
var replica1Id = GetReplicaId(Path.Combine(SrcFolder, idFileName));
var replica2Id = GetReplicaId(Path.Combine(DestFolder, idFileName));
// Set options for the sync operation
const FileSyncOptions options = FileSyncOptions.ExplicitDetectChanges |
FileSyncOptions.RecycleDeletedFiles | FileSyncOptions.RecyclePreviousFileOnUpdates | FileSyncOptions.RecycleConflictLoserFiles;
var filter = new FileSyncScopeFilter();
filter.FileNameExcludes.Add(idFileName); // Exclude the id file
// Explicitly detect changes on both replicas upfront, to avoid two change
// detection passes for the two-way sync
DetectChangesOnFileSystemReplica(replica1Id, SrcFolder, filter, options);
DetectChangesOnFileSystemReplica(replica2Id, DestFolder, filter, options);
// Sync source to destination
SyncFileSystemReplicasOneWay(replica1Id, replica2Id, SrcFolder, DestFolder, filter, options);
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception e)
{
Logger.ErrorFormat("Error from File Sync Provider: {0}\n", e.Message);
success = false;
}
return(success);
}
private void SyncFileSystem(
string sourcePath, string destinationPath)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
FileSyncScopeFilter filter = new FileSyncScopeFilter();
filter.FileNameIncludes.Add("*.zip");
FileSyncOptions options = FileSyncOptions.None;
try
{
sourceProvider = new FileSyncProvider(
sourcePath, filter, options);
destinationProvider = new FileSyncProvider(
destinationPath, filter, options);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destinationProvider;
agent.Direction = SyncDirectionOrder.Upload;
agent.Synchronize();
}
finally
{
if (sourceProvider != null)
{
sourceProvider.Dispose();
}
if (destinationProvider != null)
{
destinationProvider.Dispose();
}
}
}
// Create a provider, and detect changes on the replica that the provider
// represents.
public static void DetectChangesOnFileSystemReplica(
string replicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider provider = null;
//FileSyncProvider provider;
try
{
//3provider = new FileSyncProvider("C:\\inetpub\\wwwroot\\MAKRO\\Repository");
provider = new FileSyncProvider(replicaRootPath, filter, options);
//1provider = new FileSyncProvider(replicaRootPath);
provider.DetectChanges();
}
finally
{
// Release resources.
if (provider != null)
{
provider.Dispose();
}
}
}
private void SyncFileSystemReplicasOneWay(
string sourceReplicaRootPath, string destinationReplicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
sourceProvider = new FileSyncProvider(
sourceReplicaRootPath, filter, options);
destinationProvider = new FileSyncProvider(
destinationReplicaRootPath, filter, options);
destinationProvider.AppliedChange += new EventHandler<AppliedChangeEventArgs>(OnAppliedChange);
destinationProvider.SkippedChange += new EventHandler<SkippedChangeEventArgs>(OnSkippedChange);
destinationProvider.CopyingFile += new EventHandler<CopyingFileEventArgs>(OnCopyingFile);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destinationProvider;
agent.Direction = SyncDirectionOrder.Upload;
agent.Synchronize();
notifier.NotifyInfo("Backup in progress..");
}
catch(Exception ex)
{
notifier.NotifyError(ex.Message);
}
finally
{
if (sourceProvider != null) sourceProvider.Dispose();
if (destinationProvider != null) destinationProvider.Dispose();
}
}
//public static void DetectChangesOnFileSystemReplica(
//string replicaRootPath,
//FileSyncScopeFilter filter, FileSyncOptions options)
//{
// FileSyncProvider provider = null;
// try
// {
// provider = new FileSyncProvider(replicaRootPath, filter, options);
// provider.DetectChanges();
// }
// finally
// {
// // Release resources
// if (provider != null)
// provider.Dispose();
// }
//}
public static void SyncFileSystemReplicasOneWay(
string sourceReplicaRootPath, string destinationReplicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
sourceProvider = new FileSyncProvider(
sourceReplicaRootPath, filter, options);
//filter.SubdirectoryExcludes.Add(@".\");
destinationProvider = new FileSyncProvider(
destinationReplicaRootPath, filter, options);
sourceProvider.AppliedChange +=
new EventHandler <AppliedChangeEventArgs>(OnAppliedChange);
sourceProvider.SkippedChange +=
new EventHandler <SkippedChangeEventArgs>(OnSkippedChange);
sourceProvider.DetectChanges();
sourceProvider.CopyingFile += (s, a) =>
{
string file = a.FilePath;
int percent = a.PercentCopied;
};
sourceProvider.AppliedChange += (s, a) =>
{
string file = a.NewFilePath;
var change = a.ChangeType;
};
sourceProvider.DetectedChanges += (s, a) =>
{
//a.TotalDirectoriesFound
};
destinationProvider.CopyingFile += (s, a) =>
{
string file = a.FilePath;
int percent = a.PercentCopied;
FileIO.FileTransferProgress(null, new FileTransferProgressEventArgs(percent, Path.GetFileName(file)));
};
destinationProvider.AppliedChange += (s, a) =>
{
string file = a.NewFilePath;
};
destinationProvider.AppliedChange += (s, a) =>
{
if (a.ChangeType == ChangeType.Delete)
{
return;
}
string file = a.NewFilePath;
string serverPath = FileIO.GetPath(destinationReplicaRootPath) + file;
if (FileIO.IsDirectory(serverPath))
{
return;
}
FileIO.FinshedFileTransfer(null, new FinshedFileTransferEventArgs(Path.GetFileName(serverPath)));
string localDirectory = FileIO.GetPath(FileIO.GetPath(sourceReplicaRootPath) + file);
string localFile = localDirectory + Path.GetFileName(file);
string topLevelDir = FileIO.GetPath(sourceReplicaRootPath) + FileIO.GetTopLevelFolder(file);
try
{
File.Delete(localFile);
}
catch (Exception ex) { Logging.Log(ex.Message); }
if (topLevelDir == FileIO.GetPath(sourceReplicaRootPath))
{
return;
}
//bool isMoreTransfers = filter.FileNameIncludes.Any(x => Directory.GetFiles(localDirectory, x) != null);
foreach (string filterVal in filter.FileNameIncludes)
{
if (Directory.EnumerateFiles(topLevelDir, filterVal, SearchOption.AllDirectories).Count() > 0)
{
return;
}
}
//if (isMoreTransfers) return;
try
{
FileIO.ForceDeleteDirectory(topLevelDir);
}
catch (Exception ex) { Logging.Log(ex.Message); }
};
//SyncOrchestrator agent = new SyncOrchestrator();
_agent.LocalProvider = sourceProvider;
_agent.RemoteProvider = destinationProvider;
_agent.Direction = SyncDirectionOrder.Upload;
Logging.Log("Synchronizing changes to replica: " +
destinationProvider.RootDirectoryPath);
_agent.StateChanged += (s, a) =>
{
if (a.OldState == SyncOrchestratorState.Uploading && a.NewState == SyncOrchestratorState.Ready)
{
string path = FileIO.GetPath(destinationReplicaRootPath);
string metadataFile = path + _metadataFile;
try
{
Logging.Log("Syncronization complete, cleanning up...");
File.Delete(metadataFile);
foreach (string tmpFile in Directory.EnumerateFiles(path, "*.tmp"))
{
File.Delete(tmpFile);
}
//FileSync.WatchFileSystem(sourceReplicaRootPath, destinationReplicaRootPath);
}
catch (Exception ex)
{
Logging.LogError(ex.Message);
}
}
};
_agent.SessionProgress += (s, a) =>
{
uint p = a.CompletedWork;
};
_agent.Synchronize();
//keep background worker alive
//while (true) { };
}
catch (Exception ex)
{
Logging.Log(ex.Message);
}
finally
{
// Release resources
if (sourceProvider != null)
{
sourceProvider.Dispose();
}
if (destinationProvider != null)
{
destinationProvider.Dispose();
}
//if (_agent != null) _agent.Cancel(); _agent = null;
}
}
public static void DetectChangesOnFileSystemReplica(string replicaRootPath, FileSyncScopeFilter filter, FileSyncOptions options, string metadataPath, string metadataFile, string tempDir, string trashDir)
{
FileSyncProvider provider = null;
try
{
provider = new FileSyncProvider(replicaRootPath, filter, options, metadataPath, metadataFile, tempDir, trashDir);
provider.DetectChanges();
}
finally
{
// Release resources
if (provider != null)
{
provider.Dispose();
}
}
}
/// <summary>
/// Start the synchronization in one direction
/// </summary>
/// <param name="sourcePath">This parameter holds the source folder path</param>
/// <param name="destPath">This parameter holds the destination folder path</param>
/// <param name="filter">This parameter is the filter which will be used during synchronization</param>
/// <param name="options">This parameter holds the synchronization options</param>
/// <param name="isPreview">This parameter is a boolean which indicates if this method should be run in preview mode</param>
/// <returns>Returns a boolean to indicate if the the synchronization was successful</returns>
private bool SyncFileSystemReplicasOneWay(string sourcePath, string destPath,
FileSyncScopeFilter filter, FileSyncOptions options, bool isPreview)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destProvider = null;
try
{
sourceProvider = new FileSyncProvider(sourcePath, filter, options);
destProvider = new FileSyncProvider(destPath, filter, options);
// When it's in preview mode, no actual changes are done.
// This mode is used to compute the number of changes that will be carried out later
if (isPreview)
{
sourceProvider.PreviewMode = true;
destProvider.PreviewMode = true;
}
else
{
sourceProvider.PreviewMode = false;
destProvider.PreviewMode = false;
}
if (isPreview)
{
if (!isCheckForLeftDone)
{
freeDiskSpaceForLeft = GetFreeDiskSpaceInBytes(sourcePath.Substring(0, 1));
freeDiskSpaceForRight = GetFreeDiskSpaceInBytes(destPath.Substring(0, 1));
}
}
destProvider.Configuration.ConflictResolutionPolicy = ConflictResolutionPolicy.ApplicationDefined;
SyncCallbacks destinationCallBacks = destProvider.DestinationCallbacks;
destinationCallBacks.ItemConflicting += new EventHandler<ItemConflictingEventArgs>(OnItemConflicting);
if (isPreview)
destProvider.ApplyingChange += new EventHandler<ApplyingChangeEventArgs>(OnApplyingChange);
else
destProvider.AppliedChange += new EventHandler<AppliedChangeEventArgs>(OnAppliedChange);
agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destProvider;
agent.Direction = SyncDirectionOrder.Upload;
agent.Synchronize();
if (isPreview)
return CheckSpace();
return true;
}
catch (SyncAbortedException e)
{
throw e;
}
finally
{
if (sourceProvider != null) sourceProvider.Dispose();
if (destProvider != null) destProvider.Dispose();
}
}
public void SyncFileSystemReplicasOneWay(SyncId sourceReplicaId, SyncId destinationReplicaId, string sourceReplicaRootPath, string destinationReplicaRootPath, FileSyncScopeFilter filter, FileSyncOptions options)
{
throw new System.NotImplementedException();
}
public static void SyncFileSystems(
string source,
string dest,
FileSyncScopeFilter filter,
FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destProvider = null;
try
{
sourceProvider = new FileSyncProvider(source, filter, options);
destProvider = new FileSyncProvider(dest, filter, options);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destProvider;
agent.Direction = SyncDirectionOrder.Upload;
destProvider.AppliedChange += destProvider_AppliedChange;
destProvider.SkippedChange += destProvider_SkippedChange;
// call backs so we can monitor...
SyncCallbacks destCallbacks = destProvider.DestinationCallbacks;
destCallbacks.ItemConflicting += destCallbacks_ItemConflicting;
destCallbacks.ItemConstraint += destCallbacks_ItemConstraint;
Console.WriteLine("sync to {0} from {1}", source, dest);
agent.Synchronize();
}
finally {
if (sourceProvider != null)
sourceProvider.Dispose();
if ( destProvider != null )
destProvider.Dispose() ;
}
}
/// <summary>
/// InternalExecute
/// </summary>
protected override void InternalExecute()
{
if (!this.TargetingLocalMachine())
{
return;
}
// Check that the Source exists
if (!Directory.Exists(this.Source.GetMetadata("FullPath")))
{
this.Log.LogError(string.Format(CultureInfo.CurrentCulture, "Source Folder does not exist: {0}", this.Source.GetMetadata("FullPath")));
return;
}
// Set the sync options
if (this.SyncOptions != null)
{
FileSyncOptions fso = this.SyncOptions.Aggregate(new FileSyncOptions(), (current, opt) => current | (FileSyncOptions)Enum.Parse(typeof(FileSyncOptions), opt.ItemSpec));
this.syncOptions = fso;
this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "SyncOptions set: {0}", this.syncOptions));
}
switch (this.TaskAction)
{
case "SyncFolders":
this.SyncFolders();
break;
default:
this.Log.LogError(string.Format(CultureInfo.CurrentCulture, "Invalid TaskAction passed: {0}", this.TaskAction));
return;
}
}
public void DetectChangesOnFileSystemReplica(SyncId replicaId, string replicaRootPath, FileSyncScopeFilter filter, FileSyncOptions options)
{
throw new System.NotImplementedException();
}
public static void DetectChanges(string root, FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider provider = null;
try
{
provider = new FileSyncProvider(root, filter, options);
provider.DetectChanges();
}
finally
{
if (provider != null)
provider.Dispose();
}
}
public static void SyncFileSystemReplicasOneWay(
SyncId sourceId, SyncId destId,
string sourceReplicaRootPath, string destinationReplicaRootPath,
DirectoryInfo syncDir,
string sourceMetadata, string targetMetadata,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
sourceProvider = new FileSyncProvider(
sourceId.GetGuidId(), sourceReplicaRootPath, filter, options, syncDir.FullName, sourceMetadata, syncDir.FullName,
null);
destinationProvider = new FileSyncProvider(
destId.GetGuidId(), destinationReplicaRootPath, filter, options, syncDir.FullName, targetMetadata, syncDir.FullName,
null);
destinationProvider.AppliedChange += OnAppliedChange;
destinationProvider.SkippedChange += OnSkippedChange;
SyncOrchestrator agent = new SyncOrchestrator
{
LocalProvider = sourceProvider,
RemoteProvider = destinationProvider,
Direction = SyncDirectionOrder.Upload
};
// Sync source to destination
//Console.WriteLine("Synchronizing changes to replica: " +
// destinationProvider.RootDirectoryPath);
agent.Synchronize();
}
finally
{
// Release resources
if (sourceProvider != null) sourceProvider.Dispose();
if (destinationProvider != null) destinationProvider.Dispose();
}
}
private static void SyncFileSystemReplicaOneWay(string replicaSourcePath, string replicaTargetPath, FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider targetProvider = null;
try
{
sourceProvider = new FileSyncProvider(replicaSourcePath, filter, options);
targetProvider = new FileSyncProvider(replicaTargetPath, filter, options);
targetProvider.AppliedChange += new EventHandler <AppliedChangeEventArgs>(OnAppliedChange);
targetProvider.SkippedChange += new EventHandler <SkippedChangeEventArgs>(OnSkippedChange);
SyncCallbacks targetCallbacks = targetProvider.DestinationCallbacks;
targetCallbacks.ItemConflicting += new EventHandler <ItemConflictingEventArgs>(OnItemConflicting);
targetCallbacks.ItemConstraint += new EventHandler <ItemConstraintEventArgs>(OnItemConstraint);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = targetProvider;
agent.Direction = SyncDirectionOrder.Upload;
Console.WriteLine("Sincronizando cambios: {0}", targetProvider.RootDirectoryPath);
agent.Synchronize();
}
finally
{
if (sourceProvider != null)
{
sourceProvider.Dispose();
}
if (targetProvider != null)
{
targetProvider.Dispose();
}
}
}
private static void DetectChangesOnFileSystemReplica(string replicaPath, FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider provider = null;
try
{
provider = new FileSyncProvider(replicaPath, filter, options);
provider.DetectChanges();
}
finally
{
if (provider != null)
{
provider.Dispose();
}
}
}
/// <summary>
/// Start the synchronization in one direction
/// </summary>
/// <param name="sourcePath">This parameter holds the source folder path</param>
/// <param name="destPath">This parameter holds the destination folder path</param>
/// <param name="filter">This parameter is the filter which will be used during synchronization</param>
/// <param name="options">This parameter holds the synchronization options</param>
private void SyncFileSystemReplicasOneWay(string sourcePath, string destPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destProvider = null;
try
{
sourceProvider = new FileSyncProvider(sourcePath, filter, options);
destProvider = new FileSyncProvider(destPath, filter, options);
sourceProvider.PreviewMode = true;
destProvider.PreviewMode = true;
destProvider.Configuration.ConflictResolutionPolicy = ConflictResolutionPolicy.ApplicationDefined;
SyncCallbacks destinationCallBacks = destProvider.DestinationCallbacks;
destinationCallBacks.ItemConflicting += new EventHandler<ItemConflictingEventArgs>(OnItemConflicting);
destinationCallBacks.ItemConstraint += new EventHandler<ItemConstraintEventArgs>(OnItemConstraint);
destProvider.ApplyingChange += new EventHandler<ApplyingChangeEventArgs>(OnApplyingChange);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destProvider;
agent.Direction = SyncDirectionOrder.Upload;
agent.Synchronize();
}
finally
{
if (sourceProvider != null) sourceProvider.Dispose();
if (destProvider != null) destProvider.Dispose();
}
}
public FileSyncProvider CreateProvider(string RootPath, FileSyncScopeFilter filter, FileSyncOptions options)
{
//throw new NotImplementedException();
FileSyncProvider provider = null;
try
{
provider = new FileSyncProvider(RootPath, filter, options);
}
catch (Exception e)
{
throw e;
}
return provider;
}
private void SyncFileSystemReplicasOneWay(string sourceReplicaRootPath, string destinationReplicaRootPath, FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
// Instantiate source and destination providers, with a null filter (the filter
// was specified in DetectChangesOnFileSystemReplica()), and options for both.
sourceProvider = new FileSyncProvider(sourceReplicaRootPath, filter, options);
destinationProvider = new FileSyncProvider(destinationReplicaRootPath, filter, options);
// Register event handlers so that we can write information
// to the console.
destinationProvider.AppliedChange += new EventHandler<AppliedChangeEventArgs>(OnAppliedChange);
destinationProvider.SkippedChange += new EventHandler<SkippedChangeEventArgs>(OnSkippedChange);
// Use SyncCallbacks for conflicting items.
SyncCallbacks destinationCallbacks = destinationProvider.DestinationCallbacks;
destinationCallbacks.ItemConflicting += new EventHandler<ItemConflictingEventArgs>(OnItemConflicting);
destinationCallbacks.ItemConstraint += new EventHandler<ItemConstraintEventArgs>(OnItemConstraint);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destinationProvider;
agent.Direction = SyncDirectionOrder.Upload; // Upload changes from the source to the destination.
//Console.WriteLine("Synchronizing changes to replica: " + destinationProvider.RootDirectoryPath);
if (logger != null)
{
logger.Info("Synchronizing changes to replica: " + destinationProvider.RootDirectoryPath);
}
agent.Synchronize();
}
finally
{
// Release resources.
if (sourceProvider != null) sourceProvider.Dispose();
if (destinationProvider != null) destinationProvider.Dispose();
}
}
//This is our way of abstracting out this dependency since I'm sure it probably ties
// us to the filesystem.
private FileSyncProvider createFileSyncProvider(Guid replicaId, string replicaRootPath, FileSyncScopeFilter filter, FileSyncOptions options)
{
var provider = new FileSyncProvider(replicaId, replicaRootPath, filter, options);
return provider;
}
//public static void DetectChangesOnFileSystemReplica(
//string replicaRootPath,
//FileSyncScopeFilter filter, FileSyncOptions options)
//{
// FileSyncProvider provider = null;
// try
// {
// provider = new FileSyncProvider(replicaRootPath, filter, options);
// provider.DetectChanges();
// }
// finally
// {
// // Release resources
// if (provider != null)
// provider.Dispose();
// }
//}
public static void SyncFileSystemReplicasOneWay(
string sourceReplicaRootPath, string destinationReplicaRootPath,
FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
sourceProvider = new FileSyncProvider(
sourceReplicaRootPath, filter, options);
//filter.SubdirectoryExcludes.Add(@".\");
destinationProvider = new FileSyncProvider(
destinationReplicaRootPath, filter, options);
sourceProvider.AppliedChange +=
new EventHandler<AppliedChangeEventArgs>(OnAppliedChange);
sourceProvider.SkippedChange +=
new EventHandler<SkippedChangeEventArgs>(OnSkippedChange);
sourceProvider.DetectChanges();
sourceProvider.CopyingFile += (s, a) =>
{
string file = a.FilePath;
int percent = a.PercentCopied;
};
sourceProvider.AppliedChange += (s, a) =>
{
string file = a.NewFilePath;
var change = a.ChangeType;
};
sourceProvider.DetectedChanges += (s, a) =>
{
//a.TotalDirectoriesFound
};
destinationProvider.CopyingFile += (s, a) =>
{
string file = a.FilePath;
int percent = a.PercentCopied;
FileIO.FileTransferProgress(null, new FileTransferProgressEventArgs(percent, Path.GetFileName(file)));
};
destinationProvider.AppliedChange += (s, a) =>
{
string file = a.NewFilePath;
};
destinationProvider.AppliedChange += (s, a) =>
{
if (a.ChangeType == ChangeType.Delete) return;
string file = a.NewFilePath;
string serverPath = FileIO.GetPath(destinationReplicaRootPath) + file;
if (FileIO.IsDirectory(serverPath)) return;
FileIO.FinshedFileTransfer(null, new FinshedFileTransferEventArgs(Path.GetFileName(serverPath)));
string localDirectory = FileIO.GetPath(FileIO.GetPath(sourceReplicaRootPath) + file);
string localFile = localDirectory + Path.GetFileName(file);
string topLevelDir = FileIO.GetPath(sourceReplicaRootPath) + FileIO.GetTopLevelFolder(file);
try
{
File.Delete(localFile);
}
catch (Exception ex) { Logging.Log(ex.Message); }
if (topLevelDir == FileIO.GetPath(sourceReplicaRootPath)) return;
//bool isMoreTransfers = filter.FileNameIncludes.Any(x => Directory.GetFiles(localDirectory, x) != null);
foreach(string filterVal in filter.FileNameIncludes)
{
if (Directory.EnumerateFiles(topLevelDir, filterVal, SearchOption.AllDirectories).Count() > 0) return;
}
//if (isMoreTransfers) return;
try
{
FileIO.ForceDeleteDirectory(topLevelDir);
}
catch (Exception ex) { Logging.Log(ex.Message); }
};
//SyncOrchestrator agent = new SyncOrchestrator();
_agent.LocalProvider = sourceProvider;
_agent.RemoteProvider = destinationProvider;
_agent.Direction = SyncDirectionOrder.Upload;
Logging.Log("Synchronizing changes to replica: " +
destinationProvider.RootDirectoryPath);
_agent.StateChanged += (s, a) =>
{
if (a.OldState == SyncOrchestratorState.Uploading && a.NewState == SyncOrchestratorState.Ready)
{
string path = FileIO.GetPath(destinationReplicaRootPath);
string metadataFile = path + _metadataFile;
try
{
Logging.Log("Syncronization complete, cleanning up...");
File.Delete(metadataFile);
foreach (string tmpFile in Directory.EnumerateFiles(path, "*.tmp"))
{
File.Delete(tmpFile);
}
//FileSync.WatchFileSystem(sourceReplicaRootPath, destinationReplicaRootPath);
}
catch (Exception ex)
{
Logging.LogError(ex.Message);
}
}
};
_agent.SessionProgress += (s, a) =>
{
uint p = a.CompletedWork;
};
_agent.Synchronize();
//keep background worker alive
//while (true) { };
}
catch (Exception ex)
{
Logging.Log(ex.Message);
}
finally
{
// Release resources
if (sourceProvider != null) sourceProvider.Dispose();
if (destinationProvider != null) destinationProvider.Dispose();
//if (_agent != null) _agent.Cancel(); _agent = null;
}
}
//public static void SyncFileSystemReplicasOneWay(string sourceReplicaRootPath, string destinationReplicaRootPath, FileSyncScopeFilter filter, FileSyncOptions options, string metadataPath1, string metadataFile1, string metadataPath2, string metadataFile2, string tempDir = null, string trashDir = null)
//{
// FileSyncProvider sourceProvider = null;
// FileSyncProvider destProvider = null;
// try
// {
// sourceProvider = new FileSyncProvider(sourceReplicaRootPath, filter, options);
// destProvider = new FileSyncProvider(destinationReplicaRootPath, filter, options);
// sourceProvider.DetectChanges();
// destProvider.DetectChanges();
// //启动和控制同步会话。
// SyncOrchestrator agent = new SyncOrchestrator();
// agent.LocalProvider = sourceProvider;
// agent.RemoteProvider = destProvider;
// agent.Direction = SyncDirectionOrder.Upload;
// agent.Synchronize(); //此处开始执行文件（夹）同步。
// }
// finally
// {
// if (sourceProvider != null) sourceProvider.Dispose();
// if (destProvider != null) destProvider.Dispose();
// }
//}
public static void SyncFileSystemReplicasOneWay(string sourceReplicaRootPath, string destinationReplicaRootPath, FileSyncScopeFilter filter, FileSyncOptions options, string metadataPath1, string metadataFile1, string metadataPath2, string metadataFile2, string tempDir, string trashDir,
ref SyncOperationStatistics syncOperationStatistics)
{
FileSyncProvider sourceProvider = null;
FileSyncProvider destinationProvider = null;
try
{
sourceProvider = new FileSyncProvider(sourceReplicaRootPath, filter, options, metadataPath1, metadataFile1, tempDir, trashDir);
destinationProvider = new FileSyncProvider(destinationReplicaRootPath, filter, options, metadataPath2, metadataFile2, tempDir, trashDir);
//destinationProvider.AppliedChange += new EventHandler<AppliedChangeEventArgs>(OnAppliedChange);
//destinationProvider.SkippedChange += new EventHandler<SkippedChangeEventArgs>(OnSkippedChange);
SyncOrchestrator agent = new SyncOrchestrator();
agent.LocalProvider = sourceProvider;
agent.RemoteProvider = destinationProvider;
agent.Direction = SyncDirectionOrder.Upload; // Sync source to destination
Console.WriteLine("Synchronizing changes to replica: " + destinationProvider.RootDirectoryPath);
syncOperationStatistics = agent.Synchronize();
}
catch (Exception e)
{
throw e;
}
finally
{
// Release resources
if (sourceProvider != null)
{
sourceProvider.Dispose();
}
if (destinationProvider != null)
{
destinationProvider.Dispose();
}
}
}
public static void OneWaySyncFileSystemReplicas(string sourceReplicaRootPath, string destinationReplicaRootPath, FileSyncScopeFilter filter, FileSyncOptions options)
{
FileSyncProvider path1Provider = null;
FileSyncProvider path2Provider = null;
try
{
path1Provider = new FileSyncProvider(sourceReplicaRootPath, filter, options);
path2Provider = new FileSyncProvider(destinationReplicaRootPath, filter, options);
path2Provider.SkippedChange += OnSkippedChange;
path2Provider.AppliedChange += OnAppliedChange;
SyncOrchestrator manager = new SyncOrchestrator();
manager.LocalProvider = path1Provider;
manager.RemoteProvider = path2Provider;
manager.Direction = SyncDirectionOrder.Upload;
manager.Synchronize();
}
finally
{
if (path1Provider != null)
path1Provider.Dispose();
if (path2Provider != null)
path2Provider.Dispose();
}
}
