trunk/src/modules/sourcerepository/java/src/org/apache/lenya/cms/repository/SourceNodeRCML.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

/* $Id: RCML.java 473861 2006-11-12 03:51:14Z gregor $  */

package org.apache.lenya.cms.repository;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import org.apache.avalon.framework.service.ServiceManager;
import org.apache.excalibur.source.SourceResolver;
import org.apache.lenya.cms.cocoon.source.SourceUtil;
import org.apache.lenya.cms.rc.CheckInEntry;
import org.apache.lenya.cms.rc.CheckOutEntry;
import org.apache.lenya.cms.rc.RCML;
import org.apache.lenya.cms.rc.RCMLEntry;
import org.apache.lenya.cms.rc.RevisionControlException;
import org.apache.lenya.util.Assert;
import org.apache.lenya.xml.DocumentHelper;
import org.apache.lenya.xml.NamespaceHelper;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * Handle with the RCML file
 */
public class SourceNodeRCML implements RCML {

    protected static final String NAMESPACE = "";

    private boolean dirty = false;
    private int maximalNumberOfEntries = 5;
    private Vector entries;

    private ServiceManager manager;

    private String contentSourceUri;
    private String metaSourceUri;

    private static Map ELEMENTS = new HashMap();
    protected static final String ELEMENT_CHECKIN = "CheckIn";
    protected static final String ELEMENT_CHECKOUT = "CheckOut";
    protected static final String ELEMENT_BACKUP = "Backup";
    protected static final String ELEMENT_TIME = "Time";
    protected static final String ELEMENT_VERSION = "Version";
    protected static final String ELEMENT_IDENTITY = "Identity";
    protected static final String ELEMENT_XPSREVISIONCONTROL = "XPSRevisionControl";
    protected static final String ELEMENT_SESSION = "session";

    protected static final String ATTR_BACKUP = "backup";
    protected static final String ATTR_TIME = "time";
    protected static final String ATTR_VERSION = "version";
    protected static final String ATTR_IDENTITY = "identity";
    protected static final String ATTR_SESSION = "session";

    {
        ELEMENTS.put(new Short(ci), ELEMENT_CHECKIN);
        ELEMENTS.put(new Short(co), ELEMENT_CHECKOUT);
    }

    /**
     * @param contentSourceUri The content source URI.
     * @param metaSourceUri The meta source URI.
     * @param manager The service manager.
     */
    public SourceNodeRCML(String contentSourceUri, String metaSourceUri, ServiceManager manager) {
        this.maximalNumberOfEntries = 200;
        this.maximalNumberOfEntries = (2 * this.maximalNumberOfEntries) + 1;
        this.manager = manager;
        this.contentSourceUri = contentSourceUri;
        this.metaSourceUri = metaSourceUri;
    }

    protected static final String RCML_EXTENSION = ".rcml";

    private static final String ALL_SESSIONS = "unrestricted";

    protected String getRcmlSourceUri() {
        return this.contentSourceUri + RCML_EXTENSION;
    }

    /**
     * Call the method write, if the document is dirty
     * 
     * @throws IOException if an error occurs
     * @throws Exception if an error occurs
     */
    protected void finalize() throws IOException, Exception {
        if (this.isDirty()) {
            write();
        }
    }

    /**
     * Write the XML RCML-document in the RCML-file.
     * @throws RevisionControlException if an error occurs
     */
    public synchronized void write() throws RevisionControlException {
        NamespaceHelper helper = saveToXml();
        Assert.notNull("XML document", helper);
        try {
            SourceUtil.writeDOM(helper.getDocument(), getRcmlSourceUri(), this.manager);
        } catch (Exception e) {
            throw new RevisionControlException(e);
        }
        clearDirty();
    }

