예제 #1
0
  @Bean(destroyMethod = "shutdown")
  public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setPoolSize(10);

    return scheduler;
  }
예제 #2
0
 public static ThreadPoolTaskScheduler createTaskScheduler(int poolSize) {
   ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
   scheduler.setPoolSize(poolSize);
   scheduler.setRejectedExecutionHandler(new CallerRunsPolicy());
   scheduler.afterPropertiesSet();
   return scheduler;
 }
예제 #3
0
 /**
  * Get a task scheduler.
  *
  * @param poolSize The initial size of the thread pool that should be allocated
  * @return The task scheduler
  */
 @Bean
 public TaskScheduler taskScheduler(
     @Value("${genie.tasks.scheduler.pool.size:1}") final int poolSize) {
   final ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
   scheduler.setPoolSize(poolSize);
   return scheduler;
 }
 public RabbitTestMessageBus(ConnectionFactory connectionFactory, Codec codec) {
   RabbitMessageBus messageBus = new RabbitMessageBus(connectionFactory, codec);
   GenericApplicationContext context = new GenericApplicationContext();
   ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
   scheduler.setPoolSize(1);
   scheduler.afterPropertiesSet();
   context
       .getBeanFactory()
       .registerSingleton(IntegrationContextUtils.TASK_SCHEDULER_BEAN_NAME, scheduler);
   context.refresh();
   messageBus.setApplicationContext(context);
   messageBus.setLongStringLimit(8193);
   this.setMessageBus(messageBus);
   assertEquals(
       8193,
       TestUtils.getPropertyValue(
           messageBus, "inboundMessagePropertiesConverter.longStringLimit"));
   this.rabbitAdmin = new RabbitAdmin(connectionFactory);
 }
  public void testObtainConnectionIds(AbstractServerConnectionFactory serverFactory)
      throws Exception {
    final List<IpIntegrationEvent> events =
        Collections.synchronizedList(new ArrayList<IpIntegrationEvent>());
    int expectedEvents =
        serverFactory instanceof TcpNetServerConnectionFactory
            ? 7 // Listening, + OPEN, CLOSE, EXCEPTION for each side
            : 5; // Listening, + OPEN, CLOSE (but we *might* get exceptions, depending on timing).
    final CountDownLatch serverListeningLatch = new CountDownLatch(1);
    final CountDownLatch eventLatch = new CountDownLatch(expectedEvents);
    ApplicationEventPublisher publisher =
        new ApplicationEventPublisher() {

          @Override
          public void publishEvent(ApplicationEvent event) {
            LogFactory.getLog(this.getClass()).trace("Received: " + event);
            events.add((IpIntegrationEvent) event);
            if (event instanceof TcpConnectionServerListeningEvent) {
              serverListeningLatch.countDown();
            }
            eventLatch.countDown();
          }

          @Override
          public void publishEvent(Object event) {}
        };
    serverFactory.setBeanName("serverFactory");
    serverFactory.setApplicationEventPublisher(publisher);
    serverFactory = spy(serverFactory);
    final CountDownLatch serverConnectionInitLatch = new CountDownLatch(1);
    doAnswer(
            invocation -> {
              Object result = invocation.callRealMethod();
              serverConnectionInitLatch.countDown();
              return result;
            })
        .when(serverFactory)
        .wrapConnection(any(TcpConnectionSupport.class));
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setPoolSize(10);
    scheduler.afterPropertiesSet();
    BeanFactory bf = mock(BeanFactory.class);
    when(bf.containsBean(IntegrationContextUtils.TASK_SCHEDULER_BEAN_NAME)).thenReturn(true);
    when(bf.getBean(IntegrationContextUtils.TASK_SCHEDULER_BEAN_NAME, TaskScheduler.class))
        .thenReturn(scheduler);
    serverFactory.setBeanFactory(bf);
    TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
    adapter.setOutputChannel(new NullChannel());
    adapter.setConnectionFactory(serverFactory);
    adapter.start();
    assertTrue("Listening event not received", serverListeningLatch.await(10, TimeUnit.SECONDS));
    assertThat(events.get(0), instanceOf(TcpConnectionServerListeningEvent.class));
    assertThat(
        ((TcpConnectionServerListeningEvent) events.get(0)).getPort(),
        equalTo(serverFactory.getPort()));
    int port = serverFactory.getPort();
    TcpNetClientConnectionFactory clientFactory =
        new TcpNetClientConnectionFactory("localhost", port);
    clientFactory.registerListener(message -> false);
    clientFactory.setBeanName("clientFactory");
    clientFactory.setApplicationEventPublisher(publisher);
    clientFactory.start();
    TcpConnectionSupport client = clientFactory.getConnection();
    List<String> clients = clientFactory.getOpenConnectionIds();
    assertEquals(1, clients.size());
    assertTrue(clients.contains(client.getConnectionId()));
    assertTrue(
        "Server connection failed to register",
        serverConnectionInitLatch.await(1, TimeUnit.SECONDS));
    List<String> servers = serverFactory.getOpenConnectionIds();
    assertEquals(1, servers.size());
    assertTrue(serverFactory.closeConnection(servers.get(0)));
    servers = serverFactory.getOpenConnectionIds();
    assertEquals(0, servers.size());
    int n = 0;
    clients = clientFactory.getOpenConnectionIds();
    while (n++ < 100 && clients.size() > 0) {
      Thread.sleep(100);
      clients = clientFactory.getOpenConnectionIds();
    }
    assertEquals(0, clients.size());
    assertTrue(eventLatch.await(10, TimeUnit.SECONDS));
    assertThat(
        "Expected at least " + expectedEvents + " events; got: " + events.size() + " : " + events,
        events.size(),
        greaterThanOrEqualTo(expectedEvents));

    FooEvent event = new FooEvent(client, "foo");
    client.publishEvent(event);
    assertThat(
        "Expected at least " + expectedEvents + " events; got: " + events.size() + " : " + events,
        events.size(),
        greaterThanOrEqualTo(expectedEvents + 1));

    try {
      event = new FooEvent(mock(TcpConnectionSupport.class), "foo");
      client.publishEvent(event);
      fail("Expected exception");
    } catch (IllegalArgumentException e) {
      assertTrue("Can only publish events with this as the source".equals(e.getMessage()));
    }

    SocketAddress address = serverFactory.getServerSocketAddress();
    if (address instanceof InetSocketAddress) {
      InetSocketAddress inetAddress = (InetSocketAddress) address;
      assertEquals(port, inetAddress.getPort());
    }
    serverFactory.stop();
    scheduler.shutdown();
  }