| /* |
| * 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.cocoon.caching.impl; |
| |
| import java.io.Serializable; |
| import java.util.Iterator; |
| import java.util.Timer; |
| import java.util.TimerTask; |
| |
| import org.apache.avalon.framework.activity.Initializable; |
| import org.apache.avalon.framework.activity.Startable; |
| import org.apache.avalon.framework.parameters.ParameterException; |
| import org.apache.avalon.framework.parameters.Parameters; |
| import org.apache.avalon.framework.service.ServiceException; |
| import org.apache.avalon.framework.service.ServiceManager; |
| import org.apache.cocoon.ProcessingException; |
| import org.apache.cocoon.caching.CachedResponse; |
| import org.apache.cocoon.caching.EventAware; |
| import org.apache.cocoon.caching.EventRegistry; |
| import org.apache.cocoon.caching.validity.Event; |
| import org.apache.cocoon.caching.validity.EventValidity; |
| import org.apache.cocoon.components.source.impl.SitemapSource; |
| import org.apache.excalibur.source.SourceValidity; |
| import org.apache.excalibur.source.impl.validity.AbstractAggregatedValidity; |
| |
| /** |
| * This implementation holds all mappings between Events and PipelineCacheKeys |
| * in two MultiValueMaps to facilitate efficient lookup by either as Key. |
| * |
| * @version $Id$ |
| */ |
| public class EventAwareCacheImpl |
| extends CacheImpl |
| implements Initializable, Startable, EventAware { |
| |
| private ServiceManager m_manager; |
| |
| private EventRegistry m_eventRegistry; |
| |
| // clean-up thread |
| private static final Timer timer = new Timer(true); |
| private TimerTask timerTask; |
| private long interval; |
| |
| public void parameterize(Parameters parameters) throws ParameterException { |
| |
| super.parameterize(parameters); |
| this.interval = parameters.getParameterAsInteger("cleanupthreadinterval",1000*60*60); // 1 hour |
| if(this.interval < 1) { |
| throw new ParameterException("EventAwareCacheImpl cleanupthreadinterval parameter has to be greater then 1"); |
| } |
| |
| String eventRegistryName = parameters.getParameter("registry", EventRegistry.ROLE); |
| try { |
| this.m_eventRegistry = (EventRegistry)m_manager.lookup(eventRegistryName); |
| } catch (ServiceException e) { |
| throw new ParameterException("Unable to lookup registry: " + eventRegistryName, e); |
| } |
| } |
| |
| /** |
| * Clears the entire Cache, including all registered event-pipeline key |
| * mappings.. |
| */ |
| public void clear() { |
| super.clear(); |
| m_eventRegistry.clear(); |
| } |
| |
| /** |
| * When a new Pipeline key is stored, it needs to have it's |
| * <code>SourceValidity</code> objects examined. For every |
| * <code>EventValidity</code> found, it's <code>Event</code> will be |
| * registered with this key in the <code>EventRegistry</code>. |
| * |
| * <code>AggregatedValidity</code> is handled recursively. |
| */ |
| public void store(Serializable key, |
| CachedResponse response) |
| throws ProcessingException { |
| SourceValidity[] validities = response.getValidityObjects(); |
| for (int i=0; i< validities.length;i++) { |
| SourceValidity val = validities[i]; |
| examineValidity(val, key); |
| } |
| super.store(key, response); |
| } |
| |
| /** |
| * Look up the EventRegistry |
| */ |
| public void service(ServiceManager manager) throws ServiceException { |
| this.m_manager = manager; |
| super.service(manager); |
| } |
| |
| /** |
| * Un-register this key in the EventRegistry in addition to |
| * removing it from the Store |
| */ |
| public void remove(Serializable key) { |
| super.remove(key); |
| m_eventRegistry.removeKey(key); |
| } |
| |
| /** |
| * Receive notification about the occurrence of an Event. |
| * If this event has registered pipeline keys, remove them |
| * from the Store and unregister them |
| * @param e The Event to be processed. |
| */ |
| public void processEvent(Event e) { |
| if (e == null) return; |
| Serializable[] keys = m_eventRegistry.keysForEvent(e); |
| if (keys == null) return; |
| for (int i=0;i<keys.length; i++) { |
| if (keys[i] != null) { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Processing cache event, found Pipeline key: " + keys[i].toString()); |
| } |
| /* every pck associated with this event needs to be |
| * removed -- regardless of event mapping. and every |
| * event mapped to those keys needs to be removed |
| * recursively. |
| */ |
| remove(keys[i]); |
| } |
| } |
| } |
| |
| /** |
| * Get the EventRegistry ready, and make sure it does not contain |
| * orphaned Event/PipelineKey mappings. |
| */ |
| public void initialize() throws Exception { |
| if (!m_eventRegistry.wasRecoverySuccessful()) { |
| super.clear(); |
| } else { |
| // Not sure if we want this overhead here, but where else? |
| verifyEventCache(); |
| } |
| } |
| |
| /** |
| * Ensure that all PipelineCacheKeys registered to events still |
| * point to valid cache entries. Having an isTotallyEmpty() on |
| * Store might make this less necessary, as the most likely time |
| * to discover orphaned entries is at startup. This is because |
| * stray events could hang around indefinitely if the cache is |
| * removed abnormally or is not configured with persistence. |
| */ |
| public void verifyEventCache() { |
| Serializable[] keys = m_eventRegistry.allKeys(); |
| if (keys == null) return; |
| for (int i=0; i<keys.length; i++) { |
| if (!this.containsKey(keys[i])) { |
| m_eventRegistry.removeKey(keys[i]); |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Cache key no longer valid: " + |
| keys[i]); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Release resources |
| */ |
| public void dispose() { |
| m_manager.release(m_eventRegistry); |
| super.dispose(); |
| m_manager = null; |
| m_eventRegistry = null; |
| } |
| |
| private void examineValidity(SourceValidity val, Serializable key) { |
| if (val instanceof AbstractAggregatedValidity) { |
| handleAggregatedValidity((AbstractAggregatedValidity)val, key); |
| } else if (val instanceof EventValidity) { |
| handleEventValidity((EventValidity)val, key); |
| } else if (val instanceof SitemapSource.SitemapSourceValidity) { |
| examineValidity(((SitemapSource.SitemapSourceValidity) val).getNestedValidity(), key); |
| } |
| } |
| |
| private void handleAggregatedValidity( |
| AbstractAggregatedValidity val, |
| Serializable key) { |
| // AggregatedValidity must be investigated further. |
| Iterator it = val.getValidities().iterator(); |
| while (it.hasNext()) { |
| SourceValidity thisVal = (SourceValidity)it.next(); |
| // Allow recursion |
| examineValidity(thisVal, key); |
| } |
| } |
| |
| private void handleEventValidity(EventValidity val, Serializable key) { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Found EventValidity: " + val.toString()); |
| } |
| m_eventRegistry.register(val.getEvent(),key); |
| } |
| |
| /** |
| * starts cache-cleaner timer task scheduling |
| */ |
| public void start() throws Exception { |
| getLogger().debug("Intializing event-cache checker thread"); |
| timerTask = new TimerTask() { public void run() {verifyEventCache();}; }; |
| timer.schedule(timerTask, interval, interval); |
| } |
| |
| /** |
| * stops cache-cleaner timer task scheduling |
| */ |
| public void stop() { |
| timerTask.cancel(); |
| } |
| } |
