passenger 6.0.27 → 6.1.0

data/src/cxx_supportlib/Exceptions.cpp

@@ -27,6 +27,9 @@
 #include <Exceptions.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sstream>
+#include <cstring>
+#include <cassert>
 
 
 void
@@ -70,3 +73,178 @@ pp_error_set(const std::exception &ex, PP_Error *error) {
 		error->errnoCode = PP_NO_ERRNO;
 	}
 }
+
+
+namespace Passenger {
+
+SystemException::SystemException(const string &briefMessage, int errorCode) {
+	stringstream str;
+	str << strerror(errorCode) << " (errno=" << errorCode << ")";
+	systemMessage = str.str();
+	setBriefMessage(briefMessage);
+	m_code = errorCode;
+}
+
+SystemException::~SystemException() noexcept {}
+
+const char *
+SystemException::what() const noexcept {
+	return fullMessage.c_str();
+}
+
+void
+SystemException::setBriefMessage(const string &message) {
+	briefMessage = message;
+	fullMessage = briefMessage + ": " + systemMessage;
+}
+
+int
+SystemException::code() const noexcept {
+	return m_code;
+}
+
+string
+SystemException::brief() const noexcept {
+	return briefMessage;
+}
+
+string
+SystemException::sys() const noexcept {
+	return systemMessage;
+}
+
+
+FileSystemException::FileSystemException(const string &message, int errorCode, const string &filename)
+	: SystemException(message, errorCode), m_filename(filename) {}
+
+FileSystemException::~FileSystemException() noexcept {}
+
+string
+FileSystemException::filename() const noexcept {
+	return m_filename;
+}
+
+
+TimeRetrievalException::TimeRetrievalException(const string &message, int errorCode)
+	: SystemException(message, errorCode) {}
+
+TimeRetrievalException::~TimeRetrievalException() noexcept {}
+
+
+IOException::IOException(const string &message) : msg(message) {}
+
+IOException::~IOException() noexcept {}
+
+const char *
+IOException::what() const noexcept {
+	return msg.c_str();
+}
+
+
+FileNotFoundException::FileNotFoundException(const string &message) : IOException(message) {}
+
+FileNotFoundException::~FileNotFoundException() noexcept {}
+
+
+EOFException::EOFException(const string &message) : IOException(message) {}
+
+EOFException::~EOFException() noexcept {}
+
+
+ConfigurationException::ConfigurationException(const string &message) : msg(message) {}
+
+ConfigurationException::~ConfigurationException() noexcept {}
+
+const char *
+ConfigurationException::what() const noexcept {
+	return msg.c_str();
+}
+
+
+GetAbortedException::GetAbortedException(const string &message) : msg(message) {}
+
+GetAbortedException::GetAbortedException(const oxt::tracable_exception::no_backtrace &tag)
+	: oxt::tracable_exception(tag) {}
+
+GetAbortedException::~GetAbortedException() noexcept {}
+
+const char *
+GetAbortedException::what() const noexcept {
+	return msg.c_str();
+}
+
+
+RequestQueueFullException::RequestQueueFullException(unsigned int maxQueueSize)
+	: GetAbortedException(oxt::tracable_exception::no_backtrace())
+{
+	stringstream str;
+	str << "Request queue full (configured max. size: " << maxQueueSize << ")";
+	msg = str.str();
+}
+
+RequestQueueFullException::~RequestQueueFullException() noexcept {}
+
+const char *
+RequestQueueFullException::what() const noexcept {
+	return msg.c_str();
+}
+
+
+ArgumentException::ArgumentException(const string &message) : msg(message) {}
+
+ArgumentException::~ArgumentException() noexcept {}
+
+const char *
+ArgumentException::what() const noexcept {
+	return msg.c_str();
+}
+
+
+InvalidModeStringException::InvalidModeStringException(const string &message) : ArgumentException(message) {}
+
+
+RuntimeException::RuntimeException(const string &message) : msg(message) {}
+
+RuntimeException::~RuntimeException() noexcept {}
+
+const char *
+RuntimeException::what() const noexcept {
+	return msg.c_str();
+}
+
+
+TimeoutException::TimeoutException(const string &message) : msg(message) {}
+
+TimeoutException::~TimeoutException() noexcept {}
+
+const char *
+TimeoutException::what() const noexcept {
+	return msg.c_str();
+}
+
+
+SecurityException::SecurityException(const string &message) : msg(message) {}
+
+SecurityException::~SecurityException() noexcept {}
+
+const char *
+SecurityException::what() const noexcept {
+	return msg.c_str();
+}
+
+
+NonExistentUserException::NonExistentUserException(const string &message) : SecurityException(message) {}
+
+NonExistentGroupException::NonExistentGroupException(const string &message) : SecurityException(message) {}
+
+
+SyntaxError::SyntaxError(const string &message) : msg(message) {}
+
+SyntaxError::~SyntaxError() noexcept {}
+
+const char *
+SyntaxError::what() const noexcept {
+	return msg.c_str();
+}
+
+} // namespace Passenger

