hprose.server.HproseHttpService Maven / Gradle / Ivy

/**********************************************************\
|                                                          |
|                          hprose                          |
|                                                          |
| Official WebSite: http://www.hprose.com/                 |
|                   http://www.hprose.org/                 |
|                                                          |
\**********************************************************/
/**********************************************************\
 *                                                        *
 * HproseHttpService.java                                 *
 *                                                        *
 * hprose http service class for Java.                    *
 *                                                        *
 * LastModified: Apr 20, 2018                             *
 * Author: Ma Bingyao                   *
 *                                                        *
\**********************************************************/
package hprose.server;

import hprose.common.HproseContext;
import hprose.common.HproseMethods;
import hprose.io.ByteBufferStream;
import hprose.util.concurrent.Action;
import java.io.IOException;
import java.lang.reflect.Type;
import java.nio.ByteBuffer;
import java.util.HashMap;
import javax.servlet.AsyncContext;
import javax.servlet.AsyncEvent;
import javax.servlet.AsyncListener;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class HproseHttpService extends HproseService {
    private boolean crossDomainEnabled = false;
    private boolean p3pEnabled = false;
    private boolean getEnabled = true;
    private int asyncTimeout = 300000;
    private final HashMap origins = new HashMap();
    private final static ThreadLocal currentContext = new ThreadLocal();

    public static HttpContext getCurrentContext() {
        return currentContext.get();
    }

    @Override
    public HproseMethods getGlobalMethods() {
        if (globalMethods == null) {
            globalMethods = new HproseHttpMethods();
        }
        return globalMethods;
    }

    @Override
    public void setGlobalMethods(HproseMethods methods) {
        if (methods instanceof HproseHttpMethods) {
            this.globalMethods = methods;
        }
        else {
            throw new ClassCastException("methods must be a HproseHttpMethods instance");
        }
    }

    public boolean isCrossDomainEnabled() {
        return crossDomainEnabled;
    }

    public void setCrossDomainEnabled(boolean enabled) {
        crossDomainEnabled = enabled;
    }

    public boolean isP3pEnabled() {
        return p3pEnabled;
    }

    public void setP3pEnabled(boolean enabled) {
        p3pEnabled = enabled;
    }

    public boolean isGetEnabled() {
        return getEnabled;
    }

    public void setGetEnabled(boolean enabled) {
        getEnabled = enabled;
    }

    public int getAsyncTimeout() {
        return asyncTimeout;
    }

    public void setAsyncTimeout(int asyncTimeout) {
        this.asyncTimeout = asyncTimeout;
    }

    public void addAccessControlAllowOrigin(String origin) {
        origins.put(origin, true);
    }

    public void removeAccessControlAllowOrigin(String origin) {
        origins.remove(origin);
    }

    @Override
    protected Object[] fixArguments(Type[] argumentTypes, Object[] arguments, ServiceContext context) {
        int count = arguments.length;
        HttpContext httpContext = (HttpContext)context;
        if (argumentTypes.length != count) {
            Object[] args = new Object[argumentTypes.length];
            System.arraycopy(arguments, 0, args, 0, count);
            Class argType = (Class) argumentTypes[count];
            if (argType.equals(HproseContext.class) || argType.equals(ServiceContext.class)) {
                args[count] = context;
            }
            else if (argType.equals(HttpContext.class)) {
                args[count] = httpContext;
            }
            else if (argType.equals(HttpServletRequest.class)) {
                args[count] = httpContext.getRequest();
            }
            else if (argType.equals(HttpServletResponse.class)) {
                args[count] = httpContext.getResponse();
            }
            else if (argType.equals(HttpSession.class)) {
                args[count] = httpContext.getSession();
            }
            else if (argType.equals(ServletContext.class)) {
                args[count] = httpContext.getApplication();
            }
            else if (argType.equals(ServletConfig.class)) {
                args[count] = httpContext.getConfig();
            }
            return args;
        }
        return arguments;
    }

    protected void sendHeader(HttpContext httpContext) {
        if (event != null && HproseHttpServiceEvent.class.isInstance(event)) {
            ((HproseHttpServiceEvent)event).onSendHeader(httpContext);
        }
        HttpServletRequest request = httpContext.getRequest();
        HttpServletResponse response = httpContext.getResponse();
        response.setContentType("text/plain");
        if (p3pEnabled) {
            response.setHeader("P3P", "CP=\"CAO DSP COR CUR ADM DEV TAI PSA PSD " +
                                      "IVAi IVDi CONi TELo OTPi OUR DELi SAMi " +
                                      "OTRi UNRi PUBi IND PHY ONL UNI PUR FIN " +
                                      "COM NAV INT DEM CNT STA POL HEA PRE GOV\"");
        }
        if (crossDomainEnabled) {
            String origin = request.getHeader("Origin");
            if (origin != null && !origin.equals("null")) {
                if (origins.isEmpty() || origins.containsKey(origin)) {
                    response.setHeader("Access-Control-Allow-Origin", origin);
                    response.setHeader("Access-Control-Allow-Credentials", "true");
                }
            }
            else {
                response.setHeader("Access-Control-Allow-Origin", "*");
            }
        }
    }

    public void handle(HttpContext httpContext) {
        handle(httpContext, null);
    }

    public void handle(HttpContext httpContext, HproseHttpMethods methods) {
        sendHeader(httpContext);
        String method = httpContext.getRequest().getMethod();
        if (method.equals("GET")) {
            if (getEnabled) {
                ByteBufferStream ostream = null;
                try {
                    httpContext.setMethods(methods);
                    ostream = doFunctionList(httpContext);
                    httpContext.getResponse().setContentLength(ostream.available());
                    ostream.writeTo(httpContext.getResponse().getOutputStream());
                }
                catch (Throwable ex) {
                    fireErrorEvent(ex, httpContext);
                }
                finally {
                    if (ostream != null) {
                        ostream.close();
                    }
                }
            }
            else {
                try {
                    httpContext.getResponse().sendError(HttpServletResponse.SC_FORBIDDEN);
                }
                catch (IOException ex) {
                    fireErrorEvent(ex, httpContext);
                }
            }
        }
        else if (method.equals("POST")) {
            if (httpContext.getRequest().isAsyncSupported()) {
                asyncHandle(httpContext, methods);
            }
            else {
                syncHandle(httpContext, methods);
            }
        }
    }

    @SuppressWarnings("unchecked")
    private void asyncHandle(final HttpContext httpContext, final HproseHttpMethods methods) {
        final AsyncContext async = httpContext.getRequest().startAsync();
        async.setTimeout(asyncTimeout);
        async.addListener(new AsyncListener() {
            public void onComplete(AsyncEvent ae) throws IOException {
            }
            public void onTimeout(AsyncEvent ae) throws IOException {
                ((HttpServletResponse)ae.getSuppliedResponse()).sendError(HttpServletResponse.SC_REQUEST_TIMEOUT);
            }
            public void onError(AsyncEvent ae) throws IOException {
            }
            public void onStartAsync(AsyncEvent ae) throws IOException {
            }
        });
        async.start(new Runnable() {
            public void run() {
                final ByteBufferStream istream = new ByteBufferStream();
                try {
                    istream.readFrom(async.getRequest().getInputStream());
                }
                catch (Throwable e) {
                    fireErrorEvent(e, httpContext);
                    istream.close();
                    async.complete();
                    return;
                }
                currentContext.set(httpContext);
                handle(istream.buffer, methods, httpContext).then(new Action() {
                    public void call(ByteBuffer value) throws Throwable {
                        ByteBufferStream ostream = new ByteBufferStream(value);
                        try {
                            async.getResponse().setContentLength(ostream.available());
                            ostream.writeTo(async.getResponse().getOutputStream());
                        }
                        finally {
                            ostream.close();
                        }
                    }
                }).catchError(new Action() {
                    public void call(Throwable e) throws Throwable {
                        fireErrorEvent(e, httpContext);
                    }
                }).whenComplete(new Runnable() {
                    public void run() {
                        currentContext.remove();
                        istream.close();
                        async.complete();
                    }
                });
            }
        });
    }

    @SuppressWarnings("unchecked")
    private void syncHandle(final HttpContext httpContext, HproseHttpMethods methods) {
        final ByteBufferStream istream = new ByteBufferStream();
        try {
            istream.readFrom(httpContext.getRequest().getInputStream());
        }
        catch (Throwable e) {
            fireErrorEvent(e, httpContext);
            istream.close();
            return;
        }
        currentContext.set(httpContext);
        handle(istream.buffer, methods, httpContext).then(new Action() {
            public void call(ByteBuffer value) throws Throwable {
                ByteBufferStream ostream = new ByteBufferStream(value);
                try {
                    httpContext.getResponse().setContentLength(ostream.available());
                    ostream.writeTo(httpContext.getResponse().getOutputStream());
                }
                finally {
                    ostream.close();
                }
            }
        }).catchError(new Action() {
            public void call(Throwable e) throws Throwable {
                fireErrorEvent(e, httpContext);
            }
        }).whenComplete(new Runnable() {
            public void run() {
                currentContext.remove();
                istream.close();
            }
        });
    }
}