/**
   * Tests fake exceptions, connection should be shutdown if the scheduler was marked as going down.
   * Same test except just used to check for a spurious interrupted exception (should be logged).
   *
   * @throws SQLException
   * @throws InterruptedException
   * @throws NoSuchFieldException
   * @throws SecurityException
   * @throws IllegalAccessException
   * @throws IllegalArgumentException
   */
  @Test
  public void testExceptionOnCloseConnection()
      throws SQLException, InterruptedException, SecurityException, NoSuchFieldException,
          IllegalArgumentException, IllegalAccessException {
    ArrayBlockingQueue<ConnectionHandle> fakeFreeConnections =
        new ArrayBlockingQueue<ConnectionHandle>(1);
    fakeFreeConnections.add(mockConnection);

    config.setIdleConnectionTestPeriod(1);
    expect(mockPool.getConfig()).andReturn(config).anyTimes();
    expect(mockConnectionPartition.getFreeConnections()).andReturn(fakeFreeConnections).anyTimes();
    expect(mockConnectionPartition.getMinConnections()).andReturn(10).once();
    expect(mockConnection.isPossiblyBroken()).andReturn(false);
    expect(mockConnection.getConnectionLastUsed()).andReturn(0L);
    expect(mockPool.isConnectionHandleAlive((ConnectionHandle) anyObject()))
        .andReturn(false)
        .anyTimes();

    // connection should be closed
    mockConnection.internalClose();
    expectLastCall().andThrow(new SQLException());

    replay(mockPool, mockConnection, mockConnectionPartition, mockExecutor, mockLogger);
    this.testClass = new ConnectionTesterThread(mockConnectionPartition, mockExecutor, mockPool);
    Field loggerField = this.testClass.getClass().getDeclaredField("logger");
    loggerField.setAccessible(true);
    loggerField.set(this.testClass, mockLogger);
    this.testClass.run();
    verify(mockPool, mockConnectionPartition, mockExecutor, mockConnection, mockLogger);
  }
  /**
   * Tests that a partition with expired connections should those connections killed off.
   *
   * @throws SQLException
   */
  @Test
  @SuppressWarnings({"unchecked", "rawtypes"})
  public void testConnectionExpired() throws SQLException {

    TransferQueue<ConnectionHandle> mockQueue = createNiceMock(TransferQueue.class);
    expect(mockConnectionPartition.getAvailableConnections()).andReturn(1);
    expect(mockConnectionPartition.getFreeConnections()).andReturn(mockQueue).anyTimes();
    ConnectionHandle mockConnectionExpired = createNiceMock(ConnectionHandle.class);
    ConnectionHandle mockConnection = createNiceMock(ConnectionHandle.class);
    expect(mockQueue.poll()).andReturn(mockConnectionExpired).once();

    expect(mockConnectionExpired.isExpired(anyLong())).andReturn(true).once();

    expect(mockExecutor.isShutdown()).andReturn(false).once();

    mockConnectionExpired.internalClose();
    expectLastCall().once();

    mockPool.postDestroyConnection(mockConnectionExpired);
    expectLastCall().once();

    expect(mockExecutor.schedule((Callable) anyObject(), anyLong(), (TimeUnit) anyObject()))
        .andReturn(null)
        .once();
    replay(
        mockQueue,
        mockExecutor,
        mockConnectionPartition,
        mockConnection,
        mockPool,
        mockConnectionExpired);
    testClass.run();
    verify(mockConnectionExpired);
  }
