/// <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> /// 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> /// 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); }