/// <inheritdoc/>
public async Task <PublishStartResultModel> NodePublishStartAsync(
EndpointModel endpoint, PublishStartRequestModel request)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Item == null)
{
throw new ArgumentNullException(nameof(request.Item));
}
if (string.IsNullOrEmpty(request.Item.NodeId))
{
throw new ArgumentNullException(nameof(request.Item.NodeId));
}
var error = await TestPublishNodeAsync(endpoint, request);
if (error != null)
{
return(new PublishStartResultModel {
ErrorInfo = error
});
}
GetUserNamePassword(endpoint.User, out var user, out var password);
var content = new PublishNodesRequestModel {
EndpointUrl = endpoint.Url,
Password = password,
UserName = user,
UseSecurity = endpoint.SecurityMode != SecurityMode.None,
OpcNodes = new List <PublisherNodeModel> {
new PublisherNodeModel {
Id = ToPublisherNodeId(request.Item.NodeId),
OpcPublishingInterval =
request.Item.PublishingInterval,
OpcSamplingInterval =
request.Item.SamplingInterval
}
}
};
if (_client == null)
{
await StartAsync();
}
var(errorInfo, _) = await _client.CallMethodAsync("PublishNodes",
JsonConvertEx.SerializeObject(content), request.Header?.Diagnostics);
return(new PublishStartResultModel {
ErrorInfo = errorInfo
});
}
/// <inheritdoc/>
public async Task <PublishStartResultModel> NodePublishStartAsync(
string endpointId, PublishStartRequestModel request)
{
if (string.IsNullOrEmpty(endpointId))
{
throw new ArgumentNullException(nameof(endpointId));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Item == null)
{
throw new ArgumentNullException(nameof(request.Item));
}
if (string.IsNullOrEmpty(request.Item.NodeId))
{
throw new ArgumentNullException(nameof(request.Item.NodeId));
}
var(publisherId, endpoint) = await _publishers.FindPublisherEndpoint(
endpointId);
GetUserNamePassword(request.Header?.Elevation, out var user, out var password);
var content = new PublishNodesRequestModel {
EndpointUrl = endpoint.Url,
EndpointId = endpointId,
UseSecurity = endpoint.SecurityMode != SecurityMode.None,
SecurityMode = endpoint.SecurityMode == null ||
endpoint.SecurityMode == SecurityMode.Best ? null :
endpoint.SecurityMode.ToString(),
SecurityProfileUri = endpoint.SecurityPolicy,
Password = password,
UserName = user,
OpcNodes = new List <PublisherNodeModel> {
new PublisherNodeModel {
Id = request.Item.NodeId,
DisplayName = null,
OpcPublishingInterval = (int?)
request.Item.PublishingInterval?.TotalMilliseconds,
OpcSamplingInterval = (int?)
request.Item.SamplingInterval?.TotalMilliseconds
}
}
};
var(errorInfo, _) = await CallMethodOnPublisherAsync(publisherId, "PublishNodes",
JsonConvertEx.SerializeObject(content));
return(new PublishStartResultModel {
ErrorInfo = errorInfo
});
}
/// <inheritdoc/>
public async Task <PublishStopResultModel> NodePublishStopAsync(
EndpointModel endpoint, PublishStopRequestModel request)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (string.IsNullOrEmpty(request.NodeId))
{
throw new ArgumentNullException(nameof(request.NodeId));
}
// Check whether publishing
var publishing = await IsPublishingAsync(endpoint, request.NodeId);
if (!publishing)
{
return(new PublishStopResultModel {
ErrorInfo = new ServiceResultModel {
ErrorMessage = "Node is not published"
}
});
}
var content = new PublishNodesRequestModel {
EndpointUrl = endpoint.Url,
OpcNodes = new List <PublisherNodeModel> {
new PublisherNodeModel {
Id = ToPublisherNodeId(request.NodeId)
}
}
};
System.Diagnostics.Debug.Assert(_client != null);
var(errorInfo, _) = await _client.CallMethodAsync("UnpublishNodes",
JsonConvertEx.SerializeObject(content), request.Diagnostics);
return(new PublishStopResultModel {
ErrorInfo = errorInfo
});
}
/// <summary>
/// Configure publishing of a particular node
/// </summary>
private static async Task PublishNodesAsync(IIoTHubConfig config, ILogger logger,
string deviceId, string moduleId, string endpointUrl, string nodeId,
bool publish, CancellationToken ct)
{
if (string.IsNullOrEmpty(endpointUrl))
{
throw new ArgumentNullException(nameof(endpointUrl));
}
if (string.IsNullOrEmpty(nodeId))
{
throw new ArgumentNullException(nameof(nodeId));
}
var client = new IoTHubTwinMethodClient(CreateClient(config, logger), logger);
while (!ct.IsCancellationRequested)
{
try {
logger.Information("Start publishing {nodeId}...", nodeId);
var content = new PublishNodesRequestModel {
EndpointUrl = endpointUrl,
UseSecurity = true,
OpcNodes = new List <PublisherNodeModel> {
new PublisherNodeModel {
Id = nodeId,
OpcPublishingInterval = 1000,
OpcSamplingInterval = 1000
}
}
};
var result = await client.CallMethodAsync(deviceId, moduleId,
publish? "PublishNodes" : "UnpublishNodes",
JsonConvertEx.SerializeObject(content), null, ct);
logger.Information("... started");
break;
}
catch (Exception ex) {
logger.Verbose(ex, "Failed to configure publishing.");
// Wait a bit
await Task.Delay(TimeSpan.FromSeconds(2), ct);
}
}
}
