Motor.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package  org.turro.scheduler.motor;
 
import java.util.Date;
import java.util.Set;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import org.amic.util.date.CheckDate;
import org.turro.elephant.context.IConstructor;
import org.turro.i18n.I_;
import org.turro.log.WebLoggers;
import org.turro.scheduler.entities.EntityTask;
import org.turro.scheduler.task.AbstractTask;
import org.turro.scheduler.task.TaskSet;
import org.turro.scheduler.task.migration.TaskMigration;
 
public class Motor implements Runnable {
 
  static private Motor motor = null;
 
  private ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);
  private ScheduledFuture<?> handle;
 
  private Set<AbstractTask> tasks = null;
 
  private int entityDay = 0;
  private EntityTask entityTask = null;
 
  private Motor(IConstructor constructor) {
    this(constructor, 1, TimeUnit.MINUTES);
  }
 
  private Motor(IConstructor constructor, long period, TimeUnit unit) {
    TaskMigration.migrate(constructor);
    tasks = TaskSet.load(constructor);
    handle = scheduler.scheduleAtFixedRate(this, 0, period, unit);
    WebLoggers.info(this).message("Scheduler started.").log();
  }
 
  static public Motor getInstance() {
    return motor;
  }
 
  static public Motor getInstance(IConstructor constructor, long period, TimeUnit unit) {
    return getInstance(constructor, period, unit, false);
  }
 
  static public synchronized Motor getInstance(IConstructor constructor, long period, TimeUnit unit, boolean forceNew) {
    if(forceNew && motor != null) motor.stop();
    if(motor == null || forceNew) motor = new Motor(constructor, period, unit);
    return motor;
  }
 
  public Set<AbstractTask> getTasks() {
    return tasks;
  }
 
  @Override
  public void run() {
    Thread.currentThread().setName("ElephantTaskMotorPool");
    Date now = new Date();
 
    for(AbstractTask task : tasks) {
      if(handle.isCancelled()) break;
      if(task.isDone() &&
              task.getSettings().isActive() &&
              task.shouldRun(now)) {
        WebLoggers.info(this).message(I_.format("%s:%s started.",
                task.getName(), task.getSettings().getDescription())).log();
        task.doRun(this);
      }
    }
 
    CheckDate cd = new CheckDate(now);
    int dayOfYear = cd.getDayOfYear();
    if(dayOfYear != entityDay) {
      entityDay = dayOfYear;
      entityTask = new EntityTask();
      WebLoggers.info(this).message(I_.format("%s:%s started.",
              entityTask.getName(), entityTask.getDescription())).log();
      entityTask.doRun(this);
    }
    
    //LastActivities.generateUserContent(now);
  }
 
  public void stop() {
    for(AbstractTask task : tasks) {
      task.stop();
      WebLoggers.info(this).message(I_.format("%s:%s stopped.",
              task.getName(), task.getSettings().getDescription())).log();
    }
    if(entityTask != null) {
      entityTask.stop();
      WebLoggers.info(this).message(I_.format("%s:%s stopped.",
              entityTask.getName(), entityTask.getDescription())).log();
    }
    handle.cancel(true);
    scheduler.shutdown();
    WebLoggers.info(this).message("Scheduler shutdown.").log();
  }
 
  public ScheduledFuture<?> runTask(AbstractTask task) {
    return scheduler.schedule(task, 5, TimeUnit.SECONDS);
  }
 
}