passenger 5.3.4 → 5.3.5

data/src/cxx_supportlib/AppTypeDetector/CBindings.cpp

@@ -0,0 +1,136 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2018 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  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.
+ */
+
+#include <cstddef>
+#include <new>
+#include <exception>
+
+#include <StaticString.h>
+#include <AppTypeDetector/CBindings.h>
+#include <AppTypeDetector/Detector.h>
+
+using namespace Passenger;
+using namespace Passenger::WrapperRegistry;
+using namespace Passenger::AppTypeDetector;
+
+
+size_t
+psg_app_type_detector_result_get_object_size() {
+	return sizeof(Detector::Result);
+}
+
+PsgAppTypeDetectorResult *
+psg_app_type_detector_result_init(void *memory) {
+	Detector::Result *cxxResult = new (memory) Detector::Result();
+	return static_cast<PsgAppTypeDetectorResult *>(cxxResult);
+}
+
+void
+psg_app_type_detector_result_deinit(PsgAppTypeDetectorResult *result) {
+	Detector::Result *cxxResult = static_cast<Detector::Result *>(result);
+	cxxResult->~Result();
+}
+
+int
+psg_app_type_detector_result_is_null(const PsgAppTypeDetectorResult *result) {
+	const Detector::Result *cxxResult = static_cast<const Detector::Result *>(result);
+	return (int) cxxResult->isNull();
+}
+
+const PsgWrapperRegistryEntry *
+psg_app_type_detector_result_get_wrapper_registry_entry(const PsgAppTypeDetectorResult *result) {
+	const Detector::Result *cxxResult = static_cast<const Detector::Result *>(result);
+	return static_cast<const PsgWrapperRegistryEntry *>(cxxResult->wrapperRegistryEntry);
+}
+
+void
+psg_app_type_detector_result_set_wrapper_registry_entry(PsgAppTypeDetectorResult *result,
+	const PsgWrapperRegistryEntry *entry)
+{
+	Detector::Result *cxxResult = static_cast<Detector::Result *>(result);
+	cxxResult->wrapperRegistryEntry = static_cast<const WrapperRegistry::Entry *>(entry);
+}
+
+
+PsgAppTypeDetector *
+psg_app_type_detector_new(const PsgWrapperRegistry *registry,
+	unsigned int throttleRate)
+{
+	const Registry *cxxRegistry = static_cast<const Registry *>(registry);
+	try {
+		Detector *detector = new Detector(*cxxRegistry, NULL, NULL, throttleRate);
+		return static_cast<PsgAppTypeDetector *>(detector);
+	} catch (const std::bad_alloc &) {
+		return NULL;
+	}
+}
+
+void
+psg_app_type_detector_free(PsgAppTypeDetector *detector) {
+	Detector *cxxDetector = static_cast<Detector *>(detector);
+	delete cxxDetector;
+}
+
+void
+psg_app_type_detector_set_throttle_rate(PsgAppTypeDetector *detector,
+	unsigned int throttleRate)
+{
+	Detector *cxxDetector = static_cast<Detector *>(detector);
+	cxxDetector->setThrottleRate(throttleRate);
+}
+
+void
+psg_app_type_detector_check_document_root(
+	PsgAppTypeDetector *detector, PsgAppTypeDetectorResult *result,
+	const char *documentRoot, unsigned int len, int resolveFirstSymlink,
+	PP_Error *error)
+{
+	Detector *cxxDetector = static_cast<Detector *>(detector);
+	Detector::Result *cxxResult = static_cast<Detector::Result *>(result);
+	try {
+		*cxxResult = cxxDetector->checkDocumentRoot(
+			StaticString(documentRoot, len), resolveFirstSymlink);
+	} catch (const std::exception &e) {
+		pp_error_set(e, error);
+		*cxxResult = Detector::Result();
+	}
+}
+
+void
+psg_app_type_detector_check_app_root(
+	PsgAppTypeDetector *detector, PsgAppTypeDetectorResult *result,
+	const char *appRoot, unsigned int len, PP_Error *error)
+{
+	Detector *cxxDetector = static_cast<Detector *>(detector);
+	Detector::Result *cxxResult = static_cast<Detector::Result *>(result);
+	try {
+		*cxxResult = cxxDetector->checkAppRoot(
+			StaticString(appRoot, len));
+	} catch (const std::exception &e) {
+		pp_error_set(e, error);
+		*cxxResult = Detector::Result();
+	}
+}

