/// <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--;
}
