passenger 5.0.4 → 5.0.5

data/test/ruby/shared/loader_sharedspec.rb

@@ -1,247 +0,0 @@
-require 'socket'
-PhusionPassenger.require_passenger_lib 'utils'
-PhusionPassenger.require_passenger_lib 'message_channel'
-
-module PhusionPassenger
-
-class Loader
-  attr_reader :pid, :input, :output, :sockets
-
-  def initialize(command, app_root)
-    @app_root = app_root
-    a, input = UNIXSocket.pair
-    c, output = UNIXSocket.pair
-    @pid = pid = fork do
-      STDIN.reopen(a)
-      STDOUT.reopen(c)
-      input.close
-      output.close
-      Dir.chdir(app_root)
-      ENV['RAILS_ENV'] = ENV['RACK_ENV'] = ENV['PASSENGER_ENV'] = 'production'
-      exec(*command)
-    end
-    a.close
-    c.close
-    @input = input
-    @output = output
-    @sockets = {}
-  end
-
-  def self.new_with_sockets(input, output, app_root)
-    result = allocate
-    result.instance_variable_set(:@input, input)
-    result.instance_variable_set(:@output, output)
-    result.instance_variable_set(:@app_root, app_root)
-    result.instance_variable_set(:@sockets, {})
-    return result
-  end
-
-  def close
-    @input.close_write
-    # Wait at most 100 msec for process to exit.
-    select([@output], nil, nil, 0.1)
-
-    @input.close if !@input.closed?
-    @output.close if !@output.closed?
-    if @pid
-      begin
-        Process.kill('TERM', @pid)
-      rescue Errno::ESRCH
-      end
-      begin
-        Process.waitpid(@pid)
-      rescue Errno::ECHILD
-      end
-    end
-  end
-
-  def start(options = {})
-    init_message = read_response_line
-    if init_message != "I have control 1.0\n"
-      raise "Unknown response initialization message: #{init_message.inspect}"
-    end
-    write_request_line "You have control 1.0"
-    write_start_request(options)
-    return process_response
-  end
-
-  def connect_and_send_request(headers)
-    socket = Utils.connect_to_server(sockets["main"][:address])
-    channel = MessageChannel.new(socket)
-    data = ""
-    headers["REQUEST_METHOD"] ||= "GET"
-    headers["REQUEST_URI"] ||= headers["PATH_INFO"]
-    headers["QUERY_STRING"] ||= ""
-    headers["SCRIPT_NAME"] ||= ""
-    headers.each_pair do |key, value|
-      data << "#{key}\0#{value}\0"
-    end
-    channel.write_scalar(data)
-    return socket
-  end
-
-private
-  def write_request_line(line = "")
-    STDERR.puts "---> #{line}" if DEBUG
-    @input.puts line
-  end
-
-  def read_response_line
-    while true
-      line = @output.readline
-      STDERR.puts "<--- #{line.strip}" if DEBUG
-      if line.start_with?("!> ")
-        line.sub!(/^\!> /, '')
-        return line
-      end
-    end
-  end
-
-  def write_start_request(options)
-    write_request_line "passenger_root: #{PhusionPassenger.install_spec}"
-    write_request_line "ruby_libdir: #{PhusionPassenger.ruby_libdir}"
-    write_request_line "keepalive: false"
-    write_request_line "log_level: 6" if DEBUG
-    options.each_pair do |key, value|
-      write_request_line "#{key}: #{value}"
-    end
-    write_request_line
-  end
-
-  def process_response
-    status = read_response_line
-
-    headers = {}
-    line = read_response_line
-    while line != "\n"
-      key, value = line.strip.split(/ *: */, 2)
-      if key == "socket"
-        process_socket(value)
-      else
-        headers[key] = value
-      end
-      line = read_response_line
-    end
-
-    if status == "Error\n"
-      body = @output.read
-      STDERR.puts "<--- #{body}" if DEBUG
-    end
-
-    return { :status => status.strip, :headers => headers, :body => body }
-  end
-
-  def process_socket(spec)
-    name, address, protocol, concurrency = spec.split(';')
-    @sockets[name] = { :address => address, :protocol => protocol, :concurrency => concurrency }
-  end
-end
-
-class Preloader < Loader
-  def spawn(options = {})
-    socket = Utils.connect_to_server(sockets["spawn"])
-    loader = Loader.new_with_sockets(socket, socket.dup, @app_root)
-    begin
-      loader.send(:write_request_line, "spawn")
-      loader.send(:write_start_request, options)
-
-      line = loader.output.readline
-      puts "<--- #{line.strip}" if DEBUG
-      if line != "OK\n"
-        raise "Unexpected spawn response status #{line.inspect}"
-      end
-
-      line = loader.output.readline
-      puts "<--- #{line.strip}" if DEBUG
-      loader.instance_variable_set(:@pid, line.to_i)
-
-      return loader
-    rescue
-      loader.close
-      raise
-    end
-  end
-
-private
-  def process_socket(spec)
-    sockets["spawn"] = spec
-  end
-end
-
-module LoaderSpecHelper
-  def self.included(klass)
-    klass.before(:each) do
-      @stubs = []
-    end
-
-    klass.after(:each) do
-      begin
-        @loader.close if @loader
-        @preloader.close if @preloader
-      ensure
-        @stubs.each do |stub|
-          stub.destroy
-        end
-      end
-    end
-  end
-
-  def before_start(code)
-    @before_start = code
-  end
-
-  def after_start(code)
-    @after_start = code
-  end
-
-  def register_stub(stub)
-    @stubs << stub
-    File.prepend(stub.startup_file, "#{@before_start}\n")
-    File.append(stub.startup_file, "\n#{@after_start}")
-    return stub
-  end
-
-  def register_app(app)
-    @apps << app
-    return app
-  end
-
-  def start!(options = {})
-    result = start(options)
-    if result[:status] != "Ready"
-      raise "Loader failed to start; error page:\n#{result[:body]}"
-    end
-  end
-
-  def perform_request(headers)
-    socket = @loader.connect_and_send_request(headers)
-    headers = {}
-    line = socket.readline
-    headers["Status"] = line.split(" ")[1]
-    while line != "\r\n"
-      key, value = line.strip.split(/ *: */, 2)
-      headers[key] = value
-      line = socket.readline
-    end
-    body = socket.read
-    socket.close
-    return [headers, body]
-  end
-end
-
-shared_examples_for "a loader" do
-  it "works" do
-    result = start
-    result[:status].should == "Ready"
-    headers, body = perform_request(
-      "REQUEST_METHOD" => "GET",
-      "PATH_INFO" => "/",
-      # For Rails 2
-      "REQUEST_URI" => "/"
-    )
-    headers["Status"].should == "200"
-    body.should == "front page"
-  end
-end
-
-end # module PhusionPassenger

