/FileExtraction/Java_unseen/dlitz_resin/modules/resin/src/com/caucho/resources/ScheduledTask.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source 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.
 *
 * Resin Open Source 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, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */
package com.caucho.resources;

import java.util.Date;
import java.util.TimerTask;
import java.util.concurrent.Executor;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.annotation.PostConstruct;
import javax.ejb.Startup;
import javax.el.ELContext;
import javax.el.MethodExpression;
import javax.enterprise.inject.Instance;
import javax.inject.Inject;
import javax.inject.Singleton;
import javax.resource.spi.work.Work;
import javax.servlet.RequestDispatcher;

import com.caucho.config.ConfigException;
import com.caucho.config.Configurable;
import com.caucho.config.Unbound;
import com.caucho.config.inject.CandiELContext;
import com.caucho.config.inject.InjectManager;
import com.caucho.config.types.CronType;
import com.caucho.config.types.Period;
import com.caucho.config.types.Trigger;
import com.caucho.loader.Environment;
import com.caucho.loader.EnvironmentClassLoader;
import com.caucho.loader.EnvironmentListener;
import com.caucho.server.http.StubServletRequest;
import com.caucho.server.http.StubServletResponse;
import com.caucho.server.util.ScheduledThreadPool;
import com.caucho.server.webapp.WebApp;
import com.caucho.util.Alarm;
import com.caucho.util.AlarmListener;
import com.caucho.util.L10N;

/**
 * The cron resources starts application Work tasks at cron-specified
 * intervals.
 */

