Example usage for org.springframework.statemachine StateMachine getExtendedState

Introduction

In this page you can find the example usage for org.springframework.statemachine StateMachine getExtendedState.

Prototype

ExtendedState getExtendedState();

Source Link

Document

Gets the state machine extended state.

Usage

From source file:demo.web.StateMachineController.java

@PostConstruct
public void setup() {

    stateMachine.addStateListener(new StateMachineListenerAdapter<States, Events>() {
        @Override/*w w  w  . j  ava2  s .com*/
        public void stateEntered(State<States, Events> state) {
            StateMachineMessage message = new StateMachineMessage();
            message.setMessage("Enter state " + state.getId().toString());
            simpMessagingTemplate.convertAndSend("/topic/sm.message", message);
        }

        @Override
        public void stateExited(State<States, Events> state) {
            StateMachineMessage message = new StateMachineMessage();
            message.setMessage("Exit state " + state.getId().toString());
            simpMessagingTemplate.convertAndSend("/topic/sm.message", message);
        }

        @Override
        public void stateChanged(State<States, Events> from, State<States, Events> to) {
            Map<Object, Object> variables = stateMachine.getExtendedState().getVariables();
            ArrayList<StateMachineEvent> list = new ArrayList<StateMachineEvent>();
            for (States state : stateMachine.getState().getIds()) {
                list.add(new StateMachineEvent(state.toString()));
            }
            simpMessagingTemplate.convertAndSend("/topic/sm.states", list);
            simpMessagingTemplate.convertAndSend("/topic/sm.variables", variables);
        }

        @Override
        public void transitionEnded(Transition<States, Events> transition) {
            if (transition != null && transition.getKind() == TransitionKind.INTERNAL) {
                Map<Object, Object> variables = stateMachine.getExtendedState().getVariables();
                simpMessagingTemplate.convertAndSend("/topic/sm.variables", variables);
            }
        }

        @Override
        public void stateMachineError(StateMachine<States, Events> stateMachine, Exception exception) {
            handleStateMachineError(new StateMachineException("Received error from machine", exception));
        }

    });

    stateMachineEnsemble.addEnsembleListener(new EnsembleListenerAdapter<States, Events>() {

        @Override
        public void ensembleLeaderGranted(StateMachine<States, Events> stateMachine) {
            StateMachineMessage message = new StateMachineMessage();
            message.setMessage("Leader granted " + stateMachine.getUuid().toString());
            simpMessagingTemplate.convertAndSend("/topic/sm.message", message);
        }

        @Override
        public void ensembleLeaderRevoked(StateMachine<States, Events> stateMachine) {
            StateMachineMessage message = new StateMachineMessage();
            message.setMessage("Leader revoked " + stateMachine.getUuid().toString());
            simpMessagingTemplate.convertAndSend("/topic/sm.message", message);
        }
    });
}

---

From source file:org.springframework.statemachine.recipes.TasksHandlerTests.java

@Test
public void testRunOnceSimpleNoFailures() throws InterruptedException {
    TasksHandler handler = TasksHandler.builder().task("1", sleepRunnable()).task("2", sleepRunnable())
            .task("3", sleepRunnable()).build();

    TestListener listener = new TestListener();
    listener.reset(9, 0, 0);/*from ww  w.  java  2  s .c  o  m*/
    StateMachine<String, String> machine = handler.getStateMachine();
    machine.addStateListener(listener);
    machine.start();
    assertThat(listener.stateMachineStartedLatch.await(1, TimeUnit.SECONDS), is(true));

    handler.runTasks();

    assertThat(listener.stateChangedLatch.await(8, TimeUnit.SECONDS), is(true));
    assertThat(listener.stateChangedCount, is(9));
    assertThat(machine.getState().getIds(), contains(TasksHandler.STATE_READY));
    Map<Object, Object> variables = machine.getExtendedState().getVariables();
    assertThat(variables.size(), is(3));
}

---

From source file:org.springframework.statemachine.recipes.TasksHandlerTests.java

