ext/common/StringListCreator.h @@ -189,6 +189,7 @@ def define_common_library_task(output_dir, extra_compiler_flags = nil, 'ext/common/MessageChannel.h', 'ext/common/SpawnManager.h', 'ext/common/PoolOptions.h', + 'ext/common/StringListCreator.h', 'ext/common/FileChecker.h', 'ext/common/SystemTime.h', 'ext/common/CachedFileStat.h', @@ -243,6 +244,7 @@ end ext/common/Application.h ext/common/MessageChannel.h ext/common/PoolOptions.h + ext/common/StringListCreator.h ext/common/Version.h ext/common/Utils.h) } @@ -390,12 +392,14 @@ end test/SpawnManagerTest.cpp ext/common/SpawnManager.h ext/common/PoolOptions.h + ext/common/StringListCreator.h ext/common/Application.h ext/common/MessageChannel.h), 'test/ApplicationPoolServerTest.o' => %w( test/ApplicationPoolServerTest.cpp ext/common/ApplicationPoolServer.h ext/common/PoolOptions.h + ext/common/StringListCreator.h ext/common/MessageChannel.h), 'test/ApplicationPoolServer_ApplicationPoolTest.o' => %w( test/ApplicationPoolServer_ApplicationPoolTest.cpp @@ -404,6 +408,7 @@ end ext/common/ApplicationPool.h ext/common/SpawnManager.h ext/common/PoolOptions.h + ext/common/StringListCreator.h ext/common/Application.h ext/common/MessageChannel.h), 'test/StandardApplicationPoolTest.o' => %w( @@ -413,11 +418,13 @@ end ext/common/StandardApplicationPool.h ext/common/SpawnManager.h ext/common/PoolOptions.h + ext/common/StringListCreator.h ext/common/FileChecker.h ext/common/Application.h), 'test/PoolOptionsTest.o' => %w( test/PoolOptionsTest.cpp - ext/common/PoolOptions.h), + ext/common/PoolOptions.h + ext/common/StringListCreator.h), 'test/StaticStringTest.o' => %w( test/StaticStringTest.cpp ext/common/StaticString.h), Rakefile @@ -138,6 +138,33 @@ private: } }; + /** + * A StringListCreator which returns a list of environment variable + * names and values, as found in r->subprocess_env. + */ + class EnvironmentVariablesStringListCreator: public StringListCreator { + private: + request_rec *r; + public: + EnvironmentVariablesStringListCreator(request_rec *r) { + this->r = r; + } + + virtual const StringListPtr getItems() const { + const apr_array_header_t *env_arr; + apr_table_entry_t *env_entries; + StringListPtr result = ptr(new StringList()); + + env_arr = apr_table_elts(r->subprocess_env); + env_entries = (apr_table_entry_t *) env_arr->elts; + for (int i = 0; i < env_arr->nelts; ++i) { + result->push_back(env_entries[i].key); + result->push_back(env_entries[i].val); + } + return result; + } + }; + enum Threeway { YES, NO, UNKNOWN }; ApplicationPoolServerPtr applicationPoolServer; @@ -455,10 +482,8 @@ private: try { ServerConfig *sconfig = getServerConfig(r->server); string publicDirectory(mapper.getPublicDirectory()); - string appRoot(config->getAppRoot(publicDirectory.c_str())); - - session = getApplicationPool()->get(PoolOptions( - appRoot, + PoolOptions options( + config->getAppRoot(publicDirectory.c_str()), true, sconfig->getDefaultUser(), mapper.getEnvironment(), @@ -471,7 +496,10 @@ private: config->usingGlobalQueue(), config->getStatThrottleRate(), config->getRestartDir() - )); + ); + options.environmentVariables = ptr(new EnvironmentVariablesStringListCreator(r)); + + session = getApplicationPool()->get(options); P_TRACE(3, "Forwarding " << r->uri << " to PID " << session->getPid()); } catch (const SpawnException &e) { r->status = 500; ext/apache2/Hooks.cpp @@ -126,7 +126,8 @@ public: * @throw BusyException The application pool is too busy right now, and cannot * satisfy the request. One should either abort, or try again later. * @throw IOException Something else went wrong. - * @throw thread_interrupted + * @throw boost::thread_interrupted + * @throws Anything thrown by options.environmentVariables->getItems(). * @note Applications are uniquely identified with the application root * string. So although <tt>appRoot</tt> does not have to be absolute, it * should be. If one calls <tt>get("/home/foo")</tt> and ext/common/ApplicationPool.h @@ -380,12 +380,18 @@ private: vector<string> args; int stream; bool result; + bool serverMightNeedEnvironmentVariables = true; + /* Send a 'get' request to the ApplicationPool server. + * For efficiency reasons, we do not send the data for + * options.environmentVariables over the wire yet until + * it's necessary. + */ try { vector<string> args; args.push_back("get"); - options.toVector(args); + options.toVector(args, false); channel.write(args); } catch (const SystemException &e) { UPDATE_TRACE_POINT(); @@ -395,22 +401,52 @@ private: message.append(e.brief()); throw SystemException(message, e.code()); } - try { - UPDATE_TRACE_POINT(); - result = channel.read(args); - } catch (const SystemException &e) { - UPDATE_TRACE_POINT(); - data->disconnect(); - throw SystemException("Could not read a message from " - "the ApplicationPool server", e.code()); - } - if (!result) { - UPDATE_TRACE_POINT(); - data->disconnect(); - throw IOException("The ApplicationPool server unexpectedly " - "closed the connection while we're reading a response " - "for the 'get' command."); + + /* The first few replies from the server might be for requesting + * environment variables in the pool options object, so keep handling + * these requests until we receive a different reply. + */ + while (serverMightNeedEnvironmentVariables) { + try { + result = channel.read(args); + } catch (const SystemException &e) { + UPDATE_TRACE_POINT(); + data->disconnect(); + throw SystemException("Could not read a response from " + "the ApplicationPool server for the 'get' command", e.code()); + } + if (!result) { + UPDATE_TRACE_POINT(); + data->disconnect(); + throw IOException("The ApplicationPool server unexpectedly " + "closed the connection while we're reading a response " + "for the 'get' command."); + } + + if (args[0] == "getEnvironmentVariables") { + try { + if (options.environmentVariables) { + UPDATE_TRACE_POINT(); + channel.writeScalar(options.serializeEnvironmentVariables()); + } else { + UPDATE_TRACE_POINT(); + channel.writeScalar(""); + } + } catch (const SystemException &e) { + data->disconnect(); + throw SystemException("Could not send a response " + "for the 'getEnvironmentVariables' request " + "to the ApplicationPool server", + e.code()); + } + } else { + serverMightNeedEnvironmentVariables = false; + } } + + /* We've now received a reply other than "getEnvironmentVariables". + * Handle this... + */ if (args[0] == "ok") { UPDATE_TRACE_POINT(); pid_t pid = (pid_t) atol(args[1]); ext/common/ApplicationPoolServer.h @@ -288,6 +288,131 @@ private: /** Last used session ID. */ int lastSessionID; + class ClientCommunicationError: public oxt::tracable_exception { + private: + string briefMessage; + string systemMessage; + string fullMessage; + int m_code; + public: + /** + * Create a new ClientCommunicationError. + * + * @param briefMessage A brief message describing the error. + * @param errorCode An optional error code, i.e. the value of errno right after the error occured, if applicable. + * @note A system description of the error will be appended to the given message. + * For example, if <tt>errorCode</tt> is <tt>EBADF</tt>, and <tt>briefMessage</tt> + * is <em>"Something happened"</em>, then what() will return <em>"Something happened: Bad + * file descriptor (10)"</em> (if 10 is the number for EBADF). + * @post code() == errorCode + * @post brief() == briefMessage + */ + ClientCommunicationError(const string &briefMessage, int errorCode = -1) { + if (errorCode != -1) { + stringstream str; + + str << strerror(errorCode) << " (" << errorCode << ")"; + systemMessage = str.str(); + } + setBriefMessage(briefMessage); + m_code = errorCode; + } + + virtual ~ClientCommunicationError() throw() {} + + virtual const char *what() const throw() { + return fullMessage.c_str(); + } + + void setBriefMessage(const string &message) { + briefMessage = message; + if (systemMessage.empty()) { + fullMessage = briefMessage; + } else { + 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. + * + * @post if code() == -1: result.empty() + */ + string sys() const throw() { + return systemMessage; + } + }; + + /** + * A StringListCreator which fetches its items from the client. + * Used as an optimization for ApplicationPoolServer::Client.get(): + * environment variables are only serialized by the client process + * if a new backend process is being spawned. + */ + class EnvironmentVariablesFetcher: public StringListCreator { + private: + MessageChannel &channel; + PoolOptions &options; + public: + EnvironmentVariablesFetcher(MessageChannel &theChannel, PoolOptions &theOptions) + : channel(theChannel), + options(theOptions) + { } + + /** + * @throws ClientCommunicationError + */ + virtual const StringListPtr getItems() const { + string data; + + /* If an I/O error occurred while communicating with the client, + * then throw a ClientCommunicationException, which will bubble + * all the way up to the thread main loop, where the connection + * with the client will be broken. + */ + try { + channel.write("getEnvironmentVariables", NULL); + } catch (const SystemException &e) { + throw ClientCommunicationError( + "Unable to send a 'getEnvironmentVariables' request to the client", + e.code()); + } + try { + if (!channel.readScalar(data)) { + throw ClientCommunicationError("Unable to read a reply from the client for the 'getEnvironmentVariables' request."); + } + } catch (const SystemException &e) { + throw ClientCommunicationError( + "Unable to read a reply from the client for the 'getEnvironmentVariables' request", + e.code()); + } + + if (!data.empty()) { + SimpleStringListCreator list(data); + return list.getItems(); + } else { + return ptr(new StringList()); + } + } + }; + void processGet(const vector<string> &args) { TRACE_POINT(); Application::SessionPtr session; @@ -295,6 +420,7 @@ private: try { PoolOptions options(args, 1); + options.environmentVariables = ptr(new EnvironmentVariablesFetcher(channel, options)); session = server.pool->get(options); sessions[lastSessionID] = session; lastSessionID++; ext/common/ApplicationPoolServerExecutable.cpp @@ -26,7 +26,8 @@ #define _PASSENGER_SPAWN_OPTIONS_H_ #include <string> -#include "Utils.h" +#include <vector> +#include "StringListCreator.h" namespace Passenger { @@ -148,6 +149,19 @@ struct PoolOptions { string restartDir; /** + * If a new backend process is started, then the getItems() method + * on this object will be called, which is to return environment + * variables that should be passed to the newly spawned backend process. + * Odd indices in the resulting array contain keys, even indices contain + * the value for the key in the previous index. + * + * May be set to NULL. + * + * @invariant environmentVariables.size() is an even number. + */ + StringListCreatorPtr environmentVariables; + + /** * Creates a new PoolOptions object with the default values filled in. * One must still set appRoot manually, after having used this constructor. */ @@ -230,16 +244,23 @@ struct PoolOptions { useGlobalQueue = vec[startIndex + 21] == "true"; statThrottleRate = atol(vec[startIndex + 23]); restartDir = vec[startIndex + 25]; + if (vec.size() > startIndex + 27) { + environmentVariables = ptr(new SimpleStringListCreator(vec[startIndex + 27])); + } } /** * Append the information in this PoolOptions object to the given * string vector. The resulting array could, for example, be used * as a message to be sent to the spawn server. + * + * @param vec The vector to store the information in. + * @param storeEnvVars Whether to store environment variable information into vec as well. + * @throws Anything thrown by environmentVariables->getItems(). */ - void toVector(vector<string> &vec) const { - if (vec.capacity() < vec.size() + 10) { - vec.reserve(vec.size() + 10); + void toVector(vector<string> &vec, bool storeEnvVars = true) const { + if (vec.capacity() < vec.size() + 28) { + vec.reserve(vec.size() + 28); } appendKeyValue (vec, "app_root", appRoot); appendKeyValue (vec, "lower_privilege", lowerPrivilege ? "true" : "false"); @@ -254,6 +275,37 @@ struct PoolOptions { appendKeyValue (vec, "use_global_queue", useGlobalQueue ? "true" : "false"); appendKeyValue3(vec, "stat_throttle_rate", statThrottleRate); appendKeyValue (vec, "restart_dir", restartDir); + if (storeEnvVars) { + vec.push_back("environment_variables"); + vec.push_back(serializeEnvironmentVariables()); + } + } + + /** + * Serializes the items in environmentVariables into a string, which + * can be used to create a SimpleStringListCreator object. + * + * @throws Anything thrown by environmentVariables->getItems(). + */ + string serializeEnvironmentVariables() const { + vector<string>::const_iterator it, end; + string result; + + if (environmentVariables) { + result.reserve(1024); + + StringListPtr items = environmentVariables->getItems(); + end = items->end(); + + for (it = items->begin(); it != end; it++) { + result.append(*it); + result.append(1, '\0'); + it++; + result.append(*it); + result.append(1, '\0'); + } + } + return Base64::encode(result); } private: ext/common/PoolOptions.h @@ -265,15 +265,16 @@ private: * @param PoolOptions The spawn options to use. * @return An Application smart pointer, representing the spawned application. * @throws SpawnException Something went wrong. + * @throws Anything thrown by options.environmentVariables->getItems(). */ - ApplicationPtr sendSpawnCommand(const PoolOptions &PoolOptions) { + ApplicationPtr sendSpawnCommand(const PoolOptions &options) { TRACE_POINT(); vector<string> args; int ownerPipe; try { args.push_back("spawn_application"); - PoolOptions.toVector(args); + options.toVector(args); channel.write(args); } catch (const SystemException &e) { throw SpawnException(string("Could not write 'spawn_application' " @@ -346,15 +347,16 @@ private: ret = chown(args[1].c_str(), getuid(), getgid()); } while (ret == -1 && errno == EINTR); } - return ApplicationPtr(new Application(PoolOptions.appRoot, + return ApplicationPtr(new Application(options.appRoot, pid, args[1], args[2], ownerPipe)); } /** * @throws boost::thread_interrupted + * @throws Anything thrown by options.environmentVariables->getItems(). */ ApplicationPtr - handleSpawnException(const SpawnException &e, const PoolOptions &PoolOptions) { + handleSpawnException(const SpawnException &e, const PoolOptions &options) { TRACE_POINT(); bool restarted; try { @@ -371,7 +373,7 @@ private: restarted = false; } if (restarted) { - return sendSpawnCommand(PoolOptions); + return sendSpawnCommand(options); } else { throw SpawnException("The spawn server died unexpectedly, and restarting it failed."); } @@ -500,17 +502,18 @@ public: * spawned application. * @throws SpawnException Something went wrong. * @throws boost::thread_interrupted + * @throws Anything thrown by options.environmentVariables->getItems(). */ - ApplicationPtr spawn(const PoolOptions &PoolOptions) { + ApplicationPtr spawn(const PoolOptions &options) { TRACE_POINT(); boost::mutex::scoped_lock l(lock); try { - return sendSpawnCommand(PoolOptions); + return sendSpawnCommand(options); } catch (const SpawnException &e) { if (e.hasErrorPage()) { throw; } else { - return handleSpawnException(e, PoolOptions); + return handleSpawnException(e, options); } } } ext/common/SpawnManager.h @@ -49,6 +49,8 @@ class ApplicationSpawner # Application object will be returned, which represents the spawned # application. # + # Accepts the same options as Railz::ApplicationSpawner#initialize. + # # Raises: # - AppInitError: The Rack application raised an exception or called # exit() during startup. @@ -83,13 +85,15 @@ class ApplicationSpawner end private - def run(channel, app_root, options) $0 = "Rack: #{app_root}" app = nil success = report_app_init_status(channel) do ENV['RACK_ENV'] = options["environment"] Dir.chdir(app_root) + if options["environment_variables"] + set_passed_environment_variables(options["environment_variables"]) + end if options["lower_privilege"] lower_privilege('config.ru', options["lowest_user"]) end @@ -116,6 +120,17 @@ private end end end + + def set_passed_environment_variables(encoded_environment_variables) + env_vars_string = encoded_environment_variables.unpack("m").first + # Prevent empty string as last item from b0rking the Hash[...] statement. + # See comment in Hooks.cpp (sendHeaders) for details. + env_vars_string << "_\0_" + env_vars = Hash[*env_vars_string.split("\0")] + env_vars.each_pair do |key, value| + ENV[key] = value + end + end def load_rack_app rackup_code = ::File.read("config.ru") lib/phusion_passenger/rack/application_spawner.rb @@ -84,6 +84,11 @@ class ApplicationSpawner < AbstractServer # - +environment+: # Allows one to specify the RAILS_ENV environment to use. # + # - +environment_variables+: + # Environment variables which should be passed to the spawned application. + # This is NULL-seperated string of key-value pairs, encoded in base64. + # The last byte in the unencoded data must be a NULL. + # # All other options will be passed on to RequestHandler. def initialize(app_root, options = {}) super() @@ -93,6 +98,7 @@ class ApplicationSpawner < AbstractServer @lower_privilege = @options["lower_privilege"] @lowest_user = @options["lowest_user"] @environment = @options["environment"] + @encoded_environment_variables = @options["environment_variables"] self.max_idle_time = DEFAULT_APP_SPAWNER_MAX_IDLE_TIME assert_valid_app_root(@app_root) define_message_handler(:spawn_application, :handle_spawn_application) @@ -145,6 +151,9 @@ class ApplicationSpawner < AbstractServer success = report_app_init_status(channel) do ENV['RAILS_ENV'] = @environment Dir.chdir(@app_root) + if @encoded_environment_variables + set_passed_environment_variables + end if @lower_privilege lower_privilege('config/environment.rb', @lowest_user) end @@ -221,6 +230,9 @@ protected Object.const_set(:RAILS_ENV, ENV['RAILS_ENV']) end Dir.chdir(@app_root) + if @encoded_environment_variables + set_passed_environment_variables + end if @lower_privilege lower_privilege('config/environment.rb', @lowest_user) end @@ -229,6 +241,17 @@ protected end private + def set_passed_environment_variables + env_vars_string = @encoded_environment_variables.unpack("m").first + # Prevent empty string as last item from b0rking the Hash[...] statement. + # See comment in Hooks.cpp (sendHeaders) for details. + env_vars_string << "_\0_" + env_vars = Hash[*env_vars_string.split("\0")] + env_vars.each_pair do |key, value| + ENV[key] = value + end + end + def preload_application Object.const_set(:RAILS_ROOT, @canonicalized_app_root) if defined?(::Rails::Initializer) lib/phusion_passenger/railz/application_spawner.rb @@ -97,7 +97,7 @@ class SpawnManager < AbstractServer # # Other options are: # - # ['lower_privilege', 'lowest_user' and 'environment'] + # ['lower_privilege', 'lowest_user', 'environment' and 'environment_variables'] # See Railz::ApplicationSpawner.new for an explanation of these options. # # ['app_type'] lib/phusion_passenger/spawn_manager.rb @@ -68,5 +68,47 @@ namespace tut { } } } + + /* A StringListCreator which not only returns a dummy value, but also + * increments a counter each time getItems() is called. */ + class DummyStringListCreator: public StringListCreator { + public: + mutable int counter; + + DummyStringListCreator() { + counter = 0; + } + + virtual const StringListPtr getItems() const { + StringListPtr result = ptr(new StringList()); + counter++; + result->push_back("hello"); + result->push_back("world"); + return result; + } + }; + + TEST_METHOD(5) { + // When calling get() with a PoolOptions object, + // options.environmentVariables->getItems() isn't called unless + // the pool had to spawn something. + ApplicationPoolServerPtr server = ptr(new ApplicationPoolServer( + "./ApplicationPoolServerExecutable", + "../bin/passenger-spawn-server")); + ApplicationPoolPtr pool = server->connect(); + + shared_ptr<DummyStringListCreator> strList = ptr(new DummyStringListCreator()); + PoolOptions options("stub/rack"); + options.appType = "rack"; + options.environmentVariables = strList; + + Application::SessionPtr session1 = pool->get(options); + session1.reset(); + ensure_equals(strList->counter, 1); + + session1 = pool->get(options); + session1.reset(); + ensure_equals(strList->counter, 1); + } } test/ApplicationPoolServerTest.cpp @@ -34,4 +34,84 @@ namespace tut { ensure_equals(options.appSpawnerTimeout, copy.appSpawnerTimeout); ensure_equals(options.maxRequests, copy.maxRequests); } + + // Test empty environmentVariables serialization and deserialization. + TEST_METHOD(2) { + PoolOptions options; + vector<string> args; + options.toVector(args); + + PoolOptions options2(args); + ensure_equals(options2.environmentVariables->getItems()->size(), 0u); + } + + // Test single item environmentVariables serialization and deserialization. + TEST_METHOD(3) { + PoolOptions options; + SimpleStringListCreatorPtr list = ptr(new SimpleStringListCreator()); + vector<string> args; + list->items->push_back("hello"); + list->items->push_back("world !!"); + options.environmentVariables = list; + options.toVector(args); + + PoolOptions options2(args); + const StringListPtr list2 = options2.environmentVariables->getItems(); + ensure_equals(list2->size(), 2u); + ensure_equals(list2->at(0), "hello"); + ensure_equals(list2->at(1), "world !!"); + } + + // Test multiple items environmentVariables serialization and deserialization. + TEST_METHOD(4) { + PoolOptions options; + SimpleStringListCreatorPtr list = ptr(new SimpleStringListCreator()); + vector<string> args; + list->items->push_back("hello"); + list->items->push_back("world !!"); + list->items->push_back("PATH"); + list->items->push_back("/usr/local/bin"); + options.environmentVariables = list; + options.toVector(args); + + PoolOptions options2(args); + const StringListPtr list2 = options2.environmentVariables->getItems(); + ensure_equals(list2->size(), 4u); + ensure_equals(list2->at(0), "hello"); + ensure_equals(list2->at(1), "world !!"); + ensure_equals(list2->at(2), "PATH"); + ensure_equals(list2->at(3), "/usr/local/bin"); + } + + // Calling toVector() with storeEnvVars = false on a PoolOption object that + // has no environment variables works, and the resulting data can be unserialized. + TEST_METHOD(5) { + PoolOptions options; + vector<string> args; + options.appRoot = "hello"; + options.toVector(args, false); + + PoolOptions options2(args); + ensure_equals(options2.appRoot, "hello"); + ensure_equals(options2.environmentVariables, StringListCreatorPtr()); + } + + // Calling toVector() with storeEnvVars = false on a PoolOption object that + // has no environment variables works, and the resulting data can be unserialized. + TEST_METHOD(6) { + PoolOptions options; + SimpleStringListCreatorPtr list = ptr(new SimpleStringListCreator()); + vector<string> args; + list->items->push_back("hello"); + list->items->push_back("world"); + list->items->push_back("foo"); + list->items->push_back("bar"); + options.appRoot = "hello"; + options.environmentVariables = list; + options.toVector(args, false); + + PoolOptions options2(args); + ensure_equals(options2.appRoot, "hello"); + ensure_equals(options2.environmentVariables, StringListCreatorPtr()); + } } test/PoolOptionsTest.cpp @@ -93,6 +93,18 @@ describe "mod_passenger running in Apache 2" do end end end + + it "supports environment variable passing through mod_env" do + begin + File.open("#{@stub.app_root}/public/.htaccess", 'w') do |f| + f.puts 'SetEnv FOO "Foo Bar!"' + end + File.touch("#{@stub.app_root}/tmp/restart.txt") + get('/welcome/environment').should =~ /FOO = Foo Bar\!/ + ensure + File.unlink("#{@stub.app_root}/public/.htaccess") rescue nil + end + end end describe ": MyCook(tm) beta running in a sub-URI" do @@ -199,7 +211,8 @@ describe "mod_passenger running in Apache 2" do }) end - File.open(restart_file, 'w').close + now = Time.now + File.touch(restart_file, now - 5) get('/bar').should == "hello world" File.open(controller, 'w') do |f| @@ -212,9 +225,7 @@ describe "mod_passenger running in Apache 2" do }) end - now = Time.now - File.open(restart_file, 'w').close - File.utime(now - 10, now - 10, restart_file) + File.touch(restart_file, now - 10) get('/bar').should == "oh hai" ensure File.unlink(controller) rescue nil test/integration_tests/apache2_tests.rb @@ -124,8 +124,7 @@ shared_examples_for "MyCook(tm) beta" do end } end - File.open(restart_file, 'w').close - File.utime(now - 10, now - 10, restart_file) + File.touch(restart_file, now - 10) get('/test').should == "foo" File.open(controller, 'w') do |f| @@ -139,7 +138,7 @@ shared_examples_for "MyCook(tm) beta" do } end - File.utime(now - 5, now - 5, restart_file) + File.touch(restart_file, now - 5) get('/test').should == 'bar' ensure File.unlink(controller) rescue nil @@ -165,7 +164,7 @@ shared_examples_for "MyCook(tm) beta" do }) end begin - system "touch '#{@stub.app_root}/tmp/restart.txt'" + File.touch("#{@stub.app_root}/tmp/restart.txt") get('/welcome/passenger_name').should == 'Gourry Gabriev' ensure File.unlink("#{@stub.app_root}/app/models/passenger.rb") rescue nil test/integration_tests/mycook_spec.rb @@ -34,6 +34,23 @@ describe PhusionPassenger::Rack::ApplicationSpawner do config_ru_owner.should == touch_txt_owner end if Process.euid == 0 + it "sets the environment variables passed in the environment_variables option" do + File.append("#{@stub.app_root}/config.ru", %q{ + File.open("env.txt", "w") do |f| + ENV.each_pair do |key, value| + f.puts("#{key} = #{value}") + end + end + }) + env_vars_string = "PATH\0/usr/bin:/opt/sw/bin\0FOO\0foo bar!\0" + options = { "environment_variables" => [env_vars_string].pack("m") } + spawn(@stub.app_root, options).close + + contents = File.read("#{@stub.app_root}/env.txt") + contents.should =~ %r(PATH = /usr/bin:/opt/sw/bin\n) + contents.should =~ %r(FOO = foo bar\!\n) + end + it "calls the starting_worker_process event after config.ru has been loaded" do File.append("#{@stub.app_root}/config.ru", %q{ PhusionPassenger.on_event(:starting_worker_process) do @@ -74,9 +91,9 @@ describe PhusionPassenger::Rack::ApplicationSpawner do "worker_process_stopped\n" end - def spawn(app_root) - PhusionPassenger::Rack::ApplicationSpawner.spawn_application(app_root, - "lowest_user" => CONFIG['lowest_user']) + def spawn(app_root, extra_options = {}) + options = { "lowest_user" => CONFIG['lowest_user'] }.merge(extra_options) + PhusionPassenger::Rack::ApplicationSpawner.spawn_application(app_root, options) end end test/ruby/rack/application_spawner_spec.rb @@ -69,9 +69,9 @@ describe ApplicationSpawner do end end - def spawn_stub_application(stub) - @spawner = ApplicationSpawner.new(stub.app_root, - "lowest_user" => CONFIG['lowest_user']) + def spawn_stub_application(stub, extra_options = {}) + options = { "lowest_user" => CONFIG['lowest_user'] }.merge(extra_options) + @spawner = ApplicationSpawner.new(stub.app_root, options) begin @spawner.start return @spawner.spawn_application @@ -107,9 +107,9 @@ describe ApplicationSpawner do end end - def spawn_stub_application(stub) - @spawner = ApplicationSpawner.new(stub.app_root, - "lowest_user" => CONFIG['lowest_user']) + def spawn_stub_application(stub, extra_options = {}) + options = { "lowest_user" => CONFIG['lowest_user'] }.merge(extra_options) + @spawner = ApplicationSpawner.new(stub.app_root, options) return @spawner.spawn_application! end end test/ruby/rails/application_spawner_spec.rb @@ -76,7 +76,7 @@ describe FrameworkSpawner do it_should_behave_like "handling errors in framework initialization" end - def spawn_stub_application(stub) + def spawn_stub_application(stub, extra_options = {}) if use_vendor_rails? stub.use_vendor_rails('minimal') end @@ -86,11 +86,12 @@ describe FrameworkSpawner do else options = { :version => version } end + options["lowest_user"] = CONFIG['lowest_user'] + options = options.merge(extra_options) spawner = FrameworkSpawner.new(options) spawner.start begin - return spawner.spawn_application(stub.app_root, - "lowest_user" => CONFIG['lowest_user']) + return spawner.spawn_application(stub.app_root, options) ensure spawner.stop end test/ruby/rails/framework_spawner_spec.rb @@ -71,4 +71,23 @@ shared_examples_for "a minimal spawner" do lambda { spawn_stub_application(stub).close }.should_not raise_error end end + + it "sets the environment variables passed in the environment_variables option" do + use_rails_stub('foobar') do |stub| + File.append(stub.environment_rb, %q{ + File.open("env.txt", "w") do |f| + ENV.each_pair do |key, value| + f.puts("#{key} = #{value}") + end + end + }) + env_vars_string = "PATH\0/usr/bin:/opt/sw/bin\0FOO\0foo bar!\0" + options = { "environment_variables" => [env_vars_string].pack("m") } + spawn_stub_application(stub, options).close + + contents = File.read("#{stub.app_root}/env.txt") + contents.should =~ %r(PATH = /usr/bin:/opt/sw/bin\n) + contents.should =~ %r(FOO = foo bar\!\n) + end + end end test/ruby/rails/minimal_spawner_spec.rb @@ -169,13 +169,15 @@ describe SpawnManager do it_should_behave_like "handling errors in application initialization" it_should_behave_like "handling errors in framework initialization" - def spawn_stub_application(stub) + def spawn_stub_application(stub, extra_options = {}) spawner = SpawnManager.new begin - return spawner.spawn_application( + options = { "app_root" => stub.app_root, "spawn_method" => @spawn_method, - "lowest_user" => CONFIG['lowest_user']) + "lowest_user" => CONFIG['lowest_user'] + }.merge(extra_options) + return spawner.spawn_application(options) ensure spawner.cleanup end test/ruby/spawn_manager_spec.rb @@ -23,6 +23,9 @@ Listen 127.0.0.1:<%= @port %> <% if !has_builtin_module?('mod_rewrite.c') && has_module?('mod_rewrite.so') %> LoadModule rewrite_module "<%= modules_dir %>/mod_rewrite.so" <% end %> +<% if !has_builtin_module?('mod_env.c') %> + LoadModule env_module "<%= modules_dir %>/mod_env.so" +<% end %> LoadModule passenger_module "<%= @mod_passenger %>" PassengerRoot "<%= @passenger_root %>" test/stub/apache2/httpd.conf.erb @@ -40,6 +40,14 @@ class WelcomeController < ApplicationController def show_id render :text => params[:id] end + + def environment + text = "" + ENV.each_pair do |key, value| + text << "#{key} = #{value}\n" + end + render :text => text + end def request_uri render :text => request.request_uri test/stub/rails_apps/mycook/app/controllers/welcome_controller.rb @@ -62,6 +62,36 @@ public: }; /** + * Creates a temporary copy of the given directory. This copy is deleted + * upon object destruction. + */ +class TempDirCopy { +private: + string dir; + + void rm_rf(const string &dir) { + string command("rm -rf \""); + command.append(dir); + command.append("\""); + system(command.c_str()); + } +public: + TempDirCopy(const string &source, const string &dest) { + dir = dest; + rm_rf(dest); + + char command[1024]; + snprintf(command, sizeof(command), "cp -pR \"%s\" \"%s\"", + source.c_str(), dest.c_str()); + system(command); + } + + ~TempDirCopy() { + rm_rf(dir); + } +}; + +/** * Class which deletes the given file upon destruction. */ class DeleteFileEventually { test/support/Support.h @@ -169,5 +169,10 @@ File.class_eval do f.write(content) end end + + def self.touch(filename, timestamp = nil) + File.open(filename, 'w').close + File.utime(timestamp, timestamp, filename) if timestamp + end end test/support/test_helper.rb 0d1371fb6e4f0cf8f521508bfeec4d39aa77d8c1 Hongli Lai (Phusion) hongli@phusion.nl http://github.com/FooBarWidget/passenger/commit/f0859191f8f31f047bbcd9564839c1e8b1462fbd f0859191f8f31f047bbcd9564839c1e8b1462fbd 2009-05-12T07:45:15-07:00 2009-04-25T11:16:48-07:00 Make it possible to pass mod_env environment variables to the backend process. 65eb04018b3e375a791cf9fa930da526d2481f85 Hongli Lai (Phusion) hongli@phusion.nl