/// <summary>
///
/// </summary>
/// <returns></returns>
public ITCPClient AcceptTCPClient()
{
if (IsDisposed)
{
return(null);
}
return(new DesktopTCPClient(Listener.Accept()));
}
protected void Listen()
{
while (!Closed)
{
Socket socket = Listener.Accept();
var conn = this.AddConnection(socket);
}
}
private void Listening()
{
Socket handler = null;
try
{
handler = Listener.Accept();
if (!Connected)
{
OnConnect?.Invoke(this, null);
Connected = true;
}
while (ListenerEnabled)
{
byte[] buffer = new byte[MessageSize];
int bytesRead = handler.Receive(buffer, 0, MessageSize, 0);
ReadBytes(bytesRead, buffer);
if (this.MessageToSend != null)
{
Send(handler, this.MessageToSend);
}
}
}
catch (Exception e)
{
OnError?.Invoke(this, new ErrorEventArgs(ErrorType.Generic, e));
}
finally
{
if (handler != null)
{
handler.Shutdown(SocketShutdown.Both);
handler.Close();
Listener.Close();
}
if (Connected)
{
OnDisconnect?.Invoke(this, null);
Connected = false;
}
}
}
private void Task()
{
Listener.Listen(100);
while (!Cancel)
{
if (Pause)
{
Thread.Sleep(2000);
continue;
}
var sock = Listener.Accept();
new Thread(() => HandleClient(new Client {
Sock = sock
})).Start();
}
}
public void Init()
{
if (RetryTemplate != null && ErrorChannel != null)
{
throw new InvalidOperationException(
"Cannot have an 'errorChannel' property when a 'RetryTemplate' is "
+ "provided; use an 'ErrorMessageSendingRecoverer' in the 'recoveryCallback' property to "
+ "send an error message when retries are exhausted");
}
var messageListener = new Listener(this);
if (RetryTemplate != null)
{
RetryTemplate.RegisterListener(messageListener);
}
_messageListenerContainer.MessageListener = (m) => messageListener.Accept(m);
}
/**
* Connects to the client on the specified port.
* Displays data sent from client.
*
* @return void
*/
public void ExecuteServer()
{
//Create a socket to establish connection to client
ConnectSocket(11111);
while (true)
{
Console.WriteLine("Awaiting connection from client ... ");
// Suspend while waiting for incoming connection Using Accept()
ClientSocket = Listener.Accept();
//Display connected status message
Console.WriteLine("Connected\n");
//Proceed to the rest of the program once connection has been established
break;
}
}
public void Check()
{
while (Listener.Pending())
{
var client = Listener.Accept();
Player player = Server.Players.GetFreePlayer();
player.Connect(client);
player.State = PlayerState.Connecting;
}
foreach (var c in Server.Players)
{
c.Check();
if (c.Tcp.BatchStream.BaseStream.Length != 0)
{
var arr = ((MemoryStream)c.Tcp.BatchStream.BaseStream).ToArray();
c.Tcp.NetStreamBinary.Write(arr);
c.Udp.Stream.BaseStream.SetLength(0);
}
}
}
/// <summary>
/// This method calls Open if it was not called already by the
/// application, and then enters an endless loop where it
/// repeatedly waits for incoming requests, accepts them, and
/// performs the necessary processing for handling the request.
/// </summary>
public void Run()
{
if (!IsOpen)
{
Open();
}
while (IsOpen)
{
Stream connection = null;
// wait for next request
while (connection == null)
{
try
{
connection = Listener.Accept();
Contract.Assert(connection != null);
}
catch (IOException e)
{
Contract.Assert(connection == null);
// possibly device was disconnected
Debug.Print("IO error in Accept:\r\n" + e.Message);
if (Diagnostics != null)
{
Diagnostics.AcceptErrors = Diagnostics.AcceptErrors + 1;
}
Thread.Sleep(500); // TODO does it make sense like this?
}
catch (SocketException e)
{
Contract.Assert(connection == null);
// possibly Internet was disconnected
Debug.Print("Socket error in Accept:\r\n" + e.Message);
if (Diagnostics != null)
{
Diagnostics.AcceptErrors = Diagnostics.AcceptErrors + 1;
}
Thread.Sleep(500); // TODO does it make sense like this?
}
catch (ContractViolation e)
{
Contract.Assert(connection == null);
Debug.Print("bug in Accept:\r\n" + e);
if (Diagnostics != null)
{
Diagnostics.AcceptFailures = Diagnostics.AcceptFailures + 1;
}
Thread.Sleep(500); // TODO does it make sense like this?
}
catch (Exception e)
{
Contract.Assert(connection == null);
Debug.Print("exception in Accept:\r\n" + e);
if (Diagnostics != null)
{
Diagnostics.AcceptFailures = Diagnostics.AcceptFailures + 1;
}
Thread.Sleep(500); // TODO does it make sense like this?
}
}
// handle request
var connectionClose = true;
// ignore connectionClose, i.e., always
// close connection after a request
try
{
if (Diagnostics != null)
{
Diagnostics.RequestsTotal = Diagnostics.RequestsTotal + 1;
}
ConsumeRequest(connection, Listener.ServiceRoot,
RelayDomain, RequestRouting,
ref connectionClose);
}
catch (IOException e)
{
// possibly device was disconnected, or host has sent no data (read timeout)
Debug.Print("IO error in ConsumeRequest:\r\n" + e.Message);
if (Diagnostics != null)
{
Diagnostics.RequestHandlerErrors = Diagnostics.RequestHandlerErrors + 1;
}
}
catch (SocketException e)
{
// possibly Internet was disconnected, or host has sent no data (read timeout)
Debug.Print("Socket error in ConsumeRequest:\r\n" + e.ErrorCode);
if (Diagnostics != null)
{
Diagnostics.RequestHandlerErrors = Diagnostics.RequestHandlerErrors + 1;
}
}
catch (ContractViolation e)
{
Debug.Print("bug in ConsumeRequest:\r\n" + e);
if (Diagnostics != null)
{
Diagnostics.RequestHandlerFailures = Diagnostics.RequestHandlerFailures + 1;
}
}
//TODO remove comments
//catch (Exception e)
//{
// Debug.Print("exception in ConsumeRequest:\r\n" + e);
// if (Diagnostics != null)
// {
// Diagnostics.RequestHandlerFailures = Diagnostics.RequestHandlerFailures + 1;
// }
//}
connection.Close();
}
}
public void Start(int nofThreads)
{
Contract.Requires(nofThreads > 0);
ThreadPool.Open(nofThreads);
ThreadPool.Start();
if (!IsOpen)
{
Open();
}
while (IsOpen)
{
// wait for next request
Stream connection = null;
try
{
Debug.Print("before accept");
connection = Listener.Accept();
Debug.Print("after accept");
Contract.Ensures(connection != null);
}
catch (IOException e)
{
Contract.Assert(connection == null);
// possibly device was disconnected
Debug.Print("IO error in Accept:\r\n" + e.Message);
if (Diagnostics != null)
{
Diagnostics.AcceptErrors = Diagnostics.AcceptErrors + 1;
}
Thread.Sleep(500); // TODO does it make sense like this?
}
catch (SocketException e)
{
Contract.Assert(connection == null);
// possibly Internet was disconnected
Debug.Print("Socket error in Accept:\r\n" + e.Message);
if (Diagnostics != null)
{
Diagnostics.AcceptErrors = Diagnostics.AcceptErrors + 1;
}
Thread.Sleep(500); // TODO does it make sense like this?
}
catch (ContractViolation e)
{
Contract.Assert(connection == null);
Debug.Print("bug in Accept:\r\n" + e);
if (Diagnostics != null)
{
Diagnostics.AcceptFailures = Diagnostics.AcceptFailures + 1;
}
Thread.Sleep(500); // TODO does it make sense like this?
}
catch (Exception e)
{
Contract.Assert(connection == null);
Debug.Print("exception in Accept:\r\n" + e);
if (Diagnostics != null)
{
Diagnostics.AcceptFailures = Diagnostics.AcceptFailures + 1;
}
Thread.Sleep(500); // TODO does it make sense like this?
}
if (connection != null)
{
Debug.Print("connection was accepted");
ThreadPool.QueueUserWorkItem(ProcessRequest, connection);
}
}
}
public override R Accept <R, A>(Listener <R, A> listener, A data)
{
return(listener.Accept(this, data));
}
public Addr Accept() => s_AcceptByRef?.Invoke(ref this) ?? s_AcceptByVal?.Invoke(this) ?? Listener?.Accept() ?? throw new PanicException(RuntimeErrorPanic.NilPointerDereference);