private void sendResponse(final Packet confirmPacket, final Packet response, final boolean flush, final boolean closeChannel) { if (logger.isTraceEnabled()) { logger.trace("ServerSessionPacketHandler::scheduling response::" + response); } storageManager.afterCompleteOperations(new IOCallback() { @Override public void onError(final int errorCode, final String errorMessage) { ActiveMQServerLogger.LOGGER.errorProcessingIOCallback(errorCode, errorMessage); Packet exceptionPacket = convertToExceptionPacket(confirmPacket, ActiveMQExceptionType.createException(errorCode, errorMessage)); doConfirmAndResponse(confirmPacket, exceptionPacket, flush, closeChannel); if (logger.isTraceEnabled()) { logger.trace("ServerSessionPacketHandler::exception response sent::" + exceptionPacket); } } @Override public void done() { if (logger.isTraceEnabled()) { logger.trace("ServerSessionPacketHandler::regular response sent::" + response); } doConfirmAndResponse(confirmPacket, response, flush, closeChannel); } }); }
public Redistributor(final Queue queue, final StorageManager storageManager, final PostOffice postOffice, final Executor executor, final int batchSize) { this.queue = queue; this.sequentialID = storageManager.generateID(); this.storageManager = storageManager; this.postOffice = postOffice; this.executor = executor; this.batchSize = batchSize; }
@Override public void run() { storageManager.setContext(storageManager.newSingleThreadContext()); try { if (cleanupEnabled) { cleanup(); } } finally { storageManager.clearContext(); scheduledCleanup.decrementAndGet(); } } });
@Override public void confirmPosition(final PagePosition position) throws Exception { // if we are dealing with a persistent cursor if (persistent) { store.storeCursorAcknowledge(cursorId, position); } store.afterCompleteOperations(new IOCallback() { volatile String error = ""; @Override public void onError(final int errorCode, final String errorMessage) { error = " errorCode=" + errorCode + ", msg=" + errorMessage; ActiveMQServerLogger.LOGGER.pageSubscriptionError(this, error); } @Override public void done() { processACK(position); } @Override public String toString() { return IOCallback.class.getSimpleName() + "(" + PageSubscriptionImpl.class.getSimpleName() + ") " + error; } }); }
protected void blockOnIO() { // the storage manager could be null on the backup on certain components if (storageManager != null) { try { storageManager.waitOnOperations(); storageManager.clearContext(); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } }
PagingStore store = pagingManager.getPageStore(entry.getKey()); if (store != null && storageManager.addToPage(store, message, context.getTransaction(), entry.getValue())) { if (message.isLargeMessage()) { confirmLargeMessageSend(tx, message); storageManager.storeMessageTransactional(tx.getID(), message); } else { storageManager.storeMessage(message); storageManager.storeReferenceTransactional(tx.getID(), queue.getID(), message.getMessageID()); storageManager.storeReference(queue.getID(), message.getMessageID(), !iter.hasNext()); storageManager.updateScheduledDeliveryTimeTransactional(tx.getID(), reference); } else { storageManager.updateScheduledDeliveryTime(reference); storageManager.afterCompleteOperations(new IOCallback() { @Override public void onError(final int errorCode, final String errorMessage) {
private void onSessionRequestProducerCredits(Packet packet) { this.storageManager.setContext(session.getSessionContext()); try { Packet response = null; boolean requiresResponse = false; try { SessionRequestProducerCreditsMessage message = (SessionRequestProducerCreditsMessage) packet; session.requestProducerCredits(message.getAddress(), message.getCredits()); } catch (ActiveMQIOErrorException e) { response = onActiveMQIOErrorExceptionWhileHandlePacket(packet, e, requiresResponse, response, this.session); } catch (ActiveMQXAException e) { response = onActiveMQXAExceptionWhileHandlePacket(packet, e, requiresResponse, response); } catch (ActiveMQQueueMaxConsumerLimitReached e) { response = onActiveMQQueueMaxConsumerLimitReachedWhileHandlePacket(packet, e, requiresResponse, response); } catch (ActiveMQException e) { response = onActiveMQExceptionWhileHandlePacket(packet, e, requiresResponse, response); } catch (Throwable t) { response = onCatchThrowableWhileHandlePacket(packet, t, requiresResponse, response, this.session); } sendResponse(packet, response, false, false); } finally { this.storageManager.clearContext(); } }
@Override public Response propose(final Proposal proposal) throws Exception { OperationContext originalCtx = storageManager.getContext(); storageManager.setContext(storageManager.newSingleThreadContext()); addRecord = true; groupBinding = new GroupBinding(proposal.getGroupId(), proposal.getClusterName()); groupBinding.setId(storageManager.generateID()); List<GroupBinding> newList = new ArrayList<>(); List<GroupBinding> oldList = groupMap.putIfAbsent(groupBinding.getClusterName(), newList); storageManager.addGrouping(groupBinding); storageManager.setContext(originalCtx);
@Override public boolean addAddressInfo(AddressInfo addressInfo) throws Exception { boolean added = reloadAddressInfo(addressInfo); if (added && storageManager != null) { long txID = storageManager.generateID(); try { storageManager.addAddressBinding(txID, addressInfo); storageManager.commitBindings(txID); } catch (Exception e) { try { storageManager.rollbackBindings(txID); } catch (Exception ignored) { } throw e; } } return added; }
private void sendLarge(final Message message) throws Exception { // need to create the LargeMessage before continue long id = storageManager.generateID(); LargeServerMessage largeMsg = storageManager.createLargeMessage(id, message); if (logger.isTraceEnabled()) { logger.trace("sendLarge::" + largeMsg); } if (currentLargeMessage != null) { ActiveMQServerLogger.LOGGER.replacingIncompleteLargeMessage(currentLargeMessage.getMessageID()); } currentLargeMessage = largeMsg; }
logger.trace("TransactionImpl::prepare::" + this); storageManager.readLock(); try { synchronized (timeoutLock) { storageManager.prepare(id, xid); storageManager.afterCompleteOperations(new IOCallback() { storageManager.readUnLock();
public StompSession getTransactedSession(StompConnection connection, String txID) throws Exception { StompSession stompSession = transactedSessions.get(txID); if (stompSession == null) { stompSession = new StompSession(connection, this, server.getStorageManager().newContext(executor)); String name = UUIDGenerator.getInstance().generateStringUUID(); ServerSession session = server.createSession(name, connection.getLogin(), connection.getPasscode(), ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE, connection, false, false, false, false, null, stompSession, true, server.newOperationContext(), getPrefixes()); stompSession.setServerSession(session); transactedSessions.put(txID, stompSession); } server.getStorageManager().setContext(stompSession.getContext()); return stompSession; }
@Override public void remove(SimpleString groupid, SimpleString clusterName) { GroupBinding groupBinding = map.remove(groupid); List<GroupBinding> groupBindings = groupMap.get(clusterName); if (groupBindings != null && groupBinding != null) { groupBindings.remove(groupBinding); try { long tx = storageManager.generateID(); storageManager.deleteGrouping(tx, groupBinding); storageManager.commitBindings(tx); } catch (Exception e) { // nothing we can do being log ActiveMQServerLogger.LOGGER.warn(e.getMessage(), e); } } }
@Override public void clear() throws Exception { logger.debug("DuplicateIDCacheImpl(" + this.address + ")::clear removing duplicate ID data"); synchronized (this) { if (ids.size() > 0) { long tx = storageManager.generateID(); for (Pair<ByteArrayHolder, Long> id : ids) { storageManager.deleteDuplicateIDTransactional(tx, id.getB()); } storageManager.commit(tx); } ids.clear(); cache.clear(); pos = 0; } }
@Test public void testPageCountRecordSize() throws Exception { long tx = server.getStorageManager().generateID(); server.getStorageManager().storePageCounter(tx, 1, 1, 100); server.getStorageManager().commit(tx); server.getStorageManager().stop(); JournalStorageManager journalStorageManager = (JournalStorageManager) server.getStorageManager(); List<RecordInfo> committedRecords = new LinkedList<>(); List<PreparedTransactionInfo> preparedTransactions = new LinkedList<>(); try { journalStorageManager.getMessageJournal().start(); journalStorageManager.getMessageJournal().load(committedRecords, preparedTransactions, transactionFailure); ActiveMQBuffer buff = ActiveMQBuffers.wrappedBuffer(committedRecords.get(0).data); PageCountRecord encoding = new PageCountRecord(); encoding.decode(buff); Assert.assertEquals(100, encoding.getPersistentSize()); } finally { journalStorageManager.getMessageJournal().stop(); } }
@Test public void testPageCursorCounterRecordSizeTX() throws Exception { long tx = server.getStorageManager().generateID(); server.getStorageManager().storePageCounterInc(tx, 1, 1, 1000); server.getStorageManager().commit(tx); server.getStorageManager().stop(); JournalStorageManager journalStorageManager = (JournalStorageManager) server.getStorageManager(); List<RecordInfo> committedRecords = new LinkedList<>(); List<PreparedTransactionInfo> preparedTransactions = new LinkedList<>(); try { journalStorageManager.getMessageJournal().start(); journalStorageManager.getMessageJournal().load(committedRecords, preparedTransactions, transactionFailure); ActiveMQBuffer buff = ActiveMQBuffers.wrappedBuffer(committedRecords.get(0).data); PageCountRecordInc encoding = new PageCountRecordInc(); encoding.decode(buff); Assert.assertEquals(1000, encoding.getPersistentSize()); } finally { journalStorageManager.getMessageJournal().stop(); } }
public OperationContext recoverContext() { OperationContext oldContext = storageManager.getContext(); manager.getServer().getStorageManager().setContext(serverSession.getSessionContext()); return oldContext; }
storageManager.afterCompleteOperations(new IOCallback() { storageManager.afterStoreOperations(new IOCallback() {
@Override public void processReload() throws Exception { if (recoveredACK != null) { if (logger.isTraceEnabled()) { logger.trace("********** processing reload!!!!!!!"); } Collections.sort(recoveredACK); long txDeleteCursorOnReload = -1; for (PagePosition pos : recoveredACK) { lastAckedPosition = pos; PageCursorInfo pageInfo = getPageInfo(pos); if (pageInfo == null) { ActiveMQServerLogger.LOGGER.pageNotFound(pos); if (txDeleteCursorOnReload == -1) { txDeleteCursorOnReload = store.generateID(); } store.deleteCursorAcknowledgeTransactional(txDeleteCursorOnReload, pos.getRecordID()); } else { pageInfo.loadACK(pos); } } if (txDeleteCursorOnReload >= 0) { store.commit(txDeleteCursorOnReload); } recoveredACK.clear(); recoveredACK = null; } }
@Override public void removeAddressInfo(final SimpleString address, final SecurityAuth auth, boolean force) throws Exception { if (auth != null) { securityStore.check(address, CheckType.DELETE_ADDRESS, auth); } AddressInfo addressInfo = getAddressInfo(address); if (postOffice.removeAddressInfo(address, force) == null) { throw ActiveMQMessageBundle.BUNDLE.addressDoesNotExist(address); } long txID = storageManager.generateID(); storageManager.deleteAddressBinding(txID, addressInfo.getId()); storageManager.commitBindings(txID); pagingManager.deletePageStore(address); }