public void HandleResult(IPublishableMessage message)
{
if (message is SingleAnalogValueSCADAMessage singleAnalog)
{
Dictionary <long, AnalogModbusData> data = new Dictionary <long, AnalogModbusData>(1)
{
{ singleAnalog.AnalogModbusData.MeasurementGid, singleAnalog.AnalogModbusData },
};
Provider.Instance.MeasurementProvider.UpdateAnalogMeasurement(data);
}
else if (message is MultipleAnalogValueSCADAMessage multipleAnalog)
{
Provider.Instance.MeasurementProvider.UpdateAnalogMeasurement(multipleAnalog.Data);
}
else if (message is SingleDiscreteValueSCADAMessage singleDiscrete)
{
Dictionary <long, DiscreteModbusData> data = new Dictionary <long, DiscreteModbusData>(1)
{
{ singleDiscrete.DiscreteModbusData.MeasurementGid, singleDiscrete.DiscreteModbusData },
};
Provider.Instance.MeasurementProvider.UpdateDiscreteMeasurement(data);
}
else if (message is MultipleDiscreteValueSCADAMessage multipleDiscrete)
{
Provider.Instance.MeasurementProvider.UpdateDiscreteMeasurement(multipleDiscrete.Data);
}
else
{
logger.LogError($"Message has unsupported type [{message.GetType().ToString()}].");
}
}
public void Notify(IPublishableMessage message)
{
if (message is ActiveOutageMessage activeOutage)
{
_dispatcher.Connect();
try
{
_dispatcher.NotifyActiveOutageUpdate(activeOutage);
}
catch (Exception)
{
//log error
// retry ?
}
}
else if (message is ArchivedOutageMessage archivedOutage)
{
_dispatcher.Connect();
try
{
_dispatcher.NotifyArchiveOutageUpdate(archivedOutage);
}
catch (Exception)
{
//log error
// retry ?
}
}
else
{
//todo: if anything?
}
}
private void TrackPublications(ISubscriberCallback subscriber, string subscriberName)
{
Logger.LogInfo($"Thread for tracking publications STARTED. Subscriber [{subscriberName}]");
bool end = false;
bool isMessageNull = false;
while (!end)
{
IPublishableMessage message = Subscribers.Instance.GetNextMessage(subscriber, isMessageNull);
isMessageNull = message == null;
if (!isMessageNull)
{
try
{
subscriber.Notify(message);
Logger.LogDebug($"Subscriber [{subscriberName}] notified SUCCESSFULLY.");
}
catch (Exception)
{
Logger.LogWarn($"Subscriber [{subscriberName}] is no longer in subscriber list.");
Subscribers.Instance.RemoveSubscriber(subscriber);
Publications.Instance.RemoveSubscriber(subscriber);
end = true;
}
}
Thread.Sleep(200);
}
Logger.LogInfo($"Thread for tracking publications STOPPED. Subscriber [{subscriberName}]");
}
public void Notify(IPublishableMessage message)
{
if (message is OMSModelMessage omsModelMessage)
{
TopologyModel = omsModelMessage.OutageTopologyModel; //TODO: Da li su subsciber callback pozivi sinhroni?
HashSet <long> energizedConsumers = new HashSet <long>();
foreach (var element in TopologyModel.OutageTopology.Values)
{
if (element.DmsType.Equals(DMSType.ENERGYCONSUMER.ToString()))
{
if (element.IsActive)
{
energizedConsumers.Add(element.Id);
}
}
}
ConsumersEnergized?.Invoke(energizedConsumers);
//foreach pair in queue
//while queue.COunt > 0
//queue.Dequee
while (PotentialOutage.Count > 0)
{
var tuple = PotentialOutage.Dequeue();
OutageService.reportOutageService.ReportPotentialOutage(tuple.Item1, tuple.Item2); //TODO: enum (error, noAffectedConsumers, success,...)
}
}
else
{
Logger.LogWarn("OutageModel::Notify => UNKNOWN message type. OMSModelMessage expected.");
}
}
public async Task Notify(IPublishableMessage message, string publisherName)
{
while (!ReliableDictionariesInitialized)
{
await Task.Delay(1000);
}
if (!(message is MultipleDiscreteValueSCADAMessage multipleDiscreteValueSCADAMessage))
{
string errorMessage = $"SCADA returned wrong value for in SCADAPublication. {typeof(MultipleDiscreteValueSCADAMessage)} excepted.";
Logger.LogError(errorMessage);
throw new Exception(errorMessage);
}
var enumerableMonitoredPoints = await MonitoredIsolationPoints.GetEnumerableDictionaryAsync();
var enumerableCommandedValues = await CommandedValues.GetEnumerableDictionaryAsync();
foreach (long measurementGid in multipleDiscreteValueSCADAMessage.Data.Keys)
{
if (!enumerableMonitoredPoints.ContainsKey(measurementGid))
{
continue;
}
var scadaDataValue = multipleDiscreteValueSCADAMessage.Data[measurementGid].Value;
await UpdateMonitoredPoints(measurementGid, enumerableMonitoredPoints, scadaDataValue);
await UpdateCommandedValues(measurementGid, enumerableCommandedValues, scadaDataValue);
}
}
public void Notify(IPublishableMessage msg)
{
Console.WriteLine("Message from PubSub: " + msg);
if (msg is MultipleAnalogValueSCADAMessage multipleAnalogValue)
{
foreach (long gid in multipleAnalogValue.Data.Keys)
{
double currentValue = multipleAnalogValue.Data[gid].Value;
AlarmType alarm = multipleAnalogValue.Data[gid].Alarm;
CommandOriginType commandOrigin = multipleAnalogValue.Data[gid].CommandOrigin;
Console.WriteLine($"Analog => Gid: 0x{gid:X16} Value: {currentValue}, Alarm: {alarm}, Origin: {commandOrigin}");
}
}
else if (msg is MultipleDiscreteValueSCADAMessage multipleDiscreteValue)
{
foreach (long gid in multipleDiscreteValue.Data.Keys)
{
ushort currentValue = multipleDiscreteValue.Data[gid].Value;
AlarmType alarm = multipleDiscreteValue.Data[gid].Alarm;
CommandOriginType commandOrigin = multipleDiscreteValue.Data[gid].CommandOrigin;
Console.WriteLine($"Discrete => Gid: 0x{gid:X16}, Value: {currentValue}, Alarm: {alarm}, Origin: {commandOrigin}");
}
}
else if (msg is ActiveOutageMessage activeOutage)
{
Console.WriteLine($"Active outage id: {activeOutage.OutageId}, affected consumers:{activeOutage.AffectedConsumers}, affected element: 0x{activeOutage.OutageElementGid:x16}");
}
}
public void Notify(IPublishableMessage message)
{
if (message is MultipleDiscreteValueSCADAMessage multipleDiscreteValueSCADAMessage)
{
//UPDATE
foreach (long gid in multipleDiscreteValueSCADAMessage.Data.Keys)
{
if (optimumIsolationPointsModbusData.ContainsKey(gid))
{
if (multipleDiscreteValueSCADAMessage.Data[gid].Value != optimumIsolationPointsModbusData[gid].Value)
{
optimumIsolationPointsModbusData[gid] = multipleDiscreteValueSCADAMessage.Data[gid];
}
}
}
foreach (long gid in multipleDiscreteValueSCADAMessage.Data.Keys)
{
if (defaultIsolationPointsModbusData.ContainsKey(gid))
{
if (multipleDiscreteValueSCADAMessage.Data[gid].Value != defaultIsolationPointsModbusData[gid].Value)
{
defaultIsolationPointsModbusData[gid] = multipleDiscreteValueSCADAMessage.Data[gid];
}
}
}
//COMMAND OPEN IF TRUE
Dictionary <long, DiscreteModbusData> defaultIsolationPointsToBeOpened = new Dictionary <long, DiscreteModbusData>();
foreach (long gid in defaultIsolationPointsModbusData.Keys)
{
if (defaultToOptimumIsolationPointMap.ContainsKey(gid))
{
long optimumPointGid = defaultToOptimumIsolationPointMap[gid];
if (optimumIsolationPointsModbusData.ContainsKey(optimumPointGid))
{
ushort optimumIsolationPointValue = optimumIsolationPointsModbusData[optimumPointGid].Value;
if (optimumIsolationPointValue == (ushort)DiscreteCommandingType.CLOSE)
{
defaultIsolationPointsToBeOpened.Add(gid, defaultIsolationPointsModbusData[gid]);
}
}
}
}
OpenIsolationPoints(defaultIsolationPointsToBeOpened);
}
else
{
string errorMessage = "SCADA returned wrong value for in SCADAPublication. MultipleDiscreteValueSCADAMessage excepted.";
Logger.LogError(errorMessage);
throw new Exception(errorMessage);
}
}
public async Task Notify(IPublishableMessage message, string publisherName)
{
while (!ReliableDictionariesInitialized)
{
await Task.Delay(1000);
}
if (message is EmailToOutageMessage emailMessage)
{
if (emailMessage.Gid == 0)
{
Logger.LogError("Invalid email received.");
return;
}
Logger.LogInformation($"Received call from Energy Consumer with GID: 0x{emailMessage.Gid:X16}.");
if (!modelResourcesDesc.GetModelCodeFromId(emailMessage.Gid).Equals(ModelCode.ENERGYCONSUMER))
{
Logger.LogWarning($"Received GID 0x{emailMessage.Gid:X16} is not id of energy consumer.");
return;
}
var topologyProviderClient = TopologyProviderClient.CreateClient();
var topology = await topologyProviderClient.GetOMSModel();
if (!topology.GetElementByGid(emailMessage.Gid, out OutageTopologyElement elment))
{
Logger.LogWarning($"Received GID 0x{emailMessage.Gid:X16} is not part of topology.");
return;
}
if (!timer.Enabled)
{
timer.Start();
}
await Calls.SetAsync(emailMessage.Gid, emailMessage.Gid);
Logger.LogInformation($"Current number of calls is: {await Calls.GetCountAsync()}.");
if (await Calls.GetCountAsync() >= expectedCalls)
{
await trackingAlgorithm.Start((await Calls.GetDataCopyAsync()).Keys.ToList());
await Calls.ClearAsync();
timer.Stop();
}
}
}
public void PublishMessage(ISubscriberCallback subscriber, IPublishableMessage message)
{
bool success = subscribers.TryGetValue(subscriber, out Queue <IPublishableMessage> queueOfMessages);
string subscriberName = GetSubscriberName(subscriber);
if (success)
{
queueOfMessages.Enqueue(message);
//TODO: check this log in particular
Logger.LogDebug($"Published message [{message}] SUCCESSFYLLY enqueued on Subscriber [{subscriberName}]");
}
else if (!subscribers.ContainsKey(subscriber))
{
Logger.LogWarn($"Subscriber [{subscriberName}, HasCode: {subscriber.GetHashCode()}] does not exist in collection of all subscribers.");
}
}
/// <summary>
/// Maps the input topology object to a graph object and dispatches it
/// to a Graph Hub endpoint
/// </summary>
/// <param name="message"></param>
public void Notify(IPublishableMessage message)
{
if (message is TopologyForUIMessage topologyMessage)
{
OmsGraphViewModel graph = _mapper.Map(topologyMessage.UIModel);
_dispatcher.Connect();
try
{
_dispatcher.NotifyGraphUpdate(graph.Nodes, graph.Relations);
}
catch (Exception)
{
// retry ?
}
}
}
public IPublishableMessage GetNextMessage(ISubscriberCallback subscriber, bool lastMessageWasNull = false)
{
IPublishableMessage message = null;
bool success = subscribers.TryGetValue(subscriber, out Queue <IPublishableMessage> queueOfMessages) && queueOfMessages.Count > 0;
string subscriberName = GetSubscriberName(subscriber);
if (success)
{
if (queueOfMessages.Count > 0)
{
message = queueOfMessages.Dequeue();
Logger.LogDebug($"Published message [{message}] SUCCESSFYLLY dequeued from Subscriber's queue of messages [Subscriber name: '{subscriberName}'].");
}
}
return(message);
}
public void Notify(IPublishableMessage message)
{
if (message is MultipleDiscreteValueSCADAMessage multipleDiscreteValueSCADAMessage)
{
long headBreakerID = OutageIsolationAlgorithmParameters.HeadBreakerMeasurementId;
long recloserID = OutageIsolationAlgorithmParameters.RecloserMeasurementId;
Logger.LogDebug("ScadaNotify from outage.");
if (multipleDiscreteValueSCADAMessage.Data.ContainsKey(headBreakerID))
{
if (multipleDiscreteValueSCADAMessage.Data[headBreakerID].Value == (ushort)DiscreteCommandingType.OPEN)
{
Logger.LogDebug("ScadaNotify from outage, open command.");
OutageIsolationAlgorithmParameters.AutoResetEvent.Set();
}
}
}
}
public async Task Notify(IPublishableMessage message, string publisherName)
{
Console.WriteLine($"Message received. Message Type: {message.GetType()}, PublisherName: {publisherName}");
if (message is TopologyForUIMessage uiTopologyMessage)
{
string uiTopologyString = $"FirstNode: 0x{uiTopologyMessage.UIModel.FirstNode:X16}{Environment.NewLine}" +
$"Count of Nodes: {uiTopologyMessage.UIModel.Nodes.Count}{Environment.NewLine}" +
$"Count of Relations: {uiTopologyMessage.UIModel.Relations.Count}{Environment.NewLine}";
Console.WriteLine(uiTopologyString);
}
else if (message is OMSModelMessage omsModelMessage)
{
string omsModelString = $"FirstNode: 0x{omsModelMessage.OutageTopologyModel.FirstNode:X16}{Environment.NewLine}" +
$"Count of Elements: {omsModelMessage.OutageTopologyModel.OutageTopology.Count}{Environment.NewLine}";
Console.WriteLine(omsModelString);
}
}
public async Task Notify(IPublishableMessage message, string publisherName)
{
if (message is SingleAnalogValueSCADAMessage singleAnalog)
{
var analogData = singleAnalog.AnalogModbusData;
string dataMessage = $"Gid: 0x{analogData.MeasurementGid:X16} | Value: {analogData.Value} | Alarm: {analogData.Alarm} | Origin: {analogData.CommandOrigin}";
ServiceEventSource.Current.ServiceMessage(this.Context, $"[TestService] Notify message single analog: {dataMessage}");
Logger.LogDebug(dataMessage);
}
else if (message is MultipleAnalogValueSCADAMessage multipleAnalog)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("[TestService] Notify message multiple analog: ");
foreach (var analogData in multipleAnalog.Data.Values)
{
sb.AppendLine($"Gid: 0x{analogData.MeasurementGid:X16} | Value: {analogData.Value} | Alarm: {analogData.Alarm} | Origin: {analogData.CommandOrigin}");
}
ServiceEventSource.Current.ServiceMessage(this.Context, sb.ToString());
Logger.LogDebug(sb.ToString());
}
else if (message is SingleDiscreteValueSCADAMessage singleDiscrete)
{
var discreteData = singleDiscrete.DiscreteModbusData;
string dataMessage = $"Gid: 0x{discreteData.MeasurementGid:X16} | Value: {discreteData.Value} | Alarm: {discreteData.Alarm} | Origin: {discreteData.CommandOrigin}";
ServiceEventSource.Current.ServiceMessage(this.Context, $"[TestService] Notify message single discrete: {dataMessage}");
Logger.LogDebug(dataMessage);
}
else if (message is MultipleDiscreteValueSCADAMessage multipleDiscrete)
{
StringBuilder sb = new StringBuilder();
sb.Append("[TestService] Notify message multiple discrete: ");
foreach (var discreteData in multipleDiscrete.Data.Values)
{
sb.AppendLine($"Gid: 0x{discreteData.MeasurementGid:X16} | Value: {discreteData.Value} | Alarm: {discreteData.Alarm} | Origin: {discreteData.CommandOrigin}");
}
ServiceEventSource.Current.ServiceMessage(this.Context, sb.ToString());
Logger.LogDebug(sb.ToString());
}
}
public void Notify(IPublishableMessage message)
{
if (message is SingleAnalogValueSCADAMessage)
{
SingleAnalogValueSCADAMessage msg = (SingleAnalogValueSCADAMessage)message;
Console.WriteLine($"Merenje: {msg.AnalogModbusData.MeasurementGid} {msg.AnalogModbusData.Value}");
}
else if (message is MultipleAnalogValueSCADAMessage)
{
MultipleAnalogValueSCADAMessage msg = (MultipleAnalogValueSCADAMessage)message;
foreach (var item in msg.Data)
{
Console.WriteLine($"Merenje: {item.Key} {item.Value}");
}
}
TopologyForUIMessage model = message as TopologyForUIMessage;
PrintUI(model.UIModel);
}
public async Task Notify(IPublishableMessage message, string publisherName)
{
Logger.LogDebug($"{baseLogString} Notify method invoked.");
if (message is SingleAnalogValueSCADAMessage singleAnalog)
{
Dictionary <long, AnalogModbusData> data = new Dictionary <long, AnalogModbusData>(1)
{
{ singleAnalog.AnalogModbusData.MeasurementGid, singleAnalog.AnalogModbusData },
};
Logger.LogDebug($"{baseLogString} Calling Update analog measurement from measurement provider.");
var measurementProviderClient = MeasurementProviderClient.CreateClient();
await measurementProviderClient.UpdateAnalogMeasurement(data);
}
else if (message is MultipleAnalogValueSCADAMessage multipleAnalog)
{
Logger.LogDebug($"{baseLogString} Calling Update analog measurement from measurement provider.");
var measurementProviderClient = MeasurementProviderClient.CreateClient();
await measurementProviderClient.UpdateAnalogMeasurement(multipleAnalog.Data);
}
else if (message is SingleDiscreteValueSCADAMessage singleDiscrete)
{
Dictionary <long, DiscreteModbusData> data = new Dictionary <long, DiscreteModbusData>(1)
{
{ singleDiscrete.DiscreteModbusData.MeasurementGid, singleDiscrete.DiscreteModbusData },
};
Logger.LogDebug($"{baseLogString} Calling Update discrete measurement from measurement provider.");
var measurementProviderClient = MeasurementProviderClient.CreateClient();
await measurementProviderClient.UpdateDiscreteMeasurement(data);
}
else if (message is MultipleDiscreteValueSCADAMessage multipleDiscrete)
{
Logger.LogDebug($"{baseLogString} Calling Update discrete measurement from measurement provider.");
var measurementProviderClient = MeasurementProviderClient.CreateClient();
await measurementProviderClient.UpdateDiscreteMeasurement(multipleDiscrete.Data);
}
else
{
Logger.LogError($"{baseLogString} ERROR Message has unsupported type [{message.GetType().ToString()}].");
}
}
public void Notify(IPublishableMessage message)
{
if (message is EmailToOutageMessage emailMessage)
{
if (emailMessage.Gid == 0)
{
Logger.LogError("Invalid email received.");
return;
}
Logger.LogInfo($"Received call from Energy Consumer with GID: 0x{emailMessage.Gid:X16}.");
if (!resourcesDesc.GetModelCodeFromId(emailMessage.Gid).Equals(ModelCode.ENERGYCONSUMER))
{
Logger.LogWarn("Received GID is not id of energy consumer.");
}
else if (!outageModel.TopologyModel.OutageTopology.ContainsKey(emailMessage.Gid) && outageModel.TopologyModel.FirstNode != emailMessage.Gid)
{
Logger.LogWarn("Received GID is not part of topology");
}
else
{
if (!timer.Enabled) //first message
{
StartTimer();
}
calls.Enqueue(emailMessage.Gid);
Logger.LogInfo($"Current number of calls is: {calls.Count}.");
if (calls.Count >= expectedCalls)
{
trackingAlgorithm.Start(calls);
StopTimer();
}
}
}
else
{
Logger.LogWarn("Received message is not EmailToOutageMessage.");
}
}
public void Notify(IPublishableMessage message)
{
if (message is MultipleAnalogValueSCADAMessage analogValuesMessage)
{
Dictionary <long, AnalogModbusData> analogModbusData = new Dictionary <long, AnalogModbusData>(analogValuesMessage.Data);
_dispatcher.Connect();
try
{
_dispatcher.NotifyScadaDataUpdate(analogModbusData);
}
catch (Exception)
{
//log error
// retry ?
}
}
else
{
//todo: if anything?
}
}
protected Publication(Topic topic, IPublishableMessage message)
{
Topic = topic;
Message = message;
}
public EmailServicePublication(Topic topic, IPublishableMessage message)
: base(topic, message)
{
}
public when_publishing_topic_message_to_rabbitmq()
{
bus = new FakeBus();
message = new TopicTestMessage();
publisher = new RabbitMQ.Publisher(bus);
}
public void Notify(IPublishableMessage message)
{
Logger.LogDebug($"Message recived from PubSub with type {message.GetType().ToString()}.");
Provider.Instance.SCADAResultHandler.HandleResult(message);
}
/// <summary>
/// OBAZRIVO, treba srediti cancellation tokene, sa tajmerima...
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public Task Notify(IPublishableMessage message, string publisherName)
{
//return MethodWrapperAsync("Notify", new object[2] { message, publisherName });
return(InvokeWithRetryAsync(client => client.Channel.Notify(message, publisherName)));
}
public async Task Notify(IPublishableMessage message, string publisherName)
{
Logger.LogDebug($"{baseLogString} Notify method invoked. Publisher {publisherName}.");
while (!isActiveOutagesInitialized)
{
await Task.Delay(1000);
}
if (message is ActiveOutageMessage activeOutageMessage)
{
await ActiveOutages.SetAsync(activeOutageMessage.OutageId, activeOutageMessage);
foreach (var equipment in activeOutageMessage.OptimumIsolationPoints)
{
await this.historyDBManager.UpdateClosedSwitch(equipment.EquipmentId, activeOutageMessage.OutageId);
}
foreach (var equipment in activeOutageMessage.DefaultIsolationPoints)
{
await this.historyDBManager.UpdateClosedSwitch(equipment.EquipmentId, activeOutageMessage.OutageId);
}
foreach (var consumer in activeOutageMessage.AffectedConsumers)
{
await this.historyDBManager.UpdateConsumer(consumer.ConsumerId, activeOutageMessage.OutageId);
}
}
else if (message is ArchivedOutageMessage archiveOutageMessage)
{
if (await ActiveOutages.ContainsKeyAsync(archiveOutageMessage.OutageId))
{
await ActiveOutages.TryRemoveAsync(archiveOutageMessage.OutageId);
}
else
{
Logger.LogWarning($"{baseLogString} WARNING Acrhived outage arrived, but there is no such in active outages. Outage Id {archiveOutageMessage.OutageId}.");
}
}
else if (message is TopologyForUIMessage topology)
{
List <long> blackedOut = new List <long>();
HashSet <long> energized = new HashSet <long>();
Dictionary <long, ActiveOutageMessage> outages = await ActiveOutages.GetEnumerableDictionaryAsync();
foreach (var element in topology.UIModel.Nodes.Values)
{
DMSType type = (DMSType)ModelCodeHelper.ExtractTypeFromGlobalId(element.Id);
if (type == DMSType.ENERGYCONSUMER)
{
if (element.IsActive)
{
energized.Add(element.Id);
}
else
{
var outageId = await CheckConsumer(element.Id);
await this.historyDBManager.OnConsumerBlackedOut(element.Id, outageId);
//blackedOut.Add(element.Id);
}
}
else if (type == DMSType.LOADBREAKSWITCH ||
type == DMSType.BREAKER ||
type == DMSType.FUSE ||
type == DMSType.DISCONNECTOR)
{
if (IsOpened(element))
{
var outageId = await CheckSwitch(element.Id);
await this.historyDBManager.OnSwitchOpened(element.Id, outageId);
}
else
{
await this.historyDBManager.OnSwitchClosed(element.Id);
}
}
}
//await this.historyDBManager.OnConsumerBlackedOut(blackedOut, null);
await this.historyDBManager.OnConsumersEnergized(energized);
}
}
public void Notify(IPublishableMessage message)
{
IOutageTopologyModel outageTopologyModel = message as IOutageTopologyModel;
}
public async Task Notify(IPublishableMessage message, string publisherName)
{
if (message is ActiveOutageMessage activeOutage)
{
Logger.LogInformation($"{baseLogString} Notify => ActiveOutageMessageReceived. OutageId: 0x{activeOutage.OutageId:x16} ElementId: 0x{activeOutage.OutageElementGid}");
var outageDispatcher = new OutageHubDispatcher(_outageMapper);
outageDispatcher.Connect();
try
{
await outageDispatcher.NotifyActiveOutageUpdate(activeOutage);
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} Notify => exception {e.Message}";
Logger.LogError(errorMessage, e);
}
}
else if (message is ArchivedOutageMessage archivedOutage)
{
var outageDispatcher = new OutageHubDispatcher(_outageMapper);
outageDispatcher.Connect();
try
{
await outageDispatcher.NotifyArchiveOutageUpdate(archivedOutage);
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} Notify => exception {e.Message}";
Logger.LogError(errorMessage, e);
}
}
else if (message is TopologyForUIMessage topologyMessage)
{
OmsGraphViewModel graph = _graphMapper.Map(topologyMessage.UIModel);
var graphDispatcher = new GraphHubDispatcher();
graphDispatcher.Connect();
try
{
await graphDispatcher.NotifyGraphUpdate(graph.Nodes, graph.Relations);
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} Notify => exception {e.Message}";
Logger.LogError(errorMessage, e);
}
}
else if (message is MultipleAnalogValueSCADAMessage analogValuesMessage)
{
Dictionary <long, AnalogModbusData> analogModbusData = new Dictionary <long, AnalogModbusData>(analogValuesMessage.Data);
var scadaDispatcher = new ScadaHubDispatcher();
scadaDispatcher.Connect();
try
{
await scadaDispatcher.NotifyScadaDataUpdate(analogModbusData);
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} Notify => exception {e.Message}";
Logger.LogError(errorMessage, e);
}
}
}
public when_publishing_a_null_message_to_rabbitmq()
{
bus = new FakeBus();
message = null;
publisher = new global::Workflow.RabbitMQ.Publisher(bus);
}
public async Task Notify(IPublishableMessage message, string publisherName)
{
Logger.LogDebug($"{baseLogString} Notify method started.");
while (!ReliableDictionariesInitialized)
{
await Task.Delay(1000);
}
try
{
if (message is MultipleDiscreteValueSCADAMessage multipleDiscreteValueSCADAMessage)
{
Logger.LogDebug($"{baseLogString} MultipleDiscreteValueSCADAMessage received.");
var discreteData = multipleDiscreteValueSCADAMessage.Data;
#region HeadBreakers
var enumerableHeadBreakerMeasurements = await MonitoredHeadBreakerMeasurements.GetEnumerableDictionaryAsync();
foreach (var headMeasurementGid in enumerableHeadBreakerMeasurements.Keys)
{
if (!discreteData.ContainsKey(headMeasurementGid))
{
continue;
}
await MonitoredHeadBreakerMeasurements.SetAsync(headMeasurementGid, discreteData[headMeasurementGid]);
}
#endregion HeadBreakers
#region CommandedElements
var measurementProviderClient = MeasurementProviderClient.CreateClient();
var enumerableCommandedElements = await CommandedElements.GetEnumerableDictionaryAsync();
foreach (var commandedElementGid in enumerableCommandedElements.Keys)
{
var measurementGid = (await measurementProviderClient.GetMeasurementsOfElement(commandedElementGid)).FirstOrDefault();
var measurement = await measurementProviderClient.GetDiscreteMeasurement(measurementGid);
if (measurement is ArtificalDiscreteMeasurement)
{
await CommandedElements.TryRemoveAsync(commandedElementGid);
Logger.LogInformation($"{baseLogString} Notify => Command on element 0x{commandedElementGid:X16} executed (ArtificalDiscreteMeasurement). New value: {measurement.CurrentOpen}");
continue;
}
if (!discreteData.ContainsKey(measurementGid))
{
continue;
}
if (discreteData[measurementGid].Value == (ushort)enumerableCommandedElements[commandedElementGid].CommandingType)
{
if ((await CommandedElements.TryRemoveAsync(commandedElementGid)).HasValue)
{
Logger.LogInformation($"{baseLogString} Notify => Command on element 0x{commandedElementGid:X16} executed. New value: {discreteData[measurementGid].Value}");
}
}
}
#endregion CommandedElements
}
else if (message is OMSModelMessage omsModelMessage)
{
Logger.LogDebug($"{baseLogString} OMSModelMessage received. Count {omsModelMessage.OutageTopologyModel.OutageTopology.Count}");
OutageTopologyModel topology = omsModelMessage.OutageTopologyModel;
await OutageTopologyModel.SetAsync(ReliableDictionaryNames.OutageTopologyModel, topology);
var reportingOutageClient = PotentialOutageReportingClient.CreateClient();
while (true)
{
var result = await PotentialOutagesQueue.TryDequeueAsync();
if (!result.HasValue)
{
break;
}
var command = result.Value;
await reportingOutageClient.ReportPotentialOutage(command.ElementGid, command.CommandOriginType, command.NetworkType);
Logger.LogInformation($"{baseLogString} PotentianOutageCommand executed. ElementGid: 0x{command.ElementGid:X16}, OriginType: {command.CommandOriginType}");
}
}
else
{
Logger.LogWarning($"{baseLogString} Notify => unexpected type of message: {message.GetType()}");
return;
}
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} Notify => Exception: {e.Message}";
Logger.LogError(errorMessage, e);
}
}
public when_publishing_a_message_and_the_underlying_bus_fails()
{
bus = new FailingBus();
message = new TestMessage();
publisher = new global::Workflow.RabbitMQ.Publisher(bus, new TestingRetryStrategy());
}
/// <summary>
/// Publish an encapsulated message to the bus
/// </summary>
/// <param name="messageBus">The message bus</param>
/// <param name="message">The encapsulated message with all necessary publish details</param>
public static void PublishMessage(this IPublishable messageBus, IPublishableMessage message)
{
Assert.ArgumentNotNull(messageBus, nameof(messageBus));
Assert.ArgumentNotNull(message, nameof(message));
message.PublishTo(messageBus);
}
