Sparql.java

package eu.fbk.knowledgestore.server.http.jaxrs;

import java.util.List;
import java.util.Set;

import javax.ws.rs.Consumes;
import javax.ws.rs.FormParam;
import javax.ws.rs.GET;
import javax.ws.rs.HttpMethod;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.GenericType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;

import com.google.common.collect.Sets;

import org.codehaus.enunciate.jaxrs.TypeHint;
import org.openrdf.model.URI;

import eu.fbk.knowledgestore.Operation;
import eu.fbk.knowledgestore.OperationException;
import eu.fbk.knowledgestore.Outcome;
import eu.fbk.knowledgestore.data.Data;
import eu.fbk.knowledgestore.data.Stream;
import eu.fbk.knowledgestore.internal.jaxrs.Protocol;
import eu.fbk.knowledgestore.internal.rdf.RDFUtil;

/**
 * Provides the KnowledgeStore SPARQL endpoint.
 * <p style="color: red">
 * DOCUMENTATION COMING SOON
 * </p>
 */
@Path("/" + Protocol.PATH_SPARQL)
public class Sparql extends Resource {

    @GET
    @Produces(Protocol.MIME_TYPES_ALL)
    @TypeHint(Stream.class)
    public Response get(
            @QueryParam(Protocol.PARAMETER_DEFAULT_GRAPH) final List<String> defaultGraphs,
            @QueryParam(Protocol.PARAMETER_NAMED_GRAPH) final List<String> namedGraphs,
            @QueryParam(Protocol.PARAMETER_QUERY) final String query) throws OperationException {
        return query(query, defaultGraphs, namedGraphs);
    }

    @POST
    @Consumes("application/x-www-form-urlencoded")
    @Produces(Protocol.MIME_TYPES_ALL)
    @TypeHint(Stream.class)
    public Response postURLencoded(
            @FormParam(Protocol.PARAMETER_DEFAULT_GRAPH) final List<String> defaultGraphs,
            @FormParam(Protocol.PARAMETER_NAMED_GRAPH) final List<String> namedGraphs,
            @FormParam(Protocol.PARAMETER_QUERY) final String query) throws OperationException {
        return query(query, defaultGraphs, namedGraphs);
    }

    @POST
    @Consumes("application/sparql-query")
    @Produces(Protocol.MIME_TYPES_ALL)
    @TypeHint(Stream.class)
    public Response postDirect(
            @QueryParam(Protocol.PARAMETER_DEFAULT_GRAPH) final List<String> defaultGraphs,
            @QueryParam(Protocol.PARAMETER_NAMED_GRAPH) final List<String> namedGraphs,
            final String query) throws OperationException {
        return query(query, defaultGraphs, namedGraphs);
    }

    private Response query(final String query, final List<String> defaultGraphs,
            final List<String> namedGraphs) throws OperationException {

        // Check mandatory parameter
        checkNotNull(query, Outcome.Status.ERROR_INVALID_INPUT, "Missing query");

        // Prepare the SPARQL operation, returning an error if parameters are wrong
        final String form;
        final Operation.Sparql operation;
        try {
            form = RDFUtil.detectSparqlForm(query);
            operation = getSession().sparql(query) //
                    .timeout(getTimeout()) //
                    .defaultGraphs(parseGraphURIs(defaultGraphs)) //
                    .namedGraphs(parseGraphURIs(namedGraphs));
        } catch (final RuntimeException ex) {
            throw new OperationException(newOutcome(Outcome.Status.ERROR_INVALID_INPUT, "%s",
                    ex.getMessage()), ex);
        }

        // Select correct MIME type via negotiation, validate preconditions and handle probes
        final GenericType<?> type;
        if (form.equals("construct") || form.equals("describe")) {
            init(false, Protocol.MIME_TYPES_RDF, null, null);
            type = Protocol.STREAM_OF_STATEMENTS;
        } else if (form.equals("select")) {
            init(false, Protocol.MIME_TYPES_SPARQL_TUPLE, null, null);
            type = Protocol.STREAM_OF_TUPLES;
        } else {
            init(false, Protocol.MIME_TYPES_SPARQL_BOOLEAN, null, null);
            type = Protocol.STREAM_OF_BOOLEANS;
        }

        // Setup the result stream based on the selected type. Note that an empty result is
        // selected for HEAD methods, as only headers will be returned.
        Stream<?> entity;
        if (getMethod().equals(HttpMethod.HEAD)) {
            entity = Stream.create();
        } else if (type == Protocol.STREAM_OF_STATEMENTS) {
            entity = operation.execTriples();
        } else if (type == Protocol.STREAM_OF_TUPLES) {
            entity = operation.execTuples();
        } else if (type == Protocol.STREAM_OF_BOOLEANS) {
            entity = Stream.create(operation.execBoolean());
        } else {
            throw new Error("Unexpected type: " + type);
        }

        // Build and return the SPARQL response
        return newResponseBuilder(Status.OK, closeOnCompletion(entity), type).build();
    }

    private static Set<URI> parseGraphURIs(final List<String> strings) {
        if (strings == null || strings.isEmpty()) {
            return null;
        }
        final Set<URI> uris = Sets.newHashSetWithExpectedSize(strings.size());
        for (final String string : strings) {
            uris.add(Data.getValueFactory().createURI(string));
        }
        return uris;
    }

}