Aethel.Services.Kairos 1.0.0

Kairos

Version inicial

Kairos es un sistema de encolamiento de comandos. Provee la funcionalidad para encolar comandos internos, procesarlos utilizando la instancia de mediatr registrada en el proyecto y expone las utilidades para habilitarlo utilizando una arquitectura limpia, cqrs y eventos de dominio. Kairos expone una interfaz de almacenamiento que usara para guardar los comandos en cola, recuperarlos para procesarlos y para marcarlos como procesados con errores o sin ellos.

Features

• Implementacion de cola de comandos con almacenamiento indeterminado. La interfaz ICommandQueuedStorage permite especificar al cliente en donde quiere almacenar los comandos
• Implementacion del procesador de mensajes encolados, recuperando y transformando los mensajes encolados en comandos que puedan ser distribuidos a traves de la instancia de MediatR registrada.
• Implementacion de los procesadores de mensajes encolados para registrar su exito o fallo utilizando el storage definido

Configuracion

Para integrar Kairos solo necesitamos realizar una configuracion cuando lo agregamos a la inyeccion de dependencias de NetCore.

var services = new ServiceCollection();
// some configurations
services.AddKairos(options =>
    {
        options.CommandQueueStorage = (sp) => FactoryStorage;
        options.CommandAssembly = CurrentAssembly;
    });

FactoryStorage debe de ser una definicion de fabrica para construir la implementacion personalizada del storage. CurrenAssembly es el ensamblado actual para buscar a todos aquellos commandos internos y mapearlos para evitar hacer la busqueda con refleccion cada que se necesite.

La ruta recomendada de uso es utilizar Kairos cuando se lance un evento de dominio. Registraremos un manejador de evento para el evento que queremmos usar, que se encargara de encolar los comandos originados a partir del evento, y que queremos que se procese de forma asincrona. Kairos busca siempre alentar la reactividad y la consistencia eventual.

internal class EnqueueInternalCommands : INotificationHandler<GarageRegistrationCreatedEvent>
    {
        private readonly IQueuedCommandScheduler _commandScheduler;
        public EnqueueInternalCommands(IQueuedCommandScheduler commandScheduler)
        {
            _commandScheduler = commandScheduler;
        }
        
        public async Task Handle(GarageRegistrationCreatedEvent notification, CancellationToken cancellationToken)
        {
            // Agregamos el comando interno para enviar correo al registrante
            await _commandScheduler.EnqueueAsync(
                new SendSuccessfulGarageRegistrationEmailCommand(Guid.NewGuid(), notification.GarageRegistrationId));
        }
    }

Despues de encolar los commandos, utilizaremos un job para que de forma recurrente se ejecute un comando en el cual inyectaremos el procesador de comandos en cola, quien se encargara de recuperar los comandos internos y de ejecutarlos en la instancia actual de MediatR.

internal class InternalProcessingHandler : ICommandHandler<InternalProcessingCommand, Unit>
    {
        private readonly IQueuedCommandProcessor _queuedCommandProcessor;

        public InternalProcessingHandler(IQueuedCommandProcessor queuedCommandProcessor)
        {
            _queuedCommandProcessor = queuedCommandProcessor;
        }

        public async Task<Unit> Handle(InternalProcessingCommand request, CancellationToken cancellationToken)
        {
            await _queuedCommandProcessor.Process();
            return new Unit();
        }

Al procesar los comandos internos, se ejecutaran como un comando normal, en el cual podemos utilizar de nuevo los pipelines y toda la arquietctura de comandos, sin necesidad de ningun cambio extra. Es importante que se marquen los commmandos commo procesados con una llamada al objeto de revision

// Marcammos el comando commmo realizado
await _commandReviewer.MarkAsDone(request);

Comunmente esto es en el pipeline de transaccionalidad para permitir guardar los cambios. Con estos pasos ahora estamos listos para lanzar eventos y reaccionar a ellos a traves de Kairos.

Versiones y fechas de lanzamiento

License

MIT

If it works, learn how it do