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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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"));
}
}
public async Task Export(string dataFilePath)
{
//dirty hack, TODO : make PR to RavenDB to make IDocumentStore::Url work
var store = (EmbeddableDocumentStore)documentStore;
var dataDumper = new SmugglerDatabaseApi(new SmugglerDatabaseOptions());
OnImportExportStarted("Exporting configuration...");
await dataDumper.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions>
{
From = new RavenConnectionStringOptions
{
DefaultDatabase = Constants.DatabaseName,
Url = store.Configuration.ServerUrl
},
ToFile = dataFilePath
}).ContinueWith(t => OnImportExportEnded()).ConfigureAwait(false);
}
public void MaxNumberOfItemsToProcessInSingleBatchShouldBeRespectedBySmuggler()
{
var path = Path.Combine(NewDataPath(forceCreateDir: true), "raven.dump");
using (var server = GetNewServer(configureConfig: configuration => configuration.MaxNumberOfItemsToProcessInSingleBatch = 1234))
{
var smuggler = new SmugglerDatabaseApi(options: new SmugglerDatabaseOptions {
BatchSize = 4321
});
Assert.Equal(4321, smuggler.Options.BatchSize);
smuggler.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions> {
ToFile = path, From = new RavenConnectionStringOptions {
Url = server.Configuration.ServerUrl
}
}).ResultUnwrap();
Assert.Equal(1234, smuggler.Options.BatchSize);
smuggler = new SmugglerDatabaseApi(options: new SmugglerDatabaseOptions {
BatchSize = 4321
});
Assert.Equal(4321, smuggler.Options.BatchSize);
smuggler.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions> {
FromFile = path, To = new RavenConnectionStringOptions {
Url = server.Configuration.ServerUrl
}
}).Wait();
Assert.Equal(1234, smuggler.Options.BatchSize);
smuggler = new SmugglerDatabaseApi(options: new SmugglerDatabaseOptions {
BatchSize = 1000
});
Assert.Equal(1000, smuggler.Options.BatchSize);
smuggler.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions> {
ToFile = path, From = new RavenConnectionStringOptions {
Url = server.Configuration.ServerUrl
}
}).ResultUnwrap();
Assert.Equal(1000, smuggler.Options.BatchSize);
}
}
private async Task Export(DocumentStore store, string transformScript)
{
var smugglerApi = new SmugglerDatabaseApi();
smugglerApi.Options.TransformScript = transformScript;
await smugglerApi.ExportData(
new SmugglerExportOptions <RavenConnectionStringOptions>
{
ToFile = file,
From = new RavenConnectionStringOptions
{
Url = store.Url,
DefaultDatabase = store.DefaultDatabase
}
});
}
protected override void ExportDump()
{
// https://ravendb.net/docs/article-page/3.5/csharp/server/administration/exporting-and-importing-data#smugglerdatabaseapi
var smugglerApi = new SmugglerDatabaseApi(new SmugglerDatabaseOptions
{
OperateOnTypes = ItemType.Documents | ItemType.Indexes | ItemType.Transformers,
Incremental = false
});
var exportOptions = new SmugglerExportOptions <RavenConnectionStringOptions>
{
ToFile = o.Dump.Replace(".", "_export."),
From = new RavenConnectionStringOptions
{
DefaultDatabase = o.Db,
Url = o.Url
}
};
smugglerApi.ExportData(exportOptions).GetAwaiter().GetResult();
}
public async Task SmugglerShouldNotExportImportSubscribtionIdentities()
{
using (var store = NewRemoteDocumentStore())
{
store.Subscriptions.Create(new SubscriptionCriteria());
var smuggler = new SmugglerDatabaseApi(new SmugglerDatabaseOptions {
OperateOnTypes = ItemType.Documents
});
using (var stream = new MemoryStream())
{
await smuggler.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions>
{
From = new RavenConnectionStringOptions
{
DefaultDatabase = store.DefaultDatabase,
Url = store.Url
},
ToStream = stream
});
stream.Position = 0;
store.DatabaseCommands.GlobalAdmin.EnsureDatabaseExists("Northwind");
await smuggler.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions>
{
FromStream = stream,
To = new RavenConnectionStringOptions
{
DefaultDatabase = "Northwind",
Url = store.Url
}
});
}
}
}
public async Task CanPerformDump_Smuggler()
{
var backupPath = NewDataPath("BackupFolder");
try
{
using (var store = NewRemoteDocumentStore())
{
InsertUsers(store, 0, 2000);
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(2000, session.Query <User>().Customize(x => x.WaitForNonStaleResultsAsOfNow()).Count());
}
});
}
finally
{
IOExtensions.DeleteDirectory(backupPath);
}
}
public async Task SmugglerShouldThrowIfDatabaseDoesNotExist()
{
var path = Path.GetTempFileName();
try
{
using (var store = NewRemoteDocumentStore())
{
var connectionStringOptions =
new RavenConnectionStringOptions
{
Url = store.Url,
DefaultDatabase = "DoesNotExist"
};
var smuggler = new SmugglerDatabaseApi();
var e = await AssertAsync.Throws <SmugglerException>(() => smuggler.ImportData(
new SmugglerImportOptions <RavenConnectionStringOptions> {
FromFile = path, To = connectionStringOptions
}));
Assert.Equal(string.Format("Smuggler does not support database creation (database 'DoesNotExist' on server '{0}' must exist before running Smuggler).", store.Url), e.Message);
e = await AssertAsync.Throws <SmugglerException>(() => smuggler.ExportData(
new SmugglerExportOptions <RavenConnectionStringOptions> {
ToFile = path, From = connectionStringOptions
}));
Assert.Equal(string.Format("Smuggler does not support database creation (database 'DoesNotExist' on server '{0}' must exist before running Smuggler).", store.Url), e.Message);
}
}
finally
{
IOExtensions.DeleteFile(path);
}
}
public async Task SmugglerShouldImportConflictsProperly()
{
using (var store1 = CreateStore())
using (var store2 = CreateStore())
{
using (var session = store1.OpenSession())
{
session.Store(new Person());
session.SaveChanges();
}
using (var session = store2.OpenSession())
{
session.Store(new Person());
session.SaveChanges();
}
WaitForIndexing(store1);
WaitForIndexing(store2);
TellFirstInstanceToReplicateToSecondInstance();
WaitForReplication(store2, session =>
{
try
{
session.Load <Person>("people/1");
return(false);
}
catch (ConflictException)
{
return(true);
}
});
store2.DatabaseCommands.GlobalAdmin.EnsureDatabaseExists("Northwind");
using (var stream = new MemoryStream())
{
var smuggler = new SmugglerDatabaseApi();
await smuggler.ExportData(new SmugglerExportOptions <RavenConnectionStringOptions>
{
From = new RavenConnectionStringOptions
{
Url = store2.Url,
DefaultDatabase = store2.DefaultDatabase
},
ToStream = stream
});
await smuggler.ImportData(new SmugglerImportOptions <RavenConnectionStringOptions>
{
FromStream = stream,
To = new RavenConnectionStringOptions
{
DefaultDatabase = "Northwind",
Url = store2.Url
}
});
}
Assert.Throws <ConflictException>(() =>
{
using (var session = store2.OpenSession("Northwind"))
{
session.Load <Person>("people/1");
}
});
}
}
