Merge pull request #16 from conductor-oss/hedge

Few changes to HelloController

Author: shaileshpadave

src/main/java/org/conductoross/controller/CircuitBreakerController.java

@@ -108,12 +108,16 @@ public String faultInjection(
             @ApiResponse(responseCode = "200", description = "Successful operation"),
             @ApiResponse(responseCode = "Multiple", description = "Various status codes as specified in pattern")
     })
+
     @GetMapping("/pattern")
     public ResponseEntity<String> patternResponse(
             @Parameter(description = "Comma-separated list of response codes", required = false,
-                    example = "200,500,500,500,200,200,200")
-            @RequestParam(defaultValue = "200,500,500,500,200,200,200") String responseCode) {
+                    example = "500,500,500,200")
+            @RequestParam(defaultValue = "500,500,500,200") String statusCode,
+
+            @Parameter(description = "Request identifier for pattern tracking", required = true)
+            @RequestParam String requestId) {
 
-        return circuitBreakerService.simulatePatternResponse(responseCode);
+        return circuitBreakerService.simulatePatternResponse(statusCode, requestId);
     }
 }

src/main/java/org/conductoross/controller/HelloController.java

@@ -13,12 +13,16 @@
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.HashMap;
+import java.util.Map;
+
 @RestController
 @RequestMapping("/api/hello")
 @Tag(name = "HttpBin Service", description = "HttpBin is a microservice designed for testing HTTP-related scenarios")
 public class HelloController {
 
     private final HelloService helloService;
+    private static final String EXPECTED_SECRET = "blahSecret";
 
     public HelloController(HelloService helloService) {
         this.helloService = helloService;
@@ -180,4 +184,68 @@ public String handleHedgeRequest(
         // Process the request through service
         return helloService.processHedgeRequest(number, delayMs);
     }
+
+    @GetMapping("/validate-secret")
+    public ResponseEntity<?> validateSecret(
+            @RequestHeader Map<String, String> headers) {
+
+        String authHeader = headers.getOrDefault("X-Authorization",
+                headers.getOrDefault("x-authorization", null));
+
+        Map<String, Object> response = new HashMap<>();
+        response.put("received_headers", headers);
+        response.put("auth_status", EXPECTED_SECRET.equals(authHeader) ? "valid" : "invalid");
+        response.put("timestamp", System.currentTimeMillis());
+
+
+        if (EXPECTED_SECRET.equals(authHeader)) {
+            response.put("message", "Secret was correctly substituted");
+            return ResponseEntity.ok(response);
+        } else {
+            response.put("message", "Invalid or missing secret");
+            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(response);
+        }
+    }
+    @Operation(summary = "Hello with sequential status codes",
+            description = "Returns responses with status codes in the specified sequence. " +
+                    "Each subsequent call will return the next status code in the sequence.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "Successful operation"),
+            @ApiResponse(responseCode = "400", description = "Bad Request - Invalid status codes"),
+            @ApiResponse(responseCode = "XXX", description = "Various status codes as specified in sequence")
+    })
+    @GetMapping("/sequential-status")
+    public ResponseEntity<Map<String, Object>> sayHelloWithSequentialStatus(
+            @Parameter(description = "Name to be greeted", required = true, example = "John")
+            @RequestParam String name,
+
+            @Parameter(description = "Comma-separated list of status codes to cycle through",
+                    required = true,
+                    example = "200,400,500,304,200")
+            @RequestParam String codes) {
+
+        try {
+            // Parse the status codes
+            String[] statusCodeStrings = codes.split(",");
+            int[] statusCodes = new int[statusCodeStrings.length];
+
+            for (int i = 0; i < statusCodeStrings.length; i++) {
+                statusCodes[i] = Integer.parseInt(statusCodeStrings[i].trim());
+                // Validate status code range
+                if (statusCodes[i] < 100 || statusCodes[i] > 599) {
+                    Map<String, Object> errorResponse = new HashMap<>();
+                    errorResponse.put("error", "Invalid HTTP status code: " + statusCodes[i] + ". Valid range is 100-599.");
+                    return ResponseEntity.badRequest().body(errorResponse);
+                }
+            }
+
+            // Delegate to service to handle the sequential logic
+            return helloService.sayHelloWithSequentialStatus(name, statusCodes);
+
+        } catch (NumberFormatException e) {
+            Map<String, Object> errorResponse = new HashMap<>();
+            errorResponse.put("error", "Invalid status code format. Use comma-separated integers.");
+            return ResponseEntity.badRequest().body(errorResponse);
+        }
+    }
 }

src/main/java/org/conductoross/service/CircuitBreakerService.java

@@ -8,6 +8,7 @@
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.stream.Collectors;
 
 @Service
