[lttng-ust.git] / liblttng-ust-jul / org / lttng / ust / jul / LTTngTCPSessiondClient.java

/*
 * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License, version 2.1 only,
 * as published by the Free Software Foundation.
 *
 * This library 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 Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

package org.lttng.ust.jul;

import java.util.concurrent.Semaphore;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.lang.Integer;
import java.io.IOException;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.DataInputStream;
import java.net.*;
import java.lang.management.ManagementFactory;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Timer;
import java.util.TimerTask;
import java.util.logging.Logger;
import java.util.Collections;

class USTRegisterMsg {
	public static int pid;
}

public class LTTngTCPSessiondClient {
	/* Command header from the session deamon. */
	private LTTngSessiondCmd2_4.sessiond_hdr headerCmd =
		new LTTngSessiondCmd2_4.sessiond_hdr();

	private final String sessiondHost;
	private final int sessiondPort;
	private Socket sessiondSock;
	private boolean quit = false;

	private DataInputStream inFromSessiond;
	private DataOutputStream outToSessiond;

	private LTTngLogHandler handler;

	private Semaphore registerSem;

	private Timer eventTimer;
	private Set<LTTngEvent> enabledEventSet =
		Collections.synchronizedSet(new HashSet<LTTngEvent>());
	/*
	 * Map of Logger objects that have been enabled. They are indexed by name.
	 */
	private HashMap<String, Logger> enabledLoggers = new HashMap<String, Logger>();
	/* Timer delay at each 5 seconds. */
	private final static long timerDelay = 5 * 1000;
	private static boolean timerInitialized;

	public LTTngTCPSessiondClient(String host, int port, Semaphore sem) {
		this.sessiondHost = host;
		this.sessiondPort = port;
		this.registerSem = sem;
		this.eventTimer = new Timer();
		this.timerInitialized = false;
	}

	private void setupEventTimer() {
		if (this.timerInitialized) {
			return;
		}

		this.eventTimer.scheduleAtFixedRate(new TimerTask() {
			@Override
			public void run() {
				synchronized (enabledEventSet) {
					LTTngSessiondCmd2_4.sessiond_enable_handler enableCmd = new
						LTTngSessiondCmd2_4.sessiond_enable_handler();
					/*
					 * Modifying events in a Set will raise a
					 * ConcurrentModificationException. Thus, we remove an event
					 * and add its modified version to modifiedEvents when a
					 * modification is necessary.
					 */
					Set<LTTngEvent> modifiedEvents = new HashSet<LTTngEvent>();
					Iterator<LTTngEvent> it = enabledEventSet.iterator();

					while (it.hasNext()) {
						int ret;
						Logger logger;
						LTTngEvent event = it.next();

						/*
						 * Check if this Logger name has been enabled already. Note
						 * that in the case of "*", it's never added in that hash
						 * table thus the enable command does a lookup for each
						 * logger name in that hash table for the * case in order
						 * to make sure we don't enable twice the same logger
						 * because JUL apparently accepts that the *same*
						 * LogHandler can be added twice on a Logger object...
						 * don't ask...
						 */
						logger = enabledLoggers.get(event.name);
						if (logger != null) {
							continue;
						}

						/*
						 * Set to one means that the enable all event has been seen
						 * thus event from that point on must use loglevel for all
						 * events. Else the object has its own loglevel.
						 */
						if (handler.logLevelUseAll == 1) {
							it.remove();
							event.logLevel.level = handler.logLevelAll;
							event.logLevel.type = handler.logLevelTypeAll;
							modifiedEvents.add(event);
						}

						/*
						 * The all event is a special case since we have to iterate
						 * over every Logger to see which one was not enabled.
						 */
						if (event.name.equals("*")) {
							enableCmd.name = event.name;
							enableCmd.lttngLogLevel = event.logLevel.level;
							enableCmd.lttngLogLevelType = event.logLevel.type;
							/*
							 * The return value is irrelevant since the * event is
							 * always kept in the set.
							 */
							enableCmd.execute(handler, enabledLoggers);
							continue;
						}

						ret = enableCmd.enableLogger(handler, event, enabledLoggers);
						if (ret == 1) {
							/* Enabled so remove the event from the set. */
							if (!modifiedEvents.remove(event)) {
								/*
								 * event can only be present in one of
								 * the sets.
								 */
								it.remove();
							}
						}
					}
					enabledEventSet.addAll(modifiedEvents);
				}

			}
		}, this.timerDelay, this.timerDelay);

		this.timerInitialized = true;
	}

	public void init(LTTngLogHandler handler) throws InterruptedException {
		this.handler = handler;

		for (;;) {
			if (this.quit) {
				break;
			}

			try {

				/*
				 * Connect to the session daemon before anything else.
				 */
				connectToSessiond();

				/*
				 * Register to the session daemon as the Java component of the
				 * UST application.
				 */
				registerToSessiond();

				setupEventTimer();

				/*
				 * Block on socket receive and wait for command from the
				 * session daemon. This will return if and only if there is a
				 * fatal error or the socket closes.
				 */
				handleSessiondCmd();
			} catch (UnknownHostException uhe) {
				this.registerSem.release();
				System.out.println(uhe);
			} catch (IOException ioe) {
				this.registerSem.release();
				Thread.sleep(3000);
			} catch (Exception e) {
				this.registerSem.release();
				e.printStackTrace();
			}
		}
	}

	public void destroy() {
		this.quit = true;
		this.eventTimer.cancel();

		try {
			if (this.sessiondSock != null) {
				this.sessiondSock.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/*
	 * Receive header data from the session daemon using the LTTng command
	 * static buffer of the right size.
	 */
	private void recvHeader() throws Exception {
		int read_len;
		byte data[] = new byte[this.headerCmd.SIZE];

		read_len = this.inFromSessiond.read(data, 0, data.length);
		if (read_len != data.length) {
			throw new IOException();
		}
		this.headerCmd.populate(data);
	}

	/*
	 * Receive payload from the session daemon. This MUST be done after a
	 * recvHeader() so the header value of a command are known.
	 *
	 * The caller SHOULD use isPayload() before which returns true if a payload
	 * is expected after the header.
	 */
	private byte[] recvPayload() throws Exception {
		byte payload[] = new byte[(int) this.headerCmd.data_size];

		/* Failsafe check so we don't waste our time reading 0 bytes. */
		if (payload.length == 0) {
			return null;
		}

		this.inFromSessiond.read(payload, 0, payload.length);
		return payload;
	}

	/*
	 * Handle session command from the session daemon.
	 */
	private void handleSessiondCmd() throws Exception {
		int ret_code;
		byte data[] = null;

		while (true) {
			/* Get header from session daemon. */
			recvHeader();

			if (headerCmd.data_size > 0) {
				data = recvPayload();
			}

			switch (headerCmd.cmd) {
				case CMD_REG_DONE:
				{
					/*
					 * Release semaphore so meaning registration is done and we
					 * can proceed to continue tracing.
					 */
					this.registerSem.release();
					/*
					 * We don't send any reply to the registration done command.
					 * This just marks the end of the initial session setup.
					 */
					continue;
				}
				case CMD_LIST:
				{
					LTTngSessiondCmd2_4.sessiond_list_logger listLoggerCmd =
						new LTTngSessiondCmd2_4.sessiond_list_logger();
					listLoggerCmd.execute(this.handler);
					data = listLoggerCmd.getBytes();
					break;
				}
				case CMD_ENABLE:
				{
					LTTngEvent event;
					LTTngSessiondCmd2_4.sessiond_enable_handler enableCmd =
						new LTTngSessiondCmd2_4.sessiond_enable_handler();
					if (data == null) {
						enableCmd.code = LTTngSessiondCmd2_4.lttng_jul_ret_code.CODE_INVALID_CMD;
						break;
					}
					enableCmd.populate(data);
					event = enableCmd.execute(this.handler, this.enabledLoggers);
					if (event != null) {
						/*
						 * Add the event to the set so it can be enabled if
						 * the logger appears at some point in time.
						 */
						enabledEventSet.add(event);
					}
					data = enableCmd.getBytes();
					break;
				}
				case CMD_DISABLE:
				{
					LTTngSessiondCmd2_4.sessiond_disable_handler disableCmd =
						new LTTngSessiondCmd2_4.sessiond_disable_handler();
					if (data == null) {
						disableCmd.code = LTTngSessiondCmd2_4.lttng_jul_ret_code.CODE_INVALID_CMD;
						break;
					}
					disableCmd.populate(data);
					disableCmd.execute(this.handler);
					data = disableCmd.getBytes();
					break;
				}
				default:
				{
					data = new byte[4];
					ByteBuffer buf = ByteBuffer.wrap(data);
					buf.order(ByteOrder.BIG_ENDIAN);
					LTTngSessiondCmd2_4.lttng_jul_ret_code code =
						LTTngSessiondCmd2_4.lttng_jul_ret_code.CODE_INVALID_CMD;
					buf.putInt(code.getCode());
					break;
				}
			}

			/* Send payload to session daemon. */
			this.outToSessiond.write(data, 0, data.length);
			this.outToSessiond.flush();
		}
	}

	private void connectToSessiond() throws Exception {
		this.sessiondSock = new Socket(this.sessiondHost, this.sessiondPort);
		this.inFromSessiond = new DataInputStream(
				sessiondSock.getInputStream());
		this.outToSessiond = new DataOutputStream(
				sessiondSock.getOutputStream());
	}

	private void registerToSessiond() throws Exception {
		byte data[] = new byte[4];
		ByteBuffer buf = ByteBuffer.wrap(data);
		String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];

		buf.putInt(Integer.parseInt(pid));
		this.outToSessiond.write(data, 0, data.length);
		this.outToSessiond.flush();
	}
}
Commit	Line	Data
43e5396b DG	1	/*
	2	* Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
	3	*
	4	* This library is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU Lesser General Public License, version 2.1 only,
	6	* as published by the Free Software Foundation.
	7	*
	8	* This library is distributed in the hope that it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
	11	* for more details.
	12	*
	13	* You should have received a copy of the GNU Lesser General Public License
	14	* along with this library; if not, write to the Free Software Foundation,
	15	* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	16	*/
	17
	18	package org.lttng.ust.jul;
	19
	20	import java.util.concurrent.Semaphore;
	21	import java.nio.ByteBuffer;
	22	import java.nio.ByteOrder;
	23	import java.lang.Integer;
	24	import java.io.IOException;
	25	import java.io.BufferedOutputStream;
	26	import java.io.ByteArrayOutputStream;
	27	import java.io.DataOutputStream;
	28	import java.io.DataInputStream;
	29	import java.net.*;
	30	import java.lang.management.ManagementFactory;
	31	import java.util.ArrayList;
529e6def	32	import java.util.HashMap;
e614d916 JG	33	import java.util.HashSet;
e614d916 JG	34	import java.util.Iterator;
43e5396b	35	import java.util.List;
e614d916	36	import java.util.Set;
43e5396b DG	37	import java.util.Timer;
43e5396b DG	38	import java.util.TimerTask;
529e6def	39	import java.util.logging.Logger;
e614d916	40	import java.util.Collections;
43e5396b DG	41
	42	class USTRegisterMsg {
	43	public static int pid;
	44	}
	45
	46	public class LTTngTCPSessiondClient {
	47	/* Command header from the session deamon. */
	48	private LTTngSessiondCmd2_4.sessiond_hdr headerCmd =
	49	new LTTngSessiondCmd2_4.sessiond_hdr();
	50
	51	private final String sessiondHost;
	52	private final int sessiondPort;
	53	private Socket sessiondSock;
	54	private boolean quit = false;
	55
	56	private DataInputStream inFromSessiond;
	57	private DataOutputStream outToSessiond;
	58
	59	private LTTngLogHandler handler;
	60
	61	private Semaphore registerSem;
	62
	63	private Timer eventTimer;
e614d916 JG	64	private Set<LTTngEvent> enabledEventSet =
e614d916 JG	65	Collections.synchronizedSet(new HashSet<LTTngEvent>());
529e6def DG	66	/*
	67	* Map of Logger objects that have been enabled. They are indexed by name.
	68	*/
	69	private HashMap<String, Logger> enabledLoggers = new HashMap<String, Logger>();
43e5396b DG	70	/* Timer delay at each 5 seconds. */
	71	private final static long timerDelay = 5 * 1000;
	72	private static boolean timerInitialized;
	73
	74	public LTTngTCPSessiondClient(String host, int port, Semaphore sem) {
	75	this.sessiondHost = host;
	76	this.sessiondPort = port;
	77	this.registerSem = sem;
	78	this.eventTimer = new Timer();
	79	this.timerInitialized = false;
	80	}
	81
	82	private void setupEventTimer() {
	83	if (this.timerInitialized) {
	84	return;
	85	}
	86
	87	this.eventTimer.scheduleAtFixedRate(new TimerTask() {
	88	@Override
	89	public void run() {
e614d916 JG	90	synchronized (enabledEventSet) {
	91	LTTngSessiondCmd2_4.sessiond_enable_handler enableCmd = new
	92	LTTngSessiondCmd2_4.sessiond_enable_handler();
529e6def	93	/*
e614d916 JG	94	* Modifying events in a Set will raise a
	95	* ConcurrentModificationException. Thus, we remove an event
	96	* and add its modified version to modifiedEvents when a
	97	* modification is necessary.
529e6def	98	*/
e614d916 JG	99	Set<LTTngEvent> modifiedEvents = new HashSet<LTTngEvent>();
e614d916 JG	100	Iterator<LTTngEvent> it = enabledEventSet.iterator();
5b5ffa03	101
e614d916 JG	102	while (it.hasNext()) {
	103	int ret;
	104	Logger logger;
	105	LTTngEvent event = it.next();
5b5ffa03	106
5b5ffa03	107	/*
e614d916 JG	108	* Check if this Logger name has been enabled already. Note
	109	* that in the case of "*", it's never added in that hash
	110	* table thus the enable command does a lookup for each
	111	* logger name in that hash table for the * case in order
	112	* to make sure we don't enable twice the same logger
	113	* because JUL apparently accepts that the same
	114	* LogHandler can be added twice on a Logger object...
	115	* don't ask...
5b5ffa03	116	*/
e614d916 JG	117	logger = enabledLoggers.get(event.name);
	118	if (logger != null) {
	119	continue;
	120	}
529e6def	121
e614d916 JG	122	/*
	123	* Set to one means that the enable all event has been seen
	124	* thus event from that point on must use loglevel for all
	125	* events. Else the object has its own loglevel.
	126	*/
	127	if (handler.logLevelUseAll == 1) {
	128	it.remove();
	129	event.logLevel.level = handler.logLevelAll;
	130	event.logLevel.type = handler.logLevelTypeAll;
	131	modifiedEvents.add(event);
	132	}
	133
	134	/*
	135	* The all event is a special case since we have to iterate
	136	* over every Logger to see which one was not enabled.
	137	*/
	138	if (event.name.equals("*")) {
	139	enableCmd.name = event.name;
	140	enableCmd.lttngLogLevel = event.logLevel.level;
	141	enableCmd.lttngLogLevelType = event.logLevel.type;
	142	/*
	143	* The return value is irrelevant since the * event is
	144	* always kept in the set.
	145	*/
	146	enableCmd.execute(handler, enabledLoggers);
	147	continue;
	148	}
	149
	150	ret = enableCmd.enableLogger(handler, event, enabledLoggers);
	151	if (ret == 1) {
	152	/* Enabled so remove the event from the set. */
	153	if (!modifiedEvents.remove(event)) {
	154	/*
	155	* event can only be present in one of
	156	* the sets.
	157	*/
	158	it.remove();
	159	}
	160	}
43e5396b	161	}
e614d916	162	enabledEventSet.addAll(modifiedEvents);
43e5396b	163	}
e614d916	164
43e5396b DG	165	}
	166	}, this.timerDelay, this.timerDelay);
	167
	168	this.timerInitialized = true;
	169	}
	170
	171	public void init(LTTngLogHandler handler) throws InterruptedException {
	172	this.handler = handler;
	173
	174	for (;;) {
	175	if (this.quit) {
	176	break;
	177	}
	178
	179	try {
	180
	181	/*
	182	* Connect to the session daemon before anything else.
	183	*/
	184	connectToSessiond();
	185
	186	/*
	187	* Register to the session daemon as the Java component of the
	188	* UST application.
	189	*/
	190	registerToSessiond();
43e5396b DG	191
	192	setupEventTimer();
	193
	194	/*
	195	* Block on socket receive and wait for command from the
	196	* session daemon. This will return if and only if there is a
	197	* fatal error or the socket closes.
	198	*/
	199	handleSessiondCmd();
	200	} catch (UnknownHostException uhe) {
	201	this.registerSem.release();
	202	System.out.println(uhe);
	203	} catch (IOException ioe) {
	204	this.registerSem.release();
	205	Thread.sleep(3000);
	206	} catch (Exception e) {
	207	this.registerSem.release();
	208	e.printStackTrace();
	209	}
	210	}
	211	}
	212
	213	public void destroy() {
	214	this.quit = true;
	215	this.eventTimer.cancel();
	216
	217	try {
	218	if (this.sessiondSock != null) {
	219	this.sessiondSock.close();
	220	}
	221	} catch (Exception e) {
	222	e.printStackTrace();
	223	}
	224	}
	225
	226	/*
	227	* Receive header data from the session daemon using the LTTng command
	228	* static buffer of the right size.
	229	*/
	230	private void recvHeader() throws Exception {
	231	int read_len;
	232	byte data[] = new byte[this.headerCmd.SIZE];
	233
	234	read_len = this.inFromSessiond.read(data, 0, data.length);
	235	if (read_len != data.length) {
	236	throw new IOException();
	237	}
	238	this.headerCmd.populate(data);
	239	}
	240
	241	/*
	242	* Receive payload from the session daemon. This MUST be done after a
	243	* recvHeader() so the header value of a command are known.
	244	*
	245	* The caller SHOULD use isPayload() before which returns true if a payload
	246	* is expected after the header.
	247	*/
	248	private byte[] recvPayload() throws Exception {
	249	byte payload[] = new byte[(int) this.headerCmd.data_size];
	250
	251	/* Failsafe check so we don't waste our time reading 0 bytes. */
	252	if (payload.length == 0) {
	253	return null;
	254	}
255
256	this.inFromSessiond.read(payload, 0, payload.length);
257	return payload;
258	}
259
260	/*
261	* Handle session command from the session daemon.
262	*/
263	private void handleSessiondCmd() throws Exception {
264	int ret_code;
265	byte data[] = null;
266
267	while (true) {
268	/* Get header from session daemon. */
269	recvHeader();
270
271	if (headerCmd.data_size > 0) {
272	data = recvPayload();
273	}
274
275	switch (headerCmd.cmd) {
f08bb871 DG	276	case CMD_REG_DONE:
	277	{
	278	/*
	279	* Release semaphore so meaning registration is done and we
	280	* can proceed to continue tracing.
	281	*/
	282	this.registerSem.release();
9aabed2d DG	283	/*
	284	* We don't send any reply to the registration done command.
	285	* This just marks the end of the initial session setup.
	286	*/
	287	continue;
f08bb871	288	}
43e5396b DG	289	case CMD_LIST:
	290	{
	291	LTTngSessiondCmd2_4.sessiond_list_logger listLoggerCmd =
	292	new LTTngSessiondCmd2_4.sessiond_list_logger();
	293	listLoggerCmd.execute(this.handler);
	294	data = listLoggerCmd.getBytes();
	295	break;
	296	}
	297	case CMD_ENABLE:
	298	{
5b5ffa03	299	LTTngEvent event;
43e5396b DG	300	LTTngSessiondCmd2_4.sessiond_enable_handler enableCmd =
	301	new LTTngSessiondCmd2_4.sessiond_enable_handler();
	302	if (data == null) {
	303	enableCmd.code = LTTngSessiondCmd2_4.lttng_jul_ret_code.CODE_INVALID_CMD;
	304	break;
	305	}
	306	enableCmd.populate(data);
5b5ffa03 DG	307	event = enableCmd.execute(this.handler, this.enabledLoggers);
5b5ffa03 DG	308	if (event != null) {
43e5396b	309	/*
e614d916	310	* Add the event to the set so it can be enabled if
43e5396b DG	311	* the logger appears at some point in time.
43e5396b DG	312	*/
e614d916	313	enabledEventSet.add(event);
43e5396b DG	314	}
	315	data = enableCmd.getBytes();
	316	break;
	317	}
	318	case CMD_DISABLE:
	319	{
	320	LTTngSessiondCmd2_4.sessiond_disable_handler disableCmd =
	321	new LTTngSessiondCmd2_4.sessiond_disable_handler();
	322	if (data == null) {
	323	disableCmd.code = LTTngSessiondCmd2_4.lttng_jul_ret_code.CODE_INVALID_CMD;
	324	break;
	325	}
	326	disableCmd.populate(data);
	327	disableCmd.execute(this.handler);
	328	data = disableCmd.getBytes();
	329	break;
	330	}
	331	default:
	332	{
	333	data = new byte[4];
	334	ByteBuffer buf = ByteBuffer.wrap(data);
	335	buf.order(ByteOrder.BIG_ENDIAN);
	336	LTTngSessiondCmd2_4.lttng_jul_ret_code code =
	337	LTTngSessiondCmd2_4.lttng_jul_ret_code.CODE_INVALID_CMD;
	338	buf.putInt(code.getCode());
	339	break;
	340	}
	341	}
	342
	343	/* Send payload to session daemon. */
	344	this.outToSessiond.write(data, 0, data.length);
	345	this.outToSessiond.flush();
	346	}
	347	}
	348
	349	private void connectToSessiond() throws Exception {
	350	this.sessiondSock = new Socket(this.sessiondHost, this.sessiondPort);
	351	this.inFromSessiond = new DataInputStream(
	352	sessiondSock.getInputStream());
	353	this.outToSessiond = new DataOutputStream(
	354	sessiondSock.getOutputStream());
	355	}
	356
	357	private void registerToSessiond() throws Exception {
	358	byte data[] = new byte[4];
	359	ByteBuffer buf = ByteBuffer.wrap(data);
	360	String pid = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
	361
	362	buf.putInt(Integer.parseInt(pid));
	363	this.outToSessiond.write(data, 0, data.length);
	364	this.outToSessiond.flush();
	365	}
	366	}