/// <inheritdoc/>
public Task ConfigureAsync(DiscoveryMode mode, DiscoveryConfigModel config)
{
_request = new DiscoveryRequest(mode, config);
return(Task.CompletedTask);
}
/// <summary>
/// Run a network discovery
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private async Task <List <ApplicationRegistrationModel> > DiscoverServersAsync(
DiscoveryRequest request)
{
var discoveryUrls = await GetDiscoveryUrlsAsync(request.DiscoveryUrls);
if (request.Mode == DiscoveryMode.Off)
{
return(await DiscoverServersAsync(request, discoveryUrls,
request.Configuration.Locales));
}
_logger.Information("Start {mode} discovery run...", request.Mode);
var watch = Stopwatch.StartNew();
//
// Set up scanner pipeline and start discovery
//
var local = request.Mode == DiscoveryMode.Local;
#if !NO_WATCHDOG
_counter = 0;
#endif
var addresses = new List <IPAddress>();
_progress.OnNetScanStarted(request.Request, 0, 0, request.TotalAddresses);
using (var netscanner = new NetworkScanner(_logger, (scanner, reply) => {
_progress.OnNetScanResult(request.Request, scanner.ActiveProbes,
scanner.ScanCount, request.TotalAddresses, addresses.Count, reply.Address);
addresses.Add(reply.Address);
}, local, local ? null : request.AddressRanges, request.NetworkClass,
request.Configuration.MaxNetworkProbes, request.Configuration.NetworkProbeTimeout,
request.Token)) {
// Log progress
using (var progress = new Timer(_ => ProgressTimer(
() => _progress.OnNetScanProgress(request.Request, netscanner.ActiveProbes,
netscanner.ScanCount, request.TotalAddresses, addresses.Count)),
null, kProgressInterval, kProgressInterval)) {
await netscanner.Completion;
}
_progress.OnNetScanFinished(request.Request, netscanner.ActiveProbes,
netscanner.ScanCount, request.TotalAddresses, addresses.Count);
}
request.Token.ThrowIfCancellationRequested();
await AddLoopbackAddressesAsync(addresses);
if (addresses.Count == 0)
{
return(new List <ApplicationRegistrationModel>());
}
var ports = new List <IPEndPoint>();
var totalPorts = request.TotalPorts * addresses.Count;
var probe = new ServerProbe(_logger);
#if !NO_WATCHDOG
_counter = 0;
#endif
_progress.OnPortScanStart(request.Request, 0, 0, totalPorts);
using (var portscan = new PortScanner(_logger,
addresses.SelectMany(address => {
var ranges = request.PortRanges ?? PortRange.OpcUa;
return(ranges.SelectMany(x => x.GetEndpoints(address)));
}), (scanner, ep) => {
_progress.OnPortScanResult(request.Request, scanner.ActiveProbes,
scanner.ScanCount, totalPorts, ports.Count, ep);
ports.Add(ep);
}, probe, request.Configuration.MaxPortProbes,
request.Configuration.MinPortProbesPercent,
request.Configuration.PortProbeTimeout, request.Token)) {
using (var progress = new Timer(_ => ProgressTimer(
() => _progress.OnPortScanProgress(request.Request, portscan.ActiveProbes,
portscan.ScanCount, totalPorts, ports.Count)),
null, kProgressInterval, kProgressInterval)) {
await portscan.Completion;
}
_progress.OnPortScanFinished(request.Request, portscan.ActiveProbes,
portscan.ScanCount, totalPorts, ports.Count);
}
request.Token.ThrowIfCancellationRequested();
if (ports.Count == 0)
{
return(new List <ApplicationRegistrationModel>());
}
//
// Collect discovery urls
//
foreach (var ep in ports)
{
request.Token.ThrowIfCancellationRequested();
var resolved = await ep.TryResolveAsync();
var url = new Uri($"opc.tcp://" + resolved);
discoveryUrls.Add(ep, url);
}
request.Token.ThrowIfCancellationRequested();
//
// Create application model list from discovered endpoints...
//
var discovered = await DiscoverServersAsync(request, discoveryUrls,
request.Configuration.Locales);
_logger.Information("Discovery took {elapsed} and found {count} servers.",
watch.Elapsed, discovered.Count);
return(discovered);
}
public DiscoveryResponse Discovery(DiscoveryRequest alexaRequest)
{
//IPremiseObject PremiseServer.HomeObject, rootObject;
var response = new DiscoveryResponse();
#region CheckRequest
if ((alexaRequest == null) || (alexaRequest.header == null) || (alexaRequest.header.payloadVersion == null) || (alexaRequest.header.payloadVersion == "1"))
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.UnexpectedInformationReceivedError;
response.payload.exception = new ExceptionResponsePayload
{
faultingParameter = "alexaRequest"
};
return(response);
}
if (alexaRequest.header.name != "DiscoverAppliancesRequest")
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.UnsupportedOperationError;
response.payload.exception = new ExceptionResponsePayload
{
faultingParameter = "alexaRequest.header.name"
};
return(response);
}
#endregion CheckRequest
#region InitialzeResponse
try
{
if (response.header.payloadVersion == "3")
{
response.header.name = alexaRequest.header.name + ".Response";
}
else
{
response.header.name = alexaRequest.header.name.Replace("Request", "Response");
}
response.header.messageId = alexaRequest.header.messageId;
response.header.@namespace = alexaRequest.header.@namespace;
}
catch (Exception)
{
response.header.@namespace = Faults.QueryNamespace;
response.header.name = Faults.UnexpectedInformationReceivedError;
response.payload.exception = new ExceptionResponsePayload
{
faultingParameter = "alexaRequest.header.name"
};
return(response);
}
#endregion InitialzeResponse
if (alexaRequest.header.name != "DiscoverAppliancesRequest")
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.UnsupportedOperationError;
response.payload.exception = new ExceptionResponsePayload
{
faultingParameter = "alexaRequest.header.name"
};
return(response);
}
//SYSClient client = new SYSClient();
#region ConnectToPremise
if (PremiseServer.HomeObject == null)
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.DependentServiceUnavailableError;
response.payload.exception = new ExceptionResponsePayload
{
dependentServiceName = "Premise Server"
};
return(response);
}
#endregion ConnectToPremise
try
{
#region VerifyAccess
if (!CheckAccessToken(alexaRequest.payload.accessToken).GetAwaiter().GetResult())
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.InvalidAccessTokenError;
return(response);
}
#endregion VerifyAccess
#region Perform Discovery
InformLastContact(alexaRequest.header.name).GetAwaiter().GetResult();
response.payload.discoveredAppliances = GetAppliances().GetAwaiter().GetResult();
response.payload.discoveredAppliances.Sort(Appliance.CompareByFriendlyName);
#endregion Perform Discovery
}
catch (Exception ex)
{
response.header.@namespace = Faults.Namespace;
response.header.name = Faults.DriverpublicError;
response.payload.exception = new ExceptionResponsePayload
{
errorInfo = new ErrorInfo
{
description = ex.Message
}
};
}
return(response);
}
public Watch CreateWatch(
bool ads,
DiscoveryRequest request,
ISet <string>?knownResourceNames,
Action <Response> responseCallback)
{
var group = _hash(request.Node);
// even though we're modifying, we take a readLock to allow multiple watches to be created in parallel since it
// doesn't conflict
_rwLock.EnterReadLock();
try
{
var status = _statuses.GetOrAdd(group, g => new CacheStatusInfo <T>(group));
status.SetLastWatchRequestTime(DateTimeOffset.UtcNow.Ticks);
_snapshots.TryGetValue(group, out Snapshot? snapshot);
var version = snapshot == null
? string.Empty
: snapshot.GetVersion(request.TypeUrl, request.ResourceNames);
var watch = new Watch(ads, request, responseCallback);
if (snapshot != null)
{
var requestedResources = ImmutableHashSet.CreateRange(request.ResourceNames);
var newResourceHints = requestedResources.Except(knownResourceNames);
// If the request is asking for resources we haven't sent to the proxy yet, see if we have additional resources.
if (newResourceHints.Any())
{
// If any of the newly requested resources are in the snapshot respond immediately. If not we'll fall back to
// version comparisons.
if (snapshot.GetResources(request.TypeUrl).Keys.Any(newResourceHints.Contains))
{
this.Respond(watch, snapshot, group);
return(watch);
}
}
}
// If the requested version is up-to-date or missing a response, leave an open watch.
if (snapshot == null || request.VersionInfo.Equals(version))
{
long watchId = Interlocked.Increment(ref _watchCount);
Logger.LogDebug("open watch {0} for {1}[{2}] from node {3} for version {4}",
watchId,
request.TypeUrl,
string.Join(", ", request.ResourceNames),
group,
request.VersionInfo);
status.SetWatch(watchId, watch);
watch.SetStop(() => status.RemoveWatch(watchId));
return(watch);
}
// Otherwise, the watch may be responded immediately
var responded = this.Respond(watch, snapshot, group);
if (!responded)
{
long watchId = Interlocked.Increment(ref _watchCount);
Logger.LogDebug("did not respond immediately, leaving open watch {0} for {1}[{2}] from node {3} for version {4}",
watchId,
request.TypeUrl,
string.Join(", ", request.ResourceNames),
group,
request.VersionInfo);
status.SetWatch(watchId, watch);
watch.SetStop(() => status.RemoveWatch(watchId));
}
return(watch);
}
finally
{
_rwLock.ExitReadLock();
}
}
private void OnHandleMessagesThread()
{
while (server.Status != NetPeerStatus.NotRunning)
{
server.MessageReceivedEvent.WaitOne();
NetIncomingMessage msg;
while (server.ReadMessage(out msg))
{
switch (msg.MessageType)
{
case NetIncomingMessageType.StatusChanged: {
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
#if NETWORK_DEBUG
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.Write(" S ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("[" + msg.SenderEndPoint + "] " + status);
#endif
ClientStatusChangedEventArgs args = new ClientStatusChangedEventArgs(msg.SenderConnection, status);
ClientStatusChanged?.Invoke(args);
break;
}
case NetIncomingMessageType.Data: {
#if NETWORK_DEBUG__
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write(" R ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("[" + msg.SenderEndPoint + "] " + msg.LengthBytes + " bytes");
#endif
MessageReceivedEventArgs args = new MessageReceivedEventArgs(msg, false);
MessageReceived?.Invoke(args);
break;
}
case NetIncomingMessageType.UnconnectedData: {
#if NETWORK_DEBUG
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write(" R ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("Unconnected [" + msg.SenderEndPoint + "] " + msg.LengthBytes + " bytes");
#endif
MessageReceivedEventArgs args = new MessageReceivedEventArgs(msg, true);
MessageReceived?.Invoke(args);
break;
}
case NetIncomingMessageType.ConnectionApproval: {
ClientConnectedEventArgs args = new ClientConnectedEventArgs(msg);
ClientConnected?.Invoke(args);
if (args.DenyReason == null)
{
msg.SenderConnection.Approve();
}
else
{
msg.SenderConnection.Deny(args.DenyReason);
}
break;
}
case NetIncomingMessageType.DiscoveryRequest: {
#if NETWORK_DEBUG
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write(" Q ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("[" + msg.SenderEndPoint + "] " + msg.LengthBytes + " bytes");
#endif
DiscoveryRequestEventArgs args = new DiscoveryRequestEventArgs();
DiscoveryRequest?.Invoke(args);
server.SendDiscoveryResponse(args.Message, msg.SenderEndPoint);
break;
}
#if NETWORK_DEBUG
case NetIncomingMessageType.VerboseDebugMessage:
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.Write(" D ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.DebugMessage:
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(" D ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(" W ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(" E ");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine(msg.ReadString());
break;
#endif
}
server.Recycle(msg);
}
}
server = null;
Debug.WriteLine("ServerConnection: OnHandleMessagesThread exited!");
}
public Response(DiscoveryRequest request, IEnumerable <IMessage> resources, string version)
{
this.Request = request;
this.Resources = resources;
this.Version = version;
}
private static IEnumerable <PatientWithRank <Patient> > RanksFor(DiscoveryRequest request, Patient patient)
{
private void SetupMatchingRepositoryForDiscoveryRequest(DiscoveryRequest discoveryRequest)
{
SetupMatchingRepositoryForDiscoveryRequest(discoveryRequest, 1);
}
private static PatientWithRank <Patient> RankPatient(Patient patient, DiscoveryRequest request)
{
return(RanksFor(request, patient).Aggregate((rank, withRank) => rank + withRank));
}
public virtual async Task <ValueTuple <DiscoveryRepresentation, ErrorRepresentation> > PatientFor(
DiscoveryRequest request)
{
if (await AlreadyExists(request.TransactionId))
{
logger.Log(LogLevel.Error, LogEvents.Discovery, "Discovery Request already exists for {request.TransactionId}.");
return(null,
new ErrorRepresentation(new Error(ErrorCode.DuplicateDiscoveryRequest, "Discovery Request already exists")));
}
var(linkedAccounts, exception) = await linkPatientRepository.GetLinkedCareContexts(request.Patient.Id);
if (exception != null)
{
logger.Log(LogLevel.Critical, LogEvents.Discovery, exception, "Failed to get care contexts");
return(null,
new ErrorRepresentation(new Error(ErrorCode.FailedToGetLinkedCareContexts,
"Failed to get Linked Care Contexts")));
}
var linkedCareContexts = linkedAccounts.ToList();
if (HasAny(linkedCareContexts))
{
logger.Log(LogLevel.Information,
LogEvents.Discovery,
"User has already linked care contexts: {TransactionID}",
request.TransactionId);
var patient = await patientRepository.PatientWithAsync(linkedCareContexts.First().PatientReferenceNumber);
return(await patient
.Map(async patient =>
{
await discoveryRequestRepository.Add(new Model.DiscoveryRequest(request.TransactionId,
request.Patient.Id, patient.Identifier));
return (new DiscoveryRepresentation(patient.ToPatientEnquiryRepresentation(
GetUnlinkedCareContexts(linkedCareContexts, patient))),
(ErrorRepresentation)null);
})
.ValueOr(Task.FromResult(GetError(ErrorCode.NoPatientFound, ErrorMessage.NoPatientFound))));
}
IQueryable <Patient> patients;
try {
patients = await matchingRepository.Where(request);
}
catch (OpenMrsConnectionException)
{
return(GetError(ErrorCode.OpenMrsConnection, ErrorMessage.HipConnection));
}
try
{
foreach (var patient in patients)
{
var careContexts = await careContextRepository.GetCareContexts(patient.Uuid);
patient.CareContexts = careContexts;
}
}
catch (OpenMrsFormatException e)
{
logger.Log(LogLevel.Error,
LogEvents.Discovery, $"Could not get care contexts for transaction {request.TransactionId}.", e);
return(GetError(ErrorCode.CareContextConfiguration, ErrorMessage.HipConfiguration));
}
var(patientEnquiryRepresentation, error) =
DiscoveryUseCase.DiscoverPatient(Filter.Do(patients, request).AsQueryable());
if (patientEnquiryRepresentation == null)
{
Log.Information($"No matching unique patient found for transaction {request.TransactionId}.", error);
return(null, error);
}
await discoveryRequestRepository.Add(new Model.DiscoveryRequest(request.TransactionId,
request.Patient.Id, patientEnquiryRepresentation.ReferenceNumber));
return(new DiscoveryRepresentation(patientEnquiryRepresentation), null);
}
public Task <DiscoveryResponse> ExecuteAsync(DiscoveryRequest request, CancellationToken cancellationToken = default(CancellationToken)) => _service.ExecuteAsync(request, cancellationToken);
public DiscoveryResponse Execute(DiscoveryRequest request) => _service.Execute(request);
private static void AndTheResponseShouldContainTheTransactionId(GatewayDiscoveryRepresentation actualResponse,
DiscoveryRequest discoveryRequest)
{
actualResponse.TransactionId.Should().Be(discoveryRequest.TransactionId);
}
