public void StartDatabase(int index)
{
var previousServer = servers[index];
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(previousServer.SystemDatabase.Configuration.Port);
var serverConfiguration = new RavenConfiguration {
Settings = { { "Raven/ActiveBundles", "replication" } }
};
ConfigurationHelper.ApplySettingsToConfiguration(serverConfiguration);
serverConfiguration.AnonymousUserAccessMode = AnonymousUserAccessMode.Admin;
serverConfiguration.DataDirectory = previousServer.SystemDatabase.Configuration.DataDirectory;
serverConfiguration.RunInUnreliableYetFastModeThatIsNotSuitableForProduction = true;
serverConfiguration.RunInMemory = previousServer.SystemDatabase.Configuration.RunInMemory;
serverConfiguration.Port = previousServer.SystemDatabase.Configuration.Port;
serverConfiguration.DefaultStorageTypeName = GetDefaultStorageType();
serverConfiguration.Encryption.UseFips = ConfigurationHelper.UseFipsEncryptionAlgorithms;
ModifyConfiguration(serverConfiguration);
serverConfiguration.PostInit();
var ravenDbServer = new RavenDbServer(serverConfiguration)
{
UseEmbeddedHttpServer = true
};
ravenDbServer.Initialize(ConfigureServer);
servers[index] = ravenDbServer;
}
public TestServerFixture()
{
var configuration = new RavenConfiguration();
ConfigurationHelper.ApplySettingsToConfiguration(configuration);
configuration.Port = Port;
configuration.ServerName = ServerName;
configuration.RunInMemory = configuration.DefaultStorageTypeName == InMemoryRavenConfiguration.VoronTypeName;
configuration.DataDirectory = Path.Combine(configuration.DataDirectory, "Tests");
configuration.MaxSecondsForTaskToWaitForDatabaseToLoad = 10;
configuration.Storage.Voron.AllowOn32Bits = true;
IOExtensions.DeleteDirectory(configuration.DataDirectory);
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(Port);
Server = new RavenDbServer(configuration)
{
UseEmbeddedHttpServer = true,
RunInMemory = true
}.Initialize();
}
protected RavenDbServer GetNewServer(int port = 8079,
string dataDirectory = null,
bool runInMemory = true,
string requestedStorage = null,
bool enableAuthentication = false,
string activeBundles = null,
Action <RavenDBOptions> configureServer = null,
Action <InMemoryRavenConfiguration> configureConfig = null,
[CallerMemberName] string databaseName = null)
{
databaseName = NormalizeDatabaseName(databaseName != Constants.SystemDatabase ? databaseName : null);
checkPorts = true;
if (dataDirectory != null)
{
pathsToDelete.Add(dataDirectory);
}
var storageType = GetDefaultStorageType(requestedStorage);
var directory = dataDirectory ?? NewDataPath(databaseName == Constants.SystemDatabase ? null : databaseName);
var ravenConfiguration = new RavenConfiguration();
ConfigurationHelper.ApplySettingsToConfiguration(ravenConfiguration);
ravenConfiguration.Port = port;
ravenConfiguration.DataDirectory = Path.Combine(directory, "System");
ravenConfiguration.RunInMemory = runInMemory;
#if DEBUG
ravenConfiguration.RunInUnreliableYetFastModeThatIsNotSuitableForProduction = runInMemory;
#endif
ravenConfiguration.DefaultStorageTypeName = storageType;
ravenConfiguration.AnonymousUserAccessMode = enableAuthentication ? AnonymousUserAccessMode.None : AnonymousUserAccessMode.Admin;
ravenConfiguration.FileSystem.DataDirectory = Path.Combine(directory, "FileSystem");
ravenConfiguration.Encryption.UseFips = ConfigurationHelper.UseFipsEncryptionAlgorithms;
ravenConfiguration.Settings["Raven/StorageTypeName"] = ravenConfiguration.DefaultStorageTypeName;
if (activeBundles != null)
{
ravenConfiguration.Settings["Raven/ActiveBundles"] = activeBundles;
}
if (configureConfig != null)
{
configureConfig(ravenConfiguration);
}
ModifyConfiguration(ravenConfiguration);
ravenConfiguration.PostInit();
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(ravenConfiguration.Port);
var ravenDbServer = new RavenDbServer(ravenConfiguration)
{
UseEmbeddedHttpServer = true,
};
ravenDbServer.Initialize(configureServer);
servers.Add(ravenDbServer);
try
{
using (var documentStore = new DocumentStore
{
Url = "http://localhost:" + port,
Conventions =
{
FailoverBehavior = FailoverBehavior.FailImmediately
},
DefaultDatabase = databaseName
}.Initialize())
{
CreateDefaultIndexes(documentStore);
}
}
catch
{
ravenDbServer.Dispose();
throw;
}
if (enableAuthentication)
{
EnableAuthentication(ravenDbServer.SystemDatabase);
ModifyConfiguration(ravenConfiguration);
ravenConfiguration.PostInit();
}
return(ravenDbServer);
}
protected RavenDbServer CreateServer(int port,
string dataDirectory = null,
bool runInMemory = true,
string requestedStorage = null,
bool enableAuthentication = false,
string fileSystemName = null,
string activeBundles = null,
Action <RavenConfiguration> customConfig = null)
{
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(port);
var storageType = GetDefaultStorageType(requestedStorage);
var directory = dataDirectory ?? NewDataPath(fileSystemName + "_" + port);
var ravenConfiguration = new RavenConfiguration();
ConfigurationHelper.ApplySettingsToConfiguration(ravenConfiguration);
ravenConfiguration.Port = port;
ravenConfiguration.DataDirectory = directory;
ravenConfiguration.RunInMemory = runInMemory;
#if DEBUG
ravenConfiguration.RunInUnreliableYetFastModeThatIsNotSuitableForProduction = runInMemory;
#endif
ravenConfiguration.DefaultStorageTypeName = storageType;
ravenConfiguration.AnonymousUserAccessMode = enableAuthentication ? AnonymousUserAccessMode.None : AnonymousUserAccessMode.Admin;
ravenConfiguration.Encryption.UseFips = ConfigurationHelper.UseFipsEncryptionAlgorithms;
ravenConfiguration.FileSystem.MaximumSynchronizationInterval = SynchronizationInterval;
ravenConfiguration.FileSystem.DataDirectory = Path.Combine(directory, "FileSystems");
ravenConfiguration.FileSystem.DefaultStorageTypeName = storageType;
if (activeBundles != null)
{
ravenConfiguration.Settings[Constants.ActiveBundles] = activeBundles;
}
if (customConfig != null)
{
customConfig(ravenConfiguration);
}
if (enableAuthentication)
{
Authentication.EnableOnce();
}
var ravenDbServer = new RavenDbServer(ravenConfiguration)
{
UseEmbeddedHttpServer = true,
};
ravenDbServer.Initialize();
servers.Add(ravenDbServer);
if (enableAuthentication)
{
EnableAuthentication(ravenDbServer.SystemDatabase);
}
ConfigureServer(ravenDbServer, fileSystemName);
return(ravenDbServer);
}
/// <summary>
/// Creates a new Embeddable document store.
/// </summary>
/// <param name="runInMemory">Whatever the database should run purely in memory. When running in memory, nothing is written to disk and if the server is restarted all data will be lost.<br/>Default: <b>true</b></param>
/// <param name="requestedStorage">What storage type to use (see: RavenDB Storage engines).<br/>Allowed values: <b>vornon</b>, <b>esent</b>.<br/>Default: <b>voron</b></param>
/// <param name="catalog">Custom bundles that are not provided by RavenDb.</param>
/// <param name="dataDir">The path for the database directory. Can use ~\ as the root, in which case the path will start from the server base directory. <br/>Default: <b>~\Databases\System</b></param>
/// <param name="enableAuthentication"></param>
/// <param name="activeBundles">Semicolon separated list of bundles names, such as: 'Replication;Versioning'.<br/>Default: no bundles turned on.</param>
/// <param name="port">The port to use when creating the http listener. Allowed: 1 - 65,536 or * (find first available port from 8079 and upward).<br/>Default: <b>8079</b></param>
/// <param name="anonymousUserAccessMode">Determines what actions an anonymous user can do. Get - read only, All - read & write, None - allows access to only authenticated users, Admin - all (including administrative actions).<br/>Default: <b>Get</b></param>
/// <param name="configureStore">An action delegate which allows you to configure the document store instance that is returned. eg. <code>configureStore: store => store.DefaultDatabase = "MasterDb"</code></param>
/// <param name="databaseName">Name of the server that will show up on /admin/stats endpoint.</param>
/// <param name="indexes">A collection of indexes to execute.</param>
/// <param name="transformers">A collection of transformers to execute.</param>
/// <param name="seedData">A collection of some fake data that will be automatically stored into the document store.</param>
/// <param name="noStaleQueries">When you query an index, the query will wait for the index to complete it's indexing and not be stale -before- the query is executed.</param>
/// <param name="conventions">The conventions to be used when creating a new embeddable document store</param>
/// <remarks>Besides the document store being instantiated, it is also Initialized.<br/>Also, if you provide some indexes to be used, make sure you understand that they might be stale when you query them. To make sure you're querying against indexes that have completed their indexing (ie. index is not stale), use the <code>noStaleQueries</code> parameter to determine if you wish to query against a stale or not-stale query.</remarks>
/// <returns>A new instance of an EmbeddableDocumentStore.</returns>
public EmbeddableDocumentStore NewDocumentStore(
bool runInMemory = true,
string requestedStorage = null,
ComposablePartCatalog catalog = null,
string dataDir = null,
bool enableAuthentication = false,
string activeBundles = null,
int?port = null,
AnonymousUserAccessMode anonymousUserAccessMode = AnonymousUserAccessMode.Admin,
Action <EmbeddableDocumentStore> configureStore = null,
[CallerMemberName] string databaseName = null,
IEnumerable <AbstractIndexCreationTask> indexes = null,
IEnumerable <AbstractTransformerCreationTask> transformers = null,
IEnumerable <IEnumerable> seedData = null,
bool noStaleQueries = false,
DocumentConvention conventions = null)
{
databaseName = NormalizeDatabaseName(databaseName);
var storageType = GetDefaultStorageType(requestedStorage);
var dataDirectory = dataDir ?? NewDataPath(databaseName);
var documentStore = new EmbeddableDocumentStore
{
UseEmbeddedHttpServer = port.HasValue,
Conventions = conventions ?? new DocumentConvention()
};
ConfigurationHelper.ApplySettingsToConfiguration(documentStore.Configuration);
documentStore.Configuration.DefaultStorageTypeName = storageType;
documentStore.Configuration.DataDirectory = Path.Combine(dataDirectory, "System");
documentStore.Configuration.RunInUnreliableYetFastModeThatIsNotSuitableForProduction = true;
documentStore.Configuration.RunInMemory = storageType.Equals("esent", StringComparison.OrdinalIgnoreCase) == false && runInMemory;
documentStore.Configuration.Port = port ?? 8079;
documentStore.Configuration.AnonymousUserAccessMode = anonymousUserAccessMode;
documentStore.Configuration.FileSystem.DataDirectory = Path.Combine(dataDirectory, "FileSystem");
documentStore.Configuration.Encryption.UseFips = ConfigurationHelper.UseFipsEncryptionAlgorithms;
if (activeBundles != null)
{
documentStore.Configuration.Settings["Raven/ActiveBundles"] = activeBundles;
}
if (catalog != null)
{
documentStore.Configuration.Catalog.Catalogs.Add(catalog);
}
try
{
if (configureStore != null)
{
configureStore(documentStore);
}
ModifyStore(documentStore);
ModifyConfiguration(documentStore.Configuration);
documentStore.Configuration.PostInit();
documentStore.Initialize();
if (enableAuthentication)
{
EnableAuthentication(documentStore.SystemDatabase);
}
CreateDefaultIndexes(documentStore);
if (indexes != null)
{
ExecuteIndexes(indexes, documentStore);
}
if (noStaleQueries)
{
documentStore.Listeners.RegisterListener(new NoStaleQueriesListener());
}
if (transformers != null)
{
ExecuteTransformers(transformers, documentStore);
}
if (seedData != null)
{
StoreSeedData(seedData, documentStore);
}
return(documentStore);
}
catch
{
// We must dispose of this object in exceptional cases, otherwise this test will break all the following tests.
documentStore.Dispose();
throw;
}
finally
{
stores.Add(documentStore);
}
}
