httplite/core/src/main/java/org/apache/felix/httplite/server/Connection.java

/*
 * 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.felix.httplite.server;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

import javax.servlet.ServletException;

import org.apache.felix.httplite.osgi.Logger;
import org.apache.felix.httplite.osgi.ServiceRegistrationHandler;
import org.apache.felix.httplite.osgi.ServiceRegistrationResolver;
import org.apache.felix.httplite.servlet.ConcreteServletInputStream;
import org.apache.felix.httplite.servlet.HttpConstants;
import org.apache.felix.httplite.servlet.HttpServletRequestImpl;
import org.apache.felix.httplite.servlet.HttpServletResponseImpl;

/**
 * This class represents an accepted connection between the server and
 * a client. It supports persistent connections for both HTTP 1.0 and 1.1
 * clients. A given persistent connection is limited in the number of
 * consecutive requests it is allowed to make before having its connection
 * closed as well as after a period of inactivity.
**/
public class Connection
{
    /**
     * Connection timeout
     */
    public static final int DEFAULT_CONNECTION_TIMEOUT = 10000;
    /**
     * Requests per request
     */
    public static final int DEFAULT_CONNECTION_REQUESTLIMIT = 50;

    private final Socket m_socket;
    private ConcreteServletInputStream m_is;
    private OutputStream m_os;
    private int m_requestCount = 0;
    private final int m_requestLimit;
    private final ServiceRegistrationResolver m_resolver;
    private final Logger m_logger;

    /**
     * Constructs a connection with a default inactivity timeout and request limit.
     *     
     * @param socket Socket connection
     * @param resolver a resolver to get http request/response and handler.
     * @param logger Logger
     * @throws IOException If any I/O error occurs.
     */
    public Connection(final Socket socket, final ServiceRegistrationResolver resolver, final Logger logger) throws IOException
    {
        this(socket, DEFAULT_CONNECTION_TIMEOUT, DEFAULT_CONNECTION_REQUESTLIMIT,
            resolver, logger);
    }

    /**
     * Constructs a connection with the specified inactivity timeout and request limit.
     * @param socket The client socket.
     * @param timeout The inactivity timeout of the connection in milliseconds.
     * @param requestLimit The maximum number of consecutive requests.
     * @param resolver resolves a request URI to a client or servlet registration via the HTTP Service.
     * @param logger logger instance.
     * @throws java.io.IOException If any I/O error occurs.
     */
    public Connection(final Socket socket, final int timeout, final int requestLimit, final ServiceRegistrationResolver resolver, final Logger logger) throws IOException
    {
        m_socket = socket;
        m_resolver = resolver;
        m_logger = logger;
        m_socket.setSoTimeout(timeout);
        m_socket.setTcpNoDelay(true);
        m_requestLimit = requestLimit;
        try
        {
            m_is = new ConcreteServletInputStream(new BufferedInputStream(
                m_socket.getInputStream()));
            m_os = new BufferedOutputStream(m_socket.getOutputStream());
        }
        catch (IOException ex)
        {
            // Make sure we close any opened socket/streams.
            try
            {
                m_socket.close();
            }
            catch (IOException ex2)
            {
                m_logger.log(Logger.LOG_ERROR, "Error closing socket.", ex);
            }
            if (m_is != null)
            {
                try
                {
                    m_is.close();
                }
                catch (IOException ex2)
                {
                    m_logger.log(Logger.LOG_ERROR, "Error closing socket input stream.",
                        ex2);
                }
            }
            if (m_os != null)
            {
                try
                {
                    m_os.close();
                }
                catch (IOException ex2)
                {
                    m_logger.log(Logger.LOG_ERROR, "Error closing socket output stream.",
                        ex2);
                }
            }
            throw ex;
        }
    }

