Examples with QueueQueryResult org.apache.activemq.artemis.core.server.QueueQueryResult used on opensource projects

Example 1 with QueueQueryResult

use of org.apache.activemq.artemis.core.server.QueueQueryResult in project activemq-artemis by apache.

the class ServerSessionPacketHandler method slowPacketHandler.

// This is being separated from onMessagePacket as JIT was more efficient with a small method for the
// hot executions.
private void slowPacketHandler(final Packet packet) {
    final byte type = packet.getType();
    storageManager.setContext(session.getSessionContext());
    Packet response = null;
    boolean flush = false;
    boolean closeChannel = false;
    boolean requiresResponse = false;
    try {
        try {
            switch(type) {
                case SESS_SEND_LARGE:
                    {
                        SessionSendLargeMessage message = (SessionSendLargeMessage) packet;
                        sendLarge(message.getLargeMessage());
                        break;
                    }
                case SESS_SEND_CONTINUATION:
                    {
                        SessionSendContinuationMessage message = (SessionSendContinuationMessage) packet;
                        requiresResponse = message.isRequiresResponse();
                        sendContinuations(message.getPacketSize(), message.getMessageBodySize(), message.getBody(), message.isContinues());
                        if (requiresResponse) {
                            response = new NullResponseMessage();
                        }
                        break;
                    }
                case SESS_CREATECONSUMER:
                    {
                        SessionCreateConsumerMessage request = (SessionCreateConsumerMessage) packet;
                        requiresResponse = request.isRequiresResponse();
                        session.createConsumer(request.getID(), request.getQueueName(), request.getFilterString(), request.isBrowseOnly());
                        if (requiresResponse) {
                            // We send back queue information on the queue as a response- this allows the queue to
                            // be automatically recreated on failover
                            QueueQueryResult queueQueryResult = session.executeQueueQuery(request.getQueueName());
                            if (channel.supports(PacketImpl.SESS_QUEUEQUERY_RESP_V3)) {
                                response = new SessionQueueQueryResponseMessage_V3(queueQueryResult);
                            } else if (channel.supports(PacketImpl.SESS_QUEUEQUERY_RESP_V2)) {
                                response = new SessionQueueQueryResponseMessage_V2(queueQueryResult);
                            } else {
                                response = new SessionQueueQueryResponseMessage(queueQueryResult);
                            }
                        }
                        break;
                    }
                case CREATE_ADDRESS:
                    {
                        CreateAddressMessage request = (CreateAddressMessage) packet;
                        requiresResponse = request.isRequiresResponse();
                        session.createAddress(request.getAddress(), request.getRoutingTypes(), request.isAutoCreated());
                        if (requiresResponse) {
                            response = new NullResponseMessage();
                        }
                        break;
                    }
                case CREATE_QUEUE:
                    {
                        CreateQueueMessage request = (CreateQueueMessage) packet;
                        requiresResponse = request.isRequiresResponse();
                        session.createQueue(request.getAddress(), request.getQueueName(), RoutingType.MULTICAST, request.getFilterString(), request.isTemporary(), request.isDurable());
                        if (requiresResponse) {
                            response = new NullResponseMessage();
                        }
                        break;
                    }
                case CREATE_QUEUE_V2:
                    {
                        CreateQueueMessage_V2 request = (CreateQueueMessage_V2) packet;
                        requiresResponse = request.isRequiresResponse();
                        session.createQueue(request.getAddress(), request.getQueueName(), request.getRoutingType(), request.getFilterString(), request.isTemporary(), request.isDurable(), request.getMaxConsumers(), request.isPurgeOnNoConsumers(), request.isExclusive(), request.isLastValue(), request.isAutoCreated());
                        if (requiresResponse) {
                            response = new NullResponseMessage();
                        }
                        break;
                    }
                case CREATE_SHARED_QUEUE:
                    {
                        CreateSharedQueueMessage request = (CreateSharedQueueMessage) packet;
                        requiresResponse = request.isRequiresResponse();
                        session.createSharedQueue(request.getAddress(), request.getQueueName(), request.isDurable(), request.getFilterString());
                        if (requiresResponse) {
                            response = new NullResponseMessage();
                        }
                        break;
                    }
                case CREATE_SHARED_QUEUE_V2:
                    {
                        CreateSharedQueueMessage_V2 request = (CreateSharedQueueMessage_V2) packet;
                        requiresResponse = request.isRequiresResponse();
                        session.createSharedQueue(request.getAddress(), request.getQueueName(), request.getRoutingType(), request.getFilterString(), request.isDurable(), request.getMaxConsumers(), request.isPurgeOnNoConsumers(), request.isExclusive(), request.isLastValue());
                        if (requiresResponse) {
                            response = new NullResponseMessage();
                        }
                        break;
                    }
                case DELETE_QUEUE:
                    {
                        requiresResponse = true;
                        SessionDeleteQueueMessage request = (SessionDeleteQueueMessage) packet;
                        session.deleteQueue(request.getQueueName());
                        response = new NullResponseMessage();
                        break;
                    }
                case SESS_QUEUEQUERY:
                    {
                        requiresResponse = true;
                        SessionQueueQueryMessage request = (SessionQueueQueryMessage) packet;
                        QueueQueryResult result = session.executeQueueQuery(request.getQueueName());
                        if (result.isExists() && remotingConnection.getChannelVersion() < PacketImpl.ADDRESSING_CHANGE_VERSION) {
                            result.setAddress(SessionQueueQueryMessage.getOldPrefixedAddress(result.getAddress(), result.getRoutingType()));
                        }
                        if (channel.supports(PacketImpl.SESS_QUEUEQUERY_RESP_V3)) {
                            response = new SessionQueueQueryResponseMessage_V3(result);
                        } else if (channel.supports(PacketImpl.SESS_QUEUEQUERY_RESP_V2)) {
                            response = new SessionQueueQueryResponseMessage_V2(result);
                        } else {
                            response = new SessionQueueQueryResponseMessage(result);
                        }
                        break;
                    }
                case SESS_BINDINGQUERY:
                    {
                        requiresResponse = true;
                        SessionBindingQueryMessage request = (SessionBindingQueryMessage) packet;
                        final int clientVersion = remotingConnection.getChannelVersion();
                        BindingQueryResult result = session.executeBindingQuery(request.getAddress());
                        /* if the session is JMS and it's from an older client then we need to add the old prefix to the queue
                   * names otherwise the older client won't realize the queue exists and will try to create it and receive
                   * an error
                   */
                        if (result.isExists() && clientVersion < PacketImpl.ADDRESSING_CHANGE_VERSION && session.getMetaData(ClientSession.JMS_SESSION_IDENTIFIER_PROPERTY) != null) {
                            final List<SimpleString> queueNames = result.getQueueNames();
                            if (!queueNames.isEmpty()) {
                                final List<SimpleString> convertedQueueNames = request.convertQueueNames(clientVersion, queueNames);
                                if (convertedQueueNames != queueNames) {
                                    result = new BindingQueryResult(result.isExists(), result.getAddressInfo(), convertedQueueNames, result.isAutoCreateQueues(), result.isAutoCreateAddresses(), result.isDefaultPurgeOnNoConsumers(), result.getDefaultMaxConsumers(), result.isDefaultExclusive(), result.isDefaultLastValue());
                                }
                            }
                        }
                        if (channel.supports(PacketImpl.SESS_BINDINGQUERY_RESP_V4)) {
                            response = new SessionBindingQueryResponseMessage_V4(result.isExists(), result.getQueueNames(), result.isAutoCreateQueues(), result.isAutoCreateAddresses(), result.isDefaultPurgeOnNoConsumers(), result.getDefaultMaxConsumers(), result.isDefaultExclusive(), result.isDefaultLastValue());
                        } else if (channel.supports(PacketImpl.SESS_BINDINGQUERY_RESP_V3)) {
                            response = new SessionBindingQueryResponseMessage_V3(result.isExists(), result.getQueueNames(), result.isAutoCreateQueues(), result.isAutoCreateAddresses());
                        } else if (channel.supports(PacketImpl.SESS_BINDINGQUERY_RESP_V2)) {
                            response = new SessionBindingQueryResponseMessage_V2(result.isExists(), result.getQueueNames(), result.isAutoCreateQueues());
                        } else {
                            response = new SessionBindingQueryResponseMessage(result.isExists(), result.getQueueNames());
                        }
                        break;
                    }
                case SESS_EXPIRED:
                    {
                        SessionExpireMessage message = (SessionExpireMessage) packet;
                        session.expire(message.getConsumerID(), message.getMessageID());
                        break;
                    }
                case SESS_COMMIT:
                    {
                        requiresResponse = true;
                        session.commit();
                        response = new NullResponseMessage();
                        break;
                    }
                case SESS_ROLLBACK:
                    {
                        requiresResponse = true;
                        session.rollback(((RollbackMessage) packet).isConsiderLastMessageAsDelivered());
                        response = new NullResponseMessage();
                        break;
                    }
                case SESS_XA_COMMIT:
                    {
                        requiresResponse = true;
                        SessionXACommitMessage message = (SessionXACommitMessage) packet;
                        session.xaCommit(message.getXid(), message.isOnePhase());
                        response = new SessionXAResponseMessage(false, XAResource.XA_OK, null);
                        break;
                    }
                case SESS_XA_END:
                    {
                        requiresResponse = true;
                        SessionXAEndMessage message = (SessionXAEndMessage) packet;
                        session.xaEnd(message.getXid());
                        response = new SessionXAResponseMessage(false, XAResource.XA_OK, null);
                        break;
                    }
                case SESS_XA_FORGET:
                    {
                        requiresResponse = true;
                        SessionXAForgetMessage message = (SessionXAForgetMessage) packet;
                        session.xaForget(message.getXid());
                        response = new SessionXAResponseMessage(false, XAResource.XA_OK, null);
                        break;
                    }
                case SESS_XA_JOIN:
                    {
                        requiresResponse = true;
                        SessionXAJoinMessage message = (SessionXAJoinMessage) packet;
                        session.xaJoin(message.getXid());
                        response = new SessionXAResponseMessage(false, XAResource.XA_OK, null);
                        break;
                    }
                case SESS_XA_RESUME:
                    {
                        requiresResponse = true;
                        SessionXAResumeMessage message = (SessionXAResumeMessage) packet;
                        session.xaResume(message.getXid());
                        response = new SessionXAResponseMessage(false, XAResource.XA_OK, null);
                        break;
                    }
                case SESS_XA_ROLLBACK:
                    {
                        requiresResponse = true;
                        SessionXARollbackMessage message = (SessionXARollbackMessage) packet;
                        session.xaRollback(message.getXid());
                        response = new SessionXAResponseMessage(false, XAResource.XA_OK, null);
                        break;
                    }
                case SESS_XA_START:
                    {
                        requiresResponse = true;
                        SessionXAStartMessage message = (SessionXAStartMessage) packet;
                        session.xaStart(message.getXid());
                        response = new SessionXAResponseMessage(false, XAResource.XA_OK, null);
                        break;
                    }
                case SESS_XA_FAILED:
                    {
                        requiresResponse = true;
                        SessionXAAfterFailedMessage message = (SessionXAAfterFailedMessage) packet;
                        session.xaFailed(message.getXid());
                        // no response on this case
                        break;
                    }
                case SESS_XA_SUSPEND:
                    {
                        requiresResponse = true;
                        session.xaSuspend();
                        response = new SessionXAResponseMessage(false, XAResource.XA_OK, null);
                        break;
                    }
                case SESS_XA_PREPARE:
                    {
                        requiresResponse = true;
                        SessionXAPrepareMessage message = (SessionXAPrepareMessage) packet;
                        session.xaPrepare(message.getXid());
                        response = new SessionXAResponseMessage(false, XAResource.XA_OK, null);
                        break;
                    }
                case SESS_XA_INDOUBT_XIDS:
                    {
                        requiresResponse = true;
                        List<Xid> xids = session.xaGetInDoubtXids();
                        response = new SessionXAGetInDoubtXidsResponseMessage(xids);
                        break;
                    }
                case SESS_XA_GET_TIMEOUT:
                    {
                        requiresResponse = true;
                        int timeout = session.xaGetTimeout();
                        response = new SessionXAGetTimeoutResponseMessage(timeout);
                        break;
                    }
                case SESS_XA_SET_TIMEOUT:
                    {
                        requiresResponse = true;
                        SessionXASetTimeoutMessage message = (SessionXASetTimeoutMessage) packet;
                        session.xaSetTimeout(message.getTimeoutSeconds());
                        response = new SessionXASetTimeoutResponseMessage(true);
                        break;
                    }
                case SESS_START:
                    {
                        session.start();
                        break;
                    }
                case SESS_STOP:
                    {
                        requiresResponse = true;
                        session.stop();
                        response = new NullResponseMessage();
                        break;
                    }
                case SESS_CLOSE:
                    {
                        requiresResponse = true;
                        session.close(false);
                        // removeConnectionListeners();
                        response = new NullResponseMessage();
                        flush = true;
                        closeChannel = true;
                        break;
                    }
                case SESS_INDIVIDUAL_ACKNOWLEDGE:
                    {
                        SessionIndividualAcknowledgeMessage message = (SessionIndividualAcknowledgeMessage) packet;
                        requiresResponse = message.isRequiresResponse();
                        session.individualAcknowledge(message.getConsumerID(), message.getMessageID());
                        if (requiresResponse) {
                            response = new NullResponseMessage();
                        }
                        break;
                    }
                case SESS_CONSUMER_CLOSE:
                    {
                        requiresResponse = true;
                        SessionConsumerCloseMessage message = (SessionConsumerCloseMessage) packet;
                        session.closeConsumer(message.getConsumerID());
                        response = new NullResponseMessage();
                        break;
                    }
                case SESS_FORCE_CONSUMER_DELIVERY:
                    {
                        SessionForceConsumerDelivery message = (SessionForceConsumerDelivery) packet;
                        session.forceConsumerDelivery(message.getConsumerID(), message.getSequence());
                        break;
                    }
                case PacketImpl.SESS_ADD_METADATA:
                    {
                        response = new NullResponseMessage();
                        SessionAddMetaDataMessage message = (SessionAddMetaDataMessage) packet;
                        session.addMetaData(message.getKey(), message.getData());
                        break;
                    }
                case PacketImpl.SESS_ADD_METADATA2:
                    {
                        requiresResponse = true;
                        SessionAddMetaDataMessageV2 message = (SessionAddMetaDataMessageV2) packet;
                        if (message.isRequiresConfirmations()) {
                            response = new NullResponseMessage();
                        }
                        session.addMetaData(message.getKey(), message.getData());
                        break;
                    }
                case PacketImpl.SESS_UNIQUE_ADD_METADATA:
                    {
                        requiresResponse = true;
                        SessionUniqueAddMetaDataMessage message = (SessionUniqueAddMetaDataMessage) packet;
                        if (session.addUniqueMetaData(message.getKey(), message.getData())) {
                            response = new NullResponseMessage();
                        } else {
                            response = new ActiveMQExceptionMessage(ActiveMQMessageBundle.BUNDLE.duplicateMetadata(message.getKey(), message.getData()));
                        }
                        break;
                    }
            }
        } catch (ActiveMQIOErrorException e) {
            response = onActiveMQIOErrorExceptionWhileHandlePacket(e, requiresResponse, response, this.session);
        } catch (ActiveMQXAException e) {
            response = onActiveMQXAExceptionWhileHandlePacket(e, requiresResponse, response);
        } catch (ActiveMQQueueMaxConsumerLimitReached e) {
            response = onActiveMQQueueMaxConsumerLimitReachedWhileHandlePacket(e, requiresResponse, response);
        } catch (ActiveMQException e) {
            response = onActiveMQExceptionWhileHandlePacket(e, requiresResponse, response);
        } catch (Throwable t) {
            response = onCatchThrowableWhileHandlePacket(t, requiresResponse, response, this.session);
        }
        sendResponse(packet, response, flush, closeChannel);
    } finally {
        storageManager.clearContext();
    }
}

