Link State Routing

! Enable BFD globally for OSPF
router ospf 1
  bfd all-interfaces
 
! Configure BFD parameters per interface
interface GigabitEthernet0/1
  bfd interval 50 min_rx 50 multiplier 3
  ! Detection time = 50ms × 3 = 150ms
  
! Verify BFD neighbors
Router# show bfd neighbors detail
 
OurAddr        NeighAddr      LD/RD    State   Int
10.1.1.1       10.1.1.2       1/2      Up      Gi0/1
Session state is UP (2 received)
  Local Diag: 0, Demand mode: 0, Poll bit: 0
  MinTxInt: 50000, MinRxInt: 50000, Multiplier: 3
  Received MinTxInt: 50000, Received MinRxInt: 50000
  Hold Timer: 150000us, Detection Time: 150000us
  Last packet: Version: 1 - Diagnostic: 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

! ============================================
! OSPF Fast Convergence Configuration
! Target: Sub-200ms convergence
! ============================================
 
router ospf 1
 router-id 1.1.1.1
 
 ! Fast SPF scheduling
 ! Initial delay: 0ms (immediate first run)
 ! Holdtime: 50ms (fast subsequent runs)
 ! Max-wait: 1000ms (cap during instability)
 timers spf 0 50 1000
 
 ! Fast LSA generation
 timers lsa arrival 10
 
 ! Enable LSA pacing
 timers pacing lsa-group 10
 timers pacing flood 5
 
 ! Enable BFD for all interfaces
 bfd all-interfaces
 
 ! Incremental SPF (platform dependent)
 ispf
 
 ! Prefix prioritization (optional)
 ! Prioritize routes to critical destinations
 prefix-priority high 10.0.0.0/8
 
! Interface-level optimization
interface GigabitEthernet0/1
 description CORE_LINK
 ip ospf network point-to-point
 
 ! BFD parameters: 50ms × 3 = 150ms detection
 bfd interval 50 min_rx 50 multiplier 3
 
 ! Reduced Hello for additional safety
 ip ospf hello-interval 1
 ip ospf dead-interval 4
 
 ! Carrier delay: react immediately to link down
 carrier-delay msec 0
 
! Fast interface down detection
interface GigabitEthernet0/2
 description ACCESS_LINK
 ! Debounce: prevent flapping from causing churn
 carrier-delay msec 50
 dampening 5 1000 2000 20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

import time
import subprocess
import threading
from dataclasses import dataclass
from typing import List, Tuple
 
@dataclass
class ConvergenceResult:
    """Results from a convergence test"""
    failure_time: float
    recovery_time: float
    convergence_ms: float
    packets_sent: int
    packets_lost: int
    loss_percentage: float
 
class ConvergenceTester:
    """
    Measures network convergence time using continuous ping.
    
    Methodology:
    1. Send continuous pings through network path
    2. Induce failure event
    3. Count consecutive ping failures
    4. Calculate convergence time from loss duration
    """
    
    def __init__(self, target_ip: str, source_ip: str = None):
        self.target_ip = target_ip
        self.source_ip = source_ip
        self.ping_interval_ms = 10  # 10ms between pings
        
        self.results: List[Tuple[float, bool]] = []
        self._running = False
    
    def _ping_once(self) -> bool:
        """Send single ping, return True if successful"""
        try:
            # Use system ping with 100ms timeout
            cmd = ['ping', '-c', '1', '-W', '0.1', self.target_ip]
            if self.source_ip:
                cmd.extend(['-I', self.source_ip])
            
            result = subprocess.run(
                cmd,
                capture_output=True,
                timeout=0.5
            )
            return result.returncode == 0
        except:
            return False
    
    def start_monitoring(self):
        """Start continuous ping monitoring in background"""
        self._running = True
        self.results = []
        
        def monitor_loop():
            while self._running:
                timestamp = time.time()
                success = self._ping_once()
                self.results.append((timestamp, success))
                
                # Sleep for interval minus processing time
                elapsed = time.time() - timestamp
                sleep_time = max(0, (self.ping_interval_ms / 1000) - elapsed)
                time.sleep(sleep_time)
        
        thread = threading.Thread(target=monitor_loop, daemon=True)
        thread.start()
    
    def stop_monitoring(self):
        """Stop monitoring"""
        self._running = False
    
    def analyze_results(self, 
                        failure_time: float,
                        recovery_expected_by: float = None
                        ) -> ConvergenceResult:
        """
        Analyze ping results to calculate convergence time.
        
        Args:
            failure_time: Unix timestamp when failure was induced
            recovery_expected_by: Optional max time to wait for recovery
        """
        # Find first failure after induced failure
        first_loss_time = None
        last_loss_time = None
        total_lost = 0
        
        for timestamp, success in self.results:
            if timestamp < failure_time:
                continue  # Before induced failure
            
            if not success:
                if first_loss_time is None:
                    first_loss_time = timestamp
                last_loss_time = timestamp
                total_lost += 1
        
        # Find recovery (first success after losses)
        recovery_time = None
        for timestamp, success in self.results:
            if first_loss_time and timestamp > last_loss_time and success:
                recovery_time = timestamp
                break
        
        if first_loss_time is None:
            # No packet loss detected
            convergence_ms = 0.0
        elif recovery_time is None:
            # Never recovered
            convergence_ms = float('inf')
        else:
            convergence_ms = (recovery_time - first_loss_time) * 1000
        
        total_sent = sum(1 for t, _ in self.results if t >= failure_time)
        
        return ConvergenceResult(
            failure_time=failure_time,
            recovery_time=recovery_time or float('inf'),
            convergence_ms=convergence_ms,
            packets_sent=total_sent,
            packets_lost=total_lost,
            loss_percentage=(total_lost / total_sent * 100) if total_sent > 0 else 0
        )
 
# Example usage
def run_convergence_test(target: str, wait_before_failure: int = 5):
    """Run a complete convergence test"""
    print(f"Starting convergence test to {target}")
    
    tester = ConvergenceTester(target)
    tester.start_monitoring()
    
    print(f"Monitoring for {wait_before_failure}s baseline...")
    time.sleep(wait_before_failure)
    
    # Record failure induction time
    failure_time = time.time()
    print(f"[!] Failure induced at {failure_time}")
    print("    (Manually execute: 'shutdown' on target interface)")
    
    # Wait for recovery
    print("Waiting for convergence (max 60s)...")
    time.sleep(60)
    
    tester.stop_monitoring()
    
    result = tester.analyze_results(failure_time)
    
    print(f"\n{'='*50}")
    print("CONVERGENCE TEST RESULTS")
    print(f"{'='*50}")
    print(f"Convergence Time: {result.convergence_ms:.1f}ms")
    print(f"Packets Lost: {result.packets_lost} / {result.packets_sent}")
    print(f"Loss Percentage: {result.loss_percentage:.2f}%")
    
    return result
 
# Run test
# run_convergence_test("10.1.1.1")