MongoDBResourceProvider.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.
 */
package org.apache.sling.mongodb.impl;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;

import javax.servlet.http.HttpServletRequest;

import org.apache.sling.api.resource.ModifyingResourceProvider;
import org.apache.sling.api.resource.PersistenceException;
import org.apache.sling.api.resource.QueriableResourceProvider;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceProvider;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ValueMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.mongodb.BasicDBObject;
import com.mongodb.BasicDBObjectBuilder;
import com.mongodb.CommandResult;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.QueryBuilder;
import com.mongodb.util.JSON;

/**
 * The MongoDB resource provider creates resources based on MongoDB entries.
 * The resources contain all properties stored in the MongoDB except those starting with a "_".
 */
public class MongoDBResourceProvider implements ResourceProvider, ModifyingResourceProvider, QueriableResourceProvider {

    /** The special path property containing the (relative) path of the resource in the tree. */
    private static final String PROP_PATH = "_path";

    /** The id property. */
    private static final String PROP_ID = "_id";

    /** Logger. */
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    /** The global context .*/
    private final MongoDBContext context;

    private final Map<String, MongoDBResource> changedResources = new HashMap<String, MongoDBResource>();

    private final Set<String> deletedResources = new HashSet<String>();

    public MongoDBResourceProvider(final MongoDBContext context) {
        this.context = context;
    }

    public static String propNameToKey(final String name) {
        if ( name.startsWith("_") ) {
            return "_" + name;
        }
        return name;
    }

    public static String keyToPropName(final String key) {
        if ( key.startsWith("__") ) {
            return key.substring(1);
        } else if ( key.startsWith("_") ) {
            return null;
        }
        return key;
    }

    /**
     * @see org.apache.sling.api.resource.ModifyingResourceProvider#create(org.apache.sling.api.resource.ResourceResolver, java.lang.String, java.util.Map)
     */
    public Resource create(final ResourceResolver resolver, final String path, final Map<String, Object> properties)
            throws PersistenceException {
        final String[] info = this.extractResourceInfo(path);
        if ( info != null && info.length == 2) {
            final boolean deleted = this.deletedResources.remove(path);
            final MongoDBResource oldResource = (MongoDBResource)this.getResource(resolver, path, info);
            if ( !deleted && oldResource != null ) {
                throw new PersistenceException("Resource already exists at " + path, null, path, null);
            }
            final DBObject dbObj = new BasicDBObject();
            dbObj.put(getPROP_PATH(), info[1]);
            if ( properties != null ) {
                for(Map.Entry<String, Object> entry : properties.entrySet()) {
                    final String key = propNameToKey(entry.getKey());
                    dbObj.put(key, entry.getValue());
                }
            }
            if ( deleted && oldResource != null ) {
                dbObj.put(PROP_ID, oldResource.getProperties().get(PROP_ID));
            }
            final MongoDBResource rsrc = new MongoDBResource(resolver, path, info[0], dbObj, this);
            this.changedResources.put(path, rsrc);

            return rsrc;
        }
        throw new PersistenceException("Illegal path - unable to create resource at " + path, null, path, null);
    }

    /**
     * TODO - we should handle delete different and not put all child resources into the
     * deleted set.
     * Instead when getting resources, the parents of the resource should be checked
     * first.
     * This minimizes concurrency issues.
     * @see org.apache.sling.api.resource.ModifyingResourceProvider#delete(org.apache.sling.api.resource.ResourceResolver, java.lang.String)
     */
    public void delete(final ResourceResolver resolver, final String path)
            throws PersistenceException {
        final String[] info = this.extractResourceInfo(path);
        if ( info != null ) {
            boolean deletedResource = false;
            if ( !deletedResources.contains(path) ) {
                final Resource rsrc = this.getResource(resolver, path, info);
                if ( rsrc instanceof MongoDBResource ) {
                    this.deletedResources.add(path);
                    this.changedResources.remove(path);

                    final DBCollection col = this.getCollection(info[0]);
                    final String pattern = "^" + Pattern.quote(info[1]) + "/";

                    final DBObject query = QueryBuilder.start(getPROP_PATH()).regex(Pattern.compile(pattern)).get();
                    final DBCursor cur = col.find(query);
                    while ( cur.hasNext() ) {
                        final DBObject dbObj = cur.next();
                        final String childPath = info[0] + '/' + dbObj.get(getPROP_PATH());
                        this.deletedResources.add(childPath);
                        this.changedResources.remove(childPath);
                    }
                    deletedResource = true;
                }
            } else {
                deletedResource = true;
            }
            if ( deletedResource ) {
                final String prefix = path + "/";
                final Iterator<Map.Entry<String, MongoDBResource>> i = this.changedResources.entrySet().iterator();
                while ( i.hasNext() ) {
                    final Map.Entry<String, MongoDBResource> entry = i.next();
                    if ( entry.getKey().startsWith(prefix) ) {
                        i.remove();
                    }
                }
                return;
            }

        }
        throw new PersistenceException("Unable to delete resource at {}" + path, null, path, null);
    }

