private async void DispatchEvent(InMemFrame payload) { var requestMetrics = Metrics.StartRequestMetrics(connection.ConnectionMetrics); var receiveContext = new SimpleInMemReceiveContext(connection, connection.ConnectionMetrics, requestMetrics); var headers = payload.headers; var layerData = payload.layerData; var message = payload.message; ILayerStack layerStack; Error layerError = transport.GetLayerStack(requestMetrics.request_id, out layerStack); if (layerError == null) { layerError = LayerStackUtils.ProcessOnReceive(layerStack, MessageType.EVENT, receiveContext, layerData, logger); } if (layerError != null) { logger.Site().Error("Receiving event {0}/{1}.{2} failed due to layer error (Code: {3}, Message: {4}).", headers.conversation_id, headers.service_name, headers.method_name, layerError.error_code, layerError.message); return; } await serviceHost.DispatchEvent(headers.service_name, headers.method_name, receiveContext, message); }
private Task <IMessage> SendRequestAsync(string methodName, IMessage request) { var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics); var conversationId = AllocateNextConversationId(); var sendContext = new SimpleInMemSendContext(this, ConnectionMetrics, requestMetrics); IBonded layerData = null; ILayerStack layerStack; Error layerError = transport.GetLayerStack(requestMetrics.request_id, out layerStack); if (layerError == null) { layerError = LayerStackUtils.ProcessOnSend(layerStack, MessageType.Request, sendContext, out layerData, logger); } if (layerError != null) { logger.Site().Error("{0}: Sending request {1}/{2} failed due to layer error (Code: {3}, Message: {4}).", this, conversationId, methodName, layerError.error_code, layerError.message); return(Task.FromResult <IMessage>(Message.FromError(layerError))); } // Pass the layer stack instance as state in response task completion source. var responseCompletionSource = new TaskCompletionSource <IMessage>(layerStack); var payload = Util.NewPayLoad(conversationId, PayloadType.Request, layerData, request, responseCompletionSource); payload.headers.method_name = methodName; writeQueue.Enqueue(payload); return(payload.outstandingRequest.Task); }
private async void DispatchRequest(InMemFrame payload, InMemFrameQueue queue) { var requestMetrics = Metrics.StartRequestMetrics(connection.ConnectionMetrics); var receiveContext = new SimpleInMemReceiveContext(connection, connection.ConnectionMetrics, requestMetrics); var headers = payload.headers; var layerData = payload.layerData; var message = payload.message; var taskSource = payload.outstandingRequest; ILayerStack layerStack; Error layerError = transport.GetLayerStack(requestMetrics.request_id, out layerStack); if (layerError == null) { layerError = LayerStackUtils.ProcessOnReceive(layerStack, MessageType.REQUEST, receiveContext, layerData, logger); } IMessage response; if (layerError == null) { response = await serviceHost.DispatchRequest(headers.service_name, headers.method_name, receiveContext, message); } else { logger.Site().Error("Receiving request {0}/{1}.{2} failed due to layer error (Code: {3}, Message: {4}).", headers.conversation_id, headers.service_name, headers.method_name, layerError.error_code, layerError.message); // Set layer error as result of this Bond method call and do not dispatch to method. // Since this error will be returned to client, cleanse out internal server error details, if any. response = Message.FromError(Errors.CleanseInternalServerError(layerError)); } SendReply(headers.conversation_id, response, taskSource, layerStack, queue); }
internal async Task SendEventAsync(string methodName, IMessage message) { var conversationId = AllocateNextConversationId(); var sendContext = new EpoxySendContext(this); IBonded layerData = null; ILayerStack layerStack; Error layerError = parentTransport.GetLayerStack(out layerStack); if (layerError == null) { layerError = LayerStackUtils.ProcessOnSend( layerStack, MessageType.Event, sendContext, out layerData, logger); } if (layerError != null) { logger.Site().Error("{0} Sending event {1}/{2} failed due to layer error (Code: {3}, Message: {4}).", this, conversationId, methodName, layerError.error_code, layerError.message); return; } var frame = MessageToFrame(conversationId, methodName, PayloadType.Event, message, layerData, logger); logger.Site().Debug("{0} Sending event {1}/{2}.", this, conversationId, methodName); bool wasSent = await SendFrameAsync(frame); logger.Site().Debug("{0} Sending event {1}/{2} {3}.", this, conversationId, methodName, wasSent ? "succeeded" : "failed"); }
private void SendEventAsync(string methodName, IMessage message) { var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics); var conversationId = AllocateNextConversationId(); var sendContext = new SimpleInMemSendContext(this, ConnectionMetrics, requestMetrics); IBonded layerData = null; ILayerStack layerStack; Error layerError = transport.GetLayerStack(requestMetrics.request_id, out layerStack); if (layerError == null) { layerError = LayerStackUtils.ProcessOnSend(layerStack, MessageType.Event, sendContext, out layerData, logger); } if (layerError != null) { logger.Site().Error("{0}: Sending event {1}/{2} failed due to layer error (Code: {3}, Message: {4}).", this, conversationId, methodName, layerError.error_code, layerError.message); return; } var payload = Util.NewPayLoad(conversationId, PayloadType.Event, layerData, message, null); payload.headers.method_name = methodName; writeQueue.Enqueue(payload); }
private void DispatchEvent(EpoxyHeaders headers, ArraySegment <byte> payload, ArraySegment <byte> layerData) { if (headers.error_code != (int)ErrorCode.OK) { Log.Error("{0}.{1}: Received event with a non-zero error code. Conversation ID: {2}", this, nameof(DispatchEvent), headers.conversation_id); return; } IMessage request = Message.FromPayload(Unmarshal.From(payload)); var receiveContext = new EpoxyReceiveContext(this); IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData); Error layerError = LayerStackUtils.ProcessOnReceive(parentTransport.LayerStack, MessageType.Event, receiveContext, bondedLayerData); if (layerError != null) { Log.Error("{0}.{1}: Receiving event {2}/{3} failed due to layer error (Code: {4}, Message: {5}).", this, nameof(DispatchEvent), headers.conversation_id, headers.method_name, layerError.error_code, layerError.message); return; } Task.Run(async() => { await serviceHost.DispatchEvent(headers.method_name, receiveContext, request, connectionMetrics); }); }
private void DispatchResponse(EpoxyHeaders headers, ArraySegment <byte> payload, ArraySegment <byte> layerData) { IMessage response; if (headers.error_code != (int)ErrorCode.OK) { response = Message.FromError(Unmarshal <Error> .From(payload)); } else { response = Message.FromPayload(Unmarshal.From(payload)); } var receiveContext = new EpoxyReceiveContext(this); IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData); Error layerError = LayerStackUtils.ProcessOnReceive(parentTransport.LayerStack, MessageType.Response, receiveContext, bondedLayerData); if (layerError != null) { Log.Error("{0}.{1}: Receiving response {2}/{3} failed due to layer error (Code: {4}, Message: {5}).", this, nameof(DispatchResponse), headers.conversation_id, headers.method_name, layerError.error_code, layerError.message); response = Message.FromError(layerError); } if (!responseMap.Complete(headers.conversation_id, response)) { Log.Error("{0}.{1}: Response for unmatched request. Conversation ID: {2}", this, nameof(DispatchResponse), headers.conversation_id); } }
private async Task SendReplyAsync( ulong conversationId, IMessage response, ILayerStack layerStack, RequestMetrics requestMetrics) { var sendContext = new EpoxySendContext(this, ConnectionMetrics, requestMetrics); IBonded layerData; Error layerError = LayerStackUtils.ProcessOnSend( layerStack, MessageType.RESPONSE, sendContext, out layerData, logger); // If there was a layer error, replace the response with the layer error if (layerError != null) { logger.Site().Error("{0} Sending reply for conversation ID {1} failed due to layer error (Code: {2}, Message: {3}).", this, conversationId, layerError.error_code, layerError.message); // Set layer error as result of this Bond method call, replacing original response. // Since this error will be returned to client, cleanse out internal server error details, if any. response = Message.FromError(Errors.CleanseInternalServerError(layerError)); } var frame = MessageToFrame(conversationId, null, null, EpoxyMessageType.RESPONSE, response, layerData, logger); logger.Site().Debug("{0} Sending reply for conversation ID {1}.", this, conversationId); bool wasSent = await SendFrameAsync(frame); logger.Site().Debug("{0} Sending reply for conversation ID {1} {2}.", this, conversationId, wasSent ? "succeedeed" : "failed"); }
internal async Task SendEventAsync(string methodName, IMessage message) { var conversationId = AllocateNextConversationId(); var sendContext = new EpoxySendContext(this); IBonded layerData; Error layerError = LayerStackUtils.ProcessOnSend(parentTransport.LayerStack, MessageType.Event, sendContext, out layerData); if (layerError != null) { Log.Error("{0}.{1}: Sending event {2}/{3} failed due to layer error (Code: {4}, Message: {5}).", this, nameof(SendEventAsync), conversationId, methodName, layerError.error_code, layerError.message); return; } var frame = MessageToFrame(conversationId, methodName, PayloadType.Event, message, layerData); Log.Debug("{0}.{1}: Sending event {2}/{3}.", this, nameof(SendEventAsync), conversationId, methodName); bool wasSent = await SendFrameAsync(frame); Log.Debug( "{0}.{1}: Sending event {2}/{3} {4}.", this, nameof(SendEventAsync), conversationId, methodName, wasSent ? "succeded" : "failed"); }
internal void SendReply(ulong conversationId, IMessage response, TaskCompletionSource <IMessage> taskSource, ILayerStack layerStack, InMemFrameQueue queue) { var requestMetrics = Metrics.StartRequestMetrics(connection.ConnectionMetrics); var sendContext = new SimpleInMemSendContext(connection, connection.ConnectionMetrics, requestMetrics); IBonded layerData = null; Error layerError = LayerStackUtils.ProcessOnSend(layerStack, MessageType.RESPONSE, sendContext, out layerData, logger); // If there was a layer error, replace the response with the layer error if (layerError != null) { logger.Site().Error("Sending reply for conversation {0} failed due to layer error (Code: {1}, Message: {2}).", conversationId, layerError.error_code, layerError.message); // Set layer error as result of this Bond method call, replacing original response. // Since this error will be returned to client, cleanse out internal server error details, if any. response = Message.FromError(Errors.CleanseInternalServerError(layerError)); } var payload = Util.NewPayLoad(conversationId, SimpleInMemMessageType.RESPONSE, layerData, response, taskSource); queue.Enqueue(payload); }
private State?DispatchRequest(EpoxyHeaders headers, EpoxyProtocol.MessageData messageData, ArraySegment <byte> layerData) { Task.Run(async() => { var totalTime = Stopwatch.StartNew(); var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics); var receiveContext = new EpoxyReceiveContext(this, ConnectionMetrics, requestMetrics); ILayerStack layerStack = null; IMessage result; if (messageData.IsError) { logger.Site().Error("{0} Received request with an error message. Only payload messages are allowed. Conversation ID: {1}", this, headers.conversation_id); result = Message.FromError(new Error { error_code = (int)ErrorCode.INVALID_INVOCATION, message = "Received request with an error message" }); } else { IMessage request = Message.FromPayload(Unmarshal.From(messageData.Data)); IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData); Error layerError = parentTransport.GetLayerStack(requestMetrics.request_id, out layerStack); if (layerError == null) { layerError = LayerStackUtils.ProcessOnReceive( layerStack, MessageType.REQUEST, receiveContext, bondedLayerData, logger); } if (layerError == null) { result = await serviceHost.DispatchRequest(headers.service_name, headers.method_name, receiveContext, request); } else { logger.Site().Error("{0} Receiving request {1}/{2}.{3} failed due to layer error (Code: {4}, Message: {5}).", this, headers.conversation_id, headers.service_name, headers.method_name, layerError.error_code, layerError.message); // Set layer error as result of this Bond method call and do not dispatch to method. // Since this error will be returned to client, cleanse out internal server error details, if any. result = Message.FromError(Errors.CleanseInternalServerError(layerError)); } } await SendReplyAsync(headers.conversation_id, result, layerStack, requestMetrics); Metrics.FinishRequestMetrics(requestMetrics, totalTime); metrics.Emit(requestMetrics); }); // no state change needed return(null); }
private async Task <IMessage> SendRequestAsync <TPayload>(string serviceName, string methodName, IMessage <TPayload> request) { var conversationId = AllocateNextConversationId(); var totalTime = Stopwatch.StartNew(); var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics); var sendContext = new EpoxySendContext(this, ConnectionMetrics, requestMetrics); IBonded layerData = null; ILayerStack layerStack; Error layerError = parentTransport.GetLayerStack(requestMetrics.request_id, out layerStack); if (layerError == null) { layerError = LayerStackUtils.ProcessOnSend( layerStack, MessageType.REQUEST, sendContext, out layerData, logger); } if (layerError != null) { logger.Site().Error("{0} Sending request {1}/{2}.{3} failed due to layer error (Code: {4}, Message: {5}).", this, conversationId, serviceName, methodName, layerError.error_code, layerError.message); return(Message.FromError(layerError)); } var frame = MessageToFrame(conversationId, serviceName, methodName, EpoxyMessageType.REQUEST, request, layerData, logger); logger.Site().Debug("{0} Sending request {1}/{2}.", this, conversationId, methodName); var responseTask = responseMap.Add(conversationId, layerStack); bool wasSent = await SendFrameAsync(frame); logger.Site().Debug("{0} Sending request {1}/{2}.{3} {4}.", this, conversationId, serviceName, methodName, wasSent ? "succeeded" : "failed"); if (!wasSent) { bool wasCompleted = responseMap.Complete( conversationId, Message.FromError(new Error { error_code = (int)ErrorCode.TRANSPORT_ERROR, message = "Request could not be sent" })); if (!wasCompleted) { logger.Site().Information("{0} Unsuccessfully sent request {1}/{2}.{3} still received response.", this, conversationId, serviceName, methodName); } } var message = await responseTask; Metrics.FinishRequestMetrics(requestMetrics, totalTime); metrics.Emit(requestMetrics); return(message); }
private State?DispatchRequest(EpoxyHeaders headers, ArraySegment <byte> payload, ArraySegment <byte> layerData) { if (headers.error_code != (int)ErrorCode.OK) { logger.Site().Error("{0} Received request with a non-zero error code. Conversation ID: {1}", this, headers.conversation_id); protocolError = ProtocolErrorCode.PROTOCOL_VIOLATED; return(State.SendProtocolError); } Task.Run(async() => { var totalTime = Stopwatch.StartNew(); var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics); var receiveContext = new EpoxyReceiveContext(this, ConnectionMetrics, requestMetrics); IMessage request = Message.FromPayload(Unmarshal.From(payload)); IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData); ILayerStack layerStack; Error layerError = parentTransport.GetLayerStack(requestMetrics.request_id, out layerStack); if (layerError == null) { layerError = LayerStackUtils.ProcessOnReceive( layerStack, MessageType.Request, receiveContext, bondedLayerData, logger); } IMessage result; if (layerError == null) { result = await serviceHost.DispatchRequest(headers.method_name, receiveContext, request); } else { logger.Site().Error("{0} Receiving request {1}/{2} failed due to layer error (Code: {3}, Message: {4}).", this, headers.conversation_id, headers.method_name, layerError.error_code, layerError.message); // Set layer error as result of this Bond method call and do not dispatch to method. // Since this error will be returned to client, cleanse out internal server error details, if any. result = Message.FromError(Errors.CleanseInternalServerError(layerError)); } await SendReplyAsync(headers.conversation_id, result, layerStack, requestMetrics); Metrics.FinishRequestMetrics(requestMetrics, totalTime); metrics.Emit(requestMetrics); }); // no state change needed return(null); }
private async Task <IMessage> SendRequestAsync <TPayload>(string methodName, IMessage <TPayload> request) { var conversationId = AllocateNextConversationId(); var sendContext = new EpoxySendContext(this); IBonded layerData = null; ILayerStack layerStack; Error layerError = parentTransport.GetLayerStack(out layerStack); if (layerError == null) { layerError = LayerStackUtils.ProcessOnSend( layerStack, MessageType.Request, sendContext, out layerData, logger); } if (layerError != null) { logger.Site().Error("{0} Sending request {1}/{2} failed due to layer error (Code: {3}, Message: {4}).", this, conversationId, methodName, layerError.error_code, layerError.message); return(Message.FromError(layerError)); } var frame = MessageToFrame(conversationId, methodName, PayloadType.Request, request, layerData, logger); logger.Site().Debug("{0} Sending request {1}/{2}.", this, conversationId, methodName); var responseTask = responseMap.Add(conversationId, layerStack); bool wasSent = await SendFrameAsync(frame); logger.Site().Debug("{0} Sending request {1}/{2} {3}.", this, conversationId, methodName, wasSent ? "succeeded" : "failed"); if (!wasSent) { bool wasCompleted = responseMap.Complete( conversationId, Message.FromError(new Error { error_code = (int)ErrorCode.TransportError, message = "Request could not be sent" })); if (!wasCompleted) { logger.Site().Information("{0} Unsuccessfully sent request {1}/{2} still received response.", this, conversationId, methodName); } } return(await responseTask); }
internal async Task SendEventAsync(string serviceName, string methodName, IMessage message) { var conversationId = AllocateNextConversationId(); var totalTime = Stopwatch.StartNew(); var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics); var sendContext = new RelayEpoxySendContext(this, ConnectionMetrics, requestMetrics); IBonded layerData = null; ILayerStack layerStack; Error layerError = parentTransport.GetLayerStack(requestMetrics.request_id, out layerStack); if (layerError == null) { layerError = LayerStackUtils.ProcessOnSend( layerStack, MessageType.EVENT, sendContext, out layerData, logger); } if (layerError != null) { logger.Site().Error( "{0} Sending event {1}/{2}.{3} failed due to layer error (Code: {4}, Message: {5}).", this, conversationId, serviceName, methodName, layerError.error_code, layerError.message); return; } var frame = MessageToFrame(conversationId, serviceName, methodName, EpoxyMessageType.EVENT, message, layerData, logger); logger.Site().Debug("{0} Sending event {1}/{2}.{3}.", this, conversationId, serviceName, methodName); bool wasSent = await SendFrameAsync(frame); logger.Site().Debug( "{0} Sending event {1}/{2}.{3} {4}.", this, conversationId, serviceName, methodName, wasSent ? "succeeded" : "failed"); Metrics.FinishRequestMetrics(requestMetrics, totalTime); metrics.Emit(requestMetrics); }
void DispatchEvent(EpoxyHeaders headers, EpoxyProtocol.MessageData messageData, ArraySegment <byte> layerData) { if (messageData.IsError) { logger.Site().Error( "{0} Received event with an error message. Only payload messages are allowed. Conversation ID: {1}", this, headers.conversation_id); return; } Task.Run( async() => { IMessage request = Message.FromPayload(Unmarshal.From(messageData.Data)); var totalTime = Stopwatch.StartNew(); var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics); var receiveContext = new RelayEpoxyReceiveContext(this, ConnectionMetrics, requestMetrics); IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData); ILayerStack layerStack; Error layerError = parentTransport.GetLayerStack(requestMetrics.request_id, out layerStack); if (layerError == null) { layerError = LayerStackUtils.ProcessOnReceive( layerStack, MessageType.EVENT, receiveContext, bondedLayerData, logger); } if (layerError != null) { logger.Site().Error( "{0}: Receiving event {1}/{2}.{3} failed due to layer error (Code: {4}, Message: {5}).", this, headers.conversation_id, headers.service_name, headers.method_name, layerError.error_code, layerError.message); return; } await serviceHost.DispatchEvent(headers.service_name, headers.method_name, receiveContext, request); Metrics.FinishRequestMetrics(requestMetrics, totalTime); metrics.Emit(requestMetrics); }); }
void DispatchResponse(EpoxyHeaders headers, EpoxyProtocol.MessageData messageData, ArraySegment <byte> layerData) { IMessage response = messageData.IsError ? Message.FromError(Unmarshal <Error> .From(messageData.Data)) : Message.FromPayload(Unmarshal.From(messageData.Data)); TaskCompletionSource <IMessage> tcs = responseMap.TakeTaskCompletionSource(headers.conversation_id); if (tcs == null) { logger.Site().Error( "{0} Response for unmatched request. Conversation ID: {1}", this, headers.conversation_id); return; } Task.Run( () => { var totalTime = Stopwatch.StartNew(); var requestMetrics = Metrics.StartRequestMetrics(ConnectionMetrics); var receiveContext = new RelayEpoxyReceiveContext(this, ConnectionMetrics, requestMetrics); IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData); ILayerStack layerStack = tcs.Task.AsyncState as ILayerStack; Error layerError = LayerStackUtils.ProcessOnReceive(layerStack, MessageType.RESPONSE, receiveContext, bondedLayerData, logger); if (layerError != null) { logger.Site().Error( "{0} Receiving response {1}/{2}.{3} failed due to layer error (Code: {4}, Message: {5}).", this, headers.conversation_id, headers.service_name, headers.method_name, layerError.error_code, layerError.message); response = Message.FromError(layerError); } tcs.SetResult(response); Metrics.FinishRequestMetrics(requestMetrics, totalTime); metrics.Emit(requestMetrics); }); }
private void DispatchResponse(EpoxyHeaders headers, ArraySegment <byte> payload, ArraySegment <byte> layerData) { IMessage response; if (headers.error_code != (int)ErrorCode.OK) { response = Message.FromError(Unmarshal <Error> .From(payload)); } else { response = Message.FromPayload(Unmarshal.From(payload)); } TaskCompletionSource <IMessage> tcs = responseMap.TakeTaskCompletionSource(headers.conversation_id); if (tcs == null) { logger.Site().Error("{0} Response for unmatched request. Conversation ID: {1}", this, headers.conversation_id); return; } Task.Run(() => { var receiveContext = new EpoxyReceiveContext(this); IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData); ILayerStack layerStack = tcs.Task.AsyncState as ILayerStack; Error layerError = LayerStackUtils.ProcessOnReceive(layerStack, MessageType.Response, receiveContext, bondedLayerData, logger); if (layerError != null) { logger.Site().Error("{0} Receiving response {1}/{2} failed due to layer error (Code: {3}, Message: {4}).", this, headers.conversation_id, headers.method_name, layerError.error_code, layerError.message); response = Message.FromError(layerError); } tcs.SetResult(response); }); }
private State?DispatchRequest(EpoxyHeaders headers, ArraySegment <byte> payload, ArraySegment <byte> layerData) { if (headers.error_code != (int)ErrorCode.OK) { Log.Error("{0}.{1}: Received request with a non-zero error code. Conversation ID: {2}", this, nameof(DispatchRequest), headers.conversation_id); protocolError = ProtocolErrorCode.PROTOCOL_VIOLATED; return(State.SendProtocolError); } IMessage request = Message.FromPayload(Unmarshal.From(payload)); var receiveContext = new EpoxyReceiveContext(this); IBonded bondedLayerData = (layerData.Array == null) ? null : Unmarshal.From(layerData); Error layerError = LayerStackUtils.ProcessOnReceive(parentTransport.LayerStack, MessageType.Request, receiveContext, bondedLayerData); Task.Run(async() => { IMessage result; if (layerError == null) { result = await serviceHost.DispatchRequest(headers.method_name, receiveContext, request, connectionMetrics); } else { Log.Error("{0}.{1}: Receiving request {2}/{3} failed due to layer error (Code: {4}, Message: {5}).", this, nameof(DispatchRequest), headers.conversation_id, headers.method_name, layerError.error_code, layerError.message); result = Message.FromError(layerError); } await SendReplyAsync(headers.conversation_id, result); }); // no state change needed return(null); }
private void DispatchResponse(InMemFrame payload) { var receiveContext = new SimpleInMemReceiveContext(connection); var headers = payload.headers; var layerData = payload.layerData; var message = payload.message; var taskSource = payload.outstandingRequest; ILayerStack layerStack = taskSource.Task.AsyncState as ILayerStack; Error layerError = LayerStackUtils.ProcessOnReceive(layerStack, MessageType.Response, receiveContext, layerData, logger); if (layerError != null) { logger.Site().Error("Receiving response {0}/{1} failed due to layer error (Code: {2}, Message: {3}).", headers.conversation_id, headers.method_name, layerError.error_code, layerError.message); message = Message.FromError(layerError); } payload.outstandingRequest.SetResult(message); }
private async Task SendReplyAsync(ulong conversationId, IMessage response) { var sendContext = new EpoxySendContext(this); IBonded layerData; Error layerError = LayerStackUtils.ProcessOnSend(parentTransport.LayerStack, MessageType.Response, sendContext, out layerData); // If there was a layer error, replace the response with the layer error if (layerError != null) { Log.Error("{0}.{1}: Sending reply for conversation ID {2} failed due to layer error (Code: {3}, Message: {4}).", this, nameof(SendReplyAsync), conversationId, layerError.error_code, layerError.message); response = Message.FromError(layerError); } var frame = MessageToFrame(conversationId, null, PayloadType.Response, response, layerData); Log.Debug("{0}.{1}: Sending reply for conversation ID {2}.", this, nameof(SendReplyAsync), conversationId); bool wasSent = await SendFrameAsync(frame); Log.Debug( "{0}.{1}: Sending reply for conversation ID {2} {3}.", this, nameof(SendReplyAsync), conversationId, wasSent ? "succeded" : "failed"); }