@Test
public void testRunFail() throws InterruptedException {
    TasksHandler handler = TasksHandler.builder().task("1", sleepRunnable()).task("2", sleepRunnable())
            .task("3", failRunnable()).build();

    TestListener listener = new TestListener();
    listener.reset(11, 0, 0);//from w w w.  java2  s  .  co  m
    StateMachine<String, String> machine = handler.getStateMachine();
    machine.addStateListener(listener);
    machine.start();
    assertThat(listener.stateMachineStartedLatch.await(1, TimeUnit.SECONDS), is(true));

    handler.runTasks();

    assertThat(listener.stateChangedLatch.await(8, TimeUnit.SECONDS), is(true));
    assertThat(listener.stateChangedCount, is(11));
    assertThat(machine.getState().getIds(), contains(TasksHandler.STATE_ERROR, TasksHandler.STATE_MANUAL));
    Map<Object, Object> variables = machine.getExtendedState().getVariables();
    assertThat(variables.size(), is(3));
}

---

From source file:org.springframework.statemachine.recipes.TasksHandlerTests.java

@Test
public void testDagSingleRoot() throws InterruptedException {
    TasksHandler handler = TasksHandler.builder().task("1", sleepRunnable()).task("1", "12", sleepRunnable())
            .task("1", "13", sleepRunnable()).build();

    TestListener listener = new TestListener();
    listener.reset(9, 0, 0);//from ww w. ja  va  2 s  . co  m
    StateMachine<String, String> machine = handler.getStateMachine();
    machine.addStateListener(listener);
    machine.start();
    assertThat(listener.stateMachineStartedLatch.await(1, TimeUnit.SECONDS), is(true));

    handler.runTasks();

    assertThat(listener.stateChangedLatch.await(12, TimeUnit.SECONDS), is(true));
    assertThat(listener.stateChangedCount, is(9));
    assertThat(machine.getState().getIds(), contains(TasksHandler.STATE_READY));
    Map<Object, Object> variables = machine.getExtendedState().getVariables();
    assertThat(variables.size(), is(3));
}

---

From source file:org.springframework.statemachine.recipes.TasksHandlerTests.java

@Test
public void testDagMultiRoot() throws InterruptedException {
    TasksHandler handler = TasksHandler.builder().task("1", sleepRunnable()).task("1", "12", sleepRunnable())
            .task("1", "13", sleepRunnable()).task("2", sleepRunnable()).task("2", "22", sleepRunnable())
            .task("2", "23", sleepRunnable()).task("3", sleepRunnable()).task("3", "32", sleepRunnable())
            .task("3", "33", sleepRunnable()).build();

    TestListener listener = new TestListener();
    StateMachine<String, String> machine = handler.getStateMachine();

    machine.addStateListener(listener);//from   w w w  .  jav  a  2s  .c  o m
    listener.reset(1, 0, 0);
    machine.start();
    assertThat(listener.stateMachineStartedLatch.await(1, TimeUnit.SECONDS), is(true));
    assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
    assertThat(listener.stateChangedCount, is(1));

    listener.reset(20, 0, 0);
    handler.runTasks();

    assertThat(listener.stateChangedLatch.await(10, TimeUnit.SECONDS), is(true));
    assertThat(listener.stateChangedCount, is(20));
    assertThat(machine.getState().getIds(), contains(TasksHandler.STATE_READY));
    Map<Object, Object> variables = machine.getExtendedState().getVariables();
    assertThat(variables.size(), is(9));
}

---

From source file:org.springframework.statemachine.recipes.TasksHandlerTests.java

@Test
public void testPersist1() throws InterruptedException {
    TestStateMachinePersist persist = new TestStateMachinePersist();
    TasksHandler handler = TasksHandler.builder().task("1", sleepRunnable()).task("2", sleepRunnable())
            .task("3", sleepRunnable()).persist(persist).build();

    TestListener listener = new TestListener();
    listener.reset(9, 0, 0);//from   w  ww  .  j  a v a 2  s . c  om
    StateMachine<String, String> machine = handler.getStateMachine();
    machine.addStateListener(listener);
    machine.start();
    assertThat(listener.stateMachineStartedLatch.await(1, TimeUnit.SECONDS), is(true));

    persist.reset(5);

    handler.runTasks();

    assertThat(listener.stateChangedLatch.await(8, TimeUnit.SECONDS), is(true));
    assertThat(listener.stateChangedCount, is(9));
    assertThat(machine.getState().getIds(), contains(TasksHandler.STATE_READY));
    Map<Object, Object> variables = machine.getExtendedState().getVariables();
    assertThat(variables.size(), is(3));

    assertThat(persist.writeLatch.await(4, TimeUnit.SECONDS), is(true));
    assertThat(persist.contexts.size(), is(5));

    for (StateMachineContext<String, String> context : persist.getContexts()) {
        if (context.getState() == "TASKS") {
            assertThat(context.getChilds().size(), is(3));
        } else {
            assertThat(context.getChilds().size(), is(0));
        }
    }
}

