private void Handle(ClientMessage.DeleteStream message)
{
_outputBus.Publish(new StorageMessage.DeleteStreamRequestCreated(message.CorrelationId,
message.Envelope,
message.EventStreamId,
message.ExpectedVersion));
}
public void Handle(ClientMessage.DeleteStream message)
{
List <EventRecord> list;
if (_deletedStreams.Contains(message.EventStreamId))
{
message.Envelope.ReplyWith(new ClientMessage.DeleteStreamCompleted(message.CorrelationId, OperationResult.StreamDeleted, string.Empty, -1, -1));
return;
}
if (!_streams.TryGetValue(message.EventStreamId, out list) || list == null)
{
if (message.ExpectedVersion == ExpectedVersion.Any)
{
message.Envelope.ReplyWith(new ClientMessage.DeleteStreamCompleted(message.CorrelationId, OperationResult.StreamDeleted, string.Empty, -1, -1));
_deletedStreams.Add(message.EventStreamId);
return;
}
message.Envelope.ReplyWith(new ClientMessage.DeleteStreamCompleted(message.CorrelationId, OperationResult.WrongExpectedVersion, string.Empty));
return;
}
_deletedStreams.Add(message.EventStreamId);
ProcessWrite <Message>(
null, message.CorrelationId, SystemStreams.MetastreamOf(message.EventStreamId), ExpectedVersion.Any,
new Event[]
{ new Event(Guid.NewGuid(), SystemEventTypes.StreamMetadata, true, CreateStreamDeletedEventJson(), null) },
null, null);
message.Envelope.ReplyWith(new ClientMessage.DeleteStreamCompleted(message.CorrelationId, OperationResult.Success, string.Empty));
}
public void Handle(ClientMessage.DeleteStream message)
{
var manager = new DeleteStreamTwoPhaseRequestManager(_bus, _prepareCount, _commitCount, _prepareTimeout, _commitTimeout);
_currentRequests.Add(message.InternalCorrId, manager);
manager.Handle(message);
}
private static TcpPackage WrapDeleteStream(ClientMessage.DeleteStream msg)
{
var dto = new TcpClientMessageDto.DeleteStream(msg.EventStreamId, msg.ExpectedVersion, msg.RequireLeader,
msg.HardDelete);
return(CreateWriteRequestPackage(TcpCommand.DeleteStream, msg, dto));
}
public void Handle(ClientMessage.DeleteStream msg)
{
_externalRequestQueue.Publish(
new ClientMessage.DeleteStream(
msg.InternalCorrId, msg.CorrelationId, new PublishToWrapEnvelop(_inputQueue, msg.Envelope), false,
msg.EventStreamId, msg.ExpectedVersion, msg.HardDelete, msg.User));
}
public void Handle(ClientMessage.DeleteStream message)
{
var manager = new DeleteStreamTwoPhaseRequestManager(_bus, _prepareCount, _commitCount, _prepareTimeout, _commitTimeout, _betterOrdering);
_currentRequests.Add(message.InternalCorrId, manager);
_currentTimedRequests.Add(message.InternalCorrId, Stopwatch.StartNew());
manager.Handle(message);
}
public TcpPackage CreateNetworkPackage()
{
lock (_corrIdLock)
{
var dto = new ClientMessage.DeleteStream(_stream, _expectedVersion, _forward);
return(new TcpPackage(TcpCommand.DeleteStream, _correlationId, dto.Serialize()));
}
}
private void HandleAsNonMaster(ClientMessage.DeleteStream message)
{
if (message.RequireMaster)
{
DenyRequestBecauseNotMaster(message.CorrelationId, message.Envelope);
return;
}
var timeoutMessage = new ClientMessage.DeleteStreamCompleted(
message.CorrelationId, OperationResult.ForwardTimeout, "Forwarding timeout", -1, -1);
ForwardRequest(message, timeoutMessage);
}
public void when_wrapping_message_that_does_not_have_version1_wrapper_should_use_version2_wrapper()
{
var msg = new ClientMessage.DeleteStream(Guid.NewGuid(), Guid.NewGuid(), _envelope, true, "test-stream", ExpectedVersion.Any, false, SystemAccount.Principal);
var package = _dispatcher.WrapMessage(msg, _version);
Assert.IsNotNull(package, "Package");
Assert.AreEqual(TcpCommand.DeleteStream, package.Value.Command);
var dto = package.Value.Data.Deserialize <TcpClientMessageDto.DeleteStream>();
Assert.IsNotNull(dto, "DTO is null");
}
public void Handle(ClientMessage.DeleteStream message)
{
List <EventRecord> list;
if (_deletedStreams.Contains(message.EventStreamId))
{
message.Envelope.ReplyWith(new ClientMessage.DeleteStreamCompleted(message.CorrelationId, OperationResult.StreamDeleted, string.Empty));
return;
}
if (!_lastMessageReplies.TryGetValue(message.EventStreamId, out list) || list == null)
{
message.Envelope.ReplyWith(new ClientMessage.DeleteStreamCompleted(message.CorrelationId, OperationResult.WrongExpectedVersion, string.Empty));
return;
}
_deletedStreams.Add(message.EventStreamId);
message.Envelope.ReplyWith(new ClientMessage.DeleteStreamCompleted(message.CorrelationId, OperationResult.Success, string.Empty));
}
public void Handle(ClientMessage.DeleteStream message)
{
var manager = new DeleteStream(
_bus,
_commitTimeout,
message.Envelope,
message.InternalCorrId,
message.CorrelationId,
message.EventStreamId,
message.ExpectedVersion,
message.HardDelete,
_commitSource);
_currentRequests.Add(message.InternalCorrId, manager);
_currentTimedRequests.Add(message.InternalCorrId, Stopwatch.StartNew());
manager.Start();
}
private void DeleteStreamBodyRead(HttpEntityManager manager, string body)
{
var entity = manager.HttpEntity;
var stream = (string)manager.AsyncState;
var delete = entity.RequestCodec.From <ClientMessageDto.DeleteStreamText>(body);
if (delete == null)
{
SendBadRequest(entity, "Delete stream request body cannot be deserialized");
return;
}
var envelope = new SendToHttpEnvelope(entity,
Format.Atom.DeleteStreamCompleted,
Configure.DeleteStreamCompleted);
var msg = new ClientMessage.DeleteStream(delete.CorrelationId == Guid.Empty ? Guid.NewGuid() : delete.CorrelationId,
envelope,
stream,
delete.ExpectedVersion);
Publish(msg);
}
private static TcpPackage WrapDeleteStream(ClientMessage.DeleteStream msg)
{
var dto = new ClientMessageDto.DeleteStream(msg.CorrelationId, msg.EventStreamId, msg.ExpectedVersion);
return(new TcpPackage(TcpCommand.DeleteStream, msg.CorrelationId, dto.Serialize()));
}
public override void Handle(ClientMessage.DeleteStream message)
{
_deleteMessages.Add(message);
message.Envelope.ReplyWith(new ClientMessage.DeleteStreamCompleted(
message.CorrelationId, OperationResult.Success, String.Empty));
}
private void Handle(ClientMessage.DeleteStream message)
{
_outputBus.Publish(message);
}
public abstract void Handle(ClientMessage.DeleteStream message);