    /**
     * @see org.apache.sling.api.resource.ModifyingResourceProvider#revert(ResourceResolver)
     */
    public void revert(final ResourceResolver resolver) {
        this.changedResources.clear();
        this.deletedResources.clear();
    }

    /**
     * @see org.apache.sling.api.resource.ModifyingResourceProvider#commit(ResourceResolver)
     */
    public void commit(final ResourceResolver resolver) throws PersistenceException {
        try {
            for(final String deleted : this.deletedResources) {
                final String[] info = this.extractResourceInfo(deleted);

                // check if the collection still exists
                final DBCollection col = this.getCollection(info[0]);
                if ( col != null ) {
                    if ( col.findAndRemove(QueryBuilder.start(getPROP_PATH()).is(info[1]).get()) != null ) {
                        this.context.notifyRemoved(info);
                    }
                }
            }
            for(final MongoDBResource changed : this.changedResources.values()) {

                final DBCollection col = this.context.getDatabase().getCollection(changed.getCollection());
                if ( col != null ) {
                    final String[] info = new String[] {changed.getCollection(),
                            changed.getProperties().get(getPROP_PATH()).toString()};
                    // create or update?
                    if ( changed.getProperties().get(PROP_ID) != null ) {
                        col.update(QueryBuilder.start(getPROP_PATH()).is(changed.getProperties().get(getPROP_PATH())).get(),
                                changed.getProperties());
                        this.context.notifyUpdated(info);
                    } else {
                        // create
                        col.save(changed.getProperties());
                        this.context.notifyUpdated(info);
                    }
                } else {
                    throw new PersistenceException("Unable to create collection " + changed.getCollection(), null, changed.getPath(), null);
                }
            }
        } finally {
            this.revert(resolver);
        }
    }

    /**
     * @see org.apache.sling.api.resource.ModifyingResourceProvider#hasChanges(ResourceResolver)
     */
    public boolean hasChanges(final ResourceResolver resolver) {
        return this.changedResources.size() > 0 || this.deletedResources.size() > 0;
    }

    /**
     * @see org.apache.sling.api.resource.ResourceProvider#getResource(org.apache.sling.api.resource.ResourceResolver, java.lang.String)
     */
    public Resource getResource(final ResourceResolver resourceResolver, final String path) {
        if ( this.deletedResources.contains(path) ) {
            return null;
        }
        if ( this.changedResources.containsKey(path) ) {
            return new MongoDBResource(this.changedResources.get(path));
        }
        final String[] info = this.extractResourceInfo(path);
        if ( info != null ) {
            return this.getResource(resourceResolver, path, info);
        }
        return null;
    }

    /**
     * Inform about changes of a resource.
     */
    public void changed(final MongoDBResource resource) {
        this.deletedResources.remove(resource.getPath());
        this.changedResources.put(resource.getPath(), resource);
    }

    /**
     * TODO - we have to check for deleted and added resources
     * @see org.apache.sling.api.resource.ResourceProvider#listChildren(org.apache.sling.api.resource.Resource)
     */
    public Iterator<Resource> listChildren(final Resource parent) {
        final String[] info = this.extractResourceInfo(parent.getPath());
        if ( info != null ) {
            if ( info.length == 0 ) {
                // all collections
                final Set<String> names = new HashSet<String>(context.getDatabase().getCollectionNames());
                names.removeAll(this.context.getFilterCollectionNames());
                final Iterator<String> i = names.iterator();
                return new Iterator<Resource>() {

                    public boolean hasNext() {
                        return i.hasNext();
                    }

                    public Resource next() {
                        final String name = i.next();
                        return new MongoDBCollectionResource(parent.getResourceResolver(), parent.getPath() + '/' + name);
                    }

                    public void remove() {
                        throw new UnsupportedOperationException("remove");
                    }

                };
            }
            final DBCollection col = this.getCollection(info[0]);
            if ( col != null ) {
                final String pattern;
                if ( info.length == 1 ) {
                    pattern = "^([^/])*$";
                } else {
                    pattern = "^" + Pattern.quote(info[1]) + "/([^/])*$";
                }

                final DBObject query = QueryBuilder.start(getPROP_PATH()).regex(Pattern.compile(pattern)).get();
                final DBCursor cur = col.find(query).
                        sort(BasicDBObjectBuilder.start(getPROP_PATH(), 1).get());
                return new Iterator<Resource>() {

                    public boolean hasNext() {
                        return cur.hasNext();
                    }

                    public Resource next() {
                        final DBObject obj = cur.next();
                        final String objPath = obj.get(getPROP_PATH()).toString();
                        final int lastSlash = objPath.lastIndexOf('/');
                        final String name;
                        if (lastSlash == -1) {
                            name = objPath;
                        } else {
                            name = objPath.substring(lastSlash + 1);
                        }
                        return new MongoDBResource(parent.getResourceResolver(),
                                parent.getPath() + '/' + name,
                                info[0],
                                obj,
                                MongoDBResourceProvider.this);
                    }

                    public void remove() {
                        throw new UnsupportedOperationException("remove");
                    }

                };
            }
        }
        return null;
    }

