[babeltrace.git] / bindings / python / bt2 / bt2 / trace_collection_message_iterator.py

# The MIT License (MIT)
#
# Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.

from bt2 import utils
import bt2
import itertools
import bt2.message_iterator
import datetime
from collections import namedtuple
import numbers


# a pair of component and ComponentSpec
_ComponentAndSpec = namedtuple('_ComponentAndSpec', ['comp', 'spec'])


class ComponentSpec:
    def __init__(self, plugin_name, component_class_name, params=None):
        utils._check_str(plugin_name)
        utils._check_str(component_class_name)
        self._plugin_name = plugin_name
        self._component_class_name = component_class_name

        if type(params) is str:
            self._params = bt2.create_value({'paths': [params]})
        else:
            self._params = bt2.create_value(params)

    @property
    def plugin_name(self):
        return self._plugin_name

    @property
    def component_class_name(self):
        return self._component_class_name

    @property
    def params(self):
        return self._params


# datetime.datetime or integral to nanoseconds
def _get_ns(obj):
    if obj is None:
        return

    if isinstance(obj, numbers.Real):
        # consider that it's already in seconds
        s = obj
    elif isinstance(obj, datetime.datetime):
        # s -> ns
        s = obj.timestamp()
    else:
        raise TypeError('"{}" is not an integral number or a datetime.datetime object'.format(obj))

    return int(s * 1e9)


class _CompClsType:
    SOURCE = 0
    FILTER = 1


