Example usage for org.springframework.statemachine StateMachine sendEvent

List of usage examples for org.springframework.statemachine StateMachine sendEvent

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.statemachine.*
  5. StateMachine
  6. sendEvent

Introduction

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

Prototype

@Deprecated
boolean sendEvent(Message<E> event);

Source Link

Document

Send an event E wrapped with a Message to the region.

Usage

From source file:com.netflix.genie.agent.execution.statemachine.StateMachineAutoConfigurationTest.java

private void cancelJobBeforeEnteringState(final States targetState) {
    this.sm.getStateMachineAccessor().doWithAllRegions(function -> function
            .addStateMachineInterceptor(new StateMachineInterceptorAdapter<States, Events>() {
                @Override/*from  www  .jav a  2s  .c om*/
                public void preStateChange(final State<States, Events> state, final Message<Events> message,
                        final Transition<States, Events> transition,
                        final StateMachine<States, Events> stateMachine) {
                    log.info("Sending event {} before transitioning to state: {}", Events.CANCEL_JOB_LAUNCH,
                            targetState);
                    if (state.getId() == targetState) {
                        stateMachine.sendEvent(Events.CANCEL_JOB_LAUNCH);
                    }
                }
            }));
}

From source file:com.netflix.genie.agent.execution.statemachine.StateMachineAutoConfigurationTest.java

private void cancelJobAfterEnteringState(final States targetState) {
    this.sm.getStateMachineAccessor().doWithAllRegions(function -> function
            .addStateMachineInterceptor(new StateMachineInterceptorAdapter<States, Events>() {
                @Override//from w  ww .  j av  a2  s. c om
                public void postStateChange(final State<States, Events> state, final Message<Events> message,
                        final Transition<States, Events> transition,
                        final StateMachine<States, Events> stateMachine) {
                    log.info("Sending event {} after transitioning to state: {}", Events.CANCEL_JOB_LAUNCH,
                            targetState);
                    if (state.getId() == targetState) {
                        stateMachine.sendEvent(Events.CANCEL_JOB_LAUNCH);
                    }
                }
            }));
}

From source file:org.springframework.statemachine.StateMachineTests.java

@Test
public void testTimerTransition() throws Exception {
    context.register(BaseConfig.class, Config2.class);
    context.refresh();/*from ww  w.ja  va2 s  .  c  om*/

    TestAction testAction1 = context.getBean("testAction1", TestAction.class);
    TestAction testAction2 = context.getBean("testAction2", TestAction.class);
    TestAction testAction3 = context.getBean("testAction3", TestAction.class);
    TestAction testAction4 = context.getBean("testAction4", TestAction.class);

    @SuppressWarnings("unchecked")
    StateMachine<TestStates, TestEvents> machine = context
            .getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, StateMachine.class);
    TestListener listener = new TestListener();
    machine.addStateListener(listener);
    listener.reset(1);
    machine.start();
    assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
    assertThat(listener.stateChangedCount, is(1));
    assertThat(testAction2.stateContexts.size(), is(0));

    listener.reset(0, 1);
    machine.sendEvent(TestEvents.E1);
    assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true));
    assertThat(testAction1.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true));
    assertThat(testAction1.stateContexts.size(), is(1));
    assertThat(testAction2.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true));
    assertThat(testAction2.stateContexts.size(), is(1));

    listener.reset(0, 1);
    machine.sendEvent(TestEvents.E2);
    assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true));
    assertThat(testAction3.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true));
    assertThat(testAction3.stateContexts.size(), is(1));

    // timer still fires but should not cause transition anymore
    // after we sleep and do next event
    int timedTriggered = testAction2.stateContexts.size();
    Thread.sleep(2000);
    assertThat(testAction2.stateContexts.size(), is(timedTriggered));

    listener.reset(0, 1);
    machine.sendEvent(TestEvents.E3);
    assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true));
    assertThat(testAction4.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true));
    assertThat(testAction4.stateContexts.size(), is(1));
    assertThat(testAction2.stateContexts.size(), is(timedTriggered));
}

From source file:org.springframework.statemachine.StateMachineTests.java

@Test
public void testStringStatesAndEvents() throws Exception {
    context.register(Config4.class);
    context.refresh();//www . j  av a  2s.com
    assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE));
    @SuppressWarnings("unchecked")
    StateMachine<String, String> machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE,
            StateMachine.class);

    TestListener2 listener = new TestListener2();
    machine.addStateListener(listener);

    assertThat(machine, notNullValue());
    machine.start();
    listener.reset(1);
    machine.sendEvent(MessageBuilder.withPayload("E1").setHeader("foo", "jee1").build());
    assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
    assertThat(listener.stateChangedCount, is(1));
    assertThat(machine.getState().getIds(), containsInAnyOrder("S1"));
}

From source file:org.springframework.statemachine.StateMachineTests.java

@Test
public void testBackToItself() {
    context.register(BaseConfig.class, Config5.class);
    context.refresh();/*from w  ww  .ja  v  a 2  s . c  o  m*/
    @SuppressWarnings("unchecked")
    StateMachine<TestStates, TestEvents> machine = context
            .getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, StateMachine.class);
    assertThat(machine, notNullValue());
    TestStateEntryExitListener listener = new TestStateEntryExitListener();
    machine.addStateListener(listener);
    machine.start();
    assertThat(machine.getState().getIds(), contains(TestStates.SI));
    listener.reset();
    machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build());
    assertThat(machine.getState().getIds(), contains(TestStates.SI));
    assertThat(listener.exited.size(), is(1));
    assertThat(listener.entered.size(), is(1));
}

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

/**
 * Run test plan.// w ww  .  j  a v  a  2s  .  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()));
                }
            }
        }
    }
}

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

/**
 * Send event parallel to all machines./* ww  w. j  a  va 2 s  . co  m*/
 *
 * @param machines the machines
 * @param event the event
 */
private void sendEventParallel(final List<StateMachine<S, E>> machines, final E event) {
    final CountDownLatch latch = new CountDownLatch(1);
    final ArrayList<Thread> joins = new ArrayList<Thread>();
    int threadCount = machines.size();
    for (int i = 0; i < threadCount; ++i) {
        final StateMachine<S, E> machine = machines.get(i);
        Runnable runner = new Runnable() {

            @Override
            public void run() {
                try {
                    latch.await();
                    machine.sendEvent(event);
                } catch (InterruptedException e) {
                }
            }
        };
        Thread t = new Thread(runner, "EventSenderThread" + i);
        joins.add(t);
        t.start();
    }
    latch.countDown();
    for (Thread t : joins) {
        try {
            t.join();
        } catch (InterruptedException e) {
        }
    }
}