Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.adobe.granite.workflow.WorkflowException
 *  com.adobe.granite.workflow.WorkflowSession
 *  com.adobe.granite.workflow.collection.ResourceCollection
 *  com.adobe.granite.workflow.collection.ResourceCollectionManager
 *  com.adobe.granite.workflow.exec.Workflow
 *  com.adobe.granite.workflow.exec.Workflow$State
 *  com.adobe.granite.workflow.exec.WorkflowData
 *  com.adobe.granite.workflow.model.WorkflowModel
 *  javax.jcr.Item
 *  javax.jcr.ItemNotFoundException
 *  javax.jcr.Node
 *  javax.jcr.Property
 *  javax.jcr.RepositoryException
 *  javax.jcr.Session
 *  org.apache.felix.scr.annotations.Activate
 *  org.apache.felix.scr.annotations.Component
 *  org.apache.felix.scr.annotations.Deactivate
 *  org.apache.felix.scr.annotations.Property
 *  org.apache.felix.scr.annotations.Reference
 *  org.apache.felix.scr.annotations.ReferencePolicy
 *  org.apache.felix.scr.annotations.Service
 *  org.apache.sling.api.adapter.AdapterManager
 *  org.apache.sling.commons.threads.ThreadPool
 *  org.apache.sling.commons.threads.ThreadPoolManager
 *  org.apache.sling.jcr.api.SlingRepository
 *  org.osgi.service.component.ComponentContext
 *  org.osgi.service.event.Event
 *  org.osgi.service.event.EventHandler
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.adobe.granite.workflow.core;

