def __init__(self):
ptr = native_bt.interrupter_create()
if ptr is None:
raise bt2._MemoryError('cannot create interrupter object')
super().__init__(ptr)
def _create_packet_end_message(self, packet, default_clock_snapshot=None):
utils._check_type(packet, bt2_packet._Packet)
if packet.stream.cls.packets_have_end_default_clock_snapshot:
if default_clock_snapshot is None:
raise ValueError(
"packet end messages in this stream must have a default clock snapshot"
)
utils._check_uint64(default_clock_snapshot)
ptr = native_bt.message_packet_end_create_with_default_clock_snapshot(
self._bt_ptr, packet._ptr, default_clock_snapshot)
else:
if default_clock_snapshot is not None:
raise ValueError(
"packet end messages in this stream must not have a default clock snapshot"
)
ptr = native_bt.message_packet_end_create(self._bt_ptr,
packet._ptr)
if ptr is None:
raise bt2._MemoryError('cannot create packet end message object')
return bt2_message._PacketEndMessage(ptr)
def _handle_func_status(status, msg=None):
if status == native_bt.__BT_FUNC_STATUS_OK:
# no error
return
if status == native_bt.__BT_FUNC_STATUS_ERROR:
assert msg is not None
raise bt2._Error(msg)
elif status == native_bt.__BT_FUNC_STATUS_MEMORY_ERROR:
assert msg is not None
raise bt2._MemoryError(msg)
elif status == native_bt.__BT_FUNC_STATUS_END:
if msg is None:
raise bt2.Stop
else:
raise bt2.Stop(msg)
elif status == native_bt.__BT_FUNC_STATUS_AGAIN:
if msg is None:
raise bt2.TryAgain
else:
raise bt2.TryAgain(msg)
elif status == native_bt.__BT_FUNC_STATUS_OVERFLOW_ERROR:
if msg is None:
raise bt2._OverflowError
else:
raise bt2._OverflowError(msg)
elif status == native_bt.__BT_FUNC_STATUS_UNKNOWN_OBJECT:
if msg is None:
raise bt2.UnknownObject
else:
raise bt2.UnknownObject(msg)
else:
assert False
def __init__(self):
ptr = native_bt.graph_create()
if ptr is None:
raise bt2._MemoryError('cannot create graph object')
super().__init__(ptr)
def __init__(cls, class_name, bases, namespace, **kwargs):
super().__init__(class_name, bases, namespace)
# skip our own bases; they are never directly instantiated by the user
own_bases = (
'_UserComponent',
'_UserFilterSinkComponent',
'_UserSourceComponent',
'_UserFilterComponent',
'_UserSinkComponent',
)
if class_name in own_bases:
return
comp_cls_name = kwargs.get('name', class_name)
utils._check_str(comp_cls_name)
comp_cls_descr = None
comp_cls_help = None
if hasattr(cls, '__doc__') and cls.__doc__ is not None:
utils._check_str(cls.__doc__)
docstring = _trim_docstring(cls.__doc__)
lines = docstring.splitlines()
if len(lines) >= 1:
comp_cls_descr = lines[0]
if len(lines) >= 3:
comp_cls_help = '\n'.join(lines[2:])
iter_cls = kwargs.get('message_iterator_class')
if _UserSourceComponent in bases:
_UserComponentType._bt_set_iterator_class(cls, iter_cls)
cc_ptr = native_bt.bt2_component_class_source_create(
cls, comp_cls_name, comp_cls_descr, comp_cls_help)
elif _UserFilterComponent in bases:
_UserComponentType._bt_set_iterator_class(cls, iter_cls)
cc_ptr = native_bt.bt2_component_class_filter_create(
cls, comp_cls_name, comp_cls_descr, comp_cls_help)
elif _UserSinkComponent in bases:
if not hasattr(cls, '_user_consume'):
raise bt2._IncompleteUserClass(
"cannot create component class '{}': missing a _user_consume() method"
.format(class_name))
cc_ptr = native_bt.bt2_component_class_sink_create(
cls, comp_cls_name, comp_cls_descr, comp_cls_help)
else:
raise bt2._IncompleteUserClass(
"cannot find a known component class base in the bases of '{}'"
.format(class_name))
if cc_ptr is None:
raise bt2._MemoryError(
"cannot create component class '{}'".format(class_name))
cls._bt_cc_ptr = cc_ptr
def _create_message_iterator_inactivity_message(self, clock_class,
clock_snapshot):
utils._check_type(clock_class, bt2_clock_class._ClockClass)
ptr = native_bt.message_message_iterator_inactivity_create(
self._bt_ptr, clock_class._ptr, clock_snapshot)
if ptr is None:
raise bt2._MemoryError('cannot create inactivity message object')
return bt2_message._MessageIteratorInactivityMessage(ptr)
def _create_trace_class(self, assigns_automatic_stream_class_id=True):
ptr = self._bt_as_self_component_ptr(self._bt_ptr)
tc_ptr = native_bt.trace_class_create(ptr)
if tc_ptr is None:
raise bt2._MemoryError('could not create trace class')
tc = bt2_trace_class._TraceClass._create_from_ptr(tc_ptr)
tc._assigns_automatic_stream_class_id = assigns_automatic_stream_class_id
return tc
def create_packet(self):
if not self.cls.supports_packets:
raise ValueError(
'cannot create packet: stream class does not support packets')
packet_ptr = native_bt.packet_create(self._ptr)
if packet_ptr is None:
raise bt2._MemoryError('cannot create packet object')
return bt2_packet._Packet._create_from_ptr(packet_ptr)
def __init__(self, mip_version=0):
utils._check_uint64(mip_version)
if mip_version > bt2.get_maximal_mip_version():
raise ValueError('unknown MIP version {}'.format(mip_version))
ptr = native_bt.graph_create(mip_version)
if ptr is None:
raise bt2._MemoryError('cannot create graph object')
super().__init__(ptr)
def __init__(self, ranges=None):
ptr = self._create_range_set()
if ptr is None:
raise bt2._MemoryError('cannot create range set object')
super().__init__(ptr)
if ranges is not None:
# will raise if not iterable
for rg in ranges:
self.add(rg)
def _create_stream_end_message(self, stream, default_clock_snapshot=None):
utils._check_type(stream, bt2_stream._Stream)
ptr = native_bt.message_stream_end_create(self._bt_ptr, stream._ptr)
if ptr is None:
raise bt2._MemoryError('cannot create stream end message object')
msg = bt2_message._StreamEndMessage(ptr)
if default_clock_snapshot is not None:
msg._default_clock_snapshot = default_clock_snapshot
return msg
def __init__(self,
component_class,
object_name,
params=None,
method_obj=None):
if not isinstance(component_class,
_bt2_component()._ComponentClassConst):
err = False
try:
if not issubclass(component_class,
_bt2_component()._UserComponent):
err = True
except TypeError:
err = True
if err:
o = component_class
raise TypeError(
"'{}' is not a component class object".format(o))
utils._check_str(object_name)
if params is None:
params_ptr = native_bt.value_null
else:
params = bt2.create_value(params)
params_ptr = params._ptr
cc_ptr = component_class._bt_component_class_ptr()
assert cc_ptr is not None
if method_obj is not None and not native_bt.bt2_is_python_component_class(
cc_ptr):
raise ValueError(
'cannot pass a Python object to a non-Python component class')
ptr = native_bt.bt2_query_executor_create(cc_ptr, object_name,
params_ptr, method_obj)
if ptr is None:
raise bt2._MemoryError('cannot create query executor object')
super().__init__(ptr)
# Keep a reference of `method_obj` as the native query executor
# does not have any. This ensures that, when this object's
# query() method is called, the Python object still exists.
self._method_obj = method_obj
def __init__(self, mip_version=0):
utils._check_uint64(mip_version)
if mip_version > bt2.get_maximal_mip_version():
raise ValueError('unknown MIP version {}'.format(mip_version))
ptr = native_bt.graph_create(mip_version)
if ptr is None:
raise bt2._MemoryError('cannot create graph object')
super().__init__(ptr)
# list of listener partials to keep a reference as long as
# this graph exists
self._listener_partials = []
def _create_discarded_packets_message(self,
stream,
count=None,
beg_clock_snapshot=None,
end_clock_snapshot=None):
utils._check_type(stream, bt2_stream._Stream)
if not stream.cls.supports_discarded_packets:
raise ValueError('stream class does not support discarded packets')
if stream.cls.discarded_packets_have_default_clock_snapshots:
if beg_clock_snapshot is None or end_clock_snapshot is None:
raise ValueError(
'discarded packets have default clock snapshots for this stream class'
)
utils._check_uint64(beg_clock_snapshot)
utils._check_uint64(end_clock_snapshot)
if beg_clock_snapshot > end_clock_snapshot:
raise ValueError(
'beginning default clock snapshot value ({}) is greater than end default clock snapshot value ({})'
.format(beg_clock_snapshot, end_clock_snapshot))
ptr = (
native_bt.
message_discarded_packets_create_with_default_clock_snapshots(
self._bt_ptr, stream._ptr, beg_clock_snapshot,
end_clock_snapshot))
else:
if beg_clock_snapshot is not None or end_clock_snapshot is not None:
raise ValueError(
'discarded packets have no default clock snapshots for this stream class'
)
ptr = native_bt.message_discarded_packets_create(
self._bt_ptr, stream._ptr)
if ptr is None:
raise bt2._MemoryError('cannot discarded packets message object')
msg = bt2_message._DiscardedPacketsMessage(ptr)
if count is not None:
msg._count = count
return msg
def _create_event_message(self,
event_class,
parent,
default_clock_snapshot=None):
utils._check_type(event_class, bt2_event_class._EventClass)
if event_class.stream_class.supports_packets:
utils._check_type(parent, bt2_packet._Packet)
else:
utils._check_type(parent, bt2_stream._Stream)
if default_clock_snapshot is not None:
if event_class.stream_class.default_clock_class is None:
raise ValueError(
'event messages in this stream must not have a default clock snapshot'
)
utils._check_uint64(default_clock_snapshot)
if event_class.stream_class.supports_packets:
ptr = native_bt.message_event_create_with_packet_and_default_clock_snapshot(
self._bt_ptr, event_class._ptr, parent._ptr,
default_clock_snapshot)
else:
ptr = native_bt.message_event_create_with_default_clock_snapshot(
self._bt_ptr, event_class._ptr, parent._ptr,
default_clock_snapshot)
else:
if event_class.stream_class.default_clock_class is not None:
raise ValueError(
'event messages in this stream must have a default clock snapshot'
)
if event_class.stream_class.supports_packets:
ptr = native_bt.message_event_create_with_packet(
self._bt_ptr, event_class._ptr, parent._ptr)
else:
ptr = native_bt.message_event_create(self._bt_ptr,
event_class._ptr,
parent._ptr)
if ptr is None:
raise bt2._MemoryError('cannot create event message object')
return bt2_message._EventMessage(ptr)
def _create_clock_class(
self,
frequency=None,
name=None,
user_attributes=None,
description=None,
precision=None,
offset=None,
origin_is_unix_epoch=True,
uuid=None,
):
ptr = self._bt_as_self_component_ptr(self._bt_ptr)
cc_ptr = native_bt.clock_class_create(ptr)
if cc_ptr is None:
raise bt2._MemoryError('could not create clock class')
cc = bt2_clock_class._ClockClass._create_from_ptr(cc_ptr)
if frequency is not None:
cc._frequency = frequency
if name is not None:
cc._name = name
if user_attributes is not None:
cc._user_attributes = user_attributes
if description is not None:
cc._description = description
if precision is not None:
cc._precision = precision
if offset is not None:
cc._offset = offset
cc._origin_is_unix_epoch = origin_is_unix_epoch
if uuid is not None:
cc._uuid = uuid
return cc
def __call__(self, name=None, uuid=None, env=None):
trace_ptr = native_bt.trace_create(self._ptr)
if trace_ptr is None:
raise bt2._MemoryError('cannot create trace class object')
trace = bt2_trace._Trace._create_from_ptr(trace_ptr)
if name is not None:
trace._name = name
if uuid is not None:
trace._uuid = uuid
if env is not None:
for key, value in env.items():
trace.env[key] = value
return trace
def get_greatest_operative_mip_version(component_descriptors,
log_level=bt2.LoggingLevel.NONE):
utils._check_log_level(log_level)
comp_descr_set_ptr = native_bt.component_descriptor_set_create()
if comp_descr_set_ptr is None:
raise bt2._MemoryError('cannot create component descriptor set object')
if len(component_descriptors) == 0:
raise ValueError('no component descriptors')
try:
for descr in component_descriptors:
if type(descr) is not bt2.ComponentDescriptor:
raise TypeError(
"'{}' is not a component descriptor".format(descr))
base_cc_ptr = descr.component_class._bt_component_class_ptr()
params_ptr = None
if descr.params is not None:
params_ptr = descr.params._ptr
status = native_bt.bt2_component_descriptor_set_add_descriptor_with_initialize_method_data(
comp_descr_set_ptr, base_cc_ptr, params_ptr, descr.obj)
utils._handle_func_status(
status, 'cannot add descriptor to component descriptor set')
status, version = native_bt.get_greatest_operative_mip_version(
comp_descr_set_ptr, log_level)
if status == native_bt.__BT_FUNC_STATUS_NO_MATCH:
return None
utils._handle_func_status(status,
'cannot get greatest operative MIP version')
return version
finally:
native_bt.component_descriptor_set_put_ref(comp_descr_set_ptr)
def create_stream(self,
stream_class,
id=None,
name=None,
user_attributes=None):
utils._check_type(stream_class, bt2_stream_class._StreamClass)
if stream_class.assigns_automatic_stream_id:
if id is not None:
raise ValueError(
"id provided, but stream class assigns automatic stream ids"
)
stream_ptr = native_bt.stream_create(stream_class._ptr, self._ptr)
else:
if id is None:
raise ValueError(
"id not provided, but stream class does not assign automatic stream ids"
)
utils._check_uint64(id)
stream_ptr = native_bt.stream_create_with_id(
stream_class._ptr, self._ptr, id)
if stream_ptr is None:
raise bt2._MemoryError('cannot create stream object')
stream = bt2_stream._Stream._create_from_ptr(stream_ptr)
if name is not None:
stream._name = name
if user_attributes is not None:
stream._user_attributes = user_attributes
return stream
def _check_create_status(self, ptr):
if ptr is None:
raise bt2._MemoryError(
'cannot create {} field class object'.format(self._NAME.lower())
)
def _auto_discover_source_component_specs(auto_source_comp_specs, plugin_set):
# Transform a list of `AutoSourceComponentSpec` in a list of `ComponentSpec`
# using the automatic source discovery mechanism.
inputs = bt2.ArrayValue([spec.input for spec in auto_source_comp_specs])
if plugin_set is None:
plugin_set = bt2.find_plugins()
else:
utils._check_type(plugin_set, bt2_plugin._PluginSet)
res_ptr = native_bt.bt2_auto_discover_source_components(
inputs._ptr, plugin_set._ptr)
if res_ptr is None:
raise bt2._MemoryError('cannot auto discover source components')
res = bt2_value._create_from_ptr(res_ptr)
assert type(res) == bt2.MapValue
assert 'status' in res
status = res['status']
utils._handle_func_status(status, 'cannot auto-discover source components')
comp_specs = []
comp_specs_raw = res['results']
assert type(comp_specs_raw) == bt2.ArrayValue
used_input_indices = set()
for comp_spec_raw in comp_specs_raw:
assert type(comp_spec_raw) == bt2.ArrayValue
assert len(comp_spec_raw) == 4
plugin_name = comp_spec_raw[0]
assert type(plugin_name) == bt2.StringValue
plugin_name = str(plugin_name)
class_name = comp_spec_raw[1]
assert type(class_name) == bt2.StringValue
class_name = str(class_name)
comp_inputs = comp_spec_raw[2]
assert type(comp_inputs) == bt2.ArrayValue
comp_orig_indices = comp_spec_raw[3]
assert type(comp_orig_indices)
params = bt2.MapValue()
logging_level = bt2.LoggingLevel.NONE
obj = None
# Compute `params` for this component by piling up params given to all
# AutoSourceComponentSpec objects that contributed in the instantiation
# of this component.
#
# The effective log level for a component is the last one specified
# across the AutoSourceComponentSpec that contributed in its
# instantiation.
for idx in comp_orig_indices:
orig_spec = auto_source_comp_specs[idx]
if orig_spec.params is not None:
params.update(orig_spec.params)
if orig_spec.logging_level is not None:
logging_level = orig_spec.logging_level
if orig_spec.obj is not AutoSourceComponentSpec._no_obj:
obj = orig_spec.obj
used_input_indices.add(int(idx))
params['inputs'] = comp_inputs
comp_specs.append(
ComponentSpec.from_named_plugin_and_component_class(
plugin_name,
class_name,
params=params,
obj=obj,
logging_level=logging_level,
))
if len(used_input_indices) != len(inputs):
unused_input_indices = set(range(len(inputs))) - used_input_indices
unused_input_indices = sorted(unused_input_indices)
unused_inputs = [str(inputs[x]) for x in unused_input_indices]
msg = (
'Some auto source component specs did not produce any component: '
+ ', '.join(unused_inputs))
raise RuntimeError(msg)
return comp_specs
def _check_create_status(self, ptr, type_name):
if ptr is None:
raise bt2._MemoryError(
'cannot create {} field class'.format(type_name))
