Merge branch 'vendor-eventbus'

This branch moves the org.bushe:eventbus codebase into SciJava Common
directly, removing unneeded parts, and fixing an intermittent JVM
shutdown hang caused by a ThreadSafeEventService's cleanup timer that
wasn't marked as a daemon thread. It also adds a new
subscribe(EventSubscriber) method to the SciJava EventService.

Author: ctrueden

pom.xml

@@ -10,7 +10,7 @@
 	</parent>
 
 	<artifactId>scijava-common</artifactId>
-	<version>2.93.2-SNAPSHOT</version>
+	<version>2.94.0-SNAPSHOT</version>
 
 	<name>SciJava Common</name>
 	<description>SciJava Common is a shared library for SciJava software. It provides a plugin framework, with an extensible mechanism for service discovery, backed by its own annotation processor, so that plugins can be loaded dynamically. It is used by downstream projects in the SciJava ecosystem, such as ImageJ and SCIFIO.</description>
@@ -167,6 +167,7 @@
 		<license.licenseName>bsd_2</license.licenseName>
 		<license.projectName>SciJava Common shared library for SciJava software.</license.projectName>
 		<license.copyrightOwners>SciJava developers.</license.copyrightOwners>
+		<license.excludes>**/bushe/**</license.excludes>
 	</properties>
 
 	<dependencies>
@@ -176,13 +177,6 @@
 			<artifactId>parsington</artifactId>
 		</dependency>
 
-		<!-- Third-party dependencies -->
-		<dependency>
-			<groupId>org.bushe</groupId>
-			<artifactId>eventbus</artifactId>
-			<version>1.4</version>
-		</dependency>
-
 		<!-- Test scope dependencies -->
 		<dependency>
 			<groupId>junit</groupId>
@@ -193,7 +187,7 @@
 			<groupId>org.mockito</groupId>
 			<artifactId>mockito-core</artifactId>
 			<scope>test</scope>
-			</dependency>
+		</dependency>
 	</dependencies>
 
 	<build>

src/main/java/org/scijava/event/DefaultEventBus.java

@@ -34,18 +34,17 @@
 import java.util.Arrays;
 import java.util.List;
 
-import org.bushe.swing.event.CleanupEvent;
-import org.bushe.swing.event.ThreadSafeEventService;
+import org.scijava.event.bushe.ThreadSafeEventService;
 import org.scijava.log.LogService;
 import org.scijava.service.Service;
 import org.scijava.thread.ThreadService;
 
 /**
- * An {@link org.bushe.swing.event.EventService} implementation for SciJava.
+ * An {@code org.scijava.event.bushe.EventService} implementation for SciJava.
  * <p>
  * It is called "DefaultEventBus" rather than "DefaultEventService" to avoid a
  * name clash with {@link DefaultEventService}, which is not an
- * {@link org.bushe.swing.event.EventService} but rather a SciJava
+ * {@code org.scijava.event.bushe.EventService} but rather a SciJava
  * {@link Service} implementation.
  * </p>
  * 
@@ -59,7 +58,7 @@ public class DefaultEventBus extends ThreadSafeEventService {
 	public DefaultEventBus(final ThreadService threadService,
 		final LogService log)
 	{
-		super(200L, false, null, null, null);
+		super(200L, null, null, null);
 		this.threadService = threadService;
 		this.log = log;
 	}
@@ -112,37 +111,10 @@ public void publishLater(final String topicName, final Object eventObj) {
 			getVetoEventListeners(topicName), null);
 	}
 
-	// -- org.bushe.swing.event.EventService methods --
+	// -- org.scijava.event.bushe.EventService methods --
 
 	@Override
 	public void publish(final Object event) {
-		// HACK: Work around a deadlock problem caused by ThreadSafeEventService:
-
-		// 1) The ThreadSafeEventService superclass has a special cleanup thread
-		// that takes care of cleaning up stale references. Every time it runs, it
-		// publishes some CleanupEvents using publish(Object) to announce that this
-		// is occurring. Normally, such publication delegates to
-		// publishNow, which calls ThreadService#invoke, which calls
-		// EventQueue.invokeAndWait, which queues the publication for execution on
-		// the EDT and then blocks until publication is complete.
-
-		// 2) When the ThreadSafeEventService publishes the CleanupEvents, it does
-		// so inside a synchronized block that locks on a "listenerLock" object.
-
-		// 3) Unfortunately, since the CleanupEvent publication is merely *queued*,
-		// any other pending operations on the EDT happen first. If one such
-		// operation meanwhile calls e.g.
-		// ThreadSafeEventService#getSubscribers(Class<T>), it will deadlock because
-		// those getter methods are also synchronized on the listenerLock object.
-
-		// Hence, our hack workaround is to instead use publishLater for the
-		// CleanupEvents, since no one really cares about them anyway. ;-)
-
-		if (event instanceof CleanupEvent) {
-			publishLater(event);
-			return;
-		}
-
 		publishNow(event);
 	}
 

src/main/java/org/scijava/event/DefaultEventService.java

@@ -40,10 +40,9 @@
 import java.util.Map;
 import java.util.WeakHashMap;
 
-import org.bushe.swing.event.annotation.AbstractProxySubscriber;
-import org.bushe.swing.event.annotation.BaseProxySubscriber;
-import org.bushe.swing.event.annotation.ReferenceStrength;
 import org.scijava.Priority;
+import org.scijava.event.bushe.AbstractProxySubscriber;
+import org.scijava.event.bushe.ReferenceStrength;
 import org.scijava.log.LogService;
 import org.scijava.plugin.Parameter;
 import org.scijava.plugin.Plugin;
@@ -139,6 +138,11 @@ public List<EventSubscriber<?>> subscribe(final Object o) {
 		return subscribers;
 	}
 
+	@Override
+	public void subscribe(final EventSubscriber<?> subscriber) {
+		eventBus.subscribe(subscriber.getClass(), subscriber);
+	}
+
 	@Override
 	public void unsubscribe(final Collection<EventSubscriber<?>> subscribers) {
 		for (final EventSubscriber<?> subscriber : subscribers) {
@@ -262,9 +266,10 @@ private synchronized void keepIt(final Object o, final ProxySubscriber<?> subscr
 	/**
 	 * Helper class used by {@link #subscribe(Object)}.
 	 * <p>
-	 * Recapitulates some logic from {@link BaseProxySubscriber}, because that
-	 * class implements {@link org.bushe.swing.event.EventSubscriber} as a raw
-	 * type, which is incompatible with this class implementing SciJava's
+	 * Recapitulates some logic from
+	 * {@code org.scijava.event.bushe.BaseProxySubscriber}, because that class
+	 * implements {@link org.scijava.event.bushe.EventSubscriber} as a raw type,
+	 * which is incompatible with this class implementing SciJava's
 	 * {@link EventSubscriber} as a typed interface; it becomes impossible to
 	 * implement both {@code onEvent(Object)} and {@code onEvent(E)}.
 	 * </p>

src/main/java/org/scijava/event/EventHandler.java

@@ -40,15 +40,15 @@
  * handling methods and annotating each with @{@link EventHandler}.
  * <p>
  * Note to developers: This annotation serves exactly the same purpose as
- * EventBus's {@link org.bushe.swing.event.annotation.EventSubscriber}
- * annotation, recapitulating a subset of the same functionality. We do this to
- * avoid third party code depending directly on EventBus. That is, we do not
- * wish to require SciJava developers to {@code import org.bushe.swing.event.*}
- * or similar. In this way, EventBus is isolated as only a transitive dependency
- * of downstream code, rather than a direct dependency. Unfortunately, because
- * Java annotation interfaces cannot utilize inheritance, we have to
- * recapitulate the functionality rather than extend it (as we are able to do
- * with {@link EventSubscriber}).
+ * EventBus's {@code org.scijava.event.bushe.EventSubscriber} annotation,
+ * recapitulating a subset of the same functionality. We do this to avoid third
+ * party code depending directly on EventBus. That is, we do not wish to require
+ * SciJava developers to {@code import org.scijava.event.bushe.*} or similar. In
+ * this way, EventBus is isolated as only a transitive dependency of downstream
+ * code, rather than a direct dependency. Unfortunately, because Java annotation
+ * interfaces cannot utilize inheritance, we have to recapitulate the
+ * functionality rather than extend it (as we are able to do with
+ * {@link EventSubscriber}).
  * </p>
  * 
  * @author Curtis Rueden

src/main/java/org/scijava/event/EventService.java

@@ -125,6 +125,24 @@ public interface EventService extends SciJavaService {
 	 */
 	List<EventSubscriber<?>> subscribe(Object o);
 
