#include <common/buffer-view.h>
#include <common/string-utils/format.h>
-#include "version.h"
+#include "backward-compatibility-group-by.h"
#include "cmd.h"
+#include "connection.h"
#include "ctf-trace.h"
+#include "health-relayd.h"
#include "index.h"
-#include "utils.h"
-#include "lttng-relayd.h"
#include "live.h"
-#include "health-relayd.h"
-#include "testpoint.h"
-#include "viewer-stream.h"
+#include "lttng-relayd.h"
#include "session.h"
+#include "sessiond-trace-chunks.h"
#include "stream.h"
-#include "connection.h"
-#include "tracefile-array.h"
#include "tcp_keep_alive.h"
-#include "sessiond-trace-chunks.h"
+#include "testpoint.h"
+#include "tracefile-array.h"
+#include "utils.h"
+#include "version.h"
+#include "viewer-stream.h"
static const char *help_msg =
#ifdef LTTNG_EMBED_HELP
/* command line options */
char *opt_output_path, *opt_working_directory;
static int opt_daemon, opt_background, opt_print_version;
+enum relay_group_output_by opt_group_output_by = RELAYD_GROUP_OUTPUT_BY_UNKNOWN;
/*
* We need to wait for listener and live listener threads, as well as
{ "config", 1, 0, 'f' },
{ "version", 0, 0, 'V' },
{ "working-directory", 1, 0, 'w', },
+ { "group-output-by-session", 0, 0, 's', },
+ { "group-output-by-host", 0, 0, 'p', },
{ NULL, 0, 0, 0, },
};
}
}
break;
+ case 's':
+ if (opt_group_output_by != RELAYD_GROUP_OUTPUT_BY_UNKNOWN) {
+ ERR("Cannot set --group-output-by-session, another --group-output-by argument is present");
+ exit(EXIT_FAILURE);
+ }
+ opt_group_output_by = RELAYD_GROUP_OUTPUT_BY_SESSION;
+ break;
+ case 'p':
+ if (opt_group_output_by != RELAYD_GROUP_OUTPUT_BY_UNKNOWN) {
+ ERR("Cannot set --group-output-by-host, another --group-output-by argument is present");
+ exit(EXIT_FAILURE);
+ }
+ opt_group_output_by = RELAYD_GROUP_OUTPUT_BY_HOST;
+ break;
default:
/* Unknown option or other error.
* Error is printed by getopt, just return */
return ret;
}
+static int parse_env_options(void)
+{
+ int ret = 0;
+ char *value = NULL;
+
+ value = lttng_secure_getenv(DEFAULT_LTTNG_RELAYD_WORKING_DIRECTORY_ENV);
+ if (value) {
+ opt_working_directory = strdup(value);
+ if (!opt_working_directory) {
+ ERR("Failed to allocate working directory string (\"%s\")",
+ value);
+ ret = -1;
+ }
+ }
+ return ret;
+}
+
static int set_options(int argc, char **argv)
{
int c, ret = 0, option_index = 0, retval = 0;
}
}
+ if (opt_group_output_by == RELAYD_GROUP_OUTPUT_BY_UNKNOWN) {
+ opt_group_output_by = RELAYD_GROUP_OUTPUT_BY_HOST;
+ }
+
exit:
free(optstring);
return retval;
goto send_reply;
}
+ /*
+ * Backward compatibility for --group-output-by-session.
+ * Prior to lttng 2.11, the complete path is passed by the stream.
+ * Starting at 2.11, lttng-relayd uses chunk. When dealing with producer
+ * >=2.11 the chunk is responsible for the output path. When dealing
+ * with producer < 2.11 the chunk output_path is the root output path
+ * and the stream carries the complete path (path_name).
+ * To support --group-output-by-session with older producer (<2.11), we
+ * need to craft the path based on the stream path.
+ */
+ if (opt_group_output_by == RELAYD_GROUP_OUTPUT_BY_SESSION) {
+ if (conn->minor < 4) {
+ /*
+ * From 2.1 to 2.3, the session_name is not passed on
+ * the RELAYD_CREATE_SESSION command. The session name
+ * is necessary to detect the presence of a base_path
+ * inside the stream path. Without it we cannot perform
+ * a valid group-output-by-session transformation.
+ */
+ WARN("Unable to perform a --group-by-session transformation for session %" PRIu64
+ " for stream with path \"%s\" as it is produced by a peer using a protocol older than v2.4",
+ session->id, path_name);
+ } else if (conn->minor >= 4 && conn->minor < 11) {
+ char *group_by_session_path_name;
+
+ assert(session->session_name[0] != '\0');
+
+ group_by_session_path_name =
+ backward_compat_group_by_session(
+ path_name,
+ session->session_name);
+ if (!group_by_session_path_name) {
+ ERR("Failed to apply group by session to stream of session %" PRIu64,
+ session->id);
+ goto send_reply;
+ }
+
+ DBG("Transformed session path from \"%s\" to \"%s\" to honor per-session name grouping",
+ path_name, group_by_session_path_name);
+
+ free(path_name);
+ path_name = group_by_session_path_name;
+ }
+ }
+
trace = ctf_trace_get_by_path_or_create(session, path_name);
if (!trace) {
goto send_reply;
}
- /* This stream here has one reference on the trace. */
+ /* This stream here has one reference on the trace. */
pthread_mutex_lock(&last_relay_stream_id_lock);
stream_handle = ++last_relay_stream_id;
pthread_mutex_unlock(&last_relay_stream_id_lock);
vstream = viewer_stream_get_by_id(stream->stream_handle);
if (vstream) {
- if (vstream->metadata_sent == stream->metadata_received) {
+ if (stream->no_new_metadata_notified) {
/*
* Since all the metadata has been sent to the
* viewer and that we have a request to close
index_info.stream_instance_id =
be64toh(index_info.stream_instance_id);
index_info.packet_seq_num = be64toh(index_info.packet_seq_num);
+ } else {
+ index_info.stream_instance_id = -1ULL;
+ index_info.packet_seq_num = -1ULL;
}
stream = stream_get_by_id(index_info.relay_stream_id);
session->sessiond_uuid, session->id,
rotate_streams.new_chunk_id.value);
if (!next_trace_chunk) {
- char uuid_str[UUID_STR_LEN];
+ char uuid_str[LTTNG_UUID_STR_LEN];
lttng_uuid_to_str(session->sessiond_uuid, uuid_str);
ERR("Unknown next trace chunk in ROTATE_STREAMS command: sessiond_uuid = {%s}, session_id = %" PRIu64
struct lttng_trace_chunk *chunk = NULL, *published_chunk = NULL;
enum lttng_error_code reply_code = LTTNG_OK;
enum lttng_trace_chunk_status chunk_status;
- struct lttng_directory_handle session_output;
+ struct lttng_directory_handle *session_output = NULL;
if (!session || !conn->version_check_done) {
ERR("Trying to create a trace chunk before version check");
goto end;
}
- ret = session_init_output_directory_handle(
- conn->session, &session_output);
- if (ret) {
+ session_output = session_create_output_directory_handle(
+ conn->session);
+ if (!session_output) {
reply_code = LTTNG_ERR_CREATE_DIR_FAIL;
goto end;
}
- chunk_status = lttng_trace_chunk_set_as_owner(chunk, &session_output);
- lttng_directory_handle_fini(&session_output);
+ chunk_status = lttng_trace_chunk_set_as_owner(chunk, session_output);
+ lttng_directory_handle_put(session_output);
+ session_output = NULL;
if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
reply_code = LTTNG_ERR_UNK;
ret = -1;
conn->session->id,
chunk);
if (!published_chunk) {
- char uuid_str[UUID_STR_LEN];
+ char uuid_str[LTTNG_UUID_STR_LEN];
lttng_uuid_to_str(conn->session->sessiond_uuid, uuid_str);
ERR("Failed to publish chunk: sessiond_uuid = %s, session_id = %" PRIu64 ", chunk_id = %" PRIu64,
end_no_reply:
lttng_trace_chunk_put(chunk);
lttng_trace_chunk_put(published_chunk);
+ lttng_directory_handle_put(session_output);
return ret;
}
conn->session->id,
chunk_id);
if (!chunk) {
- char uuid_str[UUID_STR_LEN];
+ char uuid_str[LTTNG_UUID_STR_LEN];
lttng_uuid_to_str(conn->session->sessiond_uuid, uuid_str);
ERR("Failed to find chunk to close: sessiond_uuid = %s, session_id = %" PRIu64 ", chunk_id = %" PRIu64,
int ret = 0, retval = 0;
void *status;
- /* Parse arguments */
+ /* Parse environment variables */
+ ret = parse_env_options();
+ if (ret) {
+ retval = -1;
+ goto exit_options;
+ }
+
+ /*
+ * Parse arguments.
+ * Command line arguments overwrite environment.
+ */
progname = argv[0];
if (set_options(argc, argv)) {
retval = -1;
goto exit_options;
}
+ ret = fclose(stdin);
+ if (ret) {
+ PERROR("Failed to close stdin");
+ goto exit_options;
+ }
+
/* Try to create directory if -o, --output is specified. */
if (opt_output_path) {
if (*opt_output_path != '/') {