Skip to content

ANTA catalog for BFD tests

Tests

VerifyBFDPeersHealth

Verifies the health of IPv4 BFD peers across all VRFs.

This test performs the following checks for BFD peers across all VRFs:

  1. Validates that the state is up.
  2. Confirms that the remote discriminator identifier (disc) is non-zero.
  3. Optionally verifies that the peer have not been down before a specified threshold of hours.
Expected Results
  • Success: If all of the following conditions are met:
    • All BFD peers across the VRFs are up and remote disc is non-zero.
    • Last downtime of each peer is above the defined threshold, if specified.
  • Failure: If any of the following occur:
    • Any BFD peer session is not up or the remote discriminator identifier is zero.
    • Last downtime of any peer is below the defined threshold, if specified.
Examples
anta.tests.bfd:
  - VerifyBFDPeersHealth:
      down_threshold: 2

Inputs

Name Type Description Default
down_threshold int | None
Optional down threshold in hours to check if a BFD peer was down before those hours or not.
Field(default=None, gt=0)
Source code in anta/tests/bfd.py
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
class VerifyBFDPeersHealth(AntaTest):
    """Verifies the health of IPv4 BFD peers across all VRFs.

    This test performs the following checks for BFD peers across all VRFs:

      1. Validates that the state is `up`.
      2. Confirms that the remote discriminator identifier (disc) is non-zero.
      3. Optionally verifies that the peer have not been down before a specified threshold of hours.

    Expected Results
    ----------------
    * Success: If all of the following conditions are met:
        - All BFD peers across the VRFs are up and remote disc is non-zero.
        - Last downtime of each peer is above the defined threshold, if specified.
    * Failure: If any of the following occur:
        - Any BFD peer session is not up or the remote discriminator identifier is zero.
        - Last downtime of any peer is below the defined threshold, if specified.

    Examples
    --------
    ```yaml
    anta.tests.bfd:
      - VerifyBFDPeersHealth:
          down_threshold: 2
    ```
    """

    categories: ClassVar[list[str]] = ["bfd"]
    # revision 1 as later revision introduces additional nesting for type
    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [
        AntaCommand(command="show bfd peers", revision=1),
        AntaCommand(command="show clock", revision=1),
    ]

    class Input(AntaTest.Input):
        """Input model for the VerifyBFDPeersHealth test."""

        down_threshold: int | None = Field(default=None, gt=0)
        """Optional down threshold in hours to check if a BFD peer was down before those hours or not."""

    @AntaTest.anta_test
    def test(self) -> None:
        """Main test function for VerifyBFDPeersHealth."""
        self.result.is_success()

        # Extract the current timestamp and command output
        clock_output = self.instance_commands[1].json_output
        current_timestamp = clock_output["utcTime"]
        bfd_output = self.instance_commands[0].json_output

        # Check if any IPv4 BFD peer is configured
        ipv4_neighbors_exist = any(vrf_data["ipv4Neighbors"] for vrf_data in bfd_output["vrfs"].values())
        if not ipv4_neighbors_exist:
            self.result.is_failure("No IPv4 BFD peers are configured for any VRF.")
            return

        # Iterate over IPv4 BFD peers
        for vrf, vrf_data in bfd_output["vrfs"].items():
            for peer, neighbor_data in vrf_data["ipv4Neighbors"].items():
                for peer_data in neighbor_data["peerStats"].values():
                    peer_status = peer_data["status"]
                    remote_disc = peer_data["remoteDisc"]
                    last_down = peer_data["lastDown"]
                    hours_difference = (
                        datetime.fromtimestamp(current_timestamp, tz=timezone.utc) - datetime.fromtimestamp(last_down, tz=timezone.utc)
                    ).total_seconds() / 3600

                    if not (peer_status == "up" and remote_disc != 0):
                        self.result.is_failure(
                            f"Peer: {peer} VRF: {vrf} - Session not properly established - State: {peer_status} Remote Discriminator: {remote_disc}"
                        )

                    # Check if the last down is within the threshold
                    if self.inputs.down_threshold and hours_difference < self.inputs.down_threshold:
                        self.result.is_failure(
                            f"Peer: {peer} VRF: {vrf} - Session failure detected within the expected uptime threshold ({round(hours_difference)} hours ago)"
                        )

VerifyBFDPeersIntervals

Verifies the timers of IPv4 BFD peer sessions.

This test performs the following checks for each specified peer:

  1. Confirms that the specified VRF is configured.
  2. Verifies that the peer exists in the BFD configuration.
  3. Confirms that BFD peer is correctly configured with the Transmit interval, Receive interval and Multiplier.
