POMSessionManager.java

/**
 * Copyright (C) 2009 eXo Platform SAS.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */

package org.exoplatform.portal.pom.config;

import java.io.Serializable;
import java.lang.reflect.UndeclaredThrowableException;

import org.exoplatform.commons.chromattic.ChromatticLifeCycle;
import org.exoplatform.commons.chromattic.ChromatticManager;
import org.exoplatform.commons.chromattic.SessionContext;
import org.exoplatform.commons.scope.ScopedKey;
import org.exoplatform.portal.pom.config.cache.DataCache;
import org.exoplatform.portal.pom.config.cache.PortalNamesCache;
import org.exoplatform.portal.pom.data.OwnerKey;
import org.exoplatform.portal.pom.data.PortalKey;
import org.exoplatform.services.cache.CacheService;
import org.exoplatform.services.cache.CachedObjectSelector;
import org.exoplatform.services.cache.ExoCache;
import org.exoplatform.services.cache.ObjectCacheInfo;
import org.exoplatform.services.jcr.RepositoryService;
import org.gatein.common.logging.Logger;
import org.gatein.common.logging.LoggerFactory;
import org.gatein.mop.core.api.MOPService;
import org.picocontainer.Startable;

/**
 * @author <a href="mailto:julien.viet@exoplatform.com">Julien Viet</a>
 * @version $Revision$
 */
public class POMSessionManager implements Startable {

    /** . */
    private final Logger log = LoggerFactory.getLogger(POMSessionManager.class);

    /** . */
    private MOPService pomService;

    /** . */
    private final ExoCache<ScopedKey<?>, Object> cache;

    /** . */
    final ChromatticManager manager;

    /** . */
    private ChromatticLifeCycle configurator;

    /** . */
    private final TaskExecutionDecorator executor;

    /** . */
    private final RepositoryService repositoryService;

    public POMSessionManager(RepositoryService repositoryService, ChromatticManager manager, CacheService cacheService) {
        //
        this.repositoryService = repositoryService;
        this.manager = manager;
        this.cache = cacheService.getCacheInstance("MOPSessionManager");
        this.pomService = null;
        this.executor = new PortalNamesCache(new DataCache(new ExecutorDispatcher()));
    }

    public ChromatticLifeCycle getLifeCycle() {
        return configurator;
    }

    public void cachePut(Serializable key, Object value) {
        ScopedKey<?> globalKey = ScopedKey.create(key);

        //
        if (log.isTraceEnabled()) {
            log.trace("Updating cache key=" + globalKey + " with value=" + value);
        }

        //
        cache.put(globalKey, value);
    }

    public Object cacheGet(Serializable key) {
        ScopedKey globalKey = ScopedKey.create(key);

        //
        Object value = cache.get(globalKey);

        //
        if (log.isTraceEnabled()) {
            log.trace("Obtained for cache key=" + globalKey + " value=" + value);
        }

        //
        return value;
    }

    public void cacheRemove(Serializable key) {
        final ScopedKey<?> globalKey = ScopedKey.create(key);

        //
        if (log.isTraceEnabled()) {
            log.trace("Removing cache key=" + globalKey);
        }

        //
        if (key instanceof PortalKey) {
            // This code seems complex but actually it tries to find all objects in cache that have the same
            // owner key than the portal key, for instance if we remove (portal,classic) then all pages
            // related to (portal,classic) are also evicted
            final PortalKey portalKey = (PortalKey) key;
            try {
                cache.select(new CachedObjectSelector<ScopedKey<?>, Object>() {
                    public boolean select(ScopedKey<?> selectedGlobalKey, ObjectCacheInfo<?> ocinfo) {
                        if (globalKey.getScope().equals(selectedGlobalKey.getScope())) {
                            Serializable selectedLocalKey = selectedGlobalKey.getKey();
                            if (selectedLocalKey instanceof OwnerKey) {
                                OwnerKey selectedOwnerKey = (OwnerKey) selectedLocalKey;
                                if (selectedOwnerKey.getType().equals(portalKey.getType())
                                        && selectedOwnerKey.getId().equals(portalKey.getId())) {
                                    return true;
                                }
                            }
                        }
                        return false;
                    }

                    public void onSelect(ExoCache<? extends ScopedKey<?>, ?> exoCache, ScopedKey<?> key,
                            ObjectCacheInfo<?> ocinfo) throws Exception {
                        cache.remove(key);
                    }
                });
            } catch (Exception e) {
                log.error("Unexpected error when clearing pom cache", e);
            }
        } else {
            cache.remove(globalKey);
        }
    }

    public void start() {
        try {
            MOPChromatticLifeCycle configurator = (MOPChromatticLifeCycle) manager.getLifeCycle("mop");
            configurator.manager = this;

            //
            PortalMOPService pomService = new PortalMOPService(configurator.getChromattic());
            pomService.start();

            //
            this.pomService = pomService;
            this.configurator = configurator;
        } catch (Exception e) {
            throw new UndeclaredThrowableException(e);
        }
    }

    public void stop() {
    }

    public void clearCache() {
        if (log.isTraceEnabled()) {
            log.trace("Clearing cache");
        }

        //
        cache.clearCache();
    }

    public MOPService getPOMService() {
        return pomService;
    }

    public <E extends TaskExecutionDecorator> E getDecorator(Class<E> decoratorClass) {
        return executor.getDecorator(decoratorClass);
    }

    /**
     * <p>
     * Returns the session currently associated with the current thread of execution.
     * </p>
     *
     * @return the current session
     */
    public POMSession getSession() {
        SessionContext context = configurator.getContext();
        return context != null ? (POMSession) context.getAttachment("mopsession") : null;
    }

    /**
     * <p>
     * Open and returns a session to the model. When the current thread is already associated with a previously opened session
     * the method will throw an <tt>IllegalStateException</tt>.
     * </p>
     *
     * @return a session to the model.
     */
    public POMSession openSession() {
        SessionContext context = configurator.openContext();
        return (POMSession) context.getAttachment("mopsession");
    }

    /**
     * <p>
     * Execute the task with a session.
     * </p>
     *
     * @param task the task to execute
     * @throws Exception any exception thrown by the task
     * @return the value
     */
    public <V> V execute(POMTask<V> task) throws Exception {
        POMSession session = getSession();

        //
        return executor.execute(session, task);
    }

}