DriverRequest.java

/* 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

package org.esigate.impl;

import java.net.MalformedURLException;
import java.net.URL;

import org.apache.http.HttpStatus;
import org.esigate.Driver;
import org.esigate.HttpErrorPage;
import org.esigate.UserContext;
import org.esigate.api.ContainerRequestContext;
import org.esigate.http.IncomingRequest;
import org.esigate.util.UriUtils;

/**
 * A request to be executed by a given {@link Driver} instance.
 * 
 * @author Francois-Xavier Bonnet
 * 
 */
public class DriverRequest {
    private final IncomingRequest wrappedRequest;
    private final Driver driver;
    private final UserContext userContext;
    private final URL baseUrl;
    private final String visibleBaseUrl;
    private final boolean external;
    private String characterEncoding;

    /**
     * 
     * @param request
     * @param driver
     * @param relUrl
     * @throws HttpErrorPage
     */
    public DriverRequest(IncomingRequest request, Driver driver, String relUrl) throws HttpErrorPage {
        this.wrappedRequest = request;
        this.driver = driver;
        this.external = UriUtils.isAbsolute(relUrl);
        this.userContext = new UserContext(request, driver.getConfiguration().getInstanceName());
        try {
            this.baseUrl = new URL(driver.getConfiguration().getBaseUrlRetrieveStrategy().getBaseURL(request));
        } catch (MalformedURLException e) {
            throw new HttpErrorPage(HttpStatus.SC_INTERNAL_SERVER_ERROR, "Internal server error", e);
        }
        String visibleBase = driver.getConfiguration().getVisibleBaseURL();
        if (visibleBase == null) {
            String requestUri = request.getRequestLine().getUri();
            requestUri = UriUtils.removeQuerystring(requestUri);
            if (!this.external && requestUri.endsWith(relUrl)) {
                visibleBase = requestUri.substring(0, requestUri.length() - relUrl.length());
            } else {
                visibleBase = this.baseUrl.toString();
            }
        }
        this.visibleBaseUrl = UriUtils.rewriteURI(visibleBase, UriUtils.extractHost(request.getRequestLine().getUri()));
    }

    /**
     * Returns the driver instance that handles this request.
     * 
     * @return the driver instance
     */
    public Driver getDriver() {
        return driver;
    }

    /**
     * Returns the user context associated with this request.
     * 
     * @return the user context
     */
    public UserContext getUserContext() {
        return userContext;
    }

    /**
     * Returns the base url selected to send this request.
     * 
     * @return the base url
     */
    public URL getBaseUrl() {
        return baseUrl;
    }

    /**
     * Returns the charset used to encode and decode the request parameters.
     * 
     * @return the charset
     */
    public String getCharacterEncoding() {
        return characterEncoding;
    }

    /**
     * Sets the charset to use to encode and decode the parameters for this request.
     * 
     * @param characterEncoding
     *            the charset name
     */
    public void setCharacterEncoding(String characterEncoding) {
        this.characterEncoding = characterEncoding;
    }

    /**
     * Returns the context specifit to the container (servlet container for instance).
     * 
     * @return the context
     */
    public ContainerRequestContext getContext() {
        return wrappedRequest.getContext();
    }

    /**
     * Returns the original request received from the client.
     * 
     * @return the original request
     */
    public IncomingRequest getOriginalRequest() {
        return wrappedRequest;
    }

    /**
     * Returns true if the target url is not one the provider application.
     * 
     * @return true if the url is on the provider
     */
    public boolean isExternal() {
        return external;
    }

    /**
     * Returns the base url as seen by the client.
     * 
     * @return the visible base url
     */
    public String getVisibleBaseUrl() {
        return visibleBaseUrl;
    }

}