private async Task OnTrackExceptionAsync(TrackExceptionEventArgs args)
{
var builder = new EmbedBuilder()
.WithDescription($"\u26a0 {GuildUtils.Locate("PlayerError", args.Player.TextChannel)}:```{args.ErrorMessage}```")
.WithColor(FergunClient.Config.EmbedColor);
await args.Player.TextChannel.SendMessageAsync(embed : builder.Build());
// The current track is auto-skipped
}
/// <summary>
/// Handles an event payload asynchronously.
/// </summary>
/// <param name="payload">the payload</param>
/// <returns>a task that represents the asynchronous operation</returns>
protected virtual async Task OnEventReceived(EventPayload payload)
{
if (!Players.TryGetValue(payload.GuildId, out var player))
{
return;
}
// a track ended
if (payload is TrackEndEvent trackEndEvent)
{
var args = new TrackEndEventArgs(player,
trackEndEvent.TrackIdentifier,
trackEndEvent.Reason);
await Task.WhenAll(OnTrackEndAsync(args),
player.OnTrackEndAsync(args));
}
// an exception occurred while playing a track
if (payload is TrackExceptionEvent trackExceptionEvent)
{
var args = new TrackExceptionEventArgs(player,
trackExceptionEvent.TrackIdentifier,
trackExceptionEvent.Error);
await Task.WhenAll(OnTrackExceptionAsync(args),
player.OnTrackExceptionAsync(args));
}
// a track got stuck
if (payload is TrackStuckEvent trackStuckEvent)
{
var args = new TrackStuckEventArgs(player,
trackStuckEvent.TrackIdentifier,
trackStuckEvent.Threshold);
await Task.WhenAll(OnTrackStuckAsync(args),
player.OnTrackStuckAsync(args));
}
// the voice web socket was closed
if (payload is WebSocketClosedEvent webSocketClosedEvent)
{
await player.DisconnectAsync(PlayerDisconnectCause.WebSocketClosed);
Players.Remove(payload.GuildId);
player.Dispose();
Logger?.Log(this, string.Format("Voice WebSocket was closed for player: {0}" +
"\nClose Code: {1} ({2}, Reason: {3}, By Remote: {4}",
payload.GuildId, webSocketClosedEvent.CloseCode,
(int)webSocketClosedEvent.CloseCode, webSocketClosedEvent.Reason,
webSocketClosedEvent.ByRemote ? "Yes" : "No"),
webSocketClosedEvent.ByRemote ? LogLevel.Warning : LogLevel.Debug);
}
}
/// <summary>Method called when OnTrackException event is fired.
/// </summary>
private static async Task OnTrackException(TrackExceptionEventArgs arg)
{
var track = arg.Track;
//For some reason Lavalink returns error messages with \n, so we remove them
var errorMessage = arg.ErrorMessage.Replace("\\n", "");
await arg.Player.TextChannel.SendMessageAsync(
embed : CustomFormats.CreateErrorEmbed($"**An error occurred**\n Playback failed for {track.Title}\n{errorMessage}"));
}
private async Task LavalinkErrorHandler(LavalinkGuildConnection con, TrackExceptionEventArgs e)
{
if (e.Player?.Guild == null)
{
return;
}
if (!this.data.TryGetValue(e.Player.Guild.Id, out GuildMusicPlayer? gd))
{
return;
}
if (gd.CommandChannel is { })
private async Task OnTrackException(TrackExceptionEventArgs e)
{
await Logs.Write("Music", $"Could not play track {e.Track.Title}. Reason: {e.Message}");
await e.Player.TextChannel.SendMessageAsync(_localization.GetMessage("Music song exception", e.Track.Title));
await Prepare(e.Player.VoiceChannel.Guild);
var track = await _music.PlayNext();
if (track == null)
{
return;
}
await track.TextChannel.SendMessageAsync(_localization.GetMessage("Music now playing", track.Track.Title,
track.Requester.Nickname()));
}
public async Task PlayErr(TrackExceptionEventArgs ts)
{
Console.WriteLine("ErrorEvent");
var con = Bot.guit[0].LLinkCon;
var pos = Bot.guit.FindIndex(x => x.GID == ts.Player.Guild.Id);
if (pos == -1)
{
await Task.CompletedTask;
return;
}
if (Bot.guit[pos].playnow.LavaTrack.IsStream && !Bot.guit[pos].playnow.LavaTrack.IsStream)
{
var naet = await con.GetTracksAsync(new Uri(Bot.guit[pos].playnow.LavaTrack.Uri.OriginalString));
Bot.guit[pos].queue.Insert(0, new Gsets2
{
LavaTrack = Bot.guit[pos].playnow.LavaTrack,
requester = Bot.guit[pos].playnow.requester,
addtime = Bot.guit[pos].playnow.addtime
});
}
await Task.CompletedTask;
}
private async Task OnTrackException(TrackExceptionEventArgs e)
{
if (e.Player == null || e.Track == null)
{
return;
}
e.Player.Queue.Remove(e.Track);
var eb = this.GetSimpleMusicEmbed("Track threw and exception. Attempting to play next track");
string desc = $"**{e.Track.Title}**";
if (!string.IsNullOrWhiteSpace(e.ErrorMessage))
{
desc += $"\n{e.ErrorMessage}";
}
eb.WithDescription(desc);
await e.Player.TextChannel.SendMessageAsync(
embed : eb.Build());
}
internal Task InternalTrackExceptionAsync(TrackExceptionData e)
{
var ea = new TrackExceptionEventArgs(this, e.Error, LavalinkUtilities.DecodeTrack(e.Track));
return(this._trackException.InvokeAsync(ea));
}
private Task OnTrackException(TrackExceptionEventArgs arg)
{
_logger.ConsoleMusicLog($"Track exception received for {arg.Track.Title}.");
return(Task.CompletedTask);
}
private async Task Lavalink_TrackExceptionThrown(LavalinkGuildConnection con, TrackExceptionEventArgs e)
{
if (e.Player?.Guild == null)
{
return;
}
if (!this.MusicData.TryGetValue(e.Player.Guild.Id, out var gmd))
{
return;
}
await gmd.CommandChannel.SendMessageAsync($"{DiscordEmoji.FromName(this.Discord, ":msfrown:")} A problem occured while playing {Formatter.Bold(Formatter.Sanitize(e.Track.Title))} by {Formatter.Bold(Formatter.Sanitize(e.Track.Author))}:\n{e.Error}");
}
private async Task LavalinkNode_TrackException(LavalinkGuildConnection con, TrackExceptionEventArgs e)
{
await this._trackException.InvokeAsync(con, e);
}
private async Task OnTrackExceptionAsync(TrackExceptionEventArgs arg)
{
Console.WriteLine($"{arg.Track} causes exception: {arg.ErrorMessage}.");
}
private Task OnTrackException(TrackExceptionEventArgs arg)
{
Console.WriteLine($"Track exception received for {arg.Track.Title}.");
return(Task.CompletedTask);
}
/// <summary> /// Invokes the <see cref="TrackException"/> event asynchronously. (Can be override for /// event catching) /// </summary> /// <param name="eventArgs">the event arguments</param> /// <returns>a task that represents the asynchronous operation</returns> protected virtual Task OnTrackExceptionAsync(TrackExceptionEventArgs eventArgs) => TrackException.InvokeAsync(this, eventArgs);
internal Task OnTrackExceptionAsync(TrackExceptionEventArgs eventArgs) => TrackException.InvokeAsync(this, eventArgs);
private Task OnTrackException(TrackExceptionEventArgs arg)
=> this.LogAsync(new LogMessage(LogSeverity.Critical, "Victoria", $"Track exception received for {arg.Track.Title}.", null));
private async Task OnTrackException(TrackExceptionEventArgs arg)
{
_logger.LogError($"Track {arg.Track.Title} threw an exception. Check Lavalink logs.");
arg.Player.Queue.Enqueue(arg.Track);
await arg.Player.TextChannel?.SendMessageAsync($"The song {arg.Track.Title} was re-added to the queue after an error.");
}
/// <inheritdoc/> protected override Task OnTrackExceptionAsync(TrackExceptionEventArgs eventArgs) => Task.WhenAll(base.OnTrackExceptionAsync(eventArgs), Cluster.OnTrackExceptionAsync(eventArgs));
private Task OnTrackException(TrackExceptionEventArgs arg)
{
return(Task.CompletedTask);
}
private async Task OnTruckException(TrackExceptionEventArgs arg)
{
await arg.Player.TextChannel.SendMessageAsync($"{arg.ErrorMessage}");
await arg.Player.SkipAsync();
}
private Task OnTrackException(TrackExceptionEventArgs arg)
{
this._logger.LogCritical($"Track exception received for {arg.Track.Title}.", arg.ErrorMessage);
return(Task.CompletedTask);
}
/// <summary> /// Asynchronously triggered when an exception occurred while playing a track. /// </summary> /// <param name="eventArgs">the track event arguments</param> /// <returns>a task that represents the asynchronous operation</returns> public virtual Task OnTrackExceptionAsync(TrackExceptionEventArgs eventArgs) => Task.CompletedTask;
private async Task TrackExceptionAsync(TrackExceptionEventArgs arg) => await _logger.LogMessage(new LogMessage(LogSeverity.Critical,
"AudioManager",
$"Track exception received for \"{arg.Track.Title}\" in \"{arg.Player.VoiceChannel.Name}\" on {arg.Player.VoiceChannel.Guild.Name}\"."));
