public Action Connect(string path, dynamic mode) { return(new Action(() => { Disconnect()(); mbSession = ( MessageBasedSession )ResourceManager.GetLocalManager().Open(path); //LoadSetting(); //SaveSetting(); LoadConfig(mode); CreateCamObj(); })); }
/// <summary> /// Handles the server's login reply /// </summary> static public void Handle_SC_Login(SC_Login pkt, Client client) { GameClient c = ((client as Client <GameClient>)._obj); InfServer.Log.write(String.Format("(Result={0}) - (Config={1}) - (Message={2})", pkt.result, pkt.zoneConfig, pkt.popupMessage)); //No sense in being connected anymore if (pkt.result == SC_Login.Login_Result.Failed) { Disconnect discon = new Disconnect(); discon.connectionID = client._connectionID; discon.reason = Disconnect.DisconnectReason.DisconnectReasonApplication; client.send(discon); c._bLoginSuccess = false; return; } c._bLoginSuccess = true; //Signal our completion c._syncStart.Set(); if (c.loadAssets(pkt.zoneConfig)) { InfServer.Log.write(String.Format("Could not load game assets, exiting..")); c.quit(); return; } //Must have been a success, lets let the server know we're ready. client.send(new CS_Ready()); }
// Установка ника при подключении, в конце ожидается ответ от сервера об успешном подключении public static void SetUsername() { if (_tcpClient != null) { var stream = _tcpClient.GetStream(); var buffer = new byte[2048]; string data = null; int i; while ((i = stream.Read(buffer, 0, buffer.Length)) != 0) { data = Encoding.Unicode.GetString(buffer, 0, i); if (IsOkMessage(data)) { SendOkMessage(); break; } SetMessage?.Invoke(data, true); } if (NeedDisconnect(i)) { Disconnect?.Invoke(); } } }
public async Task when_sending_disconnect_and_client_session_has_clean_state_then_disconnects_and_delete_will_and_session() { var connectionProvider = new Mock <IConnectionProvider> (); var sessionRepository = new Mock <IRepository <ClientSession> >(); var willRepository = new Mock <IRepository <ConnectionWill> > (); var flow = new DisconnectFlow(connectionProvider.Object, sessionRepository.Object, willRepository.Object); var clientId = Guid.NewGuid().ToString(); var channel = new Mock <IMqttChannel <IPacket> > (); var disconnect = new Disconnect(); var session = new ClientSession(clientId, clean: true); connectionProvider .Setup(p => p.GetConnection(It.Is <string> (c => c == clientId))) .Returns(channel.Object); sessionRepository.Setup(r => r.Read(It.IsAny <string>())).Returns(session); await flow.ExecuteAsync(clientId, disconnect, channel.Object) .ConfigureAwait(continueOnCapturedContext: false); willRepository.Verify(r => r.Delete(It.IsAny <string> ())); sessionRepository.Verify(r => r.Delete(It.Is <string>(s => s == session.Id))); }
public static void Disconnect(Disconnect P) { Network.Disconnect(); SceneFunctions.ConClosed = true; MirMessageBox MMBox; switch (P.Reason) { case 0: MMBox = new MirMessageBox("You have been disconnected from the game."); MMBox.OKButton.Click += (o, e) => SceneFunctions.QuitGame(); MMBox.Show(); break; case 1: MMBox = new MirMessageBox("You have been disconnected from the game,\nAnother user logged onto your account."); MMBox.OKButton.Click += (o, e) => SceneFunctions.QuitGame(); MMBox.Show(); break; #if DEBUG default: throw new NotImplementedException(); #endif } }
private void HandleDisconnection(Disconnect disconnect, Address sender) { var sessionId = this.peers.GetValueOrDefault(disconnect.ClientId); string message; if (sessionId is null) { // Peer not previously connected to a session sessionId = SessionId.None(); message = $"{sender.Value} had no session to disconnect from {this.serviceName.Value}"; this.Logger.LogWarning(LogId.Network, message); } else { // Peer connected to a session this.peers.Remove(disconnect.ClientId); // Pop from dictionary message = $"{sender.Value} disconnected from {this.serviceName.Value} session {sessionId.Value}"; this.Logger.LogInformation(LogId.Network, message); } var response = new Disconnected( message, this.serverId, sessionId, disconnect.Id, this.NewGuid(), this.TimeNow()); this.SendMessage(response, sender); }
public CloudClient(IContainer container) { SyncWaitDic = new ConcurrentDictionary <long, ReturnEventWaitHandle>(10, 10000); AsyncCallDiy = new ConcurrentDictionary <long, AsyncCalls>(); CallBackDiy = new ConcurrentDictionary <long, AsyncCalls>(); AsyncRunDiy = new ConcurrentDictionary <long, AsyncRun>(); AsyncWaitTimeOut = new List <KeyValuePair <long, DateTime> >(); FodyDir = new Dictionary <Type, Type>(); ClientManager = container.Resolve <IConnectionManager>(); ClientManager.BinaryInput += DataOn; ClientManager.Disconnect += p => Disconnect?.Invoke(p); MillisecondsTimeout = container.Resolve <TimeOutOptions>().MillisecondsTimeout; IsCheckAsyncTimeOut = container.Resolve <TimeOutOptions>().IsCheckAsyncTimeOut; Sync = new ZYSync() { SyncSend = SendData, SyncSendAsWait = SendDataAsWait }; Module = container.Resolve <IModuleDictionary>(); IsClose = false; LoggerFactory = container.Resolve <ILoggerFactory>(); Log = new DefaultLog(LoggerFactory.CreateLogger <CloudClient>()); Task.Run(new Action(CheckAsyncTimeOut)); }
internal static void HandleRemovedEvent(int instanceId) { Logger.Log($"Joystick Removed: Instance [{ instanceId }]", LogPriority.Verbose); Disconnect?.Invoke(instanceId); openGamepads.Remove(instanceId); }
public virtual void Send(byte[] data) { try { _SendObj.Send(data); } catch (ObjectDisposedException) { IsConn = false; Disconnect?.Invoke("与服务器断开连接"); } catch (SocketException) { try { wait.Dispose(); AsynEvent.Dispose(); _sock.Close(); _sock.Dispose(); } catch { } IsConn = false; Disconnect?.Invoke("与服务器断开连接"); } }
public void Disconnect(DisconnectReason reason, string message) { m_Logger.LogDebug($"Disconnected - {reason} - {message}"); if (m_Socket != null) { if (reason != DisconnectReason.None) { try { Disconnect disconnect = new Disconnect() { Reason = reason, Description = message }; Send(disconnect); } catch (Exception) { } } try { m_Socket.Shutdown(SocketShutdown.Both); } catch (Exception) { } m_Socket = null; } }
/// <summary> /// Callback method that MdsLib calls when a device connects or disconnects /// </summary> /// <param name="mdsevent">details of device connection/disconnection</param> public void OnDeviceConnectionEvent(MDSEvent mdsevent) { var method = ((NSString)mdsevent.BodyDictionary.ValueForKey(new NSString("Method"))); if (method == new NSString("POST")) { // Device connected var bodyDict = (NSDictionary)mdsevent.BodyDictionary.ValueForKey(new NSString("Body")); var serial = (NSString)bodyDict.ValueForKey(new NSString("Serial")); var connDict = (NSDictionary)bodyDict.ValueForKey(new NSString("Connection")); var uuid = (NSString)connDict.ValueForKey(new NSString("UUID")); Debug.WriteLine($"MdsConnectionListener OnDeviceConnectionEvent CONNECTED: Serial {serial}"); ConnectionComplete?.Invoke(this, new MdsConnectionListenerEventArgs(serial, new Guid(uuid))); } else if (method == new NSString("DEL")) { // Device disconnected var serial = ((NSString)mdsevent.BodyDictionary.ValueForKey(new NSString("Serial"))); Debug.WriteLine($"MdsConnectionListener OnDeviceConnectionEvent DISCONNECTED: Serial {serial}"); Disconnect?.Invoke(this, new MdsConnectionListenerEventArgs(serial)); } else { throw new MdsException($"OnDeviceConnectionEvent unexpected method: {method}"); } }
public void DisconnectNumbersWithDefaultClientTest() { var data = new DisconnectTelephoneNumberOrder { Name = "order", DisconnectTelephoneNumberOrderType = new DisconnectTelephoneNumberOrderType { TelephoneNumbers = new[] { "111", "222" } } }; using (var server = new HttpServer(new RequestHandler { EstimatedMethod = "POST", EstimatedPathAndQuery = string.Format("/v1.0/accounts/{0}/disconnects", Helper.AccountId), EstimatedContent = Helper.ToXmlString(data) })) { Disconnect.Create("order", "111", "222").Wait(); if (server.Error != null) { throw server.Error; } } }
public void GetNotesTest() { using (var server = new HttpServer(new RequestHandler { EstimatedMethod = "GET", EstimatedPathAndQuery = string.Format("/v1.0/accounts/{0}/disconnects/1/notes", Helper.AccountId), ContentToSend = new StringContent(TestXmlStrings.NotesResponse, Encoding.UTF8, "application/xml") })) { var client = Helper.CreateClient(); var disconnect = new Disconnect(); disconnect.SetClient(client); var list = disconnect.GetNotes("1").Result; if (server.Error != null) { throw server.Error; } Assert.AreEqual(2, list.Length); Assert.AreEqual("11299", list[0].Id); Assert.AreEqual("customer", list[0].UserId); Assert.AreEqual("Test", list[0].Description); Assert.AreEqual("11301", list[1].Id); Assert.AreEqual("customer", list[1].UserId); Assert.AreEqual("Test1", list[1].Description); } }
public async Task when_sending_disconnect_and_client_session_has_persistent_state_then_disconnects_and_preserves_session() { Mock <IConnectionProvider> connectionProvider = new Mock <IConnectionProvider>(); Mock <IRepository <ClientSession> > sessionRepository = new Mock <IRepository <ClientSession> >(); Mock <IRepository <ConnectionWill> > willRepository = new Mock <IRepository <ConnectionWill> >(); DisconnectFlow flow = new DisconnectFlow(connectionProvider.Object, sessionRepository.Object, willRepository.Object); string clientId = Guid.NewGuid().ToString(); Mock <IMqttChannel <IPacket> > channel = new Mock <IMqttChannel <IPacket> >(); Disconnect disconnect = new Disconnect(); ClientSession session = new ClientSession(clientId, clean: false); connectionProvider .Setup(p => p.GetConnection(It.Is <string>(c => c == clientId))) .Returns(channel.Object); sessionRepository.Setup(r => r.Read(It.IsAny <string>())).Returns(session); await flow.ExecuteAsync(clientId, disconnect, channel.Object); willRepository.Verify(r => r.Delete(It.IsAny <string>())); sessionRepository.Verify(r => r.Delete(It.Is <string>(s => s == session.Id)), Times.Never); }
public async Task when_sending_disconnect_and_client_session_has_persistent_state_then_disconnects_and_preserves_session() { var connectionProvider = new Mock <IConnectionProvider> (); var sessionRepository = new Mock <IRepository <ClientSession> >(); var willRepository = new Mock <IRepository <ConnectionWill> > (); var flow = new DisconnectFlow(connectionProvider.Object, sessionRepository.Object, willRepository.Object); var clientId = Guid.NewGuid().ToString(); var channel = new Mock <IMqttChannel <IPacket> > (); var disconnect = new Disconnect(); var session = new ClientSession { ClientId = clientId, Clean = false }; connectionProvider .Setup(p => p.GetConnection(It.Is <string> (c => c == clientId))) .Returns(channel.Object); sessionRepository.Setup(r => r.Get(It.IsAny <Expression <Func <ClientSession, bool> > >())).Returns(session); await flow.ExecuteAsync(clientId, disconnect, channel.Object) .ConfigureAwait(continueOnCapturedContext: false); willRepository.Verify(r => r.Delete(It.IsAny <Expression <Func <ConnectionWill, bool> > > ())); sessionRepository.Verify(r => r.Delete(It.Is <ClientSession>(s => s == session)), Times.Never); }
/// <summary> /// Handles a graceful zone disconnect /// </summary> static public void Handle_Disconnect(Disconnect <Zone> pkt, Zone zone) { Log.write("{0} disconnected gracefully", zone._zone.name); //Close our connection, calls zone._client.Destruct zone._client.destroy(); }
/// <summary> /// Handles the client's disconnection notice /// NOTE: Only sent by player clients /// </summary> static public void Handle_Disconnect(Disconnect pkt, Client client) { Log.write(TLog.Normal, "Client '{0}' disconnected.", client); //Destroy the client in question client.destroy(); }
public static bool TryUnpack(byte[] buf, int size, Encryptor encryptor, out Disconnect packet) { if (sizeof(byte) + sizeof(int) + sizeof(short) + Data.Length > size) { packet = default; return(false); } if (!encryptor.TryDecrypt(buf, 5, ref size)) { packet = default; return(false); } int offset = 1; var id = BinaryUtil.ReadInt(buf, ref offset); var seq = BinaryUtil.ReadShort(buf, ref offset); for (var i = 0; i < Data.Length; i++) { if (Data[i] != buf[offset + i]) { packet = default; return(false); } } packet = new Disconnect(id, seq); return(true); }
public void FireDisconnectEvent(int connectionId, byte reason) { Disconnect?.Invoke(connectionId, reason); Connections[connectionId].Cleanup(); Connections.Remove(connectionId); }
}// icprn public string ToReportStringFormat() { // seqNum, siteName, type, discMessage, discCode, APartyNum, BPartyNum,APartyType,BPartyType,APartyDigits,BPartyDigits, // SeizeTime, AnswerTime, DisconnectTime, CallDuration, CellId, OMSISDN, string comma = ","; char zero_pad = Convert.ToChar("0"); // only convert the fields being used in our report StringBuilder sb = new StringBuilder(); sb.Append(SequenceNumber + ","); string recordType = String.Empty; int theType = Convert.ToInt32(Type); switch (theType) { case (int)OmcCdrEnums.RecordType.Call_Record: recordType = OmcCdrEnums.RecordType.Call_Record.ToString(); break; case (int)OmcCdrEnums.RecordType.SMS_Record: recordType = OmcCdrEnums.RecordType.SMS_Record.ToString(); break; } // vessel id CiberDbMgr cDb = new CiberDbMgr(); string siteName = cDb.GetSiteNameForCellId(CellId); sb.Append(siteName + comma); sb.Append(recordType + comma); DisconnectCodeMgr dMgr = new DisconnectCodeMgr(); string dMessage = dMgr.GetDisconnectMessage(DisconnectCode); sb.Append(dMessage + comma); sb.Append(DisconnectCode + comma); sb.Append(A_Party_Num + comma); sb.Append(B_Party_Num + comma); string atype = dMgr.GetPartyType(A_Party_Type); string btype = dMgr.GetPartyType(B_Party_Type); sb.Append(atype + comma); sb.Append(btype + comma); sb.Append(A_Party_Digits + comma); sb.Append(B_Party_Digits + comma); sb.Append(Seize.ToString("s") + comma); sb.Append(Answer.ToString("s") + comma); sb.Append(Disconnect.ToString("s") + comma); // call duration TimeSpan callDuration = Disconnect.Subtract(Seize); string airChargeTime = callDuration.Hours.ToString().PadLeft(2, zero_pad) + ":" + callDuration.Minutes.ToString().PadLeft(2, zero_pad) + ":" + callDuration.Seconds.ToString("D2"); sb.Append(airChargeTime + comma); return(sb.ToString()); }
public async Task ExecuteAsync(string clientId, IPacket input, IMqttChannel <IPacket> channel) { if (input.Type != MqttPacketType.Disconnect) { return; } await Task.Run(() => { Disconnect disconnect = input as Disconnect; _tracer.Info(ServerProperties.DisconnectFlow_Disconnecting(clientId)); _willRepository.Delete(clientId); ClientSession session = _sessionRepository.Read(clientId); if (session == null) { throw new MqttException(ServerProperties.SessionRepository_ClientSessionNotFound(clientId)); } if (session.Clean) { _sessionRepository.Delete(session.Id); _tracer.Info(ServerProperties.Server_DeletedSessionOnDisconnect(clientId)); } _connectionProvider.RemoveConnection(clientId); }); }
private void ConnectionStatusChanged(NetConnectionStatus status, NetConnection networkConnection) { if (status == NetConnectionStatus.Connected) { Connection connection = new Connection(server, networkConnection); lock (connectionsByRemoteIdentifier) { connectionsByRemoteIdentifier[networkConnection.RemoteUniqueIdentifier] = connection; } } else if (status == NetConnectionStatus.Disconnected) { Connection connection = GetConnection(networkConnection.RemoteUniqueIdentifier); Player player = playerManager.GetPlayer(connection); if (player != null) { playerManager.PlayerDisconnected(connection); Disconnect disconnect = new Disconnect(player.Id); playerManager.SendPacketToAllPlayers(disconnect); List <SimulatedEntity> revokedGuids = entitySimulation.CalculateSimulationChangesFromPlayerDisconnect(player); if (revokedGuids.Count > 0) { SimulationOwnershipChange ownershipChange = new SimulationOwnershipChange(revokedGuids); playerManager.SendPacketToAllPlayers(ownershipChange); } } } }
/// <summary> /// Disconnect from a certain client reuse is false since the Socket object is removed from the list. /// </summary> /// <param name="sock">Socket to disconnect from</param> public void BeginDisconnect(Socket sock) { sock.Disconnect(false); SocketArgs args = new SocketArgs(sock); Connections.Remove(sock); Disconnect?.Invoke(this, args); }
private void WebSocketConnection_OnClose(object sender, IWebSocketConnection webSocketConnection) { if (connections.TryRemove(webSocketConnection.Id, out Connection connection)) { Disconnect?.Invoke(this, webSocketConnection); _logger.LogInformation($"WebSocketConnection: \"{webSocketConnection.Id}\" was closed", connection); } }
private void DisconnectCallback(IAsyncResult ar) { Connection.EndDisconnect(ar); SocketArgs args = new SocketArgs(Connection); Disconnect?.Invoke(this, args); }
private void EyeWebTestForm_FormClosing(object sender, FormClosingEventArgs e) { if (connected) { Disconnect.Invoke(sender, e); } Application.Exit(); }
internal void GivenDisconnectMessage_WhenConnected_SendsDisconnectedToSender() { // Arrange var server = new MessageServerFacade( this.container, this.messagingAdapter, this.compressor, EncryptionSettings.None(), this.testRequestAddress, this.testResponseAddress); server.Start().Wait(); var dealer = new TestDealer( this.container, this.headerSerializer, this.requestSerializer, this.responseSerializer, this.compressor, EncryptionSettings.None(), this.testRequestAddress, this.testResponseAddress, "001"); dealer.Start().Wait(); var connect = new Connect( dealer.ClientId, "None", Guid.NewGuid(), StubZonedDateTime.UnixEpoch()); dealer.Send(connect); var response1 = (Connected)dealer.Receive(); var disconnect = new Disconnect( dealer.ClientId, response1.SessionId, Guid.NewGuid(), StubZonedDateTime.UnixEpoch()); dealer.Send(disconnect); var response2 = (Disconnected)dealer.Receive(); // Assert Assert.Equal(typeof(Connected), response1.Type); Assert.Equal(typeof(Disconnected), response2.Type); Assert.Equal(2, server.ReceivedCount); Assert.Equal(2, server.SentCount); Assert.Equal("TestDealer-001 connected to test-server session None", response1.Message); Assert.Equal("TestDealer-001 disconnected from test-server session None", response2.Message); // Tear Down dealer.Stop().Wait(); server.Stop().Wait(); dealer.Dispose(); server.Dispose(); }
public void when_serializing_disconnect_then_can_roundtrip() { var message = new Disconnect(); var bytes = MessageChannel.Convert(message); var deserialized = MessageChannel.Convert(bytes) as Disconnect; Assert.NotNull(deserialized); }
private Task DisconnectHandler(WebSocketCloseStatus closeStatus, string closeReason) { var message = $"Websocket Connection Closed with following reason \"{closeReason}\" and StatusCode \"{closeStatus}\""; EmitLogs(LogLevel.Error, message); Disconnect?.Invoke(closeStatus, closeReason); return(Task.CompletedTask); }
private void OnDisconnect() { Disconnect?.Invoke(this, this); OutgoingCall = null; IncomingCall = null; Answer = null; Drop = null; Disconnect = null; }
private void OnDisconnect() { if (m_Socket != null) { m_Socket.Close(); m_Socket = null; } Disconnect?.Invoke(this, EventArgs.Empty); }
public static void StopServer(string stopMsg = "Shutting down server...") { ConsoleFunctions.WriteInfoLine("Shutting down..."); Disconnect d = new Disconnect(null); d.Reason = new McChatMessage("§f" + stopMsg); BroadcastPacket(d); ConsoleFunctions.WriteInfoLine("Saving all player data..."); foreach (var player in LevelManager.GetAllPlayers()) { player.SavePlayer(); } OperatorLoader.SaveOperators(); ConsoleFunctions.WriteInfoLine("Disabling plugins..."); PluginManager.DisablePlugins(); ConsoleFunctions.WriteInfoLine("Saving config file..."); Config.SaveConfig(); ConsoleFunctions.WriteInfoLine("Saving chunks..."); LevelManager.SaveAllChunks(); ServerListener.StopListenening(); Environment.Exit(0); }
private void HandleDisconnect(Disconnect msg) { _heartbeatActor.Tell(new ConnectionMessages.Disconnect()); _heartbeatActor.Tell(PoisonPill.Instance); _heartbeatActor = null; Become(Disconnected); }