INT-1279 TCP ib and ob Gateways Using Connection Factories - namespace and docs to follow

spring-integration-ip/src/test/java/org/springframework/integration/ip/tcp/TcpInboundGatewayTests.java

@@ -0,0 +1,168 @@
+package org.springframework.integration.ip.tcp;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.Socket;
+
+import javax.net.SocketFactory;
+
+import org.junit.Test;
+import org.springframework.integration.channel.QueueChannel;
+import org.springframework.integration.core.ChannelResolver;
+import org.springframework.integration.core.MessageChannel;
+import org.springframework.integration.handler.ServiceActivatingHandler;
+import org.springframework.integration.ip.tcp.connection.AbstractServerConnectionFactory;
+import org.springframework.integration.ip.tcp.connection.TcpNetServerConnectionFactory;
+import org.springframework.integration.ip.tcp.connection.TcpNioServerConnectionFactory;
+import org.springframework.integration.ip.util.SocketUtils;
+
+
+public class TcpInboundGatewayTests {
+
+	@Test
+	public void testNetSingle() throws Exception {
+		final int port = SocketUtils.findAvailableServerSocket();
+		AbstractServerConnectionFactory scf = new TcpNetServerConnectionFactory(port);
+		scf.setSingleUse(true);
+		TcpInboundGateway gateway = new TcpInboundGateway();
+		gateway.setConnectionFactory(scf);
+		scf.start();
+		int n = 0;
+		while (!scf.isListening()) {
+			Thread.sleep(100);
+			if (n++ > 200) {
+				fail("Failed to listen");
+			}
+		}
+		final QueueChannel channel = new QueueChannel();
+		gateway.setRequestChannel(channel);
+		ServiceActivatingHandler handler = new ServiceActivatingHandler(new Service());
+		handler.setChannelResolver(new ChannelResolver() {
+			public MessageChannel resolveChannelName(String channelName) {
+				return channel;
+			}
+		});
+		Socket socket = SocketFactory.getDefault().createSocket("localhost", port);
+		socket.getOutputStream().write("Test1\r\n".getBytes());
+		socket.getOutputStream().write("Test2\r\n".getBytes());
+		handler.handleMessage(channel.receive());
+		handler.handleMessage(channel.receive());
+		byte[] bytes = new byte[12];
+		readFully(socket.getInputStream(), bytes);
+		assertEquals("Echo:Test1\r\n", new String(bytes));
+		readFully(socket.getInputStream(), bytes);
+		assertEquals("Echo:Test2\r\n", new String(bytes));
+	}
+
+	@Test
+	public void testNetNotSingle() throws Exception {
+		final int port = SocketUtils.findAvailableServerSocket();
+		AbstractServerConnectionFactory scf = new TcpNetServerConnectionFactory(port);
+		scf.setSingleUse(false);
+		TcpInboundGateway gateway = new TcpInboundGateway();
+		gateway.setConnectionFactory(scf);
+		scf.start();
+		int n = 0;
+		while (!scf.isListening()) {
+			Thread.sleep(100);
+			if (n++ > 200) {
+				fail("Failed to listen");
+			}
+		}
+		final QueueChannel channel = new QueueChannel();
+		gateway.setRequestChannel(channel);
+		ServiceActivatingHandler handler = new ServiceActivatingHandler(new Service());
+		Socket socket = SocketFactory.getDefault().createSocket("localhost", port);
+		socket.getOutputStream().write("Test1\r\n".getBytes());
+		socket.getOutputStream().write("Test2\r\n".getBytes());
+		handler.handleMessage(channel.receive());
+		handler.handleMessage(channel.receive());
+		byte[] bytes = new byte[12];
+		readFully(socket.getInputStream(), bytes);
+		assertEquals("Echo:Test1\r\n", new String(bytes));
+		readFully(socket.getInputStream(), bytes);
+		assertEquals("Echo:Test2\r\n", new String(bytes));
+	}
+
+	@Test
+	public void testNioSingle() throws Exception {
+		final int port = SocketUtils.findAvailableServerSocket();
+		AbstractServerConnectionFactory scf = new TcpNioServerConnectionFactory(port);
+		scf.setSingleUse(true);
+		TcpInboundGateway gateway = new TcpInboundGateway();
+		gateway.setConnectionFactory(scf);
+		scf.start();
+		int n = 0;
+		while (!scf.isListening()) {
+			Thread.sleep(100);
+			if (n++ > 200) {
+				fail("Failed to listen");
+			}
+		}
+		final QueueChannel channel = new QueueChannel();
+		gateway.setRequestChannel(channel);
+		ServiceActivatingHandler handler = new ServiceActivatingHandler(new Service());
+		handler.setChannelResolver(new ChannelResolver() {
+			public MessageChannel resolveChannelName(String channelName) {
+				return channel;
+			}
+		});
+		Socket socket = SocketFactory.getDefault().createSocket("localhost", port);
+		socket.getOutputStream().write("Test1\r\n".getBytes());
+		socket.getOutputStream().write("Test2\r\n".getBytes());
+		handler.handleMessage(channel.receive());
+		handler.handleMessage(channel.receive());
+		byte[] bytes = new byte[12];
+		readFully(socket.getInputStream(), bytes);
+		assertEquals("Echo:Test1\r\n", new String(bytes));
+		readFully(socket.getInputStream(), bytes);
+		assertEquals("Echo:Test2\r\n", new String(bytes));
+	}
+
+	@Test
+	public void testNioNotSingle() throws Exception {
+		final int port = SocketUtils.findAvailableServerSocket();
+		AbstractServerConnectionFactory scf = new TcpNioServerConnectionFactory(port);
+		scf.setSingleUse(false);
+		TcpInboundGateway gateway = new TcpInboundGateway();
+		gateway.setConnectionFactory(scf);
+		scf.start();
+		int n = 0;
+		while (!scf.isListening()) {
+			Thread.sleep(100);
+			if (n++ > 200) {
+				fail("Failed to listen");
+			}
+		}
+		final QueueChannel channel = new QueueChannel();
+		gateway.setRequestChannel(channel);
+		ServiceActivatingHandler handler = new ServiceActivatingHandler(new Service());
+		Socket socket = SocketFactory.getDefault().createSocket("localhost", port);
+		socket.getOutputStream().write("Test1\r\n".getBytes());
+		socket.getOutputStream().write("Test2\r\n".getBytes());
+		handler.handleMessage(channel.receive());
+		handler.handleMessage(channel.receive());
+		byte[] bytes = new byte[12];
+		readFully(socket.getInputStream(), bytes);
+		assertEquals("Echo:Test1\r\n", new String(bytes));
+		readFully(socket.getInputStream(), bytes);
+		assertEquals("Echo:Test2\r\n", new String(bytes));
+	}
+
+	private class Service {
+		@SuppressWarnings("unused")
+		public String serviceMethod(byte[] bytes) {
+			return "Echo:" + new String(bytes);
+		}
+	}
+
+	private void readFully(InputStream is, byte[] buff) throws IOException {
+		for (int i = 0; i < buff.length; i++) {
+			buff[i] = (byte) is.read();
+		}
+	}
+	
+}

