passenger 2.2.15 → 3.0.0.pre1

data/ext/boost/thread/pthread/thread.hpp

@@ -1,339 +0,0 @@
-#ifndef BOOST_THREAD_THREAD_PTHREAD_HPP
-#define BOOST_THREAD_THREAD_PTHREAD_HPP
-// Copyright (C) 2001-2003
-// William E. Kempf
-// Copyright (C) 2007 Anthony Williams
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/utility.hpp>
-#include <boost/function.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <list>
-#include <memory>
-
-#include <pthread.h>
-#include <boost/optional.hpp>
-#include <boost/thread/detail/move.hpp>
-#include <boost/shared_ptr.hpp>
-#include "thread_data.hpp"
-#include <stdlib.h>
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4251)
-#endif
-
-namespace boost
-{
-    class thread;
-
-    namespace detail
-    {
-        class thread_id;
-    }
-    
-    namespace this_thread
-    {
-        BOOST_THREAD_DECL detail::thread_id get_id();
-    }
-    
-    namespace detail
-    {
-        class thread_id
-        {
-        private:
-            detail::thread_data_ptr thread_data;
-            
-            thread_id(detail::thread_data_ptr thread_data_):
-                thread_data(thread_data_)
-            {}
-            friend class boost::thread;
-            friend thread_id this_thread::get_id();
-        public:
-            thread_id():
-                thread_data()
-            {}
-            
-            bool operator==(const thread_id& y) const
-            {
-                return thread_data==y.thread_data;
-            }
-        
-            bool operator!=(const thread_id& y) const
-            {
-                return thread_data!=y.thread_data;
-            }
-        
-            bool operator<(const thread_id& y) const
-            {
-                return thread_data<y.thread_data;
-            }
-        
-            bool operator>(const thread_id& y) const
-            {
-                return y.thread_data<thread_data;
-            }
-        
-            bool operator<=(const thread_id& y) const
-            {
-                return !(y.thread_data<thread_data);
-            }
-        
-            bool operator>=(const thread_id& y) const
-            {
-                return !(thread_data<y.thread_data);
-            }
-
-            template<class charT, class traits>
-            friend std::basic_ostream<charT, traits>& 
-            operator<<(std::basic_ostream<charT, traits>& os, const thread_id& x)
-            {
-                if(x.thread_data)
-                {
-                    return os<<x.thread_data;
-                }
-                else
-                {
-                    return os<<"{Not-any-thread}";
-                }
-            }
-        };
-    }
-
-    struct xtime;
-    class BOOST_THREAD_DECL thread
-    {
-    private:
-        thread(thread&);
-        thread& operator=(thread&);
-
-        template<typename F>
-        struct thread_data:
-            detail::thread_data_base
-        {
-            F f;
-
-            thread_data(F f_):
-                f(f_)
-            {}
-            thread_data(detail::thread_move_t<F> f_):
-                f(f_)
-            {}
-            
-            void run()
-            {
-                f();
-            }
-        };
-        
-        mutable boost::mutex thread_info_mutex;
-        detail::thread_data_ptr thread_info;
-
-        explicit thread(detail::thread_data_ptr data);
-
-        detail::thread_data_ptr get_thread_info() const;
-        
-    protected:
-        template <class F>
-        void set_thread_main_function(F f)
-        {
-            thread_info = detail::thread_data_ptr(new thread_data<F>(f));
-        }
-        
-        void start_thread(unsigned int stack_size);
-        
-    public:
-        thread();
-        virtual ~thread();
-
-        template <class F>
-        explicit thread(F f, unsigned int stack_size = 0):
-            thread_info(new thread_data<F>(f))
-        {
-            start_thread(stack_size);
-        }
-        
-        template <class F>
-        thread(detail::thread_move_t<F> f, unsigned int stack_size = 0):
-            thread_info(new thread_data<F>(f))
-        {
-            start_thread(stack_size);
-        }
-
-        thread(detail::thread_move_t<thread> x);
-        thread& operator=(detail::thread_move_t<thread> x);
-        operator detail::thread_move_t<thread>();
-        detail::thread_move_t<thread> move();
-
-        void swap(thread& x);
-
-        typedef detail::thread_id id;
-        
-        pthread_t native_handle() const;
-        
-        id get_id() const;
-
-        bool joinable() const;
-        void join();
-        bool timed_join(const system_time& wait_until);
-
-        template<typename TimeDuration>
-        inline bool timed_join(TimeDuration const& rel_time)
-        {
-            return timed_join(get_system_time()+rel_time);
-        }
-        void detach();
-
-        static unsigned hardware_concurrency();
-
-        // backwards compatibility
-        bool operator==(const thread& other) const;
-        bool operator!=(const thread& other) const;
-
-        static void sleep(const system_time& xt);
-        static void yield();
-
-        // extensions
-        void interrupt();
-        bool interruption_requested() const;
-    };
-
-    inline detail::thread_move_t<thread> move(thread& x)
-    {
-        return x.move();
-    }
-    
-    inline detail::thread_move_t<thread> move(detail::thread_move_t<thread> x)
-    {
-        return x;
-    }
-
-
-    template<typename F>
-    struct thread::thread_data<boost::reference_wrapper<F> >:
-        detail::thread_data_base
-    {
-        F& f;
-        
-        thread_data(boost::reference_wrapper<F> f_):
-            f(f_)
-        {}
-        
-        void run()
-        {
-            f();
-        }
-    };
-
-    namespace this_thread
-    {
-        class BOOST_THREAD_DECL disable_interruption
-        {
-            disable_interruption(const disable_interruption&);
-            disable_interruption& operator=(const disable_interruption&);
-            
-            bool interruption_was_enabled;
-            friend class restore_interruption;
-        public:
-            disable_interruption();
-            ~disable_interruption();
-        };
-
-        class BOOST_THREAD_DECL restore_interruption
-        {
-            restore_interruption(const restore_interruption&);
-            restore_interruption& operator=(const restore_interruption&);
-        public:
-            explicit restore_interruption(disable_interruption& d);
-            ~restore_interruption();
-        };
-
-        BOOST_THREAD_DECL thread::id get_id();
-
-        BOOST_THREAD_DECL void interruption_point();
-        BOOST_THREAD_DECL bool interruption_enabled();
-        BOOST_THREAD_DECL bool interruption_requested();
-
-        inline void yield()
-        {
-            thread::yield();
-        }
-        
-        template<typename TimeDuration>
-        inline void sleep(TimeDuration const& rel_time)
-        {
-            thread::sleep(get_system_time()+rel_time);
-        }
-    }
-
-    namespace detail
-    {
-        struct thread_exit_function_base
-        {
-            virtual ~thread_exit_function_base()
-            {}
-            virtual void operator()() const=0;
-        };
-        
-        template<typename F>
-        struct thread_exit_function:
-            thread_exit_function_base
-        {
-            F f;
-            
-            thread_exit_function(F f_):
-                f(f_)
-            {}
-            
-            void operator()() const
-            {
-                f();
-            }
-        };
-        
-        BOOST_THREAD_DECL void add_thread_exit_function(thread_exit_function_base*);
-    }
-    
-    namespace this_thread
-    {
-        template<typename F>
-        inline void at_thread_exit(F f)
-        {
-            detail::thread_exit_function_base* const thread_exit_func=new detail::thread_exit_function<F>(f);
-            detail::add_thread_exit_function(thread_exit_func);
-        }
-    }
-
-    class BOOST_THREAD_DECL thread_group
-    {
-    public:
-        thread_group();
-        ~thread_group();
-
-        thread* create_thread(const function0<void>& threadfunc);
-        void add_thread(thread* thrd);
-        void remove_thread(thread* thrd);
-        void join_all();
-        void interrupt_all();
-        size_t size() const;
-
-    private:
-        thread_group(thread_group&);
-        void operator=(thread_group&);
-        
-        std::list<thread*> m_threads;
-        mutex m_mutex;
-    };
-} // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-
-#endif