Expected Results
  • Success: If all of the following conditions are met:
    • All specified peers are found in the BFD configuration within the specified VRF.
    • All BFD peers are correctly configured with the Transmit interval, Receive interval and Multiplier.
  • Failure: If any of the following occur:
    • A specified peer is not found in the BFD configuration within the specified VRF.
    • Any BFD peer not correctly configured with the Transmit interval, Receive interval and Multiplier.
Examples
anta.tests.bfd:
  - VerifyBFDPeersIntervals:
      bfd_peers:
        - peer_address: 192.0.255.8
          vrf: default
          tx_interval: 1200
          rx_interval: 1200
          multiplier: 3
        - peer_address: 192.0.255.7
          vrf: default
          tx_interval: 1200
          rx_interval: 1200
          multiplier: 3

Inputs

Name Type Description Default
bfd_peers list[BFDPeer]
List of IPv4 BFD
-
BFDPeer type[BFDPeer]
To maintain backward compatibility
BFDPeer
Source code in anta/tests/bfd.py
 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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
class VerifyBFDPeersIntervals(AntaTest):
    """Verifies the timers of IPv4 BFD peer sessions.

    This test performs the following checks for each specified peer:

      1. Confirms that the specified VRF is configured.
      2. Verifies that the peer exists in the BFD configuration.
      3. Confirms that BFD peer is correctly configured with the `Transmit interval, Receive interval and Multiplier`.

    Expected Results
    ----------------
    * Success: If all of the following conditions are met:
        - All specified peers are found in the BFD configuration within the specified VRF.
        - All BFD peers are correctly configured with the `Transmit interval, Receive interval and Multiplier`.
    * Failure: If any of the following occur:
        - A specified peer is not found in the BFD configuration within the specified VRF.
        - Any BFD peer not correctly configured with the `Transmit interval, Receive interval and Multiplier`.

    Examples
    --------
    ```yaml
    anta.tests.bfd:
      - VerifyBFDPeersIntervals:
          bfd_peers:
            - peer_address: 192.0.255.8
              vrf: default
              tx_interval: 1200
              rx_interval: 1200
              multiplier: 3
            - peer_address: 192.0.255.7
              vrf: default
              tx_interval: 1200
              rx_interval: 1200
              multiplier: 3
    ```
    """

    categories: ClassVar[list[str]] = ["bfd"]
    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show bfd peers detail", revision=1)]

    class Input(AntaTest.Input):
        """Input model for the VerifyBFDPeersIntervals test."""

        bfd_peers: list[BFDPeer]
        """List of IPv4 BFD"""
        BFDPeer: ClassVar[type[BFDPeer]] = BFDPeer
        """To maintain backward compatibility"""

    @AntaTest.anta_test
    def test(self) -> None:
        """Main test function for VerifyBFDPeersIntervals."""
        self.result.is_success()

        # Iterating over BFD peers
        for bfd_peer in self.inputs.bfd_peers:
            peer = str(bfd_peer.peer_address)
            vrf = bfd_peer.vrf
            tx_interval = bfd_peer.tx_interval
            rx_interval = bfd_peer.rx_interval
            multiplier = bfd_peer.multiplier

            # Check if BFD peer configured
            bfd_output = get_value(
                self.instance_commands[0].json_output,
                f"vrfs..{vrf}..ipv4Neighbors..{peer}..peerStats..",
                separator="..",
            )
            if not bfd_output:
                self.result.is_failure(f"{bfd_peer} - Not found")
                continue

            # Convert interval timer(s) into milliseconds to be consistent with the inputs.
            bfd_details = bfd_output.get("peerStatsDetail", {})
            op_tx_interval = bfd_details.get("operTxInterval") // 1000
            op_rx_interval = bfd_details.get("operRxInterval") // 1000
            detect_multiplier = bfd_details.get("detectMult")

            if op_tx_interval != tx_interval:
                self.result.is_failure(f"{bfd_peer} - Incorrect Transmit interval - Expected: {tx_interval} Actual: {op_tx_interval}")

            if op_rx_interval != rx_interval:
                self.result.is_failure(f"{bfd_peer} - Incorrect Receive interval - Expected: {rx_interval} Actual: {op_rx_interval}")

            if detect_multiplier != multiplier:
                self.result.is_failure(f"{bfd_peer} - Incorrect Multiplier - Expected: {multiplier} Actual: {detect_multiplier}")

VerifyBFDPeersRegProtocols

Verifies the registered routing protocol of IPv4 BFD peer sessions.

