src/main/java/org/apache/sling/installer/provider/jcr/impl/FolderNameFilter.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.installer.provider.jcr.impl;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/** Defines which folders are watched by JcrInstaller, based on
 * 	their names. To be accepted, a folder must have a name that
 *  matches the expression, followed by optional suffixes based
 *  on the current RunMode.
 *
 *  See {@link org.apache.sling.installer.provider.jcr.impl.FolderNameFilterTest} for details.
 */
class FolderNameFilter {
    private final Pattern pattern;
    private final String regexp;
    private final Set<String> runModes;
    private final String [] rootPaths;
    private final Map<String, Integer> rootPriorities = new HashMap<String, Integer>();
    private final Logger log = LoggerFactory.getLogger(getClass());

    /** getPriority computes priorities as follows: each root gets its own base priority,
     * 	and paths that match one or several run levels get an additional RUNMODE_PRIORITY_OFFSET
     *  per matched run level
     */
    public static final int RUNMODE_PRIORITY_BOOST = 1;
    public static final int DEFAULT_ROOT_PRIORITY = 99;

    FolderNameFilter(final String [] rootsConfig, final String regexp, final Set<String> runModes) {
        final List<RootPathInfo> rootPathInfos = new ArrayList<RootPathInfo>();
        this.regexp = regexp;
        this.pattern = Pattern.compile(regexp);
        this.runModes = runModes;

        // Each entry in rootsConfig is like /libs:100, where 100
        // is the priority.
        // Break that up into paths and priorities
        this.rootPaths = new String[rootsConfig.length];
        for(int i = 0; i < rootsConfig.length; i++) {
        	final String [] parts = rootsConfig[i].split(":");
        	this.rootPaths[i] = cleanupRootPath(parts[0]);
        	Integer priority = new Integer(DEFAULT_ROOT_PRIORITY);
        	if(parts.length > 1) {
        		try {
        			priority = Integer.parseInt(parts[1].trim());
        		} catch(NumberFormatException nfe) {
        			log.warn("Invalid priority in path definition '{}'", rootsConfig[i]);
        		}
        	}
        	rootPriorities.put(this.rootPaths[i], priority);
        	rootPathInfos.add(new RootPathInfo(this.rootPaths[i], priority));
        	log.debug("Root path {} has priority {}", this.rootPaths[i], priority);
        }
        // sort root paths by priority
        Collections.sort(rootPathInfos);
        int index = 0;
        for(final RootPathInfo rpi : rootPathInfos) {
            this.rootPaths[index++] = rpi.path;
        }
    }

    private static final class RootPathInfo implements Comparable<RootPathInfo> {

        public final String path;
        private final Integer priority;

        public RootPathInfo(final String path, final Integer prio) {
            this.path = path;
            this.priority = prio;
        }

        public int compareTo(RootPathInfo o) {
            int result = -this.priority.compareTo(o.priority);
            if ( result == 0 ) {
                result = this.path.compareTo(o.path);
            }
            return result;
        }
    }

    /**
     * Return the list of root paths.
     * Every entry in the list starts with a slash and the entries are
     * sorted by priority - highest priority first
     */
    String [] getRootPaths() {
    	return rootPaths;
    }

    static String cleanupRootPath(final String str) {
    	String result = str.trim();
    	if (!result.startsWith("/")) {
    		result = "/" + result;
    	}
    	if (result.endsWith("/")) {
    		result = result.substring(0, result.length() - 1);
    	}
    	return result;
    }

    /** If a folder at given path can contain installable resources
     * 	(according to our regexp and current RunMode), return the
     * 	priority to use for InstallableResource found in that folder.
     *
     * 	@return -1 if path is not an installable folder, else resource priority
     */
    int getPriority(final String path) {
    	int result = 0;
    	List<String> modes = null;
    	boolean match = false;

        // If path contains dots after the last /, remove suffixes
    	// starting with dots until path matches regexp, and accept
    	// if all suffixes
        // are included in our list of runmodes
        final char DOT = '.';

        String prefix = path;
        final int lastSlash = prefix.lastIndexOf('/');
        if(lastSlash > 0) {
        	prefix = prefix.substring(lastSlash);
        }
        if(prefix.indexOf(DOT) > 0) {
            int pos = 0;
            modes = new LinkedList<String>();
            while( (pos = prefix.lastIndexOf(DOT)) >= 0) {
                modes.add(prefix.substring(pos + 1));
                prefix = prefix.substring(0, pos);
                if(pattern.matcher(prefix).matches()) {
                    result = getRootPriority(path);
                    break;
                }
            }

            // If path prefix matches, check that all our runmodes match
            if(result > 0) {
                for(String m : modes) {
                    if(runModes.contains(m)) {
                    	result += RUNMODE_PRIORITY_BOOST;
                    } else {
                        result = 0;
                        break;
                    }
                }
            }

        } else if(pattern.matcher(path).matches()) {
        	match = true;
        	result = getRootPriority(path);
        }

        if(modes != null) {
            if(log.isDebugEnabled()) {
                log.debug("getPriority(" + path + ")=" + result + " (prefix=" + prefix + ", run modes=" + modes + ")");
            }
        } else if(match ){
        	log.debug("getPriority({})={}", path, result);
        } else {
        	log.debug("getPriority({})={}, path doesn't match regexp", path, result);
        }

        return result;
    }

    public String toString() {
        return getClass().getSimpleName() + " (" + regexp + "), RunModes=" + runModes;
    }

    int getRootPriority(String path) {
    	for(Map.Entry<String, Integer> e : rootPriorities.entrySet()) {
    		if(path.startsWith(e.getKey())) {
    			return e.getValue().intValue();
    		}
    	}
    	return 0;
    }
}