예제 #3
0
 /**
  * Establishes the session with the remote host.
  *
  * @param connectionHandle - {@link ConnectionHandle} associated with the remote host.
  * @param username - the username
  * @param password - password matching the username
  * @param bmcKey - the key that should be provided if the two-key authentication is enabled, null
  *     otherwise.
  * @throws ConnectionException when connection is in the state that does not allow to perform this
  *     operation.
  * @throws Exception when sending message to the managed system or initializing one of the
  *     cipherSuite's algorithms fails
  */
 public void openSession(
     ConnectionHandle connectionHandle, String username, String password, byte[] bmcKey)
     throws Exception {
   int tries = 0;
   boolean succeded = false;
   while (tries <= retries && !succeded) {
     try {
       ++tries;
       connectionManager.startSession(
           connectionHandle.getHandle(),
           connectionHandle.getCipherSuite(),
           connectionHandle.getPrivilegeLevel(),
           username,
           password,
           bmcKey);
       succeded = true;
     } catch (Exception e) {
       logger.warn("Failed to receive answer, cause:", e);
       if (tries > retries) {
         throw e;
       }
     }
   }
   return;
 }
  /**
   * Tests fake exceptions, connection should be shutdown if the scheduler was marked as going down.
   * Mostly for code coverage.
   *
   * @throws SQLException
   * @throws InterruptedException
   */
  @Test
  public void testInterruptedException() throws SQLException, InterruptedException {
    ArrayBlockingQueue<ConnectionHandle> fakeFreeConnections =
        new ArrayBlockingQueue<ConnectionHandle>(1);
    fakeFreeConnections.add(mockConnection);

    config.setIdleConnectionTestPeriod(1);
    expect(mockPool.getConfig()).andReturn(config).anyTimes();
    expect(mockConnectionPartition.getFreeConnections()).andReturn(fakeFreeConnections).anyTimes();
    expect(mockConnectionPartition.getMinConnections()).andReturn(10).once();
    expect(mockConnection.isPossiblyBroken()).andReturn(false);
    expect(mockConnection.getConnectionLastUsed()).andReturn(0L);
    expect(mockPool.isConnectionHandleAlive((ConnectionHandle) anyObject()))
        .andReturn(true)
        .anyTimes();
    expect(mockExecutor.isShutdown()).andReturn(true);
    mockPool.releaseInAnyFreePartition(
        (ConnectionHandle) anyObject(), (ConnectionPartition) anyObject());
    expectLastCall().andThrow(new InterruptedException());
    // connection should be closed
    mockConnection.internalClose();
    mockPool.postDestroyConnection(mockConnection);
    expectLastCall().once();

    replay(mockPool, mockConnection, mockConnectionPartition, mockExecutor);
    this.testClass = new ConnectionTesterThread(mockConnectionPartition, mockExecutor, mockPool);
    this.testClass.run();
    verify(mockPool, mockConnectionPartition, mockExecutor, mockConnection);
  }
  /**
   * Tests that a partition with expired connections should those connections killed off.
   *
   * @throws SQLException
   */
  @Test
  @SuppressWarnings("unchecked")
  public void testConnectionNotExpiredLifoMode() throws SQLException {

    LIFOQueue<ConnectionHandle> mockQueue = createNiceMock(LIFOQueue.class);
    expect(mockConnectionPartition.getAvailableConnections()).andReturn(1);
    expect(mockConnectionPartition.getFreeConnections()).andReturn(mockQueue).anyTimes();
    ConnectionHandle mockConnection = createNiceMock(ConnectionHandle.class);
    expect(mockQueue.poll()).andReturn(mockConnection).once();

    expect(mockConnection.isExpired(anyLong())).andReturn(false).once();

    expect(mockExecutor.isShutdown()).andReturn(false).once();

    expect(mockConnection.getOriginatingPartition()).andReturn(mockConnectionPartition).anyTimes();
    expect(mockQueue.offerLast(mockConnection)).andReturn(false).anyTimes();
    mockConnection.internalClose();

    replay(mockQueue, mockExecutor, mockConnectionPartition, mockConnection, mockPool);
    ConnectionMaxAgeThread testClass2 =
        new ConnectionMaxAgeThread(mockConnectionPartition, mockExecutor, mockPool, 5000, true);
    testClass2.run();

    verify(mockConnection, mockPool);
  }