Example 2 with QueueQueryResult

use of org.apache.activemq.artemis.core.server.QueueQueryResult in project activemq-artemis by apache.

the class AMQConsumer method createTopicSubscription.

private SimpleString createTopicSubscription(boolean isDurable, String clientID, String physicalName, String subscriptionName, SimpleString selector, SimpleString address) throws Exception {
    SimpleString queueName;
    AddressInfo addressInfo = session.getCoreServer().getAddressInfo(address);
    if (addressInfo != null) {
        addressInfo.addRoutingType(RoutingType.MULTICAST);
    } else {
        addressInfo = new AddressInfo(address, RoutingType.MULTICAST);
    }
    addressInfo.setInternal(internalAddress);
    if (isDurable) {
        queueName = org.apache.activemq.artemis.jms.client.ActiveMQDestination.createQueueNameForSubscription(true, clientID, subscriptionName);
        QueueQueryResult result = session.getCoreSession().executeQueueQuery(queueName);
        if (result.isExists()) {
            // Already exists
            if (result.getConsumerCount() > 0) {
                throw new IllegalStateException("Cannot create a subscriber on the durable subscription since it already has subscriber(s)");
            }
            SimpleString oldFilterString = result.getFilterString();
            boolean selectorChanged = selector == null && oldFilterString != null || oldFilterString == null && selector != null || oldFilterString != null && selector != null && !oldFilterString.equals(selector);
            SimpleString oldTopicName = result.getAddress();
            boolean topicChanged = !oldTopicName.equals(address);
            if (selectorChanged || topicChanged) {
                // Delete the old durable sub
                session.getCoreSession().deleteQueue(queueName);
                // Create the new one
                session.getCoreSession().createQueue(addressInfo, queueName, selector, false, true);
            }
        } else {
            session.getCoreSession().createQueue(addressInfo, queueName, selector, false, true);
        }
    } else {
        queueName = new SimpleString(UUID.randomUUID().toString());
        session.getCoreSession().createQueue(addressInfo, queueName, selector, true, false);
    }
    return queueName;
}

