public async Task BetweenOperation_ShouldNotCreateFilesystem() { using (var store = NewStore()) { var smugglerApi = new SmugglerFilesApi(); var options = new SmugglerBetweenOptions<FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = SourceFilesystem }, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = DestinationFilesystem } }; var exception = await AssertAsync.Throws<SmugglerException>(() => smugglerApi.Between(options)); Assert.True(exception.Message.StartsWith("Smuggler does not support file system creation (file system '" + SourceFilesystem + "' on server")); await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(SourceFilesystem); exception = await AssertAsync.Throws<SmugglerException>(() => smugglerApi.Between(options)); Assert.True(exception.Message.StartsWith("Smuggler does not support file system creation (file system '" + DestinationFilesystem + "' on server")); } }
public void SmugglerBetweenOperationShouldNotCreateDatabases() { using (var store = NewRemoteDocumentStore()) { var smugglerApi = new SmugglerDatabaseApi(); var options = new SmugglerBetweenOptions<RavenConnectionStringOptions> { From = new RavenConnectionStringOptions { Url = store.Url, DefaultDatabase = "DB1" }, To = new RavenConnectionStringOptions { Url = store.Url, DefaultDatabase = "DB2" } }; var aggregateException = Assert.Throws<AggregateException>(() => smugglerApi.Between(options).Wait()); var exception = aggregateException.ExtractSingleInnerException(); Assert.True(exception.Message.StartsWith("Smuggler does not support database creation (database 'DB1' on server")); store.DatabaseCommands.GlobalAdmin.EnsureDatabaseExists("DB1"); aggregateException = Assert.Throws<AggregateException>(() => smugglerApi.Between(options).Wait()); exception = aggregateException.ExtractSingleInnerException(); Assert.True(exception.Message.StartsWith("Smuggler does not support database creation (database 'DB2' on server")); } }
private async Task <Etag> CopyBetweenStores(SmugglerBetweenOptions <FilesConnectionStringOptions> options, Etag lastEtag, Etag maxEtag) { var totalCount = 0; var lastReport = SystemTime.UtcNow; var reportInterval = TimeSpan.FromSeconds(10); Operations.ShowProgress("Exporting Files"); Exception exceptionHappened = null; try { using (var files = await Operations.GetFiles(options.From, lastEtag, Math.Min(Options.BatchSize, int.MaxValue))) { while (await files.MoveNextAsync()) { var file = files.Current; var tempLastEtag = file.Etag; if (maxEtag != null && tempLastEtag.CompareTo(maxEtag) > 0) { break; } var downloadedFile = await Operations.DownloadFile(file); await Operations.PutFiles(file, downloadedFile, file.TotalSize.Value); lastEtag = tempLastEtag; totalCount++; if (totalCount % 1000 == 0 || SystemTime.UtcNow - lastReport > reportInterval) { //TODO: Show also the MB/sec and total GB exported. Operations.ShowProgress("Exported {0} files. ", totalCount); lastReport = SystemTime.UtcNow; } } } } catch (Exception e) { Operations.ShowProgress("Got Exception during smuggler export. Exception: {0}. ", e.Message); Operations.ShowProgress("Done with reading files, total: {0}, lastEtag: {1}", totalCount, lastEtag); exceptionHappened = new SmugglerExportException(e.Message, e) { LastEtag = lastEtag, }; } if (exceptionHappened != null) { throw exceptionHappened; } Operations.ShowProgress("Done with reading documents, total: {0}, lastEtag: {1}", totalCount, lastEtag); return(lastEtag); }
public virtual async Task Between(SmugglerBetweenOptions <FilesConnectionStringOptions> betweenOptions) { Operations.Configure(Options); Operations.Initialize(Options); try { await DetectServerSupportedFeatures(betweenOptions.From); await DetectServerSupportedFeatures(betweenOptions.To); } catch (WebException e) { throw new SmugglerExportException("Failed to query server for supported features. Reason : " + e.Message) { LastEtag = Etag.Empty, }; } if (string.IsNullOrWhiteSpace(betweenOptions.IncrementalKey)) { betweenOptions.IncrementalKey = Operations.CreateIncrementalKey(); } var incremental = new ExportFilesDestinationKey(); if (this.Options.Incremental) { var smugglerExportIncremental = await Operations.GetIncrementalExportKey(); // importStore.AsyncFilesCommands.Configuration.GetKeyAsync<SmugglerExportIncremental>(SmugglerExportIncremental.RavenDocumentKey); ExportFilesDestinationKey value; if (smugglerExportIncremental.Destinations.TryGetValue(betweenOptions.IncrementalKey, out value)) { incremental = value; } this.Options.StartFilesEtag = incremental.LastEtag ?? Etag.Empty; } var result = new ExportFilesResult { LastFileEtag = Options.StartFilesEtag, }; // used to synchronize max returned values for put/delete operations var maxEtags = Operations.FetchCurrentMaxEtags(); incremental.LastEtag = await CopyBetweenStores(result.LastFileEtag, maxEtags.LastFileEtag); if (this.Options.Incremental) { var smugglerExportIncremental = await Operations.GetIncrementalExportKey(); smugglerExportIncremental.Destinations[betweenOptions.IncrementalKey] = incremental; await Operations.PutIncrementalExportKey(smugglerExportIncremental); // importStore.AsyncFilesCommands.Configuration.SetKeyAsync<SmugglerExportIncremental>(SmugglerExportIncremental.RavenDocumentKey, smugglerExportIncremental); } }
public async Task BetweenOperation_BehaviorWhenServerIsDown() { string dataDirectory = null; try { using (var store = NewStore()) { var server = GetServer(); var smugglerApi = new SmugglerFilesApi(); var options = new SmugglerBetweenOptions<FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = "http://localhost:8078/", DefaultFileSystem = SourceFilesystem }, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = DestinationFilesystem } }; await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(SourceFilesystem); await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(DestinationFilesystem); var e = await AssertAsync.Throws<SmugglerException>(() => smugglerApi.Between(options)); Assert.Contains("Smuggler encountered a connection problem:", e.Message); options.From.Url = store.Url; options.To.Url = "http://localhost:8078/"; e = await AssertAsync.Throws<SmugglerException>(() => smugglerApi.Between(options)); Assert.Contains("Smuggler encountered a connection problem:", e.Message); server.Dispose(); } } finally { if (!string.IsNullOrWhiteSpace(dataDirectory)) IOExtensions.DeleteDirectory(dataDirectory); } }
public override async Task Between(SmugglerBetweenOptions<FilesConnectionStringOptions> betweenOptions) { if (betweenOptions.From == null) throw new ArgumentNullException("betweenOptions.From"); if (betweenOptions.To == null) throw new ArgumentNullException("betweenOptions.To"); using (primaryStore = await CreateStore(betweenOptions.From)) using (secondaryStore = await CreateStore(betweenOptions.To)) using (documentStore = CreateDocumentStore(betweenOptions.To)) { Operations = new SmugglerBetweenRemoteFilesOperations(() => primaryStore, () => secondaryStore, () => documentStore); await base.Between(betweenOptions); } }
public async Task BetweenOperation_CanDumpEmptyFileSystem() { string dataDirectory = null; try { using (var store = NewStore()) { var server = GetServer(); dataDirectory = server.Configuration.DataDirectory; var smugglerApi = new SmugglerFilesApi(); var options = new SmugglerBetweenOptions<FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = SourceFilesystem }, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = DestinationFilesystem } }; await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(SourceFilesystem); await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(DestinationFilesystem); await smugglerApi.Between(options); using (var session = store.OpenAsyncSession(DestinationFilesystem)) { var files = await session.Commands.BrowseAsync(); Assert.Equal(0, files.Count()); } server.Dispose(); } } finally { if (!string.IsNullOrWhiteSpace(dataDirectory)) IOExtensions.DeleteDirectory(dataDirectory); } }
public override Task Between(SmugglerBetweenOptions<RavenConnectionStringOptions> betweenOptions) { return SmugglerDatabaseBetweenOperation.Between(betweenOptions, Options); }
public abstract Task Between(SmugglerBetweenOptions betweenOptions);
public async Task BetweenOperation_OnlyActiveContentIsPreserved_MultipleDirectories() { using (var store = NewStore()) { var server = GetServer(); var smugglerApi = new SmugglerFilesApi(); var options = new SmugglerBetweenOptions<FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = SourceFilesystem }, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = DestinationFilesystem } }; await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(SourceFilesystem); await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(DestinationFilesystem); int total = 10; var files = new string[total]; using (var session = store.OpenAsyncSession(SourceFilesystem)) { for (int i = 0; i < total; i++) { files[i] = i + "/test.file"; session.RegisterUpload(files[i], CreateRandomFileStream(100 * i + 12)); } await session.SaveChangesAsync(); } int deletedFiles = 0; var rnd = new Random(); using (var session = store.OpenAsyncSession(SourceFilesystem)) { for (int i = 0; i < total; i++) { if (rnd.Next(2) == 0) { session.RegisterFileDeletion(files[i]); deletedFiles++; } } await session.SaveChangesAsync(); } await smugglerApi.Between(options); using (var session = store.OpenAsyncSession(DestinationFilesystem)) { int activeFiles = 0; for (int i = 0; i < total; i++) { var file = await session.LoadFileAsync(files[i]); if (file != null) activeFiles++; } Assert.Equal(total - deletedFiles, activeFiles); } } }
public override Task Between(SmugglerBetweenOptions betweenOptions) { return SmugglerBetweenOperation.Between(betweenOptions, SmugglerOptions); }
public async Task CanDisableVersioningDuringImport_Between() { using (var storeExport = NewStore()) using (var storeImport = NewStore(activeBundles: "Versioning", fileSystemName: "Import", index: 1)) { for (int i = 0; i < 10; i++) { await storeExport.AsyncFilesCommands.UploadAsync("test-" + i, StringToStream("hello")); } await storeImport.AsyncFilesCommands.Configuration.SetKeyAsync(VersioningUtil.DefaultConfigurationName, new VersioningConfiguration { Id = VersioningUtil.DefaultConfigurationName }); var fileCount = (await storeExport.AsyncFilesCommands.GetStatisticsAsync()).FileCount; var smuggler = new SmugglerFilesApi(new SmugglerFilesOptions() { ShouldDisableVersioningBundle = true }); var options = new SmugglerBetweenOptions<FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = storeExport.Url, DefaultFileSystem = storeExport.DefaultFileSystem }, To = new FilesConnectionStringOptions { Url = storeImport.Url, DefaultFileSystem = storeImport.DefaultFileSystem } }; await smuggler.Between(options); var fileCountAfterImport = (await storeImport.AsyncFilesCommands.GetStatisticsAsync()).FileCount; Assert.Equal(fileCount, fileCountAfterImport); // after import versioning should be active await storeImport.AsyncFilesCommands.UploadAsync("with-rev", StringToStream("rev")); using (var session = storeImport.OpenAsyncSession()) { var revisions = await session.GetRevisionsForAsync("with-rev", 0, 10); Assert.Equal(1, revisions.Length); } } }
public async Task ShouldSmuggleConfigurationsInBetweenOperation() { using (var exportStore = NewStore()) using (var importStore = NewStore(1)) { for (int i = 0; i < 100; i++) { await exportStore.AsyncFilesCommands.Configuration.SetKeyAsync("items/" + i, new RavenJObject { { "test", "value" }, { "test-array", new RavenJArray { "item-1", "item-2", "item-3" } } }); } var countOfConfigurations = (await exportStore.AsyncFilesCommands.Configuration.GetKeyNamesAsync(0, 200)).Length; var options = new SmugglerBetweenOptions<FilesConnectionStringOptions>() { From = new FilesConnectionStringOptions() { Url = exportStore.Url, DefaultFileSystem = exportStore.DefaultFileSystem }, To = new FilesConnectionStringOptions() { Url = importStore.Url, DefaultFileSystem = importStore.DefaultFileSystem } }; var smugglerFilesApi = new SmugglerFilesApi(); smugglerFilesApi.Options.BatchSize = 5; await smugglerFilesApi.Between(options); Assert.Equal(countOfConfigurations, (await importStore.AsyncFilesCommands.Configuration.GetKeyNamesAsync(0, 200)).Length); for (int i = 0; i < 100; i++) { Assert.NotNull(await importStore.AsyncFilesCommands.Configuration.GetKeyAsync<RavenJObject>("items/" + i)); } } }
public async Task BetweenExportShouldDisableSynchronizationDestinations() { using (var exportStore = NewStore()) using (var importStore = NewStore(1)) { await exportStore.AsyncFilesCommands.Synchronization.SetDestinationsAsync(new SynchronizationDestination() { ServerUrl = "http://sample.com", FileSystem = "Sample", Enabled = true }); var options = new SmugglerBetweenOptions<FilesConnectionStringOptions>() { From = new FilesConnectionStringOptions() { Url = exportStore.Url, DefaultFileSystem = exportStore.DefaultFileSystem }, To = new FilesConnectionStringOptions() { Url = importStore.Url, DefaultFileSystem = importStore.DefaultFileSystem } }; await new SmugglerFilesApi().Between(options); var destinations = await importStore.AsyncFilesCommands.Synchronization.GetDestinationsAsync(); Assert.Equal(1, destinations.Length); Assert.Equal("http://sample.com/fs/Sample", destinations[0].Url); Assert.Equal("Sample", destinations[0].FileSystem); Assert.False(destinations[0].Enabled); } }
public async Task BetweenOperation_CanHandleFilesExceptionsGracefully() { using (var store = NewStore()) { store.DefaultFileSystem = SourceFilesystem; var server = GetServer(); var alreadyReset = false; var port = 8070; var forwarder = new ProxyServer(ref port, server.Configuration.Port) { VetoTransfer = (totalRead, buffer) => { var s = Encoding.UTF8.GetString(buffer.Array, buffer.Offset, buffer.Count); if (alreadyReset == false && totalRead > 28000 && !s.Contains("200 OK")) { alreadyReset = true; return true; } return false; } }; try { var smugglerApi = new SmugglerFilesApi(); var options = new SmugglerBetweenOptions<FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = "http://localhost:" + port, DefaultFileSystem = SourceFilesystem }, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = DestinationFilesystem } }; await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(SourceFilesystem); await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(DestinationFilesystem); ReseedRandom(100); // Force a random distribution. await InitializeWithRandomFiles(store, 20, 30); Etag lastEtag = Etag.InvalidEtag; try { await smugglerApi.Between(options); Assert.False(true, "Expected error to happen during this Between operation, but it didn't happen :-("); } catch (SmugglerExportException inner) { lastEtag = inner.LastEtag; } Assert.NotEqual(Etag.InvalidEtag, lastEtag); await smugglerApi.Between(options); using (var session = store.OpenAsyncSession(DestinationFilesystem)) { var files = await session.Commands.BrowseAsync(); Assert.Equal(20, files.Count()); } } finally { forwarder.Dispose(); server.Dispose(); } } }
public async Task BetweenOperation_ContentIsPreserved_SingleFile() { using (var store = NewStore()) { var server = GetServer(); ReseedRandom(100); // Force a random distribution. int fileSize = 10000; var smugglerApi = new SmugglerFilesApi(); var options = new SmugglerBetweenOptions<FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = SourceFilesystem }, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = DestinationFilesystem } }; await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(SourceFilesystem); await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(DestinationFilesystem); var fileContent = CreateRandomFileStream(fileSize); using (var session = store.OpenAsyncSession(SourceFilesystem)) { session.RegisterUpload("test1.file", fileContent); await session.SaveChangesAsync(); } await smugglerApi.Between(options); fileContent.Position = 0; using (var session = store.OpenAsyncSession(DestinationFilesystem)) { var file = session.LoadFileAsync("test1.file").Result; Assert.Equal(fileSize, file.TotalSize); var stream = session.DownloadAsync(file).Result; Assert.Equal(fileContent.GetMD5Hash(), stream.GetMD5Hash()); } } }
public abstract Task Between(SmugglerBetweenOptions <RavenConnectionStringOptions> betweenOptions);
public async Task BetweenOperation_ContentIsPreserved_MultipleDirectories() { using (var store = NewStore()) { var server = GetServer(); var smugglerApi = new SmugglerFilesApi(); var options = new SmugglerBetweenOptions<FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = SourceFilesystem }, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = DestinationFilesystem } }; await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(SourceFilesystem); await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(DestinationFilesystem); var files = new Stream[10]; using (var session = store.OpenAsyncSession(SourceFilesystem)) { for (int i = 0; i < files.Length; i++) { files[i] = CreateRandomFileStream(100 * i + 12); session.RegisterUpload(i + "/test.file", files[i]); } await session.SaveChangesAsync(); } await smugglerApi.Between(options); for (int i = 0; i < files.Length; i++) { using (var session = store.OpenAsyncSession(DestinationFilesystem)) { var file = await session.LoadFileAsync(i + "/test.file"); var stream = await session.DownloadAsync(file); files[i].Position = 0; Assert.Equal(files[i].GetMD5Hash(), stream.GetMD5Hash()); } } } }
public async Task BetweenOperation_CanHandleFilesExceptionsGracefully() { using (var store = NewStore()) { store.DefaultFileSystem = SourceFilesystem; var server = GetServer(); var alreadyReset = false; var forwarder = new ProxyServer(8070, server.Configuration.Port) { VetoTransfer = (totalRead, buffer) => { if (alreadyReset == false && totalRead > 28000) { alreadyReset = true; return true; } return false; } }; var smugglerApi = new SmugglerFilesApi(); var options = new SmugglerBetweenOptions<FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = "http://localhost:8070", DefaultFileSystem = SourceFilesystem }, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = DestinationFilesystem } }; await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(SourceFilesystem); await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(DestinationFilesystem); ReseedRandom(100); // Force a random distribution. await InitializeWithRandomFiles(store, 20, 30); Etag lastEtag = Etag.InvalidEtag; try { await smugglerApi.Between(options); } catch (SmugglerExportException inner) { lastEtag = inner.LastEtag; } Assert.NotEqual(Etag.InvalidEtag, lastEtag); await smugglerApi.Between(options); using (var session = store.OpenAsyncSession(DestinationFilesystem)) { var files = await session.Commands.BrowseAsync(); Assert.Equal(20, files.Count()); } } }
public async Task BetweenOperation_MetadataIsPreserved() { using (var store = NewStore()) { var server = GetServer(); var smugglerApi = new SmugglerFilesApi(); var options = new SmugglerBetweenOptions<FilesConnectionStringOptions> { From = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = SourceFilesystem }, To = new FilesConnectionStringOptions { Url = store.Url, DefaultFileSystem = DestinationFilesystem } }; await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(SourceFilesystem); await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(DestinationFilesystem); FileHeader originalFile; using (var session = store.OpenAsyncSession(SourceFilesystem)) { session.RegisterUpload("test1.file", CreateRandomFileStream(12800)); await session.SaveChangesAsync(); // content update after a metadata change originalFile = await session.LoadFileAsync("test1.file"); originalFile.Metadata["Test"] = new RavenJValue("Value"); await session.SaveChangesAsync(); } await smugglerApi.Between(options); using (var session = store.OpenAsyncSession(DestinationFilesystem)) { var file = await session.LoadFileAsync("test1.file"); Assert.Equal(originalFile.CreationDate, file.CreationDate); Assert.Equal(originalFile.Directory, file.Directory); Assert.Equal(originalFile.Extension, file.Extension); Assert.Equal(originalFile.FullPath, file.FullPath); Assert.Equal(originalFile.Name, file.Name); Assert.Equal(originalFile.TotalSize, file.TotalSize); Assert.Equal(originalFile.UploadedSize, file.UploadedSize); Assert.Equal(originalFile.LastModified, file.LastModified); Assert.True(file.Metadata.ContainsKey("Test")); } } }
public override Task Between(SmugglerBetweenOptions<RavenConnectionStringOptions> betweenOptions) { throw new NotSupportedException(); }
public static async Task Between(SmugglerBetweenOptions<RavenConnectionStringOptions> betweenOptions, SmugglerDatabaseOptions databaseOptions) { SetDatabaseNameIfEmpty(betweenOptions.From); SetDatabaseNameIfEmpty(betweenOptions.To); using (var exportStore = CreateStore(betweenOptions.From)) using (var importStore = CreateStore(betweenOptions.To)) { SmugglerDatabaseApi.ValidateThatServerIsUpAndDatabaseExists(betweenOptions.From, exportStore); SmugglerDatabaseApi.ValidateThatServerIsUpAndDatabaseExists(betweenOptions.To, importStore); var exportBatchSize = GetBatchSize(exportStore, databaseOptions); var importBatchSize = GetBatchSize(importStore, databaseOptions); var exportStoreSupportedFeatures = await DetectServerSupportedFeatures(exportStore); var importStoreSupportedFeatures = await DetectServerSupportedFeatures(importStore); if (string.IsNullOrEmpty(betweenOptions.IncrementalKey)) { betweenOptions.IncrementalKey = ((AsyncServerClient)exportStore.AsyncDatabaseCommands).Url; } var incremental = new ExportIncremental(); if (databaseOptions.Incremental) { var jsonDocument = await importStore.AsyncDatabaseCommands.GetAsync(SmugglerExportIncremental.RavenDocumentKey); if (jsonDocument != null) { var smugglerExportIncremental = jsonDocument.DataAsJson.JsonDeserialization<SmugglerExportIncremental>(); ExportIncremental value; if (smugglerExportIncremental.ExportIncremental.TryGetValue(betweenOptions.IncrementalKey, out value)) { incremental = value; } databaseOptions.StartDocsEtag = incremental.LastDocsEtag ?? Etag.Empty; databaseOptions.StartAttachmentsEtag = incremental.LastAttachmentsEtag ?? Etag.Empty; } } if (databaseOptions.OperateOnTypes.HasFlag(ItemType.Indexes)) { await ExportIndexes(exportStore, importStore, exportBatchSize); } if (databaseOptions.OperateOnTypes.HasFlag(ItemType.Transformers) && exportStoreSupportedFeatures.IsTransformersSupported && importStoreSupportedFeatures.IsTransformersSupported) { await ExportTransformers(exportStore, importStore, exportBatchSize); } if (databaseOptions.OperateOnTypes.HasFlag(ItemType.Documents)) { incremental.LastDocsEtag = await ExportDocuments(exportStore, importStore, databaseOptions, exportStoreSupportedFeatures, exportBatchSize, importBatchSize); } if (databaseOptions.OperateOnTypes.HasFlag(ItemType.Attachments)) { incremental.LastAttachmentsEtag = await ExportAttachments(exportStore, importStore, databaseOptions, exportBatchSize); } if (exportStoreSupportedFeatures.IsIdentitiesSmugglingSupported && importStoreSupportedFeatures.IsIdentitiesSmugglingSupported) { await ExportIdentities(exportStore, importStore, databaseOptions.OperateOnTypes); } if (databaseOptions.Incremental) { var smugglerExportIncremental = new SmugglerExportIncremental(); var jsonDocument = await importStore.AsyncDatabaseCommands.GetAsync(SmugglerExportIncremental.RavenDocumentKey); if (jsonDocument != null) { smugglerExportIncremental = jsonDocument.DataAsJson.JsonDeserialization<SmugglerExportIncremental>(); } smugglerExportIncremental.ExportIncremental[betweenOptions.IncrementalKey] = incremental; await importStore.AsyncDatabaseCommands.PutAsync(SmugglerExportIncremental.RavenDocumentKey, null, RavenJObject.FromObject(smugglerExportIncremental), new RavenJObject()); } } }
public override Task Between(SmugglerBetweenOptions betweenOptions) { throw new NotSupportedException(); }