Docker Images And EKS Deployment

package main

import (
	"fmt"
	loadstrike "loadstrike.com/sdk/go"
	"os"
	"strings"
)

func required(name string) string {
	value := strings.TrimSpace(os.Getenv(name))
	if value == "" {
		panic("missing " + name)
	}
	return value
}

func main() {
	role := required("NODE_ROLE")
	scenario := loadstrike.CreateScenario("checkout", func(ctx loadstrike.LoadStrikeScenarioContext) loadstrike.LoadStrikeReply {
		return loadstrike.LoadStrikeStep.Run("checkout", ctx, func(loadstrike.LoadStrikeScenarioContext) loadstrike.LoadStrikeReply {
			// Replace with the owned application's actual checkout request.
			return loadstrike.OK()
		})
	}).WithoutWarmUp().WithDeclaredSteps("checkout").WithLoadSimulations(loadstrike.LoadStrikeSimulation.IterationsForConstant(2, 100))
	reportDir := strings.TrimSpace(os.Getenv("REPORT_DIR"))
	if reportDir == "" {
		reportDir = "/reports"
	}
	context := loadstrike.RegisterScenarios(scenario).
		WithSessionId(required("SESSION_ID")).WithClusterId(required("CLUSTER_ID")).
		WithAgentGroup(required("AGENT_GROUP")).WithNatsServerUrl(required("NATS_URL")).
		WithAgentsCount(2).WithClusterCommandTimeout(loadstrike.DurationFromSeconds(120)).
		UseLoadEngineV2().WithMaxInFlight(1000).WithReportFolder(reportDir)
	switch role {
	case "Coordinator":
		context = context.WithNodeType(loadstrike.NodeTypeCoordinator).
			WithExpectedAgentIDs("agent-0", "agent-1").WithRunnerKey(required("LOADSTRIKE_RUNNER_KEY"))
	case "Agent":
		index := required("JOB_COMPLETION_INDEX")
		if index != "0" && index != "1" {
			panic("JOB_COMPLETION_INDEX must be 0 or 1")
		}
		// Keyless agents require a compatible publisher-signed runtime already
		// provisioned in their protected cache; startup does not download one.
		context = context.WithNodeType(loadstrike.NodeTypeAgent).WithAgentID("agent-" + index)
	default:
		panic("NODE_ROLE must be Agent or Coordinator")
	}
	result := context.Run()
	fmt.Printf("requests=%d ok=%d failed=%d reportingComplete=%v\n", result.AllRequestCount(), result.AllOKCount(), result.AllFailCount(), result.ReportingComplete())
	if !result.ReportingComplete() || len(result.SinkErrors()) > 0 {
		os.Exit(1)
	}
}

import com.loadstrike.runtime.LoadStrikeRuntime;

class LoadStrikeEksExample {
  public static void main(String[] args) {
    String role = required("NODE_ROLE");
    if (!role.equals("Agent") && !role.equals("Coordinator")) {
      throw new IllegalArgumentException("NODE_ROLE must be Agent or Coordinator.");
    }
    String session = required("SESSION_ID");
    String cluster = required("CLUSTER_ID");
    String group = required("AGENT_GROUP");
    String natsUrl = required("NATS_URL");
    var scenario = LoadStrikeRuntime.LoadStrikeScenario.create("checkout", context -> {
      // Call the application under test here.
      return LoadStrikeRuntime.LoadStrikeResponse.ok("200");
    }).withoutWarmUp().withLoadSimulations(
        LoadStrikeRuntime.LoadStrikeSimulation.iterationsForConstant(10, 100));
    var runner = LoadStrikeRuntime.LoadStrikeRunner.registerScenarios(scenario)
        .useLoadEngineV2().withMaxInFlight(1000).withNodeType(role)
        .withSessionId(session)
        .configure(context -> context.withClusterId(cluster))
        .withAgentGroup(group).withExpectedAgentIds("agent-0", "agent-1")
        .withAgentsCount(2).withNatsServerUrl(natsUrl)
        .withClusterCommandTimeout(120)
        .withReportFolder(System.getenv().getOrDefault("REPORT_DIR", "/reports"))
        .withReportFormats("html", "txt", "csv", "md");
    if ("Coordinator".equals(role)) {
      runner.withRunnerKey(required("LOADSTRIKE_RUNNER_KEY"));
    } else {
      int index = Integer.parseInt(required("JOB_COMPLETION_INDEX"));
      if (index < 0 || index > 1) {
        throw new IllegalArgumentException("JOB_COMPLETION_INDEX must be 0 or 1.");
      }
      if (System.getenv("LOADSTRIKE_RUNNER_KEY") != null) {
        throw new IllegalStateException("Agents must not receive the coordinator runner key.");
      }
      runner.withAgentId("agent-" + index);
    }
    var result = runner.run();
    System.out.println("requests=" + result.allRequestCount + " failed=" + result.allFailCount);
    int expected = role.equals("Coordinator") ? 100 : 50;
    if (result.allRequestCount != expected || result.allFailCount != 0
        || !result.reportingComplete || !result.sinkErrors.isEmpty()
        || !result.disabledSinks.isEmpty()) {
      throw new IllegalStateException("The distributed workload or reporting did not complete successfully.");
    }
  }

  private static String required(String name) {
    String value = System.getenv(name);
    if (value == null || value.isBlank()) {
      throw new IllegalArgumentException(name + " is required.");
    }
    return value;
  }
}

