internal static void Configure(IServiceCollection services, IConfiguration configuration, ILoggerFactory loggerFactory)
{
//uncomment us to see scheduler in action
//services.AddSingleton<IScheduledTask, ScheduledTask1>();
//services.AddSingleton<IScheduledTask, ScheduledTask2>();
//services.AddHostedService<ScheduledJob1>();
//services.AddHostedService<ScheduledJob2>();
services.AddHostedService <RefreshTokenCleanupJob>();
services.AddHostedService <AccessTokenCleanupJob>();
var logger = loggerFactory.CreateLogger("ScheduledTasks");
services.AddTransient <IHostedService, SchedulerHostedService>(serviceProvider =>
{
var instance = new SchedulerHostedService(serviceProvider.GetServices <IScheduledTask>());
instance.UnobservedTaskException += (sender, args) =>
{
logger.LogError(args.Exception, args.Exception.Message);
args.SetObserved();
};
return(instance);
});
}
public static IServiceCollection AddScheduler(this IServiceCollection services, EventHandler <UnobservedTaskExceptionEventArgs> unobservedTaskExceptionHandler)
{
return(services.AddSingleton <IHostedService, SchedulerHostedService>(serviceProvider => {
var instance = new SchedulerHostedService(serviceProvider.GetServices <IScheduledTask>());
instance.UnobservedTaskException += unobservedTaskExceptionHandler;
return instance;
}));
}
public static IServiceCollection AddScheduler(this IServiceCollection services, EventHandler <UnobservedTaskExceptionEventArgs> unobservedTaskExceptionHandler)
{
return(services.AddSingleton <IHostedService, SchedulerHostedService>(serviceProvider =>
{
var serviceScopeFactory = serviceProvider.GetRequiredService <IServiceScopeFactory>();
var configuration = serviceProvider.GetRequiredService <IConfiguration>();
var logger = serviceProvider.GetRequiredService <ILogger <SchedulerHostedService> >();
var instance = new SchedulerHostedService(serviceScopeFactory, logger, configuration);
instance.UnobservedTaskException += unobservedTaskExceptionHandler;
return instance;
}));
}
public static IServiceCollection AddScheduler(this IServiceCollection services,
EventHandler <UnobservedTaskExceptionEventArgs> unobservedTaskExceptionHandler)
{
return(services.AddTransient <IHostedService, SchedulerHostedService>(serviceProvider =>
{
var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
var scheduledJobs = serviceProvider.GetServices <IScheduledJob>();
var instance = new SchedulerHostedService(scheduledJobs, loggerFactory);
instance.UnobservedTaskException += unobservedTaskExceptionHandler;
return instance;
}));
}
private static void CreateInstance(
IServiceCollection services,
EventHandler <UnobservedTaskExceptionEventArgs> unobservedTaskExceptionHandler = null)
{
services.AddTransient <IHostedService, SchedulerHostedService>(serviceProvider =>
{
var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
var scheduledJobs = serviceProvider.GetServices <IScheduledJob>();
var instance = new SchedulerHostedService(scheduledJobs, loggerFactory);
if (unobservedTaskExceptionHandler != null)
{
instance.UnobservedTaskException += unobservedTaskExceptionHandler;
}
return(instance);
});
}
private static void CreateInstance(
IServiceCollection services,
EventHandler <UnobservedTaskExceptionEventArgs> unobservedTaskExceptionHandler = null)
{
// should prevent from double registrations.
services.TryAddEnumerable(ServiceDescriptor.Singleton <IHostedService, SchedulerHostedService>(sp =>
{
var loggerFactory = sp.GetService <ILoggerFactory>();
var scheduledJobs = sp.GetServices <IScheduledJob>();
var instance = new SchedulerHostedService(scheduledJobs, loggerFactory);
if (unobservedTaskExceptionHandler != null)
{
instance.UnobservedTaskException += unobservedTaskExceptionHandler;
}
return(instance);
}));
}
private static void CreateInstance(
IServiceCollection services,
EventHandler <UnobservedTaskExceptionEventArgs>?unobservedTaskExceptionHandler = default)
{
// should prevent from double registrations.
services.TryAddEnumerable(ServiceDescriptor.Singleton <IHostedService, SchedulerHostedService>(sp =>
{
var registry = sp.GetRequiredService <ISchedulerRegistration>();
var instance = new SchedulerHostedService(registry);
if (unobservedTaskExceptionHandler != null)
{
instance.UnobservedTaskException += unobservedTaskExceptionHandler;
}
return(instance);
}));
}
public static IServiceCollection AddSchedulingServices(this IServiceCollection services)
{
services.AddSingleton <IScheduledTask, UpdateBagsCountByBagTypeStatisticsTask>();
services.AddSingleton <IScheduledTask, UpdateCountByBrandStatistcsTask>();
services.AddSingleton <IScheduledTask, UpdateBagsCountByInsertDateStatisticsTask>();
services.AddSingleton <IScheduledTask, UpdateTotalCountByInsertDateStatisticsTask>();
services.AddSingleton <IHostedService, SchedulerHostedService>(serviceProvider => {
var logger = serviceProvider.GetService <ILogger <SchedulerHostedService> >();
var clock = serviceProvider.GetService <IClock>();
var tasks = serviceProvider.GetServices <IScheduledTask>();
var instance = new SchedulerHostedService(tasks.Select(task => new Scheduler(task, clock)));
instance.UnobservedTaskException += (sender, args) => {
// log this
logger.LogErrorAsync($"{nameof(SchedulerHostedService.UnobservedTaskException)}: {args}").GetAwaiter().GetResult();
args.SetObserved();
};
return(instance);
});
return(services);
}
/// <summary>
/// Main async method for the bot.
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
public static async Task Main(string[] args)
{
// Make sure Log folder exists
Directory.CreateDirectory(Path.Combine(Globals.AppPath, "Logs"));
// Checks for existing latest log
if (File.Exists(Path.Combine(Globals.AppPath, "Logs", "latest.log")))
{
// This is no longer the latest log; move to backlogs
string oldLogFileName = File.ReadAllLines(Path.Combine(Globals.AppPath, "Logs", "latest.log"))[0];
File.Move(Path.Combine(Globals.AppPath, "Logs", "latest.log"), Path.Combine(Globals.AppPath, "Logs", oldLogFileName));
}
// Builds a file name to prepare for future backlogging
string logFileName = $"{DateTime.Now:dd-MM-yy}-1.log";
// Loops until the log file doesn't exist
int index = 2;
while (File.Exists(Path.Combine(Globals.AppPath, "Logs", logFileName)))
{
logFileName = $"{DateTime.Now:dd-MM-yy}-{index}.log";
index++;
}
// Logs the future backlog file name
File.WriteAllText(Path.Combine(Globals.AppPath, "Logs", "latest.log"), $"{logFileName}\n");
// Set up logging through NLog
LoggingConfiguration config = new LoggingConfiguration();
FileTarget logfile = new FileTarget("logfile")
{
FileName = Path.Combine(Globals.AppPath, "Logs", "latest.log"),
Layout = "[${time}] [${level:uppercase=true}] [${logger}] ${message}"
};
config.AddRule(LogLevel.Trace, LogLevel.Fatal, logfile);
ColoredConsoleTarget coloredConsoleTarget = new ColoredConsoleTarget
{
UseDefaultRowHighlightingRules = true
};
config.AddRule(LogLevel.Info, LogLevel.Fatal, coloredConsoleTarget);
LogManager.Configuration = config;
string settingsLocation = Path.Combine(Globals.AppPath, "Data", "settings.json");
string jsonFile = File.ReadAllText(settingsLocation);
// Load the settings from file, then store it in the globals
Globals.BotSettings = JsonConvert.DeserializeObject <Settings.Settings>(jsonFile);
Client = new DiscordClient(new DiscordConfiguration
{
Token = Globals.BotSettings.BotToken,
TokenType = TokenType.Bot,
UseInternalLogHandler = true,
LogLevel = DSharpPlus.LogLevel.Debug
});
commands = Client.UseCommandsNext(new CommandsNextConfiguration
{
#if DEBUG_PREFIX
StringPrefix = Globals.BotSettings.Prefix + Globals.BotSettings.Prefix,
#else
StringPrefix = Globals.BotSettings.Prefix,
#endif
CaseSensitive = false
});
commands.RegisterCommands(Assembly.GetExecutingAssembly());
interactivity = Client.UseInteractivity(new InteractivityConfiguration {
});
Client.MessageCreated += Client_MessageReceived;
Client.MessageReactionAdded += Client_ReactionAdded;
Client.GuildMemberRemoved += Client_UserLeft;
commands.CommandExecuted += Commands_CommandExecuted;
commands.CommandErrored += Commands_CommandErrored;
Client.Ready += Client_Ready;
// Client.Log += Client_Log;
await Client.ConnectAsync();
await UpdateStandingsAsync();
List <IScheduledTask> tasks = new List <IScheduledTask>
{
#if DEBUG_PREFIX
new TestTask()
#endif
};
CancellationToken token = new CancellationToken(false);
SchedulerHostedService scheduler = new SchedulerHostedService(tasks);
await scheduler.StartAsync(token);
await Task.Delay(-1, token);
}
