[lttng-tools.git] / src / bin / lttng / commands / load.c

/*
 * Copyright (C) 2014 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2 only,
 * as published by the Free Software Foundation.
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#define _LGPL_SOURCE
#include <inttypes.h>
#include <popt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include <common/mi-lttng.h>
#include <common/config/session-config.h>
#include <lttng/load.h>

#include "../command.h"

static char *opt_input_path;
static char *opt_override_url;
static char *opt_override_session_name;
static int opt_force;
static int opt_load_all;

static const char *session_name;

enum {
	OPT_HELP = 1,
	OPT_ALL,
	OPT_FORCE,
	OPT_LIST_OPTIONS,
};

static struct mi_writer *writer;

static struct poptOption load_opts[] = {
	/* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
	{"help",          'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0},
	{"all",           'a', POPT_ARG_NONE, 0, OPT_ALL, 0, 0},
	{"input-path",    'i', POPT_ARG_STRING, &opt_input_path, 0, 0, 0},
	{"force",         'f', POPT_ARG_NONE, 0, OPT_FORCE, 0, 0},
	{"override-url",    0, POPT_ARG_STRING, &opt_override_url, 0, 0, 0},
	{"override-name",   0, POPT_ARG_STRING, &opt_override_session_name, 0, 0, 0},
	{"list-options",    0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL},
	{0, 0, 0, 0, 0, 0, 0}
};

static int mi_partial_session(const char *session_name)
{
	int ret;
	assert(writer);
	assert(session_name);

	/* Open session element */
	ret = mi_lttng_writer_open_element(writer, config_element_session);
	if (ret) {
		goto end;
	}

	ret = mi_lttng_writer_write_element_string(writer, config_element_name,
			session_name);
	if (ret) {
		goto end;
	}

	/* Closing session element */
	ret = mi_lttng_writer_close_element(writer);
end:
	return ret;
}

/*
 * Mi print of load command
 */
static int mi_load_print(const char *session_name)
{
	int ret;
	assert(writer);

	if (opt_load_all) {
		/* We use a wildcard to represent all sessions */
		session_name = "*";
	}

	/* Print load element */
	ret = mi_lttng_writer_open_element(writer, mi_lttng_element_load);
	if (ret) {
		goto end;
	}

	/* Print session element */
	ret = mi_partial_session(session_name);
	if (ret) {
		goto end;
	}

	/* Path element */
	if (opt_input_path) {
		ret = mi_lttng_writer_write_element_string(writer, config_element_path,
				opt_input_path);
		if (ret) {
			goto end;
		}
	}

	/* Print override elements */
	ret = mi_lttng_writer_open_element(writer, mi_lttng_element_load_overrides);
	if (ret) {
		goto end;
	}

	/* Session name override element */
	if (opt_override_session_name) {
		ret = mi_lttng_writer_write_element_string(writer,
				config_element_name, opt_override_session_name);
		if (ret) {
			goto end;
		}
	}

	/* Session url override element */
	if (opt_override_url) {
		ret = mi_lttng_writer_write_element_string(writer,
				mi_lttng_element_load_override_url,
				opt_override_url);
		if (ret) {
			goto end;
		}
	}

	/* Close override and load element */
	ret = mi_lttng_close_multi_element(writer, 2);
end:
	return ret;
}

/*
 * The 'load <options>' first level command
 */
