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