+	/**
+	 * Subscribes the given {@link EventSubscriber} to its associated event class.
+	 * Its {@link EventSubscriber#onEvent} method will be called whenever an event
+	 * of the matching type is published.
+	 * <p>
+	 * <strong>Important note:</strong> The event service does <em>not</em> keep a
+	 * strong reference to the subscriber! If you use this method, you are also
+	 * responsible for keeping a reference to the subscriber, or else it is likely
+	 * to be garbage collected, and thus no longer respond to events as intended.
+	 * One simple way to force a strong reference to exist is to add it to
+	 * SciJava's {@link org.scijava.object.ObjectService} via
+	 * {@link org.scijava.object.ObjectService#addObject}.
+	 * </p>
+	 * 
+	 * @param subscriber the event subscriber to register
+	 */
+	void subscribe(EventSubscriber<?> subscriber);
+
 	/**
 	 * Removes all the given subscribers; they will no longer be notified when
 	 * events are published.

src/main/java/org/scijava/event/EventSubscriber.java

@@ -44,7 +44,7 @@
  * @param <E> Type of event for which to listen
  */
 public interface EventSubscriber<E extends SciJavaEvent> extends
-	org.bushe.swing.event.EventSubscriber<E>
+	org.scijava.event.bushe.EventSubscriber<E>
 {
 
 	@Override

src/main/java/org/scijava/event/bushe/AbstractProxySubscriber.java

@@ -0,0 +1,165 @@
+package org.scijava.event.bushe;
+
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Method;
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.InvocationTargetException;
+
+/**
+ * Common base class for EventService Proxies.
+ * <p>
+ * Implementing Prioritized even when Priority is not used is always OK.  The default
+ * value of 0 retains the FIFO order. 
+ */
+public abstract class AbstractProxySubscriber implements ProxySubscriber, Prioritized {
+   private Object proxiedSubscriber;
+   private Method subscriptionMethod;
+   private ReferenceStrength referenceStrength;
+   private EventService eventService;
+   private int priority;
+   protected boolean veto;
+
+   protected AbstractProxySubscriber(Object proxiedSubscriber, Method subscriptionMethod,
+           ReferenceStrength referenceStrength, EventService es, boolean veto) {
+      this(proxiedSubscriber, subscriptionMethod, referenceStrength, 0, es, veto);
+   }
+
+   protected AbstractProxySubscriber(Object proxiedSubscriber, Method subscriptionMethod,
+           ReferenceStrength referenceStrength, int priority, EventService es, boolean veto) {
+      this.referenceStrength = referenceStrength;
+      this.priority = priority;
+      eventService = es;
+      this.veto = veto;
+      if (proxiedSubscriber == null) {
+         throw new IllegalArgumentException("The realSubscriber cannot be null when constructing a proxy subscriber.");
+      }
+      if (subscriptionMethod == null) {
+         throw new IllegalArgumentException("The subscriptionMethod cannot be null when constructing a proxy subscriber.");
+      }
+      Class<?> returnType = subscriptionMethod.getReturnType();
+      if (veto && returnType != Boolean.TYPE) {
+         throw new IllegalArgumentException("The subscriptionMethod must have the two parameters, the first one must be a String and the second a non-primitive (Object or derivative).");
+      }
+      if (ReferenceStrength.WEAK.equals(referenceStrength)) {
+         this.proxiedSubscriber = new WeakReference(proxiedSubscriber);
+      } else {
+         this.proxiedSubscriber = proxiedSubscriber;
+      }
+      this.subscriptionMethod = subscriptionMethod;
+   }
+
+   /** @return the object this proxy is subscribed on behalf of */
+   public Object getProxiedSubscriber() {
+      if (proxiedSubscriber instanceof WeakReference) {
+         return ((WeakReference)proxiedSubscriber).get();
+      }
+      return proxiedSubscriber;
+   }
+   
+   /** @return the subscriptionMethod passed in the constructor */
+   public Method getSubscriptionMethod() {
+      return subscriptionMethod;
+   }
+
+   /** @return the EventService passed in the constructor */
+   public EventService getEventService() {
+      return eventService;
+   }
+
+   /** @return the ReferenceStrength passed in the constructor */
+   public ReferenceStrength getReferenceStrength() {
+      return referenceStrength;
+   }
+
+   /**
+    * @return the priority, no effect if priority is 0 (the default value)
+    */
+   public int getPriority() {
+      return priority;
+   }
+
+   /**
+    * Called by EventServices to inform the proxy that it is unsubscribed.  
+    * The ProxySubscriber should perform any necessary cleanup.
+    * <p>
+    * <b>Overriding classes must call super.proxyUnsubscribed() or risk
+    * things not being cleanup up properly.</b>
+    */
+   public void proxyUnsubscribed() {
+      proxiedSubscriber = null;
+   }
+
+   @Override
+   public final int hashCode() {
+      throw new RuntimeException("Proxy subscribers are not allowed in Hash " +
+              "Maps, since the underlying values use Weak References that" +
+              "may disappear, the calculations may not be the same in" +
+              "successive calls as required by hashCode.");
+   }
+
+   protected boolean retryReflectiveCallUsingAccessibleObject(Object[] args, Method subscriptionMethod, Object obj,
+           IllegalAccessException e, String message) {
+      boolean accessibleTriedAndFailed = false;
+      if (subscriptionMethod != null) {
+         AccessibleObject[] accessibleMethod = {subscriptionMethod};
+         try {
+            AccessibleObject.setAccessible(accessibleMethod, true);
+            Object returnValue = subscriptionMethod.invoke(obj, args);
+            return Boolean.valueOf(returnValue+"");
+         } catch (SecurityException ex) {
+            accessibleTriedAndFailed = true;
+         } catch (InvocationTargetException e1) {
+            throw new RuntimeException(message, e);
+         } catch (IllegalAccessException e1) {
+            throw new RuntimeException(message, e);
+         }
+      }
+      if (accessibleTriedAndFailed) {
+         message = message + ".  An attempt was made to make the method accessible, but the SecurityManager denied the attempt.";
+      }
+      throw new RuntimeException(message, e);
+   }
+
+   @Override
+   public boolean equals(Object obj) {
+      if (obj instanceof AbstractProxySubscriber) {
+         AbstractProxySubscriber bps = (AbstractProxySubscriber) obj;
+         if (referenceStrength != bps.referenceStrength) {
+            return false;
+         }
+         if (subscriptionMethod != bps.subscriptionMethod) {
+            return false;
+         }
+         if (ReferenceStrength.WEAK == referenceStrength) {
+            if (((WeakReference)proxiedSubscriber).get() != ((WeakReference)bps.proxiedSubscriber).get()) {
+               return false;
+            }            
+         } else {
+            if (proxiedSubscriber != bps.proxiedSubscriber) {
+               return false;
+            }
+         }
+         if (veto != bps.veto) {
+            return false;
+         }
+         if (eventService != bps.eventService) {
+            return false;
+         }
+         return true;
+      } else {
+         return false;
+      }
+   }
+
+   @Override
+   public String toString() {
+      return "AbstractProxySubscriber{" +
+              "realSubscriber=" + (proxiedSubscriber instanceof WeakReference?
+                       ((WeakReference)proxiedSubscriber).get():proxiedSubscriber) +
+              ", subscriptionMethod=" + subscriptionMethod +
+              ", veto=" + veto +
+              ", referenceStrength=" + referenceStrength +
+              ", eventService=" + eventService +
+              '}';
+   }
+}