class TraceCollectionMessageIterator(bt2.message_iterator._MessageIterator):
    def __init__(self, source_component_specs, filter_component_specs=None,
                 stream_intersection_mode=False, begin=None, end=None):
        utils._check_bool(stream_intersection_mode)
        self._stream_intersection_mode = stream_intersection_mode
        self._begin_ns = _get_ns(begin)
        self._end_ns = _get_ns(end)

        if type(source_component_specs) is ComponentSpec:
            source_component_specs = [source_component_specs]

        if type(filter_component_specs) is ComponentSpec:
            filter_component_specs = [filter_component_specs]
        elif filter_component_specs is None:
            filter_component_specs = []

        self._src_comp_specs = source_component_specs
        self._flt_comp_specs = filter_component_specs
        self._next_suffix = 1
        self._connect_ports = False

        # lists of _ComponentAndSpec
        self._src_comps_and_specs = []
        self._flt_comps_and_specs = []

        self._validate_component_specs(source_component_specs)
        self._validate_component_specs(filter_component_specs)
        self._build_graph()

    def _validate_component_specs(self, comp_specs):
        for comp_spec in comp_specs:
            if type(comp_spec) is not ComponentSpec:
                raise TypeError('"{}" object is not a ComponentSpec'.format(type(comp_spec)))

    def __next__(self):
        return next(self._msg_iter)

    def _create_stream_intersection_trimmer(self, component, port):
        # find the original parameters specified by the user to create
        # this port's component to get the `path` parameter
        for src_comp_and_spec in self._src_comps_and_specs:
            if component == src_comp_and_spec.comp:
                break

        try:
            paths = src_comp_and_spec.spec.params['paths']
        except Exception as e:
            raise bt2.Error('all source components must be created with a "paths" parameter in stream intersection mode') from e

        params = {'paths': paths}

        # query the port's component for the `trace-info` object which
        # contains the stream intersection range for each exposed
        # trace
        query_exec = bt2.QueryExecutor()
        trace_info_res = query_exec.query(src_comp_and_spec.comp.component_class,
                                          'trace-info', params)
        begin = None
        end = None

        # find the trace info for this port's trace by name's prefix
        try:
            for trace_info in trace_info_res:
                if port.name.startswith(str(trace_info['path'])):
                    range_ns = trace_info['intersection-range-ns']
                    begin = range_ns['begin']
                    end = range_ns['end']
                    break
        except Exception:
            pass

        if begin is None or end is None:
            raise bt2.Error('cannot find stream intersection range for port "{}"'.format(port.name))

        name = 'trimmer-{}-{}'.format(src_comp_and_spec.comp.name, port.name)
        return self._create_trimmer(begin, end, name)

    def _create_muxer(self):
        plugin = bt2.find_plugin('utils')

        if plugin is None:
            raise bt2.Error('cannot find "utils" plugin (needed for the muxer)')

        if 'muxer' not in plugin.filter_component_classes:
            raise bt2.Error('cannot find "muxer" filter component class in "utils" plugin')

        comp_cls = plugin.filter_component_classes['muxer']
        return self._graph.add_component(comp_cls, 'muxer')

    def _create_trimmer(self, begin_ns, end_ns, name):
        plugin = bt2.find_plugin('utils')

        if plugin is None:
            raise bt2.Error('cannot find "utils" plugin (needed for the trimmer)')

        if 'trimmer' not in plugin.filter_component_classes:
            raise bt2.Error('cannot find "trimmer" filter component class in "utils" plugin')

        params = {}

        def ns_to_string(ns):
            s_part = ns // 1000000000
            ns_part = ns % 1000000000
            return '{}.{:09d}'.format(s_part, ns_part)

        if begin_ns is not None:
            params['begin'] = ns_to_string(begin_ns)

        if end_ns is not None:
            params['end'] = ns_to_string(end_ns)

        comp_cls = plugin.filter_component_classes['trimmer']
        return self._graph.add_component(comp_cls, name, params)

    def _get_unique_comp_name(self, comp_spec):
        name = '{}-{}'.format(comp_spec.plugin_name,
                              comp_spec.component_class_name)
        comps_and_specs = itertools.chain(self._src_comps_and_specs,
                                          self._flt_comps_and_specs)

        if name in [comp_and_spec.comp.name for comp_and_spec in comps_and_specs]:
            name += '-{}'.format(self._next_suffix)
            self._next_suffix += 1

        return name

    def _create_comp(self, comp_spec, comp_cls_type):
        plugin = bt2.find_plugin(comp_spec.plugin_name)

        if plugin is None:
            raise bt2.Error('no such plugin: {}'.format(comp_spec.plugin_name))

        if comp_cls_type == _CompClsType.SOURCE:
            comp_classes = plugin.source_component_classes
        else:
            comp_classes = plugin.filter_component_classes

        if comp_spec.component_class_name not in comp_classes:
            cc_type = 'source' if comp_cls_type == _CompClsType.SOURCE else 'filter'
            raise bt2.Error('no such {} component class in "{}" plugin: {}'.format(cc_type,
                                                                                   comp_spec.plugin_name,
                                                                                   comp_spec.component_class_name))

        comp_cls = comp_classes[comp_spec.component_class_name]
        name = self._get_unique_comp_name(comp_spec)
        comp = self._graph.add_component(comp_cls, name, comp_spec.params)
        return comp

    def _get_free_muxer_input_port(self):
        for port in self._muxer_comp.input_ports.values():
            if not port.is_connected:
                return port

    def _connect_src_comp_port(self, component, port):
        # if this trace collection iterator is in stream intersection
        # mode, we need this connection:
        #
        #     port -> trimmer -> muxer
        #
        # otherwise, simply:
        #
        #     port -> muxer
        if self._stream_intersection_mode:
            trimmer_comp = self._create_stream_intersection_trimmer(component, port)
            self._graph.connect_ports(port, trimmer_comp.input_ports['in'])
            port_to_muxer = trimmer_comp.output_ports['out']
        else:
            port_to_muxer = port

        self._graph.connect_ports(port_to_muxer, self._get_free_muxer_input_port())

    def _graph_port_added(self, component, port):
        if not self._connect_ports:
            return

        if type(port) is bt2.port._InputPort:
            return

        if component not in [comp.comp for comp in self._src_comps_and_specs]:
            # do not care about non-source components (muxer, trimmer, etc.)
            return

        self._connect_src_comp_port(component, port)

    def _build_graph(self):
        self._graph = bt2.Graph()
        self._graph.add_port_added_listener(self._graph_port_added)
        self._muxer_comp = self._create_muxer()

        if self._begin_ns is not None or self._end_ns is not None:
            trimmer_comp = self._create_trimmer(self._begin_ns,
                                                self._end_ns, 'trimmer')
            self._graph.connect_ports(self._muxer_comp.output_ports['out'],
                                      trimmer_comp.input_ports['in'])
            msg_iter_port = trimmer_comp.output_ports['out']
        else:
            msg_iter_port = self._muxer_comp.output_ports['out']

        # create extra filter components (chained)
        for comp_spec in self._flt_comp_specs:
            comp = self._create_comp(comp_spec, _CompClsType.FILTER)
            self._flt_comps_and_specs.append(_ComponentAndSpec(comp, comp_spec))

        # connect the extra filter chain
        for comp_and_spec in self._flt_comps_and_specs:
            in_port = list(comp_and_spec.comp.input_ports.values())[0]
            out_port = list(comp_and_spec.comp.output_ports.values())[0]
            self._graph.connect_ports(msg_iter_port, in_port)
            msg_iter_port = out_port

        # Here we create the components, self._graph_port_added() is
        # called when they add ports, but the callback returns early
        # because self._connect_ports is False. This is because the
        # self._graph_port_added() could not find the associated source
        # component specification in self._src_comps_and_specs because
        # it does not exist yet (it needs the created component to
        # exist).
        for comp_spec in self._src_comp_specs:
            comp = self._create_comp(comp_spec, _CompClsType.SOURCE)
            self._src_comps_and_specs.append(_ComponentAndSpec(comp, comp_spec))

        # Now we connect the ports which exist at this point. We allow
        # self._graph_port_added() to automatically connect _new_ ports.
        self._connect_ports = True

        for comp_and_spec in self._src_comps_and_specs:
            # Keep a separate list because comp_and_spec.output_ports
            # could change during the connection of one of its ports.
            # Any new port is handled by self._graph_port_added().
            out_ports = [port for port in comp_and_spec.comp.output_ports.values()]

            for out_port in out_ports:
                if out_port.is_connected:
                    continue

                self._connect_src_comp_port(comp_and_spec.comp, out_port)

        # create this trace collection iterator's message iterator
        self._msg_iter = self._graph.create_output_port_message_iterator(msg_iter_port)
