public async Task ShouldThrowIfFileSystemDoesNotExist()
{
using (var store = NewStore())
{
var server = GetServer();
var outputDirectory = Path.Combine(server.Configuration.DataDirectory, "Export");
try
{
var smugglerApi = new SmugglerFilesApi();
var options = new FilesConnectionStringOptions
{
Url = store.Url,
DefaultFileSystem = "DoesNotExist"
};
var message = string.Format("Smuggler does not support file system creation (file system 'DoesNotExist' on server '{0}' must exist before running Smuggler).", store.Url);
var e = await AssertAsync.Throws<SmugglerException>(() => smugglerApi.ExportData(new SmugglerExportOptions<FilesConnectionStringOptions> { ToFile = outputDirectory.ToFullPath(), From = options }));
Assert.Equal(message, e.Message);
e = await AssertAsync.Throws<SmugglerException>(() => smugglerApi.ImportData(new SmugglerImportOptions<FilesConnectionStringOptions> { FromFile = outputDirectory.ToFullPath(), To = options }));
Assert.Equal(message, e.Message);
}
finally
{
IOExtensions.DeleteDirectory(outputDirectory);
}
}
}
public async Task CanDisableVersioningDuringImport()
{
long fileCount;
string export = Path.Combine(NewDataPath("export_3219"), "Export");
using (var store = NewStore())
{
for (int i = 0; i < 10; i++)
{
await store.AsyncFilesCommands.UploadAsync("test-" + i, StringToStream("hello"));
}
var options = new FilesConnectionStringOptions
{
Url = store.Url,
DefaultFileSystem = store.DefaultFileSystem
};
var smuggler = new SmugglerFilesApi();
await smuggler.ExportData(new SmugglerExportOptions<FilesConnectionStringOptions>
{
From = options,
ToFile = export
});
fileCount = (await store.AsyncFilesCommands.GetStatisticsAsync()).FileCount;
}
using (var store = NewStore(activeBundles: "Versioning", fileSystemName: "Import", index: 1))
{
await store.AsyncFilesCommands.Configuration.SetKeyAsync(VersioningUtil.DefaultConfigurationName, new VersioningConfiguration
{
Id = VersioningUtil.DefaultConfigurationName
});
var smuggler = new SmugglerFilesApi(new SmugglerFilesOptions()
{
ShouldDisableVersioningBundle = true
});
var options = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = store.DefaultFileSystem };
await smuggler.ImportData(new SmugglerImportOptions<FilesConnectionStringOptions> { FromFile = export, To = options });
var fileCountAfterImport = (await store.AsyncFilesCommands.GetStatisticsAsync()).FileCount;
Assert.Equal(fileCount, fileCountAfterImport);
// after import versioning should be active
await store.AsyncFilesCommands.UploadAsync("with-rev", StringToStream("rev"));
using (var session = store.OpenAsyncSession())
{
var revisions = await session.GetRevisionsForAsync("with-rev", 0, 10);
Assert.Equal(1, revisions.Length);
}
}
}
public async Task SmugglerCanStripReplicationInformationDuringImport()
{
using (var store = NewStore())
{
var server = GetServer();
var outputDirectory = Path.Combine(server.Configuration.DataDirectory, "Export");
try
{
await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync("N1");
await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync("N2");
var content = new MemoryStream(new byte[] { 1, 2, 3 })
{
Position = 0
};
var commands = store.AsyncFilesCommands.ForFileSystem("N1");
await commands.UploadAsync("test.bin", content, new RavenJObject { { "test", "value" } });
var metadata = await commands.GetMetadataForAsync("test.bin");
var source1 = metadata[SynchronizationConstants.RavenSynchronizationSource];
var version1 = metadata[SynchronizationConstants.RavenSynchronizationVersion];
var history1 = metadata[SynchronizationConstants.RavenSynchronizationHistory] as RavenJArray;
Assert.NotNull(source1);
Assert.NotNull(version1);
Assert.NotNull(history1);
Assert.Empty(history1);
var smugglerApi = new SmugglerFilesApi(new SmugglerFilesOptions { StripReplicationInformation = true });
var export = await smugglerApi.ExportData(new SmugglerExportOptions<FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = "N1" }, ToFile = outputDirectory });
await smugglerApi.ImportData(new SmugglerImportOptions<FilesConnectionStringOptions> { FromFile = export.FilePath, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = "N2" } });
commands = store.AsyncFilesCommands.ForFileSystem("N2");
metadata = await commands.GetMetadataForAsync("test.bin");
var source2 = metadata[SynchronizationConstants.RavenSynchronizationSource];
var version2 = metadata[SynchronizationConstants.RavenSynchronizationVersion];
var history2 = metadata[SynchronizationConstants.RavenSynchronizationHistory] as RavenJArray;
Assert.NotEqual(source1, source2);
Assert.Equal(version1, version2);
Assert.NotNull(history2);
Assert.Empty(history2);
}
finally
{
IOExtensions.DeleteDirectory(outputDirectory);
}
}
}
public async Task ShouldNotThrowIfFileSystemExists()
{
using (var store = NewStore(fileSystemName: "DoesExists", requestedStorage: "esent"))
{
var server = GetServer();
var outputDirectory = Path.Combine(server.Configuration.DataDirectory, "Export");
try
{
await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(store.DefaultFileSystem);
await InitializeWithRandomFiles(store, 2, 4);
var options = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = store.DefaultFileSystem };
var smugglerApi = new SmugglerFilesApi();
var export = await smugglerApi.ExportData(new SmugglerExportOptions<FilesConnectionStringOptions> { From = options, ToFile = outputDirectory });
await smugglerApi.ImportData(new SmugglerImportOptions<FilesConnectionStringOptions> { FromFile = export.FilePath, To = options });
}
finally
{
IOExtensions.DeleteDirectory(outputDirectory);
}
}
}
public async Task ShouldNotThrowIfFileSystemExistsUsingDefaultConfiguration()
{
using (var store = NewStore())
{
var server = GetServer();
var outputDirectory = Path.Combine(server.Configuration.DataDirectory, "Export");
try
{
await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(store.DefaultFileSystem);
await InitializeWithRandomFiles(store, 1, 100);
var options = new FilesConnectionStringOptions {Url = store.Url, DefaultFileSystem = store.DefaultFileSystem};
var smugglerApi = new SmugglerFilesApi();
var export = await smugglerApi.ExportData(new SmugglerExportOptions<FilesConnectionStringOptions> { From = options, ToFile = outputDirectory.ToFullPath() });
await smugglerApi.ImportData(new SmugglerImportOptions<FilesConnectionStringOptions> { FromFile = export.FilePath, To = options });
await VerifyDump(store, export.FilePath, s =>
{
using (var session = s.OpenAsyncSession())
{
var files = s.AsyncFilesCommands.BrowseAsync().Result;
Assert.Equal(1, files.Count());
}
});
}
finally
{
IOExtensions.DeleteDirectory(outputDirectory);
}
}
}
private async Task VerifyDump(FilesStore store, string backupPath, Action<FilesStore> action)
{
try
{
store.DefaultFileSystem += "-Verify";
await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(store.DefaultFileSystem);
bool incremental = false;
var directory = new DirectoryInfo(backupPath);
if ( directory.Exists )
incremental = true;
var dumper = new SmugglerFilesApi { Options = { Incremental = incremental } };
await dumper.ImportData(new SmugglerImportOptions<FilesConnectionStringOptions>
{
FromFile = backupPath,
To = new FilesConnectionStringOptions
{
Url = store.Url,
DefaultFileSystem = store.DefaultFileSystem,
}
});
action(store);
}
catch (Exception e)
{
throw e.SimplifyException();
}
}
public async Task BehaviorWhenServerIsDown()
{
using (var store = NewStore())
{
var server = GetServer();
var outputDirectory = Path.Combine(server.Configuration.DataDirectory, "Export");
try
{
var options = new FilesConnectionStringOptions { Url = "http://localhost:8078/", DefaultFileSystem = store.DefaultFileSystem };
var smugglerApi = new SmugglerFilesApi();
var e = await AssertAsync.Throws<SmugglerException>(() => smugglerApi.ImportData(new SmugglerImportOptions<FilesConnectionStringOptions> { FromFile = outputDirectory.ToFullPath(), To = options }));
Assert.Contains("Smuggler encountered a connection problem:", e.Message);
e = await AssertAsync.Throws<SmugglerException>(() => smugglerApi.ExportData(new SmugglerExportOptions<FilesConnectionStringOptions> { ToFile = outputDirectory.ToFullPath(), From = options }));
Assert.Contains("Smuggler encountered a connection problem:", e.Message);
}
finally
{
IOExtensions.DeleteDirectory(outputDirectory);
}
}
}
