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)); }