### Home Classes Methods

### In Files

- lib/phusion_passenger/utils/tmpio.rb
- lib/phusion_passenger/utils/unseekable_socket.rb
- lib/phusion_passenger/utils/ansi_colors.rb
- lib/phusion_passenger/utils/file_system_watcher.rb
- lib/phusion_passenger/utils/hosts_file_parser.rb
- lib/phusion_passenger/utils/tee_input.rb
- lib/phusion_passenger/utils/tmpdir.rb
- lib/phusion_passenger/utils.rb

### Namespace

- MODULE PhusionPassenger::Utils::AnsiColors
- CLASS PhusionPassenger::Utils::FileSystemWatcher
- CLASS PhusionPassenger::Utils::HostsFileParser
- CLASS PhusionPassenger::Utils::TeeInput
- CLASS PhusionPassenger::Utils::TmpIO
- CLASS PhusionPassenger::Utils::UnseekableSocket

### Methods

- ::included
- ::mktmpdir
- ::new
- ::opens_files?
- ::passenger_tmpdir
- ::passenger_tmpdir=
- #connect_to_server
- #generate_random_id
- #get_socket_address_type
- #global_backtrace_report
- #install_options_as_ivars
- #local_socket_address?
- #passenger_tmpdir
- #print_exception
- #process_is_alive?
- #require_option
- #split_by_null_into_hash

### Class/Module Index

Quicksearch

- PhusionPassenger
- PhusionPassenger::AbstractInstaller
- PhusionPassenger::AbstractInstaller::Abort
- PhusionPassenger::AbstractInstaller::CommandError
- PhusionPassenger::AdminTools
- PhusionPassenger::AdminTools::MemoryStats
- PhusionPassenger::AdminTools::MemoryStats::Process
- PhusionPassenger::AdminTools::ServerInstance
- PhusionPassenger::AdminTools::ServerInstance::CorruptedDirectoryError
- PhusionPassenger::AdminTools::ServerInstance::GenerationsAbsentError
- PhusionPassenger::AdminTools::ServerInstance::Group
- PhusionPassenger::AdminTools::ServerInstance::Process
- PhusionPassenger::AdminTools::ServerInstance::RoleDeniedError
- PhusionPassenger::AdminTools::ServerInstance::StaleDirectoryError
- PhusionPassenger::AdminTools::ServerInstance::Stats
- PhusionPassenger::AdminTools::ServerInstance::UnsupportedGenerationStructureVersionError
- PhusionPassenger::AnalyticsLogger
- PhusionPassenger::AnalyticsLogger::Connection
- PhusionPassenger::AnalyticsLogger::Lock
- PhusionPassenger::AnalyticsLogger::Log
- PhusionPassenger::ClassicRails
- PhusionPassenger::ClassicRails::CGIFixed
- PhusionPassenger::ClassicRails::ThreadHandlerExtension
- PhusionPassenger::ConsoleTextTemplate
- PhusionPassenger::DebugLogging
- PhusionPassenger::LoaderSharedHelpers
- PhusionPassenger::MessageChannel
- PhusionPassenger::MessageChannel::InvalidHashError
- PhusionPassenger::MessageClient
- PhusionPassenger::NativeSupportLoader
- PhusionPassenger::Packaging
- PhusionPassenger::PlatformInfo
- PhusionPassenger::PlatformInfo::Depcheck
- PhusionPassenger::PlatformInfo::Depcheck::ConsoleRunner
- PhusionPassenger::PlatformInfo::Depcheck::Dependency
- PhusionPassenger::PlatformInfo::RuntimeError
- PhusionPassenger::Plugin
- PhusionPassenger::PreloaderSharedHelpers
- PhusionPassenger::Rack
- PhusionPassenger::Rack::OutOfBandGc
- PhusionPassenger::Rack::ThreadHandlerExtension
- PhusionPassenger::Rails3Extensions
- PhusionPassenger::Rails3Extensions::AnalyticsLogging
- PhusionPassenger::Rails3Extensions::AnalyticsLogging::ACExtension
- PhusionPassenger::Rails3Extensions::AnalyticsLogging::ASBenchmarkableExtension
- PhusionPassenger::Rails3Extensions::AnalyticsLogging::ExceptionLogger
- PhusionPassenger::RequestHandler
- PhusionPassenger::RequestHandler::ThreadHandler
- PhusionPassenger::RequestHandler::ThreadHandler::Interrupted
- PhusionPassenger::SharedConstants
- PhusionPassenger::Standalone
- PhusionPassenger::Standalone::AppFinder
- PhusionPassenger::Standalone::Command
- PhusionPassenger::Standalone::ConfigFile
- PhusionPassenger::Standalone::ConfigFile::DisallowedContextError
- PhusionPassenger::Standalone::HelpCommand
- PhusionPassenger::Standalone::Main
- PhusionPassenger::Standalone::PackageRuntimeCommand
- PhusionPassenger::Standalone::RuntimeInstaller
- PhusionPassenger::Standalone::StartCommand
- PhusionPassenger::Standalone::StatusCommand
- PhusionPassenger::Standalone::StopCommand
- PhusionPassenger::Standalone::Utils
- PhusionPassenger::Standalone::VersionCommand
- PhusionPassenger::Utils
- PhusionPassenger::Utils::AnsiColors
- PhusionPassenger::Utils::FileSystemWatcher
- PhusionPassenger::Utils::FileSystemWatcher::DirInfo
- PhusionPassenger::Utils::FileSystemWatcher::FileInfo
- PhusionPassenger::Utils::HostsFileParser
- PhusionPassenger::Utils::TeeInput
- PhusionPassenger::Utils::TmpIO
- PhusionPassenger::Utils::UnseekableSocket
- CommonLibraryBuilder
- Exception
- GC
- IO
- Object
- Signal

