Tabnine Logo
SubscriptionRepository
Code IndexAdd Tabnine to your IDE (free)

How to use
SubscriptionRepository
in
pl.allegro.tech.hermes.domain.subscription

Best Java code snippets using pl.allegro.tech.hermes.domain.subscription.SubscriptionRepository (Showing top 20 results out of 315)

origin: allegro/hermes

public Subscription getSubscriptionDetails(TopicName topicName, String subscriptionName) {
  return subscriptionRepository.getSubscriptionDetails(topicName, subscriptionName).anonymize();
}
origin: allegro/hermes

public SubscriptionMetrics getSubscriptionMetrics(TopicName topicName, String subscriptionName) {
  subscriptionRepository.ensureSubscriptionExists(topicName, subscriptionName);
  return metricsRepository.loadMetrics(topicName, subscriptionName);
}
origin: allegro/hermes

public List<Subscription> listSubscriptions(TopicName topicName) {
  return subscriptionRepository.listSubscriptions(topicName);
}
origin: allegro/hermes

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);
  }
}
origin: allegro/hermes

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();
}
origin: allegro/hermes

@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);
  }
}
origin: allegro/hermes

public void createSubscription(Subscription subscription, String createdBy, CreatorRights creatorRights) {
  subscriptionValidator.checkCreation(subscription, creatorRights);
  subscriptionRepository.createSubscription(subscription);
  auditor.objectCreated(createdBy, subscription);
  subscriptionOwnerCache.onCreatedSubscription(subscription);
}
origin: allegro/hermes

public List<String> listSubscriptionNames(TopicName topicName) {
  return subscriptionRepository.listSubscriptionNames(topicName);
}
origin: allegro/hermes

public void removeSubscription(TopicName topicName, String subscriptionName, String removedBy) {
  subscriptionRepository.removeSubscription(topicName, subscriptionName);
  auditor.objectRemoved(removedBy, Subscription.class.getSimpleName(), subscriptionName);
  subscriptionOwnerCache.onRemovedSubscription(subscriptionName, topicName);
}
origin: allegro/hermes

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);
  }
}
origin: pl.allegro.tech.hermes/hermes-consumers

@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);
  }
}
origin: allegro/hermes

@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();
}
origin: allegro/hermes

public List<Subscription> getForOwnerId(OwnerId ownerId) {
  Collection<SubscriptionName> subscriptionNames = subscriptionOwnerCache.get(ownerId);
  return subscriptionRepository.getSubscriptionDetails(subscriptionNames);
}
origin: allegro/hermes

@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);
  }
}
origin: allegro/hermes

  private Stream<Subscription> notSuspendedSubscriptionsForTopic(Topic topic) {
    return subscriptionRepository.listSubscriptions(topic.getName())
        .stream()
        .filter(sub -> Subscription.State.SUSPENDED != sub.getState());
  }
}
origin: allegro/hermes

Subscription getSubscription(SubscriptionName subscriptionName) {
  return subscriptionRepository.getSubscriptionDetails(subscriptionName);
}
origin: allegro/hermes

@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);
  }
}
origin: allegro/hermes

  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);
    }
  }
}
origin: allegro/hermes

public List<UnhealthySubscription> getAllUnhealthy(boolean respectMonitoringSeverity) {
  Collection<SubscriptionName> subscriptionNames = subscriptionOwnerCache.getAll();
  List<Subscription> subscriptions = subscriptionRepository.getSubscriptionDetails(subscriptionNames);
  return filterHealthy(subscriptions, respectMonitoringSeverity);
}
origin: allegro/hermes

@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;
}
pl.allegro.tech.hermes.domain.subscriptionSubscriptionRepository

Most used methods

  • getSubscriptionDetails
  • ensureSubscriptionExists
  • listSubscriptions
  • createSubscription
  • updateSubscriptionState
  • listSubscriptionNames
  • removeSubscription
  • subscriptionExists
  • updateSubscription

Popular in Java

  • Updating database using SQL prepared statement
  • getSharedPreferences (Context)
  • requestLocationUpdates (LocationManager)
  • getSystemService (Context)
  • Runnable (java.lang)
    Represents a command that can be executed. Often used to run code in a different Thread.
  • BigDecimal (java.math)
    An immutable arbitrary-precision signed decimal.A value is represented by an arbitrary-precision "un
  • Permission (java.security)
    Legacy security code; do not use.
  • JButton (javax.swing)
  • LoggerFactory (org.slf4j)
    The LoggerFactory is a utility class producing Loggers for various logging APIs, most notably for lo
  • Option (scala)
  • Top PhpStorm plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now