public async void Sample1() { #region smuggler_api_2 // import only Documents // from dump.raven file // to NewNorthwind database (must exist) // found on http://localhost:8080 server SmugglerDatabaseApi smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions { OperateOnTypes = ItemType.Documents, Incremental = false }); SmugglerImportOptions <RavenConnectionStringOptions> importOptions = new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = "dump.raven", To = new RavenConnectionStringOptions { DefaultDatabase = "NewNorthwind", Url = "http://localhost:8080" } }; await smugglerApi.ImportData(importOptions, null); #endregion }
public async Task SmugglerShouldNotThrowIfDatabaseExist2() { var path = Path.GetTempFileName(); try { using (var store = NewRemoteDocumentStore()) { var connectionStringOptions = new RavenConnectionStringOptions { Url = store.Url, DefaultDatabase = store.DefaultDatabase }; var smuggler = new SmugglerDatabaseApi(); await smuggler.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = path, To = connectionStringOptions }); await smuggler.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = path, From = connectionStringOptions }); } } finally { IOExtensions.DeleteFile(path); } }
public async void Sample2() { #region smuggler_api_3 // export Documents and Indexes // from Northwind database // found on http://localhost:8080 // and import them to NewNorthwind // found on the same server SmugglerDatabaseApi smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions { OperateOnTypes = ItemType.Documents | ItemType.Indexes, Incremental = false }); await smugglerApi.Between( new SmugglerBetweenOptions <RavenConnectionStringOptions> { From = new RavenConnectionStringOptions { Url = "http://localhost:8080", DefaultDatabase = "Northwind" }, To = new RavenConnectionStringOptions { Url = "http://localhost:8080", DefaultDatabase = "NewNorthwind" } }); #endregion }
public void Export_Incremental_not_overwrites_Files() { var file = Path.Combine(NewDataPath(), "Incremental"); IOExtensions.DeleteDirectory(file); var connection = new RavenConnectionStringOptions { Url = "http://localhost:8079/" }; var smugglerApi = new SmugglerDatabaseApi(); smugglerApi.Options.OperateOnTypes = ItemType.Documents | ItemType.Indexes | ItemType.Attachments; smugglerApi.Options.Incremental = true; for (int i = 0; i < 50; i++) { smugglerApi.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = file, From = connection, }).Wait(TimeSpan.FromSeconds(15)); } Assert.Equal(Directory.GetFiles(file).Length, 51); //50 .dump.inc files and 1 LastEtags.txt }
public async Task CanDumpEmptyDatabase_Smuggler() { var backupPath = NewDataPath("BackupFolder"); try { using (var store = NewRemoteDocumentStore()) { // now perform full backup var dumper = new SmugglerDatabaseApi { Options = { Incremental = true } }; await dumper.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = backupPath, From = new RavenConnectionStringOptions { Url = "http://localhost:8079", DefaultDatabase = store.DefaultDatabase, } }); } VerifyDump(backupPath, store => Assert.Equal(0, store.SystemDatabase.Documents.GetDocumentsAsJson(0, int.MaxValue, null, CancellationToken.None).Count())); } finally { IOExtensions.DeleteDirectory(backupPath); } }
public async Task CanDumpAttachmentsEmpty_Smuggler() { var backupPath = NewDataPath("BackupFolder"); try { using (var store = NewRemoteDocumentStore()) { var dumper = new SmugglerDatabaseApi { Options = { Incremental = true, BatchSize = 100, Limit = 206 } }; await dumper.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = backupPath, From = new RavenConnectionStringOptions { Url = "http://localhost:8079", DefaultDatabase = store.DefaultDatabase, } }); } VerifyDump(backupPath, store => Assert.Equal(0, store.DatabaseCommands.GetAttachmentHeadersStartingWith("user", 0, 500).Count())); } finally { IOExtensions.DeleteDirectory(backupPath); } }
public static async Task ExportDatabase(string database, string url, string path) { Log.Information($"[smuggler/routine/exportdatabase] Creating backup task for database '{database}'"); // Create database back up folder if it does not exists if (!Directory.Exists(Path.Combine(path, database))) { Directory.CreateDirectory(Path.Combine(path, database)); } var smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions { OperateOnTypes = ItemType.Documents | ItemType.Indexes | ItemType.Attachments | ItemType.Transformers, Incremental = false }); var options = new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = Path.Combine($"{path}/{database}", $"{database}_{DateTime.Now.ToString("dd_MM_yyyy_HH_mm")}.ravendump"), From = new RavenConnectionStringOptions { DefaultDatabase = database, Url = url } }; await smugglerApi.ExportData(options); }
public void Export_And_Import_Retains_Attachment_Metadata() { documentStore.DatabaseCommands.PutAttachment("test", null, new MemoryStream(new byte[] { 1, 2, 3 }), new RavenJObject { { "Test", true } }); var connection = new RavenConnectionStringOptions { Url = "http://localhost:8079/" }; var smugglerApi = new SmugglerDatabaseApi { Options = { OperateOnTypes = ItemType.Documents | ItemType.Indexes | ItemType.Attachments } }; smugglerApi.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = DumpFile, From = connection }).Wait(TimeSpan.FromSeconds(15)); Assert.True(File.Exists(DumpFile)); server.Dispose(); CreateServer(); smugglerApi.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = DumpFile, To = connection }).Wait(TimeSpan.FromSeconds(15)); var attachment = documentStore.DatabaseCommands.GetAttachment("test"); Assert.Equal(new byte[] { 1, 2, 3 }, attachment.Data().ReadData()); Assert.True(attachment.Metadata.Value <bool>("Test")); }
public async Task SmugglerBehaviorWhenServerIsDown() { var path = Path.GetTempFileName(); try { var connectionStringOptions = new RavenConnectionStringOptions { Url = "http://localhost:8078/", DefaultDatabase = "DoesNotExist" }; var smuggler = new SmugglerDatabaseApi(); var e = await AssertAsync.Throws <SmugglerException>(() => smuggler.ImportData( new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = path, To = connectionStringOptions })); Assert.Contains("Smuggler encountered a connection problem:", e.Message); e = await AssertAsync.Throws <SmugglerException>(() => smuggler.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = path, From = connectionStringOptions })); Assert.Contains("Smuggler encountered a connection problem:", e.Message); } finally { IOExtensions.DeleteFile(path); } }
public void ExportDatabaseSmugglerApi(string databaseName, ItemType itemTypeToExport = ItemType.Documents) { if (string.IsNullOrWhiteSpace(databaseName)) { _logger.Warning("Database name incorrectly"); return; } _logger.Information("Export database {0} with Smuggler Api", databaseName); BackupDir.EnsureFileDestination(); var filePath = GetFilePathFromDatabaseName(databaseName); var smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions { OperateOnTypes = itemTypeToExport, Incremental = false }); var exportOptions = new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = filePath, From = new RavenConnectionStringOptions { DefaultDatabase = databaseName, Url = _store.Url } }; //TODO: consider this var operationState = smugglerApi.ExportData(exportOptions).Result; }
public async void Sample() { #region smuggler_api_1 // export Documents, Indexes, Attachments and Transformers // to dump.raven file // from Northwind database // found on http://localhost:8080 server SmugglerDatabaseApi smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions { OperateOnTypes = ItemType.Documents | ItemType.Indexes | ItemType.Attachments | ItemType.Transformers, Incremental = false }); SmugglerExportOptions <RavenConnectionStringOptions> exportOptions = new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = "dump.raven", From = new RavenConnectionStringOptions { DefaultDatabase = "Northwind", Url = "http://localhost:8080" } }; await smugglerApi.ExportData(exportOptions); #endregion }
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")); } }
public async Task Filtering_with_export_and_import_subscriptions_should_work() { using (var store = NewRemoteDocumentStore()) { using (var session = store.OpenSession()) { session.Store(new { Foo = "Bar" }); session.SaveChanges(); } store.Subscriptions.Create(new SubscriptionCriteria { KeyStartsWith = "foo/b" }); var filters = new FilterSetting { Values = new[] { "Raven/Subscriptions" }.ToList(), ShouldMatch = false, Path = "@name" }; var smuggler = new SmugglerDatabaseApi( new SmugglerDatabaseOptions { Incremental = false, Filters = new[] { filters }.ToList(), TransformScript = null, }); using (var dummyStream = new MemoryStream()) { //this shouldn't throw exception... await smuggler.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions> { From = new RavenConnectionStringOptions { Url = store.Url, DefaultDatabase = store.DefaultDatabase }, ToStream = dummyStream }); dummyStream.Position = 0; await smuggler.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromStream = dummyStream, To = new RavenConnectionStringOptions { Url = store.Url, DefaultDatabase = store.DefaultDatabase } }); } } }
public bool ImportDatabaseSmugglerApi(string databaseName, ItemType itemTypeToImport = ItemType.Documents) { var success = true; try { if (string.IsNullOrWhiteSpace(databaseName)) { _logger.Warning("Database name incorrectly"); success = false; } _logger.Information("Import database {0} with Smuggler Api", databaseName); var filePath = GetFilePathFromDatabaseName(databaseName); var filters = new List <FilterSetting> { new FilterSetting { Path = "@metadata.@id", ShouldMatch = false, Values = new List <string> { "Raven/Encryption/Verification" } } }; var smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions { OperateOnTypes = itemTypeToImport, Incremental = false, ShouldDisableVersioningBundle = true, Filters = filters }); var importOptions = new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = filePath, To = new RavenConnectionStringOptions { DefaultDatabase = databaseName, Url = _store.Url }, }; smugglerApi.ImportData(importOptions).Wait(); } catch (Exception ex) { _logger.Information("Import database failed: {0}", ex); success = false; } return(success); }
public void Export_And_Import_Incremental_Changed_Document() { var file = Path.Combine(NewDataPath(), "Incremental"); IOExtensions.DeleteDirectory(file); using (var session = documentStore.OpenSession()) { var foo = new Foo { Something = "Before Change", Id = "Test/1" }; session.Store(foo); session.SaveChanges(); } var connection = new RavenConnectionStringOptions { Url = "http://localhost:8079/" }; var smugglerApi = new SmugglerDatabaseApi { Options = { OperateOnTypes = ItemType.Documents | ItemType.Indexes | ItemType.Attachments, Incremental = true } }; smugglerApi.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = file, From = connection, }).Wait(TimeSpan.FromSeconds(15)); using (var session = documentStore.OpenSession()) { var doc = session.Load <Foo>("Test/1"); doc.Something = "After Change"; session.SaveChanges(); } smugglerApi.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = file, From = connection, }).Wait(TimeSpan.FromSeconds(15)); server.Dispose(); CreateServer(); smugglerApi.Options.Incremental = true; smugglerApi.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = file, To = connection }).Wait(TimeSpan.FromSeconds(15)); using (var session = documentStore.OpenSession()) { var doc = session.Load <Foo>("Test/1"); Assert.Equal(doc.Something, "After Change"); } }
public void SingleAttachmentsImportShouldWork(int size) { var data = new byte[size]; new Random().NextBytes(data); using (var source = NewRemoteDocumentStore(databaseName: "fooDB")) { source.DatabaseCommands.ForSystemDatabase().CreateDatabase(new DatabaseDocument { Id = "fooDB2", Settings = new Dictionary <string, string> { { "Raven/DataDir", "FooData" } } }); using (var stream = new MemoryStream(data)) { stream.Position = 0; source.DatabaseCommands.PutAttachment("foo", null, stream, new RavenJObject()); } var smugglerApi = new SmugglerDatabaseApi(); var filename = "large-attachment-test.ravendbdump"; using (var fs = new FileStream(filename, FileMode.Create)) { smugglerApi.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions> { ToStream = fs, From = new RavenConnectionStringOptions { Url = source.Url, DefaultDatabase = "fooDB" } }).Wait(); fs.Flush(); } using (var fs = new FileStream(filename, FileMode.Open)) { smugglerApi.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromStream = fs, To = new RavenConnectionStringOptions { Url = source.Url, DefaultDatabase = "fooDB2" } }).Wait(); } var attachment = source.DatabaseCommands.ForDatabase("fooDB2").GetAttachment("foo"); Assert.Equal(attachment.Data().ReadData(), data); } }
public void CanExportImportTransformers() { var file = Path.GetTempFileName(); try { using (var documentStore = NewRemoteDocumentStore()) { new ProductWithTransformerParameters().Execute(documentStore); var smugglerApi = new SmugglerDatabaseApi(); smugglerApi.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = file, From = new RavenConnectionStringOptions { Url = documentStore.Url, DefaultDatabase = documentStore.DefaultDatabase } }).Wait(TimeSpan.FromSeconds(15)); } using (var documentStore = NewRemoteDocumentStore()) { var smugglerApi = new SmugglerDatabaseApi(); smugglerApi.ImportData( new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = file, To = new RavenConnectionStringOptions { Url = documentStore.Url, DefaultDatabase = documentStore.DefaultDatabase } }).Wait(TimeSpan.FromSeconds(15)); var transformers = documentStore.DatabaseCommands.GetTransformers(0, 128); Assert.NotNull(transformers); Assert.Equal(1, transformers.Length); Assert.Equal("ProductWithTransformerParameters", transformers[0].Name); } } finally { if (File.Exists(file)) { File.Delete(file); } } }
public void Export_And_Import_Incremental_Attachments() { var file = Path.Combine(NewDataPath(), "Incremental"); IOExtensions.DeleteDirectory(file); documentStore.DatabaseCommands.PutAttachment("test", null, new MemoryStream(new byte[] { 1, 2, 3 }), new RavenJObject { { "Test", true } }); var connection = new RavenConnectionStringOptions { Url = "http://localhost:8079/" }; var smugglerApi = new SmugglerDatabaseApi { Options = { OperateOnTypes = ItemType.Documents | ItemType.Indexes | ItemType.Attachments, Incremental = true } }; smugglerApi.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = file, From = connection, }).Wait(TimeSpan.FromSeconds(15)); documentStore.DatabaseCommands.PutAttachment("test2", null, new MemoryStream(new byte[] { 1, 2, 3 }), new RavenJObject { { "Test2", true } }); smugglerApi.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = file, From = connection, }).Wait(TimeSpan.FromSeconds(15)); server.Dispose(); CreateServer(); smugglerApi.Options.Incremental = true; smugglerApi.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = file, To = connection }).Wait(TimeSpan.FromSeconds(15)); var attachment = documentStore.DatabaseCommands.GetAttachment("test"); Assert.Equal(new byte[] { 1, 2, 3 }, attachment.Data().ReadData()); Assert.True(attachment.Metadata.Value <bool>("Test")); attachment = documentStore.DatabaseCommands.GetAttachment("test2"); Assert.Equal(new byte[] { 1, 2, 3 }, attachment.Data().ReadData()); Assert.True(attachment.Metadata.Value <bool>("Test2")); }
public void Export_And_Import_Incremental_Indexes() { var file = Path.Combine(NewDataPath(), "Incremental"); IOExtensions.DeleteDirectory(file); documentStore.DatabaseCommands.PutIndex("Index1", new IndexDefinition { Map = "from x in docs select new { x.Name, Count = 1}", }); var connection = new RavenConnectionStringOptions { Url = "http://localhost:8079/" }; var smugglerApi = new SmugglerDatabaseApi { Options = { OperateOnTypes = ItemType.Documents | ItemType.Indexes | ItemType.Attachments, Incremental = true } }; smugglerApi.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = file, From = connection, }).Wait(TimeSpan.FromSeconds(15)); documentStore.DatabaseCommands.PutIndex("Index2", new IndexDefinition { Map = "from x in docs select new { x.Title, Count = 1}", }); smugglerApi.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = file, From = connection, }).Wait(TimeSpan.FromSeconds(15)); server.Dispose(); CreateServer(); smugglerApi.Options.Incremental = true; smugglerApi.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = file, To = connection }).Wait(TimeSpan.FromSeconds(15)); var index = documentStore.DatabaseCommands.GetIndex("Index1"); Assert.NotNull(index); index = documentStore.DatabaseCommands.GetIndex("Index2"); Assert.NotNull(index); }
public void DateTimePreserved() { var file = Path.GetTempFileName(); try { var docId = string.Empty; using (var documentStore = NewRemoteDocumentStore()) { using (var session = documentStore.OpenSession()) { var foo = new Foo { Created = DateTime.Today }; session.Store(foo); docId = foo.Id; session.SaveChanges(); } var smugglerApi = new SmugglerDatabaseApi(); smugglerApi.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = file, From = new RavenConnectionStringOptions { Url = documentStore.Url, DefaultDatabase = documentStore.DefaultDatabase } }).Wait(TimeSpan.FromSeconds(15)); } using (var documentStore = NewRemoteDocumentStore()) { var smugglerApi = new SmugglerDatabaseApi(); smugglerApi.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = file, To = new RavenConnectionStringOptions { Url = documentStore.Url, DefaultDatabase = documentStore.DefaultDatabase } }).Wait(TimeSpan.FromSeconds(15)); using (var session = documentStore.OpenSession()) { var created = session.Load <Foo>(docId).Created; Assert.False(session.Advanced.HasChanges); } } } finally { if (File.Exists(file)) { File.Delete(file); } } }
public async Task ShouldSmuggleIdentitiesInExportImport() { using (var server1 = GetNewServer(port: 8079)) using (var store1 = NewRemoteDocumentStore(ravenDbServer: server1, databaseName: "Database1")) { using (var session = store1.OpenAsyncSession("Database1")) { await session.StoreAsync(new User { Id = "users/", Name = "Arek" }); await session.SaveChangesAsync(); } store1.DatabaseCommands.SeedIdentityFor("users/", 10); var smugglerApi = new SmugglerDatabaseApi(); await smugglerApi.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions> { From = new RavenConnectionStringOptions { Url = "http://localhost:8079", DefaultDatabase = "Database1" }, ToFile = ExportDir }); using (var server2 = GetNewServer(port: 8078)) { using (var store2 = NewRemoteDocumentStore(ravenDbServer: server2, databaseName: "Database2")) { await smugglerApi.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = ExportDir, To = new RavenConnectionStringOptions { Url = "http://localhost:8078", DefaultDatabase = "Database2" } }); using (var session = store2.OpenAsyncSession("Database2")) { await session.StoreAsync(new User { Id = "users/", Name = "Oren" }); await session.SaveChangesAsync(); } var documents = (await store2.AsyncDatabaseCommands.GetDocumentsAsync(0, 10)).OrderBy(x => x.Key).ToArray(); Assert.Equal(2, documents.Length); Assert.Equal("users/1", documents[0].Key); Assert.Equal("users/11", documents[1].Key); } } } }
public async Task ShouldWork() { using (var server1 = GetNewServer(port: 8079)) using (var store1 = NewRemoteDocumentStore(ravenDbServer: server1, databaseName: "Database1")) { await new UsersIndex().ExecuteAsync(store1.AsyncDatabaseCommands, new DocumentConvention()); await new UsersTransformer().ExecuteAsync(store1); using (var session = store1.OpenAsyncSession("Database1")) { await session.StoreAsync(new User { Name = "Oren Eini" }); await session.StoreAsync(new User { Name = "Fitzchak Yitzchaki" }); await session.SaveChangesAsync(); } await store1.AsyncDatabaseCommands.PutAttachmentAsync("ayende", null, new MemoryStream(new byte[] { 3 }), new RavenJObject()); await store1.AsyncDatabaseCommands.PutAttachmentAsync("fitzchak", null, new MemoryStream(new byte[] { 2 }), new RavenJObject()); using (var server2 = GetNewServer(port: 8078)) { using (var store2 = NewRemoteDocumentStore(ravenDbServer: server2, databaseName: "Database2")) { var smugglerApi = new SmugglerDatabaseApi(); await smugglerApi.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions> { From = new RavenConnectionStringOptions { Url = "http://localhost:8079", DefaultDatabase = "Database1" }, To = new RavenConnectionStringOptions { Url = "http://localhost:8078", DefaultDatabase = "Database2" } }); await AssertDatabaseHasIndex <UsersIndex>(store2); await AssertDatabaseHasTransformer <UsersTransformer>(store2); using (var session2 = store2.OpenAsyncSession("Database2")) { Assert.Equal(2, await session2.Query <User>().CountAsync()); } var attachments = await store2.AsyncDatabaseCommands.GetAttachmentsAsync(0, Etag.Empty, 25); Assert.Equal(2, attachments.Length); Assert.Equal("ayende", attachments[0].Key); Assert.Equal("fitzchak", attachments[1].Key); } } } }
public async Task CanDumpWhenHiddenDocsWithLimit_Smuggler() { var backupPath = NewDataPath("BackupFolder"); try { using (GetNewServer()) { using (var store = new DocumentStore { Url = "http://localhost:8079" }) { store.Initialize(); InsertHidenUsers(store, 2000); var user1 = store.DatabaseCommands.Get("users/1"); Assert.Null(user1); InsertUsers(store, 1, 25); // now perform full backup var dumper = new SmugglerDatabaseApi { Options = { Incremental = true } }; await dumper.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = backupPath, From = new RavenConnectionStringOptions { Url = "http://localhost:8079", DefaultDatabase = store.DefaultDatabase, } }); } } VerifyDump(backupPath, store => { using (var session = store.OpenSession()) { Assert.Equal(25, session.Query <User>().Customize(x => x.WaitForNonStaleResultsAsOfNow()).Count()); } }); } finally { IOExtensions.DeleteDirectory(backupPath); } }
public async Task CanPerformDumpWithLimitAndFilter_Smuggler() { var backupPath = NewDataPath("BackupFolder"); try { using (var store = NewRemoteDocumentStore()) { var counter = 0; counter = InsertUsers(store, counter, 1000); counter = InsertDevelopers(store, counter, 2); counter = InsertUsers(store, counter, 1000); InsertDevelopers(store, counter, 2); WaitForIndexing(store); var dumper = new SmugglerDatabaseApi { Options = { Limit = 5, Incremental = true } }; dumper.Options.Filters.Add( new FilterSetting { Path = "@metadata.Raven-Entity-Name", Values = { "Developers" }, ShouldMatch = true, }); await dumper.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = backupPath, From = new RavenConnectionStringOptions { Url = "http://localhost:8079", DefaultDatabase = store.DefaultDatabase, } }); } VerifyDump(backupPath, store => { using (var session = store.OpenSession()) { Assert.Equal(4, session.Query <Developer>().Customize(x => x.WaitForNonStaleResultsAsOfNow()).Count()); } }); } finally { IOExtensions.DeleteDirectory(backupPath); } }
public void SmugglerWithExcludeExpiredDocumentsShouldWork2() { var path = Path.GetTempFileName(); try { using (var store = NewRemoteDocumentStore()) { Initialize(store); var smuggler = new SmugglerDatabaseApi { Options = { ShouldExcludeExpired = true } }; smuggler.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = path, From = new RavenConnectionStringOptions { Url = store.Url, DefaultDatabase = store.DefaultDatabase } }).Wait(TimeSpan.FromSeconds(15)); } using (var store = NewRemoteDocumentStore()) { SystemTime.UtcDateTime = () => DateTime.UtcNow.AddMinutes(10); var smuggler = new SmugglerDatabaseApi { Options = { ShouldExcludeExpired = true } }; smuggler.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = path, To = new RavenConnectionStringOptions { Url = store.Url, DefaultDatabase = store.DefaultDatabase } }).Wait(TimeSpan.FromSeconds(15)); using (var session = store.OpenSession()) { var product1 = session.Load <Product>(1); var product2 = session.Load <Product>(2); var product3 = session.Load <Product>(3); Assert.NotNull(product1); Assert.Null(product2); Assert.Null(product3); } } } finally { IOExtensions.DeleteDirectory(path); } }
public async Task <HttpResponseMessage> Import() { // Make sure that we actually got the right data if (!Request.Content.IsMimeMultipartContent()) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } try { // Store the uploaded file into a temporary location var provider = new MultipartFormDataStreamProvider(Path.GetTempPath()); await Request.Content.ReadAsMultipartAsync(provider); string filename = provider.FormData.GetValues("filename").First(); var file = provider.FileData.First(); // Setup an import using RavenDb's Smuggler API or the DatabaseDumper API depending on whether the embedded database is being used SmugglerDatabaseApiBase importer; RavenConnectionStringOptions connectionStringOptions; if (Database.DocumentStore is EmbeddableDocumentStore embeddableDocumentStore) { importer = new DatabaseDataDumper(embeddableDocumentStore.DocumentDatabase); connectionStringOptions = new EmbeddedRavenConnectionStringOptions(); } else { importer = new SmugglerDatabaseApi(); connectionStringOptions = new RavenConnectionStringOptions() { Url = Database.DocumentStore.Url }; } var importOptions = new SmugglerImportOptions <RavenConnectionStringOptions>() { FromFile = file.LocalFileName, To = connectionStringOptions }; await importer.ImportData(importOptions); return(new HttpResponseMessage(HttpStatusCode.OK)); } catch (Exception exp) { return(this.Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exp)); } }
public void Export_And_Import_Retains_HiLoState() { using (var session = documentStore.OpenSession()) { var foo = new Foo { Something = "something2" }; Assert.Null(foo.Id); session.Store(foo); Assert.NotNull(foo.Id); session.SaveChanges(); } var smugglerApi = new SmugglerDatabaseApi { Options = { Incremental = false } }; var connection = new RavenConnectionStringOptions { Url = "http://localhost:8079/" }; smugglerApi.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { From = connection, ToFile = DumpFile }).Wait(TimeSpan.FromSeconds(15)); Assert.True(File.Exists(DumpFile)); using (var session = documentStore.OpenSession()) { var hilo = session.Load <HiLoKey>("Raven/Hilo/foos"); Assert.NotNull(hilo); Assert.Equal(32, hilo.Max); } server.Dispose(); CreateServer(); smugglerApi.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = DumpFile, To = connection }).Wait(TimeSpan.FromSeconds(15)); using (var session = documentStore.OpenSession()) { var hilo = session.Load <HiLoKey>("Raven/Hilo/foos"); Assert.NotNull(hilo); Assert.Equal(32, hilo.Max); } }
public async Task Filtering_between_with_subscriptions_should_work() { using (var serverFrom = GetNewServer(8090)) using (var serverTo = GetNewServer(8091)) using (var from = NewRemoteDocumentStore(ravenDbServer: serverFrom)) using (var to = NewRemoteDocumentStore(ravenDbServer: serverTo)) { using (var session = from.OpenSession()) { session.Store(new { Foo = "Bar" }, "foo/bar"); session.SaveChanges(); } from.Subscriptions.Create(new SubscriptionCriteria { KeyStartsWith = "foo/b" }); var filters = new FilterSetting { Values = new[] { "Raven/Subscriptions" }.ToList(), ShouldMatch = false, Path = "@name" }; var smuggler = new SmugglerDatabaseApi( new SmugglerDatabaseOptions { Incremental = false, Filters = new[] { filters }.ToList(), TransformScript = null, }); await smuggler.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions> { From = new RavenConnectionStringOptions { Url = from.Url, DefaultDatabase = from.DefaultDatabase }, To = new RavenConnectionStringOptions { Url = to.Url, DefaultDatabase = to.DefaultDatabase } }); } }
public void Can_filter_documents() { using (var session = documentStore.OpenSession()) { session.Store(new Foo { Something = "something1" }); session.Store(new Foo { Something = "something2" }); session.SaveChanges(); } var connection = new RavenConnectionStringOptions { Url = "http://localhost:8079/" }; var smugglerApi = new SmugglerDatabaseApi(); smugglerApi.Options.Filters.Add( new FilterSetting { Path = "Something", ShouldMatch = true, Values = new EquatableList <string> { "Something1" } }); smugglerApi.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToFile = DumpFile, From = connection, }).Wait(TimeSpan.FromSeconds(15)); Assert.True(File.Exists(DumpFile)); server.Dispose(); CreateServer(); smugglerApi.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = DumpFile, To = connection }).Wait(TimeSpan.FromSeconds(15)); using (var session = documentStore.OpenSession()) { Assert.NotNull(session.Load <Foo>("foos/1")); Assert.Null(session.Load <Foo>("foos/2")); } }
private async Task Import(DocumentStore documentStore, string transformScript) { var smugglerApi = new SmugglerDatabaseApi(); smugglerApi.Options.TransformScript = transformScript; ; await smugglerApi.ImportData( new SmugglerImportOptions <RavenConnectionStringOptions> { FromFile = file, To = new RavenConnectionStringOptions { Url = documentStore.Url, DefaultDatabase = documentStore.DefaultDatabase } }); }