Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.day.cq.wcm.api.Page
 *  com.day.cq.wcm.api.PageManager
 *  com.day.cq.wcm.api.WCMException
 *  com.day.cq.wcm.msm.api.Blueprint
 *  com.day.cq.wcm.msm.api.BlueprintManager
 *  com.day.cq.wcm.msm.api.BlueprintManagerFactory
 *  com.day.cq.wcm.msm.api.LiveCopy
 *  com.day.cq.wcm.msm.api.LiveRelationship
 *  com.day.cq.wcm.msm.api.LiveRelationshipManager
 *  com.day.cq.wcm.msm.api.LiveStatus
 *  com.day.cq.wcm.msm.api.RolloutConfig
 *  com.day.cq.wcm.msm.api.RolloutManager
 *  com.day.cq.wcm.msm.api.RolloutManager$Trigger
 *  com.day.text.Text
 *  javax.jcr.ItemNotFoundException
 *  javax.jcr.Node
 *  javax.jcr.NodeIterator
 *  javax.jcr.Property
 *  javax.jcr.RangeIterator
 *  javax.jcr.RepositoryException
 *  javax.jcr.Session
 *  javax.jcr.Value
 *  javax.jcr.ValueFactory
 *  org.apache.commons.collections.IteratorUtils
 *  org.apache.commons.collections.ResettableIterator
 *  org.apache.commons.collections.Transformer
 *  org.apache.commons.collections.map.ListOrderedMap
 *  org.apache.felix.scr.annotations.Activate
 *  org.apache.felix.scr.annotations.Component
 *  org.apache.felix.scr.annotations.Property
 *  org.apache.felix.scr.annotations.Reference
 *  org.apache.felix.scr.annotations.Service
 *  org.apache.jackrabbit.commons.iterator.RangeIteratorAdapter
 *  org.apache.sling.api.adapter.AdapterFactory
 *  org.apache.sling.api.resource.LoginException
 *  org.apache.sling.api.resource.NonExistingResource
 *  org.apache.sling.api.resource.PersistenceException
 *  org.apache.sling.api.resource.Resource
 *  org.apache.sling.api.resource.ResourceResolver
 *  org.apache.sling.api.resource.ResourceResolverFactory
 *  org.apache.sling.api.resource.ResourceUtil
 *  org.apache.sling.api.resource.SyntheticResource
 *  org.osgi.service.component.ComponentContext
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.day.cq.wcm.msm.impl;

