when_send_queue_size_is_smaller_than_threshold_should_not_close_connection()
        {
            var mre = new ManualResetEventSlim();

            var messageSize = _connectionPendingSendBytesThreshold;
            var evnt        = new EventRecord(0, 0, Guid.NewGuid(), Guid.NewGuid(), 0, 0, "testStream", 0, DateTime.Now,
                                              PrepareFlags.None, "eventType", new byte[messageSize], new byte[0]);
            var record  = ResolvedEvent.ForUnresolvedEvent(evnt, null);
            var message = new ClientMessage.ReadEventCompleted(Guid.NewGuid(), "testStream", ReadEventResult.Success,
                                                               record, StreamMetadata.Empty, false, "");

            var dummyConnection = new DummyTcpConnection();

            dummyConnection.SendQueueSize = ESConsts.MaxConnectionQueueSize - 1;

            var tcpConnectionManager = new TcpConnectionManager(
                Guid.NewGuid().ToString(), TcpServiceType.External, new ClientTcpDispatcher(2000),
                InMemoryBus.CreateTest(), dummyConnection, InMemoryBus.CreateTest(),
                new InternalAuthenticationProvider(InMemoryBus.CreateTest(),
                                                   new Core.Helpers.IODispatcher(InMemoryBus.CreateTest(), new NoopEnvelope()), null, 1, false),
                new AuthorizationGateway(new TestAuthorizationProvider()),
                TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { mre.Set(); },
                ESConsts.UnrestrictedPendingSendBytes, ESConsts.MaxConnectionQueueSize);

            tcpConnectionManager.SendMessage(message);

            var data            = dummyConnection.ReceivedData.Last();
            var receivedPackage = TcpPackage.FromArraySegment(data);

            Assert.AreEqual(receivedPackage.Command, TcpCommand.ReadEventCompleted,
                            "Expected ReadEventCompleted but got {0}", receivedPackage.Command);
        }
        when_send_queue_size_is_larger_than_threshold_should_close_connection()
        {
            var mre = new ManualResetEventSlim();

            var messageSize = _connectionPendingSendBytesThreshold;
            var evnt        = new EventRecord(0, 0, Guid.NewGuid(), Guid.NewGuid(), 0, 0, "testStream", 0, DateTime.Now,
                                              PrepareFlags.None, "eventType", new byte[messageSize], new byte[0]);
            var record  = ResolvedEvent.ForUnresolvedEvent(evnt, null);
            var message = new ClientMessage.ReadEventCompleted(Guid.NewGuid(), "testStream", ReadEventResult.Success,
                                                               record, StreamMetadata.Empty, false, "");

            var dummyConnection = new DummyTcpConnection();

            dummyConnection.SendQueueSize = ESConsts.MaxConnectionQueueSize + 1;

            var tcpConnectionManager = new TcpConnectionManager(
                Guid.NewGuid().ToString(), TcpServiceType.External, new ClientTcpDispatcher(2000),
                InMemoryBus.CreateTest(), dummyConnection, InMemoryBus.CreateTest(),
                new InternalAuthenticationProvider(InMemoryBus.CreateTest(),
                                                   new Core.Helpers.IODispatcher(InMemoryBus.CreateTest(), new NoopEnvelope()), null, 1, false),
                new AuthorizationGateway(new TestAuthorizationProvider()),
                TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { mre.Set(); },
                ESConsts.UnrestrictedPendingSendBytes, ESConsts.MaxConnectionQueueSize);

            tcpConnectionManager.SendMessage(message);

            if (!mre.Wait(2000))
            {
                Assert.Fail("Timed out waiting for connection to close");
            }
        }
示例#3
0
        public static string SmartFormat(ClientMessage.ReadEventCompleted completed, ICodec targetCodec)
        {
            var dto = new HttpClientMessageDto.ReadEventCompletedText(completed);

            if (completed.Record.Flags.HasFlag(PrepareFlags.IsJson))
            {
                var deserializedData     = Codec.Json.From <object>((string)dto.Data);
                var deserializedMetadata = Codec.Json.From <object>((string)dto.Metadata);

                if (deserializedData != null)
                {
                    dto.Data = deserializedData;
                }
                if (deserializedMetadata != null)
                {
                    dto.Metadata = deserializedMetadata;
                }
            }

            switch (targetCodec.ContentType)
            {
            case ContentType.Xml:
            case ContentType.ApplicationXml:
            case ContentType.Atom:
            {
                var serializeObject    = JsonConvert.SerializeObject(dto);
                var deserializeXmlNode = JsonConvert.DeserializeXmlNode(serializeObject, "read-event-result");
                return(deserializeXmlNode.InnerXml);
            }

            default:
                return(targetCodec.To(dto));
            }
        }
