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")
