private async Task RunAsync(Parameters parameters)
{
var secrets = SecretConfiguration.Load(parameters.SecretSource);
var channel = await Channels.CreateSendChannel(parameters.ClusterId, secrets);
_logger.LogInformation($"Waiting {parameters.Wait} seconds before starting...");
await Task.Delay(TimeSpan.FromSeconds(parameters.Wait));
for (var i = 0; i < parameters.Rounds; i++)
{
_logger.LogInformation($"Round #{i + 1}: sending {parameters.ServersPerRound} orders [Restart: {parameters.Restart}, Graceful: {parameters.Graceful}]");
var responses = await channel.SendMessages(
GetMessages(),
new CancellationTokenSource(TimeSpan.FromSeconds(parameters.RoundDelay)).Token);
_logger.LogInformation($"Round #{i + 1}: silos {string.Join(",", responses.Select(r => r.ServerName))} acked");
_logger.LogInformation($"Round #{i + 1}: waiting {parameters.RoundDelay}");
await Task.Delay(TimeSpan.FromSeconds(parameters.RoundDelay));
}
List <ServerMessage> GetMessages()
{
var msgs = new List <ServerMessage>();
for (var i = 0; i < parameters.ServersPerRound; i++)
{
msgs.Add(new ServerMessage(parameters.Graceful, parameters.Restart));
}
return(msgs);
}
}
public static async Task <ISendChannel> CreateSendChannel(string clusterId, SecretConfiguration configuration)
{
var writeQueue = new QueueClient(configuration.ClusteringConnectionString, string.Format(CLIENT_TO_SERVER_QUEUE, clusterId));
var readQueue = new QueueClient(configuration.ClusteringConnectionString, string.Format(SILO_TO_CLIENT_QUEUE, clusterId));
await writeQueue.CreateIfNotExistsAsync();
await readQueue.CreateIfNotExistsAsync();
return(new SendChannel(writeQueue, readQueue));
}
public async Task <string> SaveConfigurationAsync(SecretConfiguration config, CancellationToken token)
{
if (null == config)
{
throw new ArgumentNullException(nameof(config));
}
if (null == config.Policy)
{
throw new ArgumentNullException(nameof(config.Policy));
}
return(await OnSaveConfigurationAsync(config, token));
}
protected async override Task <string> OnSaveConfigurationAsync(SecretConfiguration config, CancellationToken token)
{
Contracts.Config sc = Contracts.Config.FromSecretConfiguration(config);
if (Guid.Empty == sc.ConfigurationId)
{
sc.ConfigurationId = Guid.NewGuid();
}
await SaveObjectAsync(_rootContainer, FormatFileName(StorageFolders.Config, sc.ConfigurationId.ToString()), GetObjectJson <Contracts.Config>(sc), token);
return(sc.ConfigurationId.ToString());
}
public async Task Run(ClientParameters clientParams, LoadGeneratorParameters loadParams)
{
var secrets = SecretConfiguration.Load(clientParams.SecretSource);
var hostBuilder = new HostBuilder().UseOrleansClient((ctx, builder) =>
builder.Configure <ClusterOptions>(options => { options.ClusterId = clientParams.ClusterId; options.ServiceId = clientParams.ServiceId; })
.Configure <ConnectionOptions>(options => clientParams.ConnectionsPerEndpoint = 2)
.UseAzureStorageClustering(options => options.ConfigureTableServiceClient(secrets.ClusteringConnectionString)));
using var host = hostBuilder.Build();
_logger.LogInformation("Connecting to cluster...");
await host.StartAsync();
var client = host.Services.GetService <IClusterClient>();
var generator = new ConcurrentLoadGenerator <T>(
numWorkers: loadParams.NumWorkers,
blocksPerWorker: loadParams.BlocksPerWorker != 0 ? loadParams.BlocksPerWorker : int.MaxValue,
requestsPerBlock: loadParams.RequestsPerBlock,
issueRequest: _scenario.IssueRequest,
getStateForWorker: workerId => _scenario.GetStateForWorker(client, workerId),
logger: _logger,
logIntermediateResults: true);
_logger.LogInformation("Warming-up...");
await generator.Warmup();
var cts = loadParams.Duration != 0
? new CancellationTokenSource(TimeSpan.FromSeconds(loadParams.Duration))
: new CancellationTokenSource();
_logger.LogInformation("Running");
var report = await generator.Run(cts.Token);
// Register the measurements. n0 -> format as natural number
BenchmarksEventSource.Register("requests", Operations.First, Operations.Sum, "Requests", "Number of requests completed", "n0");
BenchmarksEventSource.Register("failures", Operations.First, Operations.Sum, "Failures", "Number of failures", "n0");
BenchmarksEventSource.Register("rps", Operations.First, Operations.Sum, "Rate per second", "Rate per seconds", "n0");
// Register the measurement values
BenchmarksEventSource.Measure("requests", report.Completed);
BenchmarksEventSource.Measure("failures", report.Failures);
BenchmarksEventSource.Measure("rps", report.RatePerSecond);
await host.StopAsync();
}
private async Task RunAsync(Parameters parameters)
{
_logger.LogInformation("Connecting to cluster...");
var secrets = SecretConfiguration.Load(parameters.SecretSource);
var hostBuilder = new HostBuilder()
.UseOrleansClient(builder => {
builder
.Configure <ClusterOptions>(options => { options.ClusterId = parameters.ClusterId; options.ServiceId = parameters.ServiceId; })
.UseAzureStorageClustering(options => options.ConfigureTableServiceClient(secrets.ClusteringConnectionString));
});
using var host = hostBuilder.Build();
await host.StartAsync();
var client = host.Services.GetService <IClusterClient>();
var counterGrain = client.GetGrain <ICounterGrain>(parameters.CounterKey);
var duration = await counterGrain.GetRunDuration();
BenchmarksEventSource.Register("duration", Operations.First, Operations.Last, "duration", "duration", "n0");
BenchmarksEventSource.Measure("duration", duration.TotalSeconds);
var initialWait = await counterGrain.WaitTimeForReport();
_logger.LogInformation($"Counters should be ready in {initialWait}");
await Task.Delay(initialWait);
_logger.LogInformation($"Counters ready");
foreach (var counter in parameters.Counters)
{
var value = await counterGrain.GetTotalCounterValue(counter);
_logger.LogInformation($"{counter}: {value}");
BenchmarksEventSource.Register(counter, Operations.First, Operations.Sum, counter, counter, "n0");
BenchmarksEventSource.Measure(counter, value);
if (string.Equals(counter, "requests", StringComparison.InvariantCultureIgnoreCase))
{
var rps = (float)value / duration.TotalSeconds;
BenchmarksEventSource.Register("rps", Operations.First, Operations.Last, "rps", "Requests per second", "n0");
BenchmarksEventSource.Measure("rps", rps);
}
}
await host.StopAsync();
}
public Task SendAsync(IdentityMessage message)
{
// Plug in your email service here to send an email.
SmtpClient client = new SmtpClient("in-v3.mailjet.com");
client.Port = 587;
client.EnableSsl = true;
//If you need to authenticate
client.Credentials = new NetworkCredential(SecretConfiguration.Get("mailjet:appid"), SecretConfiguration.Get("mailjet:appsecret"));
MailMessage messagetosend = new MailMessage("*****@*****.**", message.Destination, message.Subject, message.Body);
messagetosend.IsBodyHtml = true;
//return Task.Delay(1500);
return(client.SendMailAsync(messagetosend));
}
public async Task <DirectionObject> GetDirections(string userAdress, string eventAddress, string unit, DirectionModes md1)
{
string apkey = SecretConfiguration.Get("google.direction.api");
HttpClient httpcli = new HttpClient();
var start = truncateaddress(userAdress);
var end = truncateaddress(eventAddress);
var request =
$@"https://maps.googleapis.com/maps/api/directions/json?origin=" + start + "&destination=" + end + $"&mode={md1}&units={unit}&key={apkey}";
var result = await httpcli.GetStringAsync(request);
var objResult = JsonConvert.DeserializeObject <DirectionObject>(result);
return(objResult);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IApplicationLifetime appLifetime, IOptions <SecretConfiguration> settings)
{
loggerFactory.AddSerilog();
Log.Logger.Information("Configuring http request pipeline: {environment}", new { EnvironmentName = env.EnvironmentName, ApplicationName = env.ApplicationName });
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseCors("default");
SecretConfiguration secretConfiguration = settings.Value;
app.UseJwtBearerAuthentication(new JwtBearerOptions()
{
Audience = secretConfiguration.Audience,
Authority = $"https://{secretConfiguration.ClientDomain}/",
});
app.UseMiddleware <HttpErrorHandleMiddleware>();
app.UseMvc();
app.UseSwagger(swaggerOptions =>
{
swaggerOptions.RouteTemplate = "docs/swagger/{documentName}/swagger.json";
});
app.UseSwaggerUI(swaggerUiOptions =>
{
swaggerUiOptions.RoutePrefix = "docs";
swaggerUiOptions.SwaggerEndpoint("swagger/v1/swagger.json", "Canonn API v1");
swaggerUiOptions.ConfigureOAuth2(secretConfiguration.ClientId, secretConfiguration.ClientSecret,
secretConfiguration.ClientDomain, "Canonn API",
additionalQueryStringParameters: new { audience = secretConfiguration.Audience });
});
// Ensure any buffered events are sent at shutdown
appLifetime.ApplicationStopped.Register(Log.CloseAndFlush);
// Ensure container and dependencies are cleaned up accordingly
appLifetime.ApplicationStopped.Register(ApplicationContainer.Dispose);
}
protected async override Task <SecretConfiguration> OnGetSecretConfigurationAsync(string configId, CancellationToken token)
{
string json = await GetObjectAsync(_rootContainer, FormatFileName(StorageFolders.Config, configId), token);
if (string.IsNullOrWhiteSpace(json))
{
return(null);
}
var cfg = Newtonsoft.Json.JsonConvert.DeserializeObject <Contracts.Config>(json);
SecretConfiguration result = null;
if (null != cfg)
{
result = cfg.ToSecretConfiguration();
if (result.Policy.PolicyId != Guid.Empty)
{
result.Policy = await GetPolicyAsync(result.Policy.PolicyId.ToString(), token);
}
}
return(result);
}
public void TestDurationRoutesApi()
{
//string startAdress = "14 rue godefroy 69006 Lyon";
string startAdress = "69006 Lyon";
string endAddress = "La triche 69001 Lyon";
var ulrRequest = $@"https://maps.googleapis.com/maps/api/directions/json?origin={startAdress.Replace(" ", "+")}&destination={endAddress.Replace(" ", "+")}&mode=driving&units=metric&key={SecretConfiguration.Get("google.direction.api")}";
HttpClient httpcli = new HttpClient();
var result = httpcli.GetStringAsync(ulrRequest).Result;
var objResult = JsonConvert.DeserializeObject <DirectionObject>(result);
}
public void TestMethod1()
{
var result = SecretConfiguration.Get("fake:apclient");
Assert.AreEqual("668478945646", result);
}
protected abstract Task <string> OnSaveConfigurationAsync(SecretConfiguration config, CancellationToken token);
public CheckController(IOptions <SecretConfiguration> options, IRepository repo)
{
_keys = options.Value;
_repo = repo;
}
/// <summary>
/// Initializes a new instance of the <see cref="ClientConfigurationController"/>
/// </summary>
/// <param name="settings">The configuration settings to provide</param>
public ClientConfigurationController(IOptions <SecretConfiguration> settings)
{
_settings = settings?.Value ?? throw new ArgumentNullException(nameof(settings));
}
