/** * @return a new list of all values (makes a copy) */ public List<V> values() { List<V> values = Lists.newArrayList(); forEach(value -> values.add(value)); return values; }
public UnAckedMessageTracker(PulsarClientImpl client, ConsumerBase consumerBase, long ackTimeoutMillis) { currentSet = new ConcurrentOpenHashSet<MessageIdImpl>(); oldOpenSet = new ConcurrentOpenHashSet<MessageIdImpl>(); readWriteLock = new ReentrantReadWriteLock(); readLock = readWriteLock.readLock(); writeLock = readWriteLock.writeLock(); start(client, consumerBase, ackTimeoutMillis); }
private static <V> void insertValueNoLock(V[] values, V value) { int bucket = (int) hash(value); while (true) { bucket = signSafeMod(bucket, values.length); V storedValue = values[bucket]; if (storedValue == EmptyValue) { // The bucket is empty, so we can use it values[bucket] = value; return; } ++bucket; } } }
public boolean remove(V value) { checkNotNull(value); long h = hash(value); return getSection(h).remove(value, (int) h); }
@Override public void run(Timeout t) throws Exception { if (isAckTimeout()) { log.warn("[{}] {} messages have timed-out", consumerBase, oldOpenSet.size()); Set<MessageIdImpl> messageIds = new HashSet<>(); oldOpenSet.forEach(messageIds::add); oldOpenSet.clear(); consumerBase.redeliverUnacknowledgedMessages(messageIds); } toggle(); timeout = client.timer().newTimeout(this, ackTimeoutMillis, TimeUnit.MILLISECONDS); } }, ackTimeoutMillis, TimeUnit.MILLISECONDS);
nsStats.producerCount += producers.size(); bundleStats.producerCount += producers.size(); destStatsStream.startObject(topic); producers.forEach(producer -> { producer.updateRates(); PublisherStats publisherStats = producer.getStats(); destStatsStream.writePair("producerCount", producers.size()); destStatsStream.writePair("averageMsgSize", topicStats.averageMsgSize); destStatsStream.writePair("msgRateIn", topicStats.aggMsgRateIn);
@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 (ledger.isTerminated()) { log.warn("[{}] Attempting to add producer to a terminated topic", topic); throw new TopicTerminatedException("Topic was already terminated"); } 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)); } // Start replication producers if not already startReplProducers(); } finally { lock.readLock().unlock(); } }
public boolean contains(V value) { checkNotNull(value); long h = hash(value); return getSection(h).contains(value, (int) h); }
@Override public void removeProducer(Producer producer) { checkArgument(producer.getTopic() == this); if (producers.remove(producer)) { // decrement usage only if this was a valid producer close USAGE_COUNT_UPDATER.decrementAndGet(this); if (log.isDebugEnabled()) { log.debug("[{}] [{}] Removed producer -- count: {}", topic, producer.getProducerName(), USAGE_COUNT_UPDATER.get(this)); } lastActive = System.nanoTime(); } }
private boolean isAckTimeout() { readLock.lock(); try { return !oldOpenSet.isEmpty(); } finally { readLock.unlock(); } }
@Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append('{'); final AtomicBoolean first = new AtomicBoolean(true); forEach(value -> { if (!first.getAndSet(false)) { sb.append(", "); } sb.append(value.toString()); }); sb.append('}'); return sb.toString(); }
public boolean add(V value) { checkNotNull(value); long h = hash(value); return getSection(h).add(value, (int) h); }
public PersistentTopic(String topic, ManagedLedger ledger, BrokerService brokerService) { this.topic = topic; this.ledger = ledger; this.brokerService = brokerService; this.producers = new ConcurrentOpenHashSet<Producer>(); this.subscriptions = new ConcurrentOpenHashMap<>(); this.replicators = new ConcurrentOpenHashMap<>(); this.isFenced = false; this.replicatorPrefix = brokerService.pulsar().getConfiguration().getReplicatorPrefix(); USAGE_COUNT_UPDATER.set(this, 0); for (ManagedCursor cursor : ledger.getCursors()) { if (cursor.getName().startsWith(replicatorPrefix)) { String localCluster = brokerService.pulsar().getConfiguration().getClusterName(); String remoteCluster = PersistentReplicator.getRemoteCluster(cursor.getName()); replicators.put(remoteCluster, new PersistentReplicator(this, cursor, localCluster, remoteCluster, brokerService)); } else { final String subscriptionName = Codec.decode(cursor.getName()); subscriptions.put(subscriptionName, new PersistentSubscription(this, subscriptionName, cursor)); // subscription-cursor gets activated by default: deactivate as there is no active subscription right // now subscriptions.get(subscriptionName).deactivateCursor(); } } this.lastActive = System.nanoTime(); }
private boolean hasLocalProducers() { AtomicBoolean foundLocal = new AtomicBoolean(false); producers.forEach(producer -> { if (!producer.isRemote()) { foundLocal.set(true); } }); return foundLocal.get(); }
private boolean hasRemoteProducers() { AtomicBoolean foundRemote = new AtomicBoolean(false); producers.forEach(producer -> { if (producer.isRemote()) { foundRemote.set(true); } }); return foundRemote.get(); }