Symulowanie błędów w trakcie obciążenia usługi

Scenariusze testowania w usłudze Azure Service Fabric pozwalają deweloperom nie martwić się o radzenie sobie z poszczególnymi błędami. Istnieją jednak scenariusze, w których może być konieczne jawne przeplatanie obciążenia klienta i awarii. Przeplatanie obciążenia klienta i błędów gwarantuje, że usługa faktycznie wykonuje jakąś akcję w przypadku awarii. Biorąc pod uwagę poziom kontroli zapewnianej przez możliwość testowania, mogą one znajdować się w dokładnych punktach wykonywania obciążenia. Ta indukcja błędów w różnych stanach w aplikacji może znaleźć usterki i poprawić jakość.

Przykładowy scenariusz niestandardowy

W tym teście przedstawiono scenariusz, który przeplata obciążenie biznesowe z bezproblemowymi i niegracyjnymi błędami. Błędy powinny być wywoływane w trakcie operacji usługi lub obliczeń w celu uzyskania najlepszych wyników.

Przyjrzyjmy się przykładowi usługi, która uwidacznia cztery obciążenia: A, B, C i D. Każda z nich odpowiada zestawowi przepływów pracy i może być obliczana, magazynowa lub mieszana. Ze względu na prostotę wyodrębnimy obciążenia w naszym przykładzie. Różne błędy wykonywane w tym przykładzie to:

• RestartNode: niegraceful błąd, aby symulować ponowne uruchomienie maszyny.
• RestartDeployedCodePackage: niegraceful błąd w celu symulowania awarii procesu hosta usługi.
• RemoveReplica: Błąd graceful w celu symulowania usuwania repliki.
• MovePrimary: Błąd graceful w celu symulowania ruchów replik wyzwalanych przez moduł równoważenia obciążenia usługi Service Fabric.

// Add a reference to System.Fabric.Testability.dll and System.Fabric.dll.

using System;
using System.Fabric;
using System.Fabric.Testability.Scenario;
using System.Threading;
using System.Threading.Tasks;

class Test
{
    public static int Main(string[] args)
    {
        // Replace these strings with the actual version for your cluster and application.
        string clusterConnection = "localhost:19000";
        Uri applicationName = new Uri("fabric:/samples/PersistentToDoListApp");
        Uri serviceName = new Uri("fabric:/samples/PersistentToDoListApp/PersistentToDoListService");

        Console.WriteLine("Starting Workload Test...");
        try
        {
            RunTestAsync(clusterConnection, applicationName, serviceName).Wait();
        }
        catch (AggregateException ae)
        {
            Console.WriteLine("Workload Test failed: ");
            foreach (Exception ex in ae.InnerExceptions)
            {
                if (ex is FabricException)
                {
                    Console.WriteLine("HResult: {0} Message: {1}", ex.HResult, ex.Message);
                }
            }
            return -1;
        }

        Console.WriteLine("Workload Test completed successfully.");
        return 0;
    }

    public enum ServiceWorkloads
    {
        A,
        B,
        C,
        D
    }

    public enum ServiceFabricFaults
    {
        RestartNode,
        RestartCodePackage,
        RemoveReplica,
        MovePrimary,
    }

    public static async Task RunTestAsync(string clusterConnection, Uri applicationName, Uri serviceName)
    {
        // Create FabricClient with connection and security information here.
        FabricClient fabricClient = new FabricClient(clusterConnection);
        // Maximum time to wait for a service to stabilize.
        TimeSpan maxServiceStabilizationTime = TimeSpan.FromSeconds(120);

        // How many loops of faults you want to execute.
        uint testLoopCount = 20;
        Random random = new Random();

        for (var i = 0; i < testLoopCount; ++i)
        {
            var workload = SelectRandomValue<ServiceWorkloads>(random);
            // Start the workload.
            var workloadTask = RunWorkloadAsync(workload);

            // While the task is running, induce faults into the service. They can be ungraceful faults like
            // RestartNode and RestartDeployedCodePackage or graceful faults like RemoveReplica or MovePrimary.
            var fault = SelectRandomValue<ServiceFabricFaults>(random);

            // Create a replica selector, which will select a primary replica from the given service to test.
            var replicaSelector = ReplicaSelector.PrimaryOf(PartitionSelector.RandomOf(serviceName));
            // Run the selected random fault.
            await RunFaultAsync(applicationName, fault, replicaSelector, fabricClient);
            // Validate the health and stability of the service.
            await fabricClient.TestManager.ValidateServiceAsync(serviceName, maxServiceStabilizationTime);

            // Wait for the workload to finish successfully.
            await workloadTask;
        }
    }

    private static async Task RunFaultAsync(Uri applicationName, ServiceFabricFaults fault, ReplicaSelector selector, FabricClient client)
    {
        switch (fault)
        {
            case ServiceFabricFaults.RestartNode:
                await client.FaultManager.RestartNodeAsync(selector, CompletionMode.Verify);
                break;
            case ServiceFabricFaults.RestartCodePackage:
                await client.FaultManager.RestartDeployedCodePackageAsync(applicationName, selector, CompletionMode.Verify);
                break;
            case ServiceFabricFaults.RemoveReplica:
                await client.FaultManager.RemoveReplicaAsync(selector, CompletionMode.Verify, false);
                break;
            case ServiceFabricFaults.MovePrimary:
                await client.FaultManager.MovePrimaryAsync(selector.PartitionSelector);
                break;
        }
    }

    private static Task RunWorkloadAsync(ServiceWorkloads workload)
    {
        throw new NotImplementedException();
        // This is where you trigger and complete your service workload.
        // Note that the faults induced while your service workload is running will
        // fault the primary service. Hence, you will need to reconnect to complete or check
        // the status of the workload.
    }

    private static T SelectRandomValue<T>(Random random)
    {
        Array values = Enum.GetValues(typeof(T));
        T workload = (T)values.GetValue(random.Next(values.Length));
        return workload;
    }
}