906 lines
33 KiB
Python
906 lines
33 KiB
Python
"""
|
|
Datacenter Generator for Infrahub
|
|
==================================
|
|
|
|
This generator creates a complete datacenter fabric topology including:
|
|
- Spine switches (Layer 3 core)
|
|
- Leaf switches (Aggregation with VXLAN)
|
|
- Border leaf switches (DCI gateway capable)
|
|
- Access switches (Rack ToR)
|
|
- MLAG domains for leaf and border pairs
|
|
- IP prefixes and addresses
|
|
- BGP configuration
|
|
- Interfaces with proper connectivity
|
|
|
|
Architecture:
|
|
- Spine-Leaf topology with MLAG leaf pairs
|
|
- eBGP underlay (spine ASN vs leaf pair ASNs)
|
|
- VXLAN/EVPN overlay on leafs
|
|
- Optional DCI connectivity via border leafs (eth12 shutdown by default)
|
|
"""
|
|
|
|
import math
|
|
from typing import Any, Dict, List
|
|
|
|
from infrahub_sdk.generator import InfrahubGenerator
|
|
|
|
|
|
class DatacenterGenerator(InfrahubGenerator):
|
|
"""
|
|
Generates complete datacenter fabric topology from InfraDatacenter object.
|
|
"""
|
|
|
|
async def generate(self, data: dict) -> None:
|
|
"""
|
|
Main generator entry point.
|
|
|
|
Args:
|
|
data: GraphQL query response with datacenter details
|
|
"""
|
|
# Get datacenter object from query response
|
|
dc = self.nodes[0]
|
|
|
|
self.log.info(f"🚀 Starting datacenter generation for: {dc.name.value}")
|
|
self.log.info(f" DC ID: {dc.dc_id.value}")
|
|
self.log.info(f" Number of bays: {dc.number_of_bays.value}")
|
|
self.log.info(f" Spine count: {dc.spine_count.value}")
|
|
|
|
# Step 1: Calculate derived values
|
|
self.log.info("📊 Calculating topology parameters...")
|
|
topology = self._calculate_topology(dc)
|
|
|
|
# Step 2: Create IP prefixes
|
|
self.log.info("🌐 Creating IP prefixes...")
|
|
await self._create_ip_prefixes(dc, topology)
|
|
|
|
# Step 3: Create spine switches
|
|
self.log.info("🔴 Creating spine switches...")
|
|
spines = await self._create_spines(dc, topology)
|
|
|
|
# Step 4: Create leaf switches and MLAG pairs
|
|
self.log.info("🔵 Creating leaf switches and MLAG pairs...")
|
|
leaf_pairs = await self._create_leaf_pairs(dc, topology)
|
|
|
|
# Step 5: Create border leaf switches (if enabled)
|
|
border_pair = None
|
|
if dc.has_border_leafs.value:
|
|
self.log.info("🟣 Creating border leaf switches...")
|
|
border_pair = await self._create_border_pair(dc, topology)
|
|
|
|
# Step 6: Create access switches
|
|
self.log.info("🟡 Creating access switches...")
|
|
access_switches = await self._create_access_switches(dc, topology, leaf_pairs)
|
|
|
|
# Step 7: Create spine-to-leaf interfaces and BGP sessions
|
|
self.log.info("🔗 Creating spine-to-leaf connectivity...")
|
|
await self._create_spine_leaf_connectivity(
|
|
dc, spines, leaf_pairs, border_pair, topology
|
|
)
|
|
|
|
# Step 8: Create leaf-to-access connectivity
|
|
self.log.info("🔗 Creating leaf-to-access connectivity...")
|
|
await self._create_leaf_access_connectivity(
|
|
dc, leaf_pairs, access_switches, topology
|
|
)
|
|
|
|
# Step 9: Update datacenter computed attributes
|
|
self.log.info("✍️ Updating datacenter computed attributes...")
|
|
await self._update_datacenter_computed_fields(dc, topology)
|
|
|
|
# Summary
|
|
total_devices = (
|
|
len(spines)
|
|
+ sum(len(pair["devices"]) for pair in leaf_pairs)
|
|
+ len(access_switches)
|
|
)
|
|
if border_pair:
|
|
total_devices += len(border_pair["devices"])
|
|
|
|
self.log.info("=" * 60)
|
|
self.log.info(f"✅ Datacenter '{dc.name.value}' generation complete!")
|
|
self.log.info(f" Total devices: {total_devices}")
|
|
self.log.info(f" - Spines: {len(spines)}")
|
|
self.log.info(
|
|
f" - Leaf pairs: {len(leaf_pairs)} ({sum(len(pair['devices']) for pair in leaf_pairs)} devices)"
|
|
)
|
|
if border_pair:
|
|
self.log.info(f" - Border leafs: {len(border_pair['devices'])}")
|
|
self.log.info(f" - Access switches: {len(access_switches)}")
|
|
self.log.info("=" * 60)
|
|
|
|
def _calculate_topology(self, dc) -> Dict[str, Any]:
|
|
"""
|
|
Calculate topology parameters based on datacenter configuration.
|
|
|
|
Returns:
|
|
Dictionary with calculated values:
|
|
- leaf_pair_count: Number of MLAG leaf pairs needed
|
|
- total_leaf_count: Total number of leaf switches
|
|
- total_access_count: Total number of access switches
|
|
- spine_asn: ASN for spine switches
|
|
- base_leaf_asn: Starting ASN for leaf pairs
|
|
"""
|
|
dc_id = dc.dc_id.value
|
|
number_of_bays = dc.number_of_bays.value
|
|
bgp_base_asn = dc.bgp_base_asn.value
|
|
|
|
# Calculate leaf pairs: ceil(bays / 2)
|
|
# Each pair serves 2 bays
|
|
leaf_pair_count = math.ceil(number_of_bays / 2)
|
|
total_leaf_count = leaf_pair_count * 2
|
|
total_access_count = number_of_bays
|
|
|
|
# Calculate ASNs
|
|
# Spine ASN: base + (dc_id * 100)
|
|
# Example: DC1 → 65000 + 100 = 65100
|
|
spine_asn = (
|
|
dc.spine_asn.value if dc.spine_asn.value else bgp_base_asn + (dc_id * 100)
|
|
)
|
|
|
|
# Leaf pair ASNs: spine_asn + pair_number
|
|
# Example: DC1 Pair 1 → 65100 + 1 = 65101
|
|
base_leaf_asn = spine_asn + 1
|
|
|
|
# Border leaf ASN: base_leaf_asn + leaf_pair_count
|
|
border_asn = base_leaf_asn + leaf_pair_count
|
|
|
|
topology = {
|
|
"leaf_pair_count": leaf_pair_count,
|
|
"total_leaf_count": total_leaf_count,
|
|
"total_access_count": total_access_count,
|
|
"spine_asn": spine_asn,
|
|
"base_leaf_asn": base_leaf_asn,
|
|
"border_asn": border_asn,
|
|
}
|
|
|
|
self.log.debug(f"Topology calculated: {topology}")
|
|
return topology
|
|
|
|
async def _create_ip_prefixes(self, dc, topology: Dict[str, Any]) -> None:
|
|
"""
|
|
Create IP prefixes for the datacenter.
|
|
|
|
Prefix allocation scheme:
|
|
- 10.{dc_id}.0.0/24 - Loopback0 (router IDs)
|
|
- 10.{dc_id}.1.0/24 - Loopback1 (VTEP addresses)
|
|
- 10.{dc_id}.10.0/24 - Spine-Leaf P2P links
|
|
- 10.{dc_id}.20.0/24 - Leaf-Access P2P links
|
|
- 10.{dc_id}.255.0/24 - MLAG peer links
|
|
- 10.255.0.0/24 - Management IPs
|
|
"""
|
|
dc_id = dc.dc_id.value
|
|
dc_name = dc.name.value
|
|
|
|
# TODO: Get or create namespace
|
|
# For now, assume default namespace
|
|
|
|
prefixes = [
|
|
{
|
|
"prefix": f"10.{dc_id}.0.0/24",
|
|
"description": f"Loopback0 addresses for {dc_name}",
|
|
"prefix_type": "loopback",
|
|
},
|
|
{
|
|
"prefix": f"10.{dc_id}.1.0/24",
|
|
"description": f"VTEP Loopback1 addresses for {dc_name}",
|
|
"prefix_type": "vtep",
|
|
},
|
|
{
|
|
"prefix": f"10.{dc_id}.10.0/24",
|
|
"description": f"Spine-Leaf P2P links for {dc_name}",
|
|
"prefix_type": "p2p",
|
|
},
|
|
{
|
|
"prefix": f"10.{dc_id}.20.0/24",
|
|
"description": f"Leaf-Access P2P links for {dc_name}",
|
|
"prefix_type": "p2p",
|
|
},
|
|
{
|
|
"prefix": f"10.{dc_id}.255.0/24",
|
|
"description": f"MLAG peer links for {dc_name}",
|
|
"prefix_type": "mlag",
|
|
},
|
|
]
|
|
|
|
for prefix_data in prefixes:
|
|
prefix_obj = await self.client.create(
|
|
kind="IpamIPPrefix",
|
|
data={
|
|
"prefix": prefix_data["prefix"],
|
|
"description": prefix_data["description"],
|
|
"prefix_type": prefix_data["prefix_type"],
|
|
"status": "active",
|
|
"datacenter": dc.id,
|
|
},
|
|
)
|
|
await prefix_obj.save(allow_upsert=True)
|
|
self.log.debug(
|
|
f" Created prefix: {prefix_data['prefix']} ({prefix_data['prefix_type']})"
|
|
)
|
|
|
|
async def _create_spines(self, dc, topology: Dict[str, Any]) -> List[Any]:
|
|
"""
|
|
Create spine switches.
|
|
|
|
Naming: spine{1..N}-{DC_NAME}
|
|
IPs: 10.{dc_id}.0.{10+spine_num}/32
|
|
"""
|
|
dc_id = dc.dc_id.value
|
|
dc_name = dc.name.value
|
|
spine_count = dc.spine_count.value
|
|
spine_asn = topology["spine_asn"]
|
|
|
|
spines = []
|
|
|
|
for spine_num in range(1, spine_count + 1):
|
|
hostname = f"spine{spine_num}-{dc_name}"
|
|
loopback0_ip = f"10.{dc_id}.0.{10 + spine_num}"
|
|
mgmt_ip = f"10.255.0.{10 + spine_num}"
|
|
|
|
# Create device
|
|
device = await self.client.create(
|
|
kind="NetworkDevice",
|
|
data={
|
|
"hostname": hostname,
|
|
"description": f"Spine switch {spine_num} in {dc_name}",
|
|
"role": "spine",
|
|
"platform": "cEOS",
|
|
"datacenter": dc.id,
|
|
"site": dc.site.node.id,
|
|
"status": "active",
|
|
"spine_id": spine_num,
|
|
"management_ip_template": mgmt_ip,
|
|
},
|
|
)
|
|
await device.save(allow_upsert=True)
|
|
|
|
# Create Loopback0 interface
|
|
lo0 = await self.client.create(
|
|
kind="NetworkInterface",
|
|
data={
|
|
"name": "Loopback0",
|
|
"description": f"Router ID for {hostname}",
|
|
"interface_type": "loopback",
|
|
"enabled": True,
|
|
"device": device.id,
|
|
"loopback_id": 0,
|
|
"loopback_purpose": "router_id",
|
|
},
|
|
)
|
|
await lo0.save(allow_upsert=True)
|
|
|
|
# Create IP address for Loopback0
|
|
lo0_ip = await self.client.create(
|
|
kind="IpamIPAddress",
|
|
data={
|
|
"address": f"{loopback0_ip}/32",
|
|
"description": f"Loopback0 for {hostname}",
|
|
"status": "active",
|
|
"interface": lo0.id,
|
|
},
|
|
)
|
|
await lo0_ip.save(allow_upsert=True)
|
|
|
|
# Create BGP configuration
|
|
bgp_config = await self.client.create(
|
|
kind="NetworkBGPConfig",
|
|
data={
|
|
"asn": spine_asn,
|
|
"router_id": loopback0_ip,
|
|
"maximum_paths": 64,
|
|
"distance_external": 20,
|
|
"distance_internal": 200,
|
|
"ebgp_admin_distance": 200,
|
|
"default_ipv4_unicast": False,
|
|
"device": device.id,
|
|
},
|
|
)
|
|
await bgp_config.save(allow_upsert=True)
|
|
|
|
spines.append(
|
|
{
|
|
"device": device,
|
|
"loopback0": lo0,
|
|
"loopback0_ip": loopback0_ip,
|
|
"bgp_config": bgp_config,
|
|
}
|
|
)
|
|
|
|
self.log.info(
|
|
f" ✅ Created spine: {hostname} (ASN: {spine_asn}, Loopback0: {loopback0_ip})"
|
|
)
|
|
|
|
return spines
|
|
|
|
async def _create_leaf_pairs(
|
|
self, dc, topology: Dict[str, Any]
|
|
) -> List[Dict[str, Any]]:
|
|
"""
|
|
Create leaf switch pairs with MLAG configuration.
|
|
|
|
Naming: leaf{1..N}-{DC_NAME}
|
|
IPs:
|
|
- Loopback0: 10.{dc_id}.0.{20+leaf_num}/32
|
|
- Loopback1: 10.{dc_id}.1.{20+pair_num}/32 (shared)
|
|
"""
|
|
dc_id = dc.dc_id.value
|
|
dc_name = dc.name.value
|
|
leaf_pair_count = topology["leaf_pair_count"]
|
|
base_leaf_asn = topology["base_leaf_asn"]
|
|
|
|
leaf_pairs = []
|
|
|
|
for pair_num in range(1, leaf_pair_count + 1):
|
|
pair_asn = base_leaf_asn + (pair_num - 1)
|
|
vtep_ip = f"10.{dc_id}.1.{20 + pair_num}"
|
|
|
|
# Create MLAG domain
|
|
mlag_domain = await self.client.create(
|
|
kind="NetworkMLAGDomain",
|
|
data={
|
|
"domain_id": f"MLAG-leaf{pair_num * 2 - 1}-{pair_num * 2}-{dc_name}",
|
|
"local_interface": "Vlan4094",
|
|
"peer_interface": "Vlan4094",
|
|
"peer_address": f"10.{dc_id}.255.{pair_num * 4 - 2}", # Will be set properly per device
|
|
"status": "active",
|
|
},
|
|
)
|
|
await mlag_domain.save(allow_upsert=True)
|
|
|
|
pair_devices = []
|
|
|
|
# Create 2 leafs in the pair (odd and even)
|
|
for side_num in range(2):
|
|
leaf_num = pair_num * 2 - 1 + side_num # 1, 2, 3, 4...
|
|
hostname = f"leaf{leaf_num}-{dc_name}"
|
|
loopback0_ip = f"10.{dc_id}.0.{20 + leaf_num}"
|
|
mgmt_ip = f"10.255.0.{20 + leaf_num}"
|
|
mlag_side = "left" if side_num == 0 else "right"
|
|
|
|
# Create device
|
|
device = await self.client.create(
|
|
kind="NetworkDevice",
|
|
data={
|
|
"hostname": hostname,
|
|
"description": f"Leaf switch {leaf_num} in {dc_name} (Pair {pair_num})",
|
|
"role": "leaf",
|
|
"platform": "cEOS",
|
|
"datacenter": dc.id,
|
|
"site": dc.site.node.id,
|
|
"status": "active",
|
|
"leaf_id": leaf_num,
|
|
"mlag_side": mlag_side,
|
|
"mlag_domain": mlag_domain.id,
|
|
"management_ip_template": mgmt_ip,
|
|
},
|
|
)
|
|
await device.save(allow_upsert=True)
|
|
|
|
# Create Loopback0
|
|
lo0 = await self.client.create(
|
|
kind="NetworkInterface",
|
|
data={
|
|
"name": "Loopback0",
|
|
"description": f"Router ID for {hostname}",
|
|
"interface_type": "loopback",
|
|
"enabled": True,
|
|
"device": device.id,
|
|
"loopback_id": 0,
|
|
"loopback_purpose": "router_id",
|
|
},
|
|
)
|
|
await lo0.save(allow_upsert=True)
|
|
|
|
lo0_ip = await self.client.create(
|
|
kind="IpamIPAddress",
|
|
data={
|
|
"address": f"{loopback0_ip}/32",
|
|
"description": f"Loopback0 for {hostname}",
|
|
"status": "active",
|
|
"interface": lo0.id,
|
|
},
|
|
)
|
|
await lo0_ip.save(allow_upsert=True)
|
|
|
|
# Create Loopback1 (VTEP) - shared IP
|
|
lo1 = await self.client.create(
|
|
kind="NetworkInterface",
|
|
data={
|
|
"name": "Loopback1",
|
|
"description": f"VTEP for {hostname} (shared with pair)",
|
|
"interface_type": "loopback",
|
|
"enabled": True,
|
|
"device": device.id,
|
|
"loopback_id": 1,
|
|
"loopback_purpose": "vtep",
|
|
},
|
|
)
|
|
await lo1.save(allow_upsert=True)
|
|
|
|
lo1_ip = await self.client.create(
|
|
kind="IpamIPAddress",
|
|
data={
|
|
"address": f"{vtep_ip}/32",
|
|
"description": f"VTEP shared for leaf pair {pair_num}",
|
|
"status": "active",
|
|
"interface": lo1.id,
|
|
},
|
|
)
|
|
await lo1_ip.save(allow_upsert=True)
|
|
|
|
# Create BGP configuration
|
|
bgp_config = await self.client.create(
|
|
kind="NetworkBGPConfig",
|
|
data={
|
|
"asn": pair_asn,
|
|
"router_id": loopback0_ip,
|
|
"maximum_paths": 64,
|
|
"distance_external": 20,
|
|
"distance_internal": 200,
|
|
"ebgp_admin_distance": 200,
|
|
"default_ipv4_unicast": False,
|
|
"device": device.id,
|
|
},
|
|
)
|
|
await bgp_config.save(allow_upsert=True)
|
|
|
|
# Create VXLAN interface
|
|
vxlan1 = await self.client.create(
|
|
kind="NetworkVXLANTunnel",
|
|
data={
|
|
"name": "Vxlan1",
|
|
"source_ip": vtep_ip,
|
|
"udp_port": 4789,
|
|
"device": device.id,
|
|
},
|
|
)
|
|
await vxlan1.save(allow_upsert=True)
|
|
|
|
# Create EVPN config
|
|
evpn = await self.client.create(
|
|
kind="NetworkEVPNConfig",
|
|
data={
|
|
"vni_auto": True,
|
|
"device": device.id,
|
|
},
|
|
)
|
|
await evpn.save(allow_upsert=True)
|
|
|
|
pair_devices.append(
|
|
{
|
|
"device": device,
|
|
"loopback0": lo0,
|
|
"loopback0_ip": loopback0_ip,
|
|
"loopback1": lo1,
|
|
"vtep_ip": vtep_ip,
|
|
"bgp_config": bgp_config,
|
|
}
|
|
)
|
|
|
|
self.log.info(
|
|
f" ✅ Created leaf: {hostname} (ASN: {pair_asn}, VTEP: {vtep_ip})"
|
|
)
|
|
|
|
leaf_pairs.append(
|
|
{
|
|
"pair_num": pair_num,
|
|
"asn": pair_asn,
|
|
"mlag_domain": mlag_domain,
|
|
"devices": pair_devices,
|
|
"vtep_ip": vtep_ip,
|
|
}
|
|
)
|
|
|
|
return leaf_pairs
|
|
|
|
async def _create_border_pair(self, dc, topology: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""
|
|
Create border leaf pair for DCI connectivity.
|
|
|
|
Naming: borderleaf{1,2}-{DC_NAME}
|
|
IPs: 10.{dc_id}.0.{30+num}/32
|
|
eth12: Created but shutdown by default
|
|
"""
|
|
dc_id = dc.dc_id.value
|
|
dc_name = dc.name.value
|
|
border_asn = topology["border_asn"]
|
|
border_count = dc.border_leaf_count.value
|
|
|
|
# Create MLAG domain
|
|
mlag_domain = await self.client.create(
|
|
kind="NetworkMLAGDomain",
|
|
data={
|
|
"domain_id": f"MLAG-border-{dc_name}",
|
|
"local_interface": "Vlan4094",
|
|
"peer_interface": "Vlan4094",
|
|
"peer_address": f"10.{dc_id}.255.254",
|
|
"status": "active",
|
|
},
|
|
)
|
|
await mlag_domain.save(allow_upsert=True)
|
|
|
|
border_devices = []
|
|
|
|
for border_num in range(1, border_count + 1):
|
|
hostname = f"borderleaf{border_num}-{dc_name}"
|
|
loopback0_ip = f"10.{dc_id}.0.{30 + border_num}"
|
|
mgmt_ip = f"10.255.0.{30 + border_num}"
|
|
mlag_side = "left" if border_num == 1 else "right"
|
|
|
|
# Create device
|
|
device = await self.client.create(
|
|
kind="NetworkDevice",
|
|
data={
|
|
"hostname": hostname,
|
|
"description": f"Border leaf {border_num} in {dc_name} (DCI capable)",
|
|
"role": "borderleaf",
|
|
"platform": "cEOS",
|
|
"datacenter": dc.id,
|
|
"site": dc.site.node.id,
|
|
"status": "active",
|
|
"mlag_side": mlag_side,
|
|
"mlag_domain": mlag_domain.id,
|
|
"management_ip_template": mgmt_ip,
|
|
},
|
|
)
|
|
await device.save(allow_upsert=True)
|
|
|
|
# Create Loopback0
|
|
lo0 = await self.client.create(
|
|
kind="NetworkInterface",
|
|
data={
|
|
"name": "Loopback0",
|
|
"description": f"Router ID for {hostname}",
|
|
"interface_type": "loopback",
|
|
"enabled": True,
|
|
"device": device.id,
|
|
"loopback_id": 0,
|
|
"loopback_purpose": "router_id",
|
|
},
|
|
)
|
|
await lo0.save(allow_upsert=True)
|
|
|
|
lo0_ip = await self.client.create(
|
|
kind="IpamIPAddress",
|
|
data={
|
|
"address": f"{loopback0_ip}/32",
|
|
"description": f"Loopback0 for {hostname}",
|
|
"status": "active",
|
|
"interface": lo0.id,
|
|
},
|
|
)
|
|
await lo0_ip.save(allow_upsert=True)
|
|
|
|
# Create eth12 for DCI (shutdown by default)
|
|
eth12 = await self.client.create(
|
|
kind="NetworkInterface",
|
|
data={
|
|
"name": "Ethernet12",
|
|
"description": "DCI interface to DCI switch (shutdown unless dci_enabled=true)",
|
|
"interface_type": "ethernet",
|
|
"enabled": dc.dci_enabled.value if dc.dci_enabled.value else False,
|
|
"mtu": dc.mtu.value,
|
|
"device": device.id,
|
|
},
|
|
)
|
|
await eth12.save(allow_upsert=True)
|
|
|
|
# Create BGP configuration
|
|
bgp_config = await self.client.create(
|
|
kind="NetworkBGPConfig",
|
|
data={
|
|
"asn": border_asn,
|
|
"router_id": loopback0_ip,
|
|
"maximum_paths": 64,
|
|
"distance_external": 20,
|
|
"distance_internal": 200,
|
|
"ebgp_admin_distance": 200,
|
|
"default_ipv4_unicast": False,
|
|
"device": device.id,
|
|
},
|
|
)
|
|
await bgp_config.save(allow_upsert=True)
|
|
|
|
border_devices.append(
|
|
{
|
|
"device": device,
|
|
"loopback0": lo0,
|
|
"loopback0_ip": loopback0_ip,
|
|
"bgp_config": bgp_config,
|
|
"eth12": eth12,
|
|
}
|
|
)
|
|
|
|
self.log.info(
|
|
f" ✅ Created border leaf: {hostname} (ASN: {border_asn}, eth12: {'enabled' if dc.dci_enabled.value else 'shutdown'})"
|
|
)
|
|
|
|
return {
|
|
"asn": border_asn,
|
|
"mlag_domain": mlag_domain,
|
|
"devices": border_devices,
|
|
}
|
|
|
|
async def _create_access_switches(
|
|
self, dc, topology: Dict[str, Any], leaf_pairs: List[Dict[str, Any]]
|
|
) -> List[Any]:
|
|
"""
|
|
Create access switches and assign to leaf pairs.
|
|
|
|
Assignment: Round-robin to leaf pairs (2 access per pair)
|
|
Naming: access{bay_num}-{DC_NAME}
|
|
"""
|
|
dc_name = dc.name.value
|
|
number_of_bays = dc.number_of_bays.value
|
|
|
|
access_switches = []
|
|
|
|
for bay_num in range(1, number_of_bays + 1):
|
|
hostname = f"access{bay_num}-{dc_name}"
|
|
mgmt_ip = f"10.255.0.{100 + bay_num}"
|
|
|
|
# Assign to leaf pair (round-robin)
|
|
assigned_pair_idx = (bay_num - 1) // 2
|
|
assigned_pair = leaf_pairs[assigned_pair_idx]
|
|
|
|
# Create device
|
|
device = await self.client.create(
|
|
kind="NetworkDevice",
|
|
data={
|
|
"hostname": hostname,
|
|
"description": f"Access switch for Bay {bay_num} in {dc_name}",
|
|
"role": "access",
|
|
"platform": "cEOS",
|
|
"datacenter": dc.id,
|
|
"site": dc.site.node.id,
|
|
"status": "active",
|
|
"management_ip_template": mgmt_ip,
|
|
},
|
|
)
|
|
await device.save(allow_upsert=True)
|
|
|
|
access_switches.append(
|
|
{
|
|
"device": device,
|
|
"bay_num": bay_num,
|
|
"assigned_pair": assigned_pair,
|
|
}
|
|
)
|
|
|
|
self.log.info(
|
|
f" ✅ Created access: {hostname} (Bay {bay_num} → Leaf Pair {assigned_pair['pair_num']})"
|
|
)
|
|
|
|
return access_switches
|
|
|
|
async def _create_spine_leaf_connectivity(
|
|
self,
|
|
dc,
|
|
spines: List[Any],
|
|
leaf_pairs: List[Dict[str, Any]],
|
|
border_pair: Dict[str, Any],
|
|
topology: Dict[str, Any],
|
|
) -> None:
|
|
"""
|
|
Create interfaces and BGP sessions between spines and leafs (including borders).
|
|
|
|
Each leaf connects to ALL spines.
|
|
Interface assignment:
|
|
- Spine side: Ethernet{1..N} per leaf
|
|
- Leaf side: Ethernet{1..3} for 3 spines
|
|
"""
|
|
dc_id = dc.dc_id.value
|
|
|
|
# P2P IP allocator (starting from 10.{dc_id}.10.0/31)
|
|
p2p_counter = 0
|
|
|
|
# Collect all leaf devices (regular + border)
|
|
all_leaf_devices = []
|
|
for pair in leaf_pairs:
|
|
all_leaf_devices.extend(pair["devices"])
|
|
if border_pair:
|
|
all_leaf_devices.extend(border_pair["devices"])
|
|
|
|
# For each spine
|
|
for spine_idx, spine in enumerate(spines):
|
|
spine_device = spine["device"]
|
|
|
|
# Connect to each leaf
|
|
for leaf_idx, leaf in enumerate(all_leaf_devices):
|
|
leaf_device = leaf["device"]
|
|
|
|
# Allocate P2P subnet
|
|
spine_ip = f"10.{dc_id}.10.{p2p_counter * 2}"
|
|
leaf_ip = f"10.{dc_id}.10.{p2p_counter * 2 + 1}"
|
|
p2p_counter += 1
|
|
|
|
# Spine interface
|
|
spine_eth = f"Ethernet{leaf_idx + 1}"
|
|
spine_int = await self.client.create(
|
|
kind="NetworkInterface",
|
|
data={
|
|
"name": spine_eth,
|
|
"description": f"To {leaf_device.hostname.value}",
|
|
"interface_type": "ethernet",
|
|
"enabled": True,
|
|
"mtu": dc.mtu.value,
|
|
"device": spine_device.id,
|
|
},
|
|
)
|
|
await spine_int.save(allow_upsert=True)
|
|
|
|
spine_ip_obj = await self.client.create(
|
|
kind="IpamIPAddress",
|
|
data={
|
|
"address": f"{spine_ip}/31",
|
|
"description": f"{spine_device.hostname.value} to {leaf_device.hostname.value}",
|
|
"status": "active",
|
|
"interface": spine_int.id,
|
|
},
|
|
)
|
|
await spine_ip_obj.save(allow_upsert=True)
|
|
|
|
# Leaf interface
|
|
leaf_eth = f"Ethernet{spine_idx + 1}"
|
|
leaf_int = await self.client.create(
|
|
kind="NetworkInterface",
|
|
data={
|
|
"name": leaf_eth,
|
|
"description": f"To {spine_device.hostname.value}",
|
|
"interface_type": "ethernet",
|
|
"enabled": True,
|
|
"mtu": dc.mtu.value,
|
|
"device": leaf_device.id,
|
|
},
|
|
)
|
|
await leaf_int.save(allow_upsert=True)
|
|
|
|
leaf_ip_obj = await self.client.create(
|
|
kind="IpamIPAddress",
|
|
data={
|
|
"address": f"{leaf_ip}/31",
|
|
"description": f"{leaf_device.hostname.value} to {spine_device.hostname.value}",
|
|
"status": "active",
|
|
"interface": leaf_int.id,
|
|
},
|
|
)
|
|
await leaf_ip_obj.save(allow_upsert=True)
|
|
|
|
# Create BGP neighbor on spine
|
|
spine_bgp = spine["bgp_config"]
|
|
spine_neighbor = await self.client.create(
|
|
kind="NetworkBGPNeighbor",
|
|
data={
|
|
"neighbor_ip": leaf_ip,
|
|
"description": f"To {leaf_device.hostname.value}",
|
|
"enabled": True,
|
|
"peer_type": "ebgp",
|
|
"bgp_config": spine_bgp.id,
|
|
"local_interface": spine_int.id,
|
|
"remote_device": leaf_device.id,
|
|
},
|
|
)
|
|
await spine_neighbor.save(allow_upsert=True)
|
|
|
|
# Create BGP neighbor on leaf
|
|
leaf_bgp = leaf["bgp_config"]
|
|
leaf_neighbor = await self.client.create(
|
|
kind="NetworkBGPNeighbor",
|
|
data={
|
|
"neighbor_ip": spine_ip,
|
|
"description": f"To {spine_device.hostname.value}",
|
|
"enabled": True,
|
|
"peer_type": "ebgp",
|
|
"bgp_config": leaf_bgp.id,
|
|
"local_interface": leaf_int.id,
|
|
"remote_device": spine_device.id,
|
|
},
|
|
)
|
|
await leaf_neighbor.save(allow_upsert=True)
|
|
|
|
self.log.debug(f" Created {p2p_counter} spine-leaf P2P links")
|
|
|
|
async def _create_leaf_access_connectivity(
|
|
self,
|
|
dc,
|
|
leaf_pairs: List[Dict[str, Any]],
|
|
access_switches: List[Any],
|
|
topology: Dict[str, Any],
|
|
) -> None:
|
|
"""
|
|
Create dual-homed connectivity from access switches to leaf pairs.
|
|
|
|
Each access connects to both leafs in assigned pair:
|
|
- access eth1 → leaf_left eth7
|
|
- access eth2 → leaf_right eth7
|
|
"""
|
|
dc_id = dc.dc_id.value
|
|
|
|
# P2P IP allocator (starting from 10.{dc_id}.20.0/31)
|
|
p2p_counter = 0
|
|
|
|
for access in access_switches:
|
|
access_device = access["device"]
|
|
assigned_pair = access["assigned_pair"]
|
|
|
|
# Connect to both leafs in the pair
|
|
for link_num, leaf_data in enumerate(assigned_pair["devices"], start=1):
|
|
leaf_device = leaf_data["device"]
|
|
|
|
# Allocate P2P subnet
|
|
leaf_ip = f"10.{dc_id}.20.{p2p_counter * 2}"
|
|
access_ip = f"10.{dc_id}.20.{p2p_counter * 2 + 1}"
|
|
p2p_counter += 1
|
|
|
|
# Leaf interface (eth7 for access connectivity)
|
|
leaf_int = await self.client.create(
|
|
kind="NetworkInterface",
|
|
data={
|
|
"name": "Ethernet7",
|
|
"description": f"To {access_device.hostname.value}",
|
|
"interface_type": "ethernet",
|
|
"enabled": True,
|
|
"mtu": dc.mtu.value,
|
|
"device": leaf_device.id,
|
|
},
|
|
)
|
|
await leaf_int.save(allow_upsert=True)
|
|
|
|
leaf_ip_obj = await self.client.create(
|
|
kind="IpamIPAddress",
|
|
data={
|
|
"address": f"{leaf_ip}/31",
|
|
"description": f"{leaf_device.hostname.value} to {access_device.hostname.value}",
|
|
"status": "active",
|
|
"interface": leaf_int.id,
|
|
},
|
|
)
|
|
await leaf_ip_obj.save(allow_upsert=True)
|
|
|
|
# Access interface
|
|
access_eth = f"Ethernet{link_num}"
|
|
access_int = await self.client.create(
|
|
kind="NetworkInterface",
|
|
data={
|
|
"name": access_eth,
|
|
"description": f"To {leaf_device.hostname.value}",
|
|
"interface_type": "ethernet",
|
|
"enabled": True,
|
|
"mtu": dc.mtu.value,
|
|
"device": access_device.id,
|
|
},
|
|
)
|
|
await access_int.save(allow_upsert=True)
|
|
|
|
access_ip_obj = await self.client.create(
|
|
kind="IpamIPAddress",
|
|
data={
|
|
"address": f"{access_ip}/31",
|
|
"description": f"{access_device.hostname.value} to {leaf_device.hostname.value}",
|
|
"status": "active",
|
|
"interface": access_int.id,
|
|
},
|
|
)
|
|
await access_ip_obj.save(allow_upsert=True)
|
|
|
|
self.log.debug(f" Created {p2p_counter} leaf-access P2P links")
|
|
|
|
async def _update_datacenter_computed_fields(
|
|
self, dc, topology: Dict[str, Any]
|
|
) -> None:
|
|
"""
|
|
Update the datacenter object with computed values.
|
|
"""
|
|
# Update computed attributes
|
|
dc.leaf_pair_count.value = topology["leaf_pair_count"]
|
|
dc.total_leaf_count.value = topology["total_leaf_count"]
|
|
dc.total_access_count.value = topology["total_access_count"]
|
|
|
|
await dc.save()
|
|
|
|
self.log.debug(
|
|
f" Updated computed fields: leaf_pair_count={topology['leaf_pair_count']}, "
|
|
f"total_leaf_count={topology['total_leaf_count']}, "
|
|
f"total_access_count={topology['total_access_count']}"
|
|
)
|