Examples with TcpReceivingChannelAdapter org.springframework.integration.ip.tcp.TcpReceivingChannelAdapter used on opensource projects

Example 1 with TcpReceivingChannelAdapter

use of org.springframework.integration.ip.tcp.TcpReceivingChannelAdapter in project spring-integration-samples by spring-projects.

the class DynamicTcpClientApplication method inOne.

@Bean
public TcpReceivingChannelAdapter inOne(TcpNetServerConnectionFactory cfOne) {
    TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
    adapter.setConnectionFactory(cfOne);
    adapter.setOutputChannel(outputChannel());
    return adapter;
}

Example 2 with TcpReceivingChannelAdapter

use of org.springframework.integration.ip.tcp.TcpReceivingChannelAdapter in project spring-integration-samples by spring-projects.

the class DynamicTcpClientApplication method inTwo.

@Bean
public TcpReceivingChannelAdapter inTwo(TcpNetServerConnectionFactory cfTwo) {
    TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
    adapter.setConnectionFactory(cfTwo);
    adapter.setOutputChannel(outputChannel());
    return adapter;
}

Example 3 with TcpReceivingChannelAdapter

use of org.springframework.integration.ip.tcp.TcpReceivingChannelAdapter in project spring-integration by spring-projects.

the class IpIntegrationTests method testTcpAdapters.

@Test
public void testTcpAdapters() throws Exception {
    ApplicationEventPublisher publisher = e -> {
    };
    AbstractServerConnectionFactory server = Tcp.netServer(0).backlog(2).soTimeout(5000).id("server").get();
    assertEquals("server", server.getComponentName());
    server.setApplicationEventPublisher(publisher);
    server.afterPropertiesSet();
    TcpReceivingChannelAdapter inbound = Tcp.inboundAdapter(server).get();
    QueueChannel received = new QueueChannel();
    inbound.setOutputChannel(received);
    inbound.afterPropertiesSet();
    inbound.start();
    TestingUtilities.waitListening(server, null);
    AbstractClientConnectionFactory client = Tcp.netClient("localhost", server.getPort()).id("client").get();
    assertEquals("client", client.getComponentName());
    client.setApplicationEventPublisher(publisher);
    client.afterPropertiesSet();
    TcpSendingMessageHandler handler = Tcp.outboundAdapter(client).get();
    handler.start();
    handler.handleMessage(new GenericMessage<>("foo"));
    Message<?> receivedMessage = received.receive(10000);
    assertNotNull(receivedMessage);
    assertEquals("foo", Transformers.objectToString().transform(receivedMessage).getPayload());
    client.stop();
    server.stop();
}

Example 4 with TcpReceivingChannelAdapter

use of org.springframework.integration.ip.tcp.TcpReceivingChannelAdapter in project spring-integration by spring-projects.

the class ConnectionFactoryTests method testObtainConnectionIds.

public void testObtainConnectionIds(AbstractServerConnectionFactory serverFactory) throws Exception {
    final List<IpIntegrationEvent> events = Collections.synchronizedList(new ArrayList<IpIntegrationEvent>());
    int expectedEvents = serverFactory instanceof TcpNetServerConnectionFactory ? // Listening, + OPEN, CLOSE, EXCEPTION for each side
    7 : // Listening, + OPEN, CLOSE (but we *might* get exceptions, depending on timing).
    5;
    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(10, 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();
}

Example 5 with TcpReceivingChannelAdapter

use of org.springframework.integration.ip.tcp.TcpReceivingChannelAdapter in project faf-java-server by FAForever.

the class LegacyAdapterConfig method tcpReceivingChannelAdapter.

/**
 * TCP inbound adapter that accepts connections and messages from clients.
 */
@Bean
public TcpReceivingChannelAdapter tcpReceivingChannelAdapter() {
    TcpReceivingChannelAdapter tcpReceivingChannelAdapter = new TcpReceivingChannelAdapter();
    tcpReceivingChannelAdapter.setConnectionFactory(tcpServerConnectionFactory());
    tcpReceivingChannelAdapter.setOutputChannel(legacyInbound());
    tcpReceivingChannelAdapter.setErrorChannelName(IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME);
    return tcpReceivingChannelAdapter;
}