PageRenderTime 43ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/astyanax-test/src/test/java/com/netflix/astyanax/connectionpool/impl/BaseConnectionPoolTest.java

http://github.com/Netflix/astyanax
Java | 430 lines | 320 code | 67 blank | 43 comment | 6 complexity | 12c87c56130e61f03e4db6d785278e6b MD5 | raw file
  1. /*******************************************************************************
  2. * Copyright 2011 Netflix
  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.netflix.astyanax.connectionpool.impl;
  17. import java.util.ArrayList;
  18. import java.util.List;
  19. import com.google.common.collect.Lists;
  20. import com.netflix.astyanax.connectionpool.ConnectionPool;
  21. import com.netflix.astyanax.connectionpool.ConnectionPoolConfiguration;
  22. import com.netflix.astyanax.connectionpool.Host;
  23. import com.netflix.astyanax.connectionpool.Operation;
  24. import com.netflix.astyanax.connectionpool.OperationResult;
  25. import com.netflix.astyanax.connectionpool.exceptions.ConnectionException;
  26. import com.netflix.astyanax.connectionpool.exceptions.NoAvailableHostsException;
  27. import com.netflix.astyanax.connectionpool.exceptions.OperationException;
  28. import com.netflix.astyanax.connectionpool.exceptions.PoolTimeoutException;
  29. import com.netflix.astyanax.connectionpool.exceptions.TransportException;
  30. import com.netflix.astyanax.retry.ConstantBackoff;
  31. import com.netflix.astyanax.retry.RetryPolicy;
  32. import com.netflix.astyanax.retry.RunOnce;
  33. import com.netflix.astyanax.test.TestClient;
  34. import com.netflix.astyanax.test.TestConnectionFactory;
  35. import com.netflix.astyanax.test.TestConstants;
  36. import com.netflix.astyanax.test.TestHostType;
  37. import com.netflix.astyanax.test.TestOperation;
  38. import org.apache.log4j.Logger;
  39. import org.junit.Assert;
  40. import org.junit.Ignore;
  41. import org.junit.Test;
  42. import com.netflix.astyanax.connectionpool.ConnectionContext;
  43. @Ignore
  44. public abstract class BaseConnectionPoolTest {
  45. private static Logger LOG = Logger
  46. .getLogger(RoundRobinConnectionPoolImplTest.class);
  47. private static Operation<TestClient, String> dummyOperation = new TestOperation();
  48. // private static ConnectionPoolConfigurationImpl config;
  49. // @BeforeClass
  50. public static void setup() {
  51. // config = new
  52. // ConnectionPoolConfigurationImpl(MockConstants.CLUSTER_NAME,
  53. // MockConstants.KEYSPACE_NAME);
  54. // config.setConnectionPoolFactory(ConnectionPoolType.ROUND_ROBIN);
  55. // config.setMaxTimeoutWhenExhausted(0);
  56. // config.setMaxFailoverCount(-1);
  57. }
  58. protected abstract ConnectionPool<TestClient> createPool();
  59. @Test
  60. public void testAll() {
  61. ConnectionPool<TestClient> pool = createPool();
  62. for (int i = 0; i < 5; i++) {
  63. pool.addHost(
  64. new Host("127.0." + i + ".0", TestHostType.GOOD_FAST
  65. .ordinal()), true);
  66. // pool.addHost(new Host("127.0." + i + ".1",
  67. // MockHostType.LOST_CONNECTION.ordinal()));
  68. // pool.addHost(new Host("127.0." + i + ".1",
  69. // MockHostType.CONNECT_TIMEOUT.ordinal()));
  70. // pool.addHost(new Host("127.0." + i + ".1",
  71. // MockHostType.ALWAYS_DOWN.ordinal()));
  72. // pool.addHost(new Host("127.0." + i + ".1",
  73. // MockHostType.THRASHING_TIMEOUT.ordinal()));
  74. // pool.addHost(new Host("127.0." + i + ".1",
  75. // MockHostType.CONNECT_BAD_REQUEST_EXCEPTION.ordinal()));
  76. }
  77. for (int i = 0; i < 10; i++) {
  78. try {
  79. OperationResult<String> result = pool.executeWithFailover(
  80. dummyOperation, RunOnce.get());
  81. LOG.info(result.getHost());
  82. } catch (OperationException e) {
  83. LOG.info(e.getMessage());
  84. Assert.fail(e.getMessage());
  85. } catch (ConnectionException e) {
  86. LOG.info(e.getCause());
  87. Assert.fail(e.getMessage());
  88. }
  89. }
  90. }
  91. @Test
  92. public void testRollingRestart() {
  93. ConnectionPool<TestClient> pool = createPool();
  94. List<Host> hosts = new ArrayList<Host>();
  95. for (int i = 0; i < 5; i++) {
  96. Host host = new Host("127.0." + i + ".0",
  97. TestHostType.GOOD_FAST.ordinal());
  98. pool.addHost(host, true);
  99. hosts.add(host);
  100. }
  101. for (int i = 0; i < 5; i++) {
  102. try {
  103. OperationResult<String> result = pool.executeWithFailover(
  104. new TestOperation() {
  105. @Override
  106. public String execute(TestClient client, ConnectionContext context)
  107. throws ConnectionException,
  108. OperationException {
  109. throw new TransportException("He's dead jim");
  110. }
  111. }, RunOnce.get());
  112. Assert.fail();
  113. } catch (Exception e) {
  114. }
  115. }
  116. }
  117. @Test
  118. public void testAlwaysDown() {
  119. ConnectionPool<TestClient> pool = createPool();
  120. pool.addHost(new Host("127.0.0.1", TestHostType.ALWAYS_DOWN.ordinal()),
  121. true);
  122. try {
  123. pool.executeWithFailover(dummyOperation, RunOnce.get());
  124. Assert.fail();
  125. } catch (OperationException e) {
  126. LOG.info(e.getMessage());
  127. } catch (ConnectionException e) {
  128. LOG.info(e.getMessage());
  129. }
  130. }
  131. @Test
  132. public void testConnectTimeout() {
  133. ConnectionPool<TestClient> pool = createPool();
  134. pool.addHost(
  135. new Host("127.0.0.1", TestHostType.CONNECT_TIMEOUT.ordinal()),
  136. true);
  137. try {
  138. pool.executeWithFailover(dummyOperation, RunOnce.get());
  139. Assert.fail();
  140. } catch (OperationException e) {
  141. LOG.info(e.getMessage());
  142. } catch (ConnectionException e) {
  143. LOG.info(e.getMessage());
  144. }
  145. }
  146. @Test
  147. public void testOperationTimeoutTimeout() {
  148. ConnectionPool<TestClient> pool = createPool();
  149. pool.addHost(
  150. new Host("127.0.0.1", TestHostType.OPERATION_TIMEOUT.ordinal()),
  151. true);
  152. try {
  153. pool.executeWithFailover(dummyOperation, RunOnce.get());
  154. Assert.fail();
  155. } catch (OperationException e) {
  156. LOG.info(e.getMessage());
  157. } catch (ConnectionException e) {
  158. LOG.info(e.getMessage());
  159. }
  160. }
  161. @Test
  162. public void testTimeoutTimeout() {
  163. ConnectionPool<TestClient> pool = createPool();
  164. pool.addHost(
  165. new Host("127.0.0.1", TestHostType.SOCKET_TIMEOUT.ordinal()),
  166. true);
  167. try {
  168. pool.executeWithFailover(dummyOperation, RunOnce.get());
  169. Assert.fail();
  170. } catch (OperationException e) {
  171. LOG.info(e.getMessage());
  172. } catch (ConnectionException e) {
  173. LOG.info(e.getMessage());
  174. }
  175. }
  176. @Test
  177. public void testConnectBadRequest() {
  178. ConnectionPool<TestClient> pool = createPool();
  179. pool.addHost(new Host("127.0.0.1",
  180. TestHostType.CONNECT_BAD_REQUEST_EXCEPTION.ordinal()), true);
  181. try {
  182. pool.executeWithFailover(dummyOperation, RunOnce.get());
  183. Assert.fail();
  184. } catch (OperationException e) {
  185. LOG.info(e.getMessage());
  186. } catch (ConnectionException e) {
  187. LOG.info(e.getMessage());
  188. }
  189. }
  190. @Test
  191. public void testThrashingTimeout() {
  192. ConnectionPool<TestClient> pool = createPool();
  193. pool.addHost(
  194. new Host("127.0.0.1", TestHostType.THRASHING_TIMEOUT.ordinal()),
  195. true);
  196. for (int i = 0; i < 10; i++) {
  197. try {
  198. think(1);
  199. pool.executeWithFailover(dummyOperation, RunOnce.get());
  200. } catch (OperationException e) {
  201. LOG.info(e.getMessage());
  202. } catch (ConnectionException e) {
  203. LOG.info(e.getMessage());
  204. }
  205. }
  206. }
  207. @Test
  208. public void testGoodFast() {
  209. ConnectionPool<TestClient> pool = createPool();
  210. pool.addHost(new Host("127.0.0.1", TestHostType.GOOD_SLOW.ordinal()),
  211. true);
  212. for (int i = 0; i < 10; i++) {
  213. try {
  214. pool.executeWithFailover(dummyOperation, RunOnce.get());
  215. LOG.info("Success");
  216. } catch (OperationException e) {
  217. LOG.info(e.getMessage());
  218. } catch (ConnectionException e) {
  219. LOG.info(e.getMessage());
  220. }
  221. }
  222. }
  223. @Test
  224. public void testDefaultConfig() {
  225. ConnectionPoolConfiguration config = new ConnectionPoolConfigurationImpl(
  226. TestConstants.CLUSTER_NAME + "_" + TestConstants.KEYSPACE_NAME);
  227. CountingConnectionPoolMonitor monitor = new CountingConnectionPoolMonitor();
  228. try {
  229. ConnectionPool<TestClient> pool = new RoundRobinConnectionPoolImpl<TestClient>(
  230. config, new TestConnectionFactory(config, monitor), monitor);
  231. } catch (Exception e) {
  232. e.printStackTrace();
  233. Assert.fail(e.getMessage());
  234. }
  235. }
  236. @Test
  237. public void testRestartedCluster() {
  238. ConnectionPool<TestClient> pool = createPool();
  239. Host host1 = new Host("127.0.0.1", TestHostType.GOOD_FAST.ordinal());
  240. List<Host> ring1 = Lists.newArrayList(host1);
  241. Host host2 = new Host("127.0.0.2", TestHostType.GOOD_FAST.ordinal());
  242. List<Host> ring2 = Lists.newArrayList(host2);
  243. List<Host> ring3 = Lists.newArrayList();
  244. pool.setHosts(ring1);
  245. Assert.assertTrue (pool.hasHost (host1));
  246. Assert.assertTrue (pool.isHostUp(host1));
  247. Assert.assertFalse(pool.hasHost (host2));
  248. Assert.assertFalse(pool.isHostUp(host2));
  249. try {
  250. OperationResult<String> result = pool.executeWithFailover(
  251. dummyOperation, RunOnce.get());
  252. Assert.assertEquals(host1, result.getHost());
  253. } catch (Exception e) {
  254. e.printStackTrace();
  255. Assert.fail(e.getMessage());
  256. }
  257. pool.setHosts(ring3);
  258. Assert.assertFalse(pool.hasHost(host1));
  259. Assert.assertFalse(pool.hasHost(host2));
  260. try {
  261. OperationResult<String> result = pool.executeWithFailover(
  262. dummyOperation, RunOnce.get());
  263. result = pool.executeWithFailover(dummyOperation, RunOnce.get());
  264. Assert.fail();
  265. } catch (NoAvailableHostsException e) {
  266. } catch (Exception e) {
  267. e.printStackTrace();
  268. Assert.fail(e.getMessage());
  269. }
  270. pool.setHosts(ring2);
  271. Assert.assertTrue(pool.hasHost(host2));
  272. Assert.assertTrue(pool.isHostUp(host2));
  273. Assert.assertFalse(pool.hasHost(host1));
  274. Assert.assertFalse(pool.isHostUp(host1));
  275. try {
  276. OperationResult<String> result = pool.executeWithFailover(
  277. dummyOperation, RunOnce.get());
  278. Assert.assertEquals(host2, result.getHost());
  279. } catch (Exception e) {
  280. e.printStackTrace();
  281. Assert.fail(e.getMessage());
  282. }
  283. }
  284. @Test
  285. @Ignore
  286. public void testAddHostThatIsDown() {
  287. /*
  288. * ConnectionPoolConfigurationImpl config = new
  289. * ConnectionPoolConfigurationImpl(MockConstants.CLUSTER_NAME,
  290. * MockConstants.KEYSPACE_NAME); config.setRetryBackoffStrategy(new
  291. * FixedRetryBackoffStrategy(100, 0));
  292. *
  293. * ConnectionPool<MockClient> pool = new
  294. * RoundRobinConnectionPoolImpl<MockClient>(config, new
  295. * MockConnectionFactory(config));
  296. */
  297. ConnectionPool<TestClient> pool = createPool();
  298. Host host1 = new Host("127.0.0.1",
  299. TestHostType.CONNECT_FAIL_FIRST.ordinal());
  300. List<Host> ring1 = Lists.newArrayList(host1);
  301. OperationResult<String> result;
  302. pool.setHosts(ring1);
  303. Assert.assertTrue(pool.hasHost(host1));
  304. Assert.assertTrue(pool.isHostUp(host1));
  305. try {
  306. pool.executeWithFailover(dummyOperation, RunOnce.get());
  307. Assert.fail();
  308. } catch (PoolTimeoutException e) {
  309. } catch (ConnectionException e) {
  310. e.printStackTrace();
  311. Assert.fail(e.getMessage());
  312. }
  313. think(500);
  314. Assert.assertTrue(pool.hasHost(host1));
  315. Assert.assertTrue(pool.isHostUp(host1));
  316. try {
  317. pool.executeWithFailover(dummyOperation, RunOnce.get());
  318. } catch (Exception e) {
  319. e.printStackTrace();
  320. Assert.fail(e.getMessage());
  321. }
  322. }
  323. @Test
  324. @Ignore
  325. public void testConnectionAborted() {
  326. ConnectionPool<TestClient> pool = createPool();
  327. Host host = new Host("127.0.0.1",
  328. TestHostType.ABORTED_CONNECTION.ordinal());
  329. pool.addHost(host, true);
  330. OperationResult<String> result;
  331. try {
  332. result = pool.executeWithFailover(dummyOperation, RunOnce.get());
  333. Assert.fail();
  334. } catch (ConnectionException e) {
  335. }
  336. }
  337. @Test
  338. public void testRetryEmptyPool() {
  339. ConnectionPool<TestClient> pool = createPool();
  340. RetryPolicy retry = new RunOnce();
  341. try {
  342. pool.executeWithFailover(dummyOperation, retry);
  343. Assert.fail();
  344. } catch (ConnectionException e) {
  345. Assert.assertEquals(1, retry.getAttemptCount());
  346. LOG.error(e);
  347. }
  348. retry = new ConstantBackoff(1, 10);
  349. try {
  350. pool.executeWithFailover(dummyOperation, retry);
  351. Assert.fail();
  352. } catch (ConnectionException e) {
  353. Assert.assertEquals(10, retry.getAttemptCount());
  354. LOG.info(e);
  355. }
  356. }
  357. protected void think(long timeout) {
  358. try {
  359. Thread.sleep(timeout);
  360. } catch (InterruptedException e) {
  361. }
  362. }
  363. }