예제 #1
0
 public static <V> void scheduleForCRON(Job<V> job) {
   if (!job.getClass().isAnnotationPresent(On.class)) {
     return;
   }
   String cron = job.getClass().getAnnotation(On.class).value();
   if (cron.startsWith("cron.")) {
     cron = Play.configuration.getProperty(cron);
   }
   cron = Expression.evaluate(cron, cron).toString();
   if (cron == null || "".equals(cron) || "never".equalsIgnoreCase(cron)) {
     if (Logger.isEnabledFor("INFO"))
       Logger.info("Skipping job %s, cron expression is not defined", job.getClass().getName());
     return;
   }
   try {
     Date now = new Date();
     cron = Expression.evaluate(cron, cron).toString();
     CronExpression cronExp = new CronExpression(cron);
     Date nextDate = cronExp.getNextValidTimeAfter(now);
     if (nextDate == null) {
       if (Logger.isEnabledFor("WARN"))
         Logger.warn(
             "The cron expression for job %s doesn't have any match in the future, will never be executed",
             job.getClass().getName());
       return;
     }
     if (nextDate.equals(job.nextPlannedExecution)) {
       // Bug #13: avoid running the job twice for the same time
       // (happens when we end up running the job a few minutes before the planned time)
       Date nextInvalid = cronExp.getNextInvalidTimeAfter(nextDate);
       nextDate = cronExp.getNextValidTimeAfter(nextInvalid);
     }
     job.nextPlannedExecution = nextDate;
     executor.schedule(
         (Callable<V>) job, nextDate.getTime() - now.getTime(), TimeUnit.MILLISECONDS);
     job.executor = executor;
   } catch (Exception ex) {
     throw new UnexpectedException(ex);
   }
 }
예제 #2
0
  @Override
  public void afterApplicationStart() {
    List<Class<?>> jobs = new ArrayList<Class<?>>();
    for (Class clazz : Play.classloader.getAllClasses()) {
      if (Job.class.isAssignableFrom(clazz)) {
        jobs.add(clazz);
      }
    }
    scheduledJobs = new ArrayList<Job>();
    for (final Class<?> clazz : jobs) {
      // @OnApplicationStart
      if (clazz.isAnnotationPresent(OnApplicationStart.class)) {
        // check if we're going to run the job sync or async
        OnApplicationStart appStartAnnotation = clazz.getAnnotation(OnApplicationStart.class);
        if (!appStartAnnotation.async()) {
          // run job sync
          try {
            Job<?> job = ((Job<?>) clazz.newInstance());
            scheduledJobs.add(job);
            job.run();
            if (job.wasError) {
              if (job.lastException != null) {
                throw job.lastException;
              }
              throw new RuntimeException("@OnApplicationStart Job has failed");
            }
          } catch (InstantiationException e) {
            throw new UnexpectedException("Job could not be instantiated", e);
          } catch (IllegalAccessException e) {
            throw new UnexpectedException("Job could not be instantiated", e);
          } catch (Throwable ex) {
            if (ex instanceof PlayException) {
              throw (PlayException) ex;
            }
            throw new UnexpectedException(ex);
          }
        } else {
          // run job async
          try {
            Job<?> job = ((Job<?>) clazz.newInstance());
            scheduledJobs.add(job);
            // start running job now in the background
            @SuppressWarnings("unchecked")
            Callable<Job> callable = (Callable<Job>) job;
            executor.submit(callable);
          } catch (InstantiationException ex) {
            throw new UnexpectedException("Cannot instanciate Job " + clazz.getName());
          } catch (IllegalAccessException ex) {
            throw new UnexpectedException("Cannot instanciate Job " + clazz.getName());
          }
        }
      }

      // @On
      if (clazz.isAnnotationPresent(On.class)) {
        try {
          Job<?> job = ((Job<?>) clazz.newInstance());
          scheduledJobs.add(job);
          scheduleForCRON(job);
        } catch (InstantiationException ex) {
          throw new UnexpectedException("Cannot instanciate Job " + clazz.getName());
        } catch (IllegalAccessException ex) {
          throw new UnexpectedException("Cannot instanciate Job " + clazz.getName());
        }
      }
      // @Every
      if (clazz.isAnnotationPresent(Every.class)) {
        try {
          Job job = (Job) clazz.newInstance();
          scheduledJobs.add(job);
          String value = job.getClass().getAnnotation(Every.class).value();
          if (value.startsWith("cron.")) {
            value = Play.configuration.getProperty(value);
          }
          value = Expression.evaluate(value, value).toString();
          if (!"never".equalsIgnoreCase(value)) {
            executor.scheduleWithFixedDelay(
                job, Time.parseDuration(value), Time.parseDuration(value), TimeUnit.SECONDS);
          }
        } catch (InstantiationException ex) {
          throw new UnexpectedException("Cannot instanciate Job " + clazz.getName());
        } catch (IllegalAccessException ex) {
          throw new UnexpectedException("Cannot instanciate Job " + clazz.getName());
        }
      }
    }
  }