Partager via

Services de grain

Les services associés au grain sont accessibles à distance et partitionnés pour soutenir la fonctionnalité du grain. Chaque instance d’un service de grain est responsable d’un ensemble de grains. Ces grains peuvent obtenir une référence au service de grains qui est actuellement responsable de leur service à l’aide d’un GrainServiceClient.

Les services de grains existent pour prendre en charge les cas où la responsabilité de gestion des grains doit être distribuée dans le Orleans cluster. Par exemple, Orleans les rappels sont implémentés à l’aide de services de grain : chaque silo gère les opérations de rappel pour un sous-ensemble de grains et avertit ces grains lorsque leurs rappels sont activés.

Vous configurez les services de grain sur les silos. Les systèmes s'initialisent lorsque le silo démarre, avant que l'initialisation du silo ne s'achève. Ils ne sont pas collectés lorsqu’ils sont inactifs ; au lieu de cela, leurs durées de vie s’étendent pour la durée de vie du silo lui-même.

Créer un service de grain

Un GrainService est un grain spécial : il n’a pas d’identité stable et fonctionne dans chaque silo, du démarrage à l’arrêt. L’implémentation d’une IGrainService interface implique plusieurs étapes.

  1. Définissez l’interface de communication du service de grain. Générez l’interface d’un GrainService à l’aide des mêmes principes que ceux que vous utilisez pour créer une interface de grain.

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

  2. Créez le service de grain DataService. Il est utile de savoir que vous pouvez également injecter un IGrainFactory pour pouvoir effectuer des appels de grain à partir de votre 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. Créez une interface pour les GrainServiceClient<TGrainService>GrainServiceClient que d'autres grains utiliseront pour se connecter au GrainService.

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

  4. Créez le client de service de grain. Les clients agissent généralement en tant que mandataires pour les services de grain qu'ils ciblent. Vous ajoutez donc habituellement une méthode pour chaque méthode du service cible. Ces méthodes doivent obtenir une référence au service grain cible afin de pouvoir l’appeler. La GrainServiceClient<T> classe de base fournit plusieurs surcharges de la GetGrainService méthode qui peuvent retourner une référence de grain correspondant à un GrainId, un hachage numérique (uint) ou un SiloAddress. Les deux dernières surcharges sont destinées aux cas avancés où vous souhaitez utiliser un mécanisme différent pour attribuer la responsabilité aux hôtes ou adresser directement un hôte. Dans l’exemple de code ci-dessous, nous définissons une propriété, GrainService, qui retourne le IDataService pour le grain qui appelle le DataServiceClient. Pour ce faire, nous utilisons la surcharge GetGrainService(GrainId) conjointement avec la propriété CurrentGrainReference.

    public class DataServiceClient : GrainServiceClient<IDataService>, IDataServiceClient
{
    public DataServiceClient(IServiceProvider serviceProvider)
        : base(serviceProvider)
    {
    }

    // For convenience when implementing methods, you can define a property which gets the IDataService
    // corresponding to the grain which is calling the DataServiceClient.
    private IDataService GrainService => GetGrainService(CurrentGrainReference.GrainId);

    public Task MyMethod() => GrainService.MyMethod();
}

  5. Injectez le client de service de grain dans les autres grains qui en ont besoin. Il n’est pas garanti que le GrainServiceClient puisse accéder au GrainService sur le silo local. Il est possible que votre commande soit envoyée au GrainService dans n’importe quel silo du cluster.

    public class MyNormalGrain: Grain<NormalGrainState>, INormalGrain
{
    readonly IDataServiceClient _dataServiceClient;

    public MyNormalGrain(
        IGrainActivationContext grainActivationContext,
        IDataServiceClient dataServiceClient) =>
            _dataServiceClient = dataServiceClient;
}

  6. Configurez le service de grain et le client du service grain dans le silo. Vous devez le faire pour que le silo démarre le GrainService.

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

Remarques supplémentaires

Il existe une méthode d’extension, GrainServicesSiloBuilderExtensions.AddGrainServiceutilisée pour inscrire des services de grain.

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

Le silo extrait les IGrainService types du fournisseur de services au démarrage (voir orleans/src/Orleans.Runtime/Silo/Silo.cs) :

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

Le package NuGet Microsoft.Orleans.Runtime doit être référencé par le projet GrainService.

Le package NuGet Microsoft.Orleans.OrleansRuntime doit être référencé par le projet GrainService.

Pour que cela fonctionne, vous devez inscrire le service et son client. Le code se présente comme suit :

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