Skip to content

System

ANTA catalog for system tests

Test functions related to system-level features and protocols

VerifyAgentLogs

Bases: AntaTest

Verifies there is no agent crash reported on the device.

Source code in anta/tests/system.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
class VerifyAgentLogs(AntaTest):
    """
    Verifies there is no agent crash reported on the device.
    """

    name = "VerifyAgentLogs"
    description = "Verifies there is no agent crash reported on the device."
    categories = ["system"]
    commands = [AntaCommand(command="show agent logs crash", ofmt="text")]

    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifyAgentLogs validation
        """
        command_output = self.instance_commands[0].text_output

        if len(command_output) == 0:
            self.result.is_success()
        else:
            pattern = re.compile(r"^===> (.*?) <===$", re.MULTILINE)
            agents = "\n * ".join(pattern.findall(command_output))
            self.result.is_failure(f"device reported some agent logs:\n * {agents}")

test 

test() -> None

Run VerifyAgentLogs validation

Source code in anta/tests/system.py 
118
119
120
121
122
123
124
125
126
127
128
129
130
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyAgentLogs validation
    """
    command_output = self.instance_commands[0].text_output

    if len(command_output) == 0:
        self.result.is_success()
    else:
        pattern = re.compile(r"^===> (.*?) <===$", re.MULTILINE)
        agents = "\n * ".join(pattern.findall(command_output))
        self.result.is_failure(f"device reported some agent logs:\n * {agents}")

VerifyCPUUtilization

Bases: AntaTest

Verifies the CPU utilization is less than 75%.

Source code in anta/tests/system.py 
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
class VerifyCPUUtilization(AntaTest):
    """
    Verifies the CPU utilization is less than 75%.
    """

    name = "VerifyCPUUtilization"
    description = "Verifies the CPU utilization is less than 75%."
    categories = ["system"]
    commands = [AntaCommand(command="show processes top once")]

    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifyCPUUtilization validation
        """
        command_output = self.instance_commands[0].json_output
        command_output_data = command_output["cpuInfo"]["%Cpu(s)"]["idle"]

        if command_output_data > 25:
            self.result.is_success()
        else:
            self.result.is_failure(f"device reported a high CPU utilization ({100 - command_output_data}%)")

test 

test() -> None

Run VerifyCPUUtilization validation

Source code in anta/tests/system.py 
166
167
168
169
170
171
172
173
174
175
176
177
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyCPUUtilization validation
    """
    command_output = self.instance_commands[0].json_output
    command_output_data = command_output["cpuInfo"]["%Cpu(s)"]["idle"]

    if command_output_data > 25:
        self.result.is_success()
    else:
        self.result.is_failure(f"device reported a high CPU utilization ({100 - command_output_data}%)")

VerifyCoredump

Bases: AntaTest

Verifies there is no core file.

Source code in anta/tests/system.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
class VerifyCoredump(AntaTest):
    """
    Verifies there is no core file.
    """

    name = "VerifyCoredump"
    description = "Verifies there is no core file."
    categories = ["system"]
    commands = [AntaCommand(command="bash timeout 10 ls /var/core", ofmt="text")]

    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifyCoredump validation
        """
        command_output = self.instance_commands[0].text_output

        if len(command_output) == 0:
            self.result.is_success()
        else:
            self.result.is_failure(f"Core-dump(s) have been found: {command_output}")

test 

test() -> None

Run VerifyCoredump validation

Source code in anta/tests/system.py 
 95
 96
 97
 98
 99
100
101
102
103
104
105
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyCoredump validation
    """
    command_output = self.instance_commands[0].text_output

    if len(command_output) == 0:
        self.result.is_success()
    else:
        self.result.is_failure(f"Core-dump(s) have been found: {command_output}")

VerifyFileSystemUtilization

Bases: AntaTest

Verifies each partition on the disk is used less than 75%.

