Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.day.durbo.DurboNamespaceResolver
 *  com.day.durbo.DurboOutput
 *  javax.jcr.Item
 *  javax.jcr.NamespaceException
 *  javax.jcr.Node
 *  javax.jcr.NodeIterator
 *  javax.jcr.Property
 *  javax.jcr.PropertyIterator
 *  javax.jcr.RepositoryException
 *  javax.jcr.Session
 *  javax.jcr.Value
 *  javax.jcr.Workspace
 *  javax.jcr.nodetype.NodeType
 *  javax.jcr.version.Version
 *  javax.jcr.version.VersionException
 *  javax.jcr.version.VersionHistory
 *  javax.jcr.version.VersionManager
 *  org.apache.commons.io.IOUtils
 *  org.apache.felix.scr.annotations.Activate
 *  org.apache.felix.scr.annotations.Component
 *  org.apache.felix.scr.annotations.Properties
 *  org.apache.felix.scr.annotations.Property
 *  org.apache.felix.scr.annotations.Reference
 *  org.apache.felix.scr.annotations.Service
 *  org.apache.jackrabbit.commons.JcrUtils
 *  org.apache.sling.commons.osgi.PropertiesUtil
 *  org.apache.sling.jcr.api.SlingRepository
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.day.cq.replication.impl.content.durbo;

