passenger 4.0.10 → 4.0.13

data/lib/phusion_passenger/standalone/runtime_locator.rb

@@ -0,0 +1,163 @@
+# encoding: utf-8
+#  Phusion Passenger - https://www.phusionpassenger.com/
+#  Copyright (c) 2013 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.
+
+require 'phusion_passenger/platform_info/binary_compatibility'
+require 'phusion_passenger/utils/json'
+require 'etc'
+
+module PhusionPassenger
+module Standalone
+
+# Helper class for locating runtime files used by Passenger Standalone.
+class RuntimeLocator
+	attr_reader :runtime_dir
+
+	def initialize(runtime_dir, nginx_version = PhusionPassenger::PREFERRED_NGINX_VERSION)
+		@runtime_dir = runtime_dir || default_runtime_dir
+		@nginx_version = nginx_version
+	end
+
+	def self.looks_like_support_dir?(dir)
+		File.exist?("#{dir}/agents/PassengerWatchdog") &&
+			File.exist?("#{dir}/common/libboost_oxt.a") &&
+			File.exist?("#{dir}/common/libpassenger_common/ApplicationPool2/Implementation.o")
+	end
+
+	def reload
+		@has_support_dir = @has_nginx_binary = false
+	end
+
+	# Returns the directory in which Passenger Standalone
+	# support binaries are stored, or nil if not installed.
+	def find_support_dir
+		return @support_dir if @has_support_dir
+
+		if PhusionPassenger.originally_packaged?
+			if debugging?
+				@support_dir = "#{PhusionPassenger.source_root}/buildout"
+			else
+				dir = "#{@runtime_dir}/#{version}/support-#{cxx_compat_id}"
+				if self.class.looks_like_support_dir?(dir)
+					@support_dir = dir
+				else
+					@support_dir = nil
+				end
+			end
+		else
+			@support_dir = PhusionPassenger.lib_dir
+		end
+		@has_support_dir = true
+		return @support_dir
+	end
+
+	# Returns the path to the Nginx binary that Passenger Standalone
+	# may use, or nil if not installed.
+	def find_nginx_binary
+		return @nginx_binary if @has_nginx_binary
+
+		if File.exist?(config_filename)
+			config = PhusionPassenger::Utils::JSON.parse(File.read(config_filename))
+		else
+			config = {}
+		end
+		if result = config["nginx_binary"]
+			@nginx_binary = result
+		elsif PhusionPassenger.natively_packaged? && @nginx_version == PhusionPassenger::PREFERRED_NGINX_VERSION
+			@nginx_binary = "#{PhusionPassenger.lib_dir}/nginx"
+		else
+			filename = "#{@runtime_dir}/#{version}/nginx-#{@nginx_version}-#{cxx_compat_id}/nginx"
+			if File.exist?(filename)
+				@nginx_binary = filename
+			else
+				@nginx_binary = nil
+			end
+		end
+		@has_nginx_binary = true
+		return @nginx_binary
+	end
+
+	def find_agents_dir
+		return "#{find_support_dir}/agents"
+	end
+
+	def find_lib_dir
+		return find_support_dir
+	end
+
+	def everything_installed?
+		return find_support_dir && find_nginx_binary
+	end
+
+	def install_targets
+		result = []
+		result << :nginx if find_nginx_binary.nil?
+		result << :support_binaries if find_support_dir.nil?
+		return result
+	end
+
+	# Returns the directory to which support binaries may be installed,
+	# in case the RuntimeInstaller is to be invoked.
+	def support_dir_install_destination
+		if PhusionPassenger.originally_packaged?
+			if debugging?
+				return "#{PhusionPassenger.lib_dir}/common/libpassenger_common"
+			else
+				return "#{@runtime_dir}/#{version}/support-#{cxx_compat_id}"
+			end
+		else
+			return nil
+		end
+	end
+
+	# Returns the directory to which the Nginx binary may be installed,
+	# in case the RuntimeInstaller is to be invoked.
+	def nginx_binary_install_destination
+		return "#{@runtime_dir}/#{version}/nginx-#{@nginx_version}-#{cxx_compat_id}"
+	end
+
+private
+	def default_runtime_dir
+		home = Etc.getpwuid.dir
+		return "#{home}/#{USER_NAMESPACE_DIRNAME}/standalone"
+	end
+
+	def debugging?
+		return ['yes', 'y', 'true', '1'].include?(ENV['PASSENGER_DEBUG'].to_s.downcase)
+	end
+
+	def version
+		return PhusionPassenger::VERSION_STRING
+	end
+
+	def cxx_compat_id
+		return PlatformInfo.cxx_binary_compatibility_id
+	end
+
+	def config_filename
+		return "#{@runtime_dir}/config.json"
+	end
+end
+
+end # module Standalone
+end # module PhusionPassenger

