This patch makes a `src.ctf.lttng-live` component class handle the
`babeltrace.support-info` query object. The query method replies a
weight of 0.75 (arbitrary, but it leaves some room for other component
classes to recognize this very specific URL format) when the input
string matches
net://HOST[:PORT]/host/TGTHOST/SESSION
This makes it possible to create a conversion graph with a
`src.ctf.lttng-live` source like this:
Note that this will use the component's default "session not found"
action which is to continue, so the `src.ctf.lttng-live` message
iterator will never end. The legacy mode still works, however; when you
do:
Philippe Proulx [Fri, 16 Aug 2019 01:01:49 +0000 (21:01 -0400)]
lib: make empty array/map appending/inserting functions return new object
This makes the bt_value_array_append_empty_array_element(),
bt_value_array_append_empty_map_element(),
bt_value_map_insert_empty_array_entry(), and
bt_value_map_insert_empty_map_entry() accept a new optional output
parameter to return the created empty value object.
The goal of appending/inserting an empty array/map value object is
typically to fill it afterwards, so it makes this less painful, for
example:
bt_value *inner_arr_obj;
status = bt_value_array_append_empty_array_element(outer_array_obj,
&inner_arr_obj);
assert(status == 0);
status = bt_value_array_append_bool_element(inner_arr_obj, true);
assert(status == 0);
status = bt_value_array_append_string_element(inner_arr_obj, "id");
assert(status == 0);
You can pass `NULL` as this new parameter.
The returned reference is borrowed.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I2cd3359f357a3eb1da52c0e1426ef7804a4b13aa
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1948 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Francis Deslauriers <francis.deslauriers@efficios.com> Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
Tests: ctf: add tracers timestamp quirks workaround test cases
This commit adds test traces and test cases to cover the `src.ctf.fs`
workarounds used to support timestamp corner cases or bugs in the
tracers.
Note: I manually modified the test traces to contain problematic
timestamp values using an hex editor as if there would be created by an
affected tracer.
Test traces
===========
* `event-after-packet` lttng test trace
This trace `event-after-packet` was modified manually to simulate the
hard to reproduce `event-after-packet` LTTng tracers bug.
When the bug occurs, the timestamp of the last event of a packet is larger than
the `timestamp_end` of it's own packet. It makes it look like the event
happened after the packet was closed which is non compliant with the CTF
specification.
To create a trace exhibiting this bug, the `timestamp_end` field of
the last 2 packets was made one clock cycle smaller than the timestamp
of the last event of the said packet.
This bug was fixed in the follow versions of the LTTng tracers:
- lttng-ust 2.11.0
- lttng-module 2.11.0
- lttng-module 2.10.10
- lttng-module 2.9.13
* `lttng-crash` test trace
This trace was modified manually to simulate a trace resulting from the
lttng-crash utility.
When extracting a trace using the lttng-crash utility the `timestamp_end` of
some packets may be left uninitialized with the default value of 0.
To create a trace exhibiting this behavior, the `timestamp_end` of the last
three packets were set to 0.
This is _not_ a bug and all LTTng tracers can produce such trace.
* `event-before-packet` barectf test trace
This trace `event-before-packet` exhibits a barectf bug where the first
event of the second packet has a timestamp smaller than the
`timestamp_begin` field of its own packet.
This bug was fixed in barectf tracer version 2.3.1.
Test cases
==========
* `trace-info` query
- Add test case for `event-after-packet` LTTng quirk,
- Add test case for `lttng-crash` workaround.
Both of this test traces used in these test cases are based on the same
trace and the end result on the `trace-info` query is the same. We use
the same code for both test cases.
* Trace decoding
-Add `test_succeed` cases for all three of the above test traces.
Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: Icfdb8052aa2a88038e22ad6a58f391b6d8dbd3df
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1542 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
See prior commit titled:
src.ctf.fs: index: accommodate bug in barectf tracer
for an explanation of the non-compliance of some barectf traces.
How this commit fixes the decoding for the affected traces
==========================================================
When about to emit a packet beginning message, check if the said packet
might be affected by barectf's `event-before-packet` bug by looking at
the version. If it's the case, delay the emission of the packet
beginning message until we decoded the first event of the packet. We
then check if the event is indeed before the packet.
For affected packets, we create packet beginning message using the
timestamp of the first event.
If there is event in the packet, there is nothing to fix so we emit the
packet beginning message when we are about to emit the packet end
message.
Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: Ia94e94edef27971c4acf7ab62463c80411ff1978
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1552 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
See prior commit titled:
src.ctf.fs: index: accommodate bug in LTTng tracers
for an explanation of the non-compliance of some LTTng traces.
How this commit fixes the decoding for the affected traces
==========================================================
When about to emit a packet end message, check if the said packet is
affect by LTTng's `event-after-packet` bug. If it's the case, omit to
update the default_clock_snapshot to the `timestamp_end` of the packet.
This will expand the packet time span to the contain all its events.
Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: I205caf0243c1d6f270bdb1b6508bb55a0806ba19
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1550 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
See previous commit titled:
src.ctf.fs: index: accommodate lttng-crash timestamp quirk
for an explanation of the non-compliance of lttng-crash traces.
How this commit fixes the decoding for the affected traces
==========================================================
When about to emit a packet end message, check if the said packet is
affected by the trace-crash non-compliance. If it's the case, omit to
update the default_clock_snapshot to the `timestamp_end` of the packet.
Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: If965a424afa160692c2ec148fc8f60d3d9ac1273
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1548 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
This commit is to accommodate the indexing of non-compliant CTF traces
produced by LTTng tracers and extracted by the lttng-crash utility.
What makes those traces non-compliant ?
=======================================
The lttng-crash is used to extract a trace from the tracing buffers from
non-volatile memory following a system crash. Because a system crash can
happen at any time, it's possible that some tracing packets might not
have been closed properly. It's possible to observe this by looking at
the `timestamp_end` field of the packets. They might be left to their
initial value of 0 when their `timestamp_begin` are often larger than 0.
This has the higher level effect that affected packets have a
`timestamp_end` smaller than their `timestamp_begin`, as if their end
time was before the beginning time.
How this commit fixes the index for the affected traces
=====================================================
For each index entry, if the entry's `timestamp_end` is 0 and the
`timestamp_begin` is not 0:
- If it's the stream file's last packet: set the packet index entry's end
time to the packet's last event's time, if any, or to the packet's
beginning time otherwise.
- If it's not the stream file's last packet: set the packet index
entry's end time to the next packet's beginning time.
Affected versions
=================
All current and future lttng-ust and lttng-modules versions are affect
because this really cannot be fixed by the tracers because lttng-crash
only tries to make the most of a critical situation (i.e. a system
crash).
Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: Ib6ff9683b676983d8691f514f4d6c3e5c8c7e071
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1436 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
This commit is to accommodate the indexing of non-compliant CTF traces
produced by the barectf tracer.
What makes those traces non-compliant ?
=======================================
A bug in barectf leads to events being emitted with timestamp less than
their packet's `timestamp_begin` field.
At a higher level, such event would appear as before the beginning of
its own containing packet and not within the range of any packet of the
trace.
How this commit fixes the index for the affected traces
=====================================================
For each index entry excluding the first:
- Decode the packet until the first event and use the timestamp of
this event as the `timestamp_begin` of this index entry.
- Set the previous index entry's `timestamp_end` to the
`timestamp_end` of the current index entry.
Affected versions
=================
- before barectf 2.3.1
This commit is to accommodate the indexing of non-compliant CTF traces
produced by LTTng tracers.
What makes those traces non-compliant ?
=======================================
A bug in lttng tracers may lead them to emit events with timestamps that
are greater than the timestamp_end of the their packets.
At a higher level, such event would appear as not within the range of a
packet in the trace.
How this commit fixes the index for the affected traces
=======================================================
For each index entry:
- If it's the stream file's last packet: set the packet index entry's end
time to the packet's last event's time by decoding the packet, if
any, or to the packet's beginning time otherwise.
- If it's not the stream file's last packet: set the packet index
entry's end time to the next packet's beginning time.
Affected versions
=================
- before lttng-ust 2.11.0
- before lttng-module 2.11.0
- before lttng-module 2.10.10
- before lttng-module 2.9.13
This commit adds a utility function to extract tracer version of a given
trace.
Because, it was discovered that some tracers may produce non-compliant
CTF traces more-or-less frequently. To accommodate those external tools,
we will add ad-hoc fixes for the affected version. We thus need a way to
check the tracer versions of the traces.
Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: I67e73a5928dfac0cebc1135552f5525af930ebfc
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1418 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Adds functions to extract the timestamp of the first and last event of
the current packet.
BT_HIDDEN
enum bt_msg_iter_status bt_msg_iter_first_event_clock_snapshot(
struct bt_msg_iter *notit, uint64_t *first_event_cs);
Those functions use the `decode_until_state()` function to decode the
current packet until one of two specific states and then used the clock
value of the default clock class.
Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: I18736151fd8367fb33c6b46d81a860f54432ad55
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1432 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Dry-run mode can be used when component classes need to decode CTF
packets but do not want the `bt_msg_iter` to create and use the
Babeltrace library objects (bt_field, bt_message_*, etc.).
Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: I336ec4c893835e7b1d6f32262841793f7543aa06
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1417 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
ctf: only reset state of `bt_msg_iter` on _reset()
The `bt_msg_iter` configuration should be left untouched by the reset.
The `bt_msg_iter_reset()` is used at the creation of the `bt_msg_iter`
(`bt_msg_iter_create()`) and when seeking with it
(`bt_msg_iter_seek()`). It's also used by `src.ctf.fs` message iterators
when seeking is done.
Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: I2ab948858aa5b955a3063174c9887c54d98bad5d
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1416 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
You can set the user attributes of those objects at creation time, when
calling the creation method, or when appending a structure field class
member or a variant field class option for `_StructureFieldClassMember`
and `_VariantFieldClassOption`.
To make the `_user_attributes` property of `_StructureFieldClassMember`
and `_VariantFieldClassOption` above possible, I made them wrap a real
BT pointer and keep a reference on the owning field class, making all
the properties make a call to the library instead of the object just
containing them.
In `test_field_class.py`, because there's now a common property to test
for each field class, the new `_TestFieldClass` mixin does that,
requiring a _create_default_field_class() method which accepts custom
positional and keyword arguments to create a specific default field
class to test.
Philippe Proulx [Wed, 14 Aug 2019 17:34:10 +0000 (13:34 -0400)]
sink.text.details: print user attributes
This patch makes a `sink.text.details` component print user attributes.
The component only prints user attributes when the map value is not
empty.
The output looks like this:
Event class (ID 0):
User attributes:
domain: Python
ip: Length 4:
[0]: 192
[1]: 168
[2]: 0
[3]: 100
weight: 17.231600
with-net: Yes
...
The new write_value() function textually and recursively serializes a
value object. When writing a map value object, the keys are sorted
first.
The change brought by this patch is not invasive in that all the current
test expectation files do not need any change because the sources never
set any user attribute. The goal of this patch is not to add any textual
noise.
When an enumeration, a structure, or a variant field class has user
attributes, the component prints the mappings, members, and options
indented within a dedicated section, for example:
Payload field class: Structure (3 members):
User attributes:
a: 23
b: 'log'
Members:
hello: String
bbb: Boolean
opt: Option:
Content: Unsigned integer (64-bit, Base 10)
The same strategy applies to structure field class members and variant
field class options:
Payload field class: Structure (3 members):
hello:
Field class: String
User attributes:
factor: 17.150000
bbb: Boolean
opt: Option:
Content: Unsigned integer (64-bit, Base 10)
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Icf3060dbf23bab607ebb7af6e839aa5b28bd2658
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1926 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Philippe Proulx [Wed, 14 Aug 2019 03:21:46 +0000 (23:21 -0400)]
lib: add user attributes property to metadata, stream, and trace objects
This patch adds an optional user attributes property to the following
trace IR objects:
* Clock class
* Event class
* Field class
* Structure field class member
* Variant field class option
* Stream class
* Stream
* Trace class
* Trace
A user attributes object is a map value object which adds custom
information to any of the objects above. It is entirely up to the user
to set user attributes. At creation time, all the objects above contain
an initial, empty map value.
CTF 2 will very likely have such user attributes for metadata objects,
so Babeltrace 2.0 will be ready.
For CTF 2, it is intended that user attributes will be namespaced to
reduce or eliminate clashes, for example using URLs or domain names,
which are also typically used for Java packages and XML namespaces:
CTF 2 will only have user attributes for metadata objects, but I decided
to also have user attributes for long-lived data objects: streams and
traces.
This is not enforced in Babeltrace however: the user is free to put
whatever she needs into this map value.
There's a bt_*_set_user_attributes() function to set the user attributes
of an object and
bt_*_borrow_user_attributes()/bt_*_borrow_user_attributes_const()
functions to borrow them from the object.
This patch changes when structure field class members and variant field
class options are frozen:
Before this patch:
When you append to a structure/variant field class, the
member/option is frozen, including its field class.
With this patch:
When you append to a structure/variant field class, the
member/option itself is not frozen, but its field class is.
The member/option is frozen when its containing structure/variant
field class is frozen.
This makes it possible to append a member/option to a structure/variant
field class, borrow that member/option, and then set its user attributes
before the whole structure/variant field class is frozen.
Those are non-const versions of the existing
bt_field_class_variant_borrow_option_by_index_const() and
bt_field_class_variant_borrow_option_by_name_const().
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I322c202c35d815012d2f6de494dce76a161692e4
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1920 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Philippe Proulx [Tue, 13 Aug 2019 23:35:12 +0000 (19:35 -0400)]
bt2: add bit array field class and field support
This patch adds bit array field class and field support to the Python
bindings.
A bit array field class has a `length` property (number of bits in the
array).
As of this patch, a bit array field is not a Python sequence. It could
become in the future however. The way to access a bit array field's
value is the `value_as_integer` property which simply wraps the
corresponding library functions.
A bit array field is not considered a numeric field. Its _spec_eq()
method only compares if the other object is also a bit array fields.
I did not implement the __bool__() operator because it will need to
satisfy the Python sequence protocol (length is not 0, which in fact is
always the case with a bit array field), should we decide as such in the
future. I implemented the __len__() operator however which is
straightforward.
Philippe Proulx [Tue, 13 Aug 2019 23:09:25 +0000 (19:09 -0400)]
sink.ctf.fs: write bit array field classes and fields
This patch makes a `sink.ctf.fs` component handle bit array field classes
and fields. Because CTF 1.8 has no bit array field class type, it makes a
best effort and translates it to an unsigned integer field class with
a hexadecimal base.
When a `src.ctf.fs` component reads a trace generated by `sink.ctf.fs`
where the input trace IR contained bit array field classes, the
corresponding unsigned integer field classes will stay unsigned integer
field classes; the source component has no way to determine if the
metadata describes a bit array field class or a genuine unsigned integer
field class. However, the CTF 1.8 to CTF 1.8 scenario will always be
unambiguous because a `src.ctf.fs` component never creates bit array
field classes.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I6375723d8513b06f984dc27f88d3d9b668191d21
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1911 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Philippe Proulx [Tue, 13 Aug 2019 21:34:02 +0000 (17:34 -0400)]
lib: add bit array field class and field types
This patch adds the bit array field class (FC) and field to the
available library types.
A bit array field is a simple array of bits. As opposed to integer
fields, a bit array field has no sign: it does not contain a quantity.
Such a field can be used to hold CPU register values, for example, or an
array of flags which is typically read and written as a (small) unsigned
integer.
CTF 2 will very likely have such a type, so Babeltrace 2.0 will be
ready.
You create a bit array FC with bt_field_class_bit_array_create(). This
function expects a length parameter which must be in the [1, 64] range
as of this version. The length is the number of bits in the array. You
can get the length of a bit array with
bt_field_class_bit_array_get_length().
You can set the value of a bit array field with
bt_field_bit_array_set_value_as_integer(). This function accepts an
unsigned integer and conceptually sets all the bits of the array
accordingly, where the _first_ bit of the array is the LSB of the value.
In other words, should there be a bit accessor (by index), getting the
value of bit 0 would return the LSB of that unsigned integer:
0 1 1 0 1 1 0 1
^ MSB: bit 7 ^ LSB: bit 0
Unsigned integer value: 0x6d
As such, you can get the value of the bit array with
bt_field_bit_array_get_value_as_integer(). Again, the value of bit 0 is
the LSB of the returned unsigned integer.
I chose to apply a mask to the received value in
bt_field_bit_array_set_value_as_integer() to ensure that there's no set
bit outside the bit array's range. This is to lessen the user's burden
instead of a having a precondition assertion. This in turns guarantees
that bt_field_bit_array_get_value_as_integer() always returns a value
without superfluous set bit. If this automatic masking becomes a
performance issue in the future, then we can add another function which
expects the user to do it (with a precondition assertion).
This patch does not adapt existing plugins and the Python bindings to
use and wrap the new bit array FC and field; this work is reserved for
subsequent patches.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I8ba4d111df275962cfa9f2c4f754f83a1de40e29
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1907 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Philippe Proulx [Tue, 13 Aug 2019 15:58:10 +0000 (11:58 -0400)]
bt2: add option field class and field support
This patch adds option field class and field support to the Python
bindings.
You can create an option field class with
_TraceClass.create_option_field_class(). This method requires the
optional field class and also accepts an optional selector field class
(just like the library's equivalent bt_field_class_option_create()
function).
An option field class only has the `field_class` (the optional field
class) and `selector_field_path` (can be `None`) properties.
An option field is similar to a variant field:
* You can use the `has_field` property to set whether or not the option
field has an optional field.
* You can access the optional field with the `field` property, which
returns `None` when the option field has no field.
* The __bool__() operator of an option field is the equivalent of the
`has_field` property.
* You can use the `value` property (write only, like
`_VariantField.value`) to assign a value to the optional field. This
property also sets `has_field` to `True` so it's always safe to use.
Philippe Proulx [Tue, 13 Aug 2019 00:16:09 +0000 (20:16 -0400)]
sink.ctf.fs: write option field classes and fields
This patch makes a `sink.ctf.fs` component handle option field classes
and fields. Because CTF 1.8 has no option field class type, it makes a
best effort and translates it to a variant field class with two
options:
* An empty structure field class (option field contains nothing).
* The optional field class itself.
The tag field class is always generated before the variant field class
and is an 8-bit unsigned enumeration field class.
For example, a `sink.ctf.fs` component would translate an optional
string field class to:
/*
* This enumeration field class and the following variant field
* class were a trace IR option field class.
*/
enum : integer { size = 8; align = 8; } {
none = 0,
content = 1,
} __module_name_tag;
variant <__module_name_tag> {
struct { } none;
string { encoding = UTF8; } content;
} module_name;
When a `src.ctf.fs` component reads a trace generated by `sink.ctf.fs`
where the input trace IR contained option field classes, the
corresponding variant field classes will stay variant field classes; the
source component has no way to determine if the metadata describes an
option field class or a genuine variant field class. However, the CTF
1.8 to CTF 1.8 scenario will always be unambiguous because a
`src.ctf.fs` component never creates option field classes.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Ib83e011f73795d70cd8545f55ea87e0bf10b68bc
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1901 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Philippe Proulx [Mon, 12 Aug 2019 22:15:04 +0000 (18:15 -0400)]
sink.text.pretty: print option fields
The component prints `<none>` when there's no current optional field,
and does the same as a variant field otherwise (printing the optional
field's value between `{` and `}`).
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I7a42ca31d68562fa0994945b32dbb2935aa92ee4
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1899 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Philippe Proulx [Mon, 12 Aug 2019 21:09:38 +0000 (17:09 -0400)]
lib: add option field class and field types
This patch adds the option field class (FC) and field to the available
library types.
An option field can contain or not another field. It is very similar to
a variant field in that it's a choice between two things.
CTF 2 will very likely have such a type, so Babeltrace 2.0 will be
ready.
Like a variant FC, an option FC can have a selector which must be a
reachable boolean FC.
When you create an option with bt_field_class_option_create(), you pass
the optional FC, which becomes frozen on success.
You can borrow the optional FC of an option FC with
bt_field_class_option_borrow_field_class_const(). If the option FC has a
selector FC, you can borrow the computed selector field path with
bt_field_class_option_borrow_selector_field_path_const().
To set whether or not an option field contains a field, call
bt_field_option_set_has_field(). You must call this function even if the
option field contains no field (with `BT_FALSE`) because field objects
are pooled and not reset for each message in production mode (similar to
how you must initially call bt_field_string_clear() before you call
bt_field_string_append()). Once you have called
bt_field_option_set_has_field() with `BT_TRUE`, you can borrow the
optional field with bt_field_option_borrow_field() to fill it.
On the const side, you can borrow an option field's optional field with
bt_field_option_borrow_field_const(). This function returns `NULL` if
the option field does not contain a field.
This patch also adds the
`BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT` field path item type.
Such a field path item means the current field of an option field.
This patch does not adapt existing plugins and the Python bindings to
use and wrap the new option FC and field; this work is reserved
for subsequent patches.
Philippe Proulx [Mon, 12 Aug 2019 02:04:08 +0000 (22:04 -0400)]
bt2: add boolean field class and field support
This patch adds boolean field class and field support to the Python
bindings.
A boolean field class has no properties.
A boolean field is a numeric field (like Python's `bool` is a numeric
type). The `BoolFieldTestCase` test case inherits `_TestNumericField`,
making sure the field behaves more or less like the Python `bool` type.
`BoolFieldTestCase` is very similar to `BoolValueTestCase`.
Just like `BoolValue` objects, you can set the value of a `BoolField`
object from a `bool` or `BoolField` object.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Ib6d0723d69709b7f3b459ba173eb7cbea5d8c435
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1896 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Francis Deslauriers <francis.deslauriers@efficios.com> Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
Philippe Proulx [Sun, 11 Aug 2019 16:03:55 +0000 (12:03 -0400)]
sink.ctf.fs: write boolean field classes and fields
This patch makes a `sink.ctf.fs` component handle boolean field classes
and fields. Because CTF 1.8 has no boolean field class type, it makes a
best effort and translates it to an 8-bit unsigned integer field class.
A boolean field is written as an 8-bit unsigned integer field having the
value 0 (false) or 1 (true).
When a `src.ctf.fs` component reads a trace generated by `sink.ctf.fs`
where the input trace IR contained boolean field classes, the 8-bit
unsigned integer field classes will stay integer field classes; the
source component has no way to determine if the metadata describes a
boolean field class or a genuine integer field class. However, the CTF
1.8 to CTF 1.8 scenario will always be unambiguous because a
`src.ctf.fs` component never creates boolean field classes.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I6be5967c2312bdb0e67be7db14ab663912872403
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1895 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Philippe Proulx [Sun, 11 Aug 2019 15:20:14 +0000 (11:20 -0400)]
lib: add boolean field class and field types
This patch adds the boolean field class and field to the available
library types. They are analogous to the boolean value object which
already exists.
CTF 2 will very likely have such a type, so Babeltrace 2.0 will be
ready.
This patch does not adapt existing plugins and the Python bindings to
use and wrap the new boolean field class and field; this work is
reserved for subsequent patches.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I90874f214757ad67d5eecaad5bd8297b8610c001
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1891 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Simon Marchi [Tue, 13 Aug 2019 19:30:15 +0000 (15:30 -0400)]
tests: return 0 instead of None for unknown file in test component class support-info query
I noticed some spurious warnings while running
TestAutoDiscoverSourceComponentSpecsGrouping.test_grouping (shortened
for brevity):
unexpected result type: component-class-name=source.test.TestSourceExt, input=/home/smarchi/src/babeltrace/tests/data/auto-source-discovery/grouping/bt_plugin_test.py, input-type=file, expected-types=REAL,MAP,SIGNED_INTEGER, actual-type=NULL
Indeed, the _query method of TestSourceExt fails to return a value (so
it returns None) if it doesn't know the file. This is not on purpose in
this test, so fix it.
Change-Id: I303c78dae4a518c62573263aa7a3afafd0c61ed7 Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1906 Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com> Tested-by: jenkins <jenkins@lttng.org>
Jonathan Rajotte [Tue, 13 Aug 2019 22:51:32 +0000 (18:51 -0400)]
Use uuid as first comparison criteria
This is most important in the message ordering reproducibility against
multiple sources where some might populate the trace name and some don't.
A good example of a source not populating the trace name is lttng-live.
It facilitates the testing of lttng-live source plugin since it is
possible to compare it to the src.ctf.fs plugin directly.
Philippe adds: there's a trace UUID property in a CTF metadata stream,
but no trace name property. The trace name is entirely up to the
specific CTF source component class. Therefore it's safer to use the
UUID to distinguish unique traces.
Signed-off-by: Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
Change-Id: I39f3c513e27bffd51ca02b089c097ac406e3316e
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1914
CI-Build: Philippe Proulx <eeppeliteloop@gmail.com> Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Fix: src.ctf.lttng-live: missing ordering within traces and streams
Issue
=====
Sorting of messages with the same timestamps are different from the
messages sorted by the a `flt.utils.muxer` component. This is caused by
the fact that we are not sorting messages within sessions and traces
but only across the different session currently handled by the
component.
Indeed, we need to sort messages at across three locations in the code
to ensure proper ordering: sessions, traces, and streams.
Solution
========
Handle messages with the same timestamps at each of these three
locations using the `common_muxing_compare_messages()` function.
Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: Iadc66f3b6a12f34522f6364b3f47f15eefa87930
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1888 Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com> Tested-by: jenkins <jenkins@lttng.org>
Philippe Proulx [Mon, 12 Aug 2019 03:01:00 +0000 (23:01 -0400)]
bt2: `TraceCollectionMessageIterator`: find greatest MIP version
This patch makes the `TraceCollectionMessageIterator` object use
bt2.get_greatest_operative_mip_version() to find the greatest operative
MIP version of all the components to create, including the stream
intersection `flt.utils.trimmer` components, and then use the result to
create the graph with bt2.Graph().
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Id9024a2343d0e99384ae62bd77754912a4267dac
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1881 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
Philippe Proulx [Sun, 11 Aug 2019 06:36:41 +0000 (02:36 -0400)]
cli: find greatest operative MIP version to create `run` command's graph
This patch makes the CLI's `run` command use
bt_get_greatest_operative_mip_version() to find the greatest operative
MIP version of all the components to create, including the stream
intersection `flt.utils.trimmer` components, and then use the result to
create the graph with bt_graph_create().
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I2e791ac9c8806457fa850d0dad72ea3ab6912f08
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1879 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
Philippe Proulx [Sun, 11 Aug 2019 03:24:13 +0000 (23:24 -0400)]
lib: bt_graph_create(): accept MIP version
This patch makes bt_graph_create() accept the message interchange
protocol (MIP) version with which to configure the graph.
This MIP version will usually come from
bt_get_greatest_operative_mip_version() or bt_get_maximal_mip_version().
The components can access the configured MIP version with
bt_self_component_get_graph_mip_version().
As of this patch the only possible MIP version is 0. bt_graph_create()
does not accept a MIP version that is greater than
bt_get_maximal_mip_version() because almost all the library functions
need to know the configured MIP version to behave accordingly, should
the semantics change in the future.
In Python, Graph.__init__() accepts a `mip_version` parameter which
defaults to 0. A Python component can get the configured MIP version of
its operating graph with the `_UserComponent._graph_mip_version`
property.
All the sites where bt_graph_create() is called pass 0 to it. This is
correct for tests as we always control the component classes and
initialization parameters, so we know that 0 is always supported by
them. The locations where bt_get_greatest_operative_mip_version() must
be used are the CLI and `bt2.TraceCollectionMessageIterator`. Those
sites will be addressed by subsequent patches.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I324a317922a8caa5557043ae02b97e58fc91d92d
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1878 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
Those new functions wrap bt_get_greatest_operative_mip_version() and
bt_get_maximal_mip_version().
bt2.get_greatest_operative_mip_version() excepts a list of
`bt2.ComponentDescriptor` objects. The function builds a component
descriptor set (bt_component_descriptor_set_create()) and adds the
corresponding component descriptors to it and then calls
bt_get_greatest_operative_mip_version().
bt_get_greatest_operative_mip_version() translates
`BT_GET_OPERATIVE_MIP_VERSION_STATUS_NO_MATCH` into `None`.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Iaeb36b976f3c651fa82a86de2e835f782d682299
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1877 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
Philippe Proulx [Mon, 12 Aug 2019 21:19:46 +0000 (17:19 -0400)]
bt2: add "get supported MIP versions" method support
This patch makes the `bt2` package wrap the library's "get supported MIP
versions" component class method.
In a Python component class, it is expected that the optional
_user_get_supported_mip_versions() method returns either a
`bt2.UnsignedIntegerRangeSet` object or what such an object needs to be
constructed. In other words, the method can return, for example:
return [0, 1, (3, 5)]
Like in the library, the default _user_get_supported_mip_versions()
returns 0 (only protocol 0 supported):
_bt_get_supported_mip_versions_from_native() returns a new reference on
this unsigned integer range set. Then, the native
component_class_get_supported_mip_versions() copies the ranges from the
returned range set to the range set to fill. I believe this makes
_user_get_supported_mip_versions() easier to use than receiving a range
set object and filling it like it's done in C.
The feature is not tested in this patch because the "get supported MIP
versions" method is not used within the library.
Philippe Proulx [Sat, 10 Aug 2019 18:53:32 +0000 (14:53 -0400)]
bt2: add `ComponentDescriptor` class and test
The goal of a `ComponentDescriptor` object is to eventually be used
within an array of descriptors passed to a function which computes an
effective message interchange protocol version with the help of version
support component class methods.
I choose not to wrap the `bt_component_descriptor_set` API as this is
so simple and will be used at a single location.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Ifef9b4fb0a7cf0278dbf8bed2d18d0b47934a272
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1873 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
This patch adds the bt_get_greatest_operative_mip_version() and
bt_get_maximal_mip_version() functions.
The bt_get_greatest_operative_mip_version() accepts a set of component
descriptors and returns, on success, the (greatest) operative message
interchange protocol (MIP) version for all those descriptors.
bt_get_greatest_operative_mip_version() can fail if any component class's "get
supported MIP versions" fails. It can also return
`BT_GET_OPERATIVE_MIP_VERSION_STATUS_NO_MATCH` if any component
descriptor does not support MIP version 0, the only MIP version
currently supported by the the library.
bt_get_maximal_mip_version() returns the maximal MIP version supported
by the library (currently 0).
The purpose of both functions is to be used eventually to create a graph
of which all the components and the library itself operate using a
specific MIP. You can use bt_get_greatest_operative_mip_version() to find the
greatest compatible MIP version to be used by that set of component
descriptors, or you can use bt_get_maximal_mip_version() to get the
greatest MIP version possible for that library.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: If3875b3d76ddca2b4d58a18a829394eadb3bcd39
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1872 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
Philippe Proulx [Sat, 10 Aug 2019 19:18:17 +0000 (15:18 -0400)]
lib: add "get supported MIP versions" method support
This patch adds a new optional method to component classes: get
supported message interchange protocol (MIP) versions.
As of this patch, you can set the "get supported MIP versions" method of
a component class, but it's not used.
The "message interchange protocol" term is very long so I chose to use
the acronym "mip" in the API. The API documentation will make this more
clear.
The method is considered a "class method"; no component exists yet when
calling it (like the query method). The method receives the component
class, the initialization parameters, the initalization method custom
data, and an existing, empty unsigned integer range set. The method's
purpose is to fill this integer range set with all the MIP versions it
supports depending on the initialization configuration. This makes it
possible to support specific MIP versions based on an input path or URI,
for example.
It is a postcondition that the method adds at least one MIP version to
the unsigned integer range set.
The "get supported MIP versions" method is optional: not implementing it
corresponds to adding [0, 0] to the unsigned integer range set. This
makes it possible to implement a component class of which the instance
operates according to the MIP protocol of Babeltrace 2.0.
The "get supported MIP versions" method can fail, but it cannot return
a "try again" status.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Ib26ec9e90b47a3d3e51cc56465a264de9d02b97c
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1870 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
The motivation is to eventually be able to get an effective/compatible
message interchange protocol version number from such a set.
As of this patch, the API is available, but it's not used anywhere.
A component descriptor set is a shared object.
You add a component descriptor to a component descriptor set with
bt_component_descriptor_set_add_descriptor(). Internally, the descriptor
gets appended to one of the source, filter, or sink descriptor array to
eventually have bt_component_descriptor_get_*_descriptor_count() and
bt_component_descriptor_set_borrow_*_descriptor_by_index_const()
functions if needed.
Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: I337d4c596bd988b20849700daf9747a3f188450d
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1868 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
Philippe Proulx [Mon, 12 Aug 2019 19:46:05 +0000 (15:46 -0400)]
bt2: py_plugin.py: cache `_PluginInfo` objects
This patch makes _try_load_plugin_module() cache the `_PluginInfo`
objects it creates. The cache, `_plugin_infos`, maps a Python plugin
absolute path to a `_PluginInfo` object.
This avoids loading the Python module twice, which can create problems,
for example destroying component classes earlier than expected when the
new module replaces the old one in `sys.modules`.
Simon Marchi [Mon, 12 Aug 2019 18:37:58 +0000 (14:37 -0400)]
bt2: raise an exception if an AutoSourceComponentSpec produces no component
We don't do anything special at the moment if an AutoSourceComponentSpec
passed to TraceCollectionMessageIterator produces no component. The
created graph will have no source component and the message iterator
will produce no message:
In [5]: list(bt2.TraceCollectionMessageIterator('/yomadame'))
08-12 14:43:03.938 20284 20284 W CLI-CFG-SRC-AUTO-DISC auto_discover_source_components@autodisc.c:755 No trace was found based on input `/yomadame`.
Out[5]: []
This patch changes the behavior to be a bit more strict. If any
AutoSourceComponentSpec passed to TraceCollectionMessageIterator ends up
producing no component, an exception is raised. In the following example, the
directory `/home/smarchi/lttng-traces` does contain some valid traces, and
therefore produces some components, whereas the string `/yomadame` does not
produce any.
In [2]: bt2.TraceCollectionMessageIterator(['/home/smarchi/lttng-traces', '/yomadame'])
08-12 14:45:06.433 24428 24428 W CLI-CFG-SRC-AUTO-DISC auto_discover_source_components@autodisc.c:755 No trace was found based on input `/yomadame`.
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
<ipython-input-2-107461e1b36b> in <module>
----> 1 bt2.TraceCollectionMessageIterator(['/home/smarchi/lttng-traces', '/yomadame'])
~/build/babeltrace/src/bindings/python/bt2/build/build_lib/bt2/trace_collection_message_iterator.py in _auto_discover_source_component_specs(auto_source_comp_specs, plugin_set)
194
195 msg = 'Some auto source component specs did not produce any component: ' + ', '.join(unused_inputs)
--> 196 raise RuntimeError(msg)
197
198 return comp_specs
RuntimeError: Some auto source component specs did not produce any component: /yomadame
Change-Id: I6c6df9fad18915e294559948812a8213596affdf Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1885 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Simon Marchi [Mon, 12 Aug 2019 16:25:59 +0000 (12:25 -0400)]
tests: use os.pathsep when appending to BABELTRACE_PLUGIN_PATH
On Windows, we expect BABELTRACE_PLUGIN_PATH entries to be separated
with ';', not ':' (like PATH). Python conveniently provides an
OS-dependent definition for this.
Change-Id: Ie53af04e933258963b8495c72e7607a623e83ddb Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1883 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Philippe Proulx [Sun, 11 Aug 2019 15:33:40 +0000 (11:33 -0400)]
test_plugin.py: do not search in user/system directories for tests
In `test_plugin.py`, make bt2.find_plugin() not search in user and
system directories so that it needs to find the specific plugin in the
test's search path (given by `BABELTRACE_PLUGIN_PATH`) or fail.
Simon Marchi [Sun, 11 Aug 2019 02:31:41 +0000 (22:31 -0400)]
Fix: bt2: replace bt2.CreationError instances with bt2._MemoryError
Commit
4acc866e8298 ("bt2: rename CreationError to MemoryError, handle it in and out of Python bindings")
removed bt2.CreationError in favor of bt2.MemoryError (now
bt2._MemoryError). However, some usages of bt2.CreationError were
introduced afterwards, probably by patches that were in the pipeline.
Replace them with bt2._MemoryError.
Change-Id: Id3cb6542e507b1e41c165ca61df21069d72fb44f Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1867 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Simon Marchi [Mon, 5 Aug 2019 18:45:38 +0000 (14:45 -0400)]
bt2: add auto source discovery support to TraceCollectionMessageIterator
This patch makes TraceCollectionMessageIterator capable of automatically
detecting source components from given input strings, similar to how the
command line interface does.
A new type AutoSourceComponentSpec is introduced. The user can
instantiate this type, passing a mandatory input string (equivalent to a
non-option argument on the CLI). The user can then pass instances of
AutoSourceComponentSpec in the source_component_specs list when creating
a TraceCollectionMessageIterator. In
TraceCollectionMessageIterator.__init_, we run the automatic source
algorithm on all inputs passed through AutoSourceComponentSpec
objects. We create ComponentSpec from the results of the auto discovery
and append them to the source component spec list. The rest of the
TraceCollectionMessageIterator then works as before.
The user can attach params and log levels to AutoSourceComponentSpec
inputs. The semantic for those is the same as for the CLI. There is
also an `obj` parameter, allowing to pass an arbitrary Python object.
The semantic for this one is the same as the log level: if an
auto-discovered component comes from multiple inputs, it will receive
the obj of the last input that contributed to getting it instantiated
that has a non-None `obj`.
For convenience, some shorthands when creating a
TraceCollectionMessageIterator are equivalent to using an
AutoSourceComponentSpec. For example, these three forms are equivalent:
New test cases are added to test the new feature. They are based on
the corresponding CLI tests, in that they test equivalent scenarios
(same inputs, expecting the same results).
In order for TraceCollectionMessageIterator to find the test plugin
(both bt_plugin_test.py files), the only way I found was to amend
BABELTRACE_PLUGIN_PATH for the duration of the test.
Change-Id: I0e1100d850c920723861609cfa14707f8c669892 Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1826 Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com> Tested-by: jenkins <jenkins@lttng.org>
Simon Marchi [Mon, 5 Aug 2019 15:05:08 +0000 (11:05 -0400)]
Move autodisc to its own convenience library
Since we'll want to make TraceCollectionMessageIterator have an
automatic source discovery feature, like the CLI has, move the auto
discovery code to its own library, which doesn't have any dependency on
the CLI.
To avoid dependencies on the CLI, here are the changes done to the auto
discovery code:
- To avoid depending on cli_query, use a simplified version,
simple_query, included in the auto discovery code. It doesn't handle
retrying if the status is TRY_AGAIN, as it is not very likely that a
babeltrace2.support-info query implementation will need to do that, as
we want them to be very fast (we can always revisit it in the future).
- Avoid using BT_CLI_LOGE_APPEND_CAUSE, replace with the new
BT_AUTODISC_LOGE_AND_APPEND.
- Don't use require_loaded_plugins, get_loaded_plugins_count and
borrow_loaded_plugin, as those are CLI-specific. Instead, the caller of
auto_discover_source_components must provide an array of plugins.
- plugin_restrict, used to filter down to a single plugin by name, is
removed. Instead, it is the caller's responsibility to pass a single
plugin to `plugins` if it wants to restrict the search to a single
plugin.
A side effect of moving the code is that a warning is now printed by
default when no input is found from non-option argument. I think this
is desirable to have this warning printed, so I have opted to update the
test case to expect it.
Change-Id: Id4009976430126d926eac46ff044365a6b2bc006 Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1825 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Simon Marchi [Fri, 9 Aug 2019 21:17:35 +0000 (17:17 -0400)]
tests: make auto-source-discovery-{log_level,params} tests use sink.text.details
For the same rationale as the previous patch, change how the test
component classes for test_auto_source_discovery_params and
test_auto_source_discovery_log_level report what they receive from a
print to stdout to stream name.
Change-Id: I62405ccd1fbdbe708fbec5dacc52894d4060dfb0 Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1864 Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com> Tested-by: jenkins <jenkins@lttng.org>
Simon Marchi [Fri, 9 Aug 2019 20:08:37 +0000 (16:08 -0400)]
tests: make auto-source-discovery-grouping test use sink.text.details
This patch changes the way that test component classes for the auto
source discovery grouping CLI test reports the inputs passed to each
instantiated component.
Currently, they print to stdout the input names
in the components' __init__. That is then check by the test script
(test_auto_source_discovery_grouping). The
TraceCollectionMessageIterator class in the Python bindings will soon
have the capability to automatically discover source components.
However, it's not practical to use the same test method in Python.
To facilitate this, make the test component classes report the inputs
they receive by sending a stream beginning message, where the stream
name contains the input names. The eventual Python test will be able to
inspect the stream name to validate that the right inputs were passed to
each component.
Since the information is now passed in messages, the
test_auto_source_discovery_grouping test now uses the details sink.
Change-Id: Ie5c12e390f5b68fb50a6d18c53463860fb7a1c99 Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1863 Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com> Tested-by: jenkins <jenkins@lttng.org>
Simon Marchi [Thu, 8 Aug 2019 17:58:47 +0000 (13:58 -0400)]
tests: print executed CLI command line in bt_cli
When debugging a test, it is often useful to have the complete
CLI command line executed, so we can copy paste it and reproduce
the failure by hand.
This patch makes bt_cli echo the executed CLI command line to
stderr, such that it will show up when running one test by hand and in
the test logs when running "make check".
This allows simplifying bt_diff: we no longer have to pass the
CLI arguments to have them included in the error message, since
the full CLI command line will typically be printed just above.
Change-Id: I64f8c80f648d06319efe4e7544447183ba8069cc Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1839 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Simon Marchi [Thu, 8 Aug 2019 15:09:11 +0000 (11:09 -0400)]
tests: add bt_cli util function
Add a function that simply runs the CLI, redirecting stdout and
stderr to the specified files. This will allow more flexible tests than
the existing "diff" function.
Change-Id: I8319c4a74a0baa3b40afb871bfb0605ac81c3270 Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1837 Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Simon Marchi [Fri, 9 Aug 2019 20:30:09 +0000 (16:30 -0400)]
Fix: muxer: check for MUXER_MSG_ITER_CLOCK_CLASS_EXPECTATION_NONE in validate_new_stream_clock_class
There is a problem currently when trying to send multiple streams that
don't have a clock class (which is a supported use case) to a muxer
instance.
The first time we enter validate_new_stream_clock_class without a clock
class, we set the expectation to
MUXER_MSG_ITER_CLOCK_CLASS_EXPECTATION_NONE. The second time we enter
without a clock class, we wrongfully go to the error case. We are
missing a check for MUXER_MSG_ITER_CLOCK_CLASS_EXPECTATION_NONE, which
is the expected and valid case. This patch adds it.
Also, the error message is erroneous. If we are in that situation, we
expect a stream class _without_ a clock class, but are met with a stream
class _with_ a clock class. Fix that at the same time.
Change-Id: Iea692578498ea87a33ecba5d2fd54b2980056cd0 Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/1862
CI-Build: Philippe Proulx <eeppeliteloop@gmail.com> Tested-by: jenkins <jenkins@lttng.org> Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
projects / babeltrace.git / log
