static void Main()
{
using (var ravenServer = new RavenServer(x => x.RegisterListener(new UniqueConstraintsStoreListener())))
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.RavenDBCustomSagaFinder");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration.UsePersistence<RavenDBPersistence>()
.DoNotSetupDatabasePermissions() //Only required to simplify the sample setup
.SetDefaultDocumentStore(ravenServer.DocumentStore);
using (IBus bus = Bus.Create(busConfiguration).Start())
{
bus.SendLocal(new StartOrder
{
OrderId = "123"
});
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
}
static void Main()
{
using (var ravenServer = new RavenServer())
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.UoWWithChildContainers");
#region ContainerConfiguration
Container container = new Container(x =>
{
x.For<IDocumentStore>().Use(ravenServer.DocumentStore);
x.For<IDocumentSession>().Use(c => c.GetInstance<IDocumentStore>().OpenSession());
});
busConfiguration.UseContainer<StructureMapBuilder>(c => c.ExistingContainer(container));
#endregion
#region PipelineRegistration
busConfiguration.Pipeline.Register<RavenUnitOfWork.Registration>();
#endregion
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.EnableInstallers();
int orderNumber = 1;
using (IBus bus = Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press enter to send a message");
Console.WriteLine("Press any key to exit");
Console.WriteLine("After storing a few orders you can open a browser and view them at " + ravenServer.ManagementUrl);
while (true)
{
ConsoleKeyInfo key = Console.ReadKey();
Console.WriteLine();
if (key.Key != ConsoleKey.Enter)
{
return;
}
bus.SendLocal(new PlaceOrder
{
OrderNumber = string.Format("Order-{0}", orderNumber),
OrderValue = 100
});
orderNumber++;
}
}
}
}
public LocalEndpointClient(RavenServer server)
{
_server = server;
}
protected async Task <(List <RavenServer> Nodes, RavenServer Leader)> CreateRaftCluster(
int numberOfNodes,
bool shouldRunInMemory = true,
int?leaderIndex = null,
bool useSsl = false,
bool createNewCert = false,
string serverCertPath = null,
IDictionary <string, string> customSettings = null,
List <IDictionary <string, string> > customSettingsList = null,
bool watcherCluster = false)
{
leaderIndex = leaderIndex ?? _random.Next(0, numberOfNodes);
RavenServer leader = null;
var serversToPorts = new Dictionary <RavenServer, string>();
var clustersServers = new List <RavenServer>();
_electionTimeoutInMs = Math.Max(300, numberOfNodes * 80);
if (customSettingsList != null && customSettingsList.Count != numberOfNodes)
{
throw new InvalidOperationException("The number of custom settings must equal the number of nodes.");
}
for (var i = 0; i < numberOfNodes; i++)
{
if (customSettingsList == null)
{
customSettings = customSettings ?? new Dictionary <string, string>()
{
[RavenConfiguration.GetKey(x => x.Cluster.MoveToRehabGraceTime)] = "1",
[RavenConfiguration.GetKey(x => x.Cluster.AddReplicaTimeout)] = "1",
[RavenConfiguration.GetKey(x => x.Cluster.ElectionTimeout)] = _electionTimeoutInMs.ToString(),
[RavenConfiguration.GetKey(x => x.Cluster.StabilizationTime)] = "1",
};
}
else
{
customSettings = customSettingsList[i];
}
string serverUrl;
if (useSsl)
{
serverUrl = UseFiddlerUrl("https://127.0.0.1:0");
var shouldCreateNewCert = createNewCert && i == 0;
SetupServerAuthentication(customSettings, serverUrl, createNew: shouldCreateNewCert, serverCertPath: serverCertPath);
}
else
{
serverUrl = UseFiddlerUrl("http://127.0.0.1:0");
customSettings[RavenConfiguration.GetKey(x => x.Core.ServerUrls)] = serverUrl;
}
var co = new ServerCreationOptions
{
CustomSettings = customSettings,
RunInMemory = shouldRunInMemory,
RegisterForDisposal = false
};
var server = GetNewServer(co);
var port = Convert.ToInt32(server.ServerStore.GetNodeHttpServerUrl().Split(':')[2]);
var prefix = useSsl ? "https" : "http";
serverUrl = UseFiddlerUrl($"{prefix}://127.0.0.1:{port}");
Servers.Add(server);
clustersServers.Add(server);
serversToPorts.Add(server, serverUrl);
if (i == leaderIndex)
{
server.ServerStore.EnsureNotPassive();
leader = server;
}
}
for (var i = 0; i < numberOfNodes; i++)
{
if (i == leaderIndex)
{
continue;
}
var follower = clustersServers[i];
// ReSharper disable once PossibleNullReferenceException
await leader.ServerStore.AddNodeToClusterAsync(serversToPorts[follower], asWatcher : watcherCluster);
if (watcherCluster)
{
await follower.ServerStore.WaitForTopology(Leader.TopologyModification.NonVoter);
}
else
{
await follower.ServerStore.WaitForTopology(Leader.TopologyModification.Voter);
}
}
// ReSharper disable once PossibleNullReferenceException
var condition = await leader.ServerStore.WaitForState(RachisState.Leader, CancellationToken.None).WaitAsync(numberOfNodes * _electionTimeoutInMs * 5);
var states = string.Empty;
if (condition == false)
{
states = GetLastStatesFromAllServersOrderedByTime();
}
Assert.True(condition, "The leader has changed while waiting for cluster to become stable. All nodes status: " + states);
return(clustersServers, leader);
}
protected static async Task <(string DataDir, string Url)> DisposeServerAndWaitForFinishOfDisposalAsync(RavenServer serverToDispose, CancellationToken token = default)
{
var mre = new AsyncManualResetEvent();
var dataDir = serverToDispose.Configuration.Core.DataDirectory.FullPath.Split('/').Last();
var url = serverToDispose.WebUrl;
serverToDispose.AfterDisposal += () => mre.Set();
serverToDispose.Dispose();
await mre.WaitAsync(token).ConfigureAwait(false);
return(dataDir, url);
}
protected static bool IsGlobalServer(RavenServer server)
{
return(_globalServer == server);
}
protected bool IsGlobalOrLocalServer(RavenServer server)
{
return(_globalServer == server || _localServer == server);
}
private static SnmpEngine CreateSnmpEngine(RavenServer server, ObjectStore objectStore)
{
(HashSet <SnmpVersion> versions, string handlerVersion) = GetVersions(server);
var membershipProvider = CreateMembershipProvider(server, versions);
var handlers = new[]
{
new HandlerMapping(handlerVersion, "GET", new GetMessageHandler()),
new HandlerMapping(handlerVersion, "GETNEXT", new GetNextMessageHandler()),
new HandlerMapping(handlerVersion, "GETBULK", new GetBulkMessageHandler())
};
var messageHandlerFactory = new MessageHandlerFactory(handlers);
var factory = new SnmpApplicationFactory(new SnmpLogger(Logger), objectStore, membershipProvider, messageHandlerFactory);
var listener = new Listener();
if (versions.Contains(SnmpVersion.V3))
{
var authenticationUser = server.Configuration.Monitoring.Snmp.AuthenticationUser;
var authenticationProtocol = server.Configuration.Monitoring.Snmp.AuthenticationProtocol;
var authenticationPassword = server.Configuration.Monitoring.Snmp.AuthenticationPassword ?? server.Configuration.Monitoring.Snmp.Community;
var privacyProtocol = server.Configuration.Monitoring.Snmp.PrivacyProtocol;
var privacyPassword = server.Configuration.Monitoring.Snmp.PrivacyPassword;
var privacyProvider = CreatePrivacyProvider(authenticationUser, authenticationProtocol, authenticationPassword, privacyProtocol, privacyPassword);
listener.Users.Add(new OctetString(authenticationUser), privacyProvider);
var authenticationUserSecondary = server.Configuration.Monitoring.Snmp.AuthenticationUserSecondary;
if (string.IsNullOrWhiteSpace(authenticationUserSecondary) == false)
{
var authenticationProtocolSecondary = server.Configuration.Monitoring.Snmp.AuthenticationProtocolSecondary;
var authenticationPasswordSecondary = server.Configuration.Monitoring.Snmp.AuthenticationPasswordSecondary;
var privacyProtocolSecondary = server.Configuration.Monitoring.Snmp.PrivacyProtocolSecondary;
var privacyPasswordSecondary = server.Configuration.Monitoring.Snmp.PrivacyPasswordSecondary;
var privacyProviderSecondary = CreatePrivacyProvider(authenticationUserSecondary, authenticationProtocolSecondary, authenticationPasswordSecondary, privacyProtocolSecondary, privacyPasswordSecondary);
listener.Users.Add(new OctetString(authenticationUserSecondary), privacyProviderSecondary);
}
}
int engineBoots;
using (server.ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
using (var tx = context.OpenWriteTransaction())
{
var tree = tx.InnerTransaction.CreateTree(nameof(SnmpWatcher));
engineBoots = (int)tree.Increment("EngineBoots", 1);
tx.Commit();
}
var engineGroup = new EngineGroup(engineBoots, GetIsInTime(server.Configuration.Monitoring))
{
EngineId = new OctetString(server.ServerStore.GetServerId().ToString("N"))
};
var engine = new SnmpEngine(factory, listener, engineGroup);
engine.Listener.AddBinding(new IPEndPoint(IPAddress.Any, server.Configuration.Monitoring.Snmp.Port));
engine.Listener.ExceptionRaised += (sender, e) =>
{
if (Logger.IsOperationsEnabled)
{
Logger.Operations("SNMP error: " + e.Exception.Message, e.Exception);
}
};
return(engine);
protected async Task <(IDisposable Disposable, List <DocumentStore> Stores)> GetStores(RavenServer leader, List <ProcessNode> peers,
List <RavenServer> local = null, Action <DocumentStore> modifyDocumentStore = null)
{
if (modifyDocumentStore == null)
{
modifyDocumentStore = s => s.Conventions.DisableTopologyUpdates = true;
}
var stores = new List <DocumentStore>();
var leaderStore = GetDocumentStore(new Options
{
Server = leader,
CreateDatabase = false,
ModifyDocumentStore = modifyDocumentStore
});
stores.Add(leaderStore);
if (local != null)
{
foreach (var ravenServer in local)
{
var peerStore = GetDocumentStore(new Options
{
Server = ravenServer,
CreateDatabase = false,
ModifyDocumentStore = modifyDocumentStore
});
stores.Add(peerStore);
}
}
foreach (var peer in peers)
{
var peerStore = await GetStore(peer.Url, peer.Process, null, new InterversionTestOptions
{
CreateDatabase = false,
ModifyDocumentStore = modifyDocumentStore
});
stores.Add(peerStore);
}
return(new DisposableAction(() =>
{
foreach (var documentStore in stores)
{
documentStore.Dispose();
}
if (local != null)
{
foreach (var ravenServer in local)
{
ravenServer.Dispose();
}
}
leaderStore.Dispose();
}), stores);
}
/// <summary>
/// Run backup with provided task id and wait for completion. Full backup by default.
/// </summary>
/// <returns>PeriodicBackupStatus</returns>
public PeriodicBackupStatus RunBackupAndReturnStatus(RavenServer server, long taskId, DocumentStore store, bool isFullBackup = true, OperationStatus opStatus = OperationStatus.Completed, long?expectedEtag = default, int?timeout = default)
{
return(AsyncHelpers.RunSync(() => RunBackupAndReturnStatusAsync(server, taskId, store, isFullBackup, opStatus, expectedEtag, timeout)));
}
/// <summary>
/// Update backup config, run backup and wait for completion. Full backup by default.
/// </summary>
/// <returns>TaskId</returns>
public long UpdateConfigAndRunBackup(RavenServer server, PeriodicBackupConfiguration config, DocumentStore store, bool isFullBackup = true, OperationStatus opStatus = OperationStatus.Completed, int?timeout = default)
{
return(AsyncHelpers.RunSync(() => UpdateConfigAndRunBackupAsync(server, config, store, isFullBackup, opStatus, timeout)));
}
/// <summary>
/// Run backup with provided task id and wait for completion. Full backup by default.
/// </summary>
public void RunBackup(RavenServer server, long taskId, DocumentStore store, bool isFullBackup = true, OperationStatus opStatus = OperationStatus.Completed, int?timeout = default)
{
AsyncHelpers.RunSync(() => RunBackupAsync(server, taskId, store, isFullBackup, opStatus, timeout));
}
public void UseNewLocalServer()
{
_localServer?.Dispose();
_localServer = GetNewServer(_customServerSettings);
}
protected async Task <(List <RavenServer> Nodes, RavenServer Leader, TestCertificatesHolder Certificates)> CreateRaftClusterInternalAsync(
int numberOfNodes,
bool?shouldRunInMemory = null,
int?leaderIndex = null,
bool useSsl = false,
IDictionary <string, string> customSettings = null,
List <IDictionary <string, string> > customSettingsList = null,
bool watcherCluster = false,
[CallerMemberName] string caller = null)
{
string[] allowedNodeTags = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" };
var actualLeaderIndex = leaderIndex;
leaderIndex ??= _random.Next(0, numberOfNodes);
RavenServer leader = null;
var serversToPorts = new Dictionary <RavenServer, string>();
var clusterNodes = new List <RavenServer>(); // we need this in case we create more than 1 cluster in the same test
_electionTimeoutInMs = Math.Max(300, numberOfNodes * 80);
if (customSettingsList != null && customSettingsList.Count != numberOfNodes)
{
throw new InvalidOperationException("The number of custom settings must equal the number of nodes.");
}
TestCertificatesHolder certificates = null;
for (var i = 0; i < numberOfNodes; i++)
{
if (customSettingsList == null)
{
customSettings ??= new Dictionary <string, string>(DefaultClusterSettings)
{
[RavenConfiguration.GetKey(x => x.Cluster.ElectionTimeout)] = _electionTimeoutInMs.ToString(),
};
}
else
{
customSettings = customSettingsList[i];
}
string serverUrl;
if (useSsl)
{
serverUrl = UseFiddlerUrl("https://127.0.0.1:0");
certificates = SetupServerAuthentication(customSettings, serverUrl);
}
else
{
serverUrl = UseFiddlerUrl("http://127.0.0.1:0");
customSettings[RavenConfiguration.GetKey(x => x.Core.ServerUrls)] = serverUrl;
}
var co = new ServerCreationOptions
{
CustomSettings = customSettings,
RunInMemory = shouldRunInMemory,
RegisterForDisposal = false,
NodeTag = allowedNodeTags[i]
};
var server = GetNewServer(co, caller);
var port = Convert.ToInt32(server.ServerStore.GetNodeHttpServerUrl().Split(':')[2]);
var prefix = useSsl ? "https" : "http";
serverUrl = UseFiddlerUrl($"{prefix}://127.0.0.1:{port}");
Servers.Add(server);
clusterNodes.Add(server);
serversToPorts.Add(server, serverUrl);
if (i == leaderIndex)
{
server.ServerStore.EnsureNotPassive(null, nodeTag: co.NodeTag);
leader = server;
}
}
using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(5)))
{
for (var i = 0; i < numberOfNodes; i++)
{
if (i == leaderIndex)
{
continue;
}
var follower = clusterNodes[i];
// ReSharper disable once PossibleNullReferenceException
leader = await ActionWithLeader(l =>
l.ServerStore.AddNodeToClusterAsync(serversToPorts[follower], nodeTag: allowedNodeTags[i], asWatcher: watcherCluster, token: cts.Token), clusterNodes);
if (watcherCluster)
{
await follower.ServerStore.WaitForTopology(Leader.TopologyModification.NonVoter, cts.Token);
}
else
{
await follower.ServerStore.WaitForTopology(Leader.TopologyModification.Voter, cts.Token);
}
}
}
await WaitForClusterTopologyOnAllNodes(clusterNodes);
// ReSharper disable once PossibleNullReferenceException
var condition = await leader.ServerStore.WaitForState(RachisState.Leader, CancellationToken.None).WaitAsync(numberOfNodes * _electionTimeoutInMs * 5);
var states = "The leader has changed while waiting for cluster to become stable. All nodes status: ";
if (condition == false)
{
InvalidOperationException e = null;
if (actualLeaderIndex == null)
{
// leader changed, try get the new leader if no leader index was selected
try
{
leader = await ActionWithLeader(_ => Task.CompletedTask, clusterNodes);
return(clusterNodes, leader, certificates);
}
catch (InvalidOperationException ex)
{
e = ex;
}
}
states += GetLastStatesFromAllServersOrderedByTime();
if (e != null)
{
states += $"{Environment.NewLine}{e}";
}
}
Assert.True(condition, states);
return(clusterNodes, leader, certificates);
}
private async Task <(RavenServer Leader, Dictionary <RavenServer, ProxyServer> Proxies, TestCertificatesHolder Certificates)> CreateRaftClusterWithProxiesAndGetLeaderInternalAsync(int numberOfNodes, bool shouldRunInMemory = true, int?leaderIndex = null, bool useSsl = false, int delay = 0, [CallerMemberName] string caller = null)
{
leaderIndex ??= _random.Next(0, numberOfNodes);
RavenServer leader = null;
var serversToPorts = new Dictionary <RavenServer, string>();
var serversToProxies = new Dictionary <RavenServer, ProxyServer>();
var customSettings = GetServerSettingsForPort(useSsl, out var serverUrl, out var certificates);
for (var i = 0; i < numberOfNodes; i++)
{
int proxyPort = 10000;
var co = new ServerCreationOptions
{
CustomSettings = customSettings,
RunInMemory = shouldRunInMemory,
RegisterForDisposal = false
};
var server = GetNewServer(co, caller);
var proxy = new ProxyServer(ref proxyPort, Convert.ToInt32(server.ServerStore.GetNodeHttpServerUrl()), delay);
serversToProxies.Add(server, proxy);
if (Servers.Any(s => s.WebUrl.Equals(server.WebUrl, StringComparison.OrdinalIgnoreCase)) == false)
{
Servers.Add(server);
}
serversToPorts.Add(server, serverUrl);
if (i == leaderIndex)
{
server.ServerStore.EnsureNotPassive();
leader = server;
}
}
using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(5)))
{
for (var i = 0; i < numberOfNodes; i++)
{
if (i == leaderIndex)
{
continue;
}
var follower = Servers[i];
// ReSharper disable once PossibleNullReferenceException
await leader.ServerStore.AddNodeToClusterAsync(serversToPorts[follower], token : cts.Token);
await follower.ServerStore.WaitForTopology(Leader.TopologyModification.Voter, cts.Token);
}
}
// ReSharper disable once PossibleNullReferenceException
var condition = await leader.ServerStore.WaitForState(RachisState.Leader, CancellationToken.None).WaitAsync(numberOfNodes * _electionTimeoutInMs * 5);
var states = string.Empty;
if (condition == false)
{
states = GetLastStatesFromAllServersOrderedByTime();
}
Assert.True(condition, "The leader has changed while waiting for cluster to become stable. All nodes status: " + states);
return(leader, serversToProxies, certificates);
}
public ExternalCertificateValidator(RavenServer server, Logger logger)
{
_server = server;
_logger = logger;
}
public async Task ChangesApiFailOver()
{
var db = "Test";
var topology = new DatabaseTopology
{
DynamicNodesDistribution = true
};
var leader = await CreateRaftClusterAndGetLeader(3, customSettings : new Dictionary <string, string>()
{
[RavenConfiguration.GetKey(x => x.Cluster.AddReplicaTimeout)] = "1",
[RavenConfiguration.GetKey(x => x.Cluster.MoveToRehabGraceTime)] = "0",
[RavenConfiguration.GetKey(x => x.Cluster.StabilizationTime)] = "1",
[RavenConfiguration.GetKey(x => x.Cluster.ElectionTimeout)] = "50"
});
await CreateDatabaseInCluster(new DatabaseRecord
{
DatabaseName = db,
Topology = topology
}, 2, leader.WebUrl);
using (var store = new DocumentStore
{
Database = db,
Urls = new[] { leader.WebUrl }
}.Initialize())
{
var list = new BlockingCollection <DocumentChange>();
var taskObservable = store.Changes();
await taskObservable.EnsureConnectedNow();
var observableWithTask = taskObservable.ForDocument("users/1");
observableWithTask.Subscribe(list.Add);
await observableWithTask.EnsureSubscribedNow();
using (var session = store.OpenSession())
{
session.Store(new User(), "users/1");
session.SaveChanges();
}
WaitForDocument(store, "users/1");
var value = WaitForValue(() => list.Count, 1);
Assert.Equal(1, value);
var currentUrl = store.GetRequestExecutor().Url;
RavenServer toDispose = null;
RavenServer workingServer = null;
DisposeCurrentServer(currentUrl, ref toDispose, ref workingServer);
await taskObservable.EnsureConnectedNow();
WaitForTopologyStabilization(db, workingServer, 1, 2);
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new User(), "users/1");
await session.SaveChangesAsync();
}
value = WaitForValue(() => list.Count, 2);
Assert.Equal(2, value);
currentUrl = store.GetRequestExecutor().Url;
DisposeCurrentServer(currentUrl, ref toDispose, ref workingServer);
await taskObservable.EnsureConnectedNow();
WaitForTopologyStabilization(db, workingServer, 2, 1);
using (var session = store.OpenSession())
{
session.Store(new User(), "users/1");
session.SaveChanges();
}
value = WaitForValue(() => list.Count, 3);
Assert.Equal(3, value);
}
}
public SnmpWatcher(RavenServer server)
{
_server = server;
_server.ServerStore.LicenseManager.LicenseChanged += OnLicenseChanged;
}
private void DisposeCurrentServer(string currnetUrl, ref RavenServer toDispose, ref RavenServer workingServer)
{
foreach (var server in Servers)
{
if (server.WebUrl == currnetUrl)
{
toDispose = server;
continue;
}
if (server.Disposed != true)
{
workingServer = server;
}
}
DisposeServerAndWaitForFinishOfDisposal(toDispose);
}
private static void UnloadServer(AssemblyLoadContext obj)
{
try
{
lock (ServerLocker)
{
var copyGlobalServer = _globalServer;
_globalServer = null;
if (copyGlobalServer == null)
{
return;
}
try
{
using (copyGlobalServer.ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
using (context.OpenReadTransaction())
{
var databases = copyGlobalServer
.ServerStore
.Cluster
.ItemsStartingWith(context, Constants.Documents.Prefix, 0, int.MaxValue)
.ToList();
if (databases.Count > 0)
{
var sb = new StringBuilder();
sb.AppendLine("List of non-deleted databases:");
foreach (var t in databases)
{
sb
.Append("- ")
.AppendLine(t.ItemName.Substring(Constants.Documents.Prefix.Length));
}
Console.WriteLine(sb.ToString());
}
}
}
catch (Exception e)
{
Console.WriteLine($"Could not retrieve list of non-deleted databases. Exception: {e}");
}
copyGlobalServer.Dispose();
GC.Collect(2);
GC.WaitForPendingFinalizers();
var exceptionAggregator = new ExceptionAggregator("Failed to cleanup test databases");
RavenTestHelper.DeletePaths(GlobalPathsToDelete, exceptionAggregator);
exceptionAggregator.ThrowIfNeeded();
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public CpuUsageNotificationSender(int widgetId, RavenServer server, ConnectedWatcher watcher, CancellationToken shutdown) : base(widgetId, watcher, shutdown)
{
_server = server;
}
public AuthenticatingAdapter(RavenServer server, HttpsConnectionAdapter httpsConnectionAdapter)
{
_server = server;
_httpsConnectionAdapter = httpsConnectionAdapter;
}
public RavenWin32Service(string serviceName, RavenConfiguration configuration, string[] args)
{
ServiceName = serviceName;
_args = args;
_ravenServer = new RavenServer(configuration);
}
protected async Task DisposeAndRemoveServer(RavenServer serverToDispose)
{
await DisposeServerAndWaitForFinishOfDisposalAsync(serverToDispose);
Servers.Remove(serverToDispose);
}
public static async Task ListenToAdminConsolePipe(RavenServer ravenServer, NamedPipeServerStream adminConsolePipe)
{
var pipe = adminConsolePipe;
// We start the server pipe only when running as a server
// so we won't generate one per server in our test environment
if (pipe == null)
{
return;
}
try
{
while (true)
{
await pipe.WaitForConnectionAsync();
var reader = new StreamReader(pipe);
var writer = new StreamWriter(pipe);
try
{
var cli = new RavenCli();
var restart = cli.Start(ravenServer, writer, reader, false, true);
if (restart)
{
await writer.WriteLineAsync("Restarting Server...<DELIMETER_RESTART>");
Program.RestartServerMre.Set();
Program.ShutdownServerMre.Set();
// server restarting
return;
}
await writer.WriteLineAsync("Shutting Down Server...<DELIMETER_RESTART>");
Program.ShutdownServerMre.Set();
// server shutting down
return;
}
catch (Exception e)
{
if (Logger.IsInfoEnabled)
{
Logger.Info("Got an exception inside CLI (internal error) while in pipe connection", e);
}
}
pipe.Disconnect();
}
}
catch (ObjectDisposedException)
{
//Server shutting down
}
catch (Exception e)
{
if (Logger.IsInfoEnabled)
{
Logger.Info("Got an exception trying to connect to server admin channel pipe", e);
}
}
}
public async Task ShouldKeepPullingDocsAfterServerRestart()
{
var dataPath = NewDataPath();
IDocumentStore store = null;
RavenServer server = null;
SubscriptionWorker <dynamic> subscriptionWorker = null;
try
{
server = GetNewServer(runInMemory: false, customSettings: new Dictionary <string, string>()
{
[RavenConfiguration.GetKey(x => x.Core.DataDirectory)] = dataPath
});
store = new DocumentStore()
{
Urls = new[] { server.ServerStore.GetNodeHttpServerUrl() },
Database = "RavenDB_2627",
}.Initialize();
var doc = new DatabaseRecord(store.Database);
var result = store.Maintenance.Server.Send(new CreateDatabaseOperationWithoutNameValidation(doc));
await WaitForRaftIndexToBeAppliedInCluster(result.RaftCommandIndex, _reasonableWaitTime);
using (var session = store.OpenSession())
{
session.Store(new User());
session.Store(new User());
session.Store(new User());
session.Store(new User());
session.SaveChanges();
}
var id = store.Subscriptions.Create(new SubscriptionCreationOptions <User>());
subscriptionWorker = store.Subscriptions.GetSubscriptionWorker(new SubscriptionWorkerOptions(id)
{
TimeToWaitBeforeConnectionRetry = TimeSpan.FromSeconds(1),
MaxDocsPerBatch = 1
});
var gotBatch = new ManualResetEventSlim();
var gotArek = new ManualResetEventSlim();
var t = subscriptionWorker.Run(x =>
{
gotBatch.Set();
foreach (var item in x.Items)
{
if (item.Id == "users/arek")
{
gotArek.Set();
}
}
});
Assert.True(gotBatch.Wait(_reasonableWaitTime));
Server.ServerStore.DatabasesLandlord.UnloadDirectly(store.Database);
for (int i = 0; i < 150; i++)
{
try
{
using (var session = store.OpenSession())
{
session.Store(new User(), "users/arek");
session.SaveChanges();
}
break;
}
catch
{
Thread.Sleep(25);
if (i > 100)
{
throw;
}
}
}
Assert.True(gotArek.Wait(_reasonableWaitTime));
}
finally
{
subscriptionWorker?.Dispose();
store?.Dispose();
server.Dispose();
}
}
private static SnmpEngine CreateSnmpEngine(RavenServer server, ObjectStore objectStore)
{
(HashSet <SnmpVersion> versions, string handlerVersion) = GetVersions(server);
var membershipProvider = CreateMembershipProvider(server, versions);
var handlers = new[]
{
new HandlerMapping(handlerVersion, "GET", new GetMessageHandler()),
new HandlerMapping(handlerVersion, "GETNEXT", new GetNextMessageHandler()),
new HandlerMapping(handlerVersion, "GETBULK", new GetBulkMessageHandler())
};
var messageHandlerFactory = new MessageHandlerFactory(handlers);
var factory = new SnmpApplicationFactory(new SnmpLogger(Logger), objectStore, membershipProvider, messageHandlerFactory);
var listener = new Listener();
if (versions.Contains(SnmpVersion.V3))
{
var authenticationPassword = server.Configuration.Monitoring.Snmp.AuthenticationPassword ?? server.Configuration.Monitoring.Snmp.Community;
IAuthenticationProvider authenticationProvider;
switch (server.Configuration.Monitoring.Snmp.AuthenticationProtocol)
{
case SnmpAuthenticationProtocol.SHA1:
authenticationProvider = new SHA1AuthenticationProvider(new OctetString(authenticationPassword));
break;
case SnmpAuthenticationProtocol.MD5:
authenticationProvider = new MD5AuthenticationProvider(new OctetString(authenticationPassword));
break;
default:
throw new InvalidOperationException($"Unknown authentication protocol '{server.Configuration.Monitoring.Snmp.AuthenticationProtocol}'.");
}
var privacyPassword = server.Configuration.Monitoring.Snmp.PrivacyPassword;
IPrivacyProvider privacyProvider;
switch (server.Configuration.Monitoring.Snmp.PrivacyProtocol)
{
case SnmpPrivacyProtocol.None:
privacyProvider = new DefaultPrivacyProvider(authenticationProvider);
break;
case SnmpPrivacyProtocol.DES:
privacyProvider = new BouncyCastleDESPrivacyProvider(new OctetString(privacyPassword), authenticationProvider);
break;
case SnmpPrivacyProtocol.AES:
privacyProvider = new BouncyCastleAESPrivacyProvider(new OctetString(privacyPassword), authenticationProvider);
break;
default:
throw new InvalidOperationException($"Unknown privacy protocol '{server.Configuration.Monitoring.Snmp.AuthenticationProtocol}'.");
}
listener.Users.Add(new OctetString(server.Configuration.Monitoring.Snmp.AuthenticationUser), privacyProvider);
}
var engineGroup = new EngineGroup();
var engine = new SnmpEngine(factory, listener, engineGroup);
engine.Listener.AddBinding(new IPEndPoint(IPAddress.Any, server.Configuration.Monitoring.Snmp.Port));
engine.Listener.ExceptionRaised += (sender, e) =>
{
if (Logger.IsOperationsEnabled)
{
Logger.Operations("SNMP error: " + e.Exception.Message, e.Exception);
}
};
return(engine);
}
private static async Task <OngoingTasksHandler> InstantiateOutgoingTaskHandler(string name, RavenServer server)
{
Assert.True(server.ServerStore.DatabasesLandlord.DatabasesCache.TryGetValue(name, out var db));
var database = await db;
var handler = new OngoingTasksHandler();
var ctx = new RequestHandlerContext
{
RavenServer = server,
Database = database,
HttpContext = new DefaultHttpContext()
};
handler.Init(ctx);
return(handler);
}
private static (HashSet <SnmpVersion> Versions, string HandlerVersion) GetVersions(RavenServer server)
{
var length = server.Configuration.Monitoring.Snmp.SupportedVersions.Length;
if (length <= 0)
{
throw new InvalidOperationException($"There are no SNMP versions configured. Please set at least one in via '{RavenConfiguration.GetKey(x => x.Monitoring.Snmp.SupportedVersions)}' configuration option.");
}
var protocols = new HashSet <string>();
var versions = new HashSet <SnmpVersion>();
foreach (string version in server.Configuration.Monitoring.Snmp.SupportedVersions)
{
if (Enum.TryParse(version, ignoreCase: true, out SnmpVersion v) == false)
{
throw new InvalidOperationException($"Could not recognize '{version}' as a valid SNMP version.");
}
versions.Add(v);
switch (v)
{
case SnmpVersion.V2C:
protocols.Add("V2");
break;
case SnmpVersion.V3:
protocols.Add("V3");
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(versions, string.Join(",", protocols));
}
protected X509Certificate2 AskServerForClientCertificate(string serverCertPath, Dictionary <string, DatabaseAccess> permissions, SecurityClearance clearance = SecurityClearance.ValidUser, RavenServer server = null)
{
var serverCertificate = new X509Certificate2(serverCertPath);
X509Certificate2 clientCertificate;
using (var store = GetDocumentStore(new Options
{
Server = server,
ClientCertificate = serverCertificate,
AdminCertificate = serverCertificate
}))
{
var requestExecutor = store.GetRequestExecutor();
using (requestExecutor.ContextPool.AllocateOperationContext(out JsonOperationContext context))
{
var command = new CreateClientCertificateOperation("client certificate", permissions, clearance)
.GetCommand(store.Conventions, context);
requestExecutor.Execute(command, context);
clientCertificate = new X509Certificate2(command.Result.RawData);
}
}
return(clientCertificate);
}
protected static async Task <(string DataDirectory, string Url, string NodeTag)> DisposeServerAndWaitForFinishOfDisposalAsync(RavenServer serverToDispose)
{
var dataDirectory = serverToDispose.Configuration.Core.DataDirectory.FullPath;
var url = serverToDispose.WebUrl;
var nodeTag = serverToDispose.ServerStore.NodeTag;
await DisposeServerAsync(serverToDispose);
return(dataDirectory, url, nodeTag);
}