---

From source file:org.springframework.statemachine.recipes.TasksHandlerTests.java

@Test
public void testPersist2() throws InterruptedException {
    TestStateMachinePersist persist = new TestStateMachinePersist();
    TasksHandler handler = TasksHandler.builder().task("1", sleepRunnable()).task("2", sleepRunnable())
            .task("3", failRunnable()).persist(persist).build();

    TestListener listener = new TestListener();
    listener.reset(11, 0, 0);/*from   w w w  .ja v  a  2s.  c  om*/
    StateMachine<String, String> machine = handler.getStateMachine();
    machine.addStateListener(listener);
    machine.start();
    assertThat(listener.stateMachineStartedLatch.await(1, TimeUnit.SECONDS), is(true));

    persist.reset(6);

    handler.runTasks();

    assertThat(listener.stateChangedLatch.await(8, TimeUnit.SECONDS), is(true));
    assertThat(listener.stateChangedCount, is(11));
    assertThat(machine.getState().getIds(), contains(TasksHandler.STATE_ERROR, TasksHandler.STATE_MANUAL));
    Map<Object, Object> variables = machine.getExtendedState().getVariables();
    assertThat(variables.size(), is(3));

    assertThat(persist.writeLatch.await(4, TimeUnit.SECONDS), is(true));
    assertThat(persist.contexts.size(), is(6));

    for (StateMachineContext<String, String> context : persist.getContexts()) {
        if (context.getState() == "TASKS") {
            assertThat(context.getChilds().size(), is(3));
        } else if (context.getState() == "ERROR") {
            assertThat(context.getChilds().size(), is(1));
        } else {
            assertThat(context.getChilds().size(), is(0));
        }
    }
}

---

From source file:org.springframework.statemachine.support.DefaultStateMachineExecutor.java

private StateContext<S, E> buildStateContext(Message<E> message, Transition<S, E> transition,
        StateMachine<S, E> stateMachine) {
    // TODO: maybe a direct use of MessageHeaders is wring, combine
    //       payload and headers as a message?

    // add sm id to headers so that user of a StateContext can
    // see who initiated this transition
    MessageHeaders messageHeaders = message != null ? message.getHeaders()
            : new MessageHeaders(new HashMap<String, Object>());
    Map<String, Object> map = new HashMap<String, Object>(messageHeaders);
    if (!map.containsKey(StateMachineSystemConstants.STATEMACHINE_IDENTIFIER)) {
        // don't set sm id if it's already present because
        // we want to keep the originating sm id
        map.put(StateMachineSystemConstants.STATEMACHINE_IDENTIFIER, stateMachine.getUuid());
    }//  www  . jav a2 s  . co  m
    return new DefaultStateContext<S, E>(Stage.TRANSITION, message, new MessageHeaders(map),
            stateMachine.getExtendedState(), transition, stateMachine, null, null, null);
}

---

From source file:org.springframework.statemachine.test.StateMachineTestPlan.java

/**
 * Run test plan./*from  w w w .jav  a2 s.  c o  m*/
 *
 * @throws Exception the exception
 */
