private async Task Discord_SocketClose(SocketCloseEventArgs e)
{
try
{
await RPClass.LogChannel.SendMessageAsync("Restarting: Socket Close");
}
catch
{
}
RPClass.SaveData(-1);
var process = new Process()
{
StartInfo = new ProcessStartInfo
{
FileName = "/bin/bash",
Arguments = $"-c \"dotnet RPBot-Core.dll\"",
RedirectStandardOutput = true,
UseShellExecute = false,
CreateNoWindow = true,
}
};
process.Start();
Environment.Exit(-1);
await Task.Delay(0);
}
private async Task Discord_SocketClose(SocketCloseEventArgs e)
{
try
{
await(await e.Client.GetChannelAsync(392429153909080065)).SendMessageAsync("Not Restarting(test): Socket Close");
}
catch
{
}
RPClass.SaveData(-1);
/*
* var process = new Process()
* {
* StartInfo = new ProcessStartInfo
* {
* FileName = "/bin/bash",
* Arguments = $"-c \"dotnet RPBot-Core.dll\"",
* RedirectStandardOutput = true,
* UseShellExecute = false,
* CreateNoWindow = true,
* }
* };
* process.Start();
* Environment.Exit(-1);
* await Task.Delay(0);
*/
}
private async Task OnSocketClosed(SocketCloseEventArgs e)
{
if (SocketClosed != null)
{
await SocketClosed(e);
}
}
private async Task VoiceWS_SocketClosed(IWebSocketClient client, SocketCloseEventArgs e)
{
this.Discord.Logger.LogDebug(VoiceNextEvents.VoiceConnectionClose, "Voice WebSocket closed ({0}, '{1}')", e.CloseCode, e.CloseMessage);
// generally this should not be disposed on all disconnects, only on requested ones
// or something
// otherwise problems happen
//this.Dispose();
if (e.CloseCode == 4006 || e.CloseCode == 4009)
{
this.Resume = false;
}
if (!this.IsDisposed)
{
this.TokenSource.Cancel();
this.TokenSource = new CancellationTokenSource();
this.VoiceWs = this.Discord.Configuration.WebSocketClientFactory(this.Discord.Configuration.Proxy);
this.VoiceWs.Disconnected += this.VoiceWS_SocketClosed;
this.VoiceWs.MessageReceived += this.VoiceWS_SocketMessage;
this.VoiceWs.Connected += this.VoiceWS_SocketOpened;
if (this.Resume) // emzi you dipshit
{
await this.ConnectAsync().ConfigureAwait(false);
}
}
}
internal void SocketOnClose(object sender, SocketCloseEventArgs e)
{
//means error on socket. If e.Exception == null means correct socket closing at session end
if (e.Exception != null)
{
if (this.OnError != null)
{
OnError(this, new ProtocolErrorEventArgs(e.Exception));
}
if (this.OnClose != null)
{
this.OnClose(this, new CloseFrameEventArgs(new CloseFrameExt()
{
StatusCode = (int)StatusCode.InternalError
}));
}
this.handshakeFinishedEventRaised.Set();
}
else
{
if (this.OnClose != null)
{
this.OnClose(this, new CloseFrameEventArgs(new CloseFrameExt()
{
StatusCode = (int)StatusCode.Success
}));
}
}
}
private async Task WebSocket_OnDisconnect(SocketCloseEventArgs e)
{
if (this.IsConnected && e.CloseCode != 1001 && e.CloseCode != -1)
{
this.Discord.DebugLogger.LogMessage(LogLevel.Warning, "Lavalink", $"Connection broken ({e.CloseCode}, {e.CloseMessage}); re-establishing...", DateTime.Now);
this.WebSocket = this.Discord.Configuration.WebSocketClientFactory(this.Discord.Configuration.Proxy);
this.WebSocket.Connected += this.WebSocket_OnConnect;
this.WebSocket.Disconnected += this.WebSocket_OnDisconnect;
this.WebSocket.ExceptionThrown += this.WebSocket_OnException;
this.WebSocket.MessageReceived += this.WebSocket_OnMessage;
this.WebSocket.AddDefaultHeader("Authorization", this.Configuration.Password);
this.WebSocket.AddDefaultHeader("Num-Shards", this.Discord.ShardCount.ToString(CultureInfo.InvariantCulture));
this.WebSocket.AddDefaultHeader("User-Id", this.Discord.CurrentUser.Id.ToString(CultureInfo.InvariantCulture));
await this.WebSocket.ConnectAsync(new Uri($"ws://{this.Configuration.SocketEndpoint}/"));
}
else if (e.CloseCode != 1001 && e.CloseCode != -1)
{
this.Discord.DebugLogger.LogMessage(LogLevel.Info, "Lavalink", $"Connection closed ({e.CloseCode}, {e.CloseMessage}).", DateTime.Now);
this.NodeDisconnected?.Invoke(this);
await this._disconnected.InvokeAsync(new NodeDisconnectedEventArgs(this)).ConfigureAwait(false);
}
else
{
Volatile.Write(ref this._isDisposed, true);
this.Discord.DebugLogger.LogMessage(LogLevel.Warning, "Lavalink", "Lavalink died.", DateTime.Now);
foreach (var kvp in this.ConnectedGuilds)
{
await kvp.Value.SendVoiceUpdateAsync().ConfigureAwait(false);
}
this.NodeDisconnected?.Invoke(this);
await this._disconnected.InvokeAsync(new NodeDisconnectedEventArgs(this)).ConfigureAwait(false);
}
}
private async Task VoiceWS_SocketClosed(SocketCloseEventArgs e)
{
this.Discord.DebugLogger.LogMessage(LogLevel.Debug, "VoiceNext", $"Voice socket closed ({e.CloseCode.ToString(CultureInfo.InvariantCulture)}, '{e.CloseMessage}')", DateTime.Now);
// generally this should not be disposed on all disconnects, only on requested ones
// or something
// otherwise problems happen
//this.Dispose();
if (e.CloseCode == 4006 || e.CloseCode == 4009)
{
this.Resume = false;
}
if (!this.IsDisposed)
{
this.TokenSource.Cancel();
this.TokenSource = new CancellationTokenSource();
this.VoiceWs = this.Discord.Configuration.WebSocketClientFactory(this.Discord.Configuration.Proxy);
this.VoiceWs.Disconnected += this.VoiceWS_SocketClosed;
this.VoiceWs.MessageReceived += this.VoiceWS_SocketMessage;
this.VoiceWs.Connected += this.VoiceWS_SocketOpened;
await this.ConnectAsync().ConfigureAwait(false);
}
}
/// <summary>
/// Disconnects the WebSocket connection.
/// </summary>
/// <param name="e">Disconect event arguments.</param>
/// <returns></returns>
public override async Task DisconnectAsync(SocketCloseEventArgs e)
{
//if (this.Socket.State != WebSocketState.Open || this.Token.IsCancellationRequested)
if (close_requested)
{
return;
}
close_requested = true;
try
{
await Socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", Token).ConfigureAwait(false);
e = e ?? new SocketCloseEventArgs(null)
{
CloseCode = (int)WebSocketCloseStatus.NormalClosure, CloseMessage = ""
};
Socket.Abort();
Socket.Dispose();
}
catch (Exception)
{ }
finally
{
if (e == null)
{
var cc = Socket.CloseStatus != null ? (int)Socket.CloseStatus.Value : -1;
e = new SocketCloseEventArgs(null)
{
CloseCode = cc, CloseMessage = Socket.CloseStatusDescription ?? "Unknown reason"
};
}
await OnDisconnectedAsync(e).ConfigureAwait(false);
}
}
internal Task CallOnDisconnectedAsync(SocketCloseEventArgs e)
{
// Zis is to prevent deadlocks (I hope)
_ = this._on_disconnect.InvokeAsync(e).ConfigureAwait(false);
return(Task.Delay(0));
}
private async Task SocketClosed(SocketCloseEventArgs e)
{
Console.WriteLine("[Reconnect] Websocket Closed. Attempting to reconnect.");
await e.Client.DisconnectAsync();
await e.Client.ConnectAsync();
}
/// <summary>
/// Set the Action to call when the connection has been terminated.
/// </summary>
/// <returns></returns>
protected override Task OnDisconnectedAsync(SocketCloseEventArgs e)
{
this.Socket.Abort();
this.Socket.Dispose();
_ = this._disconnected.InvokeAsync(e).ConfigureAwait(false);
return(Task.Delay(0));
}
private Task Discord_SocketClosed(DiscordClient client, SocketCloseEventArgs e)
{
if (_tlm.MonitorRunning())
{
_tlm.StopMonitor();
}
return(Task.CompletedTask);
}
public override Task InternalDisconnectAsync(SocketCloseEventArgs e)
{
if (_socket.State != ws4net.WebSocketState.Closed)
{
_socket.Close();
}
return(Task.Delay(0));
}
/// <summary>
/// Disconnects the WebSocket connection.
/// </summary>
/// <param name="e">Disconect event arguments.</param>
/// <returns></returns>
public override Task DisconnectAsync(SocketCloseEventArgs e)
{
if (_socket.IsAlive)
{
_socket.Close();
}
return(Task.Delay(0));
}
private async Task DiscordSocketClosed(SocketCloseEventArgs e)
{
Log(this, new LogEventArgs {
Type = LogType.Error,
Message = $"SocketClosed triggered: {e.CloseCode} - {e.CloseMessage}"
});
await Task.Delay(0);
}
private Task SocketClosed(SocketCloseEventArgs e)
{
_logger.Warning("Shard #{Shard} disconnected ({CloseCode}: {CloseMessage})", e.Client.ShardId, e.CloseCode, e.CloseMessage);
var info = TryGetShard(e.Client);
info.DisconnectionCount++;
info.Connected = false;
ReportShardStatus();
return(Task.CompletedTask);
}
private async Task OnDiscordDisconnected(SocketCloseEventArgs e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
if (ApiInformation.IsTypePresent("Windows.UI.ViewManagement.StatusBar"))
{
var status = StatusBar.GetForCurrentView();
status.ProgressIndicator.ProgressValue = NetworkHelper.IsNetworkConnected ? null : (double?)0;
status.ProgressIndicator.Text = NetworkHelper.IsNetworkConnected ? "Reconnecting..." : "Offline";
await status.ProgressIndicator.ShowAsync();
}
});
}
private async Task VoiceWS_SocketClosed(SocketCloseEventArgs e)
{
this.Discord.DebugLogger.LogMessage(LogLevel.Debug, "VoiceNext", $"Voice socket closed ({e.CloseCode.ToString(CultureInfo.InvariantCulture)}, '{e.CloseMessage}')", DateTime.Now);
this.Dispose();
if (!this.IsDisposed)
{
this.VoiceWs = BaseWebSocketClient.Create();
this.VoiceWs.OnDisconnect += this.VoiceWS_SocketClosed;
this.VoiceWs.OnMessage += this.VoiceWS_SocketMessage;
this.VoiceWs.OnConnect += this.VoiceWS_SocketOpened;
await this.StartAsync();
}
}
private async Task WebSocket_OnDisconnect(SocketCloseEventArgs e)
{
if (this.IsConnected && e.CloseCode != 1001 && e.CloseCode != -1)
{
this.Discord.Logger.LogWarning(LavalinkEvents.LavalinkConnectionClosed, "Connection broken ({0}, '{1}'), reconnecting", e.CloseCode, e.CloseMessage);
this.WebSocket = this.Discord.Configuration.WebSocketClientFactory(this.Discord.Configuration.Proxy);
this.WebSocket.Connected += this.WebSocket_OnConnect;
this.WebSocket.Disconnected += this.WebSocket_OnDisconnect;
this.WebSocket.ExceptionThrown += this.WebSocket_OnException;
this.WebSocket.MessageReceived += this.WebSocket_OnMessage;
this.WebSocket.AddDefaultHeader("Authorization", this.Configuration.Password);
this.WebSocket.AddDefaultHeader("Num-Shards", this.Discord.ShardCount.ToString(CultureInfo.InvariantCulture));
this.WebSocket.AddDefaultHeader("User-Id", this.Discord.CurrentUser.Id.ToString(CultureInfo.InvariantCulture));
if (this.Configuration.ResumeKey != null)
{
this.WebSocket.AddDefaultHeader("Resume-Key", this.Configuration.ResumeKey);
}
await this.WebSocket.ConnectAsync(new Uri(this.Configuration.SocketEndpoint.ToWebSocketString()));
}
else if (e.CloseCode != 1001 && e.CloseCode != -1)
{
this.Discord.Logger.LogInformation(LavalinkEvents.LavalinkConnectionClosed, "Connection closed ({0}, '{1}')", e.CloseCode, e.CloseMessage);
this.NodeDisconnected?.Invoke(this);
await this._disconnected.InvokeAsync(new NodeDisconnectedEventArgs(this)).ConfigureAwait(false);
}
else
{
Volatile.Write(ref this._isDisposed, true);
this.Discord.Logger.LogWarning(LavalinkEvents.LavalinkConnectionClosed, "Lavalink died");
foreach (var kvp in this._connectedGuilds)
{
await kvp.Value.SendVoiceUpdateAsync().ConfigureAwait(false);
_ = this._connectedGuilds.TryRemove(kvp.Key, out _);
}
this.NodeDisconnected?.Invoke(this);
await this._disconnected.InvokeAsync(new NodeDisconnectedEventArgs(this)).ConfigureAwait(false);
}
}
private Task WebSocket_OnDisconnect(SocketCloseEventArgs e)
{
if (this.IsConnected && e.CloseCode != 1001 && e.CloseCode != -1)
{
this.Discord.DebugLogger.LogMessage(LogLevel.Warning, "Lavalink", "Connection broken; re-establishing...", DateTime.Now);
this.WebSocket = this.Discord.Configuration.WebSocketClientFactory(this.Discord.Configuration.Proxy);
this.WebSocket.OnConnect += this.WebSocket_OnConnect;
this.WebSocket.OnDisconnect += this.WebSocket_OnDisconnect;
this.WebSocket.OnError += this.WebSocket_OnError;
this.WebSocket.OnMessage += this.WebSocket_OnMessage;
return(this.WebSocket.ConnectAsync(new Uri($"ws://{this.Configuration.SocketEndpoint}/"), new Dictionary <string, string>()
{
["Authorization"] = this.Configuration.Password,
["Num-Shards"] = this.Discord.ShardCount.ToString(CultureInfo.InvariantCulture),
["User-Id"] = this.Discord.CurrentUser.Id.ToString(CultureInfo.InvariantCulture)
}));
}
else if (e.CloseCode != 1001 && e.CloseCode != -1)
{
this.Discord.DebugLogger.LogMessage(LogLevel.Info, "Lavalink", "Connection closed", DateTime.Now);
if (this.NodeDisconnected != null)
{
this.NodeDisconnected(this);
}
return(this._disconnected.InvokeAsync(new NodeDisconnectedEventArgs(this)));
}
else
{
this.Discord.DebugLogger.LogMessage(LogLevel.Warning, "Lavalink", "Lavalink died", DateTime.Now);
foreach (var kvp in this.ConnectedGuilds)
{
kvp.Value.SendVoiceUpdate();
}
if (this.NodeDisconnected != null)
{
this.NodeDisconnected(this);
}
return(this._disconnected.InvokeAsync(new NodeDisconnectedEventArgs(this)));
}
}
/// <summary>
/// Disconnects the WebSocket connection.
/// </summary>
/// <param name="e">Disconect event arguments.</param>
/// <returns></returns>
public override async Task DisconnectAsync(SocketCloseEventArgs e)
{
try
{
this.TokenSource.Cancel();
this.TokenSource.Dispose();
}
catch
{ }
if (this._closeRequested)
{
return;
}
this._closeRequested = true;
try
{
// Wait for all items to be processed post-cancellation
await this.SocketQueueManager.ConfigureAwait(false);
}
catch
{ } // if anything throws here we have a stuck close cycle without this
try
{
var code = e != null ? (WebSocketCloseStatus)e.CloseCode : WebSocketCloseStatus.NormalClosure;
var msg = e?.CloseMessage ?? "";
await this.Socket.CloseAsync(code, msg, CancellationToken.None).ConfigureAwait(false);
await this.WsListener.ConfigureAwait(false);
}
catch (Exception ex)
{
await this.OnDisconnectedAsync(new SocketCloseEventArgs(null) { CloseCode = -1, CloseMessage = $"{ex.GetType()}: {ex.Message}" }).ConfigureAwait(false);
}
}
private async Task WebSocket_OnDisconnect(IWebSocketClient client, SocketCloseEventArgs e)
{
if (this.IsConnected && e.CloseCode != 1001 && e.CloseCode != -1)
{
this.Discord.Logger.LogWarning(LavalinkEvents.LavalinkConnectionClosed, "Connection broken ({0}, '{1}'), reconnecting", e.CloseCode, e.CloseMessage);
await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, false)).ConfigureAwait(false);
if (this.Configuration.SocketAutoReconnect)
{
await this.StartAsync().ConfigureAwait(false);
}
}
else if (e.CloseCode != 1001 && e.CloseCode != -1)
{
this.Discord.Logger.LogInformation(LavalinkEvents.LavalinkConnectionClosed, "Connection closed ({0}, '{1}')", e.CloseCode, e.CloseMessage);
this.NodeDisconnected?.Invoke(this);
await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, true)).ConfigureAwait(false);
}
else
{
Volatile.Write(ref this._isDisposed, true);
this.Discord.Logger.LogWarning(LavalinkEvents.LavalinkConnectionClosed, "Lavalink died");
foreach (var kvp in this._connectedGuilds)
{
await kvp.Value.SendVoiceUpdateAsync().ConfigureAwait(false);
_ = this._connectedGuilds.TryRemove(kvp.Key, out _);
}
this.NodeDisconnected?.Invoke(this);
await this._disconnected.InvokeAsync(this, new NodeDisconnectedEventArgs(this, false)).ConfigureAwait(false);
if (this.Configuration.SocketAutoReconnect)
{
await this.StartAsync().ConfigureAwait(false);
}
}
}
private Task Client_SocketClosed(SocketCloseEventArgs e) => this._socketClosed.InvokeAsync(e);
public override Task <BaseWebSocketClient> OnDisconnectAsync(SocketCloseEventArgs e)
{
return(Task.FromResult <BaseWebSocketClient>(this));
}
private Task OnClientDisconnected(DiscordClient sender, SocketCloseEventArgs e)
{
_logger.LogInformation($"Bot disconected {e.CloseMessage}");
return(Task.CompletedTask);
}
private async Task HandleTCPClose_RT(SocketCloseEventArgs args)
{
await Task.FromResult(true);
}
internal async Task ListenAsync()
{
await Task.Yield();
var buff = new byte[BUFFER_SIZE];
var buffseg = new ArraySegment <byte>(buff);
byte[] resultbuff = null;
WebSocketReceiveResult result = null;
SocketCloseEventArgs close = null;
var token = Token;
try
{
while (!token.IsCancellationRequested && Socket.State == WebSocketState.Open)
{
using (var ms = new MemoryStream())
{
do
{
result = await Socket.ReceiveAsync(buffseg, token).ConfigureAwait(false);
if (result.MessageType == WebSocketMessageType.Close)
{
var cc = result.CloseStatus != null ? (int)result.CloseStatus.Value : -1;
close = new SocketCloseEventArgs(null)
{
CloseCode = cc, CloseMessage = result.CloseStatusDescription
};
}
else
{
ms.Write(buff, 0, result.Count);
}
}while (!result.EndOfMessage);
resultbuff = ms.ToArray();
}
if (close != null)
{
break;
}
var resultstr = "";
if (result.MessageType == WebSocketMessageType.Binary)
{
if (resultbuff[0] == 0x78)
{
await CompressedStream.WriteAsync(resultbuff, 2, resultbuff.Length - 2).ConfigureAwait(false);
}
else
{
await CompressedStream.WriteAsync(resultbuff, 0, resultbuff.Length).ConfigureAwait(false);
}
await CompressedStream.FlushAsync().ConfigureAwait(false);
CompressedStream.Position = 0;
// partial credit to FiniteReality
// overall idea is their
// I tuned the finer details
// -Emzi
var sfix = BitConverter.ToUInt16(resultbuff, resultbuff.Length - 2);
if (sfix != ZLIB_STREAM_SUFFIX)
{
using (var zlib = new DeflateStream(CompressedStream, CompressionMode.Decompress, true))
{
await zlib.CopyToAsync(DecompressedStream).ConfigureAwait(false);
}
}
else
{
await StreamDecompressor.CopyToAsync(DecompressedStream).ConfigureAwait(false);
}
resultbuff = DecompressedStream.ToArray();
DecompressedStream.Position = 0;
DecompressedStream.SetLength(0);
CompressedStream.Position = 0;
CompressedStream.SetLength(0);
}
resultstr = UTF8.GetString(resultbuff, 0, resultbuff.Length);
await CallOnMessageAsync(resultstr).ConfigureAwait(false);
}
}
catch (Exception e)
{
close = new SocketCloseEventArgs(null)
{
CloseCode = -1, CloseMessage = e.Message
};
}
await DisconnectAsync(close).ConfigureAwait(false);
}
/// <summary>
/// Set the Action to call when the connection has been terminated.
/// </summary>
/// <returns></returns>
protected override Task OnDisconnectedAsync(SocketCloseEventArgs e)
{
_ = _on_disconnect.InvokeAsync(e).ConfigureAwait(false);
return(Task.Delay(0));
}
internal void ConnectionCloseHandler(object sender, SocketCloseEventArgs args)
{
if (this.OnClose != null)
this.OnClose(this, args);
}
/// <summary>
/// Set the Action to call when the connection has been terminated.
/// </summary>
/// <returns></returns>
protected override Task OnDisconnectedAsync(SocketCloseEventArgs e)
{
throw new PlatformNotSupportedException("Microsoft WebSocket client is not supported on this platform. You need to target .NETFX, .NET Standard 1.3, or provide a WebSocket implementation for this platform.");
}
private Task OnSocketClosed(SocketCloseEventArgs e)
{
SocketState = WebSocketState.Closed;
return(Task.CompletedTask);
}
