improved logging and validation

Author: networmix

examples/small_test_clos.yml

@@ -56,6 +56,7 @@ components:
     core|core: 800G-ZR+
     leaf|leaf: 800G-ZR+
     core|leaf: 800G-ZR+
+    leaf|dc: 800G-ZR+
     leaf|spine: 800G-DR4
     spine|leaf: 1600G-2xDR4
 
@@ -74,8 +75,8 @@ visualization:
 traffic:
   enabled: true
   model: gravity
-  gbps_per_mw: 250.0
-  mw_per_dc_region: 500.0
+  gbps_per_mw: 400.0
+  mw_per_dc_region: 400.0
   priority_ratios:
     0: 1
   matrix_name: baseline_traffic_matrix

tests/test_validation.py

@@ -138,3 +138,52 @@ def test_validate_scenario_yaml_isolated_nodes_flagged():
         yaml_text, integrated_graph_path=None, run_ngraph=False
     )
     assert any("appears isolated" in s for s in issues)
+
+
+def test_dc_capacity_vs_demand_validation():
+    # Build a simple scenario with one DC and a DC->PoP adjacency that has limited capacity
+    data = _minimal_scenario()
+    # Add one dc_to_pop adjacency with target_capacity 1000
+    data["network"]["adjacency"] = [
+        {
+            "source": "metro1/dc1",
+            "target": "metro1/pop1",
+            "pattern": "one_to_one",
+            "link_params": {
+                "capacity": 1000.0,
+                "cost": 1,
+                "attrs": {
+                    "link_type": "dc_to_pop",
+                    "source_metro": "Denver",
+                    "target_metro": "Denver",
+                    "target_capacity": 1000.0,
+                },
+            },
+        }
+    ]
+    # Traffic matrix with a single class that demands 1200 out of the DC and 800 into the DC
+    data["traffic_matrix_set"] = {
+        "tm": [
+            {
+                "source_path": "^metro1/dc1/.*",
+                "sink_path": "^metro1/dc1/.*",
+                "mode": "pairwise",
+                "priority": 0,
+                "demand": 1200.0,
+            },
+            {
+                "source_path": "^metro2/dc1/.*",
+                "sink_path": "^metro1/dc1/.*",
+                "mode": "pairwise",
+                "priority": 0,
+                "demand": 800.0,
+            },
+        ]
+    }
+    issues = validate_scenario_dict(data)
+    # Egress 1200 > capacity 1000 => violation
+    assert any(
+        "egress demand" in s and "exceeds adjacency capacity" in s for s in issues
+    )
+    # Ingress 800 <= capacity 1000 => no ingress violation for metro1/dc1
+    assert not any("ingress demand 800.0" in s for s in issues)

topogen/components_lib.py

