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