import com.adobe.granite.workflow.WorkflowException;
import com.adobe.granite.workflow.WorkflowSession;
import com.adobe.granite.workflow.collection.ResourceCollection;
import com.adobe.granite.workflow.collection.ResourceCollectionManager;
import com.adobe.granite.workflow.core.WorkflowConfig;
import com.adobe.granite.workflow.core.collection.ResourceCollectionUtil;
import com.adobe.granite.workflow.core.exec.WorkflowDataImpl;
import com.adobe.granite.workflow.core.util.ServiceLoginUtil;
import com.adobe.granite.workflow.exec.Workflow;
import com.adobe.granite.workflow.exec.WorkflowData;
import com.adobe.granite.workflow.model.WorkflowModel;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import javax.jcr.Item;
import javax.jcr.ItemNotFoundException;
import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.ReferencePolicy;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.adapter.AdapterManager;
import org.apache.sling.commons.threads.ThreadPool;
import org.apache.sling.commons.threads.ThreadPoolManager;
import org.apache.sling.jcr.api.SlingRepository;
import org.osgi.service.component.ComponentContext;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component(metatype=1, label="Adobe Granite Workflow PayloadMapCache", description="PayloadMap Cache to speedup workflow-related operations")
@Service(value={PayloadMapCache.class, EventHandler.class})
@org.apache.felix.scr.annotations.Property(name="event.topics", value={"com/adobe/granite/workflow/event"}, propertyPrivate=1)
public class PayloadMapCache
implements EventHandler {
    private static final Logger log = LoggerFactory.getLogger(PayloadMapCache.class);
    @org.apache.felix.scr.annotations.Property(value={"/etc/workflow/models/scheduled_activation/jcr:content/model", "/etc/workflow/models/scheduled_deactivation/jcr:content/model"}, label="%cq.workflow.payload.map.system.workflow.model.name", description="%cq.workflow.payload.map.system.workflow.model.description")
    public static final String SYSTEM_WORKFLOW_MODELS = "cq.workflow.payload.map.system.workflow.model";
    @org.apache.felix.scr.annotations.Property(value={"/etc/workflow/packages"}, label="%cq.workflow.payload.map.workflow.packages.root.path", description="%cq.workflow.payload.map.workflow.packages.root.path.description")
    public static final String WF_PACKAGES_ROOT_PATH = "cq.workflow.payload.map.workflow.packages.root.path";
    public static final String THREADPOOL_NAME = "payload-map-cache";
    @Reference(policy=ReferencePolicy.STATIC)
    private SlingRepository repository;
    @Reference(policy=ReferencePolicy.STATIC)
    private ResourceCollectionManager rcManager;
    @Reference(policy=ReferencePolicy.STATIC)
    private AdapterManager adapterManager;
    @Reference
    WorkflowConfig workflowConfig;
    @Reference
    private ThreadPoolManager threadPoolManager;
    private volatile boolean isInitialized;
    private final Map<String, Map<String, String>> cache = new HashMap<String, Map<String, String>>();
    private final Map<String, String> systemWorkflowModelsMap = new HashMap<String, String>();
    private final Map<String, Set<String>> resourceColls = new HashMap<String, Set<String>>();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private Set<String> workflowPackageRootPaths;
    private String debugCombinedRootPaths;
    private ThreadPool threadPool;

    public boolean isInWorkflow(String path, boolean excludeSystemWorkflows) {
        return this.exists(path, excludeSystemWorkflows);
    }

    public List<Workflow> getWorkflowInstances(WorkflowSession aUserSession, String path, boolean excludeSystemWorkflows) {
        if (this.exists(path, excludeSystemWorkflows)) {
            ArrayList<Workflow> list = new ArrayList<Workflow>();
            Set<String> instances = this.get(path, excludeSystemWorkflows).keySet();
            for (String instance : instances) {
                try {
                    list.add(aUserSession.getWorkflow(instance));
                }
                catch (WorkflowException we) {
                    log.warn("Unable to get workflow instance: " + we.getMessage());
                }
            }
            return list;
        }
        return new ArrayList<Workflow>();
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    public void payloadMoved(String sourcePath, String destPath, boolean includeSystemWorflows) throws WorkflowException {
        this.lock.writeLock().lock();
        try {
            WorkflowSession workflowSession = null;
            try {
                workflowSession = ServiceLoginUtil.getRepositoryReadWorkflowSession(this.repository, this.adapterManager);
                String[] payloads = new String[this.cache.keySet().size()];
                for (String payload : payloads = this.cache.keySet().toArray(payloads)) {
                    Map<String, String> instances;
                    if (!payload.equals(sourcePath) && !payload.startsWith(sourcePath) || (instances = this.cache.get(payload)) == null) continue;
                    String[] workflowIds = new String[instances.keySet().size()];
                    for (String workflowId : workflowIds = this.cache.get(payload).keySet().toArray(workflowIds)) {
                        Workflow instance = workflowSession.getWorkflow(workflowId);
                        this.index(instance, true, (Session)workflowSession.adaptTo(Session.class));
                        Session workflowInstanceSession = null;
                        try {
                            workflowInstanceSession = ServiceLoginUtil.getWorkflowInstanceDataSession(this.repository);
                            PayloadMapCache.updatePayload(instance, sourcePath, destPath, workflowInstanceSession);
                        }
                        finally {
                            if (workflowInstanceSession != null && workflowInstanceSession.isLive()) {
                                workflowInstanceSession.logout();
                            }
                        }
                        instance = workflowSession.getWorkflow(workflowId);
                        this.index(instance, false, (Session)workflowSession.adaptTo(Session.class));
                    }
                }
            }
            finally {
                workflowSession.logout();
            }
        }
        catch (RepositoryException e) {
            throw new WorkflowException(e.getMessage(), (Throwable)e);
        }
        finally {
            this.lock.writeLock().unlock();
        }
    }

    private static void updatePayload(Workflow workflow, String srcPath, String destPath, Session session) throws RepositoryException {
        String payloadPath;
        String currentPayload;
        Node payloadNode;
        Node instanceNode;
        String instancePath = workflow.getId();
        if (session.nodeExists(instancePath) && (instanceNode = session.getNode(instancePath)).hasNode(payloadPath = "data/payload") && ((currentPayload = (payloadNode = instanceNode.getNode(payloadPath)).getProperty("path").getString()).equals(srcPath) || currentPayload.startsWith(srcPath))) {
            String newPayload = currentPayload.replace(srcPath, destPath);
            payloadNode.getProperty("path").setValue(newPayload);
            session.save();
        }
    }

    public void handleEvent(final Event event) {
        Runnable task = new Runnable(){

            @Override
            public void run() {
                PayloadMapCache.this.processEvent(event);
            }
        };
        this.threadPool.execute(task);
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    public boolean processEvent(Event event) {
        log.debug("Received event of topic: " + event.getTopic());
        String topic = event.getTopic();
        WorkflowSession wfSession = ServiceLoginUtil.getRepositoryReadWorkflowSession(this.repository, this.adapterManager);
        try {
            if (topic.equals("com/adobe/granite/workflow/event")) {
                Object eventType = event.getProperty("EventType");
                if (eventType.equals("WorkflowStarted") || eventType.equals("WorkflowResumed")) {
                    String instanceId = (String)event.getProperty("WorkflowInstanceId");
                    try {
                        Workflow instance = wfSession.getWorkflow(instanceId);
                        this.lock.writeLock().lock();
                        try {
                            this.index(instance, false, (Session)wfSession.adaptTo(Session.class));
                            this.checkResourceCollection(instance, false, (Session)wfSession.adaptTo(Session.class));
                        }
                        finally {
                            this.lock.writeLock().unlock();
                        }
                    }
                    catch (WorkflowException we) {
                        log.warn("Unable to load workflow instance", (Throwable)we);
                    }
                } else if (eventType.equals("WorkflowAborted") || eventType.equals("WorkflowCompleted") || eventType.equals("WorkflowSuspended")) {
                    String instanceId = (String)event.getProperty("WorkflowInstanceId");
                    try {
                        Workflow instance = wfSession.getWorkflow(instanceId);
                        this.lock.writeLock().lock();
                        try {
                            this.index(instance, true, (Session)wfSession.adaptTo(Session.class));
                            this.checkResourceCollection(instance, true, (Session)wfSession.adaptTo(Session.class));
                        }
                        finally {
                            this.lock.writeLock().unlock();
                        }
                    }
                    catch (WorkflowException we) {
                        log.warn("Unable to load workflow instance", (Throwable)we);
                    }
                } else {
                    if (eventType.equals("ResourceCollectionModified")) {
                        this.lock.writeLock().lock();
                        try {
                            this.handleResourceCollMods(event, wfSession);
                        }
                        finally {
                            this.lock.writeLock().unlock();
                        }
                    }
                    if (eventType.equals("WorkflowPayloadModified")) {
                        this.lock.writeLock().lock();
                        try {
                            String instanceId = (String)event.getProperty("WorkflowInstanceId");
                            try {
                                Workflow instance = wfSession.getWorkflow(instanceId);
                                this.lock.writeLock().lock();
                                try {
                                    String oldPayloadPath = (String)event.getProperty("oldPayloadPath");
                                    if (instance != null && instance.getWorkflowData() != null && "JCR_PATH".equals(instance.getWorkflowData().getPayloadType()) && instance.getWorkflowData() instanceof WorkflowDataImpl && (oldPayloadPath == null || oldPayloadPath.equals(instance.getWorkflowData().getPayload()))) {
                                        String payloadPath = (String)event.getProperty("payloadPath");
                                        ((WorkflowDataImpl)instance.getWorkflowData()).setPayload(payloadPath);
                                    }
                                    this.index(instance, oldPayloadPath, false, (Session)wfSession.adaptTo(Session.class));
                                    this.checkResourceCollection(instance, false, (Session)wfSession.adaptTo(Session.class));
                                }
                                finally {
                                    this.lock.writeLock().unlock();
                                }
                            }
                            catch (WorkflowException we) {
                                log.warn("Unable to load workflow instance", (Throwable)we);
                            }
                        }
                        finally {
                            this.lock.writeLock().unlock();
                        }
                    }
                }
            }
        }
        finally {
            wfSession.logout();
        }
        return true;
    }

    @Activate
    protected void activate(ComponentContext context) throws RepositoryException {
        this.threadPool = this.threadPoolManager.get("payload-map-cache");
        String[] systemWorkflowModels = (String[])context.getProperties().get("cq.workflow.payload.map.system.workflow.model");
        String legacyRootPathValue = null;
        if (context.getProperties().get("cq.workflow.payload.map.workflow.packages.root.path") != null && (legacyRootPathValue = (String)context.getProperties().get("cq.workflow.payload.map.workflow.packages.root.path")) != null && legacyRootPathValue.trim().length() == 0) {
            legacyRootPathValue = null;
        }
        for (String model : systemWorkflowModels) {
            this.systemWorkflowModelsMap.put(model, model);
        }
        this.workflowPackageRootPaths = this.workflowConfig.getWorkflowPackageRootPaths();
        if (legacyRootPathValue != null && !this.workflowPackageRootPaths.contains(legacyRootPathValue)) {
            this.workflowPackageRootPaths.add(legacyRootPathValue);
            log.warn("Workflow Package root path {} from PayloadMapCache should be configured in the WorkflowConfig component", (Object)legacyRootPathValue);
        }
        boolean first = true;
        StringBuffer tempOutput = new StringBuffer();
        for (String path : this.workflowConfig.getWorkflowPackageRootPaths()) {
            if (!first) {
                tempOutput.append(",");
            }
            tempOutput.append(path);
            first = false;
        }
        this.debugCombinedRootPaths = tempOutput.toString();
        log.debug("Workflow package root path contains: " + this.debugCombinedRootPaths);
        this.isInitialized = false;
    }

    @Deactivate
    public void deactivate() {
        this.threadPoolManager.release(this.threadPool);
    }

    private void add(String path, String workflowId, String workflowModelId) {
        if (this.cache.containsKey(path)) {
            Map<String, String> instanceMap = this.cache.get(path);
            instanceMap.put(workflowId, workflowModelId);
            log.debug(String.format("updated cache entry for path %s with instance %s for model %s", path, workflowId, workflowModelId));
        } else {
            HashMap<String, String> instanceMap = new HashMap<String, String>();
            instanceMap.put(workflowId, workflowModelId);
            this.cache.put(path, instanceMap);
            log.debug(String.format("added new cache entry for path %s with instance %s for model %s", path, workflowId, workflowModelId));
        }
    }

    private void remove(String path, String workflowId) {
        if (this.cache.containsKey(path)) {
            Map<String, String> instanceMap = this.cache.get(path);
            instanceMap.remove(workflowId);
            log.debug("removed entry for path %s and workflowId %s", (Object)path, (Object)workflowId);
            if (instanceMap.size() == 0) {
                this.cache.remove(path);
                log.debug("removed entry for path %s", (Object)path);
            }
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private boolean exists(String path, boolean excludeSystemWorkflows) {
        block6 : {
            this.init();
            this.lock.readLock().lock();
            try {
                if (excludeSystemWorkflows) {
                    if (!this.cache.containsKey(path)) break block6;
                    Set<String> instances = this.cache.get(path).keySet();
                    for (String instance : instances) {
                        if (this.systemWorkflowModelsMap.containsKey(this.cache.get(path).get(instance))) continue;
                        boolean bl = true;
                        return bl;
                    }
                    break block6;
                }
                boolean instances = this.cache.containsKey(path);
                return instances;
            }
            finally {
                this.lock.readLock().unlock();
            }
        }
        return false;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private Map<String, String> get(String path, boolean excludeSystemWorkflows) {
        this.init();
        this.lock.readLock().lock();
        try {
            if (excludeSystemWorkflows) {
                Object instances;
                HashMap<String, String> instancesMap = new HashMap<String, String>();
                if (this.cache.containsKey(path)) {
                    instances = this.cache.get(path).keySet();
                    Iterator i$ = instances.iterator();
                    while (i$.hasNext()) {
                        String instance = (String)i$.next();
                        if (this.systemWorkflowModelsMap.containsKey(this.cache.get(path).get(instance))) continue;
                        instancesMap.put(instance, this.cache.get(path).get(instance));
                    }
                }
                instances = instancesMap;
                return instances;
            }
            Map<String, String> instancesMap = this.cache.get(path);
            return instancesMap;
        }
        finally {
            this.lock.readLock().unlock();
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private void init() {
        if (this.isInitialized) {
            return;
        }
        this.lock.writeLock().lock();
        WorkflowSession wfSession = null;
        try {
            wfSession = ServiceLoginUtil.getRepositoryReadWorkflowSession(this.repository, this.adapterManager);
            if (this.isInitialized) {
                return;
            }
            try {
                long startTime = System.currentTimeMillis();
                Workflow[] workflows = wfSession.getWorkflows(new String[]{Workflow.State.RUNNING.name()});
                log.info("Getting all running workflows (" + workflows.length + ") for cache population took: " + (System.currentTimeMillis() - startTime) + "ms");
                for (Workflow instance : workflows) {
                    this.index(instance, false, (Session)wfSession.adaptTo(Session.class));
                    this.checkResourceCollection(instance, false, (Session)wfSession.adaptTo(Session.class));
                }
                this.isInitialized = true;
                long resultingTime = System.currentTimeMillis() - startTime;
                log.info("Initial workflow payload cache population took " + resultingTime + "ms");
            }
            catch (WorkflowException we) {
                log.error("Cannot init workflow payload cache", (Throwable)we);
            }
        }
        finally {
            if (wfSession != null) {
                wfSession.logout();
            }
            this.lock.writeLock().unlock();
        }
    }

    private void index(Workflow workflow, boolean doRemove, Session admin) {
        this.index(workflow, null, doRemove, admin);
    }

    private void index(Workflow workflow, String oldPayloadPath, boolean doRemove, Session admin) {
        try {
            WorkflowData data = workflow.getWorkflowData();
            String type = data.getPayloadType();
            String path = null;
            if (type != null) {
                if (type.equals("JCR_PATH") && data.getPayload() != null) {
                    path = (String)data.getPayload();
                } else if (data.getPayload() != null && type.equals("JCR_UUID")) {
                    Node node = admin.getNodeByUUID((String)data.getPayload());
                    path = node.getPath();
                }
            }
            if (oldPayloadPath != null) {
                this.remove(oldPayloadPath, workflow.getId());
            }
            if (path != null) {
                if (doRemove) {
                    this.remove(path, workflow.getId());
                } else {
                    this.add(path, workflow.getId(), workflow.getWorkflowModel().getId());
                }
            }
        }
        catch (ItemNotFoundException infe) {
            log.warn("The referenced payload node does not exist: " + infe.getMessage());
        }
        catch (RepositoryException re) {
            log.warn("An error occured while trying to load payload object: " + re.getMessage());
        }
        catch (Throwable t) {
            log.warn("Cannot index " + workflow.getId(), t);
        }
    }

    private void handleResourceCollMods(Event event, WorkflowSession wfAdminSession) {
        Session admin = (Session)wfAdminSession.adaptTo(Session.class);
        String collectionPath = (String)event.getProperty("Path");
        boolean inWf = true;
        if (!this.exists(collectionPath, false)) {
            try {
                ResourceCollection collection = this.rcManager.createCollection((Node)admin.getItem(collectionPath));
                Node node = ResourceCollectionUtil.getContainingPage(collection, admin);
                if (!this.exists(node.getPath(), false)) {
                    inWf = false;
                }
            }
            catch (RepositoryException re) {
                inWf = false;
            }
        }
        log.debug("ResourceCollection " + collectionPath + "has been modified. " + "The Resource collection is subject of a workflow:" + inWf);
        if (inWf) {
            try {
                ResourceCollection re = this.rcManager.createCollection((Node)admin.getItem(collectionPath));
                List<Workflow> instances = this.getWorkflowInstances(wfAdminSession, collectionPath, false);
                if (instances.size() == 0) {
                    Node n = ResourceCollectionUtil.getContainingPage(re, admin);
                    instances = this.getWorkflowInstances(wfAdminSession, n.getPath(), false);
                }
                List members = re.list(new String[]{"nt:hierarchyNode"});
                HashSet removedSet = new HashSet();
                removedSet.addAll(this.resourceColls.get(re.getPath()));
                for (Node m2 : members) {
                    String mPath = m2.getPath();
                    if (!removedSet.contains(mPath)) continue;
                    removedSet.remove(mPath);
                }
                for (Node m2 : members) {
                    if (this.exists(m2.getPath(), false)) continue;
                    this.add(m2.getPath(), instances.get(0).getId(), instances.get(0).getWorkflowModel().getId());
                }
                for (String key : removedSet) {
                    this.remove(key, instances.get(0).getId());
                }
                HashSet<String> currentMembers = new HashSet<String>();
                for (Node m3 : members) {
                    currentMembers.add(m3.getPath());
                }
                this.resourceColls.put(re.getPath(), currentMembers);
            }
            catch (RepositoryException re) {
                log.warn("Cannot update payload cache within a resource collection" + collectionPath);
            }
        }
    }

    private void checkResourceCollection(Workflow workflow, boolean doRemove, Session admin) {
        WorkflowData data = workflow.getWorkflowData();
        String type = data.getPayloadType();
        String path = null;
        if (type != null && type.equals("JCR_PATH") && data.getPayload() != null) {
            path = (String)data.getPayload();
        }
        try {
            if (path != null && this.isWorkflowPackageRootPath(path)) {
                Set<String> paths;
                if (admin.itemExists(path)) {
                    ResourceCollection collection = ResourceCollectionUtil.getResourceCollection((Node)admin.getItem(path), this.rcManager);
                    if (collection != null) {
                        List members = collection.list(new String[]{"nt:hierarchyNode"});
                        HashSet<String> resourceList = new HashSet<String>();
                        for (Node member : members) {
                            String mPath = member.getPath();
                            if (doRemove) {
                                this.remove(mPath, workflow.getId());
                                continue;
                            }
                            this.add(mPath, workflow.getId(), workflow.getWorkflowModel().getId());
                            resourceList.add(mPath);
                        }
                        if (doRemove) {
                            this.resourceColls.remove(collection.getPath());
                        } else {
                            this.resourceColls.put(collection.getPath(), resourceList);
                        }
                    }
                } else if (doRemove && (paths = this.resourceColls.get(path)) != null) {
                    for (String collectionEntry : paths) {
                        this.remove(collectionEntry, workflow.getId());
                    }
                    this.resourceColls.remove(path);
                }
            } else {
                log.debug(path + "is either not existing or does not point to the workflow package lookup path: " + this.debugCombinedRootPaths);
            }
        }
        catch (RepositoryException re) {
            log.warn("Cannot check payload for a resource collection:" + re.getMessage());
        }
    }

    private boolean isWorkflowPackageRootPath(String path) {
        if (path != null) {
            for (String rootPath : this.workflowConfig.getWorkflowPackageRootPaths()) {
                if (!path.startsWith(rootPath)) continue;
                return true;
            }
        }
        return false;
    }

    protected void bindRepository(SlingRepository slingRepository) {
        this.repository = slingRepository;
    }

    protected void unbindRepository(SlingRepository slingRepository) {
        if (this.repository == slingRepository) {
            this.repository = null;
        }
    }

    protected void bindRcManager(ResourceCollectionManager resourceCollectionManager) {
        this.rcManager = resourceCollectionManager;
    }

    protected void unbindRcManager(ResourceCollectionManager resourceCollectionManager) {
        if (this.rcManager == resourceCollectionManager) {
            this.rcManager = null;
        }
    }

    protected void bindAdapterManager(AdapterManager adapterManager) {
        this.adapterManager = adapterManager;
    }

    protected void unbindAdapterManager(AdapterManager adapterManager) {
        if (this.adapterManager == adapterManager) {
            this.adapterManager = null;
        }
    }

    protected void bindWorkflowConfig(WorkflowConfig workflowConfig) {
        this.workflowConfig = workflowConfig;
    }

    protected void unbindWorkflowConfig(WorkflowConfig workflowConfig) {
        if (this.workflowConfig == workflowConfig) {
            this.workflowConfig = null;
        }
    }

    protected void bindThreadPoolManager(ThreadPoolManager threadPoolManager) {
        this.threadPoolManager = threadPoolManager;
    }

    protected void unbindThreadPoolManager(ThreadPoolManager threadPoolManager) {
        if (this.threadPoolManager == threadPoolManager) {
            this.threadPoolManager = null;
        }
    }

}