bindings/python/bt2/bt2/trace_collection_message_iterator.py

   1 # The MIT License (MIT)
   2 #
   3 # Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
   4 #
   5 # Permission is hereby granted, free of charge, to any person obtaining a copy
   6 # of this software and associated documentation files (the "Software"), to deal
   7 # in the Software without restriction, including without limitation the rights
   8 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 # copies of the Software, and to permit persons to whom the Software is
  10 # furnished to do so, subject to the following conditions:
  11 #
  12 # The above copyright notice and this permission notice shall be included in
  13 # all copies or substantial portions of the Software.
  14 #
  15 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21 # THE SOFTWARE.
  22
  23 from bt2 import utils
  24 import bt2
  25 import itertools
  26 import bt2.message_iterator
  27 import datetime
  28 from collections import namedtuple
  29 import numbers
  30
  31
  32 # a pair of component and ComponentSpec
  33 _ComponentAndSpec = namedtuple('_ComponentAndSpec', ['comp', 'spec'])
  34
  35
  36 class ComponentSpec:
  37     def __init__(self, plugin_name, component_class_name, params=None):
  38         utils._check_str(plugin_name)
  39         utils._check_str(component_class_name)
  40         self._plugin_name = plugin_name
  41         self._component_class_name = component_class_name
  42
  43         if type(params) is str:
  44             self._params = bt2.create_value({'paths': [params]})
  45         else:
  46             self._params = bt2.create_value(params)
  47
  48     @property
  49     def plugin_name(self):
  50         return self._plugin_name
  51
  52     @property
  53     def component_class_name(self):
  54         return self._component_class_name
  55
  56     @property
  57     def params(self):
  58         return self._params
  59
  60
  61 # datetime.datetime or integral to nanoseconds
  62 def _get_ns(obj):
  63     if obj is None:
  64         return
  65
  66     if isinstance(obj, numbers.Real):
  67         # consider that it's already in seconds
  68         s = obj
  69     elif isinstance(obj, datetime.datetime):
  70         # s -> ns
  71         s = obj.timestamp()
  72     else:
  73         raise TypeError('"{}" is not an integral number or a datetime.datetime object'.format(obj))
  74
  75     return int(s * 1e9)
  76
  77
  78 class _CompClsType:
  79     SOURCE = 0
  80     FILTER = 1
  81
  82
  83 class TraceCollectionMessageIterator(bt2.message_iterator._MessageIterator):
  84     def __init__(self, source_component_specs, filter_component_specs=None,
  85                  stream_intersection_mode=False, begin=None, end=None):
  86         utils._check_bool(stream_intersection_mode)
  87         self._stream_intersection_mode = stream_intersection_mode
  88         self._begin_ns = _get_ns(begin)
  89         self._end_ns = _get_ns(end)
  90
  91         if type(source_component_specs) is ComponentSpec:
  92             source_component_specs = [source_component_specs]
  93
  94         if type(filter_component_specs) is ComponentSpec:
  95             filter_component_specs = [filter_component_specs]
  96         elif filter_component_specs is None:
  97             filter_component_specs = []
  98
  99         self._src_comp_specs = source_component_specs
 100         self._flt_comp_specs = filter_component_specs
 101         self._next_suffix = 1
 102         self._connect_ports = False
 103
 104         # lists of _ComponentAndSpec
 105         self._src_comps_and_specs = []
 106         self._flt_comps_and_specs = []
 107
 108         self._validate_component_specs(source_component_specs)
 109         self._validate_component_specs(filter_component_specs)
 110         self._build_graph()
 111
 112     def _validate_component_specs(self, comp_specs):
 113         for comp_spec in comp_specs:
 114             if type(comp_spec) is not ComponentSpec:
 115                 raise TypeError('"{}" object is not a ComponentSpec'.format(type(comp_spec)))
 116
 117     def __next__(self):
 118         return next(self._msg_iter)
 119
 120     def _create_stream_intersection_trimmer(self, component, port):
 121         # find the original parameters specified by the user to create
 122         # this port's component to get the `path` parameter
 123         for src_comp_and_spec in self._src_comps_and_specs:
 124             if component == src_comp_and_spec.comp:
 125                 break
 126
 127         try:
 128             paths = src_comp_and_spec.spec.params['paths']
 129         except Exception as e:
 130             raise bt2.Error('all source components must be created with a "paths" parameter in stream intersection mode') from e
 131
 132         params = {'paths': paths}
 133
 134         # query the port's component for the `trace-info` object which
 135         # contains the stream intersection range for each exposed
 136         # trace
 137         query_exec = bt2.QueryExecutor()
 138         trace_info_res = query_exec.query(src_comp_and_spec.comp.component_class,
 139                                           'trace-info', params)
 140         begin = None
 141         end = None
 142
 143         # find the trace info for this port's trace by name's prefix
 144         try:
 145             for trace_info in trace_info_res:
 146                 if port.name.startswith(str(trace_info['path'])):
 147                     range_ns = trace_info['intersection-range-ns']
 148                     begin = range_ns['begin']
 149                     end = range_ns['end']
 150                     break
 151         except Exception:
 152             pass
 153
 154         if begin is None or end is None:
 155             raise bt2.Error('cannot find stream intersection range for port "{}"'.format(port.name))
 156
 157         name = 'trimmer-{}-{}'.format(src_comp_and_spec.comp.name, port.name)
 158         return self._create_trimmer(begin, end, name)
 159
 160     def _create_muxer(self):
 161         plugin = bt2.find_plugin('utils')
 162
 163         if plugin is None:
 164             raise bt2.Error('cannot find "utils" plugin (needed for the muxer)')
 165
 166         if 'muxer' not in plugin.filter_component_classes:
 167             raise bt2.Error('cannot find "muxer" filter component class in "utils" plugin')
 168
 169         comp_cls = plugin.filter_component_classes['muxer']
 170         return self._graph.add_component(comp_cls, 'muxer')
 171
 172     def _create_trimmer(self, begin_ns, end_ns, name):
 173         plugin = bt2.find_plugin('utils')
 174
 175         if plugin is None:
 176             raise bt2.Error('cannot find "utils" plugin (needed for the trimmer)')
 177
 178         if 'trimmer' not in plugin.filter_component_classes:
 179             raise bt2.Error('cannot find "trimmer" filter component class in "utils" plugin')
 180
 181         params = {}
 182
 183         def ns_to_string(ns):
 184             s_part = ns // 1000000000
 185             ns_part = ns % 1000000000
 186             return '{}.{:09d}'.format(s_part, ns_part)
 187
 188         if begin_ns is not None:
 189             params['begin'] = ns_to_string(begin_ns)
 190
 191         if end_ns is not None:
 192             params['end'] = ns_to_string(end_ns)
 193
 194         comp_cls = plugin.filter_component_classes['trimmer']
 195         return self._graph.add_component(comp_cls, name, params)
 196
 197     def _get_unique_comp_name(self, comp_spec):
 198         name = '{}-{}'.format(comp_spec.plugin_name,
 199                               comp_spec.component_class_name)
 200         comps_and_specs = itertools.chain(self._src_comps_and_specs,
 201                                           self._flt_comps_and_specs)
 202
 203         if name in [comp_and_spec.comp.name for comp_and_spec in comps_and_specs]:
 204             name += '-{}'.format(self._next_suffix)
 205             self._next_suffix += 1
 206
 207         return name
 208
 209     def _create_comp(self, comp_spec, comp_cls_type):
 210         plugin = bt2.find_plugin(comp_spec.plugin_name)
 211
 212         if plugin is None:
 213             raise bt2.Error('no such plugin: {}'.format(comp_spec.plugin_name))
 214
 215         if comp_cls_type == _CompClsType.SOURCE:
 216             comp_classes = plugin.source_component_classes
 217         else:
 218             comp_classes = plugin.filter_component_classes
 219
 220         if comp_spec.component_class_name not in comp_classes:
 221             cc_type = 'source' if comp_cls_type == _CompClsType.SOURCE else 'filter'
 222             raise bt2.Error('no such {} component class in "{}" plugin: {}'.format(cc_type,
 223                                                                                    comp_spec.plugin_name,
 224                                                                                    comp_spec.component_class_name))
 225
 226         comp_cls = comp_classes[comp_spec.component_class_name]
 227         name = self._get_unique_comp_name(comp_spec)
 228         comp = self._graph.add_component(comp_cls, name, comp_spec.params)
 229         return comp
 230
 231     def _get_free_muxer_input_port(self):
 232         for port in self._muxer_comp.input_ports.values():
 233             if not port.is_connected:
 234                 return port
 235
 236     def _connect_src_comp_port(self, component, port):
 237         # if this trace collection iterator is in stream intersection
 238         # mode, we need this connection:
 239         #
 240         #     port -> trimmer -> muxer
 241         #
 242         # otherwise, simply:
 243         #
 244         #     port -> muxer
 245         if self._stream_intersection_mode:
 246             trimmer_comp = self._create_stream_intersection_trimmer(component, port)
 247             self._graph.connect_ports(port, trimmer_comp.input_ports['in'])
 248             port_to_muxer = trimmer_comp.output_ports['out']
 249         else:
 250             port_to_muxer = port
 251
 252         self._graph.connect_ports(port_to_muxer, self._get_free_muxer_input_port())
 253
 254     def _graph_port_added(self, component, port):
 255         if not self._connect_ports:
 256             return
 257
 258         if type(port) is bt2.port._InputPort:
 259             return
 260
 261         if component not in [comp.comp for comp in self._src_comps_and_specs]:
 262             # do not care about non-source components (muxer, trimmer, etc.)
 263             return
 264
 265         self._connect_src_comp_port(component, port)
 266
 267     def _build_graph(self):
 268         self._graph = bt2.Graph()
 269         self._graph.add_port_added_listener(self._graph_port_added)
 270         self._muxer_comp = self._create_muxer()
 271
 272         if self._begin_ns is not None or self._end_ns is not None:
 273             trimmer_comp = self._create_trimmer(self._begin_ns,
 274                                                 self._end_ns, 'trimmer')
 275             self._graph.connect_ports(self._muxer_comp.output_ports['out'],
 276                                       trimmer_comp.input_ports['in'])
 277             msg_iter_port = trimmer_comp.output_ports['out']
 278         else:
 279             msg_iter_port = self._muxer_comp.output_ports['out']
 280
 281         # create extra filter components (chained)
 282         for comp_spec in self._flt_comp_specs:
 283             comp = self._create_comp(comp_spec, _CompClsType.FILTER)
 284             self._flt_comps_and_specs.append(_ComponentAndSpec(comp, comp_spec))
 285
 286         # connect the extra filter chain
 287         for comp_and_spec in self._flt_comps_and_specs:
 288             in_port = list(comp_and_spec.comp.input_ports.values())[0]
 289             out_port = list(comp_and_spec.comp.output_ports.values())[0]
 290             self._graph.connect_ports(msg_iter_port, in_port)
 291             msg_iter_port = out_port
 292
 293         # Here we create the components, self._graph_port_added() is
 294         # called when they add ports, but the callback returns early
 295         # because self._connect_ports is False. This is because the
 296         # self._graph_port_added() could not find the associated source
 297         # component specification in self._src_comps_and_specs because
 298         # it does not exist yet (it needs the created component to
 299         # exist).
 300         for comp_spec in self._src_comp_specs:
 301             comp = self._create_comp(comp_spec, _CompClsType.SOURCE)
 302             self._src_comps_and_specs.append(_ComponentAndSpec(comp, comp_spec))
 303
 304         # Now we connect the ports which exist at this point. We allow
 305         # self._graph_port_added() to automatically connect _new_ ports.
 306         self._connect_ports = True
 307
 308         for comp_and_spec in self._src_comps_and_specs:
 309             # Keep a separate list because comp_and_spec.output_ports
 310             # could change during the connection of one of its ports.
 311             # Any new port is handled by self._graph_port_added().
 312             out_ports = [port for port in comp_and_spec.comp.output_ports.values()]
 313
 314             for out_port in out_ports:
 315                 if out_port.is_connected:
 316                     continue
 317
 318                 self._connect_src_comp_port(comp_and_spec.comp, out_port)
 319
 320         # create this trace collection iterator's message iterator
 321         self._msg_iter = self._graph.create_output_port_message_iterator(msg_iter_port)