public void BuilderRequiresProgressProviderFactory()
{
var quidjibo = new QuidjiboBuilder();
Action build = () => quidjibo.BuildServer();
build.Should().Throw <QuidjiboBuilderException>()
.WithMessage("Failed to validate. See list of errors for more detail.")
.And.Errors.Should().Contain("Requires Progress WorkProvider Factory");
}
public static IAppBuilder UseQuidjibo(this IAppBuilder appBuilder, QuidjiboBuilder quidjiboBuilder)
{
var props = new AppProperties(appBuilder.Properties);
var server = quidjiboBuilder.BuildServer();
quidjiboBuilder.BuildClient();
props.OnAppDisposing.Register(server.Dispose);
server.Start();
return(appBuilder);
}
public static IApplicationBuilder UseQuidjibo(this IApplicationBuilder app, QuidjiboBuilder builder)
{
var lifetime = app.ApplicationServices.GetRequiredService <IApplicationLifetime>();
var server = builder.BuildServer();
builder.BuildClient();
lifetime.ApplicationStarted.Register(server.Start);
lifetime.ApplicationStopping.Register(server.Stop);
lifetime.ApplicationStopped.Register(server.Dispose);
return(app);
}
static async Task Main(string[] args)
{
System.Console.WriteLine("Resgrid Worker Engine (Events)");
System.Console.WriteLine("-----------------------------------------");
LoadConfiguration(args);
Prime();
var aes = Aes.Create();
var key = string.Join(",", aes.Key);
var cts = new CancellationTokenSource();
var cancellationToken = cts.Token;
System.Console.CancelKeyPress += (s, e) => { cts.Cancel(); };
var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
var logger = loggerFactory.CreateLogger <Program>();
// Setup DI
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterModule(new QuidjiboModule(typeof(Program).Assembly));
containerBuilder.RegisterInstance <ILogger>(logger);
var container = containerBuilder.Build();
// Setup Quidjibo
var quidjiboBuilder = new QuidjiboBuilder()
.ConfigureLogging(loggerFactory)
.UseAutofac(container)
.UseAes(Encoding.ASCII.GetBytes(WorkerConfig.PayloadKey))
.UseSqlServer(WorkerConfig.WorkerDbConnectionString)
.ConfigurePipeline(pipeline => pipeline.UseDefault());
// Quidjibo Client
var client = quidjiboBuilder.BuildClient();
// Long Running Jobs
await client.PublishAsync(new SystemQueueProcessorCommand(50), cancellationToken);
await client.PublishAsync(new QueuesProcessorCommand(51), cancellationToken);
// Quidjibo Server
using (var workServer = quidjiboBuilder.BuildServer())
{
// Start Quidjibo
workServer.Start();
cancellationToken.WaitHandle.WaitOne();
}
System.Console.ReadLine();
}
private static async Task MainAsync(string[] args, CancellationToken cancellationToken)
{
var loggerFactory = new LoggerFactory().AddConsole(LogLevel.Debug);
var logger = loggerFactory.CreateLogger <Program>();
logger.LogDebug("Hello Quidjibo!");
// Setup DI
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterModule(new QuidjiboModule(typeof(Program).Assembly));
containerBuilder.RegisterType <SimpleService>().As <ISimpleService>();
var container = containerBuilder.Build();
// Setup Quidjibo
var quidjiboBuilder = new QuidjiboBuilder()
.ConfigureLogging(loggerFactory)
//.ConfigureAssemblies(typeof(Program).GetTypeInfo().Assembly)
.UseAutofac(container)
.UseAes(fakeAesKey)
.UseSqlServer("Server=localhost;Database=SampleDb;Trusted_Connection=True;")
.ConfigurePipeline(pipeline => pipeline.UseDefault());
// Quidjibo Client
var client = quidjiboBuilder.BuildClient();
var count = 10;
var list = new List <Task>(count);
var stopWatch = new Stopwatch();
stopWatch.Start();
for (var j = 0; j < count; j++)
{
list.Add(client.PublishAsync(new Job.Command(j), cancellationToken));
}
await Task.WhenAll(list);
list.Clear();
stopWatch.Stop();
Console.WriteLine("Published {0} items in {1}s", count, stopWatch.Elapsed.TotalSeconds);
// Quidjibo Server
using (var workServer = quidjiboBuilder.BuildServer())
{
// Start Quidjibo
workServer.Start();
cancellationToken.WaitHandle.WaitOne();
}
}
public void When_Builder_IsNotConfigured_ShouldUseDefaults()
{
var quidjibo = new QuidjiboBuilder()
.Configure(Substitute.For <IQuidjiboConfiguration>())
.ConfigureWorkProviderFactory(Substitute.For <IWorkProviderFactory>())
.ConfigureScheduleProviderFactory(Substitute.For <IScheduleProviderFactory>())
.ConfigureProgressProviderFactory(Substitute.For <IProgressProviderFactory>());
var server = quidjibo.BuildServer();
var client = quidjibo.BuildClient();
server.Should().NotBeNull();
client.Should().NotBeNull();
}
private static async Task MainAsync(string[] args, CancellationToken cancellationToken)
{
var loggerFactory = new LoggerFactory().AddConsole(LogLevel.Debug);
var logger = loggerFactory.CreateLogger <Program>();
// Setup DI
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterModule(new QuidjiboModule(typeof(Program).Assembly));
containerBuilder.RegisterInstance <ILogger>(logger);
var container = containerBuilder.Build();
// Setup Quidjibo
var quidjiboBuilder = new QuidjiboBuilder()
.ConfigureLogging(loggerFactory)
.UseAutofac(container)
.UseAes(Encoding.ASCII.GetBytes(WorkerConfig.PayloadKey))
.UseSqlServer(WorkerConfig.WorkerDbConnectionString)
.ConfigurePipeline(pipeline => pipeline.UseDefault());
// Quidjibo Client
var client = quidjiboBuilder.BuildClient();
// Long Running Jobs
await client.PublishAsync(new SystemQueueProcessorCommand(8), cancellationToken);
await client.PublishAsync(new QueuesProcessorCommand(4), cancellationToken);
// Scheduled Jobs
await client.ScheduleAsync("Calendar Notifications",
new CalendarNotificationCommand(1),
Cron.MinuteIntervals(20),
cancellationToken);
await client.ScheduleAsync("Call Email Import",
new CallEmailImportCommand(2),
Cron.MinuteIntervals(5),
cancellationToken);
await client.ScheduleAsync("Call Pruning",
new CallPruneCommand(3),
Cron.MinuteIntervals(60),
cancellationToken);
await client.ScheduleAsync("Report Delivery",
new ReportDeliveryTaskCommand(5),
Cron.MinuteIntervals(60),
cancellationToken);
await client.ScheduleAsync("Shift Notifier",
new ShiftNotiferCommand(6),
Cron.MinuteIntervals(60),
cancellationToken);
await client.ScheduleAsync("Staffing Schedule",
new Commands.StaffingScheduleCommand(7),
Cron.MinuteIntervals(15),
cancellationToken);
await client.ScheduleAsync("Training Notifier",
new TrainingNotiferCommand(9),
Cron.MinuteIntervals(60),
cancellationToken);
// Quidjibo Server
using (var workServer = quidjiboBuilder.BuildServer())
{
// Start Quidjibo
workServer.Start();
cancellationToken.WaitHandle.WaitOne();
}
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var aes = Aes.Create();
var key = string.Join(",", aes.Key);
//System.Console.CancelKeyPress += (s, e) => { cancellationToken..Cancel(); };
_logger.Log(LogLevel.Information, "Starting Scheduler");
var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
var logger = loggerFactory.CreateLogger <Program>();
// Setup DI
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterModule(new QuidjiboModule(typeof(Program).Assembly));
containerBuilder.RegisterInstance <ILogger>(logger);
var container = containerBuilder.Build();
// Setup Quidjibo
var quidjiboBuilder = new QuidjiboBuilder()
.ConfigureLogging(loggerFactory)
.UseAutofac(container)
.UseAes(Encoding.ASCII.GetBytes(WorkerConfig.PayloadKey))
.UseSqlServer(WorkerConfig.WorkerDbConnectionString)
.ConfigurePipeline(pipeline => pipeline.UseDefault());
// Quidjibo Client
var client = quidjiboBuilder.BuildClient();
_logger.Log(LogLevel.Information, "Scheduler Started");
//// Long Running Jobs
////await client.PublishAsync(new SystemQueueProcessorCommand(8), cancellationToken);
////await client.PublishAsync(new QueuesProcessorCommand(4), cancellationToken);
var isEventsOnly = Environment.GetEnvironmentVariable("RESGRID__EVENTSONLY");
if (String.IsNullOrWhiteSpace(isEventsOnly) || isEventsOnly.ToLower() == "false")
{
_logger.Log(LogLevel.Information, "Starting Scheduled Jobs");
// Scheduled Jobs
_logger.Log(LogLevel.Information, "Scheduling Calendar Notifications");
await client.ScheduleAsync("Calendar Notifications",
new CalendarNotificationCommand(1),
Cron.MinuteIntervals(20),
stoppingToken);
//System.Console.WriteLine("Scheduling Calendar Notifications");
//await client.ScheduleAsync("Call Email Import",
// new CallEmailImportCommand(2),
// Cron.MinuteIntervals(5),
// cancellationToken);
_logger.Log(LogLevel.Information, "Scheduling Call Pruning");
await client.ScheduleAsync("Call Pruning",
new CallPruneCommand(3),
Cron.MinuteIntervals(60),
stoppingToken);
_logger.Log(LogLevel.Information, "Scheduling Report Delivery");
await client.ScheduleAsync("Report Delivery",
new ReportDeliveryTaskCommand(5),
Cron.MinuteIntervals(14),
stoppingToken);
_logger.Log(LogLevel.Information, "Scheduling Shift Notifier");
await client.ScheduleAsync("Shift Notifier",
new ShiftNotiferCommand(6),
Cron.MinuteIntervals(720),
stoppingToken);
_logger.Log(LogLevel.Information, "Scheduling Staffing Schedule");
await client.ScheduleAsync("Staffing Schedule",
new Commands.StaffingScheduleCommand(7),
Cron.MinuteIntervals(5),
stoppingToken);
_logger.Log(LogLevel.Information, "Scheduling Training Notifier");
await client.ScheduleAsync("Training Notifier",
new TrainingNotiferCommand(9),
Cron.MinuteIntervals(30),
stoppingToken);
_logger.Log(LogLevel.Information, "Scheduling Status Schedule");
await client.ScheduleAsync("Status Schedule",
new Commands.StatusScheduleCommand(11),
Cron.MinuteIntervals(5),
stoppingToken);
}
else
{
_logger.Log(LogLevel.Information, "Starting in Events Only Mode!");
}
// Quidjibo Server
using (var workServer = quidjiboBuilder.BuildServer())
{
// Start Quidjibo
workServer.Start();
stoppingToken.WaitHandle.WaitOne();
}
//while (!cancellationToken.IsCancellationRequested)
//{
// await Task.Delay(TimeSpan.FromSeconds(1));
//}
}