This test performs the following checks for each specified peer:

  1. Confirms that the specified VRF is configured.
  2. Verifies that the peer exists in the BFD configuration.
  3. Confirms that BFD peer is correctly configured with the routing protocol.
Expected Results
  • Success: If all of the following conditions are met:
    • All specified peers are found in the BFD configuration within the specified VRF.
    • All BFD peers are correctly configured with the routing protocol.
  • Failure: If any of the following occur:
    • A specified peer is not found in the BFD configuration within the specified VRF.
    • Any BFD peer not correctly configured with the routing protocol.
Examples
anta.tests.bfd:
  - VerifyBFDPeersRegProtocols:
      bfd_peers:
        - peer_address: 192.0.255.7
          vrf: default
          protocols:
            - bgp

Inputs

Name Type Description Default
bfd_peers list[BFDPeer]
List of IPv4 BFD
-
BFDPeer type[BFDPeer]
To maintain backward compatibility
BFDPeer
Source code in anta/tests/bfd.py
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
class VerifyBFDPeersRegProtocols(AntaTest):
    """Verifies the registered routing protocol of IPv4 BFD peer sessions.

    This test performs the following checks for each specified peer:

      1. Confirms that the specified VRF is configured.
      2. Verifies that the peer exists in the BFD configuration.
      3. Confirms that BFD peer is correctly configured with the `routing protocol`.

    Expected Results
    ----------------
    * Success: If all of the following conditions are met:
        - All specified peers are found in the BFD configuration within the specified VRF.
        - All BFD peers are correctly configured with the `routing protocol`.
    * Failure: If any of the following occur:
        - A specified peer is not found in the BFD configuration within the specified VRF.
        - Any BFD peer not correctly configured with the `routing protocol`.

    Examples
    --------
    ```yaml
    anta.tests.bfd:
      - VerifyBFDPeersRegProtocols:
          bfd_peers:
            - peer_address: 192.0.255.7
              vrf: default
              protocols:
                - bgp
    ```
    """

    categories: ClassVar[list[str]] = ["bfd"]
    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show bfd peers detail", revision=1)]

    class Input(AntaTest.Input):
        """Input model for the VerifyBFDPeersRegProtocols test."""

        bfd_peers: list[BFDPeer]
        """List of IPv4 BFD"""
        BFDPeer: ClassVar[type[BFDPeer]] = BFDPeer
        """To maintain backward compatibility"""

    @AntaTest.anta_test
    def test(self) -> None:
        """Main test function for VerifyBFDPeersRegProtocols."""
        self.result.is_success()

        # Iterating over BFD peers, extract the parameters and command output
        for bfd_peer in self.inputs.bfd_peers:
            peer = str(bfd_peer.peer_address)
            vrf = bfd_peer.vrf
            protocols = bfd_peer.protocols
            bfd_output = get_value(
                self.instance_commands[0].json_output,
                f"vrfs..{vrf}..ipv4Neighbors..{peer}..peerStats..",
                separator="..",
            )

            # Check if BFD peer configured
            if not bfd_output:
                self.result.is_failure(f"{bfd_peer} - Not found")
                continue

            # Check registered protocols
            difference = sorted(set(protocols) - set(get_value(bfd_output, "peerStatsDetail.apps")))
            if difference:
                failures = " ".join(f"`{item}`" for item in difference)
                self.result.is_failure(f"{bfd_peer} - {failures} routing protocol(s) not configured")

VerifyBFDSpecificPeers

Verifies the state of IPv4 BFD peer sessions.

This test performs the following checks for each specified peer:

  1. Confirms that the specified VRF is configured.
  2. Verifies that the peer exists in the BFD configuration.
  3. For each specified BFD peer:
    • Validates that the state is up
    • Confirms that the remote discriminator identifier (disc) is non-zero.
Expected Results
  • Success: If all of the following conditions are met:
    • All specified peers are found in the BFD configuration within the specified VRF.
    • All BFD peers are up and remote disc is non-zero.
  • Failure: If any of the following occur:
    • A specified peer is not found in the BFD configuration within the specified VRF.
    • Any BFD peer session is not up or the remote discriminator identifier is zero.
Examples
anta.tests.bfd:
  - VerifyBFDSpecificPeers:
      bfd_peers:
        - peer_address: 192.0.255.8
          vrf: default
        - peer_address: 192.0.255.7
          vrf: default

Inputs

