/// <summary>
/// Overload that does not continue on exception and can only be cancelled.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="elevation"></param>
/// <param name="priority"></param>
/// <param name="ct"></param>
/// <param name="endpoint"></param>
/// <param name="service"></param>
/// <returns></returns>
public static Task <T> ExecuteServiceAsync <T>(this IEndpointServices client,
EndpointModel endpoint, CredentialModel elevation, int priority,
CancellationToken ct, Func <Session, Task <T> > service)
{
return(client.ExecuteServiceAsync(endpoint, elevation, priority, ct, service,
_ => true));
}
/// <summary>
/// Create node stream encoder
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="diagnostics"></param>
/// <param name="encoder"></param>
/// <param name="elevation"></param>
/// <param name="logger"></param>
/// <param name="priority"></param>
public BrowseStreamEncoder(IEndpointServices client, EndpointModel endpoint,
IEncoder encoder, DiagnosticsModel diagnostics, ILogger logger, CredentialModel elevation = null,
int priority = int.MaxValue) :
this(client, endpoint, diagnostics, logger, elevation, priority)
{
_encoder = new ModelEncoder(encoder, PushNode);
}
/// <summary>
/// Overload which can only be cancelled.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="connection"></param>
/// <param name="ct"></param>
/// <param name="service"></param>
/// <param name="handler"></param>
/// <returns></returns>
public static Task <T> ExecuteServiceAsync <T>(this IEndpointServices client,
ConnectionModel connection, CancellationToken ct, Func <Session, Task <T> > service,
Func <Exception, bool> handler)
{
return(client.ExecuteServiceAsync(connection, null, 0, service,
null, ct, handler));
}
/// <summary>
/// Overload that runs in the foreground, does not continue on exception
/// but allows specifying timeout.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="elevation"></param>
/// <param name="timeout"></param>
/// <param name="endpoint"></param>
/// <param name="service"></param>
/// <returns></returns>
public static Task <T> ExecuteServiceAsync <T>(this IEndpointServices client,
EndpointModel endpoint, CredentialModel elevation, TimeSpan timeout,
Func <Session, Task <T> > service)
{
return(client.ExecuteServiceAsync(endpoint, elevation, 0, service,
timeout, CancellationToken.None, _ => true));
}
/// <summary>
/// Create twin services
/// </summary>
/// <param name="client"></param>
/// <param name="events"></param>
/// <param name="logger"></param>
public TwinServices(IEndpointServices client, IEventEmitter events, ILogger logger)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_events = events ?? throw new ArgumentNullException(nameof(events));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_endpoint = new TaskCompletionSource <EndpointModel>();
_lock = new SemaphoreSlim(1, 1);
}
/// <summary>
/// Create twin services
/// </summary>
/// <param name="client"></param>
/// <param name="services"></param>
/// <param name="events"></param>
/// <param name="logger"></param>
public TwinServices(IClientHost client, IEndpointServices services,
IEventEmitter events, ILogger logger)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_services = services ?? throw new ArgumentNullException(nameof(services));
_events = events ?? throw new ArgumentNullException(nameof(events));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
/// <summary>
/// Internal helper
/// </summary>
/// <param name="client"></param>
/// <param name="server"></param>
/// <param name="opc"></param>
/// <param name="logger"></param>
private PublisherServices(IPublisherClient client, IPublisherServer server,
IEndpointServices opc, ILogger logger)
{
_opc = opc ?? throw new ArgumentNullException(nameof(opc));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_server = server;
_client = client;
}
/// <summary>
/// Overload which can only be cancelled.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="elevation"></param>
/// <param name="priority"></param>
/// <param name="ct"></param>
/// <param name="endpoint"></param>
/// <param name="service"></param>
/// <param name="handler"></param>
/// <returns></returns>
public static Task <T> ExecuteServiceAsync <T>(this IEndpointServices client,
EndpointModel endpoint, CredentialModel elevation, int priority,
CancellationToken ct, Func <Session, Task <T> > service,
Func <Exception, bool> handler)
{
return(client.ExecuteServiceAsync(endpoint, elevation, priority, service,
null, ct, handler));
}
/// <summary>
/// Create upload services
/// </summary>
/// <param name="client"></param>
/// <param name="upload"></param>
/// <param name="scheduler"></param>
/// <param name="logger"></param>
public DataUploadServices(IEndpointServices client, IBlobUpload upload,
ITaskScheduler scheduler, ILogger logger)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_upload = upload ?? throw new ArgumentNullException(nameof(upload));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
_tasks = new ConcurrentDictionary <EndpointIdentifier, ModelUploadTask>();
}
/// <summary>
/// Create history encoder
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="encoder"></param>
/// <param name="nodeId"></param>
/// <param name="logger"></param>
/// <param name="elevation"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="maxValues"></param>
/// <param name="priority"></param>
public HistoryStreamEncoder(IEndpointServices client, EndpointModel endpoint,
IEncoder encoder, string nodeId, ILogger logger, CredentialModel elevation = null,
DateTime?startTime = null, DateTime?endTime = null, int?maxValues = null,
int priority = int.MaxValue) :
this(client, endpoint, nodeId, logger, elevation, startTime, endTime,
maxValues, priority)
{
_encoder = new ModelEncoder(encoder);
}
/// <summary>
/// Execute the service on the provided session.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="elevation"></param>
/// <param name="priority"></param>
/// <param name="service"></param>
/// <param name="timeout"></param>
/// <param name="ct"></param>
/// <param name="exceptionHandler"></param>
/// <returns></returns>
public static Task <T> ExecuteServiceAsync <T>(this IEndpointServices client,
EndpointModel endpoint, CredentialModel elevation, int priority, Func <Session,
Task <T> > service, TimeSpan?timeout, CancellationToken ct,
Func <Exception, bool> exceptionHandler)
{
return(client.ExecuteServiceAsync(new ConnectionModel {
Endpoint = endpoint
},
elevation, priority, service, timeout, ct, exceptionHandler));
}
/// <summary>
/// Create node stream encoder
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="diagnostics"></param>
/// <param name="logger"></param>
/// <param name="elevation"></param>
/// <param name="priority"></param>
private BrowseStreamEncoder(IEndpointServices client, EndpointModel endpoint,
DiagnosticsModel diagnostics, ILogger logger, CredentialModel elevation, int priority)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_endpoint = endpoint ?? throw new ArgumentNullException(nameof(endpoint));
_elevation = elevation;
_diagnostics = diagnostics;
_priority = priority;
_browseStack.Push(ObjectIds.RootFolder);
_browseStack.Push(ObjectIds.TypesFolder);
}
/// <summary>
/// Create client service to control publisher
/// </summary>
/// <param name="client"></param>
/// <param name="publisherUri"></param>
/// <param name="logger"></param>
public PublisherServerClient(IEndpointServices client, Uri publisherUri,
ILogger logger)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
if (publisherUri == null)
{
throw new ArgumentNullException(nameof(publisherUri));
}
_endpoint = new EndpointModel {
Url = publisherUri.ToString()
};
}
/// <summary>
/// Create archiver
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="elevation"></param>
/// <param name="archive"></param>
/// <param name="contentType"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="maxValues"></param>
/// <param name="logger"></param>
public AddressSpaceArchiver(IEndpointServices client, EndpointModel endpoint,
CredentialModel elevation, IArchive archive, string contentType,
DateTime?startTime, DateTime?endTime, int?maxValues, ILogger logger)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_endpoint = endpoint ?? throw new ArgumentNullException(nameof(endpoint));
_archive = archive ?? throw new ArgumentNullException(nameof(endpoint));
_contentType = contentType ?? ContentMimeType.UaJson;
_startTime = startTime ?? DateTime.UtcNow.AddDays(-1);
_endTime = endTime ?? DateTime.UtcNow;
_maxValues = maxValues ?? short.MaxValue;
_elevation = elevation;
}
/// <summary>
/// Create services connecting to publisher server
/// </summary>
/// <param name="server"></param>
/// <param name="opc"></param>
/// <param name="logger"></param>
public PublisherServices(IPublisherServer server, IEndpointServices opc,
ILogger logger) : this(null, server, opc, logger)
{
if (server == null)
{
throw new ArgumentNullException(nameof(server));
}
//
// Give it 10 seconds in which we are expecting StartAsync to be
// called. If it is not called within 10 seconds start is called
// from timer thread. This allows startup to await publisher
// finding without module processing begins and publish calls
// initially fail.
//
_pnp = new Timer(OnReconnectTimer, null, 10000, Timeout.Infinite);
}
/// <summary>
/// Read value
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="elevation"></param>
/// <param name="readNode"></param>
/// <returns></returns>
public static Task <JToken> ReadValueAsync(this IEndpointServices client,
EndpointModel endpoint, CredentialModel elevation, string readNode)
{
var codec = new JsonVariantEncoder();
return(client.ExecuteServiceAsync(endpoint, elevation, session => {
var nodesToRead = new ReadValueIdCollection {
new ReadValueId {
NodeId = readNode.ToNodeId(session.MessageContext),
AttributeId = Attributes.Value
}
};
var responseHeader = session.Read(null, 0, TimestampsToReturn.Both,
nodesToRead, out var values, out var diagnosticInfos);
var result = codec.Encode(values[0].WrappedValue,
out var tmp, session.MessageContext);
return Task.FromResult(result);
}));
/// <summary>
/// Create history encoder
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="nodeId"></param>
/// <param name="logger"></param>
/// <param name="elevation"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="maxValues"></param>
/// <param name="priority"></param>
private HistoryStreamEncoder(IEndpointServices client, EndpointModel endpoint,
string nodeId, ILogger logger, CredentialModel elevation, DateTime?startTime,
DateTime?endTime, int?maxValues, int priority)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_endpoint = endpoint ?? throw new ArgumentNullException(nameof(endpoint));
if (string.IsNullOrEmpty(nodeId))
{
throw new ArgumentNullException(nameof(nodeId));
}
_nodeId = nodeId;
_elevation = elevation;
_startTime = startTime ?? DateTime.UtcNow.AddDays(-1);
_endTime = endTime ?? DateTime.UtcNow;
_maxValues = maxValues ?? short.MaxValue * 2;
_priority = priority;
}
/// <summary>
/// Create twin services
/// </summary>
/// <param name="client"></param>
/// <param name="events"></param>
public TwinServices(IEndpointServices client, IEventEmitter events)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_events = events ?? throw new ArgumentNullException(nameof(events));
}
/// <summary>
/// Create archiver
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="archive"></param>
/// <param name="logger"></param>
public AddressSpaceArchiver(IEndpointServices client, EndpointModel endpoint,
IArchive archive, ILogger logger) :
this(client, endpoint, null, archive, null, null, null, null, logger)
{
}
/// <summary>
/// Create client service to control publisher
/// </summary>
/// <param name="client"></param>
/// <param name="logger"></param>
public PublisherServerClient(IEndpointServices client, ILogger logger) :
this(client, new Uri($"opc.tcp://{Utils.GetHostName()}:62222/UA/Publisher"),
logger)
{
}
/// <summary>
/// Read value
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="readNode"></param>
/// <returns></returns>
public static Task <JToken> ReadValueAsync(this IEndpointServices client,
EndpointModel endpoint, string readNode) =>
ReadValueAsync(client, endpoint, null, readNode);
/// <summary>
/// Overload that does not continue on exception and can only be cancelled.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="connection"></param>
/// <param name="ct"></param>
/// <param name="service"></param>
/// <returns></returns>
public static Task <T> ExecuteServiceAsync <T>(this IEndpointServices client,
ConnectionModel connection, CancellationToken ct, Func <Session, Task <T> > service)
{
return(client.ExecuteServiceAsync(connection, ct, service, _ => true));
}
/// <summary>
/// Overload that runs in the foreground, does not continue on exception
/// times out after 30 seconds.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="elevation"></param>
/// <param name="endpoint"></param>
/// <param name="service"></param>
/// <returns></returns>
public static Task <T> ExecuteServiceAsync <T>(this IEndpointServices client,
EndpointModel endpoint, CredentialModel elevation, Func <Session, Task <T> > service)
{
return(client.ExecuteServiceAsync(endpoint, elevation, TimeSpan.FromSeconds(30),
service));
}
/// <summary>
/// Create server
/// </summary>
/// <param name="modules"></param>
/// <param name="identity"></param>
/// <param name="methods"></param>
/// <param name="discovery"></param>
/// <param name="client"></param>
/// <param name="logger"></param>
public PublisherDiscovery(IModuleDiscovery modules, IIdentity identity,
IJsonMethodClient methods, IEndpointDiscovery discovery, IEndpointServices client,
ILogger logger)
{
_identity = identity ?? throw new ArgumentNullException(nameof(identity));
_methods = methods ?? throw new ArgumentNullException(nameof(methods));
_client = client ?? throw new ArgumentNullException(nameof(client));
_modules = modules ?? throw new ArgumentNullException(nameof(modules));
_discovery = discovery ?? throw new ArgumentNullException(nameof(discovery));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
/// <summary>
/// Read value
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="readNode"></param>
/// <returns></returns>
public static Task <VariantValue> ReadValueAsync(this IEndpointServices client,
EndpointModel endpoint, string readNode)
{
return(ReadValueAsync(client, endpoint, null, readNode));
}
