add networking stack test

Author: j143

.github/workflows/test.yml

@@ -42,7 +42,7 @@ jobs:
     - name: Build project with error handling
       run: |
         echo "==== Building Project ===="
-        if ! go build -o basic-docker main.go image.go; then
+        if ! go build -o basic-docker main.go network.go image.go; then
             echo "Error: Build failed. Please check the errors above." >&2
             exit 1
         fi

adr-002-networking-stack.md

@@ -166,6 +166,115 @@ func loadNetworks() {
 - `network-attach <network-id> <container-id>`: Attach a container to a network.
 - `network-detach <network-id> <container-id>`: Detach a container from a network.
 
+## New Functionality: Ping Between Containers
+
+### Context
+To verify connectivity between containers in the same network, a `Ping` function was introduced. This function simulates a ping operation by checking if both containers are attached to the same network and outputs a success message if they are.
+
+### Implementation
+The `Ping` function was added to the networking stack with the following signature:
+
+```go
+func Ping(networkID, sourceContainerID, targetContainerID string) error {
+	for _, network := range networks {
+		if network.ID == networkID {
+			sourceIP, sourceExists := network.Containers[sourceContainerID]
+			targetIP, targetExists := network.Containers[targetContainerID]
+
+			if !sourceExists || !targetExists {
+				return errors.New("one or both containers are not in the network")
+			}
+
+			fmt.Printf("Pinging from %s to %s: Success\n", sourceIP, targetIP)
+			return nil
+		}
+	}
+	return errors.New("network not found")
+}
+```
+
+### Test Scenario
+A test case, `TestPing`, was added to validate this functionality. The test performs the following steps:
+1. Creates a network.
+2. Attaches two containers to the network.
+3. Verifies that the `Ping` function confirms connectivity between the two containers.
+
+#### Test Code
+```go
+func TestPing(t *testing.T) {
+	// Setup: Create a network and attach two containers
+	networkName := "test-network"
+	CreateNetwork(networkName)
+	networkID := networks[0].ID
+
+	container1 := "container-1"
+	container2 := "container-2"
+
+	err := AttachContainerToNetwork(networkID, container1)
+	if err != nil {
+		t.Fatalf("Failed to attach container 1: %v", err)
+	}
+
+	err = AttachContainerToNetwork(networkID, container2)
+	if err != nil {
+		t.Fatalf("Failed to attach container 2: %v", err)
+	}
+
+	err = Ping(networkID, container1, container2)
+	if err != nil {
+		t.Errorf("Ping failed: %v", err)
+	}
+}
+```
+
+### Test Output
+
+The `TestPing` test case was executed successfully, confirming the functionality of the `Ping` feature. Below is the textual output from the test:
+
+```
+Network capsule test-network created with ID net-1
+Container container-1 attached to network net-1 with IP 192.168.1.2
+Container container-2 attached to network net-1 with IP 192.168.1.3
+Pinging from 192.168.1.2 to 192.168.1.3: Success
+```
+
+This output demonstrates that:
+1. A network was created successfully.
+2. Containers were attached to the network with unique IP addresses.
+3. The `Ping` function verified connectivity between the containers.
+
+## Test Overview
+
+### Purpose
+To ensure that containers within the same network can communicate effectively.
+
+### Approach
+A basic test was implemented to:
+1. Create a network.
+2. Attach two containers to the network.
+3. Verify connectivity between the containers using a simulated `Ping` function.
+
+### Diagram
+```mermaid
+graph TD
+    A[Create Network] --> B[Attach Container 1]
+    A --> C[Attach Container 2]
+    B --> D[Ping from Container 1 to Container 2]
+    C --> D
+    D --> E[Verify Connectivity]
+```
+
+### Consequences
+1. **Positive**:
+   - Provides a simple way to verify container connectivity within a network.
+   - Enhances the usability of the networking stack.
+
+2. **Negative**:
+   - Limited to basic connectivity checks; does not simulate real network traffic.
+
+### Status
+Implemented and tested.
+
 ## Design Diagram
 ```mermaid
 graph TD

main_test.go

@@ -142,6 +142,36 @@ func TestCapsuleManager(t *testing.T) {
 	}
 }
 
+// TestPing verifies that containers in the same network can communicate
+func TestPing(t *testing.T) {
+	// Cleanup: Ensure no existing networks or containers interfere with the test
+	networks = []Network{}
+	saveNetworks()
+
+	// Setup: Create a network and attach two containers
+	networkName := "test-network"
+	CreateNetwork(networkName)
+	networkID := networks[0].ID
+
+	container1 := "container-1"
+	container2 := "container-2"
+
+	err := AttachContainerToNetwork(networkID, container1)
+	if err != nil {
+		t.Fatalf("Failed to attach container 1: %v", err)
+	}
+
+	err = AttachContainerToNetwork(networkID, container2)
+	if err != nil {
+		t.Fatalf("Failed to attach container 2: %v", err)
+	}
+
+	err = Ping(networkID, container1, container2)
+	if err != nil {
+		t.Errorf("Ping failed: %v", err)
+	}
+}
+
 // BenchmarkCapsuleAccess benchmarks the access time for Resource Capsules.
 func BenchmarkCapsuleAccess(b *testing.B) {
 	cm := NewCapsuleManager()

network.go

@@ -10,10 +10,11 @@ import (
 
 const networksFile = "networks.json"
 
+// Updated Network struct to include IP addresses for containers
 type Network struct {
 	Name       string
 	ID         string
-	Containers []string // List of container IDs attached to this network
+	Containers map[string]string // Map of container IDs to their IP addresses
 }
 
 var networks = []Network{}
@@ -57,7 +58,7 @@ func saveNetworks() {
 // CreateNetwork creates a new network capsule
 func CreateNetwork(name string) {
 	id := fmt.Sprintf("net-%d", len(networks)+1)
-	network := Network{Name: name, ID: id, Containers: []string{}}
+	network := Network{Name: name, ID: id, Containers: make(map[string]string)}
 	networks = append(networks, network)
 
 	// Register the network as a resource capsule
@@ -87,19 +88,20 @@ func DeleteNetwork(id string) {
 	fmt.Printf("Network with ID %s not found\n", id)
 }
 
-// AttachContainerToNetwork attaches a container to a network capsule
+// Updated AttachContainerToNetwork to assign IP addresses
 func AttachContainerToNetwork(networkID, containerID string) error {
 	for i, network := range networks {
 		if network.ID == networkID {
 			// Check if the container is already attached
-			for _, c := range network.Containers {
-				if c == containerID {
-					return errors.New("container is already attached to the network")
-				}
+			if _, exists := network.Containers[containerID]; exists {
+				return errors.New("container is already attached to the network")
 			}
-			// Attach the container
-			networks[i].Containers = append(network.Containers, containerID)
-			fmt.Printf("Container %s attached to network %s\n", containerID, networkID)
+
+			// Assign an IP address to the container
+			ipAddress := fmt.Sprintf("192.168.%d.%d", i+1, len(network.Containers)+2)
+			networks[i].Containers[containerID] = ipAddress
+			saveNetworks()
+			fmt.Printf("Container %s attached to network %s with IP %s\n", containerID, networkID, ipAddress)
 			return nil
 		}
 	}
@@ -111,19 +113,36 @@ func DetachContainerFromNetwork(networkID, containerID string) error {
 	for i, network := range networks {
 		if network.ID == networkID {
 			// Find and remove the container
-			for j, c := range network.Containers {
-				if c == containerID {
-					networks[i].Containers = append(network.Containers[:j], network.Containers[j+1:]...)
-					fmt.Printf("Container %s detached from network %s\n", containerID, networkID)
-					return nil
-				}
+			if _, exists := network.Containers[containerID]; exists {
+				delete(networks[i].Containers, containerID)
+				saveNetworks()
+				fmt.Printf("Container %s detached from network %s\n", containerID, networkID)
+				return nil
 			}
 			return errors.New("container not found in the network")
 		}
 	}
 	return errors.New("network not found")
 }
 
+// New Ping function to test connectivity between containers
+func Ping(networkID, sourceContainerID, targetContainerID string) error {
+	for _, network := range networks {
+		if network.ID == networkID {
+			sourceIP, sourceExists := network.Containers[sourceContainerID]
+			targetIP, targetExists := network.Containers[targetContainerID]
+
+			if !sourceExists || !targetExists {
+				return errors.New("one or both containers are not in the network")
+			}
+
+			fmt.Printf("Pinging from %s to %s: Success\n", sourceIP, targetIP)
+			return nil
+		}
+	}
+	return errors.New("network not found")
+}
+
 // Call loadNetworks during initialization
 func init() {
 	loadNetworks()