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