X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust-java-agent%2Fjava%2Flttng-ust-agent-common%2Forg%2Flttng%2Fust%2Fagent%2FAbstractLttngAgent.java;h=22c58265c0c8429e38fcac90bba73f0a45f03ca3;hb=8ab5c06b92ac9a06ba2743470a38e4e1cfc6a3c9;hp=e97a7bdb222b172b62524fa7245f400287dd3d5b;hpb=1d193914f13dd604d60df9db680001c9a4af5f9d;p=lttng-ust.git

diff --git a/liblttng-ust-java-agent/java/lttng-ust-agent-common/org/lttng/ust/agent/AbstractLttngAgent.java b/liblttng-ust-java-agent/java/lttng-ust-agent-common/org/lttng/ust/agent/AbstractLttngAgent.java
index e97a7bdb..22c58265 100644
--- a/liblttng-ust-java-agent/java/lttng-ust-agent-common/org/lttng/ust/agent/AbstractLttngAgent.java
+++ b/liblttng-ust-java-agent/java/lttng-ust-agent-common/org/lttng/ust/agent/AbstractLttngAgent.java
@@ -75,6 +75,19 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler>
 	/** Number of sessions currently enabling the wildcard "*" event */
 	private final AtomicInteger enabledWildcards = new AtomicInteger(0);
 
+	/**
+	 * The application contexts currently enabled in the tracing sessions.
+	 *
+	 * It is first indexed by context retriever, then by context name. This
+	 * allows to efficiently query all the contexts for a given retriever.
+	 *
+	 * Works similarly as {@link #enabledEvents}, but for app contexts (and with
+	 * an extra degree of indexing).
+	 *
+	 * TODO Could be changed to a Guava Table once/if we start using it.
+	 */
+	private final Map<String, Map<String, Integer>> enabledAppContexts = new ConcurrentHashMap<String, Map<String, Integer>>();
+
 	/** Tracing domain. Defined by the sub-classes via the constructor. */
 	private final Domain domain;
 
@@ -186,7 +199,6 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler>
 		enabledWildcards.set(0);
 
 		initialized = false;
-
 	}
 
 	@Override
@@ -203,10 +215,10 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler>
 		if (eventName.endsWith(WILDCARD)) {
 			/* Strip the "*" from the name. */
 			String prefix = eventName.substring(0, eventName.length() - 1);
-			return incrementEventCount(prefix, enabledEventPrefixes);
+			return incrementRefCount(prefix, enabledEventPrefixes);
 		}
 
-		return incrementEventCount(eventName, enabledEvents);
+		return incrementRefCount(eventName, enabledEvents);
 	}
 
 	@Override
@@ -227,10 +239,44 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler>
 		if (eventName.endsWith(WILDCARD)) {
 			/* Strip the "*" from the name. */
 			String prefix = eventName.substring(0, eventName.length() - 1);
-			return decrementEventCount(prefix, enabledEventPrefixes);
+			return decrementRefCount(prefix, enabledEventPrefixes);
+		}
+
+		return decrementRefCount(eventName, enabledEvents);
+	}
+
+	@Override
+	public boolean appContextEnabled(String contextRetrieverName, String contextName) {
+		synchronized (enabledAppContexts) {
+			Map<String, Integer> retrieverMap = enabledAppContexts.get(contextRetrieverName);
+			if (retrieverMap == null) {
+				/* There is no submap for this retriever, let's create one. */
+				retrieverMap = new ConcurrentHashMap<String, Integer>();
+				enabledAppContexts.put(contextRetrieverName, retrieverMap);
+			}
+
+			return incrementRefCount(contextName, retrieverMap);
 		}
+	}
+
+	@Override
+	public boolean appContextDisabled(String contextRetrieverName, String contextName) {
+		synchronized (enabledAppContexts) {
+			Map<String, Integer> retrieverMap = enabledAppContexts.get(contextRetrieverName);
+			if (retrieverMap == null) {
+				/* There was no submap for this retriever, invalid command? */
+				return false;
+			}
+
+			boolean ret = decrementRefCount(contextName, retrieverMap);
 
-		return decrementEventCount(eventName, enabledEvents);
+			/* If the submap is now empty we can remove it from the main map. */
+			if (retrieverMap.isEmpty()) {
+				enabledAppContexts.remove(contextRetrieverName);
+			}
+
+			return ret;
+		}
 	}
 
 	/*
@@ -260,12 +306,17 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler>
 		return false;
 	}
 
-	private static boolean incrementEventCount(String eventName, Map<String, Integer> eventMap) {
-		synchronized (eventMap) {
-			Integer count = eventMap.get(eventName);
+	@Override
+	public Collection<Map.Entry<String, Map<String, Integer>>> getEnabledAppContexts() {
+		return enabledAppContexts.entrySet();
+	}
+
+	private static boolean incrementRefCount(String key, Map<String, Integer> refCountMap) {
+		synchronized (refCountMap) {
+			Integer count = refCountMap.get(key);
 			if (count == null) {
 				/* This is the first instance of this event being enabled */
-				eventMap.put(eventName, Integer.valueOf(1));
+				refCountMap.put(key, Integer.valueOf(1));
 				return true;
 			}
 			if (count.intValue() <= 0) {
@@ -273,14 +324,14 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler>
 				throw new IllegalStateException();
 			}
 			/* The event was already enabled, increment its refcount */
-			eventMap.put(eventName, Integer.valueOf(count.intValue() + 1));
+			refCountMap.put(key, Integer.valueOf(count.intValue() + 1));
 			return true;
 		}
 	}
 
-	private static boolean decrementEventCount(String eventName, Map<String, Integer> eventMap) {
-		synchronized (eventMap) {
-			Integer count = eventMap.get(eventName);
+	private static boolean decrementRefCount(String key, Map<String, Integer> refCountMap) {
+		synchronized (refCountMap) {
+			Integer count = refCountMap.get(key);
 			if (count == null || count.intValue() <= 0) {
 				/*
 				 * The sessiond asked us to disable an event that was not
@@ -293,14 +344,14 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler>
 				 * This is the last instance of this event being disabled,
 				 * remove it from the map so that we stop sending it.
 				 */
-				eventMap.remove(eventName);
+				refCountMap.remove(key);
 				return true;
 			}
 			/*
 			 * Other sessions are still looking for this event, simply decrement
 			 * its refcount.
 			 */
-			eventMap.put(eventName, Integer.valueOf(count.intValue() - 1));
+			refCountMap.put(key, Integer.valueOf(count.intValue() - 1));
 			return true;
 		}
 	}