public IList <IRestRequest> ParseRequests(LoadTestScenario scenario)
{
IEnumerable <IRestRequest> requests = MapRequests(scenario);
IList <IRestRequest> result = requests.ToList();
return(result);
}
public long RunScenario(Scenario model)
{
log.Debug(Debugging.HatcheryService_Invoked);
var scenarioExecution = new ScenarioExecution
{
ScenarioId = model.Id,
Started = DateTime.UtcNow,
Status = ExecutionStatus.Created
};
executionRepository.Add(scenarioExecution);
LoadTestScenario scenario = Load(model);
scenario.ExecutionId = scenarioExecution.Id;
using (var wcf = GetWcfConnectionToDrone())
{
log.Debug(Debugging.HatcheryService_Request);
wcf.Channel.StartLoadTest(scenario);
log.Debug(Debugging.HatcheryService_Response);
}
return(scenarioExecution.Id);
}
private LoadTestScenario Load(Scenario model)
{
LoadTestScenario scenario = mapper.Map <Scenario, LoadTestScenario>(model);
FileUpload file = fileService.GetUploadsByCode(model.FileCode);
string path = fileService.GetFullPath(file);
scenario.Data = ReadData(path);
return(scenario);
}
public IRestClient GetClient(LoadTestScenario scenario)
{
IRestClient client = new RestClient
{
BaseUrl = GetBaseUrl(scenario.Endpoint),
Timeout = GetTimeout(scenario.RequestTimeout)
};
return(client);
}
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);
}
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);
}
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 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 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);
}
}
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;
}
}