예제 #6
0
  /**
   * Closing a connection handle should release that connection back in the pool and mark it as
   * closed.
   *
   * @throws SecurityException
   * @throws NoSuchFieldException
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws InvocationTargetException
   * @throws NoSuchMethodException
   * @throws SQLException
   */
  @SuppressWarnings("unchecked")
  @Test
  public void testInternalClose()
      throws SecurityException, NoSuchFieldException, IllegalArgumentException,
          IllegalAccessException, InvocationTargetException, NoSuchMethodException, SQLException {
    ConcurrentLinkedQueue<Statement> mockStatementHandles =
        createNiceMock(ConcurrentLinkedQueue.class);
    StatementHandle mockStatement = createNiceMock(StatementHandle.class);

    mockConnection.close();
    expectLastCall().once().andThrow(new SQLException()).once();

    Map<Connection, Reference<ConnectionHandle>> refs =
        new HashMap<Connection, Reference<ConnectionHandle>>();
    expect(mockPool.getFinalizableRefs()).andReturn(refs).anyTimes();
    FinalizableReferenceQueue finalizableRefQueue = new FinalizableReferenceQueue();

    expect(mockPool.getFinalizableRefQueue()).andReturn(finalizableRefQueue).anyTimes();
    expect(mockConnection.getPool()).andReturn(mockPool).anyTimes();

    replay(mockStatement, mockConnection, mockStatementHandles, mockPool);
    testClass.internalClose();
    try {
      testClass.internalClose(); // 2nd time should throw exception
      fail("Should have thrown an exception");
    } catch (Throwable t) {
      // do nothing.
    }

    verify(mockStatement, mockConnection, mockStatementHandles);
  }
  /** @throws SQLException */
  @Test
  public void testCloseConnectionWithException() throws SQLException {
    ConnectionHandle mockConnection = createNiceMock(ConnectionHandle.class);
    mockPool.postDestroyConnection(mockConnection);
    expectLastCall().once();

    mockConnection.internalClose();
    expectLastCall().andThrow(new SQLException());

    replay(mockConnection, mockPool);
    testClass.closeConnection(mockConnection);
    verify(mockConnection, mockPool);
  }
예제 #8
0
  /**
   * Test renewal of connection.
   *
   * @throws SecurityException
   * @throws NoSuchFieldException
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   */
  @Test
  public void testRenewConnection()
      throws SecurityException, NoSuchFieldException, IllegalArgumentException,
          IllegalAccessException {
    Field field = testClass.getClass().getDeclaredField("doubleCloseCheck");
    field.setAccessible(true);
    field.set(testClass, true);

    field = testClass.getClass().getDeclaredField("logicallyClosed");
    field.setAccessible(true);
    field.set(testClass, true);

    testClass.renewConnection();
    assertFalse(field.getBoolean(testClass));
  }
예제 #9
0
 /**
  * Sends the IPMI message to the remote host.
  *
  * @param connectionHandle - {@link ConnectionHandle} associated with the remote host.
  * @param request - {@link IpmiCommandCoder} containing the request to be sent
  * @return ID of the message that will be also attached to the response to pair request with
  *     response if queue was not full and message was sent, -1 if sending of the message failed.
  * @throws ConnectionException when connection is in the state that does not allow to perform this
  *     operation.
  * @throws Exception when sending message to the managed system or initializing one of the
  *     cipherSuite's algorithms fails
  */
 public int sendMessage(ConnectionHandle connectionHandle, IpmiCommandCoder request)
     throws Exception {
   int tries = 0;
   int tag = -1;
   while (tries <= retries && tag < 0) {
     try {
       ++tries;
       while (tag < 0) {
         tag =
             connectionManager
                 .getConnection(connectionHandle.getHandle())
                 .sendIpmiCommand(request);
         if (tag < 0) {
           Thread.sleep(10); // tag < 0 means that MessageQueue is
           // full so we need to wait and retry
         }
       }
       logger.debug("Sending message with tag " + tag + ", try " + tries);
     } catch (IllegalArgumentException e) {
       throw e;
     } catch (Exception e) {
       logger.warn("Failed to send message, cause:", e);
       if (tries > retries) {
         throw e;
       }
     }
   }
   return tag;
 }
  /** @throws SQLException */
  @Test
  public void testCloseConnectionWithExceptionCoverage() throws SQLException {
    ConnectionHandle mockConnection = createNiceMock(ConnectionHandle.class);
    mockPool.postDestroyConnection(mockConnection);
    expectLastCall().once();
    ConnectionMaxAgeThread.logger = null; // make it break.
    mockConnection.internalClose();
    expectLastCall().andThrow(new SQLException());

    replay(mockConnection, mockPool);
    try {
      testClass.closeConnection(mockConnection);
    } catch (Exception e) {
      // do nothing
    }
    verify(mockConnection, mockPool);
  }
