Hi Roy,

I've recently done something similar. Umbraco has some very nice documentation on the RecurringTaskBase class that shows you how to run background tasks on a timer. This ofcourse is not what you ask, you are asking to trigger something on a signal from an api endpoint. Fortunately this is easily done if you look at the source code of the RecurringTaskBase class in github. You can inherit from the LatchedBackgroundTaskBase class and create your own background task that functions on a signal. Here's an example implementation that I created recently:

Component:

public class PageViewComponent : IComponent
{
    private readonly ICommandQueue _commandQueue;
    private readonly ILogger _logger;
    private readonly BackgroundTaskRunner<IBackgroundTask> _taskRunner;
    private PageViewBackgroundWorker _backgroundWorker;

    // Dependency injection resolves all your dependencies here
    public PageViewComponent(ICommandQueue commandQueue,
                             ILogger logger)
    {
        _commandQueue = commandQueue;
        _logger = logger;
        _taskRunner = new BackgroundTaskRunner<IBackgroundTask>("Page view background errands", _logger);
    }

    public void Initialize()
    {
        // pass any dependencies to your new background worker
        _backgroundWorker = new PageViewBackgroundWorker(_taskRunner, _commandQueue, _logger);
        _taskRunner.TryAdd(_backgroundWorker);
        PublishedRequest.Prepared += OnRequestPrepared;
    }

    public void Terminate()
    {
        PublishedRequest.Prepared -= OnRequestPrepared;
    }

    private void OnRequestPrepared(object sender, EventArgs e)
    {
        if (!(sender is PublishedRequest request))
        {
            _logger.Warn<PageViewComponent>("Sender is not of type {0}", typeof(PublishedRequest));
            return;
        }

        _commandQueue.Push(new SavePageViewCommand( /* any data that the handler needs to use */ ));
    }
}

Background worker:

public class PageViewBackgroundWorker : LatchedBackgroundTaskBase
{
    private readonly IBackgroundTaskRunner<LatchedBackgroundTaskBase> _runner;
    private readonly ICommandQueue _commandQueue;
    private readonly ILogger _logger;

    // Add the services that you need to the constructor here.
    public PageViewBackgroundWorker(IBackgroundTaskRunner<LatchedBackgroundTaskBase> runner,
                                    ICommandQueue commandQueue,
                                    ILogger logger)
    {
        _runner = runner;
        _commandQueue = commandQueue;
        _logger = logger;
        _commandQueue.OnCommandAdded += Dispatch;
    }

    public override async Task RunAsync(CancellationToken token)
    {
        try
        {
            while (_commandQueue.TryGet(out var command))
            {
                // configure await is false so we don't have to wait for the context to become available again.
                //   NOTE: be aware when creating commands that one command won't necessarily be executed on the same thread as the previous.
                // This is where you would perform your logic
                await command.ExecuteAsync().ConfigureAwait(false);
            }
        }
        catch (Exception e)
        {
            _logger.Error<PageViewBackgroundWorker>(e, "An exception occurred while executing a command on the queue.");
        }

        Repeat();
    }

    private void Repeat()
    {
        if (_runner.IsCompleted) return;

        Reset();

        if (!_runner.TryAdd(this))
        {
            Dispose();
        }
    }

    public void Dispatch(object sender, EventArgs e)
    {
        try
        {
            Release();
        }
        catch // it's alright if this fails, that means that this task is still running and the message will be consumed
        { }
    }

    public override bool IsAsync => true;

    protected override void DisposeResources()
    {
        base.DisposeResources();

        _commandQueue.OnCommandAdded -= Dispatch;
    }
}

In my case, the command queue object is where the signals are sent to. The command queue is a singleton object.

I left a few bits out here and there, but I hope you get the idea. Let me know if you need any additional guidance!