/** * @param close */ private void closeCleanSessions(boolean close) { HashSet<ClientSessionInternal> sessionsToClose; synchronized (sessions) { sessionsToClose = new HashSet<>(sessions); } // work on a copied set. the session will be removed from sessions when session.close() is // called for (ClientSessionInternal session : sessionsToClose) { try { if (close) session.close(); else session.cleanUp(false); } catch (Exception e1) { ActiveMQClientLogger.LOGGER.unableToCloseSession(e1); } } checkCloseConnection(); }
private void doAck(final ClientMessageInternal message) throws ActiveMQException { ackBytes = 0; lastAckedMessage = null; if (logger.isTraceEnabled()) { logger.trace(this + "::Acking message " + message); } session.acknowledge(this, message); }
SessionContext context = session.getSessionContext(); if (context instanceof ActiveMQSessionContext) { ActiveMQSessionContext sessionContext = (ActiveMQSessionContext) context; session.cleanUp(true); } catch (Exception cause) { ActiveMQClientLogger.LOGGER.failedToCleanupSession(cause);
session.preHandleFailover(connection); session.handleFailover(connection, cause);
sendingAddress = this.address; session.startCall(); session.setAddress(msg, sendingAddress); } else { msg.setAddress(sendingAddress); theCredits = session.getCredits(sendingAddress, true); session.workDone(); session.endCall();
@Override public synchronized void handleLargeMessage(final ClientLargeMessageInternal clientLargeMessage, long largeMessageSize) throws Exception { if (closing) { // This is ok - we just ignore the message return; } // Flow control for the first packet, we will have others File largeMessageCache = null; if (session.isCacheLargeMessageClient()) { largeMessageCache = File.createTempFile("tmp-large-message-" + clientLargeMessage.getMessageID() + "-", ".tmp"); largeMessageCache.deleteOnExit(); } ClientSessionFactory sf = session.getSessionFactory(); ServerLocator locator = sf.getServerLocator(); long callTimeout = locator.getCallTimeout(); currentLargeMessageController = new LargeMessageControllerImpl(this, largeMessageSize, callTimeout, largeMessageCache); if (clientLargeMessage.isCompressed()) { clientLargeMessage.setLargeMessageController(new CompressedLargeMessageControllerImpl(currentLargeMessageController)); } else { clientLargeMessage.setLargeMessageController(currentLargeMessageController); } handleRegularMessage(clientLargeMessage); }
private ClientSession createSessionInternal(final String username, final String password, final boolean xa, final boolean autoCommitSends, final boolean autoCommitAcks, final boolean preAcknowledge, final int ackBatchSize) throws ActiveMQException { String name = UUIDGenerator.getInstance().generateStringUUID(); SessionContext context = createSessionChannel(name, username, password, xa, autoCommitSends, autoCommitAcks, preAcknowledge); ClientSessionInternal session = new ClientSessionImpl(this, name, username, password, xa, autoCommitSends, autoCommitAcks, preAcknowledge, serverLocator.isBlockOnAcknowledge(), serverLocator.isAutoGroup(), ackBatchSize, serverLocator.getConsumerWindowSize(), serverLocator.getConsumerMaxRate(), serverLocator.getConfirmationWindowSize(), serverLocator.getProducerWindowSize(), serverLocator.getProducerMaxRate(), serverLocator.isBlockOnNonDurableSend(), serverLocator.isBlockOnDurableSend(), serverLocator.isCacheLargeMessagesClient(), serverLocator.getMinLargeMessageSize(), serverLocator.isCompressLargeMessage(), serverLocator.getInitialMessagePacketSize(), serverLocator.getGroupID(), context, orderedExecutorFactory.getExecutor(), orderedExecutorFactory.getExecutor(), orderedExecutorFactory.getExecutor()); synchronized (sessions) { if (closed || !clientProtocolManager.isAlive()) { session.close(); return null; } sessions.add(session); } return session; }
cf = createSessionFactory(locator); ClientSessionInternal clientSession = (ClientSessionInternal) cf.createSession(false, true, true); clientSession.createQueue(queueName, queueName, false); ClientProducer producer = clientSession.createProducer(); @SuppressWarnings("unused") ClientConsumer consumer = clientSession.createConsumer(queueName); RemotingConnection rc = clientSession.getConnection(); clientSession.close();
@Override public boolean isSameRM(final XAResource xares) throws XAException { checkXA(); if (forceNotSameRM) { return false; } ClientSessionInternal other = getSessionInternalFromXAResource(xares); if (other == null) { return false; } String liveNodeId = sessionFactory.getLiveNodeId(); String otherLiveNodeId = ((ClientSessionFactoryInternal) other.getSessionFactory()).getLiveNodeId(); if (liveNodeId != null && otherLiveNodeId != null) { return liveNodeId.equals(otherLiveNodeId); } //we shouldn't get here, live node id should always be set return sessionFactory == other.getSessionFactory(); }
/** * This doesn't apply to other protocols probably, so it will be an ActiveMQ Artemis exclusive feature * * @throws ActiveMQException */ private void handleConsumerDisconnected(DisconnectConsumerMessage packet) throws ActiveMQException { DisconnectConsumerMessage message = packet; session.handleConsumerDisconnect(new ActiveMQConsumerContext(message.getConsumerId())); }
public ClientProducerImpl(final ClientSessionInternal session, final SimpleString address, final TokenBucketLimiter rateLimiter, final boolean blockOnNonDurableSend, final boolean blockOnDurableSend, final boolean autoGroup, final SimpleString groupID, final int minLargeMessageSize, final SessionContext sessionContext) { this.sessionContext = sessionContext; this.session = session; this.address = address; this.rateLimiter = rateLimiter; this.blockOnNonDurableSend = blockOnNonDurableSend; this.blockOnDurableSend = blockOnDurableSend; if (autoGroup) { this.groupID = UUIDGenerator.getInstance().generateSimpleStringUUID(); } else { this.groupID = groupID; } this.minLargeMessageSize = minLargeMessageSize; if (address != null) { producerCredits = session.getCredits(address, false); } else { producerCredits = null; } }
session.removeFailureListener(BridgeImpl.this); try { session.close(); session = null; } catch (ActiveMQException dontcare) { logger.debug("Cleaning up session " + session); try { sessionConsumer.close(); sessionConsumer = null; } catch (ActiveMQException dontcare) {
@Test public void testProducerOnClosedSession() throws Exception { clientSession.close(); try { clientSession.createProducer(); Assert.fail("should throw exception"); } catch (ActiveMQObjectClosedException oce) { //ok } catch (ActiveMQException e) { fail("Invalid Exception type:" + e.getType()); } }
session.addMetaData("meta1", "meta1"); session.addFailoverListener(new FailoverEventListener() { @Override public void failoverEvent(FailoverEventType eventType) { session.close(); } catch (Throwable e) {
session.addFailureListener(new SessionFailureListener() { @Override public void connectionFailed(final ActiveMQException me, boolean failedOver) { } finally { try { session.close(); } catch (Throwable e) {
@Test public void testNoCheckFailoverMessage() throws Exception { final int pingPeriod = 1000; ActiveMQServer server = createServer(false, true); server.start(); ClientSessionInternal session = null; try { ServerLocator locator = createFactory(true).setClientFailureCheckPeriod(pingPeriod).setRetryInterval(500).setRetryIntervalMultiplier(1d).setReconnectAttempts(-1).setConfirmationWindowSize(1024 * 1024); locator.setProtocolManagerFactory(new HornetQClientProtocolManagerFactory()); ClientSessionFactory factory = createSessionFactory(locator); session = (ClientSessionInternal) factory.createSession(); server.stop(); Thread.sleep((pingPeriod * 2)); List<String> incomings = server.getConfiguration().getIncomingInterceptorClassNames(); incomings.add(UnsupportedPacketInterceptor.class.getName()); server.start(); //issue a query to make sure session is reconnected. ClientSession.QueueQuery query = session.queueQuery(new SimpleString("anyvalue")); assertFalse(query.isExists()); locator.close(); UnsupportedPacketInterceptor.checkReceivedTypes(); } finally { try { session.close(); } catch (Throwable e) { } server.stop(); } }
@Override public void run() { if (session != null) { try { session.cleanUp(false); } catch (Exception dontcare) { logger.debug(dontcare.getMessage(), dontcare); } session = null; } if (sessionConsumer != null) { try { sessionConsumer.cleanUp(false); } catch (Exception dontcare) { logger.debug(dontcare.getMessage(), dontcare); } sessionConsumer = null; } } });
private void stopSessionFailover() { XASession xaSource = (XASession) sourceSession; XASession xaTarget = (XASession) targetSession; ((ClientSessionInternal) xaSource.getXAResource()).getSessionContext().releaseCommunications(); ((ClientSessionInternal) xaTarget.getXAResource()).getSessionContext().releaseCommunications(); }
sendingAddress = this.address; session.startCall(); session.setAddress(msg, sendingAddress); } else { msg.setAddress(sendingAddress); theCredits = session.getCredits(sendingAddress, true); session.workDone(); session.endCall();