@Test public void testSessionClosedOnRemotingConnectionFailure() throws Exception { ClientSession session = addClientSession(sf.createSession()); session.createQueue("fooaddress", "fooqueue"); ClientProducer prod = session.createProducer("fooaddress"); ClientConsumer cons = session.createConsumer("fooqueue"); session.start(); prod.send(session.createMessage(false)); Assert.assertNotNull(cons.receive()); // Now fail the underlying connection RemotingConnection connection = ((ClientSessionInternal) session).getConnection(); connection.fail(new HornetQNotConnectedException()); Assert.assertTrue(session.isClosed()); Assert.assertTrue(prod.isClosed()); Assert.assertTrue(cons.isClosed()); // Now try and use the producer try { prod.send(session.createMessage(false)); Assert.fail("Should throw exception"); } catch (HornetQObjectClosedException oce) { // ok } catch (HornetQException e) { fail("Invalid Exception type:" + e.getType()); } try { cons.receive(); Assert.fail("Should throw exception"); } catch (HornetQObjectClosedException oce) { // ok } catch (HornetQException e) { fail("Invalid Exception type:" + e.getType()); } session.close(); }
public void write( final long position, final long size, final ByteBuffer directByteBuffer, final AIOCallback aioCallback) { if (aioCallback == null) { throw new NullPointerException("Null Callback"); } checkOpened(); if (poller == null) { startPoller(); } pendingWrites.countUp(); if (writeExecutor != null) { maxIOSemaphore.acquireUninterruptibly(); writeExecutor.execute( new Runnable() { public void run() { long sequence = nextWritingSequence.getAndIncrement(); try { write(handler, sequence, position, size, directByteBuffer, aioCallback); } catch (HornetQException e) { callbackError( aioCallback, sequence, directByteBuffer, e.getType().getCode(), e.getMessage()); } catch (RuntimeException e) { callbackError( aioCallback, sequence, directByteBuffer, HornetQExceptionType.INTERNAL_ERROR.getCode(), e.getMessage()); } } }); } else { maxIOSemaphore.acquireUninterruptibly(); long sequence = nextWritingSequence.getAndIncrement(); try { write(handler, sequence, position, size, directByteBuffer, aioCallback); } catch (HornetQException e) { callbackError( aioCallback, sequence, directByteBuffer, e.getType().getCode(), e.getMessage()); } catch (RuntimeException e) { callbackError( aioCallback, sequence, directByteBuffer, HornetQExceptionType.INTERNAL_ERROR.getCode(), e.getMessage()); } } }
public void testCreateConsumerNoQ() throws Exception { try { clientSession.createConsumer(queueName); Assert.fail("should throw exception"); } catch (NonExistentQueueException neqe) { // ok } catch (HornetQException e) { fail("Invalid Exception type:" + e.getType()); } }
public void testCreateConsumerWithInvalidFilter() throws Exception { clientSession.createQueue(queueName, queueName, false); try { clientSession.createConsumer(queueName, "this is not valid filter"); Assert.fail("should throw exception"); } catch (InvalidFilterExpressionException ifee) { // ok } catch (HornetQException e) { fail("Invalid Exception type:" + e.getType()); } }
/* (non-Javadoc) * @see org.hornetq.core.remoting.FailureListener#connectionFailed(org.hornetq.api.core.HornetQException, boolean) */ public void connectionFailed(HornetQException exception, boolean failedOver) { if (exception.getType() == HornetQExceptionType.DISCONNECTED) { HornetQJMSLogger.LOGGER.warn("being disconnected for server shutdown", exception); } else { HornetQJMSLogger.LOGGER.warn( "Notified of connection failure in xa discovery, we will retry on the next recovery", exception); } internalStop(); HornetQRecoveryRegistry.getInstance().failedDiscovery(this); }
public void writeInternal(long positionToWrite, long size, ByteBuffer bytes) throws HornetQException { try { writeInternal(handler, positionToWrite, size, bytes); } catch (HornetQException e) { fireExceptionListener(e.getType().getCode(), e.getMessage()); throw e; } if (bufferCallback != null) { bufferCallback.bufferDone(bytes); } }
public void open(final String fileName, final int maxIO) throws HornetQException { writeLock.lock(); try { if (opened) { throw new IllegalStateException("AsynchronousFile is already opened"); } this.maxIO = maxIO; maxIOSemaphore = new Semaphore(this.maxIO); this.fileName = fileName; try { handler = AsynchronousFileImpl.init(fileName, this.maxIO, HornetQJournalLogger.LOGGER); } catch (HornetQException e) { HornetQException ex = null; if (e.getType() == HornetQExceptionType.NATIVE_ERROR_CANT_INITIALIZE_AIO) { ex = new HornetQException( e.getType(), "Can't initialize AIO. Currently AIO in use = " + AsynchronousFileImpl.totalMaxIO.get() + ", trying to allocate more " + maxIO, e); } else { ex = e; } throw ex; } opened = true; AsynchronousFileImpl.addMax(this.maxIO); nextWritingSequence.set(0); nextReadSequence = 0; } finally { writeLock.unlock(); } }
public void testConnectIntoNonBackup() throws Exception { setupServer(false); try { ClientSessionFactory sf = createSessionFactory(locator); manager = new ReplicationManager(sf.getConnection(), factory); addHornetQComponent(manager); manager.start(); Assert.fail("Exception was expected"); } catch (NotConnectedException nce) { // ok } catch (HornetQException expected) { fail("Invalid Exception type:" + expected.getType()); } }
@Override public void connectionFailed(final HornetQException me, boolean failedOver) { if (me.getType() == HornetQExceptionType.DISCONNECTED) { // Backup has shut down - no need to log a stack trace HornetQServerLogger.LOGGER.replicationStopOnBackupShutdown(); } else { HornetQServerLogger.LOGGER.replicationStopOnBackupFail(me); } try { stop(); } catch (Exception e) { HornetQServerLogger.LOGGER.errorStoppingReplication(e); } }
public void testSSLWithIncorrectKeyStorePassword() throws Exception { tc.getParams().put(TransportConstants.SSL_ENABLED_PROP_NAME, true); tc.getParams() .put(TransportConstants.KEYSTORE_PATH_PROP_NAME, TransportConstants.DEFAULT_KEYSTORE_PATH); tc.getParams().put(TransportConstants.KEYSTORE_PASSWORD_PROP_NAME, "invalid password"); ServerLocator locator = addServerLocator(HornetQClient.createServerLocatorWithoutHA(tc)); try { ClientSessionFactory sf = createSessionFactory(locator); Assert.fail(); } catch (HornetQNotConnectedException se) { // ok } catch (HornetQException e) { fail("Invalid Exception type:" + e.getType()); } }
// see https://jira.jboss.org/jira/browse/HORNETQ-234 public void testPlainConnectionToSSLEndpoint() throws Exception { tc.getParams().put(TransportConstants.SSL_ENABLED_PROP_NAME, false); ServerLocator locator = addServerLocator(HornetQClient.createServerLocatorWithoutHA(tc)); locator.setCallTimeout(2000); try { createSessionFactory(locator); fail("expecting exception"); } catch (HornetQNotConnectedException se) { // ok } catch (HornetQConnectionTimedOutException ctoe) { // ok } catch (HornetQException e) { fail("Invalid Exception type:" + e.getType()); } }
private void decideOnAction() { // we may get called via multiple paths so need to guard synchronized (decisionGuard) { if (signal == BACKUP_ACTIVATION.FAIL_OVER) { return; } if (!isLiveDown()) { try { // no point in repeating all the reconnection logic sessionFactory.connect(RECONNECT_ATTEMPTS, false); return; } catch (HornetQException e) { if (e.getType() != HornetQExceptionType.NOT_CONNECTED) HornetQServerLogger.LOGGER.errorReConnecting(e); } } // live is assumed to be down, backup fails-over signal = BACKUP_ACTIVATION.FAIL_OVER; } latch.countDown(); }
public ClientSessionFactory createSessionFactory() throws HornetQException { assertOpen(); initialise(); if (initialConnectors == null && discoveryGroup != null) { // Wait for an initial broadcast to give us at least one node in the cluster long timeout = clusterConnection ? 0 : discoveryGroupConfiguration.getDiscoveryInitialWaitTimeout(); boolean ok = discoveryGroup.waitForBroadcast(timeout); if (!ok) { throw HornetQMessageBundle.BUNDLE.connectionTimedOutInInitialBroadcast(); } } ClientSessionFactoryInternal factory = null; synchronized (this) { boolean retry; int attempts = 0; do { retry = false; TransportConfiguration tc = selectConnector(); if (tc == null) { throw HornetQMessageBundle.BUNDLE.noTCForSessionFactory(); } // try each factory in the list until we find one which works try { factory = new ClientSessionFactoryImpl( this, tc, callTimeout, callFailoverTimeout, clientFailureCheckPeriod, connectionTTL, retryInterval, retryIntervalMultiplier, maxRetryInterval, reconnectAttempts, threadPool, scheduledThreadPool, interceptors); try { addToConnecting(factory); factory.connect(initialConnectAttempts, failoverOnInitialConnection); } finally { removeFromConnecting(factory); } } catch (HornetQException e) { factory.close(); factory = null; if (e.getType() == HornetQExceptionType.NOT_CONNECTED) { attempts++; if (topologyArray != null && attempts == topologyArray.length) { throw HornetQMessageBundle.BUNDLE.cannotConnectToServers(); } if (topologyArray == null && initialConnectors != null && attempts == initialConnectors.length) { throw HornetQMessageBundle.BUNDLE.cannotConnectToServers(); } retry = true; } else { throw e; } } } while (retry); if (ha || clusterConnection) { final long timeout = System.currentTimeMillis() + 30000; while (!isClosed() && !receivedTopology && timeout > System.currentTimeMillis()) { // Now wait for the topology try { wait(1000); } catch (InterruptedException ignore) { } } if (System.currentTimeMillis() > timeout && !receivedTopology) { throw HornetQMessageBundle.BUNDLE.connectionTimedOutOnReceiveTopology(discoveryGroup); } } addFactory(factory); return factory; } }