Commit	Line	Data
85dcce24 PP	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
3d60267b	25	import itertools
5602ef81	26	import bt2.message_iterator
85dcce24	27	import datetime
85dcce24 PP	28	from collections import namedtuple
	29	import numbers
	30
	31
3d60267b PP	32	# a pair of component and ComponentSpec
3d60267b PP	33	_ComponentAndSpec = namedtuple('_ComponentAndSpec', ['comp', 'spec'])
85dcce24 PP	34
85dcce24 PP	35
3d60267b	36	class ComponentSpec:
85dcce24 PP	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:
907f2b70	44	self._params = bt2.create_value({'paths': [params]})
85dcce24 PP	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
3d60267b PP	78	class _CompClsType:
	79	SOURCE = 0
	80	FILTER = 1
	81
	82
5602ef81	83	class TraceCollectionMessageIterator(bt2.message_iterator._MessageIterator):
3d60267b	84	def __init__(self, source_component_specs, filter_component_specs=None,
907f2b70	85	stream_intersection_mode=False, begin=None, end=None):
85dcce24 PP	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)
3d60267b PP	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
85dcce24	99	self._src_comp_specs = source_component_specs
3d60267b	100	self._flt_comp_specs = filter_component_specs
85dcce24 PP	101	self._next_suffix = 1
	102	self._connect_ports = False
	103
3d60267b	104	# lists of _ComponentAndSpec
85dcce24	105	self._src_comps_and_specs = []
3d60267b	106	self._flt_comps_and_specs = []
85dcce24	107
3d60267b PP	108	self._validate_component_specs(source_component_specs)
3d60267b PP	109	self._validate_component_specs(filter_component_specs)
85dcce24 PP	110	self._build_graph()
85dcce24 PP	111
3d60267b PP	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)))
85dcce24 PP	116
85dcce24 PP	117	def __next__(self):
5602ef81	118	return next(self._msg_iter)
85dcce24	119
907f2b70	120	def _create_stream_intersection_trimmer(self, component, port):
85dcce24 PP	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:
907f2b70	124	if component == src_comp_and_spec.comp:
85dcce24 PP	125	break
	126
	127	try:
