enumfc = tc.create_unsigned_enumeration_field_class() groups = str(enum_values_str).split(' ') mappings = {} range_set_type = ( bt2.SignedIntegerRangeSet if params['enum-signed'] else bt2.UnsignedIntegerRangeSet ) for group in groups: label, low, high = group.split(',') if label not in mappings.keys(): mappings[label] = range_set_type() mappings[label].add((int(low), int(high))) for x, y in mappings.items(): enumfc.add_mapping(x, y) # Create the struct field to contain the enum field class struct_fc = tc.create_structure_field_class() struct_fc.append_member('enum_field', enumfc) # Create an event class on this stream with the struct field ec1 = sc.create_event_class(name='with_enum', payload_field_class=struct_fc) self._add_output_port('out', (tc, sc, ec1, params)) bt2.register_plugin(__name__, 'test-pretty')
import bt2 import cantools import struct bt2.register_plugin( module_name=__name__, name="can", description="CAN Format", author="Gabriel-Andrew Pollo-Guilbert", license="GPL", version=(1, 0, 0), ) def log_info(cur_log_level): return cur_log_level <= bt2.LoggingLevel.INFO def print_info(text): print("INFO: {}".format(text)) class CANIterator(bt2._UserMessageIterator): def __init__(self, port): path, trace_class, self._messages = port.user_data self._file = open(path, "rb") trace = trace_class() stream_class = trace_class[0] self._stream = trace.create_stream(stream_class)
# SPDX-License-Identifier: GPL-2.0-only # # Copyright (C) 2019 EfficiOS Inc. # import bt2 import signal import os import time bt2.register_plugin(__name__, "test_exit_status") class StatusIter(bt2._UserMessageIterator): def __init__(self, config, output_port): self.case = output_port.user_data['case'] def __next__(self): if self.case == "STOP": raise bt2.Stop() if self.case == "INTERRUPTED": os.kill(os.getpid(), signal.SIGINT) # Wait until the graph is in the interrupted state. timeout_s = 10 for _ in range(timeout_s * 10): if self._is_interrupted: raise bt2.TryAgain() time.sleep(0.1)
return msg else: raise StopIteration @bt2.plugin_component_class class TheSourceOfAllEvil(bt2._UserSourceComponent, message_iterator_class=TheIteratorOfAllEvil): def __init__(self, config, params, obj): tc = self._create_trace_class() with_packets = bool(params['with-packet-msgs']) # Use a clock class with an offset, so we can test with --begin or --end # smaller than this offset (in other words, a time that it's not # possible to represent with this clock class). cc = self._create_clock_class(frequency=1, offset=bt2.ClockClassOffset(10000)) sc = tc.create_stream_class( default_clock_class=cc, supports_packets=with_packets, packets_have_beginning_default_clock_snapshot=with_packets, packets_have_end_default_clock_snapshot=with_packets, ) ec1 = sc.create_event_class(name='event 1') ec2 = sc.create_event_class(name='event 2') self._add_output_port('out', (tc, sc, ec1, ec2, params)) bt2.register_plugin(__name__, 'test-trimmer')
for event_type in event_types_available: # Stream classes event_types_available[event_type]["stream_class"] = ( rocm_trace.create_stream_class( default_clock_class=clock_class)) # Field classes payload_class = rocm_trace.create_structure_field_class() event_types_available[event_type]["payload_class"] = payload_class get_payload_class(event_types_available[event_type]["fields"], rocm_trace, payload_class) # Event classes event_types_available[event_type]["event_class"] = ( event_types_available[event_type] ["stream_class"].create_event_class( name=event_type, payload_field_class=event_types_available[event_type] ["payload_class"])) # Same trace object for all ports trace = rocm_trace() for event_type in event_types_available: self._add_output_port( "out_" + event_type, { "trace": trace, "event_type": event_types_available[event_type] }) bt2.register_plugin(module_name=__name__, name="rocm", description="rocprofiler/roctracer format", author="Arnaud Fiorini")
@bt2.plugin_component_class class ThisIsASource( bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator ): pass @bt2.plugin_component_class class ThisIsAFilter( bt2._UserFilterComponent, message_iterator_class=bt2._UserMessageIterator ): pass @bt2.plugin_component_class class ThisIsASink(bt2._UserSinkComponent): def _user_consume(self): pass bt2.register_plugin( __name__, "this-is-a-plugin", version=(1, 2, 3, 'bob'), description='A plugin', author='Jorge Mario Bergoglio', license='The license', )
offset=bt2.ClockClassOffset(0)) cc2 = src._create_clock_class(frequency=1, name='Chicoutimi', offset=bt2.ClockClassOffset(0)) src._add_output_port('out1', (test_name, cc1)) src._add_output_port('out2', (test_name, cc2)) def create_msgs(msg_iter, params): (cc, ) = params sb_msg = msg_iter._create_message_iterator_inactivity_message(cc, 0) msg_iter._msgs = [sb_msg] TEST_CASES = { 'diff_trace_name': DiffTraceName, 'diff_event_class_name': DiffEventClassName, 'diff_event_class_id': DiffEventClassId, 'diff_stream_name': DiffStreamName, 'diff_stream_no_name': DiffStreamNoName, 'diff_stream_id': DiffStreamId, 'diff_stream_class_id': DiffStreamClassId, 'diff_stream_class_name': DiffStreamClassName, 'diff_stream_class_no_name': DiffStreamClassNoName, 'diff_inactivity_msg_cs': DiffInactivityMsgCs, 'basic_timestamp_ordering': BasicTimestampOrdering, 'multi_iter_ordering': MultiIterOrdering, } bt2.register_plugin(__name__, 'test-muxer')
self._on_scope_entry(msg) print(colored(msg.event["msg"], "magenta", attrs=["bold"])) self._on_scope_exit() def _user_consume(self): msg = next(self._iterator) if type(msg) is not bt2._EventMessageConst: return event_name = msg.event.name is_syscall_getpid = event_name.endswith("getpid") if event_name == "lttng_python:event": self._on_python_logging_statement(msg) elif event_name.startswith("syscall_entry") and not is_syscall_getpid: self._on_syscall_entry(msg) elif event_name.startswith("syscall_exit") and not is_syscall_getpid: self._on_syscall_exit(msg) elif event_name == "python:function__entry": self._on_python_function_entry(msg) elif event_name == "python:function__return": self._on_python_function_exit() elif event_name == "lttng_ust_cyg_profile_fast:func_entry": self._on_native_function_entry(msg) elif event_name == "lttng_ust_cyg_profile_fast:func_exit": self._on_native_function_exit() bt2.register_plugin(__name__, "pycon")
import code from pprint import pprint from collections import defaultdict import operator import signal from executionmodel import ExecutionModel from runtimemodel import RuntimeModel from kernelmodel import KernelModel from paravertrace import ParaverTrace, ExtraeEventTypes import paraverviews as pv bt2.register_plugin( module_name=__name__, name="nanos6", description="Nanos6 CTF instrumentation backend utilities", author="Aleix Roca Nonell", license="GPL", version=(1, 0, 0), ) class ExitHandler(): def __init__(self): self._exit = False # Register exit signals signal.signal(signal.SIGTERM, self._sigtermHandler) signal.signal(signal.SIGINT, self._sigintHandler) # Register timeout if requested timeout = os.environ.get('CTF2PRV_TIMEOUT', "0")
class MyIter(bt2._UserMessageIterator): pass @bt2.plugin_component_class class MySource(bt2._UserSourceComponent, message_iterator_class=MyIter): pass @bt2.plugin_component_class class MyFilter(bt2._UserFilterComponent, message_iterator_class=MyIter): pass @bt2.plugin_component_class class MySink(bt2._UserSinkComponent): def _user_consume(self): pass bt2.register_plugin( __name__, 'sparkling', author='Philippe Proulx', description='A delicious plugin.', version=(1, 2, 3, 'EXTRA'), license='MIT', )
import bt2 class MyIter(bt2._UserNotificationIterator): pass @bt2.plugin_component_class class MySource(bt2._UserSourceComponent, notification_iterator_class=MyIter): pass @bt2.plugin_component_class class MyFilter(bt2._UserFilterComponent, notification_iterator_class=MyIter): pass @bt2.plugin_component_class class MySink(bt2._UserSinkComponent): def _consume(self): pass bt2.register_plugin(__name__, 'sparkling', author='Philippe Proulx', description='A delicious plugin.', version=(1, 2, 3, 'EXTRA'), license='MIT')
# SPDX-License-Identifier: GPL-2.0-only # # Copyright (C) 2019 EfficiOS Inc. # import bt2 import math bt2.register_plugin(__name__, "test_debug_info") class CompleteIter(bt2._UserMessageIterator): def __init__(self, config, output_port): ec = output_port.user_data sc = ec.stream_class tc = sc.trace_class trace = tc() stream = trace.create_stream(sc) ev = self._create_event_message(ec, stream, default_clock_snapshot=123) ev.event.payload_field["bool"] = False ev.event.payload_field["real_single"] = 2.0 ev.event.payload_field["real_double"] = math.pi ev.event.payload_field["int32"] = 121 ev.event.payload_field["int3"] = -1 ev.event.payload_field["int9_hex"] = -92 ev.event.payload_field["uint32"] = 121 ev.event.payload_field["uint61"] = 299792458 ev.event.payload_field["uint5_oct"] = 29
# as published by the Free Software Foundation; only version 2 # of the License. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # import bt2 from cli_params_to_string import to_string @bt2.plugin_component_class class SourceWithQueryThatPrintsParams( bt2._UserSourceComponent, message_iterator_class=bt2._UserMessageIterator): @classmethod def _user_query(cls, executor, obj, params, method_obj): if obj == 'please-fail': raise ValueError('catastrophic failure') return obj + ':' + to_string(params) bt2.register_plugin(__name__, "query")
else: return 0 else: raise bt2.UnknownObject @bt2.plugin_component_class class TestSourceABCDE(Base, bt2._UserSourceComponent, message_iterator_class=TestIter): """A source that recognizes the arbitrary string input "ABCDE".""" def __init__(self, config, params, obj): super().__init__(params) @staticmethod def _user_query(priv_query_exec, obj, params, method_obj): if obj == 'babeltrace.support-info': return ( 1.0 if params['type'] == 'string' and params['input'] == 'ABCDE' else 0.0 ) else: raise bt2.UnknownObject class TestSourceNoQuery(bt2._UserSourceComponent, message_iterator_class=TestIter): """A source that does not implement _query at all.""" bt2.register_plugin(module_name=__name__, name="test")
tree = etree.parse(input) assert tree.getroot().tag == "{http://www.topografix.com/GPX/1/1}gpx" for trk in tree.findall("{http://www.topografix.com/GPX/1/1}trk"): print("GpxSource: Adding output port for track", trk) self._add_output_port("out", (trk, trace_class)) @staticmethod def _user_query(query_executor, obj, params, log_level): if obj == "babeltrace.support-info": if params["type"] == "file" and str( params["input"]).endswith(".gpx"): w = 0.25 else: w = 0.0 return {"weight": w} else: raise bt2.UnknownObject bt2.register_plugin( module_name=__name__, name="gpx", description="GPX format", author="Simon Marchi", license="MIT", version=(1, 0, 0), )
import bt2 bt2.register_plugin(__name__, "demo") class MyFirstSourceIter(bt2._UserMessageIterator): def __init__(self, config, output_port): ec = output_port.user_data sc = ec.stream_class tc = sc.trace_class trace = tc() stream = trace.create_stream(sc) # Here, we create all the messages from the start because we just have # a few, but a "real" source iterator generating a lot of data would # create them in __next__ as it reads the trace. self._msgs = [ self._create_stream_beginning_message(stream), self._create_event_message(ec, stream, default_clock_snapshot=123), self._create_stream_end_message(stream), ] def __next__(self): if len(self._msgs) > 0: return self._msgs.pop(0) else: raise StopIteration @bt2.plugin_component_class
# SPDX-License-Identifier: GPL-2.0-only # # Copyright (C) 2019 EfficiOS Inc. # import bt2 from cli_params_to_string import to_string @bt2.plugin_component_class class SinkThatPrintsParams(bt2._UserSinkComponent): def __init__(self, config, params, obj): self._add_input_port('in') print(to_string(params)) def _user_consume(self): raise bt2.Stop bt2.register_plugin(__name__, "params")