private static void ServerTask()
{
for (int i = 0; i < _NumIterations; i++)
{
int waitVal = _Random.Next(0, 12);
Task.Delay(waitVal).Wait();
if (waitVal % 3 == 0)
{
Console.WriteLine("[server] " + (i + 1).ToString() + "/" + _NumIterations.ToString() + " Sending large message");
_Server.Send(_ClientIpPort, _DataLargeBytes);
}
else if (waitVal % 2 == 0)
{
Console.WriteLine("[server] " + (i + 1).ToString() + "/" + _NumIterations.ToString() + " Sending small message");
_Server.Send(_ClientIpPort, _DataSmallBytes);
}
else
{
Console.WriteLine("[server] " + (i + 1).ToString() + "/" + _NumIterations.ToString() + " Send and wait small message");
try
{
SyncResponse syncResponse = _Server.SendAndWait(_ClientIpPort, _SendAndWaitInterval, _DataSmallBytes);
Console.WriteLine("[server] Sync response received");
}
catch (Exception e)
{
Console.WriteLine("[server] Sync response not received: " + e.Message);
}
}
}
Console.WriteLine("[server] Finished");
}
public void TCPBroadcastMessage(string messageType, string message)
{
//TODO: stop referencing clientviewobjects? maybe move it to a seperate dataclass?
Console.Out.WriteLine("[Server] broadcasting message of Type: {0}", messageType);
foreach (string clientIPPort in clientIPs)
{
tcpServer.Send(clientIPPort, messageType + "_" + message);
}
}
internal bool Send(string ipPort, Dictionary <object, object> metadata, long contentLength, Stream stream)
{
if (String.IsNullOrEmpty(ipPort))
{
throw new ArgumentNullException(nameof(ipPort));
}
if (contentLength < 0)
{
throw new ArgumentException("Content length must be zero or greater.");
}
if (stream == null || !stream.CanRead)
{
throw new ArgumentException("Cannot read from supplied stream.");
}
if (_WtcpServer == null)
{
Logger?.Invoke("[ClusterServer] Server is null, cannot send");
return(false);
}
if (_WtcpServer.IsClientConnected(ipPort))
{
return(_WtcpServer.Send(ipPort, metadata, contentLength, stream));
}
else
{
Logger?.Invoke("[ClusterServer] Server is not connected, cannot send");
return(false);
}
}
private void btnEnviar_Click(object sender, RoutedEventArgs e)
{
if (ltbIpsConectados.SelectedItem == null)
{
foreach (string ip in ltbIpsConectados.Items)
{
server.Send(ip, txtMensagem.Text);
}
}
else
{
server.Send(ltbIpsConectados.SelectedItem.ToString(), txtMensagem.Text);
}
txtHistoricoMensagens.Text += $"Eu: {txtMensagem.Text}{Environment.NewLine}";
txtMensagem.Text = string.Empty;
}
public static void HepsineGonder(string mesaj)
{
var clientler = server.ListClients();
foreach (string client in clientler)
{
server.Send(client, mesaj);
}
}
public void timerSendTaglistEvent(object sender, ElapsedEventArgs e, int index)
{
clients[index].ClientTaglist = plc[index].Return();
PacketDTO currentPacket = new PacketDTO(Utils.TypeCommand.Control, Utils.ControlCommand.Write, clients[index].ClientPLCId, clients[index].ClientPLCName, clients[index].ClientDBId, clients[index].ClientDBName, "", ObjectToByteArray((Object)clients[index].ClientTaglist));
var peremen = clients[index].ClientTaglist.SingleOrDefault(pl => pl.Name == "WatchDogPLC").CurrentValue;
server.Send(clients[index].ClientPort, ObjectToByteArray((Object)currentPacket));
}
private void SendMessage(string ipAdress, MessageType messageType, string message)
{
TcpMessage msg = new TcpMessage()
{
MessageType = messageType,
Message = message
};
server.Send(ipAdress, JsonConvert.SerializeObject(msg));
}
/// <summary>
/// Function that uploads file to a Joined based on Relative path and IP:Port that it has to upload to.
/// </summary>
/// <param name="IpPost">IP:Port that it has to upload to.</param>
/// <param name="rel"> Relative path of uploading file.</param>
public void UploadFile(string IpPost, string rel)
{
string loc = Filed.GetLocalFromRelative(rel);
using (FileStream fs = new FileStream(loc, FileMode.Open))
{
servH.Send(IpPost, fs.Length, fs);
}
UIHandler.WriteLog($"Uploaded {rel}", Color.Green);
}
private void bSend_Click(object sender, EventArgs e)
{
if (!String.IsNullOrEmpty(_ClientIpPort))
{
_Server.Send(_ClientIpPort, "Hello world!");
Logger("Sent 'Hello world!' to client " + _ClientIpPort);
}
else
{
Logger("No client connected");
}
}
/// <summary>
/// Send a message to the specified client.
/// </summary>
/// <param name="ipPort">The IP:port of the client.</param>
/// <param name="data">Data to send to the client.</param>
/// <returns>True if successful.</returns>
internal bool Send(string ipPort, byte[] data)
{
if (_WtcpServer == null)
{
if (Debug)
{
Console.WriteLine("Server is null, cannot send");
}
return(false);
}
if (_WtcpServer.IsClientConnected(ipPort))
{
_WtcpServer.Send(ipPort, data);
return(true);
}
else
{
if (Debug)
{
Console.WriteLine("Server is not connected, cannot send");
}
return(false);
}
}
/// <summary>
/// Escribir un objeto a la red mesh
/// </summary>
/// <param name="mac">Dirección MAC a la cual escribir</param>
/// <param name="obj">Objeto a escribir</param>
/// <param name="layer">Capa de la red mesh</param>
public void Write <T>(string mac, T obj, int layer = 1)
{
if (m_connectedRootNode == null)
{
return;
}
var msg = new MeshMessage <T>(mac, obj, layer);
string serialized = JsonConvert.SerializeObject(msg, SerializationSettings);
Debug.WriteLine(this, "Escribiendo mensaje TCP: " + serialized, VerbosityLevel.Debug);
m_tcpServer.Send(m_connectedRootNode, Encoding.ASCII.GetBytes(serialized), supressHeader: true);
}
static void Main(string[] args)
{
try
{
var watsonServer = new WatsonTcpServer("127.0.0.1", Port)
{
Compression = CompType,
Logger = Console.WriteLine,
DebugMessages = true
};
watsonServer.MessageReceived += (sender, message) =>
{
Console.WriteLine("Server received message: " + Encoding.UTF8.GetString(message.Data));
watsonServer.Send(message.IpPort, message.Data);
};
watsonServer.Start();
Task.Delay(1000).Wait();
var client = new WatsonTcpClient("127.0.0.1", Port)
{
Compression = CompType,
Logger = Console.WriteLine,
DebugMessages = true
};
client.MessageReceived += (sender, message) =>
{
Console.WriteLine("Client received message: " + Encoding.UTF8.GetString(message.Data));
};
client.Start();
Task.Delay(1000).Wait();
for (int i = 0; i < 10; i++)
{
client.Send("Hello " + i);
Task.Delay(250).Wait();
}
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
void ProcessMessageQueue()
{
if (messageQueue.Count <= 0)
{
return;
}
else
{
while (messageQueue.Count > 0)
{
byte[] messageToSend = messageQueue.Dequeue();
foreach (KeyValuePair <string, string> users in connectedUsers)
{
server.Send(users.Value, messageToSend);
}
}
}
}
public void Send <T>(string ipPort, T packet)
{
var packetId = (int)((Packet)(object)packet).PacketId;
using (var stream = new MemoryStream())
{
var protocolVersion = BitConverter.GetBytes(Protocol.Version);
stream.Write(protocolVersion, 0, 4);
var pid = BitConverter.GetBytes(packetId);
stream.Write(pid, 0, 4);
Serializer.Serialize(stream, packet);
var buffer = stream.ToArray();
_watsonTcpServer.Send(ipPort, buffer);
Console.WriteLine("PID {0} of {1} bytes sent to {2}", Enum.GetName(typeof(Protocols), packetId), buffer.Length, ipPort);
}
}
/// <summary>
/// Send a packet to a client
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="ipPort"></param>
/// <param name="packet"></param>
/// <returns></returns>
public bool Send <T>(string ipPort, T packet) where T : Packet
{
var packetId = (int)packet.PacketId;
using (var stream = new MemoryStream())
{
var protocolVersion = BitConverter.GetBytes(Protocol.Version);
stream.Write(protocolVersion, 0, 4);
var pid = BitConverter.GetBytes(packetId);
stream.Write(pid, 0, 4);
Serializer.Serialize(stream, packet);
var buffer = stream.ToArray();
return(_watsonTcpServer.Send(ipPort, buffer));
//ConsoleKit.Message(ConsoleKit.MessageType.INFO, "PID {0} of {1} bytes sent to {2}\n", Enum.GetName(typeof(Protocols), packetId), buffer.Length, ipPort);
}
}
/// <summary>
/// Escribir al servidor
/// </summary>
/// <param name="ipPort">IP / Puerto destinatario</param>
/// <param name="msg">Mensaje a enviar</param>
public void Write(string ipPort, string msg)
{
byte[] data = Encoding.ASCII.GetBytes(msg);
m_server.Send(ipPort, data);
}
private static void Main(string[] args)
{
serverIp = InputString("Server IP:", "127.0.0.1", false);
serverPort = InputInteger("Server port:", 9000, true, false);
useSsl = InputBoolean("Use SSL:", false);
if (!useSsl)
{
server = new WatsonTcpServer(serverIp, serverPort);
}
else
{
certFile = InputString("Certificate file:", "test.pfx", false);
certPass = InputString("Certificate password:"******"password", false);
acceptInvalidCerts = InputBoolean("Accept invalid certs:", true);
mutualAuthentication = InputBoolean("Mutually authenticate:", false);
server = new WatsonTcpServer(serverIp, serverPort, certFile, certPass);
server.AcceptInvalidCertificates = acceptInvalidCerts;
server.MutuallyAuthenticate = mutualAuthentication;
}
server.ClientConnected = ClientConnected;
server.ClientDisconnected = ClientDisconnected;
server.MessageReceived = MessageReceived;
server.Debug = debug;
server.Start();
bool runForever = true;
while (runForever)
{
Console.Write("Command [? for help]: ");
string userInput = Console.ReadLine();
List <string> clients;
string ipPort;
bool success = false;
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(" dispose dispose of the connection");
Console.WriteLine(" send send message to client");
Console.WriteLine(" sendasync send message to a client asynchronously");
Console.WriteLine(" remove disconnect client");
Console.WriteLine(" psk set preshared key");
Console.WriteLine(" debug enable/disable debug (currently " + server.Debug + ")");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "list":
clients = 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 "dispose":
server.Dispose();
break;
case "send":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
if (String.IsNullOrEmpty(ipPort))
{
break;
}
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
success = server.Send(ipPort, Encoding.UTF8.GetBytes(userInput));
Console.WriteLine(success);
break;
case "sendasync":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
if (String.IsNullOrEmpty(ipPort))
{
break;
}
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
success = server.SendAsync(ipPort, Encoding.UTF8.GetBytes(userInput)).Result;
Console.WriteLine(success);
break;
case "remove":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
server.DisconnectClient(ipPort);
break;
case "psk":
server.PresharedKey = InputString("Preshared key:", "1234567812345678", false);
break;
case "debug":
server.Debug = !server.Debug;
Console.WriteLine("Debug set to: " + server.Debug);
break;
default:
break;
}
}
}
static void Main(string[] args)
{
server = new WatsonTcpServer("127.0.0.1", 9000);
server.Events.ClientConnected += ServerClientConnected;
server.Events.ClientDisconnected += ServerClientDisconnected;
server.Events.MessageReceived += ServerMessageReceived;
// server.StreamReceived = ServerStreamReceived;
// server.Debug = true;
server.Start();
client = new WatsonTcpClient("127.0.0.1", 9000);
client.Events.ServerConnected += ServerConnected;
client.Events.ServerDisconnected += ServerDisconnected;
client.Events.MessageReceived += MessageReceived;
// client.Events.StreamReceived = StreamReceived;
// client.Debug = true;
client.Start();
int msgSize = (1024 * 128);
Console.Write("Message size (default 128KB): ");
string userInput = Console.ReadLine();
if (!String.IsNullOrEmpty(userInput))
{
msgSize = Convert.ToInt32(userInput);
}
int msgCount = 4;
Console.Write("Message count (default 4): ");
userInput = Console.ReadLine();
if (!String.IsNullOrEmpty(userInput))
{
msgCount = Convert.ToInt32(userInput);
}
Console.WriteLine("");
Console.WriteLine("---");
Console.WriteLine("Sending messages from client to server...");
for (int i = 0; i < msgCount; i++)
{
string randomString = RandomString(msgSize);
string md5 = Md5(randomString);
Console.WriteLine("Client sending " + msgSize + " bytes: MD5 " + md5);
client.Send(Encoding.UTF8.GetBytes(randomString));
}
Console.WriteLine("");
Console.WriteLine("---");
string ipPort = server.ListClients().ToList()[0];
Console.WriteLine("Sending messages from server to client " + ipPort + "...");
for (int i = 0; i < msgCount; i++)
{
string randomString = RandomString(msgSize);
string md5 = Md5(randomString);
Console.WriteLine("Server sending " + msgSize + " bytes: MD5 " + md5);
server.Send(ipPort, Encoding.UTF8.GetBytes(randomString));
}
Console.WriteLine("");
Console.WriteLine("---");
Console.WriteLine("Press ENTER to exit");
Console.ReadLine();
server.Dispose();
client.Dispose();
}
static void Main(string[] args)
{
Console.Write("Server IP : ");
serverIp = Console.ReadLine();
Console.Write("Server Port : ");
serverPort = Convert.ToInt32(Console.ReadLine());
WatsonTcpServer server = new WatsonTcpServer(serverIp, serverPort, 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");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "list":
clients = 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.Send(ipPort, Encoding.UTF8.GetBytes(userInput));
break;
default:
break;
}
}
}
private static void Main(string[] args)
{
serverIp = InputString("Server IP:", "127.0.0.1", false);
serverPort = InputInteger("Server port:", 9000, true, false);
useSsl = InputBoolean("Use SSL:", false);
try
{
if (!useSsl)
{
server = new WatsonTcpServer(serverIp, serverPort);
}
else
{
certFile = InputString("Certificate file:", "test.pfx", false);
certPass = InputString("Certificate password:"******"password", false);
acceptInvalidCerts = InputBoolean("Accept invalid certs:", true);
mutualAuthentication = InputBoolean("Mutually authenticate:", false);
server = new WatsonTcpServer(serverIp, serverPort, certFile, certPass);
server.AcceptInvalidCertificates = acceptInvalidCerts;
server.MutuallyAuthenticate = mutualAuthentication;
}
server.ClientConnected += ClientConnected;
server.ClientDisconnected += ClientDisconnected;
server.MessageReceived += MessageReceived;
server.SyncRequestReceived = SyncRequestReceived;
// server.PresharedKey = "0000000000000000";
// server.IdleClientTimeoutSeconds = 10;
server.Logger = Logger;
server.DebugMessages = debugMessages;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
return;
}
// server.Start();
Task serverStart = server.StartAsync();
bool runForever = true;
List <string> clients;
string ipPort;
Dictionary <object, object> metadata;
bool success = false;
while (runForever)
{
string userInput = InputString("Command [? for help]:", null, false);
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(" dispose dispose of the connection");
Console.WriteLine(" send send message to client");
Console.WriteLine(" send md send message with metadata to client");
Console.WriteLine(" sendasync send message to a client asynchronously");
Console.WriteLine(" sendasync md send message with metadata to a client asynchronously");
Console.WriteLine(" sendandwait send message and wait for a response");
Console.WriteLine(" sendempty send empty message with metadata");
Console.WriteLine(" sendandwait empty send empty message with metadata and wait for a response");
Console.WriteLine(" remove disconnect client");
Console.WriteLine(" psk set preshared key");
Console.WriteLine(" stats display server statistics");
Console.WriteLine(" stats reset reset statistics other than start time and uptime");
Console.WriteLine(" comp set the compression type, currently: " + server.Compression.ToString());
Console.WriteLine(" debug enable/disable debug (currently " + server.DebugMessages + ")");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "list":
clients = server.ListClients().ToList();
if (clients != null && clients.Count > 0)
{
Console.WriteLine("Clients");
foreach (string curr in clients)
{
Console.WriteLine(" " + curr);
}
}
else
{
Console.WriteLine("None");
}
break;
case "dispose":
server.Dispose();
break;
case "send":
ipPort = InputString("IP:port:", lastIpPort, false);
userInput = InputString("Data:", null, false);
if (!server.Send(ipPort, userInput))
{
Console.WriteLine("Failed");
}
break;
case "send md":
ipPort = InputString("IP:port:", lastIpPort, false);
userInput = InputString("Data:", null, false);
metadata = InputDictionary();
if (!server.Send(ipPort, metadata, userInput))
{
Console.WriteLine("Failed");
}
Console.WriteLine(success);
break;
case "send md large":
ipPort = InputString("IP:port:", lastIpPort, false);
metadata = new Dictionary <object, object>();
for (int i = 0; i < 100000; i++)
{
metadata.Add(i, i);
}
if (!server.Send(ipPort, metadata, "Hello!"))
{
Console.WriteLine("Failed");
}
break;
case "sendasync":
ipPort = InputString("IP:port:", lastIpPort, false);
userInput = InputString("Data:", null, false);
success = server.SendAsync(ipPort, Encoding.UTF8.GetBytes(userInput)).Result;
if (!success)
{
Console.WriteLine("Failed");
}
break;
case "sendasync md":
ipPort = InputString("IP:port:", lastIpPort, false);
userInput = InputString("Data:", null, false);
metadata = InputDictionary();
success = server.SendAsync(ipPort, metadata, Encoding.UTF8.GetBytes(userInput)).Result;
if (!success)
{
Console.WriteLine("Failed");
}
break;
case "sendandwait":
SendAndWait();
break;
case "sendempty":
ipPort = InputString("IP:port:", lastIpPort, false);
metadata = InputDictionary();
if (!server.Send(ipPort, metadata))
{
Console.WriteLine("Failed");
}
break;
case "sendandwait empty":
SendAndWaitEmpty();
break;
case "remove":
ipPort = InputString("IP:port:", lastIpPort, false);
server.DisconnectClient(ipPort);
break;
case "psk":
server.PresharedKey = InputString("Preshared key:", "1234567812345678", false);
break;
case "stats":
Console.WriteLine(server.Stats.ToString());
break;
case "stats reset":
server.Stats.Reset();
break;
case "comp":
server.Compression = (CompressionType)(Enum.Parse(typeof(CompressionType), InputString("Compression [None|Default|Gzip]:", "None", false)));
break;
case "debug":
server.DebugMessages = !server.DebugMessages;
Console.WriteLine("Debug set to: " + server.DebugMessages);
break;
default:
break;
}
}
}
private static void Main(string[] args)
{
serverIp = InputString("Server IP:", "127.0.0.1", false);
serverPort = InputInteger("Server port:", 9000, true, false);
useSsl = InputBoolean("Use SSL:", false);
if (!useSsl)
{
server = new WatsonTcpServer(serverIp, serverPort);
}
else
{
certFile = InputString("Certificate file:", "test.pfx", false);
certPass = InputString("Certificate password:"******"password", false);
acceptInvalidCerts = InputBoolean("Accept Invalid Certs:", true);
mutualAuthentication = InputBoolean("Mutually authenticate:", true);
server = new WatsonTcpServer(serverIp, serverPort, certFile, certPass);
server.AcceptInvalidCertificates = acceptInvalidCerts;
server.MutuallyAuthenticate = mutualAuthentication;
}
server.ClientConnected += ClientConnected;
server.ClientDisconnected += ClientDisconnected;
server.StreamReceived += StreamReceived;
server.SyncRequestReceived = SyncRequestReceived;
server.Logger = Logger;
// server.Debug = true;
server.Start();
bool runForever = true;
while (runForever)
{
Console.Write("Command [? for help]: ");
string userInput = Console.ReadLine();
byte[] data = null;
MemoryStream ms = null;
Dictionary <object, object> metadata;
bool success = false;
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(" send md send message with metadata to client");
Console.WriteLine(" sendasync send message to a client asynchronously");
Console.WriteLine(" sendasync md send message with metadata to a client asynchronously");
Console.WriteLine(" sendandwait send message and wait for a response");
Console.WriteLine(" remove disconnect client");
Console.WriteLine(" psk set preshared key");
Console.WriteLine(" debug enable/disable debug (currently " + server.DebugMessages + ")");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "list":
clients = server.ListClients().ToList();
if (clients != null && clients.Count > 0)
{
Console.WriteLine("Clients");
foreach (string curr in clients)
{
Console.WriteLine(" " + curr);
}
}
else
{
Console.WriteLine("None");
}
break;
case "send":
ipPort = InputString("IP:port:", lastIpPort, false);
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
data = Encoding.UTF8.GetBytes(userInput);
ms = new MemoryStream(data);
success = server.Send(ipPort, data.Length, ms);
Console.WriteLine(success);
break;
case "send md":
ipPort = InputString("IP:port:", lastIpPort, false);
metadata = InputDictionary();
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
data = Encoding.UTF8.GetBytes(userInput);
ms = new MemoryStream(data);
success = server.Send(ipPort, metadata, data.Length, ms);
Console.WriteLine(success);
break;
case "sendasync":
ipPort = InputString("IP:port:", lastIpPort, false);
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
data = Encoding.UTF8.GetBytes(userInput);
ms = new MemoryStream(data);
success = server.SendAsync(ipPort, data.Length, ms).Result;
Console.WriteLine(success);
break;
case "sendasync md":
ipPort = InputString("IP:port:", lastIpPort, false);
metadata = InputDictionary();
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
data = Encoding.UTF8.GetBytes(userInput);
ms = new MemoryStream(data);
success = server.SendAsync(ipPort, metadata, data.Length, ms).Result;
Console.WriteLine(success);
break;
case "sendandwait":
SendAndWait();
break;
case "remove":
ipPort = InputString("IP:port:", lastIpPort, false);
server.DisconnectClient(ipPort);
break;
case "psk":
server.PresharedKey = InputString("Preshared key:", "1234567812345678", false);
break;
case "debug":
server.DebugMessages = !server.DebugMessages;
Console.WriteLine("Debug set to: " + server.DebugMessages);
break;
default:
break;
}
}
}
private static void Main(string[] args)
{
_ServerIp = InputString("Server IP:", "localhost", false);
_ServerPort = InputInteger("Server port:", 9000, true, false);
_Ssl = InputBoolean("Use SSL:", false);
try
{
if (!_Ssl)
{
_Server = new WatsonTcpServer(_ServerIp, _ServerPort);
}
else
{
_CertFile = InputString("Certificate file:", "test.pfx", false);
_CertPass = InputString("Certificate password:"******"password", false);
_AcceptInvalidCerts = InputBoolean("Accept invalid certs:", true);
_MutualAuth = InputBoolean("Mutually authenticate:", false);
_Server = new WatsonTcpServer(_ServerIp, _ServerPort, _CertFile, _CertPass);
_Server.Settings.AcceptInvalidCertificates = _AcceptInvalidCerts;
_Server.Settings.MutuallyAuthenticate = _MutualAuth;
}
_Server.Events.ClientConnected += ClientConnected;
_Server.Events.ClientDisconnected += ClientDisconnected;
_Server.Events.MessageReceived += MessageReceived;
_Server.Events.ServerStarted += ServerStarted;
_Server.Events.ServerStopped += ServerStopped;
_Server.Callbacks.SyncRequestReceived = SyncRequestReceived;
// _Server.Settings.IdleClientTimeoutSeconds = 10;
// _Server.Settings.PresharedKey = "0000000000000000";
_Server.Settings.Logger = Logger;
_Server.Settings.DebugMessages = _DebugMessages;
_Server.Keepalive.EnableTcpKeepAlives = true;
_Server.Keepalive.TcpKeepAliveInterval = 1;
_Server.Keepalive.TcpKeepAliveTime = 1;
_Server.Keepalive.TcpKeepAliveRetryCount = 3;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
return;
}
_Server.Start();
bool runForever = true;
List <string> clients;
string ipPort;
Dictionary <object, object> metadata;
bool success = false;
while (runForever)
{
string userInput = InputString("Command [? for help]:", null, false);
switch (userInput)
{
case "?":
bool listening = (_Server != null ? _Server.IsListening : false);
Console.WriteLine("Available commands:");
Console.WriteLine(" ? help (this menu)");
Console.WriteLine(" q quit");
Console.WriteLine(" cls clear screen");
Console.WriteLine(" start start listening for connections (listening: " + listening.ToString() + ")");
Console.WriteLine(" stop stop listening for connections (listening: " + listening.ToString() + ")");
Console.WriteLine(" list list clients");
Console.WriteLine(" dispose dispose of the server");
Console.WriteLine(" send send message to client");
Console.WriteLine(" send md send message with metadata to client");
Console.WriteLine(" sendasync send message to a client asynchronously");
Console.WriteLine(" sendasync md send message with metadata to a client asynchronously");
Console.WriteLine(" sendandwait send message and wait for a response");
Console.WriteLine(" sendempty send empty message with metadata");
Console.WriteLine(" sendandwait empty send empty message with metadata and wait for a response");
Console.WriteLine(" remove disconnect client");
Console.WriteLine(" remove all disconnect all clients");
Console.WriteLine(" psk set preshared key");
Console.WriteLine(" stats display server statistics");
Console.WriteLine(" stats reset reset statistics other than start time and uptime");
Console.WriteLine(" debug enable/disable debug");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "start":
_Server.Start();
break;
case "stop":
_Server.Stop();
break;
case "list":
clients = _Server.ListClients().ToList();
if (clients != null && clients.Count > 0)
{
Console.WriteLine("Clients");
foreach (string curr in clients)
{
Console.WriteLine(" " + curr);
}
}
else
{
Console.WriteLine("None");
}
break;
case "dispose":
_Server.Dispose();
break;
case "send":
ipPort = InputString("IP:port:", _LastIpPort, false);
userInput = InputString("Data:", null, false);
if (!_Server.Send(ipPort, userInput))
{
Console.WriteLine("Failed");
}
break;
case "send10":
ipPort = InputString("IP:port:", _LastIpPort, false);
userInput = InputString("Data:", null, false);
for (int i = 0; i < 10; i++)
{
Console.WriteLine("Sending " + i);
if (!_Server.Send(ipPort, userInput + "[" + i.ToString() + "]"))
{
Console.WriteLine("Failed");
}
}
break;
case "send md":
ipPort = InputString("IP:port:", _LastIpPort, false);
userInput = InputString("Data:", null, false);
metadata = InputDictionary();
if (!_Server.Send(ipPort, userInput, metadata))
{
Console.WriteLine("Failed");
}
break;
case "send md large":
ipPort = InputString("IP:port:", _LastIpPort, false);
metadata = new Dictionary <object, object>();
for (int i = 0; i < 100000; i++)
{
metadata.Add(i, i);
}
if (!_Server.Send(ipPort, "Hello!", metadata))
{
Console.WriteLine("Failed");
}
break;
case "sendasync":
ipPort = InputString("IP:port:", _LastIpPort, false);
userInput = InputString("Data:", null, false);
success = _Server.SendAsync(ipPort, Encoding.UTF8.GetBytes(userInput)).Result;
if (!success)
{
Console.WriteLine("Failed");
}
break;
case "sendasync md":
ipPort = InputString("IP:port:", _LastIpPort, false);
userInput = InputString("Data:", null, false);
metadata = InputDictionary();
success = _Server.SendAsync(ipPort, Encoding.UTF8.GetBytes(userInput), metadata).Result;
if (!success)
{
Console.WriteLine("Failed");
}
break;
case "sendandwait":
SendAndWait();
break;
case "sendempty":
ipPort = InputString("IP:port:", _LastIpPort, false);
metadata = InputDictionary();
if (!_Server.Send(ipPort, "", metadata))
{
Console.WriteLine("Failed");
}
break;
case "sendandwait empty":
SendAndWaitEmpty();
break;
case "remove":
ipPort = InputString("IP:port:", _LastIpPort, false);
_Server.DisconnectClient(ipPort);
break;
case "remove all":
_Server.DisconnectClients();
break;
case "psk":
_Server.Settings.PresharedKey = InputString("Preshared key:", "1234567812345678", false);
break;
case "stats":
Console.WriteLine(_Server.Statistics.ToString());
break;
case "stats reset":
_Server.Statistics.Reset();
break;
case "debug":
_Server.Settings.DebugMessages = !_Server.Settings.DebugMessages;
Console.WriteLine("Debug set to: " + _Server.Settings.DebugMessages);
break;
default:
break;
}
}
}
private static void Main(string[] args)
{
serverIp = InputString("Server IP:", "127.0.0.1", false);
serverPort = InputInteger("Server port:", 9000, true, false);
useSsl = InputBoolean("Use SSL:", false);
try
{
if (!useSsl)
{
server = new WatsonTcpServer(serverIp, serverPort);
}
else
{
certFile = InputString("Certificate file:", "test.pfx", false);
certPass = InputString("Certificate password:"******"password", false);
acceptInvalidCerts = InputBoolean("Accept invalid certs:", true);
mutualAuthentication = InputBoolean("Mutually authenticate:", false);
server = new WatsonTcpServer(serverIp, serverPort, certFile, certPass);
server.AcceptInvalidCertificates = acceptInvalidCerts;
server.MutuallyAuthenticate = mutualAuthentication;
}
server.ClientConnected += ClientConnected;
server.ClientDisconnected += ClientDisconnected;
server.MessageReceived += MessageReceived;
// server.IdleClientTimeoutSeconds = 10;
server.Logger = Logger;
server.DebugMessages = debug;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
return;
}
// server.Start();
Task serverStart = server.StartAsync();
bool runForever = true;
while (runForever)
{
Console.Write("Command [? for help]: ");
string userInput = Console.ReadLine();
List <string> clients;
string ipPort;
Dictionary <object, object> metadata;
bool success = false;
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(" dispose dispose of the connection");
Console.WriteLine(" send send message to client");
Console.WriteLine(" send md send message with metadata to client");
Console.WriteLine(" sendasync send message to a client asynchronously");
Console.WriteLine(" sendasync md send message with metadata to a client asynchronously");
Console.WriteLine(" remove disconnect client");
Console.WriteLine(" psk set preshared key");
Console.WriteLine(" stats display server statistics");
Console.WriteLine(" stats reset reset statistics other than start time and uptime");
Console.WriteLine(" conn show connection count");
Console.WriteLine(" max set max connections (currently " + server.MaxConnections + ")");
Console.WriteLine(" debug enable/disable debug (currently " + server.DebugMessages + ")");
break;
case "q":
runForever = false;
break;
case "cls":
Console.Clear();
break;
case "list":
clients = server.ListClients().ToList();
if (clients != null && clients.Count > 0)
{
Console.WriteLine("Clients");
foreach (string curr in clients)
{
Console.WriteLine(" " + curr);
}
}
else
{
Console.WriteLine("None");
}
break;
case "dispose":
server.Dispose();
break;
case "send":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
if (String.IsNullOrEmpty(ipPort))
{
break;
}
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
success = server.Send(ipPort, Encoding.UTF8.GetBytes(userInput));
Console.WriteLine(success);
break;
case "send md":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
if (String.IsNullOrEmpty(ipPort))
{
break;
}
metadata = InputDictionary();
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
success = server.Send(ipPort, metadata, Encoding.UTF8.GetBytes(userInput));
Console.WriteLine(success);
break;
case "sendasync":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
if (String.IsNullOrEmpty(ipPort))
{
break;
}
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
success = server.SendAsync(ipPort, Encoding.UTF8.GetBytes(userInput)).Result;
Console.WriteLine(success);
break;
case "sendasync md":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
if (String.IsNullOrEmpty(ipPort))
{
break;
}
metadata = InputDictionary();
Console.Write("Data: ");
userInput = Console.ReadLine();
if (String.IsNullOrEmpty(userInput))
{
break;
}
success = server.SendAsync(ipPort, metadata, Encoding.UTF8.GetBytes(userInput)).Result;
Console.WriteLine(success);
break;
case "remove":
Console.Write("IP:Port: ");
ipPort = Console.ReadLine();
server.DisconnectClient(ipPort);
break;
case "psk":
server.PresharedKey = InputString("Preshared key:", "1234567812345678", false);
break;
case "stats":
Console.WriteLine(server.Stats.ToString());
break;
case "stats reset":
server.Stats.Reset();
break;
case "conn":
Console.WriteLine("Connections: " + server.Connections);
break;
case "max":
server.MaxConnections = InputInteger("Max connections:", 4096, true, false);
break;
case "debug":
server.DebugMessages = !server.DebugMessages;
Console.WriteLine("Debug set to: " + server.DebugMessages);
break;
default:
break;
}
}
}
public bool MessageReceived(string ipPort, byte[] data)
{
Object receivedObject = new Object();
if (data != null && data.Length > 0)
{
receivedObject = ByteArrayToObject(data);
messageEdit.MaskBox.AppendText(DateTime.Now + " Client: " + ipPort + ", command: " + ((PacketDTO)receivedObject).typeCommand + Environment.NewLine);
}
switch (((PacketDTO)receivedObject).typeCommand)
{
//case Utils.Command.Get_server_plc_db1:
// plc = new Plc(CpuType.S71200, "192.168.1.54", 0, 1);
// plc.Open();
// str = string.Empty;
// for (int i = 0; i < 254; i++)
// str += "\0";
// tagDto = new TagDTO();
// tagDto.CurrentWeight = Math.Round(((uint)plc.Read("DB1.DBD0.0")).ConvertToDouble(), 2);
// tagDto.OldWeight = ((uint)plc.Read("DB1.DBD4.0")).ConvertToDouble();
// tagDto.CellNumber = ((ushort)plc.Read("DB1.DBW8.0")).ConvertToShort();
// tagDto.PLCLoadStatus = ((ushort)plc.Read("DB1.DBW10.0")).ConvertToShort();
// tagDto.PLCSetOpen = ((ushort)plc.Read("DB1.DBW12.0")).ConvertToShort();
// tagDto.PLCSetClose = ((ushort)plc.Read("DB1.DBW14.0")).ConvertToShort();
// tagDto.PLCDropoffWind = ((ushort)plc.Read("DB1.DBW16.0")).ConvertToShort();
// tagDto.Error = (bool)plc.Read("DB1.DBX18.0");
// tagDto.ErrorList = S7.Net.Types.String.FromByteArray(ReadMultipleBytes(plc, 9, 1, 22));
// tagDto.Reset = (bool)plc.Read("DB1.DBX276.0");
// currentPacket = new PacketDTO(Utils.Command.Get_server_plc_db1, Convert.ToString(DateTime.Now), ObjectToByteArray((Object)tagDto));
// server.Send(ipPort, ObjectToByteArray((Object)currentPacket));
// break;
//case Utils.Command.Get_server_plc_db27:
// plc = new Plc(CpuType.S71200, "192.168.1.54", 0, 1);
// plc.Open();
// str = string.Empty;
// for (int i = 0; i < 254; i++)
// str += "\0";
// tagDto = new TagDTO();
// tagDto.CurrentWeight = Math.Round(((uint)plc.Read("DB27.DBD0.0")).ConvertToDouble(), 2);
// tagDto.OldWeight = ((uint)plc.Read("DB27.DBD4.0")).ConvertToDouble();
// tagDto.CellNumber = ((ushort)plc.Read("DB27.DBW8.0")).ConvertToShort();
// tagDto.PLCLoadStatus = ((ushort)plc.Read("DB27.DBW10.0")).ConvertToShort();
// tagDto.PLCSetOpen = ((ushort)plc.Read("DB27.DBW12.0")).ConvertToShort();
// tagDto.PLCSetClose = ((ushort)plc.Read("DB27.DBW14.0")).ConvertToShort();
// tagDto.PLCDropoffWind = ((ushort)plc.Read("DB27.DBW16.0")).ConvertToShort();
// tagDto.Error = (bool)plc.Read("DB27.DBX18.0");
// tagDto.ErrorList = S7.Net.Types.String.FromByteArray(ReadMultipleBytes(plc, 9, 1, 22));
// tagDto.Reset = (bool)plc.Read("DB27.DBX276.0");
// currentPacket = new PacketDTO(Utils.Command.Get_server_plc_db27, Convert.ToString(DateTime.Now), ObjectToByteArray((Object)tagDto));
// server.Send(ipPort, ObjectToByteArray((Object)currentPacket));
// break;
//case Utils.Command.Get_server_plc_db28:
// plc = new Plc(CpuType.S71200, "192.168.1.54", 0, 1);
// plc.Open();
// str = string.Empty;
// for (int i = 0; i < 254; i++)
// str += "\0";
// tagDto = new TagDTO();
// tagDto.CurrentWeight = Math.Round(((uint)plc.Read("DB28.DBD0.0")).ConvertToDouble(), 2);
// tagDto.OldWeight = ((uint)plc.Read("DB28.DBD4.0")).ConvertToDouble();
// tagDto.CellNumber = ((ushort)plc.Read("DB28.DBW8.0")).ConvertToShort();
// tagDto.PLCLoadStatus = ((ushort)plc.Read("DB28.DBW10.0")).ConvertToShort();
// tagDto.PLCSetOpen = ((ushort)plc.Read("DB28.DBW12.0")).ConvertToShort();
// tagDto.PLCSetClose = ((ushort)plc.Read("DB28.DBW14.0")).ConvertToShort();
// tagDto.PLCDropoffWind = ((ushort)plc.Read("DB28.DBW16.0")).ConvertToShort();
// tagDto.Error = (bool)plc.Read("DB28.DBX18.0");
// tagDto.ErrorList = S7.Net.Types.String.FromByteArray(ReadMultipleBytes(plc, 9, 1, 22));
// tagDto.Reset = (bool)plc.Read("DB28.DBX276.0");
// currentPacket = new PacketDTO(Utils.Command.Get_server_plc_db28, Convert.ToString(DateTime.Now), ObjectToByteArray((Object)tagDto));
// server.Send(ipPort, ObjectToByteArray((Object)currentPacket));
// break;
//case Utils.Command.Get_server_plc_db29:
// plc = new Plc(CpuType.S71200, "192.168.1.54", 0, 1);
// plc.Open();
// str = string.Empty;
// for (int i = 0; i < 254; i++)
// str += "\0";
// tagDto = new TagDTO();
// tagDto.CurrentWeight = Math.Round(((uint)plc.Read("DB29.DBD0.0")).ConvertToDouble(), 2);
// tagDto.OldWeight = ((uint)plc.Read("DB29.DBD4.0")).ConvertToDouble();
// tagDto.CellNumber = ((ushort)plc.Read("DB29.DBW8.0")).ConvertToShort();
// tagDto.PLCLoadStatus = ((ushort)plc.Read("DB29.DBW10.0")).ConvertToShort();
// tagDto.PLCSetOpen = ((ushort)plc.Read("DB29.DBW12.0")).ConvertToShort();
// tagDto.PLCSetClose = ((ushort)plc.Read("DB29.DBW14.0")).ConvertToShort();
// tagDto.PLCDropoffWind = ((ushort)plc.Read("DB29.DBW16.0")).ConvertToShort();
// tagDto.Error = (bool)plc.Read("DB29.DBX18.0");
// tagDto.ErrorList = S7.Net.Types.String.FromByteArray(ReadMultipleBytes(plc, 9, 1, 22));
// tagDto.Reset = (bool)plc.Read("DB29.DBX276.0");
// currentPacket = new PacketDTO(Utils.Command.Get_server_plc_db29, Convert.ToString(DateTime.Now), ObjectToByteArray((Object)tagDto));
// server.Send(ipPort, ObjectToByteArray((Object)currentPacket));
//break;
default:
//currentPacket = new PacketDTO(Utils.Command.Not_correct_command, "Не поддерживаемая команда", null);
server.Send(ipPort, ObjectToByteArray((Object)currentPacket));
break;
}
messageEdit.MaskBox.AppendText(DateTime.Now + " Message from: " + ipPort + ", " + ((PacketDTO)receivedObject).message + Environment.NewLine);
return(true);
}
