protected override void OnStart(string[] args)
{
logger.Debug("Starting up service.");
queueFactory = CreateMessageFactory(logger);
if (!queueFactory.IsActive)
{
logger.InfoFormat("RabbitMQ is not active. Messaging will not be available.");
}
queuePublisher = new MiramarPublisher(queueFactory);
var directory = AppDomain.CurrentDomain.BaseDirectory;
var path = Path.Combine(directory, "miramar.config");
var contextProvider = new MiramarContextProvider();
var taskProvider = MiramarConfigurationParser.ParseConfiguration(queuePublisher, path);
var scheduleProvider = MiramarSchedulingParser.ParseSchedule(queuePublisher, path);
serviceTask = new Task(() =>
{
logger.Info("Starting Miramar Controller.");
var controller = new MiramarController(queuePublisher, taskProvider, scheduleProvider, contextProvider);
controller.ThreadRun(serviceSource.Token);
});
serviceTask.ContinueWith(x => logger.Info("Controller is shutting down."));
messageTask = new Task(() =>
{
logger.Info("Starting Miramar Scheduler.");
var scheduler = new ScheduleService(queueFactory, taskProvider, scheduleProvider, contextProvider);
scheduler.ThreadRun(serviceSource.Token);
});
messageTask.ContinueWith(x => logger.Info("Scheduler is shutting down."));
AddMiramarAdapter(queueFactory);
serviceTask.Start();
messageTask.Start();
logger.Info("Miramar Controller is now running.");
}
public void ThreadRun(CancellationToken token)
{
if (taskProvider == null)
{
taskProvider = MiramarConfigurationParser.ParseConfiguration("miramar.config");
}
if (scheduleProvider == null)
{
scheduleProvider = MiramarSchedulingParser.ParseSchedule("miramar.config");
}
if (contextProvider == null)
{
contextProvider = new MiramarContextProvider();
}
taskProvider.PublishConfiguration();
scheduleProvider.PublishSchedules();
using (var manual = new ManualResetEventSlim())
{
while (true)
{
if (token.IsCancellationRequested)
{
break;
}
publisher.PublishHeartbeat(DateTime.Now);
var identifiers = scheduleProvider.IdentifyTasksToExecute(DateTime.Now);
logger.TraceFormat("Identified {0} tasks that should be ran.", identifiers.Length);
foreach (var identifier in identifiers)
{
logger.TraceFormat("Identified \"{0}\" should be ran.", identifier);
ActiveTaskContext context;
if (contextProvider.TryGetValue(identifier, out context) && context.IsRunning)
{
logger.WarnFormat("Task \"{0}\" has been scheduled to run but is currently active.",
identifier);
logger.InfoFormat("Task \"{0}\" has been active since {1:yyyy-MM-dd hh:mm:ss}.",
context.TaskName, context.StartDate);
continue;
}
ExecuteTask(identifier, token);
}
try
{
manual.Wait(TimeSpan.FromSeconds(15), token);
}
catch (OperationCanceledException)
{
break;
}
}
}
var runningTasks = contextProvider
.GetRunningContexts()
.Select(x => x.RunningTask)
.ToArray();
if (contextProvider.Any())
{
WaitOnTasks(runningTasks);
}
}
static void Main(string[] args)
{
ObjectFactory.Initialize(x =>
{
x.For <IScheduleMessageHandler>()
.AddInstances(i =>
{
i.Type <HandlerAddSchedule>();
i.Type <HandlerChangeLogging>();
i.Type <HandlerChangeSchedule>();
i.Type <HandlerPublishConfiguration>();
i.Type <HandlerPublishSchedule>();
i.Type <HandlerRemoveSchedule>();
i.Type <HandlerResumeSchedule>();
i.Type <HandlerStopTask>();
});
x.Scan(s =>
{
s.AssembliesFromApplicationBaseDirectory();
s.AddAllTypesOf <IMiramarTaskFactory>();
});
});
var logger = InfrastructureFactory.CreateLogger("Console");
logger.Debug("Starting up console application.");
if (args.Length != 0)
{
logger.Info("Waiting on debugger attach. Press any key to continue.");
Console.ReadKey();
}
var messageFactory = CreateMessageFactory(logger);
if (!messageFactory.IsActive)
{
logger.InfoFormat("RabbitMQ is not active. Messaging will not be available.");
}
var source = new CancellationTokenSource();
var publisher = new MiramarPublisher(messageFactory);
var contextProvider = new MiramarContextProvider();
var taskProvider = MiramarConfigurationParser.ParseConfiguration(publisher, "miramar.config");
var scheduleProvider = MiramarSchedulingParser.ParseSchedule(publisher, "miramar.config");
var controllerTask = new Task(() =>
{
logger.Info("Starting Miramar Controller.");
var controller = new MiramarController(publisher, taskProvider, scheduleProvider, contextProvider, true);
controller.ThreadRun(source.Token);
});
controllerTask.ContinueWith(x => logger.Info("Console application is shutting down."));
var schedulerTask = new Task(() =>
{
logger.Info("Starting Miramar Scheduler.");
var scheduler = new ScheduleService(messageFactory, taskProvider, scheduleProvider, contextProvider);
scheduler.ThreadRun(source.Token);
});
schedulerTask.ContinueWith(x => logger.Info("Scheduler application is shutting down."));
AddMiramarAdapter(messageFactory);
controllerTask.Start();
schedulerTask.Start();
logger.Info("Miramar Controller is now running.");
logger.Info("Miramar Scheduler is now running");
logger.Info("Press CTRL+C or 'Q' to stop.");
Console.CancelKeyPress += (s, e) =>
{
logger.Warn("CTRL+C detected. Attempting to quit.");
CancelAndWait(source, messageFactory,
controllerTask, schedulerTask);
};
while (true)
{
var key = Console.ReadKey();
if (key.Key != ConsoleKey.Q)
{
continue;
}
logger.Warn("'Q' detected. Attempting to stop.");
CancelAndWait(source, messageFactory,
controllerTask, schedulerTask);
break;
}
}