data/lib/phusion_passenger/standalone/start_command.rb

@@ -30,10 +30,6 @@ require 'phusion_passenger/standalone/command'
 # We lazy load as many libraries as possible not only to improve startup performance,
 # but also to ensure that we don't require libraries before we've passed the dependency
 # checking stage of the runtime installer.
-#
-# IMPORTANT: do not directly or indirectly require native_support; we can't compile
-# it yet until we have a compiler, and the runtime installer is supposed to check whether
-# a compiler is installed.
 
 module PhusionPassenger
 module Standalone
@@ -56,8 +52,11 @@ class StartCommand < Command
 		parse_my_options
 		sanity_check_options
 
-		@runtime_dirs = determine_runtime_dirs
-		ensure_nginx_installed
+		require 'phusion_passenger/standalone/runtime_locator'
+		@runtime_locator = RuntimeLocator.new(@options[:runtime_dir],
+			@options[:nginx_version])
+		ensure_runtime_installed
+		exit if @options[:runtime_check_only]
 		determine_various_resource_locations
 		require_app_finder
 		@app_finder = AppFinder.new(@args, @options)
@@ -204,6 +203,8 @@ private
 				wrap_desc("Where to store the PID file")) do |value|
 				@options[:pid_file] = value
 			end
+
+			opts.separator ""
 			opts.on("--nginx-bin FILENAME", String,
 				wrap_desc("Nginx binary to use as core")) do |value|
 				@options[:nginx_bin] = value
@@ -222,10 +223,22 @@ private
 				          "checked for binaries prior to a local build.")) do |value|
 				@options[:binaries_url_root] = value
 			end
+			opts.on("--no-download-binaries",
+				wrap_desc("Never download binaries")) do
+				@options[:download_binaries] = false
+			end
 			opts.on("--runtime-dir DIRECTORY", String,
 				wrap_desc("Directory to use for Phusion Passenger Standalone runtime files")) do |value|
 				@options[:runtime_dir] = File.expand_path(value)
 			end
+			opts.on("--runtime-check-only",
+				wrap_desc("Quit after checking whether the Phusion Passenger Standalone runtime files are installed")) do
+				@options[:runtime_check_only] = true
+			end
+			opts.on("--no-compile-runtime",
+				wrap_desc("Abort if runtime must be compiled")) do
+				@options[:dont_compile_runtime] = true
+			end
 		end
 		@plugin.call_hook(:done_parsing_options)
 	end
@@ -362,58 +375,37 @@ private
 		end
 	end
 
-	def install_runtime(runtime_dirs)
+	def install_runtime(runtime_locator)
 		require 'phusion_passenger/standalone/runtime_installer'
 		installer = RuntimeInstaller.new(
-			:targets     => [:nginx, :ruby, :support_binaries],
-			:support_dir => runtime_dirs[:support_dir],
-			:nginx_dir   => runtime_dirs[:nginx_dir],
-			:ruby_dir    => runtime_dirs[:ruby_dir],
+			:targets     => runtime_locator.install_targets,
+			:support_dir => runtime_locator.support_dir_install_destination,
+			:nginx_dir   => runtime_locator.nginx_binary_install_destination,
+			:lib_dir     => runtime_locator.find_lib_dir || runtime_locator.support_dir_install_destination,
 			:nginx_version     => @options[:nginx_version],
 			:nginx_tarball     => @options[:nginx_tarball],
 			:binaries_url_root => @options[:binaries_url_root],
+			:download_binaries => @options.fetch(:download_binaries, true),
+			:dont_compile_runtime => @options[:dont_compile_runtime],
 			:plugin      => @plugin)
 		return installer.run
 	end
 
