protected void initJobState() throws Exception {
    List<String> groupNames = _persistedScheduler.getJobGroupNames();

    for (String groupName : groupNames) {
      Set<JobKey> jobkeys = _persistedScheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName));

      for (JobKey jobKey : jobkeys) {
        Trigger trigger =
            _persistedScheduler.getTrigger(new TriggerKey(jobKey.getName(), jobKey.getGroup()));

        if (trigger != null) {
          continue;
        }

        JobDetail jobDetail = _persistedScheduler.getJobDetail(jobKey);

        JobDataMap jobDataMap = jobDetail.getJobDataMap();

        Message message = getMessage(jobDataMap);

        message.put(SchedulerEngine.JOB_NAME, jobKey.getName());
        message.put(SchedulerEngine.GROUP_NAME, jobKey.getGroup());

        if (_schedulerEngineHelper != null) {
          _schedulerEngineHelper.auditSchedulerJobs(message, TriggerState.EXPIRED);
        }

        _persistedScheduler.deleteJob(jobKey);
      }
    }
  }
 public void execute(JobExecutionContext jobContext) throws JobExecutionException {
   SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this);
   JobKey jobKey = jobContext.getJobDetail().getKey();
   Long id = Long.parseLong(jobKey.getName());
   Event event = eventDAO.findById(id);
   MailService.sendMail(event, getRecipients(event));
   CronScheduler.removeJob(jobKey);
 }
 public List<RunTimeJobDetail> listAllJobs() throws SchedulerException {
   List<RunTimeJobDetail> jobs = new ArrayList<RunTimeJobDetail>();
   for (String groupName : quartzScheduler.getJobGroupNames()) {
     for (JobKey jobKey : quartzScheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
       jobs.add(getJobDetails(groupName, jobKey.getName()));
     }
   }
   return jobs;
 }
  protected SchedulerResponse getScheduledJob(Scheduler scheduler, JobKey jobKey) throws Exception {

    JobDetail jobDetail = scheduler.getJobDetail(jobKey);

    if (jobDetail == null) {
      return null;
    }

    SchedulerResponse schedulerResponse = new SchedulerResponse();

    JobDataMap jobDataMap = jobDetail.getJobDataMap();

    String description = jobDataMap.getString(SchedulerEngine.DESCRIPTION);

    schedulerResponse.setDescription(description);

    String destinationName = jobDataMap.getString(SchedulerEngine.DESTINATION_NAME);

    schedulerResponse.setDestinationName(destinationName);

    Message message = getMessage(jobDataMap);

    JobState jobState = getJobState(jobDataMap);

    message.put(SchedulerEngine.JOB_STATE, jobState);

    schedulerResponse.setMessage(message);

    StorageType storageType =
        StorageType.valueOf(jobDataMap.getString(SchedulerEngine.STORAGE_TYPE));

    schedulerResponse.setStorageType(storageType);

    String jobName = jobKey.getName();
    String groupName = jobKey.getGroup();

    TriggerKey triggerKey = new TriggerKey(jobName, groupName);

    Trigger trigger = scheduler.getTrigger(triggerKey);

    if (trigger == null) {
      schedulerResponse.setGroupName(groupName);
      schedulerResponse.setJobName(jobName);

      return schedulerResponse;
    }

    message.put(SchedulerEngine.END_TIME, trigger.getEndTime());
    message.put(SchedulerEngine.FINAL_FIRE_TIME, trigger.getFinalFireTime());
    message.put(SchedulerEngine.NEXT_FIRE_TIME, trigger.getNextFireTime());
    message.put(SchedulerEngine.PREVIOUS_FIRE_TIME, trigger.getPreviousFireTime());
    message.put(SchedulerEngine.START_TIME, trigger.getStartTime());

    schedulerResponse.setTrigger(new QuartzTrigger(trigger));

    return schedulerResponse;
  }
  @Test
  public void shouldCheckWhetherJobExists() throws JobPersistenceException {
    final String jobId = id("fooid");
    JobDetail job = newJob(DummyJobListener.class).withIdentity(jobId, "bargroup").build();

    assertFalse(couchdbStore.checkExists(JobKey.jobKey(jobId, "bargroup")));
    couchdbStore.storeJob(job, false);
    assertTrue(couchdbStore.checkExists(JobKey.jobKey(jobId, "bargroup")));
  }
    @Override
    public void resumeJobs(GroupMatcher<JobKey> groupMatcher) {
      String groupName = groupMatcher.getCompareToValue();

      for (JobKey jobKey : _jobs.keySet()) {
        if (jobKey.getGroup().equals(groupName)) {
          resumeJob(jobKey);
        }
      }
    }
  public void scheduleJobs() throws Exception {

    System.out.println("------- Initializing ----------------------");
    checkConfiguration();

    // First we must get a reference to a scheduler
    SchedulerFactory sf = new StdSchedulerFactory();
    sched = sf.getScheduler();
    sched.deleteJob(JobKey.jobKey("event-search-job", "search.broker.jobs"));
    sched.deleteJob(JobKey.jobKey("traffic-search-job", "search.broker.jobs"));
    // sched.deleteJob(JobKey.jobKey("sport-search-job",  "search.broker.jobs"));
    // sched.deleteJob(JobKey.jobKey("data-analysis-job", "search.broker.jobs"));

    System.out.println("------- Initialization Complete -----------");
    System.out.println("------- Scheduling Jobs -------------------");

    // Job #1 is scheduled to run every 3 minutes
    JobDetail evtJob =
        newJob(EventSearchJob.class).withIdentity("event-search-job", "search.broker.jobs").build();
    Trigger ET =
        newTrigger()
            .withIdentity("event-trigger", "search.broker.jobs")
            .startNow()
            .withSchedule(simpleSchedule().withIntervalInSeconds(60 * 03).repeatForever())
            .build();

    JobDetail tfcJob =
        newJob(TrafficSearchJob.class)
            .withIdentity("traffic-search-job", "search.broker.jobs")
            .build();
    Trigger TT =
        newTrigger()
            .withIdentity("traffic-trigger", "search.broker.jobs")
            .startNow()
            .withSchedule(simpleSchedule().withIntervalInSeconds(60 * 03).repeatForever())
            .build();

    /*JobDetail danJob = newJob(DataAnalysisJob.class).withIdentity("data-analysis-job", "search.broker.jobs").build();
    Trigger DT = newTrigger().withIdentity("analysis-trigger", "search.broker.jobs")
    				  .startNow().withSchedule(simpleSchedule().withIntervalInSeconds(60*15).repeatForever())
    		          .build();

       JobDetail spoJob = newJob(SportSearchJob.class).withIdentity("sport-search-job", "search.broker.jobs").build();
    Trigger ST = newTrigger().withIdentity("sport-trigger", "search.broker.jobs")
    				  .startNow().withSchedule(simpleSchedule().withIntervalInSeconds(60*10).repeatForever())
    		          .build();*/

    sched.scheduleJob(tfcJob, TT);
    sched.scheduleJob(evtJob, ET);
    // sched.scheduleJob(spoJob, ST);
    // sched.scheduleJob(danJob, DT);

    sched.start();
    System.out.println("[eduzi] all jobs started.");
  }
  @Override
  protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
    JobKey jobKey = context.getTrigger().getJobKey();

    XxlJobInfo jobInfo =
        DynamicSchedulerUtil.xxlJobInfoDao.load(jobKey.getGroup(), jobKey.getName());
    // save log
    XxlJobLog jobLog = new XxlJobLog();
    jobLog.setJobGroup(jobInfo.getJobGroup());
    jobLog.setJobName(jobInfo.getJobName());
    jobLog.setJobCron(jobInfo.getJobCron());
    jobLog.setJobDesc(jobInfo.getJobDesc());
    jobLog.setJobClass(jobInfo.getJobClass());
    DynamicSchedulerUtil.xxlJobLogDao.save(jobLog);
    logger.info(">>>>>>>>>>> xxl-job trigger start, jobId:{}", jobLog.getId());

    // trigger request
    HashMap<String, String> params = new HashMap<String, String>();
    params.put(HandlerParamEnum.TIMESTAMP.name(), String.valueOf(System.currentTimeMillis()));
    params.put(HandlerParamEnum.ACTION.name(), ActionEnum.RUN.name());

    params.put(
        HandlerParamEnum.LOG_ADDRESS.name(), XxlJobLogCallbackServer.getTrigger_log_address());
    params.put(HandlerParamEnum.LOG_ID.name(), String.valueOf(jobLog.getId()));

    params.put(HandlerParamEnum.EXECUTOR_HANDLER.name(), jobInfo.getExecutorHandler());
    params.put(HandlerParamEnum.EXECUTOR_PARAMS.name(), jobInfo.getExecutorParam());

    params.put(HandlerParamEnum.GLUE_SWITCH.name(), String.valueOf(jobInfo.getGlueSwitch()));
    params.put(HandlerParamEnum.JOB_GROUP.name(), jobInfo.getJobGroup());
    params.put(HandlerParamEnum.JOB_NAME.name(), jobInfo.getJobName());

    // failover trigger
    RemoteCallBack callback = failoverTrigger(jobInfo.getExecutorAddress(), params, jobLog);
    jobLog.setExecutorHandler(
        jobInfo.getGlueSwitch() == 0 ? jobInfo.getExecutorHandler() : "GLUE任务");
    jobLog.setExecutorParam(jobInfo.getExecutorParam());
    logger.info(
        ">>>>>>>>>>> xxl-job failoverTrigger response, jobId:{}, callback:{}",
        jobLog.getId(),
        callback);

    // update trigger info
    jobLog.setTriggerTime(new Date());
    jobLog.setTriggerStatus(callback.getStatus());
    jobLog.setTriggerMsg(callback.getMsg());
    DynamicSchedulerUtil.xxlJobLogDao.updateTriggerInfo(jobLog);

    // monitor triger
    JobMonitorHelper.monitor(jobLog.getId());

    logger.info(">>>>>>>>>>> xxl-job trigger end, jobId:{}", jobLog.getId());
  }
    @Override
    public List<String> getJobGroupNames() {
      List<String> groupNames = new ArrayList<>();

      for (JobKey jobKey : _jobs.keySet()) {
        if (!groupNames.contains(jobKey.getGroup())) {
          groupNames.add(jobKey.getGroup());
        }
      }

      return groupNames;
    }
  @Test
  public void shouldDeleteExistingJob() throws JobPersistenceException {
    final String jobId = id("fooid");
    JobDetail job =
        newJob(DummyJobListener.class)
            .withIdentity(jobId, "bargroup")
            .usingJobData("foo", "bar")
            .build();
    couchdbStore.storeJob(job, false);

    couchdbStore.removeJob(JobKey.jobKey(jobId, "bargroup"));
    assertNull(couchdbStore.retrieveJob(JobKey.jobKey(jobId, "bargroup")));
  }
    @Override
    public Set<JobKey> getJobKeys(GroupMatcher<JobKey> groupMatcher) {
      String groupName = groupMatcher.getCompareToValue();

      Set<JobKey> jobKeys = new HashSet<>();

      for (JobKey jobKey : _jobs.keySet()) {
        if (jobKey.getGroup().equals(groupName)) {
          jobKeys.add(jobKey);
        }
      }

      return jobKeys;
    }
 private boolean fetchJob(Connection conn, JobKey jobKey)
     throws IOException, SQLException, SchedulerException {
   PreparedStatement ps = null;
   ResultSet rs = null;
   try {
     ps = conn.prepareStatement(rtp(FETCH_JOB_DETAIL_TRACK, scheduler.getSchedulerName()));
     ps.setString(1, jobKey.getGroup());
     ps.setString(2, jobKey.getName());
     rs = ps.executeQuery();
     return rs.next();
   } finally {
     closeStatement(ps);
     cleanupConnection(conn);
   }
 }
