Granularità dei servizi

I servizi granulari sono accessibili in remoto, servizi partizionati per supportare i grani di funzionalità. Ogni istanza di un servizio di granularità è responsabile di alcuni grani e questi grani possono ottenere un riferimento al servizio di granularità che è attualmente responsabile della manutenzione tramite un GrainServiceClient.

Esistono dei servizi granulari per supportare i casi in cui la responsabilità per la manutenzione dei grani deve essere distribuita intorno al cluster Orleans. Ad esempio, i Promemoria Orleans vengono implementati tramite servizi granulari: ogni silo è responsabile della gestione delle operazioni di promemoria per un subset di granularità e notifica tali granularità quando vengono generati i loro promemoria.

I servizi granulari vengono configurati in silo e vengono inizializzati all'avvio del silo, prima che il silo completi l'inizializzazione. Non vengono raccolti quando sono inattivi e hanno invece delle durate che si estendono per la durata del silo stesso.

Creare un GrainService

Un GrainService è una granularità speciale, una che non ha un'identità stabile e viene eseguita in ogni silo dall'avvio all'arresto. Durante l'implementazione di un'interfaccia IGrainService sono necessari diversi passaggi.

1. Definire l'interfaccia di comunicazione del servizio granulare. L'interfaccia di un oggetto GrainService viene compilata usando gli stessi principi che si userebbero per la compilazione dell'interfaccia di una granularità.

   public interface IDataService : IGrainService
   {
       Task MyMethod();
   }
   

2. Creare il servizio granulare DataService. È bene sapere che è anche possibile inserire un oggetto IGrainFactory in modo da poter effettuare chiamate granulari da GrainService.

   [Reentrant]
   public class DataService : GrainService, IDataService
   {
       readonly IGrainFactory _grainFactory;
   
       public DataService(
           IServiceProvider services,
           GrainId id,
           Silo silo,
           ILoggerFactory loggerFactory,
           IGrainFactory grainFactory)
           : base(id, silo, loggerFactory)
       {
           _grainFactory = grainFactory;
       }
   
       public override Task Init(IServiceProvider serviceProvider) =>
           base.Init(serviceProvider);
   
       public override Task Start() => base.Start();
   
       public override Task Stop() => base.Stop();
   
       public Task MyMethod()
       {
           // TODO: custom logic here.
           return Task.CompletedTask;
       }
   }
   

   [Reentrant]
   public class DataService : GrainService, IDataService
   {
       readonly IGrainFactory _grainFactory;
   
       public DataService(
           IServiceProvider services,
           IGrainIdentity id,
           Silo silo,
           ILoggerFactory loggerFactory,
           IGrainFactory grainFactory)
           : base(id, silo, loggerFactory)
       {
           _grainFactory = grainFactory;
       }
   
       public override Task Init(IServiceProvider serviceProvider) =>
           base.Init(serviceProvider);
   
       public override Task Start() => base.Start();
   
       public override Task Stop() => base.Stop();
   
       public Task MyMethod()
       {
           // TODO: custom logic here.
           return Task.CompletedTask;
       }
   }
   

3. Creare un'interfaccia per l'oggetto GrainServiceClient<TGrainService>GrainServiceClient da utilizzare da altre granularità per connettersi all'oggetto GrainService.

   public interface IDataServiceClient : IGrainServiceClient<IDataService>, IDataService
   {
   }
   

1. Inserire il client del servizio granulare nelle altre granularità che ne hanno bisogno. GrainServiceClient non garantisce l'accesso a GrainService nel silo locale. Il comando potrebbe essere potenzialmente inviato a GrainService in qualsiasi silo nel cluster.

   public class MyNormalGrain: Grain<NormalGrainState>, INormalGrain
   {
       readonly IDataServiceClient _dataServiceClient;
   
       public MyNormalGrain(
           IGrainActivationContext grainActivationContext,
           IDataServiceClient dataServiceClient) =>
               _dataServiceClient = dataServiceClient;
   }
   

2. Configurare il servizio granulare e il client del servizio granulare nel silo. È necessario eseguire questa operazione in modo che il silo avvii GrainService.

   (ISiloHostBuilder builder) =>
       builder.ConfigureServices(
           services => services.AddGrainService<DataService>()
                               .AddSingleton<IDataServiceClient, DataServiceClient>());
   

Note aggiuntive

Esiste un metodo di estensione in GrainServicesSiloBuilderExtensions.AddGrainService che viene usato per registrare i servizi granulari.

services.AddSingleton<IGrainService>(
    serviceProvider => GrainServiceFactory(grainServiceType, serviceProvider));

Il silo recupera i tipi IGrainService dal provider di servizi all'avvio: orleans/src/Orleans.Runtime/Silo/Silo.cs

var grainServices = this.Services.GetServices<IGrainService>();

Per consentire il funzionamento, è necessario registrare sia il servizio che il client. Il codice è simile al seguente:

var builder = new HostBuilder()
    .UseOrleans(c =>
    {
        c.AddGrainService<DataService>()  // Register GrainService
        .ConfigureServices(services =>
        {
            // Register Client of GrainService
            services.AddSingleton<IDataServiceClient, DataServiceClient>();
        });
    })