Name Type Description Default
bfd_peers list[BFDPeer]
List of IPv4 BFD
-
BFDPeer type[BFDPeer]
To maintain backward compatibility.
BFDPeer
Source code in anta/tests/bfd.py
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
class VerifyBFDSpecificPeers(AntaTest):
    """Verifies the state of IPv4 BFD peer sessions.

    This test performs the following checks for each specified peer:

      1. Confirms that the specified VRF is configured.
      2. Verifies that the peer exists in the BFD configuration.
      3. For each specified BFD peer:
        - Validates that the state is `up`
        - Confirms that the remote discriminator identifier (disc) is non-zero.

    Expected Results
    ----------------
    * Success: If all of the following conditions are met:
        - All specified peers are found in the BFD configuration within the specified VRF.
        - All BFD peers are `up` and remote disc is non-zero.
    * Failure: If any of the following occur:
        - A specified peer is not found in the BFD configuration within the specified VRF.
        - Any BFD peer session is not `up` or the remote discriminator identifier is zero.

    Examples
    --------
    ```yaml
    anta.tests.bfd:
      - VerifyBFDSpecificPeers:
          bfd_peers:
            - peer_address: 192.0.255.8
              vrf: default
            - peer_address: 192.0.255.7
              vrf: default
    ```
    """

    categories: ClassVar[list[str]] = ["bfd"]
    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show bfd peers", revision=1)]

    class Input(AntaTest.Input):
        """Input model for the VerifyBFDSpecificPeers test."""

        bfd_peers: list[BFDPeer]
        """List of IPv4 BFD"""
        BFDPeer: ClassVar[type[BFDPeer]] = BFDPeer
        """To maintain backward compatibility."""

    @AntaTest.anta_test
    def test(self) -> None:
        """Main test function for VerifyBFDSpecificPeers."""
        self.result.is_success()

        # Iterating over BFD peers
        for bfd_peer in self.inputs.bfd_peers:
            peer = str(bfd_peer.peer_address)
            vrf = bfd_peer.vrf
            bfd_output = get_value(
                self.instance_commands[0].json_output,
                f"vrfs..{vrf}..ipv4Neighbors..{peer}..peerStats..",
                separator="..",
            )

            # Check if BFD peer configured
            if not bfd_output:
                self.result.is_failure(f"{bfd_peer} - Not found")
                continue

            # Check BFD peer status and remote disc
            state = bfd_output.get("status")
            remote_disc = bfd_output.get("remoteDisc")
            if not (state == "up" and remote_disc != 0):
                self.result.is_failure(f"{bfd_peer} - Session not properly established - State: {state} Remote Discriminator: {remote_disc}")

Input models

BFDPeer

BFD (Bidirectional Forwarding Detection) model representing the peer details.

Only IPv4 peers are supported for now.

Name Type Description Default
peer_address IPv4Address
IPv4 address of a BFD peer.
-
vrf str
Optional VRF for the BFD peer. Defaults to `default`.
'default'
tx_interval BfdInterval | None
Tx interval of BFD peer in milliseconds. Required field in the `VerifyBFDPeersIntervals` test.
None
rx_interval BfdInterval | None
Rx interval of BFD peer in milliseconds. Required field in the `VerifyBFDPeersIntervals` test.
None
multiplier BfdMultiplier | None
Multiplier of BFD peer. Required field in the `VerifyBFDPeersIntervals` test.
None
protocols list[BfdProtocol] | None
List of protocols to be verified. Required field in the `VerifyBFDPeersRegProtocols` test.
None
Source code in anta/input_models/bfd.py
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class BFDPeer(BaseModel):
    """BFD (Bidirectional Forwarding Detection) model representing the peer details.

    Only IPv4 peers are supported for now.
    """

    model_config = ConfigDict(extra="forbid")
    peer_address: IPv4Address
    """IPv4 address of a BFD peer."""
    vrf: str = "default"
    """Optional VRF for the BFD peer. Defaults to `default`."""
    tx_interval: BfdInterval | None = None
    """Tx interval of BFD peer in milliseconds. Required field in the `VerifyBFDPeersIntervals` test."""
    rx_interval: BfdInterval | None = None
    """Rx interval of BFD peer in milliseconds. Required field in the `VerifyBFDPeersIntervals` test."""
    multiplier: BfdMultiplier | None = None
    """Multiplier of BFD peer. Required field in the `VerifyBFDPeersIntervals` test."""
    protocols: list[BfdProtocol] | None = None
    """List of protocols to be verified. Required field in the `VerifyBFDPeersRegProtocols` test."""

    def __str__(self) -> str:
        """Return a human-readable string representation of the BFDPeer for reporting."""
        return f"Peer: {self.peer_address} VRF: {self.vrf}"