passenger 5.0.4 → 5.0.5

data/test/support/multipart.rb

@@ -1,62 +0,0 @@
-module Multipart
-  # From: http://deftcode.com/code/flickr_upload/multipartpost.rb
-  ## Helper class to prepare an HTTP POST request with a file upload
-  ## Mostly taken from
-  #http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/113774
-  ### WAS:
-  ## Anything that's broken and wrong probably the fault of Bill Stilwell
-  ##(bill@marginalia.org)
-  ### NOW:
-  ## Everything wrong is due to keith@oreilly.com
-  require 'rubygems'
-  require 'mime/types'
-  require 'net/http'
-  require 'cgi'
-
-  class Param
-    attr_accessor :k, :v
-    def initialize( k, v )
-      @k = k
-      @v = v
-    end
-
-    def to_multipart
-      #return "Content-Disposition: form-data; name=\"#{CGI::escape(k)}\"\r\n\r\n#{v}\r\n"
-      # Don't escape mine...
-      return "Content-Disposition: form-data; name=\"#{k}\"\r\n\r\n#{v}\r\n"
-    end
-  end
-
-  class FileParam
-    attr_accessor :k, :filename, :content
-    def initialize( k, filename, content )
-      @k = k
-      @filename = filename
-      @content = content
-    end
-
-    def to_multipart
-      #return "Content-Disposition: form-data; name=\"#{CGI::escape(k)}\"; filename=\"#{filename}\"\r\n" + "Content-Transfer-Encoding: binary\r\n" + "Content-Type: #{MIME::Types.type_for(@filename)}\r\n\r\n" + content + "\r\n "
-      # Don't escape mine
-      return "Content-Disposition: form-data; name=\"#{k}\"; filename=\"#{filename}\"\r\n" + "Content-Transfer-Encoding: binary\r\n" + "Content-Type: #{MIME::Types.type_for(@filename)}\r\n\r\n" + content + "\r\n"
-    end
-  end
-  class MultipartPost
-    BOUNDARY = 'tarsiers-rule0000'
-    HEADER = {"Content-type" => "multipart/form-data, boundary=" + BOUNDARY + " "}
-
-    def prepare_query (params)
-      fp = []
-      params.each {|k,v|
-        if v.respond_to?(:read)
-          fp.push(FileParam.new(k, v.path, v.read))
-        else
-          fp.push(Param.new(k,v))
-        end
-      }
-      query = fp.collect {|p| "--" + BOUNDARY + "\r\n" + p.to_multipart }.join("") + "--" + BOUNDARY + "--"
-      return query, HEADER
-    end
-  end  
-end
-

data/test/support/nginx_controller.rb

@@ -1,97 +0,0 @@
-require 'erb'
-PhusionPassenger.require_passenger_lib 'vendor/daemon_controller'
-PhusionPassenger.require_passenger_lib 'platform_info/ruby'
-
-class NginxController
-  PlatformInfo = PhusionPassenger::PlatformInfo
-  TEMPLATE_DIR = File.expand_path(File.dirname(__FILE__) + "/../stub/nginx")
-  PORT = 64507
-
-  def initialize(root_dir)
-    root_dir     = File.expand_path(root_dir)
-    @passenger_root = PhusionPassenger.install_spec
-    @nginx_root  = root_dir
-    @port        = PORT
-    @config_file = "#{root_dir}/nginx.conf"
-    @pid_file    = "#{root_dir}/nginx.pid"
-    @log_file    = "#{root_dir}/error.log"
-    @controller  = PhusionPassenger::DaemonController.new(
-      :identifier    => 'Nginx',
-      :start_command => "#{CONFIG['nginx']} -c '#{@config_file}'",
-      :ping_command  => [:tcp, '127.0.0.1', PORT],
-      :pid_file      => @pid_file,
-      :log_file      => @log_file,
-      :timeout       => 25,
-      :before_start  => method(:write_nginx_config_files)
-    )
-
-    @servers = []
-    @max_pool_size = 1
-  end
-
-  def set(options)
-    options.each_pair do |key, value|
-      instance_variable_set("@#{key}", value)
-    end
-  end
-
-  def start
-    stop
-    @controller.start
-  end
-
-  def stop
-    @controller.stop
-    # On OS X, the Nginx server socket may linger around for a while
-    # after Nginx shutdown, despite Nginx setting SO_REUSEADDR.
-    sockaddr = Socket.pack_sockaddr_in(PORT, '127.0.0.1')
-    eventually(30) do
-      !@controller.send(:ping_socket, Socket::Constants::AF_INET, sockaddr)
-    end
-  end
-
-  def running?
-    return @controller.running?
-  end
-
-  def port
-    return @port
-  end
-
-  def add_server
-    server = Server.new
-    yield server
-    @servers << server
-  end
-
-private
-  class Server
-    attr_accessor :values
-    attr_accessor :extra
-
-    def initialize
-      @values = { :passenger_enabled => "on" }
-    end
-
-    def [](key)
-      return @values[key]
-    end
-
-    def []=(key, value)
-      @values[key] = value
-    end
-
-    def <<(text)
-      @extra = text
-    end
-  end
-
-  def write_nginx_config_files
-    template = ERB.new(File.read("#{TEMPLATE_DIR}/nginx.conf.erb"))
-    File.write(@config_file, template.result(get_binding))
-  end
-
-  def get_binding
-    return binding
-  end
-end