예제 #11
0
  /**
   * Closing a connection handle should release that connection back in the pool and mark it as
   * closed.
   *
   * @throws SecurityException
   * @throws NoSuchFieldException
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws InvocationTargetException
   * @throws NoSuchMethodException
   * @throws SQLException
   */
  @Test
  public void testClose()
      throws SecurityException, NoSuchFieldException, IllegalArgumentException,
          IllegalAccessException, InvocationTargetException, NoSuchMethodException, SQLException {

    Field field = testClass.getClass().getDeclaredField("doubleCloseCheck");
    field.setAccessible(true);
    field.set(testClass, true);

    testClass.renewConnection();
    mockPool.releaseConnection((Connection) anyObject());
    expectLastCall().once().andThrow(new SQLException()).once();
    replay(mockPool);

    testClass.close();

    // logically mark the connection as closed
    field = testClass.getClass().getDeclaredField("logicallyClosed");

    field.setAccessible(true);
    Assert.assertTrue(field.getBoolean(testClass));
    assertTrue(testClass.isClosed());

    testClass.renewConnection();
    try {
      testClass.close(); // 2nd time should throw an exception
      fail("Should have thrown an exception");
    } catch (Throwable t) {
      // do nothing.
    }

    verify(mockPool);
  }
예제 #12
0
 /** Simple test. */
 @Test
 public void testIsConnectionHandleAlive() {
   // just make sure this is bounced off to the right place
   reset(mockPool);
   expect(mockPool.isConnectionHandleAlive(testClass)).andReturn(true).once();
   replay(mockPool);
   testClass.isConnectionAlive();
   verify(mockPool);
 }
  /** @throws SQLException */
  @Test
  @SuppressWarnings({"unchecked"})
  public void testExceptionsCase() throws SQLException {

    TransferQueue<ConnectionHandle> mockQueue = createNiceMock(TransferQueue.class);
    expect(mockConnectionPartition.getAvailableConnections()).andReturn(2);
    expect(mockConnectionPartition.getFreeConnections()).andReturn(mockQueue).anyTimes();
    ConnectionHandle mockConnectionException = createNiceMock(ConnectionHandle.class);
    expect(mockQueue.poll()).andReturn(mockConnectionException).times(2);
    expect(mockConnectionException.isExpired(anyLong()))
        .andThrow(new RuntimeException())
        .anyTimes();
    expect(mockExecutor.isShutdown()).andReturn(false).once().andReturn(true).once();

    replay(mockQueue, mockConnectionException, mockExecutor, mockConnectionPartition, mockPool);
    testClass.run();
    verify(mockExecutor, mockConnectionException);
  }
예제 #14
0
  /**
   * Test marking of possibly broken status.
   *
   * @throws SecurityException
   * @throws NoSuchFieldException
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   */
  @Test
  public void testMarkPossiblyBroken()
      throws SecurityException, NoSuchFieldException, IllegalArgumentException,
          IllegalAccessException {
    Field field = testClass.getClass().getDeclaredField("possiblyBroken");
    field.setAccessible(true);
    field.set(testClass, false);
    testClass.markPossiblyBroken(null);
    Assert.assertTrue(field.getBoolean(testClass));

    // Test that a db fatal error will lead to the pool being instructed to terminate all
    // connections (+ log)
    mockPool.terminateAllConnections();
    mockLogger.error((String) anyObject(), anyObject());
    replay(mockPool);
    testClass.markPossiblyBroken(new SQLException("test", "08001"));
    verify(mockPool);
  }
예제 #15
0
  /**
   * Tests that a connection that is marked broken is closed internally and that the partition is
   * marked as being able to create new connections.
   *
   * @throws SQLException
   */
  @Test
  public void testConnectionMarkedBroken() throws SQLException {
    ArrayBlockingQueue<ConnectionHandle> fakeFreeConnections =
        new ArrayBlockingQueue<ConnectionHandle>(1);
    fakeFreeConnections.add(mockConnection);

    expect(mockPool.getConfig()).andReturn(config).anyTimes();
    expect(mockConnectionPartition.getFreeConnections()).andReturn(fakeFreeConnections).anyTimes();
    expect(mockConnection.isPossiblyBroken()).andReturn(true);

    // connection should be closed
    mockConnection.internalClose();
    mockPool.postDestroyConnection(mockConnection);
    expectLastCall().once();
    replay(mockPool, mockConnection, mockConnectionPartition, mockExecutor);
    this.testClass = new ConnectionTesterThread(mockConnectionPartition, mockExecutor, mockPool);
    this.testClass.run();
    verify(mockPool, mockConnectionPartition, mockExecutor, mockConnection);
  }
