| /* |
| * 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.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.ArrayList; |
| import java.util.Calendar; |
| import java.util.Collection; |
| import java.util.Dictionary; |
| import java.util.Hashtable; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import javax.jcr.Node; |
| import javax.jcr.NodeIterator; |
| import javax.jcr.RepositoryException; |
| import javax.jcr.Session; |
| import javax.jcr.observation.Event; |
| import javax.jcr.observation.EventIterator; |
| import javax.jcr.observation.EventListener; |
| |
| import org.apache.felix.cm.file.ConfigurationHandler; |
| import org.apache.felix.scr.annotations.Component; |
| import org.apache.felix.scr.annotations.Properties; |
| import org.apache.felix.scr.annotations.Property; |
| import org.apache.felix.scr.annotations.PropertyUnbounded; |
| import org.apache.felix.scr.annotations.Reference; |
| import org.apache.felix.scr.annotations.Service; |
| import org.apache.sling.commons.osgi.PropertiesUtil; |
| import org.apache.sling.installer.api.InstallableResource; |
| import org.apache.sling.installer.api.OsgiInstaller; |
| import org.apache.sling.installer.api.UpdateHandler; |
| import org.apache.sling.installer.api.UpdateResult; |
| import org.apache.sling.jcr.api.SlingRepository; |
| import org.apache.sling.settings.SlingSettingsService; |
| import org.osgi.framework.Constants; |
| import org.osgi.framework.ServiceRegistration; |
| import org.osgi.service.cm.ConfigurationException; |
| import org.osgi.service.cm.ManagedService; |
| import org.osgi.service.component.ComponentConstants; |
| import org.osgi.service.component.ComponentContext; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * Main class of jcrinstall, runs as a service, observes the |
| * repository for changes in folders having names that match |
| * configurable regular expressions, and registers resources |
| * found in those folders with the OSGi installer for installation. |
| */ |
| @Component(label="%jcrinstall.name", description="%jcrinstall.description", immediate=true, metatype=true) |
| @Properties({ |
| @Property(name="service.description", value="Sling JCR Install Service"), |
| @Property(name="service.vendor", value="The Apache Software Foundation"), |
| @Property(name=UpdateHandler.PROPERTY_SCHEMES, value=JcrInstaller.URL_SCHEME, unbounded=PropertyUnbounded.ARRAY), |
| @Property(name="service.ranking", intValue=100) |
| }) |
| @Service(value=UpdateHandler.class) |
| public class JcrInstaller implements EventListener, UpdateHandler, ManagedService { |
| |
| public static final long RUN_LOOP_DELAY_MSEC = 500L; |
| public static final String URL_SCHEME = "jcrinstall"; |
| |
| /** PID before refactoring. */ |
| private static final String OLD_PID = "org.apache.sling.jcr.install.impl.JcrInstaller"; |
| |
| private final Logger logger = LoggerFactory.getLogger(getClass()); |
| |
| /** Counters, used for statistics and testing */ |
| private final long [] counters = new long[COUNTERS_COUNT]; |
| public static final int SCAN_FOLDERS_COUNTER = 0; |
| public static final int UPDATE_FOLDERS_LIST_COUNTER = 1; |
| public static final int RUN_LOOP_COUNTER = 2; |
| public static final int COUNTERS_COUNT = 3; |
| |
| private static final String NT_FILE = "nt:file"; |
| private static final String NT_RESOURCE = "nt:resource"; |
| private static final String PROP_DATA = "jcr:data"; |
| private static final String PROP_MODIFIED = "jcr:lastModified"; |
| private static final String PROP_ENC = "jcr:encoding"; |
| private static final String PROP_MIME = "jcr:mimeType"; |
| private static final String MIME_TXT = "text/plain"; |
| private static final String ENCODING = "UTF-8"; |
| |
| /** |
| * This class watches the repository for installable resources |
| */ |
| @Reference |
| private SlingRepository repository; |
| |
| /** |
| * Additional installation folders are activated based |
| * on the current RunMode. For example, /libs/foo/install.dev |
| * if the current run mode is "dev". |
| */ |
| @Reference |
| private SlingSettingsService settings; |
| |
| /** |
| * The OsgiInstaller installs resources in the OSGi framework. |
| */ |
| @Reference |
| private OsgiInstaller installer; |
| |
| /** Default regexp for watched folders */ |
| public static final String DEFAULT_FOLDER_NAME_REGEXP = ".*/install$"; |
| |
| /** |
| * ComponentContext property that overrides the folder name regexp |
| */ |
| @Property(value=DEFAULT_FOLDER_NAME_REGEXP) |
| public static final String FOLDER_NAME_REGEXP_PROPERTY = "sling.jcrinstall.folder.name.regexp"; |
| |
| public static final int DEFAULT_FOLDER_MAX_DEPTH = 4; |
| |
| /** |
| * Configurable max. path depth for watched folders |
| */ |
| @Property(intValue=DEFAULT_FOLDER_MAX_DEPTH) |
| public static final String PROP_INSTALL_FOLDER_MAX_DEPTH = "sling.jcrinstall.folder.max.depth"; |
| |
| /** |
| * Configurable search path, with per-path priorities. |
| * We could get it from the ResourceResolver, but introducing a dependency on this just to get those |
| * values is too much for this module that's meant to bootstrap other services. |
| */ |
| @Property(value={"/libs:100", "/apps:200"}, unbounded=PropertyUnbounded.ARRAY) |
| public static final String PROP_SEARCH_PATH = "sling.jcrinstall.search.path"; |
| public static final String [] DEFAULT_SEARCH_PATH = { "/libs:100", "/apps:200" }; |
| |
| private int maxWatchedFolderDepth; |
| |
| /** Filter for folder names */ |
| private FolderNameFilter folderNameFilter; |
| |
| /** List of watched folders */ |
| private List<WatchedFolder> watchedFolders; |
| |
| /** Session shared by all WatchedFolder */ |
| private Session session; |
| |
| /** The root folders that we watch */ |
| private String [] roots; |
| |
| /** The component context. */ |
| private ComponentContext componentContext; |
| |
| /** Service reg for managed service. */ |
| private ServiceRegistration managedServiceRef; |
| |
| /** Configuration from managed service (old pid) */ |
| private Dictionary<?, ?> oldConfiguration; |
| |
| private static final String DEFAULT_NEW_CONFIG_PATH = "sling/install"; |
| @Property(value=DEFAULT_NEW_CONFIG_PATH) |
| private static final String PROP_NEW_CONFIG_PATH = "sling.jcrinstall.new.config.path"; |
| |
| /** The path for new configurations. */ |
| private String newConfigPath; |
| |
| public static final String PAUSE_SCAN_NODE_PATH = "/system/sling/installer/jcr/pauseInstallation"; |
| @Property(value= PAUSE_SCAN_NODE_PATH) |
| private static final String PROP_SCAN_PROP_PATH = "sling.jcrinstall.signal.path"; |
| |
| /** The path for pauseInstallation property */ |
| private String pauseScanNodePath; |
| |
| private volatile boolean pauseMessageLogged = false; |
| |
| private static final boolean DEFAULT_ENABLE_WRITEBACK = true; |
| @Property(boolValue=DEFAULT_ENABLE_WRITEBACK) |
| private static final String PROP_ENABLE_WRITEBACK = "sling.jcrinstall.enable.writeback"; |
| |
| /** Write back enabled? */ |
| private boolean writeBack; |
| |
| private EventListener moveEventListener; |
| |
| /** Convert Nodes to InstallableResources */ |
| static interface NodeConverter { |
| InstallableResource convertNode(Node n, int priority) |
| throws RepositoryException; |
| } |
| |
| /** Our NodeConverters*/ |
| private final Collection <NodeConverter> converters = new ArrayList<NodeConverter>(); |
| |
| /** Detect newly created folders that we must watch */ |
| private final List<RootFolderListener> listeners = new LinkedList<RootFolderListener>(); |
| |
| /** Timer used to call updateFoldersList() */ |
| private final RescanTimer updateFoldersListTimer = new RescanTimer(); |
| |
| /** Thread that can be cleanly stopped with a flag */ |
| static int bgThreadCounter; |
| class StoppableThread extends Thread { |
| boolean active = true; |
| StoppableThread() { |
| synchronized (JcrInstaller.class) { |
| setName("JcrInstaller." + (++bgThreadCounter)); |
| } |
| setDaemon(true); |
| } |
| |
| @Override |
| public final void run() { |
| logger.info("Background thread {} starting", Thread.currentThread().getName()); |
| try { |
| // open session |
| session = repository.loginAdministrative(repository.getDefaultWorkspace()); |
| |
| for (String path : roots) { |
| listeners.add(new RootFolderListener(session, folderNameFilter, path, updateFoldersListTimer)); |
| logger.debug("Configured root folder: {}", path); |
| } |
| |
| // Watch for events on the root - that might be one of our root folders |
| session.getWorkspace().getObservationManager().addEventListener(JcrInstaller.this, |
| Event.NODE_ADDED | Event.NODE_REMOVED, |
| "/", |
| false, // isDeep |
| null, |
| null, |
| true); // noLocal |
| // add special observation listener for move events |
| JcrInstaller.this.moveEventListener = new EventListener() { |
| |
| /** |
| * @see javax.jcr.observation.EventListener#onEvent(javax.jcr.observation.EventIterator) |
| */ |
| public void onEvent(final EventIterator events) { |
| try { |
| while (events.hasNext()) { |
| final Event e = events.nextEvent(); |
| JcrInstaller.this.checkChanges(e.getIdentifier()); |
| JcrInstaller.this.checkChanges(e.getPath()); |
| } |
| } catch (final RepositoryException re) { |
| logger.warn("RepositoryException in onEvent", re); |
| } |
| } |
| }; |
| session.getWorkspace().getObservationManager().addEventListener( |
| moveEventListener, |
| Event.NODE_MOVED, |
| "/", |
| true, // isDeep |
| null, |
| null, |
| true); // noLocal |
| |
| logger.debug("Watching for node events on / to detect removal/add of our root folders"); |
| |
| |
| // Find paths to watch and create WatchedFolders to manage them |
| watchedFolders = new LinkedList<WatchedFolder>(); |
| for(String root : roots) { |
| findPathsToWatch(root, watchedFolders); |
| } |
| |
| // Scan watchedFolders and register resources with installer |
| final List<InstallableResource> resources = new LinkedList<InstallableResource>(); |
| for(WatchedFolder f : watchedFolders) { |
| f.start(); |
| final WatchedFolder.ScanResult r = f.scan(); |
| logger.debug("Startup: {} provides resources {}", f, r.toAdd); |
| resources.addAll(r.toAdd); |
| } |
| |
| logger.debug("Registering {} resources with OSGi installer: {}", resources.size(), resources); |
| installer.registerResources(URL_SCHEME, resources.toArray(new InstallableResource[resources.size()])); |
| } catch (final RepositoryException re) { |
| logger.error("Repository exception during startup - deactivating installer!", re); |
| active = false; |
| final ComponentContext ctx = componentContext; |
| if ( ctx != null ) { |
| final String name = (String) componentContext.getProperties().get( |
| ComponentConstants.COMPONENT_NAME); |
| ctx.disableComponent(name); |
| } |
| } |
| while (active) { |
| runOneCycle(); |
| } |
| logger.info("Background thread {} done", Thread.currentThread().getName()); |
| counters[RUN_LOOP_COUNTER] = -1; |
| } |
| }; |
| private StoppableThread backgroundThread; |
| |
| /** |
| * Activate this component. |
| */ |
| protected void activate(final ComponentContext context) { |
| if (backgroundThread != null) { |
| throw new IllegalStateException("Expected backgroundThread to be null in activate()"); |
| } |
| this.componentContext = context; |
| this.start(); |
| final Dictionary<String, Object> props = new Hashtable<String, Object>(); |
| props.put(Constants.SERVICE_PID, OLD_PID); |
| this.managedServiceRef = this.componentContext.getBundleContext().registerService(ManagedService.class.getName(), |
| this, |
| props); |
| } |
| |
| private void start() { |
| logger.info("Activating Apache Sling JCR Installer"); |
| this.writeBack = PropertiesUtil.toBoolean(getPropertyValue(PROP_ENABLE_WRITEBACK), DEFAULT_ENABLE_WRITEBACK); |
| |
| // Setup converters |
| converters.add(new FileNodeConverter()); |
| converters.add(new ConfigNodeConverter()); |
| |
| // Configurable max depth, system property (via bundle context) overrides default value |
| final Object obj = getPropertyValue(PROP_INSTALL_FOLDER_MAX_DEPTH); |
| if (obj != null) { |
| // depending on where it's coming from, obj might be a string or integer |
| maxWatchedFolderDepth = Integer.valueOf(String.valueOf(obj)).intValue(); |
| logger.debug("Using configured ({}) folder name max depth '{}'", PROP_INSTALL_FOLDER_MAX_DEPTH, maxWatchedFolderDepth); |
| } else { |
| maxWatchedFolderDepth = DEFAULT_FOLDER_MAX_DEPTH; |
| logger.debug("Using default folder max depth {}, not provided by {}", maxWatchedFolderDepth, PROP_INSTALL_FOLDER_MAX_DEPTH); |
| } |
| |
| // Configurable folder regexp, system property overrides default value |
| String folderNameRegexp = (String)getPropertyValue(FOLDER_NAME_REGEXP_PROPERTY); |
| if(folderNameRegexp != null) { |
| folderNameRegexp = folderNameRegexp.trim(); |
| logger.debug("Using configured ({}) folder name regexp '{}'", FOLDER_NAME_REGEXP_PROPERTY, folderNameRegexp); |
| } else { |
| folderNameRegexp = DEFAULT_FOLDER_NAME_REGEXP; |
| logger.debug("Using default folder name regexp '{}', not provided by {}", folderNameRegexp, FOLDER_NAME_REGEXP_PROPERTY); |
| } |
| |
| // Setup folder filtering and watching |
| folderNameFilter = new FolderNameFilter(PropertiesUtil.toStringArray(getPropertyValue(PROP_SEARCH_PATH), DEFAULT_SEARCH_PATH), |
| folderNameRegexp, settings.getRunModes()); |
| roots = folderNameFilter.getRootPaths(); |
| |
| // setup default path for new configurations |
| this.newConfigPath = PropertiesUtil.toString(getPropertyValue(PROP_NEW_CONFIG_PATH), DEFAULT_NEW_CONFIG_PATH); |
| final boolean postSlash = newConfigPath.endsWith("/"); |
| if ( !postSlash ) { |
| this.newConfigPath = newConfigPath.concat("/"); |
| } |
| final boolean preSlash = newConfigPath.startsWith("/"); |
| if ( !preSlash ) { |
| this.newConfigPath = this.folderNameFilter.getRootPaths()[0] + '/' + this.newConfigPath; |
| } |
| |
| this.pauseScanNodePath = PropertiesUtil.toString(getPropertyValue(PROP_SCAN_PROP_PATH), PAUSE_SCAN_NODE_PATH); |
| |
| backgroundThread = new StoppableThread(); |
| backgroundThread.start(); |
| } |
| |
| /** |
| * Deactivate this component |
| */ |
| protected void deactivate(final ComponentContext context) { |
| if ( this.managedServiceRef != null ) { |
| this.managedServiceRef.unregister(); |
| this.managedServiceRef = null; |
| } |
| this.stop(); |
| this.componentContext = null; |
| } |
| |
| private void stop() { |
| logger.info("Deactivating Apache Sling JCR Installer"); |
| |
| final long timeout = 30000L; |
| backgroundThread.active = false; |
| logger.debug("Waiting for " + backgroundThread.getName() + " Thread to end..."); |
| backgroundThread.interrupt(); |
| try { |
| backgroundThread.join(timeout); |
| } catch(InterruptedException iex) { |
| // ignore this as we want to shutdown |
| } |
| backgroundThread = null; |
| |
| folderNameFilter = null; |
| watchedFolders = null; |
| converters.clear(); |
| try { |
| if (session != null) { |
| for(RootFolderListener wfc : listeners) { |
| wfc.cleanup(session); |
| } |
| session.getWorkspace().getObservationManager().removeEventListener(this); |
| if ( moveEventListener != null ) { |
| session.getWorkspace().getObservationManager().removeEventListener(moveEventListener); |
| moveEventListener = null; |
| } |
| } |
| } catch (final RepositoryException e) { |
| logger.warn("Exception in stop()", e); |
| } |
| if ( session != null ) { |
| session.logout(); |
| session = null; |
| } |
| listeners.clear(); |
| } |
| |
| |
| /** |
| * @see org.osgi.service.cm.ManagedService#updated(java.util.Dictionary) |
| */ |
| public void updated(@SuppressWarnings("rawtypes") Dictionary properties) |
| throws ConfigurationException { |
| final boolean restart; |
| if ( this.oldConfiguration == null ) { |
| restart = properties != null; |
| } else { |
| restart = true; |
| } |
| this.oldConfiguration = properties; |
| if ( restart ) { |
| try { |
| this.stop(); |
| this.start(); |
| } catch (final Exception e) { |
| logger.error("Error restarting", e); |
| } |
| } |
| } |
| |
| /** Get a property value from the old config, component context or bundle context */ |
| protected Object getPropertyValue(final String name) { |
| final Dictionary<?, ?> oldConfig = this.oldConfiguration; |
| Object result = null; |
| if ( oldConfig != null ) { |
| result = oldConfig.get(name); |
| if ( result != null ) { |
| logger.warn("Using configuration value from obsolete configuration with PID {} for property {}." + |
| " Please merge this configuration into the configuration with the PID {}.", |
| new Object[] {OLD_PID, name, this.componentContext.getProperties().get(Constants.SERVICE_PID)}); |
| } |
| } |
| if ( result == null ) { |
| result = this.componentContext.getBundleContext().getProperty(name); |
| if (result == null) { |
| result = this.componentContext.getProperties().get(name); |
| } |
| } |
| return result; |
| } |
| |
| /** Find the paths to watch under rootPath, according to our folderNameFilter, |
| * and add them to result */ |
| private void findPathsToWatch(final String rootPath, final List<WatchedFolder> result) throws RepositoryException { |
| Session s = null; |
| |
| try { |
| s = repository.loginAdministrative(repository.getDefaultWorkspace()); |
| if (!s.itemExists(rootPath) || !s.getItem(rootPath).isNode() ) { |
| logger.info("Bundles root node {} not found, ignored", rootPath); |
| } else { |
| logger.debug("Bundles root node {} found, looking for bundle folders inside it", rootPath); |
| final Node n = (Node)s.getItem(rootPath); |
| findPathsUnderNode(n, result); |
| } |
| } finally { |
| if (s != null) { |
| s.logout(); |
| } |
| } |
| } |
| |
| /** |
| * Add n to result if it is a folder that we must watch, and recurse into its children |
| * to do the same. |
| */ |
| void findPathsUnderNode(final Node n, final List<WatchedFolder> result) throws RepositoryException { |
| final String path = n.getPath(); |
| final int priority = folderNameFilter.getPriority(path); |
| if (priority > 0) { |
| result.add(new WatchedFolder(session, path, priority, converters)); |
| } |
| final int depth = path.split("/").length; |
| if(depth > maxWatchedFolderDepth) { |
| logger.debug("Not recursing into {} due to maxWatchedFolderDepth={}", path, maxWatchedFolderDepth); |
| return; |
| } |
| final NodeIterator it = n.getNodes(); |
| while (it.hasNext()) { |
| findPathsUnderNode(it.nextNode(), result); |
| } |
| } |
| |
| /** |
| * Add WatchedFolder to our list if it doesn't exist yet. |
| */ |
| private void addWatchedFolder(final WatchedFolder toAdd) |
| throws RepositoryException { |
| WatchedFolder existing = null; |
| for(WatchedFolder wf : watchedFolders) { |
| if (wf.getPath().equals(toAdd.getPath())) { |
| existing = wf; |
| break; |
| } |
| } |
| if (existing == null) { |
| toAdd.start(); |
| watchedFolders.add(toAdd); |
| } |
| } |
| |
| /** Add new folders to watch if any have been detected |
| * @return a list of InstallableResource that must be unregistered, |
| * for folders that have been removed |
| */ |
| private List<String> updateFoldersList() throws Exception { |
| logger.debug("Updating folder list."); |
| |
| final List<String> result = new LinkedList<String>(); |
| |
| final List<WatchedFolder> newFolders = new ArrayList<WatchedFolder>(); |
| for(String root : roots) { |
| findPathsToWatch(root, newFolders); |
| } |
| for(WatchedFolder wf : newFolders) { |
| addWatchedFolder(wf); |
| } |
| |
| // Check all WatchedFolder, in case some were deleted |
| final List<WatchedFolder> toRemove = new ArrayList<WatchedFolder>(); |
| for(WatchedFolder wf : watchedFolders) { |
| logger.debug("Item {} exists? {}", wf.getPath(), session.itemExists(wf.getPath())); |
| |
| if(!session.itemExists(wf.getPath())) { |
| result.addAll(wf.scan().toRemove); |
| wf.stop(); |
| toRemove.add(wf); |
| } |
| } |
| for(final WatchedFolder wf : toRemove) { |
| logger.info("Deleting {}, path does not exist anymore", wf); |
| watchedFolders.remove(wf); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Check for changes in any of the root folders |
| */ |
| private void checkChanges(final String path) { |
| for(String root : roots) { |
| if (path.startsWith(root)) { |
| logger.info("Got event for root {}, scheduling scanning of new folders", root); |
| updateFoldersListTimer.scheduleScan(); |
| } |
| } |
| } |
| |
| /** |
| * @see javax.jcr.observation.EventListener#onEvent(javax.jcr.observation.EventIterator) |
| */ |
| public void onEvent(final EventIterator it) { |
| // Got a DELETE or ADD on root - schedule folders rescan if one |
| // of our root folders is impacted |
| try { |
| while(it.hasNext()) { |
| final Event e = it.nextEvent(); |
| logger.debug("Got event {}", e); |
| |
| this.checkChanges(e.getPath()); |
| } |
| } catch(RepositoryException re) { |
| logger.warn("RepositoryException in onEvent", re); |
| } |
| } |
| |
| /** |
| * Run periodic scans of our watched folders, and watch for folders creations/deletions. |
| */ |
| public void runOneCycle() { |
| logger.debug("Running watch cycle."); |
| |
| try { |
| boolean didRefresh = false; |
| |
| if (anyWatchFolderNeedsScan()) { |
| session.refresh(false); |
| didRefresh = true; |
| if (scanningIsPaused()) { |
| if (!pauseMessageLogged) { |
| //Avoid flooding the logs every 500 msec so log at info level once |
| logger.info("Detected signal for pausing the JCR Provider i.e. child nodes found under path {}. " + |
| "JCR Provider scanning would not be performed", pauseScanNodePath); |
| pauseMessageLogged = true; |
| } |
| return; |
| } else if (pauseMessageLogged) { |
| pauseMessageLogged = false; |
| } |
| } |
| |
| // Rescan WatchedFolders if needed |
| boolean scanWf = false; |
| for(WatchedFolder wf : watchedFolders) { |
| if (!wf.needsScan()) { |
| continue; |
| } |
| scanWf = true; |
| if ( !didRefresh ) { |
| session.refresh(false); |
| didRefresh = true; |
| } |
| counters[SCAN_FOLDERS_COUNTER]++; |
| final WatchedFolder.ScanResult sr = wf.scan(); |
| boolean toDo = false; |
| if ( sr.toAdd.size() > 0 ) { |
| logger.info("Registering resource with OSGi installer: {}",sr.toAdd); |
| toDo = true; |
| } |
| if ( sr.toRemove.size() > 0 ) { |
| logger.info("Removing resource from OSGi installer: {}", sr.toRemove); |
| toDo = true; |
| } |
| if ( toDo ) { |
| installer.updateResources(URL_SCHEME, sr.toAdd.toArray(new InstallableResource[sr.toAdd.size()]), |
| sr.toRemove.toArray(new String[sr.toRemove.size()])); |
| } |
| } |
| |
| // Update list of WatchedFolder if we got any relevant events, |
| // or if there were any WatchedFolder events |
| if (scanWf || updateFoldersListTimer.expired()) { |
| if (!didRefresh) { |
| session.refresh(false); |
| didRefresh = true; |
| } |
| updateFoldersListTimer.reset(); |
| counters[UPDATE_FOLDERS_LIST_COUNTER]++; |
| final List<String> toRemove = updateFoldersList(); |
| if ( toRemove.size() > 0 ) { |
| logger.info("Removing resource from OSGi installer (folder deleted): {}", toRemove); |
| installer.updateResources(URL_SCHEME, null, |
| toRemove.toArray(new String[toRemove.size()])); |
| } |
| } |
| |
| |
| } catch (final Exception e) { |
| logger.warn("Exception in runOneCycle()", e); |
| } |
| |
| try { |
| Thread.sleep(RUN_LOOP_DELAY_MSEC); |
| } catch (final InterruptedException ignore) { |
| // ignore |
| } |
| counters[RUN_LOOP_COUNTER]++; |
| } |
| |
| boolean scanningIsPaused() throws RepositoryException { |
| if (session.nodeExists(pauseScanNodePath)) { |
| Node node = session.getNode(pauseScanNodePath); |
| boolean result = node.hasNodes(); |
| if (result && logger.isDebugEnabled()) { |
| List<String> nodeNames = new ArrayList<String>(); |
| NodeIterator childItr = node.getNodes(); |
| while (childItr.hasNext()) { |
| nodeNames.add(childItr.nextNode().getName()); |
| } |
| logger.debug("Found child nodes {} at path {}. Scanning would be paused", nodeNames, pauseScanNodePath); |
| } |
| return result; |
| } |
| return false; |
| } |
| |
| private boolean anyWatchFolderNeedsScan() { |
| for (WatchedFolder wf : watchedFolders) { |
| if (wf.needsScan()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| long [] getCounters() { |
| return counters; |
| } |
| |
| /** |
| * @see org.apache.sling.installer.api.UpdateHandler#handleRemoval(java.lang.String, java.lang.String, java.lang.String) |
| */ |
| public UpdateResult handleRemoval(final String resourceType, |
| final String id, |
| final String url) { |
| if ( !this.writeBack ) { |
| return null; |
| } |
| final int pos = url.indexOf(':'); |
| final String path = url.substring(pos + 1); |
| |
| // check path (SLING-2407) |
| // 0. Check protocol |
| if ( !url.startsWith(URL_SCHEME) ) { |
| logger.debug("Not removing unmanaged artifact from repository: {}", url); |
| return null; |
| } |
| // 1. Is this a system configuration then don't delete |
| final String[] rootPaths = this.folderNameFilter.getRootPaths(); |
| final String systemConfigRootPath = rootPaths[rootPaths.length - 1]; |
| if ( path.startsWith(systemConfigRootPath) ) { |
| logger.debug("Not removing system artifact from repository at {}", path); |
| return null; |
| } |
| // 2. Is this configuration provisioned by us |
| boolean found = false; |
| int lastSlash = path.lastIndexOf('/'); |
| while (!found && lastSlash > 1) { |
| final String prefix = path.substring(0, lastSlash); |
| if ( this.folderNameFilter.getPriority(prefix) != -1 ) { |
| found = true; |
| } else { |
| lastSlash = prefix.lastIndexOf('/'); |
| } |
| } |
| if ( found ) { |
| // remove |
| logger.debug("Removing artifact at {}", path); |
| Session session = null; |
| try { |
| session = this.repository.loginAdministrative(null); |
| if ( session.itemExists(path) ) { |
| session.getItem(path).remove(); |
| session.save(); |
| } |
| } catch (final RepositoryException re) { |
| logger.error("Unable to remove resource from " + path, re); |
| return null; |
| } finally { |
| if ( session != null ) { |
| session.logout(); |
| } |
| } |
| return new UpdateResult(url); |
| } |
| // not provisioned by us |
| logger.debug("Not removing unmanaged artifact from repository at {}", path); |
| return null; |
| } |
| |
| /** |
| * @see org.apache.sling.installer.api.UpdateHandler#handleUpdate(java.lang.String, java.lang.String, java.lang.String, java.util.Dictionary, Map) |
| */ |
| public UpdateResult handleUpdate(final String resourceType, |
| final String id, |
| final String url, |
| final Dictionary<String, Object> dict, |
| final Map<String, Object> attributes) { |
| return this.handleUpdate(resourceType, id, url, null, dict, attributes); |
| } |
| |
| /** |
| * @see org.apache.sling.installer.api.UpdateHandler#handleUpdate(java.lang.String, java.lang.String, java.lang.String, java.io.InputStream, Map) |
| */ |
| public UpdateResult handleUpdate(final String resourceType, |
| final String id, |
| final String url, |
| final InputStream is, |
| final Map<String, Object> attributes) { |
| return this.handleUpdate(resourceType, id, url, is, null, attributes); |
| } |
| |
| private String getPathWithHighestPrio(final String oldPath) { |
| final String path; |
| // check root path, we use the path with highest prio |
| final String rootPath = this.folderNameFilter.getRootPaths()[0] + '/'; |
| if ( !oldPath.startsWith(rootPath) ) { |
| final int slashPos = oldPath.indexOf('/', 1); |
| path = rootPath + oldPath.substring(slashPos + 1); |
| } else { |
| path = oldPath; |
| } |
| return path; |
| } |
| |
| /** |
| * Internal implementation of update handling |
| */ |
| private UpdateResult handleUpdate(final String resourceType, |
| final String id, |
| final String url, |
| final InputStream is, |
| final Dictionary<String, Object> dict, |
| final Map<String, Object> attributes) { |
| if ( !this.writeBack ) { |
| return null; |
| } |
| |
| // we only handle add/update of configs for now |
| if ( !resourceType.equals(InstallableResource.TYPE_CONFIG) ) { |
| return null; |
| } |
| |
| Session session = null; |
| try { |
| session = this.repository.loginAdministrative(null); |
| |
| final String path; |
| boolean resourceIsMoved = true; |
| if ( url != null ) { |
| // update |
| final int pos = url.indexOf(':'); |
| final String oldPath = url.substring(pos + 1); |
| |
| // calculate the new node path |
| final String nodePath; |
| if ( url.startsWith(URL_SCHEME + ':') ) { |
| nodePath = getPathWithHighestPrio(oldPath); |
| } else { |
| final int lastSlash = url.lastIndexOf('/'); |
| final int lastPos = url.lastIndexOf('.'); |
| final String name; |
| if ( lastSlash == -1 || lastPos < lastSlash ) { |
| name = id; |
| } else { |
| name = url.substring(lastSlash + 1, lastPos); |
| } |
| nodePath = getPathWithHighestPrio(this.newConfigPath + name + ".config"); |
| } |
| // ensure extension 'config' |
| if ( !nodePath.endsWith(".config") ) { |
| if ( session.itemExists(nodePath) ) { |
| session.getItem(nodePath).remove(); |
| } |
| path = nodePath + ".config"; |
| } else { |
| path = nodePath; |
| } |
| |
| resourceIsMoved = nodePath.equals(oldPath); |
| logger.debug("Update of {} at {}", resourceType, path); |
| } else { |
| // add |
| final String name; |
| if ( attributes != null && attributes.get(InstallableResource.RESOURCE_URI_HINT) != null ) { |
| name = (String)attributes.get(InstallableResource.RESOURCE_URI_HINT); |
| } else { |
| name = id; |
| } |
| path = this.newConfigPath + name + ".config"; |
| logger.debug("Add of {} at {}", resourceType, path); |
| } |
| |
| // write to a byte array stream |
| final ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| ConfigurationHandler.write(baos, dict); |
| baos.close(); |
| |
| // get or create file node |
| JcrUtil.createPath(session, path, NT_FILE); |
| // get or create resource node |
| final Node dataNode = JcrUtil.createPath(session, path + "/jcr:content", NT_RESOURCE); |
| |
| dataNode.setProperty(PROP_DATA, new ByteArrayInputStream(baos.toByteArray())); |
| dataNode.setProperty(PROP_MODIFIED, Calendar.getInstance()); |
| dataNode.setProperty(PROP_ENC, ENCODING); |
| dataNode.setProperty(PROP_MIME, MIME_TXT); |
| session.save(); |
| |
| final UpdateResult result = new UpdateResult(JcrInstaller.URL_SCHEME + ':' + path); |
| // priority |
| final int lastSlash = path.lastIndexOf('/'); |
| final String parentPath = path.substring(0, lastSlash); |
| result.setPriority(this.folderNameFilter.getPriority(parentPath)); |
| result.setResourceIsMoved(resourceIsMoved); |
| return result; |
| } catch (final RepositoryException re) { |
| logger.error("Unable to add/update resource " + resourceType + ':' + id, re); |
| return null; |
| } catch (final IOException e) { |
| logger.error("Unable to add/update resource " + resourceType + ':' + id, e); |
| return null; |
| } finally { |
| if ( session != null ) { |
| session.logout(); |
| } |
| } |
| } |
| |
| } |
