org.kiwiproject.consul.PreparedQueryClient Maven / Gradle / Ivy

Go to download
package org.kiwiproject.consul;

import static java.util.Objects.nonNull;

import org.kiwiproject.consul.async.Callback;
import org.kiwiproject.consul.config.ClientConfig;
import org.kiwiproject.consul.model.query.PreparedQuery;
import org.kiwiproject.consul.model.query.QueryId;
import org.kiwiproject.consul.model.query.QueryResults;
import org.kiwiproject.consul.model.query.StoredQuery;
import org.kiwiproject.consul.monitoring.ClientEventCallback;
import org.kiwiproject.consul.option.QueryOptions;
import retrofit2.Call;
import retrofit2.Retrofit;
import retrofit2.http.Body;
import retrofit2.http.DELETE;
import retrofit2.http.GET;
import retrofit2.http.POST;
import retrofit2.http.Path;
import retrofit2.http.QueryMap;

import java.util.List;
import java.util.Map;
import java.util.Optional;

public class PreparedQueryClient extends BaseClient {

    private static final String CLIENT_NAME = "preparedquery";

    private final Api api;

    /**
     * Constructs an instance of this class.
     *
     * @param retrofit The {@link Retrofit} to build a client from.
     */
    PreparedQueryClient(Retrofit retrofit, ClientConfig config, ClientEventCallback eventCallback) {
        super(CLIENT_NAME, config, eventCallback);
        this.api = retrofit.create(Api.class);
    }

    /**
     * Creates a prepared query.
     * 
     * POST /v1/query
     *
     * @param preparedQuery The prepared query to create.
     * @return The ID of the created query.
     */
    public String createPreparedQuery(PreparedQuery preparedQuery) {
        return createPreparedQuery(preparedQuery, null);
    }

    /**
     * Creates a prepared query.
     * 

     * POST /v1/query
     *
     * @param preparedQuery The prepared query to create.
     * @param dc            The data center.
     * @return The ID of the created query.
     */
    public String createPreparedQuery(PreparedQuery preparedQuery, final String dc) {
        return http.extract(api.createPreparedQuery(preparedQuery, dcQuery(dc))).getId();
    }

    private Map dcQuery(String dc) {
        return nonNull(dc) ? Map.of("dc", dc): Map.of();
    }

    /**
     * Retrieves the list of prepared queries.
     * 

     * GET /v1/query
     *
     * @return The list of prepared queries.
     */
    public List getPreparedQueries() {
        return getPreparedQueries(null);
    }

    /**
     * Retrieves the list of prepared queries.
     * 

     * GET /v1/query
     *
     * @param dc The data center.
     * @return The list of prepared queries.
     */
    public List getPreparedQueries(final String dc) {
        return http.extract(api.getPreparedQueries(dcQuery(dc)));
    }

    /**
     * Retrieves a prepared query by its ID.
     * 

     * GET /v1/query/{id}
     *
     * @param id The query ID.
     * @return The store prepared query.
     */
    public Optional getPreparedQuery(String id) {
        return getPreparedQuery(id, null);
    }

    /**
     * Retrieves a prepared query by its ID.
     * 
     * GET /v1/query/{id}
     *
     * @param id The query ID.
     * @param dc The data center.
     * @return The store prepared query.
     */
    public Optional getPreparedQuery(String id, final String dc) {
        List result = http.extract(api.getPreparedQuery(id, dcQuery(dc)));

        return result.isEmpty() ? Optional.empty() : Optional.of(result.get(0));
    }

    /**
     * Executes a prepared query by its name or ID.
     *
     * @param nameOrId The query name or ID.
     * @return A {@link QueryResults} object containing service instances.
     */
    public QueryResults execute(String nameOrId) {
        return http.extract(api.execute(nameOrId, Map.of()));
    }

    /**
     * Executes a prepared query by its name or ID.
     *
     * @param nameOrId The query name or ID.
     * @param options Query options.
     * @param callback Basic callback for the response.
     */
    public void execute(String nameOrId, QueryOptions options, final Callback callback) {
        http.extractBasicResponse(api.execute(nameOrId, options.toQuery()), callback);
    }

    /**
     * Deletes a prepared query by its ID.
     *
     * @param id The query ID
     */
    public void deletePreparedQuery(String id) {
        deletePreparedQuery(id, null);
    }

    /**
     * Deletes a prepared query by its ID.
     *
     * @param id The query ID
     * @param dc The data center
     */
    public void deletePreparedQuery(String id, String dc) {
        http.extract(api.deletePreparedQuery(id, dcQuery(dc)));
    }

    /**
     * Retrofit API interface.
     */
    interface Api {

        @GET("query")
        Call> getPreparedQueries(@QueryMap Map queryMap);

        @POST("query")
        Call createPreparedQuery(@Body PreparedQuery preparedQuery,
                                          @QueryMap Map queryMap);

        @GET("query/{id}")
        Call> getPreparedQuery(@Path("id") String id,
                                                 @QueryMap Map queryMap);

        @GET("query/{nameOrId}/execute")
        Call execute(@Path("nameOrId") String nameOrId,
                                   @QueryMap Map queryMap);

        @DELETE("query/{id}")
        Call deletePreparedQuery(@Path("id") String id,
                                       @QueryMap Map queryMap);
    }
}