feat: sync testResult bm-controller and bm-agent, client (#58)

* dev: change static css/styles.css path in html

* dev: temporary add Randomized TestResult SSE event

* dev: css textarea style add

* dev: json mapper method add

* dev: CommonTestResult class name change

* dev: CommonTestResult class name change

* dev: invalid json string errorcode

* dev: TemplateInfo getting service

* dev: util for verify accessable template

* dev: add all throws JsonParsing exception

* dev: add prepareScript & header field

* dev: jsonMapper pre-defining

* dev: pre-check invalid json body

* dev: headers & prepareScript entity field add

* dev: remove unused test and add exception

* dev: JsonProcessingException add

* dev: remove random method and add vuser, maxRequest, maxDuration field

* dev: TestResult class change

* dev: pre-build empty template

* dev: add front design and functional method

* dev: http load sender with multi threads

* dev: dns resolver apple silicon dependency

* dev: change dto field

* dev: additional method and comments

* dev: apply changed field

* chore: apply changed field

* dev: health check endpoint

* dev: RequestSpec setter

* dev: child thread with parent thread dependency setting

* dev: child thread managing method

* dev: TPS, MTTFB percentile consts

* dev: TestResult scheduled & async-nonblocking http sender & emitter update

* test: add mockServer test

* fix: java syntax error

* dev: split service & controller

* dev: pr comment merge & test remove

* dev: test exclude setting

* dev: add jacoco perfTest within gradle

* dev: sse mocking response method !

* dev: test code with sse mock response & message event

* dev: schedulerManager duplication/shutdown test

* dev: requestHeadersSpec test

* dev: HealthCheck controller test

* dev: agent information dto

* dev: agent status manager setup

* dev: agent status manager testing

* dev: agent system scheduler

* dev: test with cpu, memory, url, etc.

* dev: system scheduler constant

* dev: encapsulate method

* chore: remove system print

* dev: maxRequest maxDuration validator

* chore: const test exclude

* test: sendRequest wrong url, duration null

* test: AgentInfo endpoint

Author: ghkdqhrbals

bm-agent/build.gradle

@@ -13,6 +13,7 @@ def excludeJacocoTestCoverageReport = [
         // bmagent
         'org/benchmarker/bmagent/BmAgentApplication**',
         'org/benchmarker/bmagent/sse/**',
+        'org/benchmarker/bmagent/consts/SystemSchedulerConst',
 //        'org/benchmarker/bmagent/**',
 ]
 
@@ -34,16 +35,21 @@ repositories {
     mavenCentral()
 }
 
+
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
-    compileOnly 'org.projectlombok:lombok'
+    implementation 'org.projectlombok:lombok'
     annotationProcessor 'org.projectlombok:lombok'
+    implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310'
     // add webflux
     implementation 'org.springframework.boot:spring-boot-starter-webflux'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'org.springframework.boot:spring-boot-testcontainers'
     testImplementation 'org.testcontainers:junit-jupiter'
     testImplementation 'com.squareup.okhttp3:mockwebserver:4.9.1'
+    if (isAppleSilicon()) {
+        runtimeOnly("io.netty:netty-resolver-dns-native-macos:4.1.94.Final:osx-aarch_64")
+    }
 
     implementation project(':bm-common')
 }
@@ -89,4 +95,8 @@ jacocoTestCoverageVerification {
             }
         }
     }
+}
+
+boolean isAppleSilicon() {
+    return System.getProperty("os.name") == "Mac OS X" && System.getProperty("os.arch") == "aarch64"
 }

bm-agent/src/main/java/org/benchmarker/bmagent/consts/PreftestConsts.java

@@ -0,0 +1,9 @@
+package org.benchmarker.bmagent.consts;
+
+import java.util.Arrays;
+import java.util.List;
+
+public interface PreftestConsts {
+    List<Double> percentiles = Arrays.asList(50D, 90D, 95D,99D,99.9D);
+
+}

bm-agent/src/main/java/org/benchmarker/bmagent/consts/SystemSchedulerConst.java