data/test/support/placebo-preloader.rb

@@ -1,88 +0,0 @@
-#!/usr/bin/env ruby
-# An application preloader which doesn't actually preload anything
-# and executes the requested start command.
-
-DIR = File.expand_path(File.dirname(__FILE__))
-require File.expand_path("#{DIR}/../../lib/phusion_passenger")
-PhusionPassenger.locate_directories
-PhusionPassenger.require_passenger_lib 'native_support'
-require 'socket'
-
-STDOUT.sync = true
-STDERR.sync = true
-puts "!> I have control 1.0"
-abort "Invalid initialization header" if STDIN.readline != "You have control 1.0\n"
-
-options = {}
-while (line = STDIN.readline) != "\n"
-  name, value = line.strip.split(/: */, 2)
-  options[name] = value
-end
-
-socket_filename = "/tmp/placebo-preloader.sock.#{Process.pid}"
-server = UNIXServer.new(socket_filename)
-puts "!> Ready"
-puts "!> socket: unix:#{socket_filename}"
-puts "!> "
-
-def process_client_command(server, client, command)
-  if command == "spawn\n"
-    options = {}
-    while (line = client.readline) != "\n"
-      name, value = line.strip.split(/: */, 2)
-      options[name] = value
-    end
-
-    command = options["start_command"].split("\t")
-    process_title = options["process_title"]
-    process_title = command[0] if !process_title || process_title.empty?
-    command[0] = [command[0], process_title]
-
-    pid = fork do
-      begin
-        STDIN.reopen(client)
-        STDOUT.reopen(client)
-        STDOUT.sync = true
-        server.close
-        client.close
-        puts "OK"
-        puts Process.pid
-        exec(*command)
-      rescue Exception => e
-        STDERR.puts "*** ERROR: #{e}\n#{e.backtrace.join("\n")}"
-      ensure
-        STDERR.flush
-        exit!(1)
-      end
-    end
-    Process.detach(pid)
-  elsif command == "pid\n"
-    client.write("#{Process.pid}\n")
-  else
-    client.write("unknown request\n")
-  end
-end
-
-begin
-  exit if ARGV[0] == "exit-immediately"
-  while true
-    ios = select([server, STDIN])[0]
-    if ios.include?(server)
-      client = server.accept
-      begin
-        process_client_command(server, client, client.readline)
-      ensure
-        client.close
-      end
-    end
-    if ios.include?(STDIN)
-      begin
-        STDIN.readline
-      rescue EOFError
-        exit
-      end
-    end
-  end
-ensure
-  File.unlink(socket_filename) rescue nil
-end

data/test/support/test_helper.rb

