/// <summary>
/// Check whether valid node and return service result if not.
/// </summary>
/// <param name="endpoint"></param>
/// <param name="request"></param>
/// <returns></returns>
private Task <ServiceResultModel> TestPublishNodeAsync(EndpointModel endpoint,
PublishStartRequestModel request)
{
// Test whether value exists and fail if not
return(_opc.ExecuteServiceAsync(endpoint, null,
TimeSpan.FromSeconds(10), async session => {
var readNode = request.Item.NodeId.ToNodeId(session.MessageContext);
if (NodeId.IsNull(readNode))
{
throw new ArgumentException(nameof(request.Item.NodeId));
}
var diagnostics = new List <OperationResultModel>();
var response = await session.ReadAsync(
(request.Header?.Diagnostics).ToStackModel(),
0, TimestampsToReturn.Both, new ReadValueIdCollection {
new ReadValueId {
NodeId = readNode,
AttributeId = Attributes.Value
}
});
OperationResultEx.Validate("Publish_" + readNode, diagnostics,
response.Results.Select(r => r.StatusCode),
response.DiagnosticInfos, false);
SessionClientEx.Validate(response.Results, response.DiagnosticInfos);
if (response.Results == null || response.Results.Count == 0)
{
return diagnostics.ToServiceModel(request.Header?.Diagnostics,
session.MessageContext);
}
return null;
}));
}
/// <inheritdoc/>
public async Task <PublishStartResultModel> NodePublishStartAsync(
string endpointId,
PublishStartRequestModel request,
CancellationToken ct = default
)
{
kNodePublishStart.Inc();
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 endpoint = await _endpoints.GetEndpointAsync(endpointId, ct : ct);
if (endpoint == null)
{
throw new ArgumentException("Invalid endpointId");
}
var jobId = GetDefaultId(endpointId);
var result = await _jobs.NewOrUpdateJobAsync(jobId, job => {
var publishJob = AsJob(job);
// TODO change to application uri?
job.Name = endpoint.ApplicationId;
publishJob.WriterGroup.WriterGroupId = GetDefaultId(endpoint.Registration.EndpointUrl);
// Add subscription
var connection = new ConnectionModel {
Endpoint = endpoint.Registration.Endpoint,
Diagnostics = request.Header?.Diagnostics,
User = request.Header?.Elevation
};
AddOrUpdateItemInJob(publishJob, request.Item, endpointId, job.Id, connection);
job.JobConfiguration = _serializer.SerializeJobConfiguration(
publishJob, out var jobType);
job.JobConfigurationType = jobType;
if (publishJob.WriterGroup.DataSetWriters.Count != 0 &&
job.LifetimeData.Status != JobStatus.Deleted)
{
job.LifetimeData.Status = JobStatus.Active;
}
job.Demands = PublisherDemands(endpoint);
return(Task.FromResult(true));
}, ct);
return(new PublishStartResultModel());
}
/// <inheritdoc/>
public async Task <PublishStartResultModel> NodePublishStartAsync(
string endpoint, PublishStartRequestModel request)
{
var result = await _client.NodePublishStartAsync(endpoint,
Map <PublishStartRequestApiModel>(request));
return(Map <PublishStartResultModel>(result));
}
/// <inheritdoc/>
public async Task <PublishStartResultModel> NodePublishStartAsync(
string endpoint, PublishStartRequestModel request)
{
var result = await _client.NodePublishStartAsync(endpoint,
request.ToApiModel());
return(result.ToServiceModel());
}
/// <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
});
}
/// <summary>
/// Create api model from service model
/// </summary>
/// <param name="model"></param>
public PublishStartRequestApiModel(PublishStartRequestModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
Item = model.Item == null ? null :
new PublishedItemApiModel(model.Item);
Header = model.Header == null ? null :
new RequestHeaderApiModel(model.Header);
}
/// <inheritdoc/>
public async Task <PublishStartResultModel> NodePublishStartAsync(
string endpoint,
PublishStartRequestModel request,
CancellationToken ct = default
)
{
var result = await _client.NodePublishStartAsync(endpoint,
request.ToApiModel(), ct);
return(result.ToServiceModel());
}
/// <inheritdoc/>
public async Task <PublishStartResultModel> NodePublishStartAsync(string endpointId,
PublishStartRequestModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = await CallServiceOnTwin <PublishStartRequestModel, PublishStartResultModel>(
"PublishStart_V2", endpointId, request);
return(result);
}
/// <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 <PublishStartResultModel> NodePublishStartAsync(
EndpointRegistrationModel registration, PublishStartRequestModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.Item == null)
{
throw new ArgumentNullException(nameof(request.Item));
}
var result = await CallServiceOnSupervisor <PublishStartRequestModel, PublishStartResultModel>(
"PublishStart_V2", registration, request);
return(result);
}
/// <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 endpoint = await _endpoints.GetEndpointAsync(endpointId);
var result = await _jobs.NewOrUpdateJobAsync(GetDefaultId(endpointId), job => {
var publishJob = AsJob(job);
// Add subscription
AddOrUpdateItemInJob(publishJob, request.Item, endpointId,
new ConnectionModel {
Endpoint = endpoint.Registration.Endpoint,
Diagnostics = request.Header?.Diagnostics,
User = request.Header?.Elevation
});
job.JobConfiguration = _serializer.SerializeJobConfiguration(
publishJob, out var jobType);
job.JobConfigurationType = jobType;
if (publishJob.WriterGroup.DataSetWriters.Count != 0 &&
job.LifetimeData.Status != JobStatus.Deleted)
{
job.LifetimeData.Status = JobStatus.Active;
}
job.Demands = PublisherDemands(endpoint);
return(Task.FromResult(true));
});
return(new PublishStartResultModel());
}
/// <inheritdoc/>
public Task <PublishStartResultModel> NodePublishStartAsync(string endpointId,
PublishStartRequestModel request)
{
return(_publish.NodePublishStartAsync(Endpoint, request));
}
/// <inheritdoc/>
public Task <PublishStartResultModel> NodePublishStartAsync(
T endpoint, PublishStartRequestModel request)
{
throw new NotSupportedException("Publishing not supported");
}
