120 lines
3.2 KiB
Java
120 lines
3.2 KiB
Java
package eu.dnetlib.enabling.tools.blackboard;
|
|
|
|
import java.util.Map;
|
|
|
|
import javax.annotation.PostConstruct;
|
|
|
|
import org.apache.commons.logging.Log;
|
|
import org.apache.commons.logging.LogFactory;
|
|
import org.springframework.beans.factory.annotation.Required;
|
|
|
|
/**
|
|
* A BlackboardServerActionExecutor dispatches the execution of server side blackboard actions.
|
|
*
|
|
* <p>
|
|
* The primary responsibility of this class is to organize the actions, dispatch the action when called, and transform
|
|
* exceptions into blackboard 'failures'.
|
|
* </p>
|
|
*
|
|
* <p>
|
|
* The action executor is synchronous. It's responsibility of the actual action implementations to put the jobs in
|
|
* background, if needed.
|
|
* </p>
|
|
*
|
|
* @author marko
|
|
*
|
|
* @param <X>
|
|
*/
|
|
public class BlackboardServerActionExecutor<X extends Enum<X>> {
|
|
private static final Log log = LogFactory.getLog(BlackboardServerActionExecutor.class); // NOPMD by marko on 11/24/08 5:02 PM
|
|
|
|
/**
|
|
* set by spring, so key has to be string
|
|
*/
|
|
private Map<String, BlackboardServerAction<X>> actionMap;
|
|
|
|
/**
|
|
* used to set bb msg status as done, failed etc.
|
|
*/
|
|
private BlackboardServerHandler blackboardHandler;
|
|
|
|
/**
|
|
* used to exploit static enum declaration for runtime checks of allowed types.
|
|
*/
|
|
private Class<X> actionType;
|
|
|
|
/**
|
|
* if true, the executor will allow for an incomplete implementation of actions. If false, it an exception will be
|
|
* thrown if not all actions are implemented, according to the actionType enum.
|
|
*/
|
|
private boolean incomplete = false;
|
|
|
|
@PostConstruct
|
|
public void check() {
|
|
for (String key : actionMap.keySet())
|
|
Enum.valueOf(actionType, key);
|
|
|
|
if (!incomplete)
|
|
for (X en : actionType.getEnumConstants())
|
|
if (actionMap.get(en.toString()) == null)
|
|
throw new IllegalArgumentException("action " + en + " not declared in action map. Action is mandatory");
|
|
}
|
|
|
|
/**
|
|
* Executes a blackboard job, watching for
|
|
*
|
|
* @param job
|
|
*/
|
|
public void execute(final BlackboardJob job) {
|
|
try {
|
|
final X label = Enum.valueOf(actionType, job.getAction());
|
|
|
|
final BlackboardServerAction<X> action = actionMap.get(label.toString());
|
|
if (action != null) {
|
|
action.execute(blackboardHandler, job);
|
|
} else {
|
|
log.warn("Cannot find action handler for blackboard action: " + label);
|
|
throw new IllegalArgumentException("Cannot find action handler for blackboard action: " + label);
|
|
}
|
|
} catch (final Throwable e) {
|
|
log.warn("got some exception during blackboard handler execution", e);
|
|
blackboardHandler.failed(job, e);
|
|
}
|
|
}
|
|
|
|
public BlackboardServerHandler getBlackboardHandler() {
|
|
return blackboardHandler;
|
|
}
|
|
|
|
@Required
|
|
public void setBlackboardHandler(final BlackboardServerHandler blackboardHandler) {
|
|
this.blackboardHandler = blackboardHandler;
|
|
}
|
|
|
|
public Class<X> getActionType() {
|
|
return actionType;
|
|
}
|
|
|
|
@Required
|
|
public void setActionType(final Class<X> actionType) {
|
|
this.actionType = actionType;
|
|
}
|
|
|
|
public Map<String, BlackboardServerAction<X>> getActionMap() {
|
|
return actionMap;
|
|
}
|
|
|
|
public void setActionMap(Map<String, BlackboardServerAction<X>> actionMap) {
|
|
this.actionMap = actionMap;
|
|
}
|
|
|
|
public boolean isIncomplete() {
|
|
return incomplete;
|
|
}
|
|
|
|
public void setIncomplete(boolean incomplete) {
|
|
this.incomplete = incomplete;
|
|
}
|
|
|
|
}
|