Current File : //proc/thread-self/root/opt/cpanel/ea-ruby27/root/usr/share/passenger/helper-scripts/wsgi-loader.py
#!/usr/bin/python2
# Phusion Passenger - https://www.phusionpassenger.com/
# Copyright (c) 2010-2017 Phusion Holding B.V.
#
# "Passenger", "Phusion Passenger" and "Union Station" are registered
# trademarks of Phusion Holding 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, 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 open(path, 'r') 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
Mini Shell