/// <summary> /// Kills the cursor. /// </summary> private void KillCursor(long cursorId) { var killCursorsMessage = new KillCursorsMessage(cursorId); try { _connection.SendMessage(killCursorsMessage, _databaseName); Id = 0; } catch (IOException exception) { throw new MongoConnectionException("Could not read data, communication failure", _connection, exception); } }
// static constructor static KillCursorsMessageJsonEncoderTests() { __testMessage = new KillCursorsMessage(__requestId, __cursorIds); __testMessageJson = "{ " + "\"opcode\" : \"killCursors\", " + "\"requestId\" : 1, " + "\"cursorIds\" : [NumberLong(2)]" + " }"; }
public void Dispose() { if (this.Id == 0) { return; //All server side resources disposed of. } KillCursorsMessage kcm = new KillCursorsMessage(this.Id); try{ this.id = 0; connection.SendMessage(kcm); }catch (IOException ioe) { throw new MongoCommException("Could not read data, communication failure", this.connection, ioe); } }
/// <summary> /// Writes the message. /// </summary> /// <param name="message">The message.</param> public void WriteMessage(KillCursorsMessage message) { Ensure.IsNotNull(message, "message"); var messageDocument = new BsonDocument { { "opcode", "killCursors" }, { "requestId", message.RequestId }, { "cursorIds", new BsonArray(message.CursorIds.Select(id => new BsonInt64(id))) } }; var jsonWriter = CreateJsonWriter(); var messageContext = BsonSerializationContext.CreateRoot(jsonWriter); BsonDocumentSerializer.Instance.Serialize(messageContext, messageDocument); }
/// <summary> /// Writes the message. /// </summary> /// <param name="message">The message.</param> public void WriteMessage(KillCursorsMessage message) { Ensure.IsNotNull(message, nameof(message)); var messageDocument = new BsonDocument { { "opcode", "killCursors" }, { "requestId", message.RequestId }, { "cursorIds", new BsonArray(message.CursorIds.Select(id => new BsonInt64(id))) } }; var jsonWriter = CreateJsonWriter(); var messageContext = BsonSerializationContext.CreateRoot(jsonWriter); BsonDocumentSerializer.Instance.Serialize(messageContext, messageDocument); }
// static constructor static KillCursorsMessageBinaryEncoderTests() { __testMessage = new KillCursorsMessage(__requestId, __cursorIds); __testMessageBytes = new byte[] { 0, 0, 0, 0, // messageLength 1, 0, 0, 0, // requestId 0, 0, 0, 0, // responseTo 215, 7, 0, 0, // opcode = 2007 0, 0, 0, 0, // reserved 1, 0, 0, 0, // numberOfCursorIds 2, 0, 0, 0, 0, 0, 0, 0 // cursorIds[0] }; __testMessageBytes[0] = (byte)__testMessageBytes.Length; }
public async Task SendMessageAsync_should_throw_MongoConnectionClosedException_for_waiting_tasks() { using (var stream = Substitute.For <Stream>()) { _streamFactory.CreateStreamAsync(null, CancellationToken.None) .ReturnsForAnyArgs(Task.FromResult <Stream>(stream)); var readTcs = new TaskCompletionSource <int>(); stream.ReadAsync(null, 0, 0, CancellationToken.None) .ReturnsForAnyArgs(readTcs.Task); var writeTcs = new TaskCompletionSource <int>(); stream.WriteAsync(null, 0, 0, CancellationToken.None) .ReturnsForAnyArgs(writeTcs.Task); await _subject.OpenAsync(CancellationToken.None); _capturedEvents.Clear(); var message1 = new KillCursorsMessage(1, new[] { 1L }); var task1 = _subject.SendMessageAsync(message1, _messageEncoderSettings, CancellationToken.None); var message2 = new KillCursorsMessage(2, new[] { 2L }); var task2 = _subject.SendMessageAsync(message2, _messageEncoderSettings, CancellationToken.None); writeTcs.SetException(new SocketException()); Func <Task> act1 = () => task1; act1.ShouldThrow <MongoConnectionException>() .WithInnerException <SocketException>() .And.ConnectionId.Should().Be(_subject.ConnectionId); Func <Task> act2 = () => task2; act2.ShouldThrow <MongoConnectionClosedException>(); _capturedEvents.Next().Should().BeOfType <ConnectionSendingMessagesEvent>(); _capturedEvents.Next().Should().BeOfType <CommandStartedEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionSendingMessagesEvent>(); _capturedEvents.Next().Should().BeOfType <CommandStartedEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionFailedEvent>(); _capturedEvents.Next().Should().BeOfType <CommandFailedEvent>(); _capturedEvents.Next().Should().BeOfType <CommandFailedEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionSendingMessagesFailedEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionSendingMessagesFailedEvent>(); _capturedEvents.Any().Should().BeFalse(); } }
/// <summary> /// Writes the message. /// </summary> /// <param name="message">The message.</param> public void WriteMessage(KillCursorsMessage message) { Ensure.IsNotNull(message, "message"); var binaryWriter = CreateBinaryWriter(); var stream = binaryWriter.BsonStream; var startPosition = stream.Position; stream.WriteInt32(0); // messageSize stream.WriteInt32(message.RequestId); stream.WriteInt32(0); // responseTo stream.WriteInt32((int)Opcode.KillCursors); stream.WriteInt32(0); // reserved stream.WriteInt32(message.CursorIds.Count); foreach (var cursorId in message.CursorIds) { stream.WriteInt64(cursorId); } stream.BackpatchSize(startPosition); }
/// <summary> /// Writes the message. /// </summary> /// <param name="message">The message.</param> public void WriteMessage(KillCursorsMessage message) { Ensure.IsNotNull(message, nameof(message)); var binaryWriter = CreateBinaryWriter(); var stream = binaryWriter.BsonStream; var startPosition = stream.Position; stream.WriteInt32(0); // messageSize stream.WriteInt32(message.RequestId); stream.WriteInt32(0); // responseTo stream.WriteInt32((int)Opcode.KillCursors); stream.WriteInt32(0); // reserved stream.WriteInt32(message.CursorIds.Count); foreach (var cursorId in message.CursorIds) { stream.WriteInt64(cursorId); } stream.BackpatchSize(startPosition); }
private void ProcessKillCursorsMessages(KillCursorsMessage originalMessage, ConnectionId connectionId, Stopwatch stopwatch) { const string commandName = "killCursors"; var operationId = EventContext.OperationId; if (_startedEvent != null) { var collectionNamespace = EventContext.KillCursorsCollectionNamespace ?? DatabaseNamespace.Admin.CommandCollection; var command = new BsonDocument { { commandName, collectionNamespace.CollectionName }, { "cursors", new BsonArray(originalMessage.CursorIds) } }; var @event = new CommandStartedEvent( commandName, command, collectionNamespace.DatabaseNamespace, operationId, originalMessage.RequestId, connectionId); _startedEvent(@event); } if (_shouldTrackState) { _state.TryAdd(originalMessage.RequestId, new CommandState { CommandName = commandName, OperationId = operationId, Stopwatch = stopwatch, ExpectedResponseType = ExpectedResponseType.None, NoResponseResponse = new BsonDocument { { "ok", 1 }, { "cursorsUnknown", new BsonArray(originalMessage.CursorIds) } } }); } }
public void SendMessageAsync_should_throw_MessageNotSentException_for_queued_messages() { using (var stream = Substitute.For <Stream>()) { _streamFactory.CreateStreamAsync(null, CancellationToken.None) .ReturnsForAnyArgs(Task.FromResult <Stream>(stream)); var readTcs = new TaskCompletionSource <int>(); stream.ReadAsync(null, 0, 0, CancellationToken.None) .ReturnsForAnyArgs(readTcs.Task); var writeTcs = new TaskCompletionSource <int>(); stream.WriteAsync(null, 0, 0, CancellationToken.None) .ReturnsForAnyArgs(writeTcs.Task); _subject.OpenAsync(CancellationToken.None).Wait(); var message1 = new KillCursorsMessage(1, new[] { 1L }); var task1 = _subject.SendMessageAsync(message1, _messageEncoderSettings, CancellationToken.None); var message2 = new KillCursorsMessage(2, new[] { 2L }); var task2 = _subject.SendMessageAsync(message2, _messageEncoderSettings, CancellationToken.None); writeTcs.SetException(new SocketException()); Action act1 = () => task1.GetAwaiter().GetResult(); act1.ShouldThrow <SocketException>(); Action act2 = () => task2.GetAwaiter().GetResult(); act2.ShouldThrow <MongoMessageNotSentException>(); _listener.ReceivedWithAnyArgs().ConnectionBeforeSendingMessages(default(ConnectionBeforeSendingMessagesEvent)); _listener.ReceivedWithAnyArgs().ConnectionErrorSendingMessages(default(ConnectionErrorSendingMessagesEvent)); _listener.ReceivedWithAnyArgs().ConnectionFailed(default(ConnectionFailedEvent)); } }
public void SendMessageshould_throw_MongoConnectionClosedException_for_waiting_tasks( [Values(false, true)] bool async1, [Values(false, true)] bool async2) { using (var stream = Substitute.For <Stream>()) { var message1 = new KillCursorsMessage(1, new[] { 1L }); var message2 = new KillCursorsMessage(2, new[] { 2L }); _streamFactory.CreateStream(null, CancellationToken.None) .ReturnsForAnyArgs(stream); var task1IsBlocked = false; var writeTcs = new TaskCompletionSource <int>(); stream .When(s => s.Write(Arg.Any <byte[]>(), Arg.Any <int>(), Arg.Any <int>())) .Do(_ => { task1IsBlocked = true; writeTcs.Task.GetAwaiter().GetResult(); }); stream.WriteAsync(null, 0, 0, CancellationToken.None) .ReturnsForAnyArgs(_ => { task1IsBlocked = true; return(writeTcs.Task); }); _subject.Open(CancellationToken.None); _capturedEvents.Clear(); Task task1; if (async1) { task1 = _subject.SendMessageAsync(message1, _messageEncoderSettings, CancellationToken.None); } else { task1 = Task.Run(() => { _subject.SendMessage(message1, _messageEncoderSettings, CancellationToken.None); }); } SpinWait.SpinUntil(() => task1IsBlocked); Task task2; if (async2) { task2 = _subject.SendMessageAsync(message2, _messageEncoderSettings, CancellationToken.None); } else { var task2IsRunning = false; task2 = Task.Run(() => { task2IsRunning = true; _subject.SendMessage(message2, _messageEncoderSettings, CancellationToken.None); }); SpinWait.SpinUntil(() => task2IsRunning, 100); } writeTcs.SetException(new SocketException()); Func <Task> act1 = () => task1; act1.ShouldThrow <MongoConnectionException>() .WithInnerException <SocketException>() .And.ConnectionId.Should().Be(_subject.ConnectionId); Func <Task> act2 = () => task2; act2.ShouldThrow <MongoConnectionClosedException>(); _capturedEvents.Next().Should().BeOfType <ConnectionSendingMessagesEvent>(); _capturedEvents.Next().Should().BeOfType <CommandStartedEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionSendingMessagesEvent>(); _capturedEvents.Next().Should().BeOfType <CommandStartedEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionFailedEvent>(); _capturedEvents.Next().Should().BeOfType <CommandFailedEvent>(); _capturedEvents.Next().Should().BeOfType <CommandFailedEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionSendingMessagesFailedEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionSendingMessagesFailedEvent>(); _capturedEvents.Any().Should().BeFalse(); } }
public void SendMessageshould_throw_MongoConnectionClosedException_for_waiting_tasks( [Values(false, true)] bool async1, [Values(false, true)] bool async2) { var mockStream = new Mock <Stream>(); using (mockStream.Object) { var message1 = new KillCursorsMessage(1, new[] { 1L }); var message2 = new KillCursorsMessage(2, new[] { 2L }); _mockStreamFactory.Setup(f => f.CreateStream(_endPoint, CancellationToken.None)) .Returns(mockStream.Object); var task1IsBlocked = false; var writeTcs = new TaskCompletionSource <int>(); mockStream.Setup(s => s.Write(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>())) .Callback(() => { task1IsBlocked = true; writeTcs.Task.GetAwaiter().GetResult(); }); mockStream.Setup(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>())) .Returns(() => { task1IsBlocked = true; return(writeTcs.Task); }); _subject.Open(CancellationToken.None); _capturedEvents.Clear(); Task task1; if (async1) { task1 = _subject.SendMessageAsync(message1, _messageEncoderSettings, CancellationToken.None); } else { task1 = Task.Run(() => { _subject.SendMessage(message1, _messageEncoderSettings, CancellationToken.None); }); } SpinWait.SpinUntil(() => task1IsBlocked, TimeSpan.FromSeconds(5)).Should().BeTrue(); task1IsBlocked.Should().BeTrue(); Task task2; if (async2) { task2 = _subject.SendMessageAsync(message2, _messageEncoderSettings, CancellationToken.None); } else { var task2IsRunning = 0; task2 = Task.Run(() => { Interlocked.Exchange(ref task2IsRunning, 1); _subject.SendMessage(message2, _messageEncoderSettings, CancellationToken.None); }); SpinWait.SpinUntil(() => Interlocked.CompareExchange(ref task2IsRunning, 0, 0) == 1, TimeSpan.FromSeconds(5)).Should().BeTrue(); } writeTcs.SetException(new SocketException()); Func <Task> act1 = () => task1; act1.ShouldThrow <MongoConnectionException>() .WithInnerException <SocketException>() .And.ConnectionId.Should().Be(_subject.ConnectionId); Func <Task> act2 = () => task2; act2.ShouldThrow <MongoConnectionClosedException>(); SpinWait.SpinUntil(() => _capturedEvents.Count >= 9, TimeSpan.FromSeconds(5)); _capturedEvents.Count.Should().Be(9); var allEvents = new List <object>(); while (_capturedEvents.Any()) { allEvents.Add(_capturedEvents.Next()); } var request1Events = GetEventsForRequest(allEvents, message1.RequestId); request1Events.Should().HaveCount(4); request1Events[0].Should().BeOfType <ConnectionSendingMessagesEvent>(); request1Events[1].Should().BeOfType <CommandStartedEvent>(); request1Events[2].Should().BeOfType <CommandFailedEvent>(); request1Events[3].Should().BeOfType <ConnectionSendingMessagesFailedEvent>(); var request2Events = GetEventsForRequest(allEvents, message2.RequestId); request2Events.Should().HaveCount(4); request2Events[0].Should().BeOfType <ConnectionSendingMessagesEvent>(); request2Events[1].Should().BeOfType <CommandStartedEvent>(); request2Events[2].Should().BeOfType <CommandFailedEvent>(); request2Events[3].Should().BeOfType <ConnectionSendingMessagesFailedEvent>(); var connectionFailedEvents = allEvents.OfType <ConnectionFailedEvent>().ToList(); connectionFailedEvents.Should().HaveCount(1); } }
public void SendMessageshould_throw_MongoConnectionClosedException_for_waiting_tasks( [Values(false, true)] bool async1, [Values(false, true)] bool async2) { var mockStream = new Mock <Stream>(); using (mockStream.Object) { var message1 = new KillCursorsMessage(1, new[] { 1L }); var message2 = new KillCursorsMessage(2, new[] { 2L }); _mockStreamFactory.Setup(f => f.CreateStream(_endPoint, CancellationToken.None)) .Returns(mockStream.Object); var task1IsBlocked = false; var writeTcs = new TaskCompletionSource <int>(); mockStream.Setup(s => s.Write(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>())) .Callback(() => { task1IsBlocked = true; writeTcs.Task.GetAwaiter().GetResult(); }); mockStream.Setup(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>())) .Returns(() => { task1IsBlocked = true; return(writeTcs.Task); }); _subject.Open(CancellationToken.None); _capturedEvents.Clear(); Task task1; if (async1) { task1 = _subject.SendMessageAsync(message1, _messageEncoderSettings, CancellationToken.None); } else { task1 = Task.Run(() => { _subject.SendMessage(message1, _messageEncoderSettings, CancellationToken.None); }); } SpinWait.SpinUntil(() => task1IsBlocked, 1000).Should().BeTrue(); task1IsBlocked.Should().BeTrue(); Task task2; if (async2) { task2 = _subject.SendMessageAsync(message2, _messageEncoderSettings, CancellationToken.None); } else { var task2IsRunning = 0; task2 = Task.Run(() => { Interlocked.Exchange(ref task2IsRunning, 1); _subject.SendMessage(message2, _messageEncoderSettings, CancellationToken.None); }); SpinWait.SpinUntil(() => Interlocked.CompareExchange(ref task2IsRunning, 0, 0) == 1, 1000).Should().BeTrue(); } writeTcs.SetException(new SocketException()); Func <Task> act1 = () => task1; act1.ShouldThrow <MongoConnectionException>() .WithInnerException <SocketException>() .And.ConnectionId.Should().Be(_subject.ConnectionId); Func <Task> act2 = () => task2; act2.ShouldThrow <MongoConnectionClosedException>(); _capturedEvents.Next().Should().BeOfType <ConnectionSendingMessagesEvent>(); _capturedEvents.Next().Should().BeOfType <CommandStartedEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionSendingMessagesEvent>(); _capturedEvents.Next().Should().BeOfType <CommandStartedEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionFailedEvent>(); _capturedEvents.Next().Should().BeOfType <CommandFailedEvent>(); var events7And8Types = new Type[] { _capturedEvents.Next().GetType(), _capturedEvents.Next().GetType() }; var expectedEventTypes = new Type[] { typeof(CommandFailedEvent), typeof(ConnectionSendingMessagesFailedEvent) }; events7And8Types.Should().BeEquivalentTo(expectedEventTypes); _capturedEvents.Next().Should().BeOfType <ConnectionSendingMessagesFailedEvent>(); _capturedEvents.Any().Should().BeFalse(); } }