/rpc/src/test/java/com/navercorp/pinpoint/rpc/stream/StreamChannelManagerTest.java

https://gitlab.com/hansol6566/pinpoint · Java · 359 lines · 244 code · 96 blank · 19 comment · 15 complexity · 068281451d000f3dd0292a022761de83 MD5 · raw file

  1. /*
  2. * Copyright 2014 NAVER Corp.
  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 com.navercorp.pinpoint.rpc.stream;
  17. import com.navercorp.pinpoint.rpc.*;
  18. import com.navercorp.pinpoint.rpc.client.PinpointClient;
  19. import com.navercorp.pinpoint.rpc.client.PinpointClientFactory;
  20. import com.navercorp.pinpoint.rpc.client.SimpleMessageListener;
  21. import com.navercorp.pinpoint.rpc.packet.stream.StreamClosePacket;
  22. import com.navercorp.pinpoint.rpc.packet.stream.StreamCode;
  23. import com.navercorp.pinpoint.rpc.packet.stream.StreamCreateFailPacket;
  24. import com.navercorp.pinpoint.rpc.packet.stream.StreamCreatePacket;
  25. import com.navercorp.pinpoint.rpc.server.PinpointServer;
  26. import com.navercorp.pinpoint.rpc.server.PinpointServerAcceptor;
  27. import com.navercorp.pinpoint.rpc.server.ServerMessageListener;
  28. import com.navercorp.pinpoint.rpc.server.SimpleServerMessageListener;
  29. import com.navercorp.pinpoint.rpc.util.PinpointRPCTestUtils;
  30. import org.junit.Assert;
  31. import org.junit.BeforeClass;
  32. import org.junit.Test;
  33. import org.springframework.util.SocketUtils;
  34. import java.io.IOException;
  35. import java.util.List;
  36. import java.util.concurrent.CopyOnWriteArrayList;
  37. public class StreamChannelManagerTest {
  38. private static int bindPort;
  39. @BeforeClass
  40. public static void setUp() throws IOException {
  41. bindPort = SocketUtils.findAvailableTcpPort();
  42. }
  43. // Client to Server Stream
  44. @Test
  45. public void streamSuccessTest1() throws IOException, InterruptedException {
  46. SimpleStreamBO bo = new SimpleStreamBO();
  47. PinpointServerAcceptor serverAcceptor = createServerFactory(SimpleServerMessageListener.DUPLEX_ECHO_INSTANCE, new ServerListener(bo));
  48. serverAcceptor.bind("localhost", bindPort);
  49. PinpointClientFactory clientFactory = createSocketFactory();
  50. try {
  51. PinpointClient client = clientFactory.connect("127.0.0.1", bindPort);
  52. RecordedStreamChannelMessageListener clientListener = new RecordedStreamChannelMessageListener(4);
  53. ClientStreamChannelContext clientContext = client.openStream(new byte[0], clientListener);
  54. int sendCount = 4;
  55. for (int i = 0; i < sendCount; i++) {
  56. sendRandomBytes(bo);
  57. }
  58. clientListener.getLatch().await();
  59. Assert.assertEquals(sendCount, clientListener.getReceivedMessage().size());
  60. clientContext.getStreamChannel().close();
  61. PinpointRPCTestUtils.close(client);
  62. } finally {
  63. clientFactory.release();
  64. PinpointRPCTestUtils.close(serverAcceptor);
  65. }
  66. }
  67. // Client to Server Stream
  68. @Test
  69. public void streamSuccessTest2() throws IOException, InterruptedException {
  70. SimpleStreamBO bo = new SimpleStreamBO();
  71. PinpointServerAcceptor serverAcceptor = createServerFactory(SimpleServerMessageListener.DUPLEX_ECHO_INSTANCE, new ServerListener(bo));
  72. serverAcceptor.bind("localhost", bindPort);
  73. PinpointClientFactory clientFactory = createSocketFactory();
  74. try {
  75. PinpointClient client = clientFactory.connect("127.0.0.1", bindPort);
  76. RecordedStreamChannelMessageListener clientListener = new RecordedStreamChannelMessageListener(4);
  77. ClientStreamChannelContext clientContext = client.openStream(new byte[0], clientListener);
  78. RecordedStreamChannelMessageListener clientListener2 = new RecordedStreamChannelMessageListener(8);
  79. ClientStreamChannelContext clientContext2 = client.openStream(new byte[0], clientListener2);
  80. int sendCount = 4;
  81. for (int i = 0; i < sendCount; i++) {
  82. sendRandomBytes(bo);
  83. }
  84. clientListener.getLatch().await();
  85. Assert.assertEquals(sendCount, clientListener.getReceivedMessage().size());
  86. clientContext.getStreamChannel().close();
  87. sendCount = 4;
  88. for (int i = 0; i < sendCount; i++) {
  89. sendRandomBytes(bo);
  90. }
  91. clientListener2.getLatch().await();
  92. Assert.assertEquals(sendCount, clientListener.getReceivedMessage().size());
  93. Assert.assertEquals(8, clientListener2.getReceivedMessage().size());
  94. clientContext2.getStreamChannel().close();
  95. PinpointRPCTestUtils.close(client);
  96. } finally {
  97. clientFactory.release();
  98. PinpointRPCTestUtils.close(serverAcceptor);
  99. }
  100. }
  101. @Test
  102. public void streamSuccessTest3() throws IOException, InterruptedException {
  103. PinpointServerAcceptor serverAcceptor = createServerFactory(SimpleServerMessageListener.DUPLEX_ECHO_INSTANCE, null);
  104. serverAcceptor.bind("localhost", bindPort);
  105. SimpleStreamBO bo = new SimpleStreamBO();
  106. PinpointClientFactory clientFactory = createSocketFactory(SimpleMessageListener.INSTANCE, new ServerListener(bo));
  107. try {
  108. PinpointClient client = clientFactory.connect("127.0.0.1", bindPort);
  109. Thread.sleep(100);
  110. List<PinpointSocket> writableServerList = serverAcceptor.getWritableSocketList();
  111. Assert.assertEquals(1, writableServerList.size());
  112. PinpointSocket writableServer = writableServerList.get(0);
  113. RecordedStreamChannelMessageListener clientListener = new RecordedStreamChannelMessageListener(4);
  114. if (writableServer instanceof PinpointServer) {
  115. ClientStreamChannelContext clientContext = ((PinpointServer)writableServer).openStream(new byte[0], clientListener);
  116. int sendCount = 4;
  117. for (int i = 0; i < sendCount; i++) {
  118. sendRandomBytes(bo);
  119. }
  120. clientListener.getLatch().await();
  121. Assert.assertEquals(sendCount, clientListener.getReceivedMessage().size());
  122. clientContext.getStreamChannel().close();
  123. } else {
  124. Assert.fail();
  125. }
  126. PinpointRPCTestUtils.close(client);
  127. } finally {
  128. clientFactory.release();
  129. PinpointRPCTestUtils.close(serverAcceptor);
  130. }
  131. }
  132. @Test
  133. public void streamClosedTest1() throws IOException, InterruptedException {
  134. PinpointServerAcceptor serverAcceptor = createServerFactory(SimpleServerMessageListener.DUPLEX_ECHO_INSTANCE, null);
  135. serverAcceptor.bind("localhost", bindPort);
  136. PinpointClientFactory clientFactory = createSocketFactory();
  137. try {
  138. PinpointClient client = clientFactory.connect("127.0.0.1", bindPort);
  139. RecordedStreamChannelMessageListener clientListener = new RecordedStreamChannelMessageListener(4);
  140. ClientStreamChannelContext clientContext = client.openStream(new byte[0], clientListener);
  141. StreamCreateFailPacket createFailPacket = clientContext.getCreateFailPacket();
  142. if (createFailPacket == null) {
  143. Assert.fail();
  144. }
  145. clientContext.getStreamChannel().close();
  146. PinpointRPCTestUtils.close(client);
  147. } finally {
  148. clientFactory.release();
  149. PinpointRPCTestUtils.close(serverAcceptor);
  150. }
  151. }
  152. @Test
  153. public void streamClosedTest2() throws IOException, InterruptedException {
  154. SimpleStreamBO bo = new SimpleStreamBO();
  155. PinpointServerAcceptor serverAcceptor = createServerFactory(SimpleServerMessageListener.DUPLEX_ECHO_INSTANCE, new ServerListener(bo));
  156. serverAcceptor.bind("localhost", bindPort);
  157. PinpointClientFactory clientFactory = createSocketFactory();
  158. PinpointClient client = null;
  159. try {
  160. client = clientFactory.connect("127.0.0.1", bindPort);
  161. RecordedStreamChannelMessageListener clientListener = new RecordedStreamChannelMessageListener(4);
  162. ClientStreamChannelContext clientContext = client.openStream(new byte[0], clientListener);
  163. Assert.assertEquals(1, bo.getStreamChannelContextSize());
  164. clientContext.getStreamChannel().close();
  165. Thread.sleep(100);
  166. Assert.assertEquals(0, bo.getStreamChannelContextSize());
  167. } finally {
  168. PinpointRPCTestUtils.close(client);
  169. clientFactory.release();
  170. PinpointRPCTestUtils.close(serverAcceptor);
  171. }
  172. }
  173. // ServerSocket to Client Stream
  174. // ServerStreamChannel first close.
  175. @Test(expected = PinpointSocketException.class)
  176. public void streamClosedTest3() throws IOException, InterruptedException {
  177. PinpointServerAcceptor serverAcceptor = createServerFactory(SimpleServerMessageListener.DUPLEX_ECHO_INSTANCE, null);
  178. serverAcceptor.bind("localhost", bindPort);
  179. SimpleStreamBO bo = new SimpleStreamBO();
  180. PinpointClientFactory clientFactory = createSocketFactory(SimpleMessageListener.INSTANCE, new ServerListener(bo));
  181. PinpointClient client = clientFactory.connect("127.0.0.1", bindPort);
  182. try {
  183. Thread.sleep(100);
  184. List<PinpointSocket> writableServerList = serverAcceptor.getWritableSocketList();
  185. Assert.assertEquals(1, writableServerList.size());
  186. PinpointSocket writableServer = writableServerList.get(0);
  187. if (writableServer instanceof PinpointServer) {
  188. RecordedStreamChannelMessageListener clientListener = new RecordedStreamChannelMessageListener(4);
  189. ClientStreamChannelContext clientContext = ((PinpointServer)writableServer).openStream(new byte[0], clientListener);
  190. StreamChannelContext streamChannelContext = client.findStreamChannel(2);
  191. streamChannelContext.getStreamChannel().close();
  192. sendRandomBytes(bo);
  193. Thread.sleep(100);
  194. clientContext.getStreamChannel().close();
  195. } else {
  196. Assert.fail();
  197. }
  198. } finally {
  199. PinpointRPCTestUtils.close(client);
  200. clientFactory.release();
  201. PinpointRPCTestUtils.close(serverAcceptor);
  202. }
  203. }
  204. private PinpointServerAcceptor createServerFactory(ServerMessageListener severMessageListener, ServerStreamChannelMessageListener serverStreamChannelMessageListener) {
  205. PinpointServerAcceptor serverAcceptor = new PinpointServerAcceptor();
  206. if (severMessageListener != null) {
  207. serverAcceptor.setMessageListener(severMessageListener);
  208. }
  209. if (serverStreamChannelMessageListener != null) {
  210. serverAcceptor.setServerStreamChannelMessageListener(serverStreamChannelMessageListener);
  211. }
  212. return serverAcceptor;
  213. }
  214. private PinpointClientFactory createSocketFactory() {
  215. PinpointClientFactory clientFactory = new PinpointClientFactory();
  216. return clientFactory;
  217. }
  218. private PinpointClientFactory createSocketFactory(MessageListener messageListener, ServerStreamChannelMessageListener serverStreamChannelMessageListener) {
  219. PinpointClientFactory clientFactory = new PinpointClientFactory();
  220. clientFactory.setMessageListener(messageListener);
  221. clientFactory.setServerStreamChannelMessageListener(serverStreamChannelMessageListener);
  222. return clientFactory;
  223. }
  224. private void sendRandomBytes(SimpleStreamBO bo) {
  225. byte[] openBytes = TestByteUtils.createRandomByte(30);
  226. bo.sendResponse(openBytes);
  227. }
  228. class ServerListener implements ServerStreamChannelMessageListener {
  229. private final SimpleStreamBO bo;
  230. public ServerListener(SimpleStreamBO bo) {
  231. this.bo = bo;
  232. }
  233. @Override
  234. public StreamCode handleStreamCreate(ServerStreamChannelContext streamChannelContext, StreamCreatePacket packet) {
  235. bo.addServerStreamChannelContext(streamChannelContext);
  236. return StreamCode.OK;
  237. }
  238. @Override
  239. public void handleStreamClose(ServerStreamChannelContext streamChannelContext, StreamClosePacket packet) {
  240. bo.removeServerStreamChannelContext(streamChannelContext);
  241. }
  242. }
  243. class SimpleStreamBO {
  244. private final List<ServerStreamChannelContext> serverStreamChannelContextList;
  245. public SimpleStreamBO() {
  246. serverStreamChannelContextList = new CopyOnWriteArrayList<ServerStreamChannelContext>();
  247. }
  248. public void addServerStreamChannelContext(ServerStreamChannelContext context) {
  249. serverStreamChannelContextList.add(context);
  250. }
  251. public void removeServerStreamChannelContext(ServerStreamChannelContext context) {
  252. serverStreamChannelContextList.remove(context);
  253. }
  254. void sendResponse(byte[] data) {
  255. for (ServerStreamChannelContext context : serverStreamChannelContextList) {
  256. context.getStreamChannel().sendData(data);
  257. }
  258. }
  259. int getStreamChannelContextSize() {
  260. return serverStreamChannelContextList.size();
  261. }
  262. }
  263. }