TaskRunnerImpl.java

/*
    This file is part of Cyclos (www.cyclos.org).
    A project of the Social Trade Organisation (www.socialtrade.org).

    Cyclos is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Cyclos 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Cyclos; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 */
package nl.strohalm.cyclos.utils.tasks;

import java.util.Calendar;
import java.util.Collection;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;

import nl.strohalm.cyclos.scheduling.SchedulingHandler;
import nl.strohalm.cyclos.scheduling.tasks.ScheduledTask;
import nl.strohalm.cyclos.services.InitializingService;
import nl.strohalm.cyclos.utils.FormatObject;
import nl.strohalm.cyclos.utils.ParallelTask;
import nl.strohalm.cyclos.utils.TransactionHelper;
import nl.strohalm.cyclos.utils.access.LoggedUser;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;

/**
 * Base implementation for task runners
 * 
 * @author luis
 */
public class TaskRunnerImpl implements TaskRunner, ApplicationContextAware {

    /**
     * Parallel threads used to run initializations
     * @author luis
     */
    private class InitializationThreads extends ParallelTask<String> {

        public InitializationThreads() {
            super("Initialization");
        }

        @Override
        protected void process(final String initialization) {
            doRunInitialization(initialization);
        }

    }

    /**
     * Parallel threads used to run scheduled tasks
     * @author luis
     */
    private class ScheduledTaskThreads extends ParallelTask<String> {
        private final Calendar time;

        public ScheduledTaskThreads(final Calendar time) {
            super("Scheduled tasks for " + FormatObject.formatObject(time));
            this.time = time;
        }

        @Override
        protected void process(final String scheduledTask) {
            doRunScheduledTask(scheduledTask, time);
        }

    }

    protected static final Log   LOG = LogFactory.getLog(TaskRunnerImpl.class);

    protected ApplicationContext applicationContext;
    private TransactionHelper    transactionHelper;
    private SchedulingHandler    schedulingHandler;

    @Override
    public void handleDatabaseInitialization(final Runnable runnable) {
        doHandleDatabaseInitialization(runnable);
    }

    @Override
    public void runInitializations(final Collection<String> beanNames) {
        InitializationThreads threads = new InitializationThreads();
        threads.run(beanNames);
    }

    @Override
    public boolean runPollingTask(final String key, final Callable<Boolean> task) {
        return doRunPollingTask(key, task);
    }

    @Override
    public void runScheduledTasks(final Calendar time, final Collection<String> taskNames) {
        ScheduledTaskThreads threads = new ScheduledTaskThreads(time);
        threads.run(taskNames);
    }

    @Override
    public final void setApplicationContext(final ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    protected void doHandleDatabaseInitialization(final Runnable runnable) {
        try {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Handling database initialization");
            }
            runnable.run();
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
    }

    protected void doRunInitialization(final String beanName) {
        final InitializingService service = applicationContext.getBean(beanName, InitializingService.class);
        getTransactionHelper().runInCurrentThread(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(final TransactionStatus status) {
                try {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("Running initialization for bean " + beanName);
                    }
                    LoggedUser.runAsSystem(Executors.callable(new Runnable() {
                        @Override
                        public void run() {
                            service.initializeService();
                        }
                    }));
                } catch (RuntimeException e) {
                    LOG.error("Error running initialization for bean " + beanName, e);
                    throw e;
                }
            }
        });
    }

    protected boolean doRunPollingTask(final String key, final Callable<Boolean> task) {
        return getTransactionHelper().runInCurrentThread(new TransactionCallback<Boolean>() {
            @Override
            public Boolean doInTransaction(final TransactionStatus status) {
                try {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("Running polling task " + key);
                    }
                    return LoggedUser.runAsSystem(task);
                } catch (RuntimeException e) {
                    LOG.error("Error running polling task" + key, e);
                    return false;
                }
            }
        });
    }

    protected void doRunScheduledTask(final String taskName, final Calendar time) {
        final ScheduledTask task = getSchedulingHandler().getTask(taskName);
        if (LOG.isDebugEnabled()) {
            LOG.debug("Running scheduled task " + taskName + " with base time " + FormatObject.formatObject(time));
        }
        if (task.shouldRunInTransaction()) {
            getTransactionHelper().runInCurrentThread(new TransactionCallbackWithoutResult() {
                @Override
                protected void doInTransactionWithoutResult(final TransactionStatus status) {
                    if (!doRunScheduledTask(task, time)) {
                        status.setRollbackOnly();
                    }
                }
            });
        } else {
            doRunScheduledTask(task, time);
        }
    }

    protected SchedulingHandler getSchedulingHandler() {
        if (schedulingHandler == null) {
            schedulingHandler = applicationContext.getBean("schedulingHandler", SchedulingHandler.class);
        }
        return schedulingHandler;
    }

    protected TransactionHelper getTransactionHelper() {
        if (transactionHelper == null) {
            transactionHelper = applicationContext.getBean("transactionHelper", TransactionHelper.class);
        }
        return transactionHelper;
    }

    private boolean doRunScheduledTask(final ScheduledTask task, final Calendar time) {
        try {
            LoggedUser.runAsSystem(Executors.callable(new Runnable() {
                @Override
                public void run() {
                    task.run(time);
                }
            }));
            return true;
        } catch (final Exception e) {
            LOG.error("Error running scheduled task " + task.getName(), e);
            return false;
        }
    }

}