public SetPaceBasedEngine(LoadTesterMetadataDetail metadataDetail)
: base(VirtualResourceType.LoadTester, metadataDetail, null)
{
var plan = metadataDetail.Plan as LoadTesterExecutionPlan;
_pace = TimeSpan.FromSeconds(plan.MinActivityDelay);
_expiration = TimeSpan.FromMinutes(plan.DurationTime);
}
public DurationBasedEngine(LoadTesterMetadataDetail metadataDetail)
: base(VirtualResourceType.LoadTester, metadataDetail, null)
{
var plan = metadataDetail.Plan as LoadTesterExecutionPlan;
_delay = new ActivityDelay(plan);
_expiration = TimeSpan.FromMinutes(plan.DurationTime > 0 ? plan.DurationTime : 0);
}
public RateBasedEngine(LoadTesterMetadataDetail metadataDetail)
: base(VirtualResourceType.LoadTester, metadataDetail, null)
{
var plan = metadataDetail.Plan as LoadTesterExecutionPlan;
RandomizeActivities = false;
_duration = plan.DurationTime;
_repeatCount = plan.RepeatCount;
_activityCount = 1;
}
private void StartWithRateBasedRampUp(LoadTesterMetadataDetail metadataDetail)
{
var plan = metadataDetail.Plan as LoadTesterExecutionPlan;
foreach (var setting in plan.RampUpSettings)
{
TraceFactory.Logger.Debug("{0} threads will start after: {1} secs".FormatWith(setting.ThreadCount, setting.Delay.TotalSeconds));
for (int i = 0; i < setting.ThreadCount; i++)
{
_threads.Add(new LoadTestThread(metadataDetail, setting.Delay));
}
}
Task.Factory.StartNew(ExecuteTasks);
}
/// <summary>
/// Initializes a new instance of the <see cref="EngineBase"/> class.
/// </summary>
/// <param name="resourceType">Type of the resource.</param>
/// <param name="metadataDetail">The detail.</param>
/// <param name="workerDetail"></param>
protected EngineBase(VirtualResourceType resourceType, LoadTesterMetadataDetail metadataDetail, OfficeWorkerDetail workerDetail)
{
if (metadataDetail == null)
{
throw new ArgumentNullException("metadataDetail");
}
if (!metadataDetail.Enabled)
{
throw new ArgumentException("MetadataDetail is not enabled", "metadataDetail");
}
ExecutionHalted = false;
ActivityQueue = new OfficeWorkerActivityQueue(new Collection <ResourceMetadataDetail>()
{
metadataDetail
}, OnActivityStateChanged, workerDetail);
}
private void StartWithTimeBasedRampUp(LoadTesterMetadataDetail metadataDetail)
{
var plan = metadataDetail.Plan as LoadTesterExecutionPlan;
plan.Mode = ExecutionMode.Duration;
// Iterate over the total thread count, but select a unique delay value for each thread.
for (int i = 0; i < plan.ThreadCount; i++)
{
TimeSpan minDelay = TimeSpan.FromSeconds(plan.MinRampUpDelay);
TimeSpan maxDelay = TimeSpan.FromSeconds(plan.MaxRampUpDelay);
var rampDelay = plan.RandomizeRampUpDelay ? TimeSpanUtil.GetRandom(minDelay, maxDelay) : minDelay;
TraceFactory.Logger.Debug("Delay: {0}".FormatWith(rampDelay.TotalSeconds));
_threads.Add(new LoadTestThread(metadataDetail, rampDelay));
}
Task.Factory.StartNew(ExecuteTasks);
}
private void CreateMetadataDetail(VirtualResource resource, ResourceDetailBase detail)
{
foreach (var data in resource.VirtualResourceMetadataSet.Where(m => m.Enabled))
{
LoadTesterMetadataDetail metadata = new LoadTesterMetadataDetail()
{
MetadataType = data.MetadataType,
Data = data.Metadata,
Plan = data.ExecutionPlan != null
? LegacySerializer.DeserializeDataContract <LoadTesterExecutionPlan>(data.ExecutionPlan)
: new LoadTesterExecutionPlan(),
Id = data.VirtualResourceMetadataId,
Name = data.Name,
MetadataVersion = data.MetadataVersion,
Enabled = data.Enabled,
};
detail.MetadataDetails.Add(metadata);
}
}
private void StartPoissonHandler(LoadTesterMetadataDetail metadataDetail)
{
var plan = metadataDetail.Plan as LoadTesterExecutionPlan;
var duration = TimeSpan.FromMinutes(plan.DurationTime);
var distribution = new PoissonDistribution().GetNormalizedValues(plan.ThreadCount);
if (distribution.Count() == 0)
{
TraceFactory.Logger.Debug("NO TASKS TO RUN");
SessionProxyBackendConnection.ChangeResourceState(RuntimeState.Completed);
return;
}
// Get the time delta between each sample point.
var delta = TimeSpan.FromTicks(duration.Ticks / (distribution.Count() - 1));
TraceFactory.Logger.Debug("Time Delta {0}".FormatWith(delta));
// Change the plan to support the Poisson settings. This will create
// each Task with a shorter execution time and will only create a
// DurationBased execution engine.
plan.DurationTime = (int)delta.TotalMinutes;
plan.Mode = ExecutionMode.Duration;
foreach (int threadCount in distribution)
{
// Create all the threads that will be used.
for (int i = 0; i < threadCount; i++)
{
// There is now ramp up delay with a Poisson thread
_threads.Add(new LoadTestThread(metadataDetail, TimeSpan.Zero));
}
// Start each thread for this segment
TraceFactory.Logger.Debug("Created {0} Tasks, now starting them...".FormatWith(threadCount));
foreach (var thread in _threads)
{
thread.Task.Start();
}
TraceFactory.Logger.Debug("{0} Tasks started, waiting for them to complete".FormatWith(threadCount));
// Wait for all the current threads to complete.
Task.WaitAll(_threads.Select(x => x.Task).ToArray());
// Clean up the completed threads
TraceFactory.Logger.Debug("{0} Tasks completed, disposing and clearing list".FormatWith(threadCount));
foreach (var thread in _threads)
{
thread.Dispose();
}
_threads.Clear();
}
TraceFactory.Logger.Debug("ALL TASKS COMPLETE");
SessionProxyBackendConnection.ChangeResourceState(RuntimeState.Completed);
}
public LoadTestThread(LoadTesterMetadataDetail metadataDetail, TimeSpan rampUpDelay)
{
_engine = ObjectFactory.Create <EngineBase>(metadataDetail.Plan.Mode, metadataDetail);
_task = new Task(() => RunHandler(_engine, rampUpDelay));
}
