protected void testPulsarFunctionality(String pulsarBrokerUrl) throws Exception { try ( PulsarClient client = PulsarClient.builder() .serviceUrl(pulsarBrokerUrl) .build(); Consumer consumer = client.newConsumer() .topic(TEST_TOPIC) .subscriptionName("test-subs") .subscribe(); Producer<byte[]> producer = client.newProducer() .topic(TEST_TOPIC) .create() ) { producer.send("test containers".getBytes()); CompletableFuture<Message> future = consumer.receiveAsync(); Message message = future.get(5, TimeUnit.SECONDS); assertThat(new String(message.getData())) .isEqualTo("test containers"); } }
private Producer createProducer(ProducerConfiguration configuration) throws Exception { PulsarClient client = PulsarClient.create(serviceUrl); return client.createProducer(defaultTopicName, configuration); }
PulsarClient createClient() throws PulsarClientException { return PulsarClient.builder() .serviceUrl(serviceUrl) .build(); }
List<Future<Producer<byte[]>>> futures = Lists.newArrayList(); ClientBuilder clientBuilder = PulsarClient.builder() // ProducerBuilder<byte[]> producerBuilder = client.newProducer() // .sendTimeout(0, TimeUnit.SECONDS) // client.close();
}; ClientBuilder clientBuilder = PulsarClient.builder() // ConsumerBuilder<byte[]> consumerBuilder = pulsarClient.newConsumer() // pulsarClient.close();
@Override public void shutdown() { try { producer.close(); pulsarClient.close(); } catch (final Exception ex) { } }
@Override public void start() { try { client = PulsarClient.builder() .serviceUrl(serviceUrl) .build(); log.info("Successfully created pulsar client to {}", serviceUrl); producer = client.newProducer(Schema.BYTES) .topic(topic) .create(); log.info("Successfully created producer to produce updates to topic {}", topic); reader = client.newReader(Schema.BYTES) .topic(topic) .startMessageId(MessageId.earliest) .create(); log.info("Successfully created reader to replay updates from topic {}", topic); CompletableFuture<Void> endFuture = new CompletableFuture<>(); readToEnd(endFuture); endFuture.join(); } catch (PulsarClientException e) { log.error("Failed to create pulsar client to cluster at {}", serviceUrl, e); throw new RuntimeException("Failed to create pulsar client to cluster at " + serviceUrl, e); } }
log.info("Pulsar driver configuration: {}", writer.writeValueAsString(config)); ClientBuilder clientBuilder = PulsarClient.builder().ioThreads(config.client.ioThreads) .connectionsPerBroker(config.client.connectionsPerBroker).statsInterval(0, TimeUnit.SECONDS) .serviceUrl(config.client.serviceUrl); producerBuilder = client.newProducer().enableBatching(config.producer.batchingEnabled) .batchingMaxPublishDelay(config.producer.batchingMaxPublishDelayMs, TimeUnit.MILLISECONDS) .blockIfQueueFull(config.producer.blockIfQueueFull)
Producer<byte[]> producer = client.newProducer().topic(topic).create(); client.close(); } catch (Exception e) { LOG.error("Error while producing messages");
Consumer<byte[]> consumer = client.newConsumer().topic(topic).subscriptionName(this.subscriptionName).subscriptionType(subscriptionType).subscribe(); client.close(); } catch (Exception e) { LOG.error("Error while consuming messages");
private ConsumerBuilder<byte[]> getConsumerConfiguration(PulsarClient client) { ConsumerBuilder<byte[]> builder = client.newConsumer(); if (queryParams.containsKey("ackTimeoutMillis")) { builder.ackTimeout(Integer.parseInt(queryParams.get("ackTimeoutMillis")), TimeUnit.MILLISECONDS); } if (queryParams.containsKey("subscriptionType")) { checkArgument(Enums.getIfPresent(SubscriptionType.class, queryParams.get("subscriptionType")).isPresent(), "Invalid subscriptionType %s", queryParams.get("subscriptionType")); builder.subscriptionType(SubscriptionType.valueOf(queryParams.get("subscriptionType"))); } if (queryParams.containsKey("receiverQueueSize")) { builder.receiverQueueSize(Math.min(Integer.parseInt(queryParams.get("receiverQueueSize")), 1000)); } if (queryParams.containsKey("consumerName")) { builder.consumerName(queryParams.get("consumerName")); } if (queryParams.containsKey("priorityLevel")) { builder.priorityLevel(Integer.parseInt(queryParams.get("priorityLevel"))); } return builder; }
public ContextImpl(InstanceConfig config, Logger logger, PulsarClient client, List<String> inputTopics) { this.config = config; this.logger = logger; this.currentAccumulatedMetrics = new ConcurrentHashMap<>(); this.accumulatedMetrics = new ConcurrentHashMap<>(); this.publishProducers = new HashMap<>(); this.inputTopics = inputTopics; this.topicSchema = new TopicSchema(client); this.producerBuilder = (ProducerBuilderImpl<?>) client.newProducer().blockIfQueueFull(true).enableBatching(true) .batchingMaxPublishDelay(1, TimeUnit.MILLISECONDS); if (config.getFunctionDetails().getUserConfig().isEmpty()) { userConfigs = new HashMap<>(); } else { userConfigs = new Gson().fromJson(config.getFunctionDetails().getUserConfig(), new TypeToken<Map<String, Object>>() { }.getType()); } }
private Producer getNewProducer() throws Exception { while (true) { try { return client.createProducer(topic, producerConf); } catch (Exception e) { Thread.sleep(10000); } } }
ReaderBuilder<byte[]> builder = service.getPulsarClient().newReader() .topic(topic.toString()) .startMessageId(getMessageId())
/** * Create a new PulsarClient object using default client configuration * * @param serviceUrl * the url of the Pulsar endpoint to be used * @return a new pulsar client object * @throws PulsarClientException.InvalidServiceURL * if the serviceUrl is invalid * @deprecated use {@link #builder()} to construct a client instance */ @Deprecated public static PulsarClient create(String serviceUrl) throws PulsarClientException { return create(serviceUrl, new ClientConfiguration()); }
private void updateConfig() throws UnsupportedAuthenticationException, MalformedURLException { ClientBuilder clientBuilder = PulsarClient.builder(); if (isNotBlank(this.authPluginClassName)) { clientBuilder.authentication(authPluginClassName, authParams); } clientBuilder.allowTlsInsecureConnection(this.tlsAllowInsecureConnection); clientBuilder.tlsTrustCertsFilePath(this.tlsTrustCertsFilePath); clientBuilder.serviceUrl(serviceURL); this.produceCommand.updateConfig(clientBuilder); this.consumeCommand.updateConfig(clientBuilder); }
@Override public void close() throws Exception { log.info("Shutting down Pulsar benchmark driver"); if (client != null) { client.close(); } if (adminClient != null) { adminClient.close(); } log.info("Pulsar benchmark driver successfully shut down"); }
Consumer<byte[]> createConsumer(PulsarClient client) throws PulsarClientException { return client.newConsumer() .topic(topic) .subscriptionName(subscriptionName) .subscriptionType(SubscriptionType.Failover) .subscribe(); } }
private ProducerBuilder<byte[]> getProducerBuilder(PulsarClient client) { ProducerBuilder<byte[]> builder = client.newProducer() .enableBatching(false) .messageRoutingMode(MessageRoutingMode.SinglePartition);