protected CommunicationController(IPublisher publisher)
{
Ensure.NotNull(publisher, "publisher");
_publisher = publisher;
Client = new HttpAsyncClient();
}
public void SetUp(Action <IHttpService> bootstrap = null)
{
_bus = new InMemoryBus($"bus_{_serverEndPoint.Port}");
var pipelineBus = InMemoryBus.CreateTest();
var queue = new QueuedHandlerThreadPool(pipelineBus, "Test", new QueueStatsManager(), true, TimeSpan.FromMilliseconds(50));
_multiQueuedHandler = new MultiQueuedHandler(new IQueuedHandler[] { queue }, null);
_multiQueuedHandler.Start();
_service = new KestrelHttpService(ServiceAccessibility.Private, _bus, new NaiveUriRouter(),
_multiQueuedHandler, false, null, 0, false, _serverEndPoint);
_internalDispatcher = new InternalDispatcherEndpoint(queue, _multiQueuedHandler);
_bus.Subscribe(_internalDispatcher);
KestrelHttpService.CreateAndSubscribePipeline(pipelineBus);
bootstrap?.Invoke(_service);
_server = new TestServer(
new WebHostBuilder()
.UseStartup(new ClusterVNodeStartup(Array.Empty <ISubsystem>(), queue, _bus, _multiQueuedHandler,
new TestAuthenticationProvider(),
new IHttpAuthenticationProvider[] {
new BasicHttpAuthenticationProvider(new TestAuthenticationProvider()),
new AnonymousHttpAuthenticationProvider(),
}, new TestAuthorizationProvider(), new FakeReadIndex(_ => false), 1024 * 1024, _service)));
_httpMessageHandler = _server.CreateHandler();
_client = new HttpAsyncClient(_timeout, _httpMessageHandler);
HttpBootstrap.Subscribe(_bus, _service);
}
public void of_http_requests_routing()
{
const int iterations = 100000;
IPublisher inputBus = new NoopPublisher();
var bus = InMemoryBus.CreateTest();
var queue = new QueuedHandlerThreadPool(bus, "Test", true, TimeSpan.FromMilliseconds(50));
var multiQueuedHandler = new MultiQueuedHandler(new IQueuedHandler[] { queue }, null);
var providers = new HttpAuthenticationProvider[] { new AnonymousHttpAuthenticationProvider() };
var httpService = new HttpService(ServiceAccessibility.Public, inputBus,
new TrieUriRouter(), multiQueuedHandler, false, "http://localhost:12345/");
HttpService.CreateAndSubscribePipeline(bus, providers);
var fakeController = new FakeController(iterations, null);
httpService.SetupController(fakeController);
httpService.Handle(new SystemMessage.SystemInit());
var rnd = new Random();
var sw = Stopwatch.StartNew();
var httpClient = new HttpAsyncClient();
for (int i = 0; i < iterations; ++i)
{
var route = fakeController.BoundRoutes[rnd.Next(0, fakeController.BoundRoutes.Count)];
switch (route.Item2)
{
case HttpMethod.Get:
httpClient.Get(route.Item1, TimeSpan.FromMilliseconds(10000), x => { }, x => { throw new Exception(); });
break;
case HttpMethod.Post:
httpClient.Post(route.Item1, "abracadabra", ContentType.Json, TimeSpan.FromMilliseconds(10000), x => { }, x => { throw new Exception(); });
break;
case HttpMethod.Delete:
httpClient.Delete(route.Item1, TimeSpan.FromMilliseconds(10000), x => { }, x => { throw new Exception(); });
break;
case HttpMethod.Put:
httpClient.Put(route.Item1, "abracadabra", ContentType.Json, TimeSpan.FromMilliseconds(10000), x => { }, x => { throw new Exception(); });
break;
default:
throw new Exception();
}
}
fakeController.CountdownEvent.Wait();
sw.Stop();
Console.WriteLine("{0} request done in {1} ({2:0.00} per sec)", iterations, sw.Elapsed, 1000.0 * iterations / sw.ElapsedMilliseconds);
httpService.Shutdown();
multiQueuedHandler.Stop();
}
public GossipController(IPublisher publisher, IPublisher networkSendQueue, TimeSpan gossipTimeout, HttpMessageHandler httpMessageHandler)
: base(publisher)
{
_networkSendQueue = networkSendQueue;
_gossipTimeout = gossipTimeout;
_client = new HttpAsyncClient(_gossipTimeout, httpMessageHandler);
}
public GossipController(IPublisher publisher, IPublisher networkSendQueue, TimeSpan gossipTimeout, Func <X509Certificate, X509Chain, SslPolicyErrors, ValueTuple <bool, string> > serverCertValidator, X509Certificate clientCertificate)
: base(publisher)
{
_networkSendQueue = networkSendQueue;
_gossipTimeout = gossipTimeout;
var socketsHttpHandler = new SocketsHttpHandler {
SslOptions =
{
RemoteCertificateValidationCallback = (sender, certificate, chain, errors) => {
var(isValid, error) = serverCertValidator(certificate, chain, errors);
if (!isValid && error != null)
{
Log.Error("Server certificate validation error: {e}", error);
}
return(isValid);
},
ClientCertificates = new X509CertificateCollection()
}
};
if (clientCertificate != null)
{
socketsHttpHandler.SslOptions.ClientCertificates.Add(clientCertificate);
}
_client = new HttpAsyncClient(_gossipTimeout, socketsHttpHandler);
}
/// <summary>
/// Creates a new <see cref="IEventStoreConnection"/> to EventStore cluster
/// using specific <see cref="ConnectionSettings"/> and <see cref="ClusterSettings"/>
/// </summary>
/// <param name="connectionSettings">The <see cref="ConnectionSettings"/> to apply to the new connection</param>
/// <param name="clusterSettings">The <see cref="ClusterSettings"/> that determine cluster behavior.</param>
/// <param name="connectionName">Optional name of connection (will be generated automatically, if not provided)</param>
/// <returns>a new <see cref="IEventStoreConnection"/></returns>
public static IEventStoreConnection Create(ConnectionSettings connectionSettings,
ClusterSettings clusterSettings, string connectionName = null)
{
Ensure.NotNull(connectionSettings, "connectionSettings");
Ensure.NotNull(clusterSettings, "clusterSettings");
var handler = connectionSettings.CustomHttpMessageHandler;
if (handler is null && !connectionSettings.ValidateServer)
{
handler = new HttpClientHandler {
ServerCertificateCustomValidationCallback = delegate { return(true); }
};
}
var discoverClient = new HttpAsyncClient(connectionSettings.GossipTimeout, handler);
var endPointDiscoverer = new ClusterDnsEndPointDiscoverer(connectionSettings.Log,
clusterSettings.ClusterDns,
clusterSettings.MaxDiscoverAttempts,
clusterSettings.HttpPort,
clusterSettings.GossipSeeds,
clusterSettings.GossipTimeout,
clusterSettings.NodePreference,
CompatibilityMode.Create(connectionSettings.CompatibilityMode),
discoverClient);
return(new EventStoreNodeConnection(connectionSettings, clusterSettings, endPointDiscoverer,
connectionName));
}
public void SetUp()
{
_bus = new InMemoryBus(string.Format("bus_{0}", _serverEndPoint.Port));
_service = new HttpService(_bus, new[] { _serverEndPoint.ToHttpUrl() });
_client = new HttpAsyncClient();
HttpBootstrap.Subscribe(_bus, _service);
}
public bool Execute(CommandProcessorContext context, string[] args)
{
var eventStreamId = "test-stream";
var eventNumber = 0;
var resolveLinkTos = false;
var requireMaster = false;
if (args.Length > 0)
{
if (args.Length > 3)
{
return(false);
}
eventStreamId = args[0];
if (args.Length >= 2)
{
eventNumber = int.Parse(args[1]);
}
if (args.Length >= 3)
{
requireMaster = bool.Parse(args[2]);
}
}
context.IsAsync();
var client = new HttpAsyncClient();
var readUrl = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}/{1}?format=json", eventStreamId,
eventNumber == -1 ? "head" : eventNumber.ToString());
context.Log.Info("[{0}]: Reading...", context.Client.HttpEndpoint);
var sw = Stopwatch.StartNew();
client.Get(readUrl,
new Dictionary <string, string>
{
{ SystemHeaders.ResolveLinkTos, resolveLinkTos ? "True" : "False" },
{ SystemHeaders.RequireMaster, requireMaster ? "True" : "False" }
},
TimeSpan.FromMilliseconds(10000),
response =>
{
sw.Stop();
context.Log.Info("[{0} ({1})]: READ events from <{2}>.",
response.HttpStatusCode, response.StatusDescription, eventStreamId);
context.Log.Info("Response:\n{0}\n\n{1}\n",
string.Join("\n", response.Headers.AllKeys.Select(x => string.Format("{0,-20}: {1}", x, response.Headers[x]))),
response.Body);
context.Log.Info("Read request took: {0}.", sw.Elapsed);
context.Success();
},
e => context.Fail(e, string.Format("READ events from <{0}>: FAILED", eventStreamId)));
return(true);
}
public void Setup()
{
_fixture = new Fixture()
.Customize(new AutoMoqCustomization())
.Customize(new MultipleCustomization());
_httpService = _fixture.Freeze<Mock<IHttpService>>();
_httpCachingService = _fixture.Freeze<Mock<IHttpCachingService>>();
_baseAddress = _fixture.Create<string>();
_uri = _fixture.Create<string>();
_headers = _fixture.Create<Dictionary<string, string>>();
_sut = _fixture.Create<HttpAsyncClient>();
}
public void Setup()
{
_fixture = new Fixture()
.Customize(new AutoMoqCustomization())
.Customize(new MultipleCustomization());
_httpService = _fixture.Freeze <Mock <IHttpService> >();
_httpCachingService = _fixture.Freeze <Mock <IHttpCachingService> >();
_baseAddress = _fixture.Create <string>();
_uri = _fixture.Create <string>();
_headers = _fixture.Create <Dictionary <string, string> >();
_sut = _fixture.Create <HttpAsyncClient>();
}
public ClusterDnsEndPointDiscoverer(ILogger log,
string clusterDns,
int maxDiscoverAttempts,
int managerExternalHttpPort,
GossipSeed[] gossipSeeds,
TimeSpan gossipTimeout)
{
Ensure.NotNull(log, "log");
_log = log;
_clusterDns = clusterDns;
_maxDiscoverAttempts = maxDiscoverAttempts;
_managerExternalHttpPort = managerExternalHttpPort;
_gossipSeeds = gossipSeeds;
_gossipTimeout = gossipTimeout;
_client = new HttpAsyncClient(log);
}
public ClusterDnsEndPointDiscoverer(ILogger log,
string clusterDns,
int maxDiscoverAttempts,
int managerExternalHttpPort,
IPAddress[] fakeDnsEntries,
TimeSpan gossipTimeout)
{
Ensure.NotNull(log, "log");
Ensure.NotNullOrEmpty(clusterDns, "clusterDns");
_log = log;
_clusterDns = clusterDns;
_maxDiscoverAttempts = maxDiscoverAttempts;
_managerExternalHttpPort = managerExternalHttpPort;
_fakeDnsEntries = fakeDnsEntries;
_gossipTimeout = gossipTimeout;
_client = new HttpAsyncClient(log);
}
public void SetUp()
{
_bus = new InMemoryBus(string.Format("bus_{0}", _serverEndPoint.Port));
{
var pipelineBus = InMemoryBus.CreateTest();
var queue = new QueuedHandlerThreadPool(pipelineBus, "Test", true, TimeSpan.FromMilliseconds(50));
_multiQueuedHandler = new MultiQueuedHandler(new IQueuedHandler[] { queue }, null);
var httpAuthenticationProviders = new HttpAuthenticationProvider[] { new AnonymousHttpAuthenticationProvider() };
_service = new HttpService(ServiceAccessibility.Private, _bus, new NaiveUriRouter(),
_multiQueuedHandler, false, _serverEndPoint.ToHttpUrl());
HttpService.CreateAndSubscribePipeline(pipelineBus, httpAuthenticationProviders);
_client = new HttpAsyncClient();
}
HttpBootstrap.Subscribe(_bus, _service);
}
public ClusterDnsEndPointDiscoverer(ILogger log,
string clusterDns,
int maxDiscoverAttempts,
int managerExternalHttpPort,
GossipSeed[] gossipSeeds,
TimeSpan gossipTimeout,
bool preferRandomNode,
HttpClientHandler clientHandler = null)
{
Ensure.NotNull(log, "log");
_log = log;
_clusterDns = clusterDns;
_maxDiscoverAttempts = maxDiscoverAttempts;
_managerExternalHttpPort = managerExternalHttpPort;
_gossipSeeds = gossipSeeds;
_gossipTimeout = gossipTimeout;
_preferRandomNode = preferRandomNode;
_client = new HttpAsyncClient(_gossipTimeout, clientHandler);
}
public bool Execute(CommandProcessorContext context, string[] args)
{
var eventStreamId = "test-stream";
var version = 0;
if (args.Length > 0)
{
if (args.Length > 2)
{
return(false);
}
eventStreamId = args[0];
if (args.Length == 2)
{
version = int.Parse(args[1]);
}
}
context.IsAsync();
var client = new HttpAsyncClient();
var readUrl = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}/event/{1}", eventStreamId, version);
context.Log.Info("[{0}]: Reading...", context.Client.HttpEndpoint);
var sw = Stopwatch.StartNew();
client.Get(readUrl,
response =>
{
sw.Stop();
context.Log.Info("READ events from <{0}>: {1}", eventStreamId, response.Body);
context.Log.Info("Read request took: {0}.", sw.Elapsed);
context.Success();
},
e => context.Fail(e, string.Format("READ events from <{0}>: FAILED", eventStreamId)));
return(true);
}
public void SetUp(Action <IHttpService> bootstrap = null)
{
_bus = new InMemoryBus($"bus_{_serverEndPoint.Port}");
var pipelineBus = InMemoryBus.CreateTest();
var queue = new QueuedHandlerThreadPool(pipelineBus, "Test", new QueueStatsManager(), true, TimeSpan.FromMilliseconds(50));
_multiQueuedHandler = new MultiQueuedHandler(new IQueuedHandler[] { queue }, null);
_multiQueuedHandler.Start();
_service = new KestrelHttpService(ServiceAccessibility.Private, _bus, new NaiveUriRouter(),
_multiQueuedHandler, false, null, 0, false, _serverEndPoint);
KestrelHttpService.CreateAndSubscribePipeline(pipelineBus);
bootstrap?.Invoke(_service);
_server = new TestServer(
new WebHostBuilder()
.UseStartup(new HttpServiceStartup(_service)));
_httpMessageHandler = _server.CreateHandler();
_client = new HttpAsyncClient(_timeout, _httpMessageHandler);
HttpBootstrap.Subscribe(_bus, _service);
}
public UsersClient(ILogger log, TimeSpan operationTimeout)
{
_operationTimeout = operationTimeout;
_client = new HttpAsyncClient(_operationTimeout);
}
private void WriteFlood(CommandProcessorContext context, int clientsCnt, int requestsCnt)
{
context.IsAsync();
var threads = new List <Thread>();
var doneEvent = new ManualResetEventSlim(false);
var succ = 0;
var fail = 0;
var all = 0;
var sw = Stopwatch.StartNew();
for (int i = 0; i < clientsCnt; i++)
{
var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0);
threads.Add(new Thread(() =>
{
var autoEvent = new AutoResetEvent(false);
var eventStreamId = "es" + Guid.NewGuid();
var client = new HttpAsyncClient();
var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", eventStreamId);
Action <HttpResponse> succHandler = response =>
{
if (response.HttpStatusCode == HttpStatusCode.Created)
{
if (Interlocked.Increment(ref succ) % 1000 == 0)
{
Console.Write(".");
}
}
else
{
if (Interlocked.Increment(ref fail) % 10 == 0)
{
context.Log.Info("ANOTHER 10th WRITE FAILED. [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription);
}
}
if (Interlocked.Increment(ref all) == requestsCnt)
{
doneEvent.Set();
}
autoEvent.Set();
};
for (int j = 0; j < count; ++j)
{
var write = new[] { new HttpClientMessageDto.ClientEventText(Guid.NewGuid(),
"type",
"DATA" + new string('*', 256),
"METADATA" + new string('$', 100)) };
var request = Codec.Xml.To(write);
client.Post(url,
request,
Codec.Xml.ContentType,
TimeSpan.FromMilliseconds(10000),
succHandler,
exc =>
{
context.Log.ErrorException(exc, "Error during POST.");
Interlocked.Increment(ref fail);
if (Interlocked.Increment(ref all) == requestsCnt)
{
doneEvent.Set();
}
autoEvent.Set();
});
autoEvent.WaitOne();
}
})
{
IsBackground = true
});
}
threads.ForEach(thread => thread.Start());
doneEvent.Wait();
sw.Stop();
var reqPerSec = (all + 0.0) / sw.ElapsedMilliseconds * 1000;
context.Log.Info("Completed. Successes: {0}, failures: {1}", succ, fail);
context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).", all, sw.ElapsedMilliseconds, reqPerSec);
PerfUtils.LogData(Keyword,
PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt),
PerfUtils.Col("requestsCnt", requestsCnt),
PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)),
PerfUtils.Row(PerfUtils.Col("successes", succ), PerfUtils.Col("failures", fail)));
PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int)reqPerSec);
PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-failureSuccessRate", Keyword, clientsCnt, requestsCnt), (int)(100.0 * fail / (fail + succ)));
PerfUtils.LogTeamCityGraphData(string.Format("{0}-latency-ms", Keyword), (int)Math.Round(sw.Elapsed.TotalMilliseconds / requestsCnt));
if (succ != requestsCnt)
{
context.Fail(reason: "There were errors or not all requests completed.");
}
else
{
context.Success();
}
}
public ElectController(IPublisher publisher) : base(publisher)
{
_operationTimeout = TimeSpan.FromMilliseconds(2000); //TODO make these configurable
_client = new HttpAsyncClient(_operationTimeout);
}
private void WriteFlood(CommandProcessorContext context, string eventStreamId, int clientsCnt, long requestsCnt)
{
context.IsAsync();
var threads = new List <Thread>();
var doneEvent = new ManualResetEventSlim(false);
long all = 0;
long succ = 0;
long fail = 0;
var sw = new Stopwatch();
var sw2 = new Stopwatch();
for (int i = 0; i < clientsCnt; i++)
{
var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0);
long sent = 0;
long received = 0;
threads.Add(new Thread(() =>
{
var esId = eventStreamId ?? ("es" + Guid.NewGuid());
var client = new HttpAsyncClient();
Action onReceived = () =>
{
Interlocked.Increment(ref received);
var localAll = Interlocked.Increment(ref all);
if (localAll % 10000 == 0)
{
var elapsed = sw2.Elapsed;
sw2.Restart();
context.Log.Trace("\nDONE TOTAL {0} WRITES IN {1} ({2:0.0}/s).", localAll, elapsed, 1000.0 * 10000 / elapsed.TotalMilliseconds);
}
if (localAll == requestsCnt)
{
doneEvent.Set();
}
};
Action <HttpResponse> onSuccess = response =>
{
if (response.HttpStatusCode == HttpStatusCode.Created)
{
if (Interlocked.Increment(ref succ) % 100 == 0)
{
Console.Write('.');
}
}
else
{
var localFail = Interlocked.Increment(ref fail);
if (localFail % 100 == 0)
{
Console.Write('#');
}
if (localFail % 10 == 0)
{
context.Log.Info("ANOTHER 10th WRITE FAILED. [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription);
}
}
onReceived();
};
Action <Exception> onException = exc =>
{
context.Log.ErrorException(exc, "Error during POST.");
if (Interlocked.Increment(ref fail) % 100 == 0)
{
Console.Write('#');
}
onReceived();
};
for (int j = 0; j < count; ++j)
{
var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", esId);
var write = new[] { new HttpClientMessageDto.ClientEventText(Guid.NewGuid(),
"type",
"DATA" + new string('*', 256),
"METADATA" + new string('$', 100)) };
var requestString = Codec.Json.To(write);
client.Post(
url,
requestString,
Codec.Json.ContentType,
new Dictionary <string, string> {
},
TimeSpan.FromMilliseconds(10000),
onSuccess, onException);
var localSent = Interlocked.Increment(ref sent);
while (localSent - Interlocked.Read(ref received) > context.Client.Options.WriteWindow / clientsCnt)
{
Thread.Sleep(1);
}
}
})
{
IsBackground = true
});
}
sw.Start();
sw2.Start();
threads.ForEach(thread => thread.Start());
doneEvent.Wait();
sw.Stop();
var reqPerSec = (all + 0.0) / sw.ElapsedMilliseconds * 1000;
context.Log.Info("Completed. Successes: {0}, failures: {1}", Interlocked.Read(ref succ), Interlocked.Read(ref fail));
context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).", all, sw.ElapsedMilliseconds, reqPerSec);
PerfUtils.LogData(Keyword,
PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt),
PerfUtils.Col("requestsCnt", requestsCnt),
PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)),
PerfUtils.Row(PerfUtils.Col("successes", succ), PerfUtils.Col("failures", fail)));
PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int)reqPerSec);
PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-failureSuccessRate", Keyword, clientsCnt, requestsCnt), (int)(100.0 * fail / (fail + succ)));
if (Interlocked.Read(ref succ) != requestsCnt)
{
context.Fail(reason: "There were errors or not all requests completed.");
}
else
{
context.Success();
}
}
public ProjectionsClient(ILogger log, TimeSpan operationTimeout)
{
_operationTimeout = operationTimeout;
_client = new HttpAsyncClient(log);
}
private void WriteFlood(CommandProcessorContext context, string eventStreamId, int clientsCnt, int requestsCnt)
{
context.IsAsync();
var threads = new List <Thread>();
var autoResetEvent = new AutoResetEvent(false);
var succ = 0;
var fail = 0;
var all = 0;
var sw = Stopwatch.StartNew();
for (int i = 0; i < clientsCnt; i++)
{
var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0);
int sent = 0;
int received = 0;
threads.Add(new Thread(() =>
{
var esId = eventStreamId ?? "es" + Guid.NewGuid();
var client = new HttpAsyncClient();
Action <HttpResponse> succHandler = response =>
{
if (response.HttpStatusCode == HttpStatusCode.Created)
{
if (Interlocked.Increment(ref succ) % 100 == 0)
{
Console.Write(".");
}
}
else
{
if (Interlocked.Increment(ref fail) % 10 == 0)
{
context.Log.Info("ANOTHER 10th WRITE FAILED. [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription);
}
}
Interlocked.Increment(ref received);
if (Interlocked.Increment(ref all) == requestsCnt)
{
autoResetEvent.Set();
}
};
for (int j = 0; j < count; ++j)
{
var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", esId);
var write = new ClientMessageDto.WriteEventText(
Guid.Empty,
ExpectedVersion.Any,
new[] {
new ClientMessageDto.EventText(Guid.NewGuid(),
"type",
"DATA" + new string('*', 256),
"METADATA" + new string('$', 100))
});
var requestString = Codec.Xml.To(write);
client.Post(url, requestString, Codec.Xml.ContentType, succHandler, exc =>
{
context.Log.ErrorException(exc, "Error during POST.");
Interlocked.Increment(ref fail);
if (Interlocked.Increment(ref all) == requestsCnt)
{
autoResetEvent.Set();
}
});
Interlocked.Increment(ref sent);
while (sent - received > context.Client.Options.WriteWindow)
{
Thread.Sleep(1);
}
}
}));
}
foreach (var thread in threads)
{
thread.IsBackground = true;
thread.Start();
}
autoResetEvent.WaitOne();
sw.Stop();
context.Log.Info("Completed. Successes: {0}, failures: {1}", succ, fail);
var reqPerSec = (requestsCnt + 0.0) / sw.ElapsedMilliseconds * 1000;
context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).",
requestsCnt,
sw.ElapsedMilliseconds,
reqPerSec);
PerfUtils.LogData(
Keyword,
PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt),
PerfUtils.Col("requestsCnt", requestsCnt),
PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)),
PerfUtils.Row(PerfUtils.Col("successes", succ), PerfUtils.Col("failures", fail))
);
PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt),
(int)reqPerSec);
PerfUtils.LogTeamCityGraphData(
string.Format("{0}-{1}-{2}-failureSuccessRate", Keyword, clientsCnt, requestsCnt),
100 * fail / (fail + succ));
context.Success();
}
private void PingFlood(CommandProcessorContext context, int clientsCnt, long requestsCnt)
{
context.IsAsync();
var threads = new List <Thread>();
var doneEvent = new ManualResetEventSlim(false);
long all = 0;
long succ = 0;
long fail = 0;
for (int i = 0; i < clientsCnt; i++)
{
var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0);
long received = 0;
long sent = 0;
threads.Add(new Thread(() =>
{
var client = new HttpAsyncClient();
var url = context.Client.HttpEndpoint.ToHttpUrl("/ping");
Action <HttpResponse> onSuccess = response =>
{
Interlocked.Increment(ref received);
if (Interlocked.Increment(ref succ) % 1000 == 0)
{
Console.Write('.');
}
if (Interlocked.Increment(ref all) == requestsCnt)
{
doneEvent.Set();
}
};
Action <Exception> onException = e =>
{
context.Log.ErrorException(e, "Error during GET");
Interlocked.Increment(ref received);
if (Interlocked.Increment(ref fail) % 1000 == 0)
{
Console.Write('#');
}
if (Interlocked.Increment(ref all) == requestsCnt)
{
doneEvent.Set();
}
};
for (int j = 0; j < count; ++j)
{
client.Get(url, TimeSpan.FromMilliseconds(10000), onSuccess, onException);
var localSent = Interlocked.Increment(ref sent);
while (localSent - Interlocked.Read(ref received) > context.Client.Options.PingWindow / clientsCnt)
{
Thread.Sleep(1);
}
}
})
{
IsBackground = true
});
}
var sw = Stopwatch.StartNew();
threads.ForEach(thread => thread.Start());
doneEvent.Wait();
sw.Stop();
var reqPerSec = (all + 0.0) / sw.ElapsedMilliseconds * 1000;
context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).", all, sw.ElapsedMilliseconds, reqPerSec);
PerfUtils.LogData(Keyword,
PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt),
PerfUtils.Col("requestsCnt", requestsCnt),
PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)));
PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt), (int)reqPerSec);
if (Interlocked.Read(ref succ) == requestsCnt)
{
context.Success();
}
else
{
context.Fail();
}
}
private void PingFlood(CommandProcessorContext context, int clientsCnt, int requestsCnt)
{
context.IsAsync();
var threads = new List <Thread>();
var autoResetEvent = new AutoResetEvent(false);
var all = 0;
for (int i = 0; i < clientsCnt; i++)
{
var count = requestsCnt / clientsCnt + ((i == clientsCnt - 1) ? requestsCnt % clientsCnt : 0);
int sent = 0;
int received = 0;
threads.Add(new Thread(() =>
{
var client = new HttpAsyncClient();
var url = context.Client.HttpEndpoint.ToHttpUrl("/ping");
Action <HttpResponse> onsuccess = response =>
{
Interlocked.Increment(ref received);
var pongs = Interlocked.Increment(ref all);
if (pongs % 1000 == 0)
{
Console.Write('.');
}
if (pongs == requestsCnt)
{
autoResetEvent.Set();
}
};
Action <Exception> onException = e =>
{
context.Log.ErrorException(e, "Error during GET");
var pongs = Interlocked.Increment(ref all);
if (pongs == requestsCnt)
{
autoResetEvent.Set();
}
};
for (int j = 0; j < count; ++j)
{
client.Get(url, onsuccess, onException);
Interlocked.Increment(ref sent);
while (sent - received > context.Client.Options.PingWindow)
{
Thread.Sleep(1);
}
}
}));
}
var sw = Stopwatch.StartNew();
foreach (var thread in threads)
{
thread.IsBackground = true;
thread.Start();
}
autoResetEvent.WaitOne();
sw.Stop();
var reqPerSec = (requestsCnt + 0.0) / sw.ElapsedMilliseconds * 1000;
context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).",
requestsCnt,
sw.ElapsedMilliseconds,
reqPerSec);
PerfUtils.LogData(
Keyword,
PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt),
PerfUtils.Col("requestsCnt", requestsCnt),
PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds))
);
PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt),
(int)reqPerSec);
context.Success();
}
public bool Execute(CommandProcessorContext context, string[] args)
{
var eventStreamId = "test-stream";
var expectedVersion = ExpectedVersion.Any;
var data = "test-data";
string metadata = null;
if (args.Length > 0)
{
if (args.Length < 3 || args.Length > 4)
{
return(false);
}
eventStreamId = args[0];
expectedVersion = args[1].ToUpper() == "ANY" ? ExpectedVersion.Any : int.Parse(args[1]);
data = args[2];
if (args.Length == 4)
{
metadata = args[3];
}
}
context.IsAsync();
var client = new HttpAsyncClient();
var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", eventStreamId);
context.Log.Info("Writing to {0}...", url);
var request = Codec.Xml.To(new HttpClientMessageDto.WriteEventsText(
expectedVersion,
new[] { new HttpClientMessageDto.ClientEventText(Guid.NewGuid(), "type", data, metadata) }));
var sw = Stopwatch.StartNew();
client.Post(
url,
request,
Codec.Xml.ContentType,
response =>
{
sw.Stop();
if (response.HttpStatusCode == HttpStatusCode.Created)
{
context.Log.Info("Successfully written");
}
else
{
context.Log.Info("Error while writing: [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription);
}
context.Log.Info("Write request took: {0}.", sw.Elapsed);
context.Success();
},
e =>
{
context.Log.ErrorException(e, "Error during POST");
context.Fail(e, "Error during POST.");
});
return(true);
}
public PersistentSubscriptionsClient(ILogger log, TimeSpan operationTimeout)
{
_operationTimeout = operationTimeout;
_client = new HttpAsyncClient(_operationTimeout);
}
public ProjectionsClient(ILogger log)
{
_client = new HttpAsyncClient(log);
}
private void Flood(CommandProcessorContext context,
int clientsCnt,
int minPerSecond,
int maxPerSecond,
int runTimeMinutes)
{
context.IsAsync();
var threads = new List <Thread>();
var autoResetEvent = new AutoResetEvent(false);
var succ = 0;
var fail = 0;
var requestsCnt = 0;
var watchLockRoot = new object();
var sw = Stopwatch.StartNew();
for (int i = 0; i < clientsCnt; i++)
{
int sent = 0;
int received = 0;
threads.Add(new Thread(() =>
{
var client = new HttpAsyncClient();
Action <HttpResponse> succHandler = response =>
{
var succDone = Interlocked.Increment(ref succ);
if (succDone % maxPerSecond == 0)
{
Console.Write(".");
}
Interlocked.Increment(ref requestsCnt);
Interlocked.Increment(ref received);
};
var sentCount = 0;
var sleepTime = 0;
var currentMinute = -1;
while (true)
{
TimeSpan elapsed;
lock (watchLockRoot)
elapsed = sw.Elapsed;
if (elapsed.TotalMinutes > runTimeMinutes)
{
autoResetEvent.Set();
break;
}
if (sentCount == 0)
{
int elapsedMinutesInt = (int)elapsed.TotalMinutes;
lock (_randomLockRoot)
{
sentCount = minPerSecond == maxPerSecond
? maxPerSecond
: _random.Next(minPerSecond, maxPerSecond);
}
if (currentMinute != elapsedMinutesInt)
{
currentMinute = elapsedMinutesInt;
context.Log.Info(Environment.NewLine + "Elapsed {0} of {1} minutes, sent {2}",
elapsedMinutesInt,
runTimeMinutes,
sent);
}
sleepTime = 1000 / sentCount;
}
var url = context.Client.HttpEndpoint.ToHttpUrl("/ping");
client.Get(url,
succHandler,
exc => context.Log.ErrorException(exc, "Error during GET."));
Interlocked.Increment(ref sent);
Thread.Sleep(sleepTime);
sentCount -= 1;
while (sent - received > context.Client.Options.PingWindow)
{
Thread.Sleep(1);
}
}
}));
}
foreach (var thread in threads)
{
thread.IsBackground = true;
thread.Start();
}
autoResetEvent.WaitOne();
sw.Stop();
context.Log.Info("Completed. Successes: {0}, failures: {1}", succ, fail);
var reqPerSec = (requestsCnt + 0.0) / sw.ElapsedMilliseconds * 1000;
context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).",
requestsCnt,
sw.ElapsedMilliseconds,
reqPerSec);
PerfUtils.LogData(
Keyword,
PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt),
PerfUtils.Col("requestsCnt", requestsCnt),
PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)),
PerfUtils.Row(PerfUtils.Col("successes", succ), PerfUtils.Col("failures", fail))
);
PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-reqPerSec", Keyword, clientsCnt, requestsCnt),
(int)reqPerSec);
PerfUtils.LogTeamCityGraphData(
string.Format("{0}-{1}-{2}-failureSuccessRate", Keyword, clientsCnt, requestsCnt),
(int)((fail / (succ + 0.0)) * 100));
context.Success();
}
public PersistentSubscriptionsClient(ILogger log, TimeSpan operationTimeout, HttpMessageHandler httpMessageHandler = null)
{
_operationTimeout = operationTimeout;
_client = new HttpAsyncClient(_operationTimeout, httpMessageHandler);
}
private void Flood(CommandProcessorContext context,
string eventStreamId,
int clientsCnt,
int minPerSecond,
int maxPerSecond,
int runTimeMinutes,
int dataSize)
{
context.IsAsync();
var threads = new List <Thread>();
var doneEvent = new ManualResetEvent(false);
var succ = 0;
var fail = 0;
var requestsCnt = 0;
int sent = 0;
int received = 0;
var watchLockRoot = new object();
var sw = Stopwatch.StartNew();
for (int i = 0; i < clientsCnt; i++)
{
threads.Add(new Thread(() =>
{
var esId = eventStreamId ?? "Stream-" + Thread.CurrentThread.ManagedThreadId % 3;
var client = new HttpAsyncClient();
Action <HttpResponse> succHandler = response =>
{
if (response.HttpStatusCode == HttpStatusCode.Created)
{
var succDone = Interlocked.Increment(ref succ);
if (succDone % maxPerSecond == 0)
{
Console.Write(".");
}
}
else
{
if (Interlocked.Increment(ref fail) % 10 == 0)
{
context.Log.Info("ANOTHER 10th WRITE FAILED. [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription);
}
}
Interlocked.Increment(ref requestsCnt);
Interlocked.Increment(ref received);
};
var sentCount = 0;
var sleepTime = 0;
var dataSizeCoefficient = 1;
var currentMinute = -1;
while (true)
{
TimeSpan elapsed;
lock (watchLockRoot)
elapsed = sw.Elapsed;
if (elapsed.TotalMinutes > runTimeMinutes)
{
doneEvent.Set();
break;
}
if (sentCount == 0)
{
int elapsedMinutesInt = (int)elapsed.TotalMinutes;
lock (_randomLockRoot)
{
sentCount = minPerSecond == maxPerSecond
? maxPerSecond : _random.Next(minPerSecond, maxPerSecond);
dataSizeCoefficient = _random.Next(8, 256);
}
if (currentMinute != elapsedMinutesInt)
{
currentMinute = elapsedMinutesInt;
context.Log.Info("\nElapsed {0} of {1} minutes, sent {2}; next block coef. {3}",
elapsedMinutesInt,
runTimeMinutes,
sent,
dataSizeCoefficient);
}
sleepTime = 1000 / sentCount;
}
var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", esId);
var dataResultingSize = dataSizeCoefficient * dataSize;
var write = new[] { new HttpClientMessageDto.ClientEventText(Guid.NewGuid(),
"type",
"DATA" + dataResultingSize.ToString(" 00000 ") + new string('*', dataResultingSize),
"METADATA" + new string('$', 100)) };
var request = Codec.Xml.To(write);
client.Post(url,
request,
Codec.Xml.ContentType,
TimeSpan.FromMilliseconds(10000),
succHandler,
exc =>
{
Interlocked.Increment(ref fail);
Interlocked.Increment(ref requestsCnt);
context.Log.ErrorException(exc, "Error during POST.");
});
Interlocked.Increment(ref sent);
Thread.Sleep(sleepTime);
sentCount -= 1;
while (sent - received > context.Client.Options.WriteWindow / clientsCnt)
{
Thread.Sleep(1);
}
}
}));
}
foreach (var thread in threads)
{
thread.IsBackground = true;
thread.Start();
}
doneEvent.WaitOne();
sw.Stop();
context.Log.Info("Completed. Successes: {0}, failures: {1}", succ, fail);
var reqPerSec = (requestsCnt + 0.0) / sw.ElapsedMilliseconds * 1000;
context.Log.Info("{0} requests completed in {1}ms ({2:0.00} reqs per sec).",
requestsCnt,
sw.ElapsedMilliseconds,
reqPerSec);
PerfUtils.LogData(
Keyword,
PerfUtils.Row(PerfUtils.Col("clientsCnt", clientsCnt),
PerfUtils.Col("requestsCnt", requestsCnt),
PerfUtils.Col("ElapsedMilliseconds", sw.ElapsedMilliseconds)),
PerfUtils.Row(PerfUtils.Col("successes", succ), PerfUtils.Col("failures", fail))
);
PerfUtils.LogTeamCityGraphData(string.Format("{0}-{1}-{2}-{3}-{4}-reqPerSec",
Keyword,
clientsCnt,
minPerSecond,
maxPerSecond,
runTimeMinutes),
(int)reqPerSec);
PerfUtils.LogTeamCityGraphData(
string.Format("{0}-{1}-{2}-failureSuccessRate", Keyword, clientsCnt, requestsCnt),
100 * fail / (fail + succ));
context.Success();
}
public bool Execute(CommandProcessorContext context, string[] args)
{
var eventStreamId = "test-stream";
var expectedVersion = ExpectedVersion.Any;
string metadata = "{'user' : 'test'}";
var requireMaster = false;
var data = "{'a' : 3 }";
if (args.Length > 0)
{
if (args.Length != 5)
{
return(false);
}
eventStreamId = args[0];
expectedVersion = args[1].ToUpper() == "ANY" ? ExpectedVersion.Any : int.Parse(args[1]);
data = args[2];
metadata = args[3];
requireMaster = bool.Parse(args[4]);
}
context.IsAsync();
var client = new HttpAsyncClient();
var url = context.Client.HttpEndpoint.ToHttpUrl("/streams/{0}", eventStreamId);
context.Log.Info("Writing to {0}...", url);
var msg = "[{'eventType': 'fooevent', 'eventId' : '" + Guid.NewGuid() + "'" + ",'data' : " + data + ", 'metadata' : " + metadata + "}]";
var sw = Stopwatch.StartNew();
client.Post(
url,
msg,
Codec.Json.ContentType,
new Dictionary <string, string>
{
{ SystemHeaders.ExpectedVersion, expectedVersion.ToString() },
{ SystemHeaders.RequireMaster, requireMaster ? "True" : "False" }
},
TimeSpan.FromMilliseconds(10000),
response =>
{
sw.Stop();
if (response.HttpStatusCode == HttpStatusCode.Created)
{
context.Log.Info("Successfully written");
}
else
{
context.Log.Info("Error while writing: [{0}] - [{1}]", response.HttpStatusCode, response.StatusDescription);
context.Log.Info("Response:\n{0}\n\n{1}\n",
string.Join("\n", response.Headers.AllKeys.Select(x => string.Format("{0,-20}: {1}", x, response.Headers[x]))),
response.Body);
}
context.Log.Info("Write request took: {0}.", sw.Elapsed);
context.Success();
},
e =>
{
context.Log.ErrorException(e, "Error during POST");
context.Fail(e, "Error during POST.");
});
return(true);
}
