public void Handle(ClientMessage.TransactionWrite message)
{
var manager = new SingleAckRequestManager(_bus, _prepareTimeout);
_currentRequests.Add(message.InternalCorrId, manager);
manager.Handle(message);
}
public void Write(ClientMessage.TransactionWrite message, ref int fakePosition)
{
foreach (var @event in message.Events)
{
_events.Add(Tuple.Create(fakePosition, @event));
fakePosition += 50;
}
}
private void Handle(ClientMessage.TransactionWrite message)
{
_outputBus.Publish(new StorageMessage.TransactionWriteRequestCreated(message.CorrelationId,
message.Envelope,
message.TransactionId,
message.EventStreamId,
message.Events));
}
public void Handle(ClientMessage.TransactionWrite message)
{
var manager = new SingleAckRequestManager(_bus, _prepareTimeout, _betterOrdering);
_currentRequests.Add(message.InternalCorrId, manager);
_currentTimedRequests.Add(message.InternalCorrId, Stopwatch.StartNew());
manager.Handle(message);
}
private static TcpPackage WrapTransactionWrite(ClientMessage.TransactionWrite msg)
{
var dto = new ClientMessageDto.TransactionWrite(msg.TransactionId,
msg.EventStreamId,
msg.Events.Select(x => new ClientMessageDto.Event(x.EventId, x.EventType, x.Data, x.Metadata)).ToArray());
return(new TcpPackage(TcpCommand.TransactionWrite, msg.CorrelationId, dto.Serialize()));
}
public TcpPackage CreateNetworkPackage()
{
lock (_corrIdLock)
{
var dtos = _events.Select(x => new ClientMessage.ClientEvent(x.EventId.ToByteArray(), x.Type, x.IsJson, x.Data, x.Metadata)).ToArray();
var write = new ClientMessage.TransactionWrite(_transactionId, _stream, dtos, _forward);
return(new TcpPackage(TcpCommand.TransactionWrite, _corrId, write.Serialize()));
}
}
public void Handle(ClientMessage.TransactionWrite message) {
Transaction transaction;
if (!_activeTransactions.TryGetValue(message.TransactionId, out transaction)) {
message.Envelope.ReplyWith(
new ClientMessage.TransactionWriteCompleted(
message.CorrelationId, message.TransactionId, OperationResult.InvalidTransaction,
"Transaction not found"));
} else {
transaction.Write(message, ref _fakePosition);
}
}
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 static TcpPackage WrapTransactionWrite(ClientMessage.TransactionWrite msg)
{
var events = new TcpClientMessageDto.NewEvent[msg.Events.Length];
for (int i = 0; i < events.Length; ++i)
{
var e = msg.Events[i];
events[i] = new TcpClientMessageDto.NewEvent(e.EventId.ToByteArray(), e.EventType, e.IsJson ? 1 : 0, 0, e.Data, e.Metadata);
}
var dto = new TcpClientMessageDto.TransactionWrite(msg.TransactionId, events, msg.RequireMaster);
return(CreateWriteRequestPackage(TcpCommand.TransactionWrite, msg, dto));
}
public Task TransactionalWriteAsync(EventStoreTransaction transaction, IEnumerable <EventData> events,
UserCredentials userCredentials = null)
{
var source = new TaskCompletionSource <EventStoreTransaction>();
var envelope = new EmbeddedResponseEnvelope(new EmbeddedResponders.TransactionWrite(source, this));
Guid corrId = Guid.NewGuid();
var message = new ClientMessage.TransactionWrite(corrId, corrId, envelope, false,
transaction.TransactionId, events.ConvertToEvents(), SystemAccount.Principal);
_publisher.Publish(message);
return(source.Task);
}
public void Handle(ClientMessage.TransactionWrite message)
{
var manager = new TransactionWrite(
_bus,
_prepareTimeout,
message.Envelope,
message.InternalCorrId,
message.CorrelationId,
message.Events,
message.TransactionId,
_commitSource);
_currentRequests.Add(message.InternalCorrId, manager);
_currentTimedRequests.Add(message.InternalCorrId, Stopwatch.StartNew());
manager.Start();
}
public void Handle(ClientMessage.TransactionWrite request)
{
if (_initialized)
{
throw new InvalidOperationException();
}
_initialized = true;
_requestType = RequestType.TransactionWrite;
_responseEnvelope = request.Envelope;
_internalCorrId = request.InternalCorrId;
_clientCorrId = request.CorrelationId;
_transactionId = request.TransactionId;
_bus.Publish(new StorageMessage.WriteTransactionData(_internalCorrId, _publishEnvelope, _transactionId, request.Events));
CompleteSuccessRequest();
}
private void Handle(ClientMessage.TransactionWrite message)
{
_outputBus.Publish(message);
}
