public void ReadAndWriteMultipleFragmentsThreaded(int maxReadLength, int maxReserveLength)
{
this.reader = new TcpReader(this.readerTcpClient.Client, maxReadLength);
this.writer = new TcpWriter(this.writerTcpClient.Client, maxReserveLength);
this.writerTcpClient.Client.SendBufferSize = 1;
var xdrReader = new XdrReader(this.reader);
var xdrWriter = new XdrWriter(this.writer);
byte[] value = TestXdr.GenerateByteTestData(17);
var task = Task.Run(
() =>
{
NetworkReadResult readResult = this.reader.BeginReading();
Assert.That(readResult.SocketError, Is.EqualTo(SocketError.Success));
Assert.That(xdrReader.ReadOpaque(), Is.EqualTo(value));
Assert.That(xdrReader.ReadInt(), Is.EqualTo(42));
this.reader.EndReading();
});
this.writer.BeginWriting();
xdrWriter.WriteVariableLengthOpaque(value);
xdrWriter.Write(42);
this.writer.EndWriting(null);
task.Wait();
}
public void Go()
{
using (var tcpClient = new TcpClient())
{
tcpClient.NoDelay = true;
tcpClient.Connect(_host, _port);
var stream = tcpClient.GetStream();
_cancel = new CancellationTokenSource();
_pipe = new Pipe <dynamic>();
_writer = new TcpWriter(stream, _cancel.Token, _pipe);
_reader = new TcpReader(stream, _cancel.Token, _pipe);
_ai = new NibblesAi();
_aiHandler = new NibblesAiHandler(_ai, _pipe.ReceiveQueue, _pipe.SendQueue, _cancel.Token);
var tasks = new List <Task>();
tasks.Add(Task.Factory.StartNew(() => _aiHandler.Go(), _cancel.Token, TaskCreationOptions.LongRunning,
TaskScheduler.Default));
tasks.Add(Task.Factory.StartNew(() => _writer.Start(), _cancel.Token,
TaskCreationOptions.LongRunning, TaskScheduler.Default));
tasks.Add(Task.Factory.StartNew(() => _reader.Start(), _cancel.Token,
TaskCreationOptions.LongRunning, TaskScheduler.Default));
Console.WriteLine("Hit enter to cancel");
Console.ReadLine();
Console.WriteLine("Cancelling...");
_cancel.Cancel();
try
{
Task.WaitAll(tasks.ToArray());
}
catch (AggregateException e)
{
Console.WriteLine("\nAggregateException thrown with the following inner exceptions:");
// Display information about each exception.
foreach (var v in e.InnerExceptions)
{
if (v is TaskCanceledException)
{
Console.WriteLine(" TaskCanceledException: Task {0}", ((TaskCanceledException)v).Task.Id);
}
else
{
Console.WriteLine(" Exception: {0}", v.GetType().Name);
}
}
Console.WriteLine();
}
finally
{
_cancel.Dispose();
}
}
}
private void EndReadBody(IAsyncResult ar)
{
Exception error = null;
try
{
int read;
lock (_sync)
{
if (_disposed)
{
throw new ObjectDisposedException(typeof(TcpClient).FullName);
}
read = _stream.EndRead(ar);
}
Log.Debug("read {0} bytes of body", read);
if (read <= 0)
{
throw new EndOfStreamException();
}
_leftToRead -= read;
_readPos += read;
if (_leftToRead <= 0)
{
Log.Trace(Toolkit.DumpToLog, "received byte dump: {0}", _readBuf);
_tcpReader.AppendBlock(_readBuf);
if (!_lastReadBlock)
{
Log.Debug("body readed", read);
BeginReadRecordMark();
return;
}
}
else
{
SafeBeginRead(EndReadBody);
return;
}
}
catch (Exception ex)
{
error = ex;
}
if (error != null)
{
_tcpReader = null;
}
_readCompleted(error, _tcpReader);
_tcpReader = null;
_readCompleted = null;
_readBuf = null;
}
public void SetUp()
{
this.listener = new TcpListener(IPAddress.Loopback, 0);
this.listener.Start();
int port = ((IPEndPoint)this.listener.Server.LocalEndPoint).Port;
this.readerTcpClient = new TcpClient();
Task task = Task.Run(() => this.writerTcpClient = this.listener.AcceptTcpClient());
this.readerTcpClient.Connect(IPAddress.Loopback, port);
task.GetAwaiter().GetResult();
this.reader = new TcpReader(this.readerTcpClient.Client);
this.writer = new TcpWriter(this.writerTcpClient.Client);
this.listener.Stop();
}
public void CanReadAppPattern()
{
using var connector = new TcpConnector(out ushort port);
using var connectingClient = new TcpReader(IPAddress.Any, port);
while (connector.ConnectedClientsCount <= 0)
{
Thread.Sleep(10);
}
string sendingString = "This is supposed to be image data.";
connector.Write(BitConverter.GetBytes((ushort)sendingString.Length));
connector.Write(Encoding.UTF8.GetBytes(sendingString));
Assert.AreEqual(sendingString, Encoding.UTF8.GetString(connectingClient.Read()));
}
public MovementDetector()
{
ushort port;
try
{
port = ushort.Parse(System.IO.File.ReadAllText(PortFile));
}
catch (Exception)
{
Console.WriteLine($"Could not parse port file \"{PortFile}\"");
throw;
}
_tcp = new TcpReader(IPAddress.Any, port);
_reader.Elapsed += async(_, _) => await GetMovement();
}
private void EndReadRecordMark(IAsyncResult ar)
{
try
{
int read;
lock (_sync)
{
if (_disposed)
{
throw new ObjectDisposedException(typeof(TcpClient).FullName);
}
read = _stream.EndRead(ar);
}
Log.Debug("read {0} bytes of Record Mark", read);
if (read <= 0)
{
throw new EndOfStreamException();
}
_leftToRead -= read;
_readPos += read;
if (_leftToRead <= 0)
{
ExtractRecordMark();
SafeBeginRead(EndReadBody);
}
else
{
SafeBeginRead(EndReadRecordMark);
}
}
catch (Exception ex)
{
_readCompleted(ex, null);
_tcpReader = null;
_readCompleted = null;
_readBuf = null;
}
}
private void OnMessageReaded(Exception err, TcpReader tcpReader)
{
if (err != null)
{
Log.Debug("No receiving TCP messages. Reason: {0}", err);
OnException(err);
return;
}
lock (_sync)
_receivingInProgress = false;
rpc_msg respMsg = null;
Reader r = null;
try
{
r = Toolkit.CreateReader(tcpReader);
respMsg = r.Read <rpc_msg>();
}
catch (Exception ex)
{
Log.Info("Parse exception: {0}", ex);
BeginReceive();
return;
}
Log.Trace("Received response xid:{0}", respMsg.xid);
ITicket ticket = EnqueueTicket(respMsg.xid);
BeginReceive();
if (ticket == null)
{
Log.Debug("No handler for xid:{0}", respMsg.xid);
}
else
{
ticket.ReadResult(tcpReader, r, respMsg);
}
}
/// <summary>
/// The <see cref="Connection.Open()"/> implementation method.
/// </summary>
/// <remarks>
/// This method is called on the service thread.
/// </remarks>
public override void OpenInternal()
{
base.OpenInternal();
var initiator = (TcpInitiator)ConnectionManager;
Debug.Assert(initiator != null);
TcpClient client = Client;
Debug.Assert(client != null);
if (Stream == null)
{
Stream = initiator.StreamProvider.GetStream(client);
}
var reader = new TcpReader(this);
reader.Start();
Reader = reader;
}
private void CommandHandlerCycle()
{
try {
while (true)
{
var message = TcpReader.ReadString();
Log.Print($"TCP in [{message}] -> {GamePlayer.Nickname}");
var command = message.Split(':');
var args = command.Length > 1 ? command[1].Split(' ') : default;
foreach (var commands in CommandHandler.Values)
{
if (commands.TryGetValue(command[0], out var action))
{
action(args);
break;
}
}
}
} catch (Exception) {
Disconnect();
}
}
public void AsyncRead(Action <Exception, TcpReader> completed)
{
//HACK: here you need to implement a timeout interrupt
try
{
if (_readCompleted != null)
{
throw new InvalidOperationException("already reading");
}
_tcpReader = new TcpReader();
_readCompleted = completed;
BeginReadRecordMark();
}
catch (Exception ex)
{
_tcpReader = null;
_readCompleted = null;
ThreadPool.QueueUserWorkItem((state) => completed(ex, null));
}
}
public void CanReadWriteData()
{
TcpReader connectingClient = null;
using var connector = new TcpConnector(out ushort port);
connector.ClientConnected += Continue;
connectingClient = new TcpReader(IPAddress.Any, port);
bool finished = false;
int? receivedAtClient = default;
// int receivedAtListener = default;
void Continue(object sender, NetworkStream e)
{
//Write to client / Read from client
e.WriteByte(123);
receivedAtClient = connectingClient.Read(1)[0];
//Write to listener / Read from listener
// connectingClient?.GetStream().WriteByte(213);
// receivedAtListener = e.ReadByte();
finished = true;
}
while (!finished)
{
Thread.Sleep(10);
}
Assert.AreEqual(123, receivedAtClient);
// Assert.AreEqual(213, receivedAtListener);
connectingClient?.Dispose();
}
public void IsConnectionPossible()
{
using var connector = new TcpConnector(out ushort port);
connector.ClientConnected += Continue;
using var connectingClient = new TcpReader(IPAddress.Any, port);
bool success = false;
void Continue(object sender, NetworkStream e)
{
success = true;
}
int tries = 0;
int totalTries = 30;
while (!success && tries < totalTries)
{
Thread.Sleep(100);
}
Assert.AreNotEqual(totalTries, tries);
Assert.IsTrue(success);
}
/// <summary>
/// Initializes a new instance of the <see cref="TcpReaderFileCache"/> class.
/// </summary>
public TcpReaderFileCache()
{
Actual = new TcpReader();
FileStore = new FileStore();
}
public void TcpReader_WhenDataIsSentToStreamWithFullMessageSeperator_ThenDataIsObserved(int tcpReaderBufferSize, string dataToSend, string dataToExpect)
{
//Arrange
_tcpReader = new TcpReader(_serverSideTcpClient, new MessageParser(MessageSeperator), tcpReaderBufferSize);
//Act
var streamWriter = new StreamWriter(_tcpClient.GetStream());
_tcpReader.Read().Subscribe(data =>
{
_stringDataReturned += data;
}, _completed.Set);
streamWriter.Write(dataToSend);
streamWriter.Flush();
streamWriter.Close();
//Assert
_completed.Wait();
Assert.AreEqual(dataToExpect, _stringDataReturned);
}
public void TcpReader_WhenDataMessageSentAndMessageSeperatorSentIn2Fragments_Then1MessagesIsObserved(int tcpReaderBufferSize)
{
//Arrange
const string dataToSend = DataMessage;
_tcpReader = new TcpReader(_serverSideTcpClient, new MessageParser(MessageSeperator), tcpReaderBufferSize);
//Act
var streamWriter = new StreamWriter(_tcpClient.GetStream());
_tcpReader.Read().Subscribe(data =>
{
_stringDataReturned += data;
}, _completed.Set);
streamWriter.Write(dataToSend);
streamWriter.Flush();
streamWriter.Write(MessageSeperator.Substring(0,2));
streamWriter.Flush();
streamWriter.Write(MessageSeperator.Substring(2, MessageSeperator.Length-2));
streamWriter.Flush();
streamWriter.Close();
//Assert
_completed.Wait();
Assert.AreEqual(dataToSend, _stringDataReturned);
}
public void TcpReader_WhenSeveralDataMessageSentAcrossMoreThanOneWriteAndNoMessageSeperators_ThenNoMessagesIsObserved(int tcpReaderBufferSize)
{
//Arrange
_tcpReader = new TcpReader(_serverSideTcpClient, new MessageParser(MessageSeperator), tcpReaderBufferSize);
const string dataToSend = DataMessage;
//Act
var streamWriter = new StreamWriter(_tcpClient.GetStream());
_tcpReader.Read().Subscribe(data =>
{
_stringDataReturned += data;
}, _completed.Set);
streamWriter.Write(dataToSend);
streamWriter.Flush();
streamWriter.Write(dataToSend);
streamWriter.Flush();
streamWriter.Close();
//Assert
_completed.Wait();
Assert.AreEqual(string.Empty, _stringDataReturned);
}
private void EndReadBody(IAsyncResult ar)
{
Exception error = null;
try
{
int read;
lock(_sync)
{
if(_disposed)
throw new ObjectDisposedException(typeof(TcpClient).FullName);
read = _stream.EndRead(ar);
}
Log.Debug("read {0} bytes of body", read);
if(read <= 0)
throw new EndOfStreamException();
_leftToRead -= read;
_readPos += read;
if(_leftToRead <= 0)
{
Log.Trace(Toolkit.DumpToLog, "received byte dump: {0}", _readBuf);
_tcpReader.AppendBlock(_readBuf);
if(!_lastReadBlock)
{
Log.Debug("body readed", read);
BeginReadRecordMark();
return;
}
}
else
{
SafeBeginRead(EndReadBody);
return;
}
}
catch(Exception ex)
{
error = ex;
}
if(error != null)
_tcpReader = null;
_readCompleted(error, _tcpReader);
_tcpReader = null;
_readCompleted = null;
_readBuf = null;
}
private void OnMessageReaded(Exception err, TcpReader tcpReader)
{
if (err != null)
{
Log.Debug("No receiving TCP messages. Reason: {0}", err);
OnException(err);
return;
}
lock (_sync)
_receivingInProgress = false;
rpc_msg respMsg = null;
Reader r = null;
try
{
r = Toolkit.CreateReader(tcpReader);
respMsg = r.Read<rpc_msg>();
}
catch (Exception ex)
{
Log.Info("Parse exception: {0}", ex);
BeginReceive();
return;
}
Log.Trace("Received response xid:{0}", respMsg.xid);
ITicket ticket = EnqueueTicket(respMsg.xid);
BeginReceive();
if (ticket == null)
Log.Debug("No handler for xid:{0}", respMsg.xid);
else
ticket.ReadResult(tcpReader, r, respMsg);
}
private void EndReadRecordMark(IAsyncResult ar)
{
try
{
int read;
lock(_sync)
{
if(_disposed)
throw new ObjectDisposedException(typeof(TcpClient).FullName);
read = _stream.EndRead(ar);
}
Log.Debug("read {0} bytes of Record Mark", read);
if(read <= 0)
throw new EndOfStreamException();
_leftToRead -= read;
_readPos += read;
if(_leftToRead <= 0)
{
ExtractRecordMark();
SafeBeginRead(EndReadBody);
}
else
SafeBeginRead(EndReadRecordMark);
}
catch(Exception ex)
{
_readCompleted(ex, null);
_tcpReader = null;
_readCompleted = null;
_readBuf = null;
}
}
public void AsyncRead(Action<Exception, TcpReader> completed)
{
//HACK: here you need to implement a timeout interrupt
try
{
if(_readCompleted != null)
throw new InvalidOperationException("already reading");
_tcpReader = new TcpReader();
_readCompleted = completed;
BeginReadRecordMark();
}
catch(Exception ex)
{
_tcpReader = null;
_readCompleted = null;
ThreadPool.QueueUserWorkItem((state) => completed(ex, null));
}
}
