public void ConnectToServer()
{
tcpClient = new WatsonTcpClient(serverip, 8901);
tcpClient.MessageReceived += MessageReceived;
tcpClient.ServerDisconnected += _ServerDisconnected;
try
{
Console.Out.WriteLine("[Client] Trying to connect to server with ip: " + serverip);
tcpClient.Start();
}
catch (SocketException e)
{
Console.Out.WriteLine(e);
}
if (tcpClient.Connected)
{
Console.Out.WriteLine("[Client] Connection sucessful");
ServerConnected(this, new EventArgs());
StopUDP();
}
else
{
Console.Out.WriteLine("[Client] Connection failed");
}
}
private static void InitSocketClient()
{
WatsonTcpClient client = new WatsonTcpClient(SERVER, Port)
{
ServerConnected = ServerConnected,
ServerDisconnected = ServerDisconnected,
MessageReceived = MessageReceived,
Debug = false
};
client.Start();
bool runForever = true;
do
{
if (ObjectQueue.Count > 0 && ObjectQueue.TryDequeue(out var @object))
{
if (@object is ColoredMessage)
{
var coloredMsg = @object as ColoredMessage;
client.Send(coloredMsg.Message, coloredMsg.Color);
}
}
Thread.Sleep(100);
}while (runForever);
}
private void connectServerBtn_Click(object sender, EventArgs e)
{
if (client == null)
{
try
{
client = new WatsonTcpClient(serverIp, 9000, ServerConnected, ServerDisconnected, MessageReceived, true);
if (client != null)
{
client.Send(ObjectToByteArray(new PacketDTO(Utils.TypeCommand.Control, Utils.ControlCommand.Connected, Convert.ToInt32(idPlcEdit.EditValue), Convert.ToString(namePlcEdit.EditValue), Convert.ToInt32(idDbEdit.EditValue), Convert.ToString(nameDbEdit.EditValue), null, null)));
connectServerBtn.Enabled = false;
disconnectServerBtn.Enabled = true;
}
else
{
MessageBox.Show("Помилка авторизації на сервері", "Внимание", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
catch (Exception ex)
{
MessageBox.Show("Ошибка при подключении к серверу.\n" + ex.Message, "Внимание", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
}
public Task SetupConnection()
{
return(TSetupConnection());
logger.Warn("Connecting to API " + connectionInfo);
if (connectionInfo.IsValid())
{
// TODO: Find a way to WAIT for the miner to open its port before starting the API Connection
// Perhaps call SetupConnection on keyword identification in the Command.cs file (where it parses each line)
Task.Run(async() =>
{
// Wait a bit for the API to boot
await Task.Delay(refreshRate);
try
{
client = new WatsonTcpClient(connectionInfo.host, connectionInfo.port, Client_OnConnected, Client_OnDisconnected, Client_OnMessageReceived, true);
await RefreshData(cts.Token);
}
catch (Exception e)
{
logger.Error("An error occured while connecting to the miner's API");
logger.Error(e);
tcs.SetResult(false);
}
});
}
return(tcs.Task);
}
private static void InitializeClient()
{
serverIp = InputString("Server IP:", "127.0.0.1", false);
serverPort = InputInteger("Server port:", 9000, true, false);
useSsl = InputBoolean("Use SSL:", false);
if (!useSsl)
{
client = new WatsonTcpClient(serverIp, serverPort);
}
else
{
bool supplyCert = InputBoolean("Supply SSL certificate:", false);
if (supplyCert)
{
certFile = InputString("Certificate file:", "test.pfx", false);
certPass = InputString("Certificate password:"******"password", false);
}
acceptInvalidCerts = InputBoolean("Accept invalid certs:", true);
mutualAuthentication = InputBoolean("Mutually authenticate:", false);
client = new WatsonTcpClient(serverIp, serverPort, certFile, certPass);
client.AcceptInvalidCertificates = acceptInvalidCerts;
client.MutuallyAuthenticate = mutualAuthentication;
}
client.Debug = debug;
ConnectClient();
}
static void Main(string[] args)
{
Task.Run(() =>
{
WatsonTcpClient client = new WatsonTcpClient("10.1.2.3", 1234); // NonExistant Server
client.ServerConnected += HandleServerConnected;
client.ServerDisconnected += HandleServerDisconnected;
client.MessageReceived += HandleMessageReceived;
try
{
Console.WriteLine("Starting Client");
client.Start();
}
catch (Exception ex)
{
Console.WriteLine("Exception: {0}", ex.Message);
client.Dispose();
}
});
Console.WriteLine("Waiting on NullReferenceException");
Thread.Sleep(10000);
}
private static void InitializeClient()
{
if (!useSsl)
{
client = new WatsonTcpClient(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);
client = new WatsonTcpClient(serverIp, serverPort, certFile, certPass);
client.Settings.AcceptInvalidCertificates = acceptInvalidCerts;
client.Settings.MutuallyAuthenticate = mutualAuthentication;
}
client.Callbacks.AuthenticationRequested = AuthenticationRequested;
client.Events.AuthenticationFailure += AuthenticationFailure;
client.Events.AuthenticationSucceeded += AuthenticationSucceeded;
client.Events.ServerConnected += ServerConnected;
client.Events.ServerDisconnected += ServerDisconnected;
client.Events.StreamReceived += StreamReceived;
client.Callbacks.SyncRequestReceived = SyncRequestReceived;
client.Settings.Logger = Logger;
// client.Debug = true;
client.Connect();
}
private static void ConnectClient()
{
if (client != null)
{
client.Dispose();
}
if (!useSsl)
{
client = new WatsonTcpClient(serverIp, serverPort);
}
else
{
client = new WatsonTcpClient(serverIp, serverPort, certFile, certPass);
client.AcceptInvalidCertificates = acceptInvalidCerts;
client.MutuallyAuthenticate = mutualAuthentication;
}
client.AuthenticationFailure = AuthenticationFailure;
client.AuthenticationRequested = AuthenticationRequested;
client.AuthenticationSucceeded = AuthenticationSucceeded;
client.ServerConnected = ServerConnected;
client.ServerDisconnected = ServerDisconnected;
client.MessageReceived = MessageReceived;
client.MessageReceivedWithMetadata = MessageReceivedWithMetadata;
client.Debug = debug;
// client.Start();
Task startClient = client.StartAsync();
}
static void InitializeClient()
{
if (!useSsl)
{
client = new WatsonTcpClient(serverIp, serverPort);
}
else
{
certFile = Common.InputString("Certificate file:", "test.pfx", false);
certPass = Common.InputString("Certificate password:"******"password", false);
acceptInvalidCerts = Common.InputBoolean("Accept Invalid Certs:", true);
mutualAuthentication = Common.InputBoolean("Mutually authenticate:", true);
client = new WatsonTcpClient(serverIp, serverPort, certFile, certPass);
client.AcceptInvalidCertificates = acceptInvalidCerts;
client.MutuallyAuthenticate = mutualAuthentication;
}
client.AuthenticationFailure = AuthenticationFailure;
client.AuthenticationRequested = AuthenticationRequested;
client.AuthenticationSucceeded = AuthenticationSucceeded;
client.ServerConnected = ServerConnected;
client.ServerDisconnected = ServerDisconnected;
client.MessageReceived = MessageReceived;
client.ReadDataStream = true;
client.ReadStreamBufferSize = 65536;
// client.Debug = true;
client.Start();
}
private static void ConnectClient()
{
if (client != null)
{
client.Dispose();
}
if (!useSsl)
{
client = new WatsonTcpClient(serverIp, serverPort);
}
else
{
client = new WatsonTcpClient(serverIp, serverPort, certFile, certPass);
client.AcceptInvalidCertificates = acceptInvalidCerts;
client.MutuallyAuthenticate = mutualAuthentication;
}
client.AuthenticationFailure = AuthenticationFailure;
client.AuthenticationRequested = AuthenticationRequested;
client.AuthenticationSucceeded = AuthenticationSucceeded;
client.ServerConnected = ServerConnected;
client.ServerDisconnected = ServerDisconnected;
client.MessageReceived = MessageReceived;
client.ReadDataStream = true;
client.ReadStreamBufferSize = 65536;
client.Debug = debug;
client.Start();
}
async Task connect()
{
retry:
try
{
close_connection();
client = new WatsonTcpClient(xip.address, xip.port + 1);
client.Events.MessageReceived += Events_MessageReceived;
await Task.Run(client.Connect);
byte[] bfr = new byte[10];
p_crypto.random.NextBytes(bfr);
var key = a.api2.c_key;
bfr = p_crypto.Encrypt(bfr, key);
m_packet data = new()
{
data = bfr,
deviceid = key.id,
};
bfr = p_crypto.convert(data);
await client.SendAsync(bfr);
time = DateTime.Now;
}
catch
{
goto retry;
}
}
private static void Main(string[] args)
{
rng = new Random((int)DateTime.Now.Ticks);
data = InitByteArray(262144, 0x00);
Console.WriteLine("Data MD5: " + BytesToHex(Md5(data)));
Console.WriteLine("Starting in 3 seconds...");
server = new WatsonTcpServer(null, serverPort);
server.ClientConnected += ServerClientConnected;
server.ClientDisconnected += ServerClientDisconnected;
server.MessageReceived += ServerMsgReceived;
server.Start();
Thread.Sleep(3000);
c = new WatsonTcpClient("localhost", serverPort);
c.ServerConnected += ClientServerConnected;
c.ServerDisconnected += ClientServerDisconnected;
c.MessageReceived += ClientMsgReceived;
c.Start();
Console.WriteLine("Press ENTER to exit");
for (int i = 0; i < clientThreads; i++)
{
Task.Run(() => ClientTask());
}
Console.ReadLine();
}
public Task TSetupConnection()
{
logger.Warn("Connecting to API " + connectionInfo);
if (connectionInfo.IsValid())
{
Task.Run(async() =>
{
// Wait a bit for the API to start
await Task.Delay(refreshRate, cts.Token);
// Create new TCP client
client = new WatsonTcpClient(connectionInfo.host, connectionInfo.port, Client_OnConnected, Client_OnDisconnected, Client_OnMessageReceived, false);
// Start refresh loop
// await RefreshData(cts.Token);
await SendRequest(new Request("summary", ""));
logger.Warn("Done!");
});
}
logger.Warn("AYAYAY");
return(tcs.Task);
}
/// <summary>
/// Start the cluster client.
/// </summary>
/// <param name="serverIp">The IP address of the peer server.</param>
/// <param name="serverPort">The TCP port of the peer server.</param>
/// <param name="debug">Enable or disable debug logging to the console.</param>
/// <param name="clusterHealthy">Function to be called when the cluster becomes healthy.</param>
/// <param name="clusterUnhealthy">Function to be called when the cluster becomes unhealthy.</param>
/// <param name="messageReceived">Function to be called when a message is received from the peer.</param>
public ClusterClient(string serverIp, int serverPort, bool debug, Func <bool> clusterHealthy, Func <bool> clusterUnhealthy, Func <byte[], bool> messageReceived)
{
if (String.IsNullOrEmpty(serverIp))
{
throw new ArgumentNullException(nameof(serverIp));
}
if (serverPort < IPEndPoint.MinPort || serverPort > IPEndPoint.MaxPort)
{
throw new ArgumentOutOfRangeException(nameof(serverPort));
}
if (clusterHealthy == null)
{
throw new ArgumentNullException(nameof(clusterHealthy));
}
if (clusterUnhealthy == null)
{
throw new ArgumentNullException(nameof(clusterUnhealthy));
}
if (messageReceived == null)
{
throw new ArgumentNullException(nameof(messageReceived));
}
ServerIp = serverIp;
ServerPort = serverPort;
Debug = debug;
Wtcp = null;
ClusterHealthy = clusterHealthy;
ClusterUnhealthy = clusterUnhealthy;
MessageReceived = messageReceived;
Task.Run(() => EstablishConnection());
}
private void EstablishConnection()
{
while (true)
{
try
{
if (Wtcp == null)
{
if (Debug)
{
Console.WriteLine("Attempting connection to " + ServerIp + ":" + ServerPort);
}
Wtcp = new WatsonTcpClient(ServerIp, ServerPort, ServerConnected, ServerDisconnected, MsgReceived, Debug);
}
else if (!Wtcp.IsConnected())
{
if (Debug)
{
Console.WriteLine("Attempting reconnect to " + ServerIp + ":" + ServerPort);
}
Wtcp.Dispose();
Wtcp = new WatsonTcpClient(ServerIp, ServerPort, ServerConnected, ServerDisconnected, MsgReceived, Debug);
}
Thread.Sleep(1000);
}
catch (Exception e)
{
if (Debug)
{
Console.WriteLine("Exception: " + e.Message);
}
}
}
}
private void Test2ClientWorker()
{
try
{
using (WatsonTcpClient client = new WatsonTcpClient("127.0.0.1", 10000))
{
client.MessageReceived += Test2ClientMsgRcv;
client.Start();
for (int i = 0; i < _NumMessages; i++)
{
if (client.Send(_MsgBytes))
{
_MessagesSentSuccess++;
_MessagesProcessing++;
_BytesSent += _MsgBytes.Length;
}
else
{
_MessagesSentFailed++;
}
}
}
_RunningTasks--;
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.ToString());
}
}
public static bool Send(this WatsonTcpClient client, string msg, Color color)
{
var coloredMsg = new ColoredMessage(color, msg);
return(client.Send(
JsonConvert.SerializeObject(new TypeAdviser(coloredMsg.GetType().FullName))
+ Environment.NewLine +
JsonConvert.SerializeObject(coloredMsg)));
}
internal void Start()
{
string ip = null;
int port = -1;
Common.ParseIpPort(PeerNode.IpPort, out ip, out port);
if (PeerNode.Ssl)
{
_TcpClient = new WatsonTcpClient(
ip,
port,
PeerNode.PfxCertificateFile,
PeerNode.PfxCertificatePassword);
Logger?.Invoke("[MeshClient] Starting TCP client with SSL to connect to " + ip + ":" + port);
}
else
{
_TcpClient = new WatsonTcpClient(
ip,
port);
Logger?.Invoke("[MeshClient] Starting TCP client to connect to " + ip + ":" + port);
}
_TcpClient.AcceptInvalidCertificates = _Settings.AcceptInvalidCertificates;
_TcpClient.MutuallyAuthenticate = _Settings.MutuallyAuthenticate;
_TcpClient.StreamBufferSize = _Settings.StreamBufferSize;
_TcpClient.AuthenticationRequested = MeshClientAuthenticationRequested;
_TcpClient.AuthenticationSucceeded += MeshClientAuthenticationSucceeded;
_TcpClient.AuthenticationFailure += MeshClientAuthenticationFailure;
_TcpClient.ServerConnected += MeshClientServerConnected;
_TcpClient.ServerDisconnected += MeshClientServerDisconnected;
_TcpClient.StreamReceived += MeshClientStreamReceived;
try
{
_TcpClient.Start();
}
catch (SocketException)
{
Task unawaited = Task.Run(() => ReconnectToServer());
ServerDisconnected?.Invoke(this, new ServerConnectionEventArgs(PeerNode));
}
catch (Exception e)
{
Logger?.Invoke("[MeshClient] Client exception: " + Environment.NewLine + Common.SerializeJson(e, true));
Task unawaited = Task.Run(() => ReconnectToServer());
ServerDisconnected?.Invoke(this, new ServerConnectionEventArgs(PeerNode));
}
Logger?.Invoke("[MeshClient] Client started");
}
public void Handle(WatsonTcpClient client, SakontyMessage message)
{
var response = new Dictionary <object, object>();
response.Add("Response", "Invalid");
string invalidResponse = $"Request of type {message.MetaData["Request"] as string} is invalid.";
var data = Encoding.UTF8.GetBytes(invalidResponse);
client.Send(data, response);
}
public ClientForm()
{
InitializeComponent();
label1.Text = "";
_Client = new WatsonTcpClient("127.0.0.1", 9000);
_Client.Events.ServerConnected += ServerConnected;
_Client.Events.ServerDisconnected += ServerDisconnected;
_Client.Events.AuthenticationFailure += OnAuthenticationFailure;
_Client.Events.MessageReceived += MessageReceived;
_Client.Settings.Logger = Logger;
}
static void ClientTask()
{
WatsonTcpClient c = new WatsonTcpClient("localhost", serverPort, ClientServerConnected, ClientServerDisconnected, ClientMsgReceived, false);
for (int i = 0; i < numIterations; i++)
{
Task.Delay(rng.Next(0, 25)).Wait();
c.Send(data);
}
Console.WriteLine("[client] finished");
}
public static void Connect()
{
try
{
client = new WatsonTcpClient(settings.ServerIp, settings.ServerPort);
client.Events.ServerConnected += ServerConnected;
client.Events.ServerDisconnected += ServerDisconnected;
client.Events.MessageReceived += MessageReceived;
client.Connect();
}
catch (Exception exp) { UCLogsViewModel.TextLogs.Value += "\n" + exp.Message; }
}
/// <summary>
/// Constructor that initializes Joined object based on given TCPSettings.
/// </summary>
/// <param name="c">TCPSettings for Joined work.</param>
public Joined(TCPSettings c)
{
ts = c;
msBeforeTimeOut = ts.msTimeout;
clientH = new WatsonTcpClient(ts.ip, ts.port);
clientH.Events.ServerConnected += JoinedConnected;
clientH.Events.ServerDisconnected += JoinedDisconnected;
clientH.Events.StreamReceived += StreamReceived;
//clientH.Events.MessageReceived += MessageReceived;
//clientH.Callbacks.SyncRequestReceived = SyncRequestReceived;
FileScan(ts.directoryPath);
clientH.Connect();
}
/// <summary>
/// Constructor that initializes Joined object based on given TCPSettings.
/// </summary>
/// <param name="c">TCPSettings for Joined work.</param>
public Joined(TCPSettings c)
{
ts = c;
msBeforeTimeOut = ts.msTimeout;
clientH = new WatsonTcpClient(ts.ip, ts.port);
clientH.Events.ServerConnected += JoinedConnected;
clientH.Events.ServerDisconnected += JoinedDisconnected;
clientH.Events.StreamReceived += StreamReceived;
//clientH.Events.MessageReceived += MessageReceived;
//clientH.Callbacks.SyncRequestReceived = SyncRequestReceived;
UIHandler.StopColorfulBarAnimation();
}
internal void RunTest()
{
using (WatsonTcpServer server = new WatsonTcpServer("127.0.0.1", 10000))
{
server.MessageReceived = Test1ServerMsgRcv;
server.Start();
using (WatsonTcpClient client = new WatsonTcpClient("127.0.0.1", 10000))
{
client.MessageReceived = Test1ClientMsgRcv;
client.Start();
_Stopwatch.Start();
for (int i = 0; i < _NumMessages; i++)
{
if (client.Send(_MsgBytes))
{
_MessageSuccess++;
_BytesSent += _MessageSize;
}
else
{
_MessageFailed++;
}
}
_Stopwatch.Stop();
}
}
Console.WriteLine("");
Console.WriteLine("Results:");
Console.WriteLine(" Messages sent successfully : " + _MessageSuccess);
Console.WriteLine(" Messages failed : " + _MessageFailed);
Console.WriteLine(" Bytes sent successfully : " + _BytesSent);
Console.WriteLine(" Bytes received successfully : " + _BytesReceived);
decimal secondsTotal = _Stopwatch.ElapsedMilliseconds / 1000;
decimal bytesPerSecond = _BytesSent / secondsTotal;
decimal kbPerSecond = bytesPerSecond / 1024;
decimal mbPerSecond = kbPerSecond / 1024;
Console.WriteLine(" Elapsed time (ms) : " + _Stopwatch.ElapsedMilliseconds + "ms");
Console.WriteLine(" Elapsed time (seconds) : " + decimal.Round(secondsTotal, 2) + "s");
Console.WriteLine(" Bytes per second : " + decimal.Round(bytesPerSecond, 2) + "B/s");
Console.WriteLine(" Kilobytes per second : " + decimal.Round(kbPerSecond, 2) + "kB/s");
Console.WriteLine(" Megabytes per second : " + decimal.Round(mbPerSecond, 2) + "MB/s");
Console.WriteLine("");
}
public static void TCPConnect()
{
WatsonTcpClient client = new WatsonTcpClient(serverIp, serverPort, ServerConnected, ServerDisconnected, MessageReceived, true);
var _continue = true;
while (_continue)
{
try
{
int numbytes = _serialPort1.BytesToRead;
byte[] rxbytearray = new byte[numbytes];
for (int i = 0; i < numbytes; i++)
{
rxbytearray[i] = (byte)_serialPort1.ReadByte();
}
if (rxbytearray.Length != 0)
{
if (rxbytearray[0] == (byte)01 && rxbytearray[1] != (byte)0x03)
{
client.Send(Encoding.UTF8.GetBytes("data:" + BitConverter.ToString(rxbytearray).Replace("-", " ")));
text.Invoke((MethodInvoker) delegate
{
if (text.Text.Length > 1024)
{
text.Text = "";
}
// Running on the UI thread
text.Text += BitConverter.ToString(rxbytearray).Replace("-", " ") + "\r\n";
});
}
}
}
catch (TimeoutException)
{
MessageBox.Show("??");
_continue1 = false;
}
}
text.Invoke((MethodInvoker) delegate
{
// Running on the UI thread
text.Text += "A:" + byteToString(null);
});
}
private void btnConectar_Click(object sender, RoutedEventArgs e)
{
try
{
client = new WatsonTcpClient(txtIp.Text, Convert.ToInt32(txtPorta.Text));
client.Events.ServerConnected += Events_ServerConnected;
client.Events.ServerDisconnected += Events_ServerDisconnected;
client.Events.MessageReceived += Events_MessageReceived;
client.Connect();
}
catch (Exception ex)
{
txtHistoricoMensagens.Text += $"Houve um error ao tentar se conectar: {ex.Message}{Environment.NewLine}";
}
}
static void Main(string[] args)
{
try
{
_Client = new WatsonTcpClient("127.0.0.1", 9000);
_Client.Events.MessageReceived += MessageReceived;
_Client.Start();
_Client.Send("Hello!");
_Client.Dispose();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private void close_connection()
{
if (client == null)
{
return;
}
try
{
reset = false;
client.Events.MessageReceived -= Events_MessageReceived;
client.Dispose();
}
catch { }
client = null;
}
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());
}
}
