review.fuel-infra Code Review - packages/trusty/mysql-wsrep-5.6.git/blob

   1 /*
   2  *  Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; version 2 of the License.
   7  *
   8  *  This program is distributed in the hope that it will be useful,
   9  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *  GNU General Public License for more details.
  12  *
  13  *  You should have received a copy of the GNU General Public License
  14  *  along with this program; if not, write to the Free Software
  15  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
  16 */
  17
  18 package testsuite.clusterj;
  19
  20 import java.util.Arrays;
  21 import java.util.List;
  22 import java.util.Properties;
  23
  24 import testsuite.clusterj.model.Employee;
  25
  26 import com.mysql.clusterj.ClusterJFatalUserException;
  27 import com.mysql.clusterj.ClusterJHelper;
  28 import com.mysql.clusterj.Constants;
  29 import com.mysql.clusterj.Session;
  30 import com.mysql.clusterj.SessionFactory;
  31 import com.mysql.clusterj.core.SessionFactoryImpl;
  32
  33
  34 public class ConnectionPoolTest extends AbstractClusterJTest {
  35
  36     @Override
  37     public boolean getDebug() {
  38         return false;
  39     }
  40
  41     protected boolean runSpecificNodeIdTests() {
  42         return false;
  43     }
  44
  45     @Override
  46     public void localSetUp() {
  47         loadProperties();
  48         // close the existing session factory because it uses one of the cluster connection (api) nodes
  49         if (sessionFactory != null) {
  50             sessionFactory.close();
  51             sessionFactory = null;
  52         }
  53     }
  54
  55     public void testNoPooling() {
  56         Properties modifiedProperties = new Properties();
  57         modifiedProperties.putAll(props);
  58         SessionFactory sessionFactory1 = null;
  59         SessionFactory sessionFactory2 = null;
  60
  61         // with connection.pool.size set to 1 each session factory should be the same
  62         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_SIZE, 1);
  63         sessionFactory1 = ClusterJHelper.getSessionFactory(modifiedProperties);
  64         sessionFactory2 = ClusterJHelper.getSessionFactory(modifiedProperties);
  65         sessionFactory1.close();
  66         sessionFactory2.close();
  67         errorIfNotEqual("With connection pooling, SessionFactory1 should be the same object as SessionFactory2",
  68                 true, sessionFactory1 == sessionFactory2);
  69
  70         // with connection.pool.size set to 0 each session factory should be unique
  71         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_SIZE, 0);
  72         sessionFactory1 = ClusterJHelper.getSessionFactory(modifiedProperties);
  73         sessionFactory2 = ClusterJHelper.getSessionFactory(modifiedProperties);
  74         try {
  75             SessionFactory sessionFactory3 = ClusterJHelper.getSessionFactory(modifiedProperties);
  76             sessionFactory3.close();
  77         } catch (ClusterJFatalUserException ex) {
  78             // good catch
  79         }
  80         sessionFactory1.close();
  81         sessionFactory2.close();
  82         errorIfNotEqual("With no connection pooling, SessionFactory1 should not be the same object as SessionFactory2",
  83                 false, sessionFactory1 == sessionFactory2);
  84
  85         failOnError();
  86     }
  87
  88     public void testConnectionPoolSize() {
  89         Properties modifiedProperties = new Properties();
  90         modifiedProperties.putAll(props);
  91         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_SIZE, 2);
  92         checkConnectionPoolSize2("testConnectionPoolSize", modifiedProperties);
  93         failOnError();
  94     }
  95
  96     public void testConnectionPoolSizeAndNodeIds() {
  97         if (!runSpecificNodeIdTests()) {
  98             return;
  99         }
 100         Properties modifiedProperties = new Properties();
 101         modifiedProperties.putAll(props);
 102         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_SIZE, 2);
 103         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_NODEIDS, "4;5");
 104         checkConnectionPoolSize2("testConnectionPoolSizeAndNodeIds", modifiedProperties);
 105         failOnError();
 106     }
 107
 108     public void testConnectionNodeIds() {
 109         if (!runSpecificNodeIdTests()) {
 110             return;
 111         }
 112         Properties modifiedProperties = new Properties();
 113         modifiedProperties.putAll(props);
 114         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_NODEIDS, "4,5");
 115         checkConnectionPoolSize2("testConnectionNodeIds", modifiedProperties);
 116         failOnError();
 117     }
 118
 119     public void testConnectionSingleNodeIdAndConnectionPoolSize() {
 120         if (!runSpecificNodeIdTests()) {
 121             return;
 122         }
 123         Properties modifiedProperties = new Properties();
 124         modifiedProperties.putAll(props);
 125         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_SIZE, 2);
 126         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_NODEIDS, "4");
 127         checkConnectionPoolSize2("testConnectionNodeIds", modifiedProperties);
 128         failOnError();
 129     }
 130
 131     private void checkConnectionPoolSize2(String where, Properties modifiedProperties) {
 132         SessionFactory sessionFactory1 = null;
 133         SessionFactory sessionFactory2 = null;
 134         SessionFactory sessionFactory3 = null;
 135         sessionFactory1 = ClusterJHelper.getSessionFactory(modifiedProperties);
 136         sessionFactory2 = ClusterJHelper.getSessionFactory(modifiedProperties);
 137         sessionFactory3 = ClusterJHelper.getSessionFactory(modifiedProperties);
 138         errorIfNotEqual(where + " SessionFactory1 should be the same object as SessionFactory2", true,
 139                 sessionFactory1 == sessionFactory2);
 140         errorIfNotEqual(where + " SessionFactory1 should be the same object as SessionFactory3", true,
 141                 sessionFactory1 == sessionFactory3);
 142         Session session1 = sessionFactory1.getSession();
 143         Employee e1 = session1.find(Employee.class, 0);
 144         checkSessions(where + " after get session1", sessionFactory1, new Integer[] {1, 0});
 145         Session session2 = sessionFactory1.getSession();
 146         Employee e2 = session2.find(Employee.class, 0);
 147         checkSessions(where + " after get session2", sessionFactory1, new Integer[] {1, 1});
 148         Session session3 = sessionFactory1.getSession();
 149         checkSessions(where + " nafter get session3", sessionFactory1, new Integer[] {2, 1});
 150         Session session4 = sessionFactory1.getSession();
 151         checkSessions(where + " after get session4", sessionFactory1, new Integer[] {2, 2});
 152         Session session5 = sessionFactory1.getSession();
 153         checkSessions(where + " after get session5", sessionFactory1, new Integer[] {3, 2});
 154         Session session6 = sessionFactory1.getSession();
 155         checkSessions(where + " after get session6", sessionFactory1, new Integer[] {3, 3});
 156
 157         session1.close();
 158         checkSessions(where + " after close session1", sessionFactory1, new Integer[] {2, 3});
 159         session4.close();
 160         checkSessions(where + " after close session4", sessionFactory1, new Integer[] {2, 2});
 161         session5.close();
 162         checkSessions(where + " after close session5", sessionFactory1, new Integer[] {1, 2});
 163         Session session7 = sessionFactory1.getSession();
 164         checkSessions(where + " after get session7", sessionFactory1, new Integer[] {2, 2});
 165
 166         session2.close();
 167         session3.close();
 168         session6.close();
 169         session7.close();
 170         sessionFactory1.close();
 171     }
 172
 173     public void testNegativeMismatchConnectionPoolSizeAndConnectionPoolNodeids() {
 174         Properties modifiedProperties = new Properties();
 175         modifiedProperties.putAll(props);
 176         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_SIZE, 3);
 177         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_NODEIDS, "4\t5");
 178         try {
 179             ClusterJHelper.getSessionFactory(modifiedProperties);
 180         } catch (ClusterJFatalUserException ex) {
 181             if (getDebug()) ex.printStackTrace();
 182             // good catch
 183             String expected = "4\t5";
 184             if (!ex.getMessage().contains(expected)) {
 185                 error("Mismatch error message should contain " + expected);
 186             }
 187         }
 188         failOnError();
 189     }
 190
 191     public void testNegativeConnectionPoolNodeidsFormatError() {
 192         Properties modifiedProperties = new Properties();
 193         modifiedProperties.putAll(props);
 194         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_SIZE, 2);
 195         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_NODEIDS, "7 t");
 196         try {
 197             ClusterJHelper.getSessionFactory(modifiedProperties);
 198         } catch (ClusterJFatalUserException ex) {
 199             if (getDebug()) ex.printStackTrace();
 200             // good catch
 201             String expected = "NumberFormatException";
 202             if (!ex.getMessage().contains(expected)) {
 203                 error("Mismatch error message '" + ex.getMessage() + "' should contain '" + expected + '"');
 204             }
 205         }
 206         failOnError();
 207     }
 208
 209     public void testNegativeConnectionPoolIllegalNodeids() {
 210         Properties modifiedProperties = new Properties();
 211         modifiedProperties.putAll(props);
 212         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_NODEIDS, "256");
 213         try {
 214             ClusterJHelper.getSessionFactory(modifiedProperties);
 215         } catch (ClusterJFatalUserException ex) {
 216             if (getDebug()) ex.printStackTrace();
 217             // good catch
 218             String expected = "illegal";
 219             if (!ex.getMessage().contains(expected)) {
 220                 error("Mismatch error message '" + ex.getMessage() + "' should contain '" + expected + '"');
 221             }
 222         }
 223         failOnError();
 224     }
 225
 226     public void testNegativeConnectionPoolNoNodeId() {
 227         if (!runSpecificNodeIdTests()) {
 228             return;
 229         }
 230         Properties modifiedProperties = new Properties();
 231         modifiedProperties.putAll(props);
 232         modifiedProperties.put(Constants.PROPERTY_CONNECTION_POOL_NODEIDS, "48");
 233         try {
 234             ClusterJHelper.getSessionFactory(modifiedProperties);
 235         } catch (ClusterJFatalUserException ex) {
 236             if (getDebug()) ex.printStackTrace();
 237             // good catch
 238             String expected = "No node defined";
 239             if (!ex.getMessage().contains(expected)) {
 240                 error("Mismatch error message '" + ex.getMessage() + "' should contain '" + expected + '"');
 241             }
 242         }
 243         failOnError();
 244     }
 245
 246     private void checkSessions(String where, SessionFactory sessionFactory1, Integer[] expected) {
 247         SessionFactoryImpl sessionFactoryImpl = (SessionFactoryImpl)sessionFactory1;
 248         List<Integer> connectionCounts = sessionFactoryImpl.getConnectionPoolSessionCounts();
 249         if (expected.length != connectionCounts.size()) {
 250             error(where + " wrong number of connections in pool\n"
 251                     + "Expected: " + Arrays.toString(expected)
 252                     + " Actual: " + connectionCounts);
 253             return;
 254         }
 255         int i = 0;
 256         for (Integer connectionCount: connectionCounts) {
 257             if (getDebug()) System.out.println("Connection " + i + " has " + connectionCount + " sessions.");
 258             if (i >= expected.length) break;
 259             errorIfNotEqual(where + " wrong count on connection " + i, expected[i], connectionCount);
 260             i++;
 261         }
 262         if (getDebug()) System.out.println();
 263     }
 264 }