private void SendResponse(Response response)
{
try
{
foreach (var client in _server.ListClients())
{
string json = "";
if (Settings.Default.AddJsonRootObject)
{
var root = new
{
Response = response
};
json = root.ToJson();
}
else
{
json = response.ToJson();
}
_server.SendAsync(client, json);
ResponseSent?.Invoke(this, json);
}
}
catch (Exception ex)
{
Error?.Invoke(this, ex);
}
}
public async Task SendVehicleUpdateAsync(WSVehicleUpdateMsg msg)
{
foreach (string client in Clients)
{
await Server.SendAsync(client, JsonConvert.SerializeObject(msg));
}
}
public async Task OnHandle(BasicControlMessage message, string name)
{
Console.WriteLine("received control command: " + message.command);
if (lastClients.Count > 0)
{
foreach (string lastClient in lastClients)
{
await socket.SendAsync(lastClient, message.command, CancellationToken.None);
}
}
else
{
await Task.Delay(10);
}
}
private async Task WebsocketServer_ClientConnected(object sender, ClientConnectedEventArgs e)
{
if (Client.ConnectionState != ConnectionState.Connected)
{
await Task.CompletedTask;
}
Console.WriteLine("WS REMOTE CONNECTED: " + e.IpPort);
var channelDict = new Dictionary <string, string>();
var channels = MainGuild.TextChannels.ToList().OrderBy(c => c.Position);
foreach (var channel in channels)
{
channelDict.Add(channel.Name, channel.Id.ToString());
}
await WebsocketServer.SendAsync(e.IpPort, JsonConvert.SerializeObject(channelDict));
}
#pragma warning restore CS1998
private static async Task MessageReceived(string ipPort, byte[] data)
{
if (stopReceive)
{
return;
}
try
{
if (!(data != null && data.Length > 0))
{
throw new ArgumentNullException("Data is empty.");
}
if (stopReceive)
{
throw new Exception("Handling of requests stopped");
}
clients[clients.FirstOrDefault(x => x.Key.IpPort == ipPort).Key] = true;
byte[] response = requestHandler.HandleRequest(data, out List <User> targets, clients.FirstOrDefault(x => x.Key.IpPort == ipPort).Key);
foreach (User user in targets)
{
User temp = user;
if (string.IsNullOrEmpty(user.IpAddress) || user.Port == 0)
{
temp = clients.FirstOrDefault(x => x.Key.Name.ToLower() == user.Name.ToLower()).Key;
}
if (temp == null || !await server.SendAsync(temp.IpPort, response))
{
log.Add($"Message could not be send to {temp}.", MessageType.Warning);
}
}
clients[clients.FirstOrDefault(x => x.Key.IpPort == ipPort).Key] = false;
}
catch (Exception ex)
{
log.Add($"Message of client {ipPort} could not be handled: {Environment.NewLine} {ex.ToString()}", MessageType.Error);
}
}
static void Main(string[] args)
{
using (WatsonWsServer wss = new WatsonWsServer(_Hostname, _Port, false))
{
wss.ClientConnected += (s, e) => Console.WriteLine("Client connected: " + e.IpPort);
wss.ClientDisconnected += (s, e) => Console.WriteLine("Client disconnected: " + e.IpPort);
wss.MessageReceived += (s, e) =>
{
Console.WriteLine("Server message received from " + e.IpPort + ": " + Encoding.UTF8.GetString(e.Data));
_ClientIpPort = e.IpPort;
};
wss.Start();
Thread.Sleep(2500);
using (WatsonWsClient wsc = new WatsonWsClient(_Hostname, _Port, false))
{
wsc.ServerConnected += (s, e) => Console.WriteLine("Client connected to server");
wsc.ServerDisconnected += (s, e) => Console.WriteLine("Client disconnected from server");
wsc.MessageReceived += (s, e) => Console.WriteLine("Client received message from server: " + Encoding.UTF8.GetString(e.Data));
wsc.Start();
Thread.Sleep(2500);
Console.WriteLine("Sending message from client to server...");
wsc.SendAsync("Hello from client").Wait();
Thread.Sleep(2500);
Console.WriteLine("Sending message from server to client...");
wss.SendAsync(_ClientIpPort, "Hello from server").Wait();
Console.WriteLine("Press ENTER to exit");
Console.ReadLine();
}
}
}
static void Main(string[] args)
{
msgData = Encoding.UTF8.GetBytes(RandomString(msgLength));
sendDelay = numClients * 20;
using (server = new WatsonWsServer(hostname, port, false))
{
#region Start-Server
serverStats = new Statistics();
server.ClientConnected += (s, e) =>
{
Console.WriteLine("Client connected: " + e.IpPort);
lock (clientsLock)
{
clients.Add(e.IpPort);
}
};
server.ClientDisconnected += (s, e) =>
{
Console.WriteLine("*** Client disconnected: " + e.IpPort);
lock (clientsLock)
{
if (clients.Contains(e.IpPort))
{
clients.Remove(e.IpPort);
}
}
};
server.MessageReceived += (s, e) =>
{
serverStats.AddRecv(e.Data.Length);
};
// server.Logger = Logger;
server.Start();
#endregion
#region Start-and-Wait-for-Clients
for (int i = 0; i < numClients; i++)
{
Console.WriteLine("Starting client " + (i + 1) + "...");
Task.Run(() => ClientTask());
Task.Delay(250).Wait();
}
while (true)
{
Task.Delay(1000).Wait();
int connected = 0;
lock (clientsLock)
{
connected = clients.Count;
}
if (connected == numClients)
{
break;
}
Console.WriteLine(connected + " of " + numClients + " connected, waiting");
}
Console.WriteLine("All clients connected!");
serverReady = true;
#endregion
#region Send-Messages-to-Clients
for (int i = 0; i < messagesPerClient; i++)
{
for (int j = 0; j < numClients; j++)
{
server.SendAsync(clients[j], msgData).Wait();
serverStats.AddSent(msgData.Length);
}
}
#endregion
#region Wait-for-Clients
while (true)
{
Task.Delay(5000).Wait();
int remaining = 0;
lock (clientsLock)
{
remaining = clients.Count;
if (remaining < 1)
{
break;
}
Console.WriteLine(DateTime.Now.ToUniversalTime().ToString("HH:mm:ss.ffffff") + " waiting for " + remaining + " clients: ");
foreach (string curr in clients)
{
Console.WriteLine("| " + curr);
}
}
}
#endregion
#region Statistics
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("Server statistics:");
Console.WriteLine(" " + serverStats.ToString());
Console.WriteLine("");
Console.WriteLine("Client statistics");
foreach (Statistics stats in clientStats)
{
Console.WriteLine(" " + stats.ToString());
}
Console.WriteLine("");
#endregion
}
}
static void Main(string[] args)
{
serverIp = InputString("Server IP:", "localhost", true);
serverPort = InputInteger("Server port:", 9000, true, true);
ssl = InputBoolean("Use SSL:", false);
InitializeServer();
bool runForever = true;
while (runForever)
{
Console.Write("Command [? for help]: ");
string userInput = Console.ReadLine()?.Trim();
if (string.IsNullOrEmpty(userInput))
{
continue;
}
string[] splitInput = userInput.Split(new string[] { " " }, 2, StringSplitOptions.None);
string ipPort = null;
bool success = false;
switch (splitInput[0])
{
case "?":
Console.WriteLine("Available commands:");
Console.WriteLine(" ? help (this menu)");
Console.WriteLine(" q quit");
Console.WriteLine(" cls clear screen");
Console.WriteLine(" list list clients");
Console.WriteLine(" stats display server statistics");
Console.WriteLine(" send ip:port message send message to client");
Console.WriteLine(" kill ip:port disconnect a client");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "list":
var clients = new List <string>(server.ListClients());
if (clients.Count > 0)
{
Console.WriteLine("Clients");
foreach (string curr in clients)
{
Console.WriteLine(" " + curr);
}
}
else
{
Console.WriteLine("[No clients connected]");
}
break;
case "stats":
Console.WriteLine(server.Stats.ToString());
break;
case "send":
if (splitInput.Length != 2)
{
break;
}
splitInput = splitInput[1].Split(new string[] { " " }, 2, StringSplitOptions.None);
if (splitInput.Length != 2)
{
break;
}
ipPort = splitInput[0];
string data = splitInput[1];
if (string.IsNullOrEmpty(data))
{
break;
}
success = server.SendAsync(ipPort, data).Result;
break;
case "kill":
if (splitInput.Length != 2)
{
break;
}
server.DisconnectClient(splitInput[1]);
break;
default:
Console.WriteLine("Unknown command: " + userInput);
break;
}
}
}
static void Main(string[] args)
{
Console.Write("Server IP : ");
serverIp = Console.ReadLine();
Console.Write("Server Port : ");
serverPort = Convert.ToInt32(Console.ReadLine());
Console.Write("SSL (true/false) : ");
ssl = Convert.ToBoolean(Console.ReadLine());
WatsonWsServer server = new WatsonWsServer(serverIp, serverPort, ssl, true, null, ClientConnected, ClientDisconnected, MessageReceived, true);
bool runForever = true;
while (runForever)
{
Console.Write("Command [? for help]: ");
string userInput = Console.ReadLine();
List <string> clients;
string ipPort;
if (String.IsNullOrEmpty(userInput))
{
continue;
}
switch (userInput)
{
case "?":
Console.WriteLine("Available commands:");
Console.WriteLine(" ? help (this menu)");
Console.WriteLine(" q quit");
Console.WriteLine(" cls clear screen");
Console.WriteLine(" list list clients");
Console.WriteLine(" send send message to client");
Console.WriteLine(" kill disconnect a client");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "list":
clients = new List <string>(server.ListClients());
if (clients != null && clients.Count > 0)
{
Console.WriteLine("Clients");
foreach (string curr in clients)
{
Console.WriteLine(" " + curr);
}
}
else
{
Console.WriteLine("None");
}
break;
case "send":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
server.SendAsync(ipPort, Encoding.UTF8.GetBytes(userInput));
break;
case "kill":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
server.KillClient(ipPort);
break;
default:
break;
}
}
}
static void Main(string[] args)
{
string header = "[Server] ";
using (server = new WatsonWsServer(hostname, port, false))
{
#region Start-Server
server.ClientConnected += (s, e) =>
{
clientIpPort = e.IpPort;
Console.WriteLine(header + "client connected: " + e.IpPort);
};
server.ClientDisconnected += (s, e) =>
{
clientIpPort = null;
Console.WriteLine(header + "client disconnected: " + e.IpPort);
};
server.MessageReceived += async(s, e) =>
{
// echo it back
serverStats.AddRecv(e.Data.Count);
await server.SendAsync(e.IpPort, e.Data);
serverStats.AddSent(e.Data.Count);
};
server.Logger = Logger;
server.Start();
Console.WriteLine(header + "started");
#endregion
#region Start-Client-and-Send-Messages
Task.Run(() => ClientTask());
Task.Delay(1000).Wait();
while (String.IsNullOrEmpty(clientIpPort))
{
Task.Delay(1000).Wait();
Console.WriteLine(header + "waiting for client connection");
}
;
Console.WriteLine(header + "detected client " + clientIpPort + ", sending messages");
for (int i = 0; i < serverSendMessageCount; i++)
{
byte[] msgData = Encoding.UTF8.GetBytes(RandomString(serverMessageLength));
server.SendAsync(clientIpPort, msgData).Wait();
serverStats.AddSent(msgData.Length);
}
Console.WriteLine(header + "messages sent");
#endregion
#region Wait-for-and-Echo-Client-Messages
while (!String.IsNullOrEmpty(clientIpPort))
{
Console.WriteLine(header + "waiting for client to finish");
Task.Delay(1000).Wait();
}
#endregion
#region Statistics
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("Server statistics:");
Console.WriteLine(" " + serverStats.ToString());
Console.WriteLine("");
Console.WriteLine("Client statistics");
Console.WriteLine(" " + clientStats.ToString());
Console.WriteLine("");
#endregion
Console.WriteLine("Press ENTER to exit");
Console.ReadLine();
}
}
static void Main(string[] args)
{
_ServerIp = InputString("Server IP:", "localhost", true);
_ServerPort = InputInteger("Server port:", 9000, true, true);
_Ssl = InputBoolean("Use SSL:", false);
InitializeServer();
// InitializeServerMultiple();
Console.WriteLine("Please manually start the server");
bool runForever = true;
while (runForever)
{
Console.Write("Command [? for help]: ");
string userInput = Console.ReadLine()?.Trim();
if (string.IsNullOrEmpty(userInput))
{
continue;
}
string[] splitInput = userInput.Split(new string[] { " " }, 2, StringSplitOptions.None);
string ipPort = null;
bool success = false;
switch (splitInput[0])
{
case "?":
Console.WriteLine("Available commands:");
Console.WriteLine(" ? help (this menu)");
Console.WriteLine(" q quit");
Console.WriteLine(" cls clear screen");
Console.WriteLine(" dispose dispose of the server");
Console.WriteLine(" reinit reinitialize the server");
Console.WriteLine(" start start accepting new connections (listening: " + _Server.IsListening + ")");
Console.WriteLine(" stop stop accepting new connections");
Console.WriteLine(" list list clients");
Console.WriteLine(" stats display server statistics");
Console.WriteLine(" send ip:port text message send text to client");
Console.WriteLine(" send ip:port bytes message send binary data to client");
Console.WriteLine(" kill ip:port disconnect a client");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "dispose":
_Server.Dispose();
break;
case "reinit":
InitializeServer();
break;
case "start":
StartServer();
break;
case "stop":
_Server.Stop();
break;
case "list":
var clients = new List <string>(_Server.ListClients());
if (clients.Count > 0)
{
Console.WriteLine("Clients");
foreach (string curr in clients)
{
Console.WriteLine(" " + curr);
}
}
else
{
Console.WriteLine("[No clients connected]");
}
break;
case "stats":
Console.WriteLine(_Server.Stats.ToString());
break;
case "send":
if (splitInput.Length != 2)
{
break;
}
splitInput = splitInput[1].Split(new string[] { " " }, 3, StringSplitOptions.None);
if (splitInput.Length != 3)
{
break;
}
if (splitInput[0].Equals("last"))
{
ipPort = _LastIpPort;
}
else
{
ipPort = splitInput[0];
}
if (String.IsNullOrEmpty(splitInput[2]))
{
break;
}
if (splitInput[1].Equals("text"))
{
success = _Server.SendAsync(ipPort, splitInput[2]).Result;
}
else if (splitInput[1].Equals("bytes"))
{
byte[] data = Encoding.UTF8.GetBytes(splitInput[2]);
success = _Server.SendAsync(ipPort, data).Result;
}
else
{
break;
}
if (!success)
{
Console.WriteLine("Failed");
}
else
{
Console.WriteLine("Success");
}
break;
case "kill":
if (splitInput.Length != 2)
{
break;
}
_Server.DisconnectClient(splitInput[1]);
break;
default:
Console.WriteLine("Unknown command: " + userInput);
break;
}
}
}
public void Send(byte[] bytes)
{
_server.SendAsync(_ipPort, bytes);
}
public void SendData(string ip, byte[] data)
{
server.SendAsync(ip, data);
}
public static bool SendMessageAsync(string ipPort, string message)
{
Socket.SendAsync(ipPort, Encoding.UTF8.GetBytes(message));
return(true);
}