Source code in anta/tests/system.py 
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
class VerifyFileSystemUtilization(AntaTest):
    """
    Verifies each partition on the disk is used less than 75%.
    """

    name = "VerifyFileSystemUtilization"
    description = "Verifies each partition on the disk is used less than 75%."
    categories = ["system"]
    commands = [AntaCommand(command="bash timeout 10 df -h", ofmt="text")]

    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifyFileSystemUtilization validation
        """
        command_output = self.instance_commands[0].text_output

        self.result.is_success()

        for line in command_output.split("\n")[1:]:
            if "loop" not in line and len(line) > 0 and (percentage := int(line.split()[4].replace("%", ""))) > 75:
                self.result.is_failure(f"mount point {line} is higher than 75% (reported {percentage})")

test 

test() -> None

Run VerifyFileSystemUtilization validation

Source code in anta/tests/system.py 
214
215
216
217
218
219
220
221
222
223
224
225
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyFileSystemUtilization validation
    """
    command_output = self.instance_commands[0].text_output

    self.result.is_success()

    for line in command_output.split("\n")[1:]:
        if "loop" not in line and len(line) > 0 and (percentage := int(line.split()[4].replace("%", ""))) > 75:
            self.result.is_failure(f"mount point {line} is higher than 75% (reported {percentage})")

VerifyMemoryUtilization

Bases: AntaTest

Verifies the Memory utilization is less than 75%.

Source code in anta/tests/system.py 
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
class VerifyMemoryUtilization(AntaTest):
    """
    Verifies the Memory utilization is less than 75%.
    """

    name = "VerifyMemoryUtilization"
    description = "Verifies the Memory utilization is less than 75%."
    categories = ["system"]
    commands = [AntaCommand(command="show version")]

    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifyMemoryUtilization validation
        """
        command_output = self.instance_commands[0].json_output

        memory_usage = command_output["memFree"] / command_output["memTotal"]
        if memory_usage > 0.25:
            self.result.is_success()
        else:
            self.result.is_failure(f"device report a high memory usage: {(1 - memory_usage)*100:.2f}%")

test 

test() -> None

Run VerifyMemoryUtilization validation

Source code in anta/tests/system.py 
190
191
192
193
194
195
196
197
198
199
200
201
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyMemoryUtilization validation
    """
    command_output = self.instance_commands[0].json_output

    memory_usage = command_output["memFree"] / command_output["memTotal"]
    if memory_usage > 0.25:
        self.result.is_success()
    else:
        self.result.is_failure(f"device report a high memory usage: {(1 - memory_usage)*100:.2f}%")

VerifyNTP

Bases: AntaTest

Verifies NTP is synchronised.

Source code in anta/tests/system.py 
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
class VerifyNTP(AntaTest):
    """
    Verifies NTP is synchronised.
    """

    name = "VerifyNTP"
    description = "Verifies NTP is synchronised."
    categories = ["system"]
    commands = [AntaCommand(command="show ntp status", ofmt="text")]

    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifyNTP validation
        """
        command_output = self.instance_commands[0].text_output

        if command_output.split("\n")[0].split(" ")[0] == "synchronised":
            self.result.is_success()
        else:
            data = command_output.split("\n")[0]
            self.result.is_failure(f"not sync with NTP server ({data})")

test 

test() -> None

Run VerifyNTP validation

Source code in anta/tests/system.py 
238
239
240
241
242
243
244
245
246
247
248
249
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyNTP validation
    """
    command_output = self.instance_commands[0].text_output

    if command_output.split("\n")[0].split(" ")[0] == "synchronised":
        self.result.is_success()
    else:
        data = command_output.split("\n")[0]
        self.result.is_failure(f"not sync with NTP server ({data})")

VerifyReloadCause

Bases: AntaTest

Verifies the last reload of the device was requested by a user.

Test considers the following messages as normal and will return success. Failure is for other messages * Reload requested by the user. * Reload requested after FPGA upgrade

