//---------------------------------------------------------------------
private void overrideTargetEditor_Load(object sender, EventArgs e)
{
if (m_overrideContextInstance == null)
{
allInstancesRadioButton.Checked = true;
}
else
{
PartialMonitoringObject monitoringObject;
monitoringObject = m_managementGroup.GetPartialMonitoringObject((Guid)m_overrideContextInstance);
m_isContextCurrentlyGroup = IsGroup(monitoringObject);
if (m_isContextCurrentlyGroup)
{
groupRadioButton.Checked = true;
groupsComboBox.Items.Clear();
groupsComboBox.Items.Add(monitoringObject);
groupsComboBox.SelectedItem = monitoringObject;
}
else
{
instanceRadioButton.Checked = true;
instancesComboBox.Items.Clear();
instancesComboBox.Items.Add(monitoringObject);
groupsComboBox.SelectedItem = monitoringObject;
}
m_currentMonitoringObject = monitoringObject;
}
}
/// <summary>
/// Inserts the performance data.
/// </summary>
/// <param name="unionId">The union identifier.</param>
/// <param name="objectName">Name of the object.</param>
/// <param name="realTimeData">The real time data.</param>
public void InsertPerformanceData(string unionId, string objectName, ServerRealTimePerformance realTimeData)
{
PartialMonitoringObject obj = this.GetObjectByUnionId(this.ServerClass, unionId);
if (obj == null)
{
return;
}
var cpuUsage = realTimeData.PercentItems.CPUUsagePercent.FirstOrDefault();
if (cpuUsage?.Value != null)
{
var cpuUsageData = new CustomMonitoringPerformanceData(objectName, "CPUUsagePercent", cpuUsage.Value.Value);
obj.InsertCustomMonitoringPerformanceData(cpuUsageData);
}
var powerConsumedWatts = realTimeData.PercentItems.PowerConsumedWatts.FirstOrDefault();
if (powerConsumedWatts?.Value != null)
{
var powerConsumedWattsData = new CustomMonitoringPerformanceData(objectName, "PowerConsumedWatts", powerConsumedWatts.Value.Value);
obj.InsertCustomMonitoringPerformanceData(powerConsumedWattsData);
}
var inletTemp = realTimeData.PercentItems.InletTemp.FirstOrDefault();
if (inletTemp?.Value != null)
{
var inletTempData = new CustomMonitoringPerformanceData(objectName, "InletTemp", inletTemp.Value.Value);
obj.InsertCustomMonitoringPerformanceData(inletTempData);
}
}
public ICollection GetSelection()
{
Dbg.Log($"Entering {MethodBase.GetCurrentMethod().Name}");
if (Grid.SelectedCells.Count == 0)
{
return(null);
}
List <object> result = new List <object>();
foreach (DataGridViewRow selectedRow in Grid.SelectedRows)
{
if (selectedRow.Cells[0].Tag != null)
{
InstanceState dataItem = (InstanceState)(selectedRow.Cells[0].Tag as GridDataItem).DataItem;
if (QueryCache.Query is StateQuery query && query.ManagementGroup != null)
{
PartialMonitoringObject monitoringObject = dataItem.GetCachedPartialMonitoringObject(query.ManagementGroup);
if (monitoringObject != null)
{
result.Add(monitoringObject);
}
}
}
}
return(new ReadOnlyCollection <object>(result));
}
protected override void OnMasterViewSelectedObjectChange(PartialMonitoringObject monitoringObjectContext)
{
CurrentParentId = monitoringObjectContext.Id;
RegisteredCommand refreshCommand = CommandService.Find(ViewCommands.Refresh);
refreshCommand?.Invoke(this, this, null);
}
public void InsertAlert()
{
var eSightHost = "192.168.0.2";
var objects = OM12Connection.Query <PartialMonitoringObject>(ESightAppliance.EntityClassName, $"Host='{eSightHost}'");
PartialMonitoringObject p = (PartialMonitoringObject)objects.First();
//OM12Connection.HuaweiESightMG.GetMonitoringAlert();
}
private void GetSharedUserData()
{
this.ASBNamespaceName = base.SharedUserData["ASBNamespaceDetails.ASBNamespaceName"] as string;
this.runAsName = base.SharedUserData["ASBNamespaceDetails.RunAsName"] as string;
this.runAsSsid = base.SharedUserData["ASBNamespaceDetails.RunAsSsid"] as byte[];
this.proxyAgentComputer = this.GetProxyAgentComputer(this.proxyAgentBrowseTextBox.Text);
}
//---------------------------------------------------------------------
internal static List <MPOverride> RetrieveDiscoveryOverrides(
PartialMonitoringObject monitoringObject,
Dictionary <Guid, MonitoringClass> typeLookupTable
)
{
return(GenerateEffectiveOverrrideList(monitoringObject,
monitoringObject.GetMonitoringDiscoveries(new MonitoringDiscoveryCriteria("HasNonCategoryOverride=1")),
typeLookupTable));
}
//---------------------------------------------------------------------
private void changeTargetMenuItem_Click(
object sender,
EventArgs e
)
{
try
{
if (SelectedItems.Count == 0)
{
return;
}
MPOverride mpOverride = ((OverrideInfo)SelectedItems[0].Tag).m_override;
if (mpOverride.ManagementPackOverride.GetManagementPack().Sealed)
{
MessageBox.Show("Its not possible to modify an override that is defined in a sealed MP");
return;
}
MPClass mpClass = mpOverride.Target;
OverrideTargetEditor targetEditor;
targetEditor = new OverrideTargetEditor(m_managementGroup,
mpClass.ManagementPackClass,
mpOverride.ManagementPackOverride.ContextInstance);
if (targetEditor.ShowDialog(this) == DialogResult.OK)
{
if (targetEditor.IsInstanceContext)
{
PartialMonitoringObject context = targetEditor.InstanceContext;
IList <ManagementPackClass> contextClasses = context.GetMostDerivedClasses();
//TODO - dmuscett 2012/11/19 - this works for custom groups, but what for non-groups?
// Are we practically changing the override to a most specific one? Need more testing...
mpOverride.ManagementPackOverride.Context = contextClasses[contextClasses.Count - 1];
mpOverride.ManagementPackOverride.ContextInstance = context.Id;
}
else
{
mpOverride.ManagementPackOverride.ContextInstance = null;
}
mpOverride.ManagementPackOverride.Status = ManagementPackElementStatus.PendingUpdate;
mpOverride.ManagementPackOverride.GetManagementPack().AcceptChanges();
}
}
catch (Microsoft.EnterpriseManagement.Common.ManagementPackException exception)
{
MessageBox.Show(exception.Message);
}
}
//---------------------------------------------------------------------
internal static string GetBestMonitoringObjectName(
PartialMonitoringObject monitoringObject
)
{
if (monitoringObject.DisplayName != null && monitoringObject.DisplayName.Length > 0)
{
return(monitoringObject.DisplayName);
}
else
{
return(monitoringObject.Name);
}
}
//---------------------------------------------------------------------
internal static List <MPOverride> RetrieveMonitorOverrides(
PartialMonitoringObject monitoringObject,
Dictionary <Guid, MonitoringClass> typeLookupTable
)
{
List <ManagementPackMonitor> monitors = new List <ManagementPackMonitor>();
RetrieveApplicableMonitors(monitoringObject, monitors, null);
return(GenerateEffectiveOverrrideList(monitoringObject,
new ReadOnlyCollection <ManagementPackMonitor>(monitors),
typeLookupTable));
}
//---------------------------------------------------------------------
internal static string GetBestMonitoringObjectName(
PartialMonitoringObject monitoringObject
)
{
if (monitoringObject.DisplayName != null && monitoringObject.DisplayName.Length > 0)
{
return (monitoringObject.DisplayName);
}
else
{
return (monitoringObject.Name);
}
}
//---------------------------------------------------------------------
private static List <MPOverride> GenerateEffectiveOverrrideList(
PartialMonitoringObject monitoringObject,
ReadOnlyCollection <ManagementPackMonitor> monitors,
Dictionary <Guid, MonitoringClass> typeLookupTable
)
{
List <MPOverride> overrides = new List <MPOverride>();
foreach (ManagementPackMonitor monitor in monitors)
{
// if we do this check which I commented out, it only works for Windows computer, not for linux ones...
// I am not sure why the check was done in the first place... what was it preventing from doing?
// was it just an optimization to speed things up, or was it protecting the UI from dealing with some weird monitors?
//if (!DoesMonitorHaveNonCategoryOverride(monitor))
//{
// continue;
//}
MonitorResultantOverrideSet overrideSet = monitoringObject.GetResultantOverrides(monitor);
MPWorkflow workflow = new MPWorkflow(monitor);
foreach (ResultantOverride <MonitorConfigurationOverride> monitorOverride in overrideSet.ResultantConfigurationOverrides.Values)
{
MonitoringClass target = typeLookupTable[monitor.Target.Id];
workflow.AddOverride(monitorOverride.EffectiveOverride);
MPOverride mpOverride = new MPOverride(monitorOverride.EffectiveOverride,
workflow,
new MPClass(target));
overrides.Add(mpOverride);
}
foreach (ResultantOverride <ManagementPackOverride> monitorOverride in overrideSet.ResultantPropertyOverrides.Values)
{
MonitoringClass target = typeLookupTable[monitor.Target.Id];
workflow.AddOverride(monitorOverride.EffectiveOverride);
MPOverride mpOverride = new MPOverride(monitorOverride.EffectiveOverride,
workflow,
new MPClass(target));
overrides.Add(mpOverride);
}
}
return(overrides);
}
/// <summary>
/// Inserts the device change event.
/// </summary>
/// <param name="mpClass">The mp class.</param>
/// <param name="deviceChangeEventData">The device change event data.</param>
public void InsertDeviceChangeEvent(ManagementPackClass mpClass, DeviceChangeEventData deviceChangeEventData)
{
try
{
MGroup.Instance.CheckConnection();
PartialMonitoringObject obj = this.GetNewReadyObject(mpClass, deviceChangeEventData.DeviceId);
obj.InsertCustomMonitoringEvent(deviceChangeEventData.ToCustomMonitoringEvent());
}
catch (Exception ex)
{
HWLogger.SERVICE.Error(ex);
throw;
}
}
/// <summary>
/// Gets the full parent object.
/// </summary>
/// <param name="obj">The object.</param>
/// <returns>PartialMonitoringObject.</returns>
protected MonitoringObject GetFullParentObject(PartialMonitoringObject obj)
{
var group = obj.GetParentPartialMonitoringObjects();
if (group.Any())
{
var parent = group.First();
var t = parent.GetParentMonitoringObjects();
if (t.Any())
{
return(t.First());
}
}
return(null);
}
private List <MPOverride> RetrieveEffectiveOverridesForMonitoringObject(
PartialMonitoringObject monitoringObject
)
{
List <MPOverride> overrides = new List <MPOverride>();
overrides.AddRange(Common.RetrieveRuleOverrides(monitoringObject,
m_overridesInfo.Types,
m_overridesInfo.TypeToRuleTable));
overrides.AddRange(Common.RetrieveMonitorOverrides(monitoringObject,
m_overridesInfo.Types));
overrides.AddRange(Common.RetrieveDiscoveryOverrides(monitoringObject,
m_overridesInfo.Types));
return(overrides);
}
private bool RunAsAccountDistributionDialog()
{
byte[] runAsSsid = base.SharedUserData["SBWSNamespaceDetails.RunAsSsid"] as byte[];
string runAsName = base.SharedUserData["SBWSNamespaceDetails.RunAsName"] as string;
sbwsHostComputer = GetSBWSHostComputer(this.sbwsHostNameBrowseTextBox.Text);
SecureData securedData = base.ManagementGroup.Security.GetSecureData(runAsSsid);
if (securedData == null)
{
return(false);
}
IApprovedHealthServicesForDistribution <PartialMonitoringObject> newState = base.ManagementGroup.Security.GetApprovedHealthServicesForDistribution <PartialMonitoringObject>(securedData);
if (newState == null)
{
return(false);
}
bool flag2 = newState.Result.Equals(ApprovedHealthServicesResults.All) || newState.HealthServices.Contains(sbwsHostComputer);
if (!flag2)
{
string text = string.Empty;
StringBuilder builder = new StringBuilder();
if (!flag2)
{
builder.AppendLine(runAsName);
}
//TODO: Fix this language
text = string.Format("To enable discovery of the queues/topics/subscriptions on Service Bus for Windows Server Namespace <{0}>, the following Run As account must be distributed to the health service '{1}':\n\n{2}\n\nWould you like Operations Manager to distribute the accounts?", this.sbwsNamespaceNameTextBox.Text, this.sbwsHostComputer.DisplayName, builder.ToString());
if (MessageBox.Show(base.ParentForm, text, "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) != DialogResult.Yes)
{
return(false);
}
if (!flag2)
{
newState.Result = ApprovedHealthServicesResults.Specified;
newState.HealthServices.Add(sbwsHostComputer);
base.ManagementGroup.Security.SetApprovedHealthServicesForDistribution <PartialMonitoringObject>(securedData, newState);
}
}
return(true);
}
//---------------------------------------------------------------------
private static List <MonitoringDiscoveryResultantOverrideSet> RetrieveDiscoveryOverrides(
PartialMonitoringObject monitoringObject
)
{
ReadOnlyCollection <MonitoringDiscovery> discoveries;
List <MonitoringDiscoveryResultantOverrideSet> listOfOverrides;
listOfOverrides = new List <MonitoringDiscoveryResultantOverrideSet>();
discoveries = monitoringObject.GetMonitoringDiscoveries(new MonitoringDiscoveryCriteria("HasNonCategoryOverride=1"));
foreach (MonitoringDiscovery discovery in discoveries)
{
listOfOverrides.Add(monitoringObject.GetResultantOverrides(discovery));
}
return(listOfOverrides);
}
//---------------------------------------------------------------------
private static void RetrieveApplicableMonitors(
PartialMonitoringObject monitoringObject,
List <ManagementPackMonitor> monitors,
MonitoringHierarchyNode <ManagementPackMonitor> hierarchyNode
)
{
if (hierarchyNode == null)
{
hierarchyNode = monitoringObject.GetMonitorHierarchy();
monitors.Add(hierarchyNode.Item);
}
foreach (MonitoringHierarchyNode <ManagementPackMonitor> node in hierarchyNode.ChildNodes)
{
monitors.Add(node.Item);
RetrieveApplicableMonitors(monitoringObject, monitors, node);
}
}
/// <summary>
/// 判断首次插入事件是否成功
/// 首次安装后 第一次插入事件会失败
/// 此处进行多次查找，以确定事件插入成功
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="firstEvent">The first event.</param>
private void FindFirstEvent(PartialMonitoringObject obj, EventData firstEvent)
{
var ev = firstEvent.ToCustomMonitoringInitEvent();
obj.InsertCustomMonitoringEvent(ev);
int i = 0;
while (i < 100)
{
var eventHistory = obj.GetMonitoringEvents();
HWLogger.SERVICE.Debug($"try Find FirstEvent:{i}.AlarmSn: {firstEvent.AlarmSn}. eventHistory Count:{eventHistory.Count}");
if (eventHistory.Any(x => x.Parameters[5] == firstEvent.AlarmSn.ToString()))
{
HWLogger.SERVICE.Debug($"Find FirstEvent Finish:{i}.AlarmSn: {firstEvent.AlarmSn}");
break;
}
Thread.Sleep(2000);
i++;
}
}
//---------------------------------------------------------------------
private void CreateGroups()
{
Dictionary <PartialMonitoringObject, List <ListViewItem> > itemDictionary = new Dictionary <PartialMonitoringObject, List <ListViewItem> >();
ShowGroups = true;
foreach (ListViewItem item in Items)
{
PartialMonitoringObject monitoringObject = ((OverrideInfo)item.Tag).m_monitoringObject;
if (!itemDictionary.ContainsKey(monitoringObject))
{
itemDictionary.Add(monitoringObject, new List <ListViewItem>());
}
itemDictionary[monitoringObject].Add(item);
}
foreach (KeyValuePair <PartialMonitoringObject, List <ListViewItem> > pair in itemDictionary)
{
PartialMonitoringObject monitoringObject = pair.Key;
MonitoringClass monitoringObjectClass = monitoringObject.GetLeastDerivedNonAbstractMonitoringClass();
string groupName;
string instanceName;
string className;
instanceName = Common.GetBestMonitoringObjectName(monitoringObject);
className = Common.GetBestElementName(monitoringObjectClass);
groupName = string.Format("{0} ({1})", instanceName, className);
ListViewGroup group = new ListViewGroup(groupName);
Groups.Add(group);
foreach (ListViewItem item in pair.Value)
{
item.Group = group;
}
}
}
//---------------------------------------------------------------------
private static List <MPOverride> GenerateEffectiveOverrrideList(
PartialMonitoringObject monitoringObject,
ReadOnlyCollection <MonitoringDiscovery> discoveries,
Dictionary <Guid, MonitoringClass> typeLookupTable
)
{
List <MPOverride> overrides = new List <MPOverride>();
foreach (MonitoringDiscovery discovery in discoveries)
{
MonitoringDiscoveryResultantOverrideSet overrideSet = monitoringObject.GetResultantOverrides(discovery);
MPWorkflow workflow = new MPWorkflow(discovery);
foreach (ResultantOverride <MonitoringDiscoveryConfigurationOverride> discoveryOverride in overrideSet.ResultantConfigurationOverrides.Values)
{
MonitoringClass target = typeLookupTable[discovery.Target.Id];
workflow.AddOverride(discoveryOverride.EffectiveOverride);
MPOverride mpOverride = new MPOverride(discoveryOverride.EffectiveOverride,
workflow,
new MPClass(target));
overrides.Add(mpOverride);
}
foreach (ResultantOverride <ManagementPackOverride> discoveryOverride in overrideSet.ResultantPropertyOverrides.Values)
{
MonitoringClass target = typeLookupTable[discovery.Target.Id];
workflow.AddOverride(discoveryOverride.EffectiveOverride);
MPOverride mpOverride = new MPOverride(discoveryOverride.EffectiveOverride,
workflow,
new MPClass(target));
overrides.Add(mpOverride);
}
}
return(overrides);
}
//---------------------------------------------------------------------
private void DisplayOverridesForMonitoringObject(TreeNode treeNode)
{
Dictionary <PartialMonitoringObject, List <MPOverride> > monitoringObjectToOverridesMap = new Dictionary <PartialMonitoringObject, List <MPOverride> >();
ReadOnlyCollection <PartialMonitoringObject> containedObjects;
PartialMonitoringObject selectedMonitoringObject = (PartialMonitoringObject)treeNode.Tag;
containedObjects = GetContainedMonitoringObjects(selectedMonitoringObject);
monitoringObjectToOverridesMap.Add(selectedMonitoringObject,
RetrieveEffectiveOverridesForMonitoringObject(selectedMonitoringObject));
foreach (PartialMonitoringObject monitoringObject in containedObjects)
{
monitoringObjectToOverridesMap.Add(monitoringObject,
RetrieveEffectiveOverridesForMonitoringObject(monitoringObject));
}
overrideListView2.ClearOverrides();
overrideListView2.AddOverrides(monitoringObjectToOverridesMap);
}
/// <summary>
/// 插入告警时，等待新增的对象的healthState不再是Not Monitor
/// </summary>
/// <param name="obj">The object.</param>
/// <returns>PartialMonitoringObject.</returns>
public bool CheckAndWaitHealthStateReady(PartialMonitoringObject obj)
{
var logger = HWLogger.Service;
if (obj.StateLastModified == null)
{
//如果对象添加超过5分钟，仍然没有健康状态，防止阻塞只查询一次
if ((DateTime.Now - obj.LastModified).TotalMinutes > 5)
{
obj = GetAppliance();
if (obj.HealthState != HealthState.Uninitialized)
{
logger.Debug($"Appliance first healthState is {obj.HealthState}.");
return(true);
}
return(false);
}
#region 新增对象
logger.Debug($"New Object:Appliance");
int i = 0;
while (i < 48)
{
i++;
// 重新查询obj状态
obj = GetAppliance();
if (obj.HealthState != HealthState.Uninitialized)
{
logger.Debug($"Appliance first healthState is {obj.HealthState}.");
Thread.Sleep(TimeSpan.FromSeconds(5));
return(true);
}
logger.Debug($"wait Appliance first Initialized...");
Thread.Sleep(TimeSpan.FromSeconds(5));
}
return(false);
#endregion
}
return(true);
}
/// <summary>
/// 插入告警时，等待新增的对象的healthState不再是Not Monitor
/// </summary>
/// <param name="mpClass">The mp class.</param>
/// <param name="obj">The object.</param>
/// <param name="eventData">The event data.</param>
/// <returns>PartialMonitoringObject.</returns>
public bool CheckAndWaitHealthStateReady(ManagementPackClass mpClass, PartialMonitoringObject obj, EventData eventData)
{
var logger = HWLogger.GetFdSdkLogger(eventData.FusionDirectorIp);
if (obj.StateLastModified == null)
{
//如果对象添加超过5分钟，仍然没有健康状态，防止阻塞只查询一次
if ((DateTime.Now - obj.TimeAdded).TotalMinutes > 5)
{
obj = GetObjectByUnionId(mpClass, eventData.UnionId);;
if (obj.HealthState != HealthState.Uninitialized)
{
logger.Info($"{eventData.UnionId} first healthState is {obj.HealthState}.");
return(true);
}
return(false);
}
#region 新增对象
logger.Info($"New Object:{eventData.UnionId}");
int i = 0;
while (i < 48)
{
i++;
// 重新查询obj状态
obj = GetObjectByUnionId(mpClass, eventData.UnionId);;
if (obj.HealthState != HealthState.Uninitialized)
{
logger.Info($"{eventData.UnionId} first healthState is {obj.HealthState}.");
Thread.Sleep(TimeSpan.FromSeconds(5));
return(true);
}
logger.Info($"wait {eventData.UnionId} first Initialized...");
Thread.Sleep(TimeSpan.FromSeconds(5));
}
return(false);
#endregion
}
return(true);
}
//---------------------------------------------------------------------
internal static List <MPOverride> RetrieveRuleOverrides(
PartialMonitoringObject monitoringObject,
Dictionary <Guid, MonitoringClass> typeLookupTable,
Dictionary <Guid, List <MonitoringRule> > typeToMonitoringRulesTable
)
{
List <MonitoringRule> rules = new List <MonitoringRule>();
string classesGuids = string.Empty;
foreach (MonitoringClass monitoringClass in monitoringObject.GetMonitoringClasses())
{
if (typeToMonitoringRulesTable.ContainsKey(monitoringClass.Id))
{
rules.AddRange(typeToMonitoringRulesTable[monitoringClass.Id]);
}
}
return(GenerateEffectiveOverrrideList(monitoringObject,
new ReadOnlyCollection <MonitoringRule>(rules),
typeLookupTable));
}
//---------------------------------------------------------------------
private void AddMonitoringObjectTreeNode(PartialMonitoringObject monitoringObject, TreeNode parentNode)
{
TreeNode node = new TreeNode();
string imageKey = GetImageKey(monitoringObject.GetLeastDerivedNonAbstractMonitoringClass());
node.Text = Common.GetBestMonitoringObjectName(monitoringObject);
node.SelectedImageKey = imageKey;
node.ImageKey = imageKey;
node.Tag = monitoringObject;
if (parentNode == null)
{
Nodes.Add(node);
}
else
{
parentNode.Nodes.Add(node);
}
PlaceholderTreeNode placeHolderNode = new PlaceholderTreeNode(node);
}
//---------------------------------------------------------------------
private bool IsGroup(PartialMonitoringObject monitoringObject)
{
ReadOnlyCollection <MonitoringClass> monitoringObjectClasses;
MonitoringClass groupClass;
bool isGroup = false;
groupClass = m_managementGroup.GetMonitoringClass(SystemMonitoringClass.Group);
monitoringObjectClasses = monitoringObject.GetMonitoringClasses();
foreach (MonitoringClass monitoringClass in monitoringObjectClasses)
{
if (monitoringClass.Id == groupClass.Id)
{
isGroup = true;
}
}
isGroup = (m_isContextCurrentlyGroup || (monitoringObjectClasses.Count == 1 && monitoringObjectClasses[0].Singleton));
return(isGroup);
}
//---------------------------------------------------------------------
protected override void OnBeforeExpand(TreeViewCancelEventArgs e)
{
if (e.Node.Nodes[0] is PlaceholderTreeNode)
{
e.Node.Nodes.Clear();
PartialMonitoringObject parentMonitoringObject = (PartialMonitoringObject)e.Node.Tag;
ReadOnlyCollection <PartialMonitoringObject> monitoringObjects;
try
{
monitoringObjects = parentMonitoringObject.GetRelatedPartialMonitoringObjects(TraversalDepth.OneLevel);
}
catch (Microsoft.EnterpriseManagement.Common.ServerDisconnectedException)
{
m_managementGroup.Reconnect();
monitoringObjects = parentMonitoringObject.GetRelatedPartialMonitoringObjects(TraversalDepth.OneLevel);
}
List <PartialMonitoringObject> monitoringObjectList = new List <PartialMonitoringObject>(monitoringObjects);
monitoringObjectList.Sort(new MonitoringObjectComparer());
BeginUpdate();
foreach (PartialMonitoringObject monitoringObject in monitoringObjectList)
{
AddMonitoringObjectTreeNode(monitoringObject, e.Node);
}
EndUpdate();
}
base.OnBeforeExpand(e);
}
//---------------------------------------------------------------------
private ReadOnlyCollection<PartialMonitoringObject> GetContainedMonitoringObjects(
PartialMonitoringObject partialMonitoringObject
)
{
return (partialMonitoringObject.GetRelatedPartialMonitoringObjects(TraversalDepth.Recursive));
}
//---------------------------------------------------------------------
private static List<MPOverride> GenerateEffectiveOverrrideList(
PartialMonitoringObject monitoringObject,
ReadOnlyCollection<MonitoringDiscovery> discoveries,
Dictionary<Guid, MonitoringClass> typeLookupTable
)
{
List<MPOverride> overrides = new List<MPOverride>();
foreach (MonitoringDiscovery discovery in discoveries)
{
MonitoringDiscoveryResultantOverrideSet overrideSet = monitoringObject.GetResultantOverrides(discovery);
MPWorkflow workflow = new MPWorkflow(discovery);
foreach (ResultantOverride<MonitoringDiscoveryConfigurationOverride> discoveryOverride in overrideSet.ResultantConfigurationOverrides.Values)
{
MonitoringClass target = typeLookupTable[discovery.Target.Id];
workflow.AddOverride(discoveryOverride.EffectiveOverride);
MPOverride mpOverride = new MPOverride(discoveryOverride.EffectiveOverride,
workflow,
new MPClass(target));
overrides.Add(mpOverride);
}
foreach (ResultantOverride<ManagementPackOverride> discoveryOverride in overrideSet.ResultantPropertyOverrides.Values)
{
MonitoringClass target = typeLookupTable[discovery.Target.Id];
workflow.AddOverride(discoveryOverride.EffectiveOverride);
MPOverride mpOverride = new MPOverride(discoveryOverride.EffectiveOverride,
workflow,
new MPClass(target));
overrides.Add(mpOverride);
}
}
return (overrides);
}
//---------------------------------------------------------------------
private static List<MPOverride> GenerateEffectiveOverrrideList(
PartialMonitoringObject monitoringObject,
ReadOnlyCollection<ManagementPackMonitor> monitors,
Dictionary<Guid, MonitoringClass> typeLookupTable
)
{
List<MPOverride> overrides = new List<MPOverride>();
foreach (ManagementPackMonitor monitor in monitors)
{
// if we do this check which I commented out, it only works for Windows computer, not for linux ones...
// I am not sure why the check was done in the first place... what was it preventing from doing?
// was it just an optimization to speed things up, or was it protecting the UI from dealing with some weird monitors?
//if (!DoesMonitorHaveNonCategoryOverride(monitor))
//{
// continue;
//}
MonitorResultantOverrideSet overrideSet = monitoringObject.GetResultantOverrides(monitor);
MPWorkflow workflow = new MPWorkflow(monitor);
foreach (ResultantOverride<MonitorConfigurationOverride> monitorOverride in overrideSet.ResultantConfigurationOverrides.Values)
{
MonitoringClass target = typeLookupTable[monitor.Target.Id];
workflow.AddOverride(monitorOverride.EffectiveOverride);
MPOverride mpOverride = new MPOverride(monitorOverride.EffectiveOverride,
workflow,
new MPClass(target));
overrides.Add(mpOverride);
}
foreach (ResultantOverride<ManagementPackOverride> monitorOverride in overrideSet.ResultantPropertyOverrides.Values)
{
MonitoringClass target = typeLookupTable[monitor.Target.Id];
workflow.AddOverride(monitorOverride.EffectiveOverride);
MPOverride mpOverride = new MPOverride(monitorOverride.EffectiveOverride,
workflow,
new MPClass(target));
overrides.Add(mpOverride);
}
}
return (overrides);
}
//---------------------------------------------------------------------
private void AddOverride(
MPOverride mpOverride,
PartialMonitoringObject monitoringObject
)
{
ManagementPackOverride actualOverride = mpOverride.ManagementPackOverride;
ManagementPack overrideMp;
ListViewItem overrideItem;
string parameter;
string newValue;
Common.RetrieveParameterInfo(actualOverride, out parameter, out newValue);
overrideMp = mpOverride.ManagementPackOverride.GetManagementPack();
overrideItem = new ListViewItem();
if (m_columnConfig == OverrideListViewColumnConfig.InstanceColumns)
{
overrideItem.Text = Common.GetBestMonitoringObjectName(monitoringObject);
}
if (m_columnConfig == OverrideListViewColumnConfig.WorkflowColumns ||
m_columnConfig == OverrideListViewColumnConfig.InstanceColumns)
{
if (overrideItem.Text == null || overrideItem.Text.Length == 0)
{
overrideItem.Text = mpOverride.Workflow.Workflow.DisplayName;
}
else
{
overrideItem.SubItems.Add(mpOverride.Workflow.Workflow.DisplayName);
}
overrideItem.SubItems.Add(GetOverridenWorkflowType(mpOverride.Workflow.Workflow));
overrideItem.SubItems.Add(parameter);
}
else
{
overrideItem.Text = parameter;
}
OverrideInfo overrideInfo = new OverrideInfo();
overrideInfo.m_monitoringObject = monitoringObject;
overrideInfo.m_override = mpOverride;
overrideItem.Tag = overrideInfo;
overrideItem.SubItems.Add(newValue);
overrideItem.SubItems.Add(actualOverride.TimeAdded.ToLocalTime().ToString());
overrideItem.SubItems.Add(Common.RetrieveContext(mpOverride.ManagementPackOverride, m_managementGroup));
overrideItem.SubItems.Add(actualOverride.Enforced.ToString());
overrideItem.SubItems.Add(Common.GetBestManagementPackName(overrideMp));
overrideItem.SubItems.Add(Common.GetManagementPackSealedFlag(overrideMp));
overrideItem.SubItems.Add(mpOverride.ManagementPackOverride.Description);
Items.Add(overrideItem);
}
//---------------------------------------------------------------------
internal static List<MPOverride> RetrieveMonitorOverrides(
PartialMonitoringObject monitoringObject,
Dictionary<Guid, MonitoringClass> typeLookupTable
)
{
List<ManagementPackMonitor> monitors = new List<ManagementPackMonitor>();
RetrieveApplicableMonitors(monitoringObject, monitors, null);
return GenerateEffectiveOverrrideList(monitoringObject,
new ReadOnlyCollection<ManagementPackMonitor>(monitors),
typeLookupTable);
}
//---------------------------------------------------------------------
private void AddOverride(
MPOverride mpOverride,
PartialMonitoringObject monitoringObject
)
{
ManagementPackOverride actualOverride = mpOverride.ManagementPackOverride;
ManagementPack overrideMp;
ListViewItem overrideItem;
string parameter;
string newValue;
Common.RetrieveParameterInfo(actualOverride, out parameter, out newValue);
overrideMp = mpOverride.ManagementPackOverride.GetManagementPack();
overrideItem = new ListViewItem();
if (m_columnConfig == OverrideListViewColumnConfig.InstanceColumns)
{
overrideItem.Text = Common.GetBestMonitoringObjectName(monitoringObject);
}
if (m_columnConfig == OverrideListViewColumnConfig.WorkflowColumns ||
m_columnConfig == OverrideListViewColumnConfig.InstanceColumns)
{
if (overrideItem.Text == null || overrideItem.Text.Length == 0)
{
overrideItem.Text = mpOverride.Workflow.Workflow.DisplayName;
}
else
{
overrideItem.SubItems.Add(mpOverride.Workflow.Workflow.DisplayName);
}
overrideItem.SubItems.Add(GetOverridenWorkflowType(mpOverride.Workflow.Workflow));
overrideItem.SubItems.Add(parameter);
}
else
{
overrideItem.Text = parameter;
}
OverrideInfo overrideInfo = new OverrideInfo();
overrideInfo.m_monitoringObject = monitoringObject;
overrideInfo.m_override = mpOverride;
overrideItem.Tag = overrideInfo;
overrideItem.SubItems.Add(newValue);
overrideItem.SubItems.Add(actualOverride.TimeAdded.ToLocalTime().ToString());
overrideItem.SubItems.Add(Common.RetrieveContext(mpOverride.ManagementPackOverride, m_managementGroup));
overrideItem.SubItems.Add(actualOverride.Enforced.ToString());
overrideItem.SubItems.Add(Common.GetBestManagementPackName(overrideMp));
overrideItem.SubItems.Add(Common.GetManagementPackSealedFlag(overrideMp));
overrideItem.SubItems.Add(mpOverride.ManagementPackOverride.Description);
Items.Add(overrideItem);
}
//---------------------------------------------------------------------
private ReadOnlyCollection <PartialMonitoringObject> GetContainedMonitoringObjects(
PartialMonitoringObject partialMonitoringObject
)
{
return(partialMonitoringObject.GetRelatedPartialMonitoringObjects(TraversalDepth.Recursive));
}
//---------------------------------------------------------------------
internal static List<MPOverride> RetrieveRuleOverrides(
PartialMonitoringObject monitoringObject,
Dictionary<Guid,MonitoringClass> typeLookupTable,
Dictionary<Guid,List<MonitoringRule>> typeToMonitoringRulesTable
)
{
List<MonitoringRule> rules = new List<MonitoringRule>();
string classesGuids = string.Empty;
foreach (MonitoringClass monitoringClass in monitoringObject.GetMonitoringClasses())
{
if (typeToMonitoringRulesTable.ContainsKey(monitoringClass.Id))
{
rules.AddRange(typeToMonitoringRulesTable[monitoringClass.Id]);
}
}
return GenerateEffectiveOverrrideList(monitoringObject,
new ReadOnlyCollection<MonitoringRule>(rules),
typeLookupTable);
}
//---------------------------------------------------------------------
private static List<MonitoringDiscoveryResultantOverrideSet> RetrieveDiscoveryOverrides(
PartialMonitoringObject monitoringObject
)
{
ReadOnlyCollection<MonitoringDiscovery> discoveries;
List<MonitoringDiscoveryResultantOverrideSet> listOfOverrides;
listOfOverrides = new List<MonitoringDiscoveryResultantOverrideSet>();
discoveries = monitoringObject.GetMonitoringDiscoveries(new MonitoringDiscoveryCriteria("HasNonCategoryOverride=1"));
foreach (MonitoringDiscovery discovery in discoveries)
{
listOfOverrides.Add(monitoringObject.GetResultantOverrides(discovery));
}
return (listOfOverrides);
}
//---------------------------------------------------------------------
private bool IsGroup(PartialMonitoringObject monitoringObject)
{
ReadOnlyCollection<MonitoringClass> monitoringObjectClasses;
MonitoringClass groupClass;
bool isGroup = false;
groupClass = m_managementGroup.GetMonitoringClass(SystemMonitoringClass.Group);
monitoringObjectClasses = monitoringObject.GetMonitoringClasses();
foreach (MonitoringClass monitoringClass in monitoringObjectClasses)
{
if (monitoringClass.Id == groupClass.Id)
{
isGroup = true;
}
}
isGroup = (m_isContextCurrentlyGroup || (monitoringObjectClasses.Count == 1 && monitoringObjectClasses[0].Singleton));
return (isGroup);
}
//---------------------------------------------------------------------
private void overrideTargetEditor_Load(object sender, EventArgs e)
{
if (m_overrideContextInstance == null)
{
allInstancesRadioButton.Checked = true;
}
else
{
PartialMonitoringObject monitoringObject;
monitoringObject = m_managementGroup.GetPartialMonitoringObject((Guid)m_overrideContextInstance);
m_isContextCurrentlyGroup = IsGroup(monitoringObject);
if (m_isContextCurrentlyGroup)
{
groupRadioButton.Checked = true;
groupsComboBox.Items.Clear();
groupsComboBox.Items.Add(monitoringObject);
groupsComboBox.SelectedItem = monitoringObject;
}
else
{
instanceRadioButton.Checked = true;
instancesComboBox.Items.Clear();
instancesComboBox.Items.Add(monitoringObject);
groupsComboBox.SelectedItem = monitoringObject;
}
m_currentMonitoringObject = monitoringObject;
}
}
private List<MPOverride> RetrieveEffectiveOverridesForMonitoringObject(
PartialMonitoringObject monitoringObject
)
{
List<MPOverride> overrides = new List<MPOverride>();
overrides.AddRange(Common.RetrieveRuleOverrides(monitoringObject,
m_overridesInfo.Types,
m_overridesInfo.TypeToRuleTable));
overrides.AddRange(Common.RetrieveMonitorOverrides(monitoringObject,
m_overridesInfo.Types));
overrides.AddRange(Common.RetrieveDiscoveryOverrides(monitoringObject,
m_overridesInfo.Types));
return (overrides);
}
//---------------------------------------------------------------------
private static void RetrieveApplicableMonitors(
PartialMonitoringObject monitoringObject,
List<ManagementPackMonitor> monitors,
MonitoringHierarchyNode<ManagementPackMonitor> hierarchyNode
)
{
if (hierarchyNode == null)
{
hierarchyNode = monitoringObject.GetMonitorHierarchy();
monitors.Add(hierarchyNode.Item);
}
foreach (MonitoringHierarchyNode<ManagementPackMonitor> node in hierarchyNode.ChildNodes)
{
monitors.Add(node.Item);
RetrieveApplicableMonitors(monitoringObject, monitors, node);
}
}
private PartialMonitoringObject GetParentEnclosure(PartialMonitoringObject obj)
{
return(this.GetParentObject(obj));
}
//---------------------------------------------------------------------
internal static List<MPOverride> RetrieveDiscoveryOverrides(
PartialMonitoringObject monitoringObject,
Dictionary<Guid, MonitoringClass> typeLookupTable
)
{
return GenerateEffectiveOverrrideList(monitoringObject,
monitoringObject.GetMonitoringDiscoveries(new MonitoringDiscoveryCriteria("HasNonCategoryOverride=1")),
typeLookupTable);
}
