Resource.java

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

import java.io.Closeable;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.List;

import javax.annotation.Nullable;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.container.ResourceInfo;
import javax.ws.rs.core.CacheControl;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.EntityTag;
import javax.ws.rs.core.GenericEntity;
import javax.ws.rs.core.GenericType;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Request;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.ResponseBuilder;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.UriInfo;
import javax.ws.rs.core.Variant;

import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.Lists;

import org.openrdf.model.URI;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import eu.fbk.knowledgestore.KnowledgeStore;
import eu.fbk.knowledgestore.OperationException;
import eu.fbk.knowledgestore.Outcome;
import eu.fbk.knowledgestore.Session;
import eu.fbk.knowledgestore.internal.jaxrs.Protocol;
import eu.fbk.knowledgestore.server.http.UIConfig;

public abstract class Resource {

    private static final Logger LOGGER = LoggerFactory.getLogger(Resource.class);

    private static final ThreadLocal<RequestContext> THREAD_CONTEXT //
    = new ThreadLocal<RequestContext>();

    @Context
    private javax.ws.rs.core.Application application;

    @Context
    private Request request;

    @Context
    private ResourceInfo resource;

    @Context
    private UriInfo uri;

    @Nullable
    private final RequestContext context; // A solution based on injection should be rather used

    Resource() {
        this.context = Preconditions.checkNotNull(THREAD_CONTEXT.get());
    }

    final UIConfig getUIConfig() {
        return Application.unwrap(this.application).getUIConfig();
    }

    final Application getApplication() {
        return Application.unwrap(this.application);
    }

    final KnowledgeStore getStore() {
        return Application.unwrap(this.application).getStore();
    }

    final Session getSession() {
        if (this.context.session == null) {
            this.context.session = getStore().newSession(getUsername(), null);
            this.context.closeables.add(this.context.session);
        }
        return this.context.session;
    }

    final URI getInvocationID() {
        return this.context.invocationID;
    }

    @Nullable
    final URI getObjectID() {
        return this.context.objectID;
    }

    @Nullable
    final String getUsername() {
        return this.context.username;
    }

    final String getMethod() {
        return this.request.getMethod();
    }

    final UriInfo getUriInfo() {
        return this.uri;
    }

    final boolean isChunkedInput() {
        return this.context.chunkedInput;
    }

    final boolean isCachingEnabled() {
        return this.context.cachingEnabled;
    }

    final long getTimeout() {
        return this.context.timeout;
    }

