protected override void CompleteSuccessRequest(long firstEventNumber, long lastEventNumber, long preparePosition, long commitPosition) { base.CompleteSuccessRequest(firstEventNumber, lastEventNumber, preparePosition, commitPosition); var responseMsg = new ClientMessage.DeleteStreamCompleted(ClientCorrId, OperationResult.Success, null, preparePosition, commitPosition); ResponseEnvelope.ReplyWith(responseMsg); }
protected override void CompleteFailedRequest(OperationResult result, string error, long currentVersion = -1) { base.CompleteFailedRequest(result, error, currentVersion); var responseMsg = new ClientMessage.DeleteStreamCompleted(ClientCorrId, result, error); ResponseEnvelope.ReplyWith(responseMsg); }
protected override void CompleteSuccessRequest(int firstEventNumber, int lastEventNumber) { base.CompleteSuccessRequest(firstEventNumber, lastEventNumber); var responseMsg = new ClientMessage.DeleteStreamCompleted(ClientCorrId, OperationResult.Success, null); ResponseEnvelope.ReplyWith(responseMsg); }
private void DeleteStreamCompleted(ClientMessage.DeleteStreamCompleted deleteStreamCompleted, Action onEmittedStreamsDeleted, string streamId, long eventNumber) { if (deleteStreamCompleted.Result == OperationResult.Success || deleteStreamCompleted.Result == OperationResult.StreamDeleted) { _retryCount = RetryLimit; _numberOfEventsProcessed++; if (_numberOfEventsProcessed >= _checkPointThreshold) { _numberOfEventsProcessed = 0; TryMarkCheckpoint(eventNumber); } DeleteEmittedStreamsFrom(eventNumber + 1, onEmittedStreamsDeleted); } else { if (_retryCount == 0) { Log.Error("PROJECTIONS: Retry limit reached, could not delete stream: {0}. Manual intervention is required and you may need to delete this stream manually", streamId); _retryCount = RetryLimit; DeleteEmittedStreamsFrom(eventNumber + 1, onEmittedStreamsDeleted); return; } Log.Error("PROJECTIONS: Failed to delete emitted stream {0}, Retrying ({1}/{2}). Reason: {3}", streamId, (RetryLimit - _retryCount) + 1, RetryLimit, deleteStreamCompleted.Result); _retryCount--; DeleteEmittedStreamsFrom(eventNumber, onEmittedStreamsDeleted); } }
protected override void CompleteFailedRequest(Guid correlationId, string eventStreamId, OperationErrorCode errorCode, string error) { base.CompleteFailedRequest(correlationId, eventStreamId, errorCode, error); var responseMsg = new ClientMessage.DeleteStreamCompleted( correlationId, eventStreamId, errorCode, error); _responseEnvelope.ReplyWith(responseMsg); }
protected override void CompleteSuccessRequest(Guid correlationId, string eventStreamId, int startEventNumber) { base.CompleteSuccessRequest(correlationId, eventStreamId, startEventNumber); var responseMsg = new ClientMessage.DeleteStreamCompleted( correlationId, eventStreamId, OperationErrorCode.Success, null); _responseEnvelope.ReplyWith(responseMsg); }
private static TcpPackage WrapDeleteStreamCompleted(ClientMessage.DeleteStreamCompleted msg) { var dto = new TcpClientMessageDto.DeleteStreamCompleted((TcpClientMessageDto.OperationResult)msg.Result, msg.Message, msg.PreparePosition, msg.CommitPosition); return(new TcpPackage(TcpCommand.DeleteStreamCompleted, 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.DeleteStreamCompleted) { return(new InspectionResult(InspectionDecision.NotifyError, new CommandNotExpectedException(TcpCommand.DeleteStreamCompleted.ToString(), package.Command.ToString()))); } var data = package.Data; var dto = data.Deserialize <ClientMessage.DeleteStreamCompleted>(); _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("Delete stream failed due to WrongExpectedVersion. Stream: {0}, Expected version: {1}, CorrID: {2}.", _stream, _expectedVersion, 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.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); }
private void CompleteFailedRequest(Guid correlationId, string eventStreamId, OperationErrorCode errorCode, string error) { Debug.Assert(errorCode != OperationErrorCode.Success); _completed = true; _bus.Publish(new ReplicationMessage.RequestCompleted(correlationId, false)); switch (_requestType) { case RequestType.CreateStream: { var responseMsg = new ClientMessage.CreateStreamCompleted(correlationId, eventStreamId, errorCode, error); _responseEnvelope.ReplyWith(responseMsg); break; } case RequestType.Write: { var responseMsg = new ClientMessage.WriteEventsCompleted( correlationId, eventStreamId, errorCode, error); _responseEnvelope.ReplyWith(responseMsg); break; } case RequestType.DeleteStream: { var responseMsg = new ClientMessage.DeleteStreamCompleted( correlationId, eventStreamId, errorCode, error); _responseEnvelope.ReplyWith(responseMsg); break; } case RequestType.TransactionCommit: { var responseMsg = new ClientMessage.TransactionCommitCompleted( correlationId, _preparePos, errorCode, error); _responseEnvelope.ReplyWith(responseMsg); break; } default: throw new ArgumentOutOfRangeException(); } }
private void StreamDeleted(ClientMessage.DeleteStreamCompleted message, string eventStreamId) { if (message.Result == OperationResult.Success) { _logger.Info("projection stream '{0}' deleted", eventStreamId); return; } _logger.Info( "Projection stream '{0}' could not be deleted. Error: {1}", eventStreamId, Enum.GetName(typeof(OperationResult), message.Result)); if (message.Result == OperationResult.CommitTimeout || message.Result == OperationResult.ForwardTimeout) { DeleteCheckpointStream(); } else { throw new NotSupportedException("Unsupported error code received"); } }
private static TcpPackage WrapDeleteStreamCompleted(ClientMessage.DeleteStreamCompleted msg) { var dto = new ClientMessageDto.DeleteStreamCompleted(msg.CorrelationId, msg.EventStreamId, msg.ErrorCode, msg.Error); return(new TcpPackage(TcpCommand.DeleteStreamCompleted, msg.CorrelationId, dto.Serialize())); }
public void Handle(ClientMessage.DeleteStreamCompleted message) { _streamDispatcher.Handle(message); }
public void Handle(ClientMessage.DeleteStreamCompleted message) { _forwardingProxy.TryForwardReply(message.CorrelationId, message, (clientCorrId, m) => m.WithCorrelationId(clientCorrId)); }