/// <summary>
/// This constructor is for unhosted objects managed by specific instance of defined Action Point class OR for hosted objects,
/// which are hosted on defined Action Point class.
/// </summary>
/// <param name="managementGroup"></param>
/// <param name="seedClass"></param>
/// <param name="actionPointClassName"></param>
/// <param name="monitoringConnector"></param>
public ScomClassInstanceEditor(ManagementGroup managementGroup, ManagementPackClass seedClass, ManagementPackClass actionPointClass, MonitoringConnector monitoringConnector = null, ManagementPackRelationship hostingRelationship = null)
: this(managementGroup, seedClass, monitoringConnector)
{
_actionPointClass = actionPointClass ?? throw new ArgumentNullException(nameof(actionPointClass));
if (seedClass.Hosted)
{
_relMapShouldManageEntity = null;
_relMapManagesEntity = null;
_relHosting = hostingRelationship ?? managementGroup.EntityTypes.GetRelationshipClass(SystemRelationship.Hosting);
}
else
{
if (actionPointClass.IsSubtypeOf(managementGroup.EntityTypes.GetClass(_managementActionPointClassId)) || actionPointClass.Id == _managementActionPointClassId)
{
_relMapShouldManageEntity = managementGroup.EntityTypes.GetRelationshipClass(_managementActionPointShouldManageEntityRelationshipId);
}
else if (actionPointClass.IsSubtypeOf(managementGroup.EntityTypes.GetClass(SystemMonitoringClass.HealthService)) || actionPointClass.Id == SystemMonitoringClass.HealthService.Id)
{
_relHsShouldManageEntity = managementGroup.EntityTypes.GetRelationshipClass(SystemMonitoringRelationship.HealthServiceShouldManageEntity);
}
else
{
throw new NotSupportedException("For unhosted scenario, action point class should be either Microsoft.SystemCenter.ManagementActionPoint or Microsoft.SystemCenter.HealthService, or inherited from these classes.");
}
_relMapManagesEntity = managementGroup.EntityTypes.GetRelationshipClass(_managementActionPointManagesEntityRelationshipId);
}
_actionPoints.AddRange(managementGroup.EntityObjects.GetObjectReader <MonitoringObject>(_actionPointClass, ObjectQueryOptions.Default));
}
public void RemoveConnector(ManagementGroup managementGroup, MonitoringConnector monitoringConnector)
{
var subscriptions = managementGroup.ConnectorFramework.GetConnectorSubscriptions();
foreach (var subscription in subscriptions)
{
managementGroup.ConnectorFramework.DeleteConnectorSubscription(subscription);
}
try
{
monitoringConnector.Uninitialize();
}
catch (Exception)
{
// ignored
}
try
{
managementGroup.ConnectorFramework.Cleanup(monitoringConnector);
}
catch (Exception)
{
// ignored
}
}
public static string GetDataWarehouseConnectionString(this ManagementGroup mg, bool integratedSecurity = true, string extraOptions = null)
{
ManagementPackClass DWClass = mg.EntityTypes.GetClass(SystemCenterId.DataWarehouseClassId); // GetClass(mg, "Microsoft.SystemCenter.DataWarehouse");
EnterpriseManagementObject DWInstance = mg.EntityObjects.GetObjectReader <EnterpriseManagementObject>(DWClass, ObjectQueryOptions.Default).FirstOrDefault();
if (DWInstance != null)
{
string DWSQLServerName = DWInstance[SystemCenterId.DataWarehouseClassProperties.MainDatabaseServerNamePropertyId].Value.ToString();
string DWDataBaseName = DWInstance[SystemCenterId.DataWarehouseClassProperties.MainDatabaseNamePropertyId].Value.ToString();
string result = "Server=" + DWSQLServerName + ";Database=" + DWDataBaseName;
if (integratedSecurity)
{
result += ";Integrated Security=True";
}
else
{
result += ";Integrated Security=False";
}
if (!string.IsNullOrEmpty(extraOptions))
{
if (extraOptions[0] != ';')
{
extraOptions = ";" + extraOptions;
}
result += extraOptions;
}
return(result);
}
else
{
throw new ObjectNotFoundException("Cannot find Data Warehouse instance. Entire SCOM must be broken.");
}
}
public PSManagementGroup(ManagementGroup managementGroup)
{
if (managementGroup != null)
{
Id = managementGroup.Id;
Type = managementGroup.Type;
Name = managementGroup.Name;
TenantId = managementGroup.TenantId;
DisplayName = managementGroup.DisplayName;
UpdatedTime = managementGroup.Details.UpdatedTime;
UpdatedBy = managementGroup.Details.UpdatedBy;
if (managementGroup.Details.Parent != null)
{
if (managementGroup.Details.Parent.Id != null)
{
ParentId = managementGroup.Details.Parent.Id;
}
if (managementGroup.Details.Parent.DisplayName != null)
{
ParentDisplayName = managementGroup.Details.Parent.DisplayName;
}
if (managementGroup.Details.Parent.Name != null)
{
ParentName = managementGroup.Details.Parent.Name;
}
}
if (managementGroup.Children != null && managementGroup.Children.Count != 0)
{
this.Children = managementGroup.Children.Select(child => new PSManagementGroupChildInfo(child)).ToList();
}
}
}
private async Task <IActionResult> AddOrUpdateAdministrator(GroupAdministratorItems user, string slug, string emailAddress, string businessId)
{
var repository = _groupRepository(_createConfig(businessId));
var existingGroup = await repository.GetContentfulGroup(slug);
existingGroup.GroupAdministrators.Items = existingGroup.GroupAdministrators.Items.Where(a => a.Email != emailAddress).ToList();
if (user != null)
{
existingGroup.GroupAdministrators.Items.Add(user);
ManagementGroup managementGroup = new ManagementGroup();
_mapper.Map(existingGroup, managementGroup);
return(await _handler.Get(async() =>
{
var managementRepository = _managementRepository(_createConfig(businessId));
var version = await managementRepository.GetVersion(existingGroup.Sys.Id);
existingGroup.Sys.Version = version;
var response = await managementRepository.CreateOrUpdate(managementGroup, existingGroup.Sys);
return response.StatusCode == System.Net.HttpStatusCode.OK ? HttpResponse.Successful($"Successfully updated the group {existingGroup.Name}") : HttpResponse.Failure(response.StatusCode, "An error has occurred");
}));
}
else
{
throw new Exception("Invalid data received");
}
}
/// <summary>
/// This constructor is for unhosted objects managed by specific instance of defined Action Point class OR for hosted objects, which are hosted on defined Action Point class.
/// </summary>
/// <param name="managementGroup"></param>
/// <param name="seedClass"></param>
/// <param name="actionPointClassName"></param>
/// <param name="insertConnector"></param>
public SCOMClassInstanceEditor(ManagementGroup managementGroup, ManagementPackClass seedClass, ManagementPackClass actionPointClass, MonitoringConnector insertConnector, ManagementPackRelationship hostingRelationship = null)
{
myActionPointClass = actionPointClass;
if (seedClass.Hosted)
{
relMAPShouldManageEntity = null;
relMAPManagesEntity = null;
relHosting = hostingRelationship ?? managementGroup.EntityTypes.GetRelationshipClass(SystemId.HostingRelationshipId);
}
else
{
relHosting = null;
if (actionPointClass.IsSubtypeOf(managementGroup.EntityTypes.GetClass(SystemCenterId.ManagementActionPointClassId)) || actionPointClass.Id == SystemCenterId.ManagementActionPointClassId)
{
relMAPShouldManageEntity = managementGroup.EntityTypes.GetRelationshipClass(SystemCenterId.ManagementActionPointShouldManageEntityRelationshipId);
}
else if (actionPointClass.IsSubtypeOf(managementGroup.EntityTypes.GetClass(SystemCenterId.HealthServiceClassId)) || actionPointClass.Id == SystemCenterId.HealthServiceClassId)
{
relHSShouldManageEntiry = managementGroup.EntityTypes.GetRelationshipClass(SystemCenterId.HealthServiceShouldManageEntityRelationshipId);
}
else
{
throw new NotSupportedException("For unhosted scenario, action point class should be either Microsoft.SystemCenter.ManagementActionPoint or Microsoft.SystemCenter.HealthService, or inherited from these classes.");
}
relMAPManagesEntity = managementGroup.EntityTypes.GetRelationshipClass(SystemCenterId.ManagementActionPointManagesEntityRelationshipId);
}
myActionPoints = new List <MonitoringObject>();
myActionPoints.AddRange(managementGroup.EntityObjects.GetObjectReader <MonitoringObject>(myActionPointClass, ObjectQueryOptions.Default));
DefaultConstructor(managementGroup, seedClass, insertConnector);
}
protected void Page_Load(object sender, EventArgs e)
{
op = RequestData.Get <string>("op");
id = RequestData.Get <string>("id");
type = RequestData.Get <string>("type");
switch (this.RequestAction)
{
case RequestActionEnum.Update:
DoUpdate();
break;
case RequestActionEnum.Insert:
case RequestActionEnum.Create:
DoCreate();
break;
case RequestActionEnum.Delete:
ent = this.GetTargetData <ManagementGroup>();
ent.DoDelete();
return;
default:
DoSelect();
break;
}
}
internal override async Task <TDestination> MapAsync <TDestination>(object source, CancellationToken cancellationToken)
{
var group = source as LocalAuthority;
if (group == null)
{
throw new ArgumentException(
$"source must be an LocalAuthority, but received {source.GetType().FullName}", nameof(source));
}
if (typeof(TDestination) != typeof(ManagementGroup))
{
throw new ArgumentException(
$"TDestination must be ManagementGroup, but received {typeof(TDestination).FullName}",
nameof(source));
}
var managementGroup = new ManagementGroup
{
Name = group.Name,
Identifier = group.Code.ToString(),
};
managementGroup.Type =
await TranslateAsync(EnumerationNames.ManagementGroupType, LocalAuthority.ManagementGroupType, cancellationToken);
managementGroup.Code = $"{managementGroup.Type}-{managementGroup.Identifier}";
managementGroup.SetLineageForRequestedFields();
return(managementGroup as TDestination);
}
public async Task ThenItShouldRaiseEventForGroupIfAlreadyExistsAndUpdated(PointInTimeGroup stagingGroup)
{
// Arrange
var managementGroup = new ManagementGroup {
Identifier = stagingGroup.Uid.ToString()
};
_mapperMock.Setup(m => m.MapAsync <ManagementGroup>(It.IsAny <PointInTimeGroup>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(managementGroup);
_groupRepositoryMock.Setup(r => r.GetGroupFromStagingAsync(stagingGroup.Uid, stagingGroup.PointInTime, _cancellationToken))
.ReturnsAsync(stagingGroup);
_groupRepositoryMock.Setup(r => r.GetGroupAsync(stagingGroup.Uid, stagingGroup.PointInTime, _cancellationToken))
.ReturnsAsync(CloneWithChanges(stagingGroup, stagingGroup.GroupName + "-updated", false));
_establishmentRepositoryMock.Setup(r => r.GetEstablishmentFromStagingAsync(It.IsAny <long>(), It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new PointInTimeEstablishment());
// Act
await _manager.ProcessGroupAsync(stagingGroup.Uid, new[] { 1000001L }, stagingGroup.PointInTime, _cancellationToken);
// Assert
_eventPublisherMock.Verify(p => p.PublishManagementGroupUpdatedAsync(
managementGroup,
stagingGroup.PointInTime,
_cancellationToken),
Times.Once);
}
/// <summary>
/// 保存
/// </summary>
private void DoSave()
{
string Id = RequestData.Get("Id") + "";
string SortIndex = RequestData.Get("SortIndex") + "";
string MName = RequestData.Get("MName") + "";
if (string.IsNullOrEmpty(Id))
{
ManagementGroup Mg = new ManagementGroup();
Mg.CreateId = UserInfo.UserID;
Mg.CreateTime = DateTime.Now;
Mg.CreateName = UserInfo.LoginName;
Mg.SortIndex = int.Parse(SortIndex);
Mg.MName = MName;
Mg.DoCreate();
this.PageState.Add("Id", Mg.Id);
}
else
{
ManagementGroup Mg = ManagementGroup.Find(Id);
Mg.SortIndex = int.Parse(SortIndex);
Mg.MName = MName;
Mg.CreateId = UserInfo.UserID;
Mg.CreateTime = DateTime.Now;
Mg.CreateName = UserInfo.LoginName;
Mg.DoUpdate();
}
}
//---------------------------------------------------------------------
internal OverridesToXmlExporter(
Dictionary<Guid, MP> mpCollection,
ManagementGroup managementGroup
)
{
m_managementPackCollection = mpCollection;
m_managementGroup = managementGroup;
}
private static ManagementGroupExtensionClient GetExtensionClient(ManagementGroup managementGroup)
{
return(managementGroup.GetCachedClient((client) =>
{
return new ManagementGroupExtensionClient(client, managementGroup.Id);
}
));
}
//---------------------------------------------------------------------
internal OverridesToXmlExporter(
Dictionary <Guid, MP> mpCollection,
ManagementGroup managementGroup
)
{
m_managementPackCollection = mpCollection;
m_managementGroup = managementGroup;
}
public async Task GetGlobalManagementGroup()
{
_mgmtGroupName = SessionRecording.GenerateAssetName("mgmt-group-");
_mgmtGroup = await GlobalClient.GetManagementGroups().CreateOrUpdateAsync(_mgmtGroupName, new CreateManagementGroupRequest());
_mgmtGroup = await _mgmtGroup.GetAsync();
StopSessionRecording();
}
public async Task TryGet()
{
ManagementGroup mgmtGroup = await Client.GetManagementGroups().GetIfExistsAsync(_mgmtGroup.Data.Name, cacheControl: "no-cache");
CompareMgmtGroups(_mgmtGroup, mgmtGroup);
var ex = Assert.ThrowsAsync <RequestFailedException>(async() => _ = await Client.GetManagementGroups().GetAsync("NotThere", cacheControl: "no-cache"));
Assert.AreEqual(403, ex.Status);
}
//删除
public void DoDelete()
{
IList <object> idList = RequestData.GetList <object>("IdList");
if (idList != null && idList.Count > 0)
{
ManagementGroup.DoBatchDelete(idList.ToArray());
}
}
public async Task GetGlobalManagementGroup()
{
_mgmtGroupName = SessionRecording.GenerateAssetName("mgmt-group-");
var mgmtOp = await GlobalClient.GetManagementGroups().CreateOrUpdateAsync(true, _mgmtGroupName, new CreateManagementGroupOptions());
_mgmtGroup = mgmtOp.Value;
_mgmtGroup = await _mgmtGroup.GetAsync();
await StopSessionRecordingAsync();
}
/// <summary>
/// Connect the <see cref="CurrentManagementGroup"/> to the specified management server.
/// </summary>
/// <param name="managementServerURI">URI of the management Server to connect to</param>
public static void ConnectToManagementGroup(string managementServerURI)
{
if (string.IsNullOrEmpty(managementServerURI))
{
throw new ArgumentNullException("Need a Management Group URI for a connection.");
}
CurrentManagementGroup = new ManagementGroup(managementServerURI);
}
/// <summary>
/// This constructor is for unhosted objects managed by All Management Server resource pool.
/// </summary>
/// <param name="managementGroup"></param>
/// <param name="seedClass"></param>
/// <param name="insertConnector"></param>
public ScomClassInstanceEditor(ManagementGroup managementGroup, ManagementPackClass seedClass, MonitoringConnector monitoringConnector = null)
{
_managementGroup = managementGroup ?? throw new ArgumentNullException(nameof(managementGroup));
_seedClass = seedClass ?? throw new ArgumentNullException(nameof(seedClass));
_monitoringConnector = monitoringConnector;
_relToClearHs = _managementGroup.EntityTypes.GetRelationshipClass(SystemMonitoringRelationship.HealthServiceShouldManageEntity);
_relToClearMap = _managementGroup.EntityTypes.GetRelationshipClass(_managementActionPointShouldManageEntityRelationshipId);
}
private ResolveFieldContext <ManagementGroup> BuildManagementGroupResolveFieldContext(
ManagementGroup source = null, int year = 2020, string type = "SchoolSummer",
string[] fields = null, AggregationRequestModel[] aggregationRequests = null)
{
if (source == null)
{
source = new ManagementGroup();
}
if (fields == null)
{
fields = new[] { "name" };
}
if (aggregationRequests != null && !fields.Any(f => f == "_aggregations"))
{
fields = fields.Concat(new[] { "_aggregations" }).ToArray();
}
var context = TestHelper.BuildResolveFieldContext(
source: source,
arguments: new Dictionary <string, object>
{
{ "year", year },
{ "type", type },
},
fields: fields);
if (aggregationRequests != null)
{
var aggregationsField = context.FieldAst.SelectionSet.Selections
.Select(x => (Field)x)
.Single(f => f.Name == "_aggregations");
aggregationsField.Arguments = new Arguments
{
new Argument(new NameNode("definitions"))
{
Value = new ListValue(aggregationRequests.Select(request =>
new ObjectValue(new[]
{
new ObjectField("name", new StringValue(request.Name)),
new ObjectField("conditions",
new ListValue(request.Conditions.Select(condition =>
new ObjectValue(new[]
{
new ObjectField("field", new StringValue(condition.Field)),
new ObjectField("operator", new StringValue(condition.Operator.ToString().ToUpper())),
new ObjectField("value", new StringValue(condition.Value)),
})))),
}))),
}
};
}
return(context);
}
public async Task ThenItShouldGetLinksForManagementGroup(ManagementGroup source)
{
var context = BuildManagementGroupResolveFieldContext(source);
await _censusResolver.ResolveAsync(context);
_registryProviderMock.Verify(reg => reg.GetLinksAsync(
"management-groups", SourceSystemNames.GetInformationAboutSchools, source.Code, null, _cancellationToken),
Times.Once);
}
public SCOMMaintenanceController()
{
System.Security.Principal.WindowsImpersonationContext impersonationContext;
impersonationContext =
((System.Security.Principal.WindowsIdentity)User.Identity).Impersonate();
var SCOMSERVER = ConfigurationManager.AppSettings["ScomSdkServer"];
ManagementGroupConnectionSettings mgSettings = new ManagementGroupConnectionSettings(SCOMSERVER);
mg = ManagementGroup.Connect(mgSettings);
}
private bool IsCorrectlyMappedEntity(ManagementGroup managementGroup, string sourceSystemName, Entity actual)
{
return(actual.EntityType == EntityNameTranslator.ManagementGroupSingular &&
actual.SourceSystemName == sourceSystemName &&
actual.SourceSystemId == managementGroup.Code &&
actual.ManagementGroupType == managementGroup.Type &&
actual.ManagementGroupId == managementGroup.Identifier &&
actual.ManagementGroupUkprn == managementGroup.Ukprn &&
actual.ManagementGroupCompaniesHouseNumber == managementGroup.CompaniesHouseNumber);
}
public async Task ThenItShouldUploadBatchWithSingleDocument(ManagementGroup managementGroup)
{
await _manager.SyncAsync(managementGroup, SourceSystemNames.GetInformationAboutSchools,
_cancellationToken);
_searchIndexMock.Verify(i => i.UploadBatchAsync(
It.Is <ManagementGroupSearchDocument[]>(a => a.Length == 1),
_cancellationToken),
Times.Once);
}
public async Task Delete()
{
ManagementGroup mgmtGroup = await Client.GetManagementGroups().CreateOrUpdateAsync(Recording.GenerateAssetName("mgmt-group-"), new CreateManagementGroupRequest());
await mgmtGroup.DeleteAsync();
var ex = Assert.ThrowsAsync <RequestFailedException>(async() => await mgmtGroup.GetAsync());
Assert.AreEqual(404, ex.Status);
}
public async Task SyncAsync(ManagementGroup managementGroup, string source, CancellationToken cancellationToken)
{
var searchDocument = MapManagementGroupToSearchDocument(managementGroup, source);
_logger.Info($"Mapped management group to search document: {JsonConvert.SerializeObject(searchDocument)}");
await _searchIndex.UploadBatchAsync(new[] { searchDocument }, cancellationToken);
_logger.Debug($"Successfully uploaded document to search index");
}
private void DefaultConstructor(ManagementGroup managementGroup, ManagementPackClass seedClass, MonitoringConnector insertConnector)
{
mySeedClass = seedClass;
myConnector = insertConnector;
myMG = managementGroup;
relToClearHS = managementGroup.EntityTypes.GetRelationshipClass(SystemCenterId.HealthServiceShouldManageEntityRelationshipId);
relToClearMAP = managementGroup.EntityTypes.GetRelationshipClass(SystemCenterId.ManagementActionPointShouldManageEntityRelationshipId);
// load initial data
Refresh();
}
public async Task CreateOrUpdate()
{
string mgmtGroupName = Recording.GenerateAssetName("mgmt-group-");
ManagementGroup mgmtGroup = await Client.GetManagementGroups().CreateOrUpdateAsync(mgmtGroupName, new CreateManagementGroupRequest());
Assert.AreEqual($"/providers/Microsoft.Management/managementGroups/{mgmtGroupName}", mgmtGroup.Data.Id.ToString());
Assert.AreEqual(mgmtGroupName, mgmtGroup.Data.Name);
Assert.AreEqual(mgmtGroupName, mgmtGroup.Data.DisplayName);
Assert.AreEqual(ManagementGroupOperations.ResourceType, mgmtGroup.Data.Type);
}
protected void CompareMgmtGroups(ManagementGroup expected, ManagementGroup actual)
{
Assert.AreEqual(expected.Data.DisplayName, actual.Data.DisplayName);
Assert.AreEqual(expected.Data.Id, actual.Data.Id);
Assert.AreEqual(expected.Data.Name, actual.Data.Name);
Assert.AreEqual(expected.Data.TenantId, actual.Data.TenantId);
Assert.AreEqual(expected.Data.ResourceType, actual.Data.ResourceType);
Assert.IsNotNull(actual.Data.Details, "Details were null");
Assert.IsNotNull(actual.Data.Children, "Children were null");
}
private void DoCreate()
{
string OrgEns = RequestData.Get("OrgEnts") + "";
ent = this.GetPostedData <ManagementGroup>();
if (!string.IsNullOrEmpty(OrgEns))
{
ent.GroupsSet = OrgEns;
}
ent.DoCreate();
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigurationPackConnector"/> class.
/// Connects to the provided management server or URI
/// </summary>
public ConfigurationPackConnector()
{
Log.WriteTrace(
EventType.UIActivity,
"Connecting to configuration override Management Pack");
try
{
ManagementGroup managementGroupConnection = ManagementGroupConnector.CurrentManagementGroup;
ManagementPackCriteria packCriteria = new ManagementPackCriteria("Name = 'Community.ManagementPackCatalog.Configuration'");
var packResults = managementGroupConnection.ManagementPacks.GetManagementPacks(packCriteria);
if (packResults.Count == 1)
{
// Good news, we should only see one
configurationOverridePack = packResults[0];
}
else if (packResults.Count == 0)
{
// install the shell unsealed pack
try
{
DialogResult installPack = System.Windows.Forms.MessageBox.Show(
"A small unsealed MP is required to configure the alerting, can we create it now?"
+ Environment.NewLine + "Community.ManagementPackCatalog.Configuration will be created for alert configuration overrides."
, "Create Override Pack?"
, System.Windows.Forms.MessageBoxButtons.YesNo
, System.Windows.Forms.MessageBoxIcon.Information);
if (installPack == DialogResult.Yes)
{
InstallConfigurationPack();
}
else
{
throw new Exception("The Settings pane cannot be used without the unsealed Configuration management pack.");
}
}
catch (Exception ex)
{
Log.WriteError(
EventType.UIActivity,
"Unable to install management pack.",
ex.Message);
}
}
}
catch (Exception ex)
{
Log.WriteError(
EventType.ExternalDependency,
"Unable to connect to Management Group and Get Override Pack",
ex.Message);
}
}
//---------------------------------------------------------------------
public OverrideTargetEditor(
ManagementGroup managementGroup,
ManagementPackClass managementPackClass,
Guid? overrideContextInstance
)
{
InitializeComponent();
m_managementGroup = managementGroup;
m_managementPackClass = managementPackClass;
m_overrideContextInstance = overrideContextInstance;
m_isContextCurrentlyGroup = false;
}
//---------------------------------------------------------------------
private void btnConnect_Click(object sender, EventArgs e)
{
try
{
ManagementGroupConnectionSettings settings = new ManagementGroupConnectionSettings(txtRmsServerName.Text);
settings.CacheMode = Microsoft.EnterpriseManagement.Common.CacheMode.Configuration;
m_managementGroup = new ManagementGroup(settings);
DialogResult = DialogResult.OK;
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
DialogResult = DialogResult.None;
}
}
//-----------------------------------------------------------------------------------
public static void CloseAlertEvent(string AlertIDFromFile)
{
MonitoringConnector connector;
ReadOnlyCollection<ConnectorMonitoringAlert> alerts;
ManagementGroup mg = new ManagementGroup("localhost");
IConnectorFrameworkManagement icfm = mg.ConnectorFramework;
Guid connectorGuid = new Guid("{6A1F8C0E-B8F1-4147-8C9B-5A2F98F10003}");
connector = icfm.GetConnector(connectorGuid);
alerts = connector.GetMonitoringAlerts();
IList<MonitoringAlertResolutionState> alertStates = mg.OperationalData.GetMonitoringAlertResolutionStates();
MonitoringAlertResolutionState closedState = null;
foreach (MonitoringAlertResolutionState thisState in alertStates)
{
if (thisState.Name == "Closed")
{
closedState = thisState;
}
}
foreach (ConnectorMonitoringAlert alert in alerts)
{
string alertID = alert.Id.ToString();
if ((alert.ResolutionState == 11) & (alertID == AlertIDFromFile))
{
string FilePath = "C:\\SCOM_OT\\Alerts\\" + alertID + ".txt";
alert.ResolutionState = closedState.ResolutionState;
Console.WriteLine("Closed in SCOM alert name: {0}",alert.Name);
alert.Update("Alert has been closed in OT");
System.IO.File.Delete(FilePath);
Console.WriteLine("Deleted file path: {0}", FilePath);
}
}
}
//-----------------------------------------------------------------------------------
public static void Start(string[] args)
{
ManagementGroup mg = new ManagementGroup("localhost");
IConnectorFrameworkManagement icfm = mg.ConnectorFramework;
Guid connectorGuid = new Guid("{6A1F8C0E-B8F1-4147-8C9B-5A2F98F10003}");
MonitoringConnector connector;
System.Timers.Timer FeedBackTimer = new System.Timers.Timer();
FeedBackTimer.Elapsed += new ElapsedEventHandler(GetAlertForClosing);
FeedBackTimer.Interval = 1000 * 60;
FeedBackTimer.Start();
try
{
if (args.Length == 1)
{
if (args[0] == "InstallConnector")
{
ConnectorInfo info = new ConnectorInfo();
info.Description = "Sample connector";
info.DisplayName = "Sample connector";
info.Name = "Sample connector";
connector = icfm.Setup(info, connectorGuid);
connector.Initialize();
Console.WriteLine("Connector {0} has been succefuly installed", info.DisplayName);
}
else if (args[0] == "UninstallConnector")
{
connector = icfm.GetConnector(connectorGuid);
IList<MonitoringConnectorSubscription> subscriptions;
subscriptions = icfm.GetConnectorSubscriptions();
foreach (MonitoringConnectorSubscription subscription in subscriptions)
{
if (subscription.MonitoringConnectorId == connectorGuid)
{
icfm.DeleteConnectorSubscription(subscription);
}
}
connector.Uninitialize();
icfm.Cleanup(connector);
}
return;
}
connector = icfm.GetConnector(connectorGuid);
//Обрабатываем предупреждения в бесконечном цикле так как наше приложение является службой Windows
while (true)
{
//Обьявляем перменную типа коллекция для хранения предупреждений
ReadOnlyCollection<ConnectorMonitoringAlert> alerts;
alerts = connector.GetMonitoringAlerts();
//Запускаем цикл для обработки каждого предупреждения
foreach (ConnectorMonitoringAlert alert in alerts)
{
//Делаем проверку должно ли предупреждение создавать инцидент, если да то переменной flag присваиваем значение Yes.
if (alert.ResolutionState == 0)
{
string flag = "No";
if ((alert.Priority == ManagementPackWorkflowPriority.High) && (alert.Severity == ManagementPackAlertSeverity.Warning))
{
flag = "Yes";
}
if ((alert.Priority == ManagementPackWorkflowPriority.Normal) && (alert.Severity == ManagementPackAlertSeverity.Error))
{
flag = "Yes";
}
if ((alert.Priority == ManagementPackWorkflowPriority.High) && (alert.Severity == ManagementPackAlertSeverity.Error))
{
flag = "Yes";
}
Console.WriteLine("Begin Processing Alert!");
// The criteria specifies that you want to collect
// computers running Windows Server 2003.
String criteria = "Id = " + "'" +alert.ClassId + "'";
Console.WriteLine(criteria);
ManagementPackClassCriteria classCriteria = new ManagementPackClassCriteria(criteria);
Console.WriteLine("Querying for data...");
// There should only be one item in the monitoringClasses collection.
IList<ManagementPackClass> monitoringClasses =
mg.EntityTypes.GetClasses(classCriteria);
// Get all instances of computers running Windows Server 2003 in the management group.
List<MonitoringObject> targets = new List<MonitoringObject>();
IObjectReader<MonitoringObject> reader = mg.EntityObjects.GetObjectReader<MonitoringObject>(monitoringClasses[0], ObjectQueryOptions.Default);
targets.AddRange(reader);
string logicalgroup = "";
foreach (MonitoringObject target in targets)
{ logicalgroup = DisplayRelationshipInformation(target, mg, alert.MonitoringObjectId);
Console.WriteLine("SCOM Group: {0}", logicalgroup);
if (logicalgroup.Contains("PS.")) { break; }
}
Log operLog = new Log("log.txt", "C:\\SCOM_OT\\Log");
operLog.Write("Begin Processing Alert: " + alert.Name.ToString() + " with serial number " + i.ToString() + " and ID " + alert.Id.ToString());
Console.WriteLine("SCOM Group Substring: {0}", logicalgroup.Substring(3));
//Send the alert to the other management system with the appropriate API
//from the other management system.
//Add a comment to the alert.
string AlertFilePath;
AlertFilePath = "C:\\SCOM_OT\\Alerts\\" + alert.Id.ToString() + ".txt";
System.IO.StreamWriter file = new System.IO.StreamWriter(AlertFilePath, true);
file.WriteLine("#{0} Alert received on {1}", i.ToString(), DateTime.Now);
file.WriteLine(">> Name: {0}", alert.Name.ToString());
file.WriteLine(">> Id: {0}", alert.Id.ToString());
file.WriteLine(">> SCOM Group: {0}", logicalgroup.Substring(3));
file.WriteLine(">> Category: {0}", alert.Category.ToString());
file.WriteLine(">> ConnectorId: {0}", alert.ConnectorId.ToString());
file.WriteLine(">> ConnectorStatus: {0}", alert.ConnectorStatus.ToString());
file.WriteLine(">> RepeatCount: {0}", alert.RepeatCount.ToString());
file.WriteLine(">> ResolutionState: {0}", alert.ResolutionState.ToString());
file.WriteLine(">> LastModified: {0}", alert.LastModified.ToString());
file.WriteLine(">> LastModifiedByNonConnector: {0}", alert.LastModifiedByNonConnector.ToString());
file.WriteLine(">> Priority: {0}", alert.Priority.ToString());
file.WriteLine(">> Severity: {0}", alert.Severity.ToString());
file.WriteLine(">> Description: {0}", alert.Description);
file.WriteLine(">> Monitoring Object ID: {0}", alert.MonitoringObjectId);
file.WriteLine(">> Must Generate Incident: {0}", flag);
file.WriteLine(">> Processed in OT: No");
file.WriteLine("");
file.Close();
Console.WriteLine("#{0} Alert received on {1}", i.ToString(), DateTime.Now);
Console.WriteLine(">> Id: {0}", alert.Id.ToString());
Console.WriteLine(">> Category: {0}", alert.Category.ToString());
Console.WriteLine(">> ConnectorId: {0}", alert.ConnectorId.ToString());
Console.WriteLine(">> ConnectorStatus: {0}", alert.ConnectorStatus.ToString());
Console.WriteLine(">> RepeatCount: {0}", alert.RepeatCount.ToString());
Console.WriteLine(">> ResolutionState: {0}", alert.ResolutionState.ToString());
Console.WriteLine(">> LastModified: {0}", alert.LastModified.ToString());
Console.WriteLine(">> LastModifiedByNonConnector: {0}", alert.LastModifiedByNonConnector.ToString());
Console.WriteLine(">> Priority: {0}", alert.Priority.ToString());
Console.WriteLine(">> Severity: {0}", alert.Severity.ToString());
Console.WriteLine(">> Description: {0}", alert.Description);
Console.WriteLine("");
i = i + 1;
//Console.WriteLine("\nAlert Resolution State Before: " + alert.ResolutionState.ToString());
alert.ResolutionState = 11;
//Console.WriteLine("\nAlert Resolution State After: " + alert.ResolutionState.ToString());
alert.Update("Alert has been forwarded to OT");
operLog.Write("End Processing Alert: " + alert.Name.ToString() + " with serial number " + i.ToString() + " and ID " + alert.Id.ToString());
}
}
//Wait for a minute before checking for new alerts again.
Thread.Sleep(5 * 1000);
}
}
catch (EnterpriseManagementException error)
{
Console.WriteLine(error.Message);
}
}
//-----------------------------------------------------------------------------------
static string DisplayRelationshipInformation(MonitoringObject mObject, ManagementGroup mg, Guid mObjectID)
{
if (mObject.Id == mObjectID)
{
//Получаем список отношений для конкретного обьекта мониторинга
IList<EnterpriseManagementRelationshipObject<MonitoringObject>> relObjects = mg.EntityObjects.GetRelationshipObjects<MonitoringObject>(mObject.Id, ObjectQueryOptions.Default);
foreach (EnterpriseManagementRelationshipObject<MonitoringObject> relObject in relObjects)
{
//Ищем группу начинающююся на "PS.", так как только обьекты мониторинга в этих группах должны обрабатыватся
if (relObject.SourceObject.DisplayName.Contains("PS.")) { return relObject.SourceObject.DisplayName; }
}
}
return "";
}
//---------------------------------------------------------------------
internal static string RetrieveContext(
ManagementPackOverride mpOverrride,
ManagementGroup managementGroup
)
{
string context = "Unknown";
if (mpOverrride.ContextInstance == null)
{
string className;
className = GetBestElementName(managementGroup.GetMonitoringClass(mpOverrride.Context.Id));
context = string.Format("All Instances of type {0}", className);
}
else
{
PartialMonitoringObject monitoringObject;
try
{
try
{
monitoringObject = managementGroup.GetPartialMonitoringObject((Guid)mpOverrride.ContextInstance);
context = monitoringObject.DisplayName;
}
catch (Microsoft.EnterpriseManagement.Common.MonitoringException exception)
{
managementGroup.Reconnect();
monitoringObject = managementGroup.GetMonitoringObject((Guid)mpOverrride.ContextInstance);
}
}
catch (Microsoft.EnterpriseManagement.Common.MonitoringException exception)
{
MessageBox.Show(exception.Message);
}
}
return (context);
}
private void CheckAlerts(object data)
{
eventLog1.Source = "Ops2ZenossSource";
if (!(Monitor.TryEnter(chkAlertsTimer)))
{
eventLog1.WriteEntry("CheckAlerts is running too long. Timer function found that prior execution is still active.",
EventLogEntryType.Error,
EventCheckAlertsRunningLong);
return;
}
try
{
if (connector == null)
{
ManagementGroup mg = new ManagementGroup("localhost");
IConnectorFrameworkManagement icfm = mg.ConnectorFramework;
connector = icfm.GetConnector(connectorGuid);
}
ReadOnlyCollection<ConnectorMonitoringAlert> Alerts;
Alerts = connector.GetMonitoringAlerts();
if (Alerts.Count > 0)
{
eventLog1.WriteEntry("Found " + Alerts.Count + " alerts for processing",
EventLogEntryType.Information);
OutputAlerts(Alerts);
eventLog1.WriteEntry("Acknowledging all alerts.",
EventLogEntryType.Information);
connector.AcknowledgeMonitoringAlerts(Alerts);
}
}
catch (EnterpriseManagementException error)
{
connector = null;
eventLog1.WriteEntry("MonitoringException in timer function:" + error.Message,
EventLogEntryType.Error,
EventCheckAlertsMonitoringException);
}
catch (Exception excp)
{
connector = null;
eventLog1.WriteEntry("Exception in timer function:" + excp.Message,
EventLogEntryType.Error,
EventCheckAlertsMonitoringException);
}
finally
{
Monitor.Exit(chkAlertsTimer);
}
}
//---------------------------------------------------------------------
internal MPOverridesInfo(ManagementGroup managementGroup)
{
m_managementGroup = managementGroup;
}
//---------------------------------------------------------------------
private bool ConnectToManagementGroup()
{
ConnectionDialog connectionDialog = new ConnectionDialog();
DialogResult dialogResult;
dialogResult = connectionDialog.ShowDialog();
if (dialogResult == DialogResult.OK)
{
m_managementGroup = connectionDialog.ManagementGroup;
Text = string.Format("Overrides Explorer 2012 - MS: {0} - MG: {1}", m_managementGroup.ConnectionSettings.ServerName, m_managementGroup.Name);
}
return (dialogResult == DialogResult.OK);
}
//---------------------------------------------------------------------
public MPBrowserDialog(ManagementGroup managementGroup)
{
InitializeComponent();
m_managementGroup = managementGroup;
}
private void managementGroupToolStripMenuItem_Click(object sender, EventArgs e)
{
m_managementPack.Clear();
Connection Connection = new Connection();
Connection.ShowDialog();
if (Connection.DialogResult != DialogResult.OK)
{
return;
}
this.ManagementGroup = Connection.Server;
try
{
if (Connection.User != "")
{
ManagementGroupConnectionSettings emgs = new ManagementGroupConnectionSettings(Connection.Server);
string[] user = Connection.User.Split('\\');
emgs.Domain = user[0];
emgs.UserName = user[1];
SecureString password = new SecureString();
foreach (char c in Connection.Password)
{
password.AppendChar(c);
}
emgs.Password = password;
emg = new ManagementGroup(emgs);
}
else
{
emg = new ManagementGroup(Connection.Server);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
BackgroundWorker MGConnector = new BackgroundWorker();
MGConnector.DoWork += MGConnector_DoWork;
MGConnector.RunWorkerCompleted += MGConnector_RunWorkerCompleted;
m_progressDialog = new ProgressDialog();
MGConnector.RunWorkerAsync(MPLoadingProgress);
m_progressDialog.ShowDialog();
MultipleMPSelectionForm form = new MultipleMPSelectionForm(MPList);
DialogResult r = form.ShowDialog();
if (r != DialogResult.Cancel && form.ChosenMP.Count > 0)
{
foreach (ManagementPack item in form.ChosenMP)
{
this.m_managementPack.Add(item.Name, item);
}
Mode = MPMode.ManagementGroup;
ProcessManagementPacks();
}
}
//---------------------------------------------------------------------
internal void Initialize(
ManagementGroup managementGroup,
OverrideListViewColumnConfig columnConfig
)
{
Debug.Assert(managementGroup != null);
m_managementGroup = managementGroup;
m_columnConfig = columnConfig;
CreateColumns();
CreateContextMenu();
}
