Пример #1
0
 @Test
 public void testIsEmbeddableAnnotated() {
   assertTrue(finder.isEmbeddableAnnotated(job.getClass()));
   assertFalse(finder.isEmbeddableAnnotated(person.getClass()));
   assertFalse(finder.isEmbeddableAnnotated(getClass()));
   assertFalse(finder.isEmbeddableAnnotated(null));
 }
Пример #2
0
 @Test
 public void testFindMethodColumns() {
   Map<String, Class> columnMap = new HashMap<String, Class>();
   finder.findMethodColumns(Job.class, null, columnMap, false);
   String columnType = columnMap.get("job_name").getCanonicalName();
   assertTrue("expecting size == 2 but found " + columnMap.size(), columnMap.size() == 2);
   assertNotNull(
       "expecting not null but found " + columnMap.get("job_name"), columnMap.get("job_name"));
   assertNotNull(
       "expecting not null but found " + columnMap.get("postal_code"),
       columnMap.get("postal_code"));
   columnMap.clear();
   finder.findMethodColumns(Job.class, null, columnMap, true);
   assertTrue("expecting size == 1 but found " + columnMap.size(), columnMap.size() == 1);
   assertNotNull(
       "expecting not null but found " + columnMap.get("job_name"), columnMap.get("job_name"));
   columnMap.clear();
   finder.findMethodColumns(Address.class, "zipcode", columnMap, false);
   assertTrue("expecting size == 1 but found " + columnMap.size(), columnMap.size() == 1);
   assertNotNull(
       "expecting not null but found " + columnMap.get("postal_code"),
       columnMap.get("postal_code"));
   assertTrue(
       "expecting 'java.lang.String' but found " + columnMap.get("postal_code").getCanonicalName(),
       columnMap.get("postal_code").getCanonicalName().equals("java.lang.String"));
   columnMap.clear();
   finder.findMethodColumns(Address.class, "zipcode", columnMap, true);
   assertTrue("expecting size == 1 but found " + columnMap.size(), columnMap.size() == 1);
   assertNotNull(
       "expecting not null but found " + columnMap.get("postal_code"),
       columnMap.get("postal_code"));
   columnMap.clear();
   finder.findMethodColumns(Person.class, "", columnMap, false);
   assertTrue("expecting size == 2 but found " + columnMap.size(), columnMap.size() == 2);
   assertNotNull(
       "expecting not null but found " + columnMap.get("job_name"), columnMap.get("job_name"));
   assertNotNull(
       "expecting not null but found " + columnMap.get("postal_code"),
       columnMap.get("postal_code"));
   columnMap.clear();
   finder.findMethodColumns(Person.class, "", columnMap, true);
   assertTrue("expecting size == 0 but found " + columnMap.size(), columnMap.isEmpty());
   columnMap.clear();
   finder.findMethodColumns(Person.class, "name", columnMap, false);
   assertTrue("expecting size == 1 but found " + columnMap.size(), columnMap.size() == 1);
   assertNotNull(
       "expecting not null but found " + columnMap.get("job_name"), columnMap.get("job_name"));
   columnMap.clear();
   finder.findMethodColumns(Person.class, "name", columnMap, true);
   assertTrue("expecting size == 0 but found " + columnMap.size(), columnMap.isEmpty());
   columnMap.clear();
   finder.findMethodColumns(job.getClass(), "dummyMethodName", columnMap, false);
   assertTrue("expecting size == 0 but found " + columnMap.size(), columnMap.isEmpty());
 }
Пример #3
0
 public static void scheduleForCRON(Job job) {
   if (job.getClass().isAnnotationPresent(On.class)) {
     String cron = ((On) (job.getClass().getAnnotation(On.class))).value();
     if (cron.startsWith("cron.")) {
       cron = Play.configuration.getProperty(cron);
     }
     if (cron != null && !cron.equals("")) {
       try {
         Date now = new Date();
         Date nextDate = Time.parseCRONExpression(cron);
         long delay = nextDate.getTime() - now.getTime();
         executor.schedule((Callable) job, delay, TimeUnit.MILLISECONDS);
         job.executor = executor;
       } catch (Exception ex) {
         throw new UnexpectedException(ex);
       }
     } else {
       Logger.info("Skipping job %s, cron expression is not defined", job.getClass().getName());
     }
   }
 }