    /**
     * Performs the actual servicing of the connection and its subsequent requests.
     * This method will be called by threads in the thread pool. This method
     * typically exits when the connection is closed due to either an explicit
     * connection close, the inactivity timeout expires, the maximum request
     * limit was reached, or an I/O error occurred. When this method returns,
     * the associated socket will be closed, regardless of whether or not an
     * expection was thrown.
     * @throws java.net.SocketTimeoutException If the inactivity timeout expired
     *         while trying to read from the socket.
     * @throws java.io.IOException If any I/O error occurs.
     * @throws ServletException on servlet errors
    **/
    public void process() throws IOException, ServletException
    {
        HttpServletRequestImpl request = m_resolver.getServletRequest(m_socket);
        HttpServletResponseImpl response = m_resolver.getServletResponse(m_os);

        try
        {
            // Loop until we close the connection.
            boolean close = false;
            while (!close)
            {
                // Read the next request.
                try
                {
                    request.parseRequestLine(m_is);
                }
                catch (IOException e)
                {
                    m_logger.log(
                        Logger.LOG_ERROR,
                        "Error with request: " + request.toString() + ": "
                            + e.getMessage());
                    throw e;
                }
                m_requestCount++;

                // Keep track of whether we have failed or not,
                // because we still want to read the bytes to clear
                // the input stream so we can service more requests.
                boolean error = false;

                m_logger.log(Logger.LOG_DEBUG,
                    "Processing " + request.getRequestURI() + " (" + (m_requestLimit - m_requestCount)
                        + " remaining)");

                // If client is HTTP/1.1, then send continue message.
                if (request.getProtocol().equals(HttpConstants.HTTP11_VERSION))
                {
                    response.sendContinueResponse();
                }

                // Read the header lines of the request.
                request.parseHeader(m_is);

                // If we have an HTTP/1.0 request without the connection set to
                // keep-alive or we explicitly have a request to close the connection,
                // then set close flag to exit the loop rather than trying to read
                // more requests.
                String v = request.getHeader(HttpConstants.HEADER_CONNECTION);
                if ((request.getProtocol().equals(HttpConstants.HTTP10_VERSION) && ((v == null) || (!v.equalsIgnoreCase(HttpConstants.KEEPALIVE_CONNECTION))))
                    || ((v != null) && v.equalsIgnoreCase(HttpConstants.CLOSE_CONNECTION)))
                {
                    close = true;
                    response.setConnectionType("close");
                }
                // If we have serviced the maximum number of requests for
                // this connection, then set close flag so we exit the loop
                // and close the connection.
                else if (m_requestCount >= m_requestLimit)
                {
                    close = true;
                    response.setConnectionType("close");
                }

                // We do not support OPTIONS method so send
                // a "not implemented" error in that case.
                if (!HttpServletRequestImpl.isSupportedMethod(request.getMethod()))
                {
                    error = true;
                    response.setConnectionType(HttpConstants.CLOSE_CONNECTION);
                    response.sendNotImplementedResponse();
                }

                // Ignore if we have already failed, otherwise send error message
                // if an HTTP/1.1 client did not include HOST header.
                if (!error && request.getProtocol().equals(HttpConstants.HTTP11_VERSION)
                    && (request.getHeader(HttpConstants.HOST_HEADER) == null))
                {
                    error = true;
                    response.setConnectionType(HttpConstants.CLOSE_CONNECTION);
                    response.sendMissingHostResponse();
                }

                // Read in the request body.
                request.parseBody(m_is);

                // Only process the request if there was no error.
                if (!error)
                {
                    ServiceRegistrationHandler processor = m_resolver.getProcessor(
                        request, response, request.getRequestURI());

                    if (processor != null)
                    {
                        processor.handle(close);

                        m_logger.log(Logger.LOG_DEBUG, "Processed " + request.toString());

                        // TODO: Adding next line to make test cases pass, but not sure if it is correct
                        // and needs further investigation.
                        close = true;
                        continue;
                    }

                    close = true;
                    response.setConnectionType(HttpConstants.CLOSE_CONNECTION);
                    response.sendNotFoundResponse();
                }
            }
        }
        finally
        {
            try
            {
                m_is.close();
            }
            catch (IOException ex)
            {
                m_logger.log(Logger.LOG_ERROR, "Error closing socket input stream.", ex);
            }
            try
            {
                m_os.close();
            }
            catch (IOException ex)
            {
                m_logger.log(Logger.LOG_ERROR, "Error closing socket output stream.", ex);
            }
            try
            {
                m_socket.close();
            }
            catch (IOException ex)
            {
                m_logger.log(Logger.LOG_ERROR, "Error closing socket.", ex);
            }
        }
    }
}