private Task Client_ClientError(ClientErrorEventArgs e)
{
// Log the details of the error that occurred in the client
e.Client.DebugLogger.LogMessage(LogLevel.Error, "Slorp", $"Exception occured: {e.Exception.GetType()}: {e.Exception.Message}", DateTime.Now);
return(Task.CompletedTask);
}
private async Task Discord_ClientErrored(ClientErrorEventArgs e)
{
try
{
await RPClass.LogChannel.SendMessageAsync("Restarting: Client Error");
}
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 Task Client_ClientErrored(ClientErrorEventArgs e)
{
Console.WriteLine("Client Error occured:");
Console.WriteLine("Event: " + e.EventName);
Console.WriteLine("Message: " + e.Exception.Message);
return(Task.CompletedTask);
}
//Error Task
private Task Client_ClientError(ClientErrorEventArgs e)
{
//log the details of the error
e.Client.DebugLogger.LogMessage(LogLevel.Error, "DiscordBot", $"Exception occured: {e.Exception.GetType()}: {e.Exception.Message}", DateTime.Now);
return(Task.CompletedTask);
}
/// <summary>
/// Log the errors from the bot.
/// </summary>
/// <param name="e">Discord event information.</param>
private Task Client_ClientErrored(DiscordClient sender, ClientErrorEventArgs e)
{
// Log the exception
LogMessage($"Exception occurred: {e.Exception.ToString()}", level: "error");
return(Task.CompletedTask);
}
private Task Client_ClientError(DiscordClient sender, ClientErrorEventArgs e)
{
sender.Logger.LogError($"Exception occured: {e.Exception.GetType()}: {e.Exception.Message}");
lastException = e.Exception;
lastExceptionDatetime = DateTime.Now;
return(Task.CompletedTask);
}
public static Task Bot_ClientErrored(DiscordClient sender, ClientErrorEventArgs e)
{
sender.Logger.LogError($"Woops: {e.Exception.GetType()}: {e.Exception.Message}");
sender.Logger.LogError($"ExceptionMessage: {e.Exception.Message}");
return(Task.CompletedTask);
}
void OnConnectionErrorOccurred(object sender, ClientErrorEventArgs args)
{
Log.Error(args.Exception,
"EventStore connection with id = {ConnectionId} error occured",
args.Connection.ConnectionName);
_onError?.Invoke(args.Exception);
var exception = (args.Exception as AggregateException)?.GetBaseException() ?? args.Exception;
switch (exception)
{
case RetriesLimitReachedException retriesLimitReached:
Log.Fatal(
"EventStore connection's limit of reconnection or operation retries reached. " +
"Stopping service...",
retriesLimitReached);
_onFatalFailure();
break;
case ClusterException clusterException:
Log.Fatal(
"EventStore connection could not establish link with EventStore cluster. " +
"Maximum number of cluster connection attempts reached. " +
"Stopping service...",
clusterException);
_onFatalFailure();
break;
default:
Log.Warning(exception, "");
break;
}
}
private Task Client_ClientError(DiscordClient sender, ClientErrorEventArgs e)
{
sender.Logger.Log(LogLevel.Error, $"Exception occured: {e.Exception.GetType()}: {e.Exception.Message}", DateTime.Now);
prog.RunBotAsync().GetAwaiter().GetResult();
return(Task.CompletedTask);
}
private Task Client_ClientErrored(ClientErrorEventArgs e)
{
// Log the exception and its message
e.Client.DebugLogger.LogMessage(LogLevel.Error, "DiscordWikiBot", $"Exception occured: {e.Exception.GetType()}: {e.Exception.Message}", DateTime.Now);
return(Task.FromResult(0));
}
public static Task Event(DiscordClient client, ClientErrorEventArgs e)
{
string erro = $"{e.Exception.GetType()}: {e.Exception.Message}";
client.Logger.LogError(new EventId(602, "Client Error"), erro, DateTime.Now);
return(Task.CompletedTask);
}
public static Task ClientErrorEventHandlerAsync(TheGodfatherShard shard, ClientErrorEventArgs e)
{
Exception ex = e.Exception;
while (ex is AggregateException)
{
ex = ex.InnerException;
}
if (ex.InnerException is null)
{
shard.LogMany(LogLevel.Critical, $"Client errored with exception: {ex.GetType()}", $"Message: {ex.Message}");
}
else
{
shard.LogMany(LogLevel.Critical,
$"Client errored with exception: {ex.GetType()}",
$"Message: {ex.Message}",
$"Inner exception: {ex.InnerException.GetType()}",
$"Inner exception message: {ex.InnerException.Message}"
);
}
return(Task.CompletedTask);
}
private async Task OnClientErrored(ClientErrorEventArgs e)
{
if (ClientErrored != null)
{
await ClientErrored(e);
}
}
public static Task Client_Error(ClientErrorEventArgs e)
{
e.Client.DebugLogger.LogMessage(LogLevel.Error, "PotatoBot", $"Exception occured: {e.Exception.GetType()}: {e.Exception.Message}", DateTime.Now);
Stats.ClientErrors++;
return(Task.CompletedTask);
}
private async Task Discord_ClientErrored(ClientErrorEventArgs e)
{
try
{
await(await e.Client.GetChannelAsync(392429153909080065)).SendMessageAsync("Not Restarting (test): Client Error");
}
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);
*/
}
/// <summary>
/// Returns an error message when the Client errors out for whatever reason
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
private Task Client_ClientError(ClientErrorEventArgs e)
{
// log the details of the error that just occured in our client
e.Client.DebugLogger.LogMessage(LogLevel.Error, "Redditizer", $"Exception occured: {e.Exception.GetType()}: {e.Exception.Message}", DateTime.Now);
// since this method is not async, return a completed task
return(Task.CompletedTask);
}
private Task Client_ClientError(ClientErrorEventArgs e)
{
// let's log the details of the error that just occured in our client
e.Client.DebugLogger.LogMessage(LogLevel.Error, "SWGOHBot", $"Exception occured: {e.Exception.GetType()}: {e.Exception.Message}", DateTime.Now);
// since this method is not async, let's return a completed task, so that no additional work is done
return(Task.CompletedTask);
}
private Task botErrorHandler(ClientErrorEventArgs e)
{
//log error that occured
e.Client.DebugLogger.LogMessage(LogLevel.Error, "Zero Two Bot", $"Exception occured: {e.Exception.GetType()}: {e.Exception.Message}", DateTime.Now);
//not async, return not await
return(Task.CompletedTask);
}
private async Task Cliente_ClientErrored(DiscordClient client, ClientErrorEventArgs e)
{
var atividade = new DiscordActivity("Vish Pifei", ActivityType.Streaming)
{
StreamUrl = "https://www.twitch.tv/avj255"
};
await Cliente.UpdateStatusAsync(activity : atividade, userStatus : UserStatus.Idle);
}
/// <summary>Some shit broke.</summary>
private Task BotClient_ClientErrored(ClientErrorEventArgs e)
{
Console.WriteLine(e.EventName);
Console.WriteLine(e.Exception);
Console.WriteLine(e.Exception.InnerException);
return(Task.CompletedTask);
}
private Task Client_ClientError(ClientErrorEventArgs e)
{
e.Client.DebugLogger.LogMessage(LogLevel.Error, "Converter Bot",
$"Exception occured: {e.Exception.GetType()}: {e.Exception.Message}",
DateTime.Now);
return(Task.CompletedTask);
}
private Task ClientError(ClientErrorEventArgs e)
{
Console.WriteLine("Client Error!");
Console.WriteLine(e.ToString());
Close();
OnClosed?.Invoke();
return(Task.CompletedTask);
}
/// <inheritdoc/>
public Task Bot_ClientErrored(DiscordClient sender, ClientErrorEventArgs e)
{
// TODO: show a message box by dispatching it to the Web UI
BotSettings.BotLogErrorList.Add(new BotLogError(e.Exception));
BotSettings.BotLogList.Add(new BotLog(Tag, $"Bot Failure."));
CleanUp();
return(Task.CompletedTask);
}
private static Task onERR(ClientErrorEventArgs e)
{
Console.WriteLine("!-------------------------------!");
Console.WriteLine(" Exception: ClientError" /*+ e.Exception*/);
Console.WriteLine("Name: " + e.EventName);
Console.WriteLine("!-------------------------------!");
return(Task.CompletedTask);
}
private Task Client_ClientError(DiscordClient client, ClientErrorEventArgs e)
{
//if (e.Exception.InnerException?.Message.Contains("The given key") == false)
{
_logger.Error(e.Exception, $"Event Name: {e.EventName}");
}
return(Task.CompletedTask);
}
static Task HandleSocketError(DiscordClient client, ClientErrorEventArgs e)
{
if (e.EventName == "HearbeatFailure")
{
Process.Start($@"{Environment.CurrentDirectory}/CarrotBot");
Environment.Exit(0);
}
return(Task.CompletedTask);
}
private async Task DiscordClientErrored(ClientErrorEventArgs e)
{
Log(this, new LogEventArgs {
Type = LogType.Error,
Message = $"ClientErrored triggered: {e.Exception}"
});
await Task.Delay(0);
}
public virtual void OnClientError(ClientErrorEventArgs eventArgs)
{
var eventToRaise = ClientError;
if (eventToRaise != null)
{
eventToRaise(this, eventArgs);
}
}
protected virtual void OnErrorOccurred(ClientErrorEventArgs e)
{
var handler = ErrorOccurred;
if (handler != null)
{
handler(this, e);
}
}
void Client_ConnectionFailed(object sender, ClientErrorEventArgs e)
{
Client cli = (Client)sender;
AppendToHistory("CONNECTION FAILED TO {0}:{1}: {2}", cli.RemoteIP, cli.RemotePort, e.Reason);
btnConnect.Enabled = true;
btnConnect.Text = "connect";
}
