void OnCloseInternal(object sender, CloseEventArgs e)
{
if (OnClose != null)
{
OnClose(this, e.Reason);
}
}
protected override void OnClose(CloseEventArgs e)
{
Program.Users.Remove(User);
//test
Program.Chanels.Remove(_test);
}
private void websocket_Closed(object sender, WebSocketSharp.CloseEventArgs e)
{
if (OnWebsocketClosed != null)
{
OnWebsocketClosed(this, e);
}
}
private void webSocketClient_Closed(object sender, WebSocketSharp.CloseEventArgs e)
{
if (!webSocketClient.IsAlive)
{
isRecon = true;
webSocketClient.ConnectAsync();
}
}
private void HandleOnClose(object sender, WebSocketSharp.CloseEventArgs e)
{
if (OnClose != null)
{
OnClose.Invoke(sender, new WebSocketCloseEventArgs(e.Reason, e.Code));
}
UnattachHandlers();
Dispose();
}
protected virtual void OnClose(WSServiceBehaviour behaviour, WebSocketSharp.CloseEventArgs e)
{
if (clientHanlders.Contains(behaviour))
{
clientHanlders.Remove(behaviour);
}
connectedClientsCount = clientHanlders.Count;
DebugService("WSServiceBehaviour closed with reason " + e.Reason + " connectedClientsCount= " + connectedClientsCount);
}
protected override void OnClose(WebSocketSharp.CloseEventArgs e)
{
Logger.Log("{0} has closed: ({1}) {2}", this, e.Code, e.Reason);
if (e.WasClean)
{
Logger.Log("The closure was not clean!");
}
HasTerminated = true;
}
protected override void OnClose(CloseEventArgs e)
{
log_.Info("closed");
EventHandler<CloseEventArgs> handler = OnCloseEvent;
if (handler != null)
{
handler(this, e);
}
}
protected override void OnClose(WebSocketSharp.CloseEventArgs e)
{
Debug.Log("socket dropped, currently open sessions: " + this.Sessions.Count);
Debug.Log(e.Reason);
string activeids = "";
foreach (string id in this.Sessions.ActiveIDs)
{
activeids += id + " ";
}
}
protected override void OnClose(CloseEventArgs e)
{
WSGroupServices.GetLogger().Info("Socket closed");
foreach (var client in _clients)
{
if (!client.Value.IsAlive && DoesFilterMatchIncomingNodeName(client.Key, WSGroupServices.GetFilter()))
{
ApplyOnDisconnect(client);
}
}
}
private void onClose(object sender, WebSocketSharp.CloseEventArgs eventArgs)
{
Debug.WriteLine("HuyaChatApiMsg::onClose() enter");
if (heartbeatTimer != null)
{
heartbeatTimer.Dispose();
heartbeatTimer = null;
}
bIsRunning = false;
Debug.WriteLine("HuyaChatApiMsg::onClose() leave");
}
void OnSocketClose(object sender, CloseEventArgs e)
{
if (_webSocket == null)
{
throw new ApplicationException("_webSocket can't be null");
}
Log.Write("WARN: RTM websocket closed. Reconnecting in a few seconds...");
Thread.Sleep(5000);
ConnectRtm();
}
private void _OnWebSocketClose(object sender, WebSocketSharp.CloseEventArgs e)
{
IsConnectedToFaceDetectionServer = false;
ActivityLog += "WebSocket Closed:" + e.Reason + "\n";
System.Threading.Thread.Sleep(5000);
_updateWS();
if (m_bMustConnect)
{
m_refWebSocket.ConnectAsync();
}
}
private void Client_Close(CloseEventArgs e)
{
if (InvokeRequired)
{
Invoke((MethodInvoker)delegate {
Client_Close(e);
});
return;
}
status.Text = "Connection closed.";
}
protected override void OnClose(WebSocketSharp.CloseEventArgs e)
{
if (webService != null)
{
// Queue the OnClose event to be called.
webServer.TaskQueue.Enqueue(() =>
{
webService.OnClose(e);
Destroy(serviceObject.gameObject);
});
}
}
protected override void OnClose(CloseEventArgs e) {
this.isReady = false;
if (this.onClose != null) {
this.onClose();
}
if (Settings.debug.info) {
Debug.Log("AirConsole: screen.html disconnected");
}
base.OnClose(e);
}
protected override void OnClose(CloseEventArgs e)
{
Program.Users.Remove(User);
try
{
Channel _chan = Program.Chanels.Single(a => a.UserIn(User) == true);
if (_chan != null)
{
_chan.RemoveUser(User);
}
}
catch { }
}
/// <summary>
/// websocket has closed unexpectedly - retry connection
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void wsClient_Closed(object sender, WebSocketSharp.CloseEventArgs e)
{
if (this.retryConnectionCount < this.RetryConnectionAttempts)
{
this.ConnectionOpenEvent.Reset();
this.ReConnect();
}
else
{
this.Close();
this.OnSocketConnectionClosedEvent(this, EventArgs.Empty);
}
}
private void OnCloseCallback(object sender, WebSocketSharp.CloseEventArgs e)
{
m_Socket.OnOpen -= OnOpenCallback;
m_Socket.OnMessage -= OnMessageCallback;
m_Socket.OnError -= OnErrorCallback;
m_Socket.OnClose -= OnCloseCallback;
if (this.NetworkChannelClosed != null)
{
this.NetworkChannelClosed(this);
}
m_Socket = null;
}
private void Socket_OnClose(object sender, CloseEventArgs e)
{
try
{
isClosed = true;
isConnected = false;
checkTimer.Stop();
logger.Error("Socket_OnClose, CloseEventArgs = " + JsonConvert.SerializeObject(e));
OnClosed(new WebSocket.EventArgs.CloseEventArgs()
{
Code = e.Code, Reason = e.Reason
});
}
catch (Exception ex)
{
logger.Error("socket_OnClose args = " + JsonConvert.SerializeObject(e) + "\n" + ex.ToString());
}
}
private void OnCloseHandler(object sender, CloseEventArgs e) {
Debug.Log("WebSocket closed with reason: " + e.Reason);
}
private void close(PayloadData data)
{
_logger.Debug ("Is this thread background?: " + Thread.CurrentThread.IsBackground);
var sent = false;
CloseEventArgs args = null;
lock (_forClose)
{
if (_readyState == WebSocketState.CLOSING || _readyState == WebSocketState.CLOSED)
return;
var current = _readyState;
_readyState = WebSocketState.CLOSING;
args = new CloseEventArgs (data);
if (current == WebSocketState.CONNECTING)
{
if (!_client)
{
close (HttpStatusCode.BadRequest);
return;
}
}
else
{
if (!data.ContainsReservedCloseStatusCode)
sent = send (createControlFrame (Opcode.CLOSE, data, _client));
}
}
var received = Thread.CurrentThread.IsBackground ||
(_exitReceiving != null && _exitReceiving.WaitOne (5 * 1000));
var released = closeResources ();
args.WasClean = sent && received && released;
_logger.Debug ("Was clean?: " + args.WasClean);
_readyState = WebSocketState.CLOSED;
OnClose.Emit (this, args);
_logger.Trace ("Exit close method.");
}
private void OnClose(object sender, WebSocketSharp.CloseEventArgs e)
{
stringArgs pack = new stringArgs(e.Code.ToString());
socket_state(pack);
}
private void OnClose(object sender, CloseEventArgs e)
{
EmitEvent("close");
}
private void close(object sender, WebSocketSharp.CloseEventArgs e)
{
Debug.Log("Closed");
_error = e.Reason;
_isConnected = false;
}
private void CloseHandle(object sender, WebSocketSharp.CloseEventArgs e)
{
Console.WriteLine("[SOCKET INFO closed]");
}
void socket_OnClose(object sender, WebSocketSharp.CloseEventArgs e)
{
this.ShowMsg(this.txtClient, "OnClose:" + e.Reason);
}
private void SocketConnectionClosed(object sender, WebSocketSharp.CloseEventArgs e)
{
//invoke when socket closed
Debug.Log("SocketConnectionClosed : " + e.Reason);
isConnected = false;
}
private void onClose(CloseEventArgs eventArgs)
{
if (!Thread.CurrentThread.IsBackground)
if (_exitReceiving != null)
_exitReceiving.WaitOne(5 * 1000);
if (!closeResources())
eventArgs.WasClean = false;
OnClose.Emit(this, eventArgs);
}
void stuffonclose(object sender, WebSocketSharp.CloseEventArgs e)
{
Debug.Log("code: " + e.Code.ToString());
Debug.Log("reason: " + e.Reason.ToString());
Debug.Log("clean?: " + e.WasClean.ToString());
}
// As server
internal void Close(CloseEventArgs args, byte [] frameAsBytes, int waitTimeOut)
{
lock (_forClose)
{
if (_readyState == WebSocketState.CLOSING || _readyState == WebSocketState.CLOSED)
return;
_readyState = WebSocketState.CLOSING;
}
args.WasClean = close (frameAsBytes, waitTimeOut, closeServerResources);
_readyState = WebSocketState.CLOSED;
OnClose.Emit (this, args);
}
private void close (CloseEventArgs e, bool send, bool wait)
{
lock (_forConn) {
if (_readyState == WebSocketState.Closing) {
_logger.Info ("The closing is already in progress.");
return;
}
if (_readyState == WebSocketState.Closed) {
_logger.Info ("The connection has been closed.");
return;
}
send = send && _readyState == WebSocketState.Open;
wait = wait && send;
_readyState = WebSocketState.Closing;
}
_logger.Trace ("Begin closing the connection.");
e.WasClean = closeHandshake (
send ? WebSocketFrame.CreateCloseFrame (e.PayloadData, _client).ToArray () : null,
wait ? _waitTime : TimeSpan.Zero,
_client ? (Action) releaseClientResources : releaseServerResources);
_logger.Trace ("End closing the connection.");
_readyState = WebSocketState.Closed;
try {
OnClose.Emit (this, e);
}
catch (Exception ex) {
_logger.Fatal (ex.ToString ());
error ("An exception has occurred during an OnClose event.", ex);
}
}
private void close(PayloadData payload, bool send, bool wait)
{
lock (_forConn) {
if (_readyState == WebSocketState.Closing || _readyState == WebSocketState.Closed) {
_logger.Info ("Closing the WebSocket connection has already been done.");
return;
}
_readyState = WebSocketState.Closing;
}
_logger.Trace ("Start closing handshake.");
var args = new CloseEventArgs (payload);
args.WasClean =
_client
? closeHandshake (
send ? WsFrame.CreateCloseFrame (Mask.Mask, payload).ToByteArray () : null,
wait ? 5000 : 0,
closeClientResources)
: closeHandshake (
send ? WsFrame.CreateCloseFrame (Mask.Unmask, payload).ToByteArray () : null,
wait ? 1000 : 0,
closeServerResources);
_logger.Trace ("End closing handshake.");
_readyState = WebSocketState.Closed;
try {
OnClose.Emit (this, args);
}
catch (Exception ex) {
_logger.Fatal (ex.ToString ());
error ("An exception has occurred while OnClose.");
}
}
protected override void OnClose(CloseEventArgs e)
{
Sessions.Broadcast (String.Format ("{0} got logged off...", _name));
}
private void onClose(object sender, WebSocketSharp.CloseEventArgs e)
{
this.CloseReason = e.Reason;
}
private void closeHandshake(PayloadData data)
{
var args = new CloseEventArgs(data);
var frame = createControlFrame(Opcode.CLOSE, data, _client);
if (send(frame))
args.WasClean = true;
onClose(args);
}
private static void Ws_OnClose(object sender, WebSocketSharp.CloseEventArgs e)
{
//Console.WriteLine("Reason: " + e.Reason);
Console.WriteLine("Closing Code: " + e.Code);
}
private void close (CloseEventArgs e, bool send, bool receive, bool received)
{
lock (_forConn) {
if (_readyState == WebSocketState.Closing) {
_logger.Info ("The closing is already in progress.");
return;
}
if (_readyState == WebSocketState.Closed) {
_logger.Info ("The connection has been closed.");
return;
}
send = send && _readyState == WebSocketState.Open;
receive = receive && send;
_readyState = WebSocketState.Closing;
}
_logger.Trace ("Begin closing the connection.");
var bytes = send ? WebSocketFrame.CreateCloseFrame (e.PayloadData, _client).ToArray () : null;
e.WasClean = closeHandshake (bytes, receive, received);
releaseResources ();
_logger.Trace ("End closing the connection.");
_readyState = WebSocketState.Closed;
try {
OnClose.Emit (this, e);
}
catch (Exception ex) {
_logger.Error (ex.ToString ());
error ("An exception has occurred during the OnClose event.", ex);
}
}
protected override void OnClose(CloseEventArgs e)
{
var msg = String.Format("{0} got logged off...", _name);
Broadcast(msg);
}
internal void WSonClose(JaPluReBehavior japlureBehavior, CloseEventArgs e)
{
if (ConnectedClients.Contains(japlureBehavior))
window.WFUIize(() => ConnectedClients.Remove(japlureBehavior));
}
protected override void OnClose(CloseEventArgs e) {
if(true) {
X13.Log.Info("{0} Disconnect: [{1}]{2}", this.ToString(), e.Code, e.Reason);
}
if(_owner!=null) {
_owner.Remove();
}
}
private void OnClose_1(object sender, WebSocketSharp.CloseEventArgs e)
{
OnClose();
}
private void Socket_OnClose(object sender, CloseEventArgs e)
{
LogHelper.Info("Koala连接关闭->" + e.Reason);
IsConnected = false;
reset.Set();
}
private void _OnClose(Object sender, WebSocketSharp.CloseEventArgs e)
{
Log.Info(String.Format("Connection with KB closed (code {0}: {1})", e.Code, e.Reason));
OnClose?.Invoke(this, EventArgs.Empty);
}
// As server
internal void Close(CloseEventArgs args, byte [] frame, int timeout)
{
lock (_forConn) {
if (_readyState == WebSocketState.Closing || _readyState == WebSocketState.Closed) {
_logger.Info ("Closing the WebSocket connection has already been done.");
return;
}
_readyState = WebSocketState.Closing;
}
args.WasClean = closeHandshake (frame, timeout, closeServerResources);
_readyState = WebSocketState.Closed;
try {
OnClose.Emit (this, args);
}
catch (Exception ex) {
_logger.Fatal (ex.ToString ());
}
}
protected override void OnClose(WebSocketSharp.CloseEventArgs e)
{
myWindowsService.SimpleServer.TheServer.OnSessionClose(this);
}
// As server
internal void Close (CloseEventArgs e, byte[] frameAsBytes, TimeSpan timeout)
{
lock (_forConn) {
if (_readyState == WebSocketState.Closing) {
_logger.Info ("The closing is already in progress.");
return;
}
if (_readyState == WebSocketState.Closed) {
_logger.Info ("The connection has been closed.");
return;
}
_readyState = WebSocketState.Closing;
}
e.WasClean = closeHandshake (frameAsBytes, timeout, releaseServerResources);
_readyState = WebSocketState.Closed;
try {
OnClose.Emit (this, e);
}
catch (Exception ex) {
_logger.Fatal (ex.ToString ());
}
}
/// <summary>
/// Closes the WebSocket connection asynchronously with the specified
/// <see cref="CloseStatusCode"/> and <see cref="string"/>, and releases
/// all associated resources.
/// </summary>
/// <remarks>
/// <para>
/// This method doesn't wait for the close to be complete.
/// </para>
/// <para>
/// This method emits a <see cref="OnError"/> event if the size of <paramref name="reason"/>
/// is greater than 123 bytes.
/// </para>
/// </remarks>
/// <param name="code">
/// One of the <see cref="CloseStatusCode"/> enum values, represents the status code
/// indicating the reason for the close.
/// </param>
/// <param name="reason">
/// A <see cref="string"/> that represents the reason for the close.
/// </param>
public void CloseAsync(CloseStatusCode code, string reason)
{
CloseEventArgs e = null;
var msg = _readyState.CheckIfClosable () ??
(e = new CloseEventArgs (code, reason)).RawData.CheckIfValidControlData ("reason");
if (msg != null) {
_logger.Error (msg);
error ("An error has occurred in closing the connection.", null);
return;
}
var send = _readyState == WebSocketState.Open && !code.IsReserved ();
closeAsync (e, send, send);
}
private void closeAsync (CloseEventArgs e, bool send, bool wait)
{
Action<CloseEventArgs, bool, bool> closer = close;
closer.BeginInvoke (e, send, wait, ar => closer.EndInvoke (ar), null);
}
private void _ws_OnClose(object sender, CloseEventArgs e) {
if(_verbose.value) {
if(e.Code==1000) {
Log.Info("WsSync/{0} - disconnected[{1}]", name, e.Code);
} else {
Log.Warning("WsSync/{0} - disconnected[{1}]", name, e.Code);
}
}
_present.value=false;
if(_st==State.Dispose) {
_reconn.Change(-1, -1);
_ws=null;
}
}
protected override void OnClose(CloseEventArgs e)
{
_onDisconnected();
}
void ws_OnClose(object sender, CloseEventArgs e)
{
Debug.Print("Closed For" + e.Reason);
listBox1.WFUIize(() => listBox1.Items.Add("Errored: " + e.Reason));
}
private void close(PayloadData payload, bool send, bool wait)
{
lock (_forClose)
{
if (_readyState == WebSocketState.CLOSING || _readyState == WebSocketState.CLOSED)
return;
_readyState = WebSocketState.CLOSING;
}
_logger.Trace ("Start closing handshake.");
var args = new CloseEventArgs (payload);
args.WasClean = _client
? close (
send ? WsFrame.CreateCloseFrame (Mask.MASK, payload).ToByteArray () : null,
wait ? 5000 : 0,
closeClientResources)
: close (
send ? WsFrame.CreateCloseFrame (Mask.UNMASK, payload).ToByteArray () : null,
wait ? 1000 : 0,
closeServerResources);
_readyState = WebSocketState.CLOSED;
OnClose.Emit (this, args);
_logger.Trace ("End closing handshake.");
}
protected void OnClose(WebSocketSharp.CloseEventArgs e, string id)
{
TriggerWaitHandle(id, null);
OnClose(new MessageEventArgs(null, false, id));
}
