[lttng-ust.git] / liblttng-ust-java-agent / java / lttng-ust-agent-common / org / lttng / ust / agent / context / ContextInfoSerializer.java

/*
 * Copyright (C) 2016 - EfficiOS Inc., Alexandre Montplaisir <alexmonthy@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.agent.context;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.util.Collection;
import java.util.Map;

import org.lttng.ust.agent.utils.LttngUstAgentLogger;

/**
 * This class is used to serialize the list of "context info" objects to pass
 * through JNI.
 *
 * The protocol expects a single byte array parameter. This byte array consists
 * of a series of fixed-size entries, where each entry contains the following
 * elements (with their size in bytes in parenthesis):
 *
 * <ul>
 * <li>The full context name, like "$app.myprovider:mycontext" (256)</li>
 * <li>The context value type (1)</li>
 * <li>The context value itself(256)</li>
 * </ul>
 *
 * So the total size of each entry is 513 bytes. All unused bytes will be
 * zero'ed.
 *
 * @author Alexandre Montplaisir
 */
public class ContextInfoSerializer {

	private enum DataType {
		NULL(0),
		INTEGER(1),
		LONG(2),
		DOUBLE(3),
		FLOAT(4),
		BYTE(5),
		SHORT(6),
		BOOLEAN(7),
		STRING(8);

		private final byte value;

		private DataType(int value) {
			this.value = (byte) value;
		}

		public byte getValue() {
			return value;
		}
	}

	private static final String UST_APP_CTX_PREFIX = "$app.";
	private static final int ELEMENT_LENGTH = 256;
	private static final int ENTRY_LENGTH = 513;
	private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
	private static final Charset UTF8_CHARSET = Charset.forName("UTF-8");
	private static final byte[] EMPTY_ARRAY = new byte[0];

	/**
	 * From the list of requested contexts in the tracing session, look them up
	 * in the {@link ContextInfoManager}, retrieve the available ones, and
	 * serialize them into a byte array.
	 *
	 * @param enabledContexts
	 *            The contexts that are enabled in the tracing session (indexed
	 *            first by retriever name, then by index names). Should come
	 *            from the LTTng Agent.
	 * @return The byte array representing the intersection of the requested and
	 *         available contexts.
	 */
	public static byte[] queryAndSerializeRequestedContexts(Collection<Map.Entry<String, Map<String, Integer>>> enabledContexts) {
		if (enabledContexts.isEmpty()) {
			/* Early return if there is no requested context information */
			return EMPTY_ARRAY;
		}

		/* Compute the total number of contexts (flatten the map) */
		int totalArraySize = 0;
		for (Map.Entry<String, Map<String, Integer>> contexts : enabledContexts) {
			totalArraySize += contexts.getValue().size() * ENTRY_LENGTH;
		}

		ContextInfoManager contextManager;
		try {
			contextManager = ContextInfoManager.getInstance();
		} catch (IOException e) {
			/*
			 * The JNI library is not available, do not send any context
			 * information. No retriever could have been defined anyways.
			 */
			return EMPTY_ARRAY;
		}

		ByteBuffer buffer = ByteBuffer.allocate(totalArraySize);
		buffer.order(NATIVE_ORDER);
		buffer.clear();

		for (Map.Entry<String, Map<String, Integer>> entry : enabledContexts) {
			String requestedRetrieverName = entry.getKey();
			Map<String, Integer> requestedContexts = entry.getValue();

			IContextInfoRetriever retriever = contextManager.getContextInfoRetriever(requestedRetrieverName);

			for (String requestedContext : requestedContexts.keySet()) {
				Object contextInfo;
				if (retriever == null) {
					contextInfo = null;
				} else {
					contextInfo = retriever.retrieveContextInfo(requestedContext);
					/*
					 * 'contextInfo' can still be null here, which would
					 * indicate the retriever does not supply this context. We
					 * will still write this information so that the tracer can
					 * know about it.
					 */
				}

				/* Serialize the result to the buffer */
				// FIXME Eventually pass the retriever name only once?
				String fullContextName = (UST_APP_CTX_PREFIX + requestedRetrieverName + ':' + requestedContext);
				byte[] strArray = fullContextName.getBytes(UTF8_CHARSET);
				int remainingBytes = ELEMENT_LENGTH - strArray.length;
				// FIXME Handle case where name is too long...
				buffer.put(strArray);
				buffer.position(buffer.position() + remainingBytes);

				LttngUstAgentLogger.log(ContextInfoSerializer.class,
						"ContextInfoSerializer: Context to be sent through JNI: " + fullContextName + '=' +
						(contextInfo == null ? "null" : contextInfo.toString()));

				serializeContextInfo(buffer, contextInfo);
			}
		}
		return buffer.array();
	}

