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 static void InitDuplexServer() { var server = new DuplexServer(GetIpAddress()); server.RegisterHandler <CustomEventData, string>((session, e) => { Console.WriteLine(string.Concat("Server: ", e.FirstName)); return("OK from Server"); }); server.RegisterHandler <string, string>((session, e) => { Console.WriteLine(string.Concat("Server: ", e)); return("OK from Server"); }); server.Start(); var client = new DuplexClient(GetIpAddress()); client.RegisterHandler <CustomEventData, string>((session, e) => { Console.WriteLine(string.Concat("Client: ", e.FirstName)); return("OK from Client"); }); client.RegisterHandler <string, string>((session, e) => { Console.WriteLine(string.Concat("Client: ", e)); return("OK from Client"); }); client.Connect(); while (true) { var watch = new Stopwatch(); watch.Start(); var r1 = client.Send <CustomEventData, object>(new CustomEventData() { FirstName = "Stefan", LastName = "Heim", //Data = File.ReadAllBytes(@"c:\temp\Aktueller Mandant.pdf") }); Console.WriteLine(string.Concat("Server response: ", r1)); var r3 = client.Send <string, object>("Das ist ein Test"); Console.WriteLine(string.Concat("Server response: ", r3)); server.Send(new CustomEventData() { FirstName = "Stefan", LastName = "Heim", //Data = File.ReadAllBytes(@"c:\temp\Aktueller Mandant.pdf") }); server.Send("Das ist ein Test"); watch.Stop(); Console.WriteLine(string.Concat(watch.ElapsedMilliseconds, "ms")); Console.ReadLine(); } }
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(); }