public void test() throws Exception {

    Map<StateMachine<S, E>, LatchStateMachineListener<S, E>> listeners = new HashMap<StateMachine<S, E>, LatchStateMachineListener<S, E>>();
    for (StateMachine<S, E> stateMachine : stateMachines.values()) {
        LatchStateMachineListener<S, E> listener = new LatchStateMachineListener<S, E>();
        listeners.put(stateMachine, listener);
        stateMachine.addStateListener(listener);
    }
    log.info("Running test plan for machines "
            + StringUtils.collectionToCommaDelimitedString(stateMachines.values()));

    int stepCounter = 0;
    for (StateMachineTestPlanStep<S, E> step : steps) {
        log.info("Running test plan step " + stepCounter++);
        for (LatchStateMachineListener<S, E> listener : listeners.values()) {
            listener.reset(step.expectStateChanged != null ? step.expectStateChanged : 0,
                    step.expectStateEntered != null ? step.expectStateEntered : 0,
                    step.expectStateExited != null ? step.expectStateExited : 0,
                    step.expectEventNotAccepted != null ? step.expectEventNotAccepted : 0,
                    step.expectTransition != null ? step.expectTransition : 0,
                    step.expectTransitionStarted != null ? step.expectTransitionStarted : 0,
                    step.expectTransitionEnded != null ? step.expectTransitionEnded : 0,
                    step.expectStateMachineStarted != null ? step.expectStateMachineStarted : 0,
                    step.expectStateMachineStopped != null ? step.expectStateMachineStopped : 0,
                    step.expectExtendedStateChanged != null ? step.expectExtendedStateChanged : 0);
        }

        // need to call start here, ok to call from all steps
        for (StateMachine<S, E> stateMachine : stateMachines.values()) {
            stateMachine.start();
        }

        if (step.expectStateMachineStarted != null) {
            for (Entry<StateMachine<S, E>, LatchStateMachineListener<S, E>> entry : listeners.entrySet()) {
                assertThat(
                        "StateMachineStarted Await not matched for machine " + entry.getKey(), entry.getValue()
                                .getStateMachineStartedLatch().await(defaultAwaitTime, TimeUnit.SECONDS),
                        is(true));
                assertThat("StateMachineStarted count not matched for machine " + entry.getKey(),
                        entry.getValue().getStateMachineStarted().size(), is(step.expectStateMachineStarted));
            }
        }

        if (!step.sendEvent.isEmpty()) {
            ArrayList<StateMachine<S, E>> sendVia = new ArrayList<StateMachine<S, E>>();
            if (step.sendEventMachineId != null) {
                sendVia.add(stateMachines.get(step.sendEventMachineId));
            } else if (step.sendEventToAll) {
                sendVia.addAll(stateMachines.values());
            } else {
                sendVia.add(stateMachines.values().iterator().next());
            }
            assertThat("Error finding machine to send via", sendVia, not(empty()));
            if (!step.sendEventParallel) {
                for (StateMachine<S, E> machine : sendVia) {
                    for (E event : step.sendEvent) {
                        log.info("Sending test event " + event + " via machine " + machine);
                        machine.sendEvent(event);
                    }
                }
            } else {
                for (E event : step.sendEvent) {
                    sendEventParallel(sendVia, event);
                }
            }
        } else if (!step.sendMessage.isEmpty()) {
            ArrayList<StateMachine<S, E>> sendVia = new ArrayList<StateMachine<S, E>>();
            if (step.sendEventMachineId != null) {
                sendVia.add(stateMachines.get(step.sendEventMachineId));
            } else if (step.sendEventToAll) {
                sendVia.addAll(stateMachines.values());
            } else {
                sendVia.add(stateMachines.values().iterator().next());
            }
            assertThat("Error finding machine to send via", sendVia, not(empty()));
            for (StateMachine<S, E> machine : sendVia) {
                for (Message<E> event : step.sendMessage) {
                    log.info("Sending test event " + event + " via machine " + machine);
                    machine.sendEvent(event);
                }
            }
        }

        if (step.expectStateChanged != null) {
            for (Entry<StateMachine<S, E>, LatchStateMachineListener<S, E>> entry : listeners.entrySet()) {
                assertThat("StateChanged Await not matched for machine " + entry.getKey(),
                        entry.getValue().getStateChangedLatch().await(defaultAwaitTime, TimeUnit.SECONDS),
                        is(true));
                assertThat("StateChanged count not matched for machine " + entry.getKey(),
                        entry.getValue().getStateChanged().size(), is(step.expectStateChanged));
            }
        }

        if (step.expectStateEntered != null) {
            for (LatchStateMachineListener<S, E> listener : listeners.values()) {
                assertThat(listener.getStateEnteredLatch().await(defaultAwaitTime, TimeUnit.SECONDS), is(true));
                assertThat(listener.getStateEntered().size(), is(step.expectStateEntered));
            }
        }

        if (step.expectStateExited != null) {
            for (LatchStateMachineListener<S, E> listener : listeners.values()) {
                assertThat(listener.getStateExitedLatch().await(defaultAwaitTime, TimeUnit.SECONDS), is(true));
                assertThat(listener.getStateExited().size(), is(step.expectStateExited));
            }
        }

        if (step.expectEventNotAccepted != null) {
            for (LatchStateMachineListener<S, E> listener : listeners.values()) {
                assertThat(listener.getEventNotAcceptedLatch().await(defaultAwaitTime, TimeUnit.SECONDS),
                        is(true));
                assertThat(listener.getEventNotAccepted().size(), is(step.expectEventNotAccepted));
            }
        }

        if (step.expectTransition != null) {
            for (LatchStateMachineListener<S, E> listener : listeners.values()) {
                assertThat(listener.getTransitionLatch().await(defaultAwaitTime, TimeUnit.SECONDS), is(true));
                assertThat(listener.getTransition().size(), is(step.expectTransition));
            }
        }

        if (step.expectTransitionStarted != null) {
            for (LatchStateMachineListener<S, E> listener : listeners.values()) {
                assertThat(listener.getTransitionStartedLatch().await(defaultAwaitTime, TimeUnit.SECONDS),
                        is(true));
                assertThat(listener.getTransitionStarted().size(), is(step.expectTransitionStarted));
            }
        }

        if (step.expectTransitionEnded != null) {
            for (LatchStateMachineListener<S, E> listener : listeners.values()) {
                assertThat(listener.getTransitionEndedLatch().await(defaultAwaitTime, TimeUnit.SECONDS),
                        is(true));
                assertThat(listener.getTransitionEnded().size(), is(step.expectTransitionEnded));
            }
        }

        if (step.expectStateMachineStopped != null) {
            for (LatchStateMachineListener<S, E> listener : listeners.values()) {
                assertThat(listener.getStateMachineStoppedLatch().await(defaultAwaitTime, TimeUnit.SECONDS),
                        is(true));
                assertThat(listener.getStateMachineStopped().size(), is(step.expectStateMachineStopped));
            }
        }

        if (!step.expectStates.isEmpty()) {
            for (StateMachine<S, E> stateMachine : stateMachines.values()) {
                assertThat(stateMachine.getState(), notNullValue());
                Collection<Matcher<? super S>> itemMatchers = new ArrayList<Matcher<? super S>>();
                for (S expectState : step.expectStates) {
                    itemMatchers.add(is(expectState));
                }
                assertThat(stateMachine.getState().getIds(), containsInAnyOrder(itemMatchers));
            }
        }

        if (!step.expectStatesEntrered.isEmpty()) {
            for (LatchStateMachineListener<S, E> listener : listeners.values()) {
                Collection<S> states = new ArrayList<S>();
                for (State<S, E> s : listener.getStateEntered()) {
                    states.add(s.getId());
                }
                assertThat(step.expectStatesEntrered, contains(states.toArray()));
            }
        }

        if (!step.expectStatesExited.isEmpty()) {
            for (LatchStateMachineListener<S, E> listener : listeners.values()) {
                Collection<S> states = new ArrayList<S>();
                for (State<S, E> s : listener.getStateExited()) {
                    states.add(s.getId());
                }
                assertThat(step.expectStatesExited, contains(states.toArray()));
            }
        }

        if (step.expectExtendedStateChanged != null) {
            for (LatchStateMachineListener<S, E> listener : listeners.values()) {
                assertThat(listener.getExtendedStateChangedLatch().await(defaultAwaitTime, TimeUnit.SECONDS),
                        is(true));
                assertThat(listener.getExtendedStateChanged().size(), is(step.expectExtendedStateChanged));
            }
        }

        if (!step.expectVariableKeys.isEmpty()) {
            for (StateMachine<S, E> stateMachine : stateMachines.values()) {
                Map<Object, Object> variables = stateMachine.getExtendedState().getVariables();
                for (Object key : step.expectVariableKeys) {
                    assertThat("Key " + key + " doesn't exist in extended state variables",
                            variables.containsKey(key), is(true));
                }
            }
        }

        if (!step.expectVariables.isEmpty()) {
            for (StateMachine<S, E> stateMachine : stateMachines.values()) {
                Map<Object, Object> variables = stateMachine.getExtendedState().getVariables();
                for (Entry<Object, Object> entry : step.expectVariables.entrySet()) {
                    assertThat("Key " + entry.getKey() + " doesn't exist in extended state variables",
                            variables.containsKey(entry.getKey()), is(true));
                    assertThat("Variable " + entry.getKey() + " doesn't match in extended state variables",
                            variables.get(entry.getKey()), is(entry.getValue()));
                }
            }
        }
    }
}

---