/// <summary>
/// Initializes a new instance of the <see cref="DeviceChangeEventData"/> class.
/// Initializes a new instance of the <see cref="EventData"/> class.
/// </summary>
/// <param name="data">
/// The data.
/// </param>
public DeviceChangeEventData(NedeviceData data)
{
this.Dn = data.DeviceId;
this.LoggingComputer = data.DeviceId;
this.Message = data.Description;
this.NedeviceData = data;
}
/// <summary>
/// Initializes a new instance of the <see cref="DeviceChangeEventData" /> class.
/// Initializes a new instance of the <see cref="EventData" /> class.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="eSightIp">The e sight ip.</param>
public DeviceChangeEventData(NedeviceData data, string eSightIp, ServerTypeEnum serverType)
{
this.DeviceId = $"{eSightIp}-{data.DeviceId}";
this.LoggingComputer = data.DeviceId;
this.ESightIp = eSightIp;
this.Message = data.Description;
this.NedeviceData = data;
}
/// <summary>
/// Submit device changed event to processing queue
/// </summary>
/// <param name="data">The data.</param>
public void SubmitNewDeviceEvent(NedeviceData data)
{
logger.Polling.Info($"[{data.DeviceId}] Submit new eSight device event to processing queue.");
lock (deviceEventQueuelocker)
{
deviceEventQueue.Enqueue(data);
}
this.receiveDeviceEvent.Set();
}
/// <summary>
/// Start Device event processor
/// </summary>
private void StartNeDeviceEventProcessor()
{
if (deviceEventProcessor == null)
{
deviceEventProcessor = new Thread(delegate()
{
while (this.IsRunning)
{
logger.Polling.Info($"Current Device Event Processing Queue amount: {deviceEventQueue.Count}.");
if (deviceEventQueue.Count > 0 || receiveDeviceEvent.WaitOne())
{
NedeviceData eventObject = null;
lock (deviceEventQueuelocker)
{
if (deviceEventQueue.Count > 0)
{
eventObject = deviceEventQueue.Dequeue();
}
}
if (eventObject != null)
{
logger.Polling.Info($"[{eventObject.DeviceId}] Start processing new device event.");
// should we catagory alarm with server type ?
var deviceId = eventObject.DeviceId;
MonitoringDeviceObject monitoringObject = GetDeviceByDN(deviceId);
if (monitoringObject == null)
{
logger.Polling.Error($"[{eventObject.DeviceId}] No MonitoringObject({deviceId}) exists, event will be ignore");
continue;
}
// waiting for monitoring-object ready.
WaitForDeviceMonitored(monitoringObject);
// Create New EventLog for new events, and generate SCOM event through associated rule
CreateNewEventLogForDeviceEvent(eventObject);
}
}
}
});
}
this.deviceEventProcessor.Start();
logger.Polling.Info("Device event processor starts successfully.");
}
/// <summary>
/// Inserts the device change event.
/// </summary>
/// <param name="data">The data.</param>
public void InsertDeviceChangeEvent(NedeviceData data)
{
Task.Run(() =>
{
try
{
var serverType = this.GetServerType(data.DeviceId);
HWLogger.NOTIFICATION_PROCESS.Info($"Start deviceChangeEvent :{data.DeviceId}");
var deviceChangeEventData = new DeviceChangeEventData(data);
switch (serverType)
{
case ServerTypeEnum.Blade:
BladeConnector.Instance.InsertDeviceChangeEvent(deviceChangeEventData);
break;
case ServerTypeEnum.ChildBlade:
BladeConnector.Instance.InsertChildDeviceChangeEvent(deviceChangeEventData);
break;
case ServerTypeEnum.Highdensity:
HighdensityConnector.Instance.InsertDeviceChangeEvent(deviceChangeEventData);
break;
case ServerTypeEnum.ChildHighdensity:
HighdensityConnector.Instance.InsertChildDeviceChangeEvent(deviceChangeEventData);
break;
case ServerTypeEnum.Rack:
RackConnector.Instance.InsertDeviceChangeEvent(deviceChangeEventData);
break;
case ServerTypeEnum.KunLun:
KunLunConnector.Instance.InsertDeviceChangeEvent(deviceChangeEventData);
break;
}
HWLogger.NOTIFICATION_PROCESS.Info($"End deviceChangeEvent: {data.DeviceId}");
}
catch (Exception ex)
{
HWLogger.UI.Error("InsertEvent Error: ", ex);
}
});
}
private void CreateNewEventLogForDeviceEvent(NedeviceData eventObject)
{
logger.Polling.Info($"[{eventObject.DeviceId}] Persist event to window EventLog now.");
// Create new event log instance
var eventId = 400 + eventIdSuffixs.ElementAt(idx++ % eventIdSuffixs.Count);
EventInstance instance = new EventInstance(eventId, 0, EventLogEntryType.Information);
var deviceId = $"{this.ESightIp}-{eventObject.DeviceId}";
object[] values = new object[] {
"Device changed notification", // channel
deviceId, // SCOM monitor object DN
eventObject.Description,
};
EventLog.WriteEvent(EVENT_SOURCE, instance, values);
this.logger.Polling.Info($"[{eventObject.DeviceId}] Persist event to window EventLog successfully.");
}
/// <summary>
/// Inserts the device change event.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="serverType">Type of the server.</param>
public void InsertDeviceChangeEvent(NedeviceData data, ServerTypeEnum serverType)
{
Task.Run(() =>
{
try
{
//logger.NotifyProcess.Info($"Start Insert deviceChangeEvent.[Dn:{data.DeviceId}] [serverType:{serverType}]");
var deviceChangeEventData = new DeviceChangeEventData(data, this.ESightIp, serverType);
switch (serverType)
{
case ServerTypeEnum.Blade:
case ServerTypeEnum.ChildBlade:
case ServerTypeEnum.Switch:
BladeConnector.Instance.InsertDeviceChangeEvent(deviceChangeEventData, serverType, this.ESightIp);
break;
case ServerTypeEnum.Highdensity:
case ServerTypeEnum.ChildHighdensity:
HighdensityConnector.Instance.InsertDeviceChangeEvent(deviceChangeEventData, serverType, this.ESightIp);
break;
case ServerTypeEnum.Rack:
RackConnector.Instance.InsertDeviceChangeEvent(deviceChangeEventData, this.ESightIp);
break;
case ServerTypeEnum.KunLun:
KunLunConnector.Instance.InsertDeviceChangeEvent(deviceChangeEventData, this.ESightIp);
break;
}
//logger.NotifyProcess.Info($"End deviceChangeEvent: {data.DeviceId}");
}
catch (Exception ex)
{
logger.NotifyProcess.Error(ex, "InsertEvent Error: ");
}
});
}