Example 3 with QueueQueryResult

use of org.apache.activemq.artemis.core.server.QueueQueryResult in project activemq-artemis by apache.

the class ProtonServerSenderContext method initialise.

/**
 * create the actual underlying ActiveMQ Artemis Server Consumer
 */
@SuppressWarnings("unchecked")
@Override
public void initialise() throws Exception {
    super.initialise();
    Source source = (Source) sender.getRemoteSource();
    SimpleString queue = null;
    String selector = null;
    final Map<Symbol, Object> supportedFilters = new HashMap<>();
    // Match the settlement mode of the remote instead of relying on the default of MIXED.
    sender.setSenderSettleMode(sender.getRemoteSenderSettleMode());
    // We don't currently support SECOND so enforce that the answer is anlways FIRST
    sender.setReceiverSettleMode(ReceiverSettleMode.FIRST);
    if (source != null) {
        // We look for message selectors on every receiver, while in other cases we might only
        // consume the filter depending on the subscription type.
        Map.Entry<Symbol, DescribedType> filter = AmqpSupport.findFilter(source.getFilter(), AmqpSupport.JMS_SELECTOR_FILTER_IDS);
        if (filter != null) {
            selector = filter.getValue().getDescribed().toString();
            // Validate the Selector.
            try {
                SelectorParser.parse(selector);
            } catch (FilterException e) {
                throw new ActiveMQAMQPException(AmqpError.INVALID_FIELD, "Invalid filter", ActiveMQExceptionType.INVALID_FILTER_EXPRESSION);
            }
            supportedFilters.put(filter.getKey(), filter.getValue());
        }
    }
    if (source == null) {
        // Attempt to recover a previous subscription happens when a link reattach happens on a
        // subscription queue
        String clientId = getClientId();
        String pubId = sender.getName();
        global = hasRemoteDesiredCapability(sender, GLOBAL);
        queue = createQueueName(connection.isUseCoreSubscriptionNaming(), clientId, pubId, true, global, false);
        QueueQueryResult result = sessionSPI.queueQuery(queue, RoutingType.MULTICAST, false);
        multicast = true;
        routingTypeToUse = RoutingType.MULTICAST;
        // the lifetime policy and capabilities of the new subscription.
        if (result.isExists()) {
            source = new org.apache.qpid.proton.amqp.messaging.Source();
            source.setAddress(queue.toString());
            source.setDurable(TerminusDurability.UNSETTLED_STATE);
            source.setExpiryPolicy(TerminusExpiryPolicy.NEVER);
            source.setDistributionMode(COPY);
            source.setCapabilities(TOPIC);
            SimpleString filterString = result.getFilterString();
            if (filterString != null) {
                selector = filterString.toString();
                boolean noLocal = false;
                String remoteContainerId = sender.getSession().getConnection().getRemoteContainer();
                String noLocalFilter = MessageUtil.CONNECTION_ID_PROPERTY_NAME.toString() + "<>'" + remoteContainerId + "'";
                if (selector.endsWith(noLocalFilter)) {
                    if (selector.length() > noLocalFilter.length()) {
                        noLocalFilter = " AND " + noLocalFilter;
                        selector = selector.substring(0, selector.length() - noLocalFilter.length());
                    } else {
                        selector = null;
                    }
                    noLocal = true;
                }
                if (noLocal) {
                    supportedFilters.put(AmqpSupport.NO_LOCAL_NAME, AmqpNoLocalFilter.NO_LOCAL);
                }
                if (selector != null && !selector.trim().isEmpty()) {
                    supportedFilters.put(AmqpSupport.JMS_SELECTOR_NAME, new AmqpJmsSelectorFilter(selector));
                }
            }
            sender.setSource(source);
        } else {
            throw new ActiveMQAMQPNotFoundException("Unknown subscription link: " + sender.getName());
        }
    } else if (source.getDynamic()) {
        // if dynamic we have to create the node (queue) and set the address on the target, the
        // node is temporary and  will be deleted on closing of the session
        queue = SimpleString.toSimpleString(java.util.UUID.randomUUID().toString());
        tempQueueName = queue;
        try {
            sessionSPI.createTemporaryQueue(queue, RoutingType.ANYCAST);
        // protonSession.getServerSession().createQueue(queue, queue, null, true, false);
        } catch (Exception e) {
            throw ActiveMQAMQPProtocolMessageBundle.BUNDLE.errorCreatingTemporaryQueue(e.getMessage());
        }
        source.setAddress(queue.toString());
    } else {
        SimpleString addressToUse;
        SimpleString queueNameToUse = null;
        shared = hasCapabilities(SHARED, source);
        global = hasCapabilities(GLOBAL, source);
        // find out if we have an address made up of the address and queue name, if yes then set queue name
        if (CompositeAddress.isFullyQualified(source.getAddress())) {
            CompositeAddress compositeAddress = CompositeAddress.getQueueName(source.getAddress());
            addressToUse = new SimpleString(compositeAddress.getAddress());
            queueNameToUse = new SimpleString(compositeAddress.getQueueName());
        } else {
            addressToUse = new SimpleString(source.getAddress());
        }
        // check to see if the client has defined how we act
        boolean clientDefined = hasCapabilities(TOPIC, source) || hasCapabilities(QUEUE, source);
        if (clientDefined) {
            multicast = hasCapabilities(TOPIC, source);
            AddressQueryResult addressQueryResult = null;
            try {
                addressQueryResult = sessionSPI.addressQuery(addressToUse, multicast ? RoutingType.MULTICAST : RoutingType.ANYCAST, true);
            } catch (ActiveMQSecurityException e) {
                throw ActiveMQAMQPProtocolMessageBundle.BUNDLE.securityErrorCreatingConsumer(e.getMessage());
            } catch (ActiveMQAMQPException e) {
                throw e;
            } catch (Exception e) {
                throw new ActiveMQAMQPInternalErrorException(e.getMessage(), e);
            }
            if (!addressQueryResult.isExists()) {
                throw ActiveMQAMQPProtocolMessageBundle.BUNDLE.sourceAddressDoesntExist();
            }
            Set<RoutingType> routingTypes = addressQueryResult.getRoutingTypes();
            // if the client defines 1 routing type and the broker another then throw an exception
            if (multicast && !routingTypes.contains(RoutingType.MULTICAST)) {
                throw new ActiveMQAMQPIllegalStateException("Address " + addressToUse + " is not configured for topic support");
            } else if (!multicast && !routingTypes.contains(RoutingType.ANYCAST)) {
                throw new ActiveMQAMQPIllegalStateException("Address " + addressToUse + " is not configured for queue support");
            }
        } else {
            // if not we look up the address
            AddressQueryResult addressQueryResult = null;
            try {
                addressQueryResult = sessionSPI.addressQuery(addressToUse, defaultRoutingType, true);
            } catch (ActiveMQSecurityException e) {
                throw ActiveMQAMQPProtocolMessageBundle.BUNDLE.securityErrorCreatingConsumer(e.getMessage());
            } catch (ActiveMQAMQPException e) {
                throw e;
            } catch (Exception e) {
                throw new ActiveMQAMQPInternalErrorException(e.getMessage(), e);
            }
            if (!addressQueryResult.isExists()) {
                throw ActiveMQAMQPProtocolMessageBundle.BUNDLE.sourceAddressDoesntExist();
            }
            Set<RoutingType> routingTypes = addressQueryResult.getRoutingTypes();
            if (routingTypes.contains(RoutingType.MULTICAST) && routingTypes.size() == 1) {
                multicast = true;
            } else {
                // todo add some checks if both routing types are supported
                multicast = false;
            }
        }
        routingTypeToUse = multicast ? RoutingType.MULTICAST : RoutingType.ANYCAST;
        // messages to, however there has to be a queue bound to it so we need to check this.
        if (multicast) {
            Map.Entry<Symbol, DescribedType> filter = AmqpSupport.findFilter(source.getFilter(), AmqpSupport.NO_LOCAL_FILTER_IDS);
            if (filter != null) {
                String remoteContainerId = sender.getSession().getConnection().getRemoteContainer();
                String noLocalFilter = MessageUtil.CONNECTION_ID_PROPERTY_NAME.toString() + "<>'" + remoteContainerId + "'";
                if (selector != null) {
                    selector += " AND " + noLocalFilter;
                } else {
                    selector = noLocalFilter;
                }
                supportedFilters.put(filter.getKey(), filter.getValue());
            }
            queue = getMatchingQueue(queueNameToUse, addressToUse, RoutingType.MULTICAST);
            SimpleString simpleStringSelector = SimpleString.toSimpleString(selector);
            // if the address specifies a broker configured queue then we always use this, treat it as a queue
            if (queue != null) {
                multicast = false;
            } else if (TerminusDurability.UNSETTLED_STATE.equals(source.getDurable()) || TerminusDurability.CONFIGURATION.equals(source.getDurable())) {
                // if we are a subscription and durable create a durable queue using the container
                // id and link name
                String clientId = getClientId();
                String pubId = sender.getName();
                queue = createQueueName(connection.isUseCoreSubscriptionNaming(), clientId, pubId, shared, global, false);
                QueueQueryResult result = sessionSPI.queueQuery(queue, routingTypeToUse, false);
                if (result.isExists()) {
                    // filter value, selector or address then we must recreate the queue (JMS semantics).
                    if (!Objects.equals(result.getFilterString(), simpleStringSelector) || (sender.getSource() != null && !sender.getSource().getAddress().equals(result.getAddress().toString()))) {
                        if (result.getConsumerCount() == 0) {
                            sessionSPI.deleteQueue(queue);
                            sessionSPI.createUnsharedDurableQueue(addressToUse, RoutingType.MULTICAST, queue, simpleStringSelector);
                        } else {
                            throw new ActiveMQAMQPIllegalStateException("Unable to recreate subscription, consumers already exist");
                        }
                    }
                } else {
                    if (shared) {
                        sessionSPI.createSharedDurableQueue(addressToUse, RoutingType.MULTICAST, queue, simpleStringSelector);
                    } else {
                        sessionSPI.createUnsharedDurableQueue(addressToUse, RoutingType.MULTICAST, queue, simpleStringSelector);
                    }
                }
            } else {
                // otherwise we are a volatile subscription
                isVolatile = true;
                if (shared && sender.getName() != null) {
                    queue = createQueueName(connection.isUseCoreSubscriptionNaming(), getClientId(), sender.getName(), shared, global, isVolatile);
                    try {
                        sessionSPI.createSharedVolatileQueue(addressToUse, RoutingType.MULTICAST, queue, simpleStringSelector);
                    } catch (ActiveMQQueueExistsException e) {
                    // this is ok, just means its shared
                    }
                } else {
                    queue = SimpleString.toSimpleString(java.util.UUID.randomUUID().toString());
                    tempQueueName = queue;
                    try {
                        sessionSPI.createTemporaryQueue(addressToUse, queue, RoutingType.MULTICAST, simpleStringSelector);
                    } catch (Exception e) {
                        throw ActiveMQAMQPProtocolMessageBundle.BUNDLE.errorCreatingTemporaryQueue(e.getMessage());
                    }
                }
            }
        } else {
            if (queueNameToUse != null) {
                SimpleString matchingAnycastQueue = getMatchingQueue(queueNameToUse, addressToUse, RoutingType.ANYCAST);
                if (matchingAnycastQueue != null) {
                    queue = matchingAnycastQueue;
                } else {
                    throw ActiveMQAMQPProtocolMessageBundle.BUNDLE.sourceAddressDoesntExist();
                }
            } else {
                SimpleString matchingAnycastQueue = sessionSPI.getMatchingQueue(addressToUse, RoutingType.ANYCAST);
                if (matchingAnycastQueue != null) {
                    queue = matchingAnycastQueue;
                } else {
                    queue = addressToUse;
                }
            }
        }
        if (queue == null) {
            throw ActiveMQAMQPProtocolMessageBundle.BUNDLE.sourceAddressNotSet();
        }
        try {
            if (!sessionSPI.queueQuery(queue, routingTypeToUse, !multicast).isExists()) {
                throw ActiveMQAMQPProtocolMessageBundle.BUNDLE.sourceAddressDoesntExist();
            }
        } catch (ActiveMQAMQPNotFoundException e) {
            throw e;
        } catch (Exception e) {
            throw new ActiveMQAMQPInternalErrorException(e.getMessage(), e);
        }
    }
    // We need to update the source with any filters we support otherwise the client
    // is free to consider the attach as having failed if we don't send back what we
    // do support or if we send something we don't support the client won't know we
    // have not honored what it asked for.
    source.setFilter(supportedFilters.isEmpty() ? null : supportedFilters);
    boolean browseOnly = !multicast && source.getDistributionMode() != null && source.getDistributionMode().equals(COPY);
    try {
        brokerConsumer = (Consumer) sessionSPI.createSender(this, queue, multicast ? null : selector, browseOnly);
    } catch (ActiveMQAMQPResourceLimitExceededException e1) {
        throw new ActiveMQAMQPResourceLimitExceededException(e1.getMessage());
    } catch (ActiveMQSecurityException e) {
        throw ActiveMQAMQPProtocolMessageBundle.BUNDLE.securityErrorCreatingConsumer(e.getMessage());
    } catch (Exception e) {
        throw ActiveMQAMQPProtocolMessageBundle.BUNDLE.errorCreatingConsumer(e.getMessage());
    }
}

