private void CompleteFailedRequest(OperationResult result, string error)
{
Debug.Assert(result != OperationResult.Success);
_completed = true;
Message responseMsg;
switch (_requestType)
{
case RequestType.TransactionStart:
responseMsg =
new ClientMessage.TransactionStartCompleted(_clientCorrId, _transactionId, result, error);
break;
case RequestType.TransactionWrite:
// Should never happen, only possibly under very heavy load...
responseMsg =
new ClientMessage.TransactionWriteCompleted(_clientCorrId, _transactionId, result, error);
break;
default:
throw new ArgumentOutOfRangeException();
}
_responseEnvelope.ReplyWith(responseMsg);
_bus.Publish(new StorageMessage.RequestCompleted(_internalCorrId, false));
}
private static TcpPackage WrapTransactionWriteCompleted(ClientMessage.TransactionWriteCompleted msg)
{
var dto = new TcpClientMessageDto.TransactionWriteCompleted(msg.TransactionId,
(TcpClientMessageDto.OperationResult)msg.Result, msg.Message);
return(new TcpPackage(TcpCommand.TransactionWriteCompleted, msg.CorrelationId, dto.Serialize()));
}
public InspectionResult InspectPackage(TcpPackage package)
{
try
{
if (package.Command == TcpCommand.DeniedToRoute)
{
var route = package.Data.Deserialize <ClientMessage.DeniedToRoute>();
return(new InspectionResult(InspectionDecision.Reconnect,
data: new EndpointsPair(route.ExternalTcpEndPoint,
route.ExternalHttpEndPoint)));
}
if (package.Command != TcpCommand.TransactionWriteCompleted)
{
return(new InspectionResult(InspectionDecision.NotifyError,
new CommandNotExpectedException(TcpCommand.TransactionWriteCompleted.ToString(),
package.Command.ToString())));
}
var data = package.Data;
var dto = data.Deserialize <ClientMessage.TransactionWriteCompleted>();
_result = dto;
switch ((OperationErrorCode)dto.ErrorCode)
{
case OperationErrorCode.Success:
return(new InspectionResult(InspectionDecision.Succeed));
case OperationErrorCode.PrepareTimeout:
case OperationErrorCode.CommitTimeout:
case OperationErrorCode.ForwardTimeout:
return(new InspectionResult(InspectionDecision.Retry));
case OperationErrorCode.WrongExpectedVersion:
var err = string.Format("Transactional write failed due to WrongExpectedVersion. Stream: {0}, TransactionID: {1}, CorrID: {2}.",
_stream,
_transactionId,
CorrelationId);
return(new InspectionResult(InspectionDecision.NotifyError, new WrongExpectedVersionException(err)));
case OperationErrorCode.StreamDeleted:
return(new InspectionResult(InspectionDecision.NotifyError, new StreamDeletedException(_stream)));
case OperationErrorCode.InvalidTransaction:
return(new InspectionResult(InspectionDecision.NotifyError, new InvalidTransactionException()));
default:
throw new ArgumentOutOfRangeException();
}
}
catch (Exception e)
{
return(new InspectionResult(InspectionDecision.NotifyError, e));
}
}
private void HandleAsNonMaster(ClientMessage.TransactionWrite message)
{
if (message.RequireMaster)
{
DenyRequestBecauseNotMaster(message.CorrelationId, message.Envelope);
return;
}
var timeoutMessage = new ClientMessage.TransactionWriteCompleted(
message.CorrelationId, message.TransactionId, OperationResult.ForwardTimeout, "Forwarding timeout");
ForwardRequest(message, timeoutMessage);
}
private void CompleteSuccessRequest()
{
_completed = true;
Message responseMsg;
switch (_requestType)
{
case RequestType.TransactionStart:
responseMsg = new ClientMessage.TransactionStartCompleted(_clientCorrId, _transactionId, OperationResult.Success, null);
break;
case RequestType.TransactionWrite:
responseMsg = new ClientMessage.TransactionWriteCompleted(_clientCorrId, _transactionId, OperationResult.Success, null);
break;
default:
throw new ArgumentOutOfRangeException();
}
_responseEnvelope.ReplyWith(responseMsg);
_bus.Publish(new StorageMessage.RequestCompleted(_internalCorrId, true));
}
private void CompleteSuccessRequest(Guid correlationId, long transactionId, string eventStreamId)
{
_completed = true;
Message responseMsg;
switch (_requestType)
{
case RequestType.TransactionStart:
responseMsg = new ClientMessage.TransactionStartCompleted(correlationId, transactionId, eventStreamId, OperationErrorCode.Success, null);
break;
case RequestType.TransactionWrite:
responseMsg = new ClientMessage.TransactionWriteCompleted(correlationId, transactionId, eventStreamId, OperationErrorCode.Success, null);
break;
default:
throw new ArgumentOutOfRangeException();
}
_responseEnvelope.ReplyWith(responseMsg);
_bus.Publish(new ReplicationMessage.RequestCompleted(correlationId, true));
}
private void CompleteFailedRequest(Guid correlationId, long transactionId, string eventStreamId, OperationErrorCode errorCode, string error)
{
Debug.Assert(errorCode != OperationErrorCode.Success);
_completed = true;
Message responseMsg;
switch (_requestType)
{
case RequestType.TransactionStart:
responseMsg = new ClientMessage.TransactionStartCompleted(correlationId, transactionId, eventStreamId, errorCode, error);
break;
case RequestType.TransactionWrite:
// Should never happen, only possibly under very heavy load...
responseMsg = new ClientMessage.TransactionWriteCompleted(correlationId, transactionId, eventStreamId, errorCode, error);
break;
default:
throw new ArgumentOutOfRangeException();
}
_responseEnvelope.ReplyWith(responseMsg);
_bus.Publish(new ReplicationMessage.RequestCompleted(correlationId, false));
}
private static TcpPackage WrapTransactionWriteCompleted(ClientMessage.TransactionWriteCompleted msg)
{
var dto = new ClientMessageDto.TransactionWriteCompleted(msg.CorrelationId, msg.TransactionId, msg.EventStreamId, msg.ErrorCode, msg.Error);
return(new TcpPackage(TcpCommand.TransactionWriteCompleted, msg.CorrelationId, dto.Serialize()));
}
public void Handle(ClientMessage.TransactionWriteCompleted message)
{
_forwardingProxy.TryForwardReply(message.CorrelationId, message,
(clientCorrId, m) => m.WithCorrelationId(clientCorrId));
}
