/// <inheritdoc/>
public virtual void OnFindEndpointsStarted(DiscoveryRequestModel request,
Uri url, IPAddress address)
{
_logger.Information(
"{request}: Trying to find endpoints on {host}:{port} ({address})...",
request.Id, url.Host, url.Port, address);
}
/// <inheritdoc/>
public virtual void OnPortScanFinished(DiscoveryRequestModel request,
IScanner portscan, int found)
{
_logger.Information("{request}: Found {count} ports on servers " +
"took {elapsed} ({scanned} scanned)...",
request.Id, found, _watch.Elapsed, portscan.ScanCount);
}
/// <inheritdoc/>
public virtual void OnNetScanProgress(DiscoveryRequestModel request,
IScanner netscanner, int found)
{
_logger.Information("{request}: {scanned} addresses scanned - {found} " +
"found ({active} probes active)...", request.Id,
netscanner.ScanCount, found, netscanner.ActiveProbes);
}
/// <inheritdoc/>
public virtual void OnDiscoveryError(DiscoveryRequestModel request,
Exception ex)
{
_logger.Error(ex, "{request}: Error during discovery run...",
request.Id);
_watch.Stop();
}
/// <inheritdoc/>
public virtual void OnNetScanFinished(DiscoveryRequestModel request,
IScanner netscanner, int found)
{
_logger.Information("{request}: Found {count} addresses took {elapsed} " +
"({scanned} scanned)...", request.Id,
found, _watch.Elapsed, netscanner.ScanCount);
}
/// <inheritdoc/>
public async Task DiscoverAsync(DiscoveryRequestModel request, CancellationToken ct)
{
kDiscoverAsync.Inc();
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var task = new DiscoveryRequest(request);
var scheduled = _queue.TryAdd(task);
if (!scheduled)
{
task.Dispose();
_logger.Error("Discovey request not scheduled, internal server error!");
var ex = new ResourceExhaustionException("Failed to schedule task");
_progress.OnDiscoveryError(request, ex);
throw ex;
}
await _lock.WaitAsync();
try {
if (_pending.Count != 0)
{
_progress.OnDiscoveryPending(task.Request, _pending.Count);
}
_pending.Add(task);
}
finally {
_lock.Release();
}
}
/// <inheritdoc/>
public void OnDiscoveryStarted(DiscoveryRequestModel request)
{
Send(new DiscoveryProgressModel {
EventType = DiscoveryProgressType.Started,
Request = request
});
}
/// <inheritdoc/>
public virtual void OnPortScanProgress(DiscoveryRequestModel request,
IScanner portscan, int found)
{
_logger.Information("{request}: {scanned} ports scanned - {found} found" +
" ({active} probes active)...", request.Id,
portscan.ScanCount, found, portscan.ActiveProbes);
}
/// <summary>
/// Create request wrapper
/// </summary>
/// <param name="request"></param>
/// <param name="networkClass"></param>
public DiscoveryRequest(DiscoveryRequestModel request,
NetworkClass networkClass = NetworkClass.Wired)
{
Request = request?.Clone() ?? throw new ArgumentNullException(nameof(request));
NetworkClass = networkClass;
if (!string.IsNullOrEmpty(request.Configuration?.AddressRangesToScan))
{
if (AddressRange.TryParse(request.Configuration?.AddressRangesToScan,
out var addresses))
{
AddressRanges = addresses;
}
}
if (AddressRanges == null)
{
if (request.Discovery == DiscoveryMode.Fast)
{
var interfaces = NetworkInformationEx.GetAllNetInterfaces(NetworkClass.Wired);
AddressRanges = interfaces.Select(t => new AddressRange(t, false, 24));
AddressRanges = AddressRanges.Concat(interfaces
.Where(t => t.Gateway != null &&
!t.Gateway.Equals(System.Net.IPAddress.Any) &&
!t.Gateway.Equals(System.Net.IPAddress.None))
.Select(i => new AddressRange(i.Gateway, 32)));
}
}
if (!string.IsNullOrEmpty(request.Configuration?.PortRangesToScan))
{
if (PortRange.TryParse(request.Configuration?.PortRangesToScan,
out var ports))
{
PortRanges = ports;
}
}
if (PortRanges == null)
{
switch (request.Discovery)
{
case DiscoveryMode.Local:
PortRanges = PortRange.All;
break;
case DiscoveryMode.Fast:
PortRanges = PortRange.WellKnown;
break;
case DiscoveryMode.Scan:
PortRanges = PortRange.Unassigned;
break;
default:
PortRanges = PortRange.OpcUa;
break;
}
}
}
/// <inheritdoc/>
public virtual void OnNetScanStarted(DiscoveryRequestModel request,
IScanner netscanner)
{
_watch.Restart();
_logger.Information(
"{request}: Starting network scan ({active} probes active)...",
request.Id, netscanner.ActiveProbes);
}
/// <inheritdoc/>
public async Task DiscoverAsync(DiscoveryRequestModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
await _events.PublishAsync(request);
}
/// <inheritdoc/>
public void OnDiscoveryFinished(DiscoveryRequestModel request)
{
Send(new DiscoveryProgressModel {
TimeStamp = DateTime.UtcNow,
EventType = DiscoveryProgressType.Finished,
Request = request
});
}
/// <inheritdoc/>
public virtual void OnServerDiscoveryStarted(DiscoveryRequestModel request,
IDictionary <IPEndPoint, Uri> discoveryUrls)
{
_watch.Restart();
_logger.Information(
"{request}: Searching {count} discovery urls for endpoints...",
request.Id, discoveryUrls.Count);
}
/// <inheritdoc/>
public void OnDiscoveryPending(DiscoveryRequestModel request,
int pending)
{
Send(new DiscoveryProgressModel {
EventType = DiscoveryProgressType.Pending,
Request = request,
Total = pending
});
}
/// <inhertitdoc/>
public async Task DiscoverAsync(string discovererId,
DiscoveryRequestModel request, CancellationToken ct)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
await CallServiceOnDiscovererAsync(discovererId, "Discover_V2", request, ct);
}
/// <inheritdoc/>
public override void OnDiscoveryStarted(DiscoveryRequestModel request)
{
Send(new DiscoveryMessageModel {
SupervisorId = _supervisorId,
Event = DiscoveryMessageType.Started,
Request = request
});
base.OnDiscoveryStarted(request);
}
/// <summary>
/// Kick off discovery
/// </summary>
/// <param name="supervisorId"></param>
/// <param name="request"></param>
/// <returns></returns>
public async Task DiscoverAsync(string supervisorId,
DiscoveryRequestModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
await CallServiceOnSupervisor(supervisorId, "Discover_V2", request);
}
/// <inheritdoc/>
public async Task DiscoverAsync(DiscoveryRequestModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
await CallServiceOnAllSupervisors("Discover_V2",
request, kDiscoveryTimeout);
}
/// <inheritdoc/>
public override void OnDiscoveryFinished(DiscoveryRequestModel request)
{
Send(new DiscoveryMessageModel {
TimeStamp = DateTime.UtcNow,
SupervisorId = _supervisorId,
Event = DiscoveryMessageType.Finished,
Request = request
});
base.OnDiscoveryFinished(request);
}
/// <summary>
/// Create from service model
/// </summary>
/// <param name="model"></param>
public DiscoveryRequestApiModel(DiscoveryRequestModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
Id = model.Id;
Discovery = model.Discovery;
Configuration = model.Configuration == null ? null :
new DiscoveryConfigApiModel(model.Configuration);
}
/// <inheritdoc/>
public void OnServerDiscoveryStarted(DiscoveryRequestModel request,
int workers, int progress, int total)
{
Send(new DiscoveryProgressModel {
EventType = DiscoveryProgressType.ServerDiscoveryStarted,
Workers = workers,
Progress = progress,
Total = total,
Request = request
});
}
/// <inheritdoc/>
public override void OnDiscoveryError(DiscoveryRequestModel request,
Exception ex)
{
Send(new DiscoveryMessageModel {
TimeStamp = DateTime.UtcNow,
SupervisorId = _supervisorId,
Event = DiscoveryMessageType.Error,
Request = request,
Result = JToken.FromObject(ex)
});
base.OnDiscoveryError(request, ex);
}
/// <summary>
/// Clone
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static DiscoveryRequestModel Clone(this DiscoveryRequestModel model)
{
if (model == null)
{
return(null);
}
return(new DiscoveryRequestModel {
Configuration = model.Configuration.Clone(),
Discovery = model.Discovery,
Id = model.Id
});
}
/// <inheritdoc/>
public override void OnServerDiscoveryFinished(DiscoveryRequestModel request,
int found)
{
Send(new DiscoveryMessageModel {
TimeStamp = DateTime.UtcNow,
SupervisorId = _supervisorId,
Event = DiscoveryMessageType.ServerDiscoveryFinished,
Discovered = found,
Request = request
});
base.OnServerDiscoveryFinished(request, found);
}
/// <inheritdoc/>
public void OnNetScanStarted(DiscoveryRequestModel request,
int workers, int progress, int total)
{
Send(new DiscoveryProgressModel {
TimeStamp = DateTime.UtcNow,
EventType = DiscoveryProgressType.NetworkScanStarted,
Workers = workers,
Progress = progress,
Total = total,
Request = request
});
}
/// <inheritdoc/>
public override void OnServerDiscoveryStarted(DiscoveryRequestModel request,
IDictionary <IPEndPoint, Uri> discoveryUrls)
{
Send(new DiscoveryMessageModel {
TimeStamp = DateTime.UtcNow,
SupervisorId = _supervisorId,
Event = DiscoveryMessageType.ServerDiscoveryStarted,
Discovered = discoveryUrls.Count,
Request = request
});
base.OnServerDiscoveryStarted(request, discoveryUrls);
}
/// <inheritdoc/>
public override void OnPortScanStart(DiscoveryRequestModel request, IScanner scanner)
{
Send(new DiscoveryMessageModel {
TimeStamp = DateTime.UtcNow,
SupervisorId = _supervisorId,
Event = DiscoveryMessageType.PortScanStarted,
Workers = scanner.ActiveProbes,
Progress = scanner.ScanCount,
Request = request
});
base.OnPortScanStart(request, scanner);
}
/// <inheritdoc/>
public void OnPortScanFinished(DiscoveryRequestModel request,
int workers, int progress, int total, int discovered)
{
Send(new DiscoveryProgressModel {
EventType = DiscoveryProgressType.PortScanFinished,
Workers = workers,
Progress = progress,
Total = total,
Discovered = discovered,
Request = request
});
}
private async Task <(string openIdConfigurationUrl, string clientId)> ProcessDiscovery()
{
var emptyResult = ("", "");
if (!string.IsNullOrEmpty(Result.ErrorMessage))
{
return(emptyResult);
}
if (string.IsNullOrEmpty(_correlationId))
{
return(emptyResult);
}
var discoveryRequest = new DiscoveryRequestModel
{
PhoneNumber = Settings.PhoneNumber,
RedirectUrl = Settings.RedirectUrl,
DiscoveryUrl = Settings.DiscoveryUrl,
DiscoveryClientId = Settings.DiscoveryClientId,
DiscoveryPassword = Settings.DiscoveryPassword,
CorrelationId = _correlationId
};
var discoveryResponse = await Client.SendDiscoveryRequest(discoveryRequest);
if (discoveryResponse == null)
{
Result.ErrorMessage = "Discovery Response is null";
return(emptyResult);
}
Result.DiscoveryResponse = discoveryResponse;
if (!discoveryResponse.IsSucceeded)
{
Result.ErrorMessage = "Discovery Response StatusCode is not success";
return(emptyResult);
}
if (!TryGetOpenIdConfigurationUrl(discoveryResponse, out var openIdConfigurationUrl))
{
return(emptyResult);
}
if (!TryGetClientId(discoveryResponse, out var clientId))
{
return(emptyResult);
}
return(openIdConfigurationUrl, clientId);
}
/// <inheritdoc/>
public void OnDiscoveryError(DiscoveryRequestModel request,
Exception ex)
{
Send(new DiscoveryProgressModel {
TimeStamp = DateTime.UtcNow,
EventType = DiscoveryProgressType.Error,
Request = request,
Result = ex.Message,
ResultDetails = new Dictionary <string, string> {
["exception"] = ex.ToString()
},
});
}