Partilhar via

Orleans Visão geral do ciclo de vida do silo

Orleans Os silos usam um ciclo de vida observável para a inicialização e o desligamento ordenados de sistemas e componentes da camada de aplicação Orleans. Para obter mais informações sobre os detalhes da implementação, consulte Orleans ciclo de vida.

Estágios

Orleans Os clientes de silo e cluster usam um conjunto comum de estágios do ciclo de vida do serviço:

public static class ServiceLifecycleStage
{
    public const int First = int.MinValue;
    public const int RuntimeInitialize = 2_000;
    public const int RuntimeServices = 4_000;
    public const int RuntimeStorageServices = 6_000;
    public const int RuntimeGrainServices = 8_000;
    public const int ApplicationServices = 10_000;
    public const int BecomeActive = Active - 1;
    public const int Active = 20_000;
    public const int Last = int.MaxValue;
}

Exploração Florestal

Devido à inversão do controle, em que os participantes ingressam no ciclo de vida em vez de o ciclo de vida ter um conjunto centralizado de etapas de inicialização, nem sempre fica claro no código qual é a ordem de inicialização/desligamento. Para ajudar a resolver isso, Orleans adiciona o registro em log antes da inicialização do silo para relatar quais componentes participam em cada estágio. Esses logs são registrados no nível de log de informações no Orleans.Runtime.SiloLifecycleSubject registrador. Por exemplo:

Information, Orleans.Runtime.SiloLifecycleSubject, "Stage 2000: Orleans.Statistics.PerfCounterEnvironmentStatistics, Orleans.Runtime.InsideRuntimeClient, Orleans.Runtime.Silo"

Information, Orleans.Runtime.SiloLifecycleSubject, "Stage 4000: Orleans.Runtime.Silo"

Information, Orleans.Runtime.SiloLifecycleSubject, "Stage 10000: Orleans.Runtime.Versions.GrainVersionStore, Orleans.Storage.AzureTableGrainStorage-Default, Orleans.Storage.AzureTableGrainStorage-PubSubStore"

Também, da mesma maneira, Orleans regista informações de tempo e erro para cada componente por etapa. Por exemplo:

Information, Orleans.Runtime.SiloLifecycleSubject, "Lifecycle observer Orleans.Runtime.InsideRuntimeClient started in stage 2000 which took 33 Milliseconds."

Information, Orleans.Runtime.SiloLifecycleSubject, "Lifecycle observer Orleans.Statistics.PerfCounterEnvironmentStatistics started in stage 2000 which took 17 Milliseconds."

Participação no ciclo de vida do silo

A lógica do aplicativo pode participar do ciclo de vida do silo registrando um serviço participante no contêiner de serviço do silo. Registre o serviço como um ILifecycleParticipant<TLifecycleObservable>, onde T está ISiloLifecycle.

public interface ISiloLifecycle : ILifecycleObservable
{
}

public interface ILifecycleParticipant<TLifecycleObservable>
    where TLifecycleObservable : ILifecycleObservable
{
    void Participate(TLifecycleObservable lifecycle);
}

Quando o silo começa, todos os participantes (ILifecycleParticipant<ISiloLifecycle>) no contêiner podem participar tendo seu ILifecycleParticipant<TLifecycleObservable>.Participate comportamento chamado. Uma vez que todos tenham tido a oportunidade de participar, o ciclo de vida observável do silo inicia todas as etapas em ordem.

Exemplo

Com a introdução do ciclo de vida do silo, os provedores de bootstrap, que anteriormente permitiam injetar lógica na fase de inicialização do provedor, não são mais necessários. Agora você pode injetar a lógica do aplicativo em qualquer estágio da inicialização do silo. No entanto, adicionamos uma fachada de "tarefa de inicialização" para ajudar na transição para desenvolvedores que usaram provedores de bootstrap. Como exemplo de como se pode desenvolver componentes que participam do ciclo de vida do silo, vamos analisar a fachada da tarefa de inicialização.

A tarefa de inicialização só precisa herdar de ILifecycleParticipant<ISiloLifecycle> e inscrever a lógica da aplicação no ciclo de vida do silo no estágio especificado.

class StartupTask : ILifecycleParticipant<ISiloLifecycle>
{
    private readonly IServiceProvider _serviceProvider;
    private readonly Func<IServiceProvider, CancellationToken, Task> _startupTask;
    private readonly int _stage;

    public StartupTask(
        IServiceProvider serviceProvider,
        Func<IServiceProvider, CancellationToken, Task> startupTask,
        int stage)
    {
        _serviceProvider = serviceProvider;
        _startupTask = startupTask;
        _stage = stage;
    }

    public void Participate(ISiloLifecycle lifecycle)
    {
        lifecycle.Subscribe<StartupTask>(
            _stage,
            cancellation => _startupTask(_serviceProvider, cancellation));
    }
}

A partir da implementação anterior, é possível observar que na chamada Participate(...) se subscreve no ciclo de vida do silo na fase configurada, passando o retorno de chamada da aplicação em vez da lógica de inicialização. Os componentes que precisam de inicialização em um determinado estágio forneceriam seu retorno de chamada, mas o padrão permanece o mesmo. Agora que tem uma garantia de StartupTask de que o gancho do aplicativo é chamado no estágio configurado, precisa garantir que o StartupTask participe no ciclo de vida do silo.

Para isso, basta registrá-lo no contêiner. Faça isso usando uma função de extensão em ISiloHostBuilder:

public static ISiloHostBuilder AddStartupTask(
    this ISiloHostBuilder builder,
    Func<IServiceProvider, CancellationToken, Task> startupTask,
    int stage = ServiceLifecycleStage.Active)
{
    builder.ConfigureServices(services =>
        services.AddTransient<ILifecycleParticipant<ISiloLifecycle>>(
            serviceProvider =>
                new StartupTask(
                    serviceProvider, startupTask, stage)));

    return builder;
}

Ao registar o StartupTask no contêiner de serviço do silo como a interface de marcador ILifecycleParticipant<ISiloLifecycle>, indica ao silo que este componente precisa participar do ciclo de vida do silo.

  • Last updated on