Update ipmentor/tools.py

ipmentor/tools.py

@@ -10,6 +10,7 @@ import shutil
 import os
 import ipaddress
 import math
+import random
 from pathlib import Path
 from typing import List, Dict, Tuple
 
@@ -536,6 +537,176 @@ def generate_diagram(ip_network: str, hosts_list: str, use_svg: bool = False) ->
         }
         
         return json.dumps(result, indent=2)
-        
+
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+
+def generate_subnetting_exercise(num_subnets: int, use_vlsm: bool = False) -> str:
+    """
+    Generate a random subnetting exercise that is solvable.
+
+    Args:
+        num_subnets (int): Number of subnets required
+        use_vlsm (bool): If True, each subnet has different host requirements (VLSM)
+                        If False, equal division of subnets
+
+    Returns:
+        str: Exercise specification in JSON format
+    """
+    try:
+        if num_subnets < 1:
+            return json.dumps({"error": "Number of subnets must be at least 1"}, indent=2)
+
+        if num_subnets > 256:
+            return json.dumps({"error": "Number of subnets too large (max 256)"}, indent=2)
+
+        # RFC 1918 Private Address Spaces
+        private_ranges = [
+            ("10.0.0.0", "10.255.255.255"),
+            ("172.16.0.0", "172.31.255.255"),
+            ("192.168.0.0", "192.168.255.255")
+        ]
+
+        # Select a random private range
+        range_start, range_end = random.choice(private_ranges)
+        start_int = int(ipaddress.IPv4Address(range_start))
+        end_int = int(ipaddress.IPv4Address(range_end))
+
+        # Determine initial CIDR range
+        if use_vlsm:
+            # For VLSM: use networks between /16 (65536 hosts) and /24 (256 hosts)
+            # This provides good variety while keeping exercises manageable
+            initial_min_cidr = 16
+            initial_max_cidr = 24
+        else:
+            bits_needed = math.ceil(math.log2(num_subnets))
+            # For equal division: /16 minimum for variety
+            # /28 maximum (or less if more subnets needed) to avoid tiny networks
+            initial_min_cidr = 16
+            initial_max_cidr = min(28, 32 - bits_needed - 1)
+
+        if initial_min_cidr > initial_max_cidr:
+            return json.dumps({
+                "error": f"Cannot generate exercise: too many subnets requested ({num_subnets})"
+            }, indent=2)
+
+        # Start with random CIDR in the desired range
+        initial_cidr = random.randint(initial_min_cidr, initial_max_cidr)
+
+        # Intelligent retry: try increasing network sizes until we find a valid one
+        # Start from initial_cidr and go down to initial_min_cidr (larger networks)
+        for network_cidr in range(initial_cidr, initial_min_cidr - 1, -1):
+            # Generate random IP within the selected private range
+            block_size = 2 ** (32 - network_cidr)
+
+            # Calculate valid starting positions (must be aligned to block_size)
+            first_valid_block = ((start_int + block_size - 1) // block_size) * block_size
+            last_valid_block = (end_int // block_size) * block_size
+
+            if first_valid_block > last_valid_block:
+                network_int = first_valid_block if first_valid_block <= end_int else start_int
+            else:
+                num_blocks = (last_valid_block - first_valid_block) // block_size + 1
+                random_block = random.randint(0, num_blocks - 1)
+                network_int = first_valid_block + (random_block * block_size)
+
+            # Create the network
+            random_ip = str(ipaddress.IPv4Address(network_int))
+            selected_network = ipaddress.IPv4Network(f"{random_ip}/{network_cidr}", strict=False)
+            network_str = str(selected_network)
+
+            # Try to generate a valid exercise with this network
+            if use_vlsm:
+                # Try multiple host combinations for VLSM
+                # 50 attempts per network size balances success rate vs performance
+                max_host_attempts = 50
+
+                for attempt in range(max_host_attempts):
+                    total_addresses = 2 ** (32 - network_cidr)
+                    host_sizes = []
+                    remaining_space = total_addresses
+
+                    for i in range(num_subnets):
+                        if i == num_subnets - 1:
+                            # Last subnet: use up to half remaining space
+                            # Cap at 1000 hosts to keep exercises reasonable
+                            max_hosts = min(remaining_space // 2, 1000)
+                        else:
+                            # Distribute remaining space across remaining subnets
+                            # Cap at 1000 hosts to avoid overly large subnets
+                            max_hosts = min(remaining_space // (num_subnets - i + 1), 1000)
+
+                        if max_hosts < 2:
+                            max_hosts = 2
+
+                        # Use power law (0.7) to bias toward smaller, more realistic subnets
+                        # This creates more varied and interesting exercises
+                        host_count = random.randint(2, max(2, int(max_hosts ** 0.7)))
+                        host_sizes.append(host_count)
+
+                        bits_for_hosts = math.ceil(math.log2(host_count + 2))
+                        subnet_size = 2 ** bits_for_hosts
+                        remaining_space -= subnet_size
+
+                    # Validate with calculate_subnets
+                    hosts_list = ",".join(str(h) for h in host_sizes)
+                    validation = calculate_subnets(network_str, num_subnets, "vlsm", hosts_list)
+
+                    if "error" not in validation:
+                        # Success! Return the exercise
+                        return json.dumps({
+                            "network": str(selected_network.network_address),
+                            "mask": f"/{network_cidr}",
+                            "mask_decimal": str(selected_network.netmask),
+                            "num_subnets": num_subnets,
+                            "type": "VLSM",
+                            "hosts_per_subnet": host_sizes,
+                            "hosts_list": hosts_list
+                        }, indent=2)
+
+                # If we couldn't find valid hosts with random generation, try fallback
+                # Only try fallback for /18 or larger (at least 16384 addresses)
+                if network_cidr >= 18:
+                    # Use powers of 2 for host counts (2, 4, 8, 16, 32, 64...)
+                    # Max power of 6 = 64 hosts, keeps exercises simple
+                    max_power = min(6, 32 - network_cidr - 2)
+                    if max_power >= 1:
+                        host_sizes = [2 ** random.randint(1, max_power) for _ in range(num_subnets)]
+                        host_sizes.sort(reverse=True)  # Largest first for better VLSM allocation
+                        hosts_list = ",".join(str(h) for h in host_sizes)
+
+                        validation = calculate_subnets(network_str, num_subnets, "vlsm", hosts_list)
+                        if "error" not in validation:
+                            return json.dumps({
+                                "network": str(selected_network.network_address),
+                                "mask": f"/{network_cidr}",
+                                "mask_decimal": str(selected_network.netmask),
+                                "num_subnets": num_subnets,
+                                "type": "VLSM",
+                                "hosts_per_subnet": host_sizes,
+                                "hosts_list": hosts_list
+                            }, indent=2)
+
+            else:
+                # Equal division - validate directly
+                validation = calculate_subnets(network_str, num_subnets, "max_subnets", "")
+
+                if "error" not in validation:
+                    # Success! Return the exercise
+                    return json.dumps({
+                        "network": str(selected_network.network_address),
+                        "mask": f"/{network_cidr}",
+                        "mask_decimal": str(selected_network.netmask),
+                        "num_subnets": num_subnets,
+                        "type": "Equal Division",
+                        "hosts_per_subnet": validation["hosts_per_subnet"]
+                    }, indent=2)
+
+        # If we exhausted all network sizes, return error
+        return json.dumps({
+            "error": f"Could not generate valid exercise after trying multiple network sizes"
+        }, indent=2)
+
     except Exception as e:
         return json.dumps({"error": str(e)}, indent=2)