| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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.apache.asyncweb.client.codec; |
| |
| import java.io.IOException; |
| import java.net.URL; |
| import java.util.concurrent.Executors; |
| import java.util.concurrent.ScheduledExecutorService; |
| import java.util.concurrent.ScheduledFuture; |
| import java.util.concurrent.TimeUnit; |
| import java.util.concurrent.TimeoutException; |
| |
| import org.apache.asyncweb.client.AsyncHttpClient; |
| import org.apache.asyncweb.client.AsyncHttpClientCallback; |
| import org.apache.asyncweb.client.auth.AuthChallengeParser; |
| import org.apache.asyncweb.client.auth.AuthPolicy; |
| import org.apache.asyncweb.client.auth.AuthScheme; |
| import org.apache.asyncweb.client.auth.AuthState; |
| import org.apache.asyncweb.client.util.DaemonThreadFactory; |
| import org.apache.asyncweb.client.util.MonitoringEvent; |
| import org.apache.asyncweb.client.util.NameValuePair; |
| import org.apache.mina.common.IoHandlerAdapter; |
| import org.apache.mina.common.IoSession; |
| |
| |
| /** |
| * The Class HttpIoHandler. Implements the MINA IoHandler interface as the primary |
| * event processor for the HTTP communication. |
| */ |
| public class HttpIoHandler extends IoHandlerAdapter { |
| |
| /** |
| * The Constant CURRENT_REQUEST. |
| */ |
| public static final String CURRENT_REQUEST = "CURRENT_REQUEST"; |
| |
| /** |
| * The Constant CURRENT_RESPONSE. |
| */ |
| public static final String CURRENT_RESPONSE = "CURRENT_RESPONSE"; |
| |
| /** |
| * The Constant REQUEST_OUTSTANDING that indicates a request is outstanding |
| * on the session and no response has been received nor an exception |
| * occurred. |
| */ |
| public static final String REQUEST_OUTSTANDING = "REQUEST_OUTSTANDING"; |
| |
| /** |
| * Indicates whether the request is getting closed due to problems. |
| */ |
| public static final String CLOSE_PENDING = "CLOSE_PENDING"; |
| |
| /** |
| * The Constant for the proxy connect status. |
| */ |
| public static final String PROXY_CONNECT_IN_PROGRESS = "PROXY_CONNECT_IN_PROGRESS"; |
| |
| /** |
| * The Constant CONNECTION_CLOSE. |
| */ |
| public static final String CONNECTION_CLOSE = "close"; |
| |
| /** |
| * The scheduler service to handle timeouts. |
| */ |
| private final ScheduledExecutorService scheduler; |
| |
| /** |
| * The session cache used for reusable connections |
| */ |
| private SessionCache sessionCache; |
| |
| /** |
| * Instantiates a new HttpIoHandler with a new a single-threaded executor. |
| */ |
| public HttpIoHandler() { |
| this(Executors.newSingleThreadScheduledExecutor(new DaemonThreadFactory())); |
| } |
| |
| /** |
| * Instantiates a new HttpIoHandler with the supplied scheduler. It is the |
| * caller's responsibility to dispose of the scheduler. |
| * |
| * @param scheduler the scheduler to use to track timeouts |
| */ |
| public HttpIoHandler(ScheduledExecutorService scheduler) { |
| this.scheduler = scheduler; |
| } |
| |
| /** |
| * Set the session cache that should be used for |
| * connection reuse. |
| * |
| * @param cache The new session cache. If null, this will disable |
| * future connection reuse. |
| */ |
| public void setSessionCache(SessionCache cache) { |
| sessionCache = cache; |
| } |
| |
| /** |
| * Retrieve the session cache used for storing |
| * connections for reuse. |
| * |
| * @return The current session cache for the client. |
| */ |
| public SessionCache getSessionCache() { |
| return sessionCache; |
| } |
| |
| /** |
| * Stub for handling sessionOpened events. |
| * |
| * @see org.apache.mina.common.IoHandlerAdapter#sessionOpened(org.apache.mina.common.IoSession) |
| */ |
| public void sessionOpened(IoSession ioSession) throws Exception { |
| } |
| |
| /** |
| * Handler for receiving a response from a remote server. |
| * |
| * @param ioSession the {@link org.apache.mina.common.IoSession} representing the connection to the server. |
| * @param object the {@link HttpResponseMessage} object |
| * @see org.apache.mina.common.IoHandlerAdapter#messageReceived(org.apache.mina.common.IoSession,java.lang.Object) |
| */ |
| public void messageReceived(IoSession ioSession, Object object) throws Exception { |
| // clear the request outstanding flag on the session |
| ioSession.removeAttribute(REQUEST_OUTSTANDING); |
| |
| HttpResponseMessage response = (HttpResponseMessage) object; |
| |
| HttpRequestMessage request = (HttpRequestMessage) ioSession.getAttribute(CURRENT_REQUEST); |
| |
| AsyncHttpClient client = (AsyncHttpClient) ioSession.getAttachment(); |
| |
| //Check if we are to handle redirects |
| if ((response.getStatusCode() == 301 |
| || response.getStatusCode() == 302 |
| || response.getStatusCode() == 307) |
| && request.isFollowRedirects()) |
| { |
| |
| // notify any interesting parties that this is starting |
| client.notifyMonitoringListeners(MonitoringEvent.REQUEST_REDIRECTED, request); |
| //Change the request url to the redirect |
| request.setUrl(new URL(response.getLocation())); |
| // if we're redirected via 30x, the request method should be reset to GET |
| if (!request.getRequestMethod().equals(HttpRequestMessage.REQUEST_GET)) { |
| request.setRequestMethod(HttpRequestMessage.REQUEST_GET); |
| } |
| // we also need to clear out the parameters and the content |
| request.clearAllParameters(); |
| request.clearContent(); |
| // make sure to add the cookies from the response |
| request.addCookies(response.getCookies()); |
| |
| //Send the redirect |
| client.sendRequest(request); |
| |
| // if we've been provided with a cache, put this session into |
| // the cache. |
| SessionCache cache = getSessionCache(); |
| if (cache != null && !HttpDecoder.CLOSE.equals(response.getConnection())) { |
| // cache the session before we return |
| cache.cacheSession(ioSession); |
| } |
| return; |
| } |
| |
| //Check if we have authentication |
| if (response.getChallenges().size() > 0) { |
| // notify any interesting parties that this is starting |
| client.notifyMonitoringListeners(MonitoringEvent.REQUEST_CHALLENGED, request); |
| for (NameValuePair nvp : response.getChallenges()) { |
| AuthState state = request.getAuthState(); |
| if (state == null) { |
| String id = AuthChallengeParser.extractScheme(nvp.getValue()); |
| AuthScheme authScheme = AuthPolicy.getAuthScheme(id); |
| state = new AuthState(); |
| state.setAuthScheme(authScheme); |
| authScheme.processChallenge(nvp.getValue()); |
| request.setAuthState(state); |
| } |
| } |
| |
| //Authenticate |
| int authCount = request.getAuthCount() + 1; |
| if (authCount <= 3) { |
| // if we've been provided with a cache, put this session into |
| // the cache. |
| SessionCache cache = getSessionCache(); |
| if (cache != null && !HttpDecoder.CLOSE.equals(response.getConnection())) { |
| // cache the session before we return |
| cache.cacheSession(ioSession); |
| } |
| |
| // make sure to add the cookies from the response |
| request.addCookies(response.getCookies()); |
| request.setAuthCount(authCount); |
| |
| client.sendRequest(request); |
| |
| return; |
| } |
| } |
| |
| cancelTasks(request); |
| |
| // complete the future which will also fire the callback |
| ResponseFuture result = request.getResponseFuture(); |
| result.set(response); |
| |
| // notify any interesting parties that this is starting |
| client.notifyMonitoringListeners(MonitoringEvent.REQUEST_COMPLETED, request); |
| |
| // if we've been provided with a cache, put this session into |
| // the cache. |
| SessionCache cache = getSessionCache(); |
| if (cache != null && !HttpDecoder.CLOSE.equals(response.getConnection())) { |
| // cache the session before we return |
| cache.cacheSession(ioSession); |
| } |
| } |
| |
| /** |
| * Handler for receiving a notification that an Exception occurred in the communication with the server |
| * |
| * @param ioSession the {@link org.apache.mina.common.IoSession} representing the connection to the server. |
| * @param throwable the {@link java.lang.Throwable} object representing the exception that occurred |
| * @see org.apache.mina.common.IoHandlerAdapter#exceptionCaught(org.apache.mina.common.IoSession,java.lang.Throwable) |
| */ |
| public void exceptionCaught(IoSession ioSession, Throwable throwable) throws Exception { |
| // mark the session as closing so it won't be used |
| ioSession.setAttribute(CLOSE_PENDING); |
| |
| // clear the request outstanding flag on the session if set |
| ioSession.removeAttribute(REQUEST_OUTSTANDING); |
| |
| //Clean up if any in-proccess decoding was occurring |
| ioSession.removeAttribute(CURRENT_RESPONSE); |
| |
| HttpRequestMessage request = (HttpRequestMessage) ioSession.getAttribute(CURRENT_REQUEST); |
| cancelTasks(request); |
| |
| // complete the future which will also fire the callback |
| ResponseFuture result = request.getResponseFuture(); |
| result.setException(throwable); |
| |
| AsyncHttpClient client = (AsyncHttpClient) ioSession.getAttachment(); |
| // notify any interesting parties that this is starting |
| client.notifyMonitoringListeners(MonitoringEvent.REQUEST_FAILED, request); |
| |
| //Exception is bad, so just close it up |
| ioSession.close(); |
| } |
| |
| /** |
| * Handler for notifying that a connection was closed to the remote server. |
| * |
| * @param ioSession the {@link org.apache.mina.common.IoSession} representing the connection to the server. |
| * @see org.apache.mina.common.IoHandlerAdapter#sessionClosed(org.apache.mina.common.IoSession) |
| */ |
| public void sessionClosed(IoSession ioSession) throws Exception { |
| // clear and get the request outstanding flag on the connection |
| Object requestOutstanding = ioSession.removeAttribute(REQUEST_OUTSTANDING); |
| |
| //Clean up if any in-proccess decoding was occurring |
| ioSession.removeAttribute(CURRENT_RESPONSE); |
| |
| // if we've been provided with a cache, remove this session from |
| // the cache. |
| SessionCache cache = getSessionCache(); |
| if (cache != null) { |
| // cache the session before we return |
| cache.removeSession(ioSession); |
| } |
| HttpRequestMessage request = (HttpRequestMessage) ioSession.getAttribute(CURRENT_REQUEST); |
| cancelTasks(request); |
| |
| // if the session is closing while the request is outstanding, it means |
| // the connection is closing prematurely; we need to cause an exception |
| if (requestOutstanding != null) { |
| request.getResponseFuture().setException(new IOException("connection was closed prematurely")); |
| } else { |
| // normal connection close after connection idle |
| AsyncHttpClientCallback callback = request.getCallback(); |
| if (callback != null) { |
| callback.onClosed(); |
| } |
| } |
| |
| AsyncHttpClient client = (AsyncHttpClient) ioSession.getAttachment(); |
| // notify any interesting parties that this is starting |
| client.notifyMonitoringListeners(MonitoringEvent.CONNECTION_CLOSED_BY_SERVER, request); |
| } |
| |
| /** |
| * Handler for notifying that a message was sent to a remote server. It is responsible for setting up the |
| * timeout for a response from the remote server. |
| * |
| * @param ioSession the {@link org.apache.mina.common.IoSession} representing the connection to the server. |
| * @param object the {@link HttpRequestMessage} object |
| * @see org.apache.mina.common.IoHandlerAdapter#messageSent(org.apache.mina.common.IoSession,java.lang.Object) |
| */ |
| public void messageSent(IoSession ioSession, Object object) throws Exception { |
| // indicate there is an outstanding request on the connection |
| ioSession.setAttribute(REQUEST_OUTSTANDING); |
| |
| HttpRequestMessage msg = (HttpRequestMessage) object; |
| |
| //Start the timeout timer now if a timeout is needed and there is not one already in effect for this request |
| if (msg.getTimeOut() > 0 && msg.getTimeoutHandle() == null) { |
| TimeoutTask task = new TimeoutTask(ioSession); |
| ScheduledFuture<?> handle = scheduler.schedule(task, msg.getTimeOut(), TimeUnit.MILLISECONDS); |
| msg.setTimeoutHandle(handle); |
| } |
| } |
| |
| /** |
| * Utility function to cancel a request timeout task. |
| * |
| * @param request the {@link HttpRequestMessage} request |
| */ |
| private void cancelTasks(HttpRequestMessage request) { |
| ScheduledFuture<?> handle = request.removeTimeoutHandle(); |
| if (handle != null) { |
| // cancel but don't interrupt |
| handle.cancel(false); |
| } |
| } |
| |
| /** |
| * The Class TimeoutTask. Subclass that encapsulates handler for timeouts for the scheduler. |
| */ |
| class TimeoutTask implements Runnable { |
| |
| /** |
| * The session object. |
| */ |
| private final IoSession sess; |
| |
| /** |
| * Instantiates a new timeout task. |
| * |
| * @param sess the {@link org.apache.mina.common.IoSession} representing the connection to the server. |
| */ |
| public TimeoutTask(IoSession sess) { |
| this.sess = sess; |
| } |
| |
| /** |
| * The running task which handles timing out the connection. |
| * |
| * @see java.lang.Runnable#run() |
| */ |
| public void run() { |
| // first, indicate that the request has timed out |
| sess.setAttribute(CLOSE_PENDING); |
| |
| // clear the request outstanding flag on the session |
| sess.removeAttribute(REQUEST_OUTSTANDING); |
| |
| // complete the future which will also fire the callback |
| HttpRequestMessage request = (HttpRequestMessage)sess.getAttribute(CURRENT_REQUEST); |
| // make sure to remove the timeout handle |
| request.setTimeoutHandle(null); |
| |
| ResponseFuture result = request.getResponseFuture(); |
| result.setException(new TimeoutException()); |
| |
| AsyncHttpClient client = (AsyncHttpClient) sess.getAttachment(); |
| // notify any interesting parties that this is starting |
| client.notifyMonitoringListeners(MonitoringEvent.REQUEST_TIMEOUT, request); |
| |
| //Close the session, its no good since the server is timing out |
| sess.close(); |
| } |
| |
| } |
| |
| |
| } |
