public List<Subscription> listSubscriptions(TopicName topicName) { return subscriptionRepository.listSubscriptions(topicName); }
public List<String> listSubscriptionNames(TopicName topicName) { return subscriptionRepository.listSubscriptionNames(topicName); }
Subscription getSubscription(SubscriptionName subscriptionName) { return subscriptionRepository.getSubscriptionDetails(subscriptionName); }
@Test public void shouldNotIncrementSharedCounterForNonExistingSubscription() { //given TopicName topicName = TopicName.fromQualifiedName("test.topic"); String subscriptionName = "sub"; doThrow(new SubscriptionNotExistsException(topicName, subscriptionName)) .when(subscriptionRepository).ensureSubscriptionExists(topicName, subscriptionName); //when storage.setSubscriptionDeliveredCounter(topicName, subscriptionName, 1L); //then verifyZeroInteractions(sharedCounter); }
public SubscriptionMetrics getSubscriptionMetrics(TopicName topicName, String subscriptionName) { subscriptionRepository.ensureSubscriptionExists(topicName, subscriptionName); return metricsRepository.loadMetrics(topicName, subscriptionName); }
@Override public void assignConsumerForSubscription(Subscription subscription) { try { Signal start = Signal.of(Signal.SignalType.START, subscription.getQualifiedName(), subscription); backgroundProcess.accept(start); if (subscription.getState() == PENDING) { subscriptionRepository.updateSubscriptionState(subscription.getTopicName(), subscription.getName(), ACTIVE); } } catch (RuntimeException e) { logger.error("Error during assigning subscription {} to consumer", subscription.getQualifiedName(), e); } }
@Override public void ensureSubscriptionExists(TopicName topicName, String subscriptionName) { if (!subscriptionExists(topicName, subscriptionName)) { throw new SubscriptionNotExistsException(topicName, subscriptionName); } }
public void createSubscription(Subscription subscription, String createdBy, CreatorRights creatorRights) { subscriptionValidator.checkCreation(subscription, creatorRights); subscriptionRepository.createSubscription(subscription); auditor.objectCreated(createdBy, subscription); subscriptionOwnerCache.onCreatedSubscription(subscription); }
public void removeSubscription(TopicName topicName, String subscriptionName, String removedBy) { subscriptionRepository.removeSubscription(topicName, subscriptionName); auditor.objectRemoved(removedBy, Subscription.class.getSimpleName(), subscriptionName); subscriptionOwnerCache.onRemovedSubscription(subscriptionName, topicName); }
public List<Subscription> getForOwnerId(OwnerId ownerId) { Collection<SubscriptionName> subscriptionNames = subscriptionOwnerCache.get(ownerId); return subscriptionRepository.getSubscriptionDetails(subscriptionNames); }
@Test public void shouldNotIncrementInflightCounterForNonExistingSubscription() { //given TopicName topicName = TopicName.fromQualifiedName("test.topic"); String subscriptionName = "sub"; doThrow(new SubscriptionNotExistsException(topicName, subscriptionName)) .when(subscriptionRepository).ensureSubscriptionExists(topicName, subscriptionName); //when storage.setInflightCounter(topicName, subscriptionName, 1L); //then verifyZeroInteractions(sharedCounter); } }
@Override public void setSubscriptionDeliveredCounter(TopicName topicName, String subscriptionName, long count) { try { subscriptionRepository.ensureSubscriptionExists(topicName, subscriptionName); incrementSharedCounter(subscriptionDeliveredCounter(topicName, subscriptionName), count); } catch (SubscriptionNotExistsException e) { LOGGER.debug("Trying to report metric on not existing subscription {} {}", topicName, subscriptionName); } }
private Stream<Subscription> notSuspendedSubscriptionsForTopic(Topic topic) { return subscriptionRepository.listSubscriptions(topic.getName()) .stream() .filter(sub -> Subscription.State.SUSPENDED != sub.getState()); } }
@Override public void assignConsumerForSubscription(Subscription subscription) { try { Signal start = Signal.of(Signal.SignalType.START, subscription.getQualifiedName(), subscription); backgroundProcess.accept(start); if (subscription.getState() == PENDING) { subscriptionRepository.updateSubscriptionState(subscription.getTopicName(), subscription.getName(), ACTIVE); } } catch (RuntimeException e) { logger.error("Error during assigning subscription {} to consumer", subscription.getQualifiedName(), e); } }
public Subscription getSubscriptionDetails(TopicName topicName, String subscriptionName) { return subscriptionRepository.getSubscriptionDetails(topicName, subscriptionName).anonymize(); }
@Override public void setSubscriptionDiscardedCounter(TopicName topicName, String subscriptionName, long count) { try { subscriptionRepository.ensureSubscriptionExists(topicName, subscriptionName); incrementSharedCounter(subscriptionDiscardedCounter(topicName, subscriptionName), count); } catch (SubscriptionNotExistsException e) { LOGGER.debug("Trying to report metric on not existing subscription {} {}", topicName, subscriptionName); } }
@Override public void start() { for(String groupName : groupRepository.listGroupNames()) { for(String topicName : topicRepository.listTopicNames(groupName)) { for(Subscription subscription : subscriptionRepository.listSubscriptions(new TopicName(groupName, topicName))) { subscriptions.put(subscription.getQualifiedName(), subscription); } } } } }
public List<UnhealthySubscription> getAllUnhealthy(boolean respectMonitoringSeverity) { Collection<SubscriptionName> subscriptionNames = subscriptionOwnerCache.getAll(); List<Subscription> subscriptions = subscriptionRepository.getSubscriptionDetails(subscriptionNames); return filterHealthy(subscriptions, respectMonitoringSeverity); }
@Override public PartitionOffsets getSubscriptionOffsets(TopicName topic, String subscriptionName, String brokersClusterName) { subscriptionRepository.ensureSubscriptionExists(topic, subscriptionName); String kafkaTopicsPath = paths.subscribedKafkaTopicsPath(topic, subscriptionName); PartitionOffsets allOffsets = new PartitionOffsets(); getZookeeperChildrenForPath(kafkaTopicsPath).stream().map(KafkaTopicName::valueOf).forEach(kafkaTopic -> allOffsets.addAll(getOffsetsForKafkaTopic(topic, kafkaTopic, subscriptionName, brokersClusterName)) ); return allOffsets; }
@Override public void setInflightCounter(TopicName topicName, String subscriptionName, long count) { try { subscriptionRepository.ensureSubscriptionExists(topicName, subscriptionName); distributedCounter.setCounterValue( pathsCompiler.compile(appendRootPath(SUBSCRIPTION_INFLIGHT_FULL_PATH), subscriptionPathContext(topicName, subscriptionName)), count); } catch (SubscriptionNotExistsException e) { LOGGER.debug("Trying to report metric on not existing subscription {} {}", topicName, subscriptionName); } }