public IDocumentStore CreateStore()
{
var port = PortRangeStart + servers.Count;
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(port);
var ravenDbServer = new RavenDbServer(new database::Raven.Database.Config.RavenConfiguration
{
AnonymousUserAccessMode = AnonymousUserAccessMode.All,
Catalog = { Catalogs = { new AssemblyCatalog(typeof(replication::Raven.Bundles.Replication.Triggers.AncestryPutTrigger).Assembly) } },
DataDirectory = "Data #" + servers.Count,
RunInUnreliableYetFastModeThatIsNotSuitableForProduction = true,
Port = port
});
servers.Add(ravenDbServer);
var documentStore = new DocumentStore {
Url = ravenDbServer.Database.Configuration.ServerUrl
};
documentStore.Initialize();
stores.Add(documentStore);
return(documentStore);
}
public void StartDatabase(int index)
{
var previousServer = servers[index];
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(previousServer.Database.Configuration.Port);
var serverConfiguration = new RavenConfiguration
{
Settings = { { "Raven/ActiveBundles", "replication" } },
AnonymousUserAccessMode = AnonymousUserAccessMode.Admin,
DataDirectory = previousServer.Database.Configuration.DataDirectory,
RunInUnreliableYetFastModeThatIsNotSuitableForProduction = true,
RunInMemory = previousServer.Database.Configuration.RunInMemory,
Port = previousServer.Database.Configuration.Port,
DefaultStorageTypeName = GetDefaultStorageType()
};
ConfigureServer(serverConfiguration);
serverConfiguration.PostInit();
var ravenDbServer = new RavenDbServer(serverConfiguration);
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();
}
private IDocumentStore InitDocumentStore(AutofacCreationConverter converter)
{
var ds = new EmbeddableDocumentStore
{
DataDirectory = _dataDirectory,
ResourceManagerId = Guid.NewGuid(),
RunInMemory = RunInMemory,
};
if (_httpAccesss)
{
ds.UseEmbeddedHttpServer = true;
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(_httpAccesssPort);
}
if (converter != null && UseCreationConverter)
{
ds.Conventions.CustomizeJsonSerializer += s => s.Converters.Add(converter);
}
ds.Conventions.DisableProfiling = true;
ds.Conventions.JsonContractResolver = new RecordClrTypeInJsonContractResolver();
ds.Conventions.CustomizeJsonSerializer += s => s.TypeNameHandling = TypeNameHandling.Arrays;
ds.Initialize();
IndexCreation.CreateIndexes(ThisAssembly, ds);
if (_indexAssemblies != null)
{
foreach (var indexAssembly in _indexAssemblies)
{
IndexCreation.CreateIndexes(indexAssembly, ds);
}
}
//global::Raven.Client.Indexes.IndexCreation.CreateIndexes(typeof(RegionTrajectoryIndex).Assembly, ds);
return(ds);
}
public static void Main(string[] args)
{
const int port = 9020;
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(port);
var host = new NancyHost(new Uri(string.Format("http://localhost:{0}/", port)));
host.Start();
while (true)
{
Console.WriteLine("Available commands: q.");
var line = Console.ReadLine();
if (line == "q")
{
host.Stop();
break;
}
}
Console.WriteLine("You have stopped the cluster manager.");
}
public void InMemoryDoesNotCreateDataDir()
{
if (Directory.Exists("Data"))
{
Directory.Delete("Data", true);
}
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8080);
using (var store = new EmbeddableDocumentStore
{
RunInMemory = true,
UseEmbeddedHttpServer = true,
Configuration =
{
Port = 8080,
RunInMemory = true
}
})
{
store.Initialize();
Assert.False(Directory.Exists("Data"));
}
}
public static IDocumentStore Initialize()
{
var store = new EmbeddableDocumentStore
{
DataDirectory = "Data",
UseEmbeddedHttpServer = true,
//RunInMemory = true,
Configuration =
{
Port = DefaultPort,
//HostName = "localhost"
AnonymousUserAccessMode = AnonymousUserAccessMode.All
},
};
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(DefaultPort);
store.Conventions.IdentityPartsSeparator = "-";
store.Initialize();
IndexCreation.CreateIndexes(Assembly.GetCallingAssembly(), store);
return(store);
}
public AsyncDocumentStoreServerTests()
{
port = 8080;
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8080);
}
public SmugglerApiTests()
{
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(Port1);
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(Port2);
IOExtensions.DeleteDirectory(BackupDir);
}
public LinqOnUrls()
{
port = 8079;
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8079);
}
public QueryingWithDynamicRavenQueryInspector()
{
port = 8079;
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8079);
}
protected RavenDbServer CreateServer(int port,
string dataDirectory = null,
bool runInMemory = true,
string requestedStorage = null,
bool enableAuthentication = false,
string fileSystemName = null,
Action <RavenConfiguration> customConfig = null)
{
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(port);
var storageType = GetDefaultStorageType(requestedStorage);
var directory = dataDirectory ?? NewDataPath(fileSystemName + "_" + port);
var ravenConfiguration = new RavenConfiguration
{
Port = port,
DataDirectory = directory,
RunInMemory = storageType.Equals("esent", StringComparison.OrdinalIgnoreCase) == false && runInMemory,
#if DEBUG
RunInUnreliableYetFastModeThatIsNotSuitableForProduction = runInMemory,
#endif
DefaultStorageTypeName = storageType,
AnonymousUserAccessMode = enableAuthentication ? AnonymousUserAccessMode.None : AnonymousUserAccessMode.Admin,
Encryption =
{
UseFips = SettingsHelper.UseFipsEncryptionAlgorithms
},
FileSystem =
{
MaximumSynchronizationInterval = this.SynchronizationInterval,
DataDirectory = Path.Combine(directory, "FileSystems"),
DefaultStorageTypeName = storageType
},
};
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);
}
public TotalCountServerTest()
{
port = 8080;
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8080);
}
public AsyncRemoteDocumentStoreServerTests()
{
ravenTest = new RemoteClientTest();
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8079);
DocumentStore = ravenTest.NewRemoteDocumentStore().Initialize();
}
public GrantAccessTokenClientCredentialsFlow()
{
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8079);
}
public OverwriteIndexRemotely()
{
port = 8079;
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8079);
}
public AccessTokenAuthentication()
{
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8079);
}
public ServerRunner(int port)
{
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(port);
server = WebApp.Start <Startup>(string.Format("http://+:{0}/", port));
}
public AttachmentEndoding()
{
port = 8079;
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8079);
}
public UsingDynamicQueryWithRemoteServer()
{
port = 8080;
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8080);
}
public SortingWithWildcardQuery()
{
port = 8080;
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8080);
}
public AccessTokenAuthentication()
{
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(port);
}
public GrantAccessTokenClientCredentialsFlow()
{
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8079);
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
#pragma warning disable 618
container.Kernel.ReleasePolicy = new NoTrackingReleasePolicy();
#pragma warning restore 618
container.Kernel.AddFacility <TypedFactoryFacility>();
container.Kernel.Resolver.AddSubResolver(new CollectionResolver(container.Kernel));
container.Register(Component.For <IQueuePoller>().ImplementedBy <QueuePoller>().LifestyleTransient(),
Component.For <IQueuePollerFactory>().AsFactory(),
Component.For <IRabbitConnectionFactory>().ImplementedBy <RabbitConnectionFactory>().LifestyleSingleton(),
Component.For <IRawMessage>().ImplementedBy <RawMessage>().LifestyleTransient(),
Component.For <IHost>().ImplementedBy <Host.Host>().LifestyleSingleton(),
Component.For <IQueuePollerHost>().ImplementedBy <QueuePollerHost>().LifestyleTransient(),
Component.For <IWebHost>().ImplementedBy <WebHost>().LifestyleTransient(),
Component.For <ISubHostFactory>().AsFactory().LifestyleSingleton(),
Component.For <ISchemaUpdater>().ImplementedBy <SchemaUpdater>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0002>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0006>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0007>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0008>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0010>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0012>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0014>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0015>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0016>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0017>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0018>().LifestyleTransient(),
Component.For <IUpdateSchemaVersion>().ImplementedBy <ToVersion0019>().LifestyleTransient(),
Component.For <IActiveQueuePollers>().ImplementedBy <ActiveQueuePollers>().LifestyleSingleton(),
Component.For <IBasicSearch>().ImplementedBy <BasicSearch>().LifestyleSingleton(),
Component.For <ICancellationTokenSource>()
.ImplementedBy <CancellationTokenSourceWrapper>()
.LifestyleTransient(),
Component.For <CancellationTokenSource>().LifestyleTransient(),
Component.For <ISettings>().ImplementedBy <Settings>().LifestyleSingleton(),
Component.For <IHeaderParser>().ImplementedBy <HeaderParser>().LifestyleSingleton(),
Component.For <IRavenTenantInitializer>().ImplementedBy <RavenTenantInitializer>().LifestyleSingleton(),
Component.For <IQualifiedSchemaUpdatersFactory>().ImplementedBy <QualifiedSchemaUpdatersFactory>().LifestyleSingleton(),
Component.For <IRetryMessages>().ImplementedBy <RetryMessagesService>().LifestyleSingleton(),
Component.For <ICreateRetryMessagesFromOriginal>().ImplementedBy <CreateRetryMessageFromOriginalService>().LifestyleSingleton(),
Component.For <IDetermineRetryDestination>().ImplementedBy <DetermineRetryDestinationService>().LifestyleSingleton(),
Component.For <IAddRetryTrackingHeaders>().ImplementedBy <AddRetryTrackingHeadersService>().LifestyleSingleton(),
Component.For <ISendMessages>().ImplementedBy <SendMessagesService>().LifestyleSingleton(),
Component.For <IStoreMessages>().ImplementedBy <StoreMessagesThatAreRetriesService>().LifestyleSingleton(),
Component.For <IStoreMessages>().ImplementedBy <StoreMessagesThatAreNotRetriesService>().LifestyleSingleton(),
Component.For <IStoreMessagesFactory>().ImplementedBy <StoreMessagesFactory>().LifestyleSingleton(),
Component.For <ICreateBasicProperties>().ImplementedBy <CreateBasicPropertiesService>().LifestyleSingleton(),
Component.For <IDocumentStore>().UsingFactoryMethod(x =>
{
IDocumentStore docStore = null;
if (Settings.StaticEmbedRavenDB)
{
var port = Settings.StaticEmbeddedRavenDBManagementPort;
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(port);
docStore = new EmbeddableDocumentStore
{
UseEmbeddedHttpServer = true,
ConnectionStringName = "RavenDB"
};
(docStore as EmbeddableDocumentStore).Configuration.Port = port;
}
else
{
docStore = new DocumentStore
{
ConnectionStringName = "RavenDB"
};
}
docStore.Conventions.DisableProfiling = true;
docStore.Initialize();
CreateDefaultDatabaseWithExpirationBundleIfNotExists(docStore);
return(docStore);
}).LifestyleSingleton());
}
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);
}
public When_Using_Parallel_Access_Strategy()
{
port = 8079;
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8079);
}
public QueryWithPercentageSignp()
{
port = 8080;
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8080);
}
public WillNotFailSystemIfServerIsNotAvailableOnStartup()
{
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8079);
}
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();
if (customConfig != null)
{
customConfig(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.MaxSecondsForTaskToWaitForDatabaseToLoad = 20;
ravenConfiguration.FileSystem.MaximumSynchronizationInterval = SynchronizationInterval;
ravenConfiguration.FileSystem.DataDirectory = Path.Combine(directory, "FileSystems");
ravenConfiguration.FileSystem.DefaultStorageTypeName = storageType;
if (activeBundles != null)
{
ravenConfiguration.Settings[Constants.ActiveBundles] = activeBundles;
}
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);
}
public ModifyingMetadataFromTrigger()
{
port = 8079;
path = GetPath("TestDb");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8079);
}
