Hierarchical states are not being persisted in the database - spring-statemachine

Question

I am struggling to get the correct state of the hierarchical state machine from the database after persisting it.The parent machine has two states ("IN_ANALYSIS", "OPEN") and the IN_ANALYSIS state has substates("IN_PROGRESS","PENDING_SIGNOFF","PENDING_SIGNOFF2","COMPLETED").
#Override
public void configure(StateMachineStateConfigurer<States, Events> states)
throws Exception {
states
.withStates()
.initial(States.IN_ANALYSIS)
.state(States.IN_ANALYSIS)
.state(States.OPEN)
.and()
.withStates()
.parent(States.IN_ANALYSIS)
.initial(States.IN_PROGRESS)
.state(States.IN_PROGRESS)
.state(States.PENDING_SIGNOFF)
.state(States.PENDING_SIGNOFF2)
.state(States.COMPLETED,closedEntryAction(), null);
}
Whenever I leave the state machine on one of the intermediate sub-states like(PENDING_SIGNOFF, PENDING_SIGNOFF2) and later fetch it again from the database than the sub-states gets reset to the initial state (IN_PROGRESS).
I am using JPA persistance provided by the spring state machine framework
#Configuration
#Profile("jpa")
public static class JpaPersisterConfig {
#Bean
public StateMachineRuntimePersister<States, Events, String> stateMachineRuntimePersister(
JpaStateMachineRepository jpaStateMachineRepository) {
return new JpaPersistingStateMachineInterceptor<>(jpaStateMachineRepository);
}
}
and using "DefaultStateMachineService"
#Configuration
public static class ServiceConfig {
#Bean
public StateMachineService<States, Events> stateMachineService(
StateMachineFactory<States, Events> stateMachineFactory,
StateMachineRuntimePersister<States, Events, String> stateMachineRuntimePersister) {
return new DefaultStateMachineService<States, Events>(stateMachineFactory, stateMachineRuntimePersister);
}
}

Answer 1

It seems Spring saves hierarchical states as a different state machine context as it described in Data Multi Persist example.
Try to configure regions by marking nested states as a region and setting region id. And then you can request state machine by id and region id
StateMachine<States, Events> sm = defaultStateMachineService.acquireStateMachine(stateMachineId + "#" + regionId)

Answer 2

