1 # The MIT License (MIT)
3 # Copyright (c) 2015-2020 Philippe Proulx <pproulx@efficios.com>
5 # Permission is hereby granted, free of charge, to any person obtaining
6 # a copy of this software and associated documentation files (the
7 # "Software"), to deal in the Software without restriction, including
8 # without limitation the rights to use, copy, modify, merge, publish,
9 # distribute, sublicense, and/or sell copies of the Software, and to
10 # permit persons to whom the Software is furnished to do so, subject to
11 # the following conditions:
13 # The above copyright notice and this permission notice shall be
14 # included in all copies or substantial portions of the Software.
16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 # IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 # CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 from barectf
.config_parse_common
import _ConfigurationParseError
25 from barectf
.config_parse_common
import _append_error_ctx
26 import barectf
.config_parse_common
as config_parse_common
27 from barectf
.config_parse_common
import _MapNode
30 from barectf
.typing
import VersionNumber
, _OptStr
31 from typing
import Optional
, List
, Dict
, TextIO
, Union
, Callable
35 def _del_prop_if_exists(node
: _MapNode
, prop_name
: str):
40 def _rename_prop(node
: _MapNode
, old_prop_name
: str, new_prop_name
: str):
41 if old_prop_name
in node
:
42 node
[new_prop_name
] = node
[old_prop_name
]
43 del node
[old_prop_name
]
46 def _copy_prop_if_exists(dst_node
: _MapNode
, src_node
: _MapNode
, src_prop_name
: str,
47 dst_prop_name
: _OptStr
= None):
48 if dst_prop_name
is None:
49 dst_prop_name
= src_prop_name
51 if src_prop_name
in src_node
:
52 dst_node
[dst_prop_name
] = copy
.deepcopy(src_node
[src_prop_name
])
55 # A barectf 2 YAML configuration parser.
57 # The only purpose of such a parser is to transform the passed root
58 # configuration node so that it's a valid barectf 3 configuration node.
60 # The parser's `config_node` property is the equivalent barectf 3
63 # See the comments of _parse() for more implementation details about the
64 # parsing stages and general strategy.
65 class _Parser(config_parse_common
._Parser
):
66 # Builds a barectf 2 YAML configuration parser and parses the root
67 # configuration node `node` (already loaded from the file-like
68 # object `root_file`).
69 def __init__(self
, root_file
: TextIO
, node
: _MapNode
, with_pkg_include_dir
: bool,
70 include_dirs
: Optional
[List
[str]], ignore_include_not_found
: bool):
71 super().__init
__(root_file
, node
, with_pkg_include_dir
, include_dirs
,
72 ignore_include_not_found
, VersionNumber(2))
73 self
._ft
_cls
_name
_to
_conv
_method
: Dict
[str, Callable
[[_MapNode
], _MapNode
]] = {
74 'int': self
._conv
_int
_ft
_node
,
75 'integer': self
._conv
_int
_ft
_node
,
76 'enum': self
._conv
_enum
_ft
_node
,
77 'enumeration': self
._conv
_enum
_ft
_node
,
78 'flt': self
._conv
_real
_ft
_node
,
79 'float': self
._conv
_real
_ft
_node
,
80 'floating-point': self
._conv
_real
_ft
_node
,
81 'str': self
._conv
_string
_ft
_node
,
82 'string': self
._conv
_string
_ft
_node
,
83 'array': self
._conv
_static
_array
_ft
_node
,
84 'struct': self
._conv
_struct
_ft
_node
,
85 'structure': self
._conv
_struct
_ft
_node
,
89 # Converts a v2 field type node to a v3 field type node and returns
91 def _conv_ft_node(self
, v2_ft_node
: _MapNode
) -> _MapNode
:
92 assert 'class' in v2_ft_node
93 cls
= v2_ft_node
['class']
94 assert cls
in self
._ft
_cls
_name
_to
_conv
_method
95 return self
._ft
_cls
_name
_to
_conv
_method
[cls
](v2_ft_node
)
97 def _conv_ft_node_if_exists(self
, v2_parent_node
: Optional
[_MapNode
], key
: str) -> Optional
[_MapNode
]:
98 if v2_parent_node
is None:
101 if key
not in v2_parent_node
:
104 return self
._conv
_ft
_node
(v2_parent_node
[key
])
106 # Converts a v2 integer field type node to a v3 integer field type
107 # node and returns it.
108 def _conv_int_ft_node(self
, v2_ft_node
: _MapNode
) -> _MapNode
:
109 # copy v2 integer field type node
110 v3_ft_node
= copy
.deepcopy(v2_ft_node
)
112 # signedness depends on the class, not a property
115 is_signed_node
= v3_ft_node
.get(prop_name
)
117 if is_signed_node
is True:
120 v3_ft_node
['class'] = cls_name
121 _del_prop_if_exists(v3_ft_node
, prop_name
)
123 # rename `align` property to `alignment`
124 _rename_prop(v3_ft_node
, 'align', 'alignment')
126 # rename `base` property to `preferred-display-base`
127 _rename_prop(v3_ft_node
, 'base', 'preferred-display-base')
129 # remove `encoding` property
130 _del_prop_if_exists(v3_ft_node
, 'encoding')
132 # remove `property-mappings` property
133 _del_prop_if_exists(v3_ft_node
, 'property-mappings')
137 # Converts a v2 enumeration field type node to a v3 enumeration
138 # field type node and returns it.
139 def _conv_enum_ft_node(self
, v2_ft_node
: _MapNode
) -> _MapNode
:
140 # An enumeration field type _is_ an integer field type, so use a
141 # copy of the converted v2 value field type node.
142 v3_ft_node
= copy
.deepcopy(self
._conv
_ft
_node
(v2_ft_node
['value-type']))
144 # transform class name accordingly
148 if v3_ft_node
[prop_name
] == 'sint':
151 v3_ft_node
[prop_name
] = cls_name
153 # convert members to mappings
154 prop_name
= 'members'
155 members_node
= v2_ft_node
.get(prop_name
)
157 if members_node
is not None:
158 mappings_node
: _MapNode
= collections
.OrderedDict()
161 for member_node
in members_node
:
162 v3_value_node
: Union
[int, List
[int]]
164 if type(member_node
) is str:
169 assert type(member_node
) is collections
.OrderedDict
170 label
= member_node
['label']
171 v2_value_node
= member_node
['value']
173 if type(v2_value_node
) is int:
174 cur
= v2_value_node
+ 1
175 v3_value_node
= v2_value_node
177 assert type(v2_value_node
) is list
178 assert len(v2_value_node
) == 2
179 v3_value_node
= list(v2_value_node
)
180 cur
= v2_value_node
[1] + 1
182 if label
not in mappings_node
:
183 mappings_node
[label
] = []
185 mappings_node
[label
].append(v3_value_node
)
187 v3_ft_node
['mappings'] = mappings_node
191 # Converts a v2 real field type node to a v3 real field type node
193 def _conv_real_ft_node(self
, v2_ft_node
: _MapNode
) -> _MapNode
:
194 # copy v2 real field type node
195 v3_ft_node
= copy
.deepcopy(v2_ft_node
)
197 # set class to `real`
198 v3_ft_node
['class'] = 'real'
200 # rename `align` property to `alignment`
201 _rename_prop(v3_ft_node
, 'align', 'alignment')
203 # set `size` property to a single integer (total size, in bits)
205 v3_ft_node
[prop_name
] = v3_ft_node
[prop_name
]['exp'] + v3_ft_node
[prop_name
]['mant']
209 # Converts a v2 string field type node to a v3 string field type
210 # node and returns it.
211 def _conv_string_ft_node(self
, v2_ft_node
: _MapNode
) -> _MapNode
:
212 # copy v2 string field type node
213 v3_ft_node
= copy
.deepcopy(v2_ft_node
)
215 # remove `encoding` property
216 _del_prop_if_exists(v3_ft_node
, 'encoding')
220 # Converts a v2 array field type node to a v3 (static) array field
221 # type node and returns it.
222 def _conv_static_array_ft_node(self
, v2_ft_node
: _MapNode
) -> _MapNode
:
223 # class renamed to `static-array`
224 v3_ft_node
: _MapNode
= collections
.OrderedDict({'class': 'static-array'})
226 # copy `length` property
227 _copy_prop_if_exists(v3_ft_node
, v2_ft_node
, 'length')
229 # convert element field type
230 v3_ft_node
['element-field-type'] = self
._conv
_ft
_node
(v2_ft_node
['element-type'])
234 # Converts a v2 structure field type node to a v3 structure field
235 # type node and returns it.
236 def _conv_struct_ft_node(self
, v2_ft_node
: _MapNode
) -> _MapNode
:
237 # Create fresh v3 structure field type node, reusing the class
239 v3_ft_node
= collections
.OrderedDict({'class': v2_ft_node
['class']})
241 # rename `min-align` property to `minimum-alignment`
242 _copy_prop_if_exists(v3_ft_node
, v2_ft_node
, 'min-align', 'minimum-alignment')
244 # convert fields to members
247 if prop_name
in v2_ft_node
:
250 for member_name
, v2_member_ft_node
in v2_ft_node
[prop_name
].items():
251 members_node
.append(collections
.OrderedDict({
252 member_name
: collections
.OrderedDict({
253 'field-type': self
._conv
_ft
_node
(v2_member_ft_node
)
257 v3_ft_node
['members'] = members_node
261 # Converts a v2 clock type node to a v3 clock type node and returns
263 def _conv_clk_type_node(self
, v2_clk_type_node
: _MapNode
) -> _MapNode
:
264 # copy v2 clock type node
265 v3_clk_type_node
= copy
.deepcopy(v2_clk_type_node
)
267 # rename `freq` property to `frequency`
268 _rename_prop(v3_clk_type_node
, 'freq', 'frequency')
270 # rename `error-cycles` property to `precision`
271 _rename_prop(v3_clk_type_node
, 'error-cycles', 'precision')
273 # rename `absolute` property to `origin-is-unix-epoch`
274 _rename_prop(v3_clk_type_node
, 'absolute', 'origin-is-unix-epoch')
276 # rename `$return-ctype`/`return-ctype` property to `$c-type`
277 new_prop_name
= '$c-type'
278 _rename_prop(v3_clk_type_node
, 'return-ctype', new_prop_name
)
279 _rename_prop(v3_clk_type_node
, '$return-ctype', new_prop_name
)
281 return v3_clk_type_node
283 # Converts a v2 event type node to a v3 event type node and returns
285 def _conv_ev_type_node(self
, v2_ev_type_node
: _MapNode
) -> _MapNode
:
286 # create empty v3 event type node
287 v3_ev_type_node
: _MapNode
= collections
.OrderedDict()
289 # copy `log-level` property
290 _copy_prop_if_exists(v3_ev_type_node
, v2_ev_type_node
, 'log-level')
292 # convert specific context field type node
293 v2_ft_node
= v2_ev_type_node
.get('context-type')
295 if v2_ft_node
is not None:
296 v3_ev_type_node
['specific-context-field-type'] = self
._conv
_ft
_node
(v2_ft_node
)
298 # convert payload field type node
299 v2_ft_node
= v2_ev_type_node
.get('payload-type')
301 if v2_ft_node
is not None:
302 v3_ev_type_node
['payload-field-type'] = self
._conv
_ft
_node
(v2_ft_node
)
304 return v3_ev_type_node
307 def _set_v3_feature_ft_if_exists(v3_features_node
: _MapNode
, key
: str,
308 node
: Union
[Optional
[_MapNode
], bool]):
314 v3_features_node
[key
] = val
316 # Converts a v2 stream type node to a v3 stream type node and
318 def _conv_stream_type_node(self
, v2_stream_type_node
: _MapNode
) -> _MapNode
:
319 # This function creates a v3 stream type features node from the
320 # packet context and event header field type nodes of a
321 # v2 stream type node.
322 def v3_features_node_from_v2_ft_nodes(v2_pkt_ctx_ft_fields_node
: _MapNode
,
323 v2_ev_header_ft_fields_node
: Optional
[_MapNode
]) -> _MapNode
:
324 if v2_ev_header_ft_fields_node
is None:
325 v2_ev_header_ft_fields_node
= collections
.OrderedDict()
327 v3_pkt_total_size_ft_node
= self
._conv
_ft
_node
(v2_pkt_ctx_ft_fields_node
['packet_size'])
328 v3_pkt_content_size_ft_node
= self
._conv
_ft
_node
(v2_pkt_ctx_ft_fields_node
['content_size'])
329 v3_pkt_beg_time_ft_node
= self
._conv
_ft
_node
_if
_exists
(v2_pkt_ctx_ft_fields_node
,
331 v3_pkt_end_time_ft_node
= self
._conv
_ft
_node
_if
_exists
(v2_pkt_ctx_ft_fields_node
,
333 v3_pkt_disc_ev_counter_ft_node
= self
._conv
_ft
_node
_if
_exists
(v2_pkt_ctx_ft_fields_node
,
335 v3_ev_type_id_ft_node
= self
._conv
_ft
_node
_if
_exists
(v2_ev_header_ft_fields_node
, 'id')
336 v3_ev_time_ft_node
= self
._conv
_ft
_node
_if
_exists
(v2_ev_header_ft_fields_node
,
338 v3_features_node
: _MapNode
= collections
.OrderedDict()
339 v3_pkt_node
: _MapNode
= collections
.OrderedDict()
340 v3_ev_node
: _MapNode
= collections
.OrderedDict()
341 v3_pkt_node
['total-size-field-type'] = v3_pkt_total_size_ft_node
342 v3_pkt_node
['content-size-field-type'] = v3_pkt_content_size_ft_node
343 self
._set
_v
3_feature
_ft
_if
_exists
(v3_pkt_node
, 'beginning-time-field-type',
344 v3_pkt_beg_time_ft_node
)
345 self
._set
_v
3_feature
_ft
_if
_exists
(v3_pkt_node
, 'end-time-field-type',
346 v3_pkt_end_time_ft_node
)
347 self
._set
_v
3_feature
_ft
_if
_exists
(v3_pkt_node
, 'discarded-events-counter-field-type',
348 v3_pkt_disc_ev_counter_ft_node
)
349 self
._set
_v
3_feature
_ft
_if
_exists
(v3_ev_node
, 'type-id-field-type',
350 v3_ev_type_id_ft_node
)
351 self
._set
_v
3_feature
_ft
_if
_exists
(v3_ev_node
, 'time-field-type', v3_ev_time_ft_node
)
352 v3_features_node
['packet'] = v3_pkt_node
353 v3_features_node
['event'] = v3_ev_node
354 return v3_features_node
356 def clk_type_name_from_v2_int_ft_node(v2_int_ft_node
: Optional
[_MapNode
]) -> _OptStr
:
357 if v2_int_ft_node
is None:
360 assert v2_int_ft_node
['class'] in ('int', 'integer')
361 prop_mappings_node
= v2_int_ft_node
.get('property-mappings')
363 if prop_mappings_node
is not None and len(prop_mappings_node
) > 0:
364 return prop_mappings_node
[0]['name']
368 # create empty v3 stream type node
369 v3_stream_type_node
: _MapNode
= collections
.OrderedDict()
371 # rename `$default` property to `$is-default`
372 _copy_prop_if_exists(v3_stream_type_node
, v2_stream_type_node
, '$default', '$is-default')
374 # set default clock type node
375 pct_prop_name
= 'packet-context-type'
376 v2_pkt_ctx_ft_fields_node
= v2_stream_type_node
[pct_prop_name
]['fields']
377 eht_prop_name
= 'event-header-type'
378 v2_ev_header_ft_fields_node
= None
379 v2_ev_header_ft_node
= v2_stream_type_node
.get(eht_prop_name
)
381 if v2_ev_header_ft_node
is not None:
382 v2_ev_header_ft_fields_node
= v2_ev_header_ft_node
['fields']
384 def_clk_type_name
= None
387 ts_begin_prop_name
= 'timestamp_begin'
388 ts_begin_clk_type_name
= clk_type_name_from_v2_int_ft_node(v2_pkt_ctx_ft_fields_node
.get(ts_begin_prop_name
))
389 ts_end_prop_name
= 'timestamp_end'
390 ts_end_clk_type_name
= clk_type_name_from_v2_int_ft_node(v2_pkt_ctx_ft_fields_node
.get(ts_end_prop_name
))
392 if ts_begin_clk_type_name
is not None and ts_end_clk_type_name
is not None:
393 if ts_begin_clk_type_name
!= ts_end_clk_type_name
:
394 raise _ConfigurationParseError(f
'`{ts_begin_prop_name}`/`{ts_end_prop_name}` properties',
395 'Field types are not mapped to the same clock type')
396 except _ConfigurationParseError
as exc
:
397 _append_error_ctx(exc
, f
'`{pct_prop_name}` property')
400 if def_clk_type_name
is None and v2_ev_header_ft_fields_node
is not None:
401 def_clk_type_name
= clk_type_name_from_v2_int_ft_node(v2_ev_header_ft_fields_node
.get('timestamp'))
403 if def_clk_type_name
is None and ts_begin_clk_type_name
is not None:
404 def_clk_type_name
= ts_begin_clk_type_name
406 if def_clk_type_name
is None and ts_end_clk_type_name
is not None:
407 def_clk_type_name
= ts_end_clk_type_name
408 except _ConfigurationParseError
as exc
:
409 _append_error_ctx(exc
, f
'`{eht_prop_name}` property')
411 if def_clk_type_name
is not None:
412 v3_stream_type_node
['$default-clock-type-name'] = def_clk_type_name
415 v3_stream_type_node
['$features'] = v3_features_node_from_v2_ft_nodes(v2_pkt_ctx_ft_fields_node
,
416 v2_ev_header_ft_fields_node
)
418 # set extra packet context field type members node
419 pkt_ctx_ft_extra_members
= []
429 for member_name
, v2_ft_node
in v2_pkt_ctx_ft_fields_node
.items():
430 if member_name
in ctf_member_names
:
433 pkt_ctx_ft_extra_members
.append(collections
.OrderedDict({
434 member_name
: collections
.OrderedDict({
435 'field-type': self
._conv
_ft
_node
(v2_ft_node
)
439 if len(pkt_ctx_ft_extra_members
) > 0:
440 v3_stream_type_node
['packet-context-field-type-extra-members'] = pkt_ctx_ft_extra_members
442 # convert event common context field type node
443 v2_ft_node
= v2_stream_type_node
.get('event-context-type')
445 if v2_ft_node
is not None:
446 v3_stream_type_node
['event-common-context-field-type'] = self
._conv
_ft
_node
(v2_ft_node
)
448 # convert event type nodes
449 v3_event_types_node
= collections
.OrderedDict()
451 for ev_type_name
, v2_ev_type_node
in v2_stream_type_node
['events'].items():
453 v3_event_types_node
[ev_type_name
] = self
._conv
_ev
_type
_node
(v2_ev_type_node
)
454 except _ConfigurationParseError
as exc
:
455 _append_error_ctx(exc
, f
'Event type `{ev_type_name}`')
457 v3_stream_type_node
['event-types'] = v3_event_types_node
459 return v3_stream_type_node
461 # Converts a v2 metadata node to a v3 trace node and returns it.
462 def _conv_meta_node(self
, v2_meta_node
: _MapNode
) -> _MapNode
:
463 def v3_features_node_from_v2_ft_node(v2_pkt_header_ft_node
: Optional
[_MapNode
]) -> _MapNode
:
464 def set_if_exists(key
, node
):
465 return self
._set
_v
3_feature
_ft
_if
_exists
(v3_features_node
, key
, node
)
467 v2_pkt_header_ft_fields_node
= collections
.OrderedDict()
469 if v2_pkt_header_ft_node
is not None:
470 v2_pkt_header_ft_fields_node
= v2_pkt_header_ft_node
['fields']
472 v3_magic_ft_node
= self
._conv
_ft
_node
_if
_exists
(v2_pkt_header_ft_fields_node
, 'magic')
473 v3_uuid_ft_node
= self
._conv
_ft
_node
_if
_exists
(v2_pkt_header_ft_fields_node
, 'uuid')
474 v3_stream_type_id_ft_node
= self
._conv
_ft
_node
_if
_exists
(v2_pkt_header_ft_fields_node
,
476 v3_features_node
: _MapNode
= collections
.OrderedDict()
477 set_if_exists('magic-field-type', v3_magic_ft_node
)
478 set_if_exists('uuid-field-type', v3_uuid_ft_node
)
479 set_if_exists('stream-type-id-field-type', v3_stream_type_id_ft_node
)
480 return v3_features_node
482 v3_trace_node
: _MapNode
= collections
.OrderedDict()
483 v3_trace_type_node
: _MapNode
= collections
.OrderedDict()
484 v2_trace_node
= v2_meta_node
['trace']
486 # Move `byte-order` property to root node's `target-byte-order`
488 self
._root
_node
['target-byte-order'] = v2_trace_node
['byte-order']
490 # copy `uuid` property
491 _copy_prop_if_exists(v3_trace_type_node
, v2_trace_node
, 'uuid')
493 # copy `$log-levels`/`log-levels` property
494 new_prop_name
= '$log-level-aliases'
495 _copy_prop_if_exists(v3_trace_type_node
, v2_meta_node
, 'log-levels', new_prop_name
)
496 _copy_prop_if_exists(v3_trace_type_node
, v2_meta_node
, '$log-levels', new_prop_name
)
498 # copy `clocks` property, converting clock type nodes
499 v2_clk_types_node
= v2_meta_node
.get('clocks')
501 if v2_clk_types_node
is not None:
502 v3_clk_types_node
= collections
.OrderedDict()
504 for name
, v2_clk_type_node
in v2_clk_types_node
.items():
505 v3_clk_types_node
[name
] = self
._conv
_clk
_type
_node
(v2_clk_type_node
)
507 v3_trace_type_node
['clock-types'] = v3_clk_types_node
510 v2_pkt_header_ft_node
= v2_trace_node
.get('packet-header-type')
511 v3_trace_type_node
['$features'] = v3_features_node_from_v2_ft_node(v2_pkt_header_ft_node
)
513 # convert stream type nodes
514 v3_stream_types_node
= collections
.OrderedDict()
516 for stream_type_name
, v2_stream_type_node
in v2_meta_node
['streams'].items():
518 v3_stream_types_node
[stream_type_name
] = self
._conv
_stream
_type
_node
(v2_stream_type_node
)
519 except _ConfigurationParseError
as exc
:
520 _append_error_ctx(exc
, f
'Stream type `{stream_type_name}`')
522 v3_trace_type_node
['stream-types'] = v3_stream_types_node
524 # If `v2_meta_node` has a `$default-stream` property, find the
525 # corresponding v3 stream type node and set its `$is-default`
526 # property to `True`.
527 prop_name
= '$default-stream'
528 v2_def_stream_type_node
= v2_meta_node
.get(prop_name
)
530 if v2_def_stream_type_node
is not None:
533 for stream_type_name
, v3_stream_type_node
in v3_stream_types_node
.items():
534 if stream_type_name
== v2_def_stream_type_node
:
535 v3_stream_type_node
['$is-default'] = True
540 raise _ConfigurationParseError(f
'`{prop_name}` property',
541 f
'Stream type `{v2_def_stream_type_node}` does not exist')
543 # set environment node
544 v2_env_node
= v2_meta_node
.get('env')
546 if v2_env_node
is not None:
547 v3_trace_node
['environment'] = copy
.deepcopy(v2_env_node
)
549 # set v3 trace node's type node
550 v3_trace_node
['type'] = v3_trace_type_node
554 # Transforms the root configuration node into a valid v3
555 # configuration node.
556 def _transform_config_node(self
):
557 # remove the `version` property
558 del self
._root
_node
['version']
560 # relocate prefix and option nodes
561 prefix_prop_name
= 'prefix'
562 v2_prefix_node
= self
._root
_node
.get(prefix_prop_name
, 'barectf_')
563 _del_prop_if_exists(self
._root
_node
, prefix_prop_name
)
564 opt_prop_name
= 'options'
565 v2_options_node
= self
._root
_node
.get(opt_prop_name
)
566 _del_prop_if_exists(self
._root
_node
, opt_prop_name
)
567 code_gen_node
= collections
.OrderedDict()
568 v3_prefixes
= config_parse_common
._v
3_prefixes
_from
_v
2_prefix
(v2_prefix_node
)
569 v3_prefix_node
= collections
.OrderedDict([
570 ('identifier', v3_prefixes
.identifier
),
571 ('file-name', v3_prefixes
.file_name
),
573 code_gen_node
[prefix_prop_name
] = v3_prefix_node
575 if v2_options_node
is not None:
576 header_node
= collections
.OrderedDict()
577 _copy_prop_if_exists(header_node
, v2_options_node
, 'gen-prefix-def',
578 'identifier-prefix-definition')
579 _copy_prop_if_exists(header_node
, v2_options_node
, 'gen-default-stream-def',
580 'default-stream-type-name-definition')
581 code_gen_node
['header'] = header_node
583 self
._root
_node
[opt_prop_name
] = collections
.OrderedDict({
584 'code-generation': code_gen_node
,
587 # convert the v2 metadata node into a v3 trace node
589 self
._root
_node
['trace'] = self
._conv
_meta
_node
(self
._root
_node
['metadata'])
590 except _ConfigurationParseError
as exc
:
591 _append_error_ctx(exc
, 'Metadata object')
593 del self
._root
_node
['metadata']
595 # Expands the field type aliases found in the metadata node.
597 # This method modifies the metadata node.
599 # When this method returns:
601 # * Any field type alias is replaced with its full field type node
604 # * The `type-aliases` property of metadata node is removed.
605 def _expand_ft_aliases(self
):
606 meta_node
= self
._root
_node
['metadata']
607 ft_aliases_node
= meta_node
['type-aliases']
609 # Expand field type aliases within trace, stream, and event
612 self
._resolve
_ft
_alias
_from
(ft_aliases_node
, meta_node
['trace'], 'packet-header-type')
613 except _ConfigurationParseError
as exc
:
614 _append_error_ctx(exc
, 'Trace type')
616 for stream_type_name
, stream_type_node
in meta_node
['streams'].items():
618 self
._resolve
_ft
_alias
_from
(ft_aliases_node
, stream_type_node
,
619 'packet-context-type')
620 self
._resolve
_ft
_alias
_from
(ft_aliases_node
, stream_type_node
, 'event-header-type')
621 self
._resolve
_ft
_alias
_from
(ft_aliases_node
, stream_type_node
,
622 'event-context-type')
624 for ev_type_name
, ev_type_node
in stream_type_node
['events'].items():
626 self
._resolve
_ft
_alias
_from
(ft_aliases_node
, ev_type_node
, 'context-type')
627 self
._resolve
_ft
_alias
_from
(ft_aliases_node
, ev_type_node
, 'payload-type')
628 except _ConfigurationParseError
as exc
:
629 _append_error_ctx(exc
, f
'Event type `{ev_type_name}`')
630 except _ConfigurationParseError
as exc
:
631 _append_error_ctx(exc
, f
'Stream type `{stream_type_name}`')
633 # remove the (now unneeded) `type-aliases` node
634 del meta_node
['type-aliases']
636 # Applies field type inheritance to all field type nodes found in
639 # This method modifies the metadata node.
641 # When this method returns, no field type node has an `$inherit` or
642 # `inherit` property.
643 def _apply_fts_inheritance(self
):
644 meta_node
= self
._root
_node
['metadata']
645 self
._apply
_ft
_inheritance
(meta_node
['trace'], 'packet-header-type')
647 for stream_type_node
in meta_node
['streams'].values():
648 self
._apply
_ft
_inheritance
(stream_type_node
, 'packet-context-type')
649 self
._apply
_ft
_inheritance
(stream_type_node
, 'event-header-type')
650 self
._apply
_ft
_inheritance
(stream_type_node
, 'event-context-type')
652 for ev_type_node
in stream_type_node
['events'].values():
653 self
._apply
_ft
_inheritance
(ev_type_node
, 'context-type')
654 self
._apply
_ft
_inheritance
(ev_type_node
, 'payload-type')
656 # Calls _expand_ft_aliases() and _apply_fts_inheritance() if the
657 # metadata node has a `type-aliases` property.
658 def _expand_fts(self
):
659 # Make sure that the current configuration node is valid
660 # considering field types are not expanded yet.
661 self
._schema
_validator
.validate(self
._root
_node
,
662 'config/2/config-pre-field-type-expansion')
664 meta_node
= self
._root
_node
['metadata']
665 ft_aliases_node
= meta_node
.get('type-aliases')
667 if ft_aliases_node
is None:
668 # If there's no `type-aliases` node, then there's no field
669 # type aliases and therefore no possible inheritance.
672 # first, expand field type aliases
673 self
._expand
_ft
_aliases
()
675 # next, apply inheritance to create effective field types
676 self
._apply
_fts
_inheritance
()
678 # Processes the inclusions of the event type node `ev_type_node`,
679 # returning the effective node.
680 def _process_ev_type_node_include(self
, ev_type_node
: _MapNode
) -> _MapNode
:
681 # Make sure the event type node is valid for the inclusion
683 self
._schema
_validator
.validate(ev_type_node
, 'config/2/event-type-pre-include')
686 return self
._process
_node
_include
(ev_type_node
, self
._process
_ev
_type
_node
_include
)
688 # Processes the inclusions of the stream type node
689 # `stream_type_node`, returning the effective node.
690 def _process_stream_type_node_include(self
, stream_type_node
: _MapNode
) -> _MapNode
:
691 def process_children_include(stream_type_node
):
694 if prop_name
in stream_type_node
:
695 ev_types_node
= stream_type_node
[prop_name
]
697 for key
in list(ev_types_node
):
698 ev_types_node
[key
] = self
._process
_ev
_type
_node
_include
(ev_types_node
[key
])
700 # Make sure the stream type node is valid for the inclusion
702 self
._schema
_validator
.validate(stream_type_node
, 'config/2/stream-type-pre-include')
705 return self
._process
_node
_include
(stream_type_node
, self
._process
_stream
_type
_node
_include
,
706 process_children_include
)
708 # Processes the inclusions of the trace type node `trace_type_node`,
709 # returning the effective node.
710 def _process_trace_type_node_include(self
, trace_type_node
: _MapNode
) -> _MapNode
:
711 # Make sure the trace type node is valid for the inclusion
713 self
._schema
_validator
.validate(trace_type_node
, 'config/2/trace-type-pre-include')
716 return self
._process
_node
_include
(trace_type_node
, self
._process
_trace
_type
_node
_include
)
718 # Processes the inclusions of the clock type node `clk_type_node`,
719 # returning the effective node.
720 def _process_clk_type_node_include(self
, clk_type_node
: _MapNode
) -> _MapNode
:
721 # Make sure the clock type node is valid for the inclusion
723 self
._schema
_validator
.validate(clk_type_node
, 'config/2/clock-type-pre-include')
726 return self
._process
_node
_include
(clk_type_node
, self
._process
_clk
_type
_node
_include
)
728 # Processes the inclusions of the metadata node `meta_node`,
729 # returning the effective node.
730 def _process_meta_node_include(self
, meta_node
: _MapNode
) -> _MapNode
:
731 def process_children_include(meta_node
: _MapNode
):
734 if prop_name
in meta_node
:
735 meta_node
[prop_name
] = self
._process
_trace
_type
_node
_include
(meta_node
[prop_name
])
739 if prop_name
in meta_node
:
740 clk_types_node
= meta_node
[prop_name
]
742 for key
in list(clk_types_node
):
743 clk_types_node
[key
] = self
._process
_clk
_type
_node
_include
(clk_types_node
[key
])
745 prop_name
= 'streams'
747 if prop_name
in meta_node
:
748 stream_types_node
= meta_node
[prop_name
]
750 for key
in list(stream_types_node
):
751 stream_types_node
[key
] = self
._process
_stream
_type
_node
_include
(stream_types_node
[key
])
753 # Make sure the metadata node is valid for the inclusion
755 self
._schema
_validator
.validate(meta_node
, 'config/2/metadata-pre-include')
758 return self
._process
_node
_include
(meta_node
, self
._process
_meta
_node
_include
,
759 process_children_include
)
761 # Processes the inclusions of the configuration node, modifying it
762 # during the process.
763 def _process_config_includes(self
):
764 # Process inclusions in this order:
766 # 1. Clock type node, event type nodes, and trace type nodes
767 # (the order between those is not important).
769 # 2. Stream type nodes.
775 # * A metadata node can include clock type nodes, a trace type
776 # node, stream type nodes, and event type nodes (indirectly).
778 # * A stream type node can include event type nodes.
780 # First, make sure the configuration node itself is valid for
781 # the inclusion processing stage.
782 self
._schema
_validator
.validate(self
._root
_node
,
783 'config/2/config-pre-include')
785 # Process metadata node inclusions.
787 # self._process_meta_node_include() returns a new (or the same)
788 # metadata node without any `$include` property in it,
790 prop_name
= 'metadata'
791 self
._root
_node
[prop_name
] = self
._process
_meta
_node
_include
(self
._root
_node
[prop_name
])
794 # Make sure the configuration node is minimally valid, that is,
795 # it contains a valid `version` property.
797 # This step does not validate the whole configuration node yet
798 # because we don't have an effective configuration node; we
801 # * Process inclusions.
802 # * Expand field types (aliases and inheritance).
803 self
._schema
_validator
.validate(self
._root
_node
, 'config/2/config-min')
805 # process configuration node inclusions
806 self
._process
_config
_includes
()
808 # Expand field type nodes.
812 # 1. Replaces field type aliases with "effective" field type
813 # nodes, recursively.
815 # After this step, the `type-aliases` property of the
816 # metadata node is gone.
818 # 2. Applies inheritance, following the `$inherit`/`inherit`
821 # After this step, field type nodes do not contain `$inherit`
822 # or `inherit` properties.
824 # This is done blindly, in that the process _doesn't_ validate
825 # field type nodes at this point.
827 # The reason we must do this here for a barectf 2 configuration,
828 # considering that barectf 3 also supports field type node
829 # aliases and inheritance, is that we need to find specific
830 # packet header and packet context field type member nodes (for
831 # example, `stream_id`, `packet_size`, or `timestamp_end`) to
832 # set the `$features` properties of barectf 3 trace type and
833 # stream type nodes. Those field type nodes can be aliases,
834 # contain aliases, or inherit from other nodes.
837 # Validate the whole, (almost) effective configuration node.
839 # It's almost effective because the `log-level` property of
840 # event type nodes can be log level aliases. Log level aliases
841 # are also a feature of a barectf 3 configuration node,
842 # therefore this is compatible.
843 self
._schema
_validator
.validate(self
._root
_node
, 'config/2/config')
845 # Transform the current configuration node into a valid v3
846 # configuration node.
847 self
._transform
_config
_node
()
850 def config_node(self
) -> config_parse_common
._ConfigNodeV
3:
851 return config_parse_common
._ConfigNodeV
3(typing
.cast(_MapNode
, self
._root
_node
))