Exemple #13
0
  @Async
  public void runJob(JobDetails jobDetails, Scheduler scheduler)
      throws JobExecutionAlreadyRunningException, JobRestartException,
          JobInstanceAlreadyCompleteException, JobParametersInvalidException,
          SpartanPersistenceException, SchedulerException, ClassNotFoundException {
    Map<String, JobParameter> jobMapParams = new HashMap<String, JobParameter>();
    JobParameter paramMonth = new JobParameter(1l);
    jobMapParams.put("salForMonth", paramMonth);

    JobParameter paramDateTime = new JobParameter(new Date(System.currentTimeMillis()));
    jobMapParams.put("myCurrentTime", paramDateTime);

    JobParameters defaultParams = new JobParameters(jobMapParams);

    JobDataMap newJobData = new JobDataMap(jobMapParams);

    // Creating Job and link to our Job class
    Class jobClass = Class.forName(jobDetails.getBeanName());
    List<String> listOfJob = scheduler.getJobGroupNames();
    if (listOfJob.size() == 0) {
      schdeuleJob(jobClass, scheduler, jobDetails, newJobData);
    } else {
      for (String groupName : scheduler.getJobGroupNames()) {

        for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {

          String jobName = jobKey.getName();
          String jobGroup = jobKey.getGroup();

          // get job's trigger
          List<Trigger> triggers = (List<Trigger>) scheduler.getTriggersOfJob(jobKey);
          CronTrigger nextFireTime = (CronTrigger) triggers.get(0);
          if (jobDetails.getJobName().equalsIgnoreCase(jobName)
              && !jobDetails
                  .getScheduler()
                  .getSchedulerExpression()
                  .equalsIgnoreCase(nextFireTime.getCronExpression())) {
            scheduler.deleteJob(jobKey);
            schdeuleJob(jobClass, scheduler, jobDetails, newJobData);
          } else if (listOfJob.contains(jobDetails.getJobName())) {

          } else {
            schdeuleJob(jobClass, scheduler, jobDetails, newJobData);
          }
        }
      }
    }
  }
  @Test
  public void shouldStoreAndRetrieveJob() throws JobPersistenceException {
    final String jobId = id("fooid");
    JobDetail job =
        newJob(DummyJobListener.class)
            .withIdentity(jobId, "bargroup")
            .usingJobData("foo", "bar")
            .usingJobData("fuu", "baz")
            .build();
    couchdbStore.storeJob(job, false);

    assertNull(couchdbStore.retrieveJob(JobKey.jobKey("something", "something")));
    assertEquals(
        "bar",
        couchdbStore.retrieveJob(JobKey.jobKey(jobId, "bargroup")).getJobDataMap().get("foo"));
  }
  @Test
  public void shouldReturnMatchingJobKeys() throws JobPersistenceException {
    JobDetail job1 = newJob(DummyJobListener.class).withIdentity(id("fooid1"), "bargroup1").build();
    final String groupId = id("bargroup2");
    final String job1Id = id("fooid2");
    final String job2Id = id("fooid3");
    JobDetail job2 = newJob(DummyJobListener.class).withIdentity(job1Id, groupId).build();
    JobDetail job3 = newJob(DummyJobListener.class).withIdentity(job2Id, groupId).build();
    couchdbStore.storeJob(job1, false);
    couchdbStore.storeJob(job2, false);
    couchdbStore.storeJob(job3, false);

    assertEquals(
        new HashSet<JobKey>(asList(JobKey.jobKey(job1Id, groupId), JobKey.jobKey(job2Id, groupId))),
        couchdbStore.getJobKeys(GroupMatcher.<JobKey>groupEquals(groupId)));
  }
  public List<RunTimeJobDetail> searchJobs(String groupExp, String nameExp)
      throws SchedulerException {
    Pattern groupPattern = Pattern.compile(groupExp);
    Pattern namePattern = Pattern.compile(nameExp);

    List<RunTimeJobDetail> jobs = new ArrayList<RunTimeJobDetail>();
    for (String groupName : quartzScheduler.getJobGroupNames()) {
      if (groupPattern.matcher(groupName).matches()) {
        for (JobKey jobKey : quartzScheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
          if (namePattern.matcher(jobKey.getName()).matches()) {
            jobs.add(getJobDetails(groupName, jobKey.getName()));
          }
        }
      }
    }
    return jobs;
  }
 private Object getJobExecParams(Connection conn, JobKey jobKey, String restart)
     throws IOException, SQLException, SchedulerException, ClassNotFoundException {
   PreparedStatement ps = null;
   ResultSet rs = null;
   try {
     ps = conn.prepareStatement(rtp(FETCH_JOB_DETAIL_EXEC_TRACK, scheduler.getSchedulerName()));
     ps.setString(1, jobKey.getGroup());
     ps.setString(2, jobKey.getName());
     ps.setString(3, restart);
     rs = ps.executeQuery();
     rs.next();
     return getJobDataFromBlob(rs, "JOB_DATA");
   } finally {
     closeStatement(ps);
     cleanupConnection(conn);
   }
 }
 /**
  * Delete all {@link Job}s of the group <code>persistModelName</code>
  *
  * @throws SchedulerException if there is an internal Scheduler error.
  */
 private void removeTimers(String persistModelName) {
   try {
     Set<JobKey> jobKeys = scheduler.getJobKeys(GroupMatcher.jobGroupEquals(persistModelName));
     for (JobKey jobKey : jobKeys) {
       try {
         boolean success = scheduler.deleteJob(jobKey);
         if (success) {
           logger.debug("Removed scheduled cron job for strategy '{}'", jobKey.toString());
         } else {
           logger.warn("Failed to delete cron jobs '{}'", jobKey.getName());
         }
       } catch (SchedulerException e) {
         logger.warn("Failed to delete cron jobs '{}'", jobKey.getName());
       }
     }
   } catch (SchedulerException e) {
     logger.warn("Failed to delete cron jobs of group '{}'", persistModelName);
   }
 }
  @Test
  public void shouldDeleteExistingJobs() throws JobPersistenceException {
    final String job1Id = id("fooid1");
    JobDetail job1 = newJob(DummyJobListener.class).withIdentity(job1Id, "bargroup1").build();
    final String job2Id = id("fooid2");
    JobDetail job2 = newJob(DummyJobListener.class).withIdentity(job2Id, "bargroup2").build();
    final String job3Id = id("fooid3");
    JobDetail job3 = newJob(DummyJobListener.class).withIdentity(job3Id, "bargroup2").build();

    couchdbStore.storeJob(job1, false);
    couchdbStore.storeJob(job2, false);
    couchdbStore.storeJob(job3, false);

    couchdbStore.removeJobs(
        asList(JobKey.jobKey(job1Id, "bargroup1"), JobKey.jobKey(job2Id, "bargroup2")));

    assertNull(couchdbStore.retrieveJob(JobKey.jobKey(job1Id, "bargroup1")));
    assertNull(couchdbStore.retrieveJob(JobKey.jobKey(job2Id, "bargroup2")));
    assertNotNull(couchdbStore.retrieveJob(JobKey.jobKey(job3Id, "bargroup2")));
  }
  @Test
  public void shouldDeleteAssociatedTriggersWhenDeletingJob() throws JobPersistenceException {
    final String jobId = id("job");
    JobDetail job = newJob(DummyJobListener.class).withIdentity(jobId, "bargroup").build();
    couchdbStore.storeJob(job, false);

    final String tridderName = id("trigger");
    SimpleTriggerImpl trigger =
        (SimpleTriggerImpl)
            newTrigger()
                .withIdentity(tridderName, "borgroup")
                .forJob(JobKey.jobKey(jobId, "bargroup"))
                .startAt(new Date(2010, 10, 20))
                .withSchedule(simpleSchedule().withIntervalInMinutes(2).repeatForever())
                .build();
    couchdbStore.storeTrigger(trigger, false);

    couchdbStore.removeJob(JobKey.jobKey(jobId, "bargroup"));
    assertNull(couchdbStore.retrieveTrigger(TriggerKey.triggerKey(tridderName, "borgroup")));
  }
  public void stop(Long id) throws Exception {
    synchronized (sync) {
      String jobKey = scheduledJobKeys.remove(id);
      if (jobKey == null) {
        throw new IllegalArgumentException("No scheduled job for function id " + id);
      }

      quartzScheduler.deleteJob(JobKey.jobKey(jobKey));

      LOG.info("Stopped {}", jobKey);
    }
  }
  protected void unschedule(Scheduler scheduler, JobKey jobKey) throws Exception {

    JobDetail jobDetail = scheduler.getJobDetail(jobKey);

    TriggerKey triggerKey = new TriggerKey(jobKey.getName(), jobKey.getGroup());

    if (jobDetail == null) {
      return;
    }

    unregisterMessageListener(scheduler, jobKey);

    JobDataMap jobDataMap = jobDetail.getJobDataMap();

    JobState jobState = getJobState(jobDataMap);

    Trigger trigger = scheduler.getTrigger(triggerKey);

    if (trigger == null) {
      return;
    }

    jobState.setTriggerDate(SchedulerEngine.END_TIME, new Date());
    jobState.setTriggerDate(SchedulerEngine.FINAL_FIRE_TIME, trigger.getPreviousFireTime());
    jobState.setTriggerDate(SchedulerEngine.NEXT_FIRE_TIME, null);
    jobState.setTriggerDate(SchedulerEngine.PREVIOUS_FIRE_TIME, trigger.getPreviousFireTime());
    jobState.setTriggerDate(SchedulerEngine.START_TIME, trigger.getStartTime());

    jobState.setTriggerState(TriggerState.UNSCHEDULED);

    jobState.clearExceptions();

    jobDataMap.put(SchedulerEngine.JOB_STATE, JobStateSerializeUtil.serialize(jobState));

    scheduler.unscheduleJob(triggerKey);

    scheduler.addJob(jobDetail, true);
  }
  /**
   * Creates and schedules a new quartz-job and trigger with model and rule name as jobData.
   *
   * @param rule the rule to schedule
   * @param trigger the defined trigger
   * @throws SchedulerException if there is an internal Scheduler error.
   */
  private void createTimers(String modelName) {
    PersistenceModel persistModel =
        (PersistenceModel) modelRepository.getModel(modelName + ".persist");
    if (persistModel != null) {
      for (Strategy strategy : persistModel.getStrategies()) {
        if (strategy instanceof CronStrategy) {
          CronStrategy cronStrategy = (CronStrategy) strategy;
          String cronExpression = cronStrategy.getCronExpression();
          JobKey jobKey = new JobKey(strategy.getName(), modelName);
          try {
            JobDetail job =
                newJob(PersistItemsJob.class)
                    .usingJobData(
                        PersistItemsJob.JOB_DATA_PERSISTMODEL,
                        cronStrategy.eResource().getURI().trimFileExtension().path())
                    .usingJobData(PersistItemsJob.JOB_DATA_STRATEGYNAME, cronStrategy.getName())
                    .withIdentity(jobKey)
                    .build();

            Trigger quartzTrigger =
                newTrigger().withSchedule(CronScheduleBuilder.cronSchedule(cronExpression)).build();

            scheduler.scheduleJob(job, quartzTrigger);

            logger.debug(
                "Scheduled strategy {} with cron expression {}",
                new Object[] {jobKey.toString(), cronExpression});
          } catch (SchedulerException e) {
            logger.error(
                "Failed to schedule job for strategy {} with cron expression {}",
                new String[] {jobKey.toString(), cronExpression},
                e);
          }
        }
      }
    }
  }
  @Test
  public void shouldReturnAllJobs() throws JobPersistenceException {
    String group1Id = id("group1Id");
    String group2Id = id("group2Id");
    String jobid1 = id("fooid1");
    String jobid2 = id("fooid2");
    String jobid3 = id("fooid3");
    JobDetail job1 = newJob(DummyJobListener.class).withIdentity(jobid1, group1Id).build();
    JobDetail job2 = newJob(DummyJobListener.class).withIdentity(jobid2, group2Id).build();
    JobDetail job3 = newJob(DummyJobListener.class).withIdentity(jobid3, group2Id).build();
    couchdbStore.storeJob(job1, false);
    couchdbStore.storeJob(job2, false);
    couchdbStore.storeJob(job3, false);

    List<CouchDbJobDetail> jobs =
        couchdbStore
            .getJobStore()
            .getJobs(asList(JobKey.jobKey(jobid1, group1Id), JobKey.jobKey(jobid3, group2Id)));
    List<JobKey> jobKeys = extract(jobs, on(CouchDbJobDetail.class).getKey());

    assertEquals(2, jobs.size());
    assertTrue(jobKeys.contains(JobKey.jobKey(jobid1, group1Id)));
    assertTrue(jobKeys.contains(JobKey.jobKey(jobid3, group2Id)));
  }
  @Test(expected = ObjectAlreadyExistsException.class)
  public void shouldNotUpdateExistingJob() throws JobPersistenceException {
    JobDetail job =
        newJob(DummyJobListener.class)
            .withIdentity("fooid", "bargroup")
            .usingJobData("foo", "bar")
            .build();
    couchdbStore.storeJob(job, false);

    JobDetail newJob =
        newJob(DummyJobListener.class)
            .withIdentity("fooid", "bargroup")
            .usingJobData("fii", "bur")
            .build();
    couchdbStore.storeJob(newJob, false);

    assertNull(
        couchdbStore.retrieveJob(JobKey.jobKey("fooid", "bargroup")).getJobDataMap().get("fii"));
  }
  @Test
  public void shouldUpdateExistingJob() throws JobPersistenceException {
    final String jobId = id("fooid");
    JobDetail job =
        newJob(DummyJobListener.class)
            .withIdentity(jobId, "bargroup")
            .usingJobData("foo", "bar")
            .build();
    couchdbStore.storeJob(job, false);

    JobDetail newJob =
        newJob(DummyJobListener.class)
            .withIdentity(jobId, "bargroup")
            .usingJobData("fii", "bur")
            .build();
    couchdbStore.storeJob(newJob, true);

    assertEquals(
        "bur",
        couchdbStore.retrieveJob(JobKey.jobKey(jobId, "bargroup")).getJobDataMap().get("fii"));
  }
