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()); } }