Add filter change notification mechanism to the Java agent

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

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 4e6d4af011f3e976c7799ec714b8b2130386cfe0..8531eaec7c3b8ddab23f0b7aa1e668ffc3376124 100644 (file)
--- 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
@@ -28,7 +28,10 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentSkipListMap;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import org.lttng.ust.agent.client.ILttngTcpClientListener;
 import org.lttng.ust.agent.client.LttngTcpSessiondClient;
+import org.lttng.ust.agent.filter.FilterChangeNotifier;
+import org.lttng.ust.agent.session.EventRule;
 
 /**
  * Base implementation of a {@link ILttngAgent}.
@@ -37,7 +40,8 @@ import org.lttng.ust.agent.client.LttngTcpSessiondClient;
  * @param <T>
  *            The type of logging handler that should register to this agent
  */
-public abstract class AbstractLttngAgent<T extends ILttngHandler> implements ILttngAgent<T> {
+public abstract class AbstractLttngAgent<T extends ILttngHandler>
+               implements ILttngAgent<T>, ILttngTcpClientListener {
 
        private static final String WILDCARD = "*";
        private static final int INIT_TIMEOUT = 3; /* Seconds */
@@ -53,7 +57,7 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler> implements ILt
         * falls to 0, this means we can avoid sending log events through JNI
         * because nobody wants them.
         *
-        * It uses a concurrent hash set", so that the {@link #isEventEnabled} and
+        * It uses a concurrent hash map, so that the {@link #isEventEnabled} and
         * read methods do not need to take a synchronization lock.
         */
        private final Map<String, Integer> enabledEvents = new ConcurrentHashMap<String, Integer>();
@@ -134,14 +138,14 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler> implements ILt
                }
                String rootClientThreadName = "Root sessiond client started by agent: " + this.getClass().getSimpleName();
 
-               rootSessiondClient = new LttngTcpSessiondClient(this, true);
+               rootSessiondClient = new LttngTcpSessiondClient(this, getDomain().value(), true);
                rootSessiondClientThread = new Thread(rootSessiondClient, rootClientThreadName);
                rootSessiondClientThread.setDaemon(true);
                rootSessiondClientThread.start();
 
                String userClientThreadName = "User sessiond client started by agent: " + this.getClass().getSimpleName();
 
-               userSessiondClient = new LttngTcpSessiondClient(this, false);
+               userSessiondClient = new LttngTcpSessiondClient(this, getDomain().value(), false);
                userSessiondClientThread = new Thread(userSessiondClient, userClientThreadName);
                userSessiondClientThread.setDaemon(true);
                userSessiondClientThread.start();
@@ -186,21 +190,17 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler> implements ILt
 
        }
 
-       /**
-        * Callback for the TCP clients to notify the agent that a request for
-        * enabling an event was sent from the session daemon.
-        *
-        * @param eventName
-        *            The name of the event that was requested to be enabled.
-        * @return Since we do not track individual sessions, right now this command
-        *         cannot fail. It will always return true.
-        */
-       public boolean eventEnabled(String eventName) {
+       @Override
+       public boolean eventEnabled(EventRule eventRule) {
+               /* Notify the filter change manager of the command */
+               FilterChangeNotifier.getInstance().addEventRule(eventRule);
+
+               String eventName = eventRule.getEventName();
+
                if (eventName.equals(WILDCARD)) {
                        enabledWildcards.incrementAndGet();
                        return true;
                }
-
                if (eventName.endsWith(WILDCARD)) {
                        /* Strip the "*" from the name. */
                        String prefix = eventName.substring(0, eventName.length() - 1);
@@ -210,16 +210,11 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler> implements ILt
                return incrementEventCount(eventName, enabledEvents);
        }
 
-       /**
-        * Callback for the TCP clients to notify the agent that a request for
-        * disabling an event was sent from the session daemon.
-        *
-        * @param eventName
-        *            The name of the event that was requested to be disabled.
-        * @return True if the command completed successfully, false if we should
-        *         report an error (event was not enabled, etc.)
-        */
+       @Override
        public boolean eventDisabled(String eventName) {
+               /* Notify the filter change manager of the command */
+               FilterChangeNotifier.getInstance().removeEventRules(eventName);
+
                if (eventName.equals(WILDCARD)) {
                        int newCount = enabledWildcards.decrementAndGet();
                        if (newCount < 0) {
@@ -227,6 +222,7 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler> implements ILt
                                enabledWildcards.incrementAndGet();
                                return false;
                        }
+                       return true;
                }
 
                if (eventName.endsWith(WILDCARD)) {
@@ -238,6 +234,20 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler> implements ILt
                return decrementEventCount(eventName, enabledEvents);
        }
 
+       @Override
+       public Iterable<String> listEnabledEvents() {
+               List<String> events = new LinkedList<String>();
+
+               if (enabledWildcards.get() > 0) {
+                       events.add(WILDCARD);
+               }
+               for (String prefix : enabledEventPrefixes.keySet()) {
+                       events.add(new String(prefix + WILDCARD));
+               }
+               events.addAll(enabledEvents.keySet());
+               return events;
+       }
+
        @Override
        public boolean isEventEnabled(String eventName) {
                /* If at least one session enabled the "*" wildcard, send the event */
@@ -259,20 +269,6 @@ public abstract class AbstractLttngAgent<T extends ILttngHandler> implements ILt
                return false;
        }
 
-       @Override
-       public Iterable<String> listEnabledEvents() {
-               List<String> events = new LinkedList<String>();
-
-               if (enabledWildcards.get() > 0) {
-                       events.add(WILDCARD);
-               }
-               for (String prefix : enabledEventPrefixes.keySet()) {
-                       events.add(new String(prefix + WILDCARD));
-               }
-               events.addAll(enabledEvents.keySet());
-               return events;
-       }
-
        private static boolean incrementEventCount(String eventName, Map<String, Integer> eventMap) {
                synchronized (eventMap) {
                        Integer count = eventMap.get(eventName);