public HistoryDBManagerService(StatefulServiceContext context)
: base(context)
{
this.logger = CloudLoggerFactory.GetLogger(ServiceEventSource.Current, context);
this.baseLogString = $"{this.GetType()} [{this.GetHashCode()}] =>{Environment.NewLine}";
Logger.LogDebug($"{baseLogString} Ctor => Logger initialized");
try
{
this.historyDBManagerProvider = new HistoryDBManager(this.StateManager);
this.reportServiceProvider = new ReportService();
this.outageModelAccessProvider = new OutageModelAccess();
this.consumerAccessProvider = new ConsumerAccess();
this.equipmentAccessProvider = new EquipmentAccess();
this.notifyNetworkModelUpdateProvider = new OmsHistoryNotifyNetworkModelUpdate(this.StateManager);
this.transactionActorProvider = new OmsHistoryTransactionActor(this.StateManager);
this.historySubscriber = new HistorySubscriber(this.StateManager, this.historyDBManagerProvider);
string infoMessage = $"{baseLogString} Ctor => Contract providers initialized.";
Logger.LogInformation(infoMessage);
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} Ctor => Exception caught: {e.Message}.";
Logger.LogError(errorMessage, e);
}
}
public GdaService(StatelessServiceContext context)
: base(context)
{
this.logger = CloudLoggerFactory.GetLogger(ServiceEventSource.Current, context);
this.baseLogString = $"{this.GetType()} [{this.GetHashCode()}] =>{Environment.NewLine}";
Logger.LogDebug($"{baseLogString} Ctor => Logger initialized");
try
{
//LOGIC
_ = Config.GetInstance(this.Context);
string debugMessage = $"{baseLogString} Ctor => Configuration initialized.";
Logger.LogDebug(debugMessage);
//LOGIC
this.networkModel = new NetworkModel();
string infoMessage = $"{baseLogString} Ctor => NetworkModel created.";
Logger.LogInformation(infoMessage);
//LOGIC
this.genericDataAccess = new GenericDataAccess(networkModel);
this.nmsTransactionActor = new NmsTransactionActor(networkModel);
infoMessage = $"{baseLogString} Ctor => Contract providers initialized.";
Logger.LogInformation(infoMessage);
}
catch (Exception e)
{
string errMessage = $"{baseLogString} Ctor => Exception caught: {e.Message}.";
Logger.LogError(errMessage, e);
}
}
public ModelProviderService(StatefulServiceContext context)
: base(context)
{
this.baseLogString = $"{this.GetType()} [{this.GetHashCode()}] =>{Environment.NewLine}";
Logger.LogDebug($"{baseLogString} Ctor => Logger initialized");
try
{
//DONE THIS WAY (in this order) BECAUSE: there is a mechanism that tracks the initialization process of reliable collections, which is set in constructors of these classes
var modelResourceDesc = new ModelResourcesDesc();
var enumDescs = new EnumDescs();
//this.scadaModelImporter = new ScadaModelImporter(this.StateManager, modelResourceDesc, enumDescs);
this.modelReadAccessProvider = new ModelReadAccessProvider(this.StateManager);
this.modelUpdateAccessProvider = new ModelUpdateAccessProvider(this.StateManager);
this.integrityUpdateProvider = new IntegrityUpdateProvider(this.StateManager);
this.scadaNotifyNetworkModelUpdate = new ScadaNotifyNetworkModelUpdate(this.StateManager);
this.scadaTransactionActorProviders = new ScadaTransactionActor(this.StateManager, modelResourceDesc, enumDescs);
string infoMessage = $"{baseLogString} Ctor => Contract providers initialized.";
Logger.LogInformation(infoMessage);
ServiceEventSource.Current.ServiceMessage(this.Context, $"[SCADA.ModelProviderService | Information] {infoMessage}");
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} Ctor => Exception caught: {e.Message}.";
Logger.LogError(errorMessage, e);
ServiceEventSource.Current.ServiceMessage(this.Context, $"[SCADA.ModelProviderService | Error] {errorMessage}");
}
}
private async Task InvokeRollbackOnActors(string transactionName)
{
var enumerableActiveTransactions = await ActiveTransactions.GetEnumerableDictionaryAsync();
if (!enumerableActiveTransactions.ContainsKey(transactionName))
{
string errorMessage = $"{baseLogString} InvokeRollbackOnActors => transaction '{transactionName}' not found in '{ReliableDictionaryNames.ActiveTransactions}'.";
Logger.LogError(errorMessage);
throw new Exception(errorMessage);
}
var result = await TransactionEnlistmentLedger.TryGetValueAsync(transactionName);
if (!result.HasValue)
{
string errorMessage = $"{baseLogString} InvokeRollbackOnActors => Transaction '{transactionName}' not found in '{ReliableDictionaryNames.TransactionEnlistmentLedger}'.";
Logger.LogError(errorMessage);
throw new Exception(errorMessage);
}
var transactionLedger = result.Value;
List <Task> tasks = new List <Task>();
foreach (var transactionActorName in transactionLedger)
{
if (enumerableActiveTransactions[transactionName].Contains(transactionActorName))
{
var task = Task.Run(async() =>
{
ITransactionActorContract transactionActorClient = TransactionActorClient.CreateClient(transactionActorName);
await transactionActorClient.Rollback();
Logger.LogInformation($"{baseLogString} InvokeRollbackOnActors => Rollback invoked on Transaction actor: {transactionActorName}.");
});
tasks.Add(task);
}
}
Task.WaitAll(tasks.ToArray());
Logger.LogInformation($"{baseLogString} InvokeRollbackOnActors => Rollback SUCCESSFULLY invoked on all transaction actors.");
}
private async Task <bool> InvokePreparationOnActors(string transactionName)
{
bool success;
var enumerableActiveTransactions = await ActiveTransactions.GetEnumerableDictionaryAsync();
if (!enumerableActiveTransactions.ContainsKey(transactionName))
{
string errorMessage = $"{baseLogString} InvokePreparationOnActors => transaction '{transactionName}' not found in '{ReliableDictionaryNames.ActiveTransactions}'.";
Logger.LogError(errorMessage);
throw new Exception(errorMessage);
}
var result = await TransactionEnlistmentLedger.TryGetValueAsync(transactionName);
if (!result.HasValue)
{
string errorMessage = $"{baseLogString} InvokePreparationOnActors => Transaction '{transactionName}' not found in '{ReliableDictionaryNames.TransactionEnlistmentLedger}'.";
Logger.LogError(errorMessage);
throw new Exception(errorMessage);
}
var transactionLedger = result.Value;
if (!enumerableActiveTransactions[transactionName].SetEquals(transactionLedger))
{
string errorMessage = $"{baseLogString} InvokePreparationOnActors => not all actors have enlisted for the transaction '{transactionName}'.";
Logger.LogError(errorMessage);
throw new NotAllActorsEnlistedException(errorMessage);
}
List <Task <Tuple <string, bool> > > tasks = new List <Task <Tuple <string, bool> > >();
foreach (var transactionActorName in transactionLedger)
{
var task = Task.Run(async() =>
{
ITransactionActorContract transactionActorClient = TransactionActorClient.CreateClient(transactionActorName);
var prepareSuccess = await transactionActorClient.Prepare();
Logger.LogInformation($"{baseLogString} InvokePreparationOnActors => Prepare invoked on Transaction actor: {transactionActorName}, Success: {prepareSuccess}.");
return(new Tuple <string, bool>(transactionActorName, prepareSuccess));
});
tasks.Add(task);
}
var taskResults = await Task.WhenAll(tasks);
success = true;
foreach (var taskResult in taskResults)
{
var actorUri = taskResult.Item1;
var prepareSuccess = taskResult.Item2;
success = success && prepareSuccess;
if (success)
{
Logger.LogInformation($"{baseLogString} InvokePreparationOnActors => Preparation on Transaction actor: {actorUri} finsihed SUCCESSFULLY.");
}
else
{
Logger.LogInformation($"{baseLogString} InvokePreparationOnActors => Preparation on Transaction actor: {actorUri} finsihed UNSUCCESSFULLY.");
break;
}
}
return(success);
}
public NmsTransactionActor(ITransactionActorContract contractProvider)
{
this.baseLogString = $"{this.GetType()} [{this.GetHashCode()}] =>{Environment.NewLine}";
this.contractProvider = contractProvider;
}
