Example usage for org.springframework.scheduling.concurrent ThreadPoolTaskScheduler setWaitForTasksToCompleteOnShutdown

List of usage examples for org.springframework.scheduling.concurrent ThreadPoolTaskScheduler setWaitForTasksToCompleteOnShutdown

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.scheduling.concurrent.*
  5. ThreadPoolTaskScheduler
  6. setWaitForTasksToCompleteOnShutdown

Introduction

In this page you can find the example usage for org.springframework.scheduling.concurrent ThreadPoolTaskScheduler setWaitForTasksToCompleteOnShutdown.

Prototype

public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown)

Source Link

Document

Set whether to wait for scheduled tasks to complete on shutdown, not interrupting running tasks and executing all tasks in the queue.

Usage

From source file:com.joshlong.esb.springintegration.modules.net.sftp.Main.java

static void run(SFTPSessionFactory sftpSessionFactory, String lp, String rp) throws Throwable {
    // local path
    File local = new File(lp); // obviously this is just for test. Do what you need to do in your own

    // we are testing, after all
    if (local.exists() && (local.list().length > 0)) {
        for (File f : local.listFiles()) {
            if (!f.delete()) {
                logger.debug("couldn't delete " + f.getAbsolutePath());
            }/*from  www.j  av a 2 s  .  c o m*/
        }
    }

    Resource localDirectory = new FileSystemResource(local);

    // pool
    QueuedSFTPSessionPool queuedSFTPSessionPool = new QueuedSFTPSessionPool(sftpSessionFactory);
    queuedSFTPSessionPool.afterPropertiesSet();

    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.setPoolSize(10);
    taskScheduler.setErrorHandler(new ErrorHandler() {
        public void handleError(Throwable t) {
            logger.debug("error! ", t);
        }
    });

    taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
    taskScheduler.initialize();

    // synchronizer
    final SFTPInboundSynchronizer sftpInboundSynchronizer = new SFTPInboundSynchronizer();
    sftpInboundSynchronizer.setLocalDirectory(localDirectory);
    sftpInboundSynchronizer.setRemotePath(rp);
    sftpInboundSynchronizer.setAutoCreatePath(true);
    sftpInboundSynchronizer.setPool(queuedSFTPSessionPool);
    sftpInboundSynchronizer.setShouldDeleteDownloadedRemoteFiles(false);
    sftpInboundSynchronizer.setTaskScheduler(taskScheduler);
    sftpInboundSynchronizer.afterPropertiesSet();
    sftpInboundSynchronizer.start();

    /*
        new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(60 * 1000); // 1 minute
            
                    sftpInboundSynchronizer.stop();
            
                } catch (InterruptedException e) {
                    // don't care
                }
            }
        }).start();
    */
}

From source file:com.nayidisha.slowglow.config.SchedulerConfig.java

@Bean(name = "taskScheduler")
public ThreadPoolTaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setPoolSize(5);//from   www .  jav  a  2 s .  c om
    scheduler.setWaitForTasksToCompleteOnShutdown(true);

    return scheduler;
}

From source file:io.pivotal.strepsirrhini.chaosloris.ChaosLoris.java

@Bean(destroyMethod = "shutdown")
ThreadPoolTaskScheduler taskScheduler(@Value("${loris.scheduler.size}") int poolSize) {
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.setPoolSize(poolSize);
    taskScheduler.setThreadNamePrefix("loris-scheduler-");
    taskScheduler.setWaitForTasksToCompleteOnShutdown(true);

    return taskScheduler;
}

From source file:com.epam.ta.reportportal.core.configs.JobsConfiguration.java

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setPoolSize(5);/*  w w  w . j ava2 s .  c  o m*/
    scheduler.setThreadNamePrefix("default-task-sched");
    scheduler.setWaitForTasksToCompleteOnShutdown(true);
    return scheduler;
}

From source file:com.alliander.osgp.webdevicesimulator.application.config.AutonomousDeviceRegisterConfig.java

@Bean(destroyMethod = "shutdown")
public TaskScheduler deviceRegistrationTaskScheduler() {
    final ThreadPoolTaskScheduler deviceRegistrationTaskScheduler = new ThreadPoolTaskScheduler();
    deviceRegistrationTaskScheduler.setPoolSize(
            Integer.parseInt(this.environment.getRequiredProperty(PROPERTY_NAME_AUTONOMOUS_POOL_SIZE)));
    deviceRegistrationTaskScheduler.setThreadNamePrefix(
            this.environment.getRequiredProperty(PROPERTY_NAME_AUTONOMOUS_THREAD_NAME_PREFIX));
    deviceRegistrationTaskScheduler.setWaitForTasksToCompleteOnShutdown(false);
    deviceRegistrationTaskScheduler.setAwaitTerminationSeconds(10);
    deviceRegistrationTaskScheduler.initialize();
    deviceRegistrationTaskScheduler.schedule(this.autonomousDeviceRegister,
            this.autonomousDeviceRegisterTrigger());
    return deviceRegistrationTaskScheduler;
}

From source file:com.alliander.osgp.webdevicesimulator.application.config.AutonomousDeviceRebootConfig.java

@Bean(destroyMethod = "shutdown")
public TaskScheduler deviceRebootTaskScheduler() {
    final ThreadPoolTaskScheduler deviceRebootTaskScheduler = new ThreadPoolTaskScheduler();
    deviceRebootTaskScheduler.setPoolSize(Integer
            .parseInt(this.environment.getRequiredProperty(PROPERTY_NAME_AUTONOMOUS_DEVICE_REBOOT_POOL_SIZE)));
    deviceRebootTaskScheduler.setThreadNamePrefix(
            this.environment.getRequiredProperty(PROPERTY_NAME_AUTONOMOUS_DEVICE_REBOOT_THREAD_NAME_PREFIX));
    deviceRebootTaskScheduler.setWaitForTasksToCompleteOnShutdown(false);
    deviceRebootTaskScheduler.setAwaitTerminationSeconds(10);
    deviceRebootTaskScheduler.initialize();
    deviceRebootTaskScheduler.schedule(this.autonomousDeviceReboot, this.autonomousDeviceRebootTrigger());
    return deviceRebootTaskScheduler;
}

