/// <summary> /// Dispatches the messages received from the client to the actor service methods or the actor methods. /// This can be used by user where they know interfaceId and MethodId for the method to dispatch to . /// </summary> /// <param name="requestContext">Request context that allows getting the callback channel if required.</param> /// <param name="requestMessage">Remoting message.</param> /// <returns></returns> public override Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync( IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { Requires.ThrowIfNull(requestMessage, "requestMessage"); Requires.ThrowIfNull(requestMessage.GetHeader(), "RequestMessageHeader"); var messageHeaders = requestMessage.GetHeader(); var actorHeaders = requestMessage.GetHeader() as IActorRemotingMessageHeaders; if (actorHeaders != null) { if (messageHeaders.InterfaceId == Runtime.ActorEventSubscription.InterfaceId) { return(this.HandleSubscriptionRequestsAsync( requestContext, messageHeaders, requestMessage.GetBody())); } return(this.HandleActorMethodDispatchAsync(actorHeaders, requestMessage.GetBody())); } return(base.HandleRequestResponseAsync(requestContext, requestMessage)); }
public override async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync( IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { IServiceRemotingRequestMessageHeader headers = requestMessage.GetHeader(); if (headers.TryGetHeaderValue(ActivityServiceRemoting.OperationIdHeaderName, out byte[] operationIdBytes))
public override Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync( IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { ExtractAndSetAllCorrelationHeaderValues(requestMessage.GetHeader()); return(base.HandleRequestResponseAsync(requestContext, requestMessage)); }
private async Task <byte[]> RequestResponseServiceMessageAsync( IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody, CustomServiceRequestHeader customHeader) { var methodName = GetServiceMethodName(messageHeaders.InterfaceId, messageHeaders.MethodId); byte[] result = null; using (new ServiceRequestContextWrapper(customHeader)) { using (_logger?.RecieveServiceMessage(_service.GetServiceContext().ServiceName, methodName, messageHeaders, customHeader)) { try { result = await _innerMessageHandler.RequestResponseAsync(requestContext, messageHeaders, requestBody); } catch (Exception ex) { _logger?.RecieveServiceMessageFailed(_service.GetServiceContext().ServiceName, methodName, messageHeaders, customHeader, ex); throw; } } } return(result); }
/// <inheritdoc /> public override async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync( IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { Activity?activity = null; IServiceRemotingResponseMessage?responseMessage = null; try { activity = requestMessage.StartActivityFromIncomingRequest(m_diagnosticListener, RequestActivityName); responseMessage = await base.HandleRequestResponseAsync(requestContext, requestMessage).ConfigureAwait(false); activity?.SetResult(ActivityResult.Success); } catch (Exception ex) { m_diagnosticListener.ReportException(ex); throw; } finally { m_diagnosticListener.StopActivityIfExist(activity); } return(responseMessage); }
/// <summary> /// Handles a message from the client that requires a response from the service. /// </summary> /// <param name="requestContext">Request context - contains additional information about the request</param> /// <param name="requestMessage">Request message</param> public virtual async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync( IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { if (this.IsCancellationRequest(requestMessage.GetHeader())) { await this.cancellationHelper.CancelRequestAsync(requestMessage.GetHeader().InterfaceId, requestMessage.GetHeader().MethodId, requestMessage.GetHeader().InvocationId); return(null); } else { var messageHeaders = requestMessage.GetHeader(); var retval = await this.cancellationHelper.DispatchRequest <IServiceRemotingResponseMessage>( messageHeaders.InterfaceId, messageHeaders.MethodId, messageHeaders.InvocationId, cancellationToken => this.OnDispatch(messageHeaders, requestMessage.GetBody(), cancellationToken)); return(retval); } }
public override async Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBodyBytes) { var actorMessageHeaders = messageHeaders.GetActorMessageHeaders(CommunicationLogger); var methodName = GetActorMethodName(actorMessageHeaders); var customHeader = messageHeaders.GetCustomServiceRequestHeader(CommunicationLogger) ?? new CustomServiceRequestHeader(); CommunicationLogger?.StartActorMessageRecieved(methodName, customHeader); byte[] result = null; try { result = await this.RunInRequestContext( async() => await base.RequestResponseAsync( requestContext, messageHeaders, requestBodyBytes), customHeader); CommunicationLogger?.ActorMessageDispatched(methodName, customHeader); } catch (Exception ex) { CommunicationLogger?.ActorMessageFailed(methodName, customHeader, ex); throw; } finally { CommunicationLogger?.StopActorMessageRecieved(methodName, customHeader); } return(result); }
public Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { // Information from Headers can be extracted here from request. ThreadCultureInfo.AddCultureInfoToCallContext(requestMessage); var response = this.innerHandler.HandleRequestResponseAsync(requestContext, requestMessage); return(response); }
/// <summary> /// Handles a one way message from the client. It consumes the correlation id and context from the message headers, if any. /// </summary> /// <param name="requestContext">Request context - contains additional information about the request.</param> /// <param name="messageHeaders">Request message headers.</param> /// <param name="requestBody">Request message body.</param> public void HandleOneWay(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { HandleAndTrackRequestAsync(messageHeaders, () => { _innerHandler.HandleOneWay(requestContext, messageHeaders, requestBody); return(Task.FromResult <byte[]>(null)); }).Forget(); }
public async override Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync( IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { IServiceRemotingResponseMessage responseMessage = await base.HandleRequestResponseAsync(requestContext, TrackingHelper.ProcessRequest(requestMessage)).ConfigureAwait(false); return(TrackingHelper.ProcessResponse(responseMessage)); }
public async override Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync( IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { MessagePipeline.Execute(requestMessage); IServiceRemotingResponseMessage responseMessage = await base.HandleRequestResponseAsync(requestContext, requestMessage); MessagePipeline.Execute(responseMessage); return(responseMessage); }
public override Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { messageHeaders.TryGetHeaderValue(HeaderIdentifiers.TraceId, out byte[] col); if (col != null && col.Any()) { CallContext.LogicalSetData(HeaderIdentifiers.TraceId, Encoding.ASCII.GetString(col)); } return(base.RequestResponseAsync(requestContext, messageHeaders, requestBody)); }
public override void HandleOneWay(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { messageHeaders.TryGetHeaderValue(HeaderIdentifiers.TraceId, out byte[] col); if (col != null && col.Any()) { CallContext.LogicalSetData(HeaderIdentifiers.TraceId, Encoding.ASCII.GetString(col)); } base.HandleOneWay(requestContext, messageHeaders, requestBody); }
public Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync( IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { var state = new ServiceHostRemotingListenerLoggerMessageState(requestMessage); using (this.logger.BeginScope(state)) { return(this.handler.HandleRequestResponseAsync(requestContext, requestMessage)); } }
public override Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { var contextDto = messageHeaders.GetContextDto(); CustomServiceContext.SetContext(contextDto); return(ServiceRequestContext.RunInRequestContext(async() => await base.RequestResponseAsync( requestContext, messageHeaders, requestBody), contextDto)); }
public Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync(IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { // Custom events can be hooked here. // Information from Headers can be extracted here. var messageHeaders = requestMessage.GetHeader(); var interfaceId = messageHeaders.InterfaceId; var methodId = messageHeaders.MethodId; CustomRemotingEvents.RaiseReceiveRequest(string.Empty); var response = this.innerHandler.HandleRequestResponseAsync(requestContext, requestMessage); CustomRemotingEvents.RaiseSendResponse(string.Empty); return(response); }
public async Task <byte[]> RequestResponseAsync( IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { try { CorrelationDetails.UpdateCurrentActivityId(messageHeaders); return(await _serviceRemotingMessageHandler.RequestResponseAsync(requestContext, messageHeaders, requestBody)); } catch (Exception e) { Console.WriteLine(e); throw; } }
public Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { var customHeader = messageHeaders.GetCustomServiceRequestHeader(_logger) ?? new CustomServiceRequestHeader(); var actorMessageHeaders = messageHeaders.GetActorMessageHeaders(_logger); if (actorMessageHeaders == null) { return(RequestResponseServiceMessageAsync(requestContext, messageHeaders, requestBody, customHeader)); } else { return(RequestResponseActorMessageAsync(requestContext, messageHeaders, requestBody, actorMessageHeaders, customHeader)); } }
public override async Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { byte[] headerValueBytes; string headerValueString; bool gotCustomHeader = messageHeaders.TryGetHeaderValue("TestHeader", out headerValueBytes); if (gotCustomHeader) { headerValueString = Encoding.UTF8.GetString(headerValueBytes); Thread.CurrentPrincipal = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { new Claim("TestHeader", headerValueString) })); } return(await base.RequestResponseAsync(requestContext, messageHeaders, requestBody)); }
/// <summary> /// Handles a message from the client that requires a response from the service. /// </summary> /// <param name="requestContext">Request context - contains additional information about the request</param> /// <param name="messageHeaders">Request message headers</param> /// <param name="requestBody">Request message body</param> /// <returns>Response body</returns> public virtual async Task <byte[]> RequestResponseAsync( IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { if (this.IsCancellationRequest(messageHeaders)) { await this.cancellationHelper.CancelRequestAsync(messageHeaders.InterfaceId, messageHeaders.MethodId, messageHeaders.InvocationId); return(null); } else { if (null != this.servicePerformanceCounterProvider.serviceOutstandingRequestsCounterWriter) { this.servicePerformanceCounterProvider.serviceOutstandingRequestsCounterWriter.UpdateCounterValue(1); } var requestStopWatch = Stopwatch.StartNew(); byte[] retval = null; try { retval = await this.cancellationHelper.DispatchRequest <byte[]>( messageHeaders.InterfaceId, messageHeaders.MethodId, messageHeaders.InvocationId, cancellationToken => this.OnDispatch(messageHeaders, requestBody, cancellationToken)); } finally { if (null != this.servicePerformanceCounterProvider.serviceOutstandingRequestsCounterWriter) { this.servicePerformanceCounterProvider.serviceOutstandingRequestsCounterWriter .UpdateCounterValue(-1); } if (null != this.servicePerformanceCounterProvider.serviceRequestProcessingTimeCounterWriter) { this.servicePerformanceCounterProvider.serviceRequestProcessingTimeCounterWriter .UpdateCounterValue( requestStopWatch.ElapsedMilliseconds); } } return(retval); } }
/// <summary> /// Dispatches the messages received from the client to the actor service methods or the actor methods. /// </summary> /// <param name="requestContext">Request context that allows getting the callback channel if required.</param> /// <param name="messageHeaders">Service remoting message headers</param> /// <param name="requestBodyBytes">serialized request body of the remoting message.</param> /// <returns> /// A <see cref="System.Threading.Tasks.Task">Task</see> that represents outstanding operation. /// The result of the Task is the serialized response body. /// </returns> public override Task <byte[]> RequestResponseAsync( IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBodyBytes) { if (messageHeaders.InterfaceId == ActorMessageDispatch.InterfaceId) { return(this.HandleActorMethodDispatchAsync(messageHeaders, requestBodyBytes)); } if (messageHeaders.InterfaceId == ActorEventSubscription.InterfaceId) { return(this.HandleSubscriptionRequestsAsync(requestContext, messageHeaders, requestBodyBytes)); } return(base.RequestResponseAsync(requestContext, messageHeaders, requestBodyBytes)); }
public override async Task <byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBodyBytes) { try { LogServiceMethodStart(...); result = await base.RequestResponseAsync(requestContext, messageHeaders, requestBodyBytes).ConfigureAwait(false); LogServiceMethodStop(...); return(result); } catch (Exception exception) { LogServiceMethodException(...); throw; } }
/// <summary> /// Handles a message from the client that requires a response from the service. /// </summary> /// <param name="requestContext">Request context - contains additional information about the request</param> /// <param name="messageHeaders">Request message headers</param> /// <param name="requestBody">Request message body</param> /// <returns>Response body</returns> public virtual Task <byte[]> RequestResponseAsync( IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { if (this.cancellationHelper.IsCancellationRequest(messageHeaders)) { return(this.cancellationHelper.CancelRequestAsync(messageHeaders.InterfaceId, messageHeaders.MethodId, messageHeaders.InvocationId)); } else { return(this.cancellationHelper.DispatchRequest( messageHeaders.InterfaceId, messageHeaders.MethodId, messageHeaders.InvocationId, cancellationToken => this.OnDispatch(messageHeaders, requestBody, cancellationToken))); } }
public async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync( IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { Dictionary <string, string> context = ExtractContextProperties(requestMessage); if (context == null) { return(await _innerHandler.HandleRequestResponseAsync(requestContext, requestMessage)); } else { using (L.Context(context)) { return(await _innerHandler.HandleRequestResponseAsync(requestContext, requestMessage)); } } }
private async Task <byte[]> HandleSubscriptionRequestsAsync( IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestMsgBodyBytes) { ActorMessageHeaders actorMessageHeaders; if (!ActorMessageHeaders.TryFromServiceMessageHeaders(messageHeaders, out actorMessageHeaders)) { //This can only happen if there is issue in our product code like Message Corruption or changing headers format. ReleaseAssert.Failfast("ActorMessageHeaders Deserialization failed"); } if (actorMessageHeaders.MethodId == ActorEventSubscription.SubscribeMethodId) { var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes); var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value; await this.actorService.ActorManager.SubscribeAsync( actorMessageHeaders.ActorId, castedRequestMsgBody.eventInterfaceId, new ActorEventSubscriberProxy( castedRequestMsgBody.subscriptionId, requestContext.GetCallbackClient())); return(null); } if (actorMessageHeaders.MethodId == ActorEventSubscription.UnSubscribeMethodId) { var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes); var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value; await this.actorService.ActorManager.UnsubscribeAsync( actorMessageHeaders.ActorId, castedRequestMsgBody.eventInterfaceId, castedRequestMsgBody.subscriptionId); return(null); } throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture, Actors.SR.ErrorInvalidMethodId, actorMessageHeaders.MethodId)); }
private async Task <byte[]> HandleSubscriptionRequests( IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestMsgBodyBytes) { ActorMessageHeaders actorMessageHeaders; if (!ActorMessageHeaders.TryFromServiceMessageHeaders(messageHeaders, out actorMessageHeaders)) { throw new SerializationException(Actors.SR.ErrorActorMessageHeadersDeserializationFailed); } if (actorMessageHeaders.MethodId == ActorEventSubscription.SubscribeMethodId) { var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes); var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value; await this.actorService.ActorManager.SubscribeAsync( actorMessageHeaders.ActorId, castedRequestMsgBody.eventInterfaceId, new ActorEventSubscriberProxy( castedRequestMsgBody.subscriptionId, requestContext.GetCallbackClient())); return(null); } if (actorMessageHeaders.MethodId == ActorEventSubscription.UnSubscribeMethodId) { var requestMsgBody = (ActorMessageBody)SerializationUtility.Deserialize(ActorEventSubscription.Serializer, requestMsgBodyBytes); var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.Value; await this.actorService.ActorManager.UnsubscribeAsync( actorMessageHeaders.ActorId, castedRequestMsgBody.eventInterfaceId, castedRequestMsgBody.subscriptionId); return(null); } throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture, Actors.SR.ErrorInvalidMethodId, actorMessageHeaders.MethodId)); }
private async Task <IServiceRemotingResponseMessage> HandleSubscriptionRequestsAsync( IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessageHeader messageHeaders, IServiceRemotingRequestMessageBody requestMsgBody) { var actorHeaders = (IActorRemotingMessageHeaders)messageHeaders; if (actorHeaders.MethodId == Runtime.ActorEventSubscription.SubscribeMethodId) { var castedRequestMsgBody = (EventSubscriptionRequestBody)requestMsgBody.GetParameter(0, "Value", typeof(EventSubscriptionRequestBody)); await this.actorService.ActorManager .SubscribeAsync( actorHeaders.ActorId, castedRequestMsgBody.eventInterfaceId, new ActorEventSubscriberProxy( castedRequestMsgBody.subscriptionId, requestContext.GetCallBackClient())); return(null); } if (messageHeaders.MethodId == Runtime.ActorEventSubscription.UnSubscribeMethodId) { var castedRequestMsgBody = (Actors.Remoting.EventSubscriptionRequestBody)requestMsgBody.GetParameter(0, "Value", typeof(Actors.Remoting.EventSubscriptionRequestBody)); await this.actorService.ActorManager .UnsubscribeAsync( actorHeaders.ActorId, castedRequestMsgBody.eventInterfaceId, castedRequestMsgBody.subscriptionId); return(null); } throw new MissingMethodException(string.Format(CultureInfo.CurrentCulture, SR.ErrorInvalidMethodId, messageHeaders.MethodId)); }
public override Task <byte[]> RequestResponseAsync( IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { var user = messageHeaders.GetUser(); var correlationId = messageHeaders.GetCorrelationId(); var headersInternal = messageHeaders.GetPrivateField <ServiceRemotingMessageHeaders, Dictionary <string, byte[]> >("headers"); var headerNames = headersInternal.Keys; return(ServiceRequestContext.RunInRequestContext( async() => await base.RequestResponseAsync( requestContext, messageHeaders, requestBody), correlationId, user)); }
public async Task <IServiceRemotingResponseMessage> HandleRequestResponseAsync( IServiceRemotingRequestContext requestContext, IServiceRemotingRequestMessage requestMessage) { Dictionary <string, string> context = ExtractContextProperties(requestMessage); string methodName = MethodResolver.GetMethodName(requestMessage); Exception gex = null; using (L.Context(context)) { using (var time = new TimeMeasure()) { try { return(await _innerHandler.HandleRequestResponseAsync(requestContext, requestMessage)); } catch (Exception ex) { gex = ex; throw; } finally { if (_raiseSummary != null) { var summary = new CallSummary(methodName, gex, time.ElapsedTicks); _raiseSummary(summary); } _log.Request(methodName, time.ElapsedTicks, gex, context.ToDictionary(k => k.Key, v => (object)(v.Value))); } } } }
public Task <byte[]> RequestResponseAsync( IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { ActivityId.UpdateCurrentActivityId(messageHeaders); return(this.innerRemotingMessageHandler.RequestResponseAsync(requestContext, messageHeaders, requestBody)); }
public Task<byte[]> RequestResponseAsync(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { return Task.FromResult(new byte[0]); }
public void HandleOneWay(IServiceRemotingRequestContext requestContext, ServiceRemotingMessageHeaders messageHeaders, byte[] requestBody) { }