Java Code Examples for software.amazon.awssdk.core.async.SdkPublisher#subscribe()

@Test
public void scanLimit() {
    insertRecords();

    SdkPublisher<Page<Record>> publisher = mappedTable.scan(r -> r.limit(5));
    publisher.subscribe(page -> page.items().forEach(item -> System.out.println(item)));

    List<Page<Record>> results = drainPublisher(publisher, 3);

    Page<Record> page1 = results.get(0);
    Page<Record> page2 = results.get(1);
    Page<Record> page3 = results.get(2);

    assertThat(page1.items(), is(RECORDS.subList(0, 5)));
    assertThat(page1.lastEvaluatedKey(), is(getKeyMap(4)));
    assertThat(page2.items(), is(RECORDS.subList(5, 10)));
    assertThat(page2.lastEvaluatedKey(), is(getKeyMap(9)));
    assertThat(page3.items(), is(empty()));
    assertThat(page3.lastEvaluatedKey(), is(nullValue()));
}
 

public static <T> List<T> drainPublisher(SdkPublisher<T> publisher, int expectedNumberOfResults) {
    BufferingSubscriber<T> subscriber = new BufferingSubscriber<>();
    publisher.subscribe(subscriber);
    subscriber.waitForCompletion(1000L);

    assertThat(subscriber.isCompleted(), is(true));
    assertThat(subscriber.bufferedError(), is(nullValue()));
    assertThat(subscriber.bufferedItems().size(), is(expectedNumberOfResults));

    return subscriber.bufferedItems();
}
 

@Override
public void onStream(SdkPublisher<ByteBuffer> publisher) {
    publisher.subscribe(new DrainingSubscriber<ByteBuffer>() {
        @Override
        public void onComplete() {
            transformFuture.complete(null);
        }
    });
}
 

@Override
public void onStream(SdkPublisher<ByteBuffer> publisher) {
    CompletableFuture<Subscription> dataSubscriptionFuture = new CompletableFuture<>();
    publisher.subscribe(new ByteSubscriber(dataSubscriptionFuture));
    dataSubscriptionFuture.thenAccept(dataSubscription -> {
        SdkPublisher<EventT> eventPublisher = new EventPublisher(dataSubscription);
        try {
            eventStreamResponseHandler.onEventStream(eventPublisher);
        } catch (Throwable t) {
            exceptionOccurred(t);
            dataSubscription.cancel();
        }
    });
}
 

@Override
public void onStream(SdkPublisher<ByteBuffer> publisher) {
  publisher.subscribe(new Subscriber<ByteBuffer>() {

    @Override
    public void onSubscribe(Subscription s) {
      s.request(Long.MAX_VALUE);
    }

    @Override
    public void onNext(ByteBuffer b) {
      int len = b.remaining();
      dst.setBytes(curOffset, b);
      curOffset += len;
    }

    @Override
    public void onError(Throwable error) {
      future.completeExceptionally(error);
    }

    @Override
    public void onComplete() {
      future.complete(null);
    }
  });
}
 

private void rejectSubscription(SdkPublisher<SubscribeToShardEventStream> publisher) {
    publisher.subscribe(new Subscriber<SubscribeToShardEventStream>() {
        Subscription localSub;

        @Override
        public void onSubscribe(Subscription s) {
            localSub = s;
            localSub.cancel();
        }

        @Override
        public void onNext(SubscribeToShardEventStream subscribeToShardEventStream) {
            localSub.cancel();
        }

        @Override
        public void onError(Throwable t) {
            localSub.cancel();
        }

        @Override
        public void onComplete() {
            localSub.cancel();
        }
    });
}
 

@Override
public void onEventStream(SdkPublisher<SubscribeToShardEventStream> publisher) {
    synchronized (parent.lockObject) {
        log.debug("{}: [SubscriptionLifetime]: (RecordFlow#onEventStream)  @ {} id: {} -- Subscribe",
                parent.shardId, connectionStartedAt, subscribeToShardId);
        if (!parent.isActiveFlow(this)) {
            this.isDisposed = true;
            log.debug(
                    "{}: [SubscriptionLifetime]: (RecordFlow#onEventStream) @ {} id: {} -- parent is disposed",
                    parent.shardId, connectionStartedAt, subscribeToShardId);
            parent.rejectSubscription(publisher);
            return;
        }

        try {
            log.debug(
                    "{}: [SubscriptionLifetime]: (RecordFlow#onEventStream) @ {} id: {} -- creating record subscription",
                    parent.shardId, connectionStartedAt, subscribeToShardId);
            subscription = new RecordSubscription(parent, this, connectionStartedAt, subscribeToShardId);
            publisher.subscribe(subscription);

            //
            // Only flip this once we succeed
            //
            parent.isFirstConnection = false;
        } catch (Throwable t) {
            log.debug(
                    "{}: [SubscriptionLifetime]: (RecordFlow#onEventStream) @ {} id: {} -- throwable during record subscription: {}",
                    parent.shardId, connectionStartedAt, subscribeToShardId, t.getMessage());
            parent.errorOccurred(this, t);
        }
    }
}
 

@Override
public void onStream(SdkPublisher<ByteBuffer> publisher) {
    publisher.subscribe(new CancelSubscriber(cf));
}
 

@Override
public void onStream(SdkPublisher<ByteBuffer> publisher) {
    // onStream may be called multiple times so reset the file channel every time
    this.fileChannel = invokeSafely(() -> createChannel(path));
    publisher.subscribe(new FileSubscriber(this.fileChannel, path, cf, this::exceptionOccurred));
}
 

@Override
public void onStream(SdkPublisher<ByteBuffer> publisher) {
    publisher.subscribe(new BaosSubscriber(cf));
}
 

@Override
public void onEventStream(SdkPublisher<Object> publisher) {
    publisher.subscribe(e -> {
    });
}