public bool ApplyUpdate(List <long> inserted, List <long> updated, List <long> deleted)
{
if (inserted == null || updated == null || deleted == null)
{
return(false);
}
lock (updateLock)
{
if (CalculationEngineService.inserted != null)
{
return(false);
}
bool ok;
DuplexClient <ITransactionManager, ITransaction> client = new DuplexClient <ITransactionManager, ITransaction>("callbackEndpoint", this);
client.Connect();
if (!client.Call <bool>(tm => tm.Enlist(), out ok) || !ok)
{
client.Disconnect();
return(false);
}
CalculationEngineService.inserted = inserted;
CalculationEngineService.updated = updated;
CalculationEngineService.deleted = deleted;
return(true);
}
}
public bool Reconnect()
{
clientLock.EnterWriteLock();
try
{
if (this.client != null)
{
this.client.Disconnect();
}
DuplexClient <ISubscribing, IPubSubClient> client = new DuplexClient <ISubscribing, IPubSubClient>("callbackEndpoint", this);
client.Connect();
if (!client.Call <bool>(sub => { sub.Subscribe(ETopic.NetworkModelChanged); sub.Subscribe(ETopic.MeasurementValuesChanged); sub.Subscribe(ETopic.TopologyChanged); sub.Subscribe(ETopic.LoadFlowChanged); sub.Subscribe(ETopic.MarkedSwitchesChanged); return(true); }, out _))
{
return(false);
}
this.client = client;
}
finally
{
clientLock.ExitWriteLock();
}
return(true);
}
public bool Start()
{
Stop();
client.Connect();
if (!client.Call <bool>(sub => { sub.Subscribe(ETopic.NetworkModelChanged); sub.Subscribe(ETopic.TopologyChanged); return(true); }, out _))
{
Logger.Instance.Log(ELogLevel.ERROR, "Cannot connect to PubSub.");
}
DownloadModel();
StartSimulation();
return(modbusServer.Start());
}
public UpdateResult ApplyUpdate(Delta delta)
{
lock (updateLock)
{
bool ok;
DuplexClient <ITransactionManager, ITransaction> client = new DuplexClient <ITransactionManager, ITransaction>("callbackEndpoint", this);
client.Connect();
if (!client.Call <bool>(tm => tm.StartEnlist(), out ok) || !ok) //TM.StartEnlist()
{
client.Disconnect();
return(new UpdateResult(ResultType.Failure));
}
NetworkModel tModel = new NetworkModel(model);
Tuple <Dictionary <long, long>, List <long>, List <long> > result = tModel.ApplyUpdate(delta);
if (result == null)
{
client.Call <bool>(tm => tm.EndEnlist(false), out ok); //TM.EndEnlist(false)
client.Disconnect();
return(new UpdateResult(ResultType.Failure));
}
lock (modelLock)
{
transactionModel = tModel;
}
if (!client.Call <bool>(tm => tm.Enlist(), out ok) || !ok) //TM.Enlist()
{
lock (modelLock)
{
transactionModel = model;
}
client.Call <bool>(tm => tm.EndEnlist(false), out ok); //TM.EndEnlist(false)
client.Disconnect();
return(new UpdateResult(ResultType.Failure));
}
{
Client <ISCADAServiceContract> scadaClient = new Client <ISCADAServiceContract>("SCADAEndpoint"); // Call SCADA
scadaClient.Connect();
if (!scadaClient.Call <bool>(scada => scada.ApplyUpdate(new List <long>(result.Item1.Values), result.Item2, result.Item3), out ok) || !ok)
{
scadaClient.Disconnect();
lock (modelLock)
{
transactionModel = model;
}
client.Call <bool>(tm => tm.EndEnlist(false), out ok); //TM.EndEnlist(false)
client.Disconnect();
return(new UpdateResult(ResultType.Failure));
}
scadaClient.Disconnect();
}
{
Client <ICalculationEngineServiceContract> ceClient = new Client <ICalculationEngineServiceContract>("CEEndpoint"); // Call CE
ceClient.Connect();
if (!ceClient.Call <bool>(ce => ce.ApplyUpdate(new List <long>(result.Item1.Values), result.Item2, result.Item3), out ok) || !ok)
{
ceClient.Disconnect();
lock (modelLock)
{
transactionModel = model;
}
client.Call <bool>(tm => tm.EndEnlist(false), out ok); //TM.EndEnlist(false)
client.Disconnect();
return(new UpdateResult(ResultType.Failure));
}
ceClient.Disconnect();
}
if (!client.Call <bool>(tm => tm.EndEnlist(true), out ok) || !ok) //TM.EndEnlist(true)
{
lock (modelLock)
{
transactionModel = model;
}
client.Disconnect();
return(new UpdateResult(ResultType.Failure));
}
client.Disconnect();
bool success;
lock (modelLock)
{
success = model == tModel;
}
if (success)
{
Client <IPublishing> pubClient = new Client <IPublishing>("publishingEndpoint");
pubClient.Connect();
pubClient.Call <bool>(pub =>
{
pub.Publish(new NetworkModelChanged());
return(true);
}, out ok);
pubClient.Disconnect();
}
return(success ? new UpdateResult(ResultType.Success, null, result.Item1, result.Item2, result.Item3) : new UpdateResult(ResultType.Failure));
}
}
void TopologyUpdated()
{
Client <ICalculationEngineServiceContract> client = new Client <ICalculationEngineServiceContract>("endpointCE");
client.Connect();
List <Tuple <long, List <Tuple <long, long> >, List <Tuple <long, long> > > > result = null;
bool success;
if (!client.Call <bool>(ce => { result = ce.GetLineEnergization(); return(true); }, out success) || !success)
{
client.Disconnect();
return;
}
client.Disconnect();
modelLock.EnterReadLock();
Dictionary <long, EEnergization> cnStates = new Dictionary <long, EEnergization>(reclosers.Count * 2);
foreach (Tuple <Recloser, long, long, int> r in reclosers)
{
cnStates[r.Item2] = EEnergization.NotEnergized;
cnStates[r.Item3] = EEnergization.NotEnergized;
}
List <long> reclosersWithoutSCADA = new List <long>();
try
{
foreach (Tuple <long, List <Tuple <long, long> >, List <Tuple <long, long> > > source in result)
{
foreach (Tuple <long, long> energizedLine in source.Item2)
{
if (cnStates.ContainsKey(energizedLine.Item1))
{
cnStates[energizedLine.Item1] = EEnergization.Energized;
}
if (cnStates.ContainsKey(energizedLine.Item2))
{
cnStates[energizedLine.Item2] = EEnergization.Energized;
}
}
foreach (Tuple <long, long> unknownLine in source.Item3)
{
EEnergization state;
if (cnStates.TryGetValue(unknownLine.Item1, out state) && state == EEnergization.Unknown)
{
cnStates[unknownLine.Item1] = EEnergization.Unknown;
}
if (cnStates.TryGetValue(unknownLine.Item2, out state) && state == EEnergization.Unknown)
{
cnStates[unknownLine.Item2] = EEnergization.Unknown;
}
}
}
foreach (Tuple <Recloser, long, long, int> r in reclosers)
{
EEnergization[] states = new EEnergization[] { cnStates[r.Item2], cnStates[r.Item3] };
if (states[0] == EEnergization.Unknown || states[1] == EEnergization.Unknown)
{
continue;
}
if (states[0] != states[1])
{
if (r.Item4 < 0)
{
reclosersWithoutSCADA.Add(r.Item1.GID);
}
else
{
SetDiscreteInput(r.Item4, 0);
}
}
}
}
finally
{
modelLock.ExitReadLock();
}
if (reclosersWithoutSCADA.Count <= 0)
{
return;
}
client = new Client <ICalculationEngineServiceContract>("endpointCE");
client.Connect();
client.Call <bool>(ce =>
{
foreach (long gid in reclosersWithoutSCADA)
{
ce.MarkSwitchState(gid, false);
}
return(true);
}, out success);
client.Disconnect();
}
