What's the purpose of this class?

This is the asynchronous complement to the SyncOnSubscribe as described in #3003.

The remaining issue with this implementation is that the inner observables are subscribed to an unbounded buffer. This could be improved to a back pressure supporting RxRingBuffer that requests from it's producer only to fill it's buffer capacity and then when it connects, drains the buffer and forwards all requests to its producer.

l still don't understand this class. Looks very similar to a SyncOnSubscribe that emits Observables and flatMaps it for you.

I understand your concern but I'm not sure about your comment. This operator does not call flatMap. This issue comes from use cases at Netflix with large services and streaming work. I think it's pretty clear to see from the unit tests that this gives a user direct access to the request and allows fulfillment by any observable (which may or may not be asynchronous).

This is very similar to the work that you tried with the AbstractProducer. It allows batching and eager subscription.

This is supposed to help with creating observables from asynchronous data sources in a non-blocking way. Consider the example below...

public static void main(String[] args) {
    Observable.<Integer>create((Subscriber<? super Integer> s) -> {
        s.setProducer((long requested) -> {
            getData(requested)
                .observe()
                .subscribe(s::onNext, s::onError, s::onCompleted);
        });
    });
}

public static HystrixCommand<Integer> getData(long requested) {
    return null;
}

public static interface HystrixCommand<T> {
    public Observable<T> observe();
}

The use case here is that for each request we want to issue an asynchronous service request and when that request is fulfilled then we want to start onNexting the data for that request. The problem with this naive implementation is that it's very easy and certainly possible to have overlapping requests. You could implement the cas addToRequestAndGet and make sure that only one thread at a time is fulfilling the request at a time but you still have the possibility of onNext events interleaving or overlapping.

it doesn't help with truly hot sources but it'll work great for progressive async sources. 👍

I have reviewed this work with @stealthcode as he's been working on it and am quite interested in where this goes. It can greatly help us solve the most difficult part of using RxJava: creating correct sources that support backpressure.

I'll open an issue to summarize the needs for 1.x and 2.x so we can all get aligned on this topic.

I'm +1 on experimenting with this and eventually getting Observable.create overloads for all these helpers.

Actually, there is already an issue: #3003