#!/usr/bin/env python3 """ SP NETWORKING ACADEMY BGP-009 - ROUTE ADVERTISEMENT AND WITHDRAWAL Test prefix: 172.16.2.2/32 Origin router: R2 Local AS: 65002 Phases: 1. Verify initial prefix availability on all routers. 2. Withdraw the prefix from R2 BGP configuration. 3. Verify withdrawal from all four BGP tables. 4. Restore the prefix advertisement on R2. 5. Verify prefix recovery on all four routers. A single consolidated report is generated. """ import sys import time from pathlib import Path from datetime import datetime from netmiko import ConnectHandler # --------------------------------------------------------- # CONFIGURATION # --------------------------------------------------------- USERNAME = "admin" PASSWORD = "cisco123" ROUTERS = { "R1": "10.0.31.1", "R2": "10.0.32.1", "R3": "10.0.33.1", "R4": "10.0.34.1", } ORIGIN_ROUTER = "R2" ORIGIN_AS = 65002 TEST_PREFIX = "172.16.2.2" TEST_PREFIX_MASK = "255.255.255.255" NETWORK_COMMAND = ( f"network {TEST_PREFIX} mask {TEST_PREFIX_MASK}" ) WITHDRAW_COMMAND = ( f"no network {TEST_PREFIX} mask {TEST_PREFIX_MASK}" ) MAX_ATTEMPTS = 18 RETRY_INTERVAL = 5 REPORT_DIR = Path(__file__).resolve().parents[1] / "REPORTS" REPORT_DIR.mkdir(parents=True, exist_ok=True) TIMESTAMP = datetime.now().strftime("%Y%m%d_%H%M%S") REPORT_FILE = REPORT_DIR / ( f"BGP-009-ROUTE-ADVERTISEMENT-{TIMESTAMP}.txt" ) report_lines = [] results = [] infrastructure_errors = 0 advertisement_removed = False restore_required = False # --------------------------------------------------------- # REPORTING FUNCTIONS # --------------------------------------------------------- def log(message): print(message) report_lines.append(message) def record(status, message): line = f"[{status}] {message}" log(line) results.append((status, message)) def save_report(): with REPORT_FILE.open("w", encoding="utf-8") as file: file.write( "SP NETWORKING ACADEMY - BGP-009 " "ROUTE ADVERTISEMENT AND WITHDRAWAL\n" ) file.write(f"Execution time: {datetime.now()}\n") file.write("=" * 78 + "\n\n") file.write("\n".join(report_lines)) file.write("\n\n" + "=" * 78 + "\n") file.write("BGP-009 EXECUTION SUMMARY\n") file.write("=" * 78 + "\n") passed = sum(1 for status, _ in results if status == "PASS") failed = sum(1 for status, _ in results if status == "FAIL") file.write(f"Checks passed: {passed}\n") file.write(f"Checks failed: {failed}\n") file.write(f"Infrastructure errors: {infrastructure_errors}\n") final_status = ( "PASS" if failed == 0 and infrastructure_errors == 0 else "FAIL" ) file.write(f"FINAL STATUS: {final_status}\n") file.write(f"Report: {REPORT_FILE}\n") # --------------------------------------------------------- # DEVICE CONNECTION # --------------------------------------------------------- def connect_router(router_name): host = ROUTERS[router_name] device = { "device_type": "cisco_ios", "host": host, "username": USERNAME, "password": PASSWORD, "conn_timeout": 15, "auth_timeout": 20, "banner_timeout": 20, "fast_cli": False, } log(f"\n[INFO] Connecting to {router_name} ({host})") connection = ConnectHandler(**device) log(f"[PASS] SSH connected to {router_name}") return connection # --------------------------------------------------------- # BGP PREFIX VERIFICATION # --------------------------------------------------------- def check_prefix(connection): output = connection.send_command( f"show ip bgp {TEST_PREFIX}", read_timeout=30, ) lower_output = output.lower() absent_indicators = [ "network not in table", "not in table", "subnet not in table", ] if any(item in lower_output for item in absent_indicators): return False, output present_indicators = [ "bgp routing table entry for", "paths:", ] if any(item in lower_output for item in present_indicators): return True, output return False, output # --------------------------------------------------------- # VERIFY PREFIX ON ALL ROUTERS # --------------------------------------------------------- def verify_all_routers(expected_present, phase_name): log(f"\n[INFO] {phase_name}") phase_results = {} for router_name in ROUTERS: connection = None try: connection = connect_router(router_name) found, output = check_prefix(connection) expected_text = ( "present" if expected_present else "withdrawn" ) if found == expected_present: record( "PASS", f"{router_name}: Prefix {TEST_PREFIX}/32 " f"is {expected_text}" ) phase_results[router_name] = True else: record( "INFO", f"{router_name}: Prefix state not yet as expected" ) phase_results[router_name] = False log("--- DEVICE OUTPUT BEGIN ---") log(output) log("--- DEVICE OUTPUT END ---") except Exception as error: record( "FAIL", f"{router_name}: Verification error: {error}" ) phase_results[router_name] = False finally: if connection: connection.disconnect() return phase_results # --------------------------------------------------------- # WAIT FOR ROUTE CONVERGENCE # --------------------------------------------------------- def wait_for_prefix(expected_present, phase_name): for attempt in range(1, MAX_ATTEMPTS + 1): log( f"\n[INFO] {phase_name} | " f"Attempt {attempt}/{MAX_ATTEMPTS}" ) states = verify_all_routers( expected_present, f"Checking prefix state on all routers" ) if all(states.values()): log( f"\n[PASS] All four routers verified " f"the expected prefix state" ) return True if attempt < MAX_ATTEMPTS: log( f"[INFO] Waiting {RETRY_INTERVAL} seconds " f"for BGP convergence" ) time.sleep(RETRY_INTERVAL) return False # --------------------------------------------------------- # MAIN TEST # --------------------------------------------------------- def main(): global infrastructure_errors global advertisement_removed global restore_required log("=" * 78) log("SP NETWORKING ACADEMY - BGP-009") log("ROUTE ADVERTISEMENT AND WITHDRAWAL") log("=" * 78) log(f"Execution started: {datetime.now()}") log(f"Origin router: {ORIGIN_ROUTER}") log(f"Origin AS: {ORIGIN_AS}") log(f"Test prefix: {TEST_PREFIX}/32") log("Authentication: Automatic") log("=" * 78) # ----------------------------------------------------- # PHASE 1 - INITIAL BASELINE # ----------------------------------------------------- baseline = verify_all_routers( True, "PHASE 1 - INITIAL PREFIX BASELINE" ) if not all(baseline.values()): record( "FAIL", "Initial baseline failed. Withdrawal aborted for safety." ) return 1 record("PASS", "Initial prefix baseline verified on all routers") # ----------------------------------------------------- # PHASE 2 - CHECK ORIGIN CONFIGURATION # ----------------------------------------------------- origin_connection = None try: origin_connection = connect_router(ORIGIN_ROUTER) log( f"\n[INFO] Checking BGP network statement on " f"{ORIGIN_ROUTER}" ) bgp_config = origin_connection.send_command( "show running-config | section router bgp", read_timeout=30, ) if NETWORK_COMMAND not in bgp_config: record( "FAIL", f"{ORIGIN_ROUTER}: Expected network statement " "not found. Withdrawal aborted." ) return 1 record( "PASS", f"{ORIGIN_ROUTER}: Origin network statement verified" ) # ------------------------------------------------- # PHASE 3 - WITHDRAW PREFIX # ------------------------------------------------- log("\n" + "=" * 78) log("PHASE 3 - BGP PREFIX WITHDRAWAL") log("=" * 78) log( f"[INFO] Removing advertisement of " f"{TEST_PREFIX}/32 from {ORIGIN_ROUTER}" ) restore_required = True config_output = origin_connection.send_config_set( [ f"router bgp {ORIGIN_AS}", WITHDRAW_COMMAND, ], read_timeout=30, ) log(config_output) verify_config = origin_connection.send_command( "show running-config | section router bgp", read_timeout=30, ) if NETWORK_COMMAND not in verify_config: advertisement_removed = True record( "PASS", f"{ORIGIN_ROUTER}: BGP network statement removed" ) else: record( "FAIL", f"{ORIGIN_ROUTER}: Network statement still present" ) return 1 origin_connection.disconnect() origin_connection = None # ------------------------------------------------- # PHASE 4 - VERIFY WITHDRAWAL # ------------------------------------------------- log("\n" + "=" * 78) log("PHASE 4 - VERIFY ROUTE WITHDRAWAL") log("=" * 78) withdrawal_success = wait_for_prefix( False, "Waiting for BGP withdrawal propagation" ) if withdrawal_success: record( "PASS", "Prefix withdrawal verified on all four routers" ) else: record( "FAIL", "Prefix withdrawal was not verified on all routers" ) except Exception as error: infrastructure_errors += 1 record("FAIL", f"Test execution error: {error}") finally: # ------------------------------------------------- # PHASE 5 - RESTORE ADVERTISEMENT # ------------------------------------------------- if restore_required: log("\n" + "=" * 78) log("PHASE 5 - RESTORE BGP ADVERTISEMENT") log("=" * 78) try: if origin_connection is None: origin_connection = connect_router(ORIGIN_ROUTER) current_config = origin_connection.send_command( "show running-config | section router bgp", read_timeout=30, ) if NETWORK_COMMAND not in current_config: log( f"[INFO] Restoring {TEST_PREFIX}/32 " f"on {ORIGIN_ROUTER}" ) restore_output = origin_connection.send_config_set( [ f"router bgp {ORIGIN_AS}", NETWORK_COMMAND, ], read_timeout=30, ) log(restore_output) restored_config = origin_connection.send_command( "show running-config | section router bgp", read_timeout=30, ) if NETWORK_COMMAND in restored_config: record( "PASS", f"{ORIGIN_ROUTER}: Network advertisement restored" ) else: record( "FAIL", f"{ORIGIN_ROUTER}: Advertisement restoration " "could not be verified" ) except Exception as error: infrastructure_errors += 1 record( "FAIL", f"Advertisement restoration error: {error}" ) finally: if origin_connection: origin_connection.disconnect() origin_connection = None # --------------------------------------------- # PHASE 6 - VERIFY PREFIX RECOVERY # --------------------------------------------- log("\n" + "=" * 78) log("PHASE 6 - VERIFY PREFIX RECOVERY") log("=" * 78) recovery_success = wait_for_prefix( True, "Waiting for BGP prefix re-advertisement" ) if recovery_success: record( "PASS", "Prefix recovery verified on all four routers" ) else: record( "FAIL", "Prefix recovery was not verified on all routers" ) # ----------------------------------------------------- # FINAL SUMMARY # ----------------------------------------------------- log("\n" + "=" * 78) log("BGP-009 EXECUTION SUMMARY") log("=" * 78) passed = sum(1 for status, _ in results if status == "PASS") failed = sum(1 for status, _ in results if status == "FAIL") log(f"Checks passed: {passed}") log(f"Checks failed: {failed}") log(f"Infrastructure errors: {infrastructure_errors}") final_status = ( "PASS" if failed == 0 and infrastructure_errors == 0 else "FAIL" ) log(f"FINAL STATUS: {final_status}") log(f"Single consolidated report: {REPORT_FILE}") log("=" * 78) save_report() return 0 if final_status == "PASS" else 1 if __name__ == "__main__": sys.exit(main())