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}.
* @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 */
* 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>();
}
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();
}
- /**
- * 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);
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) {
enabledWildcards.incrementAndGet();
return false;
}
+ return true;
}
if (eventName.endsWith(WILDCARD)) {
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 */
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);