field [isAsyncExclusive] not found on org.jbpm.graph.def.Nod

txakin — Fri, 30 Nov 2007 08:03:54 GMT

Hi people!!!!!IÃ‚Â´m more or less new using Alfresco.I want to install the Alfresco Community (from alfresco-community-war-2.1.0.zip) running in JBoss 4.0.2 AS and with Oracle.When i try to deploy the alfresco.war in the JBoss iÃ‚Â´m getting the next error :2007-11-30 14:26:56,202 ERROR [org.springf

Re: field [isAsyncExclusive] not found on org.jbpm.graph.def.Nod

txakin — Fri, 30 Nov 2007 10:53:26 GMT

Hi people!!!!!!

Maybe this information about my erorr can be useful :

After i change the Database Configuration to Oracle 10g, if i see the table JBPM_NODE in my database :


CREATE TABLE JBPM_NODE (
   ID_                    NUMBER(19) NOT NULL,
   CLASS_                 CHAR(1) NOT NULL,
   NAME_                  VARCHAR2(255),
   DESCRIPTION_           VARCHAR2(4000),
   PROCESSDEFINITION_     NUMBER(19),
   ISASYNC_               NUMBER(1),
   ISASYNCEXCL_           NUMBER(1),
   ACTION_                NUMBER(19),
   SUPERSTATE_            NUMBER(19),
   SUBPROCNAME_           VARCHAR2(255),
   SUBPROCESSDEFINITION_  NUMBER(19),
   DECISIONEXPRESSION_    VARCHAR2(255),
   DECISIONDELEGATION     NUMBER(19),
   SCRIPT_                NUMBER(19),
   SIGNAL_                NUMBER(10),
   CREATETASKS_           NUMBER(1),
   ENDTASKS_              NUMBER(1),
   NODECOLLECTIONINDEX_   NUMBER(10));
‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

I can see the field ISASYNCEXCL_ is created as a NUMBER(1).

If i check the org/jbpm/graph/def/Node.hbm.xml (inside the alfresco.war/WEB-INF/lib/jbpm-jpdl-3.2-patched.jar) :


<property name="isAsyncExclusive" column="ISASYNCEXCL_"/>
‍‍‍

The filed is referenced with the isAsyncExclusive property.

When i check the Node.java i see this methods :


// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   Node.java

package org.jbpm.graph.def;

import java.util.*;
import org.dom4j.Element;
import org.jbpm.JbpmException;
import org.jbpm.graph.action.ActionTypes;
import org.jbpm.graph.exe.ExecutionContext;
import org.jbpm.graph.exe.Token;
import org.jbpm.graph.log.NodeLog;
import org.jbpm.job.ExecuteNodeJob;
import org.jbpm.jpdl.xml.JpdlXmlReader;
import org.jbpm.jpdl.xml.Parsable;
import org.jbpm.msg.MessageService;
import org.jbpm.svc.Services;

// Referenced classes of package org.jbpm.graph.def:
//            GraphElement, Transition, Action, SuperState, 
//            ProcessDefinition

public class Node extends GraphElement
    implements Parsable
{

    public String[] getSupportedEventTypes()
    {
        return supportedEventTypes;
    }

    public Node()
    {
        leavingTransitions = null;
        leavingTransitionMap = null;
        arrivingTransitions = null;
        action = null;
        superState = null;
        isAsync = false;
        isAsyncExclusive = false;
    }

    public Node(String name)
    {
        super(name);
        leavingTransitions = null;
        leavingTransitionMap = null;
        arrivingTransitions = null;
        action = null;
        superState = null;
        isAsync = false;
        isAsyncExclusive = false;
    }

    public void read(Element nodeElement, JpdlXmlReader jpdlXmlReader)
    {
        action = jpdlXmlReader.readSingleAction(nodeElement);
    }

    public void write(Element nodeElement)
    {
        if(action != null)
        {
            String actionName = ActionTypes.getActionName(action.getClass());
            Element actionElement = nodeElement.addElement(actionName);
            action.write(actionElement);
        }
    }

    public List getLeavingTransitions()
    {
        return leavingTransitions;
    }

    public Map getLeavingTransitionsMap()
    {
        if(leavingTransitionMap == null && leavingTransitions != null)
        {
            leavingTransitionMap = new HashMap();
            Transition leavingTransition;
            for(ListIterator iter = leavingTransitions.listIterator(leavingTransitions.size()); iter.hasPrevious(); leavingTransitionMap.put(leavingTransition.getName(), leavingTransition))
                leavingTransition = (Transition)iter.previous();

        }
        return leavingTransitionMap;
    }

    public Transition addLeavingTransition(Transition leavingTransition)
    {
        if(leavingTransition == null)
            throw new IllegalArgumentException("can't add a null leaving transition to an node");
        if(leavingTransitions == null)
            leavingTransitions = new ArrayList();
        leavingTransitions.add(leavingTransition);
        leavingTransition.from = this;
        leavingTransitionMap = null;
        return leavingTransition;
    }

    public void removeLeavingTransition(Transition leavingTransition)
    {
        if(leavingTransition == null)
            throw new IllegalArgumentException("can't remove a null leavingTransition from an node");
        if(leavingTransitions != null && leavingTransitions.remove(leavingTransition))
        {
            leavingTransition.from = null;
            leavingTransitionMap = null;
        }
    }

    public boolean hasLeavingTransition(String transitionName)
    {
        if(leavingTransitions == null)
            return false;
        else
            return getLeavingTransitionsMap().containsKey(transitionName);
    }

    public Transition getLeavingTransition(String transitionName)
    {
        Transition transition = null;
        if(leavingTransitions != null)
            transition = (Transition)getLeavingTransitionsMap().get(transitionName);
        if(transition == null && superState != null)
            transition = superState.getLeavingTransition(transitionName);
        return transition;
    }

    public boolean hasNoLeavingTransitions()
    {
        return (leavingTransitions == null || leavingTransitions.size() == 0) && (superState == null || superState.hasNoLeavingTransitions());
    }

    public String generateNextLeavingTransitionName()
    {
        String name = null;
        if(leavingTransitions != null)
            if(!containsName(leavingTransitions, null))
            {
                name = null;
            } else
            {
                int n;
                for(n = 1; containsName(leavingTransitions, Integer.toString(n)); n++);
                name = Integer.toString(n);
            }
        return name;
    }

    boolean containsName(List leavingTransitions, String name)
    {
        for(Iterator iter = leavingTransitions.iterator(); iter.hasNext();)
        {
            Transition transition = (Transition)iter.next();
            if(name == null && transition.getName() == null)
                return true;
            if(name != null && name.equals(transition.getName()))
                return true;
        }

        return false;
    }

    public Transition getDefaultLeavingTransition()
    {
        Transition defaultTransition = null;
        if(leavingTransitions != null && leavingTransitions.size() > 0)
            defaultTransition = (Transition)leavingTransitions.get(0);
        else
        if(superState != null)
            defaultTransition = superState.getDefaultLeavingTransition();
        return defaultTransition;
    }

    public void reorderLeavingTransition(int oldIndex, int newIndex)
    {
        if(leavingTransitions != null && Math.min(oldIndex, newIndex) >= 0 && Math.max(oldIndex, newIndex) < leavingTransitions.size())
        {
            Object o = leavingTransitions.remove(oldIndex);
            leavingTransitions.add(newIndex, o);
        }
    }

    public List getLeavingTransitionsList()
    {
        return leavingTransitions;
    }

    public Set getArrivingTransitions()
    {
        return arrivingTransitions;
    }

    public Transition addArrivingTransition(Transition arrivingTransition)
    {
        if(arrivingTransition == null)
            throw new IllegalArgumentException("can't add a null arrivingTransition to a node");
        if(arrivingTransitions == null)
            arrivingTransitions = new HashSet();
        arrivingTransitions.add(arrivingTransition);
        arrivingTransition.to = this;
        return arrivingTransition;
    }

    public void removeArrivingTransition(Transition arrivingTransition)
    {
        if(arrivingTransition == null)
            throw new IllegalArgumentException("can't remove a null arrivingTransition from a node");
        if(arrivingTransitions != null && arrivingTransitions.remove(arrivingTransition))
            arrivingTransition.to = null;
    }

    public GraphElement getParent()
    {
        GraphElement parent = processDefinition;
        if(superState != null)
            parent = superState;
        return parent;
    }

    public void enter(ExecutionContext executionContext)
    {
        Token token = executionContext.getToken();
        token.setNode(this);
        fireEvent("node-enter", executionContext);
        token.setNodeEnter(new Date());
        executionContext.setTransition(null);
        executionContext.setTransitionSource(null);
        if(isAsync)
        {
            ExecuteNodeJob job = createAsyncContinuationJob(token);
            MessageService messageService = (MessageService)Services.getCurrentService("message");
            messageService.send(job);
            token.lock(job.toString());
        } else
        {
            execute(executionContext);
        }
    }

    protected ExecuteNodeJob createAsyncContinuationJob(Token token)
    {
        ExecuteNodeJob job = new ExecuteNodeJob(token);
        job.setNode(this);
        job.setDueDate(new Date());
        job.setExclusive(isAsyncExclusive);
        return job;
    }

    public void execute(ExecutionContext executionContext)
    {
        if(action != null)
            try
            {
                action.execute(executionContext);
            }
            catch(Exception exception)
            {
                raiseException(exception, executionContext);
            }
        else
            leave(executionContext);
    }

    public void leave(ExecutionContext executionContext)
    {
        leave(executionContext, getDefaultLeavingTransition());
    }

    public void leave(ExecutionContext executionContext, String transitionName)
    {
        Transition transition = getLeavingTransition(transitionName);
        if(transition == null)
        {
            throw new JbpmException("transition '" + transitionName + "' is not a leaving transition of node '" + this + "'");
        } else
        {
            leave(executionContext, transition);
            return;
        }
    }

    public void leave(ExecutionContext executionContext, Transition transition)
    {
        if(transition == null)
            throw new JbpmException("can't leave node '" + this + "' without leaving transition");
        Token token = executionContext.getToken();
        token.setNode(this);
        executionContext.setTransition(transition);
        fireEvent("node-leave", executionContext);
        if(token.getNodeEnter() != null)
            addNodeLog(token);
        executionContext.setTransitionSource(this);
        transition.take(executionContext);
    }

    protected void addNodeLog(Token token)
    {
        token.addLog(new NodeLog(this, token.getNodeEnter(), new Date()));
    }

    public ProcessDefinition getProcessDefinition()
    {
        ProcessDefinition pd = processDefinition;
        if(superState != null)
            pd = superState.getProcessDefinition();
        return pd;
    }

    public void setName(String name)
    {
        if(isDifferent(this.name, name))
        {
            String oldName = this.name;
            if(superState != null)
            {
                if(superState.hasNode(name))
                    throw new IllegalArgumentException("couldn't set name '" + name + "' on node '" + this + "'cause the superState of this node has already another child node with the same name");
                Map nodes = superState.getNodesMap();
                nodes.remove(oldName);
                nodes.put(name, this);
            } else
            if(processDefinition != null)
            {
                if(processDefinition.hasNode(name))
                    throw new IllegalArgumentException("couldn't set name '" + name + "' on node '" + this + "'cause the process definition of this node has already another node with the same name");
                Map nodeMap = processDefinition.getNodesMap();
                nodeMap.remove(oldName);
                nodeMap.put(name, this);
            }
            this.name = name;
        }
    }

    boolean isDifferent(String name1, String name2)
    {
        if(name1 != null && name1.equals(name2))
            return false;
        return name1 != null || name2 != null;
    }

    public String getFullyQualifiedName()
    {
        String fullyQualifiedName = name;
        if(superState != null)
            fullyQualifiedName = superState.getFullyQualifiedName() + "/" + name;
        return fullyQualifiedName;
    }

    public SuperState getSuperState()
    {
        return superState;
    }

    public Action getAction()
    {
        return action;
    }

    public void setAction(Action action)
    {
        this.action = action;
    }

    public boolean isAsync()
    {
        return isAsync;
    }

    public void setAsync(boolean isAsync)
    {
        this.isAsync = isAsync;
    }

    public boolean isAsyncExclusive()
    {
        return isAsyncExclusive;
    }

    public void setAsyncExclusive(boolean isAsyncExclusive)
    {
        this.isAsyncExclusive = isAsyncExclusive;
    }

    private static final long serialVersionUID = 1L;
    protected List leavingTransitions;
    transient Map leavingTransitionMap;
    protected Set arrivingTransitions;
    protected Action action;
    protected SuperState superState;
    protected boolean isAsync;
    protected boolean isAsyncExclusive;
    public static final String supportedEventTypes[] = {
        "node-enter", "node-leave", "before-signal", "after-signal"
    };

}
‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍

As you can see in the Oracle database the filed ISASYNCEXCL_ referenced with the property isAsyncExclusive is NUMBER(1), but in the Node.java is using like a boolean property……

If iÃ‚Â´m not wrong, Oracle database doesnÃ‚Â´t allow boolean fields……

Then…..can be the error because this kind of things?

Thanks in advance.

topic Re: field [isAsyncExclusive] not found on org.jbpm.graph.def.Nod in Alfresco Archive

field [isAsyncExclusive] not found on org.jbpm.graph.def.Nod

Re: field [isAsyncExclusive] not found on org.jbpm.graph.def.Nod