Load test any system
with a distributed cluster

      var scenario = Scenario.Create("ping_pong_websockets", async ctx =>
      {
          using var websocket = new WebSocket(new WebSocketConfig());

          var connect = await Step.Run("connect", ctx, async () =>
          {
              await websocket.Connect("ws://localhost:5233/ws");
              return Response.Ok();
          });

          var ping = await Step.Run("ping", ctx, async () =>
          {
              await websocket.Send(payload);
              return Response.Ok(sizeBytes: payload.Length);
          });

          var pong = await Step.Run("pong", ctx, async () =>
          {
              using var response = await websocket.Receive();
              return Response.Ok(sizeBytes: response.Data.Length);
          });

          var disconnect = await Step.Run("disconnect", ctx, async () =>
          {
              await websocket.Close();
              return Response.Ok();
          });

          return Response.Ok();
       });

var scenario = Scenario.Create("mqtt_scenario", async ctx =>
{
    using var client = new MqttClient(new MqttFactory().CreateMqttClient());    
  
    var topic = "/clients/" + ctx.ScenarioInfo.InstanceId;

    var connect = await Step.Run("connect", ctx, async () =>
    {
        var clientOptions = new MqttClientOptionsBuilder()
            .WithTcpServer("localhost")             
            .WithClientId(ctx.ScenarioInfo.InstanceId)
            .Build();

        var response = await client.Connect(clientOptions);
        return response;
    });

    var subscribe = await Step.Run("subscribe", ctx, () => client.Subscribe(topic));

    var publish = await Step.Run("publish", ctx, async () =>
    {
        var msg = new MqttApplicationMessageBuilder()
            .WithTopic(topic)
            .WithPayload(payload)
            .Build();

        var response = await client.Publish(msg);
        return response;
    });

    var receive = await Step.Run("receive", ctx, async () =>
    {
        var response = await client.Receive();
        return response;
    });

    var disconnect = await Step.Run("disconnect", ctx, () => client.Disconnect());

    return Response.Ok();
});

        var redis = ConnectionMultiplexer.Connect("redis0:6380");
        var db = redis.GetDatabase();
        var random = new Random();

        var scenario = Scenario.Create("redis_scenario", async context =>
        {
            var userId = random.Next(1_000);

            byte[] data = await db.StringGetAsync($"user-{userId}");

            return Response.Ok(statusCode: "ok", sizeBytes: data.Length);
        })
        .WithLoadSimulations(
            Simulation.Inject(rate: 100,
                              interval: TimeSpan.FromSeconds(1),
                              during: TimeSpan.FromMinutes(3))
        );

        NBomberRunner
            .RegisterScenarios(scenario)
            .Run();