Java SubscriptionType类代码示例

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
private ConsumerConfiguration getConsumerConfiguration() {
    ConsumerConfiguration conf = new ConsumerConfiguration();

    if (queryParams.containsKey("ackTimeoutMillis")) {
        conf.setAckTimeout(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"));
        conf.setSubscriptionType(SubscriptionType.valueOf(queryParams.get("subscriptionType")));
    }

    if (queryParams.containsKey("receiverQueueSize")) {
        conf.setReceiverQueueSize(Math.min(Integer.parseInt(queryParams.get("receiverQueueSize")), 1000));
    }

    if (queryParams.containsKey("consumerName")) {
        conf.setConsumerName(queryParams.get("consumerName"));
    }

    return conf;
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
@Test
public void testMockBrokerService() throws Exception {
    // test default actions of mock broker service
    try {
        PulsarClient client = PulsarClient.create("http://127.0.0.1:" + WEB_SERVICE_PORT);

        ConsumerConfiguration conf = new ConsumerConfiguration();
        conf.setSubscriptionType(SubscriptionType.Exclusive);
        Consumer consumer = client.subscribe("persistent://prop/use/ns/t1", "sub1", conf);

        Producer producer = client.createProducer("persistent://prop/use/ns/t1");
        Thread.sleep(ASYNC_EVENT_COMPLETION_WAIT);
        producer.send("message".getBytes());
        Thread.sleep(ASYNC_EVENT_COMPLETION_WAIT);

        consumer.unsubscribe();

        producer.close();
        consumer.close();
        client.close();
    } catch (Exception e) {
        fail("None of the mocked operations should throw a client side exception");
    }
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
private void subscribeSuccessAfterRetry(String topic) throws Exception {
    PulsarClient client = PulsarClient.create("http://127.0.0.1:" + WEB_SERVICE_PORT);
    final AtomicInteger counter = new AtomicInteger(0);

    mockBrokerService.setHandleSubscribe((ctx, subscribe) -> {
        if (counter.incrementAndGet() == 2) {
            ctx.writeAndFlush(Commands.newSuccess(subscribe.getRequestId()));
            return;
        }
        ctx.writeAndFlush(Commands.newError(subscribe.getRequestId(), ServerError.ServiceNotReady, "msg"));
    });

    try {
        ConsumerConfiguration conf = new ConsumerConfiguration();
        conf.setSubscriptionType(SubscriptionType.Exclusive);
        Consumer consumer = client.subscribe(topic, "sub1", conf);
    } catch (Exception e) {
        fail("Should not fail");
    }

    mockBrokerService.resetHandleSubscribe();
    client.close();
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
private void subscribeFailDoesNotFailOtherConsumer(String topic1, String topic2) throws Exception {
    PulsarClient client = PulsarClient.create("http://127.0.0.1:" + WEB_SERVICE_PORT);
    final AtomicInteger counter = new AtomicInteger(0);

    mockBrokerService.setHandleSubscribe((ctx, subscribe) -> {
        if (counter.incrementAndGet() == 2) {
            // fail second producer
            ctx.writeAndFlush(Commands.newError(subscribe.getRequestId(), ServerError.AuthenticationError, "msg"));
            return;
        }
        ctx.writeAndFlush(Commands.newSuccess(subscribe.getRequestId()));

    });

    ConsumerConfiguration conf = new ConsumerConfiguration();
    conf.setSubscriptionType(SubscriptionType.Exclusive);
    ConsumerBase consumer1 = (ConsumerBase) client.subscribe(topic1, "sub1", conf);

    ConsumerBase consumer2 = null;
    try {
        consumer2 = (ConsumerBase) client.subscribe(topic2, "sub1", conf);
        fail("Should have failed");
    } catch (Exception e) {
        // ok
    }

    assertTrue(consumer1.isConnected());
    assertFalse(consumer2 != null && consumer2.isConnected());

    mockBrokerService.resetHandleSubscribe();
    client.close();
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
@Test
public void testSingleClientMultipleSubscriptions() throws Exception {
    final String topicName = "persistent://prop/use/ns-abc/topic6";
    final String subName = "sub6";

    ConsumerConfiguration conf = new ConsumerConfiguration();
    conf.setSubscriptionType(SubscriptionType.Exclusive);

    pulsarClient.subscribe(topicName, subName, conf);
    pulsarClient.createProducer(topicName);
    try {
        pulsarClient.subscribe(topicName, subName, conf);
        fail("Should have thrown an exception since one consumer is already connected");
    } catch (PulsarClientException cce) {
        Assert.assertTrue(cce.getMessage().contains("Exclusive consumer is already connected"));
    }
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
@Test
public void testMultipleClientsMultipleSubscriptions() throws Exception {
    final String topicName = "persistent://prop/use/ns-abc/topic7";
    final String subName = "sub7";

    ConsumerConfiguration conf = new ConsumerConfiguration();
    conf.setSubscriptionType(SubscriptionType.Exclusive);

    PulsarClient client1 = PulsarClient.create(brokerUrl.toString());
    PulsarClient client2 = PulsarClient.create(brokerUrl.toString());

    try {
        client1.subscribe(topicName, subName, conf);
        client1.createProducer(topicName);

        client2.createProducer(topicName);

        client2.subscribe(topicName, subName, conf);
        fail("Should have thrown an exception since one consumer is already connected");
    } catch (PulsarClientException cce) {
        Assert.assertTrue(cce.getMessage().contains("Exclusive consumer is already connected"));
    } finally {
        client2.shutdown();
        client1.shutdown();
    }
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
@Override
protected void setup() throws Exception {
    super.internalSetup();
    super.producerBaseSetup();

    pulsarSpoutConf = new PulsarSpoutConfiguration();
    pulsarSpoutConf.setServiceUrl(serviceUrl);
    pulsarSpoutConf.setTopic(topic);
    pulsarSpoutConf.setSubscriptionName(subscriptionName);
    pulsarSpoutConf.setMessageToValuesMapper(messageToValuesMapper);
    pulsarSpoutConf.setFailedRetriesTimeout(1, TimeUnit.SECONDS);
    pulsarSpoutConf.setMaxFailedRetries(2);
    pulsarSpoutConf.setSharedConsumerEnabled(true);
    pulsarSpoutConf.setMetricsTimeIntervalInSecs(60);
    consumerConf = new ConsumerConfiguration();
    consumerConf.setSubscriptionType(SubscriptionType.Shared);
    spout = new PulsarSpout(pulsarSpoutConf, new ClientConfiguration(), consumerConf);
    mockCollector = new MockSpoutOutputCollector();
    SpoutOutputCollector collector = new SpoutOutputCollector(mockCollector);
    TopologyContext context = mock(TopologyContext.class);
    when(context.getThisComponentId()).thenReturn("test-spout-" + methodName);
    when(context.getThisTaskId()).thenReturn(0);
    spout.open(Maps.newHashMap(), context, collector);
    producer = pulsarClient.createProducer(topic);
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
@Test
public void testFailedConsumer() throws Exception {
    PulsarSpoutConfiguration pulsarSpoutConf = new PulsarSpoutConfiguration();
    pulsarSpoutConf.setServiceUrl(serviceUrl);
    pulsarSpoutConf.setTopic("persistent://invalidTopic");
    pulsarSpoutConf.setSubscriptionName(subscriptionName);
    pulsarSpoutConf.setMessageToValuesMapper(messageToValuesMapper);
    pulsarSpoutConf.setFailedRetriesTimeout(1, TimeUnit.SECONDS);
    pulsarSpoutConf.setMaxFailedRetries(2);
    pulsarSpoutConf.setSharedConsumerEnabled(false);
    pulsarSpoutConf.setMetricsTimeIntervalInSecs(60);
    ConsumerConfiguration consumerConf = new ConsumerConfiguration();
    consumerConf.setSubscriptionType(SubscriptionType.Shared);
    PulsarSpout spout = new PulsarSpout(pulsarSpoutConf, new ClientConfiguration(), consumerConf);
    MockSpoutOutputCollector mockCollector = new MockSpoutOutputCollector();
    SpoutOutputCollector collector = new SpoutOutputCollector(mockCollector);
    TopologyContext context = mock(TopologyContext.class);
    when(context.getThisComponentId()).thenReturn("new-test" + methodName);
    when(context.getThisTaskId()).thenReturn(0);
    try {
        spout.open(Maps.newHashMap(), context, collector);
        fail("should have failed as consumer creation failed");
    } catch (IllegalStateException e) {
        // Ok
    }
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
protected SubType getSubType() {
    SubscriptionType type = conf.getSubscriptionType();
    switch (type) {
    case Exclusive:
        return SubType.Exclusive;

    case Shared:
        return SubType.Shared;

    case Failover:
        return SubType.Failover;
    }

    // Should not happen since we cover all cases above
    return null;
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
    // Create a Pulsar client instance. A single instance can be shared across many
    // producers and consumer within the same application
    PulsarClient client = PulsarClient.create(SERVICE_URL);

    // Here you get the chance to configure consumer specific settings. eg:
    ConsumerConfiguration conf = new ConsumerConfiguration();

    // Allow multiple consumers to attache to the same subscription
    // and get messages dispatched as a Queue
    conf.setSubscriptionType(SubscriptionType.Shared);

    // Once the consumer is created, it can be used for the entire application life-cycle
    Consumer consumer = client.subscribe(TOPIC_NAME, SUBSCRIPTION_NAME, conf);
    log.info("Created Pulsar consumer");

    while (true) {
        // Wait until a message is available
        Message msg = consumer.receive();

        // Do something with the message
        String content = new String(msg.getData());
        log.info("Received message '{}' with msg-id={}", content, msg.getMessageId());

        // Acknowledge processing of message so that it can be deleted
        consumer.acknowledge(msg);
    }
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
public RawReaderImpl(PulsarClientImpl client, String topic, String subscription,
                     CompletableFuture<Consumer> consumerFuture) {
    this.client = client;
    this.subscription = subscription;
    this.topic = topic;

    consumerConfiguration = new ConsumerConfiguration();
    consumerConfiguration.setSubscriptionType(SubscriptionType.Exclusive);
    consumerConfiguration.setReceiverQueueSize(DEFAULT_RECEIVER_QUEUE_SIZE);

    consumer = new RawConsumerImpl(client, topic, subscription, consumerConfiguration,
                                   consumerFuture);
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
public void testBatchMessagesRateOut() throws PulsarClientException, InterruptedException, PulsarAdminException {
    log.info("-- Starting {} test --", methodName);
    String topicName = "persistent://my-property/cluster/my-ns/testBatchMessagesRateOut";
    double produceRate = 17;
    int batchSize = 5;
    ConsumerConfiguration consumerConf = new ConsumerConfiguration();
    consumerConf.setSubscriptionType(SubscriptionType.Exclusive);
    Consumer consumer = pulsarClient.subscribe(topicName, "my-subscriber-name", consumerConf);
    ProducerConfiguration producerConf = new ProducerConfiguration();
    producerConf.setBatchingMaxMessages(batchSize);
    producerConf.setBatchingEnabled(true);
    producerConf.setBatchingMaxPublishDelay(2, TimeUnit.SECONDS);

    Producer producer = pulsarClient.createProducer(topicName, producerConf);
    AtomicBoolean runTest = new AtomicBoolean(true);
    Thread t1 = new Thread(() -> {
        RateLimiter r = RateLimiter.create(produceRate);
        while (runTest.get()) {
            r.acquire();
            producer.sendAsync("Hello World".getBytes());
            consumer.receiveAsync().thenAccept(message -> consumer.acknowledgeAsync(message));
        }
    });
    t1.start();
    Thread.sleep(2000); // Two seconds sleep
    runTest.set(false);
    pulsar.getBrokerService().updateRates();
    double actualRate = admin.persistentTopics().getStats(topicName).msgRateOut;
    assertTrue(actualRate > (produceRate / batchSize));
    consumer.unsubscribe();
    log.info("-- Exiting {} test --", methodName);
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
@Test
public void testLookupWithDisconnection() throws Exception {
    final String brokerUrl = "pulsar://127.0.0.1:" + BROKER_SERVICE_PORT;
    PulsarClient client = PulsarClient.create(brokerUrl);
    final AtomicInteger counter = new AtomicInteger(0);
    String topic = "persistent://prop/use/ns/t1";

    mockBrokerService.setHandlePartitionLookup((ctx, lookup) -> {
        ctx.writeAndFlush(Commands.newPartitionMetadataResponse(0, lookup.getRequestId()));
    });

    mockBrokerService.setHandleLookup((ctx, lookup) -> {
        if (counter.incrementAndGet() == 1) {
            // piggyback unknown error to relay assertion failure
            ctx.close();
            return;
        }
        ctx.writeAndFlush(Commands.newLookupResponse(brokerUrl, null, true, LookupType.Connect,
                lookup.getRequestId(), false));
    });

    try {
        ConsumerConfiguration conf = new ConsumerConfiguration();
        conf.setSubscriptionType(SubscriptionType.Exclusive);
        Consumer consumer = client.subscribe(topic, "sub1", conf);
    } catch (Exception e) {
        if (e.getMessage().equals(ASSERTION_ERROR)) {
            fail("Subscribe should not retry on persistence error");
        }
        assertTrue(e instanceof PulsarClientException.BrokerPersistenceException);
    }
    mockBrokerService.resetHandlePartitionLookup();
    mockBrokerService.resetHandleLookup();
    client.close();

}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
private void subscribeFailWithoutRetry(String topic) throws Exception {
    PulsarClient client = PulsarClient.create("http://127.0.0.1:" + WEB_SERVICE_PORT);
    final AtomicInteger counter = new AtomicInteger(0);

    mockBrokerService.setHandleSubscribe((ctx, subscribe) -> {
        if (counter.incrementAndGet() == 2) {
            // piggyback unknown error to relay assertion failure
            ctx.writeAndFlush(
                    Commands.newError(subscribe.getRequestId(), ServerError.UnknownError, ASSERTION_ERROR));
            return;
        }
        ctx.writeAndFlush(Commands.newError(subscribe.getRequestId(), ServerError.PersistenceError, "msg"));
    });

    try {
        ConsumerConfiguration conf = new ConsumerConfiguration();
        conf.setSubscriptionType(SubscriptionType.Exclusive);
        Consumer consumer = client.subscribe(topic, "sub1", conf);
    } catch (Exception e) {
        if (e.getMessage().equals(ASSERTION_ERROR)) {
            fail("Subscribe should not retry on persistence error");
        }
        assertTrue(e instanceof PulsarClientException.BrokerPersistenceException);
    }
    mockBrokerService.resetHandleSubscribe();
    client.close();
}
 

import org.apache.pulsar.client.api.SubscriptionType; //导入依赖的package包/类
public void testSyncProducerAndConsumer(int batchMessageDelayMs) throws Exception {
    ConsumerConfiguration conf = new ConsumerConfiguration();
    conf.setSubscriptionType(SubscriptionType.Exclusive);
    Consumer consumer = pulsarClient.subscribe("persistent://my-property/use/my-ns/my-topic", "my-subscriber-name",
            conf);

    ProducerConfiguration producerConf = new ProducerConfiguration();

    if (batchMessageDelayMs != 0) {
        producerConf.setBatchingEnabled(true);
        producerConf.setBatchingMaxPublishDelay(batchMessageDelayMs, TimeUnit.MILLISECONDS);
        producerConf.setBatchingMaxMessages(5);
    }

    Producer producer = pulsarClient.createProducer("persistent://my-property/use/my-ns/my-topic", producerConf);
    for (int i = 0; i < 10; i++) {
        String message = "my-message-" + i;
        producer.send(message.getBytes());
    }

    Message msg = null;
    Set<String> messageSet = Sets.newHashSet();
    for (int i = 0; i < 10; i++) {
        msg = consumer.receive(5, TimeUnit.SECONDS);
        String receivedMessage = new String(msg.getData());
        log.debug("Received message: [{}]", receivedMessage);
        String expectedMessage = "my-message-" + i;
        testMessageOrderAndDuplicates(messageSet, receivedMessage, expectedMessage);
    }
    // Acknowledge the consumption of all messages at once
    consumer.acknowledgeCumulative(msg);
    consumer.close();
}