private void RememberExecution([NotNull] FileSystemPath path, bool withProgress)
{
var definition = Lifetime.CreateNested();
if (withProgress)
{
var progress = new ProgressIndicator(definition.Lifetime);
IProgressIndicator iProgress = progress;
iProgress.Start(1);
progress.Advance();
var task = RiderBackgroundTaskBuilder
.FromProgressIndicator(progress)
.AsIndeterminate()
.WithHeader("Executing template")
.WithDescription($"{path.Name}")
.Build();
Solution.Locks.ExecuteOrQueueEx(
definition.Lifetime,
"T4 execution progress launching",
() => BackgroundTaskHost.AddNewTask(definition.Lifetime, task)
);
}
RunningFiles[path] = definition;
}
public BackgroundTaskController(IBackgroundTaskStore store, ITypeResolver typeResolver, BackgroundTaskHost host,
IOptionsMonitor <BackgroundTaskOptions> options)
{
_store = store;
_typeResolver = typeResolver;
_host = host;
_options = options;
}
private static BackgroundTaskHost CreateBackgroundTaskHost(Action <BackgroundTaskOptions> configureOptions)
{
var services = new ServiceCollection();
services.AddBackgroundTasks(configureOptions);
var serviceProvider = services.BuildServiceProvider();
var timestamps = new LocalServerTimestampService();
var scheduler = new BackgroundTaskHost(serviceProvider, timestamps,
new InMemoryBackgroundTaskStore(timestamps), new JsonBackgroundTaskSerializer(),
new ReflectionTypeResolver(),
serviceProvider.GetRequiredService <IOptionsMonitor <BackgroundTaskOptions> >(),
serviceProvider.GetService <ISafeLogger <BackgroundTaskHost> >());
return(scheduler);
}
private BackgroundTaskHost CreateBackgroundTaskHost(Action <BackgroundTaskOptions> configureOptions)
{
var services = new ServiceCollection();
services.AddBackgroundTasks(configureOptions);
var serviceProvider = services.BuildServiceProvider();
var serializer = new JsonBackgroundTaskSerializer();
var typeResolver = new ReflectionTypeResolver();
var options = serviceProvider.GetRequiredService <IOptionsMonitor <BackgroundTaskOptions> >();
var host = serviceProvider.GetService <ISafeLogger <BackgroundTaskHost> >();
var scheduler = new BackgroundTaskHost(serviceProvider, Store, serializer, typeResolver, options, host);
return(scheduler);
}
static void Main()
{
// --- Create performance counters if not installed yet
var counter = PmcManager.GetCounter<TasksProcessedPmc>("consumer");
if (!counter.HasInstance)
{
Console.WriteLine("Installing performance counters...");
var pmcData = new PmcCreationData();
pmcData.MergeCountersFromAssembly(typeof(TasksProcessedPmc).Assembly);
PmcManager.InstallPerformanceCounters(pmcData);
}
// --- Clean up the message queues
var requestQueue = ResourceConnectionFactory.CreateResourceConnection<INamedQueue>(REQUEST_QUEUE);
requestQueue.Clear();
var responseQueue = ResourceConnectionFactory.CreateResourceConnection<INamedQueue>(RESPONSE_QUEUE);
responseQueue.Clear();
// --- Set up the background host
var settings = AppConfigurationManager.GetSettings<BackgroundTaskHostSettings>(BACKGROUND_TASK_HOST_SECTION);
var host = new BackgroundTaskHost(settings);
// --- Do the work for 10 seconds
Console.WriteLine("Starting background task host.");
host.Start();
Thread.Sleep(5000);
var context = host.Configuration.DefaultContext;
var processors = host.Configuration.GetTaskProcessors();
foreach (var processor in processors.Where(processor => processor.Name == "Processor"))
{
processor.InstanceCount = 3;
break;
}
host.Reconfigure(new BackgroundTaskHostSettings(context, processors));
Thread.Sleep(5000);
Console.WriteLine("Stopping background task host.");
host.Stop();
}
public BackgroundTaskService(BackgroundTaskHost host) => _host = host;