data/ext/boost/thread/pthread/tss.hpp

@@ -1,103 +0,0 @@
-#ifndef BOOST_THREAD_PTHREAD_TSS_HPP
-#define BOOST_THREAD_PTHREAD_TSS_HPP
-
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-// (C) Copyright 2007 Anthony Williams
-
-#include <boost/thread/detail/config.hpp>
-#include <boost/shared_ptr.hpp>
-
-namespace boost
-{
-    namespace detail
-    {
-        struct tss_cleanup_function
-        {
-            virtual ~tss_cleanup_function()
-            {}
-            
-            virtual void operator()(void* data)=0;
-        };
-        
-        BOOST_THREAD_DECL void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
-        BOOST_THREAD_DECL void* get_tss_data(void const* key);
-    }
-
-    template <typename T>
-    class thread_specific_ptr
-    {
-    private:
-        thread_specific_ptr(thread_specific_ptr&);
-        thread_specific_ptr& operator=(thread_specific_ptr&);
-
-        struct delete_data:
-            detail::tss_cleanup_function
-        {
-            void operator()(void* data)
-            {
-                delete static_cast<T*>(data);
-            }
-        };
-        
-        struct run_custom_cleanup_function:
-            detail::tss_cleanup_function
-        {
-            void (*cleanup_function)(T*);
-            
-            explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
-                cleanup_function(cleanup_function_)
-            {}
-            
-            void operator()(void* data)
-            {
-                cleanup_function(static_cast<T*>(data));
-            }
-        };
-
-
-        boost::shared_ptr<detail::tss_cleanup_function> cleanup;
-        
-    public:
-        thread_specific_ptr():
-            cleanup(new delete_data)
-        {}
-        explicit thread_specific_ptr(void (*func_)(T*)):
-            cleanup(new run_custom_cleanup_function(func_))
-        {}
-        ~thread_specific_ptr()
-        {
-            reset();
-        }
-
-        T* get() const
-        {
-            return static_cast<T*>(detail::get_tss_data(this));
-        }
-        T* operator->() const
-        {
-            return get();
-        }
-        T& operator*() const
-        {
-            return *get();
-        }
-        T* release()
-        {
-            T* const temp=get();
-            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,false);
-            return temp;
-        }
-        void reset(T* new_value=0)
-        {
-            T* const current_value=get();
-            if(current_value!=new_value)
-            {
-                detail::set_tss_data(this,cleanup,new_value,true);
-            }
-        }
-    };
-}
-
-#endif

