public IRestClient GetClient(LoadTestScenario scenario)
{
IRestClient client = new RestClient
{
BaseUrl = GetBaseUrl(scenario.Endpoint),
Timeout = GetTimeout(scenario.RequestTimeout)
};
return client;
}
public void StartLoadTest(LoadTestScenario scenario)
{
if (scenario == null)
{
throw new ArgumentNullException("scenario");
}
if (factories.ContainsKey(scenario.ExecutionId))
{
string message = Fault.DroneService_AlreadyInvokedExecutionId.FormatWith(scenario.ExecutionId);
throw new ArgumentException(message);
}
log.Debug(Debugging.DroneService_Received);
var context = contextFactory(scenario.ExecutionId);
factories.TryAdd(scenario.ExecutionId, context);
Task.Factory.StartNew(() => StartLoadTestAsync(scenario, context), context.Token); // completely async.
log.Debug(Debugging.DroneService_Returned);
}
private IEnumerable<IRestRequest> MapRequests(LoadTestScenario scenario)
{
string[][] data = scenario.Data;
var rows = data.Skip(1);
log.Debug(Debugging.DroneService_MappingHeader);
Header[] headers = data.Select(d => MapHeaders(d, scenario.Endpoint)).First().ToArray();
log.Debug(Debugging.DroneService_Mapping.FormatWith(data.Length - 1));
string resource = GetRelativeUrl(scenario.Endpoint);
foreach (string[] row in rows)
{
IRestRequest request = new RestRequest(resource, scenario.Method);
for (int i = 0; i < headers.Length; i++)
{
if (headers[i].Name.InsensitiveEquals(HttpVerbColumn))
{
Method method;
if (Enum.TryParse(row[i], true, out method))
{
request.Method = method; // override.
}
}
else
{
var parameter = new Parameter
{
Name = headers[i].Name,
Type = headers[i].Type,
Value = row[i]
};
request.AddParameter(parameter);
}
}
yield return request;
}
}
public IList<IRestRequest> ParseRequests(LoadTestScenario scenario)
{
IEnumerable<IRestRequest> requests = MapRequests(scenario);
IList<IRestRequest> result = requests.ToList();
return result;
}
private void Synchronize(LoadTestScenario scenario, FactoryContext context)
{
if (!scenario.StartDate.HasValue)
{
log.Debug(Debugging.DroneService_NoSleep);
return;
}
DateTime now = DateTime.UtcNow;
var remaining = scenario.StartDate.Value - now;
if (remaining > TimeSpan.Zero)
{
log.Debug(Debugging.DroneService_Idle.FormatWith(remaining.TotalSeconds));
context.Status = ExecutionStatus.Synchronizing;
Thread.Sleep(remaining);
log.Debug(Debugging.DroneService_Resumed);
}
}
private void StartLoadTestAsync(LoadTestScenario scenario, FactoryContext context)
{
IRequestFactory factory = null;
try
{
RequestCommand command = PrepareCommand(scenario, context);
Synchronize(scenario, context); // await for a configurable period of time.
if (context.Aborted)
{
return; // sanity.
}
context.Status = ExecutionStatus.Executing;
factory = new ProfiledVirtualUserNetwork(command);
context.RequestFactory = factory;
factory.Execute();
if (!context.Aborted) //
{
context.Status = ExecutionStatus.Completed;
}
}
catch (Exception fault)
{
if (factory != null)
{
factory.Abort(); // kill pending requests.
}
log.Error(Fault.DroneService_Faulted.FormatWith(fault.Message), fault);
context.Status = ExecutionStatus.Faulted;
}
finally
{
context.RequestFactory = null;
}
}
private RequestCommand PrepareCommand(LoadTestScenario scenario, FactoryContext context)
{
context.Status = ExecutionStatus.Preparing; // acknowledge.
var command = new RequestCommand
{
ExecutionId = scenario.ExecutionId,
Client = requestService.GetClient(scenario),
Requests = requestService.ParseRequests(scenario),
Users = scenario.Users,
Reporting = GetReportObject(scenario)
};
return command;
}
private IReport GetReportObject(LoadTestScenario scenario)
{
if (!scenario.SamplingInterval.HasValue)
{
return Report.Null;
}
Action<DroneSnapshotDto> send = dto =>
{
mvcClient.Request(Config.Wcf.OvermindApi.PostSnapshot, dto);
};
IReport report = new IntervalReport(send, scenario.SamplingInterval.Value);
return report;
}
