/// <summary> /// Stops receiving the WebSocket connection requests with the specified /// <see cref="CloseStatusCode"/> and <see cref="string"/>. /// </summary> /// <param name="code"> /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code /// indicating the reason for the stop. /// </param> /// <param name="reason"> /// A <see cref="string"/> that represents the reason for the stop. /// </param> public void Stop(CloseStatusCode code, string reason) { lock (_sync) { var msg = _state.CheckIfStart() ?? code.CheckIfValidCloseParameters(reason); if (msg != null) { _logger.Error(msg); return; } _state = ServerState.ShuttingDown; } stopReceiving(5000); if (code.IsNoStatusCode()) { _services.Stop(new CloseEventArgs(), true, true); } else { var send = !code.IsReserved(); _services.Stop(new CloseEventArgs(code, reason), send, send); } _state = ServerState.Stop; }
private async Task CloseAsync(CloseStatusCode code, string reason, bool wait) { await CloseAsync(new PayloadData( await((ushort)code).AppendAsync(reason).ConfigureAwait(false)), !code.IsReserved(), wait).ConfigureAwait(false); }
/// <summary> /// Stops receiving the HTTP requests with the specified <see cref="CloseStatusCode"/> and /// <see cref="string"/> used to stop the WebSocket services. /// </summary> /// <param name="code"> /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code indicating /// the reason for the stop. /// </param> /// <param name="reason"> /// A <see cref="string"/> that represents the reason for the stop. /// </param> public void Stop(CloseStatusCode code, string reason) { lock (_sync) { var msg = _state.CheckIfAvailable(false, true, false) ?? WebSocket.CheckCloseParameters(code, reason, false); if (msg != null) { _logger.Error(msg); return; } _state = ServerState.ShuttingDown; } if (code == CloseStatusCode.NoStatus) { _services.Stop(new CloseEventArgs(), true, true); } else { var send = !code.IsReserved(); _services.Stop(new CloseEventArgs(code, reason), send, send); } stopReceiving(5000); _state = ServerState.Stop; }
/// <summary> /// Stops receiving the WebSocket connection requests with the specified /// <see cref="CloseStatusCode"/> and <see cref="string"/>. /// </summary> /// <param name="code"> /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code /// indicating the reason for stop. /// </param> /// <param name="reason"> /// A <see cref="string"/> that represents the reason for stop. /// </param> public void Stop(CloseStatusCode code, string reason) { CloseEventArgs e = null; lock (_sync) { var msg = _state.CheckIfStart() ?? (e = new CloseEventArgs(code, reason)).RawData.CheckIfValidControlData("reason"); if (msg != null) { _logger.Error(msg); return; } _state = ServerState.ShuttingDown; } stopReceiving(5000); var send = !code.IsReserved(); _services.Stop(e, send, send); _state = ServerState.Stop; }
/// <summary> /// Closes the WebSocket connection with the specified <see cref="CloseStatusCode"/> /// and <see cref="string"/>, and releases all associated resources. /// </summary> /// <remarks> /// This method emits a <see cref="OnError"/> event if the size /// of <paramref name="reason"/> is greater than 123 bytes. /// </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 Close(CloseStatusCode code, string reason) { byte[] data = null; var msg = _readyState.CheckIfClosable() ?? (data = ((ushort)code).Append(reason)).CheckIfValidControlData("reason"); if (msg != null) { error(msg); return; } var send = _readyState == WebSocketState.Open && !code.IsReserved(); close(new PayloadData(data), send, send); }
/// <summary> /// Closes the WebSocket connection with the specified <see cref="CloseStatusCode"/> /// and <see cref="string"/>, and releases all associated resources. /// </summary> /// <remarks> /// This method emits a <see cref="OnError"/> event if the size /// of <paramref name="reason"/> is greater than 123 bytes. /// </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 async Task CloseAsync(CloseStatusCode code, string reason) { byte[] data = null; var msg = _readyState.CheckIfClosable() ?? (data = await((ushort)code).AppendAsync(reason).ConfigureAwait(false)).CheckIfValidControlData("reason"); if (msg != null) { error(msg); return; } var send = _readyState == WebSocketState.Open && !code.IsReserved(); await CloseAsync(new PayloadData(data), send, send).ConfigureAwait(false); }
public void Stop(CloseStatusCode code, string reason) { string str; if (!this.checkIfAvailable(false, true, false, false, out str)) { this._logger.Error(str); } else if (WebSocket.CheckParametersForClose(code, reason, false, out str)) { object obj = this._sync; Monitor.Enter(obj); try { if (this.checkIfAvailable(false, true, false, false, out str)) { this._state = ServerState.ShuttingDown; } else { this._logger.Error(str); return; } } finally { Monitor.Exit(obj); } if (code != CloseStatusCode.NoStatus) { bool flag = !code.IsReserved(); this._services.Stop(new CloseEventArgs(code, reason), flag, flag); } else { this._services.Stop(new CloseEventArgs(), true, true); } this.stopReceiving(5000); this._state = ServerState.Stop; } else { this._logger.Error(str); } }
/// <summary> /// Stops receiving the WebSocket connection requests with the specified /// <see cref="CloseStatusCode"/> and <see cref="string"/>. /// </summary> /// <param name="code"> /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code indicating /// the reason for stop. /// </param> /// <param name="reason"> /// A <see cref="string"/> that represents the reason for stop. /// </param> public void Stop(CloseStatusCode code, string reason) { byte [] data = null; lock (_sync) { var msg = _state.CheckIfStart() ?? (data = ((ushort)code).Append(reason)).CheckIfValidControlData("reason"); if (msg != null) { _logger.Error(String.Format("{0}\nstate: {1}\nreason: {2}", msg, _state, reason)); return; } _state = ServerState.ShuttingDown; } stopListener(5000); _services.Stop(data, !code.IsReserved()); _state = ServerState.Stop; }
/// <summary> /// Stops receiving the WebSocket connection requests with the specified /// <see cref="CloseStatusCode"/> and <see cref="string"/>. /// </summary> /// <param name="code"> /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code /// indicating the reason for stop. /// </param> /// <param name="reason"> /// A <see cref="string"/> that represents the reason for stop. /// </param> public async Task Stop(CloseStatusCode code, string reason) { CloseEventArgs e = null; var msg = _state.CheckIfStart() ?? (e = new CloseEventArgs(code, reason)).RawData.CheckIfValidControlData("reason"); if (msg != null) { return; } _state = ServerState.ShuttingDown; StopReceiving(); var send = !code.IsReserved(); await _services.Stop(e, send, send).ConfigureAwait(false); _state = ServerState.Stop; }
public void Stop(CloseStatusCode code, string reason) { byte[] data = null; object sync = this._sync; lock (sync) { string text; if ((text = this._state.CheckIfStart()) == null) { text = (data = ((ushort)code).Append(reason)).CheckIfValidControlData("reason"); } string text2 = text; if (text2 != null) { this._logger.Error(string.Format("{0}\nstate: {1}\nreason: {2}", text2, this._state, reason)); return; } this._state = ServerState.ShuttingDown; } this._services.Stop(data, !code.IsReserved()); this.stopListener(5000); this._state = ServerState.Stop; }
public void Stop(CloseStatusCode code, string reason) { lock (_sync) { string text = _state.CheckIfStart() ?? code.CheckIfValidCloseParameters(reason); if (text != null) { _logger.Error(text); return; } _state = ServerState.ShuttingDown; } if (code.IsNoStatusCode()) { _services.Stop(new CloseEventArgs(), send: true, wait: true); } else { bool flag = !code.IsReserved(); _services.Stop(new CloseEventArgs(code, reason), flag, flag); } stopReceiving(5000); _state = ServerState.Stop; }
/// <summary> /// Closes the WebSocket connection with the specified <see cref="CloseStatusCode"/> and /// <see cref="string"/>, and releases all associated resources. /// </summary> /// <remarks> /// This method emits a <see cref="OnError"/> event if the length of <paramref name="reason"/> /// is greater than 123 bytes. /// </remarks> /// <param name="code"> /// One of the <see cref="CloseStatusCode"/> values that indicate the status codes for closure. /// </param> /// <param name="reason"> /// A <see cref="string"/> that contains the reason for closure. /// </param> public void Close(CloseStatusCode code, string reason) { var data = ((ushort) code).Append (reason); var msg = data.CheckIfValidCloseData (); if (msg != null) { _logger.Error (String.Format ("{0}\nreason: {1}", msg, reason)); error (msg); return; } var send = _readyState == WebSocketState.OPEN && !code.IsReserved (); close (new PayloadData (data), send, true); }
/// <summary> /// Closes the WebSocket connection with the specified <see cref="CloseStatusCode"/>, /// and releases all associated resources. /// </summary> /// <param name="code"> /// One of the <see cref="CloseStatusCode"/> values that indicate the status codes for closure. /// </param> public void Close(CloseStatusCode code) { var send = _readyState == WebSocketState.OPEN && !code.IsReserved (); close (new PayloadData (((ushort) code).ToByteArrayInternally (ByteOrder.BIG)), send, true); }
private void close(CloseStatusCode code, string reason, bool wait) { close (new PayloadData (((ushort) code).Append (reason)), !code.IsReserved (), wait); }
/// <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) { var msg = _readyState.CheckIfAvailable (true, true, false, false) ?? CheckCloseParameters (code, reason, _client); if (msg != null) { _logger.Error (msg); error ("An error has occurred in closing the connection.", null); return; } if (code == CloseStatusCode.NoStatus) { closeAsync (new CloseEventArgs (), true, true); return; } var send = !code.IsReserved (); closeAsync (new CloseEventArgs (code, reason), send, send); }
/// <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 closure. /// </param> /// <param name="reason"> /// A <see cref="string"/> that represents the reason for closure. /// </param> public void CloseAsync(CloseStatusCode code, string reason) { byte [] data = null; var msg = _readyState.CheckIfClosable () ?? (data = ((ushort) code).Append (reason)).CheckIfValidControlData ("reason"); if (msg != null) { _logger.Error (String.Format ("{0}\ncode: {1} reason: {2}", msg, code, reason)); error (msg); return; } var send = _readyState == WebSocketState.Open && !code.IsReserved (); closeAsync (new PayloadData (data), send, send); }
private void fatal(string message, CloseStatusCode code) { var payload = new PayloadData ((ushort) code, message); close (payload, !code.IsReserved (), false, false); }
private void close(CloseStatusCode code, string reason, bool wait) { close(new PayloadData(((ushort)code).Append(reason)), !code.IsReserved(), wait); }
/// <summary> /// Closes the WebSocket connection asynchronously with the specified /// <see cref="CloseStatusCode"/>, and releases all associated resources. /// </summary> /// <remarks> /// This method doesn't wait for the close to be complete. /// </remarks> /// <param name="code"> /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code /// indicating the reason for the close. /// </param> public void CloseAsync (CloseStatusCode code) { var msg = _readyState.CheckIfClosable (); if (msg != null) { _logger.Error (msg); error ("An error has occurred in closing the connection.", null); return; } if (code.IsNoStatusCode ()) { closeAsync (new CloseEventArgs (), true, true); return; } var send = !code.IsReserved (); closeAsync (new CloseEventArgs (code), send, send); }
/// <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); }
/// <summary> /// Closes the WebSocket connection with the specified <see cref="CloseStatusCode"/>, /// and releases all associated resources. /// </summary> /// <param name="code"> /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code /// indicating the reason for the close. /// </param> public void Close(CloseStatusCode code) { var msg = _readyState.CheckIfClosable (); if (msg != null) { _logger.Error (msg); error ("An error has occurred in closing the connection.", null); return; } var send = _readyState == WebSocketState.Open && !code.IsReserved (); close (new CloseEventArgs (code), send, send); }
private void fatal (string message, CloseStatusCode code) { close (new CloseEventArgs (code, message), !code.IsReserved (), false, false); }
/// <summary> /// Closes the WebSocket connection asynchronously with the specified /// <paramref name="code"/> and <paramref name="reason"/>, and releases /// all associated resources. /// </summary> /// <remarks> /// This method does not wait for the close to be complete. /// </remarks> /// <param name="code"> /// One of the <see cref="CloseStatusCode"/> enum values that 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. /// The size must be 123 bytes or less. /// </param> public void CloseAsync(CloseStatusCode code, string reason) { string msg; if (!checkIfAvailable(true, true, false, false, out msg)) { #if COMPAT Log.Error(msg); #else msg.Error(); #endif Error("An error has occurred in closing the connection.", null); return; } if (!CheckParametersForClose(code, reason, _client, out msg)) { #if COMPAT Log.Error(msg); #else msg.Error(); #endif Error("An error has occurred in closing the connection.", null); return; } if (code == CloseStatusCode.NoStatus) { closeAsync(new CloseEventArgs(), true, true, false); return; } var send = !code.IsReserved(); closeAsync(new CloseEventArgs(code, reason), send, send, false); }