Пример #4
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);
   }
 }
Пример #5
0
  @Test
  public void testFindAllColumnNamesFrom() {
    checkColumnNameWith(finder.findAllColumnNamesFrom(job.getClass(), null, false));
    checkColumnNameWith(finder.findAllColumnNamesFrom(person.getClass(), "", false));

    Map<String, Class> columnMap = finder.findAllColumnNamesFrom(person.getClass(), "name", false);
    assertEquals(columnMap.get("job_name").getCanonicalName(), "java.lang.String");
    assertTrue("expecting size == 1 but found " + columnMap.size(), columnMap.size() == 1);

    columnMap = finder.findAllColumnNamesFrom(person.getClass(), "dummy", false);
    assertTrue("expecting size == 0 but found " + columnMap.size(), columnMap.isEmpty());

    columnMap = finder.findAllColumnNamesFrom(job.getClass(), null, true);
    assertTrue("expecting size == 2 but found " + columnMap.size(), columnMap.size() == 2);
    assertNotNull(
        "expecting not null but found " + columnMap.get("job_name"), columnMap.get("job_name"));
    assertNotNull(
        "expecting not null but found " + columnMap.get("summary"), columnMap.get("summary"));

    columnMap = finder.findAllColumnNamesFrom(person.getClass(), "", true);
    assertTrue("expecting size == 0 but found " + columnMap.size(), columnMap.isEmpty());
    columnMap = finder.findAllColumnNamesFrom(person.getClass(), "name", true);
    assertTrue("expecing size == 0 but found " + columnMap.size(), columnMap.isEmpty());
  }
Пример #6
0
  /**
   * are we so overloaded that we should drop the given job? This is driven both by the numReady and
   * waiting jobs, the type of job in question, and what the router's router.maxWaitingJobs config
   * parameter is set to.
   */
  private boolean shouldDrop(Job job, long numReady) {
    if (_maxWaitingJobs <= 0) return false; // dont ever drop jobs
    if (!_allowParallelOperation) return false; // dont drop during startup [duh]
    if (numReady > _maxWaitingJobs) {
      Class cls = job.getClass();
      // lets not try to drop too many tunnel messages...
      // if (cls == HandleTunnelMessageJob.class)
      //    return true;

      // we don't really *need* to answer DB lookup messages
      // This is pretty lame, there's actually a ton of different jobs we
      // could drop, but is it worth making a list?
      if (cls == HandleFloodfillDatabaseLookupMessageJob.class) return true;
    }
    return false;
  }
Пример #7
0
  public static void startJob(String jobName, Job job, String time)
      throws SchedulerException, ParseException {
    Scheduler sched = sf.getScheduler();

    JobDetail jobDetail = new JobDetail();
    jobDetail.setName(jobName);
    jobDetail.setGroup(JOB_GROUP_NAME);
    jobDetail.setJobClass(job.getClass());

    CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);
    trigger.setCronExpression(time);
    sched.scheduleJob(jobDetail, trigger);

    if (!sched.isShutdown()) {
      sched.start();
    }
  }
Пример #8
0
 @Test
 public void testFindFieldColumns() {
   Map<String, Class> columnMap = new HashMap<String, Class>();
   finder.findFieldColumns(job.getClass(), null, columnMap, false);
   String columnType = columnMap.get("summary").getCanonicalName();
   assertEquals(
       "expecting 'java.lang.String' but found " + columnType, columnType, "java.lang.String");
   columnMap.clear();
   finder.findFieldColumns(job.getClass(), null, columnMap, true);
   assertNotNull(
       "expecting not null but found " + columnMap.get("summary"), columnMap.get("summary"));
   assertTrue("expecting size == 1 but found " + columnMap.size(), columnMap.size() == 1);
   columnMap.clear();
   finder.findFieldColumns(person.getClass(), null, columnMap, false);
   columnType = columnMap.get("summary").getCanonicalName();
   assertTrue(
       "expecting 'java.lang.String' but found " + columnType,
       columnType.equals("java.lang.String"));
   columnMap.clear();
   finder.findFieldColumns(person.getClass(), null, columnMap, true);
   assertTrue("expecting size == 0 but found " + columnMap.size(), columnMap.isEmpty());
   columnMap.clear();
   finder.findFieldColumns(job.getClass(), "zipCode", columnMap, false);
   assertTrue("expecting size == 0 but found " + columnMap.size(), columnMap.isEmpty());
   columnMap.clear();
   finder.findFieldColumns(job.getClass(), "zipCode", columnMap, true);
   assertTrue("expecting size == 0 but found " + columnMap.size(), columnMap.isEmpty());
   columnMap.clear();
   finder.findFieldColumns(job.getClass(), "name", columnMap, true);
   assertTrue("expecting size == 0 but found " + columnMap.size(), columnMap.isEmpty());
   columnMap.clear();
   finder.findFieldColumns(job.getClass(), "dummyFieldName", columnMap, false);
   assertTrue("expecting size == 0 but found " + columnMap.size(), columnMap.isEmpty());
   columnMap.clear();
   finder.findFieldColumns(job.getClass(), "description", columnMap, true);
   assertTrue("expecting size == 1 but found " + columnMap.size(), columnMap.size() == 1);
   assertNotNull(
       "expecting not null but found " + columnMap.get("summary"), columnMap.get("summary"));
 }