@@ -0,0 +1,11 @@
+package org.benchmarker.bmagent.consts;
+
+public interface SystemSchedulerConst {
+
+    /**
+     * System scheduler will run in this ID
+     */
+    Long systemSchedulerId = -100L;
+    String systemUsageSchedulerName = "cpu-memory-usage-update";
+
+}

bm-agent/src/main/java/org/benchmarker/bmagent/controller/AgentApiController.java

@@ -1,12 +1,16 @@
 package org.benchmarker.bmagent.controller;
 
 
+import jakarta.servlet.http.HttpServletRequest;
 import java.util.Map;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.benchmarker.bmagent.AgentInfo;
+import org.benchmarker.bmagent.AgentStatus;
 import org.benchmarker.bmagent.schedule.SchedulerStatus;
 import org.benchmarker.bmagent.service.IScheduledTaskService;
 import org.benchmarker.bmagent.service.ISseManageService;
+import org.benchmarker.bmagent.status.AgentStatusManager;
 import org.benchmarker.bmcommon.dto.TemplateInfo;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -16,6 +20,8 @@
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 
 
@@ -27,6 +33,7 @@ public class AgentApiController {
 
     private final ISseManageService sseManageService;
     private final IScheduledTaskService scheduledTaskService;
+    private final AgentStatusManager agentStatusManager;
 
     /**
      * support sse for the given id
@@ -37,7 +44,10 @@ public class AgentApiController {
      */
     @PostMapping("/templates/{template_id}")
     public SseEmitter manageSSE(@PathVariable("template_id") Long templateId,
-        @RequestParam("action") String action, @RequestBody(required = false) TemplateInfo templateInfo) {
+        @RequestParam("action") String action, @RequestBody TemplateInfo templateInfo) {
+        log.info(templateInfo.toString());
+        agentStatusManager.getAndUpdateStatusIfReady(
+            AgentStatus.TESTING).orElseThrow(() -> new RuntimeException("agent is not ready"));
 
         if (action.equals("start")) {
             return sseManageService.start(templateId, templateInfo);
@@ -52,9 +62,27 @@ public SseEmitter manageSSE(@PathVariable("template_id") Long templateId,
      *
      * @return Map of scheduler id, status
      */
-    @GetMapping("/status")
+    @GetMapping("/scheduler/status")
     public ResponseEntity<Map<Long, SchedulerStatus>> getSchedulersStatus() {
         return ResponseEntity.ok(scheduledTaskService.getStatus());
     }
+
+    @GetMapping("/status")
+    public AgentInfo getStatus() {
+        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest();
+        String scheme = request.getScheme(); // http or https
+        String serverName = request.getServerName();
+        int serverPort = request.getServerPort();
+
+        String agentServerUrl = scheme + "://" + serverName + ":" + serverPort;
+
+        return AgentInfo.builder()
+            .cpuUsage(agentStatusManager.getCpuUsage())
+            .memoryUsage(agentStatusManager.getMemoryUsage())
+            .startedAt(agentStatusManager.getStartedAt())
+            .serverUrl(agentServerUrl)
+            .status(agentStatusManager.getStatus().get())
+            .build();
+    }
 }
 

bm-agent/src/main/java/org/benchmarker/bmagent/initializer/Initializer.java

@@ -0,0 +1,25 @@
+package org.benchmarker.bmagent.initializer;
+
+import java.util.concurrent.TimeUnit;
+import lombok.RequiredArgsConstructor;
+import org.benchmarker.bmagent.consts.SystemSchedulerConst;
+import org.benchmarker.bmagent.schedule.ScheduledTaskService;
+import org.benchmarker.bmagent.status.AgentStatusManager;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class Initializer implements CommandLineRunner {
+
+    private final ScheduledTaskService scheduledTaskService;
+    private final AgentStatusManager agentStatusManager;
+
+    @Override
+    public void run(String... args) throws Exception {
+        // cpu, memory usage checker
+        scheduledTaskService.startChild(SystemSchedulerConst.systemSchedulerId,
+            SystemSchedulerConst.systemUsageSchedulerName, agentStatusManager::updateStats, 0, 1,
+            TimeUnit.SECONDS);
+    }
+}

bm-agent/src/main/java/org/benchmarker/bmagent/pref/HttpSender.java

@@ -0,0 +1,199 @@
+package org.benchmarker.bmagent.pref;
+
+import static org.benchmarker.bmcommon.util.NoOp.noOp;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.IntStream;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.benchmarker.bmagent.service.IScheduledTaskService;
+import org.benchmarker.bmagent.util.WebClientSupport;
+import org.benchmarker.bmcommon.dto.TemplateInfo;
+import org.springframework.web.reactive.function.client.WebClient.RequestHeadersSpec;
+import reactor.core.publisher.Mono;
+
+/**
+ * High load HTTP sender
+ *
+ * @author Gyumin Hwangbo
+ */
+@Slf4j
+@Getter
+public class HttpSender {
+
+    private final ResultManagerService resultManagerService;
+    private final IScheduledTaskService scheduledTaskService;
+
+
+    public HttpSender(ResultManagerService resultManagerService,
+        IScheduledTaskService scheduledTaskService) {
+        this.resultManagerService = resultManagerService;
+        this.scheduledTaskService = scheduledTaskService;
+    }
+
+    private Integer defaultMaxRequestsPerUser = 100000000;
+    private Integer defaultMaxDuration = 5; // 5 hours
+    private AtomicInteger totalRequests = new AtomicInteger(0);
+    private AtomicInteger totalSuccess = new AtomicInteger(0);
+    private AtomicInteger totalErrors = new AtomicInteger(0);
+    // Response time, TPS
+    private AtomicInteger tps = new AtomicInteger(0);
+    private ConcurrentHashMap<LocalDateTime, Double> tpsMap = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<LocalDateTime, Long> mttfbMap = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, Integer> statusCodeCount = new ConcurrentHashMap<>();
+    private List<CompletableFuture<Void>> futures;
+    private Boolean isRunning = true;
+
+    /**
+     * <strong>Major implementation sending multiple requests to target server</strong>
+     *
+     * <p>Whenever totalRequests hit maxRequests, test stop even if duration is still remained.</p>
+     * <p>But, if you has null value of maxRequests and valid maxDuration, it will continue to run
+     * test until current time is reach to maxDuration </p>
+     *
+     * <p>This method run child scheduler with {@link TemplateInfo#id} key</p>
+     *
+     * @param templateInfo {@link TemplateInfo}
+     */
+    public void sendRequests(TemplateInfo templateInfo) throws MalformedURLException {
+        URL url = new URL(templateInfo.getUrl());
+        RequestHeadersSpec<?> req = WebClientSupport.create(templateInfo.getMethod(),
+            templateInfo.getUrl(),
+            templateInfo.getBody(),
+            templateInfo.getHeaders());
+
+        // if both duration & requests is not valid, immediately return
+        if (templateInfo.getMaxDuration() == null && templateInfo.getMaxRequest() == null) {
+            return;
+        } else if (templateInfo.getMaxRequest() != null && templateInfo.getMaxDuration() == null) {
+            templateInfo.setMaxDuration(Duration.ofHours(defaultMaxDuration));
+        } else if (templateInfo.getMaxRequest() == null && templateInfo.getMaxDuration() != null) {
+            templateInfo.setMaxRequest(defaultMaxRequestsPerUser);
+        } else {
+            noOp();
+        }
+
+        Duration duration = templateInfo.getMaxDuration();
+
+        // Future setup
+        futures = IntStream.range(0, templateInfo.getVuser())
+            .mapToObj(i -> CompletableFuture.runAsync(() -> {
+                long startTime = System.currentTimeMillis(); // 시작 시간 기록
+                long endTime = startTime + duration.toMillis();
+                for (int j = 0; j < templateInfo.getMaxRequest(); j++) {
+                    // 만약 running 이 아니거나 시간이 끝났다면,
+                    if (!isRunning || System.currentTimeMillis() > endTime) {
+                        return;
+                    }
+                    long requestStartTime = System.currentTimeMillis();  // 요청 시작 시간 기록
+                    req.exchangeToMono(resp -> {
+                        String statusCode = resp.statusCode().toString();
+                        statusCodeCount.merge(statusCode, 1, Integer::sum);
+                        if (resp.statusCode().is2xxSuccessful()) {
+                            totalSuccess.incrementAndGet();
+                        } else {
+                            totalErrors.incrementAndGet();
+                        }
+                        return Mono.empty();
+                    }).block();
+
+                    long requestEndTime = System.currentTimeMillis();
+                    long elapsedTime = requestEndTime - requestStartTime;
+                    LocalDateTime currentTime = LocalDateTime.now()
+                        .truncatedTo(ChronoUnit.SECONDS);
+                    mttfbMap.merge(currentTime, elapsedTime,
+                        (oldValue, newValue) -> (oldValue + newValue) / 2);
+                    tps.incrementAndGet();
+                    totalRequests.incrementAndGet();
+                }
+
+            }))
+            .toList();
+
+        // Need to calculate & save TPS and MTTFB in every 1 second.
+        scheduledTaskService.startChild(Long.valueOf(templateInfo.getId()), "recorder", () -> {
+            // save current tps & reset
+            tpsMap.put(LocalDateTime.now().truncatedTo(ChronoUnit.SECONDS),
+                Double.valueOf(tps.get()));
+            tps.set(0); // initial
+        }, 0, 1, java.util.concurrent.TimeUnit.SECONDS);
+
+        // CompletableFuture 종료까지 대기
+        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
+    }
+
+    /**
+     * Calculate percentile for TPS (Transactions Per Second)
+     *
+     * @param percentile The percentile to calculate (e.g., 90 for 90th percentile)
+     * @return The calculated percentile value
+     */
+    public Map<Double, Double> calculateTpsPercentile(List<Double> percentile) {
+        Map<Double, Double> result = new HashMap<>();
+
+        List<Double> tpsList = this.sortedTpsMap();
+        int size = tpsList.size();
+        for (Double p : percentile) {
+            int index = (int) Math.ceil((p / 100) * size) - 1;
+            if (index < 0) {
+                return Map.of(0D, 0D); // 예외처리: 인덱스가 음수인 경우
+            }
+            result.put(p, tpsList.get(index));
+        }
+
+        return result;
+    }
+
+    public List<Double> sortedTpsMap() {
+        Map<LocalDateTime, Double> tpsSnapshot = new ConcurrentHashMap<>(tpsMap);
+        return tpsSnapshot.values().stream().sorted(Comparator.reverseOrder())
+            .toList(); // <-- Here STOP!
+    }
+
+    public List<Long> sortedMttfbMap() {
+        Map<LocalDateTime, Long> tpsSnapshot = new ConcurrentHashMap<>(mttfbMap);
+        return tpsSnapshot.values().stream().sorted().toList(); // <-- Here STOP!
+    }
+
+    /**
+     * Calculate percentile for MTTFB (Mean Time To First Byte)
+     *
+     * @param percentile The percentile to calculate (e.g., 90 for 90th percentile)
+     * @return The calculated percentile value
+     */
+    public Map<Double, Double> calculateMttfbPercentile(List<Double> percentile) {
+        Map<Double, Double> result = new HashMap<>();
+
+        List<Long> mttfbList = this.sortedMttfbMap();
+        int size = mttfbList.size();
+        for (Double p : percentile) {
+            int index = (int) Math.ceil((p / 100) * size) - 1;
+            if (index < 0) {
+                return Map.of(0D, 0D); // 예외처리: 인덱스가 음수인 경우
+            }
+            result.put(p, Double.valueOf(mttfbList.get(index)));
+        }
+
+        return result;
+    }
+
+    /**
+     * downstream 에서만 제거 가능. 외부에서는 cancel 불가능...
+     */
+    public void cancelRequests() {
+        isRunning = false;
+
+    }
+
+}