예제 #16
0
  /**
   * Reset everything.
   *
   * @throws SecurityException
   * @throws NoSuchFieldException
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   */
  @Before
  public void before()
      throws SecurityException, NoSuchFieldException, IllegalArgumentException,
          IllegalAccessException {
    reset(mockConnection, mockPreparedStatementCache, mockPool, mockCallableStatementCache);

    Field field = testClass.getClass().getDeclaredField("logicallyClosed");
    field.setAccessible(true);
    field.set(testClass, false);
  }
예제 #17
0
 /**
  * Closes the session with the remote host if it is currently in open state.
  *
  * @param connectionHandle - {@link ConnectionHandle} associated with the remote host.
  * @throws ConnectionException when connection is in the state that does not allow to perform this
  *     operation.
  * @throws Exception when sending message to the managed system or initializing one of the
  *     cipherSuite's algorithms fails
  */
 public void closeSession(ConnectionHandle connectionHandle) throws Exception {
   if (!connectionManager.getConnection(connectionHandle.getHandle()).isSessionValid()) {
     return;
   }
   int tries = 0;
   boolean succeded = false;
   while (tries <= retries && !succeded) {
     try {
       ++tries;
       connectionManager.getConnection(connectionHandle.getHandle()).closeSession();
       succeded = true;
     } catch (Exception e) {
       logger.warn("Failed to receive answer, cause:", e);
       if (tries > retries) {
         throw e;
       }
     }
   }
   return;
 }
예제 #18
0
  // #ifdef JDK6
  @Test
  public void testSetClientInfo() {
    Properties prop = new Properties();
    try {
      mockConnection.setClientInfo(prop);
      replay(mockConnection);
      testClass.setClientInfo(prop);
      verify(mockConnection);

      reset(mockConnection);

      String name = "name";
      String value = "val";
      mockConnection.setClientInfo(name, value);
      replay(mockConnection);
      testClass.setClientInfo(name, value);
      verify(mockConnection);
    } catch (SQLClientInfoException e) {
      throw new RuntimeException(e);
    }
  }
예제 #19
0
  /**
   * Prepared statement tests.
   *
   * @throws SQLException
   * @throws SecurityException
   * @throws NoSuchFieldException
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   */
  @Test
  public void testPreparedStatement()
      throws SQLException, SecurityException, NoSuchFieldException, IllegalArgumentException,
          IllegalAccessException {
    BoneCP dsb = null;
    CommonTestUtils.logTestInfo("Tests that prepared statements are obtained from cache when set.");
    config.setMinConnectionsPerPartition(10);
    config.setMaxConnectionsPerPartition(20);
    config.setAcquireIncrement(5);
    config.setPartitionCount(1);
    config.setStatementsCacheSize(1);
    config.setLogStatementsEnabled(true);
    config.setStatementReleaseHelperThreads(0);
    dsb = new BoneCP(config);

    ConnectionHandle con = (ConnectionHandle) dsb.getConnection();
    Field preparedStatement = con.getClass().getDeclaredField("preparedStatementCache");
    preparedStatement.setAccessible(true);
    // switch to our mock
    preparedStatement.set(con, mockCache);
    expect(mockCache.get(isA(String.class))).andReturn(null);
    //		mockCache.put(isA(String.class), isA(PreparedStatement.class));

    replay(mockCache);
    Statement statement = con.prepareStatement(CommonTestUtils.TEST_QUERY);
    statement.close();
    verify(mockCache);

    reset(mockCache);
    expect(mockCache.get(isA(String.class))).andReturn(null);
    replay(mockCache);

    con.prepareStatement(CommonTestUtils.TEST_QUERY);
    statement.close();
    verify(mockCache);
    dsb.shutdown();
    statement.close();
    con.close();
    CommonTestUtils.logPass();
  }