data/test/ruby/shared/rails/union_station_extensions_sharedspec.rb

@@ -1,357 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-require 'socket'
-require 'fileutils'
-require 'tmpdir'
-PhusionPassenger.require_passenger_lib 'union_station/core'
-
-module PhusionPassenger
-
-shared_examples_for "Union Station extensions for Rails" do
-  before :each do
-    @logging_agent_password = "1234"
-    @us_tmpdir = Dir.mktmpdir
-    @dump_file = "#{@us_tmpdir}/log.txt"
-    @agent_pid, @socket_filename, @socket_address = spawn_logging_agent(@us_tmpdir,
-      @dump_file, @logging_agent_password)
-    @options = {
-      "analytics" => true,
-      "logging_agent_address" => @socket_address,
-      "logging_agent_username" => "logging",
-      "logging_agent_password" => "1234",
-      "node_name" => "localhost",
-      "app_group_name" => "foobar"
-    }
-  end
-
-  after :each do
-    FileUtils.rm_rf(@us_tmpdir) if @us_tmpdir
-    @connection.close if @connection && @connection.closed?
-    Process.kill('KILL', @agent_pid)
-    Process.waitpid(@agent_pid)
-  end
-
-  def send_request_to_app(headers)
-    headers = {
-      "PASSENGER_TXN_ID"     => "1234-abcd"
-    }.merge(headers)
-    return perform_request(headers)
-  end
-
-  def read_log
-    return File.read(@dump_file)
-  end
-
-  def base64(data)
-    return [data].pack('m').gsub("\n", "")
-  end
-
-  it "doesn't install Union Station extensions if analytics logging is turned off" do
-    @options.delete("analytics")
-    File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-      class FooController < ActionController::Base
-        def index
-          File.open("out.txt", "w") do |f|
-            f.write(request.env["UNION_STATION_REQUEST_TRANSACTION"].class.to_s)
-          end
-          render :nothing => true
-        end
-      end
-    })
-    start!(@options)
-    send_request_to_app("PATH_INFO" => "/foo")
-    eventually(5) do
-      filename = "#{@stub.app_root}/out.txt"
-      File.exist?(filename) && File.read(filename) == "NilClass"
-    end
-  end
-
-  it "logs the controller and action name" do
-    File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-      class FooController < ActionController::Base
-        def index
-          render :nothing => true
-        end
-      end
-    })
-    start!(@options)
-    send_request_to_app("PATH_INFO" => "/foo")
-    eventually(5) do
-      flush_logging_agent(@logging_agent_password, @socket_address)
-      log = read_log
-      log.include?("Controller action: FooController#index\n")
-    end
-  end
-
-  it "logs uncaught exceptions in controller actions" do
-    File.write("#{@stub.app_root}/app/controllers/crash_controller.rb", %Q{
-      class CrashController < ActionController::Base
-        def index
-          raise "something went wrong"
-        end
-      end
-    })
-    start!(@options)
-    send_request_to_app("PATH_INFO" => "/crash")
-    eventually(5) do
-      flush_logging_agent(@logging_agent_password, @socket_address)
-      log = read_log
-      log.include?("Request transaction ID: 1234-abcd\n") &&
-        log.include?("Message: " + base64("something went wrong")) &&
-        log.include?("Class: RuntimeError") &&
-        log.include?("Backtrace: ") &&
-        log.include?("Controller action: CrashController#index")
-    end
-  end
-
-  it "logs ActionController benchmarks" do
-    File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-      class FooController < ActionController::Base
-        def index
-          if respond_to?(:benchmark, true)
-            benchmark("hello") do
-            end
-          else
-            ActionController::Base.benchmark("hello") do
-            end
-          end
-          render :nothing => true
-        end
-      end
-    })
-    start!(@options)
-    send_request_to_app("PATH_INFO" => "/foo")
-    eventually(5) do
-      flush_logging_agent(@logging_agent_password, @socket_address)
-      log = read_log
-      log.include?('BEGIN: BENCHMARK: hello') &&
-        log.include?('END: BENCHMARK: hello')
-    end
-  end
-
-  it "logs ActionView benchmarks" do
-    File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-      class FooController < ActionController::Base
-      end
-    })
-    FileUtils.mkdir_p("#{@stub.app_root}/app/views/foo")
-    File.write("#{@stub.app_root}/app/views/foo/index.html.erb", %Q{
-      <% benchmark("hello") do %>
-      <% end %>
-    })
-    start!(@options)
-    send_request_to_app("PATH_INFO" => "/foo")
-    eventually(5) do
-      flush_logging_agent(@logging_agent_password, @socket_address)
-      log = read_log
-      log.include?('BEGIN: BENCHMARK: hello') &&
-        log.include?('END: BENCHMARK: hello')
-    end
-  end
-
-  it "logs successful SQL queries" do
-    File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-      class FooController < ActionController::Base
-        def index
-          db = ActiveRecord::Base.connection
-          db.execute("CREATE TABLE foobar (id INT)")
-          db.execute("INSERT INTO foobar VALUES (1)")
-          render :nothing => true
-        end
-      end
-    })
-    start!(@options.merge("active_record" => true))
-    send_request_to_app("PATH_INFO" => "/foo")
-    extra_info_regex = Regexp.escape(base64("SQL\nCREATE TABLE foobar (id INT)"))
-    eventually(5) do
-      flush_logging_agent(@logging_agent_password, @socket_address)
-      log = read_log
-      log =~ /BEGIN: DB BENCHMARK: .* \(.*\) #{extra_info_regex}$/ &&
-        log =~ /END: DB BENCHMARK: .* \(.*\)$/
-    end
-  end
-
-  it "applies event preprocessor to log events" do
-    File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-      class FooController < ActionController::Base
-        def index
-          db = ActiveRecord::Base.connection
-          db.execute("CREATE TABLE foobar (id INT)--secret")
-          db.execute("INSERT INTO foobar VALUES (1)")
-          render :nothing => true
-        end
-      end
-    })
-    start!(@options.merge("active_record" => true))
-    send_request_to_app("PATH_INFO" => "/foo")
-    extra_info_regex = Regexp.escape(base64("SQL\nCREATE TABLE foobar (id INT)--PASSWORD"))
-    eventually(5) do
-      flush_logging_agent(@logging_agent_password, @socket_address)
-      log = read_log
-      log =~ /BEGIN: DB BENCHMARK: .* \(.*\) #{extra_info_regex}$/ &&
-        log =~ /END: DB BENCHMARK: .* \(.*\)$/
-    end
-  end
-
-  it "logs failed SQL queries" do
-    File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-      class FooController < ActionController::Base
-        def index
-          db = ActiveRecord::Base.connection
-          db.execute("INVALID QUERY")
-          render :nothing => true
-        end
-      end
-    })
-    start!(@options.merge("active_record" => true))
-    send_request_to_app("PATH_INFO" => "/foo")
-    extra_info_regex = Regexp.escape(base64("SQL\nINVALID QUERY"))
-    if rails_version >= '3.0'
-      pending do
-        eventually(5) do
-          log = read_log
-          log =~ /BEGIN: DB BENCHMARK: .* \(.*\) #{extra_info_regex}$/ &&
-            log =~ /FAIL: DB BENCHMARK: .* \(.*\)$/
-        end
-      end
-    else
-      eventually(5) do
-        flush_logging_agent(@logging_agent_password, @socket_address)
-        log = read_log
-        log =~ /BEGIN: DB BENCHMARK: .* \(.*\) #{extra_info_regex}$/ &&
-          log =~ /FAIL: DB BENCHMARK: .* \(.*\)$/
-      end
-    end
-  end
-
-  it "logs controller processing time of successful actions" do
-    File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-      class FooController < ActionController::Base
-        def index
-          render :nothing => true
-        end
-      end
-    })
-    start!(@options)
-    send_request_to_app("PATH_INFO" => "/foo")
-    eventually(5) do
-      flush_logging_agent(@logging_agent_password, @socket_address)
-      log = read_log
-      log.include?("BEGIN: framework request processing") &&
-        log.include?("END: framework request processing")
-    end
-  end
-
-  it "logs controller processing time of failed actions" do
-    File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-      class FooController < ActionController::Base
-        def index
-          raise "crash"
-        end
-      end
-    })
-    start!(@options)
-    send_request_to_app("PATH_INFO" => "/foo")
-    eventually(5) do
-      flush_logging_agent(@logging_agent_password, @socket_address)
-      log = read_log
-      log.include?("BEGIN: framework request processing") &&
-        log.include?("FAIL: framework request processing")
-    end
-  end
-
-  it "logs view rendering time of successful actions" do
-    File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-      class FooController < ActionController::Base
-        def index
-        end
-      end
-    })
-    FileUtils.mkdir_p("#{@stub.app_root}/app/views/foo")
-    File.write("#{@stub.app_root}/app/views/foo/index.html.erb", %Q{
-      hello world
-    })
-    start!(@options)
-    send_request_to_app("PATH_INFO" => "/foo")
-    eventually(5) do
-      flush_logging_agent(@logging_agent_password, @socket_address)
-      log = read_log
-      log.include?("BEGIN: view rendering") &&
-        log.include?("END: view rendering") &&
-        log =~ /View rendering time: \d+$/
-    end
-  end
-
-  it "logs view rendering time of failed actions" do
-    File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-      class FooController < ActionController::Base
-        def index
-        end
-      end
-    })
-    FileUtils.mkdir_p("#{@stub.app_root}/app/views/foo")
-    File.write("#{@stub.app_root}/app/views/foo/index.html.erb", %Q{
-      <% raise "crash!" %>
-    })
-    start!(@options)
-    send_request_to_app("PATH_INFO" => "/foo")
-    eventually(5) do
-      flush_logging_agent(@logging_agent_password, @socket_address)
-      log = read_log
-      log.include?("BEGIN: view rendering") &&
-        log.include?("FAIL: view rendering")
-    end
-  end
-
-  it "logs cache hits" do
-    if rails_version >= '2.1'
-      File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-        class FooController < ActionController::Base
-          def index
-            Rails.cache.write("key1", "foo")
-            Rails.cache.write("key2", "foo")
-            Rails.cache.write("key3", "foo")
-            Rails.cache.read("key1")
-            Rails.cache.fetch("key2")
-            Rails.cache.fetch("key3") { "bar" }
-            render :text => 'ok'
-          end
-        end
-      })
-      start!(@options)
-      send_request_to_app("PATH_INFO" => "/foo")
-      eventually(5) do
-        flush_logging_agent(@logging_agent_password, @socket_address)
-        log = read_log
-        log.include?("Cache hit: key1") &&
-          log.include?("Cache hit: key2") &&
-          log.include?("Cache hit: key3")
-      end
-    end
-  end
-
-  it "logs cache misses" do
-    if rails_version >= '2.1'
-      File.write("#{@stub.app_root}/app/controllers/foo_controller.rb", %Q{
-        class FooController < ActionController::Base
-          def index
-            Rails.cache.read("key1")
-            Rails.cache.fetch("key2")
-            Rails.cache.fetch("key3") { "bar" }
-            render :text => 'ok'
-          end
-        end
-      })
-      start!(@options)
-      send_request_to_app("PATH_INFO" => "/foo")
-      eventually(5) do
-        flush_logging_agent(@logging_agent_password, @socket_address)
-        log = read_log
-        log.include?("Cache miss: key1") &&
-          log.include?("Cache miss: key2") &&
-          log =~ /Cache miss \(\d+\): key3/
-      end
-    end
-  end
-end
-
-end # module PhusionPassenger