io.dropwizard.redis.RedisClusterClientFactory Maven / Gradle / Ivy

Go to download
package io.dropwizard.redis;

import brave.Tracing;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.health.HealthCheckRegistry;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonTypeName;
import io.dropwizard.lifecycle.setup.LifecycleEnvironment;
import io.dropwizard.redis.clientoptions.ClusterClientOptionsFactory;
import io.dropwizard.redis.health.RedisHealthCheck;
import io.dropwizard.redis.managed.RedisClientManager;
import io.dropwizard.redis.metrics.event.visitor.EventVisitor;
import io.dropwizard.redis.metrics.event.wrapper.EventWrapperFactory;
import io.dropwizard.redis.metrics.event.wrapper.VisitableEventWrapper;
import io.dropwizard.redis.uri.RedisURIFactory;
import io.lettuce.core.RedisURI;
import io.lettuce.core.cluster.RedisClusterClient;
import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
import io.lettuce.core.codec.RedisCodec;
import io.lettuce.core.resource.ClientResources;
import org.hibernate.validator.constraints.NotEmpty;

import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import javax.annotation.Nullable;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;

@JsonTypeName("cluster")
public class RedisClusterClientFactory extends AbstractRedisClientFactory {
    @Valid
    @NotEmpty
    @JsonProperty
    private List nodes = Collections.emptyList();

    @Valid
    @NotNull
    @JsonProperty
    private ClusterClientOptionsFactory clientOptions = new ClusterClientOptionsFactory();

    public ClusterClientOptionsFactory getClientOptions() {
        return clientOptions;
    }

    public void setClientOptions(final ClusterClientOptionsFactory clientOptions) {
        this.clientOptions = clientOptions;
    }

    @Override
    public StatefulRedisClusterConnection build(final HealthCheckRegistry healthChecks, final LifecycleEnvironment lifecycle,
                                                      final MetricRegistry metrics) {
        return build(healthChecks, lifecycle, metrics, null);
    }

    @Override
    public StatefulRedisClusterConnection build(final HealthCheckRegistry healthChecks, final LifecycleEnvironment lifecycle,
                                                      final MetricRegistry metrics, @Nullable final Tracing tracing) {
        final List uris = nodes.stream()
                .map(RedisURIFactory::build)
                .collect(Collectors.toList());

        final ClientResources resources = clientResources.build(name, metrics, tracing);

        final RedisClusterClient redisClusterClient = RedisClusterClient.create(resources, uris);

        redisClusterClient.setOptions(clientOptions.build());

        final RedisCodec codec = redisCodec.build();

        final StatefulRedisClusterConnection connection = redisClusterClient.connect(codec);

        // manage client and connection
        lifecycle.manage(new RedisClientManager(redisClusterClient, connection, name));

        // health check
        healthChecks.register(name, new RedisHealthCheck(() -> connection.sync().ping()));

        // metrics (latency and other connection events) integration
        final List eventVisitors = buildEventVisitors(metrics);
        redisClusterClient.getResources()
                .eventBus()
                .get()
                .subscribe(event -> {
                    final Optional eventWrapperOpt = EventWrapperFactory.build(event);
                    eventWrapperOpt.ifPresent(eventWrapper -> eventVisitors.forEach(eventWrapper::accept));
                });

        return connection;
    }
}