예제 #20
0
  /**
   * Tests sendInitialSQL method.
   *
   * @throws SecurityException
   * @throws NoSuchFieldException
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws SQLException
   */
  @Test
  public void testSendInitialSQL()
      throws SecurityException, NoSuchFieldException, IllegalArgumentException,
          IllegalAccessException, SQLException {

    BoneCPConfig mockConfig = createNiceMock(BoneCPConfig.class);
    expect(mockPool.getConfig()).andReturn(mockConfig).anyTimes();

    expect(mockConfig.getInitSQL()).andReturn("test").anyTimes();
    testClass.setInternalConnection(mockConnection);

    Statement mockStatement = createNiceMock(Statement.class);
    ResultSet mockResultSet = createNiceMock(ResultSet.class);
    expect(mockConnection.createStatement()).andReturn(mockStatement).once();
    expect(mockStatement.executeQuery("test")).andReturn(mockResultSet).once();
    mockResultSet.close();
    expectLastCall().once();

    replay(mockConfig, mockPool, mockConnection, mockStatement, mockResultSet);
    testClass.sendInitSQL();
    verify(mockConfig, mockPool, mockConnection, mockStatement, mockResultSet);
  }
  /** @throws SQLException */
  @Test
  @SuppressWarnings("unchecked")
  public void testExceptionsCaseWherePutInPartitionFails() throws SQLException {

    TransferQueue<ConnectionHandle> mockQueue = createNiceMock(TransferQueue.class);
    expect(mockConnectionPartition.getAvailableConnections()).andReturn(1);
    expect(mockConnectionPartition.getFreeConnections()).andReturn(mockQueue).anyTimes();
    ConnectionHandle mockConnectionException = createNiceMock(ConnectionHandle.class);
    expect(mockQueue.poll()).andReturn(mockConnectionException).times(1);
    expect(mockConnectionException.isExpired(anyLong())).andReturn(false).anyTimes();
    expect(mockExecutor.isShutdown()).andReturn(false).anyTimes();
    mockPool.putConnectionBackInPartition(mockConnectionException);
    expectLastCall().andThrow(new SQLException()).once();

    // we should be able to reschedule
    expect(mockExecutor.schedule((Runnable) anyObject(), anyLong(), (TimeUnit) anyObject()))
        .andReturn(null)
        .once();

    replay(mockQueue, mockConnectionException, mockExecutor, mockConnectionPartition, mockPool);
    testClass.run();
    verify(mockExecutor, mockConnectionException);
  }
예제 #22
0
  /**
   * @throws SecurityException
   * @throws NoSuchFieldException
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws SQLException
   */
  @Test
  public void testDoubleClose()
      throws SecurityException, NoSuchFieldException, IllegalArgumentException,
          IllegalAccessException, SQLException {
    Field field = testClass.getClass().getDeclaredField("doubleCloseCheck");
    field.setAccessible(true);
    field.set(testClass, true);

    field = testClass.getClass().getDeclaredField("logicallyClosed");
    field.setAccessible(true);
    field.set(testClass, true);

    field = testClass.getClass().getDeclaredField("doubleCloseException");
    field.setAccessible(true);
    field.set(testClass, "fakeexception");
    mockLogger.error((String) anyObject(), anyObject());
    expectLastCall().once();

    mockPool.releaseConnection((Connection) anyObject());
    expectLastCall().once().andThrow(new SQLException()).once();
    replay(mockLogger, mockPool);

    testClass.close();
  }
예제 #23
0
  /**
   * Test for check closed routine.
   *
   * @throws SecurityException
   * @throws NoSuchFieldException
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws InvocationTargetException
   * @throws NoSuchMethodException
   */
  @Test
  public void testCheckClosed()
      throws SecurityException, NoSuchFieldException, IllegalArgumentException,
          IllegalAccessException, InvocationTargetException, NoSuchMethodException {

    testClass.renewConnection();

    // call the method (should not throw an exception)
    Method method = testClass.getClass().getDeclaredMethod("checkClosed");
    method.setAccessible(true);
    method.invoke(testClass);

    // logically mark the connection as closed
    Field field = testClass.getClass().getDeclaredField("logicallyClosed");

    field.setAccessible(true);
    field.set(testClass, true);
    try {
      method.invoke(testClass);
      fail("Should have thrown an exception");
    } catch (Throwable t) {
      // do nothing.
    }
  }
