/** * Construct an instance using an existing spring-managed connection factory. * @param connectionFactoryBean the spring-managed bean. */ TcpInboundChannelAdapterSpec(AbstractConnectionFactory connectionFactoryBean) { super(new TcpReceivingChannelAdapter()); this.connectionFactory = null; this.target.setConnectionFactory(connectionFactoryBean); }
/** * @param isClientMode true to connect in client mode * @return the spec. * @see TcpReceivingChannelAdapter#setClientMode(boolean) */ public TcpInboundChannelAdapterSpec clientMode(boolean isClientMode) { this.target.setClientMode(isClientMode); return _this(); }
/** * @param retryInterval the client mode retry interval to set. * @return the spec. * @see TcpReceivingChannelAdapter#setRetryInterval(long) */ public TcpInboundChannelAdapterSpec retryInterval(long retryInterval) { this.target.setRetryInterval(retryInterval); return _this(); }
scf.setDeserializer(serializer); scf.setSingleUse(true); TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter(); adapter.setConnectionFactory(scf); scf.start(); TestingUtilities.waitListening(scf, null); int port = scf.getPort(); QueueChannel channel = new QueueChannel(); adapter.setOutputChannel(channel); Socket socket = SocketFactory.getDefault().createSocket("localhost", port); socket.getOutputStream().write("Test1\r\n".getBytes());
ccf.setDeserializer(serializer); ccf.setSoTimeout(Integer.MAX_VALUE); TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter(); adapter.setConnectionFactory(ccf); adapter.setClientMode(true); QueueChannel channel = new QueueChannel(); adapter.setOutputChannel(channel); adapter.setBeanFactory(mock(BeanFactory.class)); adapter.afterPropertiesSet(); adapter.setRetryInterval(10000); ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler(); taskScheduler.setPoolSize(1); taskScheduler.initialize(); adapter.setTaskScheduler(taskScheduler); adapter.start(); Message<?> message = channel.receive(10000); assertNotNull(message); assertNotNull(message); assertEquals("Test2", new String((byte[]) message.getPayload())); adapter.stop(); adapter.start(); adapter.stop(); latch2.countDown(); ccf.stop();
@Bean public TcpReceivingChannelAdapter adapter( @Qualifier("tcpClientConnectionFactory") AbstractConnectionFactory connectionFactory) { TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter(); adapter.setConnectionFactory(connectionFactory); adapter.setClientMode(true); adapter.setRetryInterval(this.properties.getRetryInterval()); adapter.setOutputChannel(this.channels.output()); return adapter; }
TcpSendingMessageHandler handler = new TcpSendingMessageHandler(); handler.setConnectionFactory(ccf); TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter(); adapter.setConnectionFactory(ccf); QueueChannel channel = new QueueChannel(); adapter.setOutputChannel(channel); handler.setClientMode(true); handler.setRetryInterval(10000); handler.setTaskScheduler(taskScheduler); handler.start(); adapter.start(); handler.handleMessage(MessageBuilder.withPayload("Test").build()); handler.handleMessage(MessageBuilder.withPayload("Test").build()); handler.start(); handler.stop(); adapter.stop(); ccf.stop(); serverSocket.get().close();
@Bean public TcpReceivingChannelAdapter adapter( @Qualifier("tcpClientConnectionFactory") AbstractConnectionFactory connectionFactory) { TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter(); adapter.setConnectionFactory(connectionFactory); adapter.setClientMode(true); adapter.setRetryInterval(this.properties.getRetryInterval()); adapter.setOutputChannelName(Source.OUTPUT); return adapter; }
@Test public void testNet() throws Exception { AbstractServerConnectionFactory scf = new TcpNetServerConnectionFactory(0); noopPublisher(scf); ByteArrayCrLfSerializer serializer = new ByteArrayCrLfSerializer(); scf.setSerializer(serializer); scf.setDeserializer(serializer); TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter(); adapter.setConnectionFactory(scf); scf.start(); TestingUtilities.waitListening(scf, null); int port = scf.getPort(); QueueChannel channel = new QueueChannel(); adapter.setOutputChannel(channel); adapter.setBeanFactory(mock(BeanFactory.class)); adapter.afterPropertiesSet(); Socket socket = SocketFactory.getDefault().createSocket("localhost", port); socket.getOutputStream().write("Test1\r\n".getBytes()); socket.getOutputStream().write("Test2\r\n".getBytes()); Message<?> message = channel.receive(10000); assertNotNull(message); assertEquals("Test1", new String((byte[]) message.getPayload())); message = channel.receive(10000); assertNotNull(message); assertEquals("Test2", new String((byte[]) message.getPayload())); scf.stop(); }
scf.setSerializer(serializer); scf.setDeserializer(serializer); TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter(); adapter.setConnectionFactory(scf); scf.start(); TestingUtilities.waitListening(scf, null); int port = scf.getPort(); SubscribableChannel channel = new DirectChannel(); adapter.setOutputChannel(channel); ServiceActivatingHandler handler = new ServiceActivatingHandler(new FailingService()); handler.setBeanFactory(mock(BeanFactory.class)); channel.subscribe(handler); QueueChannel errorChannel = new QueueChannel(); adapter.setErrorChannel(errorChannel); Socket socket = SocketFactory.getDefault().createSocket("localhost", port); socket.getOutputStream().write("Test1\r\n".getBytes());
@Bean public TcpReceivingChannelAdapter adapter( @Qualifier("tcpSourceConnectionFactory") AbstractConnectionFactory connectionFactory) { TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter(); adapter.setConnectionFactory(connectionFactory); adapter.setOutputChannelName(Source.OUTPUT); return adapter; }
@Test public void testTcpAdapters() { 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(); }
@Override public int afterShutdown() { this.stop(); return this.activeCount.get(); } }
/** * @param taskScheduler the scheduler for connecting in client mode. * @return the spec. * @see TcpReceivingChannelAdapter#setTaskScheduler(TaskScheduler) */ public TcpInboundChannelAdapterSpec taskScheduler(TaskScheduler taskScheduler) { this.target.setTaskScheduler(taskScheduler); return _this(); }
@Override // protected by super#lifecycleLock protected void doStart() { super.doStart(); if (!this.active) { this.active = true; this.shuttingDown = false; if (this.serverConnectionFactory != null) { this.serverConnectionFactory.start(); } if (this.clientConnectionFactory != null) { this.clientConnectionFactory.start(); } if (this.isClientMode) { ClientModeConnectionManager manager = new ClientModeConnectionManager( this.clientConnectionFactory); this.clientModeConnectionManager = manager; Assert.state(this.getTaskScheduler() != null, "Client mode requires a task scheduler"); this.scheduledFuture = this.getTaskScheduler().scheduleAtFixedRate(manager, this.retryInterval); } } }
scf.setDeserializer(serializer); scf.setSingleUse(true); TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter(); adapter.setConnectionFactory(scf); scf.start(); TestingUtilities.waitListening(scf, null); int port = scf.getPort(); QueueChannel channel = new QueueChannel(); adapter.setOutputChannel(channel); Socket socket = SocketFactory.getDefault().createSocket("localhost", port); socket.getOutputStream().write("Test1\r\n".getBytes());
@Bean public TcpReceivingChannelAdapter adapter( @Qualifier("tcpClientConnectionFactory") AbstractConnectionFactory connectionFactory) { TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter(); adapter.setConnectionFactory(connectionFactory); adapter.setClientMode(true); adapter.setRetryInterval(this.properties.getRetryInterval()); adapter.setOutputChannel(this.source.output()); return adapter; }
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));