public SetPaceBasedEngine(OfficeWorkerDetail detail, ActivityQueueBase activity, ActivityPacingInfo info, int expirationMinutes)
: base(activity, info)
{
RandomizeActivities = detail.RandomizeActivities;
_pace = TimeSpan.FromSeconds(detail.MinActivityDelay);
_expiration = TimeSpan.FromMinutes(detail.DurationTime);
}
protected void CreateBaseWorkerDetail(OfficeWorker resource, OfficeWorkerDetail detail)
{
detail.ResourceId = resource.VirtualResourceId;
detail.ResourceType = EnumUtil.Parse <VirtualResourceType>(resource.ResourceType);
detail.Name = resource.Name;
detail.Description = resource.Description;
detail.InstanceCount = resource.InstanceCount;
detail.Platform = resource.Platform;
detail.Enabled = resource.Enabled;
detail.RandomizeActivities = resource.RandomizeActivities;
detail.RandomizeStartupDelay = resource.RandomizeStartupDelay;
detail.MinStartupDelay = resource.MinStartupDelay;
detail.MaxStartupDelay = resource.MaxStartupDelay;
detail.RandomizeActivityDelay = resource.RandomizeActivityDelay;
detail.MinActivityDelay = resource.MinActivityDelay;
detail.MaxActivityDelay = resource.MaxActivityDelay;
detail.RepeatCount = resource.RepeatCount;
detail.ExecutionMode = resource.ExecutionMode;
detail.DurationTime = resource.DurationTime;
detail.SecurityGroups = resource.SecurityGroups;
detail.ResourcesPerVM = resource.ResourcesPerVM ?? 1;
if (resource.ExecutionMode == ExecutionMode.Scheduled)
{
detail.ExecutionSchedule = resource.ExecutionSchedule;
}
}
public SetPaceBasedEngine(OfficeWorkerDetail detail)
: base(detail)
{
RandomizeActivities = detail.RandomizeActivities;
_pace = TimeSpan.FromSeconds(detail.MinActivityDelay);
_expiration = TimeSpan.FromMinutes(detail.DurationTime);
}
public DurationBasedEngine(OfficeWorkerDetail worker, ActivityQueueBase activity, ActivityPacingInfo info, int expirationMinutes)
: base(activity, info)
{
//we don't have a start/stop time
_delay = new ActivityDelay(worker);
_expiration = TimeSpan.FromMinutes(expirationMinutes > 0 ? expirationMinutes : 0);
}
public ScheduleBasedEngine(OfficeWorkerDetail worker)
: base(worker)
{
_workerDetail = worker;
_baseTime = DateTime.Now;
TraceFactory.Logger.Debug("Creating...");
}
protected void WaitOnStartupDelay()
{
OfficeWorkerDetail workerDetail = GlobalDataStore.Manifest.Resources.GetWorker <OfficeWorkerDetail>(GlobalDataStore.ResourceInstanceId);
//if (workerDetail.ResourceType.IsCitrixWorker())
//{
// return;
//}
TimeSpan minDelay = TimeSpan.FromSeconds(workerDetail.MinStartupDelay);
TimeSpan maxDelay = TimeSpan.FromSeconds(workerDetail.MaxStartupDelay);
var startupDelay = workerDetail.RandomizeStartupDelay ? TimeSpanUtil.GetRandom(minDelay, maxDelay) : minDelay;
TraceFactory.Logger.Debug("Delay for {0} secs".FormatWith(startupDelay.TotalSeconds));
_statusLogger.Caller = "StartUp";
_statusLogger.Update(_statusLogger.Index + 1, Enum.GetName(typeof(RuntimeState), 8), true, "User");
ExecutionServices.DataLogger.AsInternal().Submit(_statusLogger);
ApplicationFlowControl.Instance.Wait(startupDelay);
//CR 3192
//We're seeing an issue with duplicate entry attempts on the primary key even though we generate a new key each time. To circumvent this issue we're creating a brand new instance, which in turn generates a new id and should prevent key issues.
//VirtualResourceInstanceStatusLogger postwait = new VirtualResourceInstanceStatusLogger(_sessionId, Environment.UserName, ++_statusLogger.Index, Enum.GetName(typeof(RuntimeState), 6), true, GlobalDataStore.ResourceInstanceId);
_statusLogger.Caller = "StartUp";
_statusLogger.Update(_statusLogger.Index + 1, Enum.GetName(typeof(RuntimeState), 6), true, "StartUp");
ExecutionServices.DataLogger.AsInternal().Submit(_statusLogger);
}
/// <summary>
/// Creates an <see cref="OfficeWorkerDetail"/> from the specified resource.
/// </summary>
/// <param name="resource">The resource.</param>
public virtual OfficeWorkerDetail CreateDetail(VirtualResource resource)
{
OfficeWorkerDetail detail = new OfficeWorkerDetail();
CreateBaseWorkerDetail(resource as OfficeWorker, detail);
CreateMetadataDetail(resource, detail);
return(detail);
}
public RateBasedEngine(OfficeWorkerDetail detail)
: base(detail)
{
RandomizeActivities = detail.RandomizeActivities;
_duration = detail.DurationTime;
_repeatCount = detail.RepeatCount;
_activityCount = detail.MetadataDetails.Sum(x => x.Plan.Value);
}
/// <summary>
/// Initializes a new instance of the <see cref="EngineBase"/> class.
/// </summary>
/// <param name="worker">The worker.</param>
/// <exception cref="System.ArgumentNullException">worker</exception>
protected EngineBase(OfficeWorkerDetail worker)
: this(worker.ResourceType, worker.MetadataDetails, worker)
{
if (worker == null)
{
throw new ArgumentNullException("worker");
}
}
public DurationBasedEngine(OfficeWorkerDetail worker)
: base(worker)
{
RandomizeActivities = worker.RandomizeActivities;
_delay = new ActivityDelay(worker);
_expiration = TimeSpan.FromMinutes(worker.DurationTime);
TraceFactory.Logger.Debug("Creating...");
}
public IterationBasedEngine(OfficeWorkerDetail worker)
: base(worker)
{
_delay = new ActivityDelay(worker);
_totalIterations = worker.RepeatCount * worker.MetadataDetails.Sum(x => x.Plan.Value);
RandomizeActivities = worker.RandomizeActivities;
TraceFactory.Logger.Debug("Creating against {0} items".FormatWith(worker.MetadataDetails.Count()));
}
/// <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);
}
internal override OfficeWorkerCredential AddCredential(VirtualResource resource, OfficeWorkerDetail detail)
{
SolutionTester tester = resource as SolutionTester;
OfficeWorkerCredential credential = null;
switch (tester.AccountType)
{
case SolutionTesterCredentialType.AccountPool:
credential = ManifestAgent.UserAccounts.NextUserCredential(((OfficeWorker)resource).UserPool);
credential.ResourceInstanceId = credential.UserName;
//credential.ResourceInstanceId = SystemManifestAgent.CreateUniqueId(credential.UserName);
break;
case SolutionTesterCredentialType.DefaultDesktop:
credential = new OfficeWorkerCredential();
credential.Domain = Environment.UserDomainName;
credential.UserName = Environment.UserName;
credential.Password = string.Empty;
credential.ResourceInstanceId = SystemManifestAgent.CreateUniqueId(Environment.UserName);
break;
case SolutionTesterCredentialType.ManuallyEntered:
credential = new OfficeWorkerCredential();
credential.Domain = tester.Domain;
credential.UserName = tester.UserName;
credential.Password = tester.Password;
credential.ResourceInstanceId = SystemManifestAgent.CreateUniqueId(tester.UserName);
break;
}
return(credential);
}
public DurationBasedEngine(OfficeWorkerDetail detail, int expirationMinutes)
: this(detail)
{
_expiration = TimeSpan.FromMinutes(expirationMinutes > 0 ? expirationMinutes : 0);
}
public OfficeWorkerActivityQueue(Collection <ResourceMetadataDetail> details, EventHandler <ActivityStateEventArgs> handler, OfficeWorkerDetail workerDetail)
: base(details, handler, workerDetail)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="details"></param>
/// <param name="handler"></param>
/// <param name="officeWorker"></param>
protected ActivityQueueBase(Collection <ResourceMetadataDetail> details, EventHandler <ActivityStateEventArgs> handler, OfficeWorkerDetail officeWorker)
{
MasterList = new List <Activity>();
ExecutionQueue = new Queue <Activity>();
Randomize = false;
foreach (var metadata in details)
{
Activity activity = new Activity(metadata, officeWorker);
activity.ActivityStateChanged += handler;
MasterList.Add(activity);
TraceFactory.Logger.Debug("Adding activity: {0}".FormatWith(metadata.Name));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Activity" /> class.
/// </summary>
/// <param name="activityDetail">The activity detail.</param>
/// <param name="officeWorker">The office worker.</param>
/// <exception cref="System.ArgumentNullException">activityDetail</exception>
public Activity(ResourceMetadataDetail activityDetail, OfficeWorkerDetail officeWorker)
{
if (activityDetail == null)
{
throw new ArgumentNullException("activityDetail");
}
Id = activityDetail.Id;
Name = activityDetail.Name;
ActivityType = activityDetail.MetadataType;
ExecutionOrder = activityDetail.Plan.Order;
ExecutionValue = activityDetail.Plan.Value;
ExecutionPhase = activityDetail.Plan.Phase;
ExecutionMode = activityDetail.Plan.Mode;
Pacing = activityDetail.Plan.ActivityPacing;
XmlDocument doc = new XmlDocument();
doc.LoadXml(activityDetail.Data);
_metadata = doc;
// Populate assets for this activity
if (GlobalDataStore.Manifest.ActivityAssets.ContainsKey(activityDetail.Id))
{
var assetIds = GlobalDataStore.Manifest.ActivityAssets[activityDetail.Id];
_requestedAssets.AddRange(GlobalDataStore.Manifest.AllAssets.Where(n => assetIds.Contains(n.AssetId)));
}
// Populate documents for this activity
if (GlobalDataStore.Manifest.ActivityDocuments.ContainsKey(activityDetail.Id))
{
var documentIds = GlobalDataStore.Manifest.ActivityDocuments[activityDetail.Id];
_documents.AddRange(GlobalDataStore.Manifest.Documents.Where(n => documentIds.Contains(n.DocumentId)));
}
// Populate servers for this activity
if (GlobalDataStore.Manifest.ActivityServers.ContainsKey(activityDetail.Id))
{
var serverIds = GlobalDataStore.Manifest.ActivityServers[activityDetail.Id];
_servers.AddRange(GlobalDataStore.Manifest.Servers.Where(n => serverIds.Contains(n.ServerId)));
}
// Populate print queues for this activity
if (GlobalDataStore.Manifest.ActivityPrintQueues.ContainsKey(activityDetail.Id))
{
_requestedPrintQueues.AddRange(GlobalDataStore.Manifest.ActivityPrintQueues[activityDetail.Id]);
}
// Populate retry settings for this activity (or set them to a default instance if none are configured)
if (GlobalDataStore.Manifest.ActivityRetrySettings.ContainsKey(activityDetail.Id))
{
_retrySettings = GlobalDataStore.Manifest.ActivityRetrySettings[activityDetail.Id];
}
else
{
_retrySettings = new PluginRetrySettingDictionary(new List <PluginRetrySetting>());
}
// Populate the list of external credentials that may be needed for activity execution.
if (GlobalDataStore.Manifest.Resources.ExternalCredentials.Count() > 0)
{
_externalCredentials = GlobalDataStore.Manifest.GetExternalCredentials(GlobalDataStore.Credential);
}
// Populate environment info
_environment = new PluginEnvironment(
GlobalDataStore.Manifest.PluginDefinitions.First(n => n.Name == ActivityType).PluginSettings,
GlobalSettings.Items[Setting.Domain],
GlobalSettings.Items[Setting.DnsDomain]
);
// Populate execution context
_executionContext.SessionId = GlobalDataStore.Manifest.SessionId;
_executionContext.UserName = GlobalDataStore.Credential.UserName;
_executionContext.UserPassword = GlobalDataStore.Credential.Password;
_executionContext.UserDomain = GlobalDataStore.Credential.Domain;
// Refresh asset availability
RefreshAssetAvailability();
// Create execution data
_executionData = new PluginExecutionData(
XElement.Parse(activityDetail.Data),
activityDetail.MetadataVersion,
new AssetInfoCollection(_availableAssets),
new DocumentCollection(_documents),
new ServerInfoCollection(_servers),
new PrintQueueInfoCollection(_availablePrintQueues),
_environment,
_executionContext,
_retrySettings,
new ExternalCredentialInfoCollection(_externalCredentials)
);
CreatePlugin();
}
/// <summary>
/// Initializes a new instance of the <see cref="EngineBase"/> class.
/// </summary>
protected EngineBase(VirtualResourceType resourceType, Collection <ResourceMetadataDetail> details, OfficeWorkerDetail workerDetail)
{
if (details == null)
{
throw new ArgumentNullException("details");
}
// Create the queue of activities based on the resource metadata details that are enabled
var enabledActivityDetails = new Collection <ResourceMetadataDetail>(details.Where(x => x.Enabled).ToList());
ExecutionHalted = false;
switch (resourceType)
{
case VirtualResourceType.AdminWorker:
ActivityQueue = new AdminWorkerActivityQueue(enabledActivityDetails, OnActivityStateChanged, workerDetail);
break;
default:
ActivityQueue = new OfficeWorkerActivityQueue(enabledActivityDetails, OnActivityStateChanged, workerDetail);
break;
}
PacingInfo.ExecutionMode = workerDetail.ExecutionMode;
}
public ActivityDelay(OfficeWorkerDetail worker)
{
_activityDelayMin = TimeSpan.FromSeconds(worker.MinActivityDelay);
_activityDelayMax = TimeSpan.FromSeconds(worker.MaxActivityDelay);
_randomizeActivityDelay = worker.RandomizeActivityDelay;
}
internal virtual OfficeWorkerCredential AddCredential(VirtualResource resource, OfficeWorkerDetail detail)
{
// Get the next credential and add it to the OW definition
OfficeWorkerCredential credential = ManifestAgent.UserAccounts.NextUserCredential(((OfficeWorker)resource).UserPool);
credential.Port = detail.CommandPortOffset + credential.Port;
credential.ResourceInstanceId = credential.UserName;
return(credential);
}
internal virtual void AddExternalCredentials(OfficeWorkerCredential domainCredential, OfficeWorkerDetail officeWorkerDetail)
{
using (AssetInventoryContext context = new AssetInventoryContext(DbConnect.AssetInventoryConnectionString))
{
foreach (ExternalCredential extCredential in context.ExternalCredentials.Where(x => x.DomainUserName == domainCredential.UserName))
{
officeWorkerDetail.ExternalCredentials.Add(new ExternalCredentialDetail(extCredential.UserName, extCredential.Password, extCredential.ExternalCredentialType, extCredential.DomainUserName));
}
}
}