    final <T extends Closeable> T closeQuietly(@Nullable final T closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (final Throwable ex) {
                LOGGER.error("Exception caught closing " + closeable.getClass().getSimpleName(),
                        ex);
            }
        }
        return closeable;
    }

    final <T extends Closeable> T closeOnCompletion(@Nullable final T closeable) {
        if (closeable != null) {
            this.context.closeables.add(closeable);
        }
        return closeable;
    }

    final void check(final boolean condition, final Outcome.Status errorStatus,
            @Nullable final String errorMessage, final Object... errorArgs)
            throws OperationException {
        if (!condition) {
            throw new OperationException(newOutcome(errorStatus, errorMessage == null ? null
                    : String.format(errorMessage, errorArgs)));
        }
    }

    final <T> T checkNotNull(final T object, final Outcome.Status errorStatus,
            @Nullable final String errorMessage, final Object... errorArgs)
            throws OperationException {
        if (object == null) {
            throw new OperationException(newOutcome(errorStatus, errorMessage == null ? null
                    : String.format(errorMessage, errorArgs)));
        }
        return object;
    }

    final void init(final boolean modification, @Nullable final String responseType)
            throws OperationException {
        doInit(modification, false, responseType, null, null);
    }

    final void init(final boolean modification, @Nullable final String responseType,
            @Nullable final Date getLastModified, @Nullable final String getTag)
            throws OperationException {
        doInit(modification, true, responseType, getLastModified, getTag);
    }

    private void doInit(final boolean modification, final boolean exists,
            @Nullable final String responseType, @Nullable final Date getLastModified,
            @Nullable final String getTag) throws OperationException {

        // Determine returned variant
        this.context.variant = computeVariant(responseType);

        // Evaluate preconditions, based on available parameters (last modified, tag)
        final ResponseBuilder builder;
        if (!exists) {
            builder = this.request.evaluatePreconditions();

        } else {
            // Initialize last modified
            final Date lastModified = getLastModified != null ? getLastModified : getApplication()
                    .getLastModified();

            // Initialize etag
            final EntityTag etag = new EntityTag(String.format("%s,%s,%s", getTag != null ? getTag
                    : Long.toString(lastModified.getTime(), 16), this.context.variant
                    .getMediaType().toString(), this.context.variant.getEncoding()));

            // Check preconditions
            builder = this.request.evaluatePreconditions(lastModified, etag);

            // Store last modified and etag for later inclusion in response, in case of retrieval
            if ("GET".equalsIgnoreCase(this.request.getMethod())
                    || "HEAD".equalsIgnoreCase(this.request.getMethod())) {
                this.context.lastModified = lastModified;
                this.context.etag = etag;
            }
        }

        // If preconditions failed, return the Response built by JAX-RS
        if (builder != null) {
            // Note: no Outcome entity sent here as it can confuse clients; also, in case of 304
            // Not Modified, an entity MUST not be sent.
            throw new WebApplicationException(builder.build());
        }

        // Interrupt processing in case of a probe request
        if (this.uri.getQueryParameters().containsKey(Protocol.PARAMETER_PROBE)) {
            String newURI = this.uri.getRequestUri().toString();
            int start = newURI.indexOf('?' + Protocol.PARAMETER_PROBE);
            if (start < 0) {
                start = newURI.indexOf('&' + Protocol.PARAMETER_PROBE);
            }
            int end = newURI.indexOf('&', start + 1);
            if (end < 0) {
                end = newURI.length();
            }
            newURI = newURI.substring(0, start) + newURI.substring(end);
            final Response redirect = Response.status(Status.FOUND)
                    .location(java.net.URI.create(newURI)).build();
            throw new WebApplicationException(redirect);
        }

        // Register modification; unregister it when request processing completes
        if (modification) {
            getApplication().beginModification();
            closeOnCompletion(new Closeable() {

                @Override
                public void close() throws IOException {
                    getApplication().endModification();
                }

            });
        }
    }

    private Variant computeVariant(@Nullable final String mimeType) throws OperationException {

        // Determine supported media types from supplied type or @Produces annotation
        MediaType[] types = null;
        if (mimeType != null) {
            types = parseMediaTypes(mimeType);
        } else {
            types = new MediaType[] { MediaType.WILDCARD_TYPE };
            final Method method = this.resource.getResourceMethod();
            if (method != null) {
                final Produces produces = method.getAnnotation(Produces.class);
                if (produces != null) {
                    types = parseMediaTypes(produces.value());
                }
            }
        }

        // Determine supported encodings from supplied encoding or using defaults
        final String[] encodings = new String[] { "identity", "gzip", "deflate" };

        // Perform negotiation and return the result, failing if there is no acceptable variant
        final Variant variant = this.request.selectVariant(Variant.mediaTypes(types)
                .encodings(encodings).build());
        check(variant != null, Outcome.Status.ERROR_NOT_ACCEPTABLE, null);
        return variant;
    }

    private MediaType[] parseMediaTypes(final String... strings) {
        final List<MediaType> list = Lists.newArrayList();
        for (final String string : strings) {
            for (final String token : Splitter.on(',').trimResults().omitEmptyStrings()
                    .split(string)) {
                list.add(MediaType.valueOf(token));
            }
        }
        return list.toArray(new MediaType[list.size()]);
    }

    final ResponseBuilder newResponseBuilder(final int status, @Nullable final Object entity,
            @Nullable final GenericType<?> type) {
        return newResponseBuilder(Status.fromStatusCode(status), entity, type);
    }

    final ResponseBuilder newResponseBuilder(final Status status, @Nullable final Object entity,
            @Nullable final GenericType<?> type) {
        Preconditions.checkState(this.context.variant != null);
        final ResponseBuilder builder = Response.status(status);
        if (entity != null) {
            builder.entity(type == null ? entity : new GenericEntity<Object>(entity, type
                    .getType()));
            builder.variant(this.context.variant);
            final CacheControl cacheControl = new CacheControl();
            cacheControl.setNoStore(true);
            if ("GET".equalsIgnoreCase(this.request.getMethod())
                    || "HEAD".equalsIgnoreCase(this.request.getMethod())) {
                builder.lastModified(this.context.lastModified);
                builder.tag(this.context.etag);
                if (isCachingEnabled()) {
                    cacheControl.setNoStore(false);
                    cacheControl.setMaxAge(0); // always stale, must revalidate each time
                    cacheControl.setMustRevalidate(true);
                    cacheControl.setPrivate(getUsername() != null);
                    cacheControl.setNoTransform(true);
                }
            }
            builder.cacheControl(cacheControl);
        }
        return builder;
    }

    final Outcome newOutcome(final Outcome.Status status, @Nullable final String message,
            final Object... messageArgs) {
        return Outcome.create(status, getInvocationID(), getObjectID(), message == null ? null
                : String.format(message, messageArgs));
    }

    final OperationException newException(final Outcome.Status status,
            @Nullable final Throwable cause, @Nullable final String message, final Object... args) {
        String actualMessage = message;
        if (cause != null) {
            actualMessage = message == null ? cause.getMessage() : message + " - "
                    + cause.getMessage();
        }
        return new OperationException(newOutcome(status, actualMessage, args), cause);
    }

    static void begin(final URI invocationID, @Nullable final URI objectID,
            @Nullable final String username, final boolean chunkedInput,
            final boolean cachingEnabled, final long timeout) {
        THREAD_CONTEXT.set(new RequestContext(invocationID, objectID, username, chunkedInput,
                cachingEnabled, timeout));
    }

    static void end() {
        final RequestContext context = THREAD_CONTEXT.get();
        if (context != null) {
            context.close();
            THREAD_CONTEXT.set(null);
        }
    }

    private static final class RequestContext implements Closeable {

        final URI invocationID;

        @Nullable
        final URI objectID;

        @Nullable
        final String username;

        final boolean chunkedInput;

        final boolean cachingEnabled;

        final long timeout;

        final List<Closeable> closeables;

        @Nullable
        Session session;

        @Nullable
        Variant variant;

        @Nullable
        Date lastModified;

        @Nullable
        EntityTag etag;

        private boolean closed;

        RequestContext(final URI invocationID, final URI objectID, final String username,
                final boolean chunkedInput, final boolean cacheEnabled, final long timeout) {
            this.invocationID = Preconditions.checkNotNull(invocationID);
            this.objectID = objectID;
            this.username = username;
            this.chunkedInput = chunkedInput;
            this.cachingEnabled = cacheEnabled;
            this.timeout = timeout;
            this.closeables = Lists.newArrayList();
            this.closed = false;
        }

        @Override
        public void close() {
            if (this.closed) {
                return;
            }
            try {
                for (final Closeable closeable : this.closeables) {
                    try {
                        closeable.close();
                    } catch (final Throwable ex) {
                        LOGGER.error("Error closing " + closeable.getClass().getSimpleName(), ex);
                    }
                }
                this.closeables.clear();
                this.session = null;
                this.variant = null;
                this.lastModified = null;
                this.etag = null;
            } finally {
                this.closed = true;
            }
        }

    }

}