data/ext/common/Application.h

@@ -1,511 +0,0 @@
-/*
- *  Phusion Passenger - http://www.modrails.com/
- *  Copyright (c) 2008, 2009 Phusion
- *
- *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in
- *  all copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- *  THE SOFTWARE.
- */
-#ifndef _PASSENGER_APPLICATION_H_
-#define _PASSENGER_APPLICATION_H_
-
-#include <boost/shared_ptr.hpp>
-#include <boost/function.hpp>
-#include <oxt/system_calls.hpp>
-#include <oxt/backtrace.hpp>
-#include <string>
-#include <vector>
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <netdb.h>
-#include <unistd.h>
-#include <errno.h>
-#include <ctime>
-#include <cstring>
-
-#include "MessageChannel.h"
-#include "Exceptions.h"
-#include "Logging.h"
-#include "Utils.h"
-
-namespace Passenger {
-
-using namespace std;
-using namespace boost;
-
-/**
- * Represents a single Ruby on Rails or Rack application instance.
- *
- * @ingroup Support
- */
-class Application {
-public:
-	class Session;
-	/** Convenient alias for Session smart pointer. */
-	typedef shared_ptr<Session> SessionPtr;
-	
-	/**
-	 * Represents the life time of a single request/response pair of a
-	 * Ruby on Rails or Rack application.
-	 *
-	 * Session is used to forward a single HTTP request to a Ruby on Rails/Rack
-	 * application. A Session has two communication channels: one for reading data
-	 * from the application, and one for writing data to the application.
-	 *
-	 * In general, a session object is to be used in the following manner:
-	 *
-	 *  -# Convert the HTTP request headers into a string, as expected by sendHeaders().
-	 *     Then send that string by calling sendHeaders().
-	 *  -# In case of a POST of PUT request, send the HTTP request body by calling
-	 *     sendBodyBlock(), possibly multiple times.
-	 *  -# Shutdown the writer channel since you're now done sending data.
-	 *  -# The HTTP response can now be read through the reader channel (getStream()).
-	 *  -# When the HTTP response has been read, the session must be closed.
-	 *     This is done by destroying the Session object.
-	 *
-	 * A usage example is shown in Application::connect(). 
-	 */
-	class Session {
-	public:
-		/**
-		 * Implementing classes might throw arbitrary exceptions.
-		 */
-		virtual ~Session() {}
-		
-		/**
-		 * Send HTTP request headers to the application. The HTTP headers must be
-		 * converted into CGI headers, and then encoded into a string that matches this grammar:
-		 *
-		   @verbatim
-		   headers ::= header*
-		   header ::= name NUL value NUL
-		   name ::= notnull+
-		   value ::= notnull+
-		   notnull ::= "\x01" | "\x02" | "\x02" | ... | "\xFF"
-		   NUL = "\x00"
-		   @endverbatim
-		 *
-		 * This method should be the first one to be called during the lifetime of a Session
-		 * object. Otherwise strange things may happen.
-		 *
-		 * @param headers The HTTP request headers, converted into CGI headers and encoded as
-		 *                a string, according to the description.
-		 * @param size The size, in bytes, of <tt>headers</tt>.
-		 * @pre headers != NULL
-		 * @throws IOException The writer channel has already been closed.
-		 * @throws SystemException Something went wrong during writing.
-		 * @throws boost::thread_interrupted
-		 */
-		virtual void sendHeaders(const char *headers, unsigned int size) {
-			TRACE_POINT();
-			int stream = getStream();
-			if (stream == -1) {
-				throw IOException("Cannot write headers to the request handler "
-					"because the writer stream has already been closed.");
-			}
-			try {
-				MessageChannel(stream).writeScalar(headers, size);
-			} catch (SystemException &e) {
-				e.setBriefMessage("An error occured while writing headers "
-					"to the request handler");
-				throw;
-			}
-		}
-		
-		/**
-		 * Convenience shortcut for sendHeaders(const char *, unsigned int)
-		 * @param headers
-		 * @throws IOException The writer channel has already been closed.
-		 * @throws SystemException Something went wrong during writing.
-		 * @throws boost::thread_interrupted
-		 */
-		virtual void sendHeaders(const string &headers) {
-			sendHeaders(headers.c_str(), headers.size());
-		}
-		
-		/**
-		 * Send a chunk of HTTP request body data to the application.
-		 * You can call this method as many times as is required to transfer
-		 * the entire HTTP request body.
-		 *
-		 * This method should only be called after a sendHeaders(). Otherwise
-		 * strange things may happen.
-		 *
-		 * @param block A block of HTTP request body data to send.
-		 * @param size The size, in bytes, of <tt>block</tt>.
-		 * @throws IOException The writer channel has already been closed.
-		 * @throws SystemException Something went wrong during writing.
-		 * @throws boost::thread_interrupted
-		 */
-		virtual void sendBodyBlock(const char *block, unsigned int size) {
-			TRACE_POINT();
-			int stream = getStream();
-			if (stream == -1) {
-				throw IOException("Cannot write request body block to the "
-					"request handler because the writer stream has "
-					"already been closed.");
-			}
-			try {
-				MessageChannel(stream).writeRaw(block, size);
-			} catch (SystemException &e) {
-				e.setBriefMessage("An error occured while sending the "
-					"request body to the request handler");
-				throw;
-			}
-		}
-		
-		/**
-		 * Get the I/O stream's file descriptor. This steam is full-duplex,
-		 * and will be automatically closed upon Session's destruction,
-		 * unless discardStream() is called.
-		 *
-		 * @pre The stream has not been fully closed.
-		 */
-		virtual int getStream() const = 0;
-		
-		/**
-		 * Set the timeout value for reading data from the I/O stream.
-		 * If no data can be read within the timeout period, then the
-		 * read call will fail with error EAGAIN or EWOULDBLOCK.
-		 *
-		 * @param msec The timeout, in milliseconds. If 0 is given,
-		 *             there will be no timeout.
-		 * @throws SystemException Cannot set the timeout.
-		 */
-		virtual void setReaderTimeout(unsigned int msec) = 0;
-		
-		/**
-		 * Set the timeout value for writing data from the I/O stream.
-		 * If no data can be written within the timeout period, then the
-		 * write call will fail with error EAGAIN or EWOULDBLOCK.
-		 *
-		 * @param msec The timeout, in milliseconds. If 0 is given,
-		 *             there will be no timeout.
-		 * @throws SystemException Cannot set the timeout.
-		 */
-		virtual void setWriterTimeout(unsigned int msec) = 0;
-		
-		/**
-		 * Indicate that we don't want to read data anymore from the I/O stream.
-		 * Calling this method after closeStream() is called will have no effect.
-		 *
-		 * @throws SystemException Something went wrong.
-		 * @throws boost::thread_interrupted
-		 */
-		virtual void shutdownReader() = 0;
-		
-		/**
-		 * Indicate that we don't want to write data anymore to the I/O stream.
-		 * Calling this method after closeStream() is called will have no effect.
-		 *
-		 * @throws SystemException Something went wrong.
-		 * @throws boost::thread_interrupted
-		 */
-		virtual void shutdownWriter() = 0;
-		
-		/**
-		 * Close the I/O stream.
-		 *
-		 * @throws SystemException Something went wrong.
-		 * @throws boost::thread_interrupted
-		 */
-		virtual void closeStream() = 0;
-		
-		/**
-		 * Discard the I/O stream's file descriptor, so that Session won't automatically
-		 * closed it upon Session's destruction.
-		 */
-		virtual void discardStream() = 0;
-		
-		/**
-		 * Get the process ID of the application instance that belongs to this session.
-		 */
-		virtual pid_t getPid() const = 0;
-	};
-
-private:
-	/**
-	 * A "standard" implementation of Session.
-	 */
-	class StandardSession: public Session {
-	protected:
-		function<void()> closeCallback;
-		int fd;
-		pid_t pid;
-		
-	public:
-		StandardSession(pid_t pid,
-		                const function<void()> &closeCallback,
-		                int fd) {
-			this->pid = pid;
-			this->closeCallback = closeCallback;
-			this->fd = fd;
-		}
-	
-		virtual ~StandardSession() {
-			TRACE_POINT();
-			closeStream();
-			closeCallback();
-		}
-		
-		virtual int getStream() const {
-			return fd;
-		}
-		
-		virtual void setReaderTimeout(unsigned int msec) {
-			MessageChannel(fd).setReadTimeout(msec);
-		}
-		
-		virtual void setWriterTimeout(unsigned int msec) {
-			MessageChannel(fd).setWriteTimeout(msec);
-		}
-		
-		virtual void shutdownReader() {
-			TRACE_POINT();
-			if (fd != -1) {
-				int ret = syscalls::shutdown(fd, SHUT_RD);
-				if (ret == -1) {
-					throw SystemException("Cannot shutdown the reader stream",
-						errno);
-				}
-			}
-		}
-		
-		virtual void shutdownWriter() {
-			TRACE_POINT();
-			if (fd != -1) {
-				int ret = syscalls::shutdown(fd, SHUT_WR);
-				if (ret == -1) {
-					throw SystemException("Cannot shutdown the writer stream",
-						errno);
-				}
-			}
-		}
-		
-		virtual void closeStream() {
-			TRACE_POINT();
-			if (fd != -1) {
-				int ret = syscalls::close(fd);
-				fd = -1;
-				if (ret == -1) {
-					if (errno == EIO) {
-						throw SystemException("A write operation on the session stream failed",
-							errno);
-					} else {
-						throw SystemException("Cannot close the session stream",
-							errno);
-					}
-				}
-			}
-		}
-		
-		virtual void discardStream() {
-			fd = -1;
-		}
-		
-		virtual pid_t getPid() const {
-			return pid;
-		}
-	};
-
-	string appRoot;
-	pid_t pid;
-	string listenSocketName;
-	string listenSocketType;
-	int ownerPipe;
-	
-	SessionPtr connectToUnixServer(const function<void()> &closeCallback) const {
-		TRACE_POINT();
-		int fd = Passenger::connectToUnixServer(listenSocketName.c_str());
-		return ptr(new StandardSession(pid, closeCallback, fd));
-	}
-	
-	SessionPtr connectToTcpServer(const function<void()> &closeCallback) const {
-		TRACE_POINT();
-		int fd, ret;
-		vector<string> args;
-		
-		split(listenSocketName, ':', args);
-		if (args.size() != 2 || atoi(args[1]) == 0) {
-			throw IOException("Invalid TCP/IP address '" + listenSocketName + "'");
-		}
-		
-		struct addrinfo hints, *res;
-		
-		memset(&hints, 0, sizeof(hints));
-		hints.ai_family = PF_INET;
-		hints.ai_socktype = SOCK_STREAM;
-		ret = getaddrinfo(args[0].c_str(), args[1].c_str(), &hints, &res);
-		if (ret != 0) {
-			int e = errno;
-			throw IOException("Cannot resolve address '" + listenSocketName +
-				"': " + gai_strerror(e));
-		}
-		
-		do {
-			fd = socket(PF_INET, SOCK_STREAM, 0);
-		} while (fd == -1 && errno == EINTR);
-		if (fd == -1) {
-			freeaddrinfo(res);
-			throw SystemException("Cannot create a new unconnected TCP socket", errno);
-		}
-		
-		do {
-			ret = ::connect(fd, res->ai_addr, res->ai_addrlen);
-		} while (ret == -1 && errno == EINTR);
-		freeaddrinfo(res);
-		if (ret == -1) {
-			int e = errno;
-			string message("Cannot connect to TCP server '");
-			message.append(listenSocketName);
-			message.append("'");
-			do {
-				ret = close(fd);
-			} while (ret == -1 && errno == EINTR);
-			throw SystemException(message, e);
-		}
-		
-		return ptr(new StandardSession(pid, closeCallback, fd));
-	}
-
-public:
-	/**
-	 * Construct a new Application object.
-	 *
-	 * @param theAppRoot The application root of an application. In case of a Rails application,
-	 *             this is the folder that contains 'app/', 'public/', 'config/', etc.
-	 *             This must be a valid directory, but the path does not have to be absolute.
-	 * @param pid The process ID of this application instance.
-	 * @param listenSocketName The name of the listener socket of this application instance.
-	 * @param listenSocketType The type of the listener socket, e.g. "unix" for Unix
-	 *                         domain sockets.
-	 * @param ownerPipe The owner pipe of this application instance.
-	 * @post getAppRoot() == theAppRoot && getPid() == pid
-	 */
-	Application(const string &theAppRoot, pid_t pid, const string &listenSocketName,
-	            const string &listenSocketType, int ownerPipe) {
-		appRoot = theAppRoot;
-		this->pid = pid;
-		this->listenSocketName = listenSocketName;
-		this->listenSocketType = listenSocketType;
-		this->ownerPipe = ownerPipe;
-		P_TRACE(3, "Application " << this << ": created.");
-	}
-	
-	virtual ~Application() {
-		TRACE_POINT();
-		int ret;
-		
-		if (ownerPipe != -1) {
-			do {
-				ret = close(ownerPipe);
-			} while (ret == -1 && errno == EINTR);
-		}
-		if (listenSocketType == "unix") {
-			do {
-				ret = unlink(listenSocketName.c_str());
-			} while (ret == -1 && errno == EINTR);
-		}
-		P_TRACE(3, "Application " << this << ": destroyed.");
-	}
-	
-	/**
-	 * Returns the application root for this application. See the constructor
-	 * for information about the application root.
-	 */
-	string getAppRoot() const {
-		return appRoot;
-	}
-	
-	/**
-	 * Returns the process ID of this application instance.
-	 */
-	pid_t getPid() const {
-		return pid;
-	}
-	
-	/**
-	 * Connect to this application instance with the purpose of sending
-	 * a request to the application. Once connected, a new session will
-	 * be opened. This session represents the life time of a single
-	 * request/response pair, and can be used to send the request
-	 * data to the application instance, as well as receiving the response
-	 * data.
-	 *
-	 * The use of connect() is demonstrated in the following example.
-	 * @code
-	 *   // Connect to the application and get the newly opened session.
-	 *   Application::SessionPtr session(app->connect("/home/webapps/foo"));
-	 *   
-	 *   // Send the request headers and request body data.
-	 *   session->sendHeaders(...);
-	 *   session->sendBodyBlock(...);
-	 *   // Done sending data, so we close the writer channel.
-	 *   session->shutdownWriter();
-	 *
-	 *   // Now read the HTTP response.
-	 *   string responseData = readAllDataFromSocket(session->getReader());
-	 *   // Done reading data, so we close the reader channel.
-	 *   session->shutdownReader();
-	 *
-	 *   // This session has now finished, so we close the session by resetting
-	 *   // the smart pointer to NULL (thereby destroying the Session object).
-	 *   session.reset();
-	 *
-	 *   // We can connect to an Application multiple times. Just make sure
-	 *   // the previous session is closed.
-	 *   session = app->connect("/home/webapps/bar")
-	 * @endcode
-	 *
-	 * Note that a RoR application instance can only process one
-	 * request at the same time, and thus only one session at the same time.
-	 * It's unspecified whether Rack applications can handle multiple simultanous sessions.
-	 *
-	 * You <b>must</b> close a session when you no longer need if. If you
-	 * call connect() without having properly closed a previous session,
-	 * you might cause a deadlock because the application instance may be
-	 * waiting for you to close the previous session.
-	 *
-	 * @return A smart pointer to a Session object, which represents the created session.
-	 * @param closeCallback A function which will be called when the session has been closed.
-	 * @post this->getSessions() == old->getSessions() + 1
-	 * @throws SystemException Something went wrong during the connection process.
-	 * @throws IOException Something went wrong during the connection process.
-	 * @throws boost::thread_interrupted
-	 */
-	SessionPtr connect(const function<void()> &closeCallback) const {
-		TRACE_POINT();
-		if (listenSocketType == "unix") {
-			return connectToUnixServer(closeCallback);
-		} else if (listenSocketType == "tcp") {
-			return connectToTcpServer(closeCallback);
-		} else {
-			throw IOException("Unsupported socket type '" + listenSocketType + "'");
-		}
-	}
-};
-
-/** Convenient alias for Application smart pointer. */
-typedef shared_ptr<Application> ApplicationPtr;
-
-} // namespace Passenger
-
-#endif /* _PASSENGER_APPLICATION_H_ */