예제 #24
0
  /** Test for clear statement caches. */
  @Test
  public void testClearStatementCaches() {

    testClass.statementCachingEnabled = true;
    mockPreparedStatementCache.clear();
    expectLastCall().once();
    mockCallableStatementCache.clear();
    expectLastCall().once();

    replay(mockPreparedStatementCache, mockCallableStatementCache);
    testClass.clearStatementCaches(true);
    verify(mockPreparedStatementCache, mockCallableStatementCache);
    reset(mockPreparedStatementCache, mockCallableStatementCache);

    mockPool.closeConnectionWatch = true;
    mockPreparedStatementCache.checkForProperClosure();
    expectLastCall().once();
    mockCallableStatementCache.checkForProperClosure();
    expectLastCall().once();

    replay(mockPreparedStatementCache, mockCallableStatementCache);
    testClass.clearStatementCaches(false);
    verify(mockPreparedStatementCache, mockCallableStatementCache);
  }
예제 #25
0
 /**
  * Gets the authentication capabilities for the connection with the remote host.
  *
  * @param connectionHandle - {@link ConnectionHandle} associated with the host
  * @param cipherSuite - {@link CipherSuite} that will be used during the connection
  * @param requestedPrivilegeLevel - {@link PrivilegeLevel} that is requested for the session
  * @return - {@link GetChannelAuthenticationCapabilitiesResponseData}
  * @throws ConnectionException when connection is in the state that does not allow to perform this
  *     operation.
  * @throws Exception when sending message to the managed system fails
  */
 public GetChannelAuthenticationCapabilitiesResponseData getChannelAuthenticationCapabilities(
     ConnectionHandle connectionHandle,
     CipherSuite cipherSuite,
     PrivilegeLevel requestedPrivilegeLevel)
     throws Exception {
   int tries = 0;
   GetChannelAuthenticationCapabilitiesResponseData result = null;
   while (tries <= retries && result == null) {
     try {
       ++tries;
       result =
           connectionManager.getChannelAuthenticationCapabilities(
               connectionHandle.getHandle(), cipherSuite, requestedPrivilegeLevel);
       connectionHandle.setCipherSuite(cipherSuite);
       connectionHandle.setPrivilegeLevel(requestedPrivilegeLevel);
     } catch (Exception e) {
       logger.warn("Failed to receive answer, cause:", e);
       if (tries > retries) {
         throw e;
       }
     }
   }
   return result;
 }
예제 #26
0
 /**
  * Gets {@link CipherSuite}s available for the connection with the remote host.
  *
  * @param connectionHandle {@link ConnectionHandle} to the connection created before
  * @see #createConnection(InetAddress)
  * @return list of the {@link CipherSuite}s that are allowed during the connection
  * @throws Exception when sending message to the managed system fails
  */
 public List<CipherSuite> getAvailableCipherSuites(ConnectionHandle connectionHandle)
     throws Exception {
   int tries = 0;
   List<CipherSuite> result = null;
   while (tries <= retries && result == null) {
     try {
       ++tries;
       result = connectionManager.getAvailableCipherSuites(connectionHandle.getHandle());
     } catch (Exception e) {
       logger.warn("Failed to receive answer, cause:", e);
       if (tries > retries) {
         throw e;
       }
     }
   }
   return result;
 }
예제 #27
0
  /**
   * Mock setup.
   *
   * @throws Exception
   */
  @BeforeClass
  public static void setUp() throws Exception {
    config = CommonTestUtils.getConfigClone();
    mockConnection = createNiceMock(ConnectionHandle.class);
    mockPreparedStatementCache = createNiceMock(IStatementCache.class);
    mockCallableStatementCache = createNiceMock(IStatementCache.class);

    mockLogger = createNiceMock(Logger.class);
    makeThreadSafe(mockLogger, true);
    mockPool = createNiceMock(BoneCP.class);
    mockPool.closeConnectionWatch = true;
    expect(mockPool.getConfig()).andReturn(config).anyTimes();
    config.setTransactionRecoveryEnabled(false);
    config.setStatementsCacheSize(1);
    replay(mockPool);
    testClass =
        new ConnectionHandle(
            mockConnection, mockPreparedStatementCache, mockCallableStatementCache, mockPool);
    testStatementCache = new StatementCache(100);
    Field field = testClass.getClass().getDeclaredField("logger");
    field.setAccessible(true);
    field.set(null, mockLogger);
    config.setReleaseHelperThreads(0);
  }
