src/main/java/org/apache/sling/rewriter/impl/ProcessorManagerImpl.java - sling-org-apache-sling-rewriter - Git at Google

 /*
  * 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.rewriter.impl;

 import java.io.IOException;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Dictionary;
 import java.util.HashMap;
 import java.util.Hashtable;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Reference;
 import org.apache.felix.scr.annotations.Service;
 import org.apache.sling.api.SlingException;
 import org.apache.sling.api.resource.LoginException;
 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.observation.ExternalResourceChangeListener;
 import org.apache.sling.api.resource.observation.ResourceChange;
 import org.apache.sling.api.resource.observation.ResourceChange.ChangeType;
 import org.apache.sling.api.resource.observation.ResourceChangeListener;
 import org.apache.sling.rewriter.PipelineConfiguration;
 import org.apache.sling.rewriter.ProcessingContext;
 import org.apache.sling.rewriter.Processor;
 import org.apache.sling.rewriter.ProcessorConfiguration;
 import org.apache.sling.rewriter.ProcessorManager;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.InvalidSyntaxException;
 import org.osgi.framework.ServiceRegistration;
 import org.osgi.service.component.ComponentContext;
 import org.osgi.service.component.annotations.Activate;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 /**
  * This manager keeps track of configured processors.
  *
  */
 @Component
 @Service(value=ProcessorManager.class)
 public class ProcessorManagerImpl
     implements ProcessorManager, ResourceChangeListener, ExternalResourceChangeListener  {

     private static final String CONFIG_REL_PATH = "config/rewriter";
     private static final String CONFIG_PATH = "/" + CONFIG_REL_PATH;

     protected static final String MIME_TYPE_HTML = "text/html";

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

     /** The bundle context. */
     private BundleContext bundleContext;

     @Reference
     private ResourceResolverFactory resourceResolverFactory;

     /** loaded processor configurations */
     private final Map<String, ConfigEntry[]> processors = new HashMap<String, ConfigEntry[]>();

     /** Ordered processor configurations. */
     private List<ProcessorConfiguration> orderedProcessors = new ArrayList<ProcessorConfiguration>();

     /** Event handler registration */
     private volatile ServiceRegistration<ResourceChangeListener> eventHandlerRegistration;

     /** Search path */
     private String[] searchPath;

     /** The factory cache. */
     private FactoryCache factoryCache;

     /**
      * Activate this component.
      * @param ctx
      */
     @Activate
 	protected void activate(final BundleContext ctx)
     throws LoginException, InvalidSyntaxException {
         this.bundleContext = ctx;
         this.factoryCache = new FactoryCache(this.bundleContext);

         // create array of search paths for actions and constraints
         this.searchPath = this.initProcessors();
     	// register event handler
 		final Dictionary<String, Object> props = new Hashtable<String, Object>();
 		props.put(ResourceChangeListener.CHANGES,
 				new String[] { ChangeType.ADDED.toString(), ChangeType.CHANGED.toString(),
 						ChangeType.REMOVED.toString(), ChangeType.PROVIDER_ADDED.toString(), ChangeType.PROVIDER_REMOVED.toString() });
 		props.put(ResourceChangeListener.PATHS, "glob:*" + CONFIG_PATH + "/**");
 		props.put("service.description", "Processor Configuration/Modification Handler");
 		props.put("service.vendor", "The Apache Software Foundation");
 		this.eventHandlerRegistration = this.bundleContext.registerService(ResourceChangeListener.class, this,
 				props);
     	this.factoryCache.start();

         WebConsoleConfigPrinter.register(this.bundleContext, this);
     }

     @SuppressWarnings("deprecation")
     private ResourceResolver createResourceResolver() throws LoginException {
         return this.resourceResolverFactory.getAdministrativeResourceResolver(null);
     }

     /**
      * Deactivate this component.
      * @param ctx
      */
     protected void deactivate(final ComponentContext ctx) {
         if ( this.eventHandlerRegistration != null ) {
             this.eventHandlerRegistration.unregister();
             this.eventHandlerRegistration = null;
         }
         this.factoryCache.stop();
         this.factoryCache = null;

         WebConsoleConfigPrinter.unregister();

         this.bundleContext = null;
     }

     @Override
 	public void onChange(final List<ResourceChange> changes) {
     	for(final ResourceChange change : changes){
     		// check if the event handles something in the search paths
             String path = change.getPath();
             int foundPos = -1;
             for(final String sPath : this.searchPath) {
                 if ( path.startsWith(sPath) ) {
                     foundPos = sPath.length();
                     break;
                 }
             }
             boolean handled = false;
             if ( foundPos != -1 ) {
                 // now check if this is a rewriter config
                 // relative path after the search path
                 final int firstSlash = path.indexOf('/', foundPos);
                 final int pattern = path.indexOf(CONFIG_PATH, foundPos);
                 // only if firstSlash and pattern are at the same position, this might be a rewriter config
                 if ( firstSlash == pattern && firstSlash != -1 ) {
                     // the node should be a child of CONFIG_PATH
                     if ( path.length() > pattern + CONFIG_PATH.length() && path.charAt(pattern + CONFIG_PATH.length()) == '/') {
                         // if a child resource is changed, make sure we have the correct path
                         final int slashPos = path.indexOf('/', pattern + CONFIG_PATH.length() + 1);
                         if ( slashPos != -1 ) {
                             path = path.substring(0, slashPos);
                         }
                         // we should do the update async as we don't want to block the event delivery
                         final String configPath = path;
                         final Thread t = new Thread() {
                             @Override
                             public void run() {
                                 if (change.getType() == ChangeType.REMOVED) {
                                     removeProcessor(configPath);
                                 } else {
                                     updateProcessor(configPath);
                                 }
                             }
                         };
                         t.start();
                         handled = true;
                     }
                 }
             }
             if ( !handled && change.getType() == ChangeType.REMOVED ) {
                 final Thread t = new Thread() {
                     @Override
                     public void run() {
                         checkRemoval(change.getPath());
                     }

                 };
                 t.start();
             }
     	}

     }

     /**
      * Initializes the current processors
      */
     private synchronized String[] initProcessors() throws LoginException {
         try ( final ResourceResolver resolver = this.createResourceResolver()) {
             for(final String path : resolver.getSearchPath() ) {
                 // check if the search path exists
                 final Resource spResource = resolver.getResource(path.substring(0, path.length() - 1));
                 if ( spResource != null ) {
                     // now iterate over the child nodes
                     final Iterator<Resource> spIter = spResource.listChildren();
                     while ( spIter.hasNext() ) {
                         // check if the node has a rewriter config
                         final Resource appResource = spIter.next();
                         final Resource parentResource = resolver.getResource(appResource.getPath() + CONFIG_PATH);
                         if ( parentResource != null ) {
                             // now read configs
                             final Iterator<Resource> iter = parentResource.listChildren();
                             while ( iter.hasNext() ) {
                                 final Resource configResource = iter.next();
                                 final String key = configResource.getName();
                                 final ProcessorConfigurationImpl config = this.getProcessorConfiguration(configResource);
                                 this.log.debug("Found new processor configuration {}", config);
                                 this.addProcessor(key, configResource.getPath(), config);
                             }
                         }
                     }
                 }
             }
             return resolver.getSearchPath();
         }
     }

     /**
      * Read the configuration for the processor from the repository.
      */
     private ProcessorConfigurationImpl getProcessorConfiguration(final Resource configResource) {
         final ProcessorConfigurationImpl config = new ProcessorConfigurationImpl(configResource);
         return config;
     }

     /**
      * adds a processor configuration
      */
     protected void addProcessor(final String key, final String configPath, final ProcessorConfigurationImpl config) {
         ConfigEntry[] configs = this.processors.get(key);
         if ( configs == null ) {
             configs = new ConfigEntry[1];
             configs[0] = new ConfigEntry(configPath, config);
         } else {
             ConfigEntry[] newConfigs = new ConfigEntry[configs.length + 1];
             System.arraycopy(configs, 0, newConfigs, 0, configs.length);
             newConfigs[configs.length] = new ConfigEntry(configPath, config);
         }

         this.processors.put(key, configs);
         // only add active configurations
         if ( config.isActive() ) {
             this.orderedProcessors.add(config);
             Collections.sort(this.orderedProcessors, new ProcessorConfiguratorComparator());
         }
     }

     private void printConfiguration(final PrintWriter pw, final ConfigEntry entry) {
         if ( entry.config instanceof ProcessorConfigurationImpl ) {
             ((ProcessorConfigurationImpl)entry.config).printConfiguration(pw);
         } else {
             pw.println(entry.config.toString());
         }
         pw.print("Resource path: ");
         pw.println(entry.path);
     }

     synchronized void printConfiguration(final PrintWriter pw) {
         pw.println("Current Apache Sling Rewriter Configuration");
         pw.println("=================================================================");
         pw.println("Active Configurations");
         pw.println("-----------------------------------------------------------------");
         // we process the configs in their order
         for(final ProcessorConfiguration config : this.orderedProcessors) {
             // search the corresponding full config
             for(final Map.Entry<String, ConfigEntry[]> entry : this.processors.entrySet()) {
                 if ( entry.getValue().length > 0 && entry.getValue()[0].config == config ) {
                     pw.print("Configuration ");
                     pw.println(entry.getKey());
                     pw.println();
                     printConfiguration(pw, entry.getValue()[0]);
                     if ( entry.getValue().length > 1 ) {
                         pw.println("Overriding configurations from the following resource paths: ");
                         for(int i=1; i < entry.getValue().length; i++) {
                             pw.print("- ");
                             pw.println(entry.getValue()[i].path);
                         }
                     }
                     pw.println();
                     pw.println();
                     break;
                 }
             }
         }
     }

     /**
      * updates a processor
      */
     private synchronized void updateProcessor(final String path) {
         final int pos = path.lastIndexOf('/');
         final String key = path.substring(pos + 1);
         int keyIndex = 0;
         // search the search path
         for(final String sp : this.searchPath) {
             if ( path.startsWith(sp) ) {
                 break;
             }
             keyIndex++;
         }

         try ( final ResourceResolver resolver = this.createResourceResolver()) {
             final Resource configResource = resolver.getResource(path);
             if ( configResource == null ) {
                 return;
             }
             final ProcessorConfigurationImpl config = this.getProcessorConfiguration(configResource);

             final ConfigEntry[] configs = this.processors.get(key);
             if ( configs != null ) {
                 // search path
                 int index = -1;
                 for(int i=0; i<configs.length; i++) {
                     if ( configs[i].path.equals(path) ) {
                         index = i;
                         break;
                     }
                 }
                 if ( index != -1 ) {
                     // we are already in the array
                     if ( index == 0 ) {
                         // we are the first, so remove the old, and add the new
                         this.orderedProcessors.remove(configs[index].config);
                         configs[index] = new ConfigEntry(path, config);
                         if ( config.isActive() ) {
                             this.orderedProcessors.add(config);
                             Collections.sort(this.orderedProcessors, new ProcessorConfiguratorComparator());
                         }
                     } else {
                         // we are not the first, so we can simply exchange
                         configs[index] = new ConfigEntry(path, config);
                     }
                 } else {
                     // now we have to insert the new config at the correct place
                     int insertIndex = 0;
                     boolean found = false;
                     while ( !found && insertIndex < configs.length) {
                         final ConfigEntry current = configs[insertIndex];
                         int currentIndex = -1;
                         for(int i=0; i<searchPath.length; i++) {
                             if ( current.path.startsWith(searchPath[i]) ) {
                                 currentIndex = i;
                                 break;
                             }
                         }
                         if ( currentIndex >= keyIndex ) {
                             found = true;
                             insertIndex = currentIndex;
                         }
                     }

                     if ( !found ) {
                         // just append
                         this.addProcessor(key, path, config);
                     } else {
                         ConfigEntry[] newArray = new ConfigEntry[configs.length + 1];
                         int i = 0;
                         for(final ConfigEntry current : configs) {
                             if ( i == insertIndex ) {
                                 newArray[i] = new ConfigEntry(path, config);
                                 i++;
                             }
                             newArray[i] = current;
                             i++;
                         }
                         this.processors.put(key, newArray);
                         if ( insertIndex == 0 ) {
                             // we are the first, so remove the old, and add the new
                             this.orderedProcessors.remove(configs[1].config);
                             if ( config.isActive() ) {
                                 this.orderedProcessors.add(config);
                                 Collections.sort(this.orderedProcessors, new ProcessorConfiguratorComparator());
                             }
                         }
                     }
                 }
             } else {
                 // completely new, just add it
                 this.addProcessor(key, path, config);
             }
         } catch ( final LoginException le) {
             log.error("Unable to create resource resolver.", le);
         }
     }

     /**
      * removes a pipeline
      */
     private synchronized void removeProcessor(final String path) {
         final int pos = path.lastIndexOf('/');
         final String key = path.substring(pos + 1);
         // we have to search the config

         final ConfigEntry[] configs = this.processors.get(key);
         if ( configs != null ) {
             // search path
             ConfigEntry found = null;
             for(final ConfigEntry current : configs) {
                 if ( current.path.equals(path) ) {
                     found = current;
                     break;
                 }
             }
             if ( found != null ) {
                 this.orderedProcessors.remove(found.config);
                 if ( configs.length == 1 ) {
                     this.processors.remove(key);
                 } else {
                     if ( found == configs[0] ) {
                         this.orderedProcessors.add(configs[1].config);
                         Collections.sort(this.orderedProcessors, new ProcessorConfiguratorComparator());
                     }
                     ConfigEntry[] newArray = new ConfigEntry[configs.length - 1];
                     int index = 0;
                     for(final ConfigEntry current : configs) {
                         if ( current != found ) {
                             newArray[index] = current;
                             index++;
                         }
                     }
                     this.processors.put(key, newArray);
                 }
             }
         }
     }

     private synchronized void checkRemoval(final String path) {
         // TODO Auto-generated method stub

     }

     /**
      * @see org.apache.sling.rewriter.ProcessorManager#getProcessor(org.apache.sling.rewriter.ProcessorConfiguration, org.apache.sling.rewriter.ProcessingContext)
      */
     @Override
     public Processor getProcessor(ProcessorConfiguration configuration,
                                   ProcessingContext      context) {
         if ( configuration == null ) {
             throw new IllegalArgumentException("Processor configuration is missing.");
         }
         if ( context == null ) {
             throw new IllegalArgumentException("Processor context is missing.");
         }
         boolean isPipeline = false;
         if ( configuration instanceof ProcessorConfigurationImpl ) {
             isPipeline = ((ProcessorConfigurationImpl)configuration).isPipeline();
         } else {
             isPipeline = configuration instanceof PipelineConfiguration;
         }
         try {
             if ( isPipeline ) {
                 final PipelineImpl pipeline = new PipelineImpl(this.factoryCache);
                 pipeline.init(context, configuration);
                 return pipeline;
             }
             final Processor processor = new ProcessorWrapper(configuration, this.factoryCache);
             processor.init(context, configuration);
             return processor;
         } catch (final IOException ioe) {
             throw new SlingException("Unable to setup processor: " + ioe.getMessage(), ioe);
         }
     }

     /**
      * @see org.apache.sling.rewriter.ProcessorManager#getProcessorConfigurations()
      */
     @Override
     public List<ProcessorConfiguration> getProcessorConfigurations() {
         return this.orderedProcessors;
     }

     protected static final class ProcessorConfiguratorComparator implements Comparator<ProcessorConfiguration> {

         /**
          * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
          */
         @Override
         public int compare(ProcessorConfiguration config0, ProcessorConfiguration config1) {
             final int o0 = ((ProcessorConfigurationImpl)config0).getOrder();
             final int o1 = ((ProcessorConfigurationImpl)config1).getOrder();
             if ( o0 == o1 ) {
                 return 0;
             } else if ( o0 < o1 ) {
                 return 1;
             }
             return -1;
         }

     }

     public static final class ConfigEntry {
         public final String path;
         public final ProcessorConfiguration config;

         public ConfigEntry(final String p, final ProcessorConfiguration pc) {
             this.path = p;
             this.config = pc;
         }
     }
 }
	/*
	* 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.rewriter.impl;

	import java.io.IOException;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.Dictionary;
	import java.util.HashMap;
	import java.util.Hashtable;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import org.apache.felix.scr.annotations.Component;
	import org.apache.felix.scr.annotations.Reference;
	import org.apache.felix.scr.annotations.Service;
	import org.apache.sling.api.SlingException;
	import org.apache.sling.api.resource.LoginException;
	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.observation.ExternalResourceChangeListener;
	import org.apache.sling.api.resource.observation.ResourceChange;
	import org.apache.sling.api.resource.observation.ResourceChange.ChangeType;
	import org.apache.sling.api.resource.observation.ResourceChangeListener;
	import org.apache.sling.rewriter.PipelineConfiguration;
	import org.apache.sling.rewriter.ProcessingContext;
	import org.apache.sling.rewriter.Processor;
	import org.apache.sling.rewriter.ProcessorConfiguration;
	import org.apache.sling.rewriter.ProcessorManager;
	import org.osgi.framework.BundleContext;
	import org.osgi.framework.InvalidSyntaxException;
	import org.osgi.framework.ServiceRegistration;
	import org.osgi.service.component.ComponentContext;
	import org.osgi.service.component.annotations.Activate;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	/**
	* This manager keeps track of configured processors.
	*
	*/
	@Component
	@Service(value=ProcessorManager.class)
	public class ProcessorManagerImpl
	implements ProcessorManager, ResourceChangeListener, ExternalResourceChangeListener {

	private static final String CONFIG_REL_PATH = "config/rewriter";
	private static final String CONFIG_PATH = "/" + CONFIG_REL_PATH;

	protected static final String MIME_TYPE_HTML = "text/html";

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

	/** The bundle context. */
	private BundleContext bundleContext;

	@Reference
	private ResourceResolverFactory resourceResolverFactory;

	/** loaded processor configurations */
	private final Map<String, ConfigEntry[]> processors = new HashMap<String, ConfigEntry[]>();

	/** Ordered processor configurations. */
	private List<ProcessorConfiguration> orderedProcessors = new ArrayList<ProcessorConfiguration>();

	/** Event handler registration */
	private volatile ServiceRegistration<ResourceChangeListener> eventHandlerRegistration;

	/** Search path */
	private String[] searchPath;

	/** The factory cache. */
	private FactoryCache factoryCache;

	/**
	* Activate this component.
	* @param ctx
	*/
	@Activate
	protected void activate(final BundleContext ctx)
	throws LoginException, InvalidSyntaxException {
	this.bundleContext = ctx;
	this.factoryCache = new FactoryCache(this.bundleContext);

	// create array of search paths for actions and constraints
	this.searchPath = this.initProcessors();
	// register event handler
	final Dictionary<String, Object> props = new Hashtable<String, Object>();
	props.put(ResourceChangeListener.CHANGES,
	new String[] { ChangeType.ADDED.toString(), ChangeType.CHANGED.toString(),
	ChangeType.REMOVED.toString(), ChangeType.PROVIDER_ADDED.toString(), ChangeType.PROVIDER_REMOVED.toString() });
	props.put(ResourceChangeListener.PATHS, "glob:" + CONFIG_PATH + "/*");
	props.put("service.description", "Processor Configuration/Modification Handler");
	props.put("service.vendor", "The Apache Software Foundation");
	this.eventHandlerRegistration = this.bundleContext.registerService(ResourceChangeListener.class, this,
	props);
	this.factoryCache.start();

	WebConsoleConfigPrinter.register(this.bundleContext, this);
	}

	@SuppressWarnings("deprecation")
	private ResourceResolver createResourceResolver() throws LoginException {
	return this.resourceResolverFactory.getAdministrativeResourceResolver(null);
	}

	/**
	* Deactivate this component.
	* @param ctx
	*/
	protected void deactivate(final ComponentContext ctx) {
	if ( this.eventHandlerRegistration != null ) {
	this.eventHandlerRegistration.unregister();
	this.eventHandlerRegistration = null;
	}
	this.factoryCache.stop();
	this.factoryCache = null;

	WebConsoleConfigPrinter.unregister();

	this.bundleContext = null;
	}

	@Override
	public void onChange(final List<ResourceChange> changes) {
	for(final ResourceChange change : changes){
	// check if the event handles something in the search paths
	String path = change.getPath();
	int foundPos = -1;
	for(final String sPath : this.searchPath) {
	if ( path.startsWith(sPath) ) {
	foundPos = sPath.length();
	break;
	}
	}
	boolean handled = false;
	if ( foundPos != -1 ) {
	// now check if this is a rewriter config
	// relative path after the search path
	final int firstSlash = path.indexOf('/', foundPos);
	final int pattern = path.indexOf(CONFIG_PATH, foundPos);
	// only if firstSlash and pattern are at the same position, this might be a rewriter config
	if ( firstSlash == pattern && firstSlash != -1 ) {
	// the node should be a child of CONFIG_PATH
	if ( path.length() > pattern + CONFIG_PATH.length() && path.charAt(pattern + CONFIG_PATH.length()) == '/') {
	// if a child resource is changed, make sure we have the correct path
	final int slashPos = path.indexOf('/', pattern + CONFIG_PATH.length() + 1);
	if ( slashPos != -1 ) {
	path = path.substring(0, slashPos);
	}
	// we should do the update async as we don't want to block the event delivery
	final String configPath = path;
	final Thread t = new Thread() {
	@Override
	public void run() {
	if (change.getType() == ChangeType.REMOVED) {
	removeProcessor(configPath);
	} else {
	updateProcessor(configPath);
	}
	}
	};
	t.start();
	handled = true;
	}
	}
	}
	if ( !handled && change.getType() == ChangeType.REMOVED ) {
	final Thread t = new Thread() {
	@Override
	public void run() {
	checkRemoval(change.getPath());
	}

	};
	t.start();
	}
	}

	}

	/**
	* Initializes the current processors
	*/
	private synchronized String[] initProcessors() throws LoginException {
	try ( final ResourceResolver resolver = this.createResourceResolver()) {
	for(final String path : resolver.getSearchPath() ) {
	// check if the search path exists
	final Resource spResource = resolver.getResource(path.substring(0, path.length() - 1));
	if ( spResource != null ) {
	// now iterate over the child nodes
	final Iterator<Resource> spIter = spResource.listChildren();
	while ( spIter.hasNext() ) {
	// check if the node has a rewriter config
	final Resource appResource = spIter.next();
	final Resource parentResource = resolver.getResource(appResource.getPath() + CONFIG_PATH);
	if ( parentResource != null ) {
	// now read configs
	final Iterator<Resource> iter = parentResource.listChildren();
	while ( iter.hasNext() ) {
	final Resource configResource = iter.next();
	final String key = configResource.getName();
	final ProcessorConfigurationImpl config = this.getProcessorConfiguration(configResource);
	this.log.debug("Found new processor configuration {}", config);
	this.addProcessor(key, configResource.getPath(), config);
	}
	}
	}
	}
	}
	return resolver.getSearchPath();
	}
	}

	/**
	* Read the configuration for the processor from the repository.
	*/
	private ProcessorConfigurationImpl getProcessorConfiguration(final Resource configResource) {
	final ProcessorConfigurationImpl config = new ProcessorConfigurationImpl(configResource);
	return config;
	}

	/**
	* adds a processor configuration
	*/
	protected void addProcessor(final String key, final String configPath, final ProcessorConfigurationImpl config) {
	ConfigEntry[] configs = this.processors.get(key);
	if ( configs == null ) {
	configs = new ConfigEntry[1];
	configs[0] = new ConfigEntry(configPath, config);
	} else {
	ConfigEntry[] newConfigs = new ConfigEntry[configs.length + 1];
	System.arraycopy(configs, 0, newConfigs, 0, configs.length);
	newConfigs[configs.length] = new ConfigEntry(configPath, config);
	}

	this.processors.put(key, configs);
	// only add active configurations
	if ( config.isActive() ) {
	this.orderedProcessors.add(config);
	Collections.sort(this.orderedProcessors, new ProcessorConfiguratorComparator());
	}
	}

	private void printConfiguration(final PrintWriter pw, final ConfigEntry entry) {
	if ( entry.config instanceof ProcessorConfigurationImpl ) {
	((ProcessorConfigurationImpl)entry.config).printConfiguration(pw);
	} else {
	pw.println(entry.config.toString());
	}
	pw.print("Resource path: ");
	pw.println(entry.path);
	}

	synchronized void printConfiguration(final PrintWriter pw) {
	pw.println("Current Apache Sling Rewriter Configuration");
	pw.println("=================================================================");
	pw.println("Active Configurations");
	pw.println("-----------------------------------------------------------------");
	// we process the configs in their order
	for(final ProcessorConfiguration config : this.orderedProcessors) {
	// search the corresponding full config
	for(final Map.Entry<String, ConfigEntry[]> entry : this.processors.entrySet()) {
	if ( entry.getValue().length > 0 && entry.getValue()[0].config == config ) {
	pw.print("Configuration ");
	pw.println(entry.getKey());
	pw.println();
	printConfiguration(pw, entry.getValue()[0]);
	if ( entry.getValue().length > 1 ) {
	pw.println("Overriding configurations from the following resource paths: ");
	for(int i=1; i < entry.getValue().length; i++) {
	pw.print("- ");
	pw.println(entry.getValue()[i].path);
	}
	}
	pw.println();
	pw.println();
	break;
	}
	}
	}
	}

	/**
	* updates a processor
	*/
	private synchronized void updateProcessor(final String path) {
	final int pos = path.lastIndexOf('/');
	final String key = path.substring(pos + 1);
	int keyIndex = 0;
	// search the search path
	for(final String sp : this.searchPath) {
	if ( path.startsWith(sp) ) {
	break;
	}
	keyIndex++;
	}

	try ( final ResourceResolver resolver = this.createResourceResolver()) {
	final Resource configResource = resolver.getResource(path);
	if ( configResource == null ) {
	return;
	}
	final ProcessorConfigurationImpl config = this.getProcessorConfiguration(configResource);

	final ConfigEntry[] configs = this.processors.get(key);
	if ( configs != null ) {
	// search path
	int index = -1;
	for(int i=0; i<configs.length; i++) {
	if ( configs[i].path.equals(path) ) {
	index = i;
	break;
	}
	}
	if ( index != -1 ) {
	// we are already in the array
	if ( index == 0 ) {
	// we are the first, so remove the old, and add the new
	this.orderedProcessors.remove(configs[index].config);
	configs[index] = new ConfigEntry(path, config);
	if ( config.isActive() ) {
	this.orderedProcessors.add(config);
	Collections.sort(this.orderedProcessors, new ProcessorConfiguratorComparator());
	}
	} else {
	// we are not the first, so we can simply exchange
	configs[index] = new ConfigEntry(path, config);
	}
	} else {
	// now we have to insert the new config at the correct place
	int insertIndex = 0;
	boolean found = false;
	while ( !found && insertIndex < configs.length) {
	final ConfigEntry current = configs[insertIndex];
	int currentIndex = -1;
	for(int i=0; i<searchPath.length; i++) {
	if ( current.path.startsWith(searchPath[i]) ) {
	currentIndex = i;
	break;
	}
	}
	if ( currentIndex >= keyIndex ) {
	found = true;
	insertIndex = currentIndex;
	}
	}

	if ( !found ) {
	// just append
	this.addProcessor(key, path, config);
	} else {
	ConfigEntry[] newArray = new ConfigEntry[configs.length + 1];
	int i = 0;
	for(final ConfigEntry current : configs) {
	if ( i == insertIndex ) {
	newArray[i] = new ConfigEntry(path, config);
	i++;
	}
	newArray[i] = current;
	i++;
	}
	this.processors.put(key, newArray);
	if ( insertIndex == 0 ) {
	// we are the first, so remove the old, and add the new
	this.orderedProcessors.remove(configs[1].config);
	if ( config.isActive() ) {
	this.orderedProcessors.add(config);
	Collections.sort(this.orderedProcessors, new ProcessorConfiguratorComparator());
	}
	}
	}
	}
	} else {
	// completely new, just add it
	this.addProcessor(key, path, config);
	}
	} catch ( final LoginException le) {
	log.error("Unable to create resource resolver.", le);
	}
	}

	/**
	* removes a pipeline
	*/
	private synchronized void removeProcessor(final String path) {
	final int pos = path.lastIndexOf('/');
	final String key = path.substring(pos + 1);
	// we have to search the config

	final ConfigEntry[] configs = this.processors.get(key);
	if ( configs != null ) {
	// search path
	ConfigEntry found = null;
	for(final ConfigEntry current : configs) {
	if ( current.path.equals(path) ) {
	found = current;
	break;
	}
	}
	if ( found != null ) {
	this.orderedProcessors.remove(found.config);
	if ( configs.length == 1 ) {
	this.processors.remove(key);
	} else {
	if ( found == configs[0] ) {
	this.orderedProcessors.add(configs[1].config);
	Collections.sort(this.orderedProcessors, new ProcessorConfiguratorComparator());
	}
	ConfigEntry[] newArray = new ConfigEntry[configs.length - 1];
	int index = 0;
	for(final ConfigEntry current : configs) {
	if ( current != found ) {
	newArray[index] = current;
	index++;
	}
	}
	this.processors.put(key, newArray);
	}
	}
	}
	}

	private synchronized void checkRemoval(final String path) {
	// TODO Auto-generated method stub

	}

	/**
	* @see org.apache.sling.rewriter.ProcessorManager#getProcessor(org.apache.sling.rewriter.ProcessorConfiguration, org.apache.sling.rewriter.ProcessingContext)
	*/
	@Override
	public Processor getProcessor(ProcessorConfiguration configuration,
	ProcessingContext context) {
	if ( configuration == null ) {
	throw new IllegalArgumentException("Processor configuration is missing.");
	}
	if ( context == null ) {
	throw new IllegalArgumentException("Processor context is missing.");
	}
	boolean isPipeline = false;
	if ( configuration instanceof ProcessorConfigurationImpl ) {
	isPipeline = ((ProcessorConfigurationImpl)configuration).isPipeline();
	} else {
	isPipeline = configuration instanceof PipelineConfiguration;
	}
	try {
	if ( isPipeline ) {
	final PipelineImpl pipeline = new PipelineImpl(this.factoryCache);
	pipeline.init(context, configuration);
	return pipeline;
	}
	final Processor processor = new ProcessorWrapper(configuration, this.factoryCache);
	processor.init(context, configuration);
	return processor;
	} catch (final IOException ioe) {
	throw new SlingException("Unable to setup processor: " + ioe.getMessage(), ioe);
	}
	}

	/**
	* @see org.apache.sling.rewriter.ProcessorManager#getProcessorConfigurations()
	*/
	@Override
	public List<ProcessorConfiguration> getProcessorConfigurations() {
	return this.orderedProcessors;
	}

	protected static final class ProcessorConfiguratorComparator implements Comparator<ProcessorConfiguration> {

	/**
	* @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
	*/
	@Override
	public int compare(ProcessorConfiguration config0, ProcessorConfiguration config1) {
	final int o0 = ((ProcessorConfigurationImpl)config0).getOrder();
	final int o1 = ((ProcessorConfigurationImpl)config1).getOrder();
	if ( o0 == o1 ) {
	return 0;
	} else if ( o0 < o1 ) {
	return 1;
	}
	return -1;
	}

	}

	public static final class ConfigEntry {
	public final String path;
	public final ProcessorConfiguration config;

	public ConfigEntry(final String p, final ProcessorConfiguration pc) {
	this.path = p;
	this.config = pc;
	}
	}
	}