Grain Services

A Grain Services távolról elérhető, particionált szolgáltatások a funkciók szemcséinek támogatásához. A gabonaszolgáltatás minden példánya felelős bizonyos gabonakészletekért, és ezek a szemek hivatkozhatnak arra a gabonaszolgáltatásra, amely jelenleg a karbantartásukért felelős egy GrainServiceClient.

A Grain Services olyan eseteket támogat, amelyekben a szemek szervizelésével kapcsolatos felelősséget el kell osztani a Orleans fürt köré. Az emlékeztetők például Orleans a gabonaszolgáltatásokkal vannak implementálva: minden siló felelős a szemcsék egy részhalmazának emlékeztető műveleteiért, és értesíti ezeket a szemeket, amikor az emlékeztetők aktiválódnak.

A Grain Services silókon van konfigurálva, és a siló indításakor inicializálódik, mielőtt a siló befejezi az inicializálást. A rendszer nem gyűjti őket tétlen állapotban, hanem olyan élettartamokkal rendelkezik, amelyek a siló élettartamára terjednek ki.

GrainService létrehozása

Az A GrainService egy speciális szemcse, amely nem rendelkezik stabil identitással, és az indítástól a leállításig minden silóban fut. Az interfészek implementálásakor IGrainService több lépés is van.

1. Adja meg a grain szolgáltatás kommunikációs felületét. A felület GrainService azokat az alapelveket használja, mint a szemcsék felületének létrehozásához.

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

2. Hozza létre a DataService gabonaszolgáltatást. Jó tudni, hogy ön is injektálhat egy IGrainFactory , így szemcsés hívásokat kezdeményezhet a 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. Hozzon létre egy felületet, GrainServiceClient<TGrainService>GrainServiceClient amellyel más szemcsék csatlakozhatnak a GrainService.

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

1. Hozza létre a gabonaszolgáltatás-ügyfelet. Az ügyfelek általában proxyként működnek az általuk megcélzott szemcsés szolgáltatásokhoz, ezért általában minden metódushoz hozzáad egy metódust a célszolgáltatáshoz. Ezeknek a módszereknek a megcélzott gabonaszolgáltatásra kell hivatkozniuk, hogy be tudjanak hívni. Az GrainServiceClient<T> alaposztály számos túlterhelést biztosít a GetGrainService metódusnak, amelyek visszaadhatnak egy, egy GrainIdnumerikus kivonatnak (uint) vagy egy SiloAddress. Az utóbbi két túlterhelés speciális esetekben fordul elő, amikor a fejlesztő egy másik mechanizmust szeretne használni a gazdagépek felelősségének leképezésére, vagy közvetlenül szeretne egy gazdagépet kezelni. Az alábbi mintakódban meghatározunk egy tulajdonságot, GrainServiceamely visszaadja a IDataService nevet hívó DataServiceClientszemcse értékét. Ehhez a túlterhelést a GetGrainService(GrainId) tulajdonsággal CurrentGrainReference együtt használjuk.

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

1. Hozza létre a tényleges gabonaszolgáltatás-ügyfelet. Ez nagyjából csak az adatszolgáltatás proxyjaként működik. Sajnos manuálisan kell beírnia az összes metódusleképezést, amelyek csak egyszerű egysorosak.

   public class DataServiceClient : GrainServiceClient<IDataService>, IDataServiceClient
   {
       public DataServiceClient(IServiceProvider serviceProvider)
           : base(serviceProvider)
       {
       }
   
       public Task MyMethod() => GrainService.MyMethod();
   }
   

1. Injektálja a gabonaszolgáltatás-ügyfelet a többi olyan szemcsébe, amelyeknek szüksége van rá. A GrainServiceClient helyi silóhoz való hozzáférés GrainService nem garantált. A parancsot a fürt bármely silójának elküldheti GrainService .

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

2. Konfigurálja a gabonaszolgáltatást és a gabonaszolgáltatás-ügyfelet a silóban. Ezt úgy kell megtennie, hogy a siló elindítsa a GrainService.

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

További megjegyzések

Van egy bővítménymetódus GrainServicesSiloBuilderExtensions.AddGrainService , amelyen a gabonaszolgáltatások regisztrálva vannak.

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

A siló az indításkor lekéri a típusokat IGrainService a szolgáltatótól: orleans/src/Orleans. Futtatókörnyezet/Siló/Silo.cs

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

A Microsoft.Orleans. A Runtime NuGet-csomagra a GrainService projektnek hivatkoznia kell.

A Microsoft.Orleans.OrleansA Runtime NuGet-csomagra a GrainService projektnek hivatkoznia kell.

Ahhoz, hogy ez működjön, regisztrálnia kell a szolgáltatást és az ügyfelet is. A kód a következőképpen néz ki:

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