int cmd_load(int argc, const char **argv)
{
	int ret, success;
	int opt;
	poptContext pc;
	struct lttng_load_session_attr *session_attr = NULL;
	char *input_path = NULL;

	pc = poptGetContext(NULL, argc, argv, load_opts, 0);
	poptReadDefaultConfig(pc, 0);

	while ((opt = poptGetNextOpt(pc)) != -1) {
		switch (opt) {
		case OPT_HELP:
			SHOW_HELP();
			ret = CMD_SUCCESS;
			goto end;
		case OPT_ALL:
			opt_load_all = 1;
			break;
		case OPT_LIST_OPTIONS:
			list_cmd_options(stdout, load_opts);
			ret = CMD_SUCCESS;
			goto end;
		case OPT_FORCE:
			opt_force = 1;
			break;
		default:
			ret = CMD_UNDEFINED;
			goto end;
		}
	}

	ret = lttng_session_daemon_alive();
	if (!ret) {
		ERR("No session daemon is available");
		ret = CMD_ERROR;
		goto end;
	}

	if (!opt_load_all) {
		session_name = poptGetArg(pc);
		if (session_name) {
			DBG2("Loading session name: %s", session_name);
		} else {
			/* Default to load_all */
			opt_load_all = 1;
		}
	}

	/* Mi check */
	if (lttng_opt_mi) {
		writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
		if (!writer) {
			ret = CMD_ERROR;
			goto end;
		}

		/* Open command element */
		ret = mi_lttng_writer_command_open(writer,
				mi_lttng_element_command_load);
		if (ret) {
			ret = CMD_ERROR;
			goto end;
		}

		/* Open output element */
		ret = mi_lttng_writer_open_element(writer,
				mi_lttng_element_command_output);
		if (ret) {
			ret = CMD_ERROR;
			goto end;
		}
	}

	/* Prepare load attributes */
	session_attr = lttng_load_session_attr_create();
	if (!session_attr) {
		ERR("Failed to create load session attributes");
		ret = CMD_ERROR;
		goto end;
	}

	/*
	 * Set the input url
	 * lttng_load_session_attr_set_input_url only suppports absolute path.
	 * Use realpath to resolve any relative path.
	 * */
	if (opt_input_path) {
		input_path = realpath(opt_input_path, NULL);
		if (!input_path) {
			PERROR("Invalid input path");
			ret = CMD_ERROR;
			goto end;
		}
	} else {
		input_path = NULL;
	}

	ret = lttng_load_session_attr_set_input_url(session_attr,
			input_path);
	if (ret) {
		ERR("Invalid input path");
		ret = CMD_ERROR;
		goto end;
	}

	/* Set the session name. NULL means all sessions should be loaded */
	ret = lttng_load_session_attr_set_session_name(session_attr,
			session_name);
	if (ret) {
		ERR("Invalid session name");
		ret = CMD_ERROR;
		goto end;
	}

	/* Set the overwrite attribute */
	ret = lttng_load_session_attr_set_overwrite(session_attr, opt_force);
	if (ret) {
		ERR("Force argument could not be applied");
		ret = CMD_ERROR;
		goto end;
	}

	/* Set the overrides attributes if any */
	if (opt_override_url) {
		ret = lttng_load_session_attr_set_override_url(session_attr,
				opt_override_url);
		if (ret) {
			ERR("Url override is invalid");
			goto end;
		}
	}

	if (opt_override_session_name) {
		if (opt_load_all) {
			ERR("Options --all and --override-name cannot be used simultaneously");
			ret = CMD_ERROR;
			goto end;
		}
		ret = lttng_load_session_attr_set_override_session_name(session_attr,
				opt_override_session_name);
		if (ret) {
			ERR("Failed to set session name override");
			ret = CMD_ERROR;
			goto end;
		}
	}

	ret = lttng_load_session(session_attr);
	if (ret) {
		ERR("%s", lttng_strerror(ret));
		success = 0;
		ret = CMD_ERROR;
	} else {
		if (opt_load_all) {
			MSG("All sessions have been loaded successfully");
		} else if (session_name) {
			ret = config_init((char *) session_name);
			if (ret < 0) {
				WARN("Could not set %s as the default session",
						session_name);
			}
			MSG("Session %s has been loaded successfully", session_name);
		} else {
			MSG("Session has been loaded successfully");
		}

		if (opt_override_session_name) {
			MSG("Session name overridden with %s",
					opt_override_session_name);
		}

		if (opt_override_url) {
			MSG("Session output url overridden with %s", opt_override_url);
		}
		success = 1;
		ret = CMD_SUCCESS;
	}

	/* Mi Printing and closing */
	if (lttng_opt_mi) {
		/* Mi print */
		ret = mi_load_print(session_name);
		if (ret) {
			ret = CMD_ERROR;
			goto end;
		}

		/* Close  output element */
		ret = mi_lttng_writer_close_element(writer);
		if (ret) {
			ret = CMD_ERROR;
			goto end;
		}

		/* Success ? */
		ret = mi_lttng_writer_write_element_bool(writer,
				mi_lttng_element_command_success, success);
		if (ret) {
			ret = CMD_ERROR;
			goto end;
		}

		/* Command element close */
		ret = mi_lttng_writer_command_close(writer);
		if (ret) {
			ret = CMD_ERROR;
			goto end;
		}
	}
end:
	if (writer && mi_lttng_writer_destroy(writer)) {
		ERR("Failed to destroy mi lttng writer");
	}

	lttng_load_session_attr_destroy(session_attr);
	free(input_path);
	poptFreeContext(pc);
	return ret;
}
Commit	Line	Data
8c42d845 JG	1	/*
	2	* Copyright (C) 2014 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License, version 2 only,
	6	* as published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License along
	14	* with this program; if not, write to the Free Software Foundation, Inc.,
	15	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	16	*/
	17
