How to use

SubscriptionRepository

in

pl.allegro.tech.hermes.domain.subscription

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;
}