spring-integration-ip/src/test/java/org/springframework/integration/ip/tcp/TcpOutboundGatewayTests.java

@@ -0,0 +1,240 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.ip.tcp;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.net.ServerSocketFactory;
+
+import org.junit.Test;
+import org.springframework.commons.serializer.java.JavaStreamingConverter;
+import org.springframework.integration.Message;
+import org.springframework.integration.MessageTimeoutException;
+import org.springframework.integration.channel.QueueChannel;
+import org.springframework.integration.core.MessageBuilder;
+import org.springframework.integration.ip.tcp.connection.AbstractConnectionFactory;
+import org.springframework.integration.ip.tcp.connection.TcpNetClientConnectionFactory;
+import org.springframework.integration.ip.util.SocketUtils;
+
+
+/**
+ * @author Gary Russell
+ * @since 2.0
+ *
+ */
+public class TcpOutboundGatewayTests {
+
+	@Test 
+	public void testGoodNetSingle() {
+		final int port = SocketUtils.findAvailableServerSocket();
+		AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
+		final CountDownLatch latch = new CountDownLatch(1);
+		final AtomicBoolean done = new AtomicBoolean();
+		Executors.newSingleThreadExecutor().execute(new Runnable() {
+			public void run() {
+				try {
+					ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
+					latch.countDown();
+					int i = 0;
+					while (true) {
+						Socket socket = server.accept();
+						ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
+						Object in = ois.readObject();
+						ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
+						oos.writeObject("Reply" + (i++));
+					}
+				} catch (Exception e) {
+					if (!done.get()) {
+						e.printStackTrace();
+					}
+				}
+			}
+		});
+		JavaStreamingConverter converter = new JavaStreamingConverter();
+		ccf.setInputConverter(converter);
+		ccf.setOutputConverter(converter);
+		ccf.setSoTimeout(10000);
+		ccf.setSingleUse(true);
+		ccf.setPoolSize(10);
+		ccf.start();
+		TcpOutboundGateway gateway = new TcpOutboundGateway();
+		gateway.setConnectionFactory(ccf);
+		QueueChannel replyChannel = new QueueChannel();
+		gateway.setRequiresReply(true);
+		gateway.setOutputChannel(replyChannel);
+		gateway.setReplyTimeout(60000);
+		gateway.setRequestTimeout(60000);
+		for (int i = 100; i < 200; i++) {
+			gateway.handleMessage(MessageBuilder.withPayload("Test" + i).build());
+		}
+		Set<String> replies = new HashSet<String>();
+		for (int i = 100; i < 200; i++) { 
+			Message<?> m = replyChannel.receive(10000);
+			assertNotNull(m);
+			replies.add((String) m.getPayload());
+		}
+		for (int i = 0; i < 100; i++) {
+			assertTrue(replies.remove("Reply" + i));
+		}
+	}
+
+	@Test 
+	public void testGoodNetMultiplex() {
+		final int port = SocketUtils.findAvailableServerSocket();
+		final CountDownLatch latch = new CountDownLatch(1);
+		final AtomicBoolean done = new AtomicBoolean();
+		Executors.newSingleThreadExecutor().execute(new Runnable() {
+			public void run() {
+				try {
+					ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
+					latch.countDown();
+					int i = 0;
+					Socket socket = server.accept();
+					while (true) {
+						ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
+						ois.readObject();
+						ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
+						oos.writeObject("Reply" + (i++));
+					}
+				} catch (Exception e) {
+					if (!done.get()) {
+						e.printStackTrace();
+					}
+				}
+			}
+		});
+		AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
+		JavaStreamingConverter converter = new JavaStreamingConverter();
+		ccf.setInputConverter(converter);
+		ccf.setOutputConverter(converter);
+		ccf.setSoTimeout(10000);
+		ccf.setSingleUse(false);
+		ccf.start();
+		TcpOutboundGateway gateway = new TcpOutboundGateway();
+		gateway.setConnectionFactory(ccf);
+		QueueChannel replyChannel = new QueueChannel();
+		gateway.setRequiresReply(true);
+		gateway.setOutputChannel(replyChannel);
+		for (int i = 100; i < 110; i++) {
+			gateway.handleMessage(MessageBuilder.withPayload("Test" + i).build());
+		}
+		Set<String> replies = new HashSet<String>();
+		for (int i = 100; i < 110; i++) { 
+			Message<?> m = replyChannel.receive(10000);
+			assertNotNull(m);
+			replies.add((String) m.getPayload());
+		}
+		for (int i = 0; i < 10; i++) {
+			assertTrue(replies.remove("Reply" + i));
+		}
+	}
+
+	@Test 
+	public void testGoodNetTimeout() throws Exception {
+		final int port = SocketUtils.findAvailableServerSocket();
+		final CountDownLatch latch = new CountDownLatch(1);
+		final AtomicBoolean done = new AtomicBoolean();
+		Executors.newSingleThreadExecutor().execute(new Runnable() {
+			public void run() {
+				try {
+					ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
+					latch.countDown();
+					int i = 0;
+					Socket socket = server.accept();
+					while (true) {
+						ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
+						ois.readObject();
+						ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
+						Thread.sleep(1000);
+						oos.writeObject("Reply" + (i++));
+					}
+				} catch (Exception e) {
+					if (!done.get()) {
+						e.printStackTrace();
+					}
+				}
+			}
+		});
+		AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
+		JavaStreamingConverter converter = new JavaStreamingConverter();
+		ccf.setInputConverter(converter);
+		ccf.setOutputConverter(converter);
+		ccf.setSoTimeout(10000);
+		ccf.setSingleUse(false);
+		ccf.start();
+		final TcpOutboundGateway gateway = new TcpOutboundGateway();
+		gateway.setConnectionFactory(ccf);
+		gateway.setRequestTimeout(1);
+		QueueChannel replyChannel = new QueueChannel();
+		gateway.setRequiresReply(true);
+		gateway.setOutputChannel(replyChannel);
+		List<Future<Integer>> results = new ArrayList<Future<Integer>>();
+		for (int i = 0; i < 2; i++) {
+			final int j = i;
+			results.add(Executors.newSingleThreadExecutor().submit(new Callable<Integer>(){
+				public Integer call() throws Exception {
+					gateway.handleMessage(MessageBuilder.withPayload("Test" + j).build());
+					return 0;
+				}
+			}));
+		}
+		Set<String> replies = new HashSet<String>();
+		for (int i = 0; i < 2; i++) { 
+			try {
+				results.get(i).get();
+			} catch (InterruptedException e) {
+			} catch (ExecutionException e) {
+				if (i == 0) {
+					fail("Unexpected " + e.getMessage());
+				} else if (i == 1) {
+					assertNotNull(e.getCause());
+					assertTrue(e.getCause() instanceof MessageTimeoutException);
+				}
+				
+				continue;
+			}
+			if (i == 1) {
+				fail("Expected ExecutionException");
+			}
+			Message<?> m = replyChannel.receive(10000);
+			assertNotNull(m);
+			replies.add((String) m.getPayload());
+		}
+		for (int i = 0; i < 1; i++) {
+			assertTrue(replies.remove("Reply" + i));
+		}
+	}
+
+
+}