6c1c0768	18	#define _LGPL_SOURCE
8c42d845 JG	19	#include <inttypes.h>
	20	#include <popt.h>
	21	#include <stdio.h>
	22	#include <stdlib.h>
	23	#include <string.h>
	24	#include <assert.h>
	25
1734c658	26	#include <common/mi-lttng.h>
f40ef1d5	27	#include <common/config/session-config.h>
b6d4654a	28	#include <lttng/load.h>
1734c658	29
8c42d845 JG	30	#include "../command.h"
	31
	32	static char *opt_input_path;
fe559816	33	static char *opt_override_url;
e1f481f6	34	static char *opt_override_session_name;
8c42d845 JG	35	static int opt_force;
	36	static int opt_load_all;
	37
11143783 DG	38	static const char *session_name;
11143783 DG	39
8c42d845 JG	40	enum {
	41	OPT_HELP = 1,
	42	OPT_ALL,
	43	OPT_FORCE,
13a810d5	44	OPT_LIST_OPTIONS,
8c42d845 JG	45	};
8c42d845 JG	46
1734c658 JRJ	47	static struct mi_writer *writer;
1734c658 JRJ	48
8c42d845 JG	49	static struct poptOption load_opts[] = {
8c42d845 JG	50	/* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
e1f481f6 JR	51	{"help", 'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0},
	52	{"all", 'a', POPT_ARG_NONE, 0, OPT_ALL, 0, 0},
	53	{"input-path", 'i', POPT_ARG_STRING, &opt_input_path, 0, 0, 0},
	54	{"force", 'f', POPT_ARG_NONE, 0, OPT_FORCE, 0, 0},
	55	{"override-url", 0, POPT_ARG_STRING, &opt_override_url, 0, 0, 0},
	56	{"override-name", 0, POPT_ARG_STRING, &opt_override_session_name, 0, 0, 0},
	57	{"list-options", 0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL},
8c42d845 JG	58	{0, 0, 0, 0, 0, 0, 0}
	59	};
	60
1734c658 JRJ	61	static int mi_partial_session(const char *session_name)
	62	{
	63	int ret;
	64	assert(writer);
	65	assert(session_name);
	66
	67	/* Open session element */
	68	ret = mi_lttng_writer_open_element(writer, config_element_session);
	69	if (ret) {
	70	goto end;
	71	}
	72
	73	ret = mi_lttng_writer_write_element_string(writer, config_element_name,
	74	session_name);
	75	if (ret) {
	76	goto end;
	77	}
	78
	79	/* Closing session element */
	80	ret = mi_lttng_writer_close_element(writer);
	81	end:
	82	return ret;
	83	}
	84
	85	/*
	86	* Mi print of load command
	87	*/
	88	static int mi_load_print(const char *session_name)
	89	{
	90	int ret;
	91	assert(writer);
	92
	93	if (opt_load_all) {
	94	/* We use a wildcard to represent all sessions */
	95	session_name = "*";
	96	}
	97
	98	/* Print load element */
	99	ret = mi_lttng_writer_open_element(writer, mi_lttng_element_load);
	100	if (ret) {
	101	goto end;
	102	}
	103
	104	/* Print session element */
	105	ret = mi_partial_session(session_name);
	106	if (ret) {
	107	goto end;
	108	}
	109
	110	/* Path element */
	111	if (opt_input_path) {
	112	ret = mi_lttng_writer_write_element_string(writer, config_element_path,
	113	opt_input_path);
	114	if (ret) {
	115	goto end;
	116	}
	117	}
	118
23cb2d55 JR	119	/* Print override elements */
	120	ret = mi_lttng_writer_open_element(writer, mi_lttng_element_load_overrides);
	121	if (ret) {
	122	goto end;
	123	}
	124
	125	/* Session name override element */
	126	if (opt_override_session_name) {
	127	ret = mi_lttng_writer_write_element_string(writer,
	128	config_element_name, opt_override_session_name);
	129	if (ret) {
	130	goto end;
	131	}
	132	}
	133
	134	/* Session url override element */
	135	if (opt_override_url) {
	136	ret = mi_lttng_writer_write_element_string(writer,
	137	mi_lttng_element_load_override_url,
	138	opt_override_url);
	139	if (ret) {
	140	goto end;
	141	}
	142	}
1734c658	143
23cb2d55 JR	144	/* Close override and load element */
23cb2d55 JR	145	ret = mi_lttng_close_multi_element(writer, 2);
1734c658 JRJ	146	end:
	147	return ret;
	148	}
	149
