repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/ConsumerRecord.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/ConsumerRecord.java | package dev.snowdrop.vertx.kafka;
import java.util.List;
public interface ConsumerRecord<K, V> {
String topic();
int partition();
long offset();
long timestamp();
TimestampType timestampType();
K key();
V value();
List<Header> headers();
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/PartitionInfo.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/PartitionInfo.java | package dev.snowdrop.vertx.kafka;
import java.util.List;
public interface PartitionInfo {
String getTopic();
long getPartition();
List<Node> getReplicas();
List<Node> getInSyncReplicas();
Node getLeader();
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/TimestampType.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/TimestampType.java | package dev.snowdrop.vertx.kafka;
public interface TimestampType {
int id();
String name();
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/KafkaProducer.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/KafkaProducer.java | package dev.snowdrop.vertx.kafka;
import java.util.function.Consumer;
import java.util.function.Function;
import dev.snowdrop.vertx.streams.WriteStream;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public interface KafkaProducer<K, V> extends WriteStream<ProducerRecord<K, V>> {
Mono<RecordMetadata> send(ProducerRecord<K, V> record);
Flux<PartitionInfo> partitionsFor(String topic);
Mono<Void> flush();
Mono<Void> close();
Mono<Void> close(long timeout);
<T> Mono<T> doOnVertxProducer(Function<io.vertx.kafka.client.producer.KafkaProducer<K, V>, T> function);
// WriteStream methods overload
KafkaProducer<K, V> exceptionHandler(Consumer<Throwable> handler);
KafkaProducer<K, V> drainHandler(Consumer<Void> handler);
KafkaProducer<K, V> setWriteQueueMaxSize(int maxSize);
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropProducerRecordBuilder.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropProducerRecordBuilder.java | package dev.snowdrop.vertx.kafka;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import org.springframework.util.StringUtils;
final class SnowdropProducerRecordBuilder<K, V> implements ProducerRecordBuilder<SnowdropProducerRecord<K, V>, K, V> {
private final String topic;
private final V value;
private final List<Header> headers;
private K key;
private Integer partition;
private Long timestamp;
SnowdropProducerRecordBuilder(String topic, V value) {
if (StringUtils.isEmpty(topic)) {
throw new IllegalArgumentException("Topic cannot be empty");
}
this.topic = topic;
this.value = value;
this.headers = new LinkedList<>();
}
@Override
public ProducerRecordBuilder<SnowdropProducerRecord<K, V>, K, V> withKey(K key) {
this.key = key;
return this;
}
@Override
public ProducerRecordBuilder<SnowdropProducerRecord<K, V>, K, V> withPartition(int partition) {
if (partition < 0) {
throw new IllegalArgumentException(
String.format("Invalid partition: %d. Partition number cannot be negative.", partition));
}
this.partition = partition;
return this;
}
@Override
public ProducerRecordBuilder<SnowdropProducerRecord<K, V>, K, V> withTimestamp(long timestamp) {
if (timestamp < 0) {
throw new IllegalArgumentException(
String.format("Invalid timestamp: %d. Timestamp cannot be negative.", timestamp));
}
this.timestamp = timestamp;
return this;
}
@Override
public ProducerRecordBuilder<SnowdropProducerRecord<K, V>, K, V> withHeader(Header header) {
Objects.requireNonNull(header, "Header cannot be null");
this.headers.add(header);
return this;
}
@Override
public ProducerRecordBuilder<SnowdropProducerRecord<K, V>, K, V> withHeaders(List<Header> headers) {
Objects.requireNonNull(headers, "Headers cannot be null");
this.headers.addAll(headers);
return this;
}
@Override
public SnowdropProducerRecord<K, V> build() {
return new SnowdropProducerRecord<>(key, value, topic, partition, timestamp, headers);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropTimestampType.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropTimestampType.java | package dev.snowdrop.vertx.kafka;
import java.util.Objects;
final class SnowdropTimestampType implements TimestampType {
private final int id;
private final String name;
SnowdropTimestampType(org.apache.kafka.common.record.TimestampType delegate) {
this.id = delegate.id;
this.name = delegate.name;
}
@Override
public int id() {
return id;
}
@Override
public String name() {
return name;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
SnowdropTimestampType that = (SnowdropTimestampType) o;
return id == that.id &&
Objects.equals(name, that.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropKafkaConsumer.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropKafkaConsumer.java | package dev.snowdrop.vertx.kafka;
import java.util.Collection;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import io.smallrye.mutiny.converters.multi.MultiReactorConverters;
import io.smallrye.mutiny.converters.uni.UniReactorConverters;
import io.vertx.core.streams.ReadStream;
import io.vertx.kafka.client.common.TopicPartition;
import io.vertx.kafka.client.consumer.OffsetAndMetadata;
import io.vertx.kafka.client.consumer.OffsetAndTimestamp;
import org.springframework.util.StringUtils;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
final class SnowdropKafkaConsumer<K, V> implements KafkaConsumer<K, V> {
private final io.vertx.mutiny.kafka.client.consumer.KafkaConsumer<K, V> delegate;
SnowdropKafkaConsumer(io.vertx.mutiny.kafka.client.consumer.KafkaConsumer<K, V> delegate) {
this.delegate = delegate;
}
@Override
public Mono<Void> subscribe(String topic) {
if (StringUtils.isEmpty(topic)) {
throw new IllegalArgumentException("Topic cannot be empty");
}
return delegate.subscribe(topic).convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Void> subscribe(Collection<String> topics) {
Objects.requireNonNull(topics, "Topics cannot be null");
return delegate.subscribe(new HashSet<>(topics)).convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Void> assign(Partition partition) {
Objects.requireNonNull(partition, "Partition cannot be null");
return delegate.assign(toVertxTopicPartition(partition)).convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Void> assign(Collection<Partition> partitions) {
Objects.requireNonNull(partitions, "Partitions cannot be null");
Set<TopicPartition> vertxPartitions = partitions
.stream()
.map(this::toVertxTopicPartition)
.collect(Collectors.toSet());
return delegate.assign(vertxPartitions).convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Void> unsubscribe() {
return delegate.unsubscribe().convert().with(UniReactorConverters.toMono());
}
@Override
public Flux<String> subscriptions() {
return UniReactorConverters.<Set<String>>toMono().apply(delegate.subscription())
.flatMapMany(Flux::fromIterable);
}
@Override
public Flux<Partition> assignments() {
return delegate.assignment()
.convert()
.with(UniReactorConverters.toMono())
.flatMapMany(Flux::fromIterable)
.map(SnowdropPartition::new);
}
@Override
public Flux<PartitionInfo> partitionsFor(String topic) {
if (StringUtils.isEmpty(topic)) {
throw new IllegalArgumentException("Topic cannot be empty");
}
return delegate.partitionsFor(topic)
.convert()
.with(UniReactorConverters.toMono())
.flatMapMany(Flux::fromIterable)
.map(SnowdropPartitionInfo::new);
}
@Override
public void partitionsRevokedHandler(Consumer<Set<Partition>> handler) {
Objects.requireNonNull(handler, "Handler cannot be null");
delegate.partitionsRevokedHandler(mutinyTopicPartitions -> {
Set<Partition> partitions = mutinyTopicPartitions
.stream()
.map(SnowdropPartition::new)
.collect(Collectors.toSet());
handler.accept(partitions);
});
}
@Override
public void partitionsAssignedHandler(Consumer<Set<Partition>> handler) {
Objects.requireNonNull(handler, "Handler cannot be null");
delegate.partitionsAssignedHandler(mutinyTopicPartitions -> {
Set<Partition> partitions = mutinyTopicPartitions
.stream()
.map(SnowdropPartition::new)
.collect(Collectors.toSet());
handler.accept(partitions);
});
}
@Override
public Mono<Void> seek(Partition partition, long offset) {
Objects.requireNonNull(partition, "Partition cannot be null");
if (offset < 0) {
throw new IllegalArgumentException("Offset cannot be negative");
}
return delegate.seek(toVertxTopicPartition(partition), offset).convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Void> seekToBeginning(Partition partition) {
Objects.requireNonNull(partition, "Partition cannot be null");
return delegate.seekToBeginning(toVertxTopicPartition(partition)).convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Void> seekToBeginning(Collection<Partition> partitions) {
Objects.requireNonNull(partitions, "Partitions cannot be null");
Set<TopicPartition> vertxPartitions = partitions
.stream()
.map(this::toVertxTopicPartition)
.collect(Collectors.toSet());
return delegate.seekToBeginning(vertxPartitions).convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Void> seekToEnd(Partition partition) {
Objects.requireNonNull(partition, "Partition cannot be null");
return delegate.seekToEnd(toVertxTopicPartition(partition)).convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Void> seekToEnd(Collection<Partition> partitions) {
Objects.requireNonNull(partitions, "Partitions cannot be null");
Set<TopicPartition> vertxPartitions = partitions
.stream()
.map(this::toVertxTopicPartition)
.collect(Collectors.toSet());
return delegate.seekToEnd(vertxPartitions).convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Long> position(Partition partition) {
Objects.requireNonNull(partition, "Partition cannot be null");
return delegate.position(toVertxTopicPartition(partition)).convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Long> committed(Partition partition) {
Objects.requireNonNull(partition, "Partition cannot be null");
return delegate.committed(toVertxTopicPartition(partition))
.convert()
.with(UniReactorConverters.toMono())
.map(OffsetAndMetadata::getOffset);
}
@Override
public Mono<Long> beginningOffset(Partition partition) {
Objects.requireNonNull(partition, "Partition cannot be null");
return delegate.beginningOffsets(toVertxTopicPartition(partition))
.convert()
.with(UniReactorConverters.toMono());
}
@Override
public Mono<Long> endOffset(Partition partition) {
Objects.requireNonNull(partition, "Partition cannot be null");
return delegate.endOffsets(toVertxTopicPartition(partition)).convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Long> timeOffset(Partition partition, long timestamp) {
Objects.requireNonNull(partition, "Partition cannot be null");
if (timestamp < 0) {
throw new IllegalArgumentException("Timestamp cannot be negative");
}
return delegate.offsetsForTimes(toVertxTopicPartition(partition), timestamp)
.convert()
.with(UniReactorConverters.toMono())
.map(OffsetAndTimestamp::getOffset);
}
@Override
public Mono<Void> commit() {
return delegate.commit().convert().with(UniReactorConverters.toMono());
}
@Override
public Mono<Void> close() {
return delegate.close().convert().with(UniReactorConverters.toMono());
}
@Override
@SuppressWarnings("unchecked") // SmallRye API returns KafkaConsumer without generics
public <T> Mono<T> doOnVertxConsumer(Function<io.vertx.kafka.client.consumer.KafkaConsumer<K, V>, T> function) {
Objects.requireNonNull(function, "Function cannot be null");
return Mono.create(sink -> {
try {
T result = function.apply((io.vertx.kafka.client.consumer.KafkaConsumer<K, V>) delegate.getDelegate());
sink.success(result);
} catch (Throwable t) {
sink.error(t);
}
});
}
@Override
public Mono<ConsumerRecord<K, V>> mono() {
return delegate.toMulti()
.convert()
.with(MultiReactorConverters.toMono())
.map(SnowdropConsumerRecord::new);
}
@Override
public Flux<ConsumerRecord<K, V>> flux() {
return delegate.toMulti()
.convert()
.with(MultiReactorConverters.toFlux())
.map(SnowdropConsumerRecord::new);
}
@Override
public ReadStream vertxReadStream() {
return delegate.getDelegate();
}
private TopicPartition toVertxTopicPartition(Partition partition) {
return new TopicPartition(partition.topic(), partition.partition());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropPartitionInfo.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropPartitionInfo.java | package dev.snowdrop.vertx.kafka;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
final class SnowdropPartitionInfo implements PartitionInfo {
private final String topic;
private final long partition;
private final List<Node> replicas;
private final List<Node> inSyncReplicas;
private final Node leader;
SnowdropPartitionInfo(io.vertx.kafka.client.common.PartitionInfo vertxPartitionInfo) {
this.topic = vertxPartitionInfo.getTopic();
this.partition = vertxPartitionInfo.getPartition();
this.replicas = (vertxPartitionInfo.getReplicas() == null
? new LinkedList<>()
: convertNodes(vertxPartitionInfo.getReplicas()));
this.inSyncReplicas = (vertxPartitionInfo.getInSyncReplicas() == null
? new LinkedList<>()
: convertNodes(vertxPartitionInfo.getInSyncReplicas()));
this.leader = (vertxPartitionInfo.getLeader() == null
? null
: new SnowdropNode(vertxPartitionInfo.getLeader()));
}
public String getTopic() {
return topic;
}
public long getPartition() {
return partition;
}
public List<Node> getReplicas() {
return replicas;
}
public List<Node> getInSyncReplicas() {
return inSyncReplicas;
}
public Node getLeader() {
return leader;
}
private List<Node> convertNodes(List<io.vertx.kafka.client.common.Node> vertxNodes) {
return vertxNodes.stream()
.map(SnowdropNode::new)
.collect(Collectors.toList());
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
SnowdropPartitionInfo that = (SnowdropPartitionInfo) o;
return partition == that.partition &&
Objects.equals(topic, that.topic) &&
Objects.equals(replicas, that.replicas) &&
Objects.equals(inSyncReplicas, that.inSyncReplicas) &&
Objects.equals(leader, that.leader);
}
@Override
public int hashCode() {
return Objects.hash(topic, partition, replicas, inSyncReplicas, leader);
}
@Override
public String toString() {
return String.format("%s{topic='%s', partition=%d, replicas=%s, inSyncReplicas=%s, leader=%s}",
getClass().getSimpleName(), topic, partition, replicas, inSyncReplicas, leader);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/ProducerRecordBuilder.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/ProducerRecordBuilder.java | package dev.snowdrop.vertx.kafka;
import java.util.List;
public interface ProducerRecordBuilder<T extends ProducerRecord<K, V>, K, V> {
ProducerRecordBuilder<T, K, V> withKey(K key);
ProducerRecordBuilder<T, K, V> withPartition(int partition);
ProducerRecordBuilder<T, K, V> withTimestamp(long timestamp);
ProducerRecordBuilder<T, K, V> withHeader(Header header);
ProducerRecordBuilder<T, K, V> withHeaders(List<Header> headers);
T build();
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropHeader.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropHeader.java | package dev.snowdrop.vertx.kafka;
import java.nio.charset.StandardCharsets;
import java.util.Objects;
import io.vertx.mutiny.core.buffer.Buffer;
import io.vertx.mutiny.kafka.client.producer.KafkaHeader;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.util.StringUtils;
final class SnowdropHeader implements Header {
private final String key;
private final DataBuffer value;
SnowdropHeader(String key, DataBuffer value) {
if (StringUtils.isEmpty(key)) {
throw new IllegalArgumentException("Header key cannot be empty");
}
this.key = key;
this.value = value;
}
SnowdropHeader(String key, String value) {
this(key, toDataBuffer(value));
}
SnowdropHeader(KafkaHeader mutinyHeader) {
this(mutinyHeader.key(), toDataBuffer(mutinyHeader.value()));
}
@Override
public String key() {
return key;
}
@Override
public DataBuffer value() {
return value;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
SnowdropHeader that = (SnowdropHeader) o;
return Objects.equals(key, that.key) && Objects.equals(value, that.value);
}
@Override
public int hashCode() {
return Objects.hash(key, value);
}
private static DataBuffer toDataBuffer(String string) {
if (string == null) {
return null;
}
return new DefaultDataBufferFactory().wrap(string.getBytes(StandardCharsets.UTF_8));
}
private static DataBuffer toDataBuffer(Buffer buffer) {
if (buffer == null) {
return null;
}
return new DefaultDataBufferFactory().wrap(buffer.getBytes());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/ProducerRecord.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/ProducerRecord.java | package dev.snowdrop.vertx.kafka;
import java.util.List;
public interface ProducerRecord<K, V> {
K key();
V value();
String topic();
Integer partition();
Long timestamp();
List<Header> headers();
static <K, V> ProducerRecordBuilder<? extends ProducerRecord<K, V>, K, V> builder(String topic, V value) {
return new SnowdropProducerRecordBuilder<K, V>(topic, value);
}
static <K, V> ProducerRecordBuilder<? extends ProducerRecord<K, V>, K, V> builder(String topic, V value, K key) {
return new SnowdropProducerRecordBuilder<K, V>(topic, value)
.withKey(key);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/KafkaProducerFactory.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/KafkaProducerFactory.java | package dev.snowdrop.vertx.kafka;
import java.util.Collections;
import java.util.Map;
public interface KafkaProducerFactory {
default <K, V> KafkaProducer<K, V> create() {
return create(Collections.emptyMap());
}
<K, V> KafkaProducer<K, V> create(Map<String, String> config);
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/RecordMetadata.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/RecordMetadata.java | package dev.snowdrop.vertx.kafka;
public interface RecordMetadata {
String topic();
long partition();
long offset();
long timestamp();
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropNode.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropNode.java | package dev.snowdrop.vertx.kafka;
import java.util.Objects;
final class SnowdropNode implements Node {
private int id;
private String idString;
private String host;
private int port;
private boolean hasRack;
private String rack;
private boolean isEmpty;
SnowdropNode(io.vertx.kafka.client.common.Node vertxNode) {
this.id = vertxNode.getId();
this.idString = vertxNode.getIdString();
this.host = vertxNode.getHost();
this.port = vertxNode.getPort();
this.hasRack = vertxNode.hasRack();
this.rack = vertxNode.rack();
this.isEmpty = vertxNode.isEmpty();
}
public int getId() {
return id;
}
public String getIdString() {
return idString;
}
public String getHost() {
return host;
}
public int getPort() {
return port;
}
public boolean hasRack() {
return hasRack;
}
public String getRack() {
return rack;
}
public boolean isEmpty() {
return isEmpty;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
SnowdropNode that = (SnowdropNode) o;
return id == that.id &&
port == that.port &&
hasRack == that.hasRack &&
isEmpty == that.isEmpty &&
Objects.equals(idString, that.idString) &&
Objects.equals(host, that.host) &&
Objects.equals(rack, that.rack);
}
@Override
public int hashCode() {
return Objects.hash(id, idString, host, port, hasRack, rack, isEmpty);
}
@Override
public String toString() {
return String.format("%s{id=%d, idString='%s', host='%s', port=%d, hasRack=%b, rack='%s', isEmpty=%b}",
getClass().getSimpleName(), id, idString, host, port, hasRack, rack, isEmpty);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropKafkaProducerFactory.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/SnowdropKafkaProducerFactory.java | package dev.snowdrop.vertx.kafka;
import java.util.Map;
import io.vertx.mutiny.core.Vertx;
final class SnowdropKafkaProducerFactory implements KafkaProducerFactory {
private final Vertx vertx;
private final KafkaProperties properties;
SnowdropKafkaProducerFactory(Vertx vertx, KafkaProperties properties) {
this.vertx = vertx;
this.properties = properties;
}
@Override
public <K, V> KafkaProducer<K, V> create(Map<String, String> config) {
Map<String, String> producerConfig = properties.getProducer();
producerConfig.putAll(config);
return new SnowdropKafkaProducer<>(
io.vertx.mutiny.kafka.client.producer.KafkaProducer.create(vertx, producerConfig));
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/KafkaConsumerFactory.java | vertx-spring-boot-starter-kafka/src/main/java/dev/snowdrop/vertx/kafka/KafkaConsumerFactory.java | package dev.snowdrop.vertx.kafka;
import java.util.Collections;
import java.util.Map;
public interface KafkaConsumerFactory {
default <K, V> KafkaConsumer<K, V> create() {
return create(Collections.emptyMap());
}
<K, V> KafkaConsumer<K, V> create(Map<String, String> config);
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/test/java/dev/snowdrop/vertx/mail/VertxMailClientTest.java | vertx-spring-boot-starter-mail/src/test/java/dev/snowdrop/vertx/mail/VertxMailClientTest.java | package dev.snowdrop.vertx.mail;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.StandardOpenOption;
import java.time.Duration;
import java.util.Arrays;
import io.smallrye.mutiny.Uni;
import io.vertx.core.MultiMap;
import io.vertx.core.buffer.Buffer;
import io.vertx.mutiny.core.Vertx;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class VertxMailClientTest {
private final DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
@Mock
private io.vertx.mutiny.ext.mail.MailClient mockMutinyMailClient;
private Vertx vertx;
private MailClient mailClient;
@BeforeEach
public void before() {
io.vertx.ext.mail.MailResult vertxResult = new io.vertx.ext.mail.MailResult();
vertxResult.setMessageID("1");
vertxResult.setRecipients(Arrays.asList("to@example.com", "cc@example.com", "bcc@example.com"));
given(mockMutinyMailClient.sendMail(any())).willReturn(Uni.createFrom().item(vertxResult));
vertx = Vertx.vertx();
MultiMapConverter multiMapConverter = new MultiMapConverter();
MailAttachmentConverter mailAttachmentConverter = new MailAttachmentConverter(vertx, multiMapConverter);
MailMessageConverter mailMessageConverter =
new MailMessageConverter(mailAttachmentConverter, multiMapConverter);
MailResultConverter mailResultConverter = new MailResultConverter();
mailClient = new VertxMailClient(mockMutinyMailClient, mailMessageConverter, mailResultConverter);
}
@Test
public void shouldSendMessageWithBasicFields() {
MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
headers.add("test", "example1");
headers.add("test", "example2");
MailMessage message = new SimpleMailMessage()
.setFrom("from@example.com")
.addTo("to@example.com")
.addCc("cc@example.com")
.addBcc("bcc@example.com")
.setBounceAddress("bounce@example.com")
.setSubject("Test subject")
.setText("Test text")
.setHtml("Test html")
.setHeaders(headers);
MailResult result = mailClient.send(message)
.blockOptional()
.orElseThrow(RuntimeException::new);
assertThat(result.getMessageId()).isEqualTo("1");
assertThat(result.getRecipients()).containsOnly("to@example.com", "cc@example.com", "bcc@example.com");
ArgumentCaptor<io.vertx.ext.mail.MailMessage> vertxMessageCaptor =
ArgumentCaptor.forClass(io.vertx.ext.mail.MailMessage.class);
verify(mockMutinyMailClient).sendMail(vertxMessageCaptor.capture());
assertMessage(message, vertxMessageCaptor.getValue());
}
@Test
public void shouldSendMessageWithAttachments() throws IOException {
MailAttachment bufferAttachment = getAttachmentTemplate()
.setData(Flux.just(getDataBuffer("Test buffer content 1"), getDataBuffer("Test buffer content 2")));
MailAttachment fileAttachment = getAttachmentTemplate()
.setFile(getFile("Test file content 1"));
MailAttachment inlineBufferAttachment = getAttachmentTemplate()
.setData(Flux.just(getDataBuffer("Test buffer content 3"), getDataBuffer("Test buffer content 4")));
MailAttachment inlineFileAttachment = getAttachmentTemplate()
.setFile(getFile("Test file content 2"));
MailMessage message = new SimpleMailMessage()
.addAttachment(bufferAttachment)
.addAttachment(fileAttachment)
.addInlineAttachment(inlineBufferAttachment)
.addInlineAttachment(inlineFileAttachment);
MailResult result = mailClient.send(message)
.blockOptional()
.orElseThrow(RuntimeException::new);
assertThat(result.getMessageId()).isEqualTo("1");
assertThat(result.getRecipients()).containsOnly("to@example.com", "cc@example.com", "bcc@example.com");
ArgumentCaptor<io.vertx.ext.mail.MailMessage> vertxMessageCaptor =
ArgumentCaptor.forClass(io.vertx.ext.mail.MailMessage.class);
verify(mockMutinyMailClient).sendMail(vertxMessageCaptor.capture());
assertMessage(message, vertxMessageCaptor.getValue());
}
@Test
public void shouldFailToSend() {
given(mockMutinyMailClient.sendMail(any())).willReturn(Uni.createFrom().failure(new RuntimeException("test")));
Mono<MailResult> result = mailClient.send(new SimpleMailMessage());
StepVerifier.create(result)
.expectNextCount(0)
.expectErrorMessage("test")
.verify();
}
private DataBuffer getDataBuffer(String content) {
return dataBufferFactory.wrap(content.getBytes());
}
private File getFile(String content) throws IOException {
File file = File.createTempFile("test", "tmp");
Files.write(file.toPath(), content.getBytes(), StandardOpenOption.WRITE);
return file;
}
private MailAttachment getAttachmentTemplate() {
MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
headers.add("test", "example1");
headers.add("test", "example2");
return new SimpleMailAttachment()
.setName("Test name")
.setContentType("Test content type")
.setDisposition("Test disposition")
.setContentId("Test id")
.setHeaders(headers);
}
private void assertMessage(MailMessage expected, io.vertx.ext.mail.MailMessage actual) {
assertThat(actual.getFrom()).isEqualTo(expected.getFrom());
assertThat(actual.getTo()).containsExactlyInAnyOrderElementsOf(expected.getTo());
assertThat(actual.getCc()).containsExactlyInAnyOrderElementsOf(expected.getCc());
assertThat(actual.getBcc()).containsExactlyInAnyOrderElementsOf(expected.getBcc());
assertThat(actual.getBounceAddress()).isEqualTo(expected.getBounceAddress());
assertThat(actual.getSubject()).isEqualTo(expected.getSubject());
assertThat(actual.getText()).isEqualTo(expected.getText());
assertThat(actual.getHtml()).isEqualTo(expected.getHtml());
assertHeaders(expected.getHeaders(), actual.getHeaders());
for (int i = 0; i < expected.getAttachments().size(); i++) {
assertAttachment(expected.getAttachments().get(i), actual.getAttachment().get(i));
}
for (int i = 0; i < expected.getInlineAttachments().size(); i++) {
assertAttachment(expected.getInlineAttachments().get(i), actual.getInlineAttachment().get(i));
}
}
private void assertAttachment(MailAttachment expected, io.vertx.ext.mail.MailAttachment actual) {
assertThat(actual.getName()).isEqualTo(expected.getName());
assertThat(actual.getDescription()).isEqualTo(expected.getDescription());
assertThat(actual.getContentId()).isEqualTo(expected.getContentId());
assertThat(actual.getContentType()).isEqualTo(expected.getContentType());
assertThat(actual.getDisposition()).isEqualTo(expected.getDisposition());
assertHeaders(expected.getHeaders(), actual.getHeaders());
if (expected.getFile() != null) {
assertData(expected.getFile(), actual.getData());
} else if (expected.getData() != null) {
assertData(expected.getData(), actual.getData());
} else {
assertThat(actual.getData()).isNull();
}
}
private void assertHeaders(MultiValueMap<String, String> expected, MultiMap actual) {
assertThat(actual.names()).containsExactlyInAnyOrderElementsOf(expected.keySet());
expected.forEach((k, v) -> assertThat(actual.getAll(k)).containsExactlyInAnyOrderElementsOf(v));
}
private void assertData(Flux<DataBuffer> expected, Buffer actual) {
byte[] expectedBytes = expected
.collectList()
.map(list -> dataBufferFactory.join(list).asByteBuffer().array())
.block();
assertThat(actual.getBytes()).containsExactly(expectedBytes);
}
private void assertData(File expected, Buffer actual) {
Buffer expectedBuffer = vertx
.fileSystem()
.readFile(expected.getAbsolutePath())
.await()
.atMost(Duration.ofSeconds(2))
.getDelegate();
assertThat(actual).isEqualTo(expectedBuffer);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/test/java/dev/snowdrop/vertx/mail/MailAutoConfigurationTest.java | vertx-spring-boot-starter-mail/src/test/java/dev/snowdrop/vertx/mail/MailAutoConfigurationTest.java | package dev.snowdrop.vertx.mail;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.test.context.SpringBootTest;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest
public class MailAutoConfigurationTest {
@Autowired
private MailClient mailClient;
@Test
public void shouldInjectBeans() {
assertThat(mailClient).isNotNull();
}
@SpringBootApplication
public static class TestApplication {
public static void main(String[] args) {
SpringApplication.run(TestApplication.class, args);
}
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/SimpleMailResult.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/SimpleMailResult.java | package dev.snowdrop.vertx.mail;
import java.util.List;
class SimpleMailResult implements MailResult {
private final String messageId;
private final List<String> recipients;
SimpleMailResult(String messageId, List<String> recipients) {
this.messageId = messageId;
this.recipients = recipients;
}
@Override
public String getMessageId() {
return messageId;
}
@Override
public List<String> getRecipients() {
return recipients;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailAttachment.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailAttachment.java | package dev.snowdrop.vertx.mail;
import java.io.File;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.util.MultiValueMap;
import reactor.core.publisher.Flux;
public interface MailAttachment {
String getName();
MailAttachment setName(String name);
String getContentType();
MailAttachment setContentType(String contentType);
String getDisposition();
MailAttachment setDisposition(String disposition);
String getDescription();
MailAttachment setDescription(String description);
String getContentId();
MailAttachment setContentId(String contentId);
Flux<DataBuffer> getData();
MailAttachment setData(Flux<DataBuffer> data);
File getFile();
MailAttachment setFile(File file);
MultiValueMap<String, String> getHeaders();
MailAttachment setHeaders(MultiValueMap<String, String> headers);
MailAttachment addHeader(String key, String... values);
MailAttachment removeHeader(String key);
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailResult.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailResult.java | package dev.snowdrop.vertx.mail;
import java.util.List;
public interface MailResult {
String getMessageId();
List<String> getRecipients();
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/VertxMailClient.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/VertxMailClient.java | package dev.snowdrop.vertx.mail;
import io.smallrye.mutiny.converters.uni.UniReactorConverters;
import reactor.core.publisher.Mono;
class VertxMailClient implements MailClient {
private final io.vertx.mutiny.ext.mail.MailClient delegate;
private final MailMessageConverter mailMessageConverter;
private final MailResultConverter mailResultConverter;
VertxMailClient(io.vertx.mutiny.ext.mail.MailClient delegate, MailMessageConverter mailMessageConverter,
MailResultConverter mailResultConverter) {
this.delegate = delegate;
this.mailMessageConverter = mailMessageConverter;
this.mailResultConverter = mailResultConverter;
}
@Override
public Mono<MailResult> send(MailMessage message) {
return mailMessageConverter
.toVertxMailMessage(message)
.flatMap(vertxMessage -> delegate.sendMail(vertxMessage)
.convert()
.with(UniReactorConverters.toMono()))
.map(mailResultConverter::fromVertxMailResult);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailMessageConverter.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailMessageConverter.java | package dev.snowdrop.vertx.mail;
import java.util.List;
import io.vertx.ext.mail.MailAttachment;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
class MailMessageConverter {
private final MailAttachmentConverter mailAttachmentConverter;
private final MultiMapConverter multiMapConverter;
MailMessageConverter(MailAttachmentConverter mailAttachmentConverter, MultiMapConverter multiMapConverter) {
this.mailAttachmentConverter = mailAttachmentConverter;
this.multiMapConverter = multiMapConverter;
}
Mono<io.vertx.ext.mail.MailMessage> toVertxMailMessage(MailMessage message) {
io.vertx.ext.mail.MailMessage delegateMessage = new io.vertx.ext.mail.MailMessage();
delegateMessage.setBounceAddress(message.getBounceAddress());
delegateMessage.setFrom(message.getFrom());
delegateMessage.setTo(message.getTo());
delegateMessage.setCc(message.getCc());
delegateMessage.setBcc(message.getBcc());
delegateMessage.setSubject(message.getSubject());
delegateMessage.setText(message.getText());
delegateMessage.setHtml(message.getHtml());
delegateMessage.setHeaders(multiMapConverter.fromMultiValueMap(message.getHeaders()));
Mono<List<MailAttachment>> attachmentsFuture = Flux
.fromIterable(message.getAttachments())
.flatMap(mailAttachmentConverter::toVertxMailAttachment)
.collectList()
.doOnNext(delegateMessage::setAttachment);
Mono<List<io.vertx.ext.mail.MailAttachment>> inlineAttachmentsFuture = Flux
.fromIterable(message.getInlineAttachments())
.flatMap(mailAttachmentConverter::toVertxMailAttachment)
.collectList()
.doOnNext(delegateMessage::setInlineAttachment);
return Mono.zip(inlineAttachmentsFuture, attachmentsFuture)
.thenReturn(delegateMessage);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/SimpleMailAttachment.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/SimpleMailAttachment.java | package dev.snowdrop.vertx.mail;
import java.io.File;
import java.util.Arrays;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import reactor.core.publisher.Flux;
public class SimpleMailAttachment implements MailAttachment {
private String name;
private String contentType;
private String disposition;
private String description;
private String contentId;
private Flux<DataBuffer> data;
private File file;
private MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
@Override
public String getName() {
return name;
}
@Override
public SimpleMailAttachment setName(String name) {
this.name = name;
return this;
}
@Override
public String getContentType() {
return contentType;
}
@Override
public SimpleMailAttachment setContentType(String contentType) {
this.contentType = contentType;
return this;
}
@Override
public String getDisposition() {
return disposition;
}
@Override
public SimpleMailAttachment setDisposition(String disposition) {
this.disposition = disposition;
return this;
}
@Override
public String getDescription() {
return description;
}
@Override
public SimpleMailAttachment setDescription(String description) {
this.description = description;
return this;
}
@Override
public String getContentId() {
return contentId;
}
@Override
public SimpleMailAttachment setContentId(String contentId) {
this.contentId = contentId;
return this;
}
@Override
public Flux<DataBuffer> getData() {
return data;
}
@Override
public SimpleMailAttachment setData(Flux<DataBuffer> data) {
this.data = data;
return this;
}
@Override
public File getFile() {
return file;
}
@Override
public SimpleMailAttachment setFile(File file) {
this.file = file;
return this;
}
@Override
public MultiValueMap<String, String> getHeaders() {
return headers;
}
@Override
public SimpleMailAttachment setHeaders(MultiValueMap<String, String> headers) {
if (headers == null) {
this.headers = new LinkedMultiValueMap<>();
} else {
this.headers = headers;
}
return this;
}
@Override
public SimpleMailAttachment addHeader(String key, String... values) {
if (key == null || values == null) {
throw new IllegalArgumentException("Cannot add header, key and value must not be null");
}
headers.addAll(key, Arrays.asList(values));
return this;
}
@Override
public SimpleMailAttachment removeHeader(String key) {
if (key == null) {
throw new IllegalArgumentException("Cannot remove header, key must not be null");
}
headers.remove(key);
return this;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailAutoConfiguration.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailAutoConfiguration.java | package dev.snowdrop.vertx.mail;
import io.vertx.core.Vertx;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableConfigurationProperties(MailProperties.class)
@ConditionalOnBean(Vertx.class)
@ConditionalOnProperty(prefix = "vertx.mail", value = "enabled", matchIfMissing = true)
public class MailAutoConfiguration {
@Bean
public MailClient mailClient(Vertx vertx, MailProperties properties) {
io.vertx.mutiny.core.Vertx mutinyVertx = new io.vertx.mutiny.core.Vertx(vertx);
io.vertx.mutiny.ext.mail.MailClient mutinyMailClient =
io.vertx.mutiny.ext.mail.MailClient.create(mutinyVertx, properties.getMailConfig());
return new VertxMailClient(mutinyMailClient, getMailMessageConverter(mutinyVertx), new MailResultConverter());
}
private MailMessageConverter getMailMessageConverter(io.vertx.mutiny.core.Vertx vertx) {
MultiMapConverter multiMapConverter = new MultiMapConverter();
MailAttachmentConverter mailAttachmentConverter = new MailAttachmentConverter(vertx, multiMapConverter);
return new MailMessageConverter(mailAttachmentConverter, multiMapConverter);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/SimpleMailMessage.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/SimpleMailMessage.java | package dev.snowdrop.vertx.mail;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
public class SimpleMailMessage implements MailMessage {
private String from;
private List<String> to = new ArrayList<>();
private List<String> cc = new ArrayList<>();
private List<String> bcc = new ArrayList<>();
private String bounceAddress;
private String subject;
private String text;
private String html;
private List<MailAttachment> inlineAttachments = new ArrayList<>();
private List<MailAttachment> attachments = new ArrayList<>();
private MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
private boolean fixedHeaders = false;
@Override
public String getFrom() {
return from;
}
@Override
public SimpleMailMessage setFrom(String from) {
this.from = from;
return this;
}
@Override
public List<String> getTo() {
return to;
}
@Override
public SimpleMailMessage setTo(List<String> to) {
if (to == null) {
this.to = new ArrayList<>();
} else {
this.to = to;
}
return this;
}
@Override
public SimpleMailMessage addTo(String... to) {
if (to != null) {
Collections.addAll(this.to, to);
}
return this;
}
@Override
public List<String> getCc() {
return cc;
}
@Override
public SimpleMailMessage setCc(List<String> cc) {
if (cc == null) {
this.cc = new ArrayList<>();
} else {
this.cc = cc;
}
return this;
}
@Override
public SimpleMailMessage addCc(String... cc) {
if (cc != null) {
Collections.addAll(this.cc, cc);
}
return this;
}
@Override
public List<String> getBcc() {
return bcc;
}
@Override
public SimpleMailMessage setBcc(List<String> bcc) {
if (bcc == null) {
this.bcc = new ArrayList<>();
} else {
this.bcc = bcc;
}
return this;
}
@Override
public SimpleMailMessage addBcc(String... bcc) {
if (bcc != null) {
Collections.addAll(this.bcc, bcc);
}
return this;
}
@Override
public String getBounceAddress() {
return bounceAddress;
}
@Override
public SimpleMailMessage setBounceAddress(String bounceAddress) {
this.bounceAddress = bounceAddress;
return this;
}
@Override
public String getSubject() {
return subject;
}
@Override
public SimpleMailMessage setSubject(String subject) {
this.subject = subject;
return this;
}
@Override
public String getText() {
return text;
}
@Override
public SimpleMailMessage setText(String text) {
this.text = text;
return this;
}
@Override
public String getHtml() {
return html;
}
@Override
public SimpleMailMessage setHtml(String html) {
this.html = html;
return this;
}
@Override
public List<MailAttachment> getInlineAttachments() {
return inlineAttachments;
}
@Override
public SimpleMailMessage setInlineAttachments(List<MailAttachment> inlineAttachments) {
if (inlineAttachments == null) {
this.inlineAttachments = new ArrayList<>();
} else {
this.inlineAttachments = inlineAttachments;
}
return this;
}
@Override
public SimpleMailMessage addInlineAttachment(MailAttachment inlineAttachment) {
if (inlineAttachment != null) {
inlineAttachments.add(inlineAttachment);
}
return this;
}
@Override
public List<MailAttachment> getAttachments() {
return attachments;
}
@Override
public SimpleMailMessage setAttachments(List<MailAttachment> attachments) {
if (attachments == null) {
this.attachments = new ArrayList<>();
} else {
this.attachments = attachments;
}
return this;
}
@Override
public SimpleMailMessage addAttachment(MailAttachment attachment) {
if (attachments != null) {
attachments.add(attachment);
}
return this;
}
@Override
public MultiValueMap<String, String> getHeaders() {
return headers;
}
@Override
public SimpleMailMessage setHeaders(MultiValueMap<String, String> headers) {
if (headers == null) {
this.headers = new LinkedMultiValueMap<>();
} else {
this.headers = headers;
}
return this;
}
@Override
public SimpleMailMessage addHeader(String key, String... values) {
if (key == null || values == null) {
throw new IllegalArgumentException("Cannot add header, key and value must not be null");
}
headers.addAll(key, Arrays.asList(values));
return this;
}
@Override
public SimpleMailMessage removeHeader(String key) {
if (key == null) {
throw new IllegalArgumentException("Cannot remove header, key must not be null");
}
headers.remove(key);
return this;
}
@Override
public boolean isFixedHeaders() {
return fixedHeaders;
}
@Override
public SimpleMailMessage setFixedHeaders(boolean fixedHeaders) {
this.fixedHeaders = fixedHeaders;
return this;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MultiMapConverter.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MultiMapConverter.java | package dev.snowdrop.vertx.mail;
import io.vertx.core.MultiMap;
import org.springframework.util.MultiValueMap;
class MultiMapConverter {
MultiMap fromMultiValueMap(MultiValueMap<String, String> multiValueMap) {
MultiMap multiMap = MultiMap.caseInsensitiveMultiMap();
multiValueMap.forEach(multiMap::add);
return multiMap;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailProperties.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailProperties.java | package dev.snowdrop.vertx.mail;
import io.vertx.ext.mail.LoginOption;
import io.vertx.ext.mail.MailConfig;
import io.vertx.ext.mail.StartTLSOptions;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties(prefix = MailProperties.PROPERTIES_PREFIX)
class MailProperties {
static final String PROPERTIES_PREFIX = "vertx.mail";
private boolean enabled = true;
private MailConfig delegate = new MailConfig();
/**
* @return whether mail starter is enabled.
*/
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
/**
* Get the hostname of the mail server.
*
* @return hostname
* @see MailConfig#getHostname()
*/
public String getHost() {
return delegate.getHostname();
}
public void setHost(String host) {
delegate.setHostname(host);
}
/**
* Get the port of the mail server.
*
* @return port
* @see MailConfig#getPort()
*/
public int getPort() {
return delegate.getPort();
}
public void setPort(int port) {
delegate.setPort(port);
}
/**
* Get security (TLS) options. Could be DISABLED, OPTIONAL or REQUIRED.
*
* @return the security options
* @see MailConfig#getStarttls()
*/
public String getStartTls() {
if (delegate.getStarttls() == null) {
return null;
}
return delegate.getStarttls().name();
}
public void setStartTls(String startTls) {
if (startTls != null) {
delegate.setStarttls(StartTLSOptions.valueOf(startTls.toUpperCase()));
}
}
/**
* Get login options. Could be DISABLED, NONE, REQUIRED or XOAUTH2.
*
* @return the login options
* @see MailConfig#getLogin()
*/
public String getLoginOption() {
if (delegate.getLogin() == null) {
return null;
}
return delegate.getLogin().name();
}
public void setLoginOption(String loginOption) {
if (loginOption != null) {
delegate.setLogin(LoginOption.valueOf(loginOption.toUpperCase()));
}
}
/**
* Get string of allowed auth methods, if set only these methods will be used
* if the server supports them. If null or empty all supported methods may be
* used
*
* @return the auth methods
* @see MailConfig#getAuthMethods()
*/
public String getAuthMethods() {
return delegate.getAuthMethods();
}
public void setAuthMethods(String authMethods) {
delegate.setAuthMethods(authMethods);
}
/**
* Get mail server username
*
* @return username
* @see MailConfig#getUsername()
*/
public String getUsername() {
return delegate.getUsername();
}
public void setUsername(String username) {
delegate.setUsername(username);
}
/**
* Get mail server password
*
* @return password
* @see MailConfig#getPassword()
*/
public String getPassword() {
return delegate.getPassword();
}
public void setPassword(String password) {
delegate.setPassword(password);
}
/**
* @return whether ssl is used on connect
* @see MailConfig#isSsl()
*/
public boolean isSsl() {
return delegate.isSsl();
}
public void setSsl(boolean ssl) {
delegate.setSsl(ssl);
}
/**
* @return whether to trust all certificates on ssl connect
* @see MailConfig#isTrustAll()
*/
public boolean isTrustAll() {
return delegate.isTrustAll();
}
public void setTrustAll(boolean trustAll) {
delegate.setTrustAll(trustAll);
}
/**
* Get a key store file name to be used when opening SMTP connections.
*
* @return key store
* @see MailConfig#getKeyStore()
*/
public String getKeystore() {
return delegate.getKeyStore();
}
public void setKeystore(String keystore) {
delegate.setKeyStore(keystore);
}
/**
* Get a key store password to be used when opening SMTP connections.
*
* @return a key store password
* @see MailConfig#getKeyStorePassword()
*/
public String getKeystorePassword() {
return delegate.getKeyStorePassword();
}
public void setKeystorePassword(String keystorePassword) {
delegate.setKeyStorePassword(keystorePassword);
}
/**
* Get a hostname to be used for HELO/EHLO and the Message-ID.
*
* @return my own hostname
* @see MailConfig#getOwnHostname()
*/
public String getOwnHostName() {
return delegate.getOwnHostname();
}
public void setOwnHostName(String ownHostName) {
delegate.setOwnHostname(ownHostName);
}
/**
* Get the max allowed number of open connections to the mail server. if not set, the default is 10.
*
* @return max pool size value
* @see MailConfig#getMaxPoolSize()
*/
public int getMaxPoolSize() {
return delegate.getMaxPoolSize();
}
public void setMaxPoolSize(int maxPoolSize) {
delegate.setMaxPoolSize(maxPoolSize);
}
/**
* Whether connection pool is enabled.
* Default: true.
* If the connection pooling is disabled, the max number of sockets is enforced nevertheless.
*
* @return keep alive value
* @see MailConfig#isKeepAlive()
*/
public boolean isKeepAlive() {
return delegate.isKeepAlive();
}
public void setKeepAlive(boolean keepAlive) {
delegate.setKeepAlive(keepAlive);
}
/**
* Whether sending allows rcpt errors (default is false).
* If true, the mail will be sent to the recipients that the server accepted, if any.
*
* @return whether sending allows rcpt errors
* @see MailConfig#isAllowRcptErrors()
*/
public boolean isAllowRcptErrors() {
return delegate.isAllowRcptErrors();
}
public void setAllowRcptErrors(boolean allowRcptErrors) {
delegate.setAllowRcptErrors(allowRcptErrors);
}
/**
* Whether ESMTP should be tried as first command (EHLO) (default is true)
* <p>
* rfc 1869 states that clients should always attempt EHLO as first command to determine if ESMTP
* is supported, if this returns an error code, HELO is tried to use old SMTP.
* If there is a server that does not support EHLO and does not give an error code back, the connection
* should be closed and retried with HELO. We do not do that and rather support turning off ESMTP with a
* setting. The odds of this actually happening are very small since the client will not connect to arbitrary
* smtp hosts on the internet. Since the client knows that is connects to a host that doesn't support ESMTP/EHLO
* in that way, the property has to be set to false.
*
* @return Wwhether ESMTP should be tried as first command
* @see MailConfig#isDisableEsmtp()
*/
public boolean isDisableEsmtp() {
return delegate.isDisableEsmtp();
}
public void setDisableEsmtp(boolean disableEsmtp) {
delegate.setDisableEsmtp(disableEsmtp);
}
MailConfig getMailConfig() {
return delegate;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailResultConverter.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailResultConverter.java | package dev.snowdrop.vertx.mail;
class MailResultConverter {
MailResult fromVertxMailResult(io.vertx.ext.mail.MailResult mailResult) {
return new SimpleMailResult(mailResult.getMessageID(), mailResult.getRecipients());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailMessage.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailMessage.java | package dev.snowdrop.vertx.mail;
import java.util.List;
import org.springframework.util.MultiValueMap;
public interface MailMessage {
String getFrom();
MailMessage setFrom(String from);
List<String> getTo();
MailMessage setTo(List<String> to);
MailMessage addTo(String... to);
List<String> getCc();
MailMessage setCc(List<String> cc);
MailMessage addCc(String... cc);
List<String> getBcc();
MailMessage setBcc(List<String> bcc);
MailMessage addBcc(String... bcc);
String getBounceAddress();
MailMessage setBounceAddress(String bounceAddress);
String getSubject();
MailMessage setSubject(String subject);
String getText();
MailMessage setText(String text);
String getHtml();
MailMessage setHtml(String html);
List<MailAttachment> getInlineAttachments();
MailMessage setInlineAttachments(List<MailAttachment> inlineAttachments);
MailMessage addInlineAttachment(MailAttachment inlineAttachment);
List<MailAttachment> getAttachments();
MailMessage setAttachments(List<MailAttachment> attachments);
MailMessage addAttachment(MailAttachment attachment);
MultiValueMap<String, String> getHeaders();
MailMessage setHeaders(MultiValueMap<String, String> headers);
MailMessage addHeader(String key, String... values);
MailMessage removeHeader(String key);
boolean isFixedHeaders();
MailMessage setFixedHeaders(boolean fixedHeaders);
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailAttachmentConverter.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailAttachmentConverter.java | package dev.snowdrop.vertx.mail;
import java.io.File;
import io.smallrye.mutiny.converters.multi.MultiReactorConverters;
import io.smallrye.mutiny.converters.uni.UniReactorConverters;
import io.vertx.core.file.OpenOptions;
import io.vertx.ext.mail.impl.MailAttachmentImpl;
import io.vertx.mutiny.core.Vertx;
import io.vertx.mutiny.core.buffer.Buffer;
import io.vertx.mutiny.core.file.AsyncFile;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.NettyDataBufferFactory;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
class MailAttachmentConverter {
private final Vertx vertx;
private final MultiMapConverter multiMapConverter;
private final MailAttachmentConverter mailAttachmentConverter=null;
MailAttachmentConverter(Vertx vertx, MultiMapConverter multiMapConverter) {
this.vertx = vertx;
this.multiMapConverter = multiMapConverter;
}
Mono<io.vertx.ext.mail.MailAttachment> toVertxMailAttachment(MailAttachment attachment) {
io.vertx.ext.mail.MailAttachment delegateAttachment = new MailAttachmentImpl();
delegateAttachment.setName(attachment.getName());
delegateAttachment.setContentType(attachment.getContentType());
delegateAttachment.setDisposition(attachment.getDisposition());
delegateAttachment.setDescription(attachment.getDescription());
delegateAttachment.setContentId(attachment.getContentId());
delegateAttachment.setHeaders(multiMapConverter.fromMultiValueMap(attachment.getHeaders()));
if (attachment.getFile() != null) {
return fileAttachmentToBuffer(attachment.getFile())
.map(Buffer::getDelegate)
.map(delegateAttachment::setData);
} else if (attachment.getData() != null) {
return dataBufferAttachmentToBuffer(attachment.getData())
.map(Buffer::getDelegate)
.map(delegateAttachment::setData);
}
return Mono.error(new IllegalArgumentException("Attachment has no data"));
}
private Mono<Buffer> dataBufferAttachmentToBuffer(Flux<DataBuffer> dataBufferStream) {
return dataBufferStream
.map(NettyDataBufferFactory::toByteBuf)
.map(Buffer::buffer)
.collect(Buffer::buffer, Buffer::appendBuffer);
}
private Mono<Buffer> fileAttachmentToBuffer(File file) {
return vertx.fileSystem()
.open(file.getAbsolutePath(), new OpenOptions().setRead(true).setCreate(false))
.convert()
.with(UniReactorConverters.toMono())
.flatMap(this::readAndCloseFile);
}
private Mono<Buffer> readAndCloseFile(AsyncFile asyncFile) {
return asyncFile.toMulti()
.convert()
.with(MultiReactorConverters.toFlux())
.collect(Buffer::buffer, Buffer::appendBuffer)
.doOnTerminate(asyncFile::close);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailClient.java | vertx-spring-boot-starter-mail/src/main/java/dev/snowdrop/vertx/mail/MailClient.java | package dev.snowdrop.vertx.mail;
import reactor.core.publisher.Mono;
public interface MailClient {
Mono<MailResult> send(MailMessage message);
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-actuator/src/test/java/dev/snowdrop/vertx/http/server/actuator/TestApplication.java | vertx-spring-boot-starter-actuator/src/test/java/dev/snowdrop/vertx/http/server/actuator/TestApplication.java | package dev.snowdrop.vertx.http.server.actuator;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerResponse;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;
import static org.springframework.web.reactive.function.server.ServerResponse.noContent;
@SpringBootApplication
public class TestApplication {
public static void main(String[] args) {
SpringApplication.run(TestApplication.class, args);
}
@Bean
public RouterFunction<ServerResponse> noopRouter() {
return route()
.GET("/", request -> noContent().build())
.build();
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-actuator/src/test/java/dev/snowdrop/vertx/http/server/actuator/ActuatorIT.java | vertx-spring-boot-starter-actuator/src/test/java/dev/snowdrop/vertx/http/server/actuator/ActuatorIT.java | package dev.snowdrop.vertx.http.server.actuator;
import dev.snowdrop.vertx.http.client.VertxClientHttpConnector;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.test.web.reactive.server.WebTestClient;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, properties = "management.server.port=8081")
public class ActuatorIT {
@LocalServerPort
private String port;
@Autowired
private VertxClientHttpConnector connector;
private WebTestClient client;
@BeforeEach
public void setUp() {
client = WebTestClient
.bindToServer(connector)
.baseUrl("http://localhost:" + port)
.build();
}
@Test
public void shouldGetActuatorHealthWithModifiedPort() {
client.get()
.uri(builder -> builder
.port("8081")
.path("/actuator/health")
.build())
.exchange()
.expectBody(String.class)
.value(org.hamcrest.Matchers.containsString("\"status\":\"UP\""));
client.get()
.exchange()
.expectStatus()
.isNoContent();
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-actuator/src/main/java/dev/snowdrop/vertx/http/server/actuator/VertxManagementChildContextConfiguration.java | vertx-spring-boot-starter-actuator/src/main/java/dev/snowdrop/vertx/http/server/actuator/VertxManagementChildContextConfiguration.java | package dev.snowdrop.vertx.http.server.actuator;
import dev.snowdrop.vertx.http.server.VertxReactiveWebServerFactoryCustomizer;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.boot.actuate.autoconfigure.web.ManagementContextConfiguration;
import org.springframework.boot.actuate.autoconfigure.web.ManagementContextType;
import org.springframework.boot.actuate.autoconfigure.web.server.ManagementWebServerFactoryCustomizer;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryCustomizer;
import org.springframework.boot.web.reactive.server.ConfigurableReactiveWebServerFactory;
import org.springframework.context.annotation.Bean;
@ManagementContextConfiguration(ManagementContextType.CHILD)
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE)
public class VertxManagementChildContextConfiguration {
@Bean
public VertxManagementChildContextConfiguration.VertxManagementWebServerFactoryCustomizer vertxManagementWebServerFactoryCustomizer(
ListableBeanFactory beanFactory) {
return new VertxManagementChildContextConfiguration.VertxManagementWebServerFactoryCustomizer(beanFactory);
}
class VertxManagementWebServerFactoryCustomizer extends
ManagementWebServerFactoryCustomizer<ConfigurableReactiveWebServerFactory> {
VertxManagementWebServerFactoryCustomizer(ListableBeanFactory beanFactory) {
super(beanFactory, ReactiveWebServerFactoryCustomizer.class, VertxReactiveWebServerFactoryCustomizer.class);
}
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/utils/BufferConverterTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/utils/BufferConverterTest.java | package dev.snowdrop.vertx.http.utils;
import io.netty.buffer.ByteBufAllocator;
import io.vertx.core.buffer.Buffer;
import org.junit.jupiter.api.Test;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.NettyDataBufferFactory;
import static org.assertj.core.api.Assertions.assertThat;
public class BufferConverterTest {
private NettyDataBufferFactory dataBufferFactory = new NettyDataBufferFactory(ByteBufAllocator.DEFAULT);
private BufferConverter converter = new BufferConverter(dataBufferFactory);
@Test
public void shouldGetDataBufferFactory() {
assertThat(converter.getDataBufferFactory()).isEqualTo(dataBufferFactory);
}
@Test
public void shouldConvertToBuffer() {
DataBuffer dataBuffer = dataBufferFactory.wrap("test".getBytes());
Buffer expectedBuffer = Buffer.buffer("test");
Buffer actualBuffer = converter.toBuffer(dataBuffer);
assertThat(actualBuffer).isEqualTo(expectedBuffer);
}
@Test
public void shouldConvertToDataBuffer() {
Buffer buffer = Buffer.buffer("test");
DataBuffer expectedDataBuffer = dataBufferFactory.wrap("test".getBytes());
DataBuffer actualDataBuffer = converter.toDataBuffer(buffer);
assertThat(actualDataBuffer).isEqualTo(expectedDataBuffer);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/common/ReadStreamFluxBuilderTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/common/ReadStreamFluxBuilderTest.java | package dev.snowdrop.vertx.http.common;
import java.util.function.Function;
import io.vertx.core.Handler;
import io.vertx.core.streams.ReadStream;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import reactor.core.publisher.Flux;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class ReadStreamFluxBuilderTest {
@Mock
private ReadStream<String> mockReadStream;
@Test
public void shouldNotAcceptNullReadStream() {
assertThatExceptionOfType(NullPointerException.class).isThrownBy(
() -> new ReadStreamFluxBuilder<String, String>().dataConverter(Function.identity()).build());
}
@Test
public void shouldNotAcceptNullDataConverter() {
assertThatExceptionOfType(NullPointerException.class).isThrownBy(
() -> new ReadStreamFluxBuilder<String, String>().readStream(mockReadStream).build());
}
@Test
public void shouldHandleData() {
given(mockReadStream.handler(any())).will(invocation -> {
Handler<String> handler = invocation.getArgument(0);
handler.handle("first");
handler.handle("second");
return mockReadStream;
});
given(mockReadStream.exceptionHandler(any())).willReturn(mockReadStream);
given(mockReadStream.endHandler(any())).will(invocation -> {
Handler<Void> handler = invocation.getArgument(0);
handler.handle(null);
return mockReadStream;
});
Flux<String> flux = new ReadStreamFluxBuilder<String, String>()
.readStream(mockReadStream)
.dataConverter(String::toUpperCase)
.build();
StepVerifier.create(flux)
.expectNext("FIRST")
.expectNext("SECOND")
.verifyComplete();
verify(mockReadStream).pause();
verify(mockReadStream).fetch(Long.MAX_VALUE);
}
@Test
public void shouldHandleException() {
given(mockReadStream.handler(any())).willReturn(mockReadStream);
given(mockReadStream.exceptionHandler(any())).will(invocation -> {
Handler<Throwable> handler = invocation.getArgument(0);
handler.handle(new RuntimeException("test"));
return mockReadStream;
});
given(mockReadStream.endHandler(any())).willReturn(mockReadStream);
Flux<String> flux = new ReadStreamFluxBuilder<String, String>()
.readStream(mockReadStream)
.dataConverter(String::toUpperCase)
.build();
StepVerifier.create(flux)
.verifyErrorMessage("test");
verify(mockReadStream).pause();
verify(mockReadStream).fetch(Long.MAX_VALUE);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/common/VertxWebSocketSessionTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/common/VertxWebSocketSessionTest.java | package dev.snowdrop.vertx.http.common;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import io.vertx.core.Handler;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.ServerWebSocket;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.web.reactive.socket.CloseStatus;
import org.springframework.web.reactive.socket.HandshakeInfo;
import org.springframework.web.reactive.socket.WebSocketMessage;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import reactor.test.publisher.TestPublisher;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class VertxWebSocketSessionTest {
@Mock
private ServerWebSocket mockServerWebSocket;
@Mock
private HandshakeInfo mockHandshakeInfo;
private final BufferConverter bufferConverter = new BufferConverter();
@Test
public void shouldReceiveTextMessages() {
initMockSocketHandlers();
given(mockServerWebSocket.textMessageHandler(any())).will(invocation -> {
Handler<String> handler = invocation.getArgument(0);
handler.handle("test1");
handler.handle("test2");
return mockServerWebSocket;
});
StepVerifier.create(getWebSocketSession().receive())
.expectNext(getWebSocketMessage(WebSocketMessage.Type.TEXT, "test1"))
.expectNext(getWebSocketMessage(WebSocketMessage.Type.TEXT, "test2"))
.verifyComplete();
}
@Test
public void shouldReceiveBinaryMessages() {
initMockSocketHandlers();
given(mockServerWebSocket.binaryMessageHandler(any())).will(invocation -> {
Handler<Buffer> handler = invocation.getArgument(0);
handler.handle(Buffer.buffer("test1"));
handler.handle(Buffer.buffer("test2"));
return mockServerWebSocket;
});
StepVerifier.create(getWebSocketSession().receive())
.expectNext(getWebSocketMessage(WebSocketMessage.Type.BINARY, "test1"))
.expectNext(getWebSocketMessage(WebSocketMessage.Type.BINARY, "test2"))
.verifyComplete();
}
@Test
public void shouldReceivePongMessages() {
initMockSocketHandlers();
given(mockServerWebSocket.pongHandler(any())).will(invocation -> {
Handler<Buffer> handler = invocation.getArgument(0);
handler.handle(Buffer.buffer("test1"));
handler.handle(Buffer.buffer("test2"));
return mockServerWebSocket;
});
StepVerifier.create(getWebSocketSession().receive())
.expectNext(getWebSocketMessage(WebSocketMessage.Type.PONG, "test1"))
.expectNext(getWebSocketMessage(WebSocketMessage.Type.PONG, "test2"))
.verifyComplete();
}
@Test
public void shouldSendTextMessage() {
TestPublisher<WebSocketMessage> source = TestPublisher.create();
Mono<Void> result = getWebSocketSession().send(source);
StepVerifier.create(result)
.expectSubscription()
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(getWebSocketMessage(WebSocketMessage.Type.TEXT, "test1")))
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(getWebSocketMessage(WebSocketMessage.Type.TEXT, "test2")))
.then(() -> source.assertMinRequested(1))
.then(source::complete)
.verifyComplete();
verify(mockServerWebSocket).writeTextMessage("test1");
verify(mockServerWebSocket).writeTextMessage("test2");
}
@Test
public void shouldSendBinaryMessage() {
TestPublisher<WebSocketMessage> source = TestPublisher.create();
Mono<Void> result = getWebSocketSession().send(source);
StepVerifier.create(result)
.expectSubscription()
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(getWebSocketMessage(WebSocketMessage.Type.BINARY, "test1")))
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(getWebSocketMessage(WebSocketMessage.Type.BINARY, "test2")))
.then(() -> source.assertMinRequested(1))
.then(source::complete)
.verifyComplete();
verify(mockServerWebSocket).writeBinaryMessage(Buffer.buffer("test1"));
verify(mockServerWebSocket).writeBinaryMessage(Buffer.buffer("test2"));
}
@Test
public void shouldSendPingMessage() {
TestPublisher<WebSocketMessage> source = TestPublisher.create();
Mono<Void> result = getWebSocketSession().send(source);
StepVerifier.create(result)
.expectSubscription()
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(getWebSocketMessage(WebSocketMessage.Type.PING, "test1")))
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(getWebSocketMessage(WebSocketMessage.Type.PING, "test2")))
.then(() -> source.assertMinRequested(1))
.then(source::complete)
.verifyComplete();
verify(mockServerWebSocket).writePing(Buffer.buffer("test1"));
verify(mockServerWebSocket).writePing(Buffer.buffer("test2"));
}
@Test
public void shouldSendPongMessage() {
TestPublisher<WebSocketMessage> source = TestPublisher.create();
Mono<Void> result = getWebSocketSession().send(source);
StepVerifier.create(result)
.expectSubscription()
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(getWebSocketMessage(WebSocketMessage.Type.PONG, "test1")))
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(getWebSocketMessage(WebSocketMessage.Type.PONG, "test2")))
.then(() -> source.assertMinRequested(1))
.then(source::complete)
.verifyComplete();
verify(mockServerWebSocket).writePong(Buffer.buffer("test1"));
verify(mockServerWebSocket).writePong(Buffer.buffer("test2"));
}
@Test
public void shouldClose() {
given(mockServerWebSocket.closeHandler(any())).will(invocation -> {
Handler<Void> handler = invocation.getArgument(0);
handler.handle(null);
return mockServerWebSocket;
});
getWebSocketSession().close(new CloseStatus(1000, "test")).block();
verify(mockServerWebSocket).close((short) 1000, "test");
}
private VertxWebSocketSession getWebSocketSession() {
return new VertxWebSocketSession(mockServerWebSocket, mockHandshakeInfo, bufferConverter, 1, 1);
}
private WebSocketMessage getWebSocketMessage(WebSocketMessage.Type type, String data) {
DataBuffer dataBuffer = bufferConverter.toDataBuffer(Buffer.buffer(data));
return new WebSocketMessage(type, dataBuffer);
}
private void initMockSocketHandlers() {
given(mockServerWebSocket.pause()).willReturn(mockServerWebSocket);
given(mockServerWebSocket.textMessageHandler(any())).willReturn(mockServerWebSocket);
given(mockServerWebSocket.binaryMessageHandler(any())).willReturn(mockServerWebSocket);
given(mockServerWebSocket.pongHandler(any())).willReturn(mockServerWebSocket);
given(mockServerWebSocket.exceptionHandler(any())).willReturn(mockServerWebSocket);
given(mockServerWebSocket.endHandler(any())).will(invocation -> {
Handler<Void> handler = invocation.getArgument(0);
handler.handle(null);
return mockServerWebSocket;
});
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/common/WriteStreamSubscriberTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/common/WriteStreamSubscriberTest.java | package dev.snowdrop.vertx.http.common;
import io.vertx.core.Handler;
import io.vertx.core.streams.WriteStream;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.reactivestreams.Subscriber;
import reactor.core.publisher.MonoSink;
import reactor.test.publisher.TestPublisher;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class WriteStreamSubscriberTest {
@Mock
private WriteStream<String> mockWriteStream;
@Mock
private MonoSink<Void> mockMonoSink;
private WriteStreamSubscriber<WriteStream<String>, String> subscriber;
@BeforeEach
public void setUp() {
subscriber = new WriteStreamSubscriber.Builder<WriteStream<String>, String>()
.writeStream(mockWriteStream)
.nextHandler(WriteStream::write)
.endHook(mockMonoSink)
.build();
}
@Test
public void shouldNotAllowNullWriteStream() {
assertThatExceptionOfType(NullPointerException.class).isThrownBy(
() -> new WriteStreamSubscriber.Builder<WriteStream<String>, String>().nextHandler((stream, value) -> {})
.endHook(mockMonoSink)
.build());
}
@Test
public void shouldNotAllowNullNextHandler() {
assertThatExceptionOfType(NullPointerException.class).isThrownBy(
() -> new WriteStreamSubscriber.Builder<WriteStream<String>, String>().writeStream(mockWriteStream)
.endHook(mockMonoSink)
.build());
}
@Test
public void shouldNotAllowNullEndHook() {
assertThatExceptionOfType(NullPointerException.class).isThrownBy(
() -> new WriteStreamSubscriber.Builder<WriteStream<String>, String>().writeStream(mockWriteStream)
.nextHandler((stream, value) -> {})
.build());
}
@Test
public void shouldRegisterExceptionHandlerInConstructor() {
verify(mockWriteStream).exceptionHandler(any(Handler.class));
}
@Test
public void shouldHandleOnSubscribe() {
TestPublisher<String> publisher = TestPublisher.create();
publisher.subscribe(subscriber);
publisher.assertMinRequested(1);
verify(mockWriteStream).drainHandler(any(Handler.class));
}
@Test
public void shouldWriteAndRequestOnNext() {
TestPublisher<String> publisher = TestPublisher.create();
publisher.subscribe(subscriber);
publisher.next("test");
verify(mockWriteStream).write("test");
publisher.assertMinRequested(1);
}
@Test
public void shouldNotRequestIfFull() {
given(mockWriteStream.writeQueueFull()).willReturn(true);
TestPublisher<String> publisher = TestPublisher.create();
publisher.subscribe(subscriber);
publisher.assertMinRequested(0);
}
@Test
public void shouldWriteMultipleAndNotRequestIfFull() {
given(mockWriteStream.writeQueueFull()).willReturn(false, false, true);
subscriber = new WriteStreamSubscriber.Builder<WriteStream<String>, String>()
.writeStream(mockWriteStream)
.nextHandler(WriteStream::write)
.endHook(mockMonoSink)
.requestLimit(2)
.build();
TestPublisher<String> publisher = TestPublisher.create();
publisher.subscribe(subscriber);
publisher.assertMinRequested(2);
publisher.assertMaxRequested(2);
publisher.next("test1");
publisher.assertMinRequested(2);
publisher.assertMaxRequested(2);
publisher.next("test2");
publisher.assertMinRequested(1);
publisher.assertMaxRequested(1);
publisher.next("test3");
publisher.assertMinRequested(0);
publisher.assertMaxRequested(0);
verify(mockWriteStream).write("test1");
verify(mockWriteStream).write("test2");
verify(mockWriteStream).write("test3");
}
@Test
public void shouldHandleComplete() {
TestPublisher<String> publisher = TestPublisher.create();
publisher.subscribe(subscriber);
publisher.complete();
verify(mockMonoSink).success();
}
@Test
public void shouldHandleCancel() {
TestPublisher<String> publisher = TestPublisher.create();
publisher.subscribe(subscriber);
subscriber.cancel();
verify(mockMonoSink).success();
}
@Test
public void shouldHandleError() {
TestPublisher<String> publisher = TestPublisher.create();
publisher.subscribe(subscriber);
RuntimeException exception = new RuntimeException("test");
publisher.error(exception);
verify(mockMonoSink).error(exception);
}
@Test
public void verifyCompleteFlow() {
TestWriteStream<String> writeStream = new TestWriteStream<>();
TestPublisher<String> publisher = TestPublisher.create();
Subscriber<String> subscriber = new WriteStreamSubscriber.Builder<WriteStream<String>, String>()
.writeStream(writeStream)
.nextHandler(WriteStream::write)
.endHook(mockMonoSink)
.build();
writeStream.setWriteQueueMaxSize(2);
publisher.subscribe(subscriber);
publisher.assertMinRequested(1);
publisher.next("first");
publisher.assertMinRequested(1);
publisher.next("second");
publisher.assertMinRequested(0);
assertThat(writeStream.getReceived()).containsOnly("first", "second");
writeStream.clearReceived();
publisher.assertMinRequested(1);
publisher.next("third");
assertThat(writeStream.getReceived()).containsOnly("third");
publisher.complete();
verify(mockMonoSink).success();
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/common/TestWriteStream.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/common/TestWriteStream.java | package dev.snowdrop.vertx.http.common;
import java.util.ArrayList;
import java.util.List;
import io.vertx.core.AsyncResult;
import io.vertx.core.Future;
import io.vertx.core.Handler;
import io.vertx.core.streams.WriteStream;
public class TestWriteStream<T> implements WriteStream<T> {
private int maxSize;
private List<T> received = new ArrayList<>();
private Handler<Void> drainHandler;
public List<T> getReceived() {
return received;
}
public void clearReceived() {
boolean callDrain = writeQueueFull();
received = new ArrayList<>();
if (callDrain && drainHandler != null) {
drainHandler.handle(null);
}
}
@Override
public TestWriteStream<T> setWriteQueueMaxSize(int maxSize) {
this.maxSize = maxSize;
return this;
}
@Override
public boolean writeQueueFull() {
return received.size() >= maxSize;
}
@Override
public TestWriteStream<T> drainHandler(Handler<Void> handler) {
this.drainHandler = handler;
return this;
}
@Override
public Future<Void> write(T data) {
received.add(data);
return Future.succeededFuture();
}
@Override
public void write(T data, Handler<AsyncResult<Void>> handler) {
received.add(data);
handler.handle(Future.succeededFuture());
}
@Override
public TestWriteStream<T> exceptionHandler(Handler<Throwable> handler) {
return this;
}
@Override
public Future<Void> end() {
return null;
}
@Override
public void end(Handler<AsyncResult<Void>> handler) {
handler.handle(Future.succeededFuture());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/HttpServerPropertiesIT.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/HttpServerPropertiesIT.java | package dev.snowdrop.vertx.http.it;
import java.util.HashMap;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
import dev.snowdrop.vertx.http.server.properties.HttpServerProperties;
import io.vertx.core.http.ClientAuth;
import io.vertx.core.http.HttpVersion;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class HttpServerPropertiesIT extends TestBase {
@AfterEach
public void tearDown() {
stopServer();
}
@Test
public void verifyHttpServerProperties() {
Properties originalProperties = new Properties();
originalProperties.setProperty("vertx.http.server.host", "localhost");
originalProperties.setProperty("vertx.http.server.port", "8082");
originalProperties.setProperty("vertx.http.server.client-auth", "REQUIRED");
originalProperties.setProperty("vertx.http.server.sni", "true");
originalProperties.setProperty("vertx.http.server.alpn-versions", "HTTP_1_1,HTTP_2");
originalProperties.setProperty("vertx.http.server.http2-extra-settings.1", "10");
originalProperties.setProperty("vertx.http.server.http2-extra-settings.2", "20");
originalProperties.setProperty("vertx.http.server.idle-timeout-unit", "HOURS");
originalProperties.setProperty("vertx.http.server.enabled-cipher-suites", "cipher1,cipher2");
startServerWithoutSecurity(originalProperties);
HttpServerProperties expectedProperties = getBean(HttpServerProperties.class);
assertThat(expectedProperties.getPort()).isEqualTo(8082);
assertThat(expectedProperties.getHost()).isEqualTo("localhost");
assertThat(expectedProperties.getClientAuth()).isEqualTo(ClientAuth.REQUIRED);
assertThat(expectedProperties.isSni()).isTrue();
assertThat(expectedProperties.getAlpnVersions()).containsOnly(HttpVersion.HTTP_1_1, HttpVersion.HTTP_2);
assertThat(expectedProperties.getHttp2ExtraSettings())
.containsOnly(new HashMap.SimpleEntry<>(1, 10L), new HashMap.SimpleEntry<>(2, 20L));
assertThat(expectedProperties.getIdleTimeoutUnit()).isEqualTo(TimeUnit.HOURS);
assertThat(expectedProperties.getEnabledCipherSuites()).containsOnly("cipher1", "cipher2");
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/Http2IT.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/Http2IT.java | package dev.snowdrop.vertx.http.it;
import java.util.Properties;
public class Http2IT extends HttpIT {
@Override
protected Properties defaultProperties() {
Properties properties = super.defaultProperties();
properties.setProperty("vertx.http.client.protocol-version", "HTTP_2");
// Disable text upgrade to make compression work
properties.setProperty("vertx.http.client.http2-clear-text-upgrade", "false");
return properties;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/HttpClientPropertiesIT.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/HttpClientPropertiesIT.java | package dev.snowdrop.vertx.http.it;
import java.util.HashMap;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
import dev.snowdrop.vertx.http.client.properties.HttpClientProperties;
import io.vertx.core.http.HttpVersion;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class HttpClientPropertiesIT extends TestBase {
@AfterEach
public void tearDown() {
stopServer();
}
@Test
public void verifyHttpClientProperties() {
Properties originalProperties = new Properties();
originalProperties.setProperty("vertx.http.client.default-host", "localhost");
originalProperties.setProperty("vertx.http.client.default-port", "8082");
originalProperties.setProperty("vertx.http.client.protocol-version", "HTTP_2");
originalProperties.setProperty("vertx.http.client.force-sni", "true");
originalProperties.setProperty("vertx.http.client.http2-extra-settings.1", "10");
originalProperties.setProperty("vertx.http.client.http2-extra-settings.2", "20");
originalProperties.setProperty("vertx.http.client.idle-timeout-unit", "HOURS");
originalProperties.setProperty("vertx.http.client.enabled-cipher-suites", "cipher1,cipher2");
startServerWithoutSecurity(originalProperties);
HttpClientProperties expectedProperties = getBean(HttpClientProperties.class);
assertThat(expectedProperties.getDefaultPort()).isEqualTo(8082);
assertThat(expectedProperties.getDefaultHost()).isEqualTo("localhost");
assertThat(expectedProperties.getProtocolVersion()).isEqualTo(HttpVersion.HTTP_2);
assertThat(expectedProperties.isForceSni()).isTrue();
assertThat(expectedProperties.getHttp2ExtraSettings())
.containsOnly(new HashMap.SimpleEntry<>(1, 10L), new HashMap.SimpleEntry<>(2, 20L));
assertThat(expectedProperties.getIdleTimeoutUnit()).isEqualTo(TimeUnit.HOURS);
assertThat(expectedProperties.getEnabledCipherSuites()).containsOnly("cipher1", "cipher2");
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/TestBase.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/TestBase.java | package dev.snowdrop.vertx.http.it;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import dev.snowdrop.vertx.http.client.VertxClientHttpConnector;
import dev.snowdrop.vertx.http.client.VertxWebSocketClient;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.TestWatcher;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.web.server.ServerHttpSecurity;
import org.springframework.security.web.server.SecurityWebFilterChain;
import org.springframework.test.web.reactive.server.WebTestClient;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.socket.client.WebSocketClient;
@ExtendWith(TestBase.TestNameLogger.class)
public class TestBase {
protected static final String BASE_URL = "http://localhost:8080";
protected static final String SSL_BASE_URL = "https://localhost:8080";
protected static final String WS_BASE_URL = "ws://localhost:8080";
private ConfigurableApplicationContext context;
/**
* Start a server with default properties and provided set of configuration classes.
*/
protected void startServer(Class<?>... sources) {
startServer(new Properties(), sources);
}
/**
* Start a server with user properties merged with default properties and provided set of configuration classes.
*/
protected void startServer(Properties userProperties, Class<?>... sources) {
if (context != null) {
throw new RuntimeException("Server is already running");
}
Properties properties = new Properties(defaultProperties());
properties.putAll(userProperties);
context = new SpringApplicationBuilder(TestApplication.class)
.sources(sources)
.web(WebApplicationType.REACTIVE)
.properties(properties)
.run();
}
/**
* Start a server with default properties, provided set of configuration classes and disabled spring security.
*/
protected void startServerWithoutSecurity(Class<?>... sources) {
startServerWithoutSecurity(new Properties(), sources);
}
/**
* Start a server with user properties merged with default properties, provided set of configuration classes and
* disabled spring security.
*/
protected void startServerWithoutSecurity(Properties userProperties, Class<?>... sources) {
List<Class<?>> sourcesList = new ArrayList<>(Arrays.asList(sources));
sourcesList.add(DisableSecurity.class);
startServer(userProperties, sourcesList.toArray(new Class[0]));
}
protected void stopServer() {
if (context != null) {
context.close();
context = null;
}
}
protected <T> T getBean(Class<T> beanClass) {
return context.getBean(beanClass);
}
/**
* Get a preconfigured WebClient. Base URL is set to BASE_URL or SSL_BASE_URL depending on isSsl() value.
*/
protected WebClient getWebClient() {
return getBean(WebClient.Builder.class)
.baseUrl(isSsl() ? SSL_BASE_URL : BASE_URL)
.build();
}
/**
* Get a preconfigured WebTestClient. Base URL is set to BASE_URL or SSL_BASE_URL depending on isSsl() value.
*/
protected WebTestClient getWebTestClient() {
VertxClientHttpConnector connector = getBean(VertxClientHttpConnector.class);
return WebTestClient.bindToServer(connector)
.baseUrl(isSsl() ? SSL_BASE_URL : BASE_URL)
.build();
}
/**
* Get a preconfigured WebSocketClient.
*/
protected WebSocketClient getWebSocketClient() {
return getBean(VertxWebSocketClient.class);
}
/**
* Override this method to provide default set of properties e.g. set protocol version to HTTP_2.
*/
protected Properties defaultProperties() {
return new Properties();
}
/**
* Override this method in classes that require SSL.
*/
protected boolean isSsl() {
return false;
}
@Configuration
static class DisableSecurity {
@Bean
public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
return http
.csrf().disable()
.authorizeExchange().anyExchange().permitAll()
.and()
.build();
}
}
@SpringBootConfiguration
@EnableAutoConfiguration
private static class TestApplication {
public TestApplication() {
}
}
static class TestNameLogger implements TestWatcher {
public void testSuccessful(ExtensionContext context) {
System.out.println(context.getDisplayName() + " has succeeded");
}
public void testFailed(ExtensionContext context, Throwable cause) {
System.out.println(context.getDisplayName() + " has failed");
}
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/HttpFileTransferIT.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/HttpFileTransferIT.java | package dev.snowdrop.vertx.http.it;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Duration;
import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.file.AsyncFile;
import io.vertx.core.file.OpenOptions;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.http.HttpStatus;
import org.springframework.web.reactive.function.client.ClientResponse;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import static java.nio.file.StandardOpenOption.CREATE_NEW;
import static java.nio.file.StandardOpenOption.WRITE;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.web.reactive.function.BodyInserters.fromDataBuffers;
import static org.springframework.web.reactive.function.BodyInserters.fromResource;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;
import static org.springframework.web.reactive.function.server.ServerResponse.noContent;
import static org.springframework.web.reactive.function.server.ServerResponse.ok;
public class HttpFileTransferIT extends TestBase {
private static final Path ORIGINAL_FILE = Paths.get("target/original-file").toAbsolutePath();
private static final Path EXPECTED_FILE = Paths.get("target/expected-file").toAbsolutePath();
private static final long FILE_SIZE = Integer.MAX_VALUE;
@BeforeAll
public static void setUpClass() throws IOException {
Files.deleteIfExists(ORIGINAL_FILE);
createTestFile();
}
@BeforeEach
public void setUp() throws IOException {
Files.deleteIfExists(EXPECTED_FILE);
}
@AfterEach
public void tearDown() throws IOException {
Files.deleteIfExists(EXPECTED_FILE);
stopServer();
}
@AfterAll
public static void tearDownClass() throws IOException {
Files.deleteIfExists(ORIGINAL_FILE);
}
@Test
public void shouldUploadLargeFile() throws IOException {
startServerWithoutSecurity(UploadRouter.class);
Vertx vertx = getBean(Vertx.class);
Flux<DataBuffer> dataBuffers = readFile(vertx, ORIGINAL_FILE);
HttpStatus status = getWebClient()
.post()
.body(fromDataBuffers(dataBuffers))
.exchange()
.map(ClientResponse::statusCode)
.block(Duration.ofMinutes(5));
assertThat(status).isEqualTo(HttpStatus.NO_CONTENT);
assertThat(Files.size(EXPECTED_FILE)).isEqualTo(Files.size(ORIGINAL_FILE));
}
@Test
public void shouldDownloadLargeFile() throws IOException {
startServerWithoutSecurity(DownloadRouter.class);
Flux<DataBuffer> buffers = getWebClient()
.get()
.retrieve()
.bodyToFlux(DataBuffer.class);
writeToFile(buffers, EXPECTED_FILE)
.block(Duration.ofMinutes(5));
assertThat(Files.size(EXPECTED_FILE)).isEqualTo(Files.size(ORIGINAL_FILE));
}
private static void createTestFile() throws IOException {
RandomAccessFile file = new RandomAccessFile(ORIGINAL_FILE.toFile(), "rw");
file.setLength(FILE_SIZE);
file.close();
}
private static Flux<DataBuffer> readFile(Vertx vertx, Path path) {
AsyncFile file = vertx.fileSystem().openBlocking(path.toString(), new OpenOptions());
Flux<Buffer> buffers = Flux.create(sink -> {
file.pause();
file.endHandler(v -> sink.complete());
file.exceptionHandler(sink::error);
file.handler(sink::next);
sink.onRequest(file::fetch);
});
DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
return Flux.from(buffers)
.map(Buffer::getBytes)
.map(dataBufferFactory::wrap);
}
private static Mono<Void> writeToFile(Flux<DataBuffer> input, Path path) {
try {
AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, CREATE_NEW, WRITE);
return DataBufferUtils.write(input, channel).then();
} catch (IOException e) {
return Mono.error(e);
}
}
@Configuration
static class DownloadRouter {
@Bean
public RouterFunction<ServerResponse> downloadRouter() {
return route()
.GET("/", request -> ok().body(fromResource(new FileSystemResource(ORIGINAL_FILE))))
.build();
}
}
@Configuration
static class UploadRouter {
@Bean
public RouterFunction<ServerResponse> uploadRouter() {
return route()
.POST("/", request -> {
Flux<DataBuffer> buffers = request.bodyToFlux(DataBuffer.class);
return writeToFile(buffers, EXPECTED_FILE)
.then(noContent().build());
})
.build();
}
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/HttpSslIT.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/HttpSslIT.java | package dev.snowdrop.vertx.http.it;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
import javax.net.ssl.SSLHandshakeException;
import dev.snowdrop.vertx.http.client.properties.HttpClientOptionsCustomizer;
import dev.snowdrop.vertx.http.server.VertxServerHttpRequest;
import dev.snowdrop.vertx.http.server.properties.HttpServerOptionsCustomizer;
import io.vertx.core.http.ClientAuth;
import io.vertx.core.http.HttpServerRequest;
import io.vertx.core.http.HttpVersion;
import io.vertx.core.net.JdkSSLEngineOptions;
import io.vertx.core.net.JksOptions;
import io.vertx.core.net.OpenSSLEngineOptions;
import io.vertx.core.net.PemKeyCertOptions;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpStatus;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;
import static org.springframework.web.reactive.function.server.ServerResponse.noContent;
import static org.springframework.web.reactive.function.server.ServerResponse.status;
public class HttpSslIT extends TestBase {
private static final JksOptions SERVER_KEYSTORE = new JksOptions()
.setPath("target/test-classes/tls/server-keystore.jks")
.setPassword("wibble");
private static final JksOptions SERVER_TRUSTSTORE = new JksOptions()
.setPath("target/test-classes/tls/server-truststore.jks")
.setPassword("wibble");
private static final JksOptions CLIENT_KEYSTORE = new JksOptions()
.setPath("target/test-classes/tls/client-keystore.jks")
.setPassword("wibble");
private static final JksOptions CLIENT_TRUSTSTORE = new JksOptions()
.setPath("target/test-classes/tls/client-truststore.jks")
.setPassword("wibble");
private static final String KEY_PATH = "target/test-classes/tls/server-key.pem";
private static final String CERT_PATH = "target/test-classes/tls/server-cert.pem";
@AfterEach
public void tearDown() {
stopServer();
}
@Test
public void testSecureRequest() {
testSecureRequest(false);
}
@Test
public void testSecureRequestWithAlpn() {
assumeTrue(isOpenSsl() || isJava9(), "Neither OpenSSL nor Java 9 or higher is in a classpath");
testSecureRequest(true);
}
@Test
public void testUntrustedClient() {
testUntrustedClient(false);
}
@Test
public void testUntrustedClientWithAlpn() {
assumeTrue(isOpenSsl() || isJava9(), "Neither OpenSSL nor Java 9 or higher is in a classpath");
testUntrustedClient(true);
}
@Test
public void testDefaultEngine() {
testEngine(false, Engine.NONE);
}
@Test
public void testDefaultEngineWithAlpn() {
assumeTrue(isOpenSsl() || isJava9(), "Neither OpenSSL nor Java 9 or higher is in a classpath");
testEngine(true, Engine.NONE);
}
@Test
public void testOpenSslEngine() {
assumeTrue(isOpenSsl(), "OpenSSL is not in a classpath");
testEngine(false, Engine.OPENSSL);
}
@Test
public void testOpenSslEngineWithAlpn() {
assumeTrue(isOpenSsl(), "OpenSSL is not in a classpath");
testEngine(true, Engine.OPENSSL);
}
@Test
public void testJdkEngine() {
testEngine(false, Engine.JDK);
}
@Test
public void testJdkEngineWithAlpn() {
assumeTrue(isJava9(), "Java 9 or higher is not in a classpath");
testEngine(true, Engine.JDK);
}
@Override
protected boolean isSsl() {
return true;
}
private void testSecureRequest(boolean useAlpn) {
Properties properties = new Properties();
properties.setProperty("vertx.http.client.ssl", "true");
properties.setProperty("vertx.http.client.use-alpn", String.valueOf(useAlpn));
properties.setProperty("vertx.http.client.protocol-version",
useAlpn ? HttpVersion.HTTP_2.name() : HttpVersion.HTTP_1_1.name());
properties.setProperty("vertx.http.server.ssl", "true");
properties.setProperty("vertx.http.server.useAlpn", Boolean.toString(useAlpn));
properties.setProperty("vertx.http.server.client-auth", ClientAuth.REQUIRED.name());
properties.setProperty("server.ssl.key-store-type", "JKS");
properties.setProperty("server.ssl.key-store", SERVER_KEYSTORE.getPath());
properties.setProperty("server.ssl.key-store-password", SERVER_KEYSTORE.getPassword());
properties.setProperty("server.ssl.trust-store-type", "JKS");
properties.setProperty("server.ssl.trust-store", SERVER_TRUSTSTORE.getPath());
properties.setProperty("server.ssl.trust-store-password", SERVER_TRUSTSTORE.getPassword());
startServerWithoutSecurity(properties, ClientStoresCustomizer.class, useAlpn ? NoopHttp2Router.class : NoopHttp11Router.class);
getWebTestClient()
.get()
.exchange()
.expectStatus()
.isNoContent();
}
private void testUntrustedClient(boolean useAlpn) {
Properties properties = new Properties();
properties.setProperty("vertx.http.client.ssl", "true");
properties.setProperty("vertx.http.client.use-alpn", String.valueOf(useAlpn));
properties.setProperty("vertx.http.client.protocol-version",
useAlpn ? HttpVersion.HTTP_2.name() : HttpVersion.HTTP_1_1.name());
properties.setProperty("vertx.http.server.ssl", "true");
properties.setProperty("vertx.http.server.useAlpn", Boolean.toString(useAlpn));
properties.setProperty("vertx.http.server.client-auth", ClientAuth.REQUIRED.name());
properties.setProperty("server.ssl.key-store-type", "JKS");
properties.setProperty("server.ssl.key-store", SERVER_KEYSTORE.getPath());
properties.setProperty("server.ssl.key-store-password", SERVER_KEYSTORE.getPassword());
startServerWithoutSecurity(properties, ClientStoresCustomizer.class, useAlpn ? NoopHttp2Router.class : NoopHttp11Router.class);
try {
getWebTestClient()
.get()
.exchange();
fail("SSLHandshakeException expected");
} catch (RuntimeException e) {
assertThat(e.getCause()).isInstanceOf(SSLHandshakeException.class);
}
}
private void testEngine(boolean useAlpn, Engine engine) {
Properties properties = new Properties();
properties.setProperty("vertx.http.client.ssl", "true");
properties.setProperty("vertx.http.client.use-alpn", String.valueOf(useAlpn));
properties.setProperty("vertx.http.client.trust-all", "true");
properties.setProperty("vertx.http.client.protocol-version",
useAlpn ? HttpVersion.HTTP_2.name() : HttpVersion.HTTP_1_1.name());
properties.setProperty("vertx.http.server.ssl", "true");
properties.setProperty("vertx.http.server.useAlpn", Boolean.toString(useAlpn));
List<Class> classes = new LinkedList<>();
classes.add(ServerKeyCertCustomizer.class);
classes.add(useAlpn ? NoopHttp2Router.class : NoopHttp11Router.class);
switch (engine) {
case JDK:
classes.add(JdkSslEngineOptionsCustomizers.class);
break;
case OPENSSL:
classes.add(OpenSslEngineOptionsCustomizers.class);
}
startServerWithoutSecurity(properties, classes.toArray(new Class[]{}));
getWebTestClient()
.get()
.exchange()
.expectStatus()
.isNoContent();
}
private boolean isJava9() {
try {
HttpSslIT.class.getClassLoader().loadClass("java.lang.invoke.VarHandle");
return true;
} catch (Throwable ignore) {
return false;
}
}
private boolean isOpenSsl() {
try {
HttpSslIT.class.getClassLoader().loadClass("io.netty.internal.tcnative.SSL");
return true;
} catch (Throwable ignore) {
return false;
}
}
private enum Engine {
NONE,
JDK,
OPENSSL
}
@Configuration
static class ClientStoresCustomizer {
@Bean
public HttpClientOptionsCustomizer clientStoresCustomizer() {
return options -> options
.setKeyStoreOptions(CLIENT_KEYSTORE)
.setTrustStoreOptions(CLIENT_TRUSTSTORE);
}
}
@Configuration
static class OpenSslEngineOptionsCustomizers {
@Bean
public HttpClientOptionsCustomizer clientOpenSslEngineOptionsCustomizer() {
return options -> options.setSslEngineOptions(new OpenSSLEngineOptions());
}
@Bean
public HttpServerOptionsCustomizer serverOpenSslEngineOptionsCustomizer() {
return options -> options.setSslEngineOptions(new OpenSSLEngineOptions());
}
}
@Configuration
static class JdkSslEngineOptionsCustomizers {
@Bean
public HttpClientOptionsCustomizer clientJdkSslEngineOptionsCustomizer() {
return options -> options.setSslEngineOptions(new JdkSSLEngineOptions());
}
@Bean
public HttpServerOptionsCustomizer serverJdkSslEngineOptionsCustomizer() {
return options -> options.setSslEngineOptions(new JdkSSLEngineOptions());
}
}
@Configuration
static class ServerKeyCertCustomizer {
@Bean
public HttpServerOptionsCustomizer serverKeyCertCustomizer() {
return options -> {
PemKeyCertOptions cert = new PemKeyCertOptions()
.setKeyPath(KEY_PATH)
.setCertPath(CERT_PATH);
options.setKeyCertOptions(cert);
return options;
};
}
}
@Configuration
static class NoopHttp2Router {
@Bean
public RouterFunction<ServerResponse> noopHttp2Router() {
return route()
.GET("/", request -> {
HttpServerRequest vertxRequest = getHttpServerRequest(request);
System.out.println(vertxRequest.sslSession());
if (!HttpVersion.HTTP_2.equals(vertxRequest.version())) {
return status(HttpStatus.BAD_REQUEST).bodyValue("Not HTTP2 request");
}
if (!vertxRequest.isSSL()) {
return status(HttpStatus.BAD_REQUEST).bodyValue("Not SSL request");
}
return noContent().build();
})
.build();
}
private HttpServerRequest getHttpServerRequest(ServerRequest request) {
return ((VertxServerHttpRequest) request.exchange().getRequest()).getNativeRequest();
}
}
@Configuration
static class NoopHttp11Router {
@Bean
public RouterFunction<ServerResponse> noopHttp11Router() {
return route()
.GET("/", request -> {
HttpServerRequest vertxRequest = getHttpServerRequest(request);
if (!HttpVersion.HTTP_1_1.equals(vertxRequest.version())) {
return status(HttpStatus.BAD_REQUEST).bodyValue("Not HTTP1.1 request");
}
if (!vertxRequest.isSSL()) {
return status(HttpStatus.BAD_REQUEST).bodyValue("Not SSL request");
}
return noContent().build();
})
.build();
}
private HttpServerRequest getHttpServerRequest(ServerRequest request) {
return ((VertxServerHttpRequest) request.exchange().getRequest()).getNativeRequest();
}
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/WebSocketIT.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/WebSocketIT.java | package dev.snowdrop.vertx.http.it;
import java.net.URI;
import java.time.Duration;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicReference;
import io.vertx.core.http.UpgradeRejectedException;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.reactive.HandlerMapping;
import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.WebSocketMessage;
import org.springframework.web.reactive.socket.WebSocketSession;
import reactor.core.publisher.Mono;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.awaitility.Awaitility.await;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.equalTo;
public class WebSocketIT extends TestBase {
@AfterEach
public void tearDown() {
stopServer();
}
@Test
public void shouldSendAndReceiveTextMessage() {
startServerWithoutSecurity(Handlers.class);
AtomicReference<String> expectedMessage = new AtomicReference<>();
getWebSocketClient()
.execute(URI.create(WS_BASE_URL + "/echo"), session -> {
WebSocketMessage originalMessage = session.textMessage("ping");
Mono<Void> outputMono = session.send(Mono.just(originalMessage));
Mono<Void> inputMono = session.receive()
.filter(message -> message.getType().equals(WebSocketMessage.Type.TEXT))
.map(WebSocketMessage::getPayloadAsText)
.doOnNext(expectedMessage::set)
.then();
return outputMono.then(inputMono);
}).subscribe();
await()
.atMost(2, SECONDS)
.untilAtomic(expectedMessage, equalTo("ping"));
}
@Test
public void shouldSendAndReceiveMultiFrameTextMessage() {
Properties properties = new Properties();
properties.setProperty("vertx.http.client.maxWebSocketFrameSize", "5");
properties.setProperty("vertx.http.server.maxWebSocketFrameSize", "5");
startServerWithoutSecurity(properties, Handlers.class);
AtomicReference<String> expectedMessage = new AtomicReference<>();
getWebSocketClient()
.execute(URI.create(WS_BASE_URL + "/echo"), session -> {
WebSocketMessage originalMessage = session.textMessage("ping pong");
Mono<Void> outputMono = session.send(Mono.just(originalMessage));
Mono<Void> inputMono = session.receive()
.filter(message -> message.getType().equals(WebSocketMessage.Type.TEXT))
.map(WebSocketMessage::getPayloadAsText)
.doOnNext(expectedMessage::set)
.then();
return outputMono.then(inputMono);
}).subscribe();
await()
.atMost(2, SECONDS)
.untilAtomic(expectedMessage, equalTo("ping pong"));
}
@Test
public void shouldSendAndReceiveBinaryMessage() {
startServerWithoutSecurity(Handlers.class);
AtomicReference<String> expectedMessage = new AtomicReference<>();
getWebSocketClient()
.execute(URI.create(BASE_URL + "/echo"), session -> {
WebSocketMessage originalMessage = session.binaryMessage(factory -> factory.wrap("ping".getBytes()));
Mono<Void> outputMono = session.send(Mono.just(originalMessage));
Mono<Void> inputMono = session.receive()
.filter(message -> message.getType().equals(WebSocketMessage.Type.BINARY))
.map(WebSocketMessage::getPayloadAsText)
.doOnNext(expectedMessage::set)
.then();
return outputMono.then(inputMono);
}).subscribe();
await()
.atMost(2, SECONDS)
.untilAtomic(expectedMessage, equalTo("ping"));
}
@Test
public void shouldSendAndReceiveMultiFrameBinaryMessage() {
Properties properties = new Properties();
properties.setProperty("vertx.http.client.maxWebSocketFrameSize", "5");
properties.setProperty("vertx.http.server.maxWebSocketFrameSize", "5");
startServerWithoutSecurity(properties, Handlers.class);
AtomicReference<String> expectedMessage = new AtomicReference<>();
getWebSocketClient()
.execute(URI.create(BASE_URL + "/echo"), session -> {
WebSocketMessage originalMessage =
session.binaryMessage(factory -> factory.wrap("ping pong".getBytes()));
Mono<Void> outputMono = session.send(Mono.just(originalMessage));
Mono<Void> inputMono = session.receive()
.filter(message -> message.getType().equals(WebSocketMessage.Type.BINARY))
.map(WebSocketMessage::getPayloadAsText)
.doOnNext(expectedMessage::set)
.then();
return outputMono.then(inputMono);
}).subscribe();
await()
.atMost(2, SECONDS)
.untilAtomic(expectedMessage, equalTo("ping pong"));
}
@Test
public void shouldSendPingAndReceivePong() {
startServerWithoutSecurity(Handlers.class);
AtomicReference<String> expectedMessage = new AtomicReference<>();
// Ping should be handled by a server, not a handler
getWebSocketClient()
.execute(URI.create(BASE_URL + "/sink"), session -> {
WebSocketMessage originalMessage = session.pingMessage(factory -> factory.wrap("ping".getBytes()));
Mono<Void> outputMono = session.send(Mono.just(originalMessage));
Mono<Void> inputMono = session.receive()
.filter(message -> message.getType().equals(WebSocketMessage.Type.PONG))
.map(WebSocketMessage::getPayloadAsText)
.doOnNext(expectedMessage::set)
.then();
return outputMono.then(inputMono);
}).subscribe();
await()
.atMost(2, SECONDS)
.untilAtomic(expectedMessage, equalTo("ping"));
}
@Test
public void shouldSendAndReceivePong() {
startServerWithoutSecurity(Handlers.class);
AtomicReference<String> expectedMessage = new AtomicReference<>();
getWebSocketClient()
.execute(URI.create(BASE_URL + "/echo"), session -> {
WebSocketMessage originalMessage = session.pongMessage(factory -> factory.wrap("pong".getBytes()));
Mono<Void> outputMono = session.send(Mono.just(originalMessage));
Mono<Void> inputMono = session.receive()
.filter(message -> message.getType().equals(WebSocketMessage.Type.PONG))
.map(WebSocketMessage::getPayloadAsText)
.doOnNext(expectedMessage::set)
.then();
return outputMono.then(inputMono);
}).subscribe();
await()
.atMost(2, SECONDS)
.untilAtomic(expectedMessage, equalTo("pong"));
}
@Test
public void clientShouldCloseSocket() {
startServerWithoutSecurity(Handlers.class);
getWebSocketClient()
.execute(URI.create(BASE_URL + "/echo"), WebSocketSession::close)
.block(Duration.ofSeconds(2));
}
@Test
public void serverShouldCloseSocket() {
startServerWithoutSecurity(Handlers.class);
getWebSocketClient()
.execute(URI.create(BASE_URL + "/close"), session -> Mono.empty())
.block(Duration.ofSeconds(2));
}
@Test
public void serverShouldSendFromTwoPublishers() {
startServerWithoutSecurity(Handlers.class);
List<String> expectedMessages = new LinkedList<>();
getWebSocketClient()
.execute(URI.create(BASE_URL + "/double-producer"), session -> session.receive()
.map(WebSocketMessage::getPayloadAsText)
.doOnNext(expectedMessages::add)
.then()
).subscribe();
await()
.atMost(2, SECONDS)
.until(() -> expectedMessages, contains("ping", "pong"));
}
@Test
public void testAllowedCorsOrigin() {
startServerWithoutSecurity(Handlers.class);
HttpHeaders headers = new HttpHeaders();
headers.set(HttpHeaders.ORIGIN, "http://snowdrop.dev");
getWebSocketClient()
.execute(URI.create(WS_BASE_URL + "/sink"), headers, session -> Mono.empty())
.block(Duration.ofSeconds(2));
}
@Test
public void testNotAllowedCorsOrigin() {
startServerWithoutSecurity(Handlers.class);
HttpHeaders headers = new HttpHeaders();
headers.set(HttpHeaders.ORIGIN, "http://example.com");
assertThatExceptionOfType(UpgradeRejectedException.class)
.isThrownBy(
() -> getWebSocketClient().execute(URI.create(WS_BASE_URL + "/sink"), headers, session -> Mono.empty())
.block(Duration.ofSeconds(2)));
}
@Configuration
static class Handlers {
@Bean
public HandlerMapping handlerMapping() {
Map<String, WebSocketHandler> map = new HashMap<>();
map.put("/echo", this::echoHandler);
map.put("/sink", this::sinkHandler);
map.put("/double-producer", this::doubleProducerHandler);
map.put("/close", this::closeHandler);
SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
mapping.setUrlMap(map);
mapping.setOrder(-1);
CorsConfiguration cors = new CorsConfiguration();
cors.addAllowedOrigin("http://snowdrop.dev");
mapping.setCorsConfigurations(Collections.singletonMap("/sink", cors));
return mapping;
}
private Mono<Void> echoHandler(WebSocketSession session) {
return session.send(session.receive());
}
private Mono<Void> sinkHandler(WebSocketSession session) {
return session.receive()
.then();
}
private Mono<Void> doubleProducerHandler(WebSocketSession session) {
Mono<Void> firstSend = session.send(Mono.just(session.textMessage("ping")));
Mono<Void> secondSend = session.send(Mono.just(session.textMessage("pong")));
return firstSend.then(secondSend);
}
private Mono<Void> closeHandler(WebSocketSession session) {
return session.close();
}
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/HttpIT.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/HttpIT.java | package dev.snowdrop.vertx.http.it;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.Objects;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.http.CacheControl;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseCookie;
import org.springframework.http.ResponseEntity;
import org.springframework.http.codec.ServerSentEvent;
import org.springframework.security.core.userdetails.MapReactiveUserDetailsService;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.test.web.reactive.server.WebTestClient;
import org.springframework.util.Base64Utils;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;
import org.springframework.web.reactive.config.WebFluxConfigurer;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.ClientResponse;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.server.WebSession;
import org.springframework.web.server.adapter.ForwardedHeaderTransformer;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.emptyOrNullString;
import static org.hamcrest.Matchers.not;
import static org.springframework.http.HttpHeaders.ACCEPT_ENCODING;
import static org.springframework.web.reactive.function.server.RequestPredicates.accept;
import static org.springframework.web.reactive.function.server.RouterFunctions.resources;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;
import static org.springframework.web.reactive.function.server.ServerResponse.noContent;
import static org.springframework.web.reactive.function.server.ServerResponse.ok;
public class HttpIT extends TestBase {
@AfterEach
public void tearDown() {
stopServer();
}
@Test
public void shouldGet404Response() {
startServerWithoutSecurity();
getWebTestClient()
.get()
.uri("/non-existent-resource")
.exchange()
.expectStatus()
.isNotFound();
}
@Test
public void shouldGetEmptyResponse() {
startServerWithoutSecurity(NoopRouter.class);
getWebTestClient()
.get()
.exchange()
.expectStatus()
.isNoContent();
}
@Test
public void shouldExchangeBodies() {
startServerWithoutSecurity(UpperBodyRouter.class);
getWebTestClient()
.post()
.bodyValue("test")
.exchange()
.expectBody(String.class)
.isEqualTo("TEST");
}
@Test
public void shouldGetStaticContent() {
startServerWithoutSecurity(StaticRouter.class);
getWebTestClient()
.get()
.uri("static/index.html")
.exchange()
.expectBody(String.class)
.isEqualTo("<html><body><div>Test div</div></body></html>\n");
}
@Test
public void shouldGetCompressedStaticContent() {
Properties properties = new Properties();
properties.setProperty("server.compression.enabled", "true");
properties.setProperty("vertx.http.client.try-use-compression", "true");
startServerWithoutSecurity(properties, StaticRouter.class);
getWebTestClient()
.get()
.uri("static/index.html")
.header(ACCEPT_ENCODING, "gzip")
.exchange()
.expectBody(String.class)
.isEqualTo("<html><body><div>Test div</div></body></html>\n");
}
@Test
public void shouldExchangeHeaders() {
startServerWithoutSecurity(UpperHeaderRouter.class);
getWebTestClient()
.get()
.header("text", "test")
.exchange()
.expectHeader()
.valueEquals("text", "TEST");
}
@Test
public void shouldExchangeCookies() {
startServerWithoutSecurity(UpperCookieRouter.class);
String text = getWebClient()
.get()
.cookie("text", "test")
.exchange()
.map(response -> Objects.requireNonNull(response.cookies().getFirst("text")).getValue())
.block(Duration.ofSeconds(2));
assertThat(text).isEqualTo("TEST");
}
@Test
public void shouldGetActuatorHealth() {
startServerWithoutSecurity();
getWebTestClient()
.get()
.uri("/actuator/health")
.exchange()
.expectBody(String.class)
.value(org.hamcrest.Matchers.containsString("\"status\":\"UP\""));
}
@Test
public void shouldExtractBodyAfterRequestEnded() {
startServerWithoutSecurity(UpperBodyRouter.class);
ClientResponse response = getWebClient()
.post()
.bodyValue("test")
.exchange()
.blockOptional(Duration.ofSeconds(2))
.orElseThrow(() -> new AssertionError("Did not receive a response"));
assertThat(response.statusCode()).isEqualTo(HttpStatus.OK);
String body = response.bodyToMono(String.class)
.block(Duration.ofSeconds(2));
assertThat(body).isEqualTo("TEST");
}
@Test
public void testBasicAuth() {
startServer(SessionController.class, AuthConfiguration.class);
getWebTestClient()
.get()
.exchange()
.expectStatus()
.isUnauthorized();
String authHash = Base64Utils.encodeToString("user:password".getBytes(StandardCharsets.UTF_8));
getWebTestClient()
.get()
.header(HttpHeaders.AUTHORIZATION, "Basic " + authHash)
.exchange()
.expectStatus()
.isOk()
.expectBody(String.class)
.value(not(emptyOrNullString()));
}
@Test
public void testFormData() {
startServerWithoutSecurity(UpperFormRouter.class);
getWebTestClient()
.post()
.body(BodyInserters.fromFormData("text", "test"))
.exchange()
.expectBody(String.class)
.isEqualTo("TEST");
}
@Test
public void testForwardedHeaders() {
startServerWithoutSecurity(ForwardedHeadersRouter.class);
getWebTestClient()
.get()
.header("Forwarded", "host=127.0.0.1:1234;proto=http")
.exchange()
.expectBody(String.class)
.isEqualTo("http://127.0.0.1:1234/");
getWebTestClient()
.get()
.header("X-Forwarded-Host", "127.0.0.2")
.header("X-Forwarded-Port", "4321")
.header("X-Forwarded-Proto", "https")
.exchange()
.expectBody(String.class)
.isEqualTo("https://127.0.0.2:4321/");
}
@Test
public void testSse() {
startServerWithoutSecurity(SseController.class);
getWebTestClient()
.get()
.exchange()
.returnResult(String.class)
.consumeWith(result -> StepVerifier.create(result.getResponseBody())
.expectNext("first")
.expectNext("second")
.expectNext("third")
.verifyComplete()
);
}
@Test
public void testClientWithInfiniteSse() {
Properties properties = new Properties();
properties.setProperty("vertx.http.client.max-pool-size", "1");
startServerWithoutSecurity(properties, InfiniteSseController.class);
Flux<Long> firstFlux = getWebClient()
.get()
.retrieve()
.bodyToFlux(Long.class)
.log("first client");
Flux<Long> secondFlux = getWebClient()
.get()
.retrieve()
.bodyToFlux(Long.class)
.log("second client");
StepVerifier.create(firstFlux)
.expectNext(0L)
.expectNext(1L)
.thenCancel()
.verify();
StepVerifier.create(secondFlux)
.expectNext(0L)
.expectNext(1L)
.thenCancel()
.verify();
}
@Test
public void testExceptionHandler() {
startServerWithoutSecurity(ExceptionController.class);
getWebTestClient()
.get()
.exchange()
.expectStatus()
.isNoContent();
}
@Test
public void testCache() {
startServerWithoutSecurity(CacheController.class);
getWebTestClient()
.get()
.exchange()
.expectStatus()
.isOk()
.expectHeader()
.valueEquals(HttpHeaders.ETAG, "\"test\"")
.expectHeader()
.cacheControl(CacheControl.maxAge(1, TimeUnit.MINUTES))
.expectBody(String.class)
.isEqualTo("test");
getWebTestClient()
.get()
.header(HttpHeaders.IF_NONE_MATCH, "\"test\"")
.exchange()
.expectStatus()
.isNotModified();
}
@Test
public void testCorsAnnotation() {
testCors(AnnotatedCorsController.class);
}
@Test
public void testCorsFilter() {
testCors(UpperBodyRouter.class, CorsWebFilterConfiguration.class);
}
private void testCors(Class<?>... sources) {
startServerWithoutSecurity(sources);
WebTestClient client = getWebTestClient();
client.options()
.header(HttpHeaders.ORIGIN, "http://snowdrop.dev")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "POST")
.header(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "TEST")
.exchange()
.expectHeader()
.valueEquals(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, "http://snowdrop.dev")
.expectHeader()
.valueEquals(HttpHeaders.ACCESS_CONTROL_ALLOW_METHODS, "POST")
.expectHeader()
.valueEquals(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, "TEST")
.expectHeader()
.valueEquals(HttpHeaders.ACCESS_CONTROL_MAX_AGE, "1000");
client.post()
.header(HttpHeaders.ORIGIN, "http://snowdrop.dev")
.bodyValue("test")
.exchange()
.expectBody(String.class)
.isEqualTo("TEST");
client.post()
.header(HttpHeaders.ORIGIN, "http://example.com")
.bodyValue("test")
.exchange()
.expectStatus()
.isForbidden();
}
@Configuration
static class StaticRouter {
@Bean
public RouterFunction<ServerResponse> staticRouter() {
return resources("/**", new ClassPathResource("static"));
}
}
@Configuration
static class NoopRouter {
@Bean
public RouterFunction<ServerResponse> noopRouter() {
return route()
.GET("/", request -> noContent().build())
.build();
}
}
@Configuration
static class UpperBodyRouter {
@Bean
public RouterFunction<ServerResponse> upperBodyRouter() {
return route()
.POST("/", request -> {
Flux<String> body = request.bodyToFlux(String.class)
.map(String::toUpperCase);
return ok().body(body, String.class);
})
.build();
}
}
@Configuration
static class UpperCookieRouter {
@Bean
public RouterFunction<ServerResponse> upperCookieRouter() {
return route()
.GET("/", request -> {
String text = request.cookies()
.getFirst("text")
.getValue()
.toUpperCase();
ResponseCookie cookie = ResponseCookie.from("text", text).build();
return noContent().cookie(cookie).build();
})
.build();
}
}
@Configuration
static class UpperHeaderRouter {
@Bean
public RouterFunction<ServerResponse> upperHeaderRouter() {
return route()
.GET("/", request -> {
String text = request.headers()
.header("text")
.get(0)
.toUpperCase();
return noContent().header("text", text).build();
})
.build();
}
}
@Configuration
static class UpperFormRouter {
@Bean
public RouterFunction<ServerResponse> upperFormRouter() {
return route()
.POST("/", accept(MediaType.APPLICATION_FORM_URLENCODED), request -> {
Mono<String> body = request.exchange().getFormData()
.map(map -> map.get("text").get(0).toUpperCase());
return ok().body(body, String.class);
})
.build();
}
}
@Configuration
static class ForwardedHeadersRouter {
@Bean
public RouterFunction<ServerResponse> forwardedHeadersRouter() {
return route()
.GET("/", request -> ok().bodyValue(request.exchange().getRequest().getURI().toASCIIString()))
.build();
}
@Bean
public ForwardedHeaderTransformer forwardedHeaderTransformer() {
return new ForwardedHeaderTransformer();
}
}
@RestController
static class SseController {
@GetMapping
public Flux<ServerSentEvent<String>> sse() {
return Flux.just("first", "second", "third")
.map(s -> ServerSentEvent.<String>builder()
.data(s)
.build());
}
}
@RestController
static class InfiniteSseController {
@GetMapping(produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<Long> infiniteSse() {
return Flux.interval(Duration.ofSeconds(1))
.log(InfiniteSseController.class.getSimpleName());
}
}
@RestController
static class ExceptionController implements WebFluxConfigurer {
@GetMapping
public Flux<String> exceptionController() {
throw new RuntimeException("test");
}
@ExceptionHandler
public ResponseEntity<String> runtimeExceptionHandler(RuntimeException e) {
if ("test".equals(e.getMessage())) {
return ResponseEntity.noContent().build();
}
throw e;
}
}
@RestController
static class CacheController {
@GetMapping
public ResponseEntity<String> getString() {
return ResponseEntity
.ok()
.cacheControl(CacheControl.maxAge(1, TimeUnit.MINUTES))
.eTag("test")
.body("test");
}
}
@Configuration
static class CorsWebFilterConfiguration {
@Bean
public CorsWebFilter corsWebFilter() {
CorsConfiguration config = new CorsConfiguration();
config.addAllowedOrigin("http://snowdrop.dev");
config.addAllowedHeader("TEST");
config.addAllowedMethod(HttpMethod.POST);
config.setMaxAge(1000L);
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/", config);
return new CorsWebFilter(source);
}
}
@RestController
static class AnnotatedCorsController {
@CrossOrigin(origins = "http://snowdrop.dev", allowedHeaders = "TEST", maxAge = 1000)
@PostMapping
public Mono<String> toUpper(@RequestBody String body) {
return Mono.just(body.toUpperCase());
}
}
@RestController
static class SessionController {
@GetMapping
public Mono<String> getSessionId(WebSession session) {
return Mono.just(session.getId());
}
}
@Configuration
static class AuthConfiguration {
@Bean
public MapReactiveUserDetailsService userDetailsService() {
UserDetails user = User.withDefaultPasswordEncoder()
.username("user")
.password("password")
.roles("USER")
.build();
return new MapReactiveUserDetailsService(user);
}
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/Http2FileTransferIT.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/it/Http2FileTransferIT.java | package dev.snowdrop.vertx.http.it;
import java.util.Properties;
public class Http2FileTransferIT extends HttpFileTransferIT {
@Override
protected Properties defaultProperties() {
Properties properties = super.defaultProperties();
properties.setProperty("vertx.http.client.protocol-version", "HTTP_2");
// Disable text upgrade to make compression work
properties.setProperty("vertx.http.client.http2-clear-text-upgrade", "false");
return properties;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/VertxServerHttpRequestTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/VertxServerHttpRequestTest.java | package dev.snowdrop.vertx.http.server;
import java.net.InetSocketAddress;
import java.util.AbstractMap;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.net.ssl.SSLSession;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import io.vertx.core.Handler;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.Cookie;
import io.vertx.core.http.HttpMethod;
import io.vertx.core.http.HttpServerRequest;
import io.vertx.core.http.impl.headers.HeadersMultiMap;
import io.vertx.core.net.SocketAddress;
import io.vertx.ext.web.RoutingContext;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.http.HttpCookie;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
@ExtendWith(MockitoExtension.class)
public class VertxServerHttpRequestTest {
@Mock
private RoutingContext mockRoutingContext;
@Mock
private HttpServerRequest mockHttpServerRequest;
@Mock
private SSLSession mockSslSession;
private BufferConverter bufferConverter;
private VertxServerHttpRequest vertxServerHttpRequest;
@BeforeEach
public void setUp() {
given(mockRoutingContext.request()).willReturn(mockHttpServerRequest);
given(mockHttpServerRequest.absoluteURI()).willReturn("http://localhost:8080");
given(mockHttpServerRequest.headers()).willReturn(new HeadersMultiMap());
bufferConverter = new BufferConverter();
vertxServerHttpRequest = new VertxServerHttpRequest(mockRoutingContext, bufferConverter);
}
@Test
public void shouldGetNativeRequest() {
assertThat((HttpServerRequest) vertxServerHttpRequest.getNativeRequest()).isEqualTo(mockHttpServerRequest);
}
@Test
public void shouldGetMethodValue() {
given(mockHttpServerRequest.method()).willReturn(HttpMethod.GET);
assertThat(vertxServerHttpRequest.getMethodValue()).isEqualTo("GET");
}
@Test
public void shouldGetBody() {
Buffer firstBuffer = Buffer.buffer("chunk 1");
Buffer secondBuffer = Buffer.buffer("chunk 2");
given(mockHttpServerRequest.exceptionHandler(any())).willReturn(mockHttpServerRequest);
given(mockHttpServerRequest.handler(any())).will(invocation -> {
Handler<Buffer> handler = invocation.getArgument(0);
handler.handle(firstBuffer);
handler.handle(secondBuffer);
return mockHttpServerRequest;
});
given(mockHttpServerRequest.endHandler(any())).will(invocation -> {
Handler<Void> handler = invocation.getArgument(0);
handler.handle(null);
return mockHttpServerRequest;
});
StepVerifier.create(vertxServerHttpRequest.getBody())
.expectNext(bufferConverter.toDataBuffer(firstBuffer))
.expectNext(bufferConverter.toDataBuffer(secondBuffer))
.verifyComplete();
}
@Test
public void shouldGetNullRemoteAddress() {
assertThat(vertxServerHttpRequest.getRemoteAddress()).isNull();
}
@Test
public void shouldGetRemoteAddress() {
SocketAddress original = SocketAddress.inetSocketAddress(8080, "localhost");
given(mockHttpServerRequest.remoteAddress()).willReturn(original);
InetSocketAddress expected = new InetSocketAddress("localhost", 8080);
assertThat(vertxServerHttpRequest.getRemoteAddress()).isEqualTo(expected);
}
@Test
public void shouldInitCookies() {
Map<String, Cookie> originalCookies = new HashMap<>(2);
originalCookies.put("cookie1", Cookie.cookie("cookie1", "value1"));
originalCookies.put("cookie2", Cookie.cookie("cookie2", "value2"));
given(mockRoutingContext.cookieMap()).willReturn(originalCookies);
assertThat(vertxServerHttpRequest.initCookies()).containsOnly(
new AbstractMap.SimpleEntry<>("cookie1", Collections.singletonList(new HttpCookie("cookie1", "value1"))),
new AbstractMap.SimpleEntry<>("cookie2", Collections.singletonList(new HttpCookie("cookie2", "value2")))
);
}
@Test
public void shouldInitSslInfo() {
given(mockHttpServerRequest.sslSession()).willReturn(mockSslSession);
assertThat(vertxServerHttpRequest.initSslInfo()).isInstanceOf(SslInfoImpl.class);
}
@Test
public void shouldIgnoreNullSslSession() {
assertThat(vertxServerHttpRequest.initSslInfo()).isNull();
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/VertxServerHttpResponseTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/VertxServerHttpResponseTest.java | package dev.snowdrop.vertx.http.server;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Collections;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import io.vertx.core.AsyncResult;
import io.vertx.core.Future;
import io.vertx.core.Handler;
import io.vertx.core.MultiMap;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.Cookie;
import io.vertx.core.http.HttpServerResponse;
import io.vertx.core.http.impl.headers.HeadersMultiMap;
import io.vertx.ext.web.RoutingContext;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseCookie;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import reactor.test.publisher.TestPublisher;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class VertxServerHttpResponseTest {
@Mock
private RoutingContext mockRoutingContext;
@Mock
private HttpServerResponse mockHttpServerResponse;
private BufferConverter bufferConverter;
private VertxServerHttpResponse response;
@BeforeEach
public void setUp() {
given(mockRoutingContext.response()).willReturn(mockHttpServerResponse);
given(mockHttpServerResponse.headers()).willReturn(new HeadersMultiMap());
bufferConverter = new BufferConverter();
response = new VertxServerHttpResponse(mockRoutingContext, bufferConverter);
}
@Test
public void shouldInitHeaders() {
MultiMap originalHeaders = new HeadersMultiMap()
.add("key1", "value1")
.add("key1", "value2")
.add("key2", "value3");
given(mockHttpServerResponse.headers()).willReturn(originalHeaders);
response = new VertxServerHttpResponse(mockRoutingContext, bufferConverter);
HttpHeaders expectedHeaders = new HttpHeaders();
expectedHeaders.add("key1", "value1");
expectedHeaders.add("key1", "value2");
expectedHeaders.add("key2", "value3");
assertThat(response.getHeaders()).isEqualTo(expectedHeaders);
}
@Test
public void shouldGetNativeResponse() {
assertThat((HttpServerResponse) response.getNativeResponse()).isEqualTo(mockHttpServerResponse);
}
@Test
public void shouldWriteFile() {
given(mockHttpServerResponse.sendFile(any(), anyLong(), anyLong(), any())).will(invocation -> {
Handler<AsyncResult<Void>> handler = invocation.getArgument(3);
handler.handle(Future.succeededFuture());
return mockHttpServerResponse;
});
response.writeWith(Paths.get("/tmp/test"), 0, 0)
.block();
verify(mockHttpServerResponse).sendFile(eq("/tmp/test"), eq(0L), eq(0L), any());
}
@Test
public void shouldWriteFromPublisher() {
Buffer firstChunk = Buffer.buffer("chunk 1");
Buffer secondChunk = Buffer.buffer("chunk 2");
TestPublisher<DataBuffer> source = TestPublisher.create();
Mono<Void> result = response.writeWithInternal(source);
StepVerifier.create(result)
.expectSubscription()
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(bufferConverter.toDataBuffer(firstChunk)))
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(bufferConverter.toDataBuffer(secondChunk)))
.then(() -> source.assertMinRequested(1))
.then(source::complete)
.verifyComplete();
verify(mockHttpServerResponse).write(firstChunk);
verify(mockHttpServerResponse).write(secondChunk);
}
@Test
public void shouldWriteFromPublisherAndFlush() {
Buffer firstChunk = Buffer.buffer("chunk 1");
Buffer secondChunk = Buffer.buffer("chunk 2");
TestPublisher<DataBuffer> source = TestPublisher.create();
Mono<Void> result = response.writeAndFlushWithInternal(Flux.just(source));
StepVerifier.create(result)
.expectSubscription()
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(bufferConverter.toDataBuffer(firstChunk)))
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(bufferConverter.toDataBuffer(secondChunk)))
.then(() -> source.assertMinRequested(1))
.then(source::complete)
.verifyComplete();
verify(mockHttpServerResponse).write(firstChunk);
verify(mockHttpServerResponse).write(secondChunk);
}
@Test
public void shouldApplyStatusCode() {
response.setStatusCode(HttpStatus.OK);
response.applyStatusCode();
verify(mockHttpServerResponse).setStatusCode(200);
}
@Test
public void shouldNotApplyNullStatusCode() {
response.applyStatusCode();
verify(mockHttpServerResponse, times(0)).setStatusCode(anyInt());
}
@Test
public void shouldApplyHeaders() {
response.getHeaders().put("key1", Arrays.asList("value1", "value2"));
response.getHeaders().add("key2", "value3");
response.applyHeaders();
verify(mockHttpServerResponse).putHeader("key1", (Iterable<String>) Arrays.asList("value1", "value2"));
verify(mockHttpServerResponse).putHeader("key2", (Iterable<String>) Collections.singletonList("value3"));
}
@Test
public void shouldApplyCookies() {
response.addCookie(
ResponseCookie.from("cookie1", "value1")
.domain("domain1")
.path("path1")
.maxAge(1)
.httpOnly(true)
.secure(true)
.build()
);
response.addCookie(
ResponseCookie.from("cookie1", "value2")
.domain("domain1")
.path("path1")
.maxAge(1)
.httpOnly(true)
.secure(true)
.build()
);
response.addCookie(
ResponseCookie.from("cookie2", "value3")
.domain("domain2")
.path("path2")
.maxAge(2)
.httpOnly(false)
.secure(false)
.build()
);
response.applyCookies();
// Cookie implementation doesn't override equals, so need to work around to be able to assert values
ArgumentCaptor<Cookie> cookieCaptor = ArgumentCaptor.forClass(Cookie.class);
verify(mockRoutingContext, times(3)).addCookie(cookieCaptor.capture());
assertThat(cookieCaptor.getAllValues().get(0)).isEqualToComparingFieldByField(
Cookie.cookie("cookie1", "value1")
.setDomain("domain1")
.setPath("path1")
.setMaxAge(1)
.setHttpOnly(true)
.setSecure(true)
);
assertThat(cookieCaptor.getAllValues().get(1)).isEqualToComparingFieldByField(
Cookie.cookie("cookie1", "value2")
.setDomain("domain1")
.setPath("path1")
.setMaxAge(1)
.setHttpOnly(true)
.setSecure(true)
);
assertThat(cookieCaptor.getAllValues().get(2)).isEqualToComparingFieldByField(
Cookie.cookie("cookie2", "value3")
.setDomain("domain2")
.setPath("path2")
.setMaxAge(2)
.setHttpOnly(false)
.setSecure(false)
);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/SslInfoImplTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/SslInfoImplTest.java | package dev.snowdrop.vertx.http.server;
import java.security.cert.Certificate;
import java.security.cert.X509Certificate;
import javax.net.ssl.SSLPeerUnverifiedException;
import javax.net.ssl.SSLSession;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.mockito.BDDMockito.given;
@ExtendWith(MockitoExtension.class)
public class SslInfoImplTest {
@Mock
private SSLSession mockSession;
@Mock
private Certificate mockCertificate;
@Mock
private X509Certificate mockX509Certificate;
private SslInfoImpl sslInfo;
@BeforeEach
public void setUp() {
sslInfo = new SslInfoImpl(mockSession);
}
@Test
public void shouldNotAllowNullSession() {
assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> new SslInfoImpl(null));
}
@Test
public void shouldIgnoreNullSessionId() {
assertThat(sslInfo.getSessionId()).isNull();
}
@Test
public void shouldGetSessionId() {
given(mockSession.getId()).willReturn(new byte[]{ -1, 0, 1 });
// -1 (#ffffffff) -> ff, 0 -> 00, 1 -> 01
assertThat(sslInfo.getSessionId()).isEqualTo("ff0001");
}
@Test
public void shouldHandleSSLPeerUnverifiedException() throws SSLPeerUnverifiedException {
given(mockSession.getPeerCertificates()).willThrow(SSLPeerUnverifiedException.class);
assertThat(sslInfo.getPeerCertificates()).isNull();
}
@Test
public void shouldGetX509Certificates() throws SSLPeerUnverifiedException {
given(mockSession.getPeerCertificates()).willReturn(new Certificate[]{ mockCertificate, mockX509Certificate });
assertThat(sslInfo.getPeerCertificates()).containsOnly(mockX509Certificate);
}
@Test
public void shouldNotGetX509Certificates() throws SSLPeerUnverifiedException {
given(mockSession.getPeerCertificates()).willReturn(new Certificate[]{ mockCertificate });
assertThat(sslInfo.getPeerCertificates()).isNull();
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/VertxReactiveWebServerFactoryCustomizerTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/VertxReactiveWebServerFactoryCustomizerTest.java | package dev.snowdrop.vertx.http.server;
import java.util.Collections;
import dev.snowdrop.vertx.http.server.properties.AddressCustomizer;
import dev.snowdrop.vertx.http.server.properties.CompressionCustomizer;
import dev.snowdrop.vertx.http.server.properties.HttpServerOptionsCustomizer;
import dev.snowdrop.vertx.http.server.properties.PortCustomizer;
import dev.snowdrop.vertx.http.server.properties.SslCustomizer;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class VertxReactiveWebServerFactoryCustomizerTest {
@Mock
private VertxReactiveWebServerFactory mockVertxReactiveWebServerFactory;
@Mock
private HttpServerOptionsCustomizer mockHttpServerOptionsCustomizer;
private VertxReactiveWebServerFactoryCustomizer customizer;
@BeforeEach
public void setUp() {
customizer =
new VertxReactiveWebServerFactoryCustomizer(Collections.singleton(mockHttpServerOptionsCustomizer));
}
@Test
public void shouldCustomizeWebServerFactory() {
customizer.customize(mockVertxReactiveWebServerFactory);
verify(mockVertxReactiveWebServerFactory).registerHttpServerOptionsCustomizer(any(PortCustomizer.class));
verify(mockVertxReactiveWebServerFactory).registerHttpServerOptionsCustomizer(any(AddressCustomizer.class));
verify(mockVertxReactiveWebServerFactory).registerHttpServerOptionsCustomizer(any(SslCustomizer.class));
verify(mockVertxReactiveWebServerFactory).registerHttpServerOptionsCustomizer(any(CompressionCustomizer.class));
verify(mockVertxReactiveWebServerFactory).registerHttpServerOptionsCustomizer(mockHttpServerOptionsCustomizer);
}
@Test
public void shouldHaveCorrectPriority() {
assertThat(customizer.getOrder()).isEqualTo(1);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/VertxReactiveWebServerFactoryTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/VertxReactiveWebServerFactoryTest.java | package dev.snowdrop.vertx.http.server;
import dev.snowdrop.vertx.http.server.properties.HttpServerOptionsCustomizer;
import dev.snowdrop.vertx.http.server.properties.HttpServerProperties;
import io.vertx.core.Vertx;
import io.vertx.core.http.HttpServerOptions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.boot.web.server.WebServer;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class VertxReactiveWebServerFactoryTest {
@Mock
private Vertx mockVertx;
@Mock
private HttpServerOptionsCustomizer mockCustomizer;
@Mock
private HttpServerProperties mockHttpServerProperties;
@Mock
private HttpServerOptions mockHttpServerOptions;
private VertxReactiveWebServerFactory webServerFactory;
@BeforeEach
public void setUp() {
given(mockHttpServerProperties.getHttpServerOptions()).willReturn(mockHttpServerOptions);
webServerFactory = new VertxReactiveWebServerFactory(mockVertx, mockHttpServerProperties);
}
@Test
public void shouldCreateWebServer() {
WebServer webServer = webServerFactory.getWebServer(null);
assertThat(webServer).isNotNull();
assertThat(webServer).isInstanceOf(VertxWebServer.class);
}
@Test
public void shouldCustomizeHttpServerOptions() {
webServerFactory.registerHttpServerOptionsCustomizer(mockCustomizer);
WebServer webServer = webServerFactory.getWebServer(null);
assertThat(webServer).isNotNull();
verify(mockCustomizer).apply(mockHttpServerOptions);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/properties/CompressionCustomizerTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/properties/CompressionCustomizerTest.java | package dev.snowdrop.vertx.http.server.properties;
import io.vertx.core.http.HttpServerOptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.boot.web.server.AbstractConfigurableWebServerFactory;
import org.springframework.boot.web.server.Compression;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class CompressionCustomizerTest {
@Mock
private AbstractConfigurableWebServerFactory mockFactory;
@Mock
private HttpServerOptions mockHttpServerOptions;
@Mock
private Compression mockCompression;
@Test
public void shouldEnableCompression() {
given(mockFactory.getCompression()).willReturn(mockCompression);
given(mockCompression.getEnabled()).willReturn(true);
CompressionCustomizer customizer = new CompressionCustomizer(mockFactory);
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions).setCompressionSupported(true);
}
@Test
public void shouldIgnoreNullCompression() {
CompressionCustomizer customizer = new CompressionCustomizer(mockFactory);
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions, times(0)).setCompressionSupported(anyBoolean());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/properties/SslCustomizerTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/properties/SslCustomizerTest.java | package dev.snowdrop.vertx.http.server.properties;
import java.util.Set;
import io.vertx.core.http.ClientAuth;
import io.vertx.core.http.HttpServerOptions;
import io.vertx.core.net.JksOptions;
import io.vertx.core.net.PfxOptions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.boot.web.server.AbstractConfigurableWebServerFactory;
import org.springframework.boot.web.server.Ssl;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
@ExtendWith(MockitoExtension.class)
public class SslCustomizerTest {
@Mock
private AbstractConfigurableWebServerFactory mockFactory;
@Mock
private HttpServerOptions mockHttpServerOptions;
@Mock
private Ssl mockSsl;
private SslCustomizer customizer;
@BeforeEach
public void setUp() {
given(mockFactory.getSsl()).willReturn(mockSsl);
customizer = new SslCustomizer(mockFactory);
}
@Test
public void shouldIgnoreNullSsl() {
given(mockFactory.getSsl()).willReturn(null);
customizer.apply(mockHttpServerOptions);
verifyNoInteractions(mockHttpServerOptions);
}
@Test
public void shouldEnableSsl() {
given(mockSsl.isEnabled()).willReturn(true);
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions).setSsl(true);
}
@Test
public void shouldHandleNullClientAuth() {
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions, times(0)).setClientAuth(any());
}
@Test
public void shouldSetNoneClientAuth() {
given(mockSsl.getClientAuth()).willReturn(Ssl.ClientAuth.NONE);
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions).setClientAuth(ClientAuth.NONE);
}
@Test
public void shouldSetWantClientAuth() {
given(mockSsl.getClientAuth()).willReturn(Ssl.ClientAuth.WANT);
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions).setClientAuth(ClientAuth.REQUEST);
}
@Test
public void shouldSetNeedClientAuth() {
given(mockSsl.getClientAuth()).willReturn(Ssl.ClientAuth.NEED);
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions).setClientAuth(ClientAuth.REQUIRED);
}
@Test
public void shouldHandleNullEnabledProtocols() {
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions, times(0)).setEnabledSecureTransportProtocols(any());
}
@Test
@SuppressWarnings("unchecked")
public void shouldSetEnabledProtocols() {
given(mockSsl.getEnabledProtocols()).willReturn(new String[]{ "protocol1", "protocol2", "protocol2" });
customizer.apply(mockHttpServerOptions);
ArgumentCaptor<Set> captor = ArgumentCaptor.forClass(Set.class);
verify(mockHttpServerOptions).setEnabledSecureTransportProtocols(captor.capture());
assertThat(captor.getValue()).containsOnly("protocol1", "protocol2");
}
@Test
public void shouldHandleNullCiphers() {
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions, times(0)).addEnabledCipherSuite(anyString());
}
@Test
public void shouldAddCiphers() {
given(mockSsl.getCiphers()).willReturn(new String[]{ "cipher1", "cipher2" });
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions).addEnabledCipherSuite("cipher1");
verify(mockHttpServerOptions).addEnabledCipherSuite("cipher2");
}
@Test
public void shouldHandleNullKeyStoreType() {
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions).setKeyCertOptions(null);
}
@Test
public void shouldSetJksKeyCert() {
given(mockSsl.getKeyStoreType()).willReturn("JKS");
given(mockSsl.getKeyStore()).willReturn("/key/store/path");
given(mockSsl.getKeyStorePassword()).willReturn("pass");
customizer.apply(mockHttpServerOptions);
ArgumentCaptor<JksOptions> captor = ArgumentCaptor.forClass(JksOptions.class);
verify(mockHttpServerOptions).setKeyCertOptions(captor.capture());
JksOptions jksOptions = captor.getValue();
assertThat(jksOptions.getPath()).isEqualTo("/key/store/path");
assertThat(jksOptions.getPassword()).isEqualTo("pass");
}
@Test
public void shouldSetPfxKeyCert() {
given(mockSsl.getKeyStoreType()).willReturn("PKCS12");
given(mockSsl.getKeyStore()).willReturn("/key/store/path");
given(mockSsl.getKeyStorePassword()).willReturn("pass");
customizer.apply(mockHttpServerOptions);
ArgumentCaptor<PfxOptions> captor = ArgumentCaptor.forClass(PfxOptions.class);
verify(mockHttpServerOptions).setKeyCertOptions(captor.capture());
PfxOptions pfxOptions = captor.getValue();
assertThat(pfxOptions.getPath()).isEqualTo("/key/store/path");
assertThat(pfxOptions.getPassword()).isEqualTo("pass");
}
@Test
public void shouldHandleNullTrustStoreType() {
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions).setTrustOptions(null);
}
@Test
public void shouldSetJksTrustOptions() {
given(mockSsl.getTrustStoreType()).willReturn("JKS");
given(mockSsl.getTrustStore()).willReturn("/trust/store/path");
given(mockSsl.getTrustStorePassword()).willReturn("pass");
customizer.apply(mockHttpServerOptions);
ArgumentCaptor<JksOptions> captor = ArgumentCaptor.forClass(JksOptions.class);
verify(mockHttpServerOptions).setTrustOptions(captor.capture());
JksOptions jksOptions = captor.getValue();
assertThat(jksOptions.getPath()).isEqualTo("/trust/store/path");
assertThat(jksOptions.getPassword()).isEqualTo("pass");
}
@Test
public void shouldSetPfxTrustOptions() {
given(mockSsl.getTrustStoreType()).willReturn("PKCS12");
given(mockSsl.getTrustStore()).willReturn("/trust/store/path");
given(mockSsl.getTrustStorePassword()).willReturn("pass");
customizer.apply(mockHttpServerOptions);
ArgumentCaptor<PfxOptions> captor = ArgumentCaptor.forClass(PfxOptions.class);
verify(mockHttpServerOptions).setTrustOptions(captor.capture());
PfxOptions pfxOptions = captor.getValue();
assertThat(pfxOptions.getPath()).isEqualTo("/trust/store/path");
assertThat(pfxOptions.getPassword()).isEqualTo("pass");
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/properties/PortCustomizerTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/properties/PortCustomizerTest.java | package dev.snowdrop.vertx.http.server.properties;
import io.vertx.core.http.HttpServerOptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.boot.web.server.AbstractConfigurableWebServerFactory;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class PortCustomizerTest {
@Mock
private AbstractConfigurableWebServerFactory mockFactory;
@Mock
private HttpServerOptions mockHttpServerOptions;
@Test
public void shouldSetValidPort() {
given(mockFactory.getPort()).willReturn(1);
PortCustomizer customizer = new PortCustomizer(mockFactory);
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions).setPort(1);
}
@Test
public void shouldIgnoreInvalidPort() {
given(mockFactory.getPort()).willReturn(-1);
PortCustomizer customizer = new PortCustomizer(mockFactory);
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions, times(0)).setPort(anyInt());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/properties/AddressCustomizerTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/server/properties/AddressCustomizerTest.java | package dev.snowdrop.vertx.http.server.properties;
import java.net.InetAddress;
import java.net.UnknownHostException;
import io.vertx.core.http.HttpServerOptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.boot.web.server.AbstractConfigurableWebServerFactory;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class AddressCustomizerTest {
@Mock
private AbstractConfigurableWebServerFactory mockFactory;
@Mock
private HttpServerOptions mockHttpServerOptions;
@Test
public void shouldSetValidAddress() throws UnknownHostException {
given(mockFactory.getAddress()).willReturn(InetAddress.getByName("localhost"));
AddressCustomizer customizer = new AddressCustomizer(mockFactory);
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions).setHost("127.0.0.1");
}
@Test
public void shouldIgnoreInvalidAddress() {
AddressCustomizer customizer = new AddressCustomizer(mockFactory);
customizer.apply(mockHttpServerOptions);
verify(mockHttpServerOptions, times(0)).setHost(anyString());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/client/VertxWebSocketClientTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/client/VertxWebSocketClientTest.java | package dev.snowdrop.vertx.http.client;
import java.net.URI;
import java.time.Duration;
import java.util.Arrays;
import dev.snowdrop.vertx.http.common.VertxWebSocketSession;
import io.vertx.core.AsyncResult;
import io.vertx.core.Handler;
import io.vertx.core.Promise;
import io.vertx.core.Vertx;
import io.vertx.core.http.HttpClient;
import io.vertx.core.http.HttpClientOptions;
import io.vertx.core.http.WebSocket;
import io.vertx.core.http.WebSocketConnectOptions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.http.HttpHeaders;
import reactor.core.publisher.Mono;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.will;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class VertxWebSocketClientTest {
private static final URI TEST_URI = URI.create("ws://example.com:8080/test");
@Mock
private Vertx mockVertx;
@Mock
private HttpClient mockHttpClient;
@Mock
private WebSocket mockWebSocket;
@BeforeEach
@SuppressWarnings("unchecked")
public void setUp() {
}
@Test
public void shouldNotAcceptNullVertx() {
try {
new VertxWebSocketClient(null);
fail("IllegalArgumentException expected");
} catch (IllegalArgumentException e) {
assertThat(e).hasMessage("Vertx is required");
}
}
@Test
@SuppressWarnings("unchecked")
public void shouldUseCorrectUri() {
getWebSocketClient().execute(TEST_URI, session -> Mono.empty())
.subscribe();
ArgumentCaptor<WebSocketConnectOptions> optionsCaptor = ArgumentCaptor.forClass(WebSocketConnectOptions.class);
verify(mockHttpClient).webSocket(optionsCaptor.capture(), any(Handler.class));
assertThat(optionsCaptor.getValue().getPort()).isEqualTo(TEST_URI.getPort());
assertThat(optionsCaptor.getValue().getHost()).isEqualTo(TEST_URI.getHost());
assertThat(optionsCaptor.getValue().getURI()).isEqualTo(TEST_URI.getPath());
}
@Test
@SuppressWarnings("unchecked")
public void shouldInitializeEmptyHeaders() {
getWebSocketClient().execute(TEST_URI, session -> Mono.empty())
.subscribe();
ArgumentCaptor<WebSocketConnectOptions> optionsCaptor = ArgumentCaptor.forClass(WebSocketConnectOptions.class);
verify(mockHttpClient).webSocket(optionsCaptor.capture(), any(Handler.class));
assertThat(optionsCaptor.getValue().getPort()).isEqualTo(TEST_URI.getPort());
assertThat(optionsCaptor.getValue().getHost()).isEqualTo(TEST_URI.getHost());
assertThat(optionsCaptor.getValue().getURI()).isEqualTo(TEST_URI.getPath());
assertThat(optionsCaptor.getValue().getHeaders()).isEmpty();
}
@Test
@SuppressWarnings("unchecked")
public void shouldAdaptHeaders() {
HttpHeaders headers = new HttpHeaders();
headers.put("key1", Arrays.asList("value1", "value2"));
headers.add("key2", "value3");
getWebSocketClient().execute(TEST_URI, headers, session -> Mono.empty())
.subscribe();
ArgumentCaptor<WebSocketConnectOptions> optionsCaptor = ArgumentCaptor.forClass(WebSocketConnectOptions.class);
verify(mockHttpClient).webSocket(optionsCaptor.capture(), any(Handler.class));
assertThat(optionsCaptor.getValue().getPort()).isEqualTo(TEST_URI.getPort());
assertThat(optionsCaptor.getValue().getHost()).isEqualTo(TEST_URI.getHost());
assertThat(optionsCaptor.getValue().getURI()).isEqualTo(TEST_URI.getPath());
assertThat(optionsCaptor.getValue().getHeaders().getAll("key1")).isEqualTo(headers.get("key1"));
assertThat(optionsCaptor.getValue().getHeaders().getAll("key2")).isEqualTo(headers.get("key2"));
}
@Test
public void shouldInitSession() {
getWebSocketClient().execute(TEST_URI, session -> session instanceof VertxWebSocketSession
? Mono.empty()
: Mono.error(new AssertionError("Wrong session type: " + session.getClass()))
).block(Duration.ofSeconds(2));
}
@Test
public void shouldCompleteSuccessfully() {
getWebSocketClient().execute(TEST_URI, session -> Mono.empty())
.block(Duration.ofSeconds(2));
}
@Test
public void shouldCompleteWithError() {
assertThatExceptionOfType(RuntimeException.class).isThrownBy(
() -> getWebSocketClient().execute(TEST_URI, session -> Mono.error(RuntimeException::new))
.block(Duration.ofSeconds(2)));
}
private VertxWebSocketClient getWebSocketClient() {
// Configure mock http client to invoke passed web socket handler
will(answer -> {
Promise<WebSocket> socketPromise = Promise.promise();
socketPromise.complete(mockWebSocket);
Handler<AsyncResult<WebSocket>> handler = answer.getArgument(1);
handler.handle(socketPromise.future());
return mockHttpClient;
}).given(mockHttpClient).webSocket(any(WebSocketConnectOptions.class), any(Handler.class));
given(mockVertx.createHttpClient(any(HttpClientOptions.class))).willReturn(mockHttpClient);
return new VertxWebSocketClient(mockVertx);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/client/VertxClientHttpRequestTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/client/VertxClientHttpRequestTest.java | package dev.snowdrop.vertx.http.client;
import java.net.URI;
import java.util.Arrays;
import java.util.Collections;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.HttpClientRequest;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.http.HttpCookie;
import org.springframework.http.HttpMethod;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import reactor.test.publisher.TestPublisher;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class VertxClientHttpRequestTest {
@Mock
private HttpClientRequest mockHttpClientRequest;
private BufferConverter bufferConverter;
private VertxClientHttpRequest request;
@BeforeEach
public void setUp() {
bufferConverter = new BufferConverter();
request = new VertxClientHttpRequest(mockHttpClientRequest, bufferConverter);
}
@Test
public void shouldGetMethod() {
given(mockHttpClientRequest.getMethod()).willReturn(io.vertx.core.http.HttpMethod.GET);
HttpMethod method = request.getMethod();
assertThat(method).isEqualTo(HttpMethod.GET);
}
@Test
public void shouldGetUri() {
given(mockHttpClientRequest.absoluteURI()).willReturn("http://example.com");
URI expectedUri = URI.create("http://example.com");
URI actualUri = request.getURI();
assertThat(actualUri).isEqualTo(expectedUri);
}
@Test
public void shouldGetBufferFactory() {
DataBufferFactory dataBufferFactory = request.bufferFactory();
assertThat(dataBufferFactory).isEqualTo(bufferConverter.getDataBufferFactory());
}
@Test
public void shouldWriteFromPublisher() {
Buffer firstChunk = Buffer.buffer("chunk 1");
Buffer secondChunk = Buffer.buffer("chunk 2");
TestPublisher<DataBuffer> source = TestPublisher.create();
Mono<Void> result = request.writeWith(source);
StepVerifier.create(result)
.expectSubscription()
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(bufferConverter.toDataBuffer(firstChunk)))
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(bufferConverter.toDataBuffer(secondChunk)))
.then(() -> source.assertMinRequested(1))
.then(source::complete)
.verifyComplete();
verify(mockHttpClientRequest).write(firstChunk);
verify(mockHttpClientRequest).write(secondChunk);
verify(mockHttpClientRequest).end();
}
@Test
public void shouldWriteFromPublisherAndFlush() {
Buffer firstChunk = Buffer.buffer("chunk 1");
Buffer secondChunk = Buffer.buffer("chunk 2");
TestPublisher<DataBuffer> source = TestPublisher.create();
Mono<Void> result = request.writeAndFlushWith(Flux.just(source));
StepVerifier.create(result)
.expectSubscription()
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(bufferConverter.toDataBuffer(firstChunk)))
.then(() -> source.assertMinRequested(1))
.then(() -> source.next(bufferConverter.toDataBuffer(secondChunk)))
.then(() -> source.assertMinRequested(1))
.then(source::complete)
.verifyComplete();
verify(mockHttpClientRequest).write(firstChunk);
verify(mockHttpClientRequest).write(secondChunk);
verify(mockHttpClientRequest).end();
}
@Test
public void shouldSetComplete() {
request.setComplete().block();
verify(mockHttpClientRequest).end();
}
@Test
public void shouldApplyHeaders() {
request.getHeaders().put("key1", Arrays.asList("value1", "value2"));
request.getHeaders().add("key2", "value3");
request.applyHeaders();
verify(mockHttpClientRequest).putHeader("key1", (Iterable<String>) Arrays.asList("value1", "value2"));
verify(mockHttpClientRequest).putHeader("key2", (Iterable<String>) Collections.singletonList("value3"));
}
@Test
public void shouldApplyCookies() {
HttpCookie cookie1 = new HttpCookie("key1", "value1");
HttpCookie cookie2 = new HttpCookie("key1", "value2");
HttpCookie cookie3 = new HttpCookie("key2", "value3");
request.getCookies().put("key1", Arrays.asList(cookie1, cookie2));
request.getCookies().add("key2", cookie3);
request.applyCookies();
verify(mockHttpClientRequest).putHeader("Cookie", cookie1.toString());
verify(mockHttpClientRequest).putHeader("Cookie", cookie2.toString());
verify(mockHttpClientRequest).putHeader("Cookie", cookie3.toString());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/client/VertxClientHttpResponseTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/client/VertxClientHttpResponseTest.java | package dev.snowdrop.vertx.http.client;
import java.util.Arrays;
import io.vertx.core.MultiMap;
import io.vertx.core.http.HttpClientResponse;
import io.vertx.core.http.impl.headers.HeadersMultiMap;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseCookie;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import reactor.core.publisher.Flux;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
@ExtendWith(MockitoExtension.class)
public class VertxClientHttpResponseTest {
@Mock
private HttpClientResponse mockDelegate;
@Test
public void shouldGetRawStatus() {
given(mockDelegate.statusCode()).willReturn(200);
VertxClientHttpResponse response = new VertxClientHttpResponse(mockDelegate, Flux.empty());
int code = response.getRawStatusCode();
assertThat(code).isEqualTo(200);
}
@Test
public void shouldGetStatusCode() {
given(mockDelegate.statusCode()).willReturn(200);
VertxClientHttpResponse response = new VertxClientHttpResponse(mockDelegate, Flux.empty());
HttpStatus status = response.getStatusCode();
assertThat(status).isEqualTo(HttpStatus.OK);
}
@Test
public void shouldGetBody() {
DataBufferFactory factory = new DefaultDataBufferFactory();
Flux<DataBuffer> body = Flux.just(factory.wrap("first".getBytes()), factory.wrap("second".getBytes()));
VertxClientHttpResponse response = new VertxClientHttpResponse(mockDelegate, body);
assertThat(response.getBody()).isEqualTo(body);
}
@Test
public void shouldGetHeaders() {
MultiMap originalHeaders = new HeadersMultiMap()
.add("key1", "value1")
.add("key1", "value2")
.add("key2", "value3");
given(mockDelegate.headers()).willReturn(originalHeaders);
HttpHeaders expectedHeaders = new HttpHeaders();
expectedHeaders.add("key1", "value1");
expectedHeaders.add("key1", "value2");
expectedHeaders.add("key2", "value3");
VertxClientHttpResponse response = new VertxClientHttpResponse(mockDelegate, Flux.empty());
HttpHeaders actualHeaders = response.getHeaders();
assertThat(actualHeaders).isEqualTo(expectedHeaders);
}
@Test
public void shouldGetCookies() {
ResponseCookie simpleCookie = ResponseCookie.from("key2", "value2")
.build();
ResponseCookie complexCookie = ResponseCookie.from("key1", "value1")
.domain("domain")
.httpOnly(true)
.maxAge(1)
.path("path")
.secure(true)
.build();
given(mockDelegate.cookies()).willReturn(
Arrays.asList(simpleCookie.toString(), complexCookie.toString()));
MultiValueMap<String, ResponseCookie> expectedCookies = new LinkedMultiValueMap<>();
expectedCookies.add(simpleCookie.getName(), simpleCookie);
expectedCookies.add(complexCookie.getName(), complexCookie);
VertxClientHttpResponse response = new VertxClientHttpResponse(mockDelegate, Flux.empty());
MultiValueMap<String, ResponseCookie> actualCookies = response.getCookies();
assertThat(actualCookies).isEqualTo(expectedCookies);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/client/VertxClientHttpConnectorTest.java | vertx-spring-boot-starter-http/src/test/java/dev/snowdrop/vertx/http/client/VertxClientHttpConnectorTest.java | package dev.snowdrop.vertx.http.client;
import java.net.URI;
import io.vertx.core.Vertx;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.http.client.reactive.ClientHttpResponse;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import static org.springframework.http.HttpMethod.GET;
@ExtendWith(MockitoExtension.class)
public class VertxClientHttpConnectorTest {
@Mock
private Vertx mockVertx;
@Test
public void shouldNotConnectRelativeUri() {
VertxClientHttpConnector connector = new VertxClientHttpConnector(mockVertx);
Mono<ClientHttpResponse> result = connector.connect(GET, URI.create("/test"), r -> Mono.empty());
StepVerifier.create(result)
.verifyErrorMessage("URI is not absolute: /test");
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/utils/BufferConverter.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/utils/BufferConverter.java | package dev.snowdrop.vertx.http.utils;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.vertx.core.buffer.Buffer;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.NettyDataBufferFactory;
public final class BufferConverter {
private final NettyDataBufferFactory dataBufferFactory;
public BufferConverter() {
this(new NettyDataBufferFactory(ByteBufAllocator.DEFAULT));
}
public BufferConverter(NettyDataBufferFactory dataBufferFactory) {
this.dataBufferFactory = dataBufferFactory;
}
public NettyDataBufferFactory getDataBufferFactory() {
return dataBufferFactory;
}
public DataBuffer toDataBuffer(Buffer buffer) {
ByteBuf byteBuf = buffer.getByteBuf();
return dataBufferFactory.wrap(byteBuf);
}
public Buffer toBuffer(DataBuffer dataBuffer) {
ByteBuf byteBuf = NettyDataBufferFactory.toByteBuf(dataBuffer);
return Buffer.buffer(byteBuf);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/utils/CookieConverter.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/utils/CookieConverter.java | package dev.snowdrop.vertx.http.utils;
import java.util.List;
import java.util.stream.Collectors;
import io.vertx.core.http.Cookie;
import org.springframework.http.HttpCookie;
import org.springframework.http.ResponseCookie;
public final class CookieConverter {
public static Cookie toCookie(ResponseCookie responseCookie) {
Cookie cookie = Cookie.cookie(responseCookie.getName(), responseCookie.getValue())
.setDomain(responseCookie.getDomain())
.setPath(responseCookie.getPath())
.setHttpOnly(responseCookie.isHttpOnly())
.setSecure(responseCookie.isSecure());
if (!responseCookie.getMaxAge().isNegative()) {
cookie.setMaxAge(responseCookie.getMaxAge().getSeconds());
}
return cookie;
}
public static HttpCookie toHttpCookie(Cookie cookie) {
return new HttpCookie(cookie.getName(), cookie.getValue());
}
public static List<ResponseCookie> toResponseCookies(String cookieHeader) {
return java.net.HttpCookie.parse(cookieHeader)
.stream()
.map(CookieConverter::toResponseCookie)
.collect(Collectors.toList());
}
private static ResponseCookie toResponseCookie(java.net.HttpCookie cookie) {
return ResponseCookie.from(cookie.getName(), cookie.getValue())
.domain(cookie.getDomain())
.httpOnly(cookie.isHttpOnly())
.maxAge(cookie.getMaxAge())
.path(cookie.getPath())
.secure(cookie.getSecure())
.build();
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/common/ReadStreamFluxBuilder.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/common/ReadStreamFluxBuilder.java | package dev.snowdrop.vertx.http.common;
import java.util.Objects;
import java.util.function.Function;
import io.vertx.core.streams.ReadStream;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ObjectUtils;
import reactor.core.publisher.Flux;
public class ReadStreamFluxBuilder<T, R> {
private final Logger logger = LoggerFactory.getLogger(getClass());
private ReadStream<T> readStream;
private Function<T, R> dataConverter;
public ReadStreamFluxBuilder<T, R> readStream(ReadStream<T> readStream) {
this.readStream = readStream;
return this;
}
public ReadStreamFluxBuilder<T, R> dataConverter(Function<T, R> dataConverter) {
this.dataConverter = dataConverter;
return this;
}
public Flux<R> build() {
Objects.requireNonNull(readStream, "Read stream is required");
Objects.requireNonNull(dataConverter, "Data converter is required");
readStream.pause();
return Flux.create(sink -> {
String logPrefix = "[" + ObjectUtils.getIdentityHexString(readStream) + "] ";
readStream
.handler(data -> {
logger.debug("{}Received '{}'", logPrefix, data);
sink.next(dataConverter.apply(data));
})
.exceptionHandler(throwable -> {
logger.debug("{}Received exception '{}'", logPrefix, throwable.toString());
sink.error(throwable);
})
.endHandler(v -> {
logger.debug("{}Read stream ended", logPrefix);
sink.complete();
});
sink.onRequest(i -> {
logger.debug("{} Fetching '{}' entries from a read stream", logPrefix, i);
readStream.fetch(i);
});
});
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/common/VertxWebSocketSession.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/common/VertxWebSocketSession.java | package dev.snowdrop.vertx.http.common;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.WebSocketBase;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.util.ObjectUtils;
import org.springframework.web.reactive.socket.CloseStatus;
import org.springframework.web.reactive.socket.HandshakeInfo;
import org.springframework.web.reactive.socket.WebSocketMessage;
import org.springframework.web.reactive.socket.adapter.AbstractWebSocketSession;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public class VertxWebSocketSession extends AbstractWebSocketSession<WebSocketBase> {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final BufferConverter bufferConverter;
private final int requestLimit;
public VertxWebSocketSession(WebSocketBase delegate, HandshakeInfo handshakeInfo, BufferConverter bufferConverter,
int maxWebSocketFrameSize, int maxWebSocketMessageSize) {
super(delegate, ObjectUtils.getIdentityHexString(delegate), handshakeInfo,
bufferConverter.getDataBufferFactory());
this.bufferConverter = bufferConverter;
if (maxWebSocketMessageSize < 1 || maxWebSocketFrameSize < 1) {
throw new IllegalArgumentException("Max web socket frame and message sizes cannot be less than 1");
}
this.requestLimit = maxWebSocketMessageSize / maxWebSocketFrameSize + 1;
}
@Override
public Flux<WebSocketMessage> receive() {
return Flux.create(sink -> {
logger.debug("{}Connecting to a web socket read stream", getLogPrefix());
WebSocketBase socket = getDelegate();
socket.pause()
.textMessageHandler(payload -> {
logger.debug("{}Received text '{}' from a web socket read stream", getLogPrefix(), payload);
sink.next(textMessage(payload));
})
.binaryMessageHandler(payload -> {
logger.debug("{}Received binary '{}' from a web socket read stream", getLogPrefix(), payload);
sink.next(binaryMessage(payload));
})
.pongHandler(payload -> {
logger.debug("{}Received pong '{}' from a web socket read stream", getLogPrefix(), payload);
sink.next(pongMessage(payload));
})
.exceptionHandler(throwable -> {
logger.debug("{}Received exception '{}' from a web socket read stream", getLogPrefix(), throwable);
sink.error(throwable);
})
.endHandler(e -> {
logger.debug("{}Web socket read stream ended", getLogPrefix());
sink.complete();
});
sink.onRequest(i -> {
logger.debug("{}Fetching '{}' entries from a web socket read stream", getLogPrefix(), i);
socket.fetch(i);
});
}
);
}
@Override
public Mono<Void> send(Publisher<WebSocketMessage> messages) {
return Mono.create(sink -> {
logger.debug("{}Subscribing to messages publisher", getLogPrefix());
Subscriber<WebSocketMessage> subscriber =
new WriteStreamSubscriber.Builder<WebSocketBase, WebSocketMessage>()
.writeStream(getDelegate())
.nextHandler(this::messageHandler)
.endHook(sink)
.requestLimit(requestLimit)
.build();
messages.subscribe(subscriber);
});
}
@Override
public boolean isOpen() {
return !getDelegate().isClosed();
}
@Override
public Mono<Void> close(CloseStatus status) {
logger.debug("{}Closing web socket with status '{}'", getLogPrefix(), status);
return Mono.create(sink -> getDelegate()
.closeHandler(e -> {
logger.debug("{}Web socket closed", getLogPrefix());
sink.success();
})
.close((short) status.getCode(), status.getReason()));
}
@Override
public Mono<CloseStatus> closeStatus() {
Short code = getDelegate().closeStatusCode();
if (code == null) {
return Mono.empty();
}
String reason = getDelegate().closeReason();
if (reason == null) {
return Mono.just(new CloseStatus(code));
}
return Mono.just(new CloseStatus(code, reason));
}
private void messageHandler(WebSocketBase socket, WebSocketMessage message) {
if (message.getType() == WebSocketMessage.Type.TEXT) {
String payload = message.getPayloadAsText();
socket.writeTextMessage(payload);
} else {
Buffer buffer = bufferConverter.toBuffer(message.getPayload());
if (message.getType() == WebSocketMessage.Type.PING) {
socket.writePing(buffer);
} else if (message.getType() == WebSocketMessage.Type.PONG) {
socket.writePong(buffer);
} else {
socket.writeBinaryMessage(buffer);
}
}
}
private WebSocketMessage binaryMessage(Buffer payloadBuffer) {
DataBuffer payload = bufferConverter.toDataBuffer(payloadBuffer);
return new WebSocketMessage(WebSocketMessage.Type.BINARY, payload);
}
private WebSocketMessage pongMessage(Buffer payloadBuffer) {
DataBuffer payload = bufferConverter.toDataBuffer(payloadBuffer);
return new WebSocketMessage(WebSocketMessage.Type.PONG, payload);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/common/WriteStreamSubscriber.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/common/WriteStreamSubscriber.java | package dev.snowdrop.vertx.http.common;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.BiConsumer;
import io.vertx.core.streams.WriteStream;
import org.reactivestreams.Subscription;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ObjectUtils;
import reactor.core.publisher.BaseSubscriber;
import reactor.core.publisher.MonoSink;
import reactor.core.publisher.SignalType;
public class WriteStreamSubscriber<T extends WriteStream<?>, U> extends BaseSubscriber<U> {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final T writeStream;
private final BiConsumer<T, U> nextHandler;
private final MonoSink<Void> endHook;
private final long requestLimit;
private final AtomicLong pendingCount = new AtomicLong();
private final AtomicBoolean isActive = new AtomicBoolean(false);
private final String logPrefix;
private WriteStreamSubscriber(T writeStream, BiConsumer<T, U> nextHandler, MonoSink<Void> endHook,
long requestLimit) {
this.writeStream = writeStream;
this.nextHandler = nextHandler;
this.endHook = endHook;
this.requestLimit = requestLimit;
this.logPrefix = "[" + ObjectUtils.getIdentityHexString(writeStream) + "] ";
writeStream.exceptionHandler(this::exceptionHandler);
writeStream.drainHandler(this::drainHandler);
}
@Override
protected void hookOnSubscribe(Subscription subscription) {
logger.debug("{}{} subscribed", logPrefix, writeStream);
isActive.set(true);
requestIfNotFull();
}
@Override
protected void hookOnNext(U value) {
logger.debug("{}Next: {}", logPrefix, value);
nextHandler.accept(writeStream, value);
pendingCount.decrementAndGet();
requestIfNotFull();
}
@Override
protected void hookOnComplete() {
logger.debug("{}Completed", logPrefix);
endHook.success();
}
@Override
protected void hookOnCancel() {
logger.debug("{}Canceled", logPrefix);
endHook.success();
}
@Override
protected void hookOnError(Throwable throwable) {
logger.debug("{}Error: {}", logPrefix, throwable);
endHook.error(throwable);
}
@Override
protected void hookFinally(SignalType type) {
isActive.set(false);
}
private void exceptionHandler(Throwable ignored) {
cancel();
}
private void drainHandler(Void event) {
logger.debug("{} drain", logPrefix);
requestIfNotFull();
}
private void requestIfNotFull() {
if (isActive.get() && !writeStream.writeQueueFull() && pendingCount.get() < requestLimit) {
logger.debug("{}Requesting more data pendingCount={} requestLimit={}", logPrefix, pendingCount.get(),
requestLimit);
request(requestLimit - pendingCount.getAndSet(requestLimit));
}
}
public static class Builder<T extends WriteStream<?>, U> {
private T writeStream;
private BiConsumer<T, U> nextHandler;
private MonoSink<Void> endHook;
private long requestLimit = 1L;
public Builder<T, U> writeStream(T writeStream) {
this.writeStream = writeStream;
return this;
}
public Builder<T, U> nextHandler(BiConsumer<T, U> nextHandler) {
this.nextHandler = nextHandler;
return this;
}
public Builder<T, U> endHook(MonoSink<Void> endHook) {
this.endHook = endHook;
return this;
}
public Builder<T, U> requestLimit(long requestLimit) {
this.requestLimit = requestLimit;
return this;
}
public WriteStreamSubscriber<T, U> build() {
Objects.requireNonNull(writeStream, "Write stream is required");
Objects.requireNonNull(nextHandler, "Next handler is required");
Objects.requireNonNull(endHook, "End hook is required");
return new WriteStreamSubscriber<>(writeStream, nextHandler, endHook, requestLimit);
}
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/ServerAutoConfiguration.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/ServerAutoConfiguration.java | package dev.snowdrop.vertx.http.server;
import java.util.Set;
import dev.snowdrop.vertx.http.server.properties.HttpServerOptionsCustomizer;
import dev.snowdrop.vertx.http.server.properties.HttpServerProperties;
import io.vertx.core.Vertx;
import org.springframework.boot.autoconfigure.AutoConfigureOrder;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.reactive.server.ReactiveWebServerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.http.ReactiveHttpInputMessage;
import org.springframework.web.reactive.socket.server.WebSocketService;
import org.springframework.web.reactive.socket.server.support.HandshakeWebSocketService;
import org.springframework.web.reactive.socket.server.support.WebSocketHandlerAdapter;
@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE)
@ConditionalOnClass(ReactiveHttpInputMessage.class)
@ConditionalOnMissingBean(ReactiveWebServerFactory.class)
@EnableConfigurationProperties(HttpServerProperties.class)
public class ServerAutoConfiguration {
@Bean
public VertxReactiveWebServerFactory vertxReactiveWebServerFactory(Vertx vertx, HttpServerProperties properties) {
return new VertxReactiveWebServerFactory(vertx, properties);
}
@Bean
public VertxReactiveWebServerFactoryCustomizer vertxWebServerFactoryCustomizer(
Set<HttpServerOptionsCustomizer> userDefinedCustomizers) {
return new VertxReactiveWebServerFactoryCustomizer(userDefinedCustomizers);
}
@Bean
public WebSocketService webSocketService(HttpServerProperties properties) {
VertxRequestUpgradeStrategy requestUpgradeStrategy = new VertxRequestUpgradeStrategy(
properties.getMaxWebSocketFrameSize(), properties.getMaxWebSocketMessageSize());
return new HandshakeWebSocketService(requestUpgradeStrategy);
}
@Bean
public WebSocketHandlerAdapter webSocketHandlerAdapter(WebSocketService webSocketService) {
return new WebSocketHandlerAdapter(webSocketService);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxHttpHandlerAdapter.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxHttpHandlerAdapter.java | package dev.snowdrop.vertx.http.server;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import io.vertx.core.Handler;
import io.vertx.ext.web.RoutingContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.HttpHandler;
public class VertxHttpHandlerAdapter implements Handler<RoutingContext> {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final HttpHandler httpHandler;
private final BufferConverter bufferConverter;
public VertxHttpHandlerAdapter(HttpHandler httpHandler) {
this.httpHandler = httpHandler;
this.bufferConverter = new BufferConverter();
}
@Override
public void handle(RoutingContext context) {
logger.debug("Adapting Vert.x server request to WebFlux request");
VertxServerHttpRequest webFluxRequest = new VertxServerHttpRequest(context, bufferConverter);
VertxServerHttpResponse webFluxResponse = new VertxServerHttpResponse(context, bufferConverter);
httpHandler.handle(webFluxRequest, webFluxResponse)
.doOnSuccess(v -> {
logger.debug("Completed server request handling");
if (!context.response().ended()) {
context.response()
.end();
}
}
)
.doOnError(throwable -> {
logger.debug("Completed server request handling with an error '{}'", throwable.toString());
context.response()
.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR.value())
.end();
}
)
.subscribe();
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxServerHttpRequest.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxServerHttpRequest.java | package dev.snowdrop.vertx.http.server;
import java.net.InetSocketAddress;
import java.net.URI;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import dev.snowdrop.vertx.http.utils.CookieConverter;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.HttpServerRequest;
import io.vertx.core.net.SocketAddress;
import io.vertx.ext.web.RoutingContext;
import dev.snowdrop.vertx.http.common.ReadStreamFluxBuilder;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpCookie;
import org.springframework.http.HttpHeaders;
import org.springframework.http.server.reactive.AbstractServerHttpRequest;
import org.springframework.http.server.reactive.SslInfo;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import reactor.core.publisher.Flux;
public class VertxServerHttpRequest extends AbstractServerHttpRequest {
private final RoutingContext context;
private final HttpServerRequest delegate;
private final Flux<DataBuffer> bodyFlux;
public VertxServerHttpRequest(RoutingContext context, BufferConverter bufferConverter) {
super(initUri(context.request()), "", initHeaders(context.request()));
this.context = context;
this.delegate = context.request();
this.bodyFlux = new ReadStreamFluxBuilder<Buffer, DataBuffer>()
.readStream(delegate)
.dataConverter(bufferConverter::toDataBuffer)
.build();
}
@SuppressWarnings("unchecked")
@Override
public <T> T getNativeRequest() {
return (T) delegate;
}
@Override
public String getMethodValue() {
return delegate.method().name();
}
@Override
public Flux<DataBuffer> getBody() {
return bodyFlux;
}
@Override
public InetSocketAddress getRemoteAddress() {
SocketAddress address = delegate.remoteAddress();
if (address == null) {
return null;
}
return new InetSocketAddress(address.host(), address.port());
}
@Override
protected MultiValueMap<String, HttpCookie> initCookies() {
MultiValueMap<String, HttpCookie> cookies = new LinkedMultiValueMap<>();
context.cookieMap()
.values()
.stream()
.map(CookieConverter::toHttpCookie)
.forEach(cookie -> cookies.add(cookie.getName(), cookie));
return cookies;
}
@Override
protected SslInfo initSslInfo() {
if (delegate.sslSession() == null) {
return null;
}
return new SslInfoImpl(delegate.sslSession());
}
private static URI initUri(HttpServerRequest request) {
return URI.create(request.absoluteURI());
}
private static HttpHeaders initHeaders(HttpServerRequest request) {
HttpHeaders headers = new HttpHeaders();
request.headers()
.forEach(e -> headers.add(e.getKey(), e.getValue()));
return headers;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxWebServer.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxWebServer.java | package dev.snowdrop.vertx.http.server;
import java.time.Duration;
import io.vertx.core.Handler;
import io.vertx.core.Vertx;
import io.vertx.core.http.HttpServer;
import io.vertx.core.http.HttpServerOptions;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.RoutingContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.web.server.WebServer;
import org.springframework.boot.web.server.WebServerException;
import reactor.core.publisher.Mono;
public class VertxWebServer implements WebServer {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final Vertx vertx;
private final HttpServerOptions httpServerOptions;
private final Handler<RoutingContext> requestHandler;
private HttpServer server;
public VertxWebServer(Vertx vertx, HttpServerOptions httpServerOptions, Handler<RoutingContext> requestHandler) {
this.vertx = vertx;
this.httpServerOptions = httpServerOptions;
this.requestHandler = requestHandler;
}
@Override
public void start() throws WebServerException {
if (server != null) {
return;
}
Router router = Router.router(vertx);
router.route()
.handler(requestHandler);
server = vertx
.createHttpServer(httpServerOptions)
.requestHandler(router);
Mono<Void> future = Mono.create(sink -> server.listen(result -> {
if (result.succeeded()) {
logger.info("Vert.x HTTP server started on port {}", getPort());
sink.success();
} else {
sink.error(result.cause());
}
}));
future.block(Duration.ofSeconds(5));
}
@Override
public void stop() throws WebServerException {
if (server == null) {
return;
}
Mono<Void> future = Mono.create(sink -> server.close(result -> {
if (result.succeeded()) {
sink.success();
} else {
sink.error(result.cause());
}
}));
future
.doOnTerminate(() -> server = null)
.block(Duration.ofSeconds(5));
}
@Override
public int getPort() {
if (server != null) {
return server.actualPort();
}
return 0;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/SslInfoImpl.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/SslInfoImpl.java | package dev.snowdrop.vertx.http.server;
import java.security.cert.Certificate;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import javax.net.ssl.SSLSession;
import org.springframework.http.server.reactive.SslInfo;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
/**
* Session ID and certificates extraction logic copied from org.springframework.http.server.reactive.DefaultSslInfo.
*/
final class SslInfoImpl implements SslInfo {
private final SSLSession session;
SslInfoImpl(SSLSession session) {
Assert.notNull(session, "SSLSession is required");
this.session = session;
}
@Nullable
@Override
public String getSessionId() {
byte[] bytes = session.getId();
if (bytes == null) {
return null;
}
StringBuilder sb = new StringBuilder();
for (byte b : bytes) {
String digit = Integer.toHexString(b);
if (digit.length() < 2) {
sb.append('0');
}
if (digit.length() > 2) {
digit = digit.substring(digit.length() - 2);
}
sb.append(digit);
}
return sb.toString();
}
@Nullable
@Override
public X509Certificate[] getPeerCertificates() {
Certificate[] certificates;
try {
certificates = session.getPeerCertificates();
} catch (Throwable ex) {
return null;
}
List<X509Certificate> result = new ArrayList<>(certificates.length);
for (Certificate certificate : certificates) {
if (certificate instanceof X509Certificate) {
result.add((X509Certificate) certificate);
}
}
return (!result.isEmpty() ? result.toArray(new X509Certificate[0]) : null);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxReactiveWebServerFactoryCustomizer.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxReactiveWebServerFactoryCustomizer.java | package dev.snowdrop.vertx.http.server;
import java.util.Set;
import dev.snowdrop.vertx.http.server.properties.AddressCustomizer;
import dev.snowdrop.vertx.http.server.properties.HttpServerOptionsCustomizer;
import dev.snowdrop.vertx.http.server.properties.PortCustomizer;
import dev.snowdrop.vertx.http.server.properties.SslCustomizer;
import dev.snowdrop.vertx.http.server.properties.CompressionCustomizer;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.core.Ordered;
public class VertxReactiveWebServerFactoryCustomizer
implements WebServerFactoryCustomizer<VertxReactiveWebServerFactory>, Ordered {
private final Set<HttpServerOptionsCustomizer> userDefinedCustomizers;
public VertxReactiveWebServerFactoryCustomizer(Set<HttpServerOptionsCustomizer> userDefinedCustomizers) {
this.userDefinedCustomizers = userDefinedCustomizers;
}
@Override
public void customize(VertxReactiveWebServerFactory factory) {
factory.registerHttpServerOptionsCustomizer(new PortCustomizer(factory));
factory.registerHttpServerOptionsCustomizer(new AddressCustomizer(factory));
factory.registerHttpServerOptionsCustomizer(new SslCustomizer(factory));
factory.registerHttpServerOptionsCustomizer(new CompressionCustomizer(factory));
if (userDefinedCustomizers != null) {
userDefinedCustomizers.forEach(factory::registerHttpServerOptionsCustomizer);
}
}
@Override
public int getOrder() {
return 1; // Run after ReactiveWebServerFactoryCustomizer
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxReactiveWebServerFactory.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxReactiveWebServerFactory.java | package dev.snowdrop.vertx.http.server;
import java.util.LinkedList;
import java.util.List;
import io.vertx.core.Vertx;
import io.vertx.core.http.HttpServerOptions;
import dev.snowdrop.vertx.http.server.properties.HttpServerOptionsCustomizer;
import dev.snowdrop.vertx.http.server.properties.HttpServerProperties;
import org.springframework.boot.web.reactive.server.AbstractReactiveWebServerFactory;
import org.springframework.boot.web.server.WebServer;
import org.springframework.http.server.reactive.HttpHandler;
public class VertxReactiveWebServerFactory extends AbstractReactiveWebServerFactory {
private final Vertx vertx;
private final HttpServerProperties properties;
private final List<HttpServerOptionsCustomizer> httpServerOptionsCustomizers = new LinkedList<>();
public VertxReactiveWebServerFactory(Vertx vertx, HttpServerProperties properties) {
this.vertx = vertx;
this.properties = properties;
}
@Override
public WebServer getWebServer(HttpHandler httpHandler) {
HttpServerOptions httpServerOptions = customizeHttpServerOptions(properties.getHttpServerOptions());
VertxHttpHandlerAdapter handler = new VertxHttpHandlerAdapter(httpHandler);
return new VertxWebServer(vertx, httpServerOptions, handler);
}
public void registerHttpServerOptionsCustomizer(HttpServerOptionsCustomizer customizer) {
httpServerOptionsCustomizers.add(customizer);
}
private HttpServerOptions customizeHttpServerOptions(HttpServerOptions httpServerOptions) {
for (HttpServerOptionsCustomizer customizer : httpServerOptionsCustomizers) {
httpServerOptions = customizer.apply(httpServerOptions);
}
return httpServerOptions;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxRequestUpgradeStrategy.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxRequestUpgradeStrategy.java | package dev.snowdrop.vertx.http.server;
import dev.snowdrop.vertx.http.common.VertxWebSocketSession;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import io.vertx.core.http.HttpServerRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.server.reactive.AbstractServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.lang.Nullable;
import org.springframework.web.reactive.socket.HandshakeInfo;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.server.RequestUpgradeStrategy;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.net.URI;
import java.util.function.Supplier;
public class VertxRequestUpgradeStrategy implements RequestUpgradeStrategy {
private static final Logger LOGGER = LoggerFactory.getLogger(VertxRequestUpgradeStrategy.class);
private final BufferConverter bufferConverter;
private final int maxWebSocketFrameSize;
private final int maxWebSocketMessageSize;
public VertxRequestUpgradeStrategy(int maxWebSocketFrameSize, int maxWebSocketMessageSize) {
this.bufferConverter = new BufferConverter();
this.maxWebSocketFrameSize = maxWebSocketFrameSize;
this.maxWebSocketMessageSize = maxWebSocketMessageSize;
}
@Override
public Mono<Void> upgrade(ServerWebExchange exchange, WebSocketHandler handler,
@Nullable String subProtocol, Supplier<HandshakeInfo> handshakeInfoFactory) {
LOGGER.debug("Upgrading request to web socket");
ServerHttpRequest request = exchange.getRequest();
ServerHttpResponse response = exchange.getResponse();
HttpServerRequest vertxRequest = ((AbstractServerHttpRequest) request).getNativeRequest();
HandshakeInfo handshakeInfo = handshakeInfoFactory.get();
URI uri = exchange.getRequest().getURI();
return Mono.fromCompletionStage(vertxRequest.toWebSocket().toCompletionStage())
.flatMap(ws -> {
VertxWebSocketSession session = new VertxWebSocketSession(ws, handshakeInfo, bufferConverter, maxWebSocketFrameSize, maxWebSocketMessageSize);
return handler.handle(session).checkpoint(uri + " [VertxRequestUpgradeStrategy]");
}).then(response.setComplete());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxServerHttpResponse.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/VertxServerHttpResponse.java | package dev.snowdrop.vertx.http.server;
import java.nio.file.Path;
import java.util.List;
import dev.snowdrop.vertx.http.common.WriteStreamSubscriber;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import dev.snowdrop.vertx.http.utils.CookieConverter;
import io.vertx.core.http.HttpServerResponse;
import io.vertx.ext.web.RoutingContext;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ZeroCopyHttpOutputMessage;
import org.springframework.http.server.reactive.AbstractServerHttpResponse;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import static java.util.function.Function.identity;
public class VertxServerHttpResponse extends AbstractServerHttpResponse implements ZeroCopyHttpOutputMessage {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final RoutingContext context;
private final HttpServerResponse delegate;
private final BufferConverter bufferConverter;
public VertxServerHttpResponse(RoutingContext context, BufferConverter bufferConverter) {
super(bufferConverter.getDataBufferFactory(), initHeaders(context.response()));
this.context = context;
this.delegate = context.response();
this.bufferConverter = bufferConverter;
}
@SuppressWarnings("unchecked")
@Override
public <T> T getNativeResponse() {
return (T) delegate;
}
@Override
public Mono<Void> writeWith(Path file, long position, long count) {
Mono<Void> writeCompletion = Mono.create(sink -> {
logger.debug("Sending file '{}' pos='{}' count='{}'", file, position, count);
delegate.sendFile(file.toString(), position, count, result -> {
if (result.succeeded()) {
sink.success();
} else {
sink.error(result.cause());
}
});
});
return doCommit(() -> writeCompletion);
}
@Override
protected Mono<Void> writeWithInternal(Publisher<? extends DataBuffer> chunks) {
return Mono.create(sink -> {
logger.debug("Subscribing to body publisher");
Subscriber<DataBuffer> subscriber = new WriteStreamSubscriber.Builder<HttpServerResponse, DataBuffer>()
.writeStream(delegate)
.endHook(sink)
.nextHandler((stream, value) -> stream.write(bufferConverter.toBuffer(value)))
.build();
chunks.subscribe(subscriber);
});
}
@Override
protected Mono<Void> writeAndFlushWithInternal(Publisher<? extends Publisher<? extends DataBuffer>> chunks) {
return writeWithInternal(Flux.from(chunks).flatMap(identity()));
}
@Override
protected void applyStatusCode() {
HttpStatus statusCode = getStatusCode();
if (statusCode != null) {
delegate.setStatusCode(statusCode.value());
}
}
@Override
protected void applyHeaders() {
HttpHeaders headers = getHeaders();
if (!headers.containsKey(HttpHeaders.CONTENT_LENGTH)) {
logger.debug("Setting chunked response");
delegate.setChunked(true);
}
headers.forEach(delegate::putHeader);
}
@Override
protected void applyCookies() {
getCookies()
.values()
.stream()
.flatMap(List::stream)
.map(CookieConverter::toCookie)
.forEach(context::addCookie);
}
private static HttpHeaders initHeaders(HttpServerResponse response) {
HttpHeaders headers = new HttpHeaders();
response.headers()
.forEach(e -> headers.add(e.getKey(), e.getValue()));
return headers;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/SslCustomizer.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/SslCustomizer.java | package dev.snowdrop.vertx.http.server.properties;
import java.util.Arrays;
import java.util.LinkedHashSet;
import io.vertx.core.http.ClientAuth;
import io.vertx.core.http.HttpServerOptions;
import io.vertx.core.net.JksOptions;
import io.vertx.core.net.KeyCertOptions;
import io.vertx.core.net.PfxOptions;
import io.vertx.core.net.TrustOptions;
import org.springframework.boot.context.properties.PropertyMapper;
import org.springframework.boot.web.server.AbstractConfigurableWebServerFactory;
import org.springframework.boot.web.server.Ssl;
public class SslCustomizer implements HttpServerOptionsCustomizer {
private final AbstractConfigurableWebServerFactory factory;
private final PropertyMapper propertyMapper;
public SslCustomizer(AbstractConfigurableWebServerFactory factory) {
this.factory = factory;
this.propertyMapper = PropertyMapper.get();
}
@Override
public HttpServerOptions apply(HttpServerOptions options) {
Ssl ssl = factory.getSsl();
if (ssl == null) {
return options;
}
options.setSsl(ssl.isEnabled());
options.setKeyCertOptions(keyCertOptionsAdapter(ssl));
options.setTrustOptions(trustOptionsAdapter(ssl));
propertyMapper.from(ssl.getClientAuth())
.whenNonNull()
.as(this::clientAuthAdapter)
.to(options::setClientAuth);
propertyMapper.from(ssl.getEnabledProtocols())
.whenNonNull()
.as(Arrays::asList)
.as(LinkedHashSet::new)
.to(options::setEnabledSecureTransportProtocols);
propertyMapper.from(ssl.getCiphers())
.whenNonNull()
.as(Arrays::stream)
.to(stream -> stream.forEach(options::addEnabledCipherSuite));
return options;
}
private ClientAuth clientAuthAdapter(Ssl.ClientAuth clientAuth) {
switch (clientAuth) {
case WANT:
return ClientAuth.REQUEST;
case NEED:
return ClientAuth.REQUIRED;
default:
return ClientAuth.NONE;
}
}
private KeyCertOptions keyCertOptionsAdapter(Ssl ssl) {
if ("JKS".equalsIgnoreCase(ssl.getKeyStoreType())) {
return getJksOptions(ssl.getKeyStore(), ssl.getKeyStorePassword());
} else if ("PKCS12".equalsIgnoreCase(ssl.getKeyStoreType())) {
return getPfxOptions(ssl.getKeyStore(), ssl.getKeyStorePassword());
}
return null;
}
private TrustOptions trustOptionsAdapter(Ssl ssl) {
if ("JKS".equalsIgnoreCase(ssl.getTrustStoreType())) {
return getJksOptions(ssl.getTrustStore(), ssl.getTrustStorePassword());
} else if ("PKCS12".equalsIgnoreCase(ssl.getTrustStoreType())) {
return getPfxOptions(ssl.getTrustStore(), ssl.getTrustStorePassword());
}
return null;
}
private JksOptions getJksOptions(String path, String password) {
JksOptions options = new JksOptions();
options.setPath(path);
options.setPassword(password);
return options;
}
private PfxOptions getPfxOptions(String path, String password) {
PfxOptions options = new PfxOptions();
options.setPath(path);
options.setPassword(password);
return options;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/HttpServerProperties.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/HttpServerProperties.java | package dev.snowdrop.vertx.http.server.properties;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import io.vertx.core.http.ClientAuth;
import io.vertx.core.http.HttpServerOptions;
import io.vertx.core.http.HttpVersion;
import org.springframework.boot.autoconfigure.web.ServerProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot properties integration for HttpServerOptions. All expect the following properties are integrated:
* usePooledBuffers (deprecated), crlPaths, crlValues, keyCertOptions, trustOptions, sslEngineOptions.
* <p>
* If sslEngineOptions, crlPath or crlValues are required, please use HttpServerOptionsCustomizer.
* If keyCertOptions or trustOptions either use {@link HttpServerOptionsCustomizer} or {@link ServerProperties}.
*/
@ConfigurationProperties(prefix = HttpServerProperties.PROPERTIES_PREFIX)
public class HttpServerProperties {
static final String PROPERTIES_PREFIX = "vertx.http.server";
private final HttpServerOptions delegate = new HttpServerOptions();
public HttpServerOptions getHttpServerOptions() {
return new HttpServerOptions(delegate);
}
// Vert.x NetServerOptions
/**
* @return the port
* @see HttpServerOptions#getPort()
*/
public int getPort() {
return delegate.getPort();
}
public void setPort(int port) {
delegate.setPort(port);
}
/**
* @return the host
* @see HttpServerOptions#getHost()
*/
public String getHost() {
return delegate.getHost();
}
public void setHost(String host) {
delegate.setHost(host);
}
/**
* @return the value of accept backlog
* @see HttpServerOptions#getAcceptBacklog()
*/
public int getAcceptBacklog() {
return delegate.getAcceptBacklog();
}
public void setAcceptBacklog(int acceptBacklog) {
delegate.setAcceptBacklog(acceptBacklog);
}
/**
* One of "NONE, REQUEST, REQUIRED". If it's set to "REQUIRED" then server will require the
* SSL cert to be presented otherwise it won't accept the request. If it's set to "REQUEST" then
* it won't mandate the certificate to be presented, basically make it optional.
*
* @return client auth value
* @see HttpServerOptions#getClientAuth()
*/
public ClientAuth getClientAuth() {
return delegate.getClientAuth();
}
public void setClientAuth(ClientAuth clientAuth) {
delegate.setClientAuth(clientAuth);
}
/**
* @return whether the server supports Server Name Indication
* @see HttpServerOptions#isSni()
*/
public boolean isSni() {
return delegate.isSni();
}
public void setSni(boolean sni) {
delegate.setSni(sni);
}
// Vert.x HttpServerOptions
/**
* @return {@code true} if the server supports gzip/deflate compression
* @see HttpServerOptions#isCompressionSupported()
*/
public boolean isCompressionSupported() {
return delegate.isCompressionSupported();
}
public void setCompressionSupported(boolean compressionSupported) {
delegate.setCompressionSupported(compressionSupported);
}
/**
* @return the server gzip/deflate 'compression level' to be used in responses when client and server support is turned on
* @see HttpServerOptions#getCompressionLevel()
*/
public int getCompressionLevel() {
return delegate.getCompressionLevel();
}
public void setCompressionLevel(int compressionLevel) {
delegate.setCompressionLevel(compressionLevel);
}
/**
* @return whether server accepts unmasked frames
* @see HttpServerOptions#isAcceptUnmaskedFrames()
*/
public boolean isAcceptUnmaskedFrames() {
return delegate.isAcceptUnmaskedFrames();
}
public void setAcceptUnmaskedFrames(boolean acceptUnmaskedFrames) {
delegate.setAcceptUnmaskedFrames(acceptUnmaskedFrames);
}
/**
* @return the maximum WebSocket frame size
* @see HttpServerOptions#getMaxWebSocketFrameSize()
* @deprecated see {@link #getMaxWebSocketFrameSize()}
*/
@Deprecated
public int getMaxWebsocketFrameSize() {
return delegate.getMaxWebSocketFrameSize();
}
/**
* @return the maximum WebSocket frame size
* @see HttpServerOptions#getMaxWebSocketFrameSize()
*/
public int getMaxWebSocketFrameSize() {
return delegate.getMaxWebSocketFrameSize();
}
@Deprecated
public void setMaxWebsocketFrameSize(int maxWebSocketFrameSize) {
delegate.setMaxWebSocketFrameSize(maxWebSocketFrameSize);
}
public void setMaxWebSocketFrameSize(int maxWebSocketFrameSize) {
delegate.setMaxWebSocketFrameSize(maxWebSocketFrameSize);
}
/**
* @return the maximum WebSocket message size
* @see HttpServerOptions#getMaxWebSocketMessageSize()
* @deprecated use {@link #getMaxWebSocketMessageSize()}
*/
@Deprecated
public int getMaxWebsocketMessageSize() {
return delegate.getMaxWebSocketMessageSize();
}
/**
* @return the maximum WebSocket message size
* @see HttpServerOptions#getMaxWebSocketMessageSize()
*/
public int getMaxWebSocketMessageSize() {
return delegate.getMaxWebSocketMessageSize();
}
@Deprecated
public void setMaxWebsocketMessageSize(int maxWebSocketMessageSize) {
delegate.setMaxWebSocketMessageSize(maxWebSocketMessageSize);
}
public void setMaxWebSocketMessageSize(int maxWebSocketMessageSize) {
delegate.setMaxWebSocketMessageSize(maxWebSocketMessageSize);
}
/**
* @return Get the WebSocket sub-protocols
* @see HttpServerOptions#getWebSocketSubProtocols()
*/
public List<String> getWebSocketSubProtocols() {
return delegate.getWebSocketSubProtocols();
}
public void setWebSocketSubProtocols(List<String> subProtocols) {
delegate.setWebSocketSubProtocols(subProtocols);
}
/**
* @return whether 100 Continue should be handled automatically
* @see HttpServerOptions#isHandle100ContinueAutomatically()
*/
public boolean isHandle100ContinueAutomatically() {
return delegate.isHandle100ContinueAutomatically();
}
public void setHandle100ContinueAutomatically(boolean handle100ContinueAutomatically) {
delegate.setHandle100ContinueAutomatically(handle100ContinueAutomatically);
}
/**
* @return the maximum HTTP chunk size
* @see HttpServerOptions#getMaxChunkSize()
*/
public int getMaxChunkSize() {
return delegate.getMaxChunkSize();
}
public void setMaxChunkSize(int maxChunkSize) {
delegate.setMaxChunkSize(maxChunkSize);
}
/**
* @return the maximum length of the initial line for HTTP/1.x (e.g. {@code "GET / HTTP/1.0"})
* @see HttpServerOptions#getMaxInitialLineLength()
*/
public int getMaxInitialLineLength() {
return delegate.getMaxInitialLineLength();
}
public void setMaxInitialLineLength(int maxInitialLineLength) {
delegate.setMaxInitialLineLength(maxInitialLineLength);
}
/**
* @return Returns the maximum length of all headers for HTTP/1.x
* @see HttpServerOptions#getMaxHeaderSize()
*/
public int getMaxHeaderSize() {
return delegate.getMaxHeaderSize();
}
public void setMaxHeaderSize(int maxHeaderSize) {
delegate.setMaxHeaderSize(maxHeaderSize);
}
/**
* @return the list of protocol versions to provide during the Application-Layer Protocol Negotiatiation
* @see HttpServerOptions#getAlpnVersions()
*/
public List<HttpVersion> getAlpnVersions() {
return delegate.getAlpnVersions();
}
public void setAlpnVersions(List<HttpVersion> alpnVersions) {
delegate.setAlpnVersions(alpnVersions);
}
/**
* @return the default HTTP/2 connection window size
* @see HttpServerOptions#getHttp2ConnectionWindowSize()
*/
public int getHttp2ConnectionWindowSize() {
return delegate.getHttp2ConnectionWindowSize();
}
public void setHttp2ConnectionWindowSize(int http2ConnectionWindowSize) {
delegate.setHttp2ConnectionWindowSize(http2ConnectionWindowSize);
}
/**
* @return {@code true} if the server supports decompression
* @see HttpServerOptions#isDecompressionSupported()
*/
public boolean isDecompressionSupported() {
return delegate.isDecompressionSupported();
}
public void setDecompressionSupported(boolean decompressionSupported) {
delegate.setDecompressionSupported(decompressionSupported);
}
/**
* @return the initial buffer size for the HTTP decoder
* @see HttpServerOptions#getDecoderInitialBufferSize()
*/
public int getDecoderInitialBufferSize() {
return delegate.getDecoderInitialBufferSize();
}
public void setDecoderInitialBufferSize(int decoderInitialBufferSize) {
delegate.setDecoderInitialBufferSize(decoderInitialBufferSize);
}
/**
* Get whether WebSocket the per-frame deflate compression extension is supported.
*
* @return {@code true} if the http server will accept the per-frame deflate compression extension
* @see HttpServerOptions#getPerFrameWebSocketCompressionSupported()
* @deprecated use {@link #isPerFrameWebSocketCompressionSupported()}
*/
@Deprecated
public boolean isPerFrameWebsocketCompressionSupported() {
return delegate.getPerFrameWebSocketCompressionSupported();
}
/**
* Get whether WebSocket the per-frame deflate compression extension is supported.
*
* @return {@code true} if the http server will accept the per-frame deflate compression extension
* @see HttpServerOptions#getPerFrameWebSocketCompressionSupported()
*/
public boolean isPerFrameWebSocketCompressionSupported() {
return delegate.getPerFrameWebSocketCompressionSupported();
}
@Deprecated
public void setPerFrameWebsocketCompressionSupported(boolean perFrameWebSocketCompressionSupported) {
delegate.setPerFrameWebSocketCompressionSupported(perFrameWebSocketCompressionSupported);
}
public void setPerFrameWebSocketCompressionSupported(boolean perFrameWebSocketCompressionSupported) {
delegate.setPerFrameWebSocketCompressionSupported(perFrameWebSocketCompressionSupported);
}
/**
* Get whether WebSocket per-message deflate compression extension is supported.
*
* @return {@code true} if the http server will accept the per-message deflate compression extension
* @see HttpServerOptions#getPerMessageWebSocketCompressionSupported()
* @deprecated use {@link #isPerFrameWebSocketCompressionSupported()}
*/
@Deprecated
public boolean isPerMessageWebsocketCompressionSupported() {
return delegate.getPerMessageWebSocketCompressionSupported();
}
/**
* Get whether WebSocket per-message deflate compression extension is supported.
*
* @return {@code true} if the http server will accept the per-message deflate compression extension
* @see HttpServerOptions#getPerMessageWebSocketCompressionSupported()
*/
public boolean isPerMessageWebSocketCompressionSupported() {
return delegate.getPerMessageWebSocketCompressionSupported();
}
@Deprecated
public void setPerMessageWebsocketCompressionSupported(boolean perMessageWebSocketCompressionSupported) {
delegate.setPerMessageWebSocketCompressionSupported(perMessageWebSocketCompressionSupported);
}
public void setPerMessageWebSocketCompressionSupported(boolean perMessageWebSocketCompressionSupported) {
delegate.setPerMessageWebSocketCompressionSupported(perMessageWebSocketCompressionSupported);
}
/**
* @return the current WebSocket deflate compression level
* @see HttpServerOptions#getWebSocketCompressionLevel()
* @deprecated use {@link #getWebSocketCompressionLevel()}
*/
@Deprecated
public int getWebsocketCompressionLevel() {
return delegate.getWebSocketCompressionLevel();
}
/**
* @return the current WebSocket deflate compression level
* @see HttpServerOptions#getWebSocketCompressionLevel()
*/
public int getWebSocketCompressionLevel() {
return delegate.getWebSocketCompressionLevel();
}
@Deprecated
public void setWebsocketCompressionLevel(int webSocketCompressionLevel) {
delegate.setWebSocketCompressionLevel(webSocketCompressionLevel);
}
public void setWebSocketCompressionLevel(int webSocketCompressionLevel) {
delegate.setWebSocketCompressionLevel(webSocketCompressionLevel);
}
/**
* @return {@code true} when the WebSocket server will accept the {@code server_no_context_takeover} parameter for the per-message
* deflate compression extension offered by the client
* @see HttpServerOptions#getWebSocketAllowServerNoContext()
* @deprecated use {@link #isWebSocketAllowServerNoContext()}
*/
@Deprecated
public boolean isWebsocketAllowServerNoContext() {
return delegate.getWebSocketAllowServerNoContext();
}
/**
* @return {@code true} when the WebSocket server will accept the {@code server_no_context_takeover} parameter for the per-message
* deflate compression extension offered by the client
* @see HttpServerOptions#getWebSocketAllowServerNoContext()
*/
public boolean isWebSocketAllowServerNoContext() {
return delegate.getWebSocketAllowServerNoContext();
}
@Deprecated
public void setWebsocketAllowServerNoContext(boolean allowServerNoContext) {
delegate.setWebSocketAllowServerNoContext(allowServerNoContext);
}
public void setWebSocketAllowServerNoContext(boolean allowServerNoContext) {
delegate.setWebSocketAllowServerNoContext(allowServerNoContext);
}
/**
* @return {@code true} when the WebSocket server will accept the {@code client_no_context_takeover} parameter for the per-message
* deflate compression extension offered by the client
* @see HttpServerOptions#getWebSocketPreferredClientNoContext()
* @deprecated use {@link #isWebSocketPreferredClientNoContext()}
*/
@Deprecated
public boolean isWebsocketPreferredClientNoContext() {
return delegate.getWebSocketPreferredClientNoContext();
}
/**
* @return {@code true} when the WebSocket server will accept the {@code client_no_context_takeover} parameter for the per-message
* deflate compression extension offered by the client
* @see HttpServerOptions#getWebSocketPreferredClientNoContext()
*/
public boolean isWebSocketPreferredClientNoContext() {
return delegate.getWebSocketPreferredClientNoContext();
}
@Deprecated
public void setWebsocketPreferredClientNoContext(boolean preferredClientNoContext) {
delegate.setWebSocketPreferredClientNoContext(preferredClientNoContext);
}
public void setWebSocketPreferredClientNoContext(boolean preferredClientNoContext) {
delegate.setWebSocketPreferredClientNoContext(preferredClientNoContext);
}
/**
* @return the {@literal SETTINGS_HEADER_TABLE_SIZE} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#getHeaderTableSize()
*/
public long getHeaderTableSize() {
return delegate.getInitialSettings().getHeaderTableSize();
}
public void setHeaderTableSize(long headerTableSize) {
delegate.getInitialSettings().setHeaderTableSize(headerTableSize);
}
/**
* @return the {@literal SETTINGS_ENABLE_PUSH} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#isPushEnabled()
*/
public boolean isPushEnabled() {
return delegate.getInitialSettings().isPushEnabled();
}
public void setPushEnabled(boolean pushEnabled) {
delegate.getInitialSettings().setPushEnabled(pushEnabled);
}
/**
* @return the {@literal SETTINGS_MAX_CONCURRENT_STREAMS} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#getMaxConcurrentStreams()
*/
public long getMaxConcurrentStreams() {
return delegate.getInitialSettings().getMaxConcurrentStreams();
}
public void setMaxConcurrentStreams(long maxConcurrentStreams) {
delegate.getInitialSettings().setMaxConcurrentStreams(maxConcurrentStreams);
}
/**
* @return the {@literal SETTINGS_INITIAL_WINDOW_SIZE} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#getInitialWindowSize()
*/
public int getInitialWindowSize() {
return delegate.getInitialSettings().getInitialWindowSize();
}
public void setInitialWindowSize(int initialWindowSize) {
delegate.getInitialSettings().setInitialWindowSize(initialWindowSize);
}
/**
* @return the {@literal SETTINGS_MAX_FRAME_SIZE} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#getMaxFrameSize()
*/
public int getMaxFrameSize() {
return delegate.getInitialSettings().getMaxFrameSize();
}
public void setMaxFrameSize(int maxFrameSize) {
delegate.getInitialSettings().setMaxFrameSize(maxFrameSize);
}
/**
* @return the {@literal SETTINGS_MAX_HEADER_LIST_SIZE} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#getMaxHeaderListSize()
*/
public long getMaxHeaderListSize() {
return delegate.getInitialSettings().getMaxHeaderListSize();
}
public void setMaxHeaderListSize(long maxHeaderListSize) {
delegate.getInitialSettings().setMaxHeaderListSize(maxHeaderListSize);
}
/**
* @return the extra settings used for extending HTTP/2
* @see io.vertx.core.http.Http2Settings#getExtraSettings()
*/
public Map<Integer, Long> getHttp2ExtraSettings() {
return delegate.getInitialSettings().getExtraSettings();
}
public void setHttp2ExtraSettings(Map<Integer, Long> http2ExtraSettings) {
delegate.getInitialSettings().setExtraSettings(http2ExtraSettings);
}
// Vert.x TCPSSLOptions
/**
* @return TCP no delay enabled ?
* @see HttpServerOptions#isTcpNoDelay()
*/
public boolean isTcpNoDelay() {
return delegate.isTcpNoDelay();
}
public void setTcpNoDelay(boolean tcpNoDelay) {
delegate.setTcpNoDelay(tcpNoDelay);
}
/**
* @return is TCP keep alive enabled?
* @see HttpServerOptions#isTcpKeepAlive()
*/
public boolean isTcpKeepAlive() {
return delegate.isTcpKeepAlive();
}
public void setTcpKeepAlive(boolean tcpKeepAlive) {
delegate.setTcpKeepAlive(tcpKeepAlive);
}
/**
* @return is SO_linger enabled
* @see HttpServerOptions#getSoLinger()
*/
public int getSoLinger() {
return delegate.getSoLinger();
}
public void setSoLinger(int soLinger) {
delegate.setSoLinger(soLinger);
}
/**
* @return the idle timeout, in time unit specified by {@link #getIdleTimeoutUnit()}.
* @see HttpServerOptions#getIdleTimeout()
*/
public int getIdleTimeout() {
return delegate.getIdleTimeout();
}
public void setIdleTimeout(int idleTimeout) {
delegate.setIdleTimeout(idleTimeout);
}
/**
* @return the idle timeout unit.
* @see HttpServerOptions#getIdleTimeoutUnit()
*/
public TimeUnit getIdleTimeoutUnit() {
return delegate.getIdleTimeoutUnit();
}
public void setIdleTimeoutUnit(TimeUnit idleTimeoutUnit) {
delegate.setIdleTimeoutUnit(idleTimeoutUnit);
}
/**
* @return is SSL/TLS enabled?
* @see HttpServerOptions#isSsl()
*/
public boolean isSsl() {
return delegate.isSsl();
}
public void setSsl(boolean ssl) {
delegate.setSsl(ssl);
}
/**
* @return the enabled cipher suites
* @see HttpServerOptions#getEnabledCipherSuites()
*/
public Set<String> getEnabledCipherSuites() {
return delegate.getEnabledCipherSuites();
}
public void setEnabledCipherSuites(Set<String> enabledCipherSuites) {
if (enabledCipherSuites != null) {
enabledCipherSuites.forEach(delegate::addEnabledCipherSuite);
}
}
/**
* @return whether to use or not Application-Layer Protocol Negotiation
* @see HttpServerOptions#isUseAlpn()
*/
public boolean isUseAlpn() {
return delegate.isUseAlpn();
}
public void setUseAlpn(boolean useAlpn) {
delegate.setUseAlpn(useAlpn);
}
/**
* Returns the enabled SSL/TLS protocols
*
* @return the enabled protocols
* @see HttpServerOptions#getEnabledSecureTransportProtocols()
*/
public Set<String> getEnabledSecureTransportProtocols() {
return delegate.getEnabledSecureTransportProtocols();
}
public void setEnabledSecureTransportProtocols(Set<String> enabledSecureTransportProtocols) {
delegate.setEnabledSecureTransportProtocols(enabledSecureTransportProtocols);
}
/**
* @return wether {@code TCP_FASTOPEN} option is enabled
* @see HttpServerOptions#isTcpFastOpen()
*/
public boolean isTcpFastOpen() {
return delegate.isTcpFastOpen();
}
public void setTcpFastOpen(boolean tcpFastOpen) {
delegate.setTcpFastOpen(tcpFastOpen);
}
/**
* @return wether {@code TCP_CORK} option is enabled
* @see HttpServerOptions#isTcpCork()
*/
public boolean isTcpCork() {
return delegate.isTcpCork();
}
public void setTcpCork(boolean tcpCork) {
delegate.setTcpCork(tcpCork);
}
/**
* @return wether {@code TCP_QUICKACK} option is enabled
* @see HttpServerOptions#isTcpQuickAck()
*/
public boolean isTcpQuickAck() {
return delegate.isTcpQuickAck();
}
public void setTcpQuickAck(boolean tcpQuickAck) {
delegate.setTcpQuickAck(tcpQuickAck);
}
// NetworkOptions
/**
* Return the TCP send buffer size, in bytes.
*
* @return the send buffer size
* @see HttpServerOptions#getSendBufferSize()
*/
public int getSendBufferSize() {
return delegate.getSendBufferSize();
}
public void setSendBufferSize(int sendBufferSize) {
delegate.setSendBufferSize(sendBufferSize);
}
/**
* Return the TCP receive buffer size, in bytes
*
* @return the receive buffer size
* @see HttpServerOptions#getReceiveBufferSize()
*/
public int getReceiveBufferSize() {
return delegate.getReceiveBufferSize();
}
public void setReceiveBufferSize(int receiveBufferSize) {
delegate.setReceiveBufferSize(receiveBufferSize);
}
/**
* @return the value of traffic class
* @see HttpServerOptions#getTrafficClass()
*/
public int getTrafficClass() {
return delegate.getTrafficClass();
}
public void setTrafficClass(int trafficClass) {
delegate.setTrafficClass(trafficClass);
}
/**
* @return the value of reuse address
* @see HttpServerOptions#isReuseAddress()
*/
public boolean isReuseAddress() {
return delegate.isReuseAddress();
}
public void setReuseAddress(boolean reuseAddress) {
delegate.setReuseAddress(reuseAddress);
}
/**
* @return true when network activity logging is enabled
* @see HttpServerOptions#getLogActivity()
*/
public boolean getLogActivity() {
return delegate.getLogActivity();
}
public void setLogActivity(boolean logActivity) {
delegate.setLogActivity(logActivity);
}
/**
* @return the value of reuse address - only supported by native transports
* @see HttpServerOptions#isReusePort()
*/
public boolean isReusePort() {
return delegate.isReusePort();
}
public void setReusePort(boolean reusePort) {
delegate.setReusePort(reusePort);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/PortCustomizer.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/PortCustomizer.java | package dev.snowdrop.vertx.http.server.properties;
import io.vertx.core.http.HttpServerOptions;
import org.springframework.boot.web.server.AbstractConfigurableWebServerFactory;
public class PortCustomizer implements HttpServerOptionsCustomizer {
private final AbstractConfigurableWebServerFactory factory;
public PortCustomizer(AbstractConfigurableWebServerFactory factory) {
this.factory = factory;
}
@Override
public HttpServerOptions apply(HttpServerOptions options) {
if (factory.getPort() >= 0) {
options.setPort(factory.getPort());
}
return options;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/CompressionCustomizer.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/CompressionCustomizer.java | package dev.snowdrop.vertx.http.server.properties;
import io.vertx.core.http.HttpServerOptions;
import org.springframework.boot.web.server.AbstractConfigurableWebServerFactory;
import org.springframework.boot.web.server.Compression;
public class CompressionCustomizer implements HttpServerOptionsCustomizer {
private final AbstractConfigurableWebServerFactory factory;
public CompressionCustomizer(AbstractConfigurableWebServerFactory factory) {
this.factory = factory;
}
@Override
public HttpServerOptions apply(HttpServerOptions options) {
Compression compression = factory.getCompression();
if (compression != null) {
options.setCompressionSupported(compression.getEnabled());
}
return options;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/HttpServerOptionsCustomizer.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/HttpServerOptionsCustomizer.java | package dev.snowdrop.vertx.http.server.properties;
import java.util.function.Function;
import io.vertx.core.http.HttpServerOptions;
@FunctionalInterface
public interface HttpServerOptionsCustomizer extends Function<HttpServerOptions, HttpServerOptions> {
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/AddressCustomizer.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/server/properties/AddressCustomizer.java | package dev.snowdrop.vertx.http.server.properties;
import java.net.InetAddress;
import io.vertx.core.http.HttpServerOptions;
import org.springframework.boot.web.server.AbstractConfigurableWebServerFactory;
public class AddressCustomizer implements HttpServerOptionsCustomizer {
private final AbstractConfigurableWebServerFactory factory;
public AddressCustomizer(AbstractConfigurableWebServerFactory factory) {
this.factory = factory;
}
@Override
public HttpServerOptions apply(HttpServerOptions options) {
InetAddress address = factory.getAddress();
if (address != null && address.getHostAddress() != null) {
options.setHost(address.getHostAddress());
}
return options;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/VertxClientHttpRequest.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/VertxClientHttpRequest.java | package dev.snowdrop.vertx.http.client;
import java.net.URI;
import java.util.Collection;
import dev.snowdrop.vertx.http.common.WriteStreamSubscriber;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import io.vertx.core.http.HttpClientRequest;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.http.HttpCookie;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.client.reactive.AbstractClientHttpRequest;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import static java.util.function.Function.identity;
public class VertxClientHttpRequest extends AbstractClientHttpRequest {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final HttpClientRequest delegate;
private final BufferConverter bufferConverter;
public VertxClientHttpRequest(HttpClientRequest delegate, BufferConverter bufferConverter) {
this.delegate = delegate;
this.bufferConverter = bufferConverter;
}
@Override
public HttpMethod getMethod() {
return HttpMethod.resolve(delegate.getMethod().name());
}
@Override
public URI getURI() {
return URI.create(delegate.absoluteURI());
}
@Override
@SuppressWarnings("unchecked")
public <T> T getNativeRequest() {
return (T) delegate;
}
@Override
public DataBufferFactory bufferFactory() {
return bufferConverter.getDataBufferFactory();
}
@Override
public Mono<Void> writeWith(Publisher<? extends DataBuffer> chunks) {
Mono<Void> writeCompletion = Mono.create(sink -> {
logger.debug("Subscribing to body publisher");
Subscriber<DataBuffer> subscriber = new WriteStreamSubscriber.Builder<HttpClientRequest, DataBuffer>()
.writeStream(delegate)
.endHook(sink)
.nextHandler((stream, value) -> stream.write(bufferConverter.toBuffer(value)))
.build();
chunks.subscribe(subscriber);
});
Mono<Void> endCompletion = Mono.create(sink -> {
logger.debug("Completing request after writing");
delegate.end();
sink.success();
});
return doCommit(() -> writeCompletion.then(endCompletion));
}
@Override
public Mono<Void> writeAndFlushWith(Publisher<? extends Publisher<? extends DataBuffer>> chunks) {
return writeWith(Flux.from(chunks).flatMap(identity()));
}
@Override
public Mono<Void> setComplete() {
return doCommit(() -> Mono.create(sink -> {
logger.debug("Completing empty request");
delegate.end();
sink.success();
}));
}
@Override
protected void applyHeaders() {
HttpHeaders headers = getHeaders();
if (!headers.containsKey(HttpHeaders.CONTENT_LENGTH)) {
logger.debug("Setting chunked request");
delegate.setChunked(true);
}
headers.forEach(delegate::putHeader);
}
@Override
protected void applyCookies() {
getCookies()
.values()
.stream()
.flatMap(Collection::stream)
.map(HttpCookie::toString)
.forEach(cookie -> delegate.putHeader("Cookie", cookie));
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/ClientAutoConfiguration.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/ClientAutoConfiguration.java | package dev.snowdrop.vertx.http.client;
import java.util.Set;
import dev.snowdrop.vertx.http.client.properties.HttpClientOptionsCustomizer;
import dev.snowdrop.vertx.http.client.properties.HttpClientProperties;
import io.vertx.core.Vertx;
import io.vertx.core.http.HttpClient;
import io.vertx.core.http.HttpClientOptions;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.reactive.ClientHttpConnector;
import org.springframework.web.reactive.function.client.WebClient;
@Configuration
@ConditionalOnClass({ WebClient.class, HttpClient.class })
@ConditionalOnBean(Vertx.class)
@ConditionalOnMissingBean(ClientHttpConnector.class)
@AutoConfigureBefore(ClientHttpConnectorAutoConfiguration.class)
@EnableConfigurationProperties(HttpClientProperties.class)
public class ClientAutoConfiguration {
private final HttpClientOptions httpClientOptions;
public ClientAutoConfiguration(HttpClientProperties properties, Set<HttpClientOptionsCustomizer> customizers) {
this.httpClientOptions = customizeHttpClientOptions(properties.getHttpClientOptions(), customizers);
}
@Bean
public VertxClientHttpConnector vertxClientHttpConnector(Vertx vertx) {
return new VertxClientHttpConnector(vertx, httpClientOptions);
}
@Bean
public VertxWebSocketClient vertxWebSocketClient(Vertx vertx) {
return new VertxWebSocketClient(vertx, httpClientOptions);
}
private HttpClientOptions customizeHttpClientOptions(HttpClientOptions original,
Set<HttpClientOptionsCustomizer> customizers) {
HttpClientOptions customized = new HttpClientOptions(original);
for (HttpClientOptionsCustomizer customizer : customizers) {
customized = customizer.apply(customized);
}
return customized;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/VertxClientHttpConnector.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/VertxClientHttpConnector.java | package dev.snowdrop.vertx.http.client;
import java.net.MalformedURLException;
import java.net.URI;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.client.reactive.ClientHttpConnector;
import org.springframework.http.client.reactive.ClientHttpRequest;
import org.springframework.http.client.reactive.ClientHttpResponse;
import org.springframework.util.Assert;
import dev.snowdrop.vertx.http.common.ReadStreamFluxBuilder;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.http.HttpClient;
import io.vertx.core.http.HttpClientOptions;
import io.vertx.core.http.HttpClientRequest;
import io.vertx.core.http.HttpClientResponse;
import io.vertx.core.http.HttpMethod;
import io.vertx.core.http.RequestOptions;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public class VertxClientHttpConnector implements ClientHttpConnector {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final BufferConverter bufferConverter;
private final Vertx vertx;
private final HttpClientOptions clientOptions;
public VertxClientHttpConnector(Vertx vertx) {
Assert.notNull(vertx, "Vertx is required");
this.bufferConverter = new BufferConverter();
this.vertx = vertx;
this.clientOptions = new HttpClientOptions();
}
public VertxClientHttpConnector(Vertx vertx, HttpClientOptions options) {
Assert.notNull(vertx, "Vertx is required");
this.bufferConverter = new BufferConverter();
this.vertx = vertx;
this.clientOptions = options;
}
@Override
public Mono<ClientHttpResponse> connect(org.springframework.http.HttpMethod method, URI uri,
Function<? super ClientHttpRequest, Mono<Void>> requestCallback) {
logger.debug("Connecting to '{}' with '{}", uri, method);
if (!uri.isAbsolute()) {
return Mono.error(new IllegalArgumentException("URI is not absolute: " + uri));
}
CompletableFuture<ClientHttpResponse> responseFuture = new CompletableFuture<>();
HttpClient client = vertx.createHttpClient(clientOptions);
// New way to create absolute requests is via RequestOptions.
// More info in https://github.com/vert-x3/vertx-4-migration-guide/issues/61.
RequestOptions requestOptions = new RequestOptions();
try {
requestOptions.setAbsoluteURI(uri.toURL());
requestOptions.setMethod(HttpMethod.valueOf(method.name()));
} catch (MalformedURLException e) {
return Mono.error(new IllegalArgumentException("URI is malformed: " + uri));
}
// request handler
CompletableFuture<HttpClientRequest> requestFuture = new CompletableFuture<>();
client.request(requestOptions)
.onFailure(requestFuture::completeExceptionally)
.onSuccess(request -> {
request.response()
.onSuccess(response -> {
Flux<DataBuffer> responseBody = responseToFlux(response).doFinally(ignore -> client.close());
responseFuture.complete(new VertxClientHttpResponse(response, responseBody));
})
.onFailure(responseFuture::completeExceptionally);
requestFuture.complete(request);
});
return Mono.fromFuture(requestFuture)
.flatMap(request -> requestCallback.apply(new VertxClientHttpRequest(request, bufferConverter)))
.then(Mono.fromCompletionStage(responseFuture));
}
private Flux<DataBuffer> responseToFlux(HttpClientResponse response) {
return new ReadStreamFluxBuilder<Buffer, DataBuffer>()
.readStream(response)
.dataConverter(bufferConverter::toDataBuffer)
.build();
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/VertxWebSocketClient.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/VertxWebSocketClient.java | package dev.snowdrop.vertx.http.client;
import java.net.URI;
import dev.snowdrop.vertx.http.common.VertxWebSocketSession;
import dev.snowdrop.vertx.http.utils.BufferConverter;
import io.vertx.core.Vertx;
import io.vertx.core.http.HttpClient;
import io.vertx.core.http.HttpClientOptions;
import io.vertx.core.http.WebSocket;
import io.vertx.core.http.WebSocketConnectOptions;
import io.vertx.core.http.impl.headers.HeadersMultiMap;
import org.springframework.http.HttpHeaders;
import org.springframework.util.Assert;
import org.springframework.web.reactive.socket.HandshakeInfo;
import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.client.WebSocketClient;
import reactor.core.publisher.Mono;
import reactor.core.publisher.MonoSink;
public class VertxWebSocketClient implements WebSocketClient {
private final Vertx vertx;
private final HttpClientOptions clientOptions;
private final BufferConverter bufferConverter;
public VertxWebSocketClient(Vertx vertx) {
Assert.notNull(vertx, "Vertx is required");
this.vertx = vertx;
this.clientOptions = new HttpClientOptions();
this.bufferConverter = new BufferConverter();
}
public VertxWebSocketClient(Vertx vertx, HttpClientOptions options) {
Assert.notNull(vertx, "Vertx is required");
this.vertx = vertx;
this.clientOptions = options;
this.bufferConverter = new BufferConverter();
}
@Override
public Mono<Void> execute(URI uri, WebSocketHandler handler) {
return execute(uri, new HttpHeaders(), handler);
}
@Override
public Mono<Void> execute(URI uri, HttpHeaders headers, WebSocketHandler handler) {
HeadersMultiMap vertxHeaders = convertHeaders(headers);
return Mono.create(sink -> connect(uri, vertxHeaders, handler, sink));
}
private void connect(URI uri, HeadersMultiMap headers, WebSocketHandler handler, MonoSink<Void> callback) {
HttpClient client = vertx.createHttpClient(clientOptions);
WebSocketConnectOptions options = new WebSocketConnectOptions()
.setPort(uri.getPort())
.setHost(uri.getHost())
.setURI(uri.getPath())
.setHeaders(headers);
client.webSocket(options, result -> {
if (result.failed()) {
callback.error(result.cause());
} else {
handler.handle(initSession(uri, result.result()))
.doOnSuccess(callback::success)
.doOnError(callback::error)
.doFinally(ignore -> client.close())
.subscribe();
}
});
}
private HeadersMultiMap convertHeaders(HttpHeaders headers) {
HeadersMultiMap vertxHeaders = new HeadersMultiMap();
headers.forEach(vertxHeaders::add);
return vertxHeaders;
}
private VertxWebSocketSession initSession(URI uri, WebSocket socket) {
// Vert.x handshake doesn't return headers so passing an empty collection
HandshakeInfo handshakeInfo = new HandshakeInfo(uri, new HttpHeaders(), Mono.empty(), socket.subProtocol());
return new VertxWebSocketSession(socket, handshakeInfo, bufferConverter,
clientOptions.getMaxWebSocketFrameSize(), clientOptions.getMaxWebSocketMessageSize());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/VertxClientHttpResponse.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/VertxClientHttpResponse.java | package dev.snowdrop.vertx.http.client;
import java.util.Collection;
import dev.snowdrop.vertx.http.utils.CookieConverter;
import io.vertx.core.http.HttpClientResponse;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseCookie;
import org.springframework.http.client.reactive.ClientHttpResponse;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import reactor.core.publisher.Flux;
public class VertxClientHttpResponse implements ClientHttpResponse {
private final HttpClientResponse delegate;
private final Flux<DataBuffer> body;
public VertxClientHttpResponse(HttpClientResponse delegate, Flux<DataBuffer> body) {
this.delegate = delegate;
this.body = body;
}
@Override
public int getRawStatusCode() {
return delegate.statusCode();
}
@Override
public HttpStatus getStatusCode() {
return HttpStatus.valueOf(delegate.statusCode());
}
@Override
public Flux<DataBuffer> getBody() {
return body;
}
@Override
public HttpHeaders getHeaders() {
HttpHeaders headers = new HttpHeaders();
delegate.headers()
.forEach(e -> headers.add(e.getKey(), e.getValue()));
return headers;
}
@Override
public MultiValueMap<String, ResponseCookie> getCookies() {
MultiValueMap<String, ResponseCookie> cookies = new LinkedMultiValueMap<>();
delegate.cookies()
.stream()
.map(CookieConverter::toResponseCookies)
.flatMap(Collection::stream)
.forEach(cookie -> cookies.add(cookie.getName(), cookie));
return cookies;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/properties/HttpClientProperties.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/properties/HttpClientProperties.java | package dev.snowdrop.vertx.http.client.properties;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import io.vertx.core.http.HttpClientOptions;
import io.vertx.core.http.HttpVersion;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* Spring Boot properties integration for HttpClientOptions. All expect the following properties are integrated:
* crlPaths, crlValues, keyCertOptions, trustOptions, sslEngineOptions, proxyOptions.
* <p>
* If any of the ignored properties is required, please use {@link HttpClientOptionsCustomizer}.
*/
@ConfigurationProperties(prefix = HttpClientProperties.PROPERTIES_PREFIX)
public class HttpClientProperties {
static final String PROPERTIES_PREFIX = "vertx.http.client";
private final HttpClientOptions delegate = new HttpClientOptions();
public HttpClientOptions getHttpClientOptions() {
return new HttpClientOptions(delegate);
}
// Vert.x NetworkOptions
/**
* Return the TCP send buffer size, in bytes.
*
* @return the send buffer size
* @see HttpClientOptions#getSendBufferSize()
*/
public int getSendBufferSize() {
return delegate.getSendBufferSize();
}
public void setSendBufferSize(int sendBufferSize) {
delegate.setSendBufferSize(sendBufferSize);
}
/**
* Return the TCP receive buffer size, in bytes
*
* @return the receive buffer size
* @see HttpClientOptions#getReceiveBufferSize()
*/
public int getReceiveBufferSize() {
return delegate.getReceiveBufferSize();
}
public void setReceiveBufferSize(int receiveBufferSize) {
delegate.setReceiveBufferSize(receiveBufferSize);
}
/**
* @return the value of reuse address
* @see HttpClientOptions#isReuseAddress()
*/
public boolean isReuseAddress() {
return delegate.isReuseAddress();
}
public void setReuseAddress(boolean reuseAddress) {
delegate.setReuseAddress(reuseAddress);
}
/**
* @return the value of reuse address - only supported by native transports
* @see HttpClientOptions#isReusePort()
*/
public boolean isReusePort() {
return delegate.isReusePort();
}
public void setReusePort(boolean reusePort) {
delegate.setReusePort(reusePort);
}
/**
* @return the value of traffic class
* @see HttpClientOptions#getTrafficClass()
*/
public int getTrafficClass() {
return delegate.getTrafficClass();
}
public void setTrafficClass(int trafficClass) {
delegate.setTrafficClass(trafficClass);
}
/**
* @return true when network activity logging is enabled
* @see HttpClientOptions#getLogActivity()
*/
public boolean getLogActivity() {
return delegate.getLogActivity();
}
public void setLogActivity(boolean logEnabled) {
delegate.setLogActivity(logEnabled);
}
// Vert.x TCPSSLOptions
/**
* @return TCP no delay enabled ?
* @see HttpClientOptions#isTcpNoDelay()
*/
public boolean isTcpNoDelay() {
return delegate.isTcpNoDelay();
}
public void setTcpNoDelay(boolean tcpNoDelay) {
delegate.setTcpNoDelay(tcpNoDelay);
}
/**
* @return is TCP keep alive enabled?
* @see HttpClientOptions#isTcpKeepAlive()
*/
public boolean isTcpKeepAlive() {
return delegate.isTcpKeepAlive();
}
public void setTcpKeepAlive(boolean tcpKeepAlive) {
delegate.setTcpKeepAlive(tcpKeepAlive);
}
/**
* @return is SO_linger enabled
* @see HttpClientOptions#getSoLinger()
*/
public int getSoLinger() {
return delegate.getSoLinger();
}
public void setSoLinger(int soLinger) {
delegate.setSoLinger(soLinger);
}
/**
* @return the idle timeout, in time unit specified by {@link #getIdleTimeoutUnit()}.
* @see HttpClientOptions#getIdleTimeout()
*/
public int getIdleTimeout() {
return delegate.getIdleTimeout();
}
public void setIdleTimeout(int idleTimeout) {
delegate.setIdleTimeout(idleTimeout);
}
/**
* @return the idle timeout unit.
* @see HttpClientOptions#getIdleTimeoutUnit()
*/
public TimeUnit getIdleTimeoutUnit() {
return delegate.getIdleTimeoutUnit();
}
public void setIdleTimeoutUnit(TimeUnit idleTimeoutUnit) {
delegate.setIdleTimeoutUnit(idleTimeoutUnit);
}
/**
* @return is SSL/TLS enabled?
* @see HttpClientOptions#isSsl()
*/
public boolean isSsl() {
return delegate.isSsl();
}
public void setSsl(boolean ssl) {
delegate.setSsl(ssl);
}
/**
* @return the enabled cipher suites
* @see HttpClientOptions#getEnabledCipherSuites()
*/
public Set<String> getEnabledCipherSuites() {
return delegate.getEnabledCipherSuites();
}
public void setEnabledCipherSuites(Set<String> enabledCipherSuites) {
if (enabledCipherSuites != null) {
enabledCipherSuites.forEach(delegate::addEnabledCipherSuite);
}
}
/**
* @return whether to use or not Application-Layer Protocol Negotiation
* @see HttpClientOptions#isUseAlpn()
*/
public boolean isUseAlpn() {
return delegate.isUseAlpn();
}
public void setUseAlpn(boolean useAlpn) {
delegate.setUseAlpn(useAlpn);
}
/**
* Returns the enabled SSL/TLS protocols
*
* @return the enabled protocols
* @see HttpClientOptions#getEnabledSecureTransportProtocols()
*/
public Set<String> getEnabledSecureTransportProtocols() {
return delegate.getEnabledSecureTransportProtocols();
}
public void setEnabledSecureTransportProtocols(Set<String> enabledSecureTransportProtocols) {
delegate.setEnabledSecureTransportProtocols(enabledSecureTransportProtocols);
}
/**
* @return whether {@code TCP_FASTOPEN} option is enabled
* @see HttpClientOptions#isTcpFastOpen()
*/
public boolean isTcpFastOpen() {
return delegate.isTcpFastOpen();
}
public void setTcpFastOpen(boolean tcpFastOpen) {
delegate.setTcpFastOpen(tcpFastOpen);
}
/**
* @return whether {@code TCP_CORK} option is enabled
* @see HttpClientOptions#isTcpCork()
*/
public boolean isTcpCork() {
return delegate.isTcpCork();
}
public void setTcpCork(boolean tcpCork) {
delegate.setTcpCork(tcpCork);
}
/**
* @return whether {@code TCP_QUICKACK} option is enabled
* @see HttpClientOptions#isTcpQuickAck()
*/
public boolean isTcpQuickAck() {
return delegate.isTcpQuickAck();
}
public void setTcpQuickAck(boolean tcpQuickAck) {
delegate.setTcpQuickAck(tcpQuickAck);
}
// Vert.x ClientOptionsBase
/**
* @return the value of connect timeout
* @see HttpClientOptions#getConnectTimeout()
*/
public int getConnectTimeout() {
return delegate.getConnectTimeout();
}
public void setConnectTimeout(int connectTimeout) {
delegate.setConnectTimeout(connectTimeout);
}
/**
* @return true if all server certificates should be trusted
* @see HttpClientOptions#isTrustAll()
*/
public boolean isTrustAll() {
return delegate.isTrustAll();
}
public void setTrustAll(boolean trustAll) {
delegate.setTrustAll(trustAll);
}
/**
* @return the metrics name identifying the reported metrics.
* @see HttpClientOptions#getMetricsName()
*/
public String getMetricsName() {
return delegate.getMetricsName();
}
public void setMetricsName(String metricsName) {
delegate.setMetricsName(metricsName);
}
/**
* @return the local interface to bind for network connections.
* @see HttpClientOptions#getLocalAddress()
*/
public String getLocalAddress() {
return delegate.getLocalAddress();
}
public void setLocalAddress(String localAddress) {
delegate.setLocalAddress(localAddress);
}
// Vert.x HttpClientOptions
/**
* Is hostname verification (for SSL/TLS) enabled?
*
* @return {@code true} if enabled
* @see HttpClientOptions#isVerifyHost()
*/
public boolean isVerifyHost() {
return delegate.isVerifyHost();
}
public void setVerifyHost(boolean verifyHost) {
delegate.setVerifyHost(verifyHost);
}
/**
* Get the maximum pool size for connections
*
* @return the maximum pool size
* @see HttpClientOptions#getMaxPoolSize()
*/
public int getMaxPoolSize() {
return delegate.getMaxPoolSize();
}
public void setMaxPoolSize(int maxPoolSize) {
delegate.setMaxPoolSize(maxPoolSize);
}
/**
* Is keep alive enabled on the client?
*
* @return {@code true} if enabled
* @see HttpClientOptions#isKeepAlive()
*/
public boolean isKeepAlive() {
return delegate.isKeepAlive();
}
public void setKeepAlive(boolean keepAlive) {
delegate.setKeepAlive(keepAlive);
}
/**
* @return the keep alive timeout value in seconds for HTTP/1.x connections
* @see HttpClientOptions#getKeepAliveTimeout()
*/
public int getKeepAliveTimeout() {
return delegate.getKeepAliveTimeout();
}
public void setKeepAliveTimeout(int keepAliveTimeout) {
delegate.setKeepAliveTimeout(keepAliveTimeout);
}
/**
* @return the limit of pending requests a pipe-lined HTTP/1 connection can send
* @see HttpClientOptions#getPipeliningLimit()
*/
public int getPipeliningLimit() {
return delegate.getPipeliningLimit();
}
public void setPipeliningLimit(int limit) {
delegate.setPipeliningLimit(limit);
}
/**
* Is pipe-lining enabled on the client
*
* @return {@code true} if pipe-lining is enabled
* @see HttpClientOptions#isPipelining()
*/
public boolean isPipelining() {
return delegate.isPipelining();
}
public void setPipelining(boolean pipelining) {
delegate.setPipelining(pipelining);
}
/**
* Get the maximum pool size for HTTP/2 connections
*
* @return the maximum pool size
* @see HttpClientOptions#getHttp2MaxPoolSize()
*/
public int getHttp2MaxPoolSize() {
return delegate.getHttp2MaxPoolSize();
}
public void setHttp2MaxPoolSize(int max) {
delegate.setHttp2MaxPoolSize(max);
}
/**
* @return the maximum number of concurrent streams for an HTTP/2 connection, {@code -1} means
* the value sent by the server
* @see HttpClientOptions#getHttp2MultiplexingLimit()
*/
public int getHttp2MultiplexingLimit() {
return delegate.getHttp2MultiplexingLimit();
}
public void setHttp2MultiplexingLimit(int limit) {
delegate.setHttp2MultiplexingLimit(limit);
}
/**
* @return the default HTTP/2 connection window size
* @see HttpClientOptions#getHttp2ConnectionWindowSize()
*/
public int getHttp2ConnectionWindowSize() {
return delegate.getHttp2ConnectionWindowSize();
}
public void setHttp2ConnectionWindowSize(int http2ConnectionWindowSize) {
delegate.setHttp2ConnectionWindowSize(http2ConnectionWindowSize);
}
/**
* @return the keep alive timeout value in seconds for HTTP/2 connections
* @see HttpClientOptions#getHttp2KeepAliveTimeout()
*/
public int getHttp2KeepAliveTimeout() {
return delegate.getHttp2KeepAliveTimeout();
}
public void setHttp2KeepAliveTimeout(int keepAliveTimeout) {
delegate.setHttp2KeepAliveTimeout(keepAliveTimeout);
}
/**
* @return the connection pool cleaner period in ms.
* @see HttpClientOptions#getPoolCleanerPeriod()
*/
public int getPoolCleanerPeriod() {
return delegate.getPoolCleanerPeriod();
}
public void setPoolCleanerPeriod(int poolCleanerPeriod) {
delegate.setPoolCleanerPeriod(poolCleanerPeriod);
}
/**
* Is compression enabled on the client?
*
* @return {@code true} if enabled
* @see HttpClientOptions#isTryUseCompression()
*/
public boolean isTryUseCompression() {
return delegate.isTryUseCompression();
}
public void setTryUseCompression(boolean tryUseCompression) {
delegate.setTryUseCompression(tryUseCompression);
}
/**
* Get the maximum WebSocket frame size to use
*
* @return the max WebSocket frame size
* @see HttpClientOptions#getMaxWebSocketFrameSize()
* @deprecated use {@link #getMaxWebSocketFrameSize()}
*/
@Deprecated
public int getMaxWebsocketFrameSize() {
return delegate.getMaxWebSocketFrameSize();
}
/**
* Get the maximum WebSocket frame size to use
*
* @return the max WebSocket frame size
* @see HttpClientOptions#getMaxWebSocketFrameSize()
*/
public int getMaxWebSocketFrameSize() {
return delegate.getMaxWebSocketFrameSize();
}
@Deprecated
public void setMaxWebsocketFrameSize(int maxWebSocketFrameSize) {
delegate.setMaxWebSocketFrameSize(maxWebSocketFrameSize);
}
public void setMaxWebSocketFrameSize(int maxWebSocketFrameSize) {
delegate.setMaxWebSocketFrameSize(maxWebSocketFrameSize);
}
/**
* Get the maximum WebSocket message size to use
*
* @return the max WebSocket message size
* @see HttpClientOptions#getMaxWebSocketMessageSize()
* @deprecated use {@link #getMaxWebSocketMessageSize()}
*/
@Deprecated
public int getMaxWebsocketMessageSize() {
return delegate.getMaxWebSocketMessageSize();
}
/**
* Get the maximum WebSocket message size to use
*
* @return the max WebSocket message size
* @see HttpClientOptions#getMaxWebSocketMessageSize()
*/
public int getMaxWebSocketMessageSize() {
return delegate.getMaxWebSocketMessageSize();
}
@Deprecated
public void setMaxWebsocketMessageSize(int maxWebSocketMessageSize) {
delegate.setMaxWebSocketMessageSize(maxWebSocketMessageSize);
}
public void setMaxWebSocketMessageSize(int maxWebSocketMessageSize) {
delegate.setMaxWebSocketMessageSize(maxWebSocketMessageSize);
}
/**
* Get the default host name to be used by this client in requests if none is provided when making the request.
*
* @return the default host name
* @see HttpClientOptions#getDefaultHost()
*/
public String getDefaultHost() {
return delegate.getDefaultHost();
}
public void setDefaultHost(String defaultHost) {
delegate.setDefaultHost(defaultHost);
}
/**
* Get the default port to be used by this client in requests if none is provided when making the request.
*
* @return the default port
* @see HttpClientOptions#getDefaultPort()
*/
public int getDefaultPort() {
return delegate.getDefaultPort();
}
public void setDefaultPort(int defaultPort) {
delegate.setDefaultPort(defaultPort);
}
/**
* Get the protocol version.
*
* @return the protocol version
* @see HttpClientOptions#getProtocolVersion()
*/
public HttpVersion getProtocolVersion() {
return delegate.getProtocolVersion();
}
public void setProtocolVersion(HttpVersion protocolVersion) {
delegate.setProtocolVersion(protocolVersion);
}
/**
* Returns the maximum HTTP chunk size
*
* @return the maximum HTTP chunk size
* @see HttpClientOptions#getMaxChunkSize()
*/
public int getMaxChunkSize() {
return delegate.getMaxChunkSize();
}
public void setMaxChunkSize(int maxChunkSize) {
delegate.setMaxChunkSize(maxChunkSize);
}
/**
* @return the maximum length of the initial line for HTTP/1.x (e.g. {@code "GET / HTTP/1.0"})
* @see HttpClientOptions#getMaxInitialLineLength()
*/
public int getMaxInitialLineLength() {
return delegate.getMaxInitialLineLength();
}
public void setMaxInitialLineLength(int maxInitialLineLength) {
delegate.setMaxInitialLineLength(maxInitialLineLength);
}
/**
* @return Returns the maximum length of all headers for HTTP/1.x
* @see HttpClientOptions#getMaxHeaderSize()
*/
public int getMaxHeaderSize() {
return delegate.getMaxHeaderSize();
}
public void setMaxHeaderSize(int maxHeaderSize) {
delegate.setMaxHeaderSize(maxHeaderSize);
}
/**
* Returns the maximum wait queue size
*
* @return the maximum wait queue size
* @see HttpClientOptions#getMaxWaitQueueSize()
*/
public int getMaxWaitQueueSize() {
return delegate.getMaxWaitQueueSize();
}
public void setMaxWaitQueueSize(int maxWaitQueueSize) {
delegate.setMaxWaitQueueSize(maxWaitQueueSize);
}
/**
* @return the {@literal SETTINGS_HEADER_TABLE_SIZE} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#getHeaderTableSize()
*/
public long getHeaderTableSize() {
return delegate.getInitialSettings().getHeaderTableSize();
}
public void setHeaderTableSize(long headerTableSize) {
delegate.getInitialSettings().setHeaderTableSize(headerTableSize);
}
/**
* @return the {@literal SETTINGS_ENABLE_PUSH} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#isPushEnabled()
*/
public boolean isPushEnabled() {
return delegate.getInitialSettings().isPushEnabled();
}
public void setPushEnabled(boolean pushEnabled) {
delegate.getInitialSettings().setPushEnabled(pushEnabled);
}
/**
* @return the {@literal SETTINGS_MAX_CONCURRENT_STREAMS} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#getMaxConcurrentStreams()
*/
public long getMaxConcurrentStreams() {
return delegate.getInitialSettings().getMaxConcurrentStreams();
}
public void setMaxConcurrentStreams(long maxConcurrentStreams) {
delegate.getInitialSettings().setMaxConcurrentStreams(maxConcurrentStreams);
}
/**
* @return the {@literal SETTINGS_INITIAL_WINDOW_SIZE} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#getInitialWindowSize()
*/
public int getInitialWindowSize() {
return delegate.getInitialSettings().getInitialWindowSize();
}
public void setInitialWindowSize(int initialWindowSize) {
delegate.getInitialSettings().setInitialWindowSize(initialWindowSize);
}
/**
* @return the {@literal SETTINGS_MAX_FRAME_SIZE} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#getMaxFrameSize()
*/
public int getMaxFrameSize() {
return delegate.getInitialSettings().getMaxFrameSize();
}
public void setMaxFrameSize(int maxFrameSize) {
delegate.getInitialSettings().setMaxFrameSize(maxFrameSize);
}
/**
* @return the {@literal SETTINGS_MAX_HEADER_LIST_SIZE} HTTP/2 setting
* @see io.vertx.core.http.Http2Settings#getMaxHeaderListSize()
*/
public long getMaxHeaderListSize() {
return delegate.getInitialSettings().getMaxHeaderListSize();
}
public void setMaxHeaderListSize(long maxHeaderListSize) {
delegate.getInitialSettings().setMaxHeaderListSize(maxHeaderListSize);
}
/**
* @return the extra settings used for extending HTTP/2
* @see io.vertx.core.http.Http2Settings#getExtraSettings()
*/
public Map<Integer, Long> getHttp2ExtraSettings() {
return delegate.getInitialSettings().getExtraSettings();
}
public void setHttp2ExtraSettings(Map<Integer, Long> http2ExtraSettings) {
delegate.getInitialSettings().setExtraSettings(http2ExtraSettings);
}
/**
* @return the list of protocol versions to provide during the Application-Layer Protocol Negotiation. When
* the list is empty, the client provides a best effort list according to {@link #setProtocolVersion}
* @see HttpClientOptions#getAlpnVersions()
*/
public List<HttpVersion> getAlpnVersions() {
return delegate.getAlpnVersions();
}
public void setAlpnVersions(List<HttpVersion> alpnVersions) {
delegate.setAlpnVersions(alpnVersions);
}
/**
* @return {@code true} when an <i>h2c</i> connection is established using an HTTP/1.1 upgrade request, {@code false} when directly
* @see HttpClientOptions#isHttp2ClearTextUpgrade()
*/
public boolean isHttp2ClearTextUpgrade() {
return delegate.isHttp2ClearTextUpgrade();
}
public void setHttp2ClearTextUpgrade(boolean value) {
delegate.setHttp2ClearTextUpgrade(value);
}
/**
* @return {@code true} when frame masking is skipped
* @see HttpClientOptions#isSendUnmaskedFrames()
*/
public boolean isSendUnmaskedFrames() {
return delegate.isSendUnmaskedFrames();
}
public void setSendUnmaskedFrames(boolean sendUnmaskedFrames) {
delegate.setSendUnmaskedFrames(sendUnmaskedFrames);
}
/**
* @return the maximum number of redirection a request can follow
* @see HttpClientOptions#getMaxRedirects()
*/
public int getMaxRedirects() {
return delegate.getMaxRedirects();
}
public void setMaxRedirects(int maxRedirects) {
delegate.setMaxRedirects(maxRedirects);
}
/**
* @return whether the client should always use SNI on TLS/SSL connections
* @see HttpClientOptions#isForceSni()
*/
public boolean isForceSni() {
return delegate.isForceSni();
}
public void setForceSni(boolean forceSni) {
delegate.setForceSni(forceSni);
}
/**
* @return the initial buffer size for the HTTP decoder
* @see HttpClientOptions#getDecoderInitialBufferSize()
*/
public int getDecoderInitialBufferSize() {
return delegate.getDecoderInitialBufferSize();
}
public void setDecoderInitialBufferSize(int decoderInitialBufferSize) {
delegate.setDecoderInitialBufferSize(decoderInitialBufferSize);
}
/**
* @return {@code true} when the WebSocket per-frame deflate compression extension will be offered
* @see HttpClientOptions#getTryWebSocketDeflateFrameCompression
* @deprecated use {@link #isTryWebSocketDeflateFrameCompression()}
*/
@Deprecated
public boolean isTryWebsocketDeflateFrameCompression() {
return delegate.getTryWebSocketDeflateFrameCompression();
}
/**
* @return {@code true} when the WebSocket per-frame deflate compression extension will be offered
* @see HttpClientOptions#getTryWebSocketDeflateFrameCompression
*/
public boolean isTryWebSocketDeflateFrameCompression() {
return delegate.getTryWebSocketDeflateFrameCompression();
}
@Deprecated
public void setTryUsePerFrameWebsocketCompression(boolean tryWebSocketDeflateFrameCompression) {
delegate.setTryUsePerFrameWebSocketCompression(tryWebSocketDeflateFrameCompression);
}
public void setTryUsePerFrameWebSocketCompression(boolean tryWebSocketDeflateFrameCompression) {
delegate.setTryUsePerFrameWebSocketCompression(tryWebSocketDeflateFrameCompression);
}
/**
* @return {@code true} when the WebSocket per-message deflate compression extension will be offered
* @see HttpClientOptions#getTryUsePerMessageWebSocketCompression()
* @deprecated use {@link #isTryUsePerMessageWebSocketCompression()}
*/
@Deprecated
public boolean isTryUsePerMessageWebsocketCompression() {
return delegate.getTryUsePerMessageWebSocketCompression();
}
/**
* @return {@code true} when the WebSocket per-message deflate compression extension will be offered
* @see HttpClientOptions#getTryUsePerMessageWebSocketCompression()
*/
public boolean isTryUsePerMessageWebSocketCompression() {
return delegate.getTryUsePerMessageWebSocketCompression();
}
@Deprecated
public void setTryUsePerMessageWebsocketCompression(boolean tryUsePerMessageWebSocketCompression) {
delegate.setTryUsePerMessageWebSocketCompression(tryUsePerMessageWebSocketCompression);
}
public void setTryUsePerMessageWebSocketCompression(boolean tryUsePerMessageWebSocketCompression) {
delegate.setTryUsePerMessageWebSocketCompression(tryUsePerMessageWebSocketCompression);
}
/**
* @return the WebSocket deflate compression level
* @see HttpClientOptions#getWebSocketCompressionLevel()
* @deprecated use {@link #getWebSocketCompressionLevel()}
*/
@Deprecated
public int getWebsocketCompressionLevel() {
return delegate.getWebSocketCompressionLevel();
}
/**
* @return the WebSocket deflate compression level
* @see HttpClientOptions#getWebSocketCompressionLevel()
*/
public int getWebSocketCompressionLevel() {
return delegate.getWebSocketCompressionLevel();
}
@Deprecated
public void setWebsocketCompressionLevel(int webSocketCompressionLevel) {
delegate.setWebSocketCompressionLevel(webSocketCompressionLevel);
}
public void setWebSocketCompressionLevel(int webSocketCompressionLevel) {
delegate.setWebSocketCompressionLevel(webSocketCompressionLevel);
}
/**
* @return {@code true} when the {@code client_no_context_takeover} parameter for the WebSocket per-message
* deflate compression extension will be offered
* @see HttpClientOptions#getWebSocketCompressionAllowClientNoContext()
* @deprecated use {@link #isWebSocketCompressionAllowClientNoContext()}
*/
@Deprecated
public boolean isWebsocketCompressionAllowClientNoContext() {
return delegate.getWebSocketCompressionAllowClientNoContext();
}
/**
* @return {@code true} when the {@code client_no_context_takeover} parameter for the WebSocket per-message
* deflate compression extension will be offered
* @see HttpClientOptions#getWebSocketCompressionAllowClientNoContext()
*/
public boolean isWebSocketCompressionAllowClientNoContext() {
return delegate.getWebSocketCompressionAllowClientNoContext();
}
@Deprecated
public void setWebsocketCompressionAllowClientNoContext(boolean webSocketCompressionAllowClientNoContext) {
delegate.setWebSocketCompressionAllowClientNoContext(webSocketCompressionAllowClientNoContext);
}
public void setWebSocketCompressionAllowClientNoContext(boolean webSocketCompressionAllowClientNoContext) {
delegate.setWebSocketCompressionAllowClientNoContext(webSocketCompressionAllowClientNoContext);
}
/**
* @return {@code true} when the {@code server_no_context_takeover} parameter for the WebSocket per-message
* deflate compression extension will be offered
* @see HttpClientOptions#getWebSocketCompressionRequestServerNoContext()
* @deprecated use {@link #isWebSocketCompressionRequestServerNoContext()}
*/
@Deprecated
public boolean isWebsocketCompressionRequestServerNoContext() {
return delegate.getWebSocketCompressionRequestServerNoContext();
}
/**
* @return {@code true} when the {@code server_no_context_takeover} parameter for the WebSocket per-message
* deflate compression extension will be offered
* @see HttpClientOptions#getWebSocketCompressionRequestServerNoContext()
*/
public boolean isWebSocketCompressionRequestServerNoContext() {
return delegate.getWebSocketCompressionRequestServerNoContext();
}
@Deprecated
public void setWebsocketCompressionRequestServerNoContext(boolean webSocketCompressionRequestServerNoContext) {
delegate.setWebSocketCompressionRequestServerNoContext(webSocketCompressionRequestServerNoContext);
}
public void setWebSocketCompressionRequestServerNoContext(boolean webSocketCompressionRequestServerNoContext) {
delegate.setWebSocketCompressionRequestServerNoContext(webSocketCompressionRequestServerNoContext);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/properties/HttpClientOptionsCustomizer.java | vertx-spring-boot-starter-http/src/main/java/dev/snowdrop/vertx/http/client/properties/HttpClientOptionsCustomizer.java | package dev.snowdrop.vertx.http.client.properties;
import java.util.function.Function;
import io.vertx.core.http.HttpClientOptions;
@FunctionalInterface
public interface HttpClientOptionsCustomizer extends Function<HttpClientOptions, HttpClientOptions> {
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/SnowdropAmqpMessageBuilderTest.java | vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/SnowdropAmqpMessageBuilderTest.java | package dev.snowdrop.vertx.amqp;
import io.vertx.core.buffer.Buffer;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
public class SnowdropAmqpMessageBuilderTest {
@Mock
private io.vertx.amqp.AmqpMessageBuilder mockDelegate;
@Test
public void shouldAddDataBufferBody() {
DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
DataBuffer originalBuffer = dataBufferFactory.wrap("test".getBytes());
Buffer expectedBuffer = Buffer.buffer("test".getBytes());
new SnowdropAmqpMessageBuilder(mockDelegate).withBufferAsBody(originalBuffer);
verify(mockDelegate).withBufferAsBody(expectedBuffer);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/SnowdropAmqpMessageTest.java | vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/SnowdropAmqpMessageTest.java | package dev.snowdrop.vertx.amqp;
import io.vertx.core.buffer.Buffer;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
@ExtendWith(MockitoExtension.class)
public class SnowdropAmqpMessageTest {
@Mock
private io.vertx.amqp.AmqpMessage mockDelegate;
private DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
@Test
public void shouldGetBodyAsDataBuffer() {
Buffer originalBuffer = Buffer.buffer("test".getBytes());
DataBuffer expectedBuffer = dataBufferFactory.wrap("test".getBytes());
given(mockDelegate.bodyAsBinary()).willReturn(originalBuffer);
assertThat(new SnowdropAmqpMessage(mockDelegate).bodyAsBinary()).isEqualTo(expectedBuffer);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/it/AmqpClientSslIT.java | vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/it/AmqpClientSslIT.java | package dev.snowdrop.vertx.amqp.it;
import org.apache.activemq.artemis.core.server.embedded.EmbeddedActiveMQ;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(properties = {
"vertx.amqp.ssl=true",
"vertx.amqp.jks-key-store.enabled=true",
"vertx.amqp.jks-key-store.path=target/test-classes/tls/client-keystore.jks",
"vertx.amqp.jks-key-store.password=wibble",
"vertx.amqp.jks-trust-store.enabled=true",
"vertx.amqp.jks-trust-store.path=target/test-classes/tls/client-truststore.jks",
"vertx.amqp.jks-trust-store.password=wibble",
"vertx.amqp.jdk-ssl-engine.enabled=true"
})
public class AmqpClientSslIT extends AbstractAmqpClientIT {
private static EmbeddedActiveMQ BROKER;
@BeforeAll
public static void beforeClass() throws Exception {
BROKER = new EmbeddedActiveMQ().setConfigResourcePath("tls-broker.xml").start();
}
@AfterAll
public static void afterClass() throws Exception {
if (BROKER != null) {
BROKER.stop();
}
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/it/TestApplication.java | vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/it/TestApplication.java | package dev.snowdrop.vertx.amqp.it;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class TestApplication {
public static void main(String[] args) {
SpringApplication.run(TestApplication.class, args);
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/it/AmqpClientIT.java | vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/it/AmqpClientIT.java | package dev.snowdrop.vertx.amqp.it;
import org.apache.activemq.artemis.core.server.embedded.EmbeddedActiveMQ;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class AmqpClientIT extends AbstractAmqpClientIT {
private static EmbeddedActiveMQ BROKER;
@BeforeAll
public static void beforeClass() throws Exception {
BROKER = new EmbeddedActiveMQ().start();
}
@AfterAll
public static void afterClass() throws Exception {
if (BROKER != null) {
BROKER.stop();
}
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/it/AbstractAmqpClientIT.java | vertx-spring-boot-starter-amqp/src/test/java/dev/snowdrop/vertx/amqp/it/AbstractAmqpClientIT.java | package dev.snowdrop.vertx.amqp.it;
import java.time.Duration;
import java.util.Arrays;
import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonObject;
import dev.snowdrop.vertx.amqp.AmqpClient;
import dev.snowdrop.vertx.amqp.AmqpConnection;
import dev.snowdrop.vertx.amqp.AmqpMessage;
import dev.snowdrop.vertx.amqp.AmqpReceiver;
import dev.snowdrop.vertx.amqp.AmqpSender;
import dev.snowdrop.vertx.streams.Pump;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import reactor.core.Disposable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import static org.assertj.core.api.Assertions.assertThat;
public abstract class AbstractAmqpClientIT {
private static final Duration TIMEOUT = Duration.ofSeconds(2);
@Autowired
private AmqpClient client;
private AmqpConnection connection;
@AfterEach
public void tearDown() {
client.close().block();
}
@Test
public void testBasicSendAndReceiveFlux() {
Flux<String> receivedMessagesFlux = createReceiver("test-queue")
.flux()
.map(AmqpMessage::bodyAsString);
AmqpSender sender = createSender("test-queue");
Mono<Void> ackMono = Flux.just("first", "second", "third")
.map(string -> AmqpMessage.create().withBody(string).build())
.flatMap(sender::sendWithAck)
.then();
StepVerifier.create(ackMono)
.expectComplete()
.verify(Duration.ofSeconds(5));
StepVerifier.create(receivedMessagesFlux)
.expectNext("first")
.expectNext("second")
.expectNext("third")
.thenCancel()
.verify(Duration.ofSeconds(5));
}
@Test
public void testBasicSendAndReceiveMono() {
Mono<String> receivedMessagesMono = createReceiver("test-queue")
.mono()
.map(AmqpMessage::bodyAsString);
AmqpSender sender = createSender("test-queue");
Mono<Void> ackMono = Mono.just("first")
.map(string -> AmqpMessage.create().withBody(string).build())
.flatMap(sender::sendWithAck)
.then();
StepVerifier.create(ackMono)
.expectComplete()
.verify(Duration.ofSeconds(5));
StepVerifier.create(receivedMessagesMono)
.expectNext("first")
.thenCancel()
.verify(Duration.ofSeconds(5));
}
@Test
public void testAnonymousSenderAndDynamicReceiver() {
AmqpReceiver receiver = createDynamicReceiver();
AmqpSender sender = createAnonymousSender();
Flux<String> receivedMessagesFlux = receiver.flux()
.map(AmqpMessage::bodyAsString);
Mono<Void> ackMono = Flux.just("first", "second", "third")
.map(body -> AmqpMessage.create().address(receiver.address()).withBody(body).build())
.flatMap(sender::sendWithAck)
.then();
StepVerifier.create(ackMono)
.expectComplete()
.verify(Duration.ofSeconds(5));
StepVerifier.create(receivedMessagesFlux)
.expectNext("first")
.expectNext("second")
.expectNext("third")
.thenCancel()
.verify(Duration.ofSeconds(5));
}
@Test
public void testPipe() {
AmqpSender source = createSender("input-queue");
AmqpReceiver input = createReceiver("input-queue");
AmqpSender output = createSender("output-queue");
AmqpReceiver result = createReceiver("output-queue");
Disposable pipeDisposer = input.pipeTo(output)
.subscribe();
Flux<String> receivedMessagesFlux = result.flux()
.map(AmqpMessage::bodyAsString);
Mono<Void> endMono = Flux.just("first", "second", "third")
.map(body -> AmqpMessage.create().withBody(body).build())
.flatMap(source::sendWithAck)
.then();
pipeDisposer.dispose();
StepVerifier.create(endMono)
.expectComplete()
.verify(Duration.ofSeconds(5));
StepVerifier.create(receivedMessagesFlux)
.expectNext("first")
.expectNext("second")
.expectNext("third")
.thenCancel()
.verify(Duration.ofSeconds(5));
}
@Test
public void testPump() {
AmqpSender source = createSender("input-queue");
AmqpReceiver input = createReceiver("input-queue");
AmqpSender output = createSender("output-queue");
AmqpReceiver result = createReceiver("output-queue");
Pump.pump(input, output).start();
Flux<String> receivedMessagesFlux = result.flux()
.map(AmqpMessage::bodyAsString);
Mono<Void> endMono = Flux.just("first", "second", "third")
.map(body -> AmqpMessage.create().withBody(body).build())
.flatMap(source::sendWithAck)
.then();
StepVerifier.create(endMono)
.expectComplete()
.verify(Duration.ofSeconds(5));
StepVerifier.create(receivedMessagesFlux)
.expectNext("first")
.expectNext("second")
.expectNext("third")
.thenCancel()
.verify(Duration.ofSeconds(5));
}
@Test
public void testJsonObject() {
JsonObject original = Json.createObjectBuilder()
.add("integer", 1)
.add("boolean", true)
.add("string", "test")
.add("object", Json.createObjectBuilder().add("key", "value"))
.add("array", Json.createArrayBuilder(Arrays.asList(1, 2, 3)))
.build();
Mono<JsonObject> resultMono = createReceiver("test-queue")
.mono()
.map(AmqpMessage::bodyAsJsonObject);
AmqpMessage message = AmqpMessage.create()
.withJsonObjectAsBody(original)
.build();
createSender("test-queue")
.send(message);
StepVerifier.create(resultMono)
.expectNext(original)
.expectComplete()
.verify(Duration.ofSeconds(5));
}
@Test
public void testJsonArray() {
JsonArray original = Json.createArrayBuilder()
.add(1)
.add(true)
.add("test")
.add(Json.createObjectBuilder().add("key", "value"))
.add(Json.createArrayBuilder(Arrays.asList(1, 2, 3)))
.build();
Mono<JsonArray> resultMono = createReceiver("test-queue")
.mono()
.map(AmqpMessage::bodyAsJsonArray);
AmqpMessage message = AmqpMessage.create()
.withJsonArrayAsBody(original)
.build();
createSender("test-queue")
.send(message);
StepVerifier.create(resultMono)
.expectNext(original)
.expectComplete()
.verify(Duration.ofSeconds(5));
}
@Test
public void testDataBuffer() {
DataBuffer original = new DefaultDataBufferFactory().wrap("test".getBytes());
Mono<DataBuffer> resultMono = createReceiver("test-queue")
.mono()
.map(AmqpMessage::bodyAsBinary);
AmqpMessage message = AmqpMessage.create()
.withBufferAsBody(original)
.build();
createSender("test-queue")
.send(message);
StepVerifier.create(resultMono)
.expectNext(original)
.expectComplete()
.verify(Duration.ofSeconds(5));
}
@Test
public void testRequestResponse() {
AmqpSender sender = createAnonymousSender();
AmqpReceiver requestReceiver = createDynamicReceiver();
AmqpReceiver responseReceiver = createDynamicReceiver();
requestReceiver.flux()
.subscribe(message -> {
AmqpMessage response = AmqpMessage.create()
.address(message.replyTo())
.correlationId(message.id())
.withBody(message.bodyAsString().toUpperCase())
.build();
sender.send(response);
});
AmqpMessage request = AmqpMessage.create()
.id("test-id")
.address(requestReceiver.address())
.replyTo(responseReceiver.address())
.withBody("test")
.build();
sender.send(request);
StepVerifier.create(responseReceiver.flux())
.assertNext(message -> {
assertThat(message.correlationId()).isEqualTo(request.id());
assertThat(message.bodyAsString()).isEqualTo(request.bodyAsString().toUpperCase());
})
.thenCancel()
.verify(Duration.ofSeconds(5));
}
private AmqpConnection createConnection() {
if (connection == null) {
connection = client
.connect()
.blockOptional(TIMEOUT)
.orElseThrow(() -> new RuntimeException("Unable to create a connection"));
}
return connection;
}
private AmqpSender createSender(String address) {
return client
.createSender(address)
.blockOptional(TIMEOUT)
.orElseThrow(() -> new RuntimeException("Unable to create a sender"));
}
private AmqpSender createAnonymousSender() {
return createConnection()
.createAnonymousSender()
.blockOptional(TIMEOUT)
.orElseThrow(() -> new RuntimeException("Unable to create a sender"));
}
private AmqpReceiver createReceiver(String address) {
return client
.createReceiver(address)
.blockOptional(TIMEOUT)
.orElseThrow(() -> new RuntimeException("Unable to create a receiver"));
}
private AmqpReceiver createDynamicReceiver() {
return createConnection()
.createDynamicReceiver()
.blockOptional(TIMEOUT)
.orElseThrow(() -> new RuntimeException("Unable to create a receiver"));
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-amqp/src/main/java/dev/snowdrop/vertx/amqp/SnowdropAmqpConnection.java | vertx-spring-boot-starter-amqp/src/main/java/dev/snowdrop/vertx/amqp/SnowdropAmqpConnection.java | package dev.snowdrop.vertx.amqp;
import java.util.function.Consumer;
import io.smallrye.mutiny.converters.uni.UniReactorConverters;
import reactor.core.publisher.Mono;
class SnowdropAmqpConnection implements AmqpConnection {
private final io.vertx.mutiny.amqp.AmqpConnection delegate;
private final MessageConverter messageConverter;
SnowdropAmqpConnection(io.vertx.mutiny.amqp.AmqpConnection delegate, MessageConverter messageConverter) {
this.delegate = delegate;
this.messageConverter = messageConverter;
}
@Override
public AmqpConnection exceptionHandler(Consumer<Throwable> handler) {
delegate.exceptionHandler(handler);
return this;
}
@Override
public Mono<AmqpSender> createSender(String address) {
return delegate.createSender(address)
.convert()
.with(UniReactorConverters.toMono())
.map(delegateSender -> new SnowdropAmqpSender(delegateSender, messageConverter));
}
@Override
public Mono<AmqpSender> createSender(String address, AmqpSenderOptions options) {
return delegate.createSender(address, options.toVertxAmqpSenderOptions())
.convert()
.with(UniReactorConverters.toMono())
.map(delegateSender -> new SnowdropAmqpSender(delegateSender, messageConverter));
}
@Override
public Mono<AmqpSender> createAnonymousSender() {
return delegate.createAnonymousSender()
.convert()
.with(UniReactorConverters.toMono())
.map(delegateSender -> new SnowdropAmqpSender(delegateSender, messageConverter));
}
@Override
public Mono<AmqpReceiver> createReceiver(String address) {
return delegate.createReceiver(address)
.convert()
.with(UniReactorConverters.toMono())
.map(delegateReceiver -> new SnowdropAmqpReceiver(delegateReceiver, messageConverter));
}
@Override
public Mono<AmqpReceiver> createReceiver(String address, AmqpReceiverOptions options) {
return delegate.createReceiver(address, options.toVertxAmqpReceiverOptions())
.convert()
.with(UniReactorConverters.toMono())
.map(delegateReceiver -> new SnowdropAmqpReceiver(delegateReceiver, messageConverter));
}
@Override
public Mono<AmqpReceiver> createDynamicReceiver() {
return delegate.createDynamicReceiver()
.convert()
.with(UniReactorConverters.toMono())
.map(delegateReceiver -> new SnowdropAmqpReceiver(delegateReceiver, messageConverter));
}
@Override
public Mono<Void> close() {
return delegate.close()
.convert()
.with(UniReactorConverters.toMono());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-amqp/src/main/java/dev/snowdrop/vertx/amqp/AmqpClient.java | vertx-spring-boot-starter-amqp/src/main/java/dev/snowdrop/vertx/amqp/AmqpClient.java | package dev.snowdrop.vertx.amqp;
import reactor.core.publisher.Mono;
public interface AmqpClient {
Mono<AmqpConnection> connect();
Mono<AmqpSender> createSender(String address);
Mono<AmqpSender> createSender(String address, AmqpSenderOptions options);
Mono<AmqpReceiver> createReceiver(String address);
Mono<AmqpReceiver> createReceiver(String address, AmqpReceiverOptions options);
Mono<Void> close();
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-amqp/src/main/java/dev/snowdrop/vertx/amqp/SnowdropAmqpMessageBuilder.java | vertx-spring-boot-starter-amqp/src/main/java/dev/snowdrop/vertx/amqp/SnowdropAmqpMessageBuilder.java | package dev.snowdrop.vertx.amqp;
import java.time.Instant;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import javax.json.JsonArray;
import javax.json.JsonObject;
import io.vertx.core.buffer.Buffer;
import org.springframework.core.io.buffer.DataBuffer;
class SnowdropAmqpMessageBuilder implements AmqpMessageBuilder {
private final io.vertx.amqp.AmqpMessageBuilder delegate;
SnowdropAmqpMessageBuilder(io.vertx.amqp.AmqpMessageBuilder delegate) {
this.delegate = delegate;
}
SnowdropAmqpMessageBuilder() {
this(io.vertx.amqp.AmqpMessageBuilder.create());
}
@Override
public AmqpMessage build() {
return new SnowdropAmqpMessage(delegate.build());
}
@Override
public AmqpMessageBuilder priority(short priority) {
delegate.priority(priority);
return this;
}
@Override
public AmqpMessageBuilder durable(boolean durable) {
delegate.durable(durable);
return this;
}
@Override
public AmqpMessageBuilder ttl(long ttl) {
delegate.ttl(ttl);
return this;
}
@Override
public AmqpMessageBuilder firstAcquirer(boolean firstAcquirer) {
delegate.firstAcquirer(firstAcquirer);
return this;
}
@Override
public AmqpMessageBuilder deliveryCount(int deliveryCount) {
delegate.deliveryCount(deliveryCount);
return this;
}
@Override
public AmqpMessageBuilder id(String id) {
delegate.id(id);
return this;
}
@Override
public AmqpMessageBuilder address(String address) {
delegate.address(address);
return this;
}
@Override
public AmqpMessageBuilder replyTo(String replyTo) {
delegate.replyTo(replyTo);
return this;
}
@Override
public AmqpMessageBuilder correlationId(String correlationId) {
delegate.correlationId(correlationId);
return this;
}
@Override
public AmqpMessageBuilder withBody(String value) {
delegate.withBody(value);
return this;
}
@Override
public AmqpMessageBuilder withSymbolAsBody(String value) {
delegate.withSymbolAsBody(value);
return this;
}
@Override
public AmqpMessageBuilder subject(String subject) {
delegate.subject(subject);
return this;
}
@Override
public AmqpMessageBuilder contentType(String contentType) {
delegate.contentType(contentType);
return this;
}
@Override
public AmqpMessageBuilder contentEncoding(String contentEncoding) {
delegate.contentEncoding(contentEncoding);
return this;
}
@Override
public AmqpMessageBuilder expiryTime(long expiryTime) {
delegate.expiryTime(expiryTime);
return this;
}
@Override
public AmqpMessageBuilder creationTime(long creationTime) {
delegate.creationTime(creationTime);
return this;
}
@Override
public AmqpMessageBuilder groupId(String groupId) {
delegate.groupId(groupId);
return this;
}
@Override
public AmqpMessageBuilder replyToGroupId(String replyToGroupId) {
delegate.replyToGroupId(replyToGroupId);
return this;
}
@Override
public AmqpMessageBuilder applicationProperties(Map<String, Object> applicationProperties) {
delegate.applicationProperties(new io.vertx.core.json.JsonObject(applicationProperties));
return this;
}
@Override
public AmqpMessageBuilder withBooleanAsBody(boolean value) {
delegate.withBooleanAsBody(value);
return this;
}
@Override
public AmqpMessageBuilder withByteAsBody(byte value) {
delegate.withByteAsBody(value);
return this;
}
@Override
public AmqpMessageBuilder withShortAsBody(short value) {
delegate.withShortAsBody(value);
return this;
}
@Override
public AmqpMessageBuilder withIntegerAsBody(int value) {
delegate.withIntegerAsBody(value);
return this;
}
@Override
public AmqpMessageBuilder withLongAsBody(long value) {
delegate.withLongAsBody(value);
return this;
}
@Override
public AmqpMessageBuilder withFloatAsBody(float value) {
delegate.withFloatAsBody(value);
return this;
}
@Override
public AmqpMessageBuilder withDoubleAsBody(double value) {
delegate.withDoubleAsBody(value);
return this;
}
@Override
public AmqpMessageBuilder withCharAsBody(char value) {
delegate.withCharAsBody(value);
return this;
}
@Override
public AmqpMessageBuilder withInstantAsBody(Instant value) {
delegate.withInstantAsBody(value);
return this;
}
@Override
public AmqpMessageBuilder withUuidAsBody(UUID value) {
delegate.withUuidAsBody(value);
return this;
}
@Override
public AmqpMessageBuilder withListAsBody(List list) {
delegate.withListAsBody(list);
return this;
}
@Override
public AmqpMessageBuilder withMapAsBody(Map map) {
delegate.withMapAsBody(map);
return this;
}
@Override
public AmqpMessageBuilder withBufferAsBody(DataBuffer value) {
delegate.withBufferAsBody(Buffer.buffer(value.asByteBuffer().array()));
return this;
}
@Override
public AmqpMessageBuilder withJsonObjectAsBody(JsonObject jsonObject) {
delegate.withJsonObjectAsBody(new io.vertx.core.json.JsonObject(jsonObject.toString()));
return this;
}
@Override
public AmqpMessageBuilder withJsonArrayAsBody(JsonArray jsonArray) {
delegate.withJsonArrayAsBody(new io.vertx.core.json.JsonArray(jsonArray.toString()));
return this;
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-amqp/src/main/java/dev/snowdrop/vertx/amqp/AmqpPropertiesConverter.java | vertx-spring-boot-starter-amqp/src/main/java/dev/snowdrop/vertx/amqp/AmqpPropertiesConverter.java | package dev.snowdrop.vertx.amqp;
import io.vertx.amqp.AmqpClientOptions;
import io.vertx.core.net.JdkSSLEngineOptions;
import io.vertx.core.net.JksOptions;
import io.vertx.core.net.OpenSSLEngineOptions;
import io.vertx.core.net.PfxOptions;
import io.vertx.core.net.ProxyOptions;
import io.vertx.core.net.ProxyType;
class AmqpPropertiesConverter {
AmqpClientOptions toAmqpClientOptions(AmqpProperties from) {
AmqpClientOptions to = new AmqpClientOptions();
mapAmqpClientOptions(from, to);
mapProtonClientOptions(from, to);
mapNetClientOptions(from, to);
mapClientOptionsBase(from, to);
mapTcpSslOptions(from, to);
mapNetworkOptions(from, to);
return to;
}
private void mapAmqpClientOptions(AmqpProperties from, AmqpClientOptions to) {
to.setHost(from.getHost());
to.setPort(from.getPort());
to.setUsername(from.getUsername());
to.setPassword(from.getPassword());
to.setContainerId(from.getContainerId());
}
private void mapProtonClientOptions(AmqpProperties from, AmqpClientOptions to) {
from.getEnabledSaslMechanisms().forEach(to::addEnabledSaslMechanism);
to.setHeartbeat(from.getHeartbeat());
to.setMaxFrameSize(from.getMaxFrameSize());
to.setVirtualHost(from.getVirtualHost());
to.setSniServerName(from.getSniServerName());
}
private void mapNetClientOptions(AmqpProperties from, AmqpClientOptions to) {
to.setReconnectAttempts(from.getReconnectAttempts());
to.setReconnectInterval(from.getReconnectInterval());
to.setHostnameVerificationAlgorithm(from.getHostnameVerificationAlgorithm());
}
private void mapClientOptionsBase(AmqpProperties from, AmqpClientOptions to) {
to.setConnectTimeout(from.getConnectTimeout());
to.setTrustAll(from.isTrustAll());
to.setMetricsName(from.getMetricsName());
to.setLocalAddress(from.getLocalAddress());
if (from.getProxy().isEnabled()) {
ProxyOptions proxyOptions = new ProxyOptions()
.setHost(from.getProxy().getHost())
.setPort(from.getProxy().getPort())
.setUsername(from.getProxy().getUsername())
.setPassword(from.getProxy().getPassword())
.setType(ProxyType.valueOf(from.getProxy().getType().name()));
to.setProxyOptions(proxyOptions);
}
}
private void mapTcpSslOptions(AmqpProperties from, AmqpClientOptions to) {
to.setTcpNoDelay(from.isTcpNoDelay());
to.setTcpKeepAlive(from.isTcpKeepAlive());
to.setSoLinger(from.getSoLinger());
if (from.isUsePooledBuffers()) {
to.setReceiveBufferSize(from.getReceiveBufferSize());
to.setSendBufferSize(from.getSendBufferSize());
}
to.setIdleTimeout(from.getIdleTimeout());
to.setIdleTimeoutUnit(from.getIdleTimeoutUnit());
to.setSsl(from.isSsl());
to.setSslHandshakeTimeout(from.getSslHandshakeTimeout());
to.setSslHandshakeTimeoutUnit(from.getSslHandshakeTimeoutUnit());
from.getEnabledCipherSuites().forEach(to::addEnabledCipherSuite);
to.setEnabledSecureTransportProtocols(from.getEnabledSecureTransportProtocols());
to.setTcpFastOpen(from.isTcpFastOpen());
to.setTcpCork(from.isTcpCork());
to.setTcpQuickAck(from.isTcpQuickAck());
if (from.getJksKeyStore().isEnabled()) {
JksOptions options = new JksOptions()
.setPath(from.getJksKeyStore().getPath())
.setPassword(from.getJksKeyStore().getPassword());
to.setKeyCertOptions(options);
} else if (from.getPfxKeyStore().isEnabled()) {
PfxOptions options = new PfxOptions()
.setPath(from.getPfxKeyStore().getPath())
.setPassword(from.getPfxKeyStore().getPassword());
to.setKeyCertOptions(options);
}
if (from.getJksTrustStore().isEnabled()) {
JksOptions options = new JksOptions()
.setPath(from.getJksTrustStore().getPath())
.setPassword(from.getJksTrustStore().getPassword());
to.setTrustOptions(options);
} else if (from.getPfxKeyStore().isEnabled()) {
PfxOptions options = new PfxOptions()
.setPath(from.getPfxTrustStore().getPath())
.setPassword(from.getPfxTrustStore().getPassword());
to.setTrustOptions(options);
}
if (from.getJdkSslEngine().isEnabled()) {
to.setJdkSslEngineOptions(new JdkSSLEngineOptions());
} else if (from.getOpenSslEngine().isEnabled()) {
OpenSSLEngineOptions options = new OpenSSLEngineOptions()
.setSessionCacheEnabled(from.getOpenSslEngine().isSessionCacheEnabled());
to.setOpenSslEngineOptions(options);
}
}
private void mapNetworkOptions(AmqpProperties from, AmqpClientOptions to) {
to.setSendBufferSize(from.getSendBufferSize());
to.setReceiveBufferSize(from.getReceiveBufferSize());
to.setTrafficClass(from.getTrafficClass());
to.setReuseAddress(from.isReuseAddress());
to.setLogActivity(from.isLogActivity());
to.setReusePort(from.isReusePort());
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
snowdrop/vertx-spring-boot | https://github.com/snowdrop/vertx-spring-boot/blob/f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff/vertx-spring-boot-starter-amqp/src/main/java/dev/snowdrop/vertx/amqp/AmqpProperties.java | vertx-spring-boot-starter-amqp/src/main/java/dev/snowdrop/vertx/amqp/AmqpProperties.java | package dev.snowdrop.vertx.amqp;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties(prefix = AmqpProperties.PROPERTIES_PREFIX)
public class AmqpProperties {
static final String PROPERTIES_PREFIX = "vertx.amqp";
/**
* Enable AMQP starter.
*/
private boolean enabled = true;
// AmqpClientOptions
/**
* Broker host.
* <p>
* Default: localhost
*
* @see io.vertx.amqp.AmqpClientOptions#getHost()
*/
private String host = "localhost";
/**
* Broker port.
* <p>
* Default: 5672
*
* @see io.vertx.amqp.AmqpClientOptions#getPort()
*/
private int port = 5672;
/**
* Broker username.
*
* @see io.vertx.amqp.AmqpClientOptions#getUsername()
*/
private String username;
/**
* Broker password.
*
* @see io.vertx.amqp.AmqpClientOptions#getPassword()
*/
private String password;
/**
* Broker container id.
*
* @see io.vertx.amqp.AmqpClientOptions#getContainerId()
*/
private String containerId = UUID.randomUUID().toString();
// ProtonClientOptions
/**
* A mechanisms the client should be restricted to use.
*
* @see io.vertx.amqp.AmqpClientOptions#getEnabledSaslMechanisms()
*/
private Set<String> enabledSaslMechanisms = new LinkedHashSet<>();
/**
* A heartbeat (in milliseconds) as maximum delay between sending frames for the remote peers.
*
* @see io.vertx.amqp.AmqpClientOptions#getHeartbeat()
*/
private int heartbeat;
/**
* A maximum frame size for the connection.
*
* @see io.vertx.amqp.AmqpClientOptions#getMaxFrameSize()
*/
private int maxFrameSize;
/**
* A virtual host name override for the connection AMQP Open frame and TLS SNI server name (if TLS is in use).
*
* @see io.vertx.amqp.AmqpClientOptions#getVirtualHost()
*/
private String virtualHost;
/**
* A hostname override for TLS SNI Server Name.
*
* @see io.vertx.amqp.AmqpClientOptions#getSniServerName()
*/
private String sniServerName;
// NetClientOptions
/**
* A number of reconnect attempts.
*
* @see io.vertx.amqp.AmqpClientOptions#getReconnectAttempts()
*/
private int reconnectAttempts;
/**
* A reconnect interval.
*
* @see io.vertx.amqp.AmqpClientOptions#getReconnectInterval()
*/
private long reconnectInterval = 1000;
/**
* A hostname verification algorithm.
*
* @see io.vertx.amqp.AmqpClientOptions#getHostnameVerificationAlgorithm()
*/
private String hostnameVerificationAlgorithm = "";
// ClientOptionsBase
/**
* A connect timeout.
*
* @see io.vertx.amqp.AmqpClientOptions#getConnectTimeout()
*/
private int connectTimeout = 60000;
/**
* Whether all server certificates should be trusted.
*
* @see io.vertx.amqp.AmqpClientOptions#isTrustAll()
*/
private boolean trustAll;
/**
* A metrics name identifying the reported metrics.
*
* @see io.vertx.amqp.AmqpClientOptions#getMetricsName()
*/
private String metricsName = "";
/**
* Connection proxy settings.
*/
private Proxy proxy = new Proxy();
/**
* A local interface to bind for network connections.
*
* @see io.vertx.amqp.AmqpClientOptions#getLocalAddress()
*/
private String localAddress;
// TCPSSLOptions
/**
* Whether TCP no delay is enabled.
*
* @see io.vertx.amqp.AmqpClientOptions#isTcpNoDelay()
*/
private boolean tcpNoDelay = true;
/**
* Whether TCP keep alive is enabled.
*
* @see io.vertx.amqp.AmqpClientOptions#isTcpKeepAlive()
*/
private boolean tcpKeepAlive;
/**
* Whether SO_linger is enabled.
*
* @see io.vertx.amqp.AmqpClientOptions#getSoLinger()
*/
private int soLinger = -1;
private boolean usePooledBuffers;
/**
* An idle timeout, in time unit specified by {@link #idleTimeoutUnit}.
*
* @see io.vertx.amqp.AmqpClientOptions#getIdleTimeout()
*/
private int idleTimeout;
/**
* An idle timeout unit.
*
* @see io.vertx.amqp.AmqpClientOptions#getIdleTimeoutUnit()
*/
private TimeUnit idleTimeoutUnit = TimeUnit.SECONDS;
/**
* Whether SSL/TLS is enabled.
*
* @see io.vertx.amqp.AmqpClientOptions#isSsl()
*/
private boolean ssl;
/**
* An SSL handshake timeout, in time unit specified by {@link #sslHandshakeTimeoutUnit}.
*
* @see io.vertx.amqp.AmqpClientOptions#getSslHandshakeTimeout()
*/
private long sslHandshakeTimeout = 10L;
/**
* An SSL handshake timeout unit.
*
* @see io.vertx.amqp.AmqpClientOptions#getSslHandshakeTimeoutUnit() ()
*/
private TimeUnit sslHandshakeTimeoutUnit = TimeUnit.SECONDS;
/**
* JKS key store properties.
*/
private SslStore jksKeyStore = new SslStore();
/**
* JKS trust store properties.
*/
private SslStore jksTrustStore = new SslStore();
/**
* PFX key store properties.
*/
private SslStore pfxKeyStore = new SslStore();
/**
* PFX trust store properties.
*/
private SslStore pfxTrustStore = new SslStore();
/**
* The enabled cipher suites
*
* @see io.vertx.amqp.AmqpClientOptions#getEnabledCipherSuites()
*/
private Set<String> enabledCipherSuites = new LinkedHashSet<>();
/**
* JDK SSL engine properties.
*/
private JdkSslEngine jdkSslEngine = new JdkSslEngine();
/**
* OpenSSL engine properties.
*/
private OpenSslEngine openSslEngine = new OpenSslEngine();
/**
* The enabled SSL/TLS protocols.
*
* @see io.vertx.amqp.AmqpClientOptions#getEnabledSecureTransportProtocols()
*/
private Set<String> enabledSecureTransportProtocols =
new LinkedHashSet<>(Arrays.asList("TLSv1", "TLSv1.1", "TLSv1.2"));
/**
* Whether {@code TCP_FASTOPEN} option is enabled
*
* @see io.vertx.amqp.AmqpClientOptions#isTcpFastOpen()
*/
private boolean tcpFastOpen;
/**
* Whether {@code TCP_CORK} option is enabled.
*
* @see io.vertx.amqp.AmqpClientOptions#isTcpCork()
*/
private boolean tcpCork;
/**
* Whether {@code TCP_QUICKACK} option is enabled.
*
* @see io.vertx.amqp.AmqpClientOptions#isTcpQuickAck()
*/
private boolean tcpQuickAck;
// NetworkOptions
/**
* A TCP send buffer size in bytes.
*
* @see io.vertx.amqp.AmqpClientOptions#getSendBufferSize()
*/
private int sendBufferSize = -1;
/**
* A TCP receive buffer size in bytes
*
* @see io.vertx.amqp.AmqpClientOptions#getReceiveBufferSize()
*/
private int receiveBufferSize = -1;
/**
* A traffic class.
*
* @see io.vertx.amqp.AmqpClientOptions#getTrafficClass()
*/
private int trafficClass = -1;
/**
* Whether address should be reused.
*
* @see io.vertx.amqp.AmqpClientOptions#isReuseAddress()
*/
private boolean reuseAddress = true;
/**
* Whether network activity logging should be enabled.
*
* @see io.vertx.amqp.AmqpClientOptions#getLogActivity()
*/
private boolean logActivity;
/**
* Whether port should be reused.
*
* @see io.vertx.amqp.AmqpClientOptions#isReusePort()
*/
private boolean reusePort;
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getContainerId() {
return containerId;
}
public void setContainerId(String containerId) {
this.containerId = containerId;
}
public Set<String> getEnabledSaslMechanisms() {
return enabledSaslMechanisms;
}
public void setEnabledSaslMechanisms(Set<String> enabledSaslMechanisms) {
if (enabledSaslMechanisms == null) {
this.enabledSaslMechanisms = new LinkedHashSet<>();
} else {
this.enabledSaslMechanisms = enabledSaslMechanisms;
}
}
public int getHeartbeat() {
return heartbeat;
}
public void setHeartbeat(int heartbeat) {
this.heartbeat = heartbeat;
}
public int getMaxFrameSize() {
return maxFrameSize;
}
public void setMaxFrameSize(int maxFrameSize) {
this.maxFrameSize = maxFrameSize;
}
public String getVirtualHost() {
return virtualHost;
}
public void setVirtualHost(String virtualHost) {
this.virtualHost = virtualHost;
}
public String getSniServerName() {
return sniServerName;
}
public void setSniServerName(String sniServerName) {
this.sniServerName = sniServerName;
}
public int getReconnectAttempts() {
return reconnectAttempts;
}
public void setReconnectAttempts(int reconnectAttempts) {
this.reconnectAttempts = reconnectAttempts;
}
public long getReconnectInterval() {
return reconnectInterval;
}
public void setReconnectInterval(long reconnectInterval) {
this.reconnectInterval = reconnectInterval;
}
public String getHostnameVerificationAlgorithm() {
return hostnameVerificationAlgorithm;
}
public void setHostnameVerificationAlgorithm(String hostnameVerificationAlgorithm) {
this.hostnameVerificationAlgorithm = hostnameVerificationAlgorithm;
}
public int getConnectTimeout() {
return connectTimeout;
}
public void setConnectTimeout(int connectTimeout) {
this.connectTimeout = connectTimeout;
}
public boolean isTrustAll() {
return trustAll;
}
public void setTrustAll(boolean trustAll) {
this.trustAll = trustAll;
}
public String getMetricsName() {
return metricsName;
}
public void setMetricsName(String metricsName) {
this.metricsName = metricsName;
}
public Proxy getProxy() {
return proxy;
}
public String getLocalAddress() {
return localAddress;
}
public void setLocalAddress(String localAddress) {
this.localAddress = localAddress;
}
public boolean isTcpNoDelay() {
return tcpNoDelay;
}
public void setTcpNoDelay(boolean tcpNoDelay) {
this.tcpNoDelay = tcpNoDelay;
}
public boolean isTcpKeepAlive() {
return tcpKeepAlive;
}
public void setTcpKeepAlive(boolean tcpKeepAlive) {
this.tcpKeepAlive = tcpKeepAlive;
}
public int getSoLinger() {
return soLinger;
}
public void setSoLinger(int soLinger) {
this.soLinger = soLinger;
}
public boolean isUsePooledBuffers() {
return usePooledBuffers;
}
public void setUsePooledBuffers(boolean usePooledBuffers) {
this.usePooledBuffers = usePooledBuffers;
}
public int getIdleTimeout() {
return idleTimeout;
}
public void setIdleTimeout(int idleTimeout) {
this.idleTimeout = idleTimeout;
}
public TimeUnit getIdleTimeoutUnit() {
return idleTimeoutUnit;
}
public void setIdleTimeoutUnit(TimeUnit idleTimeoutUnit) {
this.idleTimeoutUnit = idleTimeoutUnit;
}
public boolean isSsl() {
return ssl;
}
public void setSsl(boolean ssl) {
this.ssl = ssl;
}
public long getSslHandshakeTimeout() {
return sslHandshakeTimeout;
}
public void setSslHandshakeTimeout(long sslHandshakeTimeout) {
this.sslHandshakeTimeout = sslHandshakeTimeout;
}
public TimeUnit getSslHandshakeTimeoutUnit() {
return sslHandshakeTimeoutUnit;
}
public void setSslHandshakeTimeoutUnit(TimeUnit sslHandshakeTimeoutUnit) {
this.sslHandshakeTimeoutUnit = sslHandshakeTimeoutUnit;
}
public SslStore getJksKeyStore() {
return jksKeyStore;
}
public SslStore getJksTrustStore() {
return jksTrustStore;
}
public SslStore getPfxKeyStore() {
return pfxKeyStore;
}
public SslStore getPfxTrustStore() {
return pfxTrustStore;
}
public Set<String> getEnabledCipherSuites() {
return enabledCipherSuites;
}
public void setEnabledCipherSuites(Set<String> enabledCipherSuites) {
if (enabledCipherSuites == null) {
this.enabledCipherSuites = new LinkedHashSet<>();
} else {
this.enabledCipherSuites = enabledCipherSuites;
}
}
public JdkSslEngine getJdkSslEngine() {
return jdkSslEngine;
}
public OpenSslEngine getOpenSslEngine() {
return openSslEngine;
}
public Set<String> getEnabledSecureTransportProtocols() {
return enabledSecureTransportProtocols;
}
public void setEnabledSecureTransportProtocols(Set<String> enabledSecureTransportProtocols) {
if (enabledSecureTransportProtocols == null) {
this.enabledSecureTransportProtocols = new LinkedHashSet<>();
} else {
this.enabledSecureTransportProtocols = enabledSecureTransportProtocols;
}
}
public boolean isTcpFastOpen() {
return tcpFastOpen;
}
public void setTcpFastOpen(boolean tcpFastOpen) {
this.tcpFastOpen = tcpFastOpen;
}
public boolean isTcpCork() {
return tcpCork;
}
public void setTcpCork(boolean tcpCork) {
this.tcpCork = tcpCork;
}
public boolean isTcpQuickAck() {
return tcpQuickAck;
}
public void setTcpQuickAck(boolean tcpQuickAck) {
this.tcpQuickAck = tcpQuickAck;
}
public int getSendBufferSize() {
return sendBufferSize;
}
public void setSendBufferSize(int sendBufferSize) {
this.sendBufferSize = sendBufferSize;
}
public int getReceiveBufferSize() {
return receiveBufferSize;
}
public void setReceiveBufferSize(int receiveBufferSize) {
this.receiveBufferSize = receiveBufferSize;
}
public int getTrafficClass() {
return trafficClass;
}
public void setTrafficClass(int trafficClass) {
this.trafficClass = trafficClass;
}
public boolean isReuseAddress() {
return reuseAddress;
}
public void setReuseAddress(boolean reuseAddress) {
this.reuseAddress = reuseAddress;
}
public boolean isLogActivity() {
return logActivity;
}
public void setLogActivity(boolean logActivity) {
this.logActivity = logActivity;
}
public boolean isReusePort() {
return reusePort;
}
public void setReusePort(boolean reusePort) {
this.reusePort = reusePort;
}
public static class Proxy {
private boolean enabled;
private String host = "localhost";
private int port = 3128;
private String username;
private String password;
private ProxyType type = ProxyType.HTTP;
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public ProxyType getType() {
return type;
}
public void setType(ProxyType type) {
this.type = type;
}
}
public static class SslStore {
private boolean enabled;
private String password;
private String path;
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
}
public static class OpenSslEngine {
/**
* Whether OpenSSL engine is enabled.
*/
private boolean enabled;
/**
* Whether session cache is enabled in open SSL session server context.
*
* @see io.vertx.core.net.OpenSSLEngineOptions#isSessionCacheEnabled()
*/
private boolean sessionCacheEnabled;
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public boolean isSessionCacheEnabled() {
return sessionCacheEnabled;
}
public void setSessionCacheEnabled(boolean sessionCacheEnabled) {
this.sessionCacheEnabled = sessionCacheEnabled;
}
}
public static class JdkSslEngine {
/**
* Whether JDK SSL engine is enabled.
*/
private boolean enabled;
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
}
public enum ProxyType {
HTTP,
SOCKS4,
SOCKS5
}
}
| java | Apache-2.0 | f6c0be4d6e09d03044f8ab7e9a07d00148fa96ff | 2026-01-05T02:40:52.865792Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.