passenger-jmazzi 2.2.9

data/misc/rake/rdoctask.rb

@@ -0,0 +1,209 @@
+#!/usr/bin/env ruby
+
+require 'rake'
+require 'rake/tasklib'
+
+module Rake
+
+  # Create a documentation task that will generate the RDoc files for
+  # a project.
+  #
+  # The RDocTask will create the following targets:
+  #
+  # [<b>:<em>rdoc</em></b>]
+  #   Main task for this RDOC task.  
+  #
+  # [<b>:clobber_<em>rdoc</em></b>]
+  #   Delete all the rdoc files.  This target is automatically
+  #   added to the main clobber target.
+  #
+  # [<b>:re<em>rdoc</em></b>]
+  #   Rebuild the rdoc files from scratch, even if they are not out
+  #   of date.
+  #
+  # Simple example:
+  #
+  #   Rake::RDocTask.new do |rd|
+  #     rd.main = "README.rdoc"
+  #     rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  #   end
+  #
+  # The +rd+ object passed to the block is an RDocTask object. See the
+  # attributes list for the RDocTask class for available customization options.
+  #
+  # == Specifying different task names
+  #
+  # You may wish to give the task a different name, such as if you are
+  # generating two sets of documentation.  For instance, if you want to have a
+  # development set of documentation including private methods:
+  #
+  #   Rake::RDocTask.new(:rdoc_dev) do |rd|
+  #     rd.main = "README.doc"
+  #     rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  #     rd.options << "--all"
+  #   end
+  #
+  # The tasks would then be named :<em>rdoc_dev</em>, :clobber_<em>rdoc_dev</em>, and
+  # :re<em>rdoc_dev</em>. 
+  #
+  # If you wish to have completely different task names, then pass a Hash as
+  # first argument. With the <tt>:rdoc</tt>, <tt>:clobber_rdoc</tt> and
+  # <tt>:rerdoc</tt> options, you can customize the task names to your liking.
+  # For example:
+  #
+  #   Rake::RDocTask.new(:rdoc => "rdoc", :clobber_rdoc => "rdoc:clean", :rerdoc => "rdoc:force")
+  #
+  # This will create the tasks <tt>:rdoc</tt>, <tt>:rdoc_clean</tt> and
+  # <tt>:rdoc:force</tt>.
+  #
+  class RDocTask < TaskLib
+    # Name of the main, top level task.  (default is :rdoc)
+    attr_accessor :name
+
+    # Name of directory to receive the html output files. (default is "html")
+    attr_accessor :rdoc_dir
+
+    # Title of RDoc documentation. (defaults to rdoc's default)
+    attr_accessor :title
+
+    # Name of file to be used as the main, top level file of the
+    # RDoc. (default is none)
+    attr_accessor :main
+
+    # Name of template to be used by rdoc. (defaults to rdoc's default)
+    attr_accessor :template
+
+    # List of files to be included in the rdoc generation. (default is [])
+    attr_accessor :rdoc_files
+
+    # Additional list of options to be passed rdoc.  (default is [])
+    attr_accessor :options
+
+    # Whether to run the rdoc process as an external shell (default is false)
+    attr_accessor :external
+    
+    attr_accessor :inline_source
+
+    # Create an RDoc task with the given name. See the RDocTask class overview
+    # for documentation.
+    def initialize(name = :rdoc)  # :yield: self
+      if name.is_a?(Hash)
+        invalid_options = name.keys.map { |k| k.to_sym } - [:rdoc, :clobber_rdoc, :rerdoc]
+        if !invalid_options.empty?
+          raise ArgumentError, "Invalid option(s) passed to RDocTask.new: #{invalid_options.join(", ")}"
+        end
+      end
+      
+      @name = name
+      @rdoc_files = Rake::FileList.new
+      @rdoc_dir = 'html'
+      @main = nil
+      @title = nil
+      @template = nil
+      @external = false
+      @inline_source = true
+      @options = []
+      yield self if block_given?
+      define
+    end
+    
+    # Create the tasks defined by this task lib.
+    def define
+      if rdoc_task_name != "rdoc"
+        desc "Build the RDOC HTML Files"
+      else
+        desc "Build the #{rdoc_task_name} HTML Files"
+      end
+      task rdoc_task_name
+      
+      desc "Force a rebuild of the RDOC files"
+      task rerdoc_task_name => [clobber_task_name, rdoc_task_name]
+      
+      desc "Remove rdoc products" 
+      task clobber_task_name do
+        rm_r rdoc_dir rescue nil
+      end
+      
+      task :clobber => [clobber_task_name]
+      
+      directory @rdoc_dir
+      task rdoc_task_name => [rdoc_target]
+      file rdoc_target => @rdoc_files + [Rake.application.rakefile] do
+        rm_r @rdoc_dir rescue nil
+        @before_running_rdoc.call if @before_running_rdoc
+        args = option_list + @rdoc_files
+        if @external
+          argstring = args.join(' ')
+          sh %{ruby -Ivendor vender/rd #{argstring}}
+        else
+          require 'rdoc/rdoc'
+          RDoc::RDoc.new.document(args)
+        end
+      end
+      self
+    end
+
+    def option_list
+      result = @options.dup
+      result << "-o" << @rdoc_dir
+      result << "--main" << quote(main) if main
+      result << "--title" << quote(title) if title
+      result << "-T" << quote(template) if template
+      result << "--inline-source" if inline_source && !@options.include?("--inline-source") && !@options.include?("-S")
+      result
+    end
+
+    def quote(str)
+      if @external
+        "'#{str}'"
+      else
+        str
+      end
+    end
+
+    def option_string
+      option_list.join(' ')
+    end
+    
+    # The block passed to this method will be called just before running the
+    # RDoc generator. It is allowed to modify RDocTask attributes inside the
+    # block.
+    def before_running_rdoc(&block)
+      @before_running_rdoc = block
+    end
+
+    private
+    
+    def rdoc_target
+      "#{rdoc_dir}/index.html"
+    end
+    
+    def rdoc_task_name
+      case name
+      when Hash
+        (name[:rdoc] || "rdoc").to_s
+      else
+        name.to_s
+      end
+    end
+    
+    def clobber_task_name
+      case name
+      when Hash
+        (name[:clobber_rdoc] || "clobber_rdoc").to_s
+      else
+        "clobber_#{name}"
+      end
+    end
+    
+    def rerdoc_task_name
+      case name
+      when Hash
+        (name[:rerdoc] || "rerdoc").to_s
+      else
+        "re#{name}"
+      end
+    end
+
+  end
+end

data/misc/render_error_pages.rb

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+#  Phusion Passenger - http://www.modrails.com/
+#  Copyright (c) 2008, 2009 Phusion
+#
+#  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+#
+#  Permission is hereby granted, free of charge, to any person obtaining a copy
+#  of this software and associated documentation files (the "Software"), to deal
+#  in the Software without restriction, including without limitation the rights
+#  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#  copies of the Software, and to permit persons to whom the Software is
+#  furnished to do so, subject to the following conditions:
+#
+#  The above copyright notice and this permission notice shall be included in
+#  all copies or substantial portions of the Software.
+#
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+#  THE SOFTWARE.
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib")
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../ext")
+require 'phusion_passenger/html_template'
+require 'phusion_passenger/spawn_manager'
+require 'phusion_passenger/platform_info'
+include PhusionPassenger
+
+if !defined?(Mysql::Error)
+	module Mysql
+		class Error < StandardError
+		end
+	end
+end
+
+def create_dummy_exception
+	begin
+		raise StandardError, "A dummy exception."
+	rescue => e
+		return e
+	end
+end
+
+def create_database_exception
+	begin
+		raise Mysql::Error, "Cannot connect to database localhost:12345: connection refused (1234)"
+	rescue => e
+		return e
+	end
+end
+
+def create_dummy_backtrace
+	dummy_backtrace = nil
+	begin
+		raise StandardError, "A dummy exception."
+	rescue => e
+		dummy_backtrace = e.backtrace
+	end
+	dummy_backtrace.unshift("/webapps/foo/app/models/Foo.rb:102:in `something`")
+	dummy_backtrace.unshift("/webapps/foo/config/environment.rb:10")
+	return dummy_backtrace
+end
+
+def render_error_page(exception, output, template)
+	exception.set_backtrace(create_dummy_backtrace)
+	File.open(output, 'w') do |f|
+		template = HTMLTemplate.new(template,
+			:error => exception, :app_root => "/foo/bar")
+		f.write(template.result)
+		puts "Written '#{output}'"
+	end
+end
+
+def start
+	bt = create_dummy_backtrace
+	
+	e = FrameworkInitError.new("Some error message",
+		create_dummy_exception,
+		:vendor => '/webapps/foo')
+	render_error_page(e, 'framework_init_error_with_vendor.html',
+		'framework_init_error')
+	
+	e = FrameworkInitError.new("Some error message",
+		create_dummy_exception,
+		:version => '1.2.3')
+	render_error_page(e, 'framework_init_error.html',
+		'framework_init_error')
+	
+	e = VersionNotFound.new("Some error message", '>= 1.0.2')
+	render_error_page(e, 'version_not_found.html',
+		'version_not_found')
+	
+	e = AppInitError.new("Some error message", create_dummy_exception)
+	render_error_page(e, 'app_init_error.html',
+		'app_init_error')
+	
+	e = AppInitError.new("Some error message", create_database_exception)
+	render_error_page(e, 'database_error.html',
+		'database_error')
+	
+	e = ArgumentError.new("Some error message")
+	render_error_page(e, 'invalid_app_root.html',
+		'invalid_app_root')
+	
+	e = StandardError.new("Some error message")
+	render_error_page(e, 'general_error.html',
+		'general_error')
+	
+	e = AppInitError.new("Some error message", create_dummy_exception)
+	render_error_page(e, 'app_exited.html', 'app_exited_during_initialization')
+end
+
+start

data/test/ApplicationPoolServerTest.cpp

@@ -0,0 +1,114 @@
+#include "tut.h"
+#include "ApplicationPoolServer.h"
+#include "Utils.h"
+#include <cstring>
+#include <unistd.h>
+#include <errno.h>
+
+using namespace Passenger;
+
+namespace tut {
+	struct ApplicationPoolServerTest {
+		ApplicationPoolServerPtr server;
+		ApplicationPoolPtr pool, pool2;
+		
+		ApplicationPoolServerTest() {
+			server = ptr(new ApplicationPoolServer(
+				"./ApplicationPoolServerExecutable",
+				"stub/spawn_server.rb"));
+		}
+	};
+
+	DEFINE_TEST_GROUP(ApplicationPoolServerTest);
+
+	TEST_METHOD(1) {
+		// Constructor and destructor should not crash or block indefinitely.
+		// (And yes, this test method is intended to be blank.)
+	}
+	
+	TEST_METHOD(2) {
+		// Connecting to the ApplicationPoolServer, as well as destroying the
+		// returned ApplicationPool object, should not crash.
+		server->connect();
+	}
+
+	TEST_METHOD(3) {
+		// If connect() has been called, then detach() should not crash, and the
+		// ApplicationPoolServer's destructor should not crash either.
+		pid_t pid = fork();
+		if (pid == 0) {
+			server->connect();
+			server->detach();
+			server.reset();
+			_exit(0);
+		} else {
+			int status;
+			
+			waitpid(pid, &status, 0);
+			if (status != 0) {
+				fail("Child process exited abnormally.");
+			}
+		}
+	}
+
+	TEST_METHOD(4) {
+		// If connect() has not been called, then detach() should not crash, and the
+		// ApplicationPoolServer's destructor should not crash either.
+		pid_t pid = fork();
+		if (pid == 0) {
+			server->detach();
+			server.reset();
+			_exit(0);
+		} else {
+			int status;
+			
+			waitpid(pid, &status, 0);
+			if (status != 0) {
+				fail("Child process exited abnormally.");
+			}
+		}
+	}
+	
+	/* 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);
+	}
+}
+

data/test/ApplicationPoolServer_ApplicationPoolTest.cpp

@@ -0,0 +1,33 @@
+#include "tut.h"
+#include "support/Support.h"
+#include <boost/thread.hpp>
+#include "ApplicationPoolServer.h"
+
+using namespace Passenger;
+using namespace boost;
+using namespace Test;
+
+namespace tut {
+	struct ApplicationPoolServer_ApplicationPoolTest {
+		ApplicationPoolServerPtr server;
+		ApplicationPoolPtr pool, pool2;
+		
+		ApplicationPoolServer_ApplicationPoolTest() {
+			server = ptr(new ApplicationPoolServer(
+				"./ApplicationPoolServerExecutable",
+				"../bin/passenger-spawn-server"));
+			pool = server->connect();
+			pool2 = server->connect();
+		}
+		
+		ApplicationPoolPtr newPoolConnection() {
+			return server->connect();
+		}
+	};
+	
+	DEFINE_TEST_GROUP(ApplicationPoolServer_ApplicationPoolTest);
+	
+	#define USE_TEMPLATE
+	#include "ApplicationPoolTest.cpp"
+}
+