The problem is in the DefaultStateMachineService class, during acquiring SM the service creates a new SM and the JpaPersistingStateMachineInterceptor persists the new SM with an initial state, then the DefaultStateMachineService reads state from DB (the state is already overridden) and calls restoreStateMachine method with the overridden state. So, to fix this issue You have to create your own StateMachineService implementation.
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.Lifecycle;
import org.springframework.statemachine.StateMachine;
import org.springframework.statemachine.StateMachineContext;
import org.springframework.statemachine.StateMachineException;
import org.springframework.statemachine.StateMachinePersist;
import org.springframework.statemachine.access.StateMachineAccess;
import org.springframework.statemachine.access.StateMachineFunction;
import org.springframework.statemachine.config.StateMachineFactory;
import org.springframework.statemachine.listener.StateMachineListenerAdapter;
import org.springframework.statemachine.service.DefaultStateMachineService;
import org.springframework.statemachine.service.StateMachineService;
import org.springframework.util.Assert;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import static java.util.Objects.isNull;
import static java.util.Objects.nonNull;
public class PrimeStateMachineService<S, E> implements StateMachineService<S, E>, DisposableBean {
private final static Log log = LogFactory.getLog(DefaultStateMachineService.class);
private final StateMachineFactory<S, E> stateMachineFactory;
private final Map<String, StateMachine<S, E>> machines = new HashMap<String, StateMachine<S, E>>();
private StateMachinePersist<S, E, String> stateMachinePersist;
/**
* Instantiates a new default state machine service.
*
* #param stateMachineFactory the state machine factory
*/
public PrimeStateMachineService(StateMachineFactory<S, E> stateMachineFactory) {
this(stateMachineFactory, null);
}
/**
* Instantiates a new default state machine service.
*
* #param stateMachineFactory the state machine factory
* #param stateMachinePersist the state machine persist
*/
public PrimeStateMachineService(StateMachineFactory<S, E> stateMachineFactory,
StateMachinePersist<S, E, String> stateMachinePersist) {
Assert.notNull(stateMachineFactory, "'stateMachineFactory' must be set");
this.stateMachineFactory = stateMachineFactory;
this.stateMachinePersist = stateMachinePersist;
}
#Override
public final void destroy() throws Exception {
doStop();
}
#Override
public StateMachine<S, E> acquireStateMachine(String machineId) {
return acquireStateMachine(machineId, true);
}
#Override
public StateMachine<S, E> acquireStateMachine(String machineId, boolean start) {
log.info("Acquiring machine with id " + machineId);
StateMachine<S, E> stateMachine;
synchronized (machines) {
stateMachine = machines.get(machineId);
if (isNull(stateMachine)) {
if (nonNull(stateMachinePersist)) {
try {
StateMachineContext<S, E> stateMachineContext = stateMachinePersist.read(machineId);
if (isNull(stateMachineContext)) {
stateMachine = stateMachineFactory.getStateMachine(machineId);
log.info("Getting new machine from factory with id " + machineId);
} else {
stateMachine = restoreStateMachine(stateMachineFactory.getStateMachine(machineId), stateMachineContext);
log.info("State machine restored from repository with id " + machineId);
}
} catch (Exception e) {
log.error("Error handling context", e);
throw new StateMachineException("Unable to read context from store", e);
}
}
machines.put(machineId, stateMachine);
}
}
return handleStart(stateMachine, start);
}
#Override
public void releaseStateMachine(String machineId) {
log.info("Releasing machine with id " + machineId);
synchronized (machines) {
StateMachine<S, E> stateMachine = machines.remove(machineId);
if (stateMachine != null) {
log.info("Found machine with id " + machineId);
stateMachine.stop();
}
}
}
#Override
public void releaseStateMachine(String machineId, boolean stop) {
log.info("Releasing machine with id " + machineId);
synchronized (machines) {
StateMachine<S, E> stateMachine = machines.remove(machineId);
if (stateMachine != null) {
log.info("Found machine with id " + machineId);
handleStop(stateMachine, stop);
}
}
}
/**
* Determines if the given machine identifier denotes a known managed state machine.
*
* #param machineId machine identifier
* #return true if machineId denotes a known managed state machine currently in memory
*/
public boolean hasStateMachine(String machineId) {
synchronized (machines) {
return machines.containsKey(machineId);
}
}
/**
* Sets the state machine persist.
*
* #param stateMachinePersist the state machine persist
*/
public void setStateMachinePersist(StateMachinePersist<S, E, String> stateMachinePersist) {
this.stateMachinePersist = stateMachinePersist;
}
protected void doStop() {
log.info("Entering stop sequence, stopping all managed machines");
synchronized (machines) {
ArrayList<String> machineIds = new ArrayList<>(machines.keySet());
for (String machineId : machineIds) {
releaseStateMachine(machineId, true);
}
}
}
protected StateMachine<S, E> restoreStateMachine(StateMachine<S, E> stateMachine, final StateMachineContext<S, E> stateMachineContext) {
if (stateMachineContext == null) {
return stateMachine;
}
stateMachine.stop();
stateMachine
.getStateMachineAccessor()
.doWithAllRegions(function -> function.resetStateMachine(stateMachineContext));
return stateMachine;
}
protected StateMachine<S, E> handleStart(StateMachine<S, E> stateMachine, boolean start) {
if (start) {
if (!((Lifecycle) stateMachine).isRunning()) {
PrimeStateMachineService.StartListener<S, E> listener = new PrimeStateMachineService.StartListener<>(stateMachine);
stateMachine.addStateListener(listener);
stateMachine.start();
try {
listener.latch.await();
} catch (InterruptedException e) {
}
}
}
return stateMachine;
}
protected StateMachine<S, E> handleStop(StateMachine<S, E> stateMachine, boolean stop) {
if (stop) {
if (((Lifecycle) stateMachine).isRunning()) {
PrimeStateMachineService.StopListener<S, E> listener = new PrimeStateMachineService.StopListener<>(stateMachine);
stateMachine.addStateListener(listener);
stateMachine.stop();
try {
listener.latch.await();
} catch (InterruptedException e) {
}
}
}
return stateMachine;
}
private static class StartListener<S, E> extends StateMachineListenerAdapter<S, E> {
final CountDownLatch latch = new CountDownLatch(1);
final StateMachine<S, E> stateMachine;
public StartListener(StateMachine<S, E> stateMachine) {
this.stateMachine = stateMachine;
}
#Override
public void stateMachineStarted(StateMachine<S, E> stateMachine) {
this.stateMachine.removeStateListener(this);
latch.countDown();
}
}
private static class StopListener<S, E> extends StateMachineListenerAdapter<S, E> {
final CountDownLatch latch = new CountDownLatch(1);
final StateMachine<S, E> stateMachine;
public StopListener(StateMachine<S, E> stateMachine) {
this.stateMachine = stateMachine;
}
#Override
public void stateMachineStopped(StateMachine<S, E> stateMachine) {
this.stateMachine.removeStateListener(this);
latch.countDown();
}
}
}

Answer 3

I had the same problem in my functional testing context. The takeway was to create and seed desired state machines in memory via service (without releasing it) and run the tests end to end. This way, the service did not submit for persistence, which was causing the state rollback to the initial state
public static StateMachine restoreMachine(final StateMachine<States, Events> stateMachine,
final States currentState, final ExtendedState extendedState) {
stateMachine.getStateMachineAccessor().doWithAllRegions(t ->
t.resetStateMachine(
new DefaultStateMachineContext<>(currentState, Events.ANY_DESIRED_STATE, null, extendedState, null, "your-machine-id")));
return stateMachine;
}