import com.day.cq.replication.ContentBuilder;
import com.day.cq.replication.ReplicationAction;
import com.day.cq.replication.ReplicationActionType;
import com.day.cq.replication.ReplicationContent;
import com.day.cq.replication.ReplicationContentFactory;
import com.day.cq.replication.ReplicationContentFilterChain;
import com.day.cq.replication.ReplicationException;
import com.day.cq.replication.impl.content.durbo.DurboUtil;
import com.day.durbo.DurboNamespaceResolver;
import com.day.durbo.DurboOutput;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.security.AccessControlException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import javax.jcr.Item;
import javax.jcr.NamespaceException;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.Property;
import javax.jcr.PropertyIterator;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.Value;
import javax.jcr.Workspace;
import javax.jcr.nodetype.NodeType;
import javax.jcr.version.Version;
import javax.jcr.version.VersionException;
import javax.jcr.version.VersionHistory;
import javax.jcr.version.VersionManager;
import org.apache.commons.io.IOUtils;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Properties;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.jackrabbit.commons.JcrUtils;
import org.apache.sling.commons.osgi.PropertiesUtil;
import org.apache.sling.jcr.api.SlingRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component
@Properties(value={@org.apache.felix.scr.annotations.Property(name="service.description", value={"Adobe Granite Durbo Content Builder"}), @org.apache.felix.scr.annotations.Property(name="name", value={"durbo"})})
@Service(value={ContentBuilder.class})
public class DurboContentBuilder
implements ContentBuilder {
    private static final String PN_CHILDREN_ORDER = "cq:childrenOrder";
    private static final String PN_SIBLING_ORDER = "cq:siblingOrder";
    public static final String NAME = "durbo";
    public static final String TITLE = "Durbo";
    private String name;
    private final Logger log;
    @Reference
    protected SlingRepository repository;

    public DurboContentBuilder() {
        this.log = LoggerFactory.getLogger(this.getClass());
    }

    @Activate
    protected void activate(Map<String, Object> props) {
        this.name = PropertiesUtil.toString((Object)props.get("name"), (String)"durbo");
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public String getTitle() {
        return "Durbo";
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    @Override
    public ReplicationContent create(Session session, ReplicationAction action, ReplicationContentFactory factory, Map<String, Object> parameters) throws ReplicationException {
        ReplicationContent replicationContent;
        block14 : {
            if (action.getType() != ReplicationActionType.ACTIVATE) {
                return ReplicationContent.VOID;
            }
            ReplicationContentFilterChain filters = parameters == null ? ReplicationContentFilterChain.ALLOW_ALL : (ReplicationContentFilterChain)parameters.get(ContentBuilder.PARAMETER_CONTENT_FILER_CHAIN);
            Node node = (Node)session.getItem(action.getPath());
            if (action.getRevision() == null) {
                return this.create(factory, node, filters, parameters);
            }
            Session admin = null;
            try {
                admin = this.repository.loginService("replicationService", null);
                node = admin.getNode(node.getPath());
                replicationContent = this.create(factory, node, action.getRevision(), filters, parameters);
                if (admin == null) break block14;
            }
            catch (Throwable var10_13) {
                try {
                    if (admin != null) {
                        try {
                            admin.logout();
                        }
                        catch (Exception var11_14) {
                            // empty catch block
                        }
                    }
                    throw var10_13;
                }
                catch (AccessControlException e) {
                    this.log.error("agent cannot access {}: {}", (Object)action.getPath(), (Object)e.getMessage());
                    throw new ReplicationException("Agent is unable to access " + action.getPath(), e);
                }
                catch (IOException io) {
                    this.log.error("IO exception occurred during serialization of content at {}.", (Object)action.getPath());
                    throw new ReplicationException("RepositoryException during serialization", io);
                }
                catch (RepositoryException e) {
                    this.log.error("Repository exception occurred during serialization of content at {}.", (Object)action.getPath());
                    throw new ReplicationException("RepositoryException during serialization", (Exception)e);
                }
            }
            try {
                admin.logout();
            }
            catch (Exception var9_12) {
                // empty catch block
            }
        }
        return replicationContent;
    }

    @Override
    public ReplicationContent create(Session session, ReplicationAction action, ReplicationContentFactory contentFactory) throws ReplicationException {
        return this.create(session, action, contentFactory, null);
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private ReplicationContent create(ReplicationContentFactory factory, Node node, ReplicationContentFilterChain filters, Map<String, Object> parameters) throws IOException, RepositoryException {
        File blob = null;
        FileOutputStream os = null;
        try {
            String childrenOrder;
            Object parentNodeType;
            boolean writeNodeProperties;
            StringBuilder nodePropertiesBuffer;
            String siblingOrder;
            StringBuilder nodeTypesBuffer;
            childrenOrder = DurboUtil.putNodeNames(node);
            nodeTypesBuffer = new StringBuilder();
            nodePropertiesBuffer = new StringBuilder();
            writeNodeProperties = false;
            Session admin = null;
            try {
                admin = this.repository.loginService("replicationService", null);
                Node parentNode = admin.getNode(node.getPath()).getParent();
                siblingOrder = DurboUtil.putNodeNames(parentNode);
                while (parentNode.getDepth() > 0) {
                    if (nodeTypesBuffer.length() > 0) {
                        nodeTypesBuffer.append(',');
                        nodePropertiesBuffer.append(',');
                    }
                    parentNodeType = parentNode.getPrimaryNodeType().getName();
                    String parentProperties = "";
                    if (DurboUtil.isAuthorizableNodeType((String)parentNodeType, 3)) {
                        String principalName = JcrUtils.getStringProperty((Node)parentNode, (String)"rep:principalName", (String)null);
                        String authorizableId = JcrUtils.getStringProperty((Node)parentNode, (String)"rep:authorizableId", (String)null);
                        String uuid = JcrUtils.getStringProperty((Node)parentNode, (String)"jcr:uuid", (String)null);
                        if (principalName != null && uuid != null) {
                            HashMap<String, String> propertiesMap = new HashMap<String, String>();
                            propertiesMap.put("rep:principalName", principalName);
                            if (authorizableId != null) {
                                propertiesMap.put("rep:authorizableId", authorizableId);
                            }
                            propertiesMap.put("jcr:uuid", uuid);
                            parentProperties = DurboUtil.urlEncodeMap(propertiesMap);
                            writeNodeProperties = true;
                        }
                    }
                    nodeTypesBuffer.append((String)parentNodeType);
                    nodePropertiesBuffer.append(parentProperties);
                    parentNode = parentNode.getParent();
                }
            }
            finally {
                if (admin != null) {
                    admin.logout();
                }
            }
            blob = File.createTempFile("cq5", ".durbo");
            os = new FileOutputStream(blob);
            DurboOutput output = new DurboOutput((OutputStream)os, (DurboNamespaceResolver)new DefaultDurboNamespaceResolver(node.getSession()), 2.1);
            output.writeProperty("orderSiblings", siblingOrder);
            output.writeProperty("orderChildren", childrenOrder);
            if (nodeTypesBuffer.length() > 0) {
                output.writeProperty("parentNodeTypes", nodeTypesBuffer.toString());
                if (writeNodeProperties) {
                    output.writeProperty("parentNodeProperties", nodePropertiesBuffer.toString());
                }
            }
            this.writeStartPath(parameters, output, node);
            this.write(output, node, filters, parameters);
            output.close();
            os.close();
            os = null;
            parentNodeType = factory.create("application/cq5-replication-durbo", blob, true);
            return parentNodeType;
        }
        finally {
            if (os != null) {
                IOUtils.closeQuietly((OutputStream)os);
                if (blob != null && !blob.delete()) {
                    throw new IOException("could not delete blob");
                }
            }
        }
    }

    private DurboOutput writeStartPath(Map<String, Object> parameters, DurboOutput output, Node node) throws RepositoryException, IOException {
        String startPathParam = (String)parameters.get("replicationStartPath");
        String startPath = startPathParam != null ? startPathParam : node.getPath();
        output.writeProperty("startPath", startPath);
        return output;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private ReplicationContent create(ReplicationContentFactory factory, Node node, String revision, ReplicationContentFilterChain filters, Map<String, Object> parameters) throws RepositoryException, IOException, ReplicationException {
        File blob = null;
        FileOutputStream os = null;
        try {
            boolean rootIsVersioned;
            VersionHistory history;
            Node content = node.hasNode("{http://www.jcp.org/jcr/1.0}content") ? node.getNode("{http://www.jcp.org/jcr/1.0}content") : null;
            StringBuilder nodeTypesBuffer = new StringBuilder();
            if (node.isNodeType("{http://www.jcp.org/jcr/mix/1.0}versionable")) {
                history = node.getSession().getWorkspace().getVersionManager().getVersionHistory(node.getPath());
                rootIsVersioned = true;
            } else if (content != null && content.isNodeType("{http://www.jcp.org/jcr/mix/1.0}versionable")) {
                history = content.getSession().getWorkspace().getVersionManager().getVersionHistory(content.getPath());
                rootIsVersioned = false;
            } else {
                throw new ReplicationException("Content node is not versionable at " + node.getPath());
            }
            Version version = null;
            try {
                version = history.getVersion(revision);
            }
            catch (VersionException var15_13) {
                // empty catch block
            }
            if (version == null) {
                try {
                    version = history.getVersionByLabel(revision);
                }
                catch (VersionException var15_14) {
                    // empty catch block
                }
            }
            if (version == null) {
                throw new ReplicationException("Version " + revision + " not found for path " + node.getPath());
            }
            Node root = version.getNode("{http://www.jcp.org/jcr/1.0}frozenNode");
            content = rootIsVersioned ? root.getNode("{http://www.jcp.org/jcr/1.0}content") : root;
            String childrenOrder = content.hasProperty("cq:childrenOrder") ? content.getProperty("cq:childrenOrder").getString() : DurboUtil.putNodeNames(node);
            Node parentNode = node.getParent();
            String siblingOrder = content.hasProperty("cq:siblingOrder") ? content.getProperty("cq:siblingOrder").getString() : DurboUtil.putNodeNames(parentNode);
            while (parentNode.getDepth() > 0) {
                if (nodeTypesBuffer.length() > 0) {
                    nodeTypesBuffer.append(',');
                }
                nodeTypesBuffer.append(parentNode.getPrimaryNodeType().getName());
                parentNode = parentNode.getParent();
            }
            blob = File.createTempFile("cq5", ".durbo");
            os = new FileOutputStream(blob);
            DurboOutput output = new DurboOutput((OutputStream)os, (DurboNamespaceResolver)new DefaultDurboNamespaceResolver(node.getSession()), 2.1);
            output.writeProperty("orderSiblings", siblingOrder);
            output.writeProperty("orderChildren", childrenOrder);
            if (nodeTypesBuffer.length() > 0) {
                output.writeProperty("parentNodeTypes", nodeTypesBuffer.toString());
            }
            this.writeStartPath(parameters, output, node);
            if (rootIsVersioned) {
                output.openNode(node.getName());
                this.write(output, root, false, filters, parameters);
                output.openNode("jcr:content");
                this.write(output, content, filters.allowDescent(content), filters, parameters);
                output.closeNode();
                output.closeNode();
            } else {
                output.openNode(node.getName());
                this.write(output, node, false, filters, parameters);
                output.openNode("jcr:content");
                this.write(output, content, filters.allowDescent(content), filters, parameters);
                output.closeNode();
                output.closeNode();
            }
            output.close();
            os.close();
            os = null;
            ReplicationContent replicationContent = factory.create("application/cq5-replication-durbo", blob, true);
            return replicationContent;
        }
        finally {
            if (os != null) {
                IOUtils.closeQuietly((OutputStream)os);
                if (blob != null && !blob.delete()) {
                    throw new IOException("could not delete blob");
                }
            }
        }
    }

    private void write(DurboOutput out, Node root, ReplicationContentFilterChain filters, Map<String, Object> parameters) throws IOException, RepositoryException {
        out.openNode(root.getName());
        this.write(out, root, false, filters, parameters);
        NodeIterator iter = root.getNodes();
        while (iter.hasNext()) {
            Node child = iter.nextNode();
            if (!filters.accept(child)) continue;
            out.openNode(child.getName());
            this.write(out, child, filters.allowDescent(child), filters, parameters);
            out.closeNode();
        }
        out.closeNode();
    }

    void write(DurboOutput out, Node node, boolean recursive, ReplicationContentFilterChain filters, Map<String, Object> parameters) throws IOException, RepositoryException {
        String[] mixinTypes;
        boolean isFrozen = this.isFrozenNode(node);
        out.writeProperty("jcr:primaryType", this.getPrimaryNodeType(node, isFrozen));
        if (node.isNodeType("{http://www.jcp.org/jcr/mix/1.0}referenceable")) {
            out.writeProperty("jcr:uuid", this.getUUID(node, isFrozen));
        }
        if ((mixinTypes = this.getMixinNodeTypes(node, isFrozen)) != null && mixinTypes.length > 0) {
            StringBuilder mixinTypeNames = new StringBuilder();
            for (String mix : mixinTypes) {
                mixinTypeNames.append(mix);
                mixinTypeNames.append(',');
            }
            out.writeProperty("jcr:mixinTypes", mixinTypeNames.toString());
        }
        PropertyIterator iter = node.getProperties();
        while (iter.hasNext()) {
            String propertyName;
            Property property = iter.nextProperty();
            if (!filters.accept(property) || DurboUtil.IGNORED_PROPERTIES.contains(propertyName = property.getName())) continue;
            out.writeProperty(property);
        }
        if (recursive) {
            iter = node.getNodes();
            while (iter.hasNext()) {
                Node child = iter.nextNode();
                if (!filters.accept(child)) continue;
                out.openNode(child.getName());
                this.write(out, child, filters.allowDescent(child), filters, parameters);
                out.closeNode();
            }
        }
    }

    /*
     * Enabled force condition propagation
     * Lifted jumps to return sites
     */
    String[] getMixinNodeTypes(Node node, boolean isFrozen) throws RepositoryException {
        NodeType[] mixins;
        ArrayList<String> mixinList = new ArrayList<String>();
        if (isFrozen) {
            Value[] vals;
            if (!node.hasProperty("{http://www.jcp.org/jcr/1.0}frozenMixinTypes")) return mixinList.toArray(new String[mixinList.size()]);
            Value[] arrvalue = vals = node.getProperty("{http://www.jcp.org/jcr/1.0}frozenMixinTypes").getValues();
            int n = arrvalue.length;
            int n2 = 0;
            while (n2 < n) {
                Value val = arrvalue[n2];
                mixinList.add(val.getString());
                ++n2;
            }
            return mixinList.toArray(new String[mixinList.size()]);
        }
        NodeType[] arrnodeType = mixins = node.getMixinNodeTypes();
        int n = arrnodeType.length;
        int n3 = 0;
        while (n3 < n) {
            NodeType mixin = arrnodeType[n3];
            mixinList.add(mixin.getName());
            ++n3;
        }
        return mixinList.toArray(new String[mixinList.size()]);
    }

    String getUUID(Node node, boolean isFrozen) throws RepositoryException {
        return isFrozen ? node.getProperty("{http://www.jcp.org/jcr/1.0}frozenUuid").getString() : node.getIdentifier();
    }

    String getPrimaryNodeType(Node node, boolean isFrozen) throws RepositoryException {
        return isFrozen ? node.getProperty("{http://www.jcp.org/jcr/1.0}frozenPrimaryType").getString() : node.getPrimaryNodeType().getName();
    }

    boolean isFrozenNode(Node node) throws RepositoryException {
        return node.isNodeType("{http://www.jcp.org/jcr/nt/1.0}frozenNode");
    }

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

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

    private static final class DefaultDurboNamespaceResolver
    implements DurboNamespaceResolver {
        private final Session session;

        private DefaultDurboNamespaceResolver(Session session) {
            this.session = session;
        }

        public String getURI(String prefix) throws NamespaceException {
            try {
                return this.session.getNamespaceURI(prefix);
            }
            catch (RepositoryException e) {
                throw new NamespaceException((Throwable)e);
            }
        }

        public String getPrefix(String uri) throws NamespaceException {
            try {
                return this.session.getNamespacePrefix(uri);
            }
            catch (RepositoryException e) {
                throw new NamespaceException((Throwable)e);
            }
        }
    }

}