@@ -19,12 +19,12 @@
     # Router Chassis Components
     "CoreRouter": {
         "component_type": "chassis",
-        "description": "16 slot, 36x800G ports per slot, 576 ports total",
+        "description": "16 slot, 32x800G ports per slot, 512 ports total",
         "capex": 650_000.0,
-        "power_watts": 23_000.0,  # without optics, typical consumption
-        "power_watts_max": 30_000.0,  # without optics, max consumption
-        "capacity": 460_800.0,  # Gbps
-        "ports": 576,
+        "power_watts": 22_000.0,  # without optics, typical consumption
+        "power_watts_max": 29_000.0,  # without optics, max consumption
+        "capacity": 409_600.0,  # Gbps
+        "ports": 512,
         "attrs": {"role": "core"},
     },
     "LeafRouter": {

topogen/scenario/graph_pipeline.py

@@ -152,6 +152,7 @@ def arc_ceil(
                 key=f"{adj_id}:{i}-{j}",
                 link_type="intra_metro",
                 base_capacity=base_capacity,
+                target_capacity=base_capacity,
                 cost=cost,
                 adjacency_id=adj_id,
                 distance_km=cost,
@@ -275,6 +276,7 @@ def arc_ceil(
                     key=f"{adj_id}:{dc}-{p}",
                     link_type="dc_to_pop",
                     base_capacity=base_capacity,
+                    target_capacity=base_capacity,
                     cost=cost_arc,
                     adjacency_id=adj_id,
                     distance_km=cost_arc,
@@ -345,6 +347,7 @@ def _add_inter_metro_edges(
                     key=f"{adj_id}:{p}-{q}",
                     link_type="inter_metro_corridor",
                     base_capacity=base_capacity,
+                    target_capacity=base_capacity,
                     cost=cost,
                     adjacency_id=adj_id,
                     distance_km=cost,
@@ -822,6 +825,19 @@ def tm_based_size_capacities(
     h_factor = float(getattr(sizing_cfg, "headroom", 1.3))
     respect_min = bool(getattr(sizing_cfg, "respect_min_base_capacity", True))
 
+    # Snapshot pre-adjustment aggregated capacities per directed metro corridor
+    prev_corridor_caps: dict[tuple[str, str], float] = {}
+    for _u, _v, _k, data in G.edges(keys=True, data=True):
+        if str(data.get("link_type")) != "inter_metro_corridor":
+            continue
+        src_name = data.get("source_metro")
+        tgt_name = data.get("target_metro")
+        if not isinstance(src_name, str) or not isinstance(tgt_name, str):
+            continue
+        prev_cap = float(data.get("base_capacity", data.get("capacity", 0.0)))
+        key = (src_name, tgt_name)
+        prev_corridor_caps[key] = prev_corridor_caps.get(key, 0.0) + prev_cap
+
     # Apply sized capacities to inter-metro edges in G
     for (u_g, v_g, k_g), L in edge_loads.items():
         try:
@@ -840,6 +856,55 @@ def tm_based_size_capacities(
         prev = float(data.get("base_capacity", 0.0))
         new_base = max(prev, sized) if respect_min else sized
         G.edges[u_g, v_g, k_g]["base_capacity"] = new_base
+        # Keep target_capacity aligned with total intended capacity for the adjacency
+        G.edges[u_g, v_g, k_g]["target_capacity"] = new_base
+
+    # Aggregate post-adjustment capacities per directed metro corridor
+    post_corridor_caps: dict[tuple[str, str], float] = {}
+    for _u2, _v2, _k2, data in G.edges(keys=True, data=True):
+        if str(data.get("link_type")) != "inter_metro_corridor":
+            continue
+        src_name = data.get("source_metro")
+        tgt_name = data.get("target_metro")
+        if not isinstance(src_name, str) or not isinstance(tgt_name, str):
+            continue
+        cap = float(data.get("base_capacity", data.get("capacity", 0.0)))
+        key = (src_name, tgt_name)
+        post_corridor_caps[key] = post_corridor_caps.get(key, 0.0) + cap
+
+    # Log corridor capacity deltas (per directed pair)
+    if post_corridor_caps:
+        try:
+            total_before = sum(
+                prev_corridor_caps.get(k, 0.0) for k in post_corridor_caps
+            )
+            total_after = sum(post_corridor_caps.values())
+            logger.info(
+                "TM sizing: corridor capacity totals (Gbps) before=%s after=%s delta=%s",
+                f"{total_before:,.1f}",
+                f"{total_after:,.1f}",
+                f"{(total_after - total_before):,.1f}",
+            )
+            # Only emit lines for pairs that changed
+            for pair in sorted(post_corridor_caps):
+                before = float(prev_corridor_caps.get(pair, 0.0))
+                after = float(post_corridor_caps[pair])
+                if abs(after - before) <= 0.0:
+                    continue
+                factor = (after / before) if before > 0.0 else float("inf")
+                src, dst = pair
+                logger.info(
+                    "TM sizing: %s -> %s corridor capacity %s -> %s (delta=%s, x%s)",
+                    src,
+                    dst,
+                    f"{before:,.1f}",
+                    f"{after:,.1f}",
+                    f"{(after - before):,.1f}",
+                    "inf" if not (factor < float("inf")) else f"{factor:.2f}",
+                )
+        except Exception:
+            # Logging must not affect sizing; swallow any formatting errors
+            pass
 
     # Compute PoP egress based on sized corridor capacities
     pop_egress: dict[str, float] = {}
@@ -881,6 +946,7 @@ def tm_based_size_capacities(
         prev = float(data.get("base_capacity", 0.0))
         new_base = max(prev, sized) if respect_min else sized
         G.edges[u_g, v_g, k_g]["base_capacity"] = new_base
+        G.edges[u_g, v_g, k_g]["target_capacity"] = new_base
 
     # Derive PoP<->PoP (intra-metro) base capacities
     for u_g, v_g, k_g, data in G.edges(keys=True, data=True):
@@ -895,6 +961,7 @@ def tm_based_size_capacities(
         prev = float(data.get("base_capacity", 0.0))
         new_base = max(prev, sized) if respect_min else sized
         G.edges[u_g, v_g, k_g]["base_capacity"] = new_base
+        G.edges[u_g, v_g, k_g]["target_capacity"] = new_base
 
     logger.info(
         "TM sizing: applied capacities (Q=%s Gb/s, h=%s, alpha=%s, beta=%s)",
@@ -990,6 +1057,12 @@ def to_network_sections(
             "source_metro": data.get("source_metro"),
             "target_metro": data.get("target_metro"),
         }
+        # Emit total expected capacity for the adjacency (pre per-link split)
+        try:
+            tcap = float(data.get("target_capacity", data.get("base_capacity", 0.0)))
+        except Exception:
+            tcap = float(data.get("base_capacity", 0.0))
+        attrs["target_capacity"] = tcap
         # Tag this adjacency with a stable site-edge key and optional adjacency id
         attrs["site_edge"] = f"{u}|{v}|{k}"
         if "adjacency_id" in data: