/// <summary>
/// enqueue the receivied transport event.<para/>
/// add the transport event to the event queue, for user to expect specified event directly.<para/>
/// add the transport event to data sequence, for user to expect any event(include received packet).<para/>
/// it's thread-safe.
/// </summary>
/// <param name="eventQueue">
/// a SyncFilterQueue<TransportEvent> that specifies the queue to store event.
/// </param>
/// <param name="sequence">
/// a DataSequence object that stores the received data or event sequence.
/// </param>
/// <param name="transportEvent">
/// a TransportEvent object that specifies the received event.
/// </param>
public static void Enqueue(SyncFilterQueue <TransportEvent> eventQueue, DataSequence sequence, TransportEvent transportEvent)
{
lock (eventQueue)
{
sequence.Add(transportEvent, new byte[0], null);
eventQueue.Enqueue(transportEvent);
}
}
/// <summary>
/// dequeue the received event from queue.
/// </summary>
/// <param name="eventQueue">
/// a SyncFilterQueue<TransportEvent> that specifies the queue to store event.
/// </param>
/// <param name="sequence">
/// a DataSequence object that stores the received data or event sequence.
/// </param>
/// <param name="timeout">
/// a TimeSpan object that specifies the timeout to wait for event.
/// </param>
/// <param name="filter">
/// a Filter<TransportEvent> that specifies the filter to get event.
/// </param>
/// <returns>
/// return a TransportEvent object that stores the event.
/// </returns>
public static TransportEvent Dequeue(
SyncFilterQueue <TransportEvent> eventQueue, DataSequence sequence,
TimeSpan timeout, Filter <TransportEvent> filter)
{
TransportEvent transportEvent = eventQueue.Dequeue(timeout, filter);
// remove the event from sequence.
sequence.Remove(transportEvent);
return(transportEvent);
}
/// <summary>
/// expect packet from transport.<para/>
/// the transport must be a TcpServer or NetbiosServer.
/// </summary>
/// <param name="host">
/// an IGetAnyBytesVisitor interface that specifies the host of visitor.
/// </param>
/// <param name="sequence">
/// a DataSequence object that manages the sequence information of multiple clients.
/// </param>
/// <param name="timeout">
/// a TimeSpan object that indicates the timeout to expect event.
/// </param>
/// <param name="maxCount">
/// an int value that specifies the maximum count of bytes to get.
/// </param>
/// <param name="remoteEndPoint">
/// an object that specifies the remote endpoint expected packet.
/// </param>
/// <param name="localEndPoint">
/// an object that indicates the local endpoint received packet at.
/// </param>
/// <returns>
/// a StackPacket object that specifies the received packet.<para/>
/// if all buffer is closed in this while, and required to return if all buffer is closed, return null.<para/>
/// otherwise never return null, if no packets coming in timespan, throw exception.
/// </returns>
public static byte[] Visit(
IVisitorGetAnyBytes host, DataSequence sequence, TimeSpan timeout, int maxCount,
out object remoteEndPoint, out object localEndPoint)
{
if (maxCount < 0)
{
throw new ArgumentException("max count must not be negative", "maxCount");
}
sequence.Reset();
DateTime endTime = DateTime.Now + timeout;
TimeSpan currentTimeout = timeout;
while (true)
{
SequenceItem item = sequence.Next(currentTimeout);
// skip event
if (item.Source is TransportEvent)
{
currentTimeout = endTime - DateTime.Now;
continue;
}
byte[] data = host.GetBytes(maxCount, item.Source, out remoteEndPoint, out localEndPoint);
if (data == null)
{
throw new InvalidOperationException("invalid data received from client.");
}
sequence.Consume(item.Source, data.Length);
return(data);
}
}
/// <summary>
/// expect packet from transport.<para/>
/// the transport must be a TcpServer or NetbiosServer.
/// </summary>
/// <param name="host">
/// an IGetAnyBytesVisitor interface that specifies the host of visitor.
/// </param>
/// <param name="sequence">
/// a DataSequence object that manages the sequence information of multiple clients.
/// </param>
/// <param name="timeout">
/// a TimeSpan object that indicates the timeout to expect event.
/// </param>
/// <param name="maxCount">
/// an int value that specifies the maximum count of bytes to get.
/// </param>
/// <param name="remoteEndPoint">
/// an object that specifies the remote endpoint expected packet.
/// </param>
/// <param name="localEndPoint">
/// an object that indicates the local endpoint received packet at.
/// </param>
/// <returns>
/// a StackPacket object that specifies the received packet.<para/>
/// if all buffer is closed in this while, and required to return if all buffer is closed, return null.<para/>
/// otherwise never return null, if no packets coming in timespan, throw exception.
/// </returns>
public static byte[] Visit(
IVisitorGetAnyBytes host, DataSequence sequence, TimeSpan timeout, int maxCount,
out object remoteEndPoint, out object localEndPoint)
{
if (maxCount < 0)
{
throw new ArgumentException("max count must not be negative", "maxCount");
}
sequence.Reset();
DateTime endTime = DateTime.Now + timeout;
TimeSpan currentTimeout = timeout;
while (true)
{
SequenceItem item = sequence.Next(currentTimeout);
// skip event
if (item.Source is TransportEvent)
{
currentTimeout = endTime - DateTime.Now;
continue;
}
byte[] data = host.GetBytes(maxCount, item.Source, out remoteEndPoint, out localEndPoint);
if (data == null)
{
throw new InvalidOperationException("invalid data received from client.");
}
sequence.Consume(item.Source, data.Length);
return data;
}
}
/// <summary>
/// Release resources.
/// </summary>
/// <param name = "disposing">
/// If disposing equals true, Managed and unmanaged resources are disposed. if false, Only unmanaged resources
/// can be disposed.
/// </param>
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
// If disposing equals true, dispose all managed and unmanaged resources.
if (disposing)
{
// Free managed resources & other reference types:
if (this.listeners != null)
{
// stop listener if exists.
if (this.listeners.Count > 0)
{
this.Stop();
}
this.listeners = null;
}
if (this.connections != null)
{
// disconnect clients if exists.
if (this.connections.Count > 0)
{
this.Disconnect();
}
this.connections = null;
}
if (this.eventQueue != null)
{
// the SyncFilterQueue may throw exception, donot arise exception.
this.eventQueue.Dispose();
this.eventQueue = null;
}
if (this.packetCache != null)
{
this.packetCache.Dispose();
this.packetCache = null;
}
if (this.sequence != null)
{
this.sequence.Dispose();
this.sequence = null;
}
}
// Call the appropriate methods to clean up unmanaged resources.
// If disposing is false, only the following code is executed:
this.disposed = true;
}
}
/// <summary>
/// consturctor.
/// </summary>
/// <param name="transportConfig">
/// a TransportConfig object that contains the config.
/// </param>
/// <param name="decodePacketCallback">
/// a DecodePacketCallback delegate that is used to decode the packet from bytes.
/// </param>
/// <exception cref="ArgumentException">
/// thrown when transportConfig is not SocketTransportConfig
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown when transportConfig is null.
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown when decodePacketCallback is null.
/// </exception>
public TcpServerTransport(TransportConfig transportConfig, DecodePacketCallback decodePacketCallback)
{
if (transportConfig == null)
{
throw new ArgumentNullException("transportConfig");
}
if (decodePacketCallback == null)
{
throw new ArgumentNullException("decodePacketCallback");
}
this.UpdateConfig(transportConfig);
this.decoder = decodePacketCallback;
this.listeners = new Dictionary<IPEndPoint, TcpServerListener>();
this.connections = new Dictionary<IPEndPoint, TcpServerConnection>();
this.eventQueue = new SyncFilterQueue<TransportEvent>();
this.sequence = new DataSequence();
this.packetCache = new SyncFilterQueue<IPEndPointStackPacket>();
}
/// <summary>
/// Release resources.
/// </summary>
/// <param name = "disposing">
/// If disposing equals true, Managed and unmanaged resources are disposed. if false, Only unmanaged resources
/// can be disposed.
/// </param>
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
// If disposing equals true, dispose all managed and unmanaged resources.
if (disposing)
{
// Free managed resources & other reference types:
// because the client uses listener as transport,
// so must stop listener, then dispose client, at last dispose listener.
if (this.connections != null)
{
// stop to accept clients, if exists listener.
if (this.listeners.Count > 0)
{
this.Stop();
}
// disconnect and dispose all clients, if exists.
if (this.connections.Count > 0)
{
this.Disconnect();
}
this.connections = null;
}
// dispose listeners after diposed all clients.
if (this.listeners != null)
{
// dispose all listener if exists.
foreach (NetbiosServerListener listener in this.listeners.Values)
{
listener.Dispose();
}
this.listeners = null;
}
if (this.eventQueue != null)
{
// the SyncFilterQueue may throw exception, donot arise exception.
this.eventQueue.Dispose();
this.eventQueue = null;
}
if (this.packetCache != null)
{
this.packetCache.Dispose();
this.packetCache = null;
}
if (this.sequence != null)
{
this.sequence.Dispose();
this.sequence = null;
}
}
// Call the appropriate methods to clean up unmanaged resources.
// If disposing is false, only the following code is executed:
this.disposed = true;
}
}
/// <summary>
/// expect packet from transport.<para/>
/// the transport must be a TcpServer or NetbiosServer.
/// </summary>
/// <param name="host">
/// an IVisitorGetAnyPacket interface that specifies the host of visitor.
/// </param>
/// <param name="eventQueue">
/// a SyncFilterQueue<TransportEvent> that specifies the queue to store event.
/// </param>
/// <param name="sequence">
/// a DataSequence object that manages the sequence information of multiple clients.
/// </param>
/// <param name="timeout">
/// a TimeSpan object that indicates the timeout to expect event.
/// </param>
/// <param name="skipEvent">
/// a bool value that specifies whether skip the event.<para/>
/// if true, just wait for packet coming; otherwise, both data and event will return.
/// </param>
/// <returns>
/// a StackPacket object that specifies the received packet.<para/>
/// if all buffer is closed in this while, and required to return if all buffer is closed, return null.<para/>
/// otherwise never return null, if no packets coming in timespan, throw exception.
/// </returns>
public static TransportEvent Visit(
IVisitorGetAnyData host,
SyncFilterQueue<TransportEvent> eventQueue, DataSequence sequence, TimeSpan timeout, bool skipEvent)
{
// the end time for operation.
DateTime endTime = DateTime.Now + timeout;
TimeSpan currentTimeout = timeout;
while (true)
{
sequence.Reset();
// try to decode packet from all clients in sequence.
while (true)
{
SequenceItem item = sequence.Next(TimeSpan.MinValue);
// all item in the sequences returned
if (item == null)
{
break;
}
TransportEvent transportEvent = item.Source as TransportEvent;
// if event arrived and donot skip the event, return the event directly.
if (transportEvent != null)
{
if (skipEvent)
{
continue;
}
sequence.Remove(transportEvent);
Utility.Remove(eventQueue, transportEvent);
return transportEvent;
}
object remoteEndPoint;
object localEndPoint;
host.VisitorGetEndPoint(item.Source, out remoteEndPoint, out localEndPoint);
int consumedLength = 0;
StackPacket packet = null;
try
{
// set timeout to zero, must not wait for more data.
// if timeout, process next.
packet = host.VisitorDecodePackets(
item.Source, remoteEndPoint, localEndPoint, out consumedLength);
// remove the sequence information in data sequence.
sequence.Consume(item.Source, consumedLength);
if (packet != null)
{
TcpServerConnection connection = item.Source as TcpServerConnection;
if (connection != null)
{
return connection.VisitorCreateTransportEvent(EventType.ReceivedPacket, packet);
}
else
{
return new TransportEvent(EventType.ReceivedPacket, remoteEndPoint, localEndPoint, packet);
}
}
}
// skip timeout of any host.
catch (TimeoutException)
{
}
}
// waiting for next data coming.
sequence.Next(currentTimeout);
currentTimeout = endTime - DateTime.Now;
}
}
/// <summary>
/// expect packet from transport.<para/>
/// the transport must be a TcpServer or NetbiosServer.
/// </summary>
/// <param name="host">
/// an IVisitorGetAnyPacket interface that specifies the host of visitor.
/// </param>
/// <param name="eventQueue">
/// a SyncFilterQueue<TransportEvent> that specifies the queue to store event.
/// </param>
/// <param name="sequence">
/// a DataSequence object that manages the sequence information of multiple clients.
/// </param>
/// <param name="timeout">
/// a TimeSpan object that indicates the timeout to expect event.
/// </param>
/// <param name="skipEvent">
/// a bool value that specifies whether skip the event.<para/>
/// if true, just wait for packet coming; otherwise, both data and event will return.
/// </param>
/// <returns>
/// a StackPacket object that specifies the received packet.<para/>
/// if all buffer is closed in this while, and required to return if all buffer is closed, return null.<para/>
/// otherwise never return null, if no packets coming in timespan, throw exception.
/// </returns>
public static TransportEvent Visit(
IVisitorGetAnyData host,
SyncFilterQueue <TransportEvent> eventQueue, DataSequence sequence, TimeSpan timeout, bool skipEvent)
{
// the end time for operation.
DateTime endTime = DateTime.Now + timeout;
TimeSpan currentTimeout = timeout;
while (true)
{
sequence.Reset();
// try to decode packet from all clients in sequence.
while (true)
{
SequenceItem item = sequence.Next(TimeSpan.MinValue);
// all item in the sequences returned
if (item == null)
{
break;
}
TransportEvent transportEvent = item.Source as TransportEvent;
// if event arrived and donot skip the event, return the event directly.
if (transportEvent != null)
{
if (skipEvent)
{
continue;
}
sequence.Remove(transportEvent);
Utility.Remove(eventQueue, transportEvent);
return(transportEvent);
}
object remoteEndPoint;
object localEndPoint;
host.VisitorGetEndPoint(item.Source, out remoteEndPoint, out localEndPoint);
int consumedLength = 0;
StackPacket packet = null;
try
{
// set timeout to zero, must not wait for more data.
// if timeout, process next.
packet = host.VisitorDecodePackets(
item.Source, remoteEndPoint, localEndPoint, out consumedLength);
// remove the sequence information in data sequence.
sequence.Consume(item.Source, consumedLength);
if (packet != null)
{
TcpServerConnection connection = item.Source as TcpServerConnection;
if (connection != null)
{
return(connection.VisitorCreateTransportEvent(EventType.ReceivedPacket, packet));
}
else
{
return(new TransportEvent(EventType.ReceivedPacket, remoteEndPoint, localEndPoint, packet));
}
}
}
// skip timeout of any host.
catch (TimeoutException)
{
}
}
// waiting for next data coming.
sequence.Next(currentTimeout);
currentTimeout = endTime - DateTime.Now;
}
}