import os
from loadstrike_sdk import (
    LoadStrikeResponse, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeSimulation,
)

def required(name):
    value = os.environ.get(name)
    if not value:
        raise ValueError(name + " is required")
    return value

role = required("NODE_ROLE")  # Agent or Coordinator
if role not in ("Agent", "Coordinator"):
    raise ValueError("NODE_ROLE must be Agent or Coordinator")
index = required("JOB_COMPLETION_INDEX") if role == "Agent" else None
if role == "Agent" and index not in ("0", "1"):
    raise ValueError("JOB_COMPLETION_INDEX must be 0 or 1")
agent_id = "agent-" + index if index is not None else "coordinator"
scenario = LoadStrikeScenario.create("checkout", lambda _: LoadStrikeResponse.ok("200"))
scenario = scenario.without_warm_up().with_load_simulations(
    LoadStrikeSimulation.iterations_for_constant(2, 100)
)
runner = LoadStrikeRunner.register_scenarios(scenario).configure(
    node_type=role,
    session_id=required("SESSION_ID"),
    cluster_id=required("CLUSTER_ID"),
    agent_group=required("AGENT_GROUP"),
    agent_id=agent_id,
    agents_count=2,
    expected_agent_ids=["agent-0", "agent-1"],
    nats_server_url=required("NATS_URL"),
    runner_key=required("LOADSTRIKE_RUNNER_KEY") if role == "Coordinator" else None,
    reports_enabled=role == "Coordinator",
    report_folder_path=os.environ.get("REPORT_DIR") or "/reports",
    report_formats=["html", "md", "txt", "csv"],
).use_load_engine_v2().with_max_in_flight(1000)
result = runner.run()
print(result["allRequestCount"])

import {
  LoadStrikeResponse, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeSimulation,
} from "@loadstrike/loadstrike-sdk";

function required(name: string): string {
  const value = process.env[name];
  if (!value) throw new Error(`${name} is required`);
  return value;
}
const role = required("NODE_ROLE");
if (role !== "Agent" && role !== "Coordinator") throw new Error("NODE_ROLE must be Agent or Coordinator");
const index = role === "Agent" ? required("JOB_COMPLETION_INDEX") : undefined;
if (role === "Agent" && index !== "0" && index !== "1") throw new Error("JOB_COMPLETION_INDEX must be 0 or 1");
const agentId = role === "Agent" ? `agent-${index}` : "coordinator";
const scenario = LoadStrikeScenario.create("checkout", async () => LoadStrikeResponse.ok("200"))
  .withoutWarmUp()
  .withLoadSimulations(LoadStrikeSimulation.iterationsForConstant(2, 100));
const runner = LoadStrikeRunner.registerScenarios(scenario).configure({
  nodeType: role,
  sessionId: required("SESSION_ID"),
  clusterId: required("CLUSTER_ID"),
  agentGroup: required("AGENT_GROUP"),
  agentId,
  agentsCount: 2,
  expectedAgentIds: ["agent-0", "agent-1"],
  natsServerUrl: required("NATS_URL"),
  runnerKey: role === "Coordinator" ? required("LOADSTRIKE_RUNNER_KEY") : undefined,
  reportsEnabled: role === "Coordinator",
  reportFolderPath: process.env.REPORT_DIR || "/reports",
  reportFormats: ["html", "md", "txt", "csv"],
}).useLoadEngineV2().withMaxInFlight(1000);
const result = await runner.run();
console.log(result.allRequestCount);

const {
  LoadStrikeResponse, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeSimulation,
} = require("@loadstrike/loadstrike-sdk");

function required(name) {
  const value = process.env[name];
  if (!value) throw new Error(`${name} is required`);
  return value;
}
const role = required("NODE_ROLE");
if (role !== "Agent" && role !== "Coordinator") throw new Error("NODE_ROLE must be Agent or Coordinator");
const index = role === "Agent" ? required("JOB_COMPLETION_INDEX") : undefined;
if (role === "Agent" && index !== "0" && index !== "1") throw new Error("JOB_COMPLETION_INDEX must be 0 or 1");
const agentId = role === "Agent" ? `agent-${index}` : "coordinator";
const scenario = LoadStrikeScenario.create("checkout", async () => LoadStrikeResponse.ok("200"))
  .withoutWarmUp()
  .withLoadSimulations(LoadStrikeSimulation.iterationsForConstant(2, 100));
const runner = LoadStrikeRunner.registerScenarios(scenario).configure({
  nodeType: role,
  sessionId: required("SESSION_ID"),
  clusterId: required("CLUSTER_ID"),
  agentGroup: required("AGENT_GROUP"),
  agentId,
  agentsCount: 2,
  expectedAgentIds: ["agent-0", "agent-1"],
  natsServerUrl: required("NATS_URL"),
  runnerKey: role === "Coordinator" ? required("LOADSTRIKE_RUNNER_KEY") : undefined,
  reportsEnabled: role === "Coordinator",
  reportFolderPath: process.env.REPORT_DIR || "/reports",
  reportFormats: ["html", "md", "txt", "csv"],
}).useLoadEngineV2().withMaxInFlight(1000);
(async () => {
  const result = await runner.run();
  console.log(result.allRequestCount);
})().catch(error => {
  console.error(error);
  process.exitCode = 1;
});