public async Task RegisterC2DMessageSenderTest()
{
// Arrange
IDeviceProxy deviceProxy = null;
var identity = Mock.Of <IIdentity>(i => i.Id == "d1");
var deviceListener = Mock.Of <IDeviceListener>();
Mock.Get(deviceListener).Setup(d => d.BindDeviceProxy(It.IsAny <IDeviceProxy>()))
.Callback <IDeviceProxy>(d => deviceProxy = d);
var connectionProvider = Mock.Of <IConnectionProvider>(c => c.GetDeviceListenerAsync(identity) == Task.FromResult(deviceListener));
var connectionHandler = new ClientConnectionHandler(identity, connectionProvider);
IMessage receivedMessage = null;
var c2DLinkHandler = new Mock <ISendingLinkHandler>();
c2DLinkHandler.Setup(c => c.SendMessage(It.IsAny <IMessage>()))
.Callback <IMessage>(m => receivedMessage = m)
.Returns(Task.CompletedTask);
c2DLinkHandler.SetupGet(c => c.Type)
.Returns(LinkType.C2D);
var systemProperties = new Dictionary <string, string>();
var messageToSend = Mock.Of <IMessage>(m => m.SystemProperties == systemProperties);
// Act
await connectionHandler.GetDeviceListener();
await connectionHandler.RegisterLinkHandler(c2DLinkHandler.Object);
await deviceProxy.SendC2DMessageAsync(messageToSend);
// Assert
Assert.NotNull(receivedMessage);
Assert.Equal(messageToSend, receivedMessage);
Assert.Equal("/devices/d1", systemProperties[SystemProperties.To]);
}
public void HandleHandshakeResponse(ClientStructure client, HandshakeResponseMsgData data)
{
var valid = CheckServerFull(client);
valid &= valid && CheckUsernameLength(client, data.PlayerName);
valid &= valid && CheckUsernameCharacters(client, data.PlayerName);
valid &= valid && CheckWhitelist(client, data.PlayerName);
valid &= valid && CheckPlayerIsAlreadyConnected(client, data.PlayerName);
valid &= valid && CheckUsernameIsReserved(client, data.PlayerName);
valid &= valid && CheckPlayerIsBanned(client, data.PlayerName, client.Endpoint.Address.ToString(), data.PublicKey);
valid &= valid && CheckKey(client, data.PlayerName, data.PublicKey, data.ChallengeSignature);
if (!valid)
{
LunaLog.Normal($"Client {data.PlayerName} failed to handshake: {Reason}. Disconnecting");
client.DisconnectClient = true;
ClientConnectionHandler.DisconnectClient(client, Reason);
}
else
{
client.PlayerName = data.PlayerName;
client.PublicKey = data.PublicKey;
client.Authenticated = true;
LmpPluginHandler.FireOnClientAuthenticated(client);
LunaLog.Normal($"Client {data.PlayerName} handshook successfully, Version: {data.Version}");
CreatePlayerScenarioFiles(client, data.PlayerName);
HandshakeSystemSender.SendHandshakeReply(client, HandshakeReply.HANDSHOOK_SUCCESSFULLY, "success");
MessageQueuer.RelayMessage <PlayerConnectionSrvMsg>(client, new PlayerConnectionJoinMsgData {
PlayerName = client.PlayerName
});
LunaLog.Debug($"Online Players: {ServerContext.PlayerCount}, connected: {ClientRetriever.GetClients().Length}");
}
}
public async Task RegisterMethodInvokerTest()
{
// Arrange
IDeviceProxy deviceProxy = null;
var identity = Mock.Of <IIdentity>(i => i.Id == "d1/m1");
var deviceListener = Mock.Of <IDeviceListener>();
Mock.Get(deviceListener).Setup(d => d.BindDeviceProxy(It.IsAny <IDeviceProxy>()))
.Callback <IDeviceProxy>(d => deviceProxy = d);
var connectionProvider = Mock.Of <IConnectionProvider>(c => c.GetDeviceListenerAsync(identity) == Task.FromResult(deviceListener));
var connectionHandler = new ClientConnectionHandler(identity, connectionProvider);
IMessage receivedMessage = null;
var methodSendingLinkHandler = new Mock <ISendingLinkHandler>();
methodSendingLinkHandler.Setup(c => c.SendMessage(It.IsAny <IMessage>()))
.Callback <IMessage>(m => receivedMessage = m)
.Returns(Task.CompletedTask);
methodSendingLinkHandler.SetupGet(c => c.Type)
.Returns(LinkType.MethodSending);
var sentRequest = new DirectMethodRequest(identity.Id, "poke", new byte[] { 0, 1, 2 }, TimeSpan.FromSeconds(10));
// Act
await connectionHandler.GetDeviceListener();
await connectionHandler.RegisterLinkHandler(methodSendingLinkHandler.Object);
await deviceProxy.InvokeMethodAsync(sentRequest);
// Assert
Assert.NotNull(receivedMessage);
Assert.Equal(sentRequest.Data, receivedMessage.Body);
Assert.Equal(sentRequest.CorrelationId, receivedMessage.SystemProperties[SystemProperties.CorrelationId]);
Assert.Equal(sentRequest.Name, receivedMessage.Properties[Constants.MessagePropertiesMethodNameKey]);
}
public async Task GetDeviceListenerTest()
{
// Arrange
IDeviceProxy deviceProxy = null;
var identity = Mock.Of <IIdentity>(i => i.Id == "d1/m1");
var deviceListener = Mock.Of <IDeviceListener>();
Mock.Get(deviceListener).Setup(d => d.BindDeviceProxy(It.IsAny <IDeviceProxy>()))
.Callback <IDeviceProxy>(d => deviceProxy = d);
var connectionProvider = Mock.Of <IConnectionProvider>(c => c.GetDeviceListenerAsync(identity, Option.None <string>()) == Task.FromResult(deviceListener));
var amqpConnection = new AmqpTestConnection();
var connectionHandler = new ClientConnectionHandler(identity, connectionProvider, amqpConnection);
// Act
var tasks = new List <Task <IDeviceListener> >();
for (int i = 0; i < 10; i++)
{
tasks.Add(connectionHandler.GetDeviceListener());
}
IList <IDeviceListener> deviceListeners = (await Task.WhenAll(tasks)).ToList();
// Assert
Assert.NotNull(deviceListeners);
Assert.Equal(10, deviceListeners.Count);
for (int i = 0; i < 10; i++)
{
Assert.Equal(deviceListener, deviceListeners[0]);
}
Assert.NotNull(deviceProxy);
Mock.Get(connectionProvider).Verify(c => c.GetDeviceListenerAsync(It.IsAny <IIdentity>(), Option.None <string>()), Times.Once);
Mock.Get(deviceListener).Verify(d => d.BindDeviceProxy(It.IsAny <IDeviceProxy>()), Times.Once);
}
public async Task RegisterDesiredPropertiesUpdateSenderTest()
{
// Arrange
IDeviceProxy deviceProxy = null;
var identity = Mock.Of <IIdentity>(i => i.Id == "d1/m1");
var deviceListener = Mock.Of <IDeviceListener>();
Mock.Get(deviceListener).Setup(d => d.BindDeviceProxy(It.IsAny <IDeviceProxy>()))
.Callback <IDeviceProxy>(d => deviceProxy = d);
var connectionProvider = Mock.Of <IConnectionProvider>(c => c.GetDeviceListenerAsync(identity, Option.None <string>()) == Task.FromResult(deviceListener));
var amqpConnection = new AmqpTestConnection();
var connectionHandler = new ClientConnectionHandler(identity, connectionProvider, amqpConnection);
IMessage receivedMessage = null;
var twinSendingLinkHandler = new Mock <ISendingLinkHandler>();
twinSendingLinkHandler.Setup(c => c.SendMessage(It.IsAny <IMessage>()))
.Callback <IMessage>(m => receivedMessage = m)
.Returns(Task.CompletedTask);
twinSendingLinkHandler.SetupGet(c => c.Type)
.Returns(LinkType.TwinSending);
var messageToSend = Mock.Of <IMessage>();
// Act
await connectionHandler.GetDeviceListener();
await connectionHandler.RegisterLinkHandler(twinSendingLinkHandler.Object);
await deviceProxy.OnDesiredPropertyUpdates(messageToSend);
// Assert
Assert.NotNull(receivedMessage);
Assert.Equal(messageToSend, receivedMessage);
}
public async Task CompilationsDisallowed()
{
var hitCompilation = false;
var compilerServerHost = new TestableCompilerServerHost(
delegate
{
hitCompilation = true;
Assert.True(
false,
"Should not reach compilation when compilations are disallowed"
);
throw new Exception("");
}
);
var clientConnectionHandler = new ClientConnectionHandler(compilerServerHost);
BuildResponse?response = null;
var clientConnection = new TestableClientConnection()
{
ReadBuildRequestFunc = _ => Task.FromResult(ProtocolUtil.EmptyCSharpBuildRequest),
WriteBuildResponseFunc = (r, _) =>
{
response = r;
return(Task.CompletedTask);
}
};
var completionData = await clientConnectionHandler.ProcessAsync(
Task.FromResult <IClientConnection>(clientConnection),
allowCompilationRequests : false
);
Assert.Equal(CompletionData.RequestCompleted, completionData);
Assert.True(response is RejectedBuildResponse);
Assert.False(hitCompilation);
}
public async Task ClientDisconnectDuringBuild()
{
using var buildStartedMre = new ManualResetEvent(initialState: false);
using var clientClosedMre = new ManualResetEvent(initialState: false);
var compilerServerHost = new TestableCompilerServerHost((request, cancellationToken) =>
{
buildStartedMre.Set();
clientClosedMre.WaitOne();
Assert.True(cancellationToken.IsCancellationRequested);
return(ProtocolUtil.EmptyBuildResponse);
});
var disconnectTaskCompletionSource = new TaskCompletionSource <object?>();
var isDisposed = false;
var clientConnection = new TestableClientConnection()
{
ReadBuildRequestFunc = _ => Task.FromResult(ProtocolUtil.EmptyBasicBuildRequest),
DisconnectTask = disconnectTaskCompletionSource.Task,
DisposeFunc = () => { isDisposed = true; },
};
var clientConnectionHandler = new ClientConnectionHandler(compilerServerHost);
var task = clientConnectionHandler.ProcessAsync(Task.FromResult <IClientConnection>(clientConnection));
// Don't trigger the disconnect until we confirm that the client has issueed a
// build request.
buildStartedMre.WaitOne();
disconnectTaskCompletionSource.TrySetResult(null);
var completionData = await task.ConfigureAwait(false);
Assert.Equal(CompletionData.RequestError, completionData);
Assert.True(isDisposed);
clientClosedMre.Set();
}
private void RunTrainingThread()
{
/*
* Starting Sequence
*/
// Model related logic
connection = new ClientConnectionHandler();
process = new Process();
// Calls python training script.
process.StartInfo.FileName = @"C:\Users\Michael\AppData\Local\Microsoft\WindowsApps\python.exe";
string scriptPath = @"C:\Git\Virtual-Hand\PythonScripts\ModelTrainerV4.py";
string dataSetName = "RealData15_smoothed"; // To be hard-coded (for now)
string modelName = "FirstModelTest";
process.StartInfo.Arguments = scriptPath;
// Starts the process
print("Starting the process: " + process.StartInfo.FileName);
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;
process.Start();
System.Threading.Thread.Sleep(6000);
connection.println(dataSetName);
connection.println(modelName);
print("Started the Python process. ");
// Interactions with the Python Script
// string acknowledgement = stdoutReadLine();
string acknowledgement = connection.readline();
print("Acknowledgement from Python: " + acknowledgement);
if (acknowledgement.Equals("Ready") == false)
{
print("Did not receive acknowledgement from Python script.");
Quit();
}
else
{
connection.println("Ready");
// Obtains starting angles from the python script
print("Reading start angles...");
// string[] stringBaseAngles = connection.readline().Split(' ');
// for (int i = 0; i < stringBaseAngles.Length; i++)
// {
// print(stringBaseAngles[i]);
// startingAngles[i] = float.Parse(stringBaseAngles[i]);
// }
startingAngles = GeneralData.string2floatArray(connection.readline());
// startingAngles = new float[movableLimbs.Length]; // todo, remove this
print("Expecting start angles...");
foreach (var angle in startingAngles)
{
controlled_print(angle.ToString());
}
controlled_print("Python angles obtained: " + startingAngles.ToString());
// waitingForNewFrame = true;
ResetTrainingSequence_forThread(true);
Ready();
}
// Resets the system multiple times to achieve stable start position
while (positionSetupResets > 0)
{
if (positionSetupResets % 100 == 0)
{
critical_print("Positional resets remaining: " + positionSetupResets.ToString());
}
zeroPosition = true;
ResetTrainingSequence_forThread(false);
positionSetupResets = positionSetupResets - 1;
}
// Initial ready (other ready's are received upon restart)
if (connection.readline().Equals("Ready") == false)
{
critical_print("False start! (did not receive loop ready)");
Quit();
}
/*
* Process Loop
*/
while (running == true)
{
// Step Loop-0 (as per Pprotocol)
// controlled_print("Stopwatch: " + stopwatch.ElapsedMilliseconds.ToString());
// if (waitingForNewFrame == true)
// {
// controlled_print("Next will be: ");
// nextFrameTimeMs = long.Parse(connection.readline());
// controlled_print("Next time frame: " + nextFrameTimeMs);
// waitingForNewFrame = false;
// }
// else if (stopwatch.ElapsedMilliseconds >= nextFrameTimeMs) // Step Loop-1 (as per protocol)
// {
// Step Loop-2 (as per protocol)
string toSend = GetStringLimbData_forThread();
// Sends data to python script
// Step Loop-3 (as per protocol)
long current_time_ms = stopwatch.ElapsedMilliseconds;
connection.println(current_time_ms.ToString());
critical_print("Current time: " + current_time_ms.ToString());
// Step Loop-4 (as per protocol)
connection.println(toSend);
expectedAngles =
GeneralData.string2floatArray(connection
.readline()); // Obtains the expected angles from the Python Script
// Step Loop-5 (as per protocol)
string nextCommand = connection.readline();
// Step Loop-6 (as per protocol)
if (nextCommand.Equals("Reset"))
{
if (FrameViewer.earlyReset == true)
{
ResetTrainingSequence_forThread(true);
}
if (connection.readline().Equals("Ready"))
{
ResetTrainingSequence_forThread(true);
}
else
{
critical_print("We've got a big mistake. No reset Ready received.");
}
Ready();
}
else if (nextCommand.Equals("Quit"))
{
Quit();
}
else if (nextCommand.Equals("Next"))
{
// Obtains and applies torques from python script to the limbs
string stringTorques = connection.readline();
controlled_print("Received Torques length: " + stringTorques.ToString());
lock (torquesToApply_locker)
{
// for (int i = 0; i < movableLimbs.Length; i++)
// {
// torquesToApply[i] = float.Parse(stringTorques[i]);
// }
torquesToApply = GeneralData.string2floatArray(stringTorques);
}
// waitingForNewFrame = true;
Ready();
}
else
{
print(
"Unknown nextCommand sent from python script (" + nextCommand + "). Aborting program.");
Quit();
}
// }
}
}
public static async void StartReceiveingMessages()
{
try
{
while (ServerContext.ServerRunning)
{
var msg = Server.ReadMessage();
if (msg != null)
{
var client = TryGetClient(msg);
switch (msg.MessageType)
{
case NetIncomingMessageType.ConnectionApproval:
if (ServerContext.UsePassword)
{
var password = msg.ReadString();
if (password != GeneralSettings.SettingsStore.Password)
{
msg.SenderConnection.Deny("Invalid password");
break;
}
}
msg.SenderConnection.Approve();
break;
case NetIncomingMessageType.Data:
ClientMessageReceiver.ReceiveCallback(client, msg);
break;
case NetIncomingMessageType.WarningMessage:
LunaLog.Warning(msg.ReadString());
break;
case NetIncomingMessageType.DebugMessage:
LunaLog.NetworkDebug(msg.ReadString());
break;
case NetIncomingMessageType.ConnectionLatencyUpdated:
case NetIncomingMessageType.VerboseDebugMessage:
LunaLog.NetworkVerboseDebug(msg.ReadString());
break;
case NetIncomingMessageType.Error:
LunaLog.Error(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
switch ((NetConnectionStatus)msg.ReadByte())
{
case NetConnectionStatus.Connected:
var endpoint = msg.SenderConnection.RemoteEndPoint;
LunaLog.Normal($"New client Connection from {endpoint.Address}:{endpoint.Port}");
ClientConnectionHandler.ConnectClient(msg.SenderConnection);
break;
case NetConnectionStatus.Disconnected:
var reason = msg.ReadString();
if (client != null)
{
ClientConnectionHandler.DisconnectClient(client, reason);
}
break;
}
break;
default:
var details = msg.PeekString();
LunaLog.Debug($"Lidgren: {msg.MessageType.ToString().ToUpper()} -- {details}");
break;
}
}
else
{
await Task.Delay(IntervalSettings.SettingsStore.SendReceiveThreadTickMs);
}
}
}
catch (Exception e)
{
LunaLog.Fatal($"ERROR in thread receive! Details: {e}");
}
}
/// <summary>
/// Main loop of this connection listener.
/// </summary>
public void start()
{
managementService = new JSON_RPC_Server.ManagementService();
server = new TcpListener(IPAddress.Any, listenPort);
server.Start();
Trace.TraceInformation("listening for connections at: " + listenPort);
while (continueThread)
{
try
{
client = server.AcceptTcpClient();
ClientConnectionHandler clientConnectionHandler = new ClientConnectionHandler(client, interceptor);
listOfConnectionHandlers.Add(clientConnectionHandler);
Thread thread = new Thread(new ThreadStart(clientConnectionHandler.handleConnection));
listOfThreads.Add(thread);
thread.Start();
}
catch (Exception ex)
{
Console.WriteLine("Error in TcpClient - " + ex.Message);
}
}
}
public void StartReceiveingMessages()
{
try
{
while (ServerContext.ServerRunning)
{
var msg = Server.ReadMessage();
if (msg != null)
{
var client = TryGetClient(msg);
switch (msg.MessageType)
{
case NetIncomingMessageType.ConnectionApproval:
msg.SenderConnection.Approve();
break;
case NetIncomingMessageType.Data:
ClientMessageReceiver.ReceiveCallback(client, msg);
break;
case NetIncomingMessageType.WarningMessage:
LunaLog.Error($"Lidgren WARNING: {msg.ReadString()}");
break;
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
LunaLog.Debug($"Lidgren DEBUG: {msg.MessageType}-- {msg.PeekString()}");
break;
case NetIncomingMessageType.StatusChanged:
switch ((NetConnectionStatus)msg.ReadByte())
{
case NetConnectionStatus.Connected:
var endpoint = msg.SenderConnection.RemoteEndPoint;
LunaLog.Normal($"New client Connection from {endpoint.Address}:{endpoint.Port}");
ClientConnectionHandler.ConnectClient(msg.SenderConnection);
break;
case NetConnectionStatus.Disconnected:
var reason = msg.ReadString();
if (client != null)
{
ClientConnectionHandler.DisconnectClient(client, reason);
}
break;
}
break;
default:
var details = msg.PeekString();
LunaLog.Debug($"Lidgren: {msg.MessageType.ToString().ToUpper()} -- {details}");
break;
}
}
else
{
Thread.Sleep(GeneralSettings.SettingsStore.SendReceiveThreadTickMs);
}
}
}
catch (Exception e)
{
LunaLog.Fatal($"ERROR in thread receive! Details: {e}");
}
}
public static void StartReceivingMessages()
{
while (ServerContext.ServerRunning)
{
var msg = Server.WaitMessage(ServerContext.PlayerCount > 0 ? IntervalSettings.SettingsStore.SendReceiveThreadTickMs : int.MaxValue);
if (msg != null)
{
try
{
ClientStructure client = null;
if (msg.SenderConnection != null)
{
ServerContext.Clients.TryGetValue(msg.SenderConnection.RemoteEndPoint, out client);
}
switch (msg.MessageType)
{
case NetIncomingMessageType.ConnectionApproval:
if (ServerContext.UsePassword)
{
if (msg.ReadString() != GeneralSettings.SettingsStore.Password)
{
msg.SenderConnection.Deny("Invalid password");
break;
}
}
msg.SenderConnection.Approve();
break;
case NetIncomingMessageType.Data:
MessageReceiver.ReceiveCallback(client, msg);
if (client == null)
{
break;
}
client.BytesReceived += (uint)msg.LengthBytes;
break;
case NetIncomingMessageType.WarningMessage:
LunaLog.Warning(msg.ReadString());
break;
case NetIncomingMessageType.DebugMessage:
LunaLog.NetworkDebug(msg.ReadString());
break;
case NetIncomingMessageType.ConnectionLatencyUpdated:
case NetIncomingMessageType.VerboseDebugMessage:
LunaLog.NetworkVerboseDebug(msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.Error:
LunaLog.Error(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
switch ((NetConnectionStatus)msg.ReadByte())
{
case NetConnectionStatus.Connected:
var endpoint = msg.SenderConnection.RemoteEndPoint;
LunaLog.Normal($"New client Connection from {endpoint.Address}:{endpoint.Port}");
ClientConnectionHandler.ConnectClient(msg.SenderConnection);
break;
case NetConnectionStatus.Disconnected:
if (client != null)
{
ClientConnectionHandler.DisconnectClient(client, msg.ReadString());
}
break;
}
break;
default:
LunaLog.Warning($"Unhandled Lidgren Message: {msg.MessageType} -- {msg.ReadString()}");
break;
}
}
catch (Exception e)
{
LunaLog.Error($"ERROR in networking thread! Details: {e}");
}
}
}
}
/// <summary>
/// Disconnects the given client
/// </summary>
public static void SendConnectionEnd(ClientStructure client, string reason)
{
ClientConnectionHandler.DisconnectClient(client, reason);
}
static void Main(string[] args)
{
Console.WriteLine("Welcome in Console.TicTacToe v.0.1 by Michal Jasiak...\r\n");
Console.WriteLine("Please give your name...");
var name = Console.ReadLine();
Console.WriteLine(string.Format("Hello {0},\r\ndo you want X or O?", name));
var mark = Console.ReadLine();
Console.WriteLine("Connecting...");
var connection = ClientConnection.Connect(_listeningAddress, _listeningPort);
var connectionHandler = new ClientConnectionHandler(connection);
connectionHandler.OnMessageReceived += connectionHandler_OnMessageReceived;
var requestMessage = new RequestMessage
{
Data = JsonConvert.SerializeObject(new Player
{
Name = name,
Mark = char.Parse(mark)
}),
Method = "player/add"
};
connectionHandler.Send(JsonConvert.SerializeObject(requestMessage));
connectionHandler.StartListening();
string message = string.Empty;
message = Console.ReadLine();
while (!message.Equals("exit"))
{
var choose = message.Split(' ')[0];
switch (choose)
{
case "newgame":
{
requestMessage = new RequestMessage
{
Data = string.Empty,
Method = "game/start"
};
connectionHandler.Send(requestMessage.Serialize());
break;
}
case "continue":
{
if (_currentGame != null)
{
Console.Clear();
BuildMap(_currentGame.Map);
IsYourTurn();
}
else
{
Console.WriteLine("You haven't started game yet. Write 'newgame' to start it.");
}
break;
}
case "move":
{
var isNumeric = int.TryParse(message.Split(' ')[1], out int destination);
if (isNumeric)
{
bool isNumber1to9 = Enumerable.Range(1, 9).Contains(destination);
if (isNumber1to9)
{
Move move = new Move
{
GameId = _currentGame.Id,
Player = _currentPlayer,
Destination = destination - 1
};
requestMessage = new RequestMessage
{
Data = JsonConvert.SerializeObject(move),
Method = "game/move"
};
connectionHandler.Send(requestMessage.Serialize());
break;
}
}
Console.WriteLine("First parameter of 'move' should be number from 1-9");
break;
}
case "help":
{
Console.Clear();
Console.WriteLine("--- TicTacToe Help Menu ---");
Console.WriteLine(" - newgame | Starts new game.");
if (_currentGame != null)
{
Console.WriteLine(" - continue | Continue game.");
Console.WriteLine(" - move field_number | Set your mark on specified field.");
}
Console.WriteLine(" - help | Shows help menu");
Console.WriteLine(" - exit | Close game.");
break;
}
default:
{
Console.WriteLine("Command doesn't exist");
break;
}
}
message = Console.ReadLine();
}
connectionHandler.Close();
Console.WriteLine("* Client has exited... *");
Console.Clear();
}