Пример #9
0
  @Override
  public String getStatus() {
    StringWriter sw = new StringWriter();
    PrintWriter out = new PrintWriter(sw);
    if (executor == null) {
      out.println("Jobs execution pool:");
      out.println("~~~~~~~~~~~~~~~~~~~");
      out.println("(not yet started)");
      return sw.toString();
    }
    out.println("Jobs execution pool:");
    out.println("~~~~~~~~~~~~~~~~~~~");
    out.println("Pool size: " + executor.getPoolSize());
    out.println("Active count: " + executor.getActiveCount());
    out.println("Scheduled task count: " + executor.getTaskCount());
    out.println("Queue size: " + executor.getQueue().size());
    SimpleDateFormat df = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
    if (!scheduledJobs.isEmpty()) {
      out.println();
      out.println("Scheduled jobs (" + scheduledJobs.size() + "):");
      out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~");
      for (Job job : scheduledJobs) {
        out.print(job.getClass().getName());
        if (job.getClass().isAnnotationPresent(OnApplicationStart.class)) {
          OnApplicationStart appStartAnnotation =
              job.getClass().getAnnotation(OnApplicationStart.class);
          out.print(
              " run at application start" + (appStartAnnotation.async() ? " (async)" : "") + ".");
        }

        if (job.getClass().isAnnotationPresent(On.class)) {

          String cron = job.getClass().getAnnotation(On.class).value();
          if (cron != null && cron.startsWith("cron.")) {
            cron = Play.configuration.getProperty(cron);
          }
          out.print(" run with cron expression " + cron + ".");
        }
        if (job.getClass().isAnnotationPresent(Every.class)) {
          out.print(" run every " + job.getClass().getAnnotation(Every.class).value() + ".");
        }
        if (job.lastRun > 0) {
          out.print(" (last run at " + df.format(new Date(job.lastRun)));
          if (job.wasError) {
            out.print(" with error)");
          } else {
            out.print(")");
          }
        } else {
          out.print(" (has never run)");
        }
        out.println();
      }
    }
    if (!executor.getQueue().isEmpty()) {
      out.println();
      out.println("Waiting jobs:");
      out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~");
      for (Object o : executor.getQueue()) {
        ScheduledFuture task = (ScheduledFuture) o;
        out.println(
            Java.extractUnderlyingCallable((FutureTask) task)
                + " will run in "
                + task.getDelay(TimeUnit.SECONDS)
                + " seconds");
      }
    }
    return sw.toString();
  }
Пример #10
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());
        }
      }
    }
  }
Пример #11
0
 @Override
 public void afterApplicationStart() {
   List<Class> jobs = new ArrayList();
   for (Class clazz : Play.classloader.getAllClasses()) {
     if (Job.class.isAssignableFrom(clazz)) {
       jobs.add(clazz);
     }
   }
   scheduledJobs = new ArrayList();
   for (final Class clazz : jobs) {
     // @OnApplicationStart
     if (clazz.isAnnotationPresent(OnApplicationStart.class)) {
       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);
       }
     }
     // @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 = ((Every) (job.getClass().getAnnotation(Every.class))).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());
       }
     }
   }
 }