public override void Start()
 {
     lock (shutdownLock) {
         if (shutdown)
         {
             return;
         }
         ModuleHost.RequestNextDataItem();
     }
 }
        public void OnNewDataItems(DataItemBase[] dataItems, bool isLogicalllyGrouped,
                                   DataItemAcknowledgementCallback acknowledgeCallback, object acknowledgeState,
                                   DataItemProcessingCompleteCallback completionCallback, object completionState)
        {
            if ((acknowledgeCallback == null && completionCallback != null) || (acknowledgeCallback != null && completionCallback == null))
            {
                throw new ArgumentOutOfRangeException(nameof(acknowledgeCallback), nameof(completionCallback));
            }

            lock (_shutdownLock)
            {
                if (_shutdown)
                {
                    return;
                }

                _logger.WriteLog(TraceEventType.Information, 450, $"Executing probe OnNewDataItems action");

                TOutputDataType[] results = null;

                try
                {
                    results = GetOutputData(dataItems);
                }
                catch (Exception ex)
                {
                    _logger.WriteLog(TraceEventType.Critical, 500, $"Critical exception while trying to retrieve output data \n\n {ex}");

                    acknowledgeCallback?.Invoke(acknowledgeState);
                    completionCallback?.Invoke(completionState);

                    //QUESTION: Not sure if we need to request next dataItem
                    ModuleHost.RequestNextDataItem();

                    throw new ModuleException(ex.Message, ex.InnerException);
                }

                acknowledgeCallback?.Invoke(acknowledgeState);
                completionCallback?.Invoke(completionState);

                //QUESTION: Should the state always be null?
                if (results.Length > 0)
                {
                    ModuleHost.PostOutputDataItems(results, isLogicalllyGrouped, GetAcknowledgementCallback(), null);
                }

                _logger.WriteLog(TraceEventType.Information, 451, $"Requesting next data item");

                ModuleHost.RequestNextDataItem();
            }
        }
示例#3
0
 public override void Start()
 {
     Log($"Entering {nameof(Start)}; Managed thread: {Thread.CurrentThread.ManagedThreadId}.\r\n");
     lock (shutdownLock)
     {
         if (shutdown)
         {
             return;
         }
         // Request the very first data item
         ModuleHost.RequestNextDataItem();
         Log($"First data item requested.\r\n");
     }
 }
示例#4
0
 public void OnNewDataItems(DataItemBase[] dataitems,
                            bool logicallyGrouped,
                            DataItemAcknowledgementCallback acknowledgeCallback,
                            object acknowledgedState,
                            DataItemProcessingCompleteCallback completionCallback,
                            object completionState)
 {
     Log($"Entering {nameof(OnNewDataItems)}; Managed thread: {Thread.CurrentThread.ManagedThreadId}\r\n");
     Log($"Received {(dataitems == null ? 0 : dataitems.Length)} inbound data items of {(dataitems == null && dataitems.Length >=1 ? "<unknown>" : dataitems[0].DataItemTypeName)} type.\r\n");
     lock (shutdownLock)
     {
         // don't start if shutdown is in progress
         if (shutdown)
         {
             return;
         }
         Log($"No shutdown in progress.\r\n");
         PropertyBagDataItem[] ReturningResults = null;
         try
         {
             // put the actual monitoring code here: ReturningResults = <get result code>
             Log($"Competed output data item.\r\n");
         }
         catch (Exception e)
         {
             Log($"Error while getting output data: {e.Message}.\r\n");
         }
         if (ReturningResults != null && ReturningResults.Length != 0)
         {
             // send data back to SCOM Agent, if any
             if (ReturningResults.Length == 1)
             {
                 ModuleHost.PostOutputDataItem(ReturningResults[0]);
             }
             else
             {
                 ModuleHost.PostOutputDataItems(ReturningResults, logicallyGrouped);
             }
             Log($"Output data item(s) posted.\r\n");
         }
         // completed the current run, ask for next
         ModuleHost.RequestNextDataItem();
         Log($"Next data item requested.\r\n");
     }
 }
 public void QueueCallback()
 {
     // this method can access shared static resource, because QueueManager ensures, that other queued actions called sequentially.
     try
     {
         bool NeedAcknowledge = (_acknowledgeCallback != null);
         lock (shutdownLock)
         {
             if (shutdown)
             {
                 return;
             }
             TOutputDataType[] ReturningResults;
             try
             {
                 ReturningResults = GetOutputData();
             }
             catch (Exception e)
             {
                 try
                 {
                     if (NeedAcknowledge)
                     {
                         _acknowledgeCallback(_acknowledgedState);
                         _completionCallback(_completionState);
                     }
                 }
                 catch (Exception ae)
                 {
                     Global.logWriteException("Failed to acknowledge action completion.", ae, this);
                 }
                 ModuleHost.RequestNextDataItem();
                 throw new ModuleException(e.Message, e);
             }
             if (ReturningResults == null || ReturningResults.Length == 0)
             {
                 if (NeedAcknowledge)
                 {
                     _acknowledgeCallback(_acknowledgedState);
                     _completionCallback(_completionState);
                 }
                 ModuleHost.RequestNextDataItem();
             }
             else if (NeedAcknowledge)
             {
                 void AcknowledgeBypass(object ackState)
                 {
                     lock (shutdownLock)
                     {
                         if (shutdown)
                         {
                             return;
                         }
                         _acknowledgeCallback(_acknowledgedState);
                         _completionCallback(_completionState);
                         ModuleHost.RequestNextDataItem();
                     }
                 }
                 if (ReturningResults.Length == 1)
                 {
                     ModuleHost.PostOutputDataItem(ReturningResults[0], AcknowledgeBypass, null);
                 }
                 else
                 {
                     ModuleHost.PostOutputDataItems(ReturningResults, _logicallyGrouped, AcknowledgeBypass, null);
                 }
             }
             else
             {
                 if (ReturningResults.Length == 1)
                 {
                     ModuleHost.PostOutputDataItem(ReturningResults[0]);
                 }
                 else
                 {
                     ModuleHost.PostOutputDataItems(ReturningResults, _logicallyGrouped);
                 }
                 ModuleHost.RequestNextDataItem();
             }
         }
     }
     finally
     {
         enqueuedSemaphore.Release();
     }
 }
