private void OnDisconnect(Server server)
{
client.Mutex.WaitOne();
devices.Clear();
ServerDisconnected?.Invoke(server);
client.Mutex.ReleaseMutex();
Log("Disconnected from " + Host + ":" + Port);
}
public void OnServerStopped()
{
Debug.WriteLine("[INFO] MtClient::OnServerStopped");
Close();
ServerDisconnected?.Invoke(this, EventArgs.Empty);
}
public void OnServerStopped()
{
Log.Debug("OnServerStopped: begin.");
Close();
ServerDisconnected?.Invoke(this, EventArgs.Empty);
Log.Debug("OnServerStopped: end.");
}
public void Disconnect()
{
if (IsConnected)
{
ServerDisconnected.RaiseOnUIThread(this, new EventArgs());
}
IsConnected = false;
// TODO: Cancel library and play status updates
}
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");
}
private void SetVisibleControl(bool state)
{
if (this.ServerDisconnected.InvokeRequired)
{
var d = new SetVisible(this.SetVisibleControl);
ServerDisconnected.Invoke(d, state);
}
else
{
this.ServerDisconnected.Visible = state;
}
}
private void OnServerDisconnected()
{
IsServerConnected = false;
// Remove all sessions
for (int i = 0; i < Sessions.Count; i++)
{
Sessions[i].Dispose();
}
Sessions.Clear();
ServerDisconnected.RaiseEvent();
}
//接收服务器响应线程函数
private void receiveResponseThreadFunction()
{
try
{
while (true)
{
//接收请求包
AbstractXiepPackage recvPackage = XiepIoHelper.ReceivePackage(_networkStream);
if (recvPackage == null)
{
throw new IOException("获取数据包失败。");
}
//如果是响应数据包
if (recvPackage is ResponsePackage)
{
ResponsePackage responsePackage = (ResponsePackage)recvPackage;
String requestId = responsePackage.RequestId;
lock (_mapRequestResponse)
{
if (_mapRequestResponse.ContainsKey(requestId))
{
_mapRequestResponse.Remove(requestId);
_mapRequestResponse.Add(requestId, responsePackage);
}
}
} //如果是事件数据包
else if (recvPackage is EventPackage)
{
EventPackage eventPackage = (EventPackage)recvPackage;
//触发收到服务器事件的事件
if (ServerEventCame != null)
{
ServerEventCame.BeginInvoke(this, new XiepClientEventArgs(eventPackage), new AsyncCallback(delegate(IAsyncResult iar) { }), null);
}
}
}
}
catch
{
_networkStream = null;
_socket = null;
//触发与服务器连接断开事件
if (ServerDisconnected != null)
{
//ServerDisconnected.BeginInvoke(this, new System.EventArgs(), new AsyncCallback(delegate(IAsyncResult iar) { }), this);
ServerDisconnected.Invoke(this, new System.EventArgs());
}
}
}
private async Task DataReceiver()
{
byte[] buffer = new byte[65536];
try
{
while (true)
{
if (_Token.IsCancellationRequested)
{
break;
}
MessageReceivedEventArgs msg = await MessageReadAsync(buffer);
if (msg != null)
{
if (EnableStatistics)
{
_Stats.IncrementReceivedMessages();
_Stats.AddReceivedBytes(msg.Data.Count);
}
if (msg.MessageType != WebSocketMessageType.Close)
{
if (_AwaitingSyncResponseEvent != null)
{
_AwaitingSyncResponseEvent?.Invoke(this, msg);
}
else
{
MessageReceived?.Invoke(this, msg);
}
}
}
}
}
catch (OperationCanceledException)
{
Logger?.Invoke(_Header + "data receiver canceled");
}
catch (WebSocketException)
{
Logger?.Invoke(_Header + "websocket disconnected");
}
catch (Exception e)
{
Logger?.Invoke(_Header + "exception: " + Environment.NewLine + e.ToString());
}
ServerDisconnected?.Invoke(this, EventArgs.Empty);
}
public GameClient(string address, int port)
{
_udp = new UdpClient(0)
{
Client = { Blocking = false }
};
_target = new IPEndPoint(IPAddress.Parse(address), port);
_server = new NetworkConnection(_udp, _target);
_server.MessageReceived += (fromAddr, message) => MessageReceived?.Invoke(fromAddr, message);
_server.ClientDisconnected += (fromAddr) => ServerDisconnected?.Invoke(fromAddr);
_server.MessageAcked += (fromAddr, message) => MessageAcked?.Invoke(fromAddr, message);
_server.MessageLost += (fromAddr, message) => MessageLost?.Invoke(fromAddr, message);
_reliable = new ReliableConnection(_server);
_reliable.ReliableMessageRecieved += (fromAddr, message) => ReliableMessageReceived?.Invoke(fromAddr, message);
}
public async Task <bool> Connect(IServer connection)
{
if (connection != null)
{
try
{
var connected = await connection.ConnectAsync();
if (connected && connection.IsConnected)
{
if (ShouldUpdateActiveEnvironment)
{
SetActiveServer(connection);
}
}
else
{
var result = PopupController?.ShowConnectionTimeoutConfirmation(connection.DisplayName);
if (result == MessageBoxResult.Yes)
{
await Connect(connection);
}
else
{
ServerDisconnected?.Invoke(this, connection);
}
}
OnPropertyChanged(() => connection.IsConnected);
if (ServerConnected != null && connected && connection.IsConnected)
{
ServerConnected(this, connection);
if (ShouldUpdateActiveEnvironment)
{
SetActiveServer(connection);
}
}
}
catch (Exception)
{
return(false);
}
return(true);
}
return(false);
}
private async Task DataReceiver()
{
try
{
while (true)
{
if (_Token.IsCancellationRequested)
{
break;
}
MessageReceivedEventArgs msg = await MessageReadAsync();
if (msg != null)
{
if (EnableStatistics)
{
_Stats.IncrementReceivedMessages();
_Stats.AddReceivedBytes(msg.Data.Length);
}
Task internal_unawaited = Task.Run(() => InternalMessageReceived?.Invoke(this, msg), _Token);
if (msg.MessageType != WebSocketMessageType.Close)
{
Task unawaited = Task.Run(() => MessageReceived?.Invoke(this, msg), _Token);
}
}
}
}
catch (OperationCanceledException)
{
Logger?.Invoke(_Header + "data receiver canceled");
}
catch (WebSocketException)
{
Logger?.Invoke(_Header + "websocket disconnected");
}
catch (Exception e)
{
Logger?.Invoke(_Header + "exception: " + Environment.NewLine + e.ToString());
}
ServerDisconnected?.Invoke(this, EventArgs.Empty);
InternalServerDisconnected?.Invoke(this, EventArgs.Empty);
}
protected override void ProcessMessage(IpcMessage message)
{
if (message is NetIpcLogMessage logMsg)
{
HandleLogMessage(logMsg);
}
else if (message.MessageType == IpcMessageType.NetIpcClientDisconnected)
{
ServerDisconnected?.Invoke(this, null);
}
else if (message.MessageType == IpcMessageType.NetIpcClientConnected)
{
ServerConnected?.Invoke(this, null);
}
else if (message is NetIpcAutoReconnectResponseMessage autoMsg)
{
HandleAutoReconnectStateMessage(autoMsg);
}
}
void UpdateRepositoryOnServerSaved(Guid savedServerID, bool isDeleted = false)
{
var shellViewModel = CustomContainer.Get <IShellViewModel>();
var currentServer = Servers.FirstOrDefault(server => server.EnvironmentID == savedServerID);
var idx = -1;
if (currentServer != null)
{
if (currentServer.IsConnected)
{
currentServer.Disconnect();
ServerDisconnected?.Invoke(this, currentServer);
}
idx = Servers.IndexOf(currentServer);
currentServer.NetworkStateChanged -= OnServerOnNetworkStateChanged;
Servers.Remove(currentServer);
var environmentViewModel = shellViewModel?.ExplorerViewModel?.Environments?.FirstOrDefault(model => model.ResourceId == currentServer.EnvironmentID);
if (environmentViewModel != null)
{
shellViewModel.ExplorerViewModel?.Environments?.Remove(environmentViewModel);
}
}
if (isDeleted)
{
return;
}
var updatedServer = ServerRepository.Instance.Get(savedServerID);
if (updatedServer == null)
{
return;
}
if (idx == -1)
{
idx = Servers.Count - 1;
}
updatedServer.NetworkStateChanged += OnServerOnNetworkStateChanged;
Servers.Insert(idx, updatedServer);
SelectedConnection = shellViewModel?.LocalhostServer;
}
private void AfterConnect(Task task)
{
if (task.IsCompleted)
{
if (_ClientWs.State == WebSocketState.Open)
{
Task.Run(() =>
{
Task.Run(() => DataReceiver(), _Token);
ServerConnected?.Invoke(this, EventArgs.Empty);
}, _Token);
}
else
{
ServerDisconnected?.Invoke(this, EventArgs.Empty);
}
}
else
{
ServerDisconnected?.Invoke(this, EventArgs.Empty);
}
}
private async Task DataReceiver()
{
string header = "[WatsonWsClient.DataReceiver " + _ServerIpPort + "] ";
try
{
while (true)
{
if (_Token.IsCancellationRequested)
{
break;
}
byte[] data = await MessageReadAsync();
_Stats.ReceivedMessages = _Stats.ReceivedMessages + 1;
_Stats.ReceivedBytes += data.Length;
MessageReceived?.Invoke(this, new MessageReceivedEventArgs(_ServerIpPort, data));
}
}
catch (OperationCanceledException)
{
Logger?.Invoke(header + "canceled");
}
catch (WebSocketException)
{
Logger?.Invoke(header + "websocket disconnected");
}
catch (Exception e)
{
Logger?.Invoke(header + "exception: " + Environment.NewLine + e.ToString());
}
_Connected = false;
ServerDisconnected?.Invoke(this, EventArgs.Empty);
}
private void OnServerOnNetworkStateChanged(INetworkStateChangedEventArgs args, IServer server1)
{
if (args.State != ConnectionNetworkState.Connecting && args.State != ConnectionNetworkState.Connected && !server1.IsConnected)
{
if (SelectedConnection.EnvironmentID == server1.EnvironmentID)
{
if (!IsConnecting && server1.EnvironmentID == Guid.Empty)
{
ServerHasDisconnected(this, server1);
}
IsConnected = false;
ServerDisconnected?.Invoke(this, SelectedConnection);
PopupController?.Show(ErrorResource.ServerconnectionDropped + Environment.NewLine + ErrorResource.EnsureConnectionToServerWorking
, ErrorResource.ServerDroppedErrorHeading, MessageBoxButton.OK, MessageBoxImage.Information, "", false, false, true, false, false, false);
}
}
else
{
if (args.State == ConnectionNetworkState.Connected)
{
ServerReConnected?.Invoke(this, server1);
}
}
}
internal void HandleServerDisconnected(object sender, EventArgs args)
{
ServerDisconnected?.Invoke(sender, args);
}
/// <summary>
/// Disconnects from the TcpState that accepts client connections.
/// This server instance may not be used after calling this method.
/// </summary>
public void Disconnect()
{
_tcpState?.StopAcceptingClientConnections();
ServerDisconnected?.Invoke();
}
private async Task <bool> MessageWriteAsync(byte[] data)
{
string header = "[WatsonWsClient.DataReceiver " + _ServerIpPort + "] ";
bool disconnectDetected = false;
try
{
if (!_Connected || _ClientWs == null)
{
Logger?.Invoke(header + "not connected");
disconnectDetected = true;
return(false);
}
await _SendLock.WaitAsync(_Token);
try
{
await _ClientWs.SendAsync(new ArraySegment <byte>(data, 0, data.Length), WebSocketMessageType.Binary, true, CancellationToken.None);
}
finally
{
_SendLock.Release();
}
_Stats.SentMessages += 1;
_Stats.SentBytes += data.Length;
return(true);
}
catch (OperationCanceledException)
{
Logger?.Invoke(header + "canceled");
disconnectDetected = true;
return(false);
}
catch (WebSocketException)
{
Logger?.Invoke(header + "websocket disconnected");
disconnectDetected = true;
return(false);
}
catch (ObjectDisposedException)
{
Logger?.Invoke(header + "disposed");
disconnectDetected = true;
return(false);
}
catch (SocketException)
{
Logger?.Invoke(header + "socket disconnected");
disconnectDetected = true;
return(false);
}
catch (InvalidOperationException)
{
Logger?.Invoke(header + "disconnected due to invalid operation");
disconnectDetected = true;
return(false);
}
catch (IOException)
{
Logger?.Invoke(header + "IO disconnected");
disconnectDetected = true;
return(false);
}
catch (Exception e)
{
Logger?.Invoke(header + "exception: " + Environment.NewLine + e.ToString());
disconnectDetected = true;
return(false);
}
finally
{
if (disconnectDetected)
{
_Connected = false;
Dispose();
ServerDisconnected?.Invoke(this, EventArgs.Empty);
}
}
}
private void Client_ServerDisconnected()
{
Logger.Debug("Server disconnected!");
ServerDisconnected?.Invoke();
}
protected virtual void OnServerDisconnected(object source)
{
ServerDisconnected?.Invoke(source, EventArgs.Empty);
}
protected virtual void OnServerDisconnected()
{
ServerDisconnected?.Invoke(this, new EventArgs());
}
private async Task <bool> MessageWriteAsync(byte[] data, WebSocketMessageType msgType, CancellationToken token)
{
bool disconnectDetected = false;
using (CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_Token, token))
{
try
{
if (_ClientWs == null || _ClientWs.State != WebSocketState.Open)
{
Logger?.Invoke(_Header + "not connected");
disconnectDetected = true;
return(false);
}
await _SendLock.WaitAsync(_Token);
try
{
await _ClientWs.SendAsync(new ArraySegment <byte>(data, 0, data.Length), msgType, true, token);
}
catch { }
finally
{
_SendLock.Release();
}
if (EnableStatistics)
{
_Stats.IncrementSentMessages();
_Stats.AddSentBytes(data.Length);
}
return(true);
}
catch (TaskCanceledException)
{
if (_Token.IsCancellationRequested)
{
Logger?.Invoke(_Header + "canceled");
disconnectDetected = true;
}
else if (token.IsCancellationRequested)
{
Logger?.Invoke(_Header + "message send canceled");
}
return(false);
}
catch (OperationCanceledException)
{
if (_Token.IsCancellationRequested)
{
Logger?.Invoke(_Header + "canceled");
disconnectDetected = true;
}
else if (token.IsCancellationRequested)
{
Logger?.Invoke(_Header + "message send canceled");
}
return(false);
}
catch (WebSocketException)
{
Logger?.Invoke(_Header + "websocket disconnected");
disconnectDetected = true;
return(false);
}
catch (ObjectDisposedException)
{
Logger?.Invoke(_Header + "disposed");
disconnectDetected = true;
return(false);
}
catch (SocketException)
{
Logger?.Invoke(_Header + "socket disconnected");
disconnectDetected = true;
return(false);
}
catch (InvalidOperationException)
{
Logger?.Invoke(_Header + "disconnected due to invalid operation");
disconnectDetected = true;
return(false);
}
catch (IOException)
{
Logger?.Invoke(_Header + "IO disconnected");
disconnectDetected = true;
return(false);
}
catch (Exception e)
{
Logger?.Invoke(_Header + "exception: " + Environment.NewLine + e.ToString());
disconnectDetected = true;
return(false);
}
finally
{
if (disconnectDetected)
{
Dispose();
ServerDisconnected?.Invoke(this, EventArgs.Empty);
InternalServerDisconnected?.Invoke(this, EventArgs.Empty);
}
}
}
}
/// <summary>
/// Trigger ServerDisconnected Event
/// </summary>
/// <param name="ipAddress"></param>
/// <param name="port"></param>
protected virtual void OnServerDisconnected(IPAddress[] ipAddress, int port)
{
ServerDisconnected?.Invoke(this, new TCPServerDisconnectedEventArgs(ipAddress[0], port));
}
internal virtual void OnServerDisconnected(EventArgs e) => ServerDisconnected?.Invoke(this, e);
private void RaiseServerDisconnected()
{
ServerDisconnected?.Invoke(this, new TcpServerDisconnectedEventArgs(_remoteEndPoint, _localEndPoint));
}
internal void HandleServerDisconnected(object sender, DisconnectionEventArgs args)
{
WrappedEventHandler(() => ServerDisconnected?.Invoke(sender, args), "ServerDisconnected", sender);
}
protected override void ListeningLoop()
{
const int BUFFER_SIZE = 4096;
char[] DELIM = new char[] { '$' };
StringBuilder backBuffer = new StringBuilder();
byte[] buffer = new byte[BUFFER_SIZE];
int received;
try
{
while (true)
{
try
{
received = _Socket.Receive(buffer);
}
catch (SocketException)
{
ServerDisconnected.Invoke();
Stop();
break;
}
backBuffer.Append(Encoding.UTF8.GetString(buffer, 0, received));
if (received == BUFFER_SIZE)
{
continue;
}
string[] msgStr = backBuffer.ToString().Split(DELIM, StringSplitOptions.RemoveEmptyEntries);
backBuffer = new StringBuilder();
foreach (string s in msgStr)
{
StringReader msgReader = new StringReader(s);
ServerResponse msg = null;
try
{
msg = (ServerResponse)_ReceiveMsgSerializer.Deserialize(msgReader);
}
catch (Exception)
{
Console.WriteLine("Got unexpected message!");
continue;
}
EnqueueMessage(msg);
MessageReceivedInvoke();
}
}
}
catch (ThreadAbortException)
{
}
}
private void OnServerDisconnected()
{
ServerDisconnected?.Invoke(this, new ServerDisconnected());
}
