/// <inheritdoc/>
public override void FilterClose(INextFilter nextFilter, IoSession session)
{
SslHandler handler = session.GetAttribute <SslHandler>(SSL_HANDLER);
if (handler == null)
{
// The connection might already have closed, or
// SSL might have not started yet.
base.FilterClose(nextFilter, session);
return;
}
IWriteFuture future = null;
try
{
future = InitiateClosure(handler, nextFilter, session);
future.Complete += (s, e) => base.FilterClose(nextFilter, session);
}
finally
{
if (future == null)
{
base.FilterClose(nextFilter, session);
}
}
}
public override IWriteFuture Flush()
{
IQueue <Object> bufferQueue = MessageQueue;
IWriteFuture future = null;
while (!bufferQueue.IsEmpty)
{
Object encodedMessage = bufferQueue.Dequeue();
if (encodedMessage == null)
{
break;
}
// Flush only when the buffer has remaining.
IoBuffer buf = encodedMessage as IoBuffer;
if (buf == null || buf.HasRemaining)
{
future = new DefaultWriteFuture(_session);
_nextFilter.FilterWrite(_session, new EncodedWriteRequest(encodedMessage, future, _destination));
}
}
if (future == null)
{
// Creates an empty writeRequest containing the destination
IWriteRequest writeRequest = new DefaultWriteRequest(DefaultWriteRequest.EmptyMessage, null, _destination);
future = DefaultWriteFuture.NewNotWrittenFuture(_session, new NothingWrittenException(writeRequest));
}
return(future);
}
private IWriteFuture InitiateClosure(SslHandler handler, INextFilter nextFilter, IoSession session)
{
IWriteFuture future = DefaultWriteFuture.NewWrittenFuture(session);
handler.Destroy();
return(future);
}
public DefaultWriteRequest(Object message, IWriteFuture future, EndPoint destination)
{
if (message == null)
throw new ArgumentNullException("message");
_message = message;
_future = future ?? UnusedFuture.Instance;
_destination = destination;
}
public DefaultWriteRequest(Object message, IWriteFuture future, EndPoint destination)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
_message = message;
_future = future ?? UnusedFuture.Instance;
_destination = destination;
}
/// <inheritdoc/>
public override void Flush()
{
if (_lastWriteFuture == null)
{
return;
}
_lastWriteFuture.Await();
if (!_lastWriteFuture.Written)
{
throw new IOException("The bytes could not be written to the session");
}
_lastWriteFuture = null;
}
/// <inheritdoc/>
public override void FilterWrite(INextFilter nextFilter, IoSession session, IWriteRequest writeRequest)
{
IoEvent ioe = new IoEvent(IoEventType.Write, session, writeRequest);
if (_queueHandler.Accept(this, ioe))
{
nextFilter.FilterWrite(session, writeRequest);
IWriteFuture writeFuture = writeRequest.Future;
if (writeFuture == null)
{
return;
}
// We can track the write request only when it has a future.
_queueHandler.Offered(this, ioe);
writeFuture.Complete += (s, e) => _queueHandler.Polled(this, ioe);
}
}
/// <summary>
/// Destroy the session.
/// </summary>
protected void Destroy()
{
if (_writeRequestQueue != null)
{
while (!_writeRequestQueue.IsEmpty(this))
{
IWriteRequest writeRequest = _writeRequestQueue.Poll(this);
if (writeRequest != null)
{
IWriteFuture writeFuture = writeRequest.Future;
// The WriteRequest may not always have a future:
// the CLOSE_REQUEST and MESSAGE_SENT_REQUEST don't.
if (writeFuture != null)
{
writeFuture.Written = true;
}
}
}
}
}
public void TestAcceptorFilterChain()
{
Int32 port = 1024;
IoFilter mockFilter = new MockFilter();
IoHandler mockHandler = new MockHandler();
acceptor.FilterChain.AddLast("mock", mockFilter);
acceptor.Handler = mockHandler;
acceptor.Bind(new IPEndPoint(IPAddress.Loopback, port));
try
{
IConnectFuture future = connector.Connect(new IPEndPoint(IPAddress.Loopback, port));
future.Await();
IWriteFuture writeFuture = future.Session.Write(IoBuffer.Allocate(16).PutInt32(0).Flip());
writeFuture.Await();
Assert.IsTrue(writeFuture.Written);
future.Session.Close(true);
for (int i = 0; i < 30; i++)
{
if (result.Length == 2)
{
break;
}
Thread.Sleep(100);
}
Assert.AreEqual("FH", result);
}
finally
{
acceptor.Unbind();
}
}
/// <summary>
/// Writes the given buffer.
/// </summary>
public void Write(IoBuffer buf)
{
if (CanRead)
{
if (_closed)
{
return;
}
lock (_syncRoot)
{
if (_buf.HasRemaining)
{
_buf.Compact().Put(buf).Flip();
}
else
{
_buf.Clear().Put(buf).Flip();
Monitor.PulseAll(_syncRoot);
}
}
}
else if (CanWrite)
{
if (!_session.Connected)
{
throw new IOException("The session has been closed.");
}
_lastWriteFuture = _session.Write(buf);
}
else
{
throw new NotSupportedException();
}
}
public EncodedWriteRequest(Object encodedMessage, IWriteFuture future, System.Net.EndPoint destination)
: base(encodedMessage, future, destination)
{
}
public EncodedWriteRequest(Object encodedMessage, IWriteFuture future, System.Net.EndPoint destination)
: base(encodedMessage, future, destination)
{ }
/// <summary>
/// Writes the given buffer.
/// </summary>
public void Write(IoBuffer buf)
{
if (CanRead)
{
if (_closed)
return;
lock (_syncRoot)
{
if (_buf.HasRemaining)
{
_buf.Compact().Put(buf).Flip();
}
else
{
_buf.Clear().Put(buf).Flip();
Monitor.PulseAll(_syncRoot);
}
}
}
else if (CanWrite)
{
if (!_session.Connected)
throw new IOException("The session has been closed.");
_lastWriteFuture = _session.Write(buf);
}
else
throw new NotSupportedException();
}
public ProtocolCodecSession()
{
_notWrittenFuture = DefaultWriteFuture.NewNotWrittenFuture(this, new NotImplementedException());
_encoderOutput = new DummyProtocolEncoderOutput(_notWrittenFuture);
_decoderOutput = new DummyProtocolDecoderOutput();
}
/// <inheritdoc/>
public override void Flush()
{
if (_lastWriteFuture == null)
return;
_lastWriteFuture.Await();
if (!_lastWriteFuture.Written)
throw new IOException("The bytes could not be written to the session");
_lastWriteFuture = null;
}
public DummyProtocolEncoderOutput(IWriteFuture future)
{
_future = future;
}
public DummyProtocolEncoderOutput(IWriteFuture future)
{
_future = future;
}
public DefaultWriteRequest(Object message, IWriteFuture future)
: this(message, future, null)
{
}
public DefaultWriteRequest(Object message, IWriteFuture future)
: this(message, future, null)
{ }
public ProtocolCodecSession()
{
_notWrittenFuture = DefaultWriteFuture.NewNotWrittenFuture(this, new NotImplementedException());
_encoderOutput = new DummyProtocolEncoderOutput(_notWrittenFuture);
_decoderOutput = new DummyProtocolDecoderOutput();
}
public void TestCloseRequest()
{
int port = 1024;
ExpiringSessionRecycler recycler = new ExpiringSessionRecycler(10, 1);
MockHandler acceptorHandler = new MockHandler();
MockHandler connectorHandler = new MockHandler();
acceptor.SessionConfig.SetIdleTime(IdleStatus.ReaderIdle, 1);
acceptor.Handler = acceptorHandler;
acceptor.SessionRecycler = recycler;
acceptor.Bind(new IPEndPoint(IPAddress.Loopback, port));
try
{
connector.Handler = connectorHandler;
IConnectFuture future = connector.Connect(new IPEndPoint(IPAddress.Loopback, port));
future.Await();
// Write whatever to trigger the acceptor.
future.Session.Write(IoBuffer.Allocate(1)).Await();
// Make sure the connection is closed before recycler closes it.
while (acceptorHandler.session == null)
{
Thread.Yield();
}
acceptorHandler.session.Close(true);
Assert.IsTrue(acceptorHandler.session.CloseFuture.Await(3000));
IoSession oldSession = acceptorHandler.session;
// Wait until all events are processed and clear the state.
DateTime startTime = DateTime.Now;
while (acceptorHandler.result.ToString().Length < 8)
{
Thread.Yield();
if ((DateTime.Now - startTime).TotalMilliseconds > 5000)
{
throw new Exception();
}
}
acceptorHandler.result.Clear();
acceptorHandler.session = null;
// Write whatever to trigger the acceptor again.
IWriteFuture wf = future.Session.Write(IoBuffer.Allocate(1)).Await();
Assert.IsTrue(wf.Written);
// Make sure the connection is closed before recycler closes it.
while (acceptorHandler.session == null)
{
Thread.Yield();
}
acceptorHandler.session.Close(true);
Assert.IsTrue(acceptorHandler.session.CloseFuture.Await(3000));
future.Session.Close(true).Await();
Assert.AreNotSame(oldSession, acceptorHandler.session);
}
finally
{
acceptor.Unbind();
}
}