Example 4 with QueueQueryResult

use of org.apache.activemq.artemis.core.server.QueueQueryResult in project activemq-artemis by apache.

the class QueueCommandTest method testUpdateCoreQueue.

@Test
public void testUpdateCoreQueue() throws Exception {
    final String queueName = "updateQueue";
    final SimpleString queueNameString = new SimpleString(queueName);
    final String addressName = "address";
    final SimpleString addressSimpleString = new SimpleString(addressName);
    final int oldMaxConsumers = -1;
    final RoutingType oldRoutingType = RoutingType.MULTICAST;
    final boolean oldPurgeOnNoConsumers = false;
    final AddressInfo addressInfo = new AddressInfo(addressSimpleString, EnumSet.of(RoutingType.ANYCAST, RoutingType.MULTICAST));
    server.addAddressInfo(addressInfo);
    server.createQueue(addressSimpleString, oldRoutingType, queueNameString, null, true, false, oldMaxConsumers, oldPurgeOnNoConsumers, false);
    final int newMaxConsumers = 1;
    final RoutingType newRoutingType = RoutingType.ANYCAST;
    final boolean newPurgeOnNoConsumers = true;
    final UpdateQueue updateQueue = new UpdateQueue();
    updateQueue.setName(queueName);
    updateQueue.setPurgeOnNoConsumers(newPurgeOnNoConsumers);
    updateQueue.setAnycast(true);
    updateQueue.setMulticast(false);
    updateQueue.setMaxConsumers(newMaxConsumers);
    updateQueue.execute(new ActionContext(System.in, new PrintStream(output), new PrintStream(error)));
    checkExecutionPassed(updateQueue);
    final QueueQueryResult queueQueryResult = server.queueQuery(queueNameString);
    assertEquals("maxConsumers", newMaxConsumers, queueQueryResult.getMaxConsumers());
    assertEquals("routingType", newRoutingType, queueQueryResult.getRoutingType());
    assertTrue("purgeOnNoConsumers", newPurgeOnNoConsumers == queueQueryResult.isPurgeOnNoConsumers());
}

