/// <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; }