Udostępnij za pośrednictwem

Orleans Przegląd cyklu życia silosu

Orleans Silosy używają widocznego cyklu życia do uporządkowanego uruchamiania i zamykania Orleans systemów i składników warstwy aplikacji. Aby uzyskać więcej informacji na temat szczegółów implementacji, zobacz Orleans cykl życia.

Etapach

Orleans Klienci silosu i klastra używają wspólnego zestawu etapów cyklu życia usługi:

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

Przemysł drzewny

Ze względu na inwersję kontroli, w której uczestnicy dołączają do cyklu życia zamiast cyklu życia posiadającego scentralizowany zestaw kroków inicjalizacji, nie zawsze jest jasne z kodu, jaka jest kolejność uruchamiania i zamykania. Aby rozwiązać ten problem, Orleans dodaje rejestrowanie przed uruchomieniem silosu w celu raportowania, które składniki uczestniczą na każdym etapie. Te dzienniki są rejestrowane na poziomie dziennika informacji w rejestratorze Orleans.Runtime.SiloLifecycleSubject . Przykład:

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"

Ponadto, Orleans podobnie rejestruje informacje dotyczące czasu i błędów dla każdego składnika według etapu. Przykład:

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."

Udział w cyklu życia silosu

Logika aplikacji może uczestniczyć w cyklu życia silosu, rejestrując uczestniczącą usługę w kontenerze usługi silosu. Zarejestruj usługę jako ILifecycleParticipant<TLifecycleObservable>, gdzie T to ISiloLifecycle.

public interface ISiloLifecycle : ILifecycleObservable
{
}

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

Po uruchomieniu silosu wszyscy uczestnicy (ILifecycleParticipant<ISiloLifecycle>) w kontenerze mogą uczestniczyć przez wywołanie ich ILifecycleParticipant<TLifecycleObservable>.Participate zachowania. Gdy wszyscy mieli okazję uczestniczyć, obserwowany cykl życia silosu rozpoczyna wszystkie etapy w kolejności.

Przykład

Wraz z wprowadzeniem cyklu życia silosu, dostawcy bootstrap, którzy wcześniej umożliwiali wprowadzenie logiki w fazie inicjacji dostawcy, nie są już potrzebni. Teraz możesz wdrożyć logikę aplikacji na dowolnym etapie uruchamiania silosu. Niemniej jednak dodaliśmy fasadę "zadania startowego", aby pomóc w przejściu dla deweloperów, którzy korzystali z dostawców bootstrap. Jako przykład sposobu tworzenia składników, które uczestniczą w cyklu życia silosa, przyjrzyjmy się interfejsowi zadania uruchamiania.

Zadanie uruchamiania musi dziedziczyć tylko z ILifecycleParticipant<ISiloLifecycle> i subskrybować logikę aplikacji do cyklu życia silosu na określonym etapie.

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

Z poprzedniej implementacji widać, że w wywołaniu Participate(...) subskrybuje cykl życia silosu na skonfigurowanym etapie, przekazując wywołanie zwrotne aplikacji zamiast jego logiki inicjalizacyjnej. Składniki wymagające inicjowania na danym etapie dostarczałyby swoje wywołanie zwrotne, ale wzorzec pozostaje taki sam. Teraz, gdy masz StartupTask, aby upewnić się, że hook aplikacji jest wywoływany na skonfigurowanym etapie, musisz upewnić się, że StartupTask uczestniczy w cyklu życia silosu.

W tym celu wystarczy zarejestrować go w kontenerze. Zrób to przy użyciu funkcji rozszerzenia w systemie 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;
}

Rejestrując StartupTask w kontenerze usługi silosu jako interfejs znacznika ILifecycleParticipant<ISiloLifecycle>, sygnalizujesz silosowi, że ten składnik musi uczestniczyć w cyklu życia silosu.