Exemple #27
0
 @Override
 public void execute(JobExecutionContext context) throws JobExecutionException {
   JobKey key = context.getJobDetail().getKey();
   logger.info("-----job key---" + key.getName());
   logger.info("----hello--" + new Date());
 }
  protected SchedulerResponse getScheduledJob(Scheduler scheduler, JobKey jobKey) throws Exception {

    JobDetail jobDetail = scheduler.getJobDetail(jobKey);

    if (jobDetail == null) {
      return null;
    }

    SchedulerResponse schedulerResponse = new SchedulerResponse();

    JobDataMap jobDataMap = jobDetail.getJobDataMap();

    String description = jobDataMap.getString(SchedulerEngine.DESCRIPTION);

    schedulerResponse.setDescription(description);

    String destinationName = jobDataMap.getString(SchedulerEngine.DESTINATION_NAME);

    schedulerResponse.setDestinationName(destinationName);

    Message message = getMessage(jobDataMap);

    JobState jobState = getJobState(jobDataMap);

    message.put(SchedulerEngine.JOB_STATE, jobState);

    schedulerResponse.setMessage(message);

    StorageType storageType =
        StorageType.valueOf(jobDataMap.getString(SchedulerEngine.STORAGE_TYPE));

    schedulerResponse.setStorageType(storageType);

    String jobName = jobKey.getName();
    String groupName = jobKey.getGroup();

    TriggerKey triggerKey = new TriggerKey(jobName, groupName);

    Trigger trigger = scheduler.getTrigger(triggerKey);

    if (trigger == null) {
      schedulerResponse.setGroupName(groupName);
      schedulerResponse.setJobName(jobName);

      return schedulerResponse;
    }

    message.put(SchedulerEngine.END_TIME, trigger.getEndTime());
    message.put(SchedulerEngine.FINAL_FIRE_TIME, trigger.getFinalFireTime());
    message.put(SchedulerEngine.NEXT_FIRE_TIME, trigger.getNextFireTime());
    message.put(SchedulerEngine.PREVIOUS_FIRE_TIME, trigger.getPreviousFireTime());
    message.put(SchedulerEngine.START_TIME, trigger.getStartTime());

    if (trigger instanceof CalendarIntervalTrigger) {
      CalendarIntervalTrigger calendarIntervalTrigger = CalendarIntervalTrigger.class.cast(trigger);

      IntervalUnit intervalUnit = calendarIntervalTrigger.getRepeatIntervalUnit();

      schedulerResponse.setTrigger(
          new IntervalTrigger(
              jobName,
              groupName,
              calendarIntervalTrigger.getStartTime(),
              calendarIntervalTrigger.getEndTime(),
              calendarIntervalTrigger.getRepeatInterval(),
              TimeUnit.valueOf(intervalUnit.name())));
    } else if (trigger instanceof CronTrigger) {
      CronTrigger cronTrigger = CronTrigger.class.cast(trigger);

      schedulerResponse.setTrigger(
          new com.liferay.portal.kernel.scheduler.CronTrigger(
              jobName,
              groupName,
              cronTrigger.getStartTime(),
              cronTrigger.getEndTime(),
              cronTrigger.getCronExpression()));
    } else if (trigger instanceof SimpleTrigger) {
      SimpleTrigger simpleTrigger = SimpleTrigger.class.cast(trigger);

      schedulerResponse.setTrigger(
          new IntervalTrigger(
              jobName,
              groupName,
              simpleTrigger.getStartTime(),
              simpleTrigger.getEndTime(),
              (int) simpleTrigger.getRepeatInterval(),
              TimeUnit.MILLISECOND));
    }

    return schedulerResponse;
  }
 private String getJobKeyAsString(final JobKey jobKey) {
   return jobKey.getName() + SchedulerServiceConstants.JOB_KEY_SEPERATOR + jobKey.getGroup();
 }