From cbe2615c14033a36256c23c6c2feb24669e56453 Mon Sep 17 00:00:00 2001 From: jvalkeal Date: Wed, 14 Feb 2018 09:20:25 +0200 Subject: [PATCH] Merge spring-statemachine-core from 1.2.x - Merge spring-statemachine-core/src which for some reason is not up to date in master/1.2.x anymore. - Relates #504 --- .../statemachine/event/StateMachineEvent.java | 2 +- .../support/AbstractStateMachine.java | 47 ++++++++----------- .../support/tree/AbstractIterator.java | 4 +- .../support/tree/TreeTraverser.java | 8 ++-- 4 files changed, 27 insertions(+), 34 deletions(-) diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/event/StateMachineEvent.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/event/StateMachineEvent.java index 47e5a276..5649f4d9 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/event/StateMachineEvent.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/event/StateMachineEvent.java @@ -18,7 +18,7 @@ package org.springframework.statemachine.event; import org.springframework.context.ApplicationEvent; /** - * Base {@link ApplicationEvent} class for statemachine events. All custom event + * Base {@link ApplicationEvent} class for leader based events. All custom event * classes should be derived from this class. * * @author Janne Valkealahti diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/AbstractStateMachine.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/AbstractStateMachine.java index 6534d2dc..81122240 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/AbstractStateMachine.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/AbstractStateMachine.java @@ -122,9 +122,6 @@ public abstract class AbstractStateMachine extends StateMachineObjectSuppo private volatile Message forwardedInitialEvent; - private final Object lock = new Object(); - private final Object lock2 = new Object(); - private StateMachine parentMachine; /** @@ -218,9 +215,7 @@ public abstract class AbstractStateMachine extends StateMachineObjectSuppo @Override public boolean sendEvent(Message event) { - synchronized (lock2) { - return sendEventInternal(event); - } + return sendEventInternal(event); } @Override @@ -423,15 +418,14 @@ public abstract class AbstractStateMachine extends StateMachineObjectSuppo @Override protected void doStop() { - synchronized (lock) { - stateMachineExecutor.stop(); - notifyStateMachineStopped(buildStateContext(Stage.STATEMACHINE_STOP, null, null, this)); - // stash current state before we null it so that - // we can still return where we 'were' when machine is stopped - lastState = currentState; - currentState = null; - initialEnabled = null; - } + stateMachineExecutor.stop(); + notifyStateMachineStopped(buildStateContext(Stage.STATEMACHINE_STOP, null, null, this)); + // stash current state before we null it so that + // we can still return where we 'were' when machine is stopped + lastState = currentState; + currentState = null; + initialEnabled = null; + log.debug("Stop complete " + this); } @Override @@ -642,9 +636,10 @@ public abstract class AbstractStateMachine extends StateMachineObjectSuppo public void resetStateMachine(StateMachineContext stateMachineContext) { // TODO: this function needs a serious rewrite if (stateMachineContext == null) { - log.info("Got null context, resetting to initial state and clearing extended state"); + log.info("Got null context, resetting to initial state, clearing extended state and machine id"); currentState = initialState; extendedState.getVariables().clear(); + setId(null); return; } if (log.isDebugEnabled()) { @@ -824,12 +819,13 @@ public abstract class AbstractStateMachine extends StateMachineObjectSuppo } protected synchronized boolean acceptEvent(Message message) { - if ((currentState != null && currentState.shouldDefer(message))) { - log.info("Current state " + currentState + " deferred event " + message); + State cs = currentState; + if ((cs != null && cs.shouldDefer(message))) { + log.info("Current state " + cs + " deferred event " + message); stateMachineExecutor.queueDeferredEvent(message); return true; } - if ((currentState != null && currentState.sendEvent(message))) { + if ((cs != null && cs.sendEvent(message))) { return true; } @@ -841,7 +837,7 @@ public abstract class AbstractStateMachine extends StateMachineObjectSuppo State source = transition.getSource(); Trigger trigger = transition.getTrigger(); - if (currentState != null && StateMachineUtils.containsAtleastOne(source.getIds(), currentState.getIds())) { + if (cs != null && StateMachineUtils.containsAtleastOne(source.getIds(), cs.getIds())) { if (trigger != null && trigger.evaluate(new DefaultTriggerContext(message.getPayload()))) { stateMachineExecutor.queueEvent(message); return true; @@ -850,8 +846,8 @@ public abstract class AbstractStateMachine extends StateMachineObjectSuppo } // if we're about to not accept event, check defer again in case // state was changed between original check and now - if ((currentState != null && currentState.shouldDefer(message))) { - log.info("Current state " + currentState + " deferred event " + message); + if ((cs != null && cs.shouldDefer(message))) { + log.info("Current state " + cs + " deferred event " + message); stateMachineExecutor.queueDeferredEvent(message); return true; } @@ -908,12 +904,11 @@ public abstract class AbstractStateMachine extends StateMachineObjectSuppo setCurrentState(toState, message, transition, true, stateMachine, null, targets); } - callPostStateChangeInterceptors(toState, message, transition, stateMachine); - stateMachineExecutor.execute(); if (isComplete()) { stop(); } + callPostStateChangeInterceptors(toState, message, transition, stateMachine); } private State followLinkedPseudoStates(State state, StateContext stateContext) { @@ -1014,9 +1009,7 @@ public abstract class AbstractStateMachine extends StateMachineObjectSuppo void setCurrentState(State state, Message message, Transition transition, boolean exit, StateMachine stateMachine, Collection> sources, Collection> targets) { - synchronized (lock2) { - setCurrentStateInternal(state, message, transition, exit, stateMachine, sources, targets); - } + setCurrentStateInternal(state, message, transition, exit, stateMachine, sources, targets); } private void setCurrentStateInternal(State state, Message message, Transition transition, boolean exit, diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/tree/AbstractIterator.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/tree/AbstractIterator.java index 7fd88a54..598e3f7a 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/tree/AbstractIterator.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/tree/AbstractIterator.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2017 the original author or authors. + * Copyright 2015 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -39,7 +39,7 @@ public abstract class AbstractIterator implements Iterator { @Override public final boolean hasNext() { - Assert.state(state != State.FAILED, "State should not be FAILED"); + Assert.state(state != State.FAILED); switch (state) { case DONE: return false; diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/tree/TreeTraverser.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/tree/TreeTraverser.java index 9199e54e..77bf9584 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/tree/TreeTraverser.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/tree/TreeTraverser.java @@ -24,14 +24,14 @@ public abstract class TreeTraverser { /** * Returns the children of the specified node. Must not contain null. - * + * * @param root the node * @return child iterables */ public abstract Iterable children(T root); public final Iterable postOrderTraversal(final T root) { - Assert.notNull(root, "root should not be null"); + Assert.notNull(root); return new Iterable() { @Override public Iterator iterator() { @@ -49,8 +49,8 @@ public abstract class TreeTraverser { final Iterator childIterator; PostOrderNode(T root, Iterator childIterator) { - Assert.notNull(root, "root should not be null"); - Assert.notNull(childIterator, "childIterator should not be null"); + Assert.notNull(root); + Assert.notNull(childIterator); this.root = root; this.childIterator = childIterator; }