private void RemoveSyncingConfiguration(string fileName, string destination)
{
try
{
var name = RavenFileNameHelper.SyncNameForFile(fileName, destination);
storage.Batch(accessor => accessor.DeleteConfig(name));
}
catch (Exception e)
{
Log.WarnException(
string.Format("Could not remove syncing configurations for a file {0} and a destination {1}", fileName, destination),
e);
}
}
private IEnumerable <SynchronizationDetails> GetSyncingConfigurations(SynchronizationDestination destination)
{
var configObjects = new List <SynchronizationDetails>();
try
{
storage.Batch(
accessor =>
{
configObjects = accessor.GetConfigsStartWithPrefix(RavenFileNameHelper.SyncNameForFile(string.Empty, destination.Url), 0, 100)
.Select(config => config.JsonDeserialization <SynchronizationDetails>())
.ToList();
});
}
catch (Exception e)
{
Log.WarnException(string.Format("Could not get syncing configurations for a destination {0}", destination), e);
}
return(configObjects);
}
private void CreateSyncingConfiguration(string fileName, Guid etag, string destinationFileSystemUrl, SynchronizationType synchronizationType)
{
try
{
var name = RavenFileNameHelper.SyncNameForFile(fileName, destinationFileSystemUrl);
var details = new SynchronizationDetails
{
DestinationUrl = destinationFileSystemUrl,
FileName = fileName,
FileETag = etag,
Type = synchronizationType
};
storage.Batch(accessor => accessor.SetConfig(name, JsonExtensions.ToJObject(details)));
}
catch (Exception e)
{
Log.WarnException(
string.Format("Could not create syncing configurations for a file {0} and destination {1}", fileName, destinationFileSystemUrl),
e);
}
}
public async Task Source_should_delete_configuration_record_if_destination_confirm_that_file_is_safe()
{
var sourceClient = NewAsyncClient(0);
var sourceContent = new RandomStream(10000);
var destinationClient = (IAsyncFilesCommandsImpl)NewAsyncClient(1);
await sourceClient.UploadAsync("test.bin", sourceContent);
await sourceClient.Synchronization.SetDestinationsAsync(destinationClient.ToSynchronizationDestination());
await sourceClient.Synchronization.SynchronizeAsync();
// start synchronization again to force confirmation by source
await sourceClient.Synchronization.SynchronizeAsync();
var shouldBeNull = await sourceClient.Configuration.GetKeyAsync <SynchronizationDetails>(RavenFileNameHelper.SyncNameForFile("test.bin", destinationClient.ServerUrl));
Assert.Null(shouldBeNull);
}
public async Task Source_should_save_configuration_record_after_synchronization()
{
var sourceClient = NewAsyncClient(0);
var sourceContent = new RandomStream(10000);
var destinationClient = NewAsyncClient(1);
await sourceClient.UploadAsync("test.bin", sourceContent);
await sourceClient.Synchronization.SetDestinationsAsync(destinationClient.ToSynchronizationDestination());
await sourceClient.Synchronization.SynchronizeAsync();
var fullDstUrl = destinationClient.ToSynchronizationDestination().FileSystemUrl;
var synchronizationDetails = sourceClient.Configuration.GetKeyAsync <SynchronizationDetails>(RavenFileNameHelper.SyncNameForFile("test.bin", fullDstUrl)).Result;
Assert.Equal("test.bin", synchronizationDetails.FileName);
Assert.Equal(fullDstUrl, synchronizationDetails.DestinationUrl);
Assert.NotEqual(Guid.Empty, synchronizationDetails.FileETag);
Assert.Equal(SynchronizationType.ContentUpdate, synchronizationDetails.Type);
}
public async Task Source_should_remove_syncing_item_if_conflict_was_resolved_on_destination_by_remote()
{
var sourceClient = NewAsyncClient(0);
var destinationClient = (IAsyncFilesCommandsImpl)NewAsyncClient(1);
await sourceClient.UploadAsync("test", new MemoryStream(new byte[] { 1, 2, 3 }));
await destinationClient.UploadAsync("test", new MemoryStream(new byte[] { 1, 2 }));
var shouldBeConflict = await sourceClient.Synchronization.StartAsync("test", destinationClient);
Assert.Equal(string.Format("File {0} is conflicted", FileHeader.Canonize("test")), shouldBeConflict.Exception.Message);
await destinationClient.Synchronization.ResolveConflictAsync("test", ConflictResolutionStrategy.RemoteVersion);
await sourceClient.Synchronization.SetDestinationsAsync(destinationClient.ToSynchronizationDestination());
var report = await sourceClient.Synchronization.SynchronizeAsync();
Assert.Null(report.ToArray()[0].Exception);
var syncingItem = await sourceClient.Configuration.GetKeyAsync <SynchronizationDetails>(RavenFileNameHelper.SyncNameForFile("test", destinationClient.ServerUrl));
Assert.Null(syncingItem);
}
public async Task Source_should_remove_syncing_item_if_conflict_was_resolved_on_destination_by_current()
{
var sourceClient = NewClient(0);
var destinationClient = NewClient(1);
await sourceClient.UploadAsync("test", new MemoryStream(new byte[] { 1, 2, 3 }));
await destinationClient.UploadAsync("test", new MemoryStream(new byte[] { 1, 2 }));
var shouldBeConflict = await sourceClient.Synchronization.StartAsync("test", destinationClient);
Assert.Equal("File test is conflicted", shouldBeConflict.Exception.Message);
await destinationClient.Synchronization.ResolveConflictAsync("test", ConflictResolutionStrategy.CurrentVersion);
await sourceClient.Config.SetDestinationsConfig(destinationClient.ToSynchronizationDestination());
var report = await sourceClient.Synchronization.SynchronizeDestinationsAsync();
Assert.Null(report.ToArray()[0].Exception);
var syncingItem = await sourceClient.Config.GetConfig <SynchronizationDetails>(RavenFileNameHelper.SyncNameForFile("test", destinationClient.ServerUrl));
Assert.Null(syncingItem);
}