/// <summary>
/// Open serial port
/// </summary>
public void Connect()
{
logger.Debug("Connecting to device...");
try
{
port.Open();
if (port.IsOpen == true)
{
logger.Info("Device connected.");
Connected?.Invoke();
}
else
{
logger.Info("Device not connected.");
Disconnected?.Invoke();
}
}
catch (System.Exception ex)
{
throw new CommunicationException("Port opening failed. Please check port name.", ex);
}
}
//called once a client disconnects from the server
private void OnDisconnected(INetworkPlayer player)
{
if (logger.LogEnabled())
{
logger.Log("Server disconnect client:" + player);
}
// set the flag first so we dont try to send any messages to the disconnected
// connection as they wouldn't get them
player.MarkAsDisconnected();
RemoveConnection(player);
Disconnected?.Invoke(player);
player.DestroyOwnedObjects();
player.Identity = null;
if (player == LocalPlayer)
{
LocalPlayer = null;
}
}
public void Disconnect(bool notify)
{
if (IsConnected)
{
IsConnected = false;
RemoteIP = null;
_encryption = null;
try
{
_socket.Shutdown(SocketShutdown.Both);
}
catch (Exception ex)
{
NotifyError(ex);
}
_socket.Dispose();
_socket = null;
if (notify)
{
Disconnected?.Invoke(this, EventArgs.Empty);
}
}
}
private void HookNotifications()
{
Socket.Connected += (socket, address) =>
{
Connected?.Invoke(this, address);
};
Socket.Disconnected += (socket, exception) =>
{
Disconnected?.Invoke(this, exception);
};
Socket.MessageReceived += (s, message) =>
{
var msg = FormatReceivedMessage(message);
if (msg != null)
{
MessageReceived?.Invoke(this, msg);
}
};
Socket.MessageSent += socket =>
{
MessageSent?.Invoke(this);
};
}
public void Disconnect(bool error)
{
if (Interlocked.Exchange(ref disposed, 1) == 0)
{
tcp.Close();
Disconnected?.Invoke(this, error);
lock (missions_global)
{
foreach (UInt256 hash in missions)
{
missions_global.Remove(hash);
}
}
if (protocolThread != Thread.CurrentThread && !protocolThread.ThreadState.HasFlag(ThreadState.Unstarted))
{
protocolThread.Join();
}
if (!sendThread.ThreadState.HasFlag(ThreadState.Unstarted))
{
sendThread.Join();
}
}
}
private void OnConnectionDisconnected(object sender, EventArgs e)
{
if (!_isDisconnecting)
{
_isDisconnecting = true;
if (sender == _sender)
{
_receiver.Disconnect();
}
if (sender == _receiver)
{
_sender.Disconnect();
}
IsConnected = false;
Disconnected?.Invoke(this, DisconnectedEventArgs.Empty);
_isDisconnecting = false;
}
}
public async Task <InvokeResult> RefreshAdaptersAsync()
{
if (!_isConnected)
{
await _wifiAdapter.ScanAsync();
foreach (var networks in _wifiAdapter.NetworkReport.AvailableNetworks)
{
if (networks.Ssid.StartsWith("TELLO"))
{
await _wifiAdapter.ConnectAsync(networks, WiFiReconnectionKind.Automatic);
_dispatcherService.Invoke(() => Connected?.Invoke(this, new WiFiConnection(networks)));
Debug.WriteLine("CONNEcTED TO TELLO!");
_isConnected = true;
return(InvokeResult.Success);
}
}
}
_dispatcherService.Invoke(() => Disconnected?.Invoke(this, null));
return(InvokeResult.FromError("Could not connected"));
}
private void ThreadCheckSerialOpen()
{
while (isThreadCheckSerialOpen)
{
Thread.Sleep(sleepTimeCheck);
try
{
if (serialPort == null || !serialPort.IsOpen)
{
Debug.WriteLine("seriaport disconnected");
Disconnected?.Invoke(this, new SerialCommDisconnectedEventArgs {
DeviceID = _deviceID
});
break;
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
}
protected void OnPipeData(IAsyncResult ar)
{
var conn = ar.AsyncState as PipeConnection;
try
{
DataReceived?.Invoke(conn, conn.EnsureMessageComplete(conn.Pipe.EndRead(ar)));
}
catch
{
if (!conn.Pipe.IsConnected)
{
lock (Pipes)
{
Pipes.Remove(conn.Pipe);
}
Disconnected?.Invoke(conn);
conn.Dispose();
return;
}
}
BeginPipeRead(conn);
}
public virtual void Disconnect(bool error)
{
if (Interlocked.Exchange(ref disposed, 1) == 0)
{
Disconnected?.Invoke(this, error);
bool needSync = false;
lock (missions_global)
lock (missions)
if (missions.Count > 0)
{
missions_global.ExceptWith(missions);
needSync = true;
}
if (needSync)
{
lock (localNode.connectedPeers)
foreach (RemoteNode node in localNode.connectedPeers)
{
node.EnqueueMessage("getblocks", GetBlocksPayload.Create(Blockchain.Default.CurrentBlockHash), true);
}
}
}
}
private async void ReceiveLoop(TcpClient tcpClient)
{
int connectionId = NextConnectionId();
clients.Add(connectionId, tcpClient);
try
{
// someone connected, raise event
Connected?.Invoke(connectionId);
using (Stream networkStream = tcpClient.GetStream())
{
while (true)
{
byte[] data = await ReadMessageAsync(networkStream);
if (data == null)
{
break;
}
// we received some data, raise event
ReceivedData?.Invoke(connectionId, data);
}
}
}
catch (Exception exception)
{
ReceivedError?.Invoke(connectionId, exception);
}
finally
{
clients.Remove(connectionId);
Disconnected?.Invoke(connectionId);
}
}
private void OnConnectionError()
{
if (disposedValue)
{
return;
}
lock (threadLock)
{
Disconnected?.Invoke(this, null);
ISLogger.Write($"NamedIpc->Reconnecting to service");
while (!disposedValue)
{
try
{
if (!clientRead.IsConnected)
{
clientRead.Connect(500);
}
if (!clientWrite.IsConnected)
{
clientWrite.Connect(500);
}
}
catch (Exception) { }
}
if (disposedValue)
{
return;
}
Connected?.Invoke(this, null);
ISLogger.Write($"NamedIpc->Reconnected to service");
clientRead.BeginRead(clientBuff, 0, clientBuff.Length, ClientReadCallback, null);
}
}
public ConnectionHandler(string host, int port)
{
Host = host ?? throw new ArgumentNullException(nameof(host));
Port = port;
Connection = new IPConnection();
Connection.SetAutoReconnect(true);
Connection.Connected += (s, e) =>
{
IsConnceted = true;
Connection.Enumerate();
var reason = e switch
{
IPConnection.CONNECT_REASON_REQUEST => ConnectedReason.Requested,
IPConnection.CONNECT_REASON_AUTO_RECONNECT => ConnectedReason.Reconnect,
_ => ConnectedReason.Unknown,
};
Connected?.Invoke(this, new ConnectedEventArgs(reason));
};
Connection.Disconnected += (s, e) =>
{
IsConnceted = false;
var reason = e switch
{
IPConnection.DISCONNECT_REASON_REQUEST => DisconnectedReason.RequestedFromSelf,
IPConnection.DISCONNECT_REASON_SHUTDOWN => DisconnectedReason.RequestedFromEndpoint,
IPConnection.DISCONNECT_REASON_ERROR => DisconnectedReason.Timeout,
_ => DisconnectedReason.Unknown,
};
Disconnected?.Invoke(this, new DisconnectedEventArgs(reason));
};
Connection.EnumerateCallback += (s, uid, cu, p, hV, fV, dI, eT) =>
{
Enumerate?.Invoke(this, new EnumerateEventArgs(
new TinkerforgeDeviceInfo(uid, cu, p, hV, fV, dI),
eT));
};
}
private void Release(bool userRequestedDisconnect)
{
lock (netLock)
{
if (cancellationToken != null)
{
cancellationToken.Dispose();
cancellationToken = null;
}
if (netWriter != null)
{
netWriter.Dispose();
netWriter = null;
}
if (netReader != null)
{
netReader.Dispose();
netReader = null;
}
if (netStream != null)
{
netStream.Dispose();
netStream = null;
}
if (socket != null)
{
socket.Dispose();
socket = null;
}
}
Disconnected?.Invoke(this, new DisconnectedEventArgs(userRequestedDisconnect));
}
private async Task CloseAsync(Exception e, bool awaitAll)
{
if (!IsOpen)
{
return;
}
foreach (OwnTcpServerConnection connection in connections.ToArray())
{
await CloseConnection(connection).ConfigureAwait(false);
}
isOpen = false;
listener.Stop();
await processQueue.End();
Task raiseTask = RaiseDisconnected();
if (awaitAll)
{
await raiseTask.ConfigureAwait(false);
}
async Task RaiseDisconnected()
{
if (openTask != null)
{
await openTask.ConfigureAwait(false);
}
if (e != null)
{
}
Disconnected?.Invoke(this, new DisconnectedEventArgs(e == null, e));
}
}
/// <summary>
/// Connect this instance to the specified URL, and authenticate (if needed) with the specified password
/// </summary>
/// <param name="url">Server URL in standard URL format.</param>
/// <param name="password">Server password</param>
public void Connect(string url, string password)
{
if (!url.ToLower().StartsWith(WEBSOCKET_URL_PREFIX))
{
throw new ArgumentException($"Invalid url, must start with '{WEBSOCKET_URL_PREFIX}'");
}
if (WSConnection != null && WSConnection.IsAlive)
{
Disconnect();
}
WSConnection = new WebSocket(url)
{
WaitTime = wsTimeout
};
WSConnection.OnMessage += WebsocketMessageHandler;
WSConnection.OnClose += (s, e) =>
{
Disconnected?.Invoke(this, e);
};
WSConnection.Connect();
if (!WSConnection.IsAlive)
{
return;
}
OBSAuthInfo authInfo = GetAuthInfo();
if (authInfo.AuthRequired)
{
Authenticate(password, authInfo);
}
Connected?.Invoke(this, null);
}
public static async Task <ConnectStatus> Connect(string host)
{
TcpClient tcp = null;
try {
tcp = new TcpClient();
await tcp.ConnectAsync(host ?? Protocol.Localhost, Protocol.Port);
} catch {
tcp?.Dispose();
return(ConnectStatus.Failed);
}
AlebClient.LogCommunication = true;
Server = new AlebClient(tcp);
Server.MessageReceived += Received;
Server.Disconnected += _ => Disconnected?.Invoke();
Server.Name = "Server";
Task <Message> VersionTask = Register("Version");
Server.Run();
await VersionTask;
if (Convert.ToInt32((await VersionTask).Args[0]) != Protocol.Version)
{
Server.Dispose();
Server = null;
return(ConnectStatus.VersionMismatch);
}
return(ConnectStatus.Success);
}
public API(FadeProxyClient proxy, Mode mode = Mode.BOT)
{
this.mode = mode;
// Depedency injection
Account = new Account(this);
_proxy = proxy;
_vanillaClient = new VanillaClient(this, proxy);
Account.LoginSucceed += (s, e) => Connect();
_vanillaClient.Disconnected += (s, e) => Disconnected?.Invoke(s, e);
_vanillaClient.HeroInited += (s, e) =>
{
HeroInited?.Invoke(s, e);
if (LoginTime == DateTime.MinValue)
{
LoginTime = DateTime.Now;
}
};
_vanillaClient.Attacked += (s, e) => Attacked?.Invoke(s, e);
_vanillaClient.ShipMoving += (s, e) => ShipMoving?.Invoke(s, e);
_vanillaClient.Destroyed += (s, e) => Destroyed?.Invoke(s, e);
}
public virtual void Disconnect(bool error)
{
TR.Enter();
if (Interlocked.Exchange(ref disposed, 1) == 0)
{
Disconnected?.Invoke(this, error);
bool needSync = false;
lock (missions_global)
lock (missions)
if (missions.Count > 0)
{
foreach (UInt256 hash in missions)
{
missions_global.Remove(hash);
}
needSync = true;
}
if (needSync)
{
localNode.RequestGetBlocks();
}
}
TR.Exit();
}
public async Task <bool> DisconnectAsync(CancellationTokenSource tokenSource, bool reconnect)
{
if (tokenSource == null)
{
tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(10));
}
if (Client == null || string.IsNullOrEmpty(ClientUniqueId))
{
return(false);
}
while (!tokenSource.Token.IsCancellationRequested)
{
if (Client.GetStream().DataAvailable)
{
await Task.Delay(1).ConfigureAwait(false);
continue;
}
Client.Close();
Client?.Dispose();
break;
}
tokenSource.Dispose();
lock (CoreServerBase.ConnectedClients) {
if (CoreServerBase.ConnectedClients.ContainsKey(ClientUniqueId))
{
CoreServerBase.ConnectedClients.TryRemove(ClientUniqueId, out _);
}
}
Disconnected?.Invoke(this, new OnDisconnectedEventArgs(ClientUniqueId, DateTime.Now, reconnect));
return(true);
}
private async Task DisconnectInternalAsync(Task sender, Exception exception)
{
InitiateDisconnect();
var clientWasConnected = IsConnected;
IsConnected = false;
try
{
await WaitForTaskAsync(_packetReceiverTask, sender).ConfigureAwait(false);
await WaitForTaskAsync(_keepAliveMessageSenderTask, sender).ConfigureAwait(false);
if (_adapter != null)
{
await _adapter.DisconnectAsync(_options.CommunicationTimeout, CancellationToken.None).ConfigureAwait(false);
}
_logger.Verbose("Disconnected from adapter.");
}
catch (Exception adapterException)
{
_logger.Warning(adapterException, "Error while disconnecting from adapter.");
}
finally
{
_adapter?.Dispose();
_adapter = null;
_cancellationTokenSource?.Dispose();
_cancellationTokenSource = null;
_cleanDisconnectInitiated = false;
_logger.Info("Disconnected.");
Disconnected?.Invoke(this, new MqttClientDisconnectedEventArgs(clientWasConnected, exception));
}
}
/// <inheritdoc/>
public void Disconnect(DisconnectedEventArgs e = null)
{
var didDisconnect = false;
if (!_isDisconnecting)
{
_isDisconnecting = true;
try
{
try
{
if (_sender != null)
{
_sender.Close();
_sender.Dispose();
didDisconnect = true;
}
}
catch (Exception)
{
}
_sender = null;
if (didDisconnect)
{
_connectedEvent.Reset();
Disconnected?.Invoke(this, e ?? DisconnectedEventArgs.Empty);
}
}
finally
{
_isDisconnecting = false;
}
}
}
public void Disconnect()
{
if (!IsConnected)
{
return;
}
_remoteAddress = null;
_remotePort = 0;
disconnectTimer.Stop();
backlog.Clear();
currentPacket.Clear();
try {
socket.Disconnect(false);
socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
} catch (Exception ex) {
Error?.Invoke(this, new ExceptionEventArgs(ex));
return;
}
Disconnected?.Invoke(this, EventArgs.Empty);
}
private void HandleDisconnect(bool remote)
{
/*
* Disconnect paths:
* pre: receive handler running, send possible in progress
* - local disconnect:
* - DisconnectAsync
* -> cancel token
* ReceiveHandler
* -> HandleDisconnect(remote = !token.canceled)
* - socket.close
* - event disconnected
* - remote disconnect
* - socket loses connection
* ReceiveHandler
* -> HandleDisconnect(remote = !token.canceled)
* - event disconnected
*/
_socket.Close();
Disconnected?.Invoke(this, new DisconnectedArgs(remote));
}
private void ProcessRequests()
{
try
{
foreach (Request request in RequestQueue.ToArray())
{
string serializedRequest = JsonConvert.SerializeObject(request);
this.OutputStreamWriter.WriteLine(Utils.Base64Encode(serializedRequest));
this.OutputStreamWriter.Flush();
RequestQueue.Remove(request);
}
} catch (Exception)
{
Utils.LogLine("Błąd podczas wysyłania. Odświeżanie połączenia...");
RequestQueue.Clear();
Disconnected?.Invoke();
OutputStreamWriter = null;
WaitForConnection();
}
}
public void Init(string clientId, IMqttClientOptions mqttClientOptions)
{
try
{
this.mqttClientOptions = mqttClientOptions;
var factory = new MqttFactory();
_mqttClient = factory.CreateMqttClient();
_mqttClient.ConnectedHandler = new MqttConnectedHandler(mqttClientConnectedEventArgs =>
{
Connected?.Invoke(this, mqttClientConnectedEventArgs);
});
_mqttClient.DisconnectedHandler = new MqttDisconnectedHandler(disconnectEventArgs =>
{
Disconnected?.Invoke(this, disconnectEventArgs);
});
_mqttClient.ApplicationMessageReceivedHandler = new MqttMessageReceivedHandler(messageReceivedArgs =>
{
MessageReceived?.Invoke(this, messageReceivedArgs);
});
}
catch (Exception ex)
{
}
}
void disconnectSP()
{
if (OnVirtualChannelCheck != null)
{
if (OnVirtualChannelCheck(debugChannelAddressesCB.Text))
{
connectB_Text = "Connect";
connectB_ForeColor = Color.Black;
Disconnected?.Invoke(this, new EventArgs());
VirutualChannelDisconnected?.Invoke(debugChannelAddressesCB.Text);
return;
}
}
try
{
Channel.Close();
Channel = null;
}
catch { }
hasUiUpdate = true;
connectB_Text = "Connect";
connectB_ForeColor = Color.Black;
Disconnected?.Invoke(this, new EventArgs());
}
private void AcceptConnections(IAsyncResult result)
{
var resultWrapper = (Client)result.AsyncState;
try
{
resultWrapper.ReplaceSslStream(result, m_Socket);
resultWrapper.BeginAuthenticateAsServer(EndAuthenticate);
m_Socket.BeginAccept(AcceptConnections, new Client());
}
catch (Exception e)
{
Console.WriteLine(e);
if (e.InnerException != null)
{
Console.WriteLine(e.InnerException);
}
Disconnected?.Invoke(this, resultWrapper);
resultWrapper.CloseAndDisposeSslStream();
}
}
private protected void Disconnect(DisconnectReason reason)
{
if (_clientSocket != null && _state != 0)
{
if (reason != DisconnectReason.Aborted && reason != DisconnectReason.Error)
{
Send(CommandID.DISCONNECT, new byte[1] {
255
}, 0, 1);
}
_state = 0;
try
{
_clientSocket.Shutdown(SocketShutdown.Both);
_clientSocket.Close(CLOSE_TIMEOUT);
}
catch
{
/* IGNORE */
}
_clientSocket = null;
Disconnected?.Invoke(this, reason);
}
}
private void HandleRequest(RequestData request)
{
switch (request.Request)
{
case Request.Disconnect:
// server closed or kicked player
client?.Close();
server?.Close();
client = null;
server = null;
Disconnected?.Invoke(this, EventArgs.Empty);
break;
case Request.Heartbeat:
// TODO
break;
default:
// all other requests can not be send to a client
throw new ExceptionFreeserf(ErrorSystemType.Network, $"Request {request.ToString()} can not be send to client.");
}
RespondToRequest(request);
}
