public void Should_not_perform_file_delete_if_it_is_being_synced() { var filename = FileHeader.Canonize("file.bin"); var client = NewAsyncClient(); var rfs = GetFileSystem(); client.UploadAsync("file.bin", new MemoryStream(new byte[] { 1, 2, 3, 4, 5 })).Wait(); rfs.Files.IndicateFileToDelete(filename, null); rfs.Storage.Batch(accessor => accessor.SetConfigurationValue(RavenFileNameHelper.SyncLockNameForFile(filename), LockFileTests.SynchronizationConfig(DateTime.UtcNow))); rfs.Files.CleanupDeletedFilesAsync().Wait(); DeleteFileOperation deleteFile = null; rfs.Storage.Batch(accessor => deleteFile = accessor.GetConfigurationValue <DeleteFileOperation>(RavenFileNameHelper.DeleteOperationConfigNameForFile(RavenFileNameHelper.DeletingFileName(filename)))); Assert.Equal(RavenFileNameHelper.DeletingFileName(filename), deleteFile.CurrentFileName); Assert.Equal(filename, deleteFile.OriginalFileName); }
public void Should_not_delete_downloading_file_if_synchronization_retry_is_being_performed() { const string fileName = "file.bin"; var downloadingFileName = RavenFileNameHelper.DownloadingFileName(fileName); var client = NewAsyncClient(); var rfs = GetFileSystem(); client.UploadAsync(fileName, new RandomStream(1)).Wait(); client.UploadAsync(downloadingFileName, new RandomStream(1)).Wait(); rfs.Files.IndicateFileToDelete(downloadingFileName, null); rfs.Storage.Batch(accessor => accessor.SetConfigurationValue(RavenFileNameHelper.SyncLockNameForFile(fileName), LockFileTests.SynchronizationConfig(DateTime.UtcNow))); rfs.Files.CleanupDeletedFilesAsync().Wait(); DeleteFileOperation deleteFile = null; rfs.Storage.Batch(accessor => deleteFile = accessor.GetConfigurationValue <DeleteFileOperation>(RavenFileNameHelper.DeleteOperationConfigNameForFile(RavenFileNameHelper.DeletingFileName(downloadingFileName)))); Assert.Equal(RavenFileNameHelper.DeletingFileName(downloadingFileName), deleteFile.CurrentFileName); Assert.Equal(downloadingFileName, deleteFile.OriginalFileName); }
public async Task Make_sure_that_locks_are_released_after_synchronization_when_two_files_synchronized_simultaneously() { var sourceClient = NewAsyncClient(0); var destinationClient = NewAsyncClient(1); var source1Content = new RandomStream(10000); await sourceClient.UploadAsync("test1.bin", source1Content); var source2Content = new RandomStream(10000); await sourceClient.UploadAsync("test2.bin", source2Content); await sourceClient.Synchronization.SetDestinationsAsync(destinationClient.ToSynchronizationDestination()); await sourceClient.Synchronization.SynchronizeAsync(); var configs = await destinationClient.Configuration.GetKeyNamesAsync(); Assert.DoesNotContain(RavenFileNameHelper.SyncLockNameForFile("test1.bin"), configs); Assert.DoesNotContain(RavenFileNameHelper.SyncLockNameForFile("test2.bin"), configs); // also make sure that results exist Assert.Contains(RavenFileNameHelper.SyncResultNameForFile("test1.bin"), configs); Assert.Contains(RavenFileNameHelper.SyncResultNameForFile("test2.bin"), configs); }
private static void ZeroTimeoutTest(IAsyncFilesCommands destinationClient, Action action) { destinationClient.Configuration.SetKeyAsync(RavenFileNameHelper.SyncLockNameForFile("test.bin"), SynchronizationConfig(DateTime.MinValue)).Wait(); destinationClient.Configuration.SetKeyAsync(SynchronizationConstants.RavenSynchronizationLockTimeout, TimeSpan.FromSeconds(0)).Wait(); Assert.DoesNotThrow(() => action()); }
public void UnlockByDeletingSyncConfiguration(string fileName, IStorageActionsAccessor accessor) { accessor.DeleteConfig(RavenFileNameHelper.SyncLockNameForFile(fileName)); if (log.IsDebugEnabled) { log.Debug("File '{0}' was unlocked", fileName); } }
public void LockByCreatingSyncConfiguration(string fileName, ServerInfo sourceServer, IStorageActionsAccessor accessor) { var syncLock = new SynchronizationLock { SourceServer = sourceServer, FileLockedAt = DateTime.UtcNow }; accessor.SetConfig(RavenFileNameHelper.SyncLockNameForFile(fileName), JsonExtensions.ToJObject(syncLock)); log.Debug("File '{0}' was locked", fileName); }
public async void Should_refuse_to_synchronize_file_while_sync_configuration_exists() { IAsyncFilesCommands destinationClient; IAsyncFilesCommands sourceClient; UploadFilesSynchronously(out sourceClient, out destinationClient); await destinationClient.Configuration.SetKeyAsync(RavenFileNameHelper.SyncLockNameForFile("test.bin"), SynchronizationConfig(DateTime.UtcNow)); var synchronizationReport = SyncTestUtils.ResolveConflictAndSynchronize(sourceClient, destinationClient, "test.bin"); Assert.Equal(string.Format("File {0} is being synced", FileHeader.Canonize("test.bin")), synchronizationReport.Exception.Message); }
public async void Should_refuse_to_synchronize_file_while_sync_configuration_exists() { RavenFileSystemClient destinationClient; RavenFileSystemClient sourceClient; UploadFilesSynchronously(out sourceClient, out destinationClient); await destinationClient.Config.SetConfig(RavenFileNameHelper.SyncLockNameForFile("test.bin"), SynchronizationConfig(DateTime.UtcNow)); var synchronizationReport = SyncTestUtils.ResolveConflictAndSynchronize(sourceClient, destinationClient, "test.bin"); Assert.Equal("File test.bin is being synced", synchronizationReport.Exception.Message); }
public async Task Should_refuse_to_upload_file_while_sync_configuration_exists() { IAsyncFilesCommands destinationClient; IAsyncFilesCommands sourceClient; UploadFilesSynchronously(out sourceClient, out destinationClient); await destinationClient.Configuration.SetKeyAsync(RavenFileNameHelper.SyncLockNameForFile("test.bin"), SynchronizationConfig(DateTime.UtcNow)); var innerException = SyncTestUtils.ExecuteAndGetInnerException(async() => await destinationClient.UploadAsync("test.bin", new MemoryStream())); Assert.IsType(typeof(SynchronizationException), innerException.GetBaseException()); Assert.Equal(string.Format("File {0} is being synced", FileHeader.Canonize("test.bin")), innerException.GetBaseException().Message); }
public async Task Should_refuse_to_delete_file_while_sync_configuration_exists() { RavenFileSystemClient destinationClient; RavenFileSystemClient sourceClient; UploadFilesSynchronously(out sourceClient, out destinationClient); await destinationClient.Config.SetConfig(RavenFileNameHelper.SyncLockNameForFile("test.bin"), SynchronizationConfig(DateTime.UtcNow)); var innerException = SyncTestUtils.ExecuteAndGetInnerException(async() => await destinationClient.DeleteAsync("test.bin")); Assert.IsType(typeof(SynchronizationException), innerException.GetBaseException()); Assert.Equal("File test.bin is being synced", innerException.GetBaseException().Message); }
public async Task Should_refuse_to_update_metadata_while_sync_configuration_exists() { IAsyncFilesCommands destinationClient; IAsyncFilesCommands sourceClient; UploadFilesSynchronously(out sourceClient, out destinationClient); await destinationClient.Configuration.SetKeyAsync(RavenFileNameHelper.SyncLockNameForFile("test.bin"), SynchronizationConfig(DateTime.UtcNow)); var innerException = SyncTestUtils.ExecuteAndGetInnerException(async() => await destinationClient.UpdateMetadataAsync("test.bin", new RavenJObject())); Assert.IsType(typeof(SynchronizationException), innerException.GetBaseException()); Assert.Equal("File test.bin is being synced", innerException.GetBaseException().Message); }
public bool TimeoutExceeded(string fileName, IStorageActionsAccessor accessor) { SynchronizationLock syncLock; try { syncLock = accessor.GetConfig(RavenFileNameHelper.SyncLockNameForFile(fileName)).JsonDeserialization <SynchronizationLock>(); } catch (FileNotFoundException) { return(true); } return(DateTime.UtcNow - syncLock.FileLockedAt > SynchronizationTimeout(accessor)); }
public async Task Should_delete_sync_configuration_after_synchronization() { IAsyncFilesCommands destinationClient; IAsyncFilesCommands sourceClient; UploadFilesSynchronously(out sourceClient, out destinationClient); await sourceClient.Synchronization.StartAsync("test.bin", destinationClient); var config = await destinationClient.Configuration.GetKeyAsync <SynchronizationLock>(RavenFileNameHelper.SyncLockNameForFile("test.bin")); Assert.Null(config); }