Implementare le funzionalità a livello di servizio nel servizio Actor

Articolo
08/25/2024

Come descritto in Livelli del servizio, il servizio Actor stesso è un servizio affidabile. È possibile scrivere il proprio servizio che deriva da ActorService. È anche possibile implementare le funzionalità a livello di servizio nello stesso modo usato per ereditare un servizio con stato, ad esempio:

Backup e ripristino del servizio.
Funzionalità condivisa per tutti gli attori, ad esempio un interruttore.
Chiamate di routine remote sul servizio attore stesso e su ogni singolo attore.

Uso del servizio Actor

Le istanze degli attori hanno accesso al servizio attore in cui sono in esecuzione. Tramite il servizio attore, le istanze degli attori possono ottenere il contesto del servizio a livello di codice. Il contesto del servizio include l'ID partizione, il nome del servizio, il nome dell'applicazione e altre informazioni specifiche sulla piattaforma Service Fabric.

Task MyActorMethod()
{
    Guid partitionId = this.ActorService.Context.PartitionId;
    string serviceTypeName = this.ActorService.Context.ServiceTypeName;
    Uri serviceInstanceName = this.ActorService.Context.ServiceName;
    string applicationInstanceName = this.ActorService.Context.CodePackageActivationContext.ApplicationName;
}

CompletableFuture<?> MyActorMethod()
{
    UUID partitionId = this.getActorService().getServiceContext().getPartitionId();
    String serviceTypeName = this.getActorService().getServiceContext().getServiceTypeName();
    URI serviceInstanceName = this.getActorService().getServiceContext().getServiceName();
    String applicationInstanceName = this.getActorService().getServiceContext().getCodePackageActivationContext().getApplicationName();
}

Come tutti i servizi Reliable Services, il servizio attore deve essere registrato con un tipo di servizio nel runtime di Service Fabric. Perché il servizio Actor possa eseguire le istanze degli attori, è necessario che anche il proprio tipo di attore sia registrato con il servizio Actor. Il metodo di registrazione ActorRuntime esegue questa attività per gli attori. Nel caso più semplice, è sufficiente registrare il tipo di attore e il servizio Actor userà le impostazioni predefinite.

static class Program
{
    private static void Main()
    {
        ActorRuntime.RegisterActorAsync<MyActor>().GetAwaiter().GetResult();

        Thread.Sleep(Timeout.Infinite);
    }
}

In alternativa, è possibile usare un'espressione lambda fornita dal metodo di registrazione per creare manualmente il servizio attore. È quindi possibile configurare il servizio Actor e costruire esplicitamente le istanze degli attori. È possibile inserire le dipendenze per l'attore mediante il relativo costruttore.

static class Program
{
    private static void Main()
    {
        ActorRuntime.RegisterActorAsync<MyActor>(
            (context, actorType) => new ActorService(context, actorType, () => new MyActor()))
            .GetAwaiter().GetResult();

        Thread.Sleep(Timeout.Infinite);
    }
}

static class Program
{
    private static void Main()
    {
      ActorRuntime.registerActorAsync(
              MyActor.class,
              (context, actorTypeInfo) -> new FabricActorService(context, actorTypeInfo),
              timeout);

        Thread.sleep(Long.MAX_VALUE);
    }
}

Metodi del servizio attore

