ClientsOrleans

Vous pouvez également obtenir une interface client telle que IGrainFactory ou IClusterClient à partir de ISiloHost :

La configuration est fournie via UseOrleansClient et plusieurs classes d’options supplémentaires qui contiennent une hiérarchie de propriétés de configuration pour configurer programmatiquement un client. Pour plus d’informations, consultez Configuration de client.

Considérez l’exemple de configuration client suivant :

// Alternatively, call Host.CreateDefaultBuilder(args) if using the 
// Microsoft.Extensions.Hosting NuGet package.
using IHost host = new HostBuilder()
    .UseOrleansClient(clientBuilder =>
    {
        clientBuilder.Configure<ClusterOptions>(options =>
        {
            options.ClusterId = "my-first-cluster";
            options.ServiceId = "MyOrleansService";
        });

        clientBuilder.UseAzureStorageClustering(
            options => options.ConfigureTableServiceClient(connectionString))
    })
    .Build();

Lorsque host (hôte) est démarré, le client est configuré et disponible par le biais de son instance de fournisseur de services construite.

La configuration est fournie via ClientBuilder et plusieurs classes d’options supplémentaires qui contiennent une hiérarchie de propriétés de configuration pour configurer programmatiquement un client. Pour plus d’informations, consultez Configuration de client.

Exemple de configuration de client :

var client = new ClientBuilder()
    .Configure<ClusterOptions>(options =>
    {
        options.ClusterId = "my-first-cluster";
        options.ServiceId = "MyOrleansService";
    })
    .UseAzureStorageClustering(
        options => options.ConnectionString = connectionString)
    .ConfigureApplicationParts(
        parts => parts.AddApplicationPart(typeof(IValueGrain).Assembly))
    .Build();

Pour finir, vous devez appeler la méthode Connect() sur l’objet client construit afin de l’amener à se connecter au cluster Orleans. Il s’agit d’une méthode asynchrone qui retourne un objet Task. Vous devez donc attendre la fin de son exécution avec un await ou un .Wait().

await client.Connect();

Il existe deux scénarios dans lesquels un client de cluster peut rencontrer des problèmes de connectivité :

• Quand le client tente de se connecter à un silo.
• Lors de la réalisation d’appels sur des références de grain obtenues à partir d’un client de cluster connecté.

Dans le premier cas, le client tente de se connecter à un silo. Si le client ne parvient pas à se connecter à un silo, une exception est levée pour indiquer le problème. Vous pouvez inscrire un IClientConnectionRetryFilter pour gérer l’exception et décider de réessayer ou non. Si aucun filtre de nouvelle tentative n’est fourni ou si le filtre de nouvelle tentative retourne false, le client abandonne définitivement.

using Orleans.Runtime;

internal sealed class ClientConnectRetryFilter : IClientConnectionRetryFilter
{
    private int _retryCount = 0;
    private const int MaxRetry = 5;
    private const int Delay = 1_500;

    public async Task<bool> ShouldRetryConnectionAttempt(
        Exception exception,
        CancellationToken cancellationToken)
    {
        if (_retryCount >= MaxRetry)
        {
            return false;
        }

        if (!cancellationToken.IsCancellationRequested &&
            exception is SiloUnavailableException siloUnavailableException)
        {
            await Task.Delay(++ _retryCount * Delay, cancellationToken);
            return true;
        }

        return false;
    }
}

Il existe deux scénarios dans lesquels un client de cluster peut rencontrer des problèmes de connectivité :

• Quand la méthode IClusterClient.Connect() est appelée initialement.
• Lors de la réalisation d’appels sur des références de grain obtenues à partir d’un client de cluster connecté.

Dans le premier cas, la méthode Connect lève une exception pour indiquer le problème qui est survenu. Il s’agit généralement (mais pas nécessairement) d’une exception SiloUnavailableException. Dans ce cas, l’instance de client de cluster est inutilisable et doit être supprimée. Une fonction de filtre de nouvelle tentative peut éventuellement être fournie à la méthode Connect, qui peut, par exemple, attendre un temps spécifié avant d’effectuer une autre tentative. Si aucun filtre de nouvelle tentative n’est fourni ou si le filtre de nouvelle tentative retourne false, le client abandonne définitivement.

Si Connect est retourné correctement, le client de cluster est garanti comme utilisable jusqu’à ce qu’il soit supprimé. Cela signifie que même si le client rencontre des problèmes de connexion, il tentera indéfiniment d’être récupéré. Le comportement de récupération exact peut être configuré sur un objet GatewayOptions fourni par ClientBuilder. Par exemple :

