/// <inheritdoc/>
public async Task <PublishStopResultModel> NodePublishStopAsync(
string endpoint, PublishStopRequestModel request)
{
var result = await _client.NodePublishStopAsync(endpoint,
Map <PublishStopRequestApiModel>(request));
return(Map <PublishStopResultModel>(result));
}
/// <inheritdoc/>
public async Task <PublishStopResultModel> NodePublishStopAsync(
string endpoint, PublishStopRequestModel request)
{
var result = await _client.NodePublishStopAsync(endpoint,
request.ToApiModel());
return(result.ToServiceModel());
}
/// <inheritdoc/>
public async Task <PublishStopResultModel> NodePublishStopAsync(
string endpoint,
PublishStopRequestModel request,
CancellationToken ct = default
)
{
var result = await _client.NodePublishStopAsync(endpoint,
request.ToApiModel(), ct);
return(result.ToServiceModel());
}
/// <inheritdoc/>
public async Task <PublishStopResultModel> NodePublishStopAsync(string endpointId,
PublishStopRequestModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = await CallServiceOnTwin <PublishStopRequestModel, PublishStopResultModel>(
"PublishStop_V2", endpointId, request);
return(result);
}
/// <summary>
/// Create api model from service model
/// </summary>
/// <param name="model"></param>
public PublishStopRequestApiModel(PublishStopRequestModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
NodeId = model.NodeId;
BrowsePath = model.BrowsePath;
NodeAttribute = model.NodeAttribute;
Diagnostics = model.Diagnostics == null ? null :
new DiagnosticsApiModel(model.Diagnostics);
}
/// <inheritdoc/>
public async Task <PublishStopResultModel> NodePublishStopAsync(
EndpointRegistrationModel registration, PublishStopRequestModel request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = await CallServiceOnSupervisor <PublishStopRequestModel, PublishStopResultModel>(
"PublishStop_V2", registration, request);
return(result);
}
/// <inheritdoc/>
public async Task <PublishStopResultModel> NodePublishStopAsync(
string endpointId, PublishStopRequestModel request)
{
kNodePublishStop.Inc();
if (string.IsNullOrEmpty(endpointId))
{
throw new ArgumentNullException(nameof(endpointId));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (string.IsNullOrEmpty(request.NodeId))
{
throw new ArgumentNullException(nameof(request.NodeId));
}
var endpoint = await _endpoints.GetEndpointAsync(endpointId);
if (endpoint == null)
{
throw new ArgumentException("Invalid endpointId");
}
var result = await _jobs.NewOrUpdateJobAsync(GetDefaultId(endpointId), job => {
// remove from job
var publishJob = AsJob(job);
var jobChanged = RemoveItemFromJob(publishJob, request.NodeId,
new ConnectionModel {
Endpoint = endpoint.Registration.Endpoint,
Diagnostics = request.Header?.Diagnostics,
User = request.Header?.Elevation
});
if (jobChanged)
{
job.JobConfiguration = _serializer.SerializeJobConfiguration(
publishJob, out var jobType);
job.JobConfigurationType = jobType;
if (publishJob.WriterGroup.DataSetWriters.Count == 0 &&
job.LifetimeData.Status == JobStatus.Active)
{
job.LifetimeData.Status = JobStatus.Canceled;
}
job.Demands = PublisherDemands(endpoint);
}
return(Task.FromResult(jobChanged));
});
return(new PublishStopResultModel());
}
/// <inheritdoc/>
public async Task <PublishStopResultModel> NodePublishStopAsync(
string endpointId, PublishStopRequestModel request)
{
if (string.IsNullOrEmpty(endpointId))
{
throw new ArgumentNullException(nameof(endpointId));
}
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(endpointId, request.NodeId);
if (!publishing)
{
return(new PublishStopResultModel {
ErrorInfo = new ServiceResultModel {
ErrorMessage = "Node is not published"
}
});
}
var(publisherId, endpoint) = await _publishers.FindPublisherEndpoint(endpointId);
var content = new UnpublishNodesRequestModel {
EndpointUrl = endpoint.Url,
EndpointId = endpointId,
OpcNodes = new List <PublisherNodeModel> {
new PublisherNodeModel {
Id = request.NodeId
}
}
};
var(errorInfo, _) = await CallMethodOnPublisherAsync(publisherId,
"UnpublishNodes", JsonConvertEx.SerializeObject(content));
return(new PublishStopResultModel {
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
});
}
/// <inheritdoc/>
public Task <PublishStopResultModel> NodePublishStopAsync(string endpointId,
PublishStopRequestModel request)
{
return(_publish.NodePublishStopAsync(Endpoint, request));
}
/// <inheritdoc/>
public async Task <PublishStopResultModel> NodePublishStopAsync(
string endpointId,
PublishStopRequestModel request,
CancellationToken ct = default
)
{
kNodePublishStop.Inc();
if (string.IsNullOrEmpty(endpointId))
{
throw new ArgumentNullException(nameof(endpointId));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (string.IsNullOrEmpty(request.NodeId))
{
throw new ArgumentNullException(nameof(request.NodeId));
}
var endpoint = await _endpoints.GetEndpointAsync(endpointId, ct : ct);
if (endpoint == null)
{
throw new ArgumentException("Invalid endpointId");
}
var jobChanged = false;
var jobId = GetDefaultId(endpointId);
await _jobs.NewOrUpdateJobAsync(jobId, job => {
// remove from job
var publishJob = AsJob(job);
var connection = new ConnectionModel {
Endpoint = endpoint.Registration.Endpoint,
Diagnostics = request.Header?.Diagnostics,
User = request.Header?.Elevation
};
jobChanged = RemoveItemFromJob(publishJob, request.NodeId, connection);
if (jobChanged)
{
job.JobConfiguration = _serializer.SerializeJobConfiguration(
publishJob, out var jobType);
job.JobConfigurationType = jobType;
if (publishJob.WriterGroup.DataSetWriters.Count == 0 &&
job.LifetimeData.Status == JobStatus.Active)
{
job.LifetimeData.Status = JobStatus.Canceled;
}
job.Demands = PublisherDemands(endpoint);
}
// Return whether the provided job has been changed or not.
return(Task.FromResult(jobChanged));
}, ct);
if (!jobChanged)
{
throw new ResourceNotFoundException($"Job does not contain node id: {request.NodeId}");
}
return(new PublishStopResultModel());
}
/// <inheritdoc/>
public Task <PublishStopResultModel> NodePublishStopAsync(
T endpoint, PublishStopRequestModel request)
{
return(Task.FromResult(new PublishStopResultModel()));
}