예제 #28
0
  /**
   * Test routine for callable statements.
   *
   * @param args
   * @throws SecurityException
   * @throws NoSuchFieldException
   * @throws IllegalArgumentException
   * @throws IllegalAccessException
   * @throws NoSuchMethodException
   * @throws InvocationTargetException
   */
  @SuppressWarnings("unchecked")
  private void callableStatementTest(Class... args)
      throws SecurityException, NoSuchFieldException, IllegalArgumentException,
          IllegalAccessException, NoSuchMethodException, InvocationTargetException {
    Object[] params = new Object[args.length];
    for (int i = 0; i < args.length; i++) {
      params[i] = CommonTestUtils.instanceMap.get(args[i]);
    }

    Method prepCallMethod = testClass.getClass().getMethod("prepareCall", args);

    CallableStatementHandle mockStatement = createNiceMock(CallableStatementHandle.class);
    ConcurrentLinkedQueue<Statement> mockStatementHandles =
        createNiceMock(ConcurrentLinkedQueue.class);

    testClass.renewConnection(); // logically open the connection

    // fetching a statement that is found in cache. Statement should be returned and marked as being
    // (logically) open
    doStatementMock(mockCallableStatementCache, mockStatement, params, args);

    //
    //	expect(mockCallableStatementCache.get((String)anyObject())).andReturn(mockStatement).anyTimes();

    ((StatementHandle) mockStatement).setLogicallyOpen();
    expectLastCall();
    replay(mockStatement, mockCallableStatementCache);
    prepCallMethod.invoke(testClass, params);
    verify(mockStatement, mockCallableStatementCache);

    reset(mockStatement, mockCallableStatementCache, mockStatementHandles);

    // test for a cache miss
    doStatementMock(mockCallableStatementCache, null, params, args);

    // we should be creating the preparedStatement because it's not in the cache
    expect(prepCallMethod.invoke(mockConnection, params)).andReturn(mockStatement);
    // we should be tracking this statement
    expect(mockStatementHandles.add(mockStatement)).andReturn(true);

    replay(mockStatement, mockCallableStatementCache, mockConnection, mockStatementHandles);
    prepCallMethod.invoke(testClass, params);
    verify(mockStatement, mockCallableStatementCache, mockConnection);

    // test for cache miss + sql exception
    reset(mockStatement, mockCallableStatementCache, mockConnection);

    Method mockConnectionPrepareCallMethod =
        mockConnection.getClass().getMethod("prepareCall", args);

    //		expect(mockCallableStatementCache.get((String)anyObject())).andReturn(null).once();
    doStatementMock(mockCallableStatementCache, null, params, args);

    // we should be creating the preparedStatement because it's not in the cache
    expect(mockConnectionPrepareCallMethod.invoke(mockConnection, params))
        .andThrow(new SQLException("test", "Z"));

    replay(mockStatement, mockCallableStatementCache, mockConnection);
    try {
      prepCallMethod.invoke(testClass, params);
      fail("Should have thrown an exception");
    } catch (Throwable t) {
      // do nothing
    }

    verify(mockStatement, mockCallableStatementCache, mockConnection);

    // test for no cache defined
    reset(mockStatement, mockCallableStatementCache, mockConnection);
    boolean oldState = testClass.statementCachingEnabled;

    testClass.statementCachingEnabled = false;

    // we should be creating the preparedStatement because it's not in the cache
    expect(mockConnectionPrepareCallMethod.invoke(mockConnection, params)).andReturn(mockStatement);

    replay(mockStatement, mockCallableStatementCache, mockConnection);
    prepCallMethod.invoke(testClass, params);
    verify(mockStatement, mockCallableStatementCache, mockConnection);
    // restore sanity
    testClass.statementCachingEnabled = oldState;

    reset(mockStatement, mockCallableStatementCache, mockConnection);
  }
예제 #29
0
 /**
  * Changes the timeout value for connection with the given handle.
  *
  * @param handle - {@link ConnectionHandle} associated with the remote host.
  * @param timeout - new timeout value in ms
  */
 public void setTimeout(ConnectionHandle handle, int timeout) {
   connectionManager.getConnection(handle.getHandle()).setTimeout(timeout);
 }
예제 #30
0
 /** Closes the connection with the given handle */
 public void closeConnection(ConnectionHandle handle) {
   connectionManager.getConnection(handle.getHandle()).unregisterListener(this);
   connectionManager.closeConnection(handle.getHandle());
 }