No matching classes.

# PhusionPassenger::Utils

Utility functions.

### Constants

FileSystemWatcher
NULL

### Public Class Methods

included(klass) click to toggle source

    # File lib/phusion_passenger/utils.rb, line 33
    def self.included(klass)
            # When included into another class, make sure that Utils
            # methods are made private.
            public_instance_methods(false).each do |method_name|
                    klass.send(:private, method_name)
            end
    end

mktmpdir(prefix_suffix=nil, tmpdir=nil) click to toggle source

Like Dir.mktmpdir, but creates shorter filenames.

    # File lib/phusion_passenger/utils/tmpio.rb, line 33
    def self.mktmpdir(prefix_suffix=nil, tmpdir=nil)
      case prefix_suffix
      when nil
        prefix = "d"
        suffix = ""
      when String
        prefix = prefix_suffix
        suffix = ""
      when Array
        prefix = prefix_suffix[0]
        suffix = prefix_suffix[1]
      else
        raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
      end
      tmpdir ||= Dir.tmpdir
      begin
        path = "#{tmpdir}/#{prefix}#{rand(0x100000000).to_s(36)}"
        path << suffix
        Dir.mkdir(path, 0700)
      rescue Errno::EEXIST
        retry
      end

      if block_given?
        begin
          yield path
        ensure
          FileUtils.remove_entry_secure path
        end
      else
        path
      end
    end

new(filenames, termination_pipe = nil) click to toggle source

    # File lib/phusion_passenger/utils/file_system_watcher.rb, line 60
    def self.new(filenames, termination_pipe = nil)
            # Default parameter values, type conversion and exception
            # handling in C is too much of a pain.
            filenames = filenames.map do |filename|
                    filename.to_s
            end
            return _new(filenames, termination_pipe)
    end

opens_files?() click to toggle source

    # File lib/phusion_passenger/utils/file_system_watcher.rb, line 69
    def self.opens_files?
            return true
    end

### Protected Class Methods

passenger_tmpdir(create = true) click to toggle source

