private void ProcessStateManagerSingleEntityNotification(NotifyStateManagerChangedEventArgs e)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
if (operation.Action == NotifyStateManagerChangedAction.Add)
{
var reliableStateType = operation.ReliableState.GetType();
switch (ReliableStateKindUtils.KindOfReliableState(operation.ReliableState))
{
case ReliableStateKind.ReliableDictionary:
{
var keyType = reliableStateType.GetGenericArguments()[0];
var valueType = reliableStateType.GetGenericArguments()[1];
this.GetType().GetMethod("ProcessStateManagerDictionaryChangedNotification", BindingFlags.Instance | BindingFlags.NonPublic)
.MakeGenericMethod(keyType, valueType)
.Invoke(this, new object[] { operation.ReliableState });
break;
}
case ReliableStateKind.ReliableQueue:
case ReliableStateKind.ReliableConcurrentQueue:
default:
break;
}
}
}
private async Task ProcessStateManagerRebuildNotification(NotifyStateManagerChangedEventArgs e)
{
int enumerated = 0;
bool dataByIdFound = false;
var timer = Stopwatch.StartNew();
ServiceFabricPersistenceEventSource.Log.ProcessStateManagerRebuildNotification();
var operation = e as NotifyStateManagerRebuildEventArgs;
using (var enumerator = operation.ReliableStates.GetAsyncEnumerator())
{
while (await enumerator.MoveNextAsync(this.cancellationToken))
{
enumerated++;
if (enumerator.Current is IReliableDictionary <long, WinFabPersistence.PersistedData> )
{
var dictionary = (IReliableDictionary <long, WinFabPersistence.PersistedData>)enumerator.Current;
this.SetFlagsForReliableDictionary(dictionary);
dictionary.RebuildNotificationAsyncCallback = this.OnDictionaryRebuildNotificationHandlerAsync;
// Ensure that the handler is registered only once by doing -= followed by +=
// It is safe to do -= even if no handler has been added.
dictionary.DictionaryChanged -= this.OnDictionaryChangedHandler;
dictionary.DictionaryChanged += this.OnDictionaryChangedHandler;
dataByIdFound = true;
ServiceFabricPersistenceEventSource.Log.ProcessStateManagerRebuildNotification_ReliableDictionaryFound(dictionary.Name.ToString());
}
}
}
ServiceFabricPersistenceEventSource.Log.ProcessStateManagerRebuildNotificationCompleted(enumerated, dataByIdFound, timer.ElapsedMilliseconds);
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.MonitoredHeadBreakerMeasurements)
{
this.monitoredHeadBreakerMeasurements = await ReliableDictionaryAccess <long, DiscreteModbusData> .Create(stateManager, ReliableDictionaryNames.MonitoredHeadBreakerMeasurements);
this.isMonitoredHeadBreakerMeasurementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MonitoredHeadBreakerMeasurements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.StartedIsolationAlgorithms)
{
this.startedIsolationAlgorithms = await ReliableDictionaryAccess <long, IsolationAlgorithm> .Create(stateManager, ReliableDictionaryNames.StartedIsolationAlgorithms);
this.isStartedIsolationAlgorithmsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.StartedIsolationAlgorithms}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.OutageTopologyModel)
{
this.outageTopologyModel = await ReliableDictionaryAccess <string, OutageTopologyModel> .Create(stateManager, ReliableDictionaryNames.OutageTopologyModel);
this.isOutageTopologyModelInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OutageTopologyModel}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandedElements)
{
this.commandedElements = await ReliableDictionaryAccess <long, CommandedElement> .Create(stateManager, ReliableDictionaryNames.CommandedElements);
this.isCommandedElementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandedElements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.SimulatedOutages)
{
simulatedOutages = await ReliableDictionaryAccess <long, SimulatedOutage> .Create(stateManager, ReliableDictionaryNames.SimulatedOutages);
this.isSimulatedOutagesInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.SimulatedOutages}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.MonitoredIsolationPoints)
{
monitoredIsolationPoints = await ReliableDictionaryAccess <long, MonitoredIsolationPoint> .Create(stateManager, ReliableDictionaryNames.MonitoredIsolationPoints);
this.isMonitoredIsolationPointsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MonitoredIsolationPoints}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableQueueNames.ReadCommandQueue)
{
this.readCommandQueue = await ReliableQueueAccess<ModbusFunction>.Create(stateManager, ReliableQueueNames.ReadCommandQueue);
this.isReadCommandQueueInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableQueueNames.ReadCommandQueue}' ReliableQueueAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableQueueNames.WriteCommandQueue)
{
this.writeCommandQueue = await ReliableQueueAccess<ModbusFunction>.Create(stateManager, ReliableQueueNames.WriteCommandQueue);
this.isWriteCommandQueueInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableQueueNames.WriteCommandQueue}' ReliableQueueAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableQueueNames.ModelUpdateCommandQueue)
{
this.modelUpdateCommandQueue = await ReliableQueueAccess<ModbusFunction>.Create(stateManager, ReliableQueueNames.ModelUpdateCommandQueue);
this.isModelUpdateCommandQueueInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableQueueNames.ModelUpdateCommandQueue}' ReliableQueueAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.ActiveTransactions)
{
activeTransactions = await ReliableDictionaryAccess <string, HashSet <string> > .Create(stateManager, ReliableDictionaryNames.ActiveTransactions);
isActiveTransactionsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.ActiveTransactions}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.TransactionEnlistmentLedger)
{
transactionEnlistmentLedger = await ReliableDictionaryAccess <string, HashSet <string> > .Create(stateManager, ReliableDictionaryNames.TransactionEnlistmentLedger);
isTransactionEnlistmentLedgerInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.TransactionEnlistmentLedger}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private void StateManager_StateManagerChanged(object sender, NotifyStateManagerChangedEventArgs e)
{
// state manager created
if (e.Action == NotifyStateManagerChangedAction.Add)
{
Task.Run(() => DuplicateMessages(CancellationToken.None));
}
}
private void StateManagerReplica_StateManagerChanged(object sender, NotifyStateManagerChangedEventArgs e)
{
EventHandler <NotifyStateManagerChangedEventArgs> handler = this.StateManagerChanged;
if (handler != null)
{
handler(sender, e);
}
}
private void StateManager_StateManagerChanged(object sender, NotifyStateManagerChangedEventArgs e)
{
// TODO : check if event target inputQueue only (no need to react on over state change)
// state manager created
if (e.Action == NotifyStateManagerChangedAction.Add)
{
Task.Run(() => DuplicateMessages(CancellationToken.None));
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.StartedIsolationAlgorithms)
{
this.startedIsolationAlgorithms = await ReliableDictionaryAccess <long, IsolationAlgorithm> .Create(stateManager, ReliableDictionaryNames.StartedIsolationAlgorithms);
this.isStartedIsolationAlgorithmsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.StartedIsolationAlgorithms}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.MonitoredHeadBreakerMeasurements)
{
this.monitoredHeadBreakerMeasurements = await ReliableDictionaryAccess <long, DiscreteModbusData> .Create(stateManager, ReliableDictionaryNames.MonitoredHeadBreakerMeasurements);
this.isMonitoredHeadBreakerMeasurementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MonitoredHeadBreakerMeasurements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.OutageTopologyModel)
{
this.outageTopologyModel = await ReliableDictionaryAccess <string, OutageTopologyModel> .Create(stateManager, ReliableDictionaryNames.OutageTopologyModel);
this.isOutageTopologyModelInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OutageTopologyModel}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.OptimumIsolationPoints)
{
this.optimumIsolationPoints = await ReliableDictionaryAccess <long, long> .Create(stateManager, ReliableDictionaryNames.OptimumIsolationPoints);
this.isOptimumIsolationPointsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OptimumIsolationPoints}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandedElements)
{
this.commandedElements = await ReliableDictionaryAccess <long, CommandedElement> .Create(stateManager, ReliableDictionaryNames.CommandedElements);
this.isCommandedElementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandedElements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
public void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Rebuild)
{
// throw new NotImplementedException();
}
else
{
ProcessStateManagerSingleEntityNotification(e);
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs eventArgs)
{
try
{
await InitializeReliableCollections(eventArgs);
}
catch (FabricNotPrimaryException)
{
Logger.LogDebug($"{baseLogString} OnStateManagerChangedHandler => NotPrimaryException. To be ignored.");
}
}
private void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
ServiceFabricPersistenceEventSource.Log.OnStateManagerChanged(e.Action.ToString());
if (e.Action == NotifyStateManagerChangedAction.Rebuild)
{
this.ProcessStateManagerRebuildNotification(e).GetAwaiter().GetResult();
return;
}
this.ProcessStateManagerSingleEntityNotification(e);
}
/// <summary>
/// 可靠状态管理器事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnStateManagerChangeHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Rebuild)
{
// this.ProcessStataManagerRebuildNotification(e);
return;
}
// this.ProcessStateManagerSingleEntityNotification(e);
}
private void StateManager_StateManagerChanged(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
NotifyStateManagerSingleEntityChangedEventArgs args = e as NotifyStateManagerSingleEntityChangedEventArgs;
if (args.ReliableState.Name.ToString() == "urn:" + HealthStatusDictionary)
{
IReliableDictionary <int, NationalCountyStats> dictionary = (IReliableDictionary <int, NationalCountyStats>)args.ReliableState;
dictionary.DictionaryChanged += this.Dictionary_DictionaryChanged;
}
}
}
/// <summary>
/// Handles the StateManagerChanged event of the StateManager control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="NotifyStateManagerChangedEventArgs" /> instance containing the event data.</param>
private void StateManager_StateManagerChanged(object sender, NotifyStateManagerChangedEventArgs e)
{
NotifyStateManagerSingleEntityChangedEventArgs operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
if (operation != null && operation.Action == NotifyStateManagerChangedAction.Add)
{
if (operation.ReliableState is IReliableDictionary <string, UserState> )
{
IReliableDictionary <string, UserState> dictionary = (IReliableDictionary <string, UserState>)operation.ReliableState;
dictionary.DictionaryChanged += this.Dictionary_DictionaryChanged;
}
}
}
/// <summary>
/// Called in response to a change on the state manager
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Rebuild)
{
ProcessStateManagerRebuildNotification(e);
return;
}
if (e.Action == NotifyStateManagerChangedAction.Add)
{
ProcessStateManagerAddNotification(e);
return;
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.ActiveOutages)
{
activeOutages = await ReliableDictionaryAccess <long, ActiveOutageMessage> .Create(this.stateManager, ReliableDictionaryNames.ActiveOutages);
this.isActiveOutagesInitialized = true;
}
}
}
/// <summary>
/// Called in response to an add change notification on the
/// state manager. This indicates that a collection has been
/// added. We use this to set our dictionary level callbacks
/// and notification handlers.
/// </summary>
/// <param name="e"></param>
private void ProcessStateManagerAddNotification(NotifyStateManagerChangedEventArgs e)
{
var entity = e as NotifyStateManagerSingleEntityChangedEventArgs;
if (entity.ReliableState is IReliableDictionary <string, Order> )
{
var dictionary = (IReliableDictionary <string, Order>)entity.ReliableState;
if (dictionary.Name.LocalPath == this.setName)
{
dictionary.RebuildNotificationAsyncCallback = this.OnDictionaryRebuildNotificationHandlerAsync;
dictionary.DictionaryChanged += this.OnDictionaryChangedHandler;
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.GidToPointItemMap)
{
//_ = GidToPointItemMap;
gidToPointItemMap = await ReliableDictionaryAccess <long, IScadaModelPointItem> .Create(stateManager, ReliableDictionaryNames.GidToPointItemMap);
isGidToPointItemMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.GidToPointItemMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.AddressToGidMap)
{
//_ = AddressToGidMap;
addressToGidMap = await ReliableDictionaryAccess <short, Dictionary <ushort, long> > .Create(stateManager, ReliableDictionaryNames.AddressToGidMap);
isAddressToGidMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.AddressToGidMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandDescriptionCache)
{
//_ = CommandDescriptionCache;
commandDescriptionCache = await ReliableDictionaryAccess <long, CommandDescription> .Create(stateManager, ReliableDictionaryNames.CommandDescriptionCache);
isCommandDescriptionCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandDescriptionCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.InfoCache)
{
//_ = InfoCache;
infoCache = await ReliableDictionaryAccess <string, bool> .Create(stateManager, ReliableDictionaryNames.InfoCache);
isInfoCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.InfoCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.CallsDictionary)
{
calls = await ReliableDictionaryAccess <long, long> .Create(this.stateManager, ReliableDictionaryNames.CallsDictionary);
this.isCallsDictionaryInitialized = true;
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.RegisteredSubscribersCache)
{
//_ = SubscriberCache;
registeredSubscribersCache = await ReliableDictionaryAccess <short, HashSet <string> > .Create(stateManager, ReliableDictionaryNames.RegisteredSubscribersCache);
isSubscriberCacheInitialized = true;
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.GidToPointItemMap)
{
gidToPointItemMap = await ReliableDictionaryAccess <long, IScadaModelPointItem> .Create(stateManager, ReliableDictionaryNames.GidToPointItemMap);
this.isGidToPointItemMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.GidToPointItemMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.MeasurementsCache)
{
measurementsCache = await ReliableDictionaryAccess <long, ModbusData> .Create(stateManager, ReliableDictionaryNames.MeasurementsCache);
this.isMeasurementsCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MeasurementsCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandDescriptionCache)
{
commandDescriptionCache = await ReliableDictionaryAccess <long, CommandDescription> .Create(stateManager, ReliableDictionaryNames.CommandDescriptionCache);
this.isCommandDescriptionCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandDescriptionCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.InfoCache)
{
infoCache = await ReliableDictionaryAccess <string, bool> .Create(stateManager, ReliableDictionaryNames.InfoCache);
isInfoCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.InfoCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.MonitoredHeadBreakerMeasurements)
{
this.monitoredHeadBreakerMeasurements = await ReliableDictionaryAccess <long, DiscreteModbusData> .Create(stateManager, ReliableDictionaryNames.MonitoredHeadBreakerMeasurements);
this.isMonitoredHeadBreakerMeasurementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MonitoredHeadBreakerMeasurements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.OutageTopologyModel)
{
this.outageTopologyModel = await ReliableDictionaryAccess <string, OutageTopologyModel> .Create(stateManager, ReliableDictionaryNames.OutageTopologyModel);
this.isOutageTopologyModelInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OutageTopologyModel}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandedElements)
{
this.commandedElements = await ReliableDictionaryAccess <long, CommandedElement> .Create(stateManager, ReliableDictionaryNames.CommandedElements);
this.isCommandedElementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandedElements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableQueueNames.PotentialOutages)
{
this.potentialOutagesQueue = await ReliableQueueAccess <PotentialOutageCommand> .Create(stateManager, ReliableQueueNames.PotentialOutages);
this.isPotentialOutagesQueueInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableQueueNames.PotentialOutages}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.HistoryModelChanges)
{
HistoryModelChanges = await ReliableDictionaryAccess <byte, List <long> > .Create(stateManager, ReliableDictionaryNames.HistoryModelChanges);
this.isHistoryModelChangesInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.HistoryModelChanges}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.OutageTopologyModel)
{
this.outageTopologyModel = await ReliableDictionaryAccess <string, OutageTopologyModel> .Create(stateManager, ReliableDictionaryNames.OutageTopologyModel);
this.isOutageTopologyModelInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OutageTopologyModel}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.RegisteredSubscribersCache)
{
//_ = SubscriberCache;
registeredSubscribersCache = await ReliableDictionaryAccess <short, HashSet <string> > .Create(stateManager, ReliableDictionaryNames.RegisteredSubscribersCache);
isSubscriberCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.RegisteredSubscribersCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.OpenedSwitches)
{
openedSwitches = await ReliableDictionaryAccess <long, long> .Create(this.stateManager, ReliableDictionaryNames.OpenedSwitches);
this.isOpenedSwitchesInitialized = true;
}
else if (reliableStateName == ReliableDictionaryNames.UnenergizedConsumers)
{
unenergizedConsumers = await ReliableDictionaryAccess <long, long> .Create(this.stateManager, ReliableDictionaryNames.UnenergizedConsumers);
this.isUnenergizedConsumersInitialized = true;
}
}
}
private void ProcessStateManagerSingleEntityNotification(NotifyStateManagerChangedEventArgs e)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
// Register OnDictionaryChangedHandler when dictionary is added so that no notification is missed.
if (operation.Action == NotifyStateManagerChangedAction.Add &&
operation.ReliableState is IReliableDictionary <long, WinFabPersistence.PersistedData> )
{
var dictionary = (IReliableDictionary <long, WinFabPersistence.PersistedData>)operation.ReliableState;
this.SetFlagsForReliableDictionary(dictionary);
// Ensure that the handler is registered only once by doing -= followed by +=
// It is safe to do -= even if no handler has been added.
dictionary.DictionaryChanged -= this.OnDictionaryChangedHandler;
dictionary.DictionaryChanged += this.OnDictionaryChangedHandler;
dictionary.RebuildNotificationAsyncCallback = this.OnDictionaryRebuildNotificationHandlerAsync;
ServiceFabricPersistenceEventSource.Log.ProcessStateManagerSingleEntityNotification_ReliableDictionaryAdded(dictionary.Name.ToString());
}
}
