/// <summary>
/// Log an incoming OPC UA request.
/// </summary>
/// <param name="incomingRequest">The OPC UA request.</param>
public void LogIncomingRequest(IEndpointIncomingRequest incomingRequest)
{
if (incomingRequest != null)
{
LogEntry entry = LogEntry.For((dynamic)incomingRequest.Request);
Log(entry, incomingRequest.SecureChannelContext);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncPublishOperation"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="request">The request.</param>
/// <param name="server">The server.</param>
public AsyncPublishOperation(
OperationContext context,
IEndpointIncomingRequest request,
StandardServer server)
{
m_context = context;
m_request = request;
m_server = server;
m_response = new PublishResponse();
m_request.Calldata = this;
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncPublishOperation"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="request">The request.</param>
/// <param name="server">The server.</param>
public AsyncPublishOperation(
OperationContext context,
IEndpointIncomingRequest request,
StandardServer server)
{
m_context = context;
m_request = request;
m_server = server;
m_response = new PublishResponse();
m_request.Calldata = this;
}
/// <summary>
/// Schedules an incoming request.
/// </summary>
/// <param name="request">The request.</param>
public void ScheduleIncomingRequest(IEndpointIncomingRequest request)
{
if (m_stopped)
{
request.OperationCompleted(null, StatusCodes.BadTooManyOperations);
}
else
{
Task.Run(() => {
m_server.ProcessRequest(request);
});
}
}
/// <summary>
/// Completes an asynchronous publish operation.
/// </summary>
/// <param name="request">The request.</param>
public virtual void CompletePublish(IEndpointIncomingRequest request)
{
AsyncPublishOperation operation = (AsyncPublishOperation)request.Calldata;
OperationContext context = operation.Context;
try
{
if (ServerInternal.SubscriptionManager.CompletePublish(context, operation))
{
operation.Response.ResponseHeader = CreateResponse(request.Request.RequestHeader, context.StringTable);
request.OperationCompleted(operation.Response, null);
OnRequestComplete(context);
}
}
catch (ServiceResultException e)
{
OnRequestComplete(context);
lock (ServerInternal.DiagnosticsLock)
{
ServerInternal.ServerDiagnostics.RejectedRequestsCount++;
if (IsSecurityError(e.StatusCode))
{
ServerInternal.ServerDiagnostics.SecurityRejectedRequestsCount++;
}
}
throw TranslateException(context, e);
}
}
/// <summary>
/// Begins an asynchronous publish operation.
/// </summary>
/// <param name="request">The request.</param>
public virtual void BeginPublish(IEndpointIncomingRequest request)
{
PublishRequest input = (PublishRequest)request.Request;
OperationContext context = ValidateRequest(input.RequestHeader, RequestType.Publish);
try
{
AsyncPublishOperation operation = new AsyncPublishOperation(context, request, this);
uint subscriptionId = 0;
UInt32Collection availableSequenceNumbers = null;
bool moreNotifications = false;
NotificationMessage notificationMessage = null;
StatusCodeCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
notificationMessage = ServerInternal.SubscriptionManager.Publish(
context,
input.SubscriptionAcknowledgements,
operation,
out subscriptionId,
out availableSequenceNumbers,
out moreNotifications,
out results,
out diagnosticInfos);
// request completed asychrnously.
if (notificationMessage != null)
{
OnRequestComplete(context);
operation.Response.ResponseHeader = CreateResponse(input.RequestHeader, context.StringTable);
operation.Response.SubscriptionId = subscriptionId;
operation.Response.AvailableSequenceNumbers = availableSequenceNumbers;
operation.Response.MoreNotifications = moreNotifications;
operation.Response.Results = results;
operation.Response.DiagnosticInfos = diagnosticInfos;
operation.Response.NotificationMessage = notificationMessage;
Utils.Trace("PUBLISH: #{0} Completed Synchronously", input.RequestHeader.RequestHandle);
request.OperationCompleted(operation.Response, null);
}
}
catch (ServiceResultException e)
{
OnRequestComplete(context);
lock (ServerInternal.DiagnosticsLock)
{
ServerInternal.ServerDiagnostics.RejectedRequestsCount++;
if (IsSecurityError(e.StatusCode))
{
ServerInternal.ServerDiagnostics.SecurityRejectedRequestsCount++;
}
}
throw TranslateException(context, e);
}
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="calldata">The calldata passed with the request.</param>
protected override void ProcessRequest(IEndpointIncomingRequest request, object calldata)
{
if (request.Request.TypeId != DataTypeIds.PublishRequest)
{
request.CallSynchronously();
return;
}
// set the context.
SecureChannelContext.Current = request.SecureChannelContext;
try
{
// begin a new publish.
if (request.Calldata == null)
{
BeginPublish(request);
}
// continue a previously queued publish.
else
{
CompletePublish(request);
}
}
catch (Exception e)
{
request.OperationCompleted(null, new ServiceResult(e));
}
}
/// <summary>
/// Schedules an incoming request.
/// </summary>
/// <param name="request">The request.</param>
public virtual void ScheduleIncomingRequest(IEndpointIncomingRequest request)
{
m_requestQueue.ScheduleIncomingRequest(request);
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="request">The request.</param>
protected virtual void ProcessRequest(IEndpointIncomingRequest request)
{
request.CallSynchronously();
}
/// <summary>
/// Schedules an incoming request.
/// </summary>
/// <param name="request">The request.</param>
public void ScheduleIncomingRequest(IEndpointIncomingRequest request)
{
bool tooManyOperations = false;
// queue the request.
lock (m_lock) // i.e. Monitor.Enter(m_lock)
{
// check able to schedule requests.
if (m_stopped || m_queue.Count >= m_maxRequestCount)
{
tooManyOperations = true;
}
else
{
m_queue.Enqueue(request);
// wake up an idle thread to handle the request if there is one
if (m_activeThreadCount < m_totalThreadCount)
{
Monitor.Pulse(m_lock);
}
// start a new thread to handle the request if none are idle and the pool is not full.
else if (m_totalThreadCount < m_maxThreadCount)
{
Thread thread = new Thread(OnProcessRequestQueue);
thread.IsBackground = true;
thread.Start(null);
m_totalThreadCount++;
m_activeThreadCount++; // new threads start in an active state
Utils.Trace("Thread created: " + Thread.CurrentThread.ManagedThreadId + ". Current thread count: " + m_totalThreadCount + ". Active thread count" + m_activeThreadCount);
}
}
}
if (tooManyOperations)
{
request.OperationCompleted(null, StatusCodes.BadTooManyOperations);
}
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="calldata">The calldata passed with the request.</param>
protected virtual void ProcessRequest(IEndpointIncomingRequest request, object calldata)
{
request.CallSynchronously();
}
/// <summary>
/// Schedules an incoming request.
/// </summary>
/// <param name="request">The request.</param>
public virtual void ScheduleIncomingRequest(IEndpointIncomingRequest request)
{
m_requestQueue.ScheduleIncomingRequest(request);
}
/// <summary>
/// Schedules an incoming request.
/// </summary>
/// <param name="request">The request.</param>
public void ScheduleIncomingRequest(IEndpointIncomingRequest request)
{
if (m_stopped)
{
request.OperationCompleted(null, StatusCodes.BadTooManyOperations);
}
else
{
Task.Run(() =>
{
m_server.ProcessRequest(request);
});
}
}
/// <summary>
/// Intercepts incoming requests so they can be logged.
/// </summary>
/// <param name="request">The request</param>
public override void ScheduleIncomingRequest(IEndpointIncomingRequest request)
{
m_Logger.LogIncomingRequest(request);
base.ScheduleIncomingRequest(request);
}
