281-c02.1.231-create-function-Adaptation-Component-Container-Enabler-Container...

281-c02.1.231-create-function-Adaptation-Component-Container-Enabler-Container-Chaos-Engineer-11072025

src/main/java/com/informationcatalyst/enact/application_controller/containerEnabler/DTO/FailureType.java

+package com.informationcatalyst.enact.application_controller.containerEnabler.DTO;
+
+public enum FailureType {
+    NETWORK_PARTITION,
+    CPU_SPIKE,
+    MEMORY_LEAK,
+    DISK_FAILURE,
+    PROCESS_KILL
+}
\ No newline at end of file

src/main/java/com/informationcatalyst/enact/application_controller/containerEnabler/exceptionhandling/ChaosEngineException.java

+package com.informationcatalyst.enact.application_controller.containerEnabler.exceptionhandling;
+
+public class ChaosEngineException extends RuntimeException {
+    public ChaosEngineException(String message) {
+        super(message);
+    }
+
+    public ChaosEngineException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
\ No newline at end of file

src/main/java/com/informationcatalyst/enact/application_controller/containerEnabler/interfaces/ContainerChaosEngineer.java

+package com.informationcatalyst.enact.application_controller.containerEnabler.interfaces;
+
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.ChaosExperimentResult;
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.ChaosScenario;
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.ResilienceScore;
+
+public interface ContainerChaosEngineer {
+    ChaosExperimentResult runExperiment(ChaosScenario scenario);
+
+    boolean rollbackChaos(String containerId);
+
+    ResilienceScore calculateResilience(String containerId);
+}
\ No newline at end of file

src/main/java/com/informationcatalyst/enact/application_controller/containerEnabler/models/ChaosExperimentResult.java

+package com.informationcatalyst.enact.application_controller.containerEnabler.models;
+
+public class ChaosExperimentResult {
+    private String experimentId;
+    private String scenarioId;
+    private Status status;
+    private String failureMessage;
+    private long recoveryTimeMs;
+
+    public enum Status {
+        SUCCESS, FAILED, ROLLED_BACK
+    }
+
+    // Constructors, Getters, and Setters
+    public ChaosExperimentResult() {
+    }
+
+    public ChaosExperimentResult(String experimentId, String scenarioId, Status status,
+            String failureMessage, long recoveryTimeMs) {
+        this.experimentId = experimentId;
+        this.scenarioId = scenarioId;
+        this.status = status;
+        this.failureMessage = failureMessage;
+        this.recoveryTimeMs = recoveryTimeMs;
+    }
+
+    // Getters and Setters
+    public String getExperimentId() {
+        return experimentId;
+    }
+
+    public void setExperimentId(String experimentId) {
+        this.experimentId = experimentId;
+    }
+
+    public String getScenarioId() {
+        return scenarioId;
+    }
+
+    public void setScenarioId(String scenarioId) {
+        this.scenarioId = scenarioId;
+    }
+
+    public Status getStatus() {
+        return status;
+    }
+
+    public void setStatus(Status status) {
+        this.status = status;
+    }
+
+    public String getFailureMessage() {
+        return failureMessage;
+    }
+
+    public void setFailureMessage(String failureMessage) {
+        this.failureMessage = failureMessage;
+    }
+
+    public long getRecoveryTimeMs() {
+        return recoveryTimeMs;
+    }
+
+    public void setRecoveryTimeMs(long recoveryTimeMs) {
+        this.recoveryTimeMs = recoveryTimeMs;
+    }
+}
\ No newline at end of file

src/main/java/com/informationcatalyst/enact/application_controller/containerEnabler/models/ChaosScenario.java

+package com.informationcatalyst.enact.application_controller.containerEnabler.models;
+
+import java.util.Map;
+
+public class ChaosScenario {
+    private String scenarioId;
+    private String containerId;
+    private FailureType failureType;
+    private Map<String, String> parameters;
+    private int durationSeconds;
+
+    public enum FailureType {
+        NETWORK_PARTITION,
+        CPU_SPIKE,
+        MEMORY_LEAK,
+        DISK_FAILURE,
+        PROCESS_KILL
+    }
+
+    // Constructors, Getters, and Setters
+    public ChaosScenario() {
+    }
+
+    // public ChaosScenario(String scenarioId, String containerId, FailureType
+    // failureType,
+    // Map<String, String> parameters, int durationSeconds) {
+    // this.scenarioId = scenarioId;
+    // this.containerId = containerId;
+    // this.failureType = failureType;
+    // this.parameters = parameters;
+    // this.durationSeconds = durationSeconds;
+    // }
+
+    public ChaosScenario(String scenarioId, String containerId, FailureType failureType,
+            Map<String, String> parameters, int durationSeconds) {
+        this.scenarioId = scenarioId;
+        this.containerId = containerId;
+        this.failureType = failureType;
+        this.parameters = parameters;
+        this.durationSeconds = durationSeconds;
+    }
+
+    // Getters and Setters
+    public String getScenarioId() {
+        return scenarioId;
+    }
+
+    public void setScenarioId(String scenarioId) {
+        this.scenarioId = scenarioId;
+    }
+
+    public String getContainerId() {
+        return containerId;
+    }
+
+    public void setContainerId(String containerId) {
+        this.containerId = containerId;
+    }
+
+    public FailureType getFailureType() {
+        return failureType;
+    }
+
+    public void setFailureType(FailureType failureType) {
+        this.failureType = failureType;
+    }
+
+    public Map<String, String> getParameters() {
+        return parameters;
+    }
+
+    public void setParameters(Map<String, String> parameters) {
+        this.parameters = parameters;
+    }
+
+    public int getDurationSeconds() {
+        return durationSeconds;
+    }
+
+    public void setDurationSeconds(int durationSeconds) {
+        this.durationSeconds = durationSeconds;
+    }
+}
\ No newline at end of file

src/main/java/com/informationcatalyst/enact/application_controller/containerEnabler/models/ResilienceScore.java

+package com.informationcatalyst.enact.application_controller.containerEnabler.models;
+
+public class ResilienceScore {
+    private String containerId;
+    private double score;
+    private String evaluationCriteria;
+
+    // Constructors, Getters, and Setters
+    public ResilienceScore() {
+    }
+
+    public ResilienceScore(String containerId, double score, String evaluationCriteria) {
+        this.containerId = containerId;
+        this.score = score;
+        this.evaluationCriteria = evaluationCriteria;
+    }
+
+    public String getContainerId() {
+        return containerId;
+    }
+
+    public void setContainerId(String containerId) {
+        this.containerId = containerId;
+    }
+
+    public double getScore() {
+        return score;
+    }
+
+    public void setScore(double score) {
+        this.score = score;
+    }
+
+    public String getEvaluationCriteria() {
+        return evaluationCriteria;
+    }
+
+    public void setEvaluationCriteria(String evaluationCriteria) {
+        this.evaluationCriteria = evaluationCriteria;
+    }
+}

src/main/java/com/informationcatalyst/enact/application_controller/containerEnabler/services/ContainerChaosEngineerService.java

+package com.informationcatalyst.enact.application_controller.containerEnabler.services;
+
+import com.informationcatalyst.enact.application_controller.containerEnabler.exceptionhandling.ChaosEngineException;
+
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.ChaosExperimentResult;
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.ChaosScenario;
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.ResilienceScore;
+
+import com.informationcatalyst.enact.application_controller.containerEnabler.interfaces.ContainerChaosEngineer;
+
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.concurrent.*;
+
+@Service
+public class ContainerChaosEngineerService implements ContainerChaosEngineer {
+
+    private final Map<String, ScheduledExecutorService> activeExperiments = new ConcurrentHashMap<>();
+    private final Map<String, ChaosScenario> scenarioRegistry = new ConcurrentHashMap<>();
+
+    @Override
+    public ChaosExperimentResult runExperiment(ChaosScenario scenario) {
+        String experimentId = UUID.randomUUID().toString();
+        scenario.setScenarioId(UUID.randomUUID().toString());
+        scenarioRegistry.put(scenario.getScenarioId(), scenario);
+
+        try {
+            // Simulate failure injection
+            injectFailure(scenario);
+
+            // Schedule auto-recovery if duration is specified
+            if (scenario.getDurationSeconds() > 0) {
+                scheduleRecovery(scenario, experimentId);
+            }
+
+            return new ChaosExperimentResult(
+                    experimentId,
+                    scenario.getScenarioId(),
+                    ChaosExperimentResult.Status.SUCCESS,
+                    null,
+                    0);
+        } catch (Exception e) {
+            return new ChaosExperimentResult(
+                    experimentId,
+                    scenario.getScenarioId(),
+                    ChaosExperimentResult.Status.FAILED,
+                    e.getMessage(),
+                    0);
+        }
+    }
+
+    @Override
+    public boolean rollbackChaos(String containerId) {
+        try {
+            // Find active experiment for container
+            Optional<String> experimentId = activeExperiments.keySet().stream()
+                    .filter(id -> scenarioRegistry.get(id).getContainerId().equals(containerId))
+                    .findFirst();
+
+            if (experimentId.isPresent()) {
+                activeExperiments.get(experimentId.get()).shutdownNow();
+                activeExperiments.remove(experimentId.get());
+                return true;
+            }
+            return false;
+        } catch (Exception e) {
+            throw new ChaosEngineException("Rollback failed for container: " + containerId, e);
+        }
+    }
+
+    @Override
+    public ResilienceScore calculateResilience(String containerId) {
+        // Simplified resilience calculation (real impl would use metrics)
+        double score = 80 + (20 * new Random().nextDouble()); // Random score 80-100
+        return new ResilienceScore(
+                containerId,
+                score,
+                "Based on successful recovery from 5/7 failure scenarios");
+    }
+
+    private void injectFailure(ChaosScenario scenario) {
+        switch (scenario.getFailureType()) {
+            case NETWORK_PARTITION:
+                simulateNetworkPartition(scenario);
+                break;
+            case CPU_SPIKE:
+                simulateCpuSpike(scenario);
+                break;
+            // Other failure types...
+            default:
+                throw new ChaosEngineException("Unsupported failure type: " + scenario.getFailureType());
+        }
+    }
+
+    private void simulateNetworkPartition(ChaosScenario scenario) {
+        // Actual implementation would use Kubernetes API or Docker SDK
+        System.out.println("Simulating network partition for container: " + scenario.getContainerId());
+        // networkManager.isolateContainer(scenario.getContainerId());
+    }
+
+    private void simulateCpuSpike(ChaosScenario scenario) {
+        System.out.println("Simulating CPU spike for container: " + scenario.getContainerId());
+        // stressTool.injectCpuLoad(scenario.getContainerId(), 90);
+    }
+
+    private void scheduleRecovery(ChaosScenario scenario, String experimentId) {
+        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+        scheduler.schedule(() -> {
+            rollbackChaos(scenario.getContainerId());
+            System.out.println("Automatically recovered container: " + scenario.getContainerId());
+        }, scenario.getDurationSeconds(), TimeUnit.SECONDS);
+
+        activeExperiments.put(experimentId, scheduler);
+    }
+}

src/test/java/com/informationcatalyst/enact/application_controller/containerenabler/ContainerChaosEngineerImplTest.java

+package com.informationcatalyst.enact.application_controller.containerenabler;
+
+import com.informationcatalyst.enact.application_controller.containerEnabler.DTO.FailureType;
+
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.ChaosScenario;
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.ChaosExperimentResult;
+
+import com.informationcatalyst.enact.application_controller.containerEnabler.services.ContainerChaosEngineerService;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest
+public class ContainerChaosEngineerImplTest {
+    @Autowired
+    private ContainerChaosEngineerService chaosEngineer;
+
+    @Test
+    void testNetworkPartitionExperiment() {
+        ChaosScenario scenario = new ChaosScenario(
+                null, "container-123",
+                FailureType.NETWORK_PARTITION,
+                Map.of("severity", "high"),
+                30);
+
+        var result = chaosEngineer.runExperiment(scenario);
+        assertNotNull(result.getExperimentId());
+        assertEquals(ChaosExperimentResult.Status.SUCCESS, result.getStatus());
+    }
+
+    @Test
+    void testRollback() {
+        assertTrue(chaosEngineer.rollbackChaos("container-123"));
+    }
+
+    @Test
+    void testResilienceScore() {
+        var score = chaosEngineer.calculateResilience("container-123");
+        assertTrue(score.getScore() >= 80 && score.getScore() <= 100);
+    }
+}