Example 5 with QueueQueryResult

use of org.apache.activemq.artemis.core.server.QueueQueryResult in project activemq-artemis by apache.

the class QueueCommandTest method testUpdateCoreQueueCannotChangeRoutingType.

@Test
public void testUpdateCoreQueueCannotChangeRoutingType() throws Exception {
    final String queueName = "updateQueue";
    final SimpleString queueNameString = new SimpleString(queueName);
    final String addressName = "address";
    final SimpleString addressSimpleString = new SimpleString(addressName);
    final int oldMaxConsumers = 10;
    final RoutingType oldRoutingType = RoutingType.MULTICAST;
    final boolean oldPurgeOnNoConsumers = false;
    final Set<RoutingType> supportedRoutingTypes = EnumSet.of(oldRoutingType);
    final AddressInfo addressInfo = new AddressInfo(addressSimpleString, EnumSet.copyOf(supportedRoutingTypes));
    server.addAddressInfo(addressInfo);
    server.createQueue(addressSimpleString, oldRoutingType, queueNameString, null, true, false, oldMaxConsumers, oldPurgeOnNoConsumers, false);
    final RoutingType newRoutingType = RoutingType.ANYCAST;
    final UpdateQueue updateQueue = new UpdateQueue();
    updateQueue.setName(queueName);
    updateQueue.setAnycast(true);
    updateQueue.setMulticast(false);
    updateQueue.setMaxConsumers(-1);
    updateQueue.execute(new ActionContext(System.in, new PrintStream(output), new PrintStream(error)));
    checkExecutionFailure(updateQueue, "AMQ119211");
    final QueueQueryResult queueQueryResult = server.queueQuery(queueNameString);
    assertEquals("maxConsumers", oldMaxConsumers, queueQueryResult.getMaxConsumers());
    assertEquals("routingType", oldRoutingType, queueQueryResult.getRoutingType());
    assertTrue("purgeOnNoConsumers", oldPurgeOnNoConsumers == queueQueryResult.isPurgeOnNoConsumers());
}