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
}
});
}
