private async Task <bool> SendPerformanceStatsOrHeartbeatToWebSocket(Task <WebSocketReceiveResult> receive, WebSocket webSocket,
LiveReplicationPerformanceCollector collector, MemoryStream ms, int timeToWait)
{
if (receive.IsCompleted || webSocket.State != WebSocketState.Open)
{
return(false);
}
var tuple = await collector.Stats.TryDequeueAsync(TimeSpan.FromMilliseconds(timeToWait));
if (tuple.Item1 == false)
{
await webSocket.SendAsync(WebSocketHelper.Heartbeat, WebSocketMessageType.Text, true, Database.DatabaseShutdown);
return(true);
}
ms.SetLength(0);
using (ContextPool.AllocateOperationContext(out JsonOperationContext context))
using (var writer = new AsyncBlittableJsonTextWriter(context, ms, Database.DatabaseShutdown))
{
writer.WriteStartObject();
writer.WriteArray(context, "Results", tuple.Item2, (w, c, p) =>
{
p.Write(c, w);
});
writer.WriteEndObject();
await writer.OuterFlushAsync();
}
ms.TryGetBuffer(out ArraySegment <byte> bytes);
await webSocket.SendAsync(bytes, WebSocketMessageType.Text, true, Database.DatabaseShutdown);
return(true);
}
public async Task RavenDB_17187_CheckExternalShowsInStats()
{
var database = GetDatabaseName();
using (var sender = GetNewServer(new ServerCreationOptions {
}))
using (var receiver = GetNewServer(new ServerCreationOptions {
}))
using (var senderStore = GetDocumentStore(new Options
{
Server = sender,
CreateDatabase = true,
ModifyDatabaseName = (s) => database
}))
using (var receiverStore = GetDocumentStore(new Options
{
Server = receiver,
CreateDatabase = true,
ModifyDatabaseName = (s) => database
}))
{
await SetupReplicationAsync(senderStore, receiverStore);
await EnsureReplicatingAsync(senderStore, receiverStore);
var collector = new LiveReplicationPerformanceCollector(await sender.ServerStore.DatabasesLandlord.TryGetOrCreateResourceStore(database));
var stats = await collector.Stats.DequeueAsync();
Assert.Equal(1, stats.Count);
Assert.Equal(LiveReplicationPerformanceCollector.ReplicationPerformanceType.OutgoingExternal, ((LiveReplicationPerformanceCollector.OutgoingPerformanceStats)stats[0]).Type);
var collector2 = new LiveReplicationPerformanceCollector(await receiver.ServerStore.DatabasesLandlord.TryGetOrCreateResourceStore(database));
var stats2 = await collector2.Stats.DequeueAsync();
Assert.Equal(1, stats2.Count);
Assert.Equal(LiveReplicationPerformanceCollector.ReplicationPerformanceType.IncomingExternal, ((LiveReplicationPerformanceCollector.IncomingPerformanceStats)stats2[0]).Type);
}
}
public async Task PerformanceLive()
{
using (var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync())
{
var receiveBuffer = new ArraySegment <byte>(new byte[1024]);
var receive = webSocket.ReceiveAsync(receiveBuffer, Database.DatabaseShutdown);
using (var ms = new MemoryStream())
using (var collector = new LiveReplicationPerformanceCollector(Database))
{
// 1. Send data to webSocket without making UI wait upon opening webSocket
await SendPerformanceStatsOrHeartbeatToWebSocket(receive, webSocket, collector, ms, 100);
// 2. Send data to webSocket when available
while (Database.DatabaseShutdown.IsCancellationRequested == false)
{
if (await SendPerformanceStatsOrHeartbeatToWebSocket(receive, webSocket, collector, ms, 4000) == false)
{
break;
}
}
}
}
}
public async Task RavenDB_17187_CheckInternalShowsInStats()
{
var database = GetDatabaseName();
var cluster = await CreateRaftCluster(3);
await CreateDatabaseInCluster(database, 3, cluster.Leader.WebUrl);
using (var store1 = new DocumentStore
{
Urls = new[] { cluster.Nodes[0].WebUrl },
Conventions = { DisableTopologyUpdates = true },
Database = database
}.Initialize())
using (var store2 = new DocumentStore
{
Urls = new[] { cluster.Nodes[1].WebUrl },
Conventions = { DisableTopologyUpdates = true },
Database = database,
}.Initialize())
using (var store3 = new DocumentStore
{
Urls = new[] { cluster.Nodes[2].WebUrl },
Conventions = { DisableTopologyUpdates = true },
Database = database
}.Initialize())
{
using (var s1 = store1.OpenSession(database))
{
s1.Store(new User(), "foo/bar/store1");
s1.SaveChanges();
}
using (var s2 = store2.OpenSession(database))
{
s2.Store(new User(), "foo/bar/store2");
s2.SaveChanges();
}
using (var s3 = store3.OpenSession(database))
{
s3.Store(new User(), "foo/bar/store3");
s3.SaveChanges();
}
WaitForDocumentInAllStores("foo/bar/store1");
WaitForDocumentInAllStores("foo/bar/store2");
WaitForDocumentInAllStores("foo/bar/store3");
var collector = new LiveReplicationPerformanceCollector(await cluster.Nodes[0].ServerStore.DatabasesLandlord.TryGetOrCreateResourceStore(database));
var stats = await collector.Stats.DequeueAsync();
Assert.Equal(4, stats.Count);
Assert.Equal(2,
stats.Count(performanceStats => performanceStats is LiveReplicationPerformanceCollector.IncomingPerformanceStats perf &&
perf.Type == LiveReplicationPerformanceCollector.ReplicationPerformanceType.IncomingInternal));
Assert.Equal(2,
stats.Count(performanceStats => performanceStats is LiveReplicationPerformanceCollector.OutgoingPerformanceStats perf &&
perf.Type == LiveReplicationPerformanceCollector.ReplicationPerformanceType.OutgoingInternal));
void WaitForDocumentInAllStores(string documentId)
{
WaitForDocument(store1, documentId);
WaitForDocument(store2, documentId);
WaitForDocument(store3, documentId);
}
}
}