Source code in anta/tests/system.py 
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
class VerifyReloadCause(AntaTest):
    """
    Verifies the last reload of the device was requested by a user.

    Test considers the following messages as normal and will return success. Failure is for other messages
    * Reload requested by the user.
    * Reload requested after FPGA upgrade
    """

    name = "VerifyReloadCause"
    description = "Verifies the device uptime is higher than a value."
    categories = ["system"]
    commands = [AntaCommand(command="show reload cause")]

    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifyReloadCause validation
        """

        command_output = self.instance_commands[0].json_output

        if "resetCauses" not in command_output.keys():
            self.result.is_error("no reload cause available")
            return

        if len(command_output["resetCauses"]) == 0:
            # No reload causes
            self.result.is_success()
            return

        reset_causes = command_output["resetCauses"]
        command_output_data = reset_causes[0].get("description")
        if command_output_data in [
            "Reload requested by the user.",
            "Reload requested after FPGA upgrade",
        ]:
            self.result.is_success()
        else:
            self.result.is_failure(f"Reload cause is {command_output_data}")

test 

test() -> None

Run VerifyReloadCause validation

Source code in anta/tests/system.py 
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
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyReloadCause validation
    """

    command_output = self.instance_commands[0].json_output

    if "resetCauses" not in command_output.keys():
        self.result.is_error("no reload cause available")
        return

    if len(command_output["resetCauses"]) == 0:
        # No reload causes
        self.result.is_success()
        return

    reset_causes = command_output["resetCauses"]
    command_output_data = reset_causes[0].get("description")
    if command_output_data in [
        "Reload requested by the user.",
        "Reload requested after FPGA upgrade",
    ]:
        self.result.is_success()
    else:
        self.result.is_failure(f"Reload cause is {command_output_data}")

VerifySyslog

Bases: AntaTest

Verifies the device had no syslog message with a severity of warning (or a more severe message) during the last 7 days.

Source code in anta/tests/system.py 
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
class VerifySyslog(AntaTest):
    """
    Verifies the device had no syslog message with a severity of warning (or a more severe message) during the last 7 days.
    """

    name = "VerifySyslog"
    description = "Verifies the device had no syslog message with a severity of warning (or a more severe message) during the last 7 days."
    categories = ["system"]
    commands = [AntaCommand(command="show logging last 7 days threshold warnings", ofmt="text")]

    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifySyslog validation
        """
        command_output = self.instance_commands[0].text_output

        if len(command_output) == 0:
            self.result.is_success()
        else:
            self.result.is_failure("Device has some log messages with a severity WARNING or higher")

test 

test() -> None

Run VerifySyslog validation

Source code in anta/tests/system.py 
143
144
145
146
147
148
149
150
151
152
153
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifySyslog validation
    """
    command_output = self.instance_commands[0].text_output

    if len(command_output) == 0:
        self.result.is_success()
    else:
        self.result.is_failure("Device has some log messages with a severity WARNING or higher")

VerifyUptime

Bases: AntaTest

Verifies the device uptime is higher than a value.

Source code in anta/tests/system.py 
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
class VerifyUptime(AntaTest):
    """
    Verifies the device uptime is higher than a value.
    """

    name = "VerifyUptime"
    description = "Verifies the device uptime is higher than a value."
    categories = ["system"]
    commands = [AntaCommand(command="show uptime")]

    @AntaTest.anta_test
    def test(self, minimum: Optional[int] = None) -> None:
        """
        Run VerifyUptime validation

        Args:
            minimum: Minimum uptime in seconds.
        """

        command_output = self.instance_commands[0].json_output

        if not (isinstance(minimum, (int, float))) or minimum < 0:
            self.result.is_skipped("VerifyUptime was not run as incorrect minimum uptime was given")
            return

        if command_output["upTime"] > minimum:
            self.result.is_success()
        else:
            self.result.is_failure(f"Uptime is {command_output['upTime']}")

test 

test(minimum: Optional[int] = None) -> None

Run VerifyUptime validation

Parameters:

Name Type Description Default
minimum Optional[int]

Minimum uptime in seconds.

 None
Source code in anta/tests/system.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@AntaTest.anta_test
def test(self, minimum: Optional[int] = None) -> None:
    """
    Run VerifyUptime validation

    Args:
        minimum: Minimum uptime in seconds.
    """

    command_output = self.instance_commands[0].json_output

    if not (isinstance(minimum, (int, float))) or minimum < 0:
        self.result.is_skipped("VerifyUptime was not run as incorrect minimum uptime was given")
        return

    if command_output["upTime"] > minimum:
        self.result.is_success()
    else:
        self.result.is_failure(f"Uptime is {command_output['upTime']}")
Last update: July 19, 2023