import com.day.cq.wcm.api.Page;
import com.day.cq.wcm.api.PageManager;
import com.day.cq.wcm.api.WCMException;
import com.day.cq.wcm.msm.api.Blueprint;
import com.day.cq.wcm.msm.api.BlueprintManager;
import com.day.cq.wcm.msm.api.BlueprintManagerFactory;
import com.day.cq.wcm.msm.api.LiveCopy;
import com.day.cq.wcm.msm.api.LiveRelationship;
import com.day.cq.wcm.msm.api.LiveRelationshipManager;
import com.day.cq.wcm.msm.api.LiveStatus;
import com.day.cq.wcm.msm.api.RolloutConfig;
import com.day.cq.wcm.msm.api.RolloutManager;
import com.day.cq.wcm.msm.impl.LiveCopyManagerImpl;
import com.day.cq.wcm.msm.impl.LiveCopyServiceImpl;
import com.day.cq.wcm.msm.impl.LiveRelationshipImpl;
import com.day.cq.wcm.msm.impl.LiveStatusImpl;
import com.day.cq.wcm.msm.impl.StatusUtil;
import com.day.cq.wcm.msm.impl.Utils;
import com.day.text.Text;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import javax.jcr.ItemNotFoundException;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Property;
import javax.jcr.RangeIterator;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.Value;
import javax.jcr.ValueFactory;
import org.apache.commons.collections.IteratorUtils;
import org.apache.commons.collections.ResettableIterator;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.map.ListOrderedMap;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.jackrabbit.commons.iterator.RangeIteratorAdapter;
import org.apache.sling.api.adapter.AdapterFactory;
import org.apache.sling.api.resource.LoginException;
import org.apache.sling.api.resource.NonExistingResource;
import org.apache.sling.api.resource.PersistenceException;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceResolverFactory;
import org.apache.sling.api.resource.ResourceUtil;
import org.apache.sling.api.resource.SyntheticResource;
import org.osgi.service.component.ComponentContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component(label="%liverelationshipmgr.name", description="%liverelationshipmgr.description", metatype=1)
@Service
public class LiveRelationshipManagerImpl
implements LiveRelationshipManager,
AdapterFactory {
    private static final Logger log = LoggerFactory.getLogger(LiveRelationshipManagerImpl.class);
    public static final String PATTERN_ALL = ".*";
    static final String DEFAULT_ROLLOUT_CONFIG = "/etc/msm/rolloutconfigs/default";
    public static final String RT_GHOST = "wcm/msm/components/ghost";
    @Reference
    private BlueprintManagerFactory blueprintManagerFactory = null;
    @Reference
    private ResourceResolverFactory resolverFactory = null;
    @Reference
    private LiveCopyServiceImpl liveCopyService = null;
    @org.apache.felix.scr.annotations.Property(name="adapters", propertyPrivate=1)
    public static final String[] ADAPTER_CLASSES = new String[]{LiveRelationshipManager.class.getName()};
    @org.apache.felix.scr.annotations.Property(name="adaptables", propertyPrivate=1)
    public static final String[] ADAPTABLE_CLASSES = new String[]{ResourceResolver.class.getName()};
    @org.apache.felix.scr.annotations.Property(value={"/etc/msm/rolloutconfigs/default"})
    static final String RELATIONS_DEFAULT_ROLLOUT_CONFIG = "liverelationshipmgr.relationsconfig.default";
    private static final String VERSION_QUERY = String.format("/jcr:root//element(*,%s)[%s/@%s='%%s' and %s/@%s='%%s'] order by @%s descending", "nt:version", "jcr:frozenNode", "cq:parentPath", "jcr:frozenNode", "cq:name", "jcr:created");
    private String defaultRolloutConfigPath;

    @Activate
    protected void activate(ComponentContext context) throws RepositoryException, WCMException, LoginException {
        Dictionary props = context.getProperties();
        this.defaultRolloutConfigPath = (String)props.get("liverelationshipmgr.relationsconfig.default");
    }

    public <AdapterType> AdapterType getAdapter(Object adaptable, Class<AdapterType> type) {
        if (LiveRelationshipManager.class.isAssignableFrom(type) && ResourceResolver.class.isInstance(adaptable)) {
            return (AdapterType)this;
        }
        return null;
    }

    public boolean hasLiveRelationship(Resource resource) {
        try {
            Node node = Utils.getWorkingNode((Node)resource.adaptTo(Node.class));
            return !this.isManuallyCreated(node);
        }
        catch (ItemNotFoundException ine) {
            return false;
        }
        catch (RepositoryException e) {
            log.error("Failed to access Node for Resource at {}:{}", (Object)resource.getPath(), (Object)e);
            return false;
        }
    }

    public RangeIterator getLiveRelationships(Resource source, String targetPathFilter, RolloutManager.Trigger triggerFilter) throws WCMException {
        try {
            return new LiveRelationshipIterator(source, this.liveCopyService, targetPathFilter, triggerFilter);
        }
        catch (RepositoryException e) {
            throw new WCMException((Throwable)e);
        }
    }

    public RangeIterator getChildren(LiveRelationship relationship, ResourceResolver resolver) throws WCMException {
        Resource source;
        ListOrderedMap merged = new ListOrderedMap();
        Resource target = resolver.getResource(relationship.getTargetPath());
        if (target != null) {
            Iterator<Resource> targetChildren = LiveRelationshipManagerImpl.pageToResourceIterator(target);
            while (targetChildren.hasNext()) {
                Resource child = targetChildren.next();
                LiveRelationship ship = this.getLiveRelationship(child, true);
                if (ship == null) {
                    log.debug("Found a Child of a shallow LiveCopy at {}, end roll-out for branch", (Object)child.getPath());
                    continue;
                }
                merged.put((Object)ship, (Object)ship.getSourcePath());
            }
        }
        if ((source = resolver.getResource(relationship.getSourcePath())) != null) {
            Iterator<Resource> srcChildren = LiveRelationshipManagerImpl.pageToResourceIterator(source);
            while (srcChildren.hasNext()) {
                Resource child = srcChildren.next();
                if (merged.containsValue((Object)child.getPath())) continue;
                String targetChildPath = relationship.getTargetPath().concat("/").concat(child.getName());
                Resource resource = resolver.getResource(targetChildPath);
                if (resource == null) {
                    NonExistingResource nonResource = new NonExistingResource(resolver, targetChildPath);
                    LiveRelationship ship = this.getLiveRelationship((Resource)nonResource, true);
                    if (ship == null) continue;
                    merged.put((Object)ship, (Object)child.getPath());
                    continue;
                }
                LiveRelationship ship = this.getLiveRelationship(resource, true);
                if (ship == null) {
                    log.debug("Found a child outside the Parent-LiveCopy at {}", (Object)resource.getPath());
                    continue;
                }
                log.debug("Found a child from {} to shadow current source {}", (Object)ship.getSourcePath(), (Object)child.getPath());
            }
        }
        return new RangeIteratorAdapter(merged.keySet().iterator(), (long)merged.size());
    }

    public LiveRelationship getLiveRelationship(Resource target, boolean advancedStatus) throws WCMException {
        String path = target.getPath();
        LiveCopyManagerImpl.LiveCopyImpl lc = null;
        try {
            lc = this.getContainingLiveCopy(target, target.getResourceResolver());
        }
        catch (RepositoryException e) {
            log.warn("Failed to access LiveCopy for {}", (Object)path);
        }
        if (lc != null) {
            String lcRoot = lc.getPath();
            String relPath = path.substring(lcRoot.length());
            LiveRelationship relation = this.buildRelationship(target.getResourceResolver(), lc, relPath, advancedStatus);
            log.debug("found relation for {}: {}", (Object)path, (Object)relation);
            return relation;
        }
        log.debug("no relation for {} found.", (Object)path);
        return null;
    }

    public /* varargs */ LiveRelationship establishRelationship(Page source, Page copy, boolean deep, boolean autoSave, RolloutConfig ... rolloutConfig) throws WCMException {
        Resource content = copy.getContentResource();
        if (content == null) {
            log.warn("Call to establish Relation from {} to a Page {} that has no content: skip", (Object)source.getPath(), (Object)copy.getPath());
            return null;
        }
        try {
            this.checkCircularRelationship(source.getPath(), content.getPath(), deep);
            Node contentNode = (Node)content.adaptTo(Node.class);
            LiveCopyManagerImpl usersLiveCopyMgr = this.liveCopyService.createLiveCopyManager(content.getResourceResolver());
            LiveCopyManagerImpl.LiveCopyImpl lc = usersLiveCopyMgr.create(contentNode.getParent(), source.getPath(), deep, rolloutConfig);
            LiveRelationshipManagerImpl.markRelationship((Node)copy.adaptTo(Node.class), true, deep);
            if (autoSave) {
                contentNode.getSession().save();
            }
            return this.buildRelationship(content.getResourceResolver(), lc, "/" + content.getName(), true);
        }
        catch (RepositoryException e) {
            Session session = (Session)content.getResourceResolver().adaptTo(Session.class);
            try {
                if (autoSave && session != null && session.hasPendingChanges()) {
                    session.refresh(false);
                }
            }
            catch (RepositoryException e1) {
                log.error("Failed to revert changes {}", (Throwable)e1);
            }
            throw new WCMException((Throwable)e);
        }
    }

    public void endRelationship(Resource resource, boolean autoSave) throws WCMException {
        Node node = (Node)resource.adaptTo(Node.class);
        if (node != null) {
            try {
                LiveCopyManagerImpl usersLiveCopyMgr = this.liveCopyService.createLiveCopyManager(resource.getResourceResolver());
                if (usersLiveCopyMgr.remove(node.getPath())) {
                    LiveRelationshipManagerImpl.removeMarker(node);
                } else {
                    Utils.detachLiveCopy(node, true, false);
                }
                if (autoSave) {
                    node.getSession().save();
                }
                log.debug("detached Resource at {} from LiveRelationship", (Object)resource.getPath());
            }
            catch (RepositoryException e) {
                throw new WCMException((Throwable)e);
            }
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    public boolean isSource(Resource source) {
        ResourceResolver sysView = null;
        try {
            if (source != null) {
                sysView = this.resolverFactory.getServiceResourceResolver(null);
                boolean bl = this.liveCopyService.createLiveCopyManager(sysView).getDependentLiveCopies(source.getPath()).hasNext();
                return bl;
            }
        }
        catch (RepositoryException e) {
            log.error("Failed to check isSource status of source at {}", (Object)source.getPath(), (Object)e);
        }
        catch (WCMException e) {
            log.error("Failed to check isSource status of source at {}", (Object)source.getPath(), (Object)e);
        }
        catch (LoginException e) {
            log.error("Failed to check isSource status of source at {}", (Object)source.getPath(), (Object)e);
        }
        finally {
            if (sysView != null && sysView.isLive()) {
                sysView.close();
            }
        }
        return false;
    }

    public void detach(Resource resource, boolean autoSave) throws WCMException {
        this.endRelationship(resource, autoSave);
    }

    public void cancelRelationship(ResourceResolver resolver, LiveRelationship relation, boolean deep, boolean autoSave) throws WCMException {
        if (resolver == null || relation == null) {
            throw new IllegalArgumentException("Relation must exist");
        }
        LiveStatus status = relation.getStatus();
        if (Boolean.TRUE.equals(status.getAdvancedStatus("msm:isTargetManuallyCreated"))) {
            throw new IllegalStateException("Relation must not be manually created");
        }
        Node slave = Utils.getNode(resolver, relation.getTargetPath());
        if (slave == null) {
            String msg = String.format("Call to cancelRelation on non-existing Resource '%s: use skipPages instead", relation.getTargetPath());
            throw new IllegalArgumentException(msg);
        }
        if (Boolean.TRUE.equals(status.getAdvancedStatus("msm:isTargetDeleted")) || status.isCancelled() && status.isCancelledForChildren() == deep) {
            log.debug("Nothing to do, Relationship from [0]->[1] already cancelled", (Object)relation.getSourcePath(), (Object)relation.getTargetPath());
            return;
        }
        try {
            if (!slave.isNodeType("cq:LiveSyncCancelled")) {
                slave.addMixin("cq:LiveSyncCancelled");
            }
            if (deep) {
                slave.setProperty("cq:isCancelledForChildren", true);
            } else if (slave.hasProperty("cq:isCancelledForChildren")) {
                slave.getProperty("cq:isCancelledForChildren").remove();
            }
            if (autoSave) {
                resolver.commit();
            }
        }
        catch (RepositoryException re) {
            throw new WCMException("Error while cancelling relationship", (Throwable)re);
        }
        catch (PersistenceException e) {
            throw new WCMException("Error while committing changes to cancel relationship", (Throwable)e);
        }
    }

    public void reenableRelationship(ResourceResolver resolver, LiveRelationship relation, boolean autoSave) throws WCMException {
        if (relation == null || resolver == null) {
            throw new IllegalArgumentException("Relation and ResourceResolver must exist");
        }
        if (!relation.getStatus().isCancelled()) {
            throw new IllegalStateException("The relation given is not cancelled, can not reenable");
        }
        try {
            Node slave = Utils.getNode(resolver, relation.getTargetPath());
            if (slave != null && slave.isNodeType("cq:LiveSyncCancelled")) {
                if (slave.hasProperty("cq:isCancelledForChildren")) {
                    slave.getProperty("cq:isCancelledForChildren").remove();
                }
                slave.removeMixin("cq:LiveSyncCancelled");
                if (autoSave) {
                    resolver.commit();
                }
            }
        }
        catch (RepositoryException re) {
            throw new WCMException("Error while enabling relationship", (Throwable)re);
        }
        catch (PersistenceException e) {
            throw new WCMException("Error while committing changes to cancel relationship", (Throwable)e);
        }
    }

    public void cancelPropertyRelationship(ResourceResolver resolver, LiveRelationship relation, String[] names, boolean autoSave) throws WCMException {
        if (relation == null || names.length == 0) {
            throw new IllegalArgumentException("Relation and names required");
        }
        Resource target = resolver.getResource(relation.getTargetPath());
        if (target == null || !this.hasLiveRelationship(target)) {
            throw new IllegalStateException("Relation must not be manually created");
        }
        try {
            Node slave = Utils.getWorkingNode((Node)target.adaptTo(Node.class));
            if (slave != null) {
                if (!slave.isNodeType("cq:PropertyLiveSyncCancelled")) {
                    slave.addMixin("cq:PropertyLiveSyncCancelled");
                }
                ArrayList<Value> values = new ArrayList<Value>();
                if (slave.hasProperty("cq:propertyInheritanceCancelled")) {
                    Property prop = slave.getProperty("cq:propertyInheritanceCancelled");
                    values.addAll(Arrays.asList(prop.getValues()));
                }
                ValueFactory vf = slave.getSession().getValueFactory();
                for (String name : names) {
                    boolean found = false;
                    for (Value v : values) {
                        if (!v.getString().equals(name)) continue;
                        found = true;
                        break;
                    }
                    if (found) continue;
                    values.add(vf.createValue(name));
                }
                slave.setProperty("cq:propertyInheritanceCancelled", values.toArray((T[])new Value[values.size()]));
                if (autoSave) {
                    resolver.commit();
                }
            }
        }
        catch (RepositoryException re) {
            throw new WCMException("Error while cancelling property relationship", (Throwable)re);
        }
        catch (PersistenceException e) {
            throw new WCMException("Error while saving changes", (Throwable)e);
        }
    }

    public void reenablePropertyRelationship(ResourceResolver resolver, LiveRelationship relation, String[] names, boolean autoSave) throws WCMException {
        if (relation == null || names.length == 0) {
            throw new IllegalArgumentException("Relation and names required");
        }
        Resource target = resolver.getResource(relation.getTargetPath());
        if (target == null || !this.hasLiveRelationship(target)) {
            throw new IllegalStateException("Relation must not be manually created");
        }
        try {
            Node slave = Utils.getWorkingNode((Node)target.adaptTo(Node.class));
            if (slave != null) {
                Property prop = null;
                ArrayList<Value> values = new ArrayList<Value>();
                if (slave.hasProperty("cq:propertyInheritanceCancelled")) {
                    prop = slave.getProperty("cq:propertyInheritanceCancelled");
                    values.addAll(Arrays.asList(prop.getValues()));
                }
                for (String name : names) {
                    Value value = null;
                    for (Value v : values) {
                        if (!v.getString().equals(name)) continue;
                        value = v;
                        break;
                    }
                    if (value == null) continue;
                    values.remove((Object)value);
                }
                if (prop != null) {
                    if (values.size() == 0) {
                        prop.remove();
                        if (slave.isNodeType("cq:PropertyLiveSyncCancelled")) {
                            slave.removeMixin("cq:PropertyLiveSyncCancelled");
                        }
                    } else {
                        prop.setValue(values.toArray((T[])new Value[values.size()]));
                    }
                }
                if (autoSave) {
                    resolver.commit();
                }
            }
        }
        catch (RepositoryException re) {
            throw new WCMException("Error while reenabling relationship", (Throwable)re);
        }
        catch (PersistenceException e) {
            throw new WCMException("Error while saving changes", (Throwable)e);
        }
    }

    public Map<String, Page> getSkippedSourcePages(Page parentTargetPage) throws WCMException {
        LinkedHashMap<String, Page> ret = new LinkedHashMap<String, Page>();
        Node contentNode = (Node)parentTargetPage.getContentResource().adaptTo(Node.class);
        try {
            if (contentNode != null && contentNode.hasProperty("cq:skippedPages")) {
                Value[] skippedPages;
                LiveRelationship lr = this.getLiveRelationship(parentTargetPage.getContentResource(), true);
                if (lr == null) {
                    throw new WCMException("Target page is not a Live Copy");
                }
                if (!lr.getStatus().isSourceExisting()) {
                    throw new WCMException("Source page must exist to compute skipped pages");
                }
                PageManager pm = parentTargetPage.getPageManager();
                Page parentSourcePage = pm.getContainingPage(lr.getSourcePath());
                for (Value v : skippedPages = contentNode.getProperty("cq:skippedPages").getValues()) {
                    String skippedPageName = v.getString();
                    if (!parentSourcePage.hasChild(skippedPageName) || parentTargetPage.hasChild(skippedPageName)) continue;
                    ret.put(parentTargetPage.getPath() + "/" + skippedPageName, pm.getPage(parentSourcePage.getPath() + "/" + skippedPageName));
                }
            }
        }
        catch (RepositoryException e) {
            throw new WCMException("Error while reading repository", (Throwable)e);
        }
        return ret;
    }

    public void addSkippedPages(Page parentPage, String[] childrenNames, boolean autoSave) throws WCMException {
        if (parentPage == null) {
            throw new WCMException("Cannot skip a page if parent page does not exist.");
        }
        Node node = (Node)parentPage.getContentResource().adaptTo(Node.class);
        if (node == null) {
            throw new WCMException("Cannot skip a page if parent page does not exist.");
        }
        try {
            StatusUtil.skipPages(node, childrenNames);
            if (autoSave && node.getSession().hasPendingChanges()) {
                node.getSession().save();
            }
        }
        catch (RepositoryException e) {
            throw new WCMException((Throwable)e);
        }
    }

    public void removeSkippedPages(Page parentPage, String[] childrenNames, boolean autoSave) throws WCMException {
        if (parentPage == null) {
            throw new WCMException("Cannot unskip a page if parent page does not exist.");
        }
        Node node = (Node)parentPage.getContentResource().adaptTo(Node.class);
        if (node == null) {
            throw new WCMException("Cannot unskip a page if parent page does not exist.");
        }
        try {
            StatusUtil.unskipPages(node, childrenNames);
            if (autoSave && node.getSession().hasPendingChanges()) {
                node.getSession().save();
            }
        }
        catch (RepositoryException re) {
            throw new WCMException("Error while reading the repository", (Throwable)re);
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    public Map<String, LiveCopy> getLiveCopies() {
        ResourceResolver sysResolver = null;
        try {
            LiveCopy lc;
            sysResolver = this.resolverFactory.getServiceResourceResolver(null);
            RangeIterator itr = this.liveCopyService.createLiveCopyManager(sysResolver).getAll();
            HashMap<String, LiveCopy> result = new HashMap<String, LiveCopy>();
            while (itr.hasNext()) {
                lc = (LiveCopy)itr.next();
                result.put(lc.getPath(), lc);
            }
            lc = Collections.unmodifiableMap(result);
            return lc;
        }
        catch (RepositoryException e) {
            log.error("Failed to access LiveCopies {}", (Throwable)e);
        }
        catch (WCMException e) {
            log.error("Failed to access LiveCopies {}", (Throwable)e);
        }
        catch (LoginException e) {
            log.error("Failed to access LiveCopies {}", (Throwable)e);
        }
        finally {
            if (sysResolver != null && sysResolver.isLive()) {
                sysResolver.close();
            }
        }
        return Collections.emptyMap();
    }

    public LiveCopy getLiveCopy(Resource target) {
        if (target == null || target instanceof SyntheticResource) {
            return null;
        }
        try {
            LiveCopyManagerImpl.LiveCopyImpl lc = this.getContainingLiveCopy(target, target.getResourceResolver());
            if (lc != null) {
                log.debug("Found LiveCopy in inheritance that is applicable for {}", (Object)target.getPath());
                return lc;
            }
        }
        catch (RepositoryException e) {
            log.error("Could not access LiveCopy for Resoruce{}: {}", (Object)target.getPath(), (Object)e);
        }
        catch (WCMException e) {
            log.error("Could not access LiveCopy for Resoruce{}: {}", (Object)target.getPath(), (Object)e);
        }
        return null;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    public boolean isInBlueprint(Resource resource) {
        Blueprint blueprint = null;
        ResourceResolver sysView = null;
        if (resource != null) {
            String absPath = resource.getPath();
            try {
                sysView = this.resolverFactory.getServiceResourceResolver(null);
                BlueprintManager sysBpMgr = this.blueprintManagerFactory.getBlueprintManager(sysView);
                blueprint = sysBpMgr.getContainingBlueprint(absPath);
            }
            catch (WCMException e) {
                log.error("Failed to access Blueprint at {}: {}", (Object)absPath, (Object)e);
            }
            catch (LoginException e) {
                log.error("Failed to access Blueprint at {}: {}", (Object)absPath, (Object)e);
            }
            finally {
                if (sysView != null && sysView.isLive()) {
                    sysView.close();
                }
            }
        }
        return blueprint != null;
    }

    public boolean isLiveCopy(Resource target) {
        return this.hasLiveRelationship(target);
    }

    public Collection<LiveRelationship> getLiveRelationships(Page master, RolloutManager.Trigger trigger, String[] targets, boolean advancedStatus) throws WCMException {
        return this.getLiveRelationships(master.hasContent() ? master.getContentResource() : (Resource)master.adaptTo(Resource.class), trigger, targets, advancedStatus);
    }

    public Collection<LiveRelationship> getLiveRelationships(Resource source, RolloutManager.Trigger trigger, String[] targets, boolean advancedStatus) throws WCMException {
        String sourcePath = source.getPath();
        log.debug("Get LiveRelationships for {}", (Object)sourcePath);
        HashMap<String, LiveRelationship> relations = new HashMap<String, LiveRelationship>();
        try {
            LiveCopyManagerImpl userLcManager = this.liveCopyService.createLiveCopyManager(source.getResourceResolver());
            Iterator<LiveCopyManagerImpl.LiveCopyImpl> deps = userLcManager.getDependentLiveCopies(source.getPath());
            while (deps.hasNext()) {
                LiveRelationship lr;
                LiveCopyManagerImpl.LiveCopyImpl lc = deps.next();
                String relPath = sourcePath.substring(lc.getBlueprintPath().length());
                String targetPath = lc.getPath() + relPath;
                if (targets != null && targets.length > 0) {
                    boolean allowed = false;
                    for (int i = 0; !allowed && i < targets.length; ++i) {
                        allowed = Text.isDescendantOrEqual((String)targets[i], (String)targetPath);
                    }
                    if (!allowed) {
                        log.debug("LiveCopy {} not contained in target filter {}", (Object)targetPath, (Object)targets);
                        continue;
                    }
                }
                if (relations.containsKey(targetPath) || (lr = this.buildRelationship(source.getResourceResolver(), lc, relPath, advancedStatus)) == null) continue;
                if (trigger != null && !lr.isTrigger(trigger)) {
                    log.debug("liveCopy {} ignored by trigger filter {}", (Object)lc.getPath(), (Object)trigger);
                    continue;
                }
                log.debug("adding relation {}", (Object)lr);
                relations.put(targetPath, lr);
            }
        }
        catch (RepositoryException e) {
            throw new WCMException((Throwable)e);
        }
        return relations.values();
    }

    public static void markRelationship(Node node, boolean forceContent) throws RepositoryException {
        LiveRelationshipManagerImpl.markRelationship(node, forceContent, true);
    }

    private LiveRelationship buildRelationship(ResourceResolver resolver, LiveCopy liveCopy, String relPath, boolean advancedStatus) throws WCMException {
        try {
            LiveRelationshipImpl relation = new LiveRelationshipImpl(liveCopy, relPath);
            String dstPath = relation.getTargetPath();
            Node target = Utils.getNode(resolver, dstPath);
            boolean isTargetFromDifferentTree = false;
            if (target != null && !target.isNew()) {
                LiveCopy targetLiveCopy = this.getLiveCopy(resolver.getResource(target.getPath()));
                if (!(targetLiveCopy == null || liveCopy.getBlueprintPath().equals(targetLiveCopy.getBlueprintPath()) && liveCopy.getPath().equals(targetLiveCopy.getPath()))) {
                    String syncPath = dstPath.substring(targetLiveCopy.getPath().length());
                    relation = new LiveRelationshipImpl(targetLiveCopy, syncPath);
                    isTargetFromDifferentTree = true;
                }
            } else if (target == null) {
                String parentDst;
                LiveCopy targetLiveCopy;
                int level = 1;
                if (dstPath.endsWith("/jcr:content")) {
                    level = 2;
                }
                if (!((targetLiveCopy = this.getLiveCopy(resolver.getResource(parentDst = Text.getRelativeParent((String)dstPath, (int)level)))) == null || liveCopy.getBlueprintPath().equals(targetLiveCopy.getBlueprintPath()) && liveCopy.getPath().equals(targetLiveCopy.getPath()))) {
                    String syncPath = dstPath.substring(targetLiveCopy.getPath().length());
                    relation = new LiveRelationshipImpl(targetLiveCopy, syncPath);
                    isTargetFromDifferentTree = true;
                }
            }
            LiveStatusImpl status = StatusUtil.createLiveStatus(resolver, relation.getSourcePath(), relation.getTargetPath(), relation.getLiveCopy().getPath(), advancedStatus);
            if (advancedStatus) {
                status.setAdvancedStatus("msm:isTargetFromDifferentTree", isTargetFromDifferentTree);
            }
            relation.setStatus(status);
            relation.setRolloutConfigs(this.computeRolloutConfigs(relation, resolver));
            relation.setComputationTime(-1);
            return relation;
        }
        catch (RepositoryException e) {
            throw new WCMException((Throwable)e);
        }
    }

    public static void removeMarker(Node targetNode) throws RepositoryException {
        if (targetNode.isNodeType("cq:LiveSyncCancelled")) {
            targetNode.removeMixin("cq:LiveSyncCancelled");
        }
        if (targetNode.hasProperty("cq:isCancelledForChildren")) {
            targetNode.getProperty("cq:isCancelledForChildren").remove();
        }
        if (targetNode.isNodeType("cq:PropertyLiveSyncCancelled")) {
            targetNode.removeMixin("cq:PropertyLiveSyncCancelled");
            if (targetNode.hasProperty("cq:propertyInheritanceCancelled")) {
                targetNode.getProperty("cq:propertyInheritanceCancelled").remove();
            }
        }
    }

    private List<RolloutConfig> computeRolloutConfigs(LiveRelationship relation, ResourceResolver resolver) throws WCMException, RepositoryException {
        String targetPath = Utils.getPagePath(relation.getTargetPath());
        LiveCopy lc = relation.getLiveCopy();
        if (lc.getPath().equals(targetPath) && !lc.getRolloutConfigs().isEmpty()) {
            return lc.getRolloutConfigs();
        }
        String sourcePath = Utils.getPagePath(relation.getSourcePath());
        Blueprint bp = this.blueprintManagerFactory.getBlueprintManager(resolver).getContainingBlueprint(sourcePath);
        List configs = this.inheritRolloutConfig(targetPath, sourcePath, lc, bp);
        while (configs == null && !lc.isRoot() && !targetPath.equals("/")) {
            targetPath = Text.getRelativeParent((String)targetPath, (int)1);
            sourcePath = Text.getRelativeParent((String)sourcePath, (int)1);
            lc = this.getContainingLiveCopy((Resource)new NonExistingResource(resolver, targetPath), resolver);
            configs = this.inheritRolloutConfig(targetPath, sourcePath, lc, bp);
        }
        if (configs == null) {
            RolloutConfig defaultConfig = this.liveCopyService.getRolloutConfig(this.defaultRolloutConfigPath, resolver);
            configs = defaultConfig == null ? Collections.emptyList() : Collections.singletonList(defaultConfig);
        }
        return configs;
    }

    private List<RolloutConfig> inheritRolloutConfig(String targetPath, String sourcePath, LiveCopy lc, Blueprint bp) throws WCMException {
        List rcs = null;
        boolean exhausted = lc.getPath().equals(targetPath);
        if (bp != null && Text.isDescendantOrEqual((String)bp.getSitePath(), (String)sourcePath)) {
            String srcPath;
            String string = srcPath = bp.getSitePath().equals(sourcePath) ? null : sourcePath.substring(bp.getSitePath().length() + 1);
            while (((rcs = bp.getBlueprintRolloutConfig(srcPath, true)) == null || exhausted) && srcPath != null) {
                srcPath = srcPath.lastIndexOf("/") > -1 ? srcPath.substring(0, srcPath.lastIndexOf("/")) : null;
                targetPath = Text.getRelativeParent((String)targetPath, (int)1);
                exhausted = !Text.isDescendantOrEqual((String)lc.getPath(), (String)targetPath);
                if (!exhausted) continue;
            }
        }
        if (!exhausted && rcs != null || lc.getRolloutConfigs().isEmpty()) {
            return rcs;
        }
        return lc.getRolloutConfigs();
    }

    private LiveCopyManagerImpl.LiveCopyImpl getContainingLiveCopy(Resource resource, ResourceResolver resolver) throws RepositoryException, WCMException {
        assert (resource != null);
        if (ResourceUtil.isStarResource((Resource)resource)) {
            String parentPath = resource.getPath();
            if ((resource = resource.getParent()) == null) {
                log.warn("StarResource given at {}: no parent: no LiveCopy", (Object)parentPath);
                return null;
            }
        }
        return this.liveCopyService.createLiveCopyManager(resolver).getContainingLiveCopy(resource.getPath());
    }

    private boolean isManuallyCreated(Node target) throws RepositoryException {
        return target == null || !target.isNodeType("cq:LiveRelationship");
    }

    /*
     * Enabled force condition propagation
     * Lifted jumps to return sites
     */
    private static void markRelationship(Node node, boolean forceContent, boolean deep) throws RepositoryException {
        Node workingNode;
        try {
            workingNode = Utils.getWorkingNode(node);
        }
        catch (ItemNotFoundException e) {
            if (forceContent) {
                workingNode = node.addNode("jcr:content", "nt:unstructured");
            }
            log.debug("No jcr:content on HierarchyItem: skip addition of liveRelation on {}", (Object)node.getPath());
            return;
        }
        if (!workingNode.isNodeType("cq:LiveSyncConfig") && !workingNode.isNodeType("cq:LiveRelationship")) {
            if (workingNode.canAddMixin("cq:LiveRelationship")) {
                workingNode.addMixin("cq:LiveRelationship");
                log.debug("Marked Node {} as LiveRelationship", (Object)workingNode.getPath());
            } else {
                log.debug("Not able to mark {} as {}", (Object)workingNode.getPath(), (Object)"cq:LiveRelationship");
            }
        }
        if (deep) {
            NodeIterator itr = node.getNodes();
            while (itr.hasNext()) {
                LiveRelationshipManagerImpl.markRelationship(itr.nextNode(), forceContent, true);
            }
            return;
        } else {
            if (workingNode.getPath().equals(node.getPath())) return;
            NodeIterator itr = workingNode.getNodes();
            while (itr.hasNext()) {
                LiveRelationshipManagerImpl.markRelationship(itr.nextNode(), forceContent, true);
            }
        }
    }

    private void checkCircularRelationship(String source, String target, boolean deep) throws RepositoryException, WCMException {
        ResourceResolver adminResolver = null;
        try {
            adminResolver = this.resolverFactory.getAdministrativeResourceResolver(null);
            if (this.liveCopyService.createLiveCopyManager(adminResolver).dependsOn(source, target, deep)) {
                throw new IllegalStateException(String.format("Can not establish Relation from %s -> %s: would be circular", source, target));
            }
        }
        catch (LoginException e) {
            throw new WCMException("Failed to access Repository", (Throwable)e);
        }
        finally {
            if (adminResolver != null) {
                adminResolver.close();
            }
        }
    }

    private static Iterator<Resource> pageToResourceIterator(Resource resource) {
        return resource.adaptTo(Page.class) == null ? resource.listChildren() : IteratorUtils.transformedIterator((Iterator)((Page)resource.adaptTo(Page.class)).listChildren(), (Transformer)new Transformer(){

            public Object transform(Object input) {
                return ((Page)input).adaptTo(Resource.class);
            }
        });
    }

    protected void bindBlueprintManagerFactory(BlueprintManagerFactory blueprintManagerFactory) {
        this.blueprintManagerFactory = blueprintManagerFactory;
    }

    protected void unbindBlueprintManagerFactory(BlueprintManagerFactory blueprintManagerFactory) {
        if (this.blueprintManagerFactory == blueprintManagerFactory) {
            this.blueprintManagerFactory = null;
        }
    }

    protected void bindResolverFactory(ResourceResolverFactory resourceResolverFactory) {
        this.resolverFactory = resourceResolverFactory;
    }

    protected void unbindResolverFactory(ResourceResolverFactory resourceResolverFactory) {
        if (this.resolverFactory == resourceResolverFactory) {
            this.resolverFactory = null;
        }
    }

    protected void bindLiveCopyService(LiveCopyServiceImpl liveCopyServiceImpl) {
        this.liveCopyService = liveCopyServiceImpl;
    }

    protected void unbindLiveCopyService(LiveCopyServiceImpl liveCopyServiceImpl) {
        if (this.liveCopyService == liveCopyServiceImpl) {
            this.liveCopyService = null;
        }
    }

    private class LiveRelationshipIterator
    implements RangeIterator {
        private final String sourcePath;
        private Iterator<LiveCopyManagerImpl.LiveCopyImpl> allLiveCopies;
        private final ResourceResolver resourceResolver;
        private final String targetFilter;
        private final RolloutManager.Trigger triggerFilter;
        private final LiveCopyManagerImpl lcm;
        private LiveRelationship next;
        private long pos;
        private int size;
        private HashSet<String> served;

        private LiveRelationshipIterator(Resource source, LiveCopyServiceImpl liveCopyService, String targetFilter, RolloutManager.Trigger triggerFilter) throws WCMException, RepositoryException {
            this.pos = -1;
            this.size = -1;
            this.served = new HashSet();
            this.targetFilter = targetFilter;
            this.triggerFilter = triggerFilter;
            this.sourcePath = source.getPath();
            this.resourceResolver = source.getResourceResolver();
            this.lcm = liveCopyService.createLiveCopyManager(this.resourceResolver);
            this.allLiveCopies = this.lcm.getDependentLiveCopies(this.sourcePath);
            this.seek();
        }

        private void seek() throws WCMException {
            while (this.next == null && this.allLiveCopies.hasNext()) {
                LiveCopyManagerImpl.LiveCopyImpl cand = this.allLiveCopies.next();
                if (this.targetFilter != null) {
                    String targetPath = cand.createCopyPath(this.sourcePath);
                    if (targetPath == null || !Text.isDescendantOrEqual((String)this.targetFilter, (String)targetPath) || this.served.contains(targetPath)) continue;
                    if (Text.isDescendantOrEqual((String)cand.getPath(), (String)this.targetFilter)) {
                        this.allLiveCopies = IteratorUtils.emptyIterator();
                    }
                }
                LiveRelationship rel = LiveRelationshipManagerImpl.this.buildRelationship(this.resourceResolver, cand, this.sourcePath.substring(cand.getBlueprintPath().length()), true);
                if (this.triggerFilter != null && !rel.isTrigger(this.triggerFilter)) continue;
                if (this.targetFilter != null) {
                    this.served.add(rel.getTargetPath());
                }
                this.next = rel;
                ++this.pos;
            }
        }

        public void skip(long skipNum) {
            for (long i = 0; i < skipNum; ++i) {
                this.next();
            }
        }

        public long getSize() {
            if (this.targetFilter == null && this.size == -1) {
                try {
                    this.size = IteratorUtils.toList(this.lcm.getDependentLiveCopies(this.sourcePath)).size();
                }
                catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
            return this.size;
        }

        public long getPosition() {
            return this.pos;
        }

        public boolean hasNext() {
            return this.next != null;
        }

        public Object next() {
            if (this.next == null) {
                throw new NoSuchElementException("Call hasNext first");
            }
            LiveRelationship ret = this.next;
            this.next = null;
            try {
                this.seek();
            }
            catch (WCMException e) {
                throw new RuntimeException((Throwable)e);
            }
            return ret;
        }

        public void remove() {
            throw new UnsupportedOperationException("Result can not be modified");
        }
    }

}