public void MultipleClientsTransmittingToSameServerTest()
{
SimpleTcpServer server = new SimpleTcpServer().Start(8911);
server.Delimiter = Encoding.UTF8.GetBytes("0")[0];
SimpleTcpClient client1 = new SimpleTcpClient().Connect(server.GetListeningIPs().FirstOrDefault(ip => ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork).ToString(), 8911);
SimpleTcpClient client2 = new SimpleTcpClient().Connect(server.GetListeningIPs().FirstOrDefault(ip => ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork).ToString(), 8911);
System.Threading.Thread.Sleep(1000);
if (server.ConnectedClientsCount < 2)
{
Assert.Fail("Server did not register 2 connected clients");
}
string dataRecievedByServer = "";
server.DelimiterDataReceived += (sender, msg) =>
{
dataRecievedByServer += msg.MessageString;
};
client1.Write("1111");
System.Threading.Thread.Sleep(100);
client2.Write("2222");
System.Threading.Thread.Sleep(100);
client1.Write("0");
System.Threading.Thread.Sleep(1000);
Assert.AreEqual("1111", dataRecievedByServer);
server.Stop();
}
// constructor
public WaitingRoom(string name)
{
IPAddress[] localIPs = Dns.GetHostAddresses(Dns.GetHostName());
string temp = "";
ipAdress = localIPs[2].ToString();
for (int i = 0, a = 0; i < ipAdress.Length; i++)
{
if (ipAdress[i] == '.' && ++a == 3)
{
temp = ipAdress.Substring(i + 1, ipAdress.Length - i - 1);
break;
}
}
ip = IPAddress.Parse(ipAdress);
InitializeComponent();
this.Text += temp;
this.name = name;
this.who = "host";
server = new SimpleTcpServer();
server.Delimiter = 0x13;
server.StringEncoder = Encoding.UTF8;
server.DataReceived += GetServer;
server.Start(ip, 8000);
players.Text = name + "\n";
}
private void Form1_Load(object sender, EventArgs e)
{
server = new SimpleTcpServer();
server.Delimiter = 0x13;//enter
server.StringEncoder = Encoding.UTF8;
server.DataReceived += Server_DataReceived;
}
/// <summary>
/// Launch and Start CLServer
/// </summary>
/// <param name="LicenseKey">License key of Loader</param>
/// <param name="Port">Port for use</param>
public CLServer(string LicenseKey, uint Port)
{
API_LICENSE_KEY = LicenseKey;
Init();
SetConnectionsToAPI(true);
TcpServer = new SimpleTcpServer().Start((int)Port);
DetectedNotAllowedIP += CLServer_DetectedNotAllowedIP;
// Setup a socket server
TcpServer.ClientConnected += Server_ClientConnected;
TcpServer.ClientDisconnected += Server_ClientDisconnected;
TcpServer.Delimiter = 0x13;
//Server.TcpServer.DelimiterDataReceived += (sendr, msg) =>
//{
// if (msg.MessageString.StartsWith("/"))
// {
// string[] parameters = msg.MessageString.TrimStart('/').Split(' ');
// switch (parameters[0])
// {
// case "autoclick_detected":
// break;
// default:
// break;
// }
// }
// else
// {
// }
//};
}
private void btnStart_Click(object sender, EventArgs e)
{
if (server == null)
{
int port = 0;
Int32.TryParse(txtPort.Text, out port);
if (port == 0)
{
MessageBox.Show("Enter a port...", "No port", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
start = DateTime.Now;
server = new SimpleTcpServer().Start(port);
server.Delimiter = (byte)'\n';
server.DelimiterDataReceived += Server_DelimiterDataReceived;
server.ClientConnected += (s, ev) => { AppendMessage("New Client connected."); };
server.ClientDisconnected += (s, ev) => { AppendMessage("Client disconnected."); };
AppendMessage($"Server started on port {port}");
btnStart.Text = "Stop";
}
else
{
server.Stop();
server = null;
AppendMessage("Server stopped.");
btnStart.Text = "Start";
}
}
public void Start()
{
if (InstanceOfServer != null)
{
server = new SimpleTcpServer().Start(PORT);
server.Delimiter = 0x13;
Rooms = new Dictionary <int, List <TcpClient> >();
server.DelimiterDataReceived += Server_DelimiterDataReceived;
server.ClientConnected += Server_ClientConnected;
server.ClientDisconnected += Server_ClientDisconnected;
}
else
{
instanceOfServer = new Server();
server = new SimpleTcpServer().Start(PORT);
server.Delimiter = 0x13;
Rooms = new Dictionary <int, List <TcpClient> >();
server.DelimiterDataReceived += Server_DelimiterDataReceived;
}
}
private void ServerLoaded(object sender, RoutedEventArgs e)
{
server = new SimpleTcpServer();
server.Delimiter = 0x13; //enter key
server.StringEncoder = Encoding.UTF8;
server.DataReceived += Server_DataReceived;
}
private void Server_Load(object sender, EventArgs e)
{
_SERVER = new SimpleTcpServer();
_SERVER.Delimiter = 0x13;
_SERVER.StringEncoder = Encoding.UTF8;
_SERVER.DataReceived += _SERVER_DataReceived;
}
public void startServer()
{
server = new SimpleTcpServer().Start(8910);
server.DataReceived += Server_DataReceived;
lbl_server.Text = "Server running on : " + GetLocalIPAddress();
lbl_server.BackColor = gameAreaColor;
}
private void Form1_Load(object sender, EventArgs e)
{
server = new SimpleTcpServer();
server.Delimiter = 0x13; //giriş
server.StringEncoder = Encoding.UTF8; // SERVERİN FORMATINA DÖNÜŞTÜRÜLDÜ
server.DataReceived += Server_DataReceived;
}
public void Start_passes_if_at_all_nics_passed()
{
var server = new SimpleTcpServer().Start(_serverPort, false);
Assert.IsTrue(server.IsStarted, "Server should have started");
server.Stop();
}
public void Dispose()
{
_socket.Disconnect();
_socket.Close();
_socket = null;
if (_sender != null)
{
_sender.Disconnect();
_sender.Dispose();
_sender = null;
}
if (_receiver != null)
{
if (_receiver.IsStarted)
{
_receiver.Stop();
}
_receiver = null;
}
}
public void StartListeningAsync()
{
var server = new SimpleTcpServer();
server.Start(ManagementConfig.Port, IPAddress.Parse(ManagementConfig.Ip).AddressFamily);
server.DataReceived += DataReceived;
}
public void Receive_Message_From_Client_Correctly()
{
var messageSentToServer = "This is not what it looks like";
var messageSentToServerBytes = Encoding.ASCII.GetBytes(messageSentToServer);
var messageReceived = string.Empty;
var server = SimpleTcpServer.Configure()
.WithPort(Port)
.OnClientRequest((data, send) =>
{
messageReceived = Encoding.ASCII.GetString(data);
Completion.Set();
})
.Start();
var client = SimpleTcpClient.Configure()
.WithEndpoint(IpAddress, server.Port)
.Connect();
client.Send(messageSentToServerBytes);
Completion.WaitOne();
messageSentToServer.ShouldBe(messageReceived);
server.Stop();
}
private void setupTCPServer()
{
server = new SimpleTcpServer();
server.Delimiter = 0x13; // enter
server.StringEncoder = Encoding.UTF8;
server.DataReceived += Server_DataReceived;
}
public async Task Start_StartServerAndConnectWithOneClient_Successful()
{
var ipAddress = "127.0.0.1";
var port = 8000;
var expectedClientConnectedCount = 1;
var clientConnectedCount = 0;
void ClientConnected(object?sender, ConnectionEventArgs e)
{
clientConnectedCount++;
}
using var simpleTcpServer = new SimpleTcpServer($"{ipAddress}:{port}");
simpleTcpServer.Start();
simpleTcpServer.Events.ClientConnected += ClientConnected;
using var simpleTcpClient = new SimpleTcpClient($"{ipAddress}:{port}");
simpleTcpClient.Connect();
simpleTcpClient.Send("test");
simpleTcpClient.Disconnect();
await Task.Delay(10);
simpleTcpServer.Events.ClientConnected -= ClientConnected;
simpleTcpServer.Stop();
Assert.AreEqual(expectedClientConnectedCount, clientConnectedCount);
}
public void startServer(string port, bool localhost)
{
string ip;
if (localhost)
{
ip = "127.0.0.1";
}
else
{
ip = Dns.GetHostByName(Dns.GetHostName()).AddressList[0].ToString();
}
server = new SimpleTcpServer($"{ip}:{port}");
ServerLogger.Instance.writeLog("Starting...");
server.Start();
while (!server.IsListening)
{
;
}
ServerLogger.Instance.writeLog("Done.");
ServerLogger.Instance.writeLog($"Server ip: {ip}");
ServerLogger.Instance.writeLog($"Listening on port {port}...");
server.Events.ClientConnected += EventClientConnected;
server.Events.ClientDisconnected += EventClientDisconnected;
server.Events.DataReceived += EventDataReceived;
contractLoadingThread = new ContractLoadingThread();
Thread thread = new Thread(contractLoadingThread.startListening);
thread.IsBackground = true;
thread.Start();
}
/////////////////////////////////////
// Public
/////////////////////////////////////
public bool Start(int port = 7788)
{
try
{
Host = new SimpleTcpServer();
//Host.Delimiter
//Host.DelimiterDataReceived += (o, e) => { Console.WriteLine("Delimter data received"); };
//Host.DataReceived += (o, e) => { Console.WriteLine("##############Data received"); };
//Host.DataReceived += DataReceived;
Host.DelimiterDataReceived += DataReceived;
Host.ClientConnected += ClientConnected;
Host.Start(port);
disconnectPing.Start();
InvokeOutput("Server Started.");
if (!hasConnectedBefore)
{
hasConnectedBefore = true;
Application.Current.MainWindow.Closed += Program_Exit;
}
OnStarted?.Invoke();
return(true);
}
catch (Exception ex)
{
Console.WriteLine("Warning#001 :" + ex.Message);
InvokeOutput("Server Not Started.");
return(false);
}
}
public void Start(int port = 7788)
{
try
{
Host = new SimpleTcpServer();
Host.DataReceived += Host_DataReceived;
Host.ClientConnected += (o, e) =>
{
for (int i = Clients.Count - 1; i >= 0; i--)
{
if (!Clients[i].Connected)
{
Clients.RemoveAt(i);
}
}
Clients.Add(e);
Console.WriteLine("Client Connected");
};
Host.Start(port);
Settings.IsServer = true;
Settings.InvokeConnection();
}
catch (Exception)
{
Settings.IsServer = false;
MessageBox.Show("Kunne ikke starte serveren.\nTjek at porten ikke bliver brugt.", "Server ikke startet", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public void Stop()
{
Host.Stop();
Host = null;
Settings.IsServer = false;
Settings.InvokeDisconnection(true);
}
private void UserControl_Train_Load(object sender, EventArgs e)
{
//Control_Timer.Start();
if (UserControl_Train_Setup.horizon_plane)
{
pictureBox1.Image = Leila_GUI.ResourceIcons.artificial_horizon;
}
else
{
pictureBox1.Image = Leila_GUI.ResourceIcons.airplane;
}
server = new SimpleTcpServer();
server.Delimiter = 0x13;
server.StringEncoder = Encoding.UTF8;
server.DataReceived += Server_DataReceived;
/*
* serialPort1.PortName = "COM5";
* serialPort1.BaudRate = 9600;
* serialPort1.StopBits = System.IO.Ports.StopBits.One;
* serialPort1.DataBits = 8;
* serialPort1.Open();
*/
}
/// <summary>
/// Stop the server service
/// </summary>
/// <param name="server"></param>
public static void StopService(SimpleTcpServer server)
{
if (server.IsStarted)
{
server.Stop();
}
}
private void Server_Load(object sender, EventArgs e)
{
Server1 = new SimpleTcpServer();
Server1.Delimiter = 0x13;//enter
Server1.StringEncoder = Encoding.UTF8;
Server1.DataReceived += Server1_DataReceived;
}
public void Awake()
{
this.m_Server = new SimpleTcpServer();
this.m_Environment = GetComponent <VirtualEnvironment>();
RenderSingleCamera(-1);
}
static void DumpFrame(
RenderFrame frame,
string captureFolder,
SimpleTcpServer tcpServer,
int quality,
bool losslessPNG)
{
// dump the left.
RenderTexture.active = frame.RenderTargetLeft;
frame.ResolveTexture.ReadPixels(new Rect(0, 0, frame.RenderTargetLeft.width, frame.RenderTargetLeft.height), 0, 0);
// dump the right.
RenderTexture.active = frame.RenderTargetRight;
frame.ResolveTexture.ReadPixels(new Rect(0, 0, frame.RenderTargetRight.width, frame.RenderTargetRight.height), 0, frame.RenderTargetLeft.height);
RenderTexture.active = null;
frame.ResolveTexture.Apply();
if (tcpServer != null && tcpServer.Capturing)
{
var pixels32 = frame.ResolveTexture.GetRawTextureData();
tcpServer.Send(frame.FrameCount,
frame.ResolveTexture.width,
frame.ResolveTexture.height,
pixels32);
}
else if (!string.IsNullOrEmpty(captureFolder))
{
// write to file.
var fileName = string.Format("frame_{0}.{1}", frame.FrameCount.ToString("D5"), losslessPNG ? "png" : "jpg");
File.WriteAllBytes(
Path.Combine(captureFolder, fileName),
losslessPNG ? frame.ResolveTexture.EncodeToPNG() : frame.ResolveTexture.EncodeToJPG(quality));
}
}
public Listener()
{
try
{
var server = new SimpleTcpServer().Start(Program.Configuration.Listener.Port);
server.AutoTrimStrings = true;
server.Delimiter = 0x13;
Console.WriteLine($"Listener active on {string.Join(",", server.GetListeningIPs())} : {Program.Configuration.Listener.Port}");
server.DataReceived += (sender, message) =>
{
var obj = Handle(message);
message.ReplyLine($"{obj}{Environment.NewLine}");
Console.WriteLine(obj);
};
// while (true)
// {
// Console.WriteLine("...");
// Thread.Sleep(10000);
// }
}
catch (Exception e)
{
_log.Trace(e);
}
}
void Server()
{
var server = new SimpleTcpServer().Start(8910);
// var listeningIps = server.GetListeningIPs();
var listeningV4Ips = server.GetListeningIPs().Where(ip => ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork);
server.Delimiter = 0x13;
server.DelimiterDataReceived += async(sender, msg) =>
{
msg.ReplyLine("ok");
if (msg.MessageString != "")
{
var x = await msg.AsCompletedTask();
byte[] toBytes = Convert.FromBase64String(msg.MessageString);
Application.Current.Dispatcher.Invoke(() => {
var image = LoadFromBytes(toBytes);
if (image != null)
{
bittest.Source = image;
}
else
{
Console.WriteLine("Emplty Image");
}
});
}
else
{
Console.WriteLine("empty msg");
}
};
}
private void Form1_Load(object sender, EventArgs e)
{
server = new SimpleTcpServer {
Delimiter = 0x13, StringEncoder = Encoding.UTF8
}; // Enter, Make sure you encode in UTF8 format
server.DataReceived += Server_DataReceived;
}
private static void Main()
{
HttpClient httpClient = new HttpClient();
SimpleTcpServer tcpServer = new SimpleTcpServer().Start(Constants.TcpPort);
tcpServer.DataReceived += async(sender, e) =>
{
MessageTransmission messageTransmission = JsonConvert.DeserializeObject <MessageTransmission>(e.MessageString);
string messageString = JsonConvert.SerializeObject(messageTransmission.Message);
tcpServer.Broadcast(messageString);
ByteArrayContent byteArrayContent = new ByteArrayContent(Encoding.UTF8.GetBytes(messageString));
byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Post, $"{Constants.HttpServerAddress}/messages/post")
{
Content = byteArrayContent,
Headers =
{
{ "Authorization", messageTransmission.Authorization }
}
};
await httpClient.SendAsync(message);
WriteLine("Message: {0}", messageTransmission.Message.Content);
};
ReadKey();
}
// constructors
public MultiPlayerHost(IPAddress ip)
{
InitializeComponent();
int sp = 15;
snakeUpdate.Interval = 1000 / sp;
try
{
server = new SimpleTcpServer();
server.Delimiter = 0x13;
server.StringEncoder = Encoding.UTF8;
server.DataReceived += GetServer;
server.ClientConnected += Connected;
server.Start(ip, 8000);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
g = new Game(0, FitScreen(), sketch.Width, sketch.Height);
s = new Snake(Color.Beige, g, sp, "test");
s1 = new Snake(Color.LightYellow, g, sp, "test");
f = new Food(Color.Black, Color.White, g, s);
}
public void SimpleCommTest()
{
SimpleTcpServer server = new SimpleTcpServer().Start(8910);
SimpleTcpClient client = new SimpleTcpClient().Connect(server.GetListeningIPs().FirstOrDefault(ip => ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork).ToString(), 8910);
server.DelimiterDataReceived += (sender, msg) => {
_serverRx.Add(msg.MessageString);
string serverReply = Guid.NewGuid().ToString();
msg.ReplyLine(serverReply);
_serverTx.Add(serverReply);
};
client.DelimiterDataReceived += (sender, msg) => {
_clientRx.Add(msg.MessageString);
};
System.Threading.Thread.Sleep(1000);
if (server.ConnectedClientsCount == 0)
{
Assert.Fail("Server did not register connected client");
}
for (int i = 0; i < 10; i++)
{
string clientTxMsg = Guid.NewGuid().ToString();
_clientTx.Add(clientTxMsg);
client.WriteLine(clientTxMsg);
System.Threading.Thread.Sleep(100);
}
System.Threading.Thread.Sleep(1000);
for (int i = 0; i < 10; i++)
{
if (_clientTx[i] != _serverRx[i])
{
Assert.Fail("Client TX " + i.ToString() + " did not match server RX " + i.ToString());
}
if (_serverTx[i] != _clientRx[i])
{
Assert.Fail("Client RX " + i.ToString() + " did not match server TX " + i.ToString());
}
}
var reply = client.WriteLineAndGetReply("TEST", TimeSpan.FromSeconds(1));
if (reply == null)
{
Assert.Fail("WriteLineAndGetReply returned null");
}
Assert.IsTrue(true);
}
internal ServerListener(SimpleTcpServer parentServer, IPAddress ipAddress, int port)
{
QueueStop = false;
_parent = parentServer;
IPAddress = ipAddress;
Port = port;
ReadLoopIntervalMs = 10;
_listener = new TcpListenerEx(ipAddress, port);
_listener.Start();
System.Threading.ThreadPool.QueueUserWorkItem(ListenerLoop);
}
public void Start_passes_if_at_least_one_nic_is_free()
{
var listener = new System.Net.Sockets.TcpListener(new IPAddress(new byte[] { 127, 0, 0, 1 }), _serverPort);
listener.Start();
try
{
var server = new SimpleTcpServer().Start(_serverPort);
Assert.IsTrue(server.IsStarted, "Server should have started on free nics");
server.Stop();
}
finally
{
listener.Stop();
}
}
public void Start_passes_if_at_all_nics_passed()
{
var server = new SimpleTcpServer().Start(_serverPort, false);
Assert.IsTrue(server.IsStarted, "Server should have started");
server.Stop();
}
public ServerTests()
{
_server = new SimpleTcpServer().Start(_serverPort);
}
public void Start_fails_if_all_nics_are_occupied()
{
var server2 = new SimpleTcpServer().Start(_serverPort);
server2.Stop(); //Guard-clause. Should never reach this.
}