@@ -21,6 +22,21 @@ public class CircuitBreakerService {
     // Track the current delay for progressive degradation
     private final ConcurrentHashMap<String, Integer> currentDelays = new ConcurrentHashMap<>();
 
+    // Map: requestId -> (pattern list, lock)
+    private final Map<String, PatternEntry> patternMap = new ConcurrentHashMap<>();
+
+    /**
+     * Thread-safe class to hold pattern and lock
+     */
+    private static class PatternEntry {
+        final LinkedList<Integer> pattern;
+        final ReentrantLock lock = new ReentrantLock();
+
+        PatternEntry(LinkedList<Integer> pattern) {
+            this.pattern = pattern;
+        }
+    }
+
     /**
      * Simulates a service with time-based lifecycle phases
      * (normal -> degrading -> failing -> recovering -> normal)
@@ -183,6 +199,10 @@ public ResponseEntity<String> simulatePatternResponse(String responseCodePattern
         int position = counter.getAndIncrement() % pattern.size();
         int statusCode = pattern.get(position);
 
+        if (statusCode == 200) {
+            counter.set(0);
+        }
+
         // Create a meaningful response
         String responseBody = String.format(
                 "Pattern response: step %d of %d, returning status %d",
@@ -339,4 +359,55 @@ public String getExpectedCircuitBreakerState() {
             }
         }
     }
+
+    /**
+     * Returns responses according to a specified pattern of status codes
+     * Thread-safe implementation that handles concurrent requests with the same requestId
+     */
+    public ResponseEntity<String> simulatePatternResponse(String responseCodePattern, String requestId) {
+        // Get or create pattern entry for this requestId
+        PatternEntry entry = patternMap.computeIfAbsent(requestId, k -> {
+            LinkedList<Integer> codes = new LinkedList<>();
+            try {
+                Arrays.stream(responseCodePattern.split(","))
+                        .map(String::trim)
+                        .map(Integer::parseInt)
+                        .forEach(codes::add);
+
+                if (codes.isEmpty()) {
+                    return null; // Will trigger bad request response
+                }
+
+                return new PatternEntry(codes);
+            } catch (NumberFormatException e) {
+                return null; // Will trigger bad request response
+            }
+        });
+
+        // Handle validation errors
+        if (entry == null) {
+            return ResponseEntity.badRequest().body("Invalid pattern format or empty pattern");
+        }
+
+        // Use lock to ensure thread safety when modifying the pattern list
+        entry.lock.lock();
+        try {
+            // Get the status code from the front of the list
+            int statusCode = entry.pattern.isEmpty() ? 500 : entry.pattern.removeFirst();
+
+            // Create a response message
+            String responseBody = String.format(
+                    "Pattern response for request %s: returning status %d, remaining pattern: %s",
+                    requestId, statusCode, entry.pattern);
+
+            // If we've returned a 200 or the list is now empty, remove from the map
+            if (statusCode == 200 || entry.pattern.isEmpty()) {
+                patternMap.remove(requestId);
+            }
+            System.out.println("For request ID:"+requestId+" response code is "+ statusCode);
+            return ResponseEntity.status(statusCode).body(responseBody);
+        } finally {
+            entry.lock.unlock();
+        }
+    }
 }

src/main/java/org/conductoross/service/HelloService.java

@@ -2,8 +2,12 @@
 
 import org.conductoross.exception.ExternalDependencyException;
 import org.conductoross.exception.OverloadedServiceException;
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Random;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Semaphore;
@@ -219,4 +223,32 @@ public String processRequest(String clientIp, int requestedDelay) {
         // Return the response
         return "Hello, HedgeReq. Seq is #" + currentSeq + ". Returning response after " + actualDelay + "ms.";
     }
+
+    private final Map<String, Integer> sequentialCounters = new ConcurrentHashMap<>();
+
+    public ResponseEntity<Map<String, Object>> sayHelloWithSequentialStatus(String name, int[] statusCodes) {
+        // Create a unique key for this sequence (you might want to include more context)
+        String sequenceKey = Arrays.toString(statusCodes);
+
+        // Get current position in sequence (thread-safe)
+        int currentIndex = sequentialCounters.compute(sequenceKey, (key, currentCount) -> {
+            if (currentCount == null) {
+                return 0;
+            }
+            return (currentCount + 1) % statusCodes.length;
+        });
+
+        int statusCode = statusCodes[currentIndex];
+
+        // Create response body
+        Map<String, Object> response = new HashMap<>();
+        response.put("message", "Hello, " + name + "!");
+        response.put("current_status_code", statusCode);
+        response.put("sequence_position", currentIndex + 1);
+        response.put("total_codes_in_sequence", statusCodes.length);
+        response.put("full_sequence", statusCodes);
+        response.put("timestamp", System.currentTimeMillis());
+
+        return ResponseEntity.status(statusCode).body(response);
+    }
 }