    /**
     * Write a new entry for a check out or a check in the RCML-File made by the user with identity
     * at time
     * @param node The node.
     * @param type co for a check out, ci for a check in
     * @param time
     * @param backup Create backup element (only considered for check-in entries).
     * @param newVersion If the revision number shall be increased (only considered for check-in
     *        entries).
     * @param restrictedToSession If the check-out is restricted to the session (only considered for
     *        check-out entries).
     * @throws RevisionControlException if an error occurs
     */
    public synchronized void checkOutIn(Node node, short type, long time, boolean backup,
            boolean newVersion, boolean restrictedToSession) throws RevisionControlException {

        String identity = node.getSession().getIdentity().getUser().getId();

        Vector entries = getEntries();
        if (entries.size() == 0) {
            if (type == ci) {
                throw new IllegalStateException("Can't check in - not checked out.");
            }
        } else {
            RCMLEntry latestEntry = getLatestEntry();
            if (type == latestEntry.getType()) {
                String elementName = (String) ELEMENTS.get(new Short(type));
                throw new IllegalStateException("RCML entry type <" + elementName
                        + "> not allowed twice in a row. Before: [" + latestEntry.getIdentity()
                        + "], now: [" + identity + "], node: [" + this.contentSourceUri + "]");
            }
        }

        String sessionId;
        if (type == RCML.co && !restrictedToSession) {
            sessionId = ALL_SESSIONS;
        }
        else {
            sessionId = node.getSession().getId();
        }

        RCMLEntry entry;
        switch (type) {
        case RCML.ci:
            int version = 0;
            CheckInEntry latestEntry = getLatestCheckInEntry();
            if (latestEntry != null) {
                version = latestEntry.getVersion();
            }
            if (newVersion) {
                version++;
            }
            entry = new CheckInEntry(sessionId, identity, time, version, backup);
            break;
        case RCML.co:
            entry = new CheckOutEntry(sessionId, identity, time);
            break;
        default:
            throw new IllegalArgumentException("No such type: [" + type + "]");
        }

        entries.add(0, entry);
        setDirty();
    }

    protected Element saveToXml(NamespaceHelper helper, RCMLEntry entry)
            throws RevisionControlException {
        String elementName = (String) ELEMENTS.get(new Short(entry.getType()));
        Element entryElement = helper.createElement(elementName);

        entryElement.setAttribute(ATTR_IDENTITY, entry.getIdentity());
        entryElement.setAttribute(ATTR_SESSION, entry.getSessionId());
        entryElement.setAttribute(ATTR_TIME, Long.toString(entry.getTime()));

        if (entry.getType() == ci) {
            CheckInEntry checkInEntry = (CheckInEntry) entry;
            entryElement.setAttribute(ATTR_VERSION, Integer.toString(checkInEntry.getVersion()));
            if (checkInEntry.hasBackup()) {
                entryElement.setAttribute(ATTR_BACKUP, "true");
            }
        }

        return entryElement;
    }

    protected NamespaceHelper saveToXml() throws RevisionControlException {
        try {
            NamespaceHelper helper = new NamespaceHelper(NAMESPACE, "", ELEMENT_XPSREVISIONCONTROL);
            Element root = helper.getDocument().getDocumentElement();
            Vector entries = getEntries();
            for (Iterator i = entries.iterator(); i.hasNext();) {
                RCMLEntry entry = (RCMLEntry) i.next();
                Element element = saveToXml(helper, entry);
                root.appendChild(element);
            }
            return helper;
        } catch (Exception e) {
            throw new RevisionControlException("Could create revision control XML ["
                    + getRcmlSourceUri() + "]", e);
        }
    }

    protected Element getLatestElement(NamespaceHelper helper, String type)
            throws RevisionControlException {
        Element parent = helper.getDocument().getDocumentElement();
        return helper.getFirstChild(parent, type);
    }

    /**
     * get the latest check out
     * @return CheckOutEntry The entry of the check out
     * @throws RevisionControlException if an error occurs
     */
    public CheckOutEntry getLatestCheckOutEntry() throws RevisionControlException {
        return (CheckOutEntry) getLatestEntry(RCML.co);
    }

    /**
     * get the latest check in
     * @return CheckInEntry The entry of the check in
     * @throws RevisionControlException if an error occurs
     */
    public CheckInEntry getLatestCheckInEntry() throws RevisionControlException {
        return (CheckInEntry) getLatestEntry(RCML.ci);
    }

    /**
     * get the latest entry (a check out or check in)
     * @param type The type.
     * @return RCMLEntry The entry of the check out/in
     * @throws RevisionControlException if an error occurs
     */
    public RCMLEntry getLatestEntry(short type) throws RevisionControlException {
        Vector entries = getEntries();
        for (Iterator i = entries.iterator(); i.hasNext();) {
            RCMLEntry entry = (RCMLEntry) i.next();
            if (entry.getType() == type) {
                return entry;
            }
        }
        return null;
    }