var client = new ClientBuilder()
    // ...
    .Configure<GatewayOptions>(
        options =>                         // Default is 1 min.
        options.GatewayListRefreshPeriod = TimeSpan.FromMinutes(10))
    .Build();

using Microsoft.Extensions.Hosting;

namespace Client;

public sealed class ClusterClientHostedService : IHostedService
{
    private readonly IClusterClient _client;

    public ClusterClientHostedService(IClusterClient client)
    {
        _client = client;
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        // Use the _client to consume grains...

        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
        => Task.CompletedTask;
}

public class ClusterClientHostedService : IHostedService
{
    private readonly IClusterClient _client;

    public ClusterClientHostedService(IClusterClient client)
    {
        _client = client;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // A retry filter could be provided here.
        await _client.Connect();
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        await _client.Close();

        _client.Dispose();
    }
}

try
{
    using IHost host = Host.CreateDefaultBuilder(args)
        .UseOrleansClient((context, client) =>
        {
            client.Configure<ClusterOptions>(options =>
            {
                options.ClusterId = "my-first-cluster";
                options.ServiceId = "MyOrleansService";
            })
            .UseAzureStorageClustering(
                options => options.ConfigureTableServiceClient(
                    context.Configuration["ORLEANS_AZURE_STORAGE_CONNECTION_STRING"]));
        })
        .UseConsoleLifetime()
        .Build();

    await host.StartAsync();

    IGrainFactory client = host.Services.GetRequiredService<IGrainFactory>();

    // Hardcoded player ID
    Guid playerId = new("{2349992C-860A-4EDA-9590-000000000006}");
    IPlayerGrain player = client.GetGrain<IPlayerGrain>(playerId);
    IGameGrain? game = null;
    while (game is null)
    {
        Console.WriteLine(
            $"Getting current game for player {playerId}...");

        try
        {
            game = await player.GetCurrentGame();
            if (game is null) // Wait until the player joins a game
            {
                await Task.Delay(TimeSpan.FromMilliseconds(5_000));
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Exception: {ex.GetBaseException()}");
        }
    }

    Console.WriteLine(
        $"Subscribing to updates for game {game.GetPrimaryKey()}...");

    // Subscribe for updates
    var watcher = new GameObserver();
    await game.ObserveGameUpdates(
        client.CreateObjectReference<IGameObserver>(watcher));

    Console.WriteLine(
        "Subscribed successfully. Press <Enter> to stop.");
}
catch (Exception e)
{
    Console.WriteLine(
        $"Unexpected Error: {e.GetBaseException()}");
}

await RunWatcherAsync();

// Block the main thread so that the process doesn't exit.
// Updates arrive on thread pool threads.
Console.ReadLine();

static async Task RunWatcherAsync()
{
    try
    {
        var client = new ClientBuilder()
            .Configure<ClusterOptions>(options =>
            {
                options.ClusterId = "my-first-cluster";
                options.ServiceId = "MyOrleansService";
            })
            .UseAzureStorageClustering(
                options => options.ConnectionString = connectionString)
            .ConfigureApplicationParts(
                parts => parts.AddApplicationPart(typeof(IValueGrain).Assembly))
            .Build();

            // Hardcoded player ID
            Guid playerId = new("{2349992C-860A-4EDA-9590-000000000006}");
            IPlayerGrain player = client.GetGrain<IPlayerGrain>(playerId);
            IGameGrain game = null;
            while (game is null)
            {
                Console.WriteLine(
                    $"Getting current game for player {playerId}...");

                try
                {
                    game = await player.GetCurrentGame();
                    if (game is null) // Wait until the player joins a game
                    {
                        await Task.Delay(TimeSpan.FromMilliseconds(5_000));
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Exception: {ex.GetBaseException()}");
                }
            }

            Console.WriteLine(
                $"Subscribing to updates for game {game.GetPrimaryKey()}...");

            // Subscribe for updates
            var watcher = new GameObserver();
            await game.SubscribeForGameUpdates(
                await client.CreateObjectReference<IGameObserver>(watcher));

            Console.WriteLine(
                "Subscribed successfully. Press <Enter> to stop.");

            Console.ReadLine(); 
        }
        catch (Exception e)
        {
            Console.WriteLine(
                $"Unexpected Error: {e.GetBaseException()}");
        }
    }
}

/// <summary>
/// Observer class that implements the observer interface.
/// Need to pass a grain reference to an instance of
/// this class to subscribe for updates.
/// </summary>
class GameObserver : IGameObserver
{
    public void UpdateGameScore(string score)
    {
        Console.WriteLine("New game score: {0}", score);
    }
}