spring-integration-ip/src/test/java/org/springframework/integration/ip/tcp/TcpReceivingChannelAdapterTests.java

@@ -25,8 +25,6 @@ import java.io.InputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.net.Socket;
-import java.net.SocketException;
-import java.net.UnknownHostException;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;

spring-integration-ip/src/test/java/org/springframework/integration/ip/tcp/connection/HelloWorldInterceptor.java

@@ -58,7 +58,7 @@ public class HelloWorldInterceptor extends AbstractTcpConnectionInterceptor {
 	}
 
 	@Override
-	public void onMessage(Message<?> message) {
+	public boolean onMessage(Message<?> message) {
 		if (!this.negotiated) {
 			Object payload = message.getPayload();
 			if (this.isServer()) {
@@ -67,7 +67,7 @@ public class HelloWorldInterceptor extends AbstractTcpConnectionInterceptor {
 						logger.debug("sending " + this.world);
 						super.send(MessageBuilder.withPayload(world).build());
 						this.negotiated = true;
-						return;
+						return true;
 					} catch (Exception e) {
 						throw new MessagingException("Negotiation error", e);
 					}
@@ -84,10 +84,10 @@ public class HelloWorldInterceptor extends AbstractTcpConnectionInterceptor {
 					throw new MessagingException("Negotiation error - expected '" + world + 
 								"' received " + payload);
 				}
-				return;
+				return true;
 			}
 		}
-		super.onMessage(message);
+		return super.onMessage(message);
 	}
 
 	@Override

spring-integration-ip/src/test/java/org/springframework/integration/ip/udp/MultiClientTests.java

@@ -65,7 +65,7 @@ public class MultiClientTests {
 					UnicastSendingMessageHandler sender = new UnicastSendingMessageHandler(
 							"localhost", adapter.getPort());
 					while (true) {
-						Message message = queueIn.receive();
+						Message<?> message = queueIn.receive();
 						sender.handleMessage(message);
 					}
 				}});
@@ -110,7 +110,7 @@ public class MultiClientTests {
 							SocketUtils.findAvailableUdpSocket(adapter.getPort() + j + 1000),
 							10000);
 					while (true) {
-						Message message = queueIn.receive();
+						Message<?> message = queueIn.receive();
 						sender.handleMessage(message);
 					}
 				}});
@@ -155,7 +155,7 @@ public class MultiClientTests {
 							SocketUtils.findAvailableUdpSocket(adapter.getPort() + j + 1100),
 							10000);
 					while (true) {
-						Message message = queueIn.receive();
+						Message<?> message = queueIn.receive();
 						sender.handleMessage(message);
 					}
 				}});