Examples with BrokerServiceException org.apache.pulsar.broker.service.BrokerServiceException used on opensource projects

Example 1 with BrokerServiceException

use of org.apache.pulsar.broker.service.BrokerServiceException in project incubator-pulsar by apache.

the class PersistentTopic method subscribe.

@Override
public CompletableFuture<Consumer> subscribe(final ServerCnx cnx, String subscriptionName, long consumerId, SubType subType, int priorityLevel, String consumerName, boolean isDurable, MessageId startMessageId, Map<String, String> metadata, boolean readCompacted, InitialPosition initialPosition) {
    final CompletableFuture<Consumer> future = new CompletableFuture<>();
    if (readCompacted && !(subType == SubType.Failover || subType == SubType.Exclusive)) {
        future.completeExceptionally(new NotAllowedException("readCompacted only allowed on failover or exclusive subscriptions"));
        return future;
    }
    if (isBlank(subscriptionName)) {
        if (log.isDebugEnabled()) {
            log.debug("[{}] Empty subscription name", topic);
        }
        future.completeExceptionally(new NamingException("Empty subscription name"));
        return future;
    }
    if (hasBatchMessagePublished && !cnx.isBatchMessageCompatibleVersion()) {
        if (log.isDebugEnabled()) {
            log.debug("[{}] Consumer doesn't support batch-message {}", topic, subscriptionName);
        }
        future.completeExceptionally(new UnsupportedVersionException("Consumer doesn't support batch-message"));
        return future;
    }
    if (subscriptionName.startsWith(replicatorPrefix) || subscriptionName.equals(DEDUPLICATION_CURSOR_NAME)) {
        log.warn("[{}] Failed to create subscription for {}", topic, subscriptionName);
        future.completeExceptionally(new NamingException("Subscription with reserved subscription name attempted"));
        return future;
    }
    lock.readLock().lock();
    try {
        if (isFenced) {
            log.warn("[{}] Attempting to subscribe to a fenced topic", topic);
            future.completeExceptionally(new TopicFencedException("Topic is temporarily unavailable"));
            return future;
        }
        USAGE_COUNT_UPDATER.incrementAndGet(this);
        if (log.isDebugEnabled()) {
            log.debug("[{}] [{}] [{}] Added consumer -- count: {}", topic, subscriptionName, consumerName, USAGE_COUNT_UPDATER.get(this));
        }
    } finally {
        lock.readLock().unlock();
    }
    CompletableFuture<? extends Subscription> subscriptionFuture = // 
    isDurable ? // 
    getDurableSubscription(subscriptionName, initialPosition) : getNonDurableSubscription(subscriptionName, startMessageId);
    int maxUnackedMessages = isDurable ? brokerService.pulsar().getConfiguration().getMaxUnackedMessagesPerConsumer() : 0;
    subscriptionFuture.thenAccept(subscription -> {
        try {
            Consumer consumer = new Consumer(subscription, subType, topic, consumerId, priorityLevel, consumerName, maxUnackedMessages, cnx, cnx.getRole(), metadata, readCompacted, initialPosition);
            subscription.addConsumer(consumer);
            if (!cnx.isActive()) {
                consumer.close();
                if (log.isDebugEnabled()) {
                    log.debug("[{}] [{}] [{}] Subscribe failed -- count: {}", topic, subscriptionName, consumer.consumerName(), USAGE_COUNT_UPDATER.get(PersistentTopic.this));
                }
                future.completeExceptionally(new BrokerServiceException("Connection was closed while the opening the cursor "));
            } else {
                log.info("[{}][{}] Created new subscription for {}", topic, subscriptionName, consumerId);
                future.complete(consumer);
            }
        } catch (BrokerServiceException e) {
            if (e instanceof ConsumerBusyException) {
                log.warn("[{}][{}] Consumer {} {} already connected", topic, subscriptionName, consumerId, consumerName);
            } else if (e instanceof SubscriptionBusyException) {
                log.warn("[{}][{}] {}", topic, subscriptionName, e.getMessage());
            }
            USAGE_COUNT_UPDATER.decrementAndGet(PersistentTopic.this);
            future.completeExceptionally(e);
        }
    }).exceptionally(ex -> {
        log.warn("[{}] Failed to create subscription for {}: ", topic, subscriptionName, ex.getMessage());
        USAGE_COUNT_UPDATER.decrementAndGet(PersistentTopic.this);
        future.completeExceptionally(new PersistenceException(ex));
        return null;
    });
    return future;
}

Example 2 with BrokerServiceException

use of org.apache.pulsar.broker.service.BrokerServiceException in project incubator-pulsar by apache.

the class PersistentTopic method clearBacklog.

/**
 * Clears backlog for a given cursor in the topic.
 * <p>
 * Note: For a replication cursor, just provide the remote cluster name
 * </p>
 *
 * @param cursorName
 * @return
 */
public CompletableFuture<Void> clearBacklog(String cursorName) {
    log.info("[{}] Clearing backlog for cursor {} in the topic.", topic, cursorName);
    PersistentSubscription sub = getSubscription(cursorName);
    if (sub != null) {
        return sub.clearBacklog();
    }
    PersistentReplicator repl = (PersistentReplicator) getPersistentReplicator(cursorName);
    if (repl != null) {
        return repl.clearBacklog();
    }
    return FutureUtil.failedFuture(new BrokerServiceException("Cursor not found"));
}

Example 3 with BrokerServiceException

use of org.apache.pulsar.broker.service.BrokerServiceException in project incubator-pulsar by apache.

the class PersistentSubscription method resetCursor.