-	def determine_runtime_dirs
-		require_platform_info_binary_compatibility
-		if root = @options[:runtime_dir]
-			nginx_dir = determine_nginx_runtime_dir(root)
-		else
-			root = "#{GLOBAL_STANDALONE_RESOURCE_DIR}/#{PhusionPassenger::VERSION_STRING}"
-			nginx_dir = determine_nginx_runtime_dir(root)
-			if !File.exist?("#{nginx_dir}/nginx") && Process.euid != 0
-				home      = Etc.getpwuid.dir
-				root      = "#{home}/#{LOCAL_STANDALONE_RESOURCE_DIR}/#{PhusionPassenger::VERSION_STRING}"
-				nginx_dir = determine_nginx_runtime_dir(root)
-			end
-		end
-		nginx_bin = @options[:nginx_bin] || "#{nginx_dir}/nginx"
-		result = {
-			:root => root,
-			:support_dir => "#{root}/support-#{PlatformInfo.cxx_binary_compatibility_id}",
-			:nginx_dir => nginx_dir,
-			:ruby_dir => "#{root}/rubyext-#{PlatformInfo.ruby_extension_binary_compatibility_id}",
-			:nginx_installed => File.exist?(nginx_bin)
-		}
-		result[:support_dir_installed] = File.exist?(result[:support_dir] + "/agents/PassengerWatchdog")
-		result[:everything_installed] = result[:nginx_installed] && result[:support_dir_installed]
-		return result
-	end
-
-	def determine_nginx_runtime_dir(runtime_dir)
-		return "#{runtime_dir}/nginx-#{@options[:nginx_version]}-#{PlatformInfo.cxx_binary_compatibility_id}"
-	end
-
-	def ensure_nginx_installed
-		if !@runtime_dirs[:everything_installed]
-			if !@runtime_dirs[:nginx_installed] && @options[:nginx_bin]
-				error "The given Nginx binary '#{@options[:nginx_bin]}' does not exist."
+	def ensure_runtime_installed
+		if @runtime_locator.everything_installed?
+			if !File.exist?(@runtime_locator.find_nginx_binary)
+				error "The Nginx binary '#{@runtime_locator.find_nginx_binary}' does not exist."
 				exit 1
-			elsif !install_runtime(@runtime_dirs)
+			end
+		else
+			if !@runtime_locator.find_support_dir && PhusionPassenger.natively_packaged?
+				error "Your Phusion Passenger Standalone installation is broken: the support " +
+					"files could not be found. Please reinstall Phusion Passenger Standalone. " +
+					"If this problem persists, please contact your packager."
 				exit 1
 			end
+			install_runtime(@runtime_locator) || exit(1)
+			@runtime_locator.reload
 		end
 	end
 

data/lib/phusion_passenger/utils/json.rb

