Use correct thread pools

src/main/java/io/vertx/core/file/impl/AsyncFileImpl.java

@@ -352,7 +352,7 @@ private synchronized void doFlush(Handler<AsyncResult<Void>> handler) {
       } catch (IOException e) {
         throw new FileSystemException(e);
       }
-    }, handler);
+    }, true, handler);
   }
 
   private void doWrite(ByteBuffer buff, long position, long toWrite, Handler<AsyncResult<Void>> handler) {

src/main/java/io/vertx/core/file/impl/FileSystemImpl.java

@@ -806,7 +806,7 @@ public BlockingAction(Handler<AsyncResult<T>> handler) {
      * Run the blocking action using a thread from the worker pool.
      */
     public void run() {
-      context.executeBlocking(this, handler);
+      context.executeBlocking(this, true, handler);
     }
   }
 }

src/main/java/io/vertx/core/impl/ContextImpl.java

@@ -51,11 +51,13 @@ public abstract class ContextImpl implements Context {
   private final ClassLoader tccl;
   private final EventLoop eventLoop;
   protected final Executor orderedInternalPoolExec;
+  protected final Executor workerExec;
   protected VertxThread contextThread;
 
-  protected ContextImpl(VertxInternal vertx, Executor orderedInternalPoolExec, String deploymentID, JsonObject config,
+  protected ContextImpl(VertxInternal vertx, Executor orderedInternalPoolExec, Executor workerExec, String deploymentID, JsonObject config,
                         ClassLoader tccl) {
     this.orderedInternalPoolExec = orderedInternalPoolExec;
+    this.workerExec = workerExec;
     this.deploymentID = deploymentID;
     this.config = config;
     EventLoopGroup group = vertx.getEventLoopGroup();
@@ -196,17 +198,19 @@ public EventLoop getEventLoop() {
   }
 
   // Execute an internal task on the internal blocking ordered executor
-  public <T> void executeBlocking(Action<T> action, Handler<AsyncResult<T>> resultHandler) {
-    executeBlocking(action, null, resultHandler);
+  public <T> void executeBlocking(Action<T> action, boolean internal, Handler<AsyncResult<T>> resultHandler) {
+    executeBlocking(action, null, internal, resultHandler);
   }
 
   public <T> void executeBlocking(Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler) {
-    executeBlocking(null, blockingCodeHandler, resultHandler);
+    executeBlocking(null, blockingCodeHandler, false, resultHandler);
   }
 
-  public <T> void executeBlocking(Action<T> action, Handler<Future<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler) {
+  private <T> void executeBlocking(Action<T> action, Handler<Future<T>> blockingCodeHandler, boolean internal,
+                                  Handler<AsyncResult<T>> resultHandler) {
     try {
-      orderedInternalPoolExec.execute(() -> {
+      Executor exec = internal ? orderedInternalPoolExec : workerExec;
+      exec.execute(() -> {
         Future<T> res = Future.future();
         try {
           if (blockingCodeHandler != null) {

src/main/java/io/vertx/core/impl/DeploymentManager.java

@@ -592,7 +592,7 @@ private void startRedeployTimer() {
 
     private void doStartRedeployTimer() {
       redeployTimerID = vertx.setTimer(options.getRedeployScanPeriod(), tid -> {
-        vertx.executeBlocking(redeployer, res -> {
+        vertx.executeBlockingInternal(redeployer, res -> {
           if (res.succeeded()) {
             if (res.result()) {
               doRedeploy();

src/main/java/io/vertx/core/impl/EventLoopContext.java

@@ -32,9 +32,9 @@ public class EventLoopContext extends ContextImpl {
 
   private static final Logger log = LoggerFactory.getLogger(EventLoopContext.class);
 
-  public EventLoopContext(VertxInternal vertx, Executor bgExec, String deploymentID, JsonObject config,
+  public EventLoopContext(VertxInternal vertx, Executor internalBlockingExec, Executor workerExec, String deploymentID, JsonObject config,
                           ClassLoader tccl) {
-    super(vertx, bgExec, deploymentID, config, tccl);
+    super(vertx, internalBlockingExec, workerExec, deploymentID, config, tccl);
   }
 
   public void executeAsync(Handler<Void> task) {

src/main/java/io/vertx/core/impl/HAManager.java

@@ -283,7 +283,7 @@ private synchronized void checkQuorumWhenAdded(final String nodeID, final long s
     } else {
       vertx.setTimer(200, tid -> {
         // This can block on a monitor so it needs to run as a worker
-        vertx.executeBlocking(() -> {
+        vertx.executeBlockingInternal(() -> {
           if (System.currentTimeMillis() - start > 10000) {
             log.warn("Timed out waiting for group information to appear");
           } else if (!stopped) {

src/main/java/io/vertx/core/impl/VertxImpl.java

@@ -345,7 +345,7 @@ public boolean cancelTimer(long id) {
   }
 
   public EventLoopContext createEventLoopContext(String deploymentID, JsonObject config, ClassLoader tccl) {
-    return new EventLoopContext(this, workerOrderedFact.getExecutor(), deploymentID, config, tccl);
+    return new EventLoopContext(this, internalOrderedFact.getExecutor(), workerOrderedFact.getExecutor(), deploymentID, config, tccl);
   }
 
   @Override
@@ -566,10 +566,16 @@ public Set<VerticleFactory> verticleFactories() {
     return deploymentManager.verticleFactories();
   }
 
+  @Override
+  public <T> void executeBlockingInternal(Action<T> action, Handler<AsyncResult<T>> resultHandler) {
+    ContextImpl context = getOrCreateContext();
+    context.executeBlocking(action, true, resultHandler);
+  }
+
   @Override
   public <T> void executeBlocking(Action<T> action, Handler<AsyncResult<T>> resultHandler) {
     ContextImpl context = getOrCreateContext();
-    context.executeBlocking(action, resultHandler);
+    context.executeBlocking(action, false, resultHandler);
   }
 
   @Override

src/main/java/io/vertx/core/impl/VertxInternal.java

@@ -18,9 +18,11 @@
 
 
 import io.netty.channel.EventLoopGroup;
+import io.vertx.core.AsyncResult;
 import io.vertx.core.Handler;
 import io.vertx.core.http.impl.HttpServerImpl;
 import io.vertx.core.json.JsonObject;
+import io.vertx.core.spi.cluster.Action;
 import io.vertx.core.spi.metrics.VertxMetrics;
 import io.vertx.core.net.impl.NetServerImpl;
 import io.vertx.core.net.impl.ServerID;
@@ -83,4 +85,6 @@ public interface VertxInternal extends VertxSPI {
   String getNodeID();
 
   File resolveFile(String fileName);
+
+  <T> void executeBlockingInternal(Action<T> action, Handler<AsyncResult<T>> resultHandler);
 }

src/main/java/io/vertx/core/impl/WorkerContext.java

@@ -28,12 +28,9 @@
  */
 public class WorkerContext extends ContextImpl {
 
-  protected final Executor workerExec;
-
   public WorkerContext(VertxInternal vertx, Executor orderedInternalPoolExec, Executor workerExec, String deploymentID,
                        JsonObject config, ClassLoader tccl) {
-    super(vertx, orderedInternalPoolExec, deploymentID, config, tccl);
-    this.workerExec = workerExec;
+    super(vertx, orderedInternalPoolExec, workerExec, deploymentID, config, tccl);
   }
 
   @Override