private void resetCursor(Position finalPosition, CompletableFuture<Void> future) {
    if (!IS_FENCED_UPDATER.compareAndSet(PersistentSubscription.this, FALSE, TRUE)) {
        future.completeExceptionally(new SubscriptionBusyException("Failed to fence subscription"));
        return;
    }
    final CompletableFuture<Void> disconnectFuture;
    if (dispatcher != null && dispatcher.isConsumerConnected()) {
        disconnectFuture = dispatcher.disconnectAllConsumers();
    } else {
        disconnectFuture = CompletableFuture.completedFuture(null);
    }
    disconnectFuture.whenComplete((aVoid, throwable) -> {
        if (throwable != null) {
            log.error("[{}][{}] Failed to disconnect consumer from subscription", topicName, subName, throwable);
            IS_FENCED_UPDATER.set(PersistentSubscription.this, FALSE);
            future.completeExceptionally(new SubscriptionBusyException("Failed to disconnect consumers from subscription"));
            return;
        }
        log.info("[{}][{}] Successfully disconnected consumers from subscription, proceeding with cursor reset", topicName, subName);
        try {
            cursor.asyncResetCursor(finalPosition, new AsyncCallbacks.ResetCursorCallback() {

                @Override
                public void resetComplete(Object ctx) {
                    if (log.isDebugEnabled()) {
                        log.debug("[{}][{}] Successfully reset subscription to position {}", topicName, subName, finalPosition);
                    }
                    IS_FENCED_UPDATER.set(PersistentSubscription.this, FALSE);
                    future.complete(null);
                }

                @Override
                public void resetFailed(ManagedLedgerException exception, Object ctx) {
                    log.error("[{}][{}] Failed to reset subscription to position {}", topicName, subName, finalPosition, exception);
                    IS_FENCED_UPDATER.set(PersistentSubscription.this, FALSE);
                    // or should we just ask user to retry one more time?
                    if (exception instanceof InvalidCursorPositionException) {
                        future.completeExceptionally(new SubscriptionInvalidCursorPosition(exception.getMessage()));
                    } else if (exception instanceof ConcurrentFindCursorPositionException) {
                        future.completeExceptionally(new SubscriptionBusyException(exception.getMessage()));
                    } else {
                        future.completeExceptionally(new BrokerServiceException(exception));
                    }
                }
            });
        } catch (Exception e) {
            log.error("[{}][{}] Error while resetting cursor", topicName, subName, e);
            IS_FENCED_UPDATER.set(PersistentSubscription.this, FALSE);
            future.completeExceptionally(new BrokerServiceException(e));
        }
    });
}

Example 4 with BrokerServiceException

use of org.apache.pulsar.broker.service.BrokerServiceException in project incubator-pulsar by apache.

the class NonPersistentTopic method subscribe.

@Override
public CompletableFuture<Consumer> subscribe(final ServerCnx cnx, String subscriptionName, long consumerId, SubType subType, int priorityLevel, String consumerName, boolean isDurable, MessageId startMessageId, Map<String, String> metadata, boolean readCompacted, InitialPosition initialPosition) {
    final CompletableFuture<Consumer> future = new CompletableFuture<>();
    if (hasBatchMessagePublished && !cnx.isBatchMessageCompatibleVersion()) {
        if (log.isDebugEnabled()) {
            log.debug("[{}] Consumer doesn't support batch-message {}", topic, subscriptionName);
        }
        future.completeExceptionally(new UnsupportedVersionException("Consumer doesn't support batch-message"));
        return future;
    }
    if (subscriptionName.startsWith(replicatorPrefix)) {
        log.warn("[{}] Failed to create subscription for {}", topic, subscriptionName);
        future.completeExceptionally(new NamingException("Subscription with reserved subscription name attempted"));
        return future;
    }
    if (readCompacted) {
        future.completeExceptionally(new NotAllowedException("readCompacted only valid on persistent topics"));
        return future;
    }
    lock.readLock().lock();
    try {
        if (isFenced) {
            log.warn("[{}] Attempting to subscribe to a fenced topic", topic);
            future.completeExceptionally(new TopicFencedException("Topic is temporarily unavailable"));
            return future;
        }
        USAGE_COUNT_UPDATER.incrementAndGet(this);
        if (log.isDebugEnabled()) {
            log.debug("[{}] [{}] [{}] Added consumer -- count: {}", topic, subscriptionName, consumerName, USAGE_COUNT_UPDATER.get(this));
        }
    } finally {
        lock.readLock().unlock();
    }
    NonPersistentSubscription subscription = subscriptions.computeIfAbsent(subscriptionName, name -> new NonPersistentSubscription(this, subscriptionName));
    try {
        Consumer consumer = new Consumer(subscription, subType, topic, consumerId, priorityLevel, consumerName, 0, cnx, cnx.getRole(), metadata, readCompacted, initialPosition);
        subscription.addConsumer(consumer);
        if (!cnx.isActive()) {
            consumer.close();
            if (log.isDebugEnabled()) {
                log.debug("[{}] [{}] [{}] Subscribe failed -- count: {}", topic, subscriptionName, consumer.consumerName(), USAGE_COUNT_UPDATER.get(NonPersistentTopic.this));
            }
            future.completeExceptionally(new BrokerServiceException("Connection was closed while the opening the cursor "));
        } else {
            log.info("[{}][{}] Created new subscription for {}", topic, subscriptionName, consumerId);
            future.complete(consumer);
        }
    } catch (BrokerServiceException e) {
        if (e instanceof ConsumerBusyException) {
            log.warn("[{}][{}] Consumer {} {} already connected", topic, subscriptionName, consumerId, consumerName);
        } else if (e instanceof SubscriptionBusyException) {
            log.warn("[{}][{}] {}", topic, subscriptionName, e.getMessage());
        }
        USAGE_COUNT_UPDATER.decrementAndGet(NonPersistentTopic.this);
        future.completeExceptionally(e);
    }
    return future;
}