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