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