PageRenderTime 60ms CodeModel.GetById 25ms RepoModel.GetById 1ms app.codeStats 0ms

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

https://github.com/nickspacek/spring-integration
Java | 1128 lines | 1077 code | 31 blank | 20 comment | 55 complexity | 7546dfeaebb48faff557ea39fdff64d6 MD5 | raw file
Possible License(s): Apache-2.0
  1. /*
  2. * Copyright 2002-2012 the original author or authors.
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. * http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */
  16. package org.springframework.integration.ip.tcp;
  17. import static org.junit.Assert.assertEquals;
  18. import static org.junit.Assert.assertNotNull;
  19. import static org.junit.Assert.assertTrue;
  20. import static org.junit.Assert.fail;
  21. import static org.mockito.Mockito.mock;
  22. import java.io.IOException;
  23. import java.io.InputStream;
  24. import java.io.ObjectInputStream;
  25. import java.io.ObjectOutputStream;
  26. import java.net.ServerSocket;
  27. import java.net.Socket;
  28. import java.net.SocketException;
  29. import java.util.ArrayList;
  30. import java.util.HashSet;
  31. import java.util.List;
  32. import java.util.Set;
  33. import java.util.TreeSet;
  34. import java.util.concurrent.CountDownLatch;
  35. import java.util.concurrent.Executors;
  36. import java.util.concurrent.Semaphore;
  37. import java.util.concurrent.TimeUnit;
  38. import java.util.concurrent.atomic.AtomicBoolean;
  39. import javax.net.ServerSocketFactory;
  40. import org.apache.commons.logging.Log;
  41. import org.apache.commons.logging.LogFactory;
  42. import org.junit.Test;
  43. import org.mockito.Mockito;
  44. import org.mockito.invocation.InvocationOnMock;
  45. import org.mockito.stubbing.Answer;
  46. import org.springframework.context.ApplicationContext;
  47. import org.springframework.context.support.ClassPathXmlApplicationContext;
  48. import org.springframework.core.serializer.DefaultDeserializer;
  49. import org.springframework.core.serializer.DefaultSerializer;
  50. import org.springframework.integration.Message;
  51. import org.springframework.integration.MessageChannel;
  52. import org.springframework.integration.MessagingException;
  53. import org.springframework.integration.channel.QueueChannel;
  54. import org.springframework.integration.core.PollableChannel;
  55. import org.springframework.integration.ip.tcp.connection.AbstractClientConnectionFactory;
  56. import org.springframework.integration.ip.tcp.connection.AbstractConnectionFactory;
  57. import org.springframework.integration.ip.tcp.connection.AbstractServerConnectionFactory;
  58. import org.springframework.integration.ip.tcp.connection.HelloWorldInterceptorFactory;
  59. import org.springframework.integration.ip.tcp.connection.TcpConnectionInterceptorFactory;
  60. import org.springframework.integration.ip.tcp.connection.TcpConnectionInterceptorFactoryChain;
  61. import org.springframework.integration.ip.tcp.connection.TcpNetClientConnectionFactory;
  62. import org.springframework.integration.ip.tcp.connection.TcpNioClientConnectionFactory;
  63. import org.springframework.integration.ip.tcp.serializer.ByteArrayCrLfSerializer;
  64. import org.springframework.integration.ip.tcp.serializer.ByteArrayLengthHeaderSerializer;
  65. import org.springframework.integration.ip.tcp.serializer.ByteArrayStxEtxSerializer;
  66. import org.springframework.integration.ip.util.TestingUtilities;
  67. import org.springframework.integration.message.GenericMessage;
  68. import org.springframework.integration.support.MessageBuilder;
  69. import org.springframework.integration.test.util.SocketUtils;
  70. import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
  71. /**
  72. * @author Gary Russell
  73. * @author Artem Bilan
  74. * @since 2.0
  75. */
  76. public class TcpSendingMessageHandlerTests {
  77. private static final Log logger = LogFactory.getLog(TcpSendingMessageHandlerTests.class);
  78. private void readFully(InputStream is, byte[] buff) throws IOException {
  79. for (int i = 0; i < buff.length; i++) {
  80. buff[i] = (byte) is.read();
  81. }
  82. }
  83. @Test
  84. public void testNetCrLf() throws Exception {
  85. final int port = SocketUtils.findAvailableServerSocket();
  86. final CountDownLatch latch = new CountDownLatch(1);
  87. final AtomicBoolean done = new AtomicBoolean();
  88. Executors.newSingleThreadExecutor().execute(new Runnable() {
  89. public void run() {
  90. try {
  91. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  92. latch.countDown();
  93. Socket socket = server.accept();
  94. int i = 0;
  95. while (true) {
  96. byte[] b = new byte[6];
  97. readFully(socket.getInputStream(), b);
  98. b = ("Reply" + (++i) + "\r\n").getBytes();
  99. socket.getOutputStream().write(b);
  100. }
  101. }
  102. catch (Exception e) {
  103. if (!done.get()) {
  104. e.printStackTrace();
  105. }
  106. }
  107. }
  108. });
  109. AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
  110. ByteArrayCrLfSerializer serializer = new ByteArrayCrLfSerializer();
  111. ccf.setSerializer(serializer);
  112. ccf.setDeserializer(serializer);
  113. ccf.setSoTimeout(10000);
  114. ccf.start();
  115. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  116. handler.setConnectionFactory(ccf);
  117. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  118. adapter.setConnectionFactory(ccf);
  119. QueueChannel channel = new QueueChannel();
  120. adapter.setOutputChannel(channel);
  121. assertTrue(latch.await(10, TimeUnit.SECONDS));
  122. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  123. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  124. Message<?> mOut = channel.receive(10000);
  125. assertNotNull(mOut);
  126. assertEquals("Reply1", new String((byte[]) mOut.getPayload()));
  127. mOut = channel.receive(10000);
  128. assertNotNull(mOut);
  129. assertEquals("Reply2", new String((byte[]) mOut.getPayload()));
  130. done.set(true);
  131. ccf.stop();
  132. }
  133. @Test
  134. public void testNetCrLfClientMode() throws Exception {
  135. final int port = SocketUtils.findAvailableServerSocket();
  136. final CountDownLatch latch = new CountDownLatch(1);
  137. final AtomicBoolean done = new AtomicBoolean();
  138. Executors.newSingleThreadExecutor().execute(new Runnable() {
  139. public void run() {
  140. try {
  141. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  142. latch.countDown();
  143. Socket socket = server.accept();
  144. int i = 0;
  145. while (true) {
  146. byte[] b = new byte[6];
  147. readFully(socket.getInputStream(), b);
  148. b = ("Reply" + (++i) + "\r\n").getBytes();
  149. socket.getOutputStream().write(b);
  150. }
  151. }
  152. catch (Exception e) {
  153. if (!done.get()) {
  154. e.printStackTrace();
  155. }
  156. }
  157. }
  158. });
  159. AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
  160. ByteArrayCrLfSerializer serializer = new ByteArrayCrLfSerializer();
  161. ccf.setSerializer(serializer);
  162. ccf.setDeserializer(serializer);
  163. ccf.setSoTimeout(Integer.MAX_VALUE);
  164. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  165. handler.setConnectionFactory(ccf);
  166. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  167. adapter.setConnectionFactory(ccf);
  168. QueueChannel channel = new QueueChannel();
  169. adapter.setOutputChannel(channel);
  170. assertTrue(latch.await(10, TimeUnit.SECONDS));
  171. handler.setClientMode(true);
  172. handler.setRetryInterval(10000);
  173. handler.afterPropertiesSet();
  174. ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
  175. taskScheduler.setPoolSize(1);
  176. taskScheduler.initialize();
  177. handler.setTaskScheduler(taskScheduler);
  178. handler.start();
  179. adapter.start();
  180. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  181. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  182. Message<?> mOut = channel.receive(10000);
  183. assertNotNull(mOut);
  184. assertEquals("Reply1", new String((byte[]) mOut.getPayload()));
  185. mOut = channel.receive(10000);
  186. assertNotNull(mOut);
  187. assertEquals("Reply2", new String((byte[]) mOut.getPayload()));
  188. done.set(true);
  189. handler.stop();
  190. handler.start();
  191. handler.stop();
  192. }
  193. @Test
  194. public void testNioCrLf() throws Exception {
  195. final int port = SocketUtils.findAvailableServerSocket();
  196. final CountDownLatch latch = new CountDownLatch(1);
  197. final AtomicBoolean done = new AtomicBoolean();
  198. Executors.newSingleThreadExecutor().execute(new Runnable() {
  199. public void run() {
  200. try {
  201. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  202. latch.countDown();
  203. Socket socket = server.accept();
  204. int i = 0;
  205. while (true) {
  206. byte[] b = new byte[6];
  207. readFully(socket.getInputStream(), b);
  208. b = ("Reply" + (++i) + "\r\n").getBytes();
  209. socket.getOutputStream().write(b);
  210. }
  211. } catch (Exception e) {
  212. if (!done.get()) {
  213. e.printStackTrace();
  214. }
  215. }
  216. }
  217. });
  218. AbstractConnectionFactory ccf = new TcpNioClientConnectionFactory("localhost", port);
  219. ByteArrayCrLfSerializer serializer = new ByteArrayCrLfSerializer();
  220. ccf.setSerializer(serializer);
  221. ccf.setDeserializer(serializer);
  222. ccf.setSoTimeout(10000);
  223. ccf.start();
  224. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  225. handler.setConnectionFactory(ccf);
  226. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  227. adapter.setConnectionFactory(ccf);
  228. QueueChannel channel = new QueueChannel();
  229. adapter.setOutputChannel(channel);
  230. assertTrue(latch.await(10, TimeUnit.SECONDS));
  231. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  232. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  233. Set<String> results = new HashSet<String>();
  234. Message<?> mOut = channel.receive(10000);
  235. assertNotNull(mOut);
  236. results.add(new String((byte[]) mOut.getPayload()));
  237. mOut = channel.receive(10000);
  238. assertNotNull(mOut);
  239. results.add(new String((byte[]) mOut.getPayload()));
  240. assertTrue(results.remove("Reply1"));
  241. assertTrue(results.remove("Reply2"));
  242. done.set(true);
  243. ccf.stop();
  244. }
  245. @Test
  246. public void testNetStxEtx() throws Exception {
  247. final int port = SocketUtils.findAvailableServerSocket();
  248. final CountDownLatch latch = new CountDownLatch(1);
  249. final AtomicBoolean done = new AtomicBoolean();
  250. Executors.newSingleThreadExecutor().execute(new Runnable() {
  251. public void run() {
  252. try {
  253. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  254. latch.countDown();
  255. Socket socket = server.accept();
  256. int i = 0;
  257. while (true) {
  258. byte[] b = new byte[6];
  259. readFully(socket.getInputStream(), b);
  260. b = ("\u0002Reply" + (++i) + "\u0003").getBytes();
  261. socket.getOutputStream().write(b);
  262. }
  263. } catch (Exception e) {
  264. if (!done.get()) {
  265. e.printStackTrace();
  266. }
  267. }
  268. }
  269. });
  270. AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
  271. ByteArrayStxEtxSerializer serializer = new ByteArrayStxEtxSerializer();
  272. ccf.setSerializer(serializer);
  273. ccf.setDeserializer(serializer);
  274. ccf.setSoTimeout(10000);
  275. ccf.start();
  276. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  277. handler.setConnectionFactory(ccf);
  278. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  279. adapter.setConnectionFactory(ccf);
  280. QueueChannel channel = new QueueChannel();
  281. adapter.setOutputChannel(channel);
  282. assertTrue(latch.await(10, TimeUnit.SECONDS));
  283. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  284. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  285. Message<?> mOut = channel.receive(10000);
  286. assertNotNull(mOut);
  287. assertEquals("Reply1", new String((byte[]) mOut.getPayload()));
  288. mOut = channel.receive(10000);
  289. assertNotNull(mOut);
  290. assertEquals("Reply2", new String((byte[]) mOut.getPayload()));
  291. done.set(true);
  292. ccf.stop();
  293. }
  294. @Test
  295. public void testNioStxEtx() throws Exception {
  296. final int port = SocketUtils.findAvailableServerSocket();
  297. final CountDownLatch latch = new CountDownLatch(1);
  298. final AtomicBoolean done = new AtomicBoolean();
  299. Executors.newSingleThreadExecutor().execute(new Runnable() {
  300. public void run() {
  301. try {
  302. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  303. latch.countDown();
  304. Socket socket = server.accept();
  305. int i = 0;
  306. while (true) {
  307. byte[] b = new byte[6];
  308. readFully(socket.getInputStream(), b);
  309. b = ("\u0002Reply" + (++i) + "\u0003").getBytes();
  310. socket.getOutputStream().write(b);
  311. }
  312. } catch (Exception e) {
  313. if (!done.get()) {
  314. e.printStackTrace();
  315. }
  316. }
  317. }
  318. });
  319. AbstractConnectionFactory ccf = new TcpNioClientConnectionFactory("localhost", port);
  320. ByteArrayStxEtxSerializer serializer = new ByteArrayStxEtxSerializer();
  321. ccf.setSerializer(serializer);
  322. ccf.setDeserializer(serializer);
  323. ccf.setSoTimeout(10000);
  324. ccf.start();
  325. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  326. handler.setConnectionFactory(ccf);
  327. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  328. adapter.setConnectionFactory(ccf);
  329. QueueChannel channel = new QueueChannel();
  330. adapter.setOutputChannel(channel);
  331. assertTrue(latch.await(10, TimeUnit.SECONDS));
  332. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  333. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  334. Set<String> results = new HashSet<String>();
  335. Message<?> mOut = channel.receive(10000);
  336. assertNotNull(mOut);
  337. results.add(new String((byte[]) mOut.getPayload()));
  338. mOut = channel.receive(10000);
  339. assertNotNull(mOut);
  340. results.add(new String((byte[]) mOut.getPayload()));
  341. assertTrue(results.remove("Reply1"));
  342. assertTrue(results.remove("Reply2"));
  343. done.set(true);
  344. ccf.stop();
  345. }
  346. @Test
  347. public void testNetLength() throws Exception {
  348. final int port = SocketUtils.findAvailableServerSocket();
  349. final CountDownLatch latch = new CountDownLatch(1);
  350. final AtomicBoolean done = new AtomicBoolean();
  351. Executors.newSingleThreadExecutor().execute(new Runnable() {
  352. public void run() {
  353. try {
  354. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  355. latch.countDown();
  356. Socket socket = server.accept();
  357. int i = 0;
  358. while (true) {
  359. byte[] b = new byte[8];
  360. readFully(socket.getInputStream(), b);
  361. if (!"\u0000\u0000\u0000\u0004Test".equals(new String(b))) {
  362. throw new RuntimeException("Bad Data");
  363. }
  364. b = ("\u0000\u0000\u0000\u0006Reply" + (++i)).getBytes();
  365. socket.getOutputStream().write(b);
  366. }
  367. } catch (Exception e) {
  368. if (!done.get()) {
  369. e.printStackTrace();
  370. }
  371. }
  372. }
  373. });
  374. AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
  375. ByteArrayLengthHeaderSerializer serializer = new ByteArrayLengthHeaderSerializer();
  376. ccf.setSerializer(serializer);
  377. ccf.setDeserializer(serializer);
  378. ccf.setSoTimeout(10000);
  379. ccf.start();
  380. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  381. handler.setConnectionFactory(ccf);
  382. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  383. adapter.setConnectionFactory(ccf);
  384. QueueChannel channel = new QueueChannel();
  385. adapter.setOutputChannel(channel);
  386. assertTrue(latch.await(10, TimeUnit.SECONDS));
  387. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  388. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  389. Message<?> mOut = channel.receive(10000);
  390. assertNotNull(mOut);
  391. assertEquals("Reply1", new String((byte[]) mOut.getPayload()));
  392. mOut = channel.receive(10000);
  393. assertNotNull(mOut);
  394. assertEquals("Reply2", new String((byte[]) mOut.getPayload()));
  395. done.set(true);
  396. ccf.stop();
  397. }
  398. @Test
  399. public void testNioLength() throws Exception {
  400. final int port = SocketUtils.findAvailableServerSocket();
  401. final CountDownLatch latch = new CountDownLatch(1);
  402. final AtomicBoolean done = new AtomicBoolean();
  403. Executors.newSingleThreadExecutor().execute(new Runnable() {
  404. public void run() {
  405. try {
  406. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  407. latch.countDown();
  408. Socket socket = server.accept();
  409. int i = 0;
  410. while (true) {
  411. byte[] b = new byte[8];
  412. readFully(socket.getInputStream(), b);
  413. if (!"\u0000\u0000\u0000\u0004Test".equals(new String(b))) {
  414. throw new RuntimeException("Bad Data");
  415. }
  416. b = ("\u0000\u0000\u0000\u0006Reply" + (++i)).getBytes();
  417. socket.getOutputStream().write(b);
  418. }
  419. } catch (Exception e) {
  420. if (!done.get()) {
  421. e.printStackTrace();
  422. }
  423. }
  424. }
  425. });
  426. AbstractConnectionFactory ccf = new TcpNioClientConnectionFactory("localhost", port);
  427. ByteArrayLengthHeaderSerializer serializer = new ByteArrayLengthHeaderSerializer();
  428. ccf.setSerializer(serializer);
  429. ccf.setDeserializer(serializer);
  430. ccf.setSoTimeout(10000);
  431. ccf.start();
  432. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  433. handler.setConnectionFactory(ccf);
  434. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  435. adapter.setConnectionFactory(ccf);
  436. QueueChannel channel = new QueueChannel();
  437. adapter.setOutputChannel(channel);
  438. assertTrue(latch.await(10, TimeUnit.SECONDS));
  439. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  440. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  441. Set<String> results = new HashSet<String>();
  442. Message<?> mOut = channel.receive(10000);
  443. assertNotNull(mOut);
  444. results.add(new String((byte[]) mOut.getPayload()));
  445. mOut = channel.receive(10000);
  446. assertNotNull(mOut);
  447. results.add(new String((byte[]) mOut.getPayload()));
  448. assertTrue(results.remove("Reply1"));
  449. assertTrue(results.remove("Reply2"));
  450. done.set(true);
  451. ccf.stop();
  452. }
  453. @Test
  454. public void testNetSerial() throws Exception {
  455. final int port = SocketUtils.findAvailableServerSocket();
  456. final CountDownLatch latch = new CountDownLatch(1);
  457. final AtomicBoolean done = new AtomicBoolean();
  458. Executors.newSingleThreadExecutor().execute(new Runnable() {
  459. public void run() {
  460. try {
  461. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  462. latch.countDown();
  463. Socket socket = server.accept();
  464. int i = 0;
  465. while (true) {
  466. ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
  467. ois.readObject();
  468. ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
  469. oos.writeObject("Reply" + (++i));
  470. }
  471. } catch (Exception e) {
  472. if (!done.get()) {
  473. e.printStackTrace();
  474. }
  475. }
  476. }
  477. });
  478. AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
  479. ccf.setSerializer(new DefaultSerializer());
  480. ccf.setDeserializer(new DefaultDeserializer());
  481. ccf.setSoTimeout(10000);
  482. ccf.start();
  483. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  484. handler.setConnectionFactory(ccf);
  485. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  486. adapter.setConnectionFactory(ccf);
  487. QueueChannel channel = new QueueChannel();
  488. adapter.setOutputChannel(channel);
  489. assertTrue(latch.await(10, TimeUnit.SECONDS));
  490. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  491. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  492. Message<?> mOut = channel.receive(10000);
  493. assertNotNull(mOut);
  494. assertEquals("Reply1", mOut.getPayload());
  495. mOut = channel.receive(10000);
  496. assertNotNull(mOut);
  497. assertEquals("Reply2", mOut.getPayload());
  498. done.set(true);
  499. ccf.stop();
  500. }
  501. @Test
  502. public void testNioSerial() throws Exception {
  503. final int port = SocketUtils.findAvailableServerSocket();
  504. final CountDownLatch latch = new CountDownLatch(1);
  505. final AtomicBoolean done = new AtomicBoolean();
  506. Executors.newSingleThreadExecutor().execute(new Runnable() {
  507. public void run() {
  508. try {
  509. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  510. latch.countDown();
  511. Socket socket = server.accept();
  512. int i = 0;
  513. while (true) {
  514. ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
  515. ois.readObject();
  516. ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
  517. oos.writeObject("Reply" + (++i));
  518. }
  519. } catch (Exception e) {
  520. if (!done.get()) {
  521. e.printStackTrace();
  522. }
  523. }
  524. }
  525. });
  526. AbstractConnectionFactory ccf = new TcpNioClientConnectionFactory("localhost", port);
  527. ccf.setSerializer(new DefaultSerializer());
  528. ccf.setDeserializer(new DefaultDeserializer());
  529. ccf.setSoTimeout(10000);
  530. ccf.start();
  531. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  532. handler.setConnectionFactory(ccf);
  533. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  534. adapter.setConnectionFactory(ccf);
  535. QueueChannel channel = new QueueChannel();
  536. adapter.setOutputChannel(channel);
  537. assertTrue(latch.await(10, TimeUnit.SECONDS));
  538. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  539. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  540. Set<String> results = new HashSet<String>();
  541. Message<?> mOut = channel.receive(10000);
  542. assertNotNull(mOut);
  543. results.add((String) mOut.getPayload());
  544. mOut = channel.receive(10000);
  545. assertNotNull(mOut);
  546. results.add((String) mOut.getPayload());
  547. assertTrue(results.remove("Reply1"));
  548. assertTrue(results.remove("Reply2"));
  549. done.set(true);
  550. ccf.stop();
  551. }
  552. @Test
  553. public void testNetSingleUseNoInbound() throws Exception {
  554. final int port = SocketUtils.findAvailableServerSocket();
  555. final CountDownLatch latch = new CountDownLatch(1);
  556. final Semaphore semaphore = new Semaphore(0);
  557. final AtomicBoolean done = new AtomicBoolean();
  558. Executors.newSingleThreadExecutor().execute(new Runnable() {
  559. public void run() {
  560. try {
  561. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  562. latch.countDown();
  563. for (int i = 0; i < 2; i++) {
  564. Socket socket = server.accept();
  565. semaphore.release();
  566. byte[] b = new byte[6];
  567. readFully(socket.getInputStream(), b);
  568. semaphore.release();
  569. socket.close();
  570. }
  571. server.close();
  572. } catch (Exception e) {
  573. if (!done.get()) {
  574. e.printStackTrace();
  575. }
  576. }
  577. }
  578. });
  579. AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
  580. ByteArrayCrLfSerializer serializer = new ByteArrayCrLfSerializer();
  581. ccf.setSerializer(serializer);
  582. ccf.setDeserializer(serializer);
  583. ccf.setSoTimeout(10000);
  584. ccf.start();
  585. ccf.setSingleUse(true);
  586. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  587. handler.setConnectionFactory(ccf);
  588. assertTrue(latch.await(10, TimeUnit.SECONDS));
  589. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  590. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  591. assertTrue(semaphore.tryAcquire(4, 10000, TimeUnit.MILLISECONDS));
  592. done.set(true);
  593. ccf.stop();
  594. }
  595. @Test
  596. public void testNioSingleUseNoInbound() throws Exception {
  597. final int port = SocketUtils.findAvailableServerSocket();
  598. final CountDownLatch latch = new CountDownLatch(1);
  599. final Semaphore semaphore = new Semaphore(0);
  600. final AtomicBoolean done = new AtomicBoolean();
  601. Executors.newSingleThreadExecutor().execute(new Runnable() {
  602. public void run() {
  603. try {
  604. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  605. latch.countDown();
  606. for (int i = 0; i < 2; i++) {
  607. Socket socket = server.accept();
  608. semaphore.release();
  609. byte[] b = new byte[8];
  610. readFully(socket.getInputStream(), b);
  611. semaphore.release();
  612. socket.close();
  613. }
  614. server.close();
  615. } catch (Exception e) {
  616. if (!done.get()) {
  617. e.printStackTrace();
  618. }
  619. }
  620. }
  621. });
  622. AbstractConnectionFactory ccf = new TcpNioClientConnectionFactory("localhost", port);
  623. ByteArrayCrLfSerializer serializer = new ByteArrayCrLfSerializer();
  624. ccf.setSerializer(serializer);
  625. ccf.setDeserializer(serializer);
  626. ccf.setSoTimeout(5000);
  627. ccf.start();
  628. ccf.setSingleUse(true);
  629. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  630. handler.setConnectionFactory(ccf);
  631. assertTrue(latch.await(10, TimeUnit.SECONDS));
  632. handler.handleMessage(MessageBuilder.withPayload("Test.1").build());
  633. handler.handleMessage(MessageBuilder.withPayload("Test.2").build());
  634. assertTrue(semaphore.tryAcquire(4, 10000, TimeUnit.MILLISECONDS));
  635. done.set(true);
  636. ccf.stop();
  637. }
  638. @Test
  639. public void testNetSingleUseWithInbound() throws Exception {
  640. final int port = SocketUtils.findAvailableServerSocket();
  641. final CountDownLatch latch = new CountDownLatch(1);
  642. final Semaphore semaphore = new Semaphore(0);
  643. final AtomicBoolean done = new AtomicBoolean();
  644. Executors.newSingleThreadExecutor().execute(new Runnable() {
  645. public void run() {
  646. try {
  647. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  648. latch.countDown();
  649. for (int i = 1; i < 3; i++) {
  650. Socket socket = server.accept();
  651. semaphore.release();
  652. byte[] b = new byte[6];
  653. readFully(socket.getInputStream(), b);
  654. b = ("Reply" + i + "\r\n").getBytes();
  655. socket.getOutputStream().write(b);
  656. socket.close();
  657. }
  658. server.close();
  659. } catch (Exception e) {
  660. if (!done.get()) {
  661. e.printStackTrace();
  662. }
  663. }
  664. }
  665. });
  666. AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
  667. ByteArrayCrLfSerializer serializer = new ByteArrayCrLfSerializer();
  668. ccf.setSerializer(serializer);
  669. ccf.setDeserializer(serializer);
  670. ccf.setSoTimeout(10000);
  671. ccf.start();
  672. ccf.setSingleUse(true);
  673. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  674. handler.setConnectionFactory(ccf);
  675. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  676. adapter.setConnectionFactory(ccf);
  677. QueueChannel channel = new QueueChannel();
  678. adapter.setOutputChannel(channel);
  679. assertTrue(latch.await(10, TimeUnit.SECONDS));
  680. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  681. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  682. assertTrue(semaphore.tryAcquire(2, 10000, TimeUnit.MILLISECONDS));
  683. Set<String> replies = new HashSet<String>();
  684. for (int i = 0; i < 2; i++) {
  685. Message<?> mOut = channel.receive(10000);
  686. assertNotNull(mOut);
  687. replies.add(new String((byte[])mOut.getPayload()));
  688. }
  689. assertTrue(replies.remove("Reply1"));
  690. assertTrue(replies.remove("Reply2"));
  691. done.set(true);
  692. ccf.stop();
  693. }
  694. @Test
  695. public void testNioSingleUseWithInbound() throws Exception {
  696. final int port = SocketUtils.findAvailableServerSocket();
  697. final CountDownLatch latch = new CountDownLatch(1);
  698. final Semaphore semaphore = new Semaphore(0);
  699. final AtomicBoolean done = new AtomicBoolean();
  700. Executors.newSingleThreadExecutor().execute(new Runnable() {
  701. public void run() {
  702. try {
  703. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  704. latch.countDown();
  705. for (int i = 1; i < 3; i++) {
  706. Socket socket = server.accept();
  707. semaphore.release();
  708. byte[] b = new byte[6];
  709. readFully(socket.getInputStream(), b);
  710. b = ("Reply" + i + "\r\n").getBytes();
  711. socket.getOutputStream().write(b);
  712. socket.close();
  713. }
  714. server.close();
  715. } catch (Exception e) {
  716. if (!done.get()) {
  717. e.printStackTrace();
  718. }
  719. }
  720. }
  721. });
  722. AbstractConnectionFactory ccf = new TcpNioClientConnectionFactory("localhost", port);
  723. ByteArrayCrLfSerializer serializer = new ByteArrayCrLfSerializer();
  724. ccf.setSerializer(serializer);
  725. ccf.setDeserializer(serializer);
  726. ccf.setSoTimeout(10000);
  727. ccf.start();
  728. ccf.setSingleUse(true);
  729. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  730. handler.setConnectionFactory(ccf);
  731. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  732. adapter.setConnectionFactory(ccf);
  733. QueueChannel channel = new QueueChannel();
  734. adapter.setOutputChannel(channel);
  735. assertTrue(latch.await(10, TimeUnit.SECONDS));
  736. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  737. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  738. assertTrue(semaphore.tryAcquire(2, 10000, TimeUnit.MILLISECONDS));
  739. Set<String> replies = new HashSet<String>();
  740. for (int i = 0; i < 2; i++) {
  741. Message<?> mOut = channel.receive(10000);
  742. assertNotNull(mOut);
  743. replies.add(new String((byte[])mOut.getPayload()));
  744. }
  745. assertTrue(replies.remove("Reply1"));
  746. assertTrue(replies.remove("Reply2"));
  747. done.set(true);
  748. ccf.stop();
  749. }
  750. @Test
  751. public void testNioSingleUseWithInboundMany() throws Exception {
  752. final int port = SocketUtils.findAvailableServerSocket();
  753. final CountDownLatch latch = new CountDownLatch(1);
  754. final Semaphore semaphore = new Semaphore(0);
  755. final AtomicBoolean done = new AtomicBoolean();
  756. final List<Socket> serverSockets = new ArrayList<Socket>();
  757. Executors.newSingleThreadExecutor().execute(new Runnable() {
  758. public void run() {
  759. try {
  760. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port, 100);
  761. latch.countDown();
  762. for (int i = 0; i < 100; i++) {
  763. Socket socket = server.accept();
  764. serverSockets.add(socket);
  765. semaphore.release();
  766. byte[] b = new byte[9];
  767. readFully(socket.getInputStream(), b);
  768. b = ("Reply" + i + "\r\n").getBytes();
  769. socket.getOutputStream().write(b);
  770. socket.close();
  771. }
  772. server.close();
  773. } catch (Exception e) {
  774. if (!done.get()) {
  775. e.printStackTrace();
  776. }
  777. }
  778. }
  779. });
  780. AbstractConnectionFactory ccf = new TcpNioClientConnectionFactory("localhost", port);
  781. ByteArrayCrLfSerializer serializer = new ByteArrayCrLfSerializer();
  782. ccf.setSerializer(serializer);
  783. ccf.setDeserializer(serializer);
  784. ccf.setSoTimeout(10000);
  785. ccf.setSingleUse(true);
  786. ccf.setTaskExecutor(Executors.newFixedThreadPool(100));
  787. ccf.start();
  788. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  789. handler.setConnectionFactory(ccf);
  790. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  791. adapter.setConnectionFactory(ccf);
  792. QueueChannel channel = new QueueChannel();
  793. adapter.setOutputChannel(channel);
  794. assertTrue(latch.await(10, TimeUnit.SECONDS));
  795. int i = 0;
  796. try {
  797. for (i = 100; i < 200; i++) {
  798. handler.handleMessage(MessageBuilder.withPayload("Test" + i).build());
  799. }
  800. } catch (Exception e) {
  801. e.printStackTrace();
  802. fail("Exception at " + i);
  803. }
  804. assertTrue(semaphore.tryAcquire(100, 20000, TimeUnit.MILLISECONDS));
  805. Set<String> replies = new HashSet<String>();
  806. for (i = 100; i < 200; i++) {
  807. Message<?> mOut = channel.receive(20000);
  808. assertNotNull(mOut);
  809. replies.add(new String((byte[])mOut.getPayload()));
  810. }
  811. for (i = 0; i < 100; i++) {
  812. assertTrue("Reply" + i + " missing", replies.remove("Reply" + i));
  813. }
  814. done.set(true);
  815. ccf.stop();
  816. }
  817. @Test
  818. public void testNetNegotiate() throws Exception {
  819. final int port = SocketUtils.findAvailableServerSocket();
  820. final CountDownLatch latch = new CountDownLatch(1);
  821. final AtomicBoolean done = new AtomicBoolean();
  822. Executors.newSingleThreadExecutor().execute(new Runnable() {
  823. public void run() {
  824. try {
  825. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  826. latch.countDown();
  827. Socket socket = server.accept();
  828. int i = 0;
  829. while (true) {
  830. ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
  831. Object in = null;
  832. ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
  833. if (i == 0) {
  834. in = ois.readObject();
  835. logger.debug("read object: " + in);
  836. oos.writeObject("world!");
  837. ois = new ObjectInputStream(socket.getInputStream());
  838. oos = new ObjectOutputStream(socket.getOutputStream());
  839. in = ois.readObject();
  840. logger.debug("read object: " + in);
  841. oos.writeObject("world!");
  842. ois = new ObjectInputStream(socket.getInputStream());
  843. oos = new ObjectOutputStream(socket.getOutputStream());
  844. }
  845. in = ois.readObject();
  846. oos.writeObject("Reply" + (++i));
  847. }
  848. }
  849. catch (Exception e) {
  850. if (!done.get()) {
  851. e.printStackTrace();
  852. }
  853. }
  854. }
  855. });
  856. AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
  857. ccf.setSerializer(new DefaultSerializer());
  858. ccf.setDeserializer(new DefaultDeserializer());
  859. ccf.setSoTimeout(10000);
  860. TcpConnectionInterceptorFactoryChain fc = new TcpConnectionInterceptorFactoryChain();
  861. fc.setInterceptors(new TcpConnectionInterceptorFactory[]
  862. {new HelloWorldInterceptorFactory(),
  863. new HelloWorldInterceptorFactory()});
  864. ccf.setInterceptorFactoryChain(fc);
  865. ccf.start();
  866. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  867. handler.setConnectionFactory(ccf);
  868. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  869. adapter.setConnectionFactory(ccf);
  870. QueueChannel channel = new QueueChannel();
  871. adapter.setOutputChannel(channel);
  872. assertTrue(latch.await(10, TimeUnit.SECONDS));
  873. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  874. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  875. Message<?> mOut = channel.receive(10000);
  876. assertNotNull(mOut);
  877. assertEquals("Reply1", mOut.getPayload());
  878. mOut = channel.receive(10000);
  879. assertNotNull(mOut);
  880. assertEquals("Reply2", mOut.getPayload());
  881. done.set(true);
  882. ccf.stop();
  883. }
  884. @Test
  885. public void testNioNegotiate() throws Exception {
  886. final int port = SocketUtils.findAvailableServerSocket();
  887. final CountDownLatch latch = new CountDownLatch(1);
  888. final AtomicBoolean done = new AtomicBoolean();
  889. Executors.newSingleThreadExecutor().execute(new Runnable() {
  890. public void run() {
  891. try {
  892. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  893. latch.countDown();
  894. Socket socket = server.accept();
  895. int i = 100;
  896. while (true) {
  897. ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
  898. Object in;
  899. ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
  900. if (i == 100) {
  901. in = ois.readObject();
  902. logger.debug("read object: " + in);
  903. oos.writeObject("world!");
  904. ois = new ObjectInputStream(socket.getInputStream());
  905. oos = new ObjectOutputStream(socket.getOutputStream());
  906. Thread.sleep(500);
  907. }
  908. in = ois.readObject();
  909. oos.writeObject("Reply" + (i++));
  910. }
  911. } catch (Exception e) {
  912. if (!done.get()) {
  913. e.printStackTrace();
  914. }
  915. }
  916. }
  917. });
  918. AbstractConnectionFactory ccf = new TcpNioClientConnectionFactory("localhost", port);
  919. ccf.setSerializer(new DefaultSerializer());
  920. ccf.setDeserializer(new DefaultDeserializer());
  921. ccf.setSoTimeout(10000);
  922. TcpConnectionInterceptorFactoryChain fc = new TcpConnectionInterceptorFactoryChain();
  923. fc.setInterceptors(new TcpConnectionInterceptorFactory[] {new HelloWorldInterceptorFactory()});
  924. ccf.setInterceptorFactoryChain(fc);
  925. ccf.start();
  926. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  927. handler.setConnectionFactory(ccf);
  928. TcpReceivingChannelAdapter adapter = new TcpReceivingChannelAdapter();
  929. adapter.setConnectionFactory(ccf);
  930. QueueChannel channel = new QueueChannel();
  931. adapter.setOutputChannel(channel);
  932. assertTrue(latch.await(10, TimeUnit.SECONDS));
  933. for (int i = 0; i < 1000; i++) {
  934. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  935. }
  936. Set<String> results = new TreeSet<String>();
  937. for (int i = 0; i < 1000; i++) {
  938. Message<?> mOut = channel.receive(10000);
  939. assertNotNull(mOut);
  940. results.add((String) mOut.getPayload());
  941. }
  942. logger.debug("results: " + results);
  943. for (int i = 100; i < 1100; i++) {
  944. assertTrue("Missing Reply" + i, results.remove("Reply" + i));
  945. }
  946. done.set(true);
  947. ccf.stop();
  948. }
  949. @Test
  950. public void testNetNegotiateSingleNoListen() throws Exception {
  951. final int port = SocketUtils.findAvailableServerSocket();
  952. final CountDownLatch latch = new CountDownLatch(1);
  953. final AtomicBoolean done = new AtomicBoolean();
  954. Executors.newSingleThreadExecutor().execute(new Runnable() {
  955. public void run() {
  956. try {
  957. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  958. latch.countDown();
  959. Socket socket = server.accept();
  960. int i = 0;
  961. ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
  962. Object in = null;
  963. ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
  964. if (i == 0) {
  965. in = ois.readObject();
  966. logger.debug("read object: " + in);
  967. oos.writeObject("world!");
  968. ois = new ObjectInputStream(socket.getInputStream());
  969. oos = new ObjectOutputStream(socket.getOutputStream());
  970. in = ois.readObject();
  971. logger.debug("read object: " + in);
  972. oos.writeObject("world!");
  973. ois = new ObjectInputStream(socket.getInputStream());
  974. oos = new ObjectOutputStream(socket.getOutputStream());
  975. }
  976. in = ois.readObject();
  977. oos.writeObject("Reply" + (++i));
  978. socket.close();
  979. server.close();
  980. }
  981. catch (Exception e) {
  982. if (!done.get()) {
  983. e.printStackTrace();
  984. }
  985. }
  986. }
  987. });
  988. AbstractConnectionFactory ccf = new TcpNetClientConnectionFactory("localhost", port);
  989. ccf.setSerializer(new DefaultSerializer());
  990. ccf.setDeserializer(new DefaultDeserializer());
  991. ccf.setSoTimeout(10000);
  992. TcpConnectionInterceptorFactoryChain fc = new TcpConnectionInterceptorFactoryChain();
  993. fc.setInterceptors(new TcpConnectionInterceptorFactory[]
  994. {new HelloWorldInterceptorFactory(),
  995. new HelloWorldInterceptorFactory()});
  996. ccf.setInterceptorFactoryChain(fc);
  997. ccf.setSingleUse(true);
  998. ccf.start();
  999. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  1000. handler.setConnectionFactory(ccf);
  1001. assertTrue(latch.await(10, TimeUnit.SECONDS));
  1002. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  1003. done.set(true);
  1004. ccf.stop();
  1005. }
  1006. @Test
  1007. public void testNioNegotiateSingleNoListen() throws Exception {
  1008. final int port = SocketUtils.findAvailableServerSocket();
  1009. final CountDownLatch latch = new CountDownLatch(1);
  1010. final AtomicBoolean done = new AtomicBoolean();
  1011. Executors.newSingleThreadExecutor().execute(new Runnable() {
  1012. public void run() {
  1013. int i = 0;
  1014. try {
  1015. ServerSocket server = ServerSocketFactory.getDefault().createServerSocket(port);
  1016. latch.countDown();
  1017. Socket socket = server.accept();
  1018. ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
  1019. Object in = null;
  1020. ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
  1021. if (i == 0) {
  1022. in = ois.readObject();
  1023. logger.debug("read object: " + in);
  1024. oos.writeObject("world!");
  1025. ois = new ObjectInputStream(socket.getInputStream());
  1026. oos = new ObjectOutputStream(socket.getOutputStream());
  1027. in = ois.readObject();
  1028. logger.debug("read object: " + in);
  1029. oos.writeObject("world!");
  1030. ois = new ObjectInputStream(socket.getInputStream());
  1031. oos = new ObjectOutputStream(socket.getOutputStream());
  1032. }
  1033. in = ois.readObject();
  1034. oos.writeObject("Reply" + (++i));
  1035. socket.close();
  1036. server.close();
  1037. } catch (Exception e) {
  1038. if (i == 0) {
  1039. e.printStackTrace();
  1040. }
  1041. }
  1042. }
  1043. });
  1044. AbstractConnectionFactory ccf = new TcpNioClientConnectionFactory("localhost", port);
  1045. ccf.setSerializer(new DefaultSerializer());
  1046. ccf.setDeserializer(new DefaultDeserializer());
  1047. ccf.setSoTimeout(10000);
  1048. TcpConnectionInterceptorFactoryChain fc = new TcpConnectionInterceptorFactoryChain();
  1049. fc.setInterceptors(new TcpConnectionInterceptorFactory[]
  1050. {new HelloWorldInterceptorFactory(),
  1051. new HelloWorldInterceptorFactory()});
  1052. ccf.setInterceptorFactoryChain(fc);
  1053. ccf.setSingleUse(true);
  1054. ccf.start();
  1055. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  1056. handler.setConnectionFactory(ccf);
  1057. assertTrue(latch.await(10, TimeUnit.SECONDS));
  1058. handler.handleMessage(MessageBuilder.withPayload("Test").build());
  1059. done.set(true);
  1060. ccf.stop();
  1061. }
  1062. @Test
  1063. public void testOutboundChannelAdapterWithinChain() throws Exception {
  1064. ApplicationContext ctx = new ClassPathXmlApplicationContext(
  1065. "TcpOutboundChannelAdapterWithinChainTests-context.xml", this.getClass());
  1066. AbstractServerConnectionFactory scf = ctx.getBean(AbstractServerConnectionFactory.class);
  1067. TestingUtilities.waitListening(scf, null);
  1068. MessageChannel channelAdapterWithinChain = ctx.getBean("tcpOutboundChannelAdapterWithinChain", MessageChannel.class);
  1069. PollableChannel inbound = ctx.getBean("inbound", PollableChannel.class);
  1070. String testPayload = "Hello, world!";
  1071. channelAdapterWithinChain.send(new GenericMessage<String>(testPayload));
  1072. Message<?> m = inbound.receive(1000);
  1073. assertNotNull(m);
  1074. assertEquals(testPayload, new String((byte[]) m.getPayload()));
  1075. }
  1076. @Test
  1077. public void testConnectionException() throws Exception {
  1078. TcpSendingMessageHandler handler = new TcpSendingMessageHandler();
  1079. AbstractConnectionFactory mockCcf = mock(AbstractClientConnectionFactory.class);
  1080. Mockito.doAnswer(new Answer<Object>() {
  1081. public Object answer(InvocationOnMock invocation) throws Throwable {
  1082. throw new SocketException("Failed to connect");
  1083. }
  1084. }).when(mockCcf).getConnection();
  1085. handler.setConnectionFactory(mockCcf);
  1086. try {
  1087. handler.handleMessage(new GenericMessage<String>("foo"));
  1088. fail("Expected exception");
  1089. }
  1090. catch (Exception e) {
  1091. assertTrue(e instanceof MessagingException);
  1092. assertTrue(e.getCause() != null);
  1093. assertTrue(e.getCause() instanceof SocketException);
  1094. assertEquals("Failed to connect", e.getCause().getMessage());
  1095. }
  1096. }
  1097. }