public boolean add(MessageId messageId) { writeLock.lock(); try { ConcurrentOpenHashSet<MessageId> partition = timePartitions.peekLast(); messageIdPartitionMap.put(messageId, partition); return partition.add(messageId); } finally { writeLock.unlock(); } }
public boolean add(MessageId m) { readLock.lock(); try { oldOpenSet.remove(m); return currentSet.add(m); } finally { readLock.unlock(); } }
@Override public void addProducer(Producer producer) throws BrokerServiceException { checkArgument(producer.getTopic() == this); lock.readLock().lock(); try { if (isFenced) { log.warn("[{}] Attempting to add producer to a fenced topic", topic); throw new TopicFencedException("Topic is temporarily unavailable"); } if (isProducersExceeded()) { log.warn("[{}] Attempting to add producer to topic which reached max producers limit", topic); throw new ProducerBusyException("Topic reached max producers limit"); } if (log.isDebugEnabled()) { log.debug("[{}] {} Got request to create producer ", topic, producer.getProducerName()); } if (!producers.add(producer)) { throw new NamingException( "Producer with name '" + producer.getProducerName() + "' is already connected to topic"); } USAGE_COUNT_UPDATER.incrementAndGet(this); if (log.isDebugEnabled()) { log.debug("[{}] [{}] Added producer -- count: {}", topic, producer.getProducerName(), USAGE_COUNT_UPDATER.get(this)); } } finally { lock.readLock().unlock(); } }
/** * If per-broker unack message reached to limit then it blocks dispatcher if its unack message limit has been * reached to {@link #maxUnackedMsgsPerDispatcher} * * @param dispatcher * @param numberOfMessages */ public void addUnAckedMessages(PersistentDispatcherMultipleConsumers dispatcher, int numberOfMessages) { // don't block dispatchers if maxUnackedMessages = 0 if (maxUnackedMessages > 0) { totalUnackedMessages.add(numberOfMessages); // block dispatcher: if broker is already blocked and dispatcher reaches to max dispatcher limit when broker // is blocked if (blockedDispatcherOnHighUnackedMsgs.get() && !dispatcher.isBlockedDispatcherOnUnackedMsgs() && dispatcher.getTotalUnackedMessages() > maxUnackedMsgsPerDispatcher) { lock.readLock().lock(); try { log.info("[{}] dispatcher reached to max unack msg limit on blocked-broker {}", dispatcher.getName(), dispatcher.getTotalUnackedMessages()); dispatcher.blockDispatcherOnUnackedMsgs(); blockedDispatchers.add(dispatcher); } finally { lock.readLock().unlock(); } } } }
public boolean addConsumer(ConsumerHandler consumer) { return topicConsumerMap .computeIfAbsent(consumer.getConsumer().getTopic(), topic -> new ConcurrentOpenHashSet<>()) .add(consumer); }
public boolean addProducer(ProducerHandler producer) { return topicProducerMap .computeIfAbsent(producer.getProducer().getTopic(), topic -> new ConcurrentOpenHashSet<>()) .add(producer); }
public boolean addReader(ReaderHandler reader) { return topicReaderMap.computeIfAbsent(reader.getConsumer().getTopic(), topic -> new ConcurrentOpenHashSet<>()) .add(reader); }
private void blockDispatchersWithLargeUnAckMessages() { lock.readLock().lock(); try { forEachTopic(topic -> { topic.getSubscriptions().forEach((subName, persistentSubscription) -> { if (persistentSubscription.getDispatcher() instanceof PersistentDispatcherMultipleConsumers) { PersistentDispatcherMultipleConsumers dispatcher = (PersistentDispatcherMultipleConsumers) persistentSubscription .getDispatcher(); int dispatcherUnAckMsgs = dispatcher.getTotalUnackedMessages(); if (dispatcherUnAckMsgs > maxUnackedMsgsPerDispatcher) { log.info("[{}] Blocking dispatcher due to reached max broker limit {}", dispatcher.getName(), dispatcher.getTotalUnackedMessages()); dispatcher.blockDispatcherOnUnackedMsgs(); blockedDispatchers.add(dispatcher); } } }); }); } finally { lock.readLock().unlock(); } }
if (!producers.add(producer)) { throw new NamingException( "Producer with name '" + producer.getProducerName() + "' is already connected to topic");