/// <summary> /// Send a message to the connected server. /// </summary> /// <param name="data">Data to send to the server.</param> /// <returns>True if successful.</returns> internal bool Send(byte[] data) { if (_WtcpClient == null) { if (Debug) { Console.WriteLine("Client is null, cannot send"); } return(false); } if (_WtcpClient.Connected) { _WtcpClient.Send(data); return(true); } else { if (Debug) { Console.WriteLine("Client is not connected, cannot send"); } return(false); } }
private static void ClientTask() { for (int i = 0; i < _NumIterations; i++) { int waitVal = _Random.Next(0, 12); Task.Delay(waitVal).Wait(); if (waitVal % 3 == 0) { Console.WriteLine("[client] " + (i + 1).ToString() + "/" + _NumIterations.ToString() + " Sending large message"); _Client.Send(_DataLargeBytes); } else if (waitVal % 2 == 0) { Console.WriteLine("[client] " + (i + 1).ToString() + "/" + _NumIterations.ToString() + " Sending small message"); _Client.Send(_DataSmallBytes); } else { Console.WriteLine("[client] " + (i + 1).ToString() + "/" + _NumIterations.ToString() + " Send and wait small message"); try { SyncResponse syncResponse = _Client.SendAndWait(_SendAndWaitInterval, _DataSmallBytes); Console.WriteLine("[client] Sync response received"); } catch (Exception e) { Console.WriteLine("[client] Sync response not received: " + e.Message); } } } Console.WriteLine("[client] Finished"); }
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()); } }
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); } } }
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); }
internal bool Send(Dictionary <object, object> metadata, long contentLength, Stream stream) { 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 (_WtcpClient == null) { Logger?.Invoke("[ClusterClient] Client is null, cannot send"); return(false); } if (_WtcpClient.Connected) { return(_WtcpClient.Send(metadata, contentLength, stream)); } else { Logger?.Invoke("[ClusterClient] Client is not connected, cannot send"); return(false); } }
/// <summary> /// Send a message to the connected server. /// </summary> /// <param name="data">Data to send to the server.</param> /// <returns>True if successful.</returns> public bool Send(byte[] data) { if (Wtcp == null) { if (Debug) { Console.WriteLine("Client is null, cannot send"); } return(false); } if (Wtcp.IsConnected()) { Wtcp.Send(data); return(true); } else { if (Debug) { Console.WriteLine("Client is not connected, cannot send"); } return(false); } }
public static void SendMessage(string verCore, string fileName) { try { client.Send(verCore + "^" + fileName); } catch (Exception exp) { UCLogsViewModel.TextLogs.Value += "\n" + exp.Message; } }
internal bool Send(byte[] data) { if (data == null || data.Length < 1) { throw new ArgumentNullException(nameof(data)); } try { return(_TcpClient.Send(data)); } catch (Exception e) { Logger?.Invoke("[MeshClient] Send exception: " + Environment.NewLine + Common.SerializeJson(e, true)); return(false); } }
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))); }
private static void ClientTask() { for (int i = 0; i < numIterations; i++) { Task.Delay(rng.Next(0, 25)).Wait(); c.Send(data); } Console.WriteLine("[client] finished"); }
public void SendMessage(MessageType messageType, string message) { TcpMessage msg = new TcpMessage() { MessageType = messageType, Message = message }; client.Send(JsonConvert.SerializeObject(msg)); }
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); }
private void btnEnviarMensagem_Click(object sender, RoutedEventArgs e) { if (txtMensagem.Text == string.Empty) { return; } client.Send(txtMensagem.Text); txtHistoricoMensagens.Text += $"Eu: {txtMensagem.Text}{Environment.NewLine}"; txtMensagem.Text = string.Empty; }
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"); }
/// <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 rel) { string loc = Filed.GetLocalFromRelative(rel); SyncResponse sr = SendMessage("!catchFile " + rel); using (FileStream fs = new FileStream(loc, FileMode.Open)) { clientH.Send(fs.Length, fs); } UIHandler.WriteLog($"Uploaded {rel}", Color.Green); }
private void startCommandBtn_Click(object sender, EventArgs e) { currentPacket = new PacketDTO((Utils.TypeCommand)commandTypeEdit.EditValue, (Utils.ControlCommand?)commandControlEdit.EditValue, Convert.ToInt32(idPlcEdit.EditValue), Convert.ToString(namePlcEdit.EditValue), Convert.ToInt32(idDbEdit.EditValue), Convert.ToString(nameDbEdit.EditValue), (string)textMessageEdit.EditValue, null); switch (currentPacket.typeCommand) { case Utils.TypeCommand.Control: client.Send(ObjectToByteArray(currentPacket)); break; case Utils.TypeCommand.Inform: client.Send(ObjectToByteArray(currentPacket)); break; default: break; } }
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); }); }
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()); } }
static void Main(string[] args) { if (args != null && args.Length == 2) { _MessageCount = Convert.ToInt32(args[0]); _EntryCount = Convert.ToInt32(args[1]); } _Stopwatches = new Stopwatch[_MessageCount]; using (WatsonTcpServer server = new WatsonTcpServer("127.0.0.1", _ServerPort)) { // server.Settings.DebugMessages = true; // server.Settings.Logger = ServerLogger; server.Events.MessageReceived += ServerMessageReceived; server.Start(); Console.WriteLine("Server started"); Task.Delay(1000).Wait(); using (WatsonTcpClient client = new WatsonTcpClient("127.0.0.1", _ServerPort)) { client.Events.MessageReceived += ClientMessageReceived; client.Connect(); Console.WriteLine("Client connected to server"); for (int i = 0; i < _MessageCount; i++) { Dictionary <object, object> md = new Dictionary <object, object>(); for (int j = 0; j < _EntryCount; j++) { Person p = new Person("hello", "world", i.ToString() + "." + j.ToString()); md.Add("person." + i.ToString() + "." + j.ToString(), p); } client.Send(i.ToString(), md); _Stopwatches[i] = new Stopwatch(); _Stopwatches[i].Start(); Console.WriteLine("Client sent message " + i); } } Console.WriteLine("Press ENTER to exit"); Console.ReadLine(); } }
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()); } }
public static void serverbaglandi(object sender, ConnectionEventArgs args) { Console.WriteLine("Server'e Bağlanıldı: " + args.IpPort); // bağlanıldı eventi Ping png = new Ping(); PingReply prp = png.Send(args.IpPort.Split(':')[0]); string pingzamani = "Belirsiz"; if (prp.Status == IPStatus.Success) { pingzamani = prp.RoundtripTime.ToString(); } client.Send("ekle:" + WindowsIdentity.GetCurrent().Name + ":" + pingzamani + ":" + new ComputerInfo().OSFullName); }
public void TSendRequest(APIConnect.Request request) { logger.Warn("Sending request " + request); logger.Warn("Is client connected? " + client.IsConnected()); // If client isn't connected, no point in trying to send if (!client.IsConnected()) { logger.Warn("Could not send request. Client is not connected."); return; } bool val = client.Send(Encoding.ASCII.GetBytes(request.command)); logger.Warn("Output " + val); }
public void SendMessage(string alias, string data, string ipport, string keypass) { var message = new Dictionary <object, object>(); MessageClient = new WatsonTcpClient(ipport.Split(':')[0], 4999); MessageClient.Events.MessageReceived += Events_MessageReceived1; message.Add("alias", crypto.StringCipher.Encrypt(alias)); message.Add("message", crypto.StringCipher.Encrypt(data)); message.Add("keypass", crypto.StringCipher.Encrypt(keypass)); message.Add("localkeypass", Settings.Default.keypass); MessageClient.Connect(); if (MessageClient.Connected) { MessageClient.Send("message", message); Messages.Add(new Message("To: " + alias, data, ipport.Split(':')[0] + ":" + 4999)); } }
private static void ClientTask() { using (WatsonTcpClient client = new WatsonTcpClient("localhost", serverPort)) { client.ServerConnected = ClientServerConnected; client.ServerDisconnected = ClientServerDisconnected; client.MessageReceived = ClientMsgReceived; client.Start(); for (int i = 0; i < numIterations; i++) { Task.Delay(rng.Next(0, 25)).Wait(); client.Send(data); } } Console.WriteLine("[client] finished"); }
static void ClientTask() { Console.WriteLine("ClientTask entering"); using (WatsonTcpClient client = new WatsonTcpClient("localhost", serverPort, ClientServerConnected, ClientServerDisconnected, ClientMsgReceived, false)) { while (!clientsStarted) { Thread.Sleep(100); } for (int i = 0; i < numIterations; i++) { Task.Delay(rng.Next(0, 1000)).Wait(); client.Send(data); } } Console.WriteLine("[client] finished"); }
private void btnSend_Click(object sender, EventArgs e) { if (demoMode) { if (msgTextBox.Text != "") { mainTextBox.SelectionColor = userColorSys; mainTextBox.AppendText($"{userName}: "); mainTextBox.SelectionColor = Color.Red; mainTextBox.AppendText(msgTextBox.Text + " (Not Delivered)" + "\n"); msgTextBox.Text = ""; } } else { try { Dictionary <object, object> metadata = new Dictionary <object, object>(); metadata.Add(userName, userColor); client.Send(metadata, Encoding.UTF8.GetBytes(msgTextBox.Text)); msgTextBox.Text = ""; } catch (Exception) { MessageBox.Show("A connection to Xalarwse servers was terminated." + "\nAttempting to Reconnect, if unsuccsesful, the program will" + "switch to offline (demo) mode." + "\nContact an administrator or restart application to reconnect.", "Connection Terminated", MessageBoxButtons.OK, MessageBoxIcon.Error); try { client.Start(); } catch (Exception) { this.Text = windowName + " (offline mode)"; demoMode = true; reconnectGroupBox.Visible = true; } } } }
public bool Send <T>(T packet) where T : Packet { if (_offlineMode) { return(false); } 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); _watsonTcpClient.Send(stream.ToArray()); } return(true); }
private void Test2ClientWorker() { 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)) { _MessageSuccess++; _BytesSent += _MsgBytes.Length; } else { _MessageFailed++; } } } _RunningTasks--; }