Returns the directory in which to store Phusion Passenger-specific temporary files. If `create` is true, then this method creates the directory if it doesn't exist.

    # File lib/phusion_passenger/utils/tmpdir.rb, line 37
    def self.passenger_tmpdir(create = true)
            dir = @@passenger_tmpdir
            if dir.nil? || dir.empty?
                    tmpdir = "/tmp"
                    ["PASSENGER_TEMP_DIR", "PASSENGER_TMPDIR"].each do |name|
                            if ENV.has_key?(name) && !ENV[name].empty?
                                    tmpdir = ENV[name]
                                    break
                            end
                    end
                    dir = "#{tmpdir}/passenger.1.0.#{Process.pid}"
                    dir.gsub!(%{//+}, '/')
                    @@passenger_tmpdir = dir
            end
            if create && !File.exist?(dir)
                    # This is a very minimal implementation of the subdirectory
                    # creation logic in ServerInstanceDir.h. This implementation
                    # is only meant to make the unit tests pass. For production
                    # systems one should pre-create the temp directory with
                    # ServerInstanceDir.h.
                    system("mkdir", "-p", "-m", "u=rwxs,g=rwx,o=rwx", dir)
                    system("mkdir", "-p", "-m", "u=rwxs,g=rwx,o=rwx", "#{dir}/generation-0")
                    system("mkdir", "-p", "-m", "u=rwxs,g=rwx,o=rwx", "#{dir}/backends")
                    system("mkdir", "-p", "-m", "u=rwxs,g=rwx,o=rwx", "#{dir}/spawn-server")
            end
            return dir
    end

passenger_tmpdir=(dir) click to toggle source

    # File lib/phusion_passenger/utils/tmpdir.rb, line 65
    def self.passenger_tmpdir=(dir)
            @@passenger_tmpdir = dir
    end

### Public Instance Methods

connect_to_server(address) click to toggle source

    # File lib/phusion_passenger/utils.rb, line 89
    def connect_to_server(address)
            case get_socket_address_type(address)
            when :unix
                    return UNIXSocket.new(address.sub(/^unix:/, ''))
            when :tcp
                    host, port = address.sub(%{^tcp://}, '').split(':', 2)
                    port = port.to_i
                    return TCPSocket.new(host, port)
            else
                    raise ArgumentError, "Unknown socket address type for '#{address}'."
            end
    end

generate_random_id(method) click to toggle source

Generate a long, cryptographically secure random ID string, which is also a valid filename.

    # File lib/phusion_passenger/utils.rb, line 43
    def generate_random_id(method)
            data = File.open("/dev/urandom", "rb") do |f|
                    f.read(64)
            end
            case method
            when :base64
                    data = [data].pack('m')
                    data.gsub!("\n", '')
                    data.gsub!("+", '')
                    data.gsub!("/", '')
                    data.gsub!(/==$/, '')
                    return data
            when :hex
                    return data.unpack('H*')[0]
            else
                    raise ArgumentError, "Invalid method #{method.inspect}"
            end
    end

get_socket_address_type(address) click to toggle source

    # File lib/phusion_passenger/utils.rb, line 79
    def get_socket_address_type(address)
            if address =~ %{^unix:.}
                    return :unix
            elsif address =~ %{^tcp://.}
                    return :tcp
            else
                    return :unknown
            end
    end

global_backtrace_report() click to toggle source

Returns a string which reports the backtraces for all threads, or if that's not supported the backtrace for the current thread.

    # File lib/phusion_passenger/utils.rb, line 142
    def global_backtrace_report
            if Kernel.respond_to?(:caller_for_all_threads)
                    all_thread_stacks = caller_for_all_threads
            elsif Thread.respond_to?(:list) && Thread.public_method_defined?(:backtrace)
                    all_thread_stacks = {}
                    Thread.list.each do |thread|
                            all_thread_stacks[thread] = thread.backtrace
                    end
            end

            output = "========== Process #{Process.pid}: backtrace dump ==========\n"
            if all_thread_stacks
                    all_thread_stacks.each_pair do |thread, stack|
                            if thread_name = thread[:name]
                                    thread_name = "(#{thread_name})"
                            end
                            output << ("-" * 60) << "\n"
                            output << "# Thread: #{thread.inspect}#{thread_name}, "
                            if thread == Thread.main
                                    output << "[main thread], "
                            end
                            if thread == Thread.current
                                    output << "[current thread], "
                            end
                            output << "alive = #{thread.alive?}\n"
                            output << ("-" * 60) << "\n"
                            output << "    " << stack.join("\n    ")
                            output << "\n\n"
                    end
            else
                    output << ("-" * 60) << "\n"
                    output << "# Current thread: #{Thread.current.inspect}\n"
                    output << ("-" * 60) << "\n"
                    output << "    " << caller.join("\n    ")
            end
            return output
    end

install_options_as_ivars(object, options, *keys) click to toggle source

    # File lib/phusion_passenger/utils.rb, line 134
    def install_options_as_ivars(object, options, *keys)
            keys.each do |key|
                    object.instance_variable_set("@#{key}", options[key])
            end
    end

local_socket_address?(address) click to toggle source

    # File lib/phusion_passenger/utils.rb, line 102
    def local_socket_address?(address)
            case get_socket_address_type(address)
            when :unix
                    return true
            when :tcp
                    host, port = address.sub(%{^tcp://}, '').split(':', 2)
                    return host == "127.0.0.1" || host == "::1" || host == "localhost"
            else
                    raise ArgumentError, "Unknown socket address type for '#{address}'."
            end
    end

print_exception(current_location, exception, destination = nil) click to toggle source

Print the given exception, including the stack trace, to STDERR.

`current_location` is a string which describes where the code is currently at. Usually the current class name will be enough.

    # File lib/phusion_passenger/utils.rb, line 66
    def print_exception(current_location, exception, destination = nil)
            if !exception.is_a?(SystemExit)
                    data = exception.backtrace_string(current_location)
                    if defined?(DebugLogging) && self.is_a?(DebugLogging)
                            error(data)
                    else
                            destination ||= STDERR
                            destination.puts(data)
                            destination.flush if destination.respond_to?(:flush)
                    end
            end
    end

process_is_alive?(pid) click to toggle source

Checks whether the given process exists.

    # File lib/phusion_passenger/utils.rb, line 115
    def process_is_alive?(pid)
            begin
                    Process.kill(0, pid)
                    return true
            rescue Errno::ESRCH
                    return false
            rescue SystemCallError => e
                    return true
            end
    end

require_option(hash, key) click to toggle source

    # File lib/phusion_passenger/utils.rb, line 126
    def require_option(hash, key)
            if hash.has_key?(key)
                    return hash[key]
            else
                    raise ArgumentError, "Option #{key.inspect} required"
            end
    end

split_by_null_into_hash(data) click to toggle source

Split the given string into an hash. Keys and values are obtained by splitting the string using the null character as the delimitor.

    # File lib/phusion_passenger/utils.rb, line 183
    def split_by_null_into_hash(data)
            return PhusionPassenger::NativeSupport.split_by_null_into_hash(data)
    end

### Protected Instance Methods

passenger_tmpdir(create = true) click to toggle source

    # File lib/phusion_passenger/utils/tmpdir.rb, line 30
    def passenger_tmpdir(create = true)
            PhusionPassenger::Utils.passenger_tmpdir(create)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.