    public RCMLEntry getLatestEntry() throws RevisionControlException {
        Vector entries = getEntries();
        if (entries.isEmpty()) {
            return null;
        } else {
            return (RCMLEntry) entries.firstElement();
        }
    }

    protected RCMLEntry getEntry(NamespaceHelper helper, Element element) {
        if (element.hasAttribute(ATTR_IDENTITY)) {
            String type = element.getLocalName();
            String sessionId = element.getAttribute(ATTR_SESSION);
            String identity = element.getAttribute(ATTR_IDENTITY);
            String timeString = element.getAttribute(ATTR_TIME);
            long time = new Long(timeString).longValue();
            if (type.equals(ELEMENT_CHECKIN)) {
                String versionString = element.getAttribute(ATTR_VERSION);
                int version = new Integer(versionString).intValue();
                boolean backup = element.hasAttribute(ATTR_BACKUP);
                return new CheckInEntry(sessionId, identity, time, version, backup);
            } else if (type.equals(ELEMENT_CHECKOUT)) {
                return new CheckOutEntry(sessionId, identity, time);
            } else {
                throw new RuntimeException("Unsupported RCML entry type: [" + type + "]");
            }
        } else {
            return getLegacyEntry(helper, element);
        }
    }

    protected RCMLEntry getLegacyEntry(NamespaceHelper helper, Element element) {
        String type = element.getLocalName();
        String sessionId = getChildValue(helper, element, ELEMENT_SESSION, "");
        String identity = getChildValue(helper, element, ELEMENT_IDENTITY);
        String timeString = getChildValue(helper, element, ELEMENT_TIME);
        long time = new Long(timeString).longValue();
        if (type.equals(ELEMENT_CHECKIN)) {
            String versionString = getChildValue(helper, element, ELEMENT_VERSION);
            int version = new Integer(versionString).intValue();
            boolean backup = helper.getChildren(element, ELEMENT_BACKUP).length > 0;
            return new CheckInEntry(sessionId, identity, time, version, backup);
        } else if (type.equals(ELEMENT_CHECKOUT)) {
            return new CheckOutEntry(sessionId, identity, time);
        } else {
            throw new RuntimeException("Unsupported RCML entry type: [" + type + "]");
        }
    }

    protected String getChildValue(NamespaceHelper helper, Element element, String childName,
            String defaultValue) {
        Element child = DocumentHelper.getFirstChild(element, NAMESPACE, childName);
        if (child == null) {
            return defaultValue;
        } else {
            return DocumentHelper.getSimpleElementText(child);
        }
    }

    protected String getChildValue(NamespaceHelper helper, Element element, String childName) {
        Element child = helper.getFirstChild(element, childName);
        if (child == null) {
            throw new RuntimeException("The element <" + element.getNodeName()
                    + "> has no child element <" + childName + ">. Source URI: ["
                    + getRcmlSourceUri() + "[");
        }
        return DocumentHelper.getSimpleElementText(child);
    }

    /**
     * get all check in and check out
     * @return Vector of all check out and check in entries in this RCML-file
     * @throws RevisionControlException if an error occurs
     */
    public synchronized Vector getEntries() throws RevisionControlException {
        if (this.entries == null) {
            this.entries = new Vector();
            String uri = getRcmlSourceUri();
            try {
                if (SourceUtil.exists(uri, this.manager)) {
                    Document xml = SourceUtil.readDOM(uri, this.manager);
                    NamespaceHelper helper = new NamespaceHelper(NAMESPACE, "", xml);
                    Element parent = xml.getDocumentElement();
                    Element[] elements = helper.getChildren(parent);
                    for (int i = 0; i < elements.length; i++) {
                        RCMLEntry entry = getEntry(helper, elements[i]);
                        entries.add(entry);
                    }
                }
            } catch (Exception e) {
                throw new RevisionControlException(e);
            }
        }
        return this.entries;
    }

    /**
     * get all backup entries
     * @return Vector of all entries in this RCML-file with a backup
     * @throws Exception if an error occurs
     */
    public synchronized Vector getBackupEntries() throws Exception {
        Vector entries = getEntries();
        Vector backupEntries = new Vector();
        for (Iterator i = entries.iterator(); i.hasNext();) {
            RCMLEntry entry = (RCMLEntry) i.next();
            if (entry.getType() == RCML.ci && ((CheckInEntry) entry).hasBackup()) {
                backupEntries.add(entry);
            }
        }
        return backupEntries;
    }

