}

            return Observable.empty();

          }

        })

          @Override

          public void call() {

            // connection closed, remote slot

            releaseSlot(slottingStrategyReference.getValue(), connection);

            logger.debug("Connection: "+connection.toString()+" closed");

                          return response.getContent();

                      }

                  })

                  .ignoreElements()

                      @Override

                      public void call() {

                          finishLatch.countDown();

                      }

                  })

                        return !notification

                                .isOnError();

                    }

                })

                    @Override

                    public void call() {

                        System.out.println(" --> Closing connection and stream");

                    }

                })

                                    }

                                    return Observable.empty();

                                }

                            }

                            @Override

                            public void call() {

                                System.out.println("--- Connection Closed ---");

                            }

                        });

                // wait for the helloMessage then start the output and receive echo input

                return Observable.concat(helloMessage, Observable.merge(intervalOutput, echo));

            }

            @Override

            public void call() {

                System.out.println("COMPLETED!");

            }

        }).toBlocking().toIterable();

                // wait for the helloMessage then start the output and receive echo input

                return Observable.concat(helloMessage, Observable.merge(intervalOutput, echo));

            }

            @Override

            public void call() {

                System.out.println("COMPLETED!");

            }

        }).toBlocking().toIterable();

                    public Observable<Void> handle(HttpServerRequest<ByteBuf> request,

                                                   HttpServerResponse<ByteBuf> response) {

                        request.getContent().subscribe();

                        response.writeString("Hellooo!!!");

                            @Override

                            public void call() {

                                bothClientAndServerDone.countDown();

                            }

                        });

                    }

                }).appendPipelineConfigurator(new PipelineConfigurator<HttpServerRequest<ByteBuf>, HttpServerResponse<ByteBuf>>() {

                    @Override

                    public void configureNewPipeline(ChannelPipeline pipeline) {

                        pipeline.addLast(serverCloseListener);

                    }

                }).enableWireLogging(LogLevel.ERROR).build().start();

        TestableServerMetricsEventListener listener = new TestableServerMetricsEventListener();

        server.subscribe(listener);

        TestableClientMetricsEventListener clientListener = new TestableClientMetricsEventListener();

        final ChannelCloseListener clientCloseListener = new ChannelCloseListener();

        HttpClient<ByteBuf, ByteBuf> client =

                RxNetty.<ByteBuf, ByteBuf>newHttpClientBuilder("localhost", server.getServerPort())

                       .enableWireLogging(LogLevel.DEBUG)

                       .appendPipelineConfigurator(new PipelineConfigurator<HttpClientResponse<ByteBuf>, HttpClientRequest<ByteBuf>>() {

                           @Override

                           public void configureNewPipeline(ChannelPipeline pipeline) {

                               pipeline.addLast(clientCloseListener);

                           }

                       })

                       .withNoConnectionPooling().build();

        client.subscribe(clientListener);

        client.submit(HttpClientRequest.createGet("/"))

                  @Override

                  public void call() {

                      bothClientAndServerDone.countDown();

                  }

              }).toBlocking().last();

    public void testCompletionWhenNoFuture() throws Exception {

        NoOpChannelHandlerContext context = new NoOpChannelHandlerContext();

        MultipleFutureListener listener = new MultipleFutureListener(context.newPromise());

        final CountDownLatch completionLatch = new CountDownLatch(1);

            @Override

            public void call() {

                completionLatch.countDown();

            }

        }).subscribe();

                            // store the command that is being run

                            endCurrentThreadExecutingCommand.set(Hystrix.startCurrentThreadExecutingCommand(getCommandKey()));

                            getRunObservableDecoratedForMetricsAndErrorHandling(performAsyncTimeout)

                                        @Override

                                        public void call() {

                                            // release the semaphore

                                            // this is done here instead of below so that the acquire/release happens where it is guaranteed

                                            // and not affected by the conditional circuit-breaker checks, timeouts, etc

                                            executionSemaphore.release();

                                        }

                                    }).unsafeSubscribe(observer);

                        } catch (RuntimeException e) {

                            observer.onError(e);

                        }

                    } else {

                        metrics.markSemaphoreRejection();

                        logger.debug("HystrixCommand Execution Rejection by Semaphore."); // debug only since we're throwing the exception and someone higher will do something with it

                        // retrieve a fallback or throw an exception if no fallback available

                        getFallbackOrThrowException(HystrixEventType.SEMAPHORE_REJECTED, FailureType.REJECTED_SEMAPHORE_EXECUTION, "could not acquire a semaphore for execution").unsafeSubscribe(observer);

                    }

                } else {

                    // record that we are returning a short-circuited fallback

                    metrics.markShortCircuited();

                    // short-circuit and go directly to fallback (or throw an exception if no fallback implemented)

                    try {

                        getFallbackOrThrowException(HystrixEventType.SHORT_CIRCUITED, FailureType.SHORTCIRCUIT, "short-circuited").unsafeSubscribe(observer);

                    } catch (Exception e) {

                        observer.onError(e);

                    }

                }

            }

        });

        // error handling at very end (this means fallback didn't exist or failed)

        o = o.onErrorResumeNext(new Func1<Throwable, Observable<R>>() {

            @Override

            public Observable<R> call(Throwable t) {

                // count that we are throwing an exception and re-throw it

                metrics.markExceptionThrown();

                return Observable.error(t);

            }

        });

        // any final cleanup needed

            @Override

            public void call() {

                Reference<TimerListener> tl = timeoutTimer.get();

                if (tl != null) {

                        s.onError(new RuntimeException("timed out before executing run()"));

                    } else {

                        // not timed out so execute

                        try {

                                @Override

                                public void call() {

                                    // TODO is this actually the end of the thread?

                                    executionHook.onThreadComplete(_self);

                                }

                            }).unsafeSubscribe(s);

                        } catch (Throwable t) {

                            // the run() method is a user provided implementation so can throw instead of using Observable.onError

                            // so we catch it here and turn it into Observable.error

                            Observable.<R> error(t).unsafeSubscribe(s);

                        }

                    }

                }

            }).subscribeOn(threadPool.getScheduler());

        } else {

            // semaphore isolated

            executionHook.onRunStart(_self);

            try {

                run = getExecutionObservable();

            } catch (Throwable t) {

                // the run() method is a user provided implementation so can throw instead of using Observable.onError

                // so we catch it here and turn it into Observable.error

                run = Observable.error(t);

            }

        }

        run = run.doOnEach(new Action1<Notification<? super R>>() {

            @Override

            public void call(Notification<? super R> n) {

                setRequestContextIfNeeded(currentRequestContext);

            }

        }).lift(new HystrixObservableTimeoutOperator<R>(_self, performAsyncTimeout)).map(new Func1<R, R>() {

            boolean once = false;

            @Override

            public R call(R t1) {

                System.out.println("map " + t1);

                if (!once) {

                    // report success

                    executionResult = executionResult.addEvents(HystrixEventType.SUCCESS);

                    once = true;

                }

                return executionHook.onRunSuccess(_self, t1);

            }

            @Override

            public void call() {

                long duration = System.currentTimeMillis() - invocationStartTime;

                metrics.addCommandExecutionTime(duration);