/// <inheritdoc/>
private string GetNormalizedEntityName(MonitoredItemMessageModel sample)
{
if (string.IsNullOrEmpty(sample.PublisherId) ||
string.IsNullOrEmpty(sample.DataSetWriterId) ||
string.IsNullOrEmpty(sample.NodeId))
{
return(null);
}
return(GetNormalizedKey($"{sample.PublisherId}_{sample.DataSetWriterId}" +
$"_{sample.NodeId}"));
}
/// <inheritdoc/>
public async Task HandleSampleAsync(MonitoredItemMessageModel sample)
{
var arguments = new object[] { sample.ToApiModel() };
if (!string.IsNullOrEmpty(sample.EndpointId))
{
// Send to endpoint listeners
await _callback.MulticastAsync(sample.EndpointId,
EventTargets.PublisherSampleTarget, arguments);
}
}
/// <inheritdoc/>
public Task HandleSampleAsync(MonitoredItemMessageModel sample)
{
// Set timestamp as source timestamp
var properties = new Dictionary <string, string>()
{
[CommonProperties.EventSchemaType] =
Core.MessageSchemaTypes.MonitoredItemMessageModelJson
};
return(_client.SendAsync(_serializer.SerializeToBytes(sample).ToArray(),
properties, sample.DataSetWriterId));
}
public async Task TestPublishTelemetryEventAndReceiveAsync(VariantValue v)
{
var bus = _factory.Resolve <ISubscriberMessageProcessor>();
var client = _factory.Resolve <IPublisherServiceEvents>();
var endpointId = "testid";
var result = new TaskCompletionSource <MonitoredItemMessageApiModel>();
await using (await client.NodePublishSubscribeByEndpointAsync(endpointId, ev => {
result.SetResult(ev);
return(Task.CompletedTask);
})) {
var expected = new MonitoredItemMessageModel {
DataSetWriterId = "testid",
EndpointId = endpointId,
DisplayName = "holla",
NodeId = "nodeid",
SourceTimestamp = DateTime.UtcNow,
Timestamp = DateTime.UtcNow,
Value = v
};
await bus.HandleSampleAsync(expected);
await Task.WhenAny(result.Task, Task.Delay(5000));
Assert.True(result.Task.IsCompleted);
var received = result.Task.Result;
Assert.Equal(expected.DisplayName, received.DisplayName);
Assert.Equal(expected.DataSetWriterId, received.DataSetWriterId);
Assert.Equal(expected.NodeId, received.NodeId);
Assert.Equal(expected.SourceTimestamp, received.SourceTimestamp);
Assert.Equal(expected.Timestamp, received.Timestamp);
Assert.NotNull(received?.Value);
Assert.Equal(expected.Value, received.Value);
}
}
public async Task TestPublishPublisherEventAndReceiveMultipleAsync(int total)
{
var bus = _factory.Resolve <ISubscriberMessageProcessor>();
var client = _factory.Resolve <IPublisherServiceEvents>();
var endpointId = "testid";
var expected = new MonitoredItemMessageModel {
DataSetWriterId = "testid",
EndpointId = endpointId,
DisplayName = "holla",
NodeId = "nodeid",
SourceTimestamp = DateTime.UtcNow,
Timestamp = DateTime.UtcNow,
Value = 234234
};
var result = new TaskCompletionSource <bool>();
var counter = 0;
await using (await client.NodePublishSubscribeByEndpointAsync(endpointId, ev => {
counter++;
if (counter == total)
{
result.SetResult(true);
}
return(Task.CompletedTask);
})) {
for (var i = 0; i < total; i++)
{
await bus.HandleSampleAsync(expected);
}
await Task.WhenAny(result.Task, Task.Delay(10000));
Assert.True(result.Task.IsCompleted, $"{counter} received instead of {total}");
}
}
/// <inheritdoc/>
public Task HandleSampleAsync(MonitoredItemMessageModel sample)
{
return(ProcessCdmSampleAsync(sample));
}
/// <inheritdoc/>
private CdmDataPartitionDefinition GetOrCreateEntityDataPartition(CdmManifestDefinition manifest,
string key, MonitoredItemMessageModel sample, out bool persist, bool forceNew = false)
{
persist = false;
if (string.IsNullOrEmpty(key) || sample == null)
{
return(null);
}
// check if the enetity was aleready added
var entityDefinition = manifest.Entities.Item(key);
if (entityDefinition == null)
{
// add a new entity for the sample
// add a new entity for the Message
var newSampleEntity = _cdmCorpus.MakeObject <CdmEntityDefinition>(
CdmObjectType.EntityDef, key, false);
var info = typeof(MonitoredItemMessageModel).GetProperties();
foreach (var property in info)
{
// add the attributes required
var attribute = _cdmCorpus.MakeObject <CdmTypeAttributeDefinition>(
CdmObjectType.TypeAttributeDef, property.Name, false);
attribute.Purpose = _cdmCorpus.MakeRef <CdmPurposeReference>(
CdmObjectType.PurposeRef, "hasA", true);
// if we handle a value, lookup it's type property
if (property.Name == "Value")
{
attribute.DataFormat = VariantValueTypeToCdmDataFormat(sample.Value);
}
else
{
attribute.DataFormat = DataTypeToCdmDataFormat(property.PropertyType);
}
newSampleEntity.Attributes.Add(attribute);
}
newSampleEntity.DisplayName = kPublisherSampleEntityName;
newSampleEntity.Version = "0.0.2";
newSampleEntity.Description = "Opc Ua Monitored Item Sample";
// Create a new document where the new entity's definition will be stored
var newSampleEntityDoc = _cdmCorpus.MakeObject <CdmDocumentDefinition>(
CdmObjectType.DocumentDef, $"{newSampleEntity.EntityName}.cdm.json", false);
newSampleEntityDoc.Imports.Add($"{newSampleEntity.EntityName}.cdm.json");
newSampleEntityDoc.Imports.Add(kFoundationJsonPath);
newSampleEntityDoc.Definitions.Add(newSampleEntity);
_cdmCorpus.Storage.FetchRootFolder("adls").Documents.Add(newSampleEntityDoc);
entityDefinition = manifest.Entities.Add(newSampleEntity);
persist |= true;
}
var partition = entityDefinition.DataPartitions.Count != 0
? entityDefinition.DataPartitions.Last() : null;
if (forceNew || partition == null)
{
// Define a partition and add it to the local declaration
var newPartition = _cdmCorpus.MakeObject <CdmDataPartitionDefinition>(
CdmObjectType.DataPartitionDef, entityDefinition.EntityName);
var timestamp = DateTime.UtcNow.ToString(
"yyMMddHHmmss", DateTimeFormatInfo.InvariantInfo);
newPartition.Location =
$"adls:/{entityDefinition.EntityName}/partition-data-{timestamp}.csv";
newPartition.Explanation = "OPC UA PubSub DataSet Partition";
var partitionTrait = newPartition.ExhibitsTraits.Add(
"is.partition.format.CSV");
partitionTrait.Arguments.Add("columnHeaders", "true");
partitionTrait.Arguments.Add("delimiter", kCsvPartitionsDelimiter);
partition = entityDefinition.DataPartitions.Add(newPartition);
persist |= true;
}
return(partition);
}
