v3.1.4.RELEASE

This is the 4th release of Reactor 3.1, part of BISMUTH-SR6 Release Train.

This is a recommended update for all Reactor 3 users.

⚠️ Update considerations and deprecations

• The MPSC Queue implementation from 3.1.3.RELEASE shouldn't have been public (#1010, #1035)
  • it is now exposed as a plain Queue through Queues.unboundedMultiproducer()
• 3 operator implementations have mistakenly been released as public classes (#1036)
  • These classes shouldn't have normally been noticed by users. However they have now been made private.
  • FluxDelaySequence, FluxIndex and FluxIndexFuseable
• Emitting a Context as part of Flux.repeatWhen and Flux.retryWhen companion flux triggers a specific behavior (#1048)
  • The emitted Context, which acts as a trigger for resubscription to the source, replaces the original Context of the
    xxxWhen operator and becomes visible to the upstream from that point.
  • Care should be taken to craft that Context from the original Context, otherwise you risk blindly deleting keys from the original that 3rd party libraries rely on. (this is described in the javadoc)
• Like Flux.zip, Mono.zip short-circuits on the first source that terminates empty, cancelling other pending sources (#1071)
  • this means that the Mono will complete as soon as any Mono<Void> source or any empty Mono<T> completes. this could lead to earlier than expected completions.
  • note this changes nothing for sources that are all valued
  • You should look for Mono.zip(...).then() pattern in your code and replace that with Mono.when(...) instead, as when does wait for all completions and results in a Mono<Void>.
  • If you want to keep the behavior of letting all valid sources run to completion, use Mono.zipDelayError, which
    won't cancel other sources (aggregating to a composite onError in case of 1+ errors, or an empty mono in case
    of 0 error and 1+ empty sources)

✨ New features and improvements

• log now has a variant that directly takes a Logger instance, which can improve performance if the bottleneck
  is the resolution of Loggers (#956)
• a new variant of merge, the mergeOrdered, has been added to Flux and ParallelFlux (#963)
• Flux.concatWithValues(T...) and Mono.thenReturn(T) have been added to conveniently concat/continue with
  scalar values (#1029)
• Operators that used to synchronize around a queue now use the new MPSC queue implementation instead (#914)
• distinct now allows for arbitrary backing store, not necessarily a Collection, if you also provide a
  "distinct check" BiPredicate (#1054)
• In Kotlin extensions, nullable types are mapped to non-nullable Monos (#1062)
• Emitting a Context as part of Flux.repeatWhen and Flux.retryWhen companion flux triggers a specific behavior (see update considerations above, #1048)
• Core implementations of Scheduler and Worker are now Scannable (#1050)
  • The interfaces themselves are not, so you'll need to attempt scanning by first calling Scannable.from(schedulerInstance)
  • ExecutorService-backed schedulers can offer a degree of insight into their executor if it is a ThreadPoolExecutor, via
    scanning of CAPACITY and BUFFERED
  • Most core executors that used to be backed by a Executors.newSingleThreadExecutor (which isn't introspectable by the above
    method) are now backed by a ThreadPoolExecutor with a corePoolSize == maxPoolSize of 1.
• Most operators that take a Scheduler as parameter can return that Scheduler or the Worker they use via a scan()
  of the new Attr.RUN_ON attribute. A Scannable.UNAVAILABLE_SCAN is returned if that information is not available (dcc36e5)

🪲 Bug fixes

• doOnEach could be ignored in case of a Fuseable source, due to a mistake in the way it would call its
  downstream onSubscribe method with its source rather than itself (#1056, #1067)
• The elastic Scheduler would retain a reference to all its expired workers, which has now been fixed (#1070)
• The TopicProcessor and WorkQueueProcessor forceShutdown() method would fail to shut down the "request task"
  backing ExecutorService (#1074)
• Like Flux.zip, Mono.zip short-circuits on the first source that terminates empty, cancelling other pending sources
  (see update considerations above, #1071)

📖 Documentation, Tests and Build

• Documentation improvements and typo corrections
• Various test improvements making some tests less brittle on our CI
• japicmp now has the previous 3.1.3.RELEASE as baseline (1c0fa6d)
• Some tests were missing a final verify() call, and as such not testing anything (#1046)

👍 Thanks to the following contributors that also participated to this release

@anonymousXrandom, @KPull, @pcroc, @sbuettner, @yilinwei

v3.1.3.RELEASE

This is the 3rd release of Reactor 3.1, part of BISMUTH-SR5 Release Train.

This is a recommended update for all Reactor 3 users.

⚠️ Update considerations and deprecations

• The implementations of bufferWhen and windowWhen (which are also backing their timeout based variants) have changed, fixing leaks in the process.
• distinct()/distinctUntilChanged() now use the full object (with a HashSet) instead of just the extracted hashcode() for their distinct criteria (#1025)
• EventLoopProcessor#shutdownAndAwait(long, TimeUnit) has been deprecated (#986)
• MpscLinkedQueue, FluxDelaySequence, FluxIndex, FluxIndexFuseable have been scoped public API and should NOT be used. A patch release will fix their scope back to package scope.

✨ New features and improvements

• If Level is FINE/FINEST, log() now logs errors using debug()/trace() (#967)
• ParallelFlux#composeGroup maintains parallelism() (#968)
• EventLoop based Processors now have a Duration based shutdownAndAwait (#986)
• Test features:
  • Added meaningful toString to StepVerifier steps (d3e6c4b)
  • Added Context testing features (#901, #898)
• Add delaySequence operator to Flux, that just shifts the sequence forward in time (#989)
• Prevent handle sink usage after error/complete (#965)
• Make Context accessible through Signal from materialize and doOnEach (#947, #1004)
• Avoid using only hashcode as default distinct()/distinctUntilChanged() criteria (#1025)

🪲 Bug fixes

• Detect same-thread request in Mono subscribeOn (#943, #949)
• Execute doFinally even if subscribe() throws (#951)
• Don't retain reference to UnicastProcessor subscriber on cancel (#980)
• Prevent NPE when debug mode is activated via command line (#985)
• Fix eventual premature termination issue with WorkQueueProcessor (4b2fd19)
• [test] VirtualTimeScheduler: Use single worker, wait for expectations before advancing time (#1001, #992, #959)
• windowWhile now replenishes on premature cancel (#1017)
• Fixed leak: retaining of windows in windowWhen (#975)
• Fixed leak: buffers being retained until completion of a bufferWhen Flux (#969, 170f39b)
• Notify lack of request on bufferTimeout (#994)
• Process fatal exceptions in Schedulers.handleError, don't throw / silently fail (#916)

📖 Documentation, Tests and Build

• Improve documentation of Flux.merge, advanced features reference guide, various typos (#1020, #970)
• Bump Kotlin, AssertJ and ReactiveStreams versions (#915, 69fbde6, 6c0bde7)
• Improve CI testing, avoid longer tests on Travis only, decrease verbosity of some tests (14d607b, #325, #1007, )

👍 Thanks to the following contributors that also participated to this release

@glyn, @OlegDokuka, @onionf91, @stamhankar999

v3.2.0.M1

3.2.0 MILESTONE 1

This version of 3.2.0 is an advance MILESTONE (despite the fact that development continues in parallel on 3.1.3.RELEASE). Its main goal is to make the "error mode" feature accessible for testing (see #629 and
ce62135).

Note that all latest developments on the master branch for 3.1.x versions are not necessarily present in this milestone, as it was branched from master on Jan. 10 2018 (commit 5a4d38f "Notify lack of request on bufferTimeout" in the history)

v3.1.2.RELEASE

This is the 3rd release of Reactor 3.1, part of BISMUTH-SR4 Release Train.

This is a recommended update for all Reactor 3 users. It notably contains a new Flux operator called index to index as a Tuple<Long, T> or any arbitrary container each element from a sequence.

✨ New features and improvements

• Add Flux#index operator (#934)
• Add Mono#single to enforce the presence of an element in a Mono<T> (#940)
• Add Mono#blockOptional to block and return an Optional (#918)
• Add Flux#fromStream(Supplier<Stream>) (#922)
• Use an explicit timeout message for timeout operator (#925)
• Add a Kotlin extension to create a Mono from a Supplier (#929)

🪲 Bug fixes

• Fix concatDelayError and concatMapDelayError with Mono.error (#936)

📖 Documentation, Tests and Build

• Add Context simple example in reference guide (#921)
• Fix javadoc marble for Mono.repeatWhenEmpty (#919)
• Fix CLA in Contributing.md (#98b32f5)
• Fix links to JDK Reference (#a0d8126)
• Add cache(Duration) javadoc (#930)
• Fix Context content in test (#950)
• Improvve Scheduler javadoc (#935)

👍 Thanks to the following contributors that also participated to this release

@baptistemesta, @naxhh

v3.1.1.RELEASE

This is the 2nd release of Reactor 3.1, part of BISMUTH-SR2 Release Train.

This is a recommended update for all Reactor 3 users. It notably contains an important fix for a Flux#windowTimeout bug introduced in v3.1.0.

✨ New features and improvements

• Overflow exception for interval has been clarified, making it clearer that interval doesn't really support backpressure (#911)
• Improved means of customizing the request amount mid-chain: new limitRequest operator will strictly cap the total request (without prefecthing, unlike limitRate) and limitRate now has a variant that takes a lowTide parameter that allow to customize the replenishing amount (#879, #894)
• Kotlin extension now extends Publisher with toFlux and toMono operations (#908)

🪲 Bug fixes

• Flux#windowTimeout with <10ms timeouts could trigger race conditions and lose some windows/drop data to already closed windows. The operator has consequently been reworked (#912)
• Periodic tasks of Schedulers and Workers are now correctly cancelled by calling dispose() (#880)
• Ensure that Scannable scanning of PARENT and ACTUAL always returns a Scannable, even if the original unsafe scan didn't. In the later case, the UNAVAILABLE_SCAN instance is returned (#895)
• ParallelFlux (.parallel()) is now considered a THREAD_BARRIER for fusion purposes, allowing sensitive operators to skip fusion (#905)

📖 Documentation, Tests and Build

• Several typos fixed and rephrasing have been made (#885, #868, #902)
• Reference guide now has a small section on reactor-extra (#899)
• Build has been upgraded to Gradle 4.2, binary compatibility is now checked with a baseline (3.1.0.RELEASE) using japicmp (#884)
• Java 9: fixed deep reflection issue and additional build with JDK9 in Travis CI (minus a few elements due to build dependencies not being ready, #881, #883, #891)
• The Kotlin plugin has been upgraded to 1.1.51, with a workaround for a source jar class duplication issue (#889, #887)
• OSGI compatibility has been improved with the removal of extraneous packages and marking kotlin and JSR305 as optional (#903)

👍 Thanks to the following contributors that also participated to this release

@0xflotus, @Buzzardo, @kadyana, @quaff, @sdeleuze

v3.1.0.RELEASE

This is the first release of Reactor 3.1, part of Bismuth-RELEASE Release Train.

This version is a recommended update for all Reactor 3 users, and will be the one backing Spring Framework 5.0. A lot of API polishing has occurred between the last 3.0.x release and this one, so please read the release notes below carefully if you didn't progressively upgrade through the various MILESTONEs and RCs. (if you only care about what changed since RC1, please have a look at the RC2 release note)

The release notes below are written from the perspective of a migration from 3.0.x latest version and cover
changes across all the 3.1.0 pre-releases.

Note that since pre-release v3.1.0.M2, the source code for the reactor-test artifact is part of the reactor-core github repository.

⚠️ Update considerations and deprecations

• Reactor has been updated to pass the TCK of the new Reactive Streams specification 1.0.1.RC2. A new StrictSubscriber enforces RS rules more strictly when going out of the Reactor world and bridging to an external Publisher (#711)

• The reactor-test artifact is now part of the io.projectreactor groupId (and reactor-core github repository)

• Kotlin extensions for core and test are now part of the reactor-core repo and artifacts

• behavioral changes

  • doAfterTerminate doesn't cause an onError signal if its callback fails (#270)
  • sample will now include the last element in the source sequence if it terminates with an open sampling window (#724)
  • Flux.cache(Duration) now expires the termination signal as well (#750)

• Flux/Mono method changes

  • ParallelFlux#subscribe(lambdas) lambda-based variants now return a Disposable (composite of all rails subscribers, #800)
  • Flux#toIterable now takes an int for its batchSize argument (f3e13bf)
  • Mono.doOnTerminate and doAfterTerminate now take a simple Runnable (aligning the API with Flux). The old doOnTerminate(BiConsumer<Throwable, T>) can be achieved with the added doOnSuccessOrError and old doAfterTerminate(BiConsumer<Throwable, T>) with doAfterSuccessOrError(BiConsumer<Throwable, T>). (#836 + 80a3210)
  • Flux.firstEmitting is now called first and Flux.firstEmittingWith is now called or, aligning APIs with those of Mono (#849)
  • static Mono.empty(Publisher<?>) has been removed, prefer using the new Mono.when(p) (2e7fdf3)
  • buffer operators that take a (Publisher, Function) as arguments (open boundary and closing selector) have been renamed to bufferWhen. This improves the situation where having multiple lambda-based signature can create ambiguity (even more so in languages like Kotlin) (#542)
  • delay in Flux is removed in favor of Flux.delayElements (see #263)
  • Mono#untilOther removed (use delayUntil(it -> other.take(1)) instead, see #558)

• then:

  • variants of then that took a Supplier have been removed. Use defer if you really need to provide the continuation Mono lazily (#547)
  • Flux.then(Publisher<Void>) has been removed in favor of thenEmpty
  • Mono.then(Function) is now Mono.flatMap

• Mono zip vs when

  • zip is the operator dedicated to producing Tuples (or equivalent combinations) of the elements from multiple sources.
    As a consequence, when and and variants that produced a Tuple have now been renamed zip and zipWith (#789 + 52f7f04)
  • when and and still exist, as operators in the same family as then: they only care about completion signals,
    discarding elements and returning a Mono<Void>.
  • Mono#zip with an iterable: for consistency, swap the arguments (old "function, iterable" version is deprecated, see #619)
  • zip(Iterable) and zip(Function, Iterable)in Flux has been removed (#338, #619)

• ⚠️ Mono.then(Function) and Mono.flatMap(): how to migrate (#516):

  • first replace all usage of Mono.flatMap with flatMapMany
  • then replace all usage of Mono.then(Function) (which has been removed) with flatMap.
  • the gist of this change is that the old flatMap was actually changing the return type to Flux and was thus missing the "Many" suffix we usually use. At the same time, then(Function) was transforming the source value (unlike any other form of then which usually just ignore the emissions and act on the onComplete). Thus it was actually more of a flatMap.

• error handling operators have been made more consistent between Mono and Flux (#533, #535, #531)

  • Flux: onErrorResumeWith -> onErrorResume, mapError -> onErrorMap, switchOnError -> replace with onErrorResume with a lambda that ignores the left hand side.
  • Mono: otherwise -> onErrorResume, otherwiseReturn -> onErrorReturn, otherwiseIfEmpty -> switchIfEmpty, mapError -> onErrorMap

• window:

  • various window operators have been aligned in behavior with respect to cancellation (#384)
  • window operators that take a (Publisher, Function) as arguments (open boundary and closing selector) have been renamed to windowWhen. This improves the situation where having multiple lambda-based signature can create ambiguity (even more so in languages like Kotlin) (#542)
  • Flux.window() has been removed in favor of window(Publisher), windowUntil and windowWhile(see #260)
  • Flux.windowTimeOrSize: the timeout now starts right from subscription, resulting in potentially empty windows being emitted. It also restarts if the
    timeout expires, so there could be several empty windows emitted eg. 3 for a timeout of 100ms if the Flux doesn't emit for 300ms.
    The equivalent buffer version remains unchanged. (#484)
  • windowUntil/windowWhile have Flux windows instead of GroupedFlux (#759)

• Cross operator changes based on prefix / parameter pattern:

  • xxxMillis: Timed operators with the Millis suffix have been removed, use their Duration based counterparts
  • xxx(boolean delayError): All operators that were taking a delayError boolean parameter instead of having a DelayError suffixed variant now use the suffix variant pattern (see #480)
  • xxx(Function<Throwable, ?>): Operators dealing with a Predicate or Function of Throwable have been aligned to take a more generic <? super Throwable>
  • All subscribe methods in Flux that had a prefetch parameter have been removed (you can use limitRate to achieve the same effect)

• class changes

  • Signal is now an interface and MutableNextSignal has been removed (#779)
  • Old introspection interfaces, which were mostly only used internally, have been removed in favor of the single Scannable interface (Loopback, MultiProducer, MultiReceiver, Producer, Receiver, Trackable, see #249, 20bd64d)
  • Cancellation has been removed and replaced with Disposable (see #322, 844769d)
  • TimedScheduler has been removed, as well as the Scheduler#shutdown method (most schedulers are now fully time capable and you can use dispose(). The few Scheduler that are not time-capable will throw a RejectedExecutionException indicating so whenever one attempts to use schedulePeriodically on them. Note that most timed operators now use the parallel() Scheduler by default. (see #451, #322)
  • Review interrupted flag on dispose (#507)
  • Removed fromExecutorService(exec, boolean) variant
  • Removed factory hook for simple ExecutorService (now all Scheduled)
  • OpenHashSet has been removed, as it was only used for Disposables: use Disposables.composite() (40fbd60)
  • QueueSupplier has been renamed to Queues and is now purely about queue-related utils and static suppliers. It doesn't implement Supplier<Queue> itself anymore. (#733)

• Hooks

  • Hooks are now cumulative. Setting a hook will add it on top of the existing one(s). You can also name
    some hooks, which allows to update a sub-hook or only partially reset a hook. (#687, #784)
  • new hooks onEachOperator + onLastOperator, now Function<Publisher, Publisher>, new operator lift (#775)
  • hooks must now be called with the Context (#830)

• nullability

  • Nullability checks are helped with the use of annotations. Most of the Reactor API is NonNull (#614)
  • Some additional non-null checks are enforced, notably on all Tuple (#696)

• Processors have been reworked:

  • You cannot connect explicitly anymore but should rather use the sink() method. For details and rationale, see #525.
  • Processors that are costly to instantiate (TopicProcessor, WorkQueueProcessor) now have a Builder instead of
    factory methods. However, they keep a couple of significant factory methods (see #471, #616 and #628)
  • Mono#subscribe() returns a Disposable. Use .toProcessor() to get the exact legacy behavior (see #566, #605 and #638)
  • UnicastProcessor won't ignore the overflowStrategy if we can detect that a bounded queue is used. By default, an unbounded queue is used and the strategy is silently ignored. (#612)
  • DirectProcessor and UnicastProcessor now call onErrorDropped and onNextDropped if calling after terminate. Exceptions.argumentIsNullException() has been removed (most of the time replaced by Objects.requireNonNull()). (7f6ff86)
  • MonoProcessor cancel/dispose now signals CancellationException (#792)

• Some changes have been made to the way writing custom operators works

  • Operators.SubscriberAdapter is not part of the public API anymore.
  • Operators.addAndGet(AtomicLong, ...) has been removed in favor of the AtomicLongFieldUpdater alternative, itself renamed to addCap (#371)
  • Removed unused and confusing Operators.addAndGet (#371)
  • MonoSource and FluxSource are now package privat...

v3.1.0.RC2

This is the second RELEASE CANDIDATE of Reactor 3.1.0, preparing for the upcoming Bismuth Release Train.

This is a recommended update for all Reactor 3 users.

⚠️ Update considerations and deprecations

• Flux#toIterable now takes an int for its batchSize argument (f3e13bf)
• Removed unused and confusing Operators.addAndGet (#371)
• Renamed Operators.getAndAddCap to addCap (#371)

✨ New features and improvements

• Added the expand operator (#769)
• Mono#fromCallable/fromSupplier now map null result to empty Mono (#743)
• Introduce Reactor nullability annotations (#864, #873, #875)

🪲 Bug fixes

• Fix recursive context bug on flatMapMany (8e33991)
• Add reason to default Scheduler exception throwing (#854)
• Change Operators subscriptions from enum to final classes (#857)
• Safely suppress exceptions through Exceptions.addSuppressed (#758)
• ParallelFlux now correctly support conditional subscribers (#865, #389)
• MonoProcessor shouldn't have been a strict subscriber (#866)
• Review int.max prefetch (f3e13bf)
• Multicast cancel now disposes upstream properly (#870)
• Protect serializedSink from illegal subscriber onNext throw (#613)
• Improve progressive demand handling (#371)

📖 Documentation, Tests and Build

• Reference guide has been completed (#853, #838, 0e0b6c9, 89eb394, #862)

👍 Thanks to the following contributors that also participated to this release

@osi @rdegnan @sdeleuze

v3.1.0.RC1

This is the first RELEASE CANDIDATE of Reactor 3.0, part of upcoming Bismuth-RELEASE Release Train.

This is a recommended update for all Reactor 3 users.

⚠️ Update considerations and deprecations

• sample will now include the last element in the source sequence if it terminates with an open sampling window (#724)
• Scannable.getOrDefault will always use the provided default and no longer rely on the Attr global default as an intermediate fallback (#785)
• Signal is now an interface and MutableNextSignal has been removed (#779)
• Hooks: new hooks onEachOperator + onLastOperator, now Function<Publisher, Publisher>, new operator lift (#775) TODO expand on this
• windowUntil/windowWhile have Flux windows instead of GroupedFlux (#759)
• Flux.cache(Duration) now expires the termination signal as well (#750)
• Mono#when variants are now zip. Corresponding Kotlin extensions have also been removed (zip isn't a keyword) (#789 + 52f7f04)
• ParallelFlux#subscribe(lambdas) lambda-based variants now return a Disposable (composite of all rails subscribers, #800)
• MonoProcessor cancel/dispose now signals CancellationException (#792)
• Operators.onNextDropped default behaviour is to log the drop rather than throw a "fail with cancel" exception (#823)
• DirectProcessor and UnicastProcessor now call onErrorDropped and onNextDropped if calling after terminate. Exceptions.argumentIsNullException()has been removed (most of the time replaced byObjects.requireNonNull()`). (7f6ff86)
• Hooks in Operators (eg. onOperatorError) must now be called with the Context (#830)
• Mono.doOnTerminate and doAfterTerminate now take a simple Runnable (aligning the API with Flux). The old doOnTerminate(BiConsumer<Throwable, T>) can be achieved with the added doOnSuccessOrError and old doAfterTerminate(BiConsumer<Throwable, T>) with doAfterSuccessOrError(BiConsumer<Throwable, T>). (#836 + 80a3210)
• Flux.firstEmitting is now called first and Flux.firstEmittingWith is now called or, aligning APIs with those of Mono (#849)
• static Mono.empty(Publisher<?>) has been removed, prefer using the new Mono.when(p) (2e7fdf3)
• Context API refinement:
  • Mono#currentContext does emit empty contexts rather than terminating empty (#816)
  • contextStart renamed to subscriberContext, remove contextGet (#780)
• Review interrupted flag on dispose (#507)
  • Removed fromExecutorService(exec, boolean) variant
  • Removed factory hook for simple ExecutorService (now all Scheduled)
• Rename Mono.currentContext to subscriberContext() (#831)
• Operators.onErrorDropped, onNextDropped, onOperatorError and onRejectedExecution now also take the Context as parameter (7ae167f, a9df084)
• OpenHashSet has been removed, as it was only used for Disposables: use Disposables.composite() (40fbd60)

✨ New features and improvements

• Upgrade to Kotlin 1.1.4-3
• Add ability to name and tag a reactive sequence (#579)
• Add a new Console logger, now the default fallback instead of JDK logger (#680)
• Add utility method to check if a Throwable is composite (#770)
• Add Swap & Composite Disposable specializations (#731, bf8d8cb)
• onEachOperator/onLastOperator/onOperatorError hooks can be named, allowing for additive hooks AND partial hook reset (#784)
• Offer way to do requests on original thread with subscribeOn (#777)
• Add take(Duration) and takeUntilOther(Publisher) to Mono (#797)
• Have ParallelFlux lambda subscribe return composite Disposable (#800)
• Add Disposable single(), disposed() and never() factories to a Disposables utility class ( #799, #804, #812)
• Context API refinements: factory methods and specialized implementations for 1-5 elements (#780)
• Add Mono.cache(Duration) (#683)
• Add "not dropped" assertions to StepVerifier assertions (96ae5ca)
• Add Context#delete(key) (#817)
• onErrorDropped/onNextDropped/onOperatorError/onRejectedExecution look for local hooks in the Context (b576f7f)
• Add a PublisherProbe to easily probe for subscription in tests (#833)
• Return original reference if unwrapped exception is null (#848)

🪲 Bug fixes

• ParallelScheduler does not schedule task evenly between threads (#761)
• Pass failed signal to onOperatorError in trySubscribeScalarMap (#684)
• Remove cancel during onNext for MonoDelayElement (#749)
• Attr.LARGE_BUFFERED defaults back to null (as in "irrelevant") (#751)
• Revert publishOn async path detection over-optimization (#767)
• Exceptions.addThrowable now reuse same root composite (#771)
• Guard ExecutorScheduler against Executor's task failures (#324)
• Catch fused flattenIterable polling failures (#841)
• Fix windowTimeout rejection double cancel (31ef92d)
• VirtualTimeScheduler shutdown is not correctly handled with periods (#776)
• Protect immediate flatMap scalar emissions from out of order consuming (c7d3c12, 3abcb83, ce49077)
• Ensure no Subscription#request throws/errors (4d61440, decfa13)
• Avoid the shortcut of MonoProcessor.onNext(null) for onComplete (#701)

📖 Documentation, Tests and Build

• various typos have been fixed in javadocs, README, reference guide
• the reference guide has been reviewed and wording improved
• Document groupBy caveats, as well as other batching methods (#726)
• Android compatibility and best effort support is described in README statement (#796)
• Contributing to the documentation is explained and made easier with direct edit links (#801, #808)
• Added a clarification sink() will subscribe the emitter (2cd83c2)

👍 Thanks to the following contributors that also participated to this release

@akarnokd, @Buzzardo, @helmbold, @lebannen, @olibye, @rajinisivaram, @sdeleuze, @violetagg, @zgagnon

v3.1.0.M3

This is the MILESTONE 3 release of Reactor 3.1, part of Bismuth-M3 Release Train.

This is a recommended update for all Reactor 3 users.

⚠️ Update considerations and deprecations

• Nullability checks are helped with the use of annotations. Most of the Reactor API is NonNull (#614)
  • some additional non-null checks are enforced, notably on all Tuple (#696)
• Processor builders: The move to builders from M2 has been partially reverted. Only Processors that are costly to instantiate have a Builder (TopicProcessor, WorkQueueProcessor). They also keep a couple of significant factory methods (#616)
• UnicastProcessor won't ignore the overflowStrategy if we can detect that a bounded queue is used. By default, an unbounded queue is used and the strategy is silently ignored. (#612)
• QueueSupplier has been renamed to Queues and is now purely about queue-related utils and static suppliers. It doesn't implement Supplier<Queue> itself anymore. (#733)
• Hooks are now cumulative. Setting a hook will add it on top of the existing one(s) and you need to reset the hook if you want to replace the current one. (#687)
• Flux.error and Mono.error are now ScalarCallable and the error case can be fused when source is scalar (#716)
• Some methods deprecated in M2 have been removed (see #323)
  • part of the factory methods of TopicProcessor and WorkQueueProcessor (the simpler processors have had their factory methods un-deprecated) (#471, #616)
  • untilOther, which is replaced by the more useful delayUntil (use a lambda ignoring the left-hand side if necessary) (#558)
  • zip(Function, Iterable) (#619)
• delayUntilOther has been removed (use a lambda ignoring the left-hand side instead)
• delayUntilDelayError has been removed (in flux concatMap can be used to achieve similar delayError effect; in mono, delay error doesn't really make sense)
• MonoSource and FluxSource are now package private, superseded by MonoOperator and FluxOperator.
• Scannable attributes are now regrouped back into a single generic class Attr<T>. This is a quasi-enumeration exposing constants rather than enums. (#728)
  • 🐞 LARGE_BUFFERED has a default of 0 in this version instead of null in M2, but that is a mistake that will be fixed in RC1 (see #751)
• Reactor has been updated to pass the TCK of the new Reactive Streams specification 1.0.1.RC2. A new StrictSubscriber enforces RS rules more strictly when going out of the Reactor world and bridging to an external Publisher (#711)
• ✨ Associating a Context to a reactive sequence ✨ (Flux or Mono) is now possible. This is the major new feature in this milestone. (#117, #210, #337, #447, #704, #705, #723 and various other PRs)
  • Added CoreSubscriber, a Reactor-specific Subscriber common to all Flux and Mono operators and needed to pass along the Context
  • Flux#subscribe(Subscriber) is now final, and one needs to instead implement subscribe(CoreSubscriber) in custom operators / Flux.
  • the context is enriched during the subscription phase, possibly via the contextStart operator (wich takes a Function<Context, Context>). In order to access it in the data path, the contextGet operator has been added. It takes a BiFunction<T, Context, R>, allowing to transform the data depending on the Context.
  • There is a static factory method Mono#currentContext that can be used to emit the Context initialized downstream of it (or propagated inside eg. a flatMap)
  • Context propagation and initialization is only done during the subscription phase, in reverse order of the chain of operators.

✨ New features and improvements

• Null analysis has been enabled through the use of Nullable/NonNullApi annotations (#614)
• Reduce WorkQueueProcessor/TopicProcessor sink serialization when it is not necessary (#630, #727)
• Added a distinctUntilChanged variant with a bipredicate to evaluate if there is a change (#608)
• Added a onBackpressureBuffer variant with a TTL (#296)
• Added an optional configurable default timeout on StepVerifier#verify() (#651)
• Added expect|verifyErrorSatisfies StepVerifier error expectations (#670)
• Flux now also has the delayUntil operator (#674)
• A new global hook has been added: Hooks.onNewSubscriber
• When using Mono.fromRunnable, the resulting Mono's generic type is better inferred (#686)
• Assembly tracking internals have been improved, allowing to cache assembly stacktrace notably (#712)
• Kotlin extensions for core and test are now part of the reactor-core repo and artifacts

🪲 Bug fixes

• StepVerifier now ignores empty multivalue expectations, which could previously lead to bad assertions (#650)
• Fixed a bug were macro-fusion of Flux#then and Mono#then would use arrays of incompatible types, resulting in an ArrayStoreException (#661)
• When a doOnNext callback would fail, when fused it wouldn't be caught by a doOnError (#664)
• filterWhen had a bug in tracking request and produced amount, resulting in under-requesting hangs (#689, #692)
• MonoProcessor could unnecessarily retain references to objects from its source. This is fixed by nulling out the source upon all terminations (#690)
• MonoProcessor#block() had a legacy inner timeout. It will now indefinitely wait for the actual completion. On the other hand, using a negative or 0 timeout in the Duration-based variant will now immediately time out. (#722)
• scan accumulation in a live reduction with a seed would always lag by one. It has been modified so that the seed is sent immediately, which allows the accumulator to run in lockstep with the upstream stage. (#609)
• Fixed an issue where refCnt with grace period doesn't forget subscribers when terminated, yet still reconnects. This was due to bad recycling in publish/replay. (#675)
• In Flux.create, setting an onDispose callback on the Sink after its onRequest method was called was ignored. The callback is now explicitly invoked if set after the sink was terminated. (#643)

📖 Documentation, Tests and Build

• Added tests and docs for multi-threaded producer with Processor sink, thread affinity using publishOn (#469, #521, #698)
• fix JMH IntelliJ integration: back to plugin, not imported as src scope
• Travis CI build script: only test reactor-test if all changes are in reactor-test/
• Fixed title of reactor-test javadoc + fix links to core (#644)
• Made javadoc external links slightly stand out
• Improved wording on several javadoc items and reference guide subsections

👍 Thanks to the following contributors that also participated to this release

@IlyaZinkovich, @markotron, @osi, @rajinisivaram, @sdeleuze

v3.1.0.M2

This is the MILESTONE 2 release of Reactor 3.1.0, which will be part of the Bismuth Release Train.

This MILESTONE covers API changes of the upcoming 3.1.0 release, as well as improvements.

Note that starting from this pre-release, the source code for the reactor-test artifact is part of the reactor-core github repository.

Most deprecations introduced in this pre-release should be followed by a removal in the next pre-release (or GA if no M3 happens).

⚠️ Update considerations and API changes

• Mono#subscribe() returns a Disposable. Use .toProcessor() to get the exact legacy behavior (see #566, #605 and #638)
• Flux.windowTimeOrSize: the timeout now starts right from subscription, resulting in potentially empty windows being emitted. It also restarts if the
  timeout expires, so there could be several empty windows emitted eg. 3 for a timeout of 100ms if the Flux doesn't emit for 300ms.
  The equivalent buffer version remains unchanged. (#484)
• reactor-test source code is now part of this repository, and the artifact has changed Maven groupId to io.projectreactor
• Mono#untilOther removed (use delayUntilOther(other.take(1)) instead, see #558)
• Most factory methods of Processors are deprecated in favor of Builder (see #471, #616 and #628)
• Scannable: attributes are now split into typed categories (eg. BooleanAttr) so that scan doesn't need a Class to attempt a cast. Operator implementation is still based on a Object scan, scanUnsafe. Some operators mapped some attributes to a value of incoherent type, which has been modified to fit the category of said attributes (see #606).
• Mono#zip with an iterable: for consistency, swap the arguments (old "function, iterable" version is deprecated, see #619)

✨ New features and improvements

• the checkpoint description is included inFlux/MonoSource#toString (#611)
• checkpoint(String) is now light by default, lowering the cost of using that operator (see #587)
• the Supplier used for distinct can be tuned (#577)
• refCount now has a variant that waits for a grace period before unsubscribing from upstream (#569, #624, #627)

🪲 Bug fixes

• a memory leak has been fixed in SingleScheduler.schedule (#578)

📖 Documentation, Tests and Build

• some operators' usage restrictions have been better documented in the javadoc (#560,#596)
• the reference guide's introduction to reactive programming shows an example of Future and Callback Hell, vs Reactor (#580)

👍 Thanks to the following contributors that also participated to this release

In alphabetical order:

@akarnokd, @Dmitriusan, @fabriziofortino, @jimhorng, @kamilszymanski, @making, @rajinisivaram, @TomekJurkowski