907f2b70 SM	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
85dcce24	131
907f2b70	132	params = {'paths': paths}
85dcce24 PP	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()
907f2b70	138	trace_info_res = query_exec.query(src_comp_and_spec.comp.component_class,
85dcce24 PP	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
87b768aa PP	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
907f2b70	151	except Exception:
87b768aa	152	pass
85dcce24 PP	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
907f2b70	157	name = 'trimmer-{}-{}'.format(src_comp_and_spec.comp.name, port.name)
85dcce24 PP	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
907f2b70	172	def _create_trimmer(self, begin_ns, end_ns, name):
85dcce24 PP	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
907f2b70 SM	183	def ns_to_string(ns):
	184	s_part = ns // 1000000000
	185	ns_part = ns % 1000000000
	186	return '{}.{:09d}'.format(s_part, ns_part)
85dcce24	187
907f2b70 SM	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)
85dcce24 PP	193
	194	comp_cls = plugin.filter_component_classes['trimmer']
	195	return self._graph.add_component(comp_cls, name, params)
	196
3d60267b	197	def _get_unique_comp_name(self, comp_spec):
85dcce24 PP	198	name = '{}-{}'.format(comp_spec.plugin_name,
85dcce24 PP	199	comp_spec.component_class_name)
3d60267b PP	200	comps_and_specs = itertools.chain(self._src_comps_and_specs,
3d60267b PP	201	self._flt_comps_and_specs)
85dcce24	202
3d60267b	203	if name in [comp_and_spec.comp.name for comp_and_spec in comps_and_specs]:
85dcce24 PP	204	name += '-{}'.format(self._next_suffix)
	205	self._next_suffix += 1
	206
	207	return name
	208
3d60267b	209	def _create_comp(self, comp_spec, comp_cls_type):
85dcce24 PP	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
3d60267b PP	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))
85dcce24	225
3d60267b PP	226	comp_cls = comp_classes[comp_spec.component_class_name]
3d60267b PP	227	name = self._get_unique_comp_name(comp_spec)
85dcce24 PP	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
907f2b70	236	def _connect_src_comp_port(self, component, port):
85dcce24 PP	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:
907f2b70	246	trimmer_comp = self._create_stream_intersection_trimmer(component, port)
85dcce24 PP	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
907f2b70	254	def _graph_port_added(self, component, port):
85dcce24 PP	255	if not self._connect_ports:
	256	return
	257
907f2b70	258	if type(port) is bt2.port._InputPort:
85dcce24 PP	259	return
85dcce24 PP	260
907f2b70	261	if component not in [comp.comp for comp in self._src_comps_and_specs]:
85dcce24 PP	262	# do not care about non-source components (muxer, trimmer, etc.)
	263	return
	264
907f2b70	265	self._connect_src_comp_port(component, port)
85dcce24 PP	266
	267	def _build_graph(self):
	268	self._graph = bt2.Graph()
907f2b70	269	self._graph.add_port_added_listener(self._graph_port_added)
85dcce24 PP	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'])
5602ef81	277	msg_iter_port = trimmer_comp.output_ports['out']
85dcce24	278	else:
5602ef81	279	msg_iter_port = self._muxer_comp.output_ports['out']
85dcce24	280
3d60267b PP	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]
5602ef81 SM	290	self._graph.connect_ports(msg_iter_port, in_port)
5602ef81 SM	291	msg_iter_port = out_port
3d60267b	292
85dcce24 PP	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:
3d60267b PP	301	comp = self._create_comp(comp_spec, _CompClsType.SOURCE)
3d60267b PP	302	self._src_comps_and_specs.append(_ComponentAndSpec(comp, comp_spec))
85dcce24 PP	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:
907f2b70	315	if out_port.is_connected:
85dcce24 PP	316	continue
85dcce24 PP	317
907f2b70	318	self._connect_src_comp_port(comp_and_spec.comp, out_port)
85dcce24	319
5602ef81	320	# create this trace collection iterator's message iterator
907f2b70	321	self._msg_iter = self._graph.create_output_port_message_iterator(msg_iter_port)