data/src/cxx_supportlib/AppTypeDetector/CBindings.h

@@ -0,0 +1,73 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2018 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  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_APP_TYPE_DETECTOR_CBINDINGS_H_
+#define _PASSENGER_APP_TYPE_DETECTOR_CBINDINGS_H_
+
+#include <stddef.h>
+#include "../WrapperRegistry/CBindings.h"
+#include "../Exceptions.h"
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+
+typedef void PsgAppTypeDetectorResult;
+
+size_t psg_app_type_detector_result_get_object_size();
+PsgAppTypeDetectorResult *psg_app_type_detector_result_init(void *memory);
+void psg_app_type_detector_result_deinit(PsgAppTypeDetectorResult *result);
+
+int psg_app_type_detector_result_is_null(const PsgAppTypeDetectorResult *result);
+const PsgWrapperRegistryEntry *psg_app_type_detector_result_get_wrapper_registry_entry(
+	const PsgAppTypeDetectorResult *result);
+void psg_app_type_detector_result_set_wrapper_registry_entry(PsgAppTypeDetectorResult *result,
+	const PsgWrapperRegistryEntry *entry);
+
+
+typedef void PsgAppTypeDetector;
+
+PsgAppTypeDetector *psg_app_type_detector_new(const PsgWrapperRegistry *registry,
+	unsigned int throttleRate);
+void psg_app_type_detector_free(PsgAppTypeDetector *detector);
+void psg_app_type_detector_set_throttle_rate(PsgAppTypeDetector *detector,
+	unsigned int throttleRate);
+void psg_app_type_detector_check_document_root(
+	PsgAppTypeDetector *detector,
+	PsgAppTypeDetectorResult *result,
+	const char *documentRoot, unsigned int len, int resolveFirstSymlink,
+	PP_Error *error);
+void psg_app_type_detector_check_app_root(
+	PsgAppTypeDetector *detector,
+	PsgAppTypeDetectorResult *result,
+	const char *appRoot, unsigned int len, PP_Error *error);
+
+
+#ifdef __cplusplus
+	} // extern "C"
+#endif
+
+#endif /* _PASSENGER_APP_TYPE_DETECTOR_CBINDINGS_H_ */

data/src/cxx_supportlib/{AppTypes.h → AppTypeDetector/Detector.h}

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2013-2017 Phusion Holding B.V.
+ *  Copyright (c) 2018 Phusion Holding B.V.
  *
  *  "Passenger", "Phusion Passenger" and "Union Station" are registered
  *  trademarks of Phusion Holding B.V.
@@ -23,117 +23,89 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
-#ifndef _PASSENGER_APP_TYPES_H_
-#define _PASSENGER_APP_TYPES_H_
-
-/**
- * Application type registry
- *
- * All supported application types (e.g. Rack, classic Rails, WSGI, etc)
- * are registered here. The AppTypeDetector is responsible for checking
- * what kind of application lives under the given directory.
- */
-
-#include "Exceptions.h"
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-typedef enum {
-	PAT_RACK,
-	PAT_WSGI,
-	PAT_NODE,
-	PAT_METEOR,
-	PAT_NONE,
-	PAT_ERROR
-} PassengerAppType;
-
-typedef void PP_AppTypeDetector;
-
-PP_AppTypeDetector *pp_app_type_detector_new(unsigned int throttleRate);
-void pp_app_type_detector_free(PP_AppTypeDetector *detector);
-void pp_app_type_detector_set_throttle_rate(PP_AppTypeDetector *detector,
-	unsigned int throttleRate);
-PassengerAppType pp_app_type_detector_check_document_root(PP_AppTypeDetector *detector,
-	const char *documentRoot, unsigned int len, int resolveFirstSymlink,
-	PP_Error *error);
-PassengerAppType pp_app_type_detector_check_app_root(PP_AppTypeDetector *detector,
-	const char *appRoot, unsigned int len, PP_Error *error);
-
-const char *pp_get_app_type_name(PassengerAppType type);
-PassengerAppType pp_get_app_type2(const char *name, unsigned int len);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+#ifndef _PASSENGER_APP_TYPE_DECTECTOR_H_
+#define _PASSENGER_APP_TYPE_DECTECTOR_H_
 