@Singleton
@Startup
@Unbound
@Configurable  
public class ScheduledTask
  implements AlarmListener, EnvironmentListener
{
  private static final L10N L = new L10N(ScheduledTask.class);
  private static final Logger log
    = Logger.getLogger(ScheduledTask.class.getName());

  private Executor _threadPool;

  private ClassLoader _loader;
  
  private Trigger _trigger;
  
  private TimerTrigger _timerTrigger = new TimerTrigger();
  
  private Runnable _task;
  private MethodExpression _method;
  
  private String _url;

  @SuppressWarnings("unused")
  private @Inject Instance<WebApp> _webAppInstance;
  private WebApp _webApp;
  
  private Alarm _alarm;

  private volatile boolean _isActive;

  /**
   * Constructor.
   */
  public ScheduledTask()
  {
    _loader = Thread.currentThread().getContextClassLoader();

    _threadPool = ScheduledThreadPool.getLocal();
  }

  /**
   * Sets the delay
   */
  @Configurable  
  public void setDelay(Period delay)
  {
    _trigger = _timerTrigger;

    _timerTrigger.setFirstTime(Alarm.getExactTime() + delay.getPeriod());
  }

  /**
   * Sets the period
   */
  @Configurable  
  public void setPeriod(Period period)
  {
    _trigger = _timerTrigger;

    _timerTrigger.setPeriod(period.getPeriod());
  }

  /**
   * Sets the cron interval.
   */
  @Configurable  
  public void setCron(String cron)
  {
    _trigger = new CronType(cron);
  }

  /**
   * Sets the method expression as a task
   */
  @Configurable  
  public void setMethod(MethodExpression method)
  {
    _method = method;
  }

  /**
   * Sets the url expression as a task
   */
  @Configurable  
  public void setUrl(String url)
  {
    if (! url.startsWith("/"))
      throw new ConfigException(L.l("url '{0}' must be absolute", url));
    
    _url = url;

    _webApp = WebApp.getCurrent();

    /*
      throw new ConfigException(L.l("relative url '{0}' requires web-app context",
                                    url));
    */
  }

  /**
   * Sets the task.
   */
  @Configurable  
  public void setTask(Runnable task)
  {
    _task = task;
  }

  public Runnable getTask()
  {
    return _task;
  }
  
  @Configurable
  public void add(Runnable task)
  {
    _task = task;
  }

  /**
   * Initialization.
   */
  @PostConstruct
  public void init()
    throws ConfigException
  {
    if (_task != null) {
    }
    else if (_method != null) {
      _task = new MethodTask(_method);
    }
    else if (_url != null) {
      _task = new ServletTask(_url, _webApp);
    }

    if (_task == null)
      throw new ConfigException(L.l("{0} requires a <task>, <method>, or <url> because the ScheduledTask needs a task to run.",
                                    this));

    if (_trigger == null) {
      _timerTrigger.setFirstTime(Long.MAX_VALUE / 2);
      _trigger = _timerTrigger;
    }
    
    Environment.addEnvironmentListener(this);
  }

  private void start()
  {
    long now = Alarm.getCurrentTime();
    
    long nextTime = _trigger.nextTime(now + 500);

    _isActive = true;

    assert(_task != null);

    _alarm = new Alarm("cron-resource", this, nextTime - now);

    if (log.isLoggable(Level.FINER))
      log.finer(this + " started. Next event at " + new Date(nextTime));
  }

  private void stop()
  {
    _isActive = false;
    Alarm alarm = _alarm;
    _alarm = null;
    
    if (alarm != null)
      alarm.dequeue();

    if (_task instanceof Work)
      ((Work) _task).release();
    else if (_task instanceof TimerTask)
      ((TimerTask) _task).cancel();
  }

  /**
   * The runnable.
   */
  @Override
  public void handleAlarm(Alarm alarm)
  {
    if (! _isActive)
      return;

    Thread thread = Thread.currentThread();
    ClassLoader oldLoader = thread.getContextClassLoader();
    
    try {
      thread.setContextClassLoader(_loader);
      
      log.fine(this + " executing " + _task);

      _threadPool.execute(_task);

      // XXX: needs QA
      long now = Alarm.getExactTime();
      long nextTime = _trigger.nextTime(now + 500);

      if (_isActive) {
        alarm.queueAt(nextTime);

        if (log.isLoggable(Level.FINER))
          log.finer(this + " complete. Next event at " + new Date(nextTime));
      }
    } catch (Exception e) {
      log.log(Level.WARNING, e.toString(), e);
    } finally {
      thread.setContextClassLoader(oldLoader);
    }
  }

  public void environmentConfigure(EnvironmentClassLoader loader)
    throws ConfigException
  {
  }

  public void environmentBind(EnvironmentClassLoader loader)
    throws ConfigException
  {
  }
  
  public void environmentStart(EnvironmentClassLoader loader)
  {
    start();
  }
  
  public void environmentStop(EnvironmentClassLoader loader)
  {
    stop();
  }

  public String toString()
  {
    return getClass().getSimpleName() + "[" + _task + "," + _trigger + "]";
  }

  public static class MethodTask implements Runnable {
    private static final Object[] _args = new Object[0];
    
    private ELContext _elContext;
    private MethodExpression _method;

    MethodTask(MethodExpression method)
    {
      _method = method;
      _elContext = new CandiELContext(InjectManager.create());
    }

    public void run()
    {
      _method.invoke(_elContext, _args);
    }

    public String toString()
    {
      return getClass().getSimpleName() + "[" + _method + "]";
    }
  }

  public class ServletTask implements Runnable {
    private String _url;
    private WebApp _webApp;

    ServletTask(String url, WebApp webApp)
    {
      _url = url;
      _webApp = webApp;
    }

    public void run()
    {
      StubServletRequest req = new StubServletRequest();
      StubServletResponse res = new StubServletResponse();

      try {
        RequestDispatcher dispatcher = _webApp.getRequestDispatcher(_url);

        dispatcher.forward(req, res);
      } catch (Exception e) {
        log.log(Level.FINE, e.toString(), e);
      }
    }

    public String toString()
    {
      return getClass().getSimpleName() + "[" + _url + "," + _webApp + "]";
    }
  }
}