    public synchronized void makeBackup(long time) throws RevisionControlException {
        makeBackup(this.contentSourceUri, time);
        makeBackup(this.metaSourceUri, time);
    }

    protected synchronized void makeBackup(String sourceUri, long time)
            throws RevisionControlException {
        String backupSourceUri = getBackupSourceUri(sourceUri, time);
        try {
            if (SourceUtil.exists(sourceUri, manager)) {
                SourceUtil.copy(this.manager, sourceUri, backupSourceUri);
            }
        } catch (Exception e) {
            throw new RevisionControlException(e);
        }
    }

    public synchronized void restoreBackup(Node node, long time) throws RevisionControlException {
        SourceNode sourceNode = (SourceNode) node;
        restoreBackup(sourceNode.getContentSource(), time);
        restoreBackup(sourceNode.getMetaSource(), time);
    }

    protected synchronized void restoreBackup(SourceWrapper wrapper, long time)
            throws RevisionControlException {
        String backupSourceUri = getBackupSourceUri(wrapper, time);
        SourceResolver resolver = null;
        try {
            resolver = (SourceResolver) this.manager.lookup(SourceResolver.ROLE);
            SourceUtil.copy(resolver, backupSourceUri, wrapper.getOutputStream());
        } catch (Exception e) {
            throw new RevisionControlException(e);
        } finally {
            if (resolver != null) {
                this.manager.release(resolver);
            }
        }
    }

    protected String getBackupSourceUri(SourceWrapper wrapper, long time) {
        String uri = wrapper.getRealSourceUri();
        return getBackupSourceUri(uri, time);
    }

    protected String getBackupSourceUri(String uri, long time) {
        return uri + "." + time + ".bak";
    }

    /**
     * Prune the list of entries and delete the corresponding backups. Limit the number of entries
     * to the value maximalNumberOfEntries (2maxNumberOfRollbacks(configured)+1)
     * @throws RevisionControlException if an error occurs
     */
    public synchronized void pruneEntries() throws RevisionControlException {
        Vector entries = getEntries();
        RCMLEntry[] array = (RCMLEntry[]) entries.toArray(new RCMLEntry[entries.size()]);

        for (int i = this.maximalNumberOfEntries; i < entries.size(); i++) {
            // remove the backup file associated with this entry
            RCMLEntry entry = array[i];
            if (entry.getType() == ci && ((CheckInEntry) entry).hasBackup()) {
                long time = entry.getTime();
                deleteBackup(this.contentSourceUri, time);
                deleteBackup(this.metaSourceUri, time);
            }
            this.entries.remove(entry);
        }
        setDirty();
    }

    protected synchronized void deleteBackup(String sourceUri, long time)
            throws RevisionControlException {
        String uri = getBackupSourceUri(sourceUri, time);
        try {
            SourceUtil.delete(uri, this.manager);
            SourceUtil.deleteEmptyCollections(uri, this.manager);
        } catch (Exception e) {
            throw new RevisionControlException(e);
        }
    }

    /**
     * Check if the document is dirty
     * @return boolean dirty
     */
    public boolean isDirty() {
        return this.dirty;
    }

    /**
     * Set the value dirty to true
     */
    protected void setDirty() {
        this.dirty = true;
    }

    /**
     * Set the value dirty to false
     */
    protected void clearDirty() {
        this.dirty = false;
    }

    /**
     * get the time's value of the backups
     * @return String[] the times
     * @throws Exception if an error occurs
     */
    public String[] getBackupsTime() throws Exception {

        Vector entries = getEntries();
        List times = new ArrayList();
        for (Iterator i = entries.iterator(); i.hasNext();) {
            RCMLEntry entry = (RCMLEntry) i.next();
            if (entry.getType() == ci && ((CheckInEntry) entry).hasBackup()) {
                times.add(Long.toString(entry.getTime()));
            }
        }
        return (String[]) times.toArray(new String[times.size()]);

    }

