How to start persisted state-machines on application startup?

[maseev]

I've got a state-machine factory configuration with MongoDB persistence and states which use TimerTrigger (timer method) to periodically poll information from external services.

Is it possible to start all the persisted state-machine instances on the application startup and run them from the last state?
In other words, I expect that the state-machines are going to run the TimerTrigger states via the ThreadPoolScheduler automatically upon application startup.

Right now, it's not clear how to achieve this with StateMachineService or StateMachineRuntimePersister.
If I'm not mistaken, @EnableStateMachine annotation is only applicable to a single state-machine instance per application and doesn't stack with @EnableStateMachineFactory.

[jvalkeal]

It might not be a bad idea to setup some sort of a "automatic" service system which would restore machines with some given "rules". It's true that once instance goes away, any persisted machine is dead there in a store until somebody tries to use it. Do you have ideas what those "rules" might be? Maybe last update time(if we'd add fields for it) or generally something else what you could use to choose which machines to restore/start automatically.

[maseev]

I can think of only one rule at the moment. It's whether the state machine reached the "terminal" state or not. This "terminal" state could be a couple of things:

• the state machine reached the end state
• the state machine has been stopped

In other words, I expect that the state machine is going to be restored and run from the last persisted state on the application startup unless it reached this terminal state.

I think it's also worth mentioning that my particular configuration of the state machine is more like a workflow engine type.
Meaning, the state machine sends events to itself to move to another state.
All events but the first one are internal and are sent from the state machine actions which implement some business logic and then decide where to move the state machine by sending a particular event.

Here's a simple example which demonstrates my current approach with Spring Statemachine:

states
    .withStates()
    .initial(State.ORDER)
    .end(State.DELIVERED)
    .states(setOf(*State.values()))
    .state(State.REQUEST) { context ->
        context.stateMachine.sendEvent(Event.REQUEST_GOODS)
    }

override fun configure(transitions: StateMachineTransitionConfigurer<State, Event>) {
    transitions
        .withExternal()
        .source(State.ORDER)
        .target(State.REQUEST)
        .event(Event.CHECKED)

        .and()
        .withInternal()
        .source(State.ORDER)
        .event(Event.CHECK)
        .action(checkAction(), errorHandlerAction())
        .timer(TimeUnit.MINUTES.toMillis(retryTimeout))

        .and()
        .withExternal()
        .source(State.REQUEST)
        .target(State.DELIVERED)
        .event(Event.REQUESTED)

        .and()
        .withInternal()
        .source(State.REQUEST)
        .event(Event.REQUEST_GOODS)
        .action(requestGoodsAction(), errorHandlerAction())
        .timer(TimeUnit.MINUTES.toMillis(retryTimeout))
        // ...
}

override fun execute(context: StateContext<State, Event>) {
  // ...
  context.stateMachine.sendEvent(CHECKED)
}

So the pipeline is the following:

• A client acquires a state-machine and sends the CHECK event
• The state-machine receives the CHECK event and starts the checkAction
• The checkAction does some work and then sends the CHECKED event which moves the state-machine from the ORDER to the REQUEST state
• This triggers the following portion of the code which sends the REQUEST_GOODS event:

    .state(State.REQUEST) { context ->
        context.stateMachine.sendEvent(Event.REQUEST_GOODS)
    }

• By receiving the REQUEST_GOODS event state-machine starts the requestGoodsAction which does some work and sends the REQUESTED event which moves the state-machine to the end-state.

Any of the steps mentioned above can be interrupted due to JVM crash/restart. It would be very handy if Spring Statemachine could provide some sort of service that would restore all persisted state-machines and run them from the last persisted state. If the last state contains a scheduled action - the state-machine runs it. If a particular state should trigger an event - it should trigger it automatically.

[srdjan-bestic-cif]

@maseev
Is the feature implemented, and if it is could you be so kind to point me to it?

[maseev]

@srdjan-bestic-cif I ended up creating a separate class with a @Scheduled method which periodically queries the state machines with MongoDbStateMachineRepository, reads their context with StateMachineRuntimePersister and basically resends the events which eventually trigger the state machines to start from the last step.

[srdjan-bestic-cif]

Thanks for a swift reply, I had the same workaround in mind except it gets trickier in a distributed environment.
I wouldn't close the task as your idea of non-terminating state auto resuming seems great and is something that would be a really nice addition to state machine project.

[maseev]

You can use shedlock if you have a distributed environment and don't want to start more than one instance of your state machine per service. In our case, we use shedlock + redis.

[satyasandipan]

Hello @maseev

I have similar requirement. It would really great - if you can help with sharing your sample repo to achieve using shedlock + redis .

[satyasandipan]

HI @jvalkeal

can you point me on spring statemachine on how to achieve - some sort of service that would restore all persisted state-machines (may be redis ) and run them from the last persisted state.

Thanks