//---------------------------------------------------------------------
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);
}
}
//---------------------------------------------------------------------
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 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 deleteOverrideMenuItem_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 delete an override that is defined in a sealed management pack.");
return;
}
if (MessageBox.Show("Are you sure you wish to delete the selected override?",
"Delete override",
MessageBoxButtons.YesNo) == DialogResult.Yes)
{
mpOverride.ManagementPackOverride.Status = ManagementPackElementStatus.PendingDelete;
mpOverride.ManagementPackOverride.GetManagementPack().AcceptChanges();
mpOverride.Workflow.RemoveOverride(mpOverride.ManagementPackOverride);
Items.Remove(SelectedItems[0]);
}
}
catch (Microsoft.EnterpriseManagement.Common.ManagementPackException exception)
{
MessageBox.Show(exception.Message);
}
}
//---------------------------------------------------------------------
private void moveToDifferentMPMenuItem_Click(
object sender,
EventArgs e
)
{
if (SelectedItems.Count == 0)
{
return;
}
MPBrowserDialog mpBrowserDialog = new MPBrowserDialog(m_managementGroup);
if (mpBrowserDialog.ShowDialog(this) == DialogResult.OK)
{
MPOverride sourceOverride = ((OverrideInfo)SelectedItems[0].Tag).m_override;
ManagementPack targetManagementPack = mpBrowserDialog.ManagementPack;
ManagementPack sourceManagementPack = sourceOverride.ManagementPackOverride.GetManagementPack();
if (!sourceManagementPack.Sealed)
{
OverrideMover overrideMover = new OverrideMover(sourceManagementPack,
targetManagementPack,
sourceOverride.ManagementPackOverride,
sourceOverride.Workflow);
ManagementPackOverride newOverride;
newOverride = overrideMover.PerformMove();
sourceOverride.Workflow.RemoveOverride(sourceOverride.ManagementPackOverride);
sourceOverride.Workflow.AddOverride(newOverride);
}
else
{
MessageBox.Show("Cannot move an override out of a Sealed MP!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
//---------------------------------------------------------------------
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 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 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);
}