@@ -0,0 +1,329 @@
+# encoding: utf-8
+#
+## Stupid small pure Ruby JSON parser & generator.
+#
+# Copyright © 2013 Mislav Marohnić
+#
+# 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.
+
+# We use this in Phusion Passenger at places where we cannot depend on the JSON
+# gem being available, for example in 'passenger start' before the RuntimeInstaller
+# has run.
+
+require 'strscan'
+require 'forwardable'
+
+module PhusionPassenger
+module Utils
+
+# Usage:
+#
+#   JSON.parse(json_string) => Array/Hash
+#   JSON.generate(object)   => json string
+#
+# Run tests by executing this file directly. Pipe standard input to the script to have it
+# parsed as JSON and to display the result in Ruby.
+#
+class JSON
+  def self.parse(data) new(data).parse end
+
+  WSP = /\s+/
+  OBJ = /[{\[]/;    HEN = /\}/;  AEN = /\]/
+  COL = /\s*:\s*/;  KEY = /\s*,\s*/
+  NUM = /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/
+  BOL = /true|false/;  NUL = /null/
+
+  extend Forwardable
+
+  attr_reader :scanner
+  alias_method :s, :scanner
+  def_delegators :scanner, :scan, :matched
+  private :s, :scan, :matched
+
+  def initialize data
+    @scanner = StringScanner.new data.to_s
+  end
+
+  def parse
+    space
+    object
+  end
+
+  private
+
+  def space() scan WSP end
+
+  def endkey() scan(KEY) or space end
+
+  def object
+    matched == '{' ? hash : array if scan(OBJ)
+  end
+
+  def value
+    object or string or
+      scan(NUL) ? nil :
+      scan(BOL) ? matched.size == 4:
+      scan(NUM) ? eval(matched) :
+      error
+  end
+
+  def hash
+    obj = {}
+    space
+    repeat_until(HEN) { k = string; scan(COL); obj[k] = value; endkey }
+    obj
+  end
+
+  def array
+    ary = []
+    space
+    repeat_until(AEN) { ary << value; endkey }
+    ary
+  end
+
+  SPEC = {'b' => "\b", 'f' => "\f", 'n' => "\n", 'r' => "\r", 't' => "\t"}
+  UNI = 'u'; CODE = /[a-fA-F0-9]{4}/
+  STR = /"/; STE = '"'
+  ESC = '\\'
+
+  def string
+    if scan(STR)
+      str, esc = '', false
+      while c = s.getch
+        if esc
+          str << (c == UNI ? (s.scan(CODE) || error).to_i(16).chr : SPEC[c] || c)
+          esc = false
+        else
+          case c
+          when ESC then esc = true
+          when STE then break
+          else str << c
+          end
+        end
+      end
+      str
+    end
+  end
+
+  def error
+    raise "parse error at: #{scan(/.{1,10}/m).inspect}"
+  end
+
+  def repeat_until reg
+    until scan(reg)
+      pos = s.pos
+      yield
+      error unless s.pos > pos
+    end
+  end
+
+  module Generator
+    def generate(obj)
+      raise ArgumentError unless obj.is_a? Array or obj.is_a? Hash
+      generate_type(obj)
+    end
+    alias dump generate
+
+    private
+
+    def generate_type(obj)
+      type = obj.is_a?(Numeric) ? :Numeric : obj.class.name
+      begin send(:"generate_#{type}", obj)
+      rescue NoMethodError; raise ArgumentError, "can't serialize #{type}"
+      end
+    end
+
+    ESC_MAP = Hash.new {|h,k| k }.update \
+      "\r" => 'r',
+      "\n" => 'n',
+      "\f" => 'f',
+      "\t" => 't',
+      "\b" => 'b'
+
+    def quote(str) %("#{str}") end
+
+    def generate_String(str)
+      quote str.gsub(/[\r\n\f\t\b"\\]/) { "\\#{ESC_MAP[$&]}"}
+    end
+
+    def generate_simple(obj) obj.inspect end
+    alias generate_Numeric generate_simple
+    alias generate_TrueClass generate_simple
+    alias generate_FalseClass generate_simple
+
+    def generate_Symbol(sym) generate_String(sym.to_s) end
+
+    def generate_Time(time)
+      quote time.strftime(time.utc? ? "%F %T UTC" : "%F %T %z")
+    end
+    def generate_Date(date) quote date.to_s end
+
+    def generate_NilClass(*) 'null' end
+
+    def generate_Array(ary) '[%s]' % ary.map {|o| generate_type(o) }.join(', ') end
+
+    def generate_Hash(hash)
+      '{%s}' % hash.map { |key, value|
+        "#{generate_String(key.to_s)}: #{generate_type(value)}"
+      }.join(', ')
+    end
+  end
+
+  extend Generator
+end
+
+if __FILE__ == $0
+if !$stdin.tty?
+  data = JSON.parse $stdin.read
+  require 'pp'
+  pp data
+else
+  require 'test/unit'
+  require 'date'
+  class ParserTest < Test::Unit::TestCase
+    PARSED = JSON.parse DATA.read
+    def parsed() PARSED end
+    def parse_string(str) JSON.parse(%(["#{str}"]).gsub('\\\\', '\\')).first end
+    def test_string
+      assert_equal "Pagination library for \"Rails 3\", Sinatra, Merb, DataMapper, and more",
+        parsed['head']['repository']['description']
+    end
+    def test_string_specials
+      assert_equal "\r\n\t\f\b", parse_string('\r\n\t\f\b')
+      assert_equal "aA", parse_string('\u0061\u0041')
+      assert_equal "\e", parse_string('\u001B')
+      assert_equal "xyz", parse_string('\x\y\z')
+      assert_equal '"\\/', parse_string('\"\\\\\\/')
+      assert_equal 'no #{interpolation}', parse_string('no #{interpolation}')
+    end
+    def test_hash
+      assert_equal %w[label ref repository sha user], parsed['head'].keys.sort
+    end
+    def test_number
+      assert_equal 124.3e2, parsed['head']['repository']['size']
+    end
+    def test_bool
+      assert_equal true, parsed['head']['repository']['fork']
+      assert_equal false, parsed['head']['repository']['private']
+    end
+    def test_nil
+      assert_nil parsed['head']['user']['company']
+    end
+    def test_array
+      assert_equal ["4438f", {"a" => "b"}], parsed['head']['sha']
+    end
+    def test_invalid
+      assert_raises(RuntimeError) { JSON.parse %({) }
+      assert_raises(RuntimeError) { JSON.parse %({ "foo": }) }
+      assert_raises(RuntimeError) { JSON.parse %([ "foo": "bar" ]) }
+      assert_raises(RuntimeError) { JSON.parse %([ ~"foo" ]) }
+      assert_raises(RuntimeError) { JSON.parse %([ "foo ]) }
+      assert_raises(RuntimeError) { JSON.parse %([ "foo\\" ]) }
+      assert_raises(RuntimeError) { JSON.parse %([ "foo\\uabGd" ]) }
+    end
+  end
+
+  class GeneratorTest < Test::Unit::TestCase
+    def generate(obj) JSON.generate(obj) end
+    def test_array
+      assert_equal %([1, 2, 3]), generate([1, 2, 3])
+    end
+    def test_bool
+      assert_equal %([true, false]), generate([true, false])
+    end
+    def test_null
+      assert_equal %([null]), generate([nil])
+    end
+    def test_string
+      assert_equal %(["abc\\n123"]), generate(["abc\n123"])
+    end
+    def test_string_unicode
+      assert_equal %(["ć\\"č\\nž\\tš\\\\đ"]), generate(["ć\"č\nž\tš\\đ"])
+    end
+    def test_time
+      time = Time.utc(2012, 04, 19, 1, 2, 3)
+      assert_equal %(["2012-04-19 01:02:03 UTC"]), generate([time])
+    end
+    def test_date
+      time = Date.new(2012, 04, 19)
+      assert_equal %(["2012-04-19"]), generate([time])
+    end
+    def test_symbol
+      assert_equal %(["abc"]), generate([:abc])
+    end
+    def test_hash
+      json = generate(:abc => 123, 123 => 'abc')
+      assert_match /^\{/, json
+      assert_match /\}$/, json
+      assert_equal [%("123": "abc"), %("abc": 123)], json[1...-1].split(', ').sort
+    end
+    def test_nested_structure
+      json = generate(:hash => {1=>2}, :array => [1,2])
+      assert json.include?(%("hash": {"1": 2}))
+      assert json.include?(%("array": [1, 2]))
+    end
+    def test_invalid_json
+      assert_raises(ArgumentError) { generate("abc") }
+    end
+    def test_invalid_object
+      err = assert_raises(ArgumentError) { generate("a" => Object.new) }
+      assert_equal "can't serialize Object", err.message
+    end
+  end
+end
+end
+
+end # module Utils
+end # module PhusionPassenger
+
+__END__
+{
+  "head": {
+    "ref": "master",
+    "repository": {
+      "forks": 0,
+      "integrate_branch": "rails3",
+      "watchers": 1,
+      "language": "Ruby",
+      "description": "Pagination library for \"Rails 3\", Sinatra, Merb, DataMapper, and more",
+      "has_downloads": true,
+      "fork": true,
+      "created_at": "2011/10/24 03:20:48 -0700",
+      "homepage": "http://github.com/mislav/will_paginate/wikis",
+      "size": 124.3e2,
+      "private": false,
+      "has_wiki": true,
+      "name": "will_paginate",
+      "owner": "dbackeus",
+      "url": "https://github.com/dbackeus/will_paginate",
+      "has_issues": false,
+      "open_issues": 0,
+      "pushed_at": "2011/10/25 05:44:05 -0700"
+    },
+    "label": "dbackeus:master",
+    "sha": ["4438f", { "a" : "b" }],
+    "user": {
+      "name": "David Backeus",
+      "company": null,
+      "gravatar_id": "ebe96524f5db9e92188f0542dc9d1d1a",
+      "location": "Stockholm (Sweden)",
+      "type": "User",
+      "login": "dbackeus"
+    }
+  }
+}