/// <summary>
/// Starup process, by default it scans assemblies, sorts modules, configures container, and runs startup for each module
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
public virtual IStartupContext ConfigureLocator(IStartupConfiguration config)
{
IStartupTask startupTaskWithStartModules = null;
var startupTaskContext = new StartupTaskContext(_enableImport, _locatorRegistryFactory, config, _locatorDefaultRegistrations, _finalizeRegistry);
foreach (var task in CreateStartupTasks())
{
task.Prepare(startupTaskContext);
if (task is IStartupTaskWithStartupModules withStartupModules && withStartupModules.ExecuteStartupModules)
{
startupTaskWithStartModules = withStartupModules;
continue;
}
task.Execute(config.TimedTaskManager);
}
if (startupTaskWithStartModules is null)
{
throw new Exception("No IStartupTaskWithStartupModules was used in startup tasks!");
}
// optionally allows delaying startup until later, must be implemented on IStartupConfiguration instances
_delayedStart = () => startupTaskWithStartModules.Execute(config.TimedTaskManager);
if (!_enableDelayedStartupModules)
{
TryExecuteStartupModules();
}
return(startupTaskContext.Get <IStartupContext>());
}
/// <summary>
/// Adds a startup task to be executed when the silo has started.
/// </summary>
/// <param name="builder">
/// The builder.
/// </param>
/// <param name="startupTask">
/// The startup task.
/// </param>
/// <param name="stage">
/// The stage to execute the startup task, see values in <see cref="ServiceLifecycleStage"/>.
/// </param>
/// <returns>
/// The provided <see cref="ISiloHostBuilder"/>.
/// </returns>
public static ISiloHostBuilder AddStartupTask(
this ISiloHostBuilder builder,
IStartupTask startupTask,
int stage = ServiceLifecycleStage.Active)
{
return(builder.AddStartupTask((sp, ct) => startupTask.Execute(ct), stage));
}
private int GetDelay(IStartupTask task)
{
return(GetFluentlyDeclaredDelay(task) ??
GetAttributeDelay(task) ??
GetRestDelay() ??
0);
}
private int GetGroup(IStartupTask task)
{
return(GetFluentlyDeclaredGroup(task) ??
GetAttributeGroup(task) ??
GetRestGroup() ??
0);
}
public static void TaskExecuted(this ILogger logger, IStartupTask task, TimeSpan elapsed)
{
_taskExecuted(
logger,
task.GetType().GetDisplayName(),
(long)elapsed.TotalMilliseconds);
}
/// <inheritdoc/>
public void Register(IStartupTask task)
{
lock (this._Lock)
{
this._PendingTasks.Add(new StartupTaskDescriptor(task));
}
}
private int GetSequencePosition(IStartupTask task, ICollection tasks)
{
return(GetFluentlyDeclaredPosition(task, tasks) ??
GetAttributePosition(task) ??
GetRestPosition(tasks) ??
DefaultPosition);
}
public static void TaskFailed(this ILogger logger, IStartupTask task, TimeSpan elapsed, Exception exception)
{
_taskFailed(
logger,
task.GetType().GetDisplayName(),
(long)elapsed.TotalMilliseconds,
exception: exception);
}
/// <inheritdoc/>
public void MarkAsCompleted(IStartupTask task)
{
lock (this._Lock)
{
IStartupTaskDescriptor descriptor = this.PendingTasks.FirstOrDefault(t => t.Task == task);
this._PendingTasks.Remove(descriptor);
this._CompletedTasks.Add(descriptor);
}
}
private int?GetFluentlyDeclaredGroup(IStartupTask task)
{
var group = Options.Groups.FirstOrDefault(g => g.Sequence.Any(t => t.TaskType == task.GetType()));
if (group == null)
{
return(null);
}
return(Options.Groups.IndexOf(group));
}
private Task RunTaskAsync(Context context, IStartupTask startupTask)
{
var watch = Stopwatch.StartNew();
context.WriteLog("Execute Startup Task; Type: '{0}'", startupTask);
return(startupTask.RunAsync(context.Data)
.ContinueWith(t =>
{
watch.Stop();
context.WriteLog("Complete Startup Task; Type: '{0}', Time: {1} ms", startupTask, watch.ElapsedMilliseconds);
}));
}
private static int?GetAttributePosition(IStartupTask task)
{
var attribute = task.GetType().GetCustomAttributes(false).FirstOrDefault(a => a is TaskAttribute) as TaskAttribute;
if (attribute == null)
{
return(null);
}
if (attribute.PositionInSequence == int.MaxValue)
{
return(null);
}
return(attribute.PositionInSequence);
}
private static int?GetAttributeGroup(IStartupTask task)
{
var attribute = task.GetType().GetCustomAttributes(false).FirstOrDefault(a => a is TaskAttribute) as TaskAttribute;
if (attribute == null)
{
return(null);
}
if (attribute.Group == 0)
{
return(null);
}
return(attribute.Group);
}
private static void ExecuteTaskRecursively(
IStartupTask task, ISet<Type> executedTasks, BootstrapSettings settings)
{
var dependencies =
from dependencyType in task.Dependencies
where !executedTasks.Contains(dependencyType)
select (IStartupTask) Activator.CreateInstance(dependencyType);
foreach (var dependencyTask in dependencies)
ExecuteTaskRecursively(dependencyTask, executedTasks, settings);
Log.InfoFormat("Executing {0} startup task", task.Name);
task.Invoke(settings);
Log.InfoFormat("{0} startup task have executed successfully", task.Name);
executedTasks.Add(task.GetType());
}
private int?GetFluentlyDeclaredDelay(IStartupTask task)
{
var group = Options.Groups.FirstOrDefault(g => g.Sequence.Any(t => t.TaskType == task.GetType()));
if (group == null)
{
return(null);
}
var match = group.Sequence.FirstOrDefault(t => t.TaskType == task.GetType());
if (match == null || match.Delay == 0)
{
return(null);
}
return(match.Delay);
}
private int?GetFluentlyDeclaredPosition(IStartupTask task, ICollection tasks)
{
var group = Options.Groups.FirstOrDefault(g => g.Sequence.Any(t => t.TaskType == task.GetType()));
if (group == null)
{
return(null);
}
var sequence = group.Sequence.Select(s => s.TaskType).ToList();
if (!sequence.Contains(typeof(IStartupTask)))
{
return(sequence.IndexOf(task.GetType()) + 1);
}
if (sequence.IndexOf(typeof(IStartupTask)) > sequence.IndexOf(task.GetType()))
{
return(sequence.IndexOf(task.GetType()) + 1);
}
return(tasks.Count + sequence.IndexOf(task.GetType()) - sequence.IndexOf(typeof(IStartupTask)));
}
protected virtual void RunStartupTasks()
{
ITypeFinder typeFinder = ContainerManager.Resolve <ITypeFinder>();
IEnumerable <Type> startUpTaskTypes = typeFinder.FindClassesOfType <IStartupTask>();
List <IStartupTask> startUpTasks = new List <IStartupTask>();
foreach (Type type in startUpTaskTypes)
{
IStartupTask item = (IStartupTask)Activator.CreateInstance(type);
if (item == null)
{
continue;
}
startUpTasks.Add(item);
}
startUpTasks = startUpTasks.AsQueryable().OrderBy(x => x.Order).ToList();
//startUpTasks.Sort(new StartupTaskComparer());
foreach (IStartupTask task in startUpTasks)
{
task.Execute();
}
}
public static void TaskExecuting(this ILogger logger, IStartupTask task)
{
_taskExecuting(
logger,
task.GetType().GetDisplayName());
}
/// <summary>
/// Initializes a new <see cref="StartupTaskDescriptor"/>
/// </summary>
/// <param name="task">The <see cref="IStartupTask"/> to describe</param>
public StartupTaskDescriptor(IStartupTask task)
{
this.Task = task;
this.Name = task.GetType().Name.Replace("StartupTask", "").Replace("Task", "");
this.StartedAt = DateTime.UtcNow;
}
/// <summary> /// Register a startup task that runs immediately after the container is built with full dependency injected services /// </summary> /// <param name="services"></param> public static void RegisterStartupTask(this IServiceCollection services, IStartupTask instance) => services.AddSingleton(instance);
public static void Run(IStartupTask task)
{
task.Execute();
}
public RepeatStartupTaskDecorator(IStartupTask innerStartupTask, Int32 count)
{
InnerStartupTask = innerStartupTask;
Count = count;
}
public EmptyStartupTaskDecorator2(IStartupTask innerStartupTask)
{
InnerStartupTask = innerStartupTask;
}