	private static void serializeContextInfo(ByteBuffer buffer, Object contextInfo) {
		int remainingBytes;
		if (contextInfo == null) {
			buffer.put(DataType.NULL.getValue());
			remainingBytes = ELEMENT_LENGTH;

		} else if (contextInfo instanceof Integer) {
			buffer.put(DataType.INTEGER.getValue());
			buffer.putInt(((Integer) contextInfo).intValue());
			remainingBytes = ELEMENT_LENGTH - 4;

		} else if (contextInfo instanceof Long) {
			buffer.put(DataType.LONG.getValue());
			buffer.putLong(((Long) contextInfo).longValue());
			remainingBytes = ELEMENT_LENGTH - 8;

		} else if (contextInfo instanceof Double) {
			buffer.put(DataType.DOUBLE.getValue());
			buffer.putDouble(((Double) contextInfo).doubleValue());
			remainingBytes = ELEMENT_LENGTH - 8;

		} else if (contextInfo instanceof Float) {
			buffer.put(DataType.FLOAT.getValue());
			buffer.putFloat(((Float) contextInfo).floatValue());
			remainingBytes = ELEMENT_LENGTH - 4;

		} else if (contextInfo instanceof Byte) {
			buffer.put(DataType.BYTE.getValue());
			buffer.put(((Byte) contextInfo).byteValue());
			remainingBytes = ELEMENT_LENGTH - 1;

		} else if (contextInfo instanceof Short) {
			buffer.put(DataType.SHORT.getValue());
			buffer.putShort(((Short) contextInfo).shortValue());
			remainingBytes = ELEMENT_LENGTH - 2;

		} else if (contextInfo instanceof Boolean) {
			buffer.put(DataType.BOOLEAN.getValue());
			boolean b = ((Boolean) contextInfo).booleanValue();
			/* Converted to one byte, write 1 for true, 0 for false */
			buffer.put((byte) (b ? 1 : 0));
			remainingBytes = ELEMENT_LENGTH - 1;

		} else {
			/* We'll write the object as a string. Also includes the case of Character. */
			String str = contextInfo.toString();
			byte[] strArray = str.getBytes(UTF8_CHARSET);

			buffer.put(DataType.STRING.getValue());
			if (strArray.length >= ELEMENT_LENGTH) {
				/* Trim the string to the max allowed length */
				buffer.put(strArray, 0, ELEMENT_LENGTH);
				remainingBytes = 0;
			} else {
				buffer.put(strArray);
				remainingBytes = ELEMENT_LENGTH - strArray.length;
			}
		}
		buffer.position(buffer.position() + remainingBytes);
	}
}
Commit	Line	Data
8ab5c06b AM	1	/*
	2	* Copyright (C) 2016 - EfficiOS Inc., Alexandre Montplaisir <alexmonthy@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.agent.context;
	19
	20	import java.io.IOException;
	21	import java.nio.ByteBuffer;
	22	import java.nio.ByteOrder;
	23	import java.nio.charset.Charset;
	24	import java.util.Collection;
	25	import java.util.Map;
	26
cbe2ebd6 AM	27	import org.lttng.ust.agent.utils.LttngUstAgentLogger;
cbe2ebd6 AM	28
8ab5c06b AM	29	/**
	30	* This class is used to serialize the list of "context info" objects to pass
	31	* through JNI.
	32	*
	33	* The protocol expects a single byte array parameter. This byte array consists
	34	* of a series of fixed-size entries, where each entry contains the following
	35	* elements (with their size in bytes in parenthesis):
	36	*
	37	* <ul>
	38	* <li>The full context name, like "$app.myprovider:mycontext" (256)</li>
	39	* <li>The context value type (1)</li>
	40	* <li>The context value itself(256)</li>
	41	* </ul>
	42	*
	43	* So the total size of each entry is 513 bytes. All unused bytes will be
	44	* zero'ed.
	45	*
	46	* @author Alexandre Montplaisir
	47	*/
	48	public class ContextInfoSerializer {
	49
	50	private enum DataType {
	51	NULL(0),
	52	INTEGER(1),
	53	LONG(2),
	54	DOUBLE(3),
	55	FLOAT(4),
	56	BYTE(5),
	57	SHORT(6),
	58	BOOLEAN(7),
	59	STRING(8);
	60
	61	private final byte value;
	62
	63	private DataType(int value) {
	64	this.value = (byte) value;
	65	}
	66
	67	public byte getValue() {
	68	return value;
	69	}
	70	}
	71
	72	private static final String UST_APP_CTX_PREFIX = "$app.";
	73	private static final int ELEMENT_LENGTH = 256;
	74	private static final int ENTRY_LENGTH = 513;
	75	private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
	76	private static final Charset UTF8_CHARSET = Charset.forName("UTF-8");
	77	private static final byte[] EMPTY_ARRAY = new byte[0];
	78
	79	/**
	80	* From the list of requested contexts in the tracing session, look them up
	81	* in the {@link ContextInfoManager}, retrieve the available ones, and
	82	* serialize them into a byte array.
	83	*
	84	* @param enabledContexts
	85	* The contexts that are enabled in the tracing session (indexed
	86	* first by retriever name, then by index names). Should come
	87	* from the LTTng Agent.
	88	* @return The byte array representing the intersection of the requested and
	89	* available contexts.
	90	*/
	91	public static byte[] queryAndSerializeRequestedContexts(Collection<Map.Entry<String, Map<String, Integer>>> enabledContexts) {
	92	if (enabledContexts.isEmpty()) {
93	/* Early return if there is no requested context information */
94	return EMPTY_ARRAY;
95	}
96
97	/* Compute the total number of contexts (flatten the map) */
98	int totalArraySize = 0;
99	for (Map.Entry<String, Map<String, Integer>> contexts : enabledContexts) {
100	totalArraySize += contexts.getValue().size() * ENTRY_LENGTH;
101	}
102
103	ContextInfoManager contextManager;
104	try {
105	contextManager = ContextInfoManager.getInstance();
106	} catch (IOException e) {
107	/*
108	* The JNI library is not available, do not send any context
109	* information. No retriever could have been defined anyways.
110	*/
111	return EMPTY_ARRAY;
112	}
113
114	ByteBuffer buffer = ByteBuffer.allocate(totalArraySize);
115	buffer.order(NATIVE_ORDER);
116	buffer.clear();
117
118	for (Map.Entry<String, Map<String, Integer>> entry : enabledContexts) {
119	String requestedRetrieverName = entry.getKey();
120	Map<String, Integer> requestedContexts = entry.getValue();
121
122	IContextInfoRetriever retriever = contextManager.getContextInfoRetriever(requestedRetrieverName);
123
124	for (String requestedContext : requestedContexts.keySet()) {
125	Object contextInfo;
126	if (retriever == null) {
127	contextInfo = null;
128	} else {
129	contextInfo = retriever.retrieveContextInfo(requestedContext);
130	/*
131	* 'contextInfo' can still be null here, which would
132	* indicate the retriever does not supply this context. We
133	* will still write this information so that the tracer can
134	* know about it.
135	*/
136	}
137
138	/* Serialize the result to the buffer */
139	// FIXME Eventually pass the retriever name only once?
140	String fullContextName = (UST_APP_CTX_PREFIX + requestedRetrieverName + ':' + requestedContext);
141	byte[] strArray = fullContextName.getBytes(UTF8_CHARSET);
142	int remainingBytes = ELEMENT_LENGTH - strArray.length;
143	// FIXME Handle case where name is too long...
144	buffer.put(strArray);
145	buffer.position(buffer.position() + remainingBytes);
146
cbe2ebd6 AM	147	LttngUstAgentLogger.log(ContextInfoSerializer.class,
	148	"ContextInfoSerializer: Context to be sent through JNI: " + fullContextName + '=' +
	149	(contextInfo == null ? "null" : contextInfo.toString()));
	150
8ab5c06b AM	151	serializeContextInfo(buffer, contextInfo);
	152	}
	153	}
	154	return buffer.array();
	155	}
	156
	157	private static void serializeContextInfo(ByteBuffer buffer, Object contextInfo) {
	158	int remainingBytes;
	159	if (contextInfo == null) {
	160	buffer.put(DataType.NULL.getValue());
	161	remainingBytes = ELEMENT_LENGTH;
	162
	163	} else if (contextInfo instanceof Integer) {
	164	buffer.put(DataType.INTEGER.getValue());
	165	buffer.putInt(((Integer) contextInfo).intValue());
	166	remainingBytes = ELEMENT_LENGTH - 4;
	167
	168	} else if (contextInfo instanceof Long) {
	169	buffer.put(DataType.LONG.getValue());
	170	buffer.putLong(((Long) contextInfo).longValue());
	171	remainingBytes = ELEMENT_LENGTH - 8;
	172
	173	} else if (contextInfo instanceof Double) {
	174	buffer.put(DataType.DOUBLE.getValue());
	175	buffer.putDouble(((Double) contextInfo).doubleValue());
	176	remainingBytes = ELEMENT_LENGTH - 8;
	177
	178	} else if (contextInfo instanceof Float) {
	179	buffer.put(DataType.FLOAT.getValue());
	180	buffer.putFloat(((Float) contextInfo).floatValue());
	181	remainingBytes = ELEMENT_LENGTH - 4;
	182
	183	} else if (contextInfo instanceof Byte) {
	184	buffer.put(DataType.BYTE.getValue());
	185	buffer.put(((Byte) contextInfo).byteValue());
	186	remainingBytes = ELEMENT_LENGTH - 1;
	187
	188	} else if (contextInfo instanceof Short) {
	189	buffer.put(DataType.SHORT.getValue());
	190	buffer.putShort(((Short) contextInfo).shortValue());
	191	remainingBytes = ELEMENT_LENGTH - 2;
	192
	193	} else if (contextInfo instanceof Boolean) {
	194	buffer.put(DataType.BOOLEAN.getValue());
	195	boolean b = ((Boolean) contextInfo).booleanValue();
	196	/* Converted to one byte, write 1 for true, 0 for false */
	197	buffer.put((byte) (b ? 1 : 0));
	198	remainingBytes = ELEMENT_LENGTH - 1;
	199
	200	} else {
	201	/* We'll write the object as a string. Also includes the case of Character. */
	202	String str = contextInfo.toString();
	203	byte[] strArray = str.getBytes(UTF8_CHARSET);
	204
	205	buffer.put(DataType.STRING.getValue());
	206	if (strArray.length >= ELEMENT_LENGTH) {
	207	/* Trim the string to the max allowed length */
	208	buffer.put(strArray, 0, ELEMENT_LENGTH);
	209	remainingBytes = 0;
	210	} else {
	211	buffer.put(strArray);
	212	remainingBytes = ELEMENT_LENGTH - strArray.length;
	213	}
	214	}
215	buffer.position(buffer.position() + remainingBytes);
216	}
217	}