1 # Copyright (c) 2023 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
6 # http://www.apache.org/licenses/LICENSE-2.0
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
14 """Module with keywords that publish parts of result structure."""
16 from robot.libraries.BuiltIn import BuiltIn
18 from resources.libraries.python.model.util import descend, get_export_data
21 def export_dut_type_and_version(dut_type="unknown", dut_version="unknown"):
22 """Export the arguments as dut type and version.
24 Robot tends to convert "none" into None, hence the unusual default values.
26 If either argument is missing, the value from robot variable is used.
27 If argument is present, the value is also stored to robot suite variable.
29 :param dut_type: DUT type, e.g. VPP or DPDK.
30 :param dut_version: DUT version as determined by the caller.
31 :type dut_type: Optional[str]
32 :type dut_version: Optiona[str]
33 :raises RuntimeError: If value is neither in argument not robot variable.
35 if dut_type == "unknown":
36 dut_type = BuiltIn().get_variable_value("\\${DUT_TYPE}", "unknown")
37 if dut_type == "unknown":
38 raise RuntimeError("Dut type not provided.")
40 # We want to set a variable in higher level suite setup
41 # to be available to test setup several levels lower.
42 BuiltIn().set_suite_variable(
43 "\\${DUT_TYPE}", dut_type, "children=True"
45 if dut_version == "unknown":
46 dut_version = BuiltIn().get_variable_value(
47 "\\${DUT_VERSION}", "unknown"
49 if dut_type == "unknown":
50 raise RuntimeError("Dut version not provided.")
52 BuiltIn().set_suite_variable(
53 "\\${DUT_VERSION}", dut_version, "children=True"
55 data = get_export_data()
56 data["dut_type"] = dut_type.lower()
57 data["dut_version"] = dut_version
60 def export_tg_type_and_version(tg_type="unknown", tg_version="unknown"):
61 """Export the arguments as tg type and version.
63 Robot tends to convert "none" into None, hence the unusual default values.
65 If either argument is missing, the value from robot variable is used.
66 If argument is present, the value is also stored to robot suite variable.
68 :param tg_type: TG type, e.g. TREX.
69 :param tg_version: TG version as determined by the caller.
70 :type tg_type: Optional[str]
71 :type tg_version: Optiona[str]
72 :raises RuntimeError: If value is neither in argument not robot variable.
74 if tg_type == "unknown":
75 tg_type = BuiltIn().get_variable_value("\\${TG_TYPE}", "unknown")
76 if tg_type == "unknown":
77 raise RuntimeError("TG type not provided!")
79 # We want to set a variable in higher level suite setup
80 # to be available to test setup several levels lower.
81 BuiltIn().set_suite_variable(
82 "\\${TG_TYPE}", tg_type, "children=True"
84 if tg_version == "unknown":
85 tg_version = BuiltIn().get_variable_value(
86 "\\${TG_VERSION}", "unknown"
88 if tg_type == "unknown":
89 raise RuntimeError("TG version not provided!")
91 BuiltIn().set_suite_variable(
92 "\\${TG_VERSION}", tg_version, "children=True"
94 data = get_export_data()
95 data["tg_type"] = tg_type.lower()
96 data["tg_version"] = tg_version
99 def append_mrr_value(mrr_value, mrr_unit, bandwidth_value=None,
100 bandwidth_unit="bps"):
101 """Store mrr value to proper place so it is dumped into json.
103 The value is appended only when unit is not empty.
105 :param mrr_value: Forwarding rate from MRR trial.
106 :param mrr_unit: Unit of measurement for the rate.
107 :param bandwidth_value: The same value recomputed into L1 bits per second.
108 :type mrr_value: float
110 :type bandwidth_value: Optional[float]
111 :type bandwidth_unit: Optional[str]
115 data = get_export_data()
116 data["result"]["type"] = "mrr"
118 for node_val, node_unit, node_name in ((mrr_value, mrr_unit, "rate"),
119 (bandwidth_value, bandwidth_unit, "bandwidth")):
120 if node_val is not None:
121 node = descend(descend(data["result"], "receive_rate"), node_name)
122 node["unit"] = str(node_unit)
123 values_list = descend(node, "values", list)
124 values_list.append(float(node_val))
127 def export_search_bound(text, value, unit, bandwidth=None):
128 """Store bound value and unit.
130 This function works for both NDRPDR and SOAK, decided by text.
132 If a node does not exist, it is created.
133 If a previous value exists, it is overwritten silently.
134 Result type is set (overwritten) to ndrpdr (or soak).
136 Text is used to determine whether it is ndr or pdr, upper or lower bound,
137 as the Robot caller has the information only there.
139 :param text: Info from Robot caller to determime bound type.
140 :param value: The bound value in packets (or connections) per second.
141 :param unit: Rate unit the bound is measured (or estimated) in.
142 :param bandwidth: The same value recomputed into L1 bits per second.
146 :type bandwidth: Optional[float]
149 text = str(text).lower()
150 result_type = "soak" if "plrsearch" in text else "ndrpdr"
151 upper_or_lower = "upper" if "upper" in text else "lower"
152 ndr_or_pdr = "ndr" if "ndr" in text else "pdr"
154 result_node = get_export_data()["result"]
155 result_node["type"] = result_type
156 rate_item = dict(rate=dict(value=value, unit=unit))
158 rate_item["bandwidth"] = dict(value=float(bandwidth), unit="bps")
159 if result_type == "soak":
160 descend(result_node, "critical_rate")[upper_or_lower] = rate_item
162 descend(result_node, ndr_or_pdr)[upper_or_lower] = rate_item
165 def _add_latency(result_node, percent, whichward, latency_string):
166 """Descend to a corresponding node and add values from latency string.
168 This is an internal block, moved out from export_ndrpdr_latency,
169 as it can be called up to 4 times.
171 :param result_node: UTI tree node to descend from.
172 :param percent: Percent value to use in node key (90, 50, 10, 0).
173 :param whichward: "forward" or "reverse".
174 :param latency_item: Unidir output from TRex utility, min/avg/max/hdrh.
175 :type result_node: dict
180 l_min, l_avg, l_max, l_hdrh = latency_string.split("/", 3)
181 whichward_node = descend(result_node, f"latency_{whichward}")
182 percent_node = descend(whichward_node, f"pdr_{percent}")
183 percent_node["min"] = int(l_min)
184 percent_node["avg"] = int(l_avg)
185 percent_node["max"] = int(l_max)
186 percent_node["hdrh"] = l_hdrh
187 percent_node["unit"] = "us"
190 def export_ndrpdr_latency(text, latency):
191 """Store NDRPDR hdrh latency data.
193 If "latency" node does not exist, it is created.
194 If a previous value exists, it is overwritten silently.
196 Text is used to determine what percentage of PDR is the load,
197 as the Robot caller has the information only there.
199 Reverse data may be missing, we assume the test was unidirectional.
201 :param text: Info from Robot caller to determime load.
202 :param latency: Output from TRex utility, min/avg/max/hdrh.
204 :type latency: 1-tuple or 2-tuple of str
206 result_node = get_export_data()["result"]
214 _add_latency(result_node, percent, "forward", latency[0])
215 # Else TRex does not support latency measurement for this traffic profile.
218 _add_latency(result_node, percent, "reverse", latency[1])
221 def export_reconf_result(packet_rate, packet_loss, bandwidth):
222 """Export the RECONF type results.
224 Result type is set to reconf.
226 :param packet_rate: Aggregate offered load in packets per second.
227 :param packet_loss: How many of the packets were dropped or unsent.
228 :param bandwidth: The offered load recomputed into L1 bits per second.
229 :type packet_rate: float
230 :type packet_loss: int
231 :type bandwidth: float
233 result_node = get_export_data()["result"]
234 result_node["type"] = "reconf"
236 time_loss = int(packet_loss) / float(packet_rate)
237 result_node["aggregate_rate"] = dict(
240 value=float(bandwidth)
244 value=float(packet_rate)
247 result_node["loss"] = dict(
250 value=int(packet_loss)
259 def export_hoststack_results(
260 bandwidth, rate=None, rate_unit=None, latency=None,
261 failed_requests=None, completed_requests=None, retransmits=None,
264 """Export the HOSTSTACK type results.
266 Result type is set to hoststack.
268 :param bandwidth: Measured transfer rate using bps as a unit.
269 :param rate: Resulting rate measured by the test. [Optional]
270 :param rate_unit: CPS or RPS. [Optional]
271 :param latency: Measure latency. [Optional]
272 :param failed_requests: Number of failed requests. [Optional]
273 :param completed_requests: Number of completed requests. [Optional]
274 :param retransmits: Retransmitted TCP packets. [Optional]
275 :param duration: Measurment duration. [Optional]
276 :type bandwidth: float
280 :type failed_requests: int
281 :type completed_requests: int
282 :type retransmits: int
283 :type duration: float
285 result_node = get_export_data()["result"]
286 result_node["type"] = "hoststack"
288 result_node["bandwidth"] = dict(unit="bps", value=bandwidth)
290 result_node["rate"] = \
291 dict(unit=rate_unit, value=rate)
292 if latency is not None:
293 result_node["latency"] = \
294 dict(unit="ms", value=latency)
295 if failed_requests is not None:
296 result_node["failed_requests"] = \
297 dict(unit="requests", value=failed_requests)
298 if completed_requests is not None:
299 result_node["completed_requests"] = \
300 dict(unit="requests", value=completed_requests)
301 if retransmits is not None:
302 result_node["retransmits"] = \
303 dict(unit="packets", value=retransmits)
304 if duration is not None:
305 result_node["duration"] = \
306 dict(unit="s", value=duration)
309 def append_telemetry(telemetry_item):
310 """Append telemetry entry to proper place so it is dumped into json.
312 :param telemetry_item: Telemetry entry.
313 :type telemetry_item: str
315 data = get_export_data()
316 data["telemetry"].append(telemetry_item)