void IAggregator.End()
{
_timer.Stop();
_backgroundWorker1.CancelAsync();
TestEndedEnableButtons();
}
public void Stop()
{
_pool?.StopAndDispose((int)_settings.FinishTimeout.TotalMilliseconds);
_pool = null;
_timer.Stop();
_aggregator.End();
_errorHandler.Assert();
}
// TODO: Redesign validator so it uses actual handlers.
/// <summary>
/// Validates ILoadTest scenario correctness by executing single test iteration
/// from ScenarioSetup to ScenarioTearDown on the same thread.
/// Exceptions are not handled on purpose to ease problem identification while developing.
/// </summary>
/// <param name="scenario">ILoadTestScenario object</param>
/// <param name="threadId">TheardId to set in TestContext</param>
/// <param name="threadIterationId">ThreadIterationId to set in TestContext</param>
/// <param name="globalIterationId">GlobalIterationId to set in TestContext</param>
/// <returns>Raw result from single iteration</returns>
public static IterationResult Validate(this IScenario scenario, int threadId = 0, int threadIterationId = 0, int globalIterationId = 0)
{
ExecutionTimer timer = new ExecutionTimer();
ThreadSafeCounter errorsCounter = new ThreadSafeCounter();
GlobalCounters globalCounters = new GlobalCounters(errorsCounter, new MockedIdGenerator(globalIterationId));
IIterationControl context = new IterationContext(threadId, timer);
ScenarioHandler handler = new ScenarioHandler(globalCounters, new MockedIdGenerator(threadIterationId), scenario, context);
timer.Start();
handler.Init();
handler.PrepareNext();
handler.Execute();
IterationResult result = new IterationResult(context, new WorkerThreadStats());
handler.Cleanup();
timer.Stop();
return(result);
}
public static IterationResult Validate <TData>(this IReplayScenario <TData> scenario, DataItem data, int threadId = 0, int threadIterationId = 0, int globalIterationId = 0)
{
ExecutionTimer timer = new ExecutionTimer();
ThreadSafeCounter errorsCounter = new ThreadSafeCounter();
GlobalCounters globalCounters = new GlobalCounters(errorsCounter, new MockedIdGenerator(globalIterationId));
IIterationControl context = new IterationContext(threadId, timer);
ReplayScenarioHandler <TData> handler = new ReplayScenarioHandler <TData>(globalCounters, new MockedIdGenerator(threadIterationId), scenario, context);
timer.Start();
handler.Init();
handler.PrepareNext();
handler.SetData(data.Value, data.TimeStamp);
handler.Execute();
IterationResult result = new IterationResult(context, new WorkerThreadStats());
handler.Cleanup();
timer.Stop();
return(result);
}
public virtual void Stop()
{
var timerResult = ExecutionTimer.Stop(Offset);
MessageBroker.Publish(Message.AsTimedMessage(timerResult));
}
/// <summary>
/// Execute a select statement and return the results
/// @TODO: Clean up console writelines
/// </summary>
/// <param name="query"></param>
/// <param name="bindings"></param>
/// <returns></returns>
public ResultSet Select(string query, BindingsDict bindings)
{
IDbCommand cmd = PrepareCommand(query, bindings);
ResultSet results = new ResultSet();
try
{
if (_useTimer)
{
_execTimer.Start();
}
IDataReader dataReader = cmd.ExecuteReader();
Console.WriteLine("\nReading dataresult\n----------------------------");
while (dataReader.Read())
{
Row row = new Row();
for (int i = 0; i < dataReader.FieldCount; i++)
{
// Add this column to the current result row
Column newCol = new Column(dataReader.GetName(i), dataReader[i], dataReader[i].GetSqlValueType());
row.Add(newCol);
Console.WriteLine("[{0}]: '{1}'", dataReader.GetName(i), dataReader[i].ToString());
}
// Add the row to our final result set
results.Add(row);
}
#region Debug - Write out command text
// Print out all the parameters we added to the Command object
Console.WriteLine("\nUsing:\n[CommandText]: '{0}'", cmd.CommandText);
foreach (IDbDataParameter param in cmd.Parameters)
{
Console.WriteLine("[" + param.DbType.ToString() + "] Name: '" + param.ParameterName + "', Value: " + param.Value.ToString());
}
Console.WriteLine("-");
#endregion
dataReader.Close();
if (_useTimer)
{
_execTimer.Stop();
}
}
catch (Exception ex)
{
if (_useTimer)
{
_execTimer.Stop();
}
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
throw new DBException("Failed to execute reader on Select query!", ex);
}
return(results);
}
private void RunInner()
{
if (_threadCoordinator != null)
{
throw new InvalidOperationException("Async instance is already running");
}
try
{
_threadCoordinator = new ThreadCoordinator(
_iTestScenarioObjectType,
_timer,
_parameters.ThreadingStrategy.InitialThreadCount
)
{
InitialUserData = _parameters.InitialUserData
};
_threadCoordinator.ScenarioIterationFinished += _threadCoordinator_ScenarioIterationFinished;
int testIterationCount = 0;
TimeSpan executionEnqueueThreshold = TimeSpan.Zero;
_timer.Start();
_resultsAggregator.Begin();
while (_timer.CurrentValue < _parameters.Limits.MaxDuration && testIterationCount < _parameters.Limits.MaxIterationsCount)
{
WorkerThreadStats threadStats = _threadCoordinator.BuildWorkerThreadStats();
int allowedWorkingthreadCount = _parameters.ThreadingStrategy.GetAllowedMaxWorkingThreadCount(_timer.CurrentValue, threadStats);
_threadCoordinator.AssertThreadErrors();
TryAdjustCreatedThreadCount(threadStats);
if (allowedWorkingthreadCount > threadStats.WorkingThreadCount && _timer.CurrentValue >= executionEnqueueThreshold)
{
if (_threadCoordinator.TryEnqueueSingleIteration())
{
executionEnqueueThreshold = CalculateNextExecutionTime(executionEnqueueThreshold);
testIterationCount++;
}
else
{
Thread.Sleep(1);
}
}
else
{
Thread.Sleep(1);
}
//_timer.UpdateCurrent();
}
}
finally
{
_threadCoordinator?.StopAndDispose((int)_parameters.Limits.FinishTimeout.TotalMilliseconds);
_resultsAggregator.End();
_threadCoordinator?.AssertThreadErrors();
_threadCoordinator = null;
_timer.Stop();
}
}