    /**
     * Delete the revisions, the RCML source and the collection if the latter is empty.
     * @return boolean true, if the file was deleted
     */
    public synchronized boolean delete() {
        try {
            deleteRevisions();
            SourceUtil.delete(getRcmlSourceUri(), this.manager);
            SourceUtil.deleteEmptyCollections(getRcmlSourceUri(), this.manager);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return true;
    }

    /**
     * delete the revisions
     * @throws RevisionControlException when somthing went wrong
     */
    public synchronized void deleteRevisions() throws RevisionControlException {
        try {
            String[] times = getBackupsTime();
            for (int i = 0; i < times.length; i++) {
                long time = new Long(times[i]).longValue();
                deleteBackup(this.contentSourceUri, time);
                deleteBackup(this.metaSourceUri, time);
            }
            this.entries.clear();
        } catch (Exception e) {
            throw new RevisionControlException(e);
        }
    }

    public synchronized void copyFrom(Node node, Node otherNode) throws RevisionControlException {

        SourceNode otherSourceNode = (SourceNode) otherNode;
        SourceNode sourceNode = (SourceNode) node;
        SourceNodeRCML otherRcml = (SourceNodeRCML) ((SourceNode) otherNode).getRcml();

        try {

            Vector backupEntries = otherRcml.getBackupEntries();
            for (Iterator i = backupEntries.iterator(); i.hasNext();) {
                RCMLEntry entry = (RCMLEntry) i.next();
                long time = entry.getTime();
                String otherContentUri = otherRcml.getBackupSourceUri(otherSourceNode
                        .getContentSource(), time);
                String thisContentUri = this
                        .getBackupSourceUri(sourceNode.getContentSource(), time);
                SourceUtil.copy(this.manager, otherContentUri, thisContentUri);

                String otherMetaUri = otherRcml.getBackupSourceUri(otherSourceNode.getMetaSource(),
                        time);
                String thisMetaUri = this.getBackupSourceUri(sourceNode.getMetaSource(), time);
                SourceUtil.copy(this.manager, otherMetaUri, thisMetaUri);
            }

            this.entries = new Vector();
            Vector otherEntries = otherRcml.getEntries();
            for (Iterator i = otherEntries.iterator(); i.hasNext();) {
                RCMLEntry entry = (RCMLEntry) i.next();
                RCMLEntry newEntry = null;
                switch (entry.getType()) {
                case co:
                    newEntry = new CheckOutEntry(entry.getSessionId(), entry.getIdentity(), entry
                            .getTime());
                    break;
                case ci:
                    CheckInEntry ciEntry = (CheckInEntry) entry;
                    newEntry = new CheckInEntry(ciEntry.getSessionId(), ciEntry.getIdentity(),
                            ciEntry.getTime(), ciEntry.getVersion(), ciEntry.hasBackup());
                    break;
                }
                this.entries.add(newEntry);
            }

            write();
        } catch (Exception e) {
            throw new RevisionControlException(e);
        }
    }

    public synchronized boolean isCheckedOut() throws RevisionControlException {
        RCMLEntry entry = getLatestEntry();
        return entry != null && entry.getType() == RCML.co;
    }

    public synchronized void checkIn(Node node, boolean backup, boolean newVersion)
            throws RevisionControlException {
        long time = new Date().getTime();

        if (backup) {
            makeBackup(time);
        }

        checkOutIn(node, RCML.ci, time, backup, newVersion, false);
        pruneEntries();
        write();
    }

    public synchronized void checkOut(Node node) throws RevisionControlException {
        checkOut(node, true);
    }

    public synchronized void checkOut(Node node, boolean restrictedToSession)
            throws RevisionControlException {
        checkOutIn(node, RCML.co, new Date().getTime(), false, false, restrictedToSession);
        write();
    }

    public boolean isCheckedOutBySession(Session session) throws RevisionControlException {
        Vector entries = getEntries();
        if (entries.size() > 0) {
            RCMLEntry entry = (RCMLEntry) entries.get(0);
            String otherSessionId = entry.getSessionId();
            if (entry.getType() == co) {
                // not restricted to session
                if (otherSessionId.equals(ALL_SESSIONS)) {
                    String otherUserId = entry.getIdentity();
                    String userId = session.getIdentity().getUser().getId();
                    return userId.equals(otherUserId);
                }
                // restricted to session
                if (otherSessionId.equals(session.getId())) {
                    return true;
                }
            }
        }
        return false;
    }
    
}