- As a bad behaviour we relied on reactor throwing
this particular exception to re-throw it to propagate
exception order to deny event.
- Now trying to use callback to do a same thing as
newer reactor versions don't throw anymore.
- Original preStateChange and postStateChange are now deprecated
and once those are removed we don't need to do calls to both
in StateMachineInterceptorList.
- Relates to #871
- As it's currently expected that pre/post interceptor are called
for both preStateChange and postStateChange, fix
AbstractPersistingStateMachineInterceptor so that actual persist
doesn't happen twice.
- Eventually original preStateChange and postStateChange methods
will get removed after deprecation(which should have happened
a long time ago).
- Forward port #871
- Before attempting to add better level of error handling,
discard all errors what might come from action execution.
- Handle some cases where event deny is reported back as accepted.
- Fix reactor error for double subcription.
- Relates #821
- Now starting machine outside of a sycn block with
acquire vs. release. This should allow long running
start in a machine to allow next acquire to work faster.
- Forwardport #770
- Relates #777
- For Guard and Transition change call stach to be fully
reactive from executor. Some changed signatures similarly
what was needed for reactive Actions.
- Disabling one smoke test to get figure out later as
something is broken somewhere, possible reactor bug...
- Relates #791
- First changes to introduce ReactiveGuard similar to work done
for ReactiveAction. User level interface is ReactiveGuard but internally
it is handled as its super type Function<StateContext<S, E>, Mono<Boolean>>.
- This change still keeps some calls as blocking which will get changed
in futher commits to get a full reactive chain.
- Touching only Transition to change guard signature, other use of blocking guard
internally need to get similar changes in next commits.
- Baby steps...
- Relates #791
- remove junit4 dependecies
- refactor the unit tests by junit5
- enhance the spring-statemachine-test and spring-statemachine-build-tests so they can work together with junit4/junit5
- relates #779
- Polish previous change to AbstractState by using a shared function
completionStateListenerSink to track completion sink as functionality
between entries to submachine/regions should be similar.
- Mostly relates to #743
- This commit changes a way how triggerless transitions are executed by
going via new doOnComplete method in StateListener which returns
Mono<Void>. This used to be a simple fire and forget subscribe via listener
and now fully handled via reactive chain when state is complete. Rest of
a changes are to tweak state actions to run parallel to be able to cancel
those and then follow and track when triggerless transitions need to be
executed.
- AbstractState still have some work to do for disposing things around
submachines which currently seem to break thins if handleStateDoOnComplete
is disposed when submachine state is exited. We'll leave this to get
fixed later.
- Add tag handling for junit5 which can be set via gradle build properties
statemachineIncludeTags and statemachineExcludeTags.
- Add BlockHound to build which can be activated via gradle build
property statemachineBlockHound.
- Add org.awaitility:awaitility to various test deps.
- Mostly relates to #734
- Move to use reactive methods and for now block
as concept is really blocking. Full reactive stuff
needs bigger overhaul.
- Fix event issues in DistributedStateMachine as these
caused issues when StateMachineTestPlan were changed to
send events via reactive methods.
- Relates #744
- Relates #750
- Remove use of statemachine assertj assertions to prepare move
- Move statemachine assertj assertion to spring-statemachine-test
- Polish some tests and user TestUtils from core tests
- Remove most of a deprecation warning from core tests
- Relates #744
- Add stateDoFunction, stateEntryFunction and stateExitFunction methods
taking Function with a state to register reactive actions.
- Don't yet to a full take on all similar action methods as we need
to think about how these should be named and what old methods to
depecate.
- Relates #743
- This first commit related to reactive action support basically changes internal
logic away from original Action interface which really is just
a Consumer<StateContext> but it originates pre jdk8 era.
Reactive equivalent internally is now Function<StateContext<S, E>, Mono<Void>>.
- Essentially actions will now get executed with a reactor chain fully.
- Fix StateMachineExecutorTransit in AbstractStateMachine to be full reactive
chain which were needed to get reactive actions working. This also put
StateContextTests back to its original state.
- Add typesafe interface ReactiveAction which simply wraps
Function<StateContext<S, E>, Mono<Void>> and add this to transitions with
actionFunction() as a concept. This will be added to states in next
commits if actionFunction() as a concept works.
- Polish various things and issues which were not addressed with initial reactive commit.
- Disable ActionSecurityTests for now as secured Action bean now breaks because it's
internally wrapped into a Function and Spring Security doesn't see it anymore.
Security like this needs a bit of a overhaul which can be done later.
- State do actions which are done via scheduling needs some work as now we just do
a subscribe which is probably a bit wrong. There's going to be more work for
scheduling so this also can be left later stages.
- Relates #743
