280-c02.1.230-create-function-Adaptation-Component-Container-Enabler-Edge-Offload-Manager-11072025

src/main/java/com/informationcatalyst/enact/application_controller/config/DataInitializer.java

@@ -10,9 +10,11 @@ import com.informationcatalyst.enact.application_controller.resourceAllocatorReq
 import com.informationcatalyst.enact.application_controller.relocationRequester.models.EthicalPrinciple;
 import com.informationcatalyst.enact.application_controller.relocationRequester.repositories.ContainerMetadataRepository;
 import com.informationcatalyst.enact.application_controller.relocationRequester.repositories.EthicalPrincipleRepository;
-
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.EdgeNode;
 import com.informationcatalyst.enact.application_controller.relocationRequester.models.ContainerMetadata;
 
+import com.informationcatalyst.enact.application_controller.containerEnabler.services.EdgeOffloadManagerService;
+
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -164,4 +166,18 @@ public class DataInitializer {
                         }
                 };
         }
+
+        @Bean
+        CommandLineRunner init(EdgeOffloadManagerService manager) {
+                return args -> {
+                        // Test evaluation
+                        EdgeNode testNode = new EdgeNode("edge-1", "us-west", 20, 15.2);
+                        System.out.println("Test Offload Decision: " +
+                                        manager.evaluateOffload("container-123", testNode));
+
+                        // Test comparison
+                        System.out.println("Latency Comparison: " +
+                                        manager.compareEdgeVsCloud("container-123"));
+                };
+        }
 }

src/main/java/com/informationcatalyst/enact/application_controller/containerEnabler/controllers/EdgeOffloadManagerController.java

+package com.informationcatalyst.enact.application_controller.containerEnabler.controllers;
+
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.EdgeNode;
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.LatencyComparison;
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.OffloadDecision;
+
+import com.informationcatalyst.enact.application_controller.containerEnabler.services.EdgeOffloadManagerService;
+
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/offload")
+public class EdgeOffloadManagerController {
+    private EdgeOffloadManagerService offloadManager;
+
+    @PostMapping("/evaluate")
+    public OffloadDecision evaluateOffload(
+            @RequestParam String containerId,
+            @RequestBody EdgeNode node) {
+        return offloadManager.evaluateOffload(containerId, node);
+    }
+
+    @PostMapping("/migrate")
+    public boolean migrateContainer(
+            @RequestParam String containerId,
+            @RequestBody EdgeNode targetNode) {
+        return offloadManager.migrateToEdge(containerId, targetNode);
+    }
+
+    @GetMapping("/compare")
+    public LatencyComparison compareLatency(@RequestParam String containerId) {
+        return offloadManager.compareEdgeVsCloud(containerId);
+    }
+}

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

+package com.informationcatalyst.enact.application_controller.containerEnabler.models;
+
+import lombok.Data;
+
+@Data
+public class EdgeNode {
+    private String nodeId;
+    private String location;
+    private int availableResources; // Simplified resource units
+    private double networkLatency; // ms
+
+    // Default constructor
+    public EdgeNode() {
+    }
+
+    // All-arguments constructor
+    public EdgeNode(String nodeId, String location, int availableResources, double networkLatency) {
+        this.nodeId = nodeId;
+        this.location = location;
+        this.availableResources = availableResources;
+        this.networkLatency = networkLatency;
+    }
+
+    // Getters
+    public String getNodeId() {
+        return nodeId;
+    }
+
+    public String getLocation() {
+        return location;
+    }
+
+    public int getAvailableResources() {
+        return availableResources;
+    }
+
+    public double getNetworkLatency() {
+        return networkLatency;
+    }
+
+    // Setters
+    public void setNodeId(String nodeId) {
+        this.nodeId = nodeId;
+    }
+
+    public void setLocation(String location) {
+        this.location = location;
+    }
+
+    public void setAvailableResources(int availableResources) {
+        this.availableResources = availableResources;
+    }
+
+    public void setNetworkLatency(double networkLatency) {
+        this.networkLatency = networkLatency;
+    }
+}

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

