/// <summary>
/// Send progress
/// </summary>
/// <param name="progress"></param>
protected override void Send(DiscoveryProgressModel progress)
{
progress.DiscovererId = DiscovererModelEx.CreateDiscovererId(
_events.DeviceId, _events.ModuleId);
base.Send(progress);
_processor.TrySchedule(() => SendAsync(progress));
}
public async Task TestPublishDiscoveryProgressAndReceiveMultipleAsync(int total)
{
var bus = _factory.Resolve <IEventBus>();
var client = _factory.Resolve <IRegistryServiceEvents>();
var discovererId = "TestDiscoverer1";
var expected = new DiscoveryProgressModel {
DiscovererId = discovererId,
Discovered = 55,
EventType = IIoT.OpcUa.Registry.Models.DiscoveryProgressType.NetworkScanFinished,
TimeStamp = DateTime.UtcNow
};
var result = new TaskCompletionSource <bool>();
var counter = 0;
await using (await client.SubscribeDiscoveryProgressByDiscovererIdAsync(
discovererId, ev => {
counter++;
if (counter == total)
{
result.SetResult(true);
}
return(Task.CompletedTask);
})) {
for (var i = 0; i < total; i++)
{
await bus.PublishAsync(expected);
}
await Task.WhenAny(result.Task, Task.Delay(1000));
Assert.True(result.Task.IsCompleted);
}
}
/// <inheritdoc/>
public Task OnDiscoveryProgressAsync(DiscoveryProgressModel message)
{
if (message.TimeStamp + TimeSpan.FromSeconds(10) < DateTime.UtcNow)
{
// Do not forward stale events - todo make configurable / add metric
return(Task.CompletedTask);
}
return(_bus.PublishAsync(message));
}
/// <inheritdoc/>
public async Task OnDiscoveryProgressAsync(DiscoveryProgressModel message)
{
var requestId = message.Request.Id;
var arguments = new object[] { message.ToApiModel() };
if (!string.IsNullOrEmpty(requestId))
{
// Send to user
await _callback.MulticastAsync(requestId,
EventTargets.DiscoveryProgressTarget, arguments);
}
if (!string.IsNullOrEmpty(message.DiscovererId))
{
// Send to discovery listeners
await _callback.MulticastAsync(message.DiscovererId,
EventTargets.DiscoveryProgressTarget, arguments);
}
}
/// <summary>
/// Convert to api model
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static DiscoveryProgressApiModel ToApiModel(
this DiscoveryProgressModel model)
{
return(new DiscoveryProgressApiModel {
Discovered = model.Discovered,
EventType = (DiscoveryProgressType)model.EventType,
Progress = model.Progress,
Total = model.Total,
RequestDetails = model.RequestDetails?
.ToDictionary(k => k.Key, v => v.Value),
RequestId = model.Request?.Id,
Result = model.Result,
ResultDetails = model.ResultDetails?
.ToDictionary(k => k.Key, v => v.Value),
DiscovererId = model.DiscovererId,
TimeStamp = model.TimeStamp,
Workers = model.Workers
});
}
public async Task TestPublishDiscoveryProgressWithRequestIdAndReceiveAsync()
{
var bus = _factory.Resolve <IEventBus>();
var client = _factory.Resolve <IRegistryServiceEvents>();
var requestId = "TestDiscoverer1";
var expected = new DiscoveryProgressModel {
Request = new DiscoveryRequestModel {
Id = requestId,
Configuration = new DiscoveryConfigModel {
AddressRangesToScan = "ttttttt"
}
},
DiscovererId = "testetests",
Discovered = 55,
ResultDetails = new Dictionary <string, string> {
["test"] = "test"
},
EventType = IIoT.OpcUa.Registry.Models.DiscoveryProgressType.NetworkScanFinished,
TimeStamp = DateTime.UtcNow
};
var result = new TaskCompletionSource <DiscoveryProgressApiModel>();
await using (await client.SubscribeDiscoveryProgressByRequestIdAsync(
requestId, ev => {
result.SetResult(ev);
return(Task.CompletedTask);
})) {
await bus.PublishAsync(expected);
await Task.WhenAny(result.Task, Task.Delay(1000));
Assert.True(result.Task.IsCompleted);
var received = result.Task.Result;
Assert.NotNull(received);
Assert.Equal(expected.DiscovererId, received.DiscovererId);
Assert.Equal(expected.TimeStamp, received.TimeStamp);
Assert.Equal(expected.Discovered, received.Discovered);
Assert.Equal(expected.EventType,
(IIoT.OpcUa.Registry.Models.DiscoveryProgressType)received.EventType);
Assert.Equal(expected.ResultDetails, received.ResultDetails);
}
}
/// <inheritdoc/>
public async Task HandleAsync(DiscoveryProgressModel eventData)
{
if (eventData.TimeStamp + TimeSpan.FromSeconds(10) < DateTime.UtcNow)
{
// Do not forward stale events - todo make configurable / add metric
return;
}
var requestId = eventData.Request?.Id;
var arguments = new object[] { eventData.ToApiModel() };
if (!string.IsNullOrEmpty(requestId))
{
// Send to user
await _callback.MulticastAsync(requestId,
EventTargets.DiscoveryProgressTarget, arguments);
}
if (!string.IsNullOrEmpty(eventData.DiscovererId))
{
// Send to discovery listeners
await _callback.MulticastAsync(eventData.DiscovererId,
EventTargets.DiscoveryProgressTarget, arguments);
}
}
/// <summary>
/// Send progress
/// </summary>
/// <param name="progress"></param>
/// <returns></returns>
private Task SendAsync(DiscoveryProgressModel progress)
{
return(Try.Async(() => _events.SendEventAsync(
_serializer.SerializeToBytes(progress).ToArray(), ContentMimeType.Json,
Registry.Models.MessageSchemaTypes.DiscoveryMessage, "utf-8")));
}
/// <summary>
/// Send progress
/// </summary>
/// <param name="progress"></param>
protected virtual void Send(DiscoveryProgressModel progress)
{
progress.TimeStamp = DateTime.UtcNow;
_logger.LogProgress(progress);
}
public async Task <ActionResult> DiscoveryProgress(DiscoveryProgressModel model)
{
await ZWaveLogStream(new { Timestamp = model.Timestamp.ToLocalTime(), Message = $"DiscoveryProgress: {model.Status}" });
return(Ok());
}
/// <summary>
/// Send progress
/// </summary>
/// <param name="progress"></param>
/// <returns></returns>
private Task SendAsync(DiscoveryProgressModel progress)
{
return(Try.Async(() => _events.SendJsonEventAsync(
progress, MessageSchemaTypes.DiscoveryMessage)));
}