示例#6
0
        public void OnNewDataItems(DataItemBase[] dataItems, bool logicallyGrouped,
                                   DataItemAcknowledgementCallback acknowledgeCallback, object acknowledgedState,
                                   DataItemProcessingCompleteCallback completionCallback, object completionState)
        {
            if ((acknowledgeCallback == null && completionCallback != null) ||
                (acknowledgeCallback != null && completionCallback == null))
            {
                throw new ArgumentOutOfRangeException("acknowledgeCallback, completionCallback");
            }
            bool NeedAcknowledge = (acknowledgeCallback != null);

            lock (shutdownLock)
            {
                if (shutdown)
                {
                    return;
                }
                TOutputDataType[] ReturningResults;
                try
                {
                    ReturningResults = GetOutputData(dataItems);
                }
                catch (Exception e)
                {
                    if (NeedAcknowledge)
                    {
                        acknowledgeCallback(acknowledgedState);
                        completionCallback(completionState);
                    }
                    ModuleHost.RequestNextDataItem();
                    throw new ModuleException(e.Message, e);
                }
                if (ReturningResults == null || ReturningResults.Length == 0)
                {
                    if (NeedAcknowledge)
                    {
                        acknowledgeCallback(acknowledgedState);
                        completionCallback(completionState);
                    }
                    ModuleHost.RequestNextDataItem();
                }
                else if (NeedAcknowledge)
                {
                    void AcknowledgeBypass(object ackState)
                    {
                        lock (shutdownLock)
                        {
                            if (shutdown)
                            {
                                return;
                            }
                            acknowledgeCallback(acknowledgedState);
                            completionCallback(completionState);
                            ModuleHost.RequestNextDataItem();
                        }
                    }

                    if (ReturningResults.Length == 1)
                    {
                        ModuleHost.PostOutputDataItem(ReturningResults[0], AcknowledgeBypass, null);
                    }
                    else
                    {
                        ModuleHost.PostOutputDataItems(ReturningResults, logicallyGrouped, AcknowledgeBypass, null);
                    }
                }
                else
                {
                    if (ReturningResults.Length == 1)
                    {
                        ModuleHost.PostOutputDataItem(ReturningResults[0]);
                    }
                    else
                    {
                        ModuleHost.PostOutputDataItems(ReturningResults, logicallyGrouped);
                    }
                    ModuleHost.RequestNextDataItem();
                }
            }
        }
        public void OnNewDataItems(DataItemBase[] dataItems, bool logicalSet,
                                   DataItemAcknowledgementCallback acknowledgedCallback, object acknowledgedState,
                                   DataItemProcessingCompleteCallback completionCallback, object completionState)
        {
            // Either both delegates are null or neither should be.
            if ((acknowledgedCallback == null && completionCallback != null) ||
                (acknowledgedCallback != null && completionCallback == null))
            {
                throw new ArgumentOutOfRangeException("acknowledgedCallback, completionCallback");
            }

            var ackNeeded = acknowledgedCallback != null;

            lock (shutdownLock) {
                if (shutdown)
                {
                    return;
                }

                var outputDataItems = new List <MOMPerfDataItem>();
                var timeStamp       = DateTime.UtcNow;
                foreach (var dataItem in dataItems)
                {
                    var bag = dataItem is PropertyBagDataItem ? (PropertyBagDataItem)dataItem
                                : new PropertyBagDataItem(dataItem.GetItemXml());
                    foreach (var collection in bag.Collections)
                    {
                        foreach (var record in collection.Value)
                        {
                            double value;
                            if (record.Value == null ||
                                !double.TryParse(record.Value.ToString(), out value))
                            {
                                continue;
                            }

                            var mapping = config.Mappings.FirstOrDefault(m => m.PropertyName.Equals(record.Key, StringComparison.InvariantCultureIgnoreCase));
                            if (mapping == null)
                            {
                                continue;
                            }

                            var perfDataItem = new MOMPerfDataItem(
                                timeStamp,
                                mapping.ObjectName, mapping.CounterName, mapping.InstanceName,
                                false, value,
                                config.ManagedEntityId, config.RuleId);

                            outputDataItems.Add(perfDataItem);
                        }
                    }
                }

                // Handle output
                if (outputDataItems == null || outputDataItems.Count == 0)
                {
                    return;
                }
                if (ackNeeded)
                {
                    DataItemAcknowledgementCallback ackDelegate = delegate(object ackState) {
                        lock (shutdownLock) {
                            if (shutdown)
                            {
                                return;
                            }
                            acknowledgedCallback(acknowledgedState);
                            completionCallback(completionState);
                            ModuleHost.RequestNextDataItem();
                        }
                    };

                    ModuleHost.PostOutputDataItems(outputDataItems.ToArray(), true /*logicalSet*/, ackDelegate, null);
                }
                else
                {
                    ModuleHost.PostOutputDataItems(outputDataItems.ToArray(), true /*logicalSet*/);
                    ModuleHost.RequestNextDataItem();
                }
            }
        }