data/src/cxx_supportlib/Exceptions.h

@@ -62,9 +62,6 @@ void pp_error_destroy(PP_Error *error);
 #include <oxt/tracable_exception.hpp>
 #include <string>
 #include <exception>
-#include <sstream>
-#include <cstring>
-#include <cassert>
 
 
 /**
@@ -79,21 +76,15 @@ void pp_error_destroy(PP_Error *error);
 void pp_error_set(const std::exception &ex, PP_Error *error);
 
 
-/**
- * @defgroup Exceptions Exceptions
- */
-
 namespace Passenger {
 
 using namespace std;
 
 /**
- * Represents an error returned by a system call or a standard library call.
+ * An error returned by a system call or a standard library call.
  *
- * Use the code() method to find out the value of <tt>errno</tt> at the time
+ * Use `code()` to find out the value of `errno` at the time
  * the error occured.
- *
- * @ingroup Exceptions
  */
 class SystemException: public oxt::tracable_exception {
 private:
@@ -101,6 +92,7 @@ private:
 	string systemMessage;
 	string fullMessage;
 	int m_code;
+
 public:
 	/**
 	 * Create a new SystemException.
@@ -114,138 +106,83 @@ public:
 	 * @post code() == errorCode
 	 * @post brief() == briefMessage
 	 */
-	SystemException(const string &briefMessage, int errorCode) {
-		stringstream str;
-
-		str << strerror(errorCode) << " (errno=" << errorCode << ")";
-		systemMessage = str.str();
-
-		setBriefMessage(briefMessage);
-		m_code = errorCode;
-	}
-
-	virtual ~SystemException() throw() {}
-
-	virtual const char *what() const throw() {
-		return fullMessage.c_str();
-	}
-
-	void setBriefMessage(const string &message) {
-		briefMessage = message;
-		fullMessage = briefMessage + ": " + systemMessage;
-	}
-
-	/**
-	 * The value of <tt>errno</tt> at the time the error occured.
-	 */
-	int code() const throw() {
-		return m_code;
-	}
-
-	/**
-	 * Returns a brief version of the exception message. This message does
-	 * not include the system error description, and is equivalent to the
-	 * value of the <tt>message</tt> parameter as passed to the constructor.
-	 */
-	string brief() const throw() {
-		return briefMessage;
-	}
-
-	/**
-	 * Returns the system's error message. This message contains both the
-	 * content of <tt>strerror(errno)</tt> and the errno number itself.
-	 */
-	string sys() const throw() {
-		return systemMessage;
-	}
+	SystemException(const string &briefMessage, int errorCode);
+	virtual ~SystemException() noexcept;
+	virtual const char *what() const noexcept;
+	void setBriefMessage(const string &message);
+	int code() const noexcept;
+	string brief() const noexcept;
+	string sys() const noexcept;
 };
 
 /**
  * A filesystem error, as returned by the operating system. This may include,
  * for example, permission errors.
- *
- * @ingroup Exceptions
  */
 class FileSystemException: public SystemException {
 private:
 	string m_filename;
-public:
-	FileSystemException(const string &message, int errorCode,
-		const string &filename)
-		: SystemException(message, errorCode),
-		  m_filename(filename) {}
-
-	virtual ~FileSystemException() throw() {}
 
-	/**
-	 * The filename that's associated to the error.
-	 */
-	string filename() const throw() {
-		return m_filename;
-	}
+public:
+	FileSystemException(const string &message, int errorCode, const string &filename);
+	virtual ~FileSystemException() noexcept;
+	string filename() const noexcept;
 };
 
 /**
  * Unable to retrieve the system time using <tt>time()</tt>.
- *
- * @ingroup Exceptions
  */
 class TimeRetrievalException: public SystemException {
 public:
-	TimeRetrievalException(const string &message, int errorCode)
-		: SystemException(message, errorCode)
-		{}
-	virtual ~TimeRetrievalException() throw() {}
+	TimeRetrievalException(const string &message, int errorCode);
+	virtual ~TimeRetrievalException() noexcept;
 };
 
 /**
- * Represents an error that occured during an I/O operation.
- *
- * @ingroup Exceptions
+ * Error during an I/O operation.
  */
 class IOException: public oxt::tracable_exception {
 private:
 	string msg;
+
 public:
-	IOException(const string &message): msg(message) {}
-	virtual ~IOException() throw() {}
-	virtual const char *what() const throw() { return msg.c_str(); }
+	IOException(const string &message);
+	virtual ~IOException() noexcept;
+	virtual const char *what() const noexcept;
 };
 
 /**
- * Thrown when a certain file cannot be found.
+ * Certain file cannot be found.
  */
 class FileNotFoundException: public IOException {
 public:
-	FileNotFoundException(const string &message): IOException(message) {}
-	virtual ~FileNotFoundException() throw() {}
+	FileNotFoundException(const string &message);
+	virtual ~FileNotFoundException() noexcept;
 };
 
 /**
- * An unexpected end-of-file I/O error.
- *
- * @ingroup Exceptions
+ * Unexpected end-of-file I/O error.
  */
 class EOFException: public IOException {
 public:
-	EOFException(const string &message): IOException(message) {}
-	virtual ~EOFException() throw() {}
+	EOFException(const string &message);
+	virtual ~EOFException() noexcept;
 };
 
 /**
- * Thrown when an invalid configuration is given.
+ * Invalid configuration is given.
  */
 class ConfigurationException: public oxt::tracable_exception {
 private:
 	string msg;
 public:
-	ConfigurationException(const string &message): msg(message) {}
-	virtual ~ConfigurationException() throw() {}
-	virtual const char *what() const throw() { return msg.c_str(); }
+	ConfigurationException(const string &message);
+	virtual ~ConfigurationException() noexcept;
+	virtual const char *what() const noexcept;
 };
 
 /**
- * Indicates that a Pool::get() or Pool::asyncGet() request was denied.
+ * A Pool::get() or Pool::asyncGet() request was denied.
  * The request never reached a process. This could be because, before the
  * request could reach a process, the administrator detached the containing
  * group. Or maybe the request sat in the queue for too long.
@@ -255,23 +192,14 @@ private:
 	string msg;
 
 public:
-	GetAbortedException(const string &message)
-		: msg(message)
-		{ }
-
-	GetAbortedException(const oxt::tracable_exception::no_backtrace &tag)
-		: oxt::tracable_exception(tag)
-		{ }
-
-	virtual ~GetAbortedException() throw() {}
-
-	virtual const char *what() const throw() {
-		return msg.c_str();
-	}
+	GetAbortedException(const string &message);
+	GetAbortedException(const oxt::tracable_exception::no_backtrace &tag);
+	virtual ~GetAbortedException() noexcept;
+	virtual const char *what() const noexcept;
 };
 
 /**
- * Indicates that a Pool::get() or Pool::asyncGet() request was denied because
+ * A Pool::get() or Pool::asyncGet() request was denied because
  * the getWaitlist queue was full.
  */
 class RequestQueueFullException: public GetAbortedException {
@@ -279,127 +207,84 @@ private:
 	string msg;
 
 public:
-	RequestQueueFullException(unsigned int maxQueueSize)
-		: GetAbortedException(oxt::tracable_exception::no_backtrace())
-		{
-			stringstream str;
-			str << "Request queue full (configured max. size: " << maxQueueSize << ")";
-			msg = str.str();
-		}
-
-	virtual ~RequestQueueFullException() throw() {}
-
-	virtual const char *what() const throw() {
-		return msg.c_str();
-	}
+	RequestQueueFullException(unsigned int maxQueueSize);
+	virtual ~RequestQueueFullException() noexcept;
+	virtual const char *what() const noexcept;
 };
 
 /**
- * Indicates that a specified argument is incorrect or violates a requirement.
- *
- * @ingroup Exceptions
+ * A specified argument is incorrect or violates a requirement.
  */
 class ArgumentException: public oxt::tracable_exception {
 private:
 	string msg;
 public:
-	ArgumentException(const string &message): msg(message) {}
-	virtual ~ArgumentException() throw() {}
-	virtual const char *what() const throw() { return msg.c_str(); }
+	ArgumentException(const string &message);
+	virtual ~ArgumentException() noexcept;
+	virtual const char *what() const noexcept;
 };
 
-/*
- * @ingroup Exceptions
- */
 class InvalidModeStringException: public ArgumentException {
 public:
-	InvalidModeStringException(const string &message): ArgumentException(message) {}
+	InvalidModeStringException(const string &message);
 };
 
 /**
- * A generic runtime exception.
- *
- * @ingroup Exceptions
+ * Generic runtime exception.
  */
 class RuntimeException: public oxt::tracable_exception {
 private:
 	string msg;
 public:
-	RuntimeException(const string &message): msg(message) {}
-	virtual ~RuntimeException() throw() {}
-	virtual const char *what() const throw() { return msg.c_str(); }
+	RuntimeException(const string &message);
+	virtual ~RuntimeException() noexcept;
+	virtual const char *what() const noexcept;
 };
 
 /**
- * An exception indicating that some timeout expired.
- *
- * @ingroup Exceptions
+ * Some timeout expired.
  */
 class TimeoutException: public oxt::tracable_exception {
 private:
 	string msg;
 public:
-	TimeoutException(const string &message): msg(message) {}
-	virtual ~TimeoutException() throw() {}
-	virtual const char *what() const throw() { return msg.c_str(); }
+	TimeoutException(const string &message);
+	virtual ~TimeoutException() noexcept;
+	virtual const char *what() const noexcept;
 };
 
 /**
- * Represents some kind of security error.
- *
- * @ingroup Exceptions
+ * Some kind of security error.
  */
 class SecurityException: public oxt::tracable_exception {
 private:
 	string msg;
 public:
-	SecurityException(const string &message): msg(message) {}
-	virtual ~SecurityException() throw() {}
-	virtual const char *what() const throw() { return msg.c_str(); }
+	SecurityException(const string &message);
+	virtual ~SecurityException() noexcept;
+	virtual const char *what() const noexcept;
 };
 
-/**
- * @ingroup Exceptions
- */
 class NonExistentUserException: public SecurityException {
 public:
-	NonExistentUserException(const string &message): SecurityException(message) {}
+	NonExistentUserException(const string &message);
 };
 
-/**
- * @ingroup Exceptions
- */
 class NonExistentGroupException: public SecurityException {
 public:
-	NonExistentGroupException(const string &message): SecurityException(message) {}
-};
-
-/**
- * The application pool is too busy and cannot fulfill a get() request.
- *
- * @ingroup Exceptions
- */
-class BusyException: public oxt::tracable_exception {
-private:
-	string msg;
-public:
-	BusyException(const string &message): msg(message) {}
-	virtual ~BusyException() throw() {}
-	virtual const char *what() const throw() { return msg.c_str(); }
+	NonExistentGroupException(const string &message);
 };
 
 /**
  * A parser detected a syntax error.
- *
- * @ingroup Exceptions
  */
 class SyntaxError: public oxt::tracable_exception {
 private:
 	string msg;
 public:
-	SyntaxError(const string &message): msg(message) {}
-	virtual ~SyntaxError() throw() {}
-	virtual const char *what() const throw() { return msg.c_str(); }
+	SyntaxError(const string &message);
+	virtual ~SyntaxError() noexcept;
+	virtual const char *what() const noexcept;
 };
 
 } // namespace Passenger