Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-11-20 11:36
📄 README.md This directory contains scripts that Passenger executes during runtime. These scripts are not supposed to be directly executed by the user. All the loaders - applications which are responsible for loading an application written in a certain language and hooking it up to Passenger - are in this directory.	306 B	2025-11-20 11:36
📄 backtrace-sanitizer.rb #!/usr/bin/ruby # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2013-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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. # Parses output of the glibc backtrace() function and # translates addresses into function names and source # file locations. class Addr2line attr_reader :stdin, :stdout, :pid def initialize(filename) a, b = IO.pipe c, d = IO.pipe @pid = fork do STDIN.reopen(a) b.close STDOUT.reopen(d) c.close exec("addr2line", "-Cfie", filename) end a.close d.close @stdin = b @stdout = c @stdin.sync = @stdout.sync = true end def query(address) @stdin.write("#{address}\n") function = @stdout.readline source = @stdout.readline function.strip! source.strip! return [function, source] end def close @stdin.close @stdout.close Process.kill('KILL', @pid) Process.waitpid(@pid) rescue nil end end def passthrough(input, output) while !input.eof? data = input.readline output.write(data) output.flush end end def debug(message) #puts message end input = STDIN output = STDERR output.sync = true output.puts "Using backtrace sanitizer." argv0, pid_or_filename = ARGV if pid_or_filename =~ /\A\d+\Z/ begin exe_filename = File.expand_path(File.readlink("/proc/#{pid_or_filename}/exe")) rescue Errno::ENOENT, Errno::EACCES => e warn "*** backtrace-sanitizer warning: #{e} -> passthrough input" passthrough(input, output) exit end else exe_filename = File.expand_path(pid_or_filename) end exe_basename = File.basename(exe_filename) addr2lines = {} begin while !input.eof? line = input.readline.strip debug " ---> Parse #{line.inspect}" # Example lines: # ./test() [0x400b64] # /lib/libc.so.6(__libc_start_main+0xfd) [0x7fcc0ad00c8d] # Passenger core[0x4d2697] if line =~ /(.)\[(.?)\]$/ # Split line into: # subject: /lib/libc.so.6(__libc_start_main+0xfd) # address: 0x7fcc0ad00c8d subject = $1 address = $2 subject.strip! if subject =~ /(.?)(\((.?)\))?$/ # Split subject into: # file: /lib/libc.so.6 # context: __libc_start_main+0xfd file = $1 context = $3 file.strip! context = nil if context && context.empty? else file = subject context = nil end debug " file = #{file.inspect}" debug " context = #{context.inspect}" debug " address = #{address.inspect}" if file =~ /\A\// && File.exist?(file) filename = file elsif file == argv0 \|\| file == exe_filename \|\| file == exe_basename \|\| file.sub(/ .*/, '') == exe_basename filename = exe_filename else filename = nil end if filename.nil? output.puts line else addr2line = (addr2lines[filename] \|\|= Addr2line.new(filename)) function, source = addr2line.query(address) new_context = "#{function} at #{source}" new_context << "; #{context}" if context output.puts "#{file}(#{new_context}) [#{address}]" end else output.puts line end end ensure addr2lines.each_value do \|addr2line\| addr2line.close end end	4.36 KB	2025-11-20 11:36
📄 crash-watch.rb #!/usr/bin/ruby # Copyright (c) 2015-2025 Asynchronous B.V. # # 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. # This script uses GDB to attach to a process in order to dump the # backtraces of all its threads. STDOUT.sync = true STDERR.sync = true ruby_libdir = ARGV.shift passenger_root = ARGV.shift require "#{ruby_libdir}/phusion_passenger" PhusionPassenger.locate_directories(passenger_root) PhusionPassenger.require_passenger_lib 'vendor/crash_watch/app' CrashWatch::App.new.run(ARGV)	1.47 KB	2025-11-20 11:36
📁 download_binaries	-	2026-03-21 15:53
📄 meteor-loader.rb #!/usr/bin/ruby # encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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 'socket' require 'thread' require 'logger' module PhusionPassenger module App def self.options @@options \|\|= {} return @@options end def self.try_write_file(path, contents) begin File.open(path, 'wb') do \|f\| f.write(contents) end rescue SystemCallError => e STDERR.puts "Warning: unable to write to #{path}: #{e}" end end def self.record_journey_step_begin(step, state, work_dir = nil) dir = work_dir \|\| ENV['PASSENGER_SPAWN_WORK_DIR'] step_dir = "#{dir}/response/steps/#{step.downcase}" try_write_file("#{step_dir}/state", state) try_write_file("#{step_dir}/begin_time", Time.now.to_f) end def self.record_journey_step_end(step, state, work_dir = nil) dir = work_dir \|\| ENV['PASSENGER_SPAWN_WORK_DIR'] step_dir = "#{dir}/response/steps/#{step.downcase}" try_write_file("#{step_dir}/state", state) if !File.exist?("#{step_dir}/begin_time") && !File.exist?("#{step_dir}/begin_time_monotonic") try_write_file("#{step_dir}/begin_time", Time.now.to_f) end try_write_file("#{step_dir}/end_time", Time.now.to_f) end def self.init_logging logger = Logger.new(STDOUT) logger.level = Logger::WARN logger.formatter = proc do \|severity, datetime, progname, msg\| "[ pid=#{Process.pid}, time=#{datetime} ]: #{msg.message}" end end def self.read_startup_arguments work_dir = ENV['PASSENGER_SPAWN_WORK_DIR'] @@options = File.open("#{work_dir}/args.json", 'rb') do \|f\| Utils::JSON.parse(f.read) end end def self.advertise_port(port) work_dir = ENV['PASSENGER_SPAWN_WORK_DIR'] path = work_dir + '/response/properties.json' doc = { 'sockets': [{ 'name': 'main', 'address': "tcp://127.0.0.1:#{port}", 'protocol': 'http', 'concurrency': 0, 'accept_http_requests': true }] } File.write(path, Utils::JSON.generate(doc)) end def self.advertise_readiness work_dir = ENV['PASSENGER_SPAWN_WORK_DIR'] path = work_dir + '/response/finish' File.write(path, '1') end def self.init_passenger STDOUT.sync = true STDERR.sync = true work_dir = ENV['PASSENGER_SPAWN_WORK_DIR'].to_s if work_dir.empty? abort "This program may only be invoked from Passenger (error: $PASSENGER_SPAWN_WORK_DIR not set)." end ruby_libdir = File.read("#{work_dir}/args/ruby_libdir").strip passenger_root = File.read("#{work_dir}/args/passenger_root").strip require "#{ruby_libdir}/phusion_passenger" PhusionPassenger.locate_directories(passenger_root) PhusionPassenger.require_passenger_lib 'loader_shared_helpers' PhusionPassenger.require_passenger_lib 'preloader_shared_helpers' PhusionPassenger.require_passenger_lib 'utils/json' require 'socket' end def self.ping_port(port) socket_domain = Socket::Constants::AF_INET sockaddr = Socket.pack_sockaddr_in(port, '127.0.0.1') begin socket = Socket.new(socket_domain, Socket::Constants::SOCK_STREAM, 0) begin socket.connect_nonblock(sockaddr) rescue Errno::ENOENT, Errno::EINPROGRESS, Errno::EAGAIN, Errno::EWOULDBLOCK if select(nil, [socket], nil, 0.1) begin socket.connect_nonblock(sockaddr) rescue Errno::EISCONN end else raise Errno::ECONNREFUSED end end return true rescue Errno::ECONNREFUSED, Errno::ENOENT return false ensure socket.close if socket end end def self.load_app port = nil tries = 0 while port.nil? && tries < 200 port = 1024 + rand(9999) if ping_port(port) \|\| ping_port(port + 1) \|\| ping_port(port + 2) port = nil tries += 1 end end if port.nil? abort "Cannot find a suitable port to start Meteor on" end production = options["environment"] == "production" ? "--production" : "" pid = fork do # Meteor is quite !@#$% here: if we kill its start script # with any signal, it'll leave a ton of garbage processes # around. Apparently it expects the user to press Ctrl-C in a # terminal which happens to send a signal to all processes # in the session. We emulate that behavior here by giving # Meteor its own process group, and sending signals to the # entire process group. Process.setpgrp if options["environment"] == "production" logger.warn("Warning: meteor running in simulated production mode (--production). For real production use, bundle your app.") end if options["meteor_app_settings"] PhusionPassenger.require_passenger_lib 'utils/shellwords' app_settings_file = Shellwords.escape(options["meteor_app_settings"]) logger.info("Using application settings from file #{app_settings_file}") exec("meteor run -p #{port} --settings #{app_settings_file} #{production}") else exec("meteor run -p #{port} #{production}") end exec("meteor run -p #{port} #{production} --settings settings.json") end if options["process_title"] && !options["process_title"].empty? rename_process "#{options["process_title"]} (#{pid})" else rename_process "#{$0} (#{pid})" end return [pid, port] end def self.wait_for_exit_message begin STDIN.readline rescue EOFError end end ################## Main code ################## init_passenger init_logging record_journey_step_end('SUBPROCESS_EXEC_WRAPPER', 'STEP_PERFORMED') record_journey_step_begin('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_IN_PROGRESS') begin read_startup_arguments rescue Exception record_journey_step_end('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_ERRORED') raise else record_journey_step_end('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_PERFORMED') end record_journey_step_begin('SUBPROCESS_APP_LOAD_OR_EXEC', 'STEP_IN_PROGRESS') begin pid, port = load_app rescue Exception record_journey_step_end('SUBPROCESS_APP_LOAD_OR_EXEC', 'STEP_ERRORED') raise else record_journey_step_end('SUBPROCESS_APP_LOAD_OR_EXEC', 'STEP_PERFORMED') end record_journey_step_begin('SUBPROCESS_LISTEN', 'STEP_IN_PROGRESS') begin while !ping_port(port) sleep 0.01 end rescue Exception record_journey_step_end('SUBPROCESS_LISTEN', 'STEP_ERRORED') raise else record_journey_step_end('SUBPROCESS_LISTEN', 'STEP_PERFORMED') end advertise_port(port) advertise_readiness begin wait_for_exit_message ensure if pid Process.kill('INT', -pid) rescue nil Process.waitpid(pid) rescue nil Process.kill('INT', -pid) rescue nil end end end # module App end # module PhusionPassenger	8.32 KB	2025-11-20 11:36
📄 node-loader.js /* * Phusion Passenger - https://www.phusionpassenger.com/ * Copyright (c) 2010-2025 Asynchronous B.V. * * "Passenger", "Phusion Passenger" and "Union Station" are registered * trademarks of Asynchronous B.V. * * 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. / module.paths.unshift(__dirname + "/../src/nodejs_supportlib"); var EventEmitter = require('events').EventEmitter; var os = require('os'); var fs = require('fs'); var http = require('http'); var util = require('util'); var nodeClusterErrCount = 0; var meteorClusterErrCount = 0; function badPackageError(packageName) { return "You required the " + packageName + ", which is incompatible with Passenger, a non-functional shim was returned and your app may still work. However, please remove the related code as soon as possible."; } // Logs failure to install shim + extended debug info, but with strict spamming protection. function errorMockingRequire(packageName, error, args, count) { if (count > 2) { return; // spam protect against repeated warnings } var msg = "Failed to install shim to guard against the " + packageName + ". Due to: " + error.message + ". Your can safely ignore this warning if you are not using " + packageName; msg += "\n\tNode version: " + process.version + "\tArguments: " + args.length; for (i = 0; i < args.length; i++) { if (i > 9) { // limit the amount of array elements we log break; } msg += "\n\t[" + i + "] " + util.inspect(args[i]).substr(0, 200); // limit the characters per array element }; console.error(msg); } //Mock out Node Cluster Module var Module = require('module'); var originalRequire = Module.prototype.require; Module.prototype.require = function() { try { if (arguments['0'] == 'cluster') { console.trace(badPackageError("Node Cluster module")); return { disconnect : function(){return false;}, fork : function(){return false;}, setupMaster : function(){return false;}, isWorker : true, isMaster : false, schedulingPolicy : false, settings : false, worker : false, workers : false, }; } } catch (e) { nodeClusterErrCount++; errorMockingRequire("Node Cluster module", e, arguments, nodeClusterErrCount); } return originalRequire.apply(this, arguments); }; //Mock out Meteor Cluster Module var vm = require('vm'); var orig_func = vm.runInThisContext; vm.runInThisContext = function() { try { if (arguments.length > 1) { var scriptPath = arguments['1']; if (typeof scriptPath == 'object') { scriptPath = scriptPath['filename']; } if (scriptPath.indexOf('meteorhacks_cluster') != -1) { console.trace(badPackageError("Meteorhacks cluster package")); return (function() { Package['meteorhacks:cluster'] = { Cluster: { _publicServices : {}, _registeredServices : {}, _discoveryBackends : { mongodb: {} }, connect : function(){return false;}, allowPublicAccess : function(){return false;}, discoverConnection : function(){return false;}, register : function(){return false;}, _isPublicService : function(){return false;}, registerDiscoveryBackend : function(){return false;}, _blockCallAgain : function(){return false;} } }; }); } } } catch (e) { meteorClusterErrCount++; errorMockingRequire("Meteorhacks Cluster package", e, arguments, meteorClusterErrCount); } return orig_func.apply(this, arguments); }; var LineReader = require('phusion_passenger/line_reader').LineReader; var instrumentModulePaths = [ 'phusion_passenger/log_express', 'phusion_passenger/log_mongodb']; var instrumentedModules = []; module.isApplicationLoader = true; // https://groups.google.com/forum/#!topic/compoundjs/4txxkNtROQg global.PhusionPassenger = exports.PhusionPassenger = new EventEmitter(); var stdinReader = new LineReader(process.stdin); recordJourneyStepEnd('SUBPROCESS_EXEC_WRAPPER', 'STEP_PERFORMED'); recordJourneyStepBegin('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_IN_PROGRESS'); var options = readStartupArguments(); setupEnvironment(options); function tryWriteFile(path, contents) { try { fs.writeFileSync(path, contents.toString()); } catch (e) { console.error('Warning: unable to write to ' + path + ': ' + e.message); } } function recordJourneyStepBegin(step, state) { var workDir = process.env['PASSENGER_SPAWN_WORK_DIR']; var stepDir = workDir + '/response/steps/' + step.toLowerCase(); tryWriteFile(stepDir + '/state', 'STEP_IN_PROGRESS'); tryWriteFile(stepDir + '/begin_time', (Date.now() / 1000).toString()); } function recordJourneyStepEnd(step, state) { var workDir = process.env['PASSENGER_SPAWN_WORK_DIR']; var stepDir = workDir + '/response/steps/' + step.toLowerCase(); tryWriteFile(stepDir + '/state', 'STEP_IN_PROGRESS'); if (!fs.existsSync(stepDir + '/begin_time') && !fs.existsSync(stepDir + '/begin_time_monotonic')) { tryWriteFile(stepDir + '/begin_time', (Date.now() / 1000).toString()); } tryWriteFile(stepDir + '/end_time', (Date.now() / 1000).toString()); } function readStartupArguments() { var workDir = process.env['PASSENGER_SPAWN_WORK_DIR']; var doc = fs.readFileSync(workDir + '/args.json'); return JSON.parse(doc); } function passengerToWinstonLogLevel(passengerLogLevel) { switch (passengerLogLevel) { case "1": return "error"; case "2": return "warn"; case "3": // notice case "4": // info return "info"; case "5": // debug return "verbose"; case "6": // debug2 return "debug"; case "7": // debug3 return "silly"; case "0": // crit default: break; } return "none"; } function setupEnvironment(options) { PhusionPassenger.options = options; PhusionPassenger.configure = configure; PhusionPassenger._appInstalled = false; var logLevel = passengerToWinstonLogLevel(PhusionPassenger.options.log_level); var winston = require("vendor-copy/winston"); var logger = new (winston.Logger)({ transports: [ new (winston.transports.Console)({ level: logLevel, debugStdout: true }) ] }); process.title = 'Passenger NodeApp: ' + options.app_root; http.Server.prototype.originalListen = http.Server.prototype.listen; http.Server.prototype.listen = installServer; stdinReader.close(); stdinReader = undefined; process.stdin.on('end', shutdown); process.stdin.resume(); recordJourneyStepEnd('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_PERFORMED'); recordJourneyStepBegin('SUBPROCESS_APP_LOAD_OR_EXEC', 'STEP_IN_PROGRESS'); loadApplication(); } /* * PhusionPassenger.configure(options) * * Configures Phusion Passenger's behavior inside this Node application. * * Options: * autoInstall (boolean, default true) * Whether to install the first HttpServer object for which listen() is called, * as the Phusion Passenger request handler. / function configure(_options) { var options = { autoInstall: true }; for (var key in _options) { options[key] = _options[key]; } if (!options.autoInstall) { http.Server.prototype.listen = listenAndMaybeInstall; } } function loadApplication() { var appRoot = PhusionPassenger.options.app_root \|\| process.cwd(); var startupFile = PhusionPassenger.options.startup_file \|\| (appRoot + '/' + 'app.js'); require(startupFile); } function extractCallback(args) { if (args.length > 1 && typeof(args[args.length - 1]) == 'function') { return args[args.length - 1]; } } function generateServerSocketPath() { var options = PhusionPassenger.options; var socketDir, socketPrefix, socketSuffix; if (options.socket_dir) { socketDir = options.socket_dir; socketPrefix = "node"; } else { socketDir = os.tmpdir().replace(/\/$/, ''); socketPrefix = "PsgNodeApp"; } socketSuffix = ((Math.random() 0xFFFFFFFF) & 0xFFFFFFF); var result = socketDir + "/" + socketPrefix + "." + socketSuffix.toString(36); var UNIX_PATH_MAX = options.UNIX_PATH_MAX \|\| 100; return result.substr(0, UNIX_PATH_MAX); } function addListenerAtBeginning(emitter, event, callback) { var listeners = emitter.listeners(event); var i; emitter.removeAllListeners(event); emitter.on(event, callback); for (i = 0; i < listeners.length; i++) { emitter.on(event, listeners[i]); } } function doListen(server, listenTries, callback) { function errorHandler(error) { if (error.errno == 'EADDRINUSE') { if (listenTries == 100) { server.emit('error', new Error( 'Phusion Passenger could not find suitable socket address to bind on')); } else { // Try again with another socket path. listenTries++; doListen(server, listenTries, callback); } } else { server.emit('error', error); } } var socketPath = PhusionPassenger.options.socket_path = generateServerSocketPath(); server.once('error', errorHandler); server.originalListen(socketPath, function() { server.removeListener('error', errorHandler); doneListening(server, callback); process.nextTick(finalizeStartup); }); } function doneListening(server, callback) { if (callback) { server.once('listening', callback); } server.emit('listening'); } function installServer() { var server = this; if (!PhusionPassenger._appInstalled) { PhusionPassenger._appInstalled = true; PhusionPassenger._server = server; recordJourneyStepEnd('SUBPROCESS_APP_LOAD_OR_EXEC', 'STEP_PERFORMED'); recordJourneyStepBegin('SUBPROCESS_LISTEN', 'STEP_IN_PROGRESS'); // Ensure that req.connection.remoteAddress and remotePort return something // instead of undefined. Apps like Etherpad expect it. // See https://github.com/phusion/passenger/issues/1224 addListenerAtBeginning(server, 'request', function(req) { req.connection.__defineGetter__('remoteAddress', function() { return '127.0.0.1'; }); req.connection.__defineGetter__('remotePort', function() { return 0; }); }); var listenTries = 0; doListen(server, listenTries, extractCallback(arguments)); return server; } else { throw new Error("http.Server.listen() was called more than once, which " + "is not allowed because Phusion Passenger is in auto-install mode. " + "This means that the first http.Server object for which listen() is called, " + "is automatically installed as the Phusion Passenger request handler. " + "If you want to create and listen on multiple http.Server object then " + "you should disable auto-install mode. Please read " + "http://stackoverflow.com/questions/20645231/phusion-passenger-error-http-server-listen-was-called-more-than-once/20645549"); } } function listenAndMaybeInstall(port) { if (port === 'passenger' \|\| port == '/passenger') { if (!PhusionPassenger._appInstalled) { return installServer.apply(this, arguments); } else { throw new Error("You may only call listen('passenger') once. Please read http://stackoverflow.com/questions/20645231/phusion-passenger-error-http-server-listen-was-called-more-than-once/20645549"); } } else { return this.originalListen.apply(this, arguments); } } function finalizeStartup() { recordJourneyStepEnd('SUBPROCESS_LISTEN', 'STEP_PERFORMED'); var workDir = process.env['PASSENGER_SPAWN_WORK_DIR']; fs.writeFileSync(workDir + '/response/properties.json', JSON.stringify({ sockets: [ { name: 'main', address: 'unix:' + PhusionPassenger.options.socket_path, protocol: 'http', concurrency: 0, accept_http_requests: true } ] })); // fs.writeFileSync() does not work on FIFO files var stream = fs.createWriteStream(workDir + '/response/finish'); stream.write('1'); stream.close(); } function shutdown() { if (PhusionPassenger.shutting_down) { return; } PhusionPassenger.shutting_down = true; try { fs.unlinkSync(PhusionPassenger.options.socket_path); } catch (e) { // Ignore error. } if (PhusionPassenger.listeners('exit').length > 0) { PhusionPassenger.emit('exit'); } else if (process.listeners('message').length > 0) { process.emit('message', 'shutdown'); } else { process.exit(0); } }	12.73 KB	2025-11-20 11:36
📄 prespawn #!/usr/bin/ruby # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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. STDOUT.sync = true STDERR.sync = true require 'uri' require 'socket' require 'timeout' require 'base64' class PrespawnLocation class InvalidURLError < RuntimeError def initialize(url) @url = url end def to_s message end def message "'#{@url}' is not a valid URL." end end def self.parse(url) uri = uri_for(url) if uri.scheme == 'unix' \|\| uri.host == 'unix' location = UNIXPrespawnLocation.new(uri) else case uri.scheme when 'http' location = TCPPrespawnLocation.new(uri) when 'https' location = SSLPrespawnLocation.new(uri) end end unless location raise InvalidURLError, url end location end def self.uri_for(url) URI.parse(url) rescue URI::InvalidURIError raise InvalidURLError, url end def initialize(uri) @uri = uri end def request_path @uri.path.empty? ? '/' : @uri.path end def request_host @uri.host end def socket @socket \|\|= connect end if Base64.respond_to?(:strict_encode64) def base64(data) Base64.strict_encode64(data) end else # Base64-encodes the given data. Newlines are removed. # This is like `Base64.strict_encode64`, but also works # on Ruby 1.8 which doesn't have that method. def base64(data) result = Base64.encode64(data) result.delete!("\n") result end end def head_request socket.write("HEAD #{request_path} HTTP/1.1\r\n") socket.write("Host: #{request_host}\r\n") socket.write("User-Agent: Passenger Prespawn Script\r\n") socket.write("Authorization: Basic " + base64(@uri.userinfo) + "\r\n") if @uri.userinfo socket.write("Connection: close\r\n") socket.write("\r\n") begin Timeout.timeout(10) do socket.read end rescue Timeout::Error end end end class TCPPrespawnLocation < PrespawnLocation def request_port @uri.port end def connect TCPSocket.new(request_host, request_port) rescue Errno::ECONNREFUSED TCPSocket.new('::1', request_port) end end class SSLPrespawnLocation < TCPPrespawnLocation def connect require 'openssl' socket = OpenSSL::SSL::SSLSocket.new(super) socket.sync_close = true socket.connect socket end end class UNIXPrespawnLocation < PrespawnLocation def request_path super.split(':', 2).last end def request_host '_' end def socket_path @uri.path.split(':', 2).first end def connect UNIXSocket.new(socket_path) end end url = ARGV[0] begin prespawn_location = PrespawnLocation.parse(url) rescue PrespawnLocation::InvalidURLError => e STDERR.puts "*** ERROR: #{e}" exit 1 end prespawn_location.head_request	3.96 KB	2025-11-20 11:36
📄 rack-loader.rb #!/usr/bin/env ruby # encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2013-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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. module PhusionPassenger module App def self.options @@options end def self.app @@app end def self.init_passenger STDOUT.sync = true STDERR.sync = true work_dir = ENV['PASSENGER_SPAWN_WORK_DIR'].to_s if work_dir.empty? abort "This program may only be invoked from Passenger (error: $PASSENGER_SPAWN_WORK_DIR not set)." end record_journey_step_end('SUBPROCESS_EXEC_WRAPPER', 'STEP_PERFORMED') record_journey_step_begin('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_IN_PROGRESS') ruby_libdir = File.read("#{work_dir}/args/ruby_libdir").strip passenger_root = File.read("#{work_dir}/args/passenger_root").strip require "#{ruby_libdir}/phusion_passenger" PhusionPassenger.locate_directories(passenger_root) PhusionPassenger.require_passenger_lib 'loader_shared_helpers' end def self.try_write_file(path, contents) begin File.open(path, 'wb') do \|f\| f.write(contents) end rescue SystemCallError => e STDERR.puts "Warning: unable to write to #{path}: #{e}" end end def self.record_journey_step_begin(step, state) dir = ENV['PASSENGER_SPAWN_WORK_DIR'] step_dir = "#{dir}/response/steps/#{step.downcase}" try_write_file("#{step_dir}/state", state) try_write_file("#{step_dir}/begin_time", Time.now.to_f) end def self.record_journey_step_end(step, state) dir = ENV['PASSENGER_SPAWN_WORK_DIR'] step_dir = "#{dir}/response/steps/#{step.downcase}" try_write_file("#{step_dir}/state", state) if !File.exist?("#{step_dir}/begin_time") && !File.exist?("#{step_dir}/begin_time_monotonic") try_write_file("#{step_dir}/begin_time", Time.now.to_f) end try_write_file("#{step_dir}/end_time", Time.now.to_f) end def self.load_app LoaderSharedHelpers.before_loading_app_code_step1('config.ru', options) LoaderSharedHelpers.run_load_path_setup_code(options) LoaderSharedHelpers.before_loading_app_code_step2(options) LoaderSharedHelpers.activate_gem 'rack' app_root = options['app_root'] rackup_file = LoaderSharedHelpers.maybe_make_path_relative_to_app_root( app_root, options['startup_file'] \|\| "#{app_root}/config.ru") rackup_code = ::File.open(rackup_file, 'rb') do \|f\| f.read end @@app = eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, rackup_file) LoaderSharedHelpers.after_loading_app_code(options) rescue Exception => e LoaderSharedHelpers.record_and_print_exception(e) LoaderSharedHelpers.about_to_abort(options, e) exit LoaderSharedHelpers.exit_code_for_exception(e) end ################## Main code ################## init_passenger @@options = LoaderSharedHelpers.init(self) LoaderSharedHelpers.record_journey_step_end('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_PERFORMED') LoaderSharedHelpers.run_block_and_record_step_progress('SUBPROCESS_APP_LOAD_OR_EXEC') do load_app end handler = nil LoaderSharedHelpers.run_block_and_record_step_progress('SUBPROCESS_LISTEN') do begin LoaderSharedHelpers.before_handling_requests(false, options) handler = RequestHandler.new(STDIN, options.merge('app' => app)) LoaderSharedHelpers.advertise_sockets(options, handler) rescue Exception => e LoaderSharedHelpers.record_and_print_exception(e) LoaderSharedHelpers.about_to_abort(options, e) exit LoaderSharedHelpers.exit_code_for_exception(e) end end LoaderSharedHelpers.advertise_readiness(options) handler.main_loop handler.cleanup LoaderSharedHelpers.after_handling_requests end # module App end # module PhusionPassenger	5.04 KB	2025-11-20 11:36
📄 rack-preloader.rb #!/usr/bin/env ruby # encoding: binary # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2013-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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. GC.copy_on_write_friendly = true if GC.respond_to?(:copy_on_write_friendly=) module PhusionPassenger module App def self.options @@options end def self.app @@app end def self.init_passenger STDOUT.sync = true STDERR.sync = true work_dir = ENV['PASSENGER_SPAWN_WORK_DIR'].to_s if work_dir.empty? abort "This program may only be invoked from Passenger (error: $PASSENGER_SPAWN_WORK_DIR not set)." end record_journey_step_end('SUBPROCESS_EXEC_WRAPPER', 'STEP_PERFORMED') record_journey_step_begin('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_IN_PROGRESS') ruby_libdir = File.read("#{work_dir}/args/ruby_libdir").strip passenger_root = File.read("#{work_dir}/args/passenger_root").strip require "#{ruby_libdir}/phusion_passenger" PhusionPassenger.locate_directories(passenger_root) PhusionPassenger.require_passenger_lib 'loader_shared_helpers' PhusionPassenger.require_passenger_lib 'preloader_shared_helpers' PhusionPassenger.require_passenger_lib 'utils/json' require 'socket' end def self.try_write_file(path, contents) begin File.open(path, 'wb') do \|f\| f.write(contents) end rescue SystemCallError => e STDERR.puts "Warning: unable to write to #{path}: #{e}" end end def self.record_journey_step_begin(step, state, work_dir = nil) dir = work_dir \|\| ENV['PASSENGER_SPAWN_WORK_DIR'] step_dir = "#{dir}/response/steps/#{step.downcase}" try_write_file("#{step_dir}/state", state) try_write_file("#{step_dir}/begin_time", Time.now.to_f) end def self.record_journey_step_end(step, state, work_dir = nil) dir = work_dir \|\| ENV['PASSENGER_SPAWN_WORK_DIR'] step_dir = "#{dir}/response/steps/#{step.downcase}" try_write_file("#{step_dir}/state", state) if !File.exist?("#{step_dir}/begin_time") && !File.exist?("#{step_dir}/begin_time_monotonic") try_write_file("#{step_dir}/begin_time", Time.now.to_f) end try_write_file("#{step_dir}/end_time", Time.now.to_f) end def self.preload_app LoaderSharedHelpers.before_loading_app_code_step1('config.ru', options) LoaderSharedHelpers.run_load_path_setup_code(options) LoaderSharedHelpers.before_loading_app_code_step2(options) LoaderSharedHelpers.activate_gem 'rack' app_root = options["app_root"] rackup_file = LoaderSharedHelpers.maybe_make_path_relative_to_app_root( app_root, options["startup_file"] \|\| "#{app_root}/config.ru") rackup_code = ::File.open(rackup_file, 'rb') do \|f\| f.read end @@app = eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, rackup_file) LoaderSharedHelpers.after_loading_app_code(options) rescue Exception => e LoaderSharedHelpers.record_and_print_exception(e) LoaderSharedHelpers.about_to_abort(options, e) exit LoaderSharedHelpers.exit_code_for_exception(e) end def self.create_server(options) if defined?(NativeSupport) unix_path_max = NativeSupport::UNIX_PATH_MAX else unix_path_max = options.fetch('UNIX_PATH_MAX', 100).to_i end if options['socket_dir'] socket_dir = options['socket_dir'] socket_prefix = "preloader" else socket_dir = Dir.tmpdir socket_prefix = "PsgPreloader" end socket_filename = nil server = nil Utils.retry_at_most(128, Errno::EADDRINUSE) do socket_filename = "#{socket_dir}/#{socket_prefix}.#{rand(0xFFFFFFFF).to_s(36)}" socket_filename = socket_filename.slice(0, unix_path_max - 10) server = UNIXServer.new(socket_filename) end server.close_on_exec! File.chmod(0600, socket_filename) [server, socket_filename] end def self.reinitialize_std_channels(work_dir) if File.exist?("#{work_dir}/stdin") STDIN.reopen("#{work_dir}/stdin", 'r') end if File.exist?("#{work_dir}/stdout_and_err") STDOUT.reopen("#{work_dir}/stdout_and_err", 'w') STDERR.reopen(STDOUT) end STDOUT.sync = STDERR.sync = true end def self.negotiate_spawn_command begin work_dir = ENV['PASSENGER_SPAWN_WORK_DIR'] @@options = File.open("#{work_dir}/args.json", 'rb') do \|f\| Utils::JSON.parse(f.read) end reinitialize_std_channels(work_dir) LoaderSharedHelpers.run_block_and_record_step_progress('SUBPROCESS_PREPARE_AFTER_FORKING_FROM_PRELOADER') do LoaderSharedHelpers.before_handling_requests(true, options) end handler = nil LoaderSharedHelpers.run_block_and_record_step_progress('SUBPROCESS_LISTEN') do handler = RequestHandler.new(STDIN, options.merge("app" => app)) end LoaderSharedHelpers.dump_all_information(options) LoaderSharedHelpers.advertise_sockets(options, handler) LoaderSharedHelpers.advertise_readiness(options) rescue Exception => e LoaderSharedHelpers.record_and_print_exception(e) LoaderSharedHelpers.about_to_abort(options, e) exit LoaderSharedHelpers.exit_code_for_exception(e) end handler end ################## Main code ################## init_passenger @@options = PreloaderSharedHelpers.init(self) LoaderSharedHelpers.record_journey_step_end('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_PERFORMED') LoaderSharedHelpers.run_block_and_record_step_progress('SUBPROCESS_APP_LOAD_OR_EXEC') do preload_app end server = nil LoaderSharedHelpers.run_block_and_record_step_progress('SUBPROCESS_LISTEN') do begin server = create_server(options) PreloaderSharedHelpers.advertise_sockets(options, server) LoaderSharedHelpers.dump_all_information(options) rescue Exception => e LoaderSharedHelpers.record_and_print_exception(e) LoaderSharedHelpers.about_to_abort(options, e) exit LoaderSharedHelpers.exit_code_for_exception(e) end end LoaderSharedHelpers.advertise_readiness(options) subprocess_work_dir = PreloaderSharedHelpers.run_main_loop(server, options) if subprocess_work_dir # Inside forked subprocess ENV['PASSENGER_SPAWN_WORK_DIR'] = subprocess_work_dir handler = negotiate_spawn_command handler.main_loop handler.cleanup LoaderSharedHelpers.after_handling_requests end end # module App end # module PhusionPassenger	7.74 KB	2025-11-20 11:36
📄 wsgi-loader.py #!/usr/bin/env python # Phusion Passenger - https://www.phusionpassenger.com/ # Copyright (c) 2010-2025 Asynchronous B.V. # # "Passenger", "Phusion Passenger" and "Union Station" are registered # trademarks of Asynchronous B.V. # # 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. import sys, os, io, threading, signal, traceback, socket, select, struct, logging, errno import tempfile, json, time if sys.version_info[0] >= 3 and sys.version_info[1] >= 5: from importlib import util else: import imp options = {} def abort(message): sys.stderr.write(message + "\n") sys.exit(1) def try_write_file(path, contents): try: with open(path, 'w') as f: f.write(contents) except IOError as e: logging.warn('Warning: unable to write to ' + path + ': ' + e.strerror) def initialize_logging(): logging.basicConfig( level = logging.WARNING, format = "[ pid=%(process)d, time=%(asctime)s ]: %(message)s") if hasattr(logging, 'captureWarnings'): logging.captureWarnings(True) def read_startup_arguments(): global options work_dir = os.getenv('PASSENGER_SPAWN_WORK_DIR') assert work_dir is not None path = work_dir + '/args.json' with io.open(path, 'r', encoding='utf-8') as f: options = json.load(f) def record_journey_step_begin(step, state): work_dir = os.getenv('PASSENGER_SPAWN_WORK_DIR') assert work_dir is not None step_dir = work_dir + '/response/steps/' + step.lower() try_write_file(step_dir + '/state', state) try_write_file(step_dir + '/begin_time', str(time.time())) def record_journey_step_end(step, state): work_dir = os.getenv('PASSENGER_SPAWN_WORK_DIR') assert work_dir is not None step_dir = work_dir + '/response/steps/' + step.lower() try_write_file(step_dir + '/state', state) if not os.path.exists(step_dir + '/begin_time') and not os.path.exists(step_dir + '/begin_time_monotonic'): try_write_file(step_dir + '/begin_time', str(time.time())) try_write_file(step_dir + '/end_time', str(time.time())) def load_app(): global options sys.path.insert(0, os.getcwd()) startup_file = options.get('startup_file', 'passenger_wsgi.py') if sys.version_info[0] >= 3 and sys.version_info[1] >= 5: spec = util.spec_from_file_location("passenger_wsgi", startup_file) assert spec is not None app_module = util.module_from_spec(spec) assert spec.loader is not None spec.loader.exec_module(app_module) return app_module else: return imp.load_source('passenger_wsgi', startup_file) def create_server_socket(): global options UNIX_PATH_MAX = int(options.get('UNIX_PATH_MAX', 100)) if 'socket_dir' in options: socket_dir = options['socket_dir'] socket_prefix = 'wsgi' else: socket_dir = tempfile.gettempdir() socket_prefix = 'PsgWsgiApp' i = 0 while i < 128: try: return make_socket(socket_dir, socket_prefix, UNIX_PATH_MAX) except socket.error as e: if e.errno == errno.EADDRINUSE: i += 1 if i == 128: raise e else: raise e def make_socket(socket_dir, socket_prefix, UNIX_PATH_MAX): s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) socket_suffix = format(struct.unpack('Q', os.urandom(8))[0], 'x') filename = socket_dir + '/' + socket_prefix + '.' + socket_suffix filename = filename[0:UNIX_PATH_MAX] s.bind(filename) s.listen(1000) return (filename, s) def install_signal_handlers(): def debug(sig, frame): id2name = dict([(th.ident, th.name) for th in threading.enumerate()]) code = [] for thread_id, stack in sys._current_frames().items(): code.append("\n# Thread: %s(%d)" % (id2name.get(thread_id,""), thread_id)) for filename, lineno, name, line in traceback.extract_stack(stack): code.append(' File: "%s", line %d, in %s' % (filename, lineno, name)) if line: code.append(" %s" % (line.strip())) print("\n".join(code)) def debug_and_exit(sig, frame): debug(sig, frame) sys.exit(1) # Unfortunately, there's no way to install a signal handler that prints # the backtrace without interrupting the current system call. os.siginterrupt() # doesn't seem to work properly either. That is why we only have a SIGABRT # handler and no SIGQUIT handler. signal.signal(signal.SIGABRT, debug_and_exit) def advertise_sockets(socket_filename): work_dir = os.getenv('PASSENGER_SPAWN_WORK_DIR') assert work_dir is not None path = work_dir + '/response/properties.json' doc = { 'sockets': [ { 'name': 'main', 'address': 'unix:' + socket_filename, 'protocol': 'session', 'concurrency': 1, 'accept_http_requests': True } ] } with open(path, 'w') as f: json.dump(doc, f) def advertise_readiness(): work_dir = os.getenv('PASSENGER_SPAWN_WORK_DIR') assert work_dir is not None path = work_dir + '/response/finish' with open(path, 'w') as f: f.write('1') if sys.version_info[0] >= 3: def reraise_exception(exc_info): raise exc_info[0].with_traceback(exc_info[1], exc_info[2]) def bytes_to_str(b): return b.decode('latin-1') def str_to_bytes(s): if isinstance(s, bytes): return s else: return s.encode('latin-1') else: def reraise_exception(exc_info): exec("raise exc_info[0], exc_info[1], exc_info[2]") def bytes_to_str(b): return b def str_to_bytes(s): return s class RequestHandler: def __init__(self, server_socket, owner_pipe, app): self.server = server_socket self.owner_pipe = owner_pipe self.app = app def main_loop(self): done = False try: while not done: client, address = self.accept_connection() if not client: done = True break socket_hijacked = False try: try: env, input_stream = self.parse_request(client) if env: if env['REQUEST_METHOD'] == 'ping': self.process_ping(client) else: socket_hijacked = self.process_request(env, input_stream, client) except KeyboardInterrupt: done = True except IOError as e: if not getattr(e, 'passenger', False) or e.errno != errno.EPIPE: logging.exception("WSGI application raised an I/O exception!") except Exception: logging.exception("WSGI application raised an exception!") finally: if not socket_hijacked: try: # Shutdown the socket like this just in case the app # spawned a child process that keeps it open. client.shutdown(socket.SHUT_WR) except: pass try: client.close() except: pass except KeyboardInterrupt: pass def accept_connection(self): result = select.select([self.owner_pipe, self.server.fileno()], [], [])[0] if self.server.fileno() in result: return self.server.accept() else: return (None, None) def parse_request(self, client): buf = b'' while len(buf) < 4: tmp = client.recv(4 - len(buf)) if len(tmp) == 0: return (None, None) buf += tmp header_size = struct.unpack('>I', buf)[0] buf = b'' while len(buf) < header_size: tmp = client.recv(header_size - len(buf)) if len(tmp) == 0: return (None, None) buf += tmp headers = buf.split(b"\0") headers.pop() # Remove trailing "\0" env = {} i = 0 while i < len(headers): env[bytes_to_str(headers[i])] = bytes_to_str(headers[i + 1]) i += 2 return (env, client) if hasattr(socket, '_fileobject'): def wrap_input_socket(self, sock): return socket._fileobject(sock, 'rb', 512) else: def wrap_input_socket(self, sock): return socket.socket.makefile(sock, 'rb', 512) def process_request(self, env, input_stream, output_stream): # The WSGI specification says that the input parameter object passed needs to # implement a few file-like methods. This is the reason why we "wrap" the socket._socket # into the _fileobject to solve this. # # Otherwise, the POST data won't be correctly retrieved by Django. # # See: http://www.python.org/dev/peps/pep-0333/#input-and-error-streams env['wsgi.input'] = self.wrap_input_socket(input_stream) env['wsgi.errors'] = sys.stderr env['wsgi.version'] = (1, 0) env['wsgi.multithread'] = False env['wsgi.multiprocess'] = True env['wsgi.run_once'] = False if env.get('HTTPS','off') in ('on', '1', 'true', 'yes'): env['wsgi.url_scheme'] = 'https' else: env['wsgi.url_scheme'] = 'http' headers_set = [] headers_sent = [] is_head = env['REQUEST_METHOD'] == 'HEAD' def write(data): try: if not headers_set: raise AssertionError("write() before start_response()") elif not headers_sent: # Before the first output, send the stored headers. status, response_headers = headers_sent[:] = headers_set output_stream.sendall(str_to_bytes( 'HTTP/1.1 %s\r\nStatus: %s\r\nConnection: close\r\n' % (status, status))) for header in response_headers: output_stream.sendall(str_to_bytes('%s: %s\r\n' % header)) output_stream.sendall(b'\r\n') if not is_head: output_stream.sendall(str_to_bytes(data)) except IOError as e: # Mark this exception as coming from the Phusion Passenger # socket and not some other socket. setattr(e, 'passenger', True) raise e def start_response(status, response_headers, exc_info = None): if exc_info: try: if headers_sent: # Re-raise original exception if headers sent. reraise_exception(exc_info) finally: # Avoid dangling circular ref. exc_info = None elif headers_set: raise AssertionError("Headers already set!") headers_set[:] = [status, response_headers] return write # Django's django.template.base module goes through all WSGI # environment values, and calls each value that is a callable. # No idea why, but we work around that with the `do_it` parameter. def hijack(do_it = False): if do_it: env['passenger.hijacked_socket'] = output_stream return output_stream env['passenger.hijack'] = hijack result = self.app(env, start_response) if 'passenger.hijacked_socket' in env: # Socket connection hijacked. Don't do anything. return True try: for data in result: # Don't send headers until body appears. if data: write(data) if not headers_sent: # Send headers now if body was empty. write(b'') finally: if hasattr(result, 'close'): result.close() return False def process_ping(self, output_stream): output_stream.sendall(b"pong") if __name__ == "__main__": initialize_logging() record_journey_step_end('SUBPROCESS_EXEC_WRAPPER', 'STEP_PERFORMED') record_journey_step_begin('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_IN_PROGRESS') try: read_startup_arguments() except Exception: record_journey_step_end('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_ERRORED') raise else: record_journey_step_end('SUBPROCESS_WRAPPER_PREPARATION', 'STEP_PERFORMED') record_journey_step_begin('SUBPROCESS_APP_LOAD_OR_EXEC', 'STEP_IN_PROGRESS') try: app_module = load_app() except Exception: record_journey_step_end('SUBPROCESS_APP_LOAD_OR_EXEC', 'STEP_ERRORED') raise else: record_journey_step_end('SUBPROCESS_APP_LOAD_OR_EXEC', 'STEP_PERFORMED') record_journey_step_begin('SUBPROCESS_LISTEN', 'STEP_IN_PROGRESS') try: tuple = create_server_socket() assert tuple is not None socket_filename, server_socket = tuple install_signal_handlers() handler = RequestHandler(server_socket, sys.stdin, app_module.application) advertise_sockets(socket_filename) except Exception: record_journey_step_end('SUBPROCESS_LISTEN', 'STEP_ERRORED') raise else: record_journey_step_end('SUBPROCESS_LISTEN', 'STEP_PERFORMED') advertise_readiness() handler.main_loop() try: os.remove(socket_filename) except OSError: pass	12.32 KB	2025-11-20 11:36

Terminal