/// <summary>
/// Retrieves a collection of output monitor destinations of the specified type.
/// </summary>
/// <param name="monitorType">The type of output monitor destinations to retrieve.</param>
/// <returns>A collection of output monitor destinations.</returns>
public IEnumerable <string> GetOutputMonitorDestinations(string monitorType)
{
STFMonitorType stfMonitorType = (STFMonitorType)Enum.Parse(typeof(STFMonitorType), monitorType);
Collection <string> result = new Collection <string>();
using (AssetInventoryContext context = DbConnect.AssetInventoryContext())
{
foreach (MonitorConfig monitorConfig in context.MonitorConfigs.Where(m => m.MonitorType == monitorType))
{
if (monitorConfig.Configuration.StartsWith("<OutputMonitorConfig"))
{
OutputMonitorConfig outputConfig = LegacySerializer.DeserializeXml <OutputMonitorConfig>(monitorConfig.Configuration);
if (stfMonitorType.Equals(STFMonitorType.OutputEmail) || stfMonitorType.Equals(STFMonitorType.DigitalSendNotification))
{
result.Add(outputConfig.MonitorLocation);
}
else
{
result.Add($@"\\{monitorConfig.ServerHostName}\{outputConfig.MonitorLocation}");
}
}
}
}
return(result);
}
/// <summary>
/// Initialise using the saved data
/// </summary>
/// <param name="entity"></param>
public override void Initialize(object entity)
{
_perfMonCollector = entity as PerfMonCollector;
if (_perfMonCollector == null)
{
throw new ControlTypeMismatchException(entity, typeof(PerfMonCollector));
}
//Bind to the controls that make sense
name_TextBox.DataBindings.Add("Text", _perfMonCollector, "Name");
PopulateServerList();
//browse throught the virtual resource metadata and add them to our listbox
foreach (VirtualResourceMetadata vmdata in _perfMonCollector.VirtualResourceMetadataSet)
{
PerfMonCounterData tempCounter = LegacySerializer.DeserializeXml <PerfMonCounterData>(vmdata.Metadata);
tempCounter.VirtualResourceMetadataId = vmdata.VirtualResourceMetadataId;
_selectedCountersDataList.Add(tempCounter);
}
platform_ComboBox.SetPlatform(_perfMonCollector.Platform, VirtualResourceType.PerfMonCollector);
LoadSystemSetting();
selectedCounters_DataGridView.DataSource = _selectedCountersDataList;
}
/// <summary>
/// Creates resource detail and inserts it into the manifest.
/// </summary>
/// <param name="resources">The resources.</param>
/// <param name="manifest">The manifest.</param>
internal override void AddToManifest(Collection <VirtualResource> resources, SystemManifest manifest)
{
var resource = resources.First();
MachineReservationDetail detail = manifest.Resources.GetResource <MachineReservationDetail>(resource.VirtualResourceId);
if (detail == null)
{
detail = CreateDetail(resource);
manifest.Resources.Add(detail);
}
// Add installers to the manifest that are specific to this instance of the Machine Reservation
MachineReservationMetadata metadata = LegacySerializer.DeserializeXml <MachineReservationMetadata>(resource.VirtualResourceMetadataSet.First().Metadata);
if (metadata.PackageId != Guid.Empty)
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
int i = 1;
foreach (var installer in SelectSoftwareInstallers(context, metadata.PackageId))
{
TraceFactory.Logger.Debug("Adding {0}".FormatWith(installer.Description));
manifest.SoftwareInstallers.Add(CreateSoftwareInstallerDetail(installer, i++));
}
}
}
}
/// <summary>
/// Dumps the subscribers list to a data file.
/// </summary>
public void SaveSubscriberData()
{
try
{
if (File.Exists(_dumpFile))
{
File.Delete(_dumpFile);
TraceFactory.Logger.Debug("Deleted {0}".FormatWith(_dumpFile));
}
lock (_lock)
{
if (_subscribers.Count > 0)
{
File.WriteAllText(_dumpFile, LegacySerializer.SerializeDataContract(_subscribers).ToString());
TraceFactory.Logger.Debug("Wrote out data for {0} subscribers".FormatWith(_subscribers.Count));
}
else
{
TraceFactory.Logger.Debug("Nothing to save...");
}
}
}
catch (Exception ex)
{
TraceFactory.Logger.Error("Unable to dump subscribers", ex);
}
}
/// <summary>
/// Saves the session data to a local cache.
/// </summary>
public void SessionDataSave()
{
TraceFactory.Logger.Debug("Saving proxy references and subscribers");
EventPublisher.SaveSubscriberData();
// Attempt to dump a cache file of the currently active sessions
try
{
if (File.Exists(_backupFile))
{
File.Delete(_backupFile);
TraceFactory.Logger.Debug("deleted {0}".FormatWith(_backupFile));
}
if (_proxyControllers.SessionIds.Count() > 0)
{
File.WriteAllText(_backupFile, LegacySerializer.SerializeDataContract(_proxyControllers).ToString());
TraceFactory.Logger.Debug("Wrote out {0} proxy entries".FormatWith(_proxyControllers.SessionIds.Count()));
}
else
{
TraceFactory.Logger.Debug("Nothing to save...");
}
}
catch (Exception ex)
{
TraceFactory.Logger.Error("Failed to write cache file", ex);
}
}
private VirtualResource CreateExpandedResource(Collection <ExpandedResourceMetadata> expandedData, int index)
{
// First clone this Load Tester resource, then clear it's metadata set.
VirtualResource resource = this.Clone <LoadTester>();
resource.VirtualResourceMetadataSet.Clear();
resource.Name = "{0} [{1}]".FormatWith(resource.Name, index);
// For each entry in the expanded set, get the metadata item from "this" by the id
// in the expanded set item, clone it, then update the thread count to the value
// in the expanded set item, then add the new metadata item to the resource. Do
// this for all items in the expanded data. Then return the resource.
foreach (var item in expandedData)
{
var metadata = VirtualResourceMetadataSet.First(x => x.VirtualResourceMetadataId == item.Id).Clone();
// Update the execution plan with the correct number of threads and update it with
// the property thread ramp up information.
var plan = LegacySerializer.DeserializeDataContract <LoadTesterExecutionPlan>(metadata.ExecutionPlan);
plan.ThreadCount = item.ThreadCount;
plan.RampUpSettings = new Collection <RampUpSetting>();
foreach (var setting in item.RampUpSettings)
{
plan.RampUpSettings.Add(setting);
}
metadata.ExecutionPlan = LegacySerializer.SerializeDataContract(plan).ToString();
resource.VirtualResourceMetadataSet.Add(metadata);
}
return(resource);
}
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);
}
}
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);
}
}
public ScenarioSelectionItem(EnterpriseScenario scenario)
{
ScenarioId = scenario.EnterpriseScenarioId;
Name = scenario.Name;
EstimatedRunTime = scenario.EstimatedRuntime;
// ScenarioSettings override the default
if (!string.IsNullOrEmpty(scenario.ScenarioSettings))
{
ScenarioSettings settings = LegacySerializer.DeserializeDataContract <ScenarioSettings>(scenario.ScenarioSettings);
EstimatedRunTime = settings.EstimatedRunTime;
}
}
private void LoadStoredCalculatedSeries()
{
// Pull the saved calculated series out of the user settings
var allStoredSeries = LegacySerializer.DeserializeXml <Collection <StoredCalculatedSeries> >(Settings.Default.CalculatedSeries);
StoredCalculatedSeries storedSeries = allStoredSeries.FirstOrDefault(n => n.SessionId == _sessionId && n.GraphName == this.GraphName);
if (storedSeries != null)
{
_calculatedSeries.Clear();
_calculatedSeries.AddRange(storedSeries.Series);
}
}
/// <summary>
/// Requests that the control finalize any edits that have been made by saving
/// them from the UI controls to their backing objects.
/// </summary>
public override void FinalizeEdit()
{
// Change the focused control so that data bindings will update
name_Label.Focus();
var metadata = _reservation.VirtualResourceMetadataSet.First();
if (_reservationData.PackageId != LegacySerializer.DeserializeXml <MachineReservationMetadata>(metadata.Metadata).PackageId)
{
metadata.Metadata = LegacySerializer.SerializeXml(_reservationData).ToString();
}
}
/// <summary>
/// reads the performance counters from the manifest
/// </summary>
/// <param name="perfResources"></param>
private void ReadManifest(IEnumerable <ResourceDetailBase> perfResources)
{
_perfMonCounters = new ObservableCollection <PerfMonCounterData>();
foreach (var perfResource in perfResources)
{
foreach (var data in perfResource.MetadataDetails)
{
var tempCounterData = LegacySerializer.DeserializeXml <PerfMonCounterData>(data.Data);
_perfMonCounters.Add(tempCounterData);
}
}
}
/// <summary>
/// Loads the session data from a local cache
/// </summary>
public void SessionDataLoad()
{
TraceFactory.Logger.Debug("Loading proxy references and subscribers");
EventPublisher.LoadSubscriberData();
// If there is a proxy entries cache file, load it and process it.
if (File.Exists(_backupFile))
{
TraceFactory.Logger.Debug("Cache file exists, loading");
var proxies = LegacySerializer.DeserializeDataContract <SessionProxyControllerSet>(File.ReadAllText(_backupFile));
// If the number of entries is greater than the max, then we need to adjust
// the max to account for all entries.
if (proxies.Count > _proxyControllers.Maximum)
{
_proxyControllers = new SessionProxyControllerSet(proxies.Count);
}
// Create a new entry in the proxie entries and then tell the proxy
// entry to refresh all subscribers.
foreach (var proxy in proxies.Values)
{
try
{
proxy.Channel.Ping();
_proxyControllers.Add(proxy);
TraceFactory.Logger.Debug("Endpoint reloaded for {0}".FormatWith(proxy.SessionId));
}
catch (EndpointNotFoundException ex)
{
TraceFactory.Logger.Debug("Endpoint skipped for {0}:{1}".FormatWith(proxy.SessionId, ex.Message));
}
}
try
{
File.Delete(_backupFile);
TraceFactory.Logger.Debug("deleted {0}".FormatWith(_backupFile));
}
catch (Exception ex)
{
TraceFactory.Logger.Error("Error deleting saved proxies file", ex);
}
}
else
{
TraceFactory.Logger.Debug("Nothing to load...");
}
}
/// <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 LoadDateTimeSettings()
{
// Load the serialized settings list
string serializedSettingsList = Properties.Settings.Default.DateFormats;
var settingsList = LegacySerializer.DeserializeXml <Collection <GraphDateTimeSettings> >(serializedSettingsList);
// Find the settings that apply to this graph
GraphDateTimeSettings settings = settingsList.FirstOrDefault(n => n.GraphType == this.GetType().Name.ToString());
if (settings == null)
{
settings = new GraphDateTimeSettings(this);
}
ApplyDateTimeSettings(settings);
}
private void StoreCalculatedSeries()
{
// Load the saved calculated series so we can update it
var allStoredSeries = LegacySerializer.DeserializeXml <Collection <StoredCalculatedSeries> >(Settings.Default.CalculatedSeries);
StoredCalculatedSeries storedSeries = allStoredSeries.FirstOrDefault(n => n.SessionId == _sessionId && n.GraphName == this.GraphName);
if (storedSeries == null)
{
storedSeries = new StoredCalculatedSeries(_sessionId, this.GraphName);
allStoredSeries.Add(storedSeries);
}
storedSeries.Series.Clear();
_calculatedSeries.ForEach(n => storedSeries.Series.Add(n));
Settings.Default.CalculatedSeries = LegacySerializer.SerializeXml(allStoredSeries).ToString();
Settings.Default.Save();
}
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]);
}
}
/// <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)
{
_eventLogCollector = entity as EventLogCollector;
if (_eventLogCollector == null)
{
throw new ControlTypeMismatchException(entity, typeof(EventLogCollector));
}
ServerInfo server = ConfigurationServices.AssetInventory.GetServers().FirstOrDefault(n => n.HostName == _eventLogCollector.HostName);
if (server != null)
{
serverComboBox.Initialize(server, "EventLog");
}
else
{
serverComboBox.Initialize("EventLog");
}
platform_ComboBox.SetPlatform(_eventLogCollector.Platform, VirtualResourceType.EventLogCollector);
// Set up data bindings
name_TextBox.DataBindings.Add("Text", _eventLogCollector, "Name");
description_TextBox.DataBindings.Add("Text", _eventLogCollector, "Description");
platform_ComboBox.DataBindings.Add("SelectedValue", _eventLogCollector, "Platform");
Binding intervalBinding = new Binding("Text", _eventLogCollector, "PollingInterval");
intervalBinding.Format += new ConvertEventHandler(IntervalBinding_Format);
intervalBinding.Parse += new ConvertEventHandler(IntervalBinding_Parse);
interval_TextBox.DataBindings.Add(intervalBinding);
serverComboBox_SelectionChanged(serverComboBox, EventArgs.Empty);
SelectedComponents = LegacySerializer.DeserializeXml <List <string> >(_eventLogCollector.ComponentsData);
SelectedEntryTypes = LegacySerializer.DeserializeXml <List <string> >(_eventLogCollector.EntryTypesData);
if (platform_ComboBox.SelectedIndex == -1) //Default to first item if platform isn't set
{
platform_ComboBox.SelectedIndex = 0;
}
serverComboBox.SelectionChanged += serverComboBox_SelectionChanged;
}
/// <summary>
/// Requests that the control finalize any edits that have been made by saving
/// them from the UI controls to their backing objects.
/// </summary>
public override void FinalizeEdit()
{
// Modify focus so that any data bindings will update
name_TextBox.Focus();
// Push the configuration data into the ExecutionPlan property of the metadata
foreach (var item in _loadTester.VirtualResourceMetadataSet)
{
if (string.IsNullOrEmpty(item.ExecutionPlan))
{
var configItem = _configurations.FirstOrDefault(e => e.Metadata.VirtualResourceMetadataId == item.VirtualResourceMetadataId);
if (configItem != null)
{
item.ExecutionPlan = LegacySerializer.SerializeDataContract(configItem.ExecutionPlan).ToString();
}
}
else
{
// Entity Framework handles all situations where no fields have changed, except serialized XML.
// So to ensure this form doesn't think something has changed when it hasn't, only update
// the serialized XML if there is actually a change.
XDocument oldPlan = XDocument.Parse(item.ExecutionPlan);
var configItem = _configurations.FirstOrDefault(e => e.Metadata.VirtualResourceMetadataId == item.VirtualResourceMetadataId);
if (configItem != null)
{
string serializedPlan = LegacySerializer.SerializeDataContract(configItem.ExecutionPlan).ToString();
XDocument newPlan = XDocument.Parse(serializedPlan);
if (!XmlUtil.AreEqual(oldPlan, newPlan, orderInvariant: true))
{
item.ExecutionPlan = serializedPlan;
}
}
}
}
if (GlobalSettings.IsDistributedSystem)
{
// Need to grab the platform directly from the combobox
_loadTester.Platform = ((FrameworkClientPlatform)virtualMachinePlatform_ComboBox.SelectedItem).FrameworkClientPlatformId;
}
}
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 importToolStripButton_Click(object sender, EventArgs e)
{
using (var dialog = new ExportOpenFileDialog(_directory, "Open STB Device Export File", ImportExportType.Printer))
{
if (dialog.ShowDialog() == DialogResult.OK)
{
var file = dialog.Base.FileName;
_directory = Path.GetDirectoryName(file);
using (AssetInventoryContext context = DbConnect.AssetInventoryContext())
{
var contracts = LegacySerializer.DeserializeDataContract <AssetContractCollection <PrinterContract> >(File.ReadAllText(file));
foreach (var contract in contracts)
{
var printer = ContractFactory.Create(contract, context);
AddPrinter(printer);
}
}
}
}
}
/// <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)
{
_adminWorker = entity as AdminWorker;
if (_adminWorker == null)
{
throw new ControlTypeMismatchException(entity, typeof(AdminWorker));
}
// Load the configurations into the helper class
foreach (var item in _adminWorker.VirtualResourceMetadataSet)
{
WorkerExecutionPlan plan = null;
if (item.ExecutionPlan == null)
{
plan = new WorkerExecutionPlan();
}
else
{
plan = LegacySerializer.DeserializeDataContract <WorkerExecutionPlan>(item.ExecutionPlan);
}
_mainConfigurations.Add(new WorkerActivityConfiguration(item, plan));
}
// Load the activities into the binding list
activity_TabControl.SelectTab(main_TabPage);
_selectedPhase = ResourceExecutionPhase.Main;
activity_GridView.BestFitColumns();
// Set up data bindings
name_TextBox.DataBindings.Add("Text", _adminWorker, "Name");
description_TextBox.DataBindings.Add("Text", _adminWorker, "Description");
platform_ComboBox.SetPlatform(_adminWorker.Platform, VirtualResourceType.AdminWorker);
testcaseid_numericUpDown.Value = _adminWorker.TestCaseId;
ConfigureEnableAllButton();
CreateActivityDropDownMenu();
RefreshGrid();
}
/// <summary>
/// Opens the specified path.
/// </summary>
/// <param name="path">The path.</param>
public Collection <QueueInstallationData> Open(string path)
{
SaveData saveData = null;
try
{
saveData = LegacySerializer.DeserializeXml <SaveData>(File.ReadAllText(path));
}
catch (ArgumentException ex)
{
throw new QueueInstallException("Failed top open file", ex);
}
catch (IOException ex)
{
throw new QueueInstallException("Failed top open file", ex);
}
catch (UnauthorizedAccessException ex)
{
throw new QueueInstallException("Failed top open file", ex);
}
catch (NotSupportedException ex)
{
throw new QueueInstallException("Failed top open file", ex);
}
catch (SecurityException ex)
{
throw new QueueInstallException("Failed top open file", ex);
}
_printDrivers.Clear();
foreach (string key in saveData.LoadedPackages.Keys)
{
_printDrivers.Add(key, saveData.LoadedPackages[key]);
}
UseConfigurationFile = saveData.PreConfigure;
AdditionalDescription = saveData.PreConfigureText;
return(saveData.InstallData);
}
private void importToolStripButton_Click(object sender, EventArgs e)
{
try
{
using (var dialog = new ExportOpenFileDialog(_directory, "Open Test Document Export File", ImportExportType.Document))
{
if (dialog.ShowDialog() == DialogResult.OK)
{
var file = dialog.Base.FileName;
_directory = Path.GetDirectoryName(file);
var contracts = LegacySerializer.DeserializeDataContract <DocumentContractCollection>(File.ReadAllText(file));
foreach (var contract in contracts)
{
if (!_context.TestDocuments.Any(x => x.FileName.Equals(contract.FileName, StringComparison.OrdinalIgnoreCase)))
{
var document = ContractFactory.Create(_context, contract);
_importedDocumentData.Add(document.TestDocumentId, contract.Data);
AddDocument(document);
}
else
{
// Log an error for the current file, but keep going
TraceFactory.Logger.Debug("Document already exists: {0}".FormatWith(contract.FileName));
}
}
MessageBox.Show("Documents have been imported", "Import Documents", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
catch (Exception ex)
{
TraceFactory.Logger.Error(ex);
MessageBox.Show("Error importing document: {0}. Check log file for more details.".FormatWith(ex.Message));
}
}
private void timeOptions_ToolStripMenuItem_Click(object sender, EventArgs e)
{
// Load the serialized settings list
string serializedSettingsList = Properties.Settings.Default.DateFormats;
var settingsList = LegacySerializer.DeserializeXml <Collection <GraphDateTimeSettings> >(serializedSettingsList);
// Find the settings that apply to this graph
GraphDateTimeSettings settings = settingsList.FirstOrDefault(n => n.GraphType == this.GetType().Name.ToString());
if (settings == null)
{
settings = new GraphDateTimeSettings(this);
settingsList.Add(settings);
}
settings.ShowDate = showDate_ToolStripMenuItem.Checked;
settings.Use24Hour = use24HourTime_ToolStripMenuItem.Checked;
settings.ShowAMPM = showAMPM_ToolStripMenuItem.Checked;
ApplyDateTimeSettings(settings);
Properties.Settings.Default.DateFormats = LegacySerializer.SerializeXml(settingsList).ToString();
Properties.Settings.Default.Save();
}
/// <summary>
/// Loads the subscribers list from a data file.
/// </summary>
public void LoadSubscriberData()
{
if (!File.Exists(_dumpFile))
{
TraceFactory.Logger.Debug("Nothing to load...");
return;
}
lock (_lock)
{
_subscribers = LegacySerializer.DeserializeDataContract <Collection <Uri> >(File.ReadAllText(_dumpFile));
}
TraceFactory.Logger.Debug("Loaded {0} subscribers".FormatWith(_subscribers.Count));
try
{
File.Delete(_dumpFile);
TraceFactory.Logger.Debug("Deleted {0}".FormatWith(_dumpFile));
}
catch (Exception ex)
{
TraceFactory.Logger.Error("Error deleting saved subscriber file", ex);
}
}
public WorkerScheduledExecutionForm(string scheduleXml)
{
InitializeComponent();
UserInterfaceStyler.Configure(this, FormStyle.FixedDialog);
errorProvider.SetIconAlignment(hourMin_Label, ErrorIconAlignment.MiddleRight);
if (!string.IsNullOrEmpty(scheduleXml))
{
try
{
_bindingList.Clear();
_schedule = LegacySerializer.DeserializeXml <ExecutionSchedule>(scheduleXml);
_bindingList = _schedule.BindingList;
}
catch (XmlException ex)
{
TraceFactory.Logger.Error("Bad XML in Run Schedule", ex);
MessageBox.Show
(
"Unable to load existing schedule information.",
"Load Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
}
}
else
{
_schedule = new ExecutionSchedule();
}
dataGridViewCheckBoxColumn1.HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
dataGridViewTextBoxColumn2.HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
dataGridViewTextBoxColumn3.HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
dataGridViewTextBoxColumn4.HeaderCell.Style.Alignment = DataGridViewContentAlignment.MiddleCenter;
}
/// <summary>
/// Requests that the control finalize any edits that have been made by saving
/// them from the UI controls to their backing objects.
/// </summary>
public override void FinalizeEdit()
{
// Modify focus so that any data bindings will update
name_Label.Focus();
// Update the host name
_eventLogCollector.HostName = serverComboBox.SelectedServer.HostName;
// Only assign these properties if the selected values have changed.
// This will avoid unnecessary "unsaved changes" prompts.
List <string> originalComponents = LegacySerializer.DeserializeXml <List <string> >(_eventLogCollector.ComponentsData);
if (!AreEqual(originalComponents, SelectedComponents))
{
_eventLogCollector.ComponentsData = LegacySerializer.SerializeXml(SelectedComponents).ToString();
}
List <string> originalEntryTypes = LegacySerializer.DeserializeXml <List <string> >(_eventLogCollector.EntryTypesData);
if (!AreEqual(originalEntryTypes, SelectedEntryTypes))
{
_eventLogCollector.EntryTypesData = LegacySerializer.SerializeXml(SelectedEntryTypes).ToString();
}
}
/// <summary>
/// Exports the AssetContractCollection to a file with the specified file name.
/// </summary>
/// <param name="fileName"></param>
public void Export(string fileName)
{
File.WriteAllText(fileName, LegacySerializer.SerializeDataContract(this).ToString());
}
private void LoadComboBoxes(EnterpriseTestContext context)
{
sessionName_ComboBox.DataSource = ResourceWindowsCategory.Select(context, ResourceWindowsCategoryType.SessionName.ToString());
sessionName_ComboBox.SelectedIndex = -1;
sessionType_ComboBox.DataSource = ResourceWindowsCategory.Select(context, ResourceWindowsCategoryType.SessionType.ToString());
sessionType_ComboBox.SelectedIndex = -1;
sessionCycle_ComboBox.DataSource = ResourceWindowsCategory.Select(context, ResourceWindowsCategoryType.SessionCycle.ToString());
retention_ComboBox.DataSource = SessionLogRetentionHelper.ExpirationList;
retention_ComboBox.SelectedIndex = retention_ComboBox.FindString(EnumUtil.GetDescription(WizardPageManager.GetDefaultLogRetention()));
Dictionary <string, int> failureItems = new Dictionary <string, int>();
List <TimeSpan> failTimes = new List <TimeSpan>();
using (AssetInventoryContext assetContext = DbConnect.AssetInventoryContext())
{
string powerState = EnumUtil.GetDescription(VMPowerState.PoweredOff);
var availableVMs = assetContext.FrameworkClients.Where(n => n.PowerState == powerState);
platform_ComboBox.DataSource = null;
platform_ComboBox.Items.Clear();
platform_ComboBox.DisplayMember = "Name";
platform_ComboBox.ValueMember = "FrameworkClientPlatformId";
platform_ComboBox.DataSource = assetContext.FrameworkClientPlatforms.Where(n => n.Active).OrderBy(n => n.FrameworkClientPlatformId).ToList();
holdId_ComboBox.DataSource = null;
holdId_ComboBox.Items.Clear();
holdId_ComboBox.DataSource = availableVMs.Select(n => n.HoldId).Distinct().Where(n => n != null).ToList();
}
failureItems.Add("1 Failure", 1);
failureItems.Add("2 Failures", 2);
failureItems.Add("5 Failures", 5);
failureItems.Add("10 Failures", 10);
failureItems.Add("15 Failures", 15);
failureItems.Add("20 Failures", 20);
threshold_comboBox.DataSource = new BindingSource(failureItems, null);
threshold_comboBox.DisplayMember = "Key";
threshold_comboBox.ValueMember = "Value";
failTimes.Add(TimeSpan.FromMinutes(15));
failTimes.Add(TimeSpan.FromMinutes(30));
failTimes.Add(TimeSpan.FromHours(1));
failTimes.Add(TimeSpan.FromHours(2));
failTimes.Add(TimeSpan.FromHours(6));
failTimes.Add(TimeSpan.FromHours(12));
failureTime_comboBox.DataSource = new BindingSource(failTimes, null);
if (Ticket.SessionId != null && _scenario != null)
{
if (!string.IsNullOrEmpty(_scenario.ScenarioSettings))
{
var scenarioSettings = LegacySerializer.DeserializeDataContract <ScenarioSettings>(_scenario.ScenarioSettings);
//Populate boxes from selected settings
dartLog_CheckBox.Checked = scenarioSettings.NotificationSettings.CollectDartLogs;
email_textBox.Text = scenarioSettings.NotificationSettings.Emails;
failureTime_comboBox.SelectedIndex = failTimes.FindIndex(x => x == scenarioSettings.NotificationSettings.FailureTime);
threshold_comboBox.SelectedIndex = failureItems.ToList().FindIndex(x => x.Value == scenarioSettings.NotificationSettings.FailureCount);
triggerList_TextBox.Lines = scenarioSettings.NotificationSettings.TriggerList;
runtime_NumericUpDown.Value = Math.Min(scenarioSettings.EstimatedRunTime, runtime_NumericUpDown.Maximum); // scenarioSettings.EstimatedRunTime;
logLocation_TextBox.Text = scenarioSettings.LogLocation;
eventLog_CheckBox.Checked = scenarioSettings.CollectEventLogs;
}
sessionName_ComboBox.Text = string.IsNullOrEmpty(Ticket.SessionName) ? _scenario.Name : Ticket.SessionName;
}
//TraceFactory.Logger.Debug($"initial:{_initial}");
if (!_initial)
{
sessionType_ComboBox.SelectedText = Ticket.SessionType;
sessionCycle_ComboBox.SelectedIndex = ResourceWindowsCategory.Select(context, ResourceWindowsCategoryType.SessionCycle.ToString()).Select(x => x.Name).ToList().IndexOf(Ticket.SessionCycle);
//TraceFactory.Logger.Debug($"email:{_ticket.EmailAddresses}");
if (!string.IsNullOrEmpty(Ticket.EmailAddresses))
{
dartLog_CheckBox.Checked = Ticket.CollectDARTLogs;
email_textBox.Text = Ticket.EmailAddresses;
failureTime_comboBox.SelectedIndex = failTimes.FindIndex(x => x == Ticket.FailureTime);
threshold_comboBox.SelectedIndex = failureItems.ToList().FindIndex(x => x.Value == Ticket.FailureCount);
triggerList_TextBox.Lines = Ticket.TriggerList;
runtime_NumericUpDown.Value = Math.Min(Ticket.DurationHours, runtime_NumericUpDown.Maximum);
eventLog_CheckBox.Checked = Ticket.CollectEventLogs;
email_textBox.Text = Ticket.EmailAddresses;
}
if (Ticket.FailureTime != TimeSpan.MaxValue)
{
failureTime_comboBox.SelectedIndex = failTimes.FindIndex(x => x == Ticket.FailureTime);
}
if (Ticket.FailureCount != -1)
{
threshold_comboBox.SelectedIndex = failureItems.ToList().FindIndex(x => x.Value == Ticket.FailureCount);
}
if (!string.IsNullOrEmpty(Ticket.LogLocation))
{
logLocation_TextBox.Text = Ticket.LogLocation;
}
if (Ticket.TriggerList != null)
{
triggerList_TextBox.Lines = Ticket.TriggerList;
}
dartLog_CheckBox.Checked = Ticket.CollectDARTLogs;
eventLog_CheckBox.Checked = Ticket.CollectEventLogs;
runtime_NumericUpDown.Value = Math.Min(Ticket.DurationHours, runtime_NumericUpDown.Maximum);
}
}