示例#4
0
        when_limit_pending_and_sending_message_larger_than_pending_bytes_threshold_but_no_bytes_pending_should_not_close_connection()
        {
            var messageSize = _connectionPendingSendBytesThreshold + 1000;
            var evnt        = new EventRecord(0, 0, Guid.NewGuid(), Guid.NewGuid(), 0, 0, "testStream", 0, DateTime.Now,
                                              PrepareFlags.None, "eventType", new byte[messageSize], new byte[0]);
            var record  = ResolvedEvent.ForUnresolvedEvent(evnt, null);
            var message = new ClientMessage.ReadEventCompleted(Guid.NewGuid(), "testStream", ReadEventResult.Success,
                                                               record, StreamMetadata.Empty, false, "");

            var dummyConnection = new DummyTcpConnection();

            dummyConnection.PendingSendBytes = 0;

            var tcpConnectionManager = new TcpConnectionManager(
                Guid.NewGuid().ToString(), TcpServiceType.External, new ClientTcpDispatcher(),
                InMemoryBus.CreateTest(), dummyConnection, InMemoryBus.CreateTest(),
                new InternalAuthenticationProvider(
                    new Core.Helpers.IODispatcher(InMemoryBus.CreateTest(), new NoopEnvelope()), null, 1, false),
                TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { },
                _connectionPendingSendBytesThreshold, _connectionQueueSizeThreshold);

            tcpConnectionManager.SendMessage(message);

            var data            = dummyConnection.ReceivedData.Last();
            var receivedPackage = TcpPackage.FromArraySegment(data);

            Assert.AreEqual(receivedPackage.Command, TcpCommand.ReadEventCompleted,
                            "Expected ReadEventCompleted but got {0}", receivedPackage.Command);
        }
示例#5
0
        private static TcpPackage WrapReadEventCompleted(ClientMessage.ReadEventCompleted msg)
        {
            var dto = new TcpClientMessageDto.ReadEventCompleted(
                (TcpClientMessageDto.ReadEventCompleted.ReadEventResult)msg.Result,
                new TcpClientMessageDto.ResolvedIndexedEvent(msg.Record.Event, msg.Record.Link), msg.Error);

            return(new TcpPackage(TcpCommand.ReadEventCompleted, msg.CorrelationId, dto.Serialize()));
        }
示例#6
0
 public static string GetXmlReadResult(ClientMessage.ReadEventCompleted completed, bool dataJson = true, bool metadataJson = true)
 {
     return(string.Format(XmlReadFormat,
                          completed.Record.EventStreamId,
                          completed.Record.EventNumber,
                          completed.Record.EventType,
                          dataJson ? XmlData : AsString(completed.Record.Data),
                          metadataJson ? XmlMetadata : AsString(completed.Record.Metadata)));
 }
示例#7
0
 public static string GetJsonReadResult(ClientMessage.ReadEventCompleted completed, bool dataJson = true, bool metadataJson = true)
 {
     return(string.Format(JsonReadFormat,
                          WrapIntoQuotes(completed.Record.EventStreamId),
                          completed.Record.EventNumber,
                          WrapIntoQuotes(completed.Record.EventType),
                          dataJson ? JsonData : WrapIntoQuotes(AsString(completed.Record.Data)),
                          metadataJson ? JsonMetadata : WrapIntoQuotes(AsString(completed.Record.Metadata))));
 }
        public void Handle(ClientMessage.ReadEventCompleted message)
        {
            IEnvelope envelope;

            if (_correlations.TryGetValue(message.CorrelationId, out envelope))
            {
                envelope.ReplyWith(message);
                _correlations.Remove(message.CorrelationId);
            }
        }
        private static TcpPackage WrapReadEventsCompleted(ClientMessage.ReadEventCompleted msg)
        {
            var dto = new ClientMessageDto.ReadEventCompleted(msg.CorrelationId,
                                                              msg.EventStreamId,
                                                              msg.EventNumber,
                                                              msg.Result,
                                                              msg.Record == null ? null : msg.Record.EventType,
                                                              msg.Record == null ? null : msg.Record.Data,
                                                              msg.Record == null ? null : msg.Record.Metadata);

            return(new TcpPackage(TcpCommand.ReadEventCompleted, msg.CorrelationId, dto.Serialize()));
        }
