protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
lock (ServerArena.Instance)
{
ServerArena.Instance.Exit(this);
}
}
public void SshConnectionExceptionConstructorTest2()
{
string message = string.Empty; // TODO: Initialize to an appropriate value
DisconnectReason disconnectReasonCode = new DisconnectReason(); // TODO: Initialize to an appropriate value
SshConnectionException target = new SshConnectionException(message, disconnectReasonCode);
Assert.Inconclusive("TODO: Implement code to verify target");
}
private void CloseConnection(bool force, DisconnectReason reason, int socketErrorCode)
{
lock (_connectionCloseLock)
{
//Nothing to do
if (!IsRunning)
return;
//Send goodbye
if (_peer != null && !force && _connected)
{
//Send disconnect data
var disconnectPacket = NetPacket.CreateRawPacket(PacketProperty.Disconnect, 8);
FastBitConverter.GetBytes(disconnectPacket, 1, _connectId);
SendRaw(disconnectPacket, _peer.EndPoint);
}
//Clear data
_peer = null;
_connected = false;
_connectTimer = 0;
_connectAttempts = 0;
SocketClearPeers();
//Send event to Listener
var netEvent = CreateEvent(NetEventType.Disconnect);
netEvent.DisconnectReason = reason;
netEvent.AdditionalData = socketErrorCode;
EnqueueEvent(netEvent);
}
}
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
lock (syncRoot)
{
BroadcastMessage -= this.OnBroadcastMessage;
}
}
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
var remoteAddress = this.RemoteIP + ":" + this.RemotePort;
PhotonWireApplicationBase.Instance.Logger.InboundPeerOnDisconnect(PhotonWireApplicationBase.Instance.ApplicationName, remoteAddress, this.ConnectionId, reasonCode.ToString(), reasonDetail);
PeerManager.InboundServerConnections.Remove(this);
List<Exception> exceptions = new List<Exception>();
Action<int, string>[] copy;
lock (disconnectActions)
{
if (disconnectActions.Count == 0) return;
copy = new Action<int, string>[disconnectActions.Count];
disconnectActions.CopyTo(copy);
}
foreach (var item in copy)
{
try
{
item((int)reasonCode, reasonDetail);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
if (exceptions.Count > 0)
{
throw new AggregateException(exceptions);
}
}
public void DisconnectMessageConstructorTest1()
{
DisconnectReason reasonCode = new DisconnectReason(); // TODO: Initialize to an appropriate value
string message = string.Empty; // TODO: Initialize to an appropriate value
DisconnectMessage target = new DisconnectMessage(reasonCode, message);
Assert.Inconclusive("TODO: Implement code to verify target");
}
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Latency monitoring client disconnected: reason={0}, detail{1}", reasonCode, reasonDetail);
}
}
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
lock (StarCollectorGame.Instance)
{
StarCollectorGame.Instance.PeerLeft(this);
}
}
public static bool IsDefined(DisconnectReason value)
{
if ((((value != DisconnectReason.LeavingMesh) && (value != DisconnectReason.NotUsefulNeighbor)) && ((value != DisconnectReason.DuplicateNeighbor) && (value != DisconnectReason.DuplicateNodeId))) && (value != DisconnectReason.NodeBusy))
{
return (value == DisconnectReason.InternalFailure);
}
return true;
}
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
World.Instance.RemoveClient(this);
var sendParameters = new SendParameters();
sendParameters.Unreliable = true;
WorldExitHandler(sendParameters);
Log.Debug("Disconnected!");
}
/// <summary>
/// Initializes a new instance of the <see cref="DisconnectMessage"/> class.
/// </summary>
/// <param name="reasonCode">The reason code.</param>
/// <param name="message">The message.</param>
public DisconnectMessage(DisconnectReason reasonCode, string message)
{
ReasonCode = reasonCode;
Description = message;
#if TUNING
Language = "en";
#endif
}
public static bool OnDisconnectStatic(DisconnectReason reason, string message)
{
if (Settings.AutoRelog_Enabled)
{
AutoRelog bot = new AutoRelog(Settings.AutoRelog_Delay, Settings.AutoRelog_Retries);
return bot.OnDisconnect(reason, message);
}
return false;
}
public DisconnectMessage(DisconnectReason reasonCode, string description = "", string language = "en")
{
Contract.Requires(description != null);
Contract.Requires(language != null);
ReasonCode = reasonCode;
Description = description;
Language = language;
}
/// <summary>
/// Called when Photon internally disconnects the peer.
/// </summary>
/// <param name="reasonCode">Reason for disconnecting.</param>
/// <param name="reasonDetail">Detailed reason string.</param>
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
//Null the peer out otherwise we will leak. Trust me.
GladNetPeer = null;
//Disconnects the peer
disconnectionServiceHandler.Disconnect();
networkReciever.OnNetworkMessageReceive(new PhotonStatusMessageAdapter(NetStatus.Disconnected), null);
}
//, own_address=None, bond_info=None):
public MasterEmulator( String peer_device_address, Int32 baud_rate=1000000 )
{
this.peer_device_address = peer_device_address;
this.num_of_errors = 0;
//logger = TimestampLogger();
this.connected = false;
this.disconnect_event_expected = true;
this.service_setup_done = true;
this.last_disconnect_reason = DisconnectReason.UnspecifiedError; // = -1;
this.baud_rate = baud_rate;
//this.own_address = own_address;
//this.bond_info = bond_info;
}
public override bool OnDisconnect(DisconnectReason reason, string message)
{
message = GetVerbatim(message);
string comp = message.ToLower();
foreach (string msg in dictionary)
{
if (comp.Contains(msg))
{
LogToConsole("Waiting " + delay + " seconds before reconnecting...");
System.Threading.Thread.Sleep(delay * 1000);
McTcpClient.ReconnectionAttemptsLeft = attempts;
ReconnectToTheServer();
return true;
}
}
return false;
}
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
if (!DisconnectAsWanderer())
{
if (!DisconnectAsPlayer())
{
REServer.log.Info("Disconnect Error because we don't know what is the target");
}
else
{
REServer.log.Info(player.account + ": Disconnet");
}
}
else
{
REServer.log.Info(guid+": Disconnet");
}
}
public void OnDisconnected (DisconnectReason reason, string message)
{
SparkleLogger.LogInfo ("Listener", "Disconnected from " + Server + ": " + message);
Disconnected (reason);
}
/// <summary>
/// Called when client disconnects.
/// Ensures that disconnected players leave the game <see cref = "Room" />.
/// The player is not removed immediately but a message is sent to the room. This avoids
/// threading issues by making sure the player remove is not done concurrently with operations.
/// </summary>
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("OnDisconnect: conId={0}, reason={1}, reasonDetail={2}", this.ConnectionId, reasonCode, reasonDetail);
}
if (this.RoomReference == null)
{
return;
}
var message = new RoomMessage((byte)GameMessageCodes.RemovePeerFromGame, this);
this.RoomReference.Room.EnqueueMessage(message);
this.RoomReference.Dispose();
this.RoomReference = null;
}
private void ListenerDisconnectedDelegate (DisconnectReason reason)
{
SparkleLogger.LogInfo (Name, "Falling back to regular polling");
this.poll_interval = PollInterval.Short;
this.last_disconnect_reason = reason;
if (reason == DisconnectReason.SystemSleep) {
this.remote_timer.Stop ();
int backoff_time = 2;
do {
SparkleLogger.LogInfo (Name, "Next reconnect attempt in " + backoff_time + " seconds");
Thread.Sleep (backoff_time * 1000);
this.listener.Connect ();
backoff_time *= 2;
} while (backoff_time < 64 && !this.listener.IsConnected);
this.remote_timer.Start ();
}
}
public DisconnectEventArgs( DisconnectReason reason, String comment )
{
Reason = reason;
Comment = comment;
}
public SshConnectionException(string message, DisconnectReason disconnectReason = DisconnectReason.None)
: base(message)
{
DisconnectReason = disconnectReason;
}
public void OnPeerDisconnected(NetPeer peer, DisconnectReason disconnectReason, int socketErrorCode)
{
Console.WriteLine("[Client] disconnected: " + disconnectReason);
}
/// <summary>
/// Initializes a new instance of the <see cref="SshConnectionException"/> class.
/// </summary>
/// <param name="message">The message.</param>
public SshConnectionException(string message)
: base(message)
{
DisconnectReason = DisconnectReason.None;
}
/// <summary>
/// Initializes a new instance of the <see cref="DisconnectEventArgs" /> class.
/// </summary>
/// <param name="reason">The reason.</param>
public DisconnectEventArgs(DisconnectReason reason)
{
Reason = reason;
}
public abstract void InitiateDisconnect(DisconnectReason disconnectReason, string details);
public DisconnectEventArgs(DisconnectReason disconnectReason, DisconnectType disconnectType, string details)
{
DisconnectReason = disconnectReason;
DisconnectType = disconnectType;
Details = details;
}
private PlayerServer()
{
ExitReason = DisconnectReason.AllGood;
ApproveLoadWorldReason = ApproveLoadWorldReason.LoginOk;
}
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
_peerCollection.Remove(ClientId);
BroadcastNotify -= broadcastNotify; // un-sub event
}
public override void DisconnectProtocol(DisconnectReason disconnectReason, string details)
{
Dispose();
}
private void Disconnect(ISession session, DisconnectReason reason, string details)
{
session.InitiateDisconnect(reason, details);
}
/// <summary>
/// Initializes a new instance of the <see cref="DisconnectEventArgs" /> class.
/// </summary>
/// <param name="reason">The reason.</param>
public DisconnectEventArgs(DisconnectReason reason)
{
Reason = reason;
}
public void KickConnection(NetConnection connection, DisconnectReason reason, string additionalInfo = null)
{
connection.Disconnect(reason, additionalInfo);
}
/// <summary>
/// Is called when the client has been disconnected fom the server
/// </summary>
/// <param name="reason">Disconnect Reason</param>
/// <param name="message">Kick message, if any</param>
/// <returns>Return TRUE if the client is about to restart</returns>
public virtual bool OnDisconnect(DisconnectReason reason, string message)
{
return(false);
}
public virtual void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
this.ReconnectToMaster();
this.Application.OnDisconnectFromMaster(this);
}
public void OnPeerDisconnected(NetPeer peer, DisconnectReason disconnectReason, int socketErrorCode)
{
Console.WriteLine("[Server] Peer disconnected: " + peer.EndPoint + ", reason: " + disconnectReason);
}
public void Disconnect()
{
_messageProvider.Disconnect();
_disconnectReason = DisconnectReason.User;
}
/// <summary>
/// Initializes a new instance of the <see cref="SshConnectionException"/> class.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="disconnectReasonCode">The disconnect reason code.</param>
/// <param name="inner">The inner.</param>
public SshConnectionException(string message, DisconnectReason disconnectReasonCode, Exception inner)
: base(message, inner)
{
DisconnectReason = disconnectReasonCode;
}
public WiimoteDisconnectedEventArgs(Wiimote wiimote, DisconnectReason reason)
: base(wiimote)
{
Reason = reason;
}
public override void onDisconnect(DisconnectReason Reason)
{
}
public void Disconnect(DisconnectReason reason, string details)
{
Disconnected?.Invoke(this, EventArgs.Empty);
}
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
base.OnDisconnect(reasonCode, reasonDetail);
this.onDisconnectEvent.Set();
}
public Task DisconnectAsync(DisconnectReason disconnectReason, DisconnectType disconnectType)
{
return(Task.CompletedTask);
}
private void ListenerConnectedDelegate ()
{
if (this.last_disconnect_reason == DisconnectReason.SystemSleep) {
this.last_disconnect_reason = DisconnectReason.None;
if (HasRemoteChanges && !this.is_syncing)
SyncDownBase ();
}
this.poll_interval = PollInterval.Long;
}
public Task InitiateDisconnectAsync(DisconnectReason disconnectReason)
{
Disconected = true;
DisconnectReason = disconnectReason;
return(Task.CompletedTask);
}
private void DisconnectUnauthClient(NetIncomingMessage inc, UnauthenticatedClient unauthClient, DisconnectReason reason, string message)
{
inc.SenderConnection.Disconnect(reason.ToString() + "/ " + TextManager.GetServerMessage(message));
if (unauthClient.SteamID > 0)
{
Steam.SteamManager.StopAuthSession(unauthClient.SteamID);
}
if (unauthClient != null)
{
unauthenticatedClients.Remove(unauthClient);
}
}
public ConnectionClosedEventArgs(UdpConnection connection, DisconnectReason reason, UdpRawMessage payload)
{
this.Connection = connection;
this.Reason = reason;
this.Payload = payload;
}
/// <summary>
/// Reads the payload.
/// </summary>
/// <param name="message">The message.</param>
public override void ReadPayload(NetIncomingMessage message)
{
base.ReadPayload(message);
Reason = (DisconnectReason) message.ReadByte();
}
public void Disconnect(DisconnectReason reason, string details)
{
throw new NotImplementedException();
}
/// <summary>
/// Is called when the client has been disconnected fom the server
/// </summary>
/// <param name="reason">Disconnect Reason</param>
/// <param name="message">Kick message, if any</param>
/// <returns>Return TRUE if the client is about to restart</returns>
public virtual bool OnDisconnect(DisconnectReason reason, string message) { return false; }
public ClientDisconnected(INatsClient client, DisconnectReason reason)
{
Client = client;
Reason = reason;
}