8c42d845 JG	150	/*
	151	* The 'load <options>' first level command
	152	*/
	153	int cmd_load(int argc, const char **argv)
	154	{
b6d4654a	155	int ret, success;
8c42d845 JG	156	int opt;
8c42d845 JG	157	poptContext pc;
b6d4654a JR	158	struct lttng_load_session_attr *session_attr = NULL;
b6d4654a JR	159	char *input_path = NULL;
8c42d845 JG	160
	161	pc = poptGetContext(NULL, argc, argv, load_opts, 0);
	162	poptReadDefaultConfig(pc, 0);
	163
	164	while ((opt = poptGetNextOpt(pc)) != -1) {
	165	switch (opt) {
	166	case OPT_HELP:
4ba92f18	167	SHOW_HELP();
b6d4654a	168	ret = CMD_SUCCESS;
8c42d845 JG	169	goto end;
	170	case OPT_ALL:
	171	opt_load_all = 1;
	172	break;
13a810d5 DG	173	case OPT_LIST_OPTIONS:
13a810d5 DG	174	list_cmd_options(stdout, load_opts);
b6d4654a	175	ret = CMD_SUCCESS;
13a810d5	176	goto end;
8c42d845 JG	177	case OPT_FORCE:
	178	opt_force = 1;
	179	break;
	180	default:
8c42d845 JG	181	ret = CMD_UNDEFINED;
	182	goto end;
	183	}
	184	}
	185
623bc34c JG	186	ret = lttng_session_daemon_alive();
	187	if (!ret) {
	188	ERR("No session daemon is available");
	189	ret = CMD_ERROR;
	190	goto end;
	191	}
	192
11143783 DG	193	if (!opt_load_all) {
11143783 DG	194	session_name = poptGetArg(pc);
732b768a DG	195	if (session_name) {
732b768a DG	196	DBG2("Loading session name: %s", session_name);
1734c658 JRJ	197	} else {
	198	/* Default to load_all */
	199	opt_load_all = 1;
11143783	200	}
8c42d845 JG	201	}
8c42d845 JG	202
1734c658 JRJ	203	/* Mi check */
	204	if (lttng_opt_mi) {
	205	writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
	206	if (!writer) {
b6d4654a	207	ret = CMD_ERROR;
1734c658 JRJ	208	goto end;
	209	}
	210
	211	/* Open command element */
	212	ret = mi_lttng_writer_command_open(writer,
	213	mi_lttng_element_command_load);
	214	if (ret) {
	215	ret = CMD_ERROR;
	216	goto end;
	217	}
	218
	219	/* Open output element */
	220	ret = mi_lttng_writer_open_element(writer,
	221	mi_lttng_element_command_output);
	222	if (ret) {
	223	ret = CMD_ERROR;
	224	goto end;
	225	}
	226	}
	227
b6d4654a JR	228	/* Prepare load attributes */
	229	session_attr = lttng_load_session_attr_create();
	230	if (!session_attr) {
	231	ERR("Failed to create load session attributes");
	232	ret = CMD_ERROR;
	233	goto end;
	234	}
	235
	236	/*
	237	* Set the input url
	238	* lttng_load_session_attr_set_input_url only suppports absolute path.
	239	* Use realpath to resolve any relative path.
	240	* */
	241	if (opt_input_path) {
	242	input_path = realpath(opt_input_path, NULL);
	243	if (!input_path) {
	244	PERROR("Invalid input path");
	245	ret = CMD_ERROR;
	246	goto end;
	247	}
	248	} else {
	249	input_path = NULL;
	250	}
	251
	252	ret = lttng_load_session_attr_set_input_url(session_attr,
	253	input_path);
	254	if (ret) {
	255	ERR("Invalid input path");
	256	ret = CMD_ERROR;
	257	goto end;
	258	}
	259
	260	/* Set the session name. NULL means all sessions should be loaded */
	261	ret = lttng_load_session_attr_set_session_name(session_attr,
	262	session_name);
	263	if (ret) {
	264	ERR("Invalid session name");
	265	ret = CMD_ERROR;
	266	goto end;
	267	}
	268
	269	/* Set the overwrite attribute */
	270	ret = lttng_load_session_attr_set_overwrite(session_attr, opt_force);
	271	if (ret) {
	272	ERR("Force argument could not be applied");
	273	ret = CMD_ERROR;
	274	goto end;
	275	}
	276
fe559816 JR	277	/* Set the overrides attributes if any */
	278	if (opt_override_url) {
	279	ret = lttng_load_session_attr_set_override_url(session_attr,
	280	opt_override_url);
	281	if (ret) {
	282	ERR("Url override is invalid");
	283	goto end;
	284	}
	285	}
	286
e1f481f6 JR	287	if (opt_override_session_name) {
	288	if (opt_load_all) {
	289	ERR("Options --all and --override-name cannot be used simultaneously");
	290	ret = CMD_ERROR;
	291	goto end;
	292	}
	293	ret = lttng_load_session_attr_set_override_session_name(session_attr,
	294	opt_override_session_name);
	295	if (ret) {
	296	ERR("Failed to set session name override");
	297	ret = CMD_ERROR;
	298	goto end;
	299	}
	300	}
	301
b6d4654a JR	302	ret = lttng_load_session(session_attr);
	303	if (ret) {
	304	ERR("%s", lttng_strerror(ret));
1734c658	305	success = 0;
b6d4654a	306	ret = CMD_ERROR;
279d6193 DG	307	} else {
	308	if (opt_load_all) {
	309	MSG("All sessions have been loaded successfully");
732b768a	310	} else if (session_name) {
b6d4654a	311	ret = config_init((char *) session_name);
8e525b95	312	if (ret < 0) {
96694f0b JG	313	WARN("Could not set %s as the default session",
96694f0b JG	314	session_name);
8e525b95	315	}
279d6193	316	MSG("Session %s has been loaded successfully", session_name);
732b768a DG	317	} else {
732b768a DG	318	MSG("Session has been loaded successfully");
279d6193	319	}
fe559816	320
060e2e09 JR	321	if (opt_override_session_name) {
	322	MSG("Session name overridden with %s",
	323	opt_override_session_name);
	324	}
	325
fe559816 JR	326	if (opt_override_url) {
	327	MSG("Session output url overridden with %s", opt_override_url);
	328	}
1734c658	329	success = 1;
b6d4654a	330	ret = CMD_SUCCESS;
1734c658 JRJ	331	}
	332
	333	/* Mi Printing and closing */
	334	if (lttng_opt_mi) {
	335	/* Mi print */
	336	ret = mi_load_print(session_name);
	337	if (ret) {
	338	ret = CMD_ERROR;
	339	goto end;
	340	}
	341
	342	/* Close output element */
	343	ret = mi_lttng_writer_close_element(writer);
	344	if (ret) {
	345	ret = CMD_ERROR;
	346	goto end;
	347	}
	348
	349	/* Success ? */
	350	ret = mi_lttng_writer_write_element_bool(writer,
	351	mi_lttng_element_command_success, success);
	352	if (ret) {
	353	ret = CMD_ERROR;
	354	goto end;
	355	}
	356
	357	/* Command element close */
	358	ret = mi_lttng_writer_command_close(writer);
	359	if (ret) {
	360	ret = CMD_ERROR;
	361	goto end;
	362	}
8c42d845 JG	363	}
8c42d845 JG	364	end:
1734c658	365	if (writer && mi_lttng_writer_destroy(writer)) {
b6d4654a	366	ERR("Failed to destroy mi lttng writer");
1734c658 JRJ	367	}
1734c658 JRJ	368
b6d4654a JR	369	lttng_load_session_attr_destroy(session_attr);
b6d4654a JR	370	free(input_path);
8c42d845 JG	371	poptFreeContext(pc);
	372	return ret;
	373	}