public Subscription getSubscriptionDetails(TopicName topicName, String subscriptionName) { return subscriptionRepository.getSubscriptionDetails(topicName, subscriptionName).anonymize(); }
public SubscriptionMetrics getSubscriptionMetrics(TopicName topicName, String subscriptionName) { subscriptionRepository.ensureSubscriptionExists(topicName, subscriptionName); return metricsRepository.loadMetrics(topicName, subscriptionName); }
public List<Subscription> listSubscriptions(TopicName topicName) { return subscriptionRepository.listSubscriptions(topicName); }
public void updateSubscriptionState(TopicName topicName, String subscriptionName, Subscription.State state, String modifiedBy) { Subscription retrieved = subscriptionRepository.getSubscriptionDetails(topicName, subscriptionName); if (state != Subscription.State.PENDING && !retrieved.getState().equals(state)) { Subscription updated = Patch.apply(retrieved, PatchData.patchData().set("state", state).build()); subscriptionRepository.updateSubscription(updated); auditor.objectUpdated(modifiedBy, retrieved, updated); } }
private SubscriptionName createSubscription(SubscriptionName subscriptionName) { Subscription subscription = subscription(subscriptionName).build(); Group group = Group.from(subscription.getTopicName().getGroupName()); if (!groupRepository.groupExists(group.getGroupName())) { groupRepository.createGroup(group); } if (!topicRepository.topicExists(subscription.getTopicName())) { topicRepository.createTopic(topic(subscription.getTopicName()).build()); } subscriptionRepository.createSubscription(subscription); await().atMost(adjust(ONE_SECOND)).until( () -> { subscriptionRepository.subscriptionExists(subscription.getTopicName(), subscription.getName()); subscriptionsCaches.forEach(subscriptionsCache -> subscriptionsCache.listActiveSubscriptionNames().contains(subscriptionName)); } ); return subscription.getQualifiedName(); }
@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 void createSubscription(Subscription subscription, String createdBy, CreatorRights creatorRights) { subscriptionValidator.checkCreation(subscription, creatorRights); subscriptionRepository.createSubscription(subscription); auditor.objectCreated(createdBy, subscription); subscriptionOwnerCache.onCreatedSubscription(subscription); }
public List<String> listSubscriptionNames(TopicName topicName) { return subscriptionRepository.listSubscriptionNames(topicName); }
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 void updateSubscription(TopicName topicName, String subscriptionName, PatchData patch, String modifiedBy) { Subscription retrieved = subscriptionRepository.getSubscriptionDetails(topicName, subscriptionName); Subscription.State oldState = retrieved.getState(); Subscription updated = Patch.apply(retrieved, patch); revertStateIfChangedToPending(updated, oldState); subscriptionValidator.checkModification(updated); subscriptionOwnerCache.onUpdatedSubscription(retrieved, updated); if (!retrieved.equals(updated)) { subscriptionRepository.updateSubscription(updated); auditor.objectUpdated(modifiedBy, retrieved, updated); } }
@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 TopicMetrics loadMetrics(TopicName topicName) { String rateMetric = metricPath(RATE_PATTERN, topicName); String deliveryRateMetric = metricPath(DELIVERY_RATE_PATTERN, topicName); String throughputMetric = metricPath(THROUGHPUT_PATTERN, topicName); GraphiteMetrics metrics = graphiteClient.readMetrics(rateMetric, deliveryRateMetric); return TopicMetrics.Builder.topicMetrics() .withRate(metrics.metricValue(rateMetric)) .withDeliveryRate(metrics.metricValue(deliveryRateMetric)) .withPublished(sharedCounter.getValue(zookeeperPaths.topicMetricPath(topicName, "published"))) .withSubscriptions(subscriptionRepository.listSubscriptionNames(topicName).size()) .withThroughput(metrics.metricValue(throughputMetric)) .build(); }
public List<Subscription> getForOwnerId(OwnerId ownerId) { Collection<SubscriptionName> subscriptionNames = subscriptionOwnerCache.get(ownerId); return subscriptionRepository.getSubscriptionDetails(subscriptionNames); }
@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()); } }
Subscription getSubscription(SubscriptionName subscriptionName) { return subscriptionRepository.getSubscriptionDetails(subscriptionName); }
@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); } }
private void refillCache() { try { logger.info("Starting filling SubscriptionOwnerCache"); long start = System.currentTimeMillis(); Multimap<OwnerId, SubscriptionName> cache = ArrayListMultimap.create(); topicService.getAllTopics().stream() .flatMap(topic -> subscriptionRepository.listSubscriptions(topic.getName()).stream()) .forEach(subscription -> cache.put(subscription.getOwner(), subscription.getQualifiedName())); this.cache = Multimaps.synchronizedMultimap(cache); long end = System.currentTimeMillis(); logger.info("SubscriptionOwnerCache filled. Took {}ms", end - start); } catch (Exception e) { logger.error("Error while filling SubscriptionOwnerCache", e); } } }
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; }