From source file:com.joshlong.esb.springintegration.modules.net.sftp.config.SFTPMessageSourceFactoryBean.java

@Override
protected SFTPMessageSource createInstance() throws Exception {
    try {//from  w ww. java  2 s  .  com
        if ((localWorkingDirectory == null) || StringUtils.isEmpty(localWorkingDirectory)) {
            File tmp = SystemUtils.getJavaIoTmpDir();
            File sftpTmp = new File(tmp, "sftpInbound");
            this.localWorkingDirectory = "file://" + sftpTmp.getAbsolutePath();
        }
        assert !StringUtils
                .isEmpty(this.localWorkingDirectory) : "the local working directory mustn't be null!";

        // resource for local directory
        ResourceEditor editor = new ResourceEditor(this.resourceLoader);
        editor.setAsText(this.localWorkingDirectory);
        this.localDirectoryResource = (Resource) editor.getValue();

        fileReadingMessageSource = new FileReadingMessageSource();

        synchronizer = new SFTPInboundSynchronizer();

        if (null == taskScheduler) {
            Map<String, TaskScheduler> tss = null;

            if ((tss = applicationContext.getBeansOfType(TaskScheduler.class)).keySet().size() != 0) {
                taskScheduler = tss.get(tss.keySet().iterator().next());
            }
        }

        if (null == taskScheduler) {
            ThreadPoolTaskScheduler ts = new ThreadPoolTaskScheduler();
            ts.setPoolSize(10);
            ts.setErrorHandler(new ErrorHandler() {
                public void handleError(Throwable t) {
                    // todo make this forward a message onto the error channel (how does that work?)
                    logger.debug("error! ", t);
                }
            });

            ts.setWaitForTasksToCompleteOnShutdown(true);
            ts.initialize();
            this.taskScheduler = ts;
        }

        SFTPSessionFactory sessionFactory = SFTPSessionUtils.buildSftpSessionFactory(this.getHost(),
                this.getPassword(), this.getUsername(), this.getKeyFile(), this.getKeyFilePassword(),
                this.getPort());

        QueuedSFTPSessionPool pool = new QueuedSFTPSessionPool(15, sessionFactory);
        pool.afterPropertiesSet();
        synchronizer.setRemotePath(this.getRemoteDirectory());
        synchronizer.setPool(pool);
        synchronizer.setAutoCreatePath(this.isAutoCreateDirectories());
        synchronizer.setShouldDeleteDownloadedRemoteFiles(this.isAutoDeleteRemoteFilesOnSync());

        SFTPMessageSource sftpMessageSource = new SFTPMessageSource(fileReadingMessageSource, synchronizer);

        sftpMessageSource.setTaskScheduler(taskScheduler);

        if (null != this.trigger) {
            sftpMessageSource.setTrigger(trigger);
        }

        sftpMessageSource.setLocalDirectory(this.localDirectoryResource);
        sftpMessageSource.afterPropertiesSet();
        sftpMessageSource.start();

        return sftpMessageSource;
    } catch (Throwable thr) {
        logger.debug("error occurred when trying to configure SFTPmessageSource ", thr);
    }

    return null;
}

From source file:org.springframework.integration.config.SourcePollingChannelAdapterFactoryBeanTests.java

@Test
public void testInterrupted() throws Exception {
    final CountDownLatch startLatch = new CountDownLatch(1);

    MessageSource<Object> ms = () -> {
        startLatch.countDown();//from   w w w  .j  a  v a2  s  .c  om
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new MessagingException("Interrupted awaiting stopLatch", e);
        }
        return null;
    };

    SourcePollingChannelAdapter pollingChannelAdapter = new SourcePollingChannelAdapter();
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
    taskScheduler.setAwaitTerminationSeconds(1);
    taskScheduler.afterPropertiesSet();
    pollingChannelAdapter.setTaskScheduler(taskScheduler);

    MessagePublishingErrorHandler errorHandler = new MessagePublishingErrorHandler();
    Log errorHandlerLogger = TestUtils.getPropertyValue(errorHandler, "logger", Log.class);
    errorHandlerLogger = spy(errorHandlerLogger);
    DirectFieldAccessor dfa = new DirectFieldAccessor(errorHandler);
    dfa.setPropertyValue("logger", errorHandlerLogger);
    pollingChannelAdapter.setErrorHandler(errorHandler);

    pollingChannelAdapter.setSource(ms);
    pollingChannelAdapter.setOutputChannel(new NullChannel());
    pollingChannelAdapter.setBeanFactory(mock(BeanFactory.class));
    pollingChannelAdapter.afterPropertiesSet();

    Log adapterLogger = TestUtils.getPropertyValue(pollingChannelAdapter, "logger", Log.class);
    adapterLogger = spy(adapterLogger);
    when(adapterLogger.isDebugEnabled()).thenReturn(true);

    dfa = new DirectFieldAccessor(pollingChannelAdapter);
    dfa.setPropertyValue("logger", adapterLogger);

    pollingChannelAdapter.start();

    assertTrue(startLatch.await(10, TimeUnit.SECONDS));
    pollingChannelAdapter.stop();

    taskScheduler.shutdown();

    verifyZeroInteractions(errorHandlerLogger);
    verify(adapterLogger).debug(contains("Poll interrupted - during stop()?"));
}