示例#10
0
        public static string ConvertOnRead(ClientMessage.ReadEventCompleted completed, ICodec responseCodec)
        {
            var dto = new ClientMessageDto.ReadEventCompletedText(completed);

            if (completed.Record.Flags.HasFlag(PrepareFlags.IsJson))
            {
                dto.Data     = Codec.Json.From <object>((string)dto.Data);
                dto.Metadata = Codec.Json.From <object>((string)dto.Metadata);
            }

            var type = responseCodec.GetType();

            type = type == typeof(CustomCodec) ? ((CustomCodec)responseCodec).BaseCodec.GetType() : type;
            return(type == typeof(XmlCodec) ? Codec.Json.ToXmlUsingJson(dto) : responseCodec.To(dto));
        }
示例#11
0
        public static ClientMessage.ReadEventCompleted ReadEvent(MiniClusterNode node, string streamId, long eventNumber)
        {
            ClientMessage.ReadEventCompleted readResult = null;
            var resetEvent = new ManualResetEventSlim();
            var read       = new ClientMessage.ReadEvent(Guid.NewGuid(), Guid.NewGuid(), new CallbackEnvelope(msg =>
            {
                readResult = (ClientMessage.ReadEventCompleted)msg;
                resetEvent.Set();
            }), streamId, eventNumber,
                                                         false, false, SystemAccount.Principal);

            node.Node.MainQueue.Publish(read);

            if (!resetEvent.Wait(_timeout))
            {
                Assert.Fail("Timed out waiting for the event to be read");
                return(null);
            }
            return(readResult);
        }
示例#12
0
        // Used when we need to resolve a link event to see if it points to an event that no longer exists. If that
        // event no longer exists, we skip it and resume the recovery process.
        private void OnEmittedLinkEventResolved(bool anyFound, EmittedEvent eventToWrite, Tuple <CheckpointTag, string, long> topAlreadyCommitted, ClientMessage.ReadEventCompleted resp)
        {
            if (resp.Result != ReadEventResult.StreamDeleted && resp.Result != ReadEventResult.NotFound && resp.Result != ReadEventResult.NoStream && resp.Result != ReadEventResult.Success)
            {
                throw CreateSequenceException(topAlreadyCommitted, eventToWrite);
            }

            if (resp.Result == ReadEventResult.Success)
            {
                anyFound = true;
                NotifyEventCommitted(eventToWrite, topAlreadyCommitted.Item3);
            }
            else
            {
                Log.Verbose($"Emitted event ignored after resolution because it links to an event that no longer exists: eventId: {eventToWrite.EventId}, eventType: {eventToWrite.EventId}, checkpoint: {eventToWrite.CorrelationId}, causedBy: {eventToWrite.CausedBy}");
            }
            _pendingWrites.Dequeue();
            _awaitingLinkToResolution = false;
            SubmitWriteEventsInRecoveryLoop(anyFound);
        }
示例#13
0
        // Used when we need to resolve a link event to see if it points to an event that no longer exists. If that
        // event no longer exists, we skip it and resume the recovery process.
        private void OnEmittedLinkEventResolved(bool anyFound, EmittedEvent eventToWrite, ClientMessage.ReadEventCompleted resp)
        {
            var topAlreadyCommitted = _alreadyCommittedEvents.Pop();

            if (resp.Result != ReadEventResult.StreamDeleted && resp.Result != ReadEventResult.NotFound)
            {
                throw CreateSequenceException(topAlreadyCommitted, eventToWrite);
            }

            Log.Verbose($"Emitted event ignored after resolution because it links to an event that no longer exists: eventId: {eventToWrite.EventId}, eventType: {eventToWrite.EventId}, checkpoint: {eventToWrite.CorrelationId}, causedBy: {eventToWrite.CausedBy}");
            _pendingWrites.Dequeue();
            SubmitWriteEventsInRecoveryLoop(anyFound);
        }