static void SendOneWayQuery(string query)
{
#region Authorizing on remote machine
// Get rights to access remote machine.
//
// If you use anonymous conection than you need to apply server's LSA (LocalSecurityAuthority) rules:
// - permit Guest connection over network.
// - activate Guest user.
// Without this conection will terminated by server.
//
// Relative to setting of pipes also could be required:
// - anonymous access to named pipes
//
// ATTENTION: Message will not be encrypted before post.
// User SetRoutingInstruction (whrer instruction has RSAEncryption fields as true) instead TryLogon.
bool logonResult = General.TryToLogonAtRemoteDevice(
routingInstruction.logonConfig,
out SafeAccessTokenHandle safeTokenHandle);
if (!logonResult)
{
Console.WriteLine("Logon failed. Connection not possible.\nPress any key...");
Console.ReadKey();
return;
}
#endregion
// Create transmission line.
TransmissionLine lineProcessor = OpenOutTransmissionLineViaPP(SERVER_NAME, SERVER_PIPE_NAME);
// Set impersonate token.
lineProcessor.accessToken = safeTokenHandle;
// Add sample query to queue. You can use this way if you not need answer from server.
lineProcessor.EnqueueQuery(new Query(query));
}
public TransmissionLineDetailViewModel(object transmissionLine)
{
if (transmissionLine != null && transmissionLine is TransmissionLine)
{
m_transmissionLine = transmissionLine as TransmissionLine;
GetDivisions();
GetSubstations();
}
}
/// <summary>
/// The designated initializer for the <see cref="SynchrophasorAnalytics.Modeling.Node"/> class which requires the <see cref="SynchrophasorAnalytics.Modeling.VoltageLevel.InternalID"/> of the <see cref="SynchrophasorAnalytics.Modeling.VoltageLevel"/> and the required properties defined by the <see cref="SynchrophasorAnalytics.Modeling.INetworkDescribable"/> interface as well as references to its parent <see cref="SynchrophasorAnalytics.Modeling.Substation"/> and/or <see cref="SynchrophasorAnalytics.Modeling.TransmissionLine"/>.
/// </summary>
/// <param name="internalID">An integer identifier for each <see cref="SynchrophasorAnalytics.Modeling.Node"/> which is intended to be unique among other objects of the same type.</param>
/// <param name="number">A descriptive integer for the instance of the <see cref="SynchrophasorAnalytics.Modeling.Node"/>. There are no restrictions on uniqueness.</param>
/// <param name="acronym">A string acronym for the instance of the <see cref="SynchrophasorAnalytics.Modeling.Node"/>.</param>
/// <param name="name">The string name of the instance of the <see cref="SynchrophasorAnalytics.Modeling.Node"/>.</param>
/// <param name="description">A string description of the instance of the <see cref="SynchrophasorAnalytics.Modeling.Node"/>.</param>
/// <param name="voltageLevelID">The <see cref="SynchrophasorAnalytics.Modeling.VoltageLevel.InternalID"/> of the <see cref="SynchrophasorAnalytics.Modeling.VoltageLevel"/> of the <see cref="SynchrophasorAnalytics.Modeling.Node"/>.</param>
/// <param name="parentSubstation">The parent <see cref="SynchrophasorAnalytics.Modeling.Substation"/> of the <see cref="SynchrophasorAnalytics.Modeling.Node"/>.</param>
/// <param name="parentTransmissionLine">The parent <see cref="SynchrophasorAnalytics.Modeling.TransmissionLine"/> of the <see cref="SynchrophasorAnalytics.Modeling.Node"/>.</param>
public Node(int internalID, int number, string acronym, string name, string description, int voltageLevelID, Substation parentSubstation, TransmissionLine parentTransmissionLine)
{
m_internalID = internalID;
m_number = number;
m_acronym = acronym;
m_name = name;
m_description = description;
m_voltageLevelID = voltageLevelID;
m_parentSubstation = parentSubstation;
m_parentTransmissionLine = parentTransmissionLine;
}
public bool TryMerge(ObservableIsland island, NetworkModel model)
{
TransmissionLine connectingLine = ConnectingLineBetween(island, model);
if (connectingLine != null)
{
m_substations.AddRange(island.Substations);
return(true);
}
return(false);
}
/// <summary>
/// Adds a query to the queue.
/// Opens a backward line that will calls an answer handler.
/// </summary>
/// <param name="line">Line proccessor that control queries posting to target server.</param>
/// <param name="query">Query that will sent to server.</param>
/// <param name="answerHandler">Callback that will recive answer.</param>
public static void EnqueueDuplexQueryViaPP(
TransmissionLine line,
UniformQueries.Query query,
Action <TransmissionLine, UniformQueries.Query> answerHandler)
{
// Add our query to line processor queue.
line.EnqueueQuery(query);
// Open backward chanel to recive answer from server.
ReceiveDelayedAnswerViaPP(line, query, answerHandler);
}
private void BuildVertexSet(TransmissionLine transmissionLine)
{
m_vertexSet = new List <Node>();
foreach (Node node in transmissionLine.Nodes)
{
m_vertexSet.Add(node);
}
// The FromNode and ToNode are children of the FromSubstation and ToSubstation respectively but should be included in this vertex set.
m_vertexSet.Add(transmissionLine.FromNode);
m_vertexSet.Add(transmissionLine.ToNode);
}
/// <summary>
/// Adds a query to the queue.
/// Opens a backward line that will calls an answer handler.
/// </summary>
/// <param name="serverName">Name of the server. "." if local.</param>
/// <param name="serverPipeName">Name of pipe provided by server.</param>
/// <param name="query">Query that will sent to server.</param>
/// <param name="answerHandler">Callback that will recive answer.</param>
/// <returns>Established transmission line.</returns>
public static TransmissionLine EnqueueDuplexQueryViaPP(
string serverName,
string serverPipeName,
UniformQueries.Query query,
Action <TransmissionLine, UniformQueries.Query> answerHandler)
{
// Open transmission line.
TransmissionLine line = OpenOutTransmissionLineViaPP(serverName, serverPipeName);
// Equeue query to line.
EnqueueDuplexQueryViaPP(line, query, answerHandler);
return(line);
}
/// <summary>
/// Open a line that will be ready to recive server answer.
/// New line will created related to params of requesting line and sended query.
///
/// Attention: Not work with broadcasting server.
/// </summary>
/// <param name="line">Line that was used to transmition</param>
/// <param name="answerHandler">Delegate that will be called as handler for answer processing.
/// TransmissionLine contain data about actual transmission.
/// object contain recived query (usualy string or byte[]).</param>
/// <param name="entryQuery">Query that was recived from client.
/// Method will detect core part and establish backward connection.</param>
/// <returns></returns>
public static bool ReceiveDelayedAnswerViaPP(
TransmissionLine line,
UniformQueries.Query entryQuery,
Action <TransmissionLine, UniformQueries.Query> answerHandler)
{
#region Create backward domain
// Try to compute bacward domaint to contact with client.
if (!UniformQueries.QueryPart.TryGetBackwardDomain(entryQuery, out string domain))
{
Console.WriteLine("ERROR (BCRA0): Unable to buid backward domain. QUERY: " + entryQuery.ToString());
return(false);
}
#endregion
#region Append answer handler to backward table.
string hashKey = line.ServerName + "\\" + domain;
// Try to load registred callback to overriding.
if (DuplexBackwardCallbacks[hashKey] is
System.Action <TransmissionLine, UniformQueries.Query> registredCallback)
{
DuplexBackwardCallbacks[hashKey] = answerHandler;
}
else
{
// Add colback to table as new.
DuplexBackwardCallbacks.Add(hashKey, answerHandler);
}
#endregion
#region Opening transmition line
// Create transmission line.
TransmissionLine lineProcessor = OpenTransmissionLineViaPP(
new Standard.SimpleClient(),
line.ServerName, domain,
ref line.accessToken,
HandlerInputTransmissionAsync);
// Set input direction.
lineProcessor.Direction = TransmissionLine.TransmissionDirection.In;
#endregion
// Skip line
Console.WriteLine();
return(true);
}
private void BuildEdgeSet(TransmissionLine transmissionLine)
{
m_edgeSet = new List <ITwoTerminal>();
foreach (LineSegment lineSegment in transmissionLine.LineSegments)
{
m_edgeSet.Add(lineSegment);
}
foreach (Switch circuitSwitch in transmissionLine.Switches)
{
m_edgeSet.Add(circuitSwitch);
}
foreach (SeriesCompensator seriesCompensationDevice in transmissionLine.SeriesCompensators)
{
m_edgeSet.Add(seriesCompensationDevice);
}
}
/// <summary>
/// Recive message from broadcasting server.
/// ATTENTION: Eould connect to server as guest user.
/// </summary>
/// <param name="serverName">Srver name or ip.</param>
/// <param name="pipeName">Name of pipe started on server.</param>
/// <param name="answerHandler">Delegate that would to call when message received.</param>
/// <returns>Created line.</returns>
public static TransmissionLine ReceiveAnonymousBroadcastMessage(
string serverName,
string pipeName,
Action <TransmissionLine, UniformQueries.Query> answerHandler)
{
#region Append answer handler to backward table.
string hashKey = serverName + "\\" + pipeName;
// Try to load registred callback to overriding.
if (DuplexBackwardCallbacks[hashKey] is
System.Action <TransmissionLine, UniformQueries.Query> registredCallback)
{
// Override current delegate.
DuplexBackwardCallbacks[hashKey] = answerHandler;
}
else
{
// Add callback to table as new.
DuplexBackwardCallbacks.Add(hashKey, answerHandler);
}
#endregion
#region Opening transmition line
// Create transmission line.
Console.WriteLine("RABM: Oppening line to " + serverName + "/" + pipeName);
TransmissionLine line = OpenTransmissionLineViaPP(
serverName, pipeName,
HandlerInputTransmissionAsync);
// Set input direction.
line.Direction = TransmissionLine.TransmissionDirection.In;
#endregion
// Skip line
Console.WriteLine();
// Return created line.
return(line);
}
private void Start()
{
Transmitters = FindObjectsOfType <Transmitter>();
foreach (TransmissionLink link in TransmissionLinks)
{
TransmissionLine line = Instantiate(TransmissionLinePrefab);
line.Link = link;
line.Controller = this;
Transmitter t1 = Transmitters.First(t => t.Id == link.Transmitter1);
Transmitter t2 = Transmitters.First(t => t.Id == link.Transmitter2);
Vector3[] pos = new Vector3[]
{
Transmitters.First(t => t.Id == link.Transmitter1).transform.position,
Transmitters.First(t => t.Id == link.Transmitter2).transform.position
};
line.LineRenderer.SetPositions(pos);
line.LineRenderer.startWidth = .1f;
line.LineRenderer.startWidth = .2f;
t1.Links.Add(new Link()
{
Other = t2,
TLink = link
});
t2.Links.Add(new Link()
{
Other = t1,
TLink = link
});
}
}
private static void DeleteTransmissionLine(TransmissionLine transmissionLine)
{
transmissionLine.ParentDivision.TransmissionLines.Remove(transmissionLine);
}
/// <summary>
/// Redirect recived query from current server to other.
/// </summary>
/// <param name="tc">Server's transmission controller.</param>
/// <param name="query">Query received from client.</param>
public static void QueryHandler_DuplexRelay(BaseServerTransmissionController tc, UniformQueries.Query query)
{
bool decryptionComplete = false;
bool decryptionResult = false;
Task decryptionOperation = new Task(async delegate()
{
// Try to encrypt receved message.
decryptionResult = await EnctyptionOperatorsHandler.TryToDecryptAsync(
query,
EnctyptionOperatorsHandler.AsymmetricEO);
decryptionComplete = true;
});
decryptionOperation.Start();
// Whait for decription completing.
while (!decryptionComplete)
{
Thread.Sleep(5);
}
// Loging error to client.
if (!decryptionResult)
{
// Try to get answer in string format.
SendAnswerViaPP("DUPLEX RELEAY ERROR: Data corrupted." +
" Decryption not possible. Relay terminated.", query);
return;
}
// Detect routing target.
bool relayTargetFound =
UniformClient.BaseClient.routingTable.
TryGetRoutingInstruction(query, out Instruction instruction);
// If instruction not found.
if (!relayTargetFound)
{
// If reley target not found then server will mean that query requested to itself.
PipesProvider.Handlers.Queries.ProcessingAsync(tc, query);
//// Log
//Console.WriteLine("RELAY TARGET NOT FOUND: {q}", query);
//// DO BACKWARED ERROR INFORMATION.
//SendAnswer("error=404", UniformQueries.API.DetectQueryParts(query));
// Drop continue computing.
return;
}
// Open connection.
TransmissionLine tl = UniformClient.BaseClient.EnqueueDuplexQueryViaPP(
instruction.routingIP,
instruction.pipeName,
query,
// Delegate that will invoked when relayed server send answer.
// Redirects the answer to a client.
delegate(TransmissionLine answerTL, UniformQueries.Query receivedData)
{
// Try to get answer in string format.
SendAnswerViaPP(receivedData, query);
return;
});
}
// Create delegate that will recive and procced the server's answer.
static void ServerAnswerHandler_RSAPublicKey(TransmissionLine tl, object message)
{
string messageS = message as string;
Console.WriteLine("RSA Public Key recived:\n" + (messageS ?? "Message is null"));
}
/// <summary>
/// Provide complex initalization of all relative systems.
/// Build meta data, regitrate line in common table.
/// Start new thread to avoid freezes.
/// </summary>
/// <param name="client"></param>
/// <param name="token">Token that will be used for logon. on remote machine LSA.
/// Sharing by ref to allow update in internal lines.</param>
/// <param name="serverName">Name of IP adress of remote or local server.</param>
/// <param name="pipeName">Name of the pipe started on the server.</param>
/// <param name="callback">Method that will be called when connection will be established.</param>
/// <returns>Opened transmission line. Use line.Enqueue to add your query.</returns>
public static TransmissionLine OpenTransmissionLineViaPP(
BaseClient client,
string serverName,
string pipeName,
ref SafeAccessTokenHandle token,
Action <TransmissionLine> callback)
{
lock (lineLocker)
{
// Validate client.
if (client == null)
{
Console.WriteLine("CLIENT is NULL (BC_OTL_0). Unable to open new transmission line.");
return(null);
}
// Get target GUID.
string guid = TransmissionLine.GenerateGUID(serverName, pipeName);
//// Try to load trans line by GUID.
//ClientAPI.TryGetTransmissionLineByGUID(guid, out TransmissionLine trnsLine);
//if (trnsLine != null &&
// trnsLine.Direction == TransmissionLine.TransmissionDirection.Out)
if (ClientAPI.TryGetTransmissionLineByGUID(guid, out TransmissionLine trnsLine))
{
// If not obsolterd transmission line then drop operation.
if (!trnsLine.Closed)
{
Console.WriteLine("OTL {0} | FOUND", guid);
return(trnsLine);
}
else
{
// Unregister line and recall method.
ClientAPI.TryToUnregisterTransmissionLine(guid);
Console.WriteLine("OTL {0} | RETRY", guid);
// Retry.
return(OpenTransmissionLineViaPP(client, serverName, pipeName, ref token, callback));
}
}
// If full new pipe.
else
{
// Create new if not registred.
trnsLine = new TransmissionLine(
serverName,
pipeName,
callback,
ref token);
// Request thread start but let a time quantum only when this thread will pass order.
_ = StartPPClientThreadAsync(client, guid, trnsLine);
}
// Return oppened line.
return(trnsLine);
}
}
/// <summary>
/// Allow to start thread but previous return turn to current thread.
/// Allow to use single line queries.
/// </summary>
/// <param name="client"></param>
/// <param name="guid"></param>
/// <param name="trnsLine"></param>
protected static async Task StartPPClientThreadAsync(BaseClient client, string guid, TransmissionLine trnsLine)
{
await Task.Run(() => {
client.StartClientThread(
guid,
trnsLine,
TransmissionLine.ThreadLoop);
});
}
/// <summary>
/// Requsting a public encryption key from a server definded into the instruction.
/// </summary>
/// <param name="pai">An instruction that would be used for routing to target server.</param>
/// <returns>A started async task that returns result of keys exchanging process.</returns>
private static async Task <bool> RequestPublicEncryptionKeyAsync(PartialAuthorizedInstruction pai)
{
// TODO not work.
// Create base part of query for reciving of public RSA key.
UniformQueries.Query query = null;
try
{
query = new UniformQueries.Query(
null,
new UniformQueries.QueryPart("token", pai.GuestToken),
new UniformQueries.QueryPart("get"),
new UniformQueries.QueryPart("publickey"),
new UniformQueries.QueryPart("guid", pai.GetHashCode().ToString()))
{
WaitForAnswer = true // Request waiting for answer before computing of the next query in queue.
};
}
catch (Exception ex)
{
Console.WriteLine("Encryption failed (rpeka10): " + ex.Message);
return(false);
}
// Getting line to prevent conflict.
TransmissionLine line = OpenOutTransmissionLineViaPP(pai.routingIP, pai.pipeName);
// Insert query to processing with termination of current query.
line.InsertQuery(query, true);
bool result = false;
bool completed = false;
// Open backward chanel to recive answer from server.
ReceiveDelayedAnswerViaPP(line, query,
// Create callback delegate that will set recived value to routing table.
delegate(TransmissionLine answerLine, UniformQueries.Query answer)
{
// Try to apply recived answer.
result = pai.AsymmetricEncryptionOperator.UpdateWithQuery(answer);
// Log about update
Console.WriteLine("{0}/{1}: \"{2}\" public key updating status {3}",
pai.routingIP, pai.pipeName,
PipesProvider.Security.Encryption.EnctyptionOperatorsHandler
.GetOperatorCode(pai.AsymmetricEncryptionOperator),
result);
// Finalize operation.
completed = true;
});
// Wait for result.
while (!completed)
{
await Task.Delay(20, ClientAppConfigurator.TerminationTokenSource.Token);
}
return(result);
}
public void Filter(List <string> companyNames)
{
List <Company> retainedCompanies = new List <Company>();
List <Division> retainedDivisions = new List <Division>();
List <Station> retainedStations = new List <Station>();
List <Station> stationsToRemove = new List <Station>();
List <Node> retainedNodes = new List <Node>();
List <Node> nodesToRemove = new List <Node>();
List <LineSegment> lineSegmentsToRemove = new List <LineSegment>();
List <TransmissionLine> transmissionLinesToRemove = new List <TransmissionLine>();
List <CircuitBreaker> circuitBreakersToRemove = new List <CircuitBreaker>();
List <Shunt> shuntsToRemove = new List <Shunt>();
List <Transformer> transformersToRemove = new List <Transformer>();
List <TransformerTap> retainedTaps = new List <TransformerTap>();
List <ParentTransformer> parentTransformersToRemove = new List <ParentTransformer>();
Console.WriteLine("1");
// Line segments, companies, stations
Parallel.ForEach(m_lineSegments, (lineSegment) =>
{
string fromNodeId = $"{lineSegment.FromStationName}_{lineSegment.FromNodeId}";
string toNodeId = $"{lineSegment.ToStationName}_{lineSegment.ToNodeId}";
Node fromNode = m_nodes.Find(x => $"{x.StationName}_{x.Id}" == fromNodeId);
Node toNode = m_nodes.Find(x => $"{x.StationName}_{x.Id}" == toNodeId);
Company fromCompany = GetNodeCompany(fromNode);
Company toCompany = GetNodeCompany(toNode);
Station fromStation = m_stations.Find(x => x.Name == lineSegment.FromStationName);
Station toStation = m_stations.Find(x => x.Name == lineSegment.ToStationName);
if (companyNames.Contains(fromCompany.Name) || companyNames.Contains(toCompany.Name))
{
if (!retainedStations.Contains(fromStation))
{
retainedStations.Add(fromStation);
}
if (!retainedStations.Contains(toStation))
{
retainedStations.Add(toStation);
}
if (!retainedNodes.Contains(fromNode))
{
retainedNodes.Add(fromNode);
}
if (!retainedNodes.Contains(toNode))
{
retainedNodes.Add(toNode);
}
if (!retainedCompanies.Contains(fromCompany))
{
retainedCompanies.Add(fromCompany);
}
if (!retainedCompanies.Contains(toCompany))
{
retainedCompanies.Add(toCompany);
}
}
else
{
if (!lineSegmentsToRemove.Contains(lineSegment))
{
lineSegmentsToRemove.Add(lineSegment);
}
if (!stationsToRemove.Contains(fromStation))
{
stationsToRemove.Add(fromStation);
}
if (!stationsToRemove.Contains(toStation))
{
stationsToRemove.Add(toStation);
}
}
});
Console.WriteLine("2");
// Transmission Lines
foreach (LineSegment lineSegment in lineSegmentsToRemove)
{
TransmissionLine transmissionLine = m_transmissionLines.Find(x => x.Id == lineSegment.TransmissionLineId);
if (!transmissionLinesToRemove.Contains(transmissionLine))
{
transmissionLinesToRemove.Add(transmissionLine);
}
}
Console.WriteLine("3");
// Nodes
foreach (Station station in stationsToRemove)
{
List <Node> stationNodes = m_nodes.FindAll(x => x.StationName == station.Name);
foreach (Node node in stationNodes)
{
if (!nodesToRemove.Contains(node))
{
nodesToRemove.Add(node);
}
}
}
Console.WriteLine("4");
// Divisions
foreach (Station station in retainedStations)
{
List <Node> stationNodes = m_nodes.FindAll(x => x.StationName == station.Name);
foreach (Node node in stationNodes)
{
Division division = m_divisions.Find(x => x.Name == node.DivisionName);
if (!retainedDivisions.Contains(division))
{
retainedDivisions.Add(division);
}
}
}
Console.WriteLine("5");
// Circuit breakers
foreach (CircuitBreaker breaker in m_circuitBreakers)
{
Station parentStation = m_stations.Find(x => x.Name == breaker.StationName);
if (stationsToRemove.Contains(parentStation))
{
if (!circuitBreakersToRemove.Contains(breaker))
{
circuitBreakersToRemove.Add(breaker);
}
}
}
Console.WriteLine("6");
// shunts
foreach (Shunt shunt in m_shunts)
{
Station parentStation = m_stations.Find(x => x.Name == shunt.StationName);
if (stationsToRemove.Contains(parentStation))
{
if (!shuntsToRemove.Contains(shunt))
{
shuntsToRemove.Add(shunt);
}
}
}
Console.WriteLine("7");
// Transformers and Transformer Taps
foreach (Transformer transformer in m_transformers)
{
Station parentStation = m_stations.Find(x => x.Name == transformer.StationName);
if (stationsToRemove.Contains(parentStation))
{
if (!transformersToRemove.Contains(transformer))
{
transformersToRemove.Add(transformer);
}
}
else
{
TransformerTap fromTap = m_transformerTaps.Find(x => x.Id == transformer.FromNodeTap);
TransformerTap toTap = m_transformerTaps.Find(x => x.Id == transformer.ToNodeTap);
if (!retainedTaps.Contains(fromTap))
{
retainedTaps.Add(fromTap);
}
if (!retainedTaps.Contains(toTap))
{
retainedTaps.Add(toTap);
}
}
}
Console.WriteLine("8");
// Parent Transformer
foreach (Transformer transformer in transformersToRemove)
{
ParentTransformer parentTransformer = m_parentTransformers.Find(x => x.Id == transformer.Parent);
if (!parentTransformersToRemove.Contains(parentTransformer))
{
parentTransformersToRemove.Add(parentTransformer);
}
}
m_companies = retainedCompanies;
m_divisions = retainedDivisions;
m_transformerTaps = retainedTaps;
Console.WriteLine("9");
foreach (Station station in stationsToRemove)
{
m_stations.Remove(station);
}
foreach (LineSegment lineSegment in lineSegmentsToRemove)
{
m_lineSegments.Remove(lineSegment);
}
foreach (Node node in nodesToRemove)
{
m_nodes.Remove(node);
}
foreach (Shunt shunt in shuntsToRemove)
{
m_shunts.Remove(shunt);
}
foreach (CircuitBreaker breaker in circuitBreakersToRemove)
{
m_circuitBreakers.Remove(breaker);
}
foreach (Transformer transformer in transformersToRemove)
{
m_transformers.Remove(transformer);
}
foreach (ParentTransformer transformer in parentTransformersToRemove)
{
m_parentTransformers.Remove(transformer);
}
foreach (TransmissionLine transmissionLine in transmissionLinesToRemove)
{
m_transmissionLines.Remove(transmissionLine);
}
}
/// <summary>
/// Validates and fixed a configuration and params of the transmission line.
/// </summary>
/// <param name="line">A transmission line for configuration.</param>
/// <returns>A result of configurating. False if failed.</returns>
public static async Task <bool> ConfigurateTransmissionLineAsync(TransmissionLine line)
{
if (line.RoutingInstruction != null) // Routing instruction applied.
{
// Is partial autorized instruction.
if (line.RoutingInstruction is PartialAuthorizedInstruction pai)
{
#region Token validation
// If token not exist, or emoty, or expired.
if (line.LastQuery.Data.TryGetParamValue("token", out UniformQueries.QueryPart token))
{
// If token value is emoty.
if (string.IsNullOrEmpty(token.PropertyValueString))
{
if (await TokenValidation(pai))
{
// Apply received token.
line.LastQuery.Data.SetParam(new UniformQueries.QueryPart("token", pai.GuestToken));
}
else
{
return(false);
}
}
}
else
{
// Validate token
if (await TokenValidation(pai))
{
// Add tokent to query,
line.LastQuery.Data.ListedContent?.Add(new UniformQueries.QueryPart("token", pai.GuestToken));
}
else
{
return(false);
}
}
#region Methods
// Trying to porovide valid guest token.
// Returns result of validation. False - token invalid.
async Task <bool> TokenValidation(PartialAuthorizedInstruction instruction)
{
// If guest token is not found or expired.
if (pai.GuestToken == null ||
UniformQueries.Tokens.IsExpired(instruction.GuestToken, instruction.GuestTokenHandler.ExpiryTime))
{
// Wait for token.
if (!await pai.TryToGetGuestTokenAsync(ClientAppConfigurator.TerminationTokenSource.Token))
{
return(false);
}
}
return(true);
}
#endregion
#endregion
#region Encriprion operators validation
if (line.LastQuery.Data.IsEncrypted && // Is query require encryption? (Query can't be encrypted if that query must request key for encryption.)
line.RoutingInstruction != null && // Is routing instruction is valid and allow encryption?
line.RoutingInstruction.encryption)
{
// Check asymmetric operator.
if (pai.AsymmetricEncryptionOperator == null)
{
Console.WriteLine("Encryption operator not configurated. Operation declined.");
return(false);
}
#region Receiving public key from intruction's target server
// Check if operator is valid.
if (!pai.AsymmetricEncryptionOperator.IsValid)
{
try
{
// Start async key exchanging.
var keysExchangingOperator = RequestPublicEncryptionKeyAsync(pai);
try
{
if (!keysExchangingOperator.IsCompleted)
{
keysExchangingOperator.Start();
}
}
catch { };
// Drop current query as invalid cause encryption operator still in processing.
line.Processing = false;
return(false);
}
catch (Exception ex)
{
// Unlock loop.
line.Processing = false;
Console.WriteLine("SECRET KEY ERROR (bcpph1): " + ex.Message);
return(false);
}
}
#endregion
#region Adding public key for backward encryption if not added yet
if (!line.LastQuery.Data.QueryParamExist("pk"))
{
line.LastQuery.Data.SetParam(new UniformQueries.QueryPart(
"pk",
EnctyptionOperatorsHandler.AsymmetricEO.EncryptionKey));
}
#endregion
// Encrypt query by public key of target server.
return(await EnctyptionOperatorsHandler.TryToEncryptAsync(
line.LastQuery.Data,
line.RoutingInstruction.sEncCode,
line.RoutingInstruction.AsymmetricEncryptionOperator,
ClientAppConfigurator.TerminationTokenSource.Token));
}
#endregion
}
}
return(true);
}
public TransmissionLineOPFResult(TransmissionLine transmissionLine, double power_flow)
{
this.TransmissionLine = transmissionLine;
this.PowerFlow = power_flow;
}
/// <summary>
/// The designated constructor for the <see cref="LinearStateEstimator.Graphs.TransmissionLineGraph"/> class. Requires a reference to a <see cref="LinearStateEstimator.Modeling.TransmissionLine"/> of interest.
/// </summary>
/// <param name="transmissionLine">The <see cref="LinearStateEstimator.Modeling.TransmissionLine"/> desired to represent as a graph.</param>
public TransmissionLineGraph(TransmissionLine transmissionLine)
{
m_transmissionLine = transmissionLine;
BuildVertexSet(transmissionLine);
BuildEdgeSet(transmissionLine);
}