@@ -1,455 +0,0 @@
-# Clean Bundler environment variables. Otherwise we can't test against multiple Rails versions.
-if defined?(Bundler)
-  clean_env = nil
-  Bundler.with_clean_env do
-    clean_env = ENV.to_hash
-  end
-  ENV.replace(clean_env)
-end
-
-require 'fileutils'
-require 'resolv'
-require 'net/http'
-require 'uri'
-require 'support/multipart'
-PhusionPassenger.require_passenger_lib 'constants'
-PhusionPassenger.require_passenger_lib 'debug_logging'
-PhusionPassenger.require_passenger_lib 'platform_info/ruby'
-
-# Module containing helper methods, to be included in unit tests.
-module TestHelper
-  ######## Stub helpers ########
-
-  class Stub
-    attr_reader :app_root
-    attr_reader :full_app_root
-
-    def self.use(name, app_root = nil)
-      stub = new(name, app_root)
-      begin
-        yield stub
-      ensure
-        stub.destroy
-      end
-    end
-
-    def initialize(name, app_root = nil)
-      @name = name
-      if !File.exist?(stub_source_dir)
-        raise Errno::ENOENT, "Stub '#{name}' not found."
-      end
-
-      if app_root
-        @app_root = app_root
-      else
-        identifier = name.gsub('/', '-')
-        @app_root = "tmp.#{identifier}.#{object_id}"
-      end
-      @full_app_root = File.expand_path(@app_root)
-      remove_dir_tree(@full_app_root)
-      FileUtils.mkdir_p(@full_app_root)
-      copy_stub_contents
-      system("chmod", "-R", "a+rw", @full_app_root)
-    end
-
-    def reset
-      # Empty directory without removing the directory itself,
-      # allowing processes with this directory as current working
-      # directory to continue to function properly.
-      files = Dir["#{@full_app_root}/*"]
-      files |= Dir["#{@full_app_root}/.*"]
-      files.delete("#{@full_app_root}/.")
-      files.delete("#{@full_app_root}/..")
-      FileUtils.chmod_R(0777, files)
-      FileUtils.rm_rf(files)
-
-      copy_stub_contents
-      system("chmod", "-R", "a+rw", @full_app_root)
-    end
-
-    def move(new_app_root)
-      File.rename(@full_app_root, new_app_root)
-      @app_root = new_app_root
-      @full_app_root = File.expand_path(new_app_root)
-    end
-
-    def destroy
-      remove_dir_tree(@full_app_root)
-    end
-
-    def full_app_root
-      return File.expand_path(@app_root)
-    end
-
-    def public_file(name)
-      return File.binread("#{@full_app_root}/public/#{name}")
-    end
-
-  private
-    def stub_source_dir
-      return "stub/#{@name}"
-    end
-
-    def copy_stub_contents
-      FileUtils.cp_r("#{stub_source_dir}/.", @full_app_root)
-    end
-  end
-
-  class RackStub < Stub
-    def startup_file
-      return "#{@full_app_root}/config.ru"
-    end
-
-  private
-    def copy_stub_contents
-      super
-      if PhusionPassenger.build_system_dir
-        build_system_dir = PhusionPassenger.build_system_dir
-        if !File.exist?("#{@full_app_root}/Gemfile")
-          FileUtils.cp("#{build_system_dir}/Gemfile", @full_app_root)
-          FileUtils.cp("#{build_system_dir}/Gemfile.lock", @full_app_root)
-          if File.exist?("#{build_system_dir}/.bundle")
-            FileUtils.cp_r("#{build_system_dir}/.bundle", @full_app_root)
-          end
-        end
-      end
-    end
-  end
-
-  class PythonStub < Stub
-    def startup_file
-      return "#{@full_app_root}/passenger_wsgi.py"
-    end
-  end
-
-  class NodejsStub < Stub
-    def startup_file
-      return "#{@full_app_root}/app.js"
-    end
-  end
-
-  def describe_rails_versions(matcher, &block)
-    if ENV['ONLY_RAILS_VERSION'] && !ENV['ONLY_RAILS_VERSION'].empty?
-      found_versions = [ENV['ONLY_RAILS_VERSION']]
-    else
-      found_versions = Dir.entries("stub/rails_apps").grep(/^\d+\.\d+$/)
-      if RUBY_VERSION >= '1.9.0'
-        # Only Rails >= 2.3 is compatible with Ruby 1.9.
-        found_versions.reject! do |version|
-          version < '2.3'
-        end
-      elsif RUBY_VERSION <= '1.8.6'
-        # Rails >= 3 dropped support for 1.8.6 and older.
-        found_versions.reject! do |version|
-          version >= '3.0'
-        end
-      end
-    end
-
-    case matcher
-    when /^<= (.+)$/
-      max_version = $1
-      found_versions.reject! do |version|
-        version > max_version
-      end
-    when /^>= (.+)$/
-      min_version = $1
-      found_versions.reject! do |version|
-        version < min_version
-      end
-    when /^= (.+)$/
-      exact_version = $1
-      found_versions.reject! do |version|
-        version != exact_version
-      end
-    else
-      raise ArgumentError, "Unknown matcher string '#{matcher}'"
-    end
-
-    found_versions.sort.each do |version|
-      klass = describe("Rails #{version}", &block)
-      klass.send(:define_method, :rails_version) do
-        version
-      end
-    end
-  end
-
-
-  ######## HTTP helpers ########
-  # Before using these methods, one must set the '@server' instance variable
-  # and implement the start_web_server_if_necessary method.
-
-  def get(uri)
-    if @server.nil?
-      raise "You must set the '@server' instance variable before get() can be used. For example, @server = 'http://mydomain.test/'"
-    end
-    start_web_server_if_necessary
-    return Net::HTTP.get(URI.parse("#{@server}#{uri}"))
-  end
-
-  def get_response(uri)
-    if @server.nil?
-      raise "You must set the '@server' instance variable before get() can be used. For example, @server = 'http://mydomain.test/'"
-    end
-    start_web_server_if_necessary
-    return Net::HTTP.get_response(URI.parse("#{@server}#{uri}"))
-  end
-
-  def post(uri, params = {})
-    if @server.nil?
-      raise "You must set the '@server' instance variable before get() can be used. For example, @server = 'http://mydomain.test/'"
-    end
-    start_web_server_if_necessary
-    url = URI.parse("#{@server}#{uri}")
-    if params.values.any? { |x| x.respond_to?(:read) }
-      mp = Multipart::MultipartPost.new
-      query, headers = mp.prepare_query(params)
-      Net::HTTP.start(url.host, url.port) do |http|
-        return http.post(url.path, query, headers).body
-      end
-    else
-      return Net::HTTP.post_form(url, params).body
-    end
-  end
-
-  def check_hosts_configuration
-    begin
-      ok = Resolv.getaddress("passenger.test") == "127.0.0.1"
-      ok = ok && Resolv.getaddress("1.passenger.test") == "127.0.0.1"
-    rescue Resolv::ResolvError, ArgumentError
-      # There's a bug in Ruby 1.8.6-p287's resolv.rb library, which causes
-      # an ArgumentError to be raised instead of ResolvError when resolving
-      # failed.
-      ok = false
-    end
-    if !ok
-      message = "To run the integration test, you must update " <<
-        "your hosts file.\n" <<
-        "Please add these to your /etc/hosts:\n\n" <<
-        "127.0.0.1 passenger.test\n" <<
-        "127.0.0.1 1.passenger.test 2.passenger.test 3.passenger.test\n" <<
-        "127.0.0.1 4.passenger.test 5.passenger.test 6.passenger.test\n" <<
-        "127.0.0.1 7.passenger.test 8.passenger.test 9.passenger.test\n"
-      if RUBY_PLATFORM =~ /darwin/
-        message << "\n\nThen run:\n\n" <<
-          "  dscacheutil -flushcache"
-      end
-      STDERR.puts "---------------------------"
-      STDERR.puts message
-      exit!
-    end
-  end
-
-
-  ######## Other helpers ########
-
-  def when_user_switching_possible
-    if Process.euid == 0
-      yield
-    end
-  end
-
-  alias when_running_as_root when_user_switching_possible
-
-  def when_not_running_as_root
-    if Process.euid != 0
-      yield
-    end
-  end
-
-  def eventually(deadline_duration = 2, check_interval = 0.05)
-    deadline = Time.now + deadline_duration
-    while Time.now < deadline
-      if yield
-        return
-      else
-        sleep(check_interval)
-      end
-    end
-    raise "Time limit exceeded"
-  end
-
-  def should_never_happen(deadline_duration = 1, check_interval = 0.05)
-    deadline = Time.now + deadline_duration
-    while Time.now < deadline
-      if yield
-        raise "That which shouldn't happen happened anyway"
-      else
-        sleep(check_interval)
-      end
-    end
-  end
-
-  def remove_dir_tree(dir)
-    # FileUtils.chmod_R is susceptible to race conditions:
-    # if another thread/process deletes a file just before
-    # chmod_R has chmodded it, then chmod_R will raise an error.
-    # Keep trying until a real error has been reached or until
-    # chmod_R is done.
-    done = false
-    while !done
-      begin
-        FileUtils.chmod_R(0777, dir)
-        done = true
-      rescue Errno::ENOENT
-        done = !File.exist?(dir)
-      end
-    end
-    FileUtils.rm_rf(dir)
-  end
-
-  def spawn_process(*args)
-    args.map! do |arg|
-      arg.to_s
-    end
-    if Process.respond_to?(:spawn)
-      return Process.spawn(*args)
-    else
-      return fork do
-        exec(*args)
-      end
-    end
-  end
-
-  # Run a script in a Ruby subprocess. *args are program arguments to
-  # pass to the script. Returns the script's stdout output.
-  def run_script(code, *args)
-    stdin_child, stdin_parent = IO.pipe
-    stdout_parent, stdout_child = IO.pipe
-    program_args = [PhusionPassenger::PlatformInfo.ruby_command, "-e",
-      "eval(STDIN.read, binding, '(script)', 0)",
-      PhusionPassenger::LIBDIR, *args]
-    if Process.respond_to?(:spawn)
-      program_args << {
-        STDIN  => stdin_child,
-        STDOUT => stdout_child,
-        STDERR => STDERR,
-        :close_others => true
-      }
-      pid = Process.spawn(*program_args)
-    else
-      pid = fork do
-        stdin_parent.close
-        stdout_parent.close
-        STDIN.reopen(stdin_child)
-        STDOUT.reopen(stdout_child)
-        stdin_child.close
-        stdout_child.close
-        exec(*program_args)
-      end
-    end
-    stdin_child.close
-    stdout_child.close
-    stdin_parent.write(
-      %Q[require(ARGV.shift + "/phusion_passenger")
-      #{code}])
-    stdin_parent.close
-    result = stdout_parent.read
-    stdout_parent.close
-    Process.waitpid(pid)
-    return result
-  rescue Exception
-    Process.kill('SIGKILL', pid) if pid
-    raise
-  ensure
-    [stdin_child, stdout_child, stdin_parent, stdout_parent].each do |io|
-      io.close if io && !io.closed?
-    end
-    begin
-      Process.waitpid(pid) if pid
-    rescue Errno::ECHILD, Errno::ESRCH
-    end
-  end
-
-  def spawn_logging_agent(tmpdir, dump_file, password)
-    socket_filename = "#{tmpdir}/logging.socket"
-    password_filename = "#{tmpdir}/password"
-    File.write(password_filename, password)
-    pid = spawn_process("#{PhusionPassenger.support_binaries_dir}/#{PhusionPassenger::AGENT_EXE}",
-      "logger",
-      "--passenger-root", PhusionPassenger.install_spec,
-      "--log-level", PhusionPassenger::DebugLogging.log_level,
-      "--dump-file", dump_file,
-      "--user",  CONFIG['normal_user_1'],
-      "--group", CONFIG['normal_group_1'],
-      "--listen", "unix:#{socket_filename}",
-      "--password-file", password_filename)
-    eventually do
-      File.exist?(socket_filename)
-    end
-    return [pid, socket_filename, "unix:#{socket_filename}"]
-  rescue Exception => e
-    if pid
-      Process.kill('KILL', pid)
-      Process.waitpid(pid)
-    end
-    raise e
-  end
-
-  def flush_logging_agent(password, socket_address)
-    PhusionPassenger.require_passenger_lib 'message_client' if !defined?(PhusionPassenger::MessageClient)
-    client = PhusionPassenger::MessageClient.new("logging", password, socket_address)
-    begin
-      client.write("flush")
-      client.read
-    ensure
-      client.close
-    end
-  end
-
-  def inspect_server(name)
-    instance = PhusionPassenger::AdminTools::ServerInstance.list.first
-    if name
-      instance.connect(:passenger_status) do
-        return instance.send(name)
-      end
-    else
-      return instance
-    end
-  end
-
-  if "".respond_to?(:force_encoding)
-    def binary_string(str)
-      return str.force_encoding("binary")
-    end
-  else
-    def binary_string(str)
-      return str
-    end
-  end
-end
-
-File.class_eval do
-  def self.prepend(filename, data)
-    original_content = File.read(filename)
-    File.open(filename, 'w') do |f|
-      f.write(data)
-      f.write(original_content)
-    end
-  end
-
-  def self.append(filename, data)
-    File.open(filename, 'a') do |f|
-      f.write(data)
-    end
-  end
-
-  def self.write(filename, content = nil)
-    if block_given?
-      content = yield File.read(filename)
-    end
-    File.open(filename, 'w') do |f|
-      f.write(content)
-    end
-  end
-
-  def self.touch(filename, timestamp = nil)
-    File.open(filename, 'w').close
-    File.utime(timestamp, timestamp, filename) if timestamp
-  end
-
-  def self.binread(filename)
-    return File.read(filename)
-  end if !respond_to?(:binread)
-end
-