pkg/passenger-2.2.2/test/stub/rails_apps/foobar/log/.gitignore @@ -26,11 +26,9 @@ test/CxxTests test/ApplicationPoolServerExecutable test/oxt/oxt_test_main test/stub/railsapp/app/controllers/bar_controller.rb -test/stub/*/log/* test/stub/apache2/*.log test/stub/apache2/*.pid test/stub/apache2/httpd.conf -test/stub/mycook/log test/stub/zsfa/mycook test/stub/zsfa/foo pkg .gitignore @@ -701,19 +701,10 @@ spec = Gem::Specification.new do |s| 'test/*.{rb,cpp,example}', 'test/support/*.{cpp,h,rb}', 'test/oxt/*.cpp', - 'test/ruby/*', - 'test/ruby/*/*', - 'test/integration_tests/*', - 'test/stub/*', - 'test/stub/*/*', - 'test/stub/*/*/*', - 'test/stub/*/*/*/*', - 'test/stub/*/*/*/*/*', - 'test/stub/*/*/*/*/*/*', - 'test/stub/*/*/*/*/*/*/*' - ] - Dir['test/stub/*/log/*'] \ - - Dir['test/stub/*/tmp/*/*'] \ - - Dir['test/stub/apache2/*.{pid,lock,log}'] + 'test/ruby/**/*', + 'test/integration_tests/**/*', + 'test/stub/**/*' + ] s.executables = [ 'passenger-spawn-server', 'passenger-install-apache2-module', Rakefile @@ -12,7 +12,8 @@ * This file is used as a template to test the different ApplicationPool implementations. * It is #included in StandardApplicationPoolTest.cpp and ApplicationServer_ApplicationPoolTest.cpp */ -#ifdef USE_TEMPLATE +#ifdef USE_TEMPLATE + /** Create some stub request headers. */ static string createRequestHeaders(const char *uri = "/foo/new") { string headers; #define ADD_HEADER(name, value) \ @@ -25,29 +26,11 @@ ADD_HEADER("REQUEST_URI", uri); ADD_HEADER("REQUEST_METHOD", "GET"); ADD_HEADER("REMOTE_ADDR", "localhost"); + ADD_HEADER("SCRIPT_NAME", ""); ADD_HEADER("PATH_INFO", uri); return headers; } - static string readAll(int fd) { - string result; - char buf[1024 * 32]; - ssize_t ret; - while (true) { - do { - ret = read(fd, buf, sizeof(buf)); - } while (ret == -1 && errno == EINTR); - if (ret == 0) { - break; - } else if (ret == -1) { - throw SystemException("Cannot read from socket", errno); - } else { - result.append(buf, ret); - } - } - return result; - } - static Application::SessionPtr spawnRackApp(ApplicationPoolPtr pool, const char *appRoot) { PoolOptions options; options.appRoot = appRoot; @@ -61,17 +44,17 @@ options.appType = "wsgi"; return pool->get(options); } - + TEST_METHOD(1) { // Calling ApplicationPool.get() once should return a valid Session. - Application::SessionPtr session(pool->get("stub/railsapp")); + Application::SessionPtr session(spawnRackApp(pool, "stub/rack")); session->sendHeaders(createRequestHeaders()); session->shutdownWriter(); int reader = session->getStream(); string result(readAll(reader)); session->closeStream(); - ensure(result.find("hello world") != string::npos); + ensure(result.find("hello world") != string::npos); } TEST_METHOD(2) { @@ -99,26 +82,29 @@ // If we call get() with an application root, then we call get() again before closing // the session, then the pool should have spawned 2 apps in total. Application::SessionPtr session(spawnRackApp(pool, "stub/rack")); - Application::SessionPtr session2(spawnRackApp(pool, "stub/rack")); + Application::SessionPtr session2(spawnRackApp(pool2, "stub/rack")); ensure_equals(pool->getCount(), 2u); } TEST_METHOD(5) { // If we call get() twice with different application roots, // then the pool should spawn two different apps. - Application::SessionPtr session(pool->get("stub/railsapp")); - Application::SessionPtr session2(pool2->get("stub/railsapp2")); + TempDirCopy c1("stub/rack", "rackapp1.tmp"); + TempDirCopy c2("stub/rack", "rackapp2.tmp"); + replaceStringInFile("rackapp2.tmp/config.ru", "world", "world 2"); + Application::SessionPtr session(spawnRackApp(pool, "rackapp1.tmp")); + Application::SessionPtr session2(spawnRackApp(pool2, "rackapp2.tmp")); ensure_equals("Before the sessions were closed, both apps were busy", pool->getActive(), 2u); ensure_equals("Before the sessions were closed, both apps were in the pool", pool->getCount(), 2u); session->sendHeaders(createRequestHeaders()); string result(readAll(session->getStream())); - ensure("Session 1 belongs to the correct app", result.find("hello world") != string::npos); + ensure("Session 1 belongs to the correct app", result.find("hello world") != string::npos); session.reset(); session2->sendHeaders(createRequestHeaders()); result = readAll(session2->getStream()); - ensure("Session 2 belongs to the correct app", result.find("this is railsapp2") != string::npos); + ensure("Session 2 belongs to the correct app", result.find("hello world 2") != string::npos); session2.reset(); } @@ -126,12 +112,14 @@ // If we call get() twice with different application roots, // and we close both sessions, then both 2 apps should still // be in the pool. - Application::SessionPtr session(pool->get("stub/railsapp")); - Application::SessionPtr session2(pool->get("stub/railsapp2")); + TempDirCopy c1("stub/rack", "rackapp1.tmp"); + TempDirCopy c2("stub/rack", "rackapp2.tmp"); + Application::SessionPtr session(spawnRackApp(pool, "rackapp1.tmp")); + Application::SessionPtr session2(spawnRackApp(pool, "rackapp2.tmp")); session.reset(); session2.reset(); - ensure_equals(pool->getActive(), 0u); - ensure_equals(pool->getCount(), 2u); + ensure_equals("There are 0 active apps", pool->getActive(), 0u); + ensure_equals("There are 2 apps in total", pool->getCount(), 2u); } TEST_METHOD(7) { @@ -150,26 +138,26 @@ // But the get() thereafter should not: // ApplicationPool should have spawned a new instance // after detecting that the original one died. - Application::SessionPtr session(pool->get("stub/railsapp")); + Application::SessionPtr session(spawnRackApp(pool, "stub/rack")); kill(session->getPid(), SIGTERM); session.reset(); try { - session = pool->get("stub/railsapp"); + session = spawnRackApp(pool, "stub/rack"); fail("ApplicationPool::get() is supposed to " "throw an exception because we killed " "the app instance."); } catch (const exception &e) { - session = pool->get("stub/railsapp"); + session = spawnRackApp(pool, "stub/rack"); // Should not throw. } } - struct TestThread1 { + struct PoolWaitTestThread { ApplicationPoolPtr pool; Application::SessionPtr &m_session; bool &m_done; - TestThread1(const ApplicationPoolPtr &pool, + PoolWaitTestThread(const ApplicationPoolPtr &pool, Application::SessionPtr &session, bool &done) : m_session(session), m_done(done) { @@ -194,12 +182,13 @@ Application::SessionPtr session3; bool done; - thread *thr = new thread(TestThread1(pool2, session3, done)); + shared_ptr<thread> thr = ptr(new thread(PoolWaitTestThread(pool2, session3, done))); usleep(500000); - ensure("ApplicationPool is waiting", !done); + ensure("ApplicationPool is still waiting", !done); ensure_equals(pool->getActive(), 2u); ensure_equals(pool->getCount(), 2u); + // Now release one slot from the pool. session1.reset(); // Wait at most 10 seconds. @@ -213,7 +202,7 @@ ensure_equals(pool->getCount(), 2u); thr->join(); - delete thr; + thr.reset(); } TEST_METHOD(10) { @@ -221,25 +210,27 @@ // * the pool is already full, but there are inactive apps // (active < count && count == max) // and - // * the application root is *not* already in the pool + // * the application root for this get() is *not* already in the pool // then the an inactive app should be killed in order to // satisfy this get() command. + TempDirCopy c1("stub/rack", "rackapp1.tmp"); + TempDirCopy c2("stub/rack", "rackapp2.tmp"); pool->setMax(2); - Application::SessionPtr session1(pool->get("stub/railsapp")); - Application::SessionPtr session2(pool->get("stub/railsapp")); + Application::SessionPtr session1(spawnRackApp(pool, "rackapp1.tmp")); + Application::SessionPtr session2(spawnRackApp(pool, "rackapp1.tmp")); session1.reset(); session2.reset(); ensure_equals(pool->getActive(), 0u); ensure_equals(pool->getCount(), 2u); - session1 = pool2->get("stub/railsapp2"); + session1 = spawnRackApp(pool, "rackapp2.tmp"); ensure_equals(pool->getActive(), 1u); ensure_equals(pool->getCount(), 2u); } TEST_METHOD(11) { - // Test whether Session is still usable after the Application has been destroyed. - Application::SessionPtr session(pool->get("stub/railsapp")); + // A Session should still be usable after the pool has been destroyed. + Application::SessionPtr session(spawnRackApp(pool, "stub/rack")); pool->clear(); pool.reset(); pool2.reset(); @@ -250,27 +241,27 @@ int reader = session->getStream(); string result(readAll(reader)); session->closeStream(); - ensure(result.find("hello world") != string::npos); + ensure(result.find("hello world") != string::npos); } TEST_METHOD(12) { // If tmp/restart.txt didn't exist but has now been created, // then the applications under app_root should be restarted. struct stat buf; - Application::SessionPtr session1 = pool->get("stub/railsapp"); - Application::SessionPtr session2 = pool2->get("stub/railsapp"); + TempDirCopy c("stub/rack", "rackapp.tmp"); + Application::SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp"); + Application::SessionPtr session2 = spawnRackApp(pool, "rackapp.tmp"); session1.reset(); session2.reset(); - DeleteFileEventually f("stub/railsapp/tmp/restart.txt"); - touchFile("stub/railsapp/tmp/restart.txt"); - pool->get("stub/railsapp"); + touchFile("rackapp.tmp/tmp/restart.txt"); + spawnRackApp(pool, "rackapp.tmp"); ensure_equals("No apps are active", pool->getActive(), 0u); ensure_equals("Both apps are killed, and a new one was spawned", pool->getCount(), 1u); ensure("Restart file still exists", - stat("stub/railsapp/tmp/restart.txt", &buf) == 0); + stat("rackapp.tmp/tmp/restart.txt", &buf) == 0); } TEST_METHOD(13) { @@ -279,51 +270,213 @@ // should still be restarted. However, a subsequent get() // should not result in a restart. pid_t old_pid; - - TempDir d("stub/railsapp/tmp/restart.txt"); - Application::SessionPtr session = pool->get("stub/railsapp"); + TempDirCopy c("stub/rack", "rackapp.tmp"); + TempDir d("rackapp.tmp/tmp/restart.txt"); + Application::SessionPtr session = spawnRackApp(pool, "rackapp.tmp"); old_pid = session->getPid(); session.reset(); - struct utimbuf buf; - buf.actime = time(NULL) - 10; - buf.modtime = time(NULL) - 10; - utime("stub/railsapp/tmp/restart.txt", &buf); + touchFile("rackapp.tmp/tmp/restart.txt", 10); - session = pool->get("stub/railsapp"); + session = spawnRackApp(pool, "rackapp.tmp"); ensure("The app was restarted", session->getPid() != old_pid); old_pid = session->getPid(); session.reset(); - session = pool->get("stub/railsapp"); + session = spawnRackApp(pool, "rackapp.tmp"); ensure_equals("The app was not restarted", old_pid, session->getPid()); } TEST_METHOD(15) { - // Test whether restarting really results in code reload. - DeleteFileEventually f1("stub/railsapp/app/controllers/bar_controller.rb"); - DeleteFileEventually f2("stub/railsapp/tmp/restart.txt"); - - system("cp -f stub/railsapp/app/controllers/bar_controller_1.txt " - "stub/railsapp/app/controllers/bar_controller.rb"); - Application::SessionPtr session = pool->get("stub/railsapp"); - session->sendHeaders(createRequestHeaders("/bar")); + // Test whether restarting with restart.txt really results in code reload. + TempDirCopy c("stub/rack", "rackapp.tmp"); + Application::SessionPtr session = spawnRackApp(pool, "rackapp.tmp"); + session->sendHeaders(createRequestHeaders()); string result = readAll(session->getStream()); - ensure(result.find("bar 1!") != string::npos); + ensure(result.find("hello world") != string::npos); session.reset(); - system("cp -f stub/railsapp/app/controllers/bar_controller_2.txt " - "stub/railsapp/app/controllers/bar_controller.rb"); - system("touch stub/railsapp/tmp/restart.txt"); + touchFile("rackapp.tmp/tmp/restart.txt"); + replaceStringInFile("rackapp.tmp/config.ru", "world", "world 2"); - session = pool->get("stub/railsapp"); - session->sendHeaders(createRequestHeaders("/bar")); + session = spawnRackApp(pool, "rackapp.tmp"); + session->sendHeaders(createRequestHeaders()); result = readAll(session->getStream()); - ensure("App code has been reloaded", result.find("bar 2!") != string::npos); + ensure("App code has been reloaded", result.find("hello world 2") != string::npos); } TEST_METHOD(16) { + // If tmp/always_restart.txt is present and is a file, + // then the application under app_root should be always restarted. + struct stat buf; + pid_t old_pid; + TempDirCopy c("stub/rack", "rackapp.tmp"); + Application::SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp"); + Application::SessionPtr session2 = spawnRackApp(pool2, "rackapp.tmp"); + session1.reset(); + session2.reset(); + + touchFile("rackapp.tmp/tmp/always_restart.txt"); + + // This get() results in a restart. + session1 = spawnRackApp(pool, "rackapp.tmp"); + old_pid = session1->getPid(); + session1.reset(); + ensure_equals("First restart: no apps are active", pool->getActive(), 0u); + ensure_equals("First restart: the first 2 apps were killed, and a new one was spawned", + pool->getCount(), 1u); + ensure("always_restart file has not been deleted", + stat("rackapp.tmp/tmp/always_restart.txt", &buf) == 0); + + // This get() results in a restart as well. + session1 = spawnRackApp(pool, "rackapp.tmp"); + ensure(old_pid != session1->getPid()); + session1.reset(); + ensure_equals("Second restart: no apps are active", pool->getActive(), 0u); + ensure_equals("Second restart: the last app was killed, and a new one was spawned", + pool->getCount(), 1u); + ensure("always_restart file has not been deleted", + stat("rackapp.tmp/tmp/always_restart.txt", &buf) == 0); + } + + TEST_METHOD(17) { + // If tmp/always_restart.txt is present and is a directory, + // then the application under app_root should be always restarted. + struct stat buf; + pid_t old_pid; + TempDirCopy c("stub/rack", "rackapp.tmp"); + Application::SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp"); + Application::SessionPtr session2 = spawnRackApp(pool, "rackapp.tmp"); + session1.reset(); + session2.reset(); + + TempDir d("rackapp.tmp/tmp/always_restart.txt"); + + // This get() results in a restart. + session1 = spawnRackApp(pool, "rackapp.tmp"); + old_pid = session1->getPid(); + session1.reset(); + ensure_equals("First restart: no apps are active", pool->getActive(), 0u); + ensure_equals("First restart: the first 2 apps were killed, and a new one was spawned", + pool->getCount(), 1u); + ensure("always_restart directory has not been deleted", + stat("rackapp.tmp/tmp/always_restart.txt", &buf) == 0); + + // This get() results in a restart as well. + session1 = spawnRackApp(pool, "rackapp.tmp"); + ensure(old_pid != session1->getPid()); + session1.reset(); + ensure_equals("Second restart: no apps are active", pool->getActive(), 0u); + ensure_equals("Second restart: the last app was killed, and a new one was spawned", + pool->getCount(), 1u); + ensure("always_restart directory has not been deleted", + stat("rackapp.tmp/tmp/always_restart.txt", &buf) == 0); + } + + TEST_METHOD(18) { + // Test whether restarting with tmp/always_restart.txt really results in code reload. + TempDirCopy c("stub/rack", "rackapp.tmp"); + Application::SessionPtr session = spawnRackApp(pool, "rackapp.tmp"); + session->sendHeaders(createRequestHeaders()); + string result = readAll(session->getStream()); + ensure(result.find("hello world") != string::npos); + session.reset(); + + touchFile("rackapp.tmp/tmp/always_restart.txt"); + replaceStringInFile("rackapp.tmp/config.ru", "world", "world 2"); + + session = spawnRackApp(pool, "rackapp.tmp"); + session->sendHeaders(createRequestHeaders()); + result = readAll(session->getStream()); + ensure("App code has been reloaded (1)", result.find("hello world 2") != string::npos); + session.reset(); + + replaceStringInFile("rackapp.tmp/config.ru", "world 2", "world 3"); + session = spawnRackApp(pool, "rackapp.tmp"); + session->sendHeaders(createRequestHeaders()); + result = readAll(session->getStream()); + ensure("App code has been reloaded (2)", result.find("hello world 3") != string::npos); + session.reset(); + } + + TEST_METHOD(19) { + // If tmp/restart.txt and tmp/always_restart.txt are present, + // the application under app_root should still be restarted and + // both files must be kept. + pid_t old_pid, pid; + struct stat buf; + TempDirCopy c("stub/rack", "rackapp.tmp"); + Application::SessionPtr session1 = spawnRackApp(pool, "rackapp.tmp"); + Application::SessionPtr session2 = spawnRackApp(pool2, "rackapp.tmp"); + session1.reset(); + session2.reset(); + + touchFile("rackapp.tmp/tmp/restart.txt"); + touchFile("rackapp.tmp/tmp/always_restart.txt"); + + old_pid = spawnRackApp(pool, "rackapp.tmp")->getPid(); + ensure("always_restart.txt file has not been deleted", + stat("rackapp.tmp/tmp/always_restart.txt", &buf) == 0); + ensure("restart.txt file has not been deleted", + stat("rackapp.tmp/tmp/restart.txt", &buf) == 0); + + pid = spawnRackApp(pool, "rackapp.tmp")->getPid(); + ensure("The app was restarted", pid != old_pid); + } + + TEST_METHOD(20) { + // It should look for restart.txt in the directory given by + // the restartDir option, if available. + struct stat buf; + char path[1024]; + PoolOptions options("stub/rack"); + options.appType = "rack"; + options.restartDir = string(getcwd(path, sizeof(path))) + "/stub/rack"; + + Application::SessionPtr session1 = pool->get(options); + Application::SessionPtr session2 = pool2->get(options); + session1.reset(); + session2.reset(); + + DeleteFileEventually f("stub/rack/restart.txt"); + touchFile("stub/rack/restart.txt"); + + pool->get(options); + + ensure_equals("No apps are active", pool->getActive(), 0u); + ensure_equals("Both apps are killed, and a new one was spawned", + pool->getCount(), 1u); + ensure("Restart file still exists", + stat("stub/rack/restart.txt", &buf) == 0); + } + + TEST_METHOD(21) { + // restartDir may also be a directory relative to the + // application root. + struct stat buf; + PoolOptions options("stub/rack"); + options.appType = "rack"; + options.restartDir = "public"; + + Application::SessionPtr session1 = pool->get(options); + Application::SessionPtr session2 = pool2->get(options); + session1.reset(); + session2.reset(); + + DeleteFileEventually f("stub/rack/public/restart.txt"); + touchFile("stub/rack/public/restart.txt"); + + pool->get(options); + + ensure_equals("No apps are active", pool->getActive(), 0u); + ensure_equals("Both apps are killed, and a new one was spawned", + pool->getCount(), 1u); + ensure("Restart file still exists", + stat("stub/rack/public/restart.txt", &buf) == 0); + } + + TEST_METHOD(22) { // The cleaner thread should clean idle applications without crashing. pool->setMaxIdleTime(1); spawnRackApp(pool, "stub/rack"); @@ -335,7 +488,7 @@ ensure_equals("App should have been cleaned up", pool->getCount(), 0u); } - TEST_METHOD(17) { + TEST_METHOD(23) { // MaxPerApp is respected. pool->setMax(3); pool->setMaxPerApp(1); @@ -349,18 +502,20 @@ // We connect to stub/wsgi. Assert that the pool spawns a new // instance for this app. + TempDirCopy c("stub/wsgi", "wsgiapp.tmp"); ApplicationPoolPtr pool3(newPoolConnection()); - Application::SessionPtr session3 = spawnWsgiApp(pool3, "stub/wsgi"); + Application::SessionPtr session3 = spawnWsgiApp(pool3, "wsgiapp.tmp"); ensure_equals(pool->getCount(), 2u); } - TEST_METHOD(18) { + TEST_METHOD(24) { // Application instance is shutdown after 'maxRequests' requests. - PoolOptions options("stub/railsapp"); + PoolOptions options("stub/rack"); int reader; pid_t originalPid; Application::SessionPtr session; + options.appType = "rack"; options.maxRequests = 4; pool->setMax(1); session = pool->get(options); @@ -401,7 +556,7 @@ } }; - TEST_METHOD(19) { + TEST_METHOD(25) { // If global queueing mode is enabled, then get() waits until // there's at least one idle backend process for this application // domain. @@ -429,160 +584,6 @@ thr.join(); } - TEST_METHOD(20) { - // If tmp/always_restart.txt is present, then the application under app_root - // should be always restarted. - try { - struct stat buf; - Application::SessionPtr session1 = pool->get("stub/railsapp"); - Application::SessionPtr session2 = pool2->get("stub/railsapp"); - session1.reset(); - session2.reset(); - - system("touch stub/railsapp/tmp/always_restart.txt"); - pool->get("stub/railsapp"); - - ensure_equals("No apps are active", pool->getActive(), 0u); - ensure_equals("Both apps are killed, and a new one was spawned", - pool->getCount(), 1u); - ensure("always_restart file has not been deleted", - stat("stub/railsapp/tmp/always_restart.txt", &buf) == 0); - unlink("stub/railsapp/tmp/always_restart.txt"); - } catch (...) { - unlink("stub/railsapp/tmp/always_restart.txt"); - throw; - } - } - - TEST_METHOD(21) { - // If tmp/always_restart.txt is present and is a directory, - // then the application under app_root - // should be always restarted. - struct stat buf; - Application::SessionPtr session1 = pool->get("stub/railsapp"); - Application::SessionPtr session2 = pool2->get("stub/railsapp"); - session1.reset(); - session2.reset(); - - TempDir dir("stub/railsapp/tmp/always_restart.txt"); - pool->get("stub/railsapp"); - - ensure_equals("No apps are active", pool->getActive(), 0u); - ensure_equals("Both apps are killed, and a new one was spawned", - pool->getCount(), 1u); - ensure("always_restart file has not been deleted", - stat("stub/railsapp/tmp/always_restart.txt", &buf) == 0); - } - - TEST_METHOD(22) { - // Test whether tmp/always_restart.txt really results in code reload. - DeleteFileEventually f1("stub/railsapp/app/controllers/bar_controller.rb"); - DeleteFileEventually f2("stub/railsapp/tmp/always_restart.txt"); - - system("cp -f stub/railsapp/app/controllers/bar_controller_1.txt " - "stub/railsapp/app/controllers/bar_controller.rb"); - Application::SessionPtr session = pool->get("stub/railsapp"); - session->sendHeaders(createRequestHeaders("/bar")); - string result = readAll(session->getStream()); - ensure(result.find("bar 1!") != string::npos); - session.reset(); - - system("cp -f stub/railsapp/app/controllers/bar_controller_2.txt " - "stub/railsapp/app/controllers/bar_controller.rb"); - touchFile("stub/railsapp/tmp/always_restart.txt"); - session = pool->get("stub/railsapp"); - session->sendHeaders(createRequestHeaders("/bar")); - result = readAll(session->getStream()); - ensure("App code has been reloaded (1)", result.find("bar 2!") != string::npos); - session.reset(); - - system("cp -f stub/railsapp/app/controllers/bar_controller_1.txt " - "stub/railsapp/app/controllers/bar_controller.rb"); - session = pool->get("stub/railsapp"); - session->sendHeaders(createRequestHeaders("/bar")); - result = readAll(session->getStream()); - ensure("App code has been reloaded (2)", result.find("bar 1!") != string::npos); - session.reset(); - } - - TEST_METHOD(23) { - // If tmp/restart.txt and tmp/always_restart.txt are present, - // the application under app_root should still be restarted and - // both files must be kept - pid_t old_pid, pid; - struct stat buf; - Application::SessionPtr session1 = pool->get("stub/railsapp"); - Application::SessionPtr session2 = pool2->get("stub/railsapp"); - session1.reset(); - session2.reset(); - - DeleteFileEventually f1("stub/railsapp/tmp/restart.txt"); - DeleteFileEventually f2("stub/railsapp/tmp/always_restart.txt"); - touchFile("stub/railsapp/tmp/restart.txt"); - touchFile("stub/railsapp/tmp/always_restart.txt"); - - old_pid = pool->get("stub/railsapp")->getPid(); - ensure("always_restart file has not been deleted", - stat("stub/railsapp/tmp/always_restart.txt", &buf) == 0); - - ensure("Restart file has not been deleted", - stat("stub/railsapp/tmp/restart.txt", &buf) == 0); - - pid = pool->get("stub/railsapp")->getPid(); - ensure("The app was restarted", pid != old_pid); - } - - TEST_METHOD(24) { - // It should look for restart.txt in the directory given by - // the restartDir option, if available. - struct stat buf; - char path[1024]; - PoolOptions options("stub/rack"); - options.appType = "rack"; - options.restartDir = string(getcwd(path, sizeof(path))) + "/stub/rack"; - - Application::SessionPtr session1 = pool->get(options); - Application::SessionPtr session2 = pool2->get(options); - session1.reset(); - session2.reset(); - - DeleteFileEventually f("stub/rack/restart.txt"); - touchFile("stub/rack/restart.txt"); - - pool->get(options); - - ensure_equals("No apps are active", pool->getActive(), 0u); - ensure_equals("Both apps are killed, and a new one was spawned", - pool->getCount(), 1u); - ensure("Restart file still exists", - stat("stub/rack/restart.txt", &buf) == 0); - } - - TEST_METHOD(25) { - // restartDir may also be a directory relative to the - // application root. - struct stat buf; - PoolOptions options("stub/rack"); - options.appType = "rack"; - options.restartDir = "public"; - - Application::SessionPtr session1 = pool->get(options); - Application::SessionPtr session2 = pool2->get(options); - session1.reset(); - session2.reset(); - - DeleteFileEventually f("stub/rack/public/restart.txt"); - touchFile("stub/rack/public/restart.txt"); - - pool->get(options); - - ensure_equals("No apps are active", pool->getActive(), 0u); - ensure_equals("Both apps are killed, and a new one was spawned", - pool->getCount(), 1u); - ensure("Restart file still exists", - stat("stub/rack/public/restart.txt", &buf) == 0); - } - /*************************************/ #endif /* USE_TEMPLATE */ test/ApplicationPoolTest.cpp @@ -1,17 +1,76 @@ +#include <unistd.h> #include "Support.h" namespace Test { +string +readAll(int fd) { + string result; + char buf[1024 * 32]; + ssize_t ret; + while (true) { + do { + ret = read(fd, buf, sizeof(buf)); + } while (ret == -1 && errno == EINTR); + if (ret == 0) { + break; + } else if (ret == -1) { + throw SystemException("Cannot read from socket", errno); + } else { + result.append(buf, ret); + } + } + return result; +} + +string +replaceString(const string &str, const string &toFind, const string &replaceWith) { + string::size_type pos = str.find(toFind); + if (pos == string::npos) { + return str; + } else { + string result(str); + return result.replace(pos, toFind.size(), replaceWith); + } +} + +void +replaceStringInFile(const char *filename, const string &toFind, const string &replaceWith) { + FILE *f = fopen(filename, "r"); + if (f == NULL) { + int e = errno; + string message = "Cannot open file '"; + message.append(filename); + message.append("' for reading"); + throw FileSystemException(message, e, filename); + } + string content(readAll(fileno(f))); + fclose(f); + + f = fopen(filename, "w"); + if (f == NULL) { + int e = errno; + string message = "Cannot open file '"; + message.append(filename); + message.append("' for writing"); + throw FileSystemException(message, e, filename); + } + content = replaceString(content, toFind, replaceWith); + fwrite(content.data(), 1, content.size(), f); + fclose(f); +} + void touchFile(const char *filename, time_t timestamp) { FILE *f = fopen(filename, "a"); if (f != NULL) { fclose(f); - } else { + } else if (errno != EISDIR) { int e = errno; - cerr << "Cannot touch file '" << filename << "': " << - strerror(e) <<" (" << e << ")" << endl; - throw exception(); + string message = "Cannot touch file '"; + message.append(filename); + message.append("'"); + throw FileSystemException(message, e, filename); } if (timestamp != (time_t) -1) { test/support/Support.cpp @@ -11,6 +11,7 @@ #include <cstring> #include <utime.h> +#include "Exceptions.h" #include "Utils.h" namespace Test { @@ -18,6 +19,35 @@ namespace Test { using namespace std; using namespace Passenger; +/** + * Read all data from the given file descriptor until EOF. + * + * @throws SystemException + */ +string readAll(int fd); + +/** + * Look for 'toFind' inside 'str', replace it with 'replaceWith' and return the result. + * Only the first occurence of 'toFind' is replaced. + */ +string replaceString(const string &str, const string &toFind, const string &replaceWith); + +/** + * Look for 'toFind' inside the given file, replace it with 'replaceWith' and write + * the result back to the file. Only the first occurence of 'toFind' is replaced. + * + * @throws FileSystemException + */ +void replaceStringInFile(const char *filename, const string &toFind, const string &replaceWith); + +/** + * Touch the given file: create the file if it doesn't exist, update its + * timestamp if it does. If the <tt>timestamp</tt> argument is -1, then + * the current system time will be used, otherwise the given timestamp + * will be used. + * + * @throws FileSystemException + */ void touchFile(const char *filename, time_t timestamp = (time_t) - 1); /** @@ -32,9 +62,10 @@ public: this->name = name; if (mkdir(name.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) != 0) { int e = errno; - cerr << "Cannot create directory '" << name << "': " << - strerror(e) <<" (" << e << ")" << endl; - throw exception(); + string message = "Cannot create directory '"; + message.append(name); + message.append("'"); + throw FileSystemException(message, e, name); } } test/support/Support.h test/stub/minimal-railsapp/README test/stub/minimal-railsapp/config/application.rb test/stub/minimal-railsapp/config/environment.rb test/stub/minimal-railsapp/vendor/rails/actionmailer/lib/action_mailer.rb test/stub/minimal-railsapp/vendor/rails/actionpack/lib/action_controller.rb test/stub/minimal-railsapp/vendor/rails/actionpack/lib/action_pack.rb test/stub/minimal-railsapp/vendor/rails/actionpack/lib/action_view.rb test/stub/minimal-railsapp/vendor/rails/activerecord/lib/active_record.rb test/stub/minimal-railsapp/vendor/rails/activeresource/lib/active_resource.rb test/stub/minimal-railsapp/vendor/rails/activesupport/lib/active_support.rb test/stub/minimal-railsapp/vendor/rails/activesupport/lib/active_support/whiny_nil.rb test/stub/minimal-railsapp/vendor/rails/railties/lib/dispatcher.rb test/stub/minimal-railsapp/vendor/rails/railties/lib/initializer.rb test/stub/minimal-railsapp/vendor/rails/railties/lib/ruby_version_check.rb test/stub/railsapp/app/controllers/application.rb test/stub/railsapp/app/controllers/bar_controller_1.txt test/stub/railsapp/app/controllers/bar_controller_2.txt test/stub/railsapp/app/controllers/foo_controller.rb test/stub/railsapp/app/helpers/application_helper.rb test/stub/railsapp/config/boot.rb test/stub/railsapp/config/database.yml test/stub/railsapp/config/environment.rb test/stub/railsapp/config/environments/development.rb test/stub/railsapp/config/environments/production.rb test/stub/railsapp/config/initializers/inflections.rb test/stub/railsapp/config/initializers/mime_types.rb test/stub/railsapp/config/routes.rb test/stub/railsapp/log/useless.txt test/stub/railsapp/public/useless.txt test/stub/railsapp/tmp/cache/useless.txt test/stub/railsapp/tmp/pids/useless.txt test/stub/railsapp/tmp/sessions/useless.txt test/stub/railsapp/tmp/sockets/useless.txt test/stub/railsapp2/app/controllers/application.rb test/stub/railsapp2/app/controllers/foo_controller.rb test/stub/railsapp2/app/helpers/application_helper.rb test/stub/railsapp2/config/boot.rb test/stub/railsapp2/config/database.yml test/stub/railsapp2/config/environment.rb test/stub/railsapp2/config/environments/development.rb test/stub/railsapp2/config/environments/production.rb test/stub/railsapp2/config/initializers/inflections.rb test/stub/railsapp2/config/initializers/mime_types.rb test/stub/railsapp2/config/routes.rb test/stub/railsapp2/log/useless.txt test/stub/railsapp2/public/useless.txt test/stub/railsapp2/tmp/cache/useless.txt test/stub/railsapp2/tmp/pids/useless.txt test/stub/railsapp2/tmp/sessions/useless.txt test/stub/railsapp2/tmp/sockets/useless.txt 81ca3ade903218e37617fb279c99f60bb478a638 Hongli Lai (Phusion) hongli@phusion.nl http://github.com/FooBarWidget/passenger/commit/b5093c289ce58bf4190fff1ca9b58e6de65d9de1 b5093c289ce58bf4190fff1ca9b58e6de65d9de1

2009-05-26T08:35:02-07:00

2009-05-26T01:41:44-07:00

Refactor ApplicationPoolTest: split some functionality to functions, and modify tests to use stub/rack instead of stub/railsapp because it's faster. 576395fd5b245c8cf519b1c155c7b99537633aa1 Hongli Lai (Phusion) hongli@phusion.nl