/// <summary>
/// Gets the entity object.
/// </summary>
/// <param name="id">The id.</param>
/// <returns></returns>
public EntityObject GetEntityObject(Guid id)
{
// Discard our old entity context and create a new one. This seems wasteful,
// but if we maintain the same context it will cache all the data that is ever
// loaded from it. This can cause huge memory growth over time, as well as
// concurrency issues. Creating a new context is cheap and avoids these issues.
if (_context != null)
{
_context.Dispose();
}
_context = new EnterpriseTestContext();
EnterpriseTestMapNode node = _databaseMap[id];
switch (node.NodeType)
{
case ConfigurationObjectType.EnterpriseScenario:
return(EnterpriseScenario.Select(_context, id));
case ConfigurationObjectType.VirtualResource:
return(VirtualResource.Select(_context, id));
case ConfigurationObjectType.ResourceMetadata:
return(VirtualResourceMetadata.Select(_context, id));
case ConfigurationObjectType.ScenarioFolder:
case ConfigurationObjectType.ResourceFolder:
case ConfigurationObjectType.MetadataFolder:
return(ConfigurationTreeFolder.Select(_context, id));
default:
return(null);
}
}
/// <summary>
/// Creates a copy of a Resource.
/// </summary>
/// <param name="source">The Source Resource to copy from</param>
/// <param name="srcParent"></param>
/// <param name="newParent"></param>
/// <param name="Mappings"></param>
/// <returns>Guid of the Resource node that was created</returns>
public Guid CopyResource(Guid source, Guid srcParent, Guid newParent, Dictionary <Guid?, Guid?> Mappings)
{
using (EnterpriseTestContext ctx = new EnterpriseTestContext())
{
VirtualResource vrSource = VirtualResource.Select(ctx, source);
VirtualResource vrCopy = vrSource.ShallowCopy();
HandleObjectChange(ctx, vrCopy);
ctx.SaveChanges();
EnterpriseScenario dstScenario;
if (vrSource.EnterpriseScenarioId == srcParent)
{
dstScenario = EnterpriseScenario.Select(ctx, newParent);
}
else
{
try
{
vrCopy.FolderId = (Guid)Mappings[srcParent];
dstScenario = EnterpriseScenario.Select(ctx, (Guid)Mappings[vrSource.EnterpriseScenarioId]);
}
catch (Exception)
{
throw new Exception("Cannot find New Target Scenario /Resource Folder for " + source.ToString());
}
}
dstScenario.VirtualResources.Add(vrCopy);
HandleObjectChange(ctx, vrCopy);
HandleObjectChange(ctx, dstScenario);
ctx.SaveChanges();
return(vrCopy.VirtualResourceId);
}
}
/// <summary>
/// Creates a copy of an activity (Virtual Resource metadata)
/// </summary>
/// <param name="source">The source activity to copy from</param>
/// <param name="srcParent"></param>
/// <param name="newParent"></param>
/// <param name="Mappings"></param>
/// <param name="isPartOfResourceCopy"></param>
/// <returns>Guid of the Activity (metadata) node that was created</returns>
public Guid CopyActivity(Guid source, Guid srcParent, Guid newParent, Dictionary <Guid?, Guid?> Mappings, bool isPartOfResourceCopy)
{
using (EnterpriseTestContext ctx = new EnterpriseTestContext())
{
VirtualResourceMetadata vrmdSource = VirtualResourceMetadata.Select(ctx, source);
VirtualResourceMetadata vrmdCopy = vrmdSource.Copy(isPartOfResourceCopy);
vrmdCopy.Name = vrmdSource.Name;
VirtualResource dstVR;
HandleObjectChange(ctx, vrmdCopy);
ctx.SaveChanges();
if (vrmdSource.VirtualResourceId == srcParent)
{
dstVR = VirtualResource.Select(ctx, newParent);
}
else
{
try
{
vrmdCopy.FolderId = (Guid)Mappings[srcParent];
dstVR = VirtualResource.Select(ctx, (Guid)Mappings[vrmdSource.VirtualResourceId]);
}
catch (Exception)
{
throw new Exception("Cannot find New Target VR / MetaData Folder for " + source.ToString());
}
}
dstVR.VirtualResourceMetadataSet.Add(vrmdCopy);
HandleObjectChange(ctx, vrmdCopy);
HandleObjectChange(ctx, dstVR);
ctx.SaveChanges();
return(vrmdCopy.VirtualResourceMetadataId);
}
}
public static ResourceDetailBase CreateBaseDetail(VirtualResource resource)
{
var resourceType = EnumUtil.Parse <VirtualResourceType>(resource.ResourceType);
DetailBuilderBase builder = CreateDetailBuilder(resourceType, null, null);
return(builder.CreateBaseDetail(resource));
}
/// <summary>
/// Finalizes changes to objects to ensure that they have the correct state.
/// </summary>
internal void FinalizeChanges()
{
foreach (EntityObject entity in this.GetObjectsInState(EntityState.Added | EntityState.Modified).Where(x => x != null))
{
// Check modified resources and metadata to see if they have been orphaned
// If so, change their entity state to Deleted
VirtualResource resource = entity as VirtualResource;
if (resource != null && resource.EnterpriseScenarioId == Guid.Empty)
{
DeleteObject(resource);
continue;
}
VirtualResourceMetadata metadata = entity as VirtualResourceMetadata;
if (metadata != null && metadata.VirtualResourceId == Guid.Empty)
{
DeleteObject(metadata);
continue;
}
VirtualResourceMetadataRetrySetting setting = entity as VirtualResourceMetadataRetrySetting;
if (setting != null && setting.VirtualResourceMetadataId == Guid.Empty)
{
DeleteObject(setting);
continue;
}
// Check object to see if there are actually any changed properties
// If nothing has been modified, the state will be changed back to unchanged
this.CheckIfModified(entity);
}
}
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 override OfficeWorkerDetail CreateDetail(VirtualResource resource)
{
AdminWorker worker = resource as AdminWorker;
AdminWorkerDetail detail = new AdminWorkerDetail
{
ResourceId = worker.VirtualResourceId,
ResourceType = EnumUtil.Parse <VirtualResourceType>(worker.ResourceType),
Name = worker.Name,
Description = worker.Description,
InstanceCount = worker.InstanceCount,
Platform = worker.Platform,
Enabled = worker.Enabled,
RandomizeActivities = false,
RandomizeStartupDelay = false,
MinStartupDelay = 0,
MaxStartupDelay = 0,
RandomizeActivityDelay = false,
MinActivityDelay = 0,
MaxActivityDelay = 0,
RepeatCount = 1,
ExecutionMode = worker.ExecutionMode
};
CreateMetadataDetail(worker, detail);
return(detail);
}
/// <summary>
/// Creates a node that is representative of the specified object (if applicable).
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public static EnterpriseTestMapNode Create(object entity)
{
EnterpriseScenario scenario = entity as EnterpriseScenario;
if (scenario != null)
{
return(new EnterpriseTestMapNode(scenario));
}
VirtualResource resource = entity as VirtualResource;
if (resource != null)
{
return(new EnterpriseTestMapNode(resource));
}
VirtualResourceMetadata metadata = entity as VirtualResourceMetadata;
if (metadata != null)
{
return(new EnterpriseTestMapNode(metadata));
}
ConfigurationTreeFolder folder = entity as ConfigurationTreeFolder;
if (folder != null)
{
return(new EnterpriseTestMapNode(folder));
}
return(null);
}
/// <summary>
/// Initializes this instance for configuration of a new object.
/// </summary>
public override void Initialize()
{
var reservation = new VirtualResource(VirtualResourceType.MachineReservation.ToString());
AddMetadataIfMissing(reservation);
Initialize(reservation);
}
/// <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);
}
/// <summary>
/// Loads the AdminWorkerContract from the specified VirtualResource object.
/// </summary>
/// <param name="resource"></param>
public override void Load(VirtualResource resource)
{
base.Load(resource);
var worker = resource as AdminWorker;
ExecutionMode = worker.ExecutionMode;
}
/// <summary>
/// Loads the PerfMonCollectorContract from the specified VirtualResource object.
/// </summary>
/// <param name="resource"></param>
public override void Load(VirtualResource resource)
{
base.Load(resource);
var worker = resource as PerfMonCollector;
HostName = worker.HostName;
}
/// <summary>
/// Loads the LoadTesterContract from the specified VirtualResource object.
/// </summary>
/// <param name="resource"></param>
public override void Load(VirtualResource resource)
{
base.Load(resource);
var worker = resource as LoadTester;
ThreadsPerVM = worker.ThreadsPerVM;
}
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);
}
/// <summary>
/// Initializes a new instance of the <see cref="EnterpriseTestMapNode"/> class.
/// </summary>
/// <param name="resource">The virtual resource.</param>
public EnterpriseTestMapNode(VirtualResource resource)
: this(resource.VirtualResourceId)
{
ParentId = resource.EnterpriseScenarioId;
FolderId = resource.FolderId;
Name = resource.Name;
NodeType = ConfigurationObjectType.VirtualResource;
ResourceType = resource.ResourceType;
Enabled = resource.Enabled;
}
private static void AddMetadataIfMissing(VirtualResource reservation)
{
if (reservation.VirtualResourceMetadataSet.Count == 0)
{
var resourceType = VirtualResourceType.MachineReservation.ToString();
var metadata = new VirtualResourceMetadata(resourceType, resourceType);
metadata.Metadata = LegacySerializer.SerializeXml(new MachineReservationMetadata()).ToString();
reservation.VirtualResourceMetadataSet.Add(metadata);
}
}
/// <summary>
/// Loads the CitrixWorkerContract from the specified VirtualResource object.
/// </summary>
/// <param name="resource"></param>
public override void Load(VirtualResource resource)
{
base.Load(resource);
var worker = resource as CitrixWorker;
DBWorkerRunMode = worker.DBWorkerRunMode;
ServerHostname = worker.ServerHostname;
PublishedApp = worker.PublishedApp;
}
/// <summary>
/// Loads the ResourceContract from the specified VirtualResource object.
/// </summary>
/// <param name="resource"></param>
public virtual void Load(VirtualResource resource)
{
VirtualResourceId = resource.VirtualResourceId;
Name = resource.Name;
Description = resource.Description;
ResourceType = resource.ResourceType;
InstanceCount = resource.InstanceCount;
Platform = resource.Platform;
ResourcesPerVM = resource.ResourcesPerVM;
Enabled = resource.Enabled;
}
/// <summary>
/// Loads the EventLogCollectorContract from the specified VirtualResource object.
/// </summary>
/// <param name="resource"></param>
public override void Load(VirtualResource resource)
{
base.Load(resource);
var worker = resource as EventLogCollector;
HostName = worker.HostName;
PollingInterval = worker.PollingInterval;
ComponentsData = worker.ComponentsData;
EntryTypesData = worker.EntryTypesData;
}
/// <summary>
/// Loads the SolutionTesterContract using the specified VirtualResource object.
/// </summary>
public override void Load(VirtualResource resource)
{
base.Load(resource);
var tester = resource as SolutionTester;
Username = tester.UserName;
Domain = tester.Domain;
Password = tester.Password;
AccountType = tester.AccountType;
UseCredential = tester.UseCredential;
}
private MachineReservationDetail CreateDetail(VirtualResource resource)
{
return(new MachineReservationDetail
{
ResourceId = resource.VirtualResourceId,
ResourceType = EnumUtil.Parse <VirtualResourceType>(resource.ResourceType),
Name = resource.Name,
Description = resource.Description,
InstanceCount = resource.InstanceCount,
Platform = resource.Platform,
Enabled = resource.Enabled
});
}
private void UpdateTestResult()
{
Collection <int> testcaseIds = new Collection <int>();
Dictionary <int, bool> testIdResult = new Dictionary <int, bool>();
//using (SqlAdapter datalogsqlAdapter = new SqlAdapter(DataLogSqlConnection.ConnectionString))
//{
// //string sqlText = "select (select count(*) from ActivityExecution where SessionId = '{0}' and UpdateType = 'Completed') as PassedCount, (select count(*) from ActivityExecution where SessionId = '{0}') as TotalCount".FormatWith(_ticket.SessionId);
// string sqlText = "select VirtualResourceMetadataId, MIN(case when UpdateType = 'Completed' then 1 else 0 end) as TestResult from ActivityExecution where SessionId = {0} group by VirtualResourceMetadataId".FormatWith(_ticket.SessionId);
// var reader = datalogsqlAdapter.ExecuteReader(sqlText);
// if (reader != null)
// {
// while (reader.Read())
// {
// TestIdResult.Add(Guid.Parse(reader["VirtualResourceId"].ToString()), Convert.ToBoolean(reader.GetInt32(1))) ;
// }
// }
// reader.Close();
//}
DataLogContext traceContext = DbConnect.DataLogContext();
{
var activityExecutions = traceContext.SessionData(_ticket.SessionId).Activities;
var failedActivities = activityExecutions.Where(x => x.Status == "Failed");
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
foreach (var metadataId in activityExecutions.Select(x => x.ResourceMetadataId.Value).Distinct())
{
testcaseIds.Add(VirtualResource.Select(context, VirtualResourceMetadata.Select(context, metadataId).VirtualResourceId).TestCaseId);
}
foreach (var testcaseId in testcaseIds.Distinct())
{
testIdResult.Add(testcaseId, true);
}
foreach (var failedActivity in failedActivities)
{
testIdResult.Remove(VirtualResource.Select(context, VirtualResourceMetadata.Select(context, failedActivity.ResourceMetadataId.Value).VirtualResourceId).TestCaseId);
testIdResult.Add(VirtualResource.Select(context, VirtualResourceMetadata.Select(context, failedActivity.ResourceMetadataId.Value).VirtualResourceId).TestCaseId, false);
}
}
}
_scenarioList.ElementAt(_currentScenarioIndex).TestResult = testIdResult;
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigurationObjectTag" /> class
/// representing a <see cref="VirtualResource" /> object.
/// </summary>
/// <param name="resource">The <see cref="VirtualResource" />.</param>
/// <exception cref="ArgumentNullException"><paramref name="resource" /> is null.</exception>
public ConfigurationObjectTag(VirtualResource resource)
{
if (resource == null)
{
throw new ArgumentNullException(nameof(resource));
}
Id = resource.VirtualResourceId;
ObjectType = ConfigurationObjectType.VirtualResource;
ResourceType = EnumUtil.Parse <VirtualResourceType>(resource.ResourceType);
Name = resource.Name;
ParentId = resource.EnterpriseScenarioId;
FolderId = resource.FolderId;
EnabledState = resource.Enabled ? EnabledState.Enabled : EnabledState.Disabled;
}
public override OfficeWorkerDetail CreateDetail(VirtualResource resource)
{
CitrixWorker worker = resource as CitrixWorker;
CitrixWorkerDetail detail = new CitrixWorkerDetail();
CreateBaseWorkerDetail(worker, detail);
detail.PublishedApp = worker.PublishedApp;
detail.WorkerRunMode = worker.RunMode;
detail.ServerHostname = worker.ServerHostname;
CreateMetadataDetail(resource, detail);
return(detail);
}
/// <summary>
/// Initializes this instance with the specified object.
/// </summary>
/// <param name="entity">The entity.</param>
/// <exception cref="ControlTypeMismatchException">
/// Thrown when an object of incorrect type is passed to this instance.
/// </exception>
public override void Initialize(object entity)
{
_reservation = entity as VirtualResource;
AddMetadataIfMissing(_reservation);
if (_reservation == null)
{
throw new ControlTypeMismatchException(entity, typeof(VirtualResource));
}
platform_ComboBox.SetPlatform(_reservation.Platform, VirtualResourceType.MachineReservation);
var metadata = _reservation.VirtualResourceMetadataSet.FirstOrDefault();
if (metadata != null)
{
_reservationData = LegacySerializer.DeserializeXml <MachineReservationMetadata>(metadata.Metadata);
}
else
{
_reservationData = new MachineReservationMetadata();
}
var package = SoftwareInstallerPackage.CreateSoftwareInstallerPackage(Guid.Empty);
package.Description = "None";
package_ComboBox.Items.Add(package);
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
List <SoftwareInstallerPackage> list = new List <SoftwareInstallerPackage>();
list.Add(package);
list.AddRange(context.SoftwareInstallerPackages.OrderBy(n => n.Description));
package_ComboBox.DataSource = list;
package_ComboBox.DisplayMember = "Description";
package_ComboBox.ValueMember = "PackageId";
package_ComboBox.SelectedItem = list.FirstOrDefault(e => e.PackageId == _reservationData.PackageId);
}
// Set up data bindings
name_TextBox.DataBindings.Add("Text", _reservation, "Name");
description_TextBox.DataBindings.Add("Text", _reservation, "Description");
platform_ComboBox.DataBindings.Add("SelectedValue", _reservation, "Platform");
instanceCount_NumericUpDown.DataBindings.Add("Text", _reservation, "InstanceCount");
package_ComboBox.DataBindings.Add("SelectedValue", _reservationData, "PackageId");
}
private void CreateMetadataDetail(VirtualResource resource, ResourceDetailBase detail)
{
foreach (var data in resource.VirtualResourceMetadataSet.Where(m => m.Enabled))
{
ResourceMetadataDetail metadata = new ResourceMetadataDetail()
{
MetadataType = data.MetadataType,
Data = data.Metadata,
Id = data.VirtualResourceMetadataId,
Name = data.Name,
MetadataVersion = data.MetadataVersion
};
detail.MetadataDetails.Add(metadata);
}
}
public override OfficeWorkerDetail CreateDetail(VirtualResource resource)
{
SolutionTester tester = resource as SolutionTester;
SolutionTesterDetail detail = new SolutionTesterDetail();
CreateBaseWorkerDetail(tester, detail);
detail.UseCredential = tester.UseCredential;
detail.CredentialType = tester.CredentialType;
detail.Username = tester.CredentialName;
detail.Domain = tester.CredentialDomain;
detail.Password = tester.Password;
CreateMetadataDetail(resource, detail);
return(detail);
}
protected void CreateMetadataDetail(VirtualResource resource, ResourceDetailBase detail)
{
Dictionary <int, OfficeWorkerMetadataDetail> orderedDetails = new Dictionary <int, OfficeWorkerMetadataDetail>();
foreach (var data in resource.VirtualResourceMetadataSet)
{
OfficeWorkerMetadataDetail metadata = new OfficeWorkerMetadataDetail()
{
MetadataType = data.MetadataType,
Data = data.Metadata,
Plan = data.ExecutionPlan != null
? LegacySerializer.DeserializeDataContract <WorkerExecutionPlan>(data.ExecutionPlan)
: new WorkerExecutionPlan(),
Id = data.VirtualResourceMetadataId,
Name = data.Name,
MetadataVersion = data.MetadataVersion,
Enabled = data.Enabled,
};
// Offset the key by 100, this is a bunch but it will guarantee (or should) that
// if for some reason the same order number exists in two plans that they
// won't conflict. While the ordered list contains the key, it will keep
// adding one until it's found an open spot. Using 100 means we could have up
// to 100 entries with the same order number and still resolve them. Of course this
// doesn't guarantee any ultimate order to the metadata, but in most cases when
// the order value is unique, this will just ensure the items are added in numerical
// order so that the serialized XML shows them in order as well.
int key = metadata.Plan.Order * 100;
while (orderedDetails.ContainsKey(key))
{
key++;
}
orderedDetails.Add(key, metadata);
}
// Add the metadata to the manifest in order so that the XML shows them in order.
foreach (int key in orderedDetails.Keys.OrderBy(x => x))
{
detail.MetadataDetails.Add(orderedDetails[key]);
}
}
private PerfMonCollectorDetail CreateDetail(VirtualResource resource)
{
PerfMonCollector collector = resource as PerfMonCollector;
PerfMonCollectorDetail detail = new PerfMonCollectorDetail
{
ResourceId = collector.VirtualResourceId,
ResourceType = EnumUtil.Parse <VirtualResourceType>(collector.ResourceType),
Name = collector.Name,
Description = collector.Description,
InstanceCount = collector.InstanceCount,
Platform = collector.Platform,
Enabled = collector.Enabled,
HostName = collector.HostName
};
CreateMetadataDetail(resource, detail);
return(detail);
}
private EventLogCollectorDetail CreateDetail(VirtualResource resource)
{
EventLogCollector collector = resource as EventLogCollector;
return(new EventLogCollectorDetail
{
ResourceId = collector.VirtualResourceId,
ResourceType = EnumUtil.Parse <VirtualResourceType>(collector.ResourceType),
Name = collector.Name,
Description = collector.Description,
InstanceCount = collector.InstanceCount,
Platform = collector.Platform,
Enabled = collector.Enabled,
HostName = collector.HostName,
ComponentsData = collector.ComponentsData,
EntryTypesData = collector.EntryTypesData,
PollingInterval = collector.PollingInterval
});
}
