/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.ode.daohib.bpel;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javax.xml.namespace.QName;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ode.bpel.common.ProcessState;
import org.apache.ode.bpel.dao.ActivityRecoveryDAO;
import org.apache.ode.bpel.dao.BpelDAOConnection;
import org.apache.ode.bpel.dao.CorrelationSetDAO;
import org.apache.ode.bpel.dao.CorrelatorDAO;
import org.apache.ode.bpel.dao.FaultDAO;
import org.apache.ode.bpel.dao.MessageExchangeDAO;
import org.apache.ode.bpel.dao.ProcessDAO;
import org.apache.ode.bpel.dao.ProcessInstanceDAO;
import org.apache.ode.bpel.dao.ScopeDAO;
import org.apache.ode.bpel.dao.ScopeStateEnum;
import org.apache.ode.bpel.dao.XmlDataDAO;
import org.apache.ode.bpel.evt.ProcessInstanceEvent;
import org.apache.ode.bpel.iapi.ProcessConf.CLEANUP_CATEGORY;
import org.apache.ode.daohib.SessionManager;
import org.apache.ode.daohib.bpel.hobj.HActivityRecovery;
import org.apache.ode.daohib.bpel.hobj.HBpelEvent;
import org.apache.ode.daohib.bpel.hobj.HCorrelationProperty;
import org.apache.ode.daohib.bpel.hobj.HCorrelationSet;
import org.apache.ode.daohib.bpel.hobj.HCorrelatorMessage;
import org.apache.ode.daohib.bpel.hobj.HCorrelatorSelector;
import org.apache.ode.daohib.bpel.hobj.HFaultData;
import org.apache.ode.daohib.bpel.hobj.HMessage;
import org.apache.ode.daohib.bpel.hobj.HMessageExchange;
import org.apache.ode.daohib.bpel.hobj.HMessageExchangeProperty;
import org.apache.ode.daohib.bpel.hobj.HPartnerLink;
import org.apache.ode.daohib.bpel.hobj.HProcessInstance;
import org.apache.ode.daohib.bpel.hobj.HScope;
import org.apache.ode.daohib.bpel.hobj.HVariableProperty;
import org.apache.ode.daohib.bpel.hobj.HXmlData;
import org.apache.ode.utils.DOMUtils;
import org.apache.ode.utils.QNameUtils;
import org.apache.ode.utils.stl.CollectionsX;
import org.apache.ode.utils.stl.UnaryFunction;
import org.hibernate.Criteria;
import org.hibernate.Hibernate;
import org.hibernate.Query;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.w3c.dom.Element;
/**
* Hibernate-based {@link ProcessInstanceDAO} implementation.
*/
public class ProcessInstanceDaoImpl extends HibernateDao implements ProcessInstanceDAO {
private static final Log __log = LogFactory.getLog(ProcessInstanceDaoImpl.class);
/** Query for removing selectors. */
private static final String QRY_DELSELECTORS = "delete from " +
HCorrelatorSelector.class.getName() + " where instance = ?";
private static final String QRY_VARIABLES = "from " + HXmlData.class.getName()
+ " as x where x.name = ? and x.scope.scopeModelId = ? and x.scope.instance.id = ?";
private static final String QRY_RECOVERIES = "from " + HActivityRecovery.class.getName() +
" AS x WHERE x.instance.id = ?";
private HProcessInstance _instance;
private ScopeDAO _root;
public ProcessInstanceDaoImpl(SessionManager sm, HProcessInstance instance) {
super(sm, instance);
entering("ProcessInstanceDaoImpl.ProcessInstanceDaoImpl");
_instance = instance;
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getCreateTime()
*/
public Date getCreateTime() {
return _instance.getCreated();
}
public void setFault(FaultDAO fault) {
entering("ProcessInstanceDaoImpl.setFault");
_instance.setFault(((FaultDAOImpl)fault)._self);
getSession().update(_instance);
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#setFault(javax.xml.namespace.QName, String, int, int, org.w3c.dom.Element)
*/
public void setFault(QName name, String explanation, int lineNo, int activityId, Element faultData) {
entering("ProcessInstanceDaoImpl.setFault");
if (_instance.getFault() != null)
getSession().delete(_instance.getFault());
HFaultData fault = new HFaultData();
fault.setName(QNameUtils.fromQName(name));
fault.setExplanation(explanation);
fault.setLineNo(lineNo);
fault.setActivityId(activityId);
if (faultData != null) {
fault.setData(DOMUtils.domToBytes(faultData));
}
_instance.setFault(fault);
getSession().save(fault);
getSession().update(_instance);
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getFault()
*/
public FaultDAO getFault() {
entering("ProcessInstanceDaoImpl.getFault");
if (_instance.getFault() == null) return null;
else return new FaultDAOImpl(_sm, _instance.getFault());
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getExecutionState()
*/
public byte[] getExecutionState() {
entering("ProcessInstanceDaoImpl.getExecutionState");
if (_instance.getJacobState() == null) return null;
return _instance.getJacobState();
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#setExecutionState(byte[])
*/
public void setExecutionState(byte[] bytes) {
entering("ProcessInstanceDaoImpl.setExecutionState");
if (bytes.length > 0) {
_instance.setJacobState(bytes);
}
getSession().update(_instance);
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getProcess()
*/
public ProcessDAO getProcess() {
entering("ProcessInstanceDaoImpl.getProcess");
return new ProcessDaoImpl(_sm, _instance.getProcess());
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getRootScope()
*/
public ScopeDAO getRootScope() {
entering("ProcessInstanceDaoImpl.getRootScope");
if (_root != null)
return _root;
Query rootQry = getSession().createFilter(_instance.getScopes(),
"where this.parentScope is null");
HScope hroot = (HScope)rootQry.uniqueResult();
if (hroot == null)
return null;
return _root = new ScopeDaoImpl(_sm, hroot);
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#setState(short)
*/
public void setState(short state) {
entering("ProcessInstanceDaoImpl.setState");
_instance.setPreviousState(_instance.getState());
_instance.setState(state);
if(state==ProcessState.STATE_TERMINATED) {
clearSelectors();
}
getSession().update(_instance);
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getState()
*/
public short getState() {
return _instance.getState();
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getPreviousState()
*/
public short getPreviousState() {
return _instance.getPreviousState();
}
public ScopeDAO createScope(ScopeDAO parentScope, String name, int scopeModelId) {
entering("ProcessInstanceDaoImpl.createScope");
HScope scope = new HScope();
scope.setParentScope(parentScope != null
? (HScope)((ScopeDaoImpl)parentScope).getHibernateObj()
: null);
scope.setName(name);
scope.setScopeModelId(scopeModelId);
scope.setState(ScopeStateEnum.NEW.toString());
scope.setInstance(_instance);
scope.setCreated(new Date());
// _instance.addScope(scope);
getSession().save(scope);
return new ScopeDaoImpl(_sm, scope);
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getInstanceId()
*/
public Long getInstanceId() {
return _instance.getId();
}
public ScopeDAO getScope(Long scopeInstanceId) {
entering("ProcessInstanceDaoImpl.getScope");
Long id = Long.valueOf(scopeInstanceId);
HScope scope = (HScope)getSession().get(HScope.class, id);
return scope != null
? new ScopeDaoImpl(_sm, scope)
: null;
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getScopes(java.lang.String)
*/
@SuppressWarnings("unchecked")
public Collection<ScopeDAO> getScopes(String scopeName) {
entering("ProcessInstanceDaoImpl.getScopes");
Collection<HScope> hscopes;
if (scopeName != null) {
Query filter = _sm.getSession().createFilter(_instance.getScopes(),
"where this.name=?");
filter.setString(0,scopeName);
hscopes = filter.list();
} else
hscopes = _instance.getScopes();
ArrayList<ScopeDAO> ret = new ArrayList<ScopeDAO>();
CollectionsX.transform(ret, hscopes, new UnaryFunction<HScope,ScopeDAO> () {
public ScopeDAO apply(HScope x) {
return new ScopeDaoImpl(_sm, x);
}
});
return ret;
}
public Collection<ScopeDAO> getScopes() {
return getScopes(null);
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getInstantiatingCorrelator()
*/
public CorrelatorDAO getInstantiatingCorrelator() {
entering("ProcessInstanceDaoImpl.getInstantiatingCorrelator");
return new CorrelatorDaoImpl(_sm, _instance.getInstantiatingCorrelator());
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getLastActiveTime()
*/
public Date getLastActiveTime() {
return _instance.getLastActiveTime();
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#setLastActiveTime(java.util.Date)
*/
public void setLastActiveTime(Date dt) {
entering("ProcessInstanceDaoImpl.setLastActiveTime");
_instance.setLastActiveTime(dt);
}
public Set<CorrelationSetDAO> getCorrelationSets() {
entering("ProcessInstanceDaoImpl.getCorrelationSets");
Set<CorrelationSetDAO> results = new HashSet<CorrelationSetDAO>();
for (HCorrelationSet hCorrelationSet : _instance.getCorrelationSets()) {
results.add(new CorrelationSetDaoImpl(_sm, hCorrelationSet));
}
return results;
}
public CorrelationSetDAO getCorrelationSet(String name) {
entering("ProcessInstanceDaoImpl.getCorrelationSet");
for (HCorrelationSet hCorrelationSet : _instance.getCorrelationSets()) {
if (hCorrelationSet.getName().equals(name))
return new CorrelationSetDaoImpl(_sm, hCorrelationSet);
}
return null;
}
/**
* TODO this is never used, except by test cases - should be removed
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#getVariables(java.lang.String, int)
*/
@SuppressWarnings("unchecked")
public XmlDataDAO[] getVariables(String variableName, int scopeModelId) {
entering("ProcessInstanceDaoImpl.getVariables");
List<XmlDataDAO> results = new ArrayList<XmlDataDAO>();
Iterator iter;
Query qry = getSession().createQuery(QRY_VARIABLES);
qry.setString(0, variableName);
qry.setInteger(1, scopeModelId);
qry.setLong(2, _instance.getId());
iter = qry.iterate();
while(iter.hasNext()) {
results.add(new XmlDataDaoImpl(_sm, (HXmlData)iter.next()));
}
Hibernate.close(iter);
return results.toArray(new XmlDataDAO[results.size()]);
}
/**
* @see org.apache.ode.bpel.dao.ProcessInstanceDAO#finishCompletion()
*/
public void finishCompletion() {
entering("ProcessInstanceDaoImpl.finishCompletion");
// make sure we have completed.
assert (ProcessState.isFinished(this.getState()));
// let our process know that we've done our work.
this.getProcess().instanceCompleted(this);
}
public void delete(Set<CLEANUP_CATEGORY> cleanupCategories) {
delete(cleanupCategories, true);
}
public void delete(Set<CLEANUP_CATEGORY> cleanupCategories, boolean deleteMyRoleMex) {
entering("ProcessInstanceDaoImpl.delete");
if(__log.isDebugEnabled()) __log.debug("Cleaning up instance data with categories = " + cleanupCategories);
if( _instance.getJacobState() != null ) {
_instance.setJacobState(null);
}
HProcessInstance[] instances = new HProcessInstance[] {_instance};
if( cleanupCategories.contains(CLEANUP_CATEGORY.EVENTS) ) {
deleteEvents(instances);
}
if( cleanupCategories.contains(CLEANUP_CATEGORY.CORRELATIONS) ) {
deleteCorrelations(instances);
}
if( cleanupCategories.contains(CLEANUP_CATEGORY.MESSAGES) ) {
deleteMessages(instances, deleteMyRoleMex);
}
if( cleanupCategories.contains(CLEANUP_CATEGORY.VARIABLES) ) {
deleteVariables(instances);
}
if( cleanupCategories.contains(CLEANUP_CATEGORY.INSTANCE) ) {
deleteInstances(instances);
}
getSession().flush();
if(__log.isDebugEnabled()) __log.debug("Instance data cleaned up and flushed.");
}
@SuppressWarnings("unchecked")
private void deleteInstances(HProcessInstance[] instances) {
deleteByIds(HFaultData.class, getSession().getNamedQuery(HFaultData.SELECT_FAULT_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
getSession().delete(_instance); // this deletes JcobState, HActivityRecovery -> ActivityRecovery-LData
}
@SuppressWarnings("unchecked")
private void deleteVariables(HProcessInstance[] instances) {
deleteByIds(HCorrelationProperty.class, getSession().getNamedQuery(HCorrelationProperty.SELECT_CORPROP_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
deleteByIds(HCorrelationSet.class, getSession().getNamedQuery(HCorrelationSet.SELECT_CORSET_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
deleteByIds(HVariableProperty.class, getSession().getNamedQuery(HVariableProperty.SELECT_VARIABLE_PROPERTY_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
deleteByIds(HXmlData.class, getSession().getNamedQuery(HXmlData.SELECT_XMLDATA_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
deleteByIds(HPartnerLink.class, getSession().getNamedQuery(HPartnerLink.SELECT_PARTNER_LINK_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
deleteByIds(HScope.class, getSession().getNamedQuery(HScope.SELECT_SCOPE_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
}
@SuppressWarnings("unchecked")
private void deleteMessages(HProcessInstance[] instances, boolean deleteMyRoleMex) {
// Let's delete ALL mex properties here
List<Long> allMexes = getSession().getNamedQuery(HMessageExchange.SELECT_MEX_IDS_BY_INSTANCES).setParameterList("instances", instances).list();
deleteByColumn(HMessageExchangeProperty.class, "mex.id", allMexes);
if( deleteMyRoleMex ) { // Delete my role mex and partner role mexes
// delete messages
deleteByIds(HMessage.class, getSession().getNamedQuery(HMessage.SELECT_MESSAGE_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
// delete all mexes
deleteByIds(HMessageExchange.class, allMexes);
} else { // Delete only the unmatched mexes, there are chances that some unmatched messages are still there
Collection<HMessageExchange> unmatchedMex = getSession().getNamedQuery(HMessageExchange.SELECT_UNMATCHED_MEX_BY_INSTANCES).setParameterList("instances", instances).list();
if( !unmatchedMex.isEmpty() ) {
List<Long> mexIdList = new ArrayList<Long>();
for( HMessageExchange mex : unmatchedMex ) {
mexIdList.add(mex.getId());
}
// delete unmatched mexes
getSession().delete(unmatchedMex);
}
}
// Delete routes and unmatched messages
deleteByIds(HCorrelatorMessage.class, getSession().getNamedQuery(HCorrelatorMessage.SELECT_CORMESSAGE_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
deleteByIds(HCorrelatorSelector.class, getSession().getNamedQuery(HCorrelatorSelector.SELECT_MESSAGE_ROUTE_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
}
@SuppressWarnings("unchecked")
private void deleteCorrelations(HProcessInstance[] instances) {
deleteByIds(HCorrelationProperty.class, getSession().getNamedQuery(HCorrelationProperty.SELECT_CORPROP_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
deleteByIds(HCorrelationSet.class, getSession().getNamedQuery(HCorrelationSet.SELECT_CORSET_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
}
@SuppressWarnings("unchecked")
private void deleteEvents(HProcessInstance[] instances) {
deleteByIds(HBpelEvent.class, getSession().getNamedQuery(HBpelEvent.SELECT_EVENT_IDS_BY_INSTANCES).setParameterList("instances", instances).list());
}
public void insertBpelEvent(ProcessInstanceEvent event) {
entering("ProcessInstanceDaoImpl.insertBpelEvent");
// Defer to the BpelDAOConnectionImpl
BpelDAOConnectionImpl._insertBpelEvent(getSession(), event, this.getProcess(), this);
}
public EventsFirstLastCountTuple getEventsFirstLastCount() {
entering("ProcessInstanceDaoImpl.getEventsFirstLastCount");
// Using a criteria, find the min,max, and count of event tstamps.
Criteria c = getSession().createCriteria(HBpelEvent.class);
c.add(Restrictions.eq("instance",_instance));
c.setProjection(Projections.projectionList().add(Projections.min("tstamp"))
.add(Projections.max("tstamp"))
.add(Projections.count("tstamp")));
Object[] ret = (Object[]) c.uniqueResult();
EventsFirstLastCountTuple flc = new EventsFirstLastCountTuple();
flc.first = (Date) ret[0];
flc.last = (Date) ret[1];
flc.count = (Integer)ret[2];
return flc;
}
public Collection<MessageExchangeDAO> getMessageExchanges() {
Collection<MessageExchangeDAO> exchanges = new ArrayList<MessageExchangeDAO>();
for( HMessageExchange exchange : _instance.getMessageExchanges() ) {
exchanges.add(new MessageExchangeDaoImpl(_sm, exchange));
}
return exchanges;
}
public long genMonotonic() {
entering("ProcessInstanceDaoImpl.genMonotonic");
long seq = _instance.getSequence()+1;
_instance.setSequence(seq);
return seq;
}
protected void clearSelectors() {
entering("ProcessInstanceDaoImpl.clearSelectors");
Query q = getSession().createQuery(QRY_DELSELECTORS);
q.setEntity(0, _instance);
q.executeUpdate();
}
public int getActivityFailureCount() {
return _instance.getActivityFailureCount();
}
public Date getActivityFailureDateTime() {
return _instance.getActivityFailureDateTime();
}
@SuppressWarnings("unchecked")
public Collection<ActivityRecoveryDAO> getActivityRecoveries() {
entering("ProcessInstanceDaoImpl.getActivityRecoveries");
List<ActivityRecoveryDAO> results = new ArrayList<ActivityRecoveryDAO>();
Query qry = getSession().createQuery(QRY_RECOVERIES);
qry.setLong(0, _instance.getId());
Iterator iter = qry.iterate();
while (iter.hasNext())
results.add(new ActivityRecoveryDaoImpl(_sm, (HActivityRecovery) iter.next()));
Hibernate.close(iter);
return results;
}
public void createActivityRecovery(String channel, long activityId, String reason,
Date dateTime, Element data, String[] actions, int retries) {
entering("ProcessInstanceDaoImpl.createActivityRecovery");
HActivityRecovery recovery = new HActivityRecovery();
recovery.setInstance(_instance);
recovery.setChannel(channel);
recovery.setActivityId(activityId);
recovery.setReason(reason);
recovery.setDateTime(dateTime);
recovery.setRetries(retries);
if (data != null) {
recovery.setDetails(DOMUtils.domToBytes(data));
}
String list = actions[0];
for (int i = 1; i < actions.length; ++i)
list += " " + actions[i];
recovery.setActions(list);
// _instance.addRecovery(recovery);
getSession().save(recovery);
_instance.setActivityFailureDateTime(dateTime);
_instance.setActivityFailureCount(_instance.getActivityFailureCount() + 1);
getSession().update(_instance);
}
/**
* Delete previously registered activity recovery.
*/
public void deleteActivityRecovery(String channel) {
entering("ProcessInstanceDaoImpl.deleteActivityRecovery");
for (HActivityRecovery recovery : _instance.getActivityRecoveries()) {
if (recovery.getChannel().equals(channel)) {
getSession().delete(recovery);
_instance.setActivityFailureCount(_instance.getActivityFailureCount() - 1);
getSession().update(_instance);
return;
}
}
}
public BpelDAOConnection getConnection() {
entering("ProcessInstanceDaoImpl.getConnection");
return new BpelDAOConnectionImpl(_sm);
}
public Collection<String> getMessageExchangeIds() {
Collection<String> c = new HashSet<String>();
for (HMessageExchange m : _instance.getMessageExchanges()) {
c.add(m.getId().toString());
}
return c;
}
}