+package com.informationcatalyst.enact.application_controller.containerEnabler.models;
+
+import lombok.Data;
+
+@Data
+public class LatencyComparison {
+    private double cloudLatency;
+    private double edgeLatency;
+    private double improvementPercentage;
+
+    // Default constructor
+    public LatencyComparison() {
+    }
+
+    // All-arguments constructor
+    public LatencyComparison(double cloudLatency, double edgeLatency, double improvementPercentage) {
+        this.cloudLatency = cloudLatency;
+        this.edgeLatency = edgeLatency;
+        this.improvementPercentage = improvementPercentage;
+    }
+
+    // Getters
+    public double getCloudLatency() {
+        return cloudLatency;
+    }
+
+    public double getEdgeLatency() {
+        return edgeLatency;
+    }
+
+    public double getImprovementPercentage() {
+        return improvementPercentage;
+    }
+
+    // Setters
+    public void setCloudLatency(double cloudLatency) {
+        this.cloudLatency = cloudLatency;
+    }
+
+    public void setEdgeLatency(double edgeLatency) {
+        this.edgeLatency = edgeLatency;
+    }
+
+    public void setImprovementPercentage(double improvementPercentage) {
+        this.improvementPercentage = improvementPercentage;
+    }
+}

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

+package com.informationcatalyst.enact.application_controller.containerEnabler.models;
+
+import lombok.Data;
+
+@Data
+public class OffloadDecision {
+    private boolean shouldOffload;
+    private String reason;
+    private double expectedLatencyImprovement; // %
+
+    // Default constructor
+    public OffloadDecision() {
+    }
+
+    // All-arguments constructor
+    public OffloadDecision(boolean shouldOffload, String reason, double expectedLatencyImprovement) {
+        this.shouldOffload = shouldOffload;
+        this.reason = reason;
+        this.expectedLatencyImprovement = expectedLatencyImprovement;
+    }
+
+    // Getters
+    public boolean isShouldOffload() {
+        return shouldOffload;
+    }
+
+    public String getReason() {
+        return reason;
+    }
+
+    public double getExpectedLatencyImprovement() {
+        return expectedLatencyImprovement;
+    }
+
+    // Setters
+    public void setShouldOffload(boolean shouldOffload) {
+        this.shouldOffload = shouldOffload;
+    }
+
+    public void setReason(String reason) {
+        this.reason = reason;
+    }
+
+    public void setExpectedLatencyImprovement(double expectedLatencyImprovement) {
+        this.expectedLatencyImprovement = expectedLatencyImprovement;
+    }
+}
\ No newline at end of file

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

+package com.informationcatalyst.enact.application_controller.containerEnabler.services;
+
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.EdgeNode;
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.LatencyComparison;
+import com.informationcatalyst.enact.application_controller.containerEnabler.models.OffloadDecision;
+
+import org.springframework.stereotype.Service;
+import org.springframework.beans.factory.annotation.Value;
+
+@Service
+public class EdgeOffloadManagerService {
+    @Value("${offload.latency.threshold:50.0}")
+    private double latencyThreshold;
+
+    @Value("${offload.resource.threshold:10}")
+    private int resourceThreshold;
+
+    public OffloadDecision evaluateOffload(String containerId, EdgeNode node) {
+        // Simplified decision logic
+        double latencyImprovement = estimateLatencyImprovement(containerId, node);
+        boolean shouldOffload = latencyImprovement > latencyThreshold &&
+                node.getAvailableResources() > resourceThreshold;
+
+        String reason = shouldOffload ? "Meets latency improvement and resource requirements"
+                : "Doesn't meet offload criteria";
+
+        return new OffloadDecision(shouldOffload, reason, latencyImprovement);
+    }
+
+    public boolean migrateToEdge(String containerId, EdgeNode target) {
+        // Simulate migration process
+        try {
+            // In real implementation: Container orchestration API calls
+            Thread.sleep(500); // Simulate migration delay
+            return true;
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return false;
+        }
+    }
+
+    public LatencyComparison compareEdgeVsCloud(String containerId) {
+        // Simulated latency data (would come from monitoring system)
+        double cloudLatency = 120.0 + Math.random() * 50;
+        double edgeLatency = 35.0 + Math.random() * 20;
+        double improvement = ((cloudLatency - edgeLatency) / cloudLatency) * 100;
+
+        return new LatencyComparison(
+                Math.round(cloudLatency * 100.0) / 100.0,
+                Math.round(edgeLatency * 100.0) / 100.0,
+                Math.round(improvement * 100.0) / 100.0);
+    }
+
+    private double estimateLatencyImprovement(String containerId, EdgeNode node) {
+        // Simplified estimation (real implementation would use ML model)
+        return 70.0 + (node.getNetworkLatency() * 0.2) - (node.getAvailableResources() * 0.5);
+    }
+}