    /**
     * @see org.apache.sling.api.resource.ResourceProvider#getResource(org.apache.sling.api.resource.ResourceResolver, javax.servlet.http.HttpServletRequest, java.lang.String)
     */
    @SuppressWarnings("javadoc")
    public Resource getResource(final ResourceResolver resourceResolver,
            final HttpServletRequest request,
            final String path) {
        return this.getResource(resourceResolver, path);
    }

    /**
     * Extract info about collection and path
     */
    protected String[] extractResourceInfo(final String path) {
        if ( path.startsWith(this.context.getRootWithSlash()) ) {
            if ( path.length() == this.context.getRootWithSlash().length() ) {
                // special resource - show all collections
                return new String[0];
            }
            final String info = path.substring(this.context.getRootWithSlash().length());
            final int slashPos = info.indexOf('/');
            if ( slashPos != -1 ) {
                return new String[] {info.substring(0, slashPos), info.substring(slashPos + 1)};
            }
            // special resource - collection
            return new String[] {info};
        }

        if ( path.equals(this.context.getRoot()) ) {
            // special resource - show all collections
            return new String[0];
        }

        return null;
    }

    /**
     * Check if a collection with a given name exists
     */
    protected boolean hasCollection(final String name) {
        logger.info("Mongo: Getting collection names");
        final Set<String> names = this.context.getDatabase().getCollectionNames();
        return names.contains(name) && !this.context.isFilterCollectionName(name);
    }


    /**
     * Check if a collection with a given name exists and return it
     */
    protected DBCollection getCollection(final String name) {
        if ( this.hasCollection(name) ) {
            return this.context.getDatabase().getCollection(name);
        }
        return null;
    }

    /**
     * Get a resource
     */
    protected Resource getResource(final ResourceResolver resourceResolver, final String path, final String[] info) {
        if ( info.length == 0 ) {
            // special resource : all collections
            return new MongoDBCollectionResource(resourceResolver, path);
        } else if ( info.length == 1 ) {
            // special resource : collection
            if ( this.hasCollection(info[0]) ) {
                return new MongoDBCollectionResource(resourceResolver, path);
            }
            return null;
        }
        logger.debug("Searching {} in {}", info[1], info[0]);
        final DBCollection col = this.getCollection(info[0]);
        if ( col != null ) {
            final DBObject obj = col.findOne(QueryBuilder.start(getPROP_PATH()).is(info[1]).get());
            logger.debug("Found {}", obj);
            if ( obj != null ) {
                return new MongoDBResource(resourceResolver,
                        path,
                        info[0],
                        obj,
                        this);
            }
        }

        return null;
    }

    /**
     * Check if there is a newer db object for that path.
     */
    public DBObject getUpdatedDBObject(final String path, final DBObject dbObj) {
        final MongoDBResource stored = this.changedResources.get(path);
        if ( stored != null ) {
            return stored.getProperties();
        }
        return dbObj;
    }

    protected Set<String> getDeletedResources() {
        return this.deletedResources;
    }

    protected Map<String, MongoDBResource> getChangedResources() {
        return this.changedResources;
    }

    protected MongoDBContext getContext() {
        return this.context;
    }

    protected String getPROP_PATH() {
        return PROP_PATH;
    }

    public Iterator<Resource> findResources(final ResourceResolver resolver, String query, String language) {
        if ( !language.equals( "mongodb") || query == null || query.length() == 0 || query.indexOf( ".find(" ) <= 0 )
        {
            return null;
        }
        Iterator<Resource> returnValue = null;
        final String collectionName = query.substring( 0, query.indexOf( ".find(" ) );
        DBCollection col = this.getCollection( collectionName );
        if ( col != null )
        {
            String criteria = query.trim().substring( query.indexOf( ".find(" ) + 6, query.length() - 1 );
            DBObject dbObject = (DBObject) JSON.parse( criteria );
            final DBCursor cur = col.find( dbObject );
            final String rootPath = context.getRootWithSlash();
            
            return new Iterator<Resource>() {

                public boolean hasNext() {
                    return cur.hasNext();
                }

                public Resource next() {
                    final DBObject obj = cur.next();
                    final String objPath = obj.get(getPROP_PATH()).toString();
                    final int lastSlash = objPath.lastIndexOf('/');
                    final String name;
                    if (lastSlash == -1) {
                        name = objPath;
                    } else {
                        name = objPath.substring(lastSlash + 1);
                    }
                    return new MongoDBResource(resolver,
                            rootPath + collectionName + "/" + name,
                            collectionName,
                            obj,
                            MongoDBResourceProvider.this);
                }

                public void remove() {
                    throw new UnsupportedOperationException("remove");
                }

            };
        }
        
        return returnValue;
    }

    public Iterator<ValueMap> queryResources(ResourceResolver resolver, String query, String language) {
        return null;
    }
}