Пример #1
0
 public List<String> getTaskNames() throws TaskSystemException {
   try {
     List<String> taskNames = new ArrayList<String>();
     String[] groupNames = scheduler.getJobGroupNames();
     for (String group : groupNames) {
       Collections.addAll(taskNames, scheduler.getJobNames(group));
     }
     return taskNames;
   } catch (SchedulerException e) {
     throw new TaskSystemException(e);
   }
 }
Пример #2
0
 public void runIndividualTask(String taskName) throws TaskSystemException {
   try {
     String[] scheduledTasksGroups = scheduler.getJobGroupNames();
     OUTER:
     for (String groupName : scheduledTasksGroups) {
       String[] groupsTaskNames = scheduler.getJobNames(groupName);
       for (String groupsTaskName : groupsTaskNames) {
         if (groupsTaskName.equals(taskName)) {
           scheduler.triggerJob(taskName, groupName);
           break OUTER;
         }
       }
     }
   } catch (SchedulerException se) {
     throw new TaskSystemException(se);
   }
 }
  @Override
  public void activate(ComponentContext context) throws Exception {
    log.debug("Activate");
    bundle = context.getRuntimeContext();

    // Find a scheduler
    StdSchedulerFactory schedulerFactory = new StdSchedulerFactory();
    URL cfg = context.getRuntimeContext().getResource("config/quartz.properties");
    if (cfg != null) {
      InputStream stream = cfg.openStream();
      try {
        schedulerFactory.initialize(stream);
      } finally {
        stream.close();
      }
    } else {
      // use default config (unit tests)
      Properties props = new Properties();
      props.put("org.quartz.scheduler.instanceName", "Quartz");
      props.put("org.quartz.scheduler.threadName", "Quartz_Scheduler");
      props.put("org.quartz.scheduler.instanceId", "NON_CLUSTERED");
      props.put("org.quartz.scheduler.makeSchedulerThreadDaemon", "true");
      props.put("org.quartz.scheduler.skipUpdateCheck", "true");
      props.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
      props.put("org.quartz.threadPool.threadCount", "1");
      props.put("org.quartz.threadPool.threadPriority", "4");
      props.put("org.quartz.threadPool.makeThreadsDaemons", "true");
      schedulerFactory.initialize(props);
    }
    scheduler = schedulerFactory.getScheduler();
    scheduler.start();
    // server = MBeanServerFactory.createMBeanServer();
    // server.createMBean("org.quartz.ee.jmx.jboss.QuartzService",
    // quartzObjectName);

    // clean up all nuxeo jobs
    // https://jira.nuxeo.com/browse/NXP-7303
    String[] jobs = scheduler.getJobNames("nuxeo");
    for (String job : jobs) {
      unregisterSchedule(job);
    }
  }
  @Test
  public void testExecuteQuickImport() throws Exception {
    expect(mockBarrier.await(20, TimeUnit.SECONDS)).andReturn(true);

    expect(mockBeanFactory.getInstance(currentUser)).andReturn(new MockI18nHelper()).anyTimes();
    // called during validation!
    expect(mockPermissionManager.hasPermission(Permissions.SYSTEM_ADMIN, currentUser))
        .andReturn(true);

    // This is called during the first parse of the XML file.  At this stage nothing should have
    // been created yet!
    final MockGenericValue mockGv = new MockGenericValue("someentity");
    expect(mockOfBizDelegator.makeValue(EasyMock.<String>anyObject())).andReturn(mockGv).anyTimes();
    expect(mockAttachmentPathManager.getDefaultAttachmentPath())
        .andReturn(directories.get(0).getAbsolutePath())
        .anyTimes();
    expect(mockIndexPathManager.getDefaultIndexRootPath())
        .andReturn(directories.get(1).getAbsolutePath())
        .anyTimes();
    expect(
            mockLicenseStringFactory.create(
                EasyMock.<String>anyObject(), EasyMock.<String>anyObject()))
        .andStubReturn("");

    // after the first parse check the build number.
    expect(mockBuildUtilsInfo.getCurrentBuildNumber()).andStubReturn("99999999");
    expect(mockBuildUtilsInfo.getMinimumUpgradableBuildNumber()).andStubReturn("0");

    // after the first parse we also verify the license is good.
    expect(
            mockJiraLicenseService.validate(
                EasyMock.<I18nHelper>anyObject(), EasyMock.<String>anyObject()))
        .andStubReturn(mockValidationResult);
    expect(mockValidationResult.getLicenseVersion()).andStubReturn(2);
    expect(mockValidationResult.getErrorCollection()).andStubReturn(new SimpleErrorCollection());

    // this gets called during shutdownAndFlushAsyncServices.  After parse and before the import.
    // This shuts down
    // the scheduler
    mockScheduler.standby();
    expect(mockScheduler.getJobGroupNames()).andReturn(new String[] {"group1"});
    expect(mockScheduler.getJobNames("group1")).andReturn(new String[] {"job1", "job2"});
    expect(mockScheduler.deleteJob("job1", "group1")).andReturn(true);
    expect(mockScheduler.deleteJob("job2", "group1")).andReturn(true);
    mockMailQueue.sendBuffer();
    expect(mockTaskManager.awaitUntilActiveTasksComplete(20)).andReturn(true);

    // Expect AO to be cleared.
    backup.clear();

    // Once the import is running one of the first things to do is to clear out the old database
    // values.
    expect(mockOfBizDelegator.getModelReader()).andReturn(mockModelReader);
    expect(mockModelReader.getEntityNames())
        .andReturn(CollectionBuilder.<String>list("Issue", "User"));
    expect(mockModelReader.getModelEntity("Issue")).andReturn(new ModelEntity());
    expect(mockOfBizDelegator.removeByAnd("Issue", Collections.<String, Object>emptyMap()))
        .andReturn(10);
    expect(mockModelReader.getModelEntity("User")).andReturn(new ModelEntity());
    expect(mockOfBizDelegator.removeByAnd("User", Collections.<String, Object>emptyMap()))
        .andReturn(5);

    // then we go through and create all our GVs (already mocked out during the first parse above)

    // once everything's been imported need to refresh the ofbiz sequencer and check for data
    // consistency.
    mockOfBizDelegator.refreshSequencer();
    mockConsistencyChecker.checkDataConsistency();

    // after the consistency check lets do the upgrade
    expect(mockUpgradeManager.doUpgradeIfNeededAndAllowed(null))
        .andReturn(Collections.<String>emptyList());

    // now do a reindex
    mockIndexManager.deactivate();
    expect(mockIndexManager.size()).andReturn(5);
    expect(mockIndexManager.activate((Context) notNull())).andReturn(1L);

    // raise the JiraStartedEvent
    mockPluginEventManager.broadcast(EasyMock.<JiraStartedEvent>anyObject());

    // finally we can restart the scheduler!
    expect(
            mockScheduler.scheduleJob(
                EasyMock.<JobDetail>anyObject(), EasyMock.<Trigger>anyObject()))
        .andReturn(new Date())
        .anyTimes();
    mockScheduler.start();

    final String filePath = getDataFilePath("jira-export-test.xml");
    final DataImportParams params =
        new DataImportParams.Builder(filePath).setQuickImport(true).build();

    // Finally everything's mocked out.  Run the import!
    executeTest(params, true, DataImportService.ImportError.NONE);

    // create() should have been called on our GVs
    assertTrue(mockGv.isCreated());
    // the world should have been rebuilt!
    assertTrue(((MockDataImportDependencies) mockDependencies).globalRefreshCalled);
  }