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