Java tutorial
/* * 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.bpel.memdao; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.ode.bpel.common.BpelEventFilter; import org.apache.ode.bpel.common.Filter; import org.apache.ode.bpel.common.InstanceFilter; import org.apache.ode.bpel.common.ProcessFilter; import org.apache.ode.bpel.dao.BpelDAOConnection; import org.apache.ode.bpel.dao.CorrelationSetDAO; 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.evt.BpelEvent; import org.apache.ode.bpel.iapi.Scheduler; import org.apache.ode.utils.ISO8601DateParser; import org.apache.ode.utils.stl.CollectionsX; import org.apache.ode.utils.stl.UnaryFunction; import javax.xml.namespace.QName; import java.io.Serializable; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.Date; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.ConcurrentHashMap; /** * A very simple, in-memory implementation of the {@link BpelDAOConnection} interface. */ class BpelDAOConnectionImpl implements BpelDAOConnection { private static final Log __log = LogFactory.getLog(BpelDAOConnectionImpl.class); private Scheduler _scheduler; private Map<QName, ProcessDaoImpl> _store; private List<BpelEvent> _events = new LinkedList<BpelEvent>(); long _mexTtl; private static Map<String, MessageExchangeDAO> _mexStore = Collections .synchronizedMap(new HashMap<String, MessageExchangeDAO>()); protected static Map<String, Long> _mexAge = new ConcurrentHashMap<String, Long>(); private static AtomicLong counter = new AtomicLong(Long.MAX_VALUE / 2); private static volatile long _lastRemoval = 0; BpelDAOConnectionImpl(Map<QName, ProcessDaoImpl> store, Scheduler scheduler, long mexTtl) { _store = store; _scheduler = scheduler; _mexTtl = mexTtl; } public ProcessDAO getProcess(QName processId) { return _store.get(processId); } public ProcessDAO createTransientProcess(Long id) { ProcessDaoImpl process = new ProcessDaoImpl(this, _store, null, null, null, 0); return process; } public ProcessDAO createProcess(QName pid, QName type, String guid, long version) { ProcessDaoImpl process = new ProcessDaoImpl(this, _store, pid, type, guid, version); _store.put(pid, process); return process; } public ProcessInstanceDAO getInstance(Long iid) { for (ProcessDaoImpl proc : _store.values()) { ProcessInstanceDAO instance = proc._instances.get(iid); if (instance != null) return instance; } return null; } public int getNumInstances(QName processId) { ProcessDAO process = getProcess(processId); if (process != null) return process.getNumInstances(); else return -1; } @SuppressWarnings("unchecked") public Collection<ProcessInstanceDAO> instanceQuery(InstanceFilter filter) { if (filter.getLimit() == 0) { return Collections.EMPTY_LIST; } List<ProcessInstanceDAO> matched = new ArrayList<ProcessInstanceDAO>(); // Selecting selectionCompleted: for (ProcessDaoImpl proc : _store.values()) { boolean pmatch = true; if (filter.getNameFilter() != null && !equalsOrWildcardMatch(filter.getNameFilter(), proc.getProcessId().getLocalPart())) pmatch = false; if (filter.getNamespaceFilter() != null && !equalsOrWildcardMatch(filter.getNamespaceFilter(), proc.getProcessId().getNamespaceURI())) pmatch = false; if (pmatch) { for (ProcessInstanceDAO inst : proc._instances.values()) { boolean match = true; if (filter.getStatusFilter() != null) { boolean statusMatch = false; for (Short status : filter.convertFilterState()) { if (inst.getState() == status.byteValue()) statusMatch = true; } if (!statusMatch) match = false; } if (filter.getStartedDateFilter() != null && !dateMatch(filter.getStartedDateFilter(), inst.getCreateTime(), filter)) match = false; if (filter.getLastActiveDateFilter() != null && !dateMatch(filter.getLastActiveDateFilter(), inst.getLastActiveTime(), filter)) match = false; // if (filter.getPropertyValuesFilter() != null) { // for (Map.Entry propEntry : filter.getPropertyValuesFilter().entrySet()) { // boolean entryMatched = false; // for (ProcessPropertyDAO prop : proc.getProperties()) { // if (prop.getName().equals(propEntry.getKey()) // && (propEntry.getValue().equals(prop.getMixedContent()) // || propEntry.getValue().equals(prop.getSimpleContent()))) { // entryMatched = true; // } // } // if (!entryMatched) { // match = false; // } // } // } if (match) { matched.add(inst); if (matched.size() == filter.getLimit()) { break selectionCompleted; } } } } } // And ordering if (filter.getOrders() != null) { final List<String> orders = filter.getOrders(); Collections.sort(matched, new Comparator<ProcessInstanceDAO>() { public int compare(ProcessInstanceDAO o1, ProcessInstanceDAO o2) { for (String orderKey : orders) { int result = compareInstanceUsingKey(orderKey, o1, o2); if (result != 0) return result; } return 0; } }); } return matched; } /** * Close this DAO connection. */ public void close() { } public Collection<ProcessDAO> processQuery(ProcessFilter filter) { throw new UnsupportedOperationException("Can't query process configuration using a transient DAO."); } public MessageExchangeDAO createMessageExchange(char dir) { final String id = Long.toString(counter.getAndIncrement()); MessageExchangeDAO mex = new MessageExchangeDAOImpl(dir, id); long now = System.currentTimeMillis(); _mexStore.put(id, mex); _mexAge.put(id, now); if (now > _lastRemoval + (_mexTtl / 10)) { _lastRemoval = now; Object[] oldMexs = _mexAge.keySet().toArray(); for (int i = oldMexs.length - 1; i > 0; i--) { String oldMex = (String) oldMexs[i]; Long age = _mexAge.get(oldMex); if (age != null && now - age > _mexTtl) { removeMessageExchange(oldMex); _mexAge.remove(oldMex); } } } // Removing right away on rollback onRollback(new Runnable() { public void run() { removeMessageExchange(id); _mexAge.remove(id); } }); return mex; } public MessageExchangeDAO getMessageExchange(String mexid) { return _mexStore.get(mexid); } private int compareInstanceUsingKey(String key, ProcessInstanceDAO instanceDAO1, ProcessInstanceDAO instanceDAO2) { String s1 = null; String s2 = null; boolean ascending = true; String orderKey = key; if (key.startsWith("+") || key.startsWith("-")) { orderKey = key.substring(1, key.length()); if (key.startsWith("-")) ascending = false; } ProcessDAO process1 = getProcess(instanceDAO1.getProcess().getProcessId()); ProcessDAO process2 = getProcess(instanceDAO2.getProcess().getProcessId()); if ("pid".equals(orderKey)) { s1 = process1.getProcessId().toString(); s2 = process2.getProcessId().toString(); } else if ("name".equals(orderKey)) { s1 = process1.getProcessId().getLocalPart(); s2 = process2.getProcessId().getLocalPart(); } else if ("namespace".equals(orderKey)) { s1 = process1.getProcessId().getNamespaceURI(); s2 = process2.getProcessId().getNamespaceURI(); } else if ("version".equals(orderKey)) { s1 = "" + process1.getVersion(); s2 = "" + process2.getVersion(); } else if ("status".equals(orderKey)) { s1 = "" + instanceDAO1.getState(); s2 = "" + instanceDAO2.getState(); } else if ("started".equals(orderKey)) { s1 = ISO8601DateParser.format(instanceDAO1.getCreateTime()); s2 = ISO8601DateParser.format(instanceDAO2.getCreateTime()); } else if ("last-active".equals(orderKey)) { s1 = ISO8601DateParser.format(instanceDAO1.getLastActiveTime()); s2 = ISO8601DateParser.format(instanceDAO2.getLastActiveTime()); } if (ascending) return s1.compareTo(s2); else return s2.compareTo(s1); } private boolean equalsOrWildcardMatch(String s1, String s2) { if (s1 == null || s2 == null) return false; if (s1.equals(s2)) return true; if (s1.endsWith("*")) { if (s2.startsWith(s1.substring(0, s1.length() - 1))) return true; } if (s2.endsWith("*")) { if (s1.startsWith(s2.substring(0, s2.length() - 1))) return true; } return false; } public boolean dateMatch(List<String> dateFilters, Date instanceDate, InstanceFilter filter) { boolean match = true; for (String ddf : dateFilters) { String isoDate = ISO8601DateParser.format(instanceDate); String critDate = Filter.getDateWithoutOp(ddf); if (ddf.startsWith("=")) { if (!isoDate.startsWith(critDate)) match = false; } else if (ddf.startsWith("<=")) { if (!isoDate.startsWith(critDate) && isoDate.compareTo(critDate) > 0) match = false; } else if (ddf.startsWith(">=")) { if (!isoDate.startsWith(critDate) && isoDate.compareTo(critDate) < 0) match = false; } else if (ddf.startsWith("<")) { if (isoDate.compareTo(critDate) > 0) match = false; } else if (ddf.startsWith(">")) { if (isoDate.compareTo(critDate) < 0) match = false; } } return match; } public ScopeDAO getScope(Long siidl) { for (ProcessDaoImpl process : _store.values()) { for (ProcessInstanceDAO instance : process._instances.values()) { if (instance.getScope(siidl) != null) return instance.getScope(siidl); } } return null; } public void insertBpelEvent(BpelEvent event, ProcessDAO processConfiguration, ProcessInstanceDAO instance) { _events.add(event); } public List<Date> bpelEventTimelineQuery(InstanceFilter ifilter, BpelEventFilter efilter) { // TODO : Provide more correct implementation: ArrayList<Date> dates = new ArrayList<Date>(); CollectionsX.transform(dates, _events, new UnaryFunction<BpelEvent, Date>() { public Date apply(BpelEvent x) { return x.getTimestamp(); } }); return dates; } public List<BpelEvent> bpelEventQuery(InstanceFilter ifilter, BpelEventFilter efilter) { // TODO : Provide a more correct (filtering) implementation: return _events; } /** * @see org.apache.ode.bpel.dao.BpelDAOConnection#instanceQuery(String) */ public Collection<ProcessInstanceDAO> instanceQuery(String expression) { //TODO throw new UnsupportedOperationException(); } static void removeMessageExchange(String mexId) { // Cleaning up mex if (__log.isDebugEnabled()) __log.debug("Removing mex " + mexId + " from memory store."); MessageExchangeDAO mex = _mexStore.remove(mexId); if (mex == null) __log.warn("Couldn't find mex " + mexId + " for cleanup."); _mexAge.remove(mexId); } public void defer(final Runnable runnable) { _scheduler.registerSynchronizer(new Scheduler.Synchronizer() { public void afterCompletion(boolean success) { } public void beforeCompletion() { runnable.run(); } }); } public void onRollback(final Runnable runnable) { _scheduler.registerSynchronizer(new Scheduler.Synchronizer() { public void afterCompletion(boolean success) { if (!success) runnable.run(); } public void beforeCompletion() { } }); } public Map<Long, Collection<CorrelationSetDAO>> getCorrelationSets(Collection<ProcessInstanceDAO> instances) { Map<Long, Collection<CorrelationSetDAO>> map = new HashMap<Long, Collection<CorrelationSetDAO>>(); for (ProcessInstanceDAO instance : instances) { Long id = instance.getInstanceId(); Collection<CorrelationSetDAO> existing = map.get(id); if (existing == null) { existing = new ArrayList<CorrelationSetDAO>(); map.put(id, existing); } existing.addAll(instance.getCorrelationSets()); } return map; } public Collection<CorrelationSetDAO> getActiveCorrelationSets() { throw new UnsupportedOperationException(); } public ProcessManagementDaoImpl getProcessManagement() { return new ProcessManagementDaoImpl(); } }