Il servizio Actor implementa IActorService (C#) o ActorService (Java), che a sua volta implementa IService (C#) o Service (Java). Questa è l'interfaccia usata dalla comunicazione remota di Reliable Services, che consente di effettuare RPC (Remote Procedure Call) sui metodi di servizio. Contiene i metodi a livello di servizio che possono essere chiamati in remoto mediante la comunicazione remota del servizio. È possibile usarlo per enumerare ed eliminare gli attori.

Servizio attore personalizzato

Usando l'espressione lambda di registrazione dell'attore è possibile registrare il proprio servizio attore personalizzato che deriva da ActorService (C#) e FabricActorService (Java). È quindi possibile implementare le proprie funzionalità a livello di servizio scrivendo una classe di servizio che erediti ActorService (C#) o FabricActorService (Java). Un servizio Actor personalizzato eredita tutte le funzionalità di runtime dell'attore da ActorService (C#) o FabricActorService (Java). Può essere usato per implementare i propri metodi di servizio.

class MyActorService : ActorService
{
    public MyActorService(StatefulServiceContext context, ActorTypeInformation typeInfo, Func<ActorBase> newActor)
        : base(context, typeInfo, newActor)
    { }
}

class MyActorService extends FabricActorService
{
    public MyActorService(StatefulServiceContext context, ActorTypeInformation typeInfo, BiFunction<FabricActorService, ActorId, ActorBase> newActor)
    {
         super(context, typeInfo, newActor);
    }
}

static class Program
{
    private static void Main()
    {
        ActorRuntime.RegisterActorAsync<MyActor>(
            (context, actorType) => new MyActorService(context, actorType, () => new MyActor()))
            .GetAwaiter().GetResult();

        Thread.Sleep(Timeout.Infinite);
    }
}

public class Program
{
    public static void main(String[] args)
    {
        ActorRuntime.registerActorAsync(
                MyActor.class,
                (context, actorTypeInfo) -> new FabricActorService(context, actorTypeInfo),
                timeout);
        Thread.sleep(Long.MAX_VALUE);
    }
}

Implementare il backup e ripristino dell'attore

Un servizio Actor personalizzato può esporre un metodo per il backup dei dati dell'attore sfruttando il listener di comunicazione remota già presente in ActorService. Per un esempio, vedere Backup e ripristino di attori.

Attore che usa uno stack di comunicazione remota V2 (compatibile con l'interfaccia)

Lo stack di comunicazione remota V2 (compatibile con l'interfaccia, noto come V2_1) include tutte le funzionalità dello stack di comunicazione remota V2. La sua interfaccia è compatibile con lo stack di comunicazione remota V1, ma non è compatibile con V1 e V2. Per passare da V1 a V2_1 senza compromettere la disponibilità del servizio, seguire i passaggi della sezione successiva.

Per usare lo stack di comunicazione remota V2_1 sono necessarie le seguenti modifiche:

Aggiungere il seguente attributo assembly nelle interfacce dell'attore.

[assembly:FabricTransportActorRemotingProvider(RemotingListenerVersion = RemotingListenerVersion.V2_1,RemotingClientVersion = RemotingClientVersion.V2_1)]

Compilare e aggiornare il servizio Actor e i progetti client dell'attore per iniziare a usare lo stack V2.

Aggiornare il servizio Actor allo stack di comunicazione remota V2 (compatibile con l'interfaccia) senza compromettere la disponibilità del servizio

Questa modifica consiste in un aggiornamento in due passaggi. Seguire i passaggi descritti in questa sequenza.

Aggiungere il seguente attributo assembly nelle interfacce dell'attore. Questo attributo avvia due listener per il servizio Actor, il listener V1 (esistente) e il listener V2_1. Eseguire l'aggiornamento del servizio Actor con questa modifica.
```
[assembly:FabricTransportActorRemotingProvider(RemotingListenerVersion = RemotingListenerVersion.V1|RemotingListenerVersion.V2_1,RemotingClientVersion = RemotingClientVersion.V2_1)]
```
Dopo aver completato l'aggiornamento precedente, aggiornare i client degli attori. Questo passaggio garantisce che il proxy Actor usi lo stack di comunicazione remota V2_1.

Questo passaggio è facoltativo. Modificare l'attributo precedente per rimuovere il listener V1.

[assembly:FabricTransportActorRemotingProvider(RemotingListenerVersion = RemotingListenerVersion.V2_1,RemotingClientVersion = RemotingClientVersion.V2_1)]

Attore che usa lo stack di comunicazione remota V2

Con il pacchetto NuGet 2.8, gli utenti possono usare lo stack di comunicazione remota V2: è più efficiente e fornisce funzioni quali la serializzazione personalizzata. La comunicazione remota V2 non è compatibile lo stack di comunicazione remota esistente (ora definito stack di comunicazione remota V1).

Per usare lo stack di comunicazione remota V2, sono necessarie le seguenti modifiche.