+#include <limits.h>
 
-#ifdef __cplusplus
+#include <boost/thread.hpp>
+#include <boost/foreach.hpp>
 #include <oxt/macros.hpp>
 #include <oxt/backtrace.hpp>
-#include <boost/thread.hpp>
-#include <cstdlib>
-#include <limits.h>
+
+#include <cassert>
+#include <cstddef>
 #include <string>
-#include <LoggingKit/LoggingKit.h>
-#include <StaticString.h>
+
+#include <Exceptions.h>
+#include <WrapperRegistry/Registry.h>
 #include <FileTools/PathManip.h>
 #include <FileTools/FileManip.h>
 #include <Utils.h>
-#include <Utils/StrIntUtils.h>
 #include <Utils/CachedFileStat.hpp>
+#include <Utils/StrIntUtils.h>
 
 namespace Passenger {
+namespace AppTypeDetector {
 
 using namespace std;
 
 
-struct AppTypeDefinition {
-	const PassengerAppType type;
-	const char * const name;
-	const char * const startupFile;
-	const char * const processTitle;
-};
+class Detector {
+public:
+	struct Result {
+		const WrapperRegistry::Entry *wrapperRegistryEntry;
 
-extern const AppTypeDefinition appTypeDefinitions[];
+		Result()
+			: wrapperRegistryEntry(NULL)
+			{ }
 
+		bool isNull() const {
+			return wrapperRegistryEntry == NULL;
+		}
+	};
 
-class AppTypeDetector {
 private:
+	const WrapperRegistry::Registry &registry;
 	CachedFileStat *cstat;
 	boost::mutex *cstatMutex;
 	unsigned int throttleRate;
 	bool ownsCstat;
 
-	bool check(char *buf, const char *end, const StaticString &appRoot, const char *name) {
+	bool check(char *buf, const char *end, const StaticString &appRoot,
+		const StaticString &name)
+	{
 		char *pos = buf;
 		pos = appendData(pos, end, appRoot);
-		pos = appendData(pos, end, "/");
+		pos = appendData(pos, end, "/", 1);
 		pos = appendData(pos, end, name);
 		pos = appendData(pos, end, "\0", 1);
 		if (OXT_UNLIKELY(pos == end)) {
 			TRACE_POINT();
 			throw RuntimeException("Not enough buffer space");
 		}
-		return getFileType(StaticString(buf, pos - buf - 1), cstat, cstatMutex, throttleRate) != FT_NONEXISTANT;
+		return getFileType(StaticString(buf, pos - buf - 1),
+			cstat, cstatMutex, throttleRate) != FT_NONEXISTANT;
 	}
 
 public:
-	AppTypeDetector(CachedFileStat *_cstat = NULL, boost::mutex *_cstatMutex = NULL, unsigned int _throttleRate = 1)
-		: cstat(_cstat),
+	Detector(const WrapperRegistry::Registry &_registry,
+		CachedFileStat *_cstat = NULL, boost::mutex *_cstatMutex = NULL,
+		unsigned int _throttleRate = 1)
+		: registry(_registry),
+		  cstat(_cstat),
 		  cstatMutex(_cstatMutex),
 		  throttleRate(_throttleRate),
 		  ownsCstat(false)
 	{
+		assert(_registry.isFinalized());
 		if (_cstat == NULL) {
 			cstat = new CachedFileStat();
 			ownsCstat = true;
 		}
 	}
 
-	~AppTypeDetector() {
+	~Detector() {
 		if (ownsCstat) {
 			delete cstat;
 		}
@@ -146,7 +118,7 @@ public:
 	/**
 	 * Given a web server document root (that is, some subdirectory under the
 	 * application root, e.g. "/webapps/foobar/public"), returns the type of
-	 * application that lives there. Returns PAT_NONE if it wasn't able to detect
+	 * application that lives there. Returns a null result if it wasn't able to detect
 	 * a supported application type.
 	 *
 	 * If `resolveFirstSymlink` is given, and `documentRoot` is a symlink, then
@@ -161,7 +133,7 @@ public:
 	 * @throws TimeRetrievalException
 	 * @throws boost::thread_interrupted
 	 */
-	PassengerAppType checkDocumentRoot(const StaticString &documentRoot,
+	const Result checkDocumentRoot(const StaticString &documentRoot,
 		bool resolveFirstSymlink = false,
 		string *appRoot = NULL)
 	{
@@ -193,83 +165,38 @@ public:
 
 	/**
 	 * Returns the type of application that lives under the application
-	 * directory `appRoot`. Returns PAT_NONE if it wasn't able to detect
+	 * directory `appRoot`. Returns a null result if it wasn't able to detect
 	 * a supported application type.
 	 *
 	 * @throws FileSystemException Unable to check because of a filesystem error.
 	 * @throws TimeRetrievalException
 	 * @throws boost::thread_interrupted
 	 */
-	PassengerAppType checkAppRoot(const StaticString &appRoot) {
+	const Result checkAppRoot(const StaticString &appRoot) {
 		char buf[PATH_MAX + 32];
 		const char *end = buf + sizeof(buf) - 1;
-		const AppTypeDefinition *definition = &appTypeDefinitions[0];
 
-		while (definition->type != PAT_NONE) {
-			if (check(buf, end, appRoot, definition->startupFile)) {
-				return definition->type;
+		WrapperRegistry::Registry::ConstIterator it(registry.getIterator());
+		while (*it != NULL) {
+			const WrapperRegistry::Entry &entry = it.getValue();
+			foreach (const StaticString &defaultStartupFile,
+				entry.defaultStartupFiles)
+			{
+				if (check(buf, end, appRoot, defaultStartupFile)) {
+					Result result;
+					result.wrapperRegistryEntry = &entry;
+					return result;
+				}
 			}
-			definition++;
-		}
-		return PAT_NONE;
-	}
-};
-
-
-inline const char *
-getAppTypeName(PassengerAppType type) {
-	const AppTypeDefinition *definition = &appTypeDefinitions[0];
-
-	while (definition->type != PAT_NONE) {
-		if (definition->type == type) {
-			return definition->name;
-		}
-		definition++;
-	}
-	return NULL;
-}
-
-inline PassengerAppType
-getAppType(const StaticString &name) {
-	const AppTypeDefinition *definition = &appTypeDefinitions[0];
-
-	while (definition->type != PAT_NONE) {
-		if (name == definition->name) {
-			return definition->type;
-		}
-		definition++;
-	}
-	return PAT_NONE;
-}
-
-inline const char *
-getAppTypeStartupFile(PassengerAppType type) {
-	const AppTypeDefinition *definition = &appTypeDefinitions[0];
-
-	while (definition->type != PAT_NONE) {
-		if (definition->type == type) {
-			return definition->startupFile;
+			it.next();
 		}
-		definition++;
-	}
-	return NULL;
-}
-
-inline const char *
-getAppTypeProcessTitle(PassengerAppType type) {
-	const AppTypeDefinition *definition = &appTypeDefinitions[0];
 
-	while (definition->type != PAT_NONE) {
-		if (definition->type == type) {
-			return definition->processTitle;
-		}
-		definition++;
+		return Result();
 	}
-	return NULL;
-}
+};
 
 
+} // namespace AppTypeDetector
 } // namespace Passenger
-#endif /* __cplusplus */
 
-#endif /* _PASSENGER_APP_TYPES_H_ */
+#endif /* _PASSENGER_APP_TYPE_DECTECTOR_H_ */