Provide BlockingChecker mechanism which checks current context

Fixes #227

Author: qwwdfsad

binary-compatibility-validator/reference-public-api/kotlinx-coroutines-android.txt

@@ -21,3 +21,8 @@ public final class kotlinx/coroutines/experimental/android/HandlerContextKt {
 	public static final fun getUI ()Lkotlinx/coroutines/experimental/android/HandlerContext;
 }
 
+public final class kotlinx/coroutines/experimental/android/MainLooperChecker : kotlinx/coroutines/experimental/BlockingChecker {
+	public fun <init> ()V
+	public fun runBlockingAllowed ()Z
+}
+

binary-compatibility-validator/reference-public-api/kotlinx-coroutines-core.txt

@@ -22,6 +22,10 @@ public final class kotlinx/coroutines/experimental/AwaitKt {
 	public static final fun joinAll ([Lkotlinx/coroutines/experimental/Job;Lkotlin/coroutines/experimental/Continuation;)Ljava/lang/Object;
 }
 
+public abstract interface class kotlinx/coroutines/experimental/BlockingChecker {
+	public abstract fun runBlockingAllowed ()Z
+}
+
 public final class kotlinx/coroutines/experimental/BuildersKt {
 	public static final synthetic fun launch (Lkotlin/coroutines/experimental/CoroutineContext;Lkotlinx/coroutines/experimental/CoroutineStart;Lkotlin/jvm/functions/Function2;)Lkotlinx/coroutines/experimental/Job;
 	public static final fun launch (Lkotlin/coroutines/experimental/CoroutineContext;Lkotlinx/coroutines/experimental/CoroutineStart;Lkotlinx/coroutines/experimental/Job;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function2;)Lkotlinx/coroutines/experimental/Job;

binary-compatibility-validator/reference-public-api/kotlinx-coroutines-javafx.txt

@@ -1,3 +1,8 @@
+public final class kotlinx/coroutines/experimental/javafx/ApplicationThreadChecker : kotlinx/coroutines/experimental/BlockingChecker {
+	public fun <init> ()V
+	public fun runBlockingAllowed ()Z
+}
+
 public final class kotlinx/coroutines/experimental/javafx/JavaFx : kotlinx/coroutines/experimental/CoroutineDispatcher, kotlinx/coroutines/experimental/Delay {
 	public static final field INSTANCE Lkotlinx/coroutines/experimental/javafx/JavaFx;
 	public final fun awaitPulse (Lkotlin/coroutines/experimental/Continuation;)Ljava/lang/Object;

binary-compatibility-validator/reference-public-api/kotlinx-coroutines-swing.txt

@@ -1,3 +1,8 @@
+public final class kotlinx/coroutines/experimental/swing/EventDispatchThreadChecker : kotlinx/coroutines/experimental/BlockingChecker {
+	public fun <init> ()V
+	public fun runBlockingAllowed ()Z
+}
+
 public final class kotlinx/coroutines/experimental/swing/Swing : kotlinx/coroutines/experimental/CoroutineDispatcher, kotlinx/coroutines/experimental/Delay {
 	public static final field INSTANCE Lkotlinx/coroutines/experimental/swing/Swing;
 	public fun delay (JLjava/util/concurrent/TimeUnit;Lkotlin/coroutines/experimental/Continuation;)Ljava/lang/Object;

core/kotlinx-coroutines-core/src/Builders.kt

@@ -7,6 +7,7 @@
 
 package kotlinx.coroutines.experimental
 
+import java.util.*
 import java.util.concurrent.locks.*
 import kotlin.coroutines.experimental.*
 
@@ -29,12 +30,19 @@ import kotlin.coroutines.experimental.*
  *
  * See [newCoroutineContext] for a description of debugging facilities that are available for newly created coroutine.
  *
+ * @throws IllegalStateException if blocking is not allowed in current thread.
+ *         Blocking is checked by [BlockingChecker] registered in [ServiceLoader]
  * @param context context of the coroutine. The default value is an implementation of [EventLoop].
  * @param block the coroutine code.
  */
 @Throws(InterruptedException::class)
 public fun <T> runBlocking(context: CoroutineContext = EmptyCoroutineContext, block: suspend CoroutineScope.() -> T): T {
     val currentThread = Thread.currentThread()
+
+    if (blockingChecker?.runBlockingAllowed() == false) {
+        throw IllegalStateException("runBlocking is forbidden in $currentThread")
+    }
+
     val contextInterceptor = context[ContinuationInterceptor]
     val privateEventLoop = contextInterceptor == null // create private event loop if no dispatcher is specified
     val eventLoop = if (privateEventLoop) BlockingEventLoop(currentThread) else contextInterceptor as? EventLoop
@@ -46,6 +54,36 @@ public fun <T> runBlocking(context: CoroutineContext = EmptyCoroutineContext, bl
     return coroutine.joinBlocking()
 }
 
+/**
+ * Element of classpath which determines whether invoking [runBlocking] in current thread is allowed.
+ * [runBlocking] discovers all checkers via [ServiceLoader]
+ *
+ * Common example is checking whether we're not in UI thread:
+ * ```
+ * class UiFilter : BlockingFilter {
+ *    fun runBlockingAllowed(): Boolean = !UiFramework.isInUiThread()
+ * }
+ * ```
+ */
+interface BlockingChecker {
+
+    /**
+     * @return whether [runBlocking] calls are allowed in current thread
+     */
+    fun runBlockingAllowed(): Boolean
+}
+
+// Nullable to enable DCE when no filters are present in classpath
+private val blockingChecker: BlockingChecker? = loadBlockingCheckers()
+
+private fun loadBlockingCheckers(): BlockingChecker? {
+    val filters = ServiceLoader.load(BlockingChecker::class.java).toList().toTypedArray()
+    if (filters.isEmpty()) return null
+    return object : BlockingChecker {
+        override fun runBlockingAllowed(): Boolean = filters.all { it.runBlockingAllowed() }
+    }
+}
+
 private class BlockingCoroutine<T>(
     parentContext: CoroutineContext,
     private val blockedThread: Thread,

ui/kotlinx-coroutines-android/resources/META-INF/services/kotlinx.coroutines.experimental.BlockingChecker

@@ -0,0 +1 @@
+kotlinx.coroutines.experimental.android.MainLooperChecker

ui/kotlinx-coroutines-android/src/HandlerContext.kt

@@ -4,12 +4,11 @@
 
 package kotlinx.coroutines.experimental.android
 
-import android.os.Handler
-import android.os.Looper
-import android.view.Choreographer
+import android.os.*
+import android.view.*
 import kotlinx.coroutines.experimental.*
-import java.util.concurrent.TimeUnit
-import kotlin.coroutines.experimental.CoroutineContext
+import java.util.concurrent.*
+import kotlin.coroutines.experimental.*
 
 /**
  * Dispatches execution onto Android main UI thread and provides native [delay][Delay.delay] support.
@@ -89,3 +88,7 @@ public class HandlerContext(
     override fun equals(other: Any?): Boolean = other is HandlerContext && other.handler === handler
     override fun hashCode(): Int = System.identityHashCode(handler)
 }
+
+class MainLooperChecker : BlockingChecker {
+    override fun runBlockingAllowed(): Boolean = Looper.myLooper() != Looper.getMainLooper()
+}

ui/kotlinx-coroutines-javafx/resources/META-INF/services/kotlinx.coroutines.experimental.BlockingChecker

@@ -0,0 +1 @@
+kotlinx.coroutines.experimental.javafx.ApplicationThreadChecker

ui/kotlinx-coroutines-javafx/src/JavaFx.kt

@@ -4,19 +4,15 @@
 
 package kotlinx.coroutines.experimental.javafx
 
-import com.sun.javafx.application.PlatformImpl
-import javafx.animation.AnimationTimer
-import javafx.animation.KeyFrame
-import javafx.animation.Timeline
-import javafx.application.Platform
-import javafx.event.ActionEvent
-import javafx.event.EventHandler
-import javafx.util.Duration
+import com.sun.javafx.application.*
+import javafx.animation.*
+import javafx.application.*
+import javafx.event.*
+import javafx.util.*
 import kotlinx.coroutines.experimental.*
 import kotlinx.coroutines.experimental.javafx.JavaFx.delay
-import java.util.concurrent.CopyOnWriteArrayList
-import java.util.concurrent.TimeUnit
-import kotlin.coroutines.experimental.CoroutineContext
+import java.util.concurrent.*
+import kotlin.coroutines.experimental.*
 
 /**
  * Dispatches execution onto JavaFx application thread and provides native [delay] support.
@@ -43,14 +39,14 @@ object JavaFx : CoroutineDispatcher(), Delay {
     }
 
     override fun scheduleResumeAfterDelay(time: Long, unit: TimeUnit, continuation: CancellableContinuation<Unit>) {
-        val timeline = schedule(time, unit, EventHandler<ActionEvent> {
+        val timeline = schedule(time, unit, EventHandler {
             with(continuation) { resumeUndispatched(Unit) }
         })
         continuation.invokeOnCancellation { timeline.stop() }
     }
 
     override fun invokeOnTimeout(time: Long, unit: TimeUnit, block: Runnable): DisposableHandle {
-        val timeline = schedule(time, unit, EventHandler<ActionEvent> {
+        val timeline = schedule(time, unit, EventHandler {
             block.run()
         })
         return object : DisposableHandle {
@@ -81,6 +77,10 @@ object JavaFx : CoroutineDispatcher(), Delay {
     override fun toString() = "JavaFx"
 }
 
+class ApplicationThreadChecker : BlockingChecker {
+    override fun runBlockingAllowed(): Boolean = !Platform.isFxApplicationThread()
+}
+
 internal fun initPlatform() {
     PlatformImpl.startup {}
 }

ui/kotlinx-coroutines-javafx/test/JavaFxTest.kt

@@ -4,10 +4,11 @@
 
 package kotlinx.coroutines.experimental.javafx
 
-import javafx.application.Platform
+import javafx.application.*
 import kotlinx.coroutines.experimental.*
-import org.junit.Before
+import org.junit.*
 import org.junit.Test
+import kotlin.test.*
 
 class JavaFxTest : TestBase() {
     @Before
@@ -37,4 +38,26 @@ class JavaFxTest : TestBase() {
             finish(4)
         }
     }
-}
+
+    @Test
+    fun testRunBlockingForbidden() {
+        try {
+            initPlatform()
+        } catch (e: UnsupportedOperationException) {
+            println("Skipping JavaFxTest in headless environment")
+            return // ignore test in headless environments
+        }
+
+        runBlocking(JavaFx) {
+            expect(1)
+            try {
+                runBlocking(JavaFx) {
+                    expectUnreached()
+                }
+            } catch (e: Exception) {
+                assertTrue(e.message!!.contains("runBlocking"))
+                finish(2)
+            }
+        }
+    }
+}