private void AddActivity(VirtualResourceMetadata metadata)
{
metadata.VirtualResourceId = _adminWorker.VirtualResourceId;
metadata.Enabled = true;
//metadata.ExecutionOrder = _officeWorker.VirtualResourceMetadataSet.Count + 1;
_adminWorker.VirtualResourceMetadataSet.Add(metadata);
WorkerActivityConfiguration config = new WorkerActivityConfiguration(metadata, new WorkerExecutionPlan());
config.ExecutionPlan.Order = PhaseConfigurations.Count() > 0 ? PhaseConfigurations.Max(x => x.ExecutionPlan.Order) + 1 : 1;
if (activity_TabControl.SelectedTab == main_TabPage)
{
config.ExecutionPlan.Phase = ResourceExecutionPhase.Main;
}
else if (activity_TabControl.SelectedTab == setup_TabPage)
{
config.ExecutionPlan.Phase = ResourceExecutionPhase.Setup;
}
else
{
config.ExecutionPlan.Phase = ResourceExecutionPhase.Teardown;
}
_mainConfigurations.Add(config);
RefreshGrid();
// Set the current plan to this new entry
activity_GridView.ChildRows[PhaseConfigurations.Count() - 1].IsSelected = true;
}
/// <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);
}
}
/// <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 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 void Initialize(object entity)
{
_metadata = entity as VirtualResourceMetadata;
if (_metadata == null)
{
throw new ControlTypeMismatchException(entity, typeof(VirtualResourceMetadata));
}
name_TextBox.Text = _metadata.Name;
// Remove existing plugin from the editor panel
foreach (IPluginConfigurationControl control in metadataEditor_Panel.Controls.OfType <IPluginConfigurationControl>())
{
control.ConfigurationChanged -= PluginControl_ConfigurationChanged;
}
metadataEditor_Panel.Controls.Clear();
// Create the edit plugin and add it to the editor panel
try
{
IPluginConfigurationControl pluginControl = CreatePluginControl();
Control control = (Control)pluginControl;
control.Dock = DockStyle.Fill;
metadataEditor_Panel.Controls.Add(control);
}
catch (PluginLoadException ex)
{
MessageBox.Show(ex.Message, "Plugin Load Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
// Reset unsaved changes
HasUnsavedChanges = false;
}
/// <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 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 override void Initialize(object entity)
{
_metadata = entity as VirtualResourceMetadata;
if (_metadata == null)
{
throw new EditorTypeMismatchException(entity, typeof(VirtualResourceMetadata));
}
string server = (_metadata.VirtualResource as PerfMonCollector).HostName;
List <ResourceWindowsCategory> categories = null;
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
//Load categories from the database.
categories = ResourceWindowsCategory.Select(context, "PerfMon").ToList();
}
// Get the top node. It will have a blank name.
ResourceWindowsCategory top = categories.FirstOrDefault(c => string.IsNullOrEmpty(c.Name));
foreach (ResourceWindowsCategory category in top.Children)
{
if (category.Name == PrintQueueCategory)
{
LoadPrintQueueCounterNames(category.Children);
}
else
{
BuildTree(category);
}
}
LoadPrintQueues(server);
SelectedCounter = _metadata.Metadata;
// Data Bindings
hostNameDisplay_Label.Text = server;
category_TextBox.DataBindings.Add("Text", _selected, "Category");
instance_TextBox.DataBindings.Add("Text", _selected, "Instance");
counter_TextBox.DataBindings.Add("Text", _selected, "Counter");
collect_CheckBox.DataBindings.Add("Checked", _selected, "CollectAtStart");
//Interval Binding requires special formatting.
Binding intervalBinding = new Binding("Text", _selected, "CollectionInterval");
intervalBinding.Format += new ConvertEventHandler(IntervalBinding_Format);
intervalBinding.Parse += new ConvertEventHandler(IntervalBinding_Parse);
interval_TextBox.DataBindings.Add(intervalBinding);
SyncTreeChecked(_selected.Key);
available_TreeView.BeforeCheck += new TreeViewCancelEventHandler(Available_TreeView_BeforeCheck);
available_TreeView.AfterCheck += new TreeViewEventHandler(Available_TreeView_AfterCheck);
// Validate the data coming in
ValidateInterval(_selected.CollectionInterval);
ValidateSelection();
}
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 ResourceMetadataContract from the specified VirtualResourceMetadata object.
/// </summary>
public void Load(VirtualResourceMetadata data)
{
Name = data.Name;
MetadataId = data.VirtualResourceMetadataId;
ResourceType = data.ResourceType;
MetadataType = data.MetadataType;
Metadata = data.Metadata;
Enabled = data.Enabled;
ExecutionPlan = data.ExecutionPlan;
}
private void addCounter_ToolStripButton_Click(object sender, EventArgs e)
{
if (ValidateSelection())
{
PerfMonCounterData tempCounterData = new PerfMonCounterData();
if (_loadFromMachine)
{
PerformanceCounter selectedCounter = SelectedCounter as PerformanceCounter;
tempCounterData.Category = selectedCounter.CategoryName;
tempCounterData.Counter = selectedCounter.CounterName;
tempCounterData.InstanceName = selectedCounter.InstanceName;
}
else
{
string selectedInstance = SelectedInstance;
tempCounterData.Category = SelectedCategory.ToString();
tempCounterData.Counter = ((ResourceWindowsCategory)SelectedCounter).Name;
/// Don't insert "N/A" into the counter data, use empty string instead.
tempCounterData.InstanceName = (selectedInstance == PerfMonController.InstanceDoesNotApply) ? string.Empty : selectedInstance;
}
tempCounterData.TargetHost = _selectedServer.HostName;
//if the user has entered the username and password then use it
if (!string.IsNullOrEmpty(userName_textBox.Text) || !string.IsNullOrEmpty(password_textBox.Text))
{
tempCounterData.Credentials = new PerfMonCounterCredential(userName_textBox.Text, password_textBox.Text, string.IsNullOrEmpty(domain_textBox.Text) ? "." : domain_textBox.Text);
}
else
{
tempCounterData.Credentials = new PerfMonCounterCredential();
}
tempCounterData.Interval = interval_TimeSpanControl.Value.TotalMilliseconds;
VirtualResourceMetadata tempMetaData = new VirtualResourceMetadata(VirtualResourceType.PerfMonCollector.ToString(), "PerfMonCounter");
//associate the GUID of the tempMetaData to the perfmoncounterdata item
tempCounterData.VirtualResourceMetadataId = tempMetaData.VirtualResourceMetadataId;
tempMetaData.VirtualResourceId = _perfMonCollector.VirtualResourceId;
tempMetaData.Name = tempCounterData.TargetHost + "-" + tempCounterData.Category + "/" + tempCounterData.InstanceName + "/" + tempCounterData.Counter;
string metadataxml = LegacySerializer.SerializeXml(tempCounterData).ToString();
tempMetaData.Metadata = metadataxml;
//we are not currently connected to DB or using the existing data, so add this to the virtual resource metadata collection
_perfMonCollector.VirtualResourceMetadataSet.Add(tempMetaData);
_perfMonCollector.Platform = (string)platform_ComboBox.SelectedValue;
//populate the listview in the newly added item
_selectedCountersDataList.Add(tempCounterData);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EnterpriseTestMapNode"/> class.
/// </summary>
/// <param name="metadata">The virtual resource metadata.</param>
public EnterpriseTestMapNode(VirtualResourceMetadata metadata)
: this(metadata.VirtualResourceMetadataId)
{
ParentId = metadata.VirtualResourceId;
FolderId = metadata.FolderId;
Name = metadata.Name;
NodeType = ConfigurationObjectType.ResourceMetadata;
ResourceType = metadata.ResourceType;
MetadataType = metadata.MetadataType;
Enabled = metadata.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;
}
private void AddActivity(VirtualResourceMetadata metadata)
{
metadata.VirtualResourceId = _loadTester.VirtualResourceId;
metadata.Enabled = true;
//metadata.ExecutionOrder = _loadTester.VirtualResourceMetadataSet.Count + 1;
_loadTester.VirtualResourceMetadataSet.Add(metadata);
LoadTesterConfiguration config = new LoadTesterConfiguration();
//config.Name = metadata.Name;
//config.MetadataType = metadata.MetadataType;
//config.ThreadCount = 1;
config.Metadata = metadata;
config.ExecutionPlan = new LoadTesterExecutionPlan();
_configurations.Add(config);
// Set the current plan to this new entry
_currentConfig = config;
activity_GridView.Rows[_configurations.Count - 1].IsSelected = true;
switch (config.ExecutionPlan.Mode)
{
case ExecutionMode.RateBased:
execution_TabControl.SelectedTab = rateBased_TabPage;
break;
case ExecutionMode.Duration:
execution_TabControl.SelectedTab = timeBased_TabPage;
break;
case ExecutionMode.Poisson:
execution_TabControl.SelectedTab = poisson_TabPage;
break;
}
switch (config.ExecutionPlan.RampUpMode)
{
case RampUpMode.RateBased:
rampUp_TabControl.SelectedTab = timeBasedRampUp_TabPage;
break;
case RampUpMode.TimeBased:
rampUp_TabControl.SelectedTab = rateBasedRampUp_TabPage;
break;
}
SetupExecutionPlanBindings(config);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigurationObjectTag" /> class
/// representing a <see cref="VirtualResourceMetadata" /> object.
/// </summary>
/// <param name="metadata">The <see cref="VirtualResourceMetadata" />.</param>
/// <exception cref="ArgumentNullException"><paramref name="metadata" /> is null.</exception>
public ConfigurationObjectTag(VirtualResourceMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
Id = metadata.VirtualResourceMetadataId;
ObjectType = ConfigurationObjectType.VirtualResourceMetadata;
ResourceType = EnumUtil.Parse <VirtualResourceType>(metadata.ResourceType);
MetadataType = metadata.MetadataType;
Name = metadata.Name;
ParentId = metadata.VirtualResourceId;
FolderId = metadata.FolderId;
EnabledState = metadata.Enabled ? EnabledState.Enabled : EnabledState.Disabled;
}
private void copyActivity_ToolStripButton_Click_1(object sender, EventArgs e)
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
using (VirtualResourceMetadataListForm form = new VirtualResourceMetadataListForm())
{
form.Initialize(VirtualResourceMetadata.Select(context, VirtualResourceType.LoadTester));
if (form.ShowDialog(this) == DialogResult.OK)
{
foreach (VirtualResourceMetadata metadata in form.SelectedMetadata)
{
AddActivity(metadata.Copy(false));
}
}
}
}
}
/// <summary>
/// Enables/disable the specified object.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="enabled">Whether the object should be enabled.</param>
public void EnableDisable(Guid id, bool enabled)
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
EnterpriseTestMapNode node = _databaseMap[id];
switch (node.NodeType)
{
case ConfigurationObjectType.VirtualResource:
var resource = VirtualResource.Select(context, id);
resource.Enabled = enabled;
HandleObjectChange(context, resource);
break;
case ConfigurationObjectType.ResourceMetadata:
var metadata = VirtualResourceMetadata.Select(context, id);
metadata.Enabled = enabled;
HandleObjectChange(context, metadata);
break;
}
context.SaveChanges();
}
}
private void MoveHandler(EnterpriseTestContext context, IEnumerable <Guid> affected)
{
foreach (Guid affectedId in affected)
{
EnterpriseTestMapNode moved = _databaseMap[affectedId];
switch (moved.NodeType)
{
case ConfigurationObjectType.EnterpriseScenario:
var scenario = EnterpriseScenario.Select(context, affectedId);
scenario.FolderId = moved.FolderId;
HandleObjectChange(context, scenario);
break;
case ConfigurationObjectType.VirtualResource:
var resource = VirtualResource.Select(context, affectedId);
resource.EnterpriseScenarioId = (Guid)moved.ParentId;
resource.FolderId = moved.FolderId;
HandleObjectChange(context, resource);
break;
case ConfigurationObjectType.ResourceMetadata:
var metadata = VirtualResourceMetadata.Select(context, affectedId);
metadata.VirtualResourceId = (Guid)moved.ParentId;
metadata.FolderId = moved.FolderId;
HandleObjectChange(context, metadata);
break;
case ConfigurationObjectType.ScenarioFolder:
case ConfigurationObjectType.ResourceFolder:
case ConfigurationObjectType.MetadataFolder:
var folder = ConfigurationTreeFolder.Select(context, affectedId);
folder.ParentId = moved.ParentId;
HandleObjectChange(context, folder);
break;
}
}
context.SaveChanges();
}
/// <summary>
/// Renames the object with the specified id.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="name">The name.</param>
public void Rename(Guid id, string name)
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
EnterpriseTestMapNode node = _databaseMap[id];
switch (node.NodeType)
{
case ConfigurationObjectType.EnterpriseScenario:
var scenario = EnterpriseScenario.Select(context, id);
scenario.Name = name;
HandleObjectChange(context, scenario);
break;
case ConfigurationObjectType.VirtualResource:
var resource = VirtualResource.Select(context, id);
resource.Name = name;
HandleObjectChange(context, resource);
break;
case ConfigurationObjectType.ResourceMetadata:
var metadata = VirtualResourceMetadata.Select(context, id);
metadata.Name = name;
HandleObjectChange(context, metadata);
break;
case ConfigurationObjectType.ScenarioFolder:
case ConfigurationObjectType.ResourceFolder:
case ConfigurationObjectType.MetadataFolder:
var folder = ConfigurationTreeFolder.Select(context, id);
folder.Name = name;
HandleObjectChange(context, folder);
break;
}
context.SaveChanges();
}
}
public ActivityListItem(VirtualResourceMetadata metadata)
{
Id = metadata.VirtualResourceMetadataId;
Name = metadata.Name;
ActivityType = metadata.MetadataType;
}
private static void DatabaseDelete(IEnumerable <EnterpriseTestMapNode> nodes)
{
//--------------------------------------------------------------------------------------------------
// ADD: CR #1894. Cascading deletes were throwing an unhandled exception because of a DB Foreign
// Key Constraint on the folderId field. What that means is that the ORDER in which things are
// deleted, now becomes very important. If we attempt to remove a 'container' before we remove
// the contents, the exception will be thrown when the contents are removed. So - in order to make
// this work, we group the objects to be deleted - and then we have to order those groups (since the
// order of the GroupBy could be non-deterministic) and make sure that we delete things in the
// correct sequence. There is probably a more elegant way of doing this - but there was no time.
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
int[] ordered = new int[6] {
-1, -1, -1, -1, -1, -1
};
var colls = nodes.GroupBy(n => n.NodeType, n => n.Id);
int ndx = 0;
foreach (var grp in colls)
{
switch (grp.Key)
{
case ConfigurationObjectType.ResourceMetadata:
ordered[0] = ndx++;
break;
case ConfigurationObjectType.MetadataFolder:
ordered[1] = ndx++;
break;
case ConfigurationObjectType.VirtualResource:
ordered[2] = ndx++;
break;
case ConfigurationObjectType.ResourceFolder:
ordered[3] = ndx++;
break;
case ConfigurationObjectType.EnterpriseScenario:
ordered[4] = ndx++;
break;
case ConfigurationObjectType.ScenarioFolder:
ordered[5] = ndx++;
break;
}
}
for (ndx = 0; ndx < 6; ndx++)
{
if (ordered[ndx] >= 0)
{
switch (colls.ElementAt(ordered[ndx]).Key)
{
case ConfigurationObjectType.ResourceMetadata:
foreach (var vrmd in VirtualResourceMetadata.Select(context, colls.ElementAt(ordered[ndx])))
{
context.DeleteObject(vrmd);
}
break;
case ConfigurationObjectType.MetadataFolder:
foreach (var mdf in ConfigurationTreeFolder.Select(context, colls.ElementAt(ordered[ndx])))
{
context.DeleteObject(mdf);
}
break;
case ConfigurationObjectType.VirtualResource:
foreach (var vr in VirtualResource.Select(context, colls.ElementAt(ordered[ndx])))
{
context.DeleteObject(vr);
}
break;
case ConfigurationObjectType.ResourceFolder:
foreach (var rf in ConfigurationTreeFolder.Select(context, colls.ElementAt(ordered[ndx])))
{
context.DeleteObject(rf);
}
break;
case ConfigurationObjectType.EnterpriseScenario:
foreach (var scenario in EnterpriseScenario.Select(context, colls.ElementAt(ordered[ndx])))
{
context.DeleteObject(scenario);
}
break;
case ConfigurationObjectType.ScenarioFolder:
foreach (var sf in ConfigurationTreeFolder.Select(context, colls.ElementAt(ordered[ndx])))
{
var deletingScenarioIds = nodes.Where(n => n.NodeType == ConfigurationObjectType.EnterpriseScenario).Select(n => n.Id);
foreach (var folder in ConfigurationTreeFolder.Select(context, colls.ElementAt(ordered[ndx])))
{
var containedScenarios = ConfigurationTreeFolder.ContainedScenarioIds(context, folder.ConfigurationTreeFolderId);
if (containedScenarios.All(n => deletingScenarioIds.Contains(n)))
{
// All of the sceanrios under this folder are in the list of scenarios to delete,
// so we can delete this folder as well.
context.DeleteObject(folder);
}
}
}
break;
}
context.SaveChanges();
}
}
}
}
public WorkerActivityConfiguration(VirtualResourceMetadata metadata, WorkerExecutionPlan plan)
{
Metadata = metadata;
ExecutionPlan = plan;
}
private static void UpdateMetadata(VirtualResourceMetadata metadata, IPluginConfigurationControl control)
{
// Get the XML metadata from the plugin
PluginConfigurationData editorData = control.GetConfiguration();
metadata.Metadata = editorData.GetMetadata().ToString();
metadata.MetadataVersion = editorData.MetadataVersion;
// Save asset selection data
if (editorData.Assets != null)
{
if (metadata.AssetUsage == null)
{
metadata.AssetUsage = new VirtualResourceMetadataAssetUsage();
}
metadata.AssetUsage.AssetSelectionData = Serializer.Serialize(editorData.Assets).ToString();
}
else
{
metadata.AssetUsage = null;
}
// Save document selection data
if (editorData.Documents != null)
{
if (metadata.DocumentUsage == null)
{
metadata.DocumentUsage = new VirtualResourceMetadataDocumentUsage();
}
metadata.DocumentUsage.DocumentSelectionData = Serializer.Serialize(editorData.Documents).ToString();
}
else
{
metadata.DocumentUsage = null;
}
// Save server selection data
if (editorData.Servers != null)
{
if (metadata.ServerUsage == null)
{
metadata.ServerUsage = new VirtualResourceMetadataServerUsage();
}
metadata.ServerUsage.ServerSelectionData = Serializer.Serialize(editorData.Servers).ToString();
}
else
{
metadata.ServerUsage = null;
}
// Save print queue selection data
if (editorData.PrintQueues != null)
{
if (metadata.PrintQueueUsage == null)
{
metadata.PrintQueueUsage = new VirtualResourceMetadataPrintQueueUsage();
}
metadata.PrintQueueUsage.PrintQueueSelectionData = Serializer.Serialize(editorData.PrintQueues).ToString();
}
else
{
metadata.PrintQueueUsage = null;
}
}
private void ImportScenarios(string fileName, Guid folderId)
{
int totalActivities = 0;
List <Database.EnterpriseScenario> exportedScenarios;
using (FileStream fs = File.OpenRead(fileName))
{
StreamReader sReader = new StreamReader(fs);
var scenarioString = sReader.ReadToEnd();
exportedScenarios = (List <Database.EnterpriseScenario>)JsonConvert.DeserializeObject(scenarioString, typeof(List <Database.EnterpriseScenario>));
}
using (EnterpriseTestContext context = new EnterpriseTestContext(_currentDatabase))
{
foreach (var sourceScenario in exportedScenarios)
{
EnterpriseScenario targetScenario = new EnterpriseScenario
{
Name = sourceScenario.Name,
EnterpriseScenarioId = SequentialGuid.NewGuid(),
FolderId = folderId,
Company = sourceScenario.Company,
Deleted = false,
Description = sourceScenario.Description,
Owner = UserManager.CurrentUserName,
ScenarioSettings = sourceScenario.ScenarioSettings,
Vertical = sourceScenario.Vertical
};
//if (context.EnterpriseScenarios.FirstOrDefault(x =>
// x.EnterpriseScenarioId == sourceScenario.EnterpriseScenarioId) != null)
//{
// targetScenario.EnterpriseScenarioId = SequentialGuid.NewGuid();
//}
foreach (var sourceScenarioVirtualResource in sourceScenario.VirtualResources)
{
SolutionTester targetVirtualResource = new SolutionTester("SolutionTester")
{
Description = sourceScenarioVirtualResource.Description,
Enabled = true,
EnterpriseScenarioId = targetScenario.EnterpriseScenarioId,
Name = sourceScenarioVirtualResource.Name,
InstanceCount = sourceScenarioVirtualResource.InstanceCount,
Platform = sourceScenarioVirtualResource.Platform,
ResourceType = sourceScenarioVirtualResource.ResourceType,
ResourcesPerVM = sourceScenarioVirtualResource.ResourcePerVM,
TestCaseId = sourceScenarioVirtualResource.TestCaseId,
VirtualResourceId = SequentialGuid.NewGuid(),
DurationTime = sourceScenarioVirtualResource.DurationTime,
MaxActivityDelay = sourceScenarioVirtualResource.MaxActivityDelay,
MinActivityDelay = sourceScenarioVirtualResource.MinActivityDelay,
RandomizeActivities = sourceScenarioVirtualResource.RandomizeActivities,
RandomizeActivityDelay = sourceScenarioVirtualResource.RandomizeActivityDelay,
ExecutionMode = EnumUtil.Parse <ExecutionMode>(sourceScenarioVirtualResource.RunMode),
MaxStartupDelay = sourceScenarioVirtualResource.MaxStartupDelay,
MinStartupDelay = sourceScenarioVirtualResource.MinStartupDelay,
RandomizeStartupDelay = sourceScenarioVirtualResource.RandomizeStartupDelay,
RepeatCount = sourceScenarioVirtualResource.RepeatCount,
AccountType = SolutionTesterCredentialType.DefaultDesktop,
UseCredential = false
};
//if (context.VirtualResources.FirstOrDefault(x =>
// x.VirtualResourceId == sourceScenarioVirtualResource.VirtualResourceId) != null)
//{
// targetVirtualResource.VirtualResourceId = SequentialGuid.NewGuid();
//}
foreach (var virtualResourceMetadata in sourceScenarioVirtualResource.VirtualResourceMetadata)
{
VirtualResourceMetadata targetVirtualResourceMetadata =
new VirtualResourceMetadata(virtualResourceMetadata.ResourceType,
virtualResourceMetadata.MetadataType)
{
VirtualResourceId = targetVirtualResource.VirtualResourceId,
Deleted = false,
Enabled = true,
ExecutionPlan = virtualResourceMetadata.ExecutionPlan,
Metadata = virtualResourceMetadata.Metadata,
MetadataVersion = virtualResourceMetadata.MetadataVersion,
MetadataType = virtualResourceMetadata.MetadataType,
Name = virtualResourceMetadata.Name,
ResourceType = virtualResourceMetadata.ResourceType,
VirtualResourceMetadataId = SequentialGuid.NewGuid(),
};
//if (context.VirtualResourceMetadataSet.FirstOrDefault(x =>
// x.VirtualResourceMetadataId ==
// targetVirtualResourceMetadata.VirtualResourceMetadataId) != null)
//{
// targetVirtualResourceMetadata.VirtualResourceMetadataId = SequentialGuid.NewGuid();
//}
targetVirtualResourceMetadata.AssetUsage = VirtualResourceMetadataAssetUsage
.CreateVirtualResourceMetadataAssetUsage(
targetVirtualResourceMetadata.VirtualResourceMetadataId,
Serializer.Serialize(_edtAssetSelectionControl.AssetSelectionData).ToString());
targetVirtualResource.VirtualResourceMetadataSet.Add(targetVirtualResourceMetadata);
totalActivities++;
}
targetScenario.VirtualResources.Add(targetVirtualResource);
}
context.EnterpriseScenarios.AddObject(targetScenario);
}
try
{
MessageBox.Show(
$"Found {totalActivities} activities to import. This might take few minutes to complete. Please be patient. Press OK to proceed.",
ApplicationName, MessageBoxButton.OK, MessageBoxImage.Information);
context.SaveChanges();
MessageBox.Show($"{exportedScenarios.Count} scenarios successfully imported.", ApplicationName,
MessageBoxButton.OK, MessageBoxImage.Information);
}
catch (SqlException sqlException)
{
MessageBox.Show($"Error occurred while importing the scenario. {ScalableTest.Extension.JoinAllErrorMessages(sqlException)}",
ApplicationName, MessageBoxButton.OK, MessageBoxImage.Error);
}
catch (UpdateException updateException)
{
MessageBox.Show($"Error occurred while importing the scenario. {ScalableTest.Extension.JoinAllErrorMessages(updateException)}",
ApplicationName, MessageBoxButton.OK, MessageBoxImage.Error);
}
catch (Exception e)
{
MessageBox.Show($"An unknown error occurred while importing scenario